Replace bool types with GLboolean.
Change-Id: Id016d7b3dbe736d57c335c160844864d0f51d655
diff --git a/api/resolver/rules.go b/api/resolver/rules.go
index 1d88e1c..bd9b776 100644
--- a/api/resolver/rules.go
+++ b/api/resolver/rules.go
@@ -109,6 +109,13 @@
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 aa442f0..a92fd6e 100644
--- a/cc/gapic/coder/gles.h
+++ b/cc/gapic/coder/gles.h
@@ -160,38 +160,6 @@
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 @@
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 @@
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 @@
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 @@
float mPolygonOffsetFactor;
float mPolygonOffsetUnits;
float mSampleCoverageValue;
- bool mSampleCoverageInvert;
+ uint8_t mSampleCoverageInvert;
};
class VertexPointer: public Encodable {
@@ -794,7 +762,7 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
atom::Observations mobservations;
uint32_t mParam;
- Bool__P mValues;
+ GLboolean__P mValues;
};
class GlGetBufferParameteri64v: public Encodable {
@@ -11864,214 +11832,214 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 c7a9bf8..62cd3be 100644
--- a/cc/gapii/gles_exports.cpp
+++ b/cc/gapii/gles_exports.cpp
@@ -66,7 +66,7 @@
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 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 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 @@
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 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 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 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 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 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 @@
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 @@
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 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 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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 87fd52b..e3e9722 100644
--- a/cc/gapii/gles_imports.h
+++ b/cc/gapii/gles_imports.h
@@ -69,7 +69,7 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 88cb67a..97fb649 100644
--- a/cc/gapii/gles_spy.h
+++ b/cc/gapii/gles_spy.h
@@ -75,7 +75,7 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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::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 7fbcc8d..86f435a 100644
--- a/cc/gapii/gles_types.h
+++ b/cc/gapii/gles_types.h
@@ -5803,7 +5803,7 @@
mType = v;
return *this;
}
- inline VertexAttributeArray& SetNormalized(bool v) {
+ inline VertexAttributeArray& SetNormalized(GLboolean v) {
mNormalized = v;
return *this;
}
@@ -5823,7 +5823,7 @@
bool mEnabled;
uint32_t mSize;
uint32_t mType;
- bool mNormalized;
+ GLboolean mNormalized;
GLsizei mStride;
BufferId mBuffer;
VertexPointer mPointer;
@@ -5958,7 +5958,7 @@
};
struct RasterizerState {
- inline RasterizerState& SetDepthMask(bool v) {
+ inline RasterizerState& SetDepthMask(GLboolean v) {
mDepthMask = v;
return *this;
}
@@ -5974,19 +5974,19 @@
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 @@
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 @@
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 49c2465..218a86d 100644
--- a/cc/gapir/gfx_api.cpp
+++ b/cc/gapir/gfx_api.cpp
@@ -526,10 +526,10 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 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 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 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 @@
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 @@
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 @@
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 @@
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 @@
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 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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 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 95ff2f9..e1754fa 100644
--- a/cc/gapir/gfx_api.h
+++ b/cc/gapir/gfx_api.h
@@ -6461,7 +6461,7 @@
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 *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 *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 *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 *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 *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 *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 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 *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 @@
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 @@
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 *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 *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 *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 e2415a4..41bc599 100644
--- a/gfxapi/gles/api.go
+++ b/gfxapi/gles/api.go
@@ -3547,56 +3547,6 @@
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 @@
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 @@
observations atom.Observations
Target GLenum
Index GLuint
- Result bool
+ Result GLboolean
}
func (a *GlIsEnablediEXT) String() string {
@@ -14461,7 +14254,7 @@
binary.Generate
observations atom.Observations
Query QueryId
- Result bool
+ Result GLboolean
}
func (a *GlIsQuery) String() string {
@@ -14871,7 +14664,7 @@
binary.Generate
observations atom.Observations
Buffer BufferId
- Result bool
+ Result GLboolean
}
func (a *GlIsBuffer) String() string {
@@ -20776,7 +20569,7 @@
observations atom.Observations
Target GLenum
Index GLuint
- Result bool
+ Result GLboolean
}
func (a *GlIsEnablediOES) String() string {
@@ -20810,7 +20603,7 @@
observations atom.Observations
Target GLenum
Index GLuint
- Result bool
+ Result GLboolean
}
func (a *GlIsEnablediNV) String() string {
@@ -20843,7 +20636,7 @@
binary.Generate
observations atom.Observations
Fence GLuint
- Result bool
+ Result GLboolean
}
func (a *GlIsFenceNV) String() string {
@@ -20876,7 +20669,7 @@
binary.Generate
observations atom.Observations
Handle GLuint64
- Result bool
+ Result GLboolean
}
func (a *GlIsImageHandleResidentNV) String() string {
@@ -20909,7 +20702,7 @@
binary.Generate
observations atom.Observations
Path GLuint
- Result bool
+ Result GLboolean
}
func (a *GlIsPathNV) String() string {
@@ -20945,7 +20738,7 @@
Mask GLuint
X GLfloat
Y GLfloat
- Result bool
+ Result GLboolean
}
func (a *GlIsPointInFillPathNV) String() string {
@@ -20980,7 +20773,7 @@
Path GLuint
X GLfloat
Y GLfloat
- Result bool
+ Result GLboolean
}
func (a *GlIsPointInStrokePathNV) String() string {
@@ -21013,7 +20806,7 @@
binary.Generate
observations atom.Observations
Pipeline PipelineId
- Result bool
+ Result GLboolean
}
func (a *GlIsProgramPipelineEXT) String() string {
@@ -21046,7 +20839,7 @@
binary.Generate
observations atom.Observations
Query QueryId
- Result bool
+ Result GLboolean
}
func (a *GlIsQueryEXT) String() string {
@@ -21079,7 +20872,7 @@
binary.Generate
observations atom.Observations
Sync GLsync
- Result bool
+ Result GLboolean
}
func (a *GlIsSyncAPPLE) String() string {
@@ -21112,7 +20905,7 @@
binary.Generate
observations atom.Observations
Handle GLuint64
- Result bool
+ Result GLboolean
}
func (a *GlIsTextureHandleResidentNV) String() string {
@@ -21145,7 +20938,7 @@
binary.Generate
observations atom.Observations
Array VertexArrayId
- Result bool
+ Result GLboolean
}
func (a *GlIsVertexArrayOES) String() string {
@@ -26775,7 +26568,7 @@
binary.Generate
observations atom.Observations
Value GLfloat
- Invert bool
+ Invert GLboolean
}
func (a *GlSampleCoverage) String() string {
@@ -27421,10 +27214,10 @@
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 @@
type GlDepthMask struct {
binary.Generate
observations atom.Observations
- Enabled bool
+ Enabled GLboolean
}
func (a *GlDepthMask) String() string {
@@ -27939,7 +27732,7 @@
binary.Generate
observations atom.Observations
Framebuffer FramebufferId
- Result bool
+ Result GLboolean
}
func (a *GlIsFramebuffer) String() string {
@@ -27972,7 +27765,7 @@
binary.Generate
observations atom.Observations
Renderbuffer RenderbufferId
- Result bool
+ Result GLboolean
}
func (a *GlIsRenderbuffer) String() string {
@@ -29914,7 +29707,7 @@
binary.Generate
observations atom.Observations
Program ProgramId
- Result bool
+ Result GLboolean
}
func (a *GlIsProgram) String() string {
@@ -29947,7 +29740,7 @@
binary.Generate
observations atom.Observations
Pipeline PipelineId
- Result bool
+ Result GLboolean
}
func (a *GlIsProgramPipeline) String() string {
@@ -29980,7 +29773,7 @@
binary.Generate
observations atom.Observations
Shader ShaderId
- Result bool
+ Result GLboolean
}
func (a *GlIsShader) String() string {
@@ -33016,7 +32809,7 @@
binary.Generate
observations atom.Observations
Param GLenum
- Values Boolᵖ
+ Values GLbooleanᵖ
}
func (a *GlGetBooleanv) String() string {
@@ -33319,7 +33112,7 @@
binary.Generate
observations atom.Observations
Capability GLenum
- Result bool
+ Result GLboolean
}
func (a *GlIsEnabled) String() string {
@@ -33489,7 +33282,7 @@
binary.Generate
observations atom.Observations
Sync GLsync
- Result bool
+ Result GLboolean
}
func (a *GlIsSync) String() string {
@@ -34341,7 +34134,7 @@
binary.Generate
observations atom.Observations
Sampler SamplerId
- Result bool
+ Result GLboolean
}
func (a *GlIsSampler) String() string {
@@ -34374,7 +34167,7 @@
binary.Generate
observations atom.Observations
Texture TextureId
- Result bool
+ Result GLboolean
}
func (a *GlIsTexture) String() string {
@@ -35185,7 +34978,7 @@
binary.Generate
observations atom.Observations
Id TransformFeedbackId
- Result bool
+ Result GLboolean
}
func (a *GlIsTransformFeedback) String() string {
@@ -35682,7 +35475,7 @@
binary.Generate
observations atom.Observations
Array VertexArrayId
- Result bool
+ Result GLboolean
}
func (a *GlIsVertexArray) String() string {
@@ -36298,7 +36091,7 @@
Location AttributeLocation
Size GLint
Type GLenum
- Normalized bool
+ Normalized GLboolean
Stride GLsizei
Data VertexPointer
}
@@ -37631,7 +37424,7 @@
Enabled bool
Size uint32
Type GLenum
- Normalized bool
+ Normalized GLboolean
Stride GLsizei
Buffer BufferId
Pointer VertexPointer
@@ -37641,7 +37434,7 @@
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 @@
////////////////////////////////////////////////////////////////////////////////
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 @@
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 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 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 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 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 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 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 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 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 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 @@
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 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 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 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 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 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 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 c6b8b6b..e476669 100644
--- a/gfxapi/gles/api/android_extension_pack.api
+++ b/gfxapi/gles/api/android_extension_pack.api
@@ -182,7 +182,7 @@
}
@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 41ad05d..9b7d32b 100644
--- a/gfxapi/gles/api/asynchronous_queries.api
+++ b/gfxapi/gles/api/asynchronous_queries.api
@@ -113,10 +113,10 @@
@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 f1e00a4..52531f8 100644
--- a/gfxapi/gles/api/buffer_objects.api
+++ b/gfxapi/gles/api/buffer_objects.api
@@ -304,11 +304,11 @@
@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 a982e4d..3a2233b 100644
--- a/gfxapi/gles/api/extensions.api
+++ b/gfxapi/gles/api/extensions.api
@@ -1332,56 +1332,56 @@
}
@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 @@
@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 5f06f5d..ce1f329 100644
--- a/gfxapi/gles/api/fragment_operations.api
+++ b/gfxapi/gles/api/fragment_operations.api
@@ -198,7 +198,7 @@
@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 c9e2892..57bc0a2 100644
--- a/gfxapi/gles/api/framebuffer.api
+++ b/gfxapi/gles/api/framebuffer.api
@@ -227,7 +227,7 @@
@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 @@
@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 @@
@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 99ab894..ce96884 100644
--- a/gfxapi/gles/api/programs_and_shaders.api
+++ b/gfxapi/gles/api/programs_and_shaders.api
@@ -639,15 +639,15 @@
@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 @@
@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 137694f..61d9b90 100644
--- a/gfxapi/gles/api/state_queries.api
+++ b/gfxapi/gles/api/state_queries.api
@@ -93,7 +93,7 @@
@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 @@
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 @@
@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 @@
}
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 cec6998..fb12075 100644
--- a/gfxapi/gles/api/synchronization.api
+++ b/gfxapi/gles/api/synchronization.api
@@ -63,7 +63,7 @@
@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 43fc8e4..799b87f 100644
--- a/gfxapi/gles/api/textures_and_samplers.api
+++ b/gfxapi/gles/api/textures_and_samplers.api
@@ -643,7 +643,7 @@
@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 @@
@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 8fd03bd..c745229 100644
--- a/gfxapi/gles/api/transform_feedback.api
+++ b/gfxapi/gles/api/transform_feedback.api
@@ -78,7 +78,7 @@
@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 2737490..2497ebb 100644
--- a/gfxapi/gles/api/vertex_arrays.api
+++ b/gfxapi/gles/api/vertex_arrays.api
@@ -184,7 +184,7 @@
@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 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 49fe15f..0591585 100644
--- a/gfxapi/gles/gles.api
+++ b/gfxapi/gles/gles.api
@@ -413,7 +413,7 @@
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 @@
@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 @@
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 fec2e3a..4ce48cc 100644
--- a/gfxapi/gles/gles_binary.go
+++ b/gfxapi/gles/gles_binary.go
@@ -24,8 +24,6 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
},
}
-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 @@
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 @@
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 @@
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 @@
} 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 @@
} 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 @@
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 @@
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 @@
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 @@
{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 @@
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 @@
} 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 @@
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 @@
{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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
} 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 @@
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 @@
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 @@
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 @@
} 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 @@
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 @@
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 @@
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 @@
} 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 @@
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 @@
{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 @@
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 @@
} 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 @@
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 @@
{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 @@
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 @@
} 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 @@
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 @@
{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 @@
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 @@
} 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 @@
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 @@
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 @@
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 @@
} 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 @@
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 @@
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 @@
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 @@
} 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 @@
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 @@
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 @@
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 @@
} 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 @@
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 @@
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 @@
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 @@
} 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 @@
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 @@
{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 @@
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 @@
} 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 @@
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 @@
{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 @@
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 @@
} 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 @@
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 @@
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 @@
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 @@
} 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 @@
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 @@
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 @@
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 @@
} 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 @@
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 @@
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 @@
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 @@
} 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 @@
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 @@
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 @@
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 @@
} 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 @@
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 @@
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 @@
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 @@
} 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 @@
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 @@
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 @@
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 @@
} 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 @@
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 @@
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 @@
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 @@
} 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 @@
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 @@
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 @@
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 @@
} 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 @@
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 @@
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 @@
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 @@
} 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 @@
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 @@
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 @@
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 @@
} 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 @@
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 @@
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 @@
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 @@
} 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 @@
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 @@
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 @@
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 @@
} 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 @@
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 @@
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 @@
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 @@
} 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 @@
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 @@
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 @@
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 @@
} 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 @@
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 @@
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 @@
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 @@
} 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 @@
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 @@
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 @@
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 @@
} 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 @@
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 @@
{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 686094e..d135e07 100644
--- a/gfxapi/gles/read_framebuffer.go
+++ b/gfxapi/gles/read_framebuffer.go
@@ -168,7 +168,7 @@
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 d33b9cc..2b00e77 100644
--- a/gfxapi/gles/replay_writer.go
+++ b/gfxapi/gles/replay_writer.go
@@ -52,7 +52,7 @@
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 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 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 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 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 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 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 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 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 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 @@
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 @@
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 @@
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 @@
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 @@
ϟ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 @@
ϟ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 @@
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 ed4f53a..ac7e75e 100644
--- a/gfxapi/gles/state_mutator.go
+++ b/gfxapi/gles/state_mutator.go
@@ -480,7 +480,13 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 8ef6286..9811adc 100644
--- a/gfxapi/gles/tweaker.go
+++ b/gfxapi/gles/tweaker.go
@@ -53,7 +53,7 @@
}
}
-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 eead63a..4871b89 100644
--- a/gfxapi/gles/unknown_framebuffer.go
+++ b/gfxapi/gles/unknown_framebuffer.go
@@ -110,7 +110,7 @@
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 ab93e2a..cb56d3e 100644
--- a/gfxapi/gles/wireframe.go
+++ b/gfxapi/gles/wireframe.go
@@ -65,8 +65,8 @@
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 ae7094b..0509797 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 8bbf762..f702e79 100644
--- a/integration/replay/gles/gles_test.go
+++ b/integration/replay/gles/gles_test.go
@@ -169,7 +169,7 @@
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 @@
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(
