GrGLAttribArrayState Class Reference

#include <GrGLVertexArray.h>

Public Member Functions
	GrGLAttribArrayState (int arrayCount=0)
void	resize (int newCount)
void	set (GrGLGpu *, int attribIndex, const GrBuffer *vertexBuffer, GrVertexAttribType cpuType, SkSLType gpuType, GrGLsizei stride, size_t offsetInBytes, int divisor=0)
void	enableVertexArrays (const GrGLGpu *, int enabledCount, GrPrimitiveRestart=GrPrimitiveRestart::kNo)
void	invalidate ()
int	count () const

Detailed Description

This sets and tracks the vertex attribute array state. It is used internally by GrGLVertexArray (below) but is separate because it is also used to track the state of vertex array object 0.

Definition at line 26 of file GrGLVertexArray.h.

Constructor & Destructor Documentation

GrGLAttribArrayState()

GrGLAttribArrayState::GrGLAttribArrayState ( int  arrayCount = 0 )

inlineexplicit

Definition at line 28 of file GrGLVertexArray.h.

                                                      {
        this->resize(arrayCount);
    }

Member Function Documentation

count()

int GrGLAttribArrayState::count ( ) const

inline

The number of attrib arrays that this object is configured to track.

Definition at line 68 of file GrGLVertexArray.h.

{ return fAttribArrayStates.size(); }

enableVertexArrays()

void GrGLAttribArrayState::enableVertexArrays	(	const GrGLGpu *	gpu,
		int	enabledCount,
		GrPrimitiveRestart	enablePrimitiveRestart = GrPrimitiveRestart::kNo
	)

This function enables the first 'enabledCount' vertex arrays and disables the rest.

Definition at line 156 of file GrGLVertexArray.cpp.

                                                                                         {
    SkASSERT(enabledCount <= fAttribArrayStates.size());
 
    if (!fEnableStateIsValid || enabledCount != fNumEnabledArrays) {
        int firstIdxToEnable = fEnableStateIsValid ? fNumEnabledArrays : 0;
        for (int i = firstIdxToEnable; i < enabledCount; ++i) {
            GR_GL_CALL(gpu->glInterface(), EnableVertexAttribArray(i));
        }
 
        int endIdxToDisable = fEnableStateIsValid ? fNumEnabledArrays : fAttribArrayStates.size();
        for (int i = enabledCount; i < endIdxToDisable; ++i) {
            GR_GL_CALL(gpu->glInterface(), DisableVertexAttribArray(i));
        }
 
        fNumEnabledArrays = enabledCount;
    }
 
    SkASSERT(GrPrimitiveRestart::kNo == enablePrimitiveRestart ||
             gpu->caps()->usePrimitiveRestart());
 
    if (gpu->caps()->usePrimitiveRestart() &&
        (!fEnableStateIsValid || enablePrimitiveRestart != fPrimitiveRestartEnabled)) {
        if (GrPrimitiveRestart::kYes == enablePrimitiveRestart) {
            GR_GL_CALL(gpu->glInterface(), Enable(GR_GL_PRIMITIVE_RESTART_FIXED_INDEX));
        } else {
            GR_GL_CALL(gpu->glInterface(), Disable(GR_GL_PRIMITIVE_RESTART_FIXED_INDEX));
        }
 
        fPrimitiveRestartEnabled = enablePrimitiveRestart;
    }
 
    fEnableStateIsValid = true;
}

invalidate()

void GrGLAttribArrayState::invalidate ( )

inline

Definition at line 57 of file GrGLVertexArray.h.

                      {
        int count = fAttribArrayStates.size();
        for (int i = 0; i < count; ++i) {
            fAttribArrayStates[i].invalidate();
        }
        fEnableStateIsValid = false;
    }

resize()

void GrGLAttribArrayState::resize ( int  newCount )

inline

Definition at line 32 of file GrGLVertexArray.h.

                              {
        fAttribArrayStates.resize_back(newCount);
        this->invalidate();
    }

set()

void GrGLAttribArrayState::set	(	GrGLGpu *	gpu,
		int	attribIndex,
		const GrBuffer *	vertexBuffer,
		GrVertexAttribType	cpuType,
		SkSLType	gpuType,
		GrGLsizei	stride,
		size_t	offsetInBytes,
		int	divisor = 0
	)

This function enables and sets vertex attrib state for the specified attrib index. It is assumed that the GrGLAttribArrayState is tracking the state of the currently bound vertex array object.

Definition at line 91 of file GrGLVertexArray.cpp.

                                            {
    SkASSERT(index >= 0 && index < fAttribArrayStates.size());
    SkASSERT(0 == divisor || gpu->caps()->drawInstancedSupport());
    AttribArrayState* array = &fAttribArrayStates[index];
    const char* offsetAsPtr;
    bool bufferChanged = false;
    if (vertexBuffer->isCpuBuffer()) {
        if (!array->fUsingCpuBuffer) {
            bufferChanged = true;
            array->fUsingCpuBuffer = true;
        }
        offsetAsPtr = static_cast<const GrCpuBuffer*>(vertexBuffer)->data() + offsetInBytes;
    } else {
        auto gpuBuffer = static_cast<const GrGpuBuffer*>(vertexBuffer);
        if (array->fUsingCpuBuffer || array->fVertexBufferUniqueID != gpuBuffer->uniqueID()) {
            bufferChanged = true;
            array->fVertexBufferUniqueID = gpuBuffer->uniqueID();
        }
        offsetAsPtr = reinterpret_cast<const char*>(offsetInBytes);
    }
    if (bufferChanged ||
        array->fCPUType != cpuType ||
        array->fGPUType != gpuType ||
        array->fStride != stride ||
        array->fOffset != offsetAsPtr) {
        // We always have to call this if we're going to change the array pointer. 'array' is
        // tracking the last buffer used to setup attrib pointers, not the last buffer bound.
        // GrGLGpu will avoid redundant binds.
        gpu->bindBuffer(GrGpuBufferType::kVertex, vertexBuffer);
        const AttribLayout& layout = attrib_layout(cpuType);
        if (SkSLTypeIsFloatType(gpuType)) {
            GR_GL_CALL(gpu->glInterface(), VertexAttribPointer(index,
                                                               layout.fCount,
                                                               layout.fType,
                                                               layout.fNormalized,
                                                               stride,
                                                               offsetAsPtr));
        } else {
            SkASSERT(gpu->caps()->shaderCaps()->fIntegerSupport);
            SkASSERT(!layout.fNormalized);
            GR_GL_CALL(gpu->glInterface(), VertexAttribIPointer(index,
                                                                layout.fCount,
                                                                layout.fType,
                                                                stride,
                                                                offsetAsPtr));
        }
        array->fCPUType = cpuType;
        array->fGPUType = gpuType;
        array->fStride = stride;
        array->fOffset = offsetAsPtr;
    }
    if (gpu->caps()->drawInstancedSupport() && array->fDivisor != divisor) {
        SkASSERT(0 == divisor || 1 == divisor); // not necessarily a requirement but what we expect.
        GR_GL_CALL(gpu->glInterface(), VertexAttribDivisor(index, divisor));
        array->fDivisor = divisor;
    }
}

---

The documentation for this class was generated from the following files:

• third_party/skia/src/gpu/ganesh/gl/GrGLVertexArray.h
• third_party/skia/src/gpu/ganesh/gl/GrGLVertexArray.cpp