/* read and scan a file for definitions */
void PicocPlatformScanFile(Picoc *pc, const char *FileName)
{
char *SourceStr = PlatformReadFile(pc, FileName);
/* ignore "#!/path/to/picoc" .. by replacing the "#!" with "//" */
if (SourceStr != NULL && SourceStr[0] == '#' && SourceStr[1] == '!')
{
SourceStr[0] = '/';
SourceStr[1] = '/';
}
PicocParse(pc, FileName, SourceStr, strlen(SourceStr), TRUE, FALSE, TRUE, TRUE);
}
loaded_image
GLLoadBMP(char *FilePath)
{
loaded_image Result = {};
read_file_result FileResult = PlatformReadFile(FilePath);
uint32 *BitmapPixels = {};
if (FileResult.ContentsSize != 0)
{
bmp_header *Header = (bmp_header *)FileResult.Contents;
Result.Width = Header->Width;
Result.Height = Header->Height;
// NOTE this number offset here is pulled from my ass. The offset in the image doesn't seem to work.
BitmapPixels = ((uint32 *)FileResult.Contents + 35);
}
else
{
// Something went wrong with loading the bmp
// NOTE will eventually want to just show a warning. But don't crash the game.
Assert(0);
}
uint32 *Source = (uint32 *)BitmapPixels;
for (uint32 PixelIndex = 0;
PixelIndex < (Result.Width * Result.Height);
++PixelIndex)
{
uint8 *Pixel = (uint8 *)Source;
uint8 Bit2 = *Pixel++; // A
uint8 Bit3 = *Pixel++; // R
uint8 Bit0 = *Pixel++; // G
uint8 Bit1 = *Pixel++; // B
*Source++ = (Bit0 << 24) | (Bit1 << 16) | (Bit2 << 8) | (Bit3 << 0);
}
glGenTextures(1, &Result.GLTexture);
glBindTexture(GL_TEXTURE_2D, Result.GLTexture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA,
Result.Width, Result.Height,
0, GL_RGBA, GL_UNSIGNED_BYTE, BitmapPixels);
return (Result);
}
/* read and scan a file for definitions */
void PicocPlatformScanFile(Picoc *pc, const char *FileName)
{
char *SourceStr = PlatformReadFile(pc, FileName);
/* ignore "#!/path/to/picoc" .. by replacing the "#!" with "//" */
if (SourceStr != NULL && SourceStr[0] == '#' && SourceStr[1] == '!')
{
SourceStr[0] = '/';
SourceStr[1] = '/';
}
PicocParse(pc, FileName, SourceStr, strlen(SourceStr), TRUE, FALSE, FALSE, TRUE);
free(SourceStr); /* cleanup manually (not within PicoParse): doesn't work otherwise if own allocator is used */
}
/* read and scan a file for definitions */
void PicocPlatformScanFile(const char *FileName)
{
char *SourceStr = PlatformReadFile(FileName);
PicocParse(FileName, SourceStr, strlen(SourceStr), TRUE, FALSE, TRUE);
}
loaded_sound
LoadWave(char *FilePath)
{
loaded_sound Result = {};
//NOTE this is the loading the wave file code. Maybe all this should be pulled into the game layer
read_file_result WaveResult = PlatformReadFile(FilePath);
wave_header *WaveHeader = (wave_header *)WaveResult.Contents;
Assert(WaveHeader->RiffID == WAVE_ChunkID_RIFF);
Assert(WaveHeader->WaveID == WAVE_ChunkID_WAVE);
uint32 ChannelCount = 0;
uint32 SampleDataSize = 0;
int16 *SampleData = 0;
for (riff_iterator Iter = ParseChunkAt(WaveHeader + 1, (uint8 *)(WaveHeader + 1) + WaveHeader->Size - 4);
IsValid(Iter);
Iter = NextChunk(Iter))
{
switch (GetType(Iter))
{
case WAVE_ChunkID_fmt:
{
wave_fmt *fmt = (wave_fmt *)GetChunkData(Iter);
// NOTE Assert that this file is in a supported format
// Using PCM format;
Assert(fmt->Format == 1);
Assert(fmt->NumSamplesPerSecond == 48000);
Assert(fmt->BitsPerSample == 16);
Assert(fmt->BlockAlign == (sizeof(int16) * fmt->NumberOfChannels));
ChannelCount = fmt->NumberOfChannels;
} break;
case WAVE_ChunkID_data:
{
SampleData = (int16 *)GetChunkData(Iter);
SampleDataSize = GetChunkDataSize(Iter);
} break;
}
}
Result.ChannelCount = ChannelCount;
Result.SampleCount = SampleDataSize / (ChannelCount * sizeof(int16));
if (ChannelCount == 1)
{
Result.Samples[0] = SampleData;
Result.Samples[1] = 0;
}
else if (ChannelCount == 2)
{
Result.Samples[0] = SampleData;
Result.Samples[1] = SampleData + Result.SampleCount;
for (uint32 SampleIndex = 0;
SampleIndex < Result.SampleCount;
++SampleIndex)
{
int16 Source = SampleData[2 * SampleIndex];
SampleData[2 * SampleIndex] = SampleData[SampleIndex];
SampleData[SampleIndex] = Source;
}
}
else
{
Assert(!"Invalid Channel Count");
}
// TODO this only loads the left channel. MAYBE load the right channel too
Result.ChannelCount = 1;
return (Result);
}
void
MakeBitmapCodepoint(char Letter, platform_read_file *ReadFile, game_state *GameState)
{
read_file_result FontFile = PlatformReadFile("../Assets/Gotham-Medium.ttf");
Assert(FontFile.Contents > 0);
int Width, Height, XOffset, YOffset;
stbtt_fontinfo FontInfo;
stbtt_InitFont(&FontInfo, (uint8 *)FontFile.Contents, stbtt_GetFontOffsetForIndex((uint8 *)FontFile.Contents, 0));
uint8 *MonoBitmap = stbtt_GetCodepointBitmap(&FontInfo, 0, stbtt_ScaleForPixelHeight(&FontInfo, (float)GlobalFontRenderSize),
Letter, &Width, &Height, &XOffset, &YOffset);
font_codepoint *NextCodepoint = &GameState->AlphabetBitmaps[GameState->AlphabetBitmapsCount];
GameState->AlphabetBitmapsCount++;
NextCodepoint->BaselineFactor = YOffset;
NextCodepoint->Bitmap.Width = Width;
NextCodepoint->Bitmap.Height = Height;
NextCodepoint->Bitmap.GLTexture = (GLuint)VirtualAlloc(0, sizeof(*MonoBitmap), MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
SIZE_T BitmapSize = sizeof(uint32) * Width * Height;
void *ConvertedBitmap = malloc(BitmapSize);
uint32 Pitch = Width * sizeof(uint32);
uint8 *Source = (uint8 *)MonoBitmap;
uint8 *DestRow = (uint8 *)ConvertedBitmap + ((Height - 1) * Pitch);
for (uint32 Y = 0;
Y < (uint32)Height;
++Y)
{
uint32 *Dest = (uint32 *)DestRow;
for (uint32 X = 0;
X < (uint32)Width;
++X)
{
uint8 MonoAlpha = *Source++;
uint8 Bit2 = MonoAlpha; // A
uint8 Bit3 = MonoAlpha; // R
uint8 Bit0 = MonoAlpha; // G
uint8 Bit1 = MonoAlpha; // B
*Dest++ = ((Bit0 << 24) | (Bit1 << 16) | (Bit2 << 8) | (Bit3 << 0));
}
DestRow -= Pitch;
}
//TODO pull this out into a separate GL function to keep gl code separate from game code.
glGenTextures(1, &NextCodepoint->Bitmap.GLTexture);
glBindTexture(GL_TEXTURE_2D, NextCodepoint->Bitmap.GLTexture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, Width, Height,
0, GL_RGBA, GL_UNSIGNED_BYTE, ConvertedBitmap);
VirtualFree(ConvertedBitmap, BitmapSize, MEM_RELEASE);
stbtt_FreeBitmap(MonoBitmap, 0);
}
