slifer 0.2.7 → 0.2.9

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

@@ -5,6 +5,7 @@ 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, Rectangle, Font, 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.7",
+    "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

@@ -0,0 +1,90 @@
+import { type Pointer, ptr } from 'bun: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;
+
+	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;
+		this.destArray = new Uint32Array(4);
+		this.destArray[2] = this.width;
+		this.destArray[3] = this.height;
+	}
+
+	private drawBG(color: Color) {
+		const _col = ((color.r << 16) + (color.g << 8) + (color.b << 0));
+
+		libsdl.symbols.SDL_FillRect(this.pointer, ptr(this.destArray), _col);
+	}
+
+	clear() {
+        this.drawBG(new Color(0, 0, 0, 0));
+	}
+
+	setBackground(color: Color) {
+		this.drawBG(color);
+	}
+
+	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((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

@@ -1,34 +1,45 @@
 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;
+    private destArray: 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;
+        const surface = libimage.symbols.IMG_Load(cs);
+        if (surface == null) throw `Loading ${path} failed`;
+        this.pointer = surface;
+
+
+		// 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

@@ -6,10 +6,20 @@ import Window from "./window";
 export default class Render {
 
     public static pointer : Pointer;
+    public static surface: Pointer;
+    public static destArray : Uint32Array;
 
-    public static createRenderer() {
-        const renPointer = libsdl.symbols.SDL_CreateRenderer(Window.pointer, -1, 0);
+    public static createRenderer(width: number, height: number) {
+        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

@@ -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 {
+	
+
+    public static createWindow(title: string, width: number, height: number) : void {
         const winPointer = libsdl.symbols.SDL_CreateWindow(
-            //@ts-expect-error Buffer error
             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 = new Vector2(width, height);
     }
 
     public setTitle(title: string): void {
         libsdl.symbols.SDL_SetWindowTitle(
             Window.pointer,
-            //@ts-expect-error Buffer error
             Buffer.from(title + "\x00")
         );
     }
@@ -46,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 */
@@ -222,6 +226,30 @@ export const libsdl = dlopen(libSDLImport.default, {
     },
     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'
+    },
+    SDL_FreeSurface: {
+    	args: ['pointer'],
+    	returns: 'void'
     }
 });
 

package/src/modules/graphics.ts

@@ -4,118 +4,91 @@ 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 {
 
     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);
     }
     
-    public draw(image: Image, x: number, y: number) : void {
-
-        (image as any).destArr[0] = x;
-        (image as any).destArr[1] = y;
-        
-        libsdl.symbols.SDL_RenderCopy(
-            Render.pointer,
-            (image as any).pointer,
-            null,
-            ptr((image as any).destArr)
-        );
-    }
-
-    public drawEx(image: Image, x: number, y: number, rotation?: number, scaleX?: number, scaleY?: number, flipH?: boolean) {
-        
-        const destArr = (image as any).destArr;
-        destArr[0] = x;
-        destArr[1] = y;
-        destArr[2] = image.width * (scaleX ? scaleX : 1)
-        destArr[3] = image.height * (scaleY ? scaleY : 1);
-
-        libsdl.symbols.SDL_RenderCopyEx(
-            Render.pointer,
-            (image as any).pointer,
-            null,
-            ptr(destArr),
-            rotation ? rotation : 0,
-            null,
-            Number(flipH)
+    public 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,
+        	Render.surface,
+        	ptr((drawable as any).destArray)
         );
-
-
     }
 
     public setBackground(color: Color) : void {
-        libsdl.symbols.SDL_SetRenderDrawColor(Render.pointer,
-            color.r,
-            color.g,
-            color.b,
-            color.a
-        );
-        libsdl.symbols.SDL_RenderClear(Render.pointer);
-    }
+		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) {
-        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,
-	    	Buffer.from(text+"\x00"),
-	    	ptr(wArr),
-	    	ptr(hArr)
+    		(font as any).pointer,
+    		Buffer.from(text+"\x00"),
+    		ptr(wArr),
+    		ptr(hArr)
     	);
 
-    	const _col = ((color.r << 0) + (color.g << 8) + (color.b << 16));
+    	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
+    	  	Buffer.from(text+'\x00'),
+    	   	_col
     	);
     	if (surface == null) throw `Rendering text failed`;
 
-    	const texture = libsdl.symbols.SDL_CreateTextureFromSurface(
-    		Render.pointer,
-    		surface
+    	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,
+			Render.surface,
+			ptr(destRect)
     	);
-			if (texture == null) throw `Texture Creation failed`;
-
-
-			const destRect = new Uint32Array(4);
-			destRect[0] = x;
-			destRect[1] = y;
-			destRect[2] = wArr[0];
-			destRect[3] = hArr[0];
-			libsdl.symbols.SDL_RenderCopy(
-				Render.pointer,
-				texture,
-				null,
-				ptr(destRect)
-			);
-    	
-
-    	
+		
     }
 }

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

@@ -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,6 +8,7 @@ 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;
@@ -21,16 +21,18 @@ class Slifer {
 
     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 {
-        Window.createWindow(title, size);
-        Renderer.createRenderer();
+    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());
 
@@ -40,6 +42,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));
         if (event) {
@@ -76,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();