x_ite 4.2.17 → 4.7.7

package/src/assets/shaders/Types.glsl

@@ -0,0 +1,102 @@
+
+struct x3d_FogParameters {
+	mediump int   type;
+	mediump vec3  color;
+	mediump float visibilityRange;
+	mediump mat3  matrix;
+	bool          fogCoord;
+};
+
+//uniform x3d_FogParameters x3d_Fog;
+
+struct x3d_LightSourceParameters {
+	mediump int   type;
+	mediump vec3  color;
+	mediump float intensity;
+	mediump float ambientIntensity;
+	mediump vec3  attenuation;
+	mediump vec3  location;
+	mediump vec3  direction;
+	mediump float radius;
+	mediump float beamWidth;
+	mediump float cutOffAngle;
+	mediump mat3  matrix;
+	#ifdef X3D_SHADOWS
+	mediump vec3  shadowColor;
+	mediump float shadowIntensity;
+	mediump float shadowBias;
+	mediump mat4  shadowMatrix;
+	mediump int   shadowMapSize;
+	#endif
+};
+
+//uniform x3d_LightSourceParameters x3d_LightSource [x3d_MaxLights];
+
+struct x3d_PointPropertiesParameters
+{
+	mediump float pointSizeScaleFactor;
+	mediump float pointSizeMinValue;
+	mediump float pointSizeMaxValue;
+	mediump vec3  pointSizeAttenuation;
+	mediump int   colorMode;
+};
+
+//uniform x3d_PointPropertiesParameters x3d_PointProperties;
+
+struct x3d_LinePropertiesParameters
+{
+	bool          applied;
+	mediump float linewidthScaleFactor;
+	sampler2D     linetype;
+};
+
+//uniform x3d_LinePropertiesParameters x3d_LineProperties;
+
+struct x3d_FillPropertiesParameters
+{
+	bool         filled;
+	bool         hatched;
+	mediump vec3 hatchColor;
+	sampler2D    hatchStyle;
+};
+
+//uniform x3d_FillPropertiesParameters x3d_FillProperties;
+
+struct x3d_MaterialParameters
+{
+	mediump float ambientIntensity;
+	mediump vec3  diffuseColor;
+	mediump vec3  specularColor;
+	mediump vec3  emissiveColor;
+	mediump float shininess;
+	mediump float transparency;
+};
+
+//uniform x3d_MaterialParameters x3d_Material;
+
+struct x3d_MultiTextureParameters
+{
+	mediump int mode;
+	mediump int alphaMode;
+	mediump int source;
+	mediump int function;
+};
+
+//uniform x3d_MultiTextureParameters x3d_MultiTexture [x3d_MaxTextures];
+
+struct x3d_TextureCoordinateGeneratorParameters
+{
+	mediump int   mode;
+	mediump float parameter [6];
+};
+
+//uniform x3d_TextureCoordinateGeneratorParameters x3d_TextureCoordinateGenerator [x3d_MaxTextures];
+
+struct x3d_ParticleParameters
+{
+	mediump int   id;
+	mediump int   life;
+	mediump float elapsedTime;
+};
+
+//uniform x3d_ParticleParameters x3d_Particle;

package/src/assets/shaders/webgl1/Background.fs

@@ -0,0 +1,16 @@
+
+precision highp float;
+precision highp int;
+
+varying vec4 color;  // color
+varying vec3 vertex; // point on geometry
+
+#pragma X3D include "include/ClipPlanes.glsl"
+
+void
+main ()
+{
+	clip ();
+
+	gl_FragColor = color;
+}

package/src/assets/shaders/webgl1/Background.vs

@@ -0,0 +1,22 @@
+
+precision highp float;
+precision highp int;
+
+uniform mat4 x3d_ProjectionMatrix;
+uniform mat4 x3d_ModelViewMatrix;
+
+attribute vec4 x3d_Color;
+attribute vec4 x3d_Vertex;
+
+varying vec4 color;  // color
+varying vec3 vertex; // point on geometry
+
+void
+main ()
+{
+	vec4 position = x3d_ModelViewMatrix * x3d_Vertex;
+
+	color       = x3d_Color;
+	vertex      = position .xyz;
+	gl_Position = x3d_ProjectionMatrix * position;
+}

package/src/assets/shaders/webgl1/Depth.fs

@@ -0,0 +1,16 @@
+
+precision highp float;
+precision highp int;
+
+varying vec3 vertex; // point on geometry
+
+#pragma X3D include "include/Pack.glsl"
+#pragma X3D include "include/ClipPlanes.glsl"
+
+void
+main ()
+{
+	clip ();
+
+	gl_FragColor = pack (gl_FragCoord .z);
+}

package/src/assets/shaders/webgl1/Depth.vs

@@ -0,0 +1,20 @@
+
+precision highp float;
+precision highp int;
+
+uniform mat4 x3d_ProjectionMatrix;
+uniform mat4 x3d_ModelViewMatrix;
+
+attribute vec4 x3d_Vertex;
+
+varying vec3 vertex; // point on geometry
+
+void
+main ()
+{
+	vec4 position = x3d_ModelViewMatrix * x3d_Vertex;
+
+	vertex = position .xyz;
+
+	gl_Position = x3d_ProjectionMatrix * position;
+}

package/src/assets/shaders/webgl1/Fallback.fs

@@ -0,0 +1,38 @@
+precision highp float;
+precision highp int;
+
+uniform x3d_MaterialParameters x3d_Material;
+
+uniform int       x3d_NumTextures;
+uniform sampler2D x3d_Texture2D [1];
+
+varying vec3 vertex;
+varying vec3 normal;
+varying vec4 texCoord;
+varying vec4 color;
+
+void
+main ()
+{
+	vec4 textureColor = x3d_NumTextures > 0 ? texture2D (x3d_Texture2D [0], texCoord .st) : vec4 (1.0);
+	vec4 finalColor   = vec4 (0.0);
+
+	vec3 N = normalize (gl_FrontFacing ? normal : -normal);
+	vec3 V = normalize (-vertex); // normalized vector from point on geometry to viewer's position
+
+	vec3 d = vec3 (0.0, 0.0, -1.0); // light direction
+	vec3 L = -d;
+	vec3 H = normalize (L + V); // specular term
+
+	vec3  diffuseColor   = textureColor .rgb * color .rgb * x3d_Material .diffuseColor;
+	vec3  diffuseTerm    = diffuseColor * max (dot (N, L), 0.0);
+	float specularFactor = bool (x3d_Material .shininess) ? pow (max (dot (N, H), 0.0), x3d_Material .shininess * 128.0) : 1.0;
+	vec3  specularTerm   = x3d_Material .specularColor * specularFactor;
+
+	finalColor .rgb += diffuseTerm + specularTerm;
+	finalColor .rgb += x3d_Material .emissiveColor;
+
+	finalColor .a = textureColor .a * color .a * (1.0 - x3d_Material .transparency);
+
+	gl_FragColor = finalColor;
+}

package/src/assets/shaders/webgl1/Fallback.vs

@@ -0,0 +1,30 @@
+precision highp float;
+precision highp int;
+
+uniform mat4 x3d_ProjectionMatrix;
+uniform mat4 x3d_ModelViewMatrix;
+uniform mat3 x3d_NormalMatrix;
+uniform mat4 x3d_TextureMatrix [1];
+
+uniform bool x3d_ColorMaterial;
+
+attribute vec4 x3d_Vertex;
+attribute vec3 x3d_Normal;
+attribute vec4 x3d_TexCoord0;
+attribute vec4 x3d_Color;
+
+varying vec3 vertex;
+varying vec3 normal;
+varying vec4 texCoord;
+varying vec4 color;
+
+void
+main ()
+{
+	vertex   = vec3 (x3d_ModelViewMatrix * x3d_Vertex);
+	normal   = normalize (x3d_NormalMatrix * x3d_Normal);
+	texCoord = x3d_TextureMatrix [0] * x3d_TexCoord0;
+	color    = x3d_ColorMaterial ? x3d_Color : vec4 (1.0);
+
+	gl_Position = x3d_ProjectionMatrix * x3d_ModelViewMatrix * x3d_Vertex;
+}

package/src/assets/shaders/webgl1/FallbackUnlit.fs

@@ -0,0 +1,21 @@
+precision highp float;
+precision highp int;
+
+uniform x3d_MaterialParameters x3d_Material;
+
+uniform int       x3d_NumTextures;
+uniform sampler2D x3d_Texture2D [1];
+
+varying vec4 texCoord;
+varying vec4 color;
+
+void
+main ()
+{
+	vec4 finalColor = x3d_NumTextures > 0 ? texture2D (x3d_Texture2D [0], texCoord .st) : vec4 (1.0);
+
+	finalColor .rgb *= x3d_Material .emissiveColor;
+	finalColor .a   *= color .a * (1.0 - x3d_Material .transparency);
+
+	gl_FragColor = finalColor;
+}

package/src/assets/shaders/webgl1/FallbackUnlit.vs

@@ -0,0 +1,24 @@
+precision highp float;
+precision highp int;
+
+uniform mat4 x3d_ProjectionMatrix;
+uniform mat4 x3d_ModelViewMatrix;
+uniform mat4 x3d_TextureMatrix [1];
+
+uniform bool x3d_ColorMaterial;
+
+attribute vec4 x3d_Vertex;
+attribute vec4 x3d_TexCoord0;
+attribute vec4 x3d_Color;
+
+varying vec4 texCoord;
+varying vec4 color;
+
+void
+main ()
+{
+	texCoord = x3d_TextureMatrix [0] * x3d_TexCoord0;
+	color    = x3d_ColorMaterial ? x3d_Color : vec4 (1.0);
+
+	gl_Position = x3d_ProjectionMatrix * x3d_ModelViewMatrix * x3d_Vertex;
+}

package/src/assets/shaders/webgl1/Gouraud.fs

@@ -0,0 +1,66 @@
+
+#ifdef X3D_LOGARITHMIC_DEPTH_BUFFER
+#extension GL_EXT_frag_depth : enable
+#endif
+
+precision highp float;
+precision highp int;
+
+uniform int x3d_GeometryType;
+
+uniform bool  x3d_ColorMaterial; // true if a X3DColorNode is attached, otherwise false
+uniform float x3d_AlphaCutoff;
+
+varying float fogDepth;    // fog depth
+varying vec4  frontColor;  // color
+varying vec4  backColor;   // color
+varying vec3  normal;      // normal vector at this point on geometry
+varying vec3  vertex;      // point on geometry
+varying vec3  localNormal; // normal vector at this point on geometry in local coordinates
+varying vec3  localVertex; // point on geometry in local coordinates
+
+#if x3d_MaxTextures > 0
+varying vec4 texCoord0; // texCoord0
+#endif
+
+#if x3d_MaxTextures > 1
+varying vec4 texCoord1; // texCoord1
+#endif
+
+#ifdef X3D_LOGARITHMIC_DEPTH_BUFFER
+uniform float x3d_LogarithmicFarFactor1_2;
+varying float depth;
+#endif
+
+#pragma X3D include "include/Texture.glsl"
+#pragma X3D include "include/Hatch.glsl"
+#pragma X3D include "include/Fog.glsl"
+#pragma X3D include "include/ClipPlanes.glsl"
+
+void
+main ()
+{
+ 	clip ();
+
+	vec4 finalColor = gl_FrontFacing ? frontColor : backColor;
+
+	finalColor      = getTextureColor (finalColor, vec4 (1.0));
+	finalColor      = getProjectiveTextureColor (finalColor);
+	finalColor      = getHatchColor (finalColor);
+	finalColor .rgb = getFogColor (finalColor .rgb);
+
+   if (finalColor .a < x3d_AlphaCutoff)
+   {
+      discard;
+   }
+
+	gl_FragColor = finalColor;
+
+	#ifdef X3D_LOGARITHMIC_DEPTH_BUFFER
+	//http://outerra.blogspot.com/2013/07/logarithmic-depth-buffer-optimizations.html
+	if (x3d_LogarithmicFarFactor1_2 > 0.0)
+		gl_FragDepthEXT = log2 (depth) * x3d_LogarithmicFarFactor1_2;
+	else
+		gl_FragDepthEXT = gl_FragCoord .z;
+	#endif
+}

package/src/assets/shaders/webgl1/Gouraud.vs

@@ -0,0 +1,147 @@
+
+precision highp float;
+precision highp int;
+
+uniform mat4 x3d_TextureMatrix [x3d_MaxTextures];
+uniform mat3 x3d_NormalMatrix;
+uniform mat4 x3d_ProjectionMatrix;
+uniform mat4 x3d_ModelViewMatrix;
+
+uniform bool x3d_ColorMaterial; // true if a X3DColorNode is attached, otherwise false
+
+uniform int x3d_NumLights;
+uniform x3d_LightSourceParameters x3d_LightSource [x3d_MaxLights];
+uniform x3d_MaterialParameters x3d_Material;
+
+attribute float x3d_FogDepth;
+attribute vec4  x3d_Color;
+attribute vec3  x3d_Normal;
+attribute vec4  x3d_Vertex;
+
+#if x3d_MaxTextures > 0
+attribute vec4  x3d_TexCoord0;
+#endif
+
+#if x3d_MaxTextures > 1
+attribute vec4  x3d_TexCoord1;
+#endif
+
+varying float fogDepth;    // fog depth
+varying vec4  frontColor;  // color
+varying vec4  backColor;   // color
+varying vec3  normal;      // normal vector at this point on geometry
+varying vec3  vertex;      // point on geometry
+varying vec3  localNormal; // normal vector at this point on geometry in local coordinates
+varying vec3  localVertex; // point on geometry in local coordinates
+
+#if x3d_MaxTextures > 0
+varying vec4 texCoord0; // texCoord0
+#endif
+
+#if x3d_MaxTextures > 1
+varying vec4 texCoord1; // texCoord1
+#endif
+
+#ifdef X3D_LOGARITHMIC_DEPTH_BUFFER
+varying float depth;
+#endif
+
+float
+getSpotFactor (const in float cutOffAngle, const in float beamWidth, const in vec3 L, const in vec3 d)
+{
+	float spotAngle = acos (clamp (dot (-L, d), -1.0, 1.0));
+
+	if (spotAngle >= cutOffAngle)
+		return 0.0;
+	else if (spotAngle <= beamWidth)
+		return 1.0;
+
+	return (spotAngle - cutOffAngle) / (beamWidth - cutOffAngle);
+}
+
+vec4
+getMaterialColor (const in vec3 N,
+                  const in vec3 vertex,
+                  const in x3d_MaterialParameters material)
+{
+	vec3 V = normalize (-vertex); // normalized vector from point on geometry to viewer's position
+
+	// Calculate diffuseFactor & alpha
+
+	vec3  diffuseFactor = x3d_ColorMaterial ? x3d_Color .rgb : material .diffuseColor;
+	float alpha         = (1.0 - material .transparency) * (x3d_ColorMaterial ? x3d_Color .a : 1.0);
+
+	// Ambient intensity
+
+	vec3 ambientTerm = diffuseFactor * material .ambientIntensity;
+
+	// Apply light sources
+
+	vec3 finalColor = vec3 (0.0);
+
+	for (int i = 0; i < x3d_MaxLights; ++ i)
+	{
+		if (i == x3d_NumLights)
+			break;
+
+		x3d_LightSourceParameters light = x3d_LightSource [i];
+
+		vec3  vL = light .location - vertex;
+		float dL = length (light .matrix * vL);
+		bool  di = light .type == x3d_DirectionalLight;
+
+		if (di || dL <= light .radius)
+		{
+			vec3 d = light .direction;
+			vec3 c = light .attenuation;
+			vec3 L = di ? -d : normalize (vL);      // Normalized vector from point on geometry to light source i position.
+			vec3 H = normalize (L + V);             // Specular term
+
+			float lightAngle     = max (dot (N, L), 0.0);      // Angle between normal and light ray.
+			vec3  diffuseTerm    = diffuseFactor * lightAngle;
+			float specularFactor = material .shininess > 0.0 ? pow (max (dot (N, H), 0.0), material .shininess * 128.0) : 1.0;
+			vec3  specularTerm   = material .specularColor * specularFactor;
+
+			float attenuationFactor     = di ? 1.0 : 1.0 / max (c [0] + c [1] * dL + c [2] * (dL * dL), 1.0);
+			float spotFactor            = light .type == x3d_SpotLight ? getSpotFactor (light .cutOffAngle, light .beamWidth, L, d) : 1.0;
+			float attenuationSpotFactor = attenuationFactor * spotFactor;
+			vec3  ambientColor          = light .ambientIntensity * ambientTerm;
+			vec3  diffuseSpecularColor  = light .intensity * (diffuseTerm + specularTerm);
+
+			finalColor += attenuationSpotFactor * light .color * (ambientColor + diffuseSpecularColor);
+		}
+	}
+
+	finalColor += material .emissiveColor;
+
+	return vec4 (clamp (finalColor, 0.0, 1.0), alpha);
+}
+
+void
+main ()
+{
+	vec4 position = x3d_ModelViewMatrix * x3d_Vertex;
+
+	fogDepth    = x3d_FogDepth;
+	vertex      = position .xyz;
+	normal      = normalize (x3d_NormalMatrix * x3d_Normal);
+	localNormal = x3d_Normal;
+	localVertex = x3d_Vertex .xyz;
+
+	#if x3d_MaxTextures > 0
+	texCoord0 = x3d_TextureMatrix [0] * x3d_TexCoord0;
+	#endif
+
+	#if x3d_MaxTextures > 1
+	texCoord1 = x3d_TextureMatrix [1] * x3d_TexCoord1;
+	#endif
+
+	gl_Position = x3d_ProjectionMatrix * position;
+
+	#ifdef X3D_LOGARITHMIC_DEPTH_BUFFER
+	depth = 1.0 + gl_Position .w;
+	#endif
+
+	frontColor = getMaterialColor ( normal, vertex, x3d_Material);
+	backColor  = getMaterialColor (-normal, vertex, x3d_Material);
+}

package/src/assets/shaders/webgl1/Phong.fs

@@ -0,0 +1,172 @@
+
+#ifdef X3D_LOGARITHMIC_DEPTH_BUFFER
+#extension GL_EXT_frag_depth : enable
+#endif
+
+precision highp float;
+precision highp int;
+
+uniform int   x3d_GeometryType;
+uniform bool  x3d_ColorMaterial; // true if a X3DColorNode is attached, otherwise false
+uniform float x3d_AlphaCutoff;
+
+uniform int x3d_NumLights;
+uniform x3d_LightSourceParameters x3d_LightSource [x3d_MaxLights];
+uniform x3d_MaterialParameters x3d_Material;
+
+varying float fogDepth;    // fog depth
+varying vec4  color;       // color
+varying vec3  normal;      // normal vector at this point on geometry
+varying vec3  vertex;      // point on geometry
+varying vec3  localNormal; // normal vector at this point on geometry in local coordinates
+varying vec3  localVertex; // point on geometry in local coordinates
+
+#if x3d_MaxTextures > 0
+varying vec4 texCoord0; // texCoord0
+#endif
+
+#if x3d_MaxTextures > 1
+varying vec4 texCoord1; // texCoord1
+#endif
+
+#ifdef X3D_LOGARITHMIC_DEPTH_BUFFER
+uniform float x3d_LogarithmicFarFactor1_2;
+varying float depth;
+#endif
+
+#pragma X3D include "include/Shadow.glsl"
+#pragma X3D include "include/Texture.glsl"
+#pragma X3D include "include/Hatch.glsl"
+#pragma X3D include "include/Fog.glsl"
+#pragma X3D include "include/ClipPlanes.glsl"
+
+float
+getSpotFactor (const in float cutOffAngle, const in float beamWidth, const in vec3 L, const in vec3 d)
+{
+	float spotAngle = acos (clamp (dot (-L, d), -1.0, 1.0));
+
+	if (spotAngle >= cutOffAngle)
+		return 0.0;
+	else if (spotAngle <= beamWidth)
+		return 1.0;
+
+	return (spotAngle - cutOffAngle) / (beamWidth - cutOffAngle);
+}
+
+vec4
+getMaterialColor ()
+{
+	vec3  N  = normalize (gl_FrontFacing ? normal : -normal);
+	vec3  V  = normalize (-vertex); // normalized vector from point on geometry to viewer's position
+	float dV = length (vertex);
+
+	// Calculate diffuseFactor & alpha
+
+	vec3  diffuseFactor = vec3 (1.0);
+	float alpha         = 1.0 - x3d_Material .transparency;
+
+	// Texture
+
+	vec4 D = x3d_ColorMaterial ? vec4 (color .rgb, color .a * alpha) : vec4 (x3d_Material .diffuseColor, alpha);
+	vec4 T = getTextureColor (D, vec4 (x3d_Material .specularColor, alpha));
+
+	diffuseFactor = T .rgb;
+	alpha         = T .a;
+
+	// Projective texture
+
+	vec4 P = getProjectiveTextureColor (vec4 (1.0));
+
+	diffuseFactor *= P .rgb;
+	alpha         *= P .a;
+
+	// Ambient intensity
+
+	vec3 ambientTerm = diffuseFactor * x3d_Material .ambientIntensity;
+
+	// Apply light sources
+
+	vec3 finalColor = vec3 (0.0);
+
+	for (int i = 0; i < x3d_MaxLights; i ++)
+	{
+		if (i == x3d_NumLights)
+			break;
+
+		x3d_LightSourceParameters light = x3d_LightSource [i];
+
+		vec3  vL = light .location - vertex; // Light to fragment
+		float dL = length (light .matrix * vL);
+		bool  di = light .type == x3d_DirectionalLight;
+
+		if (di || dL <= light .radius)
+		{
+			vec3 d = light .direction;
+			vec3 c = light .attenuation;
+			vec3 L = di ? -d : normalize (vL);      // Normalized vector from point on geometry to light source i position.
+			vec3 H = normalize (L + V);             // Specular term
+
+			float lightAngle     = max (dot (N, L), 0.0);      // Angle between normal and light ray.
+			vec3  diffuseTerm    = diffuseFactor * lightAngle;
+			float specularFactor = x3d_Material .shininess > 0.0 ? pow (max (dot (N, H), 0.0), x3d_Material .shininess * 128.0) : 1.0;
+			vec3  specularTerm   = x3d_Material .specularColor * specularFactor;
+
+			float attenuationFactor     = di ? 1.0 : 1.0 / max (c [0] + c [1] * dL + c [2] * (dL * dL), 1.0);
+			float spotFactor            = light .type == x3d_SpotLight ? getSpotFactor (light .cutOffAngle, light .beamWidth, L, d) : 1.0;
+			float attenuationSpotFactor = attenuationFactor * spotFactor;
+			vec3  ambientColor          = light .ambientIntensity * ambientTerm;
+			vec3  diffuseSpecularColor  = light .intensity * (diffuseTerm + specularTerm);
+
+			#ifdef X3D_SHADOWS
+				if (lightAngle > 0.0)
+					diffuseSpecularColor = mix (diffuseSpecularColor, light .shadowColor, getShadowIntensity (i, light));
+			#endif
+
+			finalColor += attenuationSpotFactor * light .color * (ambientColor + diffuseSpecularColor);
+		}
+	}
+
+	finalColor += x3d_Material .emissiveColor;
+
+	return vec4 (finalColor, alpha);
+}
+
+// DEBUG
+//uniform ivec4 x3d_Viewport;
+
+void
+main ()
+{
+	clip ();
+
+	vec4 finalColor = vec4 (0.0);
+
+	finalColor      = getMaterialColor ();
+	finalColor      = getHatchColor (finalColor);
+	finalColor .rgb = getFogColor (finalColor .rgb);
+
+   if (finalColor .a < x3d_AlphaCutoff)
+   {
+      discard;
+   }
+
+	gl_FragColor = finalColor;
+
+	#ifdef X3D_LOGARITHMIC_DEPTH_BUFFER
+	//http://outerra.blogspot.com/2013/07/logarithmic-depth-buffer-optimizations.html
+	if (x3d_LogarithmicFarFactor1_2 > 0.0)
+		gl_FragDepthEXT = log2 (depth) * x3d_LogarithmicFarFactor1_2;
+	else
+		gl_FragDepthEXT = gl_FragCoord .z;
+	#endif
+
+	// DEBUG
+	#ifdef X3D_SHADOWS
+	//gl_FragColor .rgb = texture2D (x3d_ShadowMap [0], gl_FragCoord .xy / vec2 (x3d_Viewport .zw)) .rgb;
+	//gl_FragColor .rgb = mix (tex .rgb, gl_FragColor .rgb, 0.5);
+	#endif
+
+	#ifdef X3D_LOGARITHMIC_DEPTH_BUFFER
+	//gl_FragColor .rgb = mix (vec3 (1.0, 0.0, 0.0), gl_FragColor .rgb, 0.5);
+	#endif
+}