Dengine/src/WorldTraveller.c

400 lines
12 KiB
C
Raw Normal View History

2016-06-28 06:00:03 +00:00
#include "Dengine/AssetManager.h"
#include "Dengine/Math.h"
#include "WorldTraveller/WorldTraveller.h"
2016-06-16 14:14:58 +00:00
//TODO(doyle): This is temporary! Maybe abstract into our platform layer, or
//choose to load assets outside of WorldTraveller!
#include <stdlib.h>
INTERNAL Entity *addEntity(World *world, v2 pos, v2 size,
enum Direction direction, Texture *tex, b32 collides)
{
#ifdef WT_DEBUG
ASSERT(tex && world);
ASSERT(world->freeEntityIndex < world->maxEntities);
#endif
Entity entity = {0};
entity.pos = pos;
entity.size = size;
entity.direction = direction;
entity.tex = tex;
entity.collides = collides;
world->entities[world->freeEntityIndex++] = entity;
Entity *result = &world->entities[world->freeEntityIndex-1];
return result;
}
INTERNAL void addAnim(Entity *entity, v4 *rects, i32 numRects, f32 duration)
{
#ifdef WT_DEBUG
ASSERT(rects && numRects >= 0)
ASSERT(entity->freeAnimIndex < ARRAY_COUNT(entity->anim));
#endif
EntityAnim result = {0};
result.rect = rects;
result.numRects = numRects;
result.duration = duration;
result.currDuration = duration;
entity->anim[entity->freeAnimIndex++] = result;
}
void worldTraveller_gameInit(GameState *state, v2i windowSize)
2016-06-16 14:14:58 +00:00
{
AssetManager *assetManager = &state->assetManager;
2016-06-16 14:14:58 +00:00
/* Initialise assets */
asset_loadTextureImage(assetManager,
"data/textures/WorldTraveller/TerraSprite1024.png",
texlist_hero);
asset_loadTextureImage(assetManager,
"data/textures/WorldTraveller/Terrain.png",
texlist_terrain);
TexAtlas *terrainAtlas =
asset_getTextureAtlas(assetManager, texlist_terrain);
f32 atlasTileSize = 128.0f;
terrainAtlas->texRect[terraincoords_ground] =
V4(384.0f, 512.0f, 384.0f + atlasTileSize, 512.0f + atlasTileSize);
asset_loadShaderFiles(assetManager, "data/shaders/sprite.vert.glsl",
"data/shaders/sprite.frag.glsl", shaderlist_sprite);
asset_loadTTFont(assetManager, "C:/Windows/Fonts/Arialbd.ttf");
2016-06-17 14:40:40 +00:00
glCheckError();
state->state = state_active;
state->currWorldIndex = 0;
state->tileSize = 64;
/* Init world */
const i32 targetWorldWidth = 500 * METERS_TO_PIXEL;
const i32 targetWorldHeight = 15 * METERS_TO_PIXEL;
v2i worldDimensionInTiles = V2i(targetWorldWidth / state->tileSize,
targetWorldHeight / state->tileSize);
for (i32 i = 0; i < ARRAY_COUNT(state->world); i++)
{
World *const world = &state->world[i];
world->maxEntities = 8192;
world->entities =
CAST(Entity *) calloc(world->maxEntities, sizeof(Entity));
world->texType = texlist_terrain;
TexAtlas *const atlas =
asset_getTextureAtlas(assetManager, world->texType);
for (i32 y = 0; y < worldDimensionInTiles.y; y++)
{
for (i32 x = 0; x < worldDimensionInTiles.x; x++)
{
#ifdef WT_DEBUG
ASSERT(worldDimensionInTiles.x * worldDimensionInTiles.y <
world->maxEntities);
#endif
v2 pos = V2(CAST(f32) x * state->tileSize,
CAST(f32) y * state->tileSize);
v2 size =
V2(CAST(f32) state->tileSize, CAST(f32) state->tileSize);
enum Direction dir = direction_null;
Texture *tex = asset_getTexture(assetManager, world->texType);
b32 collides = FALSE;
Entity *tile = addEntity(world, pos, size, dir, tex, collides);
f32 duration = 1.0f;
i32 numRects = 1;
v4 *animRects = CAST(v4 *)calloc(numRects, sizeof(v4));
animRects[0] = atlas->texRect[terraincoords_ground];
addAnim(tile, animRects, numRects, duration);
}
}
}
2016-06-17 14:40:40 +00:00
World *const world = &state->world[state->currWorldIndex];
/* Init hero entity */
world->heroIndex = world->freeEntityIndex;
v2 pos = V2(0.0f, 0.0f);
v2 size = V2(58.0f, 98.0f);
enum Direction dir = direction_east;
Texture *tex = asset_getTexture(assetManager, texlist_hero);
b32 collides = TRUE;
Entity *hero = addEntity(world, pos, size, dir, tex, collides);
/* Add idle animation */
f32 duration = 1.0f;
i32 numRects = 1;
v4 *heroIdleRects = CAST(v4 *) calloc(numRects, sizeof(v4));
heroIdleRects[0] = V4(746.0f, 1018.0f, 804.0f, 920.0f);
addAnim(hero, heroIdleRects, numRects, duration);
/* Add walking animation */
duration = 0.10f;
numRects = 3;
v4 *heroWalkRects = CAST(v4 *) calloc(numRects, sizeof(v4));
heroWalkRects[0] = V4(641.0f, 1018.0f, 699.0f, 920.0f);
heroWalkRects[1] = V4(746.0f, 1018.0f, 804.0f, 920.0f);
heroWalkRects[2] = V4(849.0f, 1018.0f, 904.0f, 920.0f);
addAnim(hero, heroWalkRects, numRects, duration);
2016-06-18 10:45:14 +00:00
Texture *heroSheet = hero->tex;
v2 sheetSize = V2(CAST(f32) heroSheet->width, CAST(f32) heroSheet->height);
2016-06-18 10:45:14 +00:00
if (sheetSize.x != sheetSize.y)
{
printf(
"worldTraveller_gameInit() warning: Sprite sheet is not square: "
"%dx%dpx\n",
CAST(i32) sheetSize.w, CAST(i32) sheetSize.h);
2016-06-18 10:45:14 +00:00
}
/* Create a NPC */
pos = V2(300.0f, 300.0f);
size = hero->size;
dir = direction_null;
tex = hero->tex;
collides = TRUE;
Entity *npc = addEntity(world, pos, size, dir, tex, collides);
/* Add npc waving animation */
duration = 0.30f;
numRects = 2;
v4 *npcWavingRects = CAST(v4 *) calloc(numRects, sizeof(v4));
npcWavingRects[0] = V4(944.0f, 918.0f, 1010.0f, 816.0f);
npcWavingRects[1] = V4(944.0f, 812.0f, 1010.0f, 710.0f);
addAnim(npc, npcWavingRects, numRects, duration);
2016-06-18 10:45:14 +00:00
2016-06-17 14:40:40 +00:00
/* Init renderer */
Renderer *renderer = &state->renderer;
renderer->size = V2(CAST(f32)windowSize.x, CAST(f32)windowSize.y);
// NOTE(doyle): Value to map a screen coordinate to NDC coordinate
renderer->vertexNdcFactor =
V2(1.0f / renderer->size.w, 1.0f / renderer->size.h);
renderer->shader = asset_getShader(assetManager, shaderlist_sprite);
shader_use(renderer->shader);
const mat4 projection =
mat4_ortho(0.0f, renderer->size.w, 0.0f, renderer->size.h, 0.0f, 1.0f);
shader_uniformSetMat4fv(renderer->shader, "projection", projection);
glCheckError();
2016-06-17 14:40:40 +00:00
/* Create buffers */
glGenVertexArrays(1, &renderer->vao);
glGenBuffers(1, &renderer->vbo);
2016-06-17 14:40:40 +00:00
glCheckError();
/* Bind buffers */
glBindBuffer(GL_ARRAY_BUFFER, renderer->vbo);
glBindVertexArray(renderer->vao);
2016-06-17 14:40:40 +00:00
/* Configure VAO */
const GLuint numVertexElements = 4;
const GLuint vertexSize = sizeof(v4);
2016-06-17 14:40:40 +00:00
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, numVertexElements, GL_FLOAT, GL_FALSE, vertexSize,
(GLvoid *)0);
glCheckError();
/* Unbind */
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindVertexArray(0);
glCheckError();
2016-06-16 14:14:58 +00:00
}
2016-06-17 14:40:40 +00:00
INTERNAL void parseInput(GameState *state, const f32 dt)
2016-06-16 14:14:58 +00:00
{
2016-06-17 08:11:23 +00:00
/*
Equations of Motion
f(t) = position m
f'(t) = velocity m/s
f"(t) = acceleration m/s^2
The user supplies an acceleration, a, and by integrating
f"(t) = a, where a is a constant, acceleration
f'(t) = a*t + v, where v is a constant, old velocity
f (t) = (a/2)*t^2 + v*t + p, where p is a constant, old position
*/
World *const world = &state->world[state->currWorldIndex];
Entity *hero = &world->entities[world->heroIndex];
v2 ddPos = V2(0, 0);
2016-06-16 14:14:58 +00:00
2016-06-17 14:40:40 +00:00
if (state->keys[GLFW_KEY_SPACE])
2016-06-16 14:14:58 +00:00
{
}
2016-06-17 14:40:40 +00:00
if (state->keys[GLFW_KEY_RIGHT])
2016-06-16 14:14:58 +00:00
{
2016-06-17 08:11:23 +00:00
ddPos.x = 1.0f;
hero->direction = direction_east;
2016-06-17 08:11:23 +00:00
}
2016-06-17 14:40:40 +00:00
if (state->keys[GLFW_KEY_LEFT])
2016-06-17 08:11:23 +00:00
{
ddPos.x = -1.0f;
hero->direction = direction_west;
2016-06-17 08:11:23 +00:00
}
2016-06-17 14:40:40 +00:00
if (state->keys[GLFW_KEY_UP])
2016-06-17 08:11:23 +00:00
{
ddPos.y = 1.0f;
2016-06-16 14:14:58 +00:00
}
2016-06-17 14:40:40 +00:00
if (state->keys[GLFW_KEY_DOWN])
2016-06-16 14:14:58 +00:00
{
2016-06-17 08:11:23 +00:00
ddPos.y = -1.0f;
2016-06-16 14:14:58 +00:00
}
2016-06-17 08:11:23 +00:00
if (ddPos.x != 0.0f && ddPos.y != 0.0f)
{
// NOTE(doyle): Cheese it and pre-compute the vector for diagonal using
// pythagoras theorem on a unit triangle
// 1^2 + 1^2 = c^2
ddPos = v2_scale(ddPos, 0.70710678118f);
2016-06-17 08:11:23 +00:00
}
// NOTE(doyle): Clipping threshold for snapping velocity to 0
f32 epsilon = 15.0f;
v2 epsilonDpos = v2_sub(V2(epsilon, epsilon),
V2(absolute(hero->dPos.x), absolute(hero->dPos.y)));
if (epsilonDpos.x >= 0.0f && epsilonDpos.y >= 0.0f)
{
hero->dPos = V2(0.0f, 0.0f);
// TODO(doyle): Change index to use some meaningful name like a string
// or enum for referencing animations, in this case 0 is idle and 1 is
// walking
if (hero->currAnimIndex == 1)
{
EntityAnim *currAnim = &hero->anim[hero->currAnimIndex];
currAnim->currDuration = currAnim->duration;
currAnim->currRectIndex = 0;
hero->currAnimIndex = 0;
}
2016-06-25 09:12:25 +00:00
}
else if (hero->currAnimIndex == 0)
{
EntityAnim *currAnim = &hero->anim[hero->currAnimIndex];
currAnim->currDuration = currAnim->duration;
currAnim->currRectIndex = 0;
hero->currAnimIndex = 1;
}
2016-06-17 14:40:40 +00:00
f32 heroSpeed = CAST(f32)(22.0f * METERS_TO_PIXEL); // m/s^2
if (state->keys[GLFW_KEY_LEFT_SHIFT])
{
heroSpeed = CAST(f32)(22.0f * 5.0f * METERS_TO_PIXEL);
}
ddPos = v2_scale(ddPos, heroSpeed);
2016-06-17 08:11:23 +00:00
// TODO(doyle): Counteracting force on player's acceleration is arbitrary
ddPos = v2_sub(ddPos, v2_scale(hero->dPos, 5.5f));
2016-06-17 08:11:23 +00:00
/*
NOTE(doyle): Calculate new position from acceleration with old velocity
new Position = (a/2) * (t^2) + (v*t) + p,
acceleration = (a/2) * (t^2)
old velocity = (v*t)
*/
v2 ddPosNew = v2_scale(v2_scale(ddPos, 0.5f), squared(dt));
v2 dPos = v2_scale(hero->dPos, dt);
v2 newHeroP = v2_add(v2_add(ddPosNew, dPos), hero->pos);
2016-06-17 08:11:23 +00:00
// TODO(doyle): Only check collision for entities within small bounding box
// of the hero
2016-06-25 09:12:25 +00:00
b32 heroCollided = FALSE;
if (hero->collides == TRUE)
{
for (i32 i = 0; i < world->maxEntities; i++)
2016-06-25 09:12:25 +00:00
{
if (i == world->heroIndex) continue;
Entity entity = world->entities[i];
2016-06-25 09:12:25 +00:00
if (entity.collides)
{
v4 heroRect =
V4(newHeroP.x, newHeroP.y, (newHeroP.x + hero->size.x),
(newHeroP.y + hero->size.y));
v4 entityRect = getEntityScreenRect(entity);
if (((heroRect.z >= entityRect.x && heroRect.z <= entityRect.z) ||
(heroRect.x >= entityRect.x && heroRect.x <= entityRect.z)) &&
((heroRect.w <= entityRect.y && heroRect.w >= entityRect.w) ||
(heroRect.y <= entityRect.y && heroRect.y >= entityRect.w)))
{
heroCollided = TRUE;
break;
}
}
}
}
if (heroCollided)
{
hero->dPos = V2(0.0f, 0.0f);
}
else
{
// f'(t) = curr velocity = a*t + v, where v is old velocity
hero->dPos = v2_add(hero->dPos, v2_scale(ddPos, dt));
hero->pos = newHeroP;
}
2016-06-16 14:14:58 +00:00
}
2016-06-17 14:40:40 +00:00
void worldTraveller_gameUpdateAndRender(GameState *state, const f32 dt)
2016-06-16 14:14:58 +00:00
{
2016-06-17 14:40:40 +00:00
/* Update */
parseInput(state, dt);
glCheckError();
AssetManager *assetManager = &state->assetManager;
Renderer *renderer = &state->renderer;
World *const world = &state->world[state->currWorldIndex];
/* Render entities */
ASSERT(world->freeEntityIndex < world->maxEntities);
for (i32 i = 0; i < world->freeEntityIndex; i++)
{
Entity *const entity = &world->entities[i];
renderer_entity(&state->renderer, entity, dt, 0.0f, V3(0, 0, 0));
}
2016-06-17 14:40:40 +00:00
// TODO(doyle): Clean up lines
// Renderer::~Renderer() { glDeleteVertexArrays(1, &this->quadVAO); }
#ifdef WT_DEBUG
LOCAL_PERSIST f32 debugUpdateCounter = 0.0f;
LOCAL_PERSIST char debugStrings[256][64] = {0};
LOCAL_PERSIST i32 numDebugStrings = 0;
Font *font = &assetManager->font;
if (debugUpdateCounter <= 0)
{
Entity *const hero = &world->entities[world->heroIndex];
snprintf(debugStrings[0], ARRAY_COUNT(debugStrings[0]),
"Hero Pos: %06.2f,%06.2f", hero->pos.x, hero->pos.y);
numDebugStrings++;
snprintf(debugStrings[1], ARRAY_COUNT(debugStrings[1]),
"Hero dPos: %06.2f,%06.2f", hero->dPos.x, hero->dPos.y);
numDebugStrings++;
snprintf(debugStrings[2], ARRAY_COUNT(debugStrings[2]),
"FreeEntityIndex: %d", world->freeEntityIndex);
numDebugStrings++;
const f32 debugUpdateRate = 0.15f;
debugUpdateCounter = debugUpdateRate;
}
for (i32 i = 0; i < numDebugStrings; i++)
renderer_debugString(&state->renderer, font, debugStrings[i]);
debugUpdateCounter -= dt;
debugRenderer.init = FALSE;
#endif
2016-06-16 14:14:58 +00:00
}