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