src/OpenGL/libGLESv2/utilities.cpp

   1 // SwiftShader Software Renderer\r
   2 //\r
   3 // Copyright(c) 2005-2013 TransGaming Inc.\r
   4 //\r
   5 // All rights reserved. No part of this software may be copied, distributed, transmitted,\r
   6 // transcribed, stored in a retrieval system, translated into any human or computer\r
   7 // language by any means, or disclosed to third parties without the explicit written\r
   8 // agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express\r
   9 // or implied, including but not limited to any patent rights, are granted to you.\r
  10 //\r
  11 \r
  12 // utilities.cpp: Conversion functions and other utility routines.\r
  13 \r
  14 #include "utilities.h"\r
  15 \r
  16 #include "mathutil.h"\r
  17 #include "Context.h"\r
  18 #include "common/debug.h"\r
  19 \r
  20 #include <limits>\r
  21 #include <stdio.h>\r
  22 \r
  23 namespace es2\r
  24 {\r
  25         int UniformComponentCount(GLenum type)\r
  26         {\r
  27                 switch(type)\r
  28                 {\r
  29                 case GL_BOOL:\r
  30                 case GL_FLOAT:\r
  31                 case GL_INT:\r
  32                 case GL_SAMPLER_2D:\r
  33                 case GL_SAMPLER_CUBE:\r
  34         case GL_SAMPLER_EXTERNAL_OES:\r
  35                 case GL_SAMPLER_3D_OES:\r
  36                         return 1;\r
  37                 case GL_BOOL_VEC2:\r
  38                 case GL_FLOAT_VEC2:\r
  39                 case GL_INT_VEC2:\r
  40                         return 2;\r
  41                 case GL_INT_VEC3:\r
  42                 case GL_FLOAT_VEC3:\r
  43                 case GL_BOOL_VEC3:\r
  44                         return 3;\r
  45                 case GL_BOOL_VEC4:\r
  46                 case GL_FLOAT_VEC4:\r
  47                 case GL_INT_VEC4:\r
  48                 case GL_FLOAT_MAT2:\r
  49                         return 4;\r
  50                 case GL_FLOAT_MAT3:\r
  51                         return 9;\r
  52                 case GL_FLOAT_MAT4:\r
  53                         return 16;\r
  54                 default:\r
  55                         UNREACHABLE();\r
  56                 }\r
  57 \r
  58                 return 0;\r
  59         }\r
  60 \r
  61         GLenum UniformComponentType(GLenum type)\r
  62         {\r
  63                 switch(type)\r
  64                 {\r
  65                 case GL_BOOL:\r
  66                 case GL_BOOL_VEC2:\r
  67                 case GL_BOOL_VEC3:\r
  68                 case GL_BOOL_VEC4:\r
  69                         return GL_BOOL;\r
  70                 case GL_FLOAT:\r
  71                 case GL_FLOAT_VEC2:\r
  72                 case GL_FLOAT_VEC3:\r
  73                 case GL_FLOAT_VEC4:\r
  74                 case GL_FLOAT_MAT2:\r
  75                 case GL_FLOAT_MAT3:\r
  76                 case GL_FLOAT_MAT4:\r
  77                         return GL_FLOAT;\r
  78                 case GL_INT:\r
  79                 case GL_SAMPLER_2D:\r
  80                 case GL_SAMPLER_CUBE:\r
  81                 case GL_SAMPLER_EXTERNAL_OES:\r
  82                 case GL_SAMPLER_3D_OES:\r
  83                 case GL_INT_VEC2:\r
  84                 case GL_INT_VEC3:\r
  85                 case GL_INT_VEC4:\r
  86                         return GL_INT;\r
  87                 default:\r
  88                         UNREACHABLE();\r
  89                 }\r
  90 \r
  91                 return GL_NONE;\r
  92         }\r
  93 \r
  94         size_t UniformTypeSize(GLenum type)\r
  95         {\r
  96                 switch(type)\r
  97                 {\r
  98                 case GL_BOOL:  return sizeof(GLboolean);\r
  99                 case GL_FLOAT: return sizeof(GLfloat);\r
 100                 case GL_INT:   return sizeof(GLint);\r
 101                 }\r
 102 \r
 103                 return UniformTypeSize(UniformComponentType(type)) * UniformComponentCount(type);\r
 104         }\r
 105 \r
 106         int VariableRowCount(GLenum type)\r
 107         {\r
 108                 switch(type)\r
 109                 {\r
 110                 case GL_NONE:\r
 111                         return 0;\r
 112                 case GL_BOOL:\r
 113                 case GL_FLOAT:\r
 114                 case GL_INT:\r
 115                 case GL_BOOL_VEC2:\r
 116                 case GL_FLOAT_VEC2:\r
 117                 case GL_INT_VEC2:\r
 118                 case GL_INT_VEC3:\r
 119                 case GL_FLOAT_VEC3:\r
 120                 case GL_BOOL_VEC3:\r
 121                 case GL_BOOL_VEC4:\r
 122                 case GL_FLOAT_VEC4:\r
 123                 case GL_INT_VEC4:\r
 124                 case GL_SAMPLER_2D:\r
 125                 case GL_SAMPLER_CUBE:\r
 126         case GL_SAMPLER_EXTERNAL_OES:\r
 127                 case GL_SAMPLER_3D_OES:\r
 128                         return 1;\r
 129                 case GL_FLOAT_MAT2:\r
 130                         return 2;\r
 131                 case GL_FLOAT_MAT3:\r
 132                         return 3;\r
 133                 case GL_FLOAT_MAT4:\r
 134                         return 4;\r
 135                 default:\r
 136                         UNREACHABLE();\r
 137                 }\r
 138 \r
 139                 return 0;\r
 140         }\r
 141 \r
 142         int VariableColumnCount(GLenum type)\r
 143         {\r
 144                 switch(type)\r
 145                 {\r
 146                 case GL_NONE:\r
 147                         return 0;\r
 148                 case GL_BOOL:\r
 149                 case GL_FLOAT:\r
 150                 case GL_INT:\r
 151                         return 1;\r
 152                 case GL_BOOL_VEC2:\r
 153                 case GL_FLOAT_VEC2:\r
 154                 case GL_INT_VEC2:\r
 155                 case GL_FLOAT_MAT2:\r
 156                         return 2;\r
 157                 case GL_INT_VEC3:\r
 158                 case GL_FLOAT_VEC3:\r
 159                 case GL_BOOL_VEC3:\r
 160                 case GL_FLOAT_MAT3:\r
 161                         return 3;\r
 162                 case GL_BOOL_VEC4:\r
 163                 case GL_FLOAT_VEC4:\r
 164                 case GL_INT_VEC4:\r
 165                 case GL_FLOAT_MAT4:\r
 166                         return 4;\r
 167                 default:\r
 168                         UNREACHABLE();\r
 169                 }\r
 170 \r
 171                 return 0;\r
 172         }\r
 173 \r
 174         int AllocateFirstFreeBits(unsigned int *bits, unsigned int allocationSize, unsigned int bitsSize)\r
 175         {\r
 176                 ASSERT(allocationSize <= bitsSize);\r
 177 \r
 178                 unsigned int mask = std::numeric_limits<unsigned int>::max() >> (std::numeric_limits<unsigned int>::digits - allocationSize);\r
 179 \r
 180                 for(unsigned int i = 0; i < bitsSize - allocationSize + 1; i++)\r
 181                 {\r
 182                         if((*bits & mask) == 0)\r
 183                         {\r
 184                                 *bits |= mask;\r
 185                                 return i;\r
 186                         }\r
 187 \r
 188                         mask <<= 1;\r
 189                 }\r
 190 \r
 191                 return -1;\r
 192         }\r
 193 \r
 194         GLsizei ComputePitch(GLsizei width, GLenum format, GLenum type, GLint alignment)\r
 195         {\r
 196                 ASSERT(alignment > 0 && isPow2(alignment));\r
 197 \r
 198                 GLsizei rawPitch = ComputePixelSize(format, type) * width;\r
 199                 return (rawPitch + alignment - 1) & ~(alignment - 1);\r
 200         }\r
 201 \r
 202         GLsizei ComputeCompressedPitch(GLsizei width, GLenum format)\r
 203         {\r
 204                 return ComputeCompressedSize(width, 1, format);\r
 205         }\r
 206 \r
 207         GLsizei ComputeCompressedSize(GLsizei width, GLsizei height, GLenum format)\r
 208         {\r
 209                 switch(format)\r
 210                 {\r
 211                 case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:\r
 212                 case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:\r
 213         case GL_ETC1_RGB8_OES:\r
 214                         return 8 * (GLsizei)ceil((float)width / 4.0f) * (GLsizei)ceil((float)height / 4.0f);\r
 215                 case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:\r
 216                 case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:\r
 217                         return 16 * (GLsizei)ceil((float)width / 4.0f) * (GLsizei)ceil((float)height / 4.0f);\r
 218                 default:\r
 219                         return 0;\r
 220                 }\r
 221         }\r
 222 \r
 223         bool IsCompressed(GLenum format)\r
 224         {\r
 225                 return format == GL_COMPRESSED_RGB_S3TC_DXT1_EXT ||\r
 226                        format == GL_COMPRESSED_RGBA_S3TC_DXT1_EXT ||\r
 227                format == GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE ||\r
 228                format == GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE ||\r
 229                format == GL_ETC1_RGB8_OES;\r
 230         }\r
 231 \r
 232         bool IsDepthTexture(GLenum format)\r
 233         {\r
 234                 return format == GL_DEPTH_COMPONENT ||\r
 235                        format == GL_DEPTH_STENCIL_OES;\r
 236         }\r
 237 \r
 238         bool IsStencilTexture(GLenum format)\r
 239         {\r
 240                 return format == GL_STENCIL_INDEX_OES ||\r
 241                        format == GL_DEPTH_STENCIL_OES;\r
 242         }\r
 243 \r
 244         // Returns the size, in bytes, of a single texel in an Image\r
 245         int ComputePixelSize(GLenum format, GLenum type)\r
 246         {\r
 247                 switch(type)\r
 248                 {\r
 249                 case GL_UNSIGNED_BYTE:\r
 250                         switch(format)\r
 251                         {\r
 252                         case GL_ALPHA:           return sizeof(unsigned char);\r
 253                         case GL_LUMINANCE:       return sizeof(unsigned char);\r
 254                         case GL_LUMINANCE_ALPHA: return sizeof(unsigned char) * 2;\r
 255                         case GL_RGB:             return sizeof(unsigned char) * 3;\r
 256                         case GL_RGBA:            return sizeof(unsigned char) * 4;\r
 257                         case GL_BGRA_EXT:        return sizeof(unsigned char) * 4;\r
 258                         default: UNREACHABLE();\r
 259                         }\r
 260                         break;\r
 261                 case GL_UNSIGNED_SHORT_4_4_4_4:\r
 262                 case GL_UNSIGNED_SHORT_5_5_5_1:\r
 263                 case GL_UNSIGNED_SHORT_5_6_5:\r
 264                 case GL_UNSIGNED_SHORT:\r
 265                         return sizeof(unsigned short);\r
 266                 case GL_UNSIGNED_INT:\r
 267                 case GL_UNSIGNED_INT_24_8_OES:\r
 268                         return sizeof(unsigned int);\r
 269                 case GL_FLOAT:\r
 270                         switch(format)\r
 271                         {\r
 272                         case GL_ALPHA:           return sizeof(float);\r
 273                         case GL_LUMINANCE:       return sizeof(float);\r
 274                         case GL_LUMINANCE_ALPHA: return sizeof(float) * 2;\r
 275                         case GL_RGB:             return sizeof(float) * 3;\r
 276                         case GL_RGBA:            return sizeof(float) * 4;\r
 277                         default: UNREACHABLE();\r
 278                         }\r
 279                         break;\r
 280                 case GL_HALF_FLOAT_OES:\r
 281                         switch(format)\r
 282                         {\r
 283                         case GL_ALPHA:           return sizeof(unsigned short);\r
 284                         case GL_LUMINANCE:       return sizeof(unsigned short);\r
 285                         case GL_LUMINANCE_ALPHA: return sizeof(unsigned short) * 2;\r
 286                         case GL_RGB:             return sizeof(unsigned short) * 3;\r
 287                         case GL_RGBA:            return sizeof(unsigned short) * 4;\r
 288                         default: UNREACHABLE();\r
 289                         }\r
 290                         break;\r
 291                 default: UNREACHABLE();\r
 292                 }\r
 293 \r
 294                 return 0;\r
 295         }\r
 296 \r
 297         bool IsCubemapTextureTarget(GLenum target)\r
 298         {\r
 299                 return (target >= GL_TEXTURE_CUBE_MAP_POSITIVE_X && target <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z);\r
 300         }\r
 301 \r
 302         int CubeFaceIndex(GLenum cubeFace)\r
 303         {\r
 304                 switch(cubeFace)\r
 305                 {\r
 306                 case GL_TEXTURE_CUBE_MAP:\r
 307                 case GL_TEXTURE_CUBE_MAP_POSITIVE_X: return 0;\r
 308                 case GL_TEXTURE_CUBE_MAP_NEGATIVE_X: return 1;\r
 309                 case GL_TEXTURE_CUBE_MAP_POSITIVE_Y: return 2;\r
 310                 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y: return 3;\r
 311                 case GL_TEXTURE_CUBE_MAP_POSITIVE_Z: return 4;\r
 312                 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z: return 5;\r
 313                 default: UNREACHABLE(); return 0;\r
 314                 }\r
 315         }\r
 316 \r
 317         bool IsTextureTarget(GLenum target)\r
 318         {\r
 319                 return target == GL_TEXTURE_2D || IsCubemapTextureTarget(target);\r
 320         }\r
 321 \r
 322         // Verify that format/type are one of the combinations from table 3.4.\r
 323         bool CheckTextureFormatType(GLenum format, GLenum type)\r
 324         {\r
 325                 switch(type)\r
 326                 {\r
 327                 case GL_UNSIGNED_BYTE:\r
 328                         switch(format)\r
 329                         {\r
 330                         case GL_RGBA:\r
 331                         case GL_BGRA_EXT:\r
 332                         case GL_RGB:\r
 333                         case GL_ALPHA:\r
 334                         case GL_LUMINANCE:\r
 335                         case GL_LUMINANCE_ALPHA:\r
 336                                 return true;\r
 337                         default:\r
 338                                 return false;\r
 339                         }\r
 340                 case GL_FLOAT:\r
 341                 case GL_HALF_FLOAT_OES:\r
 342                         switch(format)\r
 343                         {\r
 344                         case GL_RGBA:\r
 345                         case GL_RGB:\r
 346                         case GL_ALPHA:\r
 347                         case GL_LUMINANCE:\r
 348                         case GL_LUMINANCE_ALPHA:\r
 349                                 return true;\r
 350                         default:\r
 351                                 return false;\r
 352                         }\r
 353                 case GL_UNSIGNED_SHORT_4_4_4_4:\r
 354                 case GL_UNSIGNED_SHORT_5_5_5_1:\r
 355                         return (format == GL_RGBA);\r
 356                 case GL_UNSIGNED_SHORT_5_6_5:\r
 357                         return (format == GL_RGB);\r
 358                 case GL_UNSIGNED_INT:\r
 359                         return (format == GL_DEPTH_COMPONENT);\r
 360                 case GL_UNSIGNED_INT_24_8_OES:\r
 361                         return (format == GL_DEPTH_STENCIL_OES);\r
 362                 default:\r
 363                         return false;\r
 364                 }\r
 365         }\r
 366 \r
 367         bool IsColorRenderable(GLenum internalformat)\r
 368         {\r
 369                 switch(internalformat)\r
 370                 {\r
 371                 case GL_RGBA4:\r
 372                 case GL_RGB5_A1:\r
 373                 case GL_RGB565:\r
 374                 case GL_RGB8_OES:\r
 375                 case GL_RGBA8_OES:\r
 376                         return true;\r
 377                 case GL_DEPTH_COMPONENT16:\r
 378                 case GL_STENCIL_INDEX8:\r
 379                 case GL_DEPTH24_STENCIL8_OES:\r
 380                         return false;\r
 381                 default:\r
 382                         UNIMPLEMENTED();\r
 383                 }\r
 384 \r
 385                 return false;\r
 386         }\r
 387 \r
 388         bool IsDepthRenderable(GLenum internalformat)\r
 389         {\r
 390                 switch(internalformat)\r
 391                 {\r
 392                 case GL_DEPTH_COMPONENT16:\r
 393                 case GL_DEPTH24_STENCIL8_OES:\r
 394                         return true;\r
 395                 case GL_STENCIL_INDEX8:\r
 396                 case GL_RGBA4:\r
 397                 case GL_RGB5_A1:\r
 398                 case GL_RGB565:\r
 399                 case GL_RGB8_OES:\r
 400                 case GL_RGBA8_OES:\r
 401                         return false;\r
 402                 default:\r
 403                         UNIMPLEMENTED();\r
 404                 }\r
 405 \r
 406                 return false;\r
 407         }\r
 408 \r
 409         bool IsStencilRenderable(GLenum internalformat)\r
 410         {\r
 411                 switch(internalformat)\r
 412                 {\r
 413                 case GL_STENCIL_INDEX8:\r
 414                 case GL_DEPTH24_STENCIL8_OES:\r
 415                         return true;\r
 416                 case GL_RGBA4:\r
 417                 case GL_RGB5_A1:\r
 418                 case GL_RGB565:\r
 419                 case GL_RGB8_OES:\r
 420                 case GL_RGBA8_OES:\r
 421                 case GL_DEPTH_COMPONENT16:\r
 422                         return false;\r
 423                 default:\r
 424                         UNIMPLEMENTED();\r
 425                 }\r
 426 \r
 427                 return false;\r
 428         }\r
 429 }\r
 430 \r
 431 namespace es2sw\r
 432 {\r
 433         sw::DepthCompareMode ConvertDepthComparison(GLenum comparison)\r
 434         {\r
 435                 switch(comparison)\r
 436                 {\r
 437                 case GL_NEVER:    return sw::DEPTH_NEVER;\r
 438                 case GL_ALWAYS:   return sw::DEPTH_ALWAYS;\r
 439                 case GL_LESS:     return sw::DEPTH_LESS;\r
 440                 case GL_LEQUAL:   return sw::DEPTH_LESSEQUAL;\r
 441                 case GL_EQUAL:    return sw::DEPTH_EQUAL;\r
 442                 case GL_GREATER:  return sw::DEPTH_GREATER;\r
 443                 case GL_GEQUAL:   return sw::DEPTH_GREATEREQUAL;\r
 444                 case GL_NOTEQUAL: return sw::DEPTH_NOTEQUAL;\r
 445                 default: UNREACHABLE();\r
 446                 }\r
 447 \r
 448                 return sw::DEPTH_ALWAYS;\r
 449         }\r
 450 \r
 451         sw::StencilCompareMode ConvertStencilComparison(GLenum comparison)\r
 452         {\r
 453                 switch(comparison)\r
 454                 {\r
 455                 case GL_NEVER:    return sw::STENCIL_NEVER;\r
 456                 case GL_ALWAYS:   return sw::STENCIL_ALWAYS;\r
 457                 case GL_LESS:     return sw::STENCIL_LESS;\r
 458                 case GL_LEQUAL:   return sw::STENCIL_LESSEQUAL;\r
 459                 case GL_EQUAL:    return sw::STENCIL_EQUAL;\r
 460                 case GL_GREATER:  return sw::STENCIL_GREATER;\r
 461                 case GL_GEQUAL:   return sw::STENCIL_GREATEREQUAL;\r
 462                 case GL_NOTEQUAL: return sw::STENCIL_NOTEQUAL;\r
 463                 default: UNREACHABLE();\r
 464                 }\r
 465 \r
 466                 return sw::STENCIL_ALWAYS;\r
 467         }\r
 468 \r
 469         sw::Color<float> ConvertColor(es2::Color color)\r
 470         {\r
 471                 return sw::Color<float>(color.red, color.green, color.blue, color.alpha);\r
 472         }\r
 473 \r
 474         sw::BlendFactor ConvertBlendFunc(GLenum blend)\r
 475         {\r
 476                 switch(blend)\r
 477                 {\r
 478                 case GL_ZERO:                     return sw::BLEND_ZERO;\r
 479                 case GL_ONE:                      return sw::BLEND_ONE;\r
 480                 case GL_SRC_COLOR:                return sw::BLEND_SOURCE;\r
 481                 case GL_ONE_MINUS_SRC_COLOR:      return sw::BLEND_INVSOURCE;\r
 482                 case GL_DST_COLOR:                return sw::BLEND_DEST;\r
 483                 case GL_ONE_MINUS_DST_COLOR:      return sw::BLEND_INVDEST;\r
 484                 case GL_SRC_ALPHA:                return sw::BLEND_SOURCEALPHA;\r
 485                 case GL_ONE_MINUS_SRC_ALPHA:      return sw::BLEND_INVSOURCEALPHA;\r
 486                 case GL_DST_ALPHA:                return sw::BLEND_DESTALPHA;\r
 487                 case GL_ONE_MINUS_DST_ALPHA:      return sw::BLEND_INVDESTALPHA;\r
 488                 case GL_CONSTANT_COLOR:           return sw::BLEND_CONSTANT;\r
 489                 case GL_ONE_MINUS_CONSTANT_COLOR: return sw::BLEND_INVCONSTANT;\r
 490                 case GL_CONSTANT_ALPHA:           return sw::BLEND_CONSTANTALPHA;\r
 491                 case GL_ONE_MINUS_CONSTANT_ALPHA: return sw::BLEND_INVCONSTANTALPHA;\r
 492                 case GL_SRC_ALPHA_SATURATE:       return sw::BLEND_SRCALPHASAT;\r
 493                 default: UNREACHABLE();\r
 494                 }\r
 495 \r
 496                 return sw::BLEND_ZERO;\r
 497         }\r
 498 \r
 499         sw::BlendOperation ConvertBlendOp(GLenum blendOp)\r
 500         {\r
 501                 switch(blendOp)\r
 502                 {\r
 503                 case GL_FUNC_ADD:              return sw::BLENDOP_ADD;\r
 504                 case GL_FUNC_SUBTRACT:         return sw::BLENDOP_SUB;\r
 505                 case GL_FUNC_REVERSE_SUBTRACT: return sw::BLENDOP_INVSUB;\r
 506                 case GL_MIN_EXT:               return sw::BLENDOP_MIN;\r
 507                 case GL_MAX_EXT:               return sw::BLENDOP_MAX;\r
 508                 default: UNREACHABLE();\r
 509                 }\r
 510 \r
 511                 return sw::BLENDOP_ADD;\r
 512         }\r
 513 \r
 514         sw::StencilOperation ConvertStencilOp(GLenum stencilOp)\r
 515         {\r
 516                 switch(stencilOp)\r
 517                 {\r
 518                 case GL_ZERO:      return sw::OPERATION_ZERO;\r
 519                 case GL_KEEP:      return sw::OPERATION_KEEP;\r
 520                 case GL_REPLACE:   return sw::OPERATION_REPLACE;\r
 521                 case GL_INCR:      return sw::OPERATION_INCRSAT;\r
 522                 case GL_DECR:      return sw::OPERATION_DECRSAT;\r
 523                 case GL_INVERT:    return sw::OPERATION_INVERT;\r
 524                 case GL_INCR_WRAP: return sw::OPERATION_INCR;\r
 525                 case GL_DECR_WRAP: return sw::OPERATION_DECR;\r
 526                 default: UNREACHABLE();\r
 527                 }\r
 528 \r
 529                 return sw::OPERATION_KEEP;\r
 530         }\r
 531 \r
 532         sw::AddressingMode ConvertTextureWrap(GLenum wrap)\r
 533         {\r
 534                 switch(wrap)\r
 535                 {\r
 536                 case GL_REPEAT:            return sw::ADDRESSING_WRAP;\r
 537                 case GL_CLAMP_TO_EDGE:     return sw::ADDRESSING_CLAMP;\r
 538                 case GL_MIRRORED_REPEAT:   return sw::ADDRESSING_MIRROR;\r
 539                 default: UNREACHABLE();\r
 540                 }\r
 541 \r
 542                 return sw::ADDRESSING_WRAP;\r
 543         }\r
 544 \r
 545         sw::CullMode ConvertCullMode(GLenum cullFace, GLenum frontFace)\r
 546         {\r
 547                 switch(cullFace)\r
 548                 {\r
 549                 case GL_FRONT:\r
 550                         return (frontFace == GL_CCW ? sw::CULL_CLOCKWISE : sw::CULL_COUNTERCLOCKWISE);\r
 551                 case GL_BACK:\r
 552                         return (frontFace == GL_CCW ? sw::CULL_COUNTERCLOCKWISE : sw::CULL_CLOCKWISE);\r
 553                 case GL_FRONT_AND_BACK:\r
 554                         return sw::CULL_NONE;   // culling will be handled during draw\r
 555                 default: UNREACHABLE();\r
 556                 }\r
 557 \r
 558                 return sw::CULL_COUNTERCLOCKWISE;\r
 559         }\r
 560 \r
 561         unsigned int ConvertColorMask(bool red, bool green, bool blue, bool alpha)\r
 562         {\r
 563                 return (red   ? 0x00000001 : 0) |\r
 564                            (green ? 0x00000002 : 0) |\r
 565                            (blue  ? 0x00000004 : 0) |\r
 566                            (alpha ? 0x00000008 : 0);\r
 567         }\r
 568 \r
 569         sw::FilterType ConvertMagFilter(GLenum magFilter)\r
 570         {\r
 571                 switch(magFilter)\r
 572                 {\r
 573                 case GL_NEAREST: return sw::FILTER_POINT;\r
 574                 case GL_LINEAR:  return sw::FILTER_LINEAR;\r
 575                 default: UNREACHABLE();\r
 576                 }\r
 577 \r
 578                 return sw::FILTER_POINT;\r
 579         }\r
 580 \r
 581         void ConvertMinFilter(GLenum texFilter, sw::FilterType *minFilter, sw::MipmapType *mipFilter, float maxAnisotropy)\r
 582         {\r
 583                 switch(texFilter)\r
 584                 {\r
 585                 case GL_NEAREST:\r
 586                         *minFilter = sw::FILTER_POINT;\r
 587                         *mipFilter = sw::MIPMAP_NONE;\r
 588                         break;\r
 589                 case GL_LINEAR:\r
 590                         *minFilter = sw::FILTER_LINEAR;\r
 591                         *mipFilter = sw::MIPMAP_NONE;\r
 592                         break;\r
 593                 case GL_NEAREST_MIPMAP_NEAREST:\r
 594                         *minFilter = sw::FILTER_POINT;\r
 595                         *mipFilter = sw::MIPMAP_POINT;\r
 596                         break;\r
 597                 case GL_LINEAR_MIPMAP_NEAREST:\r
 598                         *minFilter = sw::FILTER_LINEAR;\r
 599                         *mipFilter = sw::MIPMAP_POINT;\r
 600                         break;\r
 601                 case GL_NEAREST_MIPMAP_LINEAR:\r
 602                         *minFilter = sw::FILTER_POINT;\r
 603                         *mipFilter = sw::MIPMAP_LINEAR;\r
 604                         break;\r
 605                 case GL_LINEAR_MIPMAP_LINEAR:\r
 606                         *minFilter = sw::FILTER_LINEAR;\r
 607                         *mipFilter = sw::MIPMAP_LINEAR;\r
 608                         break;\r
 609                 default:\r
 610                         *minFilter = sw::FILTER_POINT;\r
 611                         *mipFilter = sw::MIPMAP_NONE;\r
 612                         UNREACHABLE();\r
 613                 }\r
 614 \r
 615                 if(maxAnisotropy > 1.0f)\r
 616                 {\r
 617                         *minFilter = sw::FILTER_ANISOTROPIC;\r
 618                 }\r
 619         }\r
 620 \r
 621         bool ConvertPrimitiveType(GLenum primitiveType, GLsizei elementCount,  es2::PrimitiveType &swPrimitiveType, int &primitiveCount)\r
 622         {\r
 623                 switch(primitiveType)\r
 624                 {\r
 625                 case GL_POINTS:\r
 626                         swPrimitiveType = es2::DRAW_POINTLIST;\r
 627                         primitiveCount = elementCount;\r
 628                         break;\r
 629                 case GL_LINES:\r
 630                         swPrimitiveType = es2::DRAW_LINELIST;\r
 631                         primitiveCount = elementCount / 2;\r
 632                         break;\r
 633                 case GL_LINE_LOOP:\r
 634                         swPrimitiveType = es2::DRAW_LINELOOP;\r
 635                         primitiveCount = elementCount;\r
 636                         break;\r
 637                 case GL_LINE_STRIP:\r
 638                         swPrimitiveType = es2::DRAW_LINESTRIP;\r
 639                         primitiveCount = elementCount - 1;\r
 640                         break;\r
 641                 case GL_TRIANGLES:\r
 642                         swPrimitiveType = es2::DRAW_TRIANGLELIST;\r
 643                         primitiveCount = elementCount / 3;\r
 644                         break;\r
 645                 case GL_TRIANGLE_STRIP:\r
 646                         swPrimitiveType = es2::DRAW_TRIANGLESTRIP;\r
 647                         primitiveCount = elementCount - 2;\r
 648                         break;\r
 649                 case GL_TRIANGLE_FAN:\r
 650                         swPrimitiveType = es2::DRAW_TRIANGLEFAN;\r
 651                         primitiveCount = elementCount - 2;\r
 652                         break;\r
 653                 default:\r
 654                         return false;\r
 655                 }\r
 656 \r
 657                 return true;\r
 658         }\r
 659 \r
 660         sw::Format ConvertRenderbufferFormat(GLenum format)\r
 661         {\r
 662                 switch(format)\r
 663                 {\r
 664                 case GL_RGBA4:\r
 665                 case GL_RGB5_A1:\r
 666                 case GL_RGBA8_OES:            return sw::FORMAT_A8R8G8B8;\r
 667                 case GL_RGB565:               return sw::FORMAT_R5G6B5;\r
 668                 case GL_RGB8_OES:             return sw::FORMAT_X8R8G8B8;\r
 669                 case GL_DEPTH_COMPONENT16:\r
 670                 case GL_STENCIL_INDEX8:       \r
 671                 case GL_DEPTH24_STENCIL8_OES: return sw::FORMAT_D24S8;\r
 672                 default: UNREACHABLE();       return sw::FORMAT_A8R8G8B8;\r
 673                 }\r
 674         }\r
 675 }\r
 676 \r
 677 namespace sw2es\r
 678 {\r
 679         unsigned int GetStencilSize(sw::Format stencilFormat)\r
 680         {\r
 681                 switch(stencilFormat)\r
 682                 {\r
 683                 case sw::FORMAT_D24FS8:\r
 684                 case sw::FORMAT_D24S8:\r
 685                 case sw::FORMAT_D32FS8_TEXTURE:\r
 686                         return 8;\r
 687         //      case sw::FORMAT_D24X4S4:\r
 688         //              return 4;\r
 689         //      case sw::FORMAT_D15S1:\r
 690         //              return 1;\r
 691         //      case sw::FORMAT_D16_LOCKABLE:\r
 692                 case sw::FORMAT_D32:\r
 693                 case sw::FORMAT_D24X8:\r
 694                 case sw::FORMAT_D32F_LOCKABLE:\r
 695                 case sw::FORMAT_D16:\r
 696                         return 0;\r
 697         //      case sw::FORMAT_D32_LOCKABLE:  return 0;\r
 698         //      case sw::FORMAT_S8_LOCKABLE:   return 8;\r
 699                 default:\r
 700                         return 0;\r
 701                 }\r
 702         }\r
 703 \r
 704         unsigned int GetAlphaSize(sw::Format colorFormat)\r
 705         {\r
 706                 switch(colorFormat)\r
 707                 {\r
 708                 case sw::FORMAT_A16B16G16R16F:\r
 709                         return 16;\r
 710                 case sw::FORMAT_A32B32G32R32F:\r
 711                         return 32;\r
 712                 case sw::FORMAT_A2R10G10B10:\r
 713                         return 2;\r
 714                 case sw::FORMAT_A8R8G8B8:\r
 715                         return 8;\r
 716                 case sw::FORMAT_A1R5G5B5:\r
 717                         return 1;\r
 718                 case sw::FORMAT_X8R8G8B8:\r
 719                 case sw::FORMAT_R5G6B5:\r
 720                         return 0;\r
 721                 default:\r
 722                         return 0;\r
 723                 }\r
 724         }\r
 725 \r
 726         unsigned int GetRedSize(sw::Format colorFormat)\r
 727         {\r
 728                 switch(colorFormat)\r
 729                 {\r
 730                 case sw::FORMAT_A16B16G16R16F:\r
 731                         return 16;\r
 732                 case sw::FORMAT_A32B32G32R32F:\r
 733                         return 32;\r
 734                 case sw::FORMAT_A2R10G10B10:\r
 735                         return 10;\r
 736                 case sw::FORMAT_A8R8G8B8:\r
 737                 case sw::FORMAT_X8R8G8B8:\r
 738                         return 8;\r
 739                 case sw::FORMAT_A1R5G5B5:\r
 740                 case sw::FORMAT_R5G6B5:\r
 741                         return 5;\r
 742                 default:\r
 743                         return 0;\r
 744                 }\r
 745         }\r
 746 \r
 747         unsigned int GetGreenSize(sw::Format colorFormat)\r
 748         {\r
 749                 switch(colorFormat)\r
 750                 {\r
 751                 case sw::FORMAT_A16B16G16R16F:\r
 752                         return 16;\r
 753                 case sw::FORMAT_A32B32G32R32F:\r
 754                         return 32;\r
 755                 case sw::FORMAT_A2R10G10B10:\r
 756                         return 10;\r
 757                 case sw::FORMAT_A8R8G8B8:\r
 758                 case sw::FORMAT_X8R8G8B8:\r
 759                         return 8;\r
 760                 case sw::FORMAT_A1R5G5B5:\r
 761                         return 5;\r
 762                 case sw::FORMAT_R5G6B5:\r
 763                         return 6;\r
 764                 default:\r
 765                         return 0;\r
 766                 }\r
 767         }\r
 768 \r
 769         unsigned int GetBlueSize(sw::Format colorFormat)\r
 770         {\r
 771                 switch(colorFormat)\r
 772                 {\r
 773                 case sw::FORMAT_A16B16G16R16F:\r
 774                         return 16;\r
 775                 case sw::FORMAT_A32B32G32R32F:\r
 776                         return 32;\r
 777                 case sw::FORMAT_A2R10G10B10:\r
 778                         return 10;\r
 779                 case sw::FORMAT_A8R8G8B8:\r
 780                 case sw::FORMAT_X8R8G8B8:\r
 781                         return 8;\r
 782                 case sw::FORMAT_A1R5G5B5:\r
 783                 case sw::FORMAT_R5G6B5:\r
 784                         return 5;\r
 785                 default:\r
 786                         return 0;\r
 787                 }\r
 788         }\r
 789 \r
 790         unsigned int GetDepthSize(sw::Format depthFormat)\r
 791         {\r
 792                 switch(depthFormat)\r
 793                 {\r
 794         //      case sw::FORMAT_D16_LOCKABLE:   return 16;\r
 795                 case sw::FORMAT_D32:            return 32;\r
 796         //      case sw::FORMAT_D15S1:          return 15;\r
 797                 case sw::FORMAT_D24S8:          return 24;\r
 798                 case sw::FORMAT_D24X8:          return 24;\r
 799         //      case sw::FORMAT_D24X4S4:        return 24;\r
 800                 case sw::FORMAT_D16:            return 16;\r
 801                 case sw::FORMAT_D32F_LOCKABLE:  return 32;\r
 802                 case sw::FORMAT_D24FS8:         return 24;\r
 803         //      case sw::FORMAT_D32_LOCKABLE:   return 32;\r
 804         //      case sw::FORMAT_S8_LOCKABLE:    return 0;\r
 805                 case sw::FORMAT_D32FS8_TEXTURE: return 32;\r
 806                 default:                        return 0;\r
 807                 }\r
 808         }\r
 809 \r
 810         GLenum ConvertBackBufferFormat(sw::Format format)\r
 811         {\r
 812                 switch(format)\r
 813                 {\r
 814                 case sw::FORMAT_A4R4G4B4: return GL_RGBA4;\r
 815                 case sw::FORMAT_A8R8G8B8: return GL_RGBA8_OES;\r
 816                 case sw::FORMAT_A1R5G5B5: return GL_RGB5_A1;\r
 817                 case sw::FORMAT_R5G6B5:   return GL_RGB565;\r
 818                 case sw::FORMAT_X8R8G8B8: return GL_RGB8_OES;\r
 819                 default:\r
 820                         UNREACHABLE();\r
 821                 }\r
 822 \r
 823                 return GL_RGBA4;\r
 824         }\r
 825 \r
 826         GLenum ConvertDepthStencilFormat(sw::Format format)\r
 827         {\r
 828                 switch(format)\r
 829                 {\r
 830                 case sw::FORMAT_D16:\r
 831                 case sw::FORMAT_D24X8:\r
 832                 case sw::FORMAT_D32:\r
 833                         return GL_DEPTH_COMPONENT16;\r
 834                 case sw::FORMAT_D24S8:\r
 835                         return GL_DEPTH24_STENCIL8_OES;\r
 836                 default:\r
 837                         UNREACHABLE();\r
 838                 }\r
 839 \r
 840                 return GL_DEPTH24_STENCIL8_OES;\r
 841         }\r
 842 }\r