ikolokolnikov/handmadehero
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Clean up.

Browse Source
This commit is contained in:
ikolokolnikov
2026-07-14 13:21:04 -07:00
parent 943ed21776
commit ffc4310646
12 changed files with 1445 additions and 955 deletions
Download Patch File Download Diff File Expand all files Collapse all files
handmade_tile.c
+102 -45
View File
@@ -1,22 +1,31 @@
#include "handmade_tile.h"
static tile_chunk *GetTileChunk(tile_map *TileMap, U32 TileChunkX, U32 TileChunkY, U32 TileChunkZ)
static struct tile_chunk *
GetTileChunk(struct tile_map *TileMap,
unsigned int TileChunkX, unsigned int TileChunkY,
unsigned int TileChunkZ)
{
tile_chunk *TileChunk = NULL;
struct tile_chunk *TileChunk = NULL;
if((TileChunkX >= 0) && (TileChunkX < TileMap->TileChunkCountX) &&
(TileChunkY >= 0) && (TileChunkY < TileMap->TileChunkCountY) &&
(TileChunkZ >= 0) && (TileChunkZ < TileMap->TileChunkCountZ))
{
TileChunk = &TileMap->TileChunks[(TileChunkZ*TileMap->TileChunkCountY*TileMap->TileChunkCountX) + (TileChunkY*TileMap->TileChunkCountX) + TileChunkX];
TileChunk =
&TileMap->TileChunks[(TileChunkZ * TileMap->TileChunkCountY *
TileMap->TileChunkCountX) +
(TileChunkY*TileMap->TileChunkCountX) + TileChunkX];
}
return TileChunk;
}
static tile_chunk_position GetChunkPositionFor(tile_map *TileMap, U32 AbsTileX, U32 AbsTileY, U32 AbsTileZ)
static struct tile_chunk_position
GetChunkPositionFor(struct tile_map *TileMap,
unsigned int AbsTileX, unsigned int AbsTileY,
unsigned int AbsTileZ)
{
tile_chunk_position Result;
struct tile_chunk_position Result;
Result.TileChunkX = AbsTileX >> TileMap->ChunkShift;
Result.TileChunkY = AbsTileY >> TileMap->ChunkShift;
@@ -27,48 +36,68 @@ static tile_chunk_position GetChunkPositionFor(tile_map *TileMap, U32 AbsTileX,
return Result;
}
static U32 GetTileValueUnchecked(tile_map *TileMap, tile_chunk *TileChunk, U32 TileX, U32 TileY)
static unsigned int
GetTileValueUnchecked(struct tile_map *TileMap,
struct tile_chunk *TileChunk,
unsigned int TileX, unsigned int TileY)
{
ASSERT(TileChunk);
ASSERT(TileX < TileMap->ChunkDim);
ASSERT(TileY < TileMap->ChunkDim);
U32 TileChunkValue = TileChunk->Tiles[TileY * TileMap->ChunkDim + TileX];
unsigned int TileChunkValue =
TileChunk->Tiles[TileY * TileMap->ChunkDim + TileX];
return TileChunkValue;
}
static U32 GetTileChunkValue(tile_map *TileMap, tile_chunk *TileChunk, U32 TestTileX, U32 TestTileY)
static unsigned int
GetTileChunkValue(struct tile_map *TileMap, struct tile_chunk *TileChunk,
unsigned int TestTileX, unsigned int TestTileY)
{
U32 TileChunkValue = 0;
unsigned int TileChunkValue = 0;
if(TileChunk && TileChunk->Tiles) {
TileChunkValue = GetTileValueUnchecked(TileMap, TileChunk, TestTileX, TestTileY);
TileChunkValue =
GetTileValueUnchecked(TileMap, TileChunk, TestTileX, TestTileY);
}
return TileChunkValue;
}
static U32 GetTileValue(tile_map *TileMap, U32 AbsTileX, U32 AbsTileY, U32 AbsTileZ)
static unsigned int
GetTileValue(struct tile_map *TileMap,
unsigned int AbsTileX, unsigned int AbsTileY,
unsigned int AbsTileZ)
{
tile_chunk_position ChunkPos = GetChunkPositionFor(TileMap, AbsTileX, AbsTileY, AbsTileZ);
tile_chunk *TileChunk = GetTileChunk(TileMap, ChunkPos.TileChunkX, ChunkPos.TileChunkY, ChunkPos.TileChunkZ);
U32 TileChunkValue = GetTileChunkValue(TileMap, TileChunk, ChunkPos.RelTileX, ChunkPos.RelTileY);
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;
}
static B32 IsTileValueEmpty(U32 TileValue)
static int IsTileValueEmpty(unsigned int TileValue)
{
B32 Empty = ((TileValue == 1) || (TileValue == 3) || (TileValue == 4));
int Empty = ((TileValue == 1) || (TileValue == 3) || (TileValue == 4));
return Empty;
}
static U32 GetTileValueByPos(tile_map *TileMap, tile_map_position Pos)
static unsigned int GetTileValueByPos(struct tile_map *TileMap,
struct tile_map_position Pos)
{
U32 TileChunkValue = GetTileValue(TileMap, Pos.AbsTileX, Pos.AbsTileY, Pos.AbsTileZ);
unsigned int TileChunkValue =
GetTileValue(TileMap, Pos.AbsTileX, Pos.AbsTileY, Pos.AbsTileZ);
return TileChunkValue;
}
static void SetTileValueUnchecked(tile_map *TileMap, tile_chunk *TileChunk, U32 TileX, U32 TileY, U32 TileValue)
static void SetTileValueUnchecked(struct tile_map *TileMap,
struct tile_chunk *TileChunk,
unsigned int TileX, unsigned int TileY,
unsigned int TileValue)
{
ASSERT(TileChunk);
ASSERT(TileX < TileMap->ChunkDim);
@@ -77,58 +106,76 @@ static void SetTileValueUnchecked(tile_map *TileMap, tile_chunk *TileChunk, U32
TileChunk->Tiles[TileY * TileMap->ChunkDim + TileX] = TileValue;
}
static void SetTileChunkValue(tile_map *TileMap, tile_chunk *TileChunk, U32 TestTileX, U32 TestTileY, U32 TileValue)
static void SetTileChunkValue(struct tile_map *TileMap,
struct tile_chunk *TileChunk,
unsigned int TestTileX, unsigned int TestTileY,
unsigned int TileValue)
{
if(TileChunk && TileChunk->Tiles) {
SetTileValueUnchecked(TileMap, TileChunk, TestTileX, TestTileY, TileValue);
SetTileValueUnchecked(TileMap, TileChunk, TestTileX, TestTileY,
TileValue);
}
}
static B32 IsTileMapPointEmpty(tile_map *TileMap, tile_map_position Pos)
static int IsTileMapPointEmpty(struct tile_map *TileMap,
struct tile_map_position Pos)
{
U32 TileChunkValue = GetTileValueByPos(TileMap, Pos);
B32 Empty = IsTileValueEmpty(TileChunkValue);
unsigned int TileChunkValue = GetTileValueByPos(TileMap, Pos);
int Empty = IsTileValueEmpty(TileChunkValue);
return Empty;
}
static void SetTileValue(memory_arena *Arena, tile_map *TileMap, U32 AbsTileX, U32 AbsTileY, U32 AbsTileZ, U32 TileValue)
static void SetTileValue(struct memory_arena *Arena,
struct tile_map *TileMap,
unsigned int AbsTileX, unsigned int AbsTileY,
unsigned int AbsTileZ, unsigned int TileValue)
{
tile_chunk_position ChunkPos = GetChunkPositionFor(TileMap, AbsTileX, AbsTileY, AbsTileZ);
tile_chunk *TileChunk = GetTileChunk(TileMap, ChunkPos.TileChunkX, ChunkPos.TileChunkY, ChunkPos.TileChunkZ);
struct tile_chunk_position ChunkPos =
GetChunkPositionFor(TileMap, AbsTileX, AbsTileY, AbsTileZ);
struct tile_chunk *TileChunk =
GetTileChunk(TileMap, ChunkPos.TileChunkX, ChunkPos.TileChunkY,
ChunkPos.TileChunkZ);
ASSERT(TileChunk);
if(!TileChunk->Tiles) {
U32 TileCount = TileMap->ChunkDim*TileMap->ChunkDim;
unsigned int TileCount = TileMap->ChunkDim*TileMap->ChunkDim;
TileChunk->Tiles = PUSH_ARRAY(Arena, TileCount, U32);
for(U32 TileIndex = 0; TileIndex < TileCount; TileIndex++) {
TileChunk->Tiles = PUSH_ARRAY(Arena, TileCount, unsigned int);
for(unsigned int TileIndex = 0;
TileIndex < TileCount;
TileIndex++)
{
TileChunk->Tiles[TileIndex] = 1;
}
}
SetTileChunkValue(TileMap, TileChunk, ChunkPos.RelTileX, ChunkPos.RelTileY, TileValue);
SetTileChunkValue(TileMap, TileChunk, ChunkPos.RelTileX,
ChunkPos.RelTileY, TileValue);
}
//
// TODO: Do these belong more in a "positioning" or "geometry" file?
//
static void CannonicalizeCoord(tile_map *TileMap, U32 *Tile, F32 *TileRel)
static void CannonicalizeCoord(struct tile_map *TileMap, unsigned int *Tile,
float *TileRel)
{
// NOTE: The world is assumed to be toroidal topology. If you step off
// one end, you come back on the other.
S32 Offset = RoundF32toS32(*TileRel / TileMap->TileSideInMeters);
int Offset = RoundFloatToInt(*TileRel / TileMap->TileSideInMeters);
*Tile += Offset;
*TileRel -= (F32)Offset * TileMap->TileSideInMeters;
*TileRel -= (float)Offset * TileMap->TileSideInMeters;
ASSERT(*TileRel >= -0.5f*TileMap->TileSideInMeters);
ASSERT(*TileRel <= 0.5f*TileMap->TileSideInMeters);
}
static tile_map_position RecannonicalizePosition(tile_map *TileMap, tile_map_position Pos)
static struct tile_map_position
RecannonicalizePosition(struct tile_map *TileMap,
struct tile_map_position Pos)
{
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);
@@ -136,20 +183,28 @@ static tile_map_position RecannonicalizePosition(tile_map *TileMap, tile_map_pos
return Result;
}
static B32 AreOnSameTile(tile_map_position *A, tile_map_position *B)
static int AreOnSameTile(struct tile_map_position *A,
struct tile_map_position *B)
{
B32 Result = ((A->AbsTileX == B->AbsTileX) && (A->AbsTileY == B->AbsTileY) && (A->AbsTileZ == B->AbsTileZ));
int Result = ((A->AbsTileX == B->AbsTileX) &&
(A->AbsTileY == B->AbsTileY) &&
(A->AbsTileZ == B->AbsTileZ));
return Result;
}
static tile_map_difference SubtractInF32(tile_map *TileMap, tile_map_position *A, tile_map_position *B)
static struct tile_map_difference
SubtractInFloat(struct tile_map *TileMap,
struct tile_map_position *A, struct tile_map_position *B)
{
tile_map_difference Result;
struct tile_map_difference Result;
v2 dTileXY = { ((F32)A->AbsTileX - (F32)B->AbsTileX), ((F32)A->AbsTileY - (F32)B->AbsTileY) };
F32 dTileZ = (F32)A->AbsTileZ - (F32)B->AbsTileZ;
struct v2 dTileXY = { ((float)A->AbsTileX - (float)B->AbsTileX),
((float)A->AbsTileY - (float)B->AbsTileY) };
float dTileZ = (float)A->AbsTileZ - (float)B->AbsTileZ;
Result.dXY = V2Add(V2Multiply(TileMap->TileSideInMeters, dTileXY), V2Subtract(A->Offset, B->Offset));
Result.dXY = V2Add(V2Multiply(TileMap->TileSideInMeters,
dTileXY),
V2Subtract(A->Offset, B->Offset));
// TODO: Incomplete . . .
Result.dZ = TileMap->TileSideInMeters*dTileZ;
@@ -157,9 +212,11 @@ static tile_map_difference SubtractInF32(tile_map *TileMap, tile_map_position *A
return Result;
}
static tile_map_position CenteredTilePoint(U32 AbsTileX, U32 AbsTileY, U32 AbsTileZ)
static struct tile_map_position
CenteredTilePoint(unsigned int AbsTileX, unsigned int AbsTileY,
unsigned int AbsTileZ)
{
tile_map_position Result;
struct tile_map_position Result;
memset(&Result, 0, sizeof(Result));
Result.AbsTileX = AbsTileX;