lavavu-osmesa 1.8.43__cp311-cp311-manylinux_2_24_x86_64.whl

lavavu/shaders/pointShader.frag

@@ -0,0 +1,132 @@
+uniform int uPointType;
+uniform float uOpacity;
+uniform float uBrightness;
+uniform float uContrast;
+uniform float uSaturation;
+uniform float uAmbient;
+uniform float uDiffuse;
+uniform float uSpecular;
+uniform bool uOpaque;
+uniform bool uTextured;
+uniform sampler2D uTexture;
+uniform vec3 uClipMin;
+uniform vec3 uClipMax;
+uniform vec3 uLightPos;
+
+in vec4 vColour;
+in vec3 vVertex;
+in vec2 vTexCoord;
+in float vPointSize;
+in vec3 vPosEye;
+in float vPointType;
+
+#ifdef WEBGL
+#define outColour gl_FragColor
+#define texture(a,b) texture2D(a,b)
+#else
+out vec4 outColour;
+#endif
+
+void calcColour(vec3 colour, float alpha)
+{
+  //Brightness adjust
+  colour += uBrightness;
+  //Saturation & Contrast adjust
+  const vec3 LumCoeff = vec3(0.2125, 0.7154, 0.0721);
+  vec3 AvgLumin = vec3(0.5, 0.5, 0.5);
+  vec3 intensity = vec3(dot(colour, LumCoeff));
+  colour = mix(intensity, colour, uSaturation);
+  colour = mix(AvgLumin, colour, uContrast);
+
+  if (uOpaque)
+    alpha = 1.0;
+
+  outColour = vec4(colour, alpha);
+}
+
+void main(void)
+{
+  //Clip planes in X/Y/Z
+  if (any(lessThan(vVertex, uClipMin)) || any(greaterThan(vVertex, uClipMax))) discard;
+
+  float alpha = vColour.a;
+  if (uOpacity > 0.0) alpha *= uOpacity;
+  outColour = vColour;
+
+  int pointType = uPointType;
+  if (vPointType >= 0.0) pointType = int(floor(vPointType + 0.5)); //Round back to nearest int
+
+  //Textured?
+  if (uTextured && vTexCoord.y >= 0.0)
+  {
+    vec4 tColour;
+    if (vTexCoord.x < 0.0)
+      tColour = texture(uTexture, gl_PointCoord); //Point sprite mode
+    else
+      tColour = texture(uTexture, vTexCoord);
+
+    //Blend with colour
+    outColour = mix(tColour, outColour, 1.0-tColour.a);
+    alpha = outColour.a;
+  }
+
+  //Flat, square points, fastest, skip lighting
+  if (pointType == 4)
+  {
+    calcColour(outColour.rgb, alpha);
+    return;
+  }
+
+  //Circular points...
+  //Calculate normal from point/tex coordinates
+  vec3 N;
+  N.xy = gl_PointCoord * 2.0 - vec2(1.0);
+  float R = dot(N.xy, N.xy);
+  //Discard if outside circle
+  if (R > 1.0) discard;
+  //Anti-aliased edges for sphere types
+  if (pointType > 1)
+  {
+    float edge = vPointSize - R * vPointSize;
+    if (edge <= 4.0)
+      alpha *= (0.25 * edge);
+  }
+
+  //Discard if transparent (outside circle)
+  if (alpha < 0.01) discard;
+
+  if (pointType < 2)
+  {
+    //Circular with no light/shading, just blur
+    if (pointType == 0)
+      alpha *= 1.0-sqrt(R); //Gaussian
+    else //TODO: allow disable blur for circular points
+      alpha *= 1.0-R;       //Linear
+
+    calcColour(outColour.rgb, alpha);
+    return;
+  }
+
+  //Calculate diffuse lighting component
+  N.z = sqrt(1.0-R);
+  float diffuse = 1.0;
+  vec3 lightDir = normalize(uLightPos - vPosEye);
+  diffuse = max(0.0, dot(lightDir, N));
+
+  //Calculate specular lighting component
+  if (pointType == 3 && diffuse > 0.0)
+  {
+    vec3 specular = vec3(0.0,0.0,0.0);
+    float shininess = 200.0; //Size of highlight
+    vec3 specolour = vec3(1.0, 1.0, 1.0);   //Color of light
+    //Normalize the half-vector
+    //vec3 halfVector = normalize(vPosEye + lightDir);
+    vec3 halfVector = normalize(vec3(0.0, 0.0, 1.0) + lightDir);
+    //Compute cosine (dot product) with the normal
+    float NdotHV = max(dot(N, halfVector), 0.0);
+    specular = specolour * pow(NdotHV, shininess);
+    calcColour(outColour.rgb * diffuse + specular, alpha);
+  }
+  else
+    calcColour(outColour.rgb * diffuse, alpha);
+}

lavavu/shaders/pointShader.vert

@@ -0,0 +1,57 @@
+in vec3 aVertexPosition;
+in vec4 aVertexColour;
+in vec2 aVertexTexCoord;
+
+uniform mat4 uMVMatrix;
+uniform mat4 uPMatrix;
+
+out vec4 vColour;
+
+#ifdef WEBGL
+const int uPointDist = 1;   // Scale by distance
+#else
+uniform int uPointDist;   // Scale by distance
+#endif
+
+in float aSize;
+in float aPointType;
+
+uniform float uPointScale;   // scale to calculate size in pixels
+
+uniform vec4 uColour;
+uniform float uOpacity;
+
+out vec3 vVertex;
+out vec2 vTexCoord;
+out float vPointSize;
+out vec3 vPosEye;
+out float vPointType;
+
+void main(void)
+{
+  float pSize = abs(aSize);
+
+  // calculate window-space point size
+  vec4 mvPosition = uMVMatrix * vec4(aVertexPosition, 1.0);
+  vec3 posEye = mvPosition.xyz;
+  float dist = 1.0;
+  if (uPointDist > 0)
+     dist = length(posEye);
+  //Limit scaling, overly large points are very slow to render
+  //gl_PointSize = max(1.0, min(40.0, uPointScale * pSize / dist));
+
+  gl_PointSize = uPointScale * pSize / dist;
+  gl_Position = uPMatrix * mvPosition;
+
+  vPosEye = posEye;
+  vPointType = aPointType;
+  vPointSize = gl_PointSize;
+  vVertex = aVertexPosition.xyz;
+  vTexCoord = aVertexTexCoord;
+
+  if (uColour.a > 0.0)
+    vColour = uColour;
+  else
+    vColour = vec4(aVertexColour.rgb, aVertexColour.a);
+}
+

lavavu/shaders/triShader.frag

@@ -0,0 +1,170 @@
+in vec4 vColour;
+in vec3 vNormal;
+in vec3 vPosEye;
+in vec3 vVertex;
+in vec2 vTexCoord;
+in vec3 vLightPos;
+
+uniform float uOpacity;
+uniform bool uLighting;
+uniform float uBrightness;
+uniform float uContrast;
+uniform float uSaturation;
+uniform float uAmbient;
+uniform float uDiffuse;
+uniform float uSpecular;
+uniform float uShininess;
+
+uniform bool uTextured;
+uniform sampler2D uTexture;
+uniform vec3 uClipMin;
+uniform vec3 uClipMax;
+uniform bool uOpaque;
+uniform vec4 uLight;
+
+#ifdef WEBGL
+#define outColour gl_FragColor
+#define texture(a,b) texture2D(a,b)
+
+//Before OpenGL 3+ we need our own isnan function
+bool isnan3(vec3 val)
+{
+  if (!(val.x < 0.0 || 0.0 < val.x || val.x == 0.0)) return true;
+  if (!(val.y < 0.0 || 0.0 < val.y || val.y == 0.0)) return true;
+  if (!(val.z < 0.0 || 0.0 < val.z || val.z == 0.0)) return true;
+  return false;
+}
+
+#else
+#define isnan3(v) any(isnan(v))
+flat in vec4 vFlatColour;
+uniform bool uFlat;
+out vec4 outColour;
+#endif
+
+uniform bool uCalcNormal;
+
+void calcColour(vec3 colour, float alpha)
+{
+  //Brightness adjust
+  colour += uBrightness;
+  //Saturation & Contrast adjust
+  const vec3 LumCoeff = vec3(0.2125, 0.7154, 0.0721);
+  vec3 AvgLumin = vec3(0.5, 0.5, 0.5);
+  vec3 intensity = vec3(dot(colour, LumCoeff));
+  colour = mix(intensity, colour, uSaturation);
+  colour = mix(AvgLumin, colour, uContrast);
+
+  //Gamma correction
+  //https://en.wikipedia.org/wiki/Blinn%E2%80%93Phong_reflection_model#OpenGL_Shading_Language_code_sample
+  //const float screenGamma = 2.2; // Assume the monitor is calibrated to the sRGB color space
+  //vec3 colorGammaCorrected = pow(color, vec3(1.0 / screenGamma));
+
+  outColour = vec4(colour, alpha);
+}
+
+void main(void)
+{
+  //Clip planes in X/Y/Z
+  if (any(lessThan(vVertex, uClipMin)) || any(greaterThan(vVertex, uClipMax))) discard;
+
+  vec4 fColour = vColour;
+#ifndef WEBGL
+  if (uFlat)
+    fColour = vFlatColour;
+#endif
+  float alpha = fColour.a;
+  if (uTextured && vTexCoord.x > -1.0) //Null texcoord (-1,-1)
+  {
+    //With this blending mode, texture is blended over base colour,
+    //and colour opacity has no effect on texture opacity
+    //All desired texture opacity must be built in to the texture data
+    //(Could add another blend mode if we want a dynamic texture opacity)
+    vec4 tColour = texture(uTexture, vTexCoord);
+    if (fColour.a > 0.01)
+    {
+      //Additive blend alpha channel
+      alpha = fColour.a + tColour.a * (1.0 - fColour.a);
+
+      //Blend the texure colour with the fragment colour using texture alpha
+      fColour.rgb = vec3(mix(fColour.rgb, tColour.rgb, tColour.a));
+    }
+    else
+    {
+      //Disable all blending if the base colour opacity <= 0.01
+      fColour = tColour;
+      alpha = tColour.a;
+    }
+  }
+
+  if (uOpacity > 0.0) alpha *= uOpacity;
+  if (uOpaque) alpha = 1.0;
+  if (alpha < 0.01) discard;
+
+  if (!uLighting) 
+  {
+    calcColour(fColour.rgb, alpha);
+    return;
+  }
+
+  vec3 lightColour = uLight.xyz;
+  
+  //Light direction
+  vec3 lightDir = normalize(vLightPos - vPosEye);
+
+  //Calculate diffuse lighting
+  vec3 N = normalize(vNormal);
+
+  //Default normal...
+  if (uCalcNormal || dot(N,N) < 0.01 || isnan3(N))
+  {
+    //Requires extension in WebGL: OES_standard_derivatives
+    vec3 fdx = vec3(dFdx(vPosEye.x),dFdx(vPosEye.y),dFdx(vPosEye.z));    
+    vec3 fdy = vec3(dFdy(vPosEye.x),dFdy(vPosEye.y),dFdy(vPosEye.z));
+    N = normalize(cross(fdx,fdy)); 
+  }
+
+  //Modified to use energy conservation adjustment
+  //https://learnopengl.com/Advanced-Lighting/Advanced-Lighting
+  const float kPi8 = 3.14159265 * 8.0;
+
+  //Calculate diffuse component
+  //Single side or two-sided lighting with abs()?
+  float diffuse = dot(N, lightDir);
+  if (uLight.w < 0.5)
+    diffuse = abs(diffuse);
+  else
+    diffuse = max(diffuse, 0.0);
+
+  //Compute the specular term
+  if (diffuse > 0.0 && uSpecular > 0.0)
+  {
+    //Specular power, higher is more focused/shiny
+    float shininess = 256.0 * clamp(uShininess, 0.0, 1.0);
+    vec3 specolour = lightColour; //Color of light - use the same as diffuse/ambient
+    //Blinn-Phong
+    vec3 viewDir = normalize(-vPosEye);
+    //Normalize the half-vector
+    vec3 halfVector = normalize(lightDir + viewDir);
+
+    //Compute cosine (dot product) with the normal
+    float NdotHV = dot(N, halfVector);
+    //Single side or two-sided lighting with abs()?
+    if (uLight.w < 0.5)
+      NdotHV = abs(NdotHV);
+    else
+      NdotHV = max(NdotHV, 0.0);
+
+    //Energy conservation adjustment (more focused/shiny highlight will be brighter)
+    float energyConservation = ( 8.0 + shininess) / kPi8;
+    //Multiplying specular by diffuse prevents bands at edges for low shininess
+    float spec = diffuse * uSpecular * energyConservation * pow(NdotHV, shininess);
+
+    //Final colour - specular + diffuse + ambient
+    calcColour(lightColour * (fColour.rgb * (uAmbient + uDiffuse * diffuse) + vec3(spec)), alpha);
+  }
+  else
+    //Final colour - diffuse + ambient only
+    calcColour(lightColour * fColour.rgb * (uAmbient + diffuse * uDiffuse), alpha);
+}
+

lavavu/shaders/triShader.vert

@@ -0,0 +1,55 @@
+in vec3 aVertexPosition;
+in vec3 aVertexNormal;
+in vec4 aVertexColour;
+in vec2 aVertexTexCoord;
+#ifndef WEBGL
+flat out vec4 vFlatColour;
+#endif
+
+uniform mat4 uMVMatrix;
+uniform mat4 uPMatrix;
+uniform mat4 uNMatrix;
+
+uniform vec4 uColour;
+uniform vec4 uLightPos;
+
+out vec4 vColour;
+out vec3 vNormal;
+out vec3 vPosEye;
+out vec2 vTexCoord;
+out vec3 vVertex;
+out vec3 vLightPos;
+
+void main(void)
+{
+  vec4 mvPosition = uMVMatrix * vec4(aVertexPosition, 1.0);
+  vPosEye = vec3(mvPosition) / mvPosition.w;
+  gl_Position = uPMatrix * mvPosition;
+
+  vNormal = normalize(mat3(uNMatrix) * aVertexNormal);
+
+  if (uColour.a > 0.0)
+    vColour = uColour;
+  else
+    vColour = aVertexColour;
+
+  vTexCoord = aVertexTexCoord;
+#ifndef WEBGL
+  vFlatColour = vColour;
+#endif
+  vVertex = aVertexPosition;
+
+  //Head light, lightPos=(0,0,0) - vPosEye
+  //vec3 lightDir = normalize(uLightPos.xyz - vPosEye);
+  if (uLightPos.w < 0.5)
+  {
+    //Light follows camera - default mode
+    vLightPos = uLightPos.xyz;
+  }
+  else
+  {
+    //Fixed Scene Light, when lightpos.w set to 1.0
+    vLightPos = (uMVMatrix * vec4(uLightPos.xyz, 1.0)).xyz;
+  }
+}
+