GrGLBuffer.cpp File Reference

#include "src/gpu/ganesh/gl/GrGLBuffer.h"
#include "include/core/SkTraceMemoryDump.h"
#include "src/core/SkTraceEvent.h"
#include "src/gpu/ganesh/GrGpuResourcePriv.h"
#include "src/gpu/ganesh/gl/GrGLCaps.h"
#include "src/gpu/ganesh/gl/GrGLGpu.h"

Go to the source code of this file.

Macros
#define	GL_CALL(X)   GR_GL_CALL(this->glGpu()->glInterface(), X)
#define	GL_CALL_RET(RET, X)   GR_GL_CALL_RET(this->glGpu()->glInterface(), RET, X)
#define	GL_ALLOC_CALL(gpu, call)
#define	DYNAMIC_DRAW_PARAM   GR_GL_STREAM_DRAW

Functions
static GrGLenum	gr_to_gl_access_pattern (GrGpuBufferType bufferType, GrAccessPattern accessPattern, const GrGLCaps &caps)
static GrGLenum	invalidate_buffer (GrGLGpu *gpu, GrGLenum target, GrGLenum usage, GrGLuint bufferID, size_t bufferSize)

Macro Definition Documentation

DYNAMIC_DRAW_PARAM

#define DYNAMIC_DRAW_PARAM   GR_GL_STREAM_DRAW

Definition at line 51 of file GrGLBuffer.cpp.

GL_ALLOC_CALL

#define GL_ALLOC_CALL	(		gpu,
			call
	)

Value:

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

Definition at line 19 of file GrGLBuffer.cpp.

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

GL_CALL

#define GL_CALL

(

X

)

GR_GL_CALL(this->glGpu()->glInterface(), X)

Definition at line 16 of file GrGLBuffer.cpp.

GL_CALL_RET

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

Definition at line 17 of file GrGLBuffer.cpp.

Function Documentation

gr_to_gl_access_pattern()

static GrGLenum gr_to_gl_access_pattern ( GrGpuBufferType  bufferType, GrAccessPattern  accessPattern, const GrGLCaps &  caps  )

inlinestatic

Definition at line 53 of file GrGLBuffer.cpp.

                                                                     {
    auto drawUsage = [](GrAccessPattern pattern) {
        switch (pattern) {
            case kDynamic_GrAccessPattern:
                // TODO: Do we really want to use STREAM_DRAW here on non-Chromium?
                return DYNAMIC_DRAW_PARAM;
            case kStatic_GrAccessPattern:
                return GR_GL_STATIC_DRAW;
            case kStream_GrAccessPattern:
                return GR_GL_STREAM_DRAW;
        }
        SkUNREACHABLE;
    };
 
    auto readUsage = [](GrAccessPattern pattern) {
        switch (pattern) {
            case kDynamic_GrAccessPattern:
                return GR_GL_DYNAMIC_READ;
            case kStatic_GrAccessPattern:
                return GR_GL_STATIC_READ;
            case kStream_GrAccessPattern:
                return GR_GL_STREAM_READ;
        }
        SkUNREACHABLE;
    };
 
    auto usageType = [&drawUsage, &readUsage, &caps](GrGpuBufferType type,
                                                     GrAccessPattern pattern) {
        // GL_NV_pixel_buffer_object adds transfer buffers but not the related <usage> values.
        if (caps.transferBufferType() == GrGLCaps::TransferBufferType::kNV_PBO) {
            return drawUsage(pattern);
        }
        switch (type) {
            case GrGpuBufferType::kVertex:
            case GrGpuBufferType::kIndex:
            case GrGpuBufferType::kDrawIndirect:
            case GrGpuBufferType::kXferCpuToGpu:
            case GrGpuBufferType::kUniform:
                return drawUsage(pattern);
            case GrGpuBufferType::kXferGpuToCpu:
                return readUsage(pattern);
        }
        SkUNREACHABLE;
    };
 
    return usageType(bufferType, accessPattern);
}

invalidate_buffer()

static GrGLenum invalidate_buffer ( GrGLGpu *  gpu, GrGLenum  target, GrGLenum  usage, GrGLuint  bufferID, size_t  bufferSize  )

inlinestatic

Definition at line 161 of file GrGLBuffer.cpp.

                                                                          {
    switch (gpu->glCaps().invalidateBufferType()) {
        case GrGLCaps::InvalidateBufferType::kNone:
            return GR_GL_NO_ERROR;
        case GrGLCaps::InvalidateBufferType::kNullData:
            return GL_ALLOC_CALL(gpu, BufferData(target, bufferSize, nullptr, usage));
        case GrGLCaps::InvalidateBufferType::kInvalidate:
            GR_GL_CALL(gpu->glInterface(), InvalidateBufferData(bufferID));
            return GR_GL_NO_ERROR;
    }
    SkUNREACHABLE;
}