| // | |
| // Copyright 2002 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. | |
| // | |
| // renderer9_utils.cpp: Conversion functions and other utility routines | |
| // specific to the D3D9 renderer. | |
| #include "libANGLE/renderer/d3d/d3d9/renderer9_utils.h" | |
| #include "common/debug.h" | |
| #include "common/mathutil.h" | |
| #include "libANGLE/formatutils.h" | |
| #include "libANGLE/renderer/d3d/d3d9/RenderTarget9.h" | |
| #include "libANGLE/renderer/d3d/d3d9/formatutils9.h" | |
| #include "libANGLE/renderer/driver_utils.h" | |
| #include "platform/FeaturesD3D.h" | |
| #include "platform/Platform.h" | |
| #include "third_party/systeminfo/SystemInfo.h" | |
| namespace rx | |
| { | |
| namespace gl_d3d9 | |
| { | |
| D3DCMPFUNC ConvertComparison(GLenum comparison) | |
| { | |
| D3DCMPFUNC d3dComp = D3DCMP_ALWAYS; | |
| switch (comparison) | |
| { | |
| case GL_NEVER: | |
| d3dComp = D3DCMP_NEVER; | |
| break; | |
| case GL_ALWAYS: | |
| d3dComp = D3DCMP_ALWAYS; | |
| break; | |
| case GL_LESS: | |
| d3dComp = D3DCMP_LESS; | |
| break; | |
| case GL_LEQUAL: | |
| d3dComp = D3DCMP_LESSEQUAL; | |
| break; | |
| case GL_EQUAL: | |
| d3dComp = D3DCMP_EQUAL; | |
| break; | |
| case GL_GREATER: | |
| d3dComp = D3DCMP_GREATER; | |
| break; | |
| case GL_GEQUAL: | |
| d3dComp = D3DCMP_GREATEREQUAL; | |
| break; | |
| case GL_NOTEQUAL: | |
| d3dComp = D3DCMP_NOTEQUAL; | |
| break; | |
| default: | |
| UNREACHABLE(); | |
| } | |
| return d3dComp; | |
| } | |
| D3DCOLOR ConvertColor(gl::ColorF color) | |
| { | |
| return D3DCOLOR_RGBA(gl::unorm<8>(color.red), gl::unorm<8>(color.green), | |
| gl::unorm<8>(color.blue), gl::unorm<8>(color.alpha)); | |
| } | |
| D3DBLEND ConvertBlendFunc(GLenum blend) | |
| { | |
| D3DBLEND d3dBlend = D3DBLEND_ZERO; | |
| switch (blend) | |
| { | |
| case GL_ZERO: | |
| d3dBlend = D3DBLEND_ZERO; | |
| break; | |
| case GL_ONE: | |
| d3dBlend = D3DBLEND_ONE; | |
| break; | |
| case GL_SRC_COLOR: | |
| d3dBlend = D3DBLEND_SRCCOLOR; | |
| break; | |
| case GL_ONE_MINUS_SRC_COLOR: | |
| d3dBlend = D3DBLEND_INVSRCCOLOR; | |
| break; | |
| case GL_DST_COLOR: | |
| d3dBlend = D3DBLEND_DESTCOLOR; | |
| break; | |
| case GL_ONE_MINUS_DST_COLOR: | |
| d3dBlend = D3DBLEND_INVDESTCOLOR; | |
| break; | |
| case GL_SRC_ALPHA: | |
| d3dBlend = D3DBLEND_SRCALPHA; | |
| break; | |
| case GL_ONE_MINUS_SRC_ALPHA: | |
| d3dBlend = D3DBLEND_INVSRCALPHA; | |
| break; | |
| case GL_DST_ALPHA: | |
| d3dBlend = D3DBLEND_DESTALPHA; | |
| break; | |
| case GL_ONE_MINUS_DST_ALPHA: | |
| d3dBlend = D3DBLEND_INVDESTALPHA; | |
| break; | |
| case GL_CONSTANT_COLOR: | |
| d3dBlend = D3DBLEND_BLENDFACTOR; | |
| break; | |
| case GL_ONE_MINUS_CONSTANT_COLOR: | |
| d3dBlend = D3DBLEND_INVBLENDFACTOR; | |
| break; | |
| case GL_CONSTANT_ALPHA: | |
| d3dBlend = D3DBLEND_BLENDFACTOR; | |
| break; | |
| case GL_ONE_MINUS_CONSTANT_ALPHA: | |
| d3dBlend = D3DBLEND_INVBLENDFACTOR; | |
| break; | |
| case GL_SRC_ALPHA_SATURATE: | |
| d3dBlend = D3DBLEND_SRCALPHASAT; | |
| break; | |
| default: | |
| UNREACHABLE(); | |
| } | |
| return d3dBlend; | |
| } | |
| D3DBLENDOP ConvertBlendOp(GLenum blendOp) | |
| { | |
| D3DBLENDOP d3dBlendOp = D3DBLENDOP_ADD; | |
| switch (blendOp) | |
| { | |
| case GL_FUNC_ADD: | |
| d3dBlendOp = D3DBLENDOP_ADD; | |
| break; | |
| case GL_FUNC_SUBTRACT: | |
| d3dBlendOp = D3DBLENDOP_SUBTRACT; | |
| break; | |
| case GL_FUNC_REVERSE_SUBTRACT: | |
| d3dBlendOp = D3DBLENDOP_REVSUBTRACT; | |
| break; | |
| case GL_MIN_EXT: | |
| d3dBlendOp = D3DBLENDOP_MIN; | |
| break; | |
| case GL_MAX_EXT: | |
| d3dBlendOp = D3DBLENDOP_MAX; | |
| break; | |
| default: | |
| UNREACHABLE(); | |
| } | |
| return d3dBlendOp; | |
| } | |
| D3DSTENCILOP ConvertStencilOp(GLenum stencilOp) | |
| { | |
| D3DSTENCILOP d3dStencilOp = D3DSTENCILOP_KEEP; | |
| switch (stencilOp) | |
| { | |
| case GL_ZERO: | |
| d3dStencilOp = D3DSTENCILOP_ZERO; | |
| break; | |
| case GL_KEEP: | |
| d3dStencilOp = D3DSTENCILOP_KEEP; | |
| break; | |
| case GL_REPLACE: | |
| d3dStencilOp = D3DSTENCILOP_REPLACE; | |
| break; | |
| case GL_INCR: | |
| d3dStencilOp = D3DSTENCILOP_INCRSAT; | |
| break; | |
| case GL_DECR: | |
| d3dStencilOp = D3DSTENCILOP_DECRSAT; | |
| break; | |
| case GL_INVERT: | |
| d3dStencilOp = D3DSTENCILOP_INVERT; | |
| break; | |
| case GL_INCR_WRAP: | |
| d3dStencilOp = D3DSTENCILOP_INCR; | |
| break; | |
| case GL_DECR_WRAP: | |
| d3dStencilOp = D3DSTENCILOP_DECR; | |
| break; | |
| default: | |
| UNREACHABLE(); | |
| } | |
| return d3dStencilOp; | |
| } | |
| D3DTEXTUREADDRESS ConvertTextureWrap(GLenum wrap) | |
| { | |
| D3DTEXTUREADDRESS d3dWrap = D3DTADDRESS_WRAP; | |
| switch (wrap) | |
| { | |
| case GL_REPEAT: | |
| d3dWrap = D3DTADDRESS_WRAP; | |
| break; | |
| case GL_CLAMP_TO_EDGE: | |
| d3dWrap = D3DTADDRESS_CLAMP; | |
| break; | |
| case GL_CLAMP_TO_BORDER: | |
| d3dWrap = D3DTADDRESS_BORDER; | |
| break; | |
| case GL_MIRRORED_REPEAT: | |
| d3dWrap = D3DTADDRESS_MIRROR; | |
| break; | |
| default: | |
| UNREACHABLE(); | |
| } | |
| return d3dWrap; | |
| } | |
| D3DCULL ConvertCullMode(gl::CullFaceMode cullFace, GLenum frontFace) | |
| { | |
| D3DCULL cull = D3DCULL_CCW; | |
| switch (cullFace) | |
| { | |
| case gl::CullFaceMode::Front: | |
| cull = (frontFace == GL_CCW ? D3DCULL_CW : D3DCULL_CCW); | |
| break; | |
| case gl::CullFaceMode::Back: | |
| cull = (frontFace == GL_CCW ? D3DCULL_CCW : D3DCULL_CW); | |
| break; | |
| case gl::CullFaceMode::FrontAndBack: | |
| cull = D3DCULL_NONE; // culling will be handled during draw | |
| break; | |
| default: | |
| UNREACHABLE(); | |
| } | |
| return cull; | |
| } | |
| D3DCUBEMAP_FACES ConvertCubeFace(gl::TextureTarget cubeFace) | |
| { | |
| D3DCUBEMAP_FACES face = D3DCUBEMAP_FACE_POSITIVE_X; | |
| switch (cubeFace) | |
| { | |
| case gl::TextureTarget::CubeMapPositiveX: | |
| face = D3DCUBEMAP_FACE_POSITIVE_X; | |
| break; | |
| case gl::TextureTarget::CubeMapNegativeX: | |
| face = D3DCUBEMAP_FACE_NEGATIVE_X; | |
| break; | |
| case gl::TextureTarget::CubeMapPositiveY: | |
| face = D3DCUBEMAP_FACE_POSITIVE_Y; | |
| break; | |
| case gl::TextureTarget::CubeMapNegativeY: | |
| face = D3DCUBEMAP_FACE_NEGATIVE_Y; | |
| break; | |
| case gl::TextureTarget::CubeMapPositiveZ: | |
| face = D3DCUBEMAP_FACE_POSITIVE_Z; | |
| break; | |
| case gl::TextureTarget::CubeMapNegativeZ: | |
| face = D3DCUBEMAP_FACE_NEGATIVE_Z; | |
| break; | |
| default: | |
| UNREACHABLE(); | |
| } | |
| return face; | |
| } | |
| DWORD ConvertColorMask(bool red, bool green, bool blue, bool alpha) | |
| { | |
| return (red ? D3DCOLORWRITEENABLE_RED : 0) | (green ? D3DCOLORWRITEENABLE_GREEN : 0) | | |
| (blue ? D3DCOLORWRITEENABLE_BLUE : 0) | (alpha ? D3DCOLORWRITEENABLE_ALPHA : 0); | |
| } | |
| D3DTEXTUREFILTERTYPE ConvertMagFilter(GLenum magFilter, float maxAnisotropy) | |
| { | |
| if (maxAnisotropy > 1.0f) | |
| { | |
| return D3DTEXF_ANISOTROPIC; | |
| } | |
| D3DTEXTUREFILTERTYPE d3dMagFilter = D3DTEXF_POINT; | |
| switch (magFilter) | |
| { | |
| case GL_NEAREST: | |
| d3dMagFilter = D3DTEXF_POINT; | |
| break; | |
| case GL_LINEAR: | |
| d3dMagFilter = D3DTEXF_LINEAR; | |
| break; | |
| default: | |
| UNREACHABLE(); | |
| } | |
| return d3dMagFilter; | |
| } | |
| void ConvertMinFilter(GLenum minFilter, | |
| D3DTEXTUREFILTERTYPE *d3dMinFilter, | |
| D3DTEXTUREFILTERTYPE *d3dMipFilter, | |
| float *d3dLodBias, | |
| float maxAnisotropy, | |
| size_t baseLevel) | |
| { | |
| switch (minFilter) | |
| { | |
| case GL_NEAREST: | |
| *d3dMinFilter = D3DTEXF_POINT; | |
| *d3dMipFilter = D3DTEXF_NONE; | |
| break; | |
| case GL_LINEAR: | |
| *d3dMinFilter = D3DTEXF_LINEAR; | |
| *d3dMipFilter = D3DTEXF_NONE; | |
| break; | |
| case GL_NEAREST_MIPMAP_NEAREST: | |
| *d3dMinFilter = D3DTEXF_POINT; | |
| *d3dMipFilter = D3DTEXF_POINT; | |
| break; | |
| case GL_LINEAR_MIPMAP_NEAREST: | |
| *d3dMinFilter = D3DTEXF_LINEAR; | |
| *d3dMipFilter = D3DTEXF_POINT; | |
| break; | |
| case GL_NEAREST_MIPMAP_LINEAR: | |
| *d3dMinFilter = D3DTEXF_POINT; | |
| *d3dMipFilter = D3DTEXF_LINEAR; | |
| break; | |
| case GL_LINEAR_MIPMAP_LINEAR: | |
| *d3dMinFilter = D3DTEXF_LINEAR; | |
| *d3dMipFilter = D3DTEXF_LINEAR; | |
| break; | |
| default: | |
| *d3dMinFilter = D3DTEXF_POINT; | |
| *d3dMipFilter = D3DTEXF_NONE; | |
| UNREACHABLE(); | |
| } | |
| // Disabling mipmapping will always sample from level 0 of the texture. It is possible to work | |
| // around this by modifying D3DSAMP_MAXMIPLEVEL to force a specific mip level to become the | |
| // lowest sampled mip level and using a large negative value for D3DSAMP_MIPMAPLODBIAS to | |
| // ensure that only the base mip level is sampled. | |
| if (baseLevel > 0 && *d3dMipFilter == D3DTEXF_NONE) | |
| { | |
| *d3dMipFilter = D3DTEXF_POINT; | |
| *d3dLodBias = -static_cast<float>(gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS); | |
| } | |
| else | |
| { | |
| *d3dLodBias = 0.0f; | |
| } | |
| if (maxAnisotropy > 1.0f) | |
| { | |
| *d3dMinFilter = D3DTEXF_ANISOTROPIC; | |
| } | |
| } | |
| D3DQUERYTYPE ConvertQueryType(gl::QueryType type) | |
| { | |
| switch (type) | |
| { | |
| case gl::QueryType::AnySamples: | |
| case gl::QueryType::AnySamplesConservative: | |
| return D3DQUERYTYPE_OCCLUSION; | |
| case gl::QueryType::CommandsCompleted: | |
| return D3DQUERYTYPE_EVENT; | |
| default: | |
| UNREACHABLE(); | |
| return static_cast<D3DQUERYTYPE>(0); | |
| } | |
| } | |
| D3DMULTISAMPLE_TYPE GetMultisampleType(GLuint samples) | |
| { | |
| return (samples > 1) ? static_cast<D3DMULTISAMPLE_TYPE>(samples) : D3DMULTISAMPLE_NONE; | |
| } | |
| } // namespace gl_d3d9 | |
| namespace d3d9_gl | |
| { | |
| unsigned int GetReservedVaryingVectors() | |
| { | |
| // We reserve two registers for "dx_Position" and "gl_Position". The spec says they | |
| // don't count towards the varying limit, so we must make space for them. We also | |
| // reserve the last register since it can only pass a PSIZE, and not any arbitrary | |
| // varying. | |
| return 3; | |
| } | |
| unsigned int GetReservedVertexUniformVectors() | |
| { | |
| return 3; // dx_ViewCoords, dx_ViewAdjust and dx_DepthRange. | |
| } | |
| unsigned int GetReservedFragmentUniformVectors() | |
| { | |
| return 3; // dx_ViewCoords, dx_DepthFront and dx_DepthRange. | |
| } | |
| GLsizei GetSamplesCount(D3DMULTISAMPLE_TYPE type) | |
| { | |
| return (type != D3DMULTISAMPLE_NONMASKABLE) ? type : 0; | |
| } | |
| bool IsFormatChannelEquivalent(D3DFORMAT d3dformat, GLenum format) | |
| { | |
| GLenum internalFormat = d3d9::GetD3DFormatInfo(d3dformat).info().glInternalFormat; | |
| GLenum convertedFormat = gl::GetSizedInternalFormatInfo(internalFormat).format; | |
| return convertedFormat == format; | |
| } | |
| static gl::TextureCaps GenerateTextureFormatCaps(GLenum internalFormat, | |
| IDirect3D9 *d3d9, | |
| D3DDEVTYPE deviceType, | |
| UINT adapter, | |
| D3DFORMAT adapterFormat) | |
| { | |
| gl::TextureCaps textureCaps; | |
| const d3d9::TextureFormat &d3dFormatInfo = d3d9::GetTextureFormatInfo(internalFormat); | |
| const gl::InternalFormat &formatInfo = gl::GetSizedInternalFormatInfo(internalFormat); | |
| if (d3dFormatInfo.texFormat != D3DFMT_UNKNOWN) | |
| { | |
| if (formatInfo.depthBits > 0 || formatInfo.stencilBits > 0) | |
| { | |
| textureCaps.texturable = SUCCEEDED(d3d9->CheckDeviceFormat( | |
| adapter, deviceType, adapterFormat, 0, D3DRTYPE_TEXTURE, d3dFormatInfo.texFormat)); | |
| } | |
| else | |
| { | |
| textureCaps.texturable = | |
| SUCCEEDED(d3d9->CheckDeviceFormat(adapter, deviceType, adapterFormat, 0, | |
| D3DRTYPE_TEXTURE, d3dFormatInfo.texFormat)) && | |
| SUCCEEDED(d3d9->CheckDeviceFormat(adapter, deviceType, adapterFormat, 0, | |
| D3DRTYPE_CUBETEXTURE, d3dFormatInfo.texFormat)); | |
| } | |
| textureCaps.filterable = SUCCEEDED( | |
| d3d9->CheckDeviceFormat(adapter, deviceType, adapterFormat, D3DUSAGE_QUERY_FILTER, | |
| D3DRTYPE_TEXTURE, d3dFormatInfo.texFormat)); | |
| } | |
| if (d3dFormatInfo.renderFormat != D3DFMT_UNKNOWN) | |
| { | |
| textureCaps.textureAttachment = SUCCEEDED( | |
| d3d9->CheckDeviceFormat(adapter, deviceType, adapterFormat, D3DUSAGE_RENDERTARGET, | |
| D3DRTYPE_TEXTURE, d3dFormatInfo.renderFormat)); | |
| if ((formatInfo.depthBits > 0 || formatInfo.stencilBits > 0) && | |
| !textureCaps.textureAttachment) | |
| { | |
| textureCaps.textureAttachment = SUCCEEDED( | |
| d3d9->CheckDeviceFormat(adapter, deviceType, adapterFormat, D3DUSAGE_DEPTHSTENCIL, | |
| D3DRTYPE_TEXTURE, d3dFormatInfo.renderFormat)); | |
| } | |
| textureCaps.renderbuffer = textureCaps.textureAttachment; | |
| textureCaps.sampleCounts.insert(1); | |
| for (unsigned int i = D3DMULTISAMPLE_2_SAMPLES; i <= D3DMULTISAMPLE_16_SAMPLES; i++) | |
| { | |
| D3DMULTISAMPLE_TYPE multisampleType = D3DMULTISAMPLE_TYPE(i); | |
| HRESULT result = d3d9->CheckDeviceMultiSampleType( | |
| adapter, deviceType, d3dFormatInfo.renderFormat, TRUE, multisampleType, nullptr); | |
| if (SUCCEEDED(result)) | |
| { | |
| textureCaps.sampleCounts.insert(i); | |
| } | |
| } | |
| } | |
| return textureCaps; | |
| } | |
| void GenerateCaps(IDirect3D9 *d3d9, | |
| IDirect3DDevice9 *device, | |
| D3DDEVTYPE deviceType, | |
| UINT adapter, | |
| gl::Caps *caps, | |
| gl::TextureCapsMap *textureCapsMap, | |
| gl::Extensions *extensions, | |
| gl::Limitations *limitations) | |
| { | |
| D3DCAPS9 deviceCaps; | |
| if (FAILED(d3d9->GetDeviceCaps(adapter, deviceType, &deviceCaps))) | |
| { | |
| // Can't continue with out device caps | |
| return; | |
| } | |
| D3DDISPLAYMODE currentDisplayMode; | |
| d3d9->GetAdapterDisplayMode(adapter, ¤tDisplayMode); | |
| GLuint maxSamples = 0; | |
| for (GLenum internalFormat : gl::GetAllSizedInternalFormats()) | |
| { | |
| gl::TextureCaps textureCaps = GenerateTextureFormatCaps(internalFormat, d3d9, deviceType, | |
| adapter, currentDisplayMode.Format); | |
| textureCapsMap->insert(internalFormat, textureCaps); | |
| maxSamples = std::max(maxSamples, textureCaps.getMaxSamples()); | |
| if (gl::GetSizedInternalFormatInfo(internalFormat).compressed) | |
| { | |
| caps->compressedTextureFormats.push_back(internalFormat); | |
| } | |
| } | |
| // GL core feature limits | |
| caps->maxElementIndex = static_cast<GLint64>(std::numeric_limits<unsigned int>::max()); | |
| // 3D textures are unimplemented in D3D9 | |
| caps->max3DTextureSize = 1; | |
| // Only one limit in GL, use the minimum dimension | |
| caps->max2DTextureSize = std::min(deviceCaps.MaxTextureWidth, deviceCaps.MaxTextureHeight); | |
| // D3D treats cube maps as a special case of 2D textures | |
| caps->maxCubeMapTextureSize = caps->max2DTextureSize; | |
| // Array textures are not available in D3D9 | |
| caps->maxArrayTextureLayers = 1; | |
| // ES3-only feature | |
| caps->maxLODBias = 0.0f; | |
| // No specific limits on render target size, maximum 2D texture size is equivalent | |
| caps->maxRenderbufferSize = caps->max2DTextureSize; | |
| // Draw buffers are not supported in D3D9 | |
| caps->maxDrawBuffers = 1; | |
| caps->maxColorAttachments = 1; | |
| // No specific limits on viewport size, maximum 2D texture size is equivalent | |
| caps->maxViewportWidth = caps->max2DTextureSize; | |
| caps->maxViewportHeight = caps->maxViewportWidth; | |
| // Point size is clamped to 1.0f when the shader model is less than 3 | |
| caps->minAliasedPointSize = 1.0f; | |
| caps->maxAliasedPointSize = | |
| ((D3DSHADER_VERSION_MAJOR(deviceCaps.PixelShaderVersion) >= 3) ? deviceCaps.MaxPointSize | |
| : 1.0f); | |
| // Wide lines not supported | |
| caps->minAliasedLineWidth = 1.0f; | |
| caps->maxAliasedLineWidth = 1.0f; | |
| // Primitive count limits (unused in ES2) | |
| caps->maxElementsIndices = 0; | |
| caps->maxElementsVertices = 0; | |
| // Program and shader binary formats (no supported shader binary formats) | |
| caps->programBinaryFormats.push_back(GL_PROGRAM_BINARY_ANGLE); | |
| caps->vertexHighpFloat.setIEEEFloat(); | |
| caps->vertexMediumpFloat.setIEEEFloat(); | |
| caps->vertexLowpFloat.setIEEEFloat(); | |
| caps->fragmentHighpFloat.setIEEEFloat(); | |
| caps->fragmentMediumpFloat.setIEEEFloat(); | |
| caps->fragmentLowpFloat.setIEEEFloat(); | |
| // Some (most) hardware only supports single-precision floating-point numbers, | |
| // which can accurately represent integers up to +/-16777216 | |
| caps->vertexHighpInt.setSimulatedInt(24); | |
| caps->vertexMediumpInt.setSimulatedInt(24); | |
| caps->vertexLowpInt.setSimulatedInt(24); | |
| caps->fragmentHighpInt.setSimulatedInt(24); | |
| caps->fragmentMediumpInt.setSimulatedInt(24); | |
| caps->fragmentLowpInt.setSimulatedInt(24); | |
| // WaitSync is ES3-only, set to zero | |
| caps->maxServerWaitTimeout = 0; | |
| // Vertex shader limits | |
| caps->maxVertexAttributes = 16; | |
| // Vertex Attrib Binding not supported. | |
| caps->maxVertexAttribBindings = caps->maxVertexAttributes; | |
| const size_t MAX_VERTEX_CONSTANT_VECTORS_D3D9 = 256; | |
| caps->maxVertexUniformVectors = | |
| MAX_VERTEX_CONSTANT_VECTORS_D3D9 - GetReservedVertexUniformVectors(); | |
| caps->maxShaderUniformComponents[gl::ShaderType::Vertex] = caps->maxVertexUniformVectors * 4; | |
| caps->maxShaderUniformBlocks[gl::ShaderType::Vertex] = 0; | |
| // SM3 only supports 12 output variables, but the special 12th register is only for PSIZE. | |
| const unsigned int MAX_VERTEX_OUTPUT_VECTORS_SM3 = 12 - GetReservedVaryingVectors(); | |
| const unsigned int MAX_VERTEX_OUTPUT_VECTORS_SM2 = 10 - GetReservedVaryingVectors(); | |
| caps->maxVertexOutputComponents = | |
| ((deviceCaps.VertexShaderVersion >= D3DVS_VERSION(3, 0)) ? MAX_VERTEX_OUTPUT_VECTORS_SM3 | |
| : MAX_VERTEX_OUTPUT_VECTORS_SM2) * | |
| 4; | |
| // Only Direct3D 10 ready devices support all the necessary vertex texture formats. | |
| // We test this using D3D9 by checking support for the R16F format. | |
| if (deviceCaps.VertexShaderVersion >= D3DVS_VERSION(3, 0) && | |
| SUCCEEDED(d3d9->CheckDeviceFormat(adapter, deviceType, currentDisplayMode.Format, | |
| D3DUSAGE_QUERY_VERTEXTEXTURE, D3DRTYPE_TEXTURE, | |
| D3DFMT_R16F))) | |
| { | |
| const size_t MAX_TEXTURE_IMAGE_UNITS_VTF_SM3 = 4; | |
| caps->maxShaderTextureImageUnits[gl::ShaderType::Vertex] = MAX_TEXTURE_IMAGE_UNITS_VTF_SM3; | |
| } | |
| else | |
| { | |
| caps->maxShaderTextureImageUnits[gl::ShaderType::Vertex] = 0; | |
| } | |
| // Fragment shader limits | |
| const size_t MAX_PIXEL_CONSTANT_VECTORS_SM3 = 224; | |
| const size_t MAX_PIXEL_CONSTANT_VECTORS_SM2 = 32; | |
| caps->maxFragmentUniformVectors = | |
| ((deviceCaps.PixelShaderVersion >= D3DPS_VERSION(3, 0)) ? MAX_PIXEL_CONSTANT_VECTORS_SM3 | |
| : MAX_PIXEL_CONSTANT_VECTORS_SM2) - | |
| GetReservedFragmentUniformVectors(); | |
| caps->maxShaderUniformComponents[gl::ShaderType::Fragment] = | |
| caps->maxFragmentUniformVectors * 4; | |
| caps->maxShaderUniformBlocks[gl::ShaderType::Fragment] = 0; | |
| caps->maxFragmentInputComponents = caps->maxVertexOutputComponents; | |
| caps->maxShaderTextureImageUnits[gl::ShaderType::Fragment] = 16; | |
| caps->minProgramTexelOffset = 0; | |
| caps->maxProgramTexelOffset = 0; | |
| // Aggregate shader limits (unused in ES2) | |
| caps->maxUniformBufferBindings = 0; | |
| caps->maxUniformBlockSize = 0; | |
| caps->uniformBufferOffsetAlignment = 0; | |
| caps->maxCombinedUniformBlocks = 0; | |
| caps->maxCombinedShaderUniformComponents[gl::ShaderType::Vertex] = 0; | |
| caps->maxCombinedShaderUniformComponents[gl::ShaderType::Fragment] = 0; | |
| caps->maxVaryingComponents = 0; | |
| // Aggregate shader limits | |
| caps->maxVaryingVectors = caps->maxVertexOutputComponents / 4; | |
| caps->maxCombinedTextureImageUnits = caps->maxShaderTextureImageUnits[gl::ShaderType::Vertex] + | |
| caps->maxShaderTextureImageUnits[gl::ShaderType::Fragment]; | |
| // Transform feedback limits | |
| caps->maxTransformFeedbackInterleavedComponents = 0; | |
| caps->maxTransformFeedbackSeparateAttributes = 0; | |
| caps->maxTransformFeedbackSeparateComponents = 0; | |
| // Multisample limits | |
| caps->maxSamples = maxSamples; | |
| // GL extension support | |
| extensions->setTextureExtensionSupport(*textureCapsMap); | |
| extensions->elementIndexUint = deviceCaps.MaxVertexIndex >= (1 << 16); | |
| extensions->getProgramBinary = true; | |
| extensions->rgb8rgba8 = true; | |
| extensions->readFormatBGRA = true; | |
| extensions->pixelBufferObject = false; | |
| extensions->mapBuffer = false; | |
| extensions->mapBufferRange = false; | |
| // D3D does not allow depth textures to have more than one mipmap level OES_depth_texture | |
| // allows for that so we can't implement full support with the D3D9 back end. | |
| extensions->depthTextureOES = false; | |
| // textureRG is emulated and not performant. | |
| extensions->textureRG = false; | |
| D3DADAPTER_IDENTIFIER9 adapterId = {}; | |
| if (SUCCEEDED(d3d9->GetAdapterIdentifier(adapter, 0, &adapterId))) | |
| { | |
| // ATI cards on XP have problems with non-power-of-two textures. | |
| extensions->textureNPOT = !(deviceCaps.TextureCaps & D3DPTEXTURECAPS_POW2) && | |
| !(deviceCaps.TextureCaps & D3DPTEXTURECAPS_CUBEMAP_POW2) && | |
| !(deviceCaps.TextureCaps & D3DPTEXTURECAPS_NONPOW2CONDITIONAL) && | |
| !(!isWindowsVistaOrGreater() && IsAMD(adapterId.VendorId)); | |
| // Disable depth texture support on AMD cards (See ANGLE issue 839) | |
| if (IsAMD(adapterId.VendorId)) | |
| { | |
| extensions->depthTextureANGLE = false; | |
| extensions->depthTextureOES = false; | |
| } | |
| } | |
| else | |
| { | |
| extensions->textureNPOT = false; | |
| } | |
| extensions->drawBuffers = false; | |
| extensions->textureStorage = true; | |
| // Must support a minimum of 2:1 anisotropy for max anisotropy to be considered supported, per | |
| // the spec | |
| extensions->textureFilterAnisotropic = | |
| (deviceCaps.RasterCaps & D3DPRASTERCAPS_ANISOTROPY) != 0 && deviceCaps.MaxAnisotropy >= 2; | |
| extensions->maxTextureAnisotropy = static_cast<GLfloat>(deviceCaps.MaxAnisotropy); | |
| // Check occlusion query support by trying to create one | |
| IDirect3DQuery9 *occlusionQuery = nullptr; | |
| extensions->occlusionQueryBoolean = | |
| SUCCEEDED(device->CreateQuery(D3DQUERYTYPE_OCCLUSION, &occlusionQuery)) && occlusionQuery; | |
| SafeRelease(occlusionQuery); | |
| // Check event query support by trying to create one | |
| IDirect3DQuery9 *eventQuery = nullptr; | |
| extensions->fence = | |
| SUCCEEDED(device->CreateQuery(D3DQUERYTYPE_EVENT, &eventQuery)) && eventQuery; | |
| SafeRelease(eventQuery); | |
| extensions->disjointTimerQuery = false; | |
| extensions->robustness = true; | |
| // It seems that only DirectX 10 and higher enforce the well-defined behavior of always | |
| // returning zero values when out-of-bounds reads. See | |
| // https://www.khronos.org/registry/OpenGL/extensions/ARB/ARB_robustness.txt | |
| extensions->robustBufferAccessBehavior = false; | |
| extensions->blendMinMax = true; | |
| // Although according to | |
| // https://docs.microsoft.com/en-us/windows/desktop/direct3ddxgi/format-support-for-direct3d-feature-level-9-1-hardware | |
| // D3D9 doesn't have full blending capability for RGBA32F. But turns out it could provide | |
| // correct blending result in reality. As a result of some regression reports by client app, we | |
| // decided to turn floatBlend on for D3D9 | |
| extensions->floatBlend = true; | |
| extensions->framebufferBlit = true; | |
| extensions->framebufferMultisample = true; | |
| extensions->instancedArraysANGLE = deviceCaps.PixelShaderVersion >= D3DPS_VERSION(3, 0); | |
| // D3D9 requires at least one attribute that has a divisor of 0, which isn't required by the EXT | |
| // extension | |
| extensions->instancedArraysEXT = false; | |
| extensions->packReverseRowOrder = true; | |
| extensions->standardDerivatives = | |
| (deviceCaps.PS20Caps.Caps & D3DPS20CAPS_GRADIENTINSTRUCTIONS) != 0; | |
| extensions->shaderTextureLOD = true; | |
| extensions->fragDepth = true; | |
| extensions->textureUsage = true; | |
| extensions->translatedShaderSource = true; | |
| extensions->fboRenderMipmap = false; | |
| extensions->discardFramebuffer = false; // It would be valid to set this to true, since | |
| // glDiscardFramebufferEXT is just a hint | |
| extensions->colorBufferFloat = false; | |
| extensions->debugMarker = true; | |
| extensions->eglImage = true; | |
| extensions->eglImageExternal = true; | |
| extensions->unpackSubimage = true; | |
| extensions->packSubimage = true; | |
| extensions->syncQuery = extensions->fence; | |
| extensions->copyTexture = true; | |
| extensions->textureBorderClamp = true; | |
| // D3D9 has no concept of separate masks and refs for front and back faces in the depth stencil | |
| // state. | |
| limitations->noSeparateStencilRefsAndMasks = true; | |
| // D3D9 shader models have limited support for looping, so the Appendix A | |
| // index/loop limitations are necessary. Workarounds that are needed to | |
| // support dynamic indexing of vectors on HLSL also don't work on D3D9. | |
| limitations->shadersRequireIndexedLoopValidation = true; | |
| // D3D9 cannot support constant color and alpha blend funcs together | |
| limitations->noSimultaneousConstantColorAndAlphaBlendFunc = true; | |
| // D3D9 cannot support packing more than one variable to a single varying. | |
| // TODO(jmadill): Implement more sophisticated component packing in D3D9. | |
| limitations->noFlexibleVaryingPacking = true; | |
| // D3D9 does not support vertex attribute aliasing | |
| limitations->noVertexAttributeAliasing = true; | |
| } | |
| } // namespace d3d9_gl | |
| namespace d3d9 | |
| { | |
| GLuint ComputeBlockSize(D3DFORMAT format, GLuint width, GLuint height) | |
| { | |
| const D3DFormat &d3dFormatInfo = d3d9::GetD3DFormatInfo(format); | |
| GLuint numBlocksWide = (width + d3dFormatInfo.blockWidth - 1) / d3dFormatInfo.blockWidth; | |
| GLuint numBlocksHight = (height + d3dFormatInfo.blockHeight - 1) / d3dFormatInfo.blockHeight; | |
| return (d3dFormatInfo.pixelBytes * numBlocksWide * numBlocksHight); | |
| } | |
| void MakeValidSize(bool isImage, | |
| D3DFORMAT format, | |
| GLsizei *requestWidth, | |
| GLsizei *requestHeight, | |
| int *levelOffset) | |
| { | |
| const D3DFormat &d3dFormatInfo = d3d9::GetD3DFormatInfo(format); | |
| int upsampleCount = 0; | |
| // Don't expand the size of full textures that are at least (blockWidth x blockHeight) already. | |
| if (isImage || *requestWidth < static_cast<GLsizei>(d3dFormatInfo.blockWidth) || | |
| *requestHeight < static_cast<GLsizei>(d3dFormatInfo.blockHeight)) | |
| { | |
| while (*requestWidth % d3dFormatInfo.blockWidth != 0 || | |
| *requestHeight % d3dFormatInfo.blockHeight != 0) | |
| { | |
| *requestWidth <<= 1; | |
| *requestHeight <<= 1; | |
| upsampleCount++; | |
| } | |
| } | |
| *levelOffset = upsampleCount; | |
| } | |
| void InitializeFeatures(angle::FeaturesD3D *features) | |
| { | |
| ANGLE_FEATURE_CONDITION(features, mrtPerfWorkaround, true); | |
| ANGLE_FEATURE_CONDITION(features, setDataFasterThanImageUpload, false); | |
| ANGLE_FEATURE_CONDITION(features, useInstancedPointSpriteEmulation, false); | |
| // TODO(jmadill): Disable workaround when we have a fixed compiler DLL. | |
| ANGLE_FEATURE_CONDITION(features, expandIntegerPowExpressions, true); | |
| // crbug.com/1011627 Turn this on for D3D9. | |
| ANGLE_FEATURE_CONDITION(features, allowClearForRobustResourceInit, true); | |
| // Call platform hooks for testing overrides. | |
| auto *platform = ANGLEPlatformCurrent(); | |
| platform->overrideWorkaroundsD3D(platform, features); | |
| } | |
| } // namespace d3d9 | |
| } // namespace rx |