x_ite 4.2.17 → 4.7.7

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

@@ -0,0 +1,67 @@
+
+precision highp float;
+precision highp int;
+
+uniform mat4 x3d_TextureMatrix [x3d_MaxTextures];
+uniform mat3 x3d_NormalMatrix;
+uniform mat4 x3d_ProjectionMatrix;
+uniform mat4 x3d_ModelViewMatrix;
+
+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  color;       // color
+varying vec3  normal;      // normalized 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
+
+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/webgl1/PointSet.fs

@@ -0,0 +1,100 @@
+
+#ifdef X3D_LOGARITHMIC_DEPTH_BUFFER
+#extension GL_EXT_frag_depth : enable
+#endif
+
+precision highp float;
+precision highp int;
+
+uniform int   x3d_GeometryType;
+uniform float x3d_AlphaCutoff;
+uniform x3d_PointPropertiesParameters x3d_PointProperties;
+
+varying float pointSize; // point size
+varying float fogDepth;  // fog depth
+varying vec4  color;     // color
+varying 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;
+varying float depth;
+#endif
+
+#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));
+
+		if (x3d_PointProperties .colorMode == x3d_PointColor)
+		{
+			finalColor .a *= textureColor .a;
+		}
+		else if (x3d_PointProperties .colorMode == x3d_TextureColor)
+		{
+			finalColor = textureColor;
+		}
+		else // x3d_TextureAndPointColor
+		{
+			finalColor .rgb += textureColor .rgb;
+			finalColor .a   *= textureColor .a;
+		}
+	}
+	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;
+   }
+
+	gl_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/webgl1/PointSet.vs

@@ -0,0 +1,70 @@
+
+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;
+
+attribute float x3d_FogDepth;
+attribute vec4  x3d_Color;
+attribute vec4  x3d_Vertex;
+
+varying float pointSize; // point size
+varying float fogDepth;  // fog depth
+varying vec4  color;     // color
+varying vec3  vertex;    // point on geometry
+
+#ifdef X3D_LOGARITHMIC_DEPTH_BUFFER
+varying 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;
+	}
+}

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

@@ -0,0 +1,86 @@
+
+#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 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/Texture.glsl"
+#pragma X3D include "include/Hatch.glsl"
+#pragma X3D include "include/Fog.glsl"
+#pragma X3D include "include/ClipPlanes.glsl"
+
+vec4
+getMaterialColor ()
+{
+	float alpha = 1.0 - x3d_Material .transparency;
+
+	return getTextureColor (x3d_ColorMaterial ? vec4 (color .rgb, color .a * alpha) : vec4 (x3d_Material .emissiveColor, alpha), vec4 (1.0));
+}
+
+// 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
+}

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

@@ -0,0 +1,67 @@
+
+precision highp float;
+precision highp int;
+
+uniform mat4 x3d_TextureMatrix [x3d_MaxTextures];
+uniform mat3 x3d_NormalMatrix;
+uniform mat4 x3d_ProjectionMatrix;
+uniform mat4 x3d_ModelViewMatrix;
+
+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  color;       // color
+varying vec3  normal;      // normalized 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
+
+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/webgl1/Wireframe.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/Wireframe.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_MaterialParameters 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;
+	}
+}

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

@@ -0,0 +1,16 @@
+
+uniform int  x3d_NumClipPlanes;
+uniform vec4 x3d_ClipPlane [x3d_MaxClipPlanes];
+
+void
+clip ()
+{
+	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;
+	}
+}

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

@@ -0,0 +1,38 @@
+
+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;
+
+	if (x3d_Fog .type == x3d_LinearFog)
+		return (visibilityRange - dV) / visibilityRange;
+
+	if (x3d_Fog .type == x3d_ExponentialFog)
+		return exp (-dV / (visibilityRange - dV));
+
+	return 1.0;
+}
+
+vec3
+getFogColor (const in vec3 color)
+{
+	return mix (x3d_Fog .color, color, getFogInterpolant ());
+}

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

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

package/src/{x_ite/Browser/Shaders/Include/Pack.h → assets/shaders/webgl1/include/Pack.glsl}

@@ -1,4 +1,3 @@
-/* -*- Mode: C++; coding: utf-8; tab-width: 3; indent-tabs-mode: tab; c-basic-offset: 3 -*-*/
 
 #ifdef TITANIA
 

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

@@ -0,0 +1,40 @@
+
+//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)); }
+
+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);
+
+	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);
+
+	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);
+
+	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));
+}