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

basilisk/shaders/batch.frag

@@ -31,6 +31,10 @@ struct Material {
     vec2  albedoMap;
     int   hasNormalMap;
     vec2  normalMap;
+    int   hasRoughnessMap;
+    vec2  roughnessMap;
+    int   hasAoMap;
+    vec2  aoMap;
 };
 
 struct LightResult {
@@ -92,7 +96,7 @@ float AnisotropicSmithGGX(float ndots, float sdotx, float sdoty, float ax, float
 
 // 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 PrincipledDiffuse(DirectionalLight light, Material mtl, vec3 albedo, float roughness, vec3 N, vec3 V, vec3 X, vec3 Y) {
 
     LightResult result;
 
@@ -123,7 +127,7 @@ LightResult PrincipledDiffuse(DirectionalLight light, Material mtl, vec3 albedo,
     // Diffuse
     float FL = SchlickFresnel(cos_theta_l);
     float FV = SchlickFresnel(cos_theta_V);
-    float Fss90 = cos_theta_D * cos_theta_D * mtl.roughness;
+    float Fss90 = cos_theta_D * cos_theta_D * roughness;
     float Fd90 = 0.5 + 2.0 * Fss90;
 
     float Fd = mix(1.0, Fd90, FL) * mix(1.0, Fd90, FV);
@@ -133,7 +137,7 @@ LightResult PrincipledDiffuse(DirectionalLight light, Material mtl, vec3 albedo,
     float ss = 1.25 * (Fss * ((1 / (cos_theta_l + cos_theta_V)) - 0.5) + 0.5);
 
     // Specular
-    float alpha = mtl.roughness * mtl.roughness;
+    float alpha = roughness * 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);
@@ -143,7 +147,7 @@ LightResult PrincipledDiffuse(DirectionalLight light, Material mtl, vec3 albedo,
     float Ds = AnisotropicGTR2(ndoth, hdotx, hdoty, alpha_x, alpha_y);
 
     // Geometric Attenuation
-    float GalphaSquared = pow(0.5 + mtl.roughness * 0.5, 2);
+    float GalphaSquared = pow(0.5 + 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);
@@ -192,15 +196,39 @@ vec3 getNormal(Material mtl, mat3 TBN){
     return normal;
 }
 
+float getAo(Material mtl, vec2 uv) {
+    float ao;
+    if (bool(mtl.hasAoMap)){
+        ao = texture(textureArrays[int(round(mtl.aoMap.x))].array, vec3(uv, round(mtl.aoMap.y))).a;
+    }
+    else {
+        ao = 1.0;
+    }
+    return ao;
+}
+
+float getRoughness(Material mtl, vec2 uv) {
+    float roughness;
+    if (bool(mtl.hasRoughnessMap)){
+        roughness = texture(textureArrays[int(round(mtl.roughnessMap.x))].array, vec3(uv, round(mtl.roughnessMap.y))).a;
+    }
+    else {
+        roughness = mtl.roughness;
+    }
+    return roughness;
+}
+
 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];
+    vec3 albedo     = getAlbedo(mtl, uv, gamma);
+    vec3 normal     = getNormal(mtl, TBN);
+    float ao        = getAo(mtl, uv);
+    float roughness = getRoughness(mtl, uv);
+    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;
@@ -224,17 +252,18 @@ void main() {
     // 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);
+        LightResult dirLightResult = PrincipledDiffuse(dirLights[i], mtl, albedo, roughness, 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.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);
+    lightResult.diffuse  *= ao;
 
     vec3 finalColor = albedo * 0.3 * mix(vec3(1.0), reflect_sky, mtl.metallicness);
     finalColor += (lightResult.diffuse + lightResult.specular + lightResult.clearcoat);

basilisk/shaders/batch.vert

@@ -34,6 +34,10 @@ struct Material {
     vec2  albedoMap;
     int   hasNormalMap;
     vec2  normalMap;
+    int   hasRoughnessMap;
+    vec2  roughnessMap;
+    int   hasAoMap;
+    vec2  aoMap;
 };
 flat out Material mtl;
 
@@ -83,11 +87,10 @@ void main() {
     uv       = in_uv;
     
     // Get the material
-    int mtl_size = 19;
+    int mtl_size = 25;
     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;
@@ -99,10 +102,14 @@ void main() {
     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);    
+    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);    
+    mtl.hasRoughnessMap = int(texelFetch(materialsTexture,  ivec2(0, 19  + materialID * mtl_size), 0).r);
+    mtl.roughnessMap    = vec2(texelFetch(materialsTexture, ivec2(0, 20  + materialID * mtl_size), 0).r, texelFetch(materialsTexture, ivec2(0, 21 + materialID * mtl_size), 0).r);    
+    mtl.hasAoMap        = int(texelFetch(materialsTexture,  ivec2(0, 22  + materialID * mtl_size), 0).r);
+    mtl.aoMap           = vec2(texelFetch(materialsTexture, ivec2(0, 23  + materialID * mtl_size), 0).r, texelFetch(materialsTexture, ivec2(0, 24 + materialID * mtl_size), 0).r);    
 
     // Set the fragment position
     gl_Position = projectionMatrix * viewMatrix * modelMatrix * vec4(in_position, 1.0);

basilisk/shaders/geometry.frag

@@ -0,0 +1,9 @@
+#version 330 core
+
+layout (location = 0) out vec4 fragColor;
+
+
+void main() {
+    // Output fragment color
+    fragColor = vec4(1.0, 1.0, 1.0, 1.0);
+}

basilisk/shaders/geometry.vert

@@ -0,0 +1,42 @@
+#version 330 core
+
+layout (location = 0) in vec3 in_position;
+
+layout (location = 5) in vec3  obj_position;
+layout (location = 6) in vec4  obj_rotation;
+layout (location = 7) in vec3  obj_scale;
+
+// Uniforms
+uniform mat4 projectionMatrix;
+uniform mat4 viewMatrix;
+
+// 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;
+}
+
+
+void main() {
+    // Set the model matrix
+    mat4 modelMatrix = getModelMatrix(obj_position, obj_rotation, obj_scale);
+    // Set the fragment position
+    gl_Position = projectionMatrix * viewMatrix * modelMatrix * vec4(in_position, 1.0);
+}

basilisk/shaders/normal.frag

@@ -0,0 +1,60 @@
+#version 330 core
+
+layout (location = 0) out vec4 fragColor;
+
+// Structs needed for the shader
+struct textArray {
+    sampler2DArray array;
+};
+
+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;
+    int   hasRoughnessMap;
+    vec2  roughnessMap;
+    int   hasAoMap;
+    vec2  aoMap;
+};
+in vec2 uv;
+in mat3 TBN;
+
+// Material attributes
+flat in Material mtl;
+
+// Uniforms
+uniform textArray textureArrays[5];
+
+
+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() {
+    // Get lighting vectors
+    vec3 normal    = getNormal(mtl, TBN);
+
+    // Output fragment color
+    fragColor = vec4(normal, 1.0);
+}

basilisk/shaders/normal.vert

@@ -0,0 +1,97 @@
+#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 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;
+    int   hasRoughnessMap;
+    vec2  roughnessMap;
+    int   hasAoMap;
+    vec2  aoMap;
+};
+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
+    TBN      = getTBN(modelMatrix, in_normal, in_tangent, in_bitangent);
+    uv       = in_uv;
+    
+    // Get the material
+    int mtl_size = 25;
+    mtl = Material(vec3(0), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, vec2(0), 0, vec2(0), 0, vec2(0), 0, vec2(0));
+    int materialID     = int(obj_material);
+    
+    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/particle.frag

@@ -0,0 +1,72 @@
+#version 330 core
+out vec4 fragColor;
+
+in vec2 uv;
+in vec3 position;
+in mat3 TBN;
+
+struct textArray {
+    sampler2DArray array;
+};
+uniform textArray textureArrays[5];
+
+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;
+    int   hasRoughnessMap;
+    vec2  roughnessMap;
+    int   hasAoMap;
+    vec2  aoMap;
+};
+flat in Material mtl;
+
+
+vec3 getColor(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()
+{   
+    // Texture and normal data
+    float gamma = 2.2;
+    vec3 color  = getColor(mtl, uv, gamma);
+    vec3 normal = getNormal(mtl, TBN);
+
+    // Simple light calculations
+    vec3 light = normalize(vec3(1.5, 2, 1));
+    float diff = abs(dot(normal, light));
+
+    // Get color and gamma correction
+    fragColor = vec4(color * (.2 + diff), 1.0);
+    fragColor.rgb = pow(fragColor.rgb, vec3(1.0/gamma));
+}

basilisk/shaders/particle.vert

@@ -0,0 +1,85 @@
+#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;
+
+
+in vec3  in_instance_pos;
+in float in_instance_mtl;
+in float scale;
+in float life;
+
+out vec2 uv;
+out mat3 TBN;
+
+uniform mat4 projectionMatrix;
+uniform mat4 viewMatrix;
+uniform sampler2D materialsTexture;
+
+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;
+    int   hasRoughnessMap;
+    vec2  roughnessMap;
+    int   hasAoMap;
+    vec2  aoMap;
+};
+flat out Material mtl;
+
+// Function to get the model matrix from node position, rotation, and scale
+mat4 getModelMatrix(vec3 pos, float scale) {
+    mat4 translation = mat4(
+        scale, 0    , 0    , 0,
+        0    , scale, 0    , 0,
+        0    , 0    , scale, 0,
+        pos.x, pos.y, pos.z, 1
+    );
+    return translation;
+}
+
+// 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(in_instance_pos, scale * life);
+
+    // Set out variables
+    TBN      = getTBN(modelMatrix, in_normal, in_tangent, in_bitangent);
+    uv       = in_uv;
+
+    // Material Data
+    int mtl_size = 25;
+    int materialID      = int(in_instance_mtl);
+    mtl = Material(vec3(0), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, vec2(0), 0, vec2(0), 0, vec2(0), 0, vec2(0));
+    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.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);    
+
+    // Send position to the frag
+    gl_Position = projectionMatrix * viewMatrix * modelMatrix * vec4(in_position, 1.0);
+}

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: basilisk-engine
-Version: 0.0.9
+Version: 0.1.1
 Summary: Python 3D Framework
 Home-page: https://basilisk-website.vercel.app/
 Author: Name
@@ -24,10 +24,10 @@ Basilisk Engine is a Python package for effortless 3D rendering and simulation.
 Basilisk Engine uses a versatile and efficient physically based rendering pipeline, allowing for photorealistic and stylized rendering in real-time.
 
 <p align="center">
-    <img src="mud.png" alt="mud" width="400"/>
-    <img src="foil.png" alt="foil" width="400"/>
-    <img src="cloth.png" alt="mud" width="400"/>
-    <img src="floor.png" alt="mud" width="400"/>
+    <img src="images/mud.png" alt="mud" width="400"/>
+    <img src="images/foil.png" alt="foil" width="400"/>
+    <img src="images/cloth.png" alt="mud" width="400"/>
+    <img src="images/floor.png" alt="mud" width="400"/>
 </p>
 
 ## Physics

basilisk_engine-0.1.1.dist-info/RECORD

@@ -0,0 +1,95 @@
+basilisk/__init__.py,sha256=FF8VVbZ74c3pj8Yg4rGmuAeuFGc00-MdCeic7lx5R8E,422
+basilisk/config.py,sha256=ynTRlX633DGoEtZOeAK8KNJF6offV3k3XFD7cia3Keg,61
+basilisk/engine.py,sha256=0tMlCyNhAZPm7Lq5vXCJmyv--lvOReeIh61KCdQMrD0,6551
+basilisk/scene.py,sha256=vSXCv-wc6OLO3vax03RLB7Gt6xaoCr_S5TZVxefRMp4,8324
+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=pg1oVzxrtOkp-rO0ltBKzBY6jXrbi7MS7fIfsyJskFI,3945
+basilisk/collisions/collider_handler.py,sha256=dPC11sznqHDK2UmXNXrcq6UP7qngeRJER-XnQqn6Hmk,11616
+basilisk/collisions/broad/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+basilisk/collisions/broad/broad_aabb.py,sha256=cyBCFFFkMY0yNDqBUY0HZ711m3QSSzoW2Ao9f8cFshE,4708
+basilisk/collisions/broad/broad_bvh.py,sha256=M7sMYRzxAwjIu_nkYKrL8HW3YxzBvfrSN1qKClNY568,5127
+basilisk/collisions/narrow/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+basilisk/collisions/narrow/contact_manifold.py,sha256=rBqFAKvCR8ksYs54GkjZf8GVzN7hoJ6ZLbjd4bDd39Q,4819
+basilisk/collisions/narrow/dataclasses.py,sha256=RFMwSy2q5VGtN36qMT0Qn6LeNEwBrp28aogGQExAyeQ,803
+basilisk/collisions/narrow/deprecated.py,sha256=yQh6VOoVcwYENU4TThk_pXPSmwT3EfxMKILVR43sEDI,2751
+basilisk/collisions/narrow/epa.py,sha256=kzKRs62kpTDqIqPz7Te1SV6OGWmfFb9Z7kZ1PqAMEwQ,4711
+basilisk/collisions/narrow/gjk.py,sha256=lncqQ4ZkmSa-wPlAUpkdzdSdbiJjiYKDTqqGSr9xRGc,3338
+basilisk/collisions/narrow/graham_scan.py,sha256=4cpsK2qbvLPw09LGXZp779Z536B-bpQciF-atZ4ngEI,862
+basilisk/collisions/narrow/helper.py,sha256=n_ZPGxKhkbubam5ya-OiUiLLejRVl9kdKbN19-_IiKY,1238
+basilisk/collisions/narrow/line_intersections.py,sha256=CGtttZ6n51u4l8JtQXzkClgZ_uvgx9IyrrGqli6JDbI,4629
+basilisk/collisions/narrow/sutherland_hodgman.py,sha256=SUjSU5y7AuzIDiljMcTXxlGuFHT5IwtrOJ_k5HS1S2Y,3140
+basilisk/draw/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+basilisk/draw/draw.py,sha256=S1eMkuOiM2M0GQTxb1LgFMX7OCDn3YsUCkNc6-t-ClU,3631
+basilisk/draw/draw_handler.py,sha256=kWIvocGY6-1gnqx-yEIGDEVSPURcLzfGYZs4WS7s0oY,7629
+basilisk/draw/font_renderer.py,sha256=gyI59fW3DUswIcSg5VJLLcJti3OLTMdXNQrYJaw18dE,1092
+basilisk/generic/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+basilisk/generic/abstract_bvh.py,sha256=iQ6HjcI8Msw34dZ3YuDAhWSqEc4NTBHAaGqAZZAoLL8,383
+basilisk/generic/abstract_custom.py,sha256=EPE2_2OxXyrx1YYO3niSxQ05ocxXnbAmFo7fr121Zxk,4537
+basilisk/generic/collisions.py,sha256=N0A2eShH4wkXXvYQcFB_dTTouYxQs51qb3CpWDyxiak,2659
+basilisk/generic/input_validation.py,sha256=-N2q1S1MMsrwBR9617waBe2VTVx4G3hkfVrN7bVB60o,1325
+basilisk/generic/math.py,sha256=_MfMdu1t0JIdGplGnU9_Tj4ECuxhSNmauLg8zw1zcNs,176
+basilisk/generic/matrices.py,sha256=NNvD0m6Y8lZLa5m6TeXI9k_pMJH0Bo2recL8eVqKjvo,1254
+basilisk/generic/meshes.py,sha256=0Zq5EkWEtqz-2V-kEQt-R3JZvUS5RTqflih8Mj9vL4o,2639
+basilisk/generic/quat.py,sha256=2yXZ5x1GjWQRCui0XDFITGWl9cf3W1KxTtMYfNMbU64,5110
+basilisk/generic/quat_methods.py,sha256=FFqS2Iy1OLH6oJf1elhH9RbWiE_KMXe5eO95ayrEhbc,241
+basilisk/generic/vec3.py,sha256=n_OAVVFtzH-ctqU8Pqhs2426MQ0WOgBbq2Lfo3Nt498,5280
+basilisk/input/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+basilisk/input/mouse.py,sha256=ReFzNjGpmmNnoyypLZXlG1TV380Y1tpQMqtKXfrxYcY,1900
+basilisk/mesh/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+basilisk/mesh/cube.py,sha256=UAwjEmaoWfUdtSKjxATU6vUbksDYj7_bBIr1k1xDsYc,1077
+basilisk/mesh/mesh.py,sha256=vujJ0VxwCvvIKBAScPzo8nWWAouyRzE97M4-JVpqco0,9782
+basilisk/mesh/mesh_from_data.py,sha256=uP7acL2jLELHCVCPgXMKzbSuluZL6azgJyn_VDanjM4,4425
+basilisk/mesh/model.py,sha256=uVnYm_XYSoZslNWmOego59Ku-gqKxZHpta_dHi65X1s,11993
+basilisk/mesh/narrow_aabb.py,sha256=0lc06JgdfhUbzxUnCz4dcbEYSB3xjAf7DY7ec2096is,3868
+basilisk/mesh/narrow_bvh.py,sha256=jLQhmUNi6mFyU2wVwB_SOf4PIaOAygBTtcnQIyaMOGg,4351
+basilisk/mesh/narrow_primative.py,sha256=vWpIeo8I9le-EAvcr9rFUQlbl9mi6eYroqCSMK-m9eY,953
+basilisk/nodes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+basilisk/nodes/node.py,sha256=ZrXv8bsM8Q_7CTuhRoRFXmVn3ZPsmvMgvLo-VxbcnYc,28529
+basilisk/nodes/node_handler.py,sha256=CWSD5aE7WeqkmTtd1zdObfpp1OlOzptLi705mWUt_nY,6148
+basilisk/particles/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+basilisk/particles/particle_handler.py,sha256=NlgY8pC3lEOfCqouLOJ4mRUBTGbBmCyDiFAp2hlcB2I,2413
+basilisk/particles/particle_renderer.py,sha256=3OpkKLw4NUik4stORqMkCx1vqibXkdYVq0NDDjigAdo,3623
+basilisk/physics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+basilisk/physics/impulse.py,sha256=zv6MoGTSlu8qVbsbe2QxERGeyQZYbtzR_WVSqVLsmhw,5873
+basilisk/physics/physics_body.py,sha256=_mi-AVMgQqUsC3bQIca5tgk2xWXTIUw0D_uC4DcQqqs,1508
+basilisk/physics/physics_engine.py,sha256=IPMshr4j5TII5JdcRqiULc6BfkeCLPxdICKqQeZGAtY,1735
+basilisk/render/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+basilisk/render/batch.py,sha256=Vmsm7zA2xi2xE4KKutxkasYfhnRNfyF8CI_HBIZNBIc,2998
+basilisk/render/camera.py,sha256=2LykskC-Xk6gXwYk0SWnzl0jzQxJCvPOWXYNASx9Ykk,7332
+basilisk/render/chunk.py,sha256=YNtoXrZN175u0USSCkpO3_0FiMrBIoaqMZl9XAoJLAA,2656
+basilisk/render/chunk_handler.py,sha256=-vlrlEDqZIoBom2YK8c1yu9sGb7AHH-IbkI4IWYYd5Y,6168
+basilisk/render/frame.py,sha256=OwgDtBK3EtXTD8e6o8chAl0Wu3fg-KwTEYQg1-r21y8,6728
+basilisk/render/image.py,sha256=_VB9e_2iRrjIQGS9cQa9V0xJ42x29AtYsu6GHSWLRRQ,2625
+basilisk/render/image_handler.py,sha256=T_rByRj4_Ce_pMXwBceGFUrhQbsr98Vx44OONobtm40,4267
+basilisk/render/light.py,sha256=hFqODv9iK4GEDZeDyBHxOWwwd4v8Pm089_xoScBMjVY,3879
+basilisk/render/light_handler.py,sha256=Le5InqqjgglSXUu7MwkVVsb7WbNJeRkRKldYDQGr6kg,2161
+basilisk/render/material.py,sha256=JmmwCxSYkPLHw73bH-7SzPo5ewzbU3QPTIvI_2pInXQ,9655
+basilisk/render/material_handler.py,sha256=dbfQs0u7qkEan0e0FsnqPpxbmkSNAQmH2B9jv4vx-bs,4242
+basilisk/render/shader.py,sha256=uFV1gv-MiWRG-nvv2akB0K2SrADWQ54vBYqHeJoy0PY,3913
+basilisk/render/shader_handler.py,sha256=YDl4XGsAUrA_JavmsG2nuoo6k8WyzKNsx20App-RVSk,2511
+basilisk/render/sky.py,sha256=TwLJ_6dYWCOAb06HZocrRdBzlbR6mQ0ojmmJgCC6im4,4910
+basilisk/shaders/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+basilisk/shaders/batch.frag,sha256=658z5GLegHDarroeqUpoiWDCCT2FHMr0ZHnYJ21qMhQ,9339
+basilisk/shaders/batch.vert,sha256=nUZKd5uBTFJm1aOG0auQRxE2ElhcAGf1YmepyzWeG8g,5403
+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/geometry.frag,sha256=Vh57G0r7Jj0uaTQEYuovZSgzOIJyZi-bzGvNsWZ--Oc,157
+basilisk/shaders/geometry.vert,sha256=2yPpezklovRQczpuf2pUhi4mMv3-YaOjDQCbrzdcdpk,1473
+basilisk/shaders/normal.frag,sha256=E6EwJUf76VCT8B_huuLfHRVRF7PkWxG1YGjdWh6sC44,1333
+basilisk/shaders/normal.vert,sha256=4BlcNsIw3fQFsZlfF7VZr6EAV2Y-M-72tXhfaE0uReM,3320
+basilisk/shaders/particle.frag,sha256=Cv8cWQpVVQvhZeWj3NqL0D5nLtSO3EWV0VzOU-ZVL4Y,1816
+basilisk/shaders/particle.vert,sha256=ElXzT7ywiZ0SjrFcUistVDBi4wOobQ7_J5O7XVxrsVs,3027
+basilisk/shaders/sky.frag,sha256=vTmZ1Xsd601_gmeBRfLYodHuBoBDI-M_1IybRt0ZDFk,178
+basilisk/shaders/sky.vert,sha256=v_BSdnMiljSJGPqno-J_apAiom38IrBzbDoxM7pIgwI,345
+basilisk_engine-0.1.1.dist-info/METADATA,sha256=SpvKfqw7cM2tzYG0duJeQZY5pmwPggRdVptnp_2PZIc,1146
+basilisk_engine-0.1.1.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
+basilisk_engine-0.1.1.dist-info/top_level.txt,sha256=enlSYSf7CUyAly1jmUCNNGInTbaFUjGk4SKwyckZQkw,9
+basilisk_engine-0.1.1.dist-info/RECORD,,