x_ite 5.0.3 → 6.1.0

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

@@ -24,7 +24,7 @@ main ()
 {
 vec4 position = x3d_ModelViewMatrix * x3d_Vertex;
 vertex = position .xyz;
-normal = normalize (x3d_NormalMatrix * x3d_Normal);
+normal = x3d_NormalMatrix * x3d_Normal;
 texCoord0 = x3d_TexCoord0;
 texCoord1 = x3d_TexCoord1;
 color = x3d_Color;

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

@@ -965,7 +965,7 @@ float lightAngle = max (dot (N, L), 0.0);
 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 attenuationFactor = di ? 1.0 : 1.0 / max (dot (c, vec3 (1.0, dL, 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;

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

@@ -31,7 +31,7 @@ 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 /= dot (pointSizeAttenuation, vec3 (1.0, dL, dL * dL));
 pointSize = clamp (pointSize, pointSizeMinValue, pointSizeMaxValue);
 gl_PointSize = pointSize > 1.0 && x3d_NumTextures == 0 ? pointSize + 1.0 : pointSize;
 float alpha = 1.0 - x3d_Material .transparency;

package/dist/assets/shaders/webgl2/Depth.vs

@@ -1,14 +1,42 @@
 #version 300 es
 precision highp float;
 precision highp int;
+precision highp sampler2D;
 uniform mat4 x3d_ProjectionMatrix;
 uniform mat4 x3d_ModelViewMatrix;
 in vec4 x3d_Vertex;
 out vec3 vertex; 
+in vec4 x3d_Particle;
+in mat4 x3d_ParticleMatrix;
+uniform sampler2D x3d_TexCoordRamp;
+vec4
+texelFetch (const in sampler2D sampler, const in int index, const in int lod)
+{
+int x = textureSize (sampler, lod) .x;
+ivec2 p = ivec2 (index % x, index / x);
+vec4 t = texelFetch (sampler, p, lod);
+return t;
+}
+vec4
+getVertex (const in vec4 vertex)
+{
+if (x3d_Particle [0] == 0.0)
+return vertex;
+return x3d_ParticleMatrix * vertex;
+}
+vec4
+getTexCoord (const in vec4 texCoord)
+{
+int index0 = int (x3d_Particle [3]);
+if (x3d_Particle [0] == 0.0 || index0 == -1)
+return texCoord;
+const int map [6] = int [6] (0, 1, 2, 0, 2, 3);
+return texelFetch (x3d_TexCoordRamp, index0 + map [gl_VertexID % 6], 0);
+}
 void
 main ()
 {
-vec4 position = x3d_ModelViewMatrix * x3d_Vertex;
+vec4 position = x3d_ModelViewMatrix * getVertex (x3d_Vertex);
 vertex = position .xyz;
 gl_Position = x3d_ProjectionMatrix * position;
 }

package/dist/assets/shaders/webgl2/Gouraud.vs

@@ -1,6 +1,7 @@
 #version 300 es
 precision highp float;
 precision highp int;
+precision highp sampler2D;
 uniform mat3 x3d_NormalMatrix;
 uniform mat4 x3d_ProjectionMatrix;
 uniform mat4 x3d_ModelViewMatrix;
@@ -34,6 +35,33 @@ out vec4 texCoord1;
 #ifdef X3D_LOGARITHMIC_DEPTH_BUFFER
 out float depth;
 #endif
+in vec4 x3d_Particle;
+in mat4 x3d_ParticleMatrix;
+uniform sampler2D x3d_TexCoordRamp;
+vec4
+texelFetch (const in sampler2D sampler, const in int index, const in int lod)
+{
+int x = textureSize (sampler, lod) .x;
+ivec2 p = ivec2 (index % x, index / x);
+vec4 t = texelFetch (sampler, p, lod);
+return t;
+}
+vec4
+getVertex (const in vec4 vertex)
+{
+if (x3d_Particle [0] == 0.0)
+return vertex;
+return x3d_ParticleMatrix * vertex;
+}
+vec4
+getTexCoord (const in vec4 texCoord)
+{
+int index0 = int (x3d_Particle [3]);
+if (x3d_Particle [0] == 0.0 || index0 == -1)
+return texCoord;
+const int map [6] = int [6] (0, 1, 2, 0, 2, 3);
+return texelFetch (x3d_TexCoordRamp, index0 + map [gl_VertexID % 6], 0);
+}
 float
 getSpotFactor (const in float cutOffAngle, const in float beamWidth, const in vec3 L, const in vec3 d)
 {
@@ -72,7 +100,7 @@ float lightAngle = max (dot (N, L), 0.0);
 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 attenuationFactor = di ? 1.0 : 1.0 / max (dot (c, vec3 (1.0, dL, 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;
@@ -86,17 +114,17 @@ return vec4 (clamp (finalColor, 0.0, 1.0), alpha);
 void
 main ()
 {
-vec4 position = x3d_ModelViewMatrix * x3d_Vertex;
+vec4 position = x3d_ModelViewMatrix * getVertex (x3d_Vertex);
 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_TexCoord0;
+texCoord0 = getTexCoord (x3d_TexCoord0);
 #endif
 #if x3d_MaxTextures > 1
-texCoord1 = x3d_TexCoord1;
+texCoord1 = getTexCoord (x3d_TexCoord1);
 #endif
 gl_Position = x3d_ProjectionMatrix * position;
 #ifdef X3D_LOGARITHMIC_DEPTH_BUFFER

package/dist/assets/shaders/webgl2/Line.fs

@@ -4,13 +4,12 @@ precision highp int;
 uniform float x3d_AlphaCutoff;
 uniform x3d_LinePropertiesParameters x3d_LineProperties;
 uniform ivec4 x3d_Viewport;
+flat in float lengthSoFar; 
+flat in vec2 startPoint; 
+in vec2 midPoint; 
 in float fogDepth; 
 in vec4 color; 
 in vec3 vertex; 
-#ifdef X_ITE
-in vec3 startPosition; 
-in vec3 vertexPosition; 
-#endif
 #ifdef X3D_LOGARITHMIC_DEPTH_BUFFER
 uniform float x3d_LogarithmicFarFactor1_2;
 in float depth;
@@ -64,27 +63,40 @@ if (dot (vertex, x3d_ClipPlane [i] .xyz) - x3d_ClipPlane [i] .w < 0.0)
 discard;
 }
 }
-#ifdef X_ITE
+struct Line2
+{
+vec2 point;
+vec2 direction;
+};
+Line2
+line2 (const in vec2 point1, const in vec2 point2)
+{
+return Line2 (point1, normalize (point2 - point1));
+}
+vec2
+closest_point (const in Line2 line, const in vec2 point)
+{
+vec2 r = point - line .point;
+float d = dot (r, line .direction);
+return line .direction * d + line .point;
+}
 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 = texture (x3d_LineProperties .linetype, vec2 (distance, distance)) .a;
-if (color == 0.0)
+vec2 point = closest_point (line2 (startPoint, midPoint), gl_FragCoord .xy);
+float s = (lengthSoFar + length (point - startPoint)) * x3d_LineProperties .lineStippleScale;
+float alpha = texture (x3d_LineProperties .linetype, vec2 (s, 0.5)) .a;
+if (alpha != 1.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;

package/dist/assets/shaders/webgl2/Line.vs

@@ -1,36 +1,61 @@
 #version 300 es
 precision highp float;
 precision highp int;
+precision highp sampler2D;
 uniform bool x3d_ColorMaterial; 
 uniform x3d_UnlitMaterialParameters x3d_Material;
 uniform mat4 x3d_ProjectionMatrix;
 uniform mat4 x3d_ModelViewMatrix;
 in float x3d_FogDepth;
+in vec4 x3d_TexCoord0;
 in vec4 x3d_Color;
 in vec4 x3d_Vertex;
+flat out float lengthSoFar; 
+flat out vec2 startPoint; 
+out vec2 midPoint; 
 out float fogDepth; 
 out vec4 color; 
 out vec3 vertex; 
-#ifdef X_ITE
-in vec4 x3d_TexCoord0;
-out vec3 startPosition; 
-out vec3 vertexPosition; 
-#endif
 #ifdef X3D_LOGARITHMIC_DEPTH_BUFFER
 out float depth;
 #endif
+in vec4 x3d_Particle;
+in mat4 x3d_ParticleMatrix;
+uniform sampler2D x3d_TexCoordRamp;
+vec4
+texelFetch (const in sampler2D sampler, const in int index, const in int lod)
+{
+int x = textureSize (sampler, lod) .x;
+ivec2 p = ivec2 (index % x, index / x);
+vec4 t = texelFetch (sampler, p, lod);
+return t;
+}
+vec4
+getVertex (const in vec4 vertex)
+{
+if (x3d_Particle [0] == 0.0)
+return vertex;
+return x3d_ParticleMatrix * vertex;
+}
+vec4
+getTexCoord (const in vec4 texCoord)
+{
+int index0 = int (x3d_Particle [3]);
+if (x3d_Particle [0] == 0.0 || index0 == -1)
+return texCoord;
+const int map [6] = int [6] (0, 1, 2, 0, 2, 3);
+return texelFetch (x3d_TexCoordRamp, index0 + map [gl_VertexID % 6], 0);
+}
 void
 main ()
 {
-vec4 position = x3d_ModelViewMatrix * x3d_Vertex;
+vec4 position = x3d_ModelViewMatrix * getVertex (x3d_Vertex);
+lengthSoFar = x3d_TexCoord0 .z;
+startPoint = x3d_TexCoord0 .xy;
+midPoint = x3d_TexCoord0 .xy;
 fogDepth = x3d_FogDepth;
 vertex = position .xyz;
 gl_Position = x3d_ProjectionMatrix * position;
-#ifdef X_ITE
-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

package/dist/assets/shaders/webgl2/LineTransform.fs

@@ -0,0 +1,4 @@
+#version 300 es
+precision highp float;
+void
+main () { }

package/dist/assets/shaders/webgl2/LineTransform.vs

@@ -0,0 +1,57 @@
+#version 300 es
+precision highp float;
+uniform vec4 viewport;
+uniform mat4 modelViewProjectionMatrix;
+uniform mat4 invModelViewProjectionMatrix;
+uniform float scale;
+in float x3d_FogDepth0; in vec4 x3d_Color0; in vec4 x3d_TexCoord0; in vec4 x3d_Vertex0;
+in float x3d_FogDepth1; in vec4 x3d_Color1; in vec4 x3d_TexCoord1; in vec4 x3d_Vertex1;
+out float fogDepth0; out vec4 color0; out vec4 texCoord0; out vec4 vertex0;
+out float fogDepth1; out vec4 color1; out vec4 texCoord1; out vec4 vertex1;
+out float fogDepth2; out vec4 color2; out vec4 texCoord2; out vec4 vertex2;
+vec3
+projectPoint (const in vec4 point, const in mat4 modelViewProjectionMatrix, const in vec4 viewport)
+{
+vec4 vin = modelViewProjectionMatrix * point;
+vin .xyz = vin .xyz / (2.0 * vin .w) + 0.5;
+return vec3 (vin .xy * viewport .zw + viewport .xy, vin .z);
+}
+vec4
+unProjectPoint (const in vec3 win, const in mat4 invModelViewProjection, const in vec4 viewport)
+{
+vec4 vin = vec4 ((win .xy - viewport .xy) / viewport .zw * 2.0 - 1.0, 2.0 * win .z - 1.0, 1.0);
+vin = invModelViewProjection * vin;
+return vec4 (vin .xyz / vin .w, 1.0);
+}
+void
+main ()
+{
+vec3 projected0 = projectPoint (x3d_Vertex0, modelViewProjectionMatrix, viewport);
+vec3 projected1 = projectPoint (x3d_Vertex1, modelViewProjectionMatrix, viewport);
+vec2 direction = normalize (projected1 .xy - projected0 .xy);
+vec2 offset = vec2 (-direction .y, direction .x) * scale;
+if (gl_InstanceID == 0)
+{
+vec2 pq0 = projected0 .xy + offset;
+vec2 pq1 = projected0 .xy - offset;
+vec2 pq2 = projected1 .xy - offset;
+vec4 p0 = unProjectPoint (vec3 (pq0 .xy, projected0 .z), invModelViewProjectionMatrix, viewport);
+vec4 p1 = unProjectPoint (vec3 (pq1 .xy, projected0 .z), invModelViewProjectionMatrix, viewport);
+vec4 p2 = unProjectPoint (vec3 (pq2 .xy, projected1 .z), invModelViewProjectionMatrix, viewport);
+fogDepth0 = x3d_FogDepth0; color0 = x3d_Color0; texCoord0 = x3d_TexCoord0; vertex0 = p0;
+fogDepth1 = x3d_FogDepth0; color1 = x3d_Color0; texCoord1 = x3d_TexCoord0; vertex1 = p1;
+fogDepth2 = x3d_FogDepth1; color2 = x3d_Color1; texCoord2 = x3d_TexCoord1; vertex2 = p2;
+}
+else
+{
+vec2 pq0 = projected0 .xy + offset;
+vec2 pq2 = projected1 .xy - offset;
+vec2 pq3 = projected1 .xy + offset;
+vec4 p0 = unProjectPoint (vec3 (pq0 .xy, projected0 .z), invModelViewProjectionMatrix, viewport);
+vec4 p2 = unProjectPoint (vec3 (pq2 .xy, projected1 .z), invModelViewProjectionMatrix, viewport);
+vec4 p3 = unProjectPoint (vec3 (pq3 .xy, projected1 .z), invModelViewProjectionMatrix, viewport);
+fogDepth0 = x3d_FogDepth0; color0 = x3d_Color0; texCoord0 = x3d_TexCoord0; vertex0 = p0;
+fogDepth1 = x3d_FogDepth1; color1 = x3d_Color1; texCoord1 = x3d_TexCoord1; vertex1 = p2;
+fogDepth2 = x3d_FogDepth1; color2 = x3d_Color1; texCoord2 = x3d_TexCoord1; vertex2 = p3;
+}
+}

package/dist/assets/shaders/webgl2/PBR.fs

@@ -886,7 +886,7 @@ specularColor
 vec3 F = specularReflection (pbrInputs);
 float G = geometricOcclusion (pbrInputs);
 float D = microfacetDistribution (pbrInputs);
-float attenuationFactor = di ? 1.0 : 1.0 / max (c [0] + c [1] * dL + c [2] * (dL * dL), 1.0);
+float attenuationFactor = di ? 1.0 : 1.0 / max (dot (c, vec3 (1.0, dL, dL * dL)), 1.0);
 float spotFactor = light .type == x3d_SpotLight ? getSpotFactor (light .cutOffAngle, light .beamWidth, L, d) : 1.0;
 float attenuationSpotFactor = attenuationFactor * spotFactor;
 vec3 diffuseContrib = (1.0 - F) * diffuse (pbrInputs);

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

@@ -1,14 +1,15 @@
 #version 300 es
 precision highp float;
 precision highp int;
+precision highp sampler2D;
 uniform mat4 x3d_ProjectionMatrix;
 uniform mat4 x3d_ModelViewMatrix;
 uniform mat3 x3d_NormalMatrix;
-in vec4 x3d_Vertex;
-in vec3 x3d_Normal;
+in vec4 x3d_Color;
 in vec4 x3d_TexCoord0;
 in vec4 x3d_TexCoord1;
-in vec4 x3d_Color;
+in vec3 x3d_Normal;
+in vec4 x3d_Vertex;
 out vec3 vertex;
 out vec3 normal;
 out vec4 texCoord0;
@@ -19,14 +20,41 @@ out vec3 localVertex;
 #ifdef X3D_LOGARITHMIC_DEPTH_BUFFER
 out float depth;
 #endif
+in vec4 x3d_Particle;
+in mat4 x3d_ParticleMatrix;
+uniform sampler2D x3d_TexCoordRamp;
+vec4
+texelFetch (const in sampler2D sampler, const in int index, const in int lod)
+{
+int x = textureSize (sampler, lod) .x;
+ivec2 p = ivec2 (index % x, index / x);
+vec4 t = texelFetch (sampler, p, lod);
+return t;
+}
+vec4
+getVertex (const in vec4 vertex)
+{
+if (x3d_Particle [0] == 0.0)
+return vertex;
+return x3d_ParticleMatrix * vertex;
+}
+vec4
+getTexCoord (const in vec4 texCoord)
+{
+int index0 = int (x3d_Particle [3]);
+if (x3d_Particle [0] == 0.0 || index0 == -1)
+return texCoord;
+const int map [6] = int [6] (0, 1, 2, 0, 2, 3);
+return texelFetch (x3d_TexCoordRamp, index0 + map [gl_VertexID % 6], 0);
+}
 void
 main ()
 {
-vec4 position = x3d_ModelViewMatrix * x3d_Vertex;
+vec4 position = x3d_ModelViewMatrix * getVertex (x3d_Vertex);
 vertex = position .xyz;
-normal = normalize (x3d_NormalMatrix * x3d_Normal);
-texCoord0 = x3d_TexCoord0;
-texCoord1 = x3d_TexCoord1;
+normal = x3d_NormalMatrix * x3d_Normal;
+texCoord0 = getTexCoord (x3d_TexCoord0);
+texCoord1 = getTexCoord (x3d_TexCoord1);
 color = x3d_Color;
 localNormal = x3d_Normal;
 localVertex = x3d_Vertex .xyz;

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

@@ -1130,7 +1130,7 @@ float lightAngle = max (dot (N, L), 0.0);
 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 attenuationFactor = di ? 1.0 : 1.0 / max (dot (c, vec3 (1.0, dL, 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;

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

@@ -1,6 +1,7 @@
 #version 300 es
 precision highp float;
 precision highp int;
+precision highp sampler2D;
 uniform mat3 x3d_NormalMatrix;
 uniform mat4 x3d_ProjectionMatrix;
 uniform mat4 x3d_ModelViewMatrix;
@@ -29,10 +30,37 @@ out vec4 texCoord1;
 #ifdef X3D_LOGARITHMIC_DEPTH_BUFFER
 out float depth;
 #endif
+in vec4 x3d_Particle;
+in mat4 x3d_ParticleMatrix;
+uniform sampler2D x3d_TexCoordRamp;
+vec4
+texelFetch (const in sampler2D sampler, const in int index, const in int lod)
+{
+int x = textureSize (sampler, lod) .x;
+ivec2 p = ivec2 (index % x, index / x);
+vec4 t = texelFetch (sampler, p, lod);
+return t;
+}
+vec4
+getVertex (const in vec4 vertex)
+{
+if (x3d_Particle [0] == 0.0)
+return vertex;
+return x3d_ParticleMatrix * vertex;
+}
+vec4
+getTexCoord (const in vec4 texCoord)
+{
+int index0 = int (x3d_Particle [3]);
+if (x3d_Particle [0] == 0.0 || index0 == -1)
+return texCoord;
+const int map [6] = int [6] (0, 1, 2, 0, 2, 3);
+return texelFetch (x3d_TexCoordRamp, index0 + map [gl_VertexID % 6], 0);
+}
 void
 main ()
 {
-vec4 position = x3d_ModelViewMatrix * x3d_Vertex;
+vec4 position = x3d_ModelViewMatrix * getVertex (x3d_Vertex);
 fogDepth = x3d_FogDepth;
 color = x3d_Color;
 normal = x3d_NormalMatrix * x3d_Normal;
@@ -40,10 +68,10 @@ vertex = position .xyz;
 localNormal = x3d_Normal;
 localVertex = x3d_Vertex .xyz;
 #if x3d_MaxTextures > 0
-texCoord0 = x3d_TexCoord0;
+texCoord0 = getTexCoord (x3d_TexCoord0);
 #endif
 #if x3d_MaxTextures > 1
-texCoord1 = x3d_TexCoord1;
+texCoord1 = getTexCoord (x3d_TexCoord1);
 #endif
 gl_Position = x3d_ProjectionMatrix * position;
 #ifdef X3D_LOGARITHMIC_DEPTH_BUFFER

package/dist/assets/shaders/webgl2/Point.vs

@@ -1,6 +1,7 @@
 #version 300 es
 precision highp float;
 precision highp int;
+precision highp sampler2D;
 uniform x3d_PointPropertiesParameters x3d_PointProperties;
 uniform bool x3d_ColorMaterial; 
 uniform x3d_UnlitMaterialParameters x3d_Material;
@@ -17,10 +18,37 @@ out vec3 vertex;
 #ifdef X3D_LOGARITHMIC_DEPTH_BUFFER
 out float depth;
 #endif
+in vec4 x3d_Particle;
+in mat4 x3d_ParticleMatrix;
+uniform sampler2D x3d_TexCoordRamp;
+vec4
+texelFetch (const in sampler2D sampler, const in int index, const in int lod)
+{
+int x = textureSize (sampler, lod) .x;
+ivec2 p = ivec2 (index % x, index / x);
+vec4 t = texelFetch (sampler, p, lod);
+return t;
+}
+vec4
+getVertex (const in vec4 vertex)
+{
+if (x3d_Particle [0] == 0.0)
+return vertex;
+return x3d_ParticleMatrix * vertex;
+}
+vec4
+getTexCoord (const in vec4 texCoord)
+{
+int index0 = int (x3d_Particle [3]);
+if (x3d_Particle [0] == 0.0 || index0 == -1)
+return texCoord;
+const int map [6] = int [6] (0, 1, 2, 0, 2, 3);
+return texelFetch (x3d_TexCoordRamp, index0 + map [gl_VertexID % 6], 0);
+}
 void
 main ()
 {
-vec4 position = x3d_ModelViewMatrix * x3d_Vertex;
+vec4 position = x3d_ModelViewMatrix * getVertex (x3d_Vertex);
 fogDepth = x3d_FogDepth;
 vertex = position .xyz;
 gl_Position = x3d_ProjectionMatrix * position;
@@ -32,7 +60,7 @@ 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 /= dot (pointSizeAttenuation, vec3 (1.0, dL, dL * dL));
 pointSize = clamp (pointSize, pointSizeMinValue, pointSizeMaxValue);
 gl_PointSize = pointSize > 1.0 && x3d_NumTextures == 0 ? pointSize + 1.0 : pointSize;
 float alpha = 1.0 - x3d_Material .transparency;

package/dist/assets/shaders/webgl2/Unlit.vs

@@ -1,6 +1,7 @@
 #version 300 es
 precision highp float;
 precision highp int;
+precision highp sampler2D;
 uniform mat3 x3d_NormalMatrix;
 uniform mat4 x3d_ProjectionMatrix;
 uniform mat4 x3d_ModelViewMatrix;
@@ -29,10 +30,37 @@ out vec4 texCoord1;
 #ifdef X3D_LOGARITHMIC_DEPTH_BUFFER
 out float depth;
 #endif
+in vec4 x3d_Particle;
+in mat4 x3d_ParticleMatrix;
+uniform sampler2D x3d_TexCoordRamp;
+vec4
+texelFetch (const in sampler2D sampler, const in int index, const in int lod)
+{
+int x = textureSize (sampler, lod) .x;
+ivec2 p = ivec2 (index % x, index / x);
+vec4 t = texelFetch (sampler, p, lod);
+return t;
+}
+vec4
+getVertex (const in vec4 vertex)
+{
+if (x3d_Particle [0] == 0.0)
+return vertex;
+return x3d_ParticleMatrix * vertex;
+}
+vec4
+getTexCoord (const in vec4 texCoord)
+{
+int index0 = int (x3d_Particle [3]);
+if (x3d_Particle [0] == 0.0 || index0 == -1)
+return texCoord;
+const int map [6] = int [6] (0, 1, 2, 0, 2, 3);
+return texelFetch (x3d_TexCoordRamp, index0 + map [gl_VertexID % 6], 0);
+}
 void
 main ()
 {
-vec4 position = x3d_ModelViewMatrix * x3d_Vertex;
+vec4 position = x3d_ModelViewMatrix * getVertex (x3d_Vertex);
 fogDepth = x3d_FogDepth;
 color = x3d_Color;
 normal = x3d_NormalMatrix * x3d_Normal;
@@ -40,10 +68,10 @@ vertex = position .xyz;
 localNormal = x3d_Normal;
 localVertex = x3d_Vertex .xyz;
 #if x3d_MaxTextures > 0
-texCoord0 = x3d_TexCoord0;
+texCoord0 = getTexCoord (x3d_TexCoord0);
 #endif
 #if x3d_MaxTextures > 1
-texCoord1 = x3d_TexCoord1;
+texCoord1 = getTexCoord (x3d_TexCoord1);
 #endif
 gl_Position = x3d_ProjectionMatrix * position;
 #ifdef X3D_LOGARITHMIC_DEPTH_BUFFER

package/dist/example.html

@@ -2,19 +2,19 @@
   <html>
    <head>
     <meta charset="utf-8"/>
-    <link rel="stylesheet" type="text/css" href="https://create3000.github.io/code/x_ite/5.0.3/dist/x_ite.css"/>
-    <script type="text/javascript" src="https://create3000.github.io/code/x_ite/5.0.3/dist/x_ite.min.js"></script>
+    <script type="text/javascript" src="x_ite.min.js"></script>
+    <!-- <script type="text/javascript" src="https://create3000.github.io/code/x_ite/6.1.0/dist/x_ite.min.js"></script> -->
     <style>
-X3DCanvas {
+x3d-canvas {
   width: 1000px;
   height: 563px;
 }
     </style>
   </head>
   <body>
-    <X3DCanvas src="https://cdn.rawgit.com/create3000/Library/main/Examples/X_ITE/info.x3d">
+    <x3d-canvas src="https://create3000.github.io/media/x_ite/info/info.x3d">
       <p>Your browser may not support all features required by X_ITE!</p>
-    </X3DCanvas>
-    <p>If the page is not running <a href="https://github.com/create3000/x_ite/wiki#using-firefox-chrome-and-opera-with-local-files">consider setup a localhost server</a>.</p>
+    </x3d-canvas>
+    <p>If local files are not loaded <a href="https://create3000.github.io/x_ite/#using-firefox-chrome-and-opera-with-local-files">consider setup a localhost server</a>.</p>
   </body>
 </html>