1/****************************************************************************** 2 3 @File PVRTTexture.cpp 4 5 @Title PVRTTexture 6 7 @Version 8 9 @Copyright Copyright (c) Imagination Technologies Limited. 10 11 @Platform ANSI compatible 12 13 @Description Texture loading. 14 15******************************************************************************/ 16#include <string.h> 17#include <stdlib.h> 18 19#include "PVRTTexture.h" 20#include "PVRTMap.h" 21 22/***************************************************************************** 23** Functions 24*****************************************************************************/ 25/*!*************************************************************************** 26@Function ReadFromPtr 27@Input pDataCursor The data to read 28@Description Reads from a pointer of memory in to the meta data block. 29*****************************************************************************/ 30bool MetaDataBlock::ReadFromPtr(const unsigned char** pDataCursor) 31{ 32 memcpy(&DevFOURCC, *pDataCursor, sizeof(PVRTuint32)); *pDataCursor += sizeof(PVRTuint32); 33 memcpy(&u32Key, *pDataCursor, sizeof(PVRTuint32)); *pDataCursor += sizeof(PVRTuint32); 34 memcpy(&u32DataSize, *pDataCursor, sizeof(PVRTuint32)); *pDataCursor += sizeof(PVRTuint32); 35 if(u32DataSize > 0) 36 { 37 Data = new PVRTuint8[u32DataSize]; 38 memcpy(Data, *pDataCursor, u32DataSize); 39 *pDataCursor += u32DataSize; 40 } 41 42 return true; 43} 44 45/*!*************************************************************************** 46@Function PVRTTextureLoadTiled 47@Modified pDst Texture to place the tiled data 48@Input nWidthDst Width of destination texture 49@Input nHeightDst Height of destination texture 50@Input pSrc Texture to tile 51@Input nWidthSrc Width of source texture 52@Input nHeightSrc Height of source texture 53@Input nElementSize Bytes per pixel 54@Input bTwiddled True if the data is twiddled 55@Description Needed by PVRTTextureTile() in the various PVRTTextureAPIs 56*****************************************************************************/ 57void PVRTTextureLoadTiled( 58 PVRTuint8 * const pDst, 59 const unsigned int nWidthDst, 60 const unsigned int nHeightDst, 61 const PVRTuint8 * const pSrc, 62 const unsigned int nWidthSrc, 63 const unsigned int nHeightSrc, 64 const unsigned int nElementSize, 65 const bool bTwiddled) 66{ 67 unsigned int nXs, nYs; 68 unsigned int nXd, nYd; 69 unsigned int nIdxSrc, nIdxDst; 70 71 for(nIdxDst = 0; nIdxDst < nWidthDst*nHeightDst; ++nIdxDst) 72 { 73 if(bTwiddled) 74 { 75 PVRTTextureDeTwiddle(nXd, nYd, nIdxDst); 76 } 77 else 78 { 79 nXd = nIdxDst % nWidthDst; 80 nYd = nIdxDst / nWidthDst; 81 } 82 83 nXs = nXd % nWidthSrc; 84 nYs = nYd % nHeightSrc; 85 86 if(bTwiddled) 87 { 88 PVRTTextureTwiddle(nIdxSrc, nXs, nYs); 89 } 90 else 91 { 92 nIdxSrc = nYs * nWidthSrc + nXs; 93 } 94 95 memcpy(pDst + nIdxDst*nElementSize, pSrc + nIdxSrc*nElementSize, nElementSize); 96 } 97} 98 99/*!*************************************************************************** 100@Function PVRTTextureCreate 101@Input w Size of the texture 102@Input h Size of the texture 103@Input wMin Minimum size of a texture level 104@Input hMin Minimum size of a texture level 105@Input nBPP Bits per pixel of the format 106@Input bMIPMap Create memory for MIP-map levels also? 107@Return Allocated texture memory (must be free()d) 108@Description Creates a PVRTextureHeaderV3 structure, including room for 109 the specified texture, in memory. 110*****************************************************************************/ 111PVRTextureHeaderV3 *PVRTTextureCreate( 112 const unsigned int w, 113 const unsigned int h, 114 const unsigned int wMin, 115 const unsigned int hMin, 116 const unsigned int nBPP, 117 const bool bMIPMap) 118{ 119 size_t len; 120 unsigned char *p; 121 122 { 123 unsigned int wTmp = w, hTmp = h; 124 125 len = 0; 126 do 127 { 128 len += PVRT_MAX(wTmp, wMin) * PVRT_MAX(hTmp, hMin); 129 wTmp >>= 1; 130 hTmp >>= 1; 131 } 132 while(bMIPMap && (wTmp || hTmp)); 133 } 134 135 len = (len * nBPP) / 8; 136 len += PVRTEX3_HEADERSIZE; 137 138 p = (unsigned char*)malloc(len); 139 _ASSERT(p); 140 141 if(p) 142 { 143 PVRTextureHeaderV3 * const psTexHeader = (PVRTextureHeaderV3*)p; 144 145 *psTexHeader=PVRTextureHeaderV3(); 146 147 psTexHeader->u32Width=w; 148 psTexHeader->u32Height=h; 149 150 return psTexHeader; 151 } 152 else 153 { 154 return 0; 155 } 156} 157 158 159/*!*************************************************************************** 160 @Function PVRTTextureTwiddle 161 @Output a Twiddled value 162 @Input u Coordinate axis 0 163 @Input v Coordinate axis 1 164 @Description Combine a 2D coordinate into a twiddled value 165*****************************************************************************/ 166void PVRTTextureTwiddle(unsigned int &a, const unsigned int u, const unsigned int v) 167{ 168 _ASSERT(!((u|v) & 0xFFFF0000)); 169 a = 0; 170 for(int i = 0; i < 16; ++i) 171 { 172 a |= ((u & (1 << i)) << (i+1)); 173 a |= ((v & (1 << i)) << (i+0)); 174 } 175} 176 177/*!*************************************************************************** 178 @Function PVRTTextureDeTwiddle 179 @Output u Coordinate axis 0 180 @Output v Coordinate axis 1 181 @Input a Twiddled value 182 @Description Extract 2D coordinates from a twiddled value. 183*****************************************************************************/ 184void PVRTTextureDeTwiddle(unsigned int &u, unsigned int &v, const unsigned int a) 185{ 186 u = 0; 187 v = 0; 188 for(int i = 0; i < 16; ++i) 189 { 190 u |= (a & (1 << ((2*i)+1))) >> (i+1); 191 v |= (a & (1 << ((2*i)+0))) >> (i+0); 192 } 193} 194 195/*!*********************************************************************** 196 @Function PVRTGetBitsPerPixel 197 @Input u64PixelFormat A PVR Pixel Format ID. 198 @Return const PVRTuint32 Number of bits per pixel. 199 @Description Returns the number of bits per pixel in a PVR Pixel Format 200 identifier. 201*************************************************************************/ 202PVRTuint32 PVRTGetBitsPerPixel(PVRTuint64 u64PixelFormat) 203{ 204 if((u64PixelFormat&PVRTEX_PFHIGHMASK)!=0) 205 { 206 PVRTuint8* PixelFormatChar=(PVRTuint8*)&u64PixelFormat; 207 return PixelFormatChar[4]+PixelFormatChar[5]+PixelFormatChar[6]+PixelFormatChar[7]; 208 } 209 else 210 { 211 switch (u64PixelFormat) 212 { 213 case ePVRTPF_BW1bpp: 214 return 1; 215 case ePVRTPF_PVRTCI_2bpp_RGB: 216 case ePVRTPF_PVRTCI_2bpp_RGBA: 217 case ePVRTPF_PVRTCII_2bpp: 218 return 2; 219 case ePVRTPF_PVRTCI_4bpp_RGB: 220 case ePVRTPF_PVRTCI_4bpp_RGBA: 221 case ePVRTPF_PVRTCII_4bpp: 222 case ePVRTPF_ETC1: 223 case ePVRTPF_EAC_R11: 224 case ePVRTPF_ETC2_RGB: 225 case ePVRTPF_ETC2_RGB_A1: 226 case ePVRTPF_DXT1: 227 case ePVRTPF_BC4: 228 return 4; 229 case ePVRTPF_DXT2: 230 case ePVRTPF_DXT3: 231 case ePVRTPF_DXT4: 232 case ePVRTPF_DXT5: 233 case ePVRTPF_BC5: 234 case ePVRTPF_EAC_RG11: 235 case ePVRTPF_ETC2_RGBA: 236 return 8; 237 case ePVRTPF_YUY2: 238 case ePVRTPF_UYVY: 239 case ePVRTPF_RGBG8888: 240 case ePVRTPF_GRGB8888: 241 return 16; 242 case ePVRTPF_SharedExponentR9G9B9E5: 243 return 32; 244 case ePVRTPF_NumCompressedPFs: 245 return 0; 246 } 247 } 248 return 0; 249} 250 251/*!*********************************************************************** 252 @Function PVRTGetFormatMinDims 253 @Input u64PixelFormat A PVR Pixel Format ID. 254 @Modified minX Returns the minimum width. 255 @Modified minY Returns the minimum height. 256 @Modified minZ Returns the minimum depth. 257 @Description Gets the minimum dimensions (x,y,z) for a given pixel format. 258*************************************************************************/ 259void PVRTGetFormatMinDims(PVRTuint64 u64PixelFormat, PVRTuint32 &minX, PVRTuint32 &minY, PVRTuint32 &minZ) 260{ 261 switch(u64PixelFormat) 262 { 263 case ePVRTPF_DXT1: 264 case ePVRTPF_DXT2: 265 case ePVRTPF_DXT3: 266 case ePVRTPF_DXT4: 267 case ePVRTPF_DXT5: 268 case ePVRTPF_BC4: 269 case ePVRTPF_BC5: 270 case ePVRTPF_ETC1: 271 case ePVRTPF_ETC2_RGB: 272 case ePVRTPF_ETC2_RGBA: 273 case ePVRTPF_ETC2_RGB_A1: 274 case ePVRTPF_EAC_R11: 275 case ePVRTPF_EAC_RG11: 276 minX = 4; 277 minY = 4; 278 minZ = 1; 279 break; 280 case ePVRTPF_PVRTCI_4bpp_RGB: 281 case ePVRTPF_PVRTCI_4bpp_RGBA: 282 minX = 8; 283 minY = 8; 284 minZ = 1; 285 break; 286 case ePVRTPF_PVRTCI_2bpp_RGB: 287 case ePVRTPF_PVRTCI_2bpp_RGBA: 288 minX = 16; 289 minY = 8; 290 minZ = 1; 291 break; 292 case ePVRTPF_PVRTCII_4bpp: 293 minX = 4; 294 minY = 4; 295 minZ = 1; 296 break; 297 case ePVRTPF_PVRTCII_2bpp: 298 minX = 8; 299 minY = 4; 300 minZ = 1; 301 break; 302 case ePVRTPF_UYVY: 303 case ePVRTPF_YUY2: 304 case ePVRTPF_RGBG8888: 305 case ePVRTPF_GRGB8888: 306 minX = 2; 307 minY = 1; 308 minZ = 1; 309 break; 310 case ePVRTPF_BW1bpp: 311 minX = 8; 312 minY = 1; 313 minZ = 1; 314 break; 315 default: //Non-compressed formats all return 1. 316 minX = 1; 317 minY = 1; 318 minZ = 1; 319 break; 320 } 321} 322 323/*!*********************************************************************** 324@Function PVRTGetTextureDataSize 325@Input iMipLevel Specifies a mip level to check, 'PVRTEX_ALLMIPLEVELS' 326 can be passed to get the size of all MIP levels. 327@Input bAllSurfs Size of all surfaces is calculated if true, 328 only a single surface if false. 329@Input bAllFaces Size of all faces is calculated if true, 330 only a single face if false. 331@Return PVRTuint32 Size in BYTES of the specified texture area. 332@Description Gets the size in BYTES of the texture, given various input 333 parameters. User can retrieve the size of either all 334 surfaces or a single surface, all faces or a single face and 335 all MIP-Maps or a single specified MIP level. 336*************************************************************************/ 337PVRTuint32 PVRTGetTextureDataSize(PVRTextureHeaderV3 sTextureHeader, PVRTint32 iMipLevel, bool bAllSurfaces, bool bAllFaces) 338{ 339 //The smallest divisible sizes for a pixel format 340 PVRTuint32 uiSmallestWidth=1; 341 PVRTuint32 uiSmallestHeight=1; 342 PVRTuint32 uiSmallestDepth=1; 343 344 PVRTuint64 PixelFormatPartHigh = sTextureHeader.u64PixelFormat&PVRTEX_PFHIGHMASK; 345 346 //If the pixel format is compressed, get the pixel format's minimum dimensions. 347 if (PixelFormatPartHigh==0) 348 { 349 PVRTGetFormatMinDims((EPVRTPixelFormat)sTextureHeader.u64PixelFormat, uiSmallestWidth, uiSmallestHeight, uiSmallestDepth); 350 } 351 352 //Needs to be 64-bit integer to support 16kx16k and higher sizes. 353 PVRTuint64 uiDataSize = 0; 354 if (iMipLevel==-1) 355 { 356 for (PVRTuint8 uiCurrentMIP = 0; uiCurrentMIP<sTextureHeader.u32MIPMapCount; ++uiCurrentMIP) 357 { 358 //Get the dimensions of the current MIP Map level. 359 PVRTuint32 uiWidth = PVRT_MAX(1,sTextureHeader.u32Width>>uiCurrentMIP); 360 PVRTuint32 uiHeight = PVRT_MAX(1,sTextureHeader.u32Height>>uiCurrentMIP); 361 PVRTuint32 uiDepth = PVRT_MAX(1,sTextureHeader.u32Depth>>uiCurrentMIP); 362 363 //If pixel format is compressed, the dimensions need to be padded. 364 if (PixelFormatPartHigh==0) 365 { 366 uiWidth=uiWidth+( (-1*uiWidth)%uiSmallestWidth); 367 uiHeight=uiHeight+( (-1*uiHeight)%uiSmallestHeight); 368 uiDepth=uiDepth+( (-1*uiDepth)%uiSmallestDepth); 369 } 370 371 //Add the current MIP Map's data size to the total. 372 uiDataSize+=(PVRTuint64)PVRTGetBitsPerPixel(sTextureHeader.u64PixelFormat)*(PVRTuint64)uiWidth*(PVRTuint64)uiHeight*(PVRTuint64)uiDepth; 373 } 374 } 375 else 376 { 377 //Get the dimensions of the specified MIP Map level. 378 PVRTuint32 uiWidth = PVRT_MAX(1,sTextureHeader.u32Width>>iMipLevel); 379 PVRTuint32 uiHeight = PVRT_MAX(1,sTextureHeader.u32Height>>iMipLevel); 380 PVRTuint32 uiDepth = PVRT_MAX(1,sTextureHeader.u32Depth>>iMipLevel); 381 382 //If pixel format is compressed, the dimensions need to be padded. 383 if (PixelFormatPartHigh==0) 384 { 385 uiWidth=uiWidth+( (-1*uiWidth)%uiSmallestWidth); 386 uiHeight=uiHeight+( (-1*uiHeight)%uiSmallestHeight); 387 uiDepth=uiDepth+( (-1*uiDepth)%uiSmallestDepth); 388 } 389 390 //Work out the specified MIP Map's data size 391 uiDataSize=PVRTGetBitsPerPixel(sTextureHeader.u64PixelFormat)*uiWidth*uiHeight*uiDepth; 392 } 393 394 //The number of faces/surfaces to register the size of. 395 PVRTuint32 numfaces = ((bAllFaces)?(sTextureHeader.u32NumFaces):(1)); 396 PVRTuint32 numsurfs = ((bAllSurfaces)?(sTextureHeader.u32NumSurfaces):(1)); 397 398 //Multiply the data size by number of faces and surfaces specified, and return. 399 return (PVRTuint32)(uiDataSize/8)*numsurfs*numfaces; 400} 401 402/*!*********************************************************************** 403 @Function PVRTConvertOldTextureHeaderToV3 404 @Input LegacyHeader Legacy header for conversion. 405 @Modified NewHeader New header to output into. 406 @Modified MetaData MetaData Map to output into. 407 @Description Converts a legacy texture header (V1 or V2) to a current 408 generation header (V3) 409*************************************************************************/ 410void PVRTConvertOldTextureHeaderToV3(const PVR_Texture_Header* LegacyHeader, PVRTextureHeaderV3& NewHeader, CPVRTMap<PVRTuint32, CPVRTMap<PVRTuint32,MetaDataBlock> >* pMetaData) 411{ 412 //Setup variables 413 bool isPreMult; 414 PVRTuint64 ptNew; 415 EPVRTColourSpace cSpaceNew; 416 EPVRTVariableType chanTypeNew; 417 418 //Map the old enum to the new format. 419 PVRTMapLegacyTextureEnumToNewFormat((PVRTPixelType)(LegacyHeader->dwpfFlags&0xff),ptNew,cSpaceNew,chanTypeNew,isPreMult); 420 421 //Check if this is a cube map. 422 bool isCubeMap = (LegacyHeader->dwpfFlags&PVRTEX_CUBEMAP)!=0; 423 424 //Setup the new header. 425 NewHeader.u64PixelFormat=ptNew; 426 NewHeader.u32ChannelType=chanTypeNew; 427 NewHeader.u32ColourSpace=cSpaceNew; 428 NewHeader.u32Depth=1; 429 NewHeader.u32Flags=isPreMult?PVRTEX3_PREMULTIPLIED:0; 430 NewHeader.u32Height=LegacyHeader->dwHeight; 431 NewHeader.u32MetaDataSize=0; 432 NewHeader.u32MIPMapCount=(LegacyHeader->dwpfFlags&PVRTEX_MIPMAP?LegacyHeader->dwMipMapCount+1:1); //Legacy headers have a MIP Map count of 0 if there is only the top level. New Headers have a count of 1. 433 NewHeader.u32NumFaces=(isCubeMap?6:1); 434 435 //Only compute the number of surfaces if it's a V2 header, else default to 1 surface. 436 if (LegacyHeader->dwHeaderSize==sizeof(PVR_Texture_Header)) 437 NewHeader.u32NumSurfaces=(LegacyHeader->dwNumSurfs/(isCubeMap?6:1)); 438 else 439 NewHeader.u32NumSurfaces=1; 440 441 NewHeader.u32Version=PVRTEX3_IDENT; 442 NewHeader.u32Width=LegacyHeader->dwWidth; 443 444 //Clear any currently stored MetaData, or it will be inaccurate. 445 if (pMetaData) 446 { 447 pMetaData->Clear(); 448 } 449 450 //Check if this is a normal map. 451 if (LegacyHeader->dwpfFlags&PVRTEX_BUMPMAP && pMetaData) 452 { 453 //Get a reference to the correct block. 454 MetaDataBlock& mbBumpData=(*pMetaData)[PVRTEX_CURR_IDENT][ePVRTMetaDataBumpData]; 455 456 //Set up the block. 457 mbBumpData.DevFOURCC=PVRTEX_CURR_IDENT; 458 mbBumpData.u32Key=ePVRTMetaDataBumpData; 459 mbBumpData.u32DataSize=8; 460 mbBumpData.Data=new PVRTuint8[8]; 461 462 //Setup the data for the block. 463 float bumpScale = 1.0f; 464 const char* bumpOrder = "xyz"; 465 466 //Copy the bumpScale into the data. 467 memcpy(mbBumpData.Data,&bumpScale,4); 468 469 //Clear the string 470 memset(mbBumpData.Data+4,0,4); 471 472 //Copy the bumpOrder into the data. 473 memcpy(mbBumpData.Data+4, bumpOrder,3); 474 475 //Increment the meta data size. 476 NewHeader.u32MetaDataSize+=(12+mbBumpData.u32DataSize); 477 } 478 479 //Check if for vertical flip orientation. 480 if (LegacyHeader->dwpfFlags&PVRTEX_VERTICAL_FLIP && pMetaData) 481 { 482 //Get the correct meta data block 483 MetaDataBlock& mbTexOrientation=(*pMetaData)[PVRTEX_CURR_IDENT][ePVRTMetaDataTextureOrientation]; 484 485 //Set the block up. 486 mbTexOrientation.u32DataSize=3; 487 mbTexOrientation.Data=new PVRTuint8[3]; 488 mbTexOrientation.DevFOURCC=PVRTEX_CURR_IDENT; 489 mbTexOrientation.u32Key=ePVRTMetaDataTextureOrientation; 490 491 //Initialise the block to default orientation. 492 memset(mbTexOrientation.Data,0,3); 493 494 //Set the block oriented upwards. 495 mbTexOrientation.Data[ePVRTAxisY]=ePVRTOrientUp; 496 497 //Increment the meta data size. 498 NewHeader.u32MetaDataSize+=(12+mbTexOrientation.u32DataSize); 499 } 500} 501 502/*!*********************************************************************** 503 @Function PVRTMapLegacyTextureEnumToNewFormat 504 @Input OldFormat Legacy Enumeration Value 505 @Modified newType New PixelType identifier. 506 @Modified newCSpace New ColourSpace 507 @Modified newChanType New Channel Type 508 @Modified isPreMult Whether format is pre-multiplied 509 @Description Maps a legacy enumeration value to the new PVR3 style format. 510*************************************************************************/ 511void PVRTMapLegacyTextureEnumToNewFormat(PVRTPixelType OldFormat, PVRTuint64& newType, EPVRTColourSpace& newCSpace, EPVRTVariableType& newChanType, bool& isPreMult) 512{ 513 //Default value. 514 isPreMult=false; 515 516 switch (OldFormat) 517 { 518 case MGLPT_ARGB_4444: 519 { 520 newType=PVRTGENPIXELID4('a','r','g','b',4,4,4,4); 521 newCSpace=ePVRTCSpacelRGB; 522 newChanType=ePVRTVarTypeUnsignedShortNorm; 523 break; 524 } 525 526 case MGLPT_ARGB_1555: 527 { 528 newType=PVRTGENPIXELID4('a','r','g','b',1,5,5,5); 529 newCSpace=ePVRTCSpacelRGB; 530 newChanType=ePVRTVarTypeUnsignedShortNorm; 531 break; 532 } 533 534 case MGLPT_RGB_565: 535 { 536 newType=PVRTGENPIXELID3('r','g','b',5,6,5); 537 newCSpace=ePVRTCSpacelRGB; 538 newChanType=ePVRTVarTypeUnsignedShortNorm; 539 break; 540 } 541 542 case MGLPT_RGB_555: 543 { 544 newType=PVRTGENPIXELID4('x','r','g','b',1,5,5,5); 545 newCSpace=ePVRTCSpacelRGB; 546 newChanType=ePVRTVarTypeUnsignedShortNorm; 547 break; 548 } 549 550 case MGLPT_RGB_888: 551 { 552 newType=PVRTGENPIXELID3('r','g','b',8,8,8); 553 newCSpace=ePVRTCSpacelRGB; 554 newChanType=ePVRTVarTypeUnsignedIntegerNorm; 555 break; 556 } 557 558 case MGLPT_ARGB_8888: 559 { 560 newType=PVRTGENPIXELID4('a','r','g','b',8,8,8,8); 561 newCSpace=ePVRTCSpacelRGB; 562 newChanType=ePVRTVarTypeUnsignedIntegerNorm; 563 break; 564 } 565 566 case MGLPT_ARGB_8332: 567 { 568 newType=PVRTGENPIXELID4('a','r','g','b',8,3,3,2); 569 newCSpace=ePVRTCSpacelRGB; 570 newChanType=ePVRTVarTypeUnsignedShortNorm; 571 break; 572 } 573 574 case MGLPT_I_8: 575 { 576 newType=PVRTGENPIXELID1('i',8); 577 newCSpace=ePVRTCSpacelRGB; 578 newChanType=ePVRTVarTypeUnsignedByteNorm; 579 break; 580 } 581 582 case MGLPT_AI_88: 583 { 584 newType=PVRTGENPIXELID2('a','i',8,8); 585 newCSpace=ePVRTCSpacelRGB; 586 newChanType=ePVRTVarTypeUnsignedShortNorm; 587 break; 588 } 589 590 case MGLPT_1_BPP: 591 { 592 newType=ePVRTPF_BW1bpp; 593 newCSpace=ePVRTCSpacelRGB; 594 newChanType=ePVRTVarTypeUnsignedByteNorm; 595 break; 596 } 597 598 case MGLPT_VY1UY0: 599 { 600 newType=ePVRTPF_YUY2; 601 newCSpace=ePVRTCSpacelRGB; 602 newChanType=ePVRTVarTypeUnsignedByteNorm; 603 break; 604 } 605 606 case MGLPT_Y1VY0U: 607 { 608 newType=ePVRTPF_UYVY; 609 newCSpace=ePVRTCSpacelRGB; 610 newChanType=ePVRTVarTypeUnsignedByteNorm; 611 break; 612 } 613 614 case MGLPT_PVRTC2: 615 { 616 newType=ePVRTPF_PVRTCI_2bpp_RGBA; 617 newCSpace=ePVRTCSpacelRGB; 618 newChanType=ePVRTVarTypeUnsignedByteNorm; 619 break; 620 } 621 622 case MGLPT_PVRTC4: 623 { 624 newType=ePVRTPF_PVRTCI_4bpp_RGBA; 625 newCSpace=ePVRTCSpacelRGB; 626 newChanType=ePVRTVarTypeUnsignedByteNorm; 627 break; 628 } 629 630 case OGL_RGBA_4444: 631 { 632 newType=PVRTGENPIXELID4('r','g','b','a',4,4,4,4); 633 newCSpace=ePVRTCSpacelRGB; 634 newChanType=ePVRTVarTypeUnsignedShortNorm; 635 break; 636 } 637 638 case OGL_RGBA_5551: 639 { 640 newType=PVRTGENPIXELID4('r','g','b','a',5,5,5,1); 641 newCSpace=ePVRTCSpacelRGB; 642 newChanType=ePVRTVarTypeUnsignedShortNorm; 643 break; 644 } 645 646 case OGL_RGBA_8888: 647 { 648 newType=PVRTGENPIXELID4('r','g','b','a',8,8,8,8); 649 newCSpace=ePVRTCSpacelRGB; 650 newChanType=ePVRTVarTypeUnsignedByteNorm; 651 break; 652 } 653 654 case OGL_RGB_565: 655 { 656 newType=PVRTGENPIXELID3('r','g','b',5,6,5); 657 newCSpace=ePVRTCSpacelRGB; 658 newChanType=ePVRTVarTypeUnsignedShortNorm; 659 break; 660 } 661 662 case OGL_RGB_555: 663 { 664 newType=PVRTGENPIXELID4('r','g','b','x',5,5,5,1); 665 newCSpace=ePVRTCSpacelRGB; 666 newChanType=ePVRTVarTypeUnsignedShortNorm; 667 break; 668 } 669 670 case OGL_RGB_888: 671 { 672 newType=PVRTGENPIXELID3('r','g','b',8,8,8); 673 newCSpace=ePVRTCSpacelRGB; 674 newChanType=ePVRTVarTypeUnsignedByteNorm; 675 break; 676 } 677 678 case OGL_I_8: 679 { 680 newType=PVRTGENPIXELID1('l',8); 681 newCSpace=ePVRTCSpacelRGB; 682 newChanType=ePVRTVarTypeUnsignedByteNorm; 683 break; 684 } 685 686 case OGL_AI_88: 687 { 688 newType=PVRTGENPIXELID2('l','a',8,8); 689 newCSpace=ePVRTCSpacelRGB; 690 newChanType=ePVRTVarTypeUnsignedByteNorm; 691 break; 692 } 693 694 case OGL_PVRTC2: 695 { 696 newType=ePVRTPF_PVRTCI_2bpp_RGBA; 697 newCSpace=ePVRTCSpacelRGB; 698 newChanType=ePVRTVarTypeUnsignedByteNorm; 699 break; 700 } 701 702 case OGL_PVRTC4: 703 { 704 newType=ePVRTPF_PVRTCI_4bpp_RGBA; 705 newCSpace=ePVRTCSpacelRGB; 706 newChanType=ePVRTVarTypeUnsignedByteNorm; 707 break; 708 } 709 710 case OGL_BGRA_8888: 711 { 712 newType=PVRTGENPIXELID4('b','g','r','a',8,8,8,8); 713 newCSpace=ePVRTCSpacelRGB; 714 newChanType=ePVRTVarTypeUnsignedByteNorm; 715 break; 716 } 717 718 case OGL_A_8: 719 { 720 newType=PVRTGENPIXELID1('a',8); 721 newCSpace=ePVRTCSpacelRGB; 722 newChanType=ePVRTVarTypeUnsignedByteNorm; 723 break; 724 } 725 726 case OGL_PVRTCII4: 727 { 728 newType=ePVRTPF_PVRTCII_4bpp; 729 newCSpace=ePVRTCSpacelRGB; 730 newChanType=ePVRTVarTypeUnsignedByteNorm; 731 break; 732 } 733 734 case OGL_PVRTCII2: 735 { 736 newType=ePVRTPF_PVRTCII_2bpp; 737 newCSpace=ePVRTCSpacelRGB; 738 newChanType=ePVRTVarTypeUnsignedByteNorm; 739 break; 740 } 741 742#ifdef _WIN32 743 case D3D_DXT1: 744 { 745 newType=ePVRTPF_DXT1; 746 newCSpace=ePVRTCSpacelRGB; 747 newChanType=ePVRTVarTypeUnsignedByteNorm; 748 break; 749 } 750 751 case D3D_DXT2: 752 { 753 newType=ePVRTPF_DXT2; 754 newCSpace=ePVRTCSpacelRGB; 755 newChanType=ePVRTVarTypeUnsignedByteNorm; 756 isPreMult=true; 757 break; 758 } 759 760 case D3D_DXT3: 761 { 762 newType=ePVRTPF_DXT3; 763 newCSpace=ePVRTCSpacelRGB; 764 newChanType=ePVRTVarTypeUnsignedByteNorm; 765 break; 766 } 767 768 case D3D_DXT4: 769 { 770 newType=ePVRTPF_DXT4; 771 newCSpace=ePVRTCSpacelRGB; 772 newChanType=ePVRTVarTypeUnsignedByteNorm; 773 isPreMult=true; 774 break; 775 } 776 777 case D3D_DXT5: 778 { 779 newType=ePVRTPF_DXT5; 780 newCSpace=ePVRTCSpacelRGB; 781 newChanType=ePVRTVarTypeUnsignedByteNorm; 782 break; 783 } 784 785#endif 786 case D3D_RGB_332: 787 { 788 newType=PVRTGENPIXELID3('r','g','b',3,3,2); 789 newCSpace=ePVRTCSpacelRGB; 790 newChanType=ePVRTVarTypeUnsignedIntegerNorm; 791 break; 792 } 793 794 case D3D_AL_44: 795 { 796 newType=PVRTGENPIXELID2('a','l',4,4); 797 newCSpace=ePVRTCSpacelRGB; 798 newChanType=ePVRTVarTypeUnsignedIntegerNorm; 799 break; 800 } 801 802 case D3D_LVU_655: 803 { 804 newType=PVRTGENPIXELID3('l','g','r',6,5,5); 805 newCSpace=ePVRTCSpacelRGB; 806 newChanType=ePVRTVarTypeSignedIntegerNorm; 807 break; 808 } 809 810 case D3D_XLVU_8888: 811 { 812 newType=PVRTGENPIXELID4('x','l','g','r',8,8,8,8); 813 newCSpace=ePVRTCSpacelRGB; 814 newChanType=ePVRTVarTypeSignedIntegerNorm; 815 break; 816 } 817 818 case D3D_QWVU_8888: 819 { 820 newType=PVRTGENPIXELID4('a','b','g','r',8,8,8,8); 821 newCSpace=ePVRTCSpacelRGB; 822 newChanType=ePVRTVarTypeSignedIntegerNorm; 823 break; 824 } 825 826 case D3D_ABGR_2101010: 827 { 828 newType=PVRTGENPIXELID4('a','b','g','r',2,10,10,10); 829 newCSpace=ePVRTCSpacelRGB; 830 newChanType=ePVRTVarTypeUnsignedIntegerNorm; 831 break; 832 } 833 834 case D3D_ARGB_2101010: 835 { 836 newType=PVRTGENPIXELID4('a','r','g','b',2,10,10,10); 837 newCSpace=ePVRTCSpacelRGB; 838 newChanType=ePVRTVarTypeUnsignedIntegerNorm; 839 break; 840 } 841 842 case D3D_AWVU_2101010: 843 { 844 newType=PVRTGENPIXELID4('a','r','g','b',2,10,10,10); 845 newCSpace=ePVRTCSpacelRGB; 846 newChanType=ePVRTVarTypeUnsignedIntegerNorm; 847 break; 848 } 849 850 case D3D_GR_1616: 851 { 852 newType=PVRTGENPIXELID2('g','r',16,16); 853 newCSpace=ePVRTCSpacelRGB; 854 newChanType=ePVRTVarTypeUnsignedIntegerNorm; 855 break; 856 } 857 858 case D3D_VU_1616: 859 { 860 newType=PVRTGENPIXELID2('g','r',16,16); 861 newCSpace=ePVRTCSpacelRGB; 862 newChanType=ePVRTVarTypeSignedIntegerNorm; 863 break; 864 } 865 866 case D3D_ABGR_16161616: 867 { 868 newType=PVRTGENPIXELID4('a','b','g','r',16,16,16,16); 869 newCSpace=ePVRTCSpacelRGB; 870 newChanType=ePVRTVarTypeUnsignedIntegerNorm; 871 break; 872 } 873 874 case D3D_R16F: 875 { 876 newType=PVRTGENPIXELID1('r',16); 877 newCSpace=ePVRTCSpacelRGB; 878 newChanType=ePVRTVarTypeSignedFloat; 879 break; 880 } 881 882 case D3D_GR_1616F: 883 { 884 newType=PVRTGENPIXELID2('g','r',16,16); 885 newCSpace=ePVRTCSpacelRGB; 886 newChanType=ePVRTVarTypeSignedFloat; 887 break; 888 } 889 890 case D3D_ABGR_16161616F: 891 { 892 newType=PVRTGENPIXELID4('a','b','g','r',16,16,16,16); 893 newCSpace=ePVRTCSpacelRGB; 894 newChanType=ePVRTVarTypeSignedFloat; 895 break; 896 } 897 898 case D3D_R32F: 899 { 900 newType=PVRTGENPIXELID1('r',32); 901 newCSpace=ePVRTCSpacelRGB; 902 newChanType=ePVRTVarTypeSignedFloat; 903 break; 904 } 905 906 case D3D_GR_3232F: 907 { 908 newType=PVRTGENPIXELID2('g','r',32,32); 909 newCSpace=ePVRTCSpacelRGB; 910 newChanType=ePVRTVarTypeSignedFloat; 911 break; 912 } 913 914 case D3D_ABGR_32323232F: 915 { 916 newType=PVRTGENPIXELID4('a','b','g','r',32,32,32,32); 917 newCSpace=ePVRTCSpacelRGB; 918 newChanType=ePVRTVarTypeSignedFloat; 919 break; 920 } 921 922 case ETC_RGB_4BPP: 923 { 924 newType=ePVRTPF_ETC1; 925 newCSpace=ePVRTCSpacelRGB; 926 newChanType=ePVRTVarTypeUnsignedByteNorm; 927 break; 928 } 929 930 case D3D_A8: 931 { 932 newType=PVRTGENPIXELID1('a',8); 933 newCSpace=ePVRTCSpacelRGB; 934 newChanType=ePVRTVarTypeUnsignedIntegerNorm; 935 break; 936 } 937 938 case D3D_V8U8: 939 { 940 newType=PVRTGENPIXELID2('g','r',8,8); 941 newCSpace=ePVRTCSpacelRGB; 942 newChanType=ePVRTVarTypeSignedIntegerNorm; 943 break; 944 } 945 946 case D3D_L16: 947 { 948 newType=PVRTGENPIXELID1('l',16); 949 newCSpace=ePVRTCSpacelRGB; 950 newChanType=ePVRTVarTypeUnsignedIntegerNorm; 951 break; 952 } 953 954 case D3D_L8: 955 { 956 newType=PVRTGENPIXELID1('l',8); 957 newCSpace=ePVRTCSpacelRGB; 958 newChanType=ePVRTVarTypeUnsignedIntegerNorm; 959 break; 960 } 961 962 case D3D_AL_88: 963 { 964 newType=PVRTGENPIXELID2('a','l',8,8); 965 newCSpace=ePVRTCSpacelRGB; 966 newChanType=ePVRTVarTypeUnsignedIntegerNorm; 967 break; 968 } 969 970 case D3D_UYVY: 971 { 972 newType=ePVRTPF_UYVY; 973 newCSpace=ePVRTCSpacelRGB; 974 newChanType=ePVRTVarTypeUnsignedByteNorm; 975 break; 976 } 977 978 case D3D_YUY2: 979 { 980 newType=ePVRTPF_YUY2; 981 newCSpace=ePVRTCSpacelRGB; 982 newChanType=ePVRTVarTypeUnsignedByteNorm; 983 break; 984 } 985 986 case DX10_R32G32B32A32_FLOAT: 987 { 988 newType=PVRTGENPIXELID4('r','g','b','a',32,32,32,32); 989 newCSpace=ePVRTCSpacelRGB; 990 newChanType=ePVRTVarTypeSignedFloat; 991 break; 992 } 993 994 case DX10_R32G32B32A32_UINT: 995 { 996 newType=PVRTGENPIXELID4('r','g','b','a',32,32,32,32); 997 newCSpace=ePVRTCSpacelRGB; 998 newChanType=ePVRTVarTypeUnsignedInteger; 999 break; 1000 } 1001 1002 case DX10_R32G32B32A32_SINT: 1003 { 1004 newType=PVRTGENPIXELID4('r','g','b','a',32,32,32,32); 1005 newCSpace=ePVRTCSpacelRGB; 1006 newChanType=ePVRTVarTypeSignedInteger; 1007 break; 1008 } 1009 1010 case DX10_R32G32B32_FLOAT: 1011 { 1012 newType=PVRTGENPIXELID3('r','g','b',32,32,32); 1013 newCSpace=ePVRTCSpacelRGB; 1014 newChanType=ePVRTVarTypeSignedFloat; 1015 break; 1016 } 1017 1018 case DX10_R32G32B32_UINT: 1019 { 1020 newType=PVRTGENPIXELID3('r','g','b',32,32,32); 1021 newCSpace=ePVRTCSpacelRGB; 1022 newChanType=ePVRTVarTypeUnsignedInteger; 1023 break; 1024 } 1025 1026 case DX10_R32G32B32_SINT: 1027 { 1028 newType=PVRTGENPIXELID3('r','g','b',32,32,32); 1029 newCSpace=ePVRTCSpacelRGB; 1030 newChanType=ePVRTVarTypeSignedInteger; 1031 break; 1032 } 1033 1034 case DX10_R16G16B16A16_FLOAT: 1035 { 1036 newType=PVRTGENPIXELID4('r','g','b','a',16,16,16,16); 1037 newCSpace=ePVRTCSpacelRGB; 1038 newChanType=ePVRTVarTypeSignedFloat; 1039 break; 1040 } 1041 1042 case DX10_R16G16B16A16_UNORM: 1043 { 1044 newType=PVRTGENPIXELID4('r','g','b','a',16,16,16,16); 1045 newCSpace=ePVRTCSpacelRGB; 1046 newChanType=ePVRTVarTypeUnsignedShortNorm; 1047 break; 1048 } 1049 1050 case DX10_R16G16B16A16_UINT: 1051 { 1052 newType=PVRTGENPIXELID4('r','g','b','a',16,16,16,16); 1053 newCSpace=ePVRTCSpacelRGB; 1054 newChanType=ePVRTVarTypeUnsignedShort; 1055 break; 1056 } 1057 1058 case DX10_R16G16B16A16_SNORM: 1059 { 1060 newType=PVRTGENPIXELID4('r','g','b','a',16,16,16,16); 1061 newCSpace=ePVRTCSpacelRGB; 1062 newChanType=ePVRTVarTypeSignedShortNorm; 1063 break; 1064 } 1065 1066 case DX10_R16G16B16A16_SINT: 1067 { 1068 newType=PVRTGENPIXELID4('r','g','b','a',16,16,16,16); 1069 newCSpace=ePVRTCSpacelRGB; 1070 newChanType=ePVRTVarTypeSignedShort; 1071 break; 1072 } 1073 1074 case DX10_R32G32_FLOAT: 1075 { 1076 newType=PVRTGENPIXELID2('r','g',32,32); 1077 newCSpace=ePVRTCSpacelRGB; 1078 newChanType=ePVRTVarTypeSignedFloat; 1079 break; 1080 } 1081 1082 case DX10_R32G32_UINT: 1083 { 1084 newType=PVRTGENPIXELID2('r','g',32,32); 1085 newCSpace=ePVRTCSpacelRGB; 1086 newChanType=ePVRTVarTypeUnsignedInteger; 1087 break; 1088 } 1089 1090 case DX10_R32G32_SINT: 1091 { 1092 newType=PVRTGENPIXELID2('r','g',32,32); 1093 newCSpace=ePVRTCSpacelRGB; 1094 newChanType=ePVRTVarTypeSignedInteger; 1095 break; 1096 } 1097 1098 case DX10_R10G10B10A2_UNORM: 1099 { 1100 newType=PVRTGENPIXELID4('r','g','b','a',10,10,10,2); 1101 newCSpace=ePVRTCSpacelRGB; 1102 newChanType=ePVRTVarTypeUnsignedIntegerNorm; 1103 break; 1104 } 1105 1106 case DX10_R10G10B10A2_UINT: 1107 { 1108 newType=PVRTGENPIXELID4('r','g','b','a',10,10,10,2); 1109 newCSpace=ePVRTCSpacelRGB; 1110 newChanType=ePVRTVarTypeUnsignedInteger; 1111 break; 1112 } 1113 1114 case DX10_R11G11B10_FLOAT: 1115 { 1116 newType=PVRTGENPIXELID3('r','g','b',11,11,10); 1117 newCSpace=ePVRTCSpacelRGB; 1118 newChanType=ePVRTVarTypeSignedFloat; 1119 break; 1120 } 1121 1122 case DX10_R8G8B8A8_UNORM: 1123 { 1124 newType=PVRTGENPIXELID4('r','g','b','a',8,8,8,8); 1125 newCSpace=ePVRTCSpacelRGB; 1126 newChanType=ePVRTVarTypeUnsignedByteNorm; 1127 break; 1128 } 1129 1130 case DX10_R8G8B8A8_UNORM_SRGB: 1131 { 1132 newType=PVRTGENPIXELID4('r','g','b','a',8,8,8,8); 1133 newCSpace=ePVRTCSpacesRGB; 1134 newChanType=ePVRTVarTypeUnsignedByteNorm; 1135 break; 1136 } 1137 1138 case DX10_R8G8B8A8_UINT: 1139 { 1140 newType=PVRTGENPIXELID4('r','g','b','a',8,8,8,8); 1141 newCSpace=ePVRTCSpacelRGB; 1142 newChanType=ePVRTVarTypeUnsignedByte; 1143 break; 1144 } 1145 1146 case DX10_R8G8B8A8_SNORM: 1147 { 1148 newType=PVRTGENPIXELID4('r','g','b','a',8,8,8,8); 1149 newCSpace=ePVRTCSpacelRGB; 1150 newChanType=ePVRTVarTypeSignedByteNorm; 1151 break; 1152 } 1153 1154 case DX10_R8G8B8A8_SINT: 1155 { 1156 newType=PVRTGENPIXELID4('r','g','b','a',8,8,8,8); 1157 newCSpace=ePVRTCSpacelRGB; 1158 newChanType=ePVRTVarTypeSignedByte; 1159 break; 1160 } 1161 1162 case DX10_R16G16_FLOAT: 1163 { 1164 newType=PVRTGENPIXELID2('r','g',16,16); 1165 newCSpace=ePVRTCSpacelRGB; 1166 newChanType=ePVRTVarTypeSignedFloat; 1167 break; 1168 } 1169 1170 case DX10_R16G16_UNORM: 1171 { 1172 newType=PVRTGENPIXELID2('r','g',16,16); 1173 newCSpace=ePVRTCSpacelRGB; 1174 newChanType=ePVRTVarTypeUnsignedShortNorm; 1175 break; 1176 } 1177 1178 case DX10_R16G16_UINT: 1179 { 1180 newType=PVRTGENPIXELID2('r','g',16,16); 1181 newCSpace=ePVRTCSpacelRGB; 1182 newChanType=ePVRTVarTypeUnsignedShort; 1183 break; 1184 } 1185 1186 case DX10_R16G16_SNORM: 1187 { 1188 newType=PVRTGENPIXELID2('r','g',16,16); 1189 newCSpace=ePVRTCSpacelRGB; 1190 newChanType=ePVRTVarTypeSignedShortNorm; 1191 break; 1192 } 1193 1194 case DX10_R16G16_SINT: 1195 { 1196 newType=PVRTGENPIXELID2('r','g',16,16); 1197 newCSpace=ePVRTCSpacelRGB; 1198 newChanType=ePVRTVarTypeSignedShort; 1199 break; 1200 } 1201 1202 case DX10_R32_FLOAT: 1203 { 1204 newType=PVRTGENPIXELID1('r',32); 1205 newCSpace=ePVRTCSpacelRGB; 1206 newChanType=ePVRTVarTypeSignedFloat; 1207 break; 1208 } 1209 1210 case DX10_R32_UINT: 1211 { 1212 newType=PVRTGENPIXELID1('r',32); 1213 newCSpace=ePVRTCSpacelRGB; 1214 newChanType=ePVRTVarTypeUnsignedInteger; 1215 break; 1216 } 1217 1218 case DX10_R32_SINT: 1219 { 1220 newType=PVRTGENPIXELID1('r',32); 1221 newCSpace=ePVRTCSpacelRGB; 1222 newChanType=ePVRTVarTypeSignedInteger; 1223 break; 1224 } 1225 1226 case DX10_R8G8_UNORM: 1227 { 1228 newType=PVRTGENPIXELID2('r','g',8,8); 1229 newCSpace=ePVRTCSpacelRGB; 1230 newChanType=ePVRTVarTypeUnsignedByteNorm; 1231 break; 1232 } 1233 1234 case DX10_R8G8_UINT: 1235 { 1236 newType=PVRTGENPIXELID2('r','g',8,8); 1237 newCSpace=ePVRTCSpacelRGB; 1238 newChanType=ePVRTVarTypeUnsignedByte; 1239 break; 1240 } 1241 1242 case DX10_R8G8_SNORM: 1243 { 1244 newType=PVRTGENPIXELID2('r','g',8,8); 1245 newCSpace=ePVRTCSpacelRGB; 1246 newChanType=ePVRTVarTypeSignedByteNorm; 1247 break; 1248 } 1249 1250 case DX10_R8G8_SINT: 1251 { 1252 newType=PVRTGENPIXELID2('r','g',8,8); 1253 newCSpace=ePVRTCSpacelRGB; 1254 newChanType=ePVRTVarTypeSignedByte; 1255 break; 1256 } 1257 1258 case DX10_R16_FLOAT: 1259 { 1260 newType=PVRTGENPIXELID1('r',16); 1261 newCSpace=ePVRTCSpacelRGB; 1262 newChanType=ePVRTVarTypeSignedFloat; 1263 break; 1264 } 1265 1266 case DX10_R16_UNORM: 1267 { 1268 newType=PVRTGENPIXELID1('r',16); 1269 newCSpace=ePVRTCSpacelRGB; 1270 newChanType=ePVRTVarTypeUnsignedShortNorm; 1271 break; 1272 } 1273 1274 case DX10_R16_UINT: 1275 { 1276 newType=PVRTGENPIXELID1('r',16); 1277 newCSpace=ePVRTCSpacelRGB; 1278 newChanType=ePVRTVarTypeUnsignedShort; 1279 break; 1280 } 1281 1282 case DX10_R16_SNORM: 1283 { 1284 newType=PVRTGENPIXELID1('r',16); 1285 newCSpace=ePVRTCSpacelRGB; 1286 newChanType=ePVRTVarTypeSignedShortNorm; 1287 break; 1288 } 1289 1290 case DX10_R16_SINT: 1291 { 1292 newType=PVRTGENPIXELID1('r',16); 1293 newCSpace=ePVRTCSpacelRGB; 1294 newChanType=ePVRTVarTypeSignedShort; 1295 break; 1296 } 1297 1298 case DX10_R8_UNORM: 1299 { 1300 newType=PVRTGENPIXELID1('r',8); 1301 newCSpace=ePVRTCSpacelRGB; 1302 newChanType=ePVRTVarTypeUnsignedByteNorm; 1303 break; 1304 } 1305 1306 case DX10_R8_UINT: 1307 { 1308 newType=PVRTGENPIXELID1('r',8); 1309 newCSpace=ePVRTCSpacelRGB; 1310 newChanType=ePVRTVarTypeUnsignedByte; 1311 break; 1312 } 1313 1314 case DX10_R8_SNORM: 1315 { 1316 newType=PVRTGENPIXELID1('r',8); 1317 newCSpace=ePVRTCSpacelRGB; 1318 newChanType=ePVRTVarTypeSignedByteNorm; 1319 break; 1320 } 1321 1322 case DX10_R8_SINT: 1323 { 1324 newType=PVRTGENPIXELID1('r',8); 1325 newCSpace=ePVRTCSpacelRGB; 1326 newChanType=ePVRTVarTypeSignedByte; 1327 break; 1328 } 1329 1330 case DX10_A8_UNORM: 1331 { 1332 newType=PVRTGENPIXELID1('r',8); 1333 newCSpace=ePVRTCSpacelRGB; 1334 newChanType=ePVRTVarTypeUnsignedByteNorm; 1335 break; 1336 } 1337 1338 case DX10_R1_UNORM: 1339 { 1340 newType=ePVRTPF_BW1bpp; 1341 newCSpace=ePVRTCSpacelRGB; 1342 newChanType=ePVRTVarTypeUnsignedByteNorm; 1343 break; 1344 } 1345 1346 case DX10_R9G9B9E5_SHAREDEXP: 1347 { 1348 newType=ePVRTPF_SharedExponentR9G9B9E5; 1349 newCSpace=ePVRTCSpacelRGB; 1350 newChanType=ePVRTVarTypeSignedFloat; 1351 break; 1352 } 1353 1354 case DX10_R8G8_B8G8_UNORM: 1355 { 1356 newType=ePVRTPF_RGBG8888; 1357 newCSpace=ePVRTCSpacelRGB; 1358 newChanType=ePVRTVarTypeUnsignedByteNorm; 1359 break; 1360 } 1361 1362 case DX10_G8R8_G8B8_UNORM: 1363 { 1364 newType=ePVRTPF_GRGB8888; 1365 newCSpace=ePVRTCSpacelRGB; 1366 newChanType=ePVRTVarTypeUnsignedByteNorm; 1367 break; 1368 } 1369 1370#ifdef _WIN32 1371 case DX10_BC1_UNORM: 1372 { 1373 newType=ePVRTPF_DXT1; 1374 newCSpace=ePVRTCSpacelRGB; 1375 newChanType=ePVRTVarTypeUnsignedIntegerNorm; 1376 break; 1377 } 1378 1379 case DX10_BC1_UNORM_SRGB: 1380 { 1381 newType=ePVRTPF_DXT1; 1382 newCSpace=ePVRTCSpacesRGB; 1383 newChanType=ePVRTVarTypeUnsignedIntegerNorm; 1384 break; 1385 } 1386 1387 case DX10_BC2_UNORM: 1388 { 1389 newType=ePVRTPF_DXT3; 1390 newCSpace=ePVRTCSpacelRGB; 1391 newChanType=ePVRTVarTypeUnsignedIntegerNorm; 1392 break; 1393 } 1394 1395 case DX10_BC2_UNORM_SRGB: 1396 { 1397 newType=ePVRTPF_DXT3; 1398 newCSpace=ePVRTCSpacesRGB; 1399 newChanType=ePVRTVarTypeUnsignedIntegerNorm; 1400 break; 1401 } 1402 1403 case DX10_BC3_UNORM: 1404 { 1405 newType=ePVRTPF_DXT5; 1406 newCSpace=ePVRTCSpacelRGB; 1407 newChanType=ePVRTVarTypeUnsignedIntegerNorm; 1408 break; 1409 } 1410 1411 case DX10_BC3_UNORM_SRGB: 1412 { 1413 newType=ePVRTPF_DXT5; 1414 newCSpace=ePVRTCSpacesRGB; 1415 newChanType=ePVRTVarTypeUnsignedIntegerNorm; 1416 break; 1417 } 1418 1419 case DX10_BC4_UNORM: 1420 { 1421 newType=ePVRTPF_BC4; 1422 newCSpace=ePVRTCSpacesRGB; 1423 newChanType=ePVRTVarTypeUnsignedIntegerNorm; 1424 break; 1425 } 1426 1427 case DX10_BC4_SNORM: 1428 { 1429 newType=ePVRTPF_BC4; 1430 newCSpace=ePVRTCSpacelRGB; 1431 newChanType=ePVRTVarTypeSignedIntegerNorm; 1432 break; 1433 } 1434 1435 case DX10_BC5_UNORM: 1436 { 1437 newType=ePVRTPF_BC5; 1438 newCSpace=ePVRTCSpacelRGB; 1439 newChanType=ePVRTVarTypeUnsignedIntegerNorm; 1440 break; 1441 } 1442 1443 case DX10_BC5_SNORM: 1444 { 1445 newType=ePVRTPF_BC5; 1446 newCSpace=ePVRTCSpacelRGB; 1447 newChanType=ePVRTVarTypeSignedIntegerNorm; 1448 break; 1449 } 1450 1451#endif 1452 case ePT_VG_sRGBX_8888: 1453 { 1454 newType=PVRTGENPIXELID4('r','g','b','x',8,8,8,8); 1455 newCSpace=ePVRTCSpacesRGB; 1456 newChanType=ePVRTVarTypeUnsignedByteNorm; 1457 break; 1458 } 1459 1460 case ePT_VG_sRGBA_8888: 1461 { 1462 newType=PVRTGENPIXELID4('r','g','b','a',8,8,8,8); 1463 newCSpace=ePVRTCSpacesRGB; 1464 newChanType=ePVRTVarTypeUnsignedByteNorm; 1465 break; 1466 } 1467 1468 case ePT_VG_sRGBA_8888_PRE: 1469 { 1470 newType=PVRTGENPIXELID4('r','g','b','a',8,8,8,8); 1471 newCSpace=ePVRTCSpacesRGB; 1472 newChanType=ePVRTVarTypeUnsignedByteNorm; 1473 isPreMult=true; 1474 break; 1475 } 1476 1477 case ePT_VG_sRGB_565: 1478 { 1479 newType=PVRTGENPIXELID3('r','g','b',5,6,5); 1480 newCSpace=ePVRTCSpacesRGB; 1481 newChanType=ePVRTVarTypeUnsignedShortNorm; 1482 break; 1483 } 1484 1485 case ePT_VG_sRGBA_5551: 1486 { 1487 newType=PVRTGENPIXELID4('r','g','b','a',5,5,5,1); 1488 newCSpace=ePVRTCSpacesRGB; 1489 newChanType=ePVRTVarTypeUnsignedShortNorm; 1490 break; 1491 } 1492 1493 case ePT_VG_sRGBA_4444: 1494 { 1495 newType=PVRTGENPIXELID4('r','g','b','a',4,4,4,4); 1496 newCSpace=ePVRTCSpacesRGB; 1497 newChanType=ePVRTVarTypeUnsignedShortNorm; 1498 break; 1499 } 1500 1501 case ePT_VG_sL_8: 1502 { 1503 newType=PVRTGENPIXELID1('l',8); 1504 newCSpace=ePVRTCSpacesRGB; 1505 newChanType=ePVRTVarTypeUnsignedByteNorm; 1506 break; 1507 } 1508 1509 case ePT_VG_lRGBX_8888: 1510 { 1511 newType=PVRTGENPIXELID4('r','g','b','x',8,8,8,8); 1512 newCSpace=ePVRTCSpacelRGB; 1513 newChanType=ePVRTVarTypeUnsignedByteNorm; 1514 break; 1515 } 1516 1517 case ePT_VG_lRGBA_8888: 1518 { 1519 newType=PVRTGENPIXELID4('r','g','b','a',8,8,8,8); 1520 newCSpace=ePVRTCSpacelRGB; 1521 newChanType=ePVRTVarTypeUnsignedByteNorm; 1522 break; 1523 } 1524 1525 case ePT_VG_lRGBA_8888_PRE: 1526 { 1527 newType=PVRTGENPIXELID4('r','g','b','a',8,8,8,8); 1528 newCSpace=ePVRTCSpacelRGB; 1529 newChanType=ePVRTVarTypeUnsignedByteNorm; 1530 isPreMult=true; 1531 break; 1532 } 1533 1534 case ePT_VG_lL_8: 1535 { 1536 newType=PVRTGENPIXELID1('l',8); 1537 newCSpace=ePVRTCSpacelRGB; 1538 newChanType=ePVRTVarTypeUnsignedByteNorm; 1539 break; 1540 } 1541 1542 case ePT_VG_A_8: 1543 { 1544 newType=PVRTGENPIXELID1('a',8); 1545 newCSpace=ePVRTCSpacelRGB; 1546 newChanType=ePVRTVarTypeUnsignedByteNorm; 1547 break; 1548 } 1549 1550 case ePT_VG_BW_1: 1551 { 1552 newType=ePVRTPF_BW1bpp; 1553 newCSpace=ePVRTCSpacelRGB; 1554 newChanType=ePVRTVarTypeUnsignedByteNorm; 1555 break; 1556 } 1557 1558 case ePT_VG_sXRGB_8888: 1559 { 1560 newType=PVRTGENPIXELID4('x','r','g','b',8,8,8,8); 1561 newCSpace=ePVRTCSpacesRGB; 1562 newChanType=ePVRTVarTypeUnsignedByteNorm; 1563 break; 1564 } 1565 1566 case ePT_VG_sARGB_8888: 1567 { 1568 newType=PVRTGENPIXELID4('a','r','g','b',8,8,8,8); 1569 newCSpace=ePVRTCSpacesRGB; 1570 newChanType=ePVRTVarTypeUnsignedByteNorm; 1571 break; 1572 } 1573 1574 case ePT_VG_sARGB_8888_PRE: 1575 { 1576 newType=PVRTGENPIXELID4('a','r','g','b',8,8,8,8); 1577 newCSpace=ePVRTCSpacesRGB; 1578 newChanType=ePVRTVarTypeUnsignedByteNorm; 1579 isPreMult=true; 1580 break; 1581 } 1582 1583 case ePT_VG_sARGB_1555: 1584 { 1585 newType=PVRTGENPIXELID4('a','r','g','b',1,5,5,5); 1586 newCSpace=ePVRTCSpacesRGB; 1587 newChanType=ePVRTVarTypeUnsignedShortNorm; 1588 break; 1589 } 1590 1591 case ePT_VG_sARGB_4444: 1592 { 1593 newType=PVRTGENPIXELID4('a','r','g','b',4,4,4,4); 1594 newCSpace=ePVRTCSpacesRGB; 1595 newChanType=ePVRTVarTypeUnsignedShortNorm; 1596 break; 1597 } 1598 1599 case ePT_VG_lXRGB_8888: 1600 { 1601 newType=PVRTGENPIXELID4('x','r','g','b',8,8,8,8); 1602 newCSpace=ePVRTCSpacelRGB; 1603 newChanType=ePVRTVarTypeUnsignedByteNorm; 1604 break; 1605 } 1606 1607 case ePT_VG_lARGB_8888: 1608 { 1609 newType=PVRTGENPIXELID4('a','r','g','b',8,8,8,8); 1610 newCSpace=ePVRTCSpacelRGB; 1611 newChanType=ePVRTVarTypeUnsignedByteNorm; 1612 break; 1613 } 1614 1615 case ePT_VG_lARGB_8888_PRE: 1616 { 1617 newType=PVRTGENPIXELID4('a','r','g','b',8,8,8,8); 1618 newCSpace=ePVRTCSpacelRGB; 1619 newChanType=ePVRTVarTypeUnsignedByteNorm; 1620 isPreMult=true; 1621 break; 1622 } 1623 1624 case ePT_VG_sBGRX_8888: 1625 { 1626 newType=PVRTGENPIXELID4('b','g','r','x',8,8,8,8); 1627 newCSpace=ePVRTCSpacesRGB; 1628 newChanType=ePVRTVarTypeUnsignedByteNorm; 1629 break; 1630 } 1631 1632 case ePT_VG_sBGRA_8888: 1633 { 1634 newType=PVRTGENPIXELID4('b','g','r','a',8,8,8,8); 1635 newCSpace=ePVRTCSpacesRGB; 1636 newChanType=ePVRTVarTypeUnsignedByteNorm; 1637 break; 1638 } 1639 1640 case ePT_VG_sBGRA_8888_PRE: 1641 { 1642 newType=PVRTGENPIXELID4('b','g','r','a',8,8,8,8); 1643 newCSpace=ePVRTCSpacesRGB; 1644 newChanType=ePVRTVarTypeUnsignedByteNorm; 1645 isPreMult=true; 1646 break; 1647 } 1648 1649 case ePT_VG_sBGR_565: 1650 { 1651 newType=PVRTGENPIXELID3('b','g','r',5,6,5); 1652 newCSpace=ePVRTCSpacesRGB; 1653 newChanType=ePVRTVarTypeUnsignedShortNorm; 1654 break; 1655 } 1656 1657 case ePT_VG_sBGRA_5551: 1658 { 1659 newType=PVRTGENPIXELID4('b','g','r','a',5,5,5,1); 1660 newCSpace=ePVRTCSpacesRGB; 1661 newChanType=ePVRTVarTypeUnsignedShortNorm; 1662 break; 1663 } 1664 1665 case ePT_VG_sBGRA_4444: 1666 { 1667 newType=PVRTGENPIXELID4('b','g','r','x',4,4,4,4); 1668 newCSpace=ePVRTCSpacesRGB; 1669 newChanType=ePVRTVarTypeUnsignedShortNorm; 1670 break; 1671 } 1672 1673 case ePT_VG_lBGRX_8888: 1674 { 1675 newType=PVRTGENPIXELID4('b','g','r','x',8,8,8,8); 1676 newCSpace=ePVRTCSpacelRGB; 1677 newChanType=ePVRTVarTypeUnsignedByteNorm; 1678 break; 1679 } 1680 1681 case ePT_VG_lBGRA_8888: 1682 { 1683 newType=PVRTGENPIXELID4('b','g','r','a',8,8,8,8); 1684 newCSpace=ePVRTCSpacelRGB; 1685 newChanType=ePVRTVarTypeUnsignedByteNorm; 1686 break; 1687 } 1688 1689 case ePT_VG_lBGRA_8888_PRE: 1690 { 1691 newType=PVRTGENPIXELID4('b','g','r','a',8,8,8,8); 1692 newCSpace=ePVRTCSpacelRGB; 1693 newChanType=ePVRTVarTypeUnsignedByteNorm; 1694 isPreMult=true; 1695 break; 1696 } 1697 1698 case ePT_VG_sXBGR_8888: 1699 { 1700 newType=PVRTGENPIXELID4('x','b','g','r',8,8,8,8); 1701 newCSpace=ePVRTCSpacesRGB; 1702 newChanType=ePVRTVarTypeUnsignedByteNorm; 1703 break; 1704 } 1705 1706 case ePT_VG_sABGR_8888: 1707 { 1708 newType=PVRTGENPIXELID4('a','b','g','r',8,8,8,8); 1709 newCSpace=ePVRTCSpacesRGB; 1710 newChanType=ePVRTVarTypeUnsignedByteNorm; 1711 break; 1712 } 1713 1714 case ePT_VG_sABGR_8888_PRE: 1715 { 1716 newType=PVRTGENPIXELID4('a','b','g','r',8,8,8,8); 1717 newCSpace=ePVRTCSpacesRGB; 1718 newChanType=ePVRTVarTypeUnsignedByteNorm; 1719 isPreMult=true; 1720 break; 1721 } 1722 1723 case ePT_VG_sABGR_1555: 1724 { 1725 newType=PVRTGENPIXELID4('a','b','g','r',1,5,5,5); 1726 newCSpace=ePVRTCSpacesRGB; 1727 newChanType=ePVRTVarTypeUnsignedShortNorm; 1728 break; 1729 } 1730 1731 case ePT_VG_sABGR_4444: 1732 { 1733 newType=PVRTGENPIXELID4('x','b','g','r',4,4,4,4); 1734 newCSpace=ePVRTCSpacesRGB; 1735 newChanType=ePVRTVarTypeUnsignedShortNorm; 1736 break; 1737 } 1738 1739 case ePT_VG_lXBGR_8888: 1740 { 1741 newType=PVRTGENPIXELID4('x','b','g','r',8,8,8,8); 1742 newCSpace=ePVRTCSpacelRGB; 1743 newChanType=ePVRTVarTypeUnsignedByteNorm; 1744 break; 1745 } 1746 1747 case ePT_VG_lABGR_8888: 1748 { 1749 newType=PVRTGENPIXELID4('a','b','g','r',8,8,8,8); 1750 newCSpace=ePVRTCSpacelRGB; 1751 newChanType=ePVRTVarTypeUnsignedByteNorm; 1752 break; 1753 } 1754 1755 case ePT_VG_lABGR_8888_PRE: 1756 { 1757 newType=PVRTGENPIXELID4('a','b','g','r',8,8,8,8); 1758 newCSpace=ePVRTCSpacelRGB; 1759 newChanType=ePVRTVarTypeUnsignedByteNorm; 1760 isPreMult=true; 1761 break; 1762 } 1763 default: 1764 { 1765 newType=ePVRTPF_NumCompressedPFs; 1766 newCSpace=ePVRTCSpacelRGB; 1767 newChanType=ePVRTVarTypeNumVarTypes; 1768 break; 1769 } 1770 } 1771} 1772 1773/***************************************************************************** 1774 End of file (PVRTTexture.cpp) 1775*****************************************************************************/ 1776