diff options
| author | David Srbecky <dsrbecky@google.com> | 2015-08-07 12:51:00 +0000 |
|---|---|---|
| committer | Gerrit Code Review <noreply-gerritcodereview@google.com> | 2015-08-07 12:51:00 +0000 |
| commit | ec20f4993df9db72c2607de0d6e11dfc719a8696 (patch) | |
| tree | de24380efe5f488f93fdb6cc4188cc99a3849499 | |
| parent | e187687ca024f24af4c24ee28fd7b4e55ffb6ac1 (diff) | |
| parent | 9f771e4863c443e430a2624b3dfe2e7bab621ee8 (diff) | |
| download | gpu-studio-1.4-dev.tar.gz | |
Merge "Replace bool types with GLboolean." into studio-1.4-devstudio-1.4-dev
31 files changed, 1114 insertions, 1268 deletions
diff --git a/api/resolver/rules.go b/api/resolver/rules.go index 1d88e1cfa..bd9b7763f 100644 --- a/api/resolver/rules.go +++ b/api/resolver/rules.go @@ -109,6 +109,13 @@ func castable(from semantic.Type, to semantic.Type) bool { if fromIsNumber && toIsNumber { return true // any numeric conversion } + fromIsBool, toIsBool := fromBase == semantic.BoolType, toBase == semantic.BoolType + if fromIsBool && toIsNumber { + return true // bool -> number + } + if fromIsNumber && toIsBool { + return true // number -> bool + } fromPointer, fromIsPointer := fromBase.(*semantic.Pointer) toPointer, toIsPointer := toBase.(*semantic.Pointer) if fromIsPointer && toIsPointer { // A* -> B* diff --git a/cc/gapic/coder/gles.h b/cc/gapic/coder/gles.h index aa442f01a..a92fd6e34 100644 --- a/cc/gapic/coder/gles.h +++ b/cc/gapic/coder/gles.h @@ -160,38 +160,6 @@ namespace gles { uint64_t mCount; }; - class Bool__S: public Encodable { - public: - Bool__S() = default; - Bool__S(SliceInfo SliceInfo) : - mSliceInfo(SliceInfo) {} - virtual const gapic::Id& Id() const { - static gapic::Id ID{ { 0xf9, 0x44, 0xf2, 0x44, 0xbb, 0x78, 0x01, 0x7e, 0x56, 0xa1, 0x2f, 0x0d, 0x73, 0x9c, 0xa1, 0x77, 0x23, 0x5d, 0x47, 0xa8, } }; - return ID; - } - virtual void Encode(Encoder* e) const { - e->Value(this->mSliceInfo); - } - - SliceInfo mSliceInfo; - }; - - class Bool__P: public Encodable { - public: - Bool__P() = default; - Bool__P(memory::Pointer Pointer) : - mPointer(Pointer) {} - virtual const gapic::Id& Id() const { - static gapic::Id ID{ { 0x99, 0x96, 0x28, 0x2f, 0x78, 0x22, 0x44, 0xc9, 0x8f, 0x89, 0x53, 0x2f, 0x40, 0x01, 0x69, 0xd1, 0xa0, 0x82, 0x72, 0x24, } }; - return ID; - } - virtual void Encode(Encoder* e) const { - e->Value(this->mPointer); - } - - memory::Pointer mPointer; - }; - class U8__S: public Encodable { public: U8__S() = default; @@ -711,7 +679,7 @@ namespace gles { class RasterizerState: public Encodable { public: RasterizerState() = default; - RasterizerState(bool DepthMask, uint32_t DepthTestFunction, float DepthNear, float DepthFar, bool ColorMaskRed, bool ColorMaskGreen, bool ColorMaskBlue, bool ColorMaskAlpha, std::unordered_map<uint32_t,uint32_t>* StencilMask, Rect Viewport, Rect Scissor, uint32_t FrontFace, uint32_t CullFace, float LineWidth, float PolygonOffsetFactor, float PolygonOffsetUnits, float SampleCoverageValue, bool SampleCoverageInvert) : + RasterizerState(uint8_t DepthMask, uint32_t DepthTestFunction, float DepthNear, float DepthFar, uint8_t ColorMaskRed, uint8_t ColorMaskGreen, uint8_t ColorMaskBlue, uint8_t ColorMaskAlpha, std::unordered_map<uint32_t,uint32_t>* StencilMask, Rect Viewport, Rect Scissor, uint32_t FrontFace, uint32_t CullFace, float LineWidth, float PolygonOffsetFactor, float PolygonOffsetUnits, float SampleCoverageValue, uint8_t SampleCoverageInvert) : mDepthMask(DepthMask), mDepthTestFunction(DepthTestFunction), mDepthNear(DepthNear), @@ -731,18 +699,18 @@ namespace gles { mSampleCoverageValue(SampleCoverageValue), mSampleCoverageInvert(SampleCoverageInvert) {} virtual const gapic::Id& Id() const { - static gapic::Id ID{ { 0x8f, 0x8a, 0x9b, 0x1a, 0xfe, 0xff, 0x2b, 0xd1, 0x64, 0x1e, 0x91, 0xda, 0x14, 0x3c, 0x05, 0x0a, 0x1d, 0xb4, 0xc1, 0xa2, } }; + static gapic::Id ID{ { 0xba, 0xcc, 0xd9, 0x38, 0xef, 0x30, 0x2c, 0x2e, 0x7b, 0xd7, 0x18, 0x82, 0x47, 0x5c, 0x0f, 0xca, 0xd0, 0x70, 0x0c, 0x27, } }; return ID; } virtual void Encode(Encoder* e) const { - e->Bool(this->mDepthMask); + e->Uint8(this->mDepthMask); e->Uint32(this->mDepthTestFunction); e->Float32(this->mDepthNear); e->Float32(this->mDepthFar); - e->Bool(this->mColorMaskRed); - e->Bool(this->mColorMaskGreen); - e->Bool(this->mColorMaskBlue); - e->Bool(this->mColorMaskAlpha); + e->Uint8(this->mColorMaskRed); + e->Uint8(this->mColorMaskGreen); + e->Uint8(this->mColorMaskBlue); + e->Uint8(this->mColorMaskAlpha); GAPID_FATAL("C++ map encoding not supported"); e->Value(this->mViewport); e->Value(this->mScissor); @@ -752,17 +720,17 @@ namespace gles { e->Float32(this->mPolygonOffsetFactor); e->Float32(this->mPolygonOffsetUnits); e->Float32(this->mSampleCoverageValue); - e->Bool(this->mSampleCoverageInvert); + e->Uint8(this->mSampleCoverageInvert); } - bool mDepthMask; + uint8_t mDepthMask; uint32_t mDepthTestFunction; float mDepthNear; float mDepthFar; - bool mColorMaskRed; - bool mColorMaskGreen; - bool mColorMaskBlue; - bool mColorMaskAlpha; + uint8_t mColorMaskRed; + uint8_t mColorMaskGreen; + uint8_t mColorMaskBlue; + uint8_t mColorMaskAlpha; std::unordered_map<uint32_t,uint32_t>* mStencilMask; Rect mViewport; Rect mScissor; @@ -772,7 +740,7 @@ namespace gles { float mPolygonOffsetFactor; float mPolygonOffsetUnits; float mSampleCoverageValue; - bool mSampleCoverageInvert; + uint8_t mSampleCoverageInvert; }; class VertexPointer: public Encodable { @@ -794,7 +762,7 @@ namespace gles { class VertexAttributeArray: public Encodable { public: VertexAttributeArray() = default; - VertexAttributeArray(bool Enabled, uint32_t Size, uint32_t Type, bool Normalized, int32_t Stride, uint32_t Buffer, VertexPointer Pointer) : + VertexAttributeArray(bool Enabled, uint32_t Size, uint32_t Type, uint8_t Normalized, int32_t Stride, uint32_t Buffer, VertexPointer Pointer) : mEnabled(Enabled), mSize(Size), mType(Type), @@ -803,14 +771,14 @@ namespace gles { mBuffer(Buffer), mPointer(Pointer) {} virtual const gapic::Id& Id() const { - static gapic::Id ID{ { 0x64, 0x7d, 0x26, 0xce, 0xd4, 0x3e, 0xba, 0x93, 0x29, 0xf8, 0x4f, 0xa9, 0xbe, 0x10, 0x35, 0x4c, 0x00, 0x1c, 0x5d, 0xf1, } }; + static gapic::Id ID{ { 0xd6, 0xdb, 0x80, 0x6a, 0xa4, 0x37, 0x8a, 0xfb, 0x6f, 0x2b, 0xda, 0x40, 0x36, 0x4d, 0x5a, 0x43, 0xf8, 0x16, 0x3e, 0x41, } }; return ID; } virtual void Encode(Encoder* e) const { e->Bool(this->mEnabled); e->Uint32(this->mSize); e->Uint32(this->mType); - e->Bool(this->mNormalized); + e->Uint8(this->mNormalized); e->Int32(this->mStride); e->Uint32(this->mBuffer); e->Value(this->mPointer); @@ -819,7 +787,7 @@ namespace gles { bool mEnabled; uint32_t mSize; uint32_t mType; - bool mNormalized; + uint8_t mNormalized; int32_t mStride; uint32_t mBuffer; VertexPointer mPointer; @@ -3735,29 +3703,29 @@ namespace gles { class GlColorMask: public Encodable { public: GlColorMask() = default; - GlColorMask(atom::Observations observations, bool Red, bool Green, bool Blue, bool Alpha) : + GlColorMask(atom::Observations observations, uint8_t Red, uint8_t Green, uint8_t Blue, uint8_t Alpha) : mobservations(observations), mRed(Red), mGreen(Green), mBlue(Blue), mAlpha(Alpha) {} virtual const gapic::Id& Id() const { - static gapic::Id ID{ { 0x0b, 0x72, 0x03, 0xf6, 0x51, 0x6a, 0xe3, 0xca, 0x0c, 0x5d, 0x08, 0x46, 0xf6, 0x8b, 0x71, 0xdf, 0x67, 0xe5, 0xae, 0xf9, } }; + static gapic::Id ID{ { 0x08, 0x8e, 0x3b, 0xb6, 0x7d, 0x88, 0x07, 0x6c, 0x0b, 0x69, 0xba, 0xf5, 0x56, 0x97, 0xc3, 0xde, 0x2a, 0xa6, 0xc7, 0x5b, } }; return ID; } virtual void Encode(Encoder* e) const { e->Value(this->mobservations); - e->Bool(this->mRed); - e->Bool(this->mGreen); - e->Bool(this->mBlue); - e->Bool(this->mAlpha); + e->Uint8(this->mRed); + e->Uint8(this->mGreen); + e->Uint8(this->mBlue); + e->Uint8(this->mAlpha); } atom::Observations mobservations; - bool mRed; - bool mGreen; - bool mBlue; - bool mAlpha; + uint8_t mRed; + uint8_t mGreen; + uint8_t mBlue; + uint8_t mAlpha; }; class GlColorMaskiEXT: public Encodable { @@ -5508,20 +5476,20 @@ namespace gles { class GlDepthMask: public Encodable { public: GlDepthMask() = default; - GlDepthMask(atom::Observations observations, bool Enabled) : + GlDepthMask(atom::Observations observations, uint8_t Enabled) : mobservations(observations), mEnabled(Enabled) {} virtual const gapic::Id& Id() const { - static gapic::Id ID{ { 0xc5, 0x6d, 0x4e, 0x1a, 0x87, 0x06, 0xec, 0xa4, 0xe8, 0xb4, 0x2e, 0x82, 0xff, 0x78, 0x0a, 0x83, 0x79, 0x82, 0xce, 0xf1, } }; + static gapic::Id ID{ { 0x97, 0x3f, 0x4a, 0x6e, 0x55, 0xfe, 0x5c, 0x75, 0x97, 0x64, 0xbc, 0x51, 0xff, 0x17, 0x83, 0xc7, 0x86, 0x81, 0xde, 0xe2, } }; return ID; } virtual void Encode(Encoder* e) const { e->Value(this->mobservations); - e->Bool(this->mEnabled); + e->Uint8(this->mEnabled); } atom::Observations mobservations; - bool mEnabled; + uint8_t mEnabled; }; class GlDepthRangeArrayfvNV: public Encodable { @@ -8492,12 +8460,12 @@ namespace gles { class GlGetBooleanv: public Encodable { public: GlGetBooleanv() = default; - GlGetBooleanv(atom::Observations observations, uint32_t Param, Bool__P Values) : + GlGetBooleanv(atom::Observations observations, uint32_t Param, GLboolean__P Values) : mobservations(observations), mParam(Param), mValues(Values) {} virtual const gapic::Id& Id() const { - static gapic::Id ID{ { 0x97, 0xc0, 0xb6, 0x7f, 0x15, 0xec, 0xa2, 0x39, 0x64, 0x28, 0x0a, 0xac, 0x21, 0xda, 0xc1, 0x48, 0x10, 0x1b, 0x0d, 0x99, } }; + static gapic::Id ID{ { 0xb2, 0x87, 0x76, 0x95, 0xc0, 0xf9, 0xcf, 0x8f, 0x96, 0xf2, 0x88, 0x6c, 0xe2, 0x42, 0xae, 0x98, 0x8b, 0x78, 0x63, 0xfb, } }; return ID; } virtual void Encode(Encoder* e) const { @@ -8508,7 +8476,7 @@ namespace gles { atom::Observations mobservations; uint32_t mParam; - Bool__P mValues; + GLboolean__P mValues; }; class GlGetBufferParameteri64v: public Encodable { @@ -11864,214 +11832,214 @@ namespace gles { class GlIsBuffer: public Encodable { public: GlIsBuffer() = default; - GlIsBuffer(atom::Observations observations, uint32_t Buffer, bool Result) : + GlIsBuffer(atom::Observations observations, uint32_t Buffer, uint8_t Result) : mobservations(observations), mBuffer(Buffer), mResult(Result) {} virtual const gapic::Id& Id() const { - static gapic::Id ID{ { 0x25, 0xf9, 0x53, 0xf4, 0x60, 0x55, 0xc5, 0xfe, 0x8a, 0x0f, 0xd4, 0x1a, 0x88, 0xe7, 0xf4, 0x4c, 0xcc, 0x81, 0x3b, 0xb7, } }; + static gapic::Id ID{ { 0xd1, 0x42, 0xad, 0xb7, 0x81, 0x67, 0x04, 0x3a, 0x6e, 0x6a, 0x0a, 0x72, 0x75, 0xcb, 0x7c, 0x15, 0xa1, 0x9a, 0xf8, 0x66, } }; return ID; } virtual void Encode(Encoder* e) const { e->Value(this->mobservations); e->Uint32(this->mBuffer); - e->Bool(this->mResult); + e->Uint8(this->mResult); } atom::Observations mobservations; uint32_t mBuffer; - bool mResult; + uint8_t mResult; }; class GlIsEnabled: public Encodable { public: GlIsEnabled() = default; - GlIsEnabled(atom::Observations observations, uint32_t Capability, bool Result) : + GlIsEnabled(atom::Observations observations, uint32_t Capability, uint8_t Result) : mobservations(observations), mCapability(Capability), mResult(Result) {} virtual const gapic::Id& Id() const { - static gapic::Id ID{ { 0x1e, 0x76, 0x5e, 0x33, 0x18, 0x3f, 0x49, 0x72, 0x76, 0x25, 0x26, 0xfc, 0x02, 0xba, 0xec, 0x57, 0xbf, 0xcd, 0x0e, 0xa6, } }; + static gapic::Id ID{ { 0xdf, 0xea, 0x56, 0xfa, 0xb1, 0x23, 0x94, 0xf6, 0x32, 0xef, 0x9e, 0x76, 0x22, 0x90, 0x9e, 0x64, 0x72, 0x78, 0x9a, 0x77, } }; return ID; } virtual void Encode(Encoder* e) const { e->Value(this->mobservations); e->Uint32(this->mCapability); - e->Bool(this->mResult); + e->Uint8(this->mResult); } atom::Observations mobservations; uint32_t mCapability; - bool mResult; + uint8_t mResult; }; class GlIsEnablediEXT: public Encodable { public: GlIsEnablediEXT() = default; - GlIsEnablediEXT(atom::Observations observations, uint32_t Target, uint32_t Index, bool Result) : + GlIsEnablediEXT(atom::Observations observations, uint32_t Target, uint32_t Index, uint8_t Result) : mobservations(observations), mTarget(Target), mIndex(Index), mResult(Result) {} virtual const gapic::Id& Id() const { - static gapic::Id ID{ { 0x3c, 0xda, 0x4c, 0x00, 0x38, 0x1d, 0x18, 0xda, 0x25, 0x67, 0x96, 0xb9, 0xbe, 0x6f, 0xa6, 0x42, 0xa2, 0xa1, 0x64, 0x64, } }; + static gapic::Id ID{ { 0xae, 0x61, 0xac, 0xf0, 0xa8, 0x0a, 0xda, 0xd4, 0x62, 0x6f, 0x79, 0x2a, 0x94, 0xcc, 0x5b, 0x49, 0xde, 0xea, 0x1c, 0xfc, } }; return ID; } virtual void Encode(Encoder* e) const { e->Value(this->mobservations); e->Uint32(this->mTarget); e->Uint32(this->mIndex); - e->Bool(this->mResult); + e->Uint8(this->mResult); } atom::Observations mobservations; uint32_t mTarget; uint32_t mIndex; - bool mResult; + uint8_t mResult; }; class GlIsEnablediNV: public Encodable { public: GlIsEnablediNV() = default; - GlIsEnablediNV(atom::Observations observations, uint32_t Target, uint32_t Index, bool Result) : + GlIsEnablediNV(atom::Observations observations, uint32_t Target, uint32_t Index, uint8_t Result) : mobservations(observations), mTarget(Target), mIndex(Index), mResult(Result) {} virtual const gapic::Id& Id() const { - static gapic::Id ID{ { 0x16, 0x60, 0xa3, 0x8f, 0x2e, 0x7e, 0xfc, 0x14, 0xb6, 0xae, 0x10, 0x9e, 0xfc, 0xbc, 0xa4, 0xfa, 0xc4, 0x31, 0x90, 0xc9, } }; + static gapic::Id ID{ { 0x23, 0x7a, 0xc2, 0xbc, 0x0c, 0x99, 0xbd, 0xa3, 0x4a, 0x46, 0xb7, 0x73, 0xe3, 0xaf, 0xfe, 0xe9, 0x57, 0x71, 0xf8, 0xd5, } }; return ID; } virtual void Encode(Encoder* e) const { e->Value(this->mobservations); e->Uint32(this->mTarget); e->Uint32(this->mIndex); - e->Bool(this->mResult); + e->Uint8(this->mResult); } atom::Observations mobservations; uint32_t mTarget; uint32_t mIndex; - bool mResult; + uint8_t mResult; }; class GlIsEnablediOES: public Encodable { public: GlIsEnablediOES() = default; - GlIsEnablediOES(atom::Observations observations, uint32_t Target, uint32_t Index, bool Result) : + GlIsEnablediOES(atom::Observations observations, uint32_t Target, uint32_t Index, uint8_t Result) : mobservations(observations), mTarget(Target), mIndex(Index), mResult(Result) {} virtual const gapic::Id& Id() const { - static gapic::Id ID{ { 0x7a, 0x7a, 0x4b, 0x7b, 0xfc, 0xc6, 0xd9, 0xf9, 0x66, 0xb6, 0xa9, 0x50, 0x9d, 0x16, 0xa5, 0x62, 0x58, 0x5f, 0x51, 0xf8, } }; + static gapic::Id ID{ { 0xdc, 0x6b, 0x8a, 0x3f, 0x3a, 0xcb, 0xdb, 0x01, 0xc1, 0xc6, 0x0e, 0x8e, 0xab, 0x90, 0xfb, 0x0d, 0x76, 0x5e, 0xb2, 0xad, } }; return ID; } virtual void Encode(Encoder* e) const { e->Value(this->mobservations); e->Uint32(this->mTarget); e->Uint32(this->mIndex); - e->Bool(this->mResult); + e->Uint8(this->mResult); } atom::Observations mobservations; uint32_t mTarget; uint32_t mIndex; - bool mResult; + uint8_t mResult; }; class GlIsFenceNV: public Encodable { public: GlIsFenceNV() = default; - GlIsFenceNV(atom::Observations observations, uint32_t Fence, bool Result) : + GlIsFenceNV(atom::Observations observations, uint32_t Fence, uint8_t Result) : mobservations(observations), mFence(Fence), mResult(Result) {} virtual const gapic::Id& Id() const { - static gapic::Id ID{ { 0xd0, 0x36, 0x79, 0x51, 0x81, 0x82, 0xed, 0xb7, 0x37, 0xd7, 0x25, 0xb3, 0x21, 0x1d, 0x42, 0x60, 0xea, 0xeb, 0x7d, 0x36, } }; + static gapic::Id ID{ { 0x00, 0xbe, 0x20, 0x72, 0x2b, 0x08, 0x81, 0xee, 0x1e, 0x4c, 0xae, 0x5b, 0x5e, 0x61, 0x2c, 0x78, 0x6c, 0xcc, 0x58, 0xfa, } }; return ID; } virtual void Encode(Encoder* e) const { e->Value(this->mobservations); e->Uint32(this->mFence); - e->Bool(this->mResult); + e->Uint8(this->mResult); } atom::Observations mobservations; uint32_t mFence; - bool mResult; + uint8_t mResult; }; class GlIsFramebuffer: public Encodable { public: GlIsFramebuffer() = default; - GlIsFramebuffer(atom::Observations observations, uint32_t Framebuffer, bool Result) : + GlIsFramebuffer(atom::Observations observations, uint32_t Framebuffer, uint8_t Result) : mobservations(observations), mFramebuffer(Framebuffer), mResult(Result) {} virtual const gapic::Id& Id() const { - static gapic::Id ID{ { 0x0b, 0xdd, 0x4e, 0xe8, 0x9f, 0x9d, 0xcc, 0xd2, 0xea, 0x1a, 0xa6, 0xc5, 0xef, 0x65, 0x2e, 0x02, 0x80, 0xe0, 0xc4, 0x63, } }; + static gapic::Id ID{ { 0x18, 0x61, 0x06, 0x59, 0x8f, 0x47, 0x18, 0x3d, 0xc9, 0x38, 0x46, 0x78, 0x2e, 0x71, 0x54, 0x29, 0x9b, 0x9f, 0xc6, 0x33, } }; return ID; } virtual void Encode(Encoder* e) const { e->Value(this->mobservations); e->Uint32(this->mFramebuffer); - e->Bool(this->mResult); + e->Uint8(this->mResult); } atom::Observations mobservations; uint32_t mFramebuffer; - bool mResult; + uint8_t mResult; }; class GlIsImageHandleResidentNV: public Encodable { public: GlIsImageHandleResidentNV() = default; - GlIsImageHandleResidentNV(atom::Observations observations, uint64_t Handle, bool Result) : + GlIsImageHandleResidentNV(atom::Observations observations, uint64_t Handle, uint8_t Result) : mobservations(observations), mHandle(Handle), mResult(Result) {} virtual const gapic::Id& Id() const { - static gapic::Id ID{ { 0xb6, 0xfb, 0xff, 0xb4, 0x8c, 0x61, 0x02, 0xe7, 0x4c, 0x8a, 0xe2, 0x24, 0x61, 0xbc, 0x61, 0x74, 0xd3, 0x97, 0x7f, 0x16, } }; + static gapic::Id ID{ { 0x53, 0xe4, 0x84, 0xe2, 0x4e, 0x7e, 0xbf, 0x3f, 0xae, 0xac, 0x62, 0x67, 0x00, 0xc5, 0xbc, 0x10, 0x9e, 0x04, 0x11, 0xf7, } }; return ID; } virtual void Encode(Encoder* e) const { e->Value(this->mobservations); e->Uint64(this->mHandle); - e->Bool(this->mResult); + e->Uint8(this->mResult); } atom::Observations mobservations; uint64_t mHandle; - bool mResult; + uint8_t mResult; }; class GlIsPathNV: public Encodable { public: GlIsPathNV() = default; - GlIsPathNV(atom::Observations observations, uint32_t Path, bool Result) : + GlIsPathNV(atom::Observations observations, uint32_t Path, uint8_t Result) : mobservations(observations), mPath(Path), mResult(Result) {} virtual const gapic::Id& Id() const { - static gapic::Id ID{ { 0xfb, 0x83, 0xef, 0x93, 0x94, 0x6f, 0xad, 0x68, 0xa9, 0x9f, 0x83, 0x37, 0x8e, 0x23, 0x95, 0x6f, 0xf0, 0x4a, 0x38, 0x0b, } }; + static gapic::Id ID{ { 0x11, 0x8e, 0xe3, 0x7e, 0xd5, 0x0a, 0x80, 0x9f, 0xb2, 0xb3, 0x72, 0xc6, 0xc6, 0x3a, 0x5c, 0x7d, 0xc5, 0x00, 0x48, 0xde, } }; return ID; } virtual void Encode(Encoder* e) const { e->Value(this->mobservations); e->Uint32(this->mPath); - e->Bool(this->mResult); + e->Uint8(this->mResult); } atom::Observations mobservations; uint32_t mPath; - bool mResult; + uint8_t mResult; }; class GlIsPointInFillPathNV: public Encodable { public: GlIsPointInFillPathNV() = default; - GlIsPointInFillPathNV(atom::Observations observations, uint32_t Path, uint32_t Mask, float X, float Y, bool Result) : + GlIsPointInFillPathNV(atom::Observations observations, uint32_t Path, uint32_t Mask, float X, float Y, uint8_t Result) : mobservations(observations), mPath(Path), mMask(Mask), @@ -12079,7 +12047,7 @@ namespace gles { mY(Y), mResult(Result) {} virtual const gapic::Id& Id() const { - static gapic::Id ID{ { 0x07, 0xa7, 0x0a, 0xce, 0xd9, 0x63, 0x98, 0xc7, 0x0d, 0xe1, 0x10, 0xdb, 0xed, 0x19, 0x00, 0xe0, 0x3f, 0x61, 0xde, 0x31, } }; + static gapic::Id ID{ { 0x21, 0x3c, 0x21, 0xd4, 0xa6, 0xf1, 0xa7, 0xcf, 0xef, 0x46, 0x10, 0xe4, 0x3f, 0xa8, 0xc5, 0xf3, 0x5c, 0xe7, 0x9a, 0x46, } }; return ID; } virtual void Encode(Encoder* e) const { @@ -12088,7 +12056,7 @@ namespace gles { e->Uint32(this->mMask); e->Float32(this->mX); e->Float32(this->mY); - e->Bool(this->mResult); + e->Uint8(this->mResult); } atom::Observations mobservations; @@ -12096,20 +12064,20 @@ namespace gles { uint32_t mMask; float mX; float mY; - bool mResult; + uint8_t mResult; }; class GlIsPointInStrokePathNV: public Encodable { public: GlIsPointInStrokePathNV() = default; - GlIsPointInStrokePathNV(atom::Observations observations, uint32_t Path, float X, float Y, bool Result) : + GlIsPointInStrokePathNV(atom::Observations observations, uint32_t Path, float X, float Y, uint8_t Result) : mobservations(observations), mPath(Path), mX(X), mY(Y), mResult(Result) {} virtual const gapic::Id& Id() const { - static gapic::Id ID{ { 0x5b, 0xcc, 0x1e, 0x2f, 0xd6, 0x59, 0xc6, 0x90, 0x9b, 0x68, 0x80, 0x42, 0xea, 0x77, 0x2d, 0xa8, 0x1b, 0x20, 0x7b, 0x27, } }; + static gapic::Id ID{ { 0xe2, 0x25, 0x1e, 0xa9, 0x3b, 0x3c, 0x88, 0x47, 0xde, 0x73, 0xb3, 0xd8, 0x3c, 0x22, 0x91, 0x58, 0xcd, 0xba, 0xca, 0x9a, } }; return ID; } virtual void Encode(Encoder* e) const { @@ -12117,344 +12085,344 @@ namespace gles { e->Uint32(this->mPath); e->Float32(this->mX); e->Float32(this->mY); - e->Bool(this->mResult); + e->Uint8(this->mResult); } atom::Observations mobservations; uint32_t mPath; float mX; float mY; - bool mResult; + uint8_t mResult; }; class GlIsProgram: public Encodable { public: GlIsProgram() = default; - GlIsProgram(atom::Observations observations, uint32_t Program, bool Result) : + GlIsProgram(atom::Observations observations, uint32_t Program, uint8_t Result) : mobservations(observations), mProgram(Program), mResult(Result) {} virtual const gapic::Id& Id() const { - static gapic::Id ID{ { 0x62, 0xbd, 0xde, 0xd6, 0x51, 0x60, 0x50, 0x3e, 0x3d, 0x54, 0x0a, 0xec, 0xb2, 0xcd, 0xf5, 0x54, 0xfb, 0x79, 0x3c, 0xdd, } }; + static gapic::Id ID{ { 0x3d, 0x4b, 0x04, 0xa2, 0x10, 0x91, 0x77, 0xc4, 0x5b, 0xf7, 0x7b, 0x52, 0x88, 0xb8, 0x23, 0xb4, 0x8b, 0x1d, 0x49, 0x8a, } }; return ID; } virtual void Encode(Encoder* e) const { e->Value(this->mobservations); e->Uint32(this->mProgram); - e->Bool(this->mResult); + e->Uint8(this->mResult); } atom::Observations mobservations; uint32_t mProgram; - bool mResult; + uint8_t mResult; }; class GlIsProgramPipeline: public Encodable { public: GlIsProgramPipeline() = default; - GlIsProgramPipeline(atom::Observations observations, uint32_t Pipeline, bool Result) : + GlIsProgramPipeline(atom::Observations observations, uint32_t Pipeline, uint8_t Result) : mobservations(observations), mPipeline(Pipeline), mResult(Result) {} virtual const gapic::Id& Id() const { - static gapic::Id ID{ { 0x12, 0xc3, 0x33, 0x56, 0x4d, 0x0b, 0xc2, 0x6a, 0x89, 0x06, 0x71, 0x90, 0xaf, 0xc6, 0x07, 0x5b, 0x4f, 0x57, 0xed, 0x4b, } }; + static gapic::Id ID{ { 0x65, 0x87, 0x32, 0x9b, 0x5e, 0x93, 0x56, 0x50, 0xb5, 0x80, 0x11, 0xcf, 0xa9, 0xea, 0x41, 0x79, 0x91, 0x56, 0xea, 0xf5, } }; return ID; } virtual void Encode(Encoder* e) const { e->Value(this->mobservations); e->Uint32(this->mPipeline); - e->Bool(this->mResult); + e->Uint8(this->mResult); } atom::Observations mobservations; uint32_t mPipeline; - bool mResult; + uint8_t mResult; }; class GlIsProgramPipelineEXT: public Encodable { public: GlIsProgramPipelineEXT() = default; - GlIsProgramPipelineEXT(atom::Observations observations, uint32_t Pipeline, bool Result) : + GlIsProgramPipelineEXT(atom::Observations observations, uint32_t Pipeline, uint8_t Result) : mobservations(observations), mPipeline(Pipeline), mResult(Result) {} virtual const gapic::Id& Id() const { - static gapic::Id ID{ { 0x02, 0x06, 0x86, 0x2b, 0x7f, 0x2f, 0x1c, 0xa7, 0xa8, 0x6f, 0xd1, 0x91, 0x5a, 0x8d, 0xd8, 0xcd, 0xe5, 0x0b, 0x36, 0xd2, } }; + static gapic::Id ID{ { 0x20, 0x45, 0x4b, 0x4e, 0xdc, 0x7d, 0x13, 0xe1, 0xe0, 0xd8, 0x3e, 0x59, 0x26, 0x75, 0x7b, 0x9e, 0x20, 0x11, 0x92, 0x53, } }; return ID; } virtual void Encode(Encoder* e) const { e->Value(this->mobservations); e->Uint32(this->mPipeline); - e->Bool(this->mResult); + e->Uint8(this->mResult); } atom::Observations mobservations; uint32_t mPipeline; - bool mResult; + uint8_t mResult; }; class GlIsQuery: public Encodable { public: GlIsQuery() = default; - GlIsQuery(atom::Observations observations, uint32_t Query, bool Result) : + GlIsQuery(atom::Observations observations, uint32_t Query, uint8_t Result) : mobservations(observations), mQuery(Query), mResult(Result) {} virtual const gapic::Id& Id() const { - static gapic::Id ID{ { 0x3b, 0x6f, 0x09, 0x4b, 0x89, 0xdc, 0x6b, 0x2f, 0x74, 0xd6, 0x51, 0x3b, 0x3f, 0xfe, 0x6d, 0x60, 0x72, 0x60, 0x61, 0xe2, } }; + static gapic::Id ID{ { 0xeb, 0xf4, 0x49, 0xc3, 0xc4, 0x7f, 0xcf, 0x88, 0xd6, 0xba, 0xcd, 0xd3, 0x71, 0xf4, 0x54, 0x11, 0xc0, 0x5f, 0x39, 0x6c, } }; return ID; } virtual void Encode(Encoder* e) const { e->Value(this->mobservations); e->Uint32(this->mQuery); - e->Bool(this->mResult); + e->Uint8(this->mResult); } atom::Observations mobservations; uint32_t mQuery; - bool mResult; + uint8_t mResult; }; class GlIsQueryEXT: public Encodable { public: GlIsQueryEXT() = default; - GlIsQueryEXT(atom::Observations observations, uint32_t Query, bool Result) : + GlIsQueryEXT(atom::Observations observations, uint32_t Query, uint8_t Result) : mobservations(observations), mQuery(Query), mResult(Result) {} virtual const gapic::Id& Id() const { - static gapic::Id ID{ { 0xb1, 0x6a, 0x0d, 0xdf, 0xb6, 0xea, 0x3d, 0x84, 0xd0, 0x8c, 0x22, 0xf5, 0xf9, 0x82, 0x88, 0xa5, 0x3e, 0xdd, 0x56, 0xea, } }; + static gapic::Id ID{ { 0xe4, 0x92, 0x78, 0x2c, 0x94, 0x95, 0xb9, 0x72, 0xd8, 0x48, 0xa9, 0x22, 0x2e, 0xbe, 0xc9, 0x93, 0x52, 0x14, 0x68, 0x80, } }; return ID; } virtual void Encode(Encoder* e) const { e->Value(this->mobservations); e->Uint32(this->mQuery); - e->Bool(this->mResult); + e->Uint8(this->mResult); } atom::Observations mobservations; uint32_t mQuery; - bool mResult; + uint8_t mResult; }; class GlIsRenderbuffer: public Encodable { public: GlIsRenderbuffer() = default; - GlIsRenderbuffer(atom::Observations observations, uint32_t Renderbuffer, bool Result) : + GlIsRenderbuffer(atom::Observations observations, uint32_t Renderbuffer, uint8_t Result) : mobservations(observations), mRenderbuffer(Renderbuffer), mResult(Result) {} virtual const gapic::Id& Id() const { - static gapic::Id ID{ { 0xee, 0xfa, 0xeb, 0x17, 0x01, 0xe1, 0xe4, 0xc6, 0x90, 0x90, 0x9c, 0xfa, 0x28, 0x24, 0xad, 0x33, 0xc5, 0xef, 0x2f, 0xe6, } }; + static gapic::Id ID{ { 0x34, 0x29, 0x3a, 0x38, 0xe1, 0xd5, 0x24, 0x3f, 0xfc, 0xc1, 0x68, 0xb5, 0x19, 0x3b, 0x96, 0xcc, 0x06, 0xd2, 0xa0, 0x78, } }; return ID; } virtual void Encode(Encoder* e) const { e->Value(this->mobservations); e->Uint32(this->mRenderbuffer); - e->Bool(this->mResult); + e->Uint8(this->mResult); } atom::Observations mobservations; uint32_t mRenderbuffer; - bool mResult; + uint8_t mResult; }; class GlIsSampler: public Encodable { public: GlIsSampler() = default; - GlIsSampler(atom::Observations observations, uint32_t Sampler, bool Result) : + GlIsSampler(atom::Observations observations, uint32_t Sampler, uint8_t Result) : mobservations(observations), mSampler(Sampler), mResult(Result) {} virtual const gapic::Id& Id() const { - static gapic::Id ID{ { 0xe7, 0x20, 0x74, 0xdd, 0xbc, 0xd4, 0x8a, 0x01, 0xe5, 0x8d, 0xf6, 0x31, 0xa0, 0xea, 0xe8, 0xc7, 0xc2, 0x9e, 0x40, 0x12, } }; + static gapic::Id ID{ { 0x5a, 0x71, 0x95, 0xd5, 0x3d, 0x8a, 0x37, 0x3f, 0xef, 0x3c, 0x68, 0x22, 0x10, 0x11, 0x15, 0x39, 0x66, 0xde, 0x16, 0xc9, } }; return ID; } virtual void Encode(Encoder* e) const { e->Value(this->mobservations); e->Uint32(this->mSampler); - e->Bool(this->mResult); + e->Uint8(this->mResult); } atom::Observations mobservations; uint32_t mSampler; - bool mResult; + uint8_t mResult; }; class GlIsShader: public Encodable { public: GlIsShader() = default; - GlIsShader(atom::Observations observations, uint32_t Shader, bool Result) : + GlIsShader(atom::Observations observations, uint32_t Shader, uint8_t Result) : mobservations(observations), mShader(Shader), mResult(Result) {} virtual const gapic::Id& Id() const { - static gapic::Id ID{ { 0xb5, 0x7a, 0x83, 0x39, 0x62, 0xa0, 0x1c, 0x3d, 0x08, 0x84, 0x29, 0xda, 0x1a, 0x6a, 0xe2, 0xd6, 0x24, 0x88, 0x4e, 0xe2, } }; + static gapic::Id ID{ { 0xa7, 0x49, 0xe5, 0x16, 0x9b, 0xf3, 0x3e, 0x13, 0xba, 0x90, 0x7a, 0x71, 0x99, 0x9b, 0xd3, 0x77, 0x68, 0xa4, 0xb1, 0xe6, } }; return ID; } virtual void Encode(Encoder* e) const { e->Value(this->mobservations); e->Uint32(this->mShader); - e->Bool(this->mResult); + e->Uint8(this->mResult); } atom::Observations mobservations; uint32_t mShader; - bool mResult; + uint8_t mResult; }; class GlIsSync: public Encodable { public: GlIsSync() = default; - GlIsSync(atom::Observations observations, uint64_t Sync, bool Result) : + GlIsSync(atom::Observations observations, uint64_t Sync, uint8_t Result) : mobservations(observations), mSync(Sync), mResult(Result) {} virtual const gapic::Id& Id() const { - static gapic::Id ID{ { 0x91, 0x49, 0xac, 0x3e, 0x81, 0x9f, 0x67, 0x37, 0x47, 0x69, 0x6c, 0x75, 0x87, 0x40, 0x58, 0x21, 0x3d, 0x12, 0x03, 0x81, } }; + static gapic::Id ID{ { 0xa4, 0x39, 0x5f, 0xae, 0xa8, 0xe2, 0x66, 0x9d, 0x53, 0xcc, 0x8d, 0x93, 0xa3, 0x60, 0x08, 0x19, 0x9c, 0x2e, 0xe8, 0x78, } }; return ID; } virtual void Encode(Encoder* e) const { e->Value(this->mobservations); e->Uint64(this->mSync); - e->Bool(this->mResult); + e->Uint8(this->mResult); } atom::Observations mobservations; uint64_t mSync; - bool mResult; + uint8_t mResult; }; class GlIsSyncAPPLE: public Encodable { public: GlIsSyncAPPLE() = default; - GlIsSyncAPPLE(atom::Observations observations, uint64_t Sync, bool Result) : + GlIsSyncAPPLE(atom::Observations observations, uint64_t Sync, uint8_t Result) : mobservations(observations), mSync(Sync), mResult(Result) {} virtual const gapic::Id& Id() const { - static gapic::Id ID{ { 0xc5, 0xd9, 0xbc, 0x70, 0x4c, 0xd1, 0x8a, 0x59, 0x8c, 0x5a, 0xde, 0xf2, 0x3c, 0x77, 0xc3, 0xb0, 0xb8, 0x6f, 0xa2, 0x52, } }; + static gapic::Id ID{ { 0x56, 0x15, 0x61, 0xaa, 0xec, 0x7f, 0x97, 0xe1, 0xad, 0x1e, 0x61, 0xea, 0x8e, 0x2b, 0xb1, 0xe5, 0x47, 0x39, 0x0c, 0x93, } }; return ID; } virtual void Encode(Encoder* e) const { e->Value(this->mobservations); e->Uint64(this->mSync); - e->Bool(this->mResult); + e->Uint8(this->mResult); } atom::Observations mobservations; uint64_t mSync; - bool mResult; + uint8_t mResult; }; class GlIsTexture: public Encodable { public: GlIsTexture() = default; - GlIsTexture(atom::Observations observations, uint32_t Texture, bool Result) : + GlIsTexture(atom::Observations observations, uint32_t Texture, uint8_t Result) : mobservations(observations), mTexture(Texture), mResult(Result) {} virtual const gapic::Id& Id() const { - static gapic::Id ID{ { 0xae, 0x84, 0x50, 0xca, 0xe6, 0x83, 0x45, 0x6c, 0x68, 0x8d, 0x96, 0xf2, 0xb2, 0x0f, 0x9c, 0x01, 0x78, 0x1c, 0x12, 0xdd, } }; + static gapic::Id ID{ { 0x5b, 0xe3, 0xe7, 0xfa, 0xf3, 0x8f, 0xef, 0x75, 0xff, 0xf5, 0xab, 0xe8, 0xa5, 0xf6, 0xca, 0x21, 0xfa, 0xf9, 0x44, 0x38, } }; return ID; } virtual void Encode(Encoder* e) const { e->Value(this->mobservations); e->Uint32(this->mTexture); - e->Bool(this->mResult); + e->Uint8(this->mResult); } atom::Observations mobservations; uint32_t mTexture; - bool mResult; + uint8_t mResult; }; class GlIsTextureHandleResidentNV: public Encodable { public: GlIsTextureHandleResidentNV() = default; - GlIsTextureHandleResidentNV(atom::Observations observations, uint64_t Handle, bool Result) : + GlIsTextureHandleResidentNV(atom::Observations observations, uint64_t Handle, uint8_t Result) : mobservations(observations), mHandle(Handle), mResult(Result) {} virtual const gapic::Id& Id() const { - static gapic::Id ID{ { 0x86, 0xd0, 0xaf, 0x39, 0x23, 0x63, 0x6a, 0x88, 0xca, 0xd3, 0x8b, 0xa5, 0x97, 0x3f, 0x1b, 0xd0, 0x8c, 0xd6, 0xbb, 0xb0, } }; + static gapic::Id ID{ { 0x4e, 0x07, 0x08, 0x21, 0x50, 0x6f, 0x16, 0xf4, 0x6c, 0x14, 0x7a, 0x47, 0xe7, 0x3b, 0xb3, 0x3c, 0x6b, 0xc4, 0xa3, 0xb2, } }; return ID; } virtual void Encode(Encoder* e) const { e->Value(this->mobservations); e->Uint64(this->mHandle); - e->Bool(this->mResult); + e->Uint8(this->mResult); } atom::Observations mobservations; uint64_t mHandle; - bool mResult; + uint8_t mResult; }; class GlIsTransformFeedback: public Encodable { public: GlIsTransformFeedback() = default; - GlIsTransformFeedback(atom::Observations observations, uint32_t Id, bool Result) : + GlIsTransformFeedback(atom::Observations observations, uint32_t Id, uint8_t Result) : mobservations(observations), mId(Id), mResult(Result) {} virtual const gapic::Id& Id() const { - static gapic::Id ID{ { 0x73, 0xf1, 0xcd, 0x3b, 0xc3, 0xba, 0x36, 0x0d, 0x81, 0x3f, 0x46, 0x9c, 0xc0, 0x51, 0x85, 0x45, 0x1a, 0x70, 0xbb, 0xbc, } }; + static gapic::Id ID{ { 0x32, 0x19, 0xd3, 0xf0, 0xb0, 0x03, 0x77, 0x57, 0x2f, 0x77, 0x27, 0x12, 0x4a, 0x61, 0x32, 0xd3, 0xbb, 0xd7, 0x70, 0xc9, } }; return ID; } virtual void Encode(Encoder* e) const { e->Value(this->mobservations); e->Uint32(this->mId); - e->Bool(this->mResult); + e->Uint8(this->mResult); } atom::Observations mobservations; uint32_t mId; - bool mResult; + uint8_t mResult; }; class GlIsVertexArray: public Encodable { public: GlIsVertexArray() = default; - GlIsVertexArray(atom::Observations observations, uint32_t Array, bool Result) : + GlIsVertexArray(atom::Observations observations, uint32_t Array, uint8_t Result) : mobservations(observations), mArray(Array), mResult(Result) {} virtual const gapic::Id& Id() const { - static gapic::Id ID{ { 0xfa, 0x3f, 0x47, 0xbd, 0xae, 0xc8, 0x4c, 0x38, 0xa1, 0x33, 0x6c, 0x4f, 0x39, 0x74, 0x9f, 0x90, 0x9e, 0x9e, 0x5d, 0x86, } }; + static gapic::Id ID{ { 0x05, 0x80, 0x6b, 0x17, 0xc1, 0x95, 0x55, 0x32, 0x24, 0xa9, 0xcb, 0x99, 0x7d, 0x49, 0xfc, 0x8b, 0xd2, 0xfa, 0xd3, 0x2d, } }; return ID; } virtual void Encode(Encoder* e) const { e->Value(this->mobservations); e->Uint32(this->mArray); - e->Bool(this->mResult); + e->Uint8(this->mResult); } atom::Observations mobservations; uint32_t mArray; - bool mResult; + uint8_t mResult; }; class GlIsVertexArrayOES: public Encodable { public: GlIsVertexArrayOES() = default; - GlIsVertexArrayOES(atom::Observations observations, uint32_t Array, bool Result) : + GlIsVertexArrayOES(atom::Observations observations, uint32_t Array, uint8_t Result) : mobservations(observations), mArray(Array), mResult(Result) {} virtual const gapic::Id& Id() const { - static gapic::Id ID{ { 0xab, 0xa3, 0xb5, 0xac, 0x9c, 0x32, 0x14, 0xdb, 0x82, 0x00, 0xa7, 0xbd, 0xe0, 0xb2, 0x40, 0x64, 0xac, 0x30, 0xb8, 0xc7, } }; + static gapic::Id ID{ { 0xb7, 0x33, 0xcc, 0xf5, 0x7b, 0x60, 0x3f, 0x6e, 0xe4, 0xf6, 0xad, 0xaf, 0xd2, 0xd1, 0xad, 0xba, 0x86, 0x4c, 0x12, 0xa8, } }; return ID; } virtual void Encode(Encoder* e) const { e->Value(this->mobservations); e->Uint32(this->mArray); - e->Bool(this->mResult); + e->Uint8(this->mResult); } atom::Observations mobservations; uint32_t mArray; - bool mResult; + uint8_t mResult; }; class GlLabelObjectEXT: public Encodable { @@ -16689,23 +16657,23 @@ namespace gles { class GlSampleCoverage: public Encodable { public: GlSampleCoverage() = default; - GlSampleCoverage(atom::Observations observations, float Value, bool Invert) : + GlSampleCoverage(atom::Observations observations, float Value, uint8_t Invert) : mobservations(observations), mValue(Value), mInvert(Invert) {} virtual const gapic::Id& Id() const { - static gapic::Id ID{ { 0xd6, 0x38, 0xca, 0xe0, 0xdf, 0x70, 0x44, 0xf0, 0xc1, 0x90, 0xf6, 0xae, 0x37, 0x92, 0xa8, 0xc5, 0x6c, 0x14, 0x5c, 0x44, } }; + static gapic::Id ID{ { 0x8f, 0x2d, 0x0f, 0x2a, 0x05, 0x41, 0x30, 0x62, 0xd9, 0x60, 0x92, 0x3b, 0x02, 0x58, 0xdf, 0x37, 0x82, 0xa1, 0xb7, 0xbd, } }; return ID; } virtual void Encode(Encoder* e) const { e->Value(this->mobservations); e->Float32(this->mValue); - e->Bool(this->mInvert); + e->Uint8(this->mInvert); } atom::Observations mobservations; float mValue; - bool mInvert; + uint8_t mInvert; }; class GlSampleMaski: public Encodable { @@ -20539,7 +20507,7 @@ namespace gles { class GlVertexAttribPointer: public Encodable { public: GlVertexAttribPointer() = default; - GlVertexAttribPointer(atom::Observations observations, uint32_t Location, int32_t Size, uint32_t Type, bool Normalized, int32_t Stride, VertexPointer Data) : + GlVertexAttribPointer(atom::Observations observations, uint32_t Location, int32_t Size, uint32_t Type, uint8_t Normalized, int32_t Stride, VertexPointer Data) : mobservations(observations), mLocation(Location), mSize(Size), @@ -20548,7 +20516,7 @@ namespace gles { mStride(Stride), mData(Data) {} virtual const gapic::Id& Id() const { - static gapic::Id ID{ { 0x8d, 0xe5, 0x21, 0x0d, 0xc4, 0xcd, 0x43, 0x00, 0xef, 0x07, 0xe3, 0x29, 0x33, 0x8c, 0x33, 0xcf, 0xd3, 0x2d, 0xac, 0x96, } }; + static gapic::Id ID{ { 0xa9, 0xf4, 0x7e, 0x3b, 0x7c, 0x9d, 0x74, 0x34, 0xf5, 0x0b, 0xad, 0xb3, 0xd8, 0x9b, 0x87, 0xf9, 0xef, 0xf5, 0x5f, 0x90, } }; return ID; } virtual void Encode(Encoder* e) const { @@ -20556,7 +20524,7 @@ namespace gles { e->Uint32(this->mLocation); e->Int32(this->mSize); e->Uint32(this->mType); - e->Bool(this->mNormalized); + e->Uint8(this->mNormalized); e->Int32(this->mStride); e->Value(this->mData); } @@ -20565,7 +20533,7 @@ namespace gles { uint32_t mLocation; int32_t mSize; uint32_t mType; - bool mNormalized; + uint8_t mNormalized; int32_t mStride; VertexPointer mData; }; diff --git a/cc/gapii/gles_exports.cpp b/cc/gapii/gles_exports.cpp index c7a9bf8c8..62cd3beb9 100644 --- a/cc/gapii/gles_exports.cpp +++ b/cc/gapii/gles_exports.cpp @@ -66,7 +66,7 @@ EXPORT void STDCALL glGetSamplerParameterIuivEXT(uint32_t sampler, uint32_t pname, uint32_t* params); EXPORT void STDCALL glGetTexParameterIivEXT(uint32_t target, uint32_t pname, int32_t* params); EXPORT void STDCALL glGetTexParameterIuivEXT(uint32_t target, uint32_t pname, uint32_t* params); -EXPORT bool STDCALL glIsEnablediEXT(uint32_t target, uint32_t index); +EXPORT uint8_t STDCALL glIsEnablediEXT(uint32_t target, uint32_t index); EXPORT void STDCALL glMinSampleShadingOES(float value); EXPORT void STDCALL glObjectLabelKHR(uint32_t identifier, uint32_t name, int32_t length, char* label); @@ -94,7 +94,7 @@ EXPORT void STDCALL glEndQuery(uint32_t target); EXPORT void STDCALL glGenQueries(int32_t count, uint32_t* queries); EXPORT void STDCALL glGetQueryObjectuiv(uint32_t query, uint32_t parameter, uint32_t* value); EXPORT void STDCALL glGetQueryiv(uint32_t target, uint32_t parameter, int32_t* value); -EXPORT bool STDCALL glIsQuery(uint32_t query); +EXPORT uint8_t STDCALL glIsQuery(uint32_t query); EXPORT void STDCALL glBindBuffer(uint32_t target, uint32_t buffer); EXPORT void STDCALL glBindBufferBase(uint32_t target, uint32_t index, uint32_t buffer); EXPORT void STDCALL @@ -108,7 +108,7 @@ EXPORT void STDCALL glGenBuffers(int32_t count, uint32_t* buffers); EXPORT void STDCALL glGetBufferParameteri64v(uint32_t target, uint32_t pname, int64_t* params); EXPORT void STDCALL glGetBufferParameteriv(uint32_t target, uint32_t parameter, int32_t* value); EXPORT void STDCALL glGetBufferPointerv(uint32_t target, uint32_t pname, void** params); -EXPORT bool STDCALL glIsBuffer(uint32_t buffer); +EXPORT uint8_t STDCALL glIsBuffer(uint32_t buffer); EXPORT void* STDCALL glMapBufferRange(uint32_t target, int32_t offset, int32_t length, uint32_t access); EXPORT uint8_t STDCALL glUnmapBuffer(uint32_t target); @@ -392,18 +392,18 @@ glGetnUniformuivKHR(uint32_t program, int32_t location, int32_t bufSize, uint32_ EXPORT void STDCALL glInsertEventMarkerEXT(int32_t length, char* marker); EXPORT void STDCALL glInterpolatePathsNV(uint32_t resultPath, uint32_t pathA, uint32_t pathB, float weight); -EXPORT bool STDCALL glIsEnablediOES(uint32_t target, uint32_t index); -EXPORT bool STDCALL glIsEnablediNV(uint32_t target, uint32_t index); -EXPORT bool STDCALL glIsFenceNV(uint32_t fence); -EXPORT bool STDCALL glIsImageHandleResidentNV(uint64_t handle); -EXPORT bool STDCALL glIsPathNV(uint32_t path); -EXPORT bool STDCALL glIsPointInFillPathNV(uint32_t path, uint32_t mask, float x, float y); -EXPORT bool STDCALL glIsPointInStrokePathNV(uint32_t path, float x, float y); -EXPORT bool STDCALL glIsProgramPipelineEXT(uint32_t pipeline); -EXPORT bool STDCALL glIsQueryEXT(uint32_t query); -EXPORT bool STDCALL glIsSyncAPPLE(uint64_t sync); -EXPORT bool STDCALL glIsTextureHandleResidentNV(uint64_t handle); -EXPORT bool STDCALL glIsVertexArrayOES(uint32_t array); +EXPORT uint8_t STDCALL glIsEnablediOES(uint32_t target, uint32_t index); +EXPORT uint8_t STDCALL glIsEnablediNV(uint32_t target, uint32_t index); +EXPORT uint8_t STDCALL glIsFenceNV(uint32_t fence); +EXPORT uint8_t STDCALL glIsImageHandleResidentNV(uint64_t handle); +EXPORT uint8_t STDCALL glIsPathNV(uint32_t path); +EXPORT uint8_t STDCALL glIsPointInFillPathNV(uint32_t path, uint32_t mask, float x, float y); +EXPORT uint8_t STDCALL glIsPointInStrokePathNV(uint32_t path, float x, float y); +EXPORT uint8_t STDCALL glIsProgramPipelineEXT(uint32_t pipeline); +EXPORT uint8_t STDCALL glIsQueryEXT(uint32_t query); +EXPORT uint8_t STDCALL glIsSyncAPPLE(uint64_t sync); +EXPORT uint8_t STDCALL glIsTextureHandleResidentNV(uint64_t handle); +EXPORT uint8_t STDCALL glIsVertexArrayOES(uint32_t array); EXPORT void STDCALL glLabelObjectEXT(uint32_t type, uint32_t object, int32_t length, char* label); EXPORT void STDCALL glMakeImageHandleNonResidentNV(uint64_t handle); EXPORT void STDCALL glMakeImageHandleResidentNV(uint64_t handle, uint32_t access); @@ -691,7 +691,7 @@ EXPORT void STDCALL glBlendFunc(uint32_t src_factor, uint32_t dst_factor); EXPORT void STDCALL glBlendFuncSeparate(uint32_t src_factor_rgb, uint32_t dst_factor_rgb, uint32_t src_factor_alpha, uint32_t dst_factor_alpha); EXPORT void STDCALL glDepthFunc(uint32_t function); -EXPORT void STDCALL glSampleCoverage(float value, bool invert); +EXPORT void STDCALL glSampleCoverage(float value, uint8_t invert); EXPORT void STDCALL glSampleMaski(uint32_t maskNumber, uint32_t mask); EXPORT void STDCALL glScissor(int32_t x, int32_t y, int32_t width, int32_t height); EXPORT void STDCALL glStencilFunc(uint32_t func, int32_t ref, uint32_t mask); @@ -716,10 +716,10 @@ EXPORT void STDCALL glClearBufferuiv(uint32_t buffer, int32_t drawbuffer, uint32 EXPORT void STDCALL glClearColor(float r, float g, float b, float a); EXPORT void STDCALL glClearDepthf(float depth); EXPORT void STDCALL glClearStencil(int32_t stencil); -EXPORT void STDCALL glColorMask(bool red, bool green, bool blue, bool alpha); +EXPORT void STDCALL glColorMask(uint8_t red, uint8_t green, uint8_t blue, uint8_t alpha); EXPORT void STDCALL glDeleteFramebuffers(int32_t count, uint32_t* framebuffers); EXPORT void STDCALL glDeleteRenderbuffers(int32_t count, uint32_t* renderbuffers); -EXPORT void STDCALL glDepthMask(bool enabled); +EXPORT void STDCALL glDepthMask(uint8_t enabled); EXPORT void STDCALL glFramebufferParameteri(uint32_t target, uint32_t pname, int32_t param); EXPORT void STDCALL glFramebufferRenderbuffer(uint32_t framebuffer_target, uint32_t framebuffer_attachment, @@ -741,8 +741,8 @@ EXPORT void STDCALL glInvalidateFramebuffer(uint32_t target, int32_t count, uint EXPORT void STDCALL glInvalidateSubFramebuffer(uint32_t target, int32_t numAttachments, uint32_t* attachments, int32_t x, int32_t y, int32_t width, int32_t height); -EXPORT bool STDCALL glIsFramebuffer(uint32_t framebuffer); -EXPORT bool STDCALL glIsRenderbuffer(uint32_t renderbuffer); +EXPORT uint8_t STDCALL glIsFramebuffer(uint32_t framebuffer); +EXPORT uint8_t STDCALL glIsRenderbuffer(uint32_t renderbuffer); EXPORT void STDCALL glReadBuffer(uint32_t src); EXPORT void STDCALL glReadPixels(int32_t x, int32_t y, int32_t width, int32_t height, uint32_t format, uint32_t type, void* data); @@ -828,9 +828,9 @@ EXPORT int32_t STDCALL glGetUniformLocation(uint32_t program, char* name); EXPORT void STDCALL glGetUniformfv(uint32_t program, int32_t location, float* values); EXPORT void STDCALL glGetUniformiv(uint32_t program, int32_t location, int32_t* values); EXPORT void STDCALL glGetUniformuiv(uint32_t program, int32_t location, uint32_t* params); -EXPORT bool STDCALL glIsProgram(uint32_t program); -EXPORT bool STDCALL glIsProgramPipeline(uint32_t pipeline); -EXPORT bool STDCALL glIsShader(uint32_t shader); +EXPORT uint8_t STDCALL glIsProgram(uint32_t program); +EXPORT uint8_t STDCALL glIsProgramPipeline(uint32_t pipeline); +EXPORT uint8_t STDCALL glIsShader(uint32_t shader); EXPORT void STDCALL glLinkProgram(uint32_t program); EXPORT void STDCALL glMemoryBarrier(uint32_t barriers); EXPORT void STDCALL glMemoryBarrierByRegion(uint32_t barriers); @@ -961,7 +961,7 @@ EXPORT void STDCALL glLineWidth(float width); EXPORT void STDCALL glPolygonOffset(float scale_factor, float units); EXPORT void STDCALL glViewport(int32_t x, int32_t y, int32_t width, int32_t height); EXPORT void STDCALL glGetBooleani_v(uint32_t target, uint32_t index, uint8_t* data); -EXPORT void STDCALL glGetBooleanv(uint32_t param, bool* values); +EXPORT void STDCALL glGetBooleanv(uint32_t param, uint8_t* values); EXPORT void STDCALL glGetFloatv(uint32_t param, float* values); EXPORT void STDCALL glGetInteger64i_v(uint32_t target, uint32_t index, int64_t* data); EXPORT void STDCALL glGetInteger64v(uint32_t pname, int64_t* data); @@ -971,13 +971,13 @@ EXPORT void STDCALL glGetInternalformativ(uint32_t target, uint32_t internalform int32_t bufSize, int32_t* params); EXPORT uint8_t* STDCALL glGetString(uint32_t param); EXPORT uint8_t* STDCALL glGetStringi(uint32_t name, uint32_t index); -EXPORT bool STDCALL glIsEnabled(uint32_t capability); +EXPORT uint8_t STDCALL glIsEnabled(uint32_t capability); EXPORT uint32_t STDCALL glClientWaitSync(uint64_t sync, uint32_t syncFlags, uint64_t timeout); EXPORT void STDCALL glDeleteSync(uint64_t sync); EXPORT uint64_t STDCALL glFenceSync(uint32_t condition, uint32_t syncFlags); EXPORT void STDCALL glGetSynciv(uint64_t sync, uint32_t pname, int32_t bufSize, int32_t* length, int32_t* values); -EXPORT bool STDCALL glIsSync(uint64_t sync); +EXPORT uint8_t STDCALL glIsSync(uint64_t sync); EXPORT void STDCALL glWaitSync(uint64_t sync, uint32_t syncFlags, uint64_t timeout); EXPORT void STDCALL glActiveTexture(uint32_t unit); EXPORT void STDCALL glBindImageTexture(uint32_t unit, uint32_t texture, int32_t level, @@ -1019,8 +1019,8 @@ EXPORT void STDCALL glGetTexLevelParameteriv(uint32_t target, int32_t level, uint32_t pname, int32_t* params); EXPORT void STDCALL glGetTexParameterfv(uint32_t target, uint32_t parameter, float* values); EXPORT void STDCALL glGetTexParameteriv(uint32_t target, uint32_t parameter, int32_t* values); -EXPORT bool STDCALL glIsSampler(uint32_t sampler); -EXPORT bool STDCALL glIsTexture(uint32_t texture); +EXPORT uint8_t STDCALL glIsSampler(uint32_t sampler); +EXPORT uint8_t STDCALL glIsTexture(uint32_t texture); EXPORT void STDCALL glPixelStorei(uint32_t parameter, int32_t value); EXPORT void STDCALL glSamplerParameterf(uint32_t sampler, uint32_t pname, float param); EXPORT void STDCALL glSamplerParameterfv(uint32_t sampler, uint32_t pname, float* param); @@ -1057,7 +1057,7 @@ EXPORT void STDCALL glGenTransformFeedbacks(int32_t n, uint32_t* ids); EXPORT void STDCALL glGetTransformFeedbackVarying(uint32_t program, uint32_t index, int32_t bufSize, int32_t* length, int32_t* size, uint32_t* type, char* name); -EXPORT bool STDCALL glIsTransformFeedback(uint32_t id); +EXPORT uint8_t STDCALL glIsTransformFeedback(uint32_t id); EXPORT void STDCALL glPauseTransformFeedback(); EXPORT void STDCALL glResumeTransformFeedback(); EXPORT void STDCALL @@ -1074,7 +1074,7 @@ EXPORT void STDCALL glGetVertexAttribIuiv(uint32_t index, uint32_t pname, uint32 EXPORT void STDCALL glGetVertexAttribPointerv(uint32_t index, uint32_t pname, void** pointer); EXPORT void STDCALL glGetVertexAttribfv(uint32_t index, uint32_t pname, float* params); EXPORT void STDCALL glGetVertexAttribiv(uint32_t index, uint32_t pname, int32_t* params); -EXPORT bool STDCALL glIsVertexArray(uint32_t array); +EXPORT uint8_t STDCALL glIsVertexArray(uint32_t array); EXPORT void STDCALL glVertexAttrib1f(uint32_t location, float value0); EXPORT void STDCALL glVertexAttrib1fv(uint32_t location, float* value); EXPORT void STDCALL glVertexAttrib2f(uint32_t location, float value0, float value1); @@ -1098,7 +1098,7 @@ glVertexAttribIFormat(uint32_t attribindex, int32_t size, uint32_t type, uint32_ EXPORT void STDCALL glVertexAttribIPointer(uint32_t index, int32_t size, uint32_t type, int32_t stride, void* pointer); EXPORT void STDCALL glVertexAttribPointer(uint32_t location, int32_t size, uint32_t type, - bool normalized, int32_t stride, void* data); + uint8_t normalized, int32_t stride, void* data); EXPORT void STDCALL glVertexBindingDivisor(uint32_t bindingindex, uint32_t divisor); EXPORT int STDCALL eglInitialize(void* dpy, int* major, int* minor); EXPORT void* STDCALL @@ -2290,7 +2290,7 @@ EXPORT void STDCALL glGetTexParameterIuivEXT(uint32_t target, uint32_t pname, ui gapic::Lock<Spy> lock__(s); s->glGetTexParameterIuivEXT(target, pname, params); } -EXPORT bool STDCALL glIsEnablediEXT(uint32_t target, uint32_t index) { +EXPORT uint8_t STDCALL glIsEnablediEXT(uint32_t target, uint32_t index) { Spy* s = spy(); gapic::Lock<Spy> lock__(s); return s->glIsEnablediEXT(target, index); @@ -2403,7 +2403,7 @@ EXPORT void STDCALL glGetQueryiv(uint32_t target, uint32_t parameter, int32_t* v gapic::Lock<Spy> lock__(s); s->glGetQueryiv(target, parameter, value); } -EXPORT bool STDCALL glIsQuery(uint32_t query) { +EXPORT uint8_t STDCALL glIsQuery(uint32_t query) { Spy* s = spy(); gapic::Lock<Spy> lock__(s); return s->glIsQuery(query); @@ -2465,7 +2465,7 @@ EXPORT void STDCALL glGetBufferPointerv(uint32_t target, uint32_t pname, void** gapic::Lock<Spy> lock__(s); s->glGetBufferPointerv(target, pname, params); } -EXPORT bool STDCALL glIsBuffer(uint32_t buffer) { +EXPORT uint8_t STDCALL glIsBuffer(uint32_t buffer) { Spy* s = spy(); gapic::Lock<Spy> lock__(s); return s->glIsBuffer(buffer); @@ -3449,62 +3449,62 @@ glInterpolatePathsNV(uint32_t resultPath, uint32_t pathA, uint32_t pathB, float gapic::Lock<Spy> lock__(s); s->glInterpolatePathsNV(resultPath, pathA, pathB, weight); } -EXPORT bool STDCALL glIsEnablediOES(uint32_t target, uint32_t index) { +EXPORT uint8_t STDCALL glIsEnablediOES(uint32_t target, uint32_t index) { Spy* s = spy(); gapic::Lock<Spy> lock__(s); return s->glIsEnablediOES(target, index); } -EXPORT bool STDCALL glIsEnablediNV(uint32_t target, uint32_t index) { +EXPORT uint8_t STDCALL glIsEnablediNV(uint32_t target, uint32_t index) { Spy* s = spy(); gapic::Lock<Spy> lock__(s); return s->glIsEnablediNV(target, index); } -EXPORT bool STDCALL glIsFenceNV(uint32_t fence) { +EXPORT uint8_t STDCALL glIsFenceNV(uint32_t fence) { Spy* s = spy(); gapic::Lock<Spy> lock__(s); return s->glIsFenceNV(fence); } -EXPORT bool STDCALL glIsImageHandleResidentNV(uint64_t handle) { +EXPORT uint8_t STDCALL glIsImageHandleResidentNV(uint64_t handle) { Spy* s = spy(); gapic::Lock<Spy> lock__(s); return s->glIsImageHandleResidentNV(handle); } -EXPORT bool STDCALL glIsPathNV(uint32_t path) { +EXPORT uint8_t STDCALL glIsPathNV(uint32_t path) { Spy* s = spy(); gapic::Lock<Spy> lock__(s); return s->glIsPathNV(path); } -EXPORT bool STDCALL glIsPointInFillPathNV(uint32_t path, uint32_t mask, float x, float y) { +EXPORT uint8_t STDCALL glIsPointInFillPathNV(uint32_t path, uint32_t mask, float x, float y) { Spy* s = spy(); gapic::Lock<Spy> lock__(s); return s->glIsPointInFillPathNV(path, mask, x, y); } -EXPORT bool STDCALL glIsPointInStrokePathNV(uint32_t path, float x, float y) { +EXPORT uint8_t STDCALL glIsPointInStrokePathNV(uint32_t path, float x, float y) { Spy* s = spy(); gapic::Lock<Spy> lock__(s); return s->glIsPointInStrokePathNV(path, x, y); } -EXPORT bool STDCALL glIsProgramPipelineEXT(uint32_t pipeline) { +EXPORT uint8_t STDCALL glIsProgramPipelineEXT(uint32_t pipeline) { Spy* s = spy(); gapic::Lock<Spy> lock__(s); return s->glIsProgramPipelineEXT(pipeline); } -EXPORT bool STDCALL glIsQueryEXT(uint32_t query) { +EXPORT uint8_t STDCALL glIsQueryEXT(uint32_t query) { Spy* s = spy(); gapic::Lock<Spy> lock__(s); return s->glIsQueryEXT(query); } -EXPORT bool STDCALL glIsSyncAPPLE(uint64_t sync) { +EXPORT uint8_t STDCALL glIsSyncAPPLE(uint64_t sync) { Spy* s = spy(); gapic::Lock<Spy> lock__(s); return s->glIsSyncAPPLE(sync); } -EXPORT bool STDCALL glIsTextureHandleResidentNV(uint64_t handle) { +EXPORT uint8_t STDCALL glIsTextureHandleResidentNV(uint64_t handle) { Spy* s = spy(); gapic::Lock<Spy> lock__(s); return s->glIsTextureHandleResidentNV(handle); } -EXPORT bool STDCALL glIsVertexArrayOES(uint32_t array) { +EXPORT uint8_t STDCALL glIsVertexArrayOES(uint32_t array) { Spy* s = spy(); gapic::Lock<Spy> lock__(s); return s->glIsVertexArrayOES(array); @@ -4449,7 +4449,7 @@ EXPORT void STDCALL glDepthFunc(uint32_t function) { gapic::Lock<Spy> lock__(s); s->glDepthFunc(function); } -EXPORT void STDCALL glSampleCoverage(float value, bool invert) { +EXPORT void STDCALL glSampleCoverage(float value, uint8_t invert) { Spy* s = spy(); gapic::Lock<Spy> lock__(s); s->glSampleCoverage(value, invert); @@ -4550,7 +4550,7 @@ EXPORT void STDCALL glClearStencil(int32_t stencil) { gapic::Lock<Spy> lock__(s); s->glClearStencil(stencil); } -EXPORT void STDCALL glColorMask(bool red, bool green, bool blue, bool alpha) { +EXPORT void STDCALL glColorMask(uint8_t red, uint8_t green, uint8_t blue, uint8_t alpha) { Spy* s = spy(); gapic::Lock<Spy> lock__(s); s->glColorMask(red, green, blue, alpha); @@ -4565,7 +4565,7 @@ EXPORT void STDCALL glDeleteRenderbuffers(int32_t count, uint32_t* renderbuffers gapic::Lock<Spy> lock__(s); s->glDeleteRenderbuffers(count, renderbuffers); } -EXPORT void STDCALL glDepthMask(bool enabled) { +EXPORT void STDCALL glDepthMask(uint8_t enabled) { Spy* s = spy(); gapic::Lock<Spy> lock__(s); s->glDepthMask(enabled); @@ -4637,12 +4637,12 @@ EXPORT void STDCALL glInvalidateSubFramebuffer(uint32_t target, int32_t numAttac gapic::Lock<Spy> lock__(s); s->glInvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height); } -EXPORT bool STDCALL glIsFramebuffer(uint32_t framebuffer) { +EXPORT uint8_t STDCALL glIsFramebuffer(uint32_t framebuffer) { Spy* s = spy(); gapic::Lock<Spy> lock__(s); return s->glIsFramebuffer(framebuffer); } -EXPORT bool STDCALL glIsRenderbuffer(uint32_t renderbuffer) { +EXPORT uint8_t STDCALL glIsRenderbuffer(uint32_t renderbuffer) { Spy* s = spy(); gapic::Lock<Spy> lock__(s); return s->glIsRenderbuffer(renderbuffer); @@ -4960,17 +4960,17 @@ EXPORT void STDCALL glGetUniformuiv(uint32_t program, int32_t location, uint32_t gapic::Lock<Spy> lock__(s); s->glGetUniformuiv(program, location, params); } -EXPORT bool STDCALL glIsProgram(uint32_t program) { +EXPORT uint8_t STDCALL glIsProgram(uint32_t program) { Spy* s = spy(); gapic::Lock<Spy> lock__(s); return s->glIsProgram(program); } -EXPORT bool STDCALL glIsProgramPipeline(uint32_t pipeline) { +EXPORT uint8_t STDCALL glIsProgramPipeline(uint32_t pipeline) { Spy* s = spy(); gapic::Lock<Spy> lock__(s); return s->glIsProgramPipeline(pipeline); } -EXPORT bool STDCALL glIsShader(uint32_t shader) { +EXPORT uint8_t STDCALL glIsShader(uint32_t shader) { Spy* s = spy(); gapic::Lock<Spy> lock__(s); return s->glIsShader(shader); @@ -5453,7 +5453,7 @@ EXPORT void STDCALL glGetBooleani_v(uint32_t target, uint32_t index, uint8_t* da gapic::Lock<Spy> lock__(s); s->glGetBooleani_v(target, index, data); } -EXPORT void STDCALL glGetBooleanv(uint32_t param, bool* values) { +EXPORT void STDCALL glGetBooleanv(uint32_t param, uint8_t* values) { Spy* s = spy(); gapic::Lock<Spy> lock__(s); s->glGetBooleanv(param, values); @@ -5499,7 +5499,7 @@ EXPORT uint8_t* STDCALL glGetStringi(uint32_t name, uint32_t index) { gapic::Lock<Spy> lock__(s); return s->glGetStringi(name, index); } -EXPORT bool STDCALL glIsEnabled(uint32_t capability) { +EXPORT uint8_t STDCALL glIsEnabled(uint32_t capability) { Spy* s = spy(); gapic::Lock<Spy> lock__(s); return s->glIsEnabled(capability); @@ -5525,7 +5525,7 @@ glGetSynciv(uint64_t sync, uint32_t pname, int32_t bufSize, int32_t* length, int gapic::Lock<Spy> lock__(s); s->glGetSynciv(sync, pname, bufSize, length, values); } -EXPORT bool STDCALL glIsSync(uint64_t sync) { +EXPORT uint8_t STDCALL glIsSync(uint64_t sync) { Spy* s = spy(); gapic::Lock<Spy> lock__(s); return s->glIsSync(sync); @@ -5666,12 +5666,12 @@ EXPORT void STDCALL glGetTexParameteriv(uint32_t target, uint32_t parameter, int gapic::Lock<Spy> lock__(s); s->glGetTexParameteriv(target, parameter, values); } -EXPORT bool STDCALL glIsSampler(uint32_t sampler) { +EXPORT uint8_t STDCALL glIsSampler(uint32_t sampler) { Spy* s = spy(); gapic::Lock<Spy> lock__(s); return s->glIsSampler(sampler); } -EXPORT bool STDCALL glIsTexture(uint32_t texture) { +EXPORT uint8_t STDCALL glIsTexture(uint32_t texture) { Spy* s = spy(); gapic::Lock<Spy> lock__(s); return s->glIsTexture(texture); @@ -5803,7 +5803,7 @@ EXPORT void STDCALL glGetTransformFeedbackVarying(uint32_t program, uint32_t ind gapic::Lock<Spy> lock__(s); s->glGetTransformFeedbackVarying(program, index, bufSize, length, size, type, name); } -EXPORT bool STDCALL glIsTransformFeedback(uint32_t id) { +EXPORT uint8_t STDCALL glIsTransformFeedback(uint32_t id) { Spy* s = spy(); gapic::Lock<Spy> lock__(s); return s->glIsTransformFeedback(id); @@ -5880,7 +5880,7 @@ EXPORT void STDCALL glGetVertexAttribiv(uint32_t index, uint32_t pname, int32_t* gapic::Lock<Spy> lock__(s); s->glGetVertexAttribiv(index, pname, params); } -EXPORT bool STDCALL glIsVertexArray(uint32_t array) { +EXPORT uint8_t STDCALL glIsVertexArray(uint32_t array) { Spy* s = spy(); gapic::Lock<Spy> lock__(s); return s->glIsVertexArray(array); @@ -5976,7 +5976,7 @@ glVertexAttribIPointer(uint32_t index, int32_t size, uint32_t type, int32_t stri s->glVertexAttribIPointer(index, size, type, stride, pointer); } EXPORT void STDCALL glVertexAttribPointer(uint32_t location, int32_t size, uint32_t type, - bool normalized, int32_t stride, void* data) { + uint8_t normalized, int32_t stride, void* data) { Spy* s = spy(); gapic::Lock<Spy> lock__(s); s->glVertexAttribPointer(location, size, type, normalized, stride, data); diff --git a/cc/gapii/gles_imports.h b/cc/gapii/gles_imports.h index 87fd52b5c..e3e9722cf 100644 --- a/cc/gapii/gles_imports.h +++ b/cc/gapii/gles_imports.h @@ -69,7 +69,7 @@ struct GlesImports { int32_t *params); typedef void(STDCALL *PFNGLGETTEXPARAMETERIUIVEXT)(uint32_t target, uint32_t pname, uint32_t *params); - typedef bool(STDCALL *PFNGLISENABLEDIEXT)(uint32_t target, uint32_t index); + typedef uint8_t(STDCALL *PFNGLISENABLEDIEXT)(uint32_t target, uint32_t index); typedef void(STDCALL *PFNGLMINSAMPLESHADINGOES)(float value); typedef void(STDCALL *PFNGLOBJECTLABELKHR)(uint32_t identifier, uint32_t name, int32_t length, char *label); @@ -104,7 +104,7 @@ struct GlesImports { typedef void(STDCALL *PFNGLGETQUERYOBJECTUIV)(uint32_t query, uint32_t parameter, uint32_t *value); typedef void(STDCALL *PFNGLGETQUERYIV)(uint32_t target, uint32_t parameter, int32_t *value); - typedef bool(STDCALL *PFNGLISQUERY)(uint32_t query); + typedef uint8_t(STDCALL *PFNGLISQUERY)(uint32_t query); typedef void(STDCALL *PFNGLBINDBUFFER)(uint32_t target, uint32_t buffer); typedef void(STDCALL *PFNGLBINDBUFFERBASE)(uint32_t target, uint32_t index, uint32_t buffer); typedef void(STDCALL *PFNGLBINDBUFFERRANGE)(uint32_t target, uint32_t index, uint32_t buffer, @@ -123,7 +123,7 @@ struct GlesImports { typedef void(STDCALL *PFNGLGETBUFFERPARAMETERIV)(uint32_t target, uint32_t parameter, int32_t *value); typedef void(STDCALL *PFNGLGETBUFFERPOINTERV)(uint32_t target, uint32_t pname, void **params); - typedef bool(STDCALL *PFNGLISBUFFER)(uint32_t buffer); + typedef uint8_t(STDCALL *PFNGLISBUFFER)(uint32_t buffer); typedef void *(STDCALL *PFNGLMAPBUFFERRANGE)(uint32_t target, int32_t offset, int32_t length, uint32_t access); typedef uint8_t(STDCALL *PFNGLUNMAPBUFFER)(uint32_t target); @@ -464,18 +464,19 @@ struct GlesImports { typedef void(STDCALL *PFNGLINSERTEVENTMARKEREXT)(int32_t length, char *marker); typedef void(STDCALL *PFNGLINTERPOLATEPATHSNV)(uint32_t resultPath, uint32_t pathA, uint32_t pathB, float weight); - typedef bool(STDCALL *PFNGLISENABLEDIOES)(uint32_t target, uint32_t index); - typedef bool(STDCALL *PFNGLISENABLEDINV)(uint32_t target, uint32_t index); - typedef bool(STDCALL *PFNGLISFENCENV)(uint32_t fence); - typedef bool(STDCALL *PFNGLISIMAGEHANDLERESIDENTNV)(uint64_t handle); - typedef bool(STDCALL *PFNGLISPATHNV)(uint32_t path); - typedef bool(STDCALL *PFNGLISPOINTINFILLPATHNV)(uint32_t path, uint32_t mask, float x, float y); - typedef bool(STDCALL *PFNGLISPOINTINSTROKEPATHNV)(uint32_t path, float x, float y); - typedef bool(STDCALL *PFNGLISPROGRAMPIPELINEEXT)(uint32_t pipeline); - typedef bool(STDCALL *PFNGLISQUERYEXT)(uint32_t query); - typedef bool(STDCALL *PFNGLISSYNCAPPLE)(uint64_t sync); - typedef bool(STDCALL *PFNGLISTEXTUREHANDLERESIDENTNV)(uint64_t handle); - typedef bool(STDCALL *PFNGLISVERTEXARRAYOES)(uint32_t array); + typedef uint8_t(STDCALL *PFNGLISENABLEDIOES)(uint32_t target, uint32_t index); + typedef uint8_t(STDCALL *PFNGLISENABLEDINV)(uint32_t target, uint32_t index); + typedef uint8_t(STDCALL *PFNGLISFENCENV)(uint32_t fence); + typedef uint8_t(STDCALL *PFNGLISIMAGEHANDLERESIDENTNV)(uint64_t handle); + typedef uint8_t(STDCALL *PFNGLISPATHNV)(uint32_t path); + typedef uint8_t(STDCALL *PFNGLISPOINTINFILLPATHNV)(uint32_t path, uint32_t mask, float x, + float y); + typedef uint8_t(STDCALL *PFNGLISPOINTINSTROKEPATHNV)(uint32_t path, float x, float y); + typedef uint8_t(STDCALL *PFNGLISPROGRAMPIPELINEEXT)(uint32_t pipeline); + typedef uint8_t(STDCALL *PFNGLISQUERYEXT)(uint32_t query); + typedef uint8_t(STDCALL *PFNGLISSYNCAPPLE)(uint64_t sync); + typedef uint8_t(STDCALL *PFNGLISTEXTUREHANDLERESIDENTNV)(uint64_t handle); + typedef uint8_t(STDCALL *PFNGLISVERTEXARRAYOES)(uint32_t array); typedef void(STDCALL *PFNGLLABELOBJECTEXT)(uint32_t type, uint32_t object, int32_t length, char *label); typedef void(STDCALL *PFNGLMAKEIMAGEHANDLENONRESIDENTNV)(uint64_t handle); @@ -807,7 +808,7 @@ struct GlesImports { uint32_t src_factor_alpha, uint32_t dst_factor_alpha); typedef void(STDCALL *PFNGLDEPTHFUNC)(uint32_t function); - typedef void(STDCALL *PFNGLSAMPLECOVERAGE)(float value, bool invert); + typedef void(STDCALL *PFNGLSAMPLECOVERAGE)(float value, uint8_t invert); typedef void(STDCALL *PFNGLSAMPLEMASKI)(uint32_t maskNumber, uint32_t mask); typedef void(STDCALL *PFNGLSCISSOR)(int32_t x, int32_t y, int32_t width, int32_t height); typedef void(STDCALL *PFNGLSTENCILFUNC)(uint32_t func, int32_t ref, uint32_t mask); @@ -834,10 +835,10 @@ struct GlesImports { typedef void(STDCALL *PFNGLCLEARCOLOR)(float r, float g, float b, float a); typedef void(STDCALL *PFNGLCLEARDEPTHF)(float depth); typedef void(STDCALL *PFNGLCLEARSTENCIL)(int32_t stencil); - typedef void(STDCALL *PFNGLCOLORMASK)(bool red, bool green, bool blue, bool alpha); + typedef void(STDCALL *PFNGLCOLORMASK)(uint8_t red, uint8_t green, uint8_t blue, uint8_t alpha); typedef void(STDCALL *PFNGLDELETEFRAMEBUFFERS)(int32_t count, uint32_t *framebuffers); typedef void(STDCALL *PFNGLDELETERENDERBUFFERS)(int32_t count, uint32_t *renderbuffers); - typedef void(STDCALL *PFNGLDEPTHMASK)(bool enabled); + typedef void(STDCALL *PFNGLDEPTHMASK)(uint8_t enabled); typedef void(STDCALL *PFNGLFRAMEBUFFERPARAMETERI)(uint32_t target, uint32_t pname, int32_t param); typedef void(STDCALL *PFNGLFRAMEBUFFERRENDERBUFFER)(uint32_t framebuffer_target, @@ -866,8 +867,8 @@ struct GlesImports { typedef void(STDCALL *PFNGLINVALIDATESUBFRAMEBUFFER)(uint32_t target, int32_t numAttachments, uint32_t *attachments, int32_t x, int32_t y, int32_t width, int32_t height); - typedef bool(STDCALL *PFNGLISFRAMEBUFFER)(uint32_t framebuffer); - typedef bool(STDCALL *PFNGLISRENDERBUFFER)(uint32_t renderbuffer); + typedef uint8_t(STDCALL *PFNGLISFRAMEBUFFER)(uint32_t framebuffer); + typedef uint8_t(STDCALL *PFNGLISRENDERBUFFER)(uint32_t renderbuffer); typedef void(STDCALL *PFNGLREADBUFFER)(uint32_t src); typedef void(STDCALL *PFNGLREADPIXELS)(int32_t x, int32_t y, int32_t width, int32_t height, uint32_t format, uint32_t type, void *data); @@ -964,9 +965,9 @@ struct GlesImports { typedef void(STDCALL *PFNGLGETUNIFORMFV)(uint32_t program, int32_t location, float *values); typedef void(STDCALL *PFNGLGETUNIFORMIV)(uint32_t program, int32_t location, int32_t *values); typedef void(STDCALL *PFNGLGETUNIFORMUIV)(uint32_t program, int32_t location, uint32_t *params); - typedef bool(STDCALL *PFNGLISPROGRAM)(uint32_t program); - typedef bool(STDCALL *PFNGLISPROGRAMPIPELINE)(uint32_t pipeline); - typedef bool(STDCALL *PFNGLISSHADER)(uint32_t shader); + typedef uint8_t(STDCALL *PFNGLISPROGRAM)(uint32_t program); + typedef uint8_t(STDCALL *PFNGLISPROGRAMPIPELINE)(uint32_t pipeline); + typedef uint8_t(STDCALL *PFNGLISSHADER)(uint32_t shader); typedef void(STDCALL *PFNGLLINKPROGRAM)(uint32_t program); typedef void(STDCALL *PFNGLMEMORYBARRIER)(uint32_t barriers); typedef void(STDCALL *PFNGLMEMORYBARRIERBYREGION)(uint32_t barriers); @@ -1113,7 +1114,7 @@ struct GlesImports { typedef void(STDCALL *PFNGLPOLYGONOFFSET)(float scale_factor, float units); typedef void(STDCALL *PFNGLVIEWPORT)(int32_t x, int32_t y, int32_t width, int32_t height); typedef void(STDCALL *PFNGLGETBOOLEANI_V)(uint32_t target, uint32_t index, uint8_t *data); - typedef void(STDCALL *PFNGLGETBOOLEANV)(uint32_t param, bool *values); + typedef void(STDCALL *PFNGLGETBOOLEANV)(uint32_t param, uint8_t *values); typedef void(STDCALL *PFNGLGETFLOATV)(uint32_t param, float *values); typedef void(STDCALL *PFNGLGETINTEGER64I_V)(uint32_t target, uint32_t index, int64_t *data); typedef void(STDCALL *PFNGLGETINTEGER64V)(uint32_t pname, int64_t *data); @@ -1124,14 +1125,14 @@ struct GlesImports { int32_t *params); typedef uint8_t *(STDCALL *PFNGLGETSTRING)(uint32_t param); typedef uint8_t *(STDCALL *PFNGLGETSTRINGI)(uint32_t name, uint32_t index); - typedef bool(STDCALL *PFNGLISENABLED)(uint32_t capability); + typedef uint8_t(STDCALL *PFNGLISENABLED)(uint32_t capability); typedef uint32_t(STDCALL *PFNGLCLIENTWAITSYNC)(uint64_t sync, uint32_t syncFlags, uint64_t timeout); typedef void(STDCALL *PFNGLDELETESYNC)(uint64_t sync); typedef uint64_t(STDCALL *PFNGLFENCESYNC)(uint32_t condition, uint32_t syncFlags); typedef void(STDCALL *PFNGLGETSYNCIV)(uint64_t sync, uint32_t pname, int32_t bufSize, int32_t *length, int32_t *values); - typedef bool(STDCALL *PFNGLISSYNC)(uint64_t sync); + typedef uint8_t(STDCALL *PFNGLISSYNC)(uint64_t sync); typedef void(STDCALL *PFNGLWAITSYNC)(uint64_t sync, uint32_t syncFlags, uint64_t timeout); typedef void(STDCALL *PFNGLACTIVETEXTURE)(uint32_t unit); typedef void(STDCALL *PFNGLBINDIMAGETEXTURE)(uint32_t unit, uint32_t texture, int32_t level, @@ -1184,8 +1185,8 @@ struct GlesImports { float *values); typedef void(STDCALL *PFNGLGETTEXPARAMETERIV)(uint32_t target, uint32_t parameter, int32_t *values); - typedef bool(STDCALL *PFNGLISSAMPLER)(uint32_t sampler); - typedef bool(STDCALL *PFNGLISTEXTURE)(uint32_t texture); + typedef uint8_t(STDCALL *PFNGLISSAMPLER)(uint32_t sampler); + typedef uint8_t(STDCALL *PFNGLISTEXTURE)(uint32_t texture); typedef void(STDCALL *PFNGLPIXELSTOREI)(uint32_t parameter, int32_t value); typedef void(STDCALL *PFNGLSAMPLERPARAMETERF)(uint32_t sampler, uint32_t pname, float param); typedef void(STDCALL *PFNGLSAMPLERPARAMETERFV)(uint32_t sampler, uint32_t pname, float *param); @@ -1229,7 +1230,7 @@ struct GlesImports { int32_t bufSize, int32_t *length, int32_t *size, uint32_t *type, char *name); - typedef bool(STDCALL *PFNGLISTRANSFORMFEEDBACK)(uint32_t id); + typedef uint8_t(STDCALL *PFNGLISTRANSFORMFEEDBACK)(uint32_t id); typedef void(STDCALL *PFNGLPAUSETRANSFORMFEEDBACK)(); typedef void(STDCALL *PFNGLRESUMETRANSFORMFEEDBACK)(); typedef void(STDCALL *PFNGLTRANSFORMFEEDBACKVARYINGS)(uint32_t program, int32_t count, @@ -1248,7 +1249,7 @@ struct GlesImports { void **pointer); typedef void(STDCALL *PFNGLGETVERTEXATTRIBFV)(uint32_t index, uint32_t pname, float *params); typedef void(STDCALL *PFNGLGETVERTEXATTRIBIV)(uint32_t index, uint32_t pname, int32_t *params); - typedef bool(STDCALL *PFNGLISVERTEXARRAY)(uint32_t array); + typedef uint8_t(STDCALL *PFNGLISVERTEXARRAY)(uint32_t array); typedef void(STDCALL *PFNGLVERTEXATTRIB1F)(uint32_t location, float value0); typedef void(STDCALL *PFNGLVERTEXATTRIB1FV)(uint32_t location, float *value); typedef void(STDCALL *PFNGLVERTEXATTRIB2F)(uint32_t location, float value0, float value1); @@ -1275,7 +1276,7 @@ struct GlesImports { typedef void(STDCALL *PFNGLVERTEXATTRIBIPOINTER)(uint32_t index, int32_t size, uint32_t type, int32_t stride, void *pointer); typedef void(STDCALL *PFNGLVERTEXATTRIBPOINTER)(uint32_t location, int32_t size, uint32_t type, - bool normalized, int32_t stride, void *data); + uint8_t normalized, int32_t stride, void *data); typedef void(STDCALL *PFNGLVERTEXBINDINGDIVISOR)(uint32_t bindingindex, uint32_t divisor); typedef int(STDCALL *PFNEGLINITIALIZE)(void *dpy, int *major, int *minor); typedef void *(STDCALL *PFNEGLCREATECONTEXT)(void *display, void *config, void *share_context, diff --git a/cc/gapii/gles_spy.h b/cc/gapii/gles_spy.h index 88cb67a82..97fb64918 100644 --- a/cc/gapii/gles_spy.h +++ b/cc/gapii/gles_spy.h @@ -75,7 +75,7 @@ public: inline void glGetSamplerParameterIuivEXT(uint32_t sampler, uint32_t pname, uint32_t* params); inline void glGetTexParameterIivEXT(uint32_t target, uint32_t pname, int32_t* params); inline void glGetTexParameterIuivEXT(uint32_t target, uint32_t pname, uint32_t* params); - inline bool glIsEnablediEXT(uint32_t target, uint32_t index); + inline uint8_t glIsEnablediEXT(uint32_t target, uint32_t index); inline void glMinSampleShadingOES(float value); inline void glObjectLabelKHR(uint32_t identifier, uint32_t name, int32_t length, char* label); inline void glObjectPtrLabelKHR(void* ptr, int32_t length, char* label); @@ -100,7 +100,7 @@ public: inline void glGenQueries(int32_t count, uint32_t* queries); inline void glGetQueryObjectuiv(uint32_t query, uint32_t parameter, uint32_t* value); inline void glGetQueryiv(uint32_t target, uint32_t parameter, int32_t* value); - inline bool glIsQuery(uint32_t query); + inline uint8_t glIsQuery(uint32_t query); inline void glBindBuffer(uint32_t target, uint32_t buffer); inline void glBindBufferBase(uint32_t target, uint32_t index, uint32_t buffer); inline void glBindBufferRange(uint32_t target, uint32_t index, uint32_t buffer, int32_t offset, @@ -114,7 +114,7 @@ public: inline void glGetBufferParameteri64v(uint32_t target, uint32_t pname, int64_t* params); inline void glGetBufferParameteriv(uint32_t target, uint32_t parameter, int32_t* value); inline void glGetBufferPointerv(uint32_t target, uint32_t pname, void** params); - inline bool glIsBuffer(uint32_t buffer); + inline uint8_t glIsBuffer(uint32_t buffer); inline void* glMapBufferRange(uint32_t target, int32_t offset, int32_t length, uint32_t access); inline uint8_t glUnmapBuffer(uint32_t target); inline void glDrawArrays(uint32_t draw_mode, int32_t first_index, int32_t index_count); @@ -386,18 +386,18 @@ public: inline void glInsertEventMarkerEXT(int32_t length, char* marker); inline void glInterpolatePathsNV(uint32_t resultPath, uint32_t pathA, uint32_t pathB, float weight); - inline bool glIsEnablediOES(uint32_t target, uint32_t index); - inline bool glIsEnablediNV(uint32_t target, uint32_t index); - inline bool glIsFenceNV(uint32_t fence); - inline bool glIsImageHandleResidentNV(uint64_t handle); - inline bool glIsPathNV(uint32_t path); - inline bool glIsPointInFillPathNV(uint32_t path, uint32_t mask, float x, float y); - inline bool glIsPointInStrokePathNV(uint32_t path, float x, float y); - inline bool glIsProgramPipelineEXT(uint32_t pipeline); - inline bool glIsQueryEXT(uint32_t query); - inline bool glIsSyncAPPLE(uint64_t sync); - inline bool glIsTextureHandleResidentNV(uint64_t handle); - inline bool glIsVertexArrayOES(uint32_t array); + inline uint8_t glIsEnablediOES(uint32_t target, uint32_t index); + inline uint8_t glIsEnablediNV(uint32_t target, uint32_t index); + inline uint8_t glIsFenceNV(uint32_t fence); + inline uint8_t glIsImageHandleResidentNV(uint64_t handle); + inline uint8_t glIsPathNV(uint32_t path); + inline uint8_t glIsPointInFillPathNV(uint32_t path, uint32_t mask, float x, float y); + inline uint8_t glIsPointInStrokePathNV(uint32_t path, float x, float y); + inline uint8_t glIsProgramPipelineEXT(uint32_t pipeline); + inline uint8_t glIsQueryEXT(uint32_t query); + inline uint8_t glIsSyncAPPLE(uint64_t sync); + inline uint8_t glIsTextureHandleResidentNV(uint64_t handle); + inline uint8_t glIsVertexArrayOES(uint32_t array); inline void glLabelObjectEXT(uint32_t type, uint32_t object, int32_t length, char* label); inline void glMakeImageHandleNonResidentNV(uint64_t handle); inline void glMakeImageHandleResidentNV(uint64_t handle, uint32_t access); @@ -677,7 +677,7 @@ public: inline void glBlendFuncSeparate(uint32_t src_factor_rgb, uint32_t dst_factor_rgb, uint32_t src_factor_alpha, uint32_t dst_factor_alpha); inline void glDepthFunc(uint32_t function); - inline void glSampleCoverage(float value, bool invert); + inline void glSampleCoverage(float value, uint8_t invert); inline void glSampleMaski(uint32_t maskNumber, uint32_t mask); inline void glScissor(int32_t x, int32_t y, int32_t width, int32_t height); inline void glStencilFunc(uint32_t func, int32_t ref, uint32_t mask); @@ -701,10 +701,10 @@ public: inline void glClearColor(float r, float g, float b, float a); inline void glClearDepthf(float depth); inline void glClearStencil(int32_t stencil); - inline void glColorMask(bool red, bool green, bool blue, bool alpha); + inline void glColorMask(uint8_t red, uint8_t green, uint8_t blue, uint8_t alpha); inline void glDeleteFramebuffers(int32_t count, uint32_t* framebuffers); inline void glDeleteRenderbuffers(int32_t count, uint32_t* renderbuffers); - inline void glDepthMask(bool enabled); + inline void glDepthMask(uint8_t enabled); inline void glFramebufferParameteri(uint32_t target, uint32_t pname, int32_t param); inline void glFramebufferRenderbuffer(uint32_t framebuffer_target, uint32_t framebuffer_attachment, @@ -724,8 +724,8 @@ public: inline void glInvalidateSubFramebuffer(uint32_t target, int32_t numAttachments, uint32_t* attachments, int32_t x, int32_t y, int32_t width, int32_t height); - inline bool glIsFramebuffer(uint32_t framebuffer); - inline bool glIsRenderbuffer(uint32_t renderbuffer); + inline uint8_t glIsFramebuffer(uint32_t framebuffer); + inline uint8_t glIsRenderbuffer(uint32_t renderbuffer); inline void glReadBuffer(uint32_t src); inline void glReadPixels(int32_t x, int32_t y, int32_t width, int32_t height, uint32_t format, uint32_t type, void* data); @@ -810,9 +810,9 @@ public: inline void glGetUniformfv(uint32_t program, int32_t location, float* values); inline void glGetUniformiv(uint32_t program, int32_t location, int32_t* values); inline void glGetUniformuiv(uint32_t program, int32_t location, uint32_t* params); - inline bool glIsProgram(uint32_t program); - inline bool glIsProgramPipeline(uint32_t pipeline); - inline bool glIsShader(uint32_t shader); + inline uint8_t glIsProgram(uint32_t program); + inline uint8_t glIsProgramPipeline(uint32_t pipeline); + inline uint8_t glIsShader(uint32_t shader); inline void glLinkProgram(uint32_t program); inline void glMemoryBarrier(uint32_t barriers); inline void glMemoryBarrierByRegion(uint32_t barriers); @@ -941,7 +941,7 @@ public: inline void glPolygonOffset(float scale_factor, float units); inline void glViewport(int32_t x, int32_t y, int32_t width, int32_t height); inline void glGetBooleani_v(uint32_t target, uint32_t index, uint8_t* data); - inline void glGetBooleanv(uint32_t param, bool* values); + inline void glGetBooleanv(uint32_t param, uint8_t* values); inline void glGetFloatv(uint32_t param, float* values); inline void glGetInteger64i_v(uint32_t target, uint32_t index, int64_t* data); inline void glGetInteger64v(uint32_t pname, int64_t* data); @@ -951,13 +951,13 @@ public: int32_t bufSize, int32_t* params); inline uint8_t* glGetString(uint32_t param); inline uint8_t* glGetStringi(uint32_t name, uint32_t index); - inline bool glIsEnabled(uint32_t capability); + inline uint8_t glIsEnabled(uint32_t capability); inline uint32_t glClientWaitSync(uint64_t sync, uint32_t syncFlags, uint64_t timeout); inline void glDeleteSync(uint64_t sync); inline uint64_t glFenceSync(uint32_t condition, uint32_t syncFlags); inline void glGetSynciv(uint64_t sync, uint32_t pname, int32_t bufSize, int32_t* length, int32_t* values); - inline bool glIsSync(uint64_t sync); + inline uint8_t glIsSync(uint64_t sync); inline void glWaitSync(uint64_t sync, uint32_t syncFlags, uint64_t timeout); inline void glActiveTexture(uint32_t unit); inline void glBindImageTexture(uint32_t unit, uint32_t texture, int32_t level, uint8_t layered, @@ -998,8 +998,8 @@ public: int32_t* params); inline void glGetTexParameterfv(uint32_t target, uint32_t parameter, float* values); inline void glGetTexParameteriv(uint32_t target, uint32_t parameter, int32_t* values); - inline bool glIsSampler(uint32_t sampler); - inline bool glIsTexture(uint32_t texture); + inline uint8_t glIsSampler(uint32_t sampler); + inline uint8_t glIsTexture(uint32_t texture); inline void glPixelStorei(uint32_t parameter, int32_t value); inline void glSamplerParameterf(uint32_t sampler, uint32_t pname, float param); inline void glSamplerParameterfv(uint32_t sampler, uint32_t pname, float* param); @@ -1036,7 +1036,7 @@ public: inline void glGetTransformFeedbackVarying(uint32_t program, uint32_t index, int32_t bufSize, int32_t* length, int32_t* size, uint32_t* type, char* name); - inline bool glIsTransformFeedback(uint32_t id); + inline uint8_t glIsTransformFeedback(uint32_t id); inline void glPauseTransformFeedback(); inline void glResumeTransformFeedback(); inline void glTransformFeedbackVaryings(uint32_t program, int32_t count, char** varyings, @@ -1053,7 +1053,7 @@ public: inline void glGetVertexAttribPointerv(uint32_t index, uint32_t pname, void** pointer); inline void glGetVertexAttribfv(uint32_t index, uint32_t pname, float* params); inline void glGetVertexAttribiv(uint32_t index, uint32_t pname, int32_t* params); - inline bool glIsVertexArray(uint32_t array); + inline uint8_t glIsVertexArray(uint32_t array); inline void glVertexAttrib1f(uint32_t location, float value0); inline void glVertexAttrib1fv(uint32_t location, float* value); inline void glVertexAttrib2f(uint32_t location, float value0, float value1); @@ -1076,7 +1076,7 @@ public: inline void glVertexAttribIPointer(uint32_t index, int32_t size, uint32_t type, int32_t stride, void* pointer); inline void glVertexAttribPointer(uint32_t location, int32_t size, uint32_t type, - bool normalized, int32_t stride, void* data); + uint8_t normalized, int32_t stride, void* data); inline void glVertexBindingDivisor(uint32_t bindingindex, uint32_t divisor); inline int eglInitialize(void* dpy, int* major, int* minor); inline void* eglCreateContext(void* display, void* config, void* share_context, @@ -1545,10 +1545,10 @@ inline void GlesSpy::glGetTexParameterIuivEXT(uint32_t target, uint32_t pname, u mEncoder->Object(&coder); } -inline bool GlesSpy::glIsEnablediEXT(uint32_t target, uint32_t index) { +inline uint8_t GlesSpy::glIsEnablediEXT(uint32_t target, uint32_t index) { GAPID_INFO("glIsEnablediEXT(%u, %" PRIu32 ")\n", target, index); - bool result = false; + uint8_t result = 0; Observations observations; do { @@ -1973,10 +1973,10 @@ inline void GlesSpy::glGetQueryiv(uint32_t target, uint32_t parameter, int32_t* mEncoder->Object(&coder); } -inline bool GlesSpy::glIsQuery(uint32_t query) { +inline uint8_t GlesSpy::glIsQuery(uint32_t query) { GAPID_INFO("glIsQuery(%" PRIu32 ")\n", query); - bool result = false; + uint8_t result = 0; Observations observations; do { @@ -2451,10 +2451,10 @@ inline void GlesSpy::glGetBufferPointerv(uint32_t target, uint32_t pname, void** mEncoder->Object(&coder); } -inline bool GlesSpy::glIsBuffer(uint32_t buffer) { +inline uint8_t GlesSpy::glIsBuffer(uint32_t buffer) { GAPID_INFO("glIsBuffer(%" PRIu32 ")\n", buffer); - bool result = false; + uint8_t result = 0; Observations observations; do { @@ -6104,10 +6104,10 @@ inline void GlesSpy::glInterpolatePathsNV(uint32_t resultPath, uint32_t pathA, u mEncoder->Object(&coder); } -inline bool GlesSpy::glIsEnablediOES(uint32_t target, uint32_t index) { +inline uint8_t GlesSpy::glIsEnablediOES(uint32_t target, uint32_t index) { GAPID_INFO("glIsEnablediOES(%u, %" PRIu32 ")\n", target, index); - bool result = false; + uint8_t result = 0; Observations observations; do { @@ -6124,10 +6124,10 @@ inline bool GlesSpy::glIsEnablediOES(uint32_t target, uint32_t index) { return result; } -inline bool GlesSpy::glIsEnablediNV(uint32_t target, uint32_t index) { +inline uint8_t GlesSpy::glIsEnablediNV(uint32_t target, uint32_t index) { GAPID_INFO("glIsEnablediNV(%u, %" PRIu32 ")\n", target, index); - bool result = false; + uint8_t result = 0; Observations observations; do { @@ -6144,10 +6144,10 @@ inline bool GlesSpy::glIsEnablediNV(uint32_t target, uint32_t index) { return result; } -inline bool GlesSpy::glIsFenceNV(uint32_t fence) { +inline uint8_t GlesSpy::glIsFenceNV(uint32_t fence) { GAPID_INFO("glIsFenceNV(%" PRIu32 ")\n", fence); - bool result = false; + uint8_t result = 0; Observations observations; do { @@ -6164,10 +6164,10 @@ inline bool GlesSpy::glIsFenceNV(uint32_t fence) { return result; } -inline bool GlesSpy::glIsImageHandleResidentNV(uint64_t handle) { +inline uint8_t GlesSpy::glIsImageHandleResidentNV(uint64_t handle) { GAPID_INFO("glIsImageHandleResidentNV(%" PRIu64 ")\n", handle); - bool result = false; + uint8_t result = 0; Observations observations; do { @@ -6184,10 +6184,10 @@ inline bool GlesSpy::glIsImageHandleResidentNV(uint64_t handle) { return result; } -inline bool GlesSpy::glIsPathNV(uint32_t path) { +inline uint8_t GlesSpy::glIsPathNV(uint32_t path) { GAPID_INFO("glIsPathNV(%" PRIu32 ")\n", path); - bool result = false; + uint8_t result = 0; Observations observations; do { @@ -6204,10 +6204,10 @@ inline bool GlesSpy::glIsPathNV(uint32_t path) { return result; } -inline bool GlesSpy::glIsPointInFillPathNV(uint32_t path, uint32_t mask, float x, float y) { +inline uint8_t GlesSpy::glIsPointInFillPathNV(uint32_t path, uint32_t mask, float x, float y) { GAPID_INFO("glIsPointInFillPathNV(%" PRIu32 ", %" PRIu32 ", %f, %f)\n", path, mask, x, y); - bool result = false; + uint8_t result = 0; Observations observations; do { @@ -6224,10 +6224,10 @@ inline bool GlesSpy::glIsPointInFillPathNV(uint32_t path, uint32_t mask, float x return result; } -inline bool GlesSpy::glIsPointInStrokePathNV(uint32_t path, float x, float y) { +inline uint8_t GlesSpy::glIsPointInStrokePathNV(uint32_t path, float x, float y) { GAPID_INFO("glIsPointInStrokePathNV(%" PRIu32 ", %f, %f)\n", path, x, y); - bool result = false; + uint8_t result = 0; Observations observations; do { @@ -6244,10 +6244,10 @@ inline bool GlesSpy::glIsPointInStrokePathNV(uint32_t path, float x, float y) { return result; } -inline bool GlesSpy::glIsProgramPipelineEXT(uint32_t pipeline) { +inline uint8_t GlesSpy::glIsProgramPipelineEXT(uint32_t pipeline) { GAPID_INFO("glIsProgramPipelineEXT(%" PRIu32 ")\n", pipeline); - bool result = false; + uint8_t result = 0; Observations observations; do { @@ -6264,10 +6264,10 @@ inline bool GlesSpy::glIsProgramPipelineEXT(uint32_t pipeline) { return result; } -inline bool GlesSpy::glIsQueryEXT(uint32_t query) { +inline uint8_t GlesSpy::glIsQueryEXT(uint32_t query) { GAPID_INFO("glIsQueryEXT(%" PRIu32 ")\n", query); - bool result = false; + uint8_t result = 0; Observations observations; do { @@ -6288,10 +6288,10 @@ inline bool GlesSpy::glIsQueryEXT(uint32_t query) { return result; } -inline bool GlesSpy::glIsSyncAPPLE(uint64_t sync) { +inline uint8_t GlesSpy::glIsSyncAPPLE(uint64_t sync) { GAPID_INFO("glIsSyncAPPLE(%" PRIu64 ")\n", sync); - bool result = false; + uint8_t result = 0; Observations observations; do { @@ -6308,10 +6308,10 @@ inline bool GlesSpy::glIsSyncAPPLE(uint64_t sync) { return result; } -inline bool GlesSpy::glIsTextureHandleResidentNV(uint64_t handle) { +inline uint8_t GlesSpy::glIsTextureHandleResidentNV(uint64_t handle) { GAPID_INFO("glIsTextureHandleResidentNV(%" PRIu64 ")\n", handle); - bool result = false; + uint8_t result = 0; Observations observations; do { @@ -6328,10 +6328,10 @@ inline bool GlesSpy::glIsTextureHandleResidentNV(uint64_t handle) { return result; } -inline bool GlesSpy::glIsVertexArrayOES(uint32_t array) { +inline uint8_t GlesSpy::glIsVertexArrayOES(uint32_t array) { GAPID_INFO("glIsVertexArrayOES(%" PRIu32 ")\n", array); - bool result = false; + uint8_t result = 0; Observations observations; do { @@ -9592,8 +9592,8 @@ inline void GlesSpy::glDepthFunc(uint32_t function) { mEncoder->Object(&coder); } -inline void GlesSpy::glSampleCoverage(float value, bool invert) { - GAPID_INFO("glSampleCoverage(%f, %d)\n", value, invert); +inline void GlesSpy::glSampleCoverage(float value, uint8_t invert) { + GAPID_INFO("glSampleCoverage(%f, %" PRIu8 ")\n", value, invert); Observations observations; do { @@ -10156,8 +10156,9 @@ inline void GlesSpy::glClearStencil(int32_t stencil) { mEncoder->Object(&coder); } -inline void GlesSpy::glColorMask(bool red, bool green, bool blue, bool alpha) { - GAPID_INFO("glColorMask(%d, %d, %d, %d)\n", red, green, blue, alpha); +inline void GlesSpy::glColorMask(uint8_t red, uint8_t green, uint8_t blue, uint8_t alpha) { + GAPID_INFO("glColorMask(%" PRIu8 ", %" PRIu8 ", %" PRIu8 ", %" PRIu8 ")\n", red, green, blue, + alpha); Observations observations; do { @@ -10234,8 +10235,8 @@ inline void GlesSpy::glDeleteRenderbuffers(int32_t count, uint32_t* renderbuffer mEncoder->Object(&coder); } -inline void GlesSpy::glDepthMask(bool enabled) { - GAPID_INFO("glDepthMask(%d)\n", enabled); +inline void GlesSpy::glDepthMask(uint8_t enabled) { + GAPID_INFO("glDepthMask(%" PRIu8 ")\n", enabled); Observations observations; do { @@ -10842,10 +10843,10 @@ inline void GlesSpy::glInvalidateSubFramebuffer(uint32_t target, int32_t numAtta mEncoder->Object(&coder); } -inline bool GlesSpy::glIsFramebuffer(uint32_t framebuffer) { +inline uint8_t GlesSpy::glIsFramebuffer(uint32_t framebuffer) { GAPID_INFO("glIsFramebuffer(%" PRIu32 ")\n", framebuffer); - bool result = false; + uint8_t result = 0; Observations observations; do { @@ -10866,10 +10867,10 @@ inline bool GlesSpy::glIsFramebuffer(uint32_t framebuffer) { return result; } -inline bool GlesSpy::glIsRenderbuffer(uint32_t renderbuffer) { +inline uint8_t GlesSpy::glIsRenderbuffer(uint32_t renderbuffer) { GAPID_INFO("glIsRenderbuffer(%" PRIu32 ")\n", renderbuffer); - bool result = false; + uint8_t result = 0; Observations observations; do { @@ -12633,10 +12634,10 @@ inline void GlesSpy::glGetUniformuiv(uint32_t program, int32_t location, uint32_ mEncoder->Object(&coder); } -inline bool GlesSpy::glIsProgram(uint32_t program) { +inline uint8_t GlesSpy::glIsProgram(uint32_t program) { GAPID_INFO("glIsProgram(%" PRIu32 ")\n", program); - bool result = false; + uint8_t result = 0; Observations observations; do { @@ -12657,10 +12658,10 @@ inline bool GlesSpy::glIsProgram(uint32_t program) { return result; } -inline bool GlesSpy::glIsProgramPipeline(uint32_t pipeline) { +inline uint8_t GlesSpy::glIsProgramPipeline(uint32_t pipeline) { GAPID_INFO("glIsProgramPipeline(%" PRIu32 ")\n", pipeline); - bool result = false; + uint8_t result = 0; Observations observations; do { @@ -12678,10 +12679,10 @@ inline bool GlesSpy::glIsProgramPipeline(uint32_t pipeline) { return result; } -inline bool GlesSpy::glIsShader(uint32_t shader) { +inline uint8_t GlesSpy::glIsShader(uint32_t shader) { GAPID_INFO("glIsShader(%" PRIu32 ")\n", shader); - bool result = false; + uint8_t result = 0; Observations observations; do { @@ -14884,7 +14885,7 @@ inline void GlesSpy::glGetBooleani_v(uint32_t target, uint32_t index, uint8_t* d mEncoder->Object(&coder); } -inline void GlesSpy::glGetBooleanv(uint32_t param, bool* values) { +inline void GlesSpy::glGetBooleanv(uint32_t param, uint8_t* values) { GAPID_INFO("glGetBooleanv(%u, %p)\n", param, values); Observations observations; @@ -15092,7 +15093,7 @@ inline void GlesSpy::glGetBooleanv(uint32_t param, bool* values) { break; } } - Slice<bool> l_v = slice(values, (uint64_t)(0), (uint64_t)(stateVariableSize(param))); + Slice<GLboolean> l_v = slice(values, (uint64_t)(0), (uint64_t)(stateVariableSize(param))); std::shared_ptr<Context> l_context = this->Contexts[this->CurrentThread]; std::shared_ptr<Context> l_GetContext_855_result = l_context; std::shared_ptr<Context> l_ctx = l_GetContext_855_result; @@ -15100,39 +15101,40 @@ inline void GlesSpy::glGetBooleanv(uint32_t param, bool* values) { mImports.glGetBooleanv(param, values); switch (param) { case GLenum::GL_BLEND: { - write(l_v, 0, l_ctx->mCapabilities[GLenum::GL_BLEND]); + write(l_v, 0, (GLboolean)(l_ctx->mCapabilities[GLenum::GL_BLEND])); break; } case GLenum::GL_CULL_FACE: { - write(l_v, 0, l_ctx->mCapabilities[GLenum::GL_CULL_FACE]); + write(l_v, 0, (GLboolean)(l_ctx->mCapabilities[GLenum::GL_CULL_FACE])); break; } case GLenum::GL_DEPTH_TEST: { - write(l_v, 0, l_ctx->mCapabilities[GLenum::GL_DEPTH_TEST]); + write(l_v, 0, (GLboolean)(l_ctx->mCapabilities[GLenum::GL_DEPTH_TEST])); break; } case GLenum::GL_DITHER: { - write(l_v, 0, l_ctx->mCapabilities[GLenum::GL_DITHER]); + write(l_v, 0, (GLboolean)(l_ctx->mCapabilities[GLenum::GL_DITHER])); break; } case GLenum::GL_POLYGON_OFFSET_FILL: { - write(l_v, 0, l_ctx->mCapabilities[GLenum::GL_POLYGON_OFFSET_FILL]); + write(l_v, 0, (GLboolean)(l_ctx->mCapabilities[GLenum::GL_POLYGON_OFFSET_FILL])); break; } case GLenum::GL_SAMPLE_ALPHA_TO_COVERAGE: { - write(l_v, 0, l_ctx->mCapabilities[GLenum::GL_SAMPLE_ALPHA_TO_COVERAGE]); + write(l_v, 0, + (GLboolean)(l_ctx->mCapabilities[GLenum::GL_SAMPLE_ALPHA_TO_COVERAGE])); break; } case GLenum::GL_SAMPLE_COVERAGE: { - write(l_v, 0, l_ctx->mCapabilities[GLenum::GL_SAMPLE_COVERAGE]); + write(l_v, 0, (GLboolean)(l_ctx->mCapabilities[GLenum::GL_SAMPLE_COVERAGE])); break; } case GLenum::GL_SCISSOR_TEST: { - write(l_v, 0, l_ctx->mCapabilities[GLenum::GL_SCISSOR_TEST]); + write(l_v, 0, (GLboolean)(l_ctx->mCapabilities[GLenum::GL_SCISSOR_TEST])); break; } case GLenum::GL_STENCIL_TEST: { - write(l_v, 0, l_ctx->mCapabilities[GLenum::GL_STENCIL_TEST]); + write(l_v, 0, (GLboolean)(l_ctx->mCapabilities[GLenum::GL_STENCIL_TEST])); break; } case GLenum::GL_DEPTH_WRITEMASK: { @@ -15165,7 +15167,7 @@ inline void GlesSpy::glGetBooleanv(uint32_t param, bool* values) { observe(observations.mWrites); gapic::coder::gles::GlGetBooleanv coder( - observations, param, gapic::coder::gles::Bool__P(gapic::coder::memory::Pointer( + observations, param, gapic::coder::gles::GLboolean__P(gapic::coder::memory::Pointer( reinterpret_cast<uintptr_t>(values), 0))); mEncoder->Object(&coder); } @@ -16742,10 +16744,10 @@ inline uint8_t* GlesSpy::glGetStringi(uint32_t name, uint32_t index) { return result; } -inline bool GlesSpy::glIsEnabled(uint32_t capability) { +inline uint8_t GlesSpy::glIsEnabled(uint32_t capability) { GAPID_INFO("glIsEnabled(%u)\n", capability); - bool result = false; + uint8_t result = 0; Observations observations; do { @@ -16883,10 +16885,10 @@ inline void GlesSpy::glGetSynciv(uint64_t sync, uint32_t pname, int32_t bufSize, mEncoder->Object(&coder); } -inline bool GlesSpy::glIsSync(uint64_t sync) { +inline uint8_t GlesSpy::glIsSync(uint64_t sync) { GAPID_INFO("glIsSync(%" PRIu64 ")\n", sync); - bool result = false; + uint8_t result = 0; Observations observations; do { @@ -17923,10 +17925,10 @@ inline void GlesSpy::glGetTexParameteriv(uint32_t target, uint32_t parameter, in mEncoder->Object(&coder); } -inline bool GlesSpy::glIsSampler(uint32_t sampler) { +inline uint8_t GlesSpy::glIsSampler(uint32_t sampler) { GAPID_INFO("glIsSampler(%" PRIu32 ")\n", sampler); - bool result = false; + uint8_t result = 0; Observations observations; do { @@ -17944,10 +17946,10 @@ inline bool GlesSpy::glIsSampler(uint32_t sampler) { return result; } -inline bool GlesSpy::glIsTexture(uint32_t texture) { +inline uint8_t GlesSpy::glIsTexture(uint32_t texture) { GAPID_INFO("glIsTexture(%" PRIu32 ")\n", texture); - bool result = false; + uint8_t result = 0; Observations observations; do { @@ -19286,10 +19288,10 @@ inline void GlesSpy::glGetTransformFeedbackVarying(uint32_t program, uint32_t in mEncoder->Object(&coder); } -inline bool GlesSpy::glIsTransformFeedback(uint32_t id) { +inline uint8_t GlesSpy::glIsTransformFeedback(uint32_t id) { GAPID_INFO("glIsTransformFeedback(%" PRIu32 ")\n", id); - bool result = false; + uint8_t result = 0; Observations observations; do { @@ -19683,10 +19685,10 @@ inline void GlesSpy::glGetVertexAttribiv(uint32_t index, uint32_t pname, int32_t mEncoder->Object(&coder); } -inline bool GlesSpy::glIsVertexArray(uint32_t array) { +inline uint8_t GlesSpy::glIsVertexArray(uint32_t array) { GAPID_INFO("glIsVertexArray(%" PRIu32 ")\n", array); - bool result = false; + uint8_t result = 0; Observations observations; do { @@ -20056,8 +20058,8 @@ inline void GlesSpy::glVertexAttribIPointer(uint32_t index, int32_t size, uint32 } inline void GlesSpy::glVertexAttribPointer(uint32_t location, int32_t size, uint32_t type, - bool normalized, int32_t stride, void* data) { - GAPID_INFO("glVertexAttribPointer(%" PRIu32 ", %" PRId32 ", %u, %d, %" PRId32 ", %p)\n", + uint8_t normalized, int32_t stride, void* data) { + GAPID_INFO("glVertexAttribPointer(%" PRIu32 ", %" PRId32 ", %u, %" PRIu8 ", %" PRId32 ", %p)\n", location, size, type, normalized, stride, data); Observations observations; diff --git a/cc/gapii/gles_types.h b/cc/gapii/gles_types.h index 7fbcc8d90..86f435a4c 100644 --- a/cc/gapii/gles_types.h +++ b/cc/gapii/gles_types.h @@ -5803,7 +5803,7 @@ struct VertexAttributeArray { mType = v; return *this; } - inline VertexAttributeArray& SetNormalized(bool v) { + inline VertexAttributeArray& SetNormalized(GLboolean v) { mNormalized = v; return *this; } @@ -5823,7 +5823,7 @@ struct VertexAttributeArray { bool mEnabled; uint32_t mSize; uint32_t mType; - bool mNormalized; + GLboolean mNormalized; GLsizei mStride; BufferId mBuffer; VertexPointer mPointer; @@ -5958,7 +5958,7 @@ struct Rect { }; struct RasterizerState { - inline RasterizerState& SetDepthMask(bool v) { + inline RasterizerState& SetDepthMask(GLboolean v) { mDepthMask = v; return *this; } @@ -5974,19 +5974,19 @@ struct RasterizerState { mDepthFar = v; return *this; } - inline RasterizerState& SetColorMaskRed(bool v) { + inline RasterizerState& SetColorMaskRed(GLboolean v) { mColorMaskRed = v; return *this; } - inline RasterizerState& SetColorMaskGreen(bool v) { + inline RasterizerState& SetColorMaskGreen(GLboolean v) { mColorMaskGreen = v; return *this; } - inline RasterizerState& SetColorMaskBlue(bool v) { + inline RasterizerState& SetColorMaskBlue(GLboolean v) { mColorMaskBlue = v; return *this; } - inline RasterizerState& SetColorMaskAlpha(bool v) { + inline RasterizerState& SetColorMaskAlpha(GLboolean v) { mColorMaskAlpha = v; return *this; } @@ -6026,19 +6026,19 @@ struct RasterizerState { mSampleCoverageValue = v; return *this; } - inline RasterizerState& SetSampleCoverageInvert(bool v) { + inline RasterizerState& SetSampleCoverageInvert(GLboolean v) { mSampleCoverageInvert = v; return *this; } - bool mDepthMask; + GLboolean mDepthMask; uint32_t mDepthTestFunction; GLfloat mDepthNear; GLfloat mDepthFar; - bool mColorMaskRed; - bool mColorMaskGreen; - bool mColorMaskBlue; - bool mColorMaskAlpha; + GLboolean mColorMaskRed; + GLboolean mColorMaskGreen; + GLboolean mColorMaskBlue; + GLboolean mColorMaskAlpha; GLenumToGLuint mStencilMask; Rect mViewport; Rect mScissor; @@ -6048,7 +6048,7 @@ struct RasterizerState { GLfloat mPolygonOffsetFactor; GLfloat mPolygonOffsetUnits; GLfloat mSampleCoverageValue; - bool mSampleCoverageInvert; + GLboolean mSampleCoverageInvert; }; struct ClearState { diff --git a/cc/gapir/gfx_api.cpp b/cc/gapir/gfx_api.cpp index 49c246581..218a86d08 100644 --- a/cc/gapir/gfx_api.cpp +++ b/cc/gapir/gfx_api.cpp @@ -526,10 +526,10 @@ bool callGlIsEnablediEXT(Stack* stack, bool pushReturn) { if (stack->isValid()) { GAPID_INFO("glIsEnablediEXT(%u, %" PRIu32 ")\n", target, index); if (glIsEnablediEXT != nullptr) { - bool return_value = glIsEnablediEXT(target, index); - GAPID_INFO("Returned: %d\n", return_value); + uint8_t return_value = glIsEnablediEXT(target, index); + GAPID_INFO("Returned: %" PRIu8 "\n", return_value); if (pushReturn) { - stack->push<bool>(return_value); + stack->push<uint8_t>(return_value); } const GLenum err = glGetError(); if (err != GLenum::GL_NO_ERROR) { @@ -999,10 +999,10 @@ bool callGlIsQuery(Stack* stack, bool pushReturn) { if (stack->isValid()) { GAPID_INFO("glIsQuery(%" PRIu32 ")\n", query); if (glIsQuery != nullptr) { - bool return_value = glIsQuery(query); - GAPID_INFO("Returned: %d\n", return_value); + uint8_t return_value = glIsQuery(query); + GAPID_INFO("Returned: %" PRIu8 "\n", return_value); if (pushReturn) { - stack->push<bool>(return_value); + stack->push<uint8_t>(return_value); } const GLenum err = glGetError(); if (err != GLenum::GL_NO_ERROR) { @@ -1271,10 +1271,10 @@ bool callGlIsBuffer(Stack* stack, bool pushReturn) { if (stack->isValid()) { GAPID_INFO("glIsBuffer(%" PRIu32 ")\n", buffer); if (glIsBuffer != nullptr) { - bool return_value = glIsBuffer(buffer); - GAPID_INFO("Returned: %d\n", return_value); + uint8_t return_value = glIsBuffer(buffer); + GAPID_INFO("Returned: %" PRIu8 "\n", return_value); if (pushReturn) { - stack->push<bool>(return_value); + stack->push<uint8_t>(return_value); } const GLenum err = glGetError(); if (err != GLenum::GL_NO_ERROR) { @@ -5323,10 +5323,10 @@ bool callGlIsEnablediOES(Stack* stack, bool pushReturn) { if (stack->isValid()) { GAPID_INFO("glIsEnablediOES(%u, %" PRIu32 ")\n", target, index); if (glIsEnablediOES != nullptr) { - bool return_value = glIsEnablediOES(target, index); - GAPID_INFO("Returned: %d\n", return_value); + uint8_t return_value = glIsEnablediOES(target, index); + GAPID_INFO("Returned: %" PRIu8 "\n", return_value); if (pushReturn) { - stack->push<bool>(return_value); + stack->push<uint8_t>(return_value); } const GLenum err = glGetError(); if (err != GLenum::GL_NO_ERROR) { @@ -5348,10 +5348,10 @@ bool callGlIsEnablediNV(Stack* stack, bool pushReturn) { if (stack->isValid()) { GAPID_INFO("glIsEnablediNV(%u, %" PRIu32 ")\n", target, index); if (glIsEnablediNV != nullptr) { - bool return_value = glIsEnablediNV(target, index); - GAPID_INFO("Returned: %d\n", return_value); + uint8_t return_value = glIsEnablediNV(target, index); + GAPID_INFO("Returned: %" PRIu8 "\n", return_value); if (pushReturn) { - stack->push<bool>(return_value); + stack->push<uint8_t>(return_value); } const GLenum err = glGetError(); if (err != GLenum::GL_NO_ERROR) { @@ -5372,10 +5372,10 @@ bool callGlIsFenceNV(Stack* stack, bool pushReturn) { if (stack->isValid()) { GAPID_INFO("glIsFenceNV(%" PRIu32 ")\n", fence); if (glIsFenceNV != nullptr) { - bool return_value = glIsFenceNV(fence); - GAPID_INFO("Returned: %d\n", return_value); + uint8_t return_value = glIsFenceNV(fence); + GAPID_INFO("Returned: %" PRIu8 "\n", return_value); if (pushReturn) { - stack->push<bool>(return_value); + stack->push<uint8_t>(return_value); } const GLenum err = glGetError(); if (err != GLenum::GL_NO_ERROR) { @@ -5396,10 +5396,10 @@ bool callGlIsImageHandleResidentNV(Stack* stack, bool pushReturn) { if (stack->isValid()) { GAPID_INFO("glIsImageHandleResidentNV(%" PRIu64 ")\n", handle); if (glIsImageHandleResidentNV != nullptr) { - bool return_value = glIsImageHandleResidentNV(handle); - GAPID_INFO("Returned: %d\n", return_value); + uint8_t return_value = glIsImageHandleResidentNV(handle); + GAPID_INFO("Returned: %" PRIu8 "\n", return_value); if (pushReturn) { - stack->push<bool>(return_value); + stack->push<uint8_t>(return_value); } const GLenum err = glGetError(); if (err != GLenum::GL_NO_ERROR) { @@ -5420,10 +5420,10 @@ bool callGlIsPathNV(Stack* stack, bool pushReturn) { if (stack->isValid()) { GAPID_INFO("glIsPathNV(%" PRIu32 ")\n", path); if (glIsPathNV != nullptr) { - bool return_value = glIsPathNV(path); - GAPID_INFO("Returned: %d\n", return_value); + uint8_t return_value = glIsPathNV(path); + GAPID_INFO("Returned: %" PRIu8 "\n", return_value); if (pushReturn) { - stack->push<bool>(return_value); + stack->push<uint8_t>(return_value); } const GLenum err = glGetError(); if (err != GLenum::GL_NO_ERROR) { @@ -5447,10 +5447,10 @@ bool callGlIsPointInFillPathNV(Stack* stack, bool pushReturn) { if (stack->isValid()) { GAPID_INFO("glIsPointInFillPathNV(%" PRIu32 ", %" PRIu32 ", %f, %f)\n", path, mask, x, y); if (glIsPointInFillPathNV != nullptr) { - bool return_value = glIsPointInFillPathNV(path, mask, x, y); - GAPID_INFO("Returned: %d\n", return_value); + uint8_t return_value = glIsPointInFillPathNV(path, mask, x, y); + GAPID_INFO("Returned: %" PRIu8 "\n", return_value); if (pushReturn) { - stack->push<bool>(return_value); + stack->push<uint8_t>(return_value); } const GLenum err = glGetError(); if (err != GLenum::GL_NO_ERROR) { @@ -5473,10 +5473,10 @@ bool callGlIsPointInStrokePathNV(Stack* stack, bool pushReturn) { if (stack->isValid()) { GAPID_INFO("glIsPointInStrokePathNV(%" PRIu32 ", %f, %f)\n", path, x, y); if (glIsPointInStrokePathNV != nullptr) { - bool return_value = glIsPointInStrokePathNV(path, x, y); - GAPID_INFO("Returned: %d\n", return_value); + uint8_t return_value = glIsPointInStrokePathNV(path, x, y); + GAPID_INFO("Returned: %" PRIu8 "\n", return_value); if (pushReturn) { - stack->push<bool>(return_value); + stack->push<uint8_t>(return_value); } const GLenum err = glGetError(); if (err != GLenum::GL_NO_ERROR) { @@ -5497,10 +5497,10 @@ bool callGlIsProgramPipelineEXT(Stack* stack, bool pushReturn) { if (stack->isValid()) { GAPID_INFO("glIsProgramPipelineEXT(%" PRIu32 ")\n", pipeline); if (glIsProgramPipelineEXT != nullptr) { - bool return_value = glIsProgramPipelineEXT(pipeline); - GAPID_INFO("Returned: %d\n", return_value); + uint8_t return_value = glIsProgramPipelineEXT(pipeline); + GAPID_INFO("Returned: %" PRIu8 "\n", return_value); if (pushReturn) { - stack->push<bool>(return_value); + stack->push<uint8_t>(return_value); } const GLenum err = glGetError(); if (err != GLenum::GL_NO_ERROR) { @@ -5521,10 +5521,10 @@ bool callGlIsQueryEXT(Stack* stack, bool pushReturn) { if (stack->isValid()) { GAPID_INFO("glIsQueryEXT(%" PRIu32 ")\n", query); if (glIsQueryEXT != nullptr) { - bool return_value = glIsQueryEXT(query); - GAPID_INFO("Returned: %d\n", return_value); + uint8_t return_value = glIsQueryEXT(query); + GAPID_INFO("Returned: %" PRIu8 "\n", return_value); if (pushReturn) { - stack->push<bool>(return_value); + stack->push<uint8_t>(return_value); } const GLenum err = glGetError(); if (err != GLenum::GL_NO_ERROR) { @@ -5545,10 +5545,10 @@ bool callGlIsSyncAPPLE(Stack* stack, bool pushReturn) { if (stack->isValid()) { GAPID_INFO("glIsSyncAPPLE(%" PRIu64 ")\n", sync); if (glIsSyncAPPLE != nullptr) { - bool return_value = glIsSyncAPPLE(sync); - GAPID_INFO("Returned: %d\n", return_value); + uint8_t return_value = glIsSyncAPPLE(sync); + GAPID_INFO("Returned: %" PRIu8 "\n", return_value); if (pushReturn) { - stack->push<bool>(return_value); + stack->push<uint8_t>(return_value); } const GLenum err = glGetError(); if (err != GLenum::GL_NO_ERROR) { @@ -5569,10 +5569,10 @@ bool callGlIsTextureHandleResidentNV(Stack* stack, bool pushReturn) { if (stack->isValid()) { GAPID_INFO("glIsTextureHandleResidentNV(%" PRIu64 ")\n", handle); if (glIsTextureHandleResidentNV != nullptr) { - bool return_value = glIsTextureHandleResidentNV(handle); - GAPID_INFO("Returned: %d\n", return_value); + uint8_t return_value = glIsTextureHandleResidentNV(handle); + GAPID_INFO("Returned: %" PRIu8 "\n", return_value); if (pushReturn) { - stack->push<bool>(return_value); + stack->push<uint8_t>(return_value); } const GLenum err = glGetError(); if (err != GLenum::GL_NO_ERROR) { @@ -5593,10 +5593,10 @@ bool callGlIsVertexArrayOES(Stack* stack, bool pushReturn) { if (stack->isValid()) { GAPID_INFO("glIsVertexArrayOES(%" PRIu32 ")\n", array); if (glIsVertexArrayOES != nullptr) { - bool return_value = glIsVertexArrayOES(array); - GAPID_INFO("Returned: %d\n", return_value); + uint8_t return_value = glIsVertexArrayOES(array); + GAPID_INFO("Returned: %" PRIu8 "\n", return_value); if (pushReturn) { - stack->push<bool>(return_value); + stack->push<uint8_t>(return_value); } const GLenum err = glGetError(); if (err != GLenum::GL_NO_ERROR) { @@ -9515,10 +9515,10 @@ bool callGlDepthFunc(Stack* stack, bool pushReturn) { } bool callGlSampleCoverage(Stack* stack, bool pushReturn) { - bool invert = stack->pop<bool>(); + uint8_t invert = stack->pop<uint8_t>(); float value = stack->pop<float>(); if (stack->isValid()) { - GAPID_INFO("glSampleCoverage(%f, %d)\n", value, invert); + GAPID_INFO("glSampleCoverage(%f, %" PRIu8 ")\n", value, invert); if (glSampleCoverage != nullptr) { glSampleCoverage(value, invert); const GLenum err = glGetError(); @@ -9944,12 +9944,13 @@ bool callGlClearStencil(Stack* stack, bool pushReturn) { } bool callGlColorMask(Stack* stack, bool pushReturn) { - bool alpha = stack->pop<bool>(); - bool blue = stack->pop<bool>(); - bool green = stack->pop<bool>(); - bool red = stack->pop<bool>(); + uint8_t alpha = stack->pop<uint8_t>(); + uint8_t blue = stack->pop<uint8_t>(); + uint8_t green = stack->pop<uint8_t>(); + uint8_t red = stack->pop<uint8_t>(); if (stack->isValid()) { - GAPID_INFO("glColorMask(%d, %d, %d, %d)\n", red, green, blue, alpha); + GAPID_INFO("glColorMask(%" PRIu8 ", %" PRIu8 ", %" PRIu8 ", %" PRIu8 ")\n", red, green, + blue, alpha); if (glColorMask != nullptr) { glColorMask(red, green, blue, alpha); const GLenum err = glGetError(); @@ -10009,9 +10010,9 @@ bool callGlDeleteRenderbuffers(Stack* stack, bool pushReturn) { } bool callGlDepthMask(Stack* stack, bool pushReturn) { - bool enabled = stack->pop<bool>(); + uint8_t enabled = stack->pop<uint8_t>(); if (stack->isValid()) { - GAPID_INFO("glDepthMask(%d)\n", enabled); + GAPID_INFO("glDepthMask(%" PRIu8 ")\n", enabled); if (glDepthMask != nullptr) { glDepthMask(enabled); const GLenum err = glGetError(); @@ -10293,10 +10294,10 @@ bool callGlIsFramebuffer(Stack* stack, bool pushReturn) { if (stack->isValid()) { GAPID_INFO("glIsFramebuffer(%" PRIu32 ")\n", framebuffer); if (glIsFramebuffer != nullptr) { - bool return_value = glIsFramebuffer(framebuffer); - GAPID_INFO("Returned: %d\n", return_value); + uint8_t return_value = glIsFramebuffer(framebuffer); + GAPID_INFO("Returned: %" PRIu8 "\n", return_value); if (pushReturn) { - stack->push<bool>(return_value); + stack->push<uint8_t>(return_value); } const GLenum err = glGetError(); if (err != GLenum::GL_NO_ERROR) { @@ -10317,10 +10318,10 @@ bool callGlIsRenderbuffer(Stack* stack, bool pushReturn) { if (stack->isValid()) { GAPID_INFO("glIsRenderbuffer(%" PRIu32 ")\n", renderbuffer); if (glIsRenderbuffer != nullptr) { - bool return_value = glIsRenderbuffer(renderbuffer); - GAPID_INFO("Returned: %d\n", return_value); + uint8_t return_value = glIsRenderbuffer(renderbuffer); + GAPID_INFO("Returned: %" PRIu8 "\n", return_value); if (pushReturn) { - stack->push<bool>(return_value); + stack->push<uint8_t>(return_value); } const GLenum err = glGetError(); if (err != GLenum::GL_NO_ERROR) { @@ -11639,10 +11640,10 @@ bool callGlIsProgram(Stack* stack, bool pushReturn) { if (stack->isValid()) { GAPID_INFO("glIsProgram(%" PRIu32 ")\n", program); if (glIsProgram != nullptr) { - bool return_value = glIsProgram(program); - GAPID_INFO("Returned: %d\n", return_value); + uint8_t return_value = glIsProgram(program); + GAPID_INFO("Returned: %" PRIu8 "\n", return_value); if (pushReturn) { - stack->push<bool>(return_value); + stack->push<uint8_t>(return_value); } const GLenum err = glGetError(); if (err != GLenum::GL_NO_ERROR) { @@ -11663,10 +11664,10 @@ bool callGlIsProgramPipeline(Stack* stack, bool pushReturn) { if (stack->isValid()) { GAPID_INFO("glIsProgramPipeline(%" PRIu32 ")\n", pipeline); if (glIsProgramPipeline != nullptr) { - bool return_value = glIsProgramPipeline(pipeline); - GAPID_INFO("Returned: %d\n", return_value); + uint8_t return_value = glIsProgramPipeline(pipeline); + GAPID_INFO("Returned: %" PRIu8 "\n", return_value); if (pushReturn) { - stack->push<bool>(return_value); + stack->push<uint8_t>(return_value); } const GLenum err = glGetError(); if (err != GLenum::GL_NO_ERROR) { @@ -11687,10 +11688,10 @@ bool callGlIsShader(Stack* stack, bool pushReturn) { if (stack->isValid()) { GAPID_INFO("glIsShader(%" PRIu32 ")\n", shader); if (glIsShader != nullptr) { - bool return_value = glIsShader(shader); - GAPID_INFO("Returned: %d\n", return_value); + uint8_t return_value = glIsShader(shader); + GAPID_INFO("Returned: %" PRIu8 "\n", return_value); if (pushReturn) { - stack->push<bool>(return_value); + stack->push<uint8_t>(return_value); } const GLenum err = glGetError(); if (err != GLenum::GL_NO_ERROR) { @@ -13732,7 +13733,7 @@ bool callGlGetBooleaniV(Stack* stack, bool pushReturn) { } bool callGlGetBooleanv(Stack* stack, bool pushReturn) { - bool* values = stack->pop<bool*>(); + uint8_t* values = stack->pop<uint8_t*>(); GLenum param = stack->pop<GLenum>(); if (stack->isValid()) { GAPID_INFO("glGetBooleanv(%u, %p)\n", param, values); @@ -13938,10 +13939,10 @@ bool callGlIsEnabled(Stack* stack, bool pushReturn) { if (stack->isValid()) { GAPID_INFO("glIsEnabled(%u)\n", capability); if (glIsEnabled != nullptr) { - bool return_value = glIsEnabled(capability); - GAPID_INFO("Returned: %d\n", return_value); + uint8_t return_value = glIsEnabled(capability); + GAPID_INFO("Returned: %" PRIu8 "\n", return_value); if (pushReturn) { - stack->push<bool>(return_value); + stack->push<uint8_t>(return_value); } const GLenum err = glGetError(); if (err != GLenum::GL_NO_ERROR) { @@ -14058,10 +14059,10 @@ bool callGlIsSync(Stack* stack, bool pushReturn) { if (stack->isValid()) { GAPID_INFO("glIsSync(%" PRIu64 ")\n", sync); if (glIsSync != nullptr) { - bool return_value = glIsSync(sync); - GAPID_INFO("Returned: %d\n", return_value); + uint8_t return_value = glIsSync(sync); + GAPID_INFO("Returned: %" PRIu8 "\n", return_value); if (pushReturn) { - stack->push<bool>(return_value); + stack->push<uint8_t>(return_value); } const GLenum err = glGetError(); if (err != GLenum::GL_NO_ERROR) { @@ -14647,10 +14648,10 @@ bool callGlIsSampler(Stack* stack, bool pushReturn) { if (stack->isValid()) { GAPID_INFO("glIsSampler(%" PRIu32 ")\n", sampler); if (glIsSampler != nullptr) { - bool return_value = glIsSampler(sampler); - GAPID_INFO("Returned: %d\n", return_value); + uint8_t return_value = glIsSampler(sampler); + GAPID_INFO("Returned: %" PRIu8 "\n", return_value); if (pushReturn) { - stack->push<bool>(return_value); + stack->push<uint8_t>(return_value); } const GLenum err = glGetError(); if (err != GLenum::GL_NO_ERROR) { @@ -14671,10 +14672,10 @@ bool callGlIsTexture(Stack* stack, bool pushReturn) { if (stack->isValid()) { GAPID_INFO("glIsTexture(%" PRIu32 ")\n", texture); if (glIsTexture != nullptr) { - bool return_value = glIsTexture(texture); - GAPID_INFO("Returned: %d\n", return_value); + uint8_t return_value = glIsTexture(texture); + GAPID_INFO("Returned: %" PRIu8 "\n", return_value); if (pushReturn) { - stack->push<bool>(return_value); + stack->push<uint8_t>(return_value); } const GLenum err = glGetError(); if (err != GLenum::GL_NO_ERROR) { @@ -15228,10 +15229,10 @@ bool callGlIsTransformFeedback(Stack* stack, bool pushReturn) { if (stack->isValid()) { GAPID_INFO("glIsTransformFeedback(%" PRIu32 ")\n", id); if (glIsTransformFeedback != nullptr) { - bool return_value = glIsTransformFeedback(id); - GAPID_INFO("Returned: %d\n", return_value); + uint8_t return_value = glIsTransformFeedback(id); + GAPID_INFO("Returned: %" PRIu8 "\n", return_value); if (pushReturn) { - stack->push<bool>(return_value); + stack->push<uint8_t>(return_value); } const GLenum err = glGetError(); if (err != GLenum::GL_NO_ERROR) { @@ -15550,10 +15551,10 @@ bool callGlIsVertexArray(Stack* stack, bool pushReturn) { if (stack->isValid()) { GAPID_INFO("glIsVertexArray(%" PRIu32 ")\n", array); if (glIsVertexArray != nullptr) { - bool return_value = glIsVertexArray(array); - GAPID_INFO("Returned: %d\n", return_value); + uint8_t return_value = glIsVertexArray(array); + GAPID_INFO("Returned: %" PRIu8 "\n", return_value); if (pushReturn) { - stack->push<bool>(return_value); + stack->push<uint8_t>(return_value); } const GLenum err = glGetError(); if (err != GLenum::GL_NO_ERROR) { @@ -15957,12 +15958,13 @@ bool callGlVertexAttribIPointer(Stack* stack, bool pushReturn) { bool callGlVertexAttribPointer(Stack* stack, bool pushReturn) { void* data = stack->pop<void*>(); int32_t stride = stack->pop<int32_t>(); - bool normalized = stack->pop<bool>(); + uint8_t normalized = stack->pop<uint8_t>(); GLenum type = stack->pop<GLenum>(); int32_t size = stack->pop<int32_t>(); uint32_t location = stack->pop<uint32_t>(); if (stack->isValid()) { - GAPID_INFO("glVertexAttribPointer(%" PRIu32 ", %" PRId32 ", %u, %d, %" PRId32 ", %p)\n", + GAPID_INFO("glVertexAttribPointer(%" PRIu32 ", %" PRId32 ", %u, %" PRIu8 ", %" PRId32 + ", %p)\n", location, size, type, normalized, stride, data); if (glVertexAttribPointer != nullptr) { glVertexAttribPointer(location, size, type, normalized, stride, data); diff --git a/cc/gapir/gfx_api.h b/cc/gapir/gfx_api.h index 95ff2f99d..e1754fa31 100644 --- a/cc/gapir/gfx_api.h +++ b/cc/gapir/gfx_api.h @@ -6461,7 +6461,7 @@ typedef void(STDCALL *PFNGLGETSAMPLERPARAMETERIUIVEXT)(uint32_t sampler, GLenum uint32_t *params); typedef void(STDCALL *PFNGLGETTEXPARAMETERIIVEXT)(GLenum target, GLenum pname, int32_t *params); typedef void(STDCALL *PFNGLGETTEXPARAMETERIUIVEXT)(GLenum target, GLenum pname, uint32_t *params); -typedef bool(STDCALL *PFNGLISENABLEDIEXT)(GLenum target, uint32_t index); +typedef uint8_t(STDCALL *PFNGLISENABLEDIEXT)(GLenum target, uint32_t index); typedef void(STDCALL *PFNGLMINSAMPLESHADINGOES)(float value); typedef void(STDCALL *PFNGLOBJECTLABELKHR)(GLenum identifier, uint32_t name, int32_t length, char *label); @@ -6490,7 +6490,7 @@ typedef void(STDCALL *PFNGLENDQUERY)(GLenum target); typedef void(STDCALL *PFNGLGENQUERIES)(int32_t count, uint32_t *queries); typedef void(STDCALL *PFNGLGETQUERYOBJECTUIV)(uint32_t query, GLenum parameter, uint32_t *value); typedef void(STDCALL *PFNGLGETQUERYIV)(GLenum target, GLenum parameter, int32_t *value); -typedef bool(STDCALL *PFNGLISQUERY)(uint32_t query); +typedef uint8_t(STDCALL *PFNGLISQUERY)(uint32_t query); typedef void(STDCALL *PFNGLBINDBUFFER)(GLenum target, uint32_t buffer); typedef void(STDCALL *PFNGLBINDBUFFERBASE)(GLenum target, uint32_t index, uint32_t buffer); typedef void(STDCALL *PFNGLBINDBUFFERRANGE)(GLenum target, uint32_t index, uint32_t buffer, @@ -6505,7 +6505,7 @@ typedef void(STDCALL *PFNGLGENBUFFERS)(int32_t count, uint32_t *buffers); typedef void(STDCALL *PFNGLGETBUFFERPARAMETERI64V)(GLenum target, GLenum pname, int64_t *params); typedef void(STDCALL *PFNGLGETBUFFERPARAMETERIV)(GLenum target, GLenum parameter, int32_t *value); typedef void(STDCALL *PFNGLGETBUFFERPOINTERV)(GLenum target, GLenum pname, void **params); -typedef bool(STDCALL *PFNGLISBUFFER)(uint32_t buffer); +typedef uint8_t(STDCALL *PFNGLISBUFFER)(uint32_t buffer); typedef void *(STDCALL *PFNGLMAPBUFFERRANGE)(GLenum target, int32_t offset, int32_t length, GLbitfield access); typedef uint8_t(STDCALL *PFNGLUNMAPBUFFER)(GLenum target); @@ -6812,18 +6812,18 @@ typedef void(STDCALL *PFNGLGETNUNIFORMUIVKHR)(uint32_t program, int32_t location typedef void(STDCALL *PFNGLINSERTEVENTMARKEREXT)(int32_t length, char *marker); typedef void(STDCALL *PFNGLINTERPOLATEPATHSNV)(uint32_t resultPath, uint32_t pathA, uint32_t pathB, float weight); -typedef bool(STDCALL *PFNGLISENABLEDIOES)(GLenum target, uint32_t index); -typedef bool(STDCALL *PFNGLISENABLEDINV)(GLenum target, uint32_t index); -typedef bool(STDCALL *PFNGLISFENCENV)(uint32_t fence); -typedef bool(STDCALL *PFNGLISIMAGEHANDLERESIDENTNV)(uint64_t handle); -typedef bool(STDCALL *PFNGLISPATHNV)(uint32_t path); -typedef bool(STDCALL *PFNGLISPOINTINFILLPATHNV)(uint32_t path, uint32_t mask, float x, float y); -typedef bool(STDCALL *PFNGLISPOINTINSTROKEPATHNV)(uint32_t path, float x, float y); -typedef bool(STDCALL *PFNGLISPROGRAMPIPELINEEXT)(uint32_t pipeline); -typedef bool(STDCALL *PFNGLISQUERYEXT)(uint32_t query); -typedef bool(STDCALL *PFNGLISSYNCAPPLE)(uint64_t sync); -typedef bool(STDCALL *PFNGLISTEXTUREHANDLERESIDENTNV)(uint64_t handle); -typedef bool(STDCALL *PFNGLISVERTEXARRAYOES)(uint32_t array); +typedef uint8_t(STDCALL *PFNGLISENABLEDIOES)(GLenum target, uint32_t index); +typedef uint8_t(STDCALL *PFNGLISENABLEDINV)(GLenum target, uint32_t index); +typedef uint8_t(STDCALL *PFNGLISFENCENV)(uint32_t fence); +typedef uint8_t(STDCALL *PFNGLISIMAGEHANDLERESIDENTNV)(uint64_t handle); +typedef uint8_t(STDCALL *PFNGLISPATHNV)(uint32_t path); +typedef uint8_t(STDCALL *PFNGLISPOINTINFILLPATHNV)(uint32_t path, uint32_t mask, float x, float y); +typedef uint8_t(STDCALL *PFNGLISPOINTINSTROKEPATHNV)(uint32_t path, float x, float y); +typedef uint8_t(STDCALL *PFNGLISPROGRAMPIPELINEEXT)(uint32_t pipeline); +typedef uint8_t(STDCALL *PFNGLISQUERYEXT)(uint32_t query); +typedef uint8_t(STDCALL *PFNGLISSYNCAPPLE)(uint64_t sync); +typedef uint8_t(STDCALL *PFNGLISTEXTUREHANDLERESIDENTNV)(uint64_t handle); +typedef uint8_t(STDCALL *PFNGLISVERTEXARRAYOES)(uint32_t array); typedef void(STDCALL *PFNGLLABELOBJECTEXT)(GLenum type, uint32_t object, int32_t length, char *label); typedef void(STDCALL *PFNGLMAKEIMAGEHANDLENONRESIDENTNV)(uint64_t handle); @@ -7128,7 +7128,7 @@ typedef void(STDCALL *PFNGLBLENDFUNC)(GLenum src_factor, GLenum dst_factor); typedef void(STDCALL *PFNGLBLENDFUNCSEPARATE)(GLenum src_factor_rgb, GLenum dst_factor_rgb, GLenum src_factor_alpha, GLenum dst_factor_alpha); typedef void(STDCALL *PFNGLDEPTHFUNC)(GLenum function); -typedef void(STDCALL *PFNGLSAMPLECOVERAGE)(float value, bool invert); +typedef void(STDCALL *PFNGLSAMPLECOVERAGE)(float value, uint8_t invert); typedef void(STDCALL *PFNGLSAMPLEMASKI)(uint32_t maskNumber, GLbitfield mask); typedef void(STDCALL *PFNGLSCISSOR)(int32_t x, int32_t y, int32_t width, int32_t height); typedef void(STDCALL *PFNGLSTENCILFUNC)(GLenum func, int32_t ref, uint32_t mask); @@ -7154,10 +7154,10 @@ typedef void(STDCALL *PFNGLCLEARBUFFERUIV)(GLenum buffer, int32_t drawbuffer, ui typedef void(STDCALL *PFNGLCLEARCOLOR)(float r, float g, float b, float a); typedef void(STDCALL *PFNGLCLEARDEPTHF)(float depth); typedef void(STDCALL *PFNGLCLEARSTENCIL)(int32_t stencil); -typedef void(STDCALL *PFNGLCOLORMASK)(bool red, bool green, bool blue, bool alpha); +typedef void(STDCALL *PFNGLCOLORMASK)(uint8_t red, uint8_t green, uint8_t blue, uint8_t alpha); typedef void(STDCALL *PFNGLDELETEFRAMEBUFFERS)(int32_t count, uint32_t *framebuffers); typedef void(STDCALL *PFNGLDELETERENDERBUFFERS)(int32_t count, uint32_t *renderbuffers); -typedef void(STDCALL *PFNGLDEPTHMASK)(bool enabled); +typedef void(STDCALL *PFNGLDEPTHMASK)(uint8_t enabled); typedef void(STDCALL *PFNGLFRAMEBUFFERPARAMETERI)(GLenum target, GLenum pname, int32_t param); typedef void(STDCALL *PFNGLFRAMEBUFFERRENDERBUFFER)(GLenum framebuffer_target, GLenum framebuffer_attachment, @@ -7182,8 +7182,8 @@ typedef void(STDCALL *PFNGLINVALIDATEFRAMEBUFFER)(GLenum target, int32_t count, typedef void(STDCALL *PFNGLINVALIDATESUBFRAMEBUFFER)(GLenum target, int32_t numAttachments, GLenum *attachments, int32_t x, int32_t y, int32_t width, int32_t height); -typedef bool(STDCALL *PFNGLISFRAMEBUFFER)(uint32_t framebuffer); -typedef bool(STDCALL *PFNGLISRENDERBUFFER)(uint32_t renderbuffer); +typedef uint8_t(STDCALL *PFNGLISFRAMEBUFFER)(uint32_t framebuffer); +typedef uint8_t(STDCALL *PFNGLISRENDERBUFFER)(uint32_t renderbuffer); typedef void(STDCALL *PFNGLREADBUFFER)(GLenum src); typedef void(STDCALL *PFNGLREADPIXELS)(int32_t x, int32_t y, int32_t width, int32_t height, GLenum format, GLenum type, void *data); @@ -7270,9 +7270,9 @@ typedef int32_t(STDCALL *PFNGLGETUNIFORMLOCATION)(uint32_t program, char *name); typedef void(STDCALL *PFNGLGETUNIFORMFV)(uint32_t program, int32_t location, float *values); typedef void(STDCALL *PFNGLGETUNIFORMIV)(uint32_t program, int32_t location, int32_t *values); typedef void(STDCALL *PFNGLGETUNIFORMUIV)(uint32_t program, int32_t location, uint32_t *params); -typedef bool(STDCALL *PFNGLISPROGRAM)(uint32_t program); -typedef bool(STDCALL *PFNGLISPROGRAMPIPELINE)(uint32_t pipeline); -typedef bool(STDCALL *PFNGLISSHADER)(uint32_t shader); +typedef uint8_t(STDCALL *PFNGLISPROGRAM)(uint32_t program); +typedef uint8_t(STDCALL *PFNGLISPROGRAMPIPELINE)(uint32_t pipeline); +typedef uint8_t(STDCALL *PFNGLISSHADER)(uint32_t shader); typedef void(STDCALL *PFNGLLINKPROGRAM)(uint32_t program); typedef void(STDCALL *PFNGLMEMORYBARRIER)(GLbitfield barriers); typedef void(STDCALL *PFNGLMEMORYBARRIERBYREGION)(GLbitfield barriers); @@ -7414,7 +7414,7 @@ typedef void(STDCALL *PFNGLLINEWIDTH)(float width); typedef void(STDCALL *PFNGLPOLYGONOFFSET)(float scale_factor, float units); typedef void(STDCALL *PFNGLVIEWPORT)(int32_t x, int32_t y, int32_t width, int32_t height); typedef void(STDCALL *PFNGLGETBOOLEANI_V)(GLenum target, uint32_t index, uint8_t *data); -typedef void(STDCALL *PFNGLGETBOOLEANV)(GLenum param, bool *values); +typedef void(STDCALL *PFNGLGETBOOLEANV)(GLenum param, uint8_t *values); typedef void(STDCALL *PFNGLGETFLOATV)(GLenum param, float *values); typedef void(STDCALL *PFNGLGETINTEGER64I_V)(GLenum target, uint32_t index, int64_t *data); typedef void(STDCALL *PFNGLGETINTEGER64V)(GLenum pname, int64_t *data); @@ -7424,13 +7424,13 @@ typedef void(STDCALL *PFNGLGETINTERNALFORMATIV)(GLenum target, GLenum internalfo int32_t bufSize, int32_t *params); typedef uint8_t *(STDCALL *PFNGLGETSTRING)(GLenum param); typedef uint8_t *(STDCALL *PFNGLGETSTRINGI)(GLenum name, uint32_t index); -typedef bool(STDCALL *PFNGLISENABLED)(GLenum capability); +typedef uint8_t(STDCALL *PFNGLISENABLED)(GLenum capability); typedef GLenum(STDCALL *PFNGLCLIENTWAITSYNC)(uint64_t sync, GLbitfield syncFlags, uint64_t timeout); typedef void(STDCALL *PFNGLDELETESYNC)(uint64_t sync); typedef uint64_t(STDCALL *PFNGLFENCESYNC)(GLenum condition, GLbitfield syncFlags); typedef void(STDCALL *PFNGLGETSYNCIV)(uint64_t sync, GLenum pname, int32_t bufSize, int32_t *length, int32_t *values); -typedef bool(STDCALL *PFNGLISSYNC)(uint64_t sync); +typedef uint8_t(STDCALL *PFNGLISSYNC)(uint64_t sync); typedef void(STDCALL *PFNGLWAITSYNC)(uint64_t sync, GLbitfield syncFlags, uint64_t timeout); typedef void(STDCALL *PFNGLACTIVETEXTURE)(GLenum unit); typedef void(STDCALL *PFNGLBINDIMAGETEXTURE)(uint32_t unit, uint32_t texture, int32_t level, @@ -7474,8 +7474,8 @@ typedef void(STDCALL *PFNGLGETTEXLEVELPARAMETERIV)(GLenum target, int32_t level, int32_t *params); typedef void(STDCALL *PFNGLGETTEXPARAMETERFV)(GLenum target, GLenum parameter, float *values); typedef void(STDCALL *PFNGLGETTEXPARAMETERIV)(GLenum target, GLenum parameter, int32_t *values); -typedef bool(STDCALL *PFNGLISSAMPLER)(uint32_t sampler); -typedef bool(STDCALL *PFNGLISTEXTURE)(uint32_t texture); +typedef uint8_t(STDCALL *PFNGLISSAMPLER)(uint32_t sampler); +typedef uint8_t(STDCALL *PFNGLISTEXTURE)(uint32_t texture); typedef void(STDCALL *PFNGLPIXELSTOREI)(GLenum parameter, int32_t value); typedef void(STDCALL *PFNGLSAMPLERPARAMETERF)(uint32_t sampler, GLenum pname, float param); typedef void(STDCALL *PFNGLSAMPLERPARAMETERFV)(uint32_t sampler, GLenum pname, float *param); @@ -7513,7 +7513,7 @@ typedef void(STDCALL *PFNGLGENTRANSFORMFEEDBACKS)(int32_t n, uint32_t *ids); typedef void(STDCALL *PFNGLGETTRANSFORMFEEDBACKVARYING)(uint32_t program, uint32_t index, int32_t bufSize, int32_t *length, int32_t *size, GLenum *type, char *name); -typedef bool(STDCALL *PFNGLISTRANSFORMFEEDBACK)(uint32_t id); +typedef uint8_t(STDCALL *PFNGLISTRANSFORMFEEDBACK)(uint32_t id); typedef void(STDCALL *PFNGLPAUSETRANSFORMFEEDBACK)(); typedef void(STDCALL *PFNGLRESUMETRANSFORMFEEDBACK)(); typedef void(STDCALL *PFNGLTRANSFORMFEEDBACKVARYINGS)(uint32_t program, int32_t count, @@ -7530,7 +7530,7 @@ typedef void(STDCALL *PFNGLGETVERTEXATTRIBIUIV)(uint32_t index, GLenum pname, ui typedef void(STDCALL *PFNGLGETVERTEXATTRIBPOINTERV)(uint32_t index, GLenum pname, void **pointer); typedef void(STDCALL *PFNGLGETVERTEXATTRIBFV)(uint32_t index, GLenum pname, float *params); typedef void(STDCALL *PFNGLGETVERTEXATTRIBIV)(uint32_t index, GLenum pname, int32_t *params); -typedef bool(STDCALL *PFNGLISVERTEXARRAY)(uint32_t array); +typedef uint8_t(STDCALL *PFNGLISVERTEXARRAY)(uint32_t array); typedef void(STDCALL *PFNGLVERTEXATTRIB1F)(uint32_t location, float value0); typedef void(STDCALL *PFNGLVERTEXATTRIB1FV)(uint32_t location, float *value); typedef void(STDCALL *PFNGLVERTEXATTRIB2F)(uint32_t location, float value0, float value1); @@ -7556,7 +7556,7 @@ typedef void(STDCALL *PFNGLVERTEXATTRIBIFORMAT)(uint32_t attribindex, int32_t si typedef void(STDCALL *PFNGLVERTEXATTRIBIPOINTER)(uint32_t index, int32_t size, GLenum type, int32_t stride, void *pointer); typedef void(STDCALL *PFNGLVERTEXATTRIBPOINTER)(uint32_t location, int32_t size, GLenum type, - bool normalized, int32_t stride, void *data); + uint8_t normalized, int32_t stride, void *data); typedef void(STDCALL *PFNGLVERTEXBINDINGDIVISOR)(uint32_t bindingindex, uint32_t divisor); typedef int(STDCALL *PFNEGLINITIALIZE)(void *dpy, int *major, int *minor); typedef void *(STDCALL *PFNEGLCREATECONTEXT)(void *display, void *config, void *share_context, diff --git a/gfxapi/gles/api.go b/gfxapi/gles/api.go index e2415a4b2..41bc59904 100644 --- a/gfxapi/gles/api.go +++ b/gfxapi/gles/api.go @@ -3547,56 +3547,6 @@ func (p GLbooleanᵖ) Slice(start, end uint64, ϟs *gfxapi.State) GLbooleanˢ { return GLbooleanˢ{SliceInfo: SliceInfo{Root: p.Pointer, Base: p.Address + start*p.ElementSize(ϟs), Count: end - start}} } -// Boolᵖ is a pointer to a bool element. -type Boolᵖ struct { - binary.Generate - memory.Pointer -} - -// NewBoolᵖ returns a Boolᵖ that points to addr in the application pool. -func NewBoolᵖ(addr uint64) Boolᵖ { - return Boolᵖ{Pointer: memory.Pointer{Address: addr, Pool: memory.ApplicationPool}} -} - -// ElementSize returns the size in bytes of an element that Boolᵖ points to. -func (p Boolᵖ) ElementSize(ϟs *gfxapi.State) uint64 { - return uint64(1) -} - -// Read reads and returns the bool element at the pointer. -func (p Boolᵖ) Read(ϟa atom.Atom, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) bool { - return p.Slice(0, 1, ϟs).Read(ϟa, ϟs, ϟd, ϟl, ϟb)[0] -} - -// Write writes value to the bool element at the pointer. -func (p Boolᵖ) Write(value bool, ϟa atom.Atom, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) { - p.Slice(0, 1, ϟs).Write([]bool{value}, ϟa, ϟs, ϟd, ϟl, ϟb) -} - -// OnRead calls the backing pool's OnRead callback. p is returned so calls can be chained. -func (p Boolᵖ) OnRead(ϟa atom.Atom, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) Boolᵖ { - p.Slice(0, 1, ϟs).OnRead(ϟa, ϟs, ϟd, ϟl, ϟb) - return p -} - -// OnWrite calls the backing pool's OnWrite callback. p is returned so calls can be chained. -func (p Boolᵖ) OnWrite(ϟa atom.Atom, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) Boolᵖ { - p.Slice(0, 1, ϟs).OnWrite(ϟa, ϟs, ϟd, ϟl, ϟb) - return p -} -func (p Boolᵖ) MapMemory(ϟa atom.Atom, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) Boolᵖ { - p.Slice(0, 1, ϟs).MapMemory(ϟa, ϟs, ϟd, ϟl, ϟb) - return p -} - -// Slice returns a new Boolˢ from the pointer using start and end indices. -func (p Boolᵖ) Slice(start, end uint64, ϟs *gfxapi.State) Boolˢ { - if start > end { - panic(fmt.Errorf("Slice start (%d) is greater than the end (%d)", start, end)) - } - return Boolˢ{SliceInfo: SliceInfo{Root: p.Pointer, Base: p.Address + start*p.ElementSize(ϟs), Count: end - start}} -} - // SamplerIdᶜᵖ is a pointer to a SamplerId element. type SamplerIdᶜᵖ struct { binary.Generate @@ -4350,163 +4300,6 @@ type Vec4fː4ᵃ struct { Elements [4]Vec4f } -// Boolˢ is a slice of bool. -type Boolˢ struct { - binary.Generate - SliceInfo -} - -// MakeBoolˢ returns a Boolˢ backed by a new memory pool. -func MakeBoolˢ(count uint64, ϟs *gfxapi.State) Boolˢ { - id := ϟs.NextPoolID - ϟs.Memory[id] = &memory.Pool{} - ϟs.NextPoolID++ - return Boolˢ{SliceInfo: SliceInfo{Count: count, Root: memory.Pointer{Pool: id}}} -} - -// Clone returns a copy of the Boolˢ in a new memory pool. -func (s Boolˢ) Clone(ϟa atom.Atom, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) Boolˢ { - s.OnRead(ϟa, ϟs, ϟd, ϟl, ϟb) - pool := &memory.Pool{} - pool.Write(0, ϟs.Memory[s.Root.Pool].Slice(s.Range(ϟs))) - id := ϟs.NextPoolID - ϟs.Memory[id] = pool - ϟs.NextPoolID++ - dst := Boolˢ{SliceInfo: SliceInfo{Count: s.Count, Root: memory.Pointer{Pool: id}}} - return dst -} - -// ElementSize returns the size in bytes of an element that Boolˢ points to. -func (s Boolˢ) ElementSize(ϟs *gfxapi.State) uint64 { - return uint64(1) -} - -// Range returns the memory range this slice represents in the underlying pool. -func (s Boolˢ) Range(ϟs *gfxapi.State) memory.Range { - return memory.Range{Base: s.Base, Size: s.Count * s.ElementSize(ϟs)} -} - -// ResourceID returns an identifier to a resource representing the data of -// this slice. -func (s Boolˢ) ResourceID(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.ID { - id, err := ϟs.Memory[s.Root.Pool].Slice(s.Range(ϟs)).ResourceID(ϟd, ϟl) - if err != nil { - panic(err) - } - return id -} - -// Decoder returns a memory decoder for the slice. -func (s Boolˢ) Decoder(ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger) binary.Decoder { - return ϟs.MemoryDecoder(ϟs.Memory[s.Root.Pool].Slice(s.Range(ϟs)), ϟd, ϟl) -} - -// Encoder returns a memory encoder for the slice. -func (s Boolˢ) Encoder(ϟs *gfxapi.State) binary.Encoder { - return ϟs.MemoryEncoder(ϟs.Memory[s.Root.Pool], s.Range(ϟs)) -} - -// AsBoolˢ returns s cast to a Boolˢ. -// The returned slice length will be calculated so that the returned slice is -// no longer (in bytes) than s. -func AsBoolˢ(s Slice, ϟs *gfxapi.State) Boolˢ { - out := Boolˢ{SliceInfo: s.Info()} - out.Count = (out.Count * s.ElementSize(ϟs)) / out.ElementSize(ϟs) - return out -} - -// Read reads and returns all the bool elements in this Boolˢ. -func (s Boolˢ) Read(ϟa atom.Atom, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) []bool { - d, res := s.Decoder(ϟs, ϟd, ϟl), make([]bool, s.Count) - s.OnRead(ϟa, ϟs, ϟd, ϟl, ϟb) - for i := range res { - if ϟv, err := d.Bool(); err == nil { - res[i] = ϟv - } else { - panic(err) - } - } - return res -} - -// Write copies elements from src to this slice. The number of elements copied is returned -// which is the minimum of s.Count and len(src). -func (s Boolˢ) Write(src []bool, ϟa atom.Atom, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) uint64 { - count := min(s.Count, uint64(len(src))) - s = s.Slice(0, count, ϟs) - e := s.Encoder(ϟs) - for i := uint64(0); i < count; i++ { - if err := e.Bool(bool(src[i])); err != nil { - panic(err) - } - } - s.OnWrite(ϟa, ϟs, ϟd, ϟl, ϟb) - return count -} - -// Copy copies elements from src to this slice. -// The number of elements copied is the minimum of dst.Count and src.Count. -// The slices of this and dst to the copied elements is returned. -func (dst Boolˢ) Copy(src Boolˢ, ϟa atom.Atom, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) (d, s Boolˢ) { - count := min(dst.Count, src.Count) - dst, src = dst.Slice(0, count, ϟs), src.Slice(0, count, ϟs) - src.OnRead(ϟa, ϟs, ϟd, ϟl, ϟb) - ϟs.Memory[dst.Root.Pool].Write(dst.Base, ϟs.Memory[src.Root.Pool].Slice(src.Range(ϟs))) - dst.OnWrite(ϟa, ϟs, ϟd, ϟl, ϟb) - return dst, src -} - -// OnRead calls the backing pool's OnRead callback. s is returned so calls can be chained. -func (s Boolˢ) OnRead(ϟa atom.Atom, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) Boolˢ { - if f := ϟs.Memory[s.Root.Pool].OnRead; f != nil { - f(s.Range(ϟs)) - } - if ϟb != nil && s.Root.Pool == memory.ApplicationPool { - s.MapMemory(ϟa, ϟs, ϟd, ϟl, ϟb) - ϟb.Write(s.Range(ϟs), s.ResourceID(ϟs, ϟd, ϟl)) - } - return s -} - -// OnWrite calls the backing pool's OnWrite callback. s is returned so calls can be chained. -func (s Boolˢ) OnWrite(ϟa atom.Atom, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) Boolˢ { - if f := ϟs.Memory[s.Root.Pool].OnWrite; f != nil { - f(s.Range(ϟs)) - } - if ϟb != nil && s.Root.Pool == memory.ApplicationPool { - ϟb.MapMemory(s.Root.Range(uint64(s.Range(ϟs).End() - s.Root.Address))) - } - return s -} -func (s Boolˢ) MapMemory(ϟa atom.Atom, ϟs *gfxapi.State, ϟd database.Database, ϟl log.Logger, ϟb *builder.Builder) Boolˢ { - if ϟb != nil && s.Root.Pool == memory.ApplicationPool { - rng := s.Range(ϟs) - ϟb.MapMemory(s.Root.Range(uint64(rng.End() - s.Root.Address))) - } - return s -} - -// Index returns a Boolᵖ to the i'th element in this Boolˢ. -func (s Boolˢ) Index(i uint64, ϟs *gfxapi.State) Boolᵖ { - return Boolᵖ{Pointer: memory.Pointer{Address: s.Base + i*s.ElementSize(ϟs), Pool: s.Root.Pool}} -} - -// Slice returns a sub-slice from the Boolˢ using start and end indices. -func (s Boolˢ) Slice(start, end uint64, ϟs *gfxapi.State) Boolˢ { - if start >= end { - panic(fmt.Errorf("%v.Slice(%d, %d) - start must be less than end", s, start, end)) - } - if end > s.Count { - panic(fmt.Errorf("%v.Slice(%d, %d) - out of bounds", s, start, end)) - } - return Boolˢ{SliceInfo: SliceInfo{Root: s.Root, Base: s.Base + start*s.ElementSize(ϟs), Count: end - start}} -} - -// String returns a string description of the Boolˢ slice. -func (s Boolˢ) String() string { - return fmt.Sprintf("bool(%v@%v)[%d]", s.Base, s.Root.Pool, s.Count) -} - // BufferIdˢ is a slice of BufferId. type BufferIdˢ struct { binary.Generate @@ -13746,7 +13539,7 @@ type GlIsEnablediEXT struct { observations atom.Observations Target GLenum Index GLuint - Result bool + Result GLboolean } func (a *GlIsEnablediEXT) String() string { @@ -14461,7 +14254,7 @@ type GlIsQuery struct { binary.Generate observations atom.Observations Query QueryId - Result bool + Result GLboolean } func (a *GlIsQuery) String() string { @@ -14871,7 +14664,7 @@ type GlIsBuffer struct { binary.Generate observations atom.Observations Buffer BufferId - Result bool + Result GLboolean } func (a *GlIsBuffer) String() string { @@ -20776,7 +20569,7 @@ type GlIsEnablediOES struct { observations atom.Observations Target GLenum Index GLuint - Result bool + Result GLboolean } func (a *GlIsEnablediOES) String() string { @@ -20810,7 +20603,7 @@ type GlIsEnablediNV struct { observations atom.Observations Target GLenum Index GLuint - Result bool + Result GLboolean } func (a *GlIsEnablediNV) String() string { @@ -20843,7 +20636,7 @@ type GlIsFenceNV struct { binary.Generate observations atom.Observations Fence GLuint - Result bool + Result GLboolean } func (a *GlIsFenceNV) String() string { @@ -20876,7 +20669,7 @@ type GlIsImageHandleResidentNV struct { binary.Generate observations atom.Observations Handle GLuint64 - Result bool + Result GLboolean } func (a *GlIsImageHandleResidentNV) String() string { @@ -20909,7 +20702,7 @@ type GlIsPathNV struct { binary.Generate observations atom.Observations Path GLuint - Result bool + Result GLboolean } func (a *GlIsPathNV) String() string { @@ -20945,7 +20738,7 @@ type GlIsPointInFillPathNV struct { Mask GLuint X GLfloat Y GLfloat - Result bool + Result GLboolean } func (a *GlIsPointInFillPathNV) String() string { @@ -20980,7 +20773,7 @@ type GlIsPointInStrokePathNV struct { Path GLuint X GLfloat Y GLfloat - Result bool + Result GLboolean } func (a *GlIsPointInStrokePathNV) String() string { @@ -21013,7 +20806,7 @@ type GlIsProgramPipelineEXT struct { binary.Generate observations atom.Observations Pipeline PipelineId - Result bool + Result GLboolean } func (a *GlIsProgramPipelineEXT) String() string { @@ -21046,7 +20839,7 @@ type GlIsQueryEXT struct { binary.Generate observations atom.Observations Query QueryId - Result bool + Result GLboolean } func (a *GlIsQueryEXT) String() string { @@ -21079,7 +20872,7 @@ type GlIsSyncAPPLE struct { binary.Generate observations atom.Observations Sync GLsync - Result bool + Result GLboolean } func (a *GlIsSyncAPPLE) String() string { @@ -21112,7 +20905,7 @@ type GlIsTextureHandleResidentNV struct { binary.Generate observations atom.Observations Handle GLuint64 - Result bool + Result GLboolean } func (a *GlIsTextureHandleResidentNV) String() string { @@ -21145,7 +20938,7 @@ type GlIsVertexArrayOES struct { binary.Generate observations atom.Observations Array VertexArrayId - Result bool + Result GLboolean } func (a *GlIsVertexArrayOES) String() string { @@ -26775,7 +26568,7 @@ type GlSampleCoverage struct { binary.Generate observations atom.Observations Value GLfloat - Invert bool + Invert GLboolean } func (a *GlSampleCoverage) String() string { @@ -27421,10 +27214,10 @@ func (a *GlClearStencil) Observations() *atom.Observations { return &a.observati type GlColorMask struct { binary.Generate observations atom.Observations - Red bool - Green bool - Blue bool - Alpha bool + Red GLboolean + Green GLboolean + Blue GLboolean + Alpha GLboolean } func (a *GlColorMask) String() string { @@ -27522,7 +27315,7 @@ func (a *GlDeleteRenderbuffers) Observations() *atom.Observations { return &a.ob type GlDepthMask struct { binary.Generate observations atom.Observations - Enabled bool + Enabled GLboolean } func (a *GlDepthMask) String() string { @@ -27939,7 +27732,7 @@ type GlIsFramebuffer struct { binary.Generate observations atom.Observations Framebuffer FramebufferId - Result bool + Result GLboolean } func (a *GlIsFramebuffer) String() string { @@ -27972,7 +27765,7 @@ type GlIsRenderbuffer struct { binary.Generate observations atom.Observations Renderbuffer RenderbufferId - Result bool + Result GLboolean } func (a *GlIsRenderbuffer) String() string { @@ -29914,7 +29707,7 @@ type GlIsProgram struct { binary.Generate observations atom.Observations Program ProgramId - Result bool + Result GLboolean } func (a *GlIsProgram) String() string { @@ -29947,7 +29740,7 @@ type GlIsProgramPipeline struct { binary.Generate observations atom.Observations Pipeline PipelineId - Result bool + Result GLboolean } func (a *GlIsProgramPipeline) String() string { @@ -29980,7 +29773,7 @@ type GlIsShader struct { binary.Generate observations atom.Observations Shader ShaderId - Result bool + Result GLboolean } func (a *GlIsShader) String() string { @@ -33016,7 +32809,7 @@ type GlGetBooleanv struct { binary.Generate observations atom.Observations Param GLenum - Values Boolᵖ + Values GLbooleanᵖ } func (a *GlGetBooleanv) String() string { @@ -33319,7 +33112,7 @@ type GlIsEnabled struct { binary.Generate observations atom.Observations Capability GLenum - Result bool + Result GLboolean } func (a *GlIsEnabled) String() string { @@ -33489,7 +33282,7 @@ type GlIsSync struct { binary.Generate observations atom.Observations Sync GLsync - Result bool + Result GLboolean } func (a *GlIsSync) String() string { @@ -34341,7 +34134,7 @@ type GlIsSampler struct { binary.Generate observations atom.Observations Sampler SamplerId - Result bool + Result GLboolean } func (a *GlIsSampler) String() string { @@ -34374,7 +34167,7 @@ type GlIsTexture struct { binary.Generate observations atom.Observations Texture TextureId - Result bool + Result GLboolean } func (a *GlIsTexture) String() string { @@ -35185,7 +34978,7 @@ type GlIsTransformFeedback struct { binary.Generate observations atom.Observations Id TransformFeedbackId - Result bool + Result GLboolean } func (a *GlIsTransformFeedback) String() string { @@ -35682,7 +35475,7 @@ type GlIsVertexArray struct { binary.Generate observations atom.Observations Array VertexArrayId - Result bool + Result GLboolean } func (a *GlIsVertexArray) String() string { @@ -36298,7 +36091,7 @@ type GlVertexAttribPointer struct { Location AttributeLocation Size GLint Type GLenum - Normalized bool + Normalized GLboolean Stride GLsizei Data VertexPointer } @@ -37631,7 +37424,7 @@ type VertexAttributeArray struct { Enabled bool Size uint32 Type GLenum - Normalized bool + Normalized GLboolean Stride GLsizei Buffer BufferId Pointer VertexPointer @@ -37641,7 +37434,7 @@ func (c *VertexAttributeArray) Init() { c.Enabled = false c.Size = 4 c.Type = GLenum_GL_FLOAT - c.Normalized = false + c.Normalized = 0 c.Stride = 0 c.Buffer = 0 } @@ -37685,14 +37478,14 @@ func (c *BlendState) Init() { //////////////////////////////////////////////////////////////////////////////// type RasterizerState struct { binary.Generate - DepthMask bool + DepthMask GLboolean DepthTestFunction GLenum DepthNear GLfloat DepthFar GLfloat - ColorMaskRed bool - ColorMaskGreen bool - ColorMaskBlue bool - ColorMaskAlpha bool + ColorMaskRed GLboolean + ColorMaskGreen GLboolean + ColorMaskBlue GLboolean + ColorMaskAlpha GLboolean StencilMask GLenumːGLuintᵐ Viewport Rect Scissor Rect @@ -37702,18 +37495,18 @@ type RasterizerState struct { PolygonOffsetFactor GLfloat PolygonOffsetUnits GLfloat SampleCoverageValue GLfloat - SampleCoverageInvert bool + SampleCoverageInvert GLboolean } func (c *RasterizerState) Init() { - c.DepthMask = true + c.DepthMask = 1 c.DepthTestFunction = GLenum_GL_LESS c.DepthNear = 0 c.DepthFar = 1 - c.ColorMaskRed = true - c.ColorMaskGreen = true - c.ColorMaskBlue = true - c.ColorMaskAlpha = true + c.ColorMaskRed = 1 + c.ColorMaskGreen = 1 + c.ColorMaskBlue = 1 + c.ColorMaskAlpha = 1 c.StencilMask = make(GLenumːGLuintᵐ) c.Viewport.Init() c.Scissor.Init() @@ -43531,7 +43324,7 @@ func NewGlGetTexParameterIivEXT(Target GLenum, Pname GLenum, Params memory.Point func NewGlGetTexParameterIuivEXT(Target GLenum, Pname GLenum, Params memory.Pointer) *GlGetTexParameterIuivEXT { return &GlGetTexParameterIuivEXT{Target: Target, Pname: Pname, Params: GLuintᵖ{Pointer: Params}} } -func NewGlIsEnablediEXT(Target GLenum, Index GLuint, Result bool) *GlIsEnablediEXT { +func NewGlIsEnablediEXT(Target GLenum, Index GLuint, Result GLboolean) *GlIsEnablediEXT { return &GlIsEnablediEXT{Target: Target, Index: Index, Result: Result} } func NewGlMinSampleShadingOES(Value GLfloat) *GlMinSampleShadingOES { @@ -43594,7 +43387,7 @@ func NewGlGetQueryObjectuiv(Query QueryId, Parameter GLenum, Value memory.Pointe func NewGlGetQueryiv(Target GLenum, Parameter GLenum, Value memory.Pointer) *GlGetQueryiv { return &GlGetQueryiv{Target: Target, Parameter: Parameter, Value: GLintᵖ{Pointer: Value}} } -func NewGlIsQuery(Query QueryId, Result bool) *GlIsQuery { +func NewGlIsQuery(Query QueryId, Result GLboolean) *GlIsQuery { return &GlIsQuery{Query: Query, Result: Result} } func NewGlBindBuffer(Target GLenum, Buffer BufferId) *GlBindBuffer { @@ -43630,7 +43423,7 @@ func NewGlGetBufferParameteriv(Target GLenum, Parameter GLenum, Value memory.Poi func NewGlGetBufferPointerv(Target GLenum, Pname GLenum, Params memory.Pointer) *GlGetBufferPointerv { return &GlGetBufferPointerv{Target: Target, Pname: Pname, Params: Voidᵖᵖ{Pointer: Params}} } -func NewGlIsBuffer(Buffer BufferId, Result bool) *GlIsBuffer { +func NewGlIsBuffer(Buffer BufferId, Result GLboolean) *GlIsBuffer { return &GlIsBuffer{Buffer: Buffer, Result: Result} } func NewGlMapBufferRange(Target GLenum, Offset GLintptr, Length GLsizeiptr, Access GLbitfield, Result memory.Pointer) *GlMapBufferRange { @@ -44140,40 +43933,40 @@ func NewGlInsertEventMarkerEXT(Length GLsizei, Marker memory.Pointer) *GlInsertE func NewGlInterpolatePathsNV(ResultPath GLuint, PathA GLuint, PathB GLuint, Weight GLfloat) *GlInterpolatePathsNV { return &GlInterpolatePathsNV{ResultPath: ResultPath, PathA: PathA, PathB: PathB, Weight: Weight} } -func NewGlIsEnablediOES(Target GLenum, Index GLuint, Result bool) *GlIsEnablediOES { +func NewGlIsEnablediOES(Target GLenum, Index GLuint, Result GLboolean) *GlIsEnablediOES { return &GlIsEnablediOES{Target: Target, Index: Index, Result: Result} } -func NewGlIsEnablediNV(Target GLenum, Index GLuint, Result bool) *GlIsEnablediNV { +func NewGlIsEnablediNV(Target GLenum, Index GLuint, Result GLboolean) *GlIsEnablediNV { return &GlIsEnablediNV{Target: Target, Index: Index, Result: Result} } -func NewGlIsFenceNV(Fence GLuint, Result bool) *GlIsFenceNV { +func NewGlIsFenceNV(Fence GLuint, Result GLboolean) *GlIsFenceNV { return &GlIsFenceNV{Fence: Fence, Result: Result} } -func NewGlIsImageHandleResidentNV(Handle GLuint64, Result bool) *GlIsImageHandleResidentNV { +func NewGlIsImageHandleResidentNV(Handle GLuint64, Result GLboolean) *GlIsImageHandleResidentNV { return &GlIsImageHandleResidentNV{Handle: Handle, Result: Result} } -func NewGlIsPathNV(Path GLuint, Result bool) *GlIsPathNV { +func NewGlIsPathNV(Path GLuint, Result GLboolean) *GlIsPathNV { return &GlIsPathNV{Path: Path, Result: Result} } -func NewGlIsPointInFillPathNV(Path GLuint, Mask GLuint, X GLfloat, Y GLfloat, Result bool) *GlIsPointInFillPathNV { +func NewGlIsPointInFillPathNV(Path GLuint, Mask GLuint, X GLfloat, Y GLfloat, Result GLboolean) *GlIsPointInFillPathNV { return &GlIsPointInFillPathNV{Path: Path, Mask: Mask, X: X, Y: Y, Result: Result} } -func NewGlIsPointInStrokePathNV(Path GLuint, X GLfloat, Y GLfloat, Result bool) *GlIsPointInStrokePathNV { +func NewGlIsPointInStrokePathNV(Path GLuint, X GLfloat, Y GLfloat, Result GLboolean) *GlIsPointInStrokePathNV { return &GlIsPointInStrokePathNV{Path: Path, X: X, Y: Y, Result: Result} } -func NewGlIsProgramPipelineEXT(Pipeline PipelineId, Result bool) *GlIsProgramPipelineEXT { +func NewGlIsProgramPipelineEXT(Pipeline PipelineId, Result GLboolean) *GlIsProgramPipelineEXT { return &GlIsProgramPipelineEXT{Pipeline: Pipeline, Result: Result} } -func NewGlIsQueryEXT(Query QueryId, Result bool) *GlIsQueryEXT { +func NewGlIsQueryEXT(Query QueryId, Result GLboolean) *GlIsQueryEXT { return &GlIsQueryEXT{Query: Query, Result: Result} } -func NewGlIsSyncAPPLE(Sync GLsync, Result bool) *GlIsSyncAPPLE { +func NewGlIsSyncAPPLE(Sync GLsync, Result GLboolean) *GlIsSyncAPPLE { return &GlIsSyncAPPLE{Sync: Sync, Result: Result} } -func NewGlIsTextureHandleResidentNV(Handle GLuint64, Result bool) *GlIsTextureHandleResidentNV { +func NewGlIsTextureHandleResidentNV(Handle GLuint64, Result GLboolean) *GlIsTextureHandleResidentNV { return &GlIsTextureHandleResidentNV{Handle: Handle, Result: Result} } -func NewGlIsVertexArrayOES(Array VertexArrayId, Result bool) *GlIsVertexArrayOES { +func NewGlIsVertexArrayOES(Array VertexArrayId, Result GLboolean) *GlIsVertexArrayOES { return &GlIsVertexArrayOES{Array: Array, Result: Result} } func NewGlLabelObjectEXT(Type GLenum, Object GLuint, Length GLsizei, Label memory.Pointer) *GlLabelObjectEXT { @@ -44653,7 +44446,7 @@ func NewGlBlendFuncSeparate(Src_factor_rgb GLenum, Dst_factor_rgb GLenum, Src_fa func NewGlDepthFunc(Function GLenum) *GlDepthFunc { return &GlDepthFunc{Function: Function} } -func NewGlSampleCoverage(Value GLfloat, Invert bool) *GlSampleCoverage { +func NewGlSampleCoverage(Value GLfloat, Invert GLboolean) *GlSampleCoverage { return &GlSampleCoverage{Value: Value, Invert: Invert} } func NewGlSampleMaski(MaskNumber GLuint, Mask GLbitfield) *GlSampleMaski { @@ -44710,7 +44503,7 @@ func NewGlClearDepthf(Depth GLfloat) *GlClearDepthf { func NewGlClearStencil(Stencil GLint) *GlClearStencil { return &GlClearStencil{Stencil: Stencil} } -func NewGlColorMask(Red bool, Green bool, Blue bool, Alpha bool) *GlColorMask { +func NewGlColorMask(Red GLboolean, Green GLboolean, Blue GLboolean, Alpha GLboolean) *GlColorMask { return &GlColorMask{Red: Red, Green: Green, Blue: Blue, Alpha: Alpha} } func NewGlDeleteFramebuffers(Count GLsizei, Framebuffers memory.Pointer) *GlDeleteFramebuffers { @@ -44719,7 +44512,7 @@ func NewGlDeleteFramebuffers(Count GLsizei, Framebuffers memory.Pointer) *GlDele func NewGlDeleteRenderbuffers(Count GLsizei, Renderbuffers memory.Pointer) *GlDeleteRenderbuffers { return &GlDeleteRenderbuffers{Count: Count, Renderbuffers: RenderbufferIdᶜᵖ{Pointer: Renderbuffers}} } -func NewGlDepthMask(Enabled bool) *GlDepthMask { +func NewGlDepthMask(Enabled GLboolean) *GlDepthMask { return &GlDepthMask{Enabled: Enabled} } func NewGlFramebufferParameteri(Target GLenum, Pname GLenum, Param GLint) *GlFramebufferParameteri { @@ -44755,10 +44548,10 @@ func NewGlInvalidateFramebuffer(Target GLenum, Count GLsizei, Attachments memory func NewGlInvalidateSubFramebuffer(Target GLenum, NumAttachments GLsizei, Attachments memory.Pointer, X GLint, Y GLint, Width GLsizei, Height GLsizei) *GlInvalidateSubFramebuffer { return &GlInvalidateSubFramebuffer{Target: Target, NumAttachments: NumAttachments, Attachments: GLenumᶜᵖ{Pointer: Attachments}, X: X, Y: Y, Width: Width, Height: Height} } -func NewGlIsFramebuffer(Framebuffer FramebufferId, Result bool) *GlIsFramebuffer { +func NewGlIsFramebuffer(Framebuffer FramebufferId, Result GLboolean) *GlIsFramebuffer { return &GlIsFramebuffer{Framebuffer: Framebuffer, Result: Result} } -func NewGlIsRenderbuffer(Renderbuffer RenderbufferId, Result bool) *GlIsRenderbuffer { +func NewGlIsRenderbuffer(Renderbuffer RenderbufferId, Result GLboolean) *GlIsRenderbuffer { return &GlIsRenderbuffer{Renderbuffer: Renderbuffer, Result: Result} } func NewGlReadBuffer(Src GLenum) *GlReadBuffer { @@ -44929,13 +44722,13 @@ func NewGlGetUniformiv(Program ProgramId, Location UniformLocation, Values memor func NewGlGetUniformuiv(Program ProgramId, Location UniformLocation, Params memory.Pointer) *GlGetUniformuiv { return &GlGetUniformuiv{Program: Program, Location: Location, Params: GLuintᵖ{Pointer: Params}} } -func NewGlIsProgram(Program ProgramId, Result bool) *GlIsProgram { +func NewGlIsProgram(Program ProgramId, Result GLboolean) *GlIsProgram { return &GlIsProgram{Program: Program, Result: Result} } -func NewGlIsProgramPipeline(Pipeline PipelineId, Result bool) *GlIsProgramPipeline { +func NewGlIsProgramPipeline(Pipeline PipelineId, Result GLboolean) *GlIsProgramPipeline { return &GlIsProgramPipeline{Pipeline: Pipeline, Result: Result} } -func NewGlIsShader(Shader ShaderId, Result bool) *GlIsShader { +func NewGlIsShader(Shader ShaderId, Result GLboolean) *GlIsShader { return &GlIsShader{Shader: Shader, Result: Result} } func NewGlLinkProgram(Program ProgramId) *GlLinkProgram { @@ -45200,7 +44993,7 @@ func NewGlGetBooleani_v(Target GLenum, Index GLuint, Data memory.Pointer) *GlGet return &GlGetBooleani_v{Target: Target, Index: Index, Data: GLbooleanᵖ{Pointer: Data}} } func NewGlGetBooleanv(Param GLenum, Values memory.Pointer) *GlGetBooleanv { - return &GlGetBooleanv{Param: Param, Values: Boolᵖ{Pointer: Values}} + return &GlGetBooleanv{Param: Param, Values: GLbooleanᵖ{Pointer: Values}} } func NewGlGetFloatv(Param GLenum, Values memory.Pointer) *GlGetFloatv { return &GlGetFloatv{Param: Param, Values: GLfloatᵖ{Pointer: Values}} @@ -45226,7 +45019,7 @@ func NewGlGetString(Param GLenum, Result memory.Pointer) *GlGetString { func NewGlGetStringi(Name GLenum, Index GLuint, Result memory.Pointer) *GlGetStringi { return &GlGetStringi{Name: Name, Index: Index, Result: GLubyteᶜᵖ{Pointer: Result}} } -func NewGlIsEnabled(Capability GLenum, Result bool) *GlIsEnabled { +func NewGlIsEnabled(Capability GLenum, Result GLboolean) *GlIsEnabled { return &GlIsEnabled{Capability: Capability, Result: Result} } func NewGlClientWaitSync(Sync GLsync, SyncFlags GLbitfield, Timeout GLuint64, Result GLenum) *GlClientWaitSync { @@ -45241,7 +45034,7 @@ func NewGlFenceSync(Condition GLenum, SyncFlags GLbitfield, Result GLsync) *GlFe func NewGlGetSynciv(Sync GLsync, Pname GLenum, BufSize GLsizei, Length memory.Pointer, Values memory.Pointer) *GlGetSynciv { return &GlGetSynciv{Sync: Sync, Pname: Pname, BufSize: BufSize, Length: GLsizeiᵖ{Pointer: Length}, Values: GLintᵖ{Pointer: Values}} } -func NewGlIsSync(Sync GLsync, Result bool) *GlIsSync { +func NewGlIsSync(Sync GLsync, Result GLboolean) *GlIsSync { return &GlIsSync{Sync: Sync, Result: Result} } func NewGlWaitSync(Sync GLsync, SyncFlags GLbitfield, Timeout GLuint64) *GlWaitSync { @@ -45313,10 +45106,10 @@ func NewGlGetTexParameterfv(Target GLenum, Parameter GLenum, Values memory.Point func NewGlGetTexParameteriv(Target GLenum, Parameter GLenum, Values memory.Pointer) *GlGetTexParameteriv { return &GlGetTexParameteriv{Target: Target, Parameter: Parameter, Values: GLintᵖ{Pointer: Values}} } -func NewGlIsSampler(Sampler SamplerId, Result bool) *GlIsSampler { +func NewGlIsSampler(Sampler SamplerId, Result GLboolean) *GlIsSampler { return &GlIsSampler{Sampler: Sampler, Result: Result} } -func NewGlIsTexture(Texture TextureId, Result bool) *GlIsTexture { +func NewGlIsTexture(Texture TextureId, Result GLboolean) *GlIsTexture { return &GlIsTexture{Texture: Texture, Result: Result} } func NewGlPixelStorei(Parameter GLenum, Value GLint) *GlPixelStorei { @@ -45385,7 +45178,7 @@ func NewGlGenTransformFeedbacks(N GLsizei, Ids memory.Pointer) *GlGenTransformFe func NewGlGetTransformFeedbackVarying(Program ProgramId, Index GLuint, BufSize GLsizei, Length memory.Pointer, Size memory.Pointer, Type memory.Pointer, Name memory.Pointer) *GlGetTransformFeedbackVarying { return &GlGetTransformFeedbackVarying{Program: Program, Index: Index, BufSize: BufSize, Length: GLsizeiᵖ{Pointer: Length}, Size: GLsizeiᵖ{Pointer: Size}, Type: GLenumᵖ{Pointer: Type}, Name: GLcharᵖ{Pointer: Name}} } -func NewGlIsTransformFeedback(Id TransformFeedbackId, Result bool) *GlIsTransformFeedback { +func NewGlIsTransformFeedback(Id TransformFeedbackId, Result GLboolean) *GlIsTransformFeedback { return &GlIsTransformFeedback{Id: Id, Result: Result} } func NewGlPauseTransformFeedback() *GlPauseTransformFeedback { @@ -45430,7 +45223,7 @@ func NewGlGetVertexAttribfv(Index AttributeLocation, Pname GLenum, Params memory func NewGlGetVertexAttribiv(Index AttributeLocation, Pname GLenum, Params memory.Pointer) *GlGetVertexAttribiv { return &GlGetVertexAttribiv{Index: Index, Pname: Pname, Params: GLintᵖ{Pointer: Params}} } -func NewGlIsVertexArray(Array VertexArrayId, Result bool) *GlIsVertexArray { +func NewGlIsVertexArray(Array VertexArrayId, Result GLboolean) *GlIsVertexArray { return &GlIsVertexArray{Array: Array, Result: Result} } func NewGlVertexAttrib1f(Location AttributeLocation, Value0 GLfloat) *GlVertexAttrib1f { @@ -45484,7 +45277,7 @@ func NewGlVertexAttribIFormat(Attribindex GLuint, Size GLint, Type GLenum, Relat func NewGlVertexAttribIPointer(Index AttributeLocation, Size GLint, Type GLenum, Stride GLsizei, Pointer memory.Pointer) *GlVertexAttribIPointer { return &GlVertexAttribIPointer{Index: Index, Size: Size, Type: Type, Stride: Stride, Pointer: Voidᶜᵖ{Pointer: Pointer}} } -func NewGlVertexAttribPointer(Location AttributeLocation, Size GLint, Type GLenum, Normalized bool, Stride GLsizei, Data memory.Pointer) *GlVertexAttribPointer { +func NewGlVertexAttribPointer(Location AttributeLocation, Size GLint, Type GLenum, Normalized GLboolean, Stride GLsizei, Data memory.Pointer) *GlVertexAttribPointer { return &GlVertexAttribPointer{Location: Location, Size: Size, Type: Type, Normalized: Normalized, Stride: Stride, Data: VertexPointer{Pointer: Data}} } func NewGlVertexBindingDivisor(Bindingindex GLuint, Divisor GLuint) *GlVertexBindingDivisor { diff --git a/gfxapi/gles/api/android_extension_pack.api b/gfxapi/gles/api/android_extension_pack.api index c6b8b6b3b..e4766693a 100644 --- a/gfxapi/gles/api/android_extension_pack.api +++ b/gfxapi/gles/api/android_extension_pack.api @@ -182,7 +182,7 @@ cmd void glGetTexParameterIuivEXT(GLenum target, GLenum pname, GLuint* params) { } @Doc("https://www.khronos.org/registry/gles/extensions/EXT/EXT_draw_buffers_indexed.txt","GL_EXT_draw_buffers_indexed") -cmd bool glIsEnablediEXT(GLenum target, GLuint index) { +cmd GLboolean glIsEnablediEXT(GLenum target, GLuint index) { requiresExtension(GL_EXT_draw_buffers_indexed) // TODO return ? diff --git a/gfxapi/gles/api/asynchronous_queries.api b/gfxapi/gles/api/asynchronous_queries.api index 41ad05dc4..9b7d32ba9 100644 --- a/gfxapi/gles/api/asynchronous_queries.api +++ b/gfxapi/gles/api/asynchronous_queries.api @@ -113,10 +113,10 @@ cmd void glGetQueryiv(GLenum target, GLenum parameter, GLint* value) { @Doc("https://www.khronos.org/opengles/sdk/docs/man3/html/glIsQuery.xhtml","OpenGL ES 3.0") @Doc("https://www.khronos.org/opengles/sdk/docs/man31/html/glIsQuery.xhtml","OpenGL ES 3.1") -cmd bool glIsQuery(QueryId query) { +cmd GLboolean glIsQuery(QueryId query) { minRequiredVersion(3, 0) ctx := GetContext() - return query in ctx.Instances.Queries + return as!GLboolean(query in ctx.Instances.Queries) } diff --git a/gfxapi/gles/api/buffer_objects.api b/gfxapi/gles/api/buffer_objects.api index f1e00a46f..52531f8c8 100644 --- a/gfxapi/gles/api/buffer_objects.api +++ b/gfxapi/gles/api/buffer_objects.api @@ -304,11 +304,11 @@ cmd void glGetBufferPointerv(GLenum target, GLenum pname, void** params) { @Doc("https://www.khronos.org/opengles/sdk/docs/man/xhtml/glIsBuffer.xml","OpenGL ES 2.0") @Doc("https://www.khronos.org/opengles/sdk/docs/man3/html/glIsBuffer.xhtml","OpenGL ES 3.0") @Doc("https://www.khronos.org/opengles/sdk/docs/man31/html/glIsBuffer.xhtml","OpenGL ES 3.1") -cmd bool glIsBuffer(BufferId buffer) { +cmd GLboolean glIsBuffer(BufferId buffer) { minRequiredVersion(2, 0) ctx := GetContext() - return buffer in ctx.Instances.Buffers + return as!GLboolean(buffer in ctx.Instances.Buffers) } @Doc("https://www.khronos.org/opengles/sdk/docs/man3/html/glMapBufferRange.xhtml","OpenGL ES 3.0") diff --git a/gfxapi/gles/api/extensions.api b/gfxapi/gles/api/extensions.api index a982e4d99..3a2233bc8 100644 --- a/gfxapi/gles/api/extensions.api +++ b/gfxapi/gles/api/extensions.api @@ -1332,56 +1332,56 @@ cmd void glInterpolatePathsNV(GLuint resultPath, GLuint pathA, GLuint pathB, GLf } @Doc("https://www.khronos.org/registry/gles/extensions/OES/OES_draw_buffers_indexed.txt","GL_OES_draw_buffers_indexed") -cmd bool glIsEnablediOES(GLenum target, GLuint index) { +cmd GLboolean glIsEnablediOES(GLenum target, GLuint index) { requiresExtension(GL_OES_draw_buffers_indexed) // TODO return ? } @Doc("https://www.khronos.org/registry/gles/extensions/NV/NV_viewport_array.txt","GL_NV_viewport_array") -cmd bool glIsEnablediNV(GLenum target, GLuint index) { +cmd GLboolean glIsEnablediNV(GLenum target, GLuint index) { requiresExtension(GL_NV_viewport_array) // TODO return ? } @Doc("https://www.khronos.org/registry/gles/extensions/NV/fence.txt","GL_NV_fence") -cmd bool glIsFenceNV(GLuint fence) { +cmd GLboolean glIsFenceNV(GLuint fence) { requiresExtension(GL_NV_fence) // TODO return ? } @Doc("https://www.khronos.org/registry/gles/extensions/NV/bindless_texture.txt","GL_NV_bindless_texture") -cmd bool glIsImageHandleResidentNV(GLuint64 handle) { +cmd GLboolean glIsImageHandleResidentNV(GLuint64 handle) { requiresExtension(GL_NV_bindless_texture) // TODO return ? } @Doc("https://www.khronos.org/registry/gles/extensions/NV/path_rendering.txt","GL_NV_path_rendering") -cmd bool glIsPathNV(GLuint path) { +cmd GLboolean glIsPathNV(GLuint path) { requiresExtension(GL_NV_path_rendering) // TODO return ? } @Doc("https://www.khronos.org/registry/gles/extensions/NV/path_rendering.txt","GL_NV_path_rendering") -cmd bool glIsPointInFillPathNV(GLuint path, GLuint mask, GLfloat x, GLfloat y) { +cmd GLboolean glIsPointInFillPathNV(GLuint path, GLuint mask, GLfloat x, GLfloat y) { requiresExtension(GL_NV_path_rendering) // TODO return ? } @Doc("https://www.khronos.org/registry/gles/extensions/NV/path_rendering.txt","GL_NV_path_rendering") -cmd bool glIsPointInStrokePathNV(GLuint path, GLfloat x, GLfloat y) { +cmd GLboolean glIsPointInStrokePathNV(GLuint path, GLfloat x, GLfloat y) { requiresExtension(GL_NV_path_rendering) // TODO return ? } @Doc("https://www.khronos.org/registry/gles/extensions/EXT/EXT_separate_shader_objects.txt","GL_EXT_separate_shader_objects") -cmd bool glIsProgramPipelineEXT(PipelineId pipeline) { +cmd GLboolean glIsProgramPipelineEXT(PipelineId pipeline) { requiresExtension(GL_EXT_separate_shader_objects) // TODO return ? @@ -1389,35 +1389,35 @@ cmd bool glIsProgramPipelineEXT(PipelineId pipeline) { @Doc("https://www.khronos.org/registry/gles/extensions/EXT/EXT_disjoint_timer_query.txt","GL_EXT_disjoint_timer_query") @Doc("https://www.khronos.org/registry/gles/extensions/EXT/EXT_occlusion_query_boolean.txt","GL_EXT_occlusion_query_boolean") -cmd bool glIsQueryEXT(QueryId query) { +cmd GLboolean glIsQueryEXT(QueryId query) { requiresExtension(GL_EXT_disjoint_timer_query) requiresExtension(GL_EXT_occlusion_query_boolean) // TODO: Multiple extensions ctx := GetContext() - return query in ctx.Instances.Queries + return as!GLboolean(query in ctx.Instances.Queries) } @Doc("https://www.khronos.org/registry/gles/extensions/APPLE/APPLE_sync.txt","GL_APPLE_sync") -cmd bool glIsSyncAPPLE(GLsync sync) { +cmd GLboolean glIsSyncAPPLE(GLsync sync) { requiresExtension(GL_APPLE_sync) // TODO return ? } @Doc("https://www.khronos.org/registry/gles/extensions/NV/bindless_texture.txt","GL_NV_bindless_texture") -cmd bool glIsTextureHandleResidentNV(GLuint64 handle) { +cmd GLboolean glIsTextureHandleResidentNV(GLuint64 handle) { requiresExtension(GL_NV_bindless_texture) // TODO return ? } @Doc("https://www.khronos.org/registry/gles/extensions/OES/OES_vertex_array_object.txt","GL_OES_vertex_array_object") -cmd bool glIsVertexArrayOES(VertexArrayId array) { +cmd GLboolean glIsVertexArrayOES(VertexArrayId array) { requiresExtension(GL_OES_vertex_array_object) ctx := GetContext() - return array in ctx.Instances.VertexArrays + return as!GLboolean(array in ctx.Instances.VertexArrays) } @Doc("https://www.khronos.org/registry/gles/extensions/EXT/EXT_debug_label.txt","GL_EXT_debug_label") diff --git a/gfxapi/gles/api/fragment_operations.api b/gfxapi/gles/api/fragment_operations.api index 5f06f5d17..ce1f329ae 100644 --- a/gfxapi/gles/api/fragment_operations.api +++ b/gfxapi/gles/api/fragment_operations.api @@ -198,7 +198,7 @@ cmd void glDepthFunc(GLenum function) { @Doc("https://www.khronos.org/opengles/sdk/docs/man/xhtml/glSampleCoverage.xml","OpenGL ES 2.0") @Doc("https://www.khronos.org/opengles/sdk/docs/man3/html/glSampleCoverage.xhtml","OpenGL ES 3.0") @Doc("https://www.khronos.org/opengles/sdk/docs/man31/html/glSampleCoverage.xhtml","OpenGL ES 3.1") -cmd void glSampleCoverage(GLfloat value, bool invert) { +cmd void glSampleCoverage(GLfloat value, GLboolean invert) { minRequiredVersion(2, 0) ctx := GetContext() diff --git a/gfxapi/gles/api/framebuffer.api b/gfxapi/gles/api/framebuffer.api index c9e289223..57bc0a2e8 100644 --- a/gfxapi/gles/api/framebuffer.api +++ b/gfxapi/gles/api/framebuffer.api @@ -227,7 +227,7 @@ cmd void glClearStencil(GLint stencil) { @Doc("https://www.khronos.org/opengles/sdk/docs/man/xhtml/glColorMask.xml","OpenGL ES 2.0") @Doc("https://www.khronos.org/opengles/sdk/docs/man3/html/glColorMask.xhtml","OpenGL ES 3.0") @Doc("https://www.khronos.org/opengles/sdk/docs/man31/html/glColorMask.xhtml","OpenGL ES 3.1") -cmd void glColorMask(bool red, bool green, bool blue, bool alpha) { +cmd void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) { minRequiredVersion(2, 0) ctx := GetContext() @@ -266,7 +266,7 @@ cmd void glDeleteRenderbuffers(GLsizei count, const RenderbufferId* renderbuffer @Doc("https://www.khronos.org/opengles/sdk/docs/man/xhtml/glDepthMask.xml","OpenGL ES 2.0") @Doc("https://www.khronos.org/opengles/sdk/docs/man3/html/glDepthMask.xhtml","OpenGL ES 3.0") @Doc("https://www.khronos.org/opengles/sdk/docs/man31/html/glDepthMask.xhtml","OpenGL ES 3.1") -cmd void glDepthMask(bool enabled) { +cmd void glDepthMask(GLboolean enabled) { minRequiredVersion(2, 0) ctx := GetContext() @@ -674,21 +674,21 @@ cmd void glInvalidateSubFramebuffer(GLenum target, @Doc("https://www.khronos.org/opengles/sdk/docs/man/xhtml/glIsFramebuffer.xml","OpenGL ES 2.0") @Doc("https://www.khronos.org/opengles/sdk/docs/man3/html/glIsFramebuffer.xhtml","OpenGL ES 3.0") @Doc("https://www.khronos.org/opengles/sdk/docs/man31/html/glIsFramebuffer.xhtml","OpenGL ES 3.1") -cmd bool glIsFramebuffer(FramebufferId framebuffer) { +cmd GLboolean glIsFramebuffer(FramebufferId framebuffer) { minRequiredVersion(2, 0) ctx := GetContext() - return framebuffer in ctx.Instances.Framebuffers + return as!GLboolean(framebuffer in ctx.Instances.Framebuffers) } @Doc("https://www.khronos.org/opengles/sdk/docs/man/xhtml/glIsRenderbuffer.xml","OpenGL ES 2.0") @Doc("https://www.khronos.org/opengles/sdk/docs/man3/html/glIsRenderbuffer.xhtml","OpenGL ES 3.0") @Doc("https://www.khronos.org/opengles/sdk/docs/man31/html/glIsRenderbuffer.xhtml","OpenGL ES 3.1") -cmd bool glIsRenderbuffer(RenderbufferId renderbuffer) { +cmd GLboolean glIsRenderbuffer(RenderbufferId renderbuffer) { minRequiredVersion(2, 0) ctx := GetContext() - return renderbuffer in ctx.Instances.Renderbuffers + return as!GLboolean(renderbuffer in ctx.Instances.Renderbuffers) } @Doc("https://www.khronos.org/opengles/sdk/docs/man3/html/glReadBuffer.xhtml","OpenGL ES 3.0") diff --git a/gfxapi/gles/api/programs_and_shaders.api b/gfxapi/gles/api/programs_and_shaders.api index 99ab894fe..ce9688446 100644 --- a/gfxapi/gles/api/programs_and_shaders.api +++ b/gfxapi/gles/api/programs_and_shaders.api @@ -639,15 +639,15 @@ cmd void glGetUniformuiv(ProgramId program, UniformLocation location, GLuint* pa @Doc("https://www.khronos.org/opengles/sdk/docs/man/xhtml/glIsProgram.xml","OpenGL ES 2.0") @Doc("https://www.khronos.org/opengles/sdk/docs/man3/html/glIsProgram.xhtml","OpenGL ES 3.0") @Doc("https://www.khronos.org/opengles/sdk/docs/man31/html/glIsProgram.xhtml","OpenGL ES 3.1") -cmd bool glIsProgram(ProgramId program) { +cmd GLboolean glIsProgram(ProgramId program) { minRequiredVersion(2, 0) ctx := GetContext() - return program in ctx.Instances.Programs + return as!GLboolean(program in ctx.Instances.Programs) } @Doc("https://www.khronos.org/opengles/sdk/docs/man31/html/glIsProgramPipeline.xhtml","OpenGL ES 3.1") -cmd bool glIsProgramPipeline(PipelineId pipeline) { +cmd GLboolean glIsProgramPipeline(PipelineId pipeline) { minRequiredVersion(3, 1) // TODO return ? @@ -656,11 +656,11 @@ cmd bool glIsProgramPipeline(PipelineId pipeline) { @Doc("https://www.khronos.org/opengles/sdk/docs/man/xhtml/glIsShader.xml","OpenGL ES 2.0") @Doc("https://www.khronos.org/opengles/sdk/docs/man3/html/glIsShader.xhtml","OpenGL ES 3.0") @Doc("https://www.khronos.org/opengles/sdk/docs/man31/html/glIsShader.xhtml","OpenGL ES 3.1") -cmd bool glIsShader(ShaderId shader) { +cmd GLboolean glIsShader(ShaderId shader) { minRequiredVersion(2, 0) ctx := GetContext() - return shader in ctx.Instances.Shaders + return as!GLboolean(shader in ctx.Instances.Shaders) } @Doc("https://www.khronos.org/opengles/sdk/docs/man/xhtml/glLinkProgram.xml","OpenGL ES 2.0") diff --git a/gfxapi/gles/api/state_queries.api b/gfxapi/gles/api/state_queries.api index 137694fab..61d9b9023 100644 --- a/gfxapi/gles/api/state_queries.api +++ b/gfxapi/gles/api/state_queries.api @@ -93,7 +93,7 @@ cmd void glGetBooleani_v(GLenum target, GLuint index, GLboolean* data) { @Doc("https://www.khronos.org/opengles/sdk/docs/man/xhtml/glGet.xml","OpenGL ES 2.0") @Doc("https://www.khronos.org/opengles/sdk/docs/man3/html/glGet.xhtml","OpenGL ES 3.0") @Doc("https://www.khronos.org/opengles/sdk/docs/man31/html/glGet.xhtml","OpenGL ES 3.1") -cmd void glGetBooleanv(GLenum param, bool* values) { +cmd void glGetBooleanv(GLenum param, GLboolean* values) { minRequiredVersion(2, 0) switch (param) { // GL_FRAMEBUFFER_BINDING was renamed to GL_DRAW_FRAMEBUFFER_BINDING in 3.0 @@ -178,34 +178,34 @@ cmd void glGetBooleanv(GLenum param, bool* values) { ctx := GetContext() switch (param) { case GL_BLEND: - v[0] = ctx.Capabilities[GL_BLEND] + v[0] = as!GLboolean(ctx.Capabilities[GL_BLEND]) case GL_CULL_FACE: - v[0] = ctx.Capabilities[GL_CULL_FACE] + v[0] = as!GLboolean(ctx.Capabilities[GL_CULL_FACE]) case GL_DEPTH_TEST: - v[0] = ctx.Capabilities[GL_DEPTH_TEST] + v[0] = as!GLboolean(ctx.Capabilities[GL_DEPTH_TEST]) case GL_DITHER: - v[0] = ctx.Capabilities[GL_DITHER] + v[0] = as!GLboolean(ctx.Capabilities[GL_DITHER]) case GL_POLYGON_OFFSET_FILL: - v[0] = ctx.Capabilities[GL_POLYGON_OFFSET_FILL] + v[0] = as!GLboolean(ctx.Capabilities[GL_POLYGON_OFFSET_FILL]) case GL_SAMPLE_ALPHA_TO_COVERAGE: - v[0] = ctx.Capabilities[GL_SAMPLE_ALPHA_TO_COVERAGE] + v[0] = as!GLboolean(ctx.Capabilities[GL_SAMPLE_ALPHA_TO_COVERAGE]) case GL_SAMPLE_COVERAGE: - v[0] = ctx.Capabilities[GL_SAMPLE_COVERAGE] + v[0] = as!GLboolean(ctx.Capabilities[GL_SAMPLE_COVERAGE]) case GL_SCISSOR_TEST: - v[0] = ctx.Capabilities[GL_SCISSOR_TEST] + v[0] = as!GLboolean(ctx.Capabilities[GL_SCISSOR_TEST]) case GL_STENCIL_TEST: - v[0] = ctx.Capabilities[GL_STENCIL_TEST] + v[0] = as!GLboolean(ctx.Capabilities[GL_STENCIL_TEST]) case GL_DEPTH_WRITEMASK: - v[0] = ctx.Rasterizing.DepthMask + v[0] = as!GLboolean(ctx.Rasterizing.DepthMask) case GL_COLOR_WRITEMASK: { - v[0] = ctx.Rasterizing.ColorMaskRed - v[1] = ctx.Rasterizing.ColorMaskGreen - v[2] = ctx.Rasterizing.ColorMaskBlue - v[3] = ctx.Rasterizing.ColorMaskAlpha + v[0] = as!GLboolean(ctx.Rasterizing.ColorMaskRed) + v[1] = as!GLboolean(ctx.Rasterizing.ColorMaskGreen) + v[2] = as!GLboolean(ctx.Rasterizing.ColorMaskBlue) + v[3] = as!GLboolean(ctx.Rasterizing.ColorMaskAlpha) } case GL_SAMPLE_COVERAGE_INVERT: - v[0] = ctx.Rasterizing.SampleCoverageInvert + v[0] = as!GLboolean(ctx.Rasterizing.SampleCoverageInvert) case GL_SHADER_COMPILER: v[0] = ? case GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT: @@ -941,7 +941,7 @@ cmd const GLubyte* glGetStringi(GLenum name, GLuint index) { @Doc("https://www.khronos.org/opengles/sdk/docs/man/xhtml/glIsEnabled.xml","OpenGL ES 2.0") @Doc("https://www.khronos.org/opengles/sdk/docs/man3/html/glIsEnabled.xhtml","OpenGL ES 3.0") @Doc("https://www.khronos.org/opengles/sdk/docs/man31/html/glIsEnabled.xhtml","OpenGL ES 3.1") -cmd bool glIsEnabled(GLenum capability) { +cmd GLboolean glIsEnabled(GLenum capability) { minRequiredVersion(2, 0) switch (capability) { case GL_BLEND, GL_CULL_FACE, GL_DEPTH_TEST, GL_DITHER, GL_POLYGON_OFFSET_FILL, @@ -957,6 +957,6 @@ cmd bool glIsEnabled(GLenum capability) { } ctx := GetContext() - return ctx.Capabilities[capability] + return as!GLboolean(ctx.Capabilities[capability]) } diff --git a/gfxapi/gles/api/synchronization.api b/gfxapi/gles/api/synchronization.api index cec69988a..fb12075a2 100644 --- a/gfxapi/gles/api/synchronization.api +++ b/gfxapi/gles/api/synchronization.api @@ -63,7 +63,7 @@ cmd void glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length @Doc("https://www.khronos.org/opengles/sdk/docs/man3/html/glIsSync.xhtml","OpenGL ES 3.0") @Doc("https://www.khronos.org/opengles/sdk/docs/man31/html/glIsSync.xhtml","OpenGL ES 3.1") -cmd bool glIsSync(GLsync sync) { +cmd GLboolean glIsSync(GLsync sync) { minRequiredVersion(3, 0) // TODO return ? diff --git a/gfxapi/gles/api/textures_and_samplers.api b/gfxapi/gles/api/textures_and_samplers.api index 43fc8e4ed..799b87f6d 100644 --- a/gfxapi/gles/api/textures_and_samplers.api +++ b/gfxapi/gles/api/textures_and_samplers.api @@ -643,7 +643,7 @@ cmd void glGetTexParameteriv(GLenum target, GLenum parameter, GLint* values) { @Doc("https://www.khronos.org/opengles/sdk/docs/man3/html/glIsSampler.xhtml","OpenGL ES 3.0") @Doc("https://www.khronos.org/opengles/sdk/docs/man31/html/glIsSampler.xhtml","OpenGL ES 3.1") -cmd bool glIsSampler(SamplerId sampler) { +cmd GLboolean glIsSampler(SamplerId sampler) { minRequiredVersion(3, 0) // TODO return ? @@ -652,11 +652,11 @@ cmd bool glIsSampler(SamplerId sampler) { @Doc("https://www.khronos.org/opengles/sdk/docs/man/xhtml/glIsTexture.xml","OpenGL ES 2.0") @Doc("https://www.khronos.org/opengles/sdk/docs/man3/html/glIsTexture.xhtml","OpenGL ES 3.0") @Doc("https://www.khronos.org/opengles/sdk/docs/man31/html/glIsTexture.xhtml","OpenGL ES 3.1") -cmd bool glIsTexture(TextureId texture) { +cmd GLboolean glIsTexture(TextureId texture) { minRequiredVersion(2, 0) ctx := GetContext() - return texture in ctx.Instances.Textures + return as!GLboolean(texture in ctx.Instances.Textures) } @Doc("https://www.khronos.org/opengles/sdk/docs/man/xhtml/glPixelStorei.xml","OpenGL ES 2.0") diff --git a/gfxapi/gles/api/transform_feedback.api b/gfxapi/gles/api/transform_feedback.api index 8fd03bdc9..c74522921 100644 --- a/gfxapi/gles/api/transform_feedback.api +++ b/gfxapi/gles/api/transform_feedback.api @@ -78,7 +78,7 @@ cmd void glGetTransformFeedbackVarying(ProgramId program, @Doc("https://www.khronos.org/opengles/sdk/docs/man3/html/glIsTransformFeedback.xhtml","OpenGL ES 3.0") @Doc("https://www.khronos.org/opengles/sdk/docs/man31/html/glIsTransformFeedback.xhtml","OpenGL ES 3.1") -cmd bool glIsTransformFeedback(TransformFeedbackId id) { +cmd GLboolean glIsTransformFeedback(TransformFeedbackId id) { minRequiredVersion(3, 0) // TODO return ? diff --git a/gfxapi/gles/api/vertex_arrays.api b/gfxapi/gles/api/vertex_arrays.api index 2737490ae..2497ebbde 100644 --- a/gfxapi/gles/api/vertex_arrays.api +++ b/gfxapi/gles/api/vertex_arrays.api @@ -184,7 +184,7 @@ cmd void glGetVertexAttribiv(AttributeLocation index, GLenum pname, GLint* param @Doc("https://www.khronos.org/opengles/sdk/docs/man3/html/glIsVertexArray.xhtml","OpenGL ES 3.0") @Doc("https://www.khronos.org/opengles/sdk/docs/man31/html/glIsVertexArray.xhtml","OpenGL ES 3.1") -cmd bool glIsVertexArray(VertexArrayId array) { +cmd GLboolean glIsVertexArray(VertexArrayId array) { minRequiredVersion(3, 0) // TODO return ? @@ -368,7 +368,7 @@ cmd void glVertexAttribIPointer(AttributeLocation index, cmd void glVertexAttribPointer(AttributeLocation location, GLint size, GLenum type, - bool normalized, + GLboolean normalized, GLsizei stride, VertexPointer data) { minRequiredVersion(2, 0) diff --git a/gfxapi/gles/gles.api b/gfxapi/gles/gles.api index 49fe15f73..059158531 100644 --- a/gfxapi/gles/gles.api +++ b/gfxapi/gles/gles.api @@ -413,7 +413,7 @@ class VertexAttributeArray { bool Enabled = false u32 Size = 4 // Number of components. 1, 2, 3 or 4. GLenum Type = GL_FLOAT // Type of each component. - bool Normalized = false + GLboolean Normalized = 0 GLsizei Stride = 0 // Byte offset between each consecutive attribute, or 0 for tight. BufferId Buffer = 0 VertexPointer Pointer // Used if Buffer == 0 @@ -439,14 +439,14 @@ class BlendState { @internal class RasterizerState { - bool DepthMask = true + GLboolean DepthMask = 1 GLenum DepthTestFunction = GL_LESS GLfloat DepthNear = 0.0 GLfloat DepthFar = 1.0 - bool ColorMaskRed = true - bool ColorMaskGreen = true - bool ColorMaskBlue = true - bool ColorMaskAlpha = true + GLboolean ColorMaskRed = 1 + GLboolean ColorMaskGreen = 1 + GLboolean ColorMaskBlue = 1 + GLboolean ColorMaskAlpha = 1 map!(GLenum, GLuint) StencilMask Rect Viewport Rect Scissor @@ -456,7 +456,7 @@ class RasterizerState { GLfloat PolygonOffsetFactor GLfloat PolygonOffsetUnits GLfloat SampleCoverageValue = 1.0 - bool SampleCoverageInvert + GLboolean SampleCoverageInvert } @internal diff --git a/gfxapi/gles/gles_binary.go b/gfxapi/gles/gles_binary.go index fec2e3acc..4ce48ccae 100644 --- a/gfxapi/gles/gles_binary.go +++ b/gfxapi/gles/gles_binary.go @@ -24,8 +24,6 @@ func init() { Namespace.Add((*Color)(nil).Class()) Namespace.Add((*BlendState)(nil).Class()) Namespace.Add((*SliceInfo)(nil).Class()) - Namespace.Add((*Boolˢ)(nil).Class()) - Namespace.Add((*Boolᵖ)(nil).Class()) Namespace.Add((*U8ˢ)(nil).Class()) Namespace.Add((*Buffer)(nil).Class()) Namespace.Add((*BufferDataPointer)(nil).Class()) @@ -909,8 +907,6 @@ var ( binaryIDColor = binary.ID{0xd0, 0x81, 0x98, 0xcb, 0xe9, 0x4c, 0xb5, 0x68, 0xdf, 0xab, 0x2e, 0xde, 0xed, 0x47, 0x59, 0xd3, 0xa7, 0xaa, 0x6c, 0x98} binaryIDBlendState = binary.ID{0xa0, 0x25, 0x10, 0x49, 0xe6, 0xb8, 0xfb, 0x31, 0xf9, 0x74, 0xa1, 0x14, 0x8f, 0x6d, 0x7e, 0x3b, 0x51, 0x1d, 0x3b, 0x7f} binaryIDSliceInfo = binary.ID{0x8e, 0xab, 0xab, 0x1b, 0x89, 0x6a, 0x43, 0x9a, 0x3c, 0xa7, 0xb8, 0x43, 0x28, 0x26, 0x72, 0x30, 0x78, 0x26, 0x38, 0xf9} - binaryIDBoolˢ = binary.ID{0xf9, 0x44, 0xf2, 0x44, 0xbb, 0x78, 0x01, 0x7e, 0x56, 0xa1, 0x2f, 0x0d, 0x73, 0x9c, 0xa1, 0x77, 0x23, 0x5d, 0x47, 0xa8} - binaryIDBoolᵖ = binary.ID{0x99, 0x96, 0x28, 0x2f, 0x78, 0x22, 0x44, 0xc9, 0x8f, 0x89, 0x53, 0x2f, 0x40, 0x01, 0x69, 0xd1, 0xa0, 0x82, 0x72, 0x24} binaryIDU8ˢ = binary.ID{0xf7, 0xd9, 0x83, 0x86, 0x77, 0xcc, 0x52, 0xb0, 0x80, 0x2f, 0xfc, 0x47, 0xa5, 0x91, 0x72, 0xd9, 0x3b, 0xcd, 0x65, 0x01} binaryIDBuffer = binary.ID{0x72, 0x94, 0x68, 0xa4, 0x0c, 0xe0, 0x5f, 0x61, 0x88, 0x16, 0xab, 0xc8, 0xd6, 0xe8, 0x69, 0xf4, 0x39, 0x2d, 0xc4, 0xbf} binaryIDBufferDataPointer = binary.ID{0x28, 0x86, 0x55, 0x2c, 0x45, 0xa3, 0x8f, 0x56, 0xed, 0xc2, 0x86, 0x93, 0xaa, 0xf1, 0x64, 0x7b, 0x11, 0xba, 0xff, 0x0b} @@ -938,9 +934,9 @@ var ( binaryIDCharᵖ = binary.ID{0xac, 0x44, 0x67, 0xfc, 0xf8, 0x14, 0x79, 0xb0, 0x1e, 0xd5, 0xf7, 0xb0, 0xbb, 0xcb, 0x2b, 0x24, 0x88, 0xf4, 0x59, 0xc7} binaryIDClearState = binary.ID{0x08, 0xa6, 0xc5, 0x64, 0x5c, 0xc4, 0x9c, 0xf0, 0xad, 0xc5, 0x82, 0x38, 0x2d, 0x37, 0x08, 0xe6, 0x5d, 0x51, 0x63, 0xa0} binaryIDRect = binary.ID{0x90, 0xd2, 0x28, 0x1d, 0x44, 0xe8, 0xe1, 0x22, 0x18, 0xef, 0x0a, 0xa6, 0xe7, 0xb3, 0x7b, 0x88, 0xc0, 0x48, 0x38, 0xa2} - binaryIDRasterizerState = binary.ID{0x8f, 0x8a, 0x9b, 0x1a, 0xfe, 0xff, 0x2b, 0xd1, 0x64, 0x1e, 0x91, 0xda, 0x14, 0x3c, 0x05, 0x0a, 0x1d, 0xb4, 0xc1, 0xa2} + binaryIDRasterizerState = binary.ID{0xba, 0xcc, 0xd9, 0x38, 0xef, 0x30, 0x2c, 0x2e, 0x7b, 0xd7, 0x18, 0x82, 0x47, 0x5c, 0x0f, 0xca, 0xd0, 0x70, 0x0c, 0x27} binaryIDVertexPointer = binary.ID{0xf9, 0xce, 0xac, 0x76, 0x09, 0x23, 0xf1, 0xed, 0x02, 0x01, 0xe0, 0x91, 0x9a, 0x2c, 0x78, 0xaf, 0x3d, 0x8f, 0x02, 0xa9} - binaryIDVertexAttributeArray = binary.ID{0x64, 0x7d, 0x26, 0xce, 0xd4, 0x3e, 0xba, 0x93, 0x29, 0xf8, 0x4f, 0xa9, 0xbe, 0x10, 0x35, 0x4c, 0x00, 0x1c, 0x5d, 0xf1} + binaryIDVertexAttributeArray = binary.ID{0xd6, 0xdb, 0x80, 0x6a, 0xa4, 0x37, 0x8a, 0xfb, 0x6f, 0x2b, 0xda, 0x40, 0x36, 0x4d, 0x5a, 0x43, 0xf8, 0x16, 0x3e, 0x41} binaryIDRenderbuffer = binary.ID{0x76, 0xf9, 0x8d, 0xf3, 0x8e, 0xe3, 0xa9, 0xb0, 0x01, 0x9c, 0x35, 0xe6, 0xdc, 0x52, 0x1a, 0x40, 0x4d, 0xcc, 0x9b, 0xbd} binaryIDImage = binary.ID{0x7a, 0xc7, 0x5e, 0xb9, 0x51, 0x71, 0x08, 0x40, 0x9c, 0xda, 0x78, 0x5a, 0xc0, 0xca, 0x85, 0x97, 0x03, 0xff, 0xdf, 0xbb} binaryIDCubemapLevel = binary.ID{0x1c, 0xc1, 0xfa, 0xd8, 0xb4, 0xda, 0xc5, 0x86, 0x02, 0xcd, 0x3a, 0x43, 0xbc, 0x10, 0x9f, 0xe4, 0x55, 0x68, 0xe2, 0x4f} @@ -1075,7 +1071,7 @@ var ( binaryIDGlClearStencil = binary.ID{0xcf, 0xf4, 0x84, 0x08, 0x83, 0x47, 0x09, 0x6a, 0x66, 0xac, 0xbf, 0xee, 0x05, 0xb5, 0x57, 0x40, 0xa8, 0x5d, 0x8a, 0x91} binaryIDGlClientWaitSync = binary.ID{0x0b, 0x68, 0xeb, 0x64, 0xf5, 0xef, 0x38, 0xd0, 0x9f, 0xbf, 0x73, 0x4c, 0xf2, 0xdd, 0xc5, 0xe5, 0xd8, 0xd7, 0xe1, 0x84} binaryIDGlClientWaitSyncAPPLE = binary.ID{0x66, 0xc0, 0xa1, 0x35, 0xec, 0x45, 0x5d, 0xed, 0x8d, 0x2e, 0x77, 0x60, 0x07, 0xde, 0x10, 0x29, 0x7b, 0x8f, 0x5a, 0xa8} - binaryIDGlColorMask = binary.ID{0x0b, 0x72, 0x03, 0xf6, 0x51, 0x6a, 0xe3, 0xca, 0x0c, 0x5d, 0x08, 0x46, 0xf6, 0x8b, 0x71, 0xdf, 0x67, 0xe5, 0xae, 0xf9} + binaryIDGlColorMask = binary.ID{0x08, 0x8e, 0x3b, 0xb6, 0x7d, 0x88, 0x07, 0x6c, 0x0b, 0x69, 0xba, 0xf5, 0x56, 0x97, 0xc3, 0xde, 0x2a, 0xa6, 0xc7, 0x5b} binaryIDGlColorMaskiEXT = binary.ID{0xd8, 0xb9, 0x63, 0xa6, 0xb9, 0xe9, 0xbf, 0xba, 0xc9, 0x91, 0x91, 0x63, 0xa1, 0x78, 0x8c, 0xa4, 0x0f, 0x1c, 0x17, 0x95} binaryIDGlColorMaskiOES = binary.ID{0x22, 0xb2, 0xa8, 0x79, 0x8c, 0x2b, 0x70, 0x10, 0x7c, 0xc2, 0x79, 0xf6, 0xce, 0xe5, 0x03, 0x13, 0xd8, 0x40, 0x22, 0xc2} binaryIDGlCompileShader = binary.ID{0xce, 0x1e, 0x7c, 0xbf, 0xf7, 0xb7, 0x95, 0x6d, 0x38, 0x5d, 0x42, 0x6d, 0x1e, 0xba, 0x0e, 0xd5, 0xf4, 0xa9, 0xe7, 0x30} @@ -1141,7 +1137,7 @@ var ( binaryIDGlDeleteVertexArrays = binary.ID{0x76, 0x64, 0xf9, 0x2d, 0x99, 0xa8, 0xdf, 0x1c, 0x1e, 0x0a, 0x2d, 0xe5, 0x98, 0xcc, 0x86, 0x28, 0x11, 0xae, 0x98, 0x33} binaryIDGlDeleteVertexArraysOES = binary.ID{0x22, 0x27, 0xfa, 0x8c, 0x76, 0xe8, 0xf5, 0xfc, 0x12, 0xbd, 0xf0, 0xa5, 0xad, 0xe8, 0x7c, 0xab, 0xe8, 0xdc, 0xb0, 0x61} binaryIDGlDepthFunc = binary.ID{0xda, 0xba, 0x70, 0x40, 0xec, 0x50, 0xc2, 0x08, 0x20, 0x33, 0xbb, 0x87, 0x31, 0x5e, 0x01, 0x49, 0xdb, 0xf7, 0x8b, 0x60} - binaryIDGlDepthMask = binary.ID{0xc5, 0x6d, 0x4e, 0x1a, 0x87, 0x06, 0xec, 0xa4, 0xe8, 0xb4, 0x2e, 0x82, 0xff, 0x78, 0x0a, 0x83, 0x79, 0x82, 0xce, 0xf1} + binaryIDGlDepthMask = binary.ID{0x97, 0x3f, 0x4a, 0x6e, 0x55, 0xfe, 0x5c, 0x75, 0x97, 0x64, 0xbc, 0x51, 0xff, 0x17, 0x83, 0xc7, 0x86, 0x81, 0xde, 0xe2} binaryIDGlDepthRangeArrayfvNV = binary.ID{0x14, 0xd6, 0x46, 0x9f, 0x02, 0x6e, 0xbc, 0xa1, 0x43, 0xeb, 0xb8, 0x7f, 0x10, 0x39, 0x01, 0x05, 0xe4, 0x78, 0x51, 0x59} binaryIDGlDepthRangeIndexedfNV = binary.ID{0x26, 0x4b, 0x47, 0xe6, 0xd5, 0x1e, 0xbd, 0xf1, 0x29, 0x6a, 0x36, 0xec, 0xca, 0x53, 0x2a, 0x6d, 0x12, 0xdf, 0x12, 0x63} binaryIDGlDepthRangef = binary.ID{0x2e, 0x91, 0xbb, 0x94, 0xb7, 0x52, 0x60, 0xef, 0x28, 0x5f, 0x90, 0xc7, 0xd5, 0xad, 0xf3, 0xb0, 0xfb, 0x26, 0xcc, 0x48} @@ -1263,7 +1259,7 @@ var ( binaryIDGlGetAttachedShaders = binary.ID{0x50, 0x20, 0x01, 0x35, 0xf4, 0x86, 0x57, 0xab, 0xd6, 0x53, 0x6f, 0x7c, 0x7f, 0x84, 0xcb, 0x83, 0x7f, 0x43, 0xf5, 0x04} binaryIDGlGetAttribLocation = binary.ID{0x75, 0xe9, 0x55, 0x96, 0x01, 0x85, 0x1d, 0xe7, 0xa7, 0xe9, 0xef, 0x2b, 0xd9, 0x77, 0x06, 0x8f, 0xe8, 0xd1, 0xce, 0x85} binaryIDGlGetBooleani_v = binary.ID{0xbe, 0x62, 0xf1, 0x22, 0xe9, 0x23, 0x5a, 0x62, 0x6d, 0x83, 0xf4, 0xa2, 0x9b, 0x26, 0x67, 0xf0, 0xff, 0x5b, 0x49, 0x36} - binaryIDGlGetBooleanv = binary.ID{0x97, 0xc0, 0xb6, 0x7f, 0x15, 0xec, 0xa2, 0x39, 0x64, 0x28, 0x0a, 0xac, 0x21, 0xda, 0xc1, 0x48, 0x10, 0x1b, 0x0d, 0x99} + binaryIDGlGetBooleanv = binary.ID{0xb2, 0x87, 0x76, 0x95, 0xc0, 0xf9, 0xcf, 0x8f, 0x96, 0xf2, 0x88, 0x6c, 0xe2, 0x42, 0xae, 0x98, 0x8b, 0x78, 0x63, 0xfb} binaryIDGlGetBufferParameteri64v = binary.ID{0x78, 0xf8, 0xa3, 0xa0, 0xe0, 0x61, 0x42, 0x73, 0x31, 0xfe, 0x9f, 0x5f, 0xe0, 0xe9, 0x27, 0xcb, 0x91, 0xbd, 0x10, 0xb3} binaryIDGlGetBufferParameteriv = binary.ID{0xcb, 0x07, 0x1f, 0x27, 0x1d, 0x18, 0xbe, 0xcf, 0x2e, 0xb3, 0x4c, 0x5d, 0x9b, 0x3d, 0x6b, 0xa9, 0xfa, 0xe9, 0x80, 0x54} binaryIDGlGetBufferPointerv = binary.ID{0xa3, 0x3f, 0x91, 0xab, 0xed, 0x6d, 0x34, 0xb9, 0x97, 0xb3, 0xcd, 0x76, 0xbd, 0x24, 0x18, 0x2f, 0xeb, 0x6b, 0xcc, 0x42} @@ -1389,32 +1385,32 @@ var ( binaryIDGlInterpolatePathsNV = binary.ID{0xf1, 0x3f, 0x62, 0x9d, 0xc0, 0x60, 0x18, 0x46, 0x59, 0x6c, 0xa1, 0x45, 0x08, 0x2c, 0x36, 0xd2, 0xa0, 0xff, 0xae, 0xc6} binaryIDGlInvalidateFramebuffer = binary.ID{0xdb, 0x61, 0xf4, 0xea, 0xf6, 0xd0, 0x32, 0x53, 0xd9, 0xe3, 0xb8, 0x49, 0xe3, 0x7b, 0x4e, 0x3d, 0x21, 0x57, 0xae, 0xfc} binaryIDGlInvalidateSubFramebuffer = binary.ID{0x4e, 0xf4, 0x42, 0xeb, 0x9a, 0x66, 0xc5, 0xe3, 0x09, 0x6c, 0x2f, 0x32, 0x7a, 0x81, 0x05, 0x8c, 0xe3, 0x59, 0x49, 0x59} - binaryIDGlIsBuffer = binary.ID{0x25, 0xf9, 0x53, 0xf4, 0x60, 0x55, 0xc5, 0xfe, 0x8a, 0x0f, 0xd4, 0x1a, 0x88, 0xe7, 0xf4, 0x4c, 0xcc, 0x81, 0x3b, 0xb7} - binaryIDGlIsEnabled = binary.ID{0x1e, 0x76, 0x5e, 0x33, 0x18, 0x3f, 0x49, 0x72, 0x76, 0x25, 0x26, 0xfc, 0x02, 0xba, 0xec, 0x57, 0xbf, 0xcd, 0x0e, 0xa6} - binaryIDGlIsEnablediEXT = binary.ID{0x3c, 0xda, 0x4c, 0x00, 0x38, 0x1d, 0x18, 0xda, 0x25, 0x67, 0x96, 0xb9, 0xbe, 0x6f, 0xa6, 0x42, 0xa2, 0xa1, 0x64, 0x64} - binaryIDGlIsEnablediNV = binary.ID{0x16, 0x60, 0xa3, 0x8f, 0x2e, 0x7e, 0xfc, 0x14, 0xb6, 0xae, 0x10, 0x9e, 0xfc, 0xbc, 0xa4, 0xfa, 0xc4, 0x31, 0x90, 0xc9} - binaryIDGlIsEnablediOES = binary.ID{0x7a, 0x7a, 0x4b, 0x7b, 0xfc, 0xc6, 0xd9, 0xf9, 0x66, 0xb6, 0xa9, 0x50, 0x9d, 0x16, 0xa5, 0x62, 0x58, 0x5f, 0x51, 0xf8} - binaryIDGlIsFenceNV = binary.ID{0xd0, 0x36, 0x79, 0x51, 0x81, 0x82, 0xed, 0xb7, 0x37, 0xd7, 0x25, 0xb3, 0x21, 0x1d, 0x42, 0x60, 0xea, 0xeb, 0x7d, 0x36} - binaryIDGlIsFramebuffer = binary.ID{0x0b, 0xdd, 0x4e, 0xe8, 0x9f, 0x9d, 0xcc, 0xd2, 0xea, 0x1a, 0xa6, 0xc5, 0xef, 0x65, 0x2e, 0x02, 0x80, 0xe0, 0xc4, 0x63} - binaryIDGlIsImageHandleResidentNV = binary.ID{0xb6, 0xfb, 0xff, 0xb4, 0x8c, 0x61, 0x02, 0xe7, 0x4c, 0x8a, 0xe2, 0x24, 0x61, 0xbc, 0x61, 0x74, 0xd3, 0x97, 0x7f, 0x16} - binaryIDGlIsPathNV = binary.ID{0xfb, 0x83, 0xef, 0x93, 0x94, 0x6f, 0xad, 0x68, 0xa9, 0x9f, 0x83, 0x37, 0x8e, 0x23, 0x95, 0x6f, 0xf0, 0x4a, 0x38, 0x0b} - binaryIDGlIsPointInFillPathNV = binary.ID{0x07, 0xa7, 0x0a, 0xce, 0xd9, 0x63, 0x98, 0xc7, 0x0d, 0xe1, 0x10, 0xdb, 0xed, 0x19, 0x00, 0xe0, 0x3f, 0x61, 0xde, 0x31} - binaryIDGlIsPointInStrokePathNV = binary.ID{0x5b, 0xcc, 0x1e, 0x2f, 0xd6, 0x59, 0xc6, 0x90, 0x9b, 0x68, 0x80, 0x42, 0xea, 0x77, 0x2d, 0xa8, 0x1b, 0x20, 0x7b, 0x27} - binaryIDGlIsProgram = binary.ID{0x62, 0xbd, 0xde, 0xd6, 0x51, 0x60, 0x50, 0x3e, 0x3d, 0x54, 0x0a, 0xec, 0xb2, 0xcd, 0xf5, 0x54, 0xfb, 0x79, 0x3c, 0xdd} - binaryIDGlIsProgramPipeline = binary.ID{0x12, 0xc3, 0x33, 0x56, 0x4d, 0x0b, 0xc2, 0x6a, 0x89, 0x06, 0x71, 0x90, 0xaf, 0xc6, 0x07, 0x5b, 0x4f, 0x57, 0xed, 0x4b} - binaryIDGlIsProgramPipelineEXT = binary.ID{0x02, 0x06, 0x86, 0x2b, 0x7f, 0x2f, 0x1c, 0xa7, 0xa8, 0x6f, 0xd1, 0x91, 0x5a, 0x8d, 0xd8, 0xcd, 0xe5, 0x0b, 0x36, 0xd2} - binaryIDGlIsQuery = binary.ID{0x3b, 0x6f, 0x09, 0x4b, 0x89, 0xdc, 0x6b, 0x2f, 0x74, 0xd6, 0x51, 0x3b, 0x3f, 0xfe, 0x6d, 0x60, 0x72, 0x60, 0x61, 0xe2} - binaryIDGlIsQueryEXT = binary.ID{0xb1, 0x6a, 0x0d, 0xdf, 0xb6, 0xea, 0x3d, 0x84, 0xd0, 0x8c, 0x22, 0xf5, 0xf9, 0x82, 0x88, 0xa5, 0x3e, 0xdd, 0x56, 0xea} - binaryIDGlIsRenderbuffer = binary.ID{0xee, 0xfa, 0xeb, 0x17, 0x01, 0xe1, 0xe4, 0xc6, 0x90, 0x90, 0x9c, 0xfa, 0x28, 0x24, 0xad, 0x33, 0xc5, 0xef, 0x2f, 0xe6} - binaryIDGlIsSampler = binary.ID{0xe7, 0x20, 0x74, 0xdd, 0xbc, 0xd4, 0x8a, 0x01, 0xe5, 0x8d, 0xf6, 0x31, 0xa0, 0xea, 0xe8, 0xc7, 0xc2, 0x9e, 0x40, 0x12} - binaryIDGlIsShader = binary.ID{0xb5, 0x7a, 0x83, 0x39, 0x62, 0xa0, 0x1c, 0x3d, 0x08, 0x84, 0x29, 0xda, 0x1a, 0x6a, 0xe2, 0xd6, 0x24, 0x88, 0x4e, 0xe2} - binaryIDGlIsSync = binary.ID{0x91, 0x49, 0xac, 0x3e, 0x81, 0x9f, 0x67, 0x37, 0x47, 0x69, 0x6c, 0x75, 0x87, 0x40, 0x58, 0x21, 0x3d, 0x12, 0x03, 0x81} - binaryIDGlIsSyncAPPLE = binary.ID{0xc5, 0xd9, 0xbc, 0x70, 0x4c, 0xd1, 0x8a, 0x59, 0x8c, 0x5a, 0xde, 0xf2, 0x3c, 0x77, 0xc3, 0xb0, 0xb8, 0x6f, 0xa2, 0x52} - binaryIDGlIsTexture = binary.ID{0xae, 0x84, 0x50, 0xca, 0xe6, 0x83, 0x45, 0x6c, 0x68, 0x8d, 0x96, 0xf2, 0xb2, 0x0f, 0x9c, 0x01, 0x78, 0x1c, 0x12, 0xdd} - binaryIDGlIsTextureHandleResidentNV = binary.ID{0x86, 0xd0, 0xaf, 0x39, 0x23, 0x63, 0x6a, 0x88, 0xca, 0xd3, 0x8b, 0xa5, 0x97, 0x3f, 0x1b, 0xd0, 0x8c, 0xd6, 0xbb, 0xb0} - binaryIDGlIsTransformFeedback = binary.ID{0x73, 0xf1, 0xcd, 0x3b, 0xc3, 0xba, 0x36, 0x0d, 0x81, 0x3f, 0x46, 0x9c, 0xc0, 0x51, 0x85, 0x45, 0x1a, 0x70, 0xbb, 0xbc} - binaryIDGlIsVertexArray = binary.ID{0xfa, 0x3f, 0x47, 0xbd, 0xae, 0xc8, 0x4c, 0x38, 0xa1, 0x33, 0x6c, 0x4f, 0x39, 0x74, 0x9f, 0x90, 0x9e, 0x9e, 0x5d, 0x86} - binaryIDGlIsVertexArrayOES = binary.ID{0xab, 0xa3, 0xb5, 0xac, 0x9c, 0x32, 0x14, 0xdb, 0x82, 0x00, 0xa7, 0xbd, 0xe0, 0xb2, 0x40, 0x64, 0xac, 0x30, 0xb8, 0xc7} + binaryIDGlIsBuffer = binary.ID{0xd1, 0x42, 0xad, 0xb7, 0x81, 0x67, 0x04, 0x3a, 0x6e, 0x6a, 0x0a, 0x72, 0x75, 0xcb, 0x7c, 0x15, 0xa1, 0x9a, 0xf8, 0x66} + binaryIDGlIsEnabled = binary.ID{0xdf, 0xea, 0x56, 0xfa, 0xb1, 0x23, 0x94, 0xf6, 0x32, 0xef, 0x9e, 0x76, 0x22, 0x90, 0x9e, 0x64, 0x72, 0x78, 0x9a, 0x77} + binaryIDGlIsEnablediEXT = binary.ID{0xae, 0x61, 0xac, 0xf0, 0xa8, 0x0a, 0xda, 0xd4, 0x62, 0x6f, 0x79, 0x2a, 0x94, 0xcc, 0x5b, 0x49, 0xde, 0xea, 0x1c, 0xfc} + binaryIDGlIsEnablediNV = binary.ID{0x23, 0x7a, 0xc2, 0xbc, 0x0c, 0x99, 0xbd, 0xa3, 0x4a, 0x46, 0xb7, 0x73, 0xe3, 0xaf, 0xfe, 0xe9, 0x57, 0x71, 0xf8, 0xd5} + binaryIDGlIsEnablediOES = binary.ID{0xdc, 0x6b, 0x8a, 0x3f, 0x3a, 0xcb, 0xdb, 0x01, 0xc1, 0xc6, 0x0e, 0x8e, 0xab, 0x90, 0xfb, 0x0d, 0x76, 0x5e, 0xb2, 0xad} + binaryIDGlIsFenceNV = binary.ID{0x00, 0xbe, 0x20, 0x72, 0x2b, 0x08, 0x81, 0xee, 0x1e, 0x4c, 0xae, 0x5b, 0x5e, 0x61, 0x2c, 0x78, 0x6c, 0xcc, 0x58, 0xfa} + binaryIDGlIsFramebuffer = binary.ID{0x18, 0x61, 0x06, 0x59, 0x8f, 0x47, 0x18, 0x3d, 0xc9, 0x38, 0x46, 0x78, 0x2e, 0x71, 0x54, 0x29, 0x9b, 0x9f, 0xc6, 0x33} + binaryIDGlIsImageHandleResidentNV = binary.ID{0x53, 0xe4, 0x84, 0xe2, 0x4e, 0x7e, 0xbf, 0x3f, 0xae, 0xac, 0x62, 0x67, 0x00, 0xc5, 0xbc, 0x10, 0x9e, 0x04, 0x11, 0xf7} + binaryIDGlIsPathNV = binary.ID{0x11, 0x8e, 0xe3, 0x7e, 0xd5, 0x0a, 0x80, 0x9f, 0xb2, 0xb3, 0x72, 0xc6, 0xc6, 0x3a, 0x5c, 0x7d, 0xc5, 0x00, 0x48, 0xde} + binaryIDGlIsPointInFillPathNV = binary.ID{0x21, 0x3c, 0x21, 0xd4, 0xa6, 0xf1, 0xa7, 0xcf, 0xef, 0x46, 0x10, 0xe4, 0x3f, 0xa8, 0xc5, 0xf3, 0x5c, 0xe7, 0x9a, 0x46} + binaryIDGlIsPointInStrokePathNV = binary.ID{0xe2, 0x25, 0x1e, 0xa9, 0x3b, 0x3c, 0x88, 0x47, 0xde, 0x73, 0xb3, 0xd8, 0x3c, 0x22, 0x91, 0x58, 0xcd, 0xba, 0xca, 0x9a} + binaryIDGlIsProgram = binary.ID{0x3d, 0x4b, 0x04, 0xa2, 0x10, 0x91, 0x77, 0xc4, 0x5b, 0xf7, 0x7b, 0x52, 0x88, 0xb8, 0x23, 0xb4, 0x8b, 0x1d, 0x49, 0x8a} + binaryIDGlIsProgramPipeline = binary.ID{0x65, 0x87, 0x32, 0x9b, 0x5e, 0x93, 0x56, 0x50, 0xb5, 0x80, 0x11, 0xcf, 0xa9, 0xea, 0x41, 0x79, 0x91, 0x56, 0xea, 0xf5} + binaryIDGlIsProgramPipelineEXT = binary.ID{0x20, 0x45, 0x4b, 0x4e, 0xdc, 0x7d, 0x13, 0xe1, 0xe0, 0xd8, 0x3e, 0x59, 0x26, 0x75, 0x7b, 0x9e, 0x20, 0x11, 0x92, 0x53} + binaryIDGlIsQuery = binary.ID{0xeb, 0xf4, 0x49, 0xc3, 0xc4, 0x7f, 0xcf, 0x88, 0xd6, 0xba, 0xcd, 0xd3, 0x71, 0xf4, 0x54, 0x11, 0xc0, 0x5f, 0x39, 0x6c} + binaryIDGlIsQueryEXT = binary.ID{0xe4, 0x92, 0x78, 0x2c, 0x94, 0x95, 0xb9, 0x72, 0xd8, 0x48, 0xa9, 0x22, 0x2e, 0xbe, 0xc9, 0x93, 0x52, 0x14, 0x68, 0x80} + binaryIDGlIsRenderbuffer = binary.ID{0x34, 0x29, 0x3a, 0x38, 0xe1, 0xd5, 0x24, 0x3f, 0xfc, 0xc1, 0x68, 0xb5, 0x19, 0x3b, 0x96, 0xcc, 0x06, 0xd2, 0xa0, 0x78} + binaryIDGlIsSampler = binary.ID{0x5a, 0x71, 0x95, 0xd5, 0x3d, 0x8a, 0x37, 0x3f, 0xef, 0x3c, 0x68, 0x22, 0x10, 0x11, 0x15, 0x39, 0x66, 0xde, 0x16, 0xc9} + binaryIDGlIsShader = binary.ID{0xa7, 0x49, 0xe5, 0x16, 0x9b, 0xf3, 0x3e, 0x13, 0xba, 0x90, 0x7a, 0x71, 0x99, 0x9b, 0xd3, 0x77, 0x68, 0xa4, 0xb1, 0xe6} + binaryIDGlIsSync = binary.ID{0xa4, 0x39, 0x5f, 0xae, 0xa8, 0xe2, 0x66, 0x9d, 0x53, 0xcc, 0x8d, 0x93, 0xa3, 0x60, 0x08, 0x19, 0x9c, 0x2e, 0xe8, 0x78} + binaryIDGlIsSyncAPPLE = binary.ID{0x56, 0x15, 0x61, 0xaa, 0xec, 0x7f, 0x97, 0xe1, 0xad, 0x1e, 0x61, 0xea, 0x8e, 0x2b, 0xb1, 0xe5, 0x47, 0x39, 0x0c, 0x93} + binaryIDGlIsTexture = binary.ID{0x5b, 0xe3, 0xe7, 0xfa, 0xf3, 0x8f, 0xef, 0x75, 0xff, 0xf5, 0xab, 0xe8, 0xa5, 0xf6, 0xca, 0x21, 0xfa, 0xf9, 0x44, 0x38} + binaryIDGlIsTextureHandleResidentNV = binary.ID{0x4e, 0x07, 0x08, 0x21, 0x50, 0x6f, 0x16, 0xf4, 0x6c, 0x14, 0x7a, 0x47, 0xe7, 0x3b, 0xb3, 0x3c, 0x6b, 0xc4, 0xa3, 0xb2} + binaryIDGlIsTransformFeedback = binary.ID{0x32, 0x19, 0xd3, 0xf0, 0xb0, 0x03, 0x77, 0x57, 0x2f, 0x77, 0x27, 0x12, 0x4a, 0x61, 0x32, 0xd3, 0xbb, 0xd7, 0x70, 0xc9} + binaryIDGlIsVertexArray = binary.ID{0x05, 0x80, 0x6b, 0x17, 0xc1, 0x95, 0x55, 0x32, 0x24, 0xa9, 0xcb, 0x99, 0x7d, 0x49, 0xfc, 0x8b, 0xd2, 0xfa, 0xd3, 0x2d} + binaryIDGlIsVertexArrayOES = binary.ID{0xb7, 0x33, 0xcc, 0xf5, 0x7b, 0x60, 0x3f, 0x6e, 0xe4, 0xf6, 0xad, 0xaf, 0xd2, 0xd1, 0xad, 0xba, 0x86, 0x4c, 0x12, 0xa8} binaryIDGlLabelObjectEXT = binary.ID{0xb9, 0x3e, 0x8d, 0xf0, 0x23, 0xb2, 0x1b, 0x2c, 0x02, 0x10, 0x73, 0xec, 0x0b, 0x1d, 0x23, 0x7d, 0x87, 0x37, 0xe8, 0xd7} binaryIDGlLineWidth = binary.ID{0x93, 0x5b, 0xc3, 0x68, 0x79, 0x91, 0x57, 0xc2, 0x9c, 0x41, 0x25, 0x25, 0x06, 0x5a, 0x2c, 0xeb, 0xf5, 0x7a, 0x43, 0x85} binaryIDGlLinkProgram = binary.ID{0x17, 0xf0, 0x30, 0xba, 0x15, 0x5a, 0xf7, 0x20, 0x04, 0x04, 0xea, 0xd7, 0xc3, 0xba, 0x6a, 0x4c, 0x9e, 0x0d, 0x96, 0x41} @@ -1567,7 +1563,7 @@ var ( binaryIDGlResolveDepthValuesNV = binary.ID{0x1f, 0x25, 0xbe, 0xc8, 0xff, 0xbe, 0x1b, 0x80, 0xf7, 0xdb, 0x8a, 0x7f, 0x33, 0xf6, 0x96, 0x73, 0x19, 0xd8, 0xaf, 0xe6} binaryIDGlResolveMultisampleFramebufferAPPLE = binary.ID{0xfa, 0xaf, 0x24, 0x40, 0x87, 0xc2, 0xce, 0x82, 0x78, 0x08, 0x1c, 0xc8, 0xaa, 0x86, 0xc9, 0xad, 0x72, 0xbe, 0x58, 0xd7} binaryIDGlResumeTransformFeedback = binary.ID{0x78, 0x30, 0xbd, 0xa6, 0xf3, 0xcd, 0xd9, 0xb2, 0x78, 0x6d, 0x4e, 0x69, 0x2e, 0x69, 0xcf, 0xe5, 0x4f, 0x78, 0xd8, 0x21} - binaryIDGlSampleCoverage = binary.ID{0xd6, 0x38, 0xca, 0xe0, 0xdf, 0x70, 0x44, 0xf0, 0xc1, 0x90, 0xf6, 0xae, 0x37, 0x92, 0xa8, 0xc5, 0x6c, 0x14, 0x5c, 0x44} + binaryIDGlSampleCoverage = binary.ID{0x8f, 0x2d, 0x0f, 0x2a, 0x05, 0x41, 0x30, 0x62, 0xd9, 0x60, 0x92, 0x3b, 0x02, 0x58, 0xdf, 0x37, 0x82, 0xa1, 0xb7, 0xbd} binaryIDGlSampleMaski = binary.ID{0xf9, 0x62, 0x3a, 0x77, 0xe0, 0xab, 0x12, 0xac, 0xae, 0x9c, 0x9d, 0x2a, 0x7c, 0x46, 0x08, 0xca, 0xe1, 0x25, 0x23, 0x8f} binaryIDGlSamplerParameterIivEXT = binary.ID{0xb2, 0x2e, 0x2b, 0x5e, 0x97, 0xb8, 0x67, 0xcd, 0x21, 0x4c, 0xf9, 0xc6, 0x05, 0x27, 0x3a, 0xcc, 0x3e, 0x6e, 0x00, 0x0c} binaryIDGlSamplerParameterIivOES = binary.ID{0x35, 0xb2, 0x07, 0x23, 0xe3, 0xde, 0x9b, 0xad, 0xaf, 0x52, 0x20, 0x75, 0xe1, 0x09, 0x50, 0xbe, 0x60, 0x31, 0x10, 0xc8} @@ -1706,7 +1702,7 @@ var ( binaryIDGlVertexAttribI4uiv = binary.ID{0x9e, 0x75, 0x6b, 0x92, 0xb6, 0x5b, 0xb9, 0xb8, 0x7a, 0x3e, 0xc4, 0x90, 0x03, 0x7d, 0x31, 0xb2, 0x0a, 0x09, 0x17, 0xae} binaryIDGlVertexAttribIFormat = binary.ID{0x6f, 0x9a, 0xbc, 0xe0, 0x7f, 0x44, 0x96, 0xc3, 0xfa, 0xee, 0xc8, 0x98, 0xba, 0x8b, 0x44, 0xf3, 0x87, 0x97, 0x07, 0xb0} binaryIDGlVertexAttribIPointer = binary.ID{0x7f, 0x10, 0x3a, 0xc4, 0x1e, 0xab, 0x53, 0x48, 0x07, 0x47, 0x52, 0xe1, 0xf0, 0xa6, 0x7f, 0xcf, 0x11, 0xa1, 0xff, 0x2e} - binaryIDGlVertexAttribPointer = binary.ID{0x8d, 0xe5, 0x21, 0x0d, 0xc4, 0xcd, 0x43, 0x00, 0xef, 0x07, 0xe3, 0x29, 0x33, 0x8c, 0x33, 0xcf, 0xd3, 0x2d, 0xac, 0x96} + binaryIDGlVertexAttribPointer = binary.ID{0xa9, 0xf4, 0x7e, 0x3b, 0x7c, 0x9d, 0x74, 0x34, 0xf5, 0x0b, 0xad, 0xb3, 0xd8, 0x9b, 0x87, 0xf9, 0xef, 0xf5, 0x5f, 0x90} binaryIDGlVertexBindingDivisor = binary.ID{0x22, 0xb4, 0x64, 0x01, 0x30, 0xcc, 0x39, 0x6c, 0x72, 0x22, 0xc2, 0x5b, 0xc5, 0xfe, 0x55, 0xc8, 0xe4, 0x22, 0x62, 0x8f} binaryIDGlViewport = binary.ID{0x03, 0xfa, 0x0b, 0x41, 0x52, 0x97, 0x87, 0x00, 0x14, 0xd1, 0xf0, 0xff, 0x04, 0x25, 0x0d, 0x5c, 0x62, 0xc5, 0x50, 0xd8} binaryIDGlViewportArrayvNV = binary.ID{0x53, 0x50, 0xaf, 0x8d, 0x81, 0x9f, 0xd8, 0xf0, 0xcd, 0xea, 0xaa, 0x5d, 0x76, 0x9f, 0x19, 0x16, 0x7c, 0xea, 0xd0, 0x0c} @@ -2289,100 +2285,6 @@ var schemaSliceInfo = &schema.Class{ }, } -type binaryClassBoolˢ struct{} - -func (*Boolˢ) Class() binary.Class { - return (*binaryClassBoolˢ)(nil) -} -func doEncodeBoolˢ(e binary.Encoder, o *Boolˢ) error { - if err := e.Value(&o.SliceInfo); err != nil { - return err - } - return nil -} -func doDecodeBoolˢ(d binary.Decoder, o *Boolˢ) error { - if err := d.Value(&o.SliceInfo); err != nil { - return err - } - return nil -} -func doSkipBoolˢ(d binary.Decoder) error { - if err := d.SkipValue((*SliceInfo)(nil)); err != nil { - return err - } - return nil -} -func (*binaryClassBoolˢ) ID() binary.ID { return binaryIDBoolˢ } -func (*binaryClassBoolˢ) New() binary.Object { return &Boolˢ{} } -func (*binaryClassBoolˢ) Encode(e binary.Encoder, obj binary.Object) error { - return doEncodeBoolˢ(e, obj.(*Boolˢ)) -} -func (*binaryClassBoolˢ) Decode(d binary.Decoder) (binary.Object, error) { - obj := &Boolˢ{} - return obj, doDecodeBoolˢ(d, obj) -} -func (*binaryClassBoolˢ) DecodeTo(d binary.Decoder, obj binary.Object) error { - return doDecodeBoolˢ(d, obj.(*Boolˢ)) -} -func (*binaryClassBoolˢ) Skip(d binary.Decoder) error { return doSkipBoolˢ(d) } -func (*binaryClassBoolˢ) Schema() *schema.Class { return schemaBoolˢ } - -var schemaBoolˢ = &schema.Class{ - TypeID: binaryIDBoolˢ, - Package: "gles", - Name: "Boolˢ", - Fields: []schema.Field{ - {Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}}, - }, -} - -type binaryClassBoolᵖ struct{} - -func (*Boolᵖ) Class() binary.Class { - return (*binaryClassBoolᵖ)(nil) -} -func doEncodeBoolᵖ(e binary.Encoder, o *Boolᵖ) error { - if err := e.Value(&o.Pointer); err != nil { - return err - } - return nil -} -func doDecodeBoolᵖ(d binary.Decoder, o *Boolᵖ) error { - if err := d.Value(&o.Pointer); err != nil { - return err - } - return nil -} -func doSkipBoolᵖ(d binary.Decoder) error { - if err := d.SkipValue((*memory.Pointer)(nil)); err != nil { - return err - } - return nil -} -func (*binaryClassBoolᵖ) ID() binary.ID { return binaryIDBoolᵖ } -func (*binaryClassBoolᵖ) New() binary.Object { return &Boolᵖ{} } -func (*binaryClassBoolᵖ) Encode(e binary.Encoder, obj binary.Object) error { - return doEncodeBoolᵖ(e, obj.(*Boolᵖ)) -} -func (*binaryClassBoolᵖ) Decode(d binary.Decoder) (binary.Object, error) { - obj := &Boolᵖ{} - return obj, doDecodeBoolᵖ(d, obj) -} -func (*binaryClassBoolᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error { - return doDecodeBoolᵖ(d, obj.(*Boolᵖ)) -} -func (*binaryClassBoolᵖ) Skip(d binary.Decoder) error { return doSkipBoolᵖ(d) } -func (*binaryClassBoolᵖ) Schema() *schema.Class { return schemaBoolᵖ } - -var schemaBoolᵖ = &schema.Class{ - TypeID: binaryIDBoolᵖ, - Package: "gles", - Name: "Boolᵖ", - Fields: []schema.Field{ - {Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}}, - }, -} - type binaryClassU8ˢ struct{} func (*U8ˢ) Class() binary.Class { @@ -3976,7 +3878,7 @@ func (*RasterizerState) Class() binary.Class { return (*binaryClassRasterizerState)(nil) } func doEncodeRasterizerState(e binary.Encoder, o *RasterizerState) error { - if err := e.Bool(o.DepthMask); err != nil { + if err := e.Uint8(uint8(o.DepthMask)); err != nil { return err } if err := e.Uint32(uint32(o.DepthTestFunction)); err != nil { @@ -3988,16 +3890,16 @@ func doEncodeRasterizerState(e binary.Encoder, o *RasterizerState) error { if err := e.Float32(float32(o.DepthFar)); err != nil { return err } - if err := e.Bool(o.ColorMaskRed); err != nil { + if err := e.Uint8(uint8(o.ColorMaskRed)); err != nil { return err } - if err := e.Bool(o.ColorMaskGreen); err != nil { + if err := e.Uint8(uint8(o.ColorMaskGreen)); err != nil { return err } - if err := e.Bool(o.ColorMaskBlue); err != nil { + if err := e.Uint8(uint8(o.ColorMaskBlue)); err != nil { return err } - if err := e.Bool(o.ColorMaskAlpha); err != nil { + if err := e.Uint8(uint8(o.ColorMaskAlpha)); err != nil { return err } if err := e.Uint32(uint32(len(o.StencilMask))); err != nil { @@ -4035,16 +3937,16 @@ func doEncodeRasterizerState(e binary.Encoder, o *RasterizerState) error { if err := e.Float32(float32(o.SampleCoverageValue)); err != nil { return err } - if err := e.Bool(o.SampleCoverageInvert); err != nil { + if err := e.Uint8(uint8(o.SampleCoverageInvert)); err != nil { return err } return nil } func doDecodeRasterizerState(d binary.Decoder, o *RasterizerState) error { - if obj, err := d.Bool(); err != nil { + if obj, err := d.Uint8(); err != nil { return err } else { - o.DepthMask = bool(obj) + o.DepthMask = GLboolean(obj) } if obj, err := d.Uint32(); err != nil { return err @@ -4061,25 +3963,25 @@ func doDecodeRasterizerState(d binary.Decoder, o *RasterizerState) error { } else { o.DepthFar = GLfloat(obj) } - if obj, err := d.Bool(); err != nil { + if obj, err := d.Uint8(); err != nil { return err } else { - o.ColorMaskRed = bool(obj) + o.ColorMaskRed = GLboolean(obj) } - if obj, err := d.Bool(); err != nil { + if obj, err := d.Uint8(); err != nil { return err } else { - o.ColorMaskGreen = bool(obj) + o.ColorMaskGreen = GLboolean(obj) } - if obj, err := d.Bool(); err != nil { + if obj, err := d.Uint8(); err != nil { return err } else { - o.ColorMaskBlue = bool(obj) + o.ColorMaskBlue = GLboolean(obj) } - if obj, err := d.Bool(); err != nil { + if obj, err := d.Uint8(); err != nil { return err } else { - o.ColorMaskAlpha = bool(obj) + o.ColorMaskAlpha = GLboolean(obj) } if count, err := d.Uint32(); err != nil { return err @@ -4138,15 +4040,15 @@ func doDecodeRasterizerState(d binary.Decoder, o *RasterizerState) error { } else { o.SampleCoverageValue = GLfloat(obj) } - if obj, err := d.Bool(); err != nil { + if obj, err := d.Uint8(); err != nil { return err } else { - o.SampleCoverageInvert = bool(obj) + o.SampleCoverageInvert = GLboolean(obj) } return nil } func doSkipRasterizerState(d binary.Decoder) error { - if _, err := d.Bool(); err != nil { + if _, err := d.Uint8(); err != nil { return err } if _, err := d.Uint32(); err != nil { @@ -4158,16 +4060,16 @@ func doSkipRasterizerState(d binary.Decoder) error { if _, err := d.Float32(); err != nil { return err } - if _, err := d.Bool(); err != nil { + if _, err := d.Uint8(); err != nil { return err } - if _, err := d.Bool(); err != nil { + if _, err := d.Uint8(); err != nil { return err } - if _, err := d.Bool(); err != nil { + if _, err := d.Uint8(); err != nil { return err } - if _, err := d.Bool(); err != nil { + if _, err := d.Uint8(); err != nil { return err } if count, err := d.Uint32(); err != nil { @@ -4206,7 +4108,7 @@ func doSkipRasterizerState(d binary.Decoder) error { if _, err := d.Float32(); err != nil { return err } - if _, err := d.Bool(); err != nil { + if _, err := d.Uint8(); err != nil { return err } return nil @@ -4231,14 +4133,14 @@ var schemaRasterizerState = &schema.Class{ Package: "gles", Name: "RasterizerState", Fields: []schema.Field{ - {Declared: "DepthMask", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}}, + {Declared: "DepthMask", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}}, {Declared: "DepthTestFunction", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}}, {Declared: "DepthNear", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}}, {Declared: "DepthFar", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}}, - {Declared: "ColorMaskRed", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}}, - {Declared: "ColorMaskGreen", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}}, - {Declared: "ColorMaskBlue", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}}, - {Declared: "ColorMaskAlpha", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}}, + {Declared: "ColorMaskRed", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}}, + {Declared: "ColorMaskGreen", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}}, + {Declared: "ColorMaskBlue", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}}, + {Declared: "ColorMaskAlpha", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}}, {Declared: "StencilMask", Type: &schema.Map{Alias: "GLenumːGLuintᵐ", KeyType: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}, ValueType: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}}}, {Declared: "Viewport", Type: &schema.Struct{Name: "Rect", ID: (*Rect)(nil).Class().ID()}}, {Declared: "Scissor", Type: &schema.Struct{Name: "Rect", ID: (*Rect)(nil).Class().ID()}}, @@ -4248,7 +4150,7 @@ var schemaRasterizerState = &schema.Class{ {Declared: "PolygonOffsetFactor", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}}, {Declared: "PolygonOffsetUnits", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}}, {Declared: "SampleCoverageValue", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}}, - {Declared: "SampleCoverageInvert", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}}, + {Declared: "SampleCoverageInvert", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}}, }, } @@ -4314,7 +4216,7 @@ func doEncodeVertexAttributeArray(e binary.Encoder, o *VertexAttributeArray) err if err := e.Uint32(uint32(o.Type)); err != nil { return err } - if err := e.Bool(o.Normalized); err != nil { + if err := e.Uint8(uint8(o.Normalized)); err != nil { return err } if err := e.Int32(int32(o.Stride)); err != nil { @@ -4344,10 +4246,10 @@ func doDecodeVertexAttributeArray(d binary.Decoder, o *VertexAttributeArray) err } else { o.Type = GLenum(obj) } - if obj, err := d.Bool(); err != nil { + if obj, err := d.Uint8(); err != nil { return err } else { - o.Normalized = bool(obj) + o.Normalized = GLboolean(obj) } if obj, err := d.Int32(); err != nil { return err @@ -4374,7 +4276,7 @@ func doSkipVertexAttributeArray(d binary.Decoder) error { if _, err := d.Uint32(); err != nil { return err } - if _, err := d.Bool(); err != nil { + if _, err := d.Uint8(); err != nil { return err } if _, err := d.Int32(); err != nil { @@ -4413,7 +4315,7 @@ var schemaVertexAttributeArray = &schema.Class{ {Declared: "Enabled", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}}, {Declared: "Size", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}}, {Declared: "Type", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}}, - {Declared: "Normalized", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}}, + {Declared: "Normalized", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}}, {Declared: "Stride", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}}, {Declared: "Buffer", Type: &schema.Primitive{Name: "BufferId", Method: schema.Uint32}}, {Declared: "Pointer", Type: &schema.Struct{Name: "VertexPointer", ID: (*VertexPointer)(nil).Class().ID()}}, @@ -14641,16 +14543,16 @@ func doEncodeGlColorMask(e binary.Encoder, o *GlColorMask) error { if err := e.Value(&o.observations); err != nil { return err } - if err := e.Bool(o.Red); err != nil { + if err := e.Uint8(uint8(o.Red)); err != nil { return err } - if err := e.Bool(o.Green); err != nil { + if err := e.Uint8(uint8(o.Green)); err != nil { return err } - if err := e.Bool(o.Blue); err != nil { + if err := e.Uint8(uint8(o.Blue)); err != nil { return err } - if err := e.Bool(o.Alpha); err != nil { + if err := e.Uint8(uint8(o.Alpha)); err != nil { return err } return nil @@ -14659,25 +14561,25 @@ func doDecodeGlColorMask(d binary.Decoder, o *GlColorMask) error { if err := d.Value(&o.observations); err != nil { return err } - if obj, err := d.Bool(); err != nil { + if obj, err := d.Uint8(); err != nil { return err } else { - o.Red = bool(obj) + o.Red = GLboolean(obj) } - if obj, err := d.Bool(); err != nil { + if obj, err := d.Uint8(); err != nil { return err } else { - o.Green = bool(obj) + o.Green = GLboolean(obj) } - if obj, err := d.Bool(); err != nil { + if obj, err := d.Uint8(); err != nil { return err } else { - o.Blue = bool(obj) + o.Blue = GLboolean(obj) } - if obj, err := d.Bool(); err != nil { + if obj, err := d.Uint8(); err != nil { return err } else { - o.Alpha = bool(obj) + o.Alpha = GLboolean(obj) } return nil } @@ -14685,16 +14587,16 @@ func doSkipGlColorMask(d binary.Decoder) error { if err := d.SkipValue((*atom.Observations)(nil)); err != nil { return err } - if _, err := d.Bool(); err != nil { + if _, err := d.Uint8(); err != nil { return err } - if _, err := d.Bool(); err != nil { + if _, err := d.Uint8(); err != nil { return err } - if _, err := d.Bool(); err != nil { + if _, err := d.Uint8(); err != nil { return err } - if _, err := d.Bool(); err != nil { + if _, err := d.Uint8(); err != nil { return err } return nil @@ -14720,10 +14622,10 @@ var schemaGlColorMask = &schema.Class{ Name: "GlColorMask", Fields: []schema.Field{ {Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}}, - {Declared: "Red", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}}, - {Declared: "Green", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}}, - {Declared: "Blue", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}}, - {Declared: "Alpha", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}}, + {Declared: "Red", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}}, + {Declared: "Green", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}}, + {Declared: "Blue", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}}, + {Declared: "Alpha", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}}, }, } @@ -20683,7 +20585,7 @@ func doEncodeGlDepthMask(e binary.Encoder, o *GlDepthMask) error { if err := e.Value(&o.observations); err != nil { return err } - if err := e.Bool(o.Enabled); err != nil { + if err := e.Uint8(uint8(o.Enabled)); err != nil { return err } return nil @@ -20692,10 +20594,10 @@ func doDecodeGlDepthMask(d binary.Decoder, o *GlDepthMask) error { if err := d.Value(&o.observations); err != nil { return err } - if obj, err := d.Bool(); err != nil { + if obj, err := d.Uint8(); err != nil { return err } else { - o.Enabled = bool(obj) + o.Enabled = GLboolean(obj) } return nil } @@ -20703,7 +20605,7 @@ func doSkipGlDepthMask(d binary.Decoder) error { if err := d.SkipValue((*atom.Observations)(nil)); err != nil { return err } - if _, err := d.Bool(); err != nil { + if _, err := d.Uint8(); err != nil { return err } return nil @@ -20729,7 +20631,7 @@ var schemaGlDepthMask = &schema.Class{ Name: "GlDepthMask", Fields: []schema.Field{ {Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}}, - {Declared: "Enabled", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}}, + {Declared: "Enabled", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}}, }, } @@ -30778,7 +30680,7 @@ func doSkipGlGetBooleanv(d binary.Decoder) error { if _, err := d.Uint32(); err != nil { return err } - if err := d.SkipValue((*Boolᵖ)(nil)); err != nil { + if err := d.SkipValue((*GLbooleanᵖ)(nil)); err != nil { return err } return nil @@ -30805,7 +30707,7 @@ var schemaGlGetBooleanv = &schema.Class{ Fields: []schema.Field{ {Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}}, {Declared: "Param", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}}, - {Declared: "Values", Type: &schema.Struct{Name: "Boolᵖ", ID: (*Boolᵖ)(nil).Class().ID()}}, + {Declared: "Values", Type: &schema.Struct{Name: "GLbooleanᵖ", ID: (*GLbooleanᵖ)(nil).Class().ID()}}, }, } @@ -42152,7 +42054,7 @@ func doEncodeGlIsBuffer(e binary.Encoder, o *GlIsBuffer) error { if err := e.Uint32(uint32(o.Buffer)); err != nil { return err } - if err := e.Bool(o.Result); err != nil { + if err := e.Uint8(uint8(o.Result)); err != nil { return err } return nil @@ -42166,10 +42068,10 @@ func doDecodeGlIsBuffer(d binary.Decoder, o *GlIsBuffer) error { } else { o.Buffer = BufferId(obj) } - if obj, err := d.Bool(); err != nil { + if obj, err := d.Uint8(); err != nil { return err } else { - o.Result = bool(obj) + o.Result = GLboolean(obj) } return nil } @@ -42180,7 +42082,7 @@ func doSkipGlIsBuffer(d binary.Decoder) error { if _, err := d.Uint32(); err != nil { return err } - if _, err := d.Bool(); err != nil { + if _, err := d.Uint8(); err != nil { return err } return nil @@ -42207,7 +42109,7 @@ var schemaGlIsBuffer = &schema.Class{ Fields: []schema.Field{ {Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}}, {Declared: "Buffer", Type: &schema.Primitive{Name: "BufferId", Method: schema.Uint32}}, - {Declared: "Result", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}}, + {Declared: "Result", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}}, }, } @@ -42223,7 +42125,7 @@ func doEncodeGlIsEnabled(e binary.Encoder, o *GlIsEnabled) error { if err := e.Uint32(uint32(o.Capability)); err != nil { return err } - if err := e.Bool(o.Result); err != nil { + if err := e.Uint8(uint8(o.Result)); err != nil { return err } return nil @@ -42237,10 +42139,10 @@ func doDecodeGlIsEnabled(d binary.Decoder, o *GlIsEnabled) error { } else { o.Capability = GLenum(obj) } - if obj, err := d.Bool(); err != nil { + if obj, err := d.Uint8(); err != nil { return err } else { - o.Result = bool(obj) + o.Result = GLboolean(obj) } return nil } @@ -42251,7 +42153,7 @@ func doSkipGlIsEnabled(d binary.Decoder) error { if _, err := d.Uint32(); err != nil { return err } - if _, err := d.Bool(); err != nil { + if _, err := d.Uint8(); err != nil { return err } return nil @@ -42278,7 +42180,7 @@ var schemaGlIsEnabled = &schema.Class{ Fields: []schema.Field{ {Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}}, {Declared: "Capability", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}}, - {Declared: "Result", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}}, + {Declared: "Result", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}}, }, } @@ -42297,7 +42199,7 @@ func doEncodeGlIsEnablediEXT(e binary.Encoder, o *GlIsEnablediEXT) error { if err := e.Uint32(uint32(o.Index)); err != nil { return err } - if err := e.Bool(o.Result); err != nil { + if err := e.Uint8(uint8(o.Result)); err != nil { return err } return nil @@ -42316,10 +42218,10 @@ func doDecodeGlIsEnablediEXT(d binary.Decoder, o *GlIsEnablediEXT) error { } else { o.Index = GLuint(obj) } - if obj, err := d.Bool(); err != nil { + if obj, err := d.Uint8(); err != nil { return err } else { - o.Result = bool(obj) + o.Result = GLboolean(obj) } return nil } @@ -42333,7 +42235,7 @@ func doSkipGlIsEnablediEXT(d binary.Decoder) error { if _, err := d.Uint32(); err != nil { return err } - if _, err := d.Bool(); err != nil { + if _, err := d.Uint8(); err != nil { return err } return nil @@ -42361,7 +42263,7 @@ var schemaGlIsEnablediEXT = &schema.Class{ {Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}}, {Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}}, {Declared: "Index", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}}, - {Declared: "Result", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}}, + {Declared: "Result", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}}, }, } @@ -42380,7 +42282,7 @@ func doEncodeGlIsEnablediNV(e binary.Encoder, o *GlIsEnablediNV) error { if err := e.Uint32(uint32(o.Index)); err != nil { return err } - if err := e.Bool(o.Result); err != nil { + if err := e.Uint8(uint8(o.Result)); err != nil { return err } return nil @@ -42399,10 +42301,10 @@ func doDecodeGlIsEnablediNV(d binary.Decoder, o *GlIsEnablediNV) error { } else { o.Index = GLuint(obj) } - if obj, err := d.Bool(); err != nil { + if obj, err := d.Uint8(); err != nil { return err } else { - o.Result = bool(obj) + o.Result = GLboolean(obj) } return nil } @@ -42416,7 +42318,7 @@ func doSkipGlIsEnablediNV(d binary.Decoder) error { if _, err := d.Uint32(); err != nil { return err } - if _, err := d.Bool(); err != nil { + if _, err := d.Uint8(); err != nil { return err } return nil @@ -42444,7 +42346,7 @@ var schemaGlIsEnablediNV = &schema.Class{ {Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}}, {Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}}, {Declared: "Index", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}}, - {Declared: "Result", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}}, + {Declared: "Result", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}}, }, } @@ -42463,7 +42365,7 @@ func doEncodeGlIsEnablediOES(e binary.Encoder, o *GlIsEnablediOES) error { if err := e.Uint32(uint32(o.Index)); err != nil { return err } - if err := e.Bool(o.Result); err != nil { + if err := e.Uint8(uint8(o.Result)); err != nil { return err } return nil @@ -42482,10 +42384,10 @@ func doDecodeGlIsEnablediOES(d binary.Decoder, o *GlIsEnablediOES) error { } else { o.Index = GLuint(obj) } - if obj, err := d.Bool(); err != nil { + if obj, err := d.Uint8(); err != nil { return err } else { - o.Result = bool(obj) + o.Result = GLboolean(obj) } return nil } @@ -42499,7 +42401,7 @@ func doSkipGlIsEnablediOES(d binary.Decoder) error { if _, err := d.Uint32(); err != nil { return err } - if _, err := d.Bool(); err != nil { + if _, err := d.Uint8(); err != nil { return err } return nil @@ -42527,7 +42429,7 @@ var schemaGlIsEnablediOES = &schema.Class{ {Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}}, {Declared: "Target", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}}, {Declared: "Index", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}}, - {Declared: "Result", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}}, + {Declared: "Result", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}}, }, } @@ -42543,7 +42445,7 @@ func doEncodeGlIsFenceNV(e binary.Encoder, o *GlIsFenceNV) error { if err := e.Uint32(uint32(o.Fence)); err != nil { return err } - if err := e.Bool(o.Result); err != nil { + if err := e.Uint8(uint8(o.Result)); err != nil { return err } return nil @@ -42557,10 +42459,10 @@ func doDecodeGlIsFenceNV(d binary.Decoder, o *GlIsFenceNV) error { } else { o.Fence = GLuint(obj) } - if obj, err := d.Bool(); err != nil { + if obj, err := d.Uint8(); err != nil { return err } else { - o.Result = bool(obj) + o.Result = GLboolean(obj) } return nil } @@ -42571,7 +42473,7 @@ func doSkipGlIsFenceNV(d binary.Decoder) error { if _, err := d.Uint32(); err != nil { return err } - if _, err := d.Bool(); err != nil { + if _, err := d.Uint8(); err != nil { return err } return nil @@ -42598,7 +42500,7 @@ var schemaGlIsFenceNV = &schema.Class{ Fields: []schema.Field{ {Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}}, {Declared: "Fence", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}}, - {Declared: "Result", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}}, + {Declared: "Result", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}}, }, } @@ -42614,7 +42516,7 @@ func doEncodeGlIsFramebuffer(e binary.Encoder, o *GlIsFramebuffer) error { if err := e.Uint32(uint32(o.Framebuffer)); err != nil { return err } - if err := e.Bool(o.Result); err != nil { + if err := e.Uint8(uint8(o.Result)); err != nil { return err } return nil @@ -42628,10 +42530,10 @@ func doDecodeGlIsFramebuffer(d binary.Decoder, o *GlIsFramebuffer) error { } else { o.Framebuffer = FramebufferId(obj) } - if obj, err := d.Bool(); err != nil { + if obj, err := d.Uint8(); err != nil { return err } else { - o.Result = bool(obj) + o.Result = GLboolean(obj) } return nil } @@ -42642,7 +42544,7 @@ func doSkipGlIsFramebuffer(d binary.Decoder) error { if _, err := d.Uint32(); err != nil { return err } - if _, err := d.Bool(); err != nil { + if _, err := d.Uint8(); err != nil { return err } return nil @@ -42669,7 +42571,7 @@ var schemaGlIsFramebuffer = &schema.Class{ Fields: []schema.Field{ {Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}}, {Declared: "Framebuffer", Type: &schema.Primitive{Name: "FramebufferId", Method: schema.Uint32}}, - {Declared: "Result", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}}, + {Declared: "Result", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}}, }, } @@ -42685,7 +42587,7 @@ func doEncodeGlIsImageHandleResidentNV(e binary.Encoder, o *GlIsImageHandleResid if err := e.Uint64(uint64(o.Handle)); err != nil { return err } - if err := e.Bool(o.Result); err != nil { + if err := e.Uint8(uint8(o.Result)); err != nil { return err } return nil @@ -42699,10 +42601,10 @@ func doDecodeGlIsImageHandleResidentNV(d binary.Decoder, o *GlIsImageHandleResid } else { o.Handle = GLuint64(obj) } - if obj, err := d.Bool(); err != nil { + if obj, err := d.Uint8(); err != nil { return err } else { - o.Result = bool(obj) + o.Result = GLboolean(obj) } return nil } @@ -42713,7 +42615,7 @@ func doSkipGlIsImageHandleResidentNV(d binary.Decoder) error { if _, err := d.Uint64(); err != nil { return err } - if _, err := d.Bool(); err != nil { + if _, err := d.Uint8(); err != nil { return err } return nil @@ -42744,7 +42646,7 @@ var schemaGlIsImageHandleResidentNV = &schema.Class{ Fields: []schema.Field{ {Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}}, {Declared: "Handle", Type: &schema.Primitive{Name: "GLuint64", Method: schema.Uint64}}, - {Declared: "Result", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}}, + {Declared: "Result", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}}, }, } @@ -42760,7 +42662,7 @@ func doEncodeGlIsPathNV(e binary.Encoder, o *GlIsPathNV) error { if err := e.Uint32(uint32(o.Path)); err != nil { return err } - if err := e.Bool(o.Result); err != nil { + if err := e.Uint8(uint8(o.Result)); err != nil { return err } return nil @@ -42774,10 +42676,10 @@ func doDecodeGlIsPathNV(d binary.Decoder, o *GlIsPathNV) error { } else { o.Path = GLuint(obj) } - if obj, err := d.Bool(); err != nil { + if obj, err := d.Uint8(); err != nil { return err } else { - o.Result = bool(obj) + o.Result = GLboolean(obj) } return nil } @@ -42788,7 +42690,7 @@ func doSkipGlIsPathNV(d binary.Decoder) error { if _, err := d.Uint32(); err != nil { return err } - if _, err := d.Bool(); err != nil { + if _, err := d.Uint8(); err != nil { return err } return nil @@ -42815,7 +42717,7 @@ var schemaGlIsPathNV = &schema.Class{ Fields: []schema.Field{ {Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}}, {Declared: "Path", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}}, - {Declared: "Result", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}}, + {Declared: "Result", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}}, }, } @@ -42840,7 +42742,7 @@ func doEncodeGlIsPointInFillPathNV(e binary.Encoder, o *GlIsPointInFillPathNV) e if err := e.Float32(float32(o.Y)); err != nil { return err } - if err := e.Bool(o.Result); err != nil { + if err := e.Uint8(uint8(o.Result)); err != nil { return err } return nil @@ -42869,10 +42771,10 @@ func doDecodeGlIsPointInFillPathNV(d binary.Decoder, o *GlIsPointInFillPathNV) e } else { o.Y = GLfloat(obj) } - if obj, err := d.Bool(); err != nil { + if obj, err := d.Uint8(); err != nil { return err } else { - o.Result = bool(obj) + o.Result = GLboolean(obj) } return nil } @@ -42892,7 +42794,7 @@ func doSkipGlIsPointInFillPathNV(d binary.Decoder) error { if _, err := d.Float32(); err != nil { return err } - if _, err := d.Bool(); err != nil { + if _, err := d.Uint8(); err != nil { return err } return nil @@ -42924,7 +42826,7 @@ var schemaGlIsPointInFillPathNV = &schema.Class{ {Declared: "Mask", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}}, {Declared: "X", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}}, {Declared: "Y", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}}, - {Declared: "Result", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}}, + {Declared: "Result", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}}, }, } @@ -42946,7 +42848,7 @@ func doEncodeGlIsPointInStrokePathNV(e binary.Encoder, o *GlIsPointInStrokePathN if err := e.Float32(float32(o.Y)); err != nil { return err } - if err := e.Bool(o.Result); err != nil { + if err := e.Uint8(uint8(o.Result)); err != nil { return err } return nil @@ -42970,10 +42872,10 @@ func doDecodeGlIsPointInStrokePathNV(d binary.Decoder, o *GlIsPointInStrokePathN } else { o.Y = GLfloat(obj) } - if obj, err := d.Bool(); err != nil { + if obj, err := d.Uint8(); err != nil { return err } else { - o.Result = bool(obj) + o.Result = GLboolean(obj) } return nil } @@ -42990,7 +42892,7 @@ func doSkipGlIsPointInStrokePathNV(d binary.Decoder) error { if _, err := d.Float32(); err != nil { return err } - if _, err := d.Bool(); err != nil { + if _, err := d.Uint8(); err != nil { return err } return nil @@ -43023,7 +42925,7 @@ var schemaGlIsPointInStrokePathNV = &schema.Class{ {Declared: "Path", Type: &schema.Primitive{Name: "GLuint", Method: schema.Uint32}}, {Declared: "X", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}}, {Declared: "Y", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}}, - {Declared: "Result", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}}, + {Declared: "Result", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}}, }, } @@ -43039,7 +42941,7 @@ func doEncodeGlIsProgram(e binary.Encoder, o *GlIsProgram) error { if err := e.Uint32(uint32(o.Program)); err != nil { return err } - if err := e.Bool(o.Result); err != nil { + if err := e.Uint8(uint8(o.Result)); err != nil { return err } return nil @@ -43053,10 +42955,10 @@ func doDecodeGlIsProgram(d binary.Decoder, o *GlIsProgram) error { } else { o.Program = ProgramId(obj) } - if obj, err := d.Bool(); err != nil { + if obj, err := d.Uint8(); err != nil { return err } else { - o.Result = bool(obj) + o.Result = GLboolean(obj) } return nil } @@ -43067,7 +42969,7 @@ func doSkipGlIsProgram(d binary.Decoder) error { if _, err := d.Uint32(); err != nil { return err } - if _, err := d.Bool(); err != nil { + if _, err := d.Uint8(); err != nil { return err } return nil @@ -43094,7 +42996,7 @@ var schemaGlIsProgram = &schema.Class{ Fields: []schema.Field{ {Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}}, {Declared: "Program", Type: &schema.Primitive{Name: "ProgramId", Method: schema.Uint32}}, - {Declared: "Result", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}}, + {Declared: "Result", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}}, }, } @@ -43110,7 +43012,7 @@ func doEncodeGlIsProgramPipeline(e binary.Encoder, o *GlIsProgramPipeline) error if err := e.Uint32(uint32(o.Pipeline)); err != nil { return err } - if err := e.Bool(o.Result); err != nil { + if err := e.Uint8(uint8(o.Result)); err != nil { return err } return nil @@ -43124,10 +43026,10 @@ func doDecodeGlIsProgramPipeline(d binary.Decoder, o *GlIsProgramPipeline) error } else { o.Pipeline = PipelineId(obj) } - if obj, err := d.Bool(); err != nil { + if obj, err := d.Uint8(); err != nil { return err } else { - o.Result = bool(obj) + o.Result = GLboolean(obj) } return nil } @@ -43138,7 +43040,7 @@ func doSkipGlIsProgramPipeline(d binary.Decoder) error { if _, err := d.Uint32(); err != nil { return err } - if _, err := d.Bool(); err != nil { + if _, err := d.Uint8(); err != nil { return err } return nil @@ -43167,7 +43069,7 @@ var schemaGlIsProgramPipeline = &schema.Class{ Fields: []schema.Field{ {Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}}, {Declared: "Pipeline", Type: &schema.Primitive{Name: "PipelineId", Method: schema.Uint32}}, - {Declared: "Result", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}}, + {Declared: "Result", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}}, }, } @@ -43183,7 +43085,7 @@ func doEncodeGlIsProgramPipelineEXT(e binary.Encoder, o *GlIsProgramPipelineEXT) if err := e.Uint32(uint32(o.Pipeline)); err != nil { return err } - if err := e.Bool(o.Result); err != nil { + if err := e.Uint8(uint8(o.Result)); err != nil { return err } return nil @@ -43197,10 +43099,10 @@ func doDecodeGlIsProgramPipelineEXT(d binary.Decoder, o *GlIsProgramPipelineEXT) } else { o.Pipeline = PipelineId(obj) } - if obj, err := d.Bool(); err != nil { + if obj, err := d.Uint8(); err != nil { return err } else { - o.Result = bool(obj) + o.Result = GLboolean(obj) } return nil } @@ -43211,7 +43113,7 @@ func doSkipGlIsProgramPipelineEXT(d binary.Decoder) error { if _, err := d.Uint32(); err != nil { return err } - if _, err := d.Bool(); err != nil { + if _, err := d.Uint8(); err != nil { return err } return nil @@ -43240,7 +43142,7 @@ var schemaGlIsProgramPipelineEXT = &schema.Class{ Fields: []schema.Field{ {Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}}, {Declared: "Pipeline", Type: &schema.Primitive{Name: "PipelineId", Method: schema.Uint32}}, - {Declared: "Result", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}}, + {Declared: "Result", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}}, }, } @@ -43256,7 +43158,7 @@ func doEncodeGlIsQuery(e binary.Encoder, o *GlIsQuery) error { if err := e.Uint32(uint32(o.Query)); err != nil { return err } - if err := e.Bool(o.Result); err != nil { + if err := e.Uint8(uint8(o.Result)); err != nil { return err } return nil @@ -43270,10 +43172,10 @@ func doDecodeGlIsQuery(d binary.Decoder, o *GlIsQuery) error { } else { o.Query = QueryId(obj) } - if obj, err := d.Bool(); err != nil { + if obj, err := d.Uint8(); err != nil { return err } else { - o.Result = bool(obj) + o.Result = GLboolean(obj) } return nil } @@ -43284,7 +43186,7 @@ func doSkipGlIsQuery(d binary.Decoder) error { if _, err := d.Uint32(); err != nil { return err } - if _, err := d.Bool(); err != nil { + if _, err := d.Uint8(); err != nil { return err } return nil @@ -43311,7 +43213,7 @@ var schemaGlIsQuery = &schema.Class{ Fields: []schema.Field{ {Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}}, {Declared: "Query", Type: &schema.Primitive{Name: "QueryId", Method: schema.Uint32}}, - {Declared: "Result", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}}, + {Declared: "Result", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}}, }, } @@ -43327,7 +43229,7 @@ func doEncodeGlIsQueryEXT(e binary.Encoder, o *GlIsQueryEXT) error { if err := e.Uint32(uint32(o.Query)); err != nil { return err } - if err := e.Bool(o.Result); err != nil { + if err := e.Uint8(uint8(o.Result)); err != nil { return err } return nil @@ -43341,10 +43243,10 @@ func doDecodeGlIsQueryEXT(d binary.Decoder, o *GlIsQueryEXT) error { } else { o.Query = QueryId(obj) } - if obj, err := d.Bool(); err != nil { + if obj, err := d.Uint8(); err != nil { return err } else { - o.Result = bool(obj) + o.Result = GLboolean(obj) } return nil } @@ -43355,7 +43257,7 @@ func doSkipGlIsQueryEXT(d binary.Decoder) error { if _, err := d.Uint32(); err != nil { return err } - if _, err := d.Bool(); err != nil { + if _, err := d.Uint8(); err != nil { return err } return nil @@ -43382,7 +43284,7 @@ var schemaGlIsQueryEXT = &schema.Class{ Fields: []schema.Field{ {Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}}, {Declared: "Query", Type: &schema.Primitive{Name: "QueryId", Method: schema.Uint32}}, - {Declared: "Result", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}}, + {Declared: "Result", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}}, }, } @@ -43398,7 +43300,7 @@ func doEncodeGlIsRenderbuffer(e binary.Encoder, o *GlIsRenderbuffer) error { if err := e.Uint32(uint32(o.Renderbuffer)); err != nil { return err } - if err := e.Bool(o.Result); err != nil { + if err := e.Uint8(uint8(o.Result)); err != nil { return err } return nil @@ -43412,10 +43314,10 @@ func doDecodeGlIsRenderbuffer(d binary.Decoder, o *GlIsRenderbuffer) error { } else { o.Renderbuffer = RenderbufferId(obj) } - if obj, err := d.Bool(); err != nil { + if obj, err := d.Uint8(); err != nil { return err } else { - o.Result = bool(obj) + o.Result = GLboolean(obj) } return nil } @@ -43426,7 +43328,7 @@ func doSkipGlIsRenderbuffer(d binary.Decoder) error { if _, err := d.Uint32(); err != nil { return err } - if _, err := d.Bool(); err != nil { + if _, err := d.Uint8(); err != nil { return err } return nil @@ -43453,7 +43355,7 @@ var schemaGlIsRenderbuffer = &schema.Class{ Fields: []schema.Field{ {Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}}, {Declared: "Renderbuffer", Type: &schema.Primitive{Name: "RenderbufferId", Method: schema.Uint32}}, - {Declared: "Result", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}}, + {Declared: "Result", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}}, }, } @@ -43469,7 +43371,7 @@ func doEncodeGlIsSampler(e binary.Encoder, o *GlIsSampler) error { if err := e.Uint32(uint32(o.Sampler)); err != nil { return err } - if err := e.Bool(o.Result); err != nil { + if err := e.Uint8(uint8(o.Result)); err != nil { return err } return nil @@ -43483,10 +43385,10 @@ func doDecodeGlIsSampler(d binary.Decoder, o *GlIsSampler) error { } else { o.Sampler = SamplerId(obj) } - if obj, err := d.Bool(); err != nil { + if obj, err := d.Uint8(); err != nil { return err } else { - o.Result = bool(obj) + o.Result = GLboolean(obj) } return nil } @@ -43497,7 +43399,7 @@ func doSkipGlIsSampler(d binary.Decoder) error { if _, err := d.Uint32(); err != nil { return err } - if _, err := d.Bool(); err != nil { + if _, err := d.Uint8(); err != nil { return err } return nil @@ -43524,7 +43426,7 @@ var schemaGlIsSampler = &schema.Class{ Fields: []schema.Field{ {Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}}, {Declared: "Sampler", Type: &schema.Primitive{Name: "SamplerId", Method: schema.Uint32}}, - {Declared: "Result", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}}, + {Declared: "Result", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}}, }, } @@ -43540,7 +43442,7 @@ func doEncodeGlIsShader(e binary.Encoder, o *GlIsShader) error { if err := e.Uint32(uint32(o.Shader)); err != nil { return err } - if err := e.Bool(o.Result); err != nil { + if err := e.Uint8(uint8(o.Result)); err != nil { return err } return nil @@ -43554,10 +43456,10 @@ func doDecodeGlIsShader(d binary.Decoder, o *GlIsShader) error { } else { o.Shader = ShaderId(obj) } - if obj, err := d.Bool(); err != nil { + if obj, err := d.Uint8(); err != nil { return err } else { - o.Result = bool(obj) + o.Result = GLboolean(obj) } return nil } @@ -43568,7 +43470,7 @@ func doSkipGlIsShader(d binary.Decoder) error { if _, err := d.Uint32(); err != nil { return err } - if _, err := d.Bool(); err != nil { + if _, err := d.Uint8(); err != nil { return err } return nil @@ -43595,7 +43497,7 @@ var schemaGlIsShader = &schema.Class{ Fields: []schema.Field{ {Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}}, {Declared: "Shader", Type: &schema.Primitive{Name: "ShaderId", Method: schema.Uint32}}, - {Declared: "Result", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}}, + {Declared: "Result", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}}, }, } @@ -43611,7 +43513,7 @@ func doEncodeGlIsSync(e binary.Encoder, o *GlIsSync) error { if err := e.Uint64(uint64(o.Sync)); err != nil { return err } - if err := e.Bool(o.Result); err != nil { + if err := e.Uint8(uint8(o.Result)); err != nil { return err } return nil @@ -43625,10 +43527,10 @@ func doDecodeGlIsSync(d binary.Decoder, o *GlIsSync) error { } else { o.Sync = GLsync(obj) } - if obj, err := d.Bool(); err != nil { + if obj, err := d.Uint8(); err != nil { return err } else { - o.Result = bool(obj) + o.Result = GLboolean(obj) } return nil } @@ -43639,7 +43541,7 @@ func doSkipGlIsSync(d binary.Decoder) error { if _, err := d.Uint64(); err != nil { return err } - if _, err := d.Bool(); err != nil { + if _, err := d.Uint8(); err != nil { return err } return nil @@ -43666,7 +43568,7 @@ var schemaGlIsSync = &schema.Class{ Fields: []schema.Field{ {Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}}, {Declared: "Sync", Type: &schema.Primitive{Name: "GLsync", Method: schema.Uint64}}, - {Declared: "Result", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}}, + {Declared: "Result", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}}, }, } @@ -43682,7 +43584,7 @@ func doEncodeGlIsSyncAPPLE(e binary.Encoder, o *GlIsSyncAPPLE) error { if err := e.Uint64(uint64(o.Sync)); err != nil { return err } - if err := e.Bool(o.Result); err != nil { + if err := e.Uint8(uint8(o.Result)); err != nil { return err } return nil @@ -43696,10 +43598,10 @@ func doDecodeGlIsSyncAPPLE(d binary.Decoder, o *GlIsSyncAPPLE) error { } else { o.Sync = GLsync(obj) } - if obj, err := d.Bool(); err != nil { + if obj, err := d.Uint8(); err != nil { return err } else { - o.Result = bool(obj) + o.Result = GLboolean(obj) } return nil } @@ -43710,7 +43612,7 @@ func doSkipGlIsSyncAPPLE(d binary.Decoder) error { if _, err := d.Uint64(); err != nil { return err } - if _, err := d.Bool(); err != nil { + if _, err := d.Uint8(); err != nil { return err } return nil @@ -43737,7 +43639,7 @@ var schemaGlIsSyncAPPLE = &schema.Class{ Fields: []schema.Field{ {Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}}, {Declared: "Sync", Type: &schema.Primitive{Name: "GLsync", Method: schema.Uint64}}, - {Declared: "Result", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}}, + {Declared: "Result", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}}, }, } @@ -43753,7 +43655,7 @@ func doEncodeGlIsTexture(e binary.Encoder, o *GlIsTexture) error { if err := e.Uint32(uint32(o.Texture)); err != nil { return err } - if err := e.Bool(o.Result); err != nil { + if err := e.Uint8(uint8(o.Result)); err != nil { return err } return nil @@ -43767,10 +43669,10 @@ func doDecodeGlIsTexture(d binary.Decoder, o *GlIsTexture) error { } else { o.Texture = TextureId(obj) } - if obj, err := d.Bool(); err != nil { + if obj, err := d.Uint8(); err != nil { return err } else { - o.Result = bool(obj) + o.Result = GLboolean(obj) } return nil } @@ -43781,7 +43683,7 @@ func doSkipGlIsTexture(d binary.Decoder) error { if _, err := d.Uint32(); err != nil { return err } - if _, err := d.Bool(); err != nil { + if _, err := d.Uint8(); err != nil { return err } return nil @@ -43808,7 +43710,7 @@ var schemaGlIsTexture = &schema.Class{ Fields: []schema.Field{ {Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}}, {Declared: "Texture", Type: &schema.Primitive{Name: "TextureId", Method: schema.Uint32}}, - {Declared: "Result", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}}, + {Declared: "Result", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}}, }, } @@ -43824,7 +43726,7 @@ func doEncodeGlIsTextureHandleResidentNV(e binary.Encoder, o *GlIsTextureHandleR if err := e.Uint64(uint64(o.Handle)); err != nil { return err } - if err := e.Bool(o.Result); err != nil { + if err := e.Uint8(uint8(o.Result)); err != nil { return err } return nil @@ -43838,10 +43740,10 @@ func doDecodeGlIsTextureHandleResidentNV(d binary.Decoder, o *GlIsTextureHandleR } else { o.Handle = GLuint64(obj) } - if obj, err := d.Bool(); err != nil { + if obj, err := d.Uint8(); err != nil { return err } else { - o.Result = bool(obj) + o.Result = GLboolean(obj) } return nil } @@ -43852,7 +43754,7 @@ func doSkipGlIsTextureHandleResidentNV(d binary.Decoder) error { if _, err := d.Uint64(); err != nil { return err } - if _, err := d.Bool(); err != nil { + if _, err := d.Uint8(); err != nil { return err } return nil @@ -43887,7 +43789,7 @@ var schemaGlIsTextureHandleResidentNV = &schema.Class{ Fields: []schema.Field{ {Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}}, {Declared: "Handle", Type: &schema.Primitive{Name: "GLuint64", Method: schema.Uint64}}, - {Declared: "Result", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}}, + {Declared: "Result", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}}, }, } @@ -43903,7 +43805,7 @@ func doEncodeGlIsTransformFeedback(e binary.Encoder, o *GlIsTransformFeedback) e if err := e.Uint32(uint32(o.Id)); err != nil { return err } - if err := e.Bool(o.Result); err != nil { + if err := e.Uint8(uint8(o.Result)); err != nil { return err } return nil @@ -43917,10 +43819,10 @@ func doDecodeGlIsTransformFeedback(d binary.Decoder, o *GlIsTransformFeedback) e } else { o.Id = TransformFeedbackId(obj) } - if obj, err := d.Bool(); err != nil { + if obj, err := d.Uint8(); err != nil { return err } else { - o.Result = bool(obj) + o.Result = GLboolean(obj) } return nil } @@ -43931,7 +43833,7 @@ func doSkipGlIsTransformFeedback(d binary.Decoder) error { if _, err := d.Uint32(); err != nil { return err } - if _, err := d.Bool(); err != nil { + if _, err := d.Uint8(); err != nil { return err } return nil @@ -43960,7 +43862,7 @@ var schemaGlIsTransformFeedback = &schema.Class{ Fields: []schema.Field{ {Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}}, {Declared: "Id", Type: &schema.Primitive{Name: "TransformFeedbackId", Method: schema.Uint32}}, - {Declared: "Result", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}}, + {Declared: "Result", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}}, }, } @@ -43976,7 +43878,7 @@ func doEncodeGlIsVertexArray(e binary.Encoder, o *GlIsVertexArray) error { if err := e.Uint32(uint32(o.Array)); err != nil { return err } - if err := e.Bool(o.Result); err != nil { + if err := e.Uint8(uint8(o.Result)); err != nil { return err } return nil @@ -43990,10 +43892,10 @@ func doDecodeGlIsVertexArray(d binary.Decoder, o *GlIsVertexArray) error { } else { o.Array = VertexArrayId(obj) } - if obj, err := d.Bool(); err != nil { + if obj, err := d.Uint8(); err != nil { return err } else { - o.Result = bool(obj) + o.Result = GLboolean(obj) } return nil } @@ -44004,7 +43906,7 @@ func doSkipGlIsVertexArray(d binary.Decoder) error { if _, err := d.Uint32(); err != nil { return err } - if _, err := d.Bool(); err != nil { + if _, err := d.Uint8(); err != nil { return err } return nil @@ -44031,7 +43933,7 @@ var schemaGlIsVertexArray = &schema.Class{ Fields: []schema.Field{ {Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}}, {Declared: "Array", Type: &schema.Primitive{Name: "VertexArrayId", Method: schema.Uint32}}, - {Declared: "Result", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}}, + {Declared: "Result", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}}, }, } @@ -44047,7 +43949,7 @@ func doEncodeGlIsVertexArrayOES(e binary.Encoder, o *GlIsVertexArrayOES) error { if err := e.Uint32(uint32(o.Array)); err != nil { return err } - if err := e.Bool(o.Result); err != nil { + if err := e.Uint8(uint8(o.Result)); err != nil { return err } return nil @@ -44061,10 +43963,10 @@ func doDecodeGlIsVertexArrayOES(d binary.Decoder, o *GlIsVertexArrayOES) error { } else { o.Array = VertexArrayId(obj) } - if obj, err := d.Bool(); err != nil { + if obj, err := d.Uint8(); err != nil { return err } else { - o.Result = bool(obj) + o.Result = GLboolean(obj) } return nil } @@ -44075,7 +43977,7 @@ func doSkipGlIsVertexArrayOES(d binary.Decoder) error { if _, err := d.Uint32(); err != nil { return err } - if _, err := d.Bool(); err != nil { + if _, err := d.Uint8(); err != nil { return err } return nil @@ -44102,7 +44004,7 @@ var schemaGlIsVertexArrayOES = &schema.Class{ Fields: []schema.Field{ {Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}}, {Declared: "Array", Type: &schema.Primitive{Name: "VertexArrayId", Method: schema.Uint32}}, - {Declared: "Result", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}}, + {Declared: "Result", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}}, }, } @@ -58732,7 +58634,7 @@ func doEncodeGlSampleCoverage(e binary.Encoder, o *GlSampleCoverage) error { if err := e.Float32(float32(o.Value)); err != nil { return err } - if err := e.Bool(o.Invert); err != nil { + if err := e.Uint8(uint8(o.Invert)); err != nil { return err } return nil @@ -58746,10 +58648,10 @@ func doDecodeGlSampleCoverage(d binary.Decoder, o *GlSampleCoverage) error { } else { o.Value = GLfloat(obj) } - if obj, err := d.Bool(); err != nil { + if obj, err := d.Uint8(); err != nil { return err } else { - o.Invert = bool(obj) + o.Invert = GLboolean(obj) } return nil } @@ -58760,7 +58662,7 @@ func doSkipGlSampleCoverage(d binary.Decoder) error { if _, err := d.Float32(); err != nil { return err } - if _, err := d.Bool(); err != nil { + if _, err := d.Uint8(); err != nil { return err } return nil @@ -58787,7 +58689,7 @@ var schemaGlSampleCoverage = &schema.Class{ Fields: []schema.Field{ {Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}}, {Declared: "Value", Type: &schema.Primitive{Name: "GLfloat", Method: schema.Float32}}, - {Declared: "Invert", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}}, + {Declared: "Invert", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}}, }, } @@ -71843,7 +71745,7 @@ func doEncodeGlVertexAttribPointer(e binary.Encoder, o *GlVertexAttribPointer) e if err := e.Uint32(uint32(o.Type)); err != nil { return err } - if err := e.Bool(o.Normalized); err != nil { + if err := e.Uint8(uint8(o.Normalized)); err != nil { return err } if err := e.Int32(int32(o.Stride)); err != nil { @@ -71873,10 +71775,10 @@ func doDecodeGlVertexAttribPointer(d binary.Decoder, o *GlVertexAttribPointer) e } else { o.Type = GLenum(obj) } - if obj, err := d.Bool(); err != nil { + if obj, err := d.Uint8(); err != nil { return err } else { - o.Normalized = bool(obj) + o.Normalized = GLboolean(obj) } if obj, err := d.Int32(); err != nil { return err @@ -71901,7 +71803,7 @@ func doSkipGlVertexAttribPointer(d binary.Decoder) error { if _, err := d.Uint32(); err != nil { return err } - if _, err := d.Bool(); err != nil { + if _, err := d.Uint8(); err != nil { return err } if _, err := d.Int32(); err != nil { @@ -71938,7 +71840,7 @@ var schemaGlVertexAttribPointer = &schema.Class{ {Declared: "Location", Type: &schema.Primitive{Name: "AttributeLocation", Method: schema.Uint32}}, {Declared: "Size", Type: &schema.Primitive{Name: "GLint", Method: schema.Int32}}, {Declared: "Type", Type: &schema.Primitive{Name: "GLenum", Method: schema.Uint32}}, - {Declared: "Normalized", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}}, + {Declared: "Normalized", Type: &schema.Primitive{Name: "GLboolean", Method: schema.Uint8}}, {Declared: "Stride", Type: &schema.Primitive{Name: "GLsizei", Method: schema.Int32}}, {Declared: "Data", Type: &schema.Struct{Name: "VertexPointer", ID: (*VertexPointer)(nil).Class().ID()}}, }, diff --git a/gfxapi/gles/read_framebuffer.go b/gfxapi/gles/read_framebuffer.go index 686094e40..d135e07a8 100644 --- a/gfxapi/gles/read_framebuffer.go +++ b/gfxapi/gles/read_framebuffer.go @@ -168,7 +168,7 @@ func readFramebufferDepth(out chan replay.Image) atom.Atom { NewGlUniform1i(uTextureLocation, GLint(origActiveTextureUnit)), NewGlBindBuffer(GLenum_GL_ARRAY_BUFFER, 0), NewGlBindBuffer(GLenum_GL_ELEMENT_ARRAY_BUFFER, 0), - NewGlVertexAttribPointer(aScreenCoordsLocation, 2, GLenum_GL_FLOAT, false, 0, memory.Tmp), + NewGlVertexAttribPointer(aScreenCoordsLocation, 2, GLenum_GL_FLOAT, GLboolean(0), 0, memory.Tmp), NewGlDrawArrays(GLenum_GL_TRIANGLE_STRIP, 0, 4). AddRead(atom.Data(arch, d, l, memory.Tmp, positions)), ) diff --git a/gfxapi/gles/replay_writer.go b/gfxapi/gles/replay_writer.go index d33b9ccf1..2b00e774c 100644 --- a/gfxapi/gles/replay_writer.go +++ b/gfxapi/gles/replay_writer.go @@ -52,7 +52,7 @@ var funcInfoGlGetSamplerParameterIivEXT = builder.FunctionInfo{ID: 17, ReturnTyp var funcInfoGlGetSamplerParameterIuivEXT = builder.FunctionInfo{ID: 18, ReturnType: protocol.TypeVoid, Parameters: 3} var funcInfoGlGetTexParameterIivEXT = builder.FunctionInfo{ID: 19, ReturnType: protocol.TypeVoid, Parameters: 3} var funcInfoGlGetTexParameterIuivEXT = builder.FunctionInfo{ID: 20, ReturnType: protocol.TypeVoid, Parameters: 3} -var funcInfoGlIsEnablediEXT = builder.FunctionInfo{ID: 21, ReturnType: protocol.TypeBool, Parameters: 2} +var funcInfoGlIsEnablediEXT = builder.FunctionInfo{ID: 21, ReturnType: protocol.TypeUint8, Parameters: 2} var funcInfoGlMinSampleShadingOES = builder.FunctionInfo{ID: 22, ReturnType: protocol.TypeVoid, Parameters: 1} var funcInfoGlObjectLabelKHR = builder.FunctionInfo{ID: 23, ReturnType: protocol.TypeVoid, Parameters: 4} var funcInfoGlObjectPtrLabelKHR = builder.FunctionInfo{ID: 24, ReturnType: protocol.TypeVoid, Parameters: 3} @@ -73,7 +73,7 @@ var funcInfoGlEndQuery = builder.FunctionInfo{ID: 38, ReturnType: protocol.TypeV var funcInfoGlGenQueries = builder.FunctionInfo{ID: 39, ReturnType: protocol.TypeVoid, Parameters: 2} var funcInfoGlGetQueryObjectuiv = builder.FunctionInfo{ID: 40, ReturnType: protocol.TypeVoid, Parameters: 3} var funcInfoGlGetQueryiv = builder.FunctionInfo{ID: 41, ReturnType: protocol.TypeVoid, Parameters: 3} -var funcInfoGlIsQuery = builder.FunctionInfo{ID: 42, ReturnType: protocol.TypeBool, Parameters: 1} +var funcInfoGlIsQuery = builder.FunctionInfo{ID: 42, ReturnType: protocol.TypeUint8, Parameters: 1} var funcInfoGlBindBuffer = builder.FunctionInfo{ID: 43, ReturnType: protocol.TypeVoid, Parameters: 2} var funcInfoGlBindBufferBase = builder.FunctionInfo{ID: 44, ReturnType: protocol.TypeVoid, Parameters: 3} var funcInfoGlBindBufferRange = builder.FunctionInfo{ID: 45, ReturnType: protocol.TypeVoid, Parameters: 5} @@ -85,7 +85,7 @@ var funcInfoGlGenBuffers = builder.FunctionInfo{ID: 50, ReturnType: protocol.Typ var funcInfoGlGetBufferParameteri64v = builder.FunctionInfo{ID: 51, ReturnType: protocol.TypeVoid, Parameters: 3} var funcInfoGlGetBufferParameteriv = builder.FunctionInfo{ID: 52, ReturnType: protocol.TypeVoid, Parameters: 3} var funcInfoGlGetBufferPointerv = builder.FunctionInfo{ID: 53, ReturnType: protocol.TypeVoid, Parameters: 3} -var funcInfoGlIsBuffer = builder.FunctionInfo{ID: 54, ReturnType: protocol.TypeBool, Parameters: 1} +var funcInfoGlIsBuffer = builder.FunctionInfo{ID: 54, ReturnType: protocol.TypeUint8, Parameters: 1} var funcInfoGlMapBufferRange = builder.FunctionInfo{ID: 55, ReturnType: protocol.TypeVolatilePointer, Parameters: 4} var funcInfoGlUnmapBuffer = builder.FunctionInfo{ID: 56, ReturnType: protocol.TypeUint8, Parameters: 1} var funcInfoGlDrawArrays = builder.FunctionInfo{ID: 57, ReturnType: protocol.TypeVoid, Parameters: 3} @@ -255,18 +255,18 @@ var funcInfoGlGetnUniformivKHR = builder.FunctionInfo{ID: 220, ReturnType: proto var funcInfoGlGetnUniformuivKHR = builder.FunctionInfo{ID: 221, ReturnType: protocol.TypeVoid, Parameters: 4} var funcInfoGlInsertEventMarkerEXT = builder.FunctionInfo{ID: 222, ReturnType: protocol.TypeVoid, Parameters: 2} var funcInfoGlInterpolatePathsNV = builder.FunctionInfo{ID: 223, ReturnType: protocol.TypeVoid, Parameters: 4} -var funcInfoGlIsEnablediOES = builder.FunctionInfo{ID: 224, ReturnType: protocol.TypeBool, Parameters: 2} -var funcInfoGlIsEnablediNV = builder.FunctionInfo{ID: 225, ReturnType: protocol.TypeBool, Parameters: 2} -var funcInfoGlIsFenceNV = builder.FunctionInfo{ID: 226, ReturnType: protocol.TypeBool, Parameters: 1} -var funcInfoGlIsImageHandleResidentNV = builder.FunctionInfo{ID: 227, ReturnType: protocol.TypeBool, Parameters: 1} -var funcInfoGlIsPathNV = builder.FunctionInfo{ID: 228, ReturnType: protocol.TypeBool, Parameters: 1} -var funcInfoGlIsPointInFillPathNV = builder.FunctionInfo{ID: 229, ReturnType: protocol.TypeBool, Parameters: 4} -var funcInfoGlIsPointInStrokePathNV = builder.FunctionInfo{ID: 230, ReturnType: protocol.TypeBool, Parameters: 3} -var funcInfoGlIsProgramPipelineEXT = builder.FunctionInfo{ID: 231, ReturnType: protocol.TypeBool, Parameters: 1} -var funcInfoGlIsQueryEXT = builder.FunctionInfo{ID: 232, ReturnType: protocol.TypeBool, Parameters: 1} -var funcInfoGlIsSyncAPPLE = builder.FunctionInfo{ID: 233, ReturnType: protocol.TypeBool, Parameters: 1} -var funcInfoGlIsTextureHandleResidentNV = builder.FunctionInfo{ID: 234, ReturnType: protocol.TypeBool, Parameters: 1} -var funcInfoGlIsVertexArrayOES = builder.FunctionInfo{ID: 235, ReturnType: protocol.TypeBool, Parameters: 1} +var funcInfoGlIsEnablediOES = builder.FunctionInfo{ID: 224, ReturnType: protocol.TypeUint8, Parameters: 2} +var funcInfoGlIsEnablediNV = builder.FunctionInfo{ID: 225, ReturnType: protocol.TypeUint8, Parameters: 2} +var funcInfoGlIsFenceNV = builder.FunctionInfo{ID: 226, ReturnType: protocol.TypeUint8, Parameters: 1} +var funcInfoGlIsImageHandleResidentNV = builder.FunctionInfo{ID: 227, ReturnType: protocol.TypeUint8, Parameters: 1} +var funcInfoGlIsPathNV = builder.FunctionInfo{ID: 228, ReturnType: protocol.TypeUint8, Parameters: 1} +var funcInfoGlIsPointInFillPathNV = builder.FunctionInfo{ID: 229, ReturnType: protocol.TypeUint8, Parameters: 4} +var funcInfoGlIsPointInStrokePathNV = builder.FunctionInfo{ID: 230, ReturnType: protocol.TypeUint8, Parameters: 3} +var funcInfoGlIsProgramPipelineEXT = builder.FunctionInfo{ID: 231, ReturnType: protocol.TypeUint8, Parameters: 1} +var funcInfoGlIsQueryEXT = builder.FunctionInfo{ID: 232, ReturnType: protocol.TypeUint8, Parameters: 1} +var funcInfoGlIsSyncAPPLE = builder.FunctionInfo{ID: 233, ReturnType: protocol.TypeUint8, Parameters: 1} +var funcInfoGlIsTextureHandleResidentNV = builder.FunctionInfo{ID: 234, ReturnType: protocol.TypeUint8, Parameters: 1} +var funcInfoGlIsVertexArrayOES = builder.FunctionInfo{ID: 235, ReturnType: protocol.TypeUint8, Parameters: 1} var funcInfoGlLabelObjectEXT = builder.FunctionInfo{ID: 236, ReturnType: protocol.TypeVoid, Parameters: 4} var funcInfoGlMakeImageHandleNonResidentNV = builder.FunctionInfo{ID: 237, ReturnType: protocol.TypeVoid, Parameters: 1} var funcInfoGlMakeImageHandleResidentNV = builder.FunctionInfo{ID: 238, ReturnType: protocol.TypeVoid, Parameters: 2} @@ -460,8 +460,8 @@ var funcInfoGlGetFramebufferParameteriv = builder.FunctionInfo{ID: 425, ReturnTy var funcInfoGlGetRenderbufferParameteriv = builder.FunctionInfo{ID: 426, ReturnType: protocol.TypeVoid, Parameters: 3} var funcInfoGlInvalidateFramebuffer = builder.FunctionInfo{ID: 427, ReturnType: protocol.TypeVoid, Parameters: 3} var funcInfoGlInvalidateSubFramebuffer = builder.FunctionInfo{ID: 428, ReturnType: protocol.TypeVoid, Parameters: 7} -var funcInfoGlIsFramebuffer = builder.FunctionInfo{ID: 429, ReturnType: protocol.TypeBool, Parameters: 1} -var funcInfoGlIsRenderbuffer = builder.FunctionInfo{ID: 430, ReturnType: protocol.TypeBool, Parameters: 1} +var funcInfoGlIsFramebuffer = builder.FunctionInfo{ID: 429, ReturnType: protocol.TypeUint8, Parameters: 1} +var funcInfoGlIsRenderbuffer = builder.FunctionInfo{ID: 430, ReturnType: protocol.TypeUint8, Parameters: 1} var funcInfoGlReadBuffer = builder.FunctionInfo{ID: 431, ReturnType: protocol.TypeVoid, Parameters: 1} var funcInfoGlReadPixels = builder.FunctionInfo{ID: 432, ReturnType: protocol.TypeVoid, Parameters: 7} var funcInfoGlRenderbufferStorage = builder.FunctionInfo{ID: 433, ReturnType: protocol.TypeVoid, Parameters: 4} @@ -518,9 +518,9 @@ var funcInfoGlGetUniformLocation = builder.FunctionInfo{ID: 483, ReturnType: pro var funcInfoGlGetUniformfv = builder.FunctionInfo{ID: 484, ReturnType: protocol.TypeVoid, Parameters: 3} var funcInfoGlGetUniformiv = builder.FunctionInfo{ID: 485, ReturnType: protocol.TypeVoid, Parameters: 3} var funcInfoGlGetUniformuiv = builder.FunctionInfo{ID: 486, ReturnType: protocol.TypeVoid, Parameters: 3} -var funcInfoGlIsProgram = builder.FunctionInfo{ID: 487, ReturnType: protocol.TypeBool, Parameters: 1} -var funcInfoGlIsProgramPipeline = builder.FunctionInfo{ID: 488, ReturnType: protocol.TypeBool, Parameters: 1} -var funcInfoGlIsShader = builder.FunctionInfo{ID: 489, ReturnType: protocol.TypeBool, Parameters: 1} +var funcInfoGlIsProgram = builder.FunctionInfo{ID: 487, ReturnType: protocol.TypeUint8, Parameters: 1} +var funcInfoGlIsProgramPipeline = builder.FunctionInfo{ID: 488, ReturnType: protocol.TypeUint8, Parameters: 1} +var funcInfoGlIsShader = builder.FunctionInfo{ID: 489, ReturnType: protocol.TypeUint8, Parameters: 1} var funcInfoGlLinkProgram = builder.FunctionInfo{ID: 490, ReturnType: protocol.TypeVoid, Parameters: 1} var funcInfoGlMemoryBarrier = builder.FunctionInfo{ID: 491, ReturnType: protocol.TypeVoid, Parameters: 1} var funcInfoGlMemoryBarrierByRegion = builder.FunctionInfo{ID: 492, ReturnType: protocol.TypeVoid, Parameters: 1} @@ -617,12 +617,12 @@ var funcInfoGlGetIntegerv = builder.FunctionInfo{ID: 582, ReturnType: protocol.T var funcInfoGlGetInternalformativ = builder.FunctionInfo{ID: 583, ReturnType: protocol.TypeVoid, Parameters: 5} var funcInfoGlGetString = builder.FunctionInfo{ID: 584, ReturnType: protocol.TypeVolatilePointer, Parameters: 1} var funcInfoGlGetStringi = builder.FunctionInfo{ID: 585, ReturnType: protocol.TypeVolatilePointer, Parameters: 2} -var funcInfoGlIsEnabled = builder.FunctionInfo{ID: 586, ReturnType: protocol.TypeBool, Parameters: 1} +var funcInfoGlIsEnabled = builder.FunctionInfo{ID: 586, ReturnType: protocol.TypeUint8, Parameters: 1} var funcInfoGlClientWaitSync = builder.FunctionInfo{ID: 587, ReturnType: protocol.TypeUint32, Parameters: 3} var funcInfoGlDeleteSync = builder.FunctionInfo{ID: 588, ReturnType: protocol.TypeVoid, Parameters: 1} var funcInfoGlFenceSync = builder.FunctionInfo{ID: 589, ReturnType: protocol.TypeUint64, Parameters: 2} var funcInfoGlGetSynciv = builder.FunctionInfo{ID: 590, ReturnType: protocol.TypeVoid, Parameters: 5} -var funcInfoGlIsSync = builder.FunctionInfo{ID: 591, ReturnType: protocol.TypeBool, Parameters: 1} +var funcInfoGlIsSync = builder.FunctionInfo{ID: 591, ReturnType: protocol.TypeUint8, Parameters: 1} var funcInfoGlWaitSync = builder.FunctionInfo{ID: 592, ReturnType: protocol.TypeVoid, Parameters: 3} var funcInfoGlActiveTexture = builder.FunctionInfo{ID: 593, ReturnType: protocol.TypeVoid, Parameters: 1} var funcInfoGlBindImageTexture = builder.FunctionInfo{ID: 594, ReturnType: protocol.TypeVoid, Parameters: 7} @@ -646,8 +646,8 @@ var funcInfoGlGetTexLevelParameterfv = builder.FunctionInfo{ID: 611, ReturnType: var funcInfoGlGetTexLevelParameteriv = builder.FunctionInfo{ID: 612, ReturnType: protocol.TypeVoid, Parameters: 4} var funcInfoGlGetTexParameterfv = builder.FunctionInfo{ID: 613, ReturnType: protocol.TypeVoid, Parameters: 3} var funcInfoGlGetTexParameteriv = builder.FunctionInfo{ID: 614, ReturnType: protocol.TypeVoid, Parameters: 3} -var funcInfoGlIsSampler = builder.FunctionInfo{ID: 615, ReturnType: protocol.TypeBool, Parameters: 1} -var funcInfoGlIsTexture = builder.FunctionInfo{ID: 616, ReturnType: protocol.TypeBool, Parameters: 1} +var funcInfoGlIsSampler = builder.FunctionInfo{ID: 615, ReturnType: protocol.TypeUint8, Parameters: 1} +var funcInfoGlIsTexture = builder.FunctionInfo{ID: 616, ReturnType: protocol.TypeUint8, Parameters: 1} var funcInfoGlPixelStorei = builder.FunctionInfo{ID: 617, ReturnType: protocol.TypeVoid, Parameters: 2} var funcInfoGlSamplerParameterf = builder.FunctionInfo{ID: 618, ReturnType: protocol.TypeVoid, Parameters: 3} var funcInfoGlSamplerParameterfv = builder.FunctionInfo{ID: 619, ReturnType: protocol.TypeVoid, Parameters: 3} @@ -670,7 +670,7 @@ var funcInfoGlDeleteTransformFeedbacks = builder.FunctionInfo{ID: 635, ReturnTyp var funcInfoGlEndTransformFeedback = builder.FunctionInfo{ID: 636, ReturnType: protocol.TypeVoid, Parameters: 0} var funcInfoGlGenTransformFeedbacks = builder.FunctionInfo{ID: 637, ReturnType: protocol.TypeVoid, Parameters: 2} var funcInfoGlGetTransformFeedbackVarying = builder.FunctionInfo{ID: 638, ReturnType: protocol.TypeVoid, Parameters: 7} -var funcInfoGlIsTransformFeedback = builder.FunctionInfo{ID: 639, ReturnType: protocol.TypeBool, Parameters: 1} +var funcInfoGlIsTransformFeedback = builder.FunctionInfo{ID: 639, ReturnType: protocol.TypeUint8, Parameters: 1} var funcInfoGlPauseTransformFeedback = builder.FunctionInfo{ID: 640, ReturnType: protocol.TypeVoid, Parameters: 0} var funcInfoGlResumeTransformFeedback = builder.FunctionInfo{ID: 641, ReturnType: protocol.TypeVoid, Parameters: 0} var funcInfoGlTransformFeedbackVaryings = builder.FunctionInfo{ID: 642, ReturnType: protocol.TypeVoid, Parameters: 4} @@ -685,7 +685,7 @@ var funcInfoGlGetVertexAttribIuiv = builder.FunctionInfo{ID: 650, ReturnType: pr var funcInfoGlGetVertexAttribPointerv = builder.FunctionInfo{ID: 651, ReturnType: protocol.TypeVoid, Parameters: 3} var funcInfoGlGetVertexAttribfv = builder.FunctionInfo{ID: 652, ReturnType: protocol.TypeVoid, Parameters: 3} var funcInfoGlGetVertexAttribiv = builder.FunctionInfo{ID: 653, ReturnType: protocol.TypeVoid, Parameters: 3} -var funcInfoGlIsVertexArray = builder.FunctionInfo{ID: 654, ReturnType: protocol.TypeBool, Parameters: 1} +var funcInfoGlIsVertexArray = builder.FunctionInfo{ID: 654, ReturnType: protocol.TypeUint8, Parameters: 1} var funcInfoGlVertexAttrib1f = builder.FunctionInfo{ID: 655, ReturnType: protocol.TypeVoid, Parameters: 2} var funcInfoGlVertexAttrib1fv = builder.FunctionInfo{ID: 656, ReturnType: protocol.TypeVoid, Parameters: 2} var funcInfoGlVertexAttrib2f = builder.FunctionInfo{ID: 657, ReturnType: protocol.TypeVoid, Parameters: 3} @@ -8464,7 +8464,7 @@ func (ϟa *GlSampleCoverage) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database ctx.Rasterizing.SampleCoverageValue = ϟa.Value ctx.Rasterizing.SampleCoverageInvert = ϟa.Invert ϟb.Push(ϟa.Value.value(ϟb, ϟa, ϟs)) - ϟb.Push(value.Bool(ϟa.Invert)) + ϟb.Push(ϟa.Invert.value(ϟb, ϟa, ϟs)) ϟb.Call(funcInfoGlSampleCoverage) ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool]) _, _, _, _, _ = minRequiredVersion_499_major, minRequiredVersion_499_minor, context, GetContext_500_result, ctx @@ -8975,10 +8975,10 @@ func (ϟa *GlColorMask) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Data ctx.Rasterizing.ColorMaskGreen = ϟa.Green ctx.Rasterizing.ColorMaskBlue = ϟa.Blue ctx.Rasterizing.ColorMaskAlpha = ϟa.Alpha - ϟb.Push(value.Bool(ϟa.Red)) - ϟb.Push(value.Bool(ϟa.Green)) - ϟb.Push(value.Bool(ϟa.Blue)) - ϟb.Push(value.Bool(ϟa.Alpha)) + ϟb.Push(ϟa.Red.value(ϟb, ϟa, ϟs)) + ϟb.Push(ϟa.Green.value(ϟb, ϟa, ϟs)) + ϟb.Push(ϟa.Blue.value(ϟb, ϟa, ϟs)) + ϟb.Push(ϟa.Alpha.value(ϟb, ϟa, ϟs)) ϟb.Call(funcInfoGlColorMask) ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool]) _, _, _, _, _ = minRequiredVersion_547_major, minRequiredVersion_547_minor, context, GetContext_548_result, ctx @@ -9040,7 +9040,7 @@ func (ϟa *GlDepthMask) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Data GetContext_554_result := context // Contextʳ ctx := GetContext_554_result // Contextʳ ctx.Rasterizing.DepthMask = ϟa.Enabled - ϟb.Push(value.Bool(ϟa.Enabled)) + ϟb.Push(ϟa.Enabled.value(ϟb, ϟa, ϟs)) ϟb.Call(funcInfoGlDepthMask) ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool]) _, _, _, _, _ = minRequiredVersion_553_major, minRequiredVersion_553_minor, context, GetContext_554_result, ctx @@ -13439,7 +13439,7 @@ func (ϟa *GlGetBooleanv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Da v := ϟa.Param return fmt.Errorf("Missing switch case handler for value %T %v", v, v) } - v := ϟa.Values.Slice(uint64(int32(0)), uint64(externs{ϟa, ϟs, ϟd, ϟl, ϟb}.stateVariableSize(ϟa.Param)), ϟs) // Boolˢ + v := ϟa.Values.Slice(uint64(int32(0)), uint64(externs{ϟa, ϟs, ϟd, ϟl, ϟb}.stateVariableSize(ϟa.Param)), ϟs) // GLbooleanˢ context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ GetContext_855_result := context // Contextʳ ctx := GetContext_855_result // Contextʳ @@ -13449,23 +13449,77 @@ func (ϟa *GlGetBooleanv) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd database.Da ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool]) switch ϟa.Param { case GLenum_GL_BLEND: - v.Index(uint64(0), ϟs).Write(ctx.Capabilities.Get(GLenum_GL_BLEND), ϟa, ϟs, ϟd, ϟl, ϟb) + v.Index(uint64(0), ϟs).Write(func() GLboolean { + if ctx.Capabilities.Get(GLenum_GL_BLEND) { + return 1 + } else { + return 0 + } + }(), ϟa, ϟs, ϟd, ϟl, ϟb) case GLenum_GL_CULL_FACE: - v.Index(uint64(0), ϟs).Write(ctx.Capabilities.Get(GLenum_GL_CULL_FACE), ϟa, ϟs, ϟd, ϟl, ϟb) + v.Index(uint64(0), ϟs).Write(func() GLboolean { + if ctx.Capabilities.Get(GLenum_GL_CULL_FACE) { + return 1 + } else { + return 0 + } + }(), ϟa, ϟs, ϟd, ϟl, ϟb) case GLenum_GL_DEPTH_TEST: - v.Index(uint64(0), ϟs).Write(ctx.Capabilities.Get(GLenum_GL_DEPTH_TEST), ϟa, ϟs, ϟd, ϟl, ϟb) + v.Index(uint64(0), ϟs).Write(func() GLboolean { + if ctx.Capabilities.Get(GLenum_GL_DEPTH_TEST) { + return 1 + } else { + return 0 + } + }(), ϟa, ϟs, ϟd, ϟl, ϟb) case GLenum_GL_DITHER: - v.Index(uint64(0), ϟs).Write(ctx.Capabilities.Get(GLenum_GL_DITHER), ϟa, ϟs, ϟd, ϟl, ϟb) + v.Index(uint64(0), ϟs).Write(func() GLboolean { + if ctx.Capabilities.Get(GLenum_GL_DITHER) { + return 1 + } else { + return 0 + } + }(), ϟa, ϟs, ϟd, ϟl, ϟb) case GLenum_GL_POLYGON_OFFSET_FILL: - v.Index(uint64(0), ϟs).Write(ctx.Capabilities.Get(GLenum_GL_POLYGON_OFFSET_FILL), ϟa, ϟs, ϟd, ϟl, ϟb) + v.Index(uint64(0), ϟs).Write(func() GLboolean { + if ctx.Capabilities.Get(GLenum_GL_POLYGON_OFFSET_FILL) { + return 1 + } else { + return 0 + } + }(), ϟa, ϟs, ϟd, ϟl, ϟb) case GLenum_GL_SAMPLE_ALPHA_TO_COVERAGE: - v.Index(uint64(0), ϟs).Write(ctx.Capabilities.Get(GLenum_GL_SAMPLE_ALPHA_TO_COVERAGE), ϟa, ϟs, ϟd, ϟl, ϟb) + v.Index(uint64(0), ϟs).Write(func() GLboolean { + if ctx.Capabilities.Get(GLenum_GL_SAMPLE_ALPHA_TO_COVERAGE) { + return 1 + } else { + return 0 + } + }(), ϟa, ϟs, ϟd, ϟl, ϟb) case GLenum_GL_SAMPLE_COVERAGE: - v.Index(uint64(0), ϟs).Write(ctx.Capabilities.Get(GLenum_GL_SAMPLE_COVERAGE), ϟa, ϟs, ϟd, ϟl, ϟb) + v.Index(uint64(0), ϟs).Write(func() GLboolean { + if ctx.Capabilities.Get(GLenum_GL_SAMPLE_COVERAGE) { + return 1 + } else { + return 0 + } + }(), ϟa, ϟs, ϟd, ϟl, ϟb) case GLenum_GL_SCISSOR_TEST: - v.Index(uint64(0), ϟs).Write(ctx.Capabilities.Get(GLenum_GL_SCISSOR_TEST), ϟa, ϟs, ϟd, ϟl, ϟb) + v.Index(uint64(0), ϟs).Write(func() GLboolean { + if ctx.Capabilities.Get(GLenum_GL_SCISSOR_TEST) { + return 1 + } else { + return 0 + } + }(), ϟa, ϟs, ϟd, ϟl, ϟb) case GLenum_GL_STENCIL_TEST: - v.Index(uint64(0), ϟs).Write(ctx.Capabilities.Get(GLenum_GL_STENCIL_TEST), ϟa, ϟs, ϟd, ϟl, ϟb) + v.Index(uint64(0), ϟs).Write(func() GLboolean { + if ctx.Capabilities.Get(GLenum_GL_STENCIL_TEST) { + return 1 + } else { + return 0 + } + }(), ϟa, ϟs, ϟd, ϟl, ϟb) case GLenum_GL_DEPTH_WRITEMASK: v.Index(uint64(0), ϟs).Write(ctx.Rasterizing.DepthMask, ϟa, ϟs, ϟd, ϟl, ϟb) case GLenum_GL_COLOR_WRITEMASK: @@ -16390,7 +16444,7 @@ func (ϟa *GlVertexAttribPointer) Replay(ϟi atom.ID, ϟs *gfxapi.State, ϟd dat ϟb.Push(ϟa.Location.value(ϟb, ϟa, ϟs)) ϟb.Push(ϟa.Size.value(ϟb, ϟa, ϟs)) ϟb.Push(value.U32(ϟa.Type)) - ϟb.Push(value.Bool(ϟa.Normalized)) + ϟb.Push(ϟa.Normalized.value(ϟb, ϟa, ϟs)) ϟb.Push(ϟa.Stride.value(ϟb, ϟa, ϟs)) ϟb.Push(ϟa.Data.value(ϟb, ϟa, ϟs)) ϟb.Call(funcInfoGlVertexAttribPointer) @@ -16932,13 +16986,6 @@ func (p GLbooleanᵖ) value() value.Pointer { return value.AbsolutePointer(0) } } -func (p Boolᵖ) value() value.Pointer { - if p.Address != 0 { - return value.RemappedPointer(p.Address) - } else { - return value.AbsolutePointer(0) - } -} func (p SamplerIdᶜᵖ) value() value.Pointer { if p.Address != 0 { return value.RemappedPointer(p.Address) diff --git a/gfxapi/gles/state_mutator.go b/gfxapi/gles/state_mutator.go index ed4f53ad6..ac7e75ed6 100644 --- a/gfxapi/gles/state_mutator.go +++ b/gfxapi/gles/state_mutator.go @@ -480,7 +480,13 @@ func (ϟa *GlIsQuery) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log.L GetContext_50_result := context // Contextʳ ctx := GetContext_50_result // Contextʳ ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool]) - ϟa.Result = ctx.Instances.Queries.Contains(ϟa.Query) + ϟa.Result = func() GLboolean { + if ctx.Instances.Queries.Contains(ϟa.Query) { + return 1 + } else { + return 0 + } + }() _, _, _, _, _ = minRequiredVersion_49_major, minRequiredVersion_49_minor, context, GetContext_50_result, ctx return nil } @@ -801,7 +807,13 @@ func (ϟa *GlIsBuffer) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log. GetContext_93_result := context // Contextʳ ctx := GetContext_93_result // Contextʳ ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool]) - ϟa.Result = ctx.Instances.Buffers.Contains(ϟa.Buffer) + ϟa.Result = func() GLboolean { + if ctx.Instances.Buffers.Contains(ϟa.Buffer) { + return 1 + } else { + return 0 + } + }() _, _, _, _, _ = minRequiredVersion_92_major, minRequiredVersion_92_minor, context, GetContext_93_result, ctx return nil } @@ -2832,7 +2844,13 @@ func (ϟa *GlIsQueryEXT) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl lo GetContext_314_result := context // Contextʳ ctx := GetContext_314_result // Contextʳ ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool]) - ϟa.Result = ctx.Instances.Queries.Contains(ϟa.Query) + ϟa.Result = func() GLboolean { + if ctx.Instances.Queries.Contains(ϟa.Query) { + return 1 + } else { + return 0 + } + }() _, _, _, _, _ = requiresExtension_312_ext, requiresExtension_313_ext, context, GetContext_314_result, ctx return nil } @@ -2865,7 +2883,13 @@ func (ϟa *GlIsVertexArrayOES) Mutate(ϟs *gfxapi.State, ϟd database.Database, GetContext_318_result := context // Contextʳ ctx := GetContext_318_result // Contextʳ ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool]) - ϟa.Result = ctx.Instances.VertexArrays.Contains(ϟa.Array) + ϟa.Result = func() GLboolean { + if ctx.Instances.VertexArrays.Contains(ϟa.Array) { + return 1 + } else { + return 0 + } + }() _, _, _, _ = requiresExtension_317_ext, context, GetContext_318_result, ctx return nil } @@ -5322,7 +5346,13 @@ func (ϟa *GlIsFramebuffer) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl GetContext_601_result := context // Contextʳ ctx := GetContext_601_result // Contextʳ ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool]) - ϟa.Result = ctx.Instances.Framebuffers.Contains(ϟa.Framebuffer) + ϟa.Result = func() GLboolean { + if ctx.Instances.Framebuffers.Contains(ϟa.Framebuffer) { + return 1 + } else { + return 0 + } + }() _, _, _, _, _ = minRequiredVersion_600_major, minRequiredVersion_600_minor, context, GetContext_601_result, ctx return nil } @@ -5336,7 +5366,13 @@ func (ϟa *GlIsRenderbuffer) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟ GetContext_603_result := context // Contextʳ ctx := GetContext_603_result // Contextʳ ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool]) - ϟa.Result = ctx.Instances.Renderbuffers.Contains(ϟa.Renderbuffer) + ϟa.Result = func() GLboolean { + if ctx.Instances.Renderbuffers.Contains(ϟa.Renderbuffer) { + return 1 + } else { + return 0 + } + }() _, _, _, _, _ = minRequiredVersion_602_major, minRequiredVersion_602_minor, context, GetContext_603_result, ctx return nil } @@ -6376,7 +6412,13 @@ func (ϟa *GlIsProgram) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log GetContext_722_result := context // Contextʳ ctx := GetContext_722_result // Contextʳ ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool]) - ϟa.Result = ctx.Instances.Programs.Contains(ϟa.Program) + ϟa.Result = func() GLboolean { + if ctx.Instances.Programs.Contains(ϟa.Program) { + return 1 + } else { + return 0 + } + }() _, _, _, _, _ = minRequiredVersion_721_major, minRequiredVersion_721_minor, context, GetContext_722_result, ctx return nil } @@ -6401,7 +6443,13 @@ func (ϟa *GlIsShader) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log. GetContext_725_result := context // Contextʳ ctx := GetContext_725_result // Contextʳ ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool]) - ϟa.Result = ctx.Instances.Shaders.Contains(ϟa.Shader) + ϟa.Result = func() GLboolean { + if ctx.Instances.Shaders.Contains(ϟa.Shader) { + return 1 + } else { + return 0 + } + }() _, _, _, _, _ = minRequiredVersion_724_major, minRequiredVersion_724_minor, context, GetContext_725_result, ctx return nil } @@ -7649,30 +7697,84 @@ func (ϟa *GlGetBooleanv) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl l v := ϟa.Param return fmt.Errorf("Missing switch case handler for value %T %v", v, v) } - v := ϟa.Values.Slice(uint64(int32(0)), uint64(externs{ϟa, ϟs, ϟd, ϟl, ϟb}.stateVariableSize(ϟa.Param)), ϟs) // Boolˢ + v := ϟa.Values.Slice(uint64(int32(0)), uint64(externs{ϟa, ϟs, ϟd, ϟl, ϟb}.stateVariableSize(ϟa.Param)), ϟs) // GLbooleanˢ context := ϟc.Contexts.Get(ϟc.CurrentThread) // Contextʳ GetContext_855_result := context // Contextʳ ctx := GetContext_855_result // Contextʳ ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool]) switch ϟa.Param { case GLenum_GL_BLEND: - v.Index(uint64(0), ϟs).Write(ctx.Capabilities.Get(GLenum_GL_BLEND), ϟa, ϟs, ϟd, ϟl, ϟb) + v.Index(uint64(0), ϟs).Write(func() GLboolean { + if ctx.Capabilities.Get(GLenum_GL_BLEND) { + return 1 + } else { + return 0 + } + }(), ϟa, ϟs, ϟd, ϟl, ϟb) case GLenum_GL_CULL_FACE: - v.Index(uint64(0), ϟs).Write(ctx.Capabilities.Get(GLenum_GL_CULL_FACE), ϟa, ϟs, ϟd, ϟl, ϟb) + v.Index(uint64(0), ϟs).Write(func() GLboolean { + if ctx.Capabilities.Get(GLenum_GL_CULL_FACE) { + return 1 + } else { + return 0 + } + }(), ϟa, ϟs, ϟd, ϟl, ϟb) case GLenum_GL_DEPTH_TEST: - v.Index(uint64(0), ϟs).Write(ctx.Capabilities.Get(GLenum_GL_DEPTH_TEST), ϟa, ϟs, ϟd, ϟl, ϟb) + v.Index(uint64(0), ϟs).Write(func() GLboolean { + if ctx.Capabilities.Get(GLenum_GL_DEPTH_TEST) { + return 1 + } else { + return 0 + } + }(), ϟa, ϟs, ϟd, ϟl, ϟb) case GLenum_GL_DITHER: - v.Index(uint64(0), ϟs).Write(ctx.Capabilities.Get(GLenum_GL_DITHER), ϟa, ϟs, ϟd, ϟl, ϟb) + v.Index(uint64(0), ϟs).Write(func() GLboolean { + if ctx.Capabilities.Get(GLenum_GL_DITHER) { + return 1 + } else { + return 0 + } + }(), ϟa, ϟs, ϟd, ϟl, ϟb) case GLenum_GL_POLYGON_OFFSET_FILL: - v.Index(uint64(0), ϟs).Write(ctx.Capabilities.Get(GLenum_GL_POLYGON_OFFSET_FILL), ϟa, ϟs, ϟd, ϟl, ϟb) + v.Index(uint64(0), ϟs).Write(func() GLboolean { + if ctx.Capabilities.Get(GLenum_GL_POLYGON_OFFSET_FILL) { + return 1 + } else { + return 0 + } + }(), ϟa, ϟs, ϟd, ϟl, ϟb) case GLenum_GL_SAMPLE_ALPHA_TO_COVERAGE: - v.Index(uint64(0), ϟs).Write(ctx.Capabilities.Get(GLenum_GL_SAMPLE_ALPHA_TO_COVERAGE), ϟa, ϟs, ϟd, ϟl, ϟb) + v.Index(uint64(0), ϟs).Write(func() GLboolean { + if ctx.Capabilities.Get(GLenum_GL_SAMPLE_ALPHA_TO_COVERAGE) { + return 1 + } else { + return 0 + } + }(), ϟa, ϟs, ϟd, ϟl, ϟb) case GLenum_GL_SAMPLE_COVERAGE: - v.Index(uint64(0), ϟs).Write(ctx.Capabilities.Get(GLenum_GL_SAMPLE_COVERAGE), ϟa, ϟs, ϟd, ϟl, ϟb) + v.Index(uint64(0), ϟs).Write(func() GLboolean { + if ctx.Capabilities.Get(GLenum_GL_SAMPLE_COVERAGE) { + return 1 + } else { + return 0 + } + }(), ϟa, ϟs, ϟd, ϟl, ϟb) case GLenum_GL_SCISSOR_TEST: - v.Index(uint64(0), ϟs).Write(ctx.Capabilities.Get(GLenum_GL_SCISSOR_TEST), ϟa, ϟs, ϟd, ϟl, ϟb) + v.Index(uint64(0), ϟs).Write(func() GLboolean { + if ctx.Capabilities.Get(GLenum_GL_SCISSOR_TEST) { + return 1 + } else { + return 0 + } + }(), ϟa, ϟs, ϟd, ϟl, ϟb) case GLenum_GL_STENCIL_TEST: - v.Index(uint64(0), ϟs).Write(ctx.Capabilities.Get(GLenum_GL_STENCIL_TEST), ϟa, ϟs, ϟd, ϟl, ϟb) + v.Index(uint64(0), ϟs).Write(func() GLboolean { + if ctx.Capabilities.Get(GLenum_GL_STENCIL_TEST) { + return 1 + } else { + return 0 + } + }(), ϟa, ϟs, ϟd, ϟl, ϟb) case GLenum_GL_DEPTH_WRITEMASK: v.Index(uint64(0), ϟs).Write(ctx.Rasterizing.DepthMask, ϟa, ϟs, ϟd, ϟl, ϟb) case GLenum_GL_COLOR_WRITEMASK: @@ -8076,7 +8178,13 @@ func (ϟa *GlIsEnabled) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log GetContext_887_result := context // Contextʳ ctx := GetContext_887_result // Contextʳ ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool]) - ϟa.Result = ctx.Capabilities.Get(ϟa.Capability) + ϟa.Result = func() GLboolean { + if ctx.Capabilities.Get(ϟa.Capability) { + return 1 + } else { + return 0 + } + }() _, _, _, _, _ = minRequiredVersion_884_major, minRequiredVersion_884_minor, context, GetContext_887_result, ctx return nil } @@ -8768,7 +8876,13 @@ func (ϟa *GlIsTexture) Mutate(ϟs *gfxapi.State, ϟd database.Database, ϟl log GetContext_970_result := context // Contextʳ ctx := GetContext_970_result // Contextʳ ϟa.observations.ApplyWrites(ϟs.Memory[memory.ApplicationPool]) - ϟa.Result = ctx.Instances.Textures.Contains(ϟa.Texture) + ϟa.Result = func() GLboolean { + if ctx.Instances.Textures.Contains(ϟa.Texture) { + return 1 + } else { + return 0 + } + }() _, _, _, _, _ = minRequiredVersion_969_major, minRequiredVersion_969_minor, context, GetContext_970_result, ctx return nil } diff --git a/gfxapi/gles/tweaker.go b/gfxapi/gles/tweaker.go index 8ef628652..9811adc23 100644 --- a/gfxapi/gles/tweaker.go +++ b/gfxapi/gles/tweaker.go @@ -53,7 +53,7 @@ func (t *tweaker) glDisable(v GLenum) { } } -func (t *tweaker) glDepthMask(v bool) { +func (t *tweaker) glDepthMask(v GLboolean) { if o := t.ctx.Rasterizing.DepthMask; o != v { t.undo = append(t.undo, func() { t.out.Write(atom.NoID, NewGlDepthMask(o)) diff --git a/gfxapi/gles/unknown_framebuffer.go b/gfxapi/gles/unknown_framebuffer.go index eead63a62..4871b89ff 100644 --- a/gfxapi/gles/unknown_framebuffer.go +++ b/gfxapi/gles/unknown_framebuffer.go @@ -110,7 +110,7 @@ func drawUndefinedFramebuffer(a atom.Atom, s *gfxapi.State, d database.Database, out.Write(atom.NoID, NewGlUseProgram(programID)) out.Write(atom.NoID, NewGlBindBuffer(GLenum_GL_ARRAY_BUFFER, 0)) out.Write(atom.NoID, NewGlBindBuffer(GLenum_GL_ELEMENT_ARRAY_BUFFER, 0)) - out.Write(atom.NoID, NewGlVertexAttribPointer(aScreenCoordsLocation, 2, GLenum_GL_FLOAT, false, 0, memory.Tmp)) + out.Write(atom.NoID, NewGlVertexAttribPointer(aScreenCoordsLocation, 2, GLenum_GL_FLOAT, GLboolean(0), 0, memory.Tmp)) out.Write(atom.NoID, NewGlDrawArrays(GLenum_GL_TRIANGLE_STRIP, 0, 4). AddRead(atom.Data(s.Architecture, d, l, memory.Tmp, positions))) diff --git a/gfxapi/gles/wireframe.go b/gfxapi/gles/wireframe.go index ab93e2aea..cb56d3e2a 100644 --- a/gfxapi/gles/wireframe.go +++ b/gfxapi/gles/wireframe.go @@ -65,8 +65,8 @@ func wireframeOverlay(id atom.ID, d database.Database, l log.Logger) atom.Transf t.glEnable(GLenum_GL_BLEND) t.glBlendColor(1.5, 0.5, 1.0, 1.0) t.glBlendFunc(GLenum_GL_CONSTANT_COLOR, GLenum_GL_ZERO) - if t.ctx.Rasterizing.DepthMask && t.ctx.Capabilities[GLenum_GL_DEPTH_TEST] { - t.glDepthMask(false) + if t.ctx.Rasterizing.DepthMask != 0 && t.ctx.Capabilities[GLenum_GL_DEPTH_TEST] { + t.glDepthMask(GLboolean(0)) t.glDepthFunc(GLenum_GL_EQUAL) } diff --git a/gfxapi/templates/go_common.tmpl b/gfxapi/templates/go_common.tmpl index ae7094b27..0509797b0 100644 --- a/gfxapi/templates/go_common.tmpl +++ b/gfxapi/templates/go_common.tmpl @@ -577,6 +577,16 @@ string({{$src}}.{{Macro "Go.Memory.Read"}}) {{/* string[] -> char[] */}}{{else if and (IsString $src_ty) (IsSlice $dst_ty)}} Make{{Template "Go.Type" $.Type}}FromString({{$src}}, ϟs) + {{/* bool -> number */}}{{else if and (IsBool $src_ty) (IsNumericType $dst_ty)}} + func() {{Template "Go.Type" $.Type}} { + if {{$src}} { + return 1 + } else { + return 0 + } + }() + {{/* number -> bool */}}{{else if and (IsNumericType $src_ty) (IsBool $dst_ty)}} + (({{$src}}) != 0) {{else}} {{Template "Go.Type" $.Type}}({{$src}}) {{end}} diff --git a/integration/replay/gles/gles_test.go b/integration/replay/gles/gles_test.go index 8bbf762bf..f702e7984 100644 --- a/integration/replay/gles/gles_test.go +++ b/integration/replay/gles/gles_test.go @@ -169,7 +169,7 @@ func TestDrawTriangle(t *testing.T) { gles.NewGlUseProgram(prog), gles.NewGlGetAttribLocation(prog, "position", gles.GLint(pos)), gles.NewGlEnableVertexAttribArray(pos), - gles.NewGlVertexAttribPointer(pos, 2, gles.GLenum_GL_FLOAT, false, 0, p(0x100000)). + gles.NewGlVertexAttribPointer(pos, 2, gles.GLenum_GL_FLOAT, gles.GLboolean(0), 0, p(0x100000)). AddRead(atom.Data(a, d, l, p(0x100000), triangleVertices)), gles.NewGlDrawArrays(gles.GLenum_GL_TRIANGLES, 0, 3), ) @@ -198,7 +198,7 @@ func TestResizeRenderer(t *testing.T) { gles.NewGlUseProgram(prog), gles.NewGlGetAttribLocation(prog, "position", gles.GLint(pos)), gles.NewGlEnableVertexAttribArray(pos), - gles.NewGlVertexAttribPointer(pos, 2, gles.GLenum_GL_FLOAT, false, 0, p(0x100000)). + gles.NewGlVertexAttribPointer(pos, 2, gles.GLenum_GL_FLOAT, gles.GLboolean(0), 0, p(0x100000)). AddRead(atom.Data(a, d, l, p(0x100000), triangleVertices)), ) triangle := atoms.Add( |