commit e45dd56e857447943c9df0285e6d454397a5ec2f Author: Fierelier Date: Sun May 14 12:21:03 2023 +0200 First commit diff --git a/assets/scripts/main.lua b/assets/scripts/main.lua new file mode 100644 index 0000000..48e1012 --- /dev/null +++ b/assets/scripts/main.lua @@ -0,0 +1,6 @@ +texture = engine_loadTexture("assets/textures/fier0.rgba",8,32) + +a = 0 +function engine_onFrame() + engine_renderTexture2D(texture,math.random(-8,102),math.random(-8,72)) +end diff --git a/assets/textures/fier0.rgba b/assets/textures/fier0.rgba new file mode 100644 index 0000000..37ee683 Binary files /dev/null and b/assets/textures/fier0.rgba differ diff --git a/assets/textures/fier1.rgba b/assets/textures/fier1.rgba new file mode 100644 index 0000000..daf854c Binary files /dev/null and b/assets/textures/fier1.rgba differ diff --git a/assets/textures/fier2.rgba b/assets/textures/fier2.rgba new file mode 100644 index 0000000..d7a5138 Binary files /dev/null and b/assets/textures/fier2.rgba differ diff --git a/engine b/engine new file mode 100755 index 0000000..6a0b9b9 Binary files /dev/null and b/engine differ diff --git a/main.c b/main.c new file mode 100644 index 0000000..aad5fc5 --- /dev/null +++ b/main.c @@ -0,0 +1,49 @@ +#include +#include +#include "modules/engine/main.c" +#include "modules/engine/frontend/sdl/main.c" +#include "modules/engine/frontend/generic/textures.c" +#include "modules/engine/addon/lua.c" + +void handleEvent(struct ENGINE_EVENT event) { + if (event.type == ENGINE_EVENT_TYPE_EXIT) { + exit(0); + } +} + +int frame = 0; +int frameSec = 0; +Uint32 lastSec = 0; + +void tick() { + frame += 1; + frameSec += 1; + unsigned long tick = engine_time_get(); + if (tick - lastSec >= 1000) { + printf("FPS: %d\n",frameSec); + lastSec = tick; + frameSec = 0; + } + luaL_loadstring(engine_lua_state,"engine_onFrame()"); + lua_call(engine_lua_state,0,0); + engine_render(); + //engine_sleep(33); +} + +int main(int argc, char **argv) { + for (int i = 0; i < argc; ++i) { + printf("argv[%d]: %s\n", i, argv[i]); + } + + engine_init(96,64,"Game"); + engine_luaInit(); + + while (1) { + struct ENGINE_EVENT event = engine_getEvent(); + if (event.type != ENGINE_EVENT_TYPE_NONE) { + handleEvent(event); + } else { + tick(); + } + } +} diff --git a/modules/engine/addon/lua.c b/modules/engine/addon/lua.c new file mode 100644 index 0000000..b4aff5d --- /dev/null +++ b/modules/engine/addon/lua.c @@ -0,0 +1,51 @@ +#include +#include +#include + +lua_State * engine_lua_state; + +int engine_luafSleep(lua_State *L) { + int time = luaL_checkinteger(L,1); + engine_sleep(time); + return 0; +} + +int engine_luafTimeGet(lua_State *L) { + lua_pushinteger(L,engine_time_get()); + return 1; +} + +int engine_luafLoadTexture(lua_State *L) { + char * fpath = (char *)luaL_checkstring(L,1); + int width = luaL_checkinteger(L,2); + int height = luaL_checkinteger(L,3); + struct ENGINE_TEXTURE * texture = engine_createTexture(width,height); + engine_fileToTexture(texture,fpath); + lua_pushlightuserdata(L,texture); + return 1; +} + +int engine_luafRenderTexture2D(lua_State *L) { + struct ENGINE_TEXTURE * texture = (struct ENGINE_TEXTURE *)lua_touserdata(L,1); + int x = luaL_checkinteger(L,2); + int y = luaL_checkinteger(L,3); + engine_renderTexture2D(texture,x,y); + return 0; +} + +void engine_luaInit() { + engine_lua_state = luaL_newstate(); + luaL_openlibs(engine_lua_state); + + // Functions + lua_pushcfunction(engine_lua_state,engine_luafSleep); + lua_setglobal (engine_lua_state,"engine_sleep"); + lua_pushcfunction(engine_lua_state,engine_luafLoadTexture); + lua_setglobal (engine_lua_state,"engine_loadTexture"); + lua_pushcfunction(engine_lua_state,engine_luafRenderTexture2D); + lua_setglobal (engine_lua_state,"engine_renderTexture2D"); + + // Start user script + luaL_loadfile(engine_lua_state,"assets/scripts/main.lua"); + lua_call(engine_lua_state,0,0); +} diff --git a/modules/engine/frontend/generic/textures.c b/modules/engine/frontend/generic/textures.c new file mode 100644 index 0000000..69a5120 --- /dev/null +++ b/modules/engine/frontend/generic/textures.c @@ -0,0 +1,78 @@ +// Mostly for fun (but can very slightly increase performance for large textures). If set to 1, does not clear texture's affiliated and leaves garbage. +#define ENGINE_GENERIC_TEXTURE_NOCLEAR 1 + +struct ENGINE_TEXTURE { int width; int height; void * fe_texture; }; +struct ENGINE_GENERIC_TEXTURE { char * pixels; }; + +struct ENGINE_TEXTURE * engine_createTexture(int width,int height) { + // frontend texture + char * pixels = engine_malloc(NULL,sizeof(char) * width * height * 4); + #if (ENGINE_GENERIC_TEXTURE_NOCLEAR == 0) + memset(pixels,0,sizeof(char) * width * height * 4); + #endif + struct ENGINE_GENERIC_TEXTURE * fe_texture = engine_malloc(NULL,sizeof(struct ENGINE_GENERIC_TEXTURE)); + fe_texture->pixels = pixels; + + // engine texture + struct ENGINE_TEXTURE * texture = engine_malloc(NULL,sizeof(struct ENGINE_TEXTURE)); + texture->width = width; + texture->height = height; + texture->fe_texture = (void *)fe_texture; + return texture; +} + +struct ENGINE_GENERIC_TEXTURE_COLOR { char r; char g; char b; char a; }; +struct ENGINE_GENERIC_TEXTURE_COLOR engine_generic_texture_color; + +void engine_textureSetColor(char r,char g,char b,char a) { + engine_generic_texture_color.r = r; + engine_generic_texture_color.g = g; + engine_generic_texture_color.b = b; + engine_generic_texture_color.a = a; +} + +void engine_textureDrawPixel(struct ENGINE_TEXTURE * texture,int x,int y) { + char * pixels = ((struct ENGINE_GENERIC_TEXTURE *)(texture->fe_texture))->pixels; + long pixelIndex = (x + y * texture->width) * 4; + pixels[pixelIndex + 0] = engine_generic_texture_color.r; + pixels[pixelIndex + 1] = engine_generic_texture_color.g; + pixels[pixelIndex + 2] = engine_generic_texture_color.b; + pixels[pixelIndex + 3] = engine_generic_texture_color.a; +} + +void engine_textureDestroy(struct ENGINE_TEXTURE * texture) { + struct ENGINE_GENERIC_TEXTURE * fe_texture = (struct ENGINE_GENERIC_TEXTURE *)(texture->fe_texture); + engine_free(fe_texture->pixels); + engine_free(fe_texture); + engine_free(texture); +} + +void engine_renderTexture2D(struct ENGINE_TEXTURE * texture,int sx,int sy) { + char * pixels = ((struct ENGINE_GENERIC_TEXTURE *)(texture->fe_texture))->pixels; + int ex = sx + texture->width; + if (ex > engine_width) { ex = engine_width; } + int ey = sy + texture->height; + if (ey > engine_width) { ey = engine_height; } + int x = sx; + if (x < 0) { x = 0; } + int y = sy; + if (y < 0) { y = 0; } + long pixelIndex = 0; + + while (y < ey) { + while (x < ex) { + pixelIndex = ((x - sx) + (y - sy) * texture->width)*4; + engine_setColor(pixels[pixelIndex],pixels[pixelIndex + 1],pixels[pixelIndex + 2],pixels[pixelIndex + 3]); + engine_drawPixel(x,y); + ++x; + } + x = sx; + ++y; + } +} + +void engine_fileToTexture(struct ENGINE_TEXTURE * texture,char * fpath) { + FILE * f = fopen(fpath,"r"); + fgets(((struct ENGINE_GENERIC_TEXTURE *)(texture->fe_texture))->pixels,texture->width * texture->height,f); + fclose(f); +} diff --git a/modules/engine/frontend/sdl/main.c b/modules/engine/frontend/sdl/main.c new file mode 100644 index 0000000..694a533 --- /dev/null +++ b/modules/engine/frontend/sdl/main.c @@ -0,0 +1,296 @@ +// With much thanks to https://benedicthenshaw.com/soft_render_sdl2.html + +// --- SETTINGS --- +// BUFFER +// How to buffer pixels. +// 0: Use SDL_Surface (fastest in software) +// 1: Use SDL_Renderer (slow?) +// TODO: Add support for GPU texture +#define ENGINE_SDL_BUFFERTYPE 0 + +// TRANSPARENCY +// How to draw transparent pixels (SDL_Surface buffer only). +// 0: Do not handle transparency (Fastest but non-square textures will have a halo around them) +// 1: 1-bit transparency (Alpha values under 128 are not drawn) +// 2: 8-bit transparency (Nice but slow) +// TODO: Add support for SDL_Renderer +#define ENGINE_SDL_TRANSPARENCY 1 + +// --- HACKS --- +// BUFFER +// Use static color conversion. This will speed up rendering, however, the wrong colors may be displayed depending on platform. This only has an effect if ENGINE_SDL_BUFFERTYPE is set to 0. +// 0 = Disable +// 1 = RGBA (raw) +// 2 = BGRA (common) +// TODO: Add custom mode with quicker conversion of known types, and slow conversion for unknown types. +#define ENGINE_SDL_COLOR 2 + +// INTEGER UPSCALING +// 2 makes the surface scaled 2x, 3 = 3x, etc. +// TODO: Fix ENGINE_SDL_TRANSPARENCY 2 +#define ENGINE_SDL_SCALE 5 + +// SKIP: COLOR +// Skip setting colors every X requests. Set to 2 to skip every second request, 3 for every third, etc. +#define ENGINE_SDL_SKIP_COLOR_INTERVAL 0 // 2 +// How many requests to skip, when a skip is encountered. +#define ENGINE_SDL_SKIP_COLOR_AMOUNT 2 +// Whether to alternate fields. TODO +#define ENGINE_SDL_SKIP_COLOR_ALTERNATE 0 + +// SKIP: PIXEL +// Skip setting pixel every X requests. +#define ENGINE_SDL_SKIP_PIXEL_INTERVAL 0 // 2 +#define ENGINE_SDL_SKIP_PIXEL_AMOUNT 2 +#define ENGINE_SDL_SKIP_PIXEL_ALTERNATE 0 + +// SKIP: FRAME +#define ENGINE_SDL_SKIP_FRAME_INTERVAL 1 +#define ENGINE_SDL_SKIP_FRAME_AMOUNT 1 +// Entirely skip changing any colors and pixels on skipped frames, without this, this is pretty useless +#define ENGINE_SDL_SKIP_FRAME_DROP 0 + +// DO NOT TOUCH THESE +#if (ENGINE_SDL_SKIP_COLOR_INTERVAL > 0 && ENGINE_SDL_SKIP_COLOR_AMOUNT > 0) + #define ENGINE_SDL_SKIP_COLOR 1 +#endif + +#if (ENGINE_SDL_SKIP_PIXEL_INTERVAL > 0 && ENGINE_SDL_SKIP_PIXEL_AMOUNT > 0) + #define ENGINE_SDL_SKIP_PIXEL 1 +#endif + +#if (ENGINE_SDL_SKIP_FRAME_INTERVAL > 0 && ENGINE_SDL_SKIP_FRAME_AMOUNT > 0) + #define ENGINE_SDL_SKIP_FRAME 1 +#endif + +#include +SDL_Window * engine_sdl_window; + +#if (ENGINE_SDL_BUFFERTYPE == 0) + SDL_Surface * engine_sdl_surface; + Uint32 * engine_sdl_pixels; +#endif + +#if (ENGINE_SDL_BUFFERTYPE == 1) + SDL_Renderer * engine_sdl_renderer; +#endif + +int engine_width = 0; +int engine_height = 0; + +struct ENGINE_EVENT engine_getEvent() { + struct ENGINE_EVENT event; + SDL_Event sdlevent; + + if (!SDL_PollEvent(&sdlevent)) { + struct ENGINE_EVENT_NONE data; + event.type = ENGINE_EVENT_TYPE_NONE; + event.data = &data; + return event; + } + + if (sdlevent.type == SDL_QUIT) { + struct ENGINE_EVENT_EXIT data; + event.type = ENGINE_EVENT_TYPE_EXIT; + event.data = &data; + return event; + } + + if (sdlevent.type == SDL_KEYDOWN || sdlevent.type == SDL_KEYUP) { + if (sdlevent.key.repeat != 0) { goto unknown; } + struct ENGINE_EVENT_INPUTKB data; + data.pressed = (sdlevent.type == SDL_KEYDOWN); + data.key = sdlevent.key.keysym.scancode; + event.type = ENGINE_EVENT_TYPE_INPUTKB; + event.data = &data; + return event; + } + + unknown: + struct ENGINE_EVENT_UNKNOWN data; + event.type = ENGINE_EVENT_TYPE_UNKNOWN; + event.data = &data; + return event; +} + +void engine_sleep(long long ms) { + SDL_Delay(ms); +} + +long long engine_time_get() { + return SDL_GetTicks(); +} + +#ifdef ENGINE_SDL_SKIP_FRAME + char engine_sdl_skipf_interval = 0; + char engine_sdl_skipf_amount = 0; +#endif + +#ifdef ENGINE_SDL_SKIP_COLOR + char engine_sdl_skipc_interval = 0; + char engine_sdl_skipc_amount = 0; +#endif + +Uint32 engine_sdl_color; +void engine_setColor(char r,char g,char b,char a) { + #ifdef ENGINE_SDL_SKIP_COLOR + if (engine_sdl_skipc_interval == 0) { + if (engine_sdl_skipc_amount == 0) { + engine_sdl_skipc_interval = ENGINE_SDL_SKIP_COLOR_INTERVAL - 1; + engine_sdl_skipc_amount = ENGINE_SDL_SKIP_COLOR_AMOUNT; + } else { + --engine_sdl_skipc_amount; + return; + } + } else { + --engine_sdl_skipc_interval; + } + #endif + + #if (ENGINE_SDL_SKIP_FRAME == 1 && ENGINE_SDL_SKIP_FRAME_DROP == 1) + if (engine_sdl_skipf_interval == 0 && engine_sdl_skipf_amount > 0) { + return; + } + #endif + + #if (ENGINE_SDL_BUFFERTYPE == 0) + #if (ENGINE_SDL_COLOR != 0 || ENGINE_SDL_TRANSPARENCY > 0) + Uint8 * rawcolor = (Uint8 *)&engine_sdl_color; // is doing this ok? + #endif + + #if (ENGINE_SDL_COLOR == 1) + rawcolor[0] = (Uint8)r; + rawcolor[1] = (Uint8)g; + rawcolor[2] = (Uint8)b; + rawcolor[3] = (Uint8)a; + #elif (ENGINE_SDL_COLOR == 2) + rawcolor[0] = (Uint8)b; + rawcolor[1] = (Uint8)g; + rawcolor[2] = (Uint8)r; + rawcolor[3] = (Uint8)a; + #else + engine_sdl_color = SDL_MapRGBA(engine_sdl_surface->format,(Uint8)r,(Uint8)g,(Uint8)b,(Uint8)a); + #if (ENGINE_SDL_TRANSPARENCY > 0) + rawcolor[3] = (Uint8)a; + #endif + #endif + #endif + + #if (ENGINE_SDL_BUFFERTYPE == 1) + SDL_SetRenderDrawColor(engine_sdl_renderer,r,g,b,a); + #endif +} + +#ifdef ENGINE_SDL_SKIP_PIXEL + char engine_sdl_skipp_interval = 0; + char engine_sdl_skipp_amount = 0; +#endif + +void engine_drawPixel(int x,int y) { + #ifdef ENGINE_SDL_SKIP_PIXEL + if (engine_sdl_skipp_interval == 0) { + if (engine_sdl_skipp_amount == 0) { + engine_sdl_skipp_interval = ENGINE_SDL_SKIP_PIXEL_INTERVAL - 1; + engine_sdl_skipp_amount = ENGINE_SDL_SKIP_PIXEL_AMOUNT; + } else { + --engine_sdl_skipp_amount; + return; + } + } else { + --engine_sdl_skipp_interval; + } + #endif + + #if (ENGINE_SDL_SKIP_FRAME == 1 && ENGINE_SDL_SKIP_FRAME_DROP == 1) + if (engine_sdl_skipf_interval == 0 && engine_sdl_skipf_amount > 0) { + return; + } + #endif + + #if (ENGINE_SDL_BUFFERTYPE == 0) + #if (ENGINE_SDL_TRANSPARENCY == 1) + if (((Uint8 *)&engine_sdl_color)[3] < 128) { // is doing this ok? + return; + } + #endif + + #if (ENGINE_SDL_TRANSPARENCY == 2) + Uint8 * rawcolor = (Uint8 *)&engine_sdl_color; + if (rawcolor[3] < 255) { + Uint8 * sourcecolor = (Uint8 *)&engine_sdl_pixels[x + y * engine_width]; + float alpha = (float)rawcolor[3] / 255; + sourcecolor[0] = sourcecolor[0] + ((rawcolor[0] - sourcecolor[0])*alpha); + sourcecolor[1] = sourcecolor[1] + ((rawcolor[1] - sourcecolor[1])*alpha); + sourcecolor[2] = sourcecolor[2] + ((rawcolor[2] - sourcecolor[2])*alpha); + return; + } + #endif + + #if (ENGINE_SDL_SCALE == 1) + engine_sdl_pixels[x + y * engine_width] = engine_sdl_color; + #else + char xi = 0; + while (xi < ENGINE_SDL_SCALE) { + char yi = 0; + while (yi < ENGINE_SDL_SCALE) { + engine_sdl_pixels[((x * ENGINE_SDL_SCALE) + xi) + ((y * ENGINE_SDL_SCALE) + yi) * (engine_width * ENGINE_SDL_SCALE)] = engine_sdl_color; + ++yi; + } + ++xi; + } + #endif + #endif + + #if (ENGINE_SDL_BUFFERTYPE == 1) + SDL_RenderDrawPoint(engine_sdl_renderer,x,y); + #endif +} + +void engine_render() { + #ifdef ENGINE_SDL_SKIP_FRAME + if (engine_sdl_skipf_interval == 0) { + if (engine_sdl_skipf_amount == 0) { + engine_sdl_skipf_interval = ENGINE_SDL_SKIP_FRAME_INTERVAL - 1; + engine_sdl_skipf_amount = ENGINE_SDL_SKIP_FRAME_AMOUNT; + } else { + --engine_sdl_skipf_amount; + return; + } + } else { + --engine_sdl_skipf_interval; + } + #endif + + #if (ENGINE_SDL_BUFFERTYPE == 0) + SDL_UpdateWindowSurface(engine_sdl_window); + #endif + + #if (ENGINE_SDL_BUFFERTYPE == 1) + SDL_RenderPresent(engine_sdl_renderer); + #endif +} + +void engine_init(int width,int height,char *title) { + SDL_Init(SDL_INIT_VIDEO); + engine_sdl_window = SDL_CreateWindow(title,SDL_WINDOWPOS_CENTERED,SDL_WINDOWPOS_CENTERED,width * ENGINE_SDL_SCALE,height * ENGINE_SDL_SCALE,0); + #if (ENGINE_SDL_BUFFERTYPE == 0) + engine_sdl_surface = SDL_GetWindowSurface(engine_sdl_window); + engine_sdl_pixels = engine_sdl_surface->pixels; + #endif + + #if (ENGINE_SDL_BUFFERTYPE == 1) + engine_sdl_renderer = SDL_CreateRenderer(engine_sdl_window,-1,0); + #endif + + engine_width = width; + engine_height = height; + + #if (ENGINE_SDL_BUFFERTYPE == 1) + engine_setColor(0,0,0,255); + #ifdef ENGINE_SDL_SKIP_COLOR + engine_sdl_skipc_interval = 0; + engine_sdl_skipc_amount = 0; + #endif + SDL_RenderClear(engine_sdl_renderer); + #endif +} diff --git a/modules/engine/main.c b/modules/engine/main.c new file mode 100644 index 0000000..daf3fc2 --- /dev/null +++ b/modules/engine/main.c @@ -0,0 +1,22 @@ +struct ENGINE_EVENT { char type; void * data; }; +static char ENGINE_EVENT_TYPE_UNKNOWN = 0; +struct ENGINE_EVENT_UNKNOWN { }; +static char ENGINE_EVENT_TYPE_NONE = 1; +struct ENGINE_EVENT_NONE { }; +static char ENGINE_EVENT_TYPE_EXIT = 2; +struct ENGINE_EVENT_EXIT { }; +static char ENGINE_EVENT_TYPE_INPUTKB = 2; +struct ENGINE_EVENT_INPUTKB { char key; char pressed; }; + +void * engine_malloc(void * pnt,size_t size) { + void * mem = realloc(pnt,size); + if (mem == NULL) { + printf("ERROR: Could not allocate memory.\n"); + exit(1); + } + return mem; +} + +void engine_free(void *pnt) { + free(pnt); +} diff --git a/run b/run new file mode 100755 index 0000000..4f1f285 --- /dev/null +++ b/run @@ -0,0 +1,4 @@ +#!/usr/bin/env bash +set -e +gcc main.c -g -lSDL2 -llua5.3 -o engine -O3 -Werror -Wall +exec ./engine diff --git a/test.c b/test.c new file mode 100644 index 0000000..1c8b19e --- /dev/null +++ b/test.c @@ -0,0 +1,144 @@ +#include +#include +#include "modules/engine/main.c" +#include "modules/engine/frontend/sdl/main.c" +#include "modules/engine/frontend/generic/textures.c" +//#include "modules/engine/frontend/sdl/textures.c" // TODO + +void handleEvent(struct ENGINE_EVENT event) { + if (event.type == ENGINE_EVENT_TYPE_EXIT) { + exit(0); + } +} + +int frame = 0; +int frameSec = 0; +Uint32 lastSec = 0; +char tr, tg, tb; + +struct ENGINE_TEXTURE * texture; +void tick() { + int y = 0; + while (y < engine_height) { + int x = 0; + while (x < engine_width) { + /*tr = (char)(x + y) + ((char)frame * 1); + tg = (char)(x + y) + ((char)frame * 3); + tb = (char)(x + y) + ((char)frame * 5);*/ + + /*tr = (char)(x + y) * (char)frame * 1; + tg = (char)(x + y) * (char)frame * 3; + tb = (char)(x + y) * (char)frame * 5;*/ + + tr = (char)((x * y) + 64) + frame; + tg = (char)((x * y) + 128) + frame; + tb = (char)((x * y) + 192) + frame; + + /*int part = engine_width / 3; + if (x < part * 1) { + tr = 255; + tg = 0; + tb = 0; + } else if (x < part * 2) { + tr = 0; + tg = 255; + tb = 0; + } else { + tr = 0; + tg = 0; + tb = 255; + }*/ + + /*tr = 0; + tg = 255 - ((char)((x * y) + 128) + frame); + tb = 0;*/ + + /*tr = (char)(((float)x / (float)engine_width) * 255); + tg = 255 - tr; + tb = (char)(((float)y / (float)engine_height) * 255);*/ + engine_setColor(tr,tg,tb,255); + engine_drawPixel(x,y); + ++x; + } + ++y; + } + + //y = 0; + //while (y < engine_height) { + // int x = 0; + // while (x < engine_width) { + // tr = (char)(x + y) + ((char)frame * 1); + // tg = (char)(x + y) + ((char)frame * 3); + // tb = (char)(x + y) + ((char)frame * 5); + + /*tr = (char)(x + y) * (char)frame * 1; + tg = (char)(x + y) * (char)frame * 3; + tb = (char)(x + y) * (char)frame * 5;*/ + + /*tr = (char)((x * y) + 64) + frame; + tg = (char)((x * y) + 128) + frame; + tb = (char)((x * y) + 192) + frame;*/ + + /*int part = engine_width / 3; + if (x < part * 1) { + tr = 255; + tg = 0; + tb = 0; + } else if (x < part * 2) { + tr = 0; + tg = 255; + tb = 0; + } else { + tr = 0; + tg = 0; + tb = 255; + }*/ + + /*tr = 0; + tg = 255 - ((char)((x * y) + 128) + frame); + tb = 0;*/ + + /*tr = (char)(((float)x / (float)engine_width) * 255); + tg = 255 - tr; + tb = (char)(((float)y / (float)engine_height) * 255);*/ + // engine_setColor(tr,tg,tb,128); + // engine_drawPixel(x,y); + // ++x; + // } + // ++y; + //} + + + engine_renderTexture2D(texture,5,5); + + frame += 1; + frameSec += 1; + Uint32 tick = SDL_GetTicks(); + if (tick - lastSec >= 1000) { + printf("FPS: %d\n",frameSec); + lastSec = tick; + frameSec = 0; + } + engine_render(); + //engine_sleep(33); +} + +int main(int argc, char **argv) { + texture = engine_createTexture(8,8); + engine_fileToTexture(texture,"assets/textures/fier.rgba"); + + for (int i = 0; i < argc; ++i) { + printf("argv[%d]: %s\n", i, argv[i]); + } + + engine_init(256,256,"Game"); + + while (1) { + struct ENGINE_EVENT event = engine_getEvent(); + if (event.type != ENGINE_EVENT_TYPE_NONE) { + handleEvent(event); + } else { + tick(); + } + } +}