summaryrefslogtreecommitdiffstats
path: root/gfx/angle/checkout/src/libANGLE/GLES1Renderer.h
diff options
context:
space:
mode:
Diffstat (limited to 'gfx/angle/checkout/src/libANGLE/GLES1Renderer.h')
-rw-r--r--gfx/angle/checkout/src/libANGLE/GLES1Renderer.h340
1 files changed, 340 insertions, 0 deletions
diff --git a/gfx/angle/checkout/src/libANGLE/GLES1Renderer.h b/gfx/angle/checkout/src/libANGLE/GLES1Renderer.h
new file mode 100644
index 0000000000..5694b79752
--- /dev/null
+++ b/gfx/angle/checkout/src/libANGLE/GLES1Renderer.h
@@ -0,0 +1,340 @@
+//
+// Copyright 2018 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.
+//
+
+// GLES1Renderer.h: Defines GLES1 emulation rendering operations on top of a GLES3
+// context. Used by Context.h.
+
+#ifndef LIBANGLE_GLES1_RENDERER_H_
+#define LIBANGLE_GLES1_RENDERER_H_
+
+#include "GLES1State.h"
+#include "angle_gl.h"
+#include "common/angleutils.h"
+#include "libANGLE/angletypes.h"
+
+#include <memory>
+#include <string>
+#include <unordered_map>
+
+namespace gl
+{
+class Context;
+class GLES1State;
+class Program;
+class State;
+class Shader;
+class ShaderProgramManager;
+
+enum class GLES1StateEnables : uint64_t
+{
+ Lighting = 0,
+ Fog = 1,
+ ClipPlanes = 2,
+ DrawTexture = 3,
+ PointRasterization = 4,
+ PointSprite = 5,
+ RescaleNormal = 6,
+ Normalize = 7,
+ AlphaTest = 8,
+ ShadeModelFlat = 9,
+ ColorMaterial = 10,
+ LightModelTwoSided = 11,
+ LogicOpThroughFramebufferFetch = 12,
+
+ InvalidEnum = 13,
+ EnumCount = 13,
+};
+
+constexpr int kClipPlaneCount = 6;
+constexpr int kTexUnitCount = 4;
+constexpr int kLightCount = 8;
+
+using GLES1StateEnabledBitSet = angle::PackedEnumBitSet<GLES1StateEnables, uint64_t>;
+
+struct GLES1ShaderState
+{
+ GLES1ShaderState();
+ ~GLES1ShaderState();
+ GLES1ShaderState(const GLES1ShaderState &other);
+
+ size_t hash() const;
+
+ GLES1StateEnabledBitSet mGLES1StateEnabled;
+
+ using BoolLightArray = bool[kLightCount];
+ using BoolTexArray = bool[kTexUnitCount];
+ using BoolClipPlaneArray = bool[kClipPlaneCount];
+ using IntTexArray = int[kTexUnitCount];
+
+ BoolTexArray tex2DEnables = {false, false, false, false};
+ BoolTexArray texCubeEnables = {false, false, false, false};
+
+ IntTexArray tex2DFormats = {GL_RGBA, GL_RGBA, GL_RGBA, GL_RGBA};
+
+ IntTexArray texEnvModes = {};
+ IntTexArray texCombineRgbs = {};
+ IntTexArray texCombineAlphas = {};
+ IntTexArray texCombineSrc0Rgbs = {};
+ IntTexArray texCombineSrc0Alphas = {};
+ IntTexArray texCombineSrc1Rgbs = {};
+ IntTexArray texCombineSrc1Alphas = {};
+ IntTexArray texCombineSrc2Rgbs = {};
+ IntTexArray texCombineSrc2Alphas = {};
+ IntTexArray texCombineOp0Rgbs = {};
+ IntTexArray texCombineOp0Alphas = {};
+ IntTexArray texCombineOp1Rgbs = {};
+ IntTexArray texCombineOp1Alphas = {};
+ IntTexArray texCombineOp2Rgbs = {};
+ IntTexArray texCombineOp2Alphas = {};
+
+ BoolTexArray pointSpriteCoordReplaces = {};
+
+ BoolLightArray lightEnables = {};
+
+ BoolClipPlaneArray clipPlaneEnables = {};
+
+ AlphaTestFunc alphaTestFunc = {};
+
+ FogMode fogMode = {};
+};
+
+bool operator==(const GLES1ShaderState &a, const GLES1ShaderState &b);
+bool operator!=(const GLES1ShaderState &a, const GLES1ShaderState &b);
+
+} // namespace gl
+
+namespace std
+{
+template <>
+struct hash<gl::GLES1ShaderState>
+{
+ size_t operator()(const gl::GLES1ShaderState &key) const { return key.hash(); }
+};
+} // namespace std
+
+namespace gl
+{
+
+class GLES1Renderer final : angle::NonCopyable
+{
+ public:
+ GLES1Renderer();
+ ~GLES1Renderer();
+
+ void onDestroy(Context *context, State *state);
+
+ angle::Result prepareForDraw(PrimitiveMode mode, Context *context, State *glState);
+
+ static int VertexArrayIndex(ClientVertexArrayType type, const GLES1State &gles1);
+ static ClientVertexArrayType VertexArrayType(int attribIndex);
+ static int TexCoordArrayIndex(unsigned int unit);
+
+ void drawTexture(Context *context,
+ State *glState,
+ float x,
+ float y,
+ float z,
+ float width,
+ float height);
+
+ private:
+ using Mat4Uniform = float[16];
+ using Vec4Uniform = float[4];
+ using Vec3Uniform = float[3];
+
+ Shader *getShader(ShaderProgramID handle) const;
+ Program *getProgram(ShaderProgramID handle) const;
+
+ angle::Result compileShader(Context *context,
+ ShaderType shaderType,
+ const char *src,
+ ShaderProgramID *shaderOut);
+ angle::Result linkProgram(Context *context,
+ State *glState,
+ ShaderProgramID vshader,
+ ShaderProgramID fshader,
+ const angle::HashMap<GLint, std::string> &attribLocs,
+ ShaderProgramID *programOut);
+ angle::Result initializeRendererProgram(Context *context, State *glState);
+
+ void setUniform1i(Context *context,
+ Program *programObject,
+ UniformLocation location,
+ GLint value);
+ void setUniform1ui(Program *programObject, UniformLocation location, GLuint value);
+ void setUniform1iv(Context *context,
+ Program *programObject,
+ UniformLocation location,
+ GLint count,
+ const GLint *value);
+ void setUniformMatrix4fv(Program *programObject,
+ UniformLocation location,
+ GLint count,
+ GLboolean transpose,
+ const GLfloat *value);
+ void setUniform4fv(Program *programObject,
+ UniformLocation location,
+ GLint count,
+ const GLfloat *value);
+ void setUniform3fv(Program *programObject,
+ UniformLocation location,
+ GLint count,
+ const GLfloat *value);
+ void setUniform2fv(Program *programObject,
+ UniformLocation location,
+ GLint count,
+ const GLfloat *value);
+ void setUniform1f(Program *programObject, UniformLocation location, GLfloat value);
+ void setUniform1fv(Program *programObject,
+ UniformLocation location,
+ GLint count,
+ const GLfloat *value);
+
+ void setAttributesEnabled(Context *context, State *glState, AttributesMask mask);
+
+ static constexpr int kVertexAttribIndex = 0;
+ static constexpr int kNormalAttribIndex = 1;
+ static constexpr int kColorAttribIndex = 2;
+ static constexpr int kPointSizeAttribIndex = 3;
+ static constexpr int kTextureCoordAttribIndexBase = 4;
+
+ bool mRendererProgramInitialized;
+ ShaderProgramManager *mShaderPrograms;
+
+ GLES1ShaderState mShaderState = {};
+
+ const char *getShaderBool(GLES1StateEnables state);
+ void addShaderDefine(std::stringstream &outStream,
+ GLES1StateEnables state,
+ const char *enableString);
+ void addShaderInt(std::stringstream &outStream, const char *name, int value);
+ void addShaderIntTexArray(std::stringstream &outStream,
+ const char *texString,
+ GLES1ShaderState::IntTexArray &texState);
+ void addShaderBoolTexArray(std::stringstream &outStream,
+ const char *texString,
+ GLES1ShaderState::BoolTexArray &texState);
+ void addShaderBoolLightArray(std::stringstream &outStream,
+ const char *name,
+ GLES1ShaderState::BoolLightArray &value);
+ void addShaderBoolClipPlaneArray(std::stringstream &outStream,
+ const char *name,
+ GLES1ShaderState::BoolClipPlaneArray &value);
+ void addVertexShaderDefs(std::stringstream &outStream);
+ void addFragmentShaderDefs(std::stringstream &outStream);
+
+ struct GLES1ProgramState
+ {
+ ShaderProgramID program;
+
+ UniformLocation projMatrixLoc;
+ UniformLocation modelviewMatrixLoc;
+ UniformLocation textureMatrixLoc;
+ UniformLocation modelviewInvTrLoc;
+
+ // Texturing
+ std::array<UniformLocation, kTexUnitCount> tex2DSamplerLocs;
+ std::array<UniformLocation, kTexUnitCount> texCubeSamplerLocs;
+
+ UniformLocation textureEnvColorLoc;
+ UniformLocation rgbScaleLoc;
+ UniformLocation alphaScaleLoc;
+
+ // Alpha test
+ UniformLocation alphaTestRefLoc;
+
+ // Shading, materials, and lighting
+ UniformLocation materialAmbientLoc;
+ UniformLocation materialDiffuseLoc;
+ UniformLocation materialSpecularLoc;
+ UniformLocation materialEmissiveLoc;
+ UniformLocation materialSpecularExponentLoc;
+
+ UniformLocation lightModelSceneAmbientLoc;
+
+ UniformLocation lightAmbientsLoc;
+ UniformLocation lightDiffusesLoc;
+ UniformLocation lightSpecularsLoc;
+ UniformLocation lightPositionsLoc;
+ UniformLocation lightDirectionsLoc;
+ UniformLocation lightSpotlightExponentsLoc;
+ UniformLocation lightSpotlightCutoffAnglesLoc;
+ UniformLocation lightAttenuationConstsLoc;
+ UniformLocation lightAttenuationLinearsLoc;
+ UniformLocation lightAttenuationQuadraticsLoc;
+
+ // Fog
+ UniformLocation fogDensityLoc;
+ UniformLocation fogStartLoc;
+ UniformLocation fogEndLoc;
+ UniformLocation fogColorLoc;
+
+ // Clip planes
+ UniformLocation clipPlanesLoc;
+
+ // Logic op
+ UniformLocation logicOpLoc;
+
+ // Point rasterization
+ UniformLocation pointSizeMinLoc;
+ UniformLocation pointSizeMaxLoc;
+ UniformLocation pointDistanceAttenuationLoc;
+
+ // Draw texture
+ UniformLocation drawTextureCoordsLoc;
+ UniformLocation drawTextureDimsLoc;
+ UniformLocation drawTextureNormalizedCropRectLoc;
+ };
+
+ struct GLES1UniformBuffers
+ {
+ std::array<Mat4Uniform, kTexUnitCount> textureMatrices;
+
+ std::array<Vec4Uniform, kTexUnitCount> texEnvColors;
+ std::array<GLfloat, kTexUnitCount> texEnvRgbScales;
+ std::array<GLfloat, kTexUnitCount> texEnvAlphaScales;
+
+ // Lighting
+ std::array<Vec4Uniform, kLightCount> lightAmbients;
+ std::array<Vec4Uniform, kLightCount> lightDiffuses;
+ std::array<Vec4Uniform, kLightCount> lightSpeculars;
+ std::array<Vec4Uniform, kLightCount> lightPositions;
+ std::array<Vec3Uniform, kLightCount> lightDirections;
+ std::array<GLfloat, kLightCount> spotlightExponents;
+ std::array<GLfloat, kLightCount> spotlightCutoffAngles;
+ std::array<GLfloat, kLightCount> attenuationConsts;
+ std::array<GLfloat, kLightCount> attenuationLinears;
+ std::array<GLfloat, kLightCount> attenuationQuadratics;
+
+ // Clip planes
+ std::array<Vec4Uniform, kClipPlaneCount> clipPlanes;
+
+ // Texture crop rectangles
+ std::array<Vec4Uniform, kTexUnitCount> texCropRects;
+ };
+
+ struct GLES1UberShaderState
+ {
+ GLES1UniformBuffers uniformBuffers;
+ GLES1ProgramState programState;
+ };
+
+ GLES1UberShaderState &getUberShaderState()
+ {
+ ASSERT(mUberShaderState.find(mShaderState) != mUberShaderState.end());
+ return mUberShaderState[mShaderState];
+ }
+
+ angle::HashMap<GLES1ShaderState, GLES1UberShaderState> mUberShaderState;
+
+ bool mDrawTextureEnabled = false;
+ GLfloat mDrawTextureCoords[4] = {0.0f, 0.0f, 0.0f, 0.0f};
+ GLfloat mDrawTextureDims[2] = {0.0f, 0.0f};
+};
+
+} // namespace gl
+
+#endif // LIBANGLE_GLES1_RENDERER_H_
generated by cgit v1.2.3 (git 2.39.1) at 2024-06-10 11:38:27 +0000