Working planet fragment/vertex phong shader

Author: Daxode

Blobtory/Scripts/Main.py

@@ -1,7 +1,5 @@
-from direct.task import Task
 from panda3d.core import loadPrcFile, loadPrcFileData
-from direct.showbase.ShowBase import ShowBase, PTAFloat, \
-    DirectionalLight, AntialiasAttrib, AmbientLight
+from direct.showbase.ShowBase import ShowBase, PTAFloat, AmbientLight
 
 from Blobtory.Scripts.Pipeline.WindowCreator import WindowCreator
 
@@ -22,12 +20,12 @@ def __init__(self):
         super().__init__()
         self.winCreator = WindowCreator(self, enableRP=False, isFullscreen=False)
 
-        self.planetGen: PlanetGenerator = PlanetGenerator(self.winCreator, 128, 150)
+        self.planetGen: PlanetGenerator = PlanetGenerator(self.winCreator, 128, 500)
         self.planetGen.cubeformer.mouseTime.setData(PTAFloat([10, 0, 0, 1]))
         self.accept("a", self.planetGen.RegenPlanet)
 
         alight = AmbientLight('alight')
-        alight.setColor((0.6, 0.6, 0.6, 1))
+        alight.setColor((0.5, 0.5, 0.5, 1))
         alnp = self.render.attachNewNode(alight)
         self.render.setLight(alnp)
 

Blobtory/Scripts/Pipeline/WindowCreator.py

@@ -81,12 +81,18 @@ def UpdateWindow(self, isFullscreen: bool, enableRP: bool):
             # filters.setBloom()
 
             dlight = DirectionalLight('my dlight')
-            dlight.setColor((0.8, 0.5, 0.5, 1))
+            # dlight.setColor((0.8, 0.5, 0.5, 1))
             dlnp = self.base.render.attachNewNode(dlight)
-            self.base.render.setAntialias(AntialiasAttrib.MAuto)
+            self.base.render.setLight(dlnp)
+
+            dlight = DirectionalLight('my dlight')
+            dlight.setColor((0.05, 0.05, 0.05, 1))
+            dlnp = self.base.render.attachNewNode(dlight)
+            dlnp.setHpr(0, 180, 0)
             self.base.render.setLight(dlnp)
 
             #filters.setAmbientOcclusion()
             # filters.setVolumetricLighting(dlnp)
+            self.base.render.setAntialias(AntialiasAttrib.MAuto)
             self.base.setBackgroundColor(0, 0.01, 0.1)
             self.base.setFrameRateMeter(True)

Blobtory/Scripts/planet_former/MarchingCubes.py

@@ -1,7 +1,7 @@
 import math
 
 from panda3d.core import Texture, Shader, NodePath, LVecBase3i, ShaderAttrib, GeomEnums, GeomNode, \
-    GeomVertexFormat, GeomVertexData, GeomTriangles, Geom, OmniBoundingVolume
+    GeomVertexFormat, GeomVertexData, GeomTriangles, Geom, OmniBoundingVolume, Material, LColor
 
 from assets.shaders.compute.includes import MarchTable
 from Blobtory.Scripts.planet_former.CubeFormer import CubeFormer
@@ -123,8 +123,16 @@ def GenerateMesh(self):
             -self.size.getX()*0.5*self.cubeformer.spacing,
             -self.size.getY()*0.5*self.cubeformer.spacing,
             -self.size.getZ()*0.5*self.cubeformer.spacing)
+
         self.winCreator.pipelineSwitcher.AddModelWithShaderGeneralName(self.geomPath, "assets/shaders/planets/planet")
         self.geomPath.set_shader_input('vertexBufferEdge', self.edgeVertexBuffer)
         self.geomPath.set_shader_input('triangleBuffer', self.triangleBuffer)
         self.geomPath.set_shader_input('normalBuffer', self.normalBuffer)
 
+        myMaterial = Material()
+        myMaterial.setShininess(0.8)  # Make this material shiny
+        myMaterial.setDiffuse(LColor(0.95, 0.24, 0.06, 1)*0.1)
+        myMaterial.setSpecular((1.1, 1.1, 1.1, 1))
+        myMaterial.setAmbient((0.04, 0.01, 0.006, 1))  # Make this material blue
+        self.geomPath.setMaterial(myMaterial)
+

assets/shaders/compute/alphaNoiseSphere.glsl

@@ -45,7 +45,7 @@ void main() {
 
 //    point.w = (snoise(polarCoord.yz/(mouseX*10))*radius - r);
 
-    float noiseOuter = 1-abs(fractalNoise(normalize(movedPoint)*1)+1)*mouseTime.w*10;
+    float noiseOuter = 1-abs(fractalNoise(normalize(movedPoint)*1)+1)*mouseTime.w*50;
     float planetRadius = radius+noiseOuter;
     point.w = smoothstep(0, 1, (planetRadius - lengthFromCenter)/10);
 
@@ -57,7 +57,7 @@ void main() {
         float theta = rand((offset+i))*2*PI;
         float phi = rand((offset+i+200))*2*PI;
 
-        float cometSize = rand((offset+i))*20+4;
+        float cometSize = rand((offset+i))*150+50;
 
         vec3 cartCraterNormal = vec3(sin(theta)*cos(phi), sin(theta)*sin(phi), cos(theta));
         vec3 cartCraterPosCenter = (planetRadius*cometOffset-cometDiff+cometSize*sizeMatters)*cartCraterNormal;

assets/shaders/compute/cubemarcher.glsl

@@ -43,6 +43,9 @@ void main() {
     if (cubeCorners[6].w < isoLevel) cubeIndex |= 64;
     if (cubeCorners[7].w < isoLevel) cubeIndex |= 128;
 
+    float wComb = 0;
+    for (int i = 0; i < 8; i++) wComb += cubeCorners[i].w;
+
     int i = 0;
     int triangleEdgeIndex = 1;
     do {
@@ -67,7 +70,7 @@ void main() {
 
         vec3 normal = cross(v2-v0, v1-v0);
         //vec3 normal = normalize(v2+v0+v1);
-        imageStore(normalBuffer, int(triangleIDIndex/3), vec4(normal, triangleIDIndex/1000));
+        imageStore(normalBuffer, int(triangleIDIndex/3), vec4(normal, wComb));
 
         i+=3;
     } while (triangleEdgeIndex != -1);

assets/shaders/planets/planet.frag

@@ -1,28 +1,19 @@
 #version 130
 
 #pragma include "../utils/p3d_light_sources.glsl"
-
-#define MAX_ITERATION 20
+#pragma include "../utils/p3d_material.glsl"
 
 // Input from vertex shader
-in vec2 texcoord;
+in vec3 viewspacePos;
+in vec4 fragPos;
 in vec3 vertexNormal;
 in vec3 primNormal;
-in vec3 FragPos;
 in float num;
 
-in vec3 pospos;
-
 in vec3 cam_pos;
 in vec3 cam_dir;
 
 out vec4 outputColor;
-const float atten = 0.5;
-const float shininess = 0.5;
-
-const float specularStrength = 0.9;
-const vec3 specColor = vec3(1,1,1);
-const vec3 matColor = vec3(0,0.2,0);
 
 vec3 remap(vec3 iMin, vec3 iMax, vec3 oMin, vec3 oMax, vec3 v) {
   vec3 t = smoothstep(iMin, iMax, v);
@@ -35,36 +26,49 @@ float remap(float iMin, float iMax, float oMin, float oMax, float v) {
 }
 
 void main() {
-  vec3 rgb_normal = (normalize(primNormal) + 0.5) * 0.5;
-
-  //outputColor = vec4(rgb_normal, 1)*clamp(vec4(dot(primNormal, )),0,1);
-  //outputColor = vec4(rgb_normal, 1);//*clamp(primNormal, 0, 1).x;
-  vec3 lightDir = p3d_LightSource[0].position.xyz;
-  lightDir = vec3(0,-0.5,0.5);
-
-  float diff = max(dot(primNormal, lightDir), 0.0);
-  vec3 diffuse = diff * vec3(0.1);//p3d_LightSource[0].color.xyz;
-
-  vec3 viewDir = normalize(cam_pos - FragPos);
-  vec3 reflectDir = reflect(lightDir, normalize(primNormal));
-
-  float spec = pow(max(dot(-viewDir, reflectDir), 0.0), 32);
-  vec3 specular = specularStrength * spec * specColor;
-
-  vec3 light = diffuse + specular;
-  //if (any(lessThan(normalize(pospos), vec3(0)))) light = vec3(0);
-
-  vec3 result = (p3d_LightModel.ambient.xyz+light) * vec3(remap(0.5, 10, 0, 1, dot(pospos,vec3(1))));
-  outputColor = vec4(result, 1);
-
-  //outputColor = vec4()
-  //outputColor = vec4(rgb_normal, 1);// * smoothstep(0,1, dot(vertexNormal, lightDir)+0.9*dot(p3d_LightModel.ambient.xyz, vec3(1)));
-//  vec3 diffuseReflection = atten * p3d_LightSource[0].color.xyz * max(normalize(primNormal), lightDir);
-//  vec3 lightReflectDir = reflect(-lightDir, normalize(primNormal));
-//  float lightSeeDir = max(0.0, dot(lightReflectDir, cam_dir));
-//  vec3 shininessPower = vec3(pow(lightSeeDir.x, shininess), pow(lightSeeDir.y, shininess), pow(lightSeeDir.z, shininess));
-//  float shininessPower = pow(lightSeeDir, (shininess));
-//  vec3 specularReflect = atten * specColor * shininessPower;
-//
-//  outputColor = vec4(matColor*(diffuseReflection+p3d_LightModel.ambient.xyz), 1);
+  int mode = 1;
+  //vec3 viewDir = normalize(viewspacePos.xyz-cam_pos);
+  vec3 illumLightSum = vec3(0);
+  vec3 normal = normalize(primNormal);
+
+  for (int i = 0; i < p3d_LightSource.length; i++) {
+    vec3 lightDir = p3d_LightSource[i].position.xyz;
+    if (p3d_LightSource[i].position.w != 0) lightDir -= viewspacePos;
+
+    float distance = length(lightDir);
+    distance = distance * distance;
+    lightDir = normalize(lightDir);
+
+    float lambertian = max(dot(lightDir, normal), 0.0);
+    float specular = 0.0;
+
+    if (lambertian > 0.0) {
+      vec3 viewDir = normalize(-viewspacePos);
+
+      // this is blinn phong
+      vec3 halfDir = normalize(lightDir + viewDir);
+      float specAngle = max(dot(halfDir, normal), 0.0);
+      specular = pow(specAngle, p3d_Material.shininess);
+
+      // this is phong (for comparison)
+      if (mode == 2) {
+        vec3 reflectDir = reflect(-lightDir, normal);
+        specAngle = max(dot(reflectDir, viewDir), 0.0);
+        // note that the exponent is different here
+        specular = pow(specAngle, p3d_Material.shininess/4.0);
+      }
+    }
+    vec3 illumDiffuse = (p3d_Material.diffuse.xyz) * lambertian * p3d_LightSource[i].color.xyz * 1 / distance;
+    vec3 illumSpecular = p3d_Material.diffuse.xyz*p3d_Material.specular * specular * p3d_LightSource[i].color.xyz * 1 / distance;
+
+    illumLightSum += illumDiffuse+illumSpecular;
+  }
+
+  //vec3 reflectDir = reflect(-lightDir, normalize(primNormal));
+  //float spec = pow(max(dot(viewDir, reflectDir), 0.0), 64);
+  //vec3 specular = specularStrength * spec * specColor;
+
+  vec3 colorGammaCorrected = pow(p3d_LightModel.ambient.xyz*p3d_Material.ambient.xyz+illumLightSum, vec3(0.49504950495));
+  // use the gamma corrected color in the fragment0
+  outputColor = vec4(colorGammaCorrected, 1.0);
 }

assets/shaders/planets/planet.vert

@@ -2,42 +2,46 @@
 
 // Uniform inputs
 uniform mat4 p3d_ModelViewProjectionMatrix;
-uniform mat4 p3d_ViewProjectionMatrix;
-uniform mat4 p3d_ModelMatrix;
 uniform mat4 p3d_ViewMatrixInverse;
+uniform mat4 p3d_ModelMatrix;
+uniform mat4 p3d_ModelViewMatrix;
+uniform mat3 p3d_NormalMatrix;
 
 layout(rgba32f) uniform readonly image3D vertexBufferEdge;
 layout(rgba32i) uniform readonly iimageBuffer triangleBuffer;
 layout(rgba32f) uniform readonly imageBuffer normalBuffer;
 
-// Vertex inputs
+//Inputs
 in vec2 p3d_MultiTexCoord0;
-in vec3 p3d_Normal;
 
 // Output to fragment shader
 out vec2 texcoord;
 out vec3 vertexNormal;
 out vec3 primNormal;
-out vec3 FragPos;
 out float num;
-out vec3 pospos;
+out vec4 fragPos;
+out vec3 viewspacePos;
 
 out vec3 cam_pos;
 out vec3 cam_dir;
 
 void main() {
   ivec3 vertexIndex = imageLoad(triangleBuffer, gl_VertexID).xyz;
   vec4 vertex = vec4(imageLoad(vertexBufferEdge, vertexIndex).xyz, 1);
-  //vertex = vec4(gl_VertexID, gl_VertexID, gl_VertexID+1, 0);
   gl_Position = p3d_ModelViewProjectionMatrix*vertex;
+  fragPos = gl_Position;
+
+  vec4 viewspacePos4 = p3d_ModelViewMatrix * vertex;
+  viewspacePos = vec3(viewspacePos4) / viewspacePos4.w;
+
   vec4 primNormalWVal = imageLoad(normalBuffer, int(gl_VertexID/3));
   primNormal = primNormalWVal.xyz;
-  primNormal = mat3(transpose(inverse(p3d_ModelMatrix))) * primNormal;
+  primNormal = p3d_NormalMatrix * primNormal;
+
   vertexNormal = normalize(vertex.xyz);
-  FragPos = vec3(p3d_ModelViewProjectionMatrix * vertex);
+
   texcoord = p3d_MultiTexCoord0;
   num = primNormalWVal.w;
-  pospos = vertex.xyz;
 
   cam_pos = p3d_ViewMatrixInverse[3].xyz;
   cam_dir = -p3d_ViewMatrixInverse[2].xyz;

assets/shaders/utils/p3d_light_sources.glsl

@@ -25,7 +25,7 @@ uniform struct p3d_LightSourceParameters {
 
   // Transforms view-space coordinates to shadow map coordinates
   mat4 shadowViewMatrix;
-} p3d_LightSource[];
+} p3d_LightSource[8];
 
 // The sum of all active ambient light colors.
 uniform struct {

version.py

@@ -1,2 +1,2 @@
-version = "0.0.1"
+version = "0.0.2"
 print(version)