1 #include "precompiled.h" 2 // 3 // Copyright (c) 2013 The ANGLE Project Authors. All rights reserved. 4 // Use of this source code is governed by a BSD-style license that can be 5 // found in the LICENSE file. 6 // 7 8 // formatutils9.cpp: Queries for GL image formats and their translations to D3D9 9 // formats. 10 11 #include "libGLESv2/renderer/d3d9/formatutils9.h" 12 #include "libGLESv2/renderer/d3d9/Renderer9.h" 13 #include "libGLESv2/renderer/generatemip.h" 14 #include "libGLESv2/renderer/loadimage.h" 15 #include "libGLESv2/renderer/copyimage.h" 16 #include "libGLESv2/renderer/vertexconversion.h" 17 18 namespace rx 19 { 20 21 // Each GL internal format corresponds to one D3D format and data loading function. 22 // Due to not all formats being available all the time, some of the function/format types are wrapped 23 // in templates that perform format support queries on a Renderer9 object which is supplied 24 // when requesting the function or format. 25 26 typedef bool ((Renderer9::*Renderer9FormatCheckFunction)(void) const); 27 typedef LoadImageFunction (*RendererCheckLoadFunction)(const Renderer9 *renderer); 28 29 template <Renderer9FormatCheckFunction pred, LoadImageFunction prefered, LoadImageFunction fallback> 30 LoadImageFunction RendererCheckLoad(const Renderer9 *renderer) 31 { 32 return ((renderer->*pred)()) ? prefered : fallback; 33 } 34 35 template <LoadImageFunction loadFunc> 36 LoadImageFunction SimpleLoad(const Renderer9 *renderer) 37 { 38 return loadFunc; 39 } 40 41 LoadImageFunction UnreachableLoad(const Renderer9 *renderer) 42 { 43 UNREACHABLE(); 44 return NULL; 45 } 46 47 typedef bool (*FallbackPredicateFunction)(void); 48 49 template <FallbackPredicateFunction pred, LoadImageFunction prefered, LoadImageFunction fallback> 50 LoadImageFunction FallbackLoadFunction(const Renderer9 *renderer) 51 { 52 return pred() ? prefered : fallback; 53 } 54 55 typedef D3DFORMAT (*FormatQueryFunction)(const rx::Renderer9 *renderer); 56 57 template <Renderer9FormatCheckFunction pred, D3DFORMAT prefered, D3DFORMAT fallback> 58 D3DFORMAT CheckFormatSupport(const rx::Renderer9 *renderer) 59 { 60 return (renderer->*pred)() ? prefered : fallback; 61 } 62 63 template <D3DFORMAT format> 64 D3DFORMAT D3D9Format(const rx::Renderer9 *renderer) 65 { 66 return format; 67 } 68 69 struct D3D9FormatInfo 70 { 71 FormatQueryFunction mTexFormat; 72 FormatQueryFunction mRenderFormat; 73 RendererCheckLoadFunction mLoadFunction; 74 75 D3D9FormatInfo() 76 : mTexFormat(NULL), mRenderFormat(NULL), mLoadFunction(NULL) 77 { } 78 79 D3D9FormatInfo(FormatQueryFunction textureFormat, FormatQueryFunction renderFormat, RendererCheckLoadFunction loadFunc) 80 : mTexFormat(textureFormat), mRenderFormat(renderFormat), mLoadFunction(loadFunc) 81 { } 82 }; 83 84 const D3DFORMAT D3DFMT_INTZ = ((D3DFORMAT)(MAKEFOURCC('I','N','T','Z'))); 85 const D3DFORMAT D3DFMT_NULL = ((D3DFORMAT)(MAKEFOURCC('N','U','L','L'))); 86 87 typedef std::pair<GLenum, D3D9FormatInfo> D3D9FormatPair; 88 typedef std::map<GLenum, D3D9FormatInfo> D3D9FormatMap; 89 90 static D3D9FormatMap BuildD3D9FormatMap() 91 { 92 D3D9FormatMap map; 93 94 // | Internal format | Texture format | Render format | Load function | 95 map.insert(D3D9FormatPair(GL_NONE, D3D9FormatInfo(D3D9Format<D3DFMT_NULL>, D3D9Format<D3DFMT_NULL>, UnreachableLoad ))); 96 97 map.insert(D3D9FormatPair(GL_DEPTH_COMPONENT16, D3D9FormatInfo(D3D9Format<D3DFMT_INTZ>, D3D9Format<D3DFMT_D24S8>, UnreachableLoad ))); 98 map.insert(D3D9FormatPair(GL_DEPTH_COMPONENT32_OES, D3D9FormatInfo(D3D9Format<D3DFMT_INTZ>, D3D9Format<D3DFMT_D32>, UnreachableLoad ))); 99 map.insert(D3D9FormatPair(GL_DEPTH24_STENCIL8_OES, D3D9FormatInfo(D3D9Format<D3DFMT_INTZ>, D3D9Format<D3DFMT_D24S8>, UnreachableLoad ))); 100 map.insert(D3D9FormatPair(GL_STENCIL_INDEX8, D3D9FormatInfo(D3D9Format<D3DFMT_UNKNOWN>, D3D9Format<D3DFMT_D24S8>, UnreachableLoad ))); // TODO: What's the texture format? 101 102 map.insert(D3D9FormatPair(GL_RGBA32F_EXT, D3D9FormatInfo(D3D9Format<D3DFMT_A32B32G32R32F>, D3D9Format<D3DFMT_A32B32G32R32F>, SimpleLoad<loadToNative<GLfloat, 4> > ))); 103 map.insert(D3D9FormatPair(GL_RGB32F_EXT, D3D9FormatInfo(D3D9Format<D3DFMT_A32B32G32R32F>, D3D9Format<D3DFMT_A32B32G32R32F>, SimpleLoad<loadToNative3To4<GLfloat, gl::Float32One> >))); 104 map.insert(D3D9FormatPair(GL_RG32F_EXT, D3D9FormatInfo(D3D9Format<D3DFMT_G32R32F>, D3D9Format<D3DFMT_G32R32F>, SimpleLoad<loadToNative<GLfloat, 2> > ))); 105 map.insert(D3D9FormatPair(GL_R32F_EXT, D3D9FormatInfo(D3D9Format<D3DFMT_R32F>, D3D9Format<D3DFMT_R32F>, SimpleLoad<loadToNative<GLfloat, 1> > ))); 106 map.insert(D3D9FormatPair(GL_ALPHA32F_EXT, D3D9FormatInfo(D3D9Format<D3DFMT_A32B32G32R32F>, D3D9Format<D3DFMT_UNKNOWN>, SimpleLoad<loadAlphaFloatDataToRGBA> ))); 107 map.insert(D3D9FormatPair(GL_LUMINANCE32F_EXT, D3D9FormatInfo(D3D9Format<D3DFMT_A32B32G32R32F>, D3D9Format<D3DFMT_UNKNOWN>, SimpleLoad<loadLuminanceFloatDataToRGBA> ))); 108 map.insert(D3D9FormatPair(GL_LUMINANCE_ALPHA32F_EXT, D3D9FormatInfo(D3D9Format<D3DFMT_A32B32G32R32F>, D3D9Format<D3DFMT_UNKNOWN>, SimpleLoad<loadLuminanceAlphaFloatDataToRGBA> ))); 109 110 map.insert(D3D9FormatPair(GL_RGBA16F_EXT, D3D9FormatInfo(D3D9Format<D3DFMT_A16B16G16R16F>, D3D9Format<D3DFMT_A16B16G16R16F>, SimpleLoad<loadToNative<GLhalf, 4> > ))); 111 map.insert(D3D9FormatPair(GL_RGB16F_EXT, D3D9FormatInfo(D3D9Format<D3DFMT_A16B16G16R16F>, D3D9Format<D3DFMT_A16B16G16R16F>, SimpleLoad<loadToNative3To4<GLhalf, gl::Float16One> >))); 112 map.insert(D3D9FormatPair(GL_RG16F_EXT, D3D9FormatInfo(D3D9Format<D3DFMT_G16R16F>, D3D9Format<D3DFMT_G16R16F>, SimpleLoad<loadToNative<GLhalf, 2> > ))); 113 map.insert(D3D9FormatPair(GL_R16F_EXT, D3D9FormatInfo(D3D9Format<D3DFMT_R16F>, D3D9Format<D3DFMT_R16F>, SimpleLoad<loadToNative<GLhalf, 1> > ))); 114 map.insert(D3D9FormatPair(GL_ALPHA16F_EXT, D3D9FormatInfo(D3D9Format<D3DFMT_A16B16G16R16F>, D3D9Format<D3DFMT_UNKNOWN>, SimpleLoad<loadAlphaHalfFloatDataToRGBA> ))); 115 map.insert(D3D9FormatPair(GL_LUMINANCE16F_EXT, D3D9FormatInfo(D3D9Format<D3DFMT_A16B16G16R16F>, D3D9Format<D3DFMT_UNKNOWN>, SimpleLoad<loadLuminanceHalfFloatDataToRGBA> ))); 116 map.insert(D3D9FormatPair(GL_LUMINANCE_ALPHA16F_EXT, D3D9FormatInfo(D3D9Format<D3DFMT_A16B16G16R16F>, D3D9Format<D3DFMT_UNKNOWN>, SimpleLoad<loadLuminanceAlphaHalfFloatDataToRGBA>))); 117 118 map.insert(D3D9FormatPair(GL_ALPHA8_EXT, D3D9FormatInfo(D3D9Format<D3DFMT_A8R8G8B8>, D3D9Format<D3DFMT_A8R8G8B8>, FallbackLoadFunction<gl::supportsSSE2, loadAlphaDataToBGRASSE2, loadAlphaDataToBGRA>))); 119 120 map.insert(D3D9FormatPair(GL_RGB8_OES, D3D9FormatInfo(D3D9Format<D3DFMT_X8R8G8B8>, D3D9Format<D3DFMT_X8R8G8B8>, SimpleLoad<loadRGBUByteDataToBGRX> ))); 121 map.insert(D3D9FormatPair(GL_RGB565, D3D9FormatInfo(CheckFormatSupport<&Renderer9::getRGB565TextureSupport, D3DFMT_R5G6B5, D3DFMT_X8R8G8B8>, CheckFormatSupport<&Renderer9::getRGB565TextureSupport, D3DFMT_R5G6B5, D3DFMT_X8R8G8B8>, RendererCheckLoad<&Renderer9::getRGB565TextureSupport, loadToNative<GLushort, 1>, loadRGB565DataToBGRA>))); 122 map.insert(D3D9FormatPair(GL_RGBA8_OES, D3D9FormatInfo(D3D9Format<D3DFMT_A8R8G8B8>, D3D9Format<D3DFMT_A8R8G8B8>, FallbackLoadFunction<gl::supportsSSE2, loadRGBAUByteDataToBGRASSE2, loadRGBAUByteDataToBGRA>))); 123 map.insert(D3D9FormatPair(GL_RGBA4, D3D9FormatInfo(D3D9Format<D3DFMT_A8R8G8B8>, D3D9Format<D3DFMT_A8R8G8B8>, SimpleLoad<loadRGBA4444DataToBGRA> ))); 124 map.insert(D3D9FormatPair(GL_RGB5_A1, D3D9FormatInfo(D3D9Format<D3DFMT_A8R8G8B8>, D3D9Format<D3DFMT_A8R8G8B8>, SimpleLoad<loadRGBA5551DataToBGRA> ))); 125 map.insert(D3D9FormatPair(GL_R8_EXT, D3D9FormatInfo(D3D9Format<D3DFMT_X8R8G8B8>, D3D9Format<D3DFMT_X8R8G8B8>, SimpleLoad<loadRUByteDataToBGRX> ))); 126 map.insert(D3D9FormatPair(GL_RG8_EXT, D3D9FormatInfo(D3D9Format<D3DFMT_X8R8G8B8>, D3D9Format<D3DFMT_X8R8G8B8>, SimpleLoad<loadRGUByteDataToBGRX> ))); 127 128 map.insert(D3D9FormatPair(GL_BGRA8_EXT, D3D9FormatInfo(D3D9Format<D3DFMT_A8R8G8B8>, D3D9Format<D3DFMT_A8R8G8B8>, SimpleLoad<loadToNative<GLubyte, 4> > ))); 129 map.insert(D3D9FormatPair(GL_BGRA4_ANGLEX, D3D9FormatInfo(D3D9Format<D3DFMT_A8R8G8B8>, D3D9Format<D3DFMT_A8R8G8B8>, SimpleLoad<loadRGBA4444DataToRGBA> ))); 130 map.insert(D3D9FormatPair(GL_BGR5_A1_ANGLEX, D3D9FormatInfo(D3D9Format<D3DFMT_A8R8G8B8>, D3D9Format<D3DFMT_A8R8G8B8>, SimpleLoad<loadRGBA5551DataToRGBA> ))); 131 132 map.insert(D3D9FormatPair(GL_COMPRESSED_RGB_S3TC_DXT1_EXT, D3D9FormatInfo(D3D9Format<D3DFMT_DXT1>, D3D9Format<D3DFMT_UNKNOWN>, SimpleLoad<loadCompressedBlockDataToNative<4, 4, 8> >))); 133 map.insert(D3D9FormatPair(GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, D3D9FormatInfo(D3D9Format<D3DFMT_DXT1>, D3D9Format<D3DFMT_UNKNOWN>, SimpleLoad<loadCompressedBlockDataToNative<4, 4, 8> >))); 134 map.insert(D3D9FormatPair(GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE, D3D9FormatInfo(D3D9Format<D3DFMT_DXT3>, D3D9Format<D3DFMT_UNKNOWN>, SimpleLoad<loadCompressedBlockDataToNative<4, 4, 16> >))); 135 map.insert(D3D9FormatPair(GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE, D3D9FormatInfo(D3D9Format<D3DFMT_DXT5>, D3D9Format<D3DFMT_UNKNOWN>, SimpleLoad<loadCompressedBlockDataToNative<4, 4, 16> >))); 136 137 // These formats require checking if the renderer supports D3DFMT_L8 or D3DFMT_A8L8 and 138 // then changing the format and loading function appropriately. 139 map.insert(D3D9FormatPair(GL_LUMINANCE8_EXT, D3D9FormatInfo(CheckFormatSupport<&Renderer9::getLuminanceTextureSupport, D3DFMT_L8, D3DFMT_A8R8G8B8>, D3D9Format<D3DFMT_UNKNOWN>, RendererCheckLoad<&Renderer9::getLuminanceTextureSupport, loadToNative<GLubyte, 1>, loadLuminanceDataToBGRA>))); 140 map.insert(D3D9FormatPair(GL_LUMINANCE8_ALPHA8_EXT, D3D9FormatInfo(CheckFormatSupport<&Renderer9::getLuminanceAlphaTextureSupport, D3DFMT_A8L8, D3DFMT_A8R8G8B8>, D3D9Format<D3DFMT_UNKNOWN>, RendererCheckLoad<&Renderer9::getLuminanceTextureSupport, loadToNative<GLubyte, 2>, loadLuminanceAlphaDataToBGRA>))); 141 142 return map; 143 } 144 145 static bool GetD3D9FormatInfo(GLenum internalFormat, D3D9FormatInfo *outFormatInfo) 146 { 147 static const D3D9FormatMap formatMap = BuildD3D9FormatMap(); 148 D3D9FormatMap::const_iterator iter = formatMap.find(internalFormat); 149 if (iter != formatMap.end()) 150 { 151 if (outFormatInfo) 152 { 153 *outFormatInfo = iter->second; 154 } 155 return true; 156 } 157 else 158 { 159 return false; 160 } 161 } 162 163 // A map to determine the pixel size and mip generation function of a given D3D format 164 struct D3DFormatInfo 165 { 166 GLuint mPixelBits; 167 GLuint mBlockWidth; 168 GLuint mBlockHeight; 169 GLenum mInternalFormat; 170 171 MipGenerationFunction mMipGenerationFunction; 172 ColorReadFunction mColorReadFunction; 173 174 D3DFormatInfo() 175 : mPixelBits(0), mBlockWidth(0), mBlockHeight(0), mInternalFormat(GL_NONE), mMipGenerationFunction(NULL), 176 mColorReadFunction(NULL) 177 { } 178 179 D3DFormatInfo(GLuint pixelBits, GLuint blockWidth, GLuint blockHeight, GLenum internalFormat, 180 MipGenerationFunction mipFunc, ColorReadFunction readFunc) 181 : mPixelBits(pixelBits), mBlockWidth(blockWidth), mBlockHeight(blockHeight), mInternalFormat(internalFormat), 182 mMipGenerationFunction(mipFunc), mColorReadFunction(readFunc) 183 { } 184 }; 185 186 typedef std::pair<D3DFORMAT, D3DFormatInfo> D3D9FormatInfoPair; 187 typedef std::map<D3DFORMAT, D3DFormatInfo> D3D9FormatInfoMap; 188 189 static D3D9FormatInfoMap BuildD3D9FormatInfoMap() 190 { 191 D3D9FormatInfoMap map; 192 193 // | D3DFORMAT | | S |W |H | Internal format | Mip generation function | Color read function | 194 map.insert(D3D9FormatInfoPair(D3DFMT_NULL, D3DFormatInfo( 0, 0, 0, GL_NONE, NULL, NULL ))); 195 map.insert(D3D9FormatInfoPair(D3DFMT_UNKNOWN, D3DFormatInfo( 0, 0, 0, GL_NONE, NULL, NULL ))); 196 197 map.insert(D3D9FormatInfoPair(D3DFMT_L8, D3DFormatInfo( 8, 1, 1, GL_LUMINANCE8_EXT, GenerateMip<L8>, ReadColor<L8, GLfloat> ))); 198 map.insert(D3D9FormatInfoPair(D3DFMT_A8, D3DFormatInfo( 8, 1, 1, GL_ALPHA8_EXT, GenerateMip<A8>, ReadColor<A8, GLfloat> ))); 199 map.insert(D3D9FormatInfoPair(D3DFMT_A8L8, D3DFormatInfo( 16, 1, 1, GL_LUMINANCE8_ALPHA8_EXT, GenerateMip<A8L8>, ReadColor<A8L8, GLfloat> ))); 200 map.insert(D3D9FormatInfoPair(D3DFMT_A4R4G4B4, D3DFormatInfo( 16, 1, 1, GL_BGRA4_ANGLEX, GenerateMip<B4G4R4A4>, ReadColor<B4G4R4A4, GLfloat> ))); 201 map.insert(D3D9FormatInfoPair(D3DFMT_A1R5G5B5, D3DFormatInfo( 16, 1, 1, GL_BGR5_A1_ANGLEX, GenerateMip<B5G5R5A1>, ReadColor<B5G5R5A1, GLfloat> ))); 202 map.insert(D3D9FormatInfoPair(D3DFMT_R5G6B5, D3DFormatInfo( 16, 1, 1, GL_RGB565, GenerateMip<R5G6B5>, ReadColor<R5G6B5, GLfloat> ))); 203 map.insert(D3D9FormatInfoPair(D3DFMT_X8R8G8B8, D3DFormatInfo( 32, 1, 1, GL_BGRA8_EXT, GenerateMip<B8G8R8X8>, ReadColor<B8G8R8X8, GLfloat> ))); 204 map.insert(D3D9FormatInfoPair(D3DFMT_A8R8G8B8, D3DFormatInfo( 32, 1, 1, GL_BGRA8_EXT, GenerateMip<B8G8R8A8>, ReadColor<B8G8R8A8, GLfloat> ))); 205 map.insert(D3D9FormatInfoPair(D3DFMT_R16F, D3DFormatInfo( 16, 1, 1, GL_R16F_EXT, GenerateMip<R16F>, ReadColor<R16F, GLfloat> ))); 206 map.insert(D3D9FormatInfoPair(D3DFMT_G16R16F, D3DFormatInfo( 32, 1, 1, GL_RG16F_EXT, GenerateMip<R16G16F>, ReadColor<R16G16F, GLfloat> ))); 207 map.insert(D3D9FormatInfoPair(D3DFMT_A16B16G16R16F, D3DFormatInfo( 64, 1, 1, GL_RGBA16F_EXT, GenerateMip<R16G16B16A16F>, ReadColor<R16G16B16A16F, GLfloat>))); 208 map.insert(D3D9FormatInfoPair(D3DFMT_R32F, D3DFormatInfo( 32, 1, 1, GL_R32F_EXT, GenerateMip<R32F>, ReadColor<R32F, GLfloat> ))); 209 map.insert(D3D9FormatInfoPair(D3DFMT_G32R32F, D3DFormatInfo( 64, 1, 1, GL_RG32F_EXT, GenerateMip<R32G32F>, ReadColor<R32G32F, GLfloat> ))); 210 map.insert(D3D9FormatInfoPair(D3DFMT_A32B32G32R32F, D3DFormatInfo(128, 1, 1, GL_RGBA32F_EXT, GenerateMip<R32G32B32A32F>, ReadColor<R32G32B32A32F, GLfloat>))); 211 212 map.insert(D3D9FormatInfoPair(D3DFMT_D16, D3DFormatInfo( 16, 1, 1, GL_DEPTH_COMPONENT16, NULL, NULL ))); 213 map.insert(D3D9FormatInfoPair(D3DFMT_D24S8, D3DFormatInfo( 32, 1, 1, GL_DEPTH24_STENCIL8_OES, NULL, NULL ))); 214 map.insert(D3D9FormatInfoPair(D3DFMT_D24X8, D3DFormatInfo( 32, 1, 1, GL_DEPTH_COMPONENT16, NULL, NULL ))); 215 map.insert(D3D9FormatInfoPair(D3DFMT_D32, D3DFormatInfo( 32, 1, 1, GL_DEPTH_COMPONENT32_OES, NULL, NULL ))); 216 217 map.insert(D3D9FormatInfoPair(D3DFMT_INTZ, D3DFormatInfo( 32, 1, 1, GL_DEPTH24_STENCIL8_OES, NULL, NULL ))); 218 219 map.insert(D3D9FormatInfoPair(D3DFMT_DXT1, D3DFormatInfo( 64, 4, 4, GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, NULL, NULL ))); 220 map.insert(D3D9FormatInfoPair(D3DFMT_DXT3, D3DFormatInfo(128, 4, 4, GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE, NULL, NULL ))); 221 map.insert(D3D9FormatInfoPair(D3DFMT_DXT5, D3DFormatInfo(128, 4, 4, GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE, NULL, NULL ))); 222 223 return map; 224 } 225 226 static const D3D9FormatInfoMap &GetD3D9FormatInfoMap() 227 { 228 static const D3D9FormatInfoMap infoMap = BuildD3D9FormatInfoMap(); 229 return infoMap; 230 } 231 232 static bool GetD3D9FormatInfo(D3DFORMAT format, D3DFormatInfo *outFormatInfo) 233 { 234 const D3D9FormatInfoMap &infoMap = GetD3D9FormatInfoMap(); 235 D3D9FormatInfoMap::const_iterator iter = infoMap.find(format); 236 if (iter != infoMap.end()) 237 { 238 if (outFormatInfo) 239 { 240 *outFormatInfo = iter->second; 241 } 242 return true; 243 } 244 else 245 { 246 return false; 247 } 248 } 249 static d3d9::D3DFormatSet BuildAllD3DFormatSet() 250 { 251 d3d9::D3DFormatSet set; 252 253 const D3D9FormatInfoMap &infoMap = GetD3D9FormatInfoMap(); 254 for (D3D9FormatInfoMap::const_iterator i = infoMap.begin(); i != infoMap.end(); ++i) 255 { 256 set.insert(i->first); 257 } 258 259 return set; 260 } 261 262 struct D3D9FastCopyFormat 263 { 264 D3DFORMAT mSourceFormat; 265 GLenum mDestFormat; 266 GLenum mDestType; 267 268 D3D9FastCopyFormat(D3DFORMAT sourceFormat, GLenum destFormat, GLenum destType) 269 : mSourceFormat(sourceFormat), mDestFormat(destFormat), mDestType(destType) 270 { } 271 272 bool operator<(const D3D9FastCopyFormat& other) const 273 { 274 return memcmp(this, &other, sizeof(D3D9FastCopyFormat)) < 0; 275 } 276 }; 277 278 typedef std::map<D3D9FastCopyFormat, ColorCopyFunction> D3D9FastCopyMap; 279 typedef std::pair<D3D9FastCopyFormat, ColorCopyFunction> D3D9FastCopyPair; 280 281 static D3D9FastCopyMap BuildFastCopyMap() 282 { 283 D3D9FastCopyMap map; 284 285 map.insert(D3D9FastCopyPair(D3D9FastCopyFormat(D3DFMT_A8R8G8B8, GL_RGBA, GL_UNSIGNED_BYTE), CopyBGRAUByteToRGBAUByte)); 286 287 return map; 288 } 289 290 typedef std::pair<GLint, InitializeTextureDataFunction> InternalFormatInitialzerPair; 291 typedef std::map<GLint, InitializeTextureDataFunction> InternalFormatInitialzerMap; 292 293 static InternalFormatInitialzerMap BuildInternalFormatInitialzerMap() 294 { 295 InternalFormatInitialzerMap map; 296 297 map.insert(InternalFormatInitialzerPair(GL_RGB16F, initialize4ComponentData<GLhalf, 0x0000, 0x0000, 0x0000, gl::Float16One>)); 298 map.insert(InternalFormatInitialzerPair(GL_RGB32F, initialize4ComponentData<GLfloat, 0x00000000, 0x00000000, 0x00000000, gl::Float32One>)); 299 300 return map; 301 } 302 303 static const InternalFormatInitialzerMap &GetInternalFormatInitialzerMap() 304 { 305 static const InternalFormatInitialzerMap map = BuildInternalFormatInitialzerMap(); 306 return map; 307 } 308 309 namespace d3d9 310 { 311 312 MipGenerationFunction GetMipGenerationFunction(D3DFORMAT format) 313 { 314 D3DFormatInfo d3dFormatInfo; 315 if (GetD3D9FormatInfo(format, &d3dFormatInfo)) 316 { 317 return d3dFormatInfo.mMipGenerationFunction; 318 } 319 else 320 { 321 UNREACHABLE(); 322 return NULL; 323 } 324 } 325 326 LoadImageFunction GetImageLoadFunction(GLenum internalFormat, const Renderer9 *renderer) 327 { 328 if (!renderer) 329 { 330 return NULL; 331 } 332 333 ASSERT(renderer->getCurrentClientVersion() == 2); 334 335 D3D9FormatInfo d3d9FormatInfo; 336 if (GetD3D9FormatInfo(internalFormat, &d3d9FormatInfo)) 337 { 338 return d3d9FormatInfo.mLoadFunction(renderer); 339 } 340 else 341 { 342 UNREACHABLE(); 343 return NULL; 344 } 345 } 346 347 GLuint GetFormatPixelBytes(D3DFORMAT format) 348 { 349 D3DFormatInfo d3dFormatInfo; 350 if (GetD3D9FormatInfo(format, &d3dFormatInfo)) 351 { 352 return d3dFormatInfo.mPixelBits / 8; 353 } 354 else 355 { 356 UNREACHABLE(); 357 return 0; 358 } 359 } 360 361 GLuint GetBlockWidth(D3DFORMAT format) 362 { 363 D3DFormatInfo d3dFormatInfo; 364 if (GetD3D9FormatInfo(format, &d3dFormatInfo)) 365 { 366 return d3dFormatInfo.mBlockWidth; 367 } 368 else 369 { 370 UNREACHABLE(); 371 return 0; 372 } 373 } 374 375 GLuint GetBlockHeight(D3DFORMAT format) 376 { 377 D3DFormatInfo d3dFormatInfo; 378 if (GetD3D9FormatInfo(format, &d3dFormatInfo)) 379 { 380 return d3dFormatInfo.mBlockHeight; 381 } 382 else 383 { 384 UNREACHABLE(); 385 return 0; 386 } 387 } 388 389 GLuint GetBlockSize(D3DFORMAT format, GLuint width, GLuint height) 390 { 391 D3DFormatInfo d3dFormatInfo; 392 if (GetD3D9FormatInfo(format, &d3dFormatInfo)) 393 { 394 GLuint numBlocksWide = (width + d3dFormatInfo.mBlockWidth - 1) / d3dFormatInfo.mBlockWidth; 395 GLuint numBlocksHight = (height + d3dFormatInfo.mBlockHeight - 1) / d3dFormatInfo.mBlockHeight; 396 397 return (d3dFormatInfo.mPixelBits * numBlocksWide * numBlocksHight) / 8; 398 } 399 else 400 { 401 UNREACHABLE(); 402 return 0; 403 } 404 } 405 406 void MakeValidSize(bool isImage, D3DFORMAT format, GLsizei *requestWidth, GLsizei *requestHeight, int *levelOffset) 407 { 408 D3DFormatInfo d3dFormatInfo; 409 if (GetD3D9FormatInfo(format, &d3dFormatInfo)) 410 { 411 int upsampleCount = 0; 412 413 GLsizei blockWidth = d3dFormatInfo.mBlockWidth; 414 GLsizei blockHeight = d3dFormatInfo.mBlockHeight; 415 416 // Don't expand the size of full textures that are at least (blockWidth x blockHeight) already. 417 if (isImage || *requestWidth < blockWidth || *requestHeight < blockHeight) 418 { 419 while (*requestWidth % blockWidth != 0 || *requestHeight % blockHeight != 0) 420 { 421 *requestWidth <<= 1; 422 *requestHeight <<= 1; 423 upsampleCount++; 424 } 425 } 426 *levelOffset = upsampleCount; 427 } 428 } 429 430 const D3DFormatSet &GetAllUsedD3DFormats() 431 { 432 static const D3DFormatSet formatSet = BuildAllD3DFormatSet(); 433 return formatSet; 434 } 435 436 ColorReadFunction GetColorReadFunction(D3DFORMAT format) 437 { 438 D3DFormatInfo d3dFormatInfo; 439 if (GetD3D9FormatInfo(format, &d3dFormatInfo)) 440 { 441 return d3dFormatInfo.mColorReadFunction; 442 } 443 else 444 { 445 UNREACHABLE(); 446 return NULL; 447 } 448 } 449 450 ColorCopyFunction GetFastCopyFunction(D3DFORMAT sourceFormat, GLenum destFormat, GLenum destType, GLuint clientVersion) 451 { 452 static const D3D9FastCopyMap fastCopyMap = BuildFastCopyMap(); 453 D3D9FastCopyMap::const_iterator iter = fastCopyMap.find(D3D9FastCopyFormat(sourceFormat, destFormat, destType)); 454 return (iter != fastCopyMap.end()) ? iter->second : NULL; 455 } 456 457 GLenum GetDeclTypeComponentType(D3DDECLTYPE declType) 458 { 459 switch (declType) 460 { 461 case D3DDECLTYPE_FLOAT1: return GL_FLOAT; 462 case D3DDECLTYPE_FLOAT2: return GL_FLOAT; 463 case D3DDECLTYPE_FLOAT3: return GL_FLOAT; 464 case D3DDECLTYPE_FLOAT4: return GL_FLOAT; 465 case D3DDECLTYPE_UBYTE4: return GL_UNSIGNED_INT; 466 case D3DDECLTYPE_SHORT2: return GL_INT; 467 case D3DDECLTYPE_SHORT4: return GL_INT; 468 case D3DDECLTYPE_UBYTE4N: return GL_UNSIGNED_NORMALIZED; 469 case D3DDECLTYPE_SHORT4N: return GL_SIGNED_NORMALIZED; 470 case D3DDECLTYPE_USHORT4N: return GL_UNSIGNED_NORMALIZED; 471 case D3DDECLTYPE_SHORT2N: return GL_SIGNED_NORMALIZED; 472 case D3DDECLTYPE_USHORT2N: return GL_UNSIGNED_NORMALIZED; 473 default: UNREACHABLE(); return GL_NONE; 474 } 475 } 476 477 // Attribute format conversion 478 enum { NUM_GL_VERTEX_ATTRIB_TYPES = 6 }; 479 480 struct FormatConverter 481 { 482 bool identity; 483 std::size_t outputElementSize; 484 void (*convertArray)(const void *in, std::size_t stride, std::size_t n, void *out); 485 D3DDECLTYPE d3dDeclType; 486 }; 487 488 struct TranslationDescription 489 { 490 DWORD capsFlag; 491 FormatConverter preferredConversion; 492 FormatConverter fallbackConversion; 493 }; 494 495 static unsigned int typeIndex(GLenum type); 496 static const FormatConverter &formatConverter(const gl::VertexAttribute &attribute); 497 498 bool mTranslationsInitialized = false; 499 FormatConverter mFormatConverters[NUM_GL_VERTEX_ATTRIB_TYPES][2][4]; 500 501 // Mapping from OpenGL-ES vertex attrib type to D3D decl type: 502 // 503 // BYTE SHORT (Cast) 504 // BYTE-norm FLOAT (Normalize) (can't be exactly represented as SHORT-norm) 505 // UNSIGNED_BYTE UBYTE4 (Identity) or SHORT (Cast) 506 // UNSIGNED_BYTE-norm UBYTE4N (Identity) or FLOAT (Normalize) 507 // SHORT SHORT (Identity) 508 // SHORT-norm SHORT-norm (Identity) or FLOAT (Normalize) 509 // UNSIGNED_SHORT FLOAT (Cast) 510 // UNSIGNED_SHORT-norm USHORT-norm (Identity) or FLOAT (Normalize) 511 // FIXED (not in WebGL) FLOAT (FixedToFloat) 512 // FLOAT FLOAT (Identity) 513 514 // GLToCType maps from GL type (as GLenum) to the C typedef. 515 template <GLenum GLType> struct GLToCType { }; 516 517 template <> struct GLToCType<GL_BYTE> { typedef GLbyte type; }; 518 template <> struct GLToCType<GL_UNSIGNED_BYTE> { typedef GLubyte type; }; 519 template <> struct GLToCType<GL_SHORT> { typedef GLshort type; }; 520 template <> struct GLToCType<GL_UNSIGNED_SHORT> { typedef GLushort type; }; 521 template <> struct GLToCType<GL_FIXED> { typedef GLuint type; }; 522 template <> struct GLToCType<GL_FLOAT> { typedef GLfloat type; }; 523 524 // This differs from D3DDECLTYPE in that it is unsized. (Size expansion is applied last.) 525 enum D3DVertexType 526 { 527 D3DVT_FLOAT, 528 D3DVT_SHORT, 529 D3DVT_SHORT_NORM, 530 D3DVT_UBYTE, 531 D3DVT_UBYTE_NORM, 532 D3DVT_USHORT_NORM 533 }; 534 535 // D3DToCType maps from D3D vertex type (as enum D3DVertexType) to the corresponding C type. 536 template <unsigned int D3DType> struct D3DToCType { }; 537 538 template <> struct D3DToCType<D3DVT_FLOAT> { typedef float type; }; 539 template <> struct D3DToCType<D3DVT_SHORT> { typedef short type; }; 540 template <> struct D3DToCType<D3DVT_SHORT_NORM> { typedef short type; }; 541 template <> struct D3DToCType<D3DVT_UBYTE> { typedef unsigned char type; }; 542 template <> struct D3DToCType<D3DVT_UBYTE_NORM> { typedef unsigned char type; }; 543 template <> struct D3DToCType<D3DVT_USHORT_NORM> { typedef unsigned short type; }; 544 545 // Encode the type/size combinations that D3D permits. For each type/size it expands to a widener that will provide the appropriate final size. 546 template <unsigned int type, int size> struct WidenRule { }; 547 548 template <int size> struct WidenRule<D3DVT_FLOAT, size> : NoWiden<size> { }; 549 template <int size> struct WidenRule<D3DVT_SHORT, size> : WidenToEven<size> { }; 550 template <int size> struct WidenRule<D3DVT_SHORT_NORM, size> : WidenToEven<size> { }; 551 template <int size> struct WidenRule<D3DVT_UBYTE, size> : WidenToFour<size> { }; 552 template <int size> struct WidenRule<D3DVT_UBYTE_NORM, size> : WidenToFour<size> { }; 553 template <int size> struct WidenRule<D3DVT_USHORT_NORM, size> : WidenToEven<size> { }; 554 555 // VertexTypeFlags encodes the D3DCAPS9::DeclType flag and vertex declaration flag for each D3D vertex type & size combination. 556 template <unsigned int d3dtype, int size> struct VertexTypeFlags { }; 557 558 template <unsigned int _capflag, unsigned int _declflag> 559 struct VertexTypeFlagsHelper 560 { 561 enum { capflag = _capflag }; 562 enum { declflag = _declflag }; 563 }; 564 565 template <> struct VertexTypeFlags<D3DVT_FLOAT, 1> : VertexTypeFlagsHelper<0, D3DDECLTYPE_FLOAT1> { }; 566 template <> struct VertexTypeFlags<D3DVT_FLOAT, 2> : VertexTypeFlagsHelper<0, D3DDECLTYPE_FLOAT2> { }; 567 template <> struct VertexTypeFlags<D3DVT_FLOAT, 3> : VertexTypeFlagsHelper<0, D3DDECLTYPE_FLOAT3> { }; 568 template <> struct VertexTypeFlags<D3DVT_FLOAT, 4> : VertexTypeFlagsHelper<0, D3DDECLTYPE_FLOAT4> { }; 569 template <> struct VertexTypeFlags<D3DVT_SHORT, 2> : VertexTypeFlagsHelper<0, D3DDECLTYPE_SHORT2> { }; 570 template <> struct VertexTypeFlags<D3DVT_SHORT, 4> : VertexTypeFlagsHelper<0, D3DDECLTYPE_SHORT4> { }; 571 template <> struct VertexTypeFlags<D3DVT_SHORT_NORM, 2> : VertexTypeFlagsHelper<D3DDTCAPS_SHORT2N, D3DDECLTYPE_SHORT2N> { }; 572 template <> struct VertexTypeFlags<D3DVT_SHORT_NORM, 4> : VertexTypeFlagsHelper<D3DDTCAPS_SHORT4N, D3DDECLTYPE_SHORT4N> { }; 573 template <> struct VertexTypeFlags<D3DVT_UBYTE, 4> : VertexTypeFlagsHelper<D3DDTCAPS_UBYTE4, D3DDECLTYPE_UBYTE4> { }; 574 template <> struct VertexTypeFlags<D3DVT_UBYTE_NORM, 4> : VertexTypeFlagsHelper<D3DDTCAPS_UBYTE4N, D3DDECLTYPE_UBYTE4N> { }; 575 template <> struct VertexTypeFlags<D3DVT_USHORT_NORM, 2> : VertexTypeFlagsHelper<D3DDTCAPS_USHORT2N, D3DDECLTYPE_USHORT2N> { }; 576 template <> struct VertexTypeFlags<D3DVT_USHORT_NORM, 4> : VertexTypeFlagsHelper<D3DDTCAPS_USHORT4N, D3DDECLTYPE_USHORT4N> { }; 577 578 579 // VertexTypeMapping maps GL type & normalized flag to preferred and fallback D3D vertex types (as D3DVertexType enums). 580 template <GLenum GLtype, bool normalized> struct VertexTypeMapping { }; 581 582 template <D3DVertexType Preferred, D3DVertexType Fallback = Preferred> 583 struct VertexTypeMappingBase 584 { 585 enum { preferred = Preferred }; 586 enum { fallback = Fallback }; 587 }; 588 589 template <> struct VertexTypeMapping<GL_BYTE, false> : VertexTypeMappingBase<D3DVT_SHORT> { }; // Cast 590 template <> struct VertexTypeMapping<GL_BYTE, true> : VertexTypeMappingBase<D3DVT_FLOAT> { }; // Normalize 591 template <> struct VertexTypeMapping<GL_UNSIGNED_BYTE, false> : VertexTypeMappingBase<D3DVT_UBYTE, D3DVT_FLOAT> { }; // Identity, Cast 592 template <> struct VertexTypeMapping<GL_UNSIGNED_BYTE, true> : VertexTypeMappingBase<D3DVT_UBYTE_NORM, D3DVT_FLOAT> { }; // Identity, Normalize 593 template <> struct VertexTypeMapping<GL_SHORT, false> : VertexTypeMappingBase<D3DVT_SHORT> { }; // Identity 594 template <> struct VertexTypeMapping<GL_SHORT, true> : VertexTypeMappingBase<D3DVT_SHORT_NORM, D3DVT_FLOAT> { }; // Cast, Normalize 595 template <> struct VertexTypeMapping<GL_UNSIGNED_SHORT, false> : VertexTypeMappingBase<D3DVT_FLOAT> { }; // Cast 596 template <> struct VertexTypeMapping<GL_UNSIGNED_SHORT, true> : VertexTypeMappingBase<D3DVT_USHORT_NORM, D3DVT_FLOAT> { }; // Cast, Normalize 597 template <bool normalized> struct VertexTypeMapping<GL_FIXED, normalized> : VertexTypeMappingBase<D3DVT_FLOAT> { }; // FixedToFloat 598 template <bool normalized> struct VertexTypeMapping<GL_FLOAT, normalized> : VertexTypeMappingBase<D3DVT_FLOAT> { }; // Identity 599 600 601 // Given a GL type & norm flag and a D3D type, ConversionRule provides the type conversion rule (Cast, Normalize, Identity, FixedToFloat). 602 // The conversion rules themselves are defined in vertexconversion.h. 603 604 // Almost all cases are covered by Cast (including those that are actually Identity since Cast<T,T> knows it's an identity mapping). 605 template <GLenum fromType, bool normalized, unsigned int toType> 606 struct ConversionRule : Cast<typename GLToCType<fromType>::type, typename D3DToCType<toType>::type> { }; 607 608 // All conversions from normalized types to float use the Normalize operator. 609 template <GLenum fromType> struct ConversionRule<fromType, true, D3DVT_FLOAT> : Normalize<typename GLToCType<fromType>::type> { }; 610 611 // Use a full specialization for this so that it preferentially matches ahead of the generic normalize-to-float rules. 612 template <> struct ConversionRule<GL_FIXED, true, D3DVT_FLOAT> : FixedToFloat<GLint, 16> { }; 613 template <> struct ConversionRule<GL_FIXED, false, D3DVT_FLOAT> : FixedToFloat<GLint, 16> { }; 614 615 // A 2-stage construction is used for DefaultVertexValues because float must use SimpleDefaultValues (i.e. 0/1) 616 // whether it is normalized or not. 617 template <class T, bool normalized> struct DefaultVertexValuesStage2 { }; 618 619 template <class T> struct DefaultVertexValuesStage2<T, true> : NormalizedDefaultValues<T> { }; 620 template <class T> struct DefaultVertexValuesStage2<T, false> : SimpleDefaultValues<T> { }; 621 622 // Work out the default value rule for a D3D type (expressed as the C type) and 623 template <class T, bool normalized> struct DefaultVertexValues : DefaultVertexValuesStage2<T, normalized> { }; 624 template <bool normalized> struct DefaultVertexValues<float, normalized> : SimpleDefaultValues<float> { }; 625 626 // Policy rules for use with Converter, to choose whether to use the preferred or fallback conversion. 627 // The fallback conversion produces an output that all D3D9 devices must support. 628 template <class T> struct UsePreferred { enum { type = T::preferred }; }; 629 template <class T> struct UseFallback { enum { type = T::fallback }; }; 630 631 // Converter ties it all together. Given an OpenGL type/norm/size and choice of preferred/fallback conversion, 632 // it provides all the members of the appropriate VertexDataConverter, the D3DCAPS9::DeclTypes flag in cap flag 633 // and the D3DDECLTYPE member needed for the vertex declaration in declflag. 634 template <GLenum fromType, bool normalized, int size, template <class T> class PreferenceRule> 635 struct Converter 636 : VertexDataConverter<typename GLToCType<fromType>::type, 637 WidenRule<PreferenceRule< VertexTypeMapping<fromType, normalized> >::type, size>, 638 ConversionRule<fromType, 639 normalized, 640 PreferenceRule< VertexTypeMapping<fromType, normalized> >::type>, 641 DefaultVertexValues<typename D3DToCType<PreferenceRule< VertexTypeMapping<fromType, normalized> >::type>::type, normalized > > 642 { 643 private: 644 enum { d3dtype = PreferenceRule< VertexTypeMapping<fromType, normalized> >::type }; 645 enum { d3dsize = WidenRule<d3dtype, size>::finalWidth }; 646 647 public: 648 enum { capflag = VertexTypeFlags<d3dtype, d3dsize>::capflag }; 649 enum { declflag = VertexTypeFlags<d3dtype, d3dsize>::declflag }; 650 }; 651 652 // Initialize a TranslationInfo 653 #define TRANSLATION(type, norm, size, preferred) \ 654 { \ 655 Converter<type, norm, size, preferred>::identity, \ 656 Converter<type, norm, size, preferred>::finalSize, \ 657 Converter<type, norm, size, preferred>::convertArray, \ 658 static_cast<D3DDECLTYPE>(Converter<type, norm, size, preferred>::declflag) \ 659 } 660 661 #define TRANSLATION_FOR_TYPE_NORM_SIZE(type, norm, size) \ 662 { \ 663 Converter<type, norm, size, UsePreferred>::capflag, \ 664 TRANSLATION(type, norm, size, UsePreferred), \ 665 TRANSLATION(type, norm, size, UseFallback) \ 666 } 667 668 #define TRANSLATIONS_FOR_TYPE(type) \ 669 { \ 670 { TRANSLATION_FOR_TYPE_NORM_SIZE(type, false, 1), TRANSLATION_FOR_TYPE_NORM_SIZE(type, false, 2), TRANSLATION_FOR_TYPE_NORM_SIZE(type, false, 3), TRANSLATION_FOR_TYPE_NORM_SIZE(type, false, 4) }, \ 671 { TRANSLATION_FOR_TYPE_NORM_SIZE(type, true, 1), TRANSLATION_FOR_TYPE_NORM_SIZE(type, true, 2), TRANSLATION_FOR_TYPE_NORM_SIZE(type, true, 3), TRANSLATION_FOR_TYPE_NORM_SIZE(type, true, 4) }, \ 672 } 673 674 #define TRANSLATIONS_FOR_TYPE_NO_NORM(type) \ 675 { \ 676 { TRANSLATION_FOR_TYPE_NORM_SIZE(type, false, 1), TRANSLATION_FOR_TYPE_NORM_SIZE(type, false, 2), TRANSLATION_FOR_TYPE_NORM_SIZE(type, false, 3), TRANSLATION_FOR_TYPE_NORM_SIZE(type, false, 4) }, \ 677 { TRANSLATION_FOR_TYPE_NORM_SIZE(type, false, 1), TRANSLATION_FOR_TYPE_NORM_SIZE(type, false, 2), TRANSLATION_FOR_TYPE_NORM_SIZE(type, false, 3), TRANSLATION_FOR_TYPE_NORM_SIZE(type, false, 4) }, \ 678 } 679 680 const TranslationDescription mPossibleTranslations[NUM_GL_VERTEX_ATTRIB_TYPES][2][4] = // [GL types as enumerated by typeIndex()][normalized][size-1] 681 { 682 TRANSLATIONS_FOR_TYPE(GL_BYTE), 683 TRANSLATIONS_FOR_TYPE(GL_UNSIGNED_BYTE), 684 TRANSLATIONS_FOR_TYPE(GL_SHORT), 685 TRANSLATIONS_FOR_TYPE(GL_UNSIGNED_SHORT), 686 TRANSLATIONS_FOR_TYPE_NO_NORM(GL_FIXED), 687 TRANSLATIONS_FOR_TYPE_NO_NORM(GL_FLOAT) 688 }; 689 690 void InitializeVertexTranslations(const rx::Renderer9 *renderer) 691 { 692 DWORD declTypes = renderer->getCapsDeclTypes(); 693 694 for (unsigned int i = 0; i < NUM_GL_VERTEX_ATTRIB_TYPES; i++) 695 { 696 for (unsigned int j = 0; j < 2; j++) 697 { 698 for (unsigned int k = 0; k < 4; k++) 699 { 700 if (mPossibleTranslations[i][j][k].capsFlag == 0 || (declTypes & mPossibleTranslations[i][j][k].capsFlag) != 0) 701 { 702 mFormatConverters[i][j][k] = mPossibleTranslations[i][j][k].preferredConversion; 703 } 704 else 705 { 706 mFormatConverters[i][j][k] = mPossibleTranslations[i][j][k].fallbackConversion; 707 } 708 } 709 } 710 } 711 } 712 713 unsigned int typeIndex(GLenum type) 714 { 715 switch (type) 716 { 717 case GL_BYTE: return 0; 718 case GL_UNSIGNED_BYTE: return 1; 719 case GL_SHORT: return 2; 720 case GL_UNSIGNED_SHORT: return 3; 721 case GL_FIXED: return 4; 722 case GL_FLOAT: return 5; 723 724 default: UNREACHABLE(); return 5; 725 } 726 } 727 728 const FormatConverter &formatConverter(const gl::VertexFormat &vertexFormat) 729 { 730 // Pure integer attributes only supported in ES3.0 731 ASSERT(!vertexFormat.mPureInteger); 732 return mFormatConverters[typeIndex(vertexFormat.mType)][vertexFormat.mNormalized][vertexFormat.mComponents - 1]; 733 } 734 735 VertexCopyFunction GetVertexCopyFunction(const gl::VertexFormat &vertexFormat) 736 { 737 return formatConverter(vertexFormat).convertArray; 738 } 739 740 size_t GetVertexElementSize(const gl::VertexFormat &vertexFormat) 741 { 742 return formatConverter(vertexFormat).outputElementSize; 743 } 744 745 VertexConversionType GetVertexConversionType(const gl::VertexFormat &vertexFormat) 746 { 747 return (formatConverter(vertexFormat).identity ? VERTEX_CONVERT_NONE : VERTEX_CONVERT_CPU); 748 } 749 750 D3DDECLTYPE GetNativeVertexFormat(const gl::VertexFormat &vertexFormat) 751 { 752 return formatConverter(vertexFormat).d3dDeclType; 753 } 754 755 } 756 757 namespace gl_d3d9 758 { 759 760 D3DFORMAT GetTextureFormat(GLenum internalFormat, const Renderer9 *renderer) 761 { 762 if (!renderer) 763 { 764 UNREACHABLE(); 765 return D3DFMT_UNKNOWN; 766 } 767 768 ASSERT(renderer->getCurrentClientVersion() == 2); 769 770 D3D9FormatInfo d3d9FormatInfo; 771 if (GetD3D9FormatInfo(internalFormat, &d3d9FormatInfo)) 772 { 773 return d3d9FormatInfo.mTexFormat(renderer); 774 } 775 else 776 { 777 UNREACHABLE(); 778 return D3DFMT_UNKNOWN; 779 } 780 } 781 782 D3DFORMAT GetRenderFormat(GLenum internalFormat, const Renderer9 *renderer) 783 { 784 if (!renderer) 785 { 786 UNREACHABLE(); 787 return D3DFMT_UNKNOWN; 788 } 789 790 ASSERT(renderer->getCurrentClientVersion() == 2); 791 792 D3D9FormatInfo d3d9FormatInfo; 793 if (GetD3D9FormatInfo(internalFormat, &d3d9FormatInfo)) 794 { 795 return d3d9FormatInfo.mRenderFormat(renderer); 796 } 797 else 798 { 799 UNREACHABLE(); 800 return D3DFMT_UNKNOWN; 801 } 802 } 803 804 D3DMULTISAMPLE_TYPE GetMultisampleType(GLsizei samples) 805 { 806 return (samples > 1) ? static_cast<D3DMULTISAMPLE_TYPE>(samples) : D3DMULTISAMPLE_NONE; 807 } 808 809 bool RequiresTextureDataInitialization(GLint internalFormat) 810 { 811 const InternalFormatInitialzerMap &map = GetInternalFormatInitialzerMap(); 812 return map.find(internalFormat) != map.end(); 813 } 814 815 InitializeTextureDataFunction GetTextureDataInitializationFunction(GLint internalFormat) 816 { 817 const InternalFormatInitialzerMap &map = GetInternalFormatInitialzerMap(); 818 InternalFormatInitialzerMap::const_iterator iter = map.find(internalFormat); 819 if (iter != map.end()) 820 { 821 return iter->second; 822 } 823 else 824 { 825 UNREACHABLE(); 826 return NULL; 827 } 828 } 829 830 } 831 832 namespace d3d9_gl 833 { 834 835 GLenum GetInternalFormat(D3DFORMAT format) 836 { 837 static const D3D9FormatInfoMap infoMap = BuildD3D9FormatInfoMap(); 838 D3D9FormatInfoMap::const_iterator iter = infoMap.find(format); 839 if (iter != infoMap.end()) 840 { 841 return iter->second.mInternalFormat; 842 } 843 else 844 { 845 UNREACHABLE(); 846 return GL_NONE; 847 } 848 } 849 850 GLsizei GetSamplesCount(D3DMULTISAMPLE_TYPE type) 851 { 852 return (type != D3DMULTISAMPLE_NONMASKABLE) ? type : 0; 853 } 854 855 bool IsFormatChannelEquivalent(D3DFORMAT d3dformat, GLenum format, GLuint clientVersion) 856 { 857 GLenum internalFormat = d3d9_gl::GetInternalFormat(d3dformat); 858 GLenum convertedFormat = gl::GetFormat(internalFormat, clientVersion); 859 return convertedFormat == format; 860 } 861 862 } 863 864 } 865
