slifer 0.1.6 → 0.1.8

package/package.json

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

package/src/modules/graphics.ts

@@ -2,6 +2,7 @@ import { libimage, libsdl, libttf } from "../ffi";
 import Global from "../global";
 import { type Pointer, ptr } from 'bun:ffi';
 import path from 'path';
+import type { Rectangle, Vector2 } from "../slifer";
 
 /** @internal */
 class Graphics {
@@ -47,6 +48,7 @@ class Graphics {
      */
     loadImage(path: string) : Image {
         const _path = Buffer.from(path + "\x00");
+      //@ts-expect-error Buffer and CString differences
         const surface = libimage.symbols.IMG_Load(_path);
         if (surface == null) throw `Image failed to load`;
         const texture = libsdl.symbols.SDL_CreateTextureFromSurface(Global.ptrRenderer, surface);
@@ -65,19 +67,33 @@ class Graphics {
      * @param ys (optional) scale of y axis
      * @param flip (optional) horizontal flip
      */
-    draw(image: Image, x: number, y: number, rotation?: number, xs?: number, ys?: number, flip?: true) {
+    draw(image: Image, position: Vector2, clipRectangle?: Rectangle, rotation?: number, xs?: number, ys?: number, flip?: true) {
         const _dest = new Uint32Array(4);
         const wArr = new Uint32Array(1);
         const hArr = new Uint32Array(1);
-        libsdl.symbols.SDL_QueryTexture((image as any).pointer, null, null, ptr(wArr), ptr(hArr));
-        _dest[0] = x;
-        _dest[1] = y;
+        let srcRect: null | Uint32Array = null;
+        
+        if (clipRectangle == undefined) {
+            libsdl.symbols.SDL_QueryTexture((image as any).pointer, null, null, ptr(wArr), ptr(hArr));
+        } else {
+            srcRect = new Uint32Array(4);
+            srcRect[0] = clipRectangle.x;
+            srcRect[1] = clipRectangle.y;
+            srcRect[2] = clipRectangle.width;
+            srcRect[3] = clipRectangle.height;
+            wArr[0] = clipRectangle.width;
+            hArr[0] = clipRectangle.height;
+        }
+
+        
+        _dest[0] = position.x;
+        _dest[1] = position.y;
         _dest[2] = wArr[0] * (xs ? xs : 1);
         _dest[3] = hArr[0] * (ys ? ys : 1);
         const _center = new Uint32Array(2);
         _center[0] = _dest[2] / 2;
         _center[1] = _dest[3] / 2;
-        libsdl.symbols.SDL_RenderCopyEx(Global.ptrRenderer, (image as any).pointer, null, ptr(_dest), rotation ? rotation : 0, ptr(_center), flip ? Number(flip) : 0);
+        libsdl.symbols.SDL_RenderCopyEx(Global.ptrRenderer, (image as any).pointer, srcRect, ptr(_dest), rotation ? rotation : 0, ptr(_center), flip ? Number(flip) : 0);
     }
 
     /**
@@ -96,12 +112,14 @@ class Graphics {
         // Get width and height of text        
         const wArr = new Uint32Array(1);
         const hArr = new Uint32Array(1);
+      //@ts-expect-error Buffer and CString differences
         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
+      //@ts-expect-error Buffer and CString differences
         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);
@@ -125,6 +143,7 @@ class Graphics {
      * @param pt size of text
      */
     setFont(path: string, pt: number) {
+      //@ts-expect-error Buffer and CString differences
         const tempFont = libttf.symbols.TTF_OpenFont(Buffer.from(path+"\x00"), pt);
         if (tempFont == null) throw `Font loading failed`;
         Global.ptrFont = tempFont;

package/src/slifer.ts

@@ -4,10 +4,10 @@ import { ptr } from "bun:ffi";
 import Graphics from "./modules/graphics";
 import Keyboard from "./modules/keyboard";
 import Mouse from "./modules/mouse";
-import { version } from '../package.json';
+import { version } from "../package.json";
 
 //@ts-expect-error
-const fontFile = await import("../Jacquard_12/Jacquard12-Regular.ttf");
+const fontFile = await import("./Jost-Bold.ttf");
 
 /** @internal */
 class Window {
@@ -21,36 +21,49 @@ class Window {
     this.title = title;
   }
 
-  setSize(width: number, height: number) : void {
+  setSize(width: number, height: number): void {
     libsdl.symbols.SDL_SetWindowSize(Global.ptrWindow, width, height);
   }
 
-  setTitle(title: string) : void {
-    libsdl.symbols.SDL_SetWindowTitle(Global.ptrWindow, Buffer.from(title+'\x00'));
+  setTitle(title: string): void {
+    libsdl.symbols.SDL_SetWindowTitle(
+      Global.ptrWindow,
+      //@ts-expect-error Buffer and CString differences
+      Buffer.from(title + "\x00")
+    );
   }
 
-  setFullscreen(flag: boolean) : void {
+  setFullscreen(flag: boolean): void {
     libsdl.symbols.SDL_SetWindowFullscreen(Global.ptrWindow, Number(flag));
   }
 
-  centerWindow() : void {
-    libsdl.symbols.SDL_SetWindowPosition(Global.ptrWindow, 0x2FFF0000, 0x2FFF0000);
+  centerWindow(): void {
+    libsdl.symbols.SDL_SetWindowPosition(
+      Global.ptrWindow,
+      0x2fff0000,
+      0x2fff0000
+    );
   }
 
-  setPosition(x: number, y: number) : void {
+  setPosition(x: number, y: number): void {
     libsdl.symbols.SDL_SetWindowPosition(Global.ptrWindow, x, y);
   }
 }
 
 /** @interal */
 export class SliferClass {
-  isRunning: boolean = true;
+  private isRunning: boolean = true;
+  private lastFrame: number = 0;
+  private firstFrame: number = 0;
 
   // Modules
   Graphics = new Graphics();
   Keyboard = new Keyboard();
   Mouse = new Mouse();
 
+  // Public Variables
+  public dt: number = 0;
+
   constructor() {
     const baseInit = libsdl.symbols.SDL_Init(0x00000020);
     if (baseInit != 0) throw `SDL failed to initialize`;
@@ -79,12 +92,13 @@ export class SliferClass {
     }
     */
 
-    
-
     const tempFont = libttf.symbols.TTF_OpenFont(
-      Buffer.from(fontFile.default), 24);
-      if (tempFont == null) throw `Default font loading failed`;
-      Global.ptrFont = tempFont;
+      //@ts-expect-error Buffer and CString differences
+      Buffer.from(fontFile.default),
+      24
+    );
+    if (tempFont == null) throw `Default font loading failed`;
+    Global.ptrFont = tempFont;
   }
 
   /**
@@ -98,12 +112,13 @@ export class SliferClass {
 
     // Creating window pointer
     const _win = libsdl.symbols.SDL_CreateWindow(
+      //@ts-expect-error Buffer and CString differences
       _title,
-      0x2FFF0000,
-      0x2FFF0000,
+      0x2fff0000,
+      0x2fff0000,
       width,
       height,
-      0,
+      0
     );
     if (_win == null) throw `Window creation failed`;
     Global.ptrWindow = _win;
@@ -113,6 +128,8 @@ export class SliferClass {
     if (_ren == null) throw `Renderer Creation failed`;
     Global.ptrRenderer = _ren;
 
+    this.firstFrame = Number(libsdl.symbols.SDL_GetPerformanceCounter());
+
     return new Window(title, width, height);
   }
 
@@ -123,6 +140,13 @@ export class SliferClass {
     // Clear the renderer
     libsdl.symbols.SDL_RenderClear(Global.ptrRenderer);
 
+    // Setup deltatime
+    this.lastFrame = this.firstFrame;
+    this.firstFrame = Number(libsdl.symbols.SDL_GetPerformanceCounter());
+
+    this.dt = ((this.firstFrame - this.lastFrame) * 1000 / Number(libsdl.symbols.SDL_GetPerformanceFrequency()));
+
+
     // Poll Events
     const eventArray = new Uint16Array(32);
     const isEvent = libsdl.symbols.SDL_PollEvent(ptr(eventArray));
@@ -177,3 +201,34 @@ export class SliferClass {
     return version;
   }
 }
+
+export class Vector2 {
+  x;
+  y;
+
+  constructor(x: number, y: number) {
+    this.x = x;
+    this.y = y;
+  }
+}
+
+export class Rectangle {
+  private readonly pointer;
+  readonly x;
+  readonly y;
+  readonly width;
+  readonly height;
+
+  constructor(x: number, y: number, width: number, height: number) {
+    const arr = new Uint32Array(4);
+    arr[0] = x;
+    arr[1] = y;
+    arr[2] = width;
+    arr[3] = height;
+    this.pointer = ptr(arr);
+    this.x = x;
+    this.y = y;
+    this.width = width;
+    this.height = height;
+  }
+}

package/Jacquard_12/OFL.txt

@@ -1,93 +0,0 @@
-Copyright 2023 The Soft Type Project Authors (https://github.com/scfried/soft-type-jacquard)
-
-This Font Software is licensed under the SIL Open Font License, Version 1.1.
-This license is copied below, and is also available with a FAQ at:
-https://openfontlicense.org
-
-
------------------------------------------------------------
-SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
------------------------------------------------------------
-
-PREAMBLE
-The goals of the Open Font License (OFL) are to stimulate worldwide
-development of collaborative font projects, to support the font creation
-efforts of academic and linguistic communities, and to provide a free and
-open framework in which fonts may be shared and improved in partnership
-with others.
-
-The OFL allows the licensed fonts to be used, studied, modified and
-redistributed freely as long as they are not sold by themselves. The
-fonts, including any derivative works, can be bundled, embedded, 
-redistributed and/or sold with any software provided that any reserved
-names are not used by derivative works. The fonts and derivatives,
-however, cannot be released under any other type of license. The
-requirement for fonts to remain under this license does not apply
-to any document created using the fonts or their derivatives.
-
-DEFINITIONS
-"Font Software" refers to the set of files released by the Copyright
-Holder(s) under this license and clearly marked as such. This may
-include source files, build scripts and documentation.
-
-"Reserved Font Name" refers to any names specified as such after the
-copyright statement(s).
-
-"Original Version" refers to the collection of Font Software components as
-distributed by the Copyright Holder(s).
-
-"Modified Version" refers to any derivative made by adding to, deleting,
-or substituting -- in part or in whole -- any of the components of the
-Original Version, by changing formats or by porting the Font Software to a
-new environment.
-
-"Author" refers to any designer, engineer, programmer, technical
-writer or other person who contributed to the Font Software.
-
-PERMISSION & CONDITIONS
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of the Font Software, to use, study, copy, merge, embed, modify,
-redistribute, and sell modified and unmodified copies of the Font
-Software, subject to the following conditions:
-
-1) Neither the Font Software nor any of its individual components,
-in Original or Modified Versions, may be sold by itself.
-
-2) Original or Modified Versions of the Font Software may be bundled,
-redistributed and/or sold with any software, provided that each copy
-contains the above copyright notice and this license. These can be
-included either as stand-alone text files, human-readable headers or
-in the appropriate machine-readable metadata fields within text or
-binary files as long as those fields can be easily viewed by the user.
-
-3) No Modified Version of the Font Software may use the Reserved Font
-Name(s) unless explicit written permission is granted by the corresponding
-Copyright Holder. This restriction only applies to the primary font name as
-presented to the users.
-
-4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
-Software shall not be used to promote, endorse or advertise any
-Modified Version, except to acknowledge the contribution(s) of the
-Copyright Holder(s) and the Author(s) or with their explicit written
-permission.
-
-5) The Font Software, modified or unmodified, in part or in whole,
-must be distributed entirely under this license, and must not be
-distributed under any other license. The requirement for fonts to
-remain under this license does not apply to any document created
-using the Font Software.
-
-TERMINATION
-This license becomes null and void if any of the above conditions are
-not met.
-
-DISCLAIMER
-THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
-OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
-COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
-DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
-OTHER DEALINGS IN THE FONT SOFTWARE.