Google Git
Sign in
cobalt / cobalt / 72bde07ae3f88e8fd742a603ece725b122de47f5 / . / src / third_party / angle / src / libANGLE / renderer / d3d / d3d9 / formatutils9.cpp
blob: 72188bb11673f96e11354d3a83b50c3a7abf353f [file] [log] [blame]
//
// Copyright 2013 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// formatutils9.cpp: Queries for GL image formats and their translations to D3D9
// formats.
#include "libANGLE/renderer/d3d/d3d9/formatutils9.h"
#include "image_util/copyimage.h"
#include "image_util/generatemip.h"
#include "image_util/loadimage.h"
#include "anglebase/no_destructor.h"
#include "libANGLE/renderer/d3d/d3d9/Renderer9.h"
#include "libANGLE/renderer/d3d/d3d9/vertexconversion.h"
using namespace angle;
namespace rx
{
namespace d3d9
{
constexpr D3DFORMAT D3DFMT_INTZ = ((D3DFORMAT)(MAKEFOURCC('I', 'N', 'T', 'Z')));
constexpr D3DFORMAT D3DFMT_NULL = ((D3DFORMAT)(MAKEFOURCC('N', 'U', 'L', 'L')));
// A map to determine the pixel size and mip generation function of a given D3D format
typedef std::map<D3DFORMAT, D3DFormat> D3D9FormatInfoMap;
D3DFormat::D3DFormat()
: pixelBytes(0),
blockWidth(0),
blockHeight(0),
redBits(0),
greenBits(0),
blueBits(0),
alphaBits(0),
luminanceBits(0),
depthBits(0),
stencilBits(0),
formatID(angle::FormatID::NONE)
{}
D3DFormat::D3DFormat(GLuint bits,
GLuint blockWidth,
GLuint blockHeight,
GLuint redBits,
GLuint greenBits,
GLuint blueBits,
GLuint alphaBits,
GLuint lumBits,
GLuint depthBits,
GLuint stencilBits,
FormatID formatID)
: pixelBytes(bits / 8),
blockWidth(blockWidth),
blockHeight(blockHeight),
redBits(redBits),
greenBits(greenBits),
blueBits(blueBits),
alphaBits(alphaBits),
luminanceBits(lumBits),
depthBits(depthBits),
stencilBits(stencilBits),
formatID(formatID)
{}
const D3DFormat &GetD3DFormatInfo(D3DFORMAT format)
{
if (format == D3DFMT_NULL)
{
static const D3DFormat info(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, FormatID::NONE);
return info;
}
if (format == D3DFMT_INTZ)
{
static const D3DFormat info(32, 1, 1, 0, 0, 0, 0, 0, 24, 8, FormatID::D24_UNORM_S8_UINT);
return info;
}
switch (format)
{
case D3DFMT_UNKNOWN:
{
static const D3DFormat info(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, FormatID::NONE);
return info;
}
case D3DFMT_L8:
{
static const D3DFormat info(8, 1, 1, 0, 0, 0, 0, 8, 0, 0, FormatID::L8_UNORM);
return info;
}
case D3DFMT_A8:
{
static const D3DFormat info(8, 1, 1, 0, 0, 0, 8, 0, 0, 0, FormatID::A8_UNORM);
return info;
}
case D3DFMT_A8L8:
{
static const D3DFormat info(16, 1, 1, 0, 0, 0, 8, 8, 0, 0, FormatID::L8A8_UNORM);
return info;
}
case D3DFMT_A4R4G4B4:
{
static const D3DFormat info(16, 1, 1, 4, 4, 4, 4, 0, 0, 0, FormatID::B4G4R4A4_UNORM);
return info;
}
case D3DFMT_A1R5G5B5:
{
static const D3DFormat info(16, 1, 1, 5, 5, 5, 1, 0, 0, 0, FormatID::B5G5R5A1_UNORM);
return info;
}
case D3DFMT_R5G6B5:
{
static const D3DFormat info(16, 1, 1, 5, 6, 5, 0, 0, 0, 0, FormatID::R5G6B5_UNORM);
return info;
}
case D3DFMT_X8R8G8B8:
{
static const D3DFormat info(32, 1, 1, 8, 8, 8, 0, 0, 0, 0, FormatID::B8G8R8X8_UNORM);
return info;
}
case D3DFMT_A8R8G8B8:
{
static const D3DFormat info(32, 1, 1, 8, 8, 8, 8, 0, 0, 0, FormatID::B8G8R8A8_UNORM);
return info;
}
case D3DFMT_R16F:
{
static const D3DFormat info(16, 1, 1, 16, 0, 0, 0, 0, 0, 0, FormatID::R16_FLOAT);
return info;
}
case D3DFMT_G16R16F:
{
static const D3DFormat info(32, 1, 1, 16, 16, 0, 0, 0, 0, 0, FormatID::R16G16_FLOAT);
return info;
}
case D3DFMT_A16B16G16R16F:
{
static const D3DFormat info(64, 1, 1, 16, 16, 16, 16, 0, 0, 0,
FormatID::R16G16B16A16_FLOAT);
return info;
}
case D3DFMT_R32F:
{
static const D3DFormat info(32, 1, 1, 32, 0, 0, 0, 0, 0, 0, FormatID::R32_FLOAT);
return info;
}
case D3DFMT_G32R32F:
{
static const D3DFormat info(64, 1, 1, 32, 32, 0, 0, 0, 0, 0, FormatID::R32G32_FLOAT);
return info;
}
case D3DFMT_A32B32G32R32F:
{
static const D3DFormat info(128, 1, 1, 32, 32, 32, 32, 0, 0, 0,
FormatID::R32G32B32A32_FLOAT);
return info;
}
case D3DFMT_D16:
{
static const D3DFormat info(16, 1, 1, 0, 0, 0, 0, 0, 16, 0, FormatID::D16_UNORM);
return info;
}
case D3DFMT_D24S8:
{
static const D3DFormat info(32, 1, 1, 0, 0, 0, 0, 0, 24, 8,
FormatID::D24_UNORM_S8_UINT);
return info;
}
case D3DFMT_D24X8:
{
static const D3DFormat info(32, 1, 1, 0, 0, 0, 0, 0, 24, 0, FormatID::D16_UNORM);
return info;
}
case D3DFMT_D32:
{
static const D3DFormat info(32, 1, 1, 0, 0, 0, 0, 0, 32, 0, FormatID::D32_UNORM);
return info;
}
case D3DFMT_DXT1:
{
static const D3DFormat info(64, 4, 4, 0, 0, 0, 0, 0, 0, 0,
FormatID::BC1_RGBA_UNORM_BLOCK);
return info;
}
case D3DFMT_DXT3:
{
static const D3DFormat info(128, 4, 4, 0, 0, 0, 0, 0, 0, 0,
FormatID::BC2_RGBA_UNORM_BLOCK);
return info;
}
case D3DFMT_DXT5:
{
static const D3DFormat info(128, 4, 4, 0, 0, 0, 0, 0, 0, 0,
FormatID::BC3_RGBA_UNORM_BLOCK);
return info;
}
default:
{
static const D3DFormat defaultInfo;
return defaultInfo;
}
}
}
typedef std::pair<GLint, InitializeTextureDataFunction> InternalFormatInitialzerPair;
typedef std::map<GLint, InitializeTextureDataFunction> InternalFormatInitialzerMap;
static InternalFormatInitialzerMap BuildInternalFormatInitialzerMap()
{
using namespace angle; // For image initialization functions
InternalFormatInitialzerMap map;
map.insert(InternalFormatInitialzerPair(
GL_RGB16F, Initialize4ComponentData<GLhalf, 0x0000, 0x0000, 0x0000, gl::Float16One>));
map.insert(InternalFormatInitialzerPair(
GL_RGB32F,
Initialize4ComponentData<GLfloat, 0x00000000, 0x00000000, 0x00000000, gl::Float32One>));
return map;
}
static void UnreachableLoad(size_t width,
size_t height,
size_t depth,
const uint8_t *input,
size_t inputRowPitch,
size_t inputDepthPitch,
uint8_t *output,
size_t outputRowPitch,
size_t outputDepthPitch)
{
UNREACHABLE();
}
typedef std::pair<GLenum, TextureFormat> D3D9FormatPair;
typedef std::map<GLenum, TextureFormat> D3D9FormatMap;
TextureFormat::TextureFormat()
: texFormat(D3DFMT_UNKNOWN),
renderFormat(D3DFMT_UNKNOWN),
dataInitializerFunction(nullptr),
loadFunction(UnreachableLoad)
{}
static inline void InsertD3D9FormatInfo(D3D9FormatMap *map,
GLenum internalFormat,
D3DFORMAT texFormat,
D3DFORMAT renderFormat,
LoadImageFunction loadFunction)
{
TextureFormat info;
info.texFormat = texFormat;
info.renderFormat = renderFormat;
static const angle::base::NoDestructor<InternalFormatInitialzerMap> dataInitializationMap(
BuildInternalFormatInitialzerMap());
InternalFormatInitialzerMap::const_iterator dataInitIter =
dataInitializationMap->find(internalFormat);
info.dataInitializerFunction =
(dataInitIter != dataInitializationMap->end()) ? dataInitIter->second : nullptr;
info.loadFunction = loadFunction;
map->insert(std::make_pair(internalFormat, info));
}
static D3D9FormatMap BuildD3D9FormatMap()
{
using namespace angle; // For image loading functions
D3D9FormatMap map;
// clang-format off
// | Internal format | Texture format | Render format | Load function |
InsertD3D9FormatInfo(&map, GL_NONE, D3DFMT_NULL, D3DFMT_NULL, UnreachableLoad );
// We choose to downsample the GL_DEPTH_COMPONENT32_OES format to a 24-bit format because D3DFMT_D32 is not widely
// supported. We're allowed to do this because:
// - The ES spec 2.0.25 sec 3.7.1 states that we're allowed to store texture formats with internal format
// resolutions of our own choosing.
// - OES_depth_texture states that downsampling of the depth formats is allowed.
// - ANGLE_depth_texture does not state minimum required resolutions of the depth texture formats it
// introduces.
// In ES3 however, there are minimum resolutions for the texture formats and this would not be allowed.
InsertD3D9FormatInfo(&map, GL_DEPTH_COMPONENT16, D3DFMT_INTZ, D3DFMT_D24S8, UnreachableLoad );
InsertD3D9FormatInfo(&map, GL_DEPTH_COMPONENT32_OES, D3DFMT_INTZ, D3DFMT_D24X8, UnreachableLoad );
InsertD3D9FormatInfo(&map, GL_DEPTH24_STENCIL8_OES, D3DFMT_INTZ, D3DFMT_D24S8, UnreachableLoad );
InsertD3D9FormatInfo(&map, GL_STENCIL_INDEX8, D3DFMT_UNKNOWN, D3DFMT_D24S8, UnreachableLoad ); // TODO: What's the texture format?
InsertD3D9FormatInfo(&map, GL_RGBA32F_EXT, D3DFMT_A32B32G32R32F, D3DFMT_A32B32G32R32F, LoadToNative<GLfloat, 4> );
InsertD3D9FormatInfo(&map, GL_RGB32F_EXT, D3DFMT_A32B32G32R32F, D3DFMT_A32B32G32R32F, LoadToNative3To4<GLfloat, gl::Float32One>);
InsertD3D9FormatInfo(&map, GL_RG32F_EXT, D3DFMT_G32R32F, D3DFMT_G32R32F, LoadToNative<GLfloat, 2> );
InsertD3D9FormatInfo(&map, GL_R32F_EXT, D3DFMT_R32F, D3DFMT_R32F, LoadToNative<GLfloat, 1> );
InsertD3D9FormatInfo(&map, GL_ALPHA32F_EXT, D3DFMT_A32B32G32R32F, D3DFMT_UNKNOWN, LoadA32FToRGBA32F );
InsertD3D9FormatInfo(&map, GL_LUMINANCE32F_EXT, D3DFMT_A32B32G32R32F, D3DFMT_UNKNOWN, LoadL32FToRGBA32F );
InsertD3D9FormatInfo(&map, GL_LUMINANCE_ALPHA32F_EXT, D3DFMT_A32B32G32R32F, D3DFMT_UNKNOWN, LoadLA32FToRGBA32F );
InsertD3D9FormatInfo(&map, GL_RGBA16F_EXT, D3DFMT_A16B16G16R16F, D3DFMT_A16B16G16R16F, LoadToNative<GLhalf, 4> );
InsertD3D9FormatInfo(&map, GL_RGB16F_EXT, D3DFMT_A16B16G16R16F, D3DFMT_A16B16G16R16F, LoadToNative3To4<GLhalf, gl::Float16One> );
InsertD3D9FormatInfo(&map, GL_RG16F_EXT, D3DFMT_G16R16F, D3DFMT_G16R16F, LoadToNative<GLhalf, 2> );
InsertD3D9FormatInfo(&map, GL_R16F_EXT, D3DFMT_R16F, D3DFMT_R16F, LoadToNative<GLhalf, 1> );
InsertD3D9FormatInfo(&map, GL_ALPHA16F_EXT, D3DFMT_A16B16G16R16F, D3DFMT_UNKNOWN, LoadA16FToRGBA16F );
InsertD3D9FormatInfo(&map, GL_LUMINANCE16F_EXT, D3DFMT_A16B16G16R16F, D3DFMT_UNKNOWN, LoadL16FToRGBA16F );
InsertD3D9FormatInfo(&map, GL_LUMINANCE_ALPHA16F_EXT, D3DFMT_A16B16G16R16F, D3DFMT_UNKNOWN, LoadLA16FToRGBA16F );
InsertD3D9FormatInfo(&map, GL_ALPHA8_EXT, D3DFMT_A8R8G8B8, D3DFMT_A8R8G8B8, LoadA8ToBGRA8 );
InsertD3D9FormatInfo(&map, GL_RGB8_OES, D3DFMT_X8R8G8B8, D3DFMT_X8R8G8B8, LoadRGB8ToBGRX8 );
InsertD3D9FormatInfo(&map, GL_RGB565, D3DFMT_X8R8G8B8, D3DFMT_X8R8G8B8, LoadR5G6B5ToBGRA8 );
InsertD3D9FormatInfo(&map, GL_RGBA8_OES, D3DFMT_A8R8G8B8, D3DFMT_A8R8G8B8, LoadRGBA8ToBGRA8 );
InsertD3D9FormatInfo(&map, GL_RGBA4, D3DFMT_A8R8G8B8, D3DFMT_A8R8G8B8, LoadRGBA4ToBGRA8 );
InsertD3D9FormatInfo(&map, GL_RGB5_A1, D3DFMT_A8R8G8B8, D3DFMT_A8R8G8B8, LoadRGB5A1ToBGRA8 );
InsertD3D9FormatInfo(&map, GL_R8_EXT, D3DFMT_X8R8G8B8, D3DFMT_X8R8G8B8, LoadR8ToBGRX8 );
InsertD3D9FormatInfo(&map, GL_RG8_EXT, D3DFMT_X8R8G8B8, D3DFMT_X8R8G8B8, LoadRG8ToBGRX8 );
InsertD3D9FormatInfo(&map, GL_BGRA8_EXT, D3DFMT_A8R8G8B8, D3DFMT_A8R8G8B8, LoadToNative<GLubyte, 4> );
InsertD3D9FormatInfo(&map, GL_BGRA4_ANGLEX, D3DFMT_A8R8G8B8, D3DFMT_A8R8G8B8, LoadBGRA4ToBGRA8 );
InsertD3D9FormatInfo(&map, GL_BGR5_A1_ANGLEX, D3DFMT_A8R8G8B8, D3DFMT_A8R8G8B8, LoadBGR5A1ToBGRA8 );
InsertD3D9FormatInfo(&map, GL_COMPRESSED_RGB_S3TC_DXT1_EXT, D3DFMT_DXT1, D3DFMT_UNKNOWN, LoadCompressedToNative<4, 4, 1, 8> );
InsertD3D9FormatInfo(&map, GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, D3DFMT_DXT1, D3DFMT_UNKNOWN, LoadCompressedToNative<4, 4, 1, 8> );
InsertD3D9FormatInfo(&map, GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE, D3DFMT_DXT3, D3DFMT_UNKNOWN, LoadCompressedToNative<4, 4, 1, 16> );
InsertD3D9FormatInfo(&map, GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE, D3DFMT_DXT5, D3DFMT_UNKNOWN, LoadCompressedToNative<4, 4, 1, 16> );
// These formats require checking if the renderer supports D3DFMT_L8 or D3DFMT_A8L8 and
// then changing the format and loading function appropriately.
InsertD3D9FormatInfo(&map, GL_LUMINANCE8_EXT, D3DFMT_L8, D3DFMT_UNKNOWN, LoadToNative<GLubyte, 1> );
InsertD3D9FormatInfo(&map, GL_LUMINANCE8_ALPHA8_EXT, D3DFMT_A8L8, D3DFMT_UNKNOWN, LoadToNative<GLubyte, 2> );
// clang-format on
return map;
}
const TextureFormat &GetTextureFormatInfo(GLenum internalFormat)
{
static const angle::base::NoDestructor<D3D9FormatMap> formatMap(BuildD3D9FormatMap());
D3D9FormatMap::const_iterator iter = formatMap->find(internalFormat);
if (iter != formatMap->end())
{
return iter->second;
}
else
{
static const TextureFormat defaultInfo;
return defaultInfo;
}
}
static GLenum GetDeclTypeComponentType(D3DDECLTYPE declType)
{
switch (declType)
{
case D3DDECLTYPE_FLOAT1:
return GL_FLOAT;
case D3DDECLTYPE_FLOAT2:
return GL_FLOAT;
case D3DDECLTYPE_FLOAT3:
return GL_FLOAT;
case D3DDECLTYPE_FLOAT4:
return GL_FLOAT;
case D3DDECLTYPE_UBYTE4:
return GL_UNSIGNED_INT;
case D3DDECLTYPE_SHORT2:
return GL_INT;
case D3DDECLTYPE_SHORT4:
return GL_INT;
case D3DDECLTYPE_UBYTE4N:
return GL_UNSIGNED_NORMALIZED;
case D3DDECLTYPE_SHORT4N:
return GL_SIGNED_NORMALIZED;
case D3DDECLTYPE_USHORT4N:
return GL_UNSIGNED_NORMALIZED;
case D3DDECLTYPE_SHORT2N:
return GL_SIGNED_NORMALIZED;
case D3DDECLTYPE_USHORT2N:
return GL_UNSIGNED_NORMALIZED;
default:
UNREACHABLE();
return GL_NONE;
}
}
// Attribute format conversion
enum
{
NUM_GL_VERTEX_ATTRIB_TYPES = 6
};
struct TranslationDescription
{
DWORD capsFlag;
VertexFormat preferredConversion;
VertexFormat fallbackConversion;
};
// Mapping from OpenGL-ES vertex attrib type to D3D decl type:
//
// BYTE SHORT (Cast)
// BYTE-norm FLOAT (Normalize) (can't be exactly represented as SHORT-norm)
// UNSIGNED_BYTE UBYTE4 (Identity) or SHORT (Cast)
// UNSIGNED_BYTE-norm UBYTE4N (Identity) or FLOAT (Normalize)
// SHORT SHORT (Identity)
// SHORT-norm SHORT-norm (Identity) or FLOAT (Normalize)
// UNSIGNED_SHORT FLOAT (Cast)
// UNSIGNED_SHORT-norm USHORT-norm (Identity) or FLOAT (Normalize)
// FIXED (not in WebGL) FLOAT (FixedToFloat)
// FLOAT FLOAT (Identity)
// GLToCType maps from GL type (as GLenum) to the C typedef.
template <GLenum GLType>
struct GLToCType
{};
template <>
struct GLToCType<GL_BYTE>
{
typedef GLbyte type;
};
template <>
struct GLToCType<GL_UNSIGNED_BYTE>
{
typedef GLubyte type;
};
template <>
struct GLToCType<GL_SHORT>
{
typedef GLshort type;
};
template <>
struct GLToCType<GL_UNSIGNED_SHORT>
{
typedef GLushort type;
};
template <>
struct GLToCType<GL_FIXED>
{
typedef GLuint type;
};
template <>
struct GLToCType<GL_FLOAT>
{
typedef GLfloat type;
};
// This differs from D3DDECLTYPE in that it is unsized. (Size expansion is applied last.)
enum D3DVertexType
{
D3DVT_FLOAT,
D3DVT_SHORT,
D3DVT_SHORT_NORM,
D3DVT_UBYTE,
D3DVT_UBYTE_NORM,
D3DVT_USHORT_NORM
};
// D3DToCType maps from D3D vertex type (as enum D3DVertexType) to the corresponding C type.
template <unsigned int D3DType>
struct D3DToCType
{};
template <>
struct D3DToCType<D3DVT_FLOAT>
{
typedef float type;
};
template <>
struct D3DToCType<D3DVT_SHORT>
{
typedef short type;
};
template <>
struct D3DToCType<D3DVT_SHORT_NORM>
{
typedef short type;
};
template <>
struct D3DToCType<D3DVT_UBYTE>
{
typedef unsigned char type;
};
template <>
struct D3DToCType<D3DVT_UBYTE_NORM>
{
typedef unsigned char type;
};
template <>
struct D3DToCType<D3DVT_USHORT_NORM>
{
typedef unsigned short type;
};
// Encode the type/size combinations that D3D permits. For each type/size it expands to a widener
// that will provide the appropriate final size.
template <unsigned int type, int size>
struct WidenRule
{};
template <int size>
struct WidenRule<D3DVT_FLOAT, size> : NoWiden<size>
{};
template <int size>
struct WidenRule<D3DVT_SHORT, size> : WidenToEven<size>
{};
template <int size>
struct WidenRule<D3DVT_SHORT_NORM, size> : WidenToEven<size>
{};
template <int size>
struct WidenRule<D3DVT_UBYTE, size> : WidenToFour<size>
{};
template <int size>
struct WidenRule<D3DVT_UBYTE_NORM, size> : WidenToFour<size>
{};
template <int size>
struct WidenRule<D3DVT_USHORT_NORM, size> : WidenToEven<size>
{};
// VertexTypeFlags encodes the D3DCAPS9::DeclType flag and vertex declaration flag for each D3D
// vertex type & size combination.
template <unsigned int d3dtype, int size>
struct VertexTypeFlags
{};
template <unsigned int _capflag, unsigned int _declflag>
struct VertexTypeFlagsHelper
{
enum
{
capflag = _capflag
};
enum
{
declflag = _declflag
};
};
template <>
struct VertexTypeFlags<D3DVT_FLOAT, 1> : VertexTypeFlagsHelper<0, D3DDECLTYPE_FLOAT1>
{};
template <>
struct VertexTypeFlags<D3DVT_FLOAT, 2> : VertexTypeFlagsHelper<0, D3DDECLTYPE_FLOAT2>
{};
template <>
struct VertexTypeFlags<D3DVT_FLOAT, 3> : VertexTypeFlagsHelper<0, D3DDECLTYPE_FLOAT3>
{};
template <>
struct VertexTypeFlags<D3DVT_FLOAT, 4> : VertexTypeFlagsHelper<0, D3DDECLTYPE_FLOAT4>
{};
template <>
struct VertexTypeFlags<D3DVT_SHORT, 2> : VertexTypeFlagsHelper<0, D3DDECLTYPE_SHORT2>
{};
template <>
struct VertexTypeFlags<D3DVT_SHORT, 4> : VertexTypeFlagsHelper<0, D3DDECLTYPE_SHORT4>
{};
template <>
struct VertexTypeFlags<D3DVT_SHORT_NORM, 2>
: VertexTypeFlagsHelper<D3DDTCAPS_SHORT2N, D3DDECLTYPE_SHORT2N>
{};
template <>
struct VertexTypeFlags<D3DVT_SHORT_NORM, 4>
: VertexTypeFlagsHelper<D3DDTCAPS_SHORT4N, D3DDECLTYPE_SHORT4N>
{};
template <>
struct VertexTypeFlags<D3DVT_UBYTE, 4> : VertexTypeFlagsHelper<D3DDTCAPS_UBYTE4, D3DDECLTYPE_UBYTE4>
{};
template <>
struct VertexTypeFlags<D3DVT_UBYTE_NORM, 4>
: VertexTypeFlagsHelper<D3DDTCAPS_UBYTE4N, D3DDECLTYPE_UBYTE4N>
{};
template <>
struct VertexTypeFlags<D3DVT_USHORT_NORM, 2>
: VertexTypeFlagsHelper<D3DDTCAPS_USHORT2N, D3DDECLTYPE_USHORT2N>
{};
template <>
struct VertexTypeFlags<D3DVT_USHORT_NORM, 4>
: VertexTypeFlagsHelper<D3DDTCAPS_USHORT4N, D3DDECLTYPE_USHORT4N>
{};
// VertexTypeMapping maps GL type & normalized flag to preferred and fallback D3D vertex types (as
// D3DVertexType enums).
template <GLenum GLtype, bool normalized>
struct VertexTypeMapping
{};
template <D3DVertexType Preferred, D3DVertexType Fallback = Preferred>
struct VertexTypeMappingBase
{
enum
{
preferred = Preferred
};
enum
{
fallback = Fallback
};
};
template <>
struct VertexTypeMapping<GL_BYTE, false> : VertexTypeMappingBase<D3DVT_SHORT>
{}; // Cast
template <>
struct VertexTypeMapping<GL_BYTE, true> : VertexTypeMappingBase<D3DVT_FLOAT>
{}; // Normalize
template <>
struct VertexTypeMapping<GL_UNSIGNED_BYTE, false> : VertexTypeMappingBase<D3DVT_UBYTE, D3DVT_FLOAT>
{}; // Identity, Cast
template <>
struct VertexTypeMapping<GL_UNSIGNED_BYTE, true>
: VertexTypeMappingBase<D3DVT_UBYTE_NORM, D3DVT_FLOAT>
{}; // Identity, Normalize
template <>
struct VertexTypeMapping<GL_SHORT, false> : VertexTypeMappingBase<D3DVT_SHORT>
{}; // Identity
template <>
struct VertexTypeMapping<GL_SHORT, true> : VertexTypeMappingBase<D3DVT_SHORT_NORM, D3DVT_FLOAT>
{}; // Cast, Normalize
template <>
struct VertexTypeMapping<GL_UNSIGNED_SHORT, false> : VertexTypeMappingBase<D3DVT_FLOAT>
{}; // Cast
template <>
struct VertexTypeMapping<GL_UNSIGNED_SHORT, true>
: VertexTypeMappingBase<D3DVT_USHORT_NORM, D3DVT_FLOAT>
{}; // Cast, Normalize
template <bool normalized>
struct VertexTypeMapping<GL_FIXED, normalized> : VertexTypeMappingBase<D3DVT_FLOAT>
{}; // FixedToFloat
template <bool normalized>
struct VertexTypeMapping<GL_FLOAT, normalized> : VertexTypeMappingBase<D3DVT_FLOAT>
{}; // Identity
// Given a GL type & norm flag and a D3D type, ConversionRule provides the type conversion rule
// (Cast, Normalize, Identity, FixedToFloat). The conversion rules themselves are defined in
// vertexconversion.h.
// Almost all cases are covered by Cast (including those that are actually Identity since Cast<T,T>
// knows it's an identity mapping).
template <GLenum fromType, bool normalized, unsigned int toType>
struct ConversionRule : Cast<typename GLToCType<fromType>::type, typename D3DToCType<toType>::type>
{};
// All conversions from normalized types to float use the Normalize operator.
template <GLenum fromType>
struct ConversionRule<fromType, true, D3DVT_FLOAT> : Normalize<typename GLToCType<fromType>::type>
{};
// Use a full specialization for this so that it preferentially matches ahead of the generic
// normalize-to-float rules.
template <>
struct ConversionRule<GL_FIXED, true, D3DVT_FLOAT> : FixedToFloat<GLint, 16>
{};
template <>
struct ConversionRule<GL_FIXED, false, D3DVT_FLOAT> : FixedToFloat<GLint, 16>
{};
// A 2-stage construction is used for DefaultVertexValues because float must use SimpleDefaultValues
// (i.e. 0/1) whether it is normalized or not.
template <class T, bool normalized>
struct DefaultVertexValuesStage2
{};
template <class T>
struct DefaultVertexValuesStage2<T, true> : NormalizedDefaultValues<T>
{};
template <class T>
struct DefaultVertexValuesStage2<T, false> : SimpleDefaultValues<T>
{};
// Work out the default value rule for a D3D type (expressed as the C type) and
template <class T, bool normalized>
struct DefaultVertexValues : DefaultVertexValuesStage2<T, normalized>
{};
template <bool normalized>
struct DefaultVertexValues<float, normalized> : SimpleDefaultValues<float>
{};
// Policy rules for use with Converter, to choose whether to use the preferred or fallback
// conversion. The fallback conversion produces an output that all D3D9 devices must support.
template <class T>
struct UsePreferred
{
enum
{
type = T::preferred
};
};
template <class T>
struct UseFallback
{
enum
{
type = T::fallback
};
};
// Converter ties it all together. Given an OpenGL type/norm/size and choice of preferred/fallback
// conversion, it provides all the members of the appropriate VertexDataConverter, the
// D3DCAPS9::DeclTypes flag in cap flag and the D3DDECLTYPE member needed for the vertex declaration
// in declflag.
template <GLenum fromType, bool normalized, int size, template <class T> class PreferenceRule>
struct Converter
: VertexDataConverter<
typename GLToCType<fromType>::type,
WidenRule<PreferenceRule<VertexTypeMapping<fromType, normalized>>::type, size>,
ConversionRule<fromType,
normalized,
PreferenceRule<VertexTypeMapping<fromType, normalized>>::type>,
DefaultVertexValues<typename D3DToCType<PreferenceRule<
VertexTypeMapping<fromType, normalized>>::type>::type,
normalized>>
{
private:
enum
{
d3dtype = PreferenceRule<VertexTypeMapping<fromType, normalized>>::type
};
enum
{
d3dsize = WidenRule<d3dtype, size>::finalWidth
};
public:
enum
{
capflag = VertexTypeFlags<d3dtype, d3dsize>::capflag
};
enum
{
declflag = VertexTypeFlags<d3dtype, d3dsize>::declflag
};
};
VertexFormat::VertexFormat()
: conversionType(VERTEX_CONVERT_NONE),
outputElementSize(0),
copyFunction(nullptr),
nativeFormat(D3DDECLTYPE_UNUSED),
componentType(GL_NONE)
{}
// Initialize a TranslationInfo
VertexFormat CreateVertexFormatInfo(bool identity,
size_t elementSize,
VertexCopyFunction copyFunc,
D3DDECLTYPE nativeFormat)
{
VertexFormat formatInfo;
formatInfo.conversionType = identity ? VERTEX_CONVERT_NONE : VERTEX_CONVERT_CPU;
formatInfo.outputElementSize = elementSize;
formatInfo.copyFunction = copyFunc;
formatInfo.nativeFormat = nativeFormat;
formatInfo.componentType = GetDeclTypeComponentType(nativeFormat);
return formatInfo;
}
#define TRANSLATION(type, norm, size, preferred) \
CreateVertexFormatInfo( \
Converter<type, norm, size, preferred>::identity, \
Converter<type, norm, size, preferred>::finalSize, \
Converter<type, norm, size, preferred>::convertArray, \
static_cast<D3DDECLTYPE>(Converter<type, norm, size, preferred>::declflag))
#define TRANSLATION_FOR_TYPE_NORM_SIZE(type, norm, size) \
{ \
Converter<type, norm, size, UsePreferred>::capflag, \
TRANSLATION(type, norm, size, UsePreferred), \
TRANSLATION(type, norm, size, UseFallback) \
}
#define TRANSLATIONS_FOR_TYPE(type) \
{ \
{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)}, \
{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)}, \
}
#define TRANSLATIONS_FOR_TYPE_NO_NORM(type) \
{ \
{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)}, \
{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)}, \
}
static inline unsigned int ComputeTypeIndex(GLenum type)
{
switch (type)
{
case GL_BYTE:
return 0;
case GL_UNSIGNED_BYTE:
return 1;
case GL_SHORT:
return 2;
case GL_UNSIGNED_SHORT:
return 3;
case GL_FIXED:
return 4;
case GL_FLOAT:
return 5;
default:
UNREACHABLE();
return 5;
}
}
const VertexFormat &GetVertexFormatInfo(DWORD supportedDeclTypes, angle::FormatID vertexFormatID)
{
static bool initialized = false;
static DWORD initializedDeclTypes = 0;
static VertexFormat formatConverters[NUM_GL_VERTEX_ATTRIB_TYPES][2][4];
if (initializedDeclTypes != supportedDeclTypes)
{
const TranslationDescription
translations[NUM_GL_VERTEX_ATTRIB_TYPES][2]
[4] = // [GL types as enumerated by typeIndex()][normalized][size-1]
{TRANSLATIONS_FOR_TYPE(GL_BYTE), TRANSLATIONS_FOR_TYPE(GL_UNSIGNED_BYTE),
TRANSLATIONS_FOR_TYPE(GL_SHORT), TRANSLATIONS_FOR_TYPE(GL_UNSIGNED_SHORT),
TRANSLATIONS_FOR_TYPE_NO_NORM(GL_FIXED), TRANSLATIONS_FOR_TYPE_NO_NORM(GL_FLOAT)};
for (unsigned int i = 0; i < NUM_GL_VERTEX_ATTRIB_TYPES; i++)
{
for (unsigned int j = 0; j < 2; j++)
{
for (unsigned int k = 0; k < 4; k++)
{
if (translations[i][j][k].capsFlag == 0 ||
(supportedDeclTypes & translations[i][j][k].capsFlag) != 0)
{
formatConverters[i][j][k] = translations[i][j][k].preferredConversion;
}
else
{
formatConverters[i][j][k] = translations[i][j][k].fallbackConversion;
}
}
}
}
initialized = true;
initializedDeclTypes = supportedDeclTypes;
}
const gl::VertexFormat &vertexFormat = gl::GetVertexFormatFromID(vertexFormatID);
// Pure integer attributes only supported in ES3.0
ASSERT(!vertexFormat.pureInteger);
return formatConverters[ComputeTypeIndex(vertexFormat.type)][vertexFormat.normalized]
[vertexFormat.components - 1];
}
} // namespace d3d9
} // namespace rx