x_ite 4.2.17 → 4.7.7

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

@@ -0,0 +1,19 @@
+#version 300 es
+
+precision highp float;
+precision highp int;
+
+in vec3 vertex; // point on geometry
+
+out vec4 x3d_FragColor;
+
+#pragma X3D include "include/Pack.glsl"
+#pragma X3D include "include/ClipPlanes.glsl"
+
+void
+main ()
+{
+	clip ();
+
+	x3d_FragColor = pack (gl_FragCoord .z);
+}

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

@@ -0,0 +1,21 @@
+#version 300 es
+
+precision highp float;
+precision highp int;
+
+uniform mat4 x3d_ProjectionMatrix;
+uniform mat4 x3d_ModelViewMatrix;
+
+in vec4 x3d_Vertex;
+
+out 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/webgl2/Gouraud.fs

@@ -0,0 +1,64 @@
+#version 300 es
+
+precision highp float;
+precision highp int;
+
+uniform int   x3d_GeometryType;  // true if a X3DMaterialNode is attached, otherwise false
+uniform bool  x3d_ColorMaterial; // true if a X3DColorNode is attached, otherwise false
+uniform float x3d_AlphaCutoff;
+
+in float fogDepth;    // fog depth
+in vec4  frontColor;  // color
+in vec4  backColor;   // color
+in vec3  normal;      // normal vector at this point on geometry
+in vec3  vertex;      // point on geometry
+in vec3  localNormal; // normal vector at this point on geometry in local coordinates
+in vec3  localVertex; // point on geometry in local coordinates
+
+#if x3d_MaxTextures > 0
+in vec4 texCoord0;
+#endif
+
+#if x3d_MaxTextures > 1
+in vec4 texCoord1;
+#endif
+
+#ifdef X3D_LOGARITHMIC_DEPTH_BUFFER
+uniform float x3d_LogarithmicFarFactor1_2;
+in float depth;
+#endif
+
+out vec4 x3d_FragColor;
+
+#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;
+   }
+
+	x3d_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_FragDepth = log2 (depth) * x3d_LogarithmicFarFactor1_2;
+	else
+		gl_FragDepth = gl_FragCoord .z;
+	#endif
+}

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

@@ -0,0 +1,148 @@
+#version 300 es
+
+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;
+
+in float x3d_FogDepth;
+in vec4  x3d_Color;
+in vec3  x3d_Normal;
+in vec4  x3d_Vertex;
+
+#if x3d_MaxTextures > 0
+in vec4 x3d_TexCoord0;
+#endif
+
+#if x3d_MaxTextures > 1
+in vec4 x3d_TexCoord1;
+#endif
+
+out float fogDepth;    // fog depth
+out vec4  frontColor;  // color
+out vec4  backColor;   // color
+out vec3  normal;      // normal vector at this point on geometry
+out vec3  vertex;      // point on geometry
+out vec3  localNormal; // normal vector at this point on geometry in local coordinates
+out vec3  localVertex; // point on geometry in local coordinates
+
+#if x3d_MaxTextures > 0
+out vec4  texCoord0;   // texCoord0
+#endif
+
+#if x3d_MaxTextures > 1
+out vec4  texCoord1;   // texCoord1
+#endif
+
+#ifdef X3D_LOGARITHMIC_DEPTH_BUFFER
+out 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/webgl2/Phong.fs

@@ -0,0 +1,170 @@
+#version 300 es
+
+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;
+
+in float fogDepth;    // fog depth
+in vec4  color;       // color
+in vec3  normal;      // normal vector at this point on geometry
+in vec3  vertex;      // point on geometry
+in vec3  localNormal; // normal vector at this point on geometry in local coordinates
+in vec3  localVertex; // point on geometry in local coordinates
+
+#if x3d_MaxTextures > 0
+in vec4 texCoord0;
+#endif
+
+#if x3d_MaxTextures > 1
+in vec4 texCoord1;
+#endif
+
+#ifdef X3D_LOGARITHMIC_DEPTH_BUFFER
+uniform float x3d_LogarithmicFarFactor1_2;
+in float depth;
+#endif
+
+out vec4 x3d_FragColor;
+
+#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
+
+	// 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;
+   }
+
+	x3d_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_FragDepth = log2 (depth) * x3d_LogarithmicFarFactor1_2;
+	else
+		gl_FragDepth = gl_FragCoord .z;
+	#endif
+
+	// DEBUG
+	#ifdef X3D_SHADOWS
+	//x3d_FragColor .rgb = texture2D (x3d_ShadowMap [0], gl_FragCoord .xy / vec2 (x3d_Viewport .zw)) .rgb;
+	//x3d_FragColor .rgb = mix (tex .rgb, x3d_FragColor .rgb, 0.5);
+	#endif
+
+	#ifdef X3D_LOGARITHMIC_DEPTH_BUFFER
+	//x3d_FragColor .rgb = mix (vec3 (1.0, 0.0, 0.0), x3d_FragColor .rgb, 0.5);
+	#endif
+}

package/src/assets/shaders/webgl2/Phong.vs

@@ -0,0 +1,68 @@
+#version 300 es
+
+precision highp float;
+precision highp int;
+
+uniform mat4 x3d_TextureMatrix [x3d_MaxTextures];
+uniform mat3 x3d_NormalMatrix;
+uniform mat4 x3d_ProjectionMatrix;
+uniform mat4 x3d_ModelViewMatrix;
+
+in float x3d_FogDepth;
+in vec4  x3d_Color;
+in vec3  x3d_Normal;
+in vec4  x3d_Vertex;
+
+#if x3d_MaxTextures > 0
+in vec4 x3d_TexCoord0;
+#endif
+
+#if x3d_MaxTextures > 1
+in vec4 x3d_TexCoord1;
+#endif
+
+out float fogDepth;    // fog depth
+out vec4  color;       // color
+out vec3  normal;      // normalized normal vector at this point on geometry
+out vec3  vertex;      // point on geometry
+out vec3  localNormal; // normal vector at this point on geometry in local coordinates
+out vec3  localVertex; // point on geometry in local coordinates
+
+#if x3d_MaxTextures > 0
+out vec4  texCoord0;   // texCoord0
+#endif
+
+#if x3d_MaxTextures > 1
+out vec4  texCoord1;   // texCoord1
+#endif
+
+#ifdef X3D_LOGARITHMIC_DEPTH_BUFFER
+out float depth;
+#endif
+
+void
+main ()
+{
+	vec4 position = x3d_ModelViewMatrix * x3d_Vertex;
+
+	fogDepth    = x3d_FogDepth;
+	color       = x3d_Color;
+	normal      = x3d_NormalMatrix * x3d_Normal;
+	vertex      = position .xyz;
+	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
+}

package/src/assets/shaders/webgl2/PointSet.fs

@@ -0,0 +1,99 @@
+#version 300 es
+
+precision highp float;
+precision highp int;
+
+uniform int   x3d_GeometryType;
+uniform float x3d_AlphaCutoff;
+uniform x3d_PointPropertiesParameters x3d_PointProperties;
+
+in float pointSize; // point size
+in float fogDepth;  // fog depth
+in vec4  color;     // color
+in vec3  vertex;    // point on geometry
+
+// Text coords, later initialized.
+vec4 texCoord0 = vec4 (0.0);
+vec4 texCoord1 = vec4 (0.0);
+
+// Dummy variables for texture coordinate generator, which is not available.
+vec3 normal      = vec3 (0.0);
+vec3 localNormal = vec3 (0.0);
+vec3 localVertex = vec3 (0.0);
+
+#ifdef X3D_LOGARITHMIC_DEPTH_BUFFER
+uniform float x3d_LogarithmicFarFactor1_2;
+in float depth;
+#endif
+
+out vec4 x3d_FragColor;
+
+#pragma X3D include "include/Fog.glsl"
+#pragma X3D include "include/ClipPlanes.glsl"
+#pragma X3D include "include/Texture.glsl"
+
+vec4
+getPointColor ()
+{
+	vec4 finalColor = color;
+
+	if (x3d_NumTextures > 0)
+	{
+		vec4 texCoord  = vec4 (gl_PointCoord .x, 1.0 - gl_PointCoord .y, 0.0, 1.0);
+
+		texCoord0 = texCoord;
+		texCoord1 = texCoord;
+
+		vec4 textureColor = getTextureColor (vec4 (1.0), vec4 (1.0));
+
+		switch (x3d_PointProperties .colorMode)
+		{
+			case x3d_PointColor:
+				finalColor .a *= textureColor .a;
+				break;
+			case x3d_TextureColor:
+				finalColor = textureColor;
+				break;
+			case x3d_TextureAndPointColor:
+				finalColor .rgb += textureColor .rgb;
+				finalColor .a   *= textureColor .a;
+				break;
+		}
+	}
+	else
+	{
+		float ps = (pointSize + 1.0) / 2.0;
+		float t  = distance (vec2 (0.5, 0.5), gl_PointCoord) * 2.0 * ps - ps + 1.0;
+
+		finalColor .a = mix (finalColor .a, 0.0, clamp (t, 0.0, 1.0));
+	}
+
+	return finalColor;
+}
+
+void
+main ()
+{
+	clip ();
+
+	vec4 finalColor = getPointColor ();
+
+	finalColor .rgb = getFogColor (finalColor .rgb);
+
+   if (finalColor .a < x3d_AlphaCutoff)
+   {
+      discard;
+   }
+
+	x3d_FragColor = finalColor;
+
+	// Logarithmic Depth Buffer
+
+	#ifdef X3D_LOGARITHMIC_DEPTH_BUFFER
+	//http://outerra.blogspot.com/2013/07/logarithmic-depth-buffer-optimizations.html
+	if (x3d_LogarithmicFarFactor1_2 > 0.0)
+		gl_FragDepth = log2 (depth) * x3d_LogarithmicFarFactor1_2;
+	else
+		gl_FragDepth = gl_FragCoord .z;
+	#endif
+}

package/src/assets/shaders/webgl2/PointSet.vs

@@ -0,0 +1,71 @@
+#version 300 es
+
+precision highp float;
+precision highp int;
+
+uniform x3d_PointPropertiesParameters x3d_PointProperties;
+
+uniform bool x3d_ColorMaterial;   // true if a X3DColorNode is attached, otherwise false
+uniform x3d_MaterialParameters x3d_Material;
+uniform int x3d_NumTextures;
+
+uniform mat4 x3d_ProjectionMatrix;
+uniform mat4 x3d_ModelViewMatrix;
+
+in float x3d_FogDepth;
+in vec4  x3d_Color;
+in vec4  x3d_Vertex;
+
+out float pointSize; // point size
+out float fogDepth;  // fog depth
+out vec4  color;     // color
+out vec3  vertex;    // point on geometry
+
+#ifdef X3D_LOGARITHMIC_DEPTH_BUFFER
+out float depth;
+#endif
+
+void
+main ()
+{
+	// Determine varyings.
+
+	vec4 position = x3d_ModelViewMatrix * x3d_Vertex;
+
+	fogDepth = x3d_FogDepth;
+	vertex   = position .xyz;
+
+	gl_Position = x3d_ProjectionMatrix * position;
+
+	#ifdef X3D_LOGARITHMIC_DEPTH_BUFFER
+	depth = 1.0 + gl_Position .w;
+	#endif
+
+	// Determine point size.
+
+	float pointSizeMinValue    = x3d_PointProperties .pointSizeMinValue;
+	float pointSizeMaxValue    = x3d_PointProperties .pointSizeMaxValue;
+	vec3  pointSizeAttenuation = x3d_PointProperties .pointSizeAttenuation;
+	float dL                   = length (vertex);
+
+	pointSize  = x3d_PointProperties .pointSizeScaleFactor;
+	pointSize *= 1.0 / (pointSizeAttenuation [0] + pointSizeAttenuation [1] * dL + pointSizeAttenuation [2] * (dL * dL));
+	pointSize  = clamp (pointSize, pointSizeMinValue, pointSizeMaxValue);
+
+	gl_PointSize = pointSize + (x3d_NumTextures > 0 ? 0.0 : 1.0);
+
+	// Determine color.
+
+	float alpha = 1.0 - x3d_Material .transparency;
+
+	if (x3d_ColorMaterial)
+	{
+		color .rgb = x3d_Color .rgb;
+		color .a   = x3d_Color .a * alpha;
+	}
+	else
+	{
+		color .rgb = x3d_Material .emissiveColor;
+		color .a   = alpha;
+	}
+}