slifer 0.2.7 → 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

@@ -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.8",
     "description": "A game framework made for bun and typescript",
     "module": "index.ts",
     "devDependencies": {

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/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/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/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

@@ -222,6 +222,26 @@ 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'
     }
 });
 

package/src/modules/graphics.ts

@@ -4,118 +4,97 @@ 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, 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,
+        	Render.surface,
+        	ptr(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 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,
-	    	Buffer.from(text+"\x00"),
-	    	ptr(wArr),
-	    	ptr(hArr)
+    		(font as any).pointer,
+			//@ts-expect-error
+    		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
+    		//@ts-expect-error
+    	  	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_UpperBlit(
+			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.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();
+        Render.createRenderer(size.x, size.y);
 
         this.start = Number(libsdl.symbols.SDL_GetTicks64());
 
@@ -39,7 +41,7 @@ class Slifer {
 
     public shouldClose(): boolean {
         libsdl.symbols.SDL_RenderClear(Render.pointer);
-
+		
         const eventArray = new Uint16Array(32);
         const event = libsdl.symbols.SDL_PollEvent(ptr(eventArray));
         if (event) {