x_ite 4.7.12 → 5.0.0

package/dist/assets/shaders/webgl1/PBR.vs

@@ -0,0 +1,37 @@
+
+precision highp float;
+precision highp int;
+uniform mat4 x3d_ProjectionMatrix;
+uniform mat4 x3d_ModelViewMatrix;
+uniform mat3 x3d_NormalMatrix;
+attribute vec4 x3d_Vertex;
+attribute vec3 x3d_Normal;
+attribute vec4 x3d_TexCoord0;
+attribute vec4 x3d_TexCoord1;
+attribute vec4 x3d_Color;
+varying vec3 vertex;
+varying vec3 normal;
+varying vec4 texCoord0;
+varying vec4 texCoord1;
+varying vec4 color; 
+varying vec3 localNormal; 
+varying vec3 localVertex; 
+#ifdef X3D_LOGARITHMIC_DEPTH_BUFFER
+varying float depth;
+#endif
+void
+main ()
+{
+vec4 position = x3d_ModelViewMatrix * x3d_Vertex;
+vertex = position .xyz;
+normal = normalize (x3d_NormalMatrix * x3d_Normal);
+texCoord0 = x3d_TexCoord0;
+texCoord1 = x3d_TexCoord1;
+color = x3d_Color;
+localNormal = x3d_Normal;
+localVertex = x3d_Vertex .xyz;
+gl_Position = x3d_ProjectionMatrix * position;
+#ifdef X3D_LOGARITHMIC_DEPTH_BUFFER
+depth = 1.0 + gl_Position .w;
+#endif
+}

package/dist/assets/shaders/webgl1/Phong.fs

@@ -1,3 +1,4 @@
+#extension GL_OES_standard_derivatives : enable
 #ifdef X3D_LOGARITHMIC_DEPTH_BUFFER
 #extension GL_EXT_frag_depth : enable
 #endif
@@ -268,18 +269,19 @@ return light .shadowIntensity * value;
 return 0.0;
 }
 #endif
+uniform mat4 x3d_TextureMatrix [x3d_MaxTextures];
 uniform int x3d_NumTextures;
 uniform int x3d_TextureType [x3d_MaxTextures]; 
 uniform sampler2D x3d_Texture2D [x3d_MaxTextures];
-uniform samplerCube x3d_CubeMapTexture [x3d_MaxTextures];
+uniform samplerCube x3d_TextureCube [x3d_MaxTextures];
 #ifdef X3D_MULTI_TEXTURING
-#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)
 {
+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);
@@ -311,6 +313,20 @@ uniform vec3 x3d_ProjectiveTextureLocation [x3d_MaxTextures];
 uniform vec4 x3d_MultiTextureColor;
 uniform x3d_MultiTextureParameters x3d_MultiTexture [x3d_MaxTextures];
 uniform x3d_TextureCoordinateGeneratorParameters x3d_TextureCoordinateGenerator [x3d_MaxTextures];
+mat4
+getTextureMatrix (const in int i)
+{
+mat4 textureMatrix = mat4 (0.0);
+#if x3d_MaxTextures > 0
+if (i == 0)
+textureMatrix = x3d_TextureMatrix [0];
+#endif
+#if x3d_MaxTextures > 1
+else if (i == 1)
+textureMatrix = x3d_TextureMatrix [1];
+#endif
+return textureMatrix;
+}
 vec4
 getTexCoord (const in int i)
 {
@@ -326,12 +342,12 @@ texCoord = texCoord1;
 return texCoord;
 }
 vec4
-getTextureCoordinate (const in x3d_TextureCoordinateGeneratorParameters textureCoordinateGenerator, const in int i)
+getTexCoord (const in x3d_TextureCoordinateGeneratorParameters textureCoordinateGenerator, const in int textureTransformMapping, const in int textureCoordinateMapping)
 {
 int mode = textureCoordinateGenerator .mode;
 if (mode == x3d_None)
 {
-return getTexCoord (i);
+return getTextureMatrix (textureTransformMapping) * getTexCoord (textureCoordinateMapping);
 }
 else if (mode == x3d_Sphere)
 {
@@ -390,7 +406,24 @@ float eta = textureCoordinateGenerator .parameter [0];
 vec3 eye = vec3 (textureCoordinateGenerator .parameter [1], textureCoordinateGenerator .parameter [2], textureCoordinateGenerator .parameter [3]);
 return vec4 (refract (normalize (localVertex - eye), -N, eta), 1.0);
 }
-return getTexCoord (i);
+return getTextureMatrix (textureTransformMapping) * getTexCoord (textureCoordinateMapping);
+}
+vec4
+getTexCoord (const in int textureTransformMapping, const in int textureCoordinateMapping)
+{
+vec4 texCoord;
+#if x3d_MaxTextures > 0
+if (textureCoordinateMapping == 0)
+texCoord = getTexCoord (x3d_TextureCoordinateGenerator [0], textureTransformMapping, textureCoordinateMapping);
+#endif
+#if x3d_MaxTextures > 1
+else if (textureCoordinateMapping == 1)
+texCoord = getTexCoord (x3d_TextureCoordinateGenerator [1], textureTransformMapping, textureCoordinateMapping);
+#endif
+texCoord .stp /= texCoord .q;
+if ((x3d_GeometryType == x3d_Geometry2D) && (gl_FrontFacing == false))
+texCoord .s = 1.0 - texCoord .s;
+return texCoord;
 }
 vec4
 getTexture2D (const in int i, const in vec2 texCoord)
@@ -412,11 +445,11 @@ getTextureCube (const in int i, const in vec3 texCoord)
 vec4 color = vec4 (0.0);
 #if x3d_MaxTextures > 0
 if (i == 0)
-color = textureCube (x3d_CubeMapTexture [0], texCoord);
+color = textureCube (x3d_TextureCube [0], texCoord);
 #endif
 #if x3d_MaxTextures > 1
 else if (i == 1)
-color = textureCube (x3d_CubeMapTexture [1], texCoord);
+color = textureCube (x3d_TextureCube [1], texCoord);
 #endif
 return color;
 }
@@ -428,7 +461,7 @@ for (int i = 0; i < x3d_MaxTextures; ++ i)
 {
 if (i == x3d_NumTextures)
 break;
-vec4 texCoord = getTextureCoordinate (x3d_TextureCoordinateGenerator [i], i);
+vec4 texCoord = getTexCoord (x3d_TextureCoordinateGenerator [i], i, i);
 vec4 textureColor = vec4 (1.0);
 texCoord .stp /= texCoord .q;
 if ((x3d_GeometryType == x3d_Geometry2D) && (gl_FrontFacing == false))
@@ -437,7 +470,7 @@ if (x3d_TextureType [i] == x3d_TextureType2D)
 {
 textureColor = getTexture2D (i, texCoord .st);
 }
-else if (x3d_TextureType [i] == x3d_TextureTypeCubeMapTexture)
+else if (x3d_TextureType [i] == x3d_TextureTypeCube)
 {
 textureColor = getTextureCube (i, texCoord .stp);
 }
@@ -668,14 +701,19 @@ currentColor *= getProjectiveTexture (i, texCoord .st);
 }
 return currentColor;
 }
-#else
+#else 
 vec4
 getProjectiveTextureColor (in vec4 currentColor)
 {
 return currentColor;
 }
-#endif
-#else
+#endif 
+#else 
+vec4
+getTexCoord (const in int textureTransformMapping, const in int textureCoordinateMapping)
+{
+return texCoord0;
+}
 vec4
 getTextureColor (const in vec4 diffuseColor, const in vec4 specularColor)
 {
@@ -688,9 +726,9 @@ if (x3d_TextureType [0] == x3d_TextureType2D)
 {
 textureColor = texture2D (x3d_Texture2D [0], texCoord .st);
 }
-else if (x3d_TextureType [0] == x3d_TextureTypeCubeMapTexture)
+else if (x3d_TextureType [0] == x3d_TextureTypeCube)
 {
-textureColor = textureCube (x3d_CubeMapTexture [0], texCoord .stp);
+textureColor = textureCube (x3d_TextureCube [0], texCoord .stp);
 }
 return diffuseColor * textureColor;
 }
@@ -699,7 +737,42 @@ getProjectiveTextureColor (in vec4 currentColor)
 {
 return currentColor;
 }
+#endif 
+#ifdef X3D_MATERIAL_TEXTURES
+uniform x3d_NormalTextureParameters x3d_NormalTexture;
+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); 
+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;
+#if defined(X3D_NORMAL_TEXTURE) && !defined(X3D_NORMAL_TEXTURE_3D)
+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 = texture2D (x3d_NormalTexture .texture2D, texCoord .st) .rgb;
+#elif defined(X3D_NORMAL_TEXTURE_CUBE)
+vec3 n = textureCube (x3d_NormalTexture .textureCube, texCoord .stp) .rgb;
+#endif
+return normalize (tbn * ((n * 2.0 - 1.0) * normalScale)) * facing;
+#else
+return normalize (normal) * facing;
+#endif
+}
 uniform x3d_FillPropertiesParameters x3d_FillProperties;
 vec4
 getHatchColor (vec4 color)
@@ -761,22 +834,118 @@ else if (spotAngle <= beamWidth)
 return 1.0;
 return (spotAngle - cutOffAngle) / (beamWidth - cutOffAngle);
 }
+#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
+vec3
+getAmbientColor ()
+{
+vec3 ambientParameter = x3d_Material .ambientIntensity * x3d_Material .diffuseColor;
+#if defined(X3D_AMBIENT_TEXTURE) && !defined(X3D_AMBIENT_TEXTURE_3D)
+vec4 texCoord = getTexCoord (x3d_AmbientTexture .textureTransformMapping, x3d_AmbientTexture .textureCoordinateMapping);
+#if defined(X3D_AMBIENT_TEXTURE_2D)
+return ambientParameter * texture2D (x3d_AmbientTexture .texture2D, texCoord .st) .rgb;
+#elif defined(X3D_AMBIENT_TEXTURE_CUBE)
+return ambientParameter * textureCube (x3d_AmbientTexture .textureCube, texCoord .stp) .rgb;
+#endif
+#else
+return ambientParameter;
+#endif
+}
+vec4
+getDiffuseColor ()
+{
+float alpha = 1.0 - x3d_Material .transparency;
+vec4 diffuseParameter = x3d_ColorMaterial ? vec4 (color .rgb, color .a * alpha) : vec4 (x3d_Material .diffuseColor, alpha);
+#if defined(X3D_DIFFUSE_TEXTURE) && !defined(X3D_DIFFUSE_TEXTURE_3D)
+vec4 texCoord = getTexCoord (x3d_DiffuseTexture .textureTransformMapping, x3d_DiffuseTexture .textureCoordinateMapping);
+#if defined(X3D_DIFFUSE_TEXTURE_2D)
+return diffuseParameter * texture2D (x3d_DiffuseTexture .texture2D, texCoord .st) .rgba;
+#elif defined(X3D_DIFFUSE_TEXTURE_CUBE)
+return diffuseParameter * textureCube (x3d_DiffuseTexture .textureCube, texCoord .stp) .rgba;
+#endif
+#else
+return getTextureColor (diffuseParameter, vec4 (x3d_Material .specularColor, alpha));
+#endif
+}
+vec3
+getSpecularColor ()
+{
+vec3 specularParameter = x3d_Material .specularColor;
+#if defined(X3D_SPECULAR_TEXTURE) && !defined(X3D_SPECULAR_TEXTURE_3D)
+vec4 texCoord = getTexCoord (x3d_SpecularTexture .textureTransformMapping, x3d_SpecularTexture .textureCoordinateMapping);
+#if defined(X3D_SPECULAR_TEXTURE_2D)
+return specularParameter * texture2D (x3d_SpecularTexture .texture2D, texCoord .st) .rgb;
+#elif defined(X3D_SPECULAR_TEXTURE_CUBE)
+return specularParameter * textureCube (x3d_SpecularTexture .textureCube, texCoord .stp) .rgb;
+#endif
+#else
+return specularParameter;
+#endif
+}
+vec3
+getEmissiveColor ()
+{
+vec3 emissiveParameter = x3d_Material .emissiveColor;
+#if defined(X3D_EMISSIVE_TEXTURE) && !defined(X3D_EMISSIVE_TEXTURE_3D)
+vec4 texCoord = getTexCoord (x3d_EmissiveTexture .textureTransformMapping, x3d_EmissiveTexture .textureCoordinateMapping);
+#if defined(X3D_EMISSIVE_TEXTURE_2D)
+return emissiveParameter * texture2D (x3d_EmissiveTexture .texture2D, texCoord .st) .rgb;
+#elif defined(X3D_EMISSIVE_TEXTURE_CUBE)
+return emissiveParameter * textureCube (x3d_EmissiveTexture .textureCube, texCoord .stp) .rgb;
+#endif
+#else
+return emissiveParameter;
+#endif
+}
+float
+getShininessFactor ()
+{
+float shininess = x3d_Material .shininess;
+#if defined(X3D_SHININESS_TEXTURE) && !defined(X3D_SHININESS_TEXTURE_3D)
+vec4 texCoord = getTexCoord (x3d_ShininessTexture .textureTransformMapping, x3d_ShininessTexture .textureCoordinateMapping);
+#if defined(X3D_SHININESS_TEXTURE_2D)
+return shininess * texture2D (x3d_ShininessTexture .texture2D, texCoord .st) .a * 128.0;
+#elif defined(X3D_SHININESS_TEXTURE_CUBE)
+return shininess * textureCube (x3d_ShininessTexture .textureCube, texCoord .stp) .a * 128.0;
+#endif
+#else
+return shininess * 128.0;
+#endif
+}
+float
+getOcclusionFactor ()
+{
+#if defined(X3D_OCCLUSION_TEXTURE) && !defined(X3D_OCCLUSION_TEXTURE_3D)
+vec4 texCoord = getTexCoord (x3d_OcclusionTexture .textureTransformMapping, x3d_OcclusionTexture .textureCoordinateMapping);
+#if defined(X3D_OCCLUSION_TEXTURE_2D)
+return texture2D (x3d_OcclusionTexture .texture2D, texCoord .st) .r;
+#elif defined(X3D_OCCLUSION_TEXTURE_CUBE)
+return textureCube (x3d_OcclusionTexture .textureCube, texCoord .stp) .r;
+#endif
+#else
+return 1.0;
+#endif
+}
 vec4
 getMaterialColor ()
 {
-vec3 N = normalize (gl_FrontFacing ? normal : -normal);
+vec3 N = getNormalVector ();
 vec3 V = normalize (-vertex); 
-float dV = length (vertex);
-vec3 diffuseFactor = vec3 (1.0);
-float alpha = 1.0 - x3d_Material .transparency;
-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;
+vec4 diffuseColorAlpha = getDiffuseColor ();
+float alpha = diffuseColorAlpha .a;
+vec3 diffuseColor = diffuseColorAlpha .rgb;
+vec3 ambientColor = getAmbientColor ();
+vec3 specularColor = getSpecularColor ();
+float shininessFactor = getShininessFactor ();
 vec4 P = getProjectiveTextureColor (vec4 (1.0));
-diffuseFactor *= P .rgb;
+diffuseColor *= P .rgb;
 alpha *= P .a;
-vec3 ambientTerm = diffuseFactor * x3d_Material .ambientIntensity;
 vec3 finalColor = vec3 (0.0);
 for (int i = 0; i < x3d_MaxLights; i ++)
 {
@@ -793,22 +962,25 @@ vec3 c = light .attenuation;
 vec3 L = di ? -d : normalize (vL); 
 vec3 H = normalize (L + V); 
 float lightAngle = max (dot (N, L), 0.0); 
-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;
+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 ambientColor = light .ambientIntensity * ambientTerm;
-vec3 diffuseSpecularColor = light .intensity * (diffuseTerm + specularTerm);
+vec3 ambientTerm = light .ambientIntensity * ambientColor;
+vec3 diffuseSpecularTerm = light .intensity * (diffuseTerm + specularTerm);
 #ifdef X3D_SHADOWS
 if (lightAngle > 0.0)
-diffuseSpecularColor = mix (diffuseSpecularColor, light .shadowColor, getShadowIntensity (i, light));
+diffuseSpecularTerm = mix (diffuseSpecularTerm, light .shadowColor, getShadowIntensity (i, light));
 #endif
-finalColor += attenuationSpotFactor * light .color * (ambientColor + diffuseSpecularColor);
+finalColor += attenuationSpotFactor * light .color * (ambientTerm + diffuseSpecularTerm);
 }
 }
-finalColor += x3d_Material .emissiveColor;
+#ifdef X3D_OCCLUSION_TEXTURE
+finalColor = mix (finalColor, finalColor * getOcclusionFactor (), x3d_Material .occlusionStrength);
+#endif
+finalColor += getEmissiveColor ();
 return vec4 (finalColor, alpha);
 }
 void

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

@@ -1,6 +1,5 @@
 precision highp float;
 precision highp int;
-uniform mat4 x3d_TextureMatrix [x3d_MaxTextures];
 uniform mat3 x3d_NormalMatrix;
 uniform mat4 x3d_ProjectionMatrix;
 uniform mat4 x3d_ModelViewMatrix;
@@ -40,10 +39,10 @@ vertex = position .xyz;
 localNormal = x3d_Normal;
 localVertex = x3d_Vertex .xyz;
 #if x3d_MaxTextures > 0
-texCoord0 = x3d_TextureMatrix [0] * x3d_TexCoord0;
+texCoord0 = x3d_TexCoord0;
 #endif
 #if x3d_MaxTextures > 1
-texCoord1 = x3d_TextureMatrix [1] * x3d_TexCoord1;
+texCoord1 = x3d_TexCoord1;
 #endif
 gl_Position = x3d_ProjectionMatrix * position;
 #ifdef X3D_LOGARITHMIC_DEPTH_BUFFER

package/dist/assets/shaders/webgl1/{PointSet.fs → Point.fs}

@@ -57,18 +57,19 @@ if (dot (vertex, x3d_ClipPlane [i] .xyz) - x3d_ClipPlane [i] .w < 0.0)
 discard;
 }
 }
+uniform mat4 x3d_TextureMatrix [x3d_MaxTextures];
 uniform int x3d_NumTextures;
 uniform int x3d_TextureType [x3d_MaxTextures]; 
 uniform sampler2D x3d_Texture2D [x3d_MaxTextures];
-uniform samplerCube x3d_CubeMapTexture [x3d_MaxTextures];
+uniform samplerCube x3d_TextureCube [x3d_MaxTextures];
 #ifdef X3D_MULTI_TEXTURING
-#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)
 {
+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);
@@ -100,6 +101,20 @@ uniform vec3 x3d_ProjectiveTextureLocation [x3d_MaxTextures];
 uniform vec4 x3d_MultiTextureColor;
 uniform x3d_MultiTextureParameters x3d_MultiTexture [x3d_MaxTextures];
 uniform x3d_TextureCoordinateGeneratorParameters x3d_TextureCoordinateGenerator [x3d_MaxTextures];
+mat4
+getTextureMatrix (const in int i)
+{
+mat4 textureMatrix = mat4 (0.0);
+#if x3d_MaxTextures > 0
+if (i == 0)
+textureMatrix = x3d_TextureMatrix [0];
+#endif
+#if x3d_MaxTextures > 1
+else if (i == 1)
+textureMatrix = x3d_TextureMatrix [1];
+#endif
+return textureMatrix;
+}
 vec4
 getTexCoord (const in int i)
 {
@@ -115,12 +130,12 @@ texCoord = texCoord1;
 return texCoord;
 }
 vec4
-getTextureCoordinate (const in x3d_TextureCoordinateGeneratorParameters textureCoordinateGenerator, const in int i)
+getTexCoord (const in x3d_TextureCoordinateGeneratorParameters textureCoordinateGenerator, const in int textureTransformMapping, const in int textureCoordinateMapping)
 {
 int mode = textureCoordinateGenerator .mode;
 if (mode == x3d_None)
 {
-return getTexCoord (i);
+return getTextureMatrix (textureTransformMapping) * getTexCoord (textureCoordinateMapping);
 }
 else if (mode == x3d_Sphere)
 {
@@ -179,7 +194,24 @@ float eta = textureCoordinateGenerator .parameter [0];
 vec3 eye = vec3 (textureCoordinateGenerator .parameter [1], textureCoordinateGenerator .parameter [2], textureCoordinateGenerator .parameter [3]);
 return vec4 (refract (normalize (localVertex - eye), -N, eta), 1.0);
 }
-return getTexCoord (i);
+return getTextureMatrix (textureTransformMapping) * getTexCoord (textureCoordinateMapping);
+}
+vec4
+getTexCoord (const in int textureTransformMapping, const in int textureCoordinateMapping)
+{
+vec4 texCoord;
+#if x3d_MaxTextures > 0
+if (textureCoordinateMapping == 0)
+texCoord = getTexCoord (x3d_TextureCoordinateGenerator [0], textureTransformMapping, textureCoordinateMapping);
+#endif
+#if x3d_MaxTextures > 1
+else if (textureCoordinateMapping == 1)
+texCoord = getTexCoord (x3d_TextureCoordinateGenerator [1], textureTransformMapping, textureCoordinateMapping);
+#endif
+texCoord .stp /= texCoord .q;
+if ((x3d_GeometryType == x3d_Geometry2D) && (gl_FrontFacing == false))
+texCoord .s = 1.0 - texCoord .s;
+return texCoord;
 }
 vec4
 getTexture2D (const in int i, const in vec2 texCoord)
@@ -201,11 +233,11 @@ getTextureCube (const in int i, const in vec3 texCoord)
 vec4 color = vec4 (0.0);
 #if x3d_MaxTextures > 0
 if (i == 0)
-color = textureCube (x3d_CubeMapTexture [0], texCoord);
+color = textureCube (x3d_TextureCube [0], texCoord);
 #endif
 #if x3d_MaxTextures > 1
 else if (i == 1)
-color = textureCube (x3d_CubeMapTexture [1], texCoord);
+color = textureCube (x3d_TextureCube [1], texCoord);
 #endif
 return color;
 }
@@ -217,7 +249,7 @@ for (int i = 0; i < x3d_MaxTextures; ++ i)
 {
 if (i == x3d_NumTextures)
 break;
-vec4 texCoord = getTextureCoordinate (x3d_TextureCoordinateGenerator [i], i);
+vec4 texCoord = getTexCoord (x3d_TextureCoordinateGenerator [i], i, i);
 vec4 textureColor = vec4 (1.0);
 texCoord .stp /= texCoord .q;
 if ((x3d_GeometryType == x3d_Geometry2D) && (gl_FrontFacing == false))
@@ -226,7 +258,7 @@ if (x3d_TextureType [i] == x3d_TextureType2D)
 {
 textureColor = getTexture2D (i, texCoord .st);
 }
-else if (x3d_TextureType [i] == x3d_TextureTypeCubeMapTexture)
+else if (x3d_TextureType [i] == x3d_TextureTypeCube)
 {
 textureColor = getTextureCube (i, texCoord .stp);
 }
@@ -457,14 +489,19 @@ currentColor *= getProjectiveTexture (i, texCoord .st);
 }
 return currentColor;
 }
-#else
+#else 
 vec4
 getProjectiveTextureColor (in vec4 currentColor)
 {
 return currentColor;
 }
-#endif
-#else
+#endif 
+#else 
+vec4
+getTexCoord (const in int textureTransformMapping, const in int textureCoordinateMapping)
+{
+return texCoord0;
+}
 vec4
 getTextureColor (const in vec4 diffuseColor, const in vec4 specularColor)
 {
@@ -477,9 +514,9 @@ if (x3d_TextureType [0] == x3d_TextureType2D)
 {
 textureColor = texture2D (x3d_Texture2D [0], texCoord .st);
 }
-else if (x3d_TextureType [0] == x3d_TextureTypeCubeMapTexture)
+else if (x3d_TextureType [0] == x3d_TextureTypeCube)
 {
-textureColor = textureCube (x3d_CubeMapTexture [0], texCoord .stp);
+textureColor = textureCube (x3d_TextureCube [0], texCoord .stp);
 }
 return diffuseColor * textureColor;
 }
@@ -488,36 +525,25 @@ getProjectiveTextureColor (in vec4 currentColor)
 {
 return currentColor;
 }
-#endif
+#endif 
 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)
+vec4 finalColor = getTextureColor (color, vec4 (1.0));
+if (x3d_NumTextures == 0)
 {
-finalColor .a *= textureColor .a;
-}
-else if (x3d_PointProperties .colorMode == x3d_TextureColor)
+if (pointSize > 1.0)
 {
-finalColor = textureColor;
-}
-else 
-{
-finalColor .rgb += textureColor .rgb;
-finalColor .a *= textureColor .a;
-}
+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
 {
-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));
+finalColor .a *= pointSize;
+}
 }
 return finalColor;
 }

package/dist/assets/shaders/webgl1/{PointSet.vs → Point.vs}

@@ -2,7 +2,7 @@ precision highp float;
 precision highp int;
 uniform x3d_PointPropertiesParameters x3d_PointProperties;
 uniform bool x3d_ColorMaterial; 
-uniform x3d_MaterialParameters x3d_Material;
+uniform x3d_UnlitMaterialParameters x3d_Material;
 uniform int x3d_NumTextures;
 uniform mat4 x3d_ProjectionMatrix;
 uniform mat4 x3d_ModelViewMatrix;
@@ -33,7 +33,7 @@ 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);
+gl_PointSize = pointSize > 1.0 && x3d_NumTextures == 0 ? pointSize + 1.0 : pointSize;
 float alpha = 1.0 - x3d_Material .transparency;
 if (x3d_ColorMaterial)
 {