x_ite 4.7.12 → 5.0.0

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

@@ -2,12 +2,13 @@
 
 precision highp float;
 precision highp int;
+precision highp sampler3D;
 
 uniform int   x3d_GeometryType;
 uniform bool  x3d_ColorMaterial; // true if a X3DColorNode is attached, otherwise false
 uniform float x3d_AlphaCutoff;
 
-uniform x3d_MaterialParameters x3d_Material;
+uniform x3d_UnlitMaterialParameters x3d_Material;
 
 in float fogDepth;    // fog depth
 in vec4  color;       // color
@@ -36,12 +37,39 @@ out vec4 x3d_FragColor;
 #pragma X3D include "include/Fog.glsl"
 #pragma X3D include "include/ClipPlanes.glsl"
 
+#ifdef X3D_MATERIAL_TEXTURES
+uniform x3d_EmissiveTextureParameters x3d_EmissiveTexture;
+#endif
+
 vec4
-getMaterialColor ()
+getEmissiveColor ()
 {
-	float alpha = 1.0 - x3d_Material .transparency;
+   // Get emissive parameter.
+
+   float alpha             = 1.0 - x3d_Material .transparency;
+   vec4  emissiveParameter = x3d_ColorMaterial ? vec4 (color .rgb, color .a * alpha) : vec4 (x3d_Material .emissiveColor, alpha);
+
+   // Get texture color.
+
+   #if defined(X3D_EMISSIVE_TEXTURE)
+      vec4 texCoord = getTexCoord (x3d_EmissiveTexture .textureTransformMapping, x3d_EmissiveTexture .textureCoordinateMapping);
+
+      #if defined(X3D_EMISSIVE_TEXTURE_2D)
+         return emissiveParameter * texture (x3d_EmissiveTexture .texture2D, texCoord .st) .rgba;
+      #elif defined(X3D_EMISSIVE_TEXTURE_3D)
+         return emissiveParameter * texture (x3d_EmissiveTexture .texture3D, texCoord .stp) .rgba;
+      #elif defined(X3D_EMISSIVE_TEXTURE_CUBE)
+         return emissiveParameter * texture (x3d_EmissiveTexture .textureCube, texCoord .stp) .rgba;
+      #endif
+   #else
+      return getTextureColor (emissiveParameter, vec4 (vec3 (1.0), alpha));
+   #endif
+}
 
-	return getTextureColor (x3d_ColorMaterial ? vec4 (color .rgb, color .a * alpha) : vec4 (x3d_Material .emissiveColor, alpha), vec4 (1.0));
+vec4
+getMaterialColor ()
+{
+   return getEmissiveColor ();
 }
 
 // DEBUG
@@ -50,36 +78,36 @@ getMaterialColor ()
 void
 main ()
 {
-	clip ();
+   clip ();
 
-	vec4 finalColor = vec4 (0.0);
+   vec4 finalColor = vec4 (0.0);
 
-	finalColor      = getMaterialColor ();
-	finalColor      = getHatchColor (finalColor);
-	finalColor .rgb = getFogColor (finalColor .rgb);
+   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
+   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/Unlit.vs

@@ -3,7 +3,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;
@@ -43,26 +42,26 @@ out float depth;
 void
 main ()
 {
-	vec4 position = x3d_ModelViewMatrix * x3d_Vertex;
+   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;
+   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 > 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
 }

package/src/assets/shaders/webgl2/include/ClipPlanes.glsl

@@ -5,12 +5,12 @@ uniform vec4 x3d_ClipPlane [x3d_MaxClipPlanes];
 void
 clip ()
 {
-	for (int i = 0; i < x3d_MaxClipPlanes; ++ i)
-	{
-		if (i == x3d_NumClipPlanes)
-			break;
+   for (int i = 0; i < x3d_MaxClipPlanes; ++ i)
+   {
+      if (i == x3d_NumClipPlanes)
+         break;
 
-		if (dot (vertex, x3d_ClipPlane [i] .xyz) - x3d_ClipPlane [i] .w < 0.0)
-			discard;
-	}
+      if (dot (vertex, x3d_ClipPlane [i] .xyz) - x3d_ClipPlane [i] .w < 0.0)
+         discard;
+   }
 }

package/src/assets/shaders/webgl2/include/Colors.glsl

@@ -0,0 +1,27 @@
+#define MANUAL_SRGB
+
+vec4
+SRGBtoLINEAR (const in vec4 srgbIn)
+{
+   #ifdef MANUAL_SRGB
+      #ifdef SRGB_FAST_APPROXIMATION
+         vec3 linOut = pow (srgbIn .xyz, vec3 (2.2));
+      #else //SRGB_FAST_APPROXIMATION
+         vec3 bLess  = step (vec3 (0.04045), srgbIn .xyz);
+         vec3 linOut = mix (srgbIn .xyz / vec3 (12.92), pow ((srgbIn .xyz + vec3 (0.055)) / vec3 (1.055), vec3 (2.4)), bLess);
+      #endif //SRGB_FAST_APPROXIMATION
+      return vec4 (linOut, srgbIn .w);
+   #else //MANUAL_SRGB
+      return srgbIn;
+   #endif //MANUAL_SRGB
+}
+
+vec4
+Gamma (const in vec4 color)
+{
+   #ifdef MANUAL_SRGB
+   return vec4 (pow (color .rgb, vec3 (1.0 / 2.2)), color .a);
+   #else
+   return color;
+   #endif
+}

package/src/assets/shaders/webgl2/include/Fog.glsl

@@ -4,43 +4,43 @@ uniform x3d_FogParameters x3d_Fog;
 float
 getFogInterpolant ()
 {
-	// Returns 0.0 for fog color and 1.0 for material color.
-
-	if (x3d_Fog .type == x3d_None)
-		return 1.0;
-
-	if (x3d_Fog .fogCoord)
-		return clamp (1.0 - fogDepth, 0.0, 1.0);
-
-	float visibilityRange = x3d_Fog .visibilityRange;
-
-	if (visibilityRange <= 0.0)
-		return 1.0;
-
-	float dV = length (x3d_Fog .matrix * vertex);
-
-	if (dV >= visibilityRange)
-		return 0.0;
-
-	switch (x3d_Fog .type)
-	{
-		case x3d_LinearFog:
-		{
-			return (visibilityRange - dV) / visibilityRange;
-		}
-		case x3d_ExponentialFog:
-		{
-			return exp (-dV / (visibilityRange - dV));
-		}
-		default:
-		{
-			return 1.0;
-		}
-	}
+   // Returns 0.0 for fog color and 1.0 for material color.
+
+   if (x3d_Fog .type == x3d_None)
+      return 1.0;
+
+   if (x3d_Fog .fogCoord)
+      return clamp (1.0 - fogDepth, 0.0, 1.0);
+
+   float visibilityRange = x3d_Fog .visibilityRange;
+
+   if (visibilityRange <= 0.0)
+      return 1.0;
+
+   float dV = length (x3d_Fog .matrix * vertex);
+
+   if (dV >= visibilityRange)
+      return 0.0;
+
+   switch (x3d_Fog .type)
+   {
+      case x3d_LinearFog:
+      {
+         return (visibilityRange - dV) / visibilityRange;
+      }
+      case x3d_ExponentialFog:
+      {
+         return exp (-dV / (visibilityRange - dV));
+      }
+      default:
+      {
+         return 1.0;
+      }
+   }
 }
 
 vec3
 getFogColor (const in vec3 color)
 {
-	return mix (x3d_Fog .color, color, getFogInterpolant ());
+   return mix (x3d_Fog .color, color, getFogInterpolant ());
 }

package/src/assets/shaders/webgl2/include/Hatch.glsl

@@ -4,15 +4,15 @@ uniform x3d_FillPropertiesParameters x3d_FillProperties;
 vec4
 getHatchColor (vec4 color)
 {
-	vec4 finalColor = x3d_FillProperties .filled ? color : vec4 (0.0);
+   vec4 finalColor = x3d_FillProperties .filled ? color : vec4 (0.0);
 
-	if (x3d_FillProperties .hatched)
-	{
-		vec4 hatch = texture (x3d_FillProperties .hatchStyle, gl_FragCoord .xy / 32.0);
+   if (x3d_FillProperties .hatched)
+   {
+      vec4 hatch = texture (x3d_FillProperties .hatchStyle, gl_FragCoord .xy / 32.0);
 
-		hatch .rgb *= x3d_FillProperties .hatchColor;
-		finalColor  = mix (finalColor, hatch, hatch .a);
-	}
+      hatch .rgb *= x3d_FillProperties .hatchColor;
+      finalColor  = mix (finalColor, hatch, hatch .a);
+   }
 
-	return finalColor;
+   return finalColor;
 }

package/src/assets/shaders/webgl2/include/Normal.glsl

@@ -0,0 +1,46 @@
+#ifdef X3D_MATERIAL_TEXTURES
+uniform x3d_NormalTextureParameters x3d_NormalTexture;
+
+// Tangent-Bitangent-Normal-Matrix
+mat3
+getTBNMatrix (const in vec2 texCoord)
+{
+   vec3 pos_dx = dFdx (vertex);
+   vec3 pos_dy = dFdy (vertex);
+   vec3 tex_dx = dFdx (vec3 (texCoord, 0.0));
+   vec3 tex_dy = dFdy (vec3 (texCoord, 0.0));
+   vec3 t      = (tex_dy .t * pos_dx - tex_dx .t * pos_dy) / (tex_dx .s * tex_dy.t - tex_dy .s * tex_dx .t);
+   vec3 N      = normalize (normal); // OR generated face normal: n = normalize (cross (pos_dx, pos_dy));
+   vec3 T      = normalize (t - N * dot (N, t));
+   vec3 B      = normalize (cross (N, T));
+   mat3 tbn    = mat3 (T, B, N);
+
+   return tbn;
+}
+#endif
+
+vec3
+getNormalVector ()
+{
+   float facing = gl_FrontFacing ? 1.0 : -1.0;
+
+   // Get normal vector.
+
+   #if defined(X3D_NORMAL_TEXTURE)
+      vec4 texCoord    = getTexCoord (x3d_NormalTexture .textureTransformMapping, x3d_NormalTexture .textureCoordinateMapping);
+      vec3 normalScale = vec3 (vec2 (x3d_Material .normalScale), 1.0);
+      mat3 tbn         = getTBNMatrix (texCoord .st);
+
+      #if defined(X3D_NORMAL_TEXTURE_2D)
+         vec3 n = texture (x3d_NormalTexture .texture2D, texCoord .st) .rgb;
+      #elif defined(X3D_NORMAL_TEXTURE_3D)
+         vec3 n = texture (x3d_NormalTexture .texture3D, texCoord .stp) .rgb;
+      #elif defined(X3D_NORMAL_TEXTURE_CUBE)
+         vec3 n = texture (x3d_NormalTexture .textureCube, texCoord .stp) .rgb;
+      #endif
+
+      return normalize (tbn * ((n * 2.0 - 1.0) * normalScale)) * facing;
+   #else
+   return normalize (normal) * facing;
+   #endif
+}

package/src/assets/shaders/webgl2/include/Pack.glsl

@@ -4,13 +4,13 @@
 vec4
 pack (const in float value)
 {
-	return vec4 (0.0, 0.0, 0.0, 0.0);
+   return vec4 (0.0, 0.0, 0.0, 0.0);
 }
 
 float
 unpack (const in vec4 color)
 {
-	return color .r;
+   return color .r;
 }
 
 #endif
@@ -20,11 +20,11 @@ unpack (const in vec4 color)
 vec4
 pack (const in float value)
 {
-	const vec3 bitShifts = vec3 (255.0,
-	                             255.0 * 255.0,
-	                             255.0 * 255.0 * 255.0);
+   const vec3 bitShifts = vec3 (255.0,
+                                255.0 * 255.0,
+                                255.0 * 255.0 * 255.0);
 
-	return vec4 (value, fract (value * bitShifts));
+   return vec4 (value, fract (value * bitShifts));
 }
 
 #ifdef X3D_DEPTH_TEXTURE
@@ -32,7 +32,7 @@ pack (const in float value)
 float
 unpack (const in vec4 color)
 {
-	return color .r;
+   return color .r;
 }
 
 #else
@@ -40,11 +40,11 @@ unpack (const in vec4 color)
 float
 unpack (const vec4 color)
 {
-	const vec3 bitShifts = vec3 (1.0 / 255.0,
-	                             1.0 / (255.0 * 255.0),
-	                             1.0 / (255.0 * 255.0 * 255.0));
+   const vec3 bitShifts = vec3 (1.0 / 255.0,
+                                1.0 / (255.0 * 255.0),
+                                1.0 / (255.0 * 255.0 * 255.0));
 
-	return color .x + dot (color .gba, bitShifts);
+   return color .x + dot (color .gba, bitShifts);
 }
 
 #endif

package/src/assets/shaders/webgl2/include/Perlin.glsl

@@ -1,8 +1,5 @@
-
 //https://gist.github.com/patriciogonzalezvivo/670c22f3966e662d2f83
 
-#define M_PI 3.14159265358979323846
-
 float rand (vec2 co) { return fract (sin (dot (co.xy, vec2 (12.9898,78.233))) * 43758.5453); }
 float rand (vec2 co, float l) { return rand (vec2 (rand (co), l)); }
 float rand (vec2 co, float l, float t) { return rand (vec2 (rand (co, l), t)); }
@@ -10,31 +7,33 @@ float rand (vec2 co, float l, float t) { return rand (vec2 (rand (co, l), t)); }
 float
 perlin (vec2 p, float dim, float time)
 {
-	vec2 pos   = floor (p * dim);
-	vec2 posx  = pos + vec2 (1.0, 0.0);
-	vec2 posy  = pos + vec2 (0.0, 1.0);
-	vec2 posxy = pos + vec2 (1.0);
+   const float M_PI = 3.14159265358979323846;
+
+   vec2 pos   = floor (p * dim);
+   vec2 posx  = pos + vec2 (1.0, 0.0);
+   vec2 posy  = pos + vec2 (0.0, 1.0);
+   vec2 posxy = pos + vec2 (1.0);
 
-	float c   = rand (pos,   dim, time);
-	float cx  = rand (posx,  dim, time);
-	float cy  = rand (posy,  dim, time);
-	float cxy = rand (posxy, dim, time);
+   float c   = rand (pos,   dim, time);
+   float cx  = rand (posx,  dim, time);
+   float cy  = rand (posy,  dim, time);
+   float cxy = rand (posxy, dim, time);
 
-	vec2 d = fract (p * dim);
+   vec2 d = fract (p * dim);
 
-	d = -0.5 * cos (d * M_PI) + 0.5;
+   d = -0.5 * cos (d * M_PI) + 0.5;
 
-	float ccx    = mix (c,   cx,    d.x);
-	float cycxy  = mix (cy,  cxy,   d.x);
-	float center = mix (ccx, cycxy, d.y);
+   float ccx    = mix (c,   cx,    d.x);
+   float cycxy  = mix (cy,  cxy,   d.x);
+   float center = mix (ccx, cycxy, d.y);
 
-	return center * 2.0 - 1.0;
+   return center * 2.0 - 1.0;
 }
 
 vec3
 perlin (vec3 p)
 {
-	return vec3 (perlin (p.xy, 1.0, 0.0),
-	             perlin (p.yz, 1.0, 0.0),
-	             perlin (p.zx, 1.0, 0.0));
+   return vec3 (perlin (p.xy, 1.0, 0.0),
+                perlin (p.yz, 1.0, 0.0),
+                perlin (p.zx, 1.0, 0.0));
 }