kc3-lang/angle/src/libGLESv2/renderer/renderer11_utils.cpp

• Show log

  Commit

• Hash : da507fea
  Author :
  Date : 2013-08-20T12:01:42
  

  Refactored the ClearParameters type and moved Renderer11's clear logic into a Clear11 helper class.
  
  TRAC #23475
  
  Author: Geoff Lang
  Signed-off-by: Jamie Madill
  Signed-off-by: Shannon Woods
  

Download

• src/libGLESv2/renderer/renderer11_utils.cpp

• #include "precompiled.h"
  //
  // Copyright (c) 2012-2013 The ANGLE Project Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  //
  
  // renderer11_utils.cpp: Conversion functions and other utility routines
  // specific to the D3D11 renderer.
  
  #include "libGLESv2/renderer/renderer11_utils.h"
  
  #include "common/debug.h"
  
  namespace rx
  {
  
  namespace gl_d3d11
  {
  
  D3D11_BLEND ConvertBlendFunc(GLenum glBlend, bool isAlpha)
  {
      D3D11_BLEND d3dBlend = D3D11_BLEND_ZERO;
  
      switch (glBlend)
      {
        case GL_ZERO:                     d3dBlend = D3D11_BLEND_ZERO;                break;
        case GL_ONE:                      d3dBlend = D3D11_BLEND_ONE;                 break;
        case GL_SRC_COLOR:                d3dBlend = (isAlpha ? D3D11_BLEND_SRC_ALPHA : D3D11_BLEND_SRC_COLOR);           break;
        case GL_ONE_MINUS_SRC_COLOR:      d3dBlend = (isAlpha ? D3D11_BLEND_INV_SRC_ALPHA : D3D11_BLEND_INV_SRC_COLOR);   break;
        case GL_DST_COLOR:                d3dBlend = (isAlpha ? D3D11_BLEND_DEST_ALPHA : D3D11_BLEND_DEST_COLOR);         break;
        case GL_ONE_MINUS_DST_COLOR:      d3dBlend = (isAlpha ? D3D11_BLEND_INV_DEST_ALPHA : D3D11_BLEND_INV_DEST_COLOR); break;
        case GL_SRC_ALPHA:                d3dBlend = D3D11_BLEND_SRC_ALPHA;           break;
        case GL_ONE_MINUS_SRC_ALPHA:      d3dBlend = D3D11_BLEND_INV_SRC_ALPHA;       break;
        case GL_DST_ALPHA:                d3dBlend = D3D11_BLEND_DEST_ALPHA;          break;
        case GL_ONE_MINUS_DST_ALPHA:      d3dBlend = D3D11_BLEND_INV_DEST_ALPHA;      break;
        case GL_CONSTANT_COLOR:           d3dBlend = D3D11_BLEND_BLEND_FACTOR;        break;
        case GL_ONE_MINUS_CONSTANT_COLOR: d3dBlend = D3D11_BLEND_INV_BLEND_FACTOR;    break;
        case GL_CONSTANT_ALPHA:           d3dBlend = D3D11_BLEND_BLEND_FACTOR;        break;
        case GL_ONE_MINUS_CONSTANT_ALPHA: d3dBlend = D3D11_BLEND_INV_BLEND_FACTOR;    break;
        case GL_SRC_ALPHA_SATURATE:       d3dBlend = D3D11_BLEND_SRC_ALPHA_SAT;       break;
        default: UNREACHABLE();
      }
  
      return d3dBlend;
  }
  
  D3D11_BLEND_OP ConvertBlendOp(GLenum glBlendOp)
  {
      D3D11_BLEND_OP d3dBlendOp = D3D11_BLEND_OP_ADD;
  
      switch (glBlendOp)
      {
        case GL_FUNC_ADD:              d3dBlendOp = D3D11_BLEND_OP_ADD;           break;
        case GL_FUNC_SUBTRACT:         d3dBlendOp = D3D11_BLEND_OP_SUBTRACT;      break;
        case GL_FUNC_REVERSE_SUBTRACT: d3dBlendOp = D3D11_BLEND_OP_REV_SUBTRACT;  break;
        case GL_MIN:                   d3dBlendOp = D3D11_BLEND_OP_MIN;           break;
        case GL_MAX:                   d3dBlendOp = D3D11_BLEND_OP_MAX;           break;
        default: UNREACHABLE();
      }
  
      return d3dBlendOp;
  }
  
  UINT8 ConvertColorMask(bool red, bool green, bool blue, bool alpha)
  {
      UINT8 mask = 0;
      if (red)
      {
          mask |= D3D11_COLOR_WRITE_ENABLE_RED;
      }
      if (green)
      {
          mask |= D3D11_COLOR_WRITE_ENABLE_GREEN;
      }
      if (blue)
      {
          mask |= D3D11_COLOR_WRITE_ENABLE_BLUE;
      }
      if (alpha)
      {
          mask |= D3D11_COLOR_WRITE_ENABLE_ALPHA;
      }
      return mask;
  }
  
  D3D11_CULL_MODE ConvertCullMode(bool cullEnabled, GLenum cullMode)
  {
      D3D11_CULL_MODE cull = D3D11_CULL_NONE;
  
      if (cullEnabled)
      {
          switch (cullMode)
          {
            case GL_FRONT:            cull = D3D11_CULL_FRONT;    break;
            case GL_BACK:             cull = D3D11_CULL_BACK;     break;
            case GL_FRONT_AND_BACK:   cull = D3D11_CULL_NONE;     break;
            default: UNREACHABLE();
          }
      }
      else
      {
          cull = D3D11_CULL_NONE;
      }
  
      return cull;
  }
  
  D3D11_COMPARISON_FUNC ConvertComparison(GLenum comparison)
  {
      D3D11_COMPARISON_FUNC d3dComp = D3D11_COMPARISON_NEVER;
      switch (comparison)
      {
        case GL_NEVER:    d3dComp = D3D11_COMPARISON_NEVER;           break;
        case GL_ALWAYS:   d3dComp = D3D11_COMPARISON_ALWAYS;          break;
        case GL_LESS:     d3dComp = D3D11_COMPARISON_LESS;            break;
        case GL_LEQUAL:   d3dComp = D3D11_COMPARISON_LESS_EQUAL;      break;
        case GL_EQUAL:    d3dComp = D3D11_COMPARISON_EQUAL;           break;
        case GL_GREATER:  d3dComp = D3D11_COMPARISON_GREATER;         break;
        case GL_GEQUAL:   d3dComp = D3D11_COMPARISON_GREATER_EQUAL;   break;
        case GL_NOTEQUAL: d3dComp = D3D11_COMPARISON_NOT_EQUAL;       break;
        default: UNREACHABLE();
      }
  
      return d3dComp;
  }
  
  D3D11_DEPTH_WRITE_MASK ConvertDepthMask(bool depthWriteEnabled)
  {
      return depthWriteEnabled ? D3D11_DEPTH_WRITE_MASK_ALL : D3D11_DEPTH_WRITE_MASK_ZERO;
  }
  
  UINT8 ConvertStencilMask(GLuint stencilmask)
  {
      return static_cast<UINT8>(stencilmask);
  }
  
  D3D11_STENCIL_OP ConvertStencilOp(GLenum stencilOp)
  {
      D3D11_STENCIL_OP d3dStencilOp = D3D11_STENCIL_OP_KEEP;
  
      switch (stencilOp)
      {
        case GL_ZERO:      d3dStencilOp = D3D11_STENCIL_OP_ZERO;      break;
        case GL_KEEP:      d3dStencilOp = D3D11_STENCIL_OP_KEEP;      break;
        case GL_REPLACE:   d3dStencilOp = D3D11_STENCIL_OP_REPLACE;   break;
        case GL_INCR:      d3dStencilOp = D3D11_STENCIL_OP_INCR_SAT;  break;
        case GL_DECR:      d3dStencilOp = D3D11_STENCIL_OP_DECR_SAT;  break;
        case GL_INVERT:    d3dStencilOp = D3D11_STENCIL_OP_INVERT;    break;
        case GL_INCR_WRAP: d3dStencilOp = D3D11_STENCIL_OP_INCR;      break;
        case GL_DECR_WRAP: d3dStencilOp = D3D11_STENCIL_OP_DECR;      break;
        default: UNREACHABLE();
      }
  
      return d3dStencilOp;
  }
  
  D3D11_FILTER ConvertFilter(GLenum minFilter, GLenum magFilter, float maxAnisotropy, GLenum comparisonMode)
  {
      bool comparison = comparisonMode != GL_NONE;
  
      if (maxAnisotropy > 1.0f)
      {
          return D3D11_ENCODE_ANISOTROPIC_FILTER(comparison);
      }
      else
      {
          D3D11_FILTER_TYPE dxMin = D3D11_FILTER_TYPE_POINT;
          D3D11_FILTER_TYPE dxMip = D3D11_FILTER_TYPE_POINT;
          switch (minFilter)
          {
            case GL_NEAREST:                dxMin = D3D11_FILTER_TYPE_POINT;  dxMip = D3D11_FILTER_TYPE_POINT;  break;
            case GL_LINEAR:                 dxMin = D3D11_FILTER_TYPE_LINEAR; dxMip = D3D11_FILTER_TYPE_POINT;  break;
            case GL_NEAREST_MIPMAP_NEAREST: dxMin = D3D11_FILTER_TYPE_POINT;  dxMip = D3D11_FILTER_TYPE_POINT;  break;
            case GL_LINEAR_MIPMAP_NEAREST:  dxMin = D3D11_FILTER_TYPE_LINEAR; dxMip = D3D11_FILTER_TYPE_POINT;  break;
            case GL_NEAREST_MIPMAP_LINEAR:  dxMin = D3D11_FILTER_TYPE_POINT;  dxMip = D3D11_FILTER_TYPE_LINEAR; break;
            case GL_LINEAR_MIPMAP_LINEAR:   dxMin = D3D11_FILTER_TYPE_LINEAR; dxMip = D3D11_FILTER_TYPE_LINEAR; break;
            default:                        UNREACHABLE();
          }
  
          D3D11_FILTER_TYPE dxMag = D3D11_FILTER_TYPE_POINT;
          switch (magFilter)
          {
            case GL_NEAREST: dxMag = D3D11_FILTER_TYPE_POINT;  break;
            case GL_LINEAR:  dxMag = D3D11_FILTER_TYPE_LINEAR; break;
            default:         UNREACHABLE();
          }
  
          return D3D11_ENCODE_BASIC_FILTER(dxMin, dxMag, dxMip, comparison);
      }
  }
  
  D3D11_TEXTURE_ADDRESS_MODE ConvertTextureWrap(GLenum wrap)
  {
      switch (wrap)
      {
        case GL_REPEAT:          return D3D11_TEXTURE_ADDRESS_WRAP;
        case GL_CLAMP_TO_EDGE:   return D3D11_TEXTURE_ADDRESS_CLAMP;
        case GL_MIRRORED_REPEAT: return D3D11_TEXTURE_ADDRESS_MIRROR;
        default:                 UNREACHABLE();
      }
  
      return D3D11_TEXTURE_ADDRESS_WRAP;
  }
  
  FLOAT ConvertMinLOD(GLenum minFilter, unsigned int lodOffset)
  {
      return (minFilter == GL_NEAREST || minFilter == GL_LINEAR) ? static_cast<float>(lodOffset) : -FLT_MAX;
  }
  
  FLOAT ConvertMaxLOD(GLenum minFilter, unsigned int lodOffset)
  {
      return (minFilter == GL_NEAREST || minFilter == GL_LINEAR) ? static_cast<float>(lodOffset) : FLT_MAX;
  }
  
  }
  
  namespace d3d11
  {
  
  void SetPositionTexCoordVertex(PositionTexCoordVertex* vertex, float x, float y, float u, float v)
  {
      vertex->x = x;
      vertex->y = y;
      vertex->u = u;
      vertex->v = v;
  }
  
  void SetPositionLayerTexCoord3DVertex(PositionLayerTexCoord3DVertex* vertex, float x, float y,
                                        unsigned int layer, float u, float v, float s)
  {
      vertex->x = x;
      vertex->y = y;
      vertex->l = layer;
      vertex->u = u;
      vertex->v = v;
      vertex->s = s;
  }
  
  HRESULT SetDebugName(ID3D11DeviceChild *resource, const char *name)
  {
  #if defined(_DEBUG)
      return resource->SetPrivateData(WKPDID_D3DDebugObjectName, strlen(name), name);
  #else
      return S_OK;
  #endif
  }
  
  }
  
  }
  

Download