diff options
24 files changed, 746 insertions, 15 deletions
diff --git a/o3d/compiler/glsl_validator/build.xml b/o3d/compiler/glsl_validator/build.xml index be53186..ee52a8c 100644 --- a/o3d/compiler/glsl_validator/build.xml +++ b/o3d/compiler/glsl_validator/build.xml @@ -10,13 +10,13 @@ <property name="build" value="build" /> <property name="test" value="test" /> <path id="antlr.classpath"> - <pathelement location="../../third_party/antlr3/lib/antlr-3.1.1.jar" /> + <pathelement location="../../../third_party/antlr3/lib/antlr-3.1.1.jar" /> </path> <path id="antlr.runtime.classpath"> - <pathelement location="../../third_party/antlr3/lib/antlr-runtime-3.1.1.jar" /> + <pathelement location="../../../third_party/antlr3/lib/antlr-runtime-3.1.1.jar" /> </path> <path id="test.classpath"> - <pathelement location="../../third_party/antlr3/lib/antlr-runtime-3.1.1.jar" /> + <pathelement location="../../../third_party/antlr3/lib/antlr-runtime-3.1.1.jar" /> <pathelement location="${build}" /> </path> </target> @@ -25,7 +25,7 @@ <mkdir dir="${build}" /> <mkdir dir="${build}/glsl_es" /> <!-- Run ANTLR on the grammar --> - <java classname="org.antlr.Tool"> + <java classname="org.antlr.Tool" failonerror="true"> <classpath refid="antlr.classpath" /> <arg value="glsl_es/GLSL_ES.g" /> <arg value="-fo" /> @@ -45,8 +45,28 @@ <arg value="shaders/ambient.frag" /> <arg value="shaders/diffuse.vert" /> <arg value="shaders/diffuse.frag" /> + <arg value="shaders/many-planets-deep.vert" /> + <arg value="shaders/many-planets-deep.frag" /> + <arg value="shaders/nvidia-vertex-buffer-object.vert" /> + <arg value="shaders/nvidia-vertex-buffer-object.frag" /> <arg value="shaders/texture_mapping.vert" /> <arg value="shaders/texture_mapping.frag" /> + <arg value="shaders/particles-2d.vert" /> + <arg value="shaders/particles-3d.vert" /> + <arg value="shaders/particles.frag" /> + <arg value="shaders/san-angeles-flat.vert" /> + <arg value="shaders/san-angeles-lit.vert" /> + <arg value="shaders/san-angeles-flat.frag" /> + <arg value="shaders/shiny-teapot.vert" /> + <arg value="shaders/shiny-teapot.frag" /> + <arg value="shaders/spirit-box.vert" /> + <arg value="shaders/spirit-box.frag" /> + <arg value="shaders/spore-view.vert" /> + <arg value="shaders/spore-view.frag" /> + <arg value="shaders/teapot-per-pixel.vert" /> + <arg value="shaders/teapot-per-pixel.frag" /> + <arg value="shaders/teapot-per-vertex.vert" /> + <arg value="shaders/teapot-per-vertex.frag" /> </java> </target> diff --git a/o3d/compiler/glsl_validator/glsl_es/GLSL_ES.g b/o3d/compiler/glsl_validator/glsl_es/GLSL_ES.g index 688fbf8..e2cf26e 100644 --- a/o3d/compiler/glsl_validator/glsl_es/GLSL_ES.g +++ b/o3d/compiler/glsl_validator/glsl_es/GLSL_ES.g @@ -36,7 +36,7 @@ grammar GLSL_ES; options { language = Java; - } +} @lexer::header { package glsl_es; } @parser::header { package glsl_es; } @@ -97,17 +97,19 @@ function_call_header : function_identifier LEFT_PAREN ; +// NOTE: change compared to GLSL ES grammar, because constructor_identifier +// has IDENTIFIER (=TYPE_NAME) as one of its arms. function_identifier : constructor_identifier - | IDENTIFIER +// | IDENTIFIER ; // Grammar Note: Constructors look like functions, but lexical analysis recognized most of them as // keywords. // -// FIXME: do we need to register declared struct types in a dictionary -// and look them up in order to be able to handle the TYPE_NAME -// constructor identifier type? +// TODO(kbr): do we need to register declared struct types in a dictionary +// and look them up in order to be able to handle the TYPE_NAME constructor +// identifier type? constructor_identifier : FLOAT @@ -126,6 +128,7 @@ constructor_identifier | MAT3 | MAT4 // | TYPE_NAME + | IDENTIFIER ; unary_expression @@ -243,7 +246,7 @@ function_header ; parameter_declaration - : (type_qualifier (parameter_qualifier)? )? + : (type_qualifier)? (parameter_qualifier)? ( type_specifier // parameter_declarator (IDENTIFIER)? @@ -324,6 +327,7 @@ type_specifier_no_prec | SAMPLERCUBE | struct_specifier // | TYPE_NAME + | IDENTIFIER ; precision_qualifier @@ -366,6 +370,7 @@ statement_no_new_scope ; simple_statement +options { backtrack=true; } : declaration_statement | expression_statement | selection_statement @@ -412,6 +417,7 @@ iteration_statement ; for_init_statement +options { backtrack=true; } : expression_statement | declaration_statement ; @@ -487,7 +493,7 @@ IDENTIFIER ; /* -// FIXME: it isn't clear whether we need to support the TYPE_NAME +// TODO(kbr): it isn't clear whether we need to support the TYPE_NAME // token type; that may only be needed if typedef is supported TYPE_NAME : IDENTIFIER @@ -531,7 +537,7 @@ fragment BOOLCONSTANT | FALSE ; -// FIXME: this needs much more work +// TODO(kbr): this needs much more work field_selection : IDENTIFIER ; diff --git a/o3d/compiler/glsl_validator/glsl_es/GLSL_ES.y b/o3d/compiler/glsl_validator/glsl_es/GLSL_ES.y index 16b5352..10c9879 100644 --- a/o3d/compiler/glsl_validator/glsl_es/GLSL_ES.y +++ b/o3d/compiler/glsl_validator/glsl_es/GLSL_ES.y @@ -84,7 +84,7 @@ translation_unit : external_declaration | translation_unit external_declaration -/* FIXME: this requires much more work */ +/* TODO(kbr): this requires much more work */ FIELD_SELECTION : IDENTIFIER ; @@ -153,11 +153,17 @@ function_call_header : function_identifier LEFT_PAREN ; +// NOTE: change compared to GLSL ES grammar, because constructor_identifier +// has IDENTIFIER (=TYPE_NAME) as one of its arms. function_identifier : constructor_identifier | IDENTIFIER ; +// TODO(kbr): do we need to register declared struct types in a dictionary +// and look them up in order to be able to handle the TYPE_NAME constructor +// identifier type? + constructor_identifier : FLOAT | INT @@ -175,6 +181,7 @@ constructor_identifier | MAT3 | MAT4 // | TYPE_NAME +// | IDENTIFIER ; unary_expression @@ -291,7 +298,7 @@ conditional_expression | logical_or_expression conditional_expression_1 ; -/* NOTE (FIXME): difference between Mesa's grammar and GLSL ES spec; +/* NOTE (TODO(kbr)): difference between Mesa's grammar and GLSL ES spec; Mesa uses conditional_expression after the colon, GLSL ES uses assignment_expression */ conditional_expression_1 : QUESTION expression COLON assignment_expression @@ -457,6 +464,7 @@ type_specifier_no_prec | SAMPLERCUBE | struct_specifier // | TYPE_NAME +// | IDENTIFIER ; precision_qualifier @@ -535,7 +543,7 @@ compound_statement_no_new_scope | LEFT_BRACE statement_list RIGHT_BRACE ; -/* FIXME: may need refactoring */ +/* TODO(kbr): may need refactoring */ statement_list : statement_no_new_scope | statement_list statement_no_new_scope diff --git a/o3d/compiler/glsl_validator/shaders/many-planets-deep.frag b/o3d/compiler/glsl_validator/shaders/many-planets-deep.frag new file mode 100644 index 0000000..64bf5a4 --- /dev/null +++ b/o3d/compiler/glsl_validator/shaders/many-planets-deep.frag @@ -0,0 +1,11 @@ +uniform sampler2D sampler2d; + +varying float v_Dot; +varying vec2 v_texCoord; + +void main() +{ + vec4 color = texture2D(sampler2d,v_texCoord); + color += vec4(0.1,0.1,0.1,1); + gl_FragColor = vec4(color.xyz * v_Dot, color.a); +} diff --git a/o3d/compiler/glsl_validator/shaders/many-planets-deep.vert b/o3d/compiler/glsl_validator/shaders/many-planets-deep.vert new file mode 100644 index 0000000..051a226 --- /dev/null +++ b/o3d/compiler/glsl_validator/shaders/many-planets-deep.vert @@ -0,0 +1,19 @@ +uniform mat4 u_modelViewMatrix; +uniform mat4 u_modelViewProjMatrix; +uniform mat4 u_normalMatrix; +uniform vec3 lightDir; + +attribute vec3 vNormal; +attribute vec4 vTexCoord; +attribute vec4 vPosition; + +varying float v_Dot; +varying vec2 v_texCoord; + +void main() +{ + gl_Position = u_modelViewProjMatrix * vPosition; + v_texCoord = vTexCoord.st; + vec4 transNormal = u_normalMatrix * vec4(vNormal,1); + v_Dot = max(dot(transNormal.xyz, lightDir), 0.0); +} diff --git a/o3d/compiler/glsl_validator/shaders/nvidia-vertex-buffer-object.frag b/o3d/compiler/glsl_validator/shaders/nvidia-vertex-buffer-object.frag new file mode 100644 index 0000000..98e8b27 --- /dev/null +++ b/o3d/compiler/glsl_validator/shaders/nvidia-vertex-buffer-object.frag @@ -0,0 +1,5 @@ +varying vec4 v_color; + +void main() { + gl_FragColor = v_color; +} diff --git a/o3d/compiler/glsl_validator/shaders/nvidia-vertex-buffer-object.vert b/o3d/compiler/glsl_validator/shaders/nvidia-vertex-buffer-object.vert new file mode 100644 index 0000000..60fc084 --- /dev/null +++ b/o3d/compiler/glsl_validator/shaders/nvidia-vertex-buffer-object.vert @@ -0,0 +1,48 @@ +// Per-vertex phong shader +uniform mat4 worldViewProjection; +uniform vec3 lightWorldPos; +uniform vec4 lightColor; + +uniform mat4 world; +uniform mat4 viewInverse; +uniform mat4 worldInverseTranspose; + +uniform vec4 emissiveColor; +uniform vec4 ambientColor; +uniform vec4 diffuseColor; +uniform vec4 specularColor; +uniform float shininess; +uniform float specularFactor; + +attribute vec3 g_Position; +attribute vec3 g_Normal; + +varying vec4 v_color; + +vec4 lit(float n_dot_l, float n_dot_h, float m) { + return vec4(1., + clamp(n_dot_l, 0., 1.), + // FIXME: approximation to + // (n_dot_l < 0) || (n_dot_h < 0) + pow(clamp(n_dot_h, 0., 1.), m), + 1.); +} + +void main() { + vec4 position = vec4(g_Position, 1.); + vec4 worldPosition = world * position; + vec3 normal = normalize((worldInverseTranspose * + vec4(g_Normal, 0.)).xyz); + vec3 surfaceToLight = normalize(lightWorldPos - worldPosition.xyz); + vec3 surfaceToView = normalize((viewInverse[3] - worldPosition).xyz); + vec3 halfVector = normalize(surfaceToLight + surfaceToView); + vec4 litR = lit(dot(normal, surfaceToLight), + dot(normal, halfVector), shininess); + v_color = + vec4((emissiveColor + + lightColor * (ambientColor * litR.x + + diffuseColor * litR.y + + specularColor * litR.z * specularFactor)).rgb, + diffuseColor.a); + gl_Position = worldViewProjection * position; +} diff --git a/o3d/compiler/glsl_validator/shaders/particles-2d.vert b/o3d/compiler/glsl_validator/shaders/particles-2d.vert new file mode 100644 index 0000000..5197941 --- /dev/null +++ b/o3d/compiler/glsl_validator/shaders/particles-2d.vert @@ -0,0 +1,69 @@ +uniform mat4 viewProjection; +uniform mat4 world; +uniform mat4 viewInverse; +uniform vec3 worldVelocity; +uniform vec3 worldAcceleration; +uniform float timeRange; +uniform float time; +uniform float timeOffset; +uniform float frameDuration; +uniform float numFrames; + +// Incoming vertex attributes +attribute vec4 uvLifeTimeFrameStart; // uv, lifeTime, frameStart +attribute vec4 positionStartTime; // position.xyz, startTime +attribute vec4 velocityStartSize; // velocity.xyz, startSize +attribute vec4 accelerationEndSize; // acceleration.xyz, endSize +attribute vec4 spinStartSpinSpeed; // spinStart.x, spinSpeed.y +attribute vec4 colorMult; // multiplies color and ramp textures + +// Outgoing variables to fragment shader +varying vec2 outputTexcoord; +varying float outputPercentLife; +varying vec4 outputColorMult; + +void main() { + vec2 uv = uvLifeTimeFrameStart.xy; + float lifeTime = uvLifeTimeFrameStart.z; + float frameStart = uvLifeTimeFrameStart.w; + vec3 position = positionStartTime.xyz; + float startTime = positionStartTime.w; + vec3 velocity = (world * vec4(velocityStartSize.xyz, + 0.)).xyz + worldVelocity; + float startSize = velocityStartSize.w; + vec3 acceleration = (world * vec4(accelerationEndSize.xyz, + 0)).xyz + worldAcceleration; + float endSize = accelerationEndSize.w; + float spinStart = spinStartSpinSpeed.x; + float spinSpeed = spinStartSpinSpeed.y; + + float localTime = mod((time - timeOffset - startTime), timeRange); + float percentLife = localTime / lifeTime; + + float frame = mod(floor(localTime / frameDuration + frameStart), + numFrames); + float uOffset = frame / numFrames; + float u = uOffset + (uv.x + 0.5) * (1. / numFrames); + + outputTexcoord = vec2(u, uv.y + 0.5); + outputColorMult = colorMult; + + vec3 basisX = viewInverse[0].xyz; + vec3 basisZ = viewInverse[1].xyz; + + float size = mix(startSize, endSize, percentLife); + size = (percentLife < 0. || percentLife > 1.) ? 0. : size; + float s = sin(spinStart + spinSpeed * localTime); + float c = cos(spinStart + spinSpeed * localTime); + + vec2 rotatedPoint = vec2(uv.x * c + uv.y * s, + -uv.x * s + uv.y * c); + vec3 localPosition = vec3(basisX * rotatedPoint.x + + basisZ * rotatedPoint.y) * size + + velocity * localTime + + acceleration * localTime * localTime + + position; + + outputPercentLife = percentLife; + gl_Position = viewProjection * vec4(localPosition + world[3].xyz, 1.); +} diff --git a/o3d/compiler/glsl_validator/shaders/particles-3d.vert b/o3d/compiler/glsl_validator/shaders/particles-3d.vert new file mode 100644 index 0000000..7f09de7 --- /dev/null +++ b/o3d/compiler/glsl_validator/shaders/particles-3d.vert @@ -0,0 +1,87 @@ +uniform mat4 worldViewProjection; +uniform mat4 world; +uniform vec3 worldVelocity; +uniform vec3 worldAcceleration; +uniform float timeRange; +uniform float time; +uniform float timeOffset; +uniform float frameDuration; +uniform float numFrames; + +// Incoming vertex attributes +attribute vec4 uvLifeTimeFrameStart; // uv, lifeTime, frameStart +attribute vec4 positionStartTime; // position.xyz, startTime +attribute vec4 velocityStartSize; // velocity.xyz, startSize +attribute vec4 accelerationEndSize; // acceleration.xyz, endSize +attribute vec4 spinStartSpinSpeed; // spinStart.x, spinSpeed.y +attribute vec4 orientation; // orientation quaternion +attribute vec4 colorMult; // multiplies color and ramp textures + +// Outgoing variables to fragment shader +varying vec2 outputTexcoord; +varying float outputPercentLife; +varying vec4 outputColorMult; + +void main() { + vec2 uv = uvLifeTimeFrameStart.xy; + float lifeTime = uvLifeTimeFrameStart.z; + float frameStart = uvLifeTimeFrameStart.w; + vec3 position = positionStartTime.xyz; + float startTime = positionStartTime.w; + vec3 velocity = (world * vec4(velocityStartSize.xyz, + 0.)).xyz + worldVelocity; + float startSize = velocityStartSize.w; + vec3 acceleration = (world * vec4(accelerationEndSize.xyz, + 0)).xyz + worldAcceleration; + float endSize = accelerationEndSize.w; + float spinStart = spinStartSpinSpeed.x; + float spinSpeed = spinStartSpinSpeed.y; + + float localTime = mod((time - timeOffset - startTime), timeRange); + float percentLife = localTime / lifeTime; + + float frame = mod(floor(localTime / frameDuration + frameStart), + numFrames); + float uOffset = frame / numFrames; + float u = uOffset + (uv.x + 0.5) * (1. / numFrames); + + outputTexcoord = vec2(u, uv.y + 0.5); + outputColorMult = colorMult; + + float size = mix(startSize, endSize, percentLife); + size = (percentLife < 0. || percentLife > 1.) ? 0. : size; + float s = sin(spinStart + spinSpeed * localTime); + float c = cos(spinStart + spinSpeed * localTime); + + vec4 rotatedPoint = vec4((uv.x * c + uv.y * s) * size, 0., + (uv.x * s - uv.y * c) * size, 1.); + vec3 center = velocity * localTime + + acceleration * localTime * localTime + + position; + + vec4 q2 = orientation + orientation; + vec4 qx = orientation.xxxw * q2.xyzx; + vec4 qy = orientation.xyyw * q2.xyzy; + vec4 qz = orientation.xxzw * q2.xxzz; + + mat4 localMatrix = mat4( + (1.0 - qy.y) - qz.z, + qx.y + qz.w, + qx.z - qy.w, + 0, + + qx.y - qz.w, + (1.0 - qx.x) - qz.z, + qy.z + qx.w, + 0, + + qx.z + qy.w, + qy.z - qx.w, + (1.0 - qx.x) - qy.y, + 0, + + center.x, center.y, center.z, 1); + rotatedPoint = localMatrix * rotatedPoint; + outputPercentLife = percentLife; + gl_Position = worldViewProjection * rotatedPoint; +} diff --git a/o3d/compiler/glsl_validator/shaders/particles.frag b/o3d/compiler/glsl_validator/shaders/particles.frag new file mode 100644 index 0000000..25fb378 --- /dev/null +++ b/o3d/compiler/glsl_validator/shaders/particles.frag @@ -0,0 +1,17 @@ +uniform sampler2D rampSampler; +uniform sampler2D colorSampler; + +// Incoming variables from vertex shader +varying vec2 outputTexcoord; +varying float outputPercentLife; +varying vec4 outputColorMult; + +void main() { + vec4 colorMult = texture2D(rampSampler, + vec2(outputPercentLife, 0.5)) * + outputColorMult; + gl_FragColor = texture2D(colorSampler, outputTexcoord) * colorMult; + // For debugging: requires setup of some uniforms and vertex + // attributes to be commented out to avoid GL errors + // gl_FragColor = vec4(1., 0., 0., 1.); +} diff --git a/o3d/compiler/glsl_validator/shaders/san-angeles-fade.vert b/o3d/compiler/glsl_validator/shaders/san-angeles-fade.vert new file mode 100644 index 0000000..d2676ee42 --- /dev/null +++ b/o3d/compiler/glsl_validator/shaders/san-angeles-fade.vert @@ -0,0 +1,10 @@ +attribute vec2 pos; + +varying vec4 color; + +uniform float minFade; + +void main() { + color = vec4(minFade, minFade, minFade, 1.); + gl_Position = vec4(pos, 0., 1.); +} diff --git a/o3d/compiler/glsl_validator/shaders/san-angeles-flat.frag b/o3d/compiler/glsl_validator/shaders/san-angeles-flat.frag new file mode 100644 index 0000000..3f2bed8 --- /dev/null +++ b/o3d/compiler/glsl_validator/shaders/san-angeles-flat.frag @@ -0,0 +1,4 @@ +varying vec4 color; +void main() { + gl_FragColor = vec4(color.rgb, 1.0); +} diff --git a/o3d/compiler/glsl_validator/shaders/san-angeles-flat.vert b/o3d/compiler/glsl_validator/shaders/san-angeles-flat.vert new file mode 100644 index 0000000..4583d20 --- /dev/null +++ b/o3d/compiler/glsl_validator/shaders/san-angeles-flat.vert @@ -0,0 +1,8 @@ +attribute vec3 pos; +attribute vec4 colorIn; +uniform mat4 mvp; +varying vec4 color; +void main() { + color = colorIn; + gl_Position = mvp * vec4(pos.xyz, 1.); +} diff --git a/o3d/compiler/glsl_validator/shaders/san-angeles-lit.vert b/o3d/compiler/glsl_validator/shaders/san-angeles-lit.vert new file mode 100644 index 0000000..022ec5ac --- /dev/null +++ b/o3d/compiler/glsl_validator/shaders/san-angeles-lit.vert @@ -0,0 +1,50 @@ +attribute vec3 pos; +attribute vec3 normal; +attribute vec4 colorIn; + +varying vec4 color; + +uniform mat4 mvp; +uniform mat3 normalMatrix; +uniform vec4 ambient; +uniform float shininess; +uniform vec3 light_0_direction; +uniform vec4 light_0_diffuse; +uniform vec4 light_0_specular; +uniform vec3 light_1_direction; +uniform vec4 light_1_diffuse; +uniform vec3 light_2_direction; +uniform vec4 light_2_diffuse; + +vec3 worldNormal; + +vec4 SpecularLight(vec3 direction, + vec4 diffuseColor, + vec4 specularColor) { + vec3 lightDir = normalize(direction); + float diffuse = max(0., dot(worldNormal, lightDir)); + float specular = 0.; + if (diffuse > 0.) { + vec3 halfv = normalize(lightDir + vec3(0., 0., 1.)); + specular = pow(max(0., dot(halfv, worldNormal)), shininess); + } + return diffuse * diffuseColor * colorIn + specular * specularColor; +} + +vec4 DiffuseLight(vec3 direction, vec4 diffuseColor) { + vec3 lightDir = normalize(direction); + float diffuse = max(0., dot(worldNormal, lightDir)); + return diffuse * diffuseColor * colorIn; +} + +void main() { + worldNormal = normalize(normalMatrix * normal); + + gl_Position = mvp * vec4(pos, 1.); + + color = ambient * colorIn; + color += SpecularLight(light_0_direction, light_0_diffuse, + light_0_specular); + color += DiffuseLight(light_1_direction, light_1_diffuse); + color += DiffuseLight(light_2_direction, light_2_diffuse); +} diff --git a/o3d/compiler/glsl_validator/shaders/shiny-teapot.frag b/o3d/compiler/glsl_validator/shaders/shiny-teapot.frag new file mode 100644 index 0000000..7c0667e --- /dev/null +++ b/o3d/compiler/glsl_validator/shaders/shiny-teapot.frag @@ -0,0 +1,23 @@ +const float bumpHeight = 0.2; + +uniform sampler2D normalSampler; +uniform samplerCube envSampler; + +varying vec2 texCoord; +varying vec3 worldEyeVec; +varying vec3 worldNormal; +varying vec3 worldTangent; +varying vec3 worldBinorm; + +void main() { + vec2 bump = (texture2D(normalSampler, texCoord.xy).xy * 2.0 - 1.0) * bumpHeight; + vec3 normal = normalize(worldNormal); + vec3 tangent = normalize(worldTangent); + vec3 binormal = normalize(worldBinorm); + vec3 nb = normal + bump.x * tangent + bump.y * binormal; + nb = normalize(nb); + vec3 worldEye = normalize(worldEyeVec); + vec3 lookup = reflect(worldEye, nb); + vec4 color = textureCube(envSampler, lookup); + gl_FragColor = color; +} diff --git a/o3d/compiler/glsl_validator/shaders/shiny-teapot.vert b/o3d/compiler/glsl_validator/shaders/shiny-teapot.vert new file mode 100644 index 0000000..e0eef69 --- /dev/null +++ b/o3d/compiler/glsl_validator/shaders/shiny-teapot.vert @@ -0,0 +1,26 @@ +attribute vec3 g_Position; +attribute vec3 g_TexCoord0; +attribute vec3 g_Tangent; +attribute vec3 g_Binormal; +attribute vec3 g_Normal; + +uniform mat4 world; +uniform mat4 worldInverseTranspose; +uniform mat4 worldViewProj; +uniform mat4 viewInverse; + +varying vec2 texCoord; +varying vec3 worldEyeVec; +varying vec3 worldNormal; +varying vec3 worldTangent; +varying vec3 worldBinorm; + +void main() { + gl_Position = worldViewProj * vec4(g_Position.xyz, 1.); + texCoord.xy = g_TexCoord0.xy; + worldNormal = (worldInverseTranspose * vec4(g_Normal, 1.)).xyz; + worldTangent = (worldInverseTranspose * vec4(g_Tangent, 1.)).xyz; + worldBinorm = (worldInverseTranspose * vec4(g_Binormal, 1.)).xyz; + vec3 worldPos = (world * vec4(g_Position, 1.)).xyz; + worldEyeVec = normalize(worldPos - viewInverse[3].xyz); +} diff --git a/o3d/compiler/glsl_validator/shaders/spirit-box.frag b/o3d/compiler/glsl_validator/shaders/spirit-box.frag new file mode 100644 index 0000000..3013143 --- /dev/null +++ b/o3d/compiler/glsl_validator/shaders/spirit-box.frag @@ -0,0 +1,12 @@ +uniform sampler2D sampler2d; + +varying float v_Dot; +varying vec2 v_texCoord; + +void main() +{ + vec2 texCoord = vec2(v_texCoord.s, 1.0 - v_texCoord.t); + vec4 color = texture2D(sampler2d, texCoord); + color += vec4(0.1, 0.1, 0.1, 1); + gl_FragColor = vec4(color.xyz * v_Dot, color.a); +} diff --git a/o3d/compiler/glsl_validator/shaders/spirit-box.vert b/o3d/compiler/glsl_validator/shaders/spirit-box.vert new file mode 100644 index 0000000..72f86d7 --- /dev/null +++ b/o3d/compiler/glsl_validator/shaders/spirit-box.vert @@ -0,0 +1,18 @@ +uniform mat4 u_modelViewProjMatrix; +uniform mat4 u_normalMatrix; +uniform vec3 lightDir; + +attribute vec3 vNormal; +attribute vec4 vTexCoord; +attribute vec4 vPosition; + +varying float v_Dot; +varying vec2 v_texCoord; + +void main() +{ + gl_Position = u_modelViewProjMatrix * vPosition; + v_texCoord = vTexCoord.st; + vec4 transNormal = u_normalMatrix * vec4(vNormal, 1); + v_Dot = max(dot(transNormal.xyz, lightDir), 0.0); +} diff --git a/o3d/compiler/glsl_validator/shaders/spore-view.frag b/o3d/compiler/glsl_validator/shaders/spore-view.frag new file mode 100644 index 0000000..72717bb --- /dev/null +++ b/o3d/compiler/glsl_validator/shaders/spore-view.frag @@ -0,0 +1,12 @@ +varying vec3 vNormal; +varying vec3 vViewVec; +varying vec2 vTexCoord0; + +uniform vec4 uColor; +uniform sampler2D uTexture0; + +void main(void) { + float v = 0.5 * (1.0 + dot(normalize(vViewVec), vNormal)); + + gl_FragColor = texture2D(uTexture0, vTexCoord0.st); +} diff --git a/o3d/compiler/glsl_validator/shaders/spore-view.vert b/o3d/compiler/glsl_validator/shaders/spore-view.vert new file mode 100644 index 0000000..8ed64c3 --- /dev/null +++ b/o3d/compiler/glsl_validator/shaders/spore-view.vert @@ -0,0 +1,19 @@ +attribute vec3 aVertex; +attribute vec3 aNormal; +attribute vec2 aTexCoord0; + +uniform mat4 uPMatrix; +uniform mat4 uMVMatrix; +uniform vec4 uViewPosition; + +varying vec3 vNormal; +varying vec3 vViewVec; +varying vec2 vTexCoord0; + +void main(void) { + gl_Position = uPMatrix * uMVMatrix * vec4(aVertex, 1.0); + + vNormal = aNormal; + vViewVec = uViewPosition.xyz - aVertex.xyz; + vTexCoord0 = aTexCoord0; +} diff --git a/o3d/compiler/glsl_validator/shaders/teapot-per-pixel.frag b/o3d/compiler/glsl_validator/shaders/teapot-per-pixel.frag new file mode 100644 index 0000000..9e485f0 --- /dev/null +++ b/o3d/compiler/glsl_validator/shaders/teapot-per-pixel.frag @@ -0,0 +1,46 @@ +struct Light +{ + vec4 ambient; + vec4 diffuse; + vec4 specular; + vec4 position; + + vec3 halfVector; +}; + +struct Material +{ + vec4 emission; + vec4 ambient; + vec4 diffuse; + vec4 specular; + float shininess; +}; + +uniform sampler2D u_sampler2d; +uniform Light u_light; +uniform Material u_frontMaterial; +uniform Material u_backMaterial; + +varying vec4 v_diffuse, v_ambient; +varying vec3 v_normal, v_lightDir; +varying vec2 v_texCoord; + +void main() +{ + vec4 color = v_diffuse; + + vec3 n = normalize(v_normal); + + Light light = u_light; + vec3 lightDir = v_lightDir; + float nDotL = max(dot(n, lightDir), 0.0); + if (nDotL > 0.0) { + color = vec4(color.rgb * nDotL, color.a); + float nDotHV = max(dot(n, light.halfVector), 0.0); + vec4 specular = u_frontMaterial.specular * light.specular; + color += vec4(specular.rgb * pow(nDotHV, u_frontMaterial.shininess), specular.a); + } + + gl_FragColor = color + v_ambient; +} diff --git a/o3d/compiler/glsl_validator/shaders/teapot-per-pixel.vert b/o3d/compiler/glsl_validator/shaders/teapot-per-pixel.vert new file mode 100644 index 0000000..b03e747 --- /dev/null +++ b/o3d/compiler/glsl_validator/shaders/teapot-per-pixel.vert @@ -0,0 +1,96 @@ +/* + Copyright (c) 2008 Seneca College + Licenced under the MIT License (http://www.c3dl.org/index.php/mit-license/) +*/ + +// We need to create our own light structure since we can't access +// the light() function in the 2.0 context. +struct Light +{ + vec4 ambient; + vec4 diffuse; + vec4 specular; + vec4 position; + + vec3 halfVector; +}; + +struct Material +{ + vec4 emission; + vec4 ambient; + vec4 diffuse; + vec4 specular; + float shininess; +}; +// +// vertex attributes +// +attribute vec4 a_vertex; +attribute vec3 a_normal; +attribute vec4 a_texCoord; + +// for every model we multiply the projection, view and model matrices +// once to prevent having to do it for every vertex, however we still need +// the view matrix to calculate lighting. +uniform mat4 u_modelViewMatrix; + +// we can calculate this once per model to speed up processing done on the js side. +uniform mat4 u_modelViewProjMatrix; + +// matrix to transform the vertex normals +uniform mat4 u_normalMatrix; + +// custom light structures need to be used since we don't have access to +// light states. +uniform Light u_light; + +// material +uniform vec4 u_globalAmbientColor; +uniform Material u_frontMaterial; +uniform Material u_backMaterial; + +// passed to fragment shader +varying vec4 v_diffuse, v_ambient; +varying vec3 v_normal, v_lightDir; +varying vec2 v_texCoord; + +/* + Given a reference to the ambient and diffuse lighting variables, + this function will calculate how much each component contributes to the scene. + + Light light - the light in view space + vec3 normal - + vec4 ambient - + vec4 diffuse - +*/ +vec3 directionalLight(inout vec4 ambient, inout vec4 diffuse) +{ + ambient += u_light.ambient; + diffuse += u_light.diffuse; + return normalize(vec3(u_light.position)); +} + +void main() +{ + v_normal = normalize(u_normalMatrix * vec4(a_normal, 1)).xyz; + + vec4 ambient = vec4(0.0, 0.0, 0.0, 1.0); + vec4 diffuse = vec4(0.0, 0.0, 0.0, 1.0); + vec4 specular = vec4(0.0, 0.0, 0.0, 1.0); + + // place the current vertex into view space + // ecPos = eye coordinate position. + vec4 ecPos4 = u_modelViewMatrix * a_vertex; + + // the current vertex in eye coordinate space + vec3 ecPos = ecPos4.xyz/ecPos4.w; + v_lightDir = directionalLight(ambient, diffuse); + + v_ambient = u_frontMaterial.ambient * ambient; + v_ambient += u_globalAmbientColor * u_frontMaterial.ambient; + v_diffuse = u_frontMaterial.diffuse * diffuse; + + gl_Position = u_modelViewProjMatrix * a_vertex; + v_texCoord = a_texCoord.st; +} diff --git a/o3d/compiler/glsl_validator/shaders/teapot-per-vertex.frag b/o3d/compiler/glsl_validator/shaders/teapot-per-vertex.frag new file mode 100644 index 0000000..973eddb --- /dev/null +++ b/o3d/compiler/glsl_validator/shaders/teapot-per-vertex.frag @@ -0,0 +1,11 @@ +uniform sampler2D u_sampler2d; + +varying vec4 v_diffuse, v_specular; +varying vec2 v_texCoord; + +void main() +{ + vec4 color = v_diffuse; + + gl_FragColor = color + v_specular; +} diff --git a/o3d/compiler/glsl_validator/shaders/teapot-per-vertex.vert b/o3d/compiler/glsl_validator/shaders/teapot-per-vertex.vert new file mode 100644 index 0000000..cfc0d45 --- /dev/null +++ b/o3d/compiler/glsl_validator/shaders/teapot-per-vertex.vert @@ -0,0 +1,106 @@ +/* + Copyright (c) 2008 Seneca College + Licenced under the MIT License (http://www.c3dl.org/index.php/mit-license/) +*/ + +// We need to create our own light structure since we can't access +// the light() function in the 2.0 context. +struct Light +{ + vec4 ambient; + vec4 diffuse; + vec4 specular; + vec4 position; + + vec3 halfVector; +}; + +struct Material +{ + vec4 emission; + vec4 ambient; + vec4 diffuse; + vec4 specular; + float shininess; +}; + +// +// vertex attributes +// +attribute vec3 a_normal; +attribute vec4 a_texCoord; +attribute vec4 a_vertex; + +// for every model we multiply the projection, view and model matrices +// once to prevent having to do it for every vertex, however we still need +// the view matrix to calculate lighting. +uniform mat4 u_modelViewMatrix; + +// we can calculate this once per model to speed up processing done on the js side. +uniform mat4 u_modelViewProjMatrix; + +// matrix to transform the vertex normals +uniform mat4 u_normalMatrix; + +// custom light structures need to be used since we don't have access to +// light states. +uniform Light u_light; + +// material +uniform vec4 u_globalAmbientColor; +uniform Material u_frontMaterial; +uniform Material u_backMaterial; + +// passed to fragment shader +varying vec4 v_diffuse, v_specular; +varying vec2 v_texCoord; + +/* + Given a reference to the ambient and diffuse lighting variables, + this function will calculate how much each component contributes to the scene. + + Light light - the light in view space + vec3 normal - + vec4 ambient - + vec4 diffuse - +*/ +void directionalLight(in vec3 normal, inout vec4 ambient, inout vec4 diffuse, inout vec4 specular) +{ + vec3 lightDir = normalize(vec3(u_light.position)); + ambient += u_light.ambient; + + float nDotL = max(dot(normal, lightDir), 0.0); + if (nDotL > 0.0) { + diffuse += u_light.diffuse * nDotL; + float nDotHV = max(dot(normal, u_light.halfVector), 0.0); + nDotHV += 0.3; + vec4 specularColor = u_frontMaterial.specular * u_light.specular; + specular += vec4(specularColor.rgb * pow(nDotHV, u_frontMaterial.shininess), specularColor.a); + } +} + +void main() +{ + vec3 normal = normalize(u_normalMatrix * vec4(a_normal, 1)).xyz; + + vec4 ambient = vec4(0.0, 0.0, 0.0, 1.0); + vec4 diffuse = vec4(0.0, 0.0, 0.0, 1.0); + vec4 specular = vec4(0.0, 0.0, 0.0, 1.0); + + // place the current vertex into view space + // ecPos = eye coordinate position. + vec4 ecPos4 = u_modelViewMatrix * a_vertex; + + // the current vertex in eye coordinate space + vec3 ecPos = ecPos4.xyz/ecPos4.w; + directionalLight(normal, ambient, diffuse, specular); + + ambient = u_frontMaterial.ambient * ambient; + ambient += u_globalAmbientColor * u_frontMaterial.ambient; + diffuse = u_frontMaterial.diffuse * diffuse; + + v_diffuse = diffuse; + v_specular = specular + ambient; + gl_Position = u_modelViewProjMatrix * a_vertex; + v_texCoord = a_texCoord.st; +} |