Skip to content

A
angle
Commit 45965b10 by Geoff Lang
Options

Clean up copyvertex.h

* Move "private" functions into copyvertex.inl. * Capitalize global function names give them more descriptive names. * Use size_t for all dimensions. * Use uint8_t pointers instead of unsigned char pointers. Change-Id: I408cf7ebb28655c5811ad18979a20f4273d278cd Reviewed-on: https://chromium-review.googlesource.com/207373Reviewed-by: 's avatarBrandon Jones <bajones@chromium.org> Tested-by: 's avatarGeoff Lang <geofflang@chromium.org>
parent 301d161d
Showing with 411 additions and 402 deletions
projects/src/libGLESv2.vcxproj
...@@ -206,6 +206,7 @@ ...@@ -206,6 +206,7 @@
<None Include="..\..\src\angle.gyp"/> <None Include="..\..\src\angle.gyp"/>
<None Include="..\..\src\libGLESv2\libGLESv2.def"/> <None Include="..\..\src\libGLESv2\libGLESv2.def"/>
<None Include="..\..\src\libGLESv2\renderer\loadimage.inl"/> <None Include="..\..\src\libGLESv2\renderer\loadimage.inl"/>
<None Include="..\..\src\libGLESv2\renderer\copyvertex.inl"/>
<None Include="..\..\src\libGLESv2\renderer\generatemip.inl"/> <None Include="..\..\src\libGLESv2\renderer\generatemip.inl"/>
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
......
projects/src/libGLESv2.vcxproj.filters
...@@ -303,6 +303,9 @@ ...@@ -303,6 +303,9 @@
<ClInclude Include="..\..\src\libGLESv2\renderer\VertexArrayImpl.h"> <ClInclude Include="..\..\src\libGLESv2\renderer\VertexArrayImpl.h">
<Filter>src\libGLESv2\renderer</Filter> <Filter>src\libGLESv2\renderer</Filter>
</ClInclude> </ClInclude>
<None Include="..\..\src\libGLESv2\renderer\copyvertex.inl">
<Filter>src\libGLESv2\renderer</Filter>
</None>
<ClInclude Include="..\..\src\libGLESv2\renderer\SwapChain.h"> <ClInclude Include="..\..\src\libGLESv2\renderer\SwapChain.h">
<Filter>src\libGLESv2\renderer</Filter> <Filter>src\libGLESv2\renderer</Filter>
</ClInclude> </ClInclude>
......
src/libGLESv2.gypi
...@@ -118,6 +118,7 @@ ...@@ -118,6 +118,7 @@
'libGLESv2/renderer/copyimage.cpp', 'libGLESv2/renderer/copyimage.cpp',
'libGLESv2/renderer/copyimage.h', 'libGLESv2/renderer/copyimage.h',
'libGLESv2/renderer/copyvertex.h', 'libGLESv2/renderer/copyvertex.h',
'libGLESv2/renderer/copyvertex.inl',
'libGLESv2/renderer/generatemip.h', 'libGLESv2/renderer/generatemip.h',
'libGLESv2/renderer/generatemip.inl', 'libGLESv2/renderer/generatemip.inl',
'libGLESv2/renderer/imageformats.h', 'libGLESv2/renderer/imageformats.h',
......
src/libGLESv2/formatutils.h
...@@ -31,7 +31,7 @@ typedef void (*ColorReadFunction)(const void *source, void *dest); ...@@ -31,7 +31,7 @@ typedef void (*ColorReadFunction)(const void *source, void *dest);
typedef void (*ColorWriteFunction)(const void *source, void *dest); typedef void (*ColorWriteFunction)(const void *source, void *dest);
typedef void (*ColorCopyFunction)(const void *source, void *dest); typedef void (*ColorCopyFunction)(const void *source, void *dest);
typedef void (*VertexCopyFunction)(const void *input, size_t stride, size_t count, void *output); typedef void (*VertexCopyFunction)(const uint8_t *input, size_t stride, size_t count, uint8_t *output);
namespace gl namespace gl
{ {
......
src/libGLESv2/renderer/copyvertex.h
// //
// Copyright (c) 2013 The ANGLE Project Authors. All rights reserved. // Copyright (c) 2013-2014 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be // Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file. // found in the LICENSE file.
// //
...@@ -11,299 +11,25 @@ ...@@ -11,299 +11,25 @@
#include "common/mathutil.h" #include "common/mathutil.h"
// 'widenDefaultValueBits' gives the default value for the alpha channel (4th component) namespace rx
// the sentinel value 0 means we do not want to widen the input or add an alpha channel
template <typename T, unsigned int componentCount, unsigned int widenDefaultValueBits>
inline void copyVertexData(const void *input, size_t stride, size_t count, void *output)
{
const unsigned int attribSize = sizeof(T) * componentCount;
const T defaultValue = gl::bitCast<T>(widenDefaultValueBits);
const bool widen = (widenDefaultValueBits != 0);
if (attribSize == stride && !widen)
{
memcpy(output, input, count * attribSize);
}
else
{
unsigned int outputStride = widen ? 4 : componentCount;
for (unsigned int i = 0; i < count; i++)
{
const T *offsetInput = reinterpret_cast<const T*>(reinterpret_cast<const char*>(input) + i * stride);
T *offsetOutput = reinterpret_cast<T*>(output) + i * outputStride;
for (unsigned int j = 0; j < componentCount; j++)
{
offsetOutput[j] = offsetInput[j];
}
if (widen)
{
offsetOutput[3] = defaultValue;
}
}
}
}
template <unsigned int componentCount>
inline void copyFixedVertexData(const void* input, size_t stride, size_t count, void* output)
{ {
static const float divisor = 1.0f / (1 << 16);
for (unsigned int i = 0; i < count; i++)
{
const GLfixed* offsetInput = reinterpret_cast<const GLfixed*>(reinterpret_cast<const char*>(input) + stride * i);
float* offsetOutput = reinterpret_cast<float*>(output) + i * componentCount;
for (unsigned int j = 0; j < componentCount; j++) // 'widenDefaultValueBits' gives the default value for the alpha channel (4th component)
{ // the sentinel value 0 means we do not want to widen the input or add an alpha channel
offsetOutput[j] = static_cast<float>(offsetInput[j]) * divisor; template <typename T, size_t componentCount, uint32_t widenDefaultValueBits>
} inline void CopyNativeVertexData(const uint8_t *input, size_t stride, size_t count, uint8_t *output);
}
}
template <typename T, unsigned int componentCount, bool normalized>
inline void copyToFloatVertexData(const void* input, size_t stride, size_t count, void* output)
{
typedef std::numeric_limits<T> NL;
for (unsigned int i = 0; i < count; i++)
{
const T *offsetInput = reinterpret_cast<const T*>(reinterpret_cast<const char*>(input) + stride * i);
float *offsetOutput = reinterpret_cast<float*>(output) + i * componentCount;
for (unsigned int j = 0; j < componentCount; j++)
{
if (normalized)
{
if (NL::is_signed)
{
const float divisor = 1.0f / (2 * static_cast<float>(NL::max()) + 1);
offsetOutput[j] = (2 * static_cast<float>(offsetInput[j]) + 1) * divisor;
}
else
{
offsetOutput[j] = static_cast<float>(offsetInput[j]) / NL::max();
}
}
else
{
offsetOutput[j] = static_cast<float>(offsetInput[j]);
}
}
}
}
inline void copyPackedUnsignedVertexData(const void* input, size_t stride, size_t count, void* output)
{
const unsigned int attribSize = 4;
if (attribSize == stride) template <size_t componentCount>
{ inline void Copy32FixedTo32FVertexData(const uint8_t *input, size_t stride, size_t count, uint8_t *output);
memcpy(output, input, count * attribSize);
}
else
{
for (unsigned int i = 0; i < count; i++)
{
const GLuint *offsetInput = reinterpret_cast<const GLuint*>(reinterpret_cast<const char*>(input) + (i * stride));
GLuint *offsetOutput = reinterpret_cast<GLuint*>(output) + (i * attribSize);
offsetOutput[i] = offsetInput[i]; template <typename T, size_t componentCount, bool normalized>
} inline void CopyTo32FVertexData(const uint8_t *input, size_t stride, size_t count, uint8_t *output);
}
}
template <bool isSigned, bool normalized, bool toFloat> template <bool isSigned, bool normalized, bool toFloat>
static inline void copyPackedRGB(unsigned int data, void *output) inline void CopyXYZ10W2ToXYZW32FVertexData(const uint8_t *input, size_t stride, size_t count, uint8_t *output);
{
const unsigned int rgbSignMask = 0x200; // 1 set at the 9 bit
const unsigned int negativeMask = 0xFFFFFC00; // All bits from 10 to 31 set to 1
if (toFloat)
{
GLfloat *floatOutput = reinterpret_cast<GLfloat*>(output);
if (isSigned)
{
GLfloat finalValue = 0;
if (data & rgbSignMask)
{
int negativeNumber = data | negativeMask;
finalValue = static_cast<GLfloat>(negativeNumber);
}
else
{
finalValue = static_cast<GLfloat>(data);
}
if (normalized)
{
const int maxValue = 0x1FF; // 1 set in bits 0 through 8
const int minValue = 0xFFFFFE01; // Inverse of maxValue
// A 10-bit two's complement number has the possibility of being minValue - 1 but
// OpenGL's normalization rules dictate that it should be clamped to minValue in this
// case.
if (finalValue < minValue)
{
finalValue = minValue;
}
const int halfRange = (maxValue - minValue) >> 1;
*floatOutput = ((finalValue - minValue) / halfRange) - 1.0f;
}
else
{
*floatOutput = finalValue;
}
}
else
{
if (normalized)
{
const unsigned int maxValue = 0x3FF; // 1 set in bits 0 through 9
*floatOutput = static_cast<GLfloat>(data) / static_cast<GLfloat>(maxValue);
}
else
{
*floatOutput = static_cast<GLfloat>(data);
}
}
}
else
{
if (isSigned)
{
GLshort *intOutput = reinterpret_cast<GLshort*>(output);
if (data & rgbSignMask)
{
*intOutput = data | negativeMask;
}
else
{
*intOutput = data;
}
}
else
{
GLushort *uintOutput = reinterpret_cast<GLushort*>(output);
*uintOutput = data;
}
}
}
template <bool isSigned, bool normalized, bool toFloat>
inline void copyPackedAlpha(unsigned int data, void *output)
{
if (toFloat)
{
GLfloat *floatOutput = reinterpret_cast<GLfloat*>(output);
if (isSigned)
{
if (normalized)
{
switch (data)
{
case 0x0: *floatOutput = 0.0f; break;
case 0x1: *floatOutput = 1.0f; break;
case 0x2: *floatOutput = -1.0f; break;
case 0x3: *floatOutput = -1.0f; break;
default: UNREACHABLE();
}
}
else
{
switch (data)
{
case 0x0: *floatOutput = 0.0f; break;
case 0x1: *floatOutput = 1.0f; break;
case 0x2: *floatOutput = -2.0f; break;
case 0x3: *floatOutput = -1.0f; break;
default: UNREACHABLE();
}
}
}
else
{
if (normalized)
{
switch (data)
{
case 0x0: *floatOutput = 0.0f / 3.0f; break;
case 0x1: *floatOutput = 1.0f / 3.0f; break;
case 0x2: *floatOutput = 2.0f / 3.0f; break;
case 0x3: *floatOutput = 3.0f / 3.0f; break;
default: UNREACHABLE();
}
}
else
{
switch (data)
{
case 0x0: *floatOutput = 0.0f; break;
case 0x1: *floatOutput = 1.0f; break;
case 0x2: *floatOutput = 2.0f; break;
case 0x3: *floatOutput = 3.0f; break;
default: UNREACHABLE();
}
}
}
}
else
{
if (isSigned)
{
GLshort *intOutput = reinterpret_cast<GLshort*>(output);
switch (data)
{
case 0x0: *intOutput = 0; break;
case 0x1: *intOutput = 1; break;
case 0x2: *intOutput = -2; break;
case 0x3: *intOutput = -1; break;
default: UNREACHABLE();
}
}
else
{
GLushort *uintOutput = reinterpret_cast<GLushort*>(output);
switch (data)
{
case 0x0: *uintOutput = 0; break;
case 0x1: *uintOutput = 1; break;
case 0x2: *uintOutput = 2; break;
case 0x3: *uintOutput = 3; break;
default: UNREACHABLE();
}
}
}
} }
template <bool isSigned, bool normalized, bool toFloat> #include "copyvertex.inl"
inline void copyPackedVertexData(const void* input, size_t stride, size_t count, void* output)
{
const unsigned int outputComponentSize = toFloat ? 4 : 2;
const unsigned int componentCount = 4;
const unsigned int rgbMask = 0x3FF; // 1 set in bits 0 through 9
const unsigned int redShift = 0; // red is bits 0 through 9
const unsigned int greenShift = 10; // green is bits 10 through 19
const unsigned int blueShift = 20; // blue is bits 20 through 29
const unsigned int alphaMask = 0x3; // 1 set in bits 0 and 1
const unsigned int alphaShift = 30; // Alpha is the 30 and 31 bits
for (unsigned int i = 0; i < count; i++)
{
GLuint packedValue = *reinterpret_cast<const GLuint*>(reinterpret_cast<const char*>(input) + (i * stride));
GLbyte *offsetOutput = reinterpret_cast<GLbyte*>(output) + (i * outputComponentSize * componentCount);
copyPackedRGB<isSigned, normalized, toFloat>( (packedValue >> redShift) & rgbMask, offsetOutput + (0 * outputComponentSize));
copyPackedRGB<isSigned, normalized, toFloat>( (packedValue >> greenShift) & rgbMask, offsetOutput + (1 * outputComponentSize));
copyPackedRGB<isSigned, normalized, toFloat>( (packedValue >> blueShift) & rgbMask, offsetOutput + (2 * outputComponentSize));
copyPackedAlpha<isSigned, normalized, toFloat>((packedValue >> alphaShift) & alphaMask, offsetOutput + (3* outputComponentSize));
}
}
#endif // LIBGLESV2_RENDERER_COPYVERTEX_H_ #endif // LIBGLESV2_RENDERER_COPYVERTEX_H_
src/libGLESv2/renderer/copyvertex.inl 0 → 100644
//
// Copyright (c) 2014 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.
//
namespace rx
{
template <typename T, size_t componentCount, uint32_t widenDefaultValueBits>
inline void CopyNativeVertexData(const uint8_t *input, size_t stride, size_t count, uint8_t *output)
{
const size_t attribSize = sizeof(T)* componentCount;
const T defaultValue = gl::bitCast<T>(widenDefaultValueBits);
const bool widen = (widenDefaultValueBits != 0);
if (attribSize == stride && !widen)
{
memcpy(output, input, count * attribSize);
}
else
{
size_t outputStride = widen ? 4 : componentCount;
for (size_t i = 0; i < count; i++)
{
const T *offsetInput = reinterpret_cast<const T*>(input + (i * stride));
T *offsetOutput = reinterpret_cast<T*>(output) + i * outputStride;
for (size_t j = 0; j < componentCount; j++)
{
offsetOutput[j] = offsetInput[j];
}
if (widen)
{
offsetOutput[3] = defaultValue;
}
}
}
}
template <size_t componentCount>
inline void Copy32FixedTo32FVertexData(const uint8_t *input, size_t stride, size_t count, uint8_t *output)
{
static const float divisor = 1.0f / (1 << 16);
for (size_t i = 0; i < count; i++)
{
const GLfixed* offsetInput = reinterpret_cast<const GLfixed*>(input + (stride * i));
float* offsetOutput = reinterpret_cast<float*>(output) + i * componentCount;
for (size_t j = 0; j < componentCount; j++)
{
offsetOutput[j] = static_cast<float>(offsetInput[j]) * divisor;
}
}
}
template <typename T, size_t componentCount, bool normalized>
inline void CopyTo32FVertexData(const uint8_t *input, size_t stride, size_t count, uint8_t *output)
{
typedef std::numeric_limits<T> NL;
for (size_t i = 0; i < count; i++)
{
const T *offsetInput = reinterpret_cast<const T*>(input + (stride * i));
float *offsetOutput = reinterpret_cast<float*>(output) + i * componentCount;
for (size_t j = 0; j < componentCount; j++)
{
if (normalized)
{
if (NL::is_signed)
{
const float divisor = 1.0f / (2 * static_cast<float>(NL::max()) + 1);
offsetOutput[j] = (2 * static_cast<float>(offsetInput[j]) + 1) * divisor;
}
else
{
offsetOutput[j] = static_cast<float>(offsetInput[j]) / NL::max();
}
}
else
{
offsetOutput[j] = static_cast<float>(offsetInput[j]);
}
}
}
}
namespace priv
{
template <bool isSigned, bool normalized, bool toFloat>
static inline void CopyPackedRGB(uint32_t data, uint8_t *output)
{
const uint32_t rgbSignMask = 0x200; // 1 set at the 9 bit
const uint32_t negativeMask = 0xFFFFFC00; // All bits from 10 to 31 set to 1
if (toFloat)
{
GLfloat *floatOutput = reinterpret_cast<GLfloat*>(output);
if (isSigned)
{
GLfloat finalValue = 0;
if (data & rgbSignMask)
{
int negativeNumber = data | negativeMask;
finalValue = static_cast<GLfloat>(negativeNumber);
}
else
{
finalValue = static_cast<GLfloat>(data);
}
if (normalized)
{
const int32_t maxValue = 0x1FF; // 1 set in bits 0 through 8
const int32_t minValue = 0xFFFFFE01; // Inverse of maxValue
// A 10-bit two's complement number has the possibility of being minValue - 1 but
// OpenGL's normalization rules dictate that it should be clamped to minValue in this
// case.
if (finalValue < minValue)
{
finalValue = minValue;
}
const int32_t halfRange = (maxValue - minValue) >> 1;
*floatOutput = ((finalValue - minValue) / halfRange) - 1.0f;
}
else
{
*floatOutput = finalValue;
}
}
else
{
if (normalized)
{
const uint32_t maxValue = 0x3FF; // 1 set in bits 0 through 9
*floatOutput = static_cast<GLfloat>(data) / static_cast<GLfloat>(maxValue);
}
else
{
*floatOutput = static_cast<GLfloat>(data);
}
}
}
else
{
if (isSigned)
{
GLshort *intOutput = reinterpret_cast<GLshort*>(output);
if (data & rgbSignMask)
{
*intOutput = data | negativeMask;
}
else
{
*intOutput = data;
}
}
else
{
GLushort *uintOutput = reinterpret_cast<GLushort*>(output);
*uintOutput = data;
}
}
}
template <bool isSigned, bool normalized, bool toFloat>
inline void CopyPackedAlpha(uint32_t data, uint8_t *output)
{
if (toFloat)
{
GLfloat *floatOutput = reinterpret_cast<GLfloat*>(output);
if (isSigned)
{
if (normalized)
{
switch (data)
{
case 0x0: *floatOutput = 0.0f; break;
case 0x1: *floatOutput = 1.0f; break;
case 0x2: *floatOutput = -1.0f; break;
case 0x3: *floatOutput = -1.0f; break;
default: UNREACHABLE();
}
}
else
{
switch (data)
{
case 0x0: *floatOutput = 0.0f; break;
case 0x1: *floatOutput = 1.0f; break;
case 0x2: *floatOutput = -2.0f; break;
case 0x3: *floatOutput = -1.0f; break;
default: UNREACHABLE();
}
}
}
else
{
if (normalized)
{
switch (data)
{
case 0x0: *floatOutput = 0.0f / 3.0f; break;
case 0x1: *floatOutput = 1.0f / 3.0f; break;
case 0x2: *floatOutput = 2.0f / 3.0f; break;
case 0x3: *floatOutput = 3.0f / 3.0f; break;
default: UNREACHABLE();
}
}
else
{
switch (data)
{
case 0x0: *floatOutput = 0.0f; break;
case 0x1: *floatOutput = 1.0f; break;
case 0x2: *floatOutput = 2.0f; break;
case 0x3: *floatOutput = 3.0f; break;
default: UNREACHABLE();
}
}
}
}
else
{
if (isSigned)
{
GLshort *intOutput = reinterpret_cast<GLshort*>(output);
switch (data)
{
case 0x0: *intOutput = 0; break;
case 0x1: *intOutput = 1; break;
case 0x2: *intOutput = -2; break;
case 0x3: *intOutput = -1; break;
default: UNREACHABLE();
}
}
else
{
GLushort *uintOutput = reinterpret_cast<GLushort*>(output);
switch (data)
{
case 0x0: *uintOutput = 0; break;
case 0x1: *uintOutput = 1; break;
case 0x2: *uintOutput = 2; break;
case 0x3: *uintOutput = 3; break;
default: UNREACHABLE();
}
}
}
}
}
template <bool isSigned, bool normalized, bool toFloat>
inline void CopyXYZ10W2ToXYZW32FVertexData(const uint8_t *input, size_t stride, size_t count, uint8_t *output)
{
const size_t outputComponentSize = toFloat ? 4 : 2;
const size_t componentCount = 4;
const uint32_t rgbMask = 0x3FF; // 1 set in bits 0 through 9
const size_t redShift = 0; // red is bits 0 through 9
const size_t greenShift = 10; // green is bits 10 through 19
const size_t blueShift = 20; // blue is bits 20 through 29
const uint32_t alphaMask = 0x3; // 1 set in bits 0 and 1
const size_t alphaShift = 30; // Alpha is the 30 and 31 bits
for (size_t i = 0; i < count; i++)
{
GLuint packedValue = *reinterpret_cast<const GLuint*>(input + (i * stride));
uint8_t *offsetOutput = output + (i * outputComponentSize * componentCount);
priv::CopyPackedRGB<isSigned, normalized, toFloat>( (packedValue >> redShift) & rgbMask, offsetOutput + (0 * outputComponentSize));
priv::CopyPackedRGB<isSigned, normalized, toFloat>( (packedValue >> greenShift) & rgbMask, offsetOutput + (1 * outputComponentSize));
priv::CopyPackedRGB<isSigned, normalized, toFloat>( (packedValue >> blueShift) & rgbMask, offsetOutput + (2 * outputComponentSize));
priv::CopyPackedAlpha<isSigned, normalized, toFloat>((packedValue >> alphaShift) & alphaMask, offsetOutput + (3 * outputComponentSize));
}
}
}
src/libGLESv2/renderer/d3d/d3d11/VertexBuffer11.cpp
...@@ -83,24 +83,24 @@ bool VertexBuffer11::storeVertexAttributes(const gl::VertexAttribute &attrib, co ...@@ -83,24 +83,24 @@ bool VertexBuffer11::storeVertexAttributes(const gl::VertexAttribute &attrib, co
return false; return false;
} }
char* output = reinterpret_cast<char*>(mappedResource.pData) + offset; uint8_t* output = reinterpret_cast<uint8_t*>(mappedResource.pData) + offset;
const char *input = NULL; const uint8_t *input = NULL;
if (attrib.enabled) if (attrib.enabled)
{ {
if (buffer) if (buffer)
{ {
Buffer11 *storage = Buffer11::makeBuffer11(buffer->getImplementation()); Buffer11 *storage = Buffer11::makeBuffer11(buffer->getImplementation());
input = static_cast<const char*>(storage->getData()) + static_cast<int>(attrib.offset); input = static_cast<const uint8_t*>(storage->getData()) + static_cast<int>(attrib.offset);
} }
else else
{ {
input = static_cast<const char*>(attrib.pointer); input = static_cast<const uint8_t*>(attrib.pointer);
} }
} }
else else
{ {
input = reinterpret_cast<const char*>(currentValue.FloatValues); input = reinterpret_cast<const uint8_t*>(currentValue.FloatValues);
} }
if (instances == 0 || attrib.divisor == 0) if (instances == 0 || attrib.divisor == 0)
......
src/libGLESv2/renderer/d3d/d3d11/formatutils11.cpp
...@@ -909,148 +909,148 @@ static D3D11VertexFormatInfoMap BuildD3D11VertexFormatInfoMap() ...@@ -909,148 +909,148 @@ static D3D11VertexFormatInfoMap BuildD3D11VertexFormatInfoMap()
// //
// GL_BYTE -- un-normalized // GL_BYTE -- un-normalized
AddVertexFormatInfo(&map, GL_BYTE, GL_FALSE, 1, VERTEX_CONVERT_GPU, DXGI_FORMAT_R8_SINT, &copyVertexData<GLbyte, 1, 0>); AddVertexFormatInfo(&map, GL_BYTE, GL_FALSE, 1, VERTEX_CONVERT_GPU, DXGI_FORMAT_R8_SINT, &CopyNativeVertexData<GLbyte, 1, 0>);
AddVertexFormatInfo(&map, GL_BYTE, GL_FALSE, 2, VERTEX_CONVERT_GPU, DXGI_FORMAT_R8G8_SINT, &copyVertexData<GLbyte, 2, 0>); AddVertexFormatInfo(&map, GL_BYTE, GL_FALSE, 2, VERTEX_CONVERT_GPU, DXGI_FORMAT_R8G8_SINT, &CopyNativeVertexData<GLbyte, 2, 0>);
AddVertexFormatInfo(&map, GL_BYTE, GL_FALSE, 3, VERTEX_CONVERT_BOTH, DXGI_FORMAT_R8G8B8A8_SINT, &copyVertexData<GLbyte, 3, 1>); AddVertexFormatInfo(&map, GL_BYTE, GL_FALSE, 3, VERTEX_CONVERT_BOTH, DXGI_FORMAT_R8G8B8A8_SINT, &CopyNativeVertexData<GLbyte, 3, 1>);
AddVertexFormatInfo(&map, GL_BYTE, GL_FALSE, 4, VERTEX_CONVERT_GPU, DXGI_FORMAT_R8G8B8A8_SINT, &copyVertexData<GLbyte, 4, 0>); AddVertexFormatInfo(&map, GL_BYTE, GL_FALSE, 4, VERTEX_CONVERT_GPU, DXGI_FORMAT_R8G8B8A8_SINT, &CopyNativeVertexData<GLbyte, 4, 0>);
// GL_BYTE -- normalized // GL_BYTE -- normalized
AddVertexFormatInfo(&map, GL_BYTE, GL_TRUE, 1, VERTEX_CONVERT_NONE, DXGI_FORMAT_R8_SNORM, &copyVertexData<GLbyte, 1, 0>); AddVertexFormatInfo(&map, GL_BYTE, GL_TRUE, 1, VERTEX_CONVERT_NONE, DXGI_FORMAT_R8_SNORM, &CopyNativeVertexData<GLbyte, 1, 0>);
AddVertexFormatInfo(&map, GL_BYTE, GL_TRUE, 2, VERTEX_CONVERT_NONE, DXGI_FORMAT_R8G8_SNORM, &copyVertexData<GLbyte, 2, 0>); AddVertexFormatInfo(&map, GL_BYTE, GL_TRUE, 2, VERTEX_CONVERT_NONE, DXGI_FORMAT_R8G8_SNORM, &CopyNativeVertexData<GLbyte, 2, 0>);
AddVertexFormatInfo(&map, GL_BYTE, GL_TRUE, 3, VERTEX_CONVERT_CPU, DXGI_FORMAT_R8G8B8A8_SNORM, &copyVertexData<GLbyte, 3, INT8_MAX>); AddVertexFormatInfo(&map, GL_BYTE, GL_TRUE, 3, VERTEX_CONVERT_CPU, DXGI_FORMAT_R8G8B8A8_SNORM, &CopyNativeVertexData<GLbyte, 3, INT8_MAX>);
AddVertexFormatInfo(&map, GL_BYTE, GL_TRUE, 4, VERTEX_CONVERT_NONE, DXGI_FORMAT_R8G8B8A8_SNORM, &copyVertexData<GLbyte, 4, 0>); AddVertexFormatInfo(&map, GL_BYTE, GL_TRUE, 4, VERTEX_CONVERT_NONE, DXGI_FORMAT_R8G8B8A8_SNORM, &CopyNativeVertexData<GLbyte, 4, 0>);
// GL_UNSIGNED_BYTE -- un-normalized // GL_UNSIGNED_BYTE -- un-normalized
AddVertexFormatInfo(&map, GL_UNSIGNED_BYTE, GL_FALSE, 1, VERTEX_CONVERT_GPU, DXGI_FORMAT_R8_UINT, &copyVertexData<GLubyte, 1, 0>); AddVertexFormatInfo(&map, GL_UNSIGNED_BYTE, GL_FALSE, 1, VERTEX_CONVERT_GPU, DXGI_FORMAT_R8_UINT, &CopyNativeVertexData<GLubyte, 1, 0>);
AddVertexFormatInfo(&map, GL_UNSIGNED_BYTE, GL_FALSE, 2, VERTEX_CONVERT_GPU, DXGI_FORMAT_R8G8_UINT, &copyVertexData<GLubyte, 2, 0>); AddVertexFormatInfo(&map, GL_UNSIGNED_BYTE, GL_FALSE, 2, VERTEX_CONVERT_GPU, DXGI_FORMAT_R8G8_UINT, &CopyNativeVertexData<GLubyte, 2, 0>);
AddVertexFormatInfo(&map, GL_UNSIGNED_BYTE, GL_FALSE, 3, VERTEX_CONVERT_BOTH, DXGI_FORMAT_R8G8B8A8_UINT, &copyVertexData<GLubyte, 3, 1>); AddVertexFormatInfo(&map, GL_UNSIGNED_BYTE, GL_FALSE, 3, VERTEX_CONVERT_BOTH, DXGI_FORMAT_R8G8B8A8_UINT, &CopyNativeVertexData<GLubyte, 3, 1>);
AddVertexFormatInfo(&map, GL_UNSIGNED_BYTE, GL_FALSE, 4, VERTEX_CONVERT_GPU, DXGI_FORMAT_R8G8B8A8_UINT, &copyVertexData<GLubyte, 4, 0>); AddVertexFormatInfo(&map, GL_UNSIGNED_BYTE, GL_FALSE, 4, VERTEX_CONVERT_GPU, DXGI_FORMAT_R8G8B8A8_UINT, &CopyNativeVertexData<GLubyte, 4, 0>);
// GL_UNSIGNED_BYTE -- normalized // GL_UNSIGNED_BYTE -- normalized
AddVertexFormatInfo(&map, GL_UNSIGNED_BYTE, GL_TRUE, 1, VERTEX_CONVERT_NONE, DXGI_FORMAT_R8_UNORM, &copyVertexData<GLubyte, 1, 0>); AddVertexFormatInfo(&map, GL_UNSIGNED_BYTE, GL_TRUE, 1, VERTEX_CONVERT_NONE, DXGI_FORMAT_R8_UNORM, &CopyNativeVertexData<GLubyte, 1, 0>);
AddVertexFormatInfo(&map, GL_UNSIGNED_BYTE, GL_TRUE, 2, VERTEX_CONVERT_NONE, DXGI_FORMAT_R8G8_UNORM, &copyVertexData<GLubyte, 2, 0>); AddVertexFormatInfo(&map, GL_UNSIGNED_BYTE, GL_TRUE, 2, VERTEX_CONVERT_NONE, DXGI_FORMAT_R8G8_UNORM, &CopyNativeVertexData<GLubyte, 2, 0>);
AddVertexFormatInfo(&map, GL_UNSIGNED_BYTE, GL_TRUE, 3, VERTEX_CONVERT_CPU, DXGI_FORMAT_R8G8B8A8_UNORM, &copyVertexData<GLubyte, 3, UINT8_MAX>); AddVertexFormatInfo(&map, GL_UNSIGNED_BYTE, GL_TRUE, 3, VERTEX_CONVERT_CPU, DXGI_FORMAT_R8G8B8A8_UNORM, &CopyNativeVertexData<GLubyte, 3, UINT8_MAX>);
AddVertexFormatInfo(&map, GL_UNSIGNED_BYTE, GL_TRUE, 4, VERTEX_CONVERT_NONE, DXGI_FORMAT_R8G8B8A8_UNORM, &copyVertexData<GLubyte, 4, 0>); AddVertexFormatInfo(&map, GL_UNSIGNED_BYTE, GL_TRUE, 4, VERTEX_CONVERT_NONE, DXGI_FORMAT_R8G8B8A8_UNORM, &CopyNativeVertexData<GLubyte, 4, 0>);
// GL_SHORT -- un-normalized // GL_SHORT -- un-normalized
AddVertexFormatInfo(&map, GL_SHORT, GL_FALSE, 1, VERTEX_CONVERT_GPU, DXGI_FORMAT_R16_SINT, &copyVertexData<GLshort, 1, 0>); AddVertexFormatInfo(&map, GL_SHORT, GL_FALSE, 1, VERTEX_CONVERT_GPU, DXGI_FORMAT_R16_SINT, &CopyNativeVertexData<GLshort, 1, 0>);
AddVertexFormatInfo(&map, GL_SHORT, GL_FALSE, 2, VERTEX_CONVERT_GPU, DXGI_FORMAT_R16G16_SINT, &copyVertexData<GLshort, 2, 0>); AddVertexFormatInfo(&map, GL_SHORT, GL_FALSE, 2, VERTEX_CONVERT_GPU, DXGI_FORMAT_R16G16_SINT, &CopyNativeVertexData<GLshort, 2, 0>);
AddVertexFormatInfo(&map, GL_SHORT, GL_FALSE, 3, VERTEX_CONVERT_BOTH, DXGI_FORMAT_R16G16B16A16_SINT, &copyVertexData<GLshort, 4, 1>); AddVertexFormatInfo(&map, GL_SHORT, GL_FALSE, 3, VERTEX_CONVERT_BOTH, DXGI_FORMAT_R16G16B16A16_SINT, &CopyNativeVertexData<GLshort, 4, 1>);
AddVertexFormatInfo(&map, GL_SHORT, GL_FALSE, 4, VERTEX_CONVERT_GPU, DXGI_FORMAT_R16G16B16A16_SINT, &copyVertexData<GLshort, 4, 0>); AddVertexFormatInfo(&map, GL_SHORT, GL_FALSE, 4, VERTEX_CONVERT_GPU, DXGI_FORMAT_R16G16B16A16_SINT, &CopyNativeVertexData<GLshort, 4, 0>);
// GL_SHORT -- normalized // GL_SHORT -- normalized
AddVertexFormatInfo(&map, GL_SHORT, GL_TRUE, 1, VERTEX_CONVERT_NONE, DXGI_FORMAT_R16_SNORM, &copyVertexData<GLshort, 1, 0>); AddVertexFormatInfo(&map, GL_SHORT, GL_TRUE, 1, VERTEX_CONVERT_NONE, DXGI_FORMAT_R16_SNORM, &CopyNativeVertexData<GLshort, 1, 0>);
AddVertexFormatInfo(&map, GL_SHORT, GL_TRUE, 2, VERTEX_CONVERT_NONE, DXGI_FORMAT_R16G16_SNORM, &copyVertexData<GLshort, 2, 0>); AddVertexFormatInfo(&map, GL_SHORT, GL_TRUE, 2, VERTEX_CONVERT_NONE, DXGI_FORMAT_R16G16_SNORM, &CopyNativeVertexData<GLshort, 2, 0>);
AddVertexFormatInfo(&map, GL_SHORT, GL_TRUE, 3, VERTEX_CONVERT_CPU, DXGI_FORMAT_R16G16B16A16_SNORM, &copyVertexData<GLshort, 3, INT16_MAX>); AddVertexFormatInfo(&map, GL_SHORT, GL_TRUE, 3, VERTEX_CONVERT_CPU, DXGI_FORMAT_R16G16B16A16_SNORM, &CopyNativeVertexData<GLshort, 3, INT16_MAX>);
AddVertexFormatInfo(&map, GL_SHORT, GL_TRUE, 4, VERTEX_CONVERT_NONE, DXGI_FORMAT_R16G16B16A16_SNORM, &copyVertexData<GLshort, 4, 0>); AddVertexFormatInfo(&map, GL_SHORT, GL_TRUE, 4, VERTEX_CONVERT_NONE, DXGI_FORMAT_R16G16B16A16_SNORM, &CopyNativeVertexData<GLshort, 4, 0>);
// GL_UNSIGNED_SHORT -- un-normalized // GL_UNSIGNED_SHORT -- un-normalized
AddVertexFormatInfo(&map, GL_UNSIGNED_SHORT, GL_FALSE, 1, VERTEX_CONVERT_GPU, DXGI_FORMAT_R16_UINT, &copyVertexData<GLushort, 1, 0>); AddVertexFormatInfo(&map, GL_UNSIGNED_SHORT, GL_FALSE, 1, VERTEX_CONVERT_GPU, DXGI_FORMAT_R16_UINT, &CopyNativeVertexData<GLushort, 1, 0>);
AddVertexFormatInfo(&map, GL_UNSIGNED_SHORT, GL_FALSE, 2, VERTEX_CONVERT_GPU, DXGI_FORMAT_R16G16_UINT, &copyVertexData<GLushort, 2, 0>); AddVertexFormatInfo(&map, GL_UNSIGNED_SHORT, GL_FALSE, 2, VERTEX_CONVERT_GPU, DXGI_FORMAT_R16G16_UINT, &CopyNativeVertexData<GLushort, 2, 0>);
AddVertexFormatInfo(&map, GL_UNSIGNED_SHORT, GL_FALSE, 3, VERTEX_CONVERT_BOTH, DXGI_FORMAT_R16G16B16A16_UINT, &copyVertexData<GLushort, 3, 1>); AddVertexFormatInfo(&map, GL_UNSIGNED_SHORT, GL_FALSE, 3, VERTEX_CONVERT_BOTH, DXGI_FORMAT_R16G16B16A16_UINT, &CopyNativeVertexData<GLushort, 3, 1>);
AddVertexFormatInfo(&map, GL_UNSIGNED_SHORT, GL_FALSE, 4, VERTEX_CONVERT_GPU, DXGI_FORMAT_R16G16B16A16_UINT, &copyVertexData<GLushort, 4, 0>); AddVertexFormatInfo(&map, GL_UNSIGNED_SHORT, GL_FALSE, 4, VERTEX_CONVERT_GPU, DXGI_FORMAT_R16G16B16A16_UINT, &CopyNativeVertexData<GLushort, 4, 0>);
// GL_UNSIGNED_SHORT -- normalized // GL_UNSIGNED_SHORT -- normalized
AddVertexFormatInfo(&map, GL_UNSIGNED_SHORT, GL_TRUE, 1, VERTEX_CONVERT_NONE, DXGI_FORMAT_R16_UNORM, &copyVertexData<GLushort, 1, 0>); AddVertexFormatInfo(&map, GL_UNSIGNED_SHORT, GL_TRUE, 1, VERTEX_CONVERT_NONE, DXGI_FORMAT_R16_UNORM, &CopyNativeVertexData<GLushort, 1, 0>);
AddVertexFormatInfo(&map, GL_UNSIGNED_SHORT, GL_TRUE, 2, VERTEX_CONVERT_NONE, DXGI_FORMAT_R16G16_UNORM, &copyVertexData<GLushort, 2, 0>); AddVertexFormatInfo(&map, GL_UNSIGNED_SHORT, GL_TRUE, 2, VERTEX_CONVERT_NONE, DXGI_FORMAT_R16G16_UNORM, &CopyNativeVertexData<GLushort, 2, 0>);
AddVertexFormatInfo(&map, GL_UNSIGNED_SHORT, GL_TRUE, 3, VERTEX_CONVERT_CPU, DXGI_FORMAT_R16G16B16A16_UNORM, &copyVertexData<GLushort, 3, UINT16_MAX>); AddVertexFormatInfo(&map, GL_UNSIGNED_SHORT, GL_TRUE, 3, VERTEX_CONVERT_CPU, DXGI_FORMAT_R16G16B16A16_UNORM, &CopyNativeVertexData<GLushort, 3, UINT16_MAX>);
AddVertexFormatInfo(&map, GL_UNSIGNED_SHORT, GL_TRUE, 4, VERTEX_CONVERT_NONE, DXGI_FORMAT_R16G16B16A16_UNORM, &copyVertexData<GLushort, 4, 0>); AddVertexFormatInfo(&map, GL_UNSIGNED_SHORT, GL_TRUE, 4, VERTEX_CONVERT_NONE, DXGI_FORMAT_R16G16B16A16_UNORM, &CopyNativeVertexData<GLushort, 4, 0>);
// GL_INT -- un-normalized // GL_INT -- un-normalized
AddVertexFormatInfo(&map, GL_INT, GL_FALSE, 1, VERTEX_CONVERT_GPU, DXGI_FORMAT_R32_SINT, &copyVertexData<GLint, 1, 0>); AddVertexFormatInfo(&map, GL_INT, GL_FALSE, 1, VERTEX_CONVERT_GPU, DXGI_FORMAT_R32_SINT, &CopyNativeVertexData<GLint, 1, 0>);
AddVertexFormatInfo(&map, GL_INT, GL_FALSE, 2, VERTEX_CONVERT_GPU, DXGI_FORMAT_R32G32_SINT, &copyVertexData<GLint, 2, 0>); AddVertexFormatInfo(&map, GL_INT, GL_FALSE, 2, VERTEX_CONVERT_GPU, DXGI_FORMAT_R32G32_SINT, &CopyNativeVertexData<GLint, 2, 0>);
AddVertexFormatInfo(&map, GL_INT, GL_FALSE, 3, VERTEX_CONVERT_GPU, DXGI_FORMAT_R32G32B32_SINT, &copyVertexData<GLint, 3, 0>); AddVertexFormatInfo(&map, GL_INT, GL_FALSE, 3, VERTEX_CONVERT_GPU, DXGI_FORMAT_R32G32B32_SINT, &CopyNativeVertexData<GLint, 3, 0>);
AddVertexFormatInfo(&map, GL_INT, GL_FALSE, 4, VERTEX_CONVERT_GPU, DXGI_FORMAT_R32G32B32A32_SINT, &copyVertexData<GLint, 4, 0>); AddVertexFormatInfo(&map, GL_INT, GL_FALSE, 4, VERTEX_CONVERT_GPU, DXGI_FORMAT_R32G32B32A32_SINT, &CopyNativeVertexData<GLint, 4, 0>);
// GL_INT -- normalized // GL_INT -- normalized
AddVertexFormatInfo(&map, GL_INT, GL_TRUE, 1, VERTEX_CONVERT_CPU, DXGI_FORMAT_R32_FLOAT, &copyToFloatVertexData<GLint, 1, true>); AddVertexFormatInfo(&map, GL_INT, GL_TRUE, 1, VERTEX_CONVERT_CPU, DXGI_FORMAT_R32_FLOAT, &CopyTo32FVertexData<GLint, 1, true>);
AddVertexFormatInfo(&map, GL_INT, GL_TRUE, 2, VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32_FLOAT, &copyToFloatVertexData<GLint, 2, true>); AddVertexFormatInfo(&map, GL_INT, GL_TRUE, 2, VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32_FLOAT, &CopyTo32FVertexData<GLint, 2, true>);
AddVertexFormatInfo(&map, GL_INT, GL_TRUE, 3, VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32B32_FLOAT, &copyToFloatVertexData<GLint, 3, true>); AddVertexFormatInfo(&map, GL_INT, GL_TRUE, 3, VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32B32_FLOAT, &CopyTo32FVertexData<GLint, 3, true>);
AddVertexFormatInfo(&map, GL_INT, GL_TRUE, 4, VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32B32A32_FLOAT, &copyToFloatVertexData<GLint, 4, true>); AddVertexFormatInfo(&map, GL_INT, GL_TRUE, 4, VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32B32A32_FLOAT, &CopyTo32FVertexData<GLint, 4, true>);
// GL_UNSIGNED_INT -- un-normalized // GL_UNSIGNED_INT -- un-normalized
AddVertexFormatInfo(&map, GL_UNSIGNED_INT, GL_FALSE, 1, VERTEX_CONVERT_GPU, DXGI_FORMAT_R32_UINT, &copyVertexData<GLuint, 1, 0>); AddVertexFormatInfo(&map, GL_UNSIGNED_INT, GL_FALSE, 1, VERTEX_CONVERT_GPU, DXGI_FORMAT_R32_UINT, &CopyNativeVertexData<GLuint, 1, 0>);
AddVertexFormatInfo(&map, GL_UNSIGNED_INT, GL_FALSE, 2, VERTEX_CONVERT_GPU, DXGI_FORMAT_R32G32_UINT, &copyVertexData<GLuint, 2, 0>); AddVertexFormatInfo(&map, GL_UNSIGNED_INT, GL_FALSE, 2, VERTEX_CONVERT_GPU, DXGI_FORMAT_R32G32_UINT, &CopyNativeVertexData<GLuint, 2, 0>);
AddVertexFormatInfo(&map, GL_UNSIGNED_INT, GL_FALSE, 3, VERTEX_CONVERT_GPU, DXGI_FORMAT_R32G32B32_UINT, &copyVertexData<GLuint, 3, 0>); AddVertexFormatInfo(&map, GL_UNSIGNED_INT, GL_FALSE, 3, VERTEX_CONVERT_GPU, DXGI_FORMAT_R32G32B32_UINT, &CopyNativeVertexData<GLuint, 3, 0>);
AddVertexFormatInfo(&map, GL_UNSIGNED_INT, GL_FALSE, 4, VERTEX_CONVERT_GPU, DXGI_FORMAT_R32G32B32A32_UINT, &copyVertexData<GLuint, 4, 0>); AddVertexFormatInfo(&map, GL_UNSIGNED_INT, GL_FALSE, 4, VERTEX_CONVERT_GPU, DXGI_FORMAT_R32G32B32A32_UINT, &CopyNativeVertexData<GLuint, 4, 0>);
// GL_UNSIGNED_INT -- normalized // GL_UNSIGNED_INT -- normalized
AddVertexFormatInfo(&map, GL_UNSIGNED_INT, GL_TRUE, 1, VERTEX_CONVERT_NONE, DXGI_FORMAT_R32_FLOAT, &copyToFloatVertexData<GLuint, 1, true>); AddVertexFormatInfo(&map, GL_UNSIGNED_INT, GL_TRUE, 1, VERTEX_CONVERT_NONE, DXGI_FORMAT_R32_FLOAT, &CopyTo32FVertexData<GLuint, 1, true>);
AddVertexFormatInfo(&map, GL_UNSIGNED_INT, GL_TRUE, 2, VERTEX_CONVERT_NONE, DXGI_FORMAT_R32G32_FLOAT, &copyToFloatVertexData<GLuint, 2, true>); AddVertexFormatInfo(&map, GL_UNSIGNED_INT, GL_TRUE, 2, VERTEX_CONVERT_NONE, DXGI_FORMAT_R32G32_FLOAT, &CopyTo32FVertexData<GLuint, 2, true>);
AddVertexFormatInfo(&map, GL_UNSIGNED_INT, GL_TRUE, 3, VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32B32_FLOAT, &copyToFloatVertexData<GLuint, 3, true>); AddVertexFormatInfo(&map, GL_UNSIGNED_INT, GL_TRUE, 3, VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32B32_FLOAT, &CopyTo32FVertexData<GLuint, 3, true>);
AddVertexFormatInfo(&map, GL_UNSIGNED_INT, GL_TRUE, 4, VERTEX_CONVERT_NONE, DXGI_FORMAT_R32G32B32A32_FLOAT, &copyToFloatVertexData<GLuint, 4, true>); AddVertexFormatInfo(&map, GL_UNSIGNED_INT, GL_TRUE, 4, VERTEX_CONVERT_NONE, DXGI_FORMAT_R32G32B32A32_FLOAT, &CopyTo32FVertexData<GLuint, 4, true>);
// GL_FIXED // GL_FIXED
AddVertexFormatInfo(&map, GL_FIXED, GL_FALSE, 1, VERTEX_CONVERT_CPU, DXGI_FORMAT_R32_FLOAT, &copyFixedVertexData<1>); AddVertexFormatInfo(&map, GL_FIXED, GL_FALSE, 1, VERTEX_CONVERT_CPU, DXGI_FORMAT_R32_FLOAT, &Copy32FixedTo32FVertexData<1>);
AddVertexFormatInfo(&map, GL_FIXED, GL_FALSE, 2, VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32_FLOAT, &copyFixedVertexData<2>); AddVertexFormatInfo(&map, GL_FIXED, GL_FALSE, 2, VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32_FLOAT, &Copy32FixedTo32FVertexData<2>);
AddVertexFormatInfo(&map, GL_FIXED, GL_FALSE, 3, VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32B32_FLOAT, &copyFixedVertexData<3>); AddVertexFormatInfo(&map, GL_FIXED, GL_FALSE, 3, VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32B32_FLOAT, &Copy32FixedTo32FVertexData<3>);
AddVertexFormatInfo(&map, GL_FIXED, GL_FALSE, 4, VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32B32A32_FLOAT, &copyFixedVertexData<4>); AddVertexFormatInfo(&map, GL_FIXED, GL_FALSE, 4, VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32B32A32_FLOAT, &Copy32FixedTo32FVertexData<4>);
// GL_HALF_FLOAT // GL_HALF_FLOAT
AddVertexFormatInfo(&map, GL_HALF_FLOAT, GL_FALSE, 1, VERTEX_CONVERT_NONE, DXGI_FORMAT_R16_FLOAT, &copyVertexData<GLhalf, 1, 0>); AddVertexFormatInfo(&map, GL_HALF_FLOAT, GL_FALSE, 1, VERTEX_CONVERT_NONE, DXGI_FORMAT_R16_FLOAT, &CopyNativeVertexData<GLhalf, 1, 0>);
AddVertexFormatInfo(&map, GL_HALF_FLOAT, GL_FALSE, 2, VERTEX_CONVERT_NONE, DXGI_FORMAT_R16G16_FLOAT, &copyVertexData<GLhalf, 2, 0>); AddVertexFormatInfo(&map, GL_HALF_FLOAT, GL_FALSE, 2, VERTEX_CONVERT_NONE, DXGI_FORMAT_R16G16_FLOAT, &CopyNativeVertexData<GLhalf, 2, 0>);
AddVertexFormatInfo(&map, GL_HALF_FLOAT, GL_FALSE, 3, VERTEX_CONVERT_CPU, DXGI_FORMAT_R16G16B16A16_FLOAT, &copyVertexData<GLhalf, 3, gl::Float16One>); AddVertexFormatInfo(&map, GL_HALF_FLOAT, GL_FALSE, 3, VERTEX_CONVERT_CPU, DXGI_FORMAT_R16G16B16A16_FLOAT, &CopyNativeVertexData<GLhalf, 3, gl::Float16One>);
AddVertexFormatInfo(&map, GL_HALF_FLOAT, GL_FALSE, 4, VERTEX_CONVERT_NONE, DXGI_FORMAT_R16G16B16A16_FLOAT, &copyVertexData<GLhalf, 4, 0>); AddVertexFormatInfo(&map, GL_HALF_FLOAT, GL_FALSE, 4, VERTEX_CONVERT_NONE, DXGI_FORMAT_R16G16B16A16_FLOAT, &CopyNativeVertexData<GLhalf, 4, 0>);
// GL_FLOAT // GL_FLOAT
AddVertexFormatInfo(&map, GL_FLOAT, GL_FALSE, 1, VERTEX_CONVERT_NONE, DXGI_FORMAT_R32_FLOAT, &copyVertexData<GLfloat, 1, 0>); AddVertexFormatInfo(&map, GL_FLOAT, GL_FALSE, 1, VERTEX_CONVERT_NONE, DXGI_FORMAT_R32_FLOAT, &CopyNativeVertexData<GLfloat, 1, 0>);
AddVertexFormatInfo(&map, GL_FLOAT, GL_FALSE, 2, VERTEX_CONVERT_NONE, DXGI_FORMAT_R32G32_FLOAT, &copyVertexData<GLfloat, 2, 0>); AddVertexFormatInfo(&map, GL_FLOAT, GL_FALSE, 2, VERTEX_CONVERT_NONE, DXGI_FORMAT_R32G32_FLOAT, &CopyNativeVertexData<GLfloat, 2, 0>);
AddVertexFormatInfo(&map, GL_FLOAT, GL_FALSE, 3, VERTEX_CONVERT_NONE, DXGI_FORMAT_R32G32B32_FLOAT, &copyVertexData<GLfloat, 3, 0>); AddVertexFormatInfo(&map, GL_FLOAT, GL_FALSE, 3, VERTEX_CONVERT_NONE, DXGI_FORMAT_R32G32B32_FLOAT, &CopyNativeVertexData<GLfloat, 3, 0>);
AddVertexFormatInfo(&map, GL_FLOAT, GL_FALSE, 4, VERTEX_CONVERT_NONE, DXGI_FORMAT_R32G32B32A32_FLOAT, &copyVertexData<GLfloat, 4, 0>); AddVertexFormatInfo(&map, GL_FLOAT, GL_FALSE, 4, VERTEX_CONVERT_NONE, DXGI_FORMAT_R32G32B32A32_FLOAT, &CopyNativeVertexData<GLfloat, 4, 0>);
// GL_INT_2_10_10_10_REV // GL_INT_2_10_10_10_REV
AddVertexFormatInfo(&map, GL_INT_2_10_10_10_REV, GL_FALSE, 4, VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32B32A32_FLOAT, &copyPackedVertexData<true, false, true>); AddVertexFormatInfo(&map, GL_INT_2_10_10_10_REV, GL_FALSE, 4, VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32B32A32_FLOAT, &CopyXYZ10W2ToXYZW32FVertexData<true, false, true>);
AddVertexFormatInfo(&map, GL_INT_2_10_10_10_REV, GL_TRUE, 4, VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32B32A32_FLOAT, &copyPackedVertexData<true, true, true>); AddVertexFormatInfo(&map, GL_INT_2_10_10_10_REV, GL_TRUE, 4, VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32B32A32_FLOAT, &CopyXYZ10W2ToXYZW32FVertexData<true, true, true>);
// GL_UNSIGNED_INT_2_10_10_10_REV // GL_UNSIGNED_INT_2_10_10_10_REV
AddVertexFormatInfo(&map, GL_UNSIGNED_INT_2_10_10_10_REV, GL_FALSE, 4, VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32B32A32_FLOAT, &copyPackedVertexData<false, false, true>); AddVertexFormatInfo(&map, GL_UNSIGNED_INT_2_10_10_10_REV, GL_FALSE, 4, VERTEX_CONVERT_CPU, DXGI_FORMAT_R32G32B32A32_FLOAT, &CopyXYZ10W2ToXYZW32FVertexData<false, false, true>);
AddVertexFormatInfo(&map, GL_UNSIGNED_INT_2_10_10_10_REV, GL_TRUE, 4, VERTEX_CONVERT_NONE, DXGI_FORMAT_R10G10B10A2_UNORM, &copyPackedUnsignedVertexData); AddVertexFormatInfo(&map, GL_UNSIGNED_INT_2_10_10_10_REV, GL_TRUE, 4, VERTEX_CONVERT_NONE, DXGI_FORMAT_R10G10B10A2_UNORM, &CopyNativeVertexData<GLuint, 1, 0>);
// //
// Integer Formats // Integer Formats
// //
// GL_BYTE // GL_BYTE
AddIntegerVertexFormatInfo(&map, GL_BYTE, 1, VERTEX_CONVERT_NONE, DXGI_FORMAT_R8_SINT, &copyVertexData<GLbyte, 1, 0>); AddIntegerVertexFormatInfo(&map, GL_BYTE, 1, VERTEX_CONVERT_NONE, DXGI_FORMAT_R8_SINT, &CopyNativeVertexData<GLbyte, 1, 0>);
AddIntegerVertexFormatInfo(&map, GL_BYTE, 2, VERTEX_CONVERT_NONE, DXGI_FORMAT_R8G8_SINT, &copyVertexData<GLbyte, 2, 0>); AddIntegerVertexFormatInfo(&map, GL_BYTE, 2, VERTEX_CONVERT_NONE, DXGI_FORMAT_R8G8_SINT, &CopyNativeVertexData<GLbyte, 2, 0>);
AddIntegerVertexFormatInfo(&map, GL_BYTE, 3, VERTEX_CONVERT_CPU, DXGI_FORMAT_R8G8B8A8_SINT, &copyVertexData<GLbyte, 3, 1>); AddIntegerVertexFormatInfo(&map, GL_BYTE, 3, VERTEX_CONVERT_CPU, DXGI_FORMAT_R8G8B8A8_SINT, &CopyNativeVertexData<GLbyte, 3, 1>);
AddIntegerVertexFormatInfo(&map, GL_BYTE, 4, VERTEX_CONVERT_NONE, DXGI_FORMAT_R8G8B8A8_SINT, &copyVertexData<GLbyte, 4, 0>); AddIntegerVertexFormatInfo(&map, GL_BYTE, 4, VERTEX_CONVERT_NONE, DXGI_FORMAT_R8G8B8A8_SINT, &CopyNativeVertexData<GLbyte, 4, 0>);
// GL_UNSIGNED_BYTE // GL_UNSIGNED_BYTE
AddIntegerVertexFormatInfo(&map, GL_UNSIGNED_BYTE, 1, VERTEX_CONVERT_NONE, DXGI_FORMAT_R8_UINT, &copyVertexData<GLubyte, 1, 0>); AddIntegerVertexFormatInfo(&map, GL_UNSIGNED_BYTE, 1, VERTEX_CONVERT_NONE, DXGI_FORMAT_R8_UINT, &CopyNativeVertexData<GLubyte, 1, 0>);
AddIntegerVertexFormatInfo(&map, GL_UNSIGNED_BYTE, 2, VERTEX_CONVERT_NONE, DXGI_FORMAT_R8G8_UINT, &copyVertexData<GLubyte, 2, 0>); AddIntegerVertexFormatInfo(&map, GL_UNSIGNED_BYTE, 2, VERTEX_CONVERT_NONE, DXGI_FORMAT_R8G8_UINT, &CopyNativeVertexData<GLubyte, 2, 0>);
AddIntegerVertexFormatInfo(&map, GL_UNSIGNED_BYTE, 3, VERTEX_CONVERT_CPU, DXGI_FORMAT_R8G8B8A8_UINT, &copyVertexData<GLubyte, 3, 1>); AddIntegerVertexFormatInfo(&map, GL_UNSIGNED_BYTE, 3, VERTEX_CONVERT_CPU, DXGI_FORMAT_R8G8B8A8_UINT, &CopyNativeVertexData<GLubyte, 3, 1>);
AddIntegerVertexFormatInfo(&map, GL_UNSIGNED_BYTE, 4, VERTEX_CONVERT_NONE, DXGI_FORMAT_R8G8B8A8_UINT, &copyVertexData<GLubyte, 4, 0>); AddIntegerVertexFormatInfo(&map, GL_UNSIGNED_BYTE, 4, VERTEX_CONVERT_NONE, DXGI_FORMAT_R8G8B8A8_UINT, &CopyNativeVertexData<GLubyte, 4, 0>);
// GL_SHORT // GL_SHORT
AddIntegerVertexFormatInfo(&map, GL_SHORT, 1, VERTEX_CONVERT_NONE, DXGI_FORMAT_R16_SINT, &copyVertexData<GLshort, 1, 0>); AddIntegerVertexFormatInfo(&map, GL_SHORT, 1, VERTEX_CONVERT_NONE, DXGI_FORMAT_R16_SINT, &CopyNativeVertexData<GLshort, 1, 0>);
AddIntegerVertexFormatInfo(&map, GL_SHORT, 2, VERTEX_CONVERT_NONE, DXGI_FORMAT_R16G16_SINT, &copyVertexData<GLshort, 2, 0>); AddIntegerVertexFormatInfo(&map, GL_SHORT, 2, VERTEX_CONVERT_NONE, DXGI_FORMAT_R16G16_SINT, &CopyNativeVertexData<GLshort, 2, 0>);
AddIntegerVertexFormatInfo(&map, GL_SHORT, 3, VERTEX_CONVERT_CPU, DXGI_FORMAT_R16G16B16A16_SINT, &copyVertexData<GLshort, 3, 1>); AddIntegerVertexFormatInfo(&map, GL_SHORT, 3, VERTEX_CONVERT_CPU, DXGI_FORMAT_R16G16B16A16_SINT, &CopyNativeVertexData<GLshort, 3, 1>);
AddIntegerVertexFormatInfo(&map, GL_SHORT, 4, VERTEX_CONVERT_NONE, DXGI_FORMAT_R16G16B16A16_SINT, &copyVertexData<GLshort, 4, 0>); AddIntegerVertexFormatInfo(&map, GL_SHORT, 4, VERTEX_CONVERT_NONE, DXGI_FORMAT_R16G16B16A16_SINT, &CopyNativeVertexData<GLshort, 4, 0>);
// GL_UNSIGNED_SHORT // GL_UNSIGNED_SHORT
AddIntegerVertexFormatInfo(&map, GL_UNSIGNED_SHORT, 1, VERTEX_CONVERT_NONE, DXGI_FORMAT_R16_UINT, &copyVertexData<GLushort, 1, 0>); AddIntegerVertexFormatInfo(&map, GL_UNSIGNED_SHORT, 1, VERTEX_CONVERT_NONE, DXGI_FORMAT_R16_UINT, &CopyNativeVertexData<GLushort, 1, 0>);
AddIntegerVertexFormatInfo(&map, GL_UNSIGNED_SHORT, 2, VERTEX_CONVERT_NONE, DXGI_FORMAT_R16G16_UINT, &copyVertexData<GLushort, 2, 0>); AddIntegerVertexFormatInfo(&map, GL_UNSIGNED_SHORT, 2, VERTEX_CONVERT_NONE, DXGI_FORMAT_R16G16_UINT, &CopyNativeVertexData<GLushort, 2, 0>);
AddIntegerVertexFormatInfo(&map, GL_UNSIGNED_SHORT, 3, VERTEX_CONVERT_CPU, DXGI_FORMAT_R16G16B16A16_UINT, &copyVertexData<GLushort, 3, 1>); AddIntegerVertexFormatInfo(&map, GL_UNSIGNED_SHORT, 3, VERTEX_CONVERT_CPU, DXGI_FORMAT_R16G16B16A16_UINT, &CopyNativeVertexData<GLushort, 3, 1>);
AddIntegerVertexFormatInfo(&map, GL_UNSIGNED_SHORT, 4, VERTEX_CONVERT_NONE, DXGI_FORMAT_R16G16B16A16_UINT, &copyVertexData<GLushort, 4, 0>); AddIntegerVertexFormatInfo(&map, GL_UNSIGNED_SHORT, 4, VERTEX_CONVERT_NONE, DXGI_FORMAT_R16G16B16A16_UINT, &CopyNativeVertexData<GLushort, 4, 0>);
// GL_INT // GL_INT
AddIntegerVertexFormatInfo(&map, GL_INT, 1, VERTEX_CONVERT_NONE, DXGI_FORMAT_R32_SINT, &copyVertexData<GLint, 1, 0>); AddIntegerVertexFormatInfo(&map, GL_INT, 1, VERTEX_CONVERT_NONE, DXGI_FORMAT_R32_SINT, &CopyNativeVertexData<GLint, 1, 0>);
AddIntegerVertexFormatInfo(&map, GL_INT, 2, VERTEX_CONVERT_NONE, DXGI_FORMAT_R32G32_SINT, &copyVertexData<GLint, 2, 0>); AddIntegerVertexFormatInfo(&map, GL_INT, 2, VERTEX_CONVERT_NONE, DXGI_FORMAT_R32G32_SINT, &CopyNativeVertexData<GLint, 2, 0>);
AddIntegerVertexFormatInfo(&map, GL_INT, 3, VERTEX_CONVERT_NONE, DXGI_FORMAT_R32G32B32_SINT, &copyVertexData<GLint, 3, 0>); AddIntegerVertexFormatInfo(&map, GL_INT, 3, VERTEX_CONVERT_NONE, DXGI_FORMAT_R32G32B32_SINT, &CopyNativeVertexData<GLint, 3, 0>);
AddIntegerVertexFormatInfo(&map, GL_INT, 4, VERTEX_CONVERT_NONE, DXGI_FORMAT_R32G32B32A32_SINT, &copyVertexData<GLint, 4, 0>); AddIntegerVertexFormatInfo(&map, GL_INT, 4, VERTEX_CONVERT_NONE, DXGI_FORMAT_R32G32B32A32_SINT, &CopyNativeVertexData<GLint, 4, 0>);
// GL_UNSIGNED_INT // GL_UNSIGNED_INT
AddIntegerVertexFormatInfo(&map, GL_UNSIGNED_INT, 1, VERTEX_CONVERT_NONE, DXGI_FORMAT_R32_SINT, &copyVertexData<GLuint, 1, 0>); AddIntegerVertexFormatInfo(&map, GL_UNSIGNED_INT, 1, VERTEX_CONVERT_NONE, DXGI_FORMAT_R32_SINT, &CopyNativeVertexData<GLuint, 1, 0>);
AddIntegerVertexFormatInfo(&map, GL_UNSIGNED_INT, 2, VERTEX_CONVERT_NONE, DXGI_FORMAT_R32G32_SINT, &copyVertexData<GLuint, 2, 0>); AddIntegerVertexFormatInfo(&map, GL_UNSIGNED_INT, 2, VERTEX_CONVERT_NONE, DXGI_FORMAT_R32G32_SINT, &CopyNativeVertexData<GLuint, 2, 0>);
AddIntegerVertexFormatInfo(&map, GL_UNSIGNED_INT, 3, VERTEX_CONVERT_NONE, DXGI_FORMAT_R32G32B32_SINT, &copyVertexData<GLuint, 3, 0>); AddIntegerVertexFormatInfo(&map, GL_UNSIGNED_INT, 3, VERTEX_CONVERT_NONE, DXGI_FORMAT_R32G32B32_SINT, &CopyNativeVertexData<GLuint, 3, 0>);
AddIntegerVertexFormatInfo(&map, GL_UNSIGNED_INT, 4, VERTEX_CONVERT_NONE, DXGI_FORMAT_R32G32B32A32_SINT, &copyVertexData<GLuint, 4, 0>); AddIntegerVertexFormatInfo(&map, GL_UNSIGNED_INT, 4, VERTEX_CONVERT_NONE, DXGI_FORMAT_R32G32B32A32_SINT, &CopyNativeVertexData<GLuint, 4, 0>);
// GL_INT_2_10_10_10_REV // GL_INT_2_10_10_10_REV
AddIntegerVertexFormatInfo(&map, GL_INT_2_10_10_10_REV, 4, VERTEX_CONVERT_CPU, DXGI_FORMAT_R16G16B16A16_SINT, &copyPackedVertexData<true, true, false>); AddIntegerVertexFormatInfo(&map, GL_INT_2_10_10_10_REV, 4, VERTEX_CONVERT_CPU, DXGI_FORMAT_R16G16B16A16_SINT, &CopyXYZ10W2ToXYZW32FVertexData<true, true, false>);
// GL_UNSIGNED_INT_2_10_10_10_REV // GL_UNSIGNED_INT_2_10_10_10_REV
AddIntegerVertexFormatInfo(&map, GL_UNSIGNED_INT_2_10_10_10_REV, 4, VERTEX_CONVERT_NONE, DXGI_FORMAT_R10G10B10A2_UINT, &copyPackedUnsignedVertexData); AddIntegerVertexFormatInfo(&map, GL_UNSIGNED_INT_2_10_10_10_REV, 4, VERTEX_CONVERT_NONE, DXGI_FORMAT_R10G10B10A2_UINT, &CopyNativeVertexData<GLuint, 1, 0>);
return map; return map;
} }
......
src/libGLESv2/renderer/d3d/d3d9/VertexBuffer9.cpp
...@@ -77,7 +77,7 @@ bool VertexBuffer9::storeVertexAttributes(const gl::VertexAttribute &attrib, con ...@@ -77,7 +77,7 @@ bool VertexBuffer9::storeVertexAttributes(const gl::VertexAttribute &attrib, con
DWORD lockFlags = mDynamicUsage ? D3DLOCK_NOOVERWRITE : 0; DWORD lockFlags = mDynamicUsage ? D3DLOCK_NOOVERWRITE : 0;
void *mapPtr = NULL; uint8_t *mapPtr = NULL;
unsigned int mapSize; unsigned int mapSize;
if (!spaceRequired(attrib, count, instances, &mapSize)) if (!spaceRequired(attrib, count, instances, &mapSize))
...@@ -85,7 +85,7 @@ bool VertexBuffer9::storeVertexAttributes(const gl::VertexAttribute &attrib, con ...@@ -85,7 +85,7 @@ bool VertexBuffer9::storeVertexAttributes(const gl::VertexAttribute &attrib, con
return false; return false;
} }
HRESULT result = mVertexBuffer->Lock(offset, mapSize, &mapPtr, lockFlags); HRESULT result = mVertexBuffer->Lock(offset, mapSize, reinterpret_cast<void**>(&mapPtr), lockFlags);
if (FAILED(result)) if (FAILED(result))
{ {
...@@ -93,22 +93,22 @@ bool VertexBuffer9::storeVertexAttributes(const gl::VertexAttribute &attrib, con ...@@ -93,22 +93,22 @@ bool VertexBuffer9::storeVertexAttributes(const gl::VertexAttribute &attrib, con
return false; return false;
} }
const char *input = NULL; const uint8_t *input = NULL;
if (attrib.enabled) if (attrib.enabled)
{ {
if (buffer) if (buffer)
{ {
BufferImpl *storage = buffer->getImplementation(); BufferImpl *storage = buffer->getImplementation();
input = static_cast<const char*>(storage->getData()) + static_cast<int>(attrib.offset); input = static_cast<const uint8_t*>(storage->getData()) + static_cast<int>(attrib.offset);
} }
else else
{ {
input = static_cast<const char*>(attrib.pointer); input = static_cast<const uint8_t*>(attrib.pointer);
} }
} }
else else
{ {
input = reinterpret_cast<const char*>(currentValue.FloatValues); input = reinterpret_cast<const uint8_t*>(currentValue.FloatValues);
} }
if (instances == 0 || attrib.divisor == 0) if (instances == 0 || attrib.divisor == 0)
......
src/libGLESv2/renderer/vertexconversion.h
...@@ -154,11 +154,13 @@ struct VertexDataConverter ...@@ -154,11 +154,13 @@ struct VertexDataConverter
static const bool identity = (WidenRule::initialWidth == WidenRule::finalWidth) && Converter::identity; static const bool identity = (WidenRule::initialWidth == WidenRule::finalWidth) && Converter::identity;
static const std::size_t finalSize = WidenRule::finalWidth * sizeof(OutputType); static const std::size_t finalSize = WidenRule::finalWidth * sizeof(OutputType);
static void convertArray(const InputType *in, std::size_t stride, std::size_t n, OutputType *out) static void convertArray(const uint8_t *input, size_t stride, size_t n, uint8_t *output)
{ {
OutputType *out = reinterpret_cast<OutputType*>(output);
for (std::size_t i = 0; i < n; i++) for (std::size_t i = 0; i < n; i++)
{ {
const InputType *ein = pointerAddBytes(in, i * stride); const InputType *ein = reinterpret_cast<const InputType*>(input + i * stride);
copyComponent(out, ein, 0, static_cast<OutputType>(DefaultValueRule::zero())); copyComponent(out, ein, 0, static_cast<OutputType>(DefaultValueRule::zero()));
copyComponent(out, ein, 1, static_cast<OutputType>(DefaultValueRule::zero())); copyComponent(out, ein, 1, static_cast<OutputType>(DefaultValueRule::zero()));
...@@ -169,19 +171,7 @@ struct VertexDataConverter ...@@ -169,19 +171,7 @@ struct VertexDataConverter
} }
} }
static void convertArray(const void *in, std::size_t stride, std::size_t n, void *out)
{
return convertArray(static_cast<const InputType*>(in), stride, n, static_cast<OutputType*>(out));
}
private: private:
// Advance the given pointer by a number of bytes (not pointed-to elements).
template <class T>
static T *pointerAddBytes(T *basePtr, std::size_t numBytes)
{
return reinterpret_cast<T *>(reinterpret_cast<uintptr_t>(basePtr) + numBytes);
}
static void copyComponent(OutputType *out, const InputType *in, std::size_t elementindex, OutputType defaultvalue) static void copyComponent(OutputType *out, const InputType *in, std::size_t elementindex, OutputType defaultvalue)
{ {
if (WidenRule::finalWidth > elementindex) if (WidenRule::finalWidth > elementindex)
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment