Merge "Replace bool types with GLboolean." into studio-1.4-dev
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(