x_ite 4.7.12 → 5.0.0

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

@@ -9,7 +9,7 @@ uniform float x3d_AlphaCutoff;
 
 uniform int x3d_NumLights;
 uniform x3d_LightSourceParameters x3d_LightSource [x3d_MaxLights];
-uniform x3d_MaterialParameters x3d_Material;
+uniform x3d_MaterialParameters    x3d_Material;
 
 in float fogDepth;    // fog depth
 in vec4  color;       // color
@@ -35,98 +35,233 @@ out vec4 x3d_FragColor;
 
 #pragma X3D include "include/Shadow.glsl"
 #pragma X3D include "include/Texture.glsl"
+#pragma X3D include "include/Normal.glsl"
 #pragma X3D include "include/Hatch.glsl"
 #pragma X3D include "include/Fog.glsl"
 #pragma X3D include "include/ClipPlanes.glsl"
+#pragma X3D include "include/SpotFactor.glsl"
+
+#ifdef X3D_MATERIAL_TEXTURES
+uniform x3d_AmbientTextureParameters   x3d_AmbientTexture;
+uniform x3d_DiffuseTextureParameters   x3d_DiffuseTexture;
+uniform x3d_SpecularTextureParameters  x3d_SpecularTexture;
+uniform x3d_EmissiveTextureParameters  x3d_EmissiveTexture;
+uniform x3d_ShininessTextureParameters x3d_ShininessTexture;
+uniform x3d_OcclusionTextureParameters x3d_OcclusionTexture;
+#endif
 
-float
-getSpotFactor (const in float cutOffAngle, const in float beamWidth, const in vec3 L, const in vec3 d)
+vec3
+getAmbientColor ()
 {
-	float spotAngle = acos (clamp (dot (-L, d), -1.0, 1.0));
+   // Get ambient parameter.
+
+   vec3 ambientParameter = x3d_Material .ambientIntensity * x3d_Material .diffuseColor;
+
+   // Get texture color.
 
-	if (spotAngle >= cutOffAngle)
-		return 0.0;
-	else if (spotAngle <= beamWidth)
-		return 1.0;
+   #if defined(X3D_AMBIENT_TEXTURE)
+      vec4 texCoord = getTexCoord (x3d_AmbientTexture .textureTransformMapping, x3d_AmbientTexture .textureCoordinateMapping);
 
-	return (spotAngle - cutOffAngle) / (beamWidth - cutOffAngle);
+      #if defined(X3D_AMBIENT_TEXTURE_2D)
+         return ambientParameter * texture (x3d_AmbientTexture .texture2D, texCoord .st) .rgb;
+      #elif defined(X3D_AMBIENT_TEXTURE_3D)
+         return ambientParameter * texture (x3d_AmbientTexture .texture3D, texCoord .stp) .rgb;
+      #elif defined(X3D_AMBIENT_TEXTURE_CUBE)
+         return ambientParameter * texture (x3d_AmbientTexture .textureCube, texCoord .stp) .rgb;
+      #endif
+   #else
+      return ambientParameter;
+   #endif
 }
 
 vec4
-getMaterialColor ()
+getDiffuseColor ()
 {
-	vec3 N = normalize (gl_FrontFacing ? normal : -normal);
-	vec3 V = normalize (-vertex); // normalized vector from point on geometry to viewer's position
+   // Get diffuse parameter.
+
+   float alpha            = 1.0 - x3d_Material .transparency;
+   vec4  diffuseParameter = x3d_ColorMaterial ? vec4 (color .rgb, color .a * alpha) : vec4 (x3d_Material .diffuseColor, alpha);
+
+   // Get texture color.
+
+   #if defined(X3D_DIFFUSE_TEXTURE)
+      vec4 texCoord = getTexCoord (x3d_DiffuseTexture .textureTransformMapping, x3d_DiffuseTexture .textureCoordinateMapping);
+
+      #if defined(X3D_DIFFUSE_TEXTURE_2D)
+         return diffuseParameter * texture (x3d_DiffuseTexture .texture2D, texCoord .st) .rgba;
+      #elif defined(X3D_DIFFUSE_TEXTURE_3D)
+         return diffuseParameter * texture (x3d_DiffuseTexture .texture3D, texCoord .stp) .rgba;
+      #elif defined(X3D_DIFFUSE_TEXTURE_CUBE)
+         return diffuseParameter * texture (x3d_DiffuseTexture .textureCube, texCoord .stp) .rgba;
+      #endif
+   #else
+      return getTextureColor (diffuseParameter, vec4 (x3d_Material .specularColor, alpha));
+   #endif
+}
 
-	// Calculate diffuseFactor & alpha
+vec3
+getSpecularColor ()
+{
+   // Get specular parameter.
 
-	vec3  diffuseFactor = vec3 (1.0);
-	float alpha         = 1.0 - x3d_Material .transparency;
+   vec3 specularParameter = x3d_Material .specularColor;
 
-	// Texture
+   // Get texture color.
 
-	vec4 D = x3d_ColorMaterial ? vec4 (color .rgb, color .a * alpha) : vec4 (x3d_Material .diffuseColor, alpha);
-	vec4 T = getTextureColor (D, vec4 (x3d_Material .specularColor, alpha));
+   #if defined(X3D_SPECULAR_TEXTURE)
+      vec4 texCoord = getTexCoord (x3d_SpecularTexture .textureTransformMapping, x3d_SpecularTexture .textureCoordinateMapping);
 
-	diffuseFactor = T .rgb;
-	alpha         = T .a;
+      #if defined(X3D_SPECULAR_TEXTURE_2D)
+         return specularParameter * texture (x3d_SpecularTexture .texture2D, texCoord .st) .rgb;
+      #elif defined(X3D_SPECULAR_TEXTURE_3D)
+         return specularParameter * texture (x3d_SpecularTexture .texture3D, texCoord .stp) .rgb;
+      #elif defined(X3D_SPECULAR_TEXTURE_CUBE)
+         return specularParameter * texture (x3d_SpecularTexture .textureCube, texCoord .stp) .rgb;
+      #endif
+   #else
+      return specularParameter;
+   #endif
+}
 
-	// Projective texture
+vec3
+getEmissiveColor ()
+{
+   // Get emissive parameter.
 
-	vec4 P = getProjectiveTextureColor (vec4 (1.0));
+   vec3 emissiveParameter = x3d_Material .emissiveColor;
 
-	diffuseFactor *= P .rgb;
-	alpha         *= P .a;
+   // Get texture color.
 
-	// Ambient intensity
+   #if defined(X3D_EMISSIVE_TEXTURE)
+      vec4 texCoord = getTexCoord (x3d_EmissiveTexture .textureTransformMapping, x3d_EmissiveTexture .textureCoordinateMapping);
 
-	vec3 ambientTerm = diffuseFactor * x3d_Material .ambientIntensity;
+      #if defined(X3D_EMISSIVE_TEXTURE_2D)
+         return emissiveParameter * texture (x3d_EmissiveTexture .texture2D, texCoord .st) .rgb;
+      #elif defined(X3D_EMISSIVE_TEXTURE_3D)
+         return emissiveParameter * texture (x3d_EmissiveTexture .texture3D, texCoord .stp) .rgb;
+      #elif defined(X3D_EMISSIVE_TEXTURE_CUBE)
+         return emissiveParameter * texture (x3d_EmissiveTexture .textureCube, texCoord .stp) .rgb;
+      #endif
+   #else
+      return emissiveParameter;
+   #endif
+}
 
-	// Apply light sources
+float
+getShininessFactor ()
+{
+   // Get shininess parameter.
 
-	vec3 finalColor = vec3 (0.0);
+   float shininess = x3d_Material .shininess;
 
-	for (int i = 0; i < x3d_MaxLights; i ++)
-	{
-		if (i == x3d_NumLights)
-			break;
+   // Get texture color.
 
-		x3d_LightSourceParameters light = x3d_LightSource [i];
+   #if defined(X3D_SHININESS_TEXTURE)
+      vec4 texCoord = getTexCoord (x3d_ShininessTexture .textureTransformMapping, x3d_ShininessTexture .textureCoordinateMapping);
 
-		vec3  vL = light .location - vertex; // Light to fragment
-		float dL = length (light .matrix * vL);
-		bool  di = light .type == x3d_DirectionalLight;
+      #if defined(X3D_SHININESS_TEXTURE_2D)
+         return shininess * texture (x3d_ShininessTexture .texture2D, texCoord .st) .a * 128.0;
+      #elif defined(X3D_SHININESS_TEXTURE_3D)
+         return shininess * texture (x3d_ShininessTexture .texture3D, texCoord .stp) .a * 128.0;
+      #elif defined(X3D_SHININESS_TEXTURE_CUBE)
+         return shininess * texture (x3d_ShininessTexture .textureCube, texCoord .stp) .a * 128.0;
+      #endif
+   #else
+      return shininess * 128.0;
+   #endif
+}
 
-		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
+getOcclusionFactor ()
+{
+   // Get texture color.
+
+   #if defined(X3D_OCCLUSION_TEXTURE)
+      vec4 texCoord = getTexCoord (x3d_OcclusionTexture .textureTransformMapping, x3d_OcclusionTexture .textureCoordinateMapping);
+
+      #if defined(X3D_OCCLUSION_TEXTURE_2D)
+         return texture (x3d_OcclusionTexture .texture2D, texCoord .st) .r;
+      #elif defined(X3D_OCCLUSION_TEXTURE_3D)
+         return texture (x3d_OcclusionTexture .texture3D, texCoord .stp) .r;
+      #elif defined(X3D_OCCLUSION_TEXTURE_CUBE)
+         return texture (x3d_OcclusionTexture .textureCube, texCoord .stp) .r;
+      #endif
+   #else
+      return 1.0;
+   #endif
+}
+
+vec4
+getMaterialColor ()
+{
+   vec3 N = getNormalVector ();
+   vec3 V = normalize (-vertex); // normalized vector from point on geometry to viewer's position
+
+   // Calculate diffuseColor & alpha
 
-			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;
+   vec4  diffuseColorAlpha = getDiffuseColor ();
+   float alpha             = diffuseColorAlpha .a;
+   vec3  diffuseColor      = diffuseColorAlpha .rgb;
+   vec3  ambientColor      = getAmbientColor ();
+   vec3  specularColor     = getSpecularColor ();
+   float shininessFactor   = getShininessFactor ();
 
-			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);
+   // Projective texture
 
-			#ifdef X3D_SHADOWS
-				if (lightAngle > 0.0)
-					diffuseSpecularColor = mix (diffuseSpecularColor, light .shadowColor, getShadowIntensity (i, light));
-			#endif
+   vec4 P = getProjectiveTextureColor (vec4 (1.0));
+
+   diffuseColor *= P .rgb;
+   alpha        *= P .a;
+
+   // 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    = diffuseColor * lightAngle;
+         float specularFactor = shininessFactor > 0.0 ? pow (max (dot (N, H), 0.0), shininessFactor) : 1.0;
+         vec3  specularTerm   = 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  ambientTerm           = light .ambientIntensity * ambientColor;
+         vec3  diffuseSpecularTerm   = light .intensity * (diffuseTerm + specularTerm);
+
+         #ifdef X3D_SHADOWS
+            if (lightAngle > 0.0)
+               diffuseSpecularTerm = mix (diffuseSpecularTerm, light .shadowColor, getShadowIntensity (i, light));
+         #endif
+
+         finalColor += attenuationSpotFactor * light .color * (ambientTerm + diffuseSpecularTerm);
+      }
+   }
 
-			finalColor += attenuationSpotFactor * light .color * (ambientColor + diffuseSpecularColor);
-		}
-	}
+   #ifdef X3D_OCCLUSION_TEXTURE
+	finalColor = mix (finalColor, finalColor * getOcclusionFactor (), x3d_Material .occlusionStrength);
+   #endif
 
-	finalColor += x3d_Material .emissiveColor;
+   finalColor += getEmissiveColor ();
 
-	return vec4 (finalColor, alpha);
+   return vec4 (finalColor, alpha);
 }
 
 // DEBUG
@@ -135,36 +270,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/Phong.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/Point.fs

@@ -0,0 +1,87 @@
+#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/Texture.glsl"
+#pragma X3D include "include/Fog.glsl"
+#pragma X3D include "include/ClipPlanes.glsl"
+
+vec4
+getPointColor ()
+{
+   vec4 texCoord  = vec4 (gl_PointCoord .x, 1.0 - gl_PointCoord .y, 0.0, 1.0);
+
+   texCoord0 = texCoord;
+   texCoord1 = texCoord;
+
+   vec4 finalColor = getTextureColor (color, vec4 (1.0));
+
+   if (x3d_NumTextures == 0)
+   {
+      if (pointSize > 1.0)
+      {
+         float t = max (distance (vec2 (0.5), gl_PointCoord) * pointSize - max (pointSize / 2.0 - 1.0, 0.0), 0.0);
+
+         finalColor .a = mix (finalColor .a, 0.0, t);
+      }
+      else
+      {
+         finalColor .a *= pointSize;
+      }
+   }
+
+   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/Point.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_UnlitMaterialParameters 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 > 1.0 && x3d_NumTextures == 0 ? pointSize + 1.0 : pointSize;
+
+   // 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;
+   }
+}