slifer 0.2.0 → 0.2.2

package/src/modules/graphics.ts

@@ -1,17 +1,27 @@
 import { libimage, libsdl, libttf } from "../ffi";
-import Global from "../global";
 import { type Pointer, ptr } from "bun:ffi";
 import Rectangle from "../engine/rectangle";
 import Color from "../color";
 import Vector2 from "../engine/vector";
+import Renderer from "../engine/renderer";
 
-/** @internal */
 class Graphics {
+    static #instance: Graphics;
+
+    static #fontPointer: Pointer;
+
+    public static get instance() {
+        if (!Graphics.#instance) {
+            Graphics.#instance = new Graphics();
+        }
+
+        return Graphics.#instance;
+    }
     /**
      * Slifers draw function. Used to draw everything to the screen.
      */
-    render() {
-        libsdl.symbols.SDL_RenderPresent(Global.ptrRenderer);
+    public render() {
+        libsdl.symbols.SDL_RenderPresent(Renderer.pointer);
     }
 
     /**
@@ -23,7 +33,7 @@ class Graphics {
      * @param a alpha value
      * @returns Color object
      */
-    makeColor(r: number, g: number, b: number, a: number) {
+    public makeColor(r: number, g: number, b: number, a: number) {
         const _color = new Color(r, g, b, a);
         return _color;
     }
@@ -36,15 +46,15 @@ class Graphics {
      *
      * @param color Color object. Make using Slifer.Graphics.makeColor
      */
-    setBackground(color: Color) {
+    public setBackground(color: Color) {
         libsdl.symbols.SDL_SetRenderDrawColor(
-            Global.ptrRenderer,
+            Renderer.pointer,
             color.r,
             color.g,
             color.b,
             color.a
         );
-        libsdl.symbols.SDL_RenderClear(Global.ptrRenderer);
+        libsdl.symbols.SDL_RenderClear(Renderer.pointer);
     }
 
     /**
@@ -53,156 +63,93 @@ class Graphics {
      * @param path string path to image
      * @returns Image ready to draw
      */
-    loadImage(path: string): Image {
+    public loadImage(path: string): Image {
         const _path = Buffer.from(path + "\x00");
         const surface = libimage.symbols.IMG_Load(_path);
         if (surface == null) throw `Image failed to load`;
         const texture = libsdl.symbols.SDL_CreateTextureFromSurface(
-            Global.ptrRenderer,
+            Renderer.pointer,
             surface
         );
         if (texture == null) throw `Image failed to be created`;
         return new Image(texture);
     }
 
-    draw(image: Image, position: Vector2) {}
-
     /**
-     * Method to draw the image to the screen
+     * Method to draw to the screen simply
      *
      * @param image Image object to draw. Made using Slifer.Graphics.loadImage
-     * @param x x position to draw image
-     * @param y y position to draw image
-     * @param rotation (optional) rotation of image
-     * @param xs (optional) scale of x axis
-     * @param ys (optional) scale of y axis
-     * @param flip (optional) horizontal flip
-     */
-    drawEx(
-        image: Image,
-        position: Vector2,
-        clipRectangle?: Rectangle,
-        rotation?: number,
-        xs?: number,
-        ys?: number,
-        flip?: true
-    ) {
-        const _dest = new Uint32Array(4);
-        const wArr = new Uint32Array(1);
-        const hArr = new Uint32Array(1);
-        let srcRect: null | Uint32Array = null;
-
-        if (clipRectangle == undefined) {
-            libsdl.symbols.SDL_QueryTexture(
-                (image as any).pointer,
-                null,
-                null,
-                ptr(wArr),
-                ptr(hArr)
-            );
-        } else {
-            srcRect = new Uint32Array(4);
-            srcRect[0] = clipRectangle.x;
-            srcRect[1] = clipRectangle.y;
-            srcRect[2] = clipRectangle.width;
-            srcRect[3] = clipRectangle.height;
-            wArr[0] = clipRectangle.width;
-            hArr[0] = clipRectangle.height;
-        }
-
-        _dest[0] = position.x;
-        _dest[1] = position.y;
-        _dest[2] = wArr[0] * (xs ? xs : 1);
-        _dest[3] = hArr[0] * (ys ? ys : 1);
-        const _center = new Uint32Array(2);
-        _center[0] = _dest[2] / 2;
-        _center[1] = _dest[3] / 2;
-        libsdl.symbols.SDL_RenderCopyEx(
-            Global.ptrRenderer,
-            (image as any).pointer,
-            srcRect,
-            ptr(_dest),
-            rotation ? rotation : 0,
-            ptr(_center),
-            flip ? Number(flip) : 0
-        );
-    }
-
-    /**
-     * Method to draw text to the screen
+     * @param position position to draw the image
      *
-     * @param text the string of text to print
-     * @param x x position
-     * @param y y position
-     * @param color color of text. Made using Slifer.Graphics.makeColor.
      */
-    print(text: string, x: number, y: number, color: Color) {
-        // Create text buffer
-        const textBuffer = Buffer.from(text + "\x00");
-
-        // Get width and height of text
-        const wArr = new Uint32Array(1);
-        const hArr = new Uint32Array(1);
-        libttf.symbols.TTF_SizeText(
-            Global.ptrFont,
-            textBuffer,
-            ptr(wArr),
-            ptr(hArr)
-        );
-
-        // Define color
-        const _col = (color.r << 0) + (color.g << 8) + (color.b << 16);
-
-        // Create texture
-        const surface = libttf.symbols.TTF_RenderText_Solid(
-            Global.ptrFont,
-            textBuffer,
-            _col
-        );
-        if (surface == null) throw `Surface creation failed on print`;
-        const texture = libsdl.symbols.SDL_CreateTextureFromSurface(
-            Global.ptrRenderer,
-            surface
-        );
-        if (texture == null) throw `Texture creation failed on print`;
-
-        // Create destination
-        const destArr = new Uint32Array(4);
-        destArr[0] = x;
-        destArr[1] = y;
-        destArr[2] = wArr[0];
-        destArr[3] = hArr[0];
+    public draw(image: Image, position: Vector2) {
+        const dstRect = new Uint32Array(4);
+        dstRect[0] = position.x;
+        dstRect[1] = position.y;
+        dstRect[2] = image.size.x;
+        dstRect[3] = image.size.y;
 
-        // Draw text
         libsdl.symbols.SDL_RenderCopy(
-            Global.ptrRenderer,
-            texture,
+            Renderer.pointer,
+            (image as any).pointer,
             null,
-            ptr(destArr)
+            dstRect
         );
     }
 
-    /**
-     * Sets the font to a ttf file in your project
+    /*
+     * Method to draw to the screen with extended arguments
      *
-     * @param path relative path to font
-     * @param pt size of text
+     * @param image Image object to draw. Made using Slifer.Graphics.loadImage
+     * @param position Position to draw the image.
+     * @param rotation Optional argument angle of rotation
+     * @param scale Optional What to multiply the width and height of image by
      */
-    setFont(path: string, pt: number) {
-        const tempFont = libttf.symbols.TTF_OpenFont(
-            Buffer.from(path + "\x00"),
-            pt
+    public drawEx(
+        image: Image,
+        position: Vector2,
+        rotation?: number,
+        scale?: Vector2
+    ) {
+        // Define destination rect
+        const dstRect = new Uint32Array(4);
+        dstRect[0] = position.x;
+        dstRect[1] = position.y;
+        dstRect[2] = image.size.x * (scale ? scale.x : 1);
+        dstRect[3] = image.size.y * (scale ? scale.y : 1);
+
+        // Draw to screen
+        libsdl.symbols.SDL_RenderCopyEx(
+            Renderer.pointer,
+            image.pointer,
+            null,
+            ptr(dstRect),
+            rotation ? rotation : 0,
+            null,
+            null
         );
-        if (tempFont == null) throw `Font loading failed`;
-        Global.ptrFont = tempFont;
     }
 }
 
 class Image {
-    private pointer;
+    public readonly pointer: Pointer;
+    public readonly size: Vector2;
 
     constructor(texture: Pointer) {
         this.pointer = texture;
+
+        const _wArr = new Uint32Array(1);
+        const _hArr = new Uint32Array(1);
+
+        libsdl.symbols.SDL_QueryTexture(
+            texture,
+            null,
+            null,
+            ptr(_wArr),
+            ptr(_hArr)
+        );
+
+        this.size = new Vector2(_wArr[0], _hArr[0]);
     }
 }
 

package/src/modules/keyboard.ts

@@ -1,34 +1,58 @@
+import { libsdl } from "../ffi";
+
 /** @internal */
 class Keyboard {
+    static #instance: Keyboard;
 
     static downKeyMap = new Map<string, boolean>();
     static pressedKeyMap = new Map<string, boolean>();
     static releasedKeyMap = new Map<string, boolean>();
-    
-    static setKeyDown(key: string) {
-        this.downKeyMap.set(key, true);
-        this.releasedKeyMap.set(key, false);
+
+    private constructor() {}
+
+    public static get instance() {
+        if (!Keyboard.#instance) {
+            Keyboard.#instance = new Keyboard();
+        }
+
+        return Keyboard.#instance;
+    }
+
+    private static convertScancodeToKey(scancode: number): string {
+        const keyFromScancode = libsdl.symbols.SDL_GetKeyFromScancode(scancode);
+        const keyName = libsdl.symbols
+            .SDL_GetKeyName(keyFromScancode)
+            .toString();
+
+        return keyName;
+    }
+
+    static setKeyDown(key: number): void {
+        const keyName = Keyboard.convertScancodeToKey(key);
+        this.downKeyMap.set(keyName.toLowerCase(), true);
+        this.releasedKeyMap.set(keyName.toLowerCase(), false);
     }
 
-    static setKeyUp(key: string) {
-        this.downKeyMap.set(key, false);
-        this.pressedKeyMap.set(key, false);
+    static setKeyUp(key: number) {
+        const keyName = Keyboard.convertScancodeToKey(key);
+        this.downKeyMap.set(keyName.toLowerCase(), false);
+        this.pressedKeyMap.set(keyName.toLowerCase(), false);
     }
 
     /**
-     * 
+     *
      * @param key string of key
      * @returns if the key is being held down
      */
     isDown(key: keys) {
         const _state = Keyboard.downKeyMap.get(key);
-        if (_state == undefined) return false
+        if (_state == undefined) return false;
 
         return _state;
     }
 
     /**
-     * 
+     *
      * @param key string of key
      * @returns if key is pressed. Returns only once
      */
@@ -47,7 +71,7 @@ class Keyboard {
     }
 
     /**
-     * 
+     *
      * @param key string of key
      * @returns if key is released. Returns only once
      */
@@ -66,15 +90,50 @@ class Keyboard {
     }
 }
 
-type keys = 'a' |'b' |'c' |'d' |'e' |'f' |'g' |'h' |'i' |'j' |'k' |'l' |'m' |'n' |'o' |'p' |'q' |'r' |'s' |'t' |'u' |'v' |'w' |'x' |'y' |'z' |
-'1' |'2' |'3' |'4' |'5' |'6' |'7' |'8' |'9' |'0' |
-'space' |
-'caps lock' |
-'tab' |
-'left shift' |
-'right shift' |
-'left ctrl' |
-'escape';
+type keys =
+    | "a"
+    | "b"
+    | "c"
+    | "d"
+    | "e"
+    | "f"
+    | "g"
+    | "h"
+    | "i"
+    | "j"
+    | "k"
+    | "l"
+    | "m"
+    | "n"
+    | "o"
+    | "p"
+    | "q"
+    | "r"
+    | "s"
+    | "t"
+    | "u"
+    | "v"
+    | "w"
+    | "x"
+    | "y"
+    | "z"
+    | "1"
+    | "2"
+    | "3"
+    | "4"
+    | "5"
+    | "6"
+    | "7"
+    | "8"
+    | "9"
+    | "0"
+    | "space"
+    | "caps lock"
+    | "tab"
+    | "left shift"
+    | "right shift"
+    | "left ctrl"
+    | "escape";
 
 /** @internal */
-export default Keyboard;
+export default Keyboard;

package/src/modules/mouse.ts

@@ -1,16 +1,25 @@
 import { libsdl } from "../ffi";
-import { ptr } from 'bun:ffi';
+import { ptr } from "bun:ffi";
+import Vector2 from "../engine/vector";
 
 /** @internal */
 class Mouse {
+    static #instance: Mouse;
 
     static downKeyMap = new Map<string, boolean>();
     static pressedKeyMap = new Map<string, boolean>();
     static releasedKeyMap = new Map<string, boolean>();
-    
-    static setButtonDown(button: number) {
 
-        let key : string = '';
+    private constructor() {}
+
+    public static get instance() {
+        if (!Mouse.#instance) Mouse.#instance = new Mouse();
+
+        return Mouse.#instance;
+    }
+
+    static setButtonDown(button: number) {
+        let key: string = "";
         if (button == 1) {
             key = "left";
         } else if (button == 2) {
@@ -24,8 +33,7 @@ class Mouse {
     }
 
     static setButtonUp(button: number) {
-
-        let key : string = '';
+        let key: string = "";
         if (button == 1) {
             key = "left";
         } else if (button == 2) {
@@ -33,25 +41,25 @@ class Mouse {
         } else {
             key = "right";
         }
-        
+
         this.downKeyMap.set(key, false);
         this.pressedKeyMap.set(key, false);
     }
 
     /**
-     * 
+     *
      * @param button string of button
      * @returns if the button is being held down
      */
     isDown(button: buttons) {
         const _state = Mouse.downKeyMap.get(button);
-        if (_state == undefined) return false
+        if (_state == undefined) return false;
 
         return _state;
     }
 
     /**
-     * 
+     *
      * @param button string of button
      * @returns if button is pressed. Returns only once
      */
@@ -70,7 +78,7 @@ class Mouse {
     }
 
     /**
-     * 
+     *
      * @param button string of button
      * @returns if button is released. Returns only once
      */
@@ -92,11 +100,11 @@ class Mouse {
         const xArr = new Uint32Array(1);
         const yArr = new Uint32Array(1);
         libsdl.symbols.SDL_GetMouseState(ptr(xArr), ptr(yArr));
-        return {x: xArr[0], y: yArr[0]};
+        return new Vector2(xArr[0], yArr[0]);
     }
 }
 
-type buttons = 'left' | 'middle' | 'right';
+type buttons = "left" | "middle" | "right";
 
 /** @internal */
-export default Mouse;
+export default Mouse;

package/src/slifer.test.ts

@@ -1,8 +1,43 @@
 import { describe, expect, it } from "bun:test";
-import { initLibraries } from "./engine";
+import { initSDL, initSDLImage, initSDLTypeFont, initSDLMixer } from "./engine";
+import Vector2 from "./engine/vector";
+import Window from "./engine/window";
+import Renderer from "./engine/renderer";
 
-describe("Initializing ", () => {
+describe("Initializing SDL ", () => {
     it("Should initialize without error ", () => {
-        expect(() => initLibraries()).not.toThrow(Error);
+        expect(() => initSDL()).not.toThrow(Error);
+    });
+});
+
+describe("Initializing SDL Image ", () => {
+    it("Should initialize without error ", () => {
+        expect(() => initSDLImage()).not.toThrow(Error);
+    });
+});
+
+describe("Initializing SDL TTF ", () => {
+    it("Should initialize without error ", () => {
+        expect(() => initSDLTypeFont()).not.toThrow(Error);
+    });
+});
+
+describe("Initializing SDL Mixer ", () => {
+    it("Should initialize without error ", () => {
+        expect(() => initSDLMixer()).not.toThrow(Error);
+    });
+});
+
+describe("Window Creation ", () => {
+    it("Should create window without error", () => {
+        expect(() =>
+            Window.createWindow("Game", new Vector2(1, 1))
+        ).not.toThrow(Error);
+    });
+});
+
+describe("Renderer Creation ", () => {
+    it("Should create renderer without error", () => {
+        expect(() => Renderer.createRenderer()).not.toThrow(Error);
     });
 });