basilisk-engine 0.0.1__py3-none-any.whl

basilisk/__init__.py

@@ -0,0 +1,11 @@
+from .engine import Engine
+from .scene import Scene
+from .nodes.node import Node
+from .mesh.mesh import Mesh
+from .mesh.cube import cube
+from .render.image import Image
+from .render.material import Material
+from .render.shader_handler import ShaderHandler
+from .draw import draw
+from .render.camera import FreeCamera, StaticCamera
+from .render.sky import Sky

basilisk/config.py

@@ -0,0 +1,3 @@
+class Config():
+    def __init__(self) -> None:
+        ...

basilisk/engine.py

@@ -0,0 +1,171 @@
+import os
+os.environ['PYGAME_HIDE_SUPPORT_PROMPT'] = "hide"
+import pygame as pg
+import moderngl as mgl
+from .config import Config
+from .input.mouse import Mouse
+import time
+
+class Engine():
+    win_size: tuple
+    """Size of the engine window in pixels"""
+    ctx: mgl.Context
+    """ModernGL context used by the engine"""
+    scene: any
+    """Scene currently being updated and rendered by the engine"""
+    clock: pg.Clock
+    """Pygame clock used to keep track of time between frames"""
+    config: Config
+    """Object containing all global attributes"""
+    delta_time: float
+    """Time in seconds that passed between the last frame"""
+    time: float
+    """Total time the engine has been running"""
+    running: bool
+    """True if the engine is still running"""
+    events: list
+    """List of all pygame"""
+    keys: list
+    """bool list containing the state of all keys this frame"""
+    previous_keys: list
+    """bool list containing the state of all keys at the previous frame"""
+    mouse: Mouse
+    """Object containing information about the user's mouse"""
+    root: str
+    """Path to the root directory containing internal data"""
+
+    def __init__(self, win_size=(800, 800), title="Basilisk Engine", vsync=False, grab_mouse=True, headless=False) -> None:
+        """
+        Basilisk Engine Class. Sets up the engine enviornment and allows the user to interact with Basilisk
+        Args:
+            win_size: tuple
+                The initial window size of the engine
+            title: str
+                The title of the engine window
+            vsync: bool
+                Flag for running engine with vsync enabled
+            headless: bool
+                Flag for headless rendering
+        """
+        # Save the window size
+        self.win_size = win_size
+
+        pg.init()  
+        # Initialize pygame and OpenGL attributes
+        pg.display.gl_set_attribute(pg.GL_CONTEXT_MAJOR_VERSION, 3)
+        pg.display.gl_set_attribute(pg.GL_CONTEXT_MINOR_VERSION, 3)
+        pg.display.gl_set_attribute(pg.GL_CONTEXT_PROFILE_MASK, pg.GL_CONTEXT_PROFILE_CORE)
+        # Pygame display init
+        if headless:
+            pg.display.set_mode((300, 50), vsync=vsync, flags=pg.OPENGL | pg.DOUBLEBUF)
+            pg.display.iconify()
+        else:
+            pg.display.set_mode(self.win_size, vsync=vsync, flags=pg.OPENGL | pg.DOUBLEBUF | pg.RESIZABLE)
+        pg.display.set_caption(title)
+        pg.display.set_icon(pg.image.load("basilisk.png"))
+
+        # MGL context setup
+        self.ctx = mgl.create_context()
+        self.ctx.enable(flags=mgl.DEPTH_TEST | mgl.CULL_FACE | mgl.BLEND)
+
+        # Global attributes referenced by the handlers
+        self.headless = headless
+        self.set_configurations()
+        self.root = os.path.dirname(__file__)
+        print(self.root)
+
+        # Time variables
+        self.clock = pg.time.Clock()
+        self.delta_time = 0
+        self.time = 0
+
+        # Initialize input lists
+        self.keys = pg.key.get_pressed()
+        self.previous_keys = self.keys
+        self.mouse = Mouse(grab=grab_mouse)
+
+        # Scene being used by the engine
+        self.scene = None
+
+        # Set the scene to running
+        self.running = True
+
+    def update(self) -> None:
+        """
+        Updates all input, physics, and time variables. Renders the current scene.
+        """
+
+        # Tick the clock and get delta time
+        self.delta_time = self.clock.tick() / 1000
+        self.time += self.delta_time
+        pg.display.set_caption(f"FPS: {round(self.clock.get_fps())}")
+
+        # Get inputs and events
+        self.events = pg.event.get()
+        self.keys = pg.key.get_pressed()
+        self.mouse.update(self.events)
+        
+        # Loop through all pygame events
+        for event in self.events:
+            if event.type == pg.QUIT: # Quit the engine
+                self.quit()
+                return
+            if event.type == pg.VIDEORESIZE:
+                # Updates the viewport
+                self.win_size = (event.w, event.h)
+                self.ctx.viewport = (0, 0, event.w, event.h)
+                self.scene.camera.use()
+                self.scene.frame.set_textures()
+
+
+        # Update the scene if possible
+        if self.scene: self.scene.update()
+        # Render after the scene and engine has been updated
+        self.render()
+
+        # Update the previous input lists for the next frame
+        self.previous_keys = self.keys
+
+    def render(self) -> None:
+        """
+        Renders the scene currently being used by the engine
+        """
+        
+        # Set the ctx for rendering
+        self.ctx.screen.use()
+        self.ctx.clear()
+
+        # Render the scene
+        if self.scene:self.scene.render()
+
+        # Flip pygame display buffer
+        pg.display.flip()
+
+    def set_configurations(self):
+        """
+        Sets global configurations. These attributs are not used by the engine, just the handlers
+        """
+
+        # Create a config object
+        self.config = Config()
+
+        # Set the attributes on the config object
+        setattr(self.config, "chunk_size", 40)
+        setattr(self.config, "render_distance", 5)
+
+    def quit(self) -> None:
+        """
+        Stops the engine and releases all memory
+        """
+
+        pg.quit()
+        self.ctx.release()
+        self.running = False
+
+    @property
+    def scene(self): return self._scene
+    
+    @scene.setter
+    def scene(self, value):
+        self._scene = value
+        if self._scene: self._scene.set_engine(self)

basilisk/scene.py

@@ -0,0 +1,128 @@
+import moderngl as mgl
+import glm
+from .render.shader_handler import ShaderHandler
+from .mesh.mesh import Mesh
+from .render.material import Material
+from .render.material_handler import MaterialHandler
+from .render.light_handler import LightHandler
+from .render.camera import Camera, FreeCamera
+from .nodes.node_handler import NodeHandler
+from .physics.physics_engine import PhysicsEngine
+from .collisions.collider_handler import ColliderHandler
+from .draw.draw_handler import DrawHandler
+from .render.sky import Sky
+from .render.frame import Frame
+
+
+class Scene():
+    engine: any
+    """Parent engine of the scene"""
+    ctx: mgl.Context
+    """Reference to the engine context"""
+
+    def __init__(self) -> None:
+        """
+        Basilisk scene object. Contains all nodes for the scene
+        """
+
+        self.engine = None
+        self.ctx    = None
+
+        self.camera           = None
+        self.shader_handler   = None
+        self.node_handler     = None
+        self.material_handler = None
+        self.light_handler    = None
+        self.draw_handler     = None
+        self.sky              = None
+        self.frame            = None
+
+    def update(self) -> None:
+        """
+        Updates the physics and in the scene
+        """
+        
+        self.camera.update()
+        self.node_handler.update()
+
+    def render(self) -> None:
+        """
+        Renders all the nodes with meshes in the scene
+        """
+
+        self.frame.use()
+        self.shader_handler.write()
+        self.sky.render()
+        self.node_handler.render()
+        self.draw_handler.render()
+
+        if self.engine.headless: return
+        self.frame.render()
+    
+    def add_node(self, 
+            position:            glm.vec3=None, 
+            scale:               glm.vec3=None, 
+            rotation:            glm.quat=None, 
+            forward:             glm.vec3=None, 
+            mesh:                Mesh=None, 
+            material:            Material=None, 
+            velocity:            glm.vec3=None, 
+            rotational_velocity: glm.quat=None, 
+            physics:             bool=False, 
+            mass:                float=None, 
+            collisions:          bool=False, 
+            collider:            str=None, 
+            static_friction:     float=None, 
+            kinetic_friction:    float=None, 
+            elasticity:          float=None, 
+            collision_group :    float=None, 
+            name:                str='', 
+            tags:                list[str]=None,
+            static:              bool=True):
+        
+        if material: self.material_handler.add(material)
+        else: material = self.material_handler.base
+
+        return self.node_handler.add(position, scale, rotation, forward, mesh, material, velocity, rotational_velocity, physics, mass, collisions, collider, static_friction, kinetic_friction, elasticity, collision_group, name, tags, static)
+
+
+    def set_engine(self, engine: any) -> None:
+        """
+        Sets the back references to the engine and creates handlers with the context
+        """
+
+        self.engine = engine
+        self.ctx    = engine.ctx
+
+        self.camera           = FreeCamera()
+        self.shader_handler   = ShaderHandler(self)
+        self.physics_engine   = PhysicsEngine()
+        self.node_handler     = NodeHandler(self)
+        self.collider_handler = ColliderHandler(self)
+        self.material_handler = MaterialHandler(self)
+        self.light_handler    = LightHandler(self)
+        self.draw_handler     = DrawHandler(self)
+        self.frame            = Frame(self)
+        self.sky              = Sky(self.engine)
+
+    @property
+    def camera(self): return self._camera
+    @property
+    def sky(self): return self._sky
+
+    @camera.setter
+    def camera(self, value: Camera):
+        if not value: return
+        if not isinstance(value, Camera):
+            raise TypeError(f'Scene: Invalid camera type: {type(value)}. Expected type bsk.Camera')
+        self._camera = value
+        self._camera.scene = self
+
+    @sky.setter
+    def sky(self, value: Sky):
+        if not value: return
+        if not isinstance(value, Sky):
+            raise TypeError(f'Scene: Invalid sky type: {type(value)}. Expected type bsk.Sky')
+        self._sky = value
+        self._sky.write()
+

basilisk_engine-0.0.1.dist-info/METADATA

@@ -0,0 +1,38 @@
+Metadata-Version: 2.1
+Name: basilisk-engine
+Version: 0.0.1
+Summary: Python 3D Framework
+Home-page: https://basilisk-website.vercel.app/
+Author: Name
+Author-email: basiliskengine@gmail.com
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: pillow
+Requires-Dist: pygame-ce
+Requires-Dist: moderngl
+Requires-Dist: PyGLM
+Requires-Dist: numba
+
+# Basilisk Engine
+![image](https://github.com/user-attachments/assets/5e39445c-e0da-452c-9f18-e590cca948c4)
+Basilisk Engine is a Python package for effortless 3D rendering and simulation.
+
+## Learn more at the [Basilisk Engine Website](https://basilisk-website.vercel.app)
+
+# Features
+## Rendering
+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"/>
+</p>
+
+## Physics
+
+## Performance
+
+# Getting Started
+...

basilisk_engine-0.0.1.dist-info/RECORD

@@ -0,0 +1,8 @@
+basilisk/__init__.py,sha256=hJVKd8NebPIdDzhfRMZsOElR5w2wGkrsW7WJqb0tpB0,368
+basilisk/config.py,sha256=ynTRlX633DGoEtZOeAK8KNJF6offV3k3XFD7cia3Keg,61
+basilisk/engine.py,sha256=R1COiHLHNgsfIJ72U_XxAR2oftBRsVYyYOrVqTr48Xc,5709
+basilisk/scene.py,sha256=ow3w2ZouBdn7E1xw39-aMu7_gbsnDxzeNi1mqbYqa-M,4452
+basilisk_engine-0.0.1.dist-info/METADATA,sha256=HFZUa45YFHSowm4nExijxFuTmQMU6JioaHB4Js201OY,1118
+basilisk_engine-0.0.1.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
+basilisk_engine-0.0.1.dist-info/top_level.txt,sha256=enlSYSf7CUyAly1jmUCNNGInTbaFUjGk4SKwyckZQkw,9
+basilisk_engine-0.0.1.dist-info/RECORD,,

basilisk_engine-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.2.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

basilisk_engine-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+basilisk