cc/gapic/coder/gles.h

////////////////////////////////////////////////////////////////////////////////
// Do not modify!
// Generated by codergen
////////////////////////////////////////////////////////////////////////////////


#ifndef GAPIC_CODER_GLES_H
#define GAPIC_CODER_GLES_H

#include <gapic/schema.h>
#include <gapic/coder/memory.h>
#include <gapic/vector.h>
#include <gapic/coder/gles.h>
#include <gapic/map.h>

#include <gapic/static_array.h>
namespace gapic {

class Encodable;
class Encoder;

namespace coder {
namespace gles {
    class ActiveAttribute: public Encodable {
    public:
        ActiveAttribute() = default;
        ActiveAttribute(const char* Name, uint32_t Type, int32_t ArraySize, uint32_t Location)
                : mName(Name)
                , mType(Type)
                , mArraySize(ArraySize)
                , mLocation(Location) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        const char* mName;
        uint32_t mType;
        int32_t mArraySize;
        uint32_t mLocation;
    };

    class ActiveUniform: public Encodable {
    public:
        ActiveUniform() = default;
        ActiveUniform(const char* Name, uint32_t Type, int32_t ArraySize, int32_t Location)
                : mName(Name)
                , mType(Type)
                , mArraySize(ArraySize)
                , mLocation(Location) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        const char* mName;
        uint32_t mType;
        int32_t mArraySize;
        int32_t mLocation;
    };

    class Vec4f: public Encodable {
    public:
        Vec4f() = default;
        Vec4f(const gapic::StaticArray<float, 4>& Elements)
                : mElements(Elements) {}
        virtual void Encode(Encoder* e) const{
            for (int i = 0; i < 4; i++) {
                e->Float32(this->mElements[i]);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::StaticArray<float, 4> mElements;
    };

    class U8__S: public Encodable {
    public:
        U8__S() = default;
        U8__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class U8__P: public Encodable {
    public:
        U8__P() = default;
        U8__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class BufferDataPointer: public Encodable {
    public:
        BufferDataPointer() = default;
        BufferDataPointer(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class BufferId__S: public Encodable {
    public:
        BufferId__S() = default;
        BufferId__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class BufferId__P: public Encodable {
    public:
        BufferId__P() = default;
        BufferId__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class BufferId__CP: public Encodable {
    public:
        BufferId__CP() = default;
        BufferId__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class CGLContextObj: public Encodable {
    public:
        CGLContextObj() = default;
        CGLContextObj(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class CGLContextObj__S: public Encodable {
    public:
        CGLContextObj__S() = default;
        CGLContextObj__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class CGLContextObj__P: public Encodable {
    public:
        CGLContextObj__P() = default;
        CGLContextObj__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class CGLTexelFormatObj: public Encodable {
    public:
        CGLTexelFormatObj() = default;
        CGLTexelFormatObj(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class CGLCreateContext: public Encodable {
    public:
        CGLCreateContext() = default;
        CGLCreateContext(const gapic::Vector<gapic::Encodable*>& extras, CGLTexelFormatObj Pix, CGLContextObj Share, CGLContextObj__P Ctx, int64_t Result)
                : mextras(extras)
                , mPix(Pix)
                , mShare(Share)
                , mCtx(Ctx)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        CGLTexelFormatObj mPix;
        CGLContextObj mShare;
        CGLContextObj__P mCtx;
        int64_t mResult;
    };

    class CGLFlushDrawable: public Encodable {
    public:
        CGLFlushDrawable() = default;
        CGLFlushDrawable(const gapic::Vector<gapic::Encodable*>& extras, CGLContextObj Ctx, int64_t Result)
                : mextras(extras)
                , mCtx(Ctx)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Struct(this->mCtx);
            e->Int64(this->mResult);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        CGLContextObj mCtx;
        int64_t mResult;
    };

    class CGSConnectionID__P: public Encodable {
    public:
        CGSConnectionID__P() = default;
        CGSConnectionID__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class CGSWindowID__P: public Encodable {
    public:
        CGSWindowID__P() = default;
        CGSWindowID__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class CGSSurfaceID__P: public Encodable {
    public:
        CGSSurfaceID__P() = default;
        CGSSurfaceID__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class CGLGetSurface: public Encodable {
    public:
        CGLGetSurface() = default;
        CGLGetSurface(const gapic::Vector<gapic::Encodable*>& extras, CGLContextObj Ctx, CGSConnectionID__P Cid, CGSWindowID__P Wid, CGSSurfaceID__P Sid, int64_t Result)
                : mextras(extras)
                , mCtx(Ctx)
                , mCid(Cid)
                , mWid(Wid)
                , mSid(Sid)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        CGLContextObj mCtx;
        CGSConnectionID__P mCid;
        CGSWindowID__P mWid;
        CGSSurfaceID__P mSid;
        int64_t mResult;
    };

    class CGLSetCurrentContext: public Encodable {
    public:
        CGLSetCurrentContext() = default;
        CGLSetCurrentContext(const gapic::Vector<gapic::Encodable*>& extras, CGLContextObj Ctx, int64_t Result)
                : mextras(extras)
                , mCtx(Ctx)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Struct(this->mCtx);
            e->Int64(this->mResult);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        CGLContextObj mCtx;
        int64_t mResult;
    };

    class CGSConnectionID: public Encodable {
    public:
        CGSConnectionID() = default;
        CGSConnectionID(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class CGSConnectionID__S: public Encodable {
    public:
        CGSConnectionID__S() = default;
        CGSConnectionID__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class F64__P: public Encodable {
    public:
        F64__P() = default;
        F64__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class CGSGetSurfaceBounds: public Encodable {
    public:
        CGSGetSurfaceBounds() = default;
        CGSGetSurfaceBounds(const gapic::Vector<gapic::Encodable*>& extras, CGSConnectionID Cid, int32_t Wid, int32_t Sid, F64__P Bounds, int64_t Result)
                : mextras(extras)
                , mCid(Cid)
                , mWid(Wid)
                , mSid(Sid)
                , mBounds(Bounds)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        CGSConnectionID mCid;
        int32_t mWid;
        int32_t mSid;
        F64__P mBounds;
        int64_t mResult;
    };

    class CGSSurfaceID__S: public Encodable {
    public:
        CGSSurfaceID__S() = default;
        CGSSurfaceID__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class CGSWindowID__S: public Encodable {
    public:
        CGSWindowID__S() = default;
        CGSWindowID__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class Char__S: public Encodable {
    public:
        Char__S() = default;
        Char__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class Char__P: public Encodable {
    public:
        Char__P() = default;
        Char__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class Char__CP: public Encodable {
    public:
        Char__CP() = default;
        Char__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class GLfloat__2__A: public Encodable {
    public:
        GLfloat__2__A() = default;
        GLfloat__2__A(const gapic::StaticArray<float, 2>& Elements)
                : mElements(Elements) {}
        virtual void Encode(Encoder* e) const{
            for (int i = 0; i < 2; i++) {
                e->Float32(this->mElements[i]);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::StaticArray<float, 2> mElements;
    };

    class GLint__2__A: public Encodable {
    public:
        GLint__2__A() = default;
        GLint__2__A(const gapic::StaticArray<int32_t, 2>& Elements)
                : mElements(Elements) {}
        virtual void Encode(Encoder* e) const{
            for (int i = 0; i < 2; i++) {
                e->Int32(this->mElements[i]);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::StaticArray<int32_t, 2> mElements;
    };

    class PrecisionFormat: public Encodable {
    public:
        PrecisionFormat() = default;
        PrecisionFormat(int32_t MinRange, int32_t MaxRange, int32_t Precision)
                : mMinRange(MinRange)
                , mMaxRange(MaxRange)
                , mPrecision(Precision) {}
        virtual void Encode(Encoder* e) const{
            e->Int32(this->mMinRange);
            e->Int32(this->mMaxRange);
            e->Int32(this->mPrecision);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        int32_t mMinRange;
        int32_t mMaxRange;
        int32_t mPrecision;
    };

    class ShaderPrecisionFormat: public Encodable {
    public:
        ShaderPrecisionFormat() = default;
        ShaderPrecisionFormat(PrecisionFormat LowFloat, PrecisionFormat MediumFloat, PrecisionFormat HighFloat, PrecisionFormat LowInt, PrecisionFormat MediumInt, PrecisionFormat HighInt)
                : mLowFloat(LowFloat)
                , mMediumFloat(MediumFloat)
                , mHighFloat(HighFloat)
                , mLowInt(LowInt)
                , mMediumInt(MediumInt)
                , mHighInt(HighInt) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        PrecisionFormat mLowFloat;
        PrecisionFormat mMediumFloat;
        PrecisionFormat mHighFloat;
        PrecisionFormat mLowInt;
        PrecisionFormat mMediumInt;
        PrecisionFormat mHighInt;
    };

    class GLint__3__A: public Encodable {
    public:
        GLint__3__A() = default;
        GLint__3__A(const gapic::StaticArray<int32_t, 3>& Elements)
                : mElements(Elements) {}
        virtual void Encode(Encoder* e) const{
            for (int i = 0; i < 3; i++) {
                e->Int32(this->mElements[i]);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::StaticArray<int32_t, 3> mElements;
    };

    class Constants: public Encodable {
    public:
        Constants() = default;
        Constants(GLfloat__2__A AliasedLineWidthRange, GLfloat__2__A AliasedPointSizeRange, const gapic::Map<uint32_t, uint32_t>& CompressedTextureFormats, const gapic::Map<uint32_t, const char*>& Extensions, int32_t MaxCombinedTextureImageUnits, int32_t MaxCubeMapTextureSize, int32_t MaxFragmentUniformVectors, int32_t MaxRenderbufferSize, int32_t MaxTextureImageUnits, int32_t MaxTextureSize, int32_t MaxVaryingVectors, int32_t MaxVertexAttribs, int32_t MaxVertexTextureImageUnits, int32_t MaxVertexUniformVectors, GLint__2__A MaxViewportDims, const char* Renderer, const gapic::Map<uint32_t, uint32_t>& ShaderBinaryFormats, uint8_t ShaderCompiler, const char* ShadingLanguageVersion, int32_t SubpixelBits, const char* Vendor, const char* Version, ShaderPrecisionFormat VertexShaderPrecisionFormat, ShaderPrecisionFormat FragmentShaderPrecisionFormat, int32_t MajorVersion, int32_t Max3dTextureSize, int32_t MaxArrayTextureLayers, int32_t MaxColorAttachments, int64_t MaxCombinedFragmentUniformComponents, int32_t MaxCombinedUniformBlocks, int64_t MaxCombinedVertexUniformComponents, int32_t MaxDrawBuffers, int32_t MaxElementsIndices, int32_t MaxElementsVertices, int64_t MaxElementIndex, int32_t MaxFragmentInputComponents, int32_t MaxFragmentUniformBlocks, int32_t MaxFragmentUniformComponents, int32_t MaxProgramTexelOffset, int64_t MaxServerWaitTimeout, float MaxTextureLodBias, int32_t MaxTransformFeedbackInterleavedComponents, int32_t MaxTransformFeedbackSeparateAttribs, int32_t MaxTransformFeedbackSeparateComponents, int64_t MaxUniformBlockSize, int32_t MaxUniformBufferBindings, int32_t MaxVaryingComponents, int32_t MaxVertexOutputComponents, int32_t MaxVertexUniformBlocks, int32_t MaxVertexUniformComponents, int32_t MinorVersion, int32_t MinProgramTexelOffset, const gapic::Map<uint32_t, uint32_t>& ProgramBinaryFormats, int32_t UniformBufferOffsetAlignment, int32_t MaxAtomicCounterBufferBindings, int32_t MaxAtomicCounterBufferSize, int32_t MaxColorTextureSamples, int32_t MaxCombinedAtomicCounters, int32_t MaxCombinedAtomicCounterBuffers, int32_t MaxCombinedComputeUniformComponents, int32_t MaxCombinedImageUniforms, int32_t MaxCombinedShaderOutputResources, int32_t MaxCombinedShaderStorageBlocks, int32_t MaxComputeAtomicCounters, int32_t MaxComputeAtomicCounterBuffers, int32_t MaxComputeImageUniforms, int32_t MaxComputeShaderStorageBlocks, int32_t MaxComputeSharedMemorySize, int32_t MaxComputeTextureImageUnits, int32_t MaxComputeUniformBlocks, int32_t MaxComputeUniformComponents, GLint__3__A MaxComputeWorkGroupCount, int32_t MaxComputeWorkGroupInvocations, GLint__3__A MaxComputeWorkGroupSize, int32_t MaxDepthTextureSamples, int32_t MaxFragmentAtomicCounters, int32_t MaxFragmentAtomicCounterBuffers, int32_t MaxFragmentImageUniforms, int32_t MaxFragmentShaderStorageBlocks, int32_t MaxFramebufferHeight, int32_t MaxFramebufferSamples, int32_t MaxFramebufferWidth, int32_t MaxImageUnits, int32_t MaxIntegerSamples, int32_t MaxProgramTextureGatherOffset, int32_t MaxSampleMaskWords, int64_t MaxShaderStorageBlockSize, int32_t MaxShaderStorageBufferBindings, int32_t MaxUniformLocations, int32_t MaxVertexAtomicCounters, int32_t MaxVertexAtomicCounterBuffers, int32_t MaxVertexAttribBindings, int32_t MaxVertexAttribRelativeOffset, int32_t MaxVertexAttribStride, int32_t MaxVertexImageUniforms, int32_t MaxVertexShaderStorageBlocks, int32_t MinProgramTextureGatherOffset, int32_t ShaderStorageBufferOffsetAlignment, int32_t ContextFlags, int32_t FragmentInterpolationOffsetBits, uint32_t LayerProvokingVertex, int32_t MaxCombinedGeometryUniformComponents, int32_t MaxCombinedTessControlUniformComponents, int32_t MaxCombinedTessEvaluationUniformComponents, int32_t MaxDebugGroupStackDepth, int32_t MaxDebugLoggedMessages, int32_t MaxDebugMessageLength, float MaxFragmentInterpolationOffset, int32_t MaxFramebufferLayers, int32_t MaxGeometryAtomicCounters, int32_t MaxGeometryAtomicCounterBuffers, int32_t MaxGeometryImageUniforms, int32_t MaxGeometryInputComponents, int32_t MaxGeometryOutputComponents, int32_t MaxGeometryOutputVertices, int32_t MaxGeometryShaderInvocations, int32_t MaxGeometryShaderStorageBlocks, int32_t MaxGeometryTextureImageUnits, int32_t MaxGeometryTotalOutputComponents, int32_t MaxGeometryUniformBlocks, int32_t MaxGeometryUniformComponents, int32_t MaxLabelLength, int32_t MaxPatchVertices, int32_t MaxTessControlAtomicCounters, int32_t MaxTessControlAtomicCounterBuffers, int32_t MaxTessControlImageUniforms, int32_t MaxTessControlInputComponents, int32_t MaxTessControlOutputComponents, int32_t MaxTessControlShaderStorageBlocks, int32_t MaxTessControlTextureImageUnits, int32_t MaxTessControlTotalOutputComponents, int32_t MaxTessControlUniformBlocks, int32_t MaxTessControlUniformComponents, int32_t MaxTessEvaluationAtomicCounters, int32_t MaxTessEvaluationAtomicCounterBuffers, int32_t MaxTessEvaluationImageUniforms, int32_t MaxTessEvaluationInputComponents, int32_t MaxTessEvaluationOutputComponents, int32_t MaxTessEvaluationShaderStorageBlocks, int32_t MaxTessEvaluationTextureImageUnits, int32_t MaxTessEvaluationUniformBlocks, int32_t MaxTessEvaluationUniformComponents, int32_t MaxTessGenLevel, int32_t MaxTessPatchComponents, int32_t MaxTextureBufferSize, float MinFragmentInterpolationOffset, float MultisampleLineWidthGranularity, GLfloat__2__A MultisampleLineWidthRange, uint8_t PrimitiveRestartForPatchesSupported, int32_t TextureBufferOffsetAlignment, float MaxTextureMaxAnisotropyExt)
                : mAliasedLineWidthRange(AliasedLineWidthRange)
                , mAliasedPointSizeRange(AliasedPointSizeRange)
                , mCompressedTextureFormats(CompressedTextureFormats)
                , mExtensions(Extensions)
                , mMaxCombinedTextureImageUnits(MaxCombinedTextureImageUnits)
                , mMaxCubeMapTextureSize(MaxCubeMapTextureSize)
                , mMaxFragmentUniformVectors(MaxFragmentUniformVectors)
                , mMaxRenderbufferSize(MaxRenderbufferSize)
                , mMaxTextureImageUnits(MaxTextureImageUnits)
                , mMaxTextureSize(MaxTextureSize)
                , mMaxVaryingVectors(MaxVaryingVectors)
                , mMaxVertexAttribs(MaxVertexAttribs)
                , mMaxVertexTextureImageUnits(MaxVertexTextureImageUnits)
                , mMaxVertexUniformVectors(MaxVertexUniformVectors)
                , mMaxViewportDims(MaxViewportDims)
                , mRenderer(Renderer)
                , mShaderBinaryFormats(ShaderBinaryFormats)
                , mShaderCompiler(ShaderCompiler)
                , mShadingLanguageVersion(ShadingLanguageVersion)
                , mSubpixelBits(SubpixelBits)
                , mVendor(Vendor)
                , mVersion(Version)
                , mVertexShaderPrecisionFormat(VertexShaderPrecisionFormat)
                , mFragmentShaderPrecisionFormat(FragmentShaderPrecisionFormat)
                , mMajorVersion(MajorVersion)
                , mMax3dTextureSize(Max3dTextureSize)
                , mMaxArrayTextureLayers(MaxArrayTextureLayers)
                , mMaxColorAttachments(MaxColorAttachments)
                , mMaxCombinedFragmentUniformComponents(MaxCombinedFragmentUniformComponents)
                , mMaxCombinedUniformBlocks(MaxCombinedUniformBlocks)
                , mMaxCombinedVertexUniformComponents(MaxCombinedVertexUniformComponents)
                , mMaxDrawBuffers(MaxDrawBuffers)
                , mMaxElementsIndices(MaxElementsIndices)
                , mMaxElementsVertices(MaxElementsVertices)
                , mMaxElementIndex(MaxElementIndex)
                , mMaxFragmentInputComponents(MaxFragmentInputComponents)
                , mMaxFragmentUniformBlocks(MaxFragmentUniformBlocks)
                , mMaxFragmentUniformComponents(MaxFragmentUniformComponents)
                , mMaxProgramTexelOffset(MaxProgramTexelOffset)
                , mMaxServerWaitTimeout(MaxServerWaitTimeout)
                , mMaxTextureLodBias(MaxTextureLodBias)
                , mMaxTransformFeedbackInterleavedComponents(MaxTransformFeedbackInterleavedComponents)
                , mMaxTransformFeedbackSeparateAttribs(MaxTransformFeedbackSeparateAttribs)
                , mMaxTransformFeedbackSeparateComponents(MaxTransformFeedbackSeparateComponents)
                , mMaxUniformBlockSize(MaxUniformBlockSize)
                , mMaxUniformBufferBindings(MaxUniformBufferBindings)
                , mMaxVaryingComponents(MaxVaryingComponents)
                , mMaxVertexOutputComponents(MaxVertexOutputComponents)
                , mMaxVertexUniformBlocks(MaxVertexUniformBlocks)
                , mMaxVertexUniformComponents(MaxVertexUniformComponents)
                , mMinorVersion(MinorVersion)
                , mMinProgramTexelOffset(MinProgramTexelOffset)
                , mProgramBinaryFormats(ProgramBinaryFormats)
                , mUniformBufferOffsetAlignment(UniformBufferOffsetAlignment)
                , mMaxAtomicCounterBufferBindings(MaxAtomicCounterBufferBindings)
                , mMaxAtomicCounterBufferSize(MaxAtomicCounterBufferSize)
                , mMaxColorTextureSamples(MaxColorTextureSamples)
                , mMaxCombinedAtomicCounters(MaxCombinedAtomicCounters)
                , mMaxCombinedAtomicCounterBuffers(MaxCombinedAtomicCounterBuffers)
                , mMaxCombinedComputeUniformComponents(MaxCombinedComputeUniformComponents)
                , mMaxCombinedImageUniforms(MaxCombinedImageUniforms)
                , mMaxCombinedShaderOutputResources(MaxCombinedShaderOutputResources)
                , mMaxCombinedShaderStorageBlocks(MaxCombinedShaderStorageBlocks)
                , mMaxComputeAtomicCounters(MaxComputeAtomicCounters)
                , mMaxComputeAtomicCounterBuffers(MaxComputeAtomicCounterBuffers)
                , mMaxComputeImageUniforms(MaxComputeImageUniforms)
                , mMaxComputeShaderStorageBlocks(MaxComputeShaderStorageBlocks)
                , mMaxComputeSharedMemorySize(MaxComputeSharedMemorySize)
                , mMaxComputeTextureImageUnits(MaxComputeTextureImageUnits)
                , mMaxComputeUniformBlocks(MaxComputeUniformBlocks)
                , mMaxComputeUniformComponents(MaxComputeUniformComponents)
                , mMaxComputeWorkGroupCount(MaxComputeWorkGroupCount)
                , mMaxComputeWorkGroupInvocations(MaxComputeWorkGroupInvocations)
                , mMaxComputeWorkGroupSize(MaxComputeWorkGroupSize)
                , mMaxDepthTextureSamples(MaxDepthTextureSamples)
                , mMaxFragmentAtomicCounters(MaxFragmentAtomicCounters)
                , mMaxFragmentAtomicCounterBuffers(MaxFragmentAtomicCounterBuffers)
                , mMaxFragmentImageUniforms(MaxFragmentImageUniforms)
                , mMaxFragmentShaderStorageBlocks(MaxFragmentShaderStorageBlocks)
                , mMaxFramebufferHeight(MaxFramebufferHeight)
                , mMaxFramebufferSamples(MaxFramebufferSamples)
                , mMaxFramebufferWidth(MaxFramebufferWidth)
                , mMaxImageUnits(MaxImageUnits)
                , mMaxIntegerSamples(MaxIntegerSamples)
                , mMaxProgramTextureGatherOffset(MaxProgramTextureGatherOffset)
                , mMaxSampleMaskWords(MaxSampleMaskWords)
                , mMaxShaderStorageBlockSize(MaxShaderStorageBlockSize)
                , mMaxShaderStorageBufferBindings(MaxShaderStorageBufferBindings)
                , mMaxUniformLocations(MaxUniformLocations)
                , mMaxVertexAtomicCounters(MaxVertexAtomicCounters)
                , mMaxVertexAtomicCounterBuffers(MaxVertexAtomicCounterBuffers)
                , mMaxVertexAttribBindings(MaxVertexAttribBindings)
                , mMaxVertexAttribRelativeOffset(MaxVertexAttribRelativeOffset)
                , mMaxVertexAttribStride(MaxVertexAttribStride)
                , mMaxVertexImageUniforms(MaxVertexImageUniforms)
                , mMaxVertexShaderStorageBlocks(MaxVertexShaderStorageBlocks)
                , mMinProgramTextureGatherOffset(MinProgramTextureGatherOffset)
                , mShaderStorageBufferOffsetAlignment(ShaderStorageBufferOffsetAlignment)
                , mContextFlags(ContextFlags)
                , mFragmentInterpolationOffsetBits(FragmentInterpolationOffsetBits)
                , mLayerProvokingVertex(LayerProvokingVertex)
                , mMaxCombinedGeometryUniformComponents(MaxCombinedGeometryUniformComponents)
                , mMaxCombinedTessControlUniformComponents(MaxCombinedTessControlUniformComponents)
                , mMaxCombinedTessEvaluationUniformComponents(MaxCombinedTessEvaluationUniformComponents)
                , mMaxDebugGroupStackDepth(MaxDebugGroupStackDepth)
                , mMaxDebugLoggedMessages(MaxDebugLoggedMessages)
                , mMaxDebugMessageLength(MaxDebugMessageLength)
                , mMaxFragmentInterpolationOffset(MaxFragmentInterpolationOffset)
                , mMaxFramebufferLayers(MaxFramebufferLayers)
                , mMaxGeometryAtomicCounters(MaxGeometryAtomicCounters)
                , mMaxGeometryAtomicCounterBuffers(MaxGeometryAtomicCounterBuffers)
                , mMaxGeometryImageUniforms(MaxGeometryImageUniforms)
                , mMaxGeometryInputComponents(MaxGeometryInputComponents)
                , mMaxGeometryOutputComponents(MaxGeometryOutputComponents)
                , mMaxGeometryOutputVertices(MaxGeometryOutputVertices)
                , mMaxGeometryShaderInvocations(MaxGeometryShaderInvocations)
                , mMaxGeometryShaderStorageBlocks(MaxGeometryShaderStorageBlocks)
                , mMaxGeometryTextureImageUnits(MaxGeometryTextureImageUnits)
                , mMaxGeometryTotalOutputComponents(MaxGeometryTotalOutputComponents)
                , mMaxGeometryUniformBlocks(MaxGeometryUniformBlocks)
                , mMaxGeometryUniformComponents(MaxGeometryUniformComponents)
                , mMaxLabelLength(MaxLabelLength)
                , mMaxPatchVertices(MaxPatchVertices)
                , mMaxTessControlAtomicCounters(MaxTessControlAtomicCounters)
                , mMaxTessControlAtomicCounterBuffers(MaxTessControlAtomicCounterBuffers)
                , mMaxTessControlImageUniforms(MaxTessControlImageUniforms)
                , mMaxTessControlInputComponents(MaxTessControlInputComponents)
                , mMaxTessControlOutputComponents(MaxTessControlOutputComponents)
                , mMaxTessControlShaderStorageBlocks(MaxTessControlShaderStorageBlocks)
                , mMaxTessControlTextureImageUnits(MaxTessControlTextureImageUnits)
                , mMaxTessControlTotalOutputComponents(MaxTessControlTotalOutputComponents)
                , mMaxTessControlUniformBlocks(MaxTessControlUniformBlocks)
                , mMaxTessControlUniformComponents(MaxTessControlUniformComponents)
                , mMaxTessEvaluationAtomicCounters(MaxTessEvaluationAtomicCounters)
                , mMaxTessEvaluationAtomicCounterBuffers(MaxTessEvaluationAtomicCounterBuffers)
                , mMaxTessEvaluationImageUniforms(MaxTessEvaluationImageUniforms)
                , mMaxTessEvaluationInputComponents(MaxTessEvaluationInputComponents)
                , mMaxTessEvaluationOutputComponents(MaxTessEvaluationOutputComponents)
                , mMaxTessEvaluationShaderStorageBlocks(MaxTessEvaluationShaderStorageBlocks)
                , mMaxTessEvaluationTextureImageUnits(MaxTessEvaluationTextureImageUnits)
                , mMaxTessEvaluationUniformBlocks(MaxTessEvaluationUniformBlocks)
                , mMaxTessEvaluationUniformComponents(MaxTessEvaluationUniformComponents)
                , mMaxTessGenLevel(MaxTessGenLevel)
                , mMaxTessPatchComponents(MaxTessPatchComponents)
                , mMaxTextureBufferSize(MaxTextureBufferSize)
                , mMinFragmentInterpolationOffset(MinFragmentInterpolationOffset)
                , mMultisampleLineWidthGranularity(MultisampleLineWidthGranularity)
                , mMultisampleLineWidthRange(MultisampleLineWidthRange)
                , mPrimitiveRestartForPatchesSupported(PrimitiveRestartForPatchesSupported)
                , mTextureBufferOffsetAlignment(TextureBufferOffsetAlignment)
                , mMaxTextureMaxAnisotropyExt(MaxTextureMaxAnisotropyExt) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        GLfloat__2__A mAliasedLineWidthRange;
        GLfloat__2__A mAliasedPointSizeRange;
        gapic::Map<uint32_t, uint32_t> mCompressedTextureFormats;
        gapic::Map<uint32_t, const char*> mExtensions;
        int32_t mMaxCombinedTextureImageUnits;
        int32_t mMaxCubeMapTextureSize;
        int32_t mMaxFragmentUniformVectors;
        int32_t mMaxRenderbufferSize;
        int32_t mMaxTextureImageUnits;
        int32_t mMaxTextureSize;
        int32_t mMaxVaryingVectors;
        int32_t mMaxVertexAttribs;
        int32_t mMaxVertexTextureImageUnits;
        int32_t mMaxVertexUniformVectors;
        GLint__2__A mMaxViewportDims;
        const char* mRenderer;
        gapic::Map<uint32_t, uint32_t> mShaderBinaryFormats;
        uint8_t mShaderCompiler;
        const char* mShadingLanguageVersion;
        int32_t mSubpixelBits;
        const char* mVendor;
        const char* mVersion;
        ShaderPrecisionFormat mVertexShaderPrecisionFormat;
        ShaderPrecisionFormat mFragmentShaderPrecisionFormat;
        int32_t mMajorVersion;
        int32_t mMax3dTextureSize;
        int32_t mMaxArrayTextureLayers;
        int32_t mMaxColorAttachments;
        int64_t mMaxCombinedFragmentUniformComponents;
        int32_t mMaxCombinedUniformBlocks;
        int64_t mMaxCombinedVertexUniformComponents;
        int32_t mMaxDrawBuffers;
        int32_t mMaxElementsIndices;
        int32_t mMaxElementsVertices;
        int64_t mMaxElementIndex;
        int32_t mMaxFragmentInputComponents;
        int32_t mMaxFragmentUniformBlocks;
        int32_t mMaxFragmentUniformComponents;
        int32_t mMaxProgramTexelOffset;
        int64_t mMaxServerWaitTimeout;
        float mMaxTextureLodBias;
        int32_t mMaxTransformFeedbackInterleavedComponents;
        int32_t mMaxTransformFeedbackSeparateAttribs;
        int32_t mMaxTransformFeedbackSeparateComponents;
        int64_t mMaxUniformBlockSize;
        int32_t mMaxUniformBufferBindings;
        int32_t mMaxVaryingComponents;
        int32_t mMaxVertexOutputComponents;
        int32_t mMaxVertexUniformBlocks;
        int32_t mMaxVertexUniformComponents;
        int32_t mMinorVersion;
        int32_t mMinProgramTexelOffset;
        gapic::Map<uint32_t, uint32_t> mProgramBinaryFormats;
        int32_t mUniformBufferOffsetAlignment;
        int32_t mMaxAtomicCounterBufferBindings;
        int32_t mMaxAtomicCounterBufferSize;
        int32_t mMaxColorTextureSamples;
        int32_t mMaxCombinedAtomicCounters;
        int32_t mMaxCombinedAtomicCounterBuffers;
        int32_t mMaxCombinedComputeUniformComponents;
        int32_t mMaxCombinedImageUniforms;
        int32_t mMaxCombinedShaderOutputResources;
        int32_t mMaxCombinedShaderStorageBlocks;
        int32_t mMaxComputeAtomicCounters;
        int32_t mMaxComputeAtomicCounterBuffers;
        int32_t mMaxComputeImageUniforms;
        int32_t mMaxComputeShaderStorageBlocks;
        int32_t mMaxComputeSharedMemorySize;
        int32_t mMaxComputeTextureImageUnits;
        int32_t mMaxComputeUniformBlocks;
        int32_t mMaxComputeUniformComponents;
        GLint__3__A mMaxComputeWorkGroupCount;
        int32_t mMaxComputeWorkGroupInvocations;
        GLint__3__A mMaxComputeWorkGroupSize;
        int32_t mMaxDepthTextureSamples;
        int32_t mMaxFragmentAtomicCounters;
        int32_t mMaxFragmentAtomicCounterBuffers;
        int32_t mMaxFragmentImageUniforms;
        int32_t mMaxFragmentShaderStorageBlocks;
        int32_t mMaxFramebufferHeight;
        int32_t mMaxFramebufferSamples;
        int32_t mMaxFramebufferWidth;
        int32_t mMaxImageUnits;
        int32_t mMaxIntegerSamples;
        int32_t mMaxProgramTextureGatherOffset;
        int32_t mMaxSampleMaskWords;
        int64_t mMaxShaderStorageBlockSize;
        int32_t mMaxShaderStorageBufferBindings;
        int32_t mMaxUniformLocations;
        int32_t mMaxVertexAtomicCounters;
        int32_t mMaxVertexAtomicCounterBuffers;
        int32_t mMaxVertexAttribBindings;
        int32_t mMaxVertexAttribRelativeOffset;
        int32_t mMaxVertexAttribStride;
        int32_t mMaxVertexImageUniforms;
        int32_t mMaxVertexShaderStorageBlocks;
        int32_t mMinProgramTextureGatherOffset;
        int32_t mShaderStorageBufferOffsetAlignment;
        int32_t mContextFlags;
        int32_t mFragmentInterpolationOffsetBits;
        uint32_t mLayerProvokingVertex;
        int32_t mMaxCombinedGeometryUniformComponents;
        int32_t mMaxCombinedTessControlUniformComponents;
        int32_t mMaxCombinedTessEvaluationUniformComponents;
        int32_t mMaxDebugGroupStackDepth;
        int32_t mMaxDebugLoggedMessages;
        int32_t mMaxDebugMessageLength;
        float mMaxFragmentInterpolationOffset;
        int32_t mMaxFramebufferLayers;
        int32_t mMaxGeometryAtomicCounters;
        int32_t mMaxGeometryAtomicCounterBuffers;
        int32_t mMaxGeometryImageUniforms;
        int32_t mMaxGeometryInputComponents;
        int32_t mMaxGeometryOutputComponents;
        int32_t mMaxGeometryOutputVertices;
        int32_t mMaxGeometryShaderInvocations;
        int32_t mMaxGeometryShaderStorageBlocks;
        int32_t mMaxGeometryTextureImageUnits;
        int32_t mMaxGeometryTotalOutputComponents;
        int32_t mMaxGeometryUniformBlocks;
        int32_t mMaxGeometryUniformComponents;
        int32_t mMaxLabelLength;
        int32_t mMaxPatchVertices;
        int32_t mMaxTessControlAtomicCounters;
        int32_t mMaxTessControlAtomicCounterBuffers;
        int32_t mMaxTessControlImageUniforms;
        int32_t mMaxTessControlInputComponents;
        int32_t mMaxTessControlOutputComponents;
        int32_t mMaxTessControlShaderStorageBlocks;
        int32_t mMaxTessControlTextureImageUnits;
        int32_t mMaxTessControlTotalOutputComponents;
        int32_t mMaxTessControlUniformBlocks;
        int32_t mMaxTessControlUniformComponents;
        int32_t mMaxTessEvaluationAtomicCounters;
        int32_t mMaxTessEvaluationAtomicCounterBuffers;
        int32_t mMaxTessEvaluationImageUniforms;
        int32_t mMaxTessEvaluationInputComponents;
        int32_t mMaxTessEvaluationOutputComponents;
        int32_t mMaxTessEvaluationShaderStorageBlocks;
        int32_t mMaxTessEvaluationTextureImageUnits;
        int32_t mMaxTessEvaluationUniformBlocks;
        int32_t mMaxTessEvaluationUniformComponents;
        int32_t mMaxTessGenLevel;
        int32_t mMaxTessPatchComponents;
        int32_t mMaxTextureBufferSize;
        float mMinFragmentInterpolationOffset;
        float mMultisampleLineWidthGranularity;
        GLfloat__2__A mMultisampleLineWidthRange;
        uint8_t mPrimitiveRestartForPatchesSupported;
        int32_t mTextureBufferOffsetAlignment;
        float mMaxTextureMaxAnisotropyExt;
    };

    class GLDEBUGPROC: public Encodable {
    public:
        GLDEBUGPROC() = default;
        GLDEBUGPROC(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class Void__CP: public Encodable {
    public:
        Void__CP() = default;
        Void__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class Vec2f: public Encodable {
    public:
        Vec2f() = default;
        Vec2f(const gapic::StaticArray<float, 2>& Elements)
                : mElements(Elements) {}
        virtual void Encode(Encoder* e) const{
            for (int i = 0; i < 2; i++) {
                e->Float32(this->mElements[i]);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::StaticArray<float, 2> mElements;
    };

    class Vec4b: public Encodable {
    public:
        Vec4b() = default;
        Vec4b(const gapic::StaticArray<uint8_t, 4>& Elements)
                : mElements(Elements) {}
        virtual void Encode(Encoder* e) const{
            for (int i = 0; i < 4; i++) {
                e->Uint8(this->mElements[i]);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::StaticArray<uint8_t, 4> mElements;
    };

    class GLchar__S: public Encodable {
    public:
        GLchar__S() = default;
        GLchar__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class Uniform: public Encodable {
    public:
        Uniform() = default;
        Uniform(U8__S Value, uint32_t Type)
                : mValue(Value)
                , mType(Type) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mValue);
            e->Uint32(this->mType);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        U8__S mValue;
        uint32_t mType;
    };

    class VertexPointer: public Encodable {
    public:
        VertexPointer() = default;
        VertexPointer(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class GLsync: public Encodable {
    public:
        GLsync() = default;
        GLsync(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class GLenum__P: public Encodable {
    public:
        GLenum__P() = default;
        GLenum__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class U32__P: public Encodable {
    public:
        U32__P() = default;
        U32__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class ContextInfo: public Encodable {
    public:
        ContextInfo() = default;
        ContextInfo(const gapic::Vector<gapic::Encodable*>& extras, uint32_t ConstantCount, GLenum__P ConstantNames, U32__P ConstantOffsets, U32__P ConstantSizes, U8__P ConstantData, int32_t BackbufferWidth, int32_t BackbufferHeight, uint32_t BackbufferColorFmt, uint32_t BackbufferDepthFmt, uint32_t BackbufferStencilFmt, bool ResetViewportScissor, bool PreserveBuffersOnSwap)
                : mextras(extras)
                , mConstantCount(ConstantCount)
                , mConstantNames(ConstantNames)
                , mConstantOffsets(ConstantOffsets)
                , mConstantSizes(ConstantSizes)
                , mConstantData(ConstantData)
                , mBackbufferWidth(BackbufferWidth)
                , mBackbufferHeight(BackbufferHeight)
                , mBackbufferColorFmt(BackbufferColorFmt)
                , mBackbufferDepthFmt(BackbufferDepthFmt)
                , mBackbufferStencilFmt(BackbufferStencilFmt)
                , mResetViewportScissor(ResetViewportScissor)
                , mPreserveBuffersOnSwap(PreserveBuffersOnSwap) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mConstantCount;
        GLenum__P mConstantNames;
        U32__P mConstantOffsets;
        U32__P mConstantSizes;
        U8__P mConstantData;
        int32_t mBackbufferWidth;
        int32_t mBackbufferHeight;
        uint32_t mBackbufferColorFmt;
        uint32_t mBackbufferDepthFmt;
        uint32_t mBackbufferStencilFmt;
        bool mResetViewportScissor;
        bool mPreserveBuffersOnSwap;
    };

    class DeviceInfo: public Encodable {
    public:
        DeviceInfo() = default;
        DeviceInfo(const char* ProductManufacturer, const char* ProductModel, const char* BuildDescription, const char* BuildVersionRelease, const char* BuildVersionSdk, const char* Debuggable, const char* AbiList)
                : mProductManufacturer(ProductManufacturer)
                , mProductModel(ProductModel)
                , mBuildDescription(BuildDescription)
                , mBuildVersionRelease(BuildVersionRelease)
                , mBuildVersionSdk(BuildVersionSdk)
                , mDebuggable(Debuggable)
                , mAbiList(AbiList) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        const char* mProductManufacturer;
        const char* mProductModel;
        const char* mBuildDescription;
        const char* mBuildVersionRelease;
        const char* mBuildVersionSdk;
        const char* mDebuggable;
        const char* mAbiList;
    };

    class DynamicContextState: public Encodable {
    public:
        DynamicContextState() = default;
        DynamicContextState(int32_t BackbufferWidth, int32_t BackbufferHeight, uint32_t BackbufferColorFmt, uint32_t BackbufferDepthFmt, uint32_t BackbufferStencilFmt, bool ResetViewportScissor, bool PreserveBuffersOnSwap, uint32_t RedSize, uint32_t GreenSize, uint32_t BlueSize, uint32_t AlphaSize, uint32_t DepthSize, uint32_t StencilSize)
                : mBackbufferWidth(BackbufferWidth)
                , mBackbufferHeight(BackbufferHeight)
                , mBackbufferColorFmt(BackbufferColorFmt)
                , mBackbufferDepthFmt(BackbufferDepthFmt)
                , mBackbufferStencilFmt(BackbufferStencilFmt)
                , mResetViewportScissor(ResetViewportScissor)
                , mPreserveBuffersOnSwap(PreserveBuffersOnSwap)
                , mRedSize(RedSize)
                , mGreenSize(GreenSize)
                , mBlueSize(BlueSize)
                , mAlphaSize(AlphaSize)
                , mDepthSize(DepthSize)
                , mStencilSize(StencilSize) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        int32_t mBackbufferWidth;
        int32_t mBackbufferHeight;
        uint32_t mBackbufferColorFmt;
        uint32_t mBackbufferDepthFmt;
        uint32_t mBackbufferStencilFmt;
        bool mResetViewportScissor;
        bool mPreserveBuffersOnSwap;
        uint32_t mRedSize;
        uint32_t mGreenSize;
        uint32_t mBlueSize;
        uint32_t mAlphaSize;
        uint32_t mDepthSize;
        uint32_t mStencilSize;
    };

    class EGLClientBuffer: public Encodable {
    public:
        EGLClientBuffer() = default;
        EGLClientBuffer(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class EGLConfig: public Encodable {
    public:
        EGLConfig() = default;
        EGLConfig(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class EGLConfig__S: public Encodable {
    public:
        EGLConfig__S() = default;
        EGLConfig__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class EGLConfig__P: public Encodable {
    public:
        EGLConfig__P() = default;
        EGLConfig__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class EGLContext: public Encodable {
    public:
        EGLContext() = default;
        EGLContext(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class EGLDisplay: public Encodable {
    public:
        EGLDisplay() = default;
        EGLDisplay(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class EGLImageKHR: public Encodable {
    public:
        EGLImageKHR() = default;
        EGLImageKHR(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class EGLNativePixmapType: public Encodable {
    public:
        EGLNativePixmapType() = default;
        EGLNativePixmapType(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class EGLNativeWindowType: public Encodable {
    public:
        EGLNativeWindowType() = default;
        EGLNativeWindowType(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class EGLSurface: public Encodable {
    public:
        EGLSurface() = default;
        EGLSurface(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class EGLSyncKHR: public Encodable {
    public:
        EGLSyncKHR() = default;
        EGLSyncKHR(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class EGLint__S: public Encodable {
    public:
        EGLint__S() = default;
        EGLint__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class EGLint__P: public Encodable {
    public:
        EGLint__P() = default;
        EGLint__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class EGLint__CP: public Encodable {
    public:
        EGLint__CP() = default;
        EGLint__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class EglBindAPI: public Encodable {
    public:
        EglBindAPI() = default;
        EglBindAPI(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Api, int64_t Result)
                : mextras(extras)
                , mApi(Api)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mApi);
            e->Int64(this->mResult);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mApi;
        int64_t mResult;
    };

    class EglBindTexImage: public Encodable {
    public:
        EglBindTexImage() = default;
        EglBindTexImage(const gapic::Vector<gapic::Encodable*>& extras, EGLDisplay Display, EGLSurface Surface, int64_t Buffer, int64_t Result)
                : mextras(extras)
                , mDisplay(Display)
                , mSurface(Surface)
                , mBuffer(Buffer)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        EGLDisplay mDisplay;
        EGLSurface mSurface;
        int64_t mBuffer;
        int64_t mResult;
    };

    class EglChooseConfig: public Encodable {
    public:
        EglChooseConfig() = default;
        EglChooseConfig(const gapic::Vector<gapic::Encodable*>& extras, EGLDisplay Display, EGLint__CP AttribList, EGLConfig__P Configs, int64_t ConfigSize, EGLint__P NumConfig, int64_t Result)
                : mextras(extras)
                , mDisplay(Display)
                , mAttribList(AttribList)
                , mConfigs(Configs)
                , mConfigSize(ConfigSize)
                , mNumConfig(NumConfig)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        EGLDisplay mDisplay;
        EGLint__CP mAttribList;
        EGLConfig__P mConfigs;
        int64_t mConfigSize;
        EGLint__P mNumConfig;
        int64_t mResult;
    };

    class EglClientWaitSyncKHR: public Encodable {
    public:
        EglClientWaitSyncKHR() = default;
        EglClientWaitSyncKHR(const gapic::Vector<gapic::Encodable*>& extras, EGLDisplay Dpy, EGLSyncKHR Sync, int64_t SyncFlags, uint64_t Timeout, int64_t Result)
                : mextras(extras)
                , mDpy(Dpy)
                , mSync(Sync)
                , mSyncFlags(SyncFlags)
                , mTimeout(Timeout)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        EGLDisplay mDpy;
        EGLSyncKHR mSync;
        int64_t mSyncFlags;
        uint64_t mTimeout;
        int64_t mResult;
    };

    class EglCopyBuffers: public Encodable {
    public:
        EglCopyBuffers() = default;
        EglCopyBuffers(const gapic::Vector<gapic::Encodable*>& extras, EGLDisplay Display, EGLSurface Surface, EGLNativePixmapType NativePixmap, int64_t Result)
                : mextras(extras)
                , mDisplay(Display)
                , mSurface(Surface)
                , mNativePixmap(NativePixmap)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        EGLDisplay mDisplay;
        EGLSurface mSurface;
        EGLNativePixmapType mNativePixmap;
        int64_t mResult;
    };

    class EglCreateContext: public Encodable {
    public:
        EglCreateContext() = default;
        EglCreateContext(const gapic::Vector<gapic::Encodable*>& extras, EGLDisplay Display, EGLConfig Config, EGLContext ShareContext, EGLint__P AttribList, EGLContext Result)
                : mextras(extras)
                , mDisplay(Display)
                , mConfig(Config)
                , mShareContext(ShareContext)
                , mAttribList(AttribList)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        EGLDisplay mDisplay;
        EGLConfig mConfig;
        EGLContext mShareContext;
        EGLint__P mAttribList;
        EGLContext mResult;
    };

    class EglCreateImageKHR: public Encodable {
    public:
        EglCreateImageKHR() = default;
        EglCreateImageKHR(const gapic::Vector<gapic::Encodable*>& extras, EGLDisplay Dpy, EGLContext Ctx, uint32_t Target, EGLClientBuffer Buffer, EGLint__CP AttribList, EGLImageKHR Result)
                : mextras(extras)
                , mDpy(Dpy)
                , mCtx(Ctx)
                , mTarget(Target)
                , mBuffer(Buffer)
                , mAttribList(AttribList)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        EGLDisplay mDpy;
        EGLContext mCtx;
        uint32_t mTarget;
        EGLClientBuffer mBuffer;
        EGLint__CP mAttribList;
        EGLImageKHR mResult;
    };

    class EglCreatePbufferFromClientBuffer: public Encodable {
    public:
        EglCreatePbufferFromClientBuffer() = default;
        EglCreatePbufferFromClientBuffer(const gapic::Vector<gapic::Encodable*>& extras, EGLDisplay Display, uint32_t Buftype, EGLClientBuffer Buffer, EGLConfig Config, EGLint__CP AttribList, EGLSurface Result)
                : mextras(extras)
                , mDisplay(Display)
                , mBuftype(Buftype)
                , mBuffer(Buffer)
                , mConfig(Config)
                , mAttribList(AttribList)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        EGLDisplay mDisplay;
        uint32_t mBuftype;
        EGLClientBuffer mBuffer;
        EGLConfig mConfig;
        EGLint__CP mAttribList;
        EGLSurface mResult;
    };

    class EglCreatePbufferSurface: public Encodable {
    public:
        EglCreatePbufferSurface() = default;
        EglCreatePbufferSurface(const gapic::Vector<gapic::Encodable*>& extras, EGLDisplay Display, EGLConfig Config, EGLint__CP AttribList, EGLSurface Result)
                : mextras(extras)
                , mDisplay(Display)
                , mConfig(Config)
                , mAttribList(AttribList)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        EGLDisplay mDisplay;
        EGLConfig mConfig;
        EGLint__CP mAttribList;
        EGLSurface mResult;
    };

    class EglCreatePixmapSurface: public Encodable {
    public:
        EglCreatePixmapSurface() = default;
        EglCreatePixmapSurface(const gapic::Vector<gapic::Encodable*>& extras, EGLDisplay Display, EGLConfig Config, EGLNativePixmapType NativePixmap, EGLint__CP AttribList, EGLSurface Result)
                : mextras(extras)
                , mDisplay(Display)
                , mConfig(Config)
                , mNativePixmap(NativePixmap)
                , mAttribList(AttribList)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        EGLDisplay mDisplay;
        EGLConfig mConfig;
        EGLNativePixmapType mNativePixmap;
        EGLint__CP mAttribList;
        EGLSurface mResult;
    };

    class EglCreateSyncKHR: public Encodable {
    public:
        EglCreateSyncKHR() = default;
        EglCreateSyncKHR(const gapic::Vector<gapic::Encodable*>& extras, EGLDisplay Dpy, uint32_t Type, EGLint__CP AttribList, EGLSyncKHR Result)
                : mextras(extras)
                , mDpy(Dpy)
                , mType(Type)
                , mAttribList(AttribList)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        EGLDisplay mDpy;
        uint32_t mType;
        EGLint__CP mAttribList;
        EGLSyncKHR mResult;
    };

    class EglCreateWindowSurface: public Encodable {
    public:
        EglCreateWindowSurface() = default;
        EglCreateWindowSurface(const gapic::Vector<gapic::Encodable*>& extras, EGLDisplay Display, EGLConfig Config, EGLNativeWindowType NativeWindow, EGLint__CP AttribList, EGLSurface Result)
                : mextras(extras)
                , mDisplay(Display)
                , mConfig(Config)
                , mNativeWindow(NativeWindow)
                , mAttribList(AttribList)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        EGLDisplay mDisplay;
        EGLConfig mConfig;
        EGLNativeWindowType mNativeWindow;
        EGLint__CP mAttribList;
        EGLSurface mResult;
    };

    class EglDestroyContext: public Encodable {
    public:
        EglDestroyContext() = default;
        EglDestroyContext(const gapic::Vector<gapic::Encodable*>& extras, EGLDisplay Display, EGLContext Context, int64_t Result)
                : mextras(extras)
                , mDisplay(Display)
                , mContext(Context)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        EGLDisplay mDisplay;
        EGLContext mContext;
        int64_t mResult;
    };

    class EglDestroyImageKHR: public Encodable {
    public:
        EglDestroyImageKHR() = default;
        EglDestroyImageKHR(const gapic::Vector<gapic::Encodable*>& extras, EGLDisplay Dpy, EGLImageKHR Image, int64_t Result)
                : mextras(extras)
                , mDpy(Dpy)
                , mImage(Image)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        EGLDisplay mDpy;
        EGLImageKHR mImage;
        int64_t mResult;
    };

    class EglDestroySurface: public Encodable {
    public:
        EglDestroySurface() = default;
        EglDestroySurface(const gapic::Vector<gapic::Encodable*>& extras, EGLDisplay Display, EGLSurface Surface, int64_t Result)
                : mextras(extras)
                , mDisplay(Display)
                , mSurface(Surface)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        EGLDisplay mDisplay;
        EGLSurface mSurface;
        int64_t mResult;
    };

    class EglDestroySyncKHR: public Encodable {
    public:
        EglDestroySyncKHR() = default;
        EglDestroySyncKHR(const gapic::Vector<gapic::Encodable*>& extras, EGLDisplay Dpy, EGLSyncKHR Sync, int64_t Result)
                : mextras(extras)
                , mDpy(Dpy)
                , mSync(Sync)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        EGLDisplay mDpy;
        EGLSyncKHR mSync;
        int64_t mResult;
    };

    class EglGetConfigAttrib: public Encodable {
    public:
        EglGetConfigAttrib() = default;
        EglGetConfigAttrib(const gapic::Vector<gapic::Encodable*>& extras, EGLDisplay Display, EGLConfig Config, int64_t Attribute, EGLint__P Value, int64_t Result)
                : mextras(extras)
                , mDisplay(Display)
                , mConfig(Config)
                , mAttribute(Attribute)
                , mValue(Value)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        EGLDisplay mDisplay;
        EGLConfig mConfig;
        int64_t mAttribute;
        EGLint__P mValue;
        int64_t mResult;
    };

    class EglGetConfigs: public Encodable {
    public:
        EglGetConfigs() = default;
        EglGetConfigs(const gapic::Vector<gapic::Encodable*>& extras, EGLDisplay Display, EGLConfig__P Configs, int64_t ConfigSize, EGLint__P NumConfig, int64_t Result)
                : mextras(extras)
                , mDisplay(Display)
                , mConfigs(Configs)
                , mConfigSize(ConfigSize)
                , mNumConfig(NumConfig)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        EGLDisplay mDisplay;
        EGLConfig__P mConfigs;
        int64_t mConfigSize;
        EGLint__P mNumConfig;
        int64_t mResult;
    };

    class EglGetCurrentContext: public Encodable {
    public:
        EglGetCurrentContext() = default;
        EglGetCurrentContext(const gapic::Vector<gapic::Encodable*>& extras, EGLContext Result)
                : mextras(extras)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Struct(this->mResult);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        EGLContext mResult;
    };

    class EglGetCurrentDisplay: public Encodable {
    public:
        EglGetCurrentDisplay() = default;
        EglGetCurrentDisplay(const gapic::Vector<gapic::Encodable*>& extras, EGLDisplay Result)
                : mextras(extras)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Struct(this->mResult);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        EGLDisplay mResult;
    };

    class EglGetCurrentSurface: public Encodable {
    public:
        EglGetCurrentSurface() = default;
        EglGetCurrentSurface(const gapic::Vector<gapic::Encodable*>& extras, int64_t Readdraw, EGLSurface Result)
                : mextras(extras)
                , mReaddraw(Readdraw)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int64(this->mReaddraw);
            e->Struct(this->mResult);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int64_t mReaddraw;
        EGLSurface mResult;
    };

    class EglGetDisplay: public Encodable {
    public:
        EglGetDisplay() = default;
        EglGetDisplay(const gapic::Vector<gapic::Encodable*>& extras, int64_t NativeDisplay, EGLDisplay Result)
                : mextras(extras)
                , mNativeDisplay(NativeDisplay)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int64(this->mNativeDisplay);
            e->Struct(this->mResult);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int64_t mNativeDisplay;
        EGLDisplay mResult;
    };

    class EglGetError: public Encodable {
    public:
        EglGetError() = default;
        EglGetError(const gapic::Vector<gapic::Encodable*>& extras, int64_t Result)
                : mextras(extras)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int64(this->mResult);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int64_t mResult;
    };

    class EglGetSyncAttribKHR: public Encodable {
    public:
        EglGetSyncAttribKHR() = default;
        EglGetSyncAttribKHR(const gapic::Vector<gapic::Encodable*>& extras, EGLDisplay Dpy, EGLSyncKHR Sync, int64_t Attribute, EGLint__P Value, int64_t Result)
                : mextras(extras)
                , mDpy(Dpy)
                , mSync(Sync)
                , mAttribute(Attribute)
                , mValue(Value)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        EGLDisplay mDpy;
        EGLSyncKHR mSync;
        int64_t mAttribute;
        EGLint__P mValue;
        int64_t mResult;
    };

    class EglInitialize: public Encodable {
    public:
        EglInitialize() = default;
        EglInitialize(const gapic::Vector<gapic::Encodable*>& extras, EGLDisplay Dpy, EGLint__P Major, EGLint__P Minor, int64_t Result)
                : mextras(extras)
                , mDpy(Dpy)
                , mMajor(Major)
                , mMinor(Minor)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        EGLDisplay mDpy;
        EGLint__P mMajor;
        EGLint__P mMinor;
        int64_t mResult;
    };

    class EglMakeCurrent: public Encodable {
    public:
        EglMakeCurrent() = default;
        EglMakeCurrent(const gapic::Vector<gapic::Encodable*>& extras, EGLDisplay Display, EGLSurface Draw, EGLSurface Read, EGLContext Context, int64_t Result)
                : mextras(extras)
                , mDisplay(Display)
                , mDraw(Draw)
                , mRead(Read)
                , mContext(Context)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        EGLDisplay mDisplay;
        EGLSurface mDraw;
        EGLSurface mRead;
        EGLContext mContext;
        int64_t mResult;
    };

    class EglQueryAPI: public Encodable {
    public:
        EglQueryAPI() = default;
        EglQueryAPI(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Result)
                : mextras(extras)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mResult);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mResult;
    };

    class EglQueryContext: public Encodable {
    public:
        EglQueryContext() = default;
        EglQueryContext(const gapic::Vector<gapic::Encodable*>& extras, EGLDisplay Display, EGLContext Context, int64_t Attribute, EGLint__P Value, int64_t Result)
                : mextras(extras)
                , mDisplay(Display)
                , mContext(Context)
                , mAttribute(Attribute)
                , mValue(Value)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        EGLDisplay mDisplay;
        EGLContext mContext;
        int64_t mAttribute;
        EGLint__P mValue;
        int64_t mResult;
    };

    class EglQueryString: public Encodable {
    public:
        EglQueryString() = default;
        EglQueryString(const gapic::Vector<gapic::Encodable*>& extras, EGLDisplay Display, int64_t Name, Char__CP Result)
                : mextras(extras)
                , mDisplay(Display)
                , mName(Name)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        EGLDisplay mDisplay;
        int64_t mName;
        Char__CP mResult;
    };

    class EglQuerySurface: public Encodable {
    public:
        EglQuerySurface() = default;
        EglQuerySurface(const gapic::Vector<gapic::Encodable*>& extras, EGLDisplay Display, EGLSurface Surface, int64_t Attribute, EGLint__P Value, int64_t Result)
                : mextras(extras)
                , mDisplay(Display)
                , mSurface(Surface)
                , mAttribute(Attribute)
                , mValue(Value)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        EGLDisplay mDisplay;
        EGLSurface mSurface;
        int64_t mAttribute;
        EGLint__P mValue;
        int64_t mResult;
    };

    class EglReleaseTexImage: public Encodable {
    public:
        EglReleaseTexImage() = default;
        EglReleaseTexImage(const gapic::Vector<gapic::Encodable*>& extras, EGLDisplay Display, EGLSurface Surface, int64_t Buffer, int64_t Result)
                : mextras(extras)
                , mDisplay(Display)
                , mSurface(Surface)
                , mBuffer(Buffer)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        EGLDisplay mDisplay;
        EGLSurface mSurface;
        int64_t mBuffer;
        int64_t mResult;
    };

    class EglReleaseThread: public Encodable {
    public:
        EglReleaseThread() = default;
        EglReleaseThread(const gapic::Vector<gapic::Encodable*>& extras, int64_t Result)
                : mextras(extras)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int64(this->mResult);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int64_t mResult;
    };

    class EglSignalSyncKHR: public Encodable {
    public:
        EglSignalSyncKHR() = default;
        EglSignalSyncKHR(const gapic::Vector<gapic::Encodable*>& extras, EGLDisplay Dpy, EGLSyncKHR Sync, uint32_t Mode, int64_t Result)
                : mextras(extras)
                , mDpy(Dpy)
                , mSync(Sync)
                , mMode(Mode)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        EGLDisplay mDpy;
        EGLSyncKHR mSync;
        uint32_t mMode;
        int64_t mResult;
    };

    class EglSurfaceAttrib: public Encodable {
    public:
        EglSurfaceAttrib() = default;
        EglSurfaceAttrib(const gapic::Vector<gapic::Encodable*>& extras, EGLDisplay Display, EGLSurface Surface, int64_t Attribute, int64_t Value, int64_t Result)
                : mextras(extras)
                , mDisplay(Display)
                , mSurface(Surface)
                , mAttribute(Attribute)
                , mValue(Value)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        EGLDisplay mDisplay;
        EGLSurface mSurface;
        int64_t mAttribute;
        int64_t mValue;
        int64_t mResult;
    };

    class Void__P: public Encodable {
    public:
        Void__P() = default;
        Void__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class EglSwapBuffers: public Encodable {
    public:
        EglSwapBuffers() = default;
        EglSwapBuffers(const gapic::Vector<gapic::Encodable*>& extras, EGLDisplay Display, Void__P Surface, int64_t Result)
                : mextras(extras)
                , mDisplay(Display)
                , mSurface(Surface)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        EGLDisplay mDisplay;
        Void__P mSurface;
        int64_t mResult;
    };

    class EglSwapBuffersWithDamageKHR: public Encodable {
    public:
        EglSwapBuffersWithDamageKHR() = default;
        EglSwapBuffersWithDamageKHR(const gapic::Vector<gapic::Encodable*>& extras, EGLDisplay Dpy, EGLSurface Surface, EGLint__P Rects, int64_t NRects, int64_t Result)
                : mextras(extras)
                , mDpy(Dpy)
                , mSurface(Surface)
                , mRects(Rects)
                , mNRects(NRects)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        EGLDisplay mDpy;
        EGLSurface mSurface;
        EGLint__P mRects;
        int64_t mNRects;
        int64_t mResult;
    };

    class EglSwapInterval: public Encodable {
    public:
        EglSwapInterval() = default;
        EglSwapInterval(const gapic::Vector<gapic::Encodable*>& extras, EGLDisplay Display, int64_t Interval, int64_t Result)
                : mextras(extras)
                , mDisplay(Display)
                , mInterval(Interval)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        EGLDisplay mDisplay;
        int64_t mInterval;
        int64_t mResult;
    };

    class EglTerminate: public Encodable {
    public:
        EglTerminate() = default;
        EglTerminate(const gapic::Vector<gapic::Encodable*>& extras, EGLDisplay Display, int64_t Result)
                : mextras(extras)
                , mDisplay(Display)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Struct(this->mDisplay);
            e->Int64(this->mResult);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        EGLDisplay mDisplay;
        int64_t mResult;
    };

    class EglWaitClient: public Encodable {
    public:
        EglWaitClient() = default;
        EglWaitClient(const gapic::Vector<gapic::Encodable*>& extras, int64_t Result)
                : mextras(extras)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int64(this->mResult);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int64_t mResult;
    };

    class EglWaitGL: public Encodable {
    public:
        EglWaitGL() = default;
        EglWaitGL(const gapic::Vector<gapic::Encodable*>& extras, int64_t Result)
                : mextras(extras)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int64(this->mResult);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int64_t mResult;
    };

    class EglWaitNative: public Encodable {
    public:
        EglWaitNative() = default;
        EglWaitNative(const gapic::Vector<gapic::Encodable*>& extras, int64_t Engine, int64_t Result)
                : mextras(extras)
                , mEngine(Engine)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int64(this->mEngine);
            e->Int64(this->mResult);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int64_t mEngine;
        int64_t mResult;
    };

    class ErrorState: public Encodable {
    public:
        ErrorState() = default;
        ErrorState(uint32_t TraceDriversGlError, uint32_t InterceptorsGlError)
                : mTraceDriversGlError(TraceDriversGlError)
                , mInterceptorsGlError(InterceptorsGlError) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mTraceDriversGlError);
            e->Uint32(this->mInterceptorsGlError);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint32_t mTraceDriversGlError;
        uint32_t mInterceptorsGlError;
    };

    class F64__S: public Encodable {
    public:
        F64__S() = default;
        F64__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class FlushPostBuffer: public Encodable {
    public:
        FlushPostBuffer() = default;
        FlushPostBuffer(const gapic::Vector<gapic::Encodable*>& extras)
                : mextras(extras) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
    };

    class FramebufferId__S: public Encodable {
    public:
        FramebufferId__S() = default;
        FramebufferId__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class FramebufferId__P: public Encodable {
    public:
        FramebufferId__P() = default;
        FramebufferId__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class FramebufferId__CP: public Encodable {
    public:
        FramebufferId__CP() = default;
        FramebufferId__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class GLXContext: public Encodable {
    public:
        GLXContext() = default;
        GLXContext(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class GLXDrawable: public Encodable {
    public:
        GLXDrawable() = default;
        GLXDrawable(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class GLboolean__4__A: public Encodable {
    public:
        GLboolean__4__A() = default;
        GLboolean__4__A(const gapic::StaticArray<uint8_t, 4>& Elements)
                : mElements(Elements) {}
        virtual void Encode(Encoder* e) const{
            for (int i = 0; i < 4; i++) {
                e->Uint8(this->mElements[i]);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::StaticArray<uint8_t, 4> mElements;
    };

    class GLboolean__S: public Encodable {
    public:
        GLboolean__S() = default;
        GLboolean__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class GLboolean__P: public Encodable {
    public:
        GLboolean__P() = default;
        GLboolean__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class GLchar__P: public Encodable {
    public:
        GLchar__P() = default;
        GLchar__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class GLchar__CP: public Encodable {
    public:
        GLchar__CP() = default;
        GLchar__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class GLchar__CP__S: public Encodable {
    public:
        GLchar__CP__S() = default;
        GLchar__CP__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class GLchar__CP__P: public Encodable {
    public:
        GLchar__CP__P() = default;
        GLchar__CP__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class GLchar__CP__CP: public Encodable {
    public:
        GLchar__CP__CP() = default;
        GLchar__CP__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class GLeglImageOES: public Encodable {
    public:
        GLeglImageOES() = default;
        GLeglImageOES(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class GLenum__S: public Encodable {
    public:
        GLenum__S() = default;
        GLenum__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class GLenum__CP: public Encodable {
    public:
        GLenum__CP() = default;
        GLenum__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class GLfixed__S: public Encodable {
    public:
        GLfixed__S() = default;
        GLfixed__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class GLfixed__P: public Encodable {
    public:
        GLfixed__P() = default;
        GLfixed__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class GLfixed__CP: public Encodable {
    public:
        GLfixed__CP() = default;
        GLfixed__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class GLfloat__1__A: public Encodable {
    public:
        GLfloat__1__A() = default;
        GLfloat__1__A(const gapic::StaticArray<float, 1>& Elements)
                : mElements(Elements) {}
        virtual void Encode(Encoder* e) const{
            for (int i = 0; i < 1; i++) {
                e->Float32(this->mElements[i]);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::StaticArray<float, 1> mElements;
    };

    class GLfloat__3__A: public Encodable {
    public:
        GLfloat__3__A() = default;
        GLfloat__3__A(const gapic::StaticArray<float, 3>& Elements)
                : mElements(Elements) {}
        virtual void Encode(Encoder* e) const{
            for (int i = 0; i < 3; i++) {
                e->Float32(this->mElements[i]);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::StaticArray<float, 3> mElements;
    };

    class GLfloat__4__A: public Encodable {
    public:
        GLfloat__4__A() = default;
        GLfloat__4__A(const gapic::StaticArray<float, 4>& Elements)
                : mElements(Elements) {}
        virtual void Encode(Encoder* e) const{
            for (int i = 0; i < 4; i++) {
                e->Float32(this->mElements[i]);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::StaticArray<float, 4> mElements;
    };

    class GLfloat__S: public Encodable {
    public:
        GLfloat__S() = default;
        GLfloat__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class GLfloat__P: public Encodable {
    public:
        GLfloat__P() = default;
        GLfloat__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class GLfloat__CP: public Encodable {
    public:
        GLfloat__CP() = default;
        GLfloat__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class GLint64__S: public Encodable {
    public:
        GLint64__S() = default;
        GLint64__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class GLint64__P: public Encodable {
    public:
        GLint64__P() = default;
        GLint64__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class GLint__1__A: public Encodable {
    public:
        GLint__1__A() = default;
        GLint__1__A(const gapic::StaticArray<int32_t, 1>& Elements)
                : mElements(Elements) {}
        virtual void Encode(Encoder* e) const{
            for (int i = 0; i < 1; i++) {
                e->Int32(this->mElements[i]);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::StaticArray<int32_t, 1> mElements;
    };

    class GLint__4__A: public Encodable {
    public:
        GLint__4__A() = default;
        GLint__4__A(const gapic::StaticArray<int32_t, 4>& Elements)
                : mElements(Elements) {}
        virtual void Encode(Encoder* e) const{
            for (int i = 0; i < 4; i++) {
                e->Int32(this->mElements[i]);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::StaticArray<int32_t, 4> mElements;
    };

    class GLint__S: public Encodable {
    public:
        GLint__S() = default;
        GLint__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class GLint__P: public Encodable {
    public:
        GLint__P() = default;
        GLint__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class GLint__CP: public Encodable {
    public:
        GLint__CP() = default;
        GLint__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class GLshort__S: public Encodable {
    public:
        GLshort__S() = default;
        GLshort__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class GLshort__P: public Encodable {
    public:
        GLshort__P() = default;
        GLshort__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class GLshort__CP: public Encodable {
    public:
        GLshort__CP() = default;
        GLshort__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class GLsizei__S: public Encodable {
    public:
        GLsizei__S() = default;
        GLsizei__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class GLsizei__P: public Encodable {
    public:
        GLsizei__P() = default;
        GLsizei__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class GLsizei__CP: public Encodable {
    public:
        GLsizei__CP() = default;
        GLsizei__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class GLubyte__S: public Encodable {
    public:
        GLubyte__S() = default;
        GLubyte__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class GLubyte__P: public Encodable {
    public:
        GLubyte__P() = default;
        GLubyte__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class GLubyte__CP: public Encodable {
    public:
        GLubyte__CP() = default;
        GLubyte__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class GLuint64__S: public Encodable {
    public:
        GLuint64__S() = default;
        GLuint64__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class GLuint64__P: public Encodable {
    public:
        GLuint64__P() = default;
        GLuint64__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class GLuint64__CP: public Encodable {
    public:
        GLuint64__CP() = default;
        GLuint64__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class GLuint__2__A: public Encodable {
    public:
        GLuint__2__A() = default;
        GLuint__2__A(const gapic::StaticArray<uint32_t, 2>& Elements)
                : mElements(Elements) {}
        virtual void Encode(Encoder* e) const{
            for (int i = 0; i < 2; i++) {
                e->Uint32(this->mElements[i]);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::StaticArray<uint32_t, 2> mElements;
    };

    class GLuint__3__A: public Encodable {
    public:
        GLuint__3__A() = default;
        GLuint__3__A(const gapic::StaticArray<uint32_t, 3>& Elements)
                : mElements(Elements) {}
        virtual void Encode(Encoder* e) const{
            for (int i = 0; i < 3; i++) {
                e->Uint32(this->mElements[i]);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::StaticArray<uint32_t, 3> mElements;
    };

    class GLuint__4__A: public Encodable {
    public:
        GLuint__4__A() = default;
        GLuint__4__A(const gapic::StaticArray<uint32_t, 4>& Elements)
                : mElements(Elements) {}
        virtual void Encode(Encoder* e) const{
            for (int i = 0; i < 4; i++) {
                e->Uint32(this->mElements[i]);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::StaticArray<uint32_t, 4> mElements;
    };

    class GLuint__S: public Encodable {
    public:
        GLuint__S() = default;
        GLuint__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class GLuint__P: public Encodable {
    public:
        GLuint__P() = default;
        GLuint__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class GLuint__CP: public Encodable {
    public:
        GLuint__CP() = default;
        GLuint__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class GLvoid__S: public Encodable {
    public:
        GLvoid__S() = default;
        GLvoid__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class GLvoid__P: public Encodable {
    public:
        GLvoid__P() = default;
        GLvoid__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class GlActiveShaderProgram: public Encodable {
    public:
        GlActiveShaderProgram() = default;
        GlActiveShaderProgram(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Pipeline, uint32_t Program)
                : mextras(extras)
                , mPipeline(Pipeline)
                , mProgram(Program) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mPipeline);
            e->Uint32(this->mProgram);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPipeline;
        uint32_t mProgram;
    };

    class GlActiveShaderProgramEXT: public Encodable {
    public:
        GlActiveShaderProgramEXT() = default;
        GlActiveShaderProgramEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Pipeline, uint32_t Program)
                : mextras(extras)
                , mPipeline(Pipeline)
                , mProgram(Program) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mPipeline);
            e->Uint32(this->mProgram);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPipeline;
        uint32_t mProgram;
    };

    class GlActiveTexture: public Encodable {
    public:
        GlActiveTexture() = default;
        GlActiveTexture(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Unit)
                : mextras(extras)
                , mUnit(Unit) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mUnit);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mUnit;
    };

    class GlAlphaFunc: public Encodable {
    public:
        GlAlphaFunc() = default;
        GlAlphaFunc(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Func, float Ref)
                : mextras(extras)
                , mFunc(Func)
                , mRef(Ref) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mFunc);
            e->Float32(this->mRef);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mFunc;
        float mRef;
    };

    class GlAlphaFuncQCOM: public Encodable {
    public:
        GlAlphaFuncQCOM() = default;
        GlAlphaFuncQCOM(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Func, float Ref)
                : mextras(extras)
                , mFunc(Func)
                , mRef(Ref) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mFunc);
            e->Float32(this->mRef);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mFunc;
        float mRef;
    };

    class GlAlphaFuncx: public Encodable {
    public:
        GlAlphaFuncx() = default;
        GlAlphaFuncx(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Func, int32_t Ref)
                : mextras(extras)
                , mFunc(Func)
                , mRef(Ref) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mFunc);
            e->Int32(this->mRef);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mFunc;
        int32_t mRef;
    };

    class GlAlphaFuncxOES: public Encodable {
    public:
        GlAlphaFuncxOES() = default;
        GlAlphaFuncxOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Func, int32_t Ref)
                : mextras(extras)
                , mFunc(Func)
                , mRef(Ref) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mFunc);
            e->Int32(this->mRef);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mFunc;
        int32_t mRef;
    };

    class GlApplyFramebufferAttachmentCMAAINTEL: public Encodable {
    public:
        GlApplyFramebufferAttachmentCMAAINTEL() = default;
        GlApplyFramebufferAttachmentCMAAINTEL(const gapic::Vector<gapic::Encodable*>& extras)
                : mextras(extras) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
    };

    class GlAttachShader: public Encodable {
    public:
        GlAttachShader() = default;
        GlAttachShader(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, uint32_t Shader)
                : mextras(extras)
                , mProgram(Program)
                , mShader(Shader) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mProgram);
            e->Uint32(this->mShader);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        uint32_t mShader;
    };

    class GlBeginConditionalRenderNV: public Encodable {
    public:
        GlBeginConditionalRenderNV() = default;
        GlBeginConditionalRenderNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Id, uint32_t Mode)
                : mextras(extras)
                , mId(Id)
                , mMode(Mode) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mId);
            e->Uint32(this->mMode);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mId;
        uint32_t mMode;
    };

    class GlBeginPerfMonitorAMD: public Encodable {
    public:
        GlBeginPerfMonitorAMD() = default;
        GlBeginPerfMonitorAMD(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Monitor)
                : mextras(extras)
                , mMonitor(Monitor) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mMonitor);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mMonitor;
    };

    class GlBeginPerfQueryINTEL: public Encodable {
    public:
        GlBeginPerfQueryINTEL() = default;
        GlBeginPerfQueryINTEL(const gapic::Vector<gapic::Encodable*>& extras, uint32_t QueryHandle)
                : mextras(extras)
                , mQueryHandle(QueryHandle) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mQueryHandle);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mQueryHandle;
    };

    class GlBeginQuery: public Encodable {
    public:
        GlBeginQuery() = default;
        GlBeginQuery(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Query)
                : mextras(extras)
                , mTarget(Target)
                , mQuery(Query) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mTarget);
            e->Uint32(this->mQuery);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mQuery;
    };

    class GlBeginQueryEXT: public Encodable {
    public:
        GlBeginQueryEXT() = default;
        GlBeginQueryEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Query)
                : mextras(extras)
                , mTarget(Target)
                , mQuery(Query) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mTarget);
            e->Uint32(this->mQuery);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mQuery;
    };

    class GlBeginTransformFeedback: public Encodable {
    public:
        GlBeginTransformFeedback() = default;
        GlBeginTransformFeedback(const gapic::Vector<gapic::Encodable*>& extras, uint32_t PrimitiveMode)
                : mextras(extras)
                , mPrimitiveMode(PrimitiveMode) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mPrimitiveMode);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPrimitiveMode;
    };

    class GlBindAttribLocation: public Encodable {
    public:
        GlBindAttribLocation() = default;
        GlBindAttribLocation(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, uint32_t Location, const char* Name)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mName(Name) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        uint32_t mLocation;
        const char* mName;
    };

    class GlBindBuffer: public Encodable {
    public:
        GlBindBuffer() = default;
        GlBindBuffer(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Buffer)
                : mextras(extras)
                , mTarget(Target)
                , mBuffer(Buffer) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mTarget);
            e->Uint32(this->mBuffer);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mBuffer;
    };

    class GlBindBufferBase: public Encodable {
    public:
        GlBindBufferBase() = default;
        GlBindBufferBase(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Index, uint32_t Buffer)
                : mextras(extras)
                , mTarget(Target)
                , mIndex(Index)
                , mBuffer(Buffer) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mIndex;
        uint32_t mBuffer;
    };

    class GlBindBufferRange: public Encodable {
    public:
        GlBindBufferRange() = default;
        GlBindBufferRange(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Index, uint32_t Buffer, int32_t Offset, int32_t Size)
                : mextras(extras)
                , mTarget(Target)
                , mIndex(Index)
                , mBuffer(Buffer)
                , mOffset(Offset)
                , mSize(Size) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mIndex;
        uint32_t mBuffer;
        int32_t mOffset;
        int32_t mSize;
    };

    class GlBindFragDataLocation: public Encodable {
    public:
        GlBindFragDataLocation() = default;
        GlBindFragDataLocation(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, uint32_t Color, const char* Name)
                : mextras(extras)
                , mProgram(Program)
                , mColor(Color)
                , mName(Name) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        uint32_t mColor;
        const char* mName;
    };

    class GlBindFragDataLocationEXT: public Encodable {
    public:
        GlBindFragDataLocationEXT() = default;
        GlBindFragDataLocationEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, uint32_t Color, const char* Name)
                : mextras(extras)
                , mProgram(Program)
                , mColor(Color)
                , mName(Name) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        uint32_t mColor;
        const char* mName;
    };

    class GlBindFragDataLocationIndexedEXT: public Encodable {
    public:
        GlBindFragDataLocationIndexedEXT() = default;
        GlBindFragDataLocationIndexedEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, uint32_t ColorNumber, uint32_t Index, const char* Name)
                : mextras(extras)
                , mProgram(Program)
                , mColorNumber(ColorNumber)
                , mIndex(Index)
                , mName(Name) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        uint32_t mColorNumber;
        uint32_t mIndex;
        const char* mName;
    };

    class GlBindFramebuffer: public Encodable {
    public:
        GlBindFramebuffer() = default;
        GlBindFramebuffer(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Framebuffer)
                : mextras(extras)
                , mTarget(Target)
                , mFramebuffer(Framebuffer) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mTarget);
            e->Uint32(this->mFramebuffer);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mFramebuffer;
    };

    class GlBindFramebufferOES: public Encodable {
    public:
        GlBindFramebufferOES() = default;
        GlBindFramebufferOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Framebuffer)
                : mextras(extras)
                , mTarget(Target)
                , mFramebuffer(Framebuffer) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mTarget);
            e->Uint32(this->mFramebuffer);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mFramebuffer;
    };

    class GlBindImageTexture: public Encodable {
    public:
        GlBindImageTexture() = default;
        GlBindImageTexture(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Unit, uint32_t Texture, int32_t Level, uint8_t Layered, int32_t Layer, uint32_t Access, uint32_t Format)
                : mextras(extras)
                , mUnit(Unit)
                , mTexture(Texture)
                , mLevel(Level)
                , mLayered(Layered)
                , mLayer(Layer)
                , mAccess(Access)
                , mFormat(Format) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mUnit;
        uint32_t mTexture;
        int32_t mLevel;
        uint8_t mLayered;
        int32_t mLayer;
        uint32_t mAccess;
        uint32_t mFormat;
    };

    class GlBindProgramPipeline: public Encodable {
    public:
        GlBindProgramPipeline() = default;
        GlBindProgramPipeline(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Pipeline)
                : mextras(extras)
                , mPipeline(Pipeline) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mPipeline);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPipeline;
    };

    class GlBindProgramPipelineEXT: public Encodable {
    public:
        GlBindProgramPipelineEXT() = default;
        GlBindProgramPipelineEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Pipeline)
                : mextras(extras)
                , mPipeline(Pipeline) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mPipeline);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPipeline;
    };

    class GlBindRenderbuffer: public Encodable {
    public:
        GlBindRenderbuffer() = default;
        GlBindRenderbuffer(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Renderbuffer)
                : mextras(extras)
                , mTarget(Target)
                , mRenderbuffer(Renderbuffer) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mTarget);
            e->Uint32(this->mRenderbuffer);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mRenderbuffer;
    };

    class GlBindRenderbufferOES: public Encodable {
    public:
        GlBindRenderbufferOES() = default;
        GlBindRenderbufferOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Renderbuffer)
                : mextras(extras)
                , mTarget(Target)
                , mRenderbuffer(Renderbuffer) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mTarget);
            e->Uint32(this->mRenderbuffer);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mRenderbuffer;
    };

    class GlBindSampler: public Encodable {
    public:
        GlBindSampler() = default;
        GlBindSampler(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Index, uint32_t Sampler)
                : mextras(extras)
                , mIndex(Index)
                , mSampler(Sampler) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mIndex);
            e->Uint32(this->mSampler);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mIndex;
        uint32_t mSampler;
    };

    class GlBindTexture: public Encodable {
    public:
        GlBindTexture() = default;
        GlBindTexture(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Texture)
                : mextras(extras)
                , mTarget(Target)
                , mTexture(Texture) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mTarget);
            e->Uint32(this->mTexture);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mTexture;
    };

    class GlBindTransformFeedback: public Encodable {
    public:
        GlBindTransformFeedback() = default;
        GlBindTransformFeedback(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Id)
                : mextras(extras)
                , mTarget(Target)
                , mId(Id) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mTarget);
            e->Uint32(this->mId);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mId;
    };

    class GlBindVertexArray: public Encodable {
    public:
        GlBindVertexArray() = default;
        GlBindVertexArray(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Array)
                : mextras(extras)
                , mArray(Array) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mArray);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mArray;
    };

    class GlBindVertexArrayOES: public Encodable {
    public:
        GlBindVertexArrayOES() = default;
        GlBindVertexArrayOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Array)
                : mextras(extras)
                , mArray(Array) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mArray);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mArray;
    };

    class GlBindVertexBuffer: public Encodable {
    public:
        GlBindVertexBuffer() = default;
        GlBindVertexBuffer(const gapic::Vector<gapic::Encodable*>& extras, uint32_t BindingIndex, uint32_t Buffer, int32_t Offset, int32_t Stride)
                : mextras(extras)
                , mBindingIndex(BindingIndex)
                , mBuffer(Buffer)
                , mOffset(Offset)
                , mStride(Stride) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mBindingIndex;
        uint32_t mBuffer;
        int32_t mOffset;
        int32_t mStride;
    };

    class GlBlendBarrier: public Encodable {
    public:
        GlBlendBarrier() = default;
        GlBlendBarrier(const gapic::Vector<gapic::Encodable*>& extras)
                : mextras(extras) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
    };

    class GlBlendBarrierKHR: public Encodable {
    public:
        GlBlendBarrierKHR() = default;
        GlBlendBarrierKHR(const gapic::Vector<gapic::Encodable*>& extras)
                : mextras(extras) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
    };

    class GlBlendBarrierNV: public Encodable {
    public:
        GlBlendBarrierNV() = default;
        GlBlendBarrierNV(const gapic::Vector<gapic::Encodable*>& extras)
                : mextras(extras) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
    };

    class GlBlendColor: public Encodable {
    public:
        GlBlendColor() = default;
        GlBlendColor(const gapic::Vector<gapic::Encodable*>& extras, float Red, float Green, float Blue, float Alpha)
                : mextras(extras)
                , mRed(Red)
                , mGreen(Green)
                , mBlue(Blue)
                , mAlpha(Alpha) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        float mRed;
        float mGreen;
        float mBlue;
        float mAlpha;
    };

    class GlBlendEquation: public Encodable {
    public:
        GlBlendEquation() = default;
        GlBlendEquation(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Equation)
                : mextras(extras)
                , mEquation(Equation) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mEquation);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mEquation;
    };

    class GlBlendEquationOES: public Encodable {
    public:
        GlBlendEquationOES() = default;
        GlBlendEquationOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Mode)
                : mextras(extras)
                , mMode(Mode) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mMode);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mMode;
    };

    class GlBlendEquationSeparate: public Encodable {
    public:
        GlBlendEquationSeparate() = default;
        GlBlendEquationSeparate(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Rgb, uint32_t Alpha)
                : mextras(extras)
                , mRgb(Rgb)
                , mAlpha(Alpha) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mRgb);
            e->Uint32(this->mAlpha);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mRgb;
        uint32_t mAlpha;
    };

    class GlBlendEquationSeparateOES: public Encodable {
    public:
        GlBlendEquationSeparateOES() = default;
        GlBlendEquationSeparateOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t ModeRGB, uint32_t ModeAlpha)
                : mextras(extras)
                , mModeRGB(ModeRGB)
                , mModeAlpha(ModeAlpha) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mModeRGB);
            e->Uint32(this->mModeAlpha);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mModeRGB;
        uint32_t mModeAlpha;
    };

    class GlBlendEquationSeparatei: public Encodable {
    public:
        GlBlendEquationSeparatei() = default;
        GlBlendEquationSeparatei(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Buf, uint32_t ModeRGB, uint32_t ModeAlpha)
                : mextras(extras)
                , mBuf(Buf)
                , mModeRGB(ModeRGB)
                , mModeAlpha(ModeAlpha) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mBuf;
        uint32_t mModeRGB;
        uint32_t mModeAlpha;
    };

    class GlBlendEquationSeparateiEXT: public Encodable {
    public:
        GlBlendEquationSeparateiEXT() = default;
        GlBlendEquationSeparateiEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Buf, uint32_t ModeRGB, uint32_t ModeAlpha)
                : mextras(extras)
                , mBuf(Buf)
                , mModeRGB(ModeRGB)
                , mModeAlpha(ModeAlpha) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mBuf;
        uint32_t mModeRGB;
        uint32_t mModeAlpha;
    };

    class GlBlendEquationSeparateiOES: public Encodable {
    public:
        GlBlendEquationSeparateiOES() = default;
        GlBlendEquationSeparateiOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Buf, uint32_t ModeRGB, uint32_t ModeAlpha)
                : mextras(extras)
                , mBuf(Buf)
                , mModeRGB(ModeRGB)
                , mModeAlpha(ModeAlpha) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mBuf;
        uint32_t mModeRGB;
        uint32_t mModeAlpha;
    };

    class GlBlendEquationi: public Encodable {
    public:
        GlBlendEquationi() = default;
        GlBlendEquationi(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Buf, uint32_t Mode)
                : mextras(extras)
                , mBuf(Buf)
                , mMode(Mode) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mBuf);
            e->Uint32(this->mMode);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mBuf;
        uint32_t mMode;
    };

    class GlBlendEquationiEXT: public Encodable {
    public:
        GlBlendEquationiEXT() = default;
        GlBlendEquationiEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Buf, uint32_t Mode)
                : mextras(extras)
                , mBuf(Buf)
                , mMode(Mode) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mBuf);
            e->Uint32(this->mMode);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mBuf;
        uint32_t mMode;
    };

    class GlBlendEquationiOES: public Encodable {
    public:
        GlBlendEquationiOES() = default;
        GlBlendEquationiOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Buf, uint32_t Mode)
                : mextras(extras)
                , mBuf(Buf)
                , mMode(Mode) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mBuf);
            e->Uint32(this->mMode);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mBuf;
        uint32_t mMode;
    };

    class GlBlendFunc: public Encodable {
    public:
        GlBlendFunc() = default;
        GlBlendFunc(const gapic::Vector<gapic::Encodable*>& extras, uint32_t SrcFactor, uint32_t DstFactor)
                : mextras(extras)
                , mSrcFactor(SrcFactor)
                , mDstFactor(DstFactor) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mSrcFactor);
            e->Uint32(this->mDstFactor);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mSrcFactor;
        uint32_t mDstFactor;
    };

    class GlBlendFuncSeparate: public Encodable {
    public:
        GlBlendFuncSeparate() = default;
        GlBlendFuncSeparate(const gapic::Vector<gapic::Encodable*>& extras, uint32_t SrcFactorRgb, uint32_t DstFactorRgb, uint32_t SrcFactorAlpha, uint32_t DstFactorAlpha)
                : mextras(extras)
                , mSrcFactorRgb(SrcFactorRgb)
                , mDstFactorRgb(DstFactorRgb)
                , mSrcFactorAlpha(SrcFactorAlpha)
                , mDstFactorAlpha(DstFactorAlpha) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mSrcFactorRgb;
        uint32_t mDstFactorRgb;
        uint32_t mSrcFactorAlpha;
        uint32_t mDstFactorAlpha;
    };

    class GlBlendFuncSeparateOES: public Encodable {
    public:
        GlBlendFuncSeparateOES() = default;
        GlBlendFuncSeparateOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t SrcRGB, uint32_t DstRGB, uint32_t SrcAlpha, uint32_t DstAlpha)
                : mextras(extras)
                , mSrcRGB(SrcRGB)
                , mDstRGB(DstRGB)
                , mSrcAlpha(SrcAlpha)
                , mDstAlpha(DstAlpha) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mSrcRGB;
        uint32_t mDstRGB;
        uint32_t mSrcAlpha;
        uint32_t mDstAlpha;
    };

    class GlBlendFuncSeparatei: public Encodable {
    public:
        GlBlendFuncSeparatei() = default;
        GlBlendFuncSeparatei(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Buf, uint32_t SrcRGB, uint32_t DstRGB, uint32_t SrcAlpha, uint32_t DstAlpha)
                : mextras(extras)
                , mBuf(Buf)
                , mSrcRGB(SrcRGB)
                , mDstRGB(DstRGB)
                , mSrcAlpha(SrcAlpha)
                , mDstAlpha(DstAlpha) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mBuf;
        uint32_t mSrcRGB;
        uint32_t mDstRGB;
        uint32_t mSrcAlpha;
        uint32_t mDstAlpha;
    };

    class GlBlendFuncSeparateiEXT: public Encodable {
    public:
        GlBlendFuncSeparateiEXT() = default;
        GlBlendFuncSeparateiEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Buf, uint32_t SrcRGB, uint32_t DstRGB, uint32_t SrcAlpha, uint32_t DstAlpha)
                : mextras(extras)
                , mBuf(Buf)
                , mSrcRGB(SrcRGB)
                , mDstRGB(DstRGB)
                , mSrcAlpha(SrcAlpha)
                , mDstAlpha(DstAlpha) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mBuf;
        uint32_t mSrcRGB;
        uint32_t mDstRGB;
        uint32_t mSrcAlpha;
        uint32_t mDstAlpha;
    };

    class GlBlendFuncSeparateiOES: public Encodable {
    public:
        GlBlendFuncSeparateiOES() = default;
        GlBlendFuncSeparateiOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Buf, uint32_t SrcRGB, uint32_t DstRGB, uint32_t SrcAlpha, uint32_t DstAlpha)
                : mextras(extras)
                , mBuf(Buf)
                , mSrcRGB(SrcRGB)
                , mDstRGB(DstRGB)
                , mSrcAlpha(SrcAlpha)
                , mDstAlpha(DstAlpha) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mBuf;
        uint32_t mSrcRGB;
        uint32_t mDstRGB;
        uint32_t mSrcAlpha;
        uint32_t mDstAlpha;
    };

    class GlBlendFunci: public Encodable {
    public:
        GlBlendFunci() = default;
        GlBlendFunci(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Buf, uint32_t Src, uint32_t Dst)
                : mextras(extras)
                , mBuf(Buf)
                , mSrc(Src)
                , mDst(Dst) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mBuf;
        uint32_t mSrc;
        uint32_t mDst;
    };

    class GlBlendFunciEXT: public Encodable {
    public:
        GlBlendFunciEXT() = default;
        GlBlendFunciEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Buf, uint32_t Src, uint32_t Dst)
                : mextras(extras)
                , mBuf(Buf)
                , mSrc(Src)
                , mDst(Dst) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mBuf;
        uint32_t mSrc;
        uint32_t mDst;
    };

    class GlBlendFunciOES: public Encodable {
    public:
        GlBlendFunciOES() = default;
        GlBlendFunciOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Buf, uint32_t Src, uint32_t Dst)
                : mextras(extras)
                , mBuf(Buf)
                , mSrc(Src)
                , mDst(Dst) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mBuf;
        uint32_t mSrc;
        uint32_t mDst;
    };

    class GlBlendParameteriNV: public Encodable {
    public:
        GlBlendParameteriNV() = default;
        GlBlendParameteriNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Pname, int32_t Value)
                : mextras(extras)
                , mPname(Pname)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mPname);
            e->Int32(this->mValue);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPname;
        int32_t mValue;
    };

    class GlBlitFramebuffer: public Encodable {
    public:
        GlBlitFramebuffer() = default;
        GlBlitFramebuffer(const gapic::Vector<gapic::Encodable*>& extras, int32_t SrcX0, int32_t SrcY0, int32_t SrcX1, int32_t SrcY1, int32_t DstX0, int32_t DstY0, int32_t DstX1, int32_t DstY1, uint32_t Mask, uint32_t Filter)
                : mextras(extras)
                , mSrcX0(SrcX0)
                , mSrcY0(SrcY0)
                , mSrcX1(SrcX1)
                , mSrcY1(SrcY1)
                , mDstX0(DstX0)
                , mDstY0(DstY0)
                , mDstX1(DstX1)
                , mDstY1(DstY1)
                , mMask(Mask)
                , mFilter(Filter) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mSrcX0;
        int32_t mSrcY0;
        int32_t mSrcX1;
        int32_t mSrcY1;
        int32_t mDstX0;
        int32_t mDstY0;
        int32_t mDstX1;
        int32_t mDstY1;
        uint32_t mMask;
        uint32_t mFilter;
    };

    class GlBlitFramebufferANGLE: public Encodable {
    public:
        GlBlitFramebufferANGLE() = default;
        GlBlitFramebufferANGLE(const gapic::Vector<gapic::Encodable*>& extras, int32_t SrcX0, int32_t SrcY0, int32_t SrcX1, int32_t SrcY1, int32_t DstX0, int32_t DstY0, int32_t DstX1, int32_t DstY1, uint32_t Mask, uint32_t Filter)
                : mextras(extras)
                , mSrcX0(SrcX0)
                , mSrcY0(SrcY0)
                , mSrcX1(SrcX1)
                , mSrcY1(SrcY1)
                , mDstX0(DstX0)
                , mDstY0(DstY0)
                , mDstX1(DstX1)
                , mDstY1(DstY1)
                , mMask(Mask)
                , mFilter(Filter) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mSrcX0;
        int32_t mSrcY0;
        int32_t mSrcX1;
        int32_t mSrcY1;
        int32_t mDstX0;
        int32_t mDstY0;
        int32_t mDstX1;
        int32_t mDstY1;
        uint32_t mMask;
        uint32_t mFilter;
    };

    class GlBlitFramebufferNV: public Encodable {
    public:
        GlBlitFramebufferNV() = default;
        GlBlitFramebufferNV(const gapic::Vector<gapic::Encodable*>& extras, int32_t SrcX0, int32_t SrcY0, int32_t SrcX1, int32_t SrcY1, int32_t DstX0, int32_t DstY0, int32_t DstX1, int32_t DstY1, uint32_t Mask, uint32_t Filter)
                : mextras(extras)
                , mSrcX0(SrcX0)
                , mSrcY0(SrcY0)
                , mSrcX1(SrcX1)
                , mSrcY1(SrcY1)
                , mDstX0(DstX0)
                , mDstY0(DstY0)
                , mDstX1(DstX1)
                , mDstY1(DstY1)
                , mMask(Mask)
                , mFilter(Filter) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mSrcX0;
        int32_t mSrcY0;
        int32_t mSrcX1;
        int32_t mSrcY1;
        int32_t mDstX0;
        int32_t mDstY0;
        int32_t mDstX1;
        int32_t mDstY1;
        uint32_t mMask;
        uint32_t mFilter;
    };

    class GlBufferData: public Encodable {
    public:
        GlBufferData() = default;
        GlBufferData(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, int32_t Size, BufferDataPointer Data, uint32_t Usage)
                : mextras(extras)
                , mTarget(Target)
                , mSize(Size)
                , mData(Data)
                , mUsage(Usage) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        int32_t mSize;
        BufferDataPointer mData;
        uint32_t mUsage;
    };

    class GlBufferStorageEXT: public Encodable {
    public:
        GlBufferStorageEXT() = default;
        GlBufferStorageEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, int32_t Size, Void__CP Data, uint32_t Flag)
                : mextras(extras)
                , mTarget(Target)
                , mSize(Size)
                , mData(Data)
                , mFlag(Flag) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        int32_t mSize;
        Void__CP mData;
        uint32_t mFlag;
    };

    class GlBufferSubData: public Encodable {
    public:
        GlBufferSubData() = default;
        GlBufferSubData(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, int32_t Offset, int32_t Size, BufferDataPointer Data)
                : mextras(extras)
                , mTarget(Target)
                , mOffset(Offset)
                , mSize(Size)
                , mData(Data) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        int32_t mOffset;
        int32_t mSize;
        BufferDataPointer mData;
    };

    class GlCheckFramebufferStatus: public Encodable {
    public:
        GlCheckFramebufferStatus() = default;
        GlCheckFramebufferStatus(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Result)
                : mextras(extras)
                , mTarget(Target)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mTarget);
            e->Uint32(this->mResult);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mResult;
    };

    class GlCheckFramebufferStatusOES: public Encodable {
    public:
        GlCheckFramebufferStatusOES() = default;
        GlCheckFramebufferStatusOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Result)
                : mextras(extras)
                , mTarget(Target)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mTarget);
            e->Uint32(this->mResult);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mResult;
    };

    class GlClear: public Encodable {
    public:
        GlClear() = default;
        GlClear(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Mask)
                : mextras(extras)
                , mMask(Mask) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mMask);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mMask;
    };

    class GlClearBufferfi: public Encodable {
    public:
        GlClearBufferfi() = default;
        GlClearBufferfi(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Buffer, int32_t Drawbuffer, float Depth, int32_t Stencil)
                : mextras(extras)
                , mBuffer(Buffer)
                , mDrawbuffer(Drawbuffer)
                , mDepth(Depth)
                , mStencil(Stencil) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mBuffer;
        int32_t mDrawbuffer;
        float mDepth;
        int32_t mStencil;
    };

    class GlClearBufferfv: public Encodable {
    public:
        GlClearBufferfv() = default;
        GlClearBufferfv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Buffer, int32_t Drawbuffer, GLfloat__CP Value)
                : mextras(extras)
                , mBuffer(Buffer)
                , mDrawbuffer(Drawbuffer)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mBuffer;
        int32_t mDrawbuffer;
        GLfloat__CP mValue;
    };

    class GlClearBufferiv: public Encodable {
    public:
        GlClearBufferiv() = default;
        GlClearBufferiv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Buffer, int32_t Drawbuffer, GLint__CP Value)
                : mextras(extras)
                , mBuffer(Buffer)
                , mDrawbuffer(Drawbuffer)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mBuffer;
        int32_t mDrawbuffer;
        GLint__CP mValue;
    };

    class GlClearBufferuiv: public Encodable {
    public:
        GlClearBufferuiv() = default;
        GlClearBufferuiv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Buffer, int32_t Drawbuffer, GLuint__CP Value)
                : mextras(extras)
                , mBuffer(Buffer)
                , mDrawbuffer(Drawbuffer)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mBuffer;
        int32_t mDrawbuffer;
        GLuint__CP mValue;
    };

    class GlClearColor: public Encodable {
    public:
        GlClearColor() = default;
        GlClearColor(const gapic::Vector<gapic::Encodable*>& extras, float R, float G, float B, float A)
                : mextras(extras)
                , mR(R)
                , mG(G)
                , mB(B)
                , mA(A) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        float mR;
        float mG;
        float mB;
        float mA;
    };

    class GlClearColorx: public Encodable {
    public:
        GlClearColorx() = default;
        GlClearColorx(const gapic::Vector<gapic::Encodable*>& extras, int32_t Red, int32_t Green, int32_t Blue, int32_t Alpha)
                : mextras(extras)
                , mRed(Red)
                , mGreen(Green)
                , mBlue(Blue)
                , mAlpha(Alpha) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mRed;
        int32_t mGreen;
        int32_t mBlue;
        int32_t mAlpha;
    };

    class GlClearColorxOES: public Encodable {
    public:
        GlClearColorxOES() = default;
        GlClearColorxOES(const gapic::Vector<gapic::Encodable*>& extras, int32_t Red, int32_t Green, int32_t Blue, int32_t Alpha)
                : mextras(extras)
                , mRed(Red)
                , mGreen(Green)
                , mBlue(Blue)
                , mAlpha(Alpha) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mRed;
        int32_t mGreen;
        int32_t mBlue;
        int32_t mAlpha;
    };

    class GlClearDepthf: public Encodable {
    public:
        GlClearDepthf() = default;
        GlClearDepthf(const gapic::Vector<gapic::Encodable*>& extras, float Depth)
                : mextras(extras)
                , mDepth(Depth) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Float32(this->mDepth);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        float mDepth;
    };

    class GlClearDepthfOES: public Encodable {
    public:
        GlClearDepthfOES() = default;
        GlClearDepthfOES(const gapic::Vector<gapic::Encodable*>& extras, float Depth)
                : mextras(extras)
                , mDepth(Depth) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Float32(this->mDepth);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        float mDepth;
    };

    class GlClearDepthx: public Encodable {
    public:
        GlClearDepthx() = default;
        GlClearDepthx(const gapic::Vector<gapic::Encodable*>& extras, int32_t Depth)
                : mextras(extras)
                , mDepth(Depth) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int32(this->mDepth);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mDepth;
    };

    class GlClearDepthxOES: public Encodable {
    public:
        GlClearDepthxOES() = default;
        GlClearDepthxOES(const gapic::Vector<gapic::Encodable*>& extras, int32_t Depth)
                : mextras(extras)
                , mDepth(Depth) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int32(this->mDepth);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mDepth;
    };

    class GlClearStencil: public Encodable {
    public:
        GlClearStencil() = default;
        GlClearStencil(const gapic::Vector<gapic::Encodable*>& extras, int32_t Stencil)
                : mextras(extras)
                , mStencil(Stencil) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int32(this->mStencil);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mStencil;
    };

    class GlClientActiveTexture: public Encodable {
    public:
        GlClientActiveTexture() = default;
        GlClientActiveTexture(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Texture)
                : mextras(extras)
                , mTexture(Texture) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mTexture);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTexture;
    };

    class GlClientWaitSync: public Encodable {
    public:
        GlClientWaitSync() = default;
        GlClientWaitSync(const gapic::Vector<gapic::Encodable*>& extras, GLsync Sync, uint32_t SyncFlags, uint64_t Timeout, uint32_t Result)
                : mextras(extras)
                , mSync(Sync)
                , mSyncFlags(SyncFlags)
                , mTimeout(Timeout)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        GLsync mSync;
        uint32_t mSyncFlags;
        uint64_t mTimeout;
        uint32_t mResult;
    };

    class GlClientWaitSyncAPPLE: public Encodable {
    public:
        GlClientWaitSyncAPPLE() = default;
        GlClientWaitSyncAPPLE(const gapic::Vector<gapic::Encodable*>& extras, GLsync Sync, uint32_t Flag, uint64_t Timeout, uint32_t Result)
                : mextras(extras)
                , mSync(Sync)
                , mFlag(Flag)
                , mTimeout(Timeout)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        GLsync mSync;
        uint32_t mFlag;
        uint64_t mTimeout;
        uint32_t mResult;
    };

    class GlClipPlanef: public Encodable {
    public:
        GlClipPlanef() = default;
        GlClipPlanef(const gapic::Vector<gapic::Encodable*>& extras, uint32_t P, GLfloat__CP Eqn)
                : mextras(extras)
                , mP(P)
                , mEqn(Eqn) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mP);
            e->Struct(this->mEqn);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mP;
        GLfloat__CP mEqn;
    };

    class GlClipPlanefIMG: public Encodable {
    public:
        GlClipPlanefIMG() = default;
        GlClipPlanefIMG(const gapic::Vector<gapic::Encodable*>& extras, uint32_t P, GLfloat__CP Eqn)
                : mextras(extras)
                , mP(P)
                , mEqn(Eqn) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mP);
            e->Struct(this->mEqn);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mP;
        GLfloat__CP mEqn;
    };

    class GlClipPlanefOES: public Encodable {
    public:
        GlClipPlanefOES() = default;
        GlClipPlanefOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Plane, GLfloat__CP Equation)
                : mextras(extras)
                , mPlane(Plane)
                , mEquation(Equation) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mPlane);
            e->Struct(this->mEquation);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPlane;
        GLfloat__CP mEquation;
    };

    class GlClipPlanex: public Encodable {
    public:
        GlClipPlanex() = default;
        GlClipPlanex(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Plane, GLfixed__CP Equation)
                : mextras(extras)
                , mPlane(Plane)
                , mEquation(Equation) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mPlane);
            e->Struct(this->mEquation);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPlane;
        GLfixed__CP mEquation;
    };

    class GlClipPlanexIMG: public Encodable {
    public:
        GlClipPlanexIMG() = default;
        GlClipPlanexIMG(const gapic::Vector<gapic::Encodable*>& extras, uint32_t P, GLfixed__CP Eqn)
                : mextras(extras)
                , mP(P)
                , mEqn(Eqn) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mP);
            e->Struct(this->mEqn);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mP;
        GLfixed__CP mEqn;
    };

    class GlClipPlanexOES: public Encodable {
    public:
        GlClipPlanexOES() = default;
        GlClipPlanexOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Plane, GLfixed__CP Equation)
                : mextras(extras)
                , mPlane(Plane)
                , mEquation(Equation) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mPlane);
            e->Struct(this->mEquation);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPlane;
        GLfixed__CP mEquation;
    };

    class GlColor4f: public Encodable {
    public:
        GlColor4f() = default;
        GlColor4f(const gapic::Vector<gapic::Encodable*>& extras, float Red, float Green, float Blue, float Alpha)
                : mextras(extras)
                , mRed(Red)
                , mGreen(Green)
                , mBlue(Blue)
                , mAlpha(Alpha) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        float mRed;
        float mGreen;
        float mBlue;
        float mAlpha;
    };

    class GlColor4ub: public Encodable {
    public:
        GlColor4ub() = default;
        GlColor4ub(const gapic::Vector<gapic::Encodable*>& extras, uint8_t Red, uint8_t Green, uint8_t Blue, uint8_t Alpha)
                : mextras(extras)
                , mRed(Red)
                , mGreen(Green)
                , mBlue(Blue)
                , mAlpha(Alpha) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint8_t mRed;
        uint8_t mGreen;
        uint8_t mBlue;
        uint8_t mAlpha;
    };

    class GlColor4x: public Encodable {
    public:
        GlColor4x() = default;
        GlColor4x(const gapic::Vector<gapic::Encodable*>& extras, int32_t Red, int32_t Green, int32_t Blue, int32_t Alpha)
                : mextras(extras)
                , mRed(Red)
                , mGreen(Green)
                , mBlue(Blue)
                , mAlpha(Alpha) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mRed;
        int32_t mGreen;
        int32_t mBlue;
        int32_t mAlpha;
    };

    class GlColor4xOES: public Encodable {
    public:
        GlColor4xOES() = default;
        GlColor4xOES(const gapic::Vector<gapic::Encodable*>& extras, int32_t Red, int32_t Green, int32_t Blue, int32_t Alpha)
                : mextras(extras)
                , mRed(Red)
                , mGreen(Green)
                , mBlue(Blue)
                , mAlpha(Alpha) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mRed;
        int32_t mGreen;
        int32_t mBlue;
        int32_t mAlpha;
    };

    class GlColorMask: public Encodable {
    public:
        GlColorMask() = default;
        GlColorMask(const gapic::Vector<gapic::Encodable*>& extras, uint8_t Red, uint8_t Green, uint8_t Blue, uint8_t Alpha)
                : mextras(extras)
                , mRed(Red)
                , mGreen(Green)
                , mBlue(Blue)
                , mAlpha(Alpha) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint8_t mRed;
        uint8_t mGreen;
        uint8_t mBlue;
        uint8_t mAlpha;
    };

    class GlColorMaski: public Encodable {
    public:
        GlColorMaski() = default;
        GlColorMaski(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Index, uint8_t R, uint8_t G, uint8_t B, uint8_t A)
                : mextras(extras)
                , mIndex(Index)
                , mR(R)
                , mG(G)
                , mB(B)
                , mA(A) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mIndex;
        uint8_t mR;
        uint8_t mG;
        uint8_t mB;
        uint8_t mA;
    };

    class GlColorMaskiEXT: public Encodable {
    public:
        GlColorMaskiEXT() = default;
        GlColorMaskiEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Index, uint8_t R, uint8_t G, uint8_t B, uint8_t A)
                : mextras(extras)
                , mIndex(Index)
                , mR(R)
                , mG(G)
                , mB(B)
                , mA(A) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mIndex;
        uint8_t mR;
        uint8_t mG;
        uint8_t mB;
        uint8_t mA;
    };

    class GlColorMaskiOES: public Encodable {
    public:
        GlColorMaskiOES() = default;
        GlColorMaskiOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Index, uint8_t R, uint8_t G, uint8_t B, uint8_t A)
                : mextras(extras)
                , mIndex(Index)
                , mR(R)
                , mG(G)
                , mB(B)
                , mA(A) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mIndex;
        uint8_t mR;
        uint8_t mG;
        uint8_t mB;
        uint8_t mA;
    };

    class GlColorPointer: public Encodable {
    public:
        GlColorPointer() = default;
        GlColorPointer(const gapic::Vector<gapic::Encodable*>& extras, int32_t Size, uint32_t Type, int32_t Stride, Void__CP Pointer)
                : mextras(extras)
                , mSize(Size)
                , mType(Type)
                , mStride(Stride)
                , mPointer(Pointer) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mSize;
        uint32_t mType;
        int32_t mStride;
        Void__CP mPointer;
    };

    class GlColorPointerBounds: public Encodable {
    public:
        GlColorPointerBounds() = default;
        GlColorPointerBounds(const gapic::Vector<gapic::Encodable*>& extras, int32_t Size, uint32_t Type, int32_t Stride, Void__CP Pointer, int32_t Count)
                : mextras(extras)
                , mSize(Size)
                , mType(Type)
                , mStride(Stride)
                , mPointer(Pointer)
                , mCount(Count) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mSize;
        uint32_t mType;
        int32_t mStride;
        Void__CP mPointer;
        int32_t mCount;
    };

    class GlCompileShader: public Encodable {
    public:
        GlCompileShader() = default;
        GlCompileShader(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Shader)
                : mextras(extras)
                , mShader(Shader) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mShader);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mShader;
    };

    class TexturePointer: public Encodable {
    public:
        TexturePointer() = default;
        TexturePointer(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class GlCompressedTexImage2D: public Encodable {
    public:
        GlCompressedTexImage2D() = default;
        GlCompressedTexImage2D(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, int32_t Level, uint32_t Format, int32_t Width, int32_t Height, int32_t Border, int32_t ImageSize, TexturePointer Data)
                : mextras(extras)
                , mTarget(Target)
                , mLevel(Level)
                , mFormat(Format)
                , mWidth(Width)
                , mHeight(Height)
                , mBorder(Border)
                , mImageSize(ImageSize)
                , mData(Data) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        int32_t mLevel;
        uint32_t mFormat;
        int32_t mWidth;
        int32_t mHeight;
        int32_t mBorder;
        int32_t mImageSize;
        TexturePointer mData;
    };

    class GlCompressedTexImage3D: public Encodable {
    public:
        GlCompressedTexImage3D() = default;
        GlCompressedTexImage3D(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, int32_t Level, uint32_t Internalformat, int32_t Width, int32_t Height, int32_t Depth, int32_t Border, int32_t ImageSize, TexturePointer Data)
                : mextras(extras)
                , mTarget(Target)
                , mLevel(Level)
                , mInternalformat(Internalformat)
                , mWidth(Width)
                , mHeight(Height)
                , mDepth(Depth)
                , mBorder(Border)
                , mImageSize(ImageSize)
                , mData(Data) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        int32_t mLevel;
        uint32_t mInternalformat;
        int32_t mWidth;
        int32_t mHeight;
        int32_t mDepth;
        int32_t mBorder;
        int32_t mImageSize;
        TexturePointer mData;
    };

    class GlCompressedTexImage3DOES: public Encodable {
    public:
        GlCompressedTexImage3DOES() = default;
        GlCompressedTexImage3DOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, int32_t Level, uint32_t Internalformat, int32_t Width, int32_t Height, int32_t Depth, int32_t Border, int32_t ImageSize, TexturePointer Data)
                : mextras(extras)
                , mTarget(Target)
                , mLevel(Level)
                , mInternalformat(Internalformat)
                , mWidth(Width)
                , mHeight(Height)
                , mDepth(Depth)
                , mBorder(Border)
                , mImageSize(ImageSize)
                , mData(Data) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        int32_t mLevel;
        uint32_t mInternalformat;
        int32_t mWidth;
        int32_t mHeight;
        int32_t mDepth;
        int32_t mBorder;
        int32_t mImageSize;
        TexturePointer mData;
    };

    class GlCompressedTexSubImage2D: public Encodable {
    public:
        GlCompressedTexSubImage2D() = default;
        GlCompressedTexSubImage2D(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, int32_t Level, int32_t Xoffset, int32_t Yoffset, int32_t Width, int32_t Height, uint32_t Format, int32_t ImageSize, TexturePointer Data)
                : mextras(extras)
                , mTarget(Target)
                , mLevel(Level)
                , mXoffset(Xoffset)
                , mYoffset(Yoffset)
                , mWidth(Width)
                , mHeight(Height)
                , mFormat(Format)
                , mImageSize(ImageSize)
                , mData(Data) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        int32_t mLevel;
        int32_t mXoffset;
        int32_t mYoffset;
        int32_t mWidth;
        int32_t mHeight;
        uint32_t mFormat;
        int32_t mImageSize;
        TexturePointer mData;
    };

    class GlCompressedTexSubImage3D: public Encodable {
    public:
        GlCompressedTexSubImage3D() = default;
        GlCompressedTexSubImage3D(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, int32_t Level, int32_t Xoffset, int32_t Yoffset, int32_t Zoffset, int32_t Width, int32_t Height, int32_t Depth, uint32_t Format, int32_t ImageSize, TexturePointer Data)
                : mextras(extras)
                , mTarget(Target)
                , mLevel(Level)
                , mXoffset(Xoffset)
                , mYoffset(Yoffset)
                , mZoffset(Zoffset)
                , mWidth(Width)
                , mHeight(Height)
                , mDepth(Depth)
                , mFormat(Format)
                , mImageSize(ImageSize)
                , mData(Data) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        int32_t mLevel;
        int32_t mXoffset;
        int32_t mYoffset;
        int32_t mZoffset;
        int32_t mWidth;
        int32_t mHeight;
        int32_t mDepth;
        uint32_t mFormat;
        int32_t mImageSize;
        TexturePointer mData;
    };

    class GlCompressedTexSubImage3DOES: public Encodable {
    public:
        GlCompressedTexSubImage3DOES() = default;
        GlCompressedTexSubImage3DOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, int32_t Level, int32_t Xoffset, int32_t Yoffset, int32_t Zoffset, int32_t Width, int32_t Height, int32_t Depth, uint32_t Format, int32_t ImageSize, TexturePointer Data)
                : mextras(extras)
                , mTarget(Target)
                , mLevel(Level)
                , mXoffset(Xoffset)
                , mYoffset(Yoffset)
                , mZoffset(Zoffset)
                , mWidth(Width)
                , mHeight(Height)
                , mDepth(Depth)
                , mFormat(Format)
                , mImageSize(ImageSize)
                , mData(Data) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        int32_t mLevel;
        int32_t mXoffset;
        int32_t mYoffset;
        int32_t mZoffset;
        int32_t mWidth;
        int32_t mHeight;
        int32_t mDepth;
        uint32_t mFormat;
        int32_t mImageSize;
        TexturePointer mData;
    };

    class GlCopyBufferSubData: public Encodable {
    public:
        GlCopyBufferSubData() = default;
        GlCopyBufferSubData(const gapic::Vector<gapic::Encodable*>& extras, uint32_t ReadTarget, uint32_t WriteTarget, int32_t ReadOffset, int32_t WriteOffset, int32_t Size)
                : mextras(extras)
                , mReadTarget(ReadTarget)
                , mWriteTarget(WriteTarget)
                , mReadOffset(ReadOffset)
                , mWriteOffset(WriteOffset)
                , mSize(Size) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mReadTarget;
        uint32_t mWriteTarget;
        int32_t mReadOffset;
        int32_t mWriteOffset;
        int32_t mSize;
    };

    class GlCopyBufferSubDataNV: public Encodable {
    public:
        GlCopyBufferSubDataNV() = default;
        GlCopyBufferSubDataNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t ReadTarget, uint32_t WriteTarget, int32_t ReadOffset, int32_t WriteOffset, int32_t Size)
                : mextras(extras)
                , mReadTarget(ReadTarget)
                , mWriteTarget(WriteTarget)
                , mReadOffset(ReadOffset)
                , mWriteOffset(WriteOffset)
                , mSize(Size) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mReadTarget;
        uint32_t mWriteTarget;
        int32_t mReadOffset;
        int32_t mWriteOffset;
        int32_t mSize;
    };

    class GlCopyImageSubData: public Encodable {
    public:
        GlCopyImageSubData() = default;
        GlCopyImageSubData(const gapic::Vector<gapic::Encodable*>& extras, uint32_t SrcName, uint32_t SrcTarget, int32_t SrcLevel, int32_t SrcX, int32_t SrcY, int32_t SrcZ, uint32_t DstName, uint32_t DstTarget, int32_t DstLevel, int32_t DstX, int32_t DstY, int32_t DstZ, int32_t SrcWidth, int32_t SrcHeight, int32_t SrcDepth)
                : mextras(extras)
                , mSrcName(SrcName)
                , mSrcTarget(SrcTarget)
                , mSrcLevel(SrcLevel)
                , mSrcX(SrcX)
                , mSrcY(SrcY)
                , mSrcZ(SrcZ)
                , mDstName(DstName)
                , mDstTarget(DstTarget)
                , mDstLevel(DstLevel)
                , mDstX(DstX)
                , mDstY(DstY)
                , mDstZ(DstZ)
                , mSrcWidth(SrcWidth)
                , mSrcHeight(SrcHeight)
                , mSrcDepth(SrcDepth) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mSrcName;
        uint32_t mSrcTarget;
        int32_t mSrcLevel;
        int32_t mSrcX;
        int32_t mSrcY;
        int32_t mSrcZ;
        uint32_t mDstName;
        uint32_t mDstTarget;
        int32_t mDstLevel;
        int32_t mDstX;
        int32_t mDstY;
        int32_t mDstZ;
        int32_t mSrcWidth;
        int32_t mSrcHeight;
        int32_t mSrcDepth;
    };

    class GlCopyImageSubDataEXT: public Encodable {
    public:
        GlCopyImageSubDataEXT() = default;
        GlCopyImageSubDataEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t SrcName, uint32_t SrcTarget, int32_t SrcLevel, int32_t SrcX, int32_t SrcY, int32_t SrcZ, uint32_t DstName, uint32_t DstTarget, int32_t DstLevel, int32_t DstX, int32_t DstY, int32_t DstZ, int32_t SrcWidth, int32_t SrcHeight, int32_t SrcDepth)
                : mextras(extras)
                , mSrcName(SrcName)
                , mSrcTarget(SrcTarget)
                , mSrcLevel(SrcLevel)
                , mSrcX(SrcX)
                , mSrcY(SrcY)
                , mSrcZ(SrcZ)
                , mDstName(DstName)
                , mDstTarget(DstTarget)
                , mDstLevel(DstLevel)
                , mDstX(DstX)
                , mDstY(DstY)
                , mDstZ(DstZ)
                , mSrcWidth(SrcWidth)
                , mSrcHeight(SrcHeight)
                , mSrcDepth(SrcDepth) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mSrcName;
        uint32_t mSrcTarget;
        int32_t mSrcLevel;
        int32_t mSrcX;
        int32_t mSrcY;
        int32_t mSrcZ;
        uint32_t mDstName;
        uint32_t mDstTarget;
        int32_t mDstLevel;
        int32_t mDstX;
        int32_t mDstY;
        int32_t mDstZ;
        int32_t mSrcWidth;
        int32_t mSrcHeight;
        int32_t mSrcDepth;
    };

    class GlCopyImageSubDataOES: public Encodable {
    public:
        GlCopyImageSubDataOES() = default;
        GlCopyImageSubDataOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t SrcName, uint32_t SrcTarget, int32_t SrcLevel, int32_t SrcX, int32_t SrcY, int32_t SrcZ, uint32_t DstName, uint32_t DstTarget, int32_t DstLevel, int32_t DstX, int32_t DstY, int32_t DstZ, int32_t SrcWidth, int32_t SrcHeight, int32_t SrcDepth)
                : mextras(extras)
                , mSrcName(SrcName)
                , mSrcTarget(SrcTarget)
                , mSrcLevel(SrcLevel)
                , mSrcX(SrcX)
                , mSrcY(SrcY)
                , mSrcZ(SrcZ)
                , mDstName(DstName)
                , mDstTarget(DstTarget)
                , mDstLevel(DstLevel)
                , mDstX(DstX)
                , mDstY(DstY)
                , mDstZ(DstZ)
                , mSrcWidth(SrcWidth)
                , mSrcHeight(SrcHeight)
                , mSrcDepth(SrcDepth) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mSrcName;
        uint32_t mSrcTarget;
        int32_t mSrcLevel;
        int32_t mSrcX;
        int32_t mSrcY;
        int32_t mSrcZ;
        uint32_t mDstName;
        uint32_t mDstTarget;
        int32_t mDstLevel;
        int32_t mDstX;
        int32_t mDstY;
        int32_t mDstZ;
        int32_t mSrcWidth;
        int32_t mSrcHeight;
        int32_t mSrcDepth;
    };

    class GlCopyPathNV: public Encodable {
    public:
        GlCopyPathNV() = default;
        GlCopyPathNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t ResultPath, uint32_t SrcPath)
                : mextras(extras)
                , mResultPath(ResultPath)
                , mSrcPath(SrcPath) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mResultPath);
            e->Uint32(this->mSrcPath);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mResultPath;
        uint32_t mSrcPath;
    };

    class GlCopyTexImage2D: public Encodable {
    public:
        GlCopyTexImage2D() = default;
        GlCopyTexImage2D(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, int32_t Level, uint32_t Internalformat, int32_t X, int32_t Y, int32_t Width, int32_t Height, int32_t Border)
                : mextras(extras)
                , mTarget(Target)
                , mLevel(Level)
                , mInternalformat(Internalformat)
                , mX(X)
                , mY(Y)
                , mWidth(Width)
                , mHeight(Height)
                , mBorder(Border) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        int32_t mLevel;
        uint32_t mInternalformat;
        int32_t mX;
        int32_t mY;
        int32_t mWidth;
        int32_t mHeight;
        int32_t mBorder;
    };

    class GlCopyTexSubImage2D: public Encodable {
    public:
        GlCopyTexSubImage2D() = default;
        GlCopyTexSubImage2D(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, int32_t Level, int32_t Xoffset, int32_t Yoffset, int32_t X, int32_t Y, int32_t Width, int32_t Height)
                : mextras(extras)
                , mTarget(Target)
                , mLevel(Level)
                , mXoffset(Xoffset)
                , mYoffset(Yoffset)
                , mX(X)
                , mY(Y)
                , mWidth(Width)
                , mHeight(Height) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        int32_t mLevel;
        int32_t mXoffset;
        int32_t mYoffset;
        int32_t mX;
        int32_t mY;
        int32_t mWidth;
        int32_t mHeight;
    };

    class GlCopyTexSubImage3D: public Encodable {
    public:
        GlCopyTexSubImage3D() = default;
        GlCopyTexSubImage3D(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, int32_t Level, int32_t Xoffset, int32_t Yoffset, int32_t Zoffset, int32_t X, int32_t Y, int32_t Width, int32_t Height)
                : mextras(extras)
                , mTarget(Target)
                , mLevel(Level)
                , mXoffset(Xoffset)
                , mYoffset(Yoffset)
                , mZoffset(Zoffset)
                , mX(X)
                , mY(Y)
                , mWidth(Width)
                , mHeight(Height) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        int32_t mLevel;
        int32_t mXoffset;
        int32_t mYoffset;
        int32_t mZoffset;
        int32_t mX;
        int32_t mY;
        int32_t mWidth;
        int32_t mHeight;
    };

    class GlCopyTexSubImage3DOES: public Encodable {
    public:
        GlCopyTexSubImage3DOES() = default;
        GlCopyTexSubImage3DOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, int32_t Level, int32_t Xoffset, int32_t Yoffset, int32_t Zoffset, int32_t X, int32_t Y, int32_t Width, int32_t Height)
                : mextras(extras)
                , mTarget(Target)
                , mLevel(Level)
                , mXoffset(Xoffset)
                , mYoffset(Yoffset)
                , mZoffset(Zoffset)
                , mX(X)
                , mY(Y)
                , mWidth(Width)
                , mHeight(Height) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        int32_t mLevel;
        int32_t mXoffset;
        int32_t mYoffset;
        int32_t mZoffset;
        int32_t mX;
        int32_t mY;
        int32_t mWidth;
        int32_t mHeight;
    };

    class GlCopyTextureLevelsAPPLE: public Encodable {
    public:
        GlCopyTextureLevelsAPPLE() = default;
        GlCopyTextureLevelsAPPLE(const gapic::Vector<gapic::Encodable*>& extras, uint32_t DestinationTexture, uint32_t SourceTexture, int32_t SourceBaseLevel, int32_t SourceLevelCount)
                : mextras(extras)
                , mDestinationTexture(DestinationTexture)
                , mSourceTexture(SourceTexture)
                , mSourceBaseLevel(SourceBaseLevel)
                , mSourceLevelCount(SourceLevelCount) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mDestinationTexture;
        uint32_t mSourceTexture;
        int32_t mSourceBaseLevel;
        int32_t mSourceLevelCount;
    };

    class GlCoverFillPathInstancedNV: public Encodable {
    public:
        GlCoverFillPathInstancedNV() = default;
        GlCoverFillPathInstancedNV(const gapic::Vector<gapic::Encodable*>& extras, int32_t NumPaths, uint32_t PathNameType, Void__CP Paths, uint32_t PathBase, uint32_t CoverMode, uint32_t TransformType, GLfloat__CP TransformValues)
                : mextras(extras)
                , mNumPaths(NumPaths)
                , mPathNameType(PathNameType)
                , mPaths(Paths)
                , mPathBase(PathBase)
                , mCoverMode(CoverMode)
                , mTransformType(TransformType)
                , mTransformValues(TransformValues) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mNumPaths;
        uint32_t mPathNameType;
        Void__CP mPaths;
        uint32_t mPathBase;
        uint32_t mCoverMode;
        uint32_t mTransformType;
        GLfloat__CP mTransformValues;
    };

    class GlCoverFillPathNV: public Encodable {
    public:
        GlCoverFillPathNV() = default;
        GlCoverFillPathNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Path, uint32_t CoverMode)
                : mextras(extras)
                , mPath(Path)
                , mCoverMode(CoverMode) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mPath);
            e->Uint32(this->mCoverMode);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPath;
        uint32_t mCoverMode;
    };

    class GlCoverStrokePathInstancedNV: public Encodable {
    public:
        GlCoverStrokePathInstancedNV() = default;
        GlCoverStrokePathInstancedNV(const gapic::Vector<gapic::Encodable*>& extras, int32_t NumPaths, uint32_t PathNameType, Void__CP Paths, uint32_t PathBase, uint32_t CoverMode, uint32_t TransformType, GLfloat__CP TransformValues)
                : mextras(extras)
                , mNumPaths(NumPaths)
                , mPathNameType(PathNameType)
                , mPaths(Paths)
                , mPathBase(PathBase)
                , mCoverMode(CoverMode)
                , mTransformType(TransformType)
                , mTransformValues(TransformValues) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mNumPaths;
        uint32_t mPathNameType;
        Void__CP mPaths;
        uint32_t mPathBase;
        uint32_t mCoverMode;
        uint32_t mTransformType;
        GLfloat__CP mTransformValues;
    };

    class GlCoverStrokePathNV: public Encodable {
    public:
        GlCoverStrokePathNV() = default;
        GlCoverStrokePathNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Path, uint32_t CoverMode)
                : mextras(extras)
                , mPath(Path)
                , mCoverMode(CoverMode) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mPath);
            e->Uint32(this->mCoverMode);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPath;
        uint32_t mCoverMode;
    };

    class GlCoverageMaskNV: public Encodable {
    public:
        GlCoverageMaskNV() = default;
        GlCoverageMaskNV(const gapic::Vector<gapic::Encodable*>& extras, uint8_t Mask)
                : mextras(extras)
                , mMask(Mask) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint8(this->mMask);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint8_t mMask;
    };

    class GlCoverageModulationNV: public Encodable {
    public:
        GlCoverageModulationNV() = default;
        GlCoverageModulationNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Components)
                : mextras(extras)
                , mComponents(Components) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mComponents);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mComponents;
    };

    class GlCoverageModulationTableNV: public Encodable {
    public:
        GlCoverageModulationTableNV() = default;
        GlCoverageModulationTableNV(const gapic::Vector<gapic::Encodable*>& extras, int32_t N, GLfloat__CP V)
                : mextras(extras)
                , mN(N)
                , mV(V) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int32(this->mN);
            e->Struct(this->mV);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mN;
        GLfloat__CP mV;
    };

    class GlCoverageOperationNV: public Encodable {
    public:
        GlCoverageOperationNV() = default;
        GlCoverageOperationNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Operation)
                : mextras(extras)
                , mOperation(Operation) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mOperation);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mOperation;
    };

    class GlCreatePerfQueryINTEL: public Encodable {
    public:
        GlCreatePerfQueryINTEL() = default;
        GlCreatePerfQueryINTEL(const gapic::Vector<gapic::Encodable*>& extras, uint32_t QueryId, GLuint__P QueryHandle)
                : mextras(extras)
                , mQueryId(QueryId)
                , mQueryHandle(QueryHandle) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mQueryId);
            e->Struct(this->mQueryHandle);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mQueryId;
        GLuint__P mQueryHandle;
    };

    class GlCreateProgram: public Encodable {
    public:
        GlCreateProgram() = default;
        GlCreateProgram(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Result)
                : mextras(extras)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mResult);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mResult;
    };

    class GlCreateShader: public Encodable {
    public:
        GlCreateShader() = default;
        GlCreateShader(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Type, uint32_t Result)
                : mextras(extras)
                , mType(Type)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mType);
            e->Uint32(this->mResult);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mType;
        uint32_t mResult;
    };

    class GlCreateShaderProgramv: public Encodable {
    public:
        GlCreateShaderProgramv() = default;
        GlCreateShaderProgramv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Type, int32_t Count, GLchar__CP__CP Strings, uint32_t Result)
                : mextras(extras)
                , mType(Type)
                , mCount(Count)
                , mStrings(Strings)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mType;
        int32_t mCount;
        GLchar__CP__CP mStrings;
        uint32_t mResult;
    };

    class GlCreateShaderProgramvEXT: public Encodable {
    public:
        GlCreateShaderProgramvEXT() = default;
        GlCreateShaderProgramvEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Type, int32_t Count, GLchar__CP__P Strings, uint32_t Result)
                : mextras(extras)
                , mType(Type)
                , mCount(Count)
                , mStrings(Strings)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mType;
        int32_t mCount;
        GLchar__CP__P mStrings;
        uint32_t mResult;
    };

    class GlCullFace: public Encodable {
    public:
        GlCullFace() = default;
        GlCullFace(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Mode)
                : mextras(extras)
                , mMode(Mode) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mMode);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mMode;
    };

    class GlCurrentPaletteMatrixOES: public Encodable {
    public:
        GlCurrentPaletteMatrixOES() = default;
        GlCurrentPaletteMatrixOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Matrixpaletteindex)
                : mextras(extras)
                , mMatrixpaletteindex(Matrixpaletteindex) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mMatrixpaletteindex);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mMatrixpaletteindex;
    };

    class GlDebugMessageCallback: public Encodable {
    public:
        GlDebugMessageCallback() = default;
        GlDebugMessageCallback(const gapic::Vector<gapic::Encodable*>& extras, GLDEBUGPROC Callback, Void__CP UserParam)
                : mextras(extras)
                , mCallback(Callback)
                , mUserParam(UserParam) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Struct(this->mCallback);
            e->Struct(this->mUserParam);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        GLDEBUGPROC mCallback;
        Void__CP mUserParam;
    };

    class GlDebugMessageCallbackKHR: public Encodable {
    public:
        GlDebugMessageCallbackKHR() = default;
        GlDebugMessageCallbackKHR(const gapic::Vector<gapic::Encodable*>& extras, GLDEBUGPROC Callback, Void__CP UserParam)
                : mextras(extras)
                , mCallback(Callback)
                , mUserParam(UserParam) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Struct(this->mCallback);
            e->Struct(this->mUserParam);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        GLDEBUGPROC mCallback;
        Void__CP mUserParam;
    };

    class GlDebugMessageControl: public Encodable {
    public:
        GlDebugMessageControl() = default;
        GlDebugMessageControl(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Source, uint32_t Type, uint32_t Severity, int32_t Count, GLuint__CP Ids, uint8_t Enabled)
                : mextras(extras)
                , mSource(Source)
                , mType(Type)
                , mSeverity(Severity)
                , mCount(Count)
                , mIds(Ids)
                , mEnabled(Enabled) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mSource;
        uint32_t mType;
        uint32_t mSeverity;
        int32_t mCount;
        GLuint__CP mIds;
        uint8_t mEnabled;
    };

    class GlDebugMessageControlKHR: public Encodable {
    public:
        GlDebugMessageControlKHR() = default;
        GlDebugMessageControlKHR(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Source, uint32_t Type, uint32_t Severity, int32_t Count, GLuint__CP Ids, uint8_t Enabled)
                : mextras(extras)
                , mSource(Source)
                , mType(Type)
                , mSeverity(Severity)
                , mCount(Count)
                , mIds(Ids)
                , mEnabled(Enabled) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mSource;
        uint32_t mType;
        uint32_t mSeverity;
        int32_t mCount;
        GLuint__CP mIds;
        uint8_t mEnabled;
    };

    class GlDebugMessageInsert: public Encodable {
    public:
        GlDebugMessageInsert() = default;
        GlDebugMessageInsert(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Source, uint32_t Type, uint32_t Id, uint32_t Severity, int32_t Length, GLchar__CP Message)
                : mextras(extras)
                , mSource(Source)
                , mType(Type)
                , mId(Id)
                , mSeverity(Severity)
                , mLength(Length)
                , mMessage(Message) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mSource;
        uint32_t mType;
        uint32_t mId;
        uint32_t mSeverity;
        int32_t mLength;
        GLchar__CP mMessage;
    };

    class GlDebugMessageInsertKHR: public Encodable {
    public:
        GlDebugMessageInsertKHR() = default;
        GlDebugMessageInsertKHR(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Source, uint32_t Type, uint32_t Id, uint32_t Severity, int32_t Length, GLchar__CP Message)
                : mextras(extras)
                , mSource(Source)
                , mType(Type)
                , mId(Id)
                , mSeverity(Severity)
                , mLength(Length)
                , mMessage(Message) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mSource;
        uint32_t mType;
        uint32_t mId;
        uint32_t mSeverity;
        int32_t mLength;
        GLchar__CP mMessage;
    };

    class GlDeleteBuffers: public Encodable {
    public:
        GlDeleteBuffers() = default;
        GlDeleteBuffers(const gapic::Vector<gapic::Encodable*>& extras, int32_t Count, BufferId__CP Buffers)
                : mextras(extras)
                , mCount(Count)
                , mBuffers(Buffers) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int32(this->mCount);
            e->Struct(this->mBuffers);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mCount;
        BufferId__CP mBuffers;
    };

    class GlDeleteFencesNV: public Encodable {
    public:
        GlDeleteFencesNV() = default;
        GlDeleteFencesNV(const gapic::Vector<gapic::Encodable*>& extras, int32_t N, GLuint__CP Fences)
                : mextras(extras)
                , mN(N)
                , mFences(Fences) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int32(this->mN);
            e->Struct(this->mFences);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mN;
        GLuint__CP mFences;
    };

    class GlDeleteFramebuffers: public Encodable {
    public:
        GlDeleteFramebuffers() = default;
        GlDeleteFramebuffers(const gapic::Vector<gapic::Encodable*>& extras, int32_t Count, FramebufferId__CP Framebuffers)
                : mextras(extras)
                , mCount(Count)
                , mFramebuffers(Framebuffers) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int32(this->mCount);
            e->Struct(this->mFramebuffers);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mCount;
        FramebufferId__CP mFramebuffers;
    };

    class GlDeleteFramebuffersOES: public Encodable {
    public:
        GlDeleteFramebuffersOES() = default;
        GlDeleteFramebuffersOES(const gapic::Vector<gapic::Encodable*>& extras, int32_t N, GLuint__CP Framebuffers)
                : mextras(extras)
                , mN(N)
                , mFramebuffers(Framebuffers) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int32(this->mN);
            e->Struct(this->mFramebuffers);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mN;
        GLuint__CP mFramebuffers;
    };

    class GlDeletePathsNV: public Encodable {
    public:
        GlDeletePathsNV() = default;
        GlDeletePathsNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Path, int32_t Range)
                : mextras(extras)
                , mPath(Path)
                , mRange(Range) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mPath);
            e->Int32(this->mRange);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPath;
        int32_t mRange;
    };

    class GlDeletePerfMonitorsAMD: public Encodable {
    public:
        GlDeletePerfMonitorsAMD() = default;
        GlDeletePerfMonitorsAMD(const gapic::Vector<gapic::Encodable*>& extras, int32_t N, GLuint__P Monitors)
                : mextras(extras)
                , mN(N)
                , mMonitors(Monitors) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int32(this->mN);
            e->Struct(this->mMonitors);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mN;
        GLuint__P mMonitors;
    };

    class GlDeletePerfQueryINTEL: public Encodable {
    public:
        GlDeletePerfQueryINTEL() = default;
        GlDeletePerfQueryINTEL(const gapic::Vector<gapic::Encodable*>& extras, uint32_t QueryHandle)
                : mextras(extras)
                , mQueryHandle(QueryHandle) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mQueryHandle);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mQueryHandle;
    };

    class GlDeleteProgram: public Encodable {
    public:
        GlDeleteProgram() = default;
        GlDeleteProgram(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program)
                : mextras(extras)
                , mProgram(Program) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mProgram);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
    };

    class PipelineId__CP: public Encodable {
    public:
        PipelineId__CP() = default;
        PipelineId__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class GlDeleteProgramPipelines: public Encodable {
    public:
        GlDeleteProgramPipelines() = default;
        GlDeleteProgramPipelines(const gapic::Vector<gapic::Encodable*>& extras, int32_t N, PipelineId__CP Pipelines)
                : mextras(extras)
                , mN(N)
                , mPipelines(Pipelines) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int32(this->mN);
            e->Struct(this->mPipelines);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mN;
        PipelineId__CP mPipelines;
    };

    class GlDeleteProgramPipelinesEXT: public Encodable {
    public:
        GlDeleteProgramPipelinesEXT() = default;
        GlDeleteProgramPipelinesEXT(const gapic::Vector<gapic::Encodable*>& extras, int32_t N, PipelineId__CP Pipelines)
                : mextras(extras)
                , mN(N)
                , mPipelines(Pipelines) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int32(this->mN);
            e->Struct(this->mPipelines);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mN;
        PipelineId__CP mPipelines;
    };

    class QueryId__CP: public Encodable {
    public:
        QueryId__CP() = default;
        QueryId__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class GlDeleteQueries: public Encodable {
    public:
        GlDeleteQueries() = default;
        GlDeleteQueries(const gapic::Vector<gapic::Encodable*>& extras, int32_t Count, QueryId__CP Queries)
                : mextras(extras)
                , mCount(Count)
                , mQueries(Queries) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int32(this->mCount);
            e->Struct(this->mQueries);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mCount;
        QueryId__CP mQueries;
    };

    class GlDeleteQueriesEXT: public Encodable {
    public:
        GlDeleteQueriesEXT() = default;
        GlDeleteQueriesEXT(const gapic::Vector<gapic::Encodable*>& extras, int32_t Count, QueryId__CP Queries)
                : mextras(extras)
                , mCount(Count)
                , mQueries(Queries) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int32(this->mCount);
            e->Struct(this->mQueries);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mCount;
        QueryId__CP mQueries;
    };

    class RenderbufferId__CP: public Encodable {
    public:
        RenderbufferId__CP() = default;
        RenderbufferId__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class GlDeleteRenderbuffers: public Encodable {
    public:
        GlDeleteRenderbuffers() = default;
        GlDeleteRenderbuffers(const gapic::Vector<gapic::Encodable*>& extras, int32_t Count, RenderbufferId__CP Renderbuffers)
                : mextras(extras)
                , mCount(Count)
                , mRenderbuffers(Renderbuffers) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int32(this->mCount);
            e->Struct(this->mRenderbuffers);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mCount;
        RenderbufferId__CP mRenderbuffers;
    };

    class GlDeleteRenderbuffersOES: public Encodable {
    public:
        GlDeleteRenderbuffersOES() = default;
        GlDeleteRenderbuffersOES(const gapic::Vector<gapic::Encodable*>& extras, int32_t N, GLuint__CP Renderbuffers)
                : mextras(extras)
                , mN(N)
                , mRenderbuffers(Renderbuffers) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int32(this->mN);
            e->Struct(this->mRenderbuffers);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mN;
        GLuint__CP mRenderbuffers;
    };

    class SamplerId__CP: public Encodable {
    public:
        SamplerId__CP() = default;
        SamplerId__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class GlDeleteSamplers: public Encodable {
    public:
        GlDeleteSamplers() = default;
        GlDeleteSamplers(const gapic::Vector<gapic::Encodable*>& extras, int32_t Count, SamplerId__CP Samplers)
                : mextras(extras)
                , mCount(Count)
                , mSamplers(Samplers) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int32(this->mCount);
            e->Struct(this->mSamplers);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mCount;
        SamplerId__CP mSamplers;
    };

    class GlDeleteShader: public Encodable {
    public:
        GlDeleteShader() = default;
        GlDeleteShader(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Shader)
                : mextras(extras)
                , mShader(Shader) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mShader);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mShader;
    };

    class GlDeleteSync: public Encodable {
    public:
        GlDeleteSync() = default;
        GlDeleteSync(const gapic::Vector<gapic::Encodable*>& extras, GLsync Sync)
                : mextras(extras)
                , mSync(Sync) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Struct(this->mSync);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        GLsync mSync;
    };

    class GlDeleteSyncAPPLE: public Encodable {
    public:
        GlDeleteSyncAPPLE() = default;
        GlDeleteSyncAPPLE(const gapic::Vector<gapic::Encodable*>& extras, GLsync Sync)
                : mextras(extras)
                , mSync(Sync) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Struct(this->mSync);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        GLsync mSync;
    };

    class TextureId__CP: public Encodable {
    public:
        TextureId__CP() = default;
        TextureId__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class GlDeleteTextures: public Encodable {
    public:
        GlDeleteTextures() = default;
        GlDeleteTextures(const gapic::Vector<gapic::Encodable*>& extras, int32_t Count, TextureId__CP Textures)
                : mextras(extras)
                , mCount(Count)
                , mTextures(Textures) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int32(this->mCount);
            e->Struct(this->mTextures);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mCount;
        TextureId__CP mTextures;
    };

    class TransformFeedbackId__CP: public Encodable {
    public:
        TransformFeedbackId__CP() = default;
        TransformFeedbackId__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class GlDeleteTransformFeedbacks: public Encodable {
    public:
        GlDeleteTransformFeedbacks() = default;
        GlDeleteTransformFeedbacks(const gapic::Vector<gapic::Encodable*>& extras, int32_t N, TransformFeedbackId__CP Ids)
                : mextras(extras)
                , mN(N)
                , mIds(Ids) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int32(this->mN);
            e->Struct(this->mIds);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mN;
        TransformFeedbackId__CP mIds;
    };

    class VertexArrayId__CP: public Encodable {
    public:
        VertexArrayId__CP() = default;
        VertexArrayId__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class GlDeleteVertexArrays: public Encodable {
    public:
        GlDeleteVertexArrays() = default;
        GlDeleteVertexArrays(const gapic::Vector<gapic::Encodable*>& extras, int32_t Count, VertexArrayId__CP Arrays)
                : mextras(extras)
                , mCount(Count)
                , mArrays(Arrays) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int32(this->mCount);
            e->Struct(this->mArrays);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mCount;
        VertexArrayId__CP mArrays;
    };

    class GlDeleteVertexArraysOES: public Encodable {
    public:
        GlDeleteVertexArraysOES() = default;
        GlDeleteVertexArraysOES(const gapic::Vector<gapic::Encodable*>& extras, int32_t Count, VertexArrayId__CP Arrays)
                : mextras(extras)
                , mCount(Count)
                , mArrays(Arrays) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int32(this->mCount);
            e->Struct(this->mArrays);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mCount;
        VertexArrayId__CP mArrays;
    };

    class GlDepthFunc: public Encodable {
    public:
        GlDepthFunc() = default;
        GlDepthFunc(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Function)
                : mextras(extras)
                , mFunction(Function) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mFunction);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mFunction;
    };

    class GlDepthMask: public Encodable {
    public:
        GlDepthMask() = default;
        GlDepthMask(const gapic::Vector<gapic::Encodable*>& extras, uint8_t Enabled)
                : mextras(extras)
                , mEnabled(Enabled) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint8(this->mEnabled);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint8_t mEnabled;
    };

    class GlDepthRangeArrayfvNV: public Encodable {
    public:
        GlDepthRangeArrayfvNV() = default;
        GlDepthRangeArrayfvNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t First, int32_t Count, GLfloat__CP V)
                : mextras(extras)
                , mFirst(First)
                , mCount(Count)
                , mV(V) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mFirst;
        int32_t mCount;
        GLfloat__CP mV;
    };

    class GlDepthRangeIndexedfNV: public Encodable {
    public:
        GlDepthRangeIndexedfNV() = default;
        GlDepthRangeIndexedfNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Index, float N, float F)
                : mextras(extras)
                , mIndex(Index)
                , mN(N)
                , mF(F) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mIndex;
        float mN;
        float mF;
    };

    class GlDepthRangef: public Encodable {
    public:
        GlDepthRangef() = default;
        GlDepthRangef(const gapic::Vector<gapic::Encodable*>& extras, float Near, float Far)
                : mextras(extras)
                , mNear(Near)
                , mFar(Far) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Float32(this->mNear);
            e->Float32(this->mFar);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        float mNear;
        float mFar;
    };

    class GlDepthRangefOES: public Encodable {
    public:
        GlDepthRangefOES() = default;
        GlDepthRangefOES(const gapic::Vector<gapic::Encodable*>& extras, float N, float F)
                : mextras(extras)
                , mN(N)
                , mF(F) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Float32(this->mN);
            e->Float32(this->mF);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        float mN;
        float mF;
    };

    class GlDepthRangex: public Encodable {
    public:
        GlDepthRangex() = default;
        GlDepthRangex(const gapic::Vector<gapic::Encodable*>& extras, int32_t N, int32_t F)
                : mextras(extras)
                , mN(N)
                , mF(F) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int32(this->mN);
            e->Int32(this->mF);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mN;
        int32_t mF;
    };

    class GlDepthRangexOES: public Encodable {
    public:
        GlDepthRangexOES() = default;
        GlDepthRangexOES(const gapic::Vector<gapic::Encodable*>& extras, int32_t N, int32_t F)
                : mextras(extras)
                , mN(N)
                , mF(F) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int32(this->mN);
            e->Int32(this->mF);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mN;
        int32_t mF;
    };

    class GlDetachShader: public Encodable {
    public:
        GlDetachShader() = default;
        GlDetachShader(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, uint32_t Shader)
                : mextras(extras)
                , mProgram(Program)
                , mShader(Shader) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mProgram);
            e->Uint32(this->mShader);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        uint32_t mShader;
    };

    class GlDisable: public Encodable {
    public:
        GlDisable() = default;
        GlDisable(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Capability)
                : mextras(extras)
                , mCapability(Capability) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mCapability);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mCapability;
    };

    class GlDisableClientState: public Encodable {
    public:
        GlDisableClientState() = default;
        GlDisableClientState(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Array)
                : mextras(extras)
                , mArray(Array) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mArray);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mArray;
    };

    class GlDisableDriverControlQCOM: public Encodable {
    public:
        GlDisableDriverControlQCOM() = default;
        GlDisableDriverControlQCOM(const gapic::Vector<gapic::Encodable*>& extras, uint32_t DriverControl)
                : mextras(extras)
                , mDriverControl(DriverControl) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mDriverControl);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mDriverControl;
    };

    class GlDisableVertexAttribArray: public Encodable {
    public:
        GlDisableVertexAttribArray() = default;
        GlDisableVertexAttribArray(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Location)
                : mextras(extras)
                , mLocation(Location) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mLocation);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mLocation;
    };

    class GlDisablei: public Encodable {
    public:
        GlDisablei() = default;
        GlDisablei(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Capability, uint32_t Index)
                : mextras(extras)
                , mCapability(Capability)
                , mIndex(Index) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mCapability);
            e->Uint32(this->mIndex);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mCapability;
        uint32_t mIndex;
    };

    class GlDisableiEXT: public Encodable {
    public:
        GlDisableiEXT() = default;
        GlDisableiEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Index)
                : mextras(extras)
                , mTarget(Target)
                , mIndex(Index) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mTarget);
            e->Uint32(this->mIndex);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mIndex;
    };

    class GlDisableiNV: public Encodable {
    public:
        GlDisableiNV() = default;
        GlDisableiNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Index)
                : mextras(extras)
                , mTarget(Target)
                , mIndex(Index) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mTarget);
            e->Uint32(this->mIndex);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mIndex;
    };

    class GlDisableiOES: public Encodable {
    public:
        GlDisableiOES() = default;
        GlDisableiOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Index)
                : mextras(extras)
                , mTarget(Target)
                , mIndex(Index) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mTarget);
            e->Uint32(this->mIndex);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mIndex;
    };

    class GlDiscardFramebufferEXT: public Encodable {
    public:
        GlDiscardFramebufferEXT() = default;
        GlDiscardFramebufferEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, int32_t NumAttachments, GLenum__CP Attachments)
                : mextras(extras)
                , mTarget(Target)
                , mNumAttachments(NumAttachments)
                , mAttachments(Attachments) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        int32_t mNumAttachments;
        GLenum__CP mAttachments;
    };

    class GlDispatchCompute: public Encodable {
    public:
        GlDispatchCompute() = default;
        GlDispatchCompute(const gapic::Vector<gapic::Encodable*>& extras, uint32_t NumGroupsX, uint32_t NumGroupsY, uint32_t NumGroupsZ)
                : mextras(extras)
                , mNumGroupsX(NumGroupsX)
                , mNumGroupsY(NumGroupsY)
                , mNumGroupsZ(NumGroupsZ) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mNumGroupsX;
        uint32_t mNumGroupsY;
        uint32_t mNumGroupsZ;
    };

    class GlDispatchComputeIndirect: public Encodable {
    public:
        GlDispatchComputeIndirect() = default;
        GlDispatchComputeIndirect(const gapic::Vector<gapic::Encodable*>& extras, int32_t Indirect)
                : mextras(extras)
                , mIndirect(Indirect) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int32(this->mIndirect);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mIndirect;
    };

    class GlDrawArrays: public Encodable {
    public:
        GlDrawArrays() = default;
        GlDrawArrays(const gapic::Vector<gapic::Encodable*>& extras, uint32_t DrawMode, int32_t FirstIndex, int32_t IndicesCount)
                : mextras(extras)
                , mDrawMode(DrawMode)
                , mFirstIndex(FirstIndex)
                , mIndicesCount(IndicesCount) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mDrawMode;
        int32_t mFirstIndex;
        int32_t mIndicesCount;
    };

    class GlDrawArraysIndirect: public Encodable {
    public:
        GlDrawArraysIndirect() = default;
        GlDrawArraysIndirect(const gapic::Vector<gapic::Encodable*>& extras, uint32_t DrawMode, Void__CP Indirect)
                : mextras(extras)
                , mDrawMode(DrawMode)
                , mIndirect(Indirect) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mDrawMode);
            e->Struct(this->mIndirect);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mDrawMode;
        Void__CP mIndirect;
    };

    class GlDrawArraysInstanced: public Encodable {
    public:
        GlDrawArraysInstanced() = default;
        GlDrawArraysInstanced(const gapic::Vector<gapic::Encodable*>& extras, uint32_t DrawMode, int32_t FirstIndex, int32_t IndicesCount, int32_t InstanceCount)
                : mextras(extras)
                , mDrawMode(DrawMode)
                , mFirstIndex(FirstIndex)
                , mIndicesCount(IndicesCount)
                , mInstanceCount(InstanceCount) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mDrawMode;
        int32_t mFirstIndex;
        int32_t mIndicesCount;
        int32_t mInstanceCount;
    };

    class GlDrawArraysInstancedANGLE: public Encodable {
    public:
        GlDrawArraysInstancedANGLE() = default;
        GlDrawArraysInstancedANGLE(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Mode, int32_t First, int32_t Count, int32_t Primcount)
                : mextras(extras)
                , mMode(Mode)
                , mFirst(First)
                , mCount(Count)
                , mPrimcount(Primcount) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mMode;
        int32_t mFirst;
        int32_t mCount;
        int32_t mPrimcount;
    };

    class GlDrawArraysInstancedBaseInstanceEXT: public Encodable {
    public:
        GlDrawArraysInstancedBaseInstanceEXT() = default;
        GlDrawArraysInstancedBaseInstanceEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Mode, int32_t First, int32_t Count, int32_t Instancecount, uint32_t Baseinstance)
                : mextras(extras)
                , mMode(Mode)
                , mFirst(First)
                , mCount(Count)
                , mInstancecount(Instancecount)
                , mBaseinstance(Baseinstance) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mMode;
        int32_t mFirst;
        int32_t mCount;
        int32_t mInstancecount;
        uint32_t mBaseinstance;
    };

    class GlDrawArraysInstancedEXT: public Encodable {
    public:
        GlDrawArraysInstancedEXT() = default;
        GlDrawArraysInstancedEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Mode, int32_t Start, int32_t Count, int32_t Primcount)
                : mextras(extras)
                , mMode(Mode)
                , mStart(Start)
                , mCount(Count)
                , mPrimcount(Primcount) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mMode;
        int32_t mStart;
        int32_t mCount;
        int32_t mPrimcount;
    };

    class GlDrawArraysInstancedNV: public Encodable {
    public:
        GlDrawArraysInstancedNV() = default;
        GlDrawArraysInstancedNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Mode, int32_t First, int32_t Count, int32_t Primcount)
                : mextras(extras)
                , mMode(Mode)
                , mFirst(First)
                , mCount(Count)
                , mPrimcount(Primcount) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mMode;
        int32_t mFirst;
        int32_t mCount;
        int32_t mPrimcount;
    };

    class GlDrawBuffers: public Encodable {
    public:
        GlDrawBuffers() = default;
        GlDrawBuffers(const gapic::Vector<gapic::Encodable*>& extras, int32_t N, GLenum__CP Bufs)
                : mextras(extras)
                , mN(N)
                , mBufs(Bufs) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int32(this->mN);
            e->Struct(this->mBufs);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mN;
        GLenum__CP mBufs;
    };

    class GlDrawBuffersEXT: public Encodable {
    public:
        GlDrawBuffersEXT() = default;
        GlDrawBuffersEXT(const gapic::Vector<gapic::Encodable*>& extras, int32_t N, GLenum__CP Bufs)
                : mextras(extras)
                , mN(N)
                , mBufs(Bufs) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int32(this->mN);
            e->Struct(this->mBufs);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mN;
        GLenum__CP mBufs;
    };

    class GlDrawBuffersIndexedEXT: public Encodable {
    public:
        GlDrawBuffersIndexedEXT() = default;
        GlDrawBuffersIndexedEXT(const gapic::Vector<gapic::Encodable*>& extras, int32_t N, GLenum__CP Location, GLint__CP Indices)
                : mextras(extras)
                , mN(N)
                , mLocation(Location)
                , mIndices(Indices) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mN;
        GLenum__CP mLocation;
        GLint__CP mIndices;
    };

    class GlDrawBuffersNV: public Encodable {
    public:
        GlDrawBuffersNV() = default;
        GlDrawBuffersNV(const gapic::Vector<gapic::Encodable*>& extras, int32_t N, GLenum__CP Bufs)
                : mextras(extras)
                , mN(N)
                , mBufs(Bufs) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int32(this->mN);
            e->Struct(this->mBufs);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mN;
        GLenum__CP mBufs;
    };

    class IndicesPointer: public Encodable {
    public:
        IndicesPointer() = default;
        IndicesPointer(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class GlDrawElements: public Encodable {
    public:
        GlDrawElements() = default;
        GlDrawElements(const gapic::Vector<gapic::Encodable*>& extras, uint32_t DrawMode, int32_t IndicesCount, uint32_t IndicesType, IndicesPointer Indices)
                : mextras(extras)
                , mDrawMode(DrawMode)
                , mIndicesCount(IndicesCount)
                , mIndicesType(IndicesType)
                , mIndices(Indices) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mDrawMode;
        int32_t mIndicesCount;
        uint32_t mIndicesType;
        IndicesPointer mIndices;
    };

    class GlDrawElementsBaseVertex: public Encodable {
    public:
        GlDrawElementsBaseVertex() = default;
        GlDrawElementsBaseVertex(const gapic::Vector<gapic::Encodable*>& extras, uint32_t DrawMode, int32_t IndicesCount, uint32_t IndicesType, IndicesPointer Indices, int32_t BaseVertex)
                : mextras(extras)
                , mDrawMode(DrawMode)
                , mIndicesCount(IndicesCount)
                , mIndicesType(IndicesType)
                , mIndices(Indices)
                , mBaseVertex(BaseVertex) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mDrawMode;
        int32_t mIndicesCount;
        uint32_t mIndicesType;
        IndicesPointer mIndices;
        int32_t mBaseVertex;
    };

    class GlDrawElementsBaseVertexEXT: public Encodable {
    public:
        GlDrawElementsBaseVertexEXT() = default;
        GlDrawElementsBaseVertexEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Mode, int32_t Count, uint32_t Type, IndicesPointer Indices, int32_t Basevertex)
                : mextras(extras)
                , mMode(Mode)
                , mCount(Count)
                , mType(Type)
                , mIndices(Indices)
                , mBasevertex(Basevertex) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mMode;
        int32_t mCount;
        uint32_t mType;
        IndicesPointer mIndices;
        int32_t mBasevertex;
    };

    class GlDrawElementsBaseVertexOES: public Encodable {
    public:
        GlDrawElementsBaseVertexOES() = default;
        GlDrawElementsBaseVertexOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Mode, int32_t Count, uint32_t Type, IndicesPointer Indices, int32_t Basevertex)
                : mextras(extras)
                , mMode(Mode)
                , mCount(Count)
                , mType(Type)
                , mIndices(Indices)
                , mBasevertex(Basevertex) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mMode;
        int32_t mCount;
        uint32_t mType;
        IndicesPointer mIndices;
        int32_t mBasevertex;
    };

    class GlDrawElementsIndirect: public Encodable {
    public:
        GlDrawElementsIndirect() = default;
        GlDrawElementsIndirect(const gapic::Vector<gapic::Encodable*>& extras, uint32_t DrawMode, uint32_t IndicesType, Void__CP Indirect)
                : mextras(extras)
                , mDrawMode(DrawMode)
                , mIndicesType(IndicesType)
                , mIndirect(Indirect) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mDrawMode;
        uint32_t mIndicesType;
        Void__CP mIndirect;
    };

    class GlDrawElementsInstanced: public Encodable {
    public:
        GlDrawElementsInstanced() = default;
        GlDrawElementsInstanced(const gapic::Vector<gapic::Encodable*>& extras, uint32_t DrawMode, int32_t IndicesCount, uint32_t IndicesType, IndicesPointer Indices, int32_t InstanceCount)
                : mextras(extras)
                , mDrawMode(DrawMode)
                , mIndicesCount(IndicesCount)
                , mIndicesType(IndicesType)
                , mIndices(Indices)
                , mInstanceCount(InstanceCount) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mDrawMode;
        int32_t mIndicesCount;
        uint32_t mIndicesType;
        IndicesPointer mIndices;
        int32_t mInstanceCount;
    };

    class GlDrawElementsInstancedANGLE: public Encodable {
    public:
        GlDrawElementsInstancedANGLE() = default;
        GlDrawElementsInstancedANGLE(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Mode, int32_t Count, uint32_t Type, IndicesPointer Indices, int32_t Primcount)
                : mextras(extras)
                , mMode(Mode)
                , mCount(Count)
                , mType(Type)
                , mIndices(Indices)
                , mPrimcount(Primcount) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mMode;
        int32_t mCount;
        uint32_t mType;
        IndicesPointer mIndices;
        int32_t mPrimcount;
    };

    class GlDrawElementsInstancedBaseInstanceEXT: public Encodable {
    public:
        GlDrawElementsInstancedBaseInstanceEXT() = default;
        GlDrawElementsInstancedBaseInstanceEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Mode, int32_t Count, uint32_t Type, Void__CP Indices, int32_t Instancecount, uint32_t Baseinstance)
                : mextras(extras)
                , mMode(Mode)
                , mCount(Count)
                , mType(Type)
                , mIndices(Indices)
                , mInstancecount(Instancecount)
                , mBaseinstance(Baseinstance) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mMode;
        int32_t mCount;
        uint32_t mType;
        Void__CP mIndices;
        int32_t mInstancecount;
        uint32_t mBaseinstance;
    };

    class GlDrawElementsInstancedBaseVertex: public Encodable {
    public:
        GlDrawElementsInstancedBaseVertex() = default;
        GlDrawElementsInstancedBaseVertex(const gapic::Vector<gapic::Encodable*>& extras, uint32_t DrawMode, int32_t IndicesCount, uint32_t IndicesType, IndicesPointer Indices, int32_t InstanceCount, int32_t BaseVertex)
                : mextras(extras)
                , mDrawMode(DrawMode)
                , mIndicesCount(IndicesCount)
                , mIndicesType(IndicesType)
                , mIndices(Indices)
                , mInstanceCount(InstanceCount)
                , mBaseVertex(BaseVertex) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mDrawMode;
        int32_t mIndicesCount;
        uint32_t mIndicesType;
        IndicesPointer mIndices;
        int32_t mInstanceCount;
        int32_t mBaseVertex;
    };

    class GlDrawElementsInstancedBaseVertexBaseInstanceEXT: public Encodable {
    public:
        GlDrawElementsInstancedBaseVertexBaseInstanceEXT() = default;
        GlDrawElementsInstancedBaseVertexBaseInstanceEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Mode, int32_t Count, uint32_t Type, Void__CP Indices, int32_t Instancecount, int32_t Basevertex, uint32_t Baseinstance)
                : mextras(extras)
                , mMode(Mode)
                , mCount(Count)
                , mType(Type)
                , mIndices(Indices)
                , mInstancecount(Instancecount)
                , mBasevertex(Basevertex)
                , mBaseinstance(Baseinstance) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mMode;
        int32_t mCount;
        uint32_t mType;
        Void__CP mIndices;
        int32_t mInstancecount;
        int32_t mBasevertex;
        uint32_t mBaseinstance;
    };

    class GlDrawElementsInstancedBaseVertexEXT: public Encodable {
    public:
        GlDrawElementsInstancedBaseVertexEXT() = default;
        GlDrawElementsInstancedBaseVertexEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Mode, int32_t Count, uint32_t Type, IndicesPointer Indices, int32_t Instancecount, int32_t Basevertex)
                : mextras(extras)
                , mMode(Mode)
                , mCount(Count)
                , mType(Type)
                , mIndices(Indices)
                , mInstancecount(Instancecount)
                , mBasevertex(Basevertex) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mMode;
        int32_t mCount;
        uint32_t mType;
        IndicesPointer mIndices;
        int32_t mInstancecount;
        int32_t mBasevertex;
    };

    class GlDrawElementsInstancedBaseVertexOES: public Encodable {
    public:
        GlDrawElementsInstancedBaseVertexOES() = default;
        GlDrawElementsInstancedBaseVertexOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Mode, int32_t Count, uint32_t Type, IndicesPointer Indices, int32_t Instancecount, int32_t Basevertex)
                : mextras(extras)
                , mMode(Mode)
                , mCount(Count)
                , mType(Type)
                , mIndices(Indices)
                , mInstancecount(Instancecount)
                , mBasevertex(Basevertex) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mMode;
        int32_t mCount;
        uint32_t mType;
        IndicesPointer mIndices;
        int32_t mInstancecount;
        int32_t mBasevertex;
    };

    class GlDrawElementsInstancedEXT: public Encodable {
    public:
        GlDrawElementsInstancedEXT() = default;
        GlDrawElementsInstancedEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Mode, int32_t Count, uint32_t Type, IndicesPointer Indices, int32_t Primcount)
                : mextras(extras)
                , mMode(Mode)
                , mCount(Count)
                , mType(Type)
                , mIndices(Indices)
                , mPrimcount(Primcount) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mMode;
        int32_t mCount;
        uint32_t mType;
        IndicesPointer mIndices;
        int32_t mPrimcount;
    };

    class GlDrawElementsInstancedNV: public Encodable {
    public:
        GlDrawElementsInstancedNV() = default;
        GlDrawElementsInstancedNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Mode, int32_t Count, uint32_t Type, IndicesPointer Indices, int32_t Primcount)
                : mextras(extras)
                , mMode(Mode)
                , mCount(Count)
                , mType(Type)
                , mIndices(Indices)
                , mPrimcount(Primcount) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mMode;
        int32_t mCount;
        uint32_t mType;
        IndicesPointer mIndices;
        int32_t mPrimcount;
    };

    class GlDrawRangeElements: public Encodable {
    public:
        GlDrawRangeElements() = default;
        GlDrawRangeElements(const gapic::Vector<gapic::Encodable*>& extras, uint32_t DrawMode, uint32_t Start, uint32_t End, int32_t IndicesCount, uint32_t IndicesType, IndicesPointer Indices)
                : mextras(extras)
                , mDrawMode(DrawMode)
                , mStart(Start)
                , mEnd(End)
                , mIndicesCount(IndicesCount)
                , mIndicesType(IndicesType)
                , mIndices(Indices) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mDrawMode;
        uint32_t mStart;
        uint32_t mEnd;
        int32_t mIndicesCount;
        uint32_t mIndicesType;
        IndicesPointer mIndices;
    };

    class GlDrawRangeElementsBaseVertex: public Encodable {
    public:
        GlDrawRangeElementsBaseVertex() = default;
        GlDrawRangeElementsBaseVertex(const gapic::Vector<gapic::Encodable*>& extras, uint32_t DrawMode, uint32_t Start, uint32_t End, int32_t IndicesCount, uint32_t IndicesType, IndicesPointer Indices, int32_t BaseVertex)
                : mextras(extras)
                , mDrawMode(DrawMode)
                , mStart(Start)
                , mEnd(End)
                , mIndicesCount(IndicesCount)
                , mIndicesType(IndicesType)
                , mIndices(Indices)
                , mBaseVertex(BaseVertex) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mDrawMode;
        uint32_t mStart;
        uint32_t mEnd;
        int32_t mIndicesCount;
        uint32_t mIndicesType;
        IndicesPointer mIndices;
        int32_t mBaseVertex;
    };

    class GlDrawRangeElementsBaseVertexEXT: public Encodable {
    public:
        GlDrawRangeElementsBaseVertexEXT() = default;
        GlDrawRangeElementsBaseVertexEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Mode, uint32_t Start, uint32_t End, int32_t Count, uint32_t Type, IndicesPointer Indices, int32_t Basevertex)
                : mextras(extras)
                , mMode(Mode)
                , mStart(Start)
                , mEnd(End)
                , mCount(Count)
                , mType(Type)
                , mIndices(Indices)
                , mBasevertex(Basevertex) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mMode;
        uint32_t mStart;
        uint32_t mEnd;
        int32_t mCount;
        uint32_t mType;
        IndicesPointer mIndices;
        int32_t mBasevertex;
    };

    class GlDrawRangeElementsBaseVertexOES: public Encodable {
    public:
        GlDrawRangeElementsBaseVertexOES() = default;
        GlDrawRangeElementsBaseVertexOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Mode, uint32_t Start, uint32_t End, int32_t Count, uint32_t Type, IndicesPointer Indices, int32_t Basevertex)
                : mextras(extras)
                , mMode(Mode)
                , mStart(Start)
                , mEnd(End)
                , mCount(Count)
                , mType(Type)
                , mIndices(Indices)
                , mBasevertex(Basevertex) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mMode;
        uint32_t mStart;
        uint32_t mEnd;
        int32_t mCount;
        uint32_t mType;
        IndicesPointer mIndices;
        int32_t mBasevertex;
    };

    class GlDrawTexfOES: public Encodable {
    public:
        GlDrawTexfOES() = default;
        GlDrawTexfOES(const gapic::Vector<gapic::Encodable*>& extras, float X, float Y, float Z, float Width, float Height)
                : mextras(extras)
                , mX(X)
                , mY(Y)
                , mZ(Z)
                , mWidth(Width)
                , mHeight(Height) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        float mX;
        float mY;
        float mZ;
        float mWidth;
        float mHeight;
    };

    class GlDrawTexfvOES: public Encodable {
    public:
        GlDrawTexfvOES() = default;
        GlDrawTexfvOES(const gapic::Vector<gapic::Encodable*>& extras, GLfloat__CP Coords)
                : mextras(extras)
                , mCoords(Coords) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Struct(this->mCoords);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        GLfloat__CP mCoords;
    };

    class GlDrawTexiOES: public Encodable {
    public:
        GlDrawTexiOES() = default;
        GlDrawTexiOES(const gapic::Vector<gapic::Encodable*>& extras, int32_t X, int32_t Y, int32_t Z, int32_t Width, int32_t Height)
                : mextras(extras)
                , mX(X)
                , mY(Y)
                , mZ(Z)
                , mWidth(Width)
                , mHeight(Height) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mX;
        int32_t mY;
        int32_t mZ;
        int32_t mWidth;
        int32_t mHeight;
    };

    class GlDrawTexivOES: public Encodable {
    public:
        GlDrawTexivOES() = default;
        GlDrawTexivOES(const gapic::Vector<gapic::Encodable*>& extras, GLint__CP Coords)
                : mextras(extras)
                , mCoords(Coords) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Struct(this->mCoords);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        GLint__CP mCoords;
    };

    class GlDrawTexsOES: public Encodable {
    public:
        GlDrawTexsOES() = default;
        GlDrawTexsOES(const gapic::Vector<gapic::Encodable*>& extras, int16_t X, int16_t Y, int16_t Z, int16_t Width, int16_t Height)
                : mextras(extras)
                , mX(X)
                , mY(Y)
                , mZ(Z)
                , mWidth(Width)
                , mHeight(Height) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int16_t mX;
        int16_t mY;
        int16_t mZ;
        int16_t mWidth;
        int16_t mHeight;
    };

    class GlDrawTexsvOES: public Encodable {
    public:
        GlDrawTexsvOES() = default;
        GlDrawTexsvOES(const gapic::Vector<gapic::Encodable*>& extras, GLshort__CP Coords)
                : mextras(extras)
                , mCoords(Coords) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Struct(this->mCoords);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        GLshort__CP mCoords;
    };

    class GlDrawTexxOES: public Encodable {
    public:
        GlDrawTexxOES() = default;
        GlDrawTexxOES(const gapic::Vector<gapic::Encodable*>& extras, int32_t X, int32_t Y, int32_t Z, int32_t Width, int32_t Height)
                : mextras(extras)
                , mX(X)
                , mY(Y)
                , mZ(Z)
                , mWidth(Width)
                , mHeight(Height) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mX;
        int32_t mY;
        int32_t mZ;
        int32_t mWidth;
        int32_t mHeight;
    };

    class GlDrawTexxvOES: public Encodable {
    public:
        GlDrawTexxvOES() = default;
        GlDrawTexxvOES(const gapic::Vector<gapic::Encodable*>& extras, GLfixed__CP Coords)
                : mextras(extras)
                , mCoords(Coords) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Struct(this->mCoords);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        GLfixed__CP mCoords;
    };

    class GlEGLImageTargetRenderbufferStorageOES: public Encodable {
    public:
        GlEGLImageTargetRenderbufferStorageOES() = default;
        GlEGLImageTargetRenderbufferStorageOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, GLeglImageOES Image)
                : mextras(extras)
                , mTarget(Target)
                , mImage(Image) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mTarget);
            e->Struct(this->mImage);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        GLeglImageOES mImage;
    };

    class GlEGLImageTargetTexture2DOES: public Encodable {
    public:
        GlEGLImageTargetTexture2DOES() = default;
        GlEGLImageTargetTexture2DOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, GLeglImageOES Image)
                : mextras(extras)
                , mTarget(Target)
                , mImage(Image) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mTarget);
            e->Struct(this->mImage);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        GLeglImageOES mImage;
    };

    class GlEnable: public Encodable {
    public:
        GlEnable() = default;
        GlEnable(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Capability)
                : mextras(extras)
                , mCapability(Capability) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mCapability);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mCapability;
    };

    class GlEnableClientState: public Encodable {
    public:
        GlEnableClientState() = default;
        GlEnableClientState(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Array)
                : mextras(extras)
                , mArray(Array) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mArray);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mArray;
    };

    class GlEnableDriverControlQCOM: public Encodable {
    public:
        GlEnableDriverControlQCOM() = default;
        GlEnableDriverControlQCOM(const gapic::Vector<gapic::Encodable*>& extras, uint32_t DriverControl)
                : mextras(extras)
                , mDriverControl(DriverControl) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mDriverControl);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mDriverControl;
    };

    class GlEnableVertexAttribArray: public Encodable {
    public:
        GlEnableVertexAttribArray() = default;
        GlEnableVertexAttribArray(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Location)
                : mextras(extras)
                , mLocation(Location) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mLocation);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mLocation;
    };

    class GlEnablei: public Encodable {
    public:
        GlEnablei() = default;
        GlEnablei(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Capability, uint32_t Index)
                : mextras(extras)
                , mCapability(Capability)
                , mIndex(Index) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mCapability);
            e->Uint32(this->mIndex);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mCapability;
        uint32_t mIndex;
    };

    class GlEnableiEXT: public Encodable {
    public:
        GlEnableiEXT() = default;
        GlEnableiEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Index)
                : mextras(extras)
                , mTarget(Target)
                , mIndex(Index) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mTarget);
            e->Uint32(this->mIndex);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mIndex;
    };

    class GlEnableiNV: public Encodable {
    public:
        GlEnableiNV() = default;
        GlEnableiNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Index)
                : mextras(extras)
                , mTarget(Target)
                , mIndex(Index) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mTarget);
            e->Uint32(this->mIndex);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mIndex;
    };

    class GlEnableiOES: public Encodable {
    public:
        GlEnableiOES() = default;
        GlEnableiOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Index)
                : mextras(extras)
                , mTarget(Target)
                , mIndex(Index) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mTarget);
            e->Uint32(this->mIndex);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mIndex;
    };

    class GlEndConditionalRenderNV: public Encodable {
    public:
        GlEndConditionalRenderNV() = default;
        GlEndConditionalRenderNV(const gapic::Vector<gapic::Encodable*>& extras)
                : mextras(extras) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
    };

    class GlEndPerfMonitorAMD: public Encodable {
    public:
        GlEndPerfMonitorAMD() = default;
        GlEndPerfMonitorAMD(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Monitor)
                : mextras(extras)
                , mMonitor(Monitor) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mMonitor);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mMonitor;
    };

    class GlEndPerfQueryINTEL: public Encodable {
    public:
        GlEndPerfQueryINTEL() = default;
        GlEndPerfQueryINTEL(const gapic::Vector<gapic::Encodable*>& extras, uint32_t QueryHandle)
                : mextras(extras)
                , mQueryHandle(QueryHandle) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mQueryHandle);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mQueryHandle;
    };

    class GlEndQuery: public Encodable {
    public:
        GlEndQuery() = default;
        GlEndQuery(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target)
                : mextras(extras)
                , mTarget(Target) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mTarget);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
    };

    class GlEndQueryEXT: public Encodable {
    public:
        GlEndQueryEXT() = default;
        GlEndQueryEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target)
                : mextras(extras)
                , mTarget(Target) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mTarget);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
    };

    class GlEndTilingQCOM: public Encodable {
    public:
        GlEndTilingQCOM() = default;
        GlEndTilingQCOM(const gapic::Vector<gapic::Encodable*>& extras, uint32_t PreserveMask)
                : mextras(extras)
                , mPreserveMask(PreserveMask) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mPreserveMask);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPreserveMask;
    };

    class GlEndTransformFeedback: public Encodable {
    public:
        GlEndTransformFeedback() = default;
        GlEndTransformFeedback(const gapic::Vector<gapic::Encodable*>& extras)
                : mextras(extras) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
    };

    class Void__P__P: public Encodable {
    public:
        Void__P__P() = default;
        Void__P__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class GlExtGetBufferPointervQCOM: public Encodable {
    public:
        GlExtGetBufferPointervQCOM() = default;
        GlExtGetBufferPointervQCOM(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, Void__P__P Params)
                : mextras(extras)
                , mTarget(Target)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mTarget);
            e->Struct(this->mParams);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        Void__P__P mParams;
    };

    class GlExtGetBuffersQCOM: public Encodable {
    public:
        GlExtGetBuffersQCOM() = default;
        GlExtGetBuffersQCOM(const gapic::Vector<gapic::Encodable*>& extras, BufferId__P Buffers, int32_t MaxBuffers, GLint__P NumBuffers)
                : mextras(extras)
                , mBuffers(Buffers)
                , mMaxBuffers(MaxBuffers)
                , mNumBuffers(NumBuffers) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        BufferId__P mBuffers;
        int32_t mMaxBuffers;
        GLint__P mNumBuffers;
    };

    class GlExtGetFramebuffersQCOM: public Encodable {
    public:
        GlExtGetFramebuffersQCOM() = default;
        GlExtGetFramebuffersQCOM(const gapic::Vector<gapic::Encodable*>& extras, FramebufferId__P Framebuffers, int32_t MaxFramebuffers, GLint__P NumFramebuffers)
                : mextras(extras)
                , mFramebuffers(Framebuffers)
                , mMaxFramebuffers(MaxFramebuffers)
                , mNumFramebuffers(NumFramebuffers) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        FramebufferId__P mFramebuffers;
        int32_t mMaxFramebuffers;
        GLint__P mNumFramebuffers;
    };

    class GlExtGetProgramBinarySourceQCOM: public Encodable {
    public:
        GlExtGetProgramBinarySourceQCOM() = default;
        GlExtGetProgramBinarySourceQCOM(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, uint32_t Shadertype, GLchar__P Source, GLint__P Length)
                : mextras(extras)
                , mProgram(Program)
                , mShadertype(Shadertype)
                , mSource(Source)
                , mLength(Length) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        uint32_t mShadertype;
        GLchar__P mSource;
        GLint__P mLength;
    };

    class ProgramId__P: public Encodable {
    public:
        ProgramId__P() = default;
        ProgramId__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class GlExtGetProgramsQCOM: public Encodable {
    public:
        GlExtGetProgramsQCOM() = default;
        GlExtGetProgramsQCOM(const gapic::Vector<gapic::Encodable*>& extras, ProgramId__P Programs, int32_t MaxPrograms, GLint__P NumPrograms)
                : mextras(extras)
                , mPrograms(Programs)
                , mMaxPrograms(MaxPrograms)
                , mNumPrograms(NumPrograms) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        ProgramId__P mPrograms;
        int32_t mMaxPrograms;
        GLint__P mNumPrograms;
    };

    class RenderbufferId__P: public Encodable {
    public:
        RenderbufferId__P() = default;
        RenderbufferId__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class GlExtGetRenderbuffersQCOM: public Encodable {
    public:
        GlExtGetRenderbuffersQCOM() = default;
        GlExtGetRenderbuffersQCOM(const gapic::Vector<gapic::Encodable*>& extras, RenderbufferId__P Renderbuffers, int32_t MaxRenderbuffers, GLint__P NumRenderbuffers)
                : mextras(extras)
                , mRenderbuffers(Renderbuffers)
                , mMaxRenderbuffers(MaxRenderbuffers)
                , mNumRenderbuffers(NumRenderbuffers) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        RenderbufferId__P mRenderbuffers;
        int32_t mMaxRenderbuffers;
        GLint__P mNumRenderbuffers;
    };

    class ShaderId__P: public Encodable {
    public:
        ShaderId__P() = default;
        ShaderId__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class GlExtGetShadersQCOM: public Encodable {
    public:
        GlExtGetShadersQCOM() = default;
        GlExtGetShadersQCOM(const gapic::Vector<gapic::Encodable*>& extras, ShaderId__P Shaders, int32_t MaxShaders, GLint__P NumShaders)
                : mextras(extras)
                , mShaders(Shaders)
                , mMaxShaders(MaxShaders)
                , mNumShaders(NumShaders) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        ShaderId__P mShaders;
        int32_t mMaxShaders;
        GLint__P mNumShaders;
    };

    class GlExtGetTexLevelParameterivQCOM: public Encodable {
    public:
        GlExtGetTexLevelParameterivQCOM() = default;
        GlExtGetTexLevelParameterivQCOM(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Texture, uint32_t Face, int32_t Level, uint32_t Pname, GLint__P Params)
                : mextras(extras)
                , mTexture(Texture)
                , mFace(Face)
                , mLevel(Level)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTexture;
        uint32_t mFace;
        int32_t mLevel;
        uint32_t mPname;
        GLint__P mParams;
    };

    class GlExtGetTexSubImageQCOM: public Encodable {
    public:
        GlExtGetTexSubImageQCOM() = default;
        GlExtGetTexSubImageQCOM(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, int32_t Level, int32_t Xoffset, int32_t Yoffset, int32_t Zoffset, int32_t Width, int32_t Height, int32_t Depth, uint32_t Format, uint32_t Type, Void__P Texels)
                : mextras(extras)
                , mTarget(Target)
                , mLevel(Level)
                , mXoffset(Xoffset)
                , mYoffset(Yoffset)
                , mZoffset(Zoffset)
                , mWidth(Width)
                , mHeight(Height)
                , mDepth(Depth)
                , mFormat(Format)
                , mType(Type)
                , mTexels(Texels) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        int32_t mLevel;
        int32_t mXoffset;
        int32_t mYoffset;
        int32_t mZoffset;
        int32_t mWidth;
        int32_t mHeight;
        int32_t mDepth;
        uint32_t mFormat;
        uint32_t mType;
        Void__P mTexels;
    };

    class TextureId__P: public Encodable {
    public:
        TextureId__P() = default;
        TextureId__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class GlExtGetTexturesQCOM: public Encodable {
    public:
        GlExtGetTexturesQCOM() = default;
        GlExtGetTexturesQCOM(const gapic::Vector<gapic::Encodable*>& extras, TextureId__P Textures, int32_t MaxTextures, GLint__P NumTextures)
                : mextras(extras)
                , mTextures(Textures)
                , mMaxTextures(MaxTextures)
                , mNumTextures(NumTextures) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        TextureId__P mTextures;
        int32_t mMaxTextures;
        GLint__P mNumTextures;
    };

    class GlExtIsProgramBinaryQCOM: public Encodable {
    public:
        GlExtIsProgramBinaryQCOM() = default;
        GlExtIsProgramBinaryQCOM(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, uint8_t Result)
                : mextras(extras)
                , mProgram(Program)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mProgram);
            e->Uint8(this->mResult);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        uint8_t mResult;
    };

    class GlExtTexObjectStateOverrideiQCOM: public Encodable {
    public:
        GlExtTexObjectStateOverrideiQCOM() = default;
        GlExtTexObjectStateOverrideiQCOM(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Pname, int32_t Param)
                : mextras(extras)
                , mTarget(Target)
                , mPname(Pname)
                , mParam(Param) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mPname;
        int32_t mParam;
    };

    class GlFenceSync: public Encodable {
    public:
        GlFenceSync() = default;
        GlFenceSync(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Condition, uint32_t SyncFlags, GLsync Result)
                : mextras(extras)
                , mCondition(Condition)
                , mSyncFlags(SyncFlags)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mCondition;
        uint32_t mSyncFlags;
        GLsync mResult;
    };

    class GlFenceSyncAPPLE: public Encodable {
    public:
        GlFenceSyncAPPLE() = default;
        GlFenceSyncAPPLE(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Condition, uint32_t Flag, GLsync Result)
                : mextras(extras)
                , mCondition(Condition)
                , mFlag(Flag)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mCondition;
        uint32_t mFlag;
        GLsync mResult;
    };

    class GlFinish: public Encodable {
    public:
        GlFinish() = default;
        GlFinish(const gapic::Vector<gapic::Encodable*>& extras)
                : mextras(extras) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
    };

    class GlFinishFenceNV: public Encodable {
    public:
        GlFinishFenceNV() = default;
        GlFinishFenceNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Fence)
                : mextras(extras)
                , mFence(Fence) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mFence);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mFence;
    };

    class GlFlush: public Encodable {
    public:
        GlFlush() = default;
        GlFlush(const gapic::Vector<gapic::Encodable*>& extras)
                : mextras(extras) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
    };

    class GlFlushMappedBufferRange: public Encodable {
    public:
        GlFlushMappedBufferRange() = default;
        GlFlushMappedBufferRange(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, int32_t Offset, int32_t Length)
                : mextras(extras)
                , mTarget(Target)
                , mOffset(Offset)
                , mLength(Length) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        int32_t mOffset;
        int32_t mLength;
    };

    class GlFlushMappedBufferRangeEXT: public Encodable {
    public:
        GlFlushMappedBufferRangeEXT() = default;
        GlFlushMappedBufferRangeEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, int32_t Offset, int32_t Length)
                : mextras(extras)
                , mTarget(Target)
                , mOffset(Offset)
                , mLength(Length) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        int32_t mOffset;
        int32_t mLength;
    };

    class GlFogf: public Encodable {
    public:
        GlFogf() = default;
        GlFogf(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Pname, float Param)
                : mextras(extras)
                , mPname(Pname)
                , mParam(Param) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mPname);
            e->Float32(this->mParam);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPname;
        float mParam;
    };

    class GlFogfv: public Encodable {
    public:
        GlFogfv() = default;
        GlFogfv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Pname, GLfloat__CP Params)
                : mextras(extras)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mPname);
            e->Struct(this->mParams);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPname;
        GLfloat__CP mParams;
    };

    class GlFogx: public Encodable {
    public:
        GlFogx() = default;
        GlFogx(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Pname, int32_t Param)
                : mextras(extras)
                , mPname(Pname)
                , mParam(Param) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mPname);
            e->Int32(this->mParam);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPname;
        int32_t mParam;
    };

    class GlFogxOES: public Encodable {
    public:
        GlFogxOES() = default;
        GlFogxOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Pname, int32_t Param)
                : mextras(extras)
                , mPname(Pname)
                , mParam(Param) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mPname);
            e->Int32(this->mParam);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPname;
        int32_t mParam;
    };

    class GlFogxv: public Encodable {
    public:
        GlFogxv() = default;
        GlFogxv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Pname, GLfixed__CP Param)
                : mextras(extras)
                , mPname(Pname)
                , mParam(Param) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mPname);
            e->Struct(this->mParam);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPname;
        GLfixed__CP mParam;
    };

    class GlFogxvOES: public Encodable {
    public:
        GlFogxvOES() = default;
        GlFogxvOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Pname, GLfixed__CP Param)
                : mextras(extras)
                , mPname(Pname)
                , mParam(Param) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mPname);
            e->Struct(this->mParam);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPname;
        GLfixed__CP mParam;
    };

    class GlFragmentCoverageColorNV: public Encodable {
    public:
        GlFragmentCoverageColorNV() = default;
        GlFragmentCoverageColorNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Color)
                : mextras(extras)
                , mColor(Color) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mColor);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mColor;
    };

    class GlFramebufferParameteri: public Encodable {
    public:
        GlFramebufferParameteri() = default;
        GlFramebufferParameteri(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Pname, int32_t Param)
                : mextras(extras)
                , mTarget(Target)
                , mPname(Pname)
                , mParam(Param) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mPname;
        int32_t mParam;
    };

    class GlFramebufferRenderbuffer: public Encodable {
    public:
        GlFramebufferRenderbuffer() = default;
        GlFramebufferRenderbuffer(const gapic::Vector<gapic::Encodable*>& extras, uint32_t FramebufferTarget, uint32_t FramebufferAttachment, uint32_t RenderbufferTarget, uint32_t Renderbuffer)
                : mextras(extras)
                , mFramebufferTarget(FramebufferTarget)
                , mFramebufferAttachment(FramebufferAttachment)
                , mRenderbufferTarget(RenderbufferTarget)
                , mRenderbuffer(Renderbuffer) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mFramebufferTarget;
        uint32_t mFramebufferAttachment;
        uint32_t mRenderbufferTarget;
        uint32_t mRenderbuffer;
    };

    class GlFramebufferRenderbufferOES: public Encodable {
    public:
        GlFramebufferRenderbufferOES() = default;
        GlFramebufferRenderbufferOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Attachment, uint32_t Renderbuffertarget, uint32_t Renderbuffer)
                : mextras(extras)
                , mTarget(Target)
                , mAttachment(Attachment)
                , mRenderbuffertarget(Renderbuffertarget)
                , mRenderbuffer(Renderbuffer) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mAttachment;
        uint32_t mRenderbuffertarget;
        uint32_t mRenderbuffer;
    };

    class GlFramebufferSampleLocationsfvNV: public Encodable {
    public:
        GlFramebufferSampleLocationsfvNV() = default;
        GlFramebufferSampleLocationsfvNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Start, int32_t Count, GLfloat__CP V)
                : mextras(extras)
                , mTarget(Target)
                , mStart(Start)
                , mCount(Count)
                , mV(V) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mStart;
        int32_t mCount;
        GLfloat__CP mV;
    };

    class GlFramebufferTexture: public Encodable {
    public:
        GlFramebufferTexture() = default;
        GlFramebufferTexture(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Attachment, uint32_t Texture, int32_t Level)
                : mextras(extras)
                , mTarget(Target)
                , mAttachment(Attachment)
                , mTexture(Texture)
                , mLevel(Level) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mAttachment;
        uint32_t mTexture;
        int32_t mLevel;
    };

    class GlFramebufferTexture2D: public Encodable {
    public:
        GlFramebufferTexture2D() = default;
        GlFramebufferTexture2D(const gapic::Vector<gapic::Encodable*>& extras, uint32_t FramebufferTarget, uint32_t FramebufferAttachment, uint32_t TextureTarget, uint32_t Texture, int32_t Level)
                : mextras(extras)
                , mFramebufferTarget(FramebufferTarget)
                , mFramebufferAttachment(FramebufferAttachment)
                , mTextureTarget(TextureTarget)
                , mTexture(Texture)
                , mLevel(Level) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mFramebufferTarget;
        uint32_t mFramebufferAttachment;
        uint32_t mTextureTarget;
        uint32_t mTexture;
        int32_t mLevel;
    };

    class GlFramebufferTexture2DMultisampleEXT: public Encodable {
    public:
        GlFramebufferTexture2DMultisampleEXT() = default;
        GlFramebufferTexture2DMultisampleEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Attachment, uint32_t Textarget, uint32_t Texture, int32_t Level, int32_t Samples)
                : mextras(extras)
                , mTarget(Target)
                , mAttachment(Attachment)
                , mTextarget(Textarget)
                , mTexture(Texture)
                , mLevel(Level)
                , mSamples(Samples) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mAttachment;
        uint32_t mTextarget;
        uint32_t mTexture;
        int32_t mLevel;
        int32_t mSamples;
    };

    class GlFramebufferTexture2DMultisampleIMG: public Encodable {
    public:
        GlFramebufferTexture2DMultisampleIMG() = default;
        GlFramebufferTexture2DMultisampleIMG(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Attachment, uint32_t Textarget, uint32_t Texture, int32_t Level, int32_t Samples)
                : mextras(extras)
                , mTarget(Target)
                , mAttachment(Attachment)
                , mTextarget(Textarget)
                , mTexture(Texture)
                , mLevel(Level)
                , mSamples(Samples) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mAttachment;
        uint32_t mTextarget;
        uint32_t mTexture;
        int32_t mLevel;
        int32_t mSamples;
    };

    class GlFramebufferTexture2DOES: public Encodable {
    public:
        GlFramebufferTexture2DOES() = default;
        GlFramebufferTexture2DOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Attachment, uint32_t Textarget, uint32_t Texture, int32_t Level)
                : mextras(extras)
                , mTarget(Target)
                , mAttachment(Attachment)
                , mTextarget(Textarget)
                , mTexture(Texture)
                , mLevel(Level) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mAttachment;
        uint32_t mTextarget;
        uint32_t mTexture;
        int32_t mLevel;
    };

    class GlFramebufferTexture3DOES: public Encodable {
    public:
        GlFramebufferTexture3DOES() = default;
        GlFramebufferTexture3DOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Attachment, uint32_t Textarget, uint32_t Texture, int32_t Level, int32_t Zoffset)
                : mextras(extras)
                , mTarget(Target)
                , mAttachment(Attachment)
                , mTextarget(Textarget)
                , mTexture(Texture)
                , mLevel(Level)
                , mZoffset(Zoffset) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mAttachment;
        uint32_t mTextarget;
        uint32_t mTexture;
        int32_t mLevel;
        int32_t mZoffset;
    };

    class GlFramebufferTextureEXT: public Encodable {
    public:
        GlFramebufferTextureEXT() = default;
        GlFramebufferTextureEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Attachment, uint32_t Texture, int32_t Level)
                : mextras(extras)
                , mTarget(Target)
                , mAttachment(Attachment)
                , mTexture(Texture)
                , mLevel(Level) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mAttachment;
        uint32_t mTexture;
        int32_t mLevel;
    };

    class GlFramebufferTextureLayer: public Encodable {
    public:
        GlFramebufferTextureLayer() = default;
        GlFramebufferTextureLayer(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Attachment, uint32_t Texture, int32_t Level, int32_t Layer)
                : mextras(extras)
                , mTarget(Target)
                , mAttachment(Attachment)
                , mTexture(Texture)
                , mLevel(Level)
                , mLayer(Layer) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mAttachment;
        uint32_t mTexture;
        int32_t mLevel;
        int32_t mLayer;
    };

    class GlFramebufferTextureMultiviewOVR: public Encodable {
    public:
        GlFramebufferTextureMultiviewOVR() = default;
        GlFramebufferTextureMultiviewOVR(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Attachment, uint32_t Texture, int32_t Level, int32_t BaseViewIndex, int32_t NumViews)
                : mextras(extras)
                , mTarget(Target)
                , mAttachment(Attachment)
                , mTexture(Texture)
                , mLevel(Level)
                , mBaseViewIndex(BaseViewIndex)
                , mNumViews(NumViews) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mAttachment;
        uint32_t mTexture;
        int32_t mLevel;
        int32_t mBaseViewIndex;
        int32_t mNumViews;
    };

    class GlFramebufferTextureOES: public Encodable {
    public:
        GlFramebufferTextureOES() = default;
        GlFramebufferTextureOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Attachment, uint32_t Texture, int32_t Level)
                : mextras(extras)
                , mTarget(Target)
                , mAttachment(Attachment)
                , mTexture(Texture)
                , mLevel(Level) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mAttachment;
        uint32_t mTexture;
        int32_t mLevel;
    };

    class GlFrontFace: public Encodable {
    public:
        GlFrontFace() = default;
        GlFrontFace(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Orientation)
                : mextras(extras)
                , mOrientation(Orientation) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mOrientation);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mOrientation;
    };

    class GlFrustumf: public Encodable {
    public:
        GlFrustumf() = default;
        GlFrustumf(const gapic::Vector<gapic::Encodable*>& extras, float L, float R, float B, float T, float N, float F)
                : mextras(extras)
                , mL(L)
                , mR(R)
                , mB(B)
                , mT(T)
                , mN(N)
                , mF(F) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        float mL;
        float mR;
        float mB;
        float mT;
        float mN;
        float mF;
    };

    class GlFrustumfOES: public Encodable {
    public:
        GlFrustumfOES() = default;
        GlFrustumfOES(const gapic::Vector<gapic::Encodable*>& extras, float L, float R, float B, float T, float N, float F)
                : mextras(extras)
                , mL(L)
                , mR(R)
                , mB(B)
                , mT(T)
                , mN(N)
                , mF(F) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        float mL;
        float mR;
        float mB;
        float mT;
        float mN;
        float mF;
    };

    class GlFrustumx: public Encodable {
    public:
        GlFrustumx() = default;
        GlFrustumx(const gapic::Vector<gapic::Encodable*>& extras, int32_t L, int32_t R, int32_t B, int32_t T, int32_t N, int32_t F)
                : mextras(extras)
                , mL(L)
                , mR(R)
                , mB(B)
                , mT(T)
                , mN(N)
                , mF(F) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mL;
        int32_t mR;
        int32_t mB;
        int32_t mT;
        int32_t mN;
        int32_t mF;
    };

    class GlFrustumxOES: public Encodable {
    public:
        GlFrustumxOES() = default;
        GlFrustumxOES(const gapic::Vector<gapic::Encodable*>& extras, int32_t L, int32_t R, int32_t B, int32_t T, int32_t N, int32_t F)
                : mextras(extras)
                , mL(L)
                , mR(R)
                , mB(B)
                , mT(T)
                , mN(N)
                , mF(F) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mL;
        int32_t mR;
        int32_t mB;
        int32_t mT;
        int32_t mN;
        int32_t mF;
    };

    class GlGenBuffers: public Encodable {
    public:
        GlGenBuffers() = default;
        GlGenBuffers(const gapic::Vector<gapic::Encodable*>& extras, int32_t Count, BufferId__P Buffers)
                : mextras(extras)
                , mCount(Count)
                , mBuffers(Buffers) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int32(this->mCount);
            e->Struct(this->mBuffers);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mCount;
        BufferId__P mBuffers;
    };

    class GlGenFencesNV: public Encodable {
    public:
        GlGenFencesNV() = default;
        GlGenFencesNV(const gapic::Vector<gapic::Encodable*>& extras, int32_t N, GLuint__P Fences)
                : mextras(extras)
                , mN(N)
                , mFences(Fences) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int32(this->mN);
            e->Struct(this->mFences);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mN;
        GLuint__P mFences;
    };

    class GlGenFramebuffers: public Encodable {
    public:
        GlGenFramebuffers() = default;
        GlGenFramebuffers(const gapic::Vector<gapic::Encodable*>& extras, int32_t Count, FramebufferId__P Framebuffers)
                : mextras(extras)
                , mCount(Count)
                , mFramebuffers(Framebuffers) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int32(this->mCount);
            e->Struct(this->mFramebuffers);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mCount;
        FramebufferId__P mFramebuffers;
    };

    class GlGenFramebuffersOES: public Encodable {
    public:
        GlGenFramebuffersOES() = default;
        GlGenFramebuffersOES(const gapic::Vector<gapic::Encodable*>& extras, int32_t N, GLuint__P Framebuffers)
                : mextras(extras)
                , mN(N)
                , mFramebuffers(Framebuffers) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int32(this->mN);
            e->Struct(this->mFramebuffers);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mN;
        GLuint__P mFramebuffers;
    };

    class GlGenPathsNV: public Encodable {
    public:
        GlGenPathsNV() = default;
        GlGenPathsNV(const gapic::Vector<gapic::Encodable*>& extras, int32_t Range, uint32_t Result)
                : mextras(extras)
                , mRange(Range)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int32(this->mRange);
            e->Uint32(this->mResult);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mRange;
        uint32_t mResult;
    };

    class GlGenPerfMonitorsAMD: public Encodable {
    public:
        GlGenPerfMonitorsAMD() = default;
        GlGenPerfMonitorsAMD(const gapic::Vector<gapic::Encodable*>& extras, int32_t N, GLuint__P Monitors)
                : mextras(extras)
                , mN(N)
                , mMonitors(Monitors) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int32(this->mN);
            e->Struct(this->mMonitors);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mN;
        GLuint__P mMonitors;
    };

    class PipelineId__P: public Encodable {
    public:
        PipelineId__P() = default;
        PipelineId__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class GlGenProgramPipelines: public Encodable {
    public:
        GlGenProgramPipelines() = default;
        GlGenProgramPipelines(const gapic::Vector<gapic::Encodable*>& extras, int32_t N, PipelineId__P Pipelines)
                : mextras(extras)
                , mN(N)
                , mPipelines(Pipelines) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int32(this->mN);
            e->Struct(this->mPipelines);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mN;
        PipelineId__P mPipelines;
    };

    class GlGenProgramPipelinesEXT: public Encodable {
    public:
        GlGenProgramPipelinesEXT() = default;
        GlGenProgramPipelinesEXT(const gapic::Vector<gapic::Encodable*>& extras, int32_t N, PipelineId__P Pipelines)
                : mextras(extras)
                , mN(N)
                , mPipelines(Pipelines) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int32(this->mN);
            e->Struct(this->mPipelines);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mN;
        PipelineId__P mPipelines;
    };

    class QueryId__P: public Encodable {
    public:
        QueryId__P() = default;
        QueryId__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class GlGenQueries: public Encodable {
    public:
        GlGenQueries() = default;
        GlGenQueries(const gapic::Vector<gapic::Encodable*>& extras, int32_t Count, QueryId__P Queries)
                : mextras(extras)
                , mCount(Count)
                , mQueries(Queries) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int32(this->mCount);
            e->Struct(this->mQueries);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mCount;
        QueryId__P mQueries;
    };

    class GlGenQueriesEXT: public Encodable {
    public:
        GlGenQueriesEXT() = default;
        GlGenQueriesEXT(const gapic::Vector<gapic::Encodable*>& extras, int32_t Count, QueryId__P Queries)
                : mextras(extras)
                , mCount(Count)
                , mQueries(Queries) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int32(this->mCount);
            e->Struct(this->mQueries);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mCount;
        QueryId__P mQueries;
    };

    class GlGenRenderbuffers: public Encodable {
    public:
        GlGenRenderbuffers() = default;
        GlGenRenderbuffers(const gapic::Vector<gapic::Encodable*>& extras, int32_t Count, RenderbufferId__P Renderbuffers)
                : mextras(extras)
                , mCount(Count)
                , mRenderbuffers(Renderbuffers) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int32(this->mCount);
            e->Struct(this->mRenderbuffers);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mCount;
        RenderbufferId__P mRenderbuffers;
    };

    class GlGenRenderbuffersOES: public Encodable {
    public:
        GlGenRenderbuffersOES() = default;
        GlGenRenderbuffersOES(const gapic::Vector<gapic::Encodable*>& extras, int32_t N, GLuint__P Renderbuffers)
                : mextras(extras)
                , mN(N)
                , mRenderbuffers(Renderbuffers) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int32(this->mN);
            e->Struct(this->mRenderbuffers);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mN;
        GLuint__P mRenderbuffers;
    };

    class SamplerId__P: public Encodable {
    public:
        SamplerId__P() = default;
        SamplerId__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class GlGenSamplers: public Encodable {
    public:
        GlGenSamplers() = default;
        GlGenSamplers(const gapic::Vector<gapic::Encodable*>& extras, int32_t Count, SamplerId__P Samplers)
                : mextras(extras)
                , mCount(Count)
                , mSamplers(Samplers) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int32(this->mCount);
            e->Struct(this->mSamplers);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mCount;
        SamplerId__P mSamplers;
    };

    class GlGenTextures: public Encodable {
    public:
        GlGenTextures() = default;
        GlGenTextures(const gapic::Vector<gapic::Encodable*>& extras, int32_t Count, TextureId__P Textures)
                : mextras(extras)
                , mCount(Count)
                , mTextures(Textures) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int32(this->mCount);
            e->Struct(this->mTextures);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mCount;
        TextureId__P mTextures;
    };

    class TransformFeedbackId__P: public Encodable {
    public:
        TransformFeedbackId__P() = default;
        TransformFeedbackId__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class GlGenTransformFeedbacks: public Encodable {
    public:
        GlGenTransformFeedbacks() = default;
        GlGenTransformFeedbacks(const gapic::Vector<gapic::Encodable*>& extras, int32_t N, TransformFeedbackId__P Ids)
                : mextras(extras)
                , mN(N)
                , mIds(Ids) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int32(this->mN);
            e->Struct(this->mIds);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mN;
        TransformFeedbackId__P mIds;
    };

    class VertexArrayId__P: public Encodable {
    public:
        VertexArrayId__P() = default;
        VertexArrayId__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class GlGenVertexArrays: public Encodable {
    public:
        GlGenVertexArrays() = default;
        GlGenVertexArrays(const gapic::Vector<gapic::Encodable*>& extras, int32_t Count, VertexArrayId__P Arrays)
                : mextras(extras)
                , mCount(Count)
                , mArrays(Arrays) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int32(this->mCount);
            e->Struct(this->mArrays);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mCount;
        VertexArrayId__P mArrays;
    };

    class GlGenVertexArraysOES: public Encodable {
    public:
        GlGenVertexArraysOES() = default;
        GlGenVertexArraysOES(const gapic::Vector<gapic::Encodable*>& extras, int32_t Count, VertexArrayId__P Arrays)
                : mextras(extras)
                , mCount(Count)
                , mArrays(Arrays) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int32(this->mCount);
            e->Struct(this->mArrays);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mCount;
        VertexArrayId__P mArrays;
    };

    class GlGenerateMipmap: public Encodable {
    public:
        GlGenerateMipmap() = default;
        GlGenerateMipmap(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target)
                : mextras(extras)
                , mTarget(Target) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mTarget);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
    };

    class GlGenerateMipmapOES: public Encodable {
    public:
        GlGenerateMipmapOES() = default;
        GlGenerateMipmapOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target)
                : mextras(extras)
                , mTarget(Target) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mTarget);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
    };

    class GlGetActiveAttrib: public Encodable {
    public:
        GlGetActiveAttrib() = default;
        GlGetActiveAttrib(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, uint32_t Index, int32_t BufferSize, GLsizei__P BufferBytesWritten, GLint__P VectorCount, GLenum__P Type, GLchar__P Name)
                : mextras(extras)
                , mProgram(Program)
                , mIndex(Index)
                , mBufferSize(BufferSize)
                , mBufferBytesWritten(BufferBytesWritten)
                , mVectorCount(VectorCount)
                , mType(Type)
                , mName(Name) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        uint32_t mIndex;
        int32_t mBufferSize;
        GLsizei__P mBufferBytesWritten;
        GLint__P mVectorCount;
        GLenum__P mType;
        GLchar__P mName;
    };

    class GlGetActiveUniform: public Encodable {
    public:
        GlGetActiveUniform() = default;
        GlGetActiveUniform(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, uint32_t Index, int32_t BufferSize, GLsizei__P BufferBytesWritten, GLint__P VectorCount, GLenum__P Type, GLchar__P Name)
                : mextras(extras)
                , mProgram(Program)
                , mIndex(Index)
                , mBufferSize(BufferSize)
                , mBufferBytesWritten(BufferBytesWritten)
                , mVectorCount(VectorCount)
                , mType(Type)
                , mName(Name) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        uint32_t mIndex;
        int32_t mBufferSize;
        GLsizei__P mBufferBytesWritten;
        GLint__P mVectorCount;
        GLenum__P mType;
        GLchar__P mName;
    };

    class GlGetActiveUniformBlockName: public Encodable {
    public:
        GlGetActiveUniformBlockName() = default;
        GlGetActiveUniformBlockName(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, uint32_t UniformBlockIndex, int32_t BufferSize, GLsizei__P BufferBytesWritten, GLchar__P Name)
                : mextras(extras)
                , mProgram(Program)
                , mUniformBlockIndex(UniformBlockIndex)
                , mBufferSize(BufferSize)
                , mBufferBytesWritten(BufferBytesWritten)
                , mName(Name) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        uint32_t mUniformBlockIndex;
        int32_t mBufferSize;
        GLsizei__P mBufferBytesWritten;
        GLchar__P mName;
    };

    class GlGetActiveUniformBlockiv: public Encodable {
    public:
        GlGetActiveUniformBlockiv() = default;
        GlGetActiveUniformBlockiv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, uint32_t UniformBlockIndex, uint32_t ParameterName, GLint__P Parameters)
                : mextras(extras)
                , mProgram(Program)
                , mUniformBlockIndex(UniformBlockIndex)
                , mParameterName(ParameterName)
                , mParameters(Parameters) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        uint32_t mUniformBlockIndex;
        uint32_t mParameterName;
        GLint__P mParameters;
    };

    class UniformIndex__CP: public Encodable {
    public:
        UniformIndex__CP() = default;
        UniformIndex__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class GlGetActiveUniformsiv: public Encodable {
    public:
        GlGetActiveUniformsiv() = default;
        GlGetActiveUniformsiv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t UniformCount, UniformIndex__CP UniformIndices, uint32_t ParameterName, GLint__P Parameters)
                : mextras(extras)
                , mProgram(Program)
                , mUniformCount(UniformCount)
                , mUniformIndices(UniformIndices)
                , mParameterName(ParameterName)
                , mParameters(Parameters) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mUniformCount;
        UniformIndex__CP mUniformIndices;
        uint32_t mParameterName;
        GLint__P mParameters;
    };

    class GlGetAttachedShaders: public Encodable {
    public:
        GlGetAttachedShaders() = default;
        GlGetAttachedShaders(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t BufferLength, GLsizei__P ShadersLengthWritten, ShaderId__P Shaders)
                : mextras(extras)
                , mProgram(Program)
                , mBufferLength(BufferLength)
                , mShadersLengthWritten(ShadersLengthWritten)
                , mShaders(Shaders) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mBufferLength;
        GLsizei__P mShadersLengthWritten;
        ShaderId__P mShaders;
    };

    class GlGetAttribLocation: public Encodable {
    public:
        GlGetAttribLocation() = default;
        GlGetAttribLocation(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, const char* Name, int32_t Result)
                : mextras(extras)
                , mProgram(Program)
                , mName(Name)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        const char* mName;
        int32_t mResult;
    };

    class GlGetBooleani_v: public Encodable {
    public:
        GlGetBooleani_v() = default;
        GlGetBooleani_v(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Param, uint32_t Index, GLboolean__P Values)
                : mextras(extras)
                , mParam(Param)
                , mIndex(Index)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mParam;
        uint32_t mIndex;
        GLboolean__P mValues;
    };

    class GlGetBooleanv: public Encodable {
    public:
        GlGetBooleanv() = default;
        GlGetBooleanv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Param, GLboolean__P Values)
                : mextras(extras)
                , mParam(Param)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mParam);
            e->Struct(this->mValues);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mParam;
        GLboolean__P mValues;
    };

    class GlGetBufferParameteri64v: public Encodable {
    public:
        GlGetBufferParameteri64v() = default;
        GlGetBufferParameteri64v(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Parameter, GLint64__P Value)
                : mextras(extras)
                , mTarget(Target)
                , mParameter(Parameter)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mParameter;
        GLint64__P mValue;
    };

    class GlGetBufferParameteriv: public Encodable {
    public:
        GlGetBufferParameteriv() = default;
        GlGetBufferParameteriv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Parameter, GLint__P Value)
                : mextras(extras)
                , mTarget(Target)
                , mParameter(Parameter)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mParameter;
        GLint__P mValue;
    };

    class GlGetBufferPointerv: public Encodable {
    public:
        GlGetBufferPointerv() = default;
        GlGetBufferPointerv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Pname, Void__P__P Params)
                : mextras(extras)
                , mTarget(Target)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mPname;
        Void__P__P mParams;
    };

    class GlGetBufferPointervOES: public Encodable {
    public:
        GlGetBufferPointervOES() = default;
        GlGetBufferPointervOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Pname, Void__P__P Params)
                : mextras(extras)
                , mTarget(Target)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mPname;
        Void__P__P mParams;
    };

    class GlGetClipPlanef: public Encodable {
    public:
        GlGetClipPlanef() = default;
        GlGetClipPlanef(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Plane, GLfloat__P Equation)
                : mextras(extras)
                , mPlane(Plane)
                , mEquation(Equation) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mPlane);
            e->Struct(this->mEquation);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPlane;
        GLfloat__P mEquation;
    };

    class GlGetClipPlanefOES: public Encodable {
    public:
        GlGetClipPlanefOES() = default;
        GlGetClipPlanefOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Plane, GLfloat__P Equation)
                : mextras(extras)
                , mPlane(Plane)
                , mEquation(Equation) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mPlane);
            e->Struct(this->mEquation);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPlane;
        GLfloat__P mEquation;
    };

    class GlGetClipPlanex: public Encodable {
    public:
        GlGetClipPlanex() = default;
        GlGetClipPlanex(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Plane, GLfixed__P Equation)
                : mextras(extras)
                , mPlane(Plane)
                , mEquation(Equation) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mPlane);
            e->Struct(this->mEquation);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPlane;
        GLfixed__P mEquation;
    };

    class GlGetClipPlanexOES: public Encodable {
    public:
        GlGetClipPlanexOES() = default;
        GlGetClipPlanexOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Plane, GLfixed__P Equation)
                : mextras(extras)
                , mPlane(Plane)
                , mEquation(Equation) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mPlane);
            e->Struct(this->mEquation);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPlane;
        GLfixed__P mEquation;
    };

    class GlGetCoverageModulationTableNV: public Encodable {
    public:
        GlGetCoverageModulationTableNV() = default;
        GlGetCoverageModulationTableNV(const gapic::Vector<gapic::Encodable*>& extras, int32_t Bufsize, GLfloat__P V)
                : mextras(extras)
                , mBufsize(Bufsize)
                , mV(V) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int32(this->mBufsize);
            e->Struct(this->mV);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mBufsize;
        GLfloat__P mV;
    };

    class GlGetDebugMessageLog: public Encodable {
    public:
        GlGetDebugMessageLog() = default;
        GlGetDebugMessageLog(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Count, int32_t BufSize, GLenum__P Sources, GLenum__P Types, GLuint__P Ids, GLenum__P Severities, GLsizei__P Lengths, GLchar__P MessageLog, uint32_t Result)
                : mextras(extras)
                , mCount(Count)
                , mBufSize(BufSize)
                , mSources(Sources)
                , mTypes(Types)
                , mIds(Ids)
                , mSeverities(Severities)
                , mLengths(Lengths)
                , mMessageLog(MessageLog)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mCount;
        int32_t mBufSize;
        GLenum__P mSources;
        GLenum__P mTypes;
        GLuint__P mIds;
        GLenum__P mSeverities;
        GLsizei__P mLengths;
        GLchar__P mMessageLog;
        uint32_t mResult;
    };

    class GlGetDebugMessageLogKHR: public Encodable {
    public:
        GlGetDebugMessageLogKHR() = default;
        GlGetDebugMessageLogKHR(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Count, int32_t BufSize, GLenum__P Sources, GLenum__P Types, GLuint__P Ids, GLenum__P Severities, GLsizei__P Lengths, GLchar__P MessageLog, uint32_t Result)
                : mextras(extras)
                , mCount(Count)
                , mBufSize(BufSize)
                , mSources(Sources)
                , mTypes(Types)
                , mIds(Ids)
                , mSeverities(Severities)
                , mLengths(Lengths)
                , mMessageLog(MessageLog)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mCount;
        int32_t mBufSize;
        GLenum__P mSources;
        GLenum__P mTypes;
        GLuint__P mIds;
        GLenum__P mSeverities;
        GLsizei__P mLengths;
        GLchar__P mMessageLog;
        uint32_t mResult;
    };

    class GlGetDriverControlStringQCOM: public Encodable {
    public:
        GlGetDriverControlStringQCOM() = default;
        GlGetDriverControlStringQCOM(const gapic::Vector<gapic::Encodable*>& extras, uint32_t DriverControl, int32_t BufSize, GLsizei__P Length, GLchar__P DriverControlString)
                : mextras(extras)
                , mDriverControl(DriverControl)
                , mBufSize(BufSize)
                , mLength(Length)
                , mDriverControlString(DriverControlString) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mDriverControl;
        int32_t mBufSize;
        GLsizei__P mLength;
        GLchar__P mDriverControlString;
    };

    class GlGetDriverControlsQCOM: public Encodable {
    public:
        GlGetDriverControlsQCOM() = default;
        GlGetDriverControlsQCOM(const gapic::Vector<gapic::Encodable*>& extras, GLint__P Num, int32_t Size, GLuint__P DriverControls)
                : mextras(extras)
                , mNum(Num)
                , mSize(Size)
                , mDriverControls(DriverControls) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        GLint__P mNum;
        int32_t mSize;
        GLuint__P mDriverControls;
    };

    class GlGetError: public Encodable {
    public:
        GlGetError() = default;
        GlGetError(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Result)
                : mextras(extras)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mResult);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mResult;
    };

    class GlGetFenceivNV: public Encodable {
    public:
        GlGetFenceivNV() = default;
        GlGetFenceivNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Fence, uint32_t Pname, GLint__P Params)
                : mextras(extras)
                , mFence(Fence)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mFence;
        uint32_t mPname;
        GLint__P mParams;
    };

    class GlGetFirstPerfQueryIdINTEL: public Encodable {
    public:
        GlGetFirstPerfQueryIdINTEL() = default;
        GlGetFirstPerfQueryIdINTEL(const gapic::Vector<gapic::Encodable*>& extras, GLuint__P QueryId)
                : mextras(extras)
                , mQueryId(QueryId) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Struct(this->mQueryId);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        GLuint__P mQueryId;
    };

    class GlGetFixedv: public Encodable {
    public:
        GlGetFixedv() = default;
        GlGetFixedv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Pname, GLfixed__P Params)
                : mextras(extras)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mPname);
            e->Struct(this->mParams);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPname;
        GLfixed__P mParams;
    };

    class GlGetFixedvOES: public Encodable {
    public:
        GlGetFixedvOES() = default;
        GlGetFixedvOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Pname, GLfixed__P Params)
                : mextras(extras)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mPname);
            e->Struct(this->mParams);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPname;
        GLfixed__P mParams;
    };

    class GlGetFloati_vNV: public Encodable {
    public:
        GlGetFloati_vNV() = default;
        GlGetFloati_vNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Index, GLfloat__P Data)
                : mextras(extras)
                , mTarget(Target)
                , mIndex(Index)
                , mData(Data) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mIndex;
        GLfloat__P mData;
    };

    class GlGetFloatv: public Encodable {
    public:
        GlGetFloatv() = default;
        GlGetFloatv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Param, GLfloat__P Values)
                : mextras(extras)
                , mParam(Param)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mParam);
            e->Struct(this->mValues);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mParam;
        GLfloat__P mValues;
    };

    class GlGetFragDataIndexEXT: public Encodable {
    public:
        GlGetFragDataIndexEXT() = default;
        GlGetFragDataIndexEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, const char* Name, int32_t Result)
                : mextras(extras)
                , mProgram(Program)
                , mName(Name)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        const char* mName;
        int32_t mResult;
    };

    class GlGetFragDataLocation: public Encodable {
    public:
        GlGetFragDataLocation() = default;
        GlGetFragDataLocation(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, const char* Name, int32_t Result)
                : mextras(extras)
                , mProgram(Program)
                , mName(Name)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        const char* mName;
        int32_t mResult;
    };

    class GlGetFramebufferAttachmentParameteriv: public Encodable {
    public:
        GlGetFramebufferAttachmentParameteriv() = default;
        GlGetFramebufferAttachmentParameteriv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t FramebufferTarget, uint32_t Attachment, uint32_t Parameter, GLint__P Value)
                : mextras(extras)
                , mFramebufferTarget(FramebufferTarget)
                , mAttachment(Attachment)
                , mParameter(Parameter)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mFramebufferTarget;
        uint32_t mAttachment;
        uint32_t mParameter;
        GLint__P mValue;
    };

    class GlGetFramebufferAttachmentParameterivOES: public Encodable {
    public:
        GlGetFramebufferAttachmentParameterivOES() = default;
        GlGetFramebufferAttachmentParameterivOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Attachment, uint32_t Pname, GLint__P Params)
                : mextras(extras)
                , mTarget(Target)
                , mAttachment(Attachment)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mAttachment;
        uint32_t mPname;
        GLint__P mParams;
    };

    class GlGetFramebufferParameteriv: public Encodable {
    public:
        GlGetFramebufferParameteriv() = default;
        GlGetFramebufferParameteriv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Pname, GLint__P Params)
                : mextras(extras)
                , mTarget(Target)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mPname;
        GLint__P mParams;
    };

    class GlGetGraphicsResetStatus: public Encodable {
    public:
        GlGetGraphicsResetStatus() = default;
        GlGetGraphicsResetStatus(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Result)
                : mextras(extras)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mResult);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mResult;
    };

    class GlGetGraphicsResetStatusEXT: public Encodable {
    public:
        GlGetGraphicsResetStatusEXT() = default;
        GlGetGraphicsResetStatusEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Result)
                : mextras(extras)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mResult);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mResult;
    };

    class GlGetGraphicsResetStatusKHR: public Encodable {
    public:
        GlGetGraphicsResetStatusKHR() = default;
        GlGetGraphicsResetStatusKHR(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Result)
                : mextras(extras)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mResult);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mResult;
    };

    class GlGetImageHandleNV: public Encodable {
    public:
        GlGetImageHandleNV() = default;
        GlGetImageHandleNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Texture, int32_t Level, uint8_t Layered, int32_t Layer, uint32_t Format, uint64_t Result)
                : mextras(extras)
                , mTexture(Texture)
                , mLevel(Level)
                , mLayered(Layered)
                , mLayer(Layer)
                , mFormat(Format)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTexture;
        int32_t mLevel;
        uint8_t mLayered;
        int32_t mLayer;
        uint32_t mFormat;
        uint64_t mResult;
    };

    class GlGetInteger64i_v: public Encodable {
    public:
        GlGetInteger64i_v() = default;
        GlGetInteger64i_v(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Param, uint32_t Index, GLint64__P Values)
                : mextras(extras)
                , mParam(Param)
                , mIndex(Index)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mParam;
        uint32_t mIndex;
        GLint64__P mValues;
    };

    class GlGetInteger64v: public Encodable {
    public:
        GlGetInteger64v() = default;
        GlGetInteger64v(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Param, GLint64__P Values)
                : mextras(extras)
                , mParam(Param)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mParam);
            e->Struct(this->mValues);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mParam;
        GLint64__P mValues;
    };

    class GlGetInteger64vAPPLE: public Encodable {
    public:
        GlGetInteger64vAPPLE() = default;
        GlGetInteger64vAPPLE(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Pname, GLint64__P Params)
                : mextras(extras)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mPname);
            e->Struct(this->mParams);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPname;
        GLint64__P mParams;
    };

    class GlGetIntegeri_v: public Encodable {
    public:
        GlGetIntegeri_v() = default;
        GlGetIntegeri_v(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Param, uint32_t Index, GLint__P Values)
                : mextras(extras)
                , mParam(Param)
                , mIndex(Index)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mParam;
        uint32_t mIndex;
        GLint__P mValues;
    };

    class GlGetIntegeri_vEXT: public Encodable {
    public:
        GlGetIntegeri_vEXT() = default;
        GlGetIntegeri_vEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Index, GLint__P Data)
                : mextras(extras)
                , mTarget(Target)
                , mIndex(Index)
                , mData(Data) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mIndex;
        GLint__P mData;
    };

    class GlGetIntegerv: public Encodable {
    public:
        GlGetIntegerv() = default;
        GlGetIntegerv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Param, GLint__P Values)
                : mextras(extras)
                , mParam(Param)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mParam);
            e->Struct(this->mValues);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mParam;
        GLint__P mValues;
    };

    class GlGetInternalformatSampleivNV: public Encodable {
    public:
        GlGetInternalformatSampleivNV() = default;
        GlGetInternalformatSampleivNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Internalformat, int32_t Samples, uint32_t Pname, int32_t BufSize, GLint__P Params)
                : mextras(extras)
                , mTarget(Target)
                , mInternalformat(Internalformat)
                , mSamples(Samples)
                , mPname(Pname)
                , mBufSize(BufSize)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mInternalformat;
        int32_t mSamples;
        uint32_t mPname;
        int32_t mBufSize;
        GLint__P mParams;
    };

    class GlGetInternalformativ: public Encodable {
    public:
        GlGetInternalformativ() = default;
        GlGetInternalformativ(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Internalformat, uint32_t Pname, int32_t BufSize, GLint__P Params)
                : mextras(extras)
                , mTarget(Target)
                , mInternalformat(Internalformat)
                , mPname(Pname)
                , mBufSize(BufSize)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mInternalformat;
        uint32_t mPname;
        int32_t mBufSize;
        GLint__P mParams;
    };

    class GlGetLightfv: public Encodable {
    public:
        GlGetLightfv() = default;
        GlGetLightfv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Light, uint32_t Pname, GLfloat__P Params)
                : mextras(extras)
                , mLight(Light)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mLight;
        uint32_t mPname;
        GLfloat__P mParams;
    };

    class GlGetLightxv: public Encodable {
    public:
        GlGetLightxv() = default;
        GlGetLightxv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Light, uint32_t Pname, GLfixed__P Params)
                : mextras(extras)
                , mLight(Light)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mLight;
        uint32_t mPname;
        GLfixed__P mParams;
    };

    class GlGetLightxvOES: public Encodable {
    public:
        GlGetLightxvOES() = default;
        GlGetLightxvOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Light, uint32_t Pname, GLfixed__P Params)
                : mextras(extras)
                , mLight(Light)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mLight;
        uint32_t mPname;
        GLfixed__P mParams;
    };

    class GlGetMaterialfv: public Encodable {
    public:
        GlGetMaterialfv() = default;
        GlGetMaterialfv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Face, uint32_t Pname, GLfloat__P Params)
                : mextras(extras)
                , mFace(Face)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mFace;
        uint32_t mPname;
        GLfloat__P mParams;
    };

    class GlGetMaterialxv: public Encodable {
    public:
        GlGetMaterialxv() = default;
        GlGetMaterialxv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Face, uint32_t Pname, GLfixed__P Params)
                : mextras(extras)
                , mFace(Face)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mFace;
        uint32_t mPname;
        GLfixed__P mParams;
    };

    class GlGetMaterialxvOES: public Encodable {
    public:
        GlGetMaterialxvOES() = default;
        GlGetMaterialxvOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Face, uint32_t Pname, GLfixed__P Params)
                : mextras(extras)
                , mFace(Face)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mFace;
        uint32_t mPname;
        GLfixed__P mParams;
    };

    class GlGetMultisamplefv: public Encodable {
    public:
        GlGetMultisamplefv() = default;
        GlGetMultisamplefv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Pname, uint32_t Index, GLfloat__P Val)
                : mextras(extras)
                , mPname(Pname)
                , mIndex(Index)
                , mVal(Val) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPname;
        uint32_t mIndex;
        GLfloat__P mVal;
    };

    class GlGetNextPerfQueryIdINTEL: public Encodable {
    public:
        GlGetNextPerfQueryIdINTEL() = default;
        GlGetNextPerfQueryIdINTEL(const gapic::Vector<gapic::Encodable*>& extras, uint32_t QueryId, GLuint__P NextQueryId)
                : mextras(extras)
                , mQueryId(QueryId)
                , mNextQueryId(NextQueryId) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mQueryId);
            e->Struct(this->mNextQueryId);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mQueryId;
        GLuint__P mNextQueryId;
    };

    class GlGetObjectLabel: public Encodable {
    public:
        GlGetObjectLabel() = default;
        GlGetObjectLabel(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Identifier, uint32_t Name, int32_t BufSize, GLsizei__P Length, GLchar__P Label)
                : mextras(extras)
                , mIdentifier(Identifier)
                , mName(Name)
                , mBufSize(BufSize)
                , mLength(Length)
                , mLabel(Label) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mIdentifier;
        uint32_t mName;
        int32_t mBufSize;
        GLsizei__P mLength;
        GLchar__P mLabel;
    };

    class GlGetObjectLabelEXT: public Encodable {
    public:
        GlGetObjectLabelEXT() = default;
        GlGetObjectLabelEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Type, uint32_t Object, int32_t BufSize, GLsizei__P Length, GLchar__P Label)
                : mextras(extras)
                , mType(Type)
                , mObject(Object)
                , mBufSize(BufSize)
                , mLength(Length)
                , mLabel(Label) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mType;
        uint32_t mObject;
        int32_t mBufSize;
        GLsizei__P mLength;
        GLchar__P mLabel;
    };

    class GlGetObjectLabelKHR: public Encodable {
    public:
        GlGetObjectLabelKHR() = default;
        GlGetObjectLabelKHR(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Identifier, uint32_t Name, int32_t BufSize, GLsizei__P Length, GLchar__P Label)
                : mextras(extras)
                , mIdentifier(Identifier)
                , mName(Name)
                , mBufSize(BufSize)
                , mLength(Length)
                , mLabel(Label) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mIdentifier;
        uint32_t mName;
        int32_t mBufSize;
        GLsizei__P mLength;
        GLchar__P mLabel;
    };

    class GlGetObjectPtrLabel: public Encodable {
    public:
        GlGetObjectPtrLabel() = default;
        GlGetObjectPtrLabel(const gapic::Vector<gapic::Encodable*>& extras, Void__CP Ptr, int32_t BufSize, GLsizei__P Length, GLchar__P Label)
                : mextras(extras)
                , mPtr(Ptr)
                , mBufSize(BufSize)
                , mLength(Length)
                , mLabel(Label) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        Void__CP mPtr;
        int32_t mBufSize;
        GLsizei__P mLength;
        GLchar__P mLabel;
    };

    class GlGetObjectPtrLabelKHR: public Encodable {
    public:
        GlGetObjectPtrLabelKHR() = default;
        GlGetObjectPtrLabelKHR(const gapic::Vector<gapic::Encodable*>& extras, Void__CP Ptr, int32_t BufSize, GLsizei__P Length, GLchar__P Label)
                : mextras(extras)
                , mPtr(Ptr)
                , mBufSize(BufSize)
                , mLength(Length)
                , mLabel(Label) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        Void__CP mPtr;
        int32_t mBufSize;
        GLsizei__P mLength;
        GLchar__P mLabel;
    };

    class GlGetPathCommandsNV: public Encodable {
    public:
        GlGetPathCommandsNV() = default;
        GlGetPathCommandsNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Path, GLubyte__P Commands)
                : mextras(extras)
                , mPath(Path)
                , mCommands(Commands) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mPath);
            e->Struct(this->mCommands);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPath;
        GLubyte__P mCommands;
    };

    class GlGetPathCoordsNV: public Encodable {
    public:
        GlGetPathCoordsNV() = default;
        GlGetPathCoordsNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Path, GLfloat__P Coords)
                : mextras(extras)
                , mPath(Path)
                , mCoords(Coords) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mPath);
            e->Struct(this->mCoords);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPath;
        GLfloat__P mCoords;
    };

    class GlGetPathDashArrayNV: public Encodable {
    public:
        GlGetPathDashArrayNV() = default;
        GlGetPathDashArrayNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Path, GLfloat__P DashArray)
                : mextras(extras)
                , mPath(Path)
                , mDashArray(DashArray) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mPath);
            e->Struct(this->mDashArray);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPath;
        GLfloat__P mDashArray;
    };

    class GlGetPathLengthNV: public Encodable {
    public:
        GlGetPathLengthNV() = default;
        GlGetPathLengthNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Path, int32_t StartSegment, int32_t NumSegments, float Result)
                : mextras(extras)
                , mPath(Path)
                , mStartSegment(StartSegment)
                , mNumSegments(NumSegments)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPath;
        int32_t mStartSegment;
        int32_t mNumSegments;
        float mResult;
    };

    class GlGetPathMetricRangeNV: public Encodable {
    public:
        GlGetPathMetricRangeNV() = default;
        GlGetPathMetricRangeNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t MetricQueryMask, uint32_t FirstPathName, int32_t NumPaths, int32_t Stride, GLfloat__P Metrics)
                : mextras(extras)
                , mMetricQueryMask(MetricQueryMask)
                , mFirstPathName(FirstPathName)
                , mNumPaths(NumPaths)
                , mStride(Stride)
                , mMetrics(Metrics) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mMetricQueryMask;
        uint32_t mFirstPathName;
        int32_t mNumPaths;
        int32_t mStride;
        GLfloat__P mMetrics;
    };

    class GlGetPathMetricsNV: public Encodable {
    public:
        GlGetPathMetricsNV() = default;
        GlGetPathMetricsNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t MetricQueryMask, int32_t NumPaths, uint32_t PathNameType, Void__CP Paths, uint32_t PathBase, int32_t Stride, GLfloat__P Metrics)
                : mextras(extras)
                , mMetricQueryMask(MetricQueryMask)
                , mNumPaths(NumPaths)
                , mPathNameType(PathNameType)
                , mPaths(Paths)
                , mPathBase(PathBase)
                , mStride(Stride)
                , mMetrics(Metrics) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mMetricQueryMask;
        int32_t mNumPaths;
        uint32_t mPathNameType;
        Void__CP mPaths;
        uint32_t mPathBase;
        int32_t mStride;
        GLfloat__P mMetrics;
    };

    class GlGetPathParameterfvNV: public Encodable {
    public:
        GlGetPathParameterfvNV() = default;
        GlGetPathParameterfvNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Path, uint32_t Pname, GLfloat__P Value)
                : mextras(extras)
                , mPath(Path)
                , mPname(Pname)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPath;
        uint32_t mPname;
        GLfloat__P mValue;
    };

    class GlGetPathParameterivNV: public Encodable {
    public:
        GlGetPathParameterivNV() = default;
        GlGetPathParameterivNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Path, uint32_t Pname, GLint__P Value)
                : mextras(extras)
                , mPath(Path)
                , mPname(Pname)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPath;
        uint32_t mPname;
        GLint__P mValue;
    };

    class GlGetPathSpacingNV: public Encodable {
    public:
        GlGetPathSpacingNV() = default;
        GlGetPathSpacingNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t PathListMode, int32_t NumPaths, uint32_t PathNameType, Void__CP Paths, uint32_t PathBase, float AdvanceScale, float KerningScale, uint32_t TransformType, GLfloat__P ReturnedSpacing)
                : mextras(extras)
                , mPathListMode(PathListMode)
                , mNumPaths(NumPaths)
                , mPathNameType(PathNameType)
                , mPaths(Paths)
                , mPathBase(PathBase)
                , mAdvanceScale(AdvanceScale)
                , mKerningScale(KerningScale)
                , mTransformType(TransformType)
                , mReturnedSpacing(ReturnedSpacing) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPathListMode;
        int32_t mNumPaths;
        uint32_t mPathNameType;
        Void__CP mPaths;
        uint32_t mPathBase;
        float mAdvanceScale;
        float mKerningScale;
        uint32_t mTransformType;
        GLfloat__P mReturnedSpacing;
    };

    class GlGetPerfCounterInfoINTEL: public Encodable {
    public:
        GlGetPerfCounterInfoINTEL() = default;
        GlGetPerfCounterInfoINTEL(const gapic::Vector<gapic::Encodable*>& extras, uint32_t QueryId, uint32_t CounterId, uint32_t CounterNameLength, GLchar__P CounterName, uint32_t CounterDescLength, GLchar__P CounterDesc, GLuint__P CounterOffset, GLuint__P CounterDataSize, GLuint__P CounterTypeEnum, GLuint__P CounterDataTypeEnum, GLuint64__P RawCounterMaxValue)
                : mextras(extras)
                , mQueryId(QueryId)
                , mCounterId(CounterId)
                , mCounterNameLength(CounterNameLength)
                , mCounterName(CounterName)
                , mCounterDescLength(CounterDescLength)
                , mCounterDesc(CounterDesc)
                , mCounterOffset(CounterOffset)
                , mCounterDataSize(CounterDataSize)
                , mCounterTypeEnum(CounterTypeEnum)
                , mCounterDataTypeEnum(CounterDataTypeEnum)
                , mRawCounterMaxValue(RawCounterMaxValue) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mQueryId;
        uint32_t mCounterId;
        uint32_t mCounterNameLength;
        GLchar__P mCounterName;
        uint32_t mCounterDescLength;
        GLchar__P mCounterDesc;
        GLuint__P mCounterOffset;
        GLuint__P mCounterDataSize;
        GLuint__P mCounterTypeEnum;
        GLuint__P mCounterDataTypeEnum;
        GLuint64__P mRawCounterMaxValue;
    };

    class GlGetPerfMonitorCounterDataAMD: public Encodable {
    public:
        GlGetPerfMonitorCounterDataAMD() = default;
        GlGetPerfMonitorCounterDataAMD(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Monitor, uint32_t Pname, int32_t DataSize, GLuint__P Data, GLint__P BytesWritten)
                : mextras(extras)
                , mMonitor(Monitor)
                , mPname(Pname)
                , mDataSize(DataSize)
                , mData(Data)
                , mBytesWritten(BytesWritten) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mMonitor;
        uint32_t mPname;
        int32_t mDataSize;
        GLuint__P mData;
        GLint__P mBytesWritten;
    };

    class GlGetPerfMonitorCounterInfoAMD: public Encodable {
    public:
        GlGetPerfMonitorCounterInfoAMD() = default;
        GlGetPerfMonitorCounterInfoAMD(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Group, uint32_t Counter, uint32_t Pname, Void__P Data)
                : mextras(extras)
                , mGroup(Group)
                , mCounter(Counter)
                , mPname(Pname)
                , mData(Data) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mGroup;
        uint32_t mCounter;
        uint32_t mPname;
        Void__P mData;
    };

    class GlGetPerfMonitorCounterStringAMD: public Encodable {
    public:
        GlGetPerfMonitorCounterStringAMD() = default;
        GlGetPerfMonitorCounterStringAMD(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Group, uint32_t Counter, int32_t BufSize, GLsizei__P Length, GLchar__P CounterString)
                : mextras(extras)
                , mGroup(Group)
                , mCounter(Counter)
                , mBufSize(BufSize)
                , mLength(Length)
                , mCounterString(CounterString) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mGroup;
        uint32_t mCounter;
        int32_t mBufSize;
        GLsizei__P mLength;
        GLchar__P mCounterString;
    };

    class GlGetPerfMonitorCountersAMD: public Encodable {
    public:
        GlGetPerfMonitorCountersAMD() = default;
        GlGetPerfMonitorCountersAMD(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Group, GLint__P NumCounters, GLint__P MaxActiveCounters, int32_t CounterSize, GLuint__P Counters)
                : mextras(extras)
                , mGroup(Group)
                , mNumCounters(NumCounters)
                , mMaxActiveCounters(MaxActiveCounters)
                , mCounterSize(CounterSize)
                , mCounters(Counters) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mGroup;
        GLint__P mNumCounters;
        GLint__P mMaxActiveCounters;
        int32_t mCounterSize;
        GLuint__P mCounters;
    };

    class GlGetPerfMonitorGroupStringAMD: public Encodable {
    public:
        GlGetPerfMonitorGroupStringAMD() = default;
        GlGetPerfMonitorGroupStringAMD(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Group, int32_t BufSize, GLsizei__P Length, GLchar__P GroupString)
                : mextras(extras)
                , mGroup(Group)
                , mBufSize(BufSize)
                , mLength(Length)
                , mGroupString(GroupString) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mGroup;
        int32_t mBufSize;
        GLsizei__P mLength;
        GLchar__P mGroupString;
    };

    class GlGetPerfMonitorGroupsAMD: public Encodable {
    public:
        GlGetPerfMonitorGroupsAMD() = default;
        GlGetPerfMonitorGroupsAMD(const gapic::Vector<gapic::Encodable*>& extras, GLint__P NumGroups, int32_t GroupsSize, GLuint__P Groups)
                : mextras(extras)
                , mNumGroups(NumGroups)
                , mGroupsSize(GroupsSize)
                , mGroups(Groups) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        GLint__P mNumGroups;
        int32_t mGroupsSize;
        GLuint__P mGroups;
    };

    class GlGetPerfQueryDataINTEL: public Encodable {
    public:
        GlGetPerfQueryDataINTEL() = default;
        GlGetPerfQueryDataINTEL(const gapic::Vector<gapic::Encodable*>& extras, uint32_t QueryHandle, uint32_t Flag, int32_t DataSize, GLvoid__P Data, GLuint__P BytesWritten)
                : mextras(extras)
                , mQueryHandle(QueryHandle)
                , mFlag(Flag)
                , mDataSize(DataSize)
                , mData(Data)
                , mBytesWritten(BytesWritten) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mQueryHandle;
        uint32_t mFlag;
        int32_t mDataSize;
        GLvoid__P mData;
        GLuint__P mBytesWritten;
    };

    class GlGetPerfQueryIdByNameINTEL: public Encodable {
    public:
        GlGetPerfQueryIdByNameINTEL() = default;
        GlGetPerfQueryIdByNameINTEL(const gapic::Vector<gapic::Encodable*>& extras, GLchar__P QueryName, GLuint__P QueryId)
                : mextras(extras)
                , mQueryName(QueryName)
                , mQueryId(QueryId) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Struct(this->mQueryName);
            e->Struct(this->mQueryId);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        GLchar__P mQueryName;
        GLuint__P mQueryId;
    };

    class GlGetPerfQueryInfoINTEL: public Encodable {
    public:
        GlGetPerfQueryInfoINTEL() = default;
        GlGetPerfQueryInfoINTEL(const gapic::Vector<gapic::Encodable*>& extras, uint32_t QueryId, uint32_t QueryNameLength, GLchar__P QueryName, GLuint__P DataSize, GLuint__P NoCounters, GLuint__P NoInstances, GLuint__P CapsMask)
                : mextras(extras)
                , mQueryId(QueryId)
                , mQueryNameLength(QueryNameLength)
                , mQueryName(QueryName)
                , mDataSize(DataSize)
                , mNoCounters(NoCounters)
                , mNoInstances(NoInstances)
                , mCapsMask(CapsMask) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mQueryId;
        uint32_t mQueryNameLength;
        GLchar__P mQueryName;
        GLuint__P mDataSize;
        GLuint__P mNoCounters;
        GLuint__P mNoInstances;
        GLuint__P mCapsMask;
    };

    class GlGetPointerv: public Encodable {
    public:
        GlGetPointerv() = default;
        GlGetPointerv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Pname, Void__P__P Params)
                : mextras(extras)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mPname);
            e->Struct(this->mParams);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPname;
        Void__P__P mParams;
    };

    class GlGetPointervKHR: public Encodable {
    public:
        GlGetPointervKHR() = default;
        GlGetPointervKHR(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Pname, Void__P__P Params)
                : mextras(extras)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mPname);
            e->Struct(this->mParams);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPname;
        Void__P__P mParams;
    };

    class GlGetProgramBinary: public Encodable {
    public:
        GlGetProgramBinary() = default;
        GlGetProgramBinary(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t BufSize, GLsizei__P Length, GLenum__P BinaryFormat, Void__P Binary)
                : mextras(extras)
                , mProgram(Program)
                , mBufSize(BufSize)
                , mLength(Length)
                , mBinaryFormat(BinaryFormat)
                , mBinary(Binary) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mBufSize;
        GLsizei__P mLength;
        GLenum__P mBinaryFormat;
        Void__P mBinary;
    };

    class GlGetProgramBinaryOES: public Encodable {
    public:
        GlGetProgramBinaryOES() = default;
        GlGetProgramBinaryOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t BufferSize, GLsizei__P BytesWritten, GLenum__P BinaryFormat, Void__P Binary)
                : mextras(extras)
                , mProgram(Program)
                , mBufferSize(BufferSize)
                , mBytesWritten(BytesWritten)
                , mBinaryFormat(BinaryFormat)
                , mBinary(Binary) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mBufferSize;
        GLsizei__P mBytesWritten;
        GLenum__P mBinaryFormat;
        Void__P mBinary;
    };

    class GlGetProgramInfoLog: public Encodable {
    public:
        GlGetProgramInfoLog() = default;
        GlGetProgramInfoLog(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t BufferLength, GLsizei__P StringLengthWritten, GLchar__P Info)
                : mextras(extras)
                , mProgram(Program)
                , mBufferLength(BufferLength)
                , mStringLengthWritten(StringLengthWritten)
                , mInfo(Info) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mBufferLength;
        GLsizei__P mStringLengthWritten;
        GLchar__P mInfo;
    };

    class GlGetProgramInterfaceiv: public Encodable {
    public:
        GlGetProgramInterfaceiv() = default;
        GlGetProgramInterfaceiv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, uint32_t ProgramInterface, uint32_t Pname, GLint__P Params)
                : mextras(extras)
                , mProgram(Program)
                , mProgramInterface(ProgramInterface)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        uint32_t mProgramInterface;
        uint32_t mPname;
        GLint__P mParams;
    };

    class GlGetProgramPipelineInfoLog: public Encodable {
    public:
        GlGetProgramPipelineInfoLog() = default;
        GlGetProgramPipelineInfoLog(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Pipeline, int32_t BufSize, GLsizei__P Length, GLchar__P InfoLog)
                : mextras(extras)
                , mPipeline(Pipeline)
                , mBufSize(BufSize)
                , mLength(Length)
                , mInfoLog(InfoLog) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPipeline;
        int32_t mBufSize;
        GLsizei__P mLength;
        GLchar__P mInfoLog;
    };

    class GlGetProgramPipelineInfoLogEXT: public Encodable {
    public:
        GlGetProgramPipelineInfoLogEXT() = default;
        GlGetProgramPipelineInfoLogEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Pipeline, int32_t BufSize, GLsizei__P Length, GLchar__P InfoLog)
                : mextras(extras)
                , mPipeline(Pipeline)
                , mBufSize(BufSize)
                , mLength(Length)
                , mInfoLog(InfoLog) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPipeline;
        int32_t mBufSize;
        GLsizei__P mLength;
        GLchar__P mInfoLog;
    };

    class GlGetProgramPipelineiv: public Encodable {
    public:
        GlGetProgramPipelineiv() = default;
        GlGetProgramPipelineiv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Pipeline, uint32_t Pname, GLint__P Params)
                : mextras(extras)
                , mPipeline(Pipeline)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPipeline;
        uint32_t mPname;
        GLint__P mParams;
    };

    class GlGetProgramPipelineivEXT: public Encodable {
    public:
        GlGetProgramPipelineivEXT() = default;
        GlGetProgramPipelineivEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Pipeline, uint32_t Pname, GLint__P Params)
                : mextras(extras)
                , mPipeline(Pipeline)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPipeline;
        uint32_t mPname;
        GLint__P mParams;
    };

    class GlGetProgramResourceIndex: public Encodable {
    public:
        GlGetProgramResourceIndex() = default;
        GlGetProgramResourceIndex(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, uint32_t ProgramInterface, const char* Name, uint32_t Result)
                : mextras(extras)
                , mProgram(Program)
                , mProgramInterface(ProgramInterface)
                , mName(Name)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        uint32_t mProgramInterface;
        const char* mName;
        uint32_t mResult;
    };

    class GlGetProgramResourceLocation: public Encodable {
    public:
        GlGetProgramResourceLocation() = default;
        GlGetProgramResourceLocation(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, uint32_t ProgramInterface, const char* Name, int32_t Result)
                : mextras(extras)
                , mProgram(Program)
                , mProgramInterface(ProgramInterface)
                , mName(Name)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        uint32_t mProgramInterface;
        const char* mName;
        int32_t mResult;
    };

    class GlGetProgramResourceLocationIndexEXT: public Encodable {
    public:
        GlGetProgramResourceLocationIndexEXT() = default;
        GlGetProgramResourceLocationIndexEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, uint32_t ProgramInterface, const char* Name, int32_t Result)
                : mextras(extras)
                , mProgram(Program)
                , mProgramInterface(ProgramInterface)
                , mName(Name)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        uint32_t mProgramInterface;
        const char* mName;
        int32_t mResult;
    };

    class GlGetProgramResourceName: public Encodable {
    public:
        GlGetProgramResourceName() = default;
        GlGetProgramResourceName(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, uint32_t ProgramInterface, uint32_t Index, int32_t BufSize, GLsizei__P Length, GLchar__P Name)
                : mextras(extras)
                , mProgram(Program)
                , mProgramInterface(ProgramInterface)
                , mIndex(Index)
                , mBufSize(BufSize)
                , mLength(Length)
                , mName(Name) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        uint32_t mProgramInterface;
        uint32_t mIndex;
        int32_t mBufSize;
        GLsizei__P mLength;
        GLchar__P mName;
    };

    class GlGetProgramResourcefvNV: public Encodable {
    public:
        GlGetProgramResourcefvNV() = default;
        GlGetProgramResourcefvNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, uint32_t ProgramInterface, uint32_t Index, int32_t PropCount, GLenum__CP Props, int32_t BufSize, GLsizei__P Length, GLfloat__P Params)
                : mextras(extras)
                , mProgram(Program)
                , mProgramInterface(ProgramInterface)
                , mIndex(Index)
                , mPropCount(PropCount)
                , mProps(Props)
                , mBufSize(BufSize)
                , mLength(Length)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        uint32_t mProgramInterface;
        uint32_t mIndex;
        int32_t mPropCount;
        GLenum__CP mProps;
        int32_t mBufSize;
        GLsizei__P mLength;
        GLfloat__P mParams;
    };

    class GlGetProgramResourceiv: public Encodable {
    public:
        GlGetProgramResourceiv() = default;
        GlGetProgramResourceiv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, uint32_t ProgramInterface, uint32_t Index, int32_t PropCount, GLenum__CP Props, int32_t BufSize, GLsizei__P Length, GLint__P Params)
                : mextras(extras)
                , mProgram(Program)
                , mProgramInterface(ProgramInterface)
                , mIndex(Index)
                , mPropCount(PropCount)
                , mProps(Props)
                , mBufSize(BufSize)
                , mLength(Length)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        uint32_t mProgramInterface;
        uint32_t mIndex;
        int32_t mPropCount;
        GLenum__CP mProps;
        int32_t mBufSize;
        GLsizei__P mLength;
        GLint__P mParams;
    };

    class GlGetProgramiv: public Encodable {
    public:
        GlGetProgramiv() = default;
        GlGetProgramiv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, uint32_t Parameter, GLint__P Value)
                : mextras(extras)
                , mProgram(Program)
                , mParameter(Parameter)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        uint32_t mParameter;
        GLint__P mValue;
    };

    class S64__P: public Encodable {
    public:
        S64__P() = default;
        S64__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class GlGetQueryObjecti64v: public Encodable {
    public:
        GlGetQueryObjecti64v() = default;
        GlGetQueryObjecti64v(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Query, uint32_t Parameter, S64__P Value)
                : mextras(extras)
                , mQuery(Query)
                , mParameter(Parameter)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mQuery;
        uint32_t mParameter;
        S64__P mValue;
    };

    class GlGetQueryObjecti64vEXT: public Encodable {
    public:
        GlGetQueryObjecti64vEXT() = default;
        GlGetQueryObjecti64vEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Query, uint32_t Parameter, GLint64__P Value)
                : mextras(extras)
                , mQuery(Query)
                , mParameter(Parameter)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mQuery;
        uint32_t mParameter;
        GLint64__P mValue;
    };

    class GlGetQueryObjectivEXT: public Encodable {
    public:
        GlGetQueryObjectivEXT() = default;
        GlGetQueryObjectivEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Query, uint32_t Parameter, GLint__P Value)
                : mextras(extras)
                , mQuery(Query)
                , mParameter(Parameter)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mQuery;
        uint32_t mParameter;
        GLint__P mValue;
    };

    class U64__P: public Encodable {
    public:
        U64__P() = default;
        U64__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class GlGetQueryObjectui64v: public Encodable {
    public:
        GlGetQueryObjectui64v() = default;
        GlGetQueryObjectui64v(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Query, uint32_t Parameter, U64__P Value)
                : mextras(extras)
                , mQuery(Query)
                , mParameter(Parameter)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mQuery;
        uint32_t mParameter;
        U64__P mValue;
    };

    class GlGetQueryObjectui64vEXT: public Encodable {
    public:
        GlGetQueryObjectui64vEXT() = default;
        GlGetQueryObjectui64vEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Query, uint32_t Parameter, GLuint64__P Value)
                : mextras(extras)
                , mQuery(Query)
                , mParameter(Parameter)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mQuery;
        uint32_t mParameter;
        GLuint64__P mValue;
    };

    class GlGetQueryObjectuiv: public Encodable {
    public:
        GlGetQueryObjectuiv() = default;
        GlGetQueryObjectuiv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Query, uint32_t Parameter, GLuint__P Value)
                : mextras(extras)
                , mQuery(Query)
                , mParameter(Parameter)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mQuery;
        uint32_t mParameter;
        GLuint__P mValue;
    };

    class GlGetQueryObjectuivEXT: public Encodable {
    public:
        GlGetQueryObjectuivEXT() = default;
        GlGetQueryObjectuivEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Query, uint32_t Parameter, GLuint__P Value)
                : mextras(extras)
                , mQuery(Query)
                , mParameter(Parameter)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mQuery;
        uint32_t mParameter;
        GLuint__P mValue;
    };

    class GlGetQueryiv: public Encodable {
    public:
        GlGetQueryiv() = default;
        GlGetQueryiv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Parameter, GLint__P Value)
                : mextras(extras)
                , mTarget(Target)
                , mParameter(Parameter)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mParameter;
        GLint__P mValue;
    };

    class GlGetQueryivEXT: public Encodable {
    public:
        GlGetQueryivEXT() = default;
        GlGetQueryivEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Parameter, GLint__P Value)
                : mextras(extras)
                , mTarget(Target)
                , mParameter(Parameter)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mParameter;
        GLint__P mValue;
    };

    class GlGetRenderbufferParameteriv: public Encodable {
    public:
        GlGetRenderbufferParameteriv() = default;
        GlGetRenderbufferParameteriv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Parameter, GLint__P Values)
                : mextras(extras)
                , mTarget(Target)
                , mParameter(Parameter)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mParameter;
        GLint__P mValues;
    };

    class GlGetRenderbufferParameterivOES: public Encodable {
    public:
        GlGetRenderbufferParameterivOES() = default;
        GlGetRenderbufferParameterivOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Pname, GLint__P Params)
                : mextras(extras)
                , mTarget(Target)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mPname;
        GLint__P mParams;
    };

    class GlGetSamplerParameterIiv: public Encodable {
    public:
        GlGetSamplerParameterIiv() = default;
        GlGetSamplerParameterIiv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Sampler, uint32_t Pname, GLint__P Params)
                : mextras(extras)
                , mSampler(Sampler)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mSampler;
        uint32_t mPname;
        GLint__P mParams;
    };

    class GlGetSamplerParameterIivEXT: public Encodable {
    public:
        GlGetSamplerParameterIivEXT() = default;
        GlGetSamplerParameterIivEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Sampler, uint32_t Pname, GLint__P Params)
                : mextras(extras)
                , mSampler(Sampler)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mSampler;
        uint32_t mPname;
        GLint__P mParams;
    };

    class GlGetSamplerParameterIivOES: public Encodable {
    public:
        GlGetSamplerParameterIivOES() = default;
        GlGetSamplerParameterIivOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Sampler, uint32_t Pname, GLint__P Params)
                : mextras(extras)
                , mSampler(Sampler)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mSampler;
        uint32_t mPname;
        GLint__P mParams;
    };

    class GlGetSamplerParameterIuiv: public Encodable {
    public:
        GlGetSamplerParameterIuiv() = default;
        GlGetSamplerParameterIuiv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Sampler, uint32_t Pname, GLuint__P Params)
                : mextras(extras)
                , mSampler(Sampler)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mSampler;
        uint32_t mPname;
        GLuint__P mParams;
    };

    class GlGetSamplerParameterIuivEXT: public Encodable {
    public:
        GlGetSamplerParameterIuivEXT() = default;
        GlGetSamplerParameterIuivEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Sampler, uint32_t Pname, GLuint__P Params)
                : mextras(extras)
                , mSampler(Sampler)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mSampler;
        uint32_t mPname;
        GLuint__P mParams;
    };

    class GlGetSamplerParameterIuivOES: public Encodable {
    public:
        GlGetSamplerParameterIuivOES() = default;
        GlGetSamplerParameterIuivOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Sampler, uint32_t Pname, GLuint__P Params)
                : mextras(extras)
                , mSampler(Sampler)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mSampler;
        uint32_t mPname;
        GLuint__P mParams;
    };

    class GlGetSamplerParameterfv: public Encodable {
    public:
        GlGetSamplerParameterfv() = default;
        GlGetSamplerParameterfv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Sampler, uint32_t Pname, GLfloat__P Params)
                : mextras(extras)
                , mSampler(Sampler)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mSampler;
        uint32_t mPname;
        GLfloat__P mParams;
    };

    class GlGetSamplerParameteriv: public Encodable {
    public:
        GlGetSamplerParameteriv() = default;
        GlGetSamplerParameteriv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Sampler, uint32_t Pname, GLint__P Params)
                : mextras(extras)
                , mSampler(Sampler)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mSampler;
        uint32_t mPname;
        GLint__P mParams;
    };

    class GlGetShaderInfoLog: public Encodable {
    public:
        GlGetShaderInfoLog() = default;
        GlGetShaderInfoLog(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Shader, int32_t BufferLength, GLsizei__P StringLengthWritten, GLchar__P Info)
                : mextras(extras)
                , mShader(Shader)
                , mBufferLength(BufferLength)
                , mStringLengthWritten(StringLengthWritten)
                , mInfo(Info) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mShader;
        int32_t mBufferLength;
        GLsizei__P mStringLengthWritten;
        GLchar__P mInfo;
    };

    class GlGetShaderPrecisionFormat: public Encodable {
    public:
        GlGetShaderPrecisionFormat() = default;
        GlGetShaderPrecisionFormat(const gapic::Vector<gapic::Encodable*>& extras, uint32_t ShaderType, uint32_t PrecisionType, GLint__P Range, GLint__P Precision)
                : mextras(extras)
                , mShaderType(ShaderType)
                , mPrecisionType(PrecisionType)
                , mRange(Range)
                , mPrecision(Precision) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mShaderType;
        uint32_t mPrecisionType;
        GLint__P mRange;
        GLint__P mPrecision;
    };

    class GlGetShaderSource: public Encodable {
    public:
        GlGetShaderSource() = default;
        GlGetShaderSource(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Shader, int32_t BufferLength, GLsizei__P StringLengthWritten, GLchar__P Source)
                : mextras(extras)
                , mShader(Shader)
                , mBufferLength(BufferLength)
                , mStringLengthWritten(StringLengthWritten)
                , mSource(Source) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mShader;
        int32_t mBufferLength;
        GLsizei__P mStringLengthWritten;
        GLchar__P mSource;
    };

    class GlGetShaderiv: public Encodable {
    public:
        GlGetShaderiv() = default;
        GlGetShaderiv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Shader, uint32_t Parameter, GLint__P Value)
                : mextras(extras)
                , mShader(Shader)
                , mParameter(Parameter)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mShader;
        uint32_t mParameter;
        GLint__P mValue;
    };

    class GlGetString: public Encodable {
    public:
        GlGetString() = default;
        GlGetString(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Param, GLubyte__CP Result)
                : mextras(extras)
                , mParam(Param)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mParam);
            e->Struct(this->mResult);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mParam;
        GLubyte__CP mResult;
    };

    class GlGetStringi: public Encodable {
    public:
        GlGetStringi() = default;
        GlGetStringi(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Name, uint32_t Index, GLubyte__CP Result)
                : mextras(extras)
                , mName(Name)
                , mIndex(Index)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mName;
        uint32_t mIndex;
        GLubyte__CP mResult;
    };

    class GlGetSynciv: public Encodable {
    public:
        GlGetSynciv() = default;
        GlGetSynciv(const gapic::Vector<gapic::Encodable*>& extras, GLsync Sync, uint32_t Pname, int32_t BufSize, GLsizei__P Length, GLint__P Values)
                : mextras(extras)
                , mSync(Sync)
                , mPname(Pname)
                , mBufSize(BufSize)
                , mLength(Length)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        GLsync mSync;
        uint32_t mPname;
        int32_t mBufSize;
        GLsizei__P mLength;
        GLint__P mValues;
    };

    class GlGetSyncivAPPLE: public Encodable {
    public:
        GlGetSyncivAPPLE() = default;
        GlGetSyncivAPPLE(const gapic::Vector<gapic::Encodable*>& extras, GLsync Sync, uint32_t Pname, int32_t BufSize, GLsizei__P Length, GLint__P Values)
                : mextras(extras)
                , mSync(Sync)
                , mPname(Pname)
                , mBufSize(BufSize)
                , mLength(Length)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        GLsync mSync;
        uint32_t mPname;
        int32_t mBufSize;
        GLsizei__P mLength;
        GLint__P mValues;
    };

    class GlGetTexEnvfv: public Encodable {
    public:
        GlGetTexEnvfv() = default;
        GlGetTexEnvfv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Pname, GLfloat__P Params)
                : mextras(extras)
                , mTarget(Target)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mPname;
        GLfloat__P mParams;
    };

    class GlGetTexEnviv: public Encodable {
    public:
        GlGetTexEnviv() = default;
        GlGetTexEnviv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Pname, GLint__P Params)
                : mextras(extras)
                , mTarget(Target)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mPname;
        GLint__P mParams;
    };

    class GlGetTexEnvxv: public Encodable {
    public:
        GlGetTexEnvxv() = default;
        GlGetTexEnvxv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Pname, GLfixed__P Params)
                : mextras(extras)
                , mTarget(Target)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mPname;
        GLfixed__P mParams;
    };

    class GlGetTexEnvxvOES: public Encodable {
    public:
        GlGetTexEnvxvOES() = default;
        GlGetTexEnvxvOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Pname, GLfixed__P Params)
                : mextras(extras)
                , mTarget(Target)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mPname;
        GLfixed__P mParams;
    };

    class GlGetTexGenfvOES: public Encodable {
    public:
        GlGetTexGenfvOES() = default;
        GlGetTexGenfvOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Coord, uint32_t Pname, GLfloat__P Params)
                : mextras(extras)
                , mCoord(Coord)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mCoord;
        uint32_t mPname;
        GLfloat__P mParams;
    };

    class GlGetTexGenivOES: public Encodable {
    public:
        GlGetTexGenivOES() = default;
        GlGetTexGenivOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Coord, uint32_t Pname, GLint__P Params)
                : mextras(extras)
                , mCoord(Coord)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mCoord;
        uint32_t mPname;
        GLint__P mParams;
    };

    class GlGetTexGenxvOES: public Encodable {
    public:
        GlGetTexGenxvOES() = default;
        GlGetTexGenxvOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Coord, uint32_t Pname, GLfixed__P Params)
                : mextras(extras)
                , mCoord(Coord)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mCoord;
        uint32_t mPname;
        GLfixed__P mParams;
    };

    class GlGetTexLevelParameterfv: public Encodable {
    public:
        GlGetTexLevelParameterfv() = default;
        GlGetTexLevelParameterfv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, int32_t Level, uint32_t Pname, GLfloat__P Params)
                : mextras(extras)
                , mTarget(Target)
                , mLevel(Level)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        int32_t mLevel;
        uint32_t mPname;
        GLfloat__P mParams;
    };

    class GlGetTexLevelParameteriv: public Encodable {
    public:
        GlGetTexLevelParameteriv() = default;
        GlGetTexLevelParameteriv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, int32_t Level, uint32_t Pname, GLint__P Params)
                : mextras(extras)
                , mTarget(Target)
                , mLevel(Level)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        int32_t mLevel;
        uint32_t mPname;
        GLint__P mParams;
    };

    class GlGetTexParameterIiv: public Encodable {
    public:
        GlGetTexParameterIiv() = default;
        GlGetTexParameterIiv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Pname, GLint__P Params)
                : mextras(extras)
                , mTarget(Target)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mPname;
        GLint__P mParams;
    };

    class GlGetTexParameterIivEXT: public Encodable {
    public:
        GlGetTexParameterIivEXT() = default;
        GlGetTexParameterIivEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Pname, GLint__P Params)
                : mextras(extras)
                , mTarget(Target)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mPname;
        GLint__P mParams;
    };

    class GlGetTexParameterIivOES: public Encodable {
    public:
        GlGetTexParameterIivOES() = default;
        GlGetTexParameterIivOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Pname, GLint__P Params)
                : mextras(extras)
                , mTarget(Target)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mPname;
        GLint__P mParams;
    };

    class GlGetTexParameterIuiv: public Encodable {
    public:
        GlGetTexParameterIuiv() = default;
        GlGetTexParameterIuiv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Pname, GLuint__P Params)
                : mextras(extras)
                , mTarget(Target)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mPname;
        GLuint__P mParams;
    };

    class GlGetTexParameterIuivEXT: public Encodable {
    public:
        GlGetTexParameterIuivEXT() = default;
        GlGetTexParameterIuivEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Pname, GLuint__P Params)
                : mextras(extras)
                , mTarget(Target)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mPname;
        GLuint__P mParams;
    };

    class GlGetTexParameterIuivOES: public Encodable {
    public:
        GlGetTexParameterIuivOES() = default;
        GlGetTexParameterIuivOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Pname, GLuint__P Params)
                : mextras(extras)
                , mTarget(Target)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mPname;
        GLuint__P mParams;
    };

    class GlGetTexParameterfv: public Encodable {
    public:
        GlGetTexParameterfv() = default;
        GlGetTexParameterfv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Parameter, GLfloat__P Values)
                : mextras(extras)
                , mTarget(Target)
                , mParameter(Parameter)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mParameter;
        GLfloat__P mValues;
    };

    class GlGetTexParameteriv: public Encodable {
    public:
        GlGetTexParameteriv() = default;
        GlGetTexParameteriv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Parameter, GLint__P Values)
                : mextras(extras)
                , mTarget(Target)
                , mParameter(Parameter)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mParameter;
        GLint__P mValues;
    };

    class GlGetTexParameterxv: public Encodable {
    public:
        GlGetTexParameterxv() = default;
        GlGetTexParameterxv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Pname, GLfixed__P Params)
                : mextras(extras)
                , mTarget(Target)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mPname;
        GLfixed__P mParams;
    };

    class GlGetTexParameterxvOES: public Encodable {
    public:
        GlGetTexParameterxvOES() = default;
        GlGetTexParameterxvOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Pname, GLfixed__P Params)
                : mextras(extras)
                , mTarget(Target)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mPname;
        GLfixed__P mParams;
    };

    class GlGetTextureHandleNV: public Encodable {
    public:
        GlGetTextureHandleNV() = default;
        GlGetTextureHandleNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Texture, uint64_t Result)
                : mextras(extras)
                , mTexture(Texture)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mTexture);
            e->Uint64(this->mResult);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTexture;
        uint64_t mResult;
    };

    class GlGetTextureSamplerHandleNV: public Encodable {
    public:
        GlGetTextureSamplerHandleNV() = default;
        GlGetTextureSamplerHandleNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Texture, uint32_t Sampler, uint64_t Result)
                : mextras(extras)
                , mTexture(Texture)
                , mSampler(Sampler)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTexture;
        uint32_t mSampler;
        uint64_t mResult;
    };

    class GlGetTransformFeedbackVarying: public Encodable {
    public:
        GlGetTransformFeedbackVarying() = default;
        GlGetTransformFeedbackVarying(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, uint32_t Index, int32_t BufSize, GLsizei__P Length, GLsizei__P Size, GLenum__P Type, GLchar__P Name)
                : mextras(extras)
                , mProgram(Program)
                , mIndex(Index)
                , mBufSize(BufSize)
                , mLength(Length)
                , mSize(Size)
                , mType(Type)
                , mName(Name) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        uint32_t mIndex;
        int32_t mBufSize;
        GLsizei__P mLength;
        GLsizei__P mSize;
        GLenum__P mType;
        GLchar__P mName;
    };

    class GlGetTranslatedShaderSourceANGLE: public Encodable {
    public:
        GlGetTranslatedShaderSourceANGLE() = default;
        GlGetTranslatedShaderSourceANGLE(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Shader, int32_t Bufsize, GLsizei__P Length, GLchar__P Source)
                : mextras(extras)
                , mShader(Shader)
                , mBufsize(Bufsize)
                , mLength(Length)
                , mSource(Source) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mShader;
        int32_t mBufsize;
        GLsizei__P mLength;
        GLchar__P mSource;
    };

    class GlGetUniformBlockIndex: public Encodable {
    public:
        GlGetUniformBlockIndex() = default;
        GlGetUniformBlockIndex(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, const char* UniformBlockName, uint32_t Result)
                : mextras(extras)
                , mProgram(Program)
                , mUniformBlockName(UniformBlockName)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        const char* mUniformBlockName;
        uint32_t mResult;
    };

    class UniformIndex__P: public Encodable {
    public:
        UniformIndex__P() = default;
        UniformIndex__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class GlGetUniformIndices: public Encodable {
    public:
        GlGetUniformIndices() = default;
        GlGetUniformIndices(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t UniformCount, GLchar__CP__CP UniformNames, UniformIndex__P UniformIndices)
                : mextras(extras)
                , mProgram(Program)
                , mUniformCount(UniformCount)
                , mUniformNames(UniformNames)
                , mUniformIndices(UniformIndices) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mUniformCount;
        GLchar__CP__CP mUniformNames;
        UniformIndex__P mUniformIndices;
    };

    class GlGetUniformLocation: public Encodable {
    public:
        GlGetUniformLocation() = default;
        GlGetUniformLocation(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, const char* Name, int32_t Result)
                : mextras(extras)
                , mProgram(Program)
                , mName(Name)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        const char* mName;
        int32_t mResult;
    };

    class GlGetUniformfv: public Encodable {
    public:
        GlGetUniformfv() = default;
        GlGetUniformfv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, GLfloat__P Values)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        GLfloat__P mValues;
    };

    class GlGetUniformiv: public Encodable {
    public:
        GlGetUniformiv() = default;
        GlGetUniformiv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, GLint__P Values)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        GLint__P mValues;
    };

    class GlGetUniformuiv: public Encodable {
    public:
        GlGetUniformuiv() = default;
        GlGetUniformuiv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, GLuint__P Values)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        GLuint__P mValues;
    };

    class GlGetVertexAttribIiv: public Encodable {
    public:
        GlGetVertexAttribIiv() = default;
        GlGetVertexAttribIiv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Index, uint32_t Pname, GLint__P Params)
                : mextras(extras)
                , mIndex(Index)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mIndex;
        uint32_t mPname;
        GLint__P mParams;
    };

    class GlGetVertexAttribIuiv: public Encodable {
    public:
        GlGetVertexAttribIuiv() = default;
        GlGetVertexAttribIuiv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Index, uint32_t Pname, GLuint__P Params)
                : mextras(extras)
                , mIndex(Index)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mIndex;
        uint32_t mPname;
        GLuint__P mParams;
    };

    class GlGetVertexAttribPointerv: public Encodable {
    public:
        GlGetVertexAttribPointerv() = default;
        GlGetVertexAttribPointerv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Index, uint32_t Pname, Void__P__P Pointer)
                : mextras(extras)
                , mIndex(Index)
                , mPname(Pname)
                , mPointer(Pointer) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mIndex;
        uint32_t mPname;
        Void__P__P mPointer;
    };

    class GlGetVertexAttribfv: public Encodable {
    public:
        GlGetVertexAttribfv() = default;
        GlGetVertexAttribfv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Index, uint32_t Pname, GLfloat__P Params)
                : mextras(extras)
                , mIndex(Index)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mIndex;
        uint32_t mPname;
        GLfloat__P mParams;
    };

    class GlGetVertexAttribiv: public Encodable {
    public:
        GlGetVertexAttribiv() = default;
        GlGetVertexAttribiv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Index, uint32_t Pname, GLint__P Params)
                : mextras(extras)
                , mIndex(Index)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mIndex;
        uint32_t mPname;
        GLint__P mParams;
    };

    class GlGetnUniformfv: public Encodable {
    public:
        GlGetnUniformfv() = default;
        GlGetnUniformfv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, int32_t BufSize, GLfloat__P Values)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mBufSize(BufSize)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        int32_t mBufSize;
        GLfloat__P mValues;
    };

    class GlGetnUniformfvEXT: public Encodable {
    public:
        GlGetnUniformfvEXT() = default;
        GlGetnUniformfvEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, int32_t BufSize, GLfloat__P Params)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mBufSize(BufSize)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        int32_t mBufSize;
        GLfloat__P mParams;
    };

    class GlGetnUniformfvKHR: public Encodable {
    public:
        GlGetnUniformfvKHR() = default;
        GlGetnUniformfvKHR(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, int32_t BufSize, GLfloat__P Params)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mBufSize(BufSize)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        int32_t mBufSize;
        GLfloat__P mParams;
    };

    class GlGetnUniformiv: public Encodable {
    public:
        GlGetnUniformiv() = default;
        GlGetnUniformiv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, int32_t BufSize, GLint__P Values)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mBufSize(BufSize)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        int32_t mBufSize;
        GLint__P mValues;
    };

    class GlGetnUniformivEXT: public Encodable {
    public:
        GlGetnUniformivEXT() = default;
        GlGetnUniformivEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, int32_t BufSize, GLint__P Params)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mBufSize(BufSize)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        int32_t mBufSize;
        GLint__P mParams;
    };

    class GlGetnUniformivKHR: public Encodable {
    public:
        GlGetnUniformivKHR() = default;
        GlGetnUniformivKHR(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, int32_t BufSize, GLint__P Params)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mBufSize(BufSize)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        int32_t mBufSize;
        GLint__P mParams;
    };

    class GlGetnUniformuiv: public Encodable {
    public:
        GlGetnUniformuiv() = default;
        GlGetnUniformuiv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, int32_t BufSize, GLuint__P Values)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mBufSize(BufSize)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        int32_t mBufSize;
        GLuint__P mValues;
    };

    class GlGetnUniformuivKHR: public Encodable {
    public:
        GlGetnUniformuivKHR() = default;
        GlGetnUniformuivKHR(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, int32_t BufSize, GLuint__P Params)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mBufSize(BufSize)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        int32_t mBufSize;
        GLuint__P mParams;
    };

    class GlHint: public Encodable {
    public:
        GlHint() = default;
        GlHint(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Mode)
                : mextras(extras)
                , mTarget(Target)
                , mMode(Mode) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mTarget);
            e->Uint32(this->mMode);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mMode;
    };

    class GlInsertEventMarkerEXT: public Encodable {
    public:
        GlInsertEventMarkerEXT() = default;
        GlInsertEventMarkerEXT(const gapic::Vector<gapic::Encodable*>& extras, int32_t Length, GLchar__CP Marker)
                : mextras(extras)
                , mLength(Length)
                , mMarker(Marker) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int32(this->mLength);
            e->Struct(this->mMarker);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mLength;
        GLchar__CP mMarker;
    };

    class GlInterpolatePathsNV: public Encodable {
    public:
        GlInterpolatePathsNV() = default;
        GlInterpolatePathsNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t ResultPath, uint32_t PathA, uint32_t PathB, float Weight)
                : mextras(extras)
                , mResultPath(ResultPath)
                , mPathA(PathA)
                , mPathB(PathB)
                , mWeight(Weight) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mResultPath;
        uint32_t mPathA;
        uint32_t mPathB;
        float mWeight;
    };

    class GlInvalidateFramebuffer: public Encodable {
    public:
        GlInvalidateFramebuffer() = default;
        GlInvalidateFramebuffer(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, int32_t Count, GLenum__CP Attachments)
                : mextras(extras)
                , mTarget(Target)
                , mCount(Count)
                , mAttachments(Attachments) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        int32_t mCount;
        GLenum__CP mAttachments;
    };

    class GlInvalidateSubFramebuffer: public Encodable {
    public:
        GlInvalidateSubFramebuffer() = default;
        GlInvalidateSubFramebuffer(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, int32_t NumAttachments, GLenum__CP Attachments, int32_t X, int32_t Y, int32_t Width, int32_t Height)
                : mextras(extras)
                , mTarget(Target)
                , mNumAttachments(NumAttachments)
                , mAttachments(Attachments)
                , mX(X)
                , mY(Y)
                , mWidth(Width)
                , mHeight(Height) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        int32_t mNumAttachments;
        GLenum__CP mAttachments;
        int32_t mX;
        int32_t mY;
        int32_t mWidth;
        int32_t mHeight;
    };

    class GlIsBuffer: public Encodable {
    public:
        GlIsBuffer() = default;
        GlIsBuffer(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Buffer, uint8_t Result)
                : mextras(extras)
                , mBuffer(Buffer)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mBuffer);
            e->Uint8(this->mResult);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mBuffer;
        uint8_t mResult;
    };

    class GlIsEnabled: public Encodable {
    public:
        GlIsEnabled() = default;
        GlIsEnabled(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Capability, uint8_t Result)
                : mextras(extras)
                , mCapability(Capability)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mCapability);
            e->Uint8(this->mResult);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mCapability;
        uint8_t mResult;
    };

    class GlIsEnabledi: public Encodable {
    public:
        GlIsEnabledi() = default;
        GlIsEnabledi(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Capability, uint32_t Index, uint8_t Result)
                : mextras(extras)
                , mCapability(Capability)
                , mIndex(Index)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mCapability;
        uint32_t mIndex;
        uint8_t mResult;
    };

    class GlIsEnablediEXT: public Encodable {
    public:
        GlIsEnablediEXT() = default;
        GlIsEnablediEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Index, uint8_t Result)
                : mextras(extras)
                , mTarget(Target)
                , mIndex(Index)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mIndex;
        uint8_t mResult;
    };

    class GlIsEnablediNV: public Encodable {
    public:
        GlIsEnablediNV() = default;
        GlIsEnablediNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Index, uint8_t Result)
                : mextras(extras)
                , mTarget(Target)
                , mIndex(Index)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mIndex;
        uint8_t mResult;
    };

    class GlIsEnablediOES: public Encodable {
    public:
        GlIsEnablediOES() = default;
        GlIsEnablediOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Index, uint8_t Result)
                : mextras(extras)
                , mTarget(Target)
                , mIndex(Index)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mIndex;
        uint8_t mResult;
    };

    class GlIsFenceNV: public Encodable {
    public:
        GlIsFenceNV() = default;
        GlIsFenceNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Fence, uint8_t Result)
                : mextras(extras)
                , mFence(Fence)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mFence);
            e->Uint8(this->mResult);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mFence;
        uint8_t mResult;
    };

    class GlIsFramebuffer: public Encodable {
    public:
        GlIsFramebuffer() = default;
        GlIsFramebuffer(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Framebuffer, uint8_t Result)
                : mextras(extras)
                , mFramebuffer(Framebuffer)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mFramebuffer);
            e->Uint8(this->mResult);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mFramebuffer;
        uint8_t mResult;
    };

    class GlIsFramebufferOES: public Encodable {
    public:
        GlIsFramebufferOES() = default;
        GlIsFramebufferOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Framebuffer, uint8_t Result)
                : mextras(extras)
                , mFramebuffer(Framebuffer)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mFramebuffer);
            e->Uint8(this->mResult);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mFramebuffer;
        uint8_t mResult;
    };

    class GlIsImageHandleResidentNV: public Encodable {
    public:
        GlIsImageHandleResidentNV() = default;
        GlIsImageHandleResidentNV(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Handle, uint8_t Result)
                : mextras(extras)
                , mHandle(Handle)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint64(this->mHandle);
            e->Uint8(this->mResult);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mHandle;
        uint8_t mResult;
    };

    class GlIsPathNV: public Encodable {
    public:
        GlIsPathNV() = default;
        GlIsPathNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Path, uint8_t Result)
                : mextras(extras)
                , mPath(Path)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mPath);
            e->Uint8(this->mResult);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPath;
        uint8_t mResult;
    };

    class GlIsPointInFillPathNV: public Encodable {
    public:
        GlIsPointInFillPathNV() = default;
        GlIsPointInFillPathNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Path, uint32_t Mask, float X, float Y, uint8_t Result)
                : mextras(extras)
                , mPath(Path)
                , mMask(Mask)
                , mX(X)
                , mY(Y)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPath;
        uint32_t mMask;
        float mX;
        float mY;
        uint8_t mResult;
    };

    class GlIsPointInStrokePathNV: public Encodable {
    public:
        GlIsPointInStrokePathNV() = default;
        GlIsPointInStrokePathNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Path, float X, float Y, uint8_t Result)
                : mextras(extras)
                , mPath(Path)
                , mX(X)
                , mY(Y)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPath;
        float mX;
        float mY;
        uint8_t mResult;
    };

    class GlIsProgram: public Encodable {
    public:
        GlIsProgram() = default;
        GlIsProgram(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, uint8_t Result)
                : mextras(extras)
                , mProgram(Program)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mProgram);
            e->Uint8(this->mResult);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        uint8_t mResult;
    };

    class GlIsProgramPipeline: public Encodable {
    public:
        GlIsProgramPipeline() = default;
        GlIsProgramPipeline(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Pipeline, uint8_t Result)
                : mextras(extras)
                , mPipeline(Pipeline)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mPipeline);
            e->Uint8(this->mResult);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPipeline;
        uint8_t mResult;
    };

    class GlIsProgramPipelineEXT: public Encodable {
    public:
        GlIsProgramPipelineEXT() = default;
        GlIsProgramPipelineEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Pipeline, uint8_t Result)
                : mextras(extras)
                , mPipeline(Pipeline)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mPipeline);
            e->Uint8(this->mResult);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPipeline;
        uint8_t mResult;
    };

    class GlIsQuery: public Encodable {
    public:
        GlIsQuery() = default;
        GlIsQuery(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Query, uint8_t Result)
                : mextras(extras)
                , mQuery(Query)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mQuery);
            e->Uint8(this->mResult);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mQuery;
        uint8_t mResult;
    };

    class GlIsQueryEXT: public Encodable {
    public:
        GlIsQueryEXT() = default;
        GlIsQueryEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Query, uint8_t Result)
                : mextras(extras)
                , mQuery(Query)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mQuery);
            e->Uint8(this->mResult);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mQuery;
        uint8_t mResult;
    };

    class GlIsRenderbuffer: public Encodable {
    public:
        GlIsRenderbuffer() = default;
        GlIsRenderbuffer(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Renderbuffer, uint8_t Result)
                : mextras(extras)
                , mRenderbuffer(Renderbuffer)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mRenderbuffer);
            e->Uint8(this->mResult);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mRenderbuffer;
        uint8_t mResult;
    };

    class GlIsRenderbufferOES: public Encodable {
    public:
        GlIsRenderbufferOES() = default;
        GlIsRenderbufferOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Renderbuffer, uint8_t Result)
                : mextras(extras)
                , mRenderbuffer(Renderbuffer)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mRenderbuffer);
            e->Uint8(this->mResult);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mRenderbuffer;
        uint8_t mResult;
    };

    class GlIsSampler: public Encodable {
    public:
        GlIsSampler() = default;
        GlIsSampler(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Sampler, uint8_t Result)
                : mextras(extras)
                , mSampler(Sampler)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mSampler);
            e->Uint8(this->mResult);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mSampler;
        uint8_t mResult;
    };

    class GlIsShader: public Encodable {
    public:
        GlIsShader() = default;
        GlIsShader(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Shader, uint8_t Result)
                : mextras(extras)
                , mShader(Shader)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mShader);
            e->Uint8(this->mResult);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mShader;
        uint8_t mResult;
    };

    class GlIsSync: public Encodable {
    public:
        GlIsSync() = default;
        GlIsSync(const gapic::Vector<gapic::Encodable*>& extras, GLsync Sync, uint8_t Result)
                : mextras(extras)
                , mSync(Sync)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Struct(this->mSync);
            e->Uint8(this->mResult);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        GLsync mSync;
        uint8_t mResult;
    };

    class GlIsSyncAPPLE: public Encodable {
    public:
        GlIsSyncAPPLE() = default;
        GlIsSyncAPPLE(const gapic::Vector<gapic::Encodable*>& extras, GLsync Sync, uint8_t Result)
                : mextras(extras)
                , mSync(Sync)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Struct(this->mSync);
            e->Uint8(this->mResult);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        GLsync mSync;
        uint8_t mResult;
    };

    class GlIsTexture: public Encodable {
    public:
        GlIsTexture() = default;
        GlIsTexture(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Texture, uint8_t Result)
                : mextras(extras)
                , mTexture(Texture)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mTexture);
            e->Uint8(this->mResult);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTexture;
        uint8_t mResult;
    };

    class GlIsTextureHandleResidentNV: public Encodable {
    public:
        GlIsTextureHandleResidentNV() = default;
        GlIsTextureHandleResidentNV(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Handle, uint8_t Result)
                : mextras(extras)
                , mHandle(Handle)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint64(this->mHandle);
            e->Uint8(this->mResult);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mHandle;
        uint8_t mResult;
    };

    class GlIsTransformFeedback: public Encodable {
    public:
        GlIsTransformFeedback() = default;
        GlIsTransformFeedback(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Id, uint8_t Result)
                : mextras(extras)
                , mId(Id)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mId);
            e->Uint8(this->mResult);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mId;
        uint8_t mResult;
    };

    class GlIsVertexArray: public Encodable {
    public:
        GlIsVertexArray() = default;
        GlIsVertexArray(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Array, uint8_t Result)
                : mextras(extras)
                , mArray(Array)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mArray);
            e->Uint8(this->mResult);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mArray;
        uint8_t mResult;
    };

    class GlIsVertexArrayOES: public Encodable {
    public:
        GlIsVertexArrayOES() = default;
        GlIsVertexArrayOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Array, uint8_t Result)
                : mextras(extras)
                , mArray(Array)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mArray);
            e->Uint8(this->mResult);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mArray;
        uint8_t mResult;
    };

    class GlLabelObjectEXT: public Encodable {
    public:
        GlLabelObjectEXT() = default;
        GlLabelObjectEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Type, uint32_t Object, int32_t Length, GLchar__CP Label)
                : mextras(extras)
                , mType(Type)
                , mObject(Object)
                , mLength(Length)
                , mLabel(Label) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mType;
        uint32_t mObject;
        int32_t mLength;
        GLchar__CP mLabel;
    };

    class GlLightModelf: public Encodable {
    public:
        GlLightModelf() = default;
        GlLightModelf(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Pname, float Param)
                : mextras(extras)
                , mPname(Pname)
                , mParam(Param) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mPname);
            e->Float32(this->mParam);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPname;
        float mParam;
    };

    class GlLightModelfv: public Encodable {
    public:
        GlLightModelfv() = default;
        GlLightModelfv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Pname, GLfloat__CP Params)
                : mextras(extras)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mPname);
            e->Struct(this->mParams);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPname;
        GLfloat__CP mParams;
    };

    class GlLightModelx: public Encodable {
    public:
        GlLightModelx() = default;
        GlLightModelx(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Pname, int32_t Param)
                : mextras(extras)
                , mPname(Pname)
                , mParam(Param) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mPname);
            e->Int32(this->mParam);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPname;
        int32_t mParam;
    };

    class GlLightModelxOES: public Encodable {
    public:
        GlLightModelxOES() = default;
        GlLightModelxOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Pname, int32_t Param)
                : mextras(extras)
                , mPname(Pname)
                , mParam(Param) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mPname);
            e->Int32(this->mParam);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPname;
        int32_t mParam;
    };

    class GlLightModelxv: public Encodable {
    public:
        GlLightModelxv() = default;
        GlLightModelxv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Pname, GLfixed__CP Param)
                : mextras(extras)
                , mPname(Pname)
                , mParam(Param) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mPname);
            e->Struct(this->mParam);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPname;
        GLfixed__CP mParam;
    };

    class GlLightModelxvOES: public Encodable {
    public:
        GlLightModelxvOES() = default;
        GlLightModelxvOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Pname, GLfixed__CP Param)
                : mextras(extras)
                , mPname(Pname)
                , mParam(Param) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mPname);
            e->Struct(this->mParam);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPname;
        GLfixed__CP mParam;
    };

    class GlLightf: public Encodable {
    public:
        GlLightf() = default;
        GlLightf(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Light, uint32_t Pname, float Param)
                : mextras(extras)
                , mLight(Light)
                , mPname(Pname)
                , mParam(Param) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mLight;
        uint32_t mPname;
        float mParam;
    };

    class GlLightfv: public Encodable {
    public:
        GlLightfv() = default;
        GlLightfv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Light, uint32_t Pname, GLfloat__CP Params)
                : mextras(extras)
                , mLight(Light)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mLight;
        uint32_t mPname;
        GLfloat__CP mParams;
    };

    class GlLightx: public Encodable {
    public:
        GlLightx() = default;
        GlLightx(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Light, uint32_t Pname, int32_t Param)
                : mextras(extras)
                , mLight(Light)
                , mPname(Pname)
                , mParam(Param) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mLight;
        uint32_t mPname;
        int32_t mParam;
    };

    class GlLightxOES: public Encodable {
    public:
        GlLightxOES() = default;
        GlLightxOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Light, uint32_t Pname, int32_t Param)
                : mextras(extras)
                , mLight(Light)
                , mPname(Pname)
                , mParam(Param) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mLight;
        uint32_t mPname;
        int32_t mParam;
    };

    class GlLightxv: public Encodable {
    public:
        GlLightxv() = default;
        GlLightxv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Light, uint32_t Pname, GLfixed__CP Params)
                : mextras(extras)
                , mLight(Light)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mLight;
        uint32_t mPname;
        GLfixed__CP mParams;
    };

    class GlLightxvOES: public Encodable {
    public:
        GlLightxvOES() = default;
        GlLightxvOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Light, uint32_t Pname, GLfixed__CP Params)
                : mextras(extras)
                , mLight(Light)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mLight;
        uint32_t mPname;
        GLfixed__CP mParams;
    };

    class GlLineWidth: public Encodable {
    public:
        GlLineWidth() = default;
        GlLineWidth(const gapic::Vector<gapic::Encodable*>& extras, float Width)
                : mextras(extras)
                , mWidth(Width) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Float32(this->mWidth);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        float mWidth;
    };

    class GlLineWidthx: public Encodable {
    public:
        GlLineWidthx() = default;
        GlLineWidthx(const gapic::Vector<gapic::Encodable*>& extras, int32_t Width)
                : mextras(extras)
                , mWidth(Width) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int32(this->mWidth);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mWidth;
    };

    class GlLineWidthxOES: public Encodable {
    public:
        GlLineWidthxOES() = default;
        GlLineWidthxOES(const gapic::Vector<gapic::Encodable*>& extras, int32_t Width)
                : mextras(extras)
                , mWidth(Width) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int32(this->mWidth);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mWidth;
    };

    class GlLinkProgram: public Encodable {
    public:
        GlLinkProgram() = default;
        GlLinkProgram(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program)
                : mextras(extras)
                , mProgram(Program) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mProgram);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
    };

    class GlLoadIdentity: public Encodable {
    public:
        GlLoadIdentity() = default;
        GlLoadIdentity(const gapic::Vector<gapic::Encodable*>& extras)
                : mextras(extras) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
    };

    class GlLoadMatrixf: public Encodable {
    public:
        GlLoadMatrixf() = default;
        GlLoadMatrixf(const gapic::Vector<gapic::Encodable*>& extras, GLfloat__CP M)
                : mextras(extras)
                , mM(M) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Struct(this->mM);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        GLfloat__CP mM;
    };

    class GlLoadMatrixx: public Encodable {
    public:
        GlLoadMatrixx() = default;
        GlLoadMatrixx(const gapic::Vector<gapic::Encodable*>& extras, GLfixed__CP M)
                : mextras(extras)
                , mM(M) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Struct(this->mM);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        GLfixed__CP mM;
    };

    class GlLoadMatrixxOES: public Encodable {
    public:
        GlLoadMatrixxOES() = default;
        GlLoadMatrixxOES(const gapic::Vector<gapic::Encodable*>& extras, GLfixed__CP M)
                : mextras(extras)
                , mM(M) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Struct(this->mM);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        GLfixed__CP mM;
    };

    class GlLoadPaletteFromModelViewMatrixOES: public Encodable {
    public:
        GlLoadPaletteFromModelViewMatrixOES() = default;
        GlLoadPaletteFromModelViewMatrixOES(const gapic::Vector<gapic::Encodable*>& extras)
                : mextras(extras) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
    };

    class GlLogicOp: public Encodable {
    public:
        GlLogicOp() = default;
        GlLogicOp(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Opcode)
                : mextras(extras)
                , mOpcode(Opcode) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mOpcode);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mOpcode;
    };

    class GlMakeImageHandleNonResidentNV: public Encodable {
    public:
        GlMakeImageHandleNonResidentNV() = default;
        GlMakeImageHandleNonResidentNV(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Handle)
                : mextras(extras)
                , mHandle(Handle) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint64(this->mHandle);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mHandle;
    };

    class GlMakeImageHandleResidentNV: public Encodable {
    public:
        GlMakeImageHandleResidentNV() = default;
        GlMakeImageHandleResidentNV(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Handle, uint32_t Access)
                : mextras(extras)
                , mHandle(Handle)
                , mAccess(Access) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint64(this->mHandle);
            e->Uint32(this->mAccess);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mHandle;
        uint32_t mAccess;
    };

    class GlMakeTextureHandleNonResidentNV: public Encodable {
    public:
        GlMakeTextureHandleNonResidentNV() = default;
        GlMakeTextureHandleNonResidentNV(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Handle)
                : mextras(extras)
                , mHandle(Handle) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint64(this->mHandle);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mHandle;
    };

    class GlMakeTextureHandleResidentNV: public Encodable {
    public:
        GlMakeTextureHandleResidentNV() = default;
        GlMakeTextureHandleResidentNV(const gapic::Vector<gapic::Encodable*>& extras, uint64_t Handle)
                : mextras(extras)
                , mHandle(Handle) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint64(this->mHandle);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint64_t mHandle;
    };

    class GlMapBuffer: public Encodable {
    public:
        GlMapBuffer() = default;
        GlMapBuffer(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Access, Void__P Result)
                : mextras(extras)
                , mTarget(Target)
                , mAccess(Access)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mAccess;
        Void__P mResult;
    };

    class GlMapBufferOES: public Encodable {
    public:
        GlMapBufferOES() = default;
        GlMapBufferOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Access, Void__P Result)
                : mextras(extras)
                , mTarget(Target)
                , mAccess(Access)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mAccess;
        Void__P mResult;
    };

    class GlMapBufferRange: public Encodable {
    public:
        GlMapBufferRange() = default;
        GlMapBufferRange(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, int32_t Offset, int32_t Length, uint32_t Access, Void__P Result)
                : mextras(extras)
                , mTarget(Target)
                , mOffset(Offset)
                , mLength(Length)
                , mAccess(Access)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        int32_t mOffset;
        int32_t mLength;
        uint32_t mAccess;
        Void__P mResult;
    };

    class GlMapBufferRangeEXT: public Encodable {
    public:
        GlMapBufferRangeEXT() = default;
        GlMapBufferRangeEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, int32_t Offset, int32_t Length, uint32_t Access, Void__P Result)
                : mextras(extras)
                , mTarget(Target)
                , mOffset(Offset)
                , mLength(Length)
                , mAccess(Access)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        int32_t mOffset;
        int32_t mLength;
        uint32_t mAccess;
        Void__P mResult;
    };

    class GlMaterialf: public Encodable {
    public:
        GlMaterialf() = default;
        GlMaterialf(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Face, uint32_t Pname, float Param)
                : mextras(extras)
                , mFace(Face)
                , mPname(Pname)
                , mParam(Param) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mFace;
        uint32_t mPname;
        float mParam;
    };

    class GlMaterialfv: public Encodable {
    public:
        GlMaterialfv() = default;
        GlMaterialfv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Face, uint32_t Pname, GLfloat__CP Params)
                : mextras(extras)
                , mFace(Face)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mFace;
        uint32_t mPname;
        GLfloat__CP mParams;
    };

    class GlMaterialx: public Encodable {
    public:
        GlMaterialx() = default;
        GlMaterialx(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Face, uint32_t Pname, int32_t Param)
                : mextras(extras)
                , mFace(Face)
                , mPname(Pname)
                , mParam(Param) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mFace;
        uint32_t mPname;
        int32_t mParam;
    };

    class GlMaterialxOES: public Encodable {
    public:
        GlMaterialxOES() = default;
        GlMaterialxOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Face, uint32_t Pname, int32_t Param)
                : mextras(extras)
                , mFace(Face)
                , mPname(Pname)
                , mParam(Param) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mFace;
        uint32_t mPname;
        int32_t mParam;
    };

    class GlMaterialxv: public Encodable {
    public:
        GlMaterialxv() = default;
        GlMaterialxv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Face, uint32_t Pname, GLfixed__CP Param)
                : mextras(extras)
                , mFace(Face)
                , mPname(Pname)
                , mParam(Param) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mFace;
        uint32_t mPname;
        GLfixed__CP mParam;
    };

    class GlMaterialxvOES: public Encodable {
    public:
        GlMaterialxvOES() = default;
        GlMaterialxvOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Face, uint32_t Pname, GLfixed__CP Param)
                : mextras(extras)
                , mFace(Face)
                , mPname(Pname)
                , mParam(Param) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mFace;
        uint32_t mPname;
        GLfixed__CP mParam;
    };

    class GlMatrixIndexPointerOES: public Encodable {
    public:
        GlMatrixIndexPointerOES() = default;
        GlMatrixIndexPointerOES(const gapic::Vector<gapic::Encodable*>& extras, int32_t Size, uint32_t Type, int32_t Stride, Void__CP Pointer)
                : mextras(extras)
                , mSize(Size)
                , mType(Type)
                , mStride(Stride)
                , mPointer(Pointer) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mSize;
        uint32_t mType;
        int32_t mStride;
        Void__CP mPointer;
    };

    class GlMatrixIndexPointerOESBounds: public Encodable {
    public:
        GlMatrixIndexPointerOESBounds() = default;
        GlMatrixIndexPointerOESBounds(const gapic::Vector<gapic::Encodable*>& extras, int32_t Size, uint32_t Type, int32_t Stride, Void__CP Pointer, int32_t Count)
                : mextras(extras)
                , mSize(Size)
                , mType(Type)
                , mStride(Stride)
                , mPointer(Pointer)
                , mCount(Count) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mSize;
        uint32_t mType;
        int32_t mStride;
        Void__CP mPointer;
        int32_t mCount;
    };

    class GlMatrixLoad3x2fNV: public Encodable {
    public:
        GlMatrixLoad3x2fNV() = default;
        GlMatrixLoad3x2fNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t MatrixMode, GLfloat__CP M)
                : mextras(extras)
                , mMatrixMode(MatrixMode)
                , mM(M) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mMatrixMode);
            e->Struct(this->mM);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mMatrixMode;
        GLfloat__CP mM;
    };

    class GlMatrixLoad3x3fNV: public Encodable {
    public:
        GlMatrixLoad3x3fNV() = default;
        GlMatrixLoad3x3fNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t MatrixMode, GLfloat__CP M)
                : mextras(extras)
                , mMatrixMode(MatrixMode)
                , mM(M) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mMatrixMode);
            e->Struct(this->mM);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mMatrixMode;
        GLfloat__CP mM;
    };

    class GlMatrixLoadTranspose3x3fNV: public Encodable {
    public:
        GlMatrixLoadTranspose3x3fNV() = default;
        GlMatrixLoadTranspose3x3fNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t MatrixMode, GLfloat__CP M)
                : mextras(extras)
                , mMatrixMode(MatrixMode)
                , mM(M) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mMatrixMode);
            e->Struct(this->mM);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mMatrixMode;
        GLfloat__CP mM;
    };

    class GlMatrixMode: public Encodable {
    public:
        GlMatrixMode() = default;
        GlMatrixMode(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Mode)
                : mextras(extras)
                , mMode(Mode) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mMode);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mMode;
    };

    class GlMatrixMult3x2fNV: public Encodable {
    public:
        GlMatrixMult3x2fNV() = default;
        GlMatrixMult3x2fNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t MatrixMode, GLfloat__CP M)
                : mextras(extras)
                , mMatrixMode(MatrixMode)
                , mM(M) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mMatrixMode);
            e->Struct(this->mM);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mMatrixMode;
        GLfloat__CP mM;
    };

    class GlMatrixMult3x3fNV: public Encodable {
    public:
        GlMatrixMult3x3fNV() = default;
        GlMatrixMult3x3fNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t MatrixMode, GLfloat__CP M)
                : mextras(extras)
                , mMatrixMode(MatrixMode)
                , mM(M) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mMatrixMode);
            e->Struct(this->mM);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mMatrixMode;
        GLfloat__CP mM;
    };

    class GlMatrixMultTranspose3x3fNV: public Encodable {
    public:
        GlMatrixMultTranspose3x3fNV() = default;
        GlMatrixMultTranspose3x3fNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t MatrixMode, GLfloat__CP M)
                : mextras(extras)
                , mMatrixMode(MatrixMode)
                , mM(M) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mMatrixMode);
            e->Struct(this->mM);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mMatrixMode;
        GLfloat__CP mM;
    };

    class GlMemoryBarrier: public Encodable {
    public:
        GlMemoryBarrier() = default;
        GlMemoryBarrier(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Barriers)
                : mextras(extras)
                , mBarriers(Barriers) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mBarriers);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mBarriers;
    };

    class GlMemoryBarrierByRegion: public Encodable {
    public:
        GlMemoryBarrierByRegion() = default;
        GlMemoryBarrierByRegion(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Barriers)
                : mextras(extras)
                , mBarriers(Barriers) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mBarriers);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mBarriers;
    };

    class GlMinSampleShading: public Encodable {
    public:
        GlMinSampleShading() = default;
        GlMinSampleShading(const gapic::Vector<gapic::Encodable*>& extras, float Value)
                : mextras(extras)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Float32(this->mValue);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        float mValue;
    };

    class GlMinSampleShadingOES: public Encodable {
    public:
        GlMinSampleShadingOES() = default;
        GlMinSampleShadingOES(const gapic::Vector<gapic::Encodable*>& extras, float Value)
                : mextras(extras)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Float32(this->mValue);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        float mValue;
    };

    class GlMultMatrixf: public Encodable {
    public:
        GlMultMatrixf() = default;
        GlMultMatrixf(const gapic::Vector<gapic::Encodable*>& extras, GLfloat__CP M)
                : mextras(extras)
                , mM(M) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Struct(this->mM);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        GLfloat__CP mM;
    };

    class GlMultMatrixx: public Encodable {
    public:
        GlMultMatrixx() = default;
        GlMultMatrixx(const gapic::Vector<gapic::Encodable*>& extras, GLfixed__CP M)
                : mextras(extras)
                , mM(M) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Struct(this->mM);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        GLfixed__CP mM;
    };

    class GlMultMatrixxOES: public Encodable {
    public:
        GlMultMatrixxOES() = default;
        GlMultMatrixxOES(const gapic::Vector<gapic::Encodable*>& extras, GLfixed__CP M)
                : mextras(extras)
                , mM(M) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Struct(this->mM);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        GLfixed__CP mM;
    };

    class GlMultiDrawArraysEXT: public Encodable {
    public:
        GlMultiDrawArraysEXT() = default;
        GlMultiDrawArraysEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Mode, GLint__CP First, GLsizei__CP Count, int32_t Primcount)
                : mextras(extras)
                , mMode(Mode)
                , mFirst(First)
                , mCount(Count)
                , mPrimcount(Primcount) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mMode;
        GLint__CP mFirst;
        GLsizei__CP mCount;
        int32_t mPrimcount;
    };

    class GlMultiDrawArraysIndirectEXT: public Encodable {
    public:
        GlMultiDrawArraysIndirectEXT() = default;
        GlMultiDrawArraysIndirectEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Mode, Void__CP Indirect, int32_t Drawcount, int32_t Stride)
                : mextras(extras)
                , mMode(Mode)
                , mIndirect(Indirect)
                , mDrawcount(Drawcount)
                , mStride(Stride) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mMode;
        Void__CP mIndirect;
        int32_t mDrawcount;
        int32_t mStride;
    };

    class Void__CP__CP: public Encodable {
    public:
        Void__CP__CP() = default;
        Void__CP__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class GlMultiDrawElementsBaseVertexEXT: public Encodable {
    public:
        GlMultiDrawElementsBaseVertexEXT() = default;
        GlMultiDrawElementsBaseVertexEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Mode, GLsizei__CP Count, uint32_t Type, Void__CP__CP Indices, int32_t Primcount, GLint__CP Basevertex)
                : mextras(extras)
                , mMode(Mode)
                , mCount(Count)
                , mType(Type)
                , mIndices(Indices)
                , mPrimcount(Primcount)
                , mBasevertex(Basevertex) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mMode;
        GLsizei__CP mCount;
        uint32_t mType;
        Void__CP__CP mIndices;
        int32_t mPrimcount;
        GLint__CP mBasevertex;
    };

    class GlMultiDrawElementsBaseVertexOES: public Encodable {
    public:
        GlMultiDrawElementsBaseVertexOES() = default;
        GlMultiDrawElementsBaseVertexOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Mode, GLsizei__CP Count, uint32_t Type, Void__CP__CP Indices, int32_t Primcount, GLint__CP Basevertex)
                : mextras(extras)
                , mMode(Mode)
                , mCount(Count)
                , mType(Type)
                , mIndices(Indices)
                , mPrimcount(Primcount)
                , mBasevertex(Basevertex) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mMode;
        GLsizei__CP mCount;
        uint32_t mType;
        Void__CP__CP mIndices;
        int32_t mPrimcount;
        GLint__CP mBasevertex;
    };

    class GlMultiDrawElementsEXT: public Encodable {
    public:
        GlMultiDrawElementsEXT() = default;
        GlMultiDrawElementsEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Mode, GLsizei__CP Count, uint32_t Type, Void__CP__CP Indices, int32_t Primcount)
                : mextras(extras)
                , mMode(Mode)
                , mCount(Count)
                , mType(Type)
                , mIndices(Indices)
                , mPrimcount(Primcount) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mMode;
        GLsizei__CP mCount;
        uint32_t mType;
        Void__CP__CP mIndices;
        int32_t mPrimcount;
    };

    class GlMultiDrawElementsIndirectEXT: public Encodable {
    public:
        GlMultiDrawElementsIndirectEXT() = default;
        GlMultiDrawElementsIndirectEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Mode, uint32_t Type, Void__CP Indirect, int32_t Drawcount, int32_t Stride)
                : mextras(extras)
                , mMode(Mode)
                , mType(Type)
                , mIndirect(Indirect)
                , mDrawcount(Drawcount)
                , mStride(Stride) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mMode;
        uint32_t mType;
        Void__CP mIndirect;
        int32_t mDrawcount;
        int32_t mStride;
    };

    class GlMultiTexCoord4f: public Encodable {
    public:
        GlMultiTexCoord4f() = default;
        GlMultiTexCoord4f(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, float V0, float V1, float V2, float V3)
                : mextras(extras)
                , mTarget(Target)
                , mV0(V0)
                , mV1(V1)
                , mV2(V2)
                , mV3(V3) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        float mV0;
        float mV1;
        float mV2;
        float mV3;
    };

    class GlMultiTexCoord4x: public Encodable {
    public:
        GlMultiTexCoord4x() = default;
        GlMultiTexCoord4x(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Texture, int32_t V0, int32_t V1, int32_t V2, int32_t V3)
                : mextras(extras)
                , mTexture(Texture)
                , mV0(V0)
                , mV1(V1)
                , mV2(V2)
                , mV3(V3) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTexture;
        int32_t mV0;
        int32_t mV1;
        int32_t mV2;
        int32_t mV3;
    };

    class GlMultiTexCoord4xOES: public Encodable {
    public:
        GlMultiTexCoord4xOES() = default;
        GlMultiTexCoord4xOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Texture, int32_t V0, int32_t V1, int32_t V2, int32_t V3)
                : mextras(extras)
                , mTexture(Texture)
                , mV0(V0)
                , mV1(V1)
                , mV2(V2)
                , mV3(V3) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTexture;
        int32_t mV0;
        int32_t mV1;
        int32_t mV2;
        int32_t mV3;
    };

    class GlNamedFramebufferSampleLocationsfvNV: public Encodable {
    public:
        GlNamedFramebufferSampleLocationsfvNV() = default;
        GlNamedFramebufferSampleLocationsfvNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Framebuffer, uint32_t Start, int32_t Count, GLfloat__CP V)
                : mextras(extras)
                , mFramebuffer(Framebuffer)
                , mStart(Start)
                , mCount(Count)
                , mV(V) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mFramebuffer;
        uint32_t mStart;
        int32_t mCount;
        GLfloat__CP mV;
    };

    class GlNormal3f: public Encodable {
    public:
        GlNormal3f() = default;
        GlNormal3f(const gapic::Vector<gapic::Encodable*>& extras, float Nx, float Ny, float Nz)
                : mextras(extras)
                , mNx(Nx)
                , mNy(Ny)
                , mNz(Nz) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        float mNx;
        float mNy;
        float mNz;
    };

    class GlNormal3x: public Encodable {
    public:
        GlNormal3x() = default;
        GlNormal3x(const gapic::Vector<gapic::Encodable*>& extras, int32_t Nx, int32_t Ny, int32_t Nz)
                : mextras(extras)
                , mNx(Nx)
                , mNy(Ny)
                , mNz(Nz) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mNx;
        int32_t mNy;
        int32_t mNz;
    };

    class GlNormal3xOES: public Encodable {
    public:
        GlNormal3xOES() = default;
        GlNormal3xOES(const gapic::Vector<gapic::Encodable*>& extras, int32_t Nx, int32_t Ny, int32_t Nz)
                : mextras(extras)
                , mNx(Nx)
                , mNy(Ny)
                , mNz(Nz) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mNx;
        int32_t mNy;
        int32_t mNz;
    };

    class GlNormalPointer: public Encodable {
    public:
        GlNormalPointer() = default;
        GlNormalPointer(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Type, int32_t Stride, Void__CP Pointer)
                : mextras(extras)
                , mType(Type)
                , mStride(Stride)
                , mPointer(Pointer) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mType;
        int32_t mStride;
        Void__CP mPointer;
    };

    class GlNormalPointerBounds: public Encodable {
    public:
        GlNormalPointerBounds() = default;
        GlNormalPointerBounds(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Type, int32_t Stride, Void__CP Pointer, int32_t Count)
                : mextras(extras)
                , mType(Type)
                , mStride(Stride)
                , mPointer(Pointer)
                , mCount(Count) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mType;
        int32_t mStride;
        Void__CP mPointer;
        int32_t mCount;
    };

    class GlObjectLabel: public Encodable {
    public:
        GlObjectLabel() = default;
        GlObjectLabel(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Identifier, uint32_t Name, int32_t Length, GLchar__CP Label)
                : mextras(extras)
                , mIdentifier(Identifier)
                , mName(Name)
                , mLength(Length)
                , mLabel(Label) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mIdentifier;
        uint32_t mName;
        int32_t mLength;
        GLchar__CP mLabel;
    };

    class GlObjectLabelKHR: public Encodable {
    public:
        GlObjectLabelKHR() = default;
        GlObjectLabelKHR(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Identifier, uint32_t Name, int32_t Length, GLchar__CP Label)
                : mextras(extras)
                , mIdentifier(Identifier)
                , mName(Name)
                , mLength(Length)
                , mLabel(Label) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mIdentifier;
        uint32_t mName;
        int32_t mLength;
        GLchar__CP mLabel;
    };

    class GlObjectPtrLabel: public Encodable {
    public:
        GlObjectPtrLabel() = default;
        GlObjectPtrLabel(const gapic::Vector<gapic::Encodable*>& extras, Void__CP Ptr, int32_t Length, GLchar__CP Label)
                : mextras(extras)
                , mPtr(Ptr)
                , mLength(Length)
                , mLabel(Label) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        Void__CP mPtr;
        int32_t mLength;
        GLchar__CP mLabel;
    };

    class GlObjectPtrLabelKHR: public Encodable {
    public:
        GlObjectPtrLabelKHR() = default;
        GlObjectPtrLabelKHR(const gapic::Vector<gapic::Encodable*>& extras, Void__CP Ptr, int32_t Length, GLchar__CP Label)
                : mextras(extras)
                , mPtr(Ptr)
                , mLength(Length)
                , mLabel(Label) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        Void__CP mPtr;
        int32_t mLength;
        GLchar__CP mLabel;
    };

    class GlOrthof: public Encodable {
    public:
        GlOrthof() = default;
        GlOrthof(const gapic::Vector<gapic::Encodable*>& extras, float L, float R, float B, float T, float N, float F)
                : mextras(extras)
                , mL(L)
                , mR(R)
                , mB(B)
                , mT(T)
                , mN(N)
                , mF(F) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        float mL;
        float mR;
        float mB;
        float mT;
        float mN;
        float mF;
    };

    class GlOrthofOES: public Encodable {
    public:
        GlOrthofOES() = default;
        GlOrthofOES(const gapic::Vector<gapic::Encodable*>& extras, float L, float R, float B, float T, float N, float F)
                : mextras(extras)
                , mL(L)
                , mR(R)
                , mB(B)
                , mT(T)
                , mN(N)
                , mF(F) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        float mL;
        float mR;
        float mB;
        float mT;
        float mN;
        float mF;
    };

    class GlOrthox: public Encodable {
    public:
        GlOrthox() = default;
        GlOrthox(const gapic::Vector<gapic::Encodable*>& extras, int32_t L, int32_t R, int32_t B, int32_t T, int32_t N, int32_t F)
                : mextras(extras)
                , mL(L)
                , mR(R)
                , mB(B)
                , mT(T)
                , mN(N)
                , mF(F) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mL;
        int32_t mR;
        int32_t mB;
        int32_t mT;
        int32_t mN;
        int32_t mF;
    };

    class GlOrthoxOES: public Encodable {
    public:
        GlOrthoxOES() = default;
        GlOrthoxOES(const gapic::Vector<gapic::Encodable*>& extras, int32_t L, int32_t R, int32_t B, int32_t T, int32_t N, int32_t F)
                : mextras(extras)
                , mL(L)
                , mR(R)
                , mB(B)
                , mT(T)
                , mN(N)
                , mF(F) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mL;
        int32_t mR;
        int32_t mB;
        int32_t mT;
        int32_t mN;
        int32_t mF;
    };

    class GlPatchParameteri: public Encodable {
    public:
        GlPatchParameteri() = default;
        GlPatchParameteri(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Pname, int32_t Value)
                : mextras(extras)
                , mPname(Pname)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mPname);
            e->Int32(this->mValue);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPname;
        int32_t mValue;
    };

    class GlPatchParameteriEXT: public Encodable {
    public:
        GlPatchParameteriEXT() = default;
        GlPatchParameteriEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Pname, int32_t Value)
                : mextras(extras)
                , mPname(Pname)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mPname);
            e->Int32(this->mValue);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPname;
        int32_t mValue;
    };

    class GlPatchParameteriOES: public Encodable {
    public:
        GlPatchParameteriOES() = default;
        GlPatchParameteriOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Pname, int32_t Value)
                : mextras(extras)
                , mPname(Pname)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mPname);
            e->Int32(this->mValue);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPname;
        int32_t mValue;
    };

    class GlPathCommandsNV: public Encodable {
    public:
        GlPathCommandsNV() = default;
        GlPathCommandsNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Path, int32_t NumCommands, GLubyte__CP Commands, int32_t NumCoords, uint32_t CoordType, Void__CP Coords)
                : mextras(extras)
                , mPath(Path)
                , mNumCommands(NumCommands)
                , mCommands(Commands)
                , mNumCoords(NumCoords)
                , mCoordType(CoordType)
                , mCoords(Coords) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPath;
        int32_t mNumCommands;
        GLubyte__CP mCommands;
        int32_t mNumCoords;
        uint32_t mCoordType;
        Void__CP mCoords;
    };

    class GlPathCoordsNV: public Encodable {
    public:
        GlPathCoordsNV() = default;
        GlPathCoordsNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Path, int32_t NumCoords, uint32_t CoordType, Void__CP Coords)
                : mextras(extras)
                , mPath(Path)
                , mNumCoords(NumCoords)
                , mCoordType(CoordType)
                , mCoords(Coords) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPath;
        int32_t mNumCoords;
        uint32_t mCoordType;
        Void__CP mCoords;
    };

    class GlPathCoverDepthFuncNV: public Encodable {
    public:
        GlPathCoverDepthFuncNV() = default;
        GlPathCoverDepthFuncNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Func)
                : mextras(extras)
                , mFunc(Func) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mFunc);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mFunc;
    };

    class GlPathDashArrayNV: public Encodable {
    public:
        GlPathDashArrayNV() = default;
        GlPathDashArrayNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Path, int32_t DashCount, GLfloat__CP DashArray)
                : mextras(extras)
                , mPath(Path)
                , mDashCount(DashCount)
                , mDashArray(DashArray) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPath;
        int32_t mDashCount;
        GLfloat__CP mDashArray;
    };

    class GlPathGlyphIndexArrayNV: public Encodable {
    public:
        GlPathGlyphIndexArrayNV() = default;
        GlPathGlyphIndexArrayNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t FirstPathName, uint32_t FontTarget, Void__CP FontName, uint32_t FontStyle, uint32_t FirstGlyphIndex, int32_t NumGlyphs, uint32_t PathParameterTemplate, float EmScale, uint32_t Result)
                : mextras(extras)
                , mFirstPathName(FirstPathName)
                , mFontTarget(FontTarget)
                , mFontName(FontName)
                , mFontStyle(FontStyle)
                , mFirstGlyphIndex(FirstGlyphIndex)
                , mNumGlyphs(NumGlyphs)
                , mPathParameterTemplate(PathParameterTemplate)
                , mEmScale(EmScale)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mFirstPathName;
        uint32_t mFontTarget;
        Void__CP mFontName;
        uint32_t mFontStyle;
        uint32_t mFirstGlyphIndex;
        int32_t mNumGlyphs;
        uint32_t mPathParameterTemplate;
        float mEmScale;
        uint32_t mResult;
    };

    class GlPathGlyphIndexRangeNV: public Encodable {
    public:
        GlPathGlyphIndexRangeNV() = default;
        GlPathGlyphIndexRangeNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t FontTarget, Void__CP FontName, uint32_t FontStyle, uint32_t PathParameterTemplate, float EmScale, uint32_t BaseAndCount, uint32_t Result)
                : mextras(extras)
                , mFontTarget(FontTarget)
                , mFontName(FontName)
                , mFontStyle(FontStyle)
                , mPathParameterTemplate(PathParameterTemplate)
                , mEmScale(EmScale)
                , mBaseAndCount(BaseAndCount)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mFontTarget;
        Void__CP mFontName;
        uint32_t mFontStyle;
        uint32_t mPathParameterTemplate;
        float mEmScale;
        uint32_t mBaseAndCount;
        uint32_t mResult;
    };

    class GlPathGlyphRangeNV: public Encodable {
    public:
        GlPathGlyphRangeNV() = default;
        GlPathGlyphRangeNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t FirstPathName, uint32_t FontTarget, Void__CP FontName, uint32_t FontStyle, uint32_t FirstGlyph, int32_t NumGlyphs, uint32_t HandleMissingGlyphs, uint32_t PathParameterTemplate, float EmScale)
                : mextras(extras)
                , mFirstPathName(FirstPathName)
                , mFontTarget(FontTarget)
                , mFontName(FontName)
                , mFontStyle(FontStyle)
                , mFirstGlyph(FirstGlyph)
                , mNumGlyphs(NumGlyphs)
                , mHandleMissingGlyphs(HandleMissingGlyphs)
                , mPathParameterTemplate(PathParameterTemplate)
                , mEmScale(EmScale) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mFirstPathName;
        uint32_t mFontTarget;
        Void__CP mFontName;
        uint32_t mFontStyle;
        uint32_t mFirstGlyph;
        int32_t mNumGlyphs;
        uint32_t mHandleMissingGlyphs;
        uint32_t mPathParameterTemplate;
        float mEmScale;
    };

    class GlPathGlyphsNV: public Encodable {
    public:
        GlPathGlyphsNV() = default;
        GlPathGlyphsNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t FirstPathName, uint32_t FontTarget, Void__CP FontName, uint32_t FontStyle, int32_t NumGlyphs, uint32_t Type, Void__CP Charcodes, uint32_t HandleMissingGlyphs, uint32_t PathParameterTemplate, float EmScale)
                : mextras(extras)
                , mFirstPathName(FirstPathName)
                , mFontTarget(FontTarget)
                , mFontName(FontName)
                , mFontStyle(FontStyle)
                , mNumGlyphs(NumGlyphs)
                , mType(Type)
                , mCharcodes(Charcodes)
                , mHandleMissingGlyphs(HandleMissingGlyphs)
                , mPathParameterTemplate(PathParameterTemplate)
                , mEmScale(EmScale) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mFirstPathName;
        uint32_t mFontTarget;
        Void__CP mFontName;
        uint32_t mFontStyle;
        int32_t mNumGlyphs;
        uint32_t mType;
        Void__CP mCharcodes;
        uint32_t mHandleMissingGlyphs;
        uint32_t mPathParameterTemplate;
        float mEmScale;
    };

    class GlPathMemoryGlyphIndexArrayNV: public Encodable {
    public:
        GlPathMemoryGlyphIndexArrayNV() = default;
        GlPathMemoryGlyphIndexArrayNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t FirstPathName, uint32_t FontTarget, int32_t FontSize, Void__CP FontData, int32_t FaceIndex, uint32_t FirstGlyphIndex, int32_t NumGlyphs, uint32_t PathParameterTemplate, float EmScale, uint32_t Result)
                : mextras(extras)
                , mFirstPathName(FirstPathName)
                , mFontTarget(FontTarget)
                , mFontSize(FontSize)
                , mFontData(FontData)
                , mFaceIndex(FaceIndex)
                , mFirstGlyphIndex(FirstGlyphIndex)
                , mNumGlyphs(NumGlyphs)
                , mPathParameterTemplate(PathParameterTemplate)
                , mEmScale(EmScale)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mFirstPathName;
        uint32_t mFontTarget;
        int32_t mFontSize;
        Void__CP mFontData;
        int32_t mFaceIndex;
        uint32_t mFirstGlyphIndex;
        int32_t mNumGlyphs;
        uint32_t mPathParameterTemplate;
        float mEmScale;
        uint32_t mResult;
    };

    class GlPathParameterfNV: public Encodable {
    public:
        GlPathParameterfNV() = default;
        GlPathParameterfNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Path, uint32_t Pname, float Value)
                : mextras(extras)
                , mPath(Path)
                , mPname(Pname)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPath;
        uint32_t mPname;
        float mValue;
    };

    class GlPathParameterfvNV: public Encodable {
    public:
        GlPathParameterfvNV() = default;
        GlPathParameterfvNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Path, uint32_t Pname, GLfloat__CP Value)
                : mextras(extras)
                , mPath(Path)
                , mPname(Pname)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPath;
        uint32_t mPname;
        GLfloat__CP mValue;
    };

    class GlPathParameteriNV: public Encodable {
    public:
        GlPathParameteriNV() = default;
        GlPathParameteriNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Path, uint32_t Pname, int32_t Value)
                : mextras(extras)
                , mPath(Path)
                , mPname(Pname)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPath;
        uint32_t mPname;
        int32_t mValue;
    };

    class GlPathParameterivNV: public Encodable {
    public:
        GlPathParameterivNV() = default;
        GlPathParameterivNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Path, uint32_t Pname, GLint__CP Value)
                : mextras(extras)
                , mPath(Path)
                , mPname(Pname)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPath;
        uint32_t mPname;
        GLint__CP mValue;
    };

    class GlPathStencilDepthOffsetNV: public Encodable {
    public:
        GlPathStencilDepthOffsetNV() = default;
        GlPathStencilDepthOffsetNV(const gapic::Vector<gapic::Encodable*>& extras, float Factor, float Units)
                : mextras(extras)
                , mFactor(Factor)
                , mUnits(Units) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Float32(this->mFactor);
            e->Float32(this->mUnits);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        float mFactor;
        float mUnits;
    };

    class GlPathStencilFuncNV: public Encodable {
    public:
        GlPathStencilFuncNV() = default;
        GlPathStencilFuncNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Func, int32_t Ref, uint32_t Mask)
                : mextras(extras)
                , mFunc(Func)
                , mRef(Ref)
                , mMask(Mask) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mFunc;
        int32_t mRef;
        uint32_t mMask;
    };

    class GlPathStringNV: public Encodable {
    public:
        GlPathStringNV() = default;
        GlPathStringNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Path, uint32_t Format, int32_t Length, Void__CP PathString)
                : mextras(extras)
                , mPath(Path)
                , mFormat(Format)
                , mLength(Length)
                , mPathString(PathString) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPath;
        uint32_t mFormat;
        int32_t mLength;
        Void__CP mPathString;
    };

    class GlPathSubCommandsNV: public Encodable {
    public:
        GlPathSubCommandsNV() = default;
        GlPathSubCommandsNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Path, int32_t CommandStart, int32_t CommandsToDelete, int32_t NumCommands, GLubyte__CP Commands, int32_t NumCoords, uint32_t CoordType, Void__CP Coords)
                : mextras(extras)
                , mPath(Path)
                , mCommandStart(CommandStart)
                , mCommandsToDelete(CommandsToDelete)
                , mNumCommands(NumCommands)
                , mCommands(Commands)
                , mNumCoords(NumCoords)
                , mCoordType(CoordType)
                , mCoords(Coords) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPath;
        int32_t mCommandStart;
        int32_t mCommandsToDelete;
        int32_t mNumCommands;
        GLubyte__CP mCommands;
        int32_t mNumCoords;
        uint32_t mCoordType;
        Void__CP mCoords;
    };

    class GlPathSubCoordsNV: public Encodable {
    public:
        GlPathSubCoordsNV() = default;
        GlPathSubCoordsNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Path, int32_t CoordStart, int32_t NumCoords, uint32_t CoordType, Void__CP Coords)
                : mextras(extras)
                , mPath(Path)
                , mCoordStart(CoordStart)
                , mNumCoords(NumCoords)
                , mCoordType(CoordType)
                , mCoords(Coords) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPath;
        int32_t mCoordStart;
        int32_t mNumCoords;
        uint32_t mCoordType;
        Void__CP mCoords;
    };

    class GlPauseTransformFeedback: public Encodable {
    public:
        GlPauseTransformFeedback() = default;
        GlPauseTransformFeedback(const gapic::Vector<gapic::Encodable*>& extras)
                : mextras(extras) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
    };

    class GlPixelStorei: public Encodable {
    public:
        GlPixelStorei() = default;
        GlPixelStorei(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Parameter, int32_t Value)
                : mextras(extras)
                , mParameter(Parameter)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mParameter);
            e->Int32(this->mValue);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mParameter;
        int32_t mValue;
    };

    class GlPointAlongPathNV: public Encodable {
    public:
        GlPointAlongPathNV() = default;
        GlPointAlongPathNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Path, int32_t StartSegment, int32_t NumSegments, float Distance, GLfloat__P X, GLfloat__P Y, GLfloat__P TangentX, GLfloat__P TangentY, uint8_t Result)
                : mextras(extras)
                , mPath(Path)
                , mStartSegment(StartSegment)
                , mNumSegments(NumSegments)
                , mDistance(Distance)
                , mX(X)
                , mY(Y)
                , mTangentX(TangentX)
                , mTangentY(TangentY)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPath;
        int32_t mStartSegment;
        int32_t mNumSegments;
        float mDistance;
        GLfloat__P mX;
        GLfloat__P mY;
        GLfloat__P mTangentX;
        GLfloat__P mTangentY;
        uint8_t mResult;
    };

    class GlPointParameterf: public Encodable {
    public:
        GlPointParameterf() = default;
        GlPointParameterf(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Pname, float Param)
                : mextras(extras)
                , mPname(Pname)
                , mParam(Param) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mPname);
            e->Float32(this->mParam);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPname;
        float mParam;
    };

    class GlPointParameterfv: public Encodable {
    public:
        GlPointParameterfv() = default;
        GlPointParameterfv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Pname, GLfloat__CP Params)
                : mextras(extras)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mPname);
            e->Struct(this->mParams);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPname;
        GLfloat__CP mParams;
    };

    class GlPointParameterx: public Encodable {
    public:
        GlPointParameterx() = default;
        GlPointParameterx(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Pname, int32_t Param)
                : mextras(extras)
                , mPname(Pname)
                , mParam(Param) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mPname);
            e->Int32(this->mParam);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPname;
        int32_t mParam;
    };

    class GlPointParameterxOES: public Encodable {
    public:
        GlPointParameterxOES() = default;
        GlPointParameterxOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Pname, int32_t Param)
                : mextras(extras)
                , mPname(Pname)
                , mParam(Param) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mPname);
            e->Int32(this->mParam);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPname;
        int32_t mParam;
    };

    class GlPointParameterxv: public Encodable {
    public:
        GlPointParameterxv() = default;
        GlPointParameterxv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Pname, GLfixed__CP Params)
                : mextras(extras)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mPname);
            e->Struct(this->mParams);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPname;
        GLfixed__CP mParams;
    };

    class GlPointParameterxvOES: public Encodable {
    public:
        GlPointParameterxvOES() = default;
        GlPointParameterxvOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Pname, GLfixed__CP Params)
                : mextras(extras)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mPname);
            e->Struct(this->mParams);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPname;
        GLfixed__CP mParams;
    };

    class GlPointSize: public Encodable {
    public:
        GlPointSize() = default;
        GlPointSize(const gapic::Vector<gapic::Encodable*>& extras, float Size)
                : mextras(extras)
                , mSize(Size) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Float32(this->mSize);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        float mSize;
    };

    class GlPointSizePointerOES: public Encodable {
    public:
        GlPointSizePointerOES() = default;
        GlPointSizePointerOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Type, int32_t Stride, Void__CP Pointer)
                : mextras(extras)
                , mType(Type)
                , mStride(Stride)
                , mPointer(Pointer) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mType;
        int32_t mStride;
        Void__CP mPointer;
    };

    class GlPointSizePointerOESBounds: public Encodable {
    public:
        GlPointSizePointerOESBounds() = default;
        GlPointSizePointerOESBounds(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Type, int32_t Stride, Void__CP Pointer, int32_t Count)
                : mextras(extras)
                , mType(Type)
                , mStride(Stride)
                , mPointer(Pointer)
                , mCount(Count) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mType;
        int32_t mStride;
        Void__CP mPointer;
        int32_t mCount;
    };

    class GlPointSizex: public Encodable {
    public:
        GlPointSizex() = default;
        GlPointSizex(const gapic::Vector<gapic::Encodable*>& extras, int32_t Size)
                : mextras(extras)
                , mSize(Size) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int32(this->mSize);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mSize;
    };

    class GlPointSizexOES: public Encodable {
    public:
        GlPointSizexOES() = default;
        GlPointSizexOES(const gapic::Vector<gapic::Encodable*>& extras, int32_t Size)
                : mextras(extras)
                , mSize(Size) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int32(this->mSize);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mSize;
    };

    class GlPolygonModeNV: public Encodable {
    public:
        GlPolygonModeNV() = default;
        GlPolygonModeNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Face, uint32_t Mode)
                : mextras(extras)
                , mFace(Face)
                , mMode(Mode) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mFace);
            e->Uint32(this->mMode);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mFace;
        uint32_t mMode;
    };

    class GlPolygonOffset: public Encodable {
    public:
        GlPolygonOffset() = default;
        GlPolygonOffset(const gapic::Vector<gapic::Encodable*>& extras, float ScaleFactor, float Units)
                : mextras(extras)
                , mScaleFactor(ScaleFactor)
                , mUnits(Units) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Float32(this->mScaleFactor);
            e->Float32(this->mUnits);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        float mScaleFactor;
        float mUnits;
    };

    class GlPolygonOffsetx: public Encodable {
    public:
        GlPolygonOffsetx() = default;
        GlPolygonOffsetx(const gapic::Vector<gapic::Encodable*>& extras, int32_t Factor, int32_t Units)
                : mextras(extras)
                , mFactor(Factor)
                , mUnits(Units) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int32(this->mFactor);
            e->Int32(this->mUnits);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mFactor;
        int32_t mUnits;
    };

    class GlPolygonOffsetxOES: public Encodable {
    public:
        GlPolygonOffsetxOES() = default;
        GlPolygonOffsetxOES(const gapic::Vector<gapic::Encodable*>& extras, int32_t Factor, int32_t Units)
                : mextras(extras)
                , mFactor(Factor)
                , mUnits(Units) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int32(this->mFactor);
            e->Int32(this->mUnits);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mFactor;
        int32_t mUnits;
    };

    class GlPopDebugGroup: public Encodable {
    public:
        GlPopDebugGroup() = default;
        GlPopDebugGroup(const gapic::Vector<gapic::Encodable*>& extras)
                : mextras(extras) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
    };

    class GlPopDebugGroupKHR: public Encodable {
    public:
        GlPopDebugGroupKHR() = default;
        GlPopDebugGroupKHR(const gapic::Vector<gapic::Encodable*>& extras)
                : mextras(extras) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
    };

    class GlPopGroupMarkerEXT: public Encodable {
    public:
        GlPopGroupMarkerEXT() = default;
        GlPopGroupMarkerEXT(const gapic::Vector<gapic::Encodable*>& extras)
                : mextras(extras) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
    };

    class GlPopMatrix: public Encodable {
    public:
        GlPopMatrix() = default;
        GlPopMatrix(const gapic::Vector<gapic::Encodable*>& extras)
                : mextras(extras) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
    };

    class GlPrimitiveBoundingBox: public Encodable {
    public:
        GlPrimitiveBoundingBox() = default;
        GlPrimitiveBoundingBox(const gapic::Vector<gapic::Encodable*>& extras, float MinX, float MinY, float MinZ, float MinW, float MaxX, float MaxY, float MaxZ, float MaxW)
                : mextras(extras)
                , mMinX(MinX)
                , mMinY(MinY)
                , mMinZ(MinZ)
                , mMinW(MinW)
                , mMaxX(MaxX)
                , mMaxY(MaxY)
                , mMaxZ(MaxZ)
                , mMaxW(MaxW) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        float mMinX;
        float mMinY;
        float mMinZ;
        float mMinW;
        float mMaxX;
        float mMaxY;
        float mMaxZ;
        float mMaxW;
    };

    class GlPrimitiveBoundingBoxEXT: public Encodable {
    public:
        GlPrimitiveBoundingBoxEXT() = default;
        GlPrimitiveBoundingBoxEXT(const gapic::Vector<gapic::Encodable*>& extras, float MinX, float MinY, float MinZ, float MinW, float MaxX, float MaxY, float MaxZ, float MaxW)
                : mextras(extras)
                , mMinX(MinX)
                , mMinY(MinY)
                , mMinZ(MinZ)
                , mMinW(MinW)
                , mMaxX(MaxX)
                , mMaxY(MaxY)
                , mMaxZ(MaxZ)
                , mMaxW(MaxW) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        float mMinX;
        float mMinY;
        float mMinZ;
        float mMinW;
        float mMaxX;
        float mMaxY;
        float mMaxZ;
        float mMaxW;
    };

    class GlPrimitiveBoundingBoxOES: public Encodable {
    public:
        GlPrimitiveBoundingBoxOES() = default;
        GlPrimitiveBoundingBoxOES(const gapic::Vector<gapic::Encodable*>& extras, float MinX, float MinY, float MinZ, float MinW, float MaxX, float MaxY, float MaxZ, float MaxW)
                : mextras(extras)
                , mMinX(MinX)
                , mMinY(MinY)
                , mMinZ(MinZ)
                , mMinW(MinW)
                , mMaxX(MaxX)
                , mMaxY(MaxY)
                , mMaxZ(MaxZ)
                , mMaxW(MaxW) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        float mMinX;
        float mMinY;
        float mMinZ;
        float mMinW;
        float mMaxX;
        float mMaxY;
        float mMaxZ;
        float mMaxW;
    };

    class GlProgramBinary: public Encodable {
    public:
        GlProgramBinary() = default;
        GlProgramBinary(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, uint32_t BinaryFormat, Void__CP Binary, int32_t Length)
                : mextras(extras)
                , mProgram(Program)
                , mBinaryFormat(BinaryFormat)
                , mBinary(Binary)
                , mLength(Length) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        uint32_t mBinaryFormat;
        Void__CP mBinary;
        int32_t mLength;
    };

    class GlProgramBinaryOES: public Encodable {
    public:
        GlProgramBinaryOES() = default;
        GlProgramBinaryOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, uint32_t BinaryFormat, Void__CP Binary, int32_t BinarySize)
                : mextras(extras)
                , mProgram(Program)
                , mBinaryFormat(BinaryFormat)
                , mBinary(Binary)
                , mBinarySize(BinarySize) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        uint32_t mBinaryFormat;
        Void__CP mBinary;
        int32_t mBinarySize;
    };

    class GlProgramParameteri: public Encodable {
    public:
        GlProgramParameteri() = default;
        GlProgramParameteri(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, uint32_t Pname, int32_t Value)
                : mextras(extras)
                , mProgram(Program)
                , mPname(Pname)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        uint32_t mPname;
        int32_t mValue;
    };

    class GlProgramParameteriEXT: public Encodable {
    public:
        GlProgramParameteriEXT() = default;
        GlProgramParameteriEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, uint32_t Pname, int32_t Value)
                : mextras(extras)
                , mProgram(Program)
                , mPname(Pname)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        uint32_t mPname;
        int32_t mValue;
    };

    class GlProgramPathFragmentInputGenNV: public Encodable {
    public:
        GlProgramPathFragmentInputGenNV() = default;
        GlProgramPathFragmentInputGenNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, uint32_t GenMode, int32_t Components, GLfloat__CP Coeffs)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mGenMode(GenMode)
                , mComponents(Components)
                , mCoeffs(Coeffs) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        uint32_t mGenMode;
        int32_t mComponents;
        GLfloat__CP mCoeffs;
    };

    class GlProgramUniform1f: public Encodable {
    public:
        GlProgramUniform1f() = default;
        GlProgramUniform1f(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, float Value0)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mValue0(Value0) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        float mValue0;
    };

    class GlProgramUniform1fEXT: public Encodable {
    public:
        GlProgramUniform1fEXT() = default;
        GlProgramUniform1fEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, float V0)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mV0(V0) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        float mV0;
    };

    class GlProgramUniform1fv: public Encodable {
    public:
        GlProgramUniform1fv() = default;
        GlProgramUniform1fv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, int32_t Count, GLfloat__CP Values)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mCount(Count)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        int32_t mCount;
        GLfloat__CP mValues;
    };

    class GlProgramUniform1fvEXT: public Encodable {
    public:
        GlProgramUniform1fvEXT() = default;
        GlProgramUniform1fvEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, int32_t Count, GLfloat__CP Value)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mCount(Count)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        int32_t mCount;
        GLfloat__CP mValue;
    };

    class GlProgramUniform1i: public Encodable {
    public:
        GlProgramUniform1i() = default;
        GlProgramUniform1i(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, int32_t Value0)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mValue0(Value0) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        int32_t mValue0;
    };

    class GlProgramUniform1iEXT: public Encodable {
    public:
        GlProgramUniform1iEXT() = default;
        GlProgramUniform1iEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, int32_t V0)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mV0(V0) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        int32_t mV0;
    };

    class GlProgramUniform1iv: public Encodable {
    public:
        GlProgramUniform1iv() = default;
        GlProgramUniform1iv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, int32_t Count, GLint__CP Values)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mCount(Count)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        int32_t mCount;
        GLint__CP mValues;
    };

    class GlProgramUniform1ivEXT: public Encodable {
    public:
        GlProgramUniform1ivEXT() = default;
        GlProgramUniform1ivEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, int32_t Count, GLint__CP Value)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mCount(Count)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        int32_t mCount;
        GLint__CP mValue;
    };

    class GlProgramUniform1ui: public Encodable {
    public:
        GlProgramUniform1ui() = default;
        GlProgramUniform1ui(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, uint32_t Value0)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mValue0(Value0) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        uint32_t mValue0;
    };

    class GlProgramUniform1uiEXT: public Encodable {
    public:
        GlProgramUniform1uiEXT() = default;
        GlProgramUniform1uiEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, uint32_t V0)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mV0(V0) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        uint32_t mV0;
    };

    class GlProgramUniform1uiv: public Encodable {
    public:
        GlProgramUniform1uiv() = default;
        GlProgramUniform1uiv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, int32_t Count, GLuint__CP Values)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mCount(Count)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        int32_t mCount;
        GLuint__CP mValues;
    };

    class GlProgramUniform1uivEXT: public Encodable {
    public:
        GlProgramUniform1uivEXT() = default;
        GlProgramUniform1uivEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, int32_t Count, GLuint__CP Value)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mCount(Count)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        int32_t mCount;
        GLuint__CP mValue;
    };

    class GlProgramUniform2f: public Encodable {
    public:
        GlProgramUniform2f() = default;
        GlProgramUniform2f(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, float Value0, float Value1)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mValue0(Value0)
                , mValue1(Value1) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        float mValue0;
        float mValue1;
    };

    class GlProgramUniform2fEXT: public Encodable {
    public:
        GlProgramUniform2fEXT() = default;
        GlProgramUniform2fEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, float V0, float V1)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mV0(V0)
                , mV1(V1) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        float mV0;
        float mV1;
    };

    class GlProgramUniform2fv: public Encodable {
    public:
        GlProgramUniform2fv() = default;
        GlProgramUniform2fv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, int32_t Count, GLfloat__CP Values)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mCount(Count)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        int32_t mCount;
        GLfloat__CP mValues;
    };

    class GlProgramUniform2fvEXT: public Encodable {
    public:
        GlProgramUniform2fvEXT() = default;
        GlProgramUniform2fvEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, int32_t Count, GLfloat__CP Value)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mCount(Count)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        int32_t mCount;
        GLfloat__CP mValue;
    };

    class GlProgramUniform2i: public Encodable {
    public:
        GlProgramUniform2i() = default;
        GlProgramUniform2i(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, int32_t Value0, int32_t Value1)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mValue0(Value0)
                , mValue1(Value1) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        int32_t mValue0;
        int32_t mValue1;
    };

    class GlProgramUniform2iEXT: public Encodable {
    public:
        GlProgramUniform2iEXT() = default;
        GlProgramUniform2iEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, int32_t V0, int32_t V1)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mV0(V0)
                , mV1(V1) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        int32_t mV0;
        int32_t mV1;
    };

    class GlProgramUniform2iv: public Encodable {
    public:
        GlProgramUniform2iv() = default;
        GlProgramUniform2iv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, int32_t Count, GLint__CP Values)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mCount(Count)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        int32_t mCount;
        GLint__CP mValues;
    };

    class GlProgramUniform2ivEXT: public Encodable {
    public:
        GlProgramUniform2ivEXT() = default;
        GlProgramUniform2ivEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, int32_t Count, GLint__CP Value)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mCount(Count)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        int32_t mCount;
        GLint__CP mValue;
    };

    class GlProgramUniform2ui: public Encodable {
    public:
        GlProgramUniform2ui() = default;
        GlProgramUniform2ui(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, uint32_t Value0, uint32_t Value1)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mValue0(Value0)
                , mValue1(Value1) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        uint32_t mValue0;
        uint32_t mValue1;
    };

    class GlProgramUniform2uiEXT: public Encodable {
    public:
        GlProgramUniform2uiEXT() = default;
        GlProgramUniform2uiEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, uint32_t V0, uint32_t V1)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mV0(V0)
                , mV1(V1) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        uint32_t mV0;
        uint32_t mV1;
    };

    class GlProgramUniform2uiv: public Encodable {
    public:
        GlProgramUniform2uiv() = default;
        GlProgramUniform2uiv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, int32_t Count, GLuint__CP Values)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mCount(Count)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        int32_t mCount;
        GLuint__CP mValues;
    };

    class GlProgramUniform2uivEXT: public Encodable {
    public:
        GlProgramUniform2uivEXT() = default;
        GlProgramUniform2uivEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, int32_t Count, GLuint__CP Value)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mCount(Count)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        int32_t mCount;
        GLuint__CP mValue;
    };

    class GlProgramUniform3f: public Encodable {
    public:
        GlProgramUniform3f() = default;
        GlProgramUniform3f(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, float Value0, float Value1, float Value2)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mValue0(Value0)
                , mValue1(Value1)
                , mValue2(Value2) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        float mValue0;
        float mValue1;
        float mValue2;
    };

    class GlProgramUniform3fEXT: public Encodable {
    public:
        GlProgramUniform3fEXT() = default;
        GlProgramUniform3fEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, float V0, float V1, float V2)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mV0(V0)
                , mV1(V1)
                , mV2(V2) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        float mV0;
        float mV1;
        float mV2;
    };

    class GlProgramUniform3fv: public Encodable {
    public:
        GlProgramUniform3fv() = default;
        GlProgramUniform3fv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, int32_t Count, GLfloat__CP Values)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mCount(Count)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        int32_t mCount;
        GLfloat__CP mValues;
    };

    class GlProgramUniform3fvEXT: public Encodable {
    public:
        GlProgramUniform3fvEXT() = default;
        GlProgramUniform3fvEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, int32_t Count, GLfloat__CP Value)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mCount(Count)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        int32_t mCount;
        GLfloat__CP mValue;
    };

    class GlProgramUniform3i: public Encodable {
    public:
        GlProgramUniform3i() = default;
        GlProgramUniform3i(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, int32_t Value0, int32_t Value1, int32_t Value2)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mValue0(Value0)
                , mValue1(Value1)
                , mValue2(Value2) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        int32_t mValue0;
        int32_t mValue1;
        int32_t mValue2;
    };

    class GlProgramUniform3iEXT: public Encodable {
    public:
        GlProgramUniform3iEXT() = default;
        GlProgramUniform3iEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, int32_t V0, int32_t V1, int32_t V2)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mV0(V0)
                , mV1(V1)
                , mV2(V2) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        int32_t mV0;
        int32_t mV1;
        int32_t mV2;
    };

    class GlProgramUniform3iv: public Encodable {
    public:
        GlProgramUniform3iv() = default;
        GlProgramUniform3iv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, int32_t Count, GLint__CP Values)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mCount(Count)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        int32_t mCount;
        GLint__CP mValues;
    };

    class GlProgramUniform3ivEXT: public Encodable {
    public:
        GlProgramUniform3ivEXT() = default;
        GlProgramUniform3ivEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, int32_t Count, GLint__CP Value)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mCount(Count)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        int32_t mCount;
        GLint__CP mValue;
    };

    class GlProgramUniform3ui: public Encodable {
    public:
        GlProgramUniform3ui() = default;
        GlProgramUniform3ui(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, uint32_t Value0, uint32_t Value1, uint32_t Value2)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mValue0(Value0)
                , mValue1(Value1)
                , mValue2(Value2) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        uint32_t mValue0;
        uint32_t mValue1;
        uint32_t mValue2;
    };

    class GlProgramUniform3uiEXT: public Encodable {
    public:
        GlProgramUniform3uiEXT() = default;
        GlProgramUniform3uiEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, uint32_t V0, uint32_t V1, uint32_t V2)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mV0(V0)
                , mV1(V1)
                , mV2(V2) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        uint32_t mV0;
        uint32_t mV1;
        uint32_t mV2;
    };

    class GlProgramUniform3uiv: public Encodable {
    public:
        GlProgramUniform3uiv() = default;
        GlProgramUniform3uiv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, int32_t Count, GLuint__CP Values)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mCount(Count)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        int32_t mCount;
        GLuint__CP mValues;
    };

    class GlProgramUniform3uivEXT: public Encodable {
    public:
        GlProgramUniform3uivEXT() = default;
        GlProgramUniform3uivEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, int32_t Count, GLuint__CP Value)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mCount(Count)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        int32_t mCount;
        GLuint__CP mValue;
    };

    class GlProgramUniform4f: public Encodable {
    public:
        GlProgramUniform4f() = default;
        GlProgramUniform4f(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, float Value0, float Value1, float Value2, float Value3)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mValue0(Value0)
                , mValue1(Value1)
                , mValue2(Value2)
                , mValue3(Value3) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        float mValue0;
        float mValue1;
        float mValue2;
        float mValue3;
    };

    class GlProgramUniform4fEXT: public Encodable {
    public:
        GlProgramUniform4fEXT() = default;
        GlProgramUniform4fEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, float V0, float V1, float V2, float V3)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mV0(V0)
                , mV1(V1)
                , mV2(V2)
                , mV3(V3) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        float mV0;
        float mV1;
        float mV2;
        float mV3;
    };

    class GlProgramUniform4fv: public Encodable {
    public:
        GlProgramUniform4fv() = default;
        GlProgramUniform4fv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, int32_t Count, GLfloat__CP Values)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mCount(Count)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        int32_t mCount;
        GLfloat__CP mValues;
    };

    class GlProgramUniform4fvEXT: public Encodable {
    public:
        GlProgramUniform4fvEXT() = default;
        GlProgramUniform4fvEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, int32_t Count, GLfloat__CP Value)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mCount(Count)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        int32_t mCount;
        GLfloat__CP mValue;
    };

    class GlProgramUniform4i: public Encodable {
    public:
        GlProgramUniform4i() = default;
        GlProgramUniform4i(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, int32_t Value0, int32_t Value1, int32_t Value2, int32_t Value3)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mValue0(Value0)
                , mValue1(Value1)
                , mValue2(Value2)
                , mValue3(Value3) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        int32_t mValue0;
        int32_t mValue1;
        int32_t mValue2;
        int32_t mValue3;
    };

    class GlProgramUniform4iEXT: public Encodable {
    public:
        GlProgramUniform4iEXT() = default;
        GlProgramUniform4iEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, int32_t V0, int32_t V1, int32_t V2, int32_t V3)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mV0(V0)
                , mV1(V1)
                , mV2(V2)
                , mV3(V3) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        int32_t mV0;
        int32_t mV1;
        int32_t mV2;
        int32_t mV3;
    };

    class GlProgramUniform4iv: public Encodable {
    public:
        GlProgramUniform4iv() = default;
        GlProgramUniform4iv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, int32_t Count, GLint__CP Values)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mCount(Count)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        int32_t mCount;
        GLint__CP mValues;
    };

    class GlProgramUniform4ivEXT: public Encodable {
    public:
        GlProgramUniform4ivEXT() = default;
        GlProgramUniform4ivEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, int32_t Count, GLint__CP Value)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mCount(Count)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        int32_t mCount;
        GLint__CP mValue;
    };

    class GlProgramUniform4ui: public Encodable {
    public:
        GlProgramUniform4ui() = default;
        GlProgramUniform4ui(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, uint32_t Value0, uint32_t Value1, uint32_t Value2, uint32_t Value3)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mValue0(Value0)
                , mValue1(Value1)
                , mValue2(Value2)
                , mValue3(Value3) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        uint32_t mValue0;
        uint32_t mValue1;
        uint32_t mValue2;
        uint32_t mValue3;
    };

    class GlProgramUniform4uiEXT: public Encodable {
    public:
        GlProgramUniform4uiEXT() = default;
        GlProgramUniform4uiEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, uint32_t V0, uint32_t V1, uint32_t V2, uint32_t V3)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mV0(V0)
                , mV1(V1)
                , mV2(V2)
                , mV3(V3) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        uint32_t mV0;
        uint32_t mV1;
        uint32_t mV2;
        uint32_t mV3;
    };

    class GlProgramUniform4uiv: public Encodable {
    public:
        GlProgramUniform4uiv() = default;
        GlProgramUniform4uiv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, int32_t Count, GLuint__CP Values)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mCount(Count)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        int32_t mCount;
        GLuint__CP mValues;
    };

    class GlProgramUniform4uivEXT: public Encodable {
    public:
        GlProgramUniform4uivEXT() = default;
        GlProgramUniform4uivEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, int32_t Count, GLuint__CP Value)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mCount(Count)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        int32_t mCount;
        GLuint__CP mValue;
    };

    class GlProgramUniformHandleui64NV: public Encodable {
    public:
        GlProgramUniformHandleui64NV() = default;
        GlProgramUniformHandleui64NV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, uint64_t Value)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        uint64_t mValue;
    };

    class GlProgramUniformHandleui64vNV: public Encodable {
    public:
        GlProgramUniformHandleui64vNV() = default;
        GlProgramUniformHandleui64vNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, int32_t Count, GLuint64__CP Values)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mCount(Count)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        int32_t mCount;
        GLuint64__CP mValues;
    };

    class GlProgramUniformMatrix2fv: public Encodable {
    public:
        GlProgramUniformMatrix2fv() = default;
        GlProgramUniformMatrix2fv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, int32_t Count, uint8_t Transpose, GLfloat__CP Values)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mCount(Count)
                , mTranspose(Transpose)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        int32_t mCount;
        uint8_t mTranspose;
        GLfloat__CP mValues;
    };

    class GlProgramUniformMatrix2fvEXT: public Encodable {
    public:
        GlProgramUniformMatrix2fvEXT() = default;
        GlProgramUniformMatrix2fvEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, int32_t Count, uint8_t Transpose, GLfloat__CP Value)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mCount(Count)
                , mTranspose(Transpose)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        int32_t mCount;
        uint8_t mTranspose;
        GLfloat__CP mValue;
    };

    class GlProgramUniformMatrix2x3fv: public Encodable {
    public:
        GlProgramUniformMatrix2x3fv() = default;
        GlProgramUniformMatrix2x3fv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, int32_t Count, uint8_t Transpose, GLfloat__CP Values)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mCount(Count)
                , mTranspose(Transpose)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        int32_t mCount;
        uint8_t mTranspose;
        GLfloat__CP mValues;
    };

    class GlProgramUniformMatrix2x3fvEXT: public Encodable {
    public:
        GlProgramUniformMatrix2x3fvEXT() = default;
        GlProgramUniformMatrix2x3fvEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, int32_t Count, uint8_t Transpose, GLfloat__CP Value)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mCount(Count)
                , mTranspose(Transpose)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        int32_t mCount;
        uint8_t mTranspose;
        GLfloat__CP mValue;
    };

    class GlProgramUniformMatrix2x4fv: public Encodable {
    public:
        GlProgramUniformMatrix2x4fv() = default;
        GlProgramUniformMatrix2x4fv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, int32_t Count, uint8_t Transpose, GLfloat__CP Values)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mCount(Count)
                , mTranspose(Transpose)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        int32_t mCount;
        uint8_t mTranspose;
        GLfloat__CP mValues;
    };

    class GlProgramUniformMatrix2x4fvEXT: public Encodable {
    public:
        GlProgramUniformMatrix2x4fvEXT() = default;
        GlProgramUniformMatrix2x4fvEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, int32_t Count, uint8_t Transpose, GLfloat__CP Value)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mCount(Count)
                , mTranspose(Transpose)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        int32_t mCount;
        uint8_t mTranspose;
        GLfloat__CP mValue;
    };

    class GlProgramUniformMatrix3fv: public Encodable {
    public:
        GlProgramUniformMatrix3fv() = default;
        GlProgramUniformMatrix3fv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, int32_t Count, uint8_t Transpose, GLfloat__CP Values)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mCount(Count)
                , mTranspose(Transpose)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        int32_t mCount;
        uint8_t mTranspose;
        GLfloat__CP mValues;
    };

    class GlProgramUniformMatrix3fvEXT: public Encodable {
    public:
        GlProgramUniformMatrix3fvEXT() = default;
        GlProgramUniformMatrix3fvEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, int32_t Count, uint8_t Transpose, GLfloat__CP Value)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mCount(Count)
                , mTranspose(Transpose)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        int32_t mCount;
        uint8_t mTranspose;
        GLfloat__CP mValue;
    };

    class GlProgramUniformMatrix3x2fv: public Encodable {
    public:
        GlProgramUniformMatrix3x2fv() = default;
        GlProgramUniformMatrix3x2fv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, int32_t Count, uint8_t Transpose, GLfloat__CP Values)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mCount(Count)
                , mTranspose(Transpose)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        int32_t mCount;
        uint8_t mTranspose;
        GLfloat__CP mValues;
    };

    class GlProgramUniformMatrix3x2fvEXT: public Encodable {
    public:
        GlProgramUniformMatrix3x2fvEXT() = default;
        GlProgramUniformMatrix3x2fvEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, int32_t Count, uint8_t Transpose, GLfloat__CP Value)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mCount(Count)
                , mTranspose(Transpose)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        int32_t mCount;
        uint8_t mTranspose;
        GLfloat__CP mValue;
    };

    class GlProgramUniformMatrix3x4fv: public Encodable {
    public:
        GlProgramUniformMatrix3x4fv() = default;
        GlProgramUniformMatrix3x4fv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, int32_t Count, uint8_t Transpose, GLfloat__CP Values)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mCount(Count)
                , mTranspose(Transpose)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        int32_t mCount;
        uint8_t mTranspose;
        GLfloat__CP mValues;
    };

    class GlProgramUniformMatrix3x4fvEXT: public Encodable {
    public:
        GlProgramUniformMatrix3x4fvEXT() = default;
        GlProgramUniformMatrix3x4fvEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, int32_t Count, uint8_t Transpose, GLfloat__CP Value)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mCount(Count)
                , mTranspose(Transpose)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        int32_t mCount;
        uint8_t mTranspose;
        GLfloat__CP mValue;
    };

    class GlProgramUniformMatrix4fv: public Encodable {
    public:
        GlProgramUniformMatrix4fv() = default;
        GlProgramUniformMatrix4fv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, int32_t Count, uint8_t Transpose, GLfloat__CP Values)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mCount(Count)
                , mTranspose(Transpose)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        int32_t mCount;
        uint8_t mTranspose;
        GLfloat__CP mValues;
    };

    class GlProgramUniformMatrix4fvEXT: public Encodable {
    public:
        GlProgramUniformMatrix4fvEXT() = default;
        GlProgramUniformMatrix4fvEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, int32_t Count, uint8_t Transpose, GLfloat__CP Value)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mCount(Count)
                , mTranspose(Transpose)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        int32_t mCount;
        uint8_t mTranspose;
        GLfloat__CP mValue;
    };

    class GlProgramUniformMatrix4x2fv: public Encodable {
    public:
        GlProgramUniformMatrix4x2fv() = default;
        GlProgramUniformMatrix4x2fv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, int32_t Count, uint8_t Transpose, GLfloat__CP Values)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mCount(Count)
                , mTranspose(Transpose)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        int32_t mCount;
        uint8_t mTranspose;
        GLfloat__CP mValues;
    };

    class GlProgramUniformMatrix4x2fvEXT: public Encodable {
    public:
        GlProgramUniformMatrix4x2fvEXT() = default;
        GlProgramUniformMatrix4x2fvEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, int32_t Count, uint8_t Transpose, GLfloat__CP Value)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mCount(Count)
                , mTranspose(Transpose)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        int32_t mCount;
        uint8_t mTranspose;
        GLfloat__CP mValue;
    };

    class GlProgramUniformMatrix4x3fv: public Encodable {
    public:
        GlProgramUniformMatrix4x3fv() = default;
        GlProgramUniformMatrix4x3fv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, int32_t Count, uint8_t Transpose, GLfloat__CP Values)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mCount(Count)
                , mTranspose(Transpose)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        int32_t mCount;
        uint8_t mTranspose;
        GLfloat__CP mValues;
    };

    class GlProgramUniformMatrix4x3fvEXT: public Encodable {
    public:
        GlProgramUniformMatrix4x3fvEXT() = default;
        GlProgramUniformMatrix4x3fvEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Location, int32_t Count, uint8_t Transpose, GLfloat__CP Value)
                : mextras(extras)
                , mProgram(Program)
                , mLocation(Location)
                , mCount(Count)
                , mTranspose(Transpose)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mLocation;
        int32_t mCount;
        uint8_t mTranspose;
        GLfloat__CP mValue;
    };

    class GlPushDebugGroup: public Encodable {
    public:
        GlPushDebugGroup() = default;
        GlPushDebugGroup(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Source, uint32_t Id, int32_t Length, GLchar__CP Message)
                : mextras(extras)
                , mSource(Source)
                , mId(Id)
                , mLength(Length)
                , mMessage(Message) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mSource;
        uint32_t mId;
        int32_t mLength;
        GLchar__CP mMessage;
    };

    class GlPushDebugGroupKHR: public Encodable {
    public:
        GlPushDebugGroupKHR() = default;
        GlPushDebugGroupKHR(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Source, uint32_t Id, int32_t Length, GLchar__CP Message)
                : mextras(extras)
                , mSource(Source)
                , mId(Id)
                , mLength(Length)
                , mMessage(Message) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mSource;
        uint32_t mId;
        int32_t mLength;
        GLchar__CP mMessage;
    };

    class GlPushGroupMarkerEXT: public Encodable {
    public:
        GlPushGroupMarkerEXT() = default;
        GlPushGroupMarkerEXT(const gapic::Vector<gapic::Encodable*>& extras, int32_t Length, GLchar__CP Marker)
                : mextras(extras)
                , mLength(Length)
                , mMarker(Marker) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int32(this->mLength);
            e->Struct(this->mMarker);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mLength;
        GLchar__CP mMarker;
    };

    class GlPushMatrix: public Encodable {
    public:
        GlPushMatrix() = default;
        GlPushMatrix(const gapic::Vector<gapic::Encodable*>& extras)
                : mextras(extras) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
    };

    class GlQueryCounterEXT: public Encodable {
    public:
        GlQueryCounterEXT() = default;
        GlQueryCounterEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Query, uint32_t Target)
                : mextras(extras)
                , mQuery(Query)
                , mTarget(Target) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mQuery);
            e->Uint32(this->mTarget);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mQuery;
        uint32_t mTarget;
    };

    class GlQueryMatrixxOES: public Encodable {
    public:
        GlQueryMatrixxOES() = default;
        GlQueryMatrixxOES(const gapic::Vector<gapic::Encodable*>& extras, GLfixed__P Mantissa, GLint__P Exponent, uint32_t Result)
                : mextras(extras)
                , mMantissa(Mantissa)
                , mExponent(Exponent)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        GLfixed__P mMantissa;
        GLint__P mExponent;
        uint32_t mResult;
    };

    class GlRasterSamplesEXT: public Encodable {
    public:
        GlRasterSamplesEXT() = default;
        GlRasterSamplesEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Samples, uint8_t Fixedsamplelocations)
                : mextras(extras)
                , mSamples(Samples)
                , mFixedsamplelocations(Fixedsamplelocations) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mSamples);
            e->Uint8(this->mFixedsamplelocations);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mSamples;
        uint8_t mFixedsamplelocations;
    };

    class GlReadBuffer: public Encodable {
    public:
        GlReadBuffer() = default;
        GlReadBuffer(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Src)
                : mextras(extras)
                , mSrc(Src) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mSrc);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mSrc;
    };

    class GlReadBufferIndexedEXT: public Encodable {
    public:
        GlReadBufferIndexedEXT() = default;
        GlReadBufferIndexedEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Src, int32_t Index)
                : mextras(extras)
                , mSrc(Src)
                , mIndex(Index) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mSrc);
            e->Int32(this->mIndex);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mSrc;
        int32_t mIndex;
    };

    class GlReadBufferNV: public Encodable {
    public:
        GlReadBufferNV() = default;
        GlReadBufferNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Mode)
                : mextras(extras)
                , mMode(Mode) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mMode);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mMode;
    };

    class GlReadPixels: public Encodable {
    public:
        GlReadPixels() = default;
        GlReadPixels(const gapic::Vector<gapic::Encodable*>& extras, int32_t X, int32_t Y, int32_t Width, int32_t Height, uint32_t Format, uint32_t Type, Void__P Data)
                : mextras(extras)
                , mX(X)
                , mY(Y)
                , mWidth(Width)
                , mHeight(Height)
                , mFormat(Format)
                , mType(Type)
                , mData(Data) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mX;
        int32_t mY;
        int32_t mWidth;
        int32_t mHeight;
        uint32_t mFormat;
        uint32_t mType;
        Void__P mData;
    };

    class GlReadnPixels: public Encodable {
    public:
        GlReadnPixels() = default;
        GlReadnPixels(const gapic::Vector<gapic::Encodable*>& extras, int32_t X, int32_t Y, int32_t Width, int32_t Height, uint32_t Format, uint32_t Type, int32_t BufSize, Void__P Data)
                : mextras(extras)
                , mX(X)
                , mY(Y)
                , mWidth(Width)
                , mHeight(Height)
                , mFormat(Format)
                , mType(Type)
                , mBufSize(BufSize)
                , mData(Data) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mX;
        int32_t mY;
        int32_t mWidth;
        int32_t mHeight;
        uint32_t mFormat;
        uint32_t mType;
        int32_t mBufSize;
        Void__P mData;
    };

    class GlReadnPixelsEXT: public Encodable {
    public:
        GlReadnPixelsEXT() = default;
        GlReadnPixelsEXT(const gapic::Vector<gapic::Encodable*>& extras, int32_t X, int32_t Y, int32_t Width, int32_t Height, uint32_t Format, uint32_t Type, int32_t BufSize, Void__P Data)
                : mextras(extras)
                , mX(X)
                , mY(Y)
                , mWidth(Width)
                , mHeight(Height)
                , mFormat(Format)
                , mType(Type)
                , mBufSize(BufSize)
                , mData(Data) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mX;
        int32_t mY;
        int32_t mWidth;
        int32_t mHeight;
        uint32_t mFormat;
        uint32_t mType;
        int32_t mBufSize;
        Void__P mData;
    };

    class GlReadnPixelsKHR: public Encodable {
    public:
        GlReadnPixelsKHR() = default;
        GlReadnPixelsKHR(const gapic::Vector<gapic::Encodable*>& extras, int32_t X, int32_t Y, int32_t Width, int32_t Height, uint32_t Format, uint32_t Type, int32_t BufSize, Void__P Data)
                : mextras(extras)
                , mX(X)
                , mY(Y)
                , mWidth(Width)
                , mHeight(Height)
                , mFormat(Format)
                , mType(Type)
                , mBufSize(BufSize)
                , mData(Data) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mX;
        int32_t mY;
        int32_t mWidth;
        int32_t mHeight;
        uint32_t mFormat;
        uint32_t mType;
        int32_t mBufSize;
        Void__P mData;
    };

    class GlReleaseShaderCompiler: public Encodable {
    public:
        GlReleaseShaderCompiler() = default;
        GlReleaseShaderCompiler(const gapic::Vector<gapic::Encodable*>& extras)
                : mextras(extras) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
    };

    class GlRenderbufferStorage: public Encodable {
    public:
        GlRenderbufferStorage() = default;
        GlRenderbufferStorage(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Internalformat, int32_t Width, int32_t Height)
                : mextras(extras)
                , mTarget(Target)
                , mInternalformat(Internalformat)
                , mWidth(Width)
                , mHeight(Height) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mInternalformat;
        int32_t mWidth;
        int32_t mHeight;
    };

    class GlRenderbufferStorageMultisample: public Encodable {
    public:
        GlRenderbufferStorageMultisample() = default;
        GlRenderbufferStorageMultisample(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, int32_t Samples, uint32_t Internalformat, int32_t Width, int32_t Height)
                : mextras(extras)
                , mTarget(Target)
                , mSamples(Samples)
                , mInternalformat(Internalformat)
                , mWidth(Width)
                , mHeight(Height) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        int32_t mSamples;
        uint32_t mInternalformat;
        int32_t mWidth;
        int32_t mHeight;
    };

    class GlRenderbufferStorageMultisampleANGLE: public Encodable {
    public:
        GlRenderbufferStorageMultisampleANGLE() = default;
        GlRenderbufferStorageMultisampleANGLE(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, int32_t Samples, uint32_t Internalformat, int32_t Width, int32_t Height)
                : mextras(extras)
                , mTarget(Target)
                , mSamples(Samples)
                , mInternalformat(Internalformat)
                , mWidth(Width)
                , mHeight(Height) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        int32_t mSamples;
        uint32_t mInternalformat;
        int32_t mWidth;
        int32_t mHeight;
    };

    class GlRenderbufferStorageMultisampleAPPLE: public Encodable {
    public:
        GlRenderbufferStorageMultisampleAPPLE() = default;
        GlRenderbufferStorageMultisampleAPPLE(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, int32_t Samples, uint32_t Internalformat, int32_t Width, int32_t Height)
                : mextras(extras)
                , mTarget(Target)
                , mSamples(Samples)
                , mInternalformat(Internalformat)
                , mWidth(Width)
                , mHeight(Height) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        int32_t mSamples;
        uint32_t mInternalformat;
        int32_t mWidth;
        int32_t mHeight;
    };

    class GlRenderbufferStorageMultisampleEXT: public Encodable {
    public:
        GlRenderbufferStorageMultisampleEXT() = default;
        GlRenderbufferStorageMultisampleEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, int32_t Samples, uint32_t Internalformat, int32_t Width, int32_t Height)
                : mextras(extras)
                , mTarget(Target)
                , mSamples(Samples)
                , mInternalformat(Internalformat)
                , mWidth(Width)
                , mHeight(Height) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        int32_t mSamples;
        uint32_t mInternalformat;
        int32_t mWidth;
        int32_t mHeight;
    };

    class GlRenderbufferStorageMultisampleIMG: public Encodable {
    public:
        GlRenderbufferStorageMultisampleIMG() = default;
        GlRenderbufferStorageMultisampleIMG(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, int32_t Samples, uint32_t Internalformat, int32_t Width, int32_t Height)
                : mextras(extras)
                , mTarget(Target)
                , mSamples(Samples)
                , mInternalformat(Internalformat)
                , mWidth(Width)
                , mHeight(Height) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        int32_t mSamples;
        uint32_t mInternalformat;
        int32_t mWidth;
        int32_t mHeight;
    };

    class GlRenderbufferStorageMultisampleNV: public Encodable {
    public:
        GlRenderbufferStorageMultisampleNV() = default;
        GlRenderbufferStorageMultisampleNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, int32_t Samples, uint32_t Internalformat, int32_t Width, int32_t Height)
                : mextras(extras)
                , mTarget(Target)
                , mSamples(Samples)
                , mInternalformat(Internalformat)
                , mWidth(Width)
                , mHeight(Height) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        int32_t mSamples;
        uint32_t mInternalformat;
        int32_t mWidth;
        int32_t mHeight;
    };

    class GlRenderbufferStorageOES: public Encodable {
    public:
        GlRenderbufferStorageOES() = default;
        GlRenderbufferStorageOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Internalformat, int32_t Width, int32_t Height)
                : mextras(extras)
                , mTarget(Target)
                , mInternalformat(Internalformat)
                , mWidth(Width)
                , mHeight(Height) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mInternalformat;
        int32_t mWidth;
        int32_t mHeight;
    };

    class GlResolveDepthValuesNV: public Encodable {
    public:
        GlResolveDepthValuesNV() = default;
        GlResolveDepthValuesNV(const gapic::Vector<gapic::Encodable*>& extras)
                : mextras(extras) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
    };

    class GlResolveMultisampleFramebufferAPPLE: public Encodable {
    public:
        GlResolveMultisampleFramebufferAPPLE() = default;
        GlResolveMultisampleFramebufferAPPLE(const gapic::Vector<gapic::Encodable*>& extras)
                : mextras(extras) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
    };

    class GlResumeTransformFeedback: public Encodable {
    public:
        GlResumeTransformFeedback() = default;
        GlResumeTransformFeedback(const gapic::Vector<gapic::Encodable*>& extras)
                : mextras(extras) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
    };

    class GlRotatef: public Encodable {
    public:
        GlRotatef() = default;
        GlRotatef(const gapic::Vector<gapic::Encodable*>& extras, float Angle, float X, float Y, float Z)
                : mextras(extras)
                , mAngle(Angle)
                , mX(X)
                , mY(Y)
                , mZ(Z) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        float mAngle;
        float mX;
        float mY;
        float mZ;
    };

    class GlRotatex: public Encodable {
    public:
        GlRotatex() = default;
        GlRotatex(const gapic::Vector<gapic::Encodable*>& extras, int32_t Angle, int32_t X, int32_t Y, int32_t Z)
                : mextras(extras)
                , mAngle(Angle)
                , mX(X)
                , mY(Y)
                , mZ(Z) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mAngle;
        int32_t mX;
        int32_t mY;
        int32_t mZ;
    };

    class GlRotatexOES: public Encodable {
    public:
        GlRotatexOES() = default;
        GlRotatexOES(const gapic::Vector<gapic::Encodable*>& extras, int32_t Angle, int32_t X, int32_t Y, int32_t Z)
                : mextras(extras)
                , mAngle(Angle)
                , mX(X)
                , mY(Y)
                , mZ(Z) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mAngle;
        int32_t mX;
        int32_t mY;
        int32_t mZ;
    };

    class GlSampleCoverage: public Encodable {
    public:
        GlSampleCoverage() = default;
        GlSampleCoverage(const gapic::Vector<gapic::Encodable*>& extras, float Value, uint8_t Invert)
                : mextras(extras)
                , mValue(Value)
                , mInvert(Invert) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Float32(this->mValue);
            e->Uint8(this->mInvert);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        float mValue;
        uint8_t mInvert;
    };

    class GlSampleCoveragex: public Encodable {
    public:
        GlSampleCoveragex() = default;
        GlSampleCoveragex(const gapic::Vector<gapic::Encodable*>& extras, int32_t Value, uint8_t Invert)
                : mextras(extras)
                , mValue(Value)
                , mInvert(Invert) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int32(this->mValue);
            e->Uint8(this->mInvert);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mValue;
        uint8_t mInvert;
    };

    class GlSampleCoveragexOES: public Encodable {
    public:
        GlSampleCoveragexOES() = default;
        GlSampleCoveragexOES(const gapic::Vector<gapic::Encodable*>& extras, int32_t Value, uint8_t Invert)
                : mextras(extras)
                , mValue(Value)
                , mInvert(Invert) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int32(this->mValue);
            e->Uint8(this->mInvert);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mValue;
        uint8_t mInvert;
    };

    class GlSampleMaski: public Encodable {
    public:
        GlSampleMaski() = default;
        GlSampleMaski(const gapic::Vector<gapic::Encodable*>& extras, uint32_t MaskNumber, uint32_t Mask)
                : mextras(extras)
                , mMaskNumber(MaskNumber)
                , mMask(Mask) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mMaskNumber);
            e->Uint32(this->mMask);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mMaskNumber;
        uint32_t mMask;
    };

    class GlSamplerParameterIiv: public Encodable {
    public:
        GlSamplerParameterIiv() = default;
        GlSamplerParameterIiv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Sampler, uint32_t Pname, GLint__CP Param)
                : mextras(extras)
                , mSampler(Sampler)
                , mPname(Pname)
                , mParam(Param) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mSampler;
        uint32_t mPname;
        GLint__CP mParam;
    };

    class GlSamplerParameterIivEXT: public Encodable {
    public:
        GlSamplerParameterIivEXT() = default;
        GlSamplerParameterIivEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Sampler, uint32_t Pname, GLint__CP Param)
                : mextras(extras)
                , mSampler(Sampler)
                , mPname(Pname)
                , mParam(Param) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mSampler;
        uint32_t mPname;
        GLint__CP mParam;
    };

    class GlSamplerParameterIivOES: public Encodable {
    public:
        GlSamplerParameterIivOES() = default;
        GlSamplerParameterIivOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Sampler, uint32_t Pname, GLint__CP Param)
                : mextras(extras)
                , mSampler(Sampler)
                , mPname(Pname)
                , mParam(Param) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mSampler;
        uint32_t mPname;
        GLint__CP mParam;
    };

    class GlSamplerParameterIuiv: public Encodable {
    public:
        GlSamplerParameterIuiv() = default;
        GlSamplerParameterIuiv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Sampler, uint32_t Pname, GLuint__CP Param)
                : mextras(extras)
                , mSampler(Sampler)
                , mPname(Pname)
                , mParam(Param) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mSampler;
        uint32_t mPname;
        GLuint__CP mParam;
    };

    class GlSamplerParameterIuivEXT: public Encodable {
    public:
        GlSamplerParameterIuivEXT() = default;
        GlSamplerParameterIuivEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Sampler, uint32_t Pname, GLuint__CP Param)
                : mextras(extras)
                , mSampler(Sampler)
                , mPname(Pname)
                , mParam(Param) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mSampler;
        uint32_t mPname;
        GLuint__CP mParam;
    };

    class GlSamplerParameterIuivOES: public Encodable {
    public:
        GlSamplerParameterIuivOES() = default;
        GlSamplerParameterIuivOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Sampler, uint32_t Pname, GLuint__CP Param)
                : mextras(extras)
                , mSampler(Sampler)
                , mPname(Pname)
                , mParam(Param) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mSampler;
        uint32_t mPname;
        GLuint__CP mParam;
    };

    class GlSamplerParameterf: public Encodable {
    public:
        GlSamplerParameterf() = default;
        GlSamplerParameterf(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Sampler, uint32_t Pname, float Param)
                : mextras(extras)
                , mSampler(Sampler)
                , mPname(Pname)
                , mParam(Param) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mSampler;
        uint32_t mPname;
        float mParam;
    };

    class GlSamplerParameterfv: public Encodable {
    public:
        GlSamplerParameterfv() = default;
        GlSamplerParameterfv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Sampler, uint32_t Pname, GLfloat__CP Param)
                : mextras(extras)
                , mSampler(Sampler)
                , mPname(Pname)
                , mParam(Param) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mSampler;
        uint32_t mPname;
        GLfloat__CP mParam;
    };

    class GlSamplerParameteri: public Encodable {
    public:
        GlSamplerParameteri() = default;
        GlSamplerParameteri(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Sampler, uint32_t Pname, int32_t Param)
                : mextras(extras)
                , mSampler(Sampler)
                , mPname(Pname)
                , mParam(Param) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mSampler;
        uint32_t mPname;
        int32_t mParam;
    };

    class GlSamplerParameteriv: public Encodable {
    public:
        GlSamplerParameteriv() = default;
        GlSamplerParameteriv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Sampler, uint32_t Pname, GLint__CP Param)
                : mextras(extras)
                , mSampler(Sampler)
                , mPname(Pname)
                , mParam(Param) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mSampler;
        uint32_t mPname;
        GLint__CP mParam;
    };

    class GlScalef: public Encodable {
    public:
        GlScalef() = default;
        GlScalef(const gapic::Vector<gapic::Encodable*>& extras, float X, float Y, float Z)
                : mextras(extras)
                , mX(X)
                , mY(Y)
                , mZ(Z) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        float mX;
        float mY;
        float mZ;
    };

    class GlScalex: public Encodable {
    public:
        GlScalex() = default;
        GlScalex(const gapic::Vector<gapic::Encodable*>& extras, int32_t X, int32_t Y, int32_t Z)
                : mextras(extras)
                , mX(X)
                , mY(Y)
                , mZ(Z) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mX;
        int32_t mY;
        int32_t mZ;
    };

    class GlScalexOES: public Encodable {
    public:
        GlScalexOES() = default;
        GlScalexOES(const gapic::Vector<gapic::Encodable*>& extras, int32_t X, int32_t Y, int32_t Z)
                : mextras(extras)
                , mX(X)
                , mY(Y)
                , mZ(Z) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mX;
        int32_t mY;
        int32_t mZ;
    };

    class GlScissor: public Encodable {
    public:
        GlScissor() = default;
        GlScissor(const gapic::Vector<gapic::Encodable*>& extras, int32_t X, int32_t Y, int32_t Width, int32_t Height)
                : mextras(extras)
                , mX(X)
                , mY(Y)
                , mWidth(Width)
                , mHeight(Height) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mX;
        int32_t mY;
        int32_t mWidth;
        int32_t mHeight;
    };

    class GlScissorArrayvNV: public Encodable {
    public:
        GlScissorArrayvNV() = default;
        GlScissorArrayvNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t First, int32_t Count, GLint__CP V)
                : mextras(extras)
                , mFirst(First)
                , mCount(Count)
                , mV(V) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mFirst;
        int32_t mCount;
        GLint__CP mV;
    };

    class GlScissorIndexedNV: public Encodable {
    public:
        GlScissorIndexedNV() = default;
        GlScissorIndexedNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Index, int32_t Left, int32_t Bottom, int32_t Width, int32_t Height)
                : mextras(extras)
                , mIndex(Index)
                , mLeft(Left)
                , mBottom(Bottom)
                , mWidth(Width)
                , mHeight(Height) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mIndex;
        int32_t mLeft;
        int32_t mBottom;
        int32_t mWidth;
        int32_t mHeight;
    };

    class GlScissorIndexedvNV: public Encodable {
    public:
        GlScissorIndexedvNV() = default;
        GlScissorIndexedvNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Index, GLint__CP V)
                : mextras(extras)
                , mIndex(Index)
                , mV(V) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mIndex);
            e->Struct(this->mV);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mIndex;
        GLint__CP mV;
    };

    class GlSelectPerfMonitorCountersAMD: public Encodable {
    public:
        GlSelectPerfMonitorCountersAMD() = default;
        GlSelectPerfMonitorCountersAMD(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Monitor, uint8_t Enable, uint32_t Group, int32_t NumCounters, GLuint__P CounterList)
                : mextras(extras)
                , mMonitor(Monitor)
                , mEnable(Enable)
                , mGroup(Group)
                , mNumCounters(NumCounters)
                , mCounterList(CounterList) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mMonitor;
        uint8_t mEnable;
        uint32_t mGroup;
        int32_t mNumCounters;
        GLuint__P mCounterList;
    };

    class GlSetFenceNV: public Encodable {
    public:
        GlSetFenceNV() = default;
        GlSetFenceNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Fence, uint32_t Condition)
                : mextras(extras)
                , mFence(Fence)
                , mCondition(Condition) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mFence);
            e->Uint32(this->mCondition);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mFence;
        uint32_t mCondition;
    };

    class GlShadeModel: public Encodable {
    public:
        GlShadeModel() = default;
        GlShadeModel(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Mode)
                : mextras(extras)
                , mMode(Mode) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mMode);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mMode;
    };

    class ShaderId__CP: public Encodable {
    public:
        ShaderId__CP() = default;
        ShaderId__CP(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class GlShaderBinary: public Encodable {
    public:
        GlShaderBinary() = default;
        GlShaderBinary(const gapic::Vector<gapic::Encodable*>& extras, int32_t Count, ShaderId__CP Shaders, uint32_t BinaryFormat, Void__CP Binary, int32_t BinarySize)
                : mextras(extras)
                , mCount(Count)
                , mShaders(Shaders)
                , mBinaryFormat(BinaryFormat)
                , mBinary(Binary)
                , mBinarySize(BinarySize) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mCount;
        ShaderId__CP mShaders;
        uint32_t mBinaryFormat;
        Void__CP mBinary;
        int32_t mBinarySize;
    };

    class GlShaderSource: public Encodable {
    public:
        GlShaderSource() = default;
        GlShaderSource(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Shader, int32_t Count, GLchar__CP__CP Source, GLint__CP Length)
                : mextras(extras)
                , mShader(Shader)
                , mCount(Count)
                , mSource(Source)
                , mLength(Length) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mShader;
        int32_t mCount;
        GLchar__CP__CP mSource;
        GLint__CP mLength;
    };

    class GlStartTilingQCOM: public Encodable {
    public:
        GlStartTilingQCOM() = default;
        GlStartTilingQCOM(const gapic::Vector<gapic::Encodable*>& extras, uint32_t X, uint32_t Y, uint32_t Width, uint32_t Height, uint32_t PreserveMask)
                : mextras(extras)
                , mX(X)
                , mY(Y)
                , mWidth(Width)
                , mHeight(Height)
                , mPreserveMask(PreserveMask) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mX;
        uint32_t mY;
        uint32_t mWidth;
        uint32_t mHeight;
        uint32_t mPreserveMask;
    };

    class GlStencilFillPathInstancedNV: public Encodable {
    public:
        GlStencilFillPathInstancedNV() = default;
        GlStencilFillPathInstancedNV(const gapic::Vector<gapic::Encodable*>& extras, int32_t NumPaths, uint32_t PathNameType, Void__CP Paths, uint32_t PathBase, uint32_t FillMode, uint32_t Mask, uint32_t TransformType, GLfloat__CP TransformValues)
                : mextras(extras)
                , mNumPaths(NumPaths)
                , mPathNameType(PathNameType)
                , mPaths(Paths)
                , mPathBase(PathBase)
                , mFillMode(FillMode)
                , mMask(Mask)
                , mTransformType(TransformType)
                , mTransformValues(TransformValues) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mNumPaths;
        uint32_t mPathNameType;
        Void__CP mPaths;
        uint32_t mPathBase;
        uint32_t mFillMode;
        uint32_t mMask;
        uint32_t mTransformType;
        GLfloat__CP mTransformValues;
    };

    class GlStencilFillPathNV: public Encodable {
    public:
        GlStencilFillPathNV() = default;
        GlStencilFillPathNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Path, uint32_t FillMode, uint32_t Mask)
                : mextras(extras)
                , mPath(Path)
                , mFillMode(FillMode)
                , mMask(Mask) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPath;
        uint32_t mFillMode;
        uint32_t mMask;
    };

    class GlStencilFunc: public Encodable {
    public:
        GlStencilFunc() = default;
        GlStencilFunc(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Func, int32_t Ref, uint32_t Mask)
                : mextras(extras)
                , mFunc(Func)
                , mRef(Ref)
                , mMask(Mask) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mFunc;
        int32_t mRef;
        uint32_t mMask;
    };

    class GlStencilFuncSeparate: public Encodable {
    public:
        GlStencilFuncSeparate() = default;
        GlStencilFuncSeparate(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Face, uint32_t Function, int32_t ReferenceValue, uint32_t Mask)
                : mextras(extras)
                , mFace(Face)
                , mFunction(Function)
                , mReferenceValue(ReferenceValue)
                , mMask(Mask) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mFace;
        uint32_t mFunction;
        int32_t mReferenceValue;
        uint32_t mMask;
    };

    class GlStencilMask: public Encodable {
    public:
        GlStencilMask() = default;
        GlStencilMask(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Mask)
                : mextras(extras)
                , mMask(Mask) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mMask);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mMask;
    };

    class GlStencilMaskSeparate: public Encodable {
    public:
        GlStencilMaskSeparate() = default;
        GlStencilMaskSeparate(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Face, uint32_t Mask)
                : mextras(extras)
                , mFace(Face)
                , mMask(Mask) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mFace);
            e->Uint32(this->mMask);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mFace;
        uint32_t mMask;
    };

    class GlStencilOp: public Encodable {
    public:
        GlStencilOp() = default;
        GlStencilOp(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Fail, uint32_t Zfail, uint32_t Zpass)
                : mextras(extras)
                , mFail(Fail)
                , mZfail(Zfail)
                , mZpass(Zpass) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mFail;
        uint32_t mZfail;
        uint32_t mZpass;
    };

    class GlStencilOpSeparate: public Encodable {
    public:
        GlStencilOpSeparate() = default;
        GlStencilOpSeparate(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Face, uint32_t StencilFail, uint32_t StencilPassDepthFail, uint32_t StencilPassDepthPass)
                : mextras(extras)
                , mFace(Face)
                , mStencilFail(StencilFail)
                , mStencilPassDepthFail(StencilPassDepthFail)
                , mStencilPassDepthPass(StencilPassDepthPass) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mFace;
        uint32_t mStencilFail;
        uint32_t mStencilPassDepthFail;
        uint32_t mStencilPassDepthPass;
    };

    class GlStencilStrokePathInstancedNV: public Encodable {
    public:
        GlStencilStrokePathInstancedNV() = default;
        GlStencilStrokePathInstancedNV(const gapic::Vector<gapic::Encodable*>& extras, int32_t NumPaths, uint32_t PathNameType, Void__CP Paths, uint32_t PathBase, int32_t Reference, uint32_t Mask, uint32_t TransformType, GLfloat__CP TransformValues)
                : mextras(extras)
                , mNumPaths(NumPaths)
                , mPathNameType(PathNameType)
                , mPaths(Paths)
                , mPathBase(PathBase)
                , mReference(Reference)
                , mMask(Mask)
                , mTransformType(TransformType)
                , mTransformValues(TransformValues) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mNumPaths;
        uint32_t mPathNameType;
        Void__CP mPaths;
        uint32_t mPathBase;
        int32_t mReference;
        uint32_t mMask;
        uint32_t mTransformType;
        GLfloat__CP mTransformValues;
    };

    class GlStencilStrokePathNV: public Encodable {
    public:
        GlStencilStrokePathNV() = default;
        GlStencilStrokePathNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Path, int32_t Reference, uint32_t Mask)
                : mextras(extras)
                , mPath(Path)
                , mReference(Reference)
                , mMask(Mask) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPath;
        int32_t mReference;
        uint32_t mMask;
    };

    class GlStencilThenCoverFillPathInstancedNV: public Encodable {
    public:
        GlStencilThenCoverFillPathInstancedNV() = default;
        GlStencilThenCoverFillPathInstancedNV(const gapic::Vector<gapic::Encodable*>& extras, int32_t NumPaths, uint32_t PathNameType, Void__CP Paths, uint32_t PathBase, uint32_t FillMode, uint32_t Mask, uint32_t CoverMode, uint32_t TransformType, GLfloat__CP TransformValues)
                : mextras(extras)
                , mNumPaths(NumPaths)
                , mPathNameType(PathNameType)
                , mPaths(Paths)
                , mPathBase(PathBase)
                , mFillMode(FillMode)
                , mMask(Mask)
                , mCoverMode(CoverMode)
                , mTransformType(TransformType)
                , mTransformValues(TransformValues) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mNumPaths;
        uint32_t mPathNameType;
        Void__CP mPaths;
        uint32_t mPathBase;
        uint32_t mFillMode;
        uint32_t mMask;
        uint32_t mCoverMode;
        uint32_t mTransformType;
        GLfloat__CP mTransformValues;
    };

    class GlStencilThenCoverFillPathNV: public Encodable {
    public:
        GlStencilThenCoverFillPathNV() = default;
        GlStencilThenCoverFillPathNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Path, uint32_t FillMode, uint32_t Mask, uint32_t CoverMode)
                : mextras(extras)
                , mPath(Path)
                , mFillMode(FillMode)
                , mMask(Mask)
                , mCoverMode(CoverMode) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPath;
        uint32_t mFillMode;
        uint32_t mMask;
        uint32_t mCoverMode;
    };

    class GlStencilThenCoverStrokePathInstancedNV: public Encodable {
    public:
        GlStencilThenCoverStrokePathInstancedNV() = default;
        GlStencilThenCoverStrokePathInstancedNV(const gapic::Vector<gapic::Encodable*>& extras, int32_t NumPaths, uint32_t PathNameType, Void__CP Paths, uint32_t PathBase, int32_t Reference, uint32_t Mask, uint32_t CoverMode, uint32_t TransformType, GLfloat__CP TransformValues)
                : mextras(extras)
                , mNumPaths(NumPaths)
                , mPathNameType(PathNameType)
                , mPaths(Paths)
                , mPathBase(PathBase)
                , mReference(Reference)
                , mMask(Mask)
                , mCoverMode(CoverMode)
                , mTransformType(TransformType)
                , mTransformValues(TransformValues) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mNumPaths;
        uint32_t mPathNameType;
        Void__CP mPaths;
        uint32_t mPathBase;
        int32_t mReference;
        uint32_t mMask;
        uint32_t mCoverMode;
        uint32_t mTransformType;
        GLfloat__CP mTransformValues;
    };

    class GlStencilThenCoverStrokePathNV: public Encodable {
    public:
        GlStencilThenCoverStrokePathNV() = default;
        GlStencilThenCoverStrokePathNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Path, int32_t Reference, uint32_t Mask, uint32_t CoverMode)
                : mextras(extras)
                , mPath(Path)
                , mReference(Reference)
                , mMask(Mask)
                , mCoverMode(CoverMode) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPath;
        int32_t mReference;
        uint32_t mMask;
        uint32_t mCoverMode;
    };

    class GlSubpixelPrecisionBiasNV: public Encodable {
    public:
        GlSubpixelPrecisionBiasNV() = default;
        GlSubpixelPrecisionBiasNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Xbits, uint32_t Ybits)
                : mextras(extras)
                , mXbits(Xbits)
                , mYbits(Ybits) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mXbits);
            e->Uint32(this->mYbits);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mXbits;
        uint32_t mYbits;
    };

    class GlTestFenceNV: public Encodable {
    public:
        GlTestFenceNV() = default;
        GlTestFenceNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Fence, uint8_t Result)
                : mextras(extras)
                , mFence(Fence)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mFence);
            e->Uint8(this->mResult);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mFence;
        uint8_t mResult;
    };

    class GlTexBuffer: public Encodable {
    public:
        GlTexBuffer() = default;
        GlTexBuffer(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Internalformat, uint32_t Buffer)
                : mextras(extras)
                , mTarget(Target)
                , mInternalformat(Internalformat)
                , mBuffer(Buffer) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mInternalformat;
        uint32_t mBuffer;
    };

    class GlTexBufferEXT: public Encodable {
    public:
        GlTexBufferEXT() = default;
        GlTexBufferEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Internalformat, uint32_t Buffer)
                : mextras(extras)
                , mTarget(Target)
                , mInternalformat(Internalformat)
                , mBuffer(Buffer) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mInternalformat;
        uint32_t mBuffer;
    };

    class GlTexBufferOES: public Encodable {
    public:
        GlTexBufferOES() = default;
        GlTexBufferOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Internalformat, uint32_t Buffer)
                : mextras(extras)
                , mTarget(Target)
                , mInternalformat(Internalformat)
                , mBuffer(Buffer) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mInternalformat;
        uint32_t mBuffer;
    };

    class GlTexBufferRange: public Encodable {
    public:
        GlTexBufferRange() = default;
        GlTexBufferRange(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Internalformat, uint32_t Buffer, int32_t Offset, int32_t Size)
                : mextras(extras)
                , mTarget(Target)
                , mInternalformat(Internalformat)
                , mBuffer(Buffer)
                , mOffset(Offset)
                , mSize(Size) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mInternalformat;
        uint32_t mBuffer;
        int32_t mOffset;
        int32_t mSize;
    };

    class GlTexBufferRangeEXT: public Encodable {
    public:
        GlTexBufferRangeEXT() = default;
        GlTexBufferRangeEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Internalformat, uint32_t Buffer, int32_t Offset, int32_t Size)
                : mextras(extras)
                , mTarget(Target)
                , mInternalformat(Internalformat)
                , mBuffer(Buffer)
                , mOffset(Offset)
                , mSize(Size) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mInternalformat;
        uint32_t mBuffer;
        int32_t mOffset;
        int32_t mSize;
    };

    class GlTexBufferRangeOES: public Encodable {
    public:
        GlTexBufferRangeOES() = default;
        GlTexBufferRangeOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Internalformat, uint32_t Buffer, int32_t Offset, int32_t Size)
                : mextras(extras)
                , mTarget(Target)
                , mInternalformat(Internalformat)
                , mBuffer(Buffer)
                , mOffset(Offset)
                , mSize(Size) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mInternalformat;
        uint32_t mBuffer;
        int32_t mOffset;
        int32_t mSize;
    };

    class GlTexCoordPointer: public Encodable {
    public:
        GlTexCoordPointer() = default;
        GlTexCoordPointer(const gapic::Vector<gapic::Encodable*>& extras, int32_t Size, uint32_t Type, int32_t Stride, Void__CP Pointer)
                : mextras(extras)
                , mSize(Size)
                , mType(Type)
                , mStride(Stride)
                , mPointer(Pointer) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mSize;
        uint32_t mType;
        int32_t mStride;
        Void__CP mPointer;
    };

    class GlTexCoordPointerBounds: public Encodable {
    public:
        GlTexCoordPointerBounds() = default;
        GlTexCoordPointerBounds(const gapic::Vector<gapic::Encodable*>& extras, int32_t Size, uint32_t Type, int32_t Stride, Void__CP Pointer, int32_t Count)
                : mextras(extras)
                , mSize(Size)
                , mType(Type)
                , mStride(Stride)
                , mPointer(Pointer)
                , mCount(Count) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mSize;
        uint32_t mType;
        int32_t mStride;
        Void__CP mPointer;
        int32_t mCount;
    };

    class GlTexEnvf: public Encodable {
    public:
        GlTexEnvf() = default;
        GlTexEnvf(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Pname, float Param)
                : mextras(extras)
                , mTarget(Target)
                , mPname(Pname)
                , mParam(Param) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mPname;
        float mParam;
    };

    class GlTexEnvfv: public Encodable {
    public:
        GlTexEnvfv() = default;
        GlTexEnvfv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Pname, GLfloat__CP Params)
                : mextras(extras)
                , mTarget(Target)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mPname;
        GLfloat__CP mParams;
    };

    class GlTexEnvi: public Encodable {
    public:
        GlTexEnvi() = default;
        GlTexEnvi(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Pname, int32_t Param)
                : mextras(extras)
                , mTarget(Target)
                , mPname(Pname)
                , mParam(Param) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mPname;
        int32_t mParam;
    };

    class GlTexEnviv: public Encodable {
    public:
        GlTexEnviv() = default;
        GlTexEnviv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Pname, GLint__CP Params)
                : mextras(extras)
                , mTarget(Target)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mPname;
        GLint__CP mParams;
    };

    class GlTexEnvx: public Encodable {
    public:
        GlTexEnvx() = default;
        GlTexEnvx(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Pname, int32_t Param)
                : mextras(extras)
                , mTarget(Target)
                , mPname(Pname)
                , mParam(Param) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mPname;
        int32_t mParam;
    };

    class GlTexEnvxOES: public Encodable {
    public:
        GlTexEnvxOES() = default;
        GlTexEnvxOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Pname, int32_t Param)
                : mextras(extras)
                , mTarget(Target)
                , mPname(Pname)
                , mParam(Param) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mPname;
        int32_t mParam;
    };

    class GlTexEnvxv: public Encodable {
    public:
        GlTexEnvxv() = default;
        GlTexEnvxv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Pname, GLfixed__CP Params)
                : mextras(extras)
                , mTarget(Target)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mPname;
        GLfixed__CP mParams;
    };

    class GlTexEnvxvOES: public Encodable {
    public:
        GlTexEnvxvOES() = default;
        GlTexEnvxvOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Pname, GLfixed__CP Params)
                : mextras(extras)
                , mTarget(Target)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mPname;
        GLfixed__CP mParams;
    };

    class GlTexGenfOES: public Encodable {
    public:
        GlTexGenfOES() = default;
        GlTexGenfOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Coord, uint32_t Pname, float Param)
                : mextras(extras)
                , mCoord(Coord)
                , mPname(Pname)
                , mParam(Param) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mCoord;
        uint32_t mPname;
        float mParam;
    };

    class GlTexGenfvOES: public Encodable {
    public:
        GlTexGenfvOES() = default;
        GlTexGenfvOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Coord, uint32_t Pname, GLfloat__CP Params)
                : mextras(extras)
                , mCoord(Coord)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mCoord;
        uint32_t mPname;
        GLfloat__CP mParams;
    };

    class GlTexGeniOES: public Encodable {
    public:
        GlTexGeniOES() = default;
        GlTexGeniOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Coord, uint32_t Pname, int32_t Param)
                : mextras(extras)
                , mCoord(Coord)
                , mPname(Pname)
                , mParam(Param) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mCoord;
        uint32_t mPname;
        int32_t mParam;
    };

    class GlTexGenivOES: public Encodable {
    public:
        GlTexGenivOES() = default;
        GlTexGenivOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Coord, uint32_t Pname, GLint__CP Params)
                : mextras(extras)
                , mCoord(Coord)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mCoord;
        uint32_t mPname;
        GLint__CP mParams;
    };

    class GlTexGenxOES: public Encodable {
    public:
        GlTexGenxOES() = default;
        GlTexGenxOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Coord, uint32_t Pname, int32_t Param)
                : mextras(extras)
                , mCoord(Coord)
                , mPname(Pname)
                , mParam(Param) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mCoord;
        uint32_t mPname;
        int32_t mParam;
    };

    class GlTexGenxvOES: public Encodable {
    public:
        GlTexGenxvOES() = default;
        GlTexGenxvOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Coord, uint32_t Pname, GLfixed__CP Params)
                : mextras(extras)
                , mCoord(Coord)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mCoord;
        uint32_t mPname;
        GLfixed__CP mParams;
    };

    class GlTexImage2D: public Encodable {
    public:
        GlTexImage2D() = default;
        GlTexImage2D(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, int32_t Level, int32_t Internalformat, int32_t Width, int32_t Height, int32_t Border, uint32_t Format, uint32_t Type, TexturePointer Data)
                : mextras(extras)
                , mTarget(Target)
                , mLevel(Level)
                , mInternalformat(Internalformat)
                , mWidth(Width)
                , mHeight(Height)
                , mBorder(Border)
                , mFormat(Format)
                , mType(Type)
                , mData(Data) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        int32_t mLevel;
        int32_t mInternalformat;
        int32_t mWidth;
        int32_t mHeight;
        int32_t mBorder;
        uint32_t mFormat;
        uint32_t mType;
        TexturePointer mData;
    };

    class GlTexImage3D: public Encodable {
    public:
        GlTexImage3D() = default;
        GlTexImage3D(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, int32_t Level, int32_t Internalformat, int32_t Width, int32_t Height, int32_t Depth, int32_t Border, uint32_t Format, uint32_t Type, TexturePointer Data)
                : mextras(extras)
                , mTarget(Target)
                , mLevel(Level)
                , mInternalformat(Internalformat)
                , mWidth(Width)
                , mHeight(Height)
                , mDepth(Depth)
                , mBorder(Border)
                , mFormat(Format)
                , mType(Type)
                , mData(Data) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        int32_t mLevel;
        int32_t mInternalformat;
        int32_t mWidth;
        int32_t mHeight;
        int32_t mDepth;
        int32_t mBorder;
        uint32_t mFormat;
        uint32_t mType;
        TexturePointer mData;
    };

    class GlTexImage3DOES: public Encodable {
    public:
        GlTexImage3DOES() = default;
        GlTexImage3DOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, int32_t Level, uint32_t Internalformat, int32_t Width, int32_t Height, int32_t Depth, int32_t Border, uint32_t Format, uint32_t Type, TexturePointer Pixels)
                : mextras(extras)
                , mTarget(Target)
                , mLevel(Level)
                , mInternalformat(Internalformat)
                , mWidth(Width)
                , mHeight(Height)
                , mDepth(Depth)
                , mBorder(Border)
                , mFormat(Format)
                , mType(Type)
                , mPixels(Pixels) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        int32_t mLevel;
        uint32_t mInternalformat;
        int32_t mWidth;
        int32_t mHeight;
        int32_t mDepth;
        int32_t mBorder;
        uint32_t mFormat;
        uint32_t mType;
        TexturePointer mPixels;
    };

    class GlTexPageCommitmentEXT: public Encodable {
    public:
        GlTexPageCommitmentEXT() = default;
        GlTexPageCommitmentEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, int32_t Level, int32_t Xoffset, int32_t Yoffset, int32_t Zoffset, int32_t Width, int32_t Height, int32_t Depth, uint8_t Commit)
                : mextras(extras)
                , mTarget(Target)
                , mLevel(Level)
                , mXoffset(Xoffset)
                , mYoffset(Yoffset)
                , mZoffset(Zoffset)
                , mWidth(Width)
                , mHeight(Height)
                , mDepth(Depth)
                , mCommit(Commit) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        int32_t mLevel;
        int32_t mXoffset;
        int32_t mYoffset;
        int32_t mZoffset;
        int32_t mWidth;
        int32_t mHeight;
        int32_t mDepth;
        uint8_t mCommit;
    };

    class GlTexParameterIiv: public Encodable {
    public:
        GlTexParameterIiv() = default;
        GlTexParameterIiv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Pname, GLint__CP Params)
                : mextras(extras)
                , mTarget(Target)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mPname;
        GLint__CP mParams;
    };

    class GlTexParameterIivEXT: public Encodable {
    public:
        GlTexParameterIivEXT() = default;
        GlTexParameterIivEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Pname, GLint__CP Params)
                : mextras(extras)
                , mTarget(Target)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mPname;
        GLint__CP mParams;
    };

    class GlTexParameterIivOES: public Encodable {
    public:
        GlTexParameterIivOES() = default;
        GlTexParameterIivOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Pname, GLint__CP Params)
                : mextras(extras)
                , mTarget(Target)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mPname;
        GLint__CP mParams;
    };

    class GlTexParameterIuiv: public Encodable {
    public:
        GlTexParameterIuiv() = default;
        GlTexParameterIuiv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Pname, GLuint__CP Params)
                : mextras(extras)
                , mTarget(Target)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mPname;
        GLuint__CP mParams;
    };

    class GlTexParameterIuivEXT: public Encodable {
    public:
        GlTexParameterIuivEXT() = default;
        GlTexParameterIuivEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Pname, GLuint__CP Params)
                : mextras(extras)
                , mTarget(Target)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mPname;
        GLuint__CP mParams;
    };

    class GlTexParameterIuivOES: public Encodable {
    public:
        GlTexParameterIuivOES() = default;
        GlTexParameterIuivOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Pname, GLuint__CP Params)
                : mextras(extras)
                , mTarget(Target)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mPname;
        GLuint__CP mParams;
    };

    class GlTexParameterf: public Encodable {
    public:
        GlTexParameterf() = default;
        GlTexParameterf(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Parameter, float Value)
                : mextras(extras)
                , mTarget(Target)
                , mParameter(Parameter)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mParameter;
        float mValue;
    };

    class GlTexParameterfv: public Encodable {
    public:
        GlTexParameterfv() = default;
        GlTexParameterfv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Pname, GLfloat__CP Params)
                : mextras(extras)
                , mTarget(Target)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mPname;
        GLfloat__CP mParams;
    };

    class GlTexParameteri: public Encodable {
    public:
        GlTexParameteri() = default;
        GlTexParameteri(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Parameter, int32_t Value)
                : mextras(extras)
                , mTarget(Target)
                , mParameter(Parameter)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mParameter;
        int32_t mValue;
    };

    class GlTexParameteriv: public Encodable {
    public:
        GlTexParameteriv() = default;
        GlTexParameteriv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Pname, GLint__CP Params)
                : mextras(extras)
                , mTarget(Target)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mPname;
        GLint__CP mParams;
    };

    class GlTexParameterx: public Encodable {
    public:
        GlTexParameterx() = default;
        GlTexParameterx(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Pname, int32_t Param)
                : mextras(extras)
                , mTarget(Target)
                , mPname(Pname)
                , mParam(Param) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mPname;
        int32_t mParam;
    };

    class GlTexParameterxOES: public Encodable {
    public:
        GlTexParameterxOES() = default;
        GlTexParameterxOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Pname, int32_t Param)
                : mextras(extras)
                , mTarget(Target)
                , mPname(Pname)
                , mParam(Param) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mPname;
        int32_t mParam;
    };

    class GlTexParameterxv: public Encodable {
    public:
        GlTexParameterxv() = default;
        GlTexParameterxv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Pname, GLfixed__CP Params)
                : mextras(extras)
                , mTarget(Target)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mPname;
        GLfixed__CP mParams;
    };

    class GlTexParameterxvOES: public Encodable {
    public:
        GlTexParameterxvOES() = default;
        GlTexParameterxvOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint32_t Pname, GLfixed__CP Params)
                : mextras(extras)
                , mTarget(Target)
                , mPname(Pname)
                , mParams(Params) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint32_t mPname;
        GLfixed__CP mParams;
    };

    class GlTexStorage1D: public Encodable {
    public:
        GlTexStorage1D() = default;
        GlTexStorage1D(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, int32_t Levels, uint32_t Internalformat, int32_t Width)
                : mextras(extras)
                , mTarget(Target)
                , mLevels(Levels)
                , mInternalformat(Internalformat)
                , mWidth(Width) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        int32_t mLevels;
        uint32_t mInternalformat;
        int32_t mWidth;
    };

    class GlTexStorage1DEXT: public Encodable {
    public:
        GlTexStorage1DEXT() = default;
        GlTexStorage1DEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, int32_t Levels, uint32_t Internalformat, int32_t Width)
                : mextras(extras)
                , mTarget(Target)
                , mLevels(Levels)
                , mInternalformat(Internalformat)
                , mWidth(Width) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        int32_t mLevels;
        uint32_t mInternalformat;
        int32_t mWidth;
    };

    class GlTexStorage2D: public Encodable {
    public:
        GlTexStorage2D() = default;
        GlTexStorage2D(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, int32_t Levels, uint32_t Internalformat, int32_t Width, int32_t Height)
                : mextras(extras)
                , mTarget(Target)
                , mLevels(Levels)
                , mInternalformat(Internalformat)
                , mWidth(Width)
                , mHeight(Height) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        int32_t mLevels;
        uint32_t mInternalformat;
        int32_t mWidth;
        int32_t mHeight;
    };

    class GlTexStorage2DEXT: public Encodable {
    public:
        GlTexStorage2DEXT() = default;
        GlTexStorage2DEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, int32_t Levels, uint32_t Internalformat, int32_t Width, int32_t Height)
                : mextras(extras)
                , mTarget(Target)
                , mLevels(Levels)
                , mInternalformat(Internalformat)
                , mWidth(Width)
                , mHeight(Height) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        int32_t mLevels;
        uint32_t mInternalformat;
        int32_t mWidth;
        int32_t mHeight;
    };

    class GlTexStorage2DMultisample: public Encodable {
    public:
        GlTexStorage2DMultisample() = default;
        GlTexStorage2DMultisample(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, int32_t Samples, uint32_t Internalformat, int32_t Width, int32_t Height, uint8_t Fixedsamplelocations)
                : mextras(extras)
                , mTarget(Target)
                , mSamples(Samples)
                , mInternalformat(Internalformat)
                , mWidth(Width)
                , mHeight(Height)
                , mFixedsamplelocations(Fixedsamplelocations) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        int32_t mSamples;
        uint32_t mInternalformat;
        int32_t mWidth;
        int32_t mHeight;
        uint8_t mFixedsamplelocations;
    };

    class GlTexStorage3D: public Encodable {
    public:
        GlTexStorage3D() = default;
        GlTexStorage3D(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, int32_t Levels, uint32_t Internalformat, int32_t Width, int32_t Height, int32_t Depth)
                : mextras(extras)
                , mTarget(Target)
                , mLevels(Levels)
                , mInternalformat(Internalformat)
                , mWidth(Width)
                , mHeight(Height)
                , mDepth(Depth) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        int32_t mLevels;
        uint32_t mInternalformat;
        int32_t mWidth;
        int32_t mHeight;
        int32_t mDepth;
    };

    class GlTexStorage3DEXT: public Encodable {
    public:
        GlTexStorage3DEXT() = default;
        GlTexStorage3DEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, int32_t Levels, uint32_t Internalformat, int32_t Width, int32_t Height, int32_t Depth)
                : mextras(extras)
                , mTarget(Target)
                , mLevels(Levels)
                , mInternalformat(Internalformat)
                , mWidth(Width)
                , mHeight(Height)
                , mDepth(Depth) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        int32_t mLevels;
        uint32_t mInternalformat;
        int32_t mWidth;
        int32_t mHeight;
        int32_t mDepth;
    };

    class GlTexStorage3DMultisample: public Encodable {
    public:
        GlTexStorage3DMultisample() = default;
        GlTexStorage3DMultisample(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, int32_t Samples, uint32_t Internalformat, int32_t Width, int32_t Height, int32_t Depth, uint8_t Fixedsamplelocations)
                : mextras(extras)
                , mTarget(Target)
                , mSamples(Samples)
                , mInternalformat(Internalformat)
                , mWidth(Width)
                , mHeight(Height)
                , mDepth(Depth)
                , mFixedsamplelocations(Fixedsamplelocations) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        int32_t mSamples;
        uint32_t mInternalformat;
        int32_t mWidth;
        int32_t mHeight;
        int32_t mDepth;
        uint8_t mFixedsamplelocations;
    };

    class GlTexStorage3DMultisampleOES: public Encodable {
    public:
        GlTexStorage3DMultisampleOES() = default;
        GlTexStorage3DMultisampleOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, int32_t Samples, uint32_t Internalformat, int32_t Width, int32_t Height, int32_t Depth, uint8_t Fixedsamplelocations)
                : mextras(extras)
                , mTarget(Target)
                , mSamples(Samples)
                , mInternalformat(Internalformat)
                , mWidth(Width)
                , mHeight(Height)
                , mDepth(Depth)
                , mFixedsamplelocations(Fixedsamplelocations) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        int32_t mSamples;
        uint32_t mInternalformat;
        int32_t mWidth;
        int32_t mHeight;
        int32_t mDepth;
        uint8_t mFixedsamplelocations;
    };

    class GlTexSubImage2D: public Encodable {
    public:
        GlTexSubImage2D() = default;
        GlTexSubImage2D(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, int32_t Level, int32_t Xoffset, int32_t Yoffset, int32_t Width, int32_t Height, uint32_t Format, uint32_t Type, TexturePointer Data)
                : mextras(extras)
                , mTarget(Target)
                , mLevel(Level)
                , mXoffset(Xoffset)
                , mYoffset(Yoffset)
                , mWidth(Width)
                , mHeight(Height)
                , mFormat(Format)
                , mType(Type)
                , mData(Data) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        int32_t mLevel;
        int32_t mXoffset;
        int32_t mYoffset;
        int32_t mWidth;
        int32_t mHeight;
        uint32_t mFormat;
        uint32_t mType;
        TexturePointer mData;
    };

    class GlTexSubImage3D: public Encodable {
    public:
        GlTexSubImage3D() = default;
        GlTexSubImage3D(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, int32_t Level, int32_t Xoffset, int32_t Yoffset, int32_t Zoffset, int32_t Width, int32_t Height, int32_t Depth, uint32_t Format, uint32_t Type, TexturePointer Data)
                : mextras(extras)
                , mTarget(Target)
                , mLevel(Level)
                , mXoffset(Xoffset)
                , mYoffset(Yoffset)
                , mZoffset(Zoffset)
                , mWidth(Width)
                , mHeight(Height)
                , mDepth(Depth)
                , mFormat(Format)
                , mType(Type)
                , mData(Data) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        int32_t mLevel;
        int32_t mXoffset;
        int32_t mYoffset;
        int32_t mZoffset;
        int32_t mWidth;
        int32_t mHeight;
        int32_t mDepth;
        uint32_t mFormat;
        uint32_t mType;
        TexturePointer mData;
    };

    class GlTexSubImage3DOES: public Encodable {
    public:
        GlTexSubImage3DOES() = default;
        GlTexSubImage3DOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, int32_t Level, int32_t Xoffset, int32_t Yoffset, int32_t Zoffset, int32_t Width, int32_t Height, int32_t Depth, uint32_t Format, uint32_t Type, TexturePointer Pixels)
                : mextras(extras)
                , mTarget(Target)
                , mLevel(Level)
                , mXoffset(Xoffset)
                , mYoffset(Yoffset)
                , mZoffset(Zoffset)
                , mWidth(Width)
                , mHeight(Height)
                , mDepth(Depth)
                , mFormat(Format)
                , mType(Type)
                , mPixels(Pixels) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        int32_t mLevel;
        int32_t mXoffset;
        int32_t mYoffset;
        int32_t mZoffset;
        int32_t mWidth;
        int32_t mHeight;
        int32_t mDepth;
        uint32_t mFormat;
        uint32_t mType;
        TexturePointer mPixels;
    };

    class GlTextureStorage1DEXT: public Encodable {
    public:
        GlTextureStorage1DEXT() = default;
        GlTextureStorage1DEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Texture, uint32_t Target, int32_t Levels, uint32_t Internalformat, int32_t Width)
                : mextras(extras)
                , mTexture(Texture)
                , mTarget(Target)
                , mLevels(Levels)
                , mInternalformat(Internalformat)
                , mWidth(Width) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTexture;
        uint32_t mTarget;
        int32_t mLevels;
        uint32_t mInternalformat;
        int32_t mWidth;
    };

    class GlTextureStorage2DEXT: public Encodable {
    public:
        GlTextureStorage2DEXT() = default;
        GlTextureStorage2DEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Texture, uint32_t Target, int32_t Levels, uint32_t Internalformat, int32_t Width, int32_t Height)
                : mextras(extras)
                , mTexture(Texture)
                , mTarget(Target)
                , mLevels(Levels)
                , mInternalformat(Internalformat)
                , mWidth(Width)
                , mHeight(Height) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTexture;
        uint32_t mTarget;
        int32_t mLevels;
        uint32_t mInternalformat;
        int32_t mWidth;
        int32_t mHeight;
    };

    class GlTextureStorage3DEXT: public Encodable {
    public:
        GlTextureStorage3DEXT() = default;
        GlTextureStorage3DEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Texture, uint32_t Target, int32_t Levels, uint32_t Internalformat, int32_t Width, int32_t Height, int32_t Depth)
                : mextras(extras)
                , mTexture(Texture)
                , mTarget(Target)
                , mLevels(Levels)
                , mInternalformat(Internalformat)
                , mWidth(Width)
                , mHeight(Height)
                , mDepth(Depth) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTexture;
        uint32_t mTarget;
        int32_t mLevels;
        uint32_t mInternalformat;
        int32_t mWidth;
        int32_t mHeight;
        int32_t mDepth;
    };

    class GlTextureViewEXT: public Encodable {
    public:
        GlTextureViewEXT() = default;
        GlTextureViewEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Texture, uint32_t Target, uint32_t Origtexture, uint32_t Internalformat, uint32_t Minlevel, uint32_t Numlevels, uint32_t Minlayer, uint32_t Numlayers)
                : mextras(extras)
                , mTexture(Texture)
                , mTarget(Target)
                , mOrigtexture(Origtexture)
                , mInternalformat(Internalformat)
                , mMinlevel(Minlevel)
                , mNumlevels(Numlevels)
                , mMinlayer(Minlayer)
                , mNumlayers(Numlayers) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTexture;
        uint32_t mTarget;
        uint32_t mOrigtexture;
        uint32_t mInternalformat;
        uint32_t mMinlevel;
        uint32_t mNumlevels;
        uint32_t mMinlayer;
        uint32_t mNumlayers;
    };

    class GlTextureViewOES: public Encodable {
    public:
        GlTextureViewOES() = default;
        GlTextureViewOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Texture, uint32_t Target, uint32_t Origtexture, uint32_t Internalformat, uint32_t Minlevel, uint32_t Numlevels, uint32_t Minlayer, uint32_t Numlayers)
                : mextras(extras)
                , mTexture(Texture)
                , mTarget(Target)
                , mOrigtexture(Origtexture)
                , mInternalformat(Internalformat)
                , mMinlevel(Minlevel)
                , mNumlevels(Numlevels)
                , mMinlayer(Minlayer)
                , mNumlayers(Numlayers) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTexture;
        uint32_t mTarget;
        uint32_t mOrigtexture;
        uint32_t mInternalformat;
        uint32_t mMinlevel;
        uint32_t mNumlevels;
        uint32_t mMinlayer;
        uint32_t mNumlayers;
    };

    class GlTransformFeedbackVaryings: public Encodable {
    public:
        GlTransformFeedbackVaryings() = default;
        GlTransformFeedbackVaryings(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, int32_t Count, GLchar__CP__CP Varyings, uint32_t BufferMode)
                : mextras(extras)
                , mProgram(Program)
                , mCount(Count)
                , mVaryings(Varyings)
                , mBufferMode(BufferMode) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        int32_t mCount;
        GLchar__CP__CP mVaryings;
        uint32_t mBufferMode;
    };

    class GlTransformPathNV: public Encodable {
    public:
        GlTransformPathNV() = default;
        GlTransformPathNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t ResultPath, uint32_t SrcPath, uint32_t TransformType, GLfloat__CP TransformValues)
                : mextras(extras)
                , mResultPath(ResultPath)
                , mSrcPath(SrcPath)
                , mTransformType(TransformType)
                , mTransformValues(TransformValues) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mResultPath;
        uint32_t mSrcPath;
        uint32_t mTransformType;
        GLfloat__CP mTransformValues;
    };

    class GlTranslatef: public Encodable {
    public:
        GlTranslatef() = default;
        GlTranslatef(const gapic::Vector<gapic::Encodable*>& extras, float X, float Y, float Z)
                : mextras(extras)
                , mX(X)
                , mY(Y)
                , mZ(Z) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        float mX;
        float mY;
        float mZ;
    };

    class GlTranslatex: public Encodable {
    public:
        GlTranslatex() = default;
        GlTranslatex(const gapic::Vector<gapic::Encodable*>& extras, int32_t X, int32_t Y, int32_t Z)
                : mextras(extras)
                , mX(X)
                , mY(Y)
                , mZ(Z) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mX;
        int32_t mY;
        int32_t mZ;
    };

    class GlTranslatexOES: public Encodable {
    public:
        GlTranslatexOES() = default;
        GlTranslatexOES(const gapic::Vector<gapic::Encodable*>& extras, int32_t X, int32_t Y, int32_t Z)
                : mextras(extras)
                , mX(X)
                , mY(Y)
                , mZ(Z) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mX;
        int32_t mY;
        int32_t mZ;
    };

    class GlUniform1f: public Encodable {
    public:
        GlUniform1f() = default;
        GlUniform1f(const gapic::Vector<gapic::Encodable*>& extras, int32_t Location, float Value)
                : mextras(extras)
                , mLocation(Location)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int32(this->mLocation);
            e->Float32(this->mValue);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mLocation;
        float mValue;
    };

    class GlUniform1fv: public Encodable {
    public:
        GlUniform1fv() = default;
        GlUniform1fv(const gapic::Vector<gapic::Encodable*>& extras, int32_t Location, int32_t Count, GLfloat__CP Values)
                : mextras(extras)
                , mLocation(Location)
                , mCount(Count)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mLocation;
        int32_t mCount;
        GLfloat__CP mValues;
    };

    class GlUniform1i: public Encodable {
    public:
        GlUniform1i() = default;
        GlUniform1i(const gapic::Vector<gapic::Encodable*>& extras, int32_t Location, int32_t Value)
                : mextras(extras)
                , mLocation(Location)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int32(this->mLocation);
            e->Int32(this->mValue);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mLocation;
        int32_t mValue;
    };

    class GlUniform1iv: public Encodable {
    public:
        GlUniform1iv() = default;
        GlUniform1iv(const gapic::Vector<gapic::Encodable*>& extras, int32_t Location, int32_t Count, GLint__CP Values)
                : mextras(extras)
                , mLocation(Location)
                , mCount(Count)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mLocation;
        int32_t mCount;
        GLint__CP mValues;
    };

    class GlUniform1ui: public Encodable {
    public:
        GlUniform1ui() = default;
        GlUniform1ui(const gapic::Vector<gapic::Encodable*>& extras, int32_t Location, uint32_t Value0)
                : mextras(extras)
                , mLocation(Location)
                , mValue0(Value0) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int32(this->mLocation);
            e->Uint32(this->mValue0);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mLocation;
        uint32_t mValue0;
    };

    class GlUniform1uiv: public Encodable {
    public:
        GlUniform1uiv() = default;
        GlUniform1uiv(const gapic::Vector<gapic::Encodable*>& extras, int32_t Location, int32_t Count, GLuint__CP Values)
                : mextras(extras)
                , mLocation(Location)
                , mCount(Count)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mLocation;
        int32_t mCount;
        GLuint__CP mValues;
    };

    class GlUniform2f: public Encodable {
    public:
        GlUniform2f() = default;
        GlUniform2f(const gapic::Vector<gapic::Encodable*>& extras, int32_t Location, float Value0, float Value1)
                : mextras(extras)
                , mLocation(Location)
                , mValue0(Value0)
                , mValue1(Value1) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mLocation;
        float mValue0;
        float mValue1;
    };

    class GlUniform2fv: public Encodable {
    public:
        GlUniform2fv() = default;
        GlUniform2fv(const gapic::Vector<gapic::Encodable*>& extras, int32_t Location, int32_t Count, GLfloat__CP Values)
                : mextras(extras)
                , mLocation(Location)
                , mCount(Count)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mLocation;
        int32_t mCount;
        GLfloat__CP mValues;
    };

    class GlUniform2i: public Encodable {
    public:
        GlUniform2i() = default;
        GlUniform2i(const gapic::Vector<gapic::Encodable*>& extras, int32_t Location, int32_t Value0, int32_t Value1)
                : mextras(extras)
                , mLocation(Location)
                , mValue0(Value0)
                , mValue1(Value1) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mLocation;
        int32_t mValue0;
        int32_t mValue1;
    };

    class GlUniform2iv: public Encodable {
    public:
        GlUniform2iv() = default;
        GlUniform2iv(const gapic::Vector<gapic::Encodable*>& extras, int32_t Location, int32_t Count, GLint__CP Values)
                : mextras(extras)
                , mLocation(Location)
                , mCount(Count)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mLocation;
        int32_t mCount;
        GLint__CP mValues;
    };

    class GlUniform2ui: public Encodable {
    public:
        GlUniform2ui() = default;
        GlUniform2ui(const gapic::Vector<gapic::Encodable*>& extras, int32_t Location, uint32_t Value0, uint32_t Value1)
                : mextras(extras)
                , mLocation(Location)
                , mValue0(Value0)
                , mValue1(Value1) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mLocation;
        uint32_t mValue0;
        uint32_t mValue1;
    };

    class GlUniform2uiv: public Encodable {
    public:
        GlUniform2uiv() = default;
        GlUniform2uiv(const gapic::Vector<gapic::Encodable*>& extras, int32_t Location, int32_t Count, GLuint__CP Values)
                : mextras(extras)
                , mLocation(Location)
                , mCount(Count)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mLocation;
        int32_t mCount;
        GLuint__CP mValues;
    };

    class GlUniform3f: public Encodable {
    public:
        GlUniform3f() = default;
        GlUniform3f(const gapic::Vector<gapic::Encodable*>& extras, int32_t Location, float Value0, float Value1, float Value2)
                : mextras(extras)
                , mLocation(Location)
                , mValue0(Value0)
                , mValue1(Value1)
                , mValue2(Value2) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mLocation;
        float mValue0;
        float mValue1;
        float mValue2;
    };

    class GlUniform3fv: public Encodable {
    public:
        GlUniform3fv() = default;
        GlUniform3fv(const gapic::Vector<gapic::Encodable*>& extras, int32_t Location, int32_t Count, GLfloat__CP Values)
                : mextras(extras)
                , mLocation(Location)
                , mCount(Count)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mLocation;
        int32_t mCount;
        GLfloat__CP mValues;
    };

    class GlUniform3i: public Encodable {
    public:
        GlUniform3i() = default;
        GlUniform3i(const gapic::Vector<gapic::Encodable*>& extras, int32_t Location, int32_t Value0, int32_t Value1, int32_t Value2)
                : mextras(extras)
                , mLocation(Location)
                , mValue0(Value0)
                , mValue1(Value1)
                , mValue2(Value2) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mLocation;
        int32_t mValue0;
        int32_t mValue1;
        int32_t mValue2;
    };

    class GlUniform3iv: public Encodable {
    public:
        GlUniform3iv() = default;
        GlUniform3iv(const gapic::Vector<gapic::Encodable*>& extras, int32_t Location, int32_t Count, GLint__CP Values)
                : mextras(extras)
                , mLocation(Location)
                , mCount(Count)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mLocation;
        int32_t mCount;
        GLint__CP mValues;
    };

    class GlUniform3ui: public Encodable {
    public:
        GlUniform3ui() = default;
        GlUniform3ui(const gapic::Vector<gapic::Encodable*>& extras, int32_t Location, uint32_t Value0, uint32_t Value1, uint32_t Value2)
                : mextras(extras)
                , mLocation(Location)
                , mValue0(Value0)
                , mValue1(Value1)
                , mValue2(Value2) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mLocation;
        uint32_t mValue0;
        uint32_t mValue1;
        uint32_t mValue2;
    };

    class GlUniform3uiv: public Encodable {
    public:
        GlUniform3uiv() = default;
        GlUniform3uiv(const gapic::Vector<gapic::Encodable*>& extras, int32_t Location, int32_t Count, GLuint__CP Values)
                : mextras(extras)
                , mLocation(Location)
                , mCount(Count)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mLocation;
        int32_t mCount;
        GLuint__CP mValues;
    };

    class GlUniform4f: public Encodable {
    public:
        GlUniform4f() = default;
        GlUniform4f(const gapic::Vector<gapic::Encodable*>& extras, int32_t Location, float Value0, float Value1, float Value2, float Value3)
                : mextras(extras)
                , mLocation(Location)
                , mValue0(Value0)
                , mValue1(Value1)
                , mValue2(Value2)
                , mValue3(Value3) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mLocation;
        float mValue0;
        float mValue1;
        float mValue2;
        float mValue3;
    };

    class GlUniform4fv: public Encodable {
    public:
        GlUniform4fv() = default;
        GlUniform4fv(const gapic::Vector<gapic::Encodable*>& extras, int32_t Location, int32_t Count, GLfloat__CP Values)
                : mextras(extras)
                , mLocation(Location)
                , mCount(Count)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mLocation;
        int32_t mCount;
        GLfloat__CP mValues;
    };

    class GlUniform4i: public Encodable {
    public:
        GlUniform4i() = default;
        GlUniform4i(const gapic::Vector<gapic::Encodable*>& extras, int32_t Location, int32_t Value0, int32_t Value1, int32_t Value2, int32_t Value3)
                : mextras(extras)
                , mLocation(Location)
                , mValue0(Value0)
                , mValue1(Value1)
                , mValue2(Value2)
                , mValue3(Value3) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mLocation;
        int32_t mValue0;
        int32_t mValue1;
        int32_t mValue2;
        int32_t mValue3;
    };

    class GlUniform4iv: public Encodable {
    public:
        GlUniform4iv() = default;
        GlUniform4iv(const gapic::Vector<gapic::Encodable*>& extras, int32_t Location, int32_t Count, GLint__CP Values)
                : mextras(extras)
                , mLocation(Location)
                , mCount(Count)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mLocation;
        int32_t mCount;
        GLint__CP mValues;
    };

    class GlUniform4ui: public Encodable {
    public:
        GlUniform4ui() = default;
        GlUniform4ui(const gapic::Vector<gapic::Encodable*>& extras, int32_t Location, uint32_t Value0, uint32_t Value1, uint32_t Value2, uint32_t Value3)
                : mextras(extras)
                , mLocation(Location)
                , mValue0(Value0)
                , mValue1(Value1)
                , mValue2(Value2)
                , mValue3(Value3) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mLocation;
        uint32_t mValue0;
        uint32_t mValue1;
        uint32_t mValue2;
        uint32_t mValue3;
    };

    class GlUniform4uiv: public Encodable {
    public:
        GlUniform4uiv() = default;
        GlUniform4uiv(const gapic::Vector<gapic::Encodable*>& extras, int32_t Location, int32_t Count, GLuint__CP Values)
                : mextras(extras)
                , mLocation(Location)
                , mCount(Count)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mLocation;
        int32_t mCount;
        GLuint__CP mValues;
    };

    class GlUniformBlockBinding: public Encodable {
    public:
        GlUniformBlockBinding() = default;
        GlUniformBlockBinding(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program, uint32_t UniformBlockIndex, uint32_t UniformBlockBinding)
                : mextras(extras)
                , mProgram(Program)
                , mUniformBlockIndex(UniformBlockIndex)
                , mUniformBlockBinding(UniformBlockBinding) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
        uint32_t mUniformBlockIndex;
        uint32_t mUniformBlockBinding;
    };

    class GlUniformHandleui64NV: public Encodable {
    public:
        GlUniformHandleui64NV() = default;
        GlUniformHandleui64NV(const gapic::Vector<gapic::Encodable*>& extras, int32_t Location, uint64_t Value)
                : mextras(extras)
                , mLocation(Location)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Int32(this->mLocation);
            e->Uint64(this->mValue);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mLocation;
        uint64_t mValue;
    };

    class GlUniformHandleui64vNV: public Encodable {
    public:
        GlUniformHandleui64vNV() = default;
        GlUniformHandleui64vNV(const gapic::Vector<gapic::Encodable*>& extras, int32_t Location, int32_t Count, GLuint64__CP Value)
                : mextras(extras)
                , mLocation(Location)
                , mCount(Count)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mLocation;
        int32_t mCount;
        GLuint64__CP mValue;
    };

    class GlUniformMatrix2fv: public Encodable {
    public:
        GlUniformMatrix2fv() = default;
        GlUniformMatrix2fv(const gapic::Vector<gapic::Encodable*>& extras, int32_t Location, int32_t Count, uint8_t Transpose, GLfloat__CP Values)
                : mextras(extras)
                , mLocation(Location)
                , mCount(Count)
                , mTranspose(Transpose)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mLocation;
        int32_t mCount;
        uint8_t mTranspose;
        GLfloat__CP mValues;
    };

    class GlUniformMatrix2x3fv: public Encodable {
    public:
        GlUniformMatrix2x3fv() = default;
        GlUniformMatrix2x3fv(const gapic::Vector<gapic::Encodable*>& extras, int32_t Location, int32_t Count, uint8_t Transpose, GLfloat__CP Values)
                : mextras(extras)
                , mLocation(Location)
                , mCount(Count)
                , mTranspose(Transpose)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mLocation;
        int32_t mCount;
        uint8_t mTranspose;
        GLfloat__CP mValues;
    };

    class GlUniformMatrix2x3fvNV: public Encodable {
    public:
        GlUniformMatrix2x3fvNV() = default;
        GlUniformMatrix2x3fvNV(const gapic::Vector<gapic::Encodable*>& extras, int32_t Location, int32_t Count, uint8_t Transpose, GLfloat__CP Value)
                : mextras(extras)
                , mLocation(Location)
                , mCount(Count)
                , mTranspose(Transpose)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mLocation;
        int32_t mCount;
        uint8_t mTranspose;
        GLfloat__CP mValue;
    };

    class GlUniformMatrix2x4fv: public Encodable {
    public:
        GlUniformMatrix2x4fv() = default;
        GlUniformMatrix2x4fv(const gapic::Vector<gapic::Encodable*>& extras, int32_t Location, int32_t Count, uint8_t Transpose, GLfloat__CP Values)
                : mextras(extras)
                , mLocation(Location)
                , mCount(Count)
                , mTranspose(Transpose)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mLocation;
        int32_t mCount;
        uint8_t mTranspose;
        GLfloat__CP mValues;
    };

    class GlUniformMatrix2x4fvNV: public Encodable {
    public:
        GlUniformMatrix2x4fvNV() = default;
        GlUniformMatrix2x4fvNV(const gapic::Vector<gapic::Encodable*>& extras, int32_t Location, int32_t Count, uint8_t Transpose, GLfloat__CP Value)
                : mextras(extras)
                , mLocation(Location)
                , mCount(Count)
                , mTranspose(Transpose)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mLocation;
        int32_t mCount;
        uint8_t mTranspose;
        GLfloat__CP mValue;
    };

    class GlUniformMatrix3fv: public Encodable {
    public:
        GlUniformMatrix3fv() = default;
        GlUniformMatrix3fv(const gapic::Vector<gapic::Encodable*>& extras, int32_t Location, int32_t Count, uint8_t Transpose, GLfloat__CP Values)
                : mextras(extras)
                , mLocation(Location)
                , mCount(Count)
                , mTranspose(Transpose)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mLocation;
        int32_t mCount;
        uint8_t mTranspose;
        GLfloat__CP mValues;
    };

    class GlUniformMatrix3x2fv: public Encodable {
    public:
        GlUniformMatrix3x2fv() = default;
        GlUniformMatrix3x2fv(const gapic::Vector<gapic::Encodable*>& extras, int32_t Location, int32_t Count, uint8_t Transpose, GLfloat__CP Values)
                : mextras(extras)
                , mLocation(Location)
                , mCount(Count)
                , mTranspose(Transpose)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mLocation;
        int32_t mCount;
        uint8_t mTranspose;
        GLfloat__CP mValues;
    };

    class GlUniformMatrix3x2fvNV: public Encodable {
    public:
        GlUniformMatrix3x2fvNV() = default;
        GlUniformMatrix3x2fvNV(const gapic::Vector<gapic::Encodable*>& extras, int32_t Location, int32_t Count, uint8_t Transpose, GLfloat__CP Value)
                : mextras(extras)
                , mLocation(Location)
                , mCount(Count)
                , mTranspose(Transpose)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mLocation;
        int32_t mCount;
        uint8_t mTranspose;
        GLfloat__CP mValue;
    };

    class GlUniformMatrix3x4fv: public Encodable {
    public:
        GlUniformMatrix3x4fv() = default;
        GlUniformMatrix3x4fv(const gapic::Vector<gapic::Encodable*>& extras, int32_t Location, int32_t Count, uint8_t Transpose, GLfloat__CP Values)
                : mextras(extras)
                , mLocation(Location)
                , mCount(Count)
                , mTranspose(Transpose)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mLocation;
        int32_t mCount;
        uint8_t mTranspose;
        GLfloat__CP mValues;
    };

    class GlUniformMatrix3x4fvNV: public Encodable {
    public:
        GlUniformMatrix3x4fvNV() = default;
        GlUniformMatrix3x4fvNV(const gapic::Vector<gapic::Encodable*>& extras, int32_t Location, int32_t Count, uint8_t Transpose, GLfloat__CP Value)
                : mextras(extras)
                , mLocation(Location)
                , mCount(Count)
                , mTranspose(Transpose)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mLocation;
        int32_t mCount;
        uint8_t mTranspose;
        GLfloat__CP mValue;
    };

    class GlUniformMatrix4fv: public Encodable {
    public:
        GlUniformMatrix4fv() = default;
        GlUniformMatrix4fv(const gapic::Vector<gapic::Encodable*>& extras, int32_t Location, int32_t Count, uint8_t Transpose, GLfloat__CP Values)
                : mextras(extras)
                , mLocation(Location)
                , mCount(Count)
                , mTranspose(Transpose)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mLocation;
        int32_t mCount;
        uint8_t mTranspose;
        GLfloat__CP mValues;
    };

    class GlUniformMatrix4x2fv: public Encodable {
    public:
        GlUniformMatrix4x2fv() = default;
        GlUniformMatrix4x2fv(const gapic::Vector<gapic::Encodable*>& extras, int32_t Location, int32_t Count, uint8_t Transpose, GLfloat__CP Values)
                : mextras(extras)
                , mLocation(Location)
                , mCount(Count)
                , mTranspose(Transpose)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mLocation;
        int32_t mCount;
        uint8_t mTranspose;
        GLfloat__CP mValues;
    };

    class GlUniformMatrix4x2fvNV: public Encodable {
    public:
        GlUniformMatrix4x2fvNV() = default;
        GlUniformMatrix4x2fvNV(const gapic::Vector<gapic::Encodable*>& extras, int32_t Location, int32_t Count, uint8_t Transpose, GLfloat__CP Value)
                : mextras(extras)
                , mLocation(Location)
                , mCount(Count)
                , mTranspose(Transpose)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mLocation;
        int32_t mCount;
        uint8_t mTranspose;
        GLfloat__CP mValue;
    };

    class GlUniformMatrix4x3fv: public Encodable {
    public:
        GlUniformMatrix4x3fv() = default;
        GlUniformMatrix4x3fv(const gapic::Vector<gapic::Encodable*>& extras, int32_t Location, int32_t Count, uint8_t Transpose, GLfloat__CP Values)
                : mextras(extras)
                , mLocation(Location)
                , mCount(Count)
                , mTranspose(Transpose)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mLocation;
        int32_t mCount;
        uint8_t mTranspose;
        GLfloat__CP mValues;
    };

    class GlUniformMatrix4x3fvNV: public Encodable {
    public:
        GlUniformMatrix4x3fvNV() = default;
        GlUniformMatrix4x3fvNV(const gapic::Vector<gapic::Encodable*>& extras, int32_t Location, int32_t Count, uint8_t Transpose, GLfloat__CP Value)
                : mextras(extras)
                , mLocation(Location)
                , mCount(Count)
                , mTranspose(Transpose)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mLocation;
        int32_t mCount;
        uint8_t mTranspose;
        GLfloat__CP mValue;
    };

    class GlUnmapBuffer: public Encodable {
    public:
        GlUnmapBuffer() = default;
        GlUnmapBuffer(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint8_t Result)
                : mextras(extras)
                , mTarget(Target)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mTarget);
            e->Uint8(this->mResult);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint8_t mResult;
    };

    class GlUnmapBufferOES: public Encodable {
    public:
        GlUnmapBufferOES() = default;
        GlUnmapBufferOES(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Target, uint8_t Result)
                : mextras(extras)
                , mTarget(Target)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mTarget);
            e->Uint8(this->mResult);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mTarget;
        uint8_t mResult;
    };

    class GlUseProgram: public Encodable {
    public:
        GlUseProgram() = default;
        GlUseProgram(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program)
                : mextras(extras)
                , mProgram(Program) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mProgram);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
    };

    class GlUseProgramStages: public Encodable {
    public:
        GlUseProgramStages() = default;
        GlUseProgramStages(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Pipeline, uint32_t Stages, uint32_t Program)
                : mextras(extras)
                , mPipeline(Pipeline)
                , mStages(Stages)
                , mProgram(Program) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPipeline;
        uint32_t mStages;
        uint32_t mProgram;
    };

    class GlUseProgramStagesEXT: public Encodable {
    public:
        GlUseProgramStagesEXT() = default;
        GlUseProgramStagesEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Pipeline, uint32_t Stages, uint32_t Program)
                : mextras(extras)
                , mPipeline(Pipeline)
                , mStages(Stages)
                , mProgram(Program) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPipeline;
        uint32_t mStages;
        uint32_t mProgram;
    };

    class GlValidateProgram: public Encodable {
    public:
        GlValidateProgram() = default;
        GlValidateProgram(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Program)
                : mextras(extras)
                , mProgram(Program) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mProgram);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mProgram;
    };

    class GlValidateProgramPipeline: public Encodable {
    public:
        GlValidateProgramPipeline() = default;
        GlValidateProgramPipeline(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Pipeline)
                : mextras(extras)
                , mPipeline(Pipeline) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mPipeline);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPipeline;
    };

    class GlValidateProgramPipelineEXT: public Encodable {
    public:
        GlValidateProgramPipelineEXT() = default;
        GlValidateProgramPipelineEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Pipeline)
                : mextras(extras)
                , mPipeline(Pipeline) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mPipeline);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mPipeline;
    };

    class GlVertexAttrib1f: public Encodable {
    public:
        GlVertexAttrib1f() = default;
        GlVertexAttrib1f(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Location, float Value0)
                : mextras(extras)
                , mLocation(Location)
                , mValue0(Value0) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mLocation);
            e->Float32(this->mValue0);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mLocation;
        float mValue0;
    };

    class GlVertexAttrib1fv: public Encodable {
    public:
        GlVertexAttrib1fv() = default;
        GlVertexAttrib1fv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Location, GLfloat__CP Value)
                : mextras(extras)
                , mLocation(Location)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mLocation);
            e->Struct(this->mValue);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mLocation;
        GLfloat__CP mValue;
    };

    class GlVertexAttrib2f: public Encodable {
    public:
        GlVertexAttrib2f() = default;
        GlVertexAttrib2f(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Location, float Value0, float Value1)
                : mextras(extras)
                , mLocation(Location)
                , mValue0(Value0)
                , mValue1(Value1) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mLocation;
        float mValue0;
        float mValue1;
    };

    class GlVertexAttrib2fv: public Encodable {
    public:
        GlVertexAttrib2fv() = default;
        GlVertexAttrib2fv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Location, GLfloat__CP Value)
                : mextras(extras)
                , mLocation(Location)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mLocation);
            e->Struct(this->mValue);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mLocation;
        GLfloat__CP mValue;
    };

    class GlVertexAttrib3f: public Encodable {
    public:
        GlVertexAttrib3f() = default;
        GlVertexAttrib3f(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Location, float Value0, float Value1, float Value2)
                : mextras(extras)
                , mLocation(Location)
                , mValue0(Value0)
                , mValue1(Value1)
                , mValue2(Value2) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mLocation;
        float mValue0;
        float mValue1;
        float mValue2;
    };

    class GlVertexAttrib3fv: public Encodable {
    public:
        GlVertexAttrib3fv() = default;
        GlVertexAttrib3fv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Location, GLfloat__CP Value)
                : mextras(extras)
                , mLocation(Location)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mLocation);
            e->Struct(this->mValue);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mLocation;
        GLfloat__CP mValue;
    };

    class GlVertexAttrib4f: public Encodable {
    public:
        GlVertexAttrib4f() = default;
        GlVertexAttrib4f(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Location, float Value0, float Value1, float Value2, float Value3)
                : mextras(extras)
                , mLocation(Location)
                , mValue0(Value0)
                , mValue1(Value1)
                , mValue2(Value2)
                , mValue3(Value3) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mLocation;
        float mValue0;
        float mValue1;
        float mValue2;
        float mValue3;
    };

    class GlVertexAttrib4fv: public Encodable {
    public:
        GlVertexAttrib4fv() = default;
        GlVertexAttrib4fv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Location, GLfloat__CP Value)
                : mextras(extras)
                , mLocation(Location)
                , mValue(Value) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mLocation);
            e->Struct(this->mValue);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mLocation;
        GLfloat__CP mValue;
    };

    class GlVertexAttribBinding: public Encodable {
    public:
        GlVertexAttribBinding() = default;
        GlVertexAttribBinding(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Index, uint32_t BindingIndex)
                : mextras(extras)
                , mIndex(Index)
                , mBindingIndex(BindingIndex) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mIndex);
            e->Uint32(this->mBindingIndex);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mIndex;
        uint32_t mBindingIndex;
    };

    class GlVertexAttribDivisor: public Encodable {
    public:
        GlVertexAttribDivisor() = default;
        GlVertexAttribDivisor(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Index, uint32_t Divisor)
                : mextras(extras)
                , mIndex(Index)
                , mDivisor(Divisor) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mIndex);
            e->Uint32(this->mDivisor);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mIndex;
        uint32_t mDivisor;
    };

    class GlVertexAttribDivisorANGLE: public Encodable {
    public:
        GlVertexAttribDivisorANGLE() = default;
        GlVertexAttribDivisorANGLE(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Index, uint32_t Divisor)
                : mextras(extras)
                , mIndex(Index)
                , mDivisor(Divisor) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mIndex);
            e->Uint32(this->mDivisor);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mIndex;
        uint32_t mDivisor;
    };

    class GlVertexAttribDivisorEXT: public Encodable {
    public:
        GlVertexAttribDivisorEXT() = default;
        GlVertexAttribDivisorEXT(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Index, uint32_t Divisor)
                : mextras(extras)
                , mIndex(Index)
                , mDivisor(Divisor) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mIndex);
            e->Uint32(this->mDivisor);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mIndex;
        uint32_t mDivisor;
    };

    class GlVertexAttribDivisorNV: public Encodable {
    public:
        GlVertexAttribDivisorNV() = default;
        GlVertexAttribDivisorNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Index, uint32_t Divisor)
                : mextras(extras)
                , mIndex(Index)
                , mDivisor(Divisor) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mIndex);
            e->Uint32(this->mDivisor);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mIndex;
        uint32_t mDivisor;
    };

    class GlVertexAttribFormat: public Encodable {
    public:
        GlVertexAttribFormat() = default;
        GlVertexAttribFormat(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Index, int32_t Size, uint32_t Type, uint8_t Normalized, uint32_t Relativeoffset)
                : mextras(extras)
                , mIndex(Index)
                , mSize(Size)
                , mType(Type)
                , mNormalized(Normalized)
                , mRelativeoffset(Relativeoffset) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mIndex;
        int32_t mSize;
        uint32_t mType;
        uint8_t mNormalized;
        uint32_t mRelativeoffset;
    };

    class GlVertexAttribI4i: public Encodable {
    public:
        GlVertexAttribI4i() = default;
        GlVertexAttribI4i(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Index, int32_t X, int32_t Y, int32_t Z, int32_t W)
                : mextras(extras)
                , mIndex(Index)
                , mX(X)
                , mY(Y)
                , mZ(Z)
                , mW(W) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mIndex;
        int32_t mX;
        int32_t mY;
        int32_t mZ;
        int32_t mW;
    };

    class GlVertexAttribI4iv: public Encodable {
    public:
        GlVertexAttribI4iv() = default;
        GlVertexAttribI4iv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Index, GLint__CP Values)
                : mextras(extras)
                , mIndex(Index)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mIndex);
            e->Struct(this->mValues);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mIndex;
        GLint__CP mValues;
    };

    class GlVertexAttribI4ui: public Encodable {
    public:
        GlVertexAttribI4ui() = default;
        GlVertexAttribI4ui(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Index, uint32_t X, uint32_t Y, uint32_t Z, uint32_t W)
                : mextras(extras)
                , mIndex(Index)
                , mX(X)
                , mY(Y)
                , mZ(Z)
                , mW(W) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mIndex;
        uint32_t mX;
        uint32_t mY;
        uint32_t mZ;
        uint32_t mW;
    };

    class GlVertexAttribI4uiv: public Encodable {
    public:
        GlVertexAttribI4uiv() = default;
        GlVertexAttribI4uiv(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Index, GLuint__CP Values)
                : mextras(extras)
                , mIndex(Index)
                , mValues(Values) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mIndex);
            e->Struct(this->mValues);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mIndex;
        GLuint__CP mValues;
    };

    class GlVertexAttribIFormat: public Encodable {
    public:
        GlVertexAttribIFormat() = default;
        GlVertexAttribIFormat(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Index, int32_t Size, uint32_t Type, uint32_t Relativeoffset)
                : mextras(extras)
                , mIndex(Index)
                , mSize(Size)
                , mType(Type)
                , mRelativeoffset(Relativeoffset) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mIndex;
        int32_t mSize;
        uint32_t mType;
        uint32_t mRelativeoffset;
    };

    class GlVertexAttribIPointer: public Encodable {
    public:
        GlVertexAttribIPointer() = default;
        GlVertexAttribIPointer(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Location, int32_t Size, uint32_t Type, int32_t Stride, VertexPointer Data)
                : mextras(extras)
                , mLocation(Location)
                , mSize(Size)
                , mType(Type)
                , mStride(Stride)
                , mData(Data) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mLocation;
        int32_t mSize;
        uint32_t mType;
        int32_t mStride;
        VertexPointer mData;
    };

    class GlVertexAttribPointer: public Encodable {
    public:
        GlVertexAttribPointer() = default;
        GlVertexAttribPointer(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Location, int32_t Size, uint32_t Type, uint8_t Normalized, int32_t Stride, VertexPointer Data)
                : mextras(extras)
                , mLocation(Location)
                , mSize(Size)
                , mType(Type)
                , mNormalized(Normalized)
                , mStride(Stride)
                , mData(Data) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mLocation;
        int32_t mSize;
        uint32_t mType;
        uint8_t mNormalized;
        int32_t mStride;
        VertexPointer mData;
    };

    class GlVertexBindingDivisor: public Encodable {
    public:
        GlVertexBindingDivisor() = default;
        GlVertexBindingDivisor(const gapic::Vector<gapic::Encodable*>& extras, uint32_t BindingIndex, uint32_t Divisor)
                : mextras(extras)
                , mBindingIndex(BindingIndex)
                , mDivisor(Divisor) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mBindingIndex);
            e->Uint32(this->mDivisor);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mBindingIndex;
        uint32_t mDivisor;
    };

    class GlVertexPointer: public Encodable {
    public:
        GlVertexPointer() = default;
        GlVertexPointer(const gapic::Vector<gapic::Encodable*>& extras, int32_t Size, uint32_t Type, int32_t Stride, Void__CP Pointer)
                : mextras(extras)
                , mSize(Size)
                , mType(Type)
                , mStride(Stride)
                , mPointer(Pointer) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mSize;
        uint32_t mType;
        int32_t mStride;
        Void__CP mPointer;
    };

    class GlVertexPointerBounds: public Encodable {
    public:
        GlVertexPointerBounds() = default;
        GlVertexPointerBounds(const gapic::Vector<gapic::Encodable*>& extras, int32_t Size, uint32_t Type, int32_t Stride, Void__CP Pointer, int32_t Count)
                : mextras(extras)
                , mSize(Size)
                , mType(Type)
                , mStride(Stride)
                , mPointer(Pointer)
                , mCount(Count) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mSize;
        uint32_t mType;
        int32_t mStride;
        Void__CP mPointer;
        int32_t mCount;
    };

    class GlViewport: public Encodable {
    public:
        GlViewport() = default;
        GlViewport(const gapic::Vector<gapic::Encodable*>& extras, int32_t X, int32_t Y, int32_t Width, int32_t Height)
                : mextras(extras)
                , mX(X)
                , mY(Y)
                , mWidth(Width)
                , mHeight(Height) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mX;
        int32_t mY;
        int32_t mWidth;
        int32_t mHeight;
    };

    class GlViewportArrayvNV: public Encodable {
    public:
        GlViewportArrayvNV() = default;
        GlViewportArrayvNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t First, int32_t Count, GLfloat__CP V)
                : mextras(extras)
                , mFirst(First)
                , mCount(Count)
                , mV(V) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mFirst;
        int32_t mCount;
        GLfloat__CP mV;
    };

    class GlViewportIndexedfNV: public Encodable {
    public:
        GlViewportIndexedfNV() = default;
        GlViewportIndexedfNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Index, float X, float Y, float W, float H)
                : mextras(extras)
                , mIndex(Index)
                , mX(X)
                , mY(Y)
                , mW(W)
                , mH(H) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mIndex;
        float mX;
        float mY;
        float mW;
        float mH;
    };

    class GlViewportIndexedfvNV: public Encodable {
    public:
        GlViewportIndexedfvNV() = default;
        GlViewportIndexedfvNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Index, GLfloat__CP V)
                : mextras(extras)
                , mIndex(Index)
                , mV(V) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mIndex);
            e->Struct(this->mV);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mIndex;
        GLfloat__CP mV;
    };

    class GlWaitSync: public Encodable {
    public:
        GlWaitSync() = default;
        GlWaitSync(const gapic::Vector<gapic::Encodable*>& extras, GLsync Sync, uint32_t SyncFlags, uint64_t Timeout)
                : mextras(extras)
                , mSync(Sync)
                , mSyncFlags(SyncFlags)
                , mTimeout(Timeout) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        GLsync mSync;
        uint32_t mSyncFlags;
        uint64_t mTimeout;
    };

    class GlWaitSyncAPPLE: public Encodable {
    public:
        GlWaitSyncAPPLE() = default;
        GlWaitSyncAPPLE(const gapic::Vector<gapic::Encodable*>& extras, GLsync Sync, uint32_t Flag, uint64_t Timeout)
                : mextras(extras)
                , mSync(Sync)
                , mFlag(Flag)
                , mTimeout(Timeout) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        GLsync mSync;
        uint32_t mFlag;
        uint64_t mTimeout;
    };

    class GlWeightPathsNV: public Encodable {
    public:
        GlWeightPathsNV() = default;
        GlWeightPathsNV(const gapic::Vector<gapic::Encodable*>& extras, uint32_t ResultPath, int32_t NumPaths, GLuint__CP Paths, GLfloat__CP Weights)
                : mextras(extras)
                , mResultPath(ResultPath)
                , mNumPaths(NumPaths)
                , mPaths(Paths)
                , mWeights(Weights) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mResultPath;
        int32_t mNumPaths;
        GLuint__CP mPaths;
        GLfloat__CP mWeights;
    };

    class GlWeightPointerOES: public Encodable {
    public:
        GlWeightPointerOES() = default;
        GlWeightPointerOES(const gapic::Vector<gapic::Encodable*>& extras, int32_t Size, uint32_t Type, int32_t Stride, Void__CP Pointer)
                : mextras(extras)
                , mSize(Size)
                , mType(Type)
                , mStride(Stride)
                , mPointer(Pointer) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mSize;
        uint32_t mType;
        int32_t mStride;
        Void__CP mPointer;
    };

    class GlWeightPointerOESBounds: public Encodable {
    public:
        GlWeightPointerOESBounds() = default;
        GlWeightPointerOESBounds(const gapic::Vector<gapic::Encodable*>& extras, int32_t Size, uint32_t Type, int32_t Stride, Void__CP Pointer, int32_t Count)
                : mextras(extras)
                , mSize(Size)
                , mType(Type)
                , mStride(Stride)
                , mPointer(Pointer)
                , mCount(Count) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mSize;
        uint32_t mType;
        int32_t mStride;
        Void__CP mPointer;
        int32_t mCount;
    };

    class GlXCreateContext: public Encodable {
    public:
        GlXCreateContext() = default;
        GlXCreateContext(const gapic::Vector<gapic::Encodable*>& extras, Void__P Dpy, Void__P Vis, GLXContext ShareList, bool Direct, GLXContext Result)
                : mextras(extras)
                , mDpy(Dpy)
                , mVis(Vis)
                , mShareList(ShareList)
                , mDirect(Direct)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        Void__P mDpy;
        Void__P mVis;
        GLXContext mShareList;
        bool mDirect;
        GLXContext mResult;
    };

    class GlXCreateNewContext: public Encodable {
    public:
        GlXCreateNewContext() = default;
        GlXCreateNewContext(const gapic::Vector<gapic::Encodable*>& extras, Void__P Display, Void__P Fbconfig, uint32_t Type, GLXContext Shared, bool Direct, GLXContext Result)
                : mextras(extras)
                , mDisplay(Display)
                , mFbconfig(Fbconfig)
                , mType(Type)
                , mShared(Shared)
                , mDirect(Direct)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        Void__P mDisplay;
        Void__P mFbconfig;
        uint32_t mType;
        GLXContext mShared;
        bool mDirect;
        GLXContext mResult;
    };

    class GlXMakeContextCurrent: public Encodable {
    public:
        GlXMakeContextCurrent() = default;
        GlXMakeContextCurrent(const gapic::Vector<gapic::Encodable*>& extras, Void__P Display, GLXDrawable Draw, GLXDrawable Read, GLXContext Ctx, int64_t Result)
                : mextras(extras)
                , mDisplay(Display)
                , mDraw(Draw)
                , mRead(Read)
                , mCtx(Ctx)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        Void__P mDisplay;
        GLXDrawable mDraw;
        GLXDrawable mRead;
        GLXContext mCtx;
        int64_t mResult;
    };

    class GlXMakeCurrent: public Encodable {
    public:
        GlXMakeCurrent() = default;
        GlXMakeCurrent(const gapic::Vector<gapic::Encodable*>& extras, Void__P Display, GLXDrawable Drawable, GLXContext Ctx, int64_t Result)
                : mextras(extras)
                , mDisplay(Display)
                , mDrawable(Drawable)
                , mCtx(Ctx)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        Void__P mDisplay;
        GLXDrawable mDrawable;
        GLXContext mCtx;
        int64_t mResult;
    };

    class Int__P: public Encodable {
    public:
        Int__P() = default;
        Int__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class GlXQueryDrawable: public Encodable {
    public:
        GlXQueryDrawable() = default;
        GlXQueryDrawable(const gapic::Vector<gapic::Encodable*>& extras, Void__P Display, GLXDrawable Draw, int64_t Attribute, Int__P Value, int64_t Result)
                : mextras(extras)
                , mDisplay(Display)
                , mDraw(Draw)
                , mAttribute(Attribute)
                , mValue(Value)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        Void__P mDisplay;
        GLXDrawable mDraw;
        int64_t mAttribute;
        Int__P mValue;
        int64_t mResult;
    };

    class GlXSwapBuffers: public Encodable {
    public:
        GlXSwapBuffers() = default;
        GlXSwapBuffers(const gapic::Vector<gapic::Encodable*>& extras, Void__P Display, GLXDrawable Drawable)
                : mextras(extras)
                , mDisplay(Display)
                , mDrawable(Drawable) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Struct(this->mDisplay);
            e->Struct(this->mDrawable);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        Void__P mDisplay;
        GLXDrawable mDrawable;
    };

    class HDC: public Encodable {
    public:
        HDC() = default;
        HDC(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class HGLRC: public Encodable {
    public:
        HGLRC() = default;
        HGLRC(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class Int__S: public Encodable {
    public:
        Int__S() = default;
        Int__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class Mat2f: public Encodable {
    public:
        Mat2f() = default;
        Mat2f(const gapic::StaticArray<Vec2f, 2>& Elements)
                : mElements(Elements) {}
        virtual void Encode(Encoder* e) const{
            for (int i = 0; i < 2; i++) {
                e->Struct(this->mElements[i]);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::StaticArray<Vec2f, 2> mElements;
    };

    class Mat2f__S: public Encodable {
    public:
        Mat2f__S() = default;
        Mat2f__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class Mat2f__P: public Encodable {
    public:
        Mat2f__P() = default;
        Mat2f__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class Vec3f: public Encodable {
    public:
        Vec3f() = default;
        Vec3f(const gapic::StaticArray<float, 3>& Elements)
                : mElements(Elements) {}
        virtual void Encode(Encoder* e) const{
            for (int i = 0; i < 3; i++) {
                e->Float32(this->mElements[i]);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::StaticArray<float, 3> mElements;
    };

    class Mat2x3f: public Encodable {
    public:
        Mat2x3f() = default;
        Mat2x3f(const gapic::StaticArray<Vec3f, 2>& Elements)
                : mElements(Elements) {}
        virtual void Encode(Encoder* e) const{
            for (int i = 0; i < 2; i++) {
                e->Struct(this->mElements[i]);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::StaticArray<Vec3f, 2> mElements;
    };

    class Mat2x3f__S: public Encodable {
    public:
        Mat2x3f__S() = default;
        Mat2x3f__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class Mat2x3f__P: public Encodable {
    public:
        Mat2x3f__P() = default;
        Mat2x3f__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class Mat2x4f: public Encodable {
    public:
        Mat2x4f() = default;
        Mat2x4f(const gapic::StaticArray<Vec4f, 2>& Elements)
                : mElements(Elements) {}
        virtual void Encode(Encoder* e) const{
            for (int i = 0; i < 2; i++) {
                e->Struct(this->mElements[i]);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::StaticArray<Vec4f, 2> mElements;
    };

    class Mat2x4f__S: public Encodable {
    public:
        Mat2x4f__S() = default;
        Mat2x4f__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class Mat2x4f__P: public Encodable {
    public:
        Mat2x4f__P() = default;
        Mat2x4f__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class Mat3f: public Encodable {
    public:
        Mat3f() = default;
        Mat3f(const gapic::StaticArray<Vec3f, 3>& Elements)
                : mElements(Elements) {}
        virtual void Encode(Encoder* e) const{
            for (int i = 0; i < 3; i++) {
                e->Struct(this->mElements[i]);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::StaticArray<Vec3f, 3> mElements;
    };

    class Mat3f__S: public Encodable {
    public:
        Mat3f__S() = default;
        Mat3f__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class Mat3f__P: public Encodable {
    public:
        Mat3f__P() = default;
        Mat3f__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class Mat3x2f: public Encodable {
    public:
        Mat3x2f() = default;
        Mat3x2f(const gapic::StaticArray<Vec2f, 3>& Elements)
                : mElements(Elements) {}
        virtual void Encode(Encoder* e) const{
            for (int i = 0; i < 3; i++) {
                e->Struct(this->mElements[i]);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::StaticArray<Vec2f, 3> mElements;
    };

    class Mat3x2f__S: public Encodable {
    public:
        Mat3x2f__S() = default;
        Mat3x2f__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class Mat3x2f__P: public Encodable {
    public:
        Mat3x2f__P() = default;
        Mat3x2f__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class Mat3x4f: public Encodable {
    public:
        Mat3x4f() = default;
        Mat3x4f(const gapic::StaticArray<Vec4f, 3>& Elements)
                : mElements(Elements) {}
        virtual void Encode(Encoder* e) const{
            for (int i = 0; i < 3; i++) {
                e->Struct(this->mElements[i]);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::StaticArray<Vec4f, 3> mElements;
    };

    class Mat3x4f__S: public Encodable {
    public:
        Mat3x4f__S() = default;
        Mat3x4f__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class Mat3x4f__P: public Encodable {
    public:
        Mat3x4f__P() = default;
        Mat3x4f__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class Mat4f: public Encodable {
    public:
        Mat4f() = default;
        Mat4f(const gapic::StaticArray<Vec4f, 4>& Elements)
                : mElements(Elements) {}
        virtual void Encode(Encoder* e) const{
            for (int i = 0; i < 4; i++) {
                e->Struct(this->mElements[i]);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::StaticArray<Vec4f, 4> mElements;
    };

    class Mat4f__S: public Encodable {
    public:
        Mat4f__S() = default;
        Mat4f__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class Mat4f__P: public Encodable {
    public:
        Mat4f__P() = default;
        Mat4f__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class Mat4x2f: public Encodable {
    public:
        Mat4x2f() = default;
        Mat4x2f(const gapic::StaticArray<Vec2f, 4>& Elements)
                : mElements(Elements) {}
        virtual void Encode(Encoder* e) const{
            for (int i = 0; i < 4; i++) {
                e->Struct(this->mElements[i]);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::StaticArray<Vec2f, 4> mElements;
    };

    class Mat4x2f__S: public Encodable {
    public:
        Mat4x2f__S() = default;
        Mat4x2f__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class Mat4x2f__P: public Encodable {
    public:
        Mat4x2f__P() = default;
        Mat4x2f__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class Mat4x3f: public Encodable {
    public:
        Mat4x3f() = default;
        Mat4x3f(const gapic::StaticArray<Vec3f, 4>& Elements)
                : mElements(Elements) {}
        virtual void Encode(Encoder* e) const{
            for (int i = 0; i < 4; i++) {
                e->Struct(this->mElements[i]);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::StaticArray<Vec3f, 4> mElements;
    };

    class Mat4x3f__S: public Encodable {
    public:
        Mat4x3f__S() = default;
        Mat4x3f__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class Mat4x3f__P: public Encodable {
    public:
        Mat4x3f__P() = default;
        Mat4x3f__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class PipelineId__S: public Encodable {
    public:
        PipelineId__S() = default;
        PipelineId__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class ProgramId__S: public Encodable {
    public:
        ProgramId__S() = default;
        ProgramId__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class ProgramInfo: public Encodable {
    public:
        ProgramInfo() = default;
        ProgramInfo(uint8_t LinkStatus, const char* InfoLog, const gapic::Map<uint32_t, ActiveAttribute>& ActiveAttributes, const gapic::Map<uint32_t, ActiveUniform>& ActiveUniforms)
                : mLinkStatus(LinkStatus)
                , mInfoLog(InfoLog)
                , mActiveAttributes(ActiveAttributes)
                , mActiveUniforms(ActiveUniforms) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint8_t mLinkStatus;
        const char* mInfoLog;
        gapic::Map<uint32_t, ActiveAttribute> mActiveAttributes;
        gapic::Map<uint32_t, ActiveUniform> mActiveUniforms;
    };

    class QueryId__S: public Encodable {
    public:
        QueryId__S() = default;
        QueryId__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class RenderbufferId__S: public Encodable {
    public:
        RenderbufferId__S() = default;
        RenderbufferId__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class ReplayBindRenderer: public Encodable {
    public:
        ReplayBindRenderer() = default;
        ReplayBindRenderer(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Id)
                : mextras(extras)
                , mId(Id) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mId);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mId;
    };

    class ReplayChangeBackbuffer: public Encodable {
    public:
        ReplayChangeBackbuffer() = default;
        ReplayChangeBackbuffer(const gapic::Vector<gapic::Encodable*>& extras, int32_t BackbufferWidth, int32_t BackbufferHeight, uint32_t BackbufferColorFmt, uint32_t BackbufferDepthFmt, uint32_t BackbufferStencilFmt, bool ResetViewportScissor)
                : mextras(extras)
                , mBackbufferWidth(BackbufferWidth)
                , mBackbufferHeight(BackbufferHeight)
                , mBackbufferColorFmt(BackbufferColorFmt)
                , mBackbufferDepthFmt(BackbufferDepthFmt)
                , mBackbufferStencilFmt(BackbufferStencilFmt)
                , mResetViewportScissor(ResetViewportScissor) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        int32_t mBackbufferWidth;
        int32_t mBackbufferHeight;
        uint32_t mBackbufferColorFmt;
        uint32_t mBackbufferDepthFmt;
        uint32_t mBackbufferStencilFmt;
        bool mResetViewportScissor;
    };

    class ReplayCreateRenderer: public Encodable {
    public:
        ReplayCreateRenderer() = default;
        ReplayCreateRenderer(const gapic::Vector<gapic::Encodable*>& extras, uint32_t Id)
                : mextras(extras)
                , mId(Id) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint32(this->mId);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint32_t mId;
    };

    class S64__S: public Encodable {
    public:
        S64__S() = default;
        S64__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class SamplerId__S: public Encodable {
    public:
        SamplerId__S() = default;
        SamplerId__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class ShaderId__S: public Encodable {
    public:
        ShaderId__S() = default;
        ShaderId__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class StartTimer: public Encodable {
    public:
        StartTimer() = default;
        StartTimer(const gapic::Vector<gapic::Encodable*>& extras, uint8_t Index)
                : mextras(extras)
                , mIndex(Index) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint8(this->mIndex);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint8_t mIndex;
    };

    class StaticContextState: public Encodable {
    public:
        StaticContextState() = default;
        StaticContextState(Constants Constants)
                : mConstants(Constants) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mConstants);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        Constants mConstants;
    };

    class StopTimer: public Encodable {
    public:
        StopTimer() = default;
        StopTimer(const gapic::Vector<gapic::Encodable*>& extras, uint8_t Index, uint64_t Result)
                : mextras(extras)
                , mIndex(Index)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Uint8(this->mIndex);
            e->Uint64(this->mResult);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        uint8_t mIndex;
        uint64_t mResult;
    };

    class TextureId__S: public Encodable {
    public:
        TextureId__S() = default;
        TextureId__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class TransformFeedbackId__S: public Encodable {
    public:
        TransformFeedbackId__S() = default;
        TransformFeedbackId__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class U32__S: public Encodable {
    public:
        U32__S() = default;
        U32__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class U64__S: public Encodable {
    public:
        U64__S() = default;
        U64__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class UniformIndex__S: public Encodable {
    public:
        UniformIndex__S() = default;
        UniformIndex__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class Vec1f: public Encodable {
    public:
        Vec1f() = default;
        Vec1f(const gapic::StaticArray<float, 1>& Elements)
                : mElements(Elements) {}
        virtual void Encode(Encoder* e) const{
            for (int i = 0; i < 1; i++) {
                e->Float32(this->mElements[i]);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::StaticArray<float, 1> mElements;
    };

    class Vec1i: public Encodable {
    public:
        Vec1i() = default;
        Vec1i(const gapic::StaticArray<int32_t, 1>& Elements)
                : mElements(Elements) {}
        virtual void Encode(Encoder* e) const{
            for (int i = 0; i < 1; i++) {
                e->Int32(this->mElements[i]);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::StaticArray<int32_t, 1> mElements;
    };

    class Vec2f__2__A: public Encodable {
    public:
        Vec2f__2__A() = default;
        Vec2f__2__A(const gapic::StaticArray<Vec2f, 2>& Elements)
                : mElements(Elements) {}
        virtual void Encode(Encoder* e) const{
            for (int i = 0; i < 2; i++) {
                e->Struct(this->mElements[i]);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::StaticArray<Vec2f, 2> mElements;
    };

    class Vec2f__3__A: public Encodable {
    public:
        Vec2f__3__A() = default;
        Vec2f__3__A(const gapic::StaticArray<Vec2f, 3>& Elements)
                : mElements(Elements) {}
        virtual void Encode(Encoder* e) const{
            for (int i = 0; i < 3; i++) {
                e->Struct(this->mElements[i]);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::StaticArray<Vec2f, 3> mElements;
    };

    class Vec2f__4__A: public Encodable {
    public:
        Vec2f__4__A() = default;
        Vec2f__4__A(const gapic::StaticArray<Vec2f, 4>& Elements)
                : mElements(Elements) {}
        virtual void Encode(Encoder* e) const{
            for (int i = 0; i < 4; i++) {
                e->Struct(this->mElements[i]);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::StaticArray<Vec2f, 4> mElements;
    };

    class Vec2f__S: public Encodable {
    public:
        Vec2f__S() = default;
        Vec2f__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class Vec2f__P: public Encodable {
    public:
        Vec2f__P() = default;
        Vec2f__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class Vec2i: public Encodable {
    public:
        Vec2i() = default;
        Vec2i(const gapic::StaticArray<int32_t, 2>& Elements)
                : mElements(Elements) {}
        virtual void Encode(Encoder* e) const{
            for (int i = 0; i < 2; i++) {
                e->Int32(this->mElements[i]);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::StaticArray<int32_t, 2> mElements;
    };

    class Vec2i__S: public Encodable {
    public:
        Vec2i__S() = default;
        Vec2i__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class Vec2i__P: public Encodable {
    public:
        Vec2i__P() = default;
        Vec2i__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class Vec2u: public Encodable {
    public:
        Vec2u() = default;
        Vec2u(const gapic::StaticArray<uint32_t, 2>& Elements)
                : mElements(Elements) {}
        virtual void Encode(Encoder* e) const{
            for (int i = 0; i < 2; i++) {
                e->Uint32(this->mElements[i]);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::StaticArray<uint32_t, 2> mElements;
    };

    class Vec2u__S: public Encodable {
    public:
        Vec2u__S() = default;
        Vec2u__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class Vec2u__P: public Encodable {
    public:
        Vec2u__P() = default;
        Vec2u__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class Vec3f__2__A: public Encodable {
    public:
        Vec3f__2__A() = default;
        Vec3f__2__A(const gapic::StaticArray<Vec3f, 2>& Elements)
                : mElements(Elements) {}
        virtual void Encode(Encoder* e) const{
            for (int i = 0; i < 2; i++) {
                e->Struct(this->mElements[i]);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::StaticArray<Vec3f, 2> mElements;
    };

    class Vec3f__3__A: public Encodable {
    public:
        Vec3f__3__A() = default;
        Vec3f__3__A(const gapic::StaticArray<Vec3f, 3>& Elements)
                : mElements(Elements) {}
        virtual void Encode(Encoder* e) const{
            for (int i = 0; i < 3; i++) {
                e->Struct(this->mElements[i]);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::StaticArray<Vec3f, 3> mElements;
    };

    class Vec3f__4__A: public Encodable {
    public:
        Vec3f__4__A() = default;
        Vec3f__4__A(const gapic::StaticArray<Vec3f, 4>& Elements)
                : mElements(Elements) {}
        virtual void Encode(Encoder* e) const{
            for (int i = 0; i < 4; i++) {
                e->Struct(this->mElements[i]);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::StaticArray<Vec3f, 4> mElements;
    };

    class Vec3f__S: public Encodable {
    public:
        Vec3f__S() = default;
        Vec3f__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class Vec3f__P: public Encodable {
    public:
        Vec3f__P() = default;
        Vec3f__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class Vec3i: public Encodable {
    public:
        Vec3i() = default;
        Vec3i(const gapic::StaticArray<int32_t, 3>& Elements)
                : mElements(Elements) {}
        virtual void Encode(Encoder* e) const{
            for (int i = 0; i < 3; i++) {
                e->Int32(this->mElements[i]);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::StaticArray<int32_t, 3> mElements;
    };

    class Vec3i__S: public Encodable {
    public:
        Vec3i__S() = default;
        Vec3i__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class Vec3i__P: public Encodable {
    public:
        Vec3i__P() = default;
        Vec3i__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class Vec3u: public Encodable {
    public:
        Vec3u() = default;
        Vec3u(const gapic::StaticArray<uint32_t, 3>& Elements)
                : mElements(Elements) {}
        virtual void Encode(Encoder* e) const{
            for (int i = 0; i < 3; i++) {
                e->Uint32(this->mElements[i]);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::StaticArray<uint32_t, 3> mElements;
    };

    class Vec3u__S: public Encodable {
    public:
        Vec3u__S() = default;
        Vec3u__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class Vec3u__P: public Encodable {
    public:
        Vec3u__P() = default;
        Vec3u__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class Vec4f__2__A: public Encodable {
    public:
        Vec4f__2__A() = default;
        Vec4f__2__A(const gapic::StaticArray<Vec4f, 2>& Elements)
                : mElements(Elements) {}
        virtual void Encode(Encoder* e) const{
            for (int i = 0; i < 2; i++) {
                e->Struct(this->mElements[i]);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::StaticArray<Vec4f, 2> mElements;
    };

    class Vec4f__3__A: public Encodable {
    public:
        Vec4f__3__A() = default;
        Vec4f__3__A(const gapic::StaticArray<Vec4f, 3>& Elements)
                : mElements(Elements) {}
        virtual void Encode(Encoder* e) const{
            for (int i = 0; i < 3; i++) {
                e->Struct(this->mElements[i]);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::StaticArray<Vec4f, 3> mElements;
    };

    class Vec4f__4__A: public Encodable {
    public:
        Vec4f__4__A() = default;
        Vec4f__4__A(const gapic::StaticArray<Vec4f, 4>& Elements)
                : mElements(Elements) {}
        virtual void Encode(Encoder* e) const{
            for (int i = 0; i < 4; i++) {
                e->Struct(this->mElements[i]);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::StaticArray<Vec4f, 4> mElements;
    };

    class Vec4f__S: public Encodable {
    public:
        Vec4f__S() = default;
        Vec4f__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class Vec4f__P: public Encodable {
    public:
        Vec4f__P() = default;
        Vec4f__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class Vec4i: public Encodable {
    public:
        Vec4i() = default;
        Vec4i(const gapic::StaticArray<int32_t, 4>& Elements)
                : mElements(Elements) {}
        virtual void Encode(Encoder* e) const{
            for (int i = 0; i < 4; i++) {
                e->Int32(this->mElements[i]);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::StaticArray<int32_t, 4> mElements;
    };

    class Vec4i__S: public Encodable {
    public:
        Vec4i__S() = default;
        Vec4i__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class Vec4i__P: public Encodable {
    public:
        Vec4i__P() = default;
        Vec4i__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class Vec4u: public Encodable {
    public:
        Vec4u() = default;
        Vec4u(const gapic::StaticArray<uint32_t, 4>& Elements)
                : mElements(Elements) {}
        virtual void Encode(Encoder* e) const{
            for (int i = 0; i < 4; i++) {
                e->Uint32(this->mElements[i]);
            }
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::StaticArray<uint32_t, 4> mElements;
    };

    class Vec4u__S: public Encodable {
    public:
        Vec4u__S() = default;
        Vec4u__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class Vec4u__P: public Encodable {
    public:
        Vec4u__P() = default;
        Vec4u__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class VertexArrayId__S: public Encodable {
    public:
        VertexArrayId__S() = default;
        VertexArrayId__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class Void__S: public Encodable {
    public:
        Void__S() = default;
        Void__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class Void__P__S: public Encodable {
    public:
        Void__P__S() = default;
        Void__P__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class Void__CP__S: public Encodable {
    public:
        Void__CP__S() = default;
        Void__CP__S(memory::SliceInfo SliceInfo)
                : mSliceInfo(SliceInfo) {}
        virtual void Encode(Encoder* e) const{
            e->Struct(this->mSliceInfo);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        memory::SliceInfo mSliceInfo;
    };

    class Void__CP__P: public Encodable {
    public:
        Void__CP__P() = default;
        Void__CP__P(uint64_t Address, uint32_t Pool)
                : mAddress(Address)
                , mPool(Pool) {}
        virtual void Encode(Encoder* e) const{
            e->Uint64(this->mAddress);
            e->Uint32(this->mPool);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        uint64_t mAddress;
        uint32_t mPool;
    };

    class WglCreateContext: public Encodable {
    public:
        WglCreateContext() = default;
        WglCreateContext(const gapic::Vector<gapic::Encodable*>& extras, HDC Hdc, HGLRC Result)
                : mextras(extras)
                , mHdc(Hdc)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Struct(this->mHdc);
            e->Struct(this->mResult);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        HDC mHdc;
        HGLRC mResult;
    };

    class WglCreateContextAttribsARB: public Encodable {
    public:
        WglCreateContextAttribsARB() = default;
        WglCreateContextAttribsARB(const gapic::Vector<gapic::Encodable*>& extras, HDC Hdc, HGLRC HShareContext, Int__P AttribList, HGLRC Result)
                : mextras(extras)
                , mHdc(Hdc)
                , mHShareContext(HShareContext)
                , mAttribList(AttribList)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        HDC mHdc;
        HGLRC mHShareContext;
        Int__P mAttribList;
        HGLRC mResult;
    };

    class WglMakeCurrent: public Encodable {
    public:
        WglMakeCurrent() = default;
        WglMakeCurrent(const gapic::Vector<gapic::Encodable*>& extras, HDC Hdc, HGLRC Hglrc, int64_t Result)
                : mextras(extras)
                , mHdc(Hdc)
                , mHglrc(Hglrc)
                , mResult(Result) {}
        virtual void Encode(Encoder* e) const;
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        HDC mHdc;
        HGLRC mHglrc;
        int64_t mResult;
    };

    class WglSwapBuffers: public Encodable {
    public:
        WglSwapBuffers() = default;
        WglSwapBuffers(const gapic::Vector<gapic::Encodable*>& extras, HDC Hdc)
                : mextras(extras)
                , mHdc(Hdc) {}
        virtual void Encode(Encoder* e) const{
            e->Uint32(this->mextras.count());
            for (auto v : this->mextras) {
                e->Object(v);
            }
            e->Struct(this->mHdc);
        }
        virtual const schema::Entity* Schema() const {
            return StaticSchema();
        }
        static const schema::Entity* StaticSchema();
        gapic::Vector<gapic::Encodable*> mextras;
        HDC mHdc;
    };



} // namespace gles
} // namespace coder
} // namespace gapic

#endif // GAPIC_CODER_GLES_H