basilisk-engine 0.2.5__cp312-cp312-win_amd64.whl

basilisk/__init__.py

@@ -0,0 +1 @@
+from .basilisk import *

basilisk/basilisk.pyi

@@ -0,0 +1,403 @@
+"""
+pybind11 example plugin
+"""
+from __future__ import annotations
+import collections.abc
+import glm
+import typing
+__all__: list[str] = ['Collider', 'Contact', 'Edges', 'Engine', 'FeaturePair', 'Force', 'Image', 'Joint', 'Manifold', 'Material', 'Mesh', 'Motor', 'Node', 'Node2D', 'Rigid', 'Scene', 'Solver', 'Spring']
+class Collider:
+    def __init__(self, solver: Solver, vertices: collections.abc.Sequence[glm.vec2]) -> None:
+        ...
+    def getArea(self) -> float:
+        ...
+    def getBaseMoment(self) -> float:
+        ...
+    def getBaseRadius(self) -> float:
+        ...
+    def getCOM(self) -> glm.vec2:
+        ...
+    def getGC(self) -> glm.vec2:
+        ...
+    def getHalfDim(self) -> glm.vec2:
+        ...
+    def getMass(self, arg0: glm.vec2, arg1: typing.SupportsFloat) -> float:
+        ...
+    def getMoment(self, arg0: glm.vec2, arg1: typing.SupportsFloat) -> float:
+        ...
+    def getRadius(self, arg0: glm.vec2) -> float:
+        ...
+    def getVertices(self) -> list[glm.vec2]:
+        ...
+    def setArea(self, arg0: typing.SupportsFloat) -> None:
+        ...
+    def setBaseMoment(self, arg0: typing.SupportsFloat) -> None:
+        ...
+    def setCOM(self, arg0: glm.vec2) -> None:
+        ...
+    def setGC(self, arg0: glm.vec2) -> None:
+        ...
+    def setHalfDim(self, arg0: glm.vec2) -> None:
+        ...
+    def setVertices(self, arg0: collections.abc.Sequence[glm.vec2]) -> None:
+        ...
+class Contact:
+    C0: glm.vec2
+    feature: ...
+    normal: glm.vec2
+    rA: glm.vec2
+    rB: glm.vec2
+    stick: bool
+class Edges:
+    inEdge1: str
+    inEdge2: str
+    outEdge1: str
+    outEdge2: str
+class Engine:
+    def __init__(self, width: typing.SupportsInt, height: typing.SupportsInt, title: str, autoMouseGrab: bool = True) -> None:
+        ...
+    def getFrame(self) -> ...:
+        ...
+    def getKeyboard(self) -> ...:
+        ...
+    def getMouse(self) -> ...:
+        ...
+    def getResourceServer(self) -> ...:
+        ...
+    def getWindow(self) -> ...:
+        ...
+    def isRunning(self) -> bool:
+        ...
+    def render(self) -> None:
+        ...
+    def setResolution(self, arg0: typing.SupportsInt, arg1: typing.SupportsInt) -> None:
+        ...
+    def update(self) -> None:
+        ...
+    def useContext(self) -> None:
+        ...
+class FeaturePair:
+    e: ...
+    @property
+    def value(self) -> int:
+        ...
+    @value.setter
+    def value(self, arg0: typing.SupportsInt) -> None:
+        ...
+class Force:
+    def disable(self) -> None:
+        ...
+    def getBodyA(self) -> Rigid:
+        ...
+    def getBodyB(self) -> Rigid:
+        ...
+    def getC(self, arg0: typing.SupportsInt) -> float:
+        ...
+    def getFmax(self, arg0: typing.SupportsInt) -> float:
+        ...
+    def getFmin(self, arg0: typing.SupportsInt) -> float:
+        ...
+    def getFracture(self, arg0: typing.SupportsInt) -> float:
+        ...
+    def getH(self, arg0: typing.SupportsInt, arg1: Rigid) -> ...:
+        ...
+    def getJ(self, arg0: typing.SupportsInt, arg1: Rigid) -> glm.vec3:
+        ...
+    def getLambda(self, arg0: typing.SupportsInt) -> float:
+        ...
+    def getNext(self) -> Force:
+        ...
+    def getNextA(self) -> Force:
+        ...
+    def getNextB(self) -> Force:
+        ...
+    def getPenalty(self, arg0: typing.SupportsInt) -> float:
+        ...
+    def getPrev(self) -> Force:
+        ...
+    def getPrevA(self) -> Force:
+        ...
+    def getPrevB(self) -> Force:
+        ...
+    def getSolver(self) -> Solver:
+        ...
+    def getStiffness(self, arg0: typing.SupportsInt) -> float:
+        ...
+class Image:
+    def __init__(self, arg0: str) -> None:
+        ...
+    def getData(self) -> int:
+        ...
+    def getHeight(self) -> int:
+        ...
+    def getWidth(self) -> int:
+        ...
+class Joint(Force):
+    def __init__(self, solver: Solver, bodyA: Rigid, bodyB: Rigid, rA: glm.vec2, rB: glm.vec2, stiffness: glm.vec3 = ..., fracture: typing.SupportsFloat = ...) -> None:
+        ...
+    def getC0(self) -> glm.vec3:
+        ...
+    def getRA(self) -> glm.vec2:
+        ...
+    def getRB(self) -> glm.vec2:
+        ...
+    def getRestAngle(self) -> float:
+        ...
+    def getTorqueArm(self) -> float:
+        ...
+    def setC0(self, arg0: glm.vec3) -> None:
+        ...
+    def setRA(self, arg0: glm.vec2) -> None:
+        ...
+    def setRB(self, arg0: glm.vec2) -> None:
+        ...
+    def setRestAngle(self, arg0: typing.SupportsFloat) -> None:
+        ...
+    def setTorqueArm(self, arg0: typing.SupportsFloat) -> None:
+        ...
+class Manifold(Force):
+    @staticmethod
+    def collide(bodyA: Rigid, bodyB: Rigid, contacts: Contact) -> int:
+        ...
+    def __init__(self, solver: Solver, bodyA: Rigid, bodyB: Rigid) -> None:
+        ...
+    def getContact(self, arg0: typing.SupportsInt) -> Contact:
+        ...
+    def getContactRef(self, arg0: typing.SupportsInt) -> Contact:
+        ...
+    def getFriction(self) -> float:
+        ...
+    def getNumContacts(self) -> int:
+        ...
+class Material:
+    def __init__(self, color: glm.vec3 = ..., albedo: Image = None, normal: Image = None) -> None:
+        ...
+    def getAlbedo(self) -> Image:
+        ...
+    def getColor(self) -> glm.vec3:
+        ...
+    def getNormal(self) -> Image:
+        ...
+class Mesh:
+    def __init__(self, arg0: str, arg1: bool, arg2: bool) -> None:
+        ...
+    def get_indices(self) -> list[int]:
+        ...
+    def get_vertices(self) -> list[float]:
+        ...
+class Motor(Force):
+    def __init__(self, solver: Solver, bodyA: Rigid, bodyB: Rigid, speed: typing.SupportsFloat, maxTorque: typing.SupportsFloat) -> None:
+        ...
+    def getSpeed(self) -> float:
+        ...
+    def setSpeed(self, arg0: typing.SupportsFloat) -> None:
+        ...
+class Node:
+    @typing.overload
+    def __init__(self, scene: Scene, mesh: ... = None, material: ... = None, position: glm.vec3, rotation: glm.quat, scale: glm.vec3) -> None:
+        ...
+    @typing.overload
+    def __init__(self, parent: Node, mesh: ... = None, material: ... = None, position: glm.vec3, rotation: glm.quat, scale: glm.vec3) -> None:
+        ...
+    @typing.overload
+    def __init__(self, arg0: Scene, arg1: Node) -> None:
+        ...
+    def setPosition(self, arg0: glm.vec3) -> None:
+        ...
+    def setRotation(self, arg0: glm.quat) -> None:
+        ...
+    def setScale(self, arg0: glm.vec3) -> None:
+        ...
+class Node2D:
+    @typing.overload
+    def __init__(self, scene: ..., mesh: Mesh, material: Material, position: glm.vec2, rotation: typing.SupportsFloat, scale: glm.vec2, velocity: glm.vec3, collider: ..., density: typing.SupportsFloat, friction: typing.SupportsFloat) -> None:
+        ...
+    @typing.overload
+    def __init__(self, parent: Node2D, mesh: Mesh, material: Material, position: glm.vec2, rotation: typing.SupportsFloat, scale: glm.vec2, velocity: glm.vec3, collider: ..., density: typing.SupportsFloat, friction: typing.SupportsFloat) -> None:
+        ...
+    @typing.overload
+    def __init__(self, arg0: ..., arg1: Node2D) -> None:
+        ...
+    @typing.overload
+    def setPosition(self, arg0: glm.vec2) -> None:
+        ...
+    @typing.overload
+    def setPosition(self, arg0: glm.vec3) -> None:
+        ...
+    def setRotation(self, arg0: typing.SupportsFloat) -> None:
+        ...
+    def setScale(self, arg0: glm.vec2) -> None:
+        ...
+    def setVelocity(self, arg0: glm.vec3) -> None:
+        ...
+class Rigid:
+    def __init__(self, solver: Solver, node: Node2D, collider: Collider, position: glm.vec3, size: glm.vec2, density: typing.SupportsFloat, friction: typing.SupportsFloat, velocity: glm.vec3) -> None:
+        ...
+    def constrainedTo(self, arg0: Rigid) -> bool:
+        ...
+    def getAABB(self) -> tuple[glm.vec2, glm.vec2]:
+        ...
+    def getCollider(self) -> Collider:
+        ...
+    def getColor(self) -> int:
+        ...
+    def getDegree(self) -> int:
+        ...
+    def getDensity(self) -> float:
+        ...
+    def getForces(self) -> ...:
+        ...
+    def getFriction(self) -> float:
+        ...
+    def getIndex(self) -> int:
+        ...
+    def getInertial(self) -> glm.vec3:
+        ...
+    def getInitial(self) -> glm.vec3:
+        ...
+    def getMass(self) -> float:
+        ...
+    def getMoment(self) -> float:
+        ...
+    def getNext(self) -> Rigid:
+        ...
+    def getNextUnusedColor(self) -> int:
+        ...
+    def getNode(self) -> Node2D:
+        ...
+    def getPosition(self) -> glm.vec3:
+        ...
+    def getPrev(self) -> Rigid:
+        ...
+    def getPrevVelocity(self) -> glm.vec3:
+        ...
+    def getRadius(self) -> float:
+        ...
+    def getSatur(self) -> int:
+        ...
+    def getSize(self) -> glm.vec2:
+        ...
+    def getSolver(self) -> Solver:
+        ...
+    def getVel(self) -> glm.vec3:
+        ...
+    def getVelocity(self) -> glm.vec3:
+        ...
+    def incrSatur(self) -> None:
+        ...
+    def insert(self, arg0: ...) -> None:
+        ...
+    def isColorUsed(self, arg0: typing.SupportsInt) -> bool:
+        ...
+    def isColored(self) -> bool:
+        ...
+    def remove(self, arg0: ...) -> None:
+        ...
+    def reserveColors(self, arg0: typing.SupportsInt) -> None:
+        ...
+    def resetColoring(self) -> None:
+        ...
+    def setCollider(self, arg0: Collider) -> None:
+        ...
+    def setFriction(self, arg0: typing.SupportsFloat) -> None:
+        ...
+    def setInertial(self, arg0: glm.vec3) -> None:
+        ...
+    def setInitial(self, arg0: glm.vec3) -> None:
+        ...
+    def setMass(self, arg0: typing.SupportsFloat) -> None:
+        ...
+    def setMoment(self, arg0: typing.SupportsFloat) -> None:
+        ...
+    def setNode(self, arg0: Node2D) -> None:
+        ...
+    def setPosition(self, arg0: glm.vec3) -> None:
+        ...
+    def setPrevVelocity(self, arg0: glm.vec3) -> None:
+        ...
+    def setRadius(self, arg0: typing.SupportsFloat) -> None:
+        ...
+    def setScale(self, arg0: glm.vec2) -> None:
+        ...
+    def setVelocity(self, arg0: glm.vec3) -> None:
+        ...
+    def useColor(self, arg0: typing.SupportsInt) -> None:
+        ...
+    def verifyColoring(self) -> bool:
+        ...
+class Scene:
+    def __init__(self, arg0: Engine) -> None:
+        ...
+    def getCamera(self) -> ...:
+        ...
+    def getShader(self) -> ...:
+        ...
+    def render(self) -> None:
+        ...
+    def setCamera(self, arg0: ...) -> None:
+        ...
+    def update(self) -> None:
+        ...
+class Solver:
+    @staticmethod
+    def setGravity(*args, **kwargs) -> None:
+        ...
+    def __init__(self) -> None:
+        ...
+    def getAlpha(self) -> float:
+        ...
+    def getBeta(self) -> float:
+        ...
+    def getDt(self) -> float:
+        ...
+    def getGamma(self) -> float:
+        ...
+    def getGravity(self) -> ...:
+        ...
+    def getIterations(self) -> int:
+        ...
+    def getNumForces(self) -> int:
+        ...
+    def getNumRigids(self) -> int:
+        ...
+    def getPostStabilize(self) -> bool:
+        ...
+    @typing.overload
+    def insert(self, arg0: ...) -> None:
+        ...
+    @typing.overload
+    def insert(self, arg0: ...) -> None:
+        ...
+    @typing.overload
+    def remove(self, arg0: ...) -> None:
+        ...
+    @typing.overload
+    def remove(self, arg0: ...) -> None:
+        ...
+    def setAlpha(self, arg0: typing.SupportsFloat) -> None:
+        ...
+    def setBeta(self, arg0: typing.SupportsFloat) -> None:
+        ...
+    def setDt(self, arg0: typing.SupportsFloat) -> None:
+        ...
+    def setGamma(self, arg0: typing.SupportsFloat) -> None:
+        ...
+    def setIterations(self, arg0: typing.SupportsInt) -> None:
+        ...
+    def setPostStabilize(self, arg0: bool) -> None:
+        ...
+class Spring(Force):
+    def __init__(self, solver: Solver, bodyA: Rigid, bodyB: Rigid, rA: glm.vec2, rB: glm.vec2, stiffness: typing.SupportsFloat, rest: typing.SupportsFloat = -1.0) -> None:
+        ...
+    def getRA(self) -> glm.vec2:
+        ...
+    def getRB(self) -> glm.vec2:
+        ...
+    def getRest(self) -> float:
+        ...
+    def setRA(self, arg0: glm.vec2) -> None:
+        ...
+    def setRB(self, arg0: glm.vec2) -> None:
+        ...
+    def setRest(self, arg0: typing.SupportsFloat) -> None:
+        ...

basilisk/shaders/default.frag

@@ -0,0 +1,15 @@
+#version 330 core
+
+in vec3 normal;
+in vec2 uv;
+
+uniform sampler2D uTexture;
+
+out vec4 fragColor;
+
+void main() {
+    vec3 globalLight = normalize(vec3(.5, 1, .25));
+    float brightness = (dot(normal, globalLight) + 1) / 2;
+
+    fragColor = brightness * texture(uTexture, uv);
+} 

basilisk/shaders/default.vert

@@ -0,0 +1,19 @@
+#version 330 core
+
+layout (location = 0) in vec3 vPosition;
+layout (location = 1) in vec2 vUV;
+layout (location = 2) in vec3 vNormal;
+
+uniform mat4 uModel;
+uniform mat4 uView;
+uniform mat4 uProjection;
+
+out vec2 uv;
+out vec3 normal;
+
+void main() {
+    normal = vNormal;
+    uv = vUV;
+
+    gl_Position = uProjection * uView * uModel * vec4(vPosition, 1.0);
+}

basilisk/shaders/default2D.frag

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

basilisk/shaders/default2D.vert

@@ -0,0 +1,16 @@
+#version 330 core
+
+layout (location = 0) in vec3 vPosition;
+layout (location = 1) in vec2 vUV;
+
+
+uniform mat4 uModel;
+uniform mat4 uView;
+uniform mat4 uProjection;
+
+out vec2 uv;
+
+void main() {
+    uv = vUV;
+    gl_Position = uProjection * uView * uModel * vec4(vPosition, 1.0);
+}

basilisk/shaders/frame.frag

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

basilisk/shaders/frame.vert

@@ -0,0 +1,11 @@
+#version 330 core
+
+layout (location = 0) in vec2 vPosition;
+layout (location = 1) in vec2 vUV;
+
+out vec2 uv;
+
+void main() {
+    uv = vUV;
+    gl_Position = vec4(vPosition, 0.0, 1.0);
+}

basilisk/shaders/include/material.glsl

@@ -0,0 +1,52 @@
+#version 330
+
+uniform samplerBuffer materials;
+
+struct Material {
+    vec3 color;
+
+    uint albedoArray;
+    uint albedoIndex;
+    uint normalArray;
+    uint normalIndex;
+
+    float roughness;
+    float subsurface;
+    float sheen;
+    float sheenTint;
+    float anisotropic;
+    float specular;
+    float metallicness;
+    float clearcoat;
+    float clearcoatGloss;
+};
+
+Material getMaterial(int index) {
+    Material m;
+
+    int N = 4;  // N = (number of floats per material / 4)
+    int base = index * N;
+
+    vec4 v0 = texelFetch(materials, base + 0);
+    vec4 v1 = texelFetch(materials, base + 1);
+    vec4 v2 = texelFetch(materials, base + 2);
+    vec4 v3 = texelFetch(materials, base + 3);
+
+    // Unpack to struct fields:
+    m.color         = v0.rgb;
+    m.albedoArray   = floatBitsToUint(v0.a);
+    m.albedoIndex   = floatBitsToUint(v1.x);
+    m.normalArray   = floatBitsToUint(v1.y);
+    m.normalIndex   = floatBitsToUint(v1.z);
+    m.roughness     = v1.w;
+    m.subsurface    = v2.x;
+    m.sheen         = v2.y;
+    m.sheenTint     = v2.z;
+    m.anisotropic   = v2.w;
+    m.specular      = v3.x;
+    m.metallicness  = v3.y;
+    m.clearcoat     = v3.z;
+    m.clearcoatGloss= v3.w;
+
+    return m;
+}

basilisk/shaders/include/texture.glsl

@@ -0,0 +1,11 @@
+#include "material.glsl"
+
+struct textArray {
+    sampler2DArray array;
+};
+
+uniform textArray textureArrays[4];
+
+vec4 getTextureValue(Material material, vec2 uv) {
+    return texture(textureArrays[material.albedoArray].array, vec3(uv, material.albedoIndex)); 
+}

basilisk/shaders/instance.frag

@@ -0,0 +1,30 @@
+#version 330 core
+
+#include "include/material.glsl"
+#include "include/texture.glsl"
+
+in vec3 position;
+in vec2 uv;
+in vec3 normal;
+flat in Material material;
+
+uniform sampler2D uTexture;
+uniform vec3 uCameraPosition;
+uniform vec3 uViewDirection;
+
+out vec4 fragColor;
+
+void main() {
+    vec3 N = normalize(normal);
+    vec3 L = normalize(vec3(.5, 1.0, .25));
+    vec3 V = normalize(uCameraPosition - position);
+    vec3 H = normalize(L + V);
+
+    float ambient = 0.1;
+    float diffuse = max(dot(N, L), 0.0);
+    float specular = pow(max(dot(N, H), 0.0), 64);
+    float brightness = (ambient + diffuse + specular);
+
+    vec4 textureColor = getTextureValue(material, uv);
+    fragColor = vec4(brightness * textureColor.rgb, textureColor.a);
+} 

basilisk/shaders/instance.vert

@@ -0,0 +1,27 @@
+#version 330 core
+
+#include "include/material.glsl"
+
+layout (location = 0) in vec3 vPosition;
+layout (location = 1) in vec2 vUV;
+layout (location = 2) in vec3 vNormal;
+
+
+uniform mat4 uModel;
+uniform mat4 uView;
+uniform mat4 uProjection;
+uniform int uMaterialID;
+
+out vec3 position;
+out vec2 uv;
+out vec3 normal;
+flat out Material material;
+
+void main() {
+    position = vPosition;
+    uv = vUV;
+    normal = vNormal;
+    material = getMaterial(uMaterialID);
+
+    gl_Position = uProjection * uView * uModel * vec4(vPosition, 1.0);
+}

basilisk/shaders/instance2D.frag

@@ -0,0 +1,14 @@
+#version 330 core
+
+#include "include/material.glsl"
+#include "include/texture.glsl"
+
+in vec2 uv;
+flat in Material material;
+out vec4 fragColor;
+
+void main() {
+    vec4 textureColor = getTextureValue(material, uv);
+    if (textureColor.a <= 0.01) { discard; }
+    fragColor = textureColor;
+}

basilisk/shaders/instance2D.vert

@@ -0,0 +1,20 @@
+#version 330 core
+
+layout (location = 0) in vec3 vPosition;
+layout (location = 1) in vec2 vUV;
+
+#include "include/material.glsl"
+
+uniform mat4 uModel;
+uniform mat4 uView;
+uniform mat4 uProjection;
+uniform int uMaterialID;
+
+out vec2 uv;
+flat out Material material;
+
+void main() {
+    uv = vUV;
+    material = getMaterial(uMaterialID);
+    gl_Position = uProjection * uView * uModel * vec4(vPosition, 1.0);
+}

basilisk/shaders/test.frag

@@ -0,0 +1,15 @@
+#version 330 core
+
+in vec2 uv;
+
+struct textArray {
+    sampler2DArray array;
+};
+
+uniform textArray textureArrays[4];
+
+out vec4 fragColor;
+
+void main() {
+    fragColor = texture(textureArrays[1].array, vec3(uv, 0));
+} 

basilisk/shaders/test.vert

@@ -0,0 +1,11 @@
+#version 330 core
+
+layout (location = 0) in vec3 vPosition;
+layout (location = 1) in vec2 vUV;
+
+out vec2 uv;
+
+void main() {
+    uv = vUV;
+    gl_Position =  vec4(vPosition, 1.0);
+}