internal void
GameUpdateAndRender(game_offscreen_buffer *Buffer, int BlueOffset, int GreenOffset,
game_sound_output_buffer *SoundBuffer, int ToneHz)
{
// TODO: Allow sample offsets here for more robust platform options
GameOutputSound(SoundBuffer, ToneHz);
RenderWeirdGradient(Buffer, BlueOffset, GreenOffset);
}
internal void GameUpdateAndRender(game_memory *Memory, game_input *Input,
game_offscreen_buffer *Buffer)
{
Assert(sizeof(game_state) <= Memory->PermanentStorageSize);
game_state *GameState = (game_state *) Memory->PermanentStorage;
if (!Memory->IsInitialized)
{
char *Filename = __FILE__;
debug_read_file_result File = DEBUGPlatformReadEntireFile(Filename);
if (File.Contents)
{
DEBUGPlatformWriteEntireFile("test.out", File.ContentsSize, File.Contents);
DEBUGPlatformFreeFileMemory(File.Contents);
}
GameState->ToneHz = 512;
Memory->IsInitialized = true;
}
for (int ControllerIndex = 0; ControllerIndex < ArrayCount(Input->Controllers); ++ControllerIndex)
{
game_controller_input *Controller = GetController(Input, ControllerIndex);
if (Controller->IsAnalog)
{
// Use analog movement tuning.
GameState->BlueOffset += (int) (4.0f * Controller->StickAverageX);
GameState->ToneHz = 512 + (int) (128.0f * Controller->StickAverageY);
}
else
{
// Use digital movement tuning.
if (Controller->MoveLeft.EndedDown)
{
GameState->BlueOffset -= 1;
}
if (Controller->MoveRight.EndedDown)
{
GameState->BlueOffset += 1;
}
}
// Input.AButtonEndedDown;
// Input.AButtonHalfTransitionCount;
if (Controller->ActionDown.EndedDown)
{
GameState->GreenOffset += 1;
}
}
RenderWeirdGradient(Buffer, GameState->BlueOffset, GameState->GreenOffset);
}
internal void
GameUpdateAndRender(
game_offscreen_buffer* Buffer, int BlueOffset, int GreenOffset,
game_sound_output_buffer* SoundBuffer, int ToneHz)
{
// allow sample offsets here
GameOutputSound(SoundBuffer, ToneHz);
RenderWeirdGradient(Buffer, BlueOffset, GreenOffset);
}
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;
}
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;
}
}
internal void GameUpdateAndRender(
game_memory *Memory,
game_input *Input,
game_offscreen_buffer *Buffer,
game_sound_output_buffer *SoundBuffer
)
{
Assert(sizeof(game_state) <= Memory->PermanentStorageSize);
game_state *GameState = (game_state *)Memory->PermanentStorage;
if (Memory->IsInitialized)
{
char *Filename = "test.bmp";
debug_read_file_result Result = DEBUGPlatformReadEntireFile(Filename);
if (Result.Contents)
{
DEBUGPlatformFreeFileMemory(Result.Contents);
}
GameState->ToneHz = 256;
GameState->GreenOffset = 0;
GameState->BlueOffset = 0;
Memory->IsInitialized = true;
}
for (int ControllerIndex = 0; ControllerIndex < ArrayCount(Input->Controllers); ControllerIndex++)
{
game_controller_input *Controller = GetController(Input, ControllerIndex);
if (Controller->IsAnalog)
{
// Analog
GameState->ToneHz = 256 + (int)(128.0f * (Controller->StickAverageX));
GameState->BlueOffset += (int)(4.0f * (Controller->StickAverageY));
}
else
{
// Digital
if (Controller->MoveLeft.EndedDown)
{
GameState->BlueOffset--;
}
else if (Controller->MoveRight.EndedDown)
{
GameState->BlueOffset++;
}
}
if (Controller->ActionDown.EndedDown)
{
GameState->GreenOffset += 1;
}
else if (Controller->ActionUp.EndedDown)
{
GameState->GreenOffset -= 1;
}
}
GameOutputSound(SoundBuffer);
RenderWeirdGradient(Buffer, GameState->BlueOffset, GameState->GreenOffset);
}
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)
{
WNDCLASS WindowClass = {};
WindowClass.style = CS_OWNDC|CS_HREDRAW|CS_VREDRAW;
WindowClass.lpfnWndProc = Win32MainWindowCallback;
WindowClass.hInstance = Instance;
//WindowClass.icon
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)
{
int XOffset = 0;
int YOffset = 0;
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(XOffset, YOffset);
HDC DeviceContext = GetDC(Window);
RECT ClientRect;
GetClientRect(Window, &ClientRect);
int WindowWidth = ClientRect.right - ClientRect.left;
int WindowHeight = ClientRect.bottom - ClientRect.top;
Win32UpdateWindow(DeviceContext, &ClientRect, 0,0, WindowWidth,WindowHeight);
ReleaseDC(Window, DeviceContext);
++XOffset;
}
}
else
{//logging
}
}
else
{
}
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);
}
