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