src/third_party/angle/src/libGLESv2/renderer/d3d9/renderer9_utils.cpp

   1 #include "precompiled.h"
   2 //
   3 // Copyright (c) 2002-2012 The ANGLE Project Authors. All rights reserved.
   4 // Use of this source code is governed by a BSD-style license that can be
   5 // found in the LICENSE file.
   6 //
   7
   8 // renderer9_utils.cpp: Conversion functions and other utility routines
   9 // specific to the D3D9 renderer.
  10
  11 #include "libGLESv2/renderer/d3d9/renderer9_utils.h"
  12 #include "common/mathutil.h"
  13 #include "libGLESv2/Context.h"
  14
  15 #include "common/debug.h"
  16
  17 namespace rx
  18 {
  19
  20 namespace gl_d3d9
  21 {
  22
  23 D3DCMPFUNC ConvertComparison(GLenum comparison)
  24 {
  25     D3DCMPFUNC d3dComp = D3DCMP_ALWAYS;
  26     switch (comparison)
  27     {
  28       case GL_NEVER:    d3dComp = D3DCMP_NEVER;        break;
  29       case GL_ALWAYS:   d3dComp = D3DCMP_ALWAYS;       break;
  30       case GL_LESS:     d3dComp = D3DCMP_LESS;         break;
  31       case GL_LEQUAL:   d3dComp = D3DCMP_LESSEQUAL;    break;
  32       case GL_EQUAL:    d3dComp = D3DCMP_EQUAL;        break;
  33       case GL_GREATER:  d3dComp = D3DCMP_GREATER;      break;
  34       case GL_GEQUAL:   d3dComp = D3DCMP_GREATEREQUAL; break;
  35       case GL_NOTEQUAL: d3dComp = D3DCMP_NOTEQUAL;     break;
  36       default: UNREACHABLE();
  37     }
  38
  39     return d3dComp;
  40 }
  41
  42 D3DCOLOR ConvertColor(gl::ColorF color)
  43 {
  44     return D3DCOLOR_RGBA(gl::unorm<8>(color.red),
  45                          gl::unorm<8>(color.green),
  46                          gl::unorm<8>(color.blue),
  47                          gl::unorm<8>(color.alpha));
  48 }
  49
  50 D3DBLEND ConvertBlendFunc(GLenum blend)
  51 {
  52     D3DBLEND d3dBlend = D3DBLEND_ZERO;
  53
  54     switch (blend)
  55     {
  56       case GL_ZERO:                     d3dBlend = D3DBLEND_ZERO;           break;
  57       case GL_ONE:                      d3dBlend = D3DBLEND_ONE;            break;
  58       case GL_SRC_COLOR:                d3dBlend = D3DBLEND_SRCCOLOR;       break;
  59       case GL_ONE_MINUS_SRC_COLOR:      d3dBlend = D3DBLEND_INVSRCCOLOR;    break;
  60       case GL_DST_COLOR:                d3dBlend = D3DBLEND_DESTCOLOR;      break;
  61       case GL_ONE_MINUS_DST_COLOR:      d3dBlend = D3DBLEND_INVDESTCOLOR;   break;
  62       case GL_SRC_ALPHA:                d3dBlend = D3DBLEND_SRCALPHA;       break;
  63       case GL_ONE_MINUS_SRC_ALPHA:      d3dBlend = D3DBLEND_INVSRCALPHA;    break;
  64       case GL_DST_ALPHA:                d3dBlend = D3DBLEND_DESTALPHA;      break;
  65       case GL_ONE_MINUS_DST_ALPHA:      d3dBlend = D3DBLEND_INVDESTALPHA;   break;
  66       case GL_CONSTANT_COLOR:           d3dBlend = D3DBLEND_BLENDFACTOR;    break;
  67       case GL_ONE_MINUS_CONSTANT_COLOR: d3dBlend = D3DBLEND_INVBLENDFACTOR; break;
  68       case GL_CONSTANT_ALPHA:           d3dBlend = D3DBLEND_BLENDFACTOR;    break;
  69       case GL_ONE_MINUS_CONSTANT_ALPHA: d3dBlend = D3DBLEND_INVBLENDFACTOR; break;
  70       case GL_SRC_ALPHA_SATURATE:       d3dBlend = D3DBLEND_SRCALPHASAT;    break;
  71       default: UNREACHABLE();
  72     }
  73
  74     return d3dBlend;
  75 }
  76
  77 D3DBLENDOP ConvertBlendOp(GLenum blendOp)
  78 {
  79     D3DBLENDOP d3dBlendOp = D3DBLENDOP_ADD;
  80
  81     switch (blendOp)
  82     {
  83       case GL_FUNC_ADD:              d3dBlendOp = D3DBLENDOP_ADD;         break;
  84       case GL_FUNC_SUBTRACT:         d3dBlendOp = D3DBLENDOP_SUBTRACT;    break;
  85       case GL_FUNC_REVERSE_SUBTRACT: d3dBlendOp = D3DBLENDOP_REVSUBTRACT; break;
  86       case GL_MIN_EXT:               d3dBlendOp = D3DBLENDOP_MIN;         break;
  87       case GL_MAX_EXT:               d3dBlendOp = D3DBLENDOP_MAX;         break;
  88       default: UNREACHABLE();
  89     }
  90
  91     return d3dBlendOp;
  92 }
  93
  94 D3DSTENCILOP ConvertStencilOp(GLenum stencilOp)
  95 {
  96     D3DSTENCILOP d3dStencilOp = D3DSTENCILOP_KEEP;
  97
  98     switch (stencilOp)
  99     {
 100       case GL_ZERO:      d3dStencilOp = D3DSTENCILOP_ZERO;    break;
 101       case GL_KEEP:      d3dStencilOp = D3DSTENCILOP_KEEP;    break;
 102       case GL_REPLACE:   d3dStencilOp = D3DSTENCILOP_REPLACE; break;
 103       case GL_INCR:      d3dStencilOp = D3DSTENCILOP_INCRSAT; break;
 104       case GL_DECR:      d3dStencilOp = D3DSTENCILOP_DECRSAT; break;
 105       case GL_INVERT:    d3dStencilOp = D3DSTENCILOP_INVERT;  break;
 106       case GL_INCR_WRAP: d3dStencilOp = D3DSTENCILOP_INCR;    break;
 107       case GL_DECR_WRAP: d3dStencilOp = D3DSTENCILOP_DECR;    break;
 108       default: UNREACHABLE();
 109     }
 110
 111     return d3dStencilOp;
 112 }
 113
 114 D3DTEXTUREADDRESS ConvertTextureWrap(GLenum wrap)
 115 {
 116     D3DTEXTUREADDRESS d3dWrap = D3DTADDRESS_WRAP;
 117
 118     switch (wrap)
 119     {
 120       case GL_REPEAT:            d3dWrap = D3DTADDRESS_WRAP;   break;
 121       case GL_CLAMP_TO_EDGE:     d3dWrap = D3DTADDRESS_CLAMP;  break;
 122       case GL_MIRRORED_REPEAT:   d3dWrap = D3DTADDRESS_MIRROR; break;
 123       default: UNREACHABLE();
 124     }
 125
 126     return d3dWrap;
 127 }
 128
 129 D3DCULL ConvertCullMode(GLenum cullFace, GLenum frontFace)
 130 {
 131     D3DCULL cull = D3DCULL_CCW;
 132     switch (cullFace)
 133     {
 134       case GL_FRONT:
 135         cull = (frontFace == GL_CCW ? D3DCULL_CW : D3DCULL_CCW);
 136         break;
 137       case GL_BACK:
 138         cull = (frontFace == GL_CCW ? D3DCULL_CCW : D3DCULL_CW);
 139         break;
 140       case GL_FRONT_AND_BACK:
 141         cull = D3DCULL_NONE; // culling will be handled during draw
 142         break;
 143       default: UNREACHABLE();
 144     }
 145
 146     return cull;
 147 }
 148
 149 D3DCUBEMAP_FACES ConvertCubeFace(GLenum cubeFace)
 150 {
 151     D3DCUBEMAP_FACES face = D3DCUBEMAP_FACE_POSITIVE_X;
 152
 153     switch (cubeFace)
 154     {
 155       case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
 156         face = D3DCUBEMAP_FACE_POSITIVE_X;
 157         break;
 158       case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
 159         face = D3DCUBEMAP_FACE_NEGATIVE_X;
 160         break;
 161       case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
 162         face = D3DCUBEMAP_FACE_POSITIVE_Y;
 163         break;
 164       case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
 165         face = D3DCUBEMAP_FACE_NEGATIVE_Y;
 166         break;
 167       case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
 168         face = D3DCUBEMAP_FACE_POSITIVE_Z;
 169         break;
 170       case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
 171         face = D3DCUBEMAP_FACE_NEGATIVE_Z;
 172         break;
 173       default: UNREACHABLE();
 174     }
 175
 176     return face;
 177 }
 178
 179 DWORD ConvertColorMask(bool red, bool green, bool blue, bool alpha)
 180 {
 181     return (red   ? D3DCOLORWRITEENABLE_RED   : 0) |
 182            (green ? D3DCOLORWRITEENABLE_GREEN : 0) |
 183            (blue  ? D3DCOLORWRITEENABLE_BLUE  : 0) |
 184            (alpha ? D3DCOLORWRITEENABLE_ALPHA : 0);
 185 }
 186
 187 D3DTEXTUREFILTERTYPE ConvertMagFilter(GLenum magFilter, float maxAnisotropy)
 188 {
 189     if (maxAnisotropy > 1.0f)
 190     {
 191         return D3DTEXF_ANISOTROPIC;
 192     }
 193
 194     D3DTEXTUREFILTERTYPE d3dMagFilter = D3DTEXF_POINT;
 195     switch (magFilter)
 196     {
 197       case GL_NEAREST: d3dMagFilter = D3DTEXF_POINT;  break;
 198       case GL_LINEAR:  d3dMagFilter = D3DTEXF_LINEAR; break;
 199       default: UNREACHABLE();
 200     }
 201
 202     return d3dMagFilter;
 203 }
 204
 205 void ConvertMinFilter(GLenum minFilter, D3DTEXTUREFILTERTYPE *d3dMinFilter, D3DTEXTUREFILTERTYPE *d3dMipFilter, float maxAnisotropy)
 206 {
 207     switch (minFilter)
 208     {
 209       case GL_NEAREST:
 210         *d3dMinFilter = D3DTEXF_POINT;
 211         *d3dMipFilter = D3DTEXF_NONE;
 212         break;
 213       case GL_LINEAR:
 214         *d3dMinFilter = D3DTEXF_LINEAR;
 215         *d3dMipFilter = D3DTEXF_NONE;
 216         break;
 217       case GL_NEAREST_MIPMAP_NEAREST:
 218         *d3dMinFilter = D3DTEXF_POINT;
 219         *d3dMipFilter = D3DTEXF_POINT;
 220         break;
 221       case GL_LINEAR_MIPMAP_NEAREST:
 222         *d3dMinFilter = D3DTEXF_LINEAR;
 223         *d3dMipFilter = D3DTEXF_POINT;
 224         break;
 225       case GL_NEAREST_MIPMAP_LINEAR:
 226         *d3dMinFilter = D3DTEXF_POINT;
 227         *d3dMipFilter = D3DTEXF_LINEAR;
 228         break;
 229       case GL_LINEAR_MIPMAP_LINEAR:
 230         *d3dMinFilter = D3DTEXF_LINEAR;
 231         *d3dMipFilter = D3DTEXF_LINEAR;
 232         break;
 233       default:
 234         *d3dMinFilter = D3DTEXF_POINT;
 235         *d3dMipFilter = D3DTEXF_NONE;
 236         UNREACHABLE();
 237     }
 238
 239     if (maxAnisotropy > 1.0f)
 240     {
 241         *d3dMinFilter = D3DTEXF_ANISOTROPIC;
 242     }
 243 }
 244
 245 }
 246
 247 }