internal LRESULT CALLBACK Win32MainWindowCallback(HWND Window, UINT Message, WPARAM WParam, LPARAM LParam) {
LRESULT Result = 0;
switch (Message) {
case WM_DESTROY: {
// TODO: handle this as an error - recreate window?
GlobalRunning = false;
} break;
case WM_CLOSE: {
// TODO: handle this with a message to the user?
GlobalRunning = false;
} break;
case WM_SETCURSOR: {
if (DEBUGGlobalShowCursor) {
Result = DefWindowProcA(Window, Message, WParam, LParam);
}
else {
SetCursor(0);
}
} break;
case WM_ACTIVATEAPP: {
#if 0
if (WParam) {
SetLayeredWindowAttributes(Window, RGB(0, 0, 0), 255, LWA_ALPHA);
}
else {
SetLayeredWindowAttributes(Window, RGB(0, 0, 0), 64, LWA_ALPHA);
}
#endif
} break;
case WM_PAINT: {
PAINTSTRUCT Paint;
HDC DeviceContext = BeginPaint(Window, &Paint);
win32_window_dimension Dimension = Win32GetWindowDimension(Window);
Win32DisplayBufferInWindow(&GlobalBackbuffer, DeviceContext, Dimension.Width, Dimension.Height);
EndPaint(Window, &Paint);
} break;
case WM_SYSKEYDOWN:
case WM_SYSKEYUP:
case WM_KEYDOWN:
case WM_KEYUP: {
Assert(!"Keyboard input came in through a non-dispatch message!");
} break;
default: {
// OutputDebugStringA("default\n");
Result = DefWindowProcA(Window, Message, WParam, LParam);
} break;
}
return(Result);
}
LRESULT CALLBACK
Win32MainWindowCallBack(HWND Window,
UINT Message,
WPARAM WParam,
LPARAM LParam)
{
LRESULT Result = 0;
switch(Message)
{
case WM_SIZE:
{
} break;
case WM_DESTROY:
{
Running = false;
} break;
case WM_CLOSE:
{
Running = false;
} break;
case WM_ACTIVATEAPP:
{
OutputDebugStringA("WM_ACTIVATEAPP\n");
} break;
case WM_PAINT:
{
PAINTSTRUCT Paint;
HDC DeviceContext = BeginPaint(Window, &Paint);
win32_window_dimension Dimension = Win32GetWindowDimension(Window);
Win32DisplayBufferInWindow(DeviceContext, Dimension.Width, Dimension.Height, GlobalBackBuffer);
EndPaint(Window, &Paint);
} break;
default:
{
OutputDebugStringA("default\n");
Result = DefWindowProc(Window, Message, WParam, LParam);
} break;
}
return(Result);
}
int CALLBACK WinMain(HINSTANCE Instance, HINSTANCE PrevInstance, LPSTR CommandLine, int ShowCode)
{
Win32LoadXInput();
WNDCLASSA WindowClass = {};
Win32ResizeDIBSection(&GlobalBackbuffer, 1280, 720);
WindowClass.style = CS_HREDRAW|CS_VREDRAW|CS_OWNDC;
WindowClass.lpfnWndProc = Win32MainWindowCallback;
WindowClass.hInstance = Instance;
// WindowClass.hIcon = ;
WindowClass.lpszClassName = "HandmadeHeroWindowClass";
if (RegisterClassA(&WindowClass))
{
HWND Window = CreateWindowExA(0, WindowClass.lpszClassName, "Handmade Hero", WS_OVERLAPPEDWINDOW|WS_VISIBLE, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, 0, 0, Instance, 0);
if (Window)
{
// NOTE: Since we specified CS_OWNDC, we can just
// get one device context and use it forever because we
// are not sharing it with anyone.
HDC DeviceContext = GetDC(Window);
// NOTE: Graphics test
int XOffset = 0;
int YOffset = 0;
win32_sound_output SoundOutput = {};
// TODO: Make this like sixty seconds?
SoundOutput.SamplesPerSecond = 48000;
SoundOutput.ToneHz = 256;
SoundOutput.ToneVolume = 3000;
SoundOutput.WavePeriod = SoundOutput.SamplesPerSecond / SoundOutput.ToneHz;
SoundOutput.BytesPerSample = sizeof(int16) * 2;
SoundOutput.SecondaryBufferSize = SoundOutput.SamplesPerSecond * SoundOutput.BytesPerSample;
SoundOutput.LatencySampleCount = SoundOutput.SamplesPerSecond / 15;
Win32InitDSound(Window, SoundOutput.SamplesPerSecond, SoundOutput.SecondaryBufferSize);
Win32FillSoundBuffer(&SoundOutput, 0, SoundOutput.LatencySampleCount * SoundOutput.BytesPerSample);
GlobalSecondaryBuffer->Play(0, 0, DSBPLAY_LOOPING);
GlobalRunning = true;
while(GlobalRunning)
{
MSG Message;
while(PeekMessage(&Message, 0, 0, 0, PM_REMOVE))
{
if (Message.message == WM_QUIT)
{
GlobalRunning = false;
}
TranslateMessage(&Message);
DispatchMessageA(&Message);
}
// TODO: Should we poll this more frequently
for (DWORD ControllerIndex = 0; ControllerIndex < XUSER_MAX_COUNT; ++ControllerIndex)
{
XINPUT_STATE ControllerState;
if (XInputGetState(ControllerIndex, &ControllerState) == ERROR_SUCCESS)
{
// NOTE: This controller is plugged in
// TODO: See if ControllerState.dwPacketNumber increments too rapidly
XINPUT_GAMEPAD *Pad = &ControllerState.Gamepad;
bool32 Up = (Pad->wButtons & XINPUT_GAMEPAD_DPAD_UP);
bool32 Down = (Pad->wButtons & XINPUT_GAMEPAD_DPAD_DOWN);
bool32 Left = (Pad->wButtons & XINPUT_GAMEPAD_DPAD_LEFT);
bool32 Right = (Pad->wButtons & XINPUT_GAMEPAD_DPAD_RIGHT);
bool32 Start = (Pad->wButtons & XINPUT_GAMEPAD_START);
bool32 Back = (Pad->wButtons & XINPUT_GAMEPAD_BACK);
bool32 LeftShoulder = (Pad->wButtons & XINPUT_GAMEPAD_LEFT_SHOULDER);
bool32 RightShoulder = (Pad->wButtons & XINPUT_GAMEPAD_RIGHT_SHOULDER);
bool32 AButton = (Pad->wButtons & XINPUT_GAMEPAD_A);
bool32 BButton = (Pad->wButtons & XINPUT_GAMEPAD_B);
bool32 XButton = (Pad->wButtons & XINPUT_GAMEPAD_X);
bool32 YButton = (Pad->wButtons & XINPUT_GAMEPAD_Y);
int16 StickX = Pad->sThumbLX;
int16 StickY = Pad->sThumbLY;
// TODO: We will do deadzone handling later using
// XINPUT_GAMEPAD_LEFT_THUMB_DEADZONE
// XINPUT_GAMEPAD_RIGHT_THUMB_DEADZONE
XOffset += StickX / 4096;
YOffset += StickY / 4096;
SoundOutput.ToneHz = 512 + (int)(256.0f * ((real32)StickY / 30000.0f));
SoundOutput.WavePeriod = SoundOutput.SamplesPerSecond / SoundOutput.ToneHz;
}
else
{
// NOTE: The controller is not available
}
}
RenderWeirdGradient(&GlobalBackbuffer, XOffset, YOffset);
// NOTE: DirectSound output test
DWORD PlayCursor;
DWORD WriteCursor;
if (SUCCEEDED(GlobalSecondaryBuffer->GetCurrentPosition(&PlayCursor, &WriteCursor)))
{
DWORD ByteToLock = (SoundOutput.RunningSampleIndex * SoundOutput.BytesPerSample) % SoundOutput.SecondaryBufferSize;
DWORD TargetCursor = (PlayCursor + (SoundOutput.LatencySampleCount * SoundOutput.BytesPerSample)) % SoundOutput.SecondaryBufferSize;
DWORD BytesToWrite;
// TODO: Change this to using a lower latency offset from the playcursor
// when we actually start having sound effects.
if (ByteToLock > TargetCursor)
{
BytesToWrite = SoundOutput.SecondaryBufferSize - ByteToLock;
BytesToWrite += TargetCursor;
}
else
{
BytesToWrite = TargetCursor - ByteToLock;
}
Win32FillSoundBuffer(&SoundOutput, ByteToLock, BytesToWrite);
}
win32_window_dimension Dimension = Win32GetWindowDimension(Window);
Win32DisplayBufferInWindow(&GlobalBackbuffer, DeviceContext, Dimension.Width, Dimension.Height);
}
}
else
{
// TODO: Logging
}
}
else
{
// TODO: Logging
}
return 0;
}
internal LRESULT CALLBACK Win32MainWindowCallback(HWND Window, UINT Message, WPARAM WParam, LPARAM LParam)
{
LRESULT Result = 0;
switch(Message)
{
case WM_CLOSE:
{
// TODO: Handle this with a message to the user?
GlobalRunning = false;
} break;
case WM_ACTIVATEAPP:
{
OutputDebugStringA("WM_ACTIVATEAPP\n");
} break;
case WM_DESTROY:
{
// TODO: Handle this as an error - recreate window?
GlobalRunning = false;
} break;
case WM_SYSKEYDOWN:
case WM_SYSKEYUP:
case WM_KEYDOWN:
case WM_KEYUP:
{
uint32 VKCode = WParam;
bool32 WasDown = ((LParam & (1 << 30)) != 0);
bool32 IsDown = ((LParam & (1 << 31)) == 0);
if (WasDown != IsDown)
{
if (VKCode == 'W')
{
}
else if (VKCode == 'A')
{
}
else if (VKCode == 'S')
{
}
else if (VKCode == 'D')
{
}
else if (VKCode == 'Q')
{
}
else if (VKCode == 'E')
{
}
else if (VKCode == VK_UP)
{
}
else if (VKCode == VK_LEFT)
{
}
else if (VKCode == VK_DOWN)
{
}
else if (VKCode == VK_RIGHT)
{
}
else if (VKCode == VK_ESCAPE)
{
OutputDebugStringA("ESCAPE: ");
if (IsDown)
{
OutputDebugStringA("IsDown ");
}
if (WasDown)
{
OutputDebugStringA("WasDown");
}
OutputDebugStringA("\n");
}
else if (VKCode == VK_SPACE)
{
}
}
bool32 AltKeyWasDown = (LParam & (1 << 29));
if ((VKCode == VK_F4) && AltKeyWasDown)
{
GlobalRunning = false;
}
} break;
case WM_PAINT:
{
PAINTSTRUCT Paint;
HDC DeviceContext = BeginPaint(Window, &Paint);
win32_window_dimension Dimension = Win32GetWindowDimension(Window);
Win32DisplayBufferInWindow(&GlobalBackbuffer, DeviceContext,
Dimension.Width, Dimension.Height);
EndPaint(Window, &Paint);
} break;
default:
{
Result = DefWindowProcA(Window, Message, WParam, LParam);
} break;
}
return Result;
}
LRESULT CALLBACK MainWindowCallback(_In_ HWND _HWnd,
_In_ UINT _UMsg,
_In_ WPARAM _WParam,
_In_ LPARAM _LParam)
{
LRESULT result = 0;
switch (_UMsg)
{
case WM_CLOSE:
{
// TODO(jungyoun.la): Handle this with a message to the user?
GlobalRunning = false;
} break;
case WM_DESTROY:
{
// TODO(jungyoun.la): Handle this as an error - recreate window?
GlobalRunning = false;
} break;
case WM_SYSKEYDOWN:
case WM_SYSKEYUP:
case WM_KEYDOWN:
case WM_KEYUP:
{
uint32 vkCode = _WParam;
bool wasDown = ((_LParam & (1 << 30)) != 0);
bool isDown = ((_LParam & (1 << 31)) == 0);
if (wasDown != isDown)
{
if (vkCode == 'W')
{
}
else if (vkCode == 'A')
{
}
else if (vkCode == 'S')
{
}
else if (vkCode == 'D')
{
}
else if (vkCode == 'Q')
{
}
else if (vkCode == 'E')
{
}
else if (vkCode == VK_UP)
{
}
else if (vkCode == VK_LEFT)
{
}
else if (vkCode == VK_DOWN)
{
}
else if (vkCode == VK_RIGHT)
{
}
else if (vkCode == VK_ESCAPE)
{
OutputDebugStringA("ESCAPE: ");
if (isDown)
{
OutputDebugStringA("IsDown ");
}
if (wasDown)
{
OutputDebugStringA("WasDown");
}
OutputDebugStringA("\n");
}
else if (vkCode == VK_SPACE)
{
}
}
bool altKeyWasDown = ((_LParam & (1 << 29)) != 0);
if ((vkCode == VK_F4) && altKeyWasDown)
{
GlobalRunning = false;
}
} break;
case WM_ACTIVATEAPP:
{
OutputDebugStringA("WM_ACTIVATEAPP\n");
} break;
case WM_PAINT:
{
PAINTSTRUCT paint;
HDC deviceContext = BeginPaint(_HWnd, &paint);
{
// 아래 두 코드가 없어도 제대로 실행된다. 매 프레임 그리기 때문에
// 그러나 BeginPaint(), EndPaint()까지 모든 라인을 실행하지 않으면 화면에 그려지는것이 아무것도 없고 먹통이 되어버린다 왜일까??
win32_window_dimension dimension = Win32GetWindowDimension(_HWnd);
Win32DisplayBufferInWindow(&GlobalBackbuffer, deviceContext, dimension.Width, dimension.Height);
}
EndPaint(_HWnd, &paint);
} break;
default:
{
//OutputDebugStringA("default\n");
result = DefWindowProc(_HWnd, _UMsg, _WParam, _LParam);
} break;
}
return result;
}
int CALLBACK WinMain(
HINSTANCE Instance,
HINSTANCE PrevInstance,
LPSTR CommandLine,
int ShowCode
) {
Win32LoadXInput();
WNDCLASS WindowClass = {};
WindowClass.style = CS_HREDRAW|CS_VREDRAW;
WindowClass.lpfnWndProc = Win32MainWindowCallback;
WindowClass.hInstance = Instance;
//WindowClass.hIcon;
WindowClass.lpszClassName = "HandmadeHeroWindowClass";
if (RegisterClass(&WindowClass))
{
HWND Window = CreateWindowEx(
0,
WindowClass.lpszClassName,
"Handmade Hero",
WS_OVERLAPPEDWINDOW|WS_VISIBLE,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
0,
0,
Instance,
0);
if (Window) {
GlobalRunning = true;
int XOffset = 0;
int YOffset = 0;
int Hz = 256;
int SquareWaveCounter = 0;
int BytesPerSample = sizeof(int16) * 2;
int SquareWavePeriod = 48000/Hz;
Win32InitDSound(Window, 48000, 48000*sizeof(int16)*2);
while (GlobalRunning)
{
MSG Message;
while (PeekMessage(&Message, 0, 0, 0, PM_REMOVE))
{
if (Message.message == WM_QUIT) {
GlobalRunning = false;
}
TranslateMessage(&Message);
DispatchMessage(&Message);
}
for (DWORD ControllerIndex = 0; ControllerIndex < XUSER_MAX_COUNT; ControllerIndex++) {
XINPUT_STATE ControllerState;
if (XInputGetState(ControllerIndex, &ControllerState) == ERROR_SUCCESS) {
//haz controller!
XINPUT_GAMEPAD *Pad = &ControllerState.Gamepad;
bool Up = (Pad->wButtons & XINPUT_GAMEPAD_DPAD_UP);
bool Down = (Pad->wButtons & XINPUT_GAMEPAD_DPAD_DOWN);
bool Left = (Pad->wButtons & XINPUT_GAMEPAD_DPAD_LEFT);
bool Right = (Pad->wButtons & XINPUT_GAMEPAD_DPAD_RIGHT);
bool Start = (Pad->wButtons & XINPUT_GAMEPAD_START);
bool Back = (Pad->wButtons & XINPUT_GAMEPAD_BACK);
bool LeftShoulder = (Pad->wButtons & XINPUT_GAMEPAD_LEFT_SHOULDER);
bool RightShoulder = (Pad->wButtons & XINPUT_GAMEPAD_RIGHT_SHOULDER);
bool AButton = (Pad->wButtons & XINPUT_GAMEPAD_A);
bool BButton = (Pad->wButtons & XINPUT_GAMEPAD_B);
bool XButton = (Pad->wButtons & XINPUT_GAMEPAD_X);
bool YButton = (Pad->wButtons & XINPUT_GAMEPAD_Y);
int16 StickX = Pad->sThumbLX;
int16 StickY = Pad->sThumbLY;
if (AButton) {
YOffset += 2;
XINPUT_VIBRATION Vibration;
Vibration.wLeftMotorSpeed = 60000;
Vibration.wRightMotorSpeed = 60000;
XInputSetState(0, &Vibration);
}
else {
XINPUT_VIBRATION Vibration;
Vibration.wLeftMotorSpeed = 0;
Vibration.wRightMotorSpeed = 0;
XInputSetState(0, &Vibration);
}
}
else {
//Controller isn't there
}
}
RenderWeirdGradient(&GlobalBackBuffer, XOffset, YOffset);
DWORD PlayCursor;
DWORD WriteCursor;
if (SUCCEEDED(GlobalSecondaryBuffer->GetCurrentPosition(&PlayCursor,&WriteCursor))) {
DWORD WritePointer = ;
DWORD BytesToWrite = ;
VOID *Region1;
DWORD Region1Size;
VOID *Region2;
DWORD Region2Size;
if (SUCCEEDED(GlobalSecondaryBuffer->Lock(WritePointer,
BytesToWrite,
&Region1, &Region1Size,
&Region2, &Region2Size,
0))) {
// TODO(Justin): Assert Region1Size/Region2Size is valid
int16 *SampleOut = (int16 *)Region1;
DWORD Region1SampleCount = Region1Size / BytesPerSample;
DWORD Region2SampleCount = Region2Size / BytesPerSample;
for (DWORD SampleIndex = 0;
SampleIndex < Region1SampleCount;
++SampleIndex) {
if (SquareWaveCounter) {
SquareWaveCounter = SquareWavePeriod;
}
int16 SampleValue = (SquareWaveCounter > (SquareWavePeriod / 2)) ? 16000 : -16000;
*SampleOut++ = SampleValue;
*SampleOut++ = SampleValue;
--SquareWaveCounter;
}
for (DWORD SampleIndex = 0;
SampleIndex < Region2SampleCount;
++SampleIndex) {
if (SquareWaveCounter) {
SquareWaveCounter = SquareWavePeriod;
}
int16 SampleValue = (SquareWaveCounter >(SquareWavePeriod / 2)) ? 16000 : -16000;
*SampleOut++ = SampleValue;
*SampleOut++ = SampleValue;
--SquareWaveCounter;
}
}
}
HDC DeviceContext = GetDC(Window);
win32_window_dimension Dimension = win32GetWindowDimension(Window);
Win32DisplayBufferInWindow(&GlobalBackBuffer, DeviceContext, Dimension.Width, Dimension.Height,
0, 0, Dimension.Width, Dimension.Height);
ReleaseDC(Window, DeviceContext);
++XOffset;
//YOffset += 2;
}
}
LRESULT CALLBACK
Win32MainWindowCallback(
HWND Window,
UINT Message,
WPARAM WParam,
LPARAM LParam
) {
LRESULT Result = 0;
switch(Message) {
case WM_SIZE: {
//win32_window_dimension Dimension = win32GetWindowDimension(Window);
Win32ResizeDIBSection(&GlobalBackBuffer, 1280, 720);
break;
}
case WM_DESTROY:
case WM_CLOSE: {
GlobalRunning = false;
break;
}
case WM_SYSKEYDOWN:
case WM_SYSKEYUP:
case WM_KEYDOWN:
case WM_KEYUP: {
uint32 VKCode = WParam;
bool WasDown = ((LParam & (1 << 30)) != 0);
bool IsDown = ((LParam & (1 << 31)) == 0);
if (VKCode == 'W') {
}
else if (VKCode == 'A') {
}
else if (VKCode == 'S') {
}
else if (VKCode == 'D') {
}
else if (VKCode == 'Q') {
}
else if (VKCode == 'E') {
}
else if (VKCode == VK_UP) {
}
else if (VKCode == VK_LEFT) {
}
else if (VKCode == VK_DOWN) {
}
else if (VKCode == VK_RIGHT) {
}
else if(VKCode == VK_ESCAPE) {
}
else if (VKCode == VK_SPACE) {
}
if ((VKCode == VK_F4) && (LParam & (1 << 29))) {
GlobalRunning = false;
}
break;
}
case WM_PAINT: {
PAINTSTRUCT Paint;
HDC DeviceContext = BeginPaint(Window, &Paint);
int x = Paint.rcPaint.left;
int y = Paint.rcPaint.top;
int Height = Paint.rcPaint.bottom - Paint.rcPaint.top;
int Width = Paint.rcPaint.right - Paint.rcPaint.left;
win32_window_dimension Dimension = win32GetWindowDimension(Window);
Win32DisplayBufferInWindow(&GlobalBackBuffer, DeviceContext, Dimension.Width, Dimension.Height,
x, y, Width, Height);
EndPaint(Window, &Paint);
break;
}
case WM_ACTIVATEAPP: {
OutputDebugStringA("WM_ACTIVATEAPP \n");
break;
}
default: {
//OutputDebugStringA("default \n");
Result = DefWindowProc(Window, Message, WParam, LParam);
break;
}
}
return Result;
}
int CALLBACK WinMain(HINSTANCE Instance, HINSTANCE PrevInstance, LPSTR CommandLine, int ShowCode) {
win32_state Win32State = {};
LARGE_INTEGER PerfCounterFrequencyResult;
QueryPerformanceFrequency(&PerfCounterFrequencyResult);
GlobalPerfCounterFrequency = PerfCounterFrequencyResult.QuadPart;
Win32GetEXEFileName(&Win32State);
char SourceGameCodeDLLFullPath[WIN32_STATE_FILE_NAME_COUNT];
Win32BuildEXEPathFileName(&Win32State, "handmade.dll", sizeof(SourceGameCodeDLLFullPath), SourceGameCodeDLLFullPath);
char TempGameCodeDLLFullPath[WIN32_STATE_FILE_NAME_COUNT];
Win32BuildEXEPathFileName(&Win32State, "handmade_temp.dll", sizeof(TempGameCodeDLLFullPath), TempGameCodeDLLFullPath);
char GameCodeLockFullPath[WIN32_STATE_FILE_NAME_COUNT];
Win32BuildEXEPathFileName(&Win32State, "lock.tmp", sizeof(GameCodeLockFullPath), GameCodeLockFullPath);
// NOTE: setting windows scheduler granularity for our sleep() call
UINT DesiredSchedulerMS = 1;
bool32 SleepIsGranular = (timeBeginPeriod(DesiredSchedulerMS) == TIMERR_NOERROR);
Win32LoadXInput();
Win32ResizeDIBSection(&GlobalBackbuffer, 960, 540);
#if HANDMADE_INTERNAL
DEBUGGlobalShowCursor = true;
#endif
WNDCLASSEXA WindowClass = {};
WindowClass.style = CS_VREDRAW | CS_HREDRAW;
WindowClass.cbSize = sizeof(WNDCLASSEXA);
WindowClass.lpfnWndProc = Win32MainWindowCallback;
WindowClass.hInstance = Instance;
WindowClass.hCursor = LoadCursor(0, IDC_ARROW);
// WindowClass.hIcon;
WindowClass.lpszClassName = "HandmadeHeroWindowClass";
if (RegisterClassExA(&WindowClass)) {
// WS_EX_TOPMOST|WS_EX_LAYERED
HWND Window = CreateWindowExA(0, WindowClass.lpszClassName, "Handmade Hero", WS_OVERLAPPEDWINDOW | WS_VISIBLE, CW_USEDEFAULT, CW_USEDEFAULT, 996, 600, 0, 0, Instance, 0);
if (Window) {
// TODO: reliably query this from windows
int MonitorRefreshHz = 60;
HDC RefreshDC = GetDC(Window);
int Win32RefreshRate = GetDeviceCaps(RefreshDC, VREFRESH);
ReleaseDC(Window, RefreshDC);
if (Win32RefreshRate > 1) {
MonitorRefreshHz = Win32RefreshRate;
if (MonitorRefreshHz == 59) {
MonitorRefreshHz = 60;
}
}
real32 GameUpdateHz = MonitorRefreshHz / 2.0f;
real32 TargetSecondsPerFrame = 1.0f / GameUpdateHz;
// NOTE: sound test
win32_sound_output SoundOutput = {};
SoundOutput.SamplesPerSecond = 48000;
SoundOutput.BytesPerSample = sizeof(int16) * 2;
SoundOutput.SecondaryBufferSize = SoundOutput.SamplesPerSecond * SoundOutput.BytesPerSample;
// TODO: compute this variance and see what the lowest reasonable value is
SoundOutput.SafetyBytes = (int)((real32)SoundOutput.SamplesPerSecond * (real32)SoundOutput.BytesPerSample / GameUpdateHz / 3.0f);
Win32InitDSound(Window, SoundOutput.SamplesPerSecond, SoundOutput.SecondaryBufferSize);
Win32ClearSoundBuffer(&SoundOutput);
GlobalSecondaryBuffer->Play(0, 0, DSBPLAY_LOOPING);
GlobalRunning = true;
// TODO: pool with bitmap virtualalloc
int16 *Samples = (int16 *)VirtualAlloc(0, SoundOutput.SecondaryBufferSize, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
#if HANDMADE_INTERNAL
LPVOID BaseAddress = (LPVOID)Terabytes(2);
#else
LPVOID BaseAddress = 0;
#endif
game_memory GameMemory = {};
GameMemory.PermanentStorageSize = Megabytes(64);
GameMemory.TransientStorageSize = Gigabytes(1);
GameMemory.DEBUGPlatformFreeFileMemory = DEBUGPlatformFreeFileMemory;
GameMemory.DEBUGPlatformReadEntireFile = DEBUGPlatformReadEntireFile;
GameMemory.DEBUGPlatformWriteEntireFile = DEBUGPlatformWriteEntireFile;
// TODO: handle various memory footprints using system metrics
// TODO: use MEM_LARGE_PAGES
Win32State.TotalSize = GameMemory.PermanentStorageSize + GameMemory.TransientStorageSize;
Win32State.GameMemoryBlock = VirtualAlloc(BaseAddress, (size_t)Win32State.TotalSize, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
GameMemory.PermanentStorage = Win32State.GameMemoryBlock;
GameMemory.TransientStorage = (uint8 *)GameMemory.PermanentStorage + GameMemory.PermanentStorageSize;
for (int ReplayIndex = 1; ReplayIndex < ArrayCount(Win32State.ReplayBuffers); ++ReplayIndex) {
// TODO: recording system still takes too long on record start
win32_replay_buffer *ReplayBuffer = &Win32State.ReplayBuffers[ReplayIndex];
Win32GetInputFileLocation(&Win32State, false, ReplayIndex, sizeof(ReplayBuffer->FileName), ReplayBuffer->FileName);
ReplayBuffer->FileHandle = CreateFileA(ReplayBuffer->FileName, GENERIC_READ | GENERIC_WRITE, 0, 0, CREATE_ALWAYS, 0, 0);
LARGE_INTEGER MaxSize;
MaxSize.QuadPart = Win32State.TotalSize;
ReplayBuffer->MemoryMap = CreateFileMapping(ReplayBuffer->FileHandle, 0, PAGE_READWRITE, MaxSize.HighPart, MaxSize.LowPart, 0);
ReplayBuffer->MemoryBlock = MapViewOfFile(ReplayBuffer->MemoryMap, FILE_MAP_ALL_ACCESS, 0, 0, (size_t)Win32State.TotalSize);
if (!ReplayBuffer->MemoryBlock) {
// TODO: diagnostic
}
}
if (Samples && GameMemory.PermanentStorage && GameMemory.TransientStorage) {
game_input Input[2] = {};
game_input *NewInput = &Input[0];
game_input *OldInput = &Input[1];
LARGE_INTEGER LastCounter = Win32GetWallClock();
LARGE_INTEGER FlipWallClock = Win32GetWallClock();
int DebugTimeMarkerIndex = 0;
win32_debug_time_marker DebugTimeMarkers[30] = { 0 };
// TODO: handle startup specially
bool32 SoundIsValid = false;
DWORD AudioLatencyBytes = 0;
real32 AudioLatencySeconds = 0;
win32_game_code Game = Win32LoadGameCode(SourceGameCodeDLLFullPath, TempGameCodeDLLFullPath, GameCodeLockFullPath);
uint64 LastCycleCount = __rdtsc();
while (GlobalRunning) {
NewInput->FrameTimeDelta = TargetSecondsPerFrame;
FILETIME NewDLLWriteTime = Win32GetLastWriteTime(SourceGameCodeDLLFullPath);
if (CompareFileTime(&NewDLLWriteTime, &Game.DLLLastWriteTime) != 0) {
Win32UnloadGameCode(&Game);
Game = Win32LoadGameCode(SourceGameCodeDLLFullPath, TempGameCodeDLLFullPath, GameCodeLockFullPath);
}
// TODO: zeroing macro
// TODO: we cant zero everything as the up/down state will be wrong
game_controller_input *OldKeyboardController = GetController(OldInput, 0);
game_controller_input *NewKeyboardController = GetController(NewInput, 0);
*NewKeyboardController = {};
NewKeyboardController->IsConnected = true;
for (int ButtonIndex = 0; ButtonIndex < ArrayCount(NewKeyboardController->Buttons); ++ButtonIndex) {
NewKeyboardController->Buttons[ButtonIndex].EndedDown = OldKeyboardController->Buttons[ButtonIndex].EndedDown;
}
Win32ProcessPendingMessages(&Win32State, NewKeyboardController);
if (!GlobalPause) {
POINT MousePoint;
GetCursorPos(&MousePoint);
ScreenToClient(Window, &MousePoint);
NewInput->MouseX = MousePoint.x;
NewInput->MouseY = MousePoint.y;
NewInput->MouseZ = 0; // TODO: support mousewheel?
Win32ProcessKeyboardMessage(&NewInput->MouseButtons[0], GetKeyState(VK_LBUTTON) & (1 << 15));
Win32ProcessKeyboardMessage(&NewInput->MouseButtons[1], GetKeyState(VK_MBUTTON) & (1 << 15));
Win32ProcessKeyboardMessage(&NewInput->MouseButtons[2], GetKeyState(VK_RBUTTON) & (1 << 15));
Win32ProcessKeyboardMessage(&NewInput->MouseButtons[3], GetKeyState(VK_XBUTTON1) & (1 << 15));
Win32ProcessKeyboardMessage(&NewInput->MouseButtons[4], GetKeyState(VK_XBUTTON2) & (1 << 15));
// TODO: should we poll this more frequently
// TODO: dont poll disconnected controllers to prevent xinput frame rate impact
DWORD MaxControllerCount = XUSER_MAX_COUNT;
if (MaxControllerCount > (ArrayCount(NewInput->Controllers) - 1)) {
MaxControllerCount = (ArrayCount(NewInput->Controllers) - 1);
}
for (DWORD ControllerIndex = 0; ControllerIndex < MaxControllerCount; ++ControllerIndex) {
DWORD OurControllerIndex = ControllerIndex + 1;
game_controller_input *OldController = GetController(OldInput, OurControllerIndex);
game_controller_input *NewController = GetController(NewInput, OurControllerIndex);
XINPUT_STATE ControllerState;
if (XInputGetState(ControllerIndex, &ControllerState) == ERROR_SUCCESS) {
NewController->IsConnected = true;
NewController->IsAnalog = OldController->IsAnalog;
// TODO: See if ControllerState.dwPacketNumber increments too rapidly
XINPUT_GAMEPAD *Pad = &ControllerState.Gamepad;
// TODO: currently handling a square deadzone, check if it is circular
NewController->StickAverageX = Win32ProcessXInputStickValue(Pad->sThumbLX, XINPUT_GAMEPAD_LEFT_THUMB_DEADZONE);
NewController->StickAverageY = Win32ProcessXInputStickValue(Pad->sThumbLY, XINPUT_GAMEPAD_LEFT_THUMB_DEADZONE);
if ((NewController->StickAverageX != 0.0f) || (NewController->StickAverageY != 0.0f)) {
NewController->IsAnalog = true;
}
if (Pad->wButtons & XINPUT_GAMEPAD_DPAD_UP) {
NewController->StickAverageY = 1.0f;
NewController->IsAnalog = false;
}
if (Pad->wButtons & XINPUT_GAMEPAD_DPAD_DOWN) {
NewController->StickAverageY = -1.0f;
NewController->IsAnalog = false;
}
if (Pad->wButtons & XINPUT_GAMEPAD_DPAD_LEFT) {
NewController->StickAverageX = -1.0f;
NewController->IsAnalog = false;
}
if (Pad->wButtons & XINPUT_GAMEPAD_DPAD_RIGHT) {
NewController->StickAverageX = 1.0f;
NewController->IsAnalog = false;
}
real32 Threshold = 0.5f;
Win32ProcessXInputDigitalButton((NewController->StickAverageX < -Threshold) ? 1 : 0, &OldController->MoveLeft, 1, &NewController->MoveLeft);
Win32ProcessXInputDigitalButton((NewController->StickAverageX > Threshold) ? 1 : 0, &OldController->MoveRight, 1, &NewController->MoveRight);
Win32ProcessXInputDigitalButton((NewController->StickAverageY < -Threshold) ? 1 : 0, &OldController->MoveDown, 1, &NewController->MoveDown);
Win32ProcessXInputDigitalButton((NewController->StickAverageY > Threshold) ? 1 : 0, &OldController->MoveUp, 1, &NewController->MoveUp);
Win32ProcessXInputDigitalButton(Pad->wButtons, &OldController->ActionDown, XINPUT_GAMEPAD_A, &NewController->ActionDown);
Win32ProcessXInputDigitalButton(Pad->wButtons, &OldController->ActionRight, XINPUT_GAMEPAD_B, &NewController->ActionRight);
Win32ProcessXInputDigitalButton(Pad->wButtons, &OldController->ActionLeft, XINPUT_GAMEPAD_X, &NewController->ActionLeft);
Win32ProcessXInputDigitalButton(Pad->wButtons, &OldController->ActionUp, XINPUT_GAMEPAD_Y, &NewController->ActionUp);
Win32ProcessXInputDigitalButton(Pad->wButtons, &OldController->LeftShoulder, XINPUT_GAMEPAD_LEFT_SHOULDER, &NewController->LeftShoulder);
Win32ProcessXInputDigitalButton(Pad->wButtons, &OldController->RightShoulder, XINPUT_GAMEPAD_RIGHT_SHOULDER, &NewController->RightShoulder);
Win32ProcessXInputDigitalButton(Pad->wButtons, &OldController->Start, XINPUT_GAMEPAD_START, &NewController->Start);
Win32ProcessXInputDigitalButton(Pad->wButtons, &OldController->Back, XINPUT_GAMEPAD_BACK, &NewController->Back);
}
else {
// NOTE: the controller is not available
NewController->IsConnected = false;
}
}
thread_context Thread = {};
game_offscreen_buffer Buffer = {};
Buffer.Memory = GlobalBackbuffer.Memory;
Buffer.Width = GlobalBackbuffer.Width;
Buffer.Height = GlobalBackbuffer.Height;
Buffer.Pitch = GlobalBackbuffer.Pitch;
Buffer.BytesPerPixel = GlobalBackbuffer.BytesPerPixel;
if (Win32State.InputRecordingIndex) {
Win32RecordInput(&Win32State, NewInput);
}
if (Win32State.InputPlaybackIndex) {
Win32PlaybackInput(&Win32State, NewInput);
}
if (Game.UpdateAndRender) {
Game.UpdateAndRender(&Thread, &GameMemory, NewInput, &Buffer);
}
LARGE_INTEGER AudioWallClock = Win32GetWallClock();
real32 FromBeginToAudioSeconds = Win32GetSecondsElapsed(FlipWallClock, AudioWallClock);
DWORD PlayCursor;
DWORD WriteCursor;
if (GlobalSecondaryBuffer->GetCurrentPosition(&PlayCursor, &WriteCursor) == DS_OK) {
/* NOTE: Sound output explanation
We define a safety value that is the number of samples we think our game update loop can vary by.
When we wake up to write audio we look at the play cursor position and forecast where we think it will be on the next frame boundary.
If the write cursor is before that by at least our safety value, the target fill position is the frame boundary plus one frame. This gives us perfect audio sync if the audio latency is low enough.
If the write cursor is after that safety value then we assume we can't sync the audio so we write one frames worth of audio plus the safety values worth of samples.
*/
if (!SoundIsValid) {
SoundOutput.RunningSampleIndex = WriteCursor / SoundOutput.BytesPerSample;
SoundIsValid = true;
}
DWORD ByteToLock = (SoundOutput.RunningSampleIndex * SoundOutput.BytesPerSample) % SoundOutput.SecondaryBufferSize;
DWORD ExpectedSoundBytesPerFrame = (int)((real32)(SoundOutput.SamplesPerSecond * SoundOutput.BytesPerSample) / GameUpdateHz);
real32 SecondsLeftUntilFlip = TargetSecondsPerFrame - FromBeginToAudioSeconds;
DWORD ExpectedBytesUntilFlip = (DWORD)((SecondsLeftUntilFlip / TargetSecondsPerFrame) * (real32)ExpectedSoundBytesPerFrame);
DWORD ExpectedFrameBoundaryByte = PlayCursor + ExpectedBytesUntilFlip;
DWORD SafeWriteCursor = WriteCursor;
if (SafeWriteCursor < PlayCursor) {
SafeWriteCursor += SoundOutput.SecondaryBufferSize;
}
Assert(SafeWriteCursor >= PlayCursor);
SafeWriteCursor += SoundOutput.SafetyBytes;
bool32 AudioCardIsLowLatency = (SafeWriteCursor < ExpectedFrameBoundaryByte);
DWORD TargetCursor = 0;
if (AudioCardIsLowLatency) {
TargetCursor = ExpectedFrameBoundaryByte + ExpectedSoundBytesPerFrame;
}
else {
TargetCursor = WriteCursor + ExpectedSoundBytesPerFrame + SoundOutput.SafetyBytes;
}
TargetCursor = TargetCursor % SoundOutput.SecondaryBufferSize;
DWORD BytesToWrite = 0;
if (ByteToLock > TargetCursor) {
BytesToWrite = SoundOutput.SecondaryBufferSize - ByteToLock;
BytesToWrite += TargetCursor;
}
else {
BytesToWrite = TargetCursor - ByteToLock;
}
game_sound_output_buffer SoundBuffer = {};
SoundBuffer.SamplesPerSecond = SoundOutput.SamplesPerSecond;
SoundBuffer.SampleCount = BytesToWrite / SoundOutput.BytesPerSample;
SoundBuffer.Samples = Samples;
if (Game.GetSoundSamples) {
Game.GetSoundSamples(&Thread, &GameMemory, &SoundBuffer);
}
#if HANDMADE_INTERNAL
win32_debug_time_marker *Marker = &DebugTimeMarkers[DebugTimeMarkerIndex];
Marker->OutputPlayCursor = PlayCursor;
Marker->OutputWriteCursor = WriteCursor;
Marker->OutputLocation = ByteToLock;
Marker->OutputByteCount = BytesToWrite;
Marker->ExpectedFlipPlayCursor = ExpectedFrameBoundaryByte;
DWORD UnwrappedWriteCursor = WriteCursor;
if (UnwrappedWriteCursor < PlayCursor) {
UnwrappedWriteCursor += SoundOutput.SecondaryBufferSize;
}
AudioLatencyBytes = UnwrappedWriteCursor - PlayCursor;
AudioLatencySeconds = ((real32)AudioLatencyBytes / (real32)SoundOutput.BytesPerSample) / (real32)SoundOutput.SamplesPerSecond;
#if 0
char DebugSoundBuffer[256];
sprintf_s(DebugSoundBuffer, "BTL:%u TC:%u BTW:%u - PC:%u WC:%u DELTA:%u (%fs)\n", ByteToLock, TargetCursor, BytesToWrite, PlayCursor, WriteCursor, AudioLatencyBytes, AudioLatencySeconds);
OutputDebugStringA(DebugSoundBuffer);
#endif
#endif
Win32FillSoundBuffer(&SoundOutput, ByteToLock, BytesToWrite, &SoundBuffer);
}
else {
SoundIsValid = false;
}
LARGE_INTEGER WorkCounter = Win32GetWallClock();
real32 WorkSecondsElapsed = Win32GetSecondsElapsed(LastCounter, WorkCounter);
// TODO: not tested yet!
real32 SecondsElapsedForFrame = WorkSecondsElapsed;
if (SecondsElapsedForFrame < TargetSecondsPerFrame) {
if (SleepIsGranular) {
DWORD SleepMS = (DWORD)(1000.0f * (TargetSecondsPerFrame - SecondsElapsedForFrame));
if (SleepMS > 0) {
Sleep(SleepMS);
}
}
real32 TestSecondsElapsedForFrame = Win32GetSecondsElapsed(LastCounter, Win32GetWallClock());
if (TestSecondsElapsedForFrame < TargetSecondsPerFrame) {
// TODO: log missed sleep here
}
while (SecondsElapsedForFrame < TargetSecondsPerFrame) {
SecondsElapsedForFrame = Win32GetSecondsElapsed(LastCounter, Win32GetWallClock());
}
}
else {
// TODO: missed frame rate
// TODO: logging
}
LARGE_INTEGER EndCounter = Win32GetWallClock();
real32 MSPerFrame = 1000.0f * Win32GetSecondsElapsed(LastCounter, EndCounter);
LastCounter = EndCounter;
win32_window_dimension Dimension = Win32GetWindowDimension(Window);
HDC BufferDC = GetDC(Window);
Win32DisplayBufferInWindow(&GlobalBackbuffer, BufferDC, Dimension.Width, Dimension.Height);
ReleaseDC(Window, BufferDC);
FlipWallClock = Win32GetWallClock();
#if HANDMADE_INTERNAL
DWORD DebugPlayCursor;
DWORD DebugWriteCursor;
if (GlobalSecondaryBuffer->GetCurrentPosition(&DebugPlayCursor, &DebugWriteCursor) == DS_OK) {
Assert(DebugTimeMarkerIndex < ArrayCount(DebugTimeMarkers));
win32_debug_time_marker *Marker = &DebugTimeMarkers[DebugTimeMarkerIndex];
Marker->FlipPlayCursor = DebugPlayCursor;
Marker->FlipWriteCursor = DebugWriteCursor;
}
#endif
game_input *Temp = NewInput;
NewInput = OldInput;
OldInput = Temp;
// TODO: should these be cleared?
#if 0
uint64 EndCycleCount = __rdtsc();
uint64 CyclesElapsed = EndCycleCount - LastCycleCount;
LastCycleCount = EndCycleCount;
// real32 FPS = (real32)GlobalPerfCounterFrequency / (real32)CounterElapsed;
real32 FPS = 0.0f;
real32 MCPF = (real32)CyclesElapsed / (1000.0f * 1000.0f);
char DebugPerformanceBuffer[256];
sprintf_s(DebugPerformanceBuffer, "%0.02fmspf, %0.02ffps, %0.02fmcpf\n", MSPerFrame, FPS, MCPF);
OutputDebugStringA(DebugPerformanceBuffer);
#endif
#if HANDMADE_INTERNAL
++DebugTimeMarkerIndex;
if (DebugTimeMarkerIndex == ArrayCount(DebugTimeMarkers)) {
DebugTimeMarkerIndex = 0;
}
#endif
}
}
}
else {
// TODO: logging
}
}
else {
// TODO: logging
}
}
else {
// TODO: logging
}
return(0);
}
int CALLBACK
WinMain(HINSTANCE Instance,
HINSTANCE PrevInstance,
LPSTR CommandLine,
int ShowCode)
{
// Empty window -> 0 to each field
WNDCLASS WindowClass = {};
Win32ResizeDIBSection(&GlobalBackBuffer, 1280, 720);
WindowClass.style = CS_HREDRAW|CS_VREDRAW;
WindowClass.lpfnWndProc = Win32MainWindowCallBack;
WindowClass.hInstance = Instance;
WindowClass.lpszClassName = "HandmadeHeroWindowClass";
// Register window class
if(RegisterClass(&WindowClass))
{
HWND Window =
CreateWindowEx(
0,
WindowClass.lpszClassName,
"Handmade Hero",
WS_OVERLAPPEDWINDOW|WS_VISIBLE,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
0,
0,
Instance,
0);
if(Window)
{
int XOffset = 0;
int YOffset = 0;
// Start message loop
Running = true;
while(Running)
{
MSG Message;
while (PeekMessage(&Message, 0, 0, 0, PM_REMOVE))
{
if (Message.message == WM_QUIT)
{
Running = false;
}
TranslateMessage(&Message);
DispatchMessage(&Message);
}
RenderWeirdGradient(GlobalBackBuffer, XOffset, YOffset);
HDC DeviceContext = GetDC(Window);
win32_window_dimension Dimension = Win32GetWindowDimension(Window);
Win32DisplayBufferInWindow(DeviceContext,
Dimension.Width, Dimension.Height,
GlobalBackBuffer);
ReleaseDC(Window, DeviceContext);
++XOffset;
YOffset += 2;
}
}
else
{
// Fails
}
}
else
{
// Fails
}
return(0);
}
int CALLBACK
WinMain(HINSTANCE Instance,
HINSTANCE PrevInstance,
LPSTR CommandLine,
int ShowCode)
{
Win32LoadXInput();
WNDCLASSA WindowClass = {};
Win32ResizeDIBSection(&GlobalBackbuffer, 1280, 720);
WindowClass.style = CS_HREDRAW|CS_VREDRAW|CS_OWNDC;
WindowClass.lpfnWndProc = Win32MainWindowCallback;
WindowClass.hInstance = Instance;
// WindowClass.hIcon;
WindowClass.lpszClassName = "HandmadeHeroWindowClass";
if(RegisterClassA(&WindowClass))
{
HWND Window =
CreateWindowExA(
0,
WindowClass.lpszClassName,
"Handmade Hero",
WS_OVERLAPPEDWINDOW|WS_VISIBLE,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
0,
0,
Instance,
0);
if(Window)
{
// NOTE(casey): Since we specified CS_OWNDC, we can just
// get one device context and use it forever because we
// are not sharing it with anyone.
HDC DeviceContext = GetDC(Window);
int XOffset = 0;
int YOffset = 0;
GlobalRunning = true;
while(GlobalRunning)
{
MSG Message;
while(PeekMessage(&Message, 0, 0, 0, PM_REMOVE))
{
if(Message.message == WM_QUIT)
{
GlobalRunning = false;
}
TranslateMessage(&Message);
DispatchMessageA(&Message);
}
// TODO(casey): Should we poll this more frequently
for (DWORD ControllerIndex = 0;
ControllerIndex < XUSER_MAX_COUNT;
++ControllerIndex)
{
XINPUT_STATE ControllerState;
if(XInputGetState(ControllerIndex, &ControllerState) == ERROR_SUCCESS)
{
// NOTE(casey): This controller is plugged in
// TODO(casey): See if ControllerState.dwPacketNumber increments too rapidly
XINPUT_GAMEPAD *Pad = &ControllerState.Gamepad;
bool Up = (Pad->wButtons & XINPUT_GAMEPAD_DPAD_UP);
bool Down = (Pad->wButtons & XINPUT_GAMEPAD_DPAD_DOWN);
bool Left = (Pad->wButtons & XINPUT_GAMEPAD_DPAD_LEFT);
bool Right = (Pad->wButtons & XINPUT_GAMEPAD_DPAD_RIGHT);
bool Start = (Pad->wButtons & XINPUT_GAMEPAD_START);
bool Back = (Pad->wButtons & XINPUT_GAMEPAD_BACK);
bool LeftShoulder = (Pad->wButtons & XINPUT_GAMEPAD_LEFT_SHOULDER);
bool RightShoulder = (Pad->wButtons & XINPUT_GAMEPAD_RIGHT_SHOULDER);
bool AButton = (Pad->wButtons & XINPUT_GAMEPAD_A);
bool BButton = (Pad->wButtons & XINPUT_GAMEPAD_B);
bool XButton = (Pad->wButtons & XINPUT_GAMEPAD_X);
bool YButton = (Pad->wButtons & XINPUT_GAMEPAD_Y);
int16 StickX = Pad->sThumbLX;
int16 StickY = Pad->sThumbLY;
XOffset += StickX >> 12;
YOffset += StickY >> 12;
}
else
{
// NOTE(casey): The controller is not available
}
}
RenderWeirdGradient(&GlobalBackbuffer, XOffset, YOffset);
win32_window_dimension Dimension = Win32GetWindowDimension(Window);
Win32DisplayBufferInWindow(&GlobalBackbuffer, DeviceContext,
Dimension.Width, Dimension.Height);
}
int CALLBACK
WinMain(HINSTANCE Instance,
HINSTANCE PrevInstance,
LPSTR CommandLine,
int ShowCode)
{
Wind32LoadXInput();
WNDCLASSA WindowClass = {};
Win32ResizeDIBSection(&GlobalBackbuffer, 1280, 720);
WindowClass.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
WindowClass.lpfnWndProc = Win32MainWindowCallback;
WindowClass.hInstance = Instance;
// WindowClass.hIcon;
WindowClass.lpszClassName = "HandmadeHeroWindowClass";
if(RegisterClassA(&WindowClass))
{
HWND Window =
CreateWindowExA(
0,
WindowClass.lpszClassName,
"Handmade Hero",
WS_OVERLAPPEDWINDOW | WS_VISIBLE,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
0,
0,
Instance,
0);
if(Window)
{
// NOTE: Since we specified CS_OWNDC, we can just
// create it once since we aren't sharing it with anybody
HDC DeviceContext = GetDC(Window);
// NOTE: Graphics test
int XOffset = 0;
int YOffset = 0;
// NOTE: Sound test
int SamplesPerSecond = 48000;
int ToneHz = 256;
int16 ToneVolume = 3000;
uint32 RunningSampleIndex = 0;
int SquareWavePeriod = SamplesPerSecond / ToneHz;
int HalfSquareWavePeriod = SquareWavePeriod / 2;
int BytesPerSample = sizeof(int16) * 2;
int SecondaryBufferSize = SamplesPerSecond * BytesPerSample;
Win32InitDSound(Window, SamplesPerSecond, SecondaryBufferSize);
GlobalSecondaryBuffer->Play(0, 0, DSBPLAY_LOOPING);
GlobalRunning = true;
while(GlobalRunning)
{
MSG Message;
while(PeekMessage(&Message, 0, 0, 0, PM_REMOVE))
{
if(Message.message == WM_QUIT)
{
GlobalRunning = false;
}
TranslateMessage(&Message);
DispatchMessageA(&Message);
}
// TODO: Should we poll this more frequently?
for(DWORD ControllerIndex = 0;
ControllerIndex < XUSER_MAX_COUNT;
++ControllerIndex)
{
XINPUT_STATE ControllerState;
if(XInputGetState(ControllerIndex, &ControllerState) == ERROR_SUCCESS)
{
// NOTE: This controller is plugged in
// TODO: See if controllerstate.dwpacketnumber increments too rapidly
XINPUT_GAMEPAD *Pad = &ControllerState.Gamepad;
bool Up = (Pad->wButtons & XINPUT_GAMEPAD_DPAD_UP);
bool Down = (Pad->wButtons & XINPUT_GAMEPAD_DPAD_DOWN);
bool Left = (Pad->wButtons & XINPUT_GAMEPAD_DPAD_LEFT);
bool Right = (Pad->wButtons & XINPUT_GAMEPAD_DPAD_RIGHT);
bool Start = (Pad->wButtons & XINPUT_GAMEPAD_START);
bool Back = (Pad->wButtons & XINPUT_GAMEPAD_BACK);
bool LeftShoulder = (Pad->wButtons & XINPUT_GAMEPAD_LEFT_SHOULDER);
bool RightShoulder = (Pad->wButtons & XINPUT_GAMEPAD_RIGHT_SHOULDER);
bool AButton = (Pad->wButtons & XINPUT_GAMEPAD_A);
bool BButton = (Pad->wButtons & XINPUT_GAMEPAD_B);
bool XButton = (Pad->wButtons & XINPUT_GAMEPAD_X);
bool YButton = (Pad->wButtons & XINPUT_GAMEPAD_Y);
int16 stickX = Pad->sThumbLX;
int16 stickY = Pad->sThumbLY;
XOffset += stickX >> 12;
YOffset += stickY >> 12;
}
else
{
// NOTE: The controller is not available
}
}
RenderWeirdGradient(&GlobalBackbuffer, XOffset, YOffset);
// NOTE DirectSound output test
DWORD PlayCursor;
DWORD WriteCursor;
if(SUCCEEDED(GlobalSecondaryBuffer->GetCurrentPosition(&PlayCursor, &WriteCursor)))
{
DWORD ByteToLock = RunningSampleIndex * BytesPerSample % SecondaryBufferSize;
DWORD BytesToWrite;
if(ByteToLock == PlayCursor)
{
BytesToWrite = SecondaryBufferSize;
}
else if(ByteToLock > PlayCursor)
{
BytesToWrite = SecondaryBufferSize - ByteToLock;
BytesToWrite += PlayCursor;
}
else
{
BytesToWrite = PlayCursor - ByteToLock;
}
// TODO: More strenuous test
VOID *Region1;
DWORD Region1Size;
VOID *Region2;
DWORD Region2Size;
if(SUCCEEDED(GlobalSecondaryBuffer->Lock(ByteToLock, BytesToWrite,
&Region1, &Region1Size,
&Region2, &Region2Size,
0)))
{
// TODO: assert that Region1SizeRegion2Size is valid
int16 *SampleOut = (int16 *)Region1;
DWORD Region1SampleCount = Region1Size / BytesPerSample;
for(DWORD SampleIndex = 0;
SampleIndex < Region1SampleCount;
++SampleIndex)
{
int16 SampleValue = ((RunningSampleIndex++ / HalfSquareWavePeriod) % 2) ? ToneVolume : -ToneVolume;
*SampleOut++ = SampleValue;
*SampleOut++ = SampleValue;
}
DWORD Region2SampleCount = Region2Size / BytesPerSample;
SampleOut = (int16 *)Region2;
for(DWORD SampleIndex = 0;
SampleIndex < Region2SampleCount;
++SampleIndex)
{
int16 SampleValue = ((RunningSampleIndex++ / HalfSquareWavePeriod) % 2) ? ToneVolume : -ToneVolume;
*SampleOut++ = SampleValue;
*SampleOut++ = SampleValue;
}
GlobalSecondaryBuffer->Unlock(Region1, Region1Size, Region2, Region2Size);
}
}
win32_window_dimension Dimension = Win32GetWindowDimension(Window);
Win32DisplayBufferInWindow(&GlobalBackbuffer, DeviceContext,
Dimension.Width, Dimension.Height);
}
