AstralTransRocketries/ClassiCube
1
0
Fork 0
mirror of https://github.com/ClassiCube/ClassiCube.git synced 2025-09-16 02:56:09 -04:00
Code Issues Packages Projects Releases Wiki Activity

move Atlas/Atlas1D vars to exported api

Browse Source
This commit is contained in:
UnknownShadow200 2019-03-13 23:30:26 +11:00
parent 97a3d1bd65
commit c706fc161e
17 changed files with 141 additions and 140 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
src/Block.c
View File

@ -355,7 +355,7 @@ void Block_RecalculateAllSpriteBB(void) {
} }
} }
static float Block_GetSpriteBB_MinX(int size, int tileX, int tileY, Bitmap* bmp) { static float Block_GetSpriteBB_MinX(int size, int tileX, int tileY, const Bitmap* bmp) {
BitmapCol* row; BitmapCol* row;
int x, y; int x, y;
@ -368,7 +368,7 @@ static float Block_GetSpriteBB_MinX(int size, int tileX, int tileY, Bitmap* bmp)
return 1.0f; return 1.0f;
} }
static float Block_GetSpriteBB_MinY(int size, int tileX, int tileY, Bitmap* bmp) { static float Block_GetSpriteBB_MinY(int size, int tileX, int tileY, const Bitmap* bmp) {
BitmapCol* row; BitmapCol* row;
int x, y; int x, y;
@ -381,7 +381,7 @@ static float Block_GetSpriteBB_MinY(int size, int tileX, int tileY, Bitmap* bmp)
return 1.0f; return 1.0f;
} }
static float Block_GetSpriteBB_MaxX(int size, int tileX, int tileY, Bitmap* bmp) { static float Block_GetSpriteBB_MaxX(int size, int tileX, int tileY, const Bitmap* bmp) {
BitmapCol* row; BitmapCol* row;
int x, y; int x, y;
@ -394,7 +394,7 @@ static float Block_GetSpriteBB_MaxX(int size, int tileX, int tileY, Bitmap* bmp)
return 0.0f; return 0.0f;
} }
static float Block_GetSpriteBB_MaxY(int size, int tileX, int tileY, Bitmap* bmp) { static float Block_GetSpriteBB_MaxY(int size, int tileX, int tileY, const Bitmap* bmp) {
BitmapCol* row; BitmapCol* row;
int x, y; int x, y;
@ -408,8 +408,8 @@ static float Block_GetSpriteBB_MaxY(int size, int tileX, int tileY, Bitmap* bmp)
} }
void Block_RecalculateBB(BlockID block) { void Block_RecalculateBB(BlockID block) {
Bitmap* bmp = &Atlas_Bitmap; Bitmap* bmp = &Atlas2D.Bitmap;
int tileSize = Atlas_TileSize; int tileSize = Atlas2D.TileSize;
TextureLoc texLoc = Block_Tex(block, FACE_XMAX); TextureLoc texLoc = Block_Tex(block, FACE_XMAX);
int x = Atlas2D_TileX(texLoc), y = Atlas2D_TileY(texLoc); int x = Atlas2D_TileX(texLoc), y = Atlas2D_TileY(texLoc);
@ -417,7 +417,7 @@ void Block_RecalculateBB(BlockID block) {
float minX = 0, minY = 0, maxX = 1, maxY = 1; float minX = 0, minY = 0, maxX = 1, maxY = 1;
Vector3 minRaw, maxRaw; Vector3 minRaw, maxRaw;
if (y < Atlas_RowsCount) { if (y < Atlas2D.RowsCount) {
minX = Block_GetSpriteBB_MinX(tileSize, x, y, bmp); minX = Block_GetSpriteBB_MinX(tileSize, x, y, bmp);
minY = Block_GetSpriteBB_MinY(tileSize, x, y, bmp); minY = Block_GetSpriteBB_MinY(tileSize, x, y, bmp);
maxX = Block_GetSpriteBB_MaxX(tileSize, x, y, bmp); maxX = Block_GetSpriteBB_MaxX(tileSize, x, y, bmp);

40
src/Builder.c
View File

@ -478,8 +478,8 @@ static void Builder_DrawSprite(int count) {
#define s_u1 0.0f #define s_u1 0.0f
#define s_u2 UV2_Scale #define s_u2 UV2_Scale
loc = Block_Tex(Builder_Block, FACE_XMAX); loc = Block_Tex(Builder_Block, FACE_XMAX);
v1 = Atlas1D_RowId(loc) * Atlas1D_InvTileSize; v1 = Atlas1D_RowId(loc) * Atlas1D.InvTileSize;
v2 = v1 + Atlas1D_InvTileSize * UV2_Scale; v2 = v1 + Atlas1D.InvTileSize * UV2_Scale;
offsetType = Blocks.SpriteOffset[Builder_Block]; offsetType = Blocks.SpriteOffset[Builder_Block];
if (offsetType >= 6 && offsetType <= 7) { if (offsetType >= 6 && offsetType <= 7) {
@ -926,11 +926,11 @@ static int Adv_StretchZ(int countIndex, int x, int y, int z, int chunkIndex, Blo
static void Adv_DrawXMin(int count) { static void Adv_DrawXMin(int count) {
TextureLoc texLoc = Block_Tex(Builder_Block, FACE_XMIN); TextureLoc texLoc = Block_Tex(Builder_Block, FACE_XMIN);
float vOrigin = Atlas1D_RowId(texLoc) * Atlas1D_InvTileSize; float vOrigin = Atlas1D_RowId(texLoc) * Atlas1D.InvTileSize;
float u1 = adv_minBB.Z, u2 = (count - 1) + adv_maxBB.Z * UV2_Scale; float u1 = adv_minBB.Z, u2 = (count - 1) + adv_maxBB.Z * UV2_Scale;
float v1 = vOrigin + adv_maxBB.Y * Atlas1D_InvTileSize; float v1 = vOrigin + adv_maxBB.Y * Atlas1D.InvTileSize;
float v2 = vOrigin + adv_minBB.Y * Atlas1D_InvTileSize * UV2_Scale; float v2 = vOrigin + adv_minBB.Y * Atlas1D.InvTileSize * UV2_Scale;
struct Builder1DPart* part = &Builder_Parts[adv_baseOffset + Atlas1D_Index(texLoc)]; struct Builder1DPart* part = &Builder_Parts[adv_baseOffset + Atlas1D_Index(texLoc)];
int F = adv_bitFlags[Builder_ChunkIndex]; int F = adv_bitFlags[Builder_ChunkIndex];
@ -967,11 +967,11 @@ static void Adv_DrawXMin(int count) {
static void Adv_DrawXMax(int count) { static void Adv_DrawXMax(int count) {
TextureLoc texLoc = Block_Tex(Builder_Block, FACE_XMAX); TextureLoc texLoc = Block_Tex(Builder_Block, FACE_XMAX);
float vOrigin = Atlas1D_RowId(texLoc) * Atlas1D_InvTileSize; float vOrigin = Atlas1D_RowId(texLoc) * Atlas1D.InvTileSize;
float u1 = (count - adv_minBB.Z), u2 = (1 - adv_maxBB.Z) * UV2_Scale; float u1 = (count - adv_minBB.Z), u2 = (1 - adv_maxBB.Z) * UV2_Scale;
float v1 = vOrigin + adv_maxBB.Y * Atlas1D_InvTileSize; float v1 = vOrigin + adv_maxBB.Y * Atlas1D.InvTileSize;
float v2 = vOrigin + adv_minBB.Y * Atlas1D_InvTileSize * UV2_Scale; float v2 = vOrigin + adv_minBB.Y * Atlas1D.InvTileSize * UV2_Scale;
struct Builder1DPart* part = &Builder_Parts[adv_baseOffset + Atlas1D_Index(texLoc)]; struct Builder1DPart* part = &Builder_Parts[adv_baseOffset + Atlas1D_Index(texLoc)];
int F = adv_bitFlags[Builder_ChunkIndex]; int F = adv_bitFlags[Builder_ChunkIndex];
@ -1008,11 +1008,11 @@ static void Adv_DrawXMax(int count) {
static void Adv_DrawZMin(int count) { static void Adv_DrawZMin(int count) {
TextureLoc texLoc = Block_Tex(Builder_Block, FACE_ZMIN); TextureLoc texLoc = Block_Tex(Builder_Block, FACE_ZMIN);
float vOrigin = Atlas1D_RowId(texLoc) * Atlas1D_InvTileSize; float vOrigin = Atlas1D_RowId(texLoc) * Atlas1D.InvTileSize;
float u1 = (count - adv_minBB.X), u2 = (1 - adv_maxBB.X) * UV2_Scale; float u1 = (count - adv_minBB.X), u2 = (1 - adv_maxBB.X) * UV2_Scale;
float v1 = vOrigin + adv_maxBB.Y * Atlas1D_InvTileSize; float v1 = vOrigin + adv_maxBB.Y * Atlas1D.InvTileSize;
float v2 = vOrigin + adv_minBB.Y * Atlas1D_InvTileSize * UV2_Scale; float v2 = vOrigin + adv_minBB.Y * Atlas1D.InvTileSize * UV2_Scale;
struct Builder1DPart* part = &Builder_Parts[adv_baseOffset + Atlas1D_Index(texLoc)]; struct Builder1DPart* part = &Builder_Parts[adv_baseOffset + Atlas1D_Index(texLoc)];
int F = adv_bitFlags[Builder_ChunkIndex]; int F = adv_bitFlags[Builder_ChunkIndex];
@ -1049,11 +1049,11 @@ static void Adv_DrawZMin(int count) {
static void Adv_DrawZMax(int count) { static void Adv_DrawZMax(int count) {
TextureLoc texLoc = Block_Tex(Builder_Block, FACE_ZMAX); TextureLoc texLoc = Block_Tex(Builder_Block, FACE_ZMAX);
float vOrigin = Atlas1D_RowId(texLoc) * Atlas1D_InvTileSize; float vOrigin = Atlas1D_RowId(texLoc) * Atlas1D.InvTileSize;
float u1 = adv_minBB.X, u2 = (count - 1) + adv_maxBB.X * UV2_Scale; float u1 = adv_minBB.X, u2 = (count - 1) + adv_maxBB.X * UV2_Scale;
float v1 = vOrigin + adv_maxBB.Y * Atlas1D_InvTileSize; float v1 = vOrigin + adv_maxBB.Y * Atlas1D.InvTileSize;
float v2 = vOrigin + adv_minBB.Y * Atlas1D_InvTileSize * UV2_Scale; float v2 = vOrigin + adv_minBB.Y * Atlas1D.InvTileSize * UV2_Scale;
struct Builder1DPart* part = &Builder_Parts[adv_baseOffset + Atlas1D_Index(texLoc)]; struct Builder1DPart* part = &Builder_Parts[adv_baseOffset + Atlas1D_Index(texLoc)];
int F = adv_bitFlags[Builder_ChunkIndex]; int F = adv_bitFlags[Builder_ChunkIndex];
@ -1090,11 +1090,11 @@ static void Adv_DrawZMax(int count) {
static void Adv_DrawYMin(int count) { static void Adv_DrawYMin(int count) {
TextureLoc texLoc = Block_Tex(Builder_Block, FACE_YMIN); TextureLoc texLoc = Block_Tex(Builder_Block, FACE_YMIN);
float vOrigin = Atlas1D_RowId(texLoc) * Atlas1D_InvTileSize; float vOrigin = Atlas1D_RowId(texLoc) * Atlas1D.InvTileSize;
float u1 = adv_minBB.X, u2 = (count - 1) + adv_maxBB.X * UV2_Scale; float u1 = adv_minBB.X, u2 = (count - 1) + adv_maxBB.X * UV2_Scale;
float v1 = vOrigin + adv_minBB.Z * Atlas1D_InvTileSize; float v1 = vOrigin + adv_minBB.Z * Atlas1D.InvTileSize;
float v2 = vOrigin + adv_maxBB.Z * Atlas1D_InvTileSize * UV2_Scale; float v2 = vOrigin + adv_maxBB.Z * Atlas1D.InvTileSize * UV2_Scale;
struct Builder1DPart* part = &Builder_Parts[adv_baseOffset + Atlas1D_Index(texLoc)]; struct Builder1DPart* part = &Builder_Parts[adv_baseOffset + Atlas1D_Index(texLoc)];
int F = adv_bitFlags[Builder_ChunkIndex]; int F = adv_bitFlags[Builder_ChunkIndex];
@ -1131,11 +1131,11 @@ static void Adv_DrawYMin(int count) {
static void Adv_DrawYMax(int count) { static void Adv_DrawYMax(int count) {
TextureLoc texLoc = Block_Tex(Builder_Block, FACE_YMAX); TextureLoc texLoc = Block_Tex(Builder_Block, FACE_YMAX);
float vOrigin = Atlas1D_RowId(texLoc) * Atlas1D_InvTileSize; float vOrigin = Atlas1D_RowId(texLoc) * Atlas1D.InvTileSize;
float u1 = adv_minBB.X, u2 = (count - 1) + adv_maxBB.X * UV2_Scale; float u1 = adv_minBB.X, u2 = (count - 1) + adv_maxBB.X * UV2_Scale;
float v1 = vOrigin + adv_minBB.Z * Atlas1D_InvTileSize; float v1 = vOrigin + adv_minBB.Z * Atlas1D.InvTileSize;
float v2 = vOrigin + adv_maxBB.Z * Atlas1D_InvTileSize * UV2_Scale; float v2 = vOrigin + adv_maxBB.Z * Atlas1D.InvTileSize * UV2_Scale;
struct Builder1DPart* part = &Builder_Parts[adv_baseOffset + Atlas1D_Index(texLoc)]; struct Builder1DPart* part = &Builder_Parts[adv_baseOffset + Atlas1D_Index(texLoc)];
int F = adv_bitFlags[Builder_ChunkIndex]; int F = adv_bitFlags[Builder_ChunkIndex];

36
src/Drawer.c
View File

@ -15,12 +15,12 @@ col.B = (uint8_t)(col.B * Drawer.TintCol.B / 255);\
void Drawer_XMin(int count, PackedCol col, TextureLoc texLoc, VertexP3fT2fC4b** vertices) { void Drawer_XMin(int count, PackedCol col, TextureLoc texLoc, VertexP3fT2fC4b** vertices) {
VertexP3fT2fC4b* ptr = *vertices; VertexP3fT2fC4b v; VertexP3fT2fC4b* ptr = *vertices; VertexP3fT2fC4b v;
float vOrigin = Atlas1D_RowId(texLoc) * Atlas1D_InvTileSize; float vOrigin = Atlas1D_RowId(texLoc) * Atlas1D.InvTileSize;
float u1 = Drawer.MinBB.Z; float u1 = Drawer.MinBB.Z;
float u2 = (count - 1) + Drawer.MaxBB.Z * UV2_Scale; float u2 = (count - 1) + Drawer.MaxBB.Z * UV2_Scale;
float v1 = vOrigin + Drawer.MaxBB.Y * Atlas1D_InvTileSize; float v1 = vOrigin + Drawer.MaxBB.Y * Atlas1D.InvTileSize;
float v2 = vOrigin + Drawer.MinBB.Y * Atlas1D_InvTileSize * UV2_Scale; float v2 = vOrigin + Drawer.MinBB.Y * Atlas1D.InvTileSize * UV2_Scale;
ApplyTint; ApplyTint;
v.X = Drawer.X1; v.Col = col; v.X = Drawer.X1; v.Col = col;
@ -34,12 +34,12 @@ void Drawer_XMin(int count, PackedCol col, TextureLoc texLoc, VertexP3fT2fC4b**
void Drawer_XMax(int count, PackedCol col, TextureLoc texLoc, VertexP3fT2fC4b** vertices) { void Drawer_XMax(int count, PackedCol col, TextureLoc texLoc, VertexP3fT2fC4b** vertices) {
VertexP3fT2fC4b* ptr = *vertices; VertexP3fT2fC4b v; VertexP3fT2fC4b* ptr = *vertices; VertexP3fT2fC4b v;
float vOrigin = Atlas1D_RowId(texLoc) * Atlas1D_InvTileSize; float vOrigin = Atlas1D_RowId(texLoc) * Atlas1D.InvTileSize;
float u1 = (count - Drawer.MinBB.Z); float u1 = (count - Drawer.MinBB.Z);
float u2 = (1 - Drawer.MaxBB.Z) * UV2_Scale; float u2 = (1 - Drawer.MaxBB.Z) * UV2_Scale;
float v1 = vOrigin + Drawer.MaxBB.Y * Atlas1D_InvTileSize; float v1 = vOrigin + Drawer.MaxBB.Y * Atlas1D.InvTileSize;
float v2 = vOrigin + Drawer.MinBB.Y * Atlas1D_InvTileSize * UV2_Scale; float v2 = vOrigin + Drawer.MinBB.Y * Atlas1D.InvTileSize * UV2_Scale;
ApplyTint; ApplyTint;
v.X = Drawer.X2; v.Col = col; v.X = Drawer.X2; v.Col = col;
@ -53,12 +53,12 @@ void Drawer_XMax(int count, PackedCol col, TextureLoc texLoc, VertexP3fT2fC4b**
void Drawer_ZMin(int count, PackedCol col, TextureLoc texLoc, VertexP3fT2fC4b** vertices) { void Drawer_ZMin(int count, PackedCol col, TextureLoc texLoc, VertexP3fT2fC4b** vertices) {
VertexP3fT2fC4b* ptr = *vertices; VertexP3fT2fC4b v; VertexP3fT2fC4b* ptr = *vertices; VertexP3fT2fC4b v;
float vOrigin = Atlas1D_RowId(texLoc) * Atlas1D_InvTileSize; float vOrigin = Atlas1D_RowId(texLoc) * Atlas1D.InvTileSize;
float u1 = (count - Drawer.MinBB.X); float u1 = (count - Drawer.MinBB.X);
float u2 = (1 - Drawer.MaxBB.X) * UV2_Scale; float u2 = (1 - Drawer.MaxBB.X) * UV2_Scale;
float v1 = vOrigin + Drawer.MaxBB.Y * Atlas1D_InvTileSize; float v1 = vOrigin + Drawer.MaxBB.Y * Atlas1D.InvTileSize;
float v2 = vOrigin + Drawer.MinBB.Y * Atlas1D_InvTileSize * UV2_Scale; float v2 = vOrigin + Drawer.MinBB.Y * Atlas1D.InvTileSize * UV2_Scale;
ApplyTint; ApplyTint;
v.Z = Drawer.Z1; v.Col = col; v.Z = Drawer.Z1; v.Col = col;
@ -72,12 +72,12 @@ void Drawer_ZMin(int count, PackedCol col, TextureLoc texLoc, VertexP3fT2fC4b**
void Drawer_ZMax(int count, PackedCol col, TextureLoc texLoc, VertexP3fT2fC4b** vertices) { void Drawer_ZMax(int count, PackedCol col, TextureLoc texLoc, VertexP3fT2fC4b** vertices) {
VertexP3fT2fC4b* ptr = *vertices; VertexP3fT2fC4b v; VertexP3fT2fC4b* ptr = *vertices; VertexP3fT2fC4b v;
float vOrigin = Atlas1D_RowId(texLoc) * Atlas1D_InvTileSize; float vOrigin = Atlas1D_RowId(texLoc) * Atlas1D.InvTileSize;
float u1 = Drawer.MinBB.X; float u1 = Drawer.MinBB.X;
float u2 = (count - 1) + Drawer.MaxBB.X * UV2_Scale; float u2 = (count - 1) + Drawer.MaxBB.X * UV2_Scale;
float v1 = vOrigin + Drawer.MaxBB.Y * Atlas1D_InvTileSize; float v1 = vOrigin + Drawer.MaxBB.Y * Atlas1D.InvTileSize;
float v2 = vOrigin + Drawer.MinBB.Y * Atlas1D_InvTileSize * UV2_Scale; float v2 = vOrigin + Drawer.MinBB.Y * Atlas1D.InvTileSize * UV2_Scale;
ApplyTint; ApplyTint;
v.Z = Drawer.Z2; v.Col = col; v.Z = Drawer.Z2; v.Col = col;
@ -92,11 +92,11 @@ void Drawer_ZMax(int count, PackedCol col, TextureLoc texLoc, VertexP3fT2fC4b**
void Drawer_YMin(int count, PackedCol col, TextureLoc texLoc, VertexP3fT2fC4b** vertices) { void Drawer_YMin(int count, PackedCol col, TextureLoc texLoc, VertexP3fT2fC4b** vertices) {
VertexP3fT2fC4b* ptr = *vertices; VertexP3fT2fC4b v; VertexP3fT2fC4b* ptr = *vertices; VertexP3fT2fC4b v;
float vOrigin = Atlas1D_RowId(texLoc) * Atlas1D_InvTileSize; float vOrigin = Atlas1D_RowId(texLoc) * Atlas1D.InvTileSize;
float u1 = Drawer.MinBB.X; float u1 = Drawer.MinBB.X;
float u2 = (count - 1) + Drawer.MaxBB.X * UV2_Scale; float u2 = (count - 1) + Drawer.MaxBB.X * UV2_Scale;
float v1 = vOrigin + Drawer.MinBB.Z * Atlas1D_InvTileSize; float v1 = vOrigin + Drawer.MinBB.Z * Atlas1D.InvTileSize;
float v2 = vOrigin + Drawer.MaxBB.Z * Atlas1D_InvTileSize * UV2_Scale; float v2 = vOrigin + Drawer.MaxBB.Z * Atlas1D.InvTileSize * UV2_Scale;
ApplyTint; ApplyTint;
v.Y = Drawer.Y1; v.Col = col; v.Y = Drawer.Y1; v.Col = col;
@ -110,12 +110,12 @@ void Drawer_YMin(int count, PackedCol col, TextureLoc texLoc, VertexP3fT2fC4b**
void Drawer_YMax(int count, PackedCol col, TextureLoc texLoc, VertexP3fT2fC4b** vertices) { void Drawer_YMax(int count, PackedCol col, TextureLoc texLoc, VertexP3fT2fC4b** vertices) {
VertexP3fT2fC4b* ptr = *vertices; VertexP3fT2fC4b v; VertexP3fT2fC4b* ptr = *vertices; VertexP3fT2fC4b v;
float vOrigin = Atlas1D_RowId(texLoc) * Atlas1D_InvTileSize; float vOrigin = Atlas1D_RowId(texLoc) * Atlas1D.InvTileSize;
float u1 = Drawer.MinBB.X; float u1 = Drawer.MinBB.X;
float u2 = (count - 1) + Drawer.MaxBB.X * UV2_Scale; float u2 = (count - 1) + Drawer.MaxBB.X * UV2_Scale;
float v1 = vOrigin + Drawer.MinBB.Z * Atlas1D_InvTileSize; float v1 = vOrigin + Drawer.MinBB.Z * Atlas1D.InvTileSize;
float v2 = vOrigin + Drawer.MaxBB.Z * Atlas1D_InvTileSize * UV2_Scale; float v2 = vOrigin + Drawer.MaxBB.Z * Atlas1D.InvTileSize * UV2_Scale;
ApplyTint; ApplyTint;
v.Y = Drawer.Y2; v.Col = col; v.Y = Drawer.Y2; v.Col = col;

2
src/EnvRenderer.c
View File

@ -579,7 +579,7 @@ static void EnvRenderer_MakeBorderTex(GfxResourceID* texId, BlockID block) {
if (Gfx.LostContext) return; if (Gfx.LostContext) return;
Gfx_DeleteTexture(texId); Gfx_DeleteTexture(texId);
*texId = Atlas_LoadTile(loc); *texId = Atlas2D_LoadTile(loc);
} }
static Rect2D EnvRenderer_Rect(int x, int y, int width, int height) { static Rect2D EnvRenderer_Rect(int x, int y, int width, int height) {

16
src/Http.c
View File

@ -396,7 +396,7 @@ static void Http_MakeHeaders(String* headers, struct HttpRequest* req) {
if (req->LastModified) { if (req->LastModified) {
String_AppendConst(headers, "If-Modified-Since: "); String_AppendConst(headers, "If-Modified-Since: ");
DateTime_HttpDate(req->LastModified, headers); Http_FormatDate(req->LastModified, headers);
String_AppendConst(headers, "\r\n"); String_AppendConst(headers, "\r\n");
} }
@ -854,6 +854,20 @@ void Http_UrlEncodeUtf8(String* dst, const String* src) {
} }
} }
void Http_FormatDate(TimeMS ms, String* str) {
static const char* days_of_week[7] = { "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun" };
static const char* month_names[13] = { NULL, "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
struct DateTime t;
int days;
DateTime_FromTotalMs(&t, ms);
days = DateTime_TotalDays(&t);
String_Format2(str, "%c, %p2 ", days_of_week[days % 7], &t.Day);
String_Format2(str, "%c %p4 ", month_names[t.Month], &t.Year);
String_Format3(str, "%p2:%p2:%p2 GMT", &t.Hour, &t.Minute, &t.Second);
}
/*########################################################################################################################* /*########################################################################################################################*
*-----------------------------------------------------Http component------------------------------------------------------* *-----------------------------------------------------Http component------------------------------------------------------*

3
src/Http.h
View File

@ -59,6 +59,9 @@ void Http_AsyncGetDataEx(const String* url, bool priority, const String* id, Tim
void Http_UrlEncode(String* dst, const uint8_t* data, int len); void Http_UrlEncode(String* dst, const uint8_t* data, int len);
/* Converts characters to UTF8, then calls Http_URlEncode on them. */ /* Converts characters to UTF8, then calls Http_URlEncode on them. */
void Http_UrlEncodeUtf8(String* dst, const String* src); void Http_UrlEncodeUtf8(String* dst, const String* src);
/* Formats a date for inclusion in HTTP headers. */
/* NOTE: Time is always assumed as being UTC. */
void Http_FormatDate(TimeMS ms, String* str);
/* Attempts to retrieve a fully completed request. */ /* Attempts to retrieve a fully completed request. */
/* NOTE: You MUST also check Result/StatusCode, and check Size is > 0. */ /* NOTE: You MUST also check Result/StatusCode, and check Size is > 0. */

2
src/IsometricDrawer.c
View File

@ -52,7 +52,7 @@ static void IsometricDrawer_InitCache(void) {
static void IsometricDrawer_Flush(void) { static void IsometricDrawer_Flush(void) {
int count; int count;
if (iso_lastTexIndex != -1) { if (iso_lastTexIndex != -1) {
Gfx_BindTexture(Atlas1D_TexIds[iso_lastTexIndex]); Gfx_BindTexture(Atlas1D.TexIds[iso_lastTexIndex]);
count = (int)(iso_vertices - iso_vertices_base); count = (int)(iso_vertices - iso_vertices_base);
Gfx_UpdateDynamicVb_IndexedTris(iso_vb, iso_vertices_base, count); Gfx_UpdateDynamicVb_IndexedTris(iso_vb, iso_vertices_base, count);
} }

8
src/MapRenderer.c
View File

@ -185,7 +185,7 @@ void MapRenderer_RenderNormal(double delta) {
for (batch = 0; batch < MapRenderer_1DUsedCount; batch++) { for (batch = 0; batch < MapRenderer_1DUsedCount; batch++) {
if (normPartsCount[batch] <= 0) continue; if (normPartsCount[batch] <= 0) continue;
if (hasNormParts[batch] || checkNormParts[batch]) { if (hasNormParts[batch] || checkNormParts[batch]) {
Gfx_BindTexture(Atlas1D_TexIds[batch]); Gfx_BindTexture(Atlas1D.TexIds[batch]);
MapRenderer_RenderNormalBatch(batch); MapRenderer_RenderNormalBatch(batch);
checkNormParts[batch] = false; checkNormParts[batch] = false;
} }
@ -280,7 +280,7 @@ void MapRenderer_RenderTranslucent(double delta) {
for (batch = 0; batch < MapRenderer_1DUsedCount; batch++) { for (batch = 0; batch < MapRenderer_1DUsedCount; batch++) {
if (tranPartsCount[batch] <= 0) continue; if (tranPartsCount[batch] <= 0) continue;
if (!hasTranParts[batch]) continue; if (!hasTranParts[batch]) continue;
Gfx_BindTexture(Atlas1D_TexIds[batch]); Gfx_BindTexture(Atlas1D.TexIds[batch]);
MapRenderer_RenderTranslucentBatch(batch); MapRenderer_RenderTranslucentBatch(batch);
} }
Gfx_DisableMipmaps(); Gfx_DisableMipmaps();
@ -700,12 +700,12 @@ static void MapRenderer_EnvVariableChanged(void* obj, int envVar) {
static void MapRenderer_TerrainAtlasChanged(void* obj) { static void MapRenderer_TerrainAtlasChanged(void* obj) {
if (MapRenderer_1DUsedCount) { if (MapRenderer_1DUsedCount) {
bool refreshRequired = elementsPerBitmap != Atlas1D_TilesPerAtlas; bool refreshRequired = elementsPerBitmap != Atlas1D.TilesPerAtlas;
if (refreshRequired) MapRenderer_Refresh(); if (refreshRequired) MapRenderer_Refresh();
} }
MapRenderer_1DUsedCount = MapRenderer_UsedAtlases(); MapRenderer_1DUsedCount = MapRenderer_UsedAtlases();
elementsPerBitmap = Atlas1D_TilesPerAtlas; elementsPerBitmap = Atlas1D.TilesPerAtlas;
MapRenderer_ResetPartFlags(); MapRenderer_ResetPartFlags();
} }

12
src/Menus.c
View File

@ -2955,7 +2955,7 @@ static void TexIdsOverlay_ContextRecreated(void* screen) {
s->DynamicVb = Gfx_CreateDynamicVb(VERTEX_FORMAT_P3FT2FC4B, TEXID_OVERLAY_VERTICES_COUNT); s->DynamicVb = Gfx_CreateDynamicVb(VERTEX_FORMAT_P3FT2FC4B, TEXID_OVERLAY_VERTICES_COUNT);
TextAtlas_Make(&s->IdAtlas, &chars, &s->TextFont, &prefix); TextAtlas_Make(&s->IdAtlas, &chars, &s->TextFont, &prefix);
s->XOffset = Gui_CalcPos(ANCHOR_CENTRE, 0, size * Atlas_RowsCount, Game.Width); s->XOffset = Gui_CalcPos(ANCHOR_CENTRE, 0, size * Atlas2D.RowsCount, Game.Width);
s->YOffset = Gui_CalcPos(ANCHOR_CENTRE, 0, size * ATLAS2D_TILES_PER_ROW, Game.Height); s->YOffset = Gui_CalcPos(ANCHOR_CENTRE, 0, size * ATLAS2D_TILES_PER_ROW, Game.Height);
s->TileSize = size; s->TileSize = size;
@ -2978,19 +2978,19 @@ static void TexIdsOverlay_RenderTerrain(struct TexIdsOverlay* s) {
for (i = 0; i < ATLAS2D_TILES_PER_ROW * ATLAS2D_TILES_PER_ROW;) { for (i = 0; i < ATLAS2D_TILES_PER_ROW * ATLAS2D_TILES_PER_ROW;) {
ptr = vertices; ptr = vertices;
idx = Atlas1D_Index(i + s->BaseTexLoc); idx = Atlas1D_Index(i + s->BaseTexLoc);
end = i + Atlas1D_TilesPerAtlas; end = i + Atlas1D.TilesPerAtlas;
for (; i < end; i++) { for (; i < end; i++) {
tex.X = s->XOffset + Atlas2D_TileX(i) * size; tex.X = s->XOffset + Atlas2D_TileX(i) * size;
tex.Y = s->YOffset + Atlas2D_TileY(i) * size; tex.Y = s->YOffset + Atlas2D_TileY(i) * size;
tex.uv.V1 = Atlas1D_RowId(i + s->BaseTexLoc) * Atlas1D_InvTileSize; tex.uv.V1 = Atlas1D_RowId(i + s->BaseTexLoc) * Atlas1D.InvTileSize;
tex.uv.V2 = tex.uv.V1 + UV2_Scale * Atlas1D_InvTileSize; tex.uv.V2 = tex.uv.V1 + UV2_Scale * Atlas1D.InvTileSize;
Gfx_Make2DQuad(&tex, col, &ptr); Gfx_Make2DQuad(&tex, col, &ptr);
} }
Gfx_BindTexture(Atlas1D_TexIds[idx]); Gfx_BindTexture(Atlas1D.TexIds[idx]);
count = (int)(ptr - vertices); count = (int)(ptr - vertices);
Gfx_UpdateDynamicVb_IndexedTris(s->DynamicVb, vertices, count); Gfx_UpdateDynamicVb_IndexedTris(s->DynamicVb, vertices, count);
} }
@ -3042,7 +3042,7 @@ static void TexIdsOverlay_Render(void* screen, double delta) {
origXOffset = s->XOffset; origXOffset = s->XOffset;
s->BaseTexLoc = 0; s->BaseTexLoc = 0;
for (rows = Atlas_RowsCount; rows > 0; rows -= ATLAS2D_TILES_PER_ROW) { for (rows = Atlas2D.RowsCount; rows > 0; rows -= ATLAS2D_TILES_PER_ROW) {
TexIdsOverlay_RenderTerrain(s); TexIdsOverlay_RenderTerrain(s);
TexIdsOverlay_RenderTextOverlay(s); TexIdsOverlay_RenderTextOverlay(s);

2
src/Model.c
View File

@ -1494,7 +1494,7 @@ static void BlockModel_GetBounds(struct Entity* e) {
static void BlockModel_Flush(void) { static void BlockModel_Flush(void) {
if (bModel_lastTexIndex != -1) { if (bModel_lastTexIndex != -1) {
Gfx_BindTexture(Atlas1D_TexIds[bModel_lastTexIndex]); Gfx_BindTexture(Atlas1D.TexIds[bModel_lastTexIndex]);
Models.Active->index = bModel_index; Models.Active->index = bModel_index;
Model_UpdateVB(); Model_UpdateVB();
} }

8
src/Particle.c
View File

@ -259,7 +259,7 @@ static void Terrain_Update1DCounts(void) {
index = Atlas1D_Index(terrain_particles[i].TexLoc); index = Atlas1D_Index(terrain_particles[i].TexLoc);
terrain_1DCount[index] += 4; terrain_1DCount[index] += 4;
} }
for (i = 1; i < Atlas1D_Count; i++) { for (i = 1; i < Atlas1D.Count; i++) {
terrain_1DIndices[i] = terrain_1DIndices[i - 1] + terrain_1DCount[i - 1]; terrain_1DIndices[i] = terrain_1DIndices[i - 1] + terrain_1DCount[i - 1];
} }
} }
@ -281,11 +281,11 @@ static void Terrain_Render(float t) {
} }
Gfx_SetDynamicVbData(Particles_VB, vertices, terrain_count * 4); Gfx_SetDynamicVbData(Particles_VB, vertices, terrain_count * 4);
for (i = 0; i < Atlas1D_Count; i++) { for (i = 0; i < Atlas1D.Count; i++) {
int partCount = terrain_1DCount[i]; int partCount = terrain_1DCount[i];
if (!partCount) continue; if (!partCount) continue;
Gfx_BindTexture(Atlas1D_TexIds[i]); Gfx_BindTexture(Atlas1D.TexIds[i]);
Gfx_DrawVb_IndexedTris_Range(partCount, offset); Gfx_DrawVb_IndexedTris_Range(partCount, offset);
offset += partCount; offset += partCount;
} }
@ -368,7 +368,7 @@ void Particles_BreakBlockEffect(Vector3I coords, BlockID old, BlockID now) {
loc = Block_Tex(old, FACE_XMIN); loc = Block_Tex(old, FACE_XMIN);
baseRec = Atlas1D_TexRec(loc, 1, &texIndex); baseRec = Atlas1D_TexRec(loc, 1, &texIndex);
uScale = (1.0f/16.0f); vScale = (1.0f/16.0f) * Atlas1D_InvTileSize; uScale = (1.0f/16.0f); vScale = (1.0f/16.0f) * Atlas1D.InvTileSize;
minBB = Blocks.MinBB[old]; maxBB = Blocks.MaxBB[old]; minBB = Blocks.MinBB[old]; maxBB = Blocks.MaxBB[old];
minX = (int)(minBB.X * 16); maxX = (int)(maxBB.X * 16); minX = (int)(minBB.X * 16); maxX = (int)(maxBB.X * 16);

2
src/Screens.c
View File

@ -521,7 +521,7 @@ static bool LoadingScreen_MouseScroll(void* screen, float delta) { return true;
static void LoadingScreen_UpdateBackgroundVB(VertexP3fT2fC4b* vertices, int count, int atlasIndex, bool* bound) { static void LoadingScreen_UpdateBackgroundVB(VertexP3fT2fC4b* vertices, int count, int atlasIndex, bool* bound) {
if (!(*bound)) { if (!(*bound)) {
*bound = true; *bound = true;
Gfx_BindTexture(Atlas1D_TexIds[atlasIndex]); Gfx_BindTexture(Atlas1D.TexIds[atlasIndex]);
} }
Gfx_SetVertexFormat(VERTEX_FORMAT_P3FT2FC4B); Gfx_SetVertexFormat(VERTEX_FORMAT_P3FT2FC4B);

72
src/TexturePack.c
View File

@ -223,7 +223,7 @@ static void Animations_ReadDescription(struct Stream* stream, const String* path
#define ANIMS_FAST_SIZE 64 #define ANIMS_FAST_SIZE 64
static void Animations_Draw(struct AnimationData* data, TextureLoc texLoc, int size) { static void Animations_Draw(struct AnimationData* data, TextureLoc texLoc, int size) {
int dstX = Atlas1D_Index(texLoc), srcX; int dstX = Atlas1D_Index(texLoc), srcX;
int dstY = Atlas1D_RowId(texLoc) * Atlas_TileSize; int dstY = Atlas1D_RowId(texLoc) * Atlas2D.TileSize;
GfxResourceID tex; GfxResourceID tex;
uint8_t buffer[Bitmap_DataSize(ANIMS_FAST_SIZE, ANIMS_FAST_SIZE)]; uint8_t buffer[Bitmap_DataSize(ANIMS_FAST_SIZE, ANIMS_FAST_SIZE)];
@ -247,7 +247,7 @@ static void Animations_Draw(struct AnimationData* data, TextureLoc texLoc, int s
Bitmap_CopyBlock(srcX, data->FrameY, 0, 0, &anims_bmp, &frame, size); Bitmap_CopyBlock(srcX, data->FrameY, 0, 0, &anims_bmp, &frame, size);
} }
tex = Atlas1D_TexIds[dstX]; tex = Atlas1D.TexIds[dstX];
if (tex) { Gfx_UpdateTexturePart(tex, 0, dstY, &frame, Gfx.Mipmaps); } if (tex) { Gfx_UpdateTexturePart(tex, 0, dstY, &frame, Gfx.Mipmaps); }
if (size > ANIMS_FAST_SIZE) Mem_Free(ptr); if (size > ANIMS_FAST_SIZE) Mem_Free(ptr);
} }
@ -297,7 +297,7 @@ static void Animations_Validate(void) {
tileX = Atlas2D_TileX(data.TexLoc); tileX = Atlas2D_TileX(data.TexLoc);
tileY = Atlas2D_TileY(data.TexLoc); tileY = Atlas2D_TileY(data.TexLoc);
if (data.FrameSize > Atlas_TileSize || tileY >= Atlas_RowsCount) { if (data.FrameSize > Atlas2D.TileSize || tileY >= Atlas2D.RowsCount) {
Chat_Add2("&cAnimation frames for tile (%i, %i) are bigger than the size of a tile in terrain.png", &tileX, &tileY); Chat_Add2("&cAnimation frames for tile (%i, %i) are bigger than the size of a tile in terrain.png", &tileX, &tileY);
} else if (maxX > anims_bmp.Width || maxY > anims_bmp.Height) { } else if (maxX > anims_bmp.Width || maxY > anims_bmp.Height) {
Chat_Add2("&cSome of the animation frames for tile (%i, %i) are at coordinates outside animations.png", &tileX, &tileY); Chat_Add2("&cSome of the animation frames for tile (%i, %i) are at coordinates outside animations.png", &tileX, &tileY);
@ -317,11 +317,11 @@ static void Animations_Tick(struct ScheduledTask* task) {
int i, size; int i, size;
if (anims_useLavaAnim) { if (anims_useLavaAnim) {
size = min(Atlas_TileSize, 64); size = min(Atlas2D.TileSize, 64);
Animations_Draw(NULL, 30, size); Animations_Draw(NULL, 30, size);
} }
if (anims_useWaterAnim) { if (anims_useWaterAnim) {
size = min(Atlas_TileSize, 64); size = min(Atlas2D.TileSize, 64);
Animations_Draw(NULL, 14, size); Animations_Draw(NULL, 14, size);
} }
@ -388,12 +388,8 @@ struct IGameComponent Animations_Component = {
/*########################################################################################################################* /*########################################################################################################################*
*------------------------------------------------------TerrainAtlas-------------------------------------------------------* *------------------------------------------------------TerrainAtlas-------------------------------------------------------*
*#########################################################################################################################*/ *#########################################################################################################################*/
Bitmap Atlas_Bitmap; struct _Atlas2DData Atlas2D;
int Atlas_TileSize, Atlas_RowsCount; struct _Atlas1DData Atlas1D;
int Atlas1D_Count, Atlas1D_TilesPerAtlas;
int Atlas1D_Mask, Atlas1D_Shift;
float Atlas1D_InvTileSize;
GfxResourceID Atlas1D_TexIds[ATLAS1D_MAX_ATLASES];
TextureRec Atlas1D_TexRec(TextureLoc texLoc, int uCount, int* index) { TextureRec Atlas1D_TexRec(TextureLoc texLoc, int uCount, int* index) {
TextureRec rec; TextureRec rec;
@ -402,16 +398,16 @@ TextureRec Atlas1D_TexRec(TextureLoc texLoc, int uCount, int* index) {
/* Adjust coords to be slightly inside - fixes issues with AMD/ATI cards */ /* Adjust coords to be slightly inside - fixes issues with AMD/ATI cards */
rec.U1 = 0.0f; rec.U1 = 0.0f;
rec.V1 = y * Atlas1D_InvTileSize; rec.V1 = y * Atlas1D.InvTileSize;
rec.U2 = (uCount - 1) + UV2_Scale; rec.U2 = (uCount - 1) + UV2_Scale;
rec.V2 = rec.V1 + UV2_Scale * Atlas1D_InvTileSize; rec.V2 = rec.V1 + UV2_Scale * Atlas1D.InvTileSize;
return rec; return rec;
} }
static void Atlas_Convert2DTo1D(void) { static void Atlas_Convert2DTo1D(void) {
int tileSize = Atlas_TileSize; int tileSize = Atlas2D.TileSize;
int tilesPerAtlas = Atlas1D_TilesPerAtlas; int tilesPerAtlas = Atlas1D.TilesPerAtlas;
int atlasesCount = Atlas1D_Count; int atlasesCount = Atlas1D.Count;
Bitmap atlas1D; Bitmap atlas1D;
int atlasX, atlasY; int atlasX, atlasY;
int tile = 0, i, y; int tile = 0, i, y;
@ -425,9 +421,9 @@ static void Atlas_Convert2DTo1D(void) {
atlasY = Atlas2D_TileY(tile) * tileSize; atlasY = Atlas2D_TileY(tile) * tileSize;
Bitmap_CopyBlock(atlasX, atlasY, 0, y * tileSize, Bitmap_CopyBlock(atlasX, atlasY, 0, y * tileSize,
&Atlas_Bitmap, &atlas1D, tileSize); &Atlas2D.Bitmap, &atlas1D, tileSize);
} }
Atlas1D_TexIds[i] = Gfx_CreateTexture(&atlas1D, true, Gfx.Mipmaps); Atlas1D.TexIds[i] = Gfx_CreateTexture(&atlas1D, true, Gfx.Mipmaps);
} }
Mem_Free(atlas1D.Scan0); Mem_Free(atlas1D.Scan0);
} }
@ -436,38 +432,38 @@ static void Atlas_Update1D(void) {
int maxAtlasHeight, maxTilesPerAtlas, maxTiles; int maxAtlasHeight, maxTilesPerAtlas, maxTiles;
maxAtlasHeight = min(4096, Gfx.MaxTexHeight); maxAtlasHeight = min(4096, Gfx.MaxTexHeight);
maxTilesPerAtlas = maxAtlasHeight / Atlas_TileSize; maxTilesPerAtlas = maxAtlasHeight / Atlas2D.TileSize;
maxTiles = Atlas_RowsCount * ATLAS2D_TILES_PER_ROW; maxTiles = Atlas2D.RowsCount * ATLAS2D_TILES_PER_ROW;
Atlas1D_TilesPerAtlas = min(maxTilesPerAtlas, maxTiles); Atlas1D.TilesPerAtlas = min(maxTilesPerAtlas, maxTiles);
Atlas1D_Count = Math_CeilDiv(maxTiles, Atlas1D_TilesPerAtlas); Atlas1D.Count = Math_CeilDiv(maxTiles, Atlas1D.TilesPerAtlas);
Atlas1D_InvTileSize = 1.0f / Atlas1D_TilesPerAtlas; Atlas1D.InvTileSize = 1.0f / Atlas1D.TilesPerAtlas;
Atlas1D_Mask = Atlas1D_TilesPerAtlas - 1; Atlas1D.Mask = Atlas1D.TilesPerAtlas - 1;
Atlas1D_Shift = Math_Log2(Atlas1D_TilesPerAtlas); Atlas1D.Shift = Math_Log2(Atlas1D.TilesPerAtlas);
} }
void Atlas_Update(Bitmap* bmp) { void Atlas_Update(Bitmap* bmp) {
Atlas_Bitmap = *bmp; Atlas2D.Bitmap = *bmp;
Atlas_TileSize = bmp->Width / ATLAS2D_TILES_PER_ROW; Atlas2D.TileSize = bmp->Width / ATLAS2D_TILES_PER_ROW;
Atlas_RowsCount = bmp->Height / Atlas_TileSize; Atlas2D.RowsCount = bmp->Height / Atlas2D.TileSize;
Atlas_RowsCount = min(Atlas_RowsCount, ATLAS2D_MAX_ROWS_COUNT); Atlas2D.RowsCount = min(Atlas2D.RowsCount, ATLAS2D_MAX_ROWS_COUNT);
Atlas_Update1D(); Atlas_Update1D();
Atlas_Convert2DTo1D(); Atlas_Convert2DTo1D();
} }
static GfxResourceID Atlas_LoadTile_Raw(TextureLoc texLoc, Bitmap* element) { static GfxResourceID Atlas_LoadTile_Raw(TextureLoc texLoc, Bitmap* element) {
int size = Atlas_TileSize; int size = Atlas2D.TileSize;
int x = Atlas2D_TileX(texLoc), y = Atlas2D_TileY(texLoc); int x = Atlas2D_TileX(texLoc), y = Atlas2D_TileY(texLoc);
if (y >= Atlas_RowsCount) return GFX_NULL; if (y >= Atlas2D.RowsCount) return GFX_NULL;
Bitmap_CopyBlock(x * size, y * size, 0, 0, &Atlas_Bitmap, element, size); Bitmap_CopyBlock(x * size, y * size, 0, 0, &Atlas2D.Bitmap, element, size);
return Gfx_CreateTexture(element, false, Gfx.Mipmaps); return Gfx_CreateTexture(element, false, Gfx.Mipmaps);
} }
GfxResourceID Atlas_LoadTile(TextureLoc texLoc) { GfxResourceID Atlas2D_LoadTile(TextureLoc texLoc) {
int tileSize = Atlas_TileSize; int tileSize = Atlas2D.TileSize;
Bitmap tile; Bitmap tile;
GfxResourceID texId; GfxResourceID texId;
uint8_t scan0[Bitmap_DataSize(64, 64)]; uint8_t scan0[Bitmap_DataSize(64, 64)];
@ -486,11 +482,11 @@ GfxResourceID Atlas_LoadTile(TextureLoc texLoc) {
void Atlas_Free(void) { void Atlas_Free(void) {
int i; int i;
Mem_Free(Atlas_Bitmap.Scan0); Mem_Free(Atlas2D.Bitmap.Scan0);
Atlas_Bitmap.Scan0 = NULL; Atlas2D.Bitmap.Scan0 = NULL;
for (i = 0; i < Atlas1D_Count; i++) { for (i = 0; i < Atlas1D.Count; i++) {
Gfx_DeleteTexture(&Atlas1D_TexIds[i]); Gfx_DeleteTexture(&Atlas1D.TexIds[i]);
} }
} }

29
src/TexturePack.h
View File

@ -27,37 +27,42 @@ extern struct IGameComponent Animations_Component;
/* Maximum possible number of 1D terrain atlases. (worst case, each 1D atlas only has 1 tile) */ /* Maximum possible number of 1D terrain atlases. (worst case, each 1D atlas only has 1 tile) */
#define ATLAS1D_MAX_ATLASES (ATLAS2D_TILES_PER_ROW * ATLAS2D_MAX_ROWS_COUNT) #define ATLAS1D_MAX_ATLASES (ATLAS2D_TILES_PER_ROW * ATLAS2D_MAX_ROWS_COUNT)
CC_VAR extern struct _Atlas2DData {
/* Bitmap that contains the textures of all tiles. */ /* Bitmap that contains the textures of all tiles. */
/* Tiles are indexed left to right, top to bottom. */ /* Tiles are indexed left to right, top to bottom. */
extern Bitmap Atlas_Bitmap; Bitmap Bitmap;
/* Size of each tile in pixels. (default 16x16) */ /* Size of each tile in pixels. (default 16x16) */
extern int Atlas_TileSize; int TileSize;
/* Number of rows in the atlas. (default 16, can be 32) */ /* Number of rows in the atlas. (default 16, can be 32) */
extern int Atlas_RowsCount; int RowsCount;
} Atlas2D;
CC_VAR extern struct _Atlas1DData {
/* Number of 1D atlases the atlas was split into. */ /* Number of 1D atlases the atlas was split into. */
extern int Atlas1D_Count; int Count;
/* Number of tiles in each 1D atlas. */ /* Number of tiles in each 1D atlas. */
extern int Atlas1D_TilesPerAtlas; int TilesPerAtlas;
/* Converts a tile id into 1D atlas index, and index within that atlas. */ /* Converts a tile id into 1D atlas index, and index within that atlas. */
extern int Atlas1D_Mask, Atlas1D_Shift; int Mask, Shift;
/* Texture V coord that equals the size of one tile. (i.e. 1/Atlas1D_TilesPerAtlas) */ /* Texture V coord that equals the size of one tile. (i.e. 1/Atlas1D.TilesPerAtlas) */
/* NOTE: The texture U coord that equals the size of one tile is 1. */ /* NOTE: The texture U coord that equals the size of one tile is 1. */
extern float Atlas1D_InvTileSize; float InvTileSize;
/* Textures for each 1D atlas. Only Atlas1D_Count of these are valid. */ /* Textures for each 1D atlas. Only Atlas1D_Count of these are valid. */
extern GfxResourceID Atlas1D_TexIds[ATLAS1D_MAX_ATLASES]; GfxResourceID TexIds[ATLAS1D_MAX_ATLASES];
} Atlas1D;
#define Atlas2D_TileX(texLoc) ((texLoc) & ATLAS2D_MASK) /* texLoc % ATLAS2D_TILES_PER_ROW */ #define Atlas2D_TileX(texLoc) ((texLoc) & ATLAS2D_MASK) /* texLoc % ATLAS2D_TILES_PER_ROW */
#define Atlas2D_TileY(texLoc) ((texLoc) >> ATLAS2D_SHIFT) /* texLoc / ATLAS2D_TILES_PER_ROW */ #define Atlas2D_TileY(texLoc) ((texLoc) >> ATLAS2D_SHIFT) /* texLoc / ATLAS2D_TILES_PER_ROW */
/* Returns the index of the given tile id within a 1D atlas */ /* Returns the index of the given tile id within a 1D atlas */
#define Atlas1D_RowId(texLoc) ((texLoc) & Atlas1D_Mask) /* texLoc % Atlas1D_TilesPerAtlas */ #define Atlas1D_RowId(texLoc) ((texLoc) & Atlas1D.Mask) /* texLoc % Atlas1D_TilesPerAtlas */
/* Returns the index of the 1D atlas within the array of 1D atlases that contains the given tile id */ /* Returns the index of the 1D atlas within the array of 1D atlases that contains the given tile id */
#define Atlas1D_Index(texLoc) ((texLoc) >> Atlas1D_Shift) /* texLoc / Atlas1D_TilesPerAtlas */ #define Atlas1D_Index(texLoc) ((texLoc) >> Atlas1D.Shift) /* texLoc / Atlas1D_TilesPerAtlas */
/* Loads the given atlas and converts it into an array of 1D atlases. */ /* Loads the given atlas and converts it into an array of 1D atlases. */
/* NOTE: Use Game_ChangeTerrainAtlas to change atlas, because that raises TextureEvents.AtlasChanged */ /* NOTE: Use Game_ChangeTerrainAtlas to change atlas, because that raises TextureEvents.AtlasChanged */
void Atlas_Update(Bitmap* bmp); void Atlas_Update(Bitmap* bmp);
/* Loads the given tile into a new separate texture. */ /* Loads the given tile into a new separate texture. */
GfxResourceID Atlas_LoadTile(TextureLoc texLoc); GfxResourceID Atlas2D_LoadTile(TextureLoc texLoc);
/* Frees the atlas and 1D atlas textures. */ /* Frees the atlas and 1D atlas textures. */
void Atlas_Free(void); void Atlas_Free(void);
/* Returns the UV rectangle of the given tile id in the 1D atlases. */ /* Returns the UV rectangle of the given tile id in the 1D atlases. */

14
src/Utils.c
View File

@ -88,20 +88,6 @@ void DateTime_FromTotalMs(struct DateTime* time, TimeMS ms) {
} }
} }
void DateTime_HttpDate(TimeMS ms, String* str) {
static const char* days_of_week[7] = { "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun" };
static const char* month_names[13] = { NULL, "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
struct DateTime t;
int days;
DateTime_FromTotalMs(&t, ms);
days = DateTime_TotalDays(&t);
String_Format2(str, "%c, %p2 ", days_of_week[days % 7], &t.Day);
String_Format2(str, "%c %p4 ", month_names[t.Month], &t.Year);
String_Format3(str, "%p2:%p2:%p2 GMT", &t.Hour, &t.Minute, &t.Second);
}
/*########################################################################################################################* /*########################################################################################################################*
*----------------------------------------------------------Misc-----------------------------------------------------------* *----------------------------------------------------------Misc-----------------------------------------------------------*

1
src/Utils.h
View File

@ -29,7 +29,6 @@ struct DateTime {
int DateTime_TotalDays(const struct DateTime* time); int DateTime_TotalDays(const struct DateTime* time);
TimeMS DateTime_TotalMs(const struct DateTime* time); TimeMS DateTime_TotalMs(const struct DateTime* time);
void DateTime_FromTotalMs(struct DateTime* time, TimeMS ms); void DateTime_FromTotalMs(struct DateTime* time, TimeMS ms);
void DateTime_HttpDate(TimeMS ms, String* str);
CC_NOINLINE int Utils_ParseEnum(const String* text, int defValue, const char** names, int namesCount); CC_NOINLINE int Utils_ParseEnum(const String* text, int defValue, const char** names, int namesCount);
bool Utils_IsUrlPrefix(const String* value, int index); bool Utils_IsUrlPrefix(const String* value, int index);

2
src/World.h
View File

@ -13,7 +13,6 @@ struct AABB;
/* Packs an x,y,z into a single index */ /* Packs an x,y,z into a single index */
#define World_Pack(x, y, z) (((y) * World.Length + (z)) * World.Width + (x)) #define World_Pack(x, y, z) (((y) * World.Length + (z)) * World.Width + (x))
/* Contains general data about the world, primarily the blocks. */
CC_VAR extern struct _WorldData { CC_VAR extern struct _WorldData {
/* The blocks in the world. */ /* The blocks in the world. */
BlockRaw* Blocks; BlockRaw* Blocks;
@ -92,7 +91,6 @@ enum EnvVar {
ENV_VAR_SKYBOX_COL ENV_VAR_SKYBOX_COL
}; };
/* Contains data about the current environment of the world. */
CC_VAR extern struct _EnvData { CC_VAR extern struct _EnvData {
BlockID EdgeBlock, SidesBlock; BlockID EdgeBlock, SidesBlock;
int EdgeHeight, SidesOffset; int EdgeHeight, SidesOffset;