checkpoint

1 files changed, 327 insertions, 0 deletions

diff --git a/handmade_platform.h b/handmade_platform.h
new file mode 100644
index 0000000..bc3f84a
--- /dev/null
+++ b/handmade_platform.h
@@ -0,0 +1,327 @@
+/* date = May 12th 2025 10:53 am */
+
+#ifndef HANDMADE_PLATFORM_H
+#define HANDMADE_PLATFORM_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+    
+    /*
+      NOTE(casey):
+    
+      HANDMADE_INTERNAL:
+        0 - Build for public release
+        1 - Build for developer only
+    
+      HANDMADE_SLOW:
+        0 - Not slow code allowed!
+        1 - Slow code welcome.
+    */
+    
+#include <stdint.h>
+#include <stddef.h>
+    
+#if !defined(COMPILER_MSVC)
+#define COMPILER_MSVC 0
+#endif
+    
+#if !defined(COMPILER_LLVM)
+#define COMPILER_LLVM 0
+#endif
+    
+#if !defined(COMPILER_GNU)
+#define COMPILER_GNU 0
+#endif
+    
+#if !COMPILER_MSVC && !COMPILER_LLVM && !COMPILER_GNU
+#if _MSC_VER
+#undef COMPILER_MSVC
+#define COMPILER_MSVC 1
+#elif __GNUC__
+#undef COMPILER_GNU
+#define COMPILER_GNU 1 
+#else
+    // TODO(casey): More compilerz!!!
+#endif
+#endif 
+    
+#define internal static 
+#define local_persist static 
+#define global_variable static
+    
+#define Pi32 3.14159265359f
+    
+    // TODO(casey): Complete assertion macro - don't worry everyone!
+#if HANDMADE_SLOW
+# if HANDMADE_INTERNAL && OS_LINUX
+#   define Assert(Expression) if(!(Expression)) { __asm__ volatile("int3"); } 
+# else
+#  define Assert(Expression) if(!(Expression)) {*(int *)0 = 0; }
+# endif
+#else
+# define Assert(Expression)
+#endif
+    
+#define DebugBreakOnce do { local_persist b32 X = false; Assert(X); X = true; } while(0)
+    
+#define NullExpression { int X = 0; }
+    
+#define Kilobytes(Value) ((Value)*1024LL)
+#define Megabytes(Value) (Kilobytes(Value)*1024LL)
+#define Gigabytes(Value) (Megabytes(Value)*1024LL)
+#define Terabytes(Value) (Gigabytes(Value)*1024LL)
+    
+#define ArrayCount(Array) (sizeof(Array) / sizeof((Array)[0]))
+#define Min(A, B) (((A) < (B)) ? (A) : (B))
+#define Max(A, B) (((A) > (B)) ? (A) : (B))
+    
+    // TODO(casey): swap, min, max ... macros???
+    
+    typedef int8_t s8;
+    typedef int16_t s16;
+    typedef int32_t s32;
+    typedef int64_t s64;
+    typedef s32 b32;
+    
+    typedef uint8_t u8;
+    typedef uint16_t u16;
+    typedef uint32_t u32;
+    typedef uint64_t u64;
+    
+    typedef size_t psize;
+    typedef s32 rune;
+    
+    typedef float r32;
+    typedef double r64;
+    
+    typedef struct thread_context
+    {
+        int Placeholder;
+    } thread_context;
+    
+    /*
+      NOTE(casey): Services that the platform layer provides to the game
+    */
+    /* IMPORTANT(casey):
+    
+       These are NOT for doing anything in the shipping game - they are
+       blocking and the write doesn't protect against lost data!
+    */
+    struct debug_platform_read_file_result
+    {
+        psize ContentsSize;
+        void *Contents;
+    };
+    
+#define DEBUG_PLATFORM_FREE_FILE_MEMORY(Name) void Name(thread_context *Thread, void *Memory, psize MemorySize)
+    typedef DEBUG_PLATFORM_FREE_FILE_MEMORY(debug_platform_free_file_memory);
+    
+#define DEBUG_PLATFORM_READ_ENTIRE_FILE(Name) debug_platform_read_file_result Name(thread_context *Thread, char *FileName)
+    typedef DEBUG_PLATFORM_READ_ENTIRE_FILE(debug_platform_read_entire_file);
+    
+#define DEBUG_PLATFORM_WRITE_ENTIRE_FILE(Name) b32 Name(thread_context *Thread, char *FileName, psize MemorySize, void *Memory)
+    typedef DEBUG_PLATFORM_WRITE_ENTIRE_FILE(debug_platform_write_entire_file);
+    
+#define PLATFORM_RUN_COMMAND_AND_GET_OUTPUT(Name) psize Name(thread_context *Thread, char *OutputBuffer, char *Command[])
+    typedef PLATFORM_RUN_COMMAND_AND_GET_OUTPUT(platform_run_command_and_get_output);
+    
+#define PLATFORM_GET_WALL_CLOCK(Name) struct timespec Name(void)
+    typedef PLATFORM_GET_WALL_CLOCK(platform_get_wall_clock);
+    
+#define PLATFORM_LOG(Name) void Name(char *Text)
+    typedef PLATFORM_LOG(platform_log);
+    
+#define PLATFORM
+    
+    /*
+      NOTE(casey): Services that the game provides to the platform layer.
+      (this may expand in the future - sound on separate thread, etc.)
+    */
+    
+    // FOUR THINGS - timing, controller/keyboard input, bitmap buffer to use, sound buffer to use
+    
+    // TODO(casey): In the future, rendering _specifically_ will become a three-tiered abstraction!!!
+    typedef struct game_offscreen_buffer
+    {
+        // NOTE(casey): Pixels are alwasy 32-bits wide, Memory Order BB GG RR XX
+        void *Memory;
+        s32 Width;
+        s32 Height;
+        s32 Pitch;
+        s32 BytesPerPixel;
+    } game_offscreen_buffer;
+    
+    typedef struct game_sound_output_buffer
+    {
+        s32 SamplesPerSecond;
+        s32 SampleCount;
+        s16 *Samples;
+    } game_sound_output_buffer;
+    
+    typedef struct game_text_button
+    {
+        rune Codepoint;
+        // TODO(luca): Use flag and bits.
+        b32 Control;
+        b32 Shift;
+        b32 Alt;
+    } game_text_button;
+    
+    typedef struct game_button_state
+    {
+        s32 HalfTransitionCount;
+        b32 EndedDown;
+    } game_button_state;
+    
+    typedef struct game_controller_input
+    {
+        b32 IsConnected;
+        
+        struct
+        {
+            u32 Count;
+            game_text_button Buffer[64];
+        } Text;
+        
+        b32 IsAnalog;    
+        r32 StickAverageX;
+        r32 StickAverageY;
+        
+        union
+        {
+            game_button_state Buttons[12];
+            struct
+            {
+                game_button_state MoveUp;
+                game_button_state MoveDown;
+                game_button_state MoveLeft;
+                game_button_state MoveRight;
+                
+                game_button_state ActionUp;
+                game_button_state ActionDown;
+                game_button_state ActionLeft;
+                game_button_state ActionRight;
+                
+                game_button_state LeftShoulder;
+                game_button_state RightShoulder;
+                
+                game_button_state Back;
+                game_button_state Start;
+                
+                // NOTE(casey): All buttons must be added above this line
+                
+                game_button_state Terminator;
+            };
+        };
+    } game_controller_input;
+    
+    typedef enum
+    {
+        PlatformCursorShape_None = 0,
+        PlatformCursorShape_Grab,
+    } platform_cursor_shape;
+    
+    typedef enum
+    {
+        PlatformMouseButton_Left = 0,
+        PlatformMouseButton_Right,
+        PlatformMouseButton_Middle,
+        PlatformMouseButton_ScrollUp,
+        PlatformMouseButton_ScrollDown,
+        PlatformMouseButton_Count
+    } platform_mouse_buttons;
+    
+    typedef struct game_input
+    {
+        game_button_state MouseButtons[PlatformMouseButton_Count];
+        s32 MouseX, MouseY, MouseZ;
+        
+        r32 dtForFrame;
+        
+        game_controller_input Controllers[5];
+    } game_input;
+    
+    inline b32 WasPressed(game_button_state State)
+    {
+        b32 Result = ((State.HalfTransitionCount > 1) || 
+                      (State.HalfTransitionCount == 1 && State.EndedDown));
+        return Result;
+    }
+    
+    //- Threading 
+    typedef struct platform_work_queue platform_work_queue;
+    
+#define PLATFORM_WORK_QUEUE_CALLBACK(Name) void Name(platform_work_queue *Queue, void *Data)
+    typedef PLATFORM_WORK_QUEUE_CALLBACK(platform_work_queue_callback);
+    struct platform_work_queue_entry
+    {
+        platform_work_queue_callback *Callback;
+        void *Data;
+    };
+    
+    typedef void platform_add_entry(platform_work_queue *Queue, platform_work_queue_callback *CallBack, void *Data);
+    typedef void platform_complete_all_work(platform_work_queue *Queue);
+    //-
+    
+#define PLATFORM_CHANGE_CURSOR(name) void name(platform_cursor_shape Shape)
+    typedef PLATFORM_CHANGE_CURSOR(platform_change_cursor);
+    
+    typedef struct game_memory
+    {
+        b32 IsInitialized;
+        
+        psize PermanentStorageSize;
+        void *PermanentStorage; // NOTE(casey): REQUIRED to be cleared to zero at startup
+        
+        psize TransientStorageSize;
+        void *TransientStorage; // NOTE(casey): REQUIRED to be cleared to zero at startup
+        
+        platform_work_queue *HighPriorityQueue;
+        
+        platform_add_entry *PlatformAddEntry;
+        platform_complete_all_work *PlatformCompleteAllWork;
+        platform_run_command_and_get_output *PlatformRunCommandAndGetOutput;
+        platform_log *PlatformLog;
+        platform_change_cursor *PlatformChangeCursor;
+        platform_get_wall_clock *PlatformGetWallClock;
+        
+        debug_platform_free_file_memory *DEBUGPlatformFreeFileMemory;
+        debug_platform_read_entire_file *DEBUGPlatformReadEntireFile;
+        debug_platform_write_entire_file *DEBUGPlatformWriteEntireFile;
+    } game_memory;
+    
+#define GAME_UPDATE_AND_RENDER(name) void name(thread_context *Thread, game_memory *Memory, game_input *Input, game_offscreen_buffer *Buffer)
+    typedef GAME_UPDATE_AND_RENDER(game_update_and_render);
+    
+    // NOTE(casey): At the moment, this has to be a very fast function, it cannot be
+    // more than a millisecond or so.
+    // TODO(casey): Reduce the pressure on this function's performance by measuring it
+    // or asking about it, etc.
+#define GAME_GET_SOUND_SAMPLES(name) void name(thread_context *Thread, game_memory *Memory, game_sound_output_buffer *SoundBuffer)
+    typedef GAME_GET_SOUND_SAMPLES(game_get_sound_samples);
+    
+    inline u32
+        SafeTruncateUInt64(u64 Value)
+    {
+        // TODO(casey): Defines for maximum values
+        Assert(Value <= 0xFFFFFFFF);
+        u32 Result = (u32)Value;
+        return(Result);
+    }
+    
+    inline game_controller_input *GetController(game_input *Input, u32 ControllerIndex)
+    {
+        Assert(ControllerIndex < ArrayCount(Input->Controllers));
+        
+        game_controller_input *Result = &Input->Controllers[ControllerIndex];
+        return(Result);
+    }
+    
+    global_variable platform_log *Log;
+    
+#ifdef __cplusplus
+}
+#endif
+
+#endif //HANDMADE_PLATFORM_H