GrGLGpu.cpp File Reference

#include "src/gpu/ganesh/gl/GrGLGpu.h"
#include "include/core/SkAlphaType.h"
#include "include/core/SkColor.h"
#include "include/core/SkColorSpace.h"
#include "include/core/SkData.h"
#include "include/core/SkRect.h"
#include "include/core/SkSize.h"
#include "include/core/SkString.h"
#include "include/core/SkTextureCompressionType.h"
#include "include/core/SkTypes.h"
#include "include/gpu/GpuTypes.h"
#include "include/gpu/GrBackendSurface.h"
#include "include/gpu/GrContextOptions.h"
#include "include/gpu/GrDirectContext.h"
#include "include/gpu/GrDriverBugWorkarounds.h"
#include "include/gpu/GrTypes.h"
#include "include/gpu/gl/GrGLConfig.h"
#include "include/private/base/SkFloatingPoint.h"
#include "include/private/base/SkMath.h"
#include "include/private/base/SkPoint_impl.h"
#include "include/private/base/SkTemplates.h"
#include "include/private/base/SkTo.h"
#include "src/base/SkScopeExit.h"
#include "src/core/SkCompressedDataUtils.h"
#include "src/core/SkLRUCache.h"
#include "src/core/SkMipmap.h"
#include "src/core/SkSLTypeShared.h"
#include "src/core/SkTraceEvent.h"
#include "src/gpu/SkRenderEngineAbortf.h"
#include "src/gpu/Swizzle.h"
#include "src/gpu/ganesh/GrAttachment.h"
#include "src/gpu/ganesh/GrBackendSurfacePriv.h"
#include "src/gpu/ganesh/GrBackendUtils.h"
#include "src/gpu/ganesh/GrBuffer.h"
#include "src/gpu/ganesh/GrDataUtils.h"
#include "src/gpu/ganesh/GrDirectContextPriv.h"
#include "src/gpu/ganesh/GrGpuBuffer.h"
#include "src/gpu/ganesh/GrImageInfo.h"
#include "src/gpu/ganesh/GrPipeline.h"
#include "src/gpu/ganesh/GrProgramInfo.h"
#include "src/gpu/ganesh/GrRenderTarget.h"
#include "src/gpu/ganesh/GrSemaphore.h"
#include "src/gpu/ganesh/GrShaderCaps.h"
#include "src/gpu/ganesh/GrShaderVar.h"
#include "src/gpu/ganesh/GrStagingBufferManager.h"
#include "src/gpu/ganesh/GrSurface.h"
#include "src/gpu/ganesh/GrTexture.h"
#include "src/gpu/ganesh/GrUtil.h"
#include "src/gpu/ganesh/GrWindowRectangles.h"
#include "src/gpu/ganesh/gl/GrGLAttachment.h"
#include "src/gpu/ganesh/gl/GrGLBackendSurfacePriv.h"
#include "src/gpu/ganesh/gl/GrGLBuffer.h"
#include "src/gpu/ganesh/gl/GrGLOpsRenderPass.h"
#include "src/gpu/ganesh/gl/GrGLProgram.h"
#include "src/gpu/ganesh/gl/GrGLSemaphore.h"
#include "src/gpu/ganesh/gl/GrGLTextureRenderTarget.h"
#include "src/gpu/ganesh/gl/builders/GrGLShaderStringBuilder.h"
#include "src/sksl/SkSLProgramKind.h"
#include "src/sksl/SkSLProgramSettings.h"
#include "src/sksl/ir/SkSLProgram.h"
#include <algorithm>
#include <cmath>
#include <functional>
#include <memory>
#include <string>
#include <utility>

Go to the source code of this file.

Classes
class	GrGLGpu::SamplerObjectCache

Macros
#define	GL_CALL(X)   GR_GL_CALL(this->glInterface(), X)
#define	GL_CALL_RET(RET, X)   GR_GL_CALL_RET(this->glInterface(), RET, X)
#define	GL_ALLOC_CALL(call)
#define	IS_TSAN   0

Functions
static int	gl_target_to_binding_index (GrGLenum target)
static GrGLenum	filter_to_gl_mag_filter (GrSamplerState::Filter filter)
static GrGLenum	filter_to_gl_min_filter (GrSamplerState::Filter filter, GrSamplerState::MipmapMode mm)
static GrGLenum	wrap_mode_to_gl_wrap (GrSamplerState::WrapMode wrapMode, const GrCaps &caps)
static void	cleanup_program (GrGLGpu *gpu, GrGLuint *programID, GrGLuint *vshader, GrGLuint *fshader)
static bool	check_backend_texture (const GrBackendTexture &backendTex, const GrGLCaps &caps, GrGLTexture::Desc *desc, bool skipRectTexSupportCheck=false)
static sk_sp< GrGLTextureParameters >	get_gl_texture_params (const GrBackendTexture &backendTex)
static bool	check_compressed_backend_texture (const GrBackendTexture &backendTex, const GrGLCaps &caps, GrGLTexture::Desc *desc, bool skipRectTexSupportCheck=false)
static bool	check_write_and_transfer_input (GrGLTexture *glTex)
static sk_sp< GrTexture >	return_null_texture ()
static GrGLTextureParameters::SamplerOverriddenState	set_initial_texture_params (const GrGLInterface *interface, const GrGLCaps &caps, GrGLenum target)
static void	set_khr_debug_label (GrGLGpu *gpu, const GrGLuint id, std::string_view label)
static bool	use_tiled_rendering (const GrGLCaps &glCaps, const GrOpsRenderPass::StencilLoadAndStoreInfo &stencilLoadStore)
static bool	can_blit_framebuffer_for_copy_surface (const GrSurface *dst, const GrSurface *src, const SkIRect &srcRect, const SkIRect &dstRect, const GrGLCaps &caps)
static bool	rt_has_msaa_render_buffer (const GrGLRenderTarget *rt, const GrGLCaps &glCaps)
static bool	can_copy_texsubimage (const GrSurface *dst, const GrSurface *src, const GrGLCaps &caps)

Variables
static const GrGLenum	gXfermodeEquation2Blend []
static const GrGLenum	gXfermodeCoeff2Blend []

Macro Definition Documentation

GL_ALLOC_CALL

#define GL_ALLOC_CALL

(

call

)

Value:

    [&] {                                                     \
        if (this->glCaps().skipErrorChecks()) {               \
            GR_GL_CALL(this->glInterface(), call);            \
            return static_cast<GrGLenum>(GR_GL_NO_ERROR);     \
        } else {                                              \
            this->clearErrorsAndCheckForOOM();                \
            GR_GL_CALL_NOERRCHECK(this->glInterface(), call); \
            return this->getErrorAndCheckForOOM();            \
        }                                                     \
    }()

Definition at line 82 of file GrGLGpu.cpp.

        {                                                     \
        if (this->glCaps().skipErrorChecks()) {               \
            GR_GL_CALL(this->glInterface(), call);            \
            return static_cast<GrGLenum>(GR_GL_NO_ERROR);     \
        } else {                                              \
            this->clearErrorsAndCheckForOOM();                \
            GR_GL_CALL_NOERRCHECK(this->glInterface(), call); \
            return this->getErrorAndCheckForOOM();            \
        }                                                     \
    }()

GL_CALL

#define GL_CALL

(

X

)

GR_GL_CALL(this->glInterface(), X)

Definition at line 79 of file GrGLGpu.cpp.

GL_CALL_RET

#define GL_CALL_RET	(		RET,
			X
	)		GR_GL_CALL_RET(this->glInterface(), RET, X)

Definition at line 80 of file GrGLGpu.cpp.

IS_TSAN

#define IS_TSAN   0

Function Documentation

can_blit_framebuffer_for_copy_surface()

static bool can_blit_framebuffer_for_copy_surface ( const GrSurface *  dst, const GrSurface *  src, const SkIRect &  srcRect, const SkIRect &  dstRect, const GrGLCaps &  caps  )

inlinestatic

Definition at line 3053 of file GrGLGpu.cpp.

                                                                               {
    int dstSampleCnt = 0;
    int srcSampleCnt = 0;
    if (const GrRenderTarget* rt = dst->asRenderTarget()) {
        dstSampleCnt = rt->numSamples();
    }
    if (const GrRenderTarget* rt = src->asRenderTarget()) {
        srcSampleCnt = rt->numSamples();
    }
    SkASSERT((dstSampleCnt > 0) == SkToBool(dst->asRenderTarget()));
    SkASSERT((srcSampleCnt > 0) == SkToBool(src->asRenderTarget()));
 
    GrGLFormat dstFormat = GrBackendFormats::AsGLFormat(dst->backendFormat());
    GrGLFormat srcFormat = GrBackendFormats::AsGLFormat(src->backendFormat());
 
    const GrGLTexture* dstTex = static_cast<const GrGLTexture*>(dst->asTexture());
    const GrGLTexture* srcTex = static_cast<const GrGLTexture*>(src->asTexture());
 
    GrTextureType dstTexType;
    GrTextureType* dstTexTypePtr = nullptr;
    GrTextureType srcTexType;
    GrTextureType* srcTexTypePtr = nullptr;
    if (dstTex) {
        dstTexType = dstTex->textureType();
        dstTexTypePtr = &dstTexType;
    }
    if (srcTex) {
        srcTexType = srcTex->textureType();
        srcTexTypePtr = &srcTexType;
    }
 
    return caps.canCopyAsBlit(dstFormat, dstSampleCnt, dstTexTypePtr,
                              srcFormat, srcSampleCnt, srcTexTypePtr,
                              src->getBoundsRect(), true, srcRect, dstRect);
}

can_copy_texsubimage()

static bool can_copy_texsubimage ( const GrSurface *  dst, const GrSurface *  src, const GrGLCaps &  caps  )

inlinestatic

Definition at line 3101 of file GrGLGpu.cpp.

                                                              {
 
    const GrGLRenderTarget* dstRT = static_cast<const GrGLRenderTarget*>(dst->asRenderTarget());
    const GrGLRenderTarget* srcRT = static_cast<const GrGLRenderTarget*>(src->asRenderTarget());
    const GrGLTexture* dstTex = static_cast<const GrGLTexture*>(dst->asTexture());
    const GrGLTexture* srcTex = static_cast<const GrGLTexture*>(src->asTexture());
 
    bool dstHasMSAARenderBuffer = dstRT ? rt_has_msaa_render_buffer(dstRT, caps) : false;
    bool srcHasMSAARenderBuffer = srcRT ? rt_has_msaa_render_buffer(srcRT, caps) : false;
 
    GrGLFormat dstFormat = GrBackendFormats::AsGLFormat(dst->backendFormat());
    GrGLFormat srcFormat = GrBackendFormats::AsGLFormat(src->backendFormat());
 
    GrTextureType dstTexType;
    GrTextureType* dstTexTypePtr = nullptr;
    GrTextureType srcTexType;
    GrTextureType* srcTexTypePtr = nullptr;
    if (dstTex) {
        dstTexType = dstTex->textureType();
        dstTexTypePtr = &dstTexType;
    }
    if (srcTex) {
        srcTexType = srcTex->textureType();
        srcTexTypePtr = &srcTexType;
    }
 
    return caps.canCopyTexSubImage(dstFormat, dstHasMSAARenderBuffer, dstTexTypePtr,
                                   srcFormat, srcHasMSAARenderBuffer, srcTexTypePtr);
}

check_backend_texture()

static bool check_backend_texture ( const GrBackendTexture &  backendTex, const GrGLCaps &  caps, GrGLTexture::Desc *  desc, bool  skipRectTexSupportCheck = false  )

static

Definition at line 711 of file GrGLGpu.cpp.

                                                                        {
    GrGLTextureInfo info;
    if (!GrBackendTextures::GetGLTextureInfo(backendTex, &info) || !info.fID || !info.fFormat) {
        return false;
    }
 
    desc->fSize = {backendTex.width(), backendTex.height()};
    desc->fTarget = info.fTarget;
    desc->fID = info.fID;
    desc->fFormat = GrGLFormatFromGLEnum(info.fFormat);
    desc->fIsProtected = info.fProtected;
 
    if (desc->fFormat == GrGLFormat::kUnknown) {
        return false;
    }
    if (GR_GL_TEXTURE_EXTERNAL == desc->fTarget) {
        if (!caps.shaderCaps()->fExternalTextureSupport) {
            return false;
        }
    } else if (GR_GL_TEXTURE_RECTANGLE == desc->fTarget) {
        if (!caps.rectangleTextureSupport() && !skipRectTexSupportCheck) {
            return false;
        }
    } else if (GR_GL_TEXTURE_2D != desc->fTarget) {
        return false;
    }
    if (desc->fIsProtected == skgpu::Protected::kYes && !caps.supportsProtectedContent()) {
        return false;
    }
 
    return true;
}

check_compressed_backend_texture()

static bool check_compressed_backend_texture ( const GrBackendTexture &  backendTex, const GrGLCaps &  caps, GrGLTexture::Desc *  desc, bool  skipRectTexSupportCheck = false  )

static

Definition at line 786 of file GrGLGpu.cpp.

                                                                                   {
    GrGLTextureInfo info;
    if (!GrBackendTextures::GetGLTextureInfo(backendTex, &info) || !info.fID || !info.fFormat) {
        return false;
    }
 
    desc->fSize = {backendTex.width(), backendTex.height()};
    desc->fTarget = info.fTarget;
    desc->fID = info.fID;
    desc->fFormat = GrGLFormatFromGLEnum(info.fFormat);
    desc->fIsProtected = info.fProtected;
 
    if (desc->fFormat == GrGLFormat::kUnknown) {
        return false;
    }
 
    if (GR_GL_TEXTURE_2D != desc->fTarget) {
        return false;
    }
    if (desc->fIsProtected == skgpu::Protected::kYes && !caps.supportsProtectedContent()) {
        return false;
    }
 
    return true;
}

check_write_and_transfer_input()

static bool check_write_and_transfer_input ( GrGLTexture *  glTex )

static

Definition at line 928 of file GrGLGpu.cpp.

                                                               {
    if (!glTex) {
        return false;
    }
 
    // Write or transfer of pixels is not implemented for TEXTURE_EXTERNAL textures
    if (GR_GL_TEXTURE_EXTERNAL == glTex->target()) {
        return false;
    }
 
    return true;
}

cleanup_program()

static void cleanup_program ( GrGLGpu *  gpu, GrGLuint *  programID, GrGLuint *  vshader, GrGLuint *  fshader  )

static

Definition at line 256 of file GrGLGpu.cpp.

                                               {
    const GrGLInterface* gli = gpu->glInterface();
    if (programID) {
        GR_GL_CALL(gli, DeleteProgram(*programID));
        *programID = 0;
    }
    if (vshader) {
        GR_GL_CALL(gli, DeleteShader(*vshader));
        *vshader = 0;
    }
    if (fshader) {
        GR_GL_CALL(gli, DeleteShader(*fshader));
        *fshader = 0;
    }
}

filter_to_gl_mag_filter()

static GrGLenum filter_to_gl_mag_filter ( GrSamplerState::Filter  filter )

static

Definition at line 211 of file GrGLGpu.cpp.

                                                                     {
    switch (filter) {
        case GrSamplerState::Filter::kNearest: return GR_GL_NEAREST;
        case GrSamplerState::Filter::kLinear:  return GR_GL_LINEAR;
    }
    SkUNREACHABLE;
}

filter_to_gl_min_filter()

static GrGLenum filter_to_gl_min_filter ( GrSamplerState::Filter  filter, GrSamplerState::MipmapMode  mm  )

static

Definition at line 219 of file GrGLGpu.cpp.

                                                                     {
    switch (mm) {
        case GrSamplerState::MipmapMode::kNone:
            return filter_to_gl_mag_filter(filter);
        case GrSamplerState::MipmapMode::kNearest:
            switch (filter) {
                case GrSamplerState::Filter::kNearest: return GR_GL_NEAREST_MIPMAP_NEAREST;
                case GrSamplerState::Filter::kLinear:  return GR_GL_LINEAR_MIPMAP_NEAREST;
            }
            SkUNREACHABLE;
        case GrSamplerState::MipmapMode::kLinear:
            switch (filter) {
                case GrSamplerState::Filter::kNearest: return GR_GL_NEAREST_MIPMAP_LINEAR;
                case GrSamplerState::Filter::kLinear:  return GR_GL_LINEAR_MIPMAP_LINEAR;
            }
            SkUNREACHABLE;
    }
    SkUNREACHABLE;
}

get_gl_texture_params()

static sk_sp< GrGLTextureParameters > get_gl_texture_params ( const GrBackendTexture &  backendTex )

static

Definition at line 747 of file GrGLGpu.cpp.

                                                                                              {
    const GrBackendTextureData* btd = GrBackendSurfacePriv::GetBackendData(backendTex);
    auto glTextureData = static_cast<const GrGLBackendTextureData*>(btd);
    SkASSERT(glTextureData);
    return glTextureData->info().refParameters();
}

gl_target_to_binding_index()

static int gl_target_to_binding_index ( GrGLenum  target )

static

Definition at line 170 of file GrGLGpu.cpp.

                                                       {
    switch (target) {
        case GR_GL_TEXTURE_2D:
            return 0;
        case GR_GL_TEXTURE_RECTANGLE:
            return 1;
        case GR_GL_TEXTURE_EXTERNAL:
            return 2;
    }
    SK_ABORT("Unexpected GL texture target.");
}

return_null_texture()

static sk_sp< GrTexture > return_null_texture ( )

static

Definition at line 1484 of file GrGLGpu.cpp.

                                              {
//    SkDEBUGFAIL("null texture");
    return nullptr;
}

rt_has_msaa_render_buffer()

static bool rt_has_msaa_render_buffer ( const GrGLRenderTarget *  rt, const GrGLCaps &  glCaps  )

static

Definition at line 3093 of file GrGLGpu.cpp.

                                                                                          {
    // A RT has a separate MSAA renderbuffer if:
    // 1) It's multisampled
    // 2) We're using an extension with separate MSAA renderbuffers
    // 3) It's not FBO 0, which is special and always auto-resolves
    return rt->numSamples() > 1 && glCaps.usesMSAARenderBuffers() && !rt->isFBO0(true/*msaa*/);
}

set_initial_texture_params()

static GrGLTextureParameters::SamplerOverriddenState set_initial_texture_params ( const GrGLInterface *  interface, const GrGLCaps &  caps, GrGLenum  target  )

static

Definition at line 1489 of file GrGLGpu.cpp.

                         {
    // Some drivers like to know filter/wrap before seeing glTexImage2D. Some
    // drivers have a bug where an FBO won't be complete if it includes a
    // texture that is not mipmap complete (considering the filter in use).
    GrGLTextureParameters::SamplerOverriddenState state;
    state.fMinFilter = GR_GL_NEAREST;
    state.fMagFilter = GR_GL_NEAREST;
    state.fWrapS = GR_GL_CLAMP_TO_EDGE;
    state.fWrapT = GR_GL_CLAMP_TO_EDGE;
    GR_GL_CALL(interface, TexParameteri(target, GR_GL_TEXTURE_MAG_FILTER, state.fMagFilter));
    GR_GL_CALL(interface, TexParameteri(target, GR_GL_TEXTURE_MIN_FILTER, state.fMinFilter));
    GR_GL_CALL(interface, TexParameteri(target, GR_GL_TEXTURE_WRAP_S, state.fWrapS));
    GR_GL_CALL(interface, TexParameteri(target, GR_GL_TEXTURE_WRAP_T, state.fWrapT));
    return state;
}

set_khr_debug_label()

static void set_khr_debug_label ( GrGLGpu *  gpu, const GrGLuint  id, std::string_view  label  )

static

Definition at line 1839 of file GrGLGpu.cpp.

                                                                                       {
    const std::string khr_debug_label = label.empty() ? "Skia" : std::string(label);
    if (gpu->glCaps().debugSupport()) {
        GR_GL_CALL(gpu->glInterface(), ObjectLabel(GR_GL_TEXTURE, id, -1, khr_debug_label.c_str()));
    }
}

use_tiled_rendering()

static bool use_tiled_rendering ( const GrGLCaps &  glCaps, const GrOpsRenderPass::StencilLoadAndStoreInfo &  stencilLoadStore  )

static

Definition at line 2192 of file GrGLGpu.cpp.

                                                                                                {
    // Only use the tiled rendering extension if we can explicitly clear and discard the stencil.
    // Otherwise it's faster to just not use it.
    return glCaps.tiledRenderingSupport() && GrLoadOp::kClear == stencilLoadStore.fLoadOp &&
           GrStoreOp::kDiscard == stencilLoadStore.fStoreOp;
}

wrap_mode_to_gl_wrap()

static GrGLenum wrap_mode_to_gl_wrap ( GrSamplerState::WrapMode  wrapMode, const GrCaps &  caps  )

inlinestatic

Definition at line 240 of file GrGLGpu.cpp.

                                                                {
    switch (wrapMode) {
        case GrSamplerState::WrapMode::kClamp:        return GR_GL_CLAMP_TO_EDGE;
        case GrSamplerState::WrapMode::kRepeat:       return GR_GL_REPEAT;
        case GrSamplerState::WrapMode::kMirrorRepeat: return GR_GL_MIRRORED_REPEAT;
        case GrSamplerState::WrapMode::kClampToBorder:
            // May not be supported but should have been caught earlier
            SkASSERT(caps.clampToBorderSupport());
            return GR_GL_CLAMP_TO_BORDER;
    }
    SkUNREACHABLE;
}

Variable Documentation

gXfermodeCoeff2Blend

const GrGLenum gXfermodeCoeff2Blend[]

static

Initial value:

= {
    GR_GL_ZERO,
    GR_GL_ONE,
    GR_GL_SRC_COLOR,
    GR_GL_ONE_MINUS_SRC_COLOR,
    GR_GL_DST_COLOR,
    GR_GL_ONE_MINUS_DST_COLOR,
    GR_GL_SRC_ALPHA,
    GR_GL_ONE_MINUS_SRC_ALPHA,
    GR_GL_DST_ALPHA,
    GR_GL_ONE_MINUS_DST_ALPHA,
    GR_GL_CONSTANT_COLOR,
    GR_GL_ONE_MINUS_CONSTANT_COLOR,
 
    
    GR_GL_SRC1_COLOR,
    GR_GL_ONE_MINUS_SRC1_COLOR,
    GR_GL_SRC1_ALPHA,
    GR_GL_ONE_MINUS_SRC1_ALPHA,
 
    
    GR_GL_ZERO,
}

Definition at line 144 of file GrGLGpu.cpp.

                                               {
    GR_GL_ZERO,
    GR_GL_ONE,
    GR_GL_SRC_COLOR,
    GR_GL_ONE_MINUS_SRC_COLOR,
    GR_GL_DST_COLOR,
    GR_GL_ONE_MINUS_DST_COLOR,
    GR_GL_SRC_ALPHA,
    GR_GL_ONE_MINUS_SRC_ALPHA,
    GR_GL_DST_ALPHA,
    GR_GL_ONE_MINUS_DST_ALPHA,
    GR_GL_CONSTANT_COLOR,
    GR_GL_ONE_MINUS_CONSTANT_COLOR,
 
    // extended blend coeffs
    GR_GL_SRC1_COLOR,
    GR_GL_ONE_MINUS_SRC1_COLOR,
    GR_GL_SRC1_ALPHA,
    GR_GL_ONE_MINUS_SRC1_ALPHA,
 
    // Illegal... needs to map to something.
    GR_GL_ZERO,
};

gXfermodeEquation2Blend

const GrGLenum gXfermodeEquation2Blend[]

static

Initial value:

= {
    
    GR_GL_FUNC_ADD,
    GR_GL_FUNC_SUBTRACT,
    GR_GL_FUNC_REVERSE_SUBTRACT,
 
    
    GR_GL_SCREEN,
    GR_GL_OVERLAY,
    GR_GL_DARKEN,
    GR_GL_LIGHTEN,
    GR_GL_COLORDODGE,
    GR_GL_COLORBURN,
    GR_GL_HARDLIGHT,
    GR_GL_SOFTLIGHT,
    GR_GL_DIFFERENCE,
    GR_GL_EXCLUSION,
    GR_GL_MULTIPLY,
    GR_GL_HSL_HUE,
    GR_GL_HSL_SATURATION,
    GR_GL_HSL_COLOR,
    GR_GL_HSL_LUMINOSITY,
 
    
    GR_GL_FUNC_ADD,
}

Definition at line 98 of file GrGLGpu.cpp.

                                                  {
    // Basic OpenGL blend equations.
    GR_GL_FUNC_ADD,
    GR_GL_FUNC_SUBTRACT,
    GR_GL_FUNC_REVERSE_SUBTRACT,
 
    // GL_KHR_blend_equation_advanced.
    GR_GL_SCREEN,
    GR_GL_OVERLAY,
    GR_GL_DARKEN,
    GR_GL_LIGHTEN,
    GR_GL_COLORDODGE,
    GR_GL_COLORBURN,
    GR_GL_HARDLIGHT,
    GR_GL_SOFTLIGHT,
    GR_GL_DIFFERENCE,
    GR_GL_EXCLUSION,
    GR_GL_MULTIPLY,
    GR_GL_HSL_HUE,
    GR_GL_HSL_SATURATION,
    GR_GL_HSL_COLOR,
    GR_GL_HSL_LUMINOSITY,
 
    // Illegal... needs to map to something.
    GR_GL_FUNC_ADD,
};