540 lines
22 KiB
C++
540 lines
22 KiB
C++
#include "base_core.h"
|
|
#include "sdl_handmade.h"
|
|
#include "handmade.cpp"
|
|
|
|
#include <SDL.h>
|
|
#include <sys/mman.h> // mmap
|
|
#include <stdlib.h> // malloc, calloc
|
|
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h> // fstat
|
|
#include <fcntl.h> // open
|
|
#include <unistd.h> // close, read
|
|
|
|
// NOTE: This is so it compiles on ARM.
|
|
#if __x86_64__ || __i386__
|
|
#include <x86intrin.h>
|
|
#endif
|
|
|
|
global bool GlobalRunning;
|
|
|
|
global U64 GlobalPerfCountFrequency;
|
|
|
|
#define CONTROLLER_LEFT_THUMB_DEADZONE 8000
|
|
#define MAX_CONTROLLERS 4
|
|
SDL_GameController *ControllerHandles[MAX_CONTROLLERS];
|
|
|
|
global offscreen_buffer GlobalBackbuffer;
|
|
|
|
internal U32 SafeTruncateUInt64(U64 Value)
|
|
{
|
|
Assert(Value <= 0xFFFFFFFF);
|
|
U32 Result = (U32)Value;
|
|
return Result;
|
|
}
|
|
|
|
internal debug_read_file_result DEBUGPlatformReadEntireFile(const char *Filename)
|
|
{
|
|
debug_read_file_result Result = {0};
|
|
S32 FileHandle = open(Filename, O_RDONLY);
|
|
if(FileHandle == -1) {
|
|
return Result;
|
|
}
|
|
|
|
struct stat FileStatus;
|
|
if(fstat(FileHandle, &FileStatus) == -1) {
|
|
close(FileHandle);
|
|
return Result;
|
|
}
|
|
Result.ContentsSize = SafeTruncateUInt64(FileStatus.st_size);
|
|
|
|
Result.Contents = malloc(Result.ContentsSize);
|
|
if(!Result.Contents) {
|
|
Result.ContentsSize = 0;
|
|
close(FileHandle);
|
|
return Result;
|
|
}
|
|
|
|
U32 BytesToRead = Result.ContentsSize;
|
|
U8 *NextByteLocation = (U8 *)Result.Contents;
|
|
while(BytesToRead) {
|
|
U32 BytesRead = read(FileHandle, NextByteLocation, BytesToRead);
|
|
if(BytesRead == (U32)-1) {
|
|
free(Result.Contents);
|
|
Result.Contents = 0;
|
|
Result.ContentsSize = 0;
|
|
close(FileHandle);
|
|
return Result;
|
|
}
|
|
BytesToRead -= BytesRead;
|
|
NextByteLocation += BytesRead;
|
|
}
|
|
|
|
close(FileHandle);
|
|
|
|
return Result;
|
|
}
|
|
|
|
internal B32 DEBUGPlatformWriteEntireFile(const char *Filename, U32 MemorySize, void *Memory)
|
|
{
|
|
S32 FileHandle = open(Filename, O_WRONLY | O_CREAT, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
|
|
if(FileHandle == -1)
|
|
return false;
|
|
|
|
U32 BytesToWrite = MemorySize;
|
|
U8 *NextByteLocation = (U8*)Memory;
|
|
while(BytesToWrite) {
|
|
U32 BytesWritten = write(FileHandle, NextByteLocation, BytesToWrite);
|
|
if(BytesWritten == (U32)-1) {
|
|
close(FileHandle);
|
|
return false;
|
|
}
|
|
BytesToWrite -= BytesWritten;
|
|
NextByteLocation += BytesWritten;
|
|
}
|
|
|
|
close(FileHandle);
|
|
|
|
return true;
|
|
}
|
|
|
|
internal void DEBUGPlatformFreeFileMemory(void *Memory)
|
|
{
|
|
if(Memory)
|
|
free(Memory);
|
|
}
|
|
|
|
|
|
sdl_window_dimension SDLGetWindowDimension(SDL_Window *Window)
|
|
{
|
|
sdl_window_dimension Dimension;
|
|
SDL_GetWindowSize(Window, &Dimension.Width, &Dimension.Height);
|
|
return Dimension;
|
|
}
|
|
|
|
internal void SDLResizeTexture(offscreen_buffer *Buffer, SDL_Renderer *Renderer, int Width, int Height)
|
|
{
|
|
if(Buffer->Texture)
|
|
SDL_DestroyTexture(Buffer->Texture);
|
|
|
|
if(Buffer->Memory)
|
|
free(Buffer->Memory);
|
|
|
|
S32 BytesPerPixel = 4;
|
|
|
|
Buffer->Texture = SDL_CreateTexture(Renderer, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_STREAMING, Width, Height);
|
|
Buffer->Memory = malloc(Width * Height * BytesPerPixel);
|
|
|
|
Buffer->Height = Height;
|
|
Buffer->Width = Width;
|
|
Buffer->Pitch = Width * BytesPerPixel;
|
|
}
|
|
|
|
internal void SDLDisplayBufferInWindow(offscreen_buffer Buffer, SDL_Window *Window, SDL_Renderer *Renderer)
|
|
{
|
|
if(SDL_UpdateTexture(Buffer.Texture, 0, Buffer.Memory, Buffer.Pitch)) {
|
|
// TODO: Do something about this error!
|
|
}
|
|
|
|
SDL_RenderCopy(Renderer, Buffer.Texture, 0, 0);
|
|
SDL_RenderPresent(Renderer);
|
|
}
|
|
|
|
internal void SDLInitControllers()
|
|
{
|
|
int MaxJoysticks = SDL_NumJoysticks();
|
|
int ControllerIndex = 0;
|
|
for(int JoystickIndex = 0; JoystickIndex < MaxJoysticks; JoystickIndex++) {
|
|
if(!SDL_IsGameController(JoystickIndex))
|
|
continue;
|
|
if(ControllerIndex >= MAX_CONTROLLERS)
|
|
break;
|
|
ControllerHandles[ControllerIndex] = SDL_GameControllerOpen(JoystickIndex);
|
|
ControllerIndex++;
|
|
}
|
|
}
|
|
|
|
/*
|
|
internal void SDLDeinitControllers()
|
|
{
|
|
for(int ControllerIndex = 0; ControllerIndex < MAX_CONTROLLERS; ControllerIndex++) {
|
|
if (ControllerHandles[ControllerIndex])
|
|
SDL_GameControllerClose(ControllerHandles[ControllerIndex]);
|
|
}
|
|
}
|
|
*/
|
|
|
|
|
|
internal void SDLInitSound(S32 SamplesPerSecond, S32 BufferSize)
|
|
{
|
|
SDL_AudioSpec AudioSettings = {0};
|
|
|
|
AudioSettings.freq = SamplesPerSecond;
|
|
AudioSettings.format = AUDIO_S16LSB;
|
|
AudioSettings.channels = 2;
|
|
AudioSettings.samples = BufferSize;
|
|
|
|
SDL_OpenAudio(&AudioSettings, 0);
|
|
|
|
if(AudioSettings.format != AUDIO_S16LSB) {
|
|
SDL_CloseAudio();
|
|
}
|
|
}
|
|
|
|
internal void SDLFillSoundBuffer(sdl_sound_output *SoundOutput, S32 BytesToWrite)
|
|
{
|
|
SDL_QueueAudio(1, SoundOutput->Samples, BytesToWrite);
|
|
}
|
|
|
|
internal void SDLClearSoundBuffer(sdl_sound_output *SoundOutput)
|
|
{
|
|
memset(SoundOutput->Samples, 0, SoundOutput->SecondaryBufferSize);
|
|
}
|
|
|
|
internal void SDLProcessKeyboardMessage(game_button_state *NewState, bool IsDown)
|
|
{
|
|
Assert(NewState->EndedDown != IsDown);
|
|
NewState->EndedDown = IsDown;
|
|
++NewState->HalfTransitionCount;
|
|
}
|
|
|
|
internal void SDLProcessInputDigitalButton(SDL_GameController *Controller, game_button_state *OldState,
|
|
SDL_GameControllerButton Button, game_button_state *NewState)
|
|
{
|
|
NewState->EndedDown = SDL_GameControllerGetButton(Controller, Button);
|
|
NewState->HalfTransitionCount = (OldState->EndedDown != NewState->EndedDown) ? 1 : 0;
|
|
}
|
|
|
|
internal void HandleEvent(SDL_Event *Event)
|
|
{
|
|
switch(Event->type) {
|
|
case SDL_QUIT: {
|
|
GlobalRunning = false;
|
|
} break;
|
|
|
|
case SDL_WINDOWEVENT: {
|
|
switch(Event->window.event) {
|
|
case SDL_WINDOWEVENT_SIZE_CHANGED: {
|
|
SDL_Window *Window = SDL_GetWindowFromID(Event->window.windowID);
|
|
SDL_Renderer *Renderer = SDL_GetRenderer(Window);
|
|
|
|
sdl_window_dimension Dimension = SDLGetWindowDimension(Window);
|
|
SDLResizeTexture(&GlobalBackbuffer, Renderer, Dimension.Width, Dimension.Height);
|
|
} break;
|
|
|
|
case SDL_WINDOWEVENT_EXPOSED: {
|
|
} break;
|
|
}
|
|
} break;
|
|
}
|
|
}
|
|
|
|
internal void SDLProcessMessages(game_controller_input *KeyboardController)
|
|
{
|
|
SDL_Event Event;
|
|
while(SDL_PollEvent(&Event)) {
|
|
switch(Event.type) {
|
|
case SDL_KEYDOWN:
|
|
case SDL_KEYUP: {
|
|
SDL_Keycode KeyCode = Event.key.keysym.sym;
|
|
bool IsDown = (Event.key.state == SDL_PRESSED);
|
|
bool WasDown = false;
|
|
if(Event.key.state == SDL_RELEASED) {
|
|
WasDown = true;
|
|
} else if(Event.key.repeat != 0) {
|
|
WasDown = true;
|
|
}
|
|
|
|
if(Event.key.repeat == 0) {
|
|
if(KeyCode == SDLK_w) {
|
|
SDLProcessKeyboardMessage(&KeyboardController->MoveUp, IsDown);
|
|
} else if(KeyCode == SDLK_s) {
|
|
SDLProcessKeyboardMessage(&KeyboardController->MoveDown, IsDown);
|
|
} else if(KeyCode == SDLK_a) {
|
|
SDLProcessKeyboardMessage(&KeyboardController->MoveLeft, IsDown);
|
|
} else if(KeyCode == SDLK_d) {
|
|
SDLProcessKeyboardMessage(&KeyboardController->MoveRight, IsDown);
|
|
} else if(KeyCode == SDLK_q) {
|
|
SDLProcessKeyboardMessage(&KeyboardController->LeftShoulder, IsDown);
|
|
} else if(KeyCode == SDLK_e) {
|
|
SDLProcessKeyboardMessage(&KeyboardController->RightShoulder, IsDown);
|
|
} else if(KeyCode == SDLK_UP) {
|
|
SDLProcessKeyboardMessage(&KeyboardController->ActionUp, IsDown);
|
|
} else if(KeyCode == SDLK_DOWN) {
|
|
SDLProcessKeyboardMessage(&KeyboardController->ActionDown, IsDown);
|
|
} else if(KeyCode == SDLK_LEFT) {
|
|
SDLProcessKeyboardMessage(&KeyboardController->ActionLeft, IsDown);
|
|
} else if(KeyCode == SDLK_RIGHT) {
|
|
SDLProcessKeyboardMessage(&KeyboardController->ActionRight, IsDown);
|
|
} else if(KeyCode == SDLK_ESCAPE) {
|
|
SDLProcessKeyboardMessage(&KeyboardController->Start, IsDown);
|
|
} else if(KeyCode == SDLK_SPACE) {
|
|
SDLProcessKeyboardMessage(&KeyboardController->Back, IsDown);
|
|
}
|
|
}
|
|
|
|
// NOTE: If your window manager already uses an Alt+F4 keybind to close programs, then we are likely to see SDL_QUIT event occur before our keybind.
|
|
bool AltKeyWasDown = (Event.key.keysym.mod & KMOD_ALT);
|
|
if(KeyCode == SDLK_F4 && AltKeyWasDown)
|
|
GlobalRunning = false;
|
|
} break;
|
|
|
|
default: {
|
|
HandleEvent(&Event);
|
|
} break;
|
|
}
|
|
}
|
|
}
|
|
|
|
internal F32 SDLProcessInputStickValue(F32 Value, S32 DeadZoneThreshold)
|
|
{
|
|
F32 Result = 0.0f;
|
|
if(Value < -DeadZoneThreshold)
|
|
Result = (F32)((Value + DeadZoneThreshold) / (32768.0f - DeadZoneThreshold));
|
|
else if(Value > DeadZoneThreshold)
|
|
Result = (F32)((Value + DeadZoneThreshold) / (32767.0f - DeadZoneThreshold));
|
|
return Result;
|
|
}
|
|
|
|
#define DEFAULT_REFRESH_RATE 60
|
|
internal S32 SDLGetWindowRefreshRate(SDL_Window *Window)
|
|
{
|
|
int DisplayIndex = SDL_GetWindowDisplayIndex(Window);
|
|
SDL_DisplayMode Mode;
|
|
|
|
if(SDL_GetDesktopDisplayMode(DisplayIndex, &Mode) != 0)
|
|
return DEFAULT_REFRESH_RATE;
|
|
if(Mode.refresh_rate == 0)
|
|
return DEFAULT_REFRESH_RATE;
|
|
return Mode.refresh_rate;
|
|
}
|
|
|
|
internal U64 SDLGetWallClock()
|
|
{
|
|
return SDL_GetPerformanceCounter();
|
|
}
|
|
|
|
internal F32 SDLGetSecondsElapsed(U64 Start, U64 End)
|
|
{
|
|
return (F32)(End - Start) / (F32)GlobalPerfCountFrequency;
|
|
}
|
|
|
|
S32 main(int argc, char *argv[])
|
|
{
|
|
if(SDL_Init(SDL_INIT_VIDEO|SDL_INIT_GAMECONTROLLER|SDL_INIT_AUDIO)) {
|
|
/* TODO: This didn't work . . . */
|
|
}
|
|
|
|
SDLInitControllers();
|
|
|
|
SDL_Window *Window = SDL_CreateWindow("Handmade Hero", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, 700, 500, SDL_WINDOW_RESIZABLE);
|
|
|
|
if(Window) {
|
|
//SDL_Renderer *Renderer = SDL_CreateRenderer(Window, -1, 0);
|
|
SDL_Renderer *Renderer = SDL_CreateRenderer(Window, -1, SDL_RENDERER_PRESENTVSYNC);
|
|
// "Wayland needs an event loop and rendering or it won't function." https://github.com/libsdl-org/SDL/issues/7699#issuecomment-1545684792
|
|
// NOTE: This means that we need to readraw to even resize the window, otherwise the window frame will appear outdated to its actual size.
|
|
// SDL_RenderPresent(Renderer) is enough to display the window.
|
|
if(Renderer) {
|
|
GlobalRunning = true;
|
|
|
|
sdl_window_dimension Dimension = SDLGetWindowDimension(Window);
|
|
SDLResizeTexture(&GlobalBackbuffer, Renderer, Dimension.Width, Dimension.Height);
|
|
|
|
sdl_sound_output SoundOutput = {0};
|
|
|
|
SoundOutput.SamplesPerSecond = 48000;
|
|
SoundOutput.BytesPerSample = sizeof(S16) * 2;
|
|
SoundOutput.SecondaryBufferSize = SoundOutput.SamplesPerSecond * SoundOutput.BytesPerSample;
|
|
SoundOutput.tSine = 0;
|
|
SoundOutput.LatencySampleCount = SoundOutput.SamplesPerSecond / 15;
|
|
|
|
SDLInitSound(SoundOutput.SamplesPerSecond, SoundOutput.SamplesPerSecond * SoundOutput.BytesPerSample / 60);
|
|
SDL_PauseAudio(0);
|
|
|
|
SoundOutput.Samples = calloc(SoundOutput.SamplesPerSecond, SoundOutput.BytesPerSample);
|
|
// SoundOutput.Samples = malloc(SoundOutput.SecondaryBufferSize);
|
|
// SDLClearSoundBuffer(&SoundOutput); // NOTE: calloc auto clears to zero
|
|
|
|
#if BUILD_DEBUG
|
|
void *BaseAddress = (void *)TB(2);
|
|
#else
|
|
void *BaseAddress = (void *)(0);
|
|
#endif
|
|
|
|
game_memory GameMemory = {0};
|
|
|
|
GameMemory.PermanentStorageSize = MB(64);
|
|
GameMemory.TransientStorageSize = GB(4);
|
|
U64 TotalStorageSize = GameMemory.PermanentStorageSize + GameMemory.TransientStorageSize;
|
|
|
|
// NOTE: On MacOS and Linux, mmap seems to zero-fill anonymous
|
|
// memory as a side-effect of security.
|
|
GameMemory.PermanentStorage = mmap(BaseAddress, TotalStorageSize, PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE, -1, 0);
|
|
GameMemory.TransientStorage = (U8 *)(GameMemory.PermanentStorage) + GameMemory.PermanentStorageSize;
|
|
|
|
if(SoundOutput.Samples && GameMemory.PermanentStorage && GameMemory.TransientStorage) {
|
|
game_input Input[2];
|
|
game_input *NewInput = &Input[0];
|
|
game_input *OldInput = &Input[1];
|
|
memset(&Input, 0, sizeof(Input));
|
|
|
|
GlobalPerfCountFrequency = SDL_GetPerformanceFrequency();
|
|
|
|
U64 LastCounter;
|
|
#if __x86_64__ || __i386__
|
|
U64 LastCycleCount;
|
|
#endif
|
|
|
|
while(GlobalRunning) {
|
|
LastCounter = SDLGetWallClock();
|
|
|
|
#if __x86_64__ || __i386__
|
|
LastCycleCount = __rdtsc(); // NOTE: rdtsc reports clock cylces, however it is not meant for really precise profiler work as the value returned is varied.
|
|
#endif // Also, __rdtsc is not available on MacOS ARM; I have not checked MacOS x64.
|
|
|
|
S32 MonitorRefreshHz = SDLGetWindowRefreshRate(Window);
|
|
S32 GameUpdateHz = MonitorRefreshHz / 2;
|
|
F32 TargetSecondsPerFrame = 1.0f / (F32)GameUpdateHz;
|
|
|
|
game_controller_input *OldKeyboardController = GetController(OldInput, 0);
|
|
game_controller_input *NewKeyboardController = GetController(NewInput, 0);
|
|
game_controller_input ZeroController = {0};
|
|
*NewKeyboardController = ZeroController;
|
|
NewKeyboardController->IsConnected = true;
|
|
|
|
for(U32 ButtonIndex = 0; ButtonIndex < ArrayCount(NewKeyboardController->Buttons); ButtonIndex++) {
|
|
NewKeyboardController->Buttons[ButtonIndex].EndedDown = OldKeyboardController->Buttons[ButtonIndex].EndedDown;
|
|
}
|
|
|
|
SDLProcessMessages(NewKeyboardController);
|
|
|
|
for(S32 ControllerIndex = 0; ControllerIndex < MAX_CONTROLLERS; ControllerIndex++) {
|
|
game_controller_input *OldController = GetController(OldInput, ControllerIndex+1);
|
|
game_controller_input *NewController = GetController(NewInput, ControllerIndex+1);
|
|
|
|
if(ControllerHandles[ControllerIndex] != 0 && SDL_GameControllerGetAttached(ControllerHandles[ControllerIndex])) {
|
|
NewController->IsConnected = true;
|
|
|
|
S16 StickX = SDL_GameControllerGetAxis(ControllerHandles[ControllerIndex], SDL_CONTROLLER_AXIS_LEFTX);
|
|
S16 StickY = SDL_GameControllerGetAxis(ControllerHandles[ControllerIndex], SDL_CONTROLLER_AXIS_LEFTY);
|
|
|
|
NewController->IsAnalog = true;
|
|
NewController->StickAverageX = SDLProcessInputStickValue((F32)StickX, CONTROLLER_LEFT_THUMB_DEADZONE);
|
|
NewController->StickAverageY = SDLProcessInputStickValue((F32)StickY, CONTROLLER_LEFT_THUMB_DEADZONE);
|
|
|
|
if((NewController->StickAverageX != 0.0f) || (NewController->StickAverageY != 0.0f)) {
|
|
NewController->IsAnalog = true;
|
|
}
|
|
|
|
if(SDL_GameControllerGetButton(ControllerHandles[ControllerIndex], SDL_CONTROLLER_BUTTON_DPAD_UP)) {
|
|
NewController->StickAverageY = -1.0f;
|
|
NewController->IsAnalog = false;
|
|
}
|
|
|
|
if(SDL_GameControllerGetButton(ControllerHandles[ControllerIndex], SDL_CONTROLLER_BUTTON_DPAD_DOWN)) {
|
|
NewController->StickAverageY = 1.0f;
|
|
NewController->IsAnalog = false;
|
|
}
|
|
|
|
if(SDL_GameControllerGetButton(ControllerHandles[ControllerIndex], SDL_CONTROLLER_BUTTON_DPAD_LEFT)) {
|
|
NewController->StickAverageX = -1.0f;
|
|
NewController->IsAnalog = false;
|
|
}
|
|
|
|
if(SDL_GameControllerGetButton(ControllerHandles[ControllerIndex], SDL_CONTROLLER_BUTTON_DPAD_RIGHT)) {
|
|
NewController->StickAverageX = 1.0f;
|
|
NewController->IsAnalog = false;
|
|
}
|
|
|
|
F32 Threshold = 0.5f;
|
|
SDLProcessInputDigitalButton(ControllerHandles[(NewController->StickAverageY < -Threshold) ? 1 : 0], &OldController->MoveUp, SDL_CONTROLLER_BUTTON_A, &NewController->MoveUp);
|
|
SDLProcessInputDigitalButton(ControllerHandles[(NewController->StickAverageY > Threshold) ? 1 : 0], &OldController->MoveDown, SDL_CONTROLLER_BUTTON_A, &NewController->MoveDown);
|
|
SDLProcessInputDigitalButton(ControllerHandles[(NewController->StickAverageX < -Threshold) ? 1 : 0], &OldController->MoveLeft, SDL_CONTROLLER_BUTTON_A, &NewController->MoveLeft);
|
|
SDLProcessInputDigitalButton(ControllerHandles[(NewController->StickAverageX > Threshold) ? 1 : 0], &OldController->MoveRight, SDL_CONTROLLER_BUTTON_A, &NewController->MoveRight);
|
|
|
|
SDLProcessInputDigitalButton(ControllerHandles[ControllerIndex], &OldController->ActionDown, SDL_CONTROLLER_BUTTON_A, &NewController->ActionDown);
|
|
SDLProcessInputDigitalButton(ControllerHandles[ControllerIndex], &OldController->ActionRight, SDL_CONTROLLER_BUTTON_B, &NewController->ActionRight);
|
|
SDLProcessInputDigitalButton(ControllerHandles[ControllerIndex], &OldController->ActionLeft, SDL_CONTROLLER_BUTTON_X, &NewController->ActionLeft);
|
|
SDLProcessInputDigitalButton(ControllerHandles[ControllerIndex], &OldController->ActionUp, SDL_CONTROLLER_BUTTON_Y, &NewController->ActionUp);
|
|
SDLProcessInputDigitalButton(ControllerHandles[ControllerIndex], &OldController->LeftShoulder, SDL_CONTROLLER_BUTTON_LEFTSHOULDER, &NewController->LeftShoulder);
|
|
SDLProcessInputDigitalButton(ControllerHandles[ControllerIndex], &OldController->RightShoulder, SDL_CONTROLLER_BUTTON_RIGHTSHOULDER, &NewController->RightShoulder);
|
|
|
|
SDLProcessInputDigitalButton(ControllerHandles[ControllerIndex], &OldController->Start, SDL_CONTROLLER_BUTTON_START, &NewController->Start);
|
|
SDLProcessInputDigitalButton(ControllerHandles[ControllerIndex], &OldController->Back, SDL_CONTROLLER_BUTTON_BACK, &NewController->Back);
|
|
} else {
|
|
// NOTE: This controller is note plugged in.
|
|
NewController->IsConnected = false;
|
|
}
|
|
}
|
|
|
|
S32 TargetQueueBytes = SoundOutput.LatencySampleCount * SoundOutput.BytesPerSample;
|
|
S32 BytesToWrite = TargetQueueBytes - SDL_GetQueuedAudioSize(1);
|
|
game_sound_output_buffer SoundBuffer;
|
|
SoundBuffer.SamplesPerSecond = SoundOutput.SamplesPerSecond;
|
|
SoundBuffer.SampleCount = BytesToWrite / SoundOutput.BytesPerSample;
|
|
SoundBuffer.Samples = (S16 *)SoundOutput.Samples;
|
|
|
|
game_offscreen_buffer Buffer;
|
|
Buffer.Memory = GlobalBackbuffer.Memory;
|
|
Buffer.Width = GlobalBackbuffer.Width;
|
|
Buffer.Height = GlobalBackbuffer.Height;
|
|
Buffer.Pitch = GlobalBackbuffer.Pitch;
|
|
GameUpdateAndRender(&GameMemory, NewInput, &Buffer, &SoundBuffer);
|
|
SDLFillSoundBuffer(&SoundOutput, BytesToWrite);
|
|
|
|
U64 WorkCounter = SDLGetWallClock();
|
|
F32 WorkSecondsElapsed = SDLGetSecondsElapsed(LastCounter, WorkCounter);
|
|
|
|
F32 SecondsElapsedForFrame = WorkSecondsElapsed;
|
|
if(SecondsElapsedForFrame < TargetSecondsPerFrame) {
|
|
while(SecondsElapsedForFrame < TargetSecondsPerFrame) {
|
|
SecondsElapsedForFrame = SDLGetSecondsElapsed(LastCounter, SDLGetWallClock());
|
|
SDL_Delay((U32)((TargetSecondsPerFrame - SecondsElapsedForFrame) * 1000.0f));
|
|
}
|
|
} else {
|
|
// TODO: Missed frame rate!
|
|
// TODO: Logging.
|
|
}
|
|
|
|
U64 EndCounter = SDLGetWallClock();
|
|
|
|
SDLDisplayBufferInWindow(GlobalBackbuffer, Window, Renderer);
|
|
|
|
F64 MSPerFrame = 1000.0f * SDLGetSecondsElapsed(LastCounter, EndCounter);
|
|
F64 FPS = 0.0f;
|
|
|
|
LastCounter = EndCounter;
|
|
|
|
#if __x86_64__ || __i386__
|
|
U64 EndCycleCount = __rdtsc();
|
|
U64 CyclesElapsed = EndCycleCount - LastCycleCount;
|
|
F64 MCPF = ((F64)CyclesElapsed / (1000.0f * 1000.0f));
|
|
fprintf(stderr, "%.02f ms/f, %.02f/s, %.02f mc/f\n", MSPerFrame, FPS, MCPF);
|
|
LastCycleCount = EndCycleCount;
|
|
#else
|
|
fprintf(stderr, "%.02f ms/f, %.02f/s\n", MSPerFrame, FPS);
|
|
#endif
|
|
|
|
Swap(game_input *, NewInput, OldInput);
|
|
}
|
|
} else {
|
|
// TODO: Failed to allocate Samples and Sound memory . . .
|
|
}
|
|
} else {
|
|
// TODO: This didn't work . . .
|
|
}
|
|
} else {
|
|
// TODO: This didn't work . . .
|
|
}
|
|
|
|
// NOTE: Let the OS clean things up.
|
|
// SDLDeinitControllers(); // NOTE: This, however, might need to be closed? Is there maybe some clean up state that close communicates to the controller?
|
|
// SDL_CloseAudio();
|
|
// SDL_DestroyRenderer(Renderer);
|
|
// SDL_DestroyWindow(Window);
|
|
// SDL_Quit();
|
|
|
|
return 0;
|
|
}
|