slifer 0.2.1 → 0.2.3

package/src/modules/graphics.ts

@@ -1,17 +1,28 @@
-import { libimage, libsdl, libttf } from "../ffi";
-import Global from "../global";
+import { libimage, libsdl } from "../ffi";
 import { type Pointer, ptr } from "bun:ffi";
-import Rectangle from "../engine/rectangle";
+import { Image } from "../engine/image";
+import { Rectangle } from "../engine/rectangle";
 import Color from "../color";
-import Vector2 from "../engine/vector";
+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 +34,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 +47,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,12 +64,12 @@ 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`;
@@ -67,165 +78,69 @@ class Graphics {
 
     /**
      * Method to draw to the screen simply
+     *
      * @param image Image object to draw. Made using Slifer.Graphics.loadImage
      * @param position position to draw the image
      *
      */
-    draw(image: Image, position: Vector2) {
+    public draw(image: Image, position: Vector2) {
         const dstRect = new Uint32Array(4);
         dstRect[0] = position.x;
         dstRect[1] = position.y;
-        dstRect[2] = image.width;
-        dstRect[3] = image.height;
+        dstRect[2] = image.size.x;
+        dstRect[3] = image.size.y;
 
         libsdl.symbols.SDL_RenderCopy(
-            Global.ptrRenderer,
+            Renderer.pointer,
             (image as any).pointer,
             null,
             dstRect
         );
     }
 
-    /**
-     * Method to draw the image to the screen with extended arguments
+    /*
+     * Method to draw to the screen with extended arguments
      *
      * @param image Image object to draw. Made using Slifer.Graphics.loadImage
-     * @param position position to draw the 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
+     * @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
      */
-    drawEx(
+    public drawEx(
         image: Image,
         position: Vector2,
-        clipRectangle?: Rectangle | null,
         rotation?: number,
-        xs?: number,
-        ys?: number,
-        flip?: true
+        scale?: Vector2,
+        flipH?: boolean
     ) {
-        const _dest = new Uint32Array(4);
-        let srcRect: null | Uint32Array = null;
-
-        if (clipRectangle != null) {
-            srcRect = new Uint32Array(4);
-            srcRect[0] = clipRectangle.position.x;
-            srcRect[1] = clipRectangle.position.y;
-            srcRect[2] = clipRectangle.size.x;
-            srcRect[3] = clipRectangle.size.y;
-        }
+        // 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);
 
-        _dest[0] = position.x;
-        _dest[1] = position.y;
-        _dest[2] = image.width * (xs ? xs : 1);
-        _dest[3] = image.height * (ys ? ys : 1);
-        const _center = new Uint32Array(2);
-        _center[0] = _dest[2] / 2;
-        _center[1] = _dest[3] / 2;
+        // Draw to screen
         libsdl.symbols.SDL_RenderCopyEx(
-            Global.ptrRenderer,
-            (image as any).pointer,
-            srcRect,
-            ptr(_dest),
+            Renderer.pointer,
+            image.pointer,
+            null,
+            ptr(dstRect),
             rotation ? rotation : 0,
-            ptr(_center),
-            flip ? Number(flip) : 0
-        );
-    }
-
-    /**
-     * Method to draw text to the screen
-     *
-     * @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];
-
-        // Draw text
-        libsdl.symbols.SDL_RenderCopy(
-            Global.ptrRenderer,
-            texture,
             null,
-            ptr(destArr)
+            flipH ? Number(flipH) : 0
         );
     }
 
-    /**
-     * Sets the font to a ttf file in your project
-     *
-     * @param path relative path to font
-     * @param pt size of text
-     */
-    setFont(path: string, pt: number) {
-        const tempFont = libttf.symbols.TTF_OpenFont(
-            Buffer.from(path + "\x00"),
-            pt
-        );
-        if (tempFont == null) throw `Font loading failed`;
-        Global.ptrFont = tempFont;
-    }
-}
-
-class Image {
-    private pointer;
-    public readonly width;
-    public readonly height;
-
-    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)
+    public drawRect(rectangle: Rectangle, color: Color) {
+        libsdl.symbols.SDL_SetRenderDrawColor(
+            Renderer.pointer,
+            color.r,
+            color.g,
+            color.b,
+            color.a
         );
-
-        this.width = _wArr[0];
-        this.height = _hArr[0];
+        libsdl.symbols.SDL_RenderFillRect(Renderer.pointer, rectangle.pointer);
     }
 }
 

package/src/modules/keyboard.ts

@@ -1,80 +1,125 @@
+import { libsdl } from "../ffi";
+import { toArrayBuffer } from "bun: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);
-    }
+    static keyState: DataView;
+    static pressMap = new Map<string, number>();
+
+    private constructor() {}
 
-    static setKeyUp(key: string) {
-        this.downKeyMap.set(key, false);
-        this.pressedKeyMap.set(key, false);
+    public static get instance() {
+        if (!Keyboard.#instance) {
+            Keyboard.#instance = new Keyboard();
+        }
+
+        return Keyboard.#instance;
     }
 
-    /**
-     * 
-     * @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
+    private static convertScancodeToKey(scancode: number): string {
+        const keyFromScancode = libsdl.symbols.SDL_GetKeyFromScancode(scancode);
+        const keyName = libsdl.symbols
+            .SDL_GetKeyName(keyFromScancode)
+            .toString();
 
-        return _state;
+        return keyName;
     }
 
-    /**
-     * 
-     * @param key string of key
-     * @returns if key is pressed. Returns only once
-     */
-    isPressed(key: keys) {
-        const _pressedState = Keyboard.pressedKeyMap.get(key);
-        const _downState = Keyboard.downKeyMap.get(key);
-
-        if (_downState == true) {
-            if (_pressedState == false || _pressedState == undefined) {
-                Keyboard.pressedKeyMap.set(key, true);
-                return true;
+    static getStates() {
+        const state = libsdl.symbols.SDL_GetKeyboardState(null);
+        if (state == null) return;
+        const myArr = new DataView(toArrayBuffer(state, 0, 512));
+        
+        for (let i = 0; i < 512; ++i) {
+            if (myArr.getUint8(i) == 1) {
+                const keyName = this.convertScancodeToKey(i).toLowerCase();
+                const kmGet = this.pressMap.get(keyName);
+                if (kmGet == undefined || kmGet == 0) {
+                    this.pressMap.set(keyName, 1);
+                } else if (kmGet == 1) {
+                    this.pressMap.set(keyName, 2);
+                }
+            } else if (myArr.getUint8(i) == 0) {
+                const keyName = this.convertScancodeToKey(i).toLowerCase();
+                this.pressMap.set(keyName, 0);
             }
         }
+    }
+
+    public isPressed(key: keys) {
+        /*
+        const scancode = libsdl.symbols.SDL_GetScancodeFromName(
+            Buffer.from(key + "\x00")
+        );
+        const thisval = Keyboard.keyState.getUint8(scancode);
+        */
+
+        const kmGet = Keyboard.pressMap.get(key);
+        if (kmGet == 1) {
+            return true;
+        }
+
 
         return false;
     }
 
-    /**
-     * 
-     * @param key string of key
-     * @returns if key is released. Returns only once
-     */
-    isReleased(key: keys) {
-        const _releasedState = Keyboard.releasedKeyMap.get(key);
-        const _downState = Keyboard.downKeyMap.get(key);
-
-        if (_downState == false) {
-            if (_releasedState == false || undefined) {
-                Keyboard.releasedKeyMap.set(key, true);
-                return true;
-            }
+
+    public isDown(key: keys) {
+        const kmGet = Keyboard.pressMap.get(key);
+        if (kmGet == 1 || kmGet == 2) {
+            return true;
         }
 
         return false;
     }
 }
 
-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);
     });
 });