diff options
Diffstat (limited to 'src/3rdparty/angle/src/libANGLE/renderer/d3d/RendererD3D.cpp')
| -rw-r--r-- | src/3rdparty/angle/src/libANGLE/renderer/d3d/RendererD3D.cpp | 421 |
1 files changed, 248 insertions, 173 deletions
diff --git a/src/3rdparty/angle/src/libANGLE/renderer/d3d/RendererD3D.cpp b/src/3rdparty/angle/src/libANGLE/renderer/d3d/RendererD3D.cpp index 2ce0ce5a1b..105587f62c 100644 --- a/src/3rdparty/angle/src/libANGLE/renderer/d3d/RendererD3D.cpp +++ b/src/3rdparty/angle/src/libANGLE/renderer/d3d/RendererD3D.cpp @@ -8,18 +8,22 @@ #include "libANGLE/renderer/d3d/RendererD3D.h" +#include "common/debug.h" #include "common/MemoryBuffer.h" #include "common/utilities.h" #include "libANGLE/Display.h" +#include "libANGLE/formatutils.h" #include "libANGLE/Framebuffer.h" #include "libANGLE/FramebufferAttachment.h" -#include "libANGLE/ResourceManager.h" -#include "libANGLE/State.h" -#include "libANGLE/VertexArray.h" -#include "libANGLE/formatutils.h" #include "libANGLE/renderer/d3d/BufferD3D.h" +#include "libANGLE/renderer/d3d/DeviceD3D.h" #include "libANGLE/renderer/d3d/DisplayD3D.h" #include "libANGLE/renderer/d3d/IndexDataManager.h" +#include "libANGLE/renderer/d3d/ProgramD3D.h" +#include "libANGLE/renderer/d3d/SamplerD3D.h" +#include "libANGLE/ResourceManager.h" +#include "libANGLE/State.h" +#include "libANGLE/VertexArray.h" namespace rx { @@ -30,12 +34,17 @@ namespace // release and recreate the scratch buffer. This ensures we don't have a // degenerate case where we are stuck hogging memory. const int ScratchMemoryBufferLifetime = 1000; -} + +} // anonymous namespace RendererD3D::RendererD3D(egl::Display *display) : mDisplay(display), mDeviceLost(false), - mScratchMemoryBufferResetCounter(0) + mAnnotator(nullptr), + mPresentPathFastEnabled(false), + mScratchMemoryBufferResetCounter(0), + mWorkaroundsInitialized(false), + mDisjoint(false) { } @@ -47,35 +56,85 @@ RendererD3D::~RendererD3D() void RendererD3D::cleanup() { mScratchMemoryBuffer.resize(0); - for (auto it = mIncompleteTextures.begin(); it != mIncompleteTextures.end(); ++it) + for (auto &incompleteTexture : mIncompleteTextures) { - it->second.set(NULL); + incompleteTexture.second.set(NULL); } mIncompleteTextures.clear(); + + if (mAnnotator != nullptr) + { + gl::UninitializeDebugAnnotations(); + SafeDelete(mAnnotator); + } +} + +SamplerImpl *RendererD3D::createSampler() +{ + return new SamplerD3D(); } -// static -RendererD3D *RendererD3D::makeRendererD3D(Renderer *renderer) +gl::Error RendererD3D::drawArrays(const gl::Data &data, GLenum mode, GLint first, GLsizei count) { - ASSERT(HAS_DYNAMIC_TYPE(RendererD3D*, renderer)); - return static_cast<RendererD3D*>(renderer); + return genericDrawArrays(data, mode, first, count, 0); +} + +gl::Error RendererD3D::drawArraysInstanced(const gl::Data &data, + GLenum mode, + GLint first, + GLsizei count, + GLsizei instanceCount) +{ + return genericDrawArrays(data, mode, first, count, instanceCount); } gl::Error RendererD3D::drawElements(const gl::Data &data, - GLenum mode, GLsizei count, GLenum type, - const GLvoid *indices, GLsizei instances, - const RangeUI &indexRange) + GLenum mode, + GLsizei count, + GLenum type, + const GLvoid *indices, + const gl::IndexRange &indexRange) { - if (data.state->isPrimitiveRestartEnabled()) - { - UNIMPLEMENTED(); - return gl::Error(GL_INVALID_OPERATION, "Primitive restart not implemented"); - } + return genericDrawElements(data, mode, count, type, indices, 0, indexRange); +} + +gl::Error RendererD3D::drawElementsInstanced(const gl::Data &data, + GLenum mode, + GLsizei count, + GLenum type, + const GLvoid *indices, + GLsizei instances, + const gl::IndexRange &indexRange) +{ + return genericDrawElements(data, mode, count, type, indices, instances, indexRange); +} + +gl::Error RendererD3D::drawRangeElements(const gl::Data &data, + GLenum mode, + GLuint start, + GLuint end, + GLsizei count, + GLenum type, + const GLvoid *indices, + const gl::IndexRange &indexRange) +{ + return genericDrawElements(data, mode, count, type, indices, 0, indexRange); +} +gl::Error RendererD3D::genericDrawElements(const gl::Data &data, + GLenum mode, + GLsizei count, + GLenum type, + const GLvoid *indices, + GLsizei instances, + const gl::IndexRange &indexRange) +{ gl::Program *program = data.state->getProgram(); - ASSERT(program != NULL); + ASSERT(program != nullptr); + ProgramD3D *programD3D = GetImplAs<ProgramD3D>(program); + bool usesPointSize = programD3D->usesPointSize(); - program->updateSamplerMapping(); + programD3D->updateSamplerMapping(); gl::Error error = generateSwizzles(data); if (error.isError()) @@ -83,27 +142,21 @@ gl::Error RendererD3D::drawElements(const gl::Data &data, return error; } - if (!applyPrimitiveType(mode, count, program->usesPointSize())) + if (!applyPrimitiveType(mode, count, usesPointSize)) { return gl::Error(GL_NO_ERROR); } - error = applyRenderTarget(data, mode, false); - if (error.isError()) - { - return error; - } - - error = applyState(data, mode); + error = updateState(data, mode); if (error.isError()) { return error; } - gl::VertexArray *vao = data.state->getVertexArray(); TranslatedIndexData indexInfo; indexInfo.indexRange = indexRange; - error = applyIndexBuffer(indices, vao->getElementArrayBuffer(), count, mode, type, &indexInfo); + + error = applyIndexBuffer(data, indices, count, mode, type, &indexInfo); if (error.isError()) { return error; @@ -114,26 +167,27 @@ gl::Error RendererD3D::drawElements(const gl::Data &data, // layer. ASSERT(!data.state->isTransformFeedbackActiveUnpaused()); - GLsizei vertexCount = indexInfo.indexRange.length() + 1; - error = applyVertexBuffer(*data.state, mode, indexInfo.indexRange.start, vertexCount, instances); + size_t vertexCount = indexInfo.indexRange.vertexCount(); + error = applyVertexBuffer(*data.state, mode, static_cast<GLsizei>(indexInfo.indexRange.start), + static_cast<GLsizei>(vertexCount), instances, &indexInfo); if (error.isError()) { return error; } - error = applyShaders(data); + error = applyTextures(data); if (error.isError()) { return error; } - error = applyTextures(data); + error = applyShaders(data, mode); if (error.isError()) { return error; } - error = program->applyUniformBuffers(data); + error = programD3D->applyUniformBuffers(data); if (error.isError()) { return error; @@ -141,7 +195,7 @@ gl::Error RendererD3D::drawElements(const gl::Data &data, if (!skipDraw(data, mode)) { - error = drawElements(mode, count, type, indices, vao->getElementArrayBuffer(), indexInfo, instances); + error = drawElementsImpl(data, indexInfo, mode, count, type, indices, instances); if (error.isError()) { return error; @@ -151,14 +205,18 @@ gl::Error RendererD3D::drawElements(const gl::Data &data, return gl::Error(GL_NO_ERROR); } -gl::Error RendererD3D::drawArrays(const gl::Data &data, - GLenum mode, GLint first, - GLsizei count, GLsizei instances) +gl::Error RendererD3D::genericDrawArrays(const gl::Data &data, + GLenum mode, + GLint first, + GLsizei count, + GLsizei instances) { gl::Program *program = data.state->getProgram(); - ASSERT(program != NULL); + ASSERT(program != nullptr); + ProgramD3D *programD3D = GetImplAs<ProgramD3D>(program); + bool usesPointSize = programD3D->usesPointSize(); - program->updateSamplerMapping(); + programD3D->updateSamplerMapping(); gl::Error error = generateSwizzles(data); if (error.isError()) @@ -166,18 +224,12 @@ gl::Error RendererD3D::drawArrays(const gl::Data &data, return error; } - if (!applyPrimitiveType(mode, count, program->usesPointSize())) + if (!applyPrimitiveType(mode, count, usesPointSize)) { return gl::Error(GL_NO_ERROR); } - error = applyRenderTarget(data, mode, false); - if (error.isError()) - { - return error; - } - - error = applyState(data, mode); + error = updateState(data, mode); if (error.isError()) { return error; @@ -185,25 +237,25 @@ gl::Error RendererD3D::drawArrays(const gl::Data &data, applyTransformFeedbackBuffers(*data.state); - error = applyVertexBuffer(*data.state, mode, first, count, instances); + error = applyVertexBuffer(*data.state, mode, first, count, instances, nullptr); if (error.isError()) { return error; } - error = applyShaders(data); + error = applyTextures(data); if (error.isError()) { return error; } - error = applyTextures(data); + error = applyShaders(data, mode); if (error.isError()) { return error; } - error = program->applyUniformBuffers(data); + error = programD3D->applyUniformBuffers(data); if (error.isError()) { return error; @@ -211,7 +263,7 @@ gl::Error RendererD3D::drawArrays(const gl::Data &data, if (!skipDraw(data, mode)) { - error = drawArrays(data, mode, count, instances, program->usesPointSize()); + error = drawArraysImpl(data, mode, count, instances); if (error.isError()) { return error; @@ -228,19 +280,19 @@ gl::Error RendererD3D::drawArrays(const gl::Data &data, gl::Error RendererD3D::generateSwizzles(const gl::Data &data, gl::SamplerType type) { - gl::Program *program = data.state->getProgram(); + ProgramD3D *programD3D = GetImplAs<ProgramD3D>(data.state->getProgram()); - size_t samplerRange = program->getUsedSamplerRange(type); + unsigned int samplerRange = static_cast<unsigned int>(programD3D->getUsedSamplerRange(type)); - for (size_t i = 0; i < samplerRange; i++) + for (unsigned int i = 0; i < samplerRange; i++) { - GLenum textureType = program->getSamplerTextureType(type, i); - GLint textureUnit = program->getSamplerMapping(type, i, *data.caps); + GLenum textureType = programD3D->getSamplerTextureType(type, i); + GLint textureUnit = programD3D->getSamplerMapping(type, i, *data.caps); if (textureUnit != -1) { gl::Texture *texture = data.state->getSamplerTexture(textureUnit, textureType); ASSERT(texture); - if (texture->getSamplerState().swizzleRequired()) + if (texture->getTextureState().swizzleRequired()) { gl::Error error = generateSwizzle(texture); if (error.isError()) @@ -271,51 +323,12 @@ gl::Error RendererD3D::generateSwizzles(const gl::Data &data) return gl::Error(GL_NO_ERROR); } -// Applies the render target surface, depth stencil surface, viewport rectangle and -// scissor rectangle to the renderer -gl::Error RendererD3D::applyRenderTarget(const gl::Data &data, GLenum drawMode, bool ignoreViewport) -{ - const gl::Framebuffer *framebufferObject = data.state->getDrawFramebuffer(); - ASSERT(framebufferObject && framebufferObject->checkStatus(data) == GL_FRAMEBUFFER_COMPLETE); - - gl::Error error = applyRenderTarget(framebufferObject); - if (error.isError()) - { - return error; - } - - float nearZ, farZ; - data.state->getDepthRange(&nearZ, &farZ); - setViewport(data.state->getViewport(), nearZ, farZ, drawMode, - data.state->getRasterizerState().frontFace, ignoreViewport); - - setScissorRectangle(data.state->getScissor(), data.state->isScissorTestEnabled()); - - return gl::Error(GL_NO_ERROR); -} - -// Applies the fixed-function state (culling, depth test, alpha blending, stenciling, etc) to the Direct3D device -gl::Error RendererD3D::applyState(const gl::Data &data, GLenum drawMode) +unsigned int RendererD3D::GetBlendSampleMask(const gl::Data &data, int samples) { - const gl::Framebuffer *framebufferObject = data.state->getDrawFramebuffer(); - int samples = framebufferObject->getSamples(data); - - gl::RasterizerState rasterizer = data.state->getRasterizerState(); - rasterizer.pointDrawMode = (drawMode == GL_POINTS); - rasterizer.multiSample = (samples != 0); - - gl::Error error = setRasterizerState(rasterizer); - if (error.isError()) - { - return error; - } - unsigned int mask = 0; if (data.state->isSampleCoverageEnabled()) { - GLclampf coverageValue; - bool coverageInvert = false; - data.state->getSampleCoverageParams(&coverageValue, &coverageInvert); + GLclampf coverageValue = data.state->getSampleCoverageValue(); if (coverageValue != 0) { float threshold = 0.5f; @@ -332,6 +345,7 @@ gl::Error RendererD3D::applyState(const gl::Data &data, GLenum drawMode) } } + bool coverageInvert = data.state->getSampleCoverageInvert(); if (coverageInvert) { mask = ~mask; @@ -341,71 +355,58 @@ gl::Error RendererD3D::applyState(const gl::Data &data, GLenum drawMode) { mask = 0xFFFFFFFF; } - error = setBlendState(framebufferObject, data.state->getBlendState(), data.state->getBlendColor(), mask); - if (error.isError()) - { - return error; - } - - error = setDepthStencilState(data.state->getDepthStencilState(), data.state->getStencilRef(), - data.state->getStencilBackRef(), rasterizer.frontFace == GL_CCW); - if (error.isError()) - { - return error; - } - return gl::Error(GL_NO_ERROR); + return mask; } // Applies the shaders and shader constants to the Direct3D device -gl::Error RendererD3D::applyShaders(const gl::Data &data) +gl::Error RendererD3D::applyShaders(const gl::Data &data, GLenum drawMode) { gl::Program *program = data.state->getProgram(); + ProgramD3D *programD3D = GetImplAs<ProgramD3D>(program); + programD3D->updateCachedInputLayout(*data.state); - gl::VertexFormat inputLayout[gl::MAX_VERTEX_ATTRIBS]; - gl::VertexFormat::GetInputLayout(inputLayout, program, *data.state); - - const gl::Framebuffer *fbo = data.state->getDrawFramebuffer(); - - gl::Error error = applyShaders(program, inputLayout, fbo, data.state->getRasterizerState().rasterizerDiscard, data.state->isTransformFeedbackActiveUnpaused()); + gl::Error error = applyShadersImpl(data, drawMode); if (error.isError()) { return error; } - return program->applyUniforms(); + return programD3D->applyUniforms(drawMode); } // For each Direct3D sampler of either the pixel or vertex stage, // looks up the corresponding OpenGL texture image unit and texture type, // and sets the texture and its addressing/filtering state (or NULL when inactive). +// Sampler mapping needs to be up-to-date on the program object before this is called. gl::Error RendererD3D::applyTextures(const gl::Data &data, gl::SamplerType shaderType, - const FramebufferTextureSerialArray &framebufferSerials, size_t framebufferSerialCount) + const FramebufferTextureArray &framebufferTextures, size_t framebufferTextureCount) { - gl::Program *program = data.state->getProgram(); + ProgramD3D *programD3D = GetImplAs<ProgramD3D>(data.state->getProgram()); + + ASSERT(!programD3D->isSamplerMappingDirty()); - size_t samplerRange = program->getUsedSamplerRange(shaderType); - for (size_t samplerIndex = 0; samplerIndex < samplerRange; samplerIndex++) + unsigned int samplerRange = programD3D->getUsedSamplerRange(shaderType); + for (unsigned int samplerIndex = 0; samplerIndex < samplerRange; samplerIndex++) { - GLenum textureType = program->getSamplerTextureType(shaderType, samplerIndex); - GLint textureUnit = program->getSamplerMapping(shaderType, samplerIndex, *data.caps); + GLenum textureType = programD3D->getSamplerTextureType(shaderType, samplerIndex); + GLint textureUnit = programD3D->getSamplerMapping(shaderType, samplerIndex, *data.caps); if (textureUnit != -1) { gl::Texture *texture = data.state->getSamplerTexture(textureUnit, textureType); ASSERT(texture); - gl::SamplerState sampler = texture->getSamplerState(); gl::Sampler *samplerObject = data.state->getSampler(textureUnit); - if (samplerObject) - { - samplerObject->getState(&sampler); - } + + const gl::SamplerState &samplerState = + samplerObject ? samplerObject->getSamplerState() : texture->getSamplerState(); // TODO: std::binary_search may become unavailable using older versions of GCC - if (texture->isSamplerComplete(sampler, data) && - !std::binary_search(framebufferSerials.begin(), framebufferSerials.begin() + framebufferSerialCount, texture->getTextureSerial())) + if (texture->isSamplerComplete(samplerState, data) && + !std::binary_search(framebufferTextures.begin(), + framebufferTextures.begin() + framebufferTextureCount, texture)) { - gl::Error error = setSamplerState(shaderType, samplerIndex, texture, sampler); + gl::Error error = setSamplerState(shaderType, samplerIndex, texture, samplerState); if (error.isError()) { return error; @@ -421,7 +422,15 @@ gl::Error RendererD3D::applyTextures(const gl::Data &data, gl::SamplerType shade { // Texture is not sampler complete or it is in use by the framebuffer. Bind the incomplete texture. gl::Texture *incompleteTexture = getIncompleteTexture(textureType); - gl::Error error = setTexture(shaderType, samplerIndex, incompleteTexture); + + gl::Error error = setSamplerState(shaderType, samplerIndex, incompleteTexture, + incompleteTexture->getSamplerState()); + if (error.isError()) + { + return error; + } + + error = setTexture(shaderType, samplerIndex, incompleteTexture); if (error.isError()) { return error; @@ -442,30 +451,23 @@ gl::Error RendererD3D::applyTextures(const gl::Data &data, gl::SamplerType shade // Set all the remaining textures to NULL size_t samplerCount = (shaderType == gl::SAMPLER_PIXEL) ? data.caps->maxTextureImageUnits : data.caps->maxVertexTextureImageUnits; - for (size_t samplerIndex = samplerRange; samplerIndex < samplerCount; samplerIndex++) - { - gl::Error error = setTexture(shaderType, samplerIndex, NULL); - if (error.isError()) - { - return error; - } - } + clearTextures(shaderType, samplerRange, samplerCount); return gl::Error(GL_NO_ERROR); } gl::Error RendererD3D::applyTextures(const gl::Data &data) { - FramebufferTextureSerialArray framebufferSerials; - size_t framebufferSerialCount = getBoundFramebufferTextureSerials(data, &framebufferSerials); + FramebufferTextureArray framebufferTextures; + size_t framebufferSerialCount = getBoundFramebufferTextures(data, &framebufferTextures); - gl::Error error = applyTextures(data, gl::SAMPLER_VERTEX, framebufferSerials, framebufferSerialCount); + gl::Error error = applyTextures(data, gl::SAMPLER_VERTEX, framebufferTextures, framebufferSerialCount); if (error.isError()) { return error; } - error = applyTextures(data, gl::SAMPLER_PIXEL, framebufferSerials, framebufferSerialCount); + error = applyTextures(data, gl::SAMPLER_PIXEL, framebufferTextures, framebufferSerialCount); if (error.isError()) { return error; @@ -476,12 +478,16 @@ gl::Error RendererD3D::applyTextures(const gl::Data &data) bool RendererD3D::skipDraw(const gl::Data &data, GLenum drawMode) { + const gl::State &state = *data.state; + if (drawMode == GL_POINTS) { + bool usesPointSize = GetImplAs<ProgramD3D>(state.getProgram())->usesPointSize(); + // ProgramBinary assumes non-point rendering if gl_PointSize isn't written, // which affects varying interpolation. Since the value of gl_PointSize is // undefined when not written, just skip drawing to avoid unexpected results. - if (!data.state->getProgram()->usesPointSize() && !data.state->isTransformFeedbackActiveUnpaused()) + if (!usesPointSize && !state.isTransformFeedbackActiveUnpaused()) { // This is stictly speaking not an error, but developers should be // notified of risking undefined behavior. @@ -492,7 +498,8 @@ bool RendererD3D::skipDraw(const gl::Data &data, GLenum drawMode) } else if (gl::IsTriangleMode(drawMode)) { - if (data.state->getRasterizerState().cullFace && data.state->getRasterizerState().cullMode == GL_FRONT_AND_BACK) + if (state.getRasterizerState().cullFace && + state.getRasterizerState().cullMode == GL_FRONT_AND_BACK) { return true; } @@ -503,43 +510,41 @@ bool RendererD3D::skipDraw(const gl::Data &data, GLenum drawMode) void RendererD3D::markTransformFeedbackUsage(const gl::Data &data) { - for (size_t i = 0; i < data.caps->maxTransformFeedbackSeparateAttributes; i++) + const gl::TransformFeedback *transformFeedback = data.state->getCurrentTransformFeedback(); + for (size_t i = 0; i < transformFeedback->getIndexedBufferCount(); i++) { - gl::Buffer *buffer = data.state->getIndexedTransformFeedbackBuffer(i); - if (buffer) + const OffsetBindingPointer<gl::Buffer> &binding = transformFeedback->getIndexedBuffer(i); + if (binding.get() != nullptr) { - BufferD3D *bufferD3D = GetImplAs<BufferD3D>(buffer); + BufferD3D *bufferD3D = GetImplAs<BufferD3D>(binding.get()); bufferD3D->markTransformFeedbackUsage(); } } } -size_t RendererD3D::getBoundFramebufferTextureSerials(const gl::Data &data, - FramebufferTextureSerialArray *outSerialArray) +size_t RendererD3D::getBoundFramebufferTextures(const gl::Data &data, FramebufferTextureArray *outTextureArray) { - size_t serialCount = 0; + size_t textureCount = 0; const gl::Framebuffer *drawFramebuffer = data.state->getDrawFramebuffer(); - for (unsigned int i = 0; i < data.caps->maxColorAttachments; i++) + for (size_t i = 0; i < drawFramebuffer->getNumColorBuffers(); i++) { - gl::FramebufferAttachment *attachment = drawFramebuffer->getColorbuffer(i); + const gl::FramebufferAttachment *attachment = drawFramebuffer->getColorbuffer(i); if (attachment && attachment->type() == GL_TEXTURE) { - gl::Texture *texture = attachment->getTexture(); - (*outSerialArray)[serialCount++] = texture->getTextureSerial(); + (*outTextureArray)[textureCount++] = attachment->getTexture(); } } - gl::FramebufferAttachment *depthStencilAttachment = drawFramebuffer->getDepthOrStencilbuffer(); + const gl::FramebufferAttachment *depthStencilAttachment = drawFramebuffer->getDepthOrStencilbuffer(); if (depthStencilAttachment && depthStencilAttachment->type() == GL_TEXTURE) { - gl::Texture *depthStencilTexture = depthStencilAttachment->getTexture(); - (*outSerialArray)[serialCount++] = depthStencilTexture->getTextureSerial(); + (*outTextureArray)[textureCount++] = depthStencilAttachment->getTexture(); } - std::sort(outSerialArray->begin(), outSerialArray->begin() + serialCount); + std::sort(outTextureArray->begin(), outTextureArray->begin() + textureCount); - return serialCount; + return textureCount; } gl::Texture *RendererD3D::getIncompleteTexture(GLenum type) @@ -548,20 +553,26 @@ gl::Texture *RendererD3D::getIncompleteTexture(GLenum type) { const GLubyte color[] = { 0, 0, 0, 255 }; const gl::Extents colorSize(1, 1, 1); - const gl::PixelUnpackState incompleteUnpackState(1, 0); + const gl::PixelUnpackState unpack(1, 0); + const gl::Box area(0, 0, 0, 1, 1, 1); - gl::Texture* t = new gl::Texture(createTexture(type), gl::Texture::INCOMPLETE_TEXTURE_ID, type); + // Skip the API layer to avoid needing to pass the Context and mess with dirty bits. + gl::Texture *t = + new gl::Texture(createTexture(type), std::numeric_limits<GLuint>::max(), type); + t->setStorage(type, 1, GL_RGBA8, colorSize); if (type == GL_TEXTURE_CUBE_MAP) { for (GLenum face = GL_TEXTURE_CUBE_MAP_POSITIVE_X; face <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z; face++) { - t->setImage(face, 0, GL_RGBA, colorSize, GL_RGBA, GL_UNSIGNED_BYTE, incompleteUnpackState, color); + t->getImplementation()->setSubImage(face, 0, area, GL_RGBA8, GL_UNSIGNED_BYTE, + unpack, color); } } else { - t->setImage(type, 0, GL_RGBA, colorSize, GL_RGBA, GL_UNSIGNED_BYTE, incompleteUnpackState, color); + t->getImplementation()->setSubImage(type, 0, area, GL_RGBA8, GL_UNSIGNED_BYTE, unpack, + color); } mIncompleteTextures[type].set(t); @@ -625,4 +636,68 @@ gl::Error RendererD3D::getScratchMemoryBuffer(size_t requestedSize, MemoryBuffer return gl::Error(GL_NO_ERROR); } +void RendererD3D::insertEventMarker(GLsizei length, const char *marker) +{ + std::vector<wchar_t> wcstring (length + 1); + size_t convertedChars = 0; + errno_t err = mbstowcs_s(&convertedChars, wcstring.data(), length + 1, marker, _TRUNCATE); + if (err == 0) + { + getAnnotator()->setMarker(wcstring.data()); + } +} + +void RendererD3D::pushGroupMarker(GLsizei length, const char *marker) +{ + std::vector<wchar_t> wcstring(length + 1); + size_t convertedChars = 0; + errno_t err = mbstowcs_s(&convertedChars, wcstring.data(), length + 1, marker, _TRUNCATE); + if (err == 0) + { + getAnnotator()->beginEvent(wcstring.data()); + } +} + +void RendererD3D::popGroupMarker() +{ + getAnnotator()->endEvent(); +} + +void RendererD3D::setGPUDisjoint() +{ + mDisjoint = true; +} + +GLint RendererD3D::getGPUDisjoint() +{ + bool disjoint = mDisjoint; + + // Disjoint flag is cleared when read + mDisjoint = false; + + return disjoint; +} + +GLint64 RendererD3D::getTimestamp() +{ + // D3D has no way to get an actual timestamp reliably so 0 is returned + return 0; +} + +void RendererD3D::onMakeCurrent(const gl::Data &data) +{ +} + +void RendererD3D::initializeDebugAnnotator() +{ + createAnnotator(); + ASSERT(mAnnotator); + gl::InitializeDebugAnnotations(mAnnotator); +} + +gl::DebugAnnotator *RendererD3D::getAnnotator() +{ + ASSERT(mAnnotator); + return mAnnotator; +} } |