void character_update(character* c) {
c->velocity.x = clamp(c->velocity.x, -7.0, 7.0);
c->position = v2_add(c->position, c->velocity);
if (c->flap_timer > 0.0) {
c->flap_timer -= frame_time();
}
}
/* Compute the mean of a set of vectors */
v2_t v2_mean(int n, v2_t *v) {
int i;
v2_t mean = v2_new(0.0, 0.0);
for (i = 0; i < n; i++) {
mean = v2_add(mean, v[i]);
}
return v2_scale(1.0 / n, mean);
}
void ui_spinner_render(ui_spinner* s) {
if (!s->active) return;
vector2 top_left = s->top_left;
vector2 top_right = v2(s->bottom_right.x, s->top_left.y);
vector2 bot_left = v2(s->top_left.x, s->bottom_right.y);
vector2 bot_right = s->bottom_right;
vector2 center;
center.x = (top_left.x + top_right.x) / 2;
center.y = (top_left.y + bot_left.y) / 2;
top_left = v2_sub(top_left, center);
top_right = v2_sub(top_right, center);
bot_left = v2_sub(bot_left, center);
bot_right = v2_sub(bot_right, center);
matrix_2x2 rot = m22_rotation(s->rotation);
top_left = m22_mul_v2(rot, top_left);
top_right = m22_mul_v2(rot, top_right);
bot_left = m22_mul_v2(rot, bot_left);
bot_right = m22_mul_v2(rot, bot_right);
top_left = v2_add(top_left, center);
top_right = v2_add(top_right, center);
bot_left = v2_add(bot_left, center);
bot_right = v2_add(bot_right, center);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
glOrtho(0, graphics_viewport_width(), graphics_viewport_height(), 0, -1, 1);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, *(s->texture) );
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glColor4f(s->color.r, s->color.g, s->color.b, s->color.a);
glBegin(GL_QUADS);
glTexCoord2f(0, 1); glVertex3f(top_left.x, top_left.y, 0);
glTexCoord2f(1, 1); glVertex3f(bot_left.x, bot_left.y, 0);
glTexCoord2f(1, 0); glVertex3f(bot_right.x, bot_right.y, 0);
glTexCoord2f(0, 0); glVertex3f(top_right.x, top_right.y, 0);
glEnd();
glColor4f(1, 1, 1, 1);
glDisable(GL_BLEND);
glDisable(GL_TEXTURE_2D);
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
}
/* Create a new image by applying transformation T to img and
* resampling. Resize the image so that the whole thing fits when
* transformed. */
img_t *img_resample_bbox(img_t *img, trans2D_t *T) {
int w = img->w, h = img->h;
int x, y;
trans2D_t *Tinv = transform_invert(T);
int w_new, h_new, i;
// double x_min = DBL_MAX, x_max = -DBL_MAX, y_min = DBL_MAX, y_max = -DBL_MAX;
v2_t min = v2_new(DBL_MAX, DBL_MAX);
v2_t max = v2_new(-DBL_MAX, -DBL_MAX);
v2_t origin;
img_t *Timg;
/* Find the new dimensions of the window */
v2_t crs[4]; /* Four corners of the original image */
crs[0] = v2_new(0, 0);
crs[1] = v2_new(0, h - 1);
crs[2] = v2_new(w - 1, 0);
crs[3] = v2_new(w - 1, h - 1);
for (i = 0; i < 4; i++) {
crs[i] = v2_add(crs[i], img->origin);
crs[i] = transform_vector(T, crs[i]);
min = v2_minimum(min, crs[i]);
max = v2_maximum(max, crs[i]);
}
Vx(min) = floor(Vx(min));
Vy(min) = floor(Vy(min));
w_new = iround(floor(Vx(max) - Vx(min) + 1));
h_new = iround(floor(Vy(max) - Vy(min) + 1));
origin = min;
Timg = img_new(w_new, h_new);
Timg->origin = origin;
for (y = 0; y < h_new; y++) {
for (x = 0; x < w_new; x++) {
double Tp[2];
fcolor_t c;
/* Invert the point (x, y) - trans */
transform_point(Tinv, x + Vx(origin), y + Vy(origin), &Tp[0], &Tp[1]);
#if 1
/* Check if the result is in range */
if (Tp[0] < Vx(img->origin) || Tp[1] < Vy(img->origin) ||
Tp[0] > Vx(img->origin) + w - 1 || Tp[1] > Vy(img->origin) + h - 1) {
/* pass */
} else {
/* Check if the result is valid */
int x_f = (int) (Tp[0] - Vx(img->origin));
int x_c = x_f + 1;
int y_f = (int) (Tp[1] - Vy(img->origin));
int y_c = y_f + 1;
if (img_pixel_is_valid(img, x_f, y_f) ||
img_pixel_is_valid(img, x_c, y_f) ||
img_pixel_is_valid(img, x_f, y_c) ||
img_pixel_is_valid(img, x_c, y_c)) {
/* Apply bilinear interpolation */
c = pixel_lerp(img, Tp[0] - Vx(img->origin), Tp[1] - Vy(img->origin));
img_set_pixel(Timg, x, y, iround(c.r), iround(c.g), iround(c.b));
} else {
// img_nullify_pixel(Timg, x, y);
}
}
#else
if (Tp[0] < 0.0) Tp[0] = 0.0;
else if (Tp[0] > w - 1) Tp[0] = w - 1;
if (Tp[1] < 0.0) Tp[1] = 0.0;
else if (Tp[1] > h - 1) Tp[1] = h - 1;
c = pixel_lerp(img, Tp[0], Tp[1]);
img_set_pixel(Timg, x, y, c.r, c.g, c.b);
#endif
}
}
/* Add the old origin to the image */
// Timg->origin = v2_add(origin, img->origin);
transform_free(Tinv);
return Timg;
}
INTERNAL void gameUpdate(GameState *state, Memory *memory, f32 dt)
{
GameWorldState *world =
GET_STATE_DATA(state, &state->persistentArena, GameWorldState);
if (!common_isSet(world->flags, gameworldstateflags_init))
{
#ifdef DENGINE_DEBUG
{
u8 *data = (u8 *)world;
for (i32 i = 0; i < sizeof(GameWorldState); i++)
ASSERT(data[i] == 0);
}
#endif
world->pixelsPerMeter = 70.0f;
MemoryIndex entityArenaSize =
(MemoryIndex)((f32)memory->transientSize * 0.5f);
u8 *arenaBase = state->transientArena.base + state->transientArena.size;
memory_arenaInit(&world->entityArena, arenaBase, entityArenaSize);
world->camera.min = V2(0, 0);
world->camera.max = state->renderer.size;
world->size = state->renderer.size;
world->entityListSize = 1024;
world->entityList = MEMORY_PUSH_ARRAY(&world->entityArena,
world->entityListSize, Entity);
{ // Init null entity
Entity *nullEntity = &world->entityList[world->entityIndex++];
nullEntity->id = world->entityIdCounter++;
}
{ // Init asteroid entities
world->numAsteroids = 15;
}
{ // Init audio renderer
world->numAudioRenderers = 8;
world->audioRenderer = MEMORY_PUSH_ARRAY(
&world->entityArena, world->numAudioRenderers, AudioRenderer);
}
{ // Global Collision Rules
setCollisionRule(world, entitytype_ship, entitytype_asteroid_small,
TRUE);
setCollisionRule(world, entitytype_ship, entitytype_asteroid_medium,
TRUE);
setCollisionRule(world, entitytype_ship, entitytype_asteroid_large,
TRUE);
setCollisionRule(world, entitytype_bullet,
entitytype_asteroid_small, TRUE);
setCollisionRule(world, entitytype_bullet,
entitytype_asteroid_medium, TRUE);
setCollisionRule(world, entitytype_bullet,
entitytype_asteroid_large, TRUE);
}
world->numStarP = 100;
world->starPList =
MEMORY_PUSH_ARRAY(&world->entityArena, world->numStarP, v2);
world->starMinOpacity = 0.25f;
for (i32 i = 0; i < world->numStarP; i++)
{
i32 randX = rand() % (i32)world->size.x;
i32 randY = rand() % (i32)world->size.y;
world->starPList[i] = V2i(randX, randY);
}
world->flags |= gameworldstateflags_init;
world->scoreMultiplier = 5;
world->scoreMultiplierBarTimer = 0.0f;
world->scoreMultiplierBarThresholdInS = 2.0f;
}
if (common_isSet(world->flags, gameworldstateflags_level_started))
{
Font *arial40 = asset_fontGet(&state->assetManager, "Arial", 40);
Renderer *renderer = &state->renderer;
/* Render scores onto screen */
v2 stringP =
V2((renderer->size.w * 0.5f), renderer->size.h - arial40->size);
char gamePointsString[COMMON_ITOA_MAX_BUFFER_32BIT] = {0};
common_itoa(world->score, gamePointsString,
ARRAY_COUNT(gamePointsString));
renderer_stringFixedCentered(renderer, &state->transientArena, arial40,
gamePointsString, stringP, V2(0, 0), 0,
V4(1.0f, 1.0f, 1.0f, 1.0f), 1, 0);
/* Render multiplier accumulator bar onto screen */
v2 stringDim = asset_fontStringDimInPixels(arial40, gamePointsString);
v2 multiplierOutlineSize =
V2(renderer->size.w * 0.5f, stringDim.h * 0.25f);
v2 multiplierOutlineP = V2(renderer->size.w * 0.5f, stringP.h);
multiplierOutlineP.x -= (multiplierOutlineSize.w * 0.5f);
multiplierOutlineP.y -= stringDim.h * 1.5f;
renderer_rectFixedOutline(
renderer, multiplierOutlineP, multiplierOutlineSize, V2(0, 0), 2, 0,
NULL, V4(0.2f, 0.3f, 0.8f, 1.0f), 2, renderflag_no_texture);
f32 progressNormalised = world->scoreMultiplierBarTimer /
world->scoreMultiplierBarThresholdInS;
renderer_rectFixed(renderer, multiplierOutlineP,
V2(multiplierOutlineSize.w * progressNormalised,
multiplierOutlineSize.h),
V2(0, 0), 0, NULL, V4(0.2f, 0.3f, 0.8f, 1.0f), 1,
renderflag_no_texture);
/* Render multiplier counter hud onto screen */
v2 multiplierHudP = V2(0, 0.05f * renderer->size.h);
v2 multiplierHudSize =
V2((arial40->maxSize.w * 3.5f), arial40->fontHeight * 1.2f);
renderer_rectFixed(renderer, multiplierHudP, multiplierHudSize,
V2(0, 0), 0, NULL, V4(1, 1, 1, 0.1f), 2,
renderflag_no_texture);
/* Render multiplier counter string to hud */
char multiplierToString[COMMON_ITOA_MAX_BUFFER_32BIT + 1] = {0};
common_itoa(world->scoreMultiplier, multiplierToString + 1,
ARRAY_COUNT(multiplierToString) - 1);
multiplierToString[0] = 'x';
v2 multiplierToStringP = multiplierHudP;
multiplierToStringP =
v2_add(multiplierToStringP, v2_scale(multiplierHudSize, 0.5f));
renderer_stringFixedCentered(
renderer, &state->transientArena, arial40, multiplierToString,
multiplierToStringP, V2(0, 0), 0, V4(1.0f, 1.0f, 1.0f, 1.0f), 3, 0);
/* Process multiplier bar updates */
if (!common_isSet(world->flags, gameworldstateflags_player_lost))
{
f32 barTimerPenalty = 1.0f;
if (world->timeSinceLastShot < 1.5f)
{
barTimerPenalty = 0.1f;
}
world->scoreMultiplierBarTimer += (barTimerPenalty * dt);
world->timeSinceLastShot += dt;
if (world->scoreMultiplierBarTimer >
world->scoreMultiplierBarThresholdInS)
{
world->scoreMultiplierBarTimer = 0;
world->scoreMultiplier++;
if (world->scoreMultiplier > 9999)
world->scoreMultiplier = 9999;
}
}
}
if (common_isSet(world->flags, gameworldstateflags_player_lost))
{
Font *arial40 = asset_fontGet(&state->assetManager, "Arial", 40);
char *gameOver = "Game Over";
v2 gameOverP = v2_scale(state->renderer.size, 0.5f);
renderer_stringFixedCentered(
&state->renderer, &state->transientArena, arial40, "Game Over",
gameOverP, V2(0, 0), 0, V4(1, 1, 1, 1), 0, 0);
v2 gameOverSize = asset_fontStringDimInPixels(arial40, gameOver);
v2 replayP = V2(gameOverP.x, gameOverP.y - (gameOverSize.h * 1.2f));
renderer_stringFixedCentered(
&state->renderer, &state->transientArena, arial40,
"Press enter to play again or backspace to return to menu", replayP,
V2(0, 0), 0, V4(1, 1, 1, 1), 0, 0);
if (platform_queryKey(&state->input.keys[keycode_enter],
readkeytype_one_shot, 0.0f))
{
// TODO(doyle): Extract score init default values to some game
// definitions file
world->score = 0;
world->scoreMultiplier = 5;
world->scoreMultiplierBarTimer = 0.0f;
world->scoreMultiplierBarThresholdInS = 2.0f;
addPlayer(world);
world->flags ^= gameworldstateflags_player_lost;
}
else if (platform_queryKey(&state->input.keys[keycode_backspace],
readkeytype_one_shot, 0.0f))
{
common_memset((u8 *)world, 0, sizeof(*world));
state->currState = appstate_StartMenuState;
return;
}
}
for (u32 i = world->asteroidCounter; i < world->numAsteroids; i++)
addAsteroid(world, (rand() % asteroidsize_count));
Radians starRotation = DEGREES_TO_RADIANS(45.0f);
v2 starSize = V2(2, 2);
ASSERT(world->starMinOpacity >= 0.0f && world->starMinOpacity <= 1.0f);
f32 opacityFadeRateInS = 0.5f;
if (world->starFadeAway)
{
opacityFadeRateInS *= -1.0f;
}
if (world->starOpacity > 1.0f)
{
world->starOpacity = 1.0f;
world->starFadeAway = TRUE;
}
else if (world->starOpacity < world->starMinOpacity)
{
world->starOpacity = world->starMinOpacity;
world->starFadeAway = FALSE;
}
world->starOpacity += (opacityFadeRateInS * dt);
DEBUG_PUSH_VAR("Star Opacity: %5.2f", world->starOpacity, "f32");
for (i32 i = 0; i < world->numStarP; i++)
{
world->starPList[i] = v2_add(world->starPList[i], V2(4.0f * dt, 0));
world->starPList[i] = wrapPAroundBounds(
world->starPList[i], math_rectCreate(V2(0, 0), world->size));
renderer_rect(&state->renderer, world->camera, world->starPList[i],
starSize, V2(0, 0), starRotation, NULL,
V4(0.8f, 0.8f, 0.8f, world->starOpacity), 0,
renderflag_no_texture | renderflag_wireframe);
}
#ifdef DENGINE_DEBUG
if (platform_queryKey(&state->input.keys[keycode_left_square_bracket],
readkeytype_repeat, 0.2f))
{
addAsteroid(world, (rand() % asteroidsize_count));
}
#endif
ASSERT(world->entityList[0].id == NULL_ENTITY_ID);
for (i32 i = 1; i < world->entityIndex; i++)
{
Entity *entity = &world->entityList[i];
ASSERT(entity->type != entitytype_invalid);
v2 pivotPoint = {0};
f32 ddPSpeedInMs = 0;
v2 ddP = {0};
if (entity->type == entitytype_ship)
{
if (platform_queryKey(&state->input.keys[keycode_up],
readkeytype_repeat, 0.0f))
{
// TODO(doyle): Renderer creates upfacing triangles by default,
// but we need to offset rotation so that our base "0 degrees"
// is right facing for trig to work
Radians rotation =
DEGREES_TO_RADIANS((entity->rotation + 90.0f));
v2 direction = V2(math_cosf(rotation), math_sinf(rotation));
ddP = direction;
AudioVorbis *thrust =
asset_vorbisGet(&state->assetManager, "thrust");
AudioRenderer *audioRenderer =
getFreeAudioRenderer(world, thrust, 3);
if (audioRenderer)
{
audio_vorbisPlay(&state->transientArena,
&state->audioManager, audioRenderer,
thrust, 1);
}
}
if (platform_queryKey(&state->input.keys[keycode_space],
readkeytype_one_shot, KEY_DELAY_NONE))
{
addBullet(world, entity);
if (world->timeSinceLastShot >= 0)
{
world->timeSinceLastShot = 0;
f32 multiplierPenalty = -2.0f;
world->timeSinceLastShot += multiplierPenalty;
}
AudioVorbis *fire =
asset_vorbisGet(&state->assetManager, "fire");
AudioRenderer *audioRenderer =
getFreeAudioRenderer(world, fire, 2);
if (audioRenderer)
{
// TODO(doyle): Atm transient arena is not used, this is
// just to fill out the arguments
audio_vorbisPlay(&state->transientArena,
&state->audioManager, audioRenderer, fire,
1);
}
}
Degrees rotationsPerSecond = 180.0f;
if (platform_queryKey(&state->input.keys[keycode_left],
readkeytype_repeat, 0.0f))
{
entity->rotation += (rotationsPerSecond)*dt;
}
if (platform_queryKey(&state->input.keys[keycode_right],
readkeytype_repeat, 0.0f))
{
entity->rotation -= (rotationsPerSecond)*dt;
}
entity->rotation = (f32)((i32)entity->rotation);
ddPSpeedInMs = 25;
DEBUG_PUSH_VAR("Pos: %5.2f, %5.2f", entity->pos, "v2");
DEBUG_PUSH_VAR("Velocity: %5.2f, %5.2f", entity->dP, "v2");
DEBUG_PUSH_VAR("Rotation: %5.2f", entity->rotation, "f32");
DEBUG_PUSH_VAR("TimeSinceLastShot: %5.2f", world->timeSinceLastShot,
"f32");
renderer_rect(&state->renderer, world->camera, entity->pos,
V2(5, 5), V2(0, 0),
DEGREES_TO_RADIANS(entity->rotation), NULL,
V4(1.0f, 1.0f, 1.0f, 1.0f), 0, renderflag_no_texture);
}
else if (entity->type >= entitytype_asteroid_small &&
entity->type <= entitytype_asteroid_large)
{
i32 randValue = rand();
// NOTE(doyle): If it is a new asteroid with no dp set, we need to
// set a initial dp for it to move from.
v2 localDp = {0};
if ((i32)entity->dP.x == 0 && (i32)entity->dP.y == 0)
{
enum Direction direction = randValue % direction_count;
switch (direction)
{
case direction_north:
case direction_northwest:
{
localDp.x = 1.0f;
localDp.y = 1.0f;
}
break;
case direction_west:
case direction_southwest:
{
localDp.x = -1.0f;
localDp.y = -1.0f;
}
break;
case direction_south:
case direction_southeast:
{
localDp.x = 1.0f;
localDp.y = -1.0f;
}
break;
case direction_east:
case direction_northeast:
{
localDp.x = 1.0f;
localDp.y = 1.0f;
}
break;
default:
{
ASSERT(INVALID_CODE_PATH);
}
break;
}
}
// NOTE(doyle): Otherwise, if it has pre-existing dp, maintain our
// direction by extrapolating from it's current dp
else
{
if (entity->dP.x >= 0)
localDp.x = 1.0f;
else
localDp.x = -1.0f;
if (entity->dP.y >= 0)
localDp.y = 1.0f;
else
localDp.y = -1.0f;
}
/*
NOTE(doyle): We compare current dP with the calculated dP. In the
event we want to artificially boost the asteroid, we set a higher
dP on creation, which will have a higher dP than the default dP
we calculate. So here we choose to keep it until it decays enough
that the default dP of the asteroid is accepted.
*/
v2 newDp = v2_scale(localDp, world->pixelsPerMeter * 1.5f);
f32 newDpSum = ABS(newDp.x) + ABS(newDp.y);
f32 oldDpSum = ABS(entity->dP.x) + ABS(entity->dP.y);
if (newDpSum > oldDpSum)
{
entity->dP = newDp;
}
}
else if (entity->type == entitytype_bullet)
{
if (!math_rectContainsP(world->camera, entity->pos))
{
deleteEntity(world, i--);
continue;
}
Radians rotation = DEGREES_TO_RADIANS((entity->rotation + 90.0f));
v2 localDp = V2(math_cosf(rotation), math_sinf(rotation));
entity->dP = v2_scale(localDp, world->pixelsPerMeter * 5);
}
else if (entity->type == entitytype_particle)
{
f32 diff = entity->color.a - 0.1f;
if (diff < 0.01f)
{
deleteEntity(world, i--);
continue;
}
f32 divisor =
MAX(entity->particleInitDp.x, entity->particleInitDp.y);
f32 maxDp = MAX(entity->dP.x, entity->dP.y);
entity->color.a = maxDp / divisor;
}
entity->pos = wrapPAroundBounds(entity->pos,
math_rectCreate(V2(0, 0), world->size));
/* Loop entity around world */
i32 collisionIndex = moveEntity(world, &state->transientArena, entity,
i, ddP, dt, ddPSpeedInMs);
v4 collideColor = {0};
if (collisionIndex != -1)
{
ASSERT(collisionIndex < world->entityIndex);
Entity *collideEntity = &world->entityList[collisionIndex];
Entity *colliderA;
Entity *colliderB;
if (collideEntity->type < entity->type)
{
colliderA = collideEntity;
colliderB = entity;
}
else
{
colliderA = entity;
colliderB = collideEntity;
}
// Assumptions made that the collision detect system relies on
ASSERT(entitytype_ship < entitytype_asteroid_small);
ASSERT(entitytype_asteroid_small < entitytype_asteroid_medium);
ASSERT(entitytype_asteroid_medium < entitytype_asteroid_large);
ASSERT(entitytype_asteroid_large < entitytype_bullet);
ASSERT(entitytype_asteroid_small + 1 == entitytype_asteroid_medium);
ASSERT(entitytype_asteroid_medium + 1 == entitytype_asteroid_large);
if (colliderA->type >= entitytype_asteroid_small &&
colliderA->type <= entitytype_asteroid_large)
{
f32 numParticles = 4;
if (colliderA->type == entitytype_asteroid_medium)
{
AsteroidSpec spec = {0};
spec.pos = colliderA->pos;
spec.dP = v2_scale(colliderA->dP, -2.0f);
addAsteroidWithSpec(world, asteroidsize_small, &spec);
numParticles = 8;
world->score += (10 * world->scoreMultiplier);
}
else if (colliderA->type == entitytype_asteroid_large)
{
AsteroidSpec spec = {0};
spec.pos = colliderA->pos;
spec.dP = v2_scale(colliderA->dP, -4.0f);
addAsteroidWithSpec(world, asteroidsize_medium, &spec);
spec.dP = v2_perpendicular(spec.dP);
addAsteroidWithSpec(world, asteroidsize_small, &spec);
spec.dP = v2_perpendicular(colliderA->dP);
addAsteroidWithSpec(world, asteroidsize_small, &spec);
numParticles = 16;
world->score += (20 * world->scoreMultiplier);
}
else
{
world->score += (5 * world->scoreMultiplier);
}
for (i32 i = 0; i < numParticles; i++)
{
{ // Add particles
Entity *particle =
&world->entityList[world->entityIndex++];
particle->id = world->entityIdCounter++;
particle->pos = colliderA->pos;
particle->size = V2(4.0f, 4.0f);
i32 randValue = rand();
Radians rotation =
DEGREES_TO_RADIANS((randValue % 360));
v2 randDirectionVec =
V2(math_cosf(rotation), math_sinf(rotation));
i32 particleDpLimit = 8;
f32 randDpMultiplier =
(f32)(randValue % particleDpLimit) + 1;
v2 newDp = v2_scale(colliderA->dP, randDpMultiplier);
newDp = v2_hadamard(newDp, randDirectionVec);
particle->dP = newDp;
particle->particleInitDp = newDp;
particle->offset = v2_scale(particle->size, -0.5f);
particle->hitbox = particle->size;
particle->rotation = 0;
particle->renderMode = rendermode_polygon;
if (!world->particleVertexCache)
{
world->particleVertexCache =
MEMORY_PUSH_ARRAY(&world->entityArena, 4, v2);
world->particleVertexCache[0] =
V2(0, particle->size.h);
world->particleVertexCache[1] = V2(0, 0);
world->particleVertexCache[2] =
V2(particle->size.w, 0);
world->particleVertexCache[3] = particle->size;
}
particle->vertexPoints = world->particleVertexCache;
particle->numVertexPoints = 4;
particle->type = entitytype_particle;
particle->color = V4(1.0f, 0.0f, 0, 1.0f);
}
}
ASSERT(colliderB->type == entitytype_bullet);
deleteEntity(world, collisionIndex);
deleteEntity(world, i--);
world->asteroidCounter--;
ASSERT(world->asteroidCounter >= 0);
char *sound;
i32 choice = rand() % 3;
if (choice == 0)
{
sound = "bang_small";
}
else if (choice == 1)
{
sound = "bang_medium";
}
else
{
sound = "bang_large";
}
AudioVorbis *explode =
asset_vorbisGet(&state->assetManager, sound);
AudioRenderer *audioRenderer =
getFreeAudioRenderer(world, explode, 3);
if (audioRenderer)
{
audio_vorbisPlay(&state->transientArena,
&state->audioManager, audioRenderer,
explode, 1);
}
continue;
}
else if (colliderA->type == entitytype_ship)
{
if (colliderB->type >= entitytype_asteroid_small &&
colliderB->type <= entitytype_asteroid_large)
{
world->flags |= gameworldstateflags_player_lost;
if (collideEntity->type == entitytype_ship)
{
deleteEntity(world, collisionIndex);
}
else
{
deleteEntity(world, i--);
}
AudioVorbis *explode =
asset_vorbisGet(&state->assetManager, "bang_large");
AudioRenderer *audioRenderer =
getFreeAudioRenderer(world, explode, 3);
if (audioRenderer)
{
audio_vorbisPlay(&state->transientArena,
&state->audioManager, audioRenderer,
explode, 1);
}
continue;
}
}
}
RenderFlags flags = renderflag_wireframe | renderflag_no_texture;
renderer_entity(&state->renderer, &state->transientArena, world->camera,
entity, V2(0, 0), 0, collideColor, 0, flags);
}
for (i32 i = 0; i < world->numAudioRenderers; i++)
{
AudioRenderer *audioRenderer = &world->audioRenderer[i];
audio_updateAndPlay(&state->transientArena, &state->audioManager,
audioRenderer);
}
}
INTERNAL u32 moveEntity(GameWorldState *world, MemoryArena_ *transientArena,
Entity *entity, i32 entityIndex, v2 ddP, f32 dt,
f32 ddPSpeed)
{
ASSERT(ABS(ddP.x) <= 1.0f && ABS(ddP.y) <= 1.0f);
/*
Assuming acceleration A over t time, then integrate twice to get
newVelocity = a*t + oldVelocity
newPos = (a*t^2)/2 + oldVelocity*t + oldPos
*/
if (ddP.x > 0.0f && ddP.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
ddP = v2_scale(ddP, 0.70710678118f);
}
ddP = v2_scale(ddP, world->pixelsPerMeter * ddPSpeed);
v2 oldDp = entity->dP;
v2 resistance = v2_scale(oldDp, 2.0f);
ddP = v2_sub(ddP, resistance);
v2 newDp = v2_add(v2_scale(ddP, dt), oldDp);
v2 ddPHalf = v2_scale(ddP, 0.5f);
v2 ddPHalfDtSquared = v2_scale(ddPHalf, (SQUARED(dt)));
v2 oldDpDt = v2_scale(oldDp, dt);
v2 oldPos = entity->pos;
v2 newPos = v2_add(v2_add(ddPHalfDtSquared, oldDpDt), oldPos);
i32 collisionIndex = -1;
// TODO(doyle): Collision for rects, (need to create vertex list for it)
for (i32 i = 1; i < world->entityIndex; i++)
{
if (i == entityIndex) continue;
Entity *checkEntity = &world->entityList[i];
ASSERT(checkEntity->id != entity->id);
if (world->collisionTable[entity->type][checkEntity->type])
{
ASSERT(entity->vertexPoints);
ASSERT(checkEntity->vertexPoints);
/* Create entity edge lists */
v2 *entityVertexListOffsetToP =
entity_generateUpdatedVertexList(transientArena, entity);
v2 *checkEntityVertexListOffsetToP =
entity_generateUpdatedVertexList(transientArena, checkEntity);
v2 *entityEdgeList =
createNormalEdgeList(transientArena, entityVertexListOffsetToP,
entity->numVertexPoints);
v2 *checkEntityEdgeList = createNormalEdgeList(
transientArena, checkEntityVertexListOffsetToP,
checkEntity->numVertexPoints);
/* Combine both edge lists into one */
i32 totalNumEdges =
checkEntity->numVertexPoints + entity->numVertexPoints;
v2 *edgeList =
memory_pushBytes(transientArena, totalNumEdges * sizeof(v2));
for (i32 i = 0; i < entity->numVertexPoints; i++)
{
edgeList[i] = entityEdgeList[i];
}
for (i32 i = 0; i < checkEntity->numVertexPoints; i++)
{
edgeList[i + entity->numVertexPoints] = checkEntityEdgeList[i];
}
if (checkEdgeProjectionOverlap(
entityVertexListOffsetToP, entity->numVertexPoints,
checkEntityVertexListOffsetToP,
checkEntity->numVertexPoints, edgeList, totalNumEdges))
{
collisionIndex = i;
}
}
if (collisionIndex != -1) break;
}
entity->dP = newDp;
entity->pos = newPos;
return collisionIndex;
}
void scotland_init() {
graphics_viewport_set_dimensions(1280, 720);
graphics_viewport_set_title("Scotland");
ui_button* loading = ui_elem_new("loading", ui_button);
ui_button_move(loading, v2(graphics_viewport_width() / 2 - 40,graphics_viewport_height() / 2 - 13));
ui_button_resize(loading, v2(80,25));
ui_button_set_label(loading, "Loading...");
ui_button_disable(loading);
ui_spinner* load_spinner = ui_elem_new("load_spinner", ui_spinner);
load_spinner->color = v4(1,1,1,1);
load_spinner->top_left = v2(graphics_viewport_width() / 2 + 50, graphics_viewport_height() / 2 - 13);
load_spinner->bottom_right = v2_add(load_spinner->top_left, v2(24,24));
ui_button* framerate = ui_elem_new("framerate", ui_button);
ui_button_move(framerate, v2(10,10));
ui_button_resize(framerate, v2(30,25));
ui_button_set_label(framerate, "FRAMERATE");
ui_button_disable(framerate);
framerate->active = false;
ui_button* wireframe = ui_elem_new("wireframe", ui_button);
ui_button_move(wireframe, v2(50,10));
ui_button_resize(wireframe, v2(80,25));
ui_button_set_label(wireframe, "wireframe");
wireframe->active = false;
ui_elem_add_event("wireframe", toggle_wireframe);
ui_button* freecam = ui_elem_new("freecam", ui_button);
ui_button_move(freecam, v2(140,10));
ui_button_resize(freecam, v2(65,25));
ui_button_set_label(freecam, "freecam");
freecam->active = false;
ui_elem_add_event("freecam", toggle_freecam);
loading_resources = true;
SDL_Thread* load_thread = SDL_GL_CreateThread(load_resources, NULL);
/* New Camera and light */
camera* cam = entity_new("camera", camera);
cam->position = v3(512.0, 200.0, 512.0);
cam->target = v3(0.0, 0.0, 0.0);
light* sun = entity_new("sun", light);
light_set_type(sun, light_type_sun);
sun->position = v3(0, 512, 0);
sun->target = v3(512, 0, 512);
/* Renderer Setup */
shadow_mapper_init(sun);
forward_renderer_init();
forward_renderer_set_camera(cam);
forward_renderer_set_shadow_light(sun);
forward_renderer_set_shadow_texture( shadow_mapper_depth_texture() );
forward_renderer_add_light(sun);
}
