AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Generate a table of config->glformat info. Precursor to lifting this to caps.

Browse Source 
GOLD_TRYBOT_URL= https://gold.skia.org/search2?unt=true&query=source_type%3Dgm&master=false&issue=1527383003

Review URL: https://codereview.chromium.org/1527383003
This commit is contained in:
bsalomon 2015-12-16 11:51:22 -08:00 committed by Commit bot
parent 78e0aef610
commit 54c6fe8519
4 changed files with 228 additions and 229 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

56
src/gpu/gl/GrGLDefines.h
View File

@ -285,35 +285,35 @@
#define GR_GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT 0x8E8E
#define GR_GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT 0x8E8F
#define GR_GL_COMPRESSED_RGBA_ASTC_4x4_KHR 0x93B0
#define GR_GL_COMPRESSED_RGBA_ASTC_5x4_KHR 0x93B1
#define GR_GL_COMPRESSED_RGBA_ASTC_5x5_KHR 0x93B2
#define GR_GL_COMPRESSED_RGBA_ASTC_6x5_KHR 0x93B3
#define GR_GL_COMPRESSED_RGBA_ASTC_6x6_KHR 0x93B4
#define GR_GL_COMPRESSED_RGBA_ASTC_8x5_KHR 0x93B5
#define GR_GL_COMPRESSED_RGBA_ASTC_8x6_KHR 0x93B6
#define GR_GL_COMPRESSED_RGBA_ASTC_8x8_KHR 0x93B7
#define GR_GL_COMPRESSED_RGBA_ASTC_10x5_KHR 0x93B8
#define GR_GL_COMPRESSED_RGBA_ASTC_10x6_KHR 0x93B9
#define GR_GL_COMPRESSED_RGBA_ASTC_10x8_KHR 0x93BA
#define GR_GL_COMPRESSED_RGBA_ASTC_10x10_KHR 0x93BB
#define GR_GL_COMPRESSED_RGBA_ASTC_12x10_KHR 0x93BC
#define GR_GL_COMPRESSED_RGBA_ASTC_12x12_KHR 0x93BD
#define GR_GL_COMPRESSED_RGBA_ASTC_4x4 0x93B0
#define GR_GL_COMPRESSED_RGBA_ASTC_5x4 0x93B1
#define GR_GL_COMPRESSED_RGBA_ASTC_5x5 0x93B2
#define GR_GL_COMPRESSED_RGBA_ASTC_6x5 0x93B3
#define GR_GL_COMPRESSED_RGBA_ASTC_6x6 0x93B4
#define GR_GL_COMPRESSED_RGBA_ASTC_8x5 0x93B5
#define GR_GL_COMPRESSED_RGBA_ASTC_8x6 0x93B6
#define GR_GL_COMPRESSED_RGBA_ASTC_8x8 0x93B7
#define GR_GL_COMPRESSED_RGBA_ASTC_10x5 0x93B8
#define GR_GL_COMPRESSED_RGBA_ASTC_10x6 0x93B9
#define GR_GL_COMPRESSED_RGBA_ASTC_10x8 0x93BA
#define GR_GL_COMPRESSED_RGBA_ASTC_10x10 0x93BB
#define GR_GL_COMPRESSED_RGBA_ASTC_12x10 0x93BC
#define GR_GL_COMPRESSED_RGBA_ASTC_12x12 0x93BD
#define GR_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR 0x93D0
#define GR_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR 0x93D1
#define GR_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR 0x93D2
#define GR_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR 0x93D3
#define GR_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR 0x93D4
#define GR_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR 0x93D5
#define GR_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR 0x93D6
#define GR_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR 0x93D7
#define GR_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR 0x93D8
#define GR_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR 0x93D9
#define GR_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR 0x93DA
#define GR_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR 0x93DB
#define GR_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR 0x93DC
#define GR_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR 0x93DD
#define GR_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4 0x93D0
#define GR_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4 0x93D1
#define GR_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5 0x93D2
#define GR_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5 0x93D3
#define GR_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6 0x93D4
#define GR_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5 0x93D5
#define GR_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6 0x93D6
#define GR_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8 0x93D7
#define GR_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5 0x93D8
#define GR_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6 0x93D9
#define GR_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8 0x93DA
#define GR_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10 0x93DB
#define GR_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10 0x93DC
#define GR_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12 0x93DD
/* HintMode */
#define GR_GL_DONT_CARE 0x1100

338
src/gpu/gl/GrGLGpu.cpp
View File

@ -195,6 +195,7 @@ GrGLGpu::GrGLGpu(GrGLContext* ctx, GrContext* context)
, fGLContext(ctx) {
SkASSERT(ctx);
fCaps.reset(SkRef(ctx->caps()));
this->generateConfigTable();
fHWBoundTextureUniqueIDs.reset(this->glCaps().maxFragmentTextureUnits());
@ -2683,191 +2684,178 @@ void GrGLGpu::flushDrawFace(GrPipelineBuilder::DrawFace face) {
}
}
void GrGLGpu::generateConfigTable() {
fConfigTable[kUnknown_GrPixelConfig].fBaseInternalFormat = 0;
fConfigTable[kUnknown_GrPixelConfig].fSizedInternalFormat = 0;
fConfigTable[kUnknown_GrPixelConfig].fExternalFormat = 0;
fConfigTable[kUnknown_GrPixelConfig].fExternalType = 0;
fConfigTable[kRGBA_8888_GrPixelConfig].fBaseInternalFormat = GR_GL_RGBA;
fConfigTable[kRGBA_8888_GrPixelConfig].fSizedInternalFormat = GR_GL_RGBA8;
fConfigTable[kRGBA_8888_GrPixelConfig].fExternalFormat = GR_GL_RGBA;
fConfigTable[kRGBA_8888_GrPixelConfig].fExternalType = GR_GL_UNSIGNED_BYTE;
if (this->glCaps().bgraIsInternalFormat()) {
fConfigTable[kBGRA_8888_GrPixelConfig].fBaseInternalFormat = GR_GL_BGRA;
fConfigTable[kBGRA_8888_GrPixelConfig].fSizedInternalFormat = GR_GL_BGRA8;
} else {
fConfigTable[kBGRA_8888_GrPixelConfig].fBaseInternalFormat = GR_GL_RGBA;
fConfigTable[kBGRA_8888_GrPixelConfig].fSizedInternalFormat = GR_GL_RGBA8;
}
fConfigTable[kBGRA_8888_GrPixelConfig].fExternalFormat= GR_GL_BGRA;
fConfigTable[kBGRA_8888_GrPixelConfig].fExternalType = GR_GL_UNSIGNED_BYTE;
fConfigTable[kSRGBA_8888_GrPixelConfig].fBaseInternalFormat = GR_GL_SRGB_ALPHA;
fConfigTable[kSRGBA_8888_GrPixelConfig].fSizedInternalFormat = GR_GL_SRGB8_ALPHA8;
// OpenGL ES 2.0 + GL_EXT_sRGB allows GL_SRGB_ALPHA to be specified as the <format>
// param to Tex(Sub)Image2D. ES 2.0 requires the internalFormat and format to match.
// Thus, on ES 2.0 we will use GL_SRGB_ALPHA as the externalFormat. However,
// onReadPixels needs code to override that because GL_SRGB_ALPHA is not allowed as a
// glReadPixels format.
// On OpenGL and ES 3.0 GL_SRGB_ALPHA does not work for the <format> param to
// glReadPixels nor does it work with Tex(Sub)Image2D So we always set the externalFormat
// return to GL_RGBA.
if (this->glStandard() == kGLES_GrGLStandard &&
this->glVersion() == GR_GL_VER(2,0)) {
fConfigTable[kSRGBA_8888_GrPixelConfig].fExternalFormat = GR_GL_SRGB_ALPHA;
} else {
fConfigTable[kSRGBA_8888_GrPixelConfig].fExternalFormat = GR_GL_RGBA;
}
fConfigTable[kSRGBA_8888_GrPixelConfig].fExternalType = GR_GL_UNSIGNED_BYTE;
fConfigTable[kRGB_565_GrPixelConfig].fBaseInternalFormat = GR_GL_RGB;
if (this->glCaps().ES2CompatibilitySupport()) {
fConfigTable[kRGB_565_GrPixelConfig].fSizedInternalFormat = GR_GL_RGB565;
} else {
fConfigTable[kRGB_565_GrPixelConfig].fSizedInternalFormat = GR_GL_RGB5;
}
fConfigTable[kRGB_565_GrPixelConfig].fExternalFormat = GR_GL_RGB;
fConfigTable[kRGB_565_GrPixelConfig].fExternalType = GR_GL_UNSIGNED_SHORT_5_6_5;
fConfigTable[kRGBA_4444_GrPixelConfig].fBaseInternalFormat = GR_GL_RGBA;
fConfigTable[kRGBA_4444_GrPixelConfig].fSizedInternalFormat = GR_GL_RGBA4;
fConfigTable[kRGBA_4444_GrPixelConfig].fExternalFormat = GR_GL_RGBA;
fConfigTable[kRGBA_4444_GrPixelConfig].fExternalType = GR_GL_UNSIGNED_SHORT_4_4_4_4;
if (this->glCaps().textureRedSupport()) {
fConfigTable[kAlpha_8_GrPixelConfig].fBaseInternalFormat = GR_GL_RED;
fConfigTable[kAlpha_8_GrPixelConfig].fSizedInternalFormat = GR_GL_R8;
fConfigTable[kAlpha_8_GrPixelConfig].fExternalFormat = GR_GL_RED;
} else {
fConfigTable[kAlpha_8_GrPixelConfig].fBaseInternalFormat = GR_GL_ALPHA;
fConfigTable[kAlpha_8_GrPixelConfig].fSizedInternalFormat = GR_GL_ALPHA8;
fConfigTable[kAlpha_8_GrPixelConfig].fExternalFormat = GR_GL_ALPHA;
}
fConfigTable[kAlpha_8_GrPixelConfig].fExternalType = GR_GL_UNSIGNED_BYTE;
fConfigTable[kRGBA_float_GrPixelConfig].fBaseInternalFormat = GR_GL_RGBA;
fConfigTable[kRGBA_float_GrPixelConfig].fSizedInternalFormat = GR_GL_RGBA32F;
fConfigTable[kRGBA_float_GrPixelConfig].fExternalFormat = GR_GL_RGBA;
fConfigTable[kRGBA_float_GrPixelConfig].fExternalType = GR_GL_FLOAT;
if (this->glCaps().textureRedSupport()) {
fConfigTable[kAlpha_half_GrPixelConfig].fBaseInternalFormat = GR_GL_RED;
fConfigTable[kAlpha_half_GrPixelConfig].fSizedInternalFormat = GR_GL_R16F;
fConfigTable[kAlpha_half_GrPixelConfig].fExternalFormat = GR_GL_RED;
} else {
fConfigTable[kAlpha_half_GrPixelConfig].fBaseInternalFormat = GR_GL_ALPHA;
fConfigTable[kAlpha_half_GrPixelConfig].fSizedInternalFormat = GR_GL_ALPHA16F;
fConfigTable[kAlpha_half_GrPixelConfig].fExternalFormat = GR_GL_ALPHA;
}
if (kGL_GrGLStandard == this->glStandard() || this->glVersion() >= GR_GL_VER(3, 0)) {
fConfigTable[kAlpha_half_GrPixelConfig].fExternalType = GR_GL_HALF_FLOAT;
} else {
fConfigTable[kAlpha_half_GrPixelConfig].fExternalType = GR_GL_HALF_FLOAT_OES;
}
fConfigTable[kRGBA_half_GrPixelConfig].fBaseInternalFormat = GR_GL_RGBA;
fConfigTable[kRGBA_half_GrPixelConfig].fSizedInternalFormat = GR_GL_RGBA16F;
fConfigTable[kRGBA_half_GrPixelConfig].fExternalFormat = GR_GL_RGBA;
if (kGL_GrGLStandard == this->glStandard() || this->glVersion() >= GR_GL_VER(3, 0)) {
fConfigTable[kRGBA_half_GrPixelConfig].fExternalType = GR_GL_HALF_FLOAT;
} else {
fConfigTable[kRGBA_half_GrPixelConfig].fExternalType = GR_GL_HALF_FLOAT_OES;
}
// No sized/unsized internal format distinction for compressed formats, no external format.
fConfigTable[kIndex_8_GrPixelConfig].fBaseInternalFormat = GR_GL_PALETTE8_RGBA8;
fConfigTable[kIndex_8_GrPixelConfig].fSizedInternalFormat = GR_GL_PALETTE8_RGBA8;
fConfigTable[kIndex_8_GrPixelConfig].fExternalFormat = 0;
fConfigTable[kIndex_8_GrPixelConfig].fExternalType = 0;
switch(this->glCaps().latcAlias()) {
case GrGLCaps::kLATC_LATCAlias:
fConfigTable[kLATC_GrPixelConfig].fBaseInternalFormat =
GR_GL_COMPRESSED_LUMINANCE_LATC1;
fConfigTable[kLATC_GrPixelConfig].fSizedInternalFormat =
GR_GL_COMPRESSED_LUMINANCE_LATC1;
break;
case GrGLCaps::kRGTC_LATCAlias:
fConfigTable[kLATC_GrPixelConfig].fBaseInternalFormat = GR_GL_COMPRESSED_RED_RGTC1;
fConfigTable[kLATC_GrPixelConfig].fSizedInternalFormat = GR_GL_COMPRESSED_RED_RGTC1;
break;
case GrGLCaps::k3DC_LATCAlias:
fConfigTable[kLATC_GrPixelConfig].fBaseInternalFormat = GR_GL_COMPRESSED_3DC_X;
fConfigTable[kLATC_GrPixelConfig].fSizedInternalFormat = GR_GL_COMPRESSED_3DC_X;
break;
}
fConfigTable[kLATC_GrPixelConfig].fExternalFormat = 0;
fConfigTable[kLATC_GrPixelConfig].fExternalType = 0;
fConfigTable[kETC1_GrPixelConfig].fBaseInternalFormat = GR_GL_COMPRESSED_ETC1_RGB8;
fConfigTable[kETC1_GrPixelConfig].fSizedInternalFormat = GR_GL_COMPRESSED_ETC1_RGB8;
fConfigTable[kETC1_GrPixelConfig].fExternalFormat = 0;
fConfigTable[kETC1_GrPixelConfig].fExternalType = 0;
fConfigTable[kR11_EAC_GrPixelConfig].fBaseInternalFormat = GR_GL_COMPRESSED_R11_EAC;
fConfigTable[kR11_EAC_GrPixelConfig].fSizedInternalFormat = GR_GL_COMPRESSED_R11_EAC;
fConfigTable[kR11_EAC_GrPixelConfig].fExternalFormat = 0;
fConfigTable[kR11_EAC_GrPixelConfig].fExternalType = 0;
fConfigTable[kASTC_12x12_GrPixelConfig].fBaseInternalFormat = GR_GL_COMPRESSED_RGBA_ASTC_12x12;
fConfigTable[kASTC_12x12_GrPixelConfig].fSizedInternalFormat = GR_GL_COMPRESSED_RGBA_ASTC_12x12;
fConfigTable[kASTC_12x12_GrPixelConfig].fExternalFormat = 0;
fConfigTable[kASTC_12x12_GrPixelConfig].fExternalType = 0;
#ifdef SK_DEBUG
// Make sure we initialized everything.
ConfigEntry defaultEntry;
for (int i = 0; i < kLast_GrPixelConfig; ++i) {
SkASSERT(defaultEntry.fBaseInternalFormat != fConfigTable[i].fBaseInternalFormat);
SkASSERT(defaultEntry.fSizedInternalFormat != fConfigTable[i].fSizedInternalFormat);
SkASSERT(defaultEntry.fExternalFormat != fConfigTable[i].fExternalFormat);
SkASSERT(defaultEntry.fExternalType != fConfigTable[i].fExternalType);
}
#endif
}
bool GrGLGpu::configToGLFormats(GrPixelConfig config,
bool getSizedInternalFormat,
GrGLenum* internalFormat,
GrGLenum* externalFormat,
GrGLenum* externalType) const {
GrGLenum dontCare;
if (nullptr == internalFormat) {
internalFormat = &dontCare;
}
if (nullptr == externalFormat) {
externalFormat = &dontCare;
}
if (nullptr == externalType) {
externalType = &dontCare;
}
if(!this->glCaps().isConfigTexturable(config)) {
return false;
}
switch (config) {
case kRGBA_8888_GrPixelConfig:
*internalFormat = GR_GL_RGBA;
*externalFormat = GR_GL_RGBA;
if (getSizedInternalFormat) {
*internalFormat = GR_GL_RGBA8;
} else {
*internalFormat = GR_GL_RGBA;
}
*externalType = GR_GL_UNSIGNED_BYTE;
break;
case kBGRA_8888_GrPixelConfig:
if (this->glCaps().bgraIsInternalFormat()) {
if (getSizedInternalFormat) {
*internalFormat = GR_GL_BGRA8;
} else {
*internalFormat = GR_GL_BGRA;
}
} else {
if (getSizedInternalFormat) {
*internalFormat = GR_GL_RGBA8;
} else {
*internalFormat = GR_GL_RGBA;
}
}
*externalFormat = GR_GL_BGRA;
*externalType = GR_GL_UNSIGNED_BYTE;
break;
case kSRGBA_8888_GrPixelConfig:
if (getSizedInternalFormat) {
*internalFormat = GR_GL_SRGB8_ALPHA8;
} else {
*internalFormat = GR_GL_SRGB_ALPHA;
}
// OpenGL ES 2.0 + GL_EXT_sRGB allows GL_SRGB_ALPHA to be specified as the <format>
// param to Tex(Sub)Image2D. ES 2.0 requires the internalFormat and format to match.
// Thus, on ES 2.0 we will use GL_SRGB_ALPHA as the externalFormat. However,
// onReadPixels needs code to override that because GL_SRGB_ALPHA is not allowed as a
// glReadPixels format.
// On OpenGL and ES 3.0 GL_SRGB_ALPHA does not work for the <format> param to
// glReadPixels nor does it work with Tex(Sub)Image2D So we always set the externalFormat
// return to GL_RGBA.
if (this->glStandard() == kGLES_GrGLStandard &&
this->glVersion() == GR_GL_VER(2,0)) {
*externalFormat = GR_GL_SRGB_ALPHA;
} else {
*externalFormat = GR_GL_RGBA;
}
*externalType = GR_GL_UNSIGNED_BYTE;
break;
case kRGB_565_GrPixelConfig:
*internalFormat = GR_GL_RGB;
*externalFormat = GR_GL_RGB;
if (getSizedInternalFormat) {
if (!this->glCaps().ES2CompatibilitySupport()) {
*internalFormat = GR_GL_RGB5;
} else {
*internalFormat = GR_GL_RGB565;
}
} else {
*internalFormat = GR_GL_RGB;
}
*externalType = GR_GL_UNSIGNED_SHORT_5_6_5;
break;
case kRGBA_4444_GrPixelConfig:
*internalFormat = GR_GL_RGBA;
*externalFormat = GR_GL_RGBA;
if (getSizedInternalFormat) {
*internalFormat = GR_GL_RGBA4;
} else {
*internalFormat = GR_GL_RGBA;
}
*externalType = GR_GL_UNSIGNED_SHORT_4_4_4_4;
break;
case kIndex_8_GrPixelConfig:
// no sized/unsized internal format distinction here
*internalFormat = GR_GL_PALETTE8_RGBA8;
break;
case kAlpha_8_GrPixelConfig:
if (this->glCaps().textureRedSupport()) {
*internalFormat = GR_GL_RED;
*externalFormat = GR_GL_RED;
if (getSizedInternalFormat) {
*internalFormat = GR_GL_R8;
} else {
*internalFormat = GR_GL_RED;
}
*externalType = GR_GL_UNSIGNED_BYTE;
} else {
*internalFormat = GR_GL_ALPHA;
*externalFormat = GR_GL_ALPHA;
if (getSizedInternalFormat) {
*internalFormat = GR_GL_ALPHA8;
} else {
*internalFormat = GR_GL_ALPHA;
}
*externalType = GR_GL_UNSIGNED_BYTE;
}
break;
case kETC1_GrPixelConfig:
*internalFormat = GR_GL_COMPRESSED_ETC1_RGB8;
break;
case kLATC_GrPixelConfig:
switch(this->glCaps().latcAlias()) {
case GrGLCaps::kLATC_LATCAlias:
*internalFormat = GR_GL_COMPRESSED_LUMINANCE_LATC1;
break;
case GrGLCaps::kRGTC_LATCAlias:
*internalFormat = GR_GL_COMPRESSED_RED_RGTC1;
break;
case GrGLCaps::k3DC_LATCAlias:
*internalFormat = GR_GL_COMPRESSED_3DC_X;
break;
}
break;
case kR11_EAC_GrPixelConfig:
*internalFormat = GR_GL_COMPRESSED_R11_EAC;
break;
case kASTC_12x12_GrPixelConfig:
*internalFormat = GR_GL_COMPRESSED_RGBA_ASTC_12x12_KHR;
break;
case kRGBA_float_GrPixelConfig:
*internalFormat = GR_GL_RGBA32F;
*externalFormat = GR_GL_RGBA;
*externalType = GR_GL_FLOAT;
break;
case kAlpha_half_GrPixelConfig:
if (this->glCaps().textureRedSupport()) {
if (getSizedInternalFormat) {
*internalFormat = GR_GL_R16F;
} else {
*internalFormat = GR_GL_RED;
}
*externalFormat = GR_GL_RED;
} else {
if (getSizedInternalFormat) {
*internalFormat = GR_GL_ALPHA16F;
} else {
*internalFormat = GR_GL_ALPHA;
}
*externalFormat = GR_GL_ALPHA;
}
if (kGL_GrGLStandard == this->glStandard() || this->glVersion() >= GR_GL_VER(3, 0)) {
*externalType = GR_GL_HALF_FLOAT;
} else {
*externalType = GR_GL_HALF_FLOAT_OES;
}
break;
case kRGBA_half_GrPixelConfig:
*internalFormat = GR_GL_RGBA16F;
*externalFormat = GR_GL_RGBA;
if (kGL_GrGLStandard == this->glStandard() || this->glVersion() >= GR_GL_VER(3, 0)) {
*externalType = GR_GL_HALF_FLOAT;
} else {
*externalType = GR_GL_HALF_FLOAT_OES;
}
break;
default:
return false;
if (nullptr != internalFormat) {
if (getSizedInternalFormat) {
*internalFormat = fConfigTable[config].fSizedInternalFormat;
} else {
*internalFormat = fConfigTable[config].fBaseInternalFormat;
}
}
if (nullptr != externalFormat) {
*externalFormat = fConfigTable[config].fExternalFormat;
}
if (nullptr != externalType) {
*externalType = fConfigTable[config].fExternalType;
}
return true;
}

35
src/gpu/gl/GrGLGpu.h
View File

@ -283,6 +283,7 @@ private:
void flushStencil(const GrStencilSettings&);
void flushHWAAState(GrRenderTarget* rt, bool useHWAA);
void generateConfigTable();
bool configToGLFormats(GrPixelConfig config,
bool getSizedInternal,
GrGLenum* internalFormat,
@ -500,6 +501,19 @@ private:
}
} fHWBlendState;
TriState fMSAAEnabled;
GrStencilSettings fHWStencilSettings;
TriState fHWStencilTestEnabled;
GrPipelineBuilder::DrawFace fHWDrawFace;
TriState fHWWriteToColor;
uint32_t fHWBoundRenderTargetUniqueID;
TriState fHWSRGBFramebuffer;
SkTArray<uint32_t, true> fHWBoundTextureUniqueIDs;
///@}
/** IDs for copy surface program. */
struct {
GrGLuint fProgram;
@ -525,19 +539,16 @@ private:
}
}
TriState fMSAAEnabled;
struct ConfigEntry {
// Default constructor inits to known bad GL enum values.
ConfigEntry() { memset(this, 0xAB, sizeof(ConfigEntry)); }
GrGLenum fBaseInternalFormat;
GrGLenum fSizedInternalFormat;
GrGLenum fExternalFormat;
GrGLenum fExternalType;
};
GrStencilSettings fHWStencilSettings;
TriState fHWStencilTestEnabled;
GrPipelineBuilder::DrawFace fHWDrawFace;
TriState fHWWriteToColor;
uint32_t fHWBoundRenderTargetUniqueID;
TriState fHWSRGBFramebuffer;
SkTArray<uint32_t, true> fHWBoundTextureUniqueIDs;
///@}
ConfigEntry fConfigTable[kLast_GrPixelConfig + 1];
// Mapping of pixel configs to known supported stencil formats to be used
// when adding a stencil buffer to a framebuffer.

28
third_party/ktx/ktx.cpp vendored
View File

@ -21,20 +21,20 @@ static inline uint32_t compressed_fmt_to_gl_define(SkTextureCompressor::Format f
GR_GL_COMPRESSED_LUMINANCE_LATC1, // kLATC_Format
GR_GL_COMPRESSED_R11_EAC, // kR11_EAC_Format
GR_GL_COMPRESSED_ETC1_RGB8, // kETC1_Format
GR_GL_COMPRESSED_RGBA_ASTC_4x4_KHR, // kASTC_4x4_Format
GR_GL_COMPRESSED_RGBA_ASTC_5x4_KHR, // kASTC_5x4_Format
GR_GL_COMPRESSED_RGBA_ASTC_5x5_KHR, // kASTC_5x5_Format
GR_GL_COMPRESSED_RGBA_ASTC_6x5_KHR, // kASTC_6x5_Format
GR_GL_COMPRESSED_RGBA_ASTC_6x6_KHR, // kASTC_6x6_Format
GR_GL_COMPRESSED_RGBA_ASTC_8x5_KHR, // kASTC_8x5_Format
GR_GL_COMPRESSED_RGBA_ASTC_8x6_KHR, // kASTC_8x6_Format
GR_GL_COMPRESSED_RGBA_ASTC_8x8_KHR, // kASTC_8x8_Format
GR_GL_COMPRESSED_RGBA_ASTC_10x5_KHR, // kASTC_10x5_Format
GR_GL_COMPRESSED_RGBA_ASTC_10x6_KHR, // kASTC_10x6_Format
GR_GL_COMPRESSED_RGBA_ASTC_10x8_KHR, // kASTC_10x8_Format
GR_GL_COMPRESSED_RGBA_ASTC_10x10_KHR, // kASTC_10x10_Format
GR_GL_COMPRESSED_RGBA_ASTC_12x10_KHR, // kASTC_12x10_Format
GR_GL_COMPRESSED_RGBA_ASTC_12x12_KHR, // kASTC_12x12_Format
GR_GL_COMPRESSED_RGBA_ASTC_4x4, // kASTC_4x4_Format
GR_GL_COMPRESSED_RGBA_ASTC_5x4, // kASTC_5x4_Format
GR_GL_COMPRESSED_RGBA_ASTC_5x5, // kASTC_5x5_Format
GR_GL_COMPRESSED_RGBA_ASTC_6x5, // kASTC_6x5_Format
GR_GL_COMPRESSED_RGBA_ASTC_6x6, // kASTC_6x6_Format
GR_GL_COMPRESSED_RGBA_ASTC_8x5, // kASTC_8x5_Format
GR_GL_COMPRESSED_RGBA_ASTC_8x6, // kASTC_8x6_Format
GR_GL_COMPRESSED_RGBA_ASTC_8x8, // kASTC_8x8_Format
GR_GL_COMPRESSED_RGBA_ASTC_10x5, // kASTC_10x5_Format
GR_GL_COMPRESSED_RGBA_ASTC_10x6, // kASTC_10x6_Format
GR_GL_COMPRESSED_RGBA_ASTC_10x8, // kASTC_10x8_Format
GR_GL_COMPRESSED_RGBA_ASTC_10x10, // kASTC_10x10_Format
GR_GL_COMPRESSED_RGBA_ASTC_12x10, // kASTC_12x10_Format
GR_GL_COMPRESSED_RGBA_ASTC_12x12, // kASTC_12x12_Format
};
GR_STATIC_ASSERT(0 == SkTextureCompressor::kLATC_Format);