slifer 0.2.8 → 0.2.9

package/package.json

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

package/src/download.ts

@@ -1,27 +1,48 @@
 import * as path from 'path';
+import { parseArgs } from 'util';
 
 const libDir = path.join(__dirname, '../libs/');
 
 async function downloadLibrary(url: string, filename: string) {
     const response = await fetch(url);
     await Bun.write(libDir + filename, response);
-    
-    
 }
 
-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");
-}
+function downloadFiles(check: string) {
+	if (check == "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 (check == "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 (check == "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");
+	}
+}
+
+const { values } = parseArgs({
+	args: Bun.argv,
+	options: {
+		mode: {
+			type: 'string'
+		}
+	},
+	strict: true,
+	allowPositionals: true
+})
+
+if (values.mode == undefined) {
+	downloadFiles(process.platform);
+} else {
+	downloadFiles(values.mode);
+}
+
+
+

package/src/engine/canvas.ts

@@ -1,13 +1,15 @@
 import { type Pointer, ptr } from 'bun:ffi';
-import { libsdl } from '../ffi';
+import { libsdl, libttf } from '../ffi';
 import Image from './image';
 import Render from './render';
 import Color from './color';
+import Font from './font';
 
 /** @internal */
 export default class Canvas {
 
 	private pointer : Pointer;
+	private destArray: Uint32Array;
 
 	public readonly width;
 	public readonly height;
@@ -18,18 +20,15 @@ export default class Canvas {
 		this.pointer = surPointer;
 		this.width = width;
 		this.height = height;
+		this.destArray = new Uint32Array(4);
+		this.destArray[2] = this.width;
+		this.destArray[3] = this.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);
+		libsdl.symbols.SDL_FillRect(this.pointer, ptr(this.destArray), _col);
 	}
 
 	clear() {
@@ -40,19 +39,52 @@ export default class Canvas {
 		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);
+	draw(drawable: Image | Canvas, x: number, y: number) : void {
+		(drawable as any).destArray[0] = x;
+		(drawable as any).destArray[1] = y;
 		        
         libsdl.symbols.SDL_UpperBlitScaled(
         	(drawable as any).pointer,
         	null,
         	this.pointer,
-        	ptr(destArray)
+        	ptr((drawable as any).destArray)
         );
 	}
 
+	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,
+	    		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,
+	    	  	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_UpperBlitScaled(
+				surface,
+				null,
+				this.pointer,
+				ptr(destRect)
+	    	);
+			
+	    }
+	
+
 }

package/src/engine/image.ts

@@ -6,18 +6,40 @@ import Render from "./render";
 export default class Image {
 
     private pointer:  Pointer;
+    private destArray: Uint32Array;
 
     public readonly width: number;
     public readonly height: number;
 
     constructor(path: string) {
         const cs = Buffer.from(path+'\x00');
-        //@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);
+
+
+		// Convert to texture
+		const texture = libsdl.symbols.SDL_CreateTextureFromSurface(
+			Render.pointer,
+			this.pointer
+		)
+		if (texture == null) throw `Loading ${path} failed`;
+
+		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.destArray = new Uint32Array(4);
+		this.destArray[2] = this.width;
+		this.destArray[3] = this.height;
     }
 }

package/src/engine/render.ts

@@ -7,13 +7,19 @@ export default class Render {
 
     public static pointer : Pointer;
     public static surface: Pointer;
+    public static destArray : Uint32Array;
 
     public static createRenderer(width: number, height: number) {
-        const renPointer = libsdl.symbols.SDL_CreateRenderer(Window.pointer, -1, 0);
+        const renPointer = libsdl.symbols.SDL_CreateRenderer(Window.pointer, -1, 0x00000004 + 0x00000002);
         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;
+		this.destArray = new Uint32Array(4);
+		this.destArray[0] = 0;
+		this.destArray[1] = 0;
+		this.destArray[2] = width;
+		this.destArray[3] = height;
     }
 }

package/src/engine/window.ts

@@ -12,19 +12,19 @@ export default class Window {
 
 	
 
-    public static createWindow(title: string, size: Vector2) : void {
+    public static createWindow(title: string, width: number, height: number) : void {
         const winPointer = libsdl.symbols.SDL_CreateWindow(
             Buffer.from(title + '\x00'),
             this.centerPos,
             this.centerPos,
-            size.x,
-            size.y,
+            width,
+            height,
             0
         );
 
         if (winPointer == null) throw `Window creation failed.`;
         this.pointer = winPointer;
-        this.size = size;
+        this.size = new Vector2(width, height);
     }
 
     public setTitle(title: string): void {
@@ -49,4 +49,8 @@ export default class Window {
     public centerWindow() {
         this.setPosition(new Vector2(Window.centerPos, Window.centerPos));
     }
+
+    public setSize(width: number, height: number) {
+    	libsdl.symbols.SDL_SetWindowSize(Window.pointer, width, height);
+    }
 }

package/src/ffi.ts

@@ -27,10 +27,14 @@ if (process.platform == "win32") {
     //@ts-expect-error
     libMixerImport = await import("../libs/libSDL2_mixer.dylib");
 } else if (process.platform == "linux") {
-    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`);
+	//@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");
 }
 
 /** @internal */
@@ -242,6 +246,10 @@ export const libsdl = dlopen(libSDLImport.default, {
     SDL_MapRGB: {
     	args: ['pointer', 'int', 'int', 'int'],
     	returns: 'u32'
+    },
+    SDL_FreeSurface: {
+    	args: ['pointer'],
+    	returns: 'void'
     }
 });
 

package/src/modules/graphics.ts

@@ -25,28 +25,24 @@ export default class Graphics {
         libsdl.symbols.SDL_DestroyTexture(texture);
     }
     
-    public draw(drawable: Image | Canvas, x: number, y: number, scaleX?: number, scaleY?: number) : void {
+    public draw(drawable: Image | Canvas, x: number, y: 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);
+		(drawable as any).destArray[0] = x;
+		(drawable as any).destArray[1] = y;
+		
 		        
         libsdl.symbols.SDL_UpperBlitScaled(
         	(drawable as any).pointer,
         	null,
         	Render.surface,
-        	ptr(destArray)
+        	ptr((drawable as any).destArray)
         );
     }
 
     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);
+		const _col = ((color.r << 16) + (color.g << 8) + (color.b << 0));
+		libsdl.symbols.SDL_FillRect(Render.surface, ptr(Render.destArray), _col);
+
    	}
 
     public drawRect(rectangle: Rectangle, color: Color) {
@@ -67,7 +63,6 @@ export default class Graphics {
     	
     	libttf.symbols.TTF_SizeText(
     		(font as any).pointer,
-			//@ts-expect-error
     		Buffer.from(text+"\x00"),
     		ptr(wArr),
     		ptr(hArr)
@@ -77,7 +72,6 @@ export default class Graphics {
 
     	const surface = libttf.symbols.TTF_RenderText_Solid(
     		(font as any).pointer,
-    		//@ts-expect-error
     	  	Buffer.from(text+'\x00'),
     	   	_col
     	);
@@ -89,7 +83,7 @@ export default class Graphics {
 		destRect[2] = wArr[0];
 		destRect[3] = hArr[0];
 
-    	libsdl.symbols.SDL_UpperBlit(
+    	libsdl.symbols.SDL_UpperBlitScaled(
 			surface,
 			null,
 			Render.surface,

package/src/slifer.test.ts

@@ -31,13 +31,13 @@ describe("Initializing SDL Mixer ", () => {
 describe("Window Creation ", () => {
     it("Should create window without error", () => {
         expect(() =>
-            Window.createWindow("Game", new Vector2(1, 1))
+            Window.createWindow("Game", 1, 1)
         ).not.toThrow(Error);
     });
 });
 
 describe("Renderer Creation ", () => {
     it("Should create renderer without error", () => {
-        expect(() => Render.createRenderer()).not.toThrow(Error);
+        expect(() => Render.createRenderer(1, 1)).not.toThrow(Error);
     });
 });

package/src/slifer.ts

@@ -30,9 +30,9 @@ class Slifer {
 		this.black = new Color(0,0,0,0);
     }
 
-    public createWindow(title: string, size: Vector2): Window {
-        Window.createWindow(title, size);
-        Render.createRenderer(size.x, size.y);
+    public createWindow(title: string, width: number, height: number): Window {
+        Window.createWindow(title, width, height);
+        Render.createRenderer(width, height);
 
         this.start = Number(libsdl.symbols.SDL_GetTicks64());
 
@@ -41,6 +41,8 @@ class Slifer {
 
     public shouldClose(): boolean {
         libsdl.symbols.SDL_RenderClear(Render.pointer);
+
+        this.Graphics.setBackground(this.black);
 		
         const eventArray = new Uint16Array(32);
         const event = libsdl.symbols.SDL_PollEvent(ptr(eventArray));
@@ -78,6 +80,7 @@ class Slifer {
     }
 
     public quit(): void {
+    	libsdl.symbols.SDL_FreeSurface(Render.surface);
         libsdl.symbols.SDL_DestroyRenderer(Render.pointer);
         libsdl.symbols.SDL_DestroyWindow(Window.pointer);
         libsdl.symbols.SDL_Quit();