Skip to content

G
glslang
Commit 3af0d53d by John Kessenich
Options

Remove unnecessary TString constructors.

git-svn-id: https://cvs.khronos.org/svn/repos/ogl/trunk/ecosystem/public/sdk/tools/glslang@22844 e7fa87d3-cd2b-0410-9028-fcbf551c1848
parent a5ea9c63
Showing with 658 additions and 657 deletions
glslang/MachineIndependent/Initialize.cpp
......@@ -88,498 +88,498 @@ void TBuiltIns::initialize(int version, EProfile profile)
//
// Angle and Trigonometric Functions.
//
s.append(TString("float radians(float degrees);"));
s.append(TString("vec2 radians(vec2 degrees);"));
s.append(TString("vec3 radians(vec3 degrees);"));
s.append(TString("vec4 radians(vec4 degrees);"));
s.append(TString("float degrees(float radians);"));
s.append(TString("vec2 degrees(vec2 radians);"));
s.append(TString("vec3 degrees(vec3 radians);"));
s.append(TString("vec4 degrees(vec4 radians);"));
s.append(TString("float sin(float angle);"));
s.append(TString("vec2 sin(vec2 angle);"));
s.append(TString("vec3 sin(vec3 angle);"));
s.append(TString("vec4 sin(vec4 angle);"));
s.append(TString("float cos(float angle);"));
s.append(TString("vec2 cos(vec2 angle);"));
s.append(TString("vec3 cos(vec3 angle);"));
s.append(TString("vec4 cos(vec4 angle);"));
s.append(TString("float tan(float angle);"));
s.append(TString("vec2 tan(vec2 angle);"));
s.append(TString("vec3 tan(vec3 angle);"));
s.append(TString("vec4 tan(vec4 angle);"));
s.append(TString("float asin(float x);"));
s.append(TString("vec2 asin(vec2 x);"));
s.append(TString("vec3 asin(vec3 x);"));
s.append(TString("vec4 asin(vec4 x);"));
s.append(TString("float acos(float x);"));
s.append(TString("vec2 acos(vec2 x);"));
s.append(TString("vec3 acos(vec3 x);"));
s.append(TString("vec4 acos(vec4 x);"));
s.append(TString("float atan(float y, float x);"));
s.append(TString("vec2 atan(vec2 y, vec2 x);"));
s.append(TString("vec3 atan(vec3 y, vec3 x);"));
s.append(TString("vec4 atan(vec4 y, vec4 x);"));
s.append(TString("float atan(float y_over_x);"));
s.append(TString("vec2 atan(vec2 y_over_x);"));
s.append(TString("vec3 atan(vec3 y_over_x);"));
s.append(TString("vec4 atan(vec4 y_over_x);"));
s.append(TString("float sinh(float angle);"));
s.append(TString("vec2 sinh(vec2 angle);"));
s.append(TString("vec3 sinh(vec3 angle);"));
s.append(TString("vec4 sinh(vec4 angle);"));
s.append(TString("float cosh(float angle);"));
s.append(TString("vec2 cosh(vec2 angle);"));
s.append(TString("vec3 cosh(vec3 angle);"));
s.append(TString("vec4 cosh(vec4 angle);"));
s.append(TString("float tanh(float angle);"));
s.append(TString("vec2 tanh(vec2 angle);"));
s.append(TString("vec3 tanh(vec3 angle);"));
s.append(TString("vec4 tanh(vec4 angle);"));
s.append(TString("float asinh(float x);"));
s.append(TString("vec2 asinh(vec2 x);"));
s.append(TString("vec3 asinh(vec3 x);"));
s.append(TString("vec4 asinh(vec4 x);"));
s.append(TString("float acosh(float x);"));
s.append(TString("vec2 acosh(vec2 x);"));
s.append(TString("vec3 acosh(vec3 x);"));
s.append(TString("vec4 acosh(vec4 x);"));
s.append(TString("float atanh(float y_over_x);"));
s.append(TString("vec2 atanh(vec2 y_over_x);"));
s.append(TString("vec3 atanh(vec3 y_over_x);"));
s.append(TString("vec4 atanh(vec4 y_over_x);"));
s.append("float radians(float degrees);");
s.append("vec2 radians(vec2 degrees);");
s.append("vec3 radians(vec3 degrees);");
s.append("vec4 radians(vec4 degrees);");
s.append("float degrees(float radians);");
s.append("vec2 degrees(vec2 radians);");
s.append("vec3 degrees(vec3 radians);");
s.append("vec4 degrees(vec4 radians);");
s.append("float sin(float angle);");
s.append("vec2 sin(vec2 angle);");
s.append("vec3 sin(vec3 angle);");
s.append("vec4 sin(vec4 angle);");
s.append("float cos(float angle);");
s.append("vec2 cos(vec2 angle);");
s.append("vec3 cos(vec3 angle);");
s.append("vec4 cos(vec4 angle);");
s.append("float tan(float angle);");
s.append("vec2 tan(vec2 angle);");
s.append("vec3 tan(vec3 angle);");
s.append("vec4 tan(vec4 angle);");
s.append("float asin(float x);");
s.append("vec2 asin(vec2 x);");
s.append("vec3 asin(vec3 x);");
s.append("vec4 asin(vec4 x);");
s.append("float acos(float x);");
s.append("vec2 acos(vec2 x);");
s.append("vec3 acos(vec3 x);");
s.append("vec4 acos(vec4 x);");
s.append("float atan(float y, float x);");
s.append("vec2 atan(vec2 y, vec2 x);");
s.append("vec3 atan(vec3 y, vec3 x);");
s.append("vec4 atan(vec4 y, vec4 x);");
s.append("float atan(float y_over_x);");
s.append("vec2 atan(vec2 y_over_x);");
s.append("vec3 atan(vec3 y_over_x);");
s.append("vec4 atan(vec4 y_over_x);");
s.append("float sinh(float angle);");
s.append("vec2 sinh(vec2 angle);");
s.append("vec3 sinh(vec3 angle);");
s.append("vec4 sinh(vec4 angle);");
s.append("float cosh(float angle);");
s.append("vec2 cosh(vec2 angle);");
s.append("vec3 cosh(vec3 angle);");
s.append("vec4 cosh(vec4 angle);");
s.append("float tanh(float angle);");
s.append("vec2 tanh(vec2 angle);");
s.append("vec3 tanh(vec3 angle);");
s.append("vec4 tanh(vec4 angle);");
s.append("float asinh(float x);");
s.append("vec2 asinh(vec2 x);");
s.append("vec3 asinh(vec3 x);");
s.append("vec4 asinh(vec4 x);");
s.append("float acosh(float x);");
s.append("vec2 acosh(vec2 x);");
s.append("vec3 acosh(vec3 x);");
s.append("vec4 acosh(vec4 x);");
s.append("float atanh(float y_over_x);");
s.append("vec2 atanh(vec2 y_over_x);");
s.append("vec3 atanh(vec3 y_over_x);");
s.append("vec4 atanh(vec4 y_over_x);");
//
// Exponential Functions.
//
s.append(TString("float pow(float x, float y);"));
s.append(TString("vec2 pow(vec2 x, vec2 y);"));
s.append(TString("vec3 pow(vec3 x, vec3 y);"));
s.append(TString("vec4 pow(vec4 x, vec4 y);"));
s.append(TString("float exp(float x);"));
s.append(TString("vec2 exp(vec2 x);"));
s.append(TString("vec3 exp(vec3 x);"));
s.append(TString("vec4 exp(vec4 x);"));
s.append(TString("float log(float x);"));
s.append(TString("vec2 log(vec2 x);"));
s.append(TString("vec3 log(vec3 x);"));
s.append(TString("vec4 log(vec4 x);"));
s.append(TString("float exp2(float x);"));
s.append(TString("vec2 exp2(vec2 x);"));
s.append(TString("vec3 exp2(vec3 x);"));
s.append(TString("vec4 exp2(vec4 x);"));
s.append(TString("float log2(float x);"));
s.append(TString("vec2 log2(vec2 x);"));
s.append(TString("vec3 log2(vec3 x);"));
s.append(TString("vec4 log2(vec4 x);"));
s.append(TString("float sqrt(float x);"));
s.append(TString("vec2 sqrt(vec2 x);"));
s.append(TString("vec3 sqrt(vec3 x);"));
s.append(TString("vec4 sqrt(vec4 x);"));
s.append(TString("float inversesqrt(float x);"));
s.append(TString("vec2 inversesqrt(vec2 x);"));
s.append(TString("vec3 inversesqrt(vec3 x);"));
s.append(TString("vec4 inversesqrt(vec4 x);"));
s.append("float pow(float x, float y);");
s.append("vec2 pow(vec2 x, vec2 y);");
s.append("vec3 pow(vec3 x, vec3 y);");
s.append("vec4 pow(vec4 x, vec4 y);");
s.append("float exp(float x);");
s.append("vec2 exp(vec2 x);");
s.append("vec3 exp(vec3 x);");
s.append("vec4 exp(vec4 x);");
s.append("float log(float x);");
s.append("vec2 log(vec2 x);");
s.append("vec3 log(vec3 x);");
s.append("vec4 log(vec4 x);");
s.append("float exp2(float x);");
s.append("vec2 exp2(vec2 x);");
s.append("vec3 exp2(vec3 x);");
s.append("vec4 exp2(vec4 x);");
s.append("float log2(float x);");
s.append("vec2 log2(vec2 x);");
s.append("vec3 log2(vec3 x);");
s.append("vec4 log2(vec4 x);");
s.append("float sqrt(float x);");
s.append("vec2 sqrt(vec2 x);");
s.append("vec3 sqrt(vec3 x);");
s.append("vec4 sqrt(vec4 x);");
s.append("float inversesqrt(float x);");
s.append("vec2 inversesqrt(vec2 x);");
s.append("vec3 inversesqrt(vec3 x);");
s.append("vec4 inversesqrt(vec4 x);");
//
// Common Functions.
//
s.append(TString("float abs(float x);"));
s.append(TString("vec2 abs(vec2 x);"));
s.append(TString("vec3 abs(vec3 x);"));
s.append(TString("vec4 abs(vec4 x);"));
s.append("float abs(float x);");
s.append("vec2 abs(vec2 x);");
s.append("vec3 abs(vec3 x);");
s.append("vec4 abs(vec4 x);");
if (version >= 130) {
s.append(TString(" int abs( int x);"));
s.append(TString("ivec2 abs(ivec2 x);"));
s.append(TString("ivec3 abs(ivec3 x);"));
s.append(TString("ivec4 abs(ivec4 x);"));
s.append(" int abs( int x);");
s.append("ivec2 abs(ivec2 x);");
s.append("ivec3 abs(ivec3 x);");
s.append("ivec4 abs(ivec4 x);");
}
s.append(TString("float sign(float x);"));
s.append(TString("vec2 sign(vec2 x);"));
s.append(TString("vec3 sign(vec3 x);"));
s.append(TString("vec4 sign(vec4 x);"));
s.append("float sign(float x);");
s.append("vec2 sign(vec2 x);");
s.append("vec3 sign(vec3 x);");
s.append("vec4 sign(vec4 x);");
if (version >= 130) {
s.append(TString(" int sign( int x);"));
s.append(TString("ivec2 sign(ivec2 x);"));
s.append(TString("ivec3 sign(ivec3 x);"));
s.append(TString("ivec4 sign(ivec4 x);"));
s.append(" int sign( int x);");
s.append("ivec2 sign(ivec2 x);");
s.append("ivec3 sign(ivec3 x);");
s.append("ivec4 sign(ivec4 x);");
}
s.append(TString("float floor(float x);"));
s.append(TString("vec2 floor(vec2 x);"));
s.append(TString("vec3 floor(vec3 x);"));
s.append(TString("vec4 floor(vec4 x);"));
s.append("float floor(float x);");
s.append("vec2 floor(vec2 x);");
s.append("vec3 floor(vec3 x);");
s.append("vec4 floor(vec4 x);");
if (version >= 130) {
s.append(TString("float trunc(float x);"));
s.append(TString("vec2 trunc(vec2 x);"));
s.append(TString("vec3 trunc(vec3 x);"));
s.append(TString("vec4 trunc(vec4 x);"));
s.append(TString("float round(float x);"));
s.append(TString("vec2 round(vec2 x);"));
s.append(TString("vec3 round(vec3 x);"));
s.append(TString("vec4 round(vec4 x);"));
s.append(TString("float roundEven(float x);"));
s.append(TString("vec2 roundEven(vec2 x);"));
s.append(TString("vec3 roundEven(vec3 x);"));
s.append(TString("vec4 roundEven(vec4 x);"));
s.append("float trunc(float x);");
s.append("vec2 trunc(vec2 x);");
s.append("vec3 trunc(vec3 x);");
s.append("vec4 trunc(vec4 x);");
s.append("float round(float x);");
s.append("vec2 round(vec2 x);");
s.append("vec3 round(vec3 x);");
s.append("vec4 round(vec4 x);");
s.append("float roundEven(float x);");
s.append("vec2 roundEven(vec2 x);");
s.append("vec3 roundEven(vec3 x);");
s.append("vec4 roundEven(vec4 x);");
}
s.append(TString("float ceil(float x);"));
s.append(TString("vec2 ceil(vec2 x);"));
s.append(TString("vec3 ceil(vec3 x);"));
s.append(TString("vec4 ceil(vec4 x);"));
s.append("float ceil(float x);");
s.append("vec2 ceil(vec2 x);");
s.append("vec3 ceil(vec3 x);");
s.append("vec4 ceil(vec4 x);");
s.append(TString("float fract(float x);"));
s.append(TString("vec2 fract(vec2 x);"));
s.append(TString("vec3 fract(vec3 x);"));
s.append(TString("vec4 fract(vec4 x);"));
s.append("float fract(float x);");
s.append("vec2 fract(vec2 x);");
s.append("vec3 fract(vec3 x);");
s.append("vec4 fract(vec4 x);");
s.append(TString("float mod(float x, float y);"));
s.append(TString("vec2 mod(vec2 x, float y);"));
s.append(TString("vec3 mod(vec3 x, float y);"));
s.append(TString("vec4 mod(vec4 x, float y);"));
s.append(TString("vec2 mod(vec2 x, vec2 y);"));
s.append(TString("vec3 mod(vec3 x, vec3 y);"));
s.append(TString("vec4 mod(vec4 x, vec4 y);"));
s.append("float mod(float x, float y);");
s.append("vec2 mod(vec2 x, float y);");
s.append("vec3 mod(vec3 x, float y);");
s.append("vec4 mod(vec4 x, float y);");
s.append("vec2 mod(vec2 x, vec2 y);");
s.append("vec3 mod(vec3 x, vec3 y);");
s.append("vec4 mod(vec4 x, vec4 y);");
if (version >= 130) {
s.append(TString("float modf(float, out float);"));
s.append(TString("vec2 modf(vec2, out vec2 );"));
s.append(TString("vec3 modf(vec3, out vec3 );"));
s.append(TString("vec4 modf(vec4, out vec4 );"));
s.append("float modf(float, out float);");
s.append("vec2 modf(vec2, out vec2 );");
s.append("vec3 modf(vec3, out vec3 );");
s.append("vec4 modf(vec4, out vec4 );");
}
s.append(TString("float min(float x, float y);"));
s.append(TString("vec2 min(vec2 x, float y);"));
s.append(TString("vec3 min(vec3 x, float y);"));
s.append(TString("vec4 min(vec4 x, float y);"));
s.append(TString("vec2 min(vec2 x, vec2 y);"));
s.append(TString("vec3 min(vec3 x, vec3 y);"));
s.append(TString("vec4 min(vec4 x, vec4 y);"));
s.append("float min(float x, float y);");
s.append("vec2 min(vec2 x, float y);");
s.append("vec3 min(vec3 x, float y);");
s.append("vec4 min(vec4 x, float y);");
s.append("vec2 min(vec2 x, vec2 y);");
s.append("vec3 min(vec3 x, vec3 y);");
s.append("vec4 min(vec4 x, vec4 y);");
if (version >= 130) {
s.append(TString(" int min(int x, int y);"));
s.append(TString("ivec2 min(ivec2 x, int y);"));
s.append(TString("ivec3 min(ivec3 x, int y);"));
s.append(TString("ivec4 min(ivec4 x, int y);"));
s.append(TString("ivec2 min(ivec2 x, ivec2 y);"));
s.append(TString("ivec3 min(ivec3 x, ivec3 y);"));
s.append(TString("ivec4 min(ivec4 x, ivec4 y);"));
s.append(TString(" uint min(uint x, uint y);"));
s.append(TString("uvec2 min(uvec2 x, uint y);"));
s.append(TString("uvec3 min(uvec3 x, uint y);"));
s.append(TString("uvec4 min(uvec4 x, uint y);"));
s.append(TString("uvec2 min(uvec2 x, uvec2 y);"));
s.append(TString("uvec3 min(uvec3 x, uvec3 y);"));
s.append(TString("uvec4 min(uvec4 x, uvec4 y);"));
s.append(" int min(int x, int y);");
s.append("ivec2 min(ivec2 x, int y);");
s.append("ivec3 min(ivec3 x, int y);");
s.append("ivec4 min(ivec4 x, int y);");
s.append("ivec2 min(ivec2 x, ivec2 y);");
s.append("ivec3 min(ivec3 x, ivec3 y);");
s.append("ivec4 min(ivec4 x, ivec4 y);");
s.append(" uint min(uint x, uint y);");
s.append("uvec2 min(uvec2 x, uint y);");
s.append("uvec3 min(uvec3 x, uint y);");
s.append("uvec4 min(uvec4 x, uint y);");
s.append("uvec2 min(uvec2 x, uvec2 y);");
s.append("uvec3 min(uvec3 x, uvec3 y);");
s.append("uvec4 min(uvec4 x, uvec4 y);");
}
s.append(TString("float max(float x, float y);"));
s.append(TString("vec2 max(vec2 x, float y);"));
s.append(TString("vec3 max(vec3 x, float y);"));
s.append(TString("vec4 max(vec4 x, float y);"));
s.append(TString("vec2 max(vec2 x, vec2 y);"));
s.append(TString("vec3 max(vec3 x, vec3 y);"));
s.append(TString("vec4 max(vec4 x, vec4 y);"));
s.append("float max(float x, float y);");
s.append("vec2 max(vec2 x, float y);");
s.append("vec3 max(vec3 x, float y);");
s.append("vec4 max(vec4 x, float y);");
s.append("vec2 max(vec2 x, vec2 y);");
s.append("vec3 max(vec3 x, vec3 y);");
s.append("vec4 max(vec4 x, vec4 y);");
if (version >= 130) {
s.append(TString(" int max(int x, int y);"));
s.append(TString("ivec2 max(ivec2 x, int y);"));
s.append(TString("ivec3 max(ivec3 x, int y);"));
s.append(TString("ivec4 max(ivec4 x, int y);"));
s.append(TString("ivec2 max(ivec2 x, ivec2 y);"));
s.append(TString("ivec3 max(ivec3 x, ivec3 y);"));
s.append(TString("ivec4 max(ivec4 x, ivec4 y);"));
s.append(TString(" uint max(uint x, uint y);"));
s.append(TString("uvec2 max(uvec2 x, uint y);"));
s.append(TString("uvec3 max(uvec3 x, uint y);"));
s.append(TString("uvec4 max(uvec4 x, uint y);"));
s.append(TString("uvec2 max(uvec2 x, uvec2 y);"));
s.append(TString("uvec3 max(uvec3 x, uvec3 y);"));
s.append(TString("uvec4 max(uvec4 x, uvec4 y);"));
s.append(" int max(int x, int y);");
s.append("ivec2 max(ivec2 x, int y);");
s.append("ivec3 max(ivec3 x, int y);");
s.append("ivec4 max(ivec4 x, int y);");
s.append("ivec2 max(ivec2 x, ivec2 y);");
s.append("ivec3 max(ivec3 x, ivec3 y);");
s.append("ivec4 max(ivec4 x, ivec4 y);");
s.append(" uint max(uint x, uint y);");
s.append("uvec2 max(uvec2 x, uint y);");
s.append("uvec3 max(uvec3 x, uint y);");
s.append("uvec4 max(uvec4 x, uint y);");
s.append("uvec2 max(uvec2 x, uvec2 y);");
s.append("uvec3 max(uvec3 x, uvec3 y);");
s.append("uvec4 max(uvec4 x, uvec4 y);");
}
s.append(TString("float clamp(float x, float minVal, float maxVal);"));
s.append(TString("vec2 clamp(vec2 x, float minVal, float maxVal);"));
s.append(TString("vec3 clamp(vec3 x, float minVal, float maxVal);"));
s.append(TString("vec4 clamp(vec4 x, float minVal, float maxVal);"));
s.append(TString("vec2 clamp(vec2 x, vec2 minVal, vec2 maxVal);"));
s.append(TString("vec3 clamp(vec3 x, vec3 minVal, vec3 maxVal);"));
s.append(TString("vec4 clamp(vec4 x, vec4 minVal, vec4 maxVal);"));
s.append("float clamp(float x, float minVal, float maxVal);");
s.append("vec2 clamp(vec2 x, float minVal, float maxVal);");
s.append("vec3 clamp(vec3 x, float minVal, float maxVal);");
s.append("vec4 clamp(vec4 x, float minVal, float maxVal);");
s.append("vec2 clamp(vec2 x, vec2 minVal, vec2 maxVal);");
s.append("vec3 clamp(vec3 x, vec3 minVal, vec3 maxVal);");
s.append("vec4 clamp(vec4 x, vec4 minVal, vec4 maxVal);");
if (version >= 130) {
s.append(TString("int clamp(int x, int minVal, int maxVal);"));
s.append(TString("ivec2 clamp(ivec2 x, int minVal, int maxVal);"));
s.append(TString("ivec3 clamp(ivec3 x, int minVal, int maxVal);"));
s.append(TString("ivec4 clamp(ivec4 x, int minVal, int maxVal);"));
s.append(TString("ivec2 clamp(ivec2 x, ivec2 minVal, ivec2 maxVal);"));
s.append(TString("ivec3 clamp(ivec3 x, ivec3 minVal, ivec3 maxVal);"));
s.append(TString("ivec4 clamp(ivec4 x, ivec4 minVal, ivec4 maxVal);"));
s.append(TString("uint clamp(uint x, uint minVal, uint maxVal);"));
s.append(TString("uvec2 clamp(uvec2 x, uint minVal, uint maxVal);"));
s.append(TString("uvec3 clamp(uvec3 x, uint minVal, uint maxVal);"));
s.append(TString("uvec4 clamp(uvec4 x, uint minVal, uint maxVal);"));
s.append(TString("uvec2 clamp(uvec2 x, uvec2 minVal, uvec2 maxVal);"));
s.append(TString("uvec3 clamp(uvec3 x, uvec3 minVal, uvec3 maxVal);"));
s.append(TString("uvec4 clamp(uvec4 x, uvec4 minVal, uvec4 maxVal);"));
s.append("int clamp(int x, int minVal, int maxVal);");
s.append("ivec2 clamp(ivec2 x, int minVal, int maxVal);");
s.append("ivec3 clamp(ivec3 x, int minVal, int maxVal);");
s.append("ivec4 clamp(ivec4 x, int minVal, int maxVal);");
s.append("ivec2 clamp(ivec2 x, ivec2 minVal, ivec2 maxVal);");
s.append("ivec3 clamp(ivec3 x, ivec3 minVal, ivec3 maxVal);");
s.append("ivec4 clamp(ivec4 x, ivec4 minVal, ivec4 maxVal);");
s.append("uint clamp(uint x, uint minVal, uint maxVal);");
s.append("uvec2 clamp(uvec2 x, uint minVal, uint maxVal);");
s.append("uvec3 clamp(uvec3 x, uint minVal, uint maxVal);");
s.append("uvec4 clamp(uvec4 x, uint minVal, uint maxVal);");
s.append("uvec2 clamp(uvec2 x, uvec2 minVal, uvec2 maxVal);");
s.append("uvec3 clamp(uvec3 x, uvec3 minVal, uvec3 maxVal);");
s.append("uvec4 clamp(uvec4 x, uvec4 minVal, uvec4 maxVal);");
}
s.append(TString("float mix(float x, float y, float a);"));
s.append(TString("vec2 mix(vec2 x, vec2 y, float a);"));
s.append(TString("vec3 mix(vec3 x, vec3 y, float a);"));
s.append(TString("vec4 mix(vec4 x, vec4 y, float a);"));
s.append(TString("vec2 mix(vec2 x, vec2 y, vec2 a);"));
s.append(TString("vec3 mix(vec3 x, vec3 y, vec3 a);"));
s.append(TString("vec4 mix(vec4 x, vec4 y, vec4 a);"));
s.append("float mix(float x, float y, float a);");
s.append("vec2 mix(vec2 x, vec2 y, float a);");
s.append("vec3 mix(vec3 x, vec3 y, float a);");
s.append("vec4 mix(vec4 x, vec4 y, float a);");
s.append("vec2 mix(vec2 x, vec2 y, vec2 a);");
s.append("vec3 mix(vec3 x, vec3 y, vec3 a);");
s.append("vec4 mix(vec4 x, vec4 y, vec4 a);");
if (version >= 130) {
s.append(TString("float mix(float x, float y, bool a);"));
s.append(TString("vec2 mix(vec2 x, vec2 y, bvec2 a);"));
s.append(TString("vec3 mix(vec3 x, vec3 y, bvec3 a);"));
s.append(TString("vec4 mix(vec4 x, vec4 y, bvec4 a);"));
s.append("float mix(float x, float y, bool a);");
s.append("vec2 mix(vec2 x, vec2 y, bvec2 a);");
s.append("vec3 mix(vec3 x, vec3 y, bvec3 a);");
s.append("vec4 mix(vec4 x, vec4 y, bvec4 a);");
}
s.append(TString("float step(float edge, float x);"));
s.append(TString("vec2 step(vec2 edge, vec2 x);"));
s.append(TString("vec3 step(vec3 edge, vec3 x);"));
s.append(TString("vec4 step(vec4 edge, vec4 x);"));
s.append(TString("vec2 step(float edge, vec2 x);"));
s.append(TString("vec3 step(float edge, vec3 x);"));
s.append(TString("vec4 step(float edge, vec4 x);"));
s.append(TString("float smoothstep(float edge0, float edge1, float x);"));
s.append(TString("vec2 smoothstep(vec2 edge0, vec2 edge1, vec2 x);"));
s.append(TString("vec3 smoothstep(vec3 edge0, vec3 edge1, vec3 x);"));
s.append(TString("vec4 smoothstep(vec4 edge0, vec4 edge1, vec4 x);"));
s.append(TString("vec2 smoothstep(float edge0, float edge1, vec2 x);"));
s.append(TString("vec3 smoothstep(float edge0, float edge1, vec3 x);"));
s.append(TString("vec4 smoothstep(float edge0, float edge1, vec4 x);"));
s.append("float step(float edge, float x);");
s.append("vec2 step(vec2 edge, vec2 x);");
s.append("vec3 step(vec3 edge, vec3 x);");
s.append("vec4 step(vec4 edge, vec4 x);");
s.append("vec2 step(float edge, vec2 x);");
s.append("vec3 step(float edge, vec3 x);");
s.append("vec4 step(float edge, vec4 x);");
s.append("float smoothstep(float edge0, float edge1, float x);");
s.append("vec2 smoothstep(vec2 edge0, vec2 edge1, vec2 x);");
s.append("vec3 smoothstep(vec3 edge0, vec3 edge1, vec3 x);");
s.append("vec4 smoothstep(vec4 edge0, vec4 edge1, vec4 x);");
s.append("vec2 smoothstep(float edge0, float edge1, vec2 x);");
s.append("vec3 smoothstep(float edge0, float edge1, vec3 x);");
s.append("vec4 smoothstep(float edge0, float edge1, vec4 x);");
if (version >= 130) {
s.append(TString("bool isnan(float x);"));
s.append(TString("bvec2 isnan(vec2 x);"));
s.append(TString("bvec3 isnan(vec3 x);"));
s.append(TString("bvec4 isnan(vec4 x);"));
s.append(TString("bool isinf(float x);"));
s.append(TString("bvec2 isinf(vec2 x);"));
s.append(TString("bvec3 isinf(vec3 x);"));
s.append(TString("bvec4 isinf(vec4 x);"));
s.append("bool isnan(float x);");
s.append("bvec2 isnan(vec2 x);");
s.append("bvec3 isnan(vec3 x);");
s.append("bvec4 isnan(vec4 x);");
s.append("bool isinf(float x);");
s.append("bvec2 isinf(vec2 x);");
s.append("bvec3 isinf(vec3 x);");
s.append("bvec4 isinf(vec4 x);");
}
if (profile == EEsProfile && version >= 300 ||
profile != EEsProfile && version >= 330) {
s.append(TString("int floatBitsToInt(float value);"));
s.append(TString("ivec2 floatBitsToInt(vec2 value);"));
s.append(TString("ivec3 floatBitsToInt(vec3 value);"));
s.append(TString("ivec4 floatBitsToInt(vec4 value);"));
s.append(TString("uint floatBitsToUint(float value);"));
s.append(TString("uvec2 floatBitsToUint(vec2 value);"));
s.append(TString("uvec3 floatBitsToUint(vec3 value);"));
s.append(TString("uvec4 floatBitsToUint(vec4 value);"));
s.append(TString("float intBitsToFloat(int value);"));
s.append(TString("vec2 intBitsToFloat(ivec2 value);"));
s.append(TString("vec3 intBitsToFloat(ivec3 value);"));
s.append(TString("vec4 intBitsToFloat(ivec4 value);"));
s.append(TString("float uintBitsToFloat(uint value);"));
s.append(TString("vec2 uintBitsToFloat(uvec2 value);"));
s.append(TString("vec3 uintBitsToFloat(uvec3 value);"));
s.append(TString("vec4 uintBitsToFloat(uvec4 value);"));
s.append("int floatBitsToInt(float value);");
s.append("ivec2 floatBitsToInt(vec2 value);");
s.append("ivec3 floatBitsToInt(vec3 value);");
s.append("ivec4 floatBitsToInt(vec4 value);");
s.append("uint floatBitsToUint(float value);");
s.append("uvec2 floatBitsToUint(vec2 value);");
s.append("uvec3 floatBitsToUint(vec3 value);");
s.append("uvec4 floatBitsToUint(vec4 value);");
s.append("float intBitsToFloat(int value);");
s.append("vec2 intBitsToFloat(ivec2 value);");
s.append("vec3 intBitsToFloat(ivec3 value);");
s.append("vec4 intBitsToFloat(ivec4 value);");
s.append("float uintBitsToFloat(uint value);");
s.append("vec2 uintBitsToFloat(uvec2 value);");
s.append("vec3 uintBitsToFloat(uvec3 value);");
s.append("vec4 uintBitsToFloat(uvec4 value);");
}
if (profile == EEsProfile && version >= 300 ||
profile != EEsProfile && version >= 400) {
s.append(TString( "highp uint packSnorm2x16 (vec2);"));
s.append(TString( "highp vec2 unpackSnorm2x16 (highp uint);"));
s.append(TString( "highp uint packUnorm2x16 (vec2);"));
s.append(TString( "highp vec2 unpackUnorm2x16 (highp uint);"));
s.append(TString( "highp uint packHalf2x16(mediump vec2);"));
s.append(TString("mediump vec2 unpackHalf2x16(highp uint);"));
s.append( "highp uint packSnorm2x16 (vec2);");
s.append( "highp vec2 unpackSnorm2x16 (highp uint);");
s.append( "highp uint packUnorm2x16 (vec2);");
s.append( "highp vec2 unpackUnorm2x16 (highp uint);");
s.append( "highp uint packHalf2x16(mediump vec2);");
s.append("mediump vec2 unpackHalf2x16(highp uint);");
}
//
// Geometric Functions.
//
s.append(TString("float length(float x);"));
s.append(TString("float length(vec2 x);"));
s.append(TString("float length(vec3 x);"));
s.append(TString("float length(vec4 x);"));
s.append(TString("float distance(float p0, float p1);"));
s.append(TString("float distance(vec2 p0, vec2 p1);"));
s.append(TString("float distance(vec3 p0, vec3 p1);"));
s.append(TString("float distance(vec4 p0, vec4 p1);"));
s.append(TString("float dot(float x, float y);"));
s.append(TString("float dot(vec2 x, vec2 y);"));
s.append(TString("float dot(vec3 x, vec3 y);"));
s.append(TString("float dot(vec4 x, vec4 y);"));
s.append(TString("vec3 cross(vec3 x, vec3 y);"));
s.append(TString("float normalize(float x);"));
s.append(TString("vec2 normalize(vec2 x);"));
s.append(TString("vec3 normalize(vec3 x);"));
s.append(TString("vec4 normalize(vec4 x);"));
s.append(TString("float faceforward(float N, float I, float Nref);"));
s.append(TString("vec2 faceforward(vec2 N, vec2 I, vec2 Nref);"));
s.append(TString("vec3 faceforward(vec3 N, vec3 I, vec3 Nref);"));
s.append(TString("vec4 faceforward(vec4 N, vec4 I, vec4 Nref);"));
s.append(TString("float reflect(float I, float N);"));
s.append(TString("vec2 reflect(vec2 I, vec2 N);"));
s.append(TString("vec3 reflect(vec3 I, vec3 N);"));
s.append(TString("vec4 reflect(vec4 I, vec4 N);"));
s.append(TString("float refract(float I, float N, float eta);"));
s.append(TString("vec2 refract(vec2 I, vec2 N, float eta);"));
s.append(TString("vec3 refract(vec3 I, vec3 N, float eta);"));
s.append(TString("vec4 refract(vec4 I, vec4 N, float eta);"));
s.append("float length(float x);");
s.append("float length(vec2 x);");
s.append("float length(vec3 x);");
s.append("float length(vec4 x);");
s.append("float distance(float p0, float p1);");
s.append("float distance(vec2 p0, vec2 p1);");
s.append("float distance(vec3 p0, vec3 p1);");
s.append("float distance(vec4 p0, vec4 p1);");
s.append("float dot(float x, float y);");
s.append("float dot(vec2 x, vec2 y);");
s.append("float dot(vec3 x, vec3 y);");
s.append("float dot(vec4 x, vec4 y);");
s.append("vec3 cross(vec3 x, vec3 y);");
s.append("float normalize(float x);");
s.append("vec2 normalize(vec2 x);");
s.append("vec3 normalize(vec3 x);");
s.append("vec4 normalize(vec4 x);");
s.append("float faceforward(float N, float I, float Nref);");
s.append("vec2 faceforward(vec2 N, vec2 I, vec2 Nref);");
s.append("vec3 faceforward(vec3 N, vec3 I, vec3 Nref);");
s.append("vec4 faceforward(vec4 N, vec4 I, vec4 Nref);");
s.append("float reflect(float I, float N);");
s.append("vec2 reflect(vec2 I, vec2 N);");
s.append("vec3 reflect(vec3 I, vec3 N);");
s.append("vec4 reflect(vec4 I, vec4 N);");
s.append("float refract(float I, float N, float eta);");
s.append("vec2 refract(vec2 I, vec2 N, float eta);");
s.append("vec3 refract(vec3 I, vec3 N, float eta);");
s.append("vec4 refract(vec4 I, vec4 N, float eta);");
//
// Matrix Functions.
//
s.append(TString("mat2 matrixCompMult(mat2 x, mat2 y);"));
s.append(TString("mat3 matrixCompMult(mat3 x, mat3 y);"));
s.append(TString("mat4 matrixCompMult(mat4 x, mat4 y);"));
s.append("mat2 matrixCompMult(mat2 x, mat2 y);");
s.append("mat3 matrixCompMult(mat3 x, mat3 y);");
s.append("mat4 matrixCompMult(mat4 x, mat4 y);");
if (version >= 120) {
s.append(TString("mat2 outerProduct(vec2 c, vec2 r);"));
s.append(TString("mat3 outerProduct(vec3 c, vec3 r);"));
s.append(TString("mat4 outerProduct(vec4 c, vec4 r);"));
s.append(TString("mat2x3 outerProduct(vec3 c, vec2 r);"));
s.append(TString("mat3x2 outerProduct(vec2 c, vec3 r);"));
s.append(TString("mat2x4 outerProduct(vec4 c, vec2 r);"));
s.append(TString("mat4x2 outerProduct(vec2 c, vec4 r);"));
s.append(TString("mat3x4 outerProduct(vec4 c, vec3 r);"));
s.append(TString("mat4x3 outerProduct(vec3 c, vec4 r);"));
s.append(TString("mat2 transpose(mat2 m);"));
s.append(TString("mat3 transpose(mat3 m);"));
s.append(TString("mat4 transpose(mat4 m);"));
s.append(TString("mat2x3 transpose(mat3x2 m);"));
s.append(TString("mat3x2 transpose(mat2x3 m);"));
s.append(TString("mat2x4 transpose(mat4x2 m);"));
s.append(TString("mat4x2 transpose(mat2x4 m);"));
s.append(TString("mat3x4 transpose(mat4x3 m);"));
s.append(TString("mat4x3 transpose(mat3x4 m);"));
s.append("mat2 outerProduct(vec2 c, vec2 r);");
s.append("mat3 outerProduct(vec3 c, vec3 r);");
s.append("mat4 outerProduct(vec4 c, vec4 r);");
s.append("mat2x3 outerProduct(vec3 c, vec2 r);");
s.append("mat3x2 outerProduct(vec2 c, vec3 r);");
s.append("mat2x4 outerProduct(vec4 c, vec2 r);");
s.append("mat4x2 outerProduct(vec2 c, vec4 r);");
s.append("mat3x4 outerProduct(vec4 c, vec3 r);");
s.append("mat4x3 outerProduct(vec3 c, vec4 r);");
s.append("mat2 transpose(mat2 m);");
s.append("mat3 transpose(mat3 m);");
s.append("mat4 transpose(mat4 m);");
s.append("mat2x3 transpose(mat3x2 m);");
s.append("mat3x2 transpose(mat2x3 m);");
s.append("mat2x4 transpose(mat4x2 m);");
s.append("mat4x2 transpose(mat2x4 m);");
s.append("mat3x4 transpose(mat4x3 m);");
s.append("mat4x3 transpose(mat3x4 m);");
if (version >= 150) {
s.append(TString("float determinant(mat2 m);"));
s.append(TString("float determinant(mat3 m);"));
s.append(TString("float determinant(mat4 m);"));
s.append("float determinant(mat2 m);");
s.append("float determinant(mat3 m);");
s.append("float determinant(mat4 m);");
s.append(TString("mat2 inverse(mat2 m);"));
s.append(TString("mat3 inverse(mat3 m);"));
s.append(TString("mat4 inverse(mat4 m);"));
s.append("mat2 inverse(mat2 m);");
s.append("mat3 inverse(mat3 m);");
s.append("mat4 inverse(mat4 m);");
}
}
//
// Vector relational functions.
//
s.append(TString("bvec2 lessThan(vec2 x, vec2 y);"));
s.append(TString("bvec3 lessThan(vec3 x, vec3 y);"));
s.append(TString("bvec4 lessThan(vec4 x, vec4 y);"));
s.append("bvec2 lessThan(vec2 x, vec2 y);");
s.append("bvec3 lessThan(vec3 x, vec3 y);");
s.append("bvec4 lessThan(vec4 x, vec4 y);");
s.append(TString("bvec2 lessThan(ivec2 x, ivec2 y);"));
s.append(TString("bvec3 lessThan(ivec3 x, ivec3 y);"));
s.append(TString("bvec4 lessThan(ivec4 x, ivec4 y);"));
s.append("bvec2 lessThan(ivec2 x, ivec2 y);");
s.append("bvec3 lessThan(ivec3 x, ivec3 y);");
s.append("bvec4 lessThan(ivec4 x, ivec4 y);");
s.append(TString("bvec2 lessThanEqual(vec2 x, vec2 y);"));
s.append(TString("bvec3 lessThanEqual(vec3 x, vec3 y);"));
s.append(TString("bvec4 lessThanEqual(vec4 x, vec4 y);"));
s.append("bvec2 lessThanEqual(vec2 x, vec2 y);");
s.append("bvec3 lessThanEqual(vec3 x, vec3 y);");
s.append("bvec4 lessThanEqual(vec4 x, vec4 y);");
s.append(TString("bvec2 lessThanEqual(ivec2 x, ivec2 y);"));
s.append(TString("bvec3 lessThanEqual(ivec3 x, ivec3 y);"));
s.append(TString("bvec4 lessThanEqual(ivec4 x, ivec4 y);"));
s.append("bvec2 lessThanEqual(ivec2 x, ivec2 y);");
s.append("bvec3 lessThanEqual(ivec3 x, ivec3 y);");
s.append("bvec4 lessThanEqual(ivec4 x, ivec4 y);");
s.append(TString("bvec2 greaterThan(vec2 x, vec2 y);"));
s.append(TString("bvec3 greaterThan(vec3 x, vec3 y);"));
s.append(TString("bvec4 greaterThan(vec4 x, vec4 y);"));
s.append("bvec2 greaterThan(vec2 x, vec2 y);");
s.append("bvec3 greaterThan(vec3 x, vec3 y);");
s.append("bvec4 greaterThan(vec4 x, vec4 y);");
s.append(TString("bvec2 greaterThan(ivec2 x, ivec2 y);"));
s.append(TString("bvec3 greaterThan(ivec3 x, ivec3 y);"));
s.append(TString("bvec4 greaterThan(ivec4 x, ivec4 y);"));
s.append("bvec2 greaterThan(ivec2 x, ivec2 y);");
s.append("bvec3 greaterThan(ivec3 x, ivec3 y);");
s.append("bvec4 greaterThan(ivec4 x, ivec4 y);");
s.append(TString("bvec2 greaterThanEqual(vec2 x, vec2 y);"));
s.append(TString("bvec3 greaterThanEqual(vec3 x, vec3 y);"));
s.append(TString("bvec4 greaterThanEqual(vec4 x, vec4 y);"));
s.append("bvec2 greaterThanEqual(vec2 x, vec2 y);");
s.append("bvec3 greaterThanEqual(vec3 x, vec3 y);");
s.append("bvec4 greaterThanEqual(vec4 x, vec4 y);");
s.append(TString("bvec2 greaterThanEqual(ivec2 x, ivec2 y);"));
s.append(TString("bvec3 greaterThanEqual(ivec3 x, ivec3 y);"));
s.append(TString("bvec4 greaterThanEqual(ivec4 x, ivec4 y);"));
s.append("bvec2 greaterThanEqual(ivec2 x, ivec2 y);");
s.append("bvec3 greaterThanEqual(ivec3 x, ivec3 y);");
s.append("bvec4 greaterThanEqual(ivec4 x, ivec4 y);");
s.append(TString("bvec2 equal(vec2 x, vec2 y);"));
s.append(TString("bvec3 equal(vec3 x, vec3 y);"));
s.append(TString("bvec4 equal(vec4 x, vec4 y);"));
s.append("bvec2 equal(vec2 x, vec2 y);");
s.append("bvec3 equal(vec3 x, vec3 y);");
s.append("bvec4 equal(vec4 x, vec4 y);");
s.append(TString("bvec2 equal(ivec2 x, ivec2 y);"));
s.append(TString("bvec3 equal(ivec3 x, ivec3 y);"));
s.append(TString("bvec4 equal(ivec4 x, ivec4 y);"));
s.append("bvec2 equal(ivec2 x, ivec2 y);");
s.append("bvec3 equal(ivec3 x, ivec3 y);");
s.append("bvec4 equal(ivec4 x, ivec4 y);");
s.append(TString("bvec2 equal(bvec2 x, bvec2 y);"));
s.append(TString("bvec3 equal(bvec3 x, bvec3 y);"));
s.append(TString("bvec4 equal(bvec4 x, bvec4 y);"));
s.append("bvec2 equal(bvec2 x, bvec2 y);");
s.append("bvec3 equal(bvec3 x, bvec3 y);");
s.append("bvec4 equal(bvec4 x, bvec4 y);");
s.append(TString("bvec2 notEqual(vec2 x, vec2 y);"));
s.append(TString("bvec3 notEqual(vec3 x, vec3 y);"));
s.append(TString("bvec4 notEqual(vec4 x, vec4 y);"));
s.append("bvec2 notEqual(vec2 x, vec2 y);");
s.append("bvec3 notEqual(vec3 x, vec3 y);");
s.append("bvec4 notEqual(vec4 x, vec4 y);");
s.append(TString("bvec2 notEqual(ivec2 x, ivec2 y);"));
s.append(TString("bvec3 notEqual(ivec3 x, ivec3 y);"));
s.append(TString("bvec4 notEqual(ivec4 x, ivec4 y);"));
s.append("bvec2 notEqual(ivec2 x, ivec2 y);");
s.append("bvec3 notEqual(ivec3 x, ivec3 y);");
s.append("bvec4 notEqual(ivec4 x, ivec4 y);");
s.append(TString("bvec2 notEqual(bvec2 x, bvec2 y);"));
s.append(TString("bvec3 notEqual(bvec3 x, bvec3 y);"));
s.append(TString("bvec4 notEqual(bvec4 x, bvec4 y);"));
s.append("bvec2 notEqual(bvec2 x, bvec2 y);");
s.append("bvec3 notEqual(bvec3 x, bvec3 y);");
s.append("bvec4 notEqual(bvec4 x, bvec4 y);");
s.append(TString("bool any(bvec2 x);"));
s.append(TString("bool any(bvec3 x);"));
s.append(TString("bool any(bvec4 x);"));
s.append("bool any(bvec2 x);");
s.append("bool any(bvec3 x);");
s.append("bool any(bvec4 x);");
s.append(TString("bool all(bvec2 x);"));
s.append(TString("bool all(bvec3 x);"));
s.append(TString("bool all(bvec4 x);"));
s.append("bool all(bvec2 x);");
s.append("bool all(bvec3 x);");
s.append("bool all(bvec4 x);");
s.append(TString("bvec2 not(bvec2 x);"));
s.append(TString("bvec3 not(bvec3 x);"));
s.append(TString("bvec4 not(bvec4 x);"));
s.append("bvec2 not(bvec2 x);");
s.append("bvec3 not(bvec3 x);");
s.append("bvec4 not(bvec4 x);");
s.append(TString("\n"));
s.append("\n");
//
// Original-style texture Functions existing in both stages.
......@@ -587,58 +587,58 @@ void TBuiltIns::initialize(int version, EProfile profile)
//
if (profile == EEsProfile && version == 100 ||
profile == ECompatibilityProfile || version < FirstProfileVersion) {
s.append(TString("vec4 texture2D(sampler2D, vec2);"));
s.append("vec4 texture2D(sampler2D, vec2);");
s.append(TString("vec4 texture2DProj(sampler2D, vec3);"));
s.append(TString("vec4 texture2DProj(sampler2D, vec4);"));
s.append("vec4 texture2DProj(sampler2D, vec3);");
s.append("vec4 texture2DProj(sampler2D, vec4);");
s.append(TString("vec4 textureCube(samplerCube, vec3);"));
s.append("vec4 textureCube(samplerCube, vec3);");
}
if (profile != EEsProfile &&
(profile == ECompatibilityProfile || version < FirstProfileVersion)) {
s.append(TString("vec4 texture1D(sampler1D, float);"));
s.append("vec4 texture1D(sampler1D, float);");
s.append(TString("vec4 texture1DProj(sampler1D, vec2);"));
s.append(TString("vec4 texture1DProj(sampler1D, vec4);"));
s.append("vec4 texture1DProj(sampler1D, vec2);");
s.append("vec4 texture1DProj(sampler1D, vec4);");
s.append(TString("vec4 texture3D(sampler3D, vec3);"));
s.append(TString("vec4 texture3DProj(sampler3D, vec4);"));
s.append("vec4 texture3D(sampler3D, vec3);");
s.append("vec4 texture3DProj(sampler3D, vec4);");
s.append(TString("vec4 shadow1D(sampler1DShadow, vec3);"));
s.append(TString("vec4 shadow2D(sampler2DShadow, vec3);"));
s.append(TString("vec4 shadow1DProj(sampler1DShadow, vec4);"));
s.append(TString("vec4 shadow2DProj(sampler2DShadow, vec4);"));
s.append("vec4 shadow1D(sampler1DShadow, vec3);");
s.append("vec4 shadow2D(sampler2DShadow, vec3);");
s.append("vec4 shadow1DProj(sampler1DShadow, vec4);");
s.append("vec4 shadow2DProj(sampler2DShadow, vec4);");
// TODO: functionality: non-ES legacy texuring for Lod, others?
}
s.append(TString("\n"));
s.append("\n");
//
// Noise functions.
//
if (profile != EEsProfile) {
s.append(TString("float noise1(float x);"));
s.append(TString("float noise1(vec2 x);"));
s.append(TString("float noise1(vec3 x);"));
s.append(TString("float noise1(vec4 x);"));
s.append(TString("vec2 noise2(float x);"));
s.append(TString("vec2 noise2(vec2 x);"));
s.append(TString("vec2 noise2(vec3 x);"));
s.append(TString("vec2 noise2(vec4 x);"));
s.append(TString("vec3 noise3(float x);"));
s.append(TString("vec3 noise3(vec2 x);"));
s.append(TString("vec3 noise3(vec3 x);"));
s.append(TString("vec3 noise3(vec4 x);"));
s.append(TString("vec4 noise4(float x);"));
s.append(TString("vec4 noise4(vec2 x);"));
s.append(TString("vec4 noise4(vec3 x);"));
s.append(TString("vec4 noise4(vec4 x);"));
s.append(TString("\n"));
s.append("float noise1(float x);");
s.append("float noise1(vec2 x);");
s.append("float noise1(vec3 x);");
s.append("float noise1(vec4 x);");
s.append("vec2 noise2(float x);");
s.append("vec2 noise2(vec2 x);");
s.append("vec2 noise2(vec3 x);");
s.append("vec2 noise2(vec4 x);");
s.append("vec3 noise3(float x);");
s.append("vec3 noise3(vec2 x);");
s.append("vec3 noise3(vec3 x);");
s.append("vec3 noise3(vec4 x);");
s.append("vec4 noise4(float x);");
s.append("vec4 noise4(vec2 x);");
s.append("vec4 noise4(vec3 x);");
s.append("vec4 noise4(vec4 x);");
s.append("\n");
}
}
{
......@@ -654,29 +654,29 @@ void TBuiltIns::initialize(int version, EProfile profile)
// Geometric Functions.
//
if (profile != EEsProfile)
s.append(TString("vec4 ftransform();"));
s.append("vec4 ftransform();");
//
// Original-style texture Functions with lod.
//
if (profile != EEsProfile || version == 100) {
s.append(TString("vec4 texture2DLod(sampler2D, vec2, float);"));
s.append(TString("vec4 texture2DProjLod(sampler2D, vec3, float);"));
s.append(TString("vec4 texture2DProjLod(sampler2D, vec4, float);"));
s.append(TString("vec4 textureCubeLod(samplerCube, vec3, float);"));
s.append("vec4 texture2DLod(sampler2D, vec2, float);");
s.append("vec4 texture2DProjLod(sampler2D, vec3, float);");
s.append("vec4 texture2DProjLod(sampler2D, vec4, float);");
s.append("vec4 textureCubeLod(samplerCube, vec3, float);");
}
if (profile != EEsProfile && version > 100) {
s.append(TString("vec4 texture1DLod(sampler1D, float, float);"));
s.append(TString("vec4 texture1DProjLod(sampler1D, vec2, float);"));
s.append(TString("vec4 texture1DProjLod(sampler1D, vec4, float);"));
s.append(TString("vec4 texture3DLod(sampler3D, vec3, float);"));
s.append(TString("vec4 texture3DProjLod(sampler3D, vec4, float);"));
s.append(TString("vec4 shadow1DLod(sampler1DShadow, vec3, float);"));
s.append(TString("vec4 shadow2DLod(sampler2DShadow, vec3, float);"));
s.append(TString("vec4 shadow1DProjLod(sampler1DShadow, vec4, float);"));
s.append(TString("vec4 shadow2DProjLod(sampler2DShadow, vec4, float);"));
s.append("vec4 texture1DLod(sampler1D, float, float);");
s.append("vec4 texture1DProjLod(sampler1D, vec2, float);");
s.append("vec4 texture1DProjLod(sampler1D, vec4, float);");
s.append("vec4 texture3DLod(sampler3D, vec3, float);");
s.append("vec4 texture3DProjLod(sampler3D, vec4, float);");
s.append("vec4 shadow1DLod(sampler1DShadow, vec3, float);");
s.append("vec4 shadow2DLod(sampler2DShadow, vec3, float);");
s.append("vec4 shadow1DProjLod(sampler1DShadow, vec4, float);");
s.append("vec4 shadow2DProjLod(sampler2DShadow, vec4, float);");
}
s.append(TString("\n"));
s.append("\n");
}
if (profile != EEsProfile && version >= 150) {
//============================================================================
......@@ -688,12 +688,12 @@ void TBuiltIns::initialize(int version, EProfile profile)
TString& s = stageBuiltins[EShLangGeometry];
if (version >= 400) {
s.append(TString("void EmitStreamVertex(int);"));
s.append(TString("void EndStreamPrimitive(int);"));
s.append("void EmitStreamVertex(int);");
s.append("void EndStreamPrimitive(int);");
}
s.append(TString("void EmitVertex();"));
s.append(TString("void EndPrimitive();"));
s.append(TString("\n"));
s.append("void EmitVertex();");
s.append("void EndPrimitive();");
s.append("\n");
}
if (profile != EEsProfile) {
//============================================================================
......@@ -730,39 +730,39 @@ void TBuiltIns::initialize(int version, EProfile profile)
// Original-style texture Functions with bias.
//
if (profile != EEsProfile || version == 100) {
s.append(TString("vec4 texture2D(sampler2D, vec2, float);"));
s.append(TString("vec4 texture2DProj(sampler2D, vec3, float);"));
s.append(TString("vec4 texture2DProj(sampler2D, vec4, float);"));
s.append(TString("vec4 textureCube(samplerCube, vec3, float);"));
s.append("vec4 texture2D(sampler2D, vec2, float);");
s.append("vec4 texture2DProj(sampler2D, vec3, float);");
s.append("vec4 texture2DProj(sampler2D, vec4, float);");
s.append("vec4 textureCube(samplerCube, vec3, float);");
}
if (profile != EEsProfile && version > 100) {
s.append(TString("vec4 texture1D(sampler1D, float, float);"));
s.append(TString("vec4 texture1DProj(sampler1D, vec2, float);"));
s.append(TString("vec4 texture1DProj(sampler1D, vec4, float);"));
s.append(TString("vec4 texture3D(sampler3D, vec3, float);"));
s.append(TString("vec4 texture3DProj(sampler3D, vec4, float);"));
s.append(TString("vec4 shadow1D(sampler1DShadow, vec3, float);"));
s.append(TString("vec4 shadow2D(sampler2DShadow, vec3, float);"));
s.append(TString("vec4 shadow1DProj(sampler1DShadow, vec4, float);"));
s.append(TString("vec4 shadow2DProj(sampler2DShadow, vec4, float);"));
s.append("vec4 texture1D(sampler1D, float, float);");
s.append("vec4 texture1DProj(sampler1D, vec2, float);");
s.append("vec4 texture1DProj(sampler1D, vec4, float);");
s.append("vec4 texture3D(sampler3D, vec3, float);");
s.append("vec4 texture3DProj(sampler3D, vec4, float);");
s.append("vec4 shadow1D(sampler1DShadow, vec3, float);");
s.append("vec4 shadow2D(sampler2DShadow, vec3, float);");
s.append("vec4 shadow1DProj(sampler1DShadow, vec4, float);");
s.append("vec4 shadow2DProj(sampler2DShadow, vec4, float);");
}
s.append(TString("float dFdx(float p);"));
s.append(TString("vec2 dFdx(vec2 p);"));
s.append(TString("vec3 dFdx(vec3 p);"));
s.append(TString("vec4 dFdx(vec4 p);"));
s.append("float dFdx(float p);");
s.append("vec2 dFdx(vec2 p);");
s.append("vec3 dFdx(vec3 p);");
s.append("vec4 dFdx(vec4 p);");
s.append(TString("float dFdy(float p);"));
s.append(TString("vec2 dFdy(vec2 p);"));
s.append(TString("vec3 dFdy(vec3 p);"));
s.append(TString("vec4 dFdy(vec4 p);"));
s.append("float dFdy(float p);");
s.append("vec2 dFdy(vec2 p);");
s.append("vec3 dFdy(vec3 p);");
s.append("vec4 dFdy(vec4 p);");
s.append(TString("float fwidth(float p);"));
s.append(TString("vec2 fwidth(vec2 p);"));
s.append(TString("vec3 fwidth(vec3 p);"));
s.append(TString("vec4 fwidth(vec4 p);"));
s.append("float fwidth(float p);");
s.append("vec2 fwidth(vec2 p);");
s.append("vec3 fwidth(vec3 p);");
s.append("vec4 fwidth(vec4 p);");
s.append(TString("\n"));
s.append("\n");
}
{
//============================================================================
......@@ -776,138 +776,138 @@ void TBuiltIns::initialize(int version, EProfile profile)
//
// Depth range in window coordinates, p. 33
//
s.append(TString("struct gl_DepthRangeParameters {"));
s.append("struct gl_DepthRangeParameters {");
if (profile == EEsProfile) {
s.append(TString(" highp float near;")); // n
s.append(TString(" highp float far;")); // f
s.append(TString(" highp float diff;")); // f - n
s.append(" highp float near;"); // n
s.append(" highp float far;"); // f
s.append(" highp float diff;"); // f - n
} else {
s.append(TString(" float near;")); // n
s.append(TString(" float far;")); // f
s.append(TString(" float diff;")); // f - n
s.append(" float near;"); // n
s.append(" float far;"); // f
s.append(" float diff;"); // f - n
}
s.append(TString("};"));
s.append(TString("uniform gl_DepthRangeParameters gl_DepthRange;"));
s.append("};");
s.append("uniform gl_DepthRangeParameters gl_DepthRange;");
if (profile != EEsProfile && (version < FirstProfileVersion || profile == ECompatibilityProfile)) {
//
// Matrix state. p. 31, 32, 37, 39, 40.
//
s.append(TString("uniform mat4 gl_ModelViewMatrix;"));
s.append(TString("uniform mat4 gl_ProjectionMatrix;"));
s.append(TString("uniform mat4 gl_ModelViewProjectionMatrix;"));
s.append("uniform mat4 gl_ModelViewMatrix;");
s.append("uniform mat4 gl_ProjectionMatrix;");
s.append("uniform mat4 gl_ModelViewProjectionMatrix;");
//
// Derived matrix state that provides inverse and transposed versions
// of the matrices above.
//
s.append(TString("uniform mat3 gl_NormalMatrix;"));
s.append("uniform mat3 gl_NormalMatrix;");
s.append(TString("uniform mat4 gl_ModelViewMatrixInverse;"));
s.append(TString("uniform mat4 gl_ProjectionMatrixInverse;"));
s.append(TString("uniform mat4 gl_ModelViewProjectionMatrixInverse;"));
s.append("uniform mat4 gl_ModelViewMatrixInverse;");
s.append("uniform mat4 gl_ProjectionMatrixInverse;");
s.append("uniform mat4 gl_ModelViewProjectionMatrixInverse;");
s.append(TString("uniform mat4 gl_ModelViewMatrixTranspose;"));
s.append(TString("uniform mat4 gl_ProjectionMatrixTranspose;"));
s.append(TString("uniform mat4 gl_ModelViewProjectionMatrixTranspose;"));
s.append("uniform mat4 gl_ModelViewMatrixTranspose;");
s.append("uniform mat4 gl_ProjectionMatrixTranspose;");
s.append("uniform mat4 gl_ModelViewProjectionMatrixTranspose;");
s.append(TString("uniform mat4 gl_ModelViewMatrixInverseTranspose;"));
s.append(TString("uniform mat4 gl_ProjectionMatrixInverseTranspose;"));
s.append(TString("uniform mat4 gl_ModelViewProjectionMatrixInverseTranspose;"));
s.append("uniform mat4 gl_ModelViewMatrixInverseTranspose;");
s.append("uniform mat4 gl_ProjectionMatrixInverseTranspose;");
s.append("uniform mat4 gl_ModelViewProjectionMatrixInverseTranspose;");
//
// Normal scaling p. 39.
//
s.append(TString("uniform float gl_NormalScale;"));
s.append("uniform float gl_NormalScale;");
//
// Point Size, p. 66, 67.
//
s.append(TString("struct gl_PointParameters {"));
s.append(TString(" float size;"));
s.append(TString(" float sizeMin;"));
s.append(TString(" float sizeMax;"));
s.append(TString(" float fadeThresholdSize;"));
s.append(TString(" float distanceConstantAttenuation;"));
s.append(TString(" float distanceLinearAttenuation;"));
s.append(TString(" float distanceQuadraticAttenuation;"));
s.append(TString("};"));
s.append(TString("uniform gl_PointParameters gl_Point;"));
s.append("struct gl_PointParameters {");
s.append(" float size;");
s.append(" float sizeMin;");
s.append(" float sizeMax;");
s.append(" float fadeThresholdSize;");
s.append(" float distanceConstantAttenuation;");
s.append(" float distanceLinearAttenuation;");
s.append(" float distanceQuadraticAttenuation;");
s.append("};");
s.append("uniform gl_PointParameters gl_Point;");
//
// Material State p. 50, 55.
//
s.append(TString("struct gl_MaterialParameters {"));
s.append(TString(" vec4 emission;")); // Ecm
s.append(TString(" vec4 ambient;")); // Acm
s.append(TString(" vec4 diffuse;")); // Dcm
s.append(TString(" vec4 specular;")); // Scm
s.append(TString(" float shininess;")); // Srm
s.append(TString("};"));
s.append(TString("uniform gl_MaterialParameters gl_FrontMaterial;"));
s.append(TString("uniform gl_MaterialParameters gl_BackMaterial;"));
s.append("struct gl_MaterialParameters {");
s.append(" vec4 emission;"); // Ecm
s.append(" vec4 ambient;"); // Acm
s.append(" vec4 diffuse;"); // Dcm
s.append(" vec4 specular;"); // Scm
s.append(" float shininess;"); // Srm
s.append("};");
s.append("uniform gl_MaterialParameters gl_FrontMaterial;");
s.append("uniform gl_MaterialParameters gl_BackMaterial;");
//
// Light State p 50, 53, 55.
//
s.append(TString("struct gl_LightSourceParameters {"));
s.append(TString(" vec4 ambient;")); // Acli
s.append(TString(" vec4 diffuse;")); // Dcli
s.append(TString(" vec4 specular;")); // Scli
s.append(TString(" vec4 position;")); // Ppli
s.append(TString(" vec4 halfVector;")); // Derived: Hi
s.append(TString(" vec3 spotDirection;")); // Sdli
s.append(TString(" float spotExponent;")); // Srli
s.append(TString(" float spotCutoff;")); // Crli
s.append("struct gl_LightSourceParameters {");
s.append(" vec4 ambient;"); // Acli
s.append(" vec4 diffuse;"); // Dcli
s.append(" vec4 specular;"); // Scli
s.append(" vec4 position;"); // Ppli
s.append(" vec4 halfVector;"); // Derived: Hi
s.append(" vec3 spotDirection;"); // Sdli
s.append(" float spotExponent;"); // Srli
s.append(" float spotCutoff;"); // Crli
// (range: [0.0,90.0], 180.0)
s.append(TString(" float spotCosCutoff;")); // Derived: cos(Crli)
s.append(" float spotCosCutoff;"); // Derived: cos(Crli)
// (range: [1.0,0.0],-1.0)
s.append(TString(" float constantAttenuation;")); // K0
s.append(TString(" float linearAttenuation;")); // K1
s.append(TString(" float quadraticAttenuation;"));// K2
s.append(TString("};"));
s.append(" float constantAttenuation;"); // K0
s.append(" float linearAttenuation;"); // K1
s.append(" float quadraticAttenuation;");// K2
s.append("};");
s.append(TString("struct gl_LightModelParameters {"));
s.append(TString(" vec4 ambient;")); // Acs
s.append(TString("};"));
s.append("struct gl_LightModelParameters {");
s.append(" vec4 ambient;"); // Acs
s.append("};");
s.append(TString("uniform gl_LightModelParameters gl_LightModel;"));
s.append("uniform gl_LightModelParameters gl_LightModel;");
//
// Derived state from products of light and material.
//
s.append(TString("struct gl_LightModelProducts {"));
s.append(TString(" vec4 sceneColor;")); // Derived. Ecm + Acm * Acs
s.append(TString("};"));
s.append("struct gl_LightModelProducts {");
s.append(" vec4 sceneColor;"); // Derived. Ecm + Acm * Acs
s.append("};");
s.append(TString("uniform gl_LightModelProducts gl_FrontLightModelProduct;"));
s.append(TString("uniform gl_LightModelProducts gl_BackLightModelProduct;"));
s.append("uniform gl_LightModelProducts gl_FrontLightModelProduct;");
s.append("uniform gl_LightModelProducts gl_BackLightModelProduct;");
s.append(TString("struct gl_LightProducts {"));
s.append(TString(" vec4 ambient;")); // Acm * Acli
s.append(TString(" vec4 diffuse;")); // Dcm * Dcli
s.append(TString(" vec4 specular;")); // Scm * Scli
s.append(TString("};"));
s.append("struct gl_LightProducts {");
s.append(" vec4 ambient;"); // Acm * Acli
s.append(" vec4 diffuse;"); // Dcm * Dcli
s.append(" vec4 specular;"); // Scm * Scli
s.append("};");
//
// Fog p. 161
//
s.append(TString("struct gl_FogParameters {"));
s.append(TString(" vec4 color;"));
s.append(TString(" float density;"));
s.append(TString(" float start;"));
s.append(TString(" float end;"));
s.append(TString(" float scale;")); // 1 / (gl_FogEnd - gl_FogStart)
s.append(TString("};"));
s.append(TString("uniform gl_FogParameters gl_Fog;"));
s.append("struct gl_FogParameters {");
s.append(" vec4 color;");
s.append(" float density;");
s.append(" float start;");
s.append(" float end;");
s.append(" float scale;"); // 1 / (gl_FogEnd - gl_FogStart)
s.append("};");
s.append("uniform gl_FogParameters gl_Fog;");
}
s.append(TString("\n"));
s.append("\n");
}
//============================================================================
//
......@@ -919,36 +919,36 @@ void TBuiltIns::initialize(int version, EProfile profile)
TString& s = stageBuiltins[EShLangVertex];
if (version < 130) {
s.append(TString("attribute vec4 gl_Color;"));
s.append(TString("attribute vec4 gl_SecondaryColor;"));
s.append(TString("attribute vec3 gl_Normal;"));
s.append(TString("attribute vec4 gl_Vertex;"));
s.append(TString("attribute vec4 gl_MultiTexCoord0;"));
s.append(TString("attribute vec4 gl_MultiTexCoord1;"));
s.append(TString("attribute vec4 gl_MultiTexCoord2;"));
s.append(TString("attribute vec4 gl_MultiTexCoord3;"));
s.append(TString("attribute vec4 gl_MultiTexCoord4;"));
s.append(TString("attribute vec4 gl_MultiTexCoord5;"));
s.append(TString("attribute vec4 gl_MultiTexCoord6;"));
s.append(TString("attribute vec4 gl_MultiTexCoord7;"));
s.append(TString("attribute float gl_FogCoord;"));
s.append("attribute vec4 gl_Color;");
s.append("attribute vec4 gl_SecondaryColor;");
s.append("attribute vec3 gl_Normal;");
s.append("attribute vec4 gl_Vertex;");
s.append("attribute vec4 gl_MultiTexCoord0;");
s.append("attribute vec4 gl_MultiTexCoord1;");
s.append("attribute vec4 gl_MultiTexCoord2;");
s.append("attribute vec4 gl_MultiTexCoord3;");
s.append("attribute vec4 gl_MultiTexCoord4;");
s.append("attribute vec4 gl_MultiTexCoord5;");
s.append("attribute vec4 gl_MultiTexCoord6;");
s.append("attribute vec4 gl_MultiTexCoord7;");
s.append("attribute float gl_FogCoord;");
} else if (version < FirstProfileVersion || profile == ECompatibilityProfile) {
s.append(TString("in vec4 gl_Color;"));
s.append(TString("in vec4 gl_SecondaryColor;"));
s.append(TString("in vec3 gl_Normal;"));
s.append(TString("in vec4 gl_Vertex;"));
s.append(TString("in vec4 gl_MultiTexCoord0;"));
s.append(TString("in vec4 gl_MultiTexCoord1;"));
s.append(TString("in vec4 gl_MultiTexCoord2;"));
s.append(TString("in vec4 gl_MultiTexCoord3;"));
s.append(TString("in vec4 gl_MultiTexCoord4;"));
s.append(TString("in vec4 gl_MultiTexCoord5;"));
s.append(TString("in vec4 gl_MultiTexCoord6;"));
s.append(TString("in vec4 gl_MultiTexCoord7;"));
s.append(TString("in float gl_FogCoord;"));
s.append("in vec4 gl_Color;");
s.append("in vec4 gl_SecondaryColor;");
s.append("in vec3 gl_Normal;");
s.append("in vec4 gl_Vertex;");
s.append("in vec4 gl_MultiTexCoord0;");
s.append("in vec4 gl_MultiTexCoord1;");
s.append("in vec4 gl_MultiTexCoord2;");
s.append("in vec4 gl_MultiTexCoord3;");
s.append("in vec4 gl_MultiTexCoord4;");
s.append("in vec4 gl_MultiTexCoord5;");
s.append("in vec4 gl_MultiTexCoord6;");
s.append("in vec4 gl_MultiTexCoord7;");
s.append("in float gl_FogCoord;");
}
s.append(TString("\n"));
s.append("\n");
}
//============================================================================
//
......@@ -960,22 +960,22 @@ void TBuiltIns::initialize(int version, EProfile profile)
TString& s = stageBuiltins[EShLangVertex];
if (version < 130) {
s.append(TString("varying vec4 gl_FrontColor;"));
s.append(TString("varying vec4 gl_BackColor;"));
s.append(TString("varying vec4 gl_FrontSecondaryColor;"));
s.append(TString("varying vec4 gl_BackSecondaryColor;"));
s.append(TString("varying vec4 gl_TexCoord[];"));
s.append(TString("varying float gl_FogFragCoord;"));
s.append("varying vec4 gl_FrontColor;");
s.append("varying vec4 gl_BackColor;");
s.append("varying vec4 gl_FrontSecondaryColor;");
s.append("varying vec4 gl_BackSecondaryColor;");
s.append("varying vec4 gl_TexCoord[];");
s.append("varying float gl_FogFragCoord;");
} else if (version < FirstProfileVersion || profile == ECompatibilityProfile) {
s.append(TString("out vec4 gl_FrontColor;"));
s.append(TString("out vec4 gl_BackColor;"));
s.append(TString("out vec4 gl_FrontSecondaryColor;"));
s.append(TString("out vec4 gl_BackSecondaryColor;"));
s.append(TString("out vec4 gl_TexCoord[];"));
s.append(TString("out float gl_FogFragCoord;"));
s.append("out vec4 gl_FrontColor;");
s.append("out vec4 gl_BackColor;");
s.append("out vec4 gl_FrontSecondaryColor;");
s.append("out vec4 gl_BackSecondaryColor;");
s.append("out vec4 gl_TexCoord[];");
s.append("out float gl_FogFragCoord;");
}
s.append(TString("\n"));
s.append("\n");
}
{
//============================================================================
......@@ -987,23 +987,25 @@ void TBuiltIns::initialize(int version, EProfile profile)
if (profile != EEsProfile) {
TString& s = stageBuiltins[EShLangFragment];
if (version < 130) {
s.append(TString("varying vec4 gl_Color;"));
s.append(TString("varying vec4 gl_SecondaryColor;"));
s.append(TString("varying vec4 gl_TexCoord[];"));
s.append(TString("varying float gl_FogFragCoord;"));
s.append("varying vec4 gl_Color;");
s.append("varying vec4 gl_SecondaryColor;");
s.append("varying vec4 gl_TexCoord[];");
s.append("varying float gl_FogFragCoord;");
} else if (version < FirstProfileVersion || profile == ECompatibilityProfile) {
s.append(TString("in vec4 gl_Color;"));
s.append(TString("in vec4 gl_SecondaryColor;"));
s.append(TString("in vec4 gl_TexCoord[];"));
s.append(TString("in float gl_FogFragCoord;"));
s.append("in vec4 gl_Color;");
s.append("in vec4 gl_SecondaryColor;");
s.append("in vec4 gl_TexCoord[];");
s.append("in float gl_FogFragCoord;");
}
s.append(TString("\n"));
s.append("\n");
}
}
if (version >= 130)
add2ndGenerationSamplingImaging(version, profile);
//printf("%s\n", commonBuiltins.c_str();
}
void TBuiltIns::add2ndGenerationSamplingImaging(int version, EProfile profile)
......@@ -1309,84 +1311,83 @@ void TBuiltIns::initialize(const TBuiltInResource &resources, int version, EProf
char builtInConstant[maxSize];
//
// Implementation dependent constants. The example values below
// are the minimum values allowed for these maximums.
// Build string of implementation dependent constants.
//
if (profile == EEsProfile) {
snprintf(builtInConstant, maxSize, "const mediump int gl_MaxVertexAttribs = %d;", resources.maxVertexAttribs);
s.append(TString(builtInConstant));
s.append(builtInConstant);
snprintf(builtInConstant, maxSize, "const mediump int gl_MaxVertexUniformVectors = %d;", resources.maxVertexUniformVectors);
s.append(TString(builtInConstant));
s.append(builtInConstant);
snprintf(builtInConstant, maxSize, "const mediump int gl_MaxVertexTextureImageUnits = %d;", resources.maxVertexTextureImageUnits);
s.append(TString(builtInConstant));
s.append(builtInConstant);
snprintf(builtInConstant, maxSize, "const mediump int gl_MaxCombinedTextureImageUnits = %d;", resources.maxCombinedTextureImageUnits);
s.append(TString(builtInConstant));
s.append(builtInConstant);
snprintf(builtInConstant, maxSize, "const mediump int gl_MaxTextureImageUnits = %d;", resources.maxTextureImageUnits);
s.append(TString(builtInConstant));
s.append(builtInConstant);
snprintf(builtInConstant, maxSize, "const mediump int gl_MaxFragmentUniformVectors = %d;", resources.maxFragmentUniformVectors);
s.append(TString(builtInConstant));
s.append(builtInConstant);
snprintf(builtInConstant, maxSize, "const mediump int gl_MaxDrawBuffers = %d;", resources.maxDrawBuffers);
s.append(TString(builtInConstant));
s.append(builtInConstant);
if (version == 100) {
snprintf(builtInConstant, maxSize, "const mediump int gl_MaxVaryingVectors = %d;", resources.maxVaryingVectors);
s.append(TString(builtInConstant));
s.append(builtInConstant);
} else {
snprintf(builtInConstant, maxSize, "const mediump int gl_MaxVertexOutputVectors = %d;", resources.maxVertexOutputVectors);
s.append(TString(builtInConstant));
s.append(builtInConstant);
snprintf(builtInConstant, maxSize, "const mediump int gl_MaxFragmentInputVectors = %d;", resources.maxFragmentInputVectors);
s.append(TString(builtInConstant));
s.append(builtInConstant);
snprintf(builtInConstant, maxSize, "const mediump int gl_MinProgramTexelOffset = %d;", resources.minProgramTexelOffset);
s.append(TString(builtInConstant));
s.append(builtInConstant);
snprintf(builtInConstant, maxSize, "const mediump int gl_MaxProgramTexelOffset = %d;", resources.maxProgramTexelOffset);
s.append(TString(builtInConstant));
s.append(builtInConstant);
}
} else {
snprintf(builtInConstant, maxSize, "const int gl_MaxVertexAttribs = %d;", resources.maxVertexAttribs);
s.append(TString(builtInConstant));
s.append(builtInConstant);
snprintf(builtInConstant, maxSize, "const int gl_MaxVertexTextureImageUnits = %d;", resources.maxVertexTextureImageUnits);
s.append(TString(builtInConstant));
s.append(builtInConstant);
snprintf(builtInConstant, maxSize, "const int gl_MaxCombinedTextureImageUnits = %d;", resources.maxCombinedTextureImageUnits);
s.append(TString(builtInConstant));
s.append(builtInConstant);
snprintf(builtInConstant, maxSize, "const int gl_MaxTextureImageUnits = %d;", resources.maxTextureImageUnits);
s.append(TString(builtInConstant));
s.append(builtInConstant);
snprintf(builtInConstant, maxSize, "const int gl_MaxDrawBuffers = %d;", resources.maxDrawBuffers);
s.append(TString(builtInConstant));
s.append(builtInConstant);
snprintf(builtInConstant, maxSize, "const int gl_MaxLights = %d;", resources.maxLights);
s.append(TString(builtInConstant));
s.append(builtInConstant);
snprintf(builtInConstant, maxSize, "const int gl_MaxClipPlanes = %d;", resources.maxClipPlanes);
s.append(TString(builtInConstant));
s.append(builtInConstant);
snprintf(builtInConstant, maxSize, "const int gl_MaxTextureUnits = %d;", resources.maxTextureUnits);
s.append(TString(builtInConstant));
s.append(builtInConstant);
snprintf(builtInConstant, maxSize, "const int gl_MaxTextureCoords = %d;", resources.maxTextureCoords);
s.append(TString(builtInConstant));
s.append(builtInConstant);
snprintf(builtInConstant, maxSize, "const int gl_MaxVertexUniformComponents = %d;", resources.maxVertexUniformComponents);
s.append(TString(builtInConstant));
s.append(builtInConstant);
snprintf(builtInConstant, maxSize, "const int gl_MaxVaryingFloats = %d;", resources.maxVaryingFloats);
s.append(TString(builtInConstant));
s.append(builtInConstant);
snprintf(builtInConstant, maxSize, "const int gl_MaxFragmentUniformComponents = %d;", resources.maxFragmentUniformComponents);
s.append(TString(builtInConstant));
s.append(builtInConstant);
if (version < FirstProfileVersion || profile == ECompatibilityProfile) {
//
......@@ -1397,50 +1398,50 @@ void TBuiltIns::initialize(const TBuiltInResource &resources, int version, EProf
//
// Matrix state. p. 31, 32, 37, 39, 40.
//
s.append(TString("uniform mat4 gl_TextureMatrix[gl_MaxTextureCoords];"));
s.append("uniform mat4 gl_TextureMatrix[gl_MaxTextureCoords];");
//
// Derived matrix state that provides inverse and transposed versions
// of the matrices above.
//
s.append(TString("uniform mat4 gl_TextureMatrixInverse[gl_MaxTextureCoords];"));
s.append("uniform mat4 gl_TextureMatrixInverse[gl_MaxTextureCoords];");
s.append(TString("uniform mat4 gl_TextureMatrixTranspose[gl_MaxTextureCoords];"));
s.append("uniform mat4 gl_TextureMatrixTranspose[gl_MaxTextureCoords];");
s.append(TString("uniform mat4 gl_TextureMatrixInverseTranspose[gl_MaxTextureCoords];"));
s.append("uniform mat4 gl_TextureMatrixInverseTranspose[gl_MaxTextureCoords];");
//
// Clip planes p. 42.
//
s.append(TString("uniform vec4 gl_ClipPlane[gl_MaxClipPlanes];"));
s.append("uniform vec4 gl_ClipPlane[gl_MaxClipPlanes];");
//
// Light State p 50, 53, 55.
//
s.append(TString("uniform gl_LightSourceParameters gl_LightSource[gl_MaxLights];"));
s.append("uniform gl_LightSourceParameters gl_LightSource[gl_MaxLights];");
//
// Derived state from products of light.
//
s.append(TString("uniform gl_LightProducts gl_FrontLightProduct[gl_MaxLights];"));
s.append(TString("uniform gl_LightProducts gl_BackLightProduct[gl_MaxLights];"));
s.append("uniform gl_LightProducts gl_FrontLightProduct[gl_MaxLights];");
s.append("uniform gl_LightProducts gl_BackLightProduct[gl_MaxLights];");
//
// Textureg Environment and Generation, p. 152, p. 40-42.
//
s.append(TString("uniform vec4 gl_TextureEnvColor[gl_MaxTextureImageUnits];"));
s.append(TString("uniform vec4 gl_EyePlaneS[gl_MaxTextureCoords];"));
s.append(TString("uniform vec4 gl_EyePlaneT[gl_MaxTextureCoords];"));
s.append(TString("uniform vec4 gl_EyePlaneR[gl_MaxTextureCoords];"));
s.append(TString("uniform vec4 gl_EyePlaneQ[gl_MaxTextureCoords];"));
s.append(TString("uniform vec4 gl_ObjectPlaneS[gl_MaxTextureCoords];"));
s.append(TString("uniform vec4 gl_ObjectPlaneT[gl_MaxTextureCoords];"));
s.append(TString("uniform vec4 gl_ObjectPlaneR[gl_MaxTextureCoords];"));
s.append(TString("uniform vec4 gl_ObjectPlaneQ[gl_MaxTextureCoords];"));
s.append("uniform vec4 gl_TextureEnvColor[gl_MaxTextureImageUnits];");
s.append("uniform vec4 gl_EyePlaneS[gl_MaxTextureCoords];");
s.append("uniform vec4 gl_EyePlaneT[gl_MaxTextureCoords];");
s.append("uniform vec4 gl_EyePlaneR[gl_MaxTextureCoords];");
s.append("uniform vec4 gl_EyePlaneQ[gl_MaxTextureCoords];");
s.append("uniform vec4 gl_ObjectPlaneS[gl_MaxTextureCoords];");
s.append("uniform vec4 gl_ObjectPlaneT[gl_MaxTextureCoords];");
s.append("uniform vec4 gl_ObjectPlaneR[gl_MaxTextureCoords];");
s.append("uniform vec4 gl_ObjectPlaneQ[gl_MaxTextureCoords];");
}
}
s.append(TString("\n"));
s.append("\n");
}
}
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment