Remove core.h, SDL2->SDL3, Makefile cleanup, ansi C, 80 char.
This commit is contained in:
+158
-140
@@ -1,232 +1,250 @@
|
||||
#include "handmade_tile.h"
|
||||
|
||||
static struct tile_chunk *
|
||||
GetTileChunk(struct tile_map *TileMap,
|
||||
unsigned int TileChunkX, unsigned int TileChunkY,
|
||||
unsigned int TileChunkZ)
|
||||
{
|
||||
struct tile_chunk *TileChunk = NULL;
|
||||
#include <assert.h>
|
||||
|
||||
if((TileChunkX >= 0) && (TileChunkX < TileMap->TileChunkCountX) &&
|
||||
(TileChunkY >= 0) && (TileChunkY < TileMap->TileChunkCountY) &&
|
||||
(TileChunkZ >= 0) && (TileChunkZ < TileMap->TileChunkCountZ))
|
||||
static struct tile_chunk *
|
||||
get_tile_chunk(struct tile_map *tile_map,
|
||||
unsigned int tile_chunk_x, unsigned int tile_chunk_y,
|
||||
unsigned int tile_chunk_z)
|
||||
{
|
||||
struct tile_chunk *tile_chunk = NULL;
|
||||
|
||||
if((tile_chunk_x >= 0) && (tile_chunk_x < tile_map->tile_chunk_count_x) &&
|
||||
(tile_chunk_y >= 0) && (tile_chunk_y < tile_map->tile_chunk_count_y) &&
|
||||
(tile_chunk_z >= 0) && (tile_chunk_z < tile_map->tile_chunk_count_z))
|
||||
{
|
||||
TileChunk =
|
||||
&TileMap->TileChunks[(TileChunkZ * TileMap->TileChunkCountY *
|
||||
TileMap->TileChunkCountX) +
|
||||
(TileChunkY*TileMap->TileChunkCountX) + TileChunkX];
|
||||
tile_chunk =
|
||||
&tile_map->tile_chunks[(tile_chunk_z * tile_map->tile_chunk_count_y *
|
||||
tile_map->tile_chunk_count_x) +
|
||||
(tile_chunk_y*tile_map->tile_chunk_count_x) + tile_chunk_x];
|
||||
}
|
||||
|
||||
return TileChunk;
|
||||
return tile_chunk;
|
||||
}
|
||||
|
||||
static struct tile_chunk_position
|
||||
GetChunkPositionFor(struct tile_map *TileMap,
|
||||
unsigned int AbsTileX, unsigned int AbsTileY,
|
||||
unsigned int AbsTileZ)
|
||||
get_chunk_position_for(struct tile_map *tile_map,
|
||||
unsigned int abs_tile_x, unsigned int abs_tile_y,
|
||||
unsigned int abs_tile_z)
|
||||
{
|
||||
struct tile_chunk_position Result;
|
||||
struct tile_chunk_position result;
|
||||
|
||||
Result.TileChunkX = AbsTileX >> TileMap->ChunkShift;
|
||||
Result.TileChunkY = AbsTileY >> TileMap->ChunkShift;
|
||||
Result.TileChunkZ = AbsTileZ;
|
||||
Result.RelTileX = AbsTileX & TileMap->ChunkMask;
|
||||
Result.RelTileY = AbsTileY & TileMap->ChunkMask;
|
||||
result.tile_chunk_x = abs_tile_x >> tile_map->chunk_shift;
|
||||
result.tile_chunk_y = abs_tile_y >> tile_map->chunk_shift;
|
||||
result.tile_chunk_z = abs_tile_z;
|
||||
result.rel_tile_x = abs_tile_x & tile_map->chunk_mask;
|
||||
result.rel_tile_y = abs_tile_y & tile_map->chunk_mask;
|
||||
|
||||
return Result;
|
||||
return result;
|
||||
}
|
||||
|
||||
static unsigned int
|
||||
GetTileValueUnchecked(struct tile_map *TileMap,
|
||||
struct tile_chunk *TileChunk,
|
||||
unsigned int TileX, unsigned int TileY)
|
||||
get_tile_value_unchecked(struct tile_map *tile_map,
|
||||
struct tile_chunk *tile_chunk,
|
||||
unsigned int tile_x, unsigned int tile_y)
|
||||
{
|
||||
unsigned int TileChunkValue;
|
||||
unsigned int tile_chunk_value;
|
||||
|
||||
ASSERT(TileChunk);
|
||||
ASSERT(TileX < TileMap->ChunkDim);
|
||||
ASSERT(TileY < TileMap->ChunkDim);
|
||||
assert(tile_chunk);
|
||||
assert(tile_x < tile_map->chunk_dim);
|
||||
assert(tile_y < tile_map->chunk_dim);
|
||||
|
||||
TileChunkValue = TileChunk->Tiles[TileY * TileMap->ChunkDim + TileX];
|
||||
return TileChunkValue;
|
||||
tile_chunk_value =
|
||||
tile_chunk->tiles[tile_y * tile_map->chunk_dim + tile_x];
|
||||
return tile_chunk_value;
|
||||
}
|
||||
|
||||
static unsigned int
|
||||
GetTileChunkValue(struct tile_map *TileMap, struct tile_chunk *TileChunk,
|
||||
unsigned int TestTileX, unsigned int TestTileY)
|
||||
get_tile_chunk_value(struct tile_map *tile_map,
|
||||
struct tile_chunk *tile_chunk,
|
||||
unsigned int test_tile_x, unsigned int test_tile_y)
|
||||
{
|
||||
unsigned int TileChunkValue = 0;
|
||||
unsigned int tile_chunk_value = 0;
|
||||
|
||||
if(TileChunk && TileChunk->Tiles) {
|
||||
TileChunkValue =
|
||||
GetTileValueUnchecked(TileMap, TileChunk, TestTileX, TestTileY);
|
||||
if(tile_chunk && tile_chunk->tiles) {
|
||||
tile_chunk_value =
|
||||
get_tile_value_unchecked(tile_map, tile_chunk,
|
||||
test_tile_x, test_tile_y);
|
||||
}
|
||||
|
||||
return TileChunkValue;
|
||||
return tile_chunk_value;
|
||||
}
|
||||
|
||||
static unsigned int
|
||||
GetTileValue(struct tile_map *TileMap,
|
||||
unsigned int AbsTileX, unsigned int AbsTileY,
|
||||
unsigned int AbsTileZ)
|
||||
get_tile_value(struct tile_map *tile_map,
|
||||
unsigned int abs_tile_x, unsigned int abs_tile_y,
|
||||
unsigned int abs_tile_z)
|
||||
{
|
||||
struct tile_chunk_position ChunkPos =
|
||||
GetChunkPositionFor(TileMap, AbsTileX, AbsTileY, AbsTileZ);
|
||||
struct tile_chunk *TileChunk =
|
||||
GetTileChunk(TileMap, ChunkPos.TileChunkX, ChunkPos.TileChunkY,
|
||||
ChunkPos.TileChunkZ);
|
||||
unsigned int TileChunkValue =
|
||||
GetTileChunkValue(TileMap, TileChunk, ChunkPos.RelTileX,
|
||||
ChunkPos.RelTileY);
|
||||
return TileChunkValue;
|
||||
struct tile_chunk_position chunk_pos =
|
||||
get_chunk_position_for(tile_map, abs_tile_x, abs_tile_y, abs_tile_z);
|
||||
struct tile_chunk *tile_chunk =
|
||||
get_tile_chunk(tile_map, chunk_pos.tile_chunk_x, chunk_pos.tile_chunk_y,
|
||||
chunk_pos.tile_chunk_z);
|
||||
unsigned int tile_chunk_value =
|
||||
get_tile_chunk_value(tile_map, tile_chunk, chunk_pos.rel_tile_x,
|
||||
chunk_pos.rel_tile_y);
|
||||
return tile_chunk_value;
|
||||
}
|
||||
|
||||
static int IsTileValueEmpty(unsigned int TileValue)
|
||||
static int is_tile_value_empty(unsigned int tile_value)
|
||||
{
|
||||
int Empty = ((TileValue == 1) || (TileValue == 3) || (TileValue == 4));
|
||||
return Empty;
|
||||
int empty = ((tile_value == 1) || (tile_value == 3) || (tile_value == 4));
|
||||
return empty;
|
||||
}
|
||||
|
||||
static unsigned int GetTileValueByPos(struct tile_map *TileMap,
|
||||
struct tile_map_position Pos)
|
||||
static unsigned int get_tile_value_by_pos(struct tile_map *tile_map,
|
||||
struct tile_map_position pos)
|
||||
{
|
||||
unsigned int TileChunkValue =
|
||||
GetTileValue(TileMap, Pos.AbsTileX, Pos.AbsTileY, Pos.AbsTileZ);
|
||||
return TileChunkValue;
|
||||
unsigned int tile_chunk_value =
|
||||
get_tile_value(tile_map, pos.abs_tile_x,
|
||||
pos.abs_tile_y, pos.abs_tile_z);
|
||||
return tile_chunk_value;
|
||||
}
|
||||
|
||||
static void SetTileValueUnchecked(struct tile_map *TileMap,
|
||||
struct tile_chunk *TileChunk,
|
||||
unsigned int TileX, unsigned int TileY,
|
||||
unsigned int TileValue)
|
||||
static void set_tile_value_unchecked(struct tile_map *tile_map,
|
||||
struct tile_chunk *tile_chunk,
|
||||
unsigned int tile_x,
|
||||
unsigned int tile_y,
|
||||
unsigned int tile_value)
|
||||
{
|
||||
ASSERT(TileChunk);
|
||||
ASSERT(TileX < TileMap->ChunkDim);
|
||||
ASSERT(TileY < TileMap->ChunkDim);
|
||||
assert(tile_chunk);
|
||||
assert(tile_x < tile_map->chunk_dim);
|
||||
assert(tile_y < tile_map->chunk_dim);
|
||||
|
||||
TileChunk->Tiles[TileY * TileMap->ChunkDim + TileX] = TileValue;
|
||||
tile_chunk->tiles[tile_y * tile_map->chunk_dim + tile_x] = tile_value;
|
||||
}
|
||||
|
||||
static void SetTileChunkValue(struct tile_map *TileMap,
|
||||
struct tile_chunk *TileChunk,
|
||||
unsigned int TestTileX, unsigned int TestTileY,
|
||||
unsigned int TileValue)
|
||||
static void set_tile_chunk_value(struct tile_map *tile_map,
|
||||
struct tile_chunk *tile_chunk,
|
||||
unsigned int test_tile_x,
|
||||
unsigned int test_tile_y,
|
||||
unsigned int tile_value)
|
||||
{
|
||||
if(TileChunk && TileChunk->Tiles) {
|
||||
SetTileValueUnchecked(TileMap, TileChunk, TestTileX, TestTileY,
|
||||
TileValue);
|
||||
if(tile_chunk && tile_chunk->tiles) {
|
||||
set_tile_value_unchecked(tile_map, tile_chunk,
|
||||
test_tile_x, test_tile_y,
|
||||
tile_value);
|
||||
}
|
||||
}
|
||||
|
||||
static int IsTileMapPointEmpty(struct tile_map *TileMap,
|
||||
struct tile_map_position Pos)
|
||||
static int is_tile_map_point_empty(struct tile_map *tile_map,
|
||||
struct tile_map_position pos)
|
||||
{
|
||||
unsigned int TileChunkValue = GetTileValueByPos(TileMap, Pos);
|
||||
int Empty = IsTileValueEmpty(TileChunkValue);
|
||||
return Empty;
|
||||
unsigned int tile_chunk_value;
|
||||
int empty;
|
||||
|
||||
tile_chunk_value = get_tile_value_by_pos(tile_map, pos);
|
||||
empty = is_tile_value_empty(tile_chunk_value);
|
||||
return empty;
|
||||
}
|
||||
|
||||
static void SetTileValue(struct memory_arena *Arena,
|
||||
struct tile_map *TileMap,
|
||||
unsigned int AbsTileX, unsigned int AbsTileY,
|
||||
unsigned int AbsTileZ, unsigned int TileValue)
|
||||
static void set_tile_value(struct memory_arena *arena,
|
||||
struct tile_map *tile_map,
|
||||
unsigned int abs_tile_x, unsigned int abs_tile_y,
|
||||
unsigned int abs_tile_z, unsigned int tile_value)
|
||||
{
|
||||
struct tile_chunk_position chunk_pos;
|
||||
struct tile_chunk *tile_chunk;
|
||||
|
||||
struct tile_chunk_position ChunkPos =
|
||||
GetChunkPositionFor(TileMap, AbsTileX, AbsTileY, AbsTileZ);
|
||||
struct tile_chunk *TileChunk =
|
||||
GetTileChunk(TileMap, ChunkPos.TileChunkX, ChunkPos.TileChunkY,
|
||||
ChunkPos.TileChunkZ);
|
||||
chunk_pos = get_chunk_position_for(tile_map,
|
||||
abs_tile_x, abs_tile_y, abs_tile_z);
|
||||
tile_chunk = get_tile_chunk(tile_map,
|
||||
chunk_pos.tile_chunk_x,
|
||||
chunk_pos.tile_chunk_y,
|
||||
chunk_pos.tile_chunk_z);
|
||||
|
||||
ASSERT(TileChunk);
|
||||
if(!TileChunk->Tiles) {
|
||||
unsigned int TileCount = TileMap->ChunkDim*TileMap->ChunkDim;
|
||||
unsigned int TileIndex;
|
||||
assert(tile_chunk);
|
||||
if(!tile_chunk->tiles) {
|
||||
unsigned int tile_count, tile_index;
|
||||
|
||||
TileChunk->Tiles = PUSH_ARRAY(Arena, TileCount, unsigned int);
|
||||
for(TileIndex = 0;
|
||||
TileIndex < TileCount;
|
||||
TileIndex++)
|
||||
tile_count = tile_map->chunk_dim*tile_map->chunk_dim;
|
||||
|
||||
tile_chunk->tiles = PUSH_ARRAY(arena, tile_count, unsigned int);
|
||||
for(tile_index = 0;
|
||||
tile_index < tile_count;
|
||||
tile_index++)
|
||||
{
|
||||
TileChunk->Tiles[TileIndex] = 1;
|
||||
tile_chunk->tiles[tile_index] = 1;
|
||||
}
|
||||
}
|
||||
|
||||
SetTileChunkValue(TileMap, TileChunk, ChunkPos.RelTileX,
|
||||
ChunkPos.RelTileY, TileValue);
|
||||
set_tile_chunk_value(tile_map, tile_chunk, chunk_pos.rel_tile_x,
|
||||
chunk_pos.rel_tile_y, tile_value);
|
||||
}
|
||||
|
||||
/* TODO: Do these belong more in a "positioning" or "geometry" file? */
|
||||
|
||||
static void CannonicalizeCoord(struct tile_map *TileMap, unsigned int *Tile,
|
||||
float *TileRel)
|
||||
static void cannonicalize_coord(struct tile_map *tile_map,
|
||||
unsigned int *tile,
|
||||
float *tile_rel)
|
||||
{
|
||||
/* NOTE: The world is assumed to be toroidal topology. If you step off
|
||||
* one end, you come back on the other.*/
|
||||
int Offset = RoundFloatToInt(*TileRel / TileMap->TileSideInMeters);
|
||||
*Tile += Offset;
|
||||
*TileRel -= (float)Offset * TileMap->TileSideInMeters;
|
||||
int offset =
|
||||
round_float_to_int(*tile_rel / tile_map->tile_side_in_meters);
|
||||
*tile += offset;
|
||||
*tile_rel -= (float)offset * tile_map->tile_side_in_meters;
|
||||
|
||||
ASSERT(*TileRel >= -0.5f*TileMap->TileSideInMeters);
|
||||
ASSERT(*TileRel <= 0.5f*TileMap->TileSideInMeters);
|
||||
assert(*tile_rel >= -0.5f*tile_map->tile_side_in_meters);
|
||||
assert(*tile_rel <= 0.5f*tile_map->tile_side_in_meters);
|
||||
}
|
||||
|
||||
static struct tile_map_position
|
||||
RecannonicalizePosition(struct tile_map *TileMap,
|
||||
struct tile_map_position Pos)
|
||||
recannonicalize_position(struct tile_map *tile_map,
|
||||
struct tile_map_position pos)
|
||||
{
|
||||
struct tile_map_position Result = Pos;
|
||||
struct tile_map_position result = pos;
|
||||
|
||||
CannonicalizeCoord(TileMap, &Result.AbsTileX, &Result.Offset.X);
|
||||
CannonicalizeCoord(TileMap, &Result.AbsTileY, &Result.Offset.Y);
|
||||
cannonicalize_coord(tile_map, &result.abs_tile_x, &result.offset.x);
|
||||
cannonicalize_coord(tile_map, &result.abs_tile_y, &result.offset.y);
|
||||
|
||||
return Result;
|
||||
return result;
|
||||
}
|
||||
|
||||
static int AreOnSameTile(struct tile_map_position *A,
|
||||
struct tile_map_position *B)
|
||||
static int are_on_same_tile(struct tile_map_position *a,
|
||||
struct tile_map_position *b)
|
||||
{
|
||||
int Result = ((A->AbsTileX == B->AbsTileX) &&
|
||||
(A->AbsTileY == B->AbsTileY) &&
|
||||
(A->AbsTileZ == B->AbsTileZ));
|
||||
return Result;
|
||||
int result = ((a->abs_tile_x == b->abs_tile_x) &&
|
||||
(a->abs_tile_y == b->abs_tile_y) &&
|
||||
(a->abs_tile_z == b->abs_tile_z));
|
||||
return result;
|
||||
}
|
||||
|
||||
static struct tile_map_difference
|
||||
SubtractInFloat(struct tile_map *TileMap,
|
||||
struct tile_map_position *A, struct tile_map_position *B)
|
||||
subtract_in_float(struct tile_map *tile_map,
|
||||
struct tile_map_position *a, struct tile_map_position *b)
|
||||
{
|
||||
struct tile_map_difference Result;
|
||||
struct tile_map_difference result;
|
||||
|
||||
struct v2 dTileXY;
|
||||
struct v2 d_tile_xy;
|
||||
|
||||
float dTileZ;
|
||||
float d_tile_z;
|
||||
|
||||
dTileXY.X = (float)A->AbsTileX - (float)B->AbsTileX;
|
||||
dTileXY.Y = (float)A->AbsTileY - (float)B->AbsTileY;
|
||||
d_tile_xy.x = (float)a->abs_tile_x - (float)b->abs_tile_x;
|
||||
d_tile_xy.y = (float)a->abs_tile_y - (float)b->abs_tile_y;
|
||||
|
||||
dTileZ = (float)A->AbsTileZ - (float)B->AbsTileZ;
|
||||
d_tile_z = (float)a->abs_tile_z - (float)b->abs_tile_z;
|
||||
|
||||
Result.dXY = V2Add(V2Multiply(TileMap->TileSideInMeters,
|
||||
dTileXY),
|
||||
V2Subtract(A->Offset, B->Offset));
|
||||
result.d_xy = V2Add(V2Multiply(tile_map->tile_side_in_meters,
|
||||
d_tile_xy),
|
||||
V2Subtract(a->offset, b->offset));
|
||||
|
||||
/* TODO: Incomplete . . . */
|
||||
Result.dZ = TileMap->TileSideInMeters*dTileZ;
|
||||
result.d_z = tile_map->tile_side_in_meters*d_tile_z;
|
||||
|
||||
return Result;
|
||||
return result;
|
||||
}
|
||||
|
||||
static struct tile_map_position
|
||||
CenteredTilePoint(unsigned int AbsTileX, unsigned int AbsTileY,
|
||||
unsigned int AbsTileZ)
|
||||
centered_tile_point(unsigned int abs_tile_x, unsigned int abs_tile_y,
|
||||
unsigned int abs_tile_z)
|
||||
{
|
||||
struct tile_map_position Result;
|
||||
memset(&Result, 0, sizeof(Result));
|
||||
struct tile_map_position result;
|
||||
memset(&result, 0, sizeof(result));
|
||||
|
||||
Result.AbsTileX = AbsTileX;
|
||||
Result.AbsTileY = AbsTileY;
|
||||
Result.AbsTileZ = AbsTileZ;
|
||||
result.abs_tile_x = abs_tile_x;
|
||||
result.abs_tile_y = abs_tile_y;
|
||||
result.abs_tile_z = abs_tile_z;
|
||||
|
||||
return Result;
|
||||
return result;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user