Implemented VertexBuffer11.
TRAC #22227
Signed-off-by: Nicolas Capens
Signed-off-by: Daniel Koch
Author: Geoff Lang
git-svn-id: https://angleproject.googlecode.com/svn/branches/dx11proto@1598 736b8ea6-26fd-11df-bfd4-992fa37f6226
diff --git a/src/build_angle.gypi b/src/build_angle.gypi
index 1b20995..6503335 100644
--- a/src/build_angle.gypi
+++ b/src/build_angle.gypi
@@ -297,6 +297,8 @@
'libGLESv2/renderer/VertexBuffer.h',
'libGLESv2/renderer/VertexBuffer9.cpp',
'libGLESv2/renderer/VertexBuffer9.h',
+ 'libGLESv2/renderer/VertexBuffer11.cpp',
+ 'libGLESv2/renderer/VertexBuffer11.h',
'libGLESv2/renderer/VertexDeclarationCache.cpp',
'libGLESv2/renderer/VertexDeclarationCache.h',
'libGLESv2/ResourceManager.cpp',
diff --git a/src/libGLESv2/libGLESv2.vcxproj b/src/libGLESv2/libGLESv2.vcxproj
index 648770d..facc361 100644
--- a/src/libGLESv2/libGLESv2.vcxproj
+++ b/src/libGLESv2/libGLESv2.vcxproj
@@ -264,6 +264,7 @@
<ClCompile Include="renderer\SwapChain9.cpp" />
<ClCompile Include="renderer\TextureStorage.cpp" />
<ClCompile Include="renderer\VertexBuffer.cpp" />
+ <ClCompile Include="renderer\VertexBuffer11.cpp" />
<ClCompile Include="renderer\VertexBuffer9.cpp" />
<ClCompile Include="renderer\VertexDataManager.cpp" />
<ClCompile Include="renderer\VertexDeclarationCache.cpp" />
@@ -317,6 +318,7 @@
<ClInclude Include="renderer\SwapChain9.h" />
<ClInclude Include="renderer\TextureStorage.h" />
<ClInclude Include="renderer\VertexBuffer.h" />
+ <ClInclude Include="renderer\VertexBuffer11.h" />
<ClInclude Include="renderer\VertexBuffer9.h" />
<ClInclude Include="renderer\vertexconversion.h" />
<ClInclude Include="renderer\VertexDataManager.h" />
diff --git a/src/libGLESv2/libGLESv2.vcxproj.filters b/src/libGLESv2/libGLESv2.vcxproj.filters
index 24741f6..ddab5e0 100644
--- a/src/libGLESv2/libGLESv2.vcxproj.filters
+++ b/src/libGLESv2/libGLESv2.vcxproj.filters
@@ -149,12 +149,15 @@
<ClCompile Include="renderer\VertexBuffer9.cpp">
<Filter>Renderer</Filter>
</ClCompile>
+ <ClCompile Include="renderer\VertexBuffer11.cpp">
+ <Filter>Renderer</Filter>
+ </ClCompile>
<ClCompile Include="renderer\Image11.cpp">
<Filter>Renderer</Filter>
</ClCompile>
<ClCompile Include="Uniform.cpp">
<Filter>Source Files</Filter>
- </ClCompile>
+ </ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="BinaryStream.h">
@@ -313,12 +316,9 @@
<ClInclude Include="renderer\VertexBuffer9.h">
<Filter>Renderer</Filter>
</ClInclude>
- <ClInclude Include="renderer\Image11.h">
+ <ClInclude Include="renderer\VertexBuffer11.h">
<Filter>Renderer</Filter>
- </ClInclude>
- <ClInclude Include="Uniform.h">
- <Filter>Header Files</Filter>
- </ClInclude>
+ </ClInclude>
</ItemGroup>
<ItemGroup>
<None Include="libGLESv2.def">
diff --git a/src/libGLESv2/renderer/Renderer11.cpp b/src/libGLESv2/renderer/Renderer11.cpp
index 53b2fdd..5a055f6 100644
--- a/src/libGLESv2/renderer/Renderer11.cpp
+++ b/src/libGLESv2/renderer/Renderer11.cpp
@@ -20,6 +20,7 @@
#include "libGLESv2/renderer/ShaderExecutable11.h"
#include "libGLESv2/renderer/SwapChain11.h"
#include "libGLESv2/renderer/Image11.h"
+#include "libGLESv2/renderer/VertexBuffer11.h"
#include "libEGL/Config.h"
#include "libEGL/Display.h"
@@ -1250,9 +1251,7 @@
VertexBuffer *Renderer11::createVertexBuffer()
{
- // TODO
- UNIMPLEMENTED();
- return NULL;
+ return new VertexBuffer11(this);
}
bool Renderer11::blitRect(gl::Framebuffer *readTarget, gl::Rectangle *readRect, gl::Framebuffer *drawTarget, gl::Rectangle *drawRect,
diff --git a/src/libGLESv2/renderer/VertexBuffer11.cpp b/src/libGLESv2/renderer/VertexBuffer11.cpp
new file mode 100644
index 0000000..c985e78
--- /dev/null
+++ b/src/libGLESv2/renderer/VertexBuffer11.cpp
@@ -0,0 +1,375 @@
+//
+// Copyright (c) 2012 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.
+//
+
+// VertexBuffer11.cpp: Defines the D3D11 VertexBuffer implementation.
+
+#include "libGLESv2/renderer/VertexBuffer11.h"
+
+#include "libGLESv2/Buffer.h"
+
+namespace rx
+{
+
+VertexBuffer11::VertexBuffer11(rx::Renderer11 *const renderer) : mRenderer(renderer)
+{
+ mBuffer = NULL;
+ mBufferSize = 0;
+ mDynamicUsage = false;
+}
+
+VertexBuffer11::~VertexBuffer11()
+{
+ if (mBuffer)
+ {
+ mBuffer->Release();
+ mBuffer = NULL;
+ }
+}
+
+bool VertexBuffer11::initialize(unsigned int size, bool dynamicUsage)
+{
+ if (mBuffer)
+ {
+ mBuffer->Release();
+ mBuffer = NULL;
+ }
+
+ updateSerial();
+
+ if (size > 0)
+ {
+ ID3D11Device* dxDevice = mRenderer->getDevice();
+
+ D3D11_BUFFER_DESC bufferDesc;
+ bufferDesc.ByteWidth = size;
+ bufferDesc.Usage = D3D11_USAGE_DYNAMIC;
+ bufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
+ bufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
+ bufferDesc.MiscFlags = 0;
+ bufferDesc.StructureByteStride = 0;
+
+ HRESULT result = dxDevice->CreateBuffer(&bufferDesc, NULL, &mBuffer);
+ if (FAILED(result))
+ {
+ return false;
+ }
+ }
+
+ mBufferSize = size;
+ mDynamicUsage = dynamicUsage;
+ return true;
+}
+
+VertexBuffer11 *VertexBuffer11::makeVertexBuffer11(VertexBuffer *vetexBuffer)
+{
+ ASSERT(dynamic_cast<VertexBuffer11*>(vetexBuffer) != NULL);
+ return static_cast<VertexBuffer11*>(vetexBuffer);
+}
+
+bool VertexBuffer11::storeVertexAttributes(const gl::VertexAttribute &attrib, GLint start, GLsizei count,
+ GLsizei instances, unsigned int offset)
+{
+ if (mBuffer)
+ {
+ gl::Buffer *buffer = attrib.mBoundBuffer.get();
+
+ int inputStride = attrib.stride();
+ int elementSize = attrib.typeSize();
+ const VertexConverter &converter = getVertexConversion(attrib);
+
+ ID3D11DeviceContext *dxContext = mRenderer->getDeviceContext();
+
+ D3D11_MAPPED_SUBRESOURCE mappedResource;
+ HRESULT result = dxContext->Map(mBuffer, 0, D3D11_MAP_WRITE_NO_OVERWRITE, 0, &mappedResource);
+ if (FAILED(result))
+ {
+ ERR("Vertex buffer map failed with error 0x%08x", result);
+ return false;
+ }
+
+ char* output = reinterpret_cast<char*>(mappedResource.pData) + offset;
+
+ const char *input = NULL;
+ if (buffer)
+ {
+ input = static_cast<const char*>(buffer->data()) + static_cast<int>(attrib.mOffset);
+ }
+ else
+ {
+ input = static_cast<const char*>(attrib.mPointer);
+ }
+
+ if (instances == 0 || attrib.mDivisor == 0)
+ {
+ input += inputStride * start;
+ }
+
+ converter.conversionFunc(input, inputStride, count, output);
+
+ dxContext->Unmap(mBuffer, 0);
+
+ return true;
+ }
+ else
+ {
+ ERR("Vertex buffer not initialized.");
+ return false;
+ }
+}
+
+bool VertexBuffer11::storeRawData(const void* data, unsigned int size, unsigned int offset)
+{
+ if (mBuffer)
+ {
+ ID3D11DeviceContext *dxContext = mRenderer->getDeviceContext();
+
+ D3D11_MAPPED_SUBRESOURCE mappedResource;
+ HRESULT result = dxContext->Map(mBuffer, 0, D3D11_MAP_WRITE_NO_OVERWRITE, 0, &mappedResource);
+ if (FAILED(result))
+ {
+ ERR("Vertex buffer map failed with error 0x%08x", result);
+ return false;
+ }
+
+ char* bufferData = static_cast<char*>(mappedResource.pData);
+ memcpy(bufferData + offset, data, size);
+
+ dxContext->Unmap(mBuffer, 0);
+
+ return true;
+ }
+ else
+ {
+ ERR("Vertex buffer not initialized.");
+ return false;
+ }
+}
+
+unsigned int VertexBuffer11::getSpaceRequired(const gl::VertexAttribute &attrib, GLsizei count,
+ GLsizei instances) const
+{
+ unsigned int elementSize = getVertexConversion(attrib).outputElementSize;
+
+ if (instances == 0 || attrib.mDivisor == 0)
+ {
+ return elementSize * count;
+ }
+ else
+ {
+ return elementSize * ((instances + attrib.mDivisor - 1) / attrib.mDivisor);
+ }
+}
+
+unsigned int VertexBuffer11::getBufferSize() const
+{
+ return mBufferSize;
+}
+
+bool VertexBuffer11::setBufferSize(unsigned int size)
+{
+ if (size > mBufferSize)
+ {
+ return initialize(size, mDynamicUsage);
+ }
+ else
+ {
+ return true;
+ }
+}
+
+bool VertexBuffer11::discard()
+{
+ if (mBuffer)
+ {
+ ID3D11DeviceContext *dxContext = mRenderer->getDeviceContext();
+
+ D3D11_MAPPED_SUBRESOURCE mappedResource;
+ HRESULT result = dxContext->Map(mBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
+ if (FAILED(result))
+ {
+ ERR("Vertex buffer map failed with error 0x%08x", result);
+ return false;
+ }
+
+ dxContext->Unmap(mBuffer, 0);
+
+ return true;
+ }
+ else
+ {
+ ERR("Vertex buffer not initialized.");
+ return false;
+ }
+}
+
+unsigned int VertexBuffer11::getVertexSize(const gl::VertexAttribute &attrib) const
+{
+ return getVertexConversion(attrib).outputElementSize;
+}
+
+DXGI_FORMAT VertexBuffer11::getDXGIFormat(const gl::VertexAttribute &attrib) const
+{
+ return getVertexConversion(attrib).dxgiFormat;
+}
+
+ID3D11Buffer *VertexBuffer11::getBuffer() const
+{
+ return mBuffer;
+}
+
+template <typename T, unsigned int componentCount, bool widen, bool normalized>
+static void copyVertexData(const void* input, unsigned int stride, unsigned int count, void* output)
+{
+ unsigned int typeSize = sizeof(T);
+ unsigned int vertexSize = typeSize * componentCount;
+
+ unsigned int outputStride = widen ? 4 : componentCount;
+ T defaultVal = normalized ? std::numeric_limits<T>::max() : T(1);
+
+ if (vertexSize == stride && !widen)
+ {
+ memcpy(output, input, count * vertexSize);
+ }
+ else
+ {
+ for (unsigned int i = 0; i < count; i++)
+ {
+ const T* offsetInput = reinterpret_cast<const T*>(reinterpret_cast<const char*>(input) + stride * i);
+ T* offsetOutput = reinterpret_cast<T*>(output) + i * outputStride;
+
+ memcpy(offsetOutput, offsetInput, vertexSize);
+
+ if (widen)
+ {
+ offsetOutput[3] = defaultVal;
+ }
+ }
+ }
+}
+
+template <unsigned int componentCount>
+static void copyFixedVertexData(const void* input, unsigned int stride, unsigned int 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++)
+ {
+ offsetOutput[j] = static_cast<float>(offsetInput[j]) * divisor;
+ }
+ }
+}
+
+const VertexBuffer11::VertexConverter VertexBuffer11::mPossibleTranslations[NUM_GL_VERTEX_ATTRIB_TYPES][2][4] =
+{
+ { // GL_BYTE
+ { // unnormalized
+ { ©VertexData<GLbyte, 1, false, false>, DXGI_FORMAT_R8_SINT, 1 },
+ { ©VertexData<GLbyte, 2, false, false>, DXGI_FORMAT_R8G8_SINT, 2 },
+ { ©VertexData<GLbyte, 3, true, false>, DXGI_FORMAT_R8G8B8A8_SINT, 4 },
+ { ©VertexData<GLbyte, 4, false, false>, DXGI_FORMAT_R8G8B8A8_SINT, 4 },
+ },
+ { // normalized
+ { ©VertexData<GLbyte, 1, false, true>, DXGI_FORMAT_R8_SNORM, 1 },
+ { ©VertexData<GLbyte, 2, false, true>, DXGI_FORMAT_R8G8_SNORM, 2 },
+ { ©VertexData<GLbyte, 3, true, true>, DXGI_FORMAT_R8G8B8A8_SNORM, 4 },
+ { ©VertexData<GLbyte, 4, false, true>, DXGI_FORMAT_R8G8B8A8_SNORM, 4 },
+ },
+ },
+ { // GL_UNSIGNED_BYTE
+ { // unnormalized
+ { ©VertexData<GLubyte, 1, false, false>, DXGI_FORMAT_R8_UINT, 1 },
+ { ©VertexData<GLubyte, 2, false, false>, DXGI_FORMAT_R8G8_UINT, 2 },
+ { ©VertexData<GLubyte, 3, true, false>, DXGI_FORMAT_R8G8B8A8_UINT, 4 },
+ { ©VertexData<GLubyte, 4, false, false>, DXGI_FORMAT_R8G8B8A8_UINT, 4 },
+ },
+ { // normalized
+ { ©VertexData<GLubyte, 1, false, true>, DXGI_FORMAT_R8_UNORM, 1 },
+ { ©VertexData<GLubyte, 2, false, true>, DXGI_FORMAT_R8G8_UNORM, 2 },
+ { ©VertexData<GLubyte, 3, true, true>, DXGI_FORMAT_R8G8B8A8_UNORM, 4 },
+ { ©VertexData<GLubyte, 4, false, true>, DXGI_FORMAT_R8G8B8A8_UNORM, 4 },
+ },
+ },
+ { // GL_SHORT
+ { // unnormalized
+ { ©VertexData<GLshort, 1, false, false>, DXGI_FORMAT_R16_SINT, 2 },
+ { ©VertexData<GLshort, 2, false, false>, DXGI_FORMAT_R16G16_SINT, 4 },
+ { ©VertexData<GLshort, 3, true, false>, DXGI_FORMAT_R16G16B16A16_SINT, 8 },
+ { ©VertexData<GLshort, 4, false, false>, DXGI_FORMAT_R16G16B16A16_SINT, 8 },
+ },
+ { // normalized
+ { ©VertexData<GLshort, 1, false, true>, DXGI_FORMAT_R16_SNORM, 2 },
+ { ©VertexData<GLshort, 2, false, true>, DXGI_FORMAT_R16G16_SNORM, 4 },
+ { ©VertexData<GLshort, 3, true, true>, DXGI_FORMAT_R16G16B16A16_SNORM, 8 },
+ { ©VertexData<GLshort, 4, false, true>, DXGI_FORMAT_R16G16B16A16_SNORM, 8 },
+ },
+ },
+ { // GL_UNSIGNED_SHORT
+ { // unnormalized
+ { ©VertexData<GLushort, 1, false, false>, DXGI_FORMAT_R16_UINT, 2 },
+ { ©VertexData<GLushort, 2, false, false>, DXGI_FORMAT_R16G16_UINT, 4 },
+ { ©VertexData<GLushort, 3, true, false>, DXGI_FORMAT_R16G16B16A16_UINT, 8 },
+ { ©VertexData<GLushort, 4, false, false>, DXGI_FORMAT_R16G16B16A16_UINT, 8 },
+ },
+ { // normalized
+ { ©VertexData<GLushort, 1, false, true>, DXGI_FORMAT_R16_UNORM, 2 },
+ { ©VertexData<GLushort, 2, false, true>, DXGI_FORMAT_R16G16_UNORM, 4 },
+ { ©VertexData<GLushort, 3, true, true>, DXGI_FORMAT_R16G16B16A16_UNORM, 8 },
+ { ©VertexData<GLushort, 4, false, true>, DXGI_FORMAT_R16G16B16A16_UNORM, 8 },
+ },
+ },
+ { // GL_FIXED
+ { // unnormalized
+ { ©FixedVertexData<1>, DXGI_FORMAT_R32_FLOAT, 4 },
+ { ©FixedVertexData<2>, DXGI_FORMAT_R32G32_FLOAT, 8 },
+ { ©FixedVertexData<3>, DXGI_FORMAT_R32G32B32_FLOAT, 12 },
+ { ©FixedVertexData<4>, DXGI_FORMAT_R32G32B32A32_FLOAT, 16 },
+ },
+ { // normalized
+ { ©FixedVertexData<1>, DXGI_FORMAT_R32_FLOAT, 4 },
+ { ©FixedVertexData<2>, DXGI_FORMAT_R32G32_FLOAT, 8 },
+ { ©FixedVertexData<3>, DXGI_FORMAT_R32G32B32_FLOAT, 12 },
+ { ©FixedVertexData<4>, DXGI_FORMAT_R32G32B32A32_FLOAT, 16 },
+ },
+ },
+ { // GL_FLOAT
+ { // unnormalized
+ { ©VertexData<GLfloat, 1, false, false>, DXGI_FORMAT_R32_FLOAT, 4 },
+ { ©VertexData<GLfloat, 2, false, false>, DXGI_FORMAT_R32G32_FLOAT, 8 },
+ { ©VertexData<GLfloat, 3, false, false>, DXGI_FORMAT_R32G32B32_FLOAT, 12 },
+ { ©VertexData<GLfloat, 4, false, false>, DXGI_FORMAT_R32G32B32A32_FLOAT, 16 },
+ },
+ { // normalized
+ { ©VertexData<GLfloat, 1, false, false>, DXGI_FORMAT_R32_FLOAT, 4 },
+ { ©VertexData<GLfloat, 2, false, false>, DXGI_FORMAT_R32G32_FLOAT, 8 },
+ { ©VertexData<GLfloat, 3, false, false>, DXGI_FORMAT_R32G32B32_FLOAT, 12 },
+ { ©VertexData<GLfloat, 4, false, false>, DXGI_FORMAT_R32G32B32A32_FLOAT, 16 },
+ },
+ },
+};
+
+const VertexBuffer11::VertexConverter &VertexBuffer11::getVertexConversion(const gl::VertexAttribute &attribute)
+{
+ unsigned int typeIndex = 0;
+ switch (attribute.mType)
+ {
+ case GL_BYTE: typeIndex = 0; break;
+ case GL_UNSIGNED_BYTE: typeIndex = 1; break;
+ case GL_SHORT: typeIndex = 2; break;
+ case GL_UNSIGNED_SHORT: typeIndex = 3; break;
+ case GL_FIXED: typeIndex = 4; break;
+ case GL_FLOAT: typeIndex = 5; break;
+ default: UNREACHABLE(); break;
+ }
+
+ return mPossibleTranslations[typeIndex][attribute.mNormalized][attribute.mSize - 1];
+}
+
+}
diff --git a/src/libGLESv2/renderer/VertexBuffer11.h b/src/libGLESv2/renderer/VertexBuffer11.h
new file mode 100644
index 0000000..d179e70
--- /dev/null
+++ b/src/libGLESv2/renderer/VertexBuffer11.h
@@ -0,0 +1,72 @@
+//
+// Copyright (c) 2012 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.
+//
+
+// VertexBuffer11.h: Defines the D3D11 VertexBuffer implementation.
+
+#ifndef LIBGLESV2_RENDERER_VERTEXBUFFER11_H_
+#define LIBGLESV2_RENDERER_VERTEXBUFFER11_H_
+
+#include "libGLESv2/renderer/VertexBuffer.h"
+#include "libGLESv2/renderer/Renderer11.h"
+
+#include <d3d11.h>
+
+namespace rx
+{
+
+class VertexBuffer11 : public VertexBuffer
+{
+ public:
+ explicit VertexBuffer11(rx::Renderer11 *const renderer);
+ virtual ~VertexBuffer11();
+
+ virtual bool initialize(unsigned int size, bool dynamicUsage);
+
+ static VertexBuffer11 *makeVertexBuffer11(VertexBuffer *vetexBuffer);
+
+ virtual bool storeVertexAttributes(const gl::VertexAttribute &attrib, GLint start, GLsizei count, GLsizei instances,
+ unsigned int offset);
+ virtual bool storeRawData(const void* data, unsigned int size, unsigned int offset);
+
+ virtual unsigned int getSpaceRequired(const gl::VertexAttribute &attrib, GLsizei count, GLsizei instances) const;
+
+ virtual unsigned int getBufferSize() const;
+ virtual bool setBufferSize(unsigned int size);
+ virtual bool discard();
+
+ unsigned int getVertexSize(const gl::VertexAttribute &attrib) const;
+ DXGI_FORMAT getDXGIFormat(const gl::VertexAttribute &attrib) const;
+
+ ID3D11Buffer *getBuffer() const;
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(VertexBuffer11);
+
+ rx::Renderer11 *const mRenderer;
+
+ ID3D11Buffer *mBuffer;
+ unsigned int mBufferSize;
+ bool mDynamicUsage;
+
+ typedef void (*VertexConversionFunction)(const void *, unsigned int, unsigned int, void *);
+ struct VertexConverter
+ {
+ VertexConversionFunction conversionFunc;
+ DXGI_FORMAT dxgiFormat;
+ unsigned int outputElementSize;
+ };
+
+ enum { NUM_GL_VERTEX_ATTRIB_TYPES = 6 };
+
+ // This table is used to generate mAttributeTypes.
+ static const VertexConverter mPossibleTranslations[NUM_GL_VERTEX_ATTRIB_TYPES][2][4]; // [GL types as enumerated by typeIndex()][normalized][size - 1]
+
+ static const VertexConverter &getVertexConversion(const gl::VertexAttribute &attribute);
+};
+
+}
+
+#endif // LIBGLESV2_RENDERER_VERTEXBUFFER11_H_
\ No newline at end of file