slifer 0.2.1 → 0.2.2

package/README.md

@@ -7,7 +7,7 @@
 > [!CAUTION]
 > Slifer is currently in alpha. Use at your own risk.
 
-> [!NOTE] 
+> [!NOTE]
 > Not all basic features have been implemented. Many are missing such as
 > window customization. As such, I recommend waiting for a beta release of
 > Slifer before using it for a long term project.
@@ -16,6 +16,8 @@ Slifer is a game framework made to allow users to code games in typescript. The
 framework uses bun and SDL2 under the hood to allow your game to render and
 build natively to desktop.
 
+If you'd like to learn more about Slifer, feel free to head to [Slifers Webpage](https://slifer.hazyvt.com).
+
 ## Contents
 
 - [Goals](#goals)
@@ -53,13 +55,13 @@ Slifer.createWindow("Example Window", 640, 480);
 const bg = Slifer.Graphics.makeColor(36, 36, 36, 255);
 
 while (!Slifer.shouldClose()) {
-  Slifer.Graphics.setBackground(bg);
+    Slifer.Graphics.setBackground(bg);
 
-  if (Slifer.Keyboard.isPressed("escape")) {
-    Slifer.isRunning = false;
-  }
+    if (Slifer.Keyboard.isPressed("escape")) {
+        Slifer.isRunning = false;
+    }
 
-  Slifer.Graphics.render();
+    Slifer.Graphics.render();
 }
 
 Slifer.quit();

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "slifer",
-    "version": "0.2.01",
+    "version": "0.2.2",
     "description": "A game framework made for bun and typescript",
     "module": "index.ts",
     "devDependencies": {

package/src/engine/renderer.ts

@@ -0,0 +1,40 @@
+import { type Pointer } from "bun:ffi";
+import { libsdl } from "../ffi";
+import Window from "./window";
+
+class Renderer {
+    static #instance: Renderer;
+    static #pointer: Pointer;
+
+    private constructor() {}
+
+    public static get instance() {
+        if (!Renderer.#instance) {
+            Renderer.#instance = new Renderer();
+        }
+
+        return Renderer.#instance;
+    }
+
+    public static get pointer() {
+        return Renderer.#pointer;
+    }
+
+    static createRenderer() {
+        const vsyncHint = 0x00000004;
+        const _ren = libsdl.symbols.SDL_CreateRenderer(
+            Window.pointer,
+            -1,
+            vsyncHint
+        );
+
+        if (_ren == null) throw `Renderer Creation Failed`;
+        Renderer.#pointer = _ren;
+    }
+
+    static clear() {
+        libsdl.symbols.SDL_RenderClear(Renderer.pointer);
+    }
+}
+
+export default Renderer;

package/src/engine/time.ts

@@ -0,0 +1,34 @@
+import { libsdl } from "../ffi";
+
+class Time {
+    static #instance: Time;
+
+    private lastframe: number = 0;
+    private firstFrame: number = 0;
+
+    private constructor() {}
+
+    public static get instance() {
+        if (!Time.#instance) {
+            Time.#instance = new Time();
+        }
+
+        return Time.#instance;
+    }
+
+    public init() {
+        this.firstFrame = Number(libsdl.symbols.SDL_GetPerformanceCounter());
+    }
+
+    public calcDelta(): number {
+        this.lastframe = this.firstFrame;
+        this.firstFrame = Number(libsdl.symbols.SDL_GetPerformanceCounter());
+        const deltaTime =
+            ((this.firstFrame - this.lastframe) * 1000) /
+            Number(libsdl.symbols.SDL_GetPerformanceFrequency());
+
+        return deltaTime;
+    }
+}
+
+export default Time;

package/src/engine/window.ts

@@ -0,0 +1,79 @@
+import { type Pointer } from "bun:ffi";
+import Vector2 from "./vector";
+import { libsdl } from "../ffi";
+
+class Window {
+    static #instance: Window;
+    static #pointer: Pointer;
+
+    private title!: string;
+    private size!: Vector2;
+
+    private static readonly centerPos = 0x2fff0000;
+
+    private constructor() {}
+
+    public static get instance() {
+        if (!Window.#instance) {
+            Window.#instance = new Window();
+        }
+
+        return Window.#instance;
+    }
+
+    public static get pointer() {
+        return Window.#pointer;
+    }
+
+    public static createWindow(title: string, size: Vector2): void {
+        Window.instance.title = title;
+        Window.instance.size = size;
+
+        // Create cstring by buffer from string
+        const _titleBuffer = new Buffer(Window.instance.title + "\x00");
+
+        // Create window pointer
+        const _winPointer = libsdl.symbols.SDL_CreateWindow(
+            _titleBuffer,
+            Window.centerPos,
+            Window.centerPos,
+            Window.instance.size.x,
+            Window.instance.size.y,
+            0
+        );
+
+        if (_winPointer == null) throw `Window Creation Failed`;
+        Window.#pointer = _winPointer;
+    }
+
+    public setSize(size: Vector2): void {
+        this.size = size;
+        libsdl.symbols.SDL_SetWindowSize(Window.pointer, size.x, size.y);
+    }
+
+    public setTitle(title: string): void {
+        this.title = title;
+        libsdl.symbols.SDL_SetWindowTitle(
+            Window.pointer,
+            Buffer.from(title + "\x00")
+        );
+    }
+
+    public setFullscreen(flag: boolean) {
+        libsdl.symbols.SDL_SetWindowFullscreen(Window.pointer, Number(flag));
+    }
+
+    public setPosition(position: Vector2) {
+        libsdl.symbols.SDL_SetWindowPosition(
+            Window.pointer,
+            position.x,
+            position.y
+        );
+    }
+
+    public centerWindow() {
+        this.setPosition(new Vector2(Window.centerPos, Window.centerPos));
+    }
+}
+
+export default Window;

package/src/engine.ts

@@ -1,24 +1,31 @@
-import { libsdl, libimage, libttf } from "./ffi";
-import Global from "./global";
+import { libsdl, libimage, libttf, libmixer } from "./ffi";
+import Graphics from "./modules/graphics";
 
-//@ts-expect-error
-const fontFile = await import("./Jost-Bold.ttf");
-
-export function initLibraries(): void {
-    const baseInit = libsdl.symbols.SDL_Init(0x00000020);
+export function initSDL() {
+    const initVideo = 0x00000020;
+    const initAudio = 0x00000010;
+    const baseInit = libsdl.symbols.SDL_Init(initVideo + initAudio);
     if (baseInit != 0) throw `SDL failed to initialize`;
+}
 
+export function initSDLImage() {
     const imageInit = libimage.symbols.IMG_Init(3);
     if (imageInit != 3) throw `SDL Image failed to initialize`;
+}
 
+export function initSDLTypeFont() {
     const ttfInit = libttf.symbols.TTF_Init();
     if (ttfInit != 0) throw `SDL TTF failed to initialize`;
+}
 
-    const tempFont = libttf.symbols.TTF_OpenFont(
-        Buffer.from(fontFile.default),
-        24
-    );
+export function initSDLMixer() {
+    const mixInit = libmixer.symbols.Mix_OpenAudio(22050, null, 2, 4096);
+    if (mixInit != 0) throw `SDL Audio failed to initialize`;
+}
 
-    if (tempFont == null) throw `Default font loading failed`;
-    Global.ptrFont = tempFont;
+export function initLibraries(): void {
+    initSDL();
+	initSDLImage();
+	initSDLTypeFont();
+	initSDLMixer();
 }