// // Copyright 2023 The ANGLE Project Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. // // context_private_call.cpp: // Helpers that set/get state that is entirely locally accessed by the context. #include "libANGLE/context_private_call_autogen.h" #include "common/debug.h" #include "libANGLE/queryconversions.h" #include "libANGLE/queryutils.h" namespace { angle::Mat4 FixedMatrixToMat4(const GLfixed *m) { angle::Mat4 matrixAsFloat; GLfloat *floatData = matrixAsFloat.data(); for (int i = 0; i < 16; i++) { floatData[i] = gl::ConvertFixedToFloat(m[i]); } return matrixAsFloat; } } // namespace namespace gl { void ContextPrivateClearColor(PrivateState *privateState, PrivateStateCache *privateStateCache, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) { privateState->setColorClearValue(red, green, blue, alpha); } void ContextPrivateClearDepthf(PrivateState *privateState, PrivateStateCache *privateStateCache, GLfloat depth) { privateState->setDepthClearValue(clamp01(depth)); } void ContextPrivateClearStencil(PrivateState *privateState, PrivateStateCache *privateStateCache, GLint stencil) { privateState->setStencilClearValue(stencil); } void ContextPrivateClearColorx(PrivateState *privateState, PrivateStateCache *privateStateCache, GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha) { ContextPrivateClearColor(privateState, privateStateCache, ConvertFixedToFloat(red), ConvertFixedToFloat(green), ConvertFixedToFloat(blue), ConvertFixedToFloat(alpha)); } void ContextPrivateClearDepthx(PrivateState *privateState, PrivateStateCache *privateStateCache, GLfixed depth) { ContextPrivateClearDepthf(privateState, privateStateCache, ConvertFixedToFloat(depth)); } void ContextPrivateColorMask(PrivateState *privateState, PrivateStateCache *privateStateCache, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) { privateState->setColorMask(ConvertToBool(red), ConvertToBool(green), ConvertToBool(blue), ConvertToBool(alpha)); privateStateCache->onColorMaskChange(); } void ContextPrivateColorMaski(PrivateState *privateState, PrivateStateCache *privateStateCache, GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a) { privateState->setColorMaskIndexed(ConvertToBool(r), ConvertToBool(g), ConvertToBool(b), ConvertToBool(a), index); privateStateCache->onColorMaskChange(); } void ContextPrivateDepthMask(PrivateState *privateState, PrivateStateCache *privateStateCache, GLboolean flag) { privateState->setDepthMask(ConvertToBool(flag)); } void ContextPrivateDisable(PrivateState *privateState, PrivateStateCache *privateStateCache, GLenum cap) { privateState->setEnableFeature(cap, false); privateStateCache->onCapChange(); } void ContextPrivateDisablei(PrivateState *privateState, PrivateStateCache *privateStateCache, GLenum target, GLuint index) { privateState->setEnableFeatureIndexed(target, false, index); privateStateCache->onCapChange(); } void ContextPrivateEnable(PrivateState *privateState, PrivateStateCache *privateStateCache, GLenum cap) { privateState->setEnableFeature(cap, true); privateStateCache->onCapChange(); } void ContextPrivateEnablei(PrivateState *privateState, PrivateStateCache *privateStateCache, GLenum target, GLuint index) { privateState->setEnableFeatureIndexed(target, true, index); privateStateCache->onCapChange(); } void ContextPrivateActiveTexture(PrivateState *privateState, PrivateStateCache *privateStateCache, GLenum texture) { privateState->setActiveSampler(texture - GL_TEXTURE0); } void ContextPrivateCullFace(PrivateState *privateState, PrivateStateCache *privateStateCache, CullFaceMode mode) { privateState->setCullMode(mode); } void ContextPrivateDepthFunc(PrivateState *privateState, PrivateStateCache *privateStateCache, GLenum func) { privateState->setDepthFunc(func); } void ContextPrivateDepthRangef(PrivateState *privateState, PrivateStateCache *privateStateCache, GLfloat zNear, GLfloat zFar) { privateState->setDepthRange(clamp01(zNear), clamp01(zFar)); } void ContextPrivateDepthRangex(PrivateState *privateState, PrivateStateCache *privateStateCache, GLfixed zNear, GLfixed zFar) { ContextPrivateDepthRangef(privateState, privateStateCache, ConvertFixedToFloat(zNear), ConvertFixedToFloat(zFar)); } void ContextPrivateFrontFace(PrivateState *privateState, PrivateStateCache *privateStateCache, GLenum mode) { privateState->setFrontFace(mode); } void ContextPrivateLineWidth(PrivateState *privateState, PrivateStateCache *privateStateCache, GLfloat width) { privateState->setLineWidth(width); } void ContextPrivateLineWidthx(PrivateState *privateState, PrivateStateCache *privateStateCache, GLfixed width) { ContextPrivateLineWidth(privateState, privateStateCache, ConvertFixedToFloat(width)); } void ContextPrivatePolygonOffset(PrivateState *privateState, PrivateStateCache *privateStateCache, GLfloat factor, GLfloat units) { privateState->setPolygonOffsetParams(factor, units, 0.0f); } void ContextPrivatePolygonOffsetClamp(PrivateState *privateState, PrivateStateCache *privateStateCache, GLfloat factor, GLfloat units, GLfloat clamp) { privateState->setPolygonOffsetParams(factor, units, clamp); } void ContextPrivatePolygonOffsetx(PrivateState *privateState, PrivateStateCache *privateStateCache, GLfixed factor, GLfixed units) { ContextPrivatePolygonOffsetClamp(privateState, privateStateCache, ConvertFixedToFloat(factor), ConvertFixedToFloat(units), 0.0f); } void ContextPrivateSampleCoverage(PrivateState *privateState, PrivateStateCache *privateStateCache, GLfloat value, GLboolean invert) { privateState->setSampleCoverageParams(clamp01(value), ConvertToBool(invert)); } void ContextPrivateSampleCoveragex(PrivateState *privateState, PrivateStateCache *privateStateCache, GLclampx value, GLboolean invert) { ContextPrivateSampleCoverage(privateState, privateStateCache, ConvertFixedToFloat(value), invert); } void ContextPrivateScissor(PrivateState *privateState, PrivateStateCache *privateStateCache, GLint x, GLint y, GLsizei width, GLsizei height) { privateState->setScissorParams(x, y, width, height); } void ContextPrivateVertexAttrib1f(PrivateState *privateState, PrivateStateCache *privateStateCache, GLuint index, GLfloat x) { GLfloat vals[4] = {x, 0, 0, 1}; privateState->setVertexAttribf(index, vals); privateStateCache->onDefaultVertexAttributeChange(); } void ContextPrivateVertexAttrib1fv(PrivateState *privateState, PrivateStateCache *privateStateCache, GLuint index, const GLfloat *values) { GLfloat vals[4] = {values[0], 0, 0, 1}; privateState->setVertexAttribf(index, vals); privateStateCache->onDefaultVertexAttributeChange(); } void ContextPrivateVertexAttrib2f(PrivateState *privateState, PrivateStateCache *privateStateCache, GLuint index, GLfloat x, GLfloat y) { GLfloat vals[4] = {x, y, 0, 1}; privateState->setVertexAttribf(index, vals); privateStateCache->onDefaultVertexAttributeChange(); } void ContextPrivateVertexAttrib2fv(PrivateState *privateState, PrivateStateCache *privateStateCache, GLuint index, const GLfloat *values) { GLfloat vals[4] = {values[0], values[1], 0, 1}; privateState->setVertexAttribf(index, vals); privateStateCache->onDefaultVertexAttributeChange(); } void ContextPrivateVertexAttrib3f(PrivateState *privateState, PrivateStateCache *privateStateCache, GLuint index, GLfloat x, GLfloat y, GLfloat z) { GLfloat vals[4] = {x, y, z, 1}; privateState->setVertexAttribf(index, vals); privateStateCache->onDefaultVertexAttributeChange(); } void ContextPrivateVertexAttrib3fv(PrivateState *privateState, PrivateStateCache *privateStateCache, GLuint index, const GLfloat *values) { GLfloat vals[4] = {values[0], values[1], values[2], 1}; privateState->setVertexAttribf(index, vals); privateStateCache->onDefaultVertexAttributeChange(); } void ContextPrivateVertexAttrib4f(PrivateState *privateState, PrivateStateCache *privateStateCache, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) { GLfloat vals[4] = {x, y, z, w}; privateState->setVertexAttribf(index, vals); privateStateCache->onDefaultVertexAttributeChange(); } void ContextPrivateVertexAttrib4fv(PrivateState *privateState, PrivateStateCache *privateStateCache, GLuint index, const GLfloat *values) { privateState->setVertexAttribf(index, values); privateStateCache->onDefaultVertexAttributeChange(); } void ContextPrivateVertexAttribI4i(PrivateState *privateState, PrivateStateCache *privateStateCache, GLuint index, GLint x, GLint y, GLint z, GLint w) { GLint vals[4] = {x, y, z, w}; privateState->setVertexAttribi(index, vals); privateStateCache->onDefaultVertexAttributeChange(); } void ContextPrivateVertexAttribI4iv(PrivateState *privateState, PrivateStateCache *privateStateCache, GLuint index, const GLint *values) { privateState->setVertexAttribi(index, values); privateStateCache->onDefaultVertexAttributeChange(); } void ContextPrivateVertexAttribI4ui(PrivateState *privateState, PrivateStateCache *privateStateCache, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) { GLuint vals[4] = {x, y, z, w}; privateState->setVertexAttribu(index, vals); privateStateCache->onDefaultVertexAttributeChange(); } void ContextPrivateVertexAttribI4uiv(PrivateState *privateState, PrivateStateCache *privateStateCache, GLuint index, const GLuint *values) { privateState->setVertexAttribu(index, values); privateStateCache->onDefaultVertexAttributeChange(); } void ContextPrivateViewport(PrivateState *privateState, PrivateStateCache *privateStateCache, GLint x, GLint y, GLsizei width, GLsizei height) { privateState->setViewportParams(x, y, width, height); } void ContextPrivateSampleMaski(PrivateState *privateState, PrivateStateCache *privateStateCache, GLuint maskNumber, GLbitfield mask) { privateState->setSampleMaskParams(maskNumber, mask); } void ContextPrivateMinSampleShading(PrivateState *privateState, PrivateStateCache *privateStateCache, GLfloat value) { privateState->setMinSampleShading(value); } void ContextPrivatePrimitiveBoundingBox(PrivateState *privateState, PrivateStateCache *privateStateCache, GLfloat minX, GLfloat minY, GLfloat minZ, GLfloat minW, GLfloat maxX, GLfloat maxY, GLfloat maxZ, GLfloat maxW) { privateState->setBoundingBox(minX, minY, minZ, minW, maxX, maxY, maxZ, maxW); } void ContextPrivateLogicOp(PrivateState *privateState, PrivateStateCache *privateStateCache, LogicalOperation opcode) { privateState->getMutableGLES1State()->setLogicOp(opcode); } void ContextPrivateLogicOpANGLE(PrivateState *privateState, PrivateStateCache *privateStateCache, LogicalOperation opcode) { privateState->setLogicOp(opcode); } void ContextPrivatePolygonMode(PrivateState *privateState, PrivateStateCache *privateStateCache, GLenum face, PolygonMode mode) { ASSERT(face == GL_FRONT_AND_BACK); privateState->setPolygonMode(mode); } void ContextPrivatePolygonModeNV(PrivateState *privateState, PrivateStateCache *privateStateCache, GLenum face, PolygonMode mode) { ContextPrivatePolygonMode(privateState, privateStateCache, face, mode); } void ContextPrivateProvokingVertex(PrivateState *privateState, PrivateStateCache *privateStateCache, ProvokingVertexConvention provokeMode) { privateState->setProvokingVertex(provokeMode); } void ContextPrivateCoverageModulation(PrivateState *privateState, PrivateStateCache *privateStateCache, GLenum components) { privateState->setCoverageModulation(components); } void ContextPrivateClipControl(PrivateState *privateState, PrivateStateCache *privateStateCache, ClipOrigin origin, ClipDepthMode depth) { privateState->setClipControl(origin, depth); } void ContextPrivateShadingRate(PrivateState *privateState, PrivateStateCache *privateStateCache, GLenum rate) { privateState->setShadingRate(rate); } void ContextPrivateBlendColor(PrivateState *privateState, PrivateStateCache *privateStateCache, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) { privateState->setBlendColor(red, green, blue, alpha); } void ContextPrivateBlendEquation(PrivateState *privateState, PrivateStateCache *privateStateCache, GLenum mode) { privateState->setBlendEquation(mode, mode); if (privateState->getExtensions().blendEquationAdvancedKHR) { privateStateCache->onBlendEquationOrFuncChange(); } } void ContextPrivateBlendEquationi(PrivateState *privateState, PrivateStateCache *privateStateCache, GLuint buf, GLenum mode) { privateState->setBlendEquationIndexed(mode, mode, buf); if (privateState->getExtensions().blendEquationAdvancedKHR) { privateStateCache->onBlendEquationOrFuncChange(); } } void ContextPrivateBlendEquationSeparate(PrivateState *privateState, PrivateStateCache *privateStateCache, GLenum modeRGB, GLenum modeAlpha) { privateState->setBlendEquation(modeRGB, modeAlpha); if (privateState->getExtensions().blendEquationAdvancedKHR) { privateStateCache->onBlendEquationOrFuncChange(); } } void ContextPrivateBlendEquationSeparatei(PrivateState *privateState, PrivateStateCache *privateStateCache, GLuint buf, GLenum modeRGB, GLenum modeAlpha) { privateState->setBlendEquationIndexed(modeRGB, modeAlpha, buf); if (privateState->getExtensions().blendEquationAdvancedKHR) { privateStateCache->onBlendEquationOrFuncChange(); } } void ContextPrivateBlendFunc(PrivateState *privateState, PrivateStateCache *privateStateCache, GLenum sfactor, GLenum dfactor) { privateState->setBlendFactors(sfactor, dfactor, sfactor, dfactor); if (privateState->getExtensions().blendFuncExtendedEXT) { privateStateCache->onBlendEquationOrFuncChange(); } } void ContextPrivateBlendFunci(PrivateState *privateState, PrivateStateCache *privateStateCache, GLuint buf, GLenum src, GLenum dst) { privateState->setBlendFactorsIndexed(src, dst, src, dst, buf); if (privateState->noSimultaneousConstantColorAndAlphaBlendFunc() || privateState->getExtensions().blendFuncExtendedEXT) { privateStateCache->onBlendEquationOrFuncChange(); } } void ContextPrivateBlendFuncSeparate(PrivateState *privateState, PrivateStateCache *privateStateCache, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) { privateState->setBlendFactors(srcRGB, dstRGB, srcAlpha, dstAlpha); if (privateState->getExtensions().blendFuncExtendedEXT) { privateStateCache->onBlendEquationOrFuncChange(); } } void ContextPrivateBlendFuncSeparatei(PrivateState *privateState, PrivateStateCache *privateStateCache, GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) { privateState->setBlendFactorsIndexed(srcRGB, dstRGB, srcAlpha, dstAlpha, buf); if (privateState->noSimultaneousConstantColorAndAlphaBlendFunc() || privateState->getExtensions().blendFuncExtendedEXT) { privateStateCache->onBlendEquationOrFuncChange(); } } void ContextPrivateStencilFunc(PrivateState *privateState, PrivateStateCache *privateStateCache, GLenum func, GLint ref, GLuint mask) { ContextPrivateStencilFuncSeparate(privateState, privateStateCache, GL_FRONT_AND_BACK, func, ref, mask); } void ContextPrivateStencilFuncSeparate(PrivateState *privateState, PrivateStateCache *privateStateCache, GLenum face, GLenum func, GLint ref, GLuint mask) { GLint clampedRef = gl::clamp(ref, 0, std::numeric_limits::max()); if (face == GL_FRONT || face == GL_FRONT_AND_BACK) { privateState->setStencilParams(func, clampedRef, mask); } if (face == GL_BACK || face == GL_FRONT_AND_BACK) { privateState->setStencilBackParams(func, clampedRef, mask); } privateStateCache->onStencilStateChange(); } void ContextPrivateStencilMask(PrivateState *privateState, PrivateStateCache *privateStateCache, GLuint mask) { ContextPrivateStencilMaskSeparate(privateState, privateStateCache, GL_FRONT_AND_BACK, mask); } void ContextPrivateStencilMaskSeparate(PrivateState *privateState, PrivateStateCache *privateStateCache, GLenum face, GLuint mask) { if (face == GL_FRONT || face == GL_FRONT_AND_BACK) { privateState->setStencilWritemask(mask); } if (face == GL_BACK || face == GL_FRONT_AND_BACK) { privateState->setStencilBackWritemask(mask); } privateStateCache->onStencilStateChange(); } void ContextPrivateStencilOp(PrivateState *privateState, PrivateStateCache *privateStateCache, GLenum fail, GLenum zfail, GLenum zpass) { ContextPrivateStencilOpSeparate(privateState, privateStateCache, GL_FRONT_AND_BACK, fail, zfail, zpass); } void ContextPrivateStencilOpSeparate(PrivateState *privateState, PrivateStateCache *privateStateCache, GLenum face, GLenum fail, GLenum zfail, GLenum zpass) { if (face == GL_FRONT || face == GL_FRONT_AND_BACK) { privateState->setStencilOperations(fail, zfail, zpass); } if (face == GL_BACK || face == GL_FRONT_AND_BACK) { privateState->setStencilBackOperations(fail, zfail, zpass); } } void ContextPrivatePixelStorei(PrivateState *privateState, PrivateStateCache *privateStateCache, GLenum pname, GLint param) { switch (pname) { case GL_UNPACK_ALIGNMENT: privateState->setUnpackAlignment(param); break; case GL_PACK_ALIGNMENT: privateState->setPackAlignment(param); break; case GL_PACK_REVERSE_ROW_ORDER_ANGLE: privateState->setPackReverseRowOrder(param != 0); break; case GL_UNPACK_ROW_LENGTH: ASSERT(privateState->getClientMajorVersion() >= 3 || privateState->getExtensions().unpackSubimageEXT); privateState->setUnpackRowLength(param); break; case GL_UNPACK_IMAGE_HEIGHT: ASSERT(privateState->getClientMajorVersion() >= 3); privateState->setUnpackImageHeight(param); break; case GL_UNPACK_SKIP_IMAGES: ASSERT(privateState->getClientMajorVersion() >= 3); privateState->setUnpackSkipImages(param); break; case GL_UNPACK_SKIP_ROWS: ASSERT((privateState->getClientMajorVersion() >= 3) || privateState->getExtensions().unpackSubimageEXT); privateState->setUnpackSkipRows(param); break; case GL_UNPACK_SKIP_PIXELS: ASSERT((privateState->getClientMajorVersion() >= 3) || privateState->getExtensions().unpackSubimageEXT); privateState->setUnpackSkipPixels(param); break; case GL_PACK_ROW_LENGTH: ASSERT((privateState->getClientMajorVersion() >= 3) || privateState->getExtensions().packSubimageNV); privateState->setPackRowLength(param); break; case GL_PACK_SKIP_ROWS: ASSERT((privateState->getClientMajorVersion() >= 3) || privateState->getExtensions().packSubimageNV); privateState->setPackSkipRows(param); break; case GL_PACK_SKIP_PIXELS: ASSERT((privateState->getClientMajorVersion() >= 3) || privateState->getExtensions().packSubimageNV); privateState->setPackSkipPixels(param); break; default: UNREACHABLE(); return; } } void ContextPrivateHint(PrivateState *privateState, PrivateStateCache *privateStateCache, GLenum target, GLenum mode) { switch (target) { case GL_GENERATE_MIPMAP_HINT: privateState->setGenerateMipmapHint(mode); break; case GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES: privateState->setFragmentShaderDerivativeHint(mode); break; case GL_PERSPECTIVE_CORRECTION_HINT: case GL_POINT_SMOOTH_HINT: case GL_LINE_SMOOTH_HINT: case GL_FOG_HINT: privateState->getMutableGLES1State()->setHint(target, mode); break; default: UNREACHABLE(); return; } } GLboolean ContextPrivateIsEnabled(PrivateState *privateState, PrivateStateCache *privateStateCache, GLenum cap) { return privateState->getEnableFeature(cap); } GLboolean ContextPrivateIsEnabledi(PrivateState *privateState, PrivateStateCache *privateStateCache, GLenum target, GLuint index) { return privateState->getEnableFeatureIndexed(target, index); } void ContextPrivatePatchParameteri(PrivateState *privateState, PrivateStateCache *privateStateCache, GLenum pname, GLint value) { switch (pname) { case GL_PATCH_VERTICES: privateState->setPatchVertices(value); break; default: break; } } void ContextPrivateAlphaFunc(PrivateState *privateState, PrivateStateCache *privateStateCache, AlphaTestFunc func, GLfloat ref) { privateState->getMutableGLES1State()->setAlphaTestParameters(func, ref); } void ContextPrivateAlphaFuncx(PrivateState *privateState, PrivateStateCache *privateStateCache, AlphaTestFunc func, GLfixed ref) { ContextPrivateAlphaFunc(privateState, privateStateCache, func, ConvertFixedToFloat(ref)); } void ContextPrivateClipPlanef(PrivateState *privateState, PrivateStateCache *privateStateCache, GLenum p, const GLfloat *eqn) { privateState->getMutableGLES1State()->setClipPlane(p - GL_CLIP_PLANE0, eqn); } void ContextPrivateClipPlanex(PrivateState *privateState, PrivateStateCache *privateStateCache, GLenum plane, const GLfixed *equation) { const GLfloat equationf[4] = { ConvertFixedToFloat(equation[0]), ConvertFixedToFloat(equation[1]), ConvertFixedToFloat(equation[2]), ConvertFixedToFloat(equation[3]), }; ContextPrivateClipPlanef(privateState, privateStateCache, plane, equationf); } void ContextPrivateColor4f(PrivateState *privateState, PrivateStateCache *privateStateCache, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) { privateState->getMutableGLES1State()->setCurrentColor({red, green, blue, alpha}); } void ContextPrivateColor4ub(PrivateState *privateState, PrivateStateCache *privateStateCache, GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) { ContextPrivateColor4f(privateState, privateStateCache, normalizedToFloat(red), normalizedToFloat(green), normalizedToFloat(blue), normalizedToFloat(alpha)); } void ContextPrivateColor4x(PrivateState *privateState, PrivateStateCache *privateStateCache, GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha) { ContextPrivateColor4f(privateState, privateStateCache, ConvertFixedToFloat(red), ConvertFixedToFloat(green), ConvertFixedToFloat(blue), ConvertFixedToFloat(alpha)); } void ContextPrivateFogf(PrivateState *privateState, PrivateStateCache *privateStateCache, GLenum pname, GLfloat param) { ContextPrivateFogfv(privateState, privateStateCache, pname, ¶m); } void ContextPrivateFogfv(PrivateState *privateState, PrivateStateCache *privateStateCache, GLenum pname, const GLfloat *params) { SetFogParameters(privateState->getMutableGLES1State(), pname, params); } void ContextPrivateFogx(PrivateState *privateState, PrivateStateCache *privateStateCache, GLenum pname, GLfixed param) { if (GetFogParameterCount(pname) == 1) { GLfloat paramf = pname == GL_FOG_MODE ? ConvertToGLenum(param) : ConvertFixedToFloat(param); ContextPrivateFogfv(privateState, privateStateCache, pname, ¶mf); } else { UNREACHABLE(); } } void ContextPrivateFogxv(PrivateState *privateState, PrivateStateCache *privateStateCache, GLenum pname, const GLfixed *params) { int paramCount = GetFogParameterCount(pname); if (paramCount > 0) { GLfloat paramsf[4]; for (int i = 0; i < paramCount; i++) { paramsf[i] = pname == GL_FOG_MODE ? ConvertToGLenum(params[i]) : ConvertFixedToFloat(params[i]); } ContextPrivateFogfv(privateState, privateStateCache, pname, paramsf); } else { UNREACHABLE(); } } void ContextPrivateFrustumf(PrivateState *privateState, PrivateStateCache *privateStateCache, GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat n, GLfloat f) { privateState->getMutableGLES1State()->multMatrix(angle::Mat4::Frustum(l, r, b, t, n, f)); } void ContextPrivateFrustumx(PrivateState *privateState, PrivateStateCache *privateStateCache, GLfixed l, GLfixed r, GLfixed b, GLfixed t, GLfixed n, GLfixed f) { ContextPrivateFrustumf(privateState, privateStateCache, ConvertFixedToFloat(l), ConvertFixedToFloat(r), ConvertFixedToFloat(b), ConvertFixedToFloat(t), ConvertFixedToFloat(n), ConvertFixedToFloat(f)); } void ContextPrivateGetClipPlanef(PrivateState *privateState, PrivateStateCache *privateStateCache, GLenum plane, GLfloat *equation) { privateState->gles1().getClipPlane(plane - GL_CLIP_PLANE0, equation); } void ContextPrivateGetClipPlanex(PrivateState *privateState, PrivateStateCache *privateStateCache, GLenum plane, GLfixed *equation) { GLfloat equationf[4] = {}; ContextPrivateGetClipPlanef(privateState, privateStateCache, plane, equationf); for (int i = 0; i < 4; i++) { equation[i] = ConvertFloatToFixed(equationf[i]); } } void ContextPrivateGetLightfv(PrivateState *privateState, PrivateStateCache *privateStateCache, GLenum light, LightParameter pname, GLfloat *params) { GetLightParameters(privateState->getMutableGLES1State(), light, pname, params); } void ContextPrivateGetLightxv(PrivateState *privateState, PrivateStateCache *privateStateCache, GLenum light, LightParameter pname, GLfixed *params) { GLfloat paramsf[4]; ContextPrivateGetLightfv(privateState, privateStateCache, light, pname, paramsf); for (unsigned int i = 0; i < GetLightParameterCount(pname); i++) { params[i] = ConvertFloatToFixed(paramsf[i]); } } void ContextPrivateGetMaterialfv(PrivateState *privateState, PrivateStateCache *privateStateCache, GLenum face, MaterialParameter pname, GLfloat *params) { GetMaterialParameters(privateState->getMutableGLES1State(), face, pname, params); } void ContextPrivateGetMaterialxv(PrivateState *privateState, PrivateStateCache *privateStateCache, GLenum face, MaterialParameter pname, GLfixed *params) { GLfloat paramsf[4]; ContextPrivateGetMaterialfv(privateState, privateStateCache, face, pname, paramsf); for (unsigned int i = 0; i < GetMaterialParameterCount(pname); i++) { params[i] = ConvertFloatToFixed(paramsf[i]); } } void ContextPrivateGetTexEnvfv(PrivateState *privateState, PrivateStateCache *privateStateCache, TextureEnvTarget target, TextureEnvParameter pname, GLfloat *params) { GetTextureEnv(privateState->getActiveSampler(), privateState->getMutableGLES1State(), target, pname, params); } void ContextPrivateGetTexEnviv(PrivateState *privateState, PrivateStateCache *privateStateCache, TextureEnvTarget target, TextureEnvParameter pname, GLint *params) { GLfloat paramsf[4]; ContextPrivateGetTexEnvfv(privateState, privateStateCache, target, pname, paramsf); ConvertTextureEnvToInt(pname, paramsf, params); } void ContextPrivateGetTexEnvxv(PrivateState *privateState, PrivateStateCache *privateStateCache, TextureEnvTarget target, TextureEnvParameter pname, GLfixed *params) { GLfloat paramsf[4]; ContextPrivateGetTexEnvfv(privateState, privateStateCache, target, pname, paramsf); ConvertTextureEnvToFixed(pname, paramsf, params); } void ContextPrivateLightModelf(PrivateState *privateState, PrivateStateCache *privateStateCache, GLenum pname, GLfloat param) { ContextPrivateLightModelfv(privateState, privateStateCache, pname, ¶m); } void ContextPrivateLightModelfv(PrivateState *privateState, PrivateStateCache *privateStateCache, GLenum pname, const GLfloat *params) { SetLightModelParameters(privateState->getMutableGLES1State(), pname, params); } void ContextPrivateLightModelx(PrivateState *privateState, PrivateStateCache *privateStateCache, GLenum pname, GLfixed param) { ContextPrivateLightModelf(privateState, privateStateCache, pname, ConvertFixedToFloat(param)); } void ContextPrivateLightModelxv(PrivateState *privateState, PrivateStateCache *privateStateCache, GLenum pname, const GLfixed *param) { GLfloat paramsf[4]; for (unsigned int i = 0; i < GetLightModelParameterCount(pname); i++) { paramsf[i] = ConvertFixedToFloat(param[i]); } ContextPrivateLightModelfv(privateState, privateStateCache, pname, paramsf); } void ContextPrivateLightf(PrivateState *privateState, PrivateStateCache *privateStateCache, GLenum light, LightParameter pname, GLfloat param) { ContextPrivateLightfv(privateState, privateStateCache, light, pname, ¶m); } void ContextPrivateLightfv(PrivateState *privateState, PrivateStateCache *privateStateCache, GLenum light, LightParameter pname, const GLfloat *params) { SetLightParameters(privateState->getMutableGLES1State(), light, pname, params); } void ContextPrivateLightx(PrivateState *privateState, PrivateStateCache *privateStateCache, GLenum light, LightParameter pname, GLfixed param) { ContextPrivateLightf(privateState, privateStateCache, light, pname, ConvertFixedToFloat(param)); } void ContextPrivateLightxv(PrivateState *privateState, PrivateStateCache *privateStateCache, GLenum light, LightParameter pname, const GLfixed *params) { GLfloat paramsf[4]; for (unsigned int i = 0; i < GetLightParameterCount(pname); i++) { paramsf[i] = ConvertFixedToFloat(params[i]); } ContextPrivateLightfv(privateState, privateStateCache, light, pname, paramsf); } void ContextPrivateLoadIdentity(PrivateState *privateState, PrivateStateCache *privateStateCache) { privateState->getMutableGLES1State()->loadMatrix(angle::Mat4()); } void ContextPrivateLoadMatrixf(PrivateState *privateState, PrivateStateCache *privateStateCache, const GLfloat *m) { privateState->getMutableGLES1State()->loadMatrix(angle::Mat4(m)); } void ContextPrivateLoadMatrixx(PrivateState *privateState, PrivateStateCache *privateStateCache, const GLfixed *m) { privateState->getMutableGLES1State()->loadMatrix(FixedMatrixToMat4(m)); } void ContextPrivateMaterialf(PrivateState *privateState, PrivateStateCache *privateStateCache, GLenum face, MaterialParameter pname, GLfloat param) { ContextPrivateMaterialfv(privateState, privateStateCache, face, pname, ¶m); } void ContextPrivateMaterialfv(PrivateState *privateState, PrivateStateCache *privateStateCache, GLenum face, MaterialParameter pname, const GLfloat *params) { SetMaterialParameters(privateState->getMutableGLES1State(), face, pname, params); } void ContextPrivateMaterialx(PrivateState *privateState, PrivateStateCache *privateStateCache, GLenum face, MaterialParameter pname, GLfixed param) { ContextPrivateMaterialf(privateState, privateStateCache, face, pname, ConvertFixedToFloat(param)); } void ContextPrivateMaterialxv(PrivateState *privateState, PrivateStateCache *privateStateCache, GLenum face, MaterialParameter pname, const GLfixed *param) { GLfloat paramsf[4]; for (unsigned int i = 0; i < GetMaterialParameterCount(pname); i++) { paramsf[i] = ConvertFixedToFloat(param[i]); } ContextPrivateMaterialfv(privateState, privateStateCache, face, pname, paramsf); } void ContextPrivateMatrixMode(PrivateState *privateState, PrivateStateCache *privateStateCache, MatrixType mode) { privateState->getMutableGLES1State()->setMatrixMode(mode); } void ContextPrivateMultMatrixf(PrivateState *privateState, PrivateStateCache *privateStateCache, const GLfloat *m) { privateState->getMutableGLES1State()->multMatrix(angle::Mat4(m)); } void ContextPrivateMultMatrixx(PrivateState *privateState, PrivateStateCache *privateStateCache, const GLfixed *m) { privateState->getMutableGLES1State()->multMatrix(FixedMatrixToMat4(m)); } void ContextPrivateMultiTexCoord4f(PrivateState *privateState, PrivateStateCache *privateStateCache, GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q) { unsigned int unit = target - GL_TEXTURE0; ASSERT(target >= GL_TEXTURE0 && unit < privateState->getCaps().maxMultitextureUnits); privateState->getMutableGLES1State()->setCurrentTextureCoords(unit, {s, t, r, q}); } void ContextPrivateMultiTexCoord4x(PrivateState *privateState, PrivateStateCache *privateStateCache, GLenum texture, GLfixed s, GLfixed t, GLfixed r, GLfixed q) { ContextPrivateMultiTexCoord4f(privateState, privateStateCache, texture, ConvertFixedToFloat(s), ConvertFixedToFloat(t), ConvertFixedToFloat(r), ConvertFixedToFloat(q)); } void ContextPrivateNormal3f(PrivateState *privateState, PrivateStateCache *privateStateCache, GLfloat nx, GLfloat ny, GLfloat nz) { privateState->getMutableGLES1State()->setCurrentNormal({nx, ny, nz}); } void ContextPrivateNormal3x(PrivateState *privateState, PrivateStateCache *privateStateCache, GLfixed nx, GLfixed ny, GLfixed nz) { ContextPrivateNormal3f(privateState, privateStateCache, ConvertFixedToFloat(nx), ConvertFixedToFloat(ny), ConvertFixedToFloat(nz)); } void ContextPrivateOrthof(PrivateState *privateState, PrivateStateCache *privateStateCache, GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar) { privateState->getMutableGLES1State()->multMatrix( angle::Mat4::Ortho(left, right, bottom, top, zNear, zFar)); } void ContextPrivateOrthox(PrivateState *privateState, PrivateStateCache *privateStateCache, GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar) { ContextPrivateOrthof(privateState, privateStateCache, ConvertFixedToFloat(left), ConvertFixedToFloat(right), ConvertFixedToFloat(bottom), ConvertFixedToFloat(top), ConvertFixedToFloat(zNear), ConvertFixedToFloat(zFar)); } void ContextPrivatePointParameterf(PrivateState *privateState, PrivateStateCache *privateStateCache, PointParameter pname, GLfloat param) { ContextPrivatePointParameterfv(privateState, privateStateCache, pname, ¶m); } void ContextPrivatePointParameterfv(PrivateState *privateState, PrivateStateCache *privateStateCache, PointParameter pname, const GLfloat *params) { SetPointParameter(privateState->getMutableGLES1State(), pname, params); } void ContextPrivatePointParameterx(PrivateState *privateState, PrivateStateCache *privateStateCache, PointParameter pname, GLfixed param) { ContextPrivatePointParameterf(privateState, privateStateCache, pname, ConvertFixedToFloat(param)); } void ContextPrivatePointParameterxv(PrivateState *privateState, PrivateStateCache *privateStateCache, PointParameter pname, const GLfixed *params) { GLfloat paramsf[4] = {}; for (unsigned int i = 0; i < GetPointParameterCount(pname); i++) { paramsf[i] = ConvertFixedToFloat(params[i]); } ContextPrivatePointParameterfv(privateState, privateStateCache, pname, paramsf); } void ContextPrivatePointSize(PrivateState *privateState, PrivateStateCache *privateStateCache, GLfloat size) { SetPointSize(privateState->getMutableGLES1State(), size); } void ContextPrivatePointSizex(PrivateState *privateState, PrivateStateCache *privateStateCache, GLfixed size) { ContextPrivatePointSize(privateState, privateStateCache, ConvertFixedToFloat(size)); } void ContextPrivatePopMatrix(PrivateState *privateState, PrivateStateCache *privateStateCache) { privateState->getMutableGLES1State()->popMatrix(); } void ContextPrivatePushMatrix(PrivateState *privateState, PrivateStateCache *privateStateCache) { privateState->getMutableGLES1State()->pushMatrix(); } void ContextPrivateRotatef(PrivateState *privateState, PrivateStateCache *privateStateCache, GLfloat angle, GLfloat x, GLfloat y, GLfloat z) { privateState->getMutableGLES1State()->multMatrix( angle::Mat4::Rotate(angle, angle::Vector3(x, y, z))); } void ContextPrivateRotatex(PrivateState *privateState, PrivateStateCache *privateStateCache, GLfixed angle, GLfixed x, GLfixed y, GLfixed z) { ContextPrivateRotatef(privateState, privateStateCache, ConvertFixedToFloat(angle), ConvertFixedToFloat(x), ConvertFixedToFloat(y), ConvertFixedToFloat(z)); } void ContextPrivateScalef(PrivateState *privateState, PrivateStateCache *privateStateCache, GLfloat x, GLfloat y, GLfloat z) { privateState->getMutableGLES1State()->multMatrix(angle::Mat4::Scale(angle::Vector3(x, y, z))); } void ContextPrivateScalex(PrivateState *privateState, PrivateStateCache *privateStateCache, GLfixed x, GLfixed y, GLfixed z) { ContextPrivateScalef(privateState, privateStateCache, ConvertFixedToFloat(x), ConvertFixedToFloat(y), ConvertFixedToFloat(z)); } void ContextPrivateShadeModel(PrivateState *privateState, PrivateStateCache *privateStateCache, ShadingModel model) { privateState->getMutableGLES1State()->setShadeModel(model); } void ContextPrivateTexEnvf(PrivateState *privateState, PrivateStateCache *privateStateCache, TextureEnvTarget target, TextureEnvParameter pname, GLfloat param) { ContextPrivateTexEnvfv(privateState, privateStateCache, target, pname, ¶m); } void ContextPrivateTexEnvfv(PrivateState *privateState, PrivateStateCache *privateStateCache, TextureEnvTarget target, TextureEnvParameter pname, const GLfloat *params) { SetTextureEnv(privateState->getActiveSampler(), privateState->getMutableGLES1State(), target, pname, params); } void ContextPrivateTexEnvi(PrivateState *privateState, PrivateStateCache *privateStateCache, TextureEnvTarget target, TextureEnvParameter pname, GLint param) { ContextPrivateTexEnviv(privateState, privateStateCache, target, pname, ¶m); } void ContextPrivateTexEnviv(PrivateState *privateState, PrivateStateCache *privateStateCache, TextureEnvTarget target, TextureEnvParameter pname, const GLint *params) { GLfloat paramsf[4] = {}; ConvertTextureEnvFromInt(pname, params, paramsf); ContextPrivateTexEnvfv(privateState, privateStateCache, target, pname, paramsf); } void ContextPrivateTexEnvx(PrivateState *privateState, PrivateStateCache *privateStateCache, TextureEnvTarget target, TextureEnvParameter pname, GLfixed param) { ContextPrivateTexEnvxv(privateState, privateStateCache, target, pname, ¶m); } void ContextPrivateTexEnvxv(PrivateState *privateState, PrivateStateCache *privateStateCache, TextureEnvTarget target, TextureEnvParameter pname, const GLfixed *params) { GLfloat paramsf[4] = {}; ConvertTextureEnvFromFixed(pname, params, paramsf); ContextPrivateTexEnvfv(privateState, privateStateCache, target, pname, paramsf); } void ContextPrivateTranslatef(PrivateState *privateState, PrivateStateCache *privateStateCache, GLfloat x, GLfloat y, GLfloat z) { privateState->getMutableGLES1State()->multMatrix( angle::Mat4::Translate(angle::Vector3(x, y, z))); } void ContextPrivateTranslatex(PrivateState *privateState, PrivateStateCache *privateStateCache, GLfixed x, GLfixed y, GLfixed z) { ContextPrivateTranslatef(privateState, privateStateCache, ConvertFixedToFloat(x), ConvertFixedToFloat(y), ConvertFixedToFloat(z)); } } // namespace gl