x_ite 4.7.14 → 5.0.2

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

@@ -21,10 +21,10 @@ 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);
+   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;
+   gl_Position = x3d_ProjectionMatrix * x3d_ModelViewMatrix * x3d_Vertex;
 }

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

@@ -12,10 +12,10 @@ varying vec4 color;
 void
 main ()
 {
-	vec4 finalColor = x3d_NumTextures > 0 ? texture2D (x3d_Texture2D [0], texCoord .st) : vec4 (1.0);
+   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);
+   finalColor .rgb *= x3d_Material .emissiveColor;
+   finalColor .a   *= color .a * (1.0 - x3d_Material .transparency);
 
-	gl_FragColor = finalColor;
+   gl_FragColor = finalColor;
 }

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

@@ -17,8 +17,8 @@ varying vec4 color;
 void
 main ()
 {
-	texCoord = x3d_TextureMatrix [0] * x3d_TexCoord0;
-	color    = x3d_ColorMaterial ? x3d_Color : vec4 (1.0);
+   texCoord = x3d_TextureMatrix [0] * x3d_TexCoord0;
+   color    = x3d_ColorMaterial ? x3d_Color : vec4 (1.0);
 
-	gl_Position = x3d_ProjectionMatrix * x3d_ModelViewMatrix * x3d_Vertex;
+   gl_Position = x3d_ProjectionMatrix * x3d_ModelViewMatrix * x3d_Vertex;
 }

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

@@ -40,27 +40,27 @@ varying float depth;
 void
 main ()
 {
- 	clip ();
+    clip ();
 
-	vec4 finalColor = gl_FrontFacing ? frontColor : backColor;
+   vec4 finalColor = gl_FrontFacing ? frontColor : backColor;
 
-	finalColor      = getTextureColor (finalColor, vec4 (1.0));
-	finalColor      = getProjectiveTextureColor (finalColor);
-	finalColor      = getHatchColor (finalColor);
-	finalColor .rgb = getFogColor (finalColor .rgb);
+   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;
+   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
+   #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

@@ -2,7 +2,6 @@
 precision highp float;
 precision highp int;
 
-uniform mat4 x3d_TextureMatrix [x3d_MaxTextures];
 uniform mat3 x3d_NormalMatrix;
 uniform mat4 x3d_ProjectionMatrix;
 uniform mat4 x3d_ModelViewMatrix;
@@ -46,102 +45,88 @@ varying vec4 texCoord1; // texCoord1
 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);
-}
+#pragma X3D include "include/SpotFactor.glsl"
 
 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);
+   vec3 V = normalize (-vertex); // normalized vector from point on geometry to viewer's position
 
-	// Ambient intensity
+   // Calculate diffuseColor & alpha
 
-	vec3 ambientTerm = diffuseFactor * material .ambientIntensity;
+   float alpha        = (1.0 - material .transparency) * (x3d_ColorMaterial ? x3d_Color .a : 1.0);
+   vec3  diffuseColor = x3d_ColorMaterial ? x3d_Color .rgb : material .diffuseColor;
+   vec3  ambientColor = diffuseColor * material .ambientIntensity;
 
-	// Apply light sources
+   // Apply light sources
 
-	vec3 finalColor = vec3 (0.0);
+   vec3 finalColor = vec3 (0.0);
 
-	for (int i = 0; i < x3d_MaxLights; ++ i)
-	{
-		if (i == x3d_NumLights)
-			break;
+   for (int i = 0; i < x3d_MaxLights; ++ i)
+   {
+      if (i == x3d_NumLights)
+         break;
 
-		x3d_LightSourceParameters light = x3d_LightSource [i];
+      x3d_LightSourceParameters light = x3d_LightSource [i];
 
-		vec3  vL = light .location - vertex;
-		float dL = length (light .matrix * vL);
-		bool  di = light .type == x3d_DirectionalLight;
+      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
+      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 lightAngle     = max (dot (N, L), 0.0);      // Angle between normal and light ray.
+         vec3  diffuseTerm    = diffuseColor * 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);
+         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  ambientTerm           = light .ambientIntensity * ambientColor;
+         vec3  diffuseSpecularTerm   = light .intensity * (diffuseTerm + specularTerm);
 
-			finalColor += attenuationSpotFactor * light .color * (ambientColor + diffuseSpecularColor);
-		}
-	}
+         finalColor += attenuationSpotFactor * light .color * (ambientTerm + diffuseSpecularTerm);
+      }
+   }
 
-	finalColor += material .emissiveColor;
+   finalColor += material .emissiveColor;
 
-	return vec4 (clamp (finalColor, 0.0, 1.0), alpha);
+   return vec4 (clamp (finalColor, 0.0, 1.0), alpha);
 }
 
 void
 main ()
 {
-	vec4 position = x3d_ModelViewMatrix * x3d_Vertex;
+   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;
+   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 > 0
+   texCoord0 = x3d_TexCoord0;
+   #endif
 
-	#if x3d_MaxTextures > 1
-	texCoord1 = x3d_TextureMatrix [1] * x3d_TexCoord1;
-	#endif
+   #if x3d_MaxTextures > 1
+   texCoord1 = x3d_TexCoord1;
+   #endif
 
-	gl_Position = x3d_ProjectionMatrix * position;
+   gl_Position = x3d_ProjectionMatrix * position;
 
-	#ifdef X3D_LOGARITHMIC_DEPTH_BUFFER
-	depth = 1.0 + gl_Position .w;
-	#endif
+   #ifdef X3D_LOGARITHMIC_DEPTH_BUFFER
+   depth = 1.0 + gl_Position .w;
+   #endif
 
-	frontColor = getMaterialColor ( normal, vertex, x3d_Material);
-	backColor  = getMaterialColor (-normal, vertex, x3d_Material);
+   frontColor = getMaterialColor ( normal, vertex, x3d_Material);
+   backColor  = getMaterialColor (-normal, vertex, x3d_Material);
 }

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

@@ -0,0 +1,74 @@
+
+#ifdef X3D_LOGARITHMIC_DEPTH_BUFFER
+#extension GL_EXT_frag_depth : enable
+#endif
+
+precision highp float;
+precision highp int;
+
+uniform float x3d_AlphaCutoff;
+uniform x3d_LinePropertiesParameters x3d_LineProperties;
+uniform ivec4 x3d_Viewport;
+
+varying float fogDepth; // fog depth
+varying vec4  color;    // color
+varying vec3  vertex;   // point on geometry
+
+#ifdef X_ITE
+varying vec3 startPosition;  // line stipple start
+varying vec3 vertexPosition; // current line stipple position
+#endif
+
+#ifdef X3D_LOGARITHMIC_DEPTH_BUFFER
+uniform float x3d_LogarithmicFarFactor1_2;
+varying float depth;
+#endif
+
+#pragma X3D include "include/Fog.glsl"
+#pragma X3D include "include/ClipPlanes.glsl"
+
+#ifdef X_ITE
+void
+stipple ()
+{
+   if (x3d_LineProperties .applied)
+   {
+      vec2  direction = (vertexPosition .xy - startPosition .xy) * vec2 (x3d_Viewport .zw) * 0.5;
+      float distance  = length (direction) / 16.0;
+      float color     = texture2D (x3d_LineProperties .linetype, vec2 (distance, distance)) .a;
+
+      if (color == 0.0)
+         discard;
+   }
+}
+#endif
+
+void
+main ()
+{
+   clip ();
+
+   #ifdef X_ITE
+   stipple ();
+   #endif
+
+   vec4 finalColor = vec4 (0.0);
+
+   finalColor .rgb = getFogColor (color .rgb);
+   finalColor .a   = color .a;
+
+   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/Line.vs

@@ -0,0 +1,63 @@
+
+precision highp float;
+precision highp int;
+
+uniform bool x3d_ColorMaterial;   // true if a X3DColorNode is attached, otherwise false
+uniform x3d_UnlitMaterialParameters x3d_Material;
+
+uniform mat4 x3d_ProjectionMatrix;
+uniform mat4 x3d_ModelViewMatrix;
+
+attribute float x3d_FogDepth;
+attribute vec4  x3d_Color;
+attribute vec4  x3d_Vertex;
+
+varying float fogDepth; // fog depth
+varying vec4  color;    // color
+varying vec3  vertex;   // point on geometry
+
+#ifdef X_ITE
+attribute vec4 x3d_TexCoord0;
+varying   vec3 startPosition;  // line stipple start
+varying   vec3 vertexPosition; // current line stipple position
+#endif
+
+#ifdef X3D_LOGARITHMIC_DEPTH_BUFFER
+varying float depth;
+#endif
+
+void
+main ()
+{
+   vec4 position = x3d_ModelViewMatrix * x3d_Vertex;
+
+   fogDepth = x3d_FogDepth;
+   vertex   = position .xyz;
+
+   gl_Position = x3d_ProjectionMatrix * position;
+
+   #ifdef X_ITE
+   // Line Stipple
+   vec4 start = x3d_ProjectionMatrix * x3d_ModelViewMatrix * x3d_TexCoord0;
+
+   startPosition  = start .xyz / start .w;
+   vertexPosition = gl_Position .xyz / gl_Position .w;
+   #endif
+
+   #ifdef X3D_LOGARITHMIC_DEPTH_BUFFER
+   depth = 1.0 + gl_Position .w;
+   #endif
+
+   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;
+   }
+}