slifer 0.2.6 → 0.2.8

package/.npmignore

@@ -7,6 +7,7 @@ yarn-error.log*
 lerna-debug.log*
 .pnpm-debug.log*
 .vs
+.DS_Store
 Resources
 .idea
 
@@ -135,4 +136,4 @@ test.ts
 char.png
 
 .wakatime-project
-libs/
+libs/

package/index.ts

@@ -3,6 +3,9 @@ import Image from "./src/engine/image";
 import Vector2 from "./src/engine/vector2";
 import Color from "./src/engine/color";
 import Audio from "./src/engine/audio";
+import Rectangle from "./src/engine/rectangle";
+import Font from "./src/engine/font";
+import Canvas from './src/engine/canvas';
 
 const slf = new Slifer();
-export { Vector2, Color, Image, Audio, slf as Slifer };
+export { Vector2, Color, Image, Audio, Rectangle, Font, Canvas, slf as Slifer };

package/package.json

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

package/src/download.ts

@@ -1,5 +1,3 @@
-import * as https from 'https';
-import * as fs from 'fs';
 import * as path from 'path';
 
 const libDir = path.join(__dirname, '../libs/');
@@ -13,11 +11,17 @@ async function downloadLibrary(url: string, filename: string) {
 
 if (process.platform == "darwin") {
     downloadLibrary("https://github.com/HazyVT/Slifer/releases/download/Libraries/libSDL2.dylib", "libSDL2.dylib");
-    
-    
     downloadLibrary("https://github.com/HazyVT/Slifer/releases/download/Libraries/libSDL2_image.dylib", "libSDL2_image.dylib");
-    
     downloadLibrary("https://github.com/HazyVT/Slifer/releases/download/Libraries/libSDL2_mixer.dylib", "libSDL2_mixer.dylib");
-    
     downloadLibrary("https://github.com/HazyVT/Slifer/releases/download/Libraries/libSDL2_ttf.dylib", "libSDL2_ttf.dylib");
+} else if (process.platform == "win32") {
+    downloadLibrary("https://github.com/HazyVT/Slifer/releases/download/Libraries/SDL2.dll", "SDL2.dll");
+    downloadLibrary("https://github.com/HazyVT/Slifer/releases/download/Libraries/SDL2_image.dll", "SDL2_image.dll");
+    downloadLibrary("https://github.com/HazyVT/Slifer/releases/download/Libraries/SDL2_mixer.dll", "SDL2_mixer.dll");
+    downloadLibrary("https://github.com/HazyVT/Slifer/releases/download/Libraries/SDL2_ttf.dll", "SDL2_ttf.dll");
+} else if (process.platform == "linux") {
+    downloadLibrary("https://github.com/HazyVT/Slifer/releases/download/Libraries/libSDL2.so", "libSDL2.so");
+    downloadLibrary("https://github.com/HazyVT/Slifer/releases/download/Libraries/libSDL2_image.so", "libSDL2_image.so");
+    downloadLibrary("https://github.com/HazyVT/Slifer/releases/download/Libraries/libSDL2_mixer.so", "libSDL2_mixer.so");
+    downloadLibrary("https://github.com/HazyVT/Slifer/releases/download/Libraries/libSDL2_ttf.so", "libSDL2_ttf.so");
 }

package/src/engine/canvas.ts

@@ -0,0 +1,58 @@
+import { type Pointer, ptr } from 'bun:ffi';
+import { libsdl } from '../ffi';
+import Image from './image';
+import Render from './render';
+import Color from './color';
+
+/** @internal */
+export default class Canvas {
+
+	private pointer : Pointer;
+
+	public readonly width;
+	public readonly height;
+
+	constructor(width: number, height: number) {
+		const surPointer = libsdl.symbols.SDL_CreateRGBSurface(0, width, height, 32, 0, 0, 0, 0)
+		if (surPointer == null) throw `Canvas creation failed`;
+		this.pointer = surPointer;
+		this.width = width;
+		this.height = height;
+	}
+
+	private drawBG(color: Color) {
+		const rect = new Uint32Array(4);
+		rect[0] = 0;
+		rect[1] = 0;
+		rect[2] = this.width;
+		rect[3] = this.height;
+
+		const _col = ((color.r << 16) + (color.g << 8) + (color.b << 0));
+
+		libsdl.symbols.SDL_FillRect(this.pointer, ptr(rect), _col);
+	}
+
+	clear() {
+        this.drawBG(new Color(0, 0, 0, 0));
+	}
+
+	setBackground(color: Color) {
+		this.drawBG(color);
+	}
+
+	draw(drawable: Image | Canvas, x: number, y: number, scaleX?: number, scaleY?: number) : void {
+		const destArray = new Uint32Array(4);
+		destArray[0] = x;
+		destArray[1] = y;
+		destArray[2] = drawable.width * (scaleX ? scaleX : 1);
+		destArray[3] = drawable.height * (scaleY ? scaleY : 1);
+		        
+        libsdl.symbols.SDL_UpperBlitScaled(
+        	(drawable as any).pointer,
+        	null,
+        	this.pointer,
+        	ptr(destArray)
+        );
+	}
+
+}

package/src/engine/font.ts

@@ -0,0 +1,16 @@
+import { type Pointer } from 'bun:ffi';
+import { libttf } from '../ffi';
+
+export default class Font {
+	private pointer : Pointer;
+
+	constructor(path: string, size: number) {
+		const fp = libttf.symbols.TTF_OpenFont(Buffer.from(path+"\x00"), size);
+		if (fp == null) throw `Font failed to be opened`;
+		this.pointer = fp;
+	}
+
+	public destroy() {
+		libttf.symbols.TTF_CloseFont(this.pointer);
+	}
+}

package/src/engine/image.ts

@@ -1,34 +1,23 @@
 import { libimage, libsdl } from "../ffi";
-import { type Pointer, ptr } from 'bun:ffi';
+import { type Pointer, ptr, toArrayBuffer } from 'bun:ffi';
 import Render from "./render";
 
 /** @internal */
 export default class Image {
 
     private pointer:  Pointer;
-    private destArr: Uint32Array;
 
-    public readonly width;
-    public readonly height;
+    public readonly width: number;
+    public readonly height: number;
 
     constructor(path: string) {
         const cs = Buffer.from(path+'\x00');
-        //@ts-expect-error Buffer error;
-        const texture = libimage.symbols.IMG_LoadTexture(Render.pointer, cs);
-        if (texture == null) throw `Texture creation failed.`;
-        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.width = wArr[0];
-        this.height = hArr[0];
-
-        this.destArr = new Uint32Array(4);
-        this.destArr[0] = 0;
-        this.destArr[1] = 0;
-        this.destArr[2] = this.width;
-        this.destArr[3] = this.height;
+        //@ts-expect-error
+        const surface = libimage.symbols.IMG_Load(cs);
+        if (surface == null) throw `Loading ${path} failed`;
+        this.pointer = surface;
+		const dv = new DataView(toArrayBuffer(this.pointer, 0, 21));
+		this.width = dv.getUint8(16);
+		this.height = dv.getUint8(20);
     }
-}
+}

package/src/engine/rectangle.ts

@@ -1,4 +1,4 @@
-import type Vector2 from "./vector2";
+import Vector2 from "./vector2";
 import { ptr, type Pointer } from 'bun:ffi';
 
 /** @internal */
@@ -12,6 +12,10 @@ export default class Rectangle {
         this.size = size;
     }
 
+	static empty() : Rectangle {
+		return new Rectangle(new Vector2(0, 0), new Vector2(0, 0));
+	}
+
     public isColliding(rectangle: Rectangle) : boolean {
     	if (
     		this.position.x < rectangle.position.x + rectangle.size.x &&

package/src/engine/render.ts

@@ -6,10 +6,14 @@ import Window from "./window";
 export default class Render {
 
     public static pointer : Pointer;
+    public static surface: Pointer;
 
-    public static createRenderer() {
+    public static createRenderer(width: number, height: number) {
         const renPointer = libsdl.symbols.SDL_CreateRenderer(Window.pointer, -1, 0);
         if (renPointer == null) throw `Renderer creation failed.`;
         this.pointer = renPointer;
+        const surPointer = libsdl.symbols.SDL_CreateRGBSurface(0, width, height, 32, 0, 0, 0, 0)
+		if (surPointer == null) throw `Surface creation failed`;
+		this.surface = surPointer;
     }
-}
+}

package/src/engine/vector2.ts

@@ -7,4 +7,20 @@ export default class Vector2 {
         this.x = x;
         this.y = y;
     }
+
+    static one() : Vector2 {
+        return new Vector2(1, 1);
+    }
+
+    static unitX() : Vector2 {
+        return new Vector2(1, 0);
+    }
+
+    static unitY() : Vector2 {
+        return new Vector2(0, 1);
+    }
+
+    static zero() : Vector2 {
+        return new Vector2(0, 0);
+    }
 }   

package/src/engine/window.ts

@@ -4,29 +4,32 @@ import { libsdl } from '../ffi';
 
 /** @internal */
 export default class Window {
-    public static pointer: Pointer;
 
+    public static pointer: Pointer;
+	public static size: Vector2;
+	
     private static centerPos = 0x2fff0000;
 
+	
+
     public static createWindow(title: string, size: Vector2) : void {
         const winPointer = libsdl.symbols.SDL_CreateWindow(
-            //@ts-expect-error Buffer error
             Buffer.from(title + '\x00'),
             this.centerPos,
             this.centerPos,
             size.x,
             size.y,
             0
-        )
+        );
 
         if (winPointer == null) throw `Window creation failed.`;
         this.pointer = winPointer;
+        this.size = size;
     }
 
     public setTitle(title: string): void {
         libsdl.symbols.SDL_SetWindowTitle(
             Window.pointer,
-            //@ts-expect-error Buffer error
             Buffer.from(title + "\x00")
         );
     }
@@ -46,4 +49,4 @@ export default class Window {
     public centerWindow() {
         this.setPosition(new Vector2(Window.centerPos, Window.centerPos));
     }
-}
+}

package/src/ffi.ts

@@ -1,19 +1,22 @@
 import { dlopen, FFIType, suffix } from "bun:ffi";
+import * as path from "path";
 
 let libSDLImport;
 let libImageImport;
 let libTTFImport;
 let libMixerImport;
 
+const libDir = path.join(__dirname, "../libs/");
+
 if (process.platform == "win32") {
     //@ts-expect-error
-    libSDLImport = await import("../libs/libSDL2.dll");
+    libSDLImport = await import("../libs/SDL2.dll");
     //@ts-expect-error
-    libImageImport = await import("../libs/libSDL2_image.dll");
+    libImageImport = await import("../libs/SDL2_image.dll");
     //@ts-expect-error
-    libTTFImport = await import("../libs/libSDL2_ttf.dll");
+    libTTFImport = await import("../libs/SDL2_ttf.dll");
     //@ts-expect-error
-    libMixerImport = await import("../libs/libSDL2_mixer.dll");
+    libMixerImport = await import("../libs/SDL2_mixer.dll");
 } else if (process.platform == "darwin") {
     //@ts-expect-error
     libSDLImport = await import("../libs/libSDL2.dylib");
@@ -24,14 +27,10 @@ if (process.platform == "win32") {
     //@ts-expect-error
     libMixerImport = await import("../libs/libSDL2_mixer.dylib");
 } else if (process.platform == "linux") {
-    //@ts-expect-error
-    libSDLImport = await import("../libs/libSDL2.so");
-    //@ts-expect-error
-    libImageImport = await import("../libs/libSDL2_image.so");
-    //@ts-expect-error
-    libTTFImport = await import("../libs/libSDL2_ttf.so");
-    //@ts-expect-error
-    libMixerImport = await import("../libs/libSDL2_mixer.so");
+    libSDLImport = await import(`${libDir}libSDL2.so`);
+    libImageImport = await import(`${libDir}libSDL2_image.so`);
+    libTTFImport = await import(`${libDir}libSDL2_ttf.so`);
+    libMixerImport = await import(`${libDir}libSDL2_mixer.so`);
 }
 
 /** @internal */
@@ -220,6 +219,29 @@ export const libsdl = dlopen(libSDLImport.default, {
     SDL_GetScancodeFromName: {
         args: ["cstring"],
         returns: "int",
+    },
+    SDL_GetTicks64: {
+    	returns: 'u64'
+    },
+    SDL_CreateRGBSurface: {
+    	args: ['int', 'int', 'int', 'int', 'int', 'int', 'int', 'int'],
+    	returns: 'pointer'
+    },
+    SDL_UpperBlitScaled: {
+    	args: ['pointer', 'pointer','pointer','pointer'],
+    	returns: 'int'
+    },
+    SDL_FillRect: {
+    	args: ['pointer', 'pointer', 'int'],
+    	returns: 'int'
+    },
+    SDL_DestroyTexture : {
+    	args: ['pointer'],
+    	returns: 'void'
+    },
+    SDL_MapRGB: {
+    	args: ['pointer', 'int', 'int', 'int'],
+    	returns: 'u32'
     }
 });
 
@@ -234,9 +256,9 @@ export const libimage = dlopen(libImageImport.default, {
         returns: "pointer",
     },
     IMG_LoadTexture: {
-        args: ['pointer', 'cstring'],
-        returns: 'pointer'
-    }
+        args: ["pointer", "cstring"],
+        returns: "pointer",
+    },
 });
 
 /** @internal */

package/src/modules/graphics.ts

@@ -1,78 +1,100 @@
 import Vector2 from "../engine/vector2";
-import { libsdl } from "../ffi";
+import { libsdl, libttf } from "../ffi";
 import { ptr } from 'bun:ffi';
-
+import Font from '../engine/font';
 import type Image from "../engine/image";
 import Render from "../engine/render";
+import Window from '../engine/window';
 import type Color from "../engine/color";
-import type Rectangle from "../engine/rectangle";
+import Rectangle from "../engine/rectangle";
+import Canvas from '../engine/canvas';
 
 /** @internal */
 export default class Graphics {
 
-    render() : void {
+    public render() : void {
+    	const texture = libsdl.symbols.SDL_CreateTextureFromSurface(Render.pointer, Render.surface);
+    	if (texture == null) throw `Render texture creation failed`;
+    	libsdl.symbols.SDL_RenderCopy(
+    		Render.pointer,
+    		texture,
+    		null,
+    		null
+    	);
         libsdl.symbols.SDL_RenderPresent(Render.pointer);
+        libsdl.symbols.SDL_DestroyTexture(texture);
     }
     
-    draw(image: Image, position: Vector2) : void {
-
-        (image as any).destArr[0] = position.x;
-        (image as any).destArr[1] = position.y;
-        
-        libsdl.symbols.SDL_RenderCopy(
-            Render.pointer,
-            (image as any).pointer,
-            null,
-            ptr((image as any).destArr)
-        );
-    }
+    public draw(drawable: Image | Canvas, x: number, y: number, scaleX?: number, scaleY?: number) : void {
 
-    drawEx(image: Image, position: Vector2, rotation?: number, scale?: Vector2, flipH?: boolean) {
-        
-        const destArr = (image as any).destArr;
-        destArr[0] = position.x;
-        destArr[1] = position.y;
-        destArr[2] = image.width * (scale ? scale.x : 1);
-        destArr[3] = image.height * (scale ? scale.y : 1);
-
-        libsdl.symbols.SDL_RenderCopyEx(
-            Render.pointer,
-            (image as any).pointer,
-            null,
-            ptr(destArr),
-            rotation ? rotation : 0,
-            null,
-            Number(flipH)
+		const destArray = new Uint32Array(4);
+		destArray[0] = x;
+		destArray[1] = y;
+		destArray[2] = drawable.width * (scaleX ? scaleX : 1);
+		destArray[3] = drawable.height * (scaleY ? scaleY : 1);
+		        
+        libsdl.symbols.SDL_UpperBlitScaled(
+        	(drawable as any).pointer,
+        	null,
+        	Render.surface,
+        	ptr(destArray)
         );
-
-
     }
 
-    setBackground(color: Color) : void {
-        libsdl.symbols.SDL_SetRenderDrawColor(Render.pointer,
-            color.r,
-            color.g,
-            color.b,
-            color.a
-        );
-        libsdl.symbols.SDL_RenderClear(Render.pointer);
-    }
+    public setBackground(color: Color) : void {
+		const rect = new Rectangle(
+			new Vector2(0, 0),
+			new Vector2(Window.size.x, Window.size.y)
+		);
+		this.drawRect(rect, color);
+   	}
 
     public drawRect(rectangle: Rectangle, color: Color) {
-        libsdl.symbols.SDL_SetRenderDrawColor(
-            Render.pointer,
-            color.r,
-            color.g,
-            color.b,
-            color.a
-        );
+		const _col = ((color.r << 16) + (color.g << 8) + (color.b << 0));
 
         const rect = new Uint32Array(4);
         rect[0] = rectangle.position.x;
-        rect[1] = rectangle.position.y;
+    	rect[1] = rectangle.position.y;
         rect[2] = rectangle.size.x;
         rect[3] = rectangle.size.y;
 
-        libsdl.symbols.SDL_RenderFillRect(Render.pointer, ptr(rect));
+        libsdl.symbols.SDL_FillRect(Render.surface, ptr(rect), _col);
+    }
+    
+    public print(text: string, x: number, y: number, font: Font, color: Color) {
+    	const wArr = new Uint32Array(1);
+    	const hArr = new Uint32Array(1);
+    	
+    	libttf.symbols.TTF_SizeText(
+    		(font as any).pointer,
+			//@ts-expect-error
+    		Buffer.from(text+"\x00"),
+    		ptr(wArr),
+    		ptr(hArr)
+    	);
+
+    	const _col = ((color.r << 16) + (color.g << 8) + (color.b << 0));
+
+    	const surface = libttf.symbols.TTF_RenderText_Solid(
+    		(font as any).pointer,
+    		//@ts-expect-error
+    	  	Buffer.from(text+'\x00'),
+    	   	_col
+    	);
+    	if (surface == null) throw `Rendering text failed`;
+
+    	const destRect = new Uint32Array(4);
+		destRect[0] = x;
+		destRect[1] = y;
+		destRect[2] = wArr[0];
+		destRect[3] = hArr[0];
+
+    	libsdl.symbols.SDL_UpperBlit(
+			surface,
+			null,
+			Render.surface,
+			ptr(destRect)
+    	);
+		
     }
-}
+}

package/src/modules/mouse.ts

@@ -4,18 +4,24 @@ import Vector2 from "../engine/vector2";
 
 /** @internal */
 class Mouse {
-
-    private static x : number;
-    private static y : number;
+    private static x: number;
+    private static y: number;
 
     private static buttonMap = new Map<number, number>();
-    
+
     static onRelease(button: number) {
         this.buttonMap.set(button, 0);
     }
 
+    static onMove(x: number, y: number) {
+        this.x = x;
+        this.y = y;
+    }
+
     static handleState() {
-        const down = libsdl.symbols.SDL_GetMouseState();
+        const xArr = new Uint32Array(1);
+        const yArr = new Uint32Array(1);
+        const down = libsdl.symbols.SDL_GetMouseState(ptr(xArr), ptr(yArr));
         const bmGet = this.buttonMap.get(down);
 
         if (bmGet == undefined || bmGet == 0) {
@@ -37,27 +43,31 @@ class Mouse {
         return false;
     }
 
-    isPressed(button: buttons) : boolean {
+    isPressed(button: buttons): boolean {
         switch (button) {
-            case 'left':
+            case "left":
                 return Mouse.getPressMap(1);
-            case 'middle':
+            case "middle":
                 return Mouse.getPressMap(2);
-            case 'right':
+            case "right":
                 return Mouse.getPressMap(3);
         }
     }
 
-    isDown(button: buttons) : boolean {
+    isDown(button: buttons): boolean {
         switch (button) {
-            case 'left':
+            case "left":
                 return Mouse.getDownMap(1);
-            case 'middle':
+            case "middle":
                 return Mouse.getDownMap(2);
-            case 'right':
+            case "right":
                 return Mouse.getDownMap(3);
         }
     }
+
+    getPosition(): Vector2 {
+        return new Vector2(Mouse.x, Mouse.y);
+    }
 }
 
 type buttons = "left" | "middle" | "right";

package/src/slifer.ts

@@ -1,6 +1,5 @@
 import { libsdl } from "./ffi";
 import Window from "./engine/window";
-import Renderer from "./engine/render";
 import { ptr } from "bun:ffi";
 import { initLibraries } from "./engine";
 import { version } from "../package.json";
@@ -9,32 +8,40 @@ import Graphics from "./modules/graphics";
 import Keyboard from "./modules/keyboard";
 import Mouse from "./modules/mouse";
 import Render from "./engine/render";
+import Color from './engine/color';
 
 class Slifer {
-    
     public isRunning: boolean;
+	public deltaTime: number;
 
     // Modules
     public Graphics = new Graphics();
     public Keyboard = new Keyboard();
     public Mouse = new Mouse();
 
+    private start = 0;
+    private end = 0;
+    private black : Color;
+
     constructor() {
         initLibraries();
         this.isRunning = true;
+        this.deltaTime = 0;
+		this.black = new Color(0,0,0,0);
     }
 
-    public createWindow(title: string, size: Vector2) : Window {
+    public createWindow(title: string, size: Vector2): Window {
         Window.createWindow(title, size);
-        Renderer.createRenderer();
+        Render.createRenderer(size.x, size.y);
+
+        this.start = Number(libsdl.symbols.SDL_GetTicks64());
 
         return new Window();
     }
 
-    public shouldClose() : boolean {
-
+    public shouldClose(): boolean {
         libsdl.symbols.SDL_RenderClear(Render.pointer);
-
+		
         const eventArray = new Uint16Array(32);
         const event = libsdl.symbols.SDL_PollEvent(ptr(eventArray));
         if (event) {
@@ -42,24 +49,39 @@ class Slifer {
                 case 256:
                     this.isRunning = false;
                     break;
+                case 1024:
+                    Mouse.onMove(eventArray[10], eventArray[12]);
+                    break;
                 case 1026:
                     Mouse.onRelease(eventArray[8]);
                     break;
             }
         }
 
+
         Keyboard.handleStates();
 
         Mouse.handleState();
+
+        this.end = Number(libsdl.symbols.SDL_GetTicks64());
+
+		this.deltaTime = (this.end - this.start) / 1000;
+
+        this.start = this.end;
         
-        
+
         return !this.isRunning;
     }
 
-    public getVersion() : string {
-        return 'v' + version;
+    public getVersion(): string {
+        return "v" + version;
     }
-}
 
+    public quit(): void {
+        libsdl.symbols.SDL_DestroyRenderer(Render.pointer);
+        libsdl.symbols.SDL_DestroyWindow(Window.pointer);
+        libsdl.symbols.SDL_Quit();
+    }
+}
 
 export default Slifer;