KlemenPl/PixelDefense
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
852dc43556dd92b73397e0f49ceb55ed4b04bd56
PixelDefense/game/main.c

674 lines
22 KiB
C
Raw Blame History

#include <rlImGui.h>
#include <raygui.h>
#include <time.h>
#include <raymath.h>
#include <stdlib.h>
#include "systems/systems.h"
#include "components.h"
#include "game_state.h"
#include "game_tileset.h"
#include "input.h"
#include "map_init.h"
#include "map_layers.h"
#include "buildings.h"
#include "ui_widgets.h"
#include "unit_ai.h"
#include "unit_actions.h"
#include "pathfinding.h"
ECS_COMPONENT_DECLARE(Game);
ECS_COMPONENT_DECLARE(InputState);
BzUI *UI = NULL;
ecs_world_t *ECS = NULL;
bool init(void *userData);
void deinit(void *userData);
void update(float dt, void *userData);
void render(float dt, void *userData);
void imguiRender(float dt, void *userData);
bool bzMain(BzAppDesc *appDesc, int argc, const char **argv) {
appDesc->width = 1280;
appDesc->height = 720;
appDesc->title = "PixelDefense";
appDesc->fps = 60;
appDesc->init = (BzAppInitFunc) init;
appDesc->deinit = (BzAppDeinitFunc) deinit;
appDesc->update = (BzAppUpdateFunc) update;
appDesc->render = (BzAppRenderFunc) render;
appDesc->imguiRender = (BzAppRenderFunc) imguiRender;
appDesc->userData = NULL;
//SetConfigFlags(FLAG_WINDOW_RESIZABLE);
return true;
}
void terrainRender(BzTileMap *map, BzTileLayer *layer) {
BzTileset *tileset = bzTileLayerGetTileset(map, layer);
Vector2 drawPos = {layer->offsetX, layer->offsetY};
static f32 elapsed = 0.0f;
elapsed += GetFrameTime();
for (i32 y = 0; y < layer->height; y++) {
for (i32 x = 0; x < layer->width; x++) {
BzTile tile = bzTileLayerGetTile(layer, x, y);
tile = bzTilesetGetTileID(tileset, tile);
if (tile != -1) {
if (terrainHasAnimation(tile)) {
f32 frameDuration = terrainGetAnimationFrame(tile, 0).duration;
i32 numFrames = terrainGetAnimationSequence(tile).frameCount;
i32 frameIdx = (i32) (elapsed / frameDuration) % numFrames;
tile = terrainGetAnimationFrame(tile, frameIdx).frame;
}
Rectangle rec = bzTilesetGetTileRegion(tileset, tile);
DrawTextureRec(tileset->tiles, rec, drawPos, WHITE);
}
drawPos.x += (float) tileset->tileWidth;
}
drawPos.x = layer->offsetX;
drawPos.y += (float) tileset->tileHeight;
}
}
void unloadMap(Game *game) {
ecs_delete_with(ECS, GameEntity);
if (game->map.isValid) {
bzTileMapDestroy(&game->map);
game->map.isValid = false;
}
if (game->entityGrid) {
bzSpatialGridDestroy(game->entityGrid);
game->entityGrid = NULL;
}
}
void loadMap(Game *game, const char *path) {
game->map = bzTileMapCreate(&(BzTileMapDesc) {
.path=path,
.generateCollisionMap=true,
.tilesets[0]=game->tileset,
.layers[LAYER_TERRAIN]=(BzTileLayerDesc) {"terrain", .renderer=terrainRender, .applyColliders=true},
.layers[LAYER_ROCKS]=(BzTileLayerDesc) {"rocks"},
.layers[LAYER_ROCKS2]=(BzTileLayerDesc) {"rocks_s"},
.layers[LAYER_TREES]=(BzTileLayerDesc) {"trees"},
.layers[LAYER_TREES2]=(BzTileLayerDesc) {"trees_s"},
.layers[LAYER_BUILDINGS]=(BzTileLayerDesc) {"buildings", .applyColliders=true},
.layers[LAYER_BUILDING_OWNER]=(BzTileLayerDesc) {"building_ownership", BZ_TILE_LAYER_SKIP_RENDER},
.objectGroups[OBJECTS_GAME]=(BzTileObjectsDesc) {"game"},
.objectGroups[OBJECTS_ENTITIES]=(BzTileObjectsDesc ) {"entities"}
});
game->entityGrid = bzSpatialGridCreate(&(BzSpatialGridDesc) {
.maxWidth=game->map.width * game->map.tileWidth,
.maxHeight=game->map.height * game->map.tileHeight,
.cellWidth=game->map.tileWidth * 4,
.cellHeight=game->map.tileHeight * 4,
.userDataSize=sizeof(ecs_entity_t)
});
game->camera = (Camera2D){ 0 };
game->camera.target = (Vector2) {0, 0};
game->camera.offset = (Vector2) { GetScreenWidth() * 0.5f, GetScreenHeight() * 0.5f };
game->camera.rotation = 0.0f;
game->camera.zoom = 3.0f;
bzTileMapOverrideLayer(&game->map, LAYER_TREES, initTreesLayer);
bzTileMapOverrideLayer(&game->map, LAYER_TREES2, initTreesLayer);
bzTileMapOverrideLayer(&game->map, LAYER_BUILDING_OWNER, initBuildingsLayer);
bzTileMapOverrideObjectGroup(&game->map, OBJECTS_GAME, initGameObjectsLayer);
bzTileMapOverrideObjectGroup(&game->map, OBJECTS_ENTITIES, initEntityObjectsLayer);
}
int cmpDrawData(const void *a, const void *b) {
const DrawData *lhs = (DrawData *) a;
const DrawData *rhs = (DrawData *) b;
f32 dif = (rhs->dst.y) - (lhs->dst.y);
int cmpVal = 0;
if (dif < 0) cmpVal = 1;
else if (dif > 0) cmpVal = -1;
return cmpVal;
}
bool init(void *userData) {
// Center window
int monitor = GetCurrentMonitor();
int monitorWidth = GetMonitorWidth(monitor);
int monitorHeight = GetMonitorHeight(monitor);
int windowWidth = GetScreenWidth();
int windowHeight = GetScreenHeight();
SetWindowPosition((int)(monitorWidth / 2) - (int)(windowWidth / 2), (int)(monitorHeight / 2) - (int)(windowHeight / 2));
BZ_UNUSED(userData);
SetExitKey(0);
UI = bzUICreate();
ECS = ecs_init();
initComponentIDs(ECS);
// For ecs explorer
//ecs_singleton_set(ECS, EcsRest, {0});
//ECS_IMPORT(ECS, FlecsMonitor);
ECS_COMPONENT_DEFINE(ECS, Game);
ecs_singleton_set(ECS, Game, {});
Game *game = ecs_singleton_get_mut(ECS, Game);
game->screen = SCREEN_MAIN_MENU;
game->font = LoadFontEx("assets/fonts/CompassPro.ttf", 92, NULL, 0);
game->drawData = bzArrayCreate(DrawData, 1000);
game->drawQuery = ecs_query(ECS, {
.filter.terms = {
{ ecs_id(Position) },
{ ecs_id(Size) },
{ ecs_id(Rotation) },
{ ecs_id(TextureRegion) }
},
});
ECS_COMPONENT_DEFINE(ECS, InputState);
ecs_singleton_set(ECS, InputState, {});
InputState *input = ecs_singleton_get_mut(ECS, InputState);
input->mapping = inputDefaultMapping();
// Create queries
input->queries.selected = ecs_query(ECS, {
.filter.terms = {
{ ecs_id(Position) }, { ecs_id(Size) }, { ecs_id(Selected) }
}
});
game->stackAlloc = bzStackAllocCreate(10 * 1000 * 1000); // 10 MB
// init pools
game->pools.pathData = bzObjectPoolCreate(&(BzObjectPoolDesc) {
.objectSize = sizeof(PathData),
.objectsPerPage = 512
});
game->pools.actions = bzObjectPoolCreate(&(BzObjectPoolDesc) {
.objectSize = sizeof(Action),
.objectsPerPage = 1024,
});
game->frameDuration = 0.16f;
game->tileset = bzTilesetCreate( &(BzTilesetDesc) {
.path="assets/game.tsj",
.texturePath="assets/game.png"
});
// Fixes texture bleeding
GenTextureMipmaps(&game->tileset.tiles);
SetTextureWrap(game->tileset.tiles, TEXTURE_WRAP_CLAMP);
SetTextureFilter(game->tileset.tiles, TEXTURE_FILTER_POINT);
setupSystems();
loadMap(game, "assets/maps/main_menu_01.tmj");
game->debugDraw.mapColliders = true;
game->debugDraw.spatialGrid = true;
game->debugDraw.path = true;
return true;
}
void deinit(void *userData) {
BZ_UNUSED(userData);
Game *game = ecs_singleton_get_mut(ECS, Game);
InputState *input = ecs_singleton_get_mut(ECS, InputState);
unloadMap(game);
// Destroy queries
ecs_query_fini(input->queries.selected);
ecs_query_fini(game->drawQuery);
Game gameCopy = *game;
InputState inputCopy = *input;
// Destroy ECS
ecs_fini(ECS);
ECS = NULL;
game = &gameCopy;
input = &inputCopy;
bzTilesetDestroy(&game->tileset);
bzStackAllocDestroy(&game->stackAlloc);
bzObjectPoolDestroy(game->pools.pathData);
bzObjectPoolDestroy(game->pools.actions);
bzArrayDestroy(game->drawData);
bzUIDestroy(UI);
UI = NULL;
UnloadFont(game->font);
}
void update(float dt, void *userData) {
BZ_UNUSED(userData);
char titleBuf[32];
snprintf(titleBuf, sizeof(titleBuf), "FPS: %d | %.2f ms", GetFPS(), GetFrameTime() * 1000);
SetWindowTitle(titleBuf);
Game *game = ecs_singleton_get_mut(ECS, Game);
InputState *input = ecs_singleton_get_mut(ECS, InputState);
BZ_ASSERT(game->stackAlloc.allocated == 0);
bzStackAllocReset(&game->stackAlloc);
updateInputState(input, game->camera, dt);
switch (game->screen) {
case SCREEN_GAME:
updatePlayerInput();
if (IsKeyReleased(input->mapping.backBtn)) {
game->screen = SCREEN_PAUSE_MENU;
}
break;
case SCREEN_PAUSE_MENU:
if (IsKeyReleased(input->mapping.backBtn)) {
game->screen = SCREEN_GAME;
}
break;
case SCREEN_MAIN_MENU:
break;
case SCREEN_SETTINGS:
break;
}
}
static void drawOverScreen(Color c) {
i32 width = GetScreenWidth();
i32 height = GetScreenHeight();
DrawRectangle(0, 0, width, height, c);
}
static void renderGame(Game *game, float dt) {
ClearBackground(RAYWHITE);
BeginMode2D(game->camera);
// Map
bzTileMapDraw(&game->map);
// Ground UI
drawPlayerInputUIGround();
// Entities
bzArrayClear(game->drawData);
ecs_iter_t it = ecs_query_iter(ECS, game->drawQuery);
while (ecs_iter_next(&it)) {
Position *p = ecs_field(&it, Position, 1);
Size *s = ecs_field(&it, Size, 2);
Rotation *r = ecs_field(&it, Rotation, 3);
TextureRegion *t = ecs_field(&it, TextureRegion, 4);
for (i32 i = 0; i < it.count; i++) {
Rectangle dst = {p[i].x, p[i].y, s[i].x, s[i].y};
Vector2 origin = {dst.width * 0.5f, dst.height};
dst.x += origin.x - dst.width * 0.5f;
dst.y += origin.y - dst.height * 0.5f;
Rectangle src = t[i].rec;
// Fixes texture bleeding issue
src.x += 0.01f;
src.y += 0.01f;
src.width -= 0.01f;
src.height -= 0.01f;
if (t[i].flipX) src.width *= -1.0f;
if (t[i].flipY) src.height *= -1.0f;
bzArrayPush(game->drawData, (DrawData) {
.tex = t[i].texture,
.src = src,
.dst = dst,
.origin = origin,
.rotation = r[i]
});
}
}
qsort(game->drawData, bzArraySize(game->drawData), sizeof(*game->drawData), cmpDrawData);
for (i32 i = 0; i < bzArraySize(game->drawData); i++) {
DrawData draw = game->drawData[i];
DrawTexturePro(draw.tex, draw.src, draw.dst, draw.origin, draw.rotation, WHITE);
}
ecs_progress(ECS, dt);
ecs_enable(ECS, renderDebugPathSystem, game->debugDraw.path);
ecs_enable(ECS, renderCollidersSystem, game->debugDraw.entityColliders);
if (game->debugDraw.mapColliders)
bzTileMapDrawCollisions(&game->map);
if (game->debugDraw.spatialGrid)
bzSpatialGridDrawDebugGrid(game->entityGrid);
drawPlayerInputUI();
EndMode2D();
}
static void renderGameMenu(Game *game, float dt) {
// UI
i32 width = GetScreenWidth();
i32 height = GetScreenHeight();
bzUIBegin(UI, width, height);
bzUISetParentLayout(UI, (BzUILayout) {
.type = BZ_UI_LAYOUT_FLEX_BOX,
.flags = BZ_UI_FLEX_DIR_COLUMN |
BZ_UI_FLEX_JUSTIFY_SPACE_BETWEEN |
BZ_UI_FLEX_ALIGN_CENTER
});
// top bar
f32 topBarHeight = 0.05f;
BzUINode *topBar = uiPushDivParentPercentage(1.0f, topBarHeight);
bzUISetParentLayout(UI, (BzUILayout) {
.type = BZ_UI_LAYOUT_FLEX_BOX,
.flags = BZ_UI_FLEX_DIR_ROW |
BZ_UI_FLEX_ALIGN_CENTER |
BZ_UI_FLEX_JUSTIFY_START
});
Color topBarBG = {0, 0, 0, 50};
bzUISetBackgroundStyle(UI, topBar, (BzUIBackgroundStyle) {
.normal = topBarBG,
.hover = topBarBG,
.active = topBarBG,
});
BzTileset *tileset = &game->tileset;
Rectangle woodRec = bzTilesetGetTileRegion(tileset, getEntityTile(ENTITY_WOOD));
Rectangle stoneRec = bzTilesetGetTileRegion(tileset, getEntityTile(ENTITY_STONE));
Rectangle foodRec = bzTilesetGetTileRegion(tileset, getEntityTile(ENTITY_APPLE));
Rectangle goldRec = bzTilesetGetTileRegion(tileset, getEntityTile(ENTITY_GOLD));
Rectangle popRec = bzTilesetGetTileRegion(tileset, getEntityTile(ENTITY_POP));
uiGameResCount(100, -1, woodRec, tileset->tiles);
uiGameResCount(100, -1, stoneRec, tileset->tiles);
uiGameResCount(100, -1, foodRec, tileset->tiles);
uiGameResCount(250, -1, goldRec, tileset->tiles);
uiGameResCount(1, 10, popRec, tileset->tiles);
bzUIPopParent(UI);
bzUIEnd(UI);
}
static void renderPauseMenu(Game *game, float dt) {
i32 width = GetScreenWidth();
i32 height = GetScreenHeight();
bzUIBegin(UI, width, height);
bzUISetParentLayout(UI, (BzUILayout) {
.type = BZ_UI_LAYOUT_FLEX_BOX,
.flags = BZ_UI_FLEX_DIR_COLUMN
});
uiPushDivParentPercentage(1.0f, 0.4f);
bzUISetParentLayout(UI, (BzUILayout) {
.type = BZ_UI_LAYOUT_FLEX_BOX,
.flags = BZ_UI_FLEX_DIR_COLUMN | BZ_UI_FLEX_JUSTIFY_CENTER | BZ_UI_FLEX_ALIGN_CENTER
});
uiMainMenuLabel("Paused");
bzUIPopParent(UI);
uiPushDivParentPercentage(1.0f, 0.6f);
bzUISetParentLayout(UI, (BzUILayout) {
.type = BZ_UI_LAYOUT_FLEX_BOX,
.flags = BZ_UI_FLEX_DIR_COLUMN | BZ_UI_FLEX_ALIGN_CENTER
});
if (uiMainMenuButton("Resume")) {
game->screen = SCREEN_GAME;
}
if (uiMainMenuButton("Exit")) {
game->screen = SCREEN_MAIN_MENU;
unloadMap(game);
loadMap(game, "assets/maps/main_menu_01.tmj");
}
bzUIPopParent(UI);
bzUIEnd(UI);
}
static void renderMainMenu(Game *game, float dt) {
i32 width = GetScreenWidth();
i32 height = GetScreenHeight();
game->camera.zoom = 3 * uiGetScale();
bzUIBegin(UI, width, height);
bzUISetParentLayout(UI, (BzUILayout) {
.type = BZ_UI_LAYOUT_FLEX_BOX,
.flags = BZ_UI_FLEX_DIR_COLUMN
});
uiPushDivParentPercentage(1.0f, 0.4f);
bzUISetParentLayout(UI, (BzUILayout) {
.type = BZ_UI_LAYOUT_FLEX_BOX,
.flags = BZ_UI_FLEX_DIR_COLUMN | BZ_UI_FLEX_JUSTIFY_CENTER | BZ_UI_FLEX_ALIGN_CENTER
});
uiMainMenuLabel("Pixel Defense");
bzUIPopParent(UI);
uiPushDivParentPercentage(1.0f, 0.6f);
bzUISetParentLayout(UI, (BzUILayout) {
.type = BZ_UI_LAYOUT_FLEX_BOX,
.flags = BZ_UI_FLEX_DIR_COLUMN | BZ_UI_FLEX_ALIGN_CENTER
});
if (uiMainMenuButton("Play")) {
game->screen = SCREEN_GAME;
unloadMap(game);
loadMap(game, "assets/maps/map_01.tmj");
}
if (uiMainMenuButton("Settings")) {
game->screen = SCREEN_SETTINGS;
}
if (uiMainMenuButton("Exit")) {
bzGameExit();
}
bzUIPopParent(UI);
bzUIEnd(UI);
}
static void renderSettings(Game *game, float dt) {
i32 width = GetScreenWidth();
i32 height = GetScreenHeight();
game->camera.zoom = 3 * uiGetScale();
bzUIBegin(UI, width, height);
bzUISetParentLayout(UI, (BzUILayout) {
.type = BZ_UI_LAYOUT_FLEX_BOX,
.flags = BZ_UI_FLEX_DIR_COLUMN | BZ_UI_FLEX_JUSTIFY_CENTER | BZ_UI_FLEX_ALIGN_CENTER
});
bzUIPushDiv(UI, (BzUISize) { BZ_UI_SIZE_REL_PARENT, 0.8f},
(BzUISize) { BZ_UI_SIZE_REL_PARENT, 0.8f});
bzUISetParentLayout(UI, (BzUILayout) {
.type = BZ_UI_LAYOUT_FLEX_BOX,
.flags = BZ_UI_FLEX_DIR_COLUMN | BZ_UI_FLEX_JUSTIFY_CENTER | BZ_UI_FLEX_ALIGN_CENTER
});
static bool fullscreen = false;
static bool vsync = false;
uiSettingsLabel("Video");
uiSettingsCheckbox("Fullscreen", &fullscreen);
uiSettingsCheckbox("V-Sync", &vsync);
static f32 master = 50.0f;
static f32 music = 50.0f;
static f32 sound = 50.0f;
uiSettingsLabel("Audio");
uiSettingsSlider("Master: ", &master);
uiSettingsSlider("Music: ", &music);
uiSettingsSlider("Sound: ", &sound);
bzUIPopParent(UI);
bzUIPushDiv(UI, (BzUISize) {BZ_UI_SIZE_REL_PARENT, 0.8f},
(BzUISize) {BZ_UI_SIZE_REL_PARENT, 0.2f});
bzUISetParentLayout(UI, (BzUILayout) {
.type = BZ_UI_LAYOUT_FLEX_BOX,
.flags = BZ_UI_FLEX_DIR_ROW | BZ_UI_FLEX_JUSTIFY_CENTER | BZ_UI_FLEX_ALIGN_CENTER
});
if (uiSettingsButton("Back")) {
game->screen = SCREEN_MAIN_MENU;
}
if (uiSettingsButton("Reset")) {
}
if (uiSettingsButton("Apply")) {
game->screen = SCREEN_MAIN_MENU;
}
bzUIEnd(UI);
}
void render(float dt, void *userData) {
BZ_UNUSED(userData);
Game *game = ecs_singleton_get_mut(ECS, Game);
const InputState *input = ecs_singleton_get(ECS, InputState);;
Color shadow = BLACK;
shadow.a = 35;
switch (game->screen) {
case SCREEN_GAME:
renderGame(game, dt);
renderGameMenu(game, dt);
break;
case SCREEN_PAUSE_MENU:
renderGame(game, dt);
drawOverScreen(shadow);
renderPauseMenu(game, dt);
break;
case SCREEN_MAIN_MENU:
renderGame(game, dt);
drawOverScreen(shadow);
renderMainMenu(game, dt);
break;
case SCREEN_SETTINGS:
renderGame(game, dt);
drawOverScreen(shadow);
renderSettings(game, dt);
break;
}
}
void imguiRender(float dt, void *userData) {
BZ_UNUSED(userData);
Game *game = ecs_singleton_get_mut(ECS, Game);
InputState *input = ecs_singleton_get_mut(ECS, InputState);
igSetNextWindowSize((ImVec2){300, 400}, ImGuiCond_FirstUseEver);
igBegin("Debug Menu", NULL, 0);
igText("PathData pool available: %llu", bzObjectPoolGetNumFree(game->pools.pathData));
igText("Action pool available: %llu", bzObjectPoolGetNumFree(game->pools.actions));
const char *inputState = "NONE";
switch (input->state) {
case INPUT_NONE:
inputState = "NONE";
break;
case INPUT_BUILDING:
inputState = "BUILDING";
break;
case INPUT_SELECTED_UNITS:
inputState = "SELECTED_UNITS";
break;
case INPUT_SELECTED_OBJECT:
inputState = "SELECTED_OBJECT";
break;
case INPUT_SELECTED_BUILDING:
inputState = "SELECTED_BUILDING";
break;
}
igText("Input state: %s", inputState);
if (igCollapsingHeader_TreeNodeFlags("Selection", 0)) {
switch (input->state) {
case INPUT_SELECTED_UNITS: {
igText("Selected units:");
ecs_iter_t it = ecs_query_iter(ECS, input->queries.selected);
while (ecs_iter_next(&it)) {
for (i32 i = 0; i < it.count; i++) {
ecs_entity_t entity = it.entities[i];
igText("Entity %llu", entity);
igText("Actions:");
const Action *pAction = NULL;
if (ecs_has(ECS, entity, UnitAction)) {
pAction = ecs_get(ECS, entity, UnitAction)->first;
}
while (pAction) {
igText("\t%d: %s", pAction->type, actionTypeToPrettyStr(pAction->type));
pAction = pAction->next;
}
}
}
break;
}
case INPUT_SELECTED_OBJECT: {
igText("Selected objects:");
ecs_iter_t it = ecs_query_iter(ECS, input->queries.selected);
while (ecs_iter_next(&it)) {
for (i32 i = 0; i < it.count; i++) {
ecs_entity_t entity = it.entities[i];
if (ecs_has(ECS, entity, Harvestable) &&
ecs_has(ECS, entity, Resource)) {
Resource *res = ecs_get_mut(ECS, entity, Resource);
const char *resName = getResourceTypePrettyName(res->type);
igText("\tEntity %llu:", entity);
igSliderInt("\t\twood", &res->amount, 0, 20, NULL, 0);
}
}
}
break;
}
default:
igText("NONE");
break;
}
}
if (igCollapsingHeader_TreeNodeFlags("Resources", 0)) {
igText("Wood: %lld", game->resources.wood);
igText("Iron: %lld", game->resources.iron);
igText("Food: %lld", game->resources.food);
igText("Gold: %lld", game->resources.gold);
igText("Population: %lld", game->resources.pop);
}
if (igCollapsingHeader_TreeNodeFlags("BuildMenu", 0)) {
for (int i = 0; i < BUILDING_COUNT; i++) {
if (igSelectable_Bool(getBuildingStr(i), input->building == i, 0, (ImVec2){0, 0}))
input->building = i;
}
if (input->building)
input->state = INPUT_BUILDING;
}
if (igCollapsingHeader_TreeNodeFlags("DebugDraw", 0)) {
igCheckbox("map colliders", &game->debugDraw.mapColliders);
igCheckbox("entity colliders", &game->debugDraw.entityColliders);
igCheckbox("spatial grid", &game->debugDraw.spatialGrid);
igCheckbox("path", &game->debugDraw.path);
}
if (igCollapsingHeader_TreeNodeFlags("Entities", 0)) {
igSliderFloat("Frame duration", &game->frameDuration, 0.0f, 1.0f, NULL, 0);
}
if (igSmallButton("Quite game")) {
bzGameExit();
}
igEnd();
}
Reference in New Issue View Git Blame Copy Permalink