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

Day 36. 25:01. Need to draw assets.

Browse Source
This commit is contained in:
igor
2026-04-16 22:18:24 -07:00
parent dea811e073
commit a8a3b57f8a
6 changed files with 269 additions and 362 deletions
Download Patch File Download Diff File Expand all files Collapse all files
handmade.c
+93 -118
View File
@@ -5,7 +5,7 @@
#include "handmade_intrinsics.h"
#include "handmade_random.h"
#include "handmade_tile.h"
#include "handmade_tile.cpp"
#include "handmade_tile.c"
#include <string.h> /* memset */
@@ -44,12 +44,10 @@ static void GameOutputSound(game_state *GameState,
static void ClearBackground(game_offscreen_buffer *Buffer)
{
S32 Width, Height, X;
S32 Width = Buffer->Width;
S32 Height = Buffer->Height;
Width = Buffer->Width;
Height = Buffer->Height;
for(X = 0; X < Width * Height; X++) {
for(S32 X = 0; X < Width * Height; X++) {
U32 *Pixel = &((U32 *)Buffer->Memory)[X];
*Pixel = 0xFFFFFF;
}
@@ -68,10 +66,6 @@ static void DrawRectangle(game_offscreen_buffer *Buffer,
S32 Width = Buffer->Width;
S32 Height = Buffer->Height;
U8 *Row;
S32 Y, X;
U32 Color;
if(MinX < 0)
MinX = 0;
if(MinY < 0)
@@ -82,15 +76,15 @@ static void DrawRectangle(game_offscreen_buffer *Buffer,
if(MaxY > Height)
MaxY = Height;
Color = (U32)((RoundF32toS32(R * 255.0f) << 16) |
(RoundF32toS32(G * 255.0f) << 8) |
(RoundF32toS32(B * 255.0f) << 0));
U32 Color = (U32)((RoundF32toS32(R * 255.0f) << 16) |
(RoundF32toS32(G * 255.0f) << 8) |
(RoundF32toS32(B * 255.0f) << 0));
Row = ((U8 *)Buffer->Memory + MinX*Buffer->BytesPerPixel +
MinY*Buffer->Pitch);
for(Y = MinY; Y < MaxY; Y++) {
U8 *Row = ((U8 *)Buffer->Memory + MinX*Buffer->BytesPerPixel +
MinY*Buffer->Pitch);
for(S32 Y = MinY; Y < MaxY; Y++) {
U32 *Pixel = (U32 *)Row;
for(X = MinX; X < MaxX; X++) {
for(S32 X = MinX; X < MaxX; X++) {
*(U32 *)Pixel = Color;
Pixel++;
}
@@ -102,60 +96,36 @@ void UpdateAndRender(thread_context *Thread, game_memory *Memory,
game_input *Input, game_offscreen_buffer *Buffer,
game_sound_output_buffer *SoundBuffer)
{
#define TILEMAP_COUNT_X 256
#define TILEMAP_COUNT_Y 256
game_state *GameState;
U32 ControllerIndex;
F32 PlayerR, PlayerG, PlayerB,
PlayerWidth, PlayerHeight,
PlayerLeft, PlayerTop;
F32 ScreenCenterX, ScreenCenterY;
world *World;
tile_map *TileMap;
S32 TileSideInPixels;
F32 MetersToPixels;
ASSERT((&Input->Controllers[0].u.buttons.Terminator -
&Input->Controllers[0].u.Buttons[0]) ==
ARRAY_SIZE(Input->Controllers[0].u.Buttons));
ASSERT(sizeof(game_state) <= Memory->PermanentStorageSize);
PlayerHeight = 1.4f;
PlayerWidth = 0.75f * PlayerHeight;
#define TILEMAP_COUNT_X 256
#define TILEMAP_COUNT_Y 256
game_state *GameState;
F32 PlayerHeight = 1.4f;
F32 PlayerWidth = 0.75f * PlayerHeight;
GameState = (game_state *)Memory->PermanentStorage;
if(!Memory->IsInitialized) {
U32 TilesPerWidth, TilesPerHeight;
U32 ScreenX, ScreenY;
U32 ScreenIndex;
tile_map *TileMap;
world *World;
U32 AbsTileZ;
B32 DoorTop, DoorBottom, DoorLeft, DoorRight, DoorUp, DoorDown;
U32 RandomNumberIndex;
GameState->PlayerP.AbsTileX = 2;
GameState->PlayerP.AbsTileY = 3;
GameState->PlayerP.TileRelX = 5.0f;
GameState->PlayerP.TileRelY = 5.0f;
GameState->PlayerP.OffsetX = 5.0f;
GameState->PlayerP.OffsetY = 5.0f;
InitializeArena(&GameState->WorldArena,
Memory->PermanentStorageSize - sizeof(game_state),
(U8 *)Memory->PermanentStorage + sizeof(game_state));
GameState->World = PUSH_STRUCT(&GameState->WorldArena, world);
World = GameState->World;
world *World = GameState->World;
World->TileMap = PUSH_STRUCT(&GameState->WorldArena, tile_map);
TileMap = World->TileMap;
tile_map *TileMap = World->TileMap;
TileMap->ChunkShift = 4;
TileMap->ChunkMask = (1 << TileMap->ChunkShift) - 1;
@@ -174,34 +144,37 @@ void UpdateAndRender(thread_context *Thread, game_memory *Memory,
TileMap->TileSideInMeters = 1.4f;
RandomNumberIndex = 0;
U32 RandomNumberIndex = 0;
TilesPerWidth = 17;
TilesPerHeight = 9;
ScreenX = 0;
ScreenY = 0;
U32 TilesPerWidth = 17;
U32 TilesPerHeight = 9;
U32 ScreenX = 0;
U32 ScreenY = 0;
AbsTileZ = 0;
DoorTop = FALSE;
DoorBottom = FALSE;
DoorLeft = FALSE;
DoorRight = FALSE;
DoorUp = FALSE;
DoorDown = FALSE;
for(ScreenIndex = 0; ScreenIndex < 100; ScreenIndex++) {
/* TODO: Random number generator. */
U32 TileX, TileY;
U32 RandomChoice;
U32 AbsTileZ = 0;
B32 DoorTop = FALSE;
B32 DoorBottom = FALSE;
B32 DoorLeft = FALSE;
B32 DoorRight = FALSE;
B32 DoorUp = FALSE;
B32 DoorDown = FALSE;
for(U32 ScreenIndex = 0; ScreenIndex < 100; ScreenIndex++) {
ASSERT(RandomNumberIndex < ARRAY_SIZE(RandomNumberTable));
/* TODO: Random number generator. */
U32 RandomChoice;
if(DoorUp || DoorDown) {
RandomChoice = RandomNumberTable[RandomNumberIndex++] % 2;
} else {
RandomChoice = RandomNumberTable[RandomNumberIndex++] % 3;
}
B32 CreatedZDoor = FALSE;
if(RandomChoice == 2) {
CreatedZDoor = TRUE;
if(AbsTileZ == 0) {
DoorUp = TRUE;
} else {
@@ -213,8 +186,8 @@ void UpdateAndRender(thread_context *Thread, game_memory *Memory,
DoorTop = TRUE;
}
for(TileY = 0; TileY < TilesPerHeight; TileY++) {
for(TileX = 0; TileX < TilesPerWidth; TileX++) {
for(U32 TileY = 0; TileY < TilesPerHeight; TileY++) {
for(U32 TileX = 0; TileX < TilesPerWidth; TileX++) {
U32 AbsTileX = ScreenX * TilesPerWidth + TileX;
U32 AbsTileY = ScreenY * TilesPerHeight + TileY;
@@ -259,16 +232,12 @@ void UpdateAndRender(thread_context *Thread, game_memory *Memory,
}
}
DoorLeft = DoorRight;
DoorBottom = DoorTop;
if(DoorUp) {
DoorDown = TRUE;
DoorUp = FALSE;
} else if (DoorDown) {
DoorUp = TRUE;
DoorDown = FALSE;
if(CreatedZDoor) {
DoorDown = !DoorDown;
DoorUp = !DoorUp;
} else {
DoorUp = FALSE;
DoorDown = FALSE;
@@ -293,13 +262,13 @@ void UpdateAndRender(thread_context *Thread, game_memory *Memory,
Memory->IsInitialized = TRUE;
}
World = GameState->World;
TileMap = World->TileMap;
world *World = GameState->World;
tile_map *TileMap = World->TileMap;
TileSideInPixels = 60;
MetersToPixels = (F32)TileSideInPixels / TileMap->TileSideInMeters;
S32 TileSideInPixels = 60;
F32 MetersToPixels = (F32)TileSideInPixels / TileMap->TileSideInMeters;
for(ControllerIndex = 0;
for(U32 ControllerIndex = 0;
ControllerIndex < ARRAY_SIZE(Input->Controllers);
ControllerIndex++)
{
@@ -310,8 +279,6 @@ void UpdateAndRender(thread_context *Thread, game_memory *Memory,
F32 dPlayerX = 0.0f;
F32 dPlayerY = 0.0f;
tile_map_position NewPlayerP, PlayerLeft, PlayerRight;
if(Controller->u.buttons.MoveUp.EndedDown) {
dPlayerY = 1.0f;
}
@@ -325,48 +292,58 @@ void UpdateAndRender(thread_context *Thread, game_memory *Memory,
dPlayerX = 1.0f;
}
{
F32 PlayerSpeed = 2.0f;
F32 PlayerSpeed = 2.0f;
if(Controller->u.buttons.ActionUp.EndedDown)
PlayerSpeed = 10.0f;
if(Controller->u.buttons.ActionUp.EndedDown)
PlayerSpeed = 10.0f;
dPlayerX *= PlayerSpeed;
dPlayerY *= PlayerSpeed;
}
dPlayerX *= PlayerSpeed;
dPlayerY *= PlayerSpeed;
tile_map_position NewPlayerP;
NewPlayerP = GameState->PlayerP;
NewPlayerP.TileRelX += Input->dtForFrame*dPlayerX;
NewPlayerP.TileRelY += Input->dtForFrame*dPlayerY;
NewPlayerP.OffsetX += Input->dtForFrame*dPlayerX;
NewPlayerP.OffsetY += Input->dtForFrame*dPlayerY;
NewPlayerP = RecannonicalizePosition(TileMap, NewPlayerP);
tile_map_position PlayerLeft;
PlayerLeft = NewPlayerP;
PlayerLeft.TileRelX -= 0.5f*PlayerWidth;
PlayerLeft.OffsetX -= 0.5f*PlayerWidth;
PlayerLeft = RecannonicalizePosition(TileMap, PlayerLeft);
tile_map_position PlayerRight;
PlayerRight = NewPlayerP;
PlayerRight.TileRelX += 0.5f*PlayerWidth;
PlayerRight.OffsetX += 0.5f*PlayerWidth;
PlayerRight = RecannonicalizePosition(TileMap, PlayerRight);
if(IsTileMapPointEmpty(TileMap, NewPlayerP) &&
IsTileMapPointEmpty(TileMap, PlayerLeft) &&
IsTileMapPointEmpty(TileMap, PlayerRight))
{
if(!AreOnSameTile(&GameState->PlayerP, &NewPlayerP)) {
U32 NewTileValue =
GetTileValueByPos(TileMap, NewPlayerP);
if(NewTileValue == 3) {
NewPlayerP.AbsTileZ++;
} else if(NewTileValue == 4) {
NewPlayerP.AbsTileZ--;
}
}
GameState->PlayerP = NewPlayerP;
}
}
}
ScreenCenterX = 0.5f * (F32)Buffer->Width;
ScreenCenterY = 0.5f * (F32)Buffer->Height;
F32 ScreenCenterX = 0.5f * (F32)Buffer->Width;
F32 ScreenCenterY = 0.5f * (F32)Buffer->Height;
DrawRectangle(Buffer, 0.0f, 0.0f,
(F32)Buffer->Width, (F32)Buffer->Height,
0.0f, 1.0f, 0.0f);
{
S32 RelRow, RelColumn;
for(RelRow = -10; RelRow < 10; RelRow++) {
for(RelColumn = -20; RelColumn < 20; RelColumn++) {
for(S32 RelRow = -10; RelRow < 10; RelRow++) {
for(S32 RelColumn = -20; RelColumn < 20; RelColumn++) {
U32 Column = GameState->PlayerP.AbsTileX + RelColumn;
U32 Row = GameState->PlayerP.AbsTileY + RelRow;
@@ -376,8 +353,6 @@ void UpdateAndRender(thread_context *Thread, game_memory *Memory,
GameState->PlayerP.AbsTileZ);
if(TileID > 0) {
F32 CenterX, CenterY, MinX, MinY, MaxX, MaxY;
F32 Gray = 0.5f;
if(TileID == 2) {
Gray = 1.0f;
@@ -394,16 +369,16 @@ void UpdateAndRender(thread_context *Thread, game_memory *Memory,
}
CenterX = ScreenCenterX -
MetersToPixels*GameState->PlayerP.TileRelX +
(F32)RelColumn*(F32)TileSideInPixels;
CenterY = ScreenCenterY +
MetersToPixels*GameState->PlayerP.TileRelY -
(F32)RelRow*(F32)TileSideInPixels;
MinX = CenterX - 0.5f*(F32)TileSideInPixels;
MinY = CenterY - 0.5f*(F32)TileSideInPixels;
MaxX = CenterX + 0.5f*(F32)TileSideInPixels;
MaxY = CenterY + 0.5f*(F32)TileSideInPixels;
F32 CenterX = ScreenCenterX -
MetersToPixels*GameState->PlayerP.OffsetX +
(F32)RelColumn*(F32)TileSideInPixels;
F32 CenterY = ScreenCenterY +
MetersToPixels*GameState->PlayerP.OffsetY -
(F32)RelRow*(F32)TileSideInPixels;
F32 MinX = CenterX - 0.5f*(F32)TileSideInPixels;
F32 MinY = CenterY - 0.5f*(F32)TileSideInPixels;
F32 MaxX = CenterX + 0.5f*(F32)TileSideInPixels;
F32 MaxY = CenterY + 0.5f*(F32)TileSideInPixels;
DrawRectangle(Buffer,
MinX, MinY, MaxX, MaxY,
Gray, Gray, Gray);
@@ -412,11 +387,11 @@ void UpdateAndRender(thread_context *Thread, game_memory *Memory,
}
}
PlayerR = 1.0f;
PlayerG = 0.0f;
PlayerB = 0.0f;
PlayerLeft = ScreenCenterX - 0.5f * MetersToPixels*PlayerWidth;
PlayerTop = ScreenCenterY - MetersToPixels*PlayerHeight;
F32 PlayerR = 1.0f;
F32 PlayerG = 0.0f;
F32 PlayerB = 0.0f;
F32 PlayerLeft = ScreenCenterX - 0.5f * MetersToPixels*PlayerWidth;
F32 PlayerTop = ScreenCenterY - MetersToPixels*PlayerHeight;
DrawRectangle(Buffer,
PlayerLeft, PlayerTop,
PlayerLeft + MetersToPixels*PlayerWidth,