basilisk-engine 0.2.6__cp311-cp311-win32.whl → 0.2.10__cp311-cp311-win32.whl

basilisk/basilisk/key.pyi

@@ -0,0 +1,277 @@
+"""
+Keyboard key constants
+"""
+from __future__ import annotations
+import typing
+__all__: list[str] = ['K_0', 'K_1', 'K_2', 'K_3', 'K_4', 'K_5', 'K_6', 'K_7', 'K_8', 'K_9', 'K_A', 'K_B', 'K_BACKSPACE', 'K_C', 'K_CAPS_LOCK', 'K_D', 'K_E', 'K_ENTER', 'K_ESCAPE', 'K_F', 'K_F1', 'K_F10', 'K_F11', 'K_F12', 'K_F2', 'K_F3', 'K_F4', 'K_F5', 'K_F6', 'K_F7', 'K_F8', 'K_F9', 'K_G', 'K_H', 'K_I', 'K_J', 'K_K', 'K_L', 'K_LEFT_ALT', 'K_LEFT_CONTROL', 'K_LEFT_SHIFT', 'K_M', 'K_N', 'K_O', 'K_P', 'K_Q', 'K_R', 'K_RIGHT_ALT', 'K_RIGHT_CONTROL', 'K_RIGHT_SHIFT', 'K_S', 'K_SPACE', 'K_T', 'K_TAB', 'K_U', 'K_V', 'K_W', 'K_X', 'K_Y', 'K_Z', 'KeyCode']
+class KeyCode:
+    """
+    Members:
+    
+      K_A
+    
+      K_B
+    
+      K_C
+    
+      K_D
+    
+      K_E
+    
+      K_F
+    
+      K_G
+    
+      K_H
+    
+      K_I
+    
+      K_J
+    
+      K_K
+    
+      K_L
+    
+      K_M
+    
+      K_N
+    
+      K_O
+    
+      K_P
+    
+      K_Q
+    
+      K_R
+    
+      K_S
+    
+      K_T
+    
+      K_U
+    
+      K_V
+    
+      K_W
+    
+      K_X
+    
+      K_Y
+    
+      K_Z
+    
+      K_0
+    
+      K_1
+    
+      K_2
+    
+      K_3
+    
+      K_4
+    
+      K_5
+    
+      K_6
+    
+      K_7
+    
+      K_8
+    
+      K_9
+    
+      K_F1
+    
+      K_F2
+    
+      K_F3
+    
+      K_F4
+    
+      K_F5
+    
+      K_F6
+    
+      K_F7
+    
+      K_F8
+    
+      K_F9
+    
+      K_F10
+    
+      K_F11
+    
+      K_F12
+    
+      K_BACKSPACE
+    
+      K_TAB
+    
+      K_ENTER
+    
+      K_LEFT_SHIFT
+    
+      K_RIGHT_SHIFT
+    
+      K_LEFT_CONTROL
+    
+      K_RIGHT_CONTROL
+    
+      K_LEFT_ALT
+    
+      K_RIGHT_ALT
+    
+      K_CAPS_LOCK
+    
+      K_ESCAPE
+    
+      K_SPACE
+    """
+    K_0: typing.ClassVar[KeyCode]  # value = <KeyCode.K_0: 48>
+    K_1: typing.ClassVar[KeyCode]  # value = <KeyCode.K_1: 49>
+    K_2: typing.ClassVar[KeyCode]  # value = <KeyCode.K_2: 50>
+    K_3: typing.ClassVar[KeyCode]  # value = <KeyCode.K_3: 51>
+    K_4: typing.ClassVar[KeyCode]  # value = <KeyCode.K_4: 52>
+    K_5: typing.ClassVar[KeyCode]  # value = <KeyCode.K_5: 53>
+    K_6: typing.ClassVar[KeyCode]  # value = <KeyCode.K_6: 54>
+    K_7: typing.ClassVar[KeyCode]  # value = <KeyCode.K_7: 55>
+    K_8: typing.ClassVar[KeyCode]  # value = <KeyCode.K_8: 56>
+    K_9: typing.ClassVar[KeyCode]  # value = <KeyCode.K_9: 57>
+    K_A: typing.ClassVar[KeyCode]  # value = <KeyCode.K_A: 65>
+    K_B: typing.ClassVar[KeyCode]  # value = <KeyCode.K_B: 66>
+    K_BACKSPACE: typing.ClassVar[KeyCode]  # value = <KeyCode.K_BACKSPACE: 259>
+    K_C: typing.ClassVar[KeyCode]  # value = <KeyCode.K_C: 67>
+    K_CAPS_LOCK: typing.ClassVar[KeyCode]  # value = <KeyCode.K_CAPS_LOCK: 280>
+    K_D: typing.ClassVar[KeyCode]  # value = <KeyCode.K_D: 68>
+    K_E: typing.ClassVar[KeyCode]  # value = <KeyCode.K_E: 69>
+    K_ENTER: typing.ClassVar[KeyCode]  # value = <KeyCode.K_ENTER: 257>
+    K_ESCAPE: typing.ClassVar[KeyCode]  # value = <KeyCode.K_ESCAPE: 256>
+    K_F: typing.ClassVar[KeyCode]  # value = <KeyCode.K_F: 70>
+    K_F1: typing.ClassVar[KeyCode]  # value = <KeyCode.K_F1: 290>
+    K_F10: typing.ClassVar[KeyCode]  # value = <KeyCode.K_F10: 299>
+    K_F11: typing.ClassVar[KeyCode]  # value = <KeyCode.K_F11: 300>
+    K_F12: typing.ClassVar[KeyCode]  # value = <KeyCode.K_F12: 301>
+    K_F2: typing.ClassVar[KeyCode]  # value = <KeyCode.K_F2: 291>
+    K_F3: typing.ClassVar[KeyCode]  # value = <KeyCode.K_F3: 292>
+    K_F4: typing.ClassVar[KeyCode]  # value = <KeyCode.K_F4: 293>
+    K_F5: typing.ClassVar[KeyCode]  # value = <KeyCode.K_F5: 294>
+    K_F6: typing.ClassVar[KeyCode]  # value = <KeyCode.K_F6: 295>
+    K_F7: typing.ClassVar[KeyCode]  # value = <KeyCode.K_F7: 296>
+    K_F8: typing.ClassVar[KeyCode]  # value = <KeyCode.K_F8: 297>
+    K_F9: typing.ClassVar[KeyCode]  # value = <KeyCode.K_F9: 298>
+    K_G: typing.ClassVar[KeyCode]  # value = <KeyCode.K_G: 71>
+    K_H: typing.ClassVar[KeyCode]  # value = <KeyCode.K_H: 72>
+    K_I: typing.ClassVar[KeyCode]  # value = <KeyCode.K_I: 73>
+    K_J: typing.ClassVar[KeyCode]  # value = <KeyCode.K_J: 74>
+    K_K: typing.ClassVar[KeyCode]  # value = <KeyCode.K_K: 75>
+    K_L: typing.ClassVar[KeyCode]  # value = <KeyCode.K_L: 76>
+    K_LEFT_ALT: typing.ClassVar[KeyCode]  # value = <KeyCode.K_LEFT_ALT: 342>
+    K_LEFT_CONTROL: typing.ClassVar[KeyCode]  # value = <KeyCode.K_LEFT_CONTROL: 341>
+    K_LEFT_SHIFT: typing.ClassVar[KeyCode]  # value = <KeyCode.K_LEFT_SHIFT: 340>
+    K_M: typing.ClassVar[KeyCode]  # value = <KeyCode.K_M: 77>
+    K_N: typing.ClassVar[KeyCode]  # value = <KeyCode.K_N: 78>
+    K_O: typing.ClassVar[KeyCode]  # value = <KeyCode.K_O: 79>
+    K_P: typing.ClassVar[KeyCode]  # value = <KeyCode.K_P: 80>
+    K_Q: typing.ClassVar[KeyCode]  # value = <KeyCode.K_Q: 81>
+    K_R: typing.ClassVar[KeyCode]  # value = <KeyCode.K_R: 82>
+    K_RIGHT_ALT: typing.ClassVar[KeyCode]  # value = <KeyCode.K_RIGHT_ALT: 346>
+    K_RIGHT_CONTROL: typing.ClassVar[KeyCode]  # value = <KeyCode.K_RIGHT_CONTROL: 345>
+    K_RIGHT_SHIFT: typing.ClassVar[KeyCode]  # value = <KeyCode.K_RIGHT_SHIFT: 344>
+    K_S: typing.ClassVar[KeyCode]  # value = <KeyCode.K_S: 83>
+    K_SPACE: typing.ClassVar[KeyCode]  # value = <KeyCode.K_SPACE: 32>
+    K_T: typing.ClassVar[KeyCode]  # value = <KeyCode.K_T: 84>
+    K_TAB: typing.ClassVar[KeyCode]  # value = <KeyCode.K_TAB: 258>
+    K_U: typing.ClassVar[KeyCode]  # value = <KeyCode.K_U: 85>
+    K_V: typing.ClassVar[KeyCode]  # value = <KeyCode.K_V: 86>
+    K_W: typing.ClassVar[KeyCode]  # value = <KeyCode.K_W: 87>
+    K_X: typing.ClassVar[KeyCode]  # value = <KeyCode.K_X: 88>
+    K_Y: typing.ClassVar[KeyCode]  # value = <KeyCode.K_Y: 89>
+    K_Z: typing.ClassVar[KeyCode]  # value = <KeyCode.K_Z: 90>
+    __members__: typing.ClassVar[dict[str, KeyCode]]  # value = {'K_A': <KeyCode.K_A: 65>, 'K_B': <KeyCode.K_B: 66>, 'K_C': <KeyCode.K_C: 67>, 'K_D': <KeyCode.K_D: 68>, 'K_E': <KeyCode.K_E: 69>, 'K_F': <KeyCode.K_F: 70>, 'K_G': <KeyCode.K_G: 71>, 'K_H': <KeyCode.K_H: 72>, 'K_I': <KeyCode.K_I: 73>, 'K_J': <KeyCode.K_J: 74>, 'K_K': <KeyCode.K_K: 75>, 'K_L': <KeyCode.K_L: 76>, 'K_M': <KeyCode.K_M: 77>, 'K_N': <KeyCode.K_N: 78>, 'K_O': <KeyCode.K_O: 79>, 'K_P': <KeyCode.K_P: 80>, 'K_Q': <KeyCode.K_Q: 81>, 'K_R': <KeyCode.K_R: 82>, 'K_S': <KeyCode.K_S: 83>, 'K_T': <KeyCode.K_T: 84>, 'K_U': <KeyCode.K_U: 85>, 'K_V': <KeyCode.K_V: 86>, 'K_W': <KeyCode.K_W: 87>, 'K_X': <KeyCode.K_X: 88>, 'K_Y': <KeyCode.K_Y: 89>, 'K_Z': <KeyCode.K_Z: 90>, 'K_0': <KeyCode.K_0: 48>, 'K_1': <KeyCode.K_1: 49>, 'K_2': <KeyCode.K_2: 50>, 'K_3': <KeyCode.K_3: 51>, 'K_4': <KeyCode.K_4: 52>, 'K_5': <KeyCode.K_5: 53>, 'K_6': <KeyCode.K_6: 54>, 'K_7': <KeyCode.K_7: 55>, 'K_8': <KeyCode.K_8: 56>, 'K_9': <KeyCode.K_9: 57>, 'K_F1': <KeyCode.K_F1: 290>, 'K_F2': <KeyCode.K_F2: 291>, 'K_F3': <KeyCode.K_F3: 292>, 'K_F4': <KeyCode.K_F4: 293>, 'K_F5': <KeyCode.K_F5: 294>, 'K_F6': <KeyCode.K_F6: 295>, 'K_F7': <KeyCode.K_F7: 296>, 'K_F8': <KeyCode.K_F8: 297>, 'K_F9': <KeyCode.K_F9: 298>, 'K_F10': <KeyCode.K_F10: 299>, 'K_F11': <KeyCode.K_F11: 300>, 'K_F12': <KeyCode.K_F12: 301>, 'K_BACKSPACE': <KeyCode.K_BACKSPACE: 259>, 'K_TAB': <KeyCode.K_TAB: 258>, 'K_ENTER': <KeyCode.K_ENTER: 257>, 'K_LEFT_SHIFT': <KeyCode.K_LEFT_SHIFT: 340>, 'K_RIGHT_SHIFT': <KeyCode.K_RIGHT_SHIFT: 344>, 'K_LEFT_CONTROL': <KeyCode.K_LEFT_CONTROL: 341>, 'K_RIGHT_CONTROL': <KeyCode.K_RIGHT_CONTROL: 345>, 'K_LEFT_ALT': <KeyCode.K_LEFT_ALT: 342>, 'K_RIGHT_ALT': <KeyCode.K_RIGHT_ALT: 346>, 'K_CAPS_LOCK': <KeyCode.K_CAPS_LOCK: 280>, 'K_ESCAPE': <KeyCode.K_ESCAPE: 256>, 'K_SPACE': <KeyCode.K_SPACE: 32>}
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    def __init__(self, value: typing.SupportsInt) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __repr__(self) -> str:
+        ...
+    def __setstate__(self, state: typing.SupportsInt) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+K_0: KeyCode  # value = <KeyCode.K_0: 48>
+K_1: KeyCode  # value = <KeyCode.K_1: 49>
+K_2: KeyCode  # value = <KeyCode.K_2: 50>
+K_3: KeyCode  # value = <KeyCode.K_3: 51>
+K_4: KeyCode  # value = <KeyCode.K_4: 52>
+K_5: KeyCode  # value = <KeyCode.K_5: 53>
+K_6: KeyCode  # value = <KeyCode.K_6: 54>
+K_7: KeyCode  # value = <KeyCode.K_7: 55>
+K_8: KeyCode  # value = <KeyCode.K_8: 56>
+K_9: KeyCode  # value = <KeyCode.K_9: 57>
+K_A: KeyCode  # value = <KeyCode.K_A: 65>
+K_B: KeyCode  # value = <KeyCode.K_B: 66>
+K_BACKSPACE: KeyCode  # value = <KeyCode.K_BACKSPACE: 259>
+K_C: KeyCode  # value = <KeyCode.K_C: 67>
+K_CAPS_LOCK: KeyCode  # value = <KeyCode.K_CAPS_LOCK: 280>
+K_D: KeyCode  # value = <KeyCode.K_D: 68>
+K_E: KeyCode  # value = <KeyCode.K_E: 69>
+K_ENTER: KeyCode  # value = <KeyCode.K_ENTER: 257>
+K_ESCAPE: KeyCode  # value = <KeyCode.K_ESCAPE: 256>
+K_F: KeyCode  # value = <KeyCode.K_F: 70>
+K_F1: KeyCode  # value = <KeyCode.K_F1: 290>
+K_F10: KeyCode  # value = <KeyCode.K_F10: 299>
+K_F11: KeyCode  # value = <KeyCode.K_F11: 300>
+K_F12: KeyCode  # value = <KeyCode.K_F12: 301>
+K_F2: KeyCode  # value = <KeyCode.K_F2: 291>
+K_F3: KeyCode  # value = <KeyCode.K_F3: 292>
+K_F4: KeyCode  # value = <KeyCode.K_F4: 293>
+K_F5: KeyCode  # value = <KeyCode.K_F5: 294>
+K_F6: KeyCode  # value = <KeyCode.K_F6: 295>
+K_F7: KeyCode  # value = <KeyCode.K_F7: 296>
+K_F8: KeyCode  # value = <KeyCode.K_F8: 297>
+K_F9: KeyCode  # value = <KeyCode.K_F9: 298>
+K_G: KeyCode  # value = <KeyCode.K_G: 71>
+K_H: KeyCode  # value = <KeyCode.K_H: 72>
+K_I: KeyCode  # value = <KeyCode.K_I: 73>
+K_J: KeyCode  # value = <KeyCode.K_J: 74>
+K_K: KeyCode  # value = <KeyCode.K_K: 75>
+K_L: KeyCode  # value = <KeyCode.K_L: 76>
+K_LEFT_ALT: KeyCode  # value = <KeyCode.K_LEFT_ALT: 342>
+K_LEFT_CONTROL: KeyCode  # value = <KeyCode.K_LEFT_CONTROL: 341>
+K_LEFT_SHIFT: KeyCode  # value = <KeyCode.K_LEFT_SHIFT: 340>
+K_M: KeyCode  # value = <KeyCode.K_M: 77>
+K_N: KeyCode  # value = <KeyCode.K_N: 78>
+K_O: KeyCode  # value = <KeyCode.K_O: 79>
+K_P: KeyCode  # value = <KeyCode.K_P: 80>
+K_Q: KeyCode  # value = <KeyCode.K_Q: 81>
+K_R: KeyCode  # value = <KeyCode.K_R: 82>
+K_RIGHT_ALT: KeyCode  # value = <KeyCode.K_RIGHT_ALT: 346>
+K_RIGHT_CONTROL: KeyCode  # value = <KeyCode.K_RIGHT_CONTROL: 345>
+K_RIGHT_SHIFT: KeyCode  # value = <KeyCode.K_RIGHT_SHIFT: 344>
+K_S: KeyCode  # value = <KeyCode.K_S: 83>
+K_SPACE: KeyCode  # value = <KeyCode.K_SPACE: 32>
+K_T: KeyCode  # value = <KeyCode.K_T: 84>
+K_TAB: KeyCode  # value = <KeyCode.K_TAB: 258>
+K_U: KeyCode  # value = <KeyCode.K_U: 85>
+K_V: KeyCode  # value = <KeyCode.K_V: 86>
+K_W: KeyCode  # value = <KeyCode.K_W: 87>
+K_X: KeyCode  # value = <KeyCode.K_X: 88>
+K_Y: KeyCode  # value = <KeyCode.K_Y: 89>
+K_Z: KeyCode  # value = <KeyCode.K_Z: 90>

basilisk/basilisk.pyi

@@ -5,7 +5,8 @@ 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']
+import typing_extensions
+__all__: list[str] = ['Collider', 'Contact', 'EBO', 'Edges', 'Engine', 'FBO', 'FeaturePair', 'Force', 'Frame', 'Image', 'Joint', 'Manifold', 'Material', 'Mesh', 'Motor', 'Node', 'Node2D', 'Rigid', 'Scene', 'Shader', 'Solver', 'Spring', 'VAO', 'VBO']
 class Collider:
     def __init__(self, solver: Solver, vertices: collections.abc.Sequence[glm.vec2]) -> None:
         ...
@@ -48,6 +49,17 @@ class Contact:
     rA: glm.vec2
     rB: glm.vec2
     stick: bool
+class EBO:
+    def __init__(self, data: collections.abc.Sequence[typing.SupportsInt], drawType: typing.SupportsInt = 35044) -> None:
+        ...
+    def bind(self) -> None:
+        ...
+    def getSize(self) -> int:
+        ...
+    def unbind(self) -> None:
+        ...
+    def write(self, data: typing_extensions.CapsuleType, size: typing.SupportsInt, offset: typing.SupportsInt) -> None:
+        ...
 class Edges:
     inEdge1: str
     inEdge2: str
@@ -76,6 +88,25 @@ class Engine:
         ...
     def useContext(self) -> None:
         ...
+class FBO:
+    def __init__(self, width: typing.SupportsInt, height: typing.SupportsInt, components: typing.SupportsInt) -> None:
+        ...
+    def bind(self) -> None:
+        ...
+    def clear(self, r: typing.SupportsFloat, g: typing.SupportsFloat, b: typing.SupportsFloat, a: typing.SupportsFloat) -> None:
+        ...
+    def getDepthID(self) -> int:
+        ...
+    def getHeight(self) -> int:
+        ...
+    def getID(self) -> int:
+        ...
+    def getTextureID(self) -> int:
+        ...
+    def getWidth(self) -> int:
+        ...
+    def unbind(self) -> None:
+        ...
 class FeaturePair:
     e: ...
     @property
@@ -123,6 +154,39 @@ class Force:
         ...
     def getStiffness(self, arg0: typing.SupportsInt) -> float:
         ...
+class Frame:
+    def __init__(self, engine: Engine, width: typing.SupportsInt, height: typing.SupportsInt) -> None:
+        ...
+    def clear(self, r: typing.SupportsFloat, g: typing.SupportsFloat, b: typing.SupportsFloat, a: typing.SupportsFloat) -> None:
+        ...
+    def getAspectRatio(self) -> float:
+        ...
+    def getEBO(self) -> EBO:
+        ...
+    def getFBO(self) -> FBO:
+        ...
+    def getHeight(self) -> int:
+        ...
+    def getRenderHeight(self) -> int:
+        ...
+    def getRenderWidth(self) -> int:
+        ...
+    def getShader(self) -> Shader:
+        ...
+    def getVAO(self) -> VAO:
+        ...
+    def getVBO(self) -> VBO:
+        ...
+    def getWidth(self) -> int:
+        ...
+    @typing.overload
+    def render(self) -> None:
+        ...
+    @typing.overload
+    def render(self, x: typing.SupportsInt, y: typing.SupportsInt, width: typing.SupportsInt, height: typing.SupportsInt) -> None:
+        ...
+    def use(self) -> None:
+        ...
 class Image:
     def __init__(self, file: str) -> None:
         ...
@@ -338,6 +402,45 @@ class Scene:
         ...
     def update(self) -> None:
         ...
+class Shader:
+    @staticmethod
+    @typing.overload
+    def setUniform(*args, **kwargs) -> None:
+        ...
+    def __init__(self, vertexPath: str, fragmentPath: str) -> None:
+        ...
+    @typing.overload
+    def bind(self, name: str, texture: ..., slot: typing.SupportsInt) -> None:
+        ...
+    @typing.overload
+    def bind(self, name: str, textureArray: ..., slot: typing.SupportsInt) -> None:
+        ...
+    @typing.overload
+    def bind(self, name: str, tbo: ..., slot: typing.SupportsInt) -> None:
+        ...
+    @typing.overload
+    def bind(self, name: str, fbo: ..., slot: typing.SupportsInt) -> None:
+        ...
+    def getAttributes(self) -> ...:
+        ...
+    def getStride(self) -> int:
+        ...
+    def getUniformLocation(self, name: str) -> int:
+        ...
+    @typing.overload
+    def setUniform(self, name: str, value: typing.SupportsFloat) -> None:
+        ...
+    @typing.overload
+    def setUniform(self, name: str, value: typing.SupportsFloat) -> None:
+        ...
+    @typing.overload
+    def setUniform(self, name: str, value: typing.SupportsInt) -> None:
+        ...
+    @typing.overload
+    def setUniform(self, name: str, value: glm.vec3) -> None:
+        ...
+    def use(self) -> None:
+        ...
 class Solver:
     @staticmethod
     def setGravity(*args, **kwargs) -> None:
@@ -401,3 +504,33 @@ class Spring(Force):
         ...
     def setRest(self, arg0: typing.SupportsFloat) -> None:
         ...
+class VAO:
+    def __init__(self, shader: Shader, vertices: VBO, indices: EBO) -> None:
+        ...
+    def bind(self) -> None:
+        ...
+    def bindAttribute(self, location: typing.SupportsInt, count: typing.SupportsInt, dataType: typing.SupportsInt, stride: typing.SupportsInt, offset: typing.SupportsInt, divisor: typing.SupportsInt) -> None:
+        ...
+    def bindAttributes(self, attribs: ..., std: ..., std: ..., std: ..., std: ..., std: ..., divisor: typing.SupportsInt) -> None:
+        ...
+    @typing.overload
+    def bindBuffer(self, buffer: VBO, attribs: ..., std: ..., std: ..., std: ..., std: ..., std: ..., divisor: typing.SupportsInt) -> None:
+        ...
+    @typing.overload
+    def bindBuffer(self, buffer: VBO, indices: EBO, attribs: ..., std: ..., std: ..., std: ..., std: ..., std: ..., divisor: typing.SupportsInt) -> None:
+        ...
+    def render(self, instanceCount: typing.SupportsInt) -> None:
+        ...
+class VBO:
+    @typing.overload
+    def __init__(self, data: typing_extensions.CapsuleType, size: typing.SupportsInt, drawType: typing.SupportsInt) -> None:
+        ...
+    @typing.overload
+    def __init__(self, data: collections.abc.Sequence[typing.SupportsFloat], drawType: typing.SupportsInt = 35044) -> None:
+        ...
+    def bind(self) -> None:
+        ...
+    def getSize(self) -> int:
+        ...
+    def unbind(self) -> None:
+        ...

basilisk/shaders/include/blinn_phong.glsl

@@ -0,0 +1,41 @@
+#include "light.glsl"
+
+float getAttenuation(float distance, float range) {
+    float q = 1.0 / (range * range);
+    float attenuation = 1.0 / (1.0 + q * distance * distance);
+
+    float fade = 1.0 - smoothstep(0.8 * range, range, distance);
+    // float fade = clamp((range - distance) / (0.2 * range), 0.0, 1.0);
+    return attenuation * fade;
+}
+
+vec3 calculateDirectionalLight(DirectionalLight light, vec3 N, vec3 V) {
+    vec3 L = normalize(-light.direction);
+    vec3 H = normalize(L + V);
+
+    float diffuse = max(dot(N, L), 0.0);
+    float specular = pow(max(dot(N, H), 0.0), 64);
+
+    return light.color * light.intensity * (diffuse + specular);
+}
+
+vec3 calculatePointLight(PointLight light, vec3 fragPosition, vec3 N, vec3 V) {
+    vec3 toLight = light.position - fragPosition;
+    
+    float distSquared = dot(toLight, toLight);
+    float rangeSquared = light.range * light.range;
+    if (distSquared > rangeSquared) return vec3(0.0);
+
+    float distance = sqrt(distSquared);
+    vec3 L = toLight * inversesqrt(distSquared);
+    vec3 H = normalize(L + V);
+
+    
+    float ndotl = dot(N, L);
+    if (ndotl <= 0.0) return vec3(0.0);
+    float diffuse = max(ndotl, 0.0);
+    float specular = pow(max(dot(N, H), 0.0), 64);
+    float attenuation = getAttenuation(distance, light.range);
+
+    return light.color * light.intensity * attenuation * (diffuse + specular);
+}

basilisk/shaders/include/light.glsl

@@ -0,0 +1,72 @@
+#define MAX_DIRECTIONAL_LIGHTS 5
+#define TILE_SIZE 32
+
+uniform int uDirectionalLightCount;
+uniform int uPointLightCount;
+uniform usamplerBuffer uLightTiles;
+uniform usamplerBuffer uLightIndices;
+uniform samplerBuffer uPointLights;
+uniform vec3 uAmbientLight;
+
+struct DirectionalLight {
+    vec3 color;
+    float intensity;
+    vec3 direction;
+};
+
+struct PointLight {
+    vec3 color;
+    float intensity;
+    vec3 position;
+    float range;
+};
+
+struct AmbientLight {
+    vec3 color;
+};
+
+struct Tile {
+    uint offset;
+    uint count;
+};
+
+layout (std140) uniform uDirectionalLights {
+    DirectionalLight directionalLights[MAX_DIRECTIONAL_LIGHTS];
+};
+
+PointLight getPointLight(int index) {
+    vec4 t1 = texelFetch(uPointLights, 2 * index);
+    vec4 t2 = texelFetch(uPointLights, 2 * index + 1);
+
+    PointLight light;
+    light.color = t1.rgb;
+    light.intensity = t1.a;
+    light.position = t2.xyz;
+    light.range = t2.w;
+
+    return light;
+}
+
+Tile getTile() {
+    int tilesX = int(ceil(800.0 / float(TILE_SIZE)));
+
+    ivec2 tileCoord = ivec2(gl_FragCoord.xy) / TILE_SIZE;
+    int tileIndex = tileCoord.y * tilesX + tileCoord.x;
+
+    uvec4 texelData = texelFetch(uLightTiles, tileIndex);
+
+    Tile tile;
+    tile.offset = texelData.x;
+    tile.count  = texelData.y;
+    return tile;
+}
+
+PointLight getLightByIndex(uint linearIndex) {
+    int texelIndex = int(linearIndex) / 4;
+    int component  = int(linearIndex) % 4;
+
+    uvec4 texelData = texelFetch(uLightIndices, texelIndex);
+    uint lightIndex = texelData[component];
+
+    return getPointLight(int(lightIndex));
+}

basilisk/shaders/instance.frag

@@ -2,6 +2,8 @@
 
 #include "include/material.glsl"
 #include "include/texture.glsl"
+#include "include/light.glsl"
+#include "include/blinn_phong.glsl"
 
 in vec3 position;
 in vec2 uv;
@@ -15,16 +17,25 @@ uniform vec3 uViewDirection;
 out vec4 fragColor;
 
 void main() {
+    Tile tile = getTile();
+    vec4 textureColor = getTextureValue(material, uv);
+    
     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);
+    vec3 directionalLightColor = vec3(0.0, 0.0, 0.0);
+    for (int i = 0; i < uDirectionalLightCount; i++) {
+        DirectionalLight directionalLight = directionalLights[i];
+        directionalLightColor += calculateDirectionalLight(directionalLight, N, V);
+    }
+    
+    vec3 pointLightColor = vec3(0.0, 0.0, 0.0);
+    for (uint i = tile.offset; i < tile.offset + tile.count; i++) {
+        PointLight pointLight = getLightByIndex(i);
+        pointLightColor += calculatePointLight(pointLight, position, N, V);
+    }
 
-    vec4 textureColor = getTextureValue(material, uv);
-    fragColor = vec4(brightness * textureColor.rgb, textureColor.a);
+    vec3 ambientColor = uAmbientLight;
+
+    fragColor = vec4((directionalLightColor + pointLightColor + ambientColor) * textureColor.rgb, textureColor.a);
 } 

basilisk/shaders/instance.vert

@@ -18,9 +18,9 @@ out vec3 normal;
 flat out Material material;
 
 void main() {
-    position = vPosition;
+    position = (uModel * vec4(vPosition, 1.0)).xyz;
     uv = vUV;
-    normal = vNormal;
+    normal = (uModel * vec4(vNormal, 0.0)).xyz;
     material = getMaterial(uMaterialID);
 
     gl_Position = uProjection * uView * uModel * vec4(vPosition, 1.0);

basilisk/shaders/skybox.frag

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

basilisk/shaders/skybox.vert

@@ -0,0 +1,14 @@
+#version 330 core
+
+layout (location = 0) in vec3 vPosition;
+
+uniform mat4 uProjection;
+uniform mat4 uView;
+
+out vec3 uv;
+
+void main() {
+    uv = vPosition;
+    gl_Position = uProjection * uView * vec4(vPosition, 1.0);
+    // gl_Position = pos.xyww;
+}  

basilisk/shaders/test.frag

@@ -1,15 +1,16 @@
 #version 330 core
 
-in vec2 uv;
-
-struct textArray {
-    sampler2DArray array;
+struct Color {
+    vec4 value;
 };
 
-uniform textArray textureArrays[4];
+layout (std140) uniform testBlock {
+    Color colors[2];
+};
 
+in vec2 uv;
 out vec4 fragColor;
 
 void main() {
-    fragColor = texture(textureArrays[1].array, vec3(uv, 0));
-} 
+    fragColor = vec4(vec3(1.0, uv), 1.0) * colors[1].value;
+}

basilisk/shaders/test.vert

@@ -7,5 +7,6 @@ out vec2 uv;
 
 void main() {
     uv = vUV;
-    gl_Position =  vec4(vPosition, 1.0);
+
+    gl_Position = vec4(vPosition, 1.0);
 }