apatrick@chromium.org | ea09f9b | 2012-06-08 00:45:32 +0000 | [diff] [blame] | 1 | // |
Geoff Lang | 48dcae7 | 2014-02-05 16:28:24 -0500 | [diff] [blame] | 2 | // Copyright (c) 2002-2014 The ANGLE Project Authors. All rights reserved. |
apatrick@chromium.org | ea09f9b | 2012-06-08 00:45:32 +0000 | [diff] [blame] | 3 | // Use of this source code is governed by a BSD-style license that can be |
| 4 | // found in the LICENSE file. |
| 5 | // |
| 6 | |
| 7 | // Program.h: Defines the gl::Program class. Implements GL program objects |
| 8 | // and related functionality. [OpenGL ES 2.0.24] section 2.10.3 page 28. |
| 9 | |
| 10 | #ifndef LIBGLESV2_PROGRAM_BINARY_H_ |
| 11 | #define LIBGLESV2_PROGRAM_BINARY_H_ |
| 12 | |
shannon.woods@transgaming.com | d2811d6 | 2013-02-28 23:11:19 +0000 | [diff] [blame] | 13 | #include "common/RefCountObject.h" |
| 14 | #include "angletypes.h" |
shannonwoods@chromium.org | a2ecfcc | 2013-05-30 00:11:59 +0000 | [diff] [blame] | 15 | #include "common/mathutil.h" |
daniel@transgaming.com | 15186aa | 2012-12-20 21:08:23 +0000 | [diff] [blame] | 16 | #include "libGLESv2/Uniform.h" |
shannon.woods@transgaming.com | d2811d6 | 2013-02-28 23:11:19 +0000 | [diff] [blame] | 17 | #include "libGLESv2/Shader.h" |
shannon.woods@transgaming.com | 486d9e9 | 2013-02-28 23:15:41 +0000 | [diff] [blame] | 18 | #include "libGLESv2/Constants.h" |
Brandon Jones | c7a4104 | 2014-06-23 12:03:25 -0700 | [diff] [blame] | 19 | #include "libGLESv2/renderer/d3d/VertexDataManager.h" |
Brandon Jones | d8d7243 | 2014-08-22 15:11:23 -0700 | [diff] [blame] | 20 | #include "libGLESv2/renderer/d3d/DynamicHLSL.h" |
apatrick@chromium.org | ea09f9b | 2012-06-08 00:45:32 +0000 | [diff] [blame] | 21 | |
Geoff Lang | 0b7eef7 | 2014-06-12 14:10:47 -0400 | [diff] [blame] | 22 | #include "angle_gl.h" |
| 23 | |
| 24 | #include <string> |
| 25 | #include <vector> |
| 26 | |
Jamie Madill | 3f2e61d | 2014-09-05 10:38:05 -0400 | [diff] [blame] | 27 | // TODO(jmadill): place this in workarounds library |
| 28 | #define ANGLE_WORKAROUND_ENABLED 1 |
| 29 | #define ANGLE_WORKAROUND_DISABLED 2 |
| 30 | #define ANGLE_MRT_PERF_WORKAROUND ANGLE_WORKAROUND_ENABLED |
| 31 | |
Jamie Madill | bf9cce2 | 2014-07-18 10:33:09 -0400 | [diff] [blame] | 32 | namespace sh |
| 33 | { |
| 34 | class HLSLBlockEncoder; |
| 35 | } |
| 36 | |
Geoff Lang | 0b7eef7 | 2014-06-12 14:10:47 -0400 | [diff] [blame] | 37 | #include <GLES3/gl3.h> |
| 38 | #include <GLES2/gl2.h> |
| 39 | #include <GLES2/gl2ext.h> |
| 40 | |
| 41 | #include <string> |
| 42 | #include <vector> |
| 43 | |
shannon.woods@transgaming.com | d2811d6 | 2013-02-28 23:11:19 +0000 | [diff] [blame] | 44 | namespace rx |
| 45 | { |
| 46 | class ShaderExecutable; |
| 47 | class Renderer; |
shannon.woods@transgaming.com | 0b60014 | 2013-02-28 23:15:04 +0000 | [diff] [blame] | 48 | struct TranslatedAttribute; |
Jamie Madill | 8ff21ae | 2014-02-04 16:04:05 -0500 | [diff] [blame] | 49 | class UniformStorage; |
Brandon Jones | c9610c5 | 2014-08-25 17:02:59 -0700 | [diff] [blame] | 50 | class ProgramImpl; |
shannon.woods@transgaming.com | d2811d6 | 2013-02-28 23:11:19 +0000 | [diff] [blame] | 51 | } |
daniel@transgaming.com | a9c7142 | 2012-11-28 20:58:45 +0000 | [diff] [blame] | 52 | |
apatrick@chromium.org | ea09f9b | 2012-06-08 00:45:32 +0000 | [diff] [blame] | 53 | namespace gl |
| 54 | { |
Brandon Jones | 43a53e2 | 2014-08-28 16:23:22 -0700 | [diff] [blame] | 55 | struct Caps; |
Brandon Jones | 7162096 | 2014-08-20 14:04:59 -0700 | [diff] [blame] | 56 | class Shader; |
shannon.woods@transgaming.com | d2811d6 | 2013-02-28 23:11:19 +0000 | [diff] [blame] | 57 | class InfoLog; |
| 58 | class AttributeBindings; |
shannonwoods@chromium.org | 1bddfb9 | 2013-05-30 00:11:29 +0000 | [diff] [blame] | 59 | class Buffer; |
Geoff Lang | 04fb89a | 2014-06-09 15:05:36 -0400 | [diff] [blame] | 60 | class Framebuffer; |
apatrick@chromium.org | ea09f9b | 2012-06-08 00:45:32 +0000 | [diff] [blame] | 61 | |
apatrick@chromium.org | ea09f9b | 2012-06-08 00:45:32 +0000 | [diff] [blame] | 62 | // Struct used for correlating uniforms/elements of uniform arrays to handles |
Jamie Madill | 63491ea | 2013-06-06 11:56:45 -0400 | [diff] [blame] | 63 | struct VariableLocation |
apatrick@chromium.org | ea09f9b | 2012-06-08 00:45:32 +0000 | [diff] [blame] | 64 | { |
Jamie Madill | 63491ea | 2013-06-06 11:56:45 -0400 | [diff] [blame] | 65 | VariableLocation() |
apatrick@chromium.org | 90080e3 | 2012-07-09 22:15:33 +0000 | [diff] [blame] | 66 | { |
| 67 | } |
| 68 | |
Jamie Madill | 63491ea | 2013-06-06 11:56:45 -0400 | [diff] [blame] | 69 | VariableLocation(const std::string &name, unsigned int element, unsigned int index); |
apatrick@chromium.org | ea09f9b | 2012-06-08 00:45:32 +0000 | [diff] [blame] | 70 | |
| 71 | std::string name; |
| 72 | unsigned int element; |
| 73 | unsigned int index; |
| 74 | }; |
| 75 | |
Geoff Lang | 48dcae7 | 2014-02-05 16:28:24 -0500 | [diff] [blame] | 76 | struct LinkedVarying |
| 77 | { |
| 78 | LinkedVarying(); |
| 79 | LinkedVarying(const std::string &name, GLenum type, GLsizei size, const std::string &semanticName, |
| 80 | unsigned int semanticIndex, unsigned int semanticIndexCount); |
| 81 | |
| 82 | // Original GL name |
| 83 | std::string name; |
| 84 | |
| 85 | GLenum type; |
| 86 | GLsizei size; |
| 87 | |
| 88 | // DirectX semantic information |
| 89 | std::string semanticName; |
| 90 | unsigned int semanticIndex; |
| 91 | unsigned int semanticIndexCount; |
| 92 | }; |
| 93 | |
apatrick@chromium.org | ea09f9b | 2012-06-08 00:45:32 +0000 | [diff] [blame] | 94 | // This is the result of linking a program. It is the state that would be passed to ProgramBinary. |
daniel@transgaming.com | 989c1c8 | 2012-07-24 18:40:38 +0000 | [diff] [blame] | 95 | class ProgramBinary : public RefCountObject |
apatrick@chromium.org | ea09f9b | 2012-06-08 00:45:32 +0000 | [diff] [blame] | 96 | { |
| 97 | public: |
Brandon Jones | c9610c5 | 2014-08-25 17:02:59 -0700 | [diff] [blame] | 98 | explicit ProgramBinary(rx::ProgramImpl *impl); |
apatrick@chromium.org | ea09f9b | 2012-06-08 00:45:32 +0000 | [diff] [blame] | 99 | ~ProgramBinary(); |
| 100 | |
Brandon Jones | c9610c5 | 2014-08-25 17:02:59 -0700 | [diff] [blame] | 101 | rx::ProgramImpl *getImplementation() { return mProgram; } |
| 102 | const rx::ProgramImpl *getImplementation() const { return mProgram; } |
| 103 | |
Geoff Lang | 04fb89a | 2014-06-09 15:05:36 -0400 | [diff] [blame] | 104 | rx::ShaderExecutable *getPixelExecutableForFramebuffer(const Framebuffer *fbo); |
| 105 | rx::ShaderExecutable *getPixelExecutableForOutputLayout(const std::vector<GLenum> &outputLayout); |
Jamie Madill | 834e8b7 | 2014-04-11 13:33:58 -0400 | [diff] [blame] | 106 | rx::ShaderExecutable *getVertexExecutableForInputLayout(const VertexFormat inputLayout[MAX_VERTEX_ATTRIBS]); |
Jamie Madill | 8ff21ae | 2014-02-04 16:04:05 -0500 | [diff] [blame] | 107 | rx::ShaderExecutable *getGeometryExecutable() const; |
apatrick@chromium.org | ea09f9b | 2012-06-08 00:45:32 +0000 | [diff] [blame] | 108 | |
| 109 | GLuint getAttributeLocation(const char *name); |
| 110 | int getSemanticIndex(int attributeIndex); |
| 111 | |
Brandon Jones | 43a53e2 | 2014-08-28 16:23:22 -0700 | [diff] [blame] | 112 | GLint getSamplerMapping(SamplerType type, unsigned int samplerIndex, const Caps &caps); |
Geoff Lang | 76b10c9 | 2014-09-05 16:28:14 -0400 | [diff] [blame] | 113 | GLenum getSamplerTextureType(SamplerType type, unsigned int samplerIndex); |
apatrick@chromium.org | ea09f9b | 2012-06-08 00:45:32 +0000 | [diff] [blame] | 114 | GLint getUsedSamplerRange(SamplerType type); |
daniel@transgaming.com | 087e578 | 2012-09-17 21:28:47 +0000 | [diff] [blame] | 115 | bool usesPointSize() const; |
shannon.woods@transgaming.com | 3e773bb | 2013-01-25 21:55:47 +0000 | [diff] [blame] | 116 | bool usesPointSpriteEmulation() const; |
| 117 | bool usesGeometryShader() const; |
apatrick@chromium.org | ea09f9b | 2012-06-08 00:45:32 +0000 | [diff] [blame] | 118 | |
| 119 | GLint getUniformLocation(std::string name); |
shannonwoods@chromium.org | c2ed991 | 2013-05-30 00:05:33 +0000 | [diff] [blame] | 120 | GLuint getUniformIndex(std::string name); |
shannonwoods@chromium.org | 4276625 | 2013-05-30 00:07:12 +0000 | [diff] [blame] | 121 | GLuint getUniformBlockIndex(std::string name); |
Jamie Madill | 3639892 | 2014-05-20 14:51:53 -0400 | [diff] [blame] | 122 | void setUniform1fv(GLint location, GLsizei count, const GLfloat *v); |
| 123 | void setUniform2fv(GLint location, GLsizei count, const GLfloat *v); |
| 124 | void setUniform3fv(GLint location, GLsizei count, const GLfloat *v); |
| 125 | void setUniform4fv(GLint location, GLsizei count, const GLfloat *v); |
| 126 | void setUniform1iv(GLint location, GLsizei count, const GLint *v); |
| 127 | void setUniform2iv(GLint location, GLsizei count, const GLint *v); |
| 128 | void setUniform3iv(GLint location, GLsizei count, const GLint *v); |
| 129 | void setUniform4iv(GLint location, GLsizei count, const GLint *v); |
| 130 | void setUniform1uiv(GLint location, GLsizei count, const GLuint *v); |
| 131 | void setUniform2uiv(GLint location, GLsizei count, const GLuint *v); |
| 132 | void setUniform3uiv(GLint location, GLsizei count, const GLuint *v); |
| 133 | void setUniform4uiv(GLint location, GLsizei count, const GLuint *v); |
| 134 | void setUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); |
| 135 | void setUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); |
| 136 | void setUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); |
| 137 | void setUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); |
| 138 | void setUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); |
| 139 | void setUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); |
| 140 | void setUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); |
| 141 | void setUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); |
| 142 | void setUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); |
apatrick@chromium.org | ea09f9b | 2012-06-08 00:45:32 +0000 | [diff] [blame] | 143 | |
Jamie Madill | 99a1e98 | 2014-08-25 15:47:54 -0400 | [diff] [blame] | 144 | void getUniformfv(GLint location, GLfloat *params); |
| 145 | void getUniformiv(GLint location, GLint *params); |
| 146 | void getUniformuiv(GLint location, GLuint *params); |
apatrick@chromium.org | ea09f9b | 2012-06-08 00:45:32 +0000 | [diff] [blame] | 147 | |
apatrick@chromium.org | ea09f9b | 2012-06-08 00:45:32 +0000 | [diff] [blame] | 148 | void dirtyAllUniforms(); |
| 149 | void applyUniforms(); |
Brandon Jones | 43a53e2 | 2014-08-28 16:23:22 -0700 | [diff] [blame] | 150 | bool applyUniformBuffers(const std::vector<Buffer*> boundBuffers, const Caps &caps); |
apatrick@chromium.org | ea09f9b | 2012-06-08 00:45:32 +0000 | [diff] [blame] | 151 | |
Geoff Lang | 900013c | 2014-07-07 11:32:19 -0400 | [diff] [blame] | 152 | bool load(InfoLog &infoLog, GLenum binaryFormat, const void *binary, GLsizei length); |
| 153 | bool save(GLenum *binaryFormat, void *binary, GLsizei bufSize, GLsizei *length); |
apatrick@chromium.org | 90080e3 | 2012-07-09 22:15:33 +0000 | [diff] [blame] | 154 | GLint getLength(); |
| 155 | |
Brandon Jones | 7162096 | 2014-08-20 14:04:59 -0700 | [diff] [blame] | 156 | bool link(InfoLog &infoLog, const AttributeBindings &attributeBindings, Shader *fragmentShader, Shader *vertexShader, |
Brandon Jones | 43a53e2 | 2014-08-28 16:23:22 -0700 | [diff] [blame] | 157 | const std::vector<std::string>& transformFeedbackVaryings, GLenum transformFeedbackBufferMode, const Caps &caps); |
apatrick@chromium.org | ea09f9b | 2012-06-08 00:45:32 +0000 | [diff] [blame] | 158 | void getAttachedShaders(GLsizei maxCount, GLsizei *count, GLuint *shaders); |
| 159 | |
shannon.woods@transgaming.com | 4f4215f | 2013-02-28 23:14:58 +0000 | [diff] [blame] | 160 | void getActiveAttribute(GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, GLchar *name) const; |
| 161 | GLint getActiveAttributeCount() const; |
| 162 | GLint getActiveAttributeMaxLength() const; |
apatrick@chromium.org | ea09f9b | 2012-06-08 00:45:32 +0000 | [diff] [blame] | 163 | |
shannon.woods@transgaming.com | 4f4215f | 2013-02-28 23:14:58 +0000 | [diff] [blame] | 164 | void getActiveUniform(GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, GLchar *name) const; |
| 165 | GLint getActiveUniformCount() const; |
| 166 | GLint getActiveUniformMaxLength() const; |
shannonwoods@chromium.org | 2a9a9d2 | 2013-05-30 00:05:40 +0000 | [diff] [blame] | 167 | GLint getActiveUniformi(GLuint index, GLenum pname) const; |
Jamie Madill | 3639892 | 2014-05-20 14:51:53 -0400 | [diff] [blame] | 168 | bool isValidUniformLocation(GLint location) const; |
| 169 | LinkedUniform *getUniformByLocation(GLint location) const; |
Jamie Madill | 66d43d2 | 2014-07-11 17:02:03 -0400 | [diff] [blame] | 170 | LinkedUniform *getUniformByName(const std::string &name) const; |
apatrick@chromium.org | ea09f9b | 2012-06-08 00:45:32 +0000 | [diff] [blame] | 171 | |
shannonwoods@chromium.org | beb0278 | 2013-05-30 00:07:28 +0000 | [diff] [blame] | 172 | void getActiveUniformBlockName(GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName) const; |
shannonwoods@chromium.org | e7317ca | 2013-05-30 00:07:35 +0000 | [diff] [blame] | 173 | void getActiveUniformBlockiv(GLuint uniformBlockIndex, GLenum pname, GLint *params) const; |
shannonwoods@chromium.org | 70eb1ea | 2013-05-30 00:07:20 +0000 | [diff] [blame] | 174 | GLuint getActiveUniformBlockCount() const; |
shannonwoods@chromium.org | e684b58 | 2013-05-30 00:07:42 +0000 | [diff] [blame] | 175 | GLuint getActiveUniformBlockMaxLength() const; |
shannonwoods@chromium.org | 1bddfb9 | 2013-05-30 00:11:29 +0000 | [diff] [blame] | 176 | UniformBlock *getUniformBlockByIndex(GLuint blockIndex); |
shannonwoods@chromium.org | 70eb1ea | 2013-05-30 00:07:20 +0000 | [diff] [blame] | 177 | |
Jamie Madill | d1e78c9 | 2013-06-20 11:55:50 -0400 | [diff] [blame] | 178 | GLint getFragDataLocation(const char *name) const; |
| 179 | |
Geoff Lang | 48dcae7 | 2014-02-05 16:28:24 -0500 | [diff] [blame] | 180 | size_t getTransformFeedbackVaryingCount() const; |
| 181 | const LinkedVarying &getTransformFeedbackVarying(size_t idx) const; |
| 182 | GLenum getTransformFeedbackBufferMode() const; |
| 183 | |
Brandon Jones | 43a53e2 | 2014-08-28 16:23:22 -0700 | [diff] [blame] | 184 | void validate(InfoLog &infoLog, const Caps &caps); |
| 185 | bool validateSamplers(InfoLog *infoLog, const Caps &caps); |
apatrick@chromium.org | ea09f9b | 2012-06-08 00:45:32 +0000 | [diff] [blame] | 186 | bool isValidated() const; |
Jamie Madill | d4cfa57 | 2014-07-08 10:00:32 -0400 | [diff] [blame] | 187 | void updateSamplerMapping(); |
apatrick@chromium.org | ea09f9b | 2012-06-08 00:45:32 +0000 | [diff] [blame] | 188 | |
daniel@transgaming.com | e87ca00 | 2012-07-24 18:30:43 +0000 | [diff] [blame] | 189 | unsigned int getSerial() const; |
shannonwoods@chromium.org | 83ac5e8 | 2013-05-30 00:15:29 +0000 | [diff] [blame] | 190 | int getShaderVersion() const; |
daniel@transgaming.com | e87ca00 | 2012-07-24 18:30:43 +0000 | [diff] [blame] | 191 | |
Al Patrick | 3f2daa8 | 2013-08-07 12:58:57 -0700 | [diff] [blame] | 192 | void initAttributesByLayout(); |
Jamie Madill | 834e8b7 | 2014-04-11 13:33:58 -0400 | [diff] [blame] | 193 | void sortAttributesByLayout(rx::TranslatedAttribute attributes[MAX_VERTEX_ATTRIBS], int sortedSemanticIndices[MAX_VERTEX_ATTRIBS]) const; |
shannon.woods@transgaming.com | 0b60014 | 2013-02-28 23:15:04 +0000 | [diff] [blame] | 194 | |
Jamie Madill | 834e8b7 | 2014-04-11 13:33:58 -0400 | [diff] [blame] | 195 | const std::vector<LinkedUniform*> &getUniforms() const { return mUniforms; } |
Jamie Madill | 8ff21ae | 2014-02-04 16:04:05 -0500 | [diff] [blame] | 196 | |
Brandon Jones | 22502d5 | 2014-08-29 16:58:36 -0700 | [diff] [blame] | 197 | static bool linkVaryings(InfoLog &infoLog, Shader *fragmentShader, Shader *vertexShader); |
| 198 | |
apatrick@chromium.org | ea09f9b | 2012-06-08 00:45:32 +0000 | [diff] [blame] | 199 | private: |
| 200 | DISALLOW_COPY_AND_ASSIGN(ProgramBinary); |
| 201 | |
Jamie Madill | 66d43d2 | 2014-07-11 17:02:03 -0400 | [diff] [blame] | 202 | struct Sampler |
| 203 | { |
| 204 | Sampler(); |
| 205 | |
| 206 | bool active; |
| 207 | GLint logicalTextureUnit; |
Geoff Lang | 76b10c9 | 2014-09-05 16:28:14 -0400 | [diff] [blame] | 208 | GLenum textureType; |
Jamie Madill | 66d43d2 | 2014-07-11 17:02:03 -0400 | [diff] [blame] | 209 | }; |
| 210 | |
Geoff Lang | 04fb89a | 2014-06-09 15:05:36 -0400 | [diff] [blame] | 211 | void reset(); |
| 212 | |
Jamie Madill | d15250e | 2014-09-03 09:40:44 -0400 | [diff] [blame] | 213 | bool linkAttributes(InfoLog &infoLog, const AttributeBindings &attributeBindings, const Shader *vertexShader); |
apatrick@chromium.org | ea09f9b | 2012-06-08 00:45:32 +0000 | [diff] [blame] | 214 | |
Brandon Jones | 22502d5 | 2014-08-29 16:58:36 -0700 | [diff] [blame] | 215 | static bool linkValidateVariablesBase(InfoLog &infoLog, |
| 216 | const std::string &variableName, |
| 217 | const sh::ShaderVariable &vertexVariable, |
| 218 | const sh::ShaderVariable &fragmentVariable, |
| 219 | bool validatePrecision); |
Jamie Madill | 9d2ffb1 | 2013-08-30 13:21:04 -0400 | [diff] [blame] | 220 | |
Brandon Jones | 22502d5 | 2014-08-29 16:58:36 -0700 | [diff] [blame] | 221 | static bool linkValidateUniforms(InfoLog &infoLog, const std::string &uniformName, const sh::Uniform &vertexUniform, const sh::Uniform &fragmentUniform); |
| 222 | static bool linkValidateVaryings(InfoLog &infoLog, const std::string &varyingName, const sh::Varying &vertexVarying, const sh::Varying &fragmentVarying); |
| 223 | static bool linkValidateInterfaceBlockFields(InfoLog &infoLog, const std::string &uniformName, const sh::InterfaceBlockField &vertexUniform, const sh::InterfaceBlockField &fragmentUniform); |
Brandon Jones | 43a53e2 | 2014-08-28 16:23:22 -0700 | [diff] [blame] | 224 | bool linkUniforms(InfoLog &infoLog, const Shader &vertexShader, const Shader &fragmentShader, const Caps &caps); |
Jamie Madill | bf9cce2 | 2014-07-18 10:33:09 -0400 | [diff] [blame] | 225 | void defineUniformBase(GLenum shader, const sh::Uniform &uniform, unsigned int uniformRegister); |
Jamie Madill | 42bcf32 | 2014-08-25 16:20:46 -0400 | [diff] [blame] | 226 | void defineUniform(GLenum shader, const sh::ShaderVariable &uniform, const std::string &fullName, sh::HLSLBlockEncoder *encoder); |
Brandon Jones | 43a53e2 | 2014-08-28 16:23:22 -0700 | [diff] [blame] | 227 | bool indexSamplerUniform(const LinkedUniform &uniform, InfoLog &infoLog, const Caps &caps); |
| 228 | bool indexUniforms(InfoLog &infoLog, const Caps &caps); |
Jamie Madill | 66d43d2 | 2014-07-11 17:02:03 -0400 | [diff] [blame] | 229 | static bool assignSamplers(unsigned int startSamplerIndex, GLenum samplerType, unsigned int samplerCount, |
Geoff Lang | 76b10c9 | 2014-09-05 16:28:14 -0400 | [diff] [blame] | 230 | std::vector<Sampler> &outSamplers, GLuint *outUsedRange); |
Jamie Madill | f257598 | 2014-06-25 16:04:54 -0400 | [diff] [blame] | 231 | bool areMatchingInterfaceBlocks(InfoLog &infoLog, const sh::InterfaceBlock &vertexInterfaceBlock, const sh::InterfaceBlock &fragmentInterfaceBlock); |
Brandon Jones | 43a53e2 | 2014-08-28 16:23:22 -0700 | [diff] [blame] | 232 | bool linkUniformBlocks(InfoLog &infoLog, const Shader &vertexShader, const Shader &fragmentShader, const Caps &caps); |
Geoff Lang | 48dcae7 | 2014-02-05 16:28:24 -0500 | [diff] [blame] | 233 | bool gatherTransformFeedbackLinkedVaryings(InfoLog &infoLog, const std::vector<LinkedVarying> &linkedVaryings, |
| 234 | const std::vector<std::string> &transformFeedbackVaryingNames, |
| 235 | GLenum transformFeedbackBufferMode, |
Brandon Jones | 43a53e2 | 2014-08-28 16:23:22 -0700 | [diff] [blame] | 236 | std::vector<LinkedVarying> *outTransformFeedbackLinkedVaryings, |
| 237 | const Caps &caps) const; |
Jamie Madill | 42bcf32 | 2014-08-25 16:20:46 -0400 | [diff] [blame] | 238 | template <typename VarT> |
| 239 | void defineUniformBlockMembers(const std::vector<VarT> &fields, const std::string &prefix, int blockIndex, |
Jamie Madill | a6f267f | 2014-08-27 11:44:15 -0400 | [diff] [blame] | 240 | sh::BlockLayoutEncoder *encoder, std::vector<unsigned int> *blockUniformIndexes, |
| 241 | bool inRowMajorLayout); |
Brandon Jones | 43a53e2 | 2014-08-28 16:23:22 -0700 | [diff] [blame] | 242 | bool defineUniformBlock(InfoLog &infoLog, const Shader &shader, const sh::InterfaceBlock &interfaceBlock, const Caps &caps); |
| 243 | bool assignUniformBlockRegister(InfoLog &infoLog, UniformBlock *uniformBlock, GLenum shader, unsigned int registerIndex, const Caps &caps); |
Brandon Jones | 7162096 | 2014-08-20 14:04:59 -0700 | [diff] [blame] | 244 | void defineOutputVariables(Shader *fragmentShader); |
Jamie Madill | 46131a3 | 2013-06-20 11:55:50 -0400 | [diff] [blame] | 245 | |
shannon.woods%transgaming.com@gtempaccount.com | 8a19eed | 2013-04-13 03:40:22 +0000 | [diff] [blame] | 246 | template <typename T> |
Jamie Madill | 3639892 | 2014-05-20 14:51:53 -0400 | [diff] [blame] | 247 | void setUniform(GLint location, GLsizei count, const T* v, GLenum targetUniformType); |
shannon.woods%transgaming.com@gtempaccount.com | 8a19eed | 2013-04-13 03:40:22 +0000 | [diff] [blame] | 248 | |
shannon.woods%transgaming.com@gtempaccount.com | 36c76a9 | 2013-04-13 03:39:58 +0000 | [diff] [blame] | 249 | template <int cols, int rows> |
Jamie Madill | 3639892 | 2014-05-20 14:51:53 -0400 | [diff] [blame] | 250 | void setUniformMatrixfv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value, GLenum targetUniformType); |
shannon.woods%transgaming.com@gtempaccount.com | 36c76a9 | 2013-04-13 03:39:58 +0000 | [diff] [blame] | 251 | |
shannon.woods%transgaming.com@gtempaccount.com | 4590d89 | 2013-04-13 03:41:01 +0000 | [diff] [blame] | 252 | template <typename T> |
Jamie Madill | 99a1e98 | 2014-08-25 15:47:54 -0400 | [diff] [blame] | 253 | void getUniformv(GLint location, T *params, GLenum uniformType); |
shannon.woods%transgaming.com@gtempaccount.com | 4590d89 | 2013-04-13 03:41:01 +0000 | [diff] [blame] | 254 | |
Jamie Madill | c5a8300 | 2014-02-14 16:41:25 -0500 | [diff] [blame] | 255 | class VertexExecutable |
| 256 | { |
| 257 | public: |
Geoff Lang | 04fb89a | 2014-06-09 15:05:36 -0400 | [diff] [blame] | 258 | VertexExecutable(const VertexFormat inputLayout[MAX_VERTEX_ATTRIBS], |
Jamie Madill | 7a29e4a | 2014-05-02 10:41:48 -0400 | [diff] [blame] | 259 | const GLenum signature[MAX_VERTEX_ATTRIBS], |
Jamie Madill | c5a8300 | 2014-02-14 16:41:25 -0500 | [diff] [blame] | 260 | rx::ShaderExecutable *shaderExecutable); |
Jamie Madill | 8b4f8f8 | 2014-03-26 14:01:58 -0400 | [diff] [blame] | 261 | ~VertexExecutable(); |
| 262 | |
Jamie Madill | 7a29e4a | 2014-05-02 10:41:48 -0400 | [diff] [blame] | 263 | bool matchesSignature(const GLenum convertedLayout[MAX_VERTEX_ATTRIBS]) const; |
Jamie Madill | c5a8300 | 2014-02-14 16:41:25 -0500 | [diff] [blame] | 264 | |
| 265 | const VertexFormat *inputs() const { return mInputs; } |
Jamie Madill | 7a29e4a | 2014-05-02 10:41:48 -0400 | [diff] [blame] | 266 | const GLenum *signature() const { return mSignature; } |
Jamie Madill | c5a8300 | 2014-02-14 16:41:25 -0500 | [diff] [blame] | 267 | rx::ShaderExecutable *shaderExecutable() const { return mShaderExecutable; } |
| 268 | |
| 269 | private: |
Jamie Madill | 834e8b7 | 2014-04-11 13:33:58 -0400 | [diff] [blame] | 270 | VertexFormat mInputs[MAX_VERTEX_ATTRIBS]; |
Jamie Madill | 7a29e4a | 2014-05-02 10:41:48 -0400 | [diff] [blame] | 271 | GLenum mSignature[MAX_VERTEX_ATTRIBS]; |
Jamie Madill | c5a8300 | 2014-02-14 16:41:25 -0500 | [diff] [blame] | 272 | rx::ShaderExecutable *mShaderExecutable; |
| 273 | }; |
| 274 | |
Geoff Lang | 04fb89a | 2014-06-09 15:05:36 -0400 | [diff] [blame] | 275 | class PixelExecutable |
| 276 | { |
| 277 | public: |
| 278 | PixelExecutable(const std::vector<GLenum> &outputSignature, rx::ShaderExecutable *shaderExecutable); |
| 279 | ~PixelExecutable(); |
| 280 | |
Jamie Madill | 3f2e61d | 2014-09-05 10:38:05 -0400 | [diff] [blame] | 281 | bool matchesSignature(const std::vector<GLenum> &signature) const { return mOutputSignature == signature; } |
Geoff Lang | 4ace423 | 2014-06-18 19:12:48 -0400 | [diff] [blame] | 282 | |
Geoff Lang | 04fb89a | 2014-06-09 15:05:36 -0400 | [diff] [blame] | 283 | const std::vector<GLenum> &outputSignature() const { return mOutputSignature; } |
| 284 | rx::ShaderExecutable *shaderExecutable() const { return mShaderExecutable; } |
| 285 | |
| 286 | private: |
| 287 | std::vector<GLenum> mOutputSignature; |
| 288 | rx::ShaderExecutable *mShaderExecutable; |
| 289 | }; |
| 290 | |
Brandon Jones | c9610c5 | 2014-08-25 17:02:59 -0700 | [diff] [blame] | 291 | rx::ProgramImpl *mProgram; |
apatrick@chromium.org | ea09f9b | 2012-06-08 00:45:32 +0000 | [diff] [blame] | 292 | |
Jamie Madill | c5a8300 | 2014-02-14 16:41:25 -0500 | [diff] [blame] | 293 | std::vector<VertexExecutable *> mVertexExecutables; |
Geoff Lang | 04fb89a | 2014-06-09 15:05:36 -0400 | [diff] [blame] | 294 | std::vector<PixelExecutable *> mPixelExecutables; |
| 295 | |
shannon.woods@transgaming.com | 3e773bb | 2013-01-25 21:55:47 +0000 | [diff] [blame] | 296 | rx::ShaderExecutable *mGeometryExecutable; |
apatrick@chromium.org | ea09f9b | 2012-06-08 00:45:32 +0000 | [diff] [blame] | 297 | |
Jamie Madill | f257598 | 2014-06-25 16:04:54 -0400 | [diff] [blame] | 298 | sh::Attribute mLinkedAttribute[MAX_VERTEX_ATTRIBS]; |
| 299 | sh::Attribute mShaderAttributes[MAX_VERTEX_ATTRIBS]; |
apatrick@chromium.org | ea09f9b | 2012-06-08 00:45:32 +0000 | [diff] [blame] | 300 | int mSemanticIndex[MAX_VERTEX_ATTRIBS]; |
Al Patrick | 3f2daa8 | 2013-08-07 12:58:57 -0700 | [diff] [blame] | 301 | int mAttributesByLayout[MAX_VERTEX_ATTRIBS]; |
apatrick@chromium.org | ea09f9b | 2012-06-08 00:45:32 +0000 | [diff] [blame] | 302 | |
Geoff Lang | 48dcae7 | 2014-02-05 16:28:24 -0500 | [diff] [blame] | 303 | GLenum mTransformFeedbackBufferMode; |
| 304 | std::vector<LinkedVarying> mTransformFeedbackLinkedVaryings; |
| 305 | |
Geoff Lang | 76b10c9 | 2014-09-05 16:28:14 -0400 | [diff] [blame] | 306 | std::vector<Sampler> mSamplersPS; |
| 307 | std::vector<Sampler> mSamplersVS; |
apatrick@chromium.org | ea09f9b | 2012-06-08 00:45:32 +0000 | [diff] [blame] | 308 | GLuint mUsedVertexSamplerRange; |
| 309 | GLuint mUsedPixelSamplerRange; |
daniel@transgaming.com | 087e578 | 2012-09-17 21:28:47 +0000 | [diff] [blame] | 310 | bool mUsesPointSize; |
shannonwoods@chromium.org | 83ac5e8 | 2013-05-30 00:15:29 +0000 | [diff] [blame] | 311 | int mShaderVersion; |
Jamie Madill | d4cfa57 | 2014-07-08 10:00:32 -0400 | [diff] [blame] | 312 | bool mDirtySamplerMapping; |
apatrick@chromium.org | ea09f9b | 2012-06-08 00:45:32 +0000 | [diff] [blame] | 313 | |
Jamie Madill | 834e8b7 | 2014-04-11 13:33:58 -0400 | [diff] [blame] | 314 | std::vector<LinkedUniform*> mUniforms; |
| 315 | std::vector<UniformBlock*> mUniformBlocks; |
Jamie Madill | 5f56273 | 2014-02-14 16:41:24 -0500 | [diff] [blame] | 316 | std::vector<VariableLocation> mUniformIndex; |
| 317 | std::map<int, VariableLocation> mOutputVariables; |
apatrick@chromium.org | ea09f9b | 2012-06-08 00:45:32 +0000 | [diff] [blame] | 318 | |
apatrick@chromium.org | ea09f9b | 2012-06-08 00:45:32 +0000 | [diff] [blame] | 319 | bool mValidated; |
daniel@transgaming.com | e87ca00 | 2012-07-24 18:30:43 +0000 | [diff] [blame] | 320 | |
| 321 | const unsigned int mSerial; |
| 322 | |
| 323 | static unsigned int issueSerial(); |
| 324 | static unsigned int mCurrentSerial; |
apatrick@chromium.org | ea09f9b | 2012-06-08 00:45:32 +0000 | [diff] [blame] | 325 | }; |
Jamie Madill | 5f56273 | 2014-02-14 16:41:24 -0500 | [diff] [blame] | 326 | |
apatrick@chromium.org | ea09f9b | 2012-06-08 00:45:32 +0000 | [diff] [blame] | 327 | } |
| 328 | |
| 329 | #endif // LIBGLESV2_PROGRAM_BINARY_H_ |