implemented gas planet texture and jupiter material.

also replaced default material on planet creation with jupiter material, only for testing

data/shader/CommonDeferredFrag.glsl

@@ -39,6 +39,8 @@ uniform mat4 uViewProjectionMatrix;
 uniform mat4 uPrevModelMatrix;
 uniform mat4 uPrevViewProjectionMatrix;
 
+uniform vec3 cameraPosition;
+
 out vec4 oColor;
 out vec4 oEmissive;
 out vec3 oNormal;

data/shader/noise/noise2d.glsl

@@ -14,19 +14,19 @@
 //               https://github.com/ashima/webgl-noise
 //
 
-vec3 mod289(vec3 x) {
+vec3 mod289_2d(vec3 x) {
   return x - floor(x * (1.0 / 289.0)) * 289.0;
 }
 
-vec2 mod289(vec2 x) {
+vec2 mod289_2d(vec2 x) {
   return x - floor(x * (1.0 / 289.0)) * 289.0;
 }
 
-vec3 permute(vec3 x) {
-  return mod289(((x*34.0)+1.0)*x);
+vec3 permute_2d(vec3 x) {
+  return mod289_2d(((x*34.0)+1.0)*x);
 }
 
-float snoise(vec2 v)
+float snoise_2d(vec2 v)
   {
   const vec4 C = vec4(0.211324865405187,  // (3.0-sqrt(3.0))/6.0
                       0.366025403784439,  // 0.5*(sqrt(3.0)-1.0)
@@ -48,8 +48,8 @@ float snoise(vec2 v)
   x12.xy -= i1;
 
 // Permutations
-  i = mod289(i); // Avoid truncation effects in permutation
-  vec3 p = permute( permute( i.y + vec3(0.0, i1.y, 1.0 ))
+  i = mod289_2d(i); // Avoid truncation effects in permutation
+  vec3 p = permute_2d( permute_2d( i.y + vec3(0.0, i1.y, 1.0 ))
                 + i.x + vec3(0.0, i1.x, 1.0 ));
 
   vec3 m = max(0.5 - vec3(dot(x0,x0), dot(x12.xy,x12.xy), dot(x12.zw,x12.zw)), 0.0);
@@ -85,7 +85,7 @@ float fbm_2d(vec2 coords, int numberOfOcts, float freq){
         float fValue = 0.0;
         float weight = 0.5;
         for(int i = 0; i < numberOfOcts; i++){
-                fValue += snoise(freq * coords) * weight;
+                fValue += snoise_2d(freq * coords) * weight;
                 weight *= 0.5;
                 freq *= 2.0;
         }

data/shader/noise/noise3d.glsl

@@ -16,24 +16,24 @@
 //               https://github.com/ashima/webgl-noise
 //
 
-vec3 mod289(vec3 x) {
+vec3 mod289_3d(vec3 x) {
   return x - floor(x * (1.0 / 289.0)) * 289.0;
 }
 
-vec4 mod289(vec4 x) {
+vec4 mod289_3d(vec4 x) {
   return x - floor(x * (1.0 / 289.0)) * 289.0;
 }
 
-vec4 permute(vec4 x) {
-     return mod289(((x*34.0)+1.0)*x);
+vec4 permute_3d(vec4 x) {
+     return mod289_3d(((x*34.0)+1.0)*x);
 }
 
-vec4 taylorInvSqrt(vec4 r)
+vec4 taylorInvSqrt_3d(vec4 r)
 {
   return 1.79284291400159 - 0.85373472095314 * r;
 }
 
-float snoise(vec3 v)
+float snoise_3d(vec3 v)
   {
   const vec2  C = vec2(1.0/6.0, 1.0/3.0) ;
   const vec4  D = vec4(0.0, 0.5, 1.0, 2.0);
@@ -57,8 +57,8 @@ float snoise(vec3 v)
   vec3 x3 = x0 - D.yyy;      // -1.0+3.0*C.x = -0.5 = -D.y
 
 // Permutations
-  i = mod289(i);
-  vec4 p = permute( permute( permute(
+  i = mod289_3d(i);
+  vec4 p = permute_3d( permute_3d( permute_3d(
              i.z + vec4(0.0, i1.z, i2.z, 1.0 ))
            + i.y + vec4(0.0, i1.y, i2.y, 1.0 ))
            + i.x + vec4(0.0, i1.x, i2.x, 1.0 ));
@@ -95,7 +95,7 @@ float snoise(vec3 v)
   vec3 p3 = vec3(a1.zw,h.w);
 
 //Normalise gradients
-  vec4 norm = taylorInvSqrt(vec4(dot(p0,p0), dot(p1,p1), dot(p2, p2), dot(p3,p3)));
+  vec4 norm = taylorInvSqrt_3d(vec4(dot(p0,p0), dot(p1,p1), dot(p2, p2), dot(p3,p3)));
   p0 *= norm.x;
   p1 *= norm.y;
   p2 *= norm.z;
@@ -124,7 +124,7 @@ float fbm_3d(vec3 coords, int numberOfOcts, float freq){
         float fValue = 0.0;
         float weight = .5;
         for(int i = 0; i < numberOfOcts; i++){
-                fValue += snoise(freq * coords) * weight;
+                fValue += snoise_3d(freq * coords) * weight;
                 weight *= 0.5;
                 freq *= 2.0;
         }

data/shader/planets/earth_texture.glsl

@@ -3,6 +3,7 @@
 //needed for calculation of modified normal-vector; change until you get a good result for normals:
 #define SAMPLE_ANGLE__NORMAL_VECTOR 0.0005
 
+
 float getHeightNoise(vec3 normalizedPosInModelspace) {
     return (fbm_3d( normalizedPosInModelspace , 4, 80.)/2. + 2*fbm_3d (normalizedPosInModelspace , 2, 1.25));
 }
@@ -14,14 +15,30 @@ float getHeightNoise(vec3 normalizedPosInModelspace) {
 
 #define ROCK_SLOPE .6
 
-vec4 texture_getColor(vec3 texCoord3d, vec3 upVectorNormalized, vec3 normalNormalized){
-    float noiseVal1 = fbm_3d( texCoord3d,4, 128.*128.);// * 0.05;
+vec4 texture_getColor(vec3 texCoord3d, vec3 upVectorNormalized, vec3 normalNormalized, float depth){
+    //float noiseVal1 = fbm_3d( texCoord3d,4, 128.*128.);// * 0.05;
+    float noiseOct1 = 0.;
+    float noiseOct2 = 0.;
+    float noiseOct3 = 0.;
+    float noiseOct4 = 0.;
+    float noiseOct5 = 0.;
+
+    if (depth == 1.) {
+        noiseOct1 = snoise_3d(128.*128. * texCoord3d);
+        noiseOct2 = snoise_3d(2*128.*128. * texCoord3d);
+        noiseOct3 = snoise_3d(4*128.*128. * texCoord3d);
+        noiseOct4 = snoise_3d(8*128.*128. * texCoord3d);
+        noiseOct5 = snoise_3d(16*128.*128. * texCoord3d);
+    }
+
     vec3 distortion = vec3 (.1, .1, .1);
-    float noiseVal2 = fbm_3d( texCoord3d, 4, 8*128.*128.);// * 0.05;
-    float noiseVal3 = fbm_3d( texCoord3d + distortion, 4, 8*128.*128.);// * 0.05;
+    //float noiseVal2 = fbm_3d( texCoord3d, 3, 128.*128.);
+    float noiseVal2 = 1./2.*noiseOct1 + 1./4.*noiseOct2 + 1./8.*noiseOct3;
+    //float noiseVal3 = fbm_3d( texCoord3d + distortion, 4, 8*128.*128.);// * 0.05;
+    float noiseVal3 = 1./2.*noiseOct4 + 1./4.*noiseOct5;
     vec4 color = vec4(1., 1., 1., 1.);
 
-    float height = getHeightNoise(texCoord3d)*.9 + noiseVal2 * .1;
+    float height = getHeightNoise(texCoord3d)*.8 + noiseVal2 * .2;
 
 
     //color = vec4(normalNormalized.x,normalNormalized.y, normalNormalized.z, 1.);
@@ -30,7 +47,7 @@ vec4 texture_getColor(vec3 texCoord3d, vec3 upVectorNormalized, vec3 normalNorma
     float cs = dt / (length(normalNormalized) * length(upVectorNormalized));
     float phi = acos(dt);
     float phiNormalized = 2*phi / M_PI; //scale results from [0, M_PI/2] to [0, 1]
-    float c = noiseVal1*.3 +.3;
+    //float c = noiseVal1*.3 +.3;
 
     float phiPert = .9*phiNormalized + .1 * noiseVal3;
 
@@ -48,6 +65,10 @@ vec4 texture_getColor(vec3 texCoord3d, vec3 upVectorNormalized, vec3 normalNorma
     return color;
 }
 
+vec4 texture_getColor(vec3 texCoord3d, vec3 upVectorNormalized, vec3 normalNormalized){
+    return texture_getColor(texCoord3d, upVectorNormalized, normalNormalized, 1.);
+}
+
 float texture_getFinalHeight(vec3 normalizedPosInModelspace){
     return 0.008 * getHeightNoise(normalizedPosInModelspace);
 }

data/shader/planets/gas_texture.glsl

+#pragma import "../noise/noise3d.glsl"
+#pragma import "../noise/noise2d.glsl"
+
+
+//float getHeightNoise(vec3 normalizedPosInModelspace) {
+//    return (fbm_3d( normalizedPosInModelspace , 4, 80.)/2. + 2*fbm_3d (normalizedPosInModelspace , 2, 1.25));
+//}
+
+
+
+vec4 texture_getColor(vec3 texCoord3d, vec3 upVectorNormalized, vec3 normalNormalized, float depth){
+    float noiseColorRingsR = fbm_2d( vec2(texCoord3d.z, .2),6, 16.);
+    float noiseColorRingsG = fbm_2d( vec2(texCoord3d.z, .5),5, 8.);
+    float pFlowRings = fbm_2d( vec2(texCoord3d.z, .8),6, 2.);
+    float pTime =  (pFlowRings-.5)*2. * uTime*0.05;
+
+    float co= cos(pTime);
+    float si= sin(pTime);
+    mat3 flowRotation = mat3x3(co , -si, 0.,
+                               si, co, 0.,
+                               0., 0., 1.);
+
+    texCoord3d = texCoord3d * flowRotation;
+    float noiseFlow = fbm_3d( vec3(texCoord3d.xy, uTime*.05),6, 2.);
+    return vec4 (noiseFlow * noiseColorRingsR *.7 +.3, noiseFlow * noiseColorRingsG * .8, 0., 1.);
+
+}
+
+//vec4 texture_getColor(vec3 texCoord3d, vec3 upVectorNormalized, vec3 normalNormalized, float depth){
+//    //float noiseVal1 = fbm_3d( texCoord3d,4, 128.*128.);// * 0.05;
+//    float noiseOct1 = 0.;
+//    float noiseOct2 = 0.;
+//    float noiseOct3 = 0.;
+//    float noiseOct4 = 0.;
+//    float noiseOct5 = 0.;
+
+//    if (depth == 1.) {
+//        noiseOct1 = snoise_3d(128.*128. * texCoord3d);
+//        noiseOct2 = snoise_3d(2*128.*128. * texCoord3d);
+//        noiseOct3 = snoise_3d(4*128.*128. * texCoord3d);
+//        noiseOct4 = snoise_3d(8*128.*128. * texCoord3d);
+//        noiseOct5 = snoise_3d(16*128.*128. * texCoord3d);
+//    }
+
+//    vec3 distortion = vec3 (.1, .1, .1);
+//    //float noiseVal2 = fbm_3d( texCoord3d, 3, 128.*128.);
+//    float noiseVal2 = 1./2.*noiseOct1 + 1./4.*noiseOct2 + 1./8.*noiseOct3;
+//    //float noiseVal3 = fbm_3d( texCoord3d + distortion, 4, 8*128.*128.);// * 0.05;
+//    float noiseVal3 = 1./2.*noiseOct4 + 1./4.*noiseOct5;
+//    vec4 color = vec4(1., 1., 1., 1.);
+
+//    float height = getHeightNoise(texCoord3d)*.8 + noiseVal2 * .2;
+
+
+//    //color = vec4(normalNormalized.x,normalNormalized.y, normalNormalized.z, 1.);
+//    //color = vec4(upVectorNormalized.x,upVectorNormalized.y, upVectorNormalized.z, 1.);
+//    float dt = dot(normalNormalized, upVectorNormalized);
+//    float cs = dt / (length(normalNormalized) * length(upVectorNormalized));
+//    float phi = acos(dt);
+//    float phiNormalized = 2*phi / M_PI; //scale results from [0, M_PI/2] to [0, 1]
+//    //float c = noiseVal1*.3 +.3;
+
+//    float phiPert = .9*phiNormalized + .1 * noiseVal3;
+
+
+//    if (height> SNOW_LEVEL && phiPert <= ROCK_SLOPE) {
+//        color = vec4(1., 1., 1., 1.);
+//    } else if (height> ROCK_LEVEL || phiPert > ROCK_SLOPE) {
+//        color = vec4(.1, .1, .1, 1.);
+
+//    } else if (height> PLANT_LEVEL) {
+//        color = vec4(.2, .5,.15, 1.);
+//    }else { //"sand""
+//        color = vec4(1., .8, .55, 1.);
+//    }
+//    return color;
+//}
+
+vec4 texture_getColor(vec3 texCoord3d, vec3 upVectorNormalized, vec3 normalNormalized){
+    return texture_getColor(texCoord3d, upVectorNormalized, normalNormalized, 1.);
+}
+
+//float texture_getFinalHeight(vec3 normalizedPosInModelspace){
+//    return 0.008 * 1.;
+//}
+
+
+//vec3 texture_getDisplacedPosition_modelspace(vec3 normalizedPosInModelspace, vec3 normalizedNormal) {
+//    vec3 newPosition = normalizedPosInModelspace + normalizedNormal * texture_getFinalHeight(normalizedPosInModelspace);
+//    return newPosition;
+//}
+
+

data/shader/planets/jupiter.fsh

+#version 410 core
+
+#define LAST_SHADER GEOMETRY
+
+#pragma import "../CommonDeferredFrag.glsl"
+
+#pragma import "gas_texture.glsl"
+
+#pragma import "../terrain/plainSphere_fsh.glsl"

data/shader/planets/jupiter.gsh

+#pragma import "../terrain/plainSphere_gsh.glsl"

data/shader/planets/jupiter.tcsh

+#pragma import "../terrain/plainSphere_tcsh.glsl"

data/shader/planets/jupiter.tesh

+
+#pragma import "../terrain/plainSphere_tesh.glsl"

data/shader/planets/jupiter.vsh

+#pragma import "../terrain/plainSphere_vsh.glsl"

data/shader/planets/moon_texture.glsl

@@ -7,10 +7,14 @@ float getHeight(vec3 normalizedPosInModelspace) {
     return (fbm_3d( normalizedPosInModelspace , 4, 80.)/2. + 2*fbm_3d (normalizedPosInModelspace , 2, 1.25));
 }
 
-vec4 texture_getColor(vec3 texCoord3d, vec3 upVectorNormalized, vec3 normalNormalized){
+vec4 texture_getColor(vec3 texCoord3d, vec3 upVectorNormalized, vec3 normalNormalized, float depth){
     return vec4(.1, .1, .1, .1);
 }
 
+vec4 texture_getColor(vec3 texCoord3d, vec3 upVectorNormalized, vec3 normalNormalized){
+    return texture_getColor(texCoord3d, upVectorNormalized, normalNormalized, 1.);
+}
+
 vec3 texture_getDisplacedPosition_modelspace(vec3 normalizedPosInModelspace, vec3 normalizedNormal) {
     float noiseValue = getHeight(normalizedPosInModelspace);
     vec3 newPosition = normalizedPosInModelspace + normalizedNormal * 0.008 * noiseValue;

data/shader/terrain/dispMapping_fsh.glsl

@@ -23,7 +23,7 @@ vec4 color() {
   approxNormal = approximateTerrainNormal(normalize(gPosInModelspace));
   //approxNormal = inNormal;
 
-  vec4 color = texture_getColor(gPosInModelspace, gNormal, approxNormal);
+  vec4 color = texture_getColor(gPosInModelspace, gNormal, approxNormal, length(cameraPosition - inPosition));
 
   /*float d1 = min(min(gTriDistance.x, gTriDistance.y), gTriDistance.z);
   float d2 = min(min(gPatchDistance.x, gPatchDistance.y), gPatchDistance.z);

data/shader/terrain/gasPlanet_fsh.glsl

+
+in vec3 vPosInModelspace;
+
+vec3 approxNormal;
+
+void initShader(){
+    approxNormal = inNormal;
+};
+
+vec4 color() {
+
+  vec4 color = texture_getColor(vPosInModelspace, approxNormal, approxNormal, length(cameraPosition - inPosition));
+
+  color.a = 1.0;
+
+  return vec4(1.,0.,0.,1.);
+  return color;
+}
+
+vec4 emissive() {
+  return uEmissiveColor;
+}
+
+vec3 normal() {
+  return approxNormal;
+}
+
+vec4 specularSmoothness() {
+    return vec4(0.2, 0.2, 0.2, 0.1);
+}

data/shader/terrain/gasPlanet_vsh.glsl

+#pragma import "../CommonDeferredVert.glsl"
+
+out vec3 vPosInModelspace;
+
+vec3 normal() {
+  return aPosition;
+}
+
+vec2 texCoord() {
+  return aTexCoord;
+}
+
+vec3 position() {
+    vPosInModelspace = aPosition;
+
+    vec4 modelPos = vec4(aPosition, 1.0);
+    vec4 worldPosition = uModelMatrix * modelPos;
+    return worldPosition.xyz;
+}

data/shader/terrain/plainSphere_fsh.glsl

+#define LAST_SHADER GEOMETRY
+
+in vec3 gPosInModelspace;
+
+void initShader(){};
+
+
+vec4 color() {
+
+  vec4 color = texture_getColor(gPosInModelspace, inNormal, inNormal, length(cameraPosition - inPosition));
+  color.a = 1.0;
+  return color;
+}
+
+vec4 emissive() {
+  return uEmissiveColor;
+}
+
+vec3 normal() {
+  return inNormal;
+}
+
+vec4 specularSmoothness() {
+    return vec4(0.2, 0.2, 0.2, 0.1);
+}

data/shader/terrain/plainSphere_gsh.glsl

+#version 410 core
+
+layout(triangles) in;
+layout(triangle_strip, max_vertices = 3) out;
+
+in vec3 tPosition[3];
+in vec3 tPatchDistance[3];
+
+in vec3 tNormal[3];
+in vec2 tTexCoord[3];
+
+//in float tHeight[3];
+//in vec3 tUpVector_normalized[3];
+in vec3 tPosInModelspace[3];
+
+out vec3 gNormal;
+out vec3 gPosition;
+out vec2 gTexCoord;
+
+//out float gHeight;
+//out float gSurfaceAngle;
+//out vec3 gUpVector_normalized;
+out vec3 gPosInModelspace;
+
+out vec3 gPatchDistance;
+out vec3 gTriDistance;
+
+void main()
+{
+    //vec3 A = tPosition[2] - tPosition[0];
+    //vec3 B = tPosition[1] - tPosition[0];
+    //gNormal = -normalize(cross(A, B));
+
+    gPatchDistance = tPatchDistance[0];
+    
+    gTexCoord = tTexCoord[0];
+    gPosition = tPosition[0];
+
+    //gHeight = tHeight[0];
+    //gSurfaceAngle = acos(dot(gNormal, tUpVector[0]));
+    //gUpVector_normalized = tUpVector_normalized[0];
+    gPosInModelspace = tPosInModelspace[0];
+    
+    gNormal = tNormal[0];
+    gTriDistance = vec3(1, 0, 0);
+    gl_Position = gl_in[0].gl_Position; EmitVertex();
+
+    gTexCoord = tTexCoord[1];
+    gPosition = tPosition[1];
+
+    //gHeight = tHeight[1];
+    //gSurfaceAngle = acos(dot(gNormal, tUpVector[1]));
+    //gUpVector_normalized = tUpVector_normalized[1];
+    gPosInModelspace = tPosInModelspace[1];
+    
+    gNormal = tNormal[1];
+    gPatchDistance = tPatchDistance[1];
+    gTriDistance = vec3(0, 1, 0);
+    gl_Position = gl_in[1].gl_Position; EmitVertex();
+
+    gTexCoord = tTexCoord[2];
+    gPosition = tPosition[2];
+
+    //gHeight = tHeight[2];
+    //gSurfaceAngle = acos(dot(gNormal, tUpVector[2]));
+    //gUpVector_normalized = tUpVector_normalized[2];
+    gPosInModelspace = tPosInModelspace[2];
+    
+    gNormal = tNormal[2];
+    gPatchDistance = tPatchDistance[2];
+    gTriDistance = vec3(0, 0, 1);
+    gl_Position = gl_in[2].gl_Position; EmitVertex();
+
+    EndPrimitive();
+}

data/shader/terrain/plainSphere_tcsh.glsl

+#version 410 core
+
+layout(vertices = 3) out;
+
+in vec3 vNormal[];
+in vec3 vPosition[];
+in vec2 vTexCoord[];
+
+out vec3 tcNormal[];
+out vec2 tcTexCoord[];
+out vec3 tcPosition[];
+
+uniform mat4 uModelMatrix;
+
+uniform vec3 cameraPosition;
+
+#define ID gl_InvocationID
+
+
+float getTessLevel(float d0, float d1){
+
+    float avg = (d0 + d1) / 2.0;
+    if(avg >= 100){
+                return 1;
+        }
+        if(avg >= 80){
+                return 2;
+        }
+        if(avg >= 60){
+                return 4;
+        }
+        if(avg >= 40){
+                return 8;
+        }
+        if(avg >= 20){
+                return 16;
+        }
+        if(avg >= 10){
+                return 32;
+        }
+        if(avg >= 0){
+                return 64;
+        }
+        else return 1;
+}
+
+
+void main(){
+
+        tcNormal[ID] = vNormal[ID];
+        tcTexCoord[ID] = vTexCoord[ID];
+        tcPosition[ID] = vPosition[ID];
+
+        if (ID == 0) {
+
+
+
+                float d0 = distance(cameraPosition, (uModelMatrix * vec4(tcPosition[0], 1)).xyz );
+            float d1 = distance(cameraPosition, (uModelMatrix * vec4(tcPosition[1], 1)).xyz );
+            float d2 = distance(cameraPosition, (uModelMatrix * vec4(tcPosition[2], 1)).xyz );
+
+            gl_TessLevelOuter[0] = getTessLevel(d1, d2);
+            gl_TessLevelOuter[1] = getTessLevel(d2, d0);
+            gl_TessLevelOuter[2] = getTessLevel(d0, d1);
+            gl_TessLevelInner[0] = 0.5 * gl_TessLevelOuter[2];
+
+            /*
+
+            float avgDist = (d0 + d1 + d2)/3.0;
+
+            vec3 midPoint;
+            float fDistance;
+
+            midPoint = (tcPosition[2] + tcPosition[0] / 2.0);
+            fDistance = distance(midPoint, cameraPosition) * 1;
+            gl_TessLevelOuter[0] = getTessLevel(fDistance, fDistance);
+
+
+                midPoint = (tcPosition[2] + tcPosition[0] / 2.0);
+            fDistance = distance(midPoint, cameraPosition) * 1;
+            gl_TessLevelOuter[1] = getTessLevel(fDistance, fDistance);
+
+
+            midPoint = (tcPosition[2] + tcPosition[0] / 2.0);
+            fDistance = distance(midPoint, cameraPosition) * 1;
+            gl_TessLevelOuter[2] = getTessLevel(fDistance, fDistance);
+
+            gl_TessLevelInner[0] = (gl_TessLevelOuter[0] + gl_TessLevelOuter[1] +gl_TessLevelOuter[2]) /3;
+            */
+        }
+}

data/shader/terrain/plainSphere_tesh.glsl

+#version 410 core
+
+//#pragma import "noise/noise3d.glsl"
+//#pragma import "terrain/sphereUV.glsl"
+//#pragma import "../terrain/mountainTexture.glsl"
+
+layout(triangles, equal_spacing, ccw) in;
+
+in vec2 tcTexCoord[];
+in vec3 tcNormal[];
+in vec3 tcPosition[];
+
+out vec3 tNormal;
+out vec2 tTexCoord;
+out vec3 tPosition;
+
+//out float tHeight;
+//out vec3 tUpVector_normalized;
+out vec3 tPosInModelspace;
+
+out vec3 tPatchDistance;
+
+uniform mat4 uViewProjectionMatrix;
+uniform mat4 uModelMatrix;
+uniform vec3 cameraPostion;
+
+//vec3 mod289(vec3 x)
+//{
+//  return x - floor(x * (1.0 / 289.0)) * 289.0;
+//}
+
+//vec4 mod289(vec4 x)
+//{
+//  return x - floor(x * (1.0 / 289.0)) * 289.0;
+//}
+