basilisk-engine 0.0.7__py3-none-any.whl → 0.0.9__py3-none-any.whl

basilisk/bsk_assets/cube.obj

@@ -0,0 +1,49 @@
+# Blender 4.1.0
+# www.blender.org
+mtllib cube.mtl
+o Cube
+v -1.000000 -1.000000 1.000000
+v -1.000000 1.000000 1.000000
+v -1.000000 -1.000000 -1.000000
+v -1.000000 1.000000 -1.000000
+v 1.000000 -1.000000 1.000000
+v 1.000000 1.000000 1.000000
+v 1.000000 -1.000000 -1.000000
+v 1.000000 1.000000 -1.000000
+vn -1.0000 -0.0000 -0.0000
+vn -0.0000 -0.0000 -1.0000
+vn 1.0000 -0.0000 -0.0000
+vn -0.0000 -0.0000 1.0000
+vn -0.0000 -1.0000 -0.0000
+vn -0.0000 1.0000 -0.0000
+vt 0.002191 0.000000
+vt 0.997809 0.002461
+vt 0.996578 0.998078
+vt 0.002191 0.994387
+vt 0.002191 0.005152
+vt 1.000269 0.001461
+vt 0.996578 0.999539
+vt 0.003422 0.998309
+vt 0.000961 0.000461
+vt 0.999039 -0.004461
+vt 0.996578 0.996078
+vt 0.002191 0.993618
+vt 0.003422 -0.001769
+vt 1.001500 0.001922
+vt 0.996578 0.997539
+vt 0.002191 1.001230
+vt 0.005652 0.000461
+vt 0.997578 0.000461
+vt 0.995117 1.001000
+vt 0.000730 0.998539
+vt 0.001191 -0.000769
+vt 1.000000 0.000000
+vt 0.997479 0.997489
+vt 0.006113 0.997309
+s 0
+f 1/1/1 2/2/1 4/3/1 3/4/1
+f 3/5/2 4/6/2 8/7/2 7/8/2
+f 7/9/3 8/10/3 6/11/3 5/12/3
+f 5/13/4 6/14/4 2/15/4 1/16/4
+f 3/17/5 7/18/5 5/19/5 1/20/5
+f 8/21/6 4/22/6 2/23/6 6/24/6

basilisk/render/frame.py

@@ -88,9 +88,9 @@ class Frame:
         """
 
         # Read the shaders
-        with open(f'basilisk/shaders/{vert}.vert') as file:
+        with open(self.engine.root + f'/shaders/{vert}.vert') as file:
             vertex_shader = file.read()
-        with open(f'basilisk/shaders/{frag}.frag') as file:
+        with open(self.engine.root + f'/shaders/{frag}.frag') as file:
             fragment_shader = file.read()
 
         # Create the program

basilisk/shaders/batch.frag

@@ -0,0 +1,248 @@
+#version 330 core
+
+layout (location = 0) out vec4 fragColor;
+
+// Structs needed for the shader
+struct textArray {
+    sampler2DArray array;
+};
+
+struct DirectionalLight {
+    vec3 direction;
+    float intensity;
+    vec3 color;
+    float ambient;
+};  
+
+struct Material {
+    vec3  color;
+    float roughness;
+    float subsurface;
+    float sheen;
+    float sheenTint;
+    float anisotropic;
+    float specular;
+    float metallicness;
+    float specularTint;
+    float clearcoat;
+    float clearcoatGloss;
+    
+    int   hasAlbedoMap;
+    vec2  albedoMap;
+    int   hasNormalMap;
+    vec2  normalMap;
+};
+
+struct LightResult {
+    vec3 diffuse;
+    vec3 specular;
+    vec3 clearcoat;
+};
+
+in vec2 uv;
+in vec3 position;
+in mat3 TBN;
+
+// Material attributes
+flat in Material mtl;
+
+// Uniforms
+uniform vec3 cameraPosition;
+const int    maxDirLights = 5;
+uniform      DirectionalLight dirLights[maxDirLights];
+uniform int  numDirLights;
+uniform      textArray textureArrays[5];
+uniform samplerCube skyboxTexture;
+
+
+float luminance(vec3 color) {
+    return dot(color, vec3(0.299, 0.587, 0.114));
+}
+
+float sqr(float x) { 
+    return x * x; 
+}
+
+float SchlickFresnel(float x) {
+    x = clamp(1.0 - x, 0.0, 1.0);
+    float x2 = x * x;
+    return x2 * x2 * x;
+}
+
+float GTR1(float ndoth, float a) {
+    float a2 = a * a;
+    float t = 1.0 + (a2 - 1.0) * ndoth * ndoth;
+    return (a2 - 1.0) / (3.1415 * log(a2) * t);
+}
+
+float AnisotropicGTR2(float ndoth, float hdotx, float hdoty, float ax, float ay) {
+    return 1 / (3.1415 * ax * ay * sqr(sqr(hdotx / ax) + sqr(hdoty / ay) + sqr(ndoth)));
+}
+
+float SmithGGX(float alpha, float ndotl, float ndotv) {
+    float a = ndotv * sqrt(alpha + ndotl * (ndotl - alpha * ndotl));
+    float b = ndotl * sqrt(alpha + ndotv * (ndotv - alpha * ndotv));
+
+    return 0.5 / (a + b);
+}
+
+float AnisotropicSmithGGX(float ndots, float sdotx, float sdoty, float ax, float ay) {
+    return 1 / (ndots + sqrt(pow(sdotx * ax, 2) + pow(sdoty * ay, 2) + pow(ndots, 2)));
+}
+
+// Diffuse model as outlined by Burley: https://media.disneyanimation.com/uploads/production/publication_asset/48/asset/s2012_pbs_disney_brdf_notes_v3.pdf
+// Much help from Acerola's video on the topic: https://www.youtube.com/watch?v=KkOkx0FiHDA&t=570s
+LightResult PrincipledDiffuse(DirectionalLight light, Material mtl, vec3 albedo, vec3 N, vec3 V, vec3 X, vec3 Y) {
+
+    LightResult result;
+
+    vec3 L = normalize(-light.direction);        // light direction
+    vec3 H = normalize(L + V);                      // half vector
+
+    // Commonly used values
+    float cos_theta_l = clamp(dot(N, L), 0.0, 1.0);
+    float cos_theta_V = clamp(dot(N, V), 0.0, 1.0);
+    float cos_theta_D = clamp(dot(L, H), 0.0, 1.0); // Also equal to dot(V, H) by symetry
+
+    float ndoth = dot(N, H);
+    float hdotx = dot(H, X);
+    float hdoty = dot(H, Y);
+    float ldotx = dot(L, X);
+    float ldoty = dot(L, Y);
+    float vdotx = dot(V, X);
+    float vdoty = dot(V, Y);
+
+    // Color Values
+    vec3 surfaceColor = albedo;
+    float Cdlum = luminance(surfaceColor);
+
+    vec3 Ctint = Cdlum > 0.0 ? surfaceColor / Cdlum : vec3(1.0, 1.0, 1.0);
+    vec3 Cspec0 = mix(mtl.specular * 0.08 * mix(vec3(1.0, 1.0, 1.0), Ctint, mtl.specularTint), surfaceColor, mtl.metallicness);
+    vec3 Csheen = mix(vec3(1.0, 1.0, 1.0), Ctint, mtl.sheenTint);
+
+    // Diffuse
+    float FL = SchlickFresnel(cos_theta_l);
+    float FV = SchlickFresnel(cos_theta_V);
+    float Fss90 = cos_theta_D * cos_theta_D * mtl.roughness;
+    float Fd90 = 0.5 + 2.0 * Fss90;
+
+    float Fd = mix(1.0, Fd90, FL) * mix(1.0, Fd90, FV);
+
+    // Subsurface
+    float Fss = mix(1.0, Fss90, FL) * mix(1.0, Fss90, FV);
+    float ss = 1.25 * (Fss * ((1 / (cos_theta_l + cos_theta_V)) - 0.5) + 0.5);
+
+    // Specular
+    float alpha = mtl.roughness * mtl.roughness;
+    float aspect = sqrt(1.0 - 0.9 * mtl.anisotropic);
+    float alpha_x = max(0.001, alpha / aspect);
+    float alpha_y = max(0.001, alpha * aspect);
+
+
+    // Anisotropic Microfacet Normal Distribution
+    float Ds = AnisotropicGTR2(ndoth, hdotx, hdoty, alpha_x, alpha_y);
+
+    // Geometric Attenuation
+    float GalphaSquared = pow(0.5 + mtl.roughness * 0.5, 2);
+    float GalphaX = max(0.001, GalphaSquared / aspect);
+    float GalphaY = max(0.001, GalphaSquared * aspect);
+    float G = AnisotropicSmithGGX(cos_theta_l, ldotx, ldoty, GalphaX, GalphaY);
+    G = sqrt(G);
+    G *= AnisotropicSmithGGX(cos_theta_V, vdotx, vdoty, GalphaX, GalphaY);
+
+    // Fresnel Reflectance
+    float FH = SchlickFresnel(cos_theta_D);
+    vec3 F = mix(Cspec0, vec3(1.0, 1.0, 1.0), FH);
+
+    // Sheen lobe
+    vec3 Fsheen = FH * mtl.sheen * Csheen;
+
+    // Clearcoat
+    float Dr = GTR1(ndoth, mix(0.1, 0.001, mtl.clearcoatGloss)); // Normalized Isotropic GTR Gamma == 1
+    float Fr = mix(0.04, 1.0, FH);
+    float Gr = SmithGGX(cos_theta_l, cos_theta_V, 0.25);
+
+    // Result for all lobes
+
+    result.diffuse =   max(vec3(0.0), (1 / 3.1415) * albedo * (mix(Fd, ss, mtl.subsurface) + Fsheen) * (1.0 - mtl.metallicness) * cos_theta_l);
+    result.specular =  max(vec3(0.0), vec3(Ds * F * G) * cos_theta_l);
+    result.clearcoat = max(vec3(0.0), vec3(0.25 * mtl.clearcoat * Gr * Fr * Dr) * cos_theta_l);
+
+    // Combine lobes and multiply weakening factor and light attributes
+    return result;
+}
+
+vec3 getAlbedo(Material mtl, vec2 uv, float gamma) {
+    vec3 albedo = mtl.color;
+    if (bool(mtl.hasAlbedoMap)){
+        albedo *= pow(texture(textureArrays[int(round(mtl.albedoMap.x))].array, vec3(uv, round(mtl.albedoMap.y))).rgb, vec3(gamma));
+    }
+    return albedo;
+}
+
+vec3 getNormal(Material mtl, mat3 TBN){
+    // Isolate the normal vector from the TBN basis
+    vec3 normal = TBN[2];
+    // Apply normal map if the material has one
+    if (bool(mtl.hasNormalMap)) {
+        normal = texture(textureArrays[int(round(mtl.normalMap.x))].array, vec3(uv, round(mtl.normalMap.y))).rgb * 2.0 - 1.0;
+        normal = normalize(TBN * normal); 
+    }
+    // Return vector
+    return normal;
+}
+
+void main() {
+    float gamma = 2.2;
+    vec3 viewDir = vec3(normalize(cameraPosition - position));
+
+    // Get lighting vectors
+    vec3 albedo    = getAlbedo(mtl, uv, gamma);
+    vec3 normal    = getNormal(mtl, TBN);
+    vec3 tangent   = TBN[0];
+    vec3 bitangent = TBN[1];
+
+    // Orthogonalize the tangent and bitangent according to the mapped normal vector
+    tangent = tangent - dot(normal, tangent) * normal;
+    bitangent = bitangent - dot(normal, bitangent) * normal - dot(tangent, bitangent) * tangent;
+
+    // Lighting variables
+    vec3 N = normalize(normal);                     // normal
+    vec3 V = normalize(cameraPosition - position);  // view vector
+    vec3 X = normalize(tangent);                    // Tangent Vector
+    vec3 Y = normalize(bitangent);                  // Bitangent Vector
+
+    // Indirect lighting
+    vec3 ambient_sky = texture(skyboxTexture, N).rgb;
+    vec3 reflect_sky = texture(skyboxTexture, reflect(-V, N)).rgb;
+
+    LightResult lightResult;
+    lightResult.diffuse   = vec3(0.0);
+    lightResult.specular  = vec3(0.0);
+    lightResult.clearcoat = vec3(0.0);
+
+    // Add result from each directional light in the scene
+    for (int i = 0; i < numDirLights; i++) {
+        // Caculate the light for the directional light
+        LightResult dirLightResult = PrincipledDiffuse(dirLights[i], mtl, albedo, N, V, X, Y);
+        vec3 lightFactor = dirLights[i].intensity * dirLights[i].color;
+        // Add each lobe
+        lightResult.diffuse   += dirLightResult.diffuse * lightFactor;
+        lightResult.specular  += dirLightResult.specular * lightFactor;
+        lightResult.clearcoat += dirLightResult.clearcoat * lightFactor;
+    }
+
+    lightResult.specular =  min(vec3(1.0), lightResult.specular);
+    lightResult.specular *= mix(vec3(1.0), reflect_sky, mtl.metallicness) * luminance(reflect_sky);
+    lightResult.diffuse  *= mix(vec3(1.0), ambient_sky, 0.25);
+
+    vec3 finalColor = albedo * 0.3 * mix(vec3(1.0), reflect_sky, mtl.metallicness);
+    finalColor += (lightResult.diffuse + lightResult.specular + lightResult.clearcoat);
+
+    // light_result *= mix(vec3(1.0), texture(skyboxTexture, reflect(-V, N)).rgb, mtl.metallicness);
+    // Gamma correction
+    finalColor = pow(finalColor, vec3(1.0/gamma));
+
+    // Output fragment color
+    fragColor = vec4(finalColor, 1.0);
+}

basilisk/shaders/batch.vert

@@ -0,0 +1,109 @@
+#version 330 core
+
+layout (location = 0) in vec3 in_position;
+layout (location = 1) in vec2 in_uv;
+layout (location = 2) in vec3 in_normal;
+layout (location = 3) in vec3 in_tangent;
+layout (location = 4) in vec3 in_bitangent;
+
+layout (location = 5) in vec3  obj_position;
+layout (location = 6) in vec4  obj_rotation;
+layout (location = 7) in vec3  obj_scale;
+layout (location = 8) in float obj_material;
+
+// Variables passed on to the fragment shader
+out vec2 uv;
+out vec3 position;
+out mat3 TBN;
+
+// Material struct sent to fragment shader
+struct Material {
+    vec3  color;
+    float roughness;
+    float subsurface;
+    float sheen;
+    float sheenTint;
+    float anisotropic;
+    float specular;
+    float metallicness;
+    float specularTint;
+    float clearcoat;
+    float clearcoatGloss;
+    
+    int   hasAlbedoMap;
+    vec2  albedoMap;
+    int   hasNormalMap;
+    vec2  normalMap;
+};
+flat out Material mtl;
+
+// Uniforms
+uniform mat4 projectionMatrix;
+uniform mat4 viewMatrix;
+uniform sampler2D materialsTexture;
+
+// Function to get the model matrix from node position, rotation, and scale
+mat4 getModelMatrix(vec3 pos, vec4 rot, vec3 scl) {
+    mat4 translation = mat4(
+        1    , 0    , 0    , 0,
+        0    , 1    , 0    , 0,
+        0    , 0    , 1    , 0,
+        pos.x, pos.y, pos.z, 1
+    );
+    mat4 rotation = mat4(
+        1 - 2 * (rot.z * rot.z + rot.w * rot.w), 2 * (rot.y * rot.z - rot.w * rot.x), 2 * (rot.y * rot.w + rot.z * rot.x), 0,
+        2 * (rot.y * rot.z + rot.w * rot.x), 1 - 2 * (rot.y * rot.y + rot.w * rot.w), 2 * (rot.z * rot.w - rot.y * rot.x), 0,
+        2 * (rot.y * rot.w - rot.z * rot.x), 2 * (rot.z * rot.w + rot.y * rot.x), 1 - 2 * (rot.y * rot.y + rot.z * rot.z), 0,
+        0, 0, 0, 1
+    );
+    mat4 scale = mat4(
+        scl.x, 0    , 0    , 0,
+        0    , scl.y, 0    , 0,
+        0    , 0    , scl.z, 0,
+        0    , 0    , 0    , 1
+    );
+    return translation * rotation * scale;
+}
+
+// Function to get the TBN matrix for normal mapping
+mat3 getTBN(mat4 modelMatrix, vec3 normal, vec3 tangent, vec3 bitangent){
+    vec3 T = normalize(vec3(modelMatrix * vec4(tangent,   0.0)));
+    vec3 B = normalize(vec3(modelMatrix * vec4(bitangent, 0.0)));
+    vec3 N = normalize(vec3(modelMatrix * vec4(normal,    0.0)));
+    return mat3(T, B, N);
+}
+
+void main() {
+    // Set the model matrix
+    mat4 modelMatrix = getModelMatrix(obj_position, obj_rotation, obj_scale);
+
+    // Set out variables
+    position = (modelMatrix * vec4(in_position, 1.0)).xyz;
+    TBN      = getTBN(modelMatrix, in_normal, in_tangent, in_bitangent);
+    uv       = in_uv;
+    
+    // Get the material
+    int mtl_size = 19;
+    int materialID     = int(obj_material);
+    mtl.color          = vec3(texelFetch(materialsTexture, ivec2(0, 0 + materialID * mtl_size), 0).r, texelFetch(materialsTexture, ivec2(0, 1  + materialID * mtl_size), 0).r, texelFetch(materialsTexture, ivec2(0, 2  + materialID * mtl_size), 0).r);
+    
+    
+    mtl.roughness      = texelFetch(materialsTexture, ivec2(0, 3 + materialID * mtl_size), 0).r;
+    mtl.subsurface     = texelFetch(materialsTexture, ivec2(0, 4 + materialID * mtl_size), 0).r;
+    mtl.sheen          = texelFetch(materialsTexture, ivec2(0, 5 + materialID * mtl_size), 0).r;
+    mtl.sheenTint      = texelFetch(materialsTexture, ivec2(0, 6 + materialID * mtl_size), 0).r;
+    mtl.anisotropic    = texelFetch(materialsTexture, ivec2(0, 7 + materialID * mtl_size), 0).r;
+    mtl.specular       = texelFetch(materialsTexture, ivec2(0, 8 + materialID * mtl_size), 0).r;
+    mtl.metallicness   = texelFetch(materialsTexture, ivec2(0, 9 + materialID * mtl_size), 0).r;
+    mtl.specularTint   = texelFetch(materialsTexture, ivec2(0, 10 + materialID * mtl_size), 0).r;
+    mtl.clearcoat      = texelFetch(materialsTexture, ivec2(0, 11 + materialID * mtl_size), 0).r;
+    mtl.clearcoatGloss = texelFetch(materialsTexture, ivec2(0, 12 + materialID * mtl_size), 0).r;
+    
+    mtl.hasAlbedoMap   = int(texelFetch(materialsTexture,  ivec2(0, 13  + materialID * mtl_size), 0).r);
+    mtl.albedoMap      = vec2(texelFetch(materialsTexture, ivec2(0, 14  + materialID * mtl_size), 0).r, texelFetch(materialsTexture, ivec2(0, 15  + materialID * mtl_size), 0).r);
+    mtl.hasNormalMap   = int(texelFetch(materialsTexture,  ivec2(0, 16  + materialID * mtl_size), 0).r);
+    mtl.normalMap      = vec2(texelFetch(materialsTexture, ivec2(0, 17  + materialID * mtl_size), 0).r, texelFetch(materialsTexture, ivec2(0, 18 + materialID * mtl_size), 0).r);    
+
+    // Set the fragment position
+    gl_Position = projectionMatrix * viewMatrix * modelMatrix * vec4(in_position, 1.0);
+}

basilisk/shaders/draw.frag

@@ -0,0 +1,22 @@
+#version 330 core
+
+layout (location = 0) out vec4 fragColor;
+
+in vec4     color;
+in vec2     imageIndex;
+in vec2     uv;
+flat in int usesImage;
+
+struct textArray {
+    sampler2DArray array;
+};
+uniform textArray textureArrays[5];
+
+void main() {
+    if (bool(usesImage)) {
+        fragColor = texture(textureArrays[int(round(imageIndex.x))].array, vec3(uv, round(imageIndex.y)));
+    }
+    else {
+        fragColor = color;
+    }
+}

basilisk/shaders/draw.vert

@@ -0,0 +1,22 @@
+#version 330 core
+
+layout (location = 0) in vec2  in_position;
+layout (location = 1) in vec4  in_color;
+layout (location = 2) in int   in_uses_image;
+
+out vec4     color;
+out vec2     imageIndex;
+out vec2     uv;
+flat out int usesImage;
+
+void main() {
+    usesImage = in_uses_image;
+    if (bool(in_uses_image)) {
+        imageIndex = in_color.xy;
+        uv = in_color.zw;
+    }
+    else{
+        color = in_color;
+    }
+    gl_Position = vec4(in_position.x, -in_position.y, 0.0, 1.0);
+}

basilisk/shaders/filter.frag

@@ -0,0 +1,23 @@
+#version 330 core
+
+out vec4 fragColor;
+
+in vec2 uv;
+
+uniform sampler2D screenTexture;
+
+
+void main()
+{
+    vec2  direction   =  normalize(vec2(1.0, 1.0));
+    float magnitude   =  0.6;
+    float redOffset   =  0.009 * magnitude;
+    float greenOffset =  0.006 * magnitude;
+    float blueOffset  = -0.006 * magnitude;
+
+    float r = texture(screenTexture, uv + direction * redOffset).r;
+    float g = texture(screenTexture, uv + direction * greenOffset).g;
+    float b = texture(screenTexture, uv + direction * blueOffset).b;
+
+    fragColor = vec4(r, g, b, 1.0);
+}

basilisk/shaders/frame.frag

@@ -0,0 +1,13 @@
+#version 330 core
+
+out vec4 fragColor;
+
+in vec2 uv;
+
+uniform sampler2D screenTexture;
+
+
+void main()
+{ 
+    fragColor = texture(screenTexture, uv);
+}

basilisk/shaders/frame.vert

@@ -0,0 +1,14 @@
+#version 330 core
+
+
+layout (location = 0) in vec3 in_position;
+layout (location = 1) in vec2 in_uv;
+
+out vec2 uv;
+
+
+void main()
+{
+    gl_Position = vec4(in_position.x, in_position.y, 0.0, 1.0); 
+    uv = in_uv;
+}  

basilisk/shaders/sky.frag

@@ -0,0 +1,10 @@
+#version 330 core
+out vec4 fragColor;
+
+in vec3 texCubeCoords;
+
+uniform samplerCube skyboxTexture;
+
+void main() {
+    fragColor = texture(skyboxTexture, texCubeCoords);
+}

basilisk/shaders/sky.vert

@@ -0,0 +1,14 @@
+#version 330 core
+layout (location = 0) in vec3 in_position;
+
+out vec3 texCubeCoords;
+
+uniform mat4 projectionMatrix;
+uniform mat4 viewMatrix;
+
+void main() {
+    texCubeCoords = in_position;
+    vec4 pos = projectionMatrix * mat4(mat3(viewMatrix)) * vec4(in_position, 1.0);
+    gl_Position = pos.xyww;
+    gl_Position.z -= 0.0001;
+}

{basilisk_engine-0.0.7.dist-info → basilisk_engine-0.0.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: basilisk-engine
-Version: 0.0.7
+Version: 0.0.9
 Summary: Python 3D Framework
 Home-page: https://basilisk-website.vercel.app/
 Author: Name

{basilisk_engine-0.0.7.dist-info → basilisk_engine-0.0.9.dist-info}/RECORD

@@ -2,7 +2,11 @@ basilisk/__init__.py,sha256=g1picXHoGTf2Oo0cc7XfMZr58QW8sPO7Gubsvlfmj_E,339
 basilisk/config.py,sha256=ynTRlX633DGoEtZOeAK8KNJF6offV3k3XFD7cia3Keg,61
 basilisk/engine.py,sha256=lGDJtSf6Z4mgJ014AWqHXOUz5iM4aJd18A0k_48gH7o,5805
 basilisk/scene.py,sha256=ow3w2ZouBdn7E1xw39-aMu7_gbsnDxzeNi1mqbYqa-M,4452
+basilisk/bsk_assets/Roboto-Regular.ttf,sha256=kqYnZjMRQMpbyLulIChCLSdgYa1XF8GsUIoRi2Gcauw,168260
 basilisk/bsk_assets/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+basilisk/bsk_assets/basilisk.png,sha256=1xePD8qDycxlRQ7hjEmfuw900BRykhRyumJePi6hxi8,21299
+basilisk/bsk_assets/cube.obj,sha256=rLm2nNcfj1zPZUx-VSF5CxqnToteHjzXQNxfRNq5iKU,1189
+basilisk/bsk_assets/skybox.png,sha256=0C9MvWUwNzewyiMtWLKrZJzAcLC1Ce72T3-Lq4hJZu0,1206153
 basilisk/collisions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 basilisk/collisions/collider.py,sha256=-bWTt5s_cO2Nmn9lG3igFQulYw5M19B9xoEEiGRCAzM,3469
 basilisk/collisions/collider_handler.py,sha256=S1TsBd8S3s_U5vozodTxIxRrAUMcYP6dIe2uf_42zaM,7372
@@ -48,7 +52,7 @@ basilisk/render/batch.py,sha256=YGhmTIY3SHWft6ESuFJc1WluZNh8_w2TMNdRK6wTJjM,2950
 basilisk/render/camera.py,sha256=nTlp48fhtSo9cc0dLIwPyx6lW3o595FhZM2r1iBCjEQ,6056
 basilisk/render/chunk.py,sha256=hU1xjy_ibQO40YDeWULNMofLsI4EfOYGmtxN6FqhwfE,2246
 basilisk/render/chunk_handler.py,sha256=2ZsUiLw9SA_YzBQXtTZMMQ6-Lc1oJVo_VENZDWXXHh0,5652
-basilisk/render/frame.py,sha256=kJVl0meCYm56CrU-RpAxt4mOpZaqf05eksQ_i5RH78w,6706
+basilisk/render/frame.py,sha256=OwgDtBK3EtXTD8e6o8chAl0Wu3fg-KwTEYQg1-r21y8,6728
 basilisk/render/image.py,sha256=27Jg8LuLjJ-NhSgbueFHc8RC8WmTOJOf2R6k1SLzI6I,2628
 basilisk/render/image_handler.py,sha256=giebUrgf9OpJ0vwljyJe1YdDtmB5oUisYmCL-t0kIRY,4119
 basilisk/render/light.py,sha256=hFqODv9iK4GEDZeDyBHxOWwwd4v8Pm089_xoScBMjVY,3879
@@ -58,7 +62,17 @@ basilisk/render/material_handler.py,sha256=pYgDBFFJw9TASVBQ33F4eO7SEh4vpVIHIDoVf
 basilisk/render/shader_handler.py,sha256=DBpW_Dx4GAaR_YHAslu4ZuXk35mL4iZaEIGMCpBQX7U,3557
 basilisk/render/sky.py,sha256=aYC8W_RehC084OcJK22HQnViu_wFPWqHv8lMzSwBJMw,4725
 basilisk/shaders/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-basilisk_engine-0.0.7.dist-info/METADATA,sha256=QPAnSuPi8GK_G-WZeqN52RGwTaSxIDSAl1ccHpLW6TY,1118
-basilisk_engine-0.0.7.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
-basilisk_engine-0.0.7.dist-info/top_level.txt,sha256=enlSYSf7CUyAly1jmUCNNGInTbaFUjGk4SKwyckZQkw,9
-basilisk_engine-0.0.7.dist-info/RECORD,,
+basilisk/shaders/batch.frag,sha256=w0t98k3Zp5v4qmg2ou7pnrselyIufIlQst61LkZXvjM,8544
+basilisk/shaders/batch.vert,sha256=qYjN0YIJI_70jpDSiMt7kn5F1XEReqqKdjDp_nCd8KI,4735
+basilisk/shaders/draw.frag,sha256=XV7dcVm-RhZXs6e6ddJhesR6BAmVWEHZqQgEJQEA77Q,450
+basilisk/shaders/draw.vert,sha256=UQtceYDIUfrluXZSb_Y_L8_-Ky_bjAj9Uyvuu8KkpeE,509
+basilisk/shaders/filter.frag,sha256=m_egR4yiFRmIHGwCCfpcdvGXQi1w1Ago_iABlbnX80c,584
+basilisk/shaders/frame.frag,sha256=rs_AA1u7DL3CxtqpTqvhgQjYYthl_l_Dg7RXpU9_5Ks,160
+basilisk/shaders/frame.vert,sha256=KPB-Q3-Rix9-JxSj5tBHbZOu7QCdFgCzHwiZKEYIbFc,227
+basilisk/shaders/image.png,sha256=nZRs38y_Ze8sKVuUWuYDnf9y35v2TOX_L6Ae0nJ7Ilc,13906
+basilisk/shaders/sky.frag,sha256=vTmZ1Xsd601_gmeBRfLYodHuBoBDI-M_1IybRt0ZDFk,178
+basilisk/shaders/sky.vert,sha256=v_BSdnMiljSJGPqno-J_apAiom38IrBzbDoxM7pIgwI,345
+basilisk_engine-0.0.9.dist-info/METADATA,sha256=dBinxZxclHiFPD-5IA2rwqXNhwrZV-qNWNSFnnosTeA,1118
+basilisk_engine-0.0.9.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
+basilisk_engine-0.0.9.dist-info/top_level.txt,sha256=enlSYSf7CUyAly1jmUCNNGInTbaFUjGk4SKwyckZQkw,9
+basilisk_engine-0.0.9.dist-info/RECORD,,