Simple solar system example (initial version)

Author: einarf

examples/system/README.md

@@ -0,0 +1,4 @@
+
+# Planet System
+
+https://www.solarsystemscope.com/textures/

examples/system/dependencies.py

@@ -0,0 +1,27 @@
+import os
+
+from demosys.resources.meta import ProgramDescription, TextureDescription
+
+
+def local(path):
+    """
+    Prepend the effect package name to a path so resources
+    can still be loaded when copied into a new effect package.
+    """
+    return os.path.join(__name__.split('.')[-2], path)
+
+
+effect_packages = []
+
+resources = [
+    TextureDescription(label='milkyway', path=local('MilkyWayPanorama4K.jpg')),
+    ProgramDescription(label='milkyway', path=local('milkyway.glsl')),
+
+    TextureDescription(label='sun', path=local('2k_sun.jpg'), mipmap=True),
+    ProgramDescription(label='sun', path=local('sun.glsl')),
+
+    TextureDescription(label='earth_day', path=local('2k_earth_daymap.jpg'), mipmap=True),
+    TextureDescription(label='earth_night', path=local('2k_earth_nightmap.jpg'), mipmap=True),
+    TextureDescription(label='earth_clouds', path=local('2k_earth_clouds.jpg'), mipmap=True),
+    ProgramDescription(label='earth', path=local('earth.glsl')),
+]

examples/system/effects.py

@@ -0,0 +1,95 @@
+import moderngl
+from demosys import geometry
+from demosys.effects import effect
+from pyrr import matrix44, matrix33
+
+
+class SunSystemEffect(effect.Effect):
+    runnable = True
+
+    def __init__(self):
+        self.sky_sphere = geometry.sphere(100.0)
+        self.sky_texture = self.get_texture('milkyway')
+        self.sky_shader = self.get_program('milkyway')
+
+        self.sun_sphere = geometry.sphere(10.0)
+        self.sun_shader = self.get_program('sun')
+        self.sun_texture = self.get_texture('sun')
+
+        # Matrices
+        self.projection_bytes = self.sys_camera.projection.tobytes()
+        self.sun_matrix = matrix44.create_identity()
+
+        # Default shader parameters
+        self.sky_shader['m_proj'].write(self.projection_bytes)
+        self.sky_shader['texture0'].value = 0
+        self.sky_texture.use(location=0)
+
+        # self.sun_shader['m_proj'].write(self.projection_bytes)
+        # self.sun_shader['texture0'].value = 1
+
+        self.sun_pos = None
+        self.earth = EarthEffect(parent=self)
+
+    def draw(self, time, frametime, target):
+        # Enable depth testing and face fulling
+        self.ctx.disable(moderngl.DEPTH_TEST | moderngl.CULL_FACE)
+        cam_mat = self.sys_camera.view_matrix
+
+        # Skybox
+        sky_matrix = matrix44.create_from_matrix33(matrix33.create_from_matrix44(cam_mat))
+        self.sky_shader['m_mv'].write(sky_matrix.astype('f4').tobytes())
+        self.sky_sphere.render(self.sky_shader)
+
+        self.ctx.enable(moderngl.DEPTH_TEST | moderngl.CULL_FACE)
+
+        # Sun position
+        self.sun_pos = cam_mat[3][0:3].astype('f4')
+
+        # Sun
+        self.sun_shader['m_mv'].write(self.sys_camera.view_matrix.astype('f4').tobytes())
+        self.sun_shader['m_proj'].write(self.projection_bytes)
+        self.sun_shader['time'].value = time
+        self.sun_shader['texture0'].value = 1
+        self.sun_texture.use(location=1)
+        self.sun_sphere.render(self.sun_shader)
+
+        # Earth
+        self.earth.draw(time, frametime, target)
+
+
+class EarthEffect(effect.Effect):
+
+    def __init__(self, parent=None):
+        self.parent = parent
+        self.program = self.get_program('earth')
+        self.texture_day = self.get_texture('earth_day')
+        self.texture_night = self.get_texture('earth_night')
+        self.texture_clouds = self.get_texture('earth_clouds')
+        self.sphere = geometry.sphere(2.0, sectors=128, rings=128)
+
+    def draw(self, time, frametime, target):
+        matrix = matrix44.multiply(
+            # Rotate earth around its own axis
+            matrix44.multiply(
+                matrix44.create_from_eulers([0.0, 0.0, -time / 5.0]),
+                # Translate out from the sun and rotate around it
+                matrix44.multiply(
+                    matrix44.create_from_translation([-40, 0, 0]),
+                    matrix44.create_from_eulers([0, 0, 0])  # time/100.0])
+                ),
+            ),
+            self.sys_camera.view_matrix
+        )
+
+        self.program['m_proj'].write(self.sys_camera.projection.tobytes())
+        self.program['m_mv'].write(matrix.astype('f4').tobytes())
+        self.program['m_proj'].write(self.sys_camera.projection.tobytes())
+        self.program['sun_pos'].write(self.parent.sun_pos.tobytes())
+        self.program['texture_day'].value = 1
+        self.program['texture_night'].value = 2
+        self.program['texture_clouds'].value = 3
+        self.texture_day.use(location=1)
+        self.texture_night.use(location=2)
+        self.texture_clouds.use(location=3)
+        self.sphere.render(self.program)

examples/system/resources/programs/system/earth.glsl

@@ -0,0 +1,49 @@
+#version 330
+
+#if defined VERTEX_SHADER
+
+in vec3 in_position;
+in vec3 in_normal;
+in vec2 in_uv;
+
+uniform mat4 m_proj;
+uniform mat4 m_mv;
+
+out vec2 uv;
+out vec3 normal;
+out vec3 pos;
+
+void main() {
+    vec4 p = m_mv * vec4(in_position, 1.0);
+	gl_Position = m_proj * p;
+    normal = transpose(inverse(mat3(m_mv))) * in_normal;
+    uv = in_uv;
+    pos = p.xyz;
+}
+
+#elif defined FRAGMENT_SHADER
+
+out vec4 fragColor;
+
+uniform sampler2D texture_day;
+uniform sampler2D texture_night;
+uniform sampler2D texture_clouds;
+uniform vec3 sun_pos;
+
+in vec2 uv;
+in vec3 normal;
+in vec3 pos;
+
+void main()
+{
+    float v = dot(normalize(normal), normalize(sun_pos - pos));
+    float m = smoothstep(0.0, 1.0, v * 3);
+    vec4 c = mix(
+        texture(texture_night, uv),
+        texture(texture_day, uv),
+        m
+    );
+    fragColor = c + texture(texture_clouds, uv) * m;
+}
+
+#endif

examples/system/resources/programs/system/milkyway.glsl

@@ -0,0 +1,29 @@
+#version 330
+
+#if defined VERTEX_SHADER
+
+in vec3 in_position;
+in vec2 in_uv;
+
+uniform mat4 m_proj;
+uniform mat4 m_mv;
+
+out vec2 uv;
+
+void main() {
+	gl_Position = m_proj * m_mv * vec4(in_position, 1.0);
+    uv = in_uv;
+}
+
+#elif defined FRAGMENT_SHADER
+
+out vec4 fragColor;
+uniform sampler2D texture0;
+in vec2 uv;
+
+void main()
+{
+    fragColor = texture(texture0, uv);
+}
+
+#endif

examples/system/resources/programs/system/sun.glsl

@@ -0,0 +1,128 @@
+#version 330
+
+#if defined VERTEX_SHADER
+
+in vec3 in_position;
+in vec2 in_uv;
+
+uniform mat4 m_proj;
+uniform mat4 m_mv;
+
+out vec2 uv;
+out vec3 pos;
+
+void main() {
+	gl_Position = m_proj * m_mv * vec4(in_position, 1.0);
+    pos = in_position.xyz;
+    uv = in_uv;
+}
+
+#elif defined FRAGMENT_SHADER
+//	Simplex 4D Noise 
+//	by Ian McEwan, Ashima Arts
+//
+vec4 permute(vec4 x){return mod(((x*34.0)+1.0)*x, 289.0);}
+float permute(float x){return floor(mod(((x*34.0)+1.0)*x, 289.0));}
+vec4 taylorInvSqrt(vec4 r){return 1.79284291400159 - 0.85373472095314 * r;}
+float taylorInvSqrt(float r){return 1.79284291400159 - 0.85373472095314 * r;}
+
+vec4 grad4(float j, vec4 ip){
+  const vec4 ones = vec4(1.0, 1.0, 1.0, -1.0);
+  vec4 p,s;
+
+  p.xyz = floor( fract (vec3(j) * ip.xyz) * 7.0) * ip.z - 1.0;
+  p.w = 1.5 - dot(abs(p.xyz), ones.xyz);
+  s = vec4(lessThan(p, vec4(0.0)));
+  p.xyz = p.xyz + (s.xyz*2.0 - 1.0) * s.www; 
+
+  return p;
+}
+
+float snoise(vec4 v){
+  const vec2  C = vec2( 0.138196601125010504,  // (5 - sqrt(5))/20  G4
+                        0.309016994374947451); // (sqrt(5) - 1)/4   F4
+// First corner
+  vec4 i  = floor(v + dot(v, C.yyyy) );
+  vec4 x0 = v -   i + dot(i, C.xxxx);
+
+// Other corners
+
+// Rank sorting originally contributed by Bill Licea-Kane, AMD (formerly ATI)
+  vec4 i0;
+
+  vec3 isX = step( x0.yzw, x0.xxx );
+  vec3 isYZ = step( x0.zww, x0.yyz );
+//  i0.x = dot( isX, vec3( 1.0 ) );
+  i0.x = isX.x + isX.y + isX.z;
+  i0.yzw = 1.0 - isX;
+
+//  i0.y += dot( isYZ.xy, vec2( 1.0 ) );
+  i0.y += isYZ.x + isYZ.y;
+  i0.zw += 1.0 - isYZ.xy;
+
+  i0.z += isYZ.z;
+  i0.w += 1.0 - isYZ.z;
+
+  // i0 now contains the unique values 0,1,2,3 in each channel
+  vec4 i3 = clamp( i0, 0.0, 1.0 );
+  vec4 i2 = clamp( i0-1.0, 0.0, 1.0 );
+  vec4 i1 = clamp( i0-2.0, 0.0, 1.0 );
+
+  //  x0 = x0 - 0.0 + 0.0 * C 
+  vec4 x1 = x0 - i1 + 1.0 * C.xxxx;
+  vec4 x2 = x0 - i2 + 2.0 * C.xxxx;
+  vec4 x3 = x0 - i3 + 3.0 * C.xxxx;
+  vec4 x4 = x0 - 1.0 + 4.0 * C.xxxx;
+
+// Permutations
+  i = mod(i, 289.0); 
+  float j0 = permute( permute( permute( permute(i.w) + i.z) + i.y) + i.x);
+  vec4 j1 = permute( permute( permute( permute (
+             i.w + vec4(i1.w, i2.w, i3.w, 1.0 ))
+           + i.z + vec4(i1.z, i2.z, i3.z, 1.0 ))
+           + i.y + vec4(i1.y, i2.y, i3.y, 1.0 ))
+           + i.x + vec4(i1.x, i2.x, i3.x, 1.0 ));
+// Gradients
+// ( 7*7*6 points uniformly over a cube, mapped onto a 4-octahedron.)
+// 7*7*6 = 294, which is close to the ring size 17*17 = 289.
+
+  vec4 ip = vec4(1.0/294.0, 1.0/49.0, 1.0/7.0, 0.0) ;
+
+  vec4 p0 = grad4(j0,   ip);
+  vec4 p1 = grad4(j1.x, ip);
+  vec4 p2 = grad4(j1.y, ip);
+  vec4 p3 = grad4(j1.z, ip);
+  vec4 p4 = grad4(j1.w, ip);
+
+// Normalise gradients
+  vec4 norm = taylorInvSqrt(vec4(dot(p0,p0), dot(p1,p1), dot(p2, p2), dot(p3,p3)));
+  p0 *= norm.x;
+  p1 *= norm.y;
+  p2 *= norm.z;
+  p3 *= norm.w;
+  p4 *= taylorInvSqrt(dot(p4,p4));
+
+// Mix contributions from the five corners
+  vec3 m0 = max(0.6 - vec3(dot(x0,x0), dot(x1,x1), dot(x2,x2)), 0.0);
+  vec2 m1 = max(0.6 - vec2(dot(x3,x3), dot(x4,x4)            ), 0.0);
+  m0 = m0 * m0;
+  m1 = m1 * m1;
+  return 49.0 * ( dot(m0*m0, vec3( dot( p0, x0 ), dot( p1, x1 ), dot( p2, x2 )))
+               + dot(m1*m1, vec2( dot( p3, x3 ), dot( p4, x4 ) ) ) ) ;
+
+}
+
+out vec4 fragColor;
+uniform sampler2D texture0;
+uniform float time;
+in vec2 uv;
+in vec3 pos;
+
+void main()
+{
+    float v = snoise(vec4(pos * 2.5, time / 4.0));
+    fragColor = mix(texture(texture0, uv), vec4(v), 0.3);
+    // fragColor = texture(texture0, uv);
+}
+
+#endif