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

Phase 1 of renaming VertexP3fT2fC4b/P3fC4b to VertexTextured/Coloured

Browse Source
This commit is contained in:
UnknownShadow200 2020-05-06 22:08:06 +10:00
parent a092b86ac8
commit 64a968237c
14 changed files with 114 additions and 111 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/AxisLinesRenderer.c
View File

@ -32,7 +32,7 @@ void AxisLinesRenderer_Render(void) {
if (!AxisLinesRenderer_Enabled || Gfx.LostContext) return; if (!AxisLinesRenderer_Enabled || Gfx.LostContext) return;
/* Don't do it in a ContextRecreated handler, because we only want VB recreated if ShowAxisLines in on. */ /* Don't do it in a ContextRecreated handler, because we only want VB recreated if ShowAxisLines in on. */
if (!axisLines_vb) { if (!axisLines_vb) {
axisLines_vb = Gfx_CreateDynamicVb(VERTEX_FORMAT_P3FC4B, AXISLINES_NUM_VERTICES); axisLines_vb = Gfx_CreateDynamicVb(VERTEX_FORMAT_COLOURED, AXISLINES_NUM_VERTICES);
} }
Gfx_SetTexturing(false); Gfx_SetTexturing(false);
@ -45,7 +45,7 @@ void AxisLinesRenderer_Render(void) {
Vec3_Add1(&coords[3], &pos, AXISLINES_THICKNESS); Vec3_Add1(&coords[3], &pos, AXISLINES_THICKNESS);
Vec3_Add1(&coords[4], &pos, AXISLINES_LENGTH); Vec3_Add1(&coords[4], &pos, AXISLINES_LENGTH);
v = (VertexP3fC4b*)Gfx_LockDynamicVb(axisLines_vb, VERTEX_FORMAT_P3FC4B, AXISLINES_NUM_VERTICES); v = (VertexP3fC4b*)Gfx_LockDynamicVb(axisLines_vb, VERTEX_FORMAT_COLOURED, AXISLINES_NUM_VERTICES);
for (i = 0; i < count; i++, v++) { for (i = 0; i < count; i++, v++) {
v->X = coords[indices[i*3 + 0]].X; v->X = coords[indices[i*3 + 0]].X;
v->Y = coords[indices[i*3 + 1]].Y; v->Y = coords[indices[i*3 + 1]].Y;
@ -53,7 +53,7 @@ void AxisLinesRenderer_Render(void) {
v->Col = cols[i >> 2]; v->Col = cols[i >> 2];
} }
Gfx_SetVertexFormat(VERTEX_FORMAT_P3FC4B); Gfx_SetVertexFormat(VERTEX_FORMAT_COLOURED);
Gfx_UnlockDynamicVb(axisLines_vb); Gfx_UnlockDynamicVb(axisLines_vb);
Gfx_DrawVb_IndexedTris(count); Gfx_DrawVb_IndexedTris(count);
} }

2
src/Builder.c
View File

@ -393,7 +393,7 @@ static cc_bool BuildChunk(int x1, int y1, int z1, struct ChunkInfo* info) {
#ifndef CC_BUILD_GL11 #ifndef CC_BUILD_GL11
/* add an extra element to fix crashing on some GPUs */ /* add an extra element to fix crashing on some GPUs */
Builder_Vertices = Gfx_CreateAndLockVb(VERTEX_FORMAT_P3FT2FC4B, totalVerts + 1, &info->Vb); Builder_Vertices = Gfx_CreateAndLockVb(VERTEX_FORMAT_TEXTURED, totalVerts + 1, &info->Vb);
#else #else
/* NOTE: Relies on assumption vb is ignored by GL11 Gfx_LockVb implementation */ /* NOTE: Relies on assumption vb is ignored by GL11 Gfx_LockVb implementation */
Builder_Vertices = Gfx_LockVb(0, VERTEX_FORMAT_P3FT2FC4B, totalVerts + 1); Builder_Vertices = Gfx_LockVb(0, VERTEX_FORMAT_P3FT2FC4B, totalVerts + 1);

4
src/Entity.c
View File

@ -304,7 +304,7 @@ static void DrawName(struct Entity* e) {
} }
Particle_DoRender(&size, &pos, &e->NameTex.uv, col, vertices); Particle_DoRender(&size, &pos, &e->NameTex.uv, col, vertices);
Gfx_SetVertexFormat(VERTEX_FORMAT_P3FT2FC4B); Gfx_SetVertexFormat(VERTEX_FORMAT_TEXTURED);
Gfx_UpdateDynamicVb_IndexedTris(Gfx_texVb, vertices, 4); Gfx_UpdateDynamicVb_IndexedTris(Gfx_texVb, vertices, 4);
} }
@ -673,7 +673,7 @@ void Entities_DrawShadows(void) {
Gfx_SetAlphaBlending(true); Gfx_SetAlphaBlending(true);
Gfx_SetTexturing(true); Gfx_SetTexturing(true);
Gfx_SetVertexFormat(VERTEX_FORMAT_P3FT2FC4B); Gfx_SetVertexFormat(VERTEX_FORMAT_TEXTURED);
ShadowComponent_Draw(Entities.List[ENTITIES_SELF_ID]); ShadowComponent_Draw(Entities.List[ENTITIES_SELF_ID]);
if (Entities.ShadowsMode == SHADOW_MODE_CIRCLE_ALL) { if (Entities.ShadowsMode == SHADOW_MODE_CIRCLE_ALL) {

22
src/EnvRenderer.c
View File

@ -144,7 +144,7 @@ void EnvRenderer_RenderClouds(void) {
Gfx_SetAlphaTest(true); Gfx_SetAlphaTest(true);
Gfx_SetTexturing(true); Gfx_SetTexturing(true);
Gfx_BindTexture(clouds_tex); Gfx_BindTexture(clouds_tex);
Gfx_SetVertexFormat(VERTEX_FORMAT_P3FT2FC4B); Gfx_SetVertexFormat(VERTEX_FORMAT_TEXTURED);
Gfx_BindVb(clouds_vb); Gfx_BindVb(clouds_vb);
Gfx_DrawVb_IndexedTris(clouds_vertices); Gfx_DrawVb_IndexedTris(clouds_vertices);
Gfx_SetAlphaTest(false); Gfx_SetAlphaTest(false);
@ -194,7 +194,7 @@ static void UpdateClouds(void) {
z1 = -extent; z2 = World.Length + extent; z1 = -extent; z2 = World.Length + extent;
clouds_vertices = CalcNumVertices(x2 - x1, z2 - z1); clouds_vertices = CalcNumVertices(x2 - x1, z2 - z1);
data = Gfx_CreateAndLockVb(VERTEX_FORMAT_P3FT2FC4B, clouds_vertices, &clouds_vb); data = Gfx_CreateAndLockVb(VERTEX_FORMAT_TEXTURED, clouds_vertices, &clouds_vb);
DrawCloudsY(x1, z1, x2, z2, Env.CloudsHeight, data); DrawCloudsY(x1, z1, x2, z2, Env.CloudsHeight, data);
Gfx_UnlockVb(clouds_vb); Gfx_UnlockVb(clouds_vb);
} }
@ -213,7 +213,7 @@ void EnvRenderer_RenderSky(void) {
normY = (float)World.Height + 8.0f; normY = (float)World.Height + 8.0f;
skyY = max(Camera.CurrentPos.Y + 8.0f, normY); skyY = max(Camera.CurrentPos.Y + 8.0f, normY);
Gfx_SetVertexFormat(VERTEX_FORMAT_P3FC4B); Gfx_SetVertexFormat(VERTEX_FORMAT_COLOURED);
Gfx_BindVb(sky_vb); Gfx_BindVb(sky_vb);
if (skyY == normY) { if (skyY == normY) {
@ -265,7 +265,7 @@ static void UpdateSky(void) {
z1 = -extent; z2 = World.Length + extent; z1 = -extent; z2 = World.Length + extent;
sky_vertices = CalcNumVertices(x2 - x1, z2 - z1); sky_vertices = CalcNumVertices(x2 - x1, z2 - z1);
data = Gfx_CreateAndLockVb(VERTEX_FORMAT_P3FC4B, sky_vertices, &sky_vb); data = Gfx_CreateAndLockVb(VERTEX_FORMAT_COLOURED, sky_vertices, &sky_vb);
height = max((World.Height + 2), Env.CloudsHeight) + 6; height = max((World.Height + 2), Env.CloudsHeight) + 6;
DrawSkyY(x1, z1, x2, z2, height, data); DrawSkyY(x1, z1, x2, z2, height, data);
Gfx_UnlockVb(sky_vb); Gfx_UnlockVb(sky_vb);
@ -287,7 +287,7 @@ void EnvRenderer_RenderSkybox(void) {
Gfx_SetDepthWrite(false); Gfx_SetDepthWrite(false);
Gfx_SetTexturing(true); Gfx_SetTexturing(true);
Gfx_BindTexture(skybox_tex); Gfx_BindTexture(skybox_tex);
Gfx_SetVertexFormat(VERTEX_FORMAT_P3FT2FC4B); Gfx_SetVertexFormat(VERTEX_FORMAT_TEXTURED);
/* Base skybox rotation */ /* Base skybox rotation */
rotTime = (float)(Game.Time * 2 * MATH_PI); /* So speed of 1 rotates whole skybox every second */ rotTime = (float)(Game.Time * 2 * MATH_PI); /* So speed of 1 rotates whole skybox every second */
@ -338,7 +338,7 @@ static void UpdateSkybox(void) {
if (Gfx.LostContext) return; if (Gfx.LostContext) return;
if (EnvRenderer_Minimal) return; if (EnvRenderer_Minimal) return;
data = Gfx_CreateAndLockVb(VERTEX_FORMAT_P3FT2FC4B, SKYBOX_COUNT, &skybox_vb); data = Gfx_CreateAndLockVb(VERTEX_FORMAT_TEXTURED, SKYBOX_COUNT, &skybox_vb);
Mem_Copy(data, vertices, sizeof(vertices)); Mem_Copy(data, vertices, sizeof(vertices));
for (i = 0; i < SKYBOX_COUNT; i++) { data[i].Col = Env.SkyboxCol; } for (i = 0; i < SKYBOX_COUNT; i++) { data[i].Col = Env.SkyboxCol; }
Gfx_UnlockVb(skybox_vb); Gfx_UnlockVb(skybox_vb);
@ -514,7 +514,7 @@ void EnvRenderer_RenderWeather(double deltaTime) {
Gfx_SetDepthWrite(false); Gfx_SetDepthWrite(false);
Gfx_SetAlphaArgBlend(true); Gfx_SetAlphaArgBlend(true);
Gfx_SetVertexFormat(VERTEX_FORMAT_P3FT2FC4B); Gfx_SetVertexFormat(VERTEX_FORMAT_TEXTURED);
vCount = (int)(v - vertices); vCount = (int)(v - vertices);
Gfx_UpdateDynamicVb_IndexedTris(weather_vb, vertices, vCount); Gfx_UpdateDynamicVb_IndexedTris(weather_vb, vertices, vCount);
@ -540,7 +540,7 @@ static void RenderBorders(BlockID block, GfxResourceID vb, GfxResourceID tex, in
Gfx_EnableMipmaps(); Gfx_EnableMipmaps();
Gfx_BindTexture(tex); Gfx_BindTexture(tex);
Gfx_SetVertexFormat(VERTEX_FORMAT_P3FT2FC4B); Gfx_SetVertexFormat(VERTEX_FORMAT_TEXTURED);
Gfx_BindVb(vb); Gfx_BindVb(vb);
Gfx_DrawVb_IndexedTris(count); Gfx_DrawVb_IndexedTris(count);
@ -688,7 +688,7 @@ static void UpdateMapSides(void) {
sides_vertices += CalcNumVertices(World.Width, World.Length); /* YQuads beneath map */ sides_vertices += CalcNumVertices(World.Width, World.Length); /* YQuads beneath map */
sides_vertices += 2 * CalcNumVertices(World.Width, Math_AbsI(y)); /* ZQuads */ sides_vertices += 2 * CalcNumVertices(World.Width, Math_AbsI(y)); /* ZQuads */
sides_vertices += 2 * CalcNumVertices(World.Length, Math_AbsI(y)); /* XQuads */ sides_vertices += 2 * CalcNumVertices(World.Length, Math_AbsI(y)); /* XQuads */
data = Gfx_CreateAndLockVb(VERTEX_FORMAT_P3FT2FC4B, sides_vertices, &sides_vb); data = Gfx_CreateAndLockVb(VERTEX_FORMAT_TEXTURED, sides_vertices, &sides_vb);
sides_fullBright = Blocks.FullBright[block]; sides_fullBright = Blocks.FullBright[block];
col = sides_fullBright ? white : Env.ShadowCol; col = sides_fullBright ? white : Env.ShadowCol;
@ -733,7 +733,7 @@ static void UpdateMapEdges(void) {
r = rects[i]; r = rects[i];
edges_vertices += CalcNumVertices(r.Width, r.Height); /* YPlanes outside */ edges_vertices += CalcNumVertices(r.Width, r.Height); /* YPlanes outside */
} }
data = Gfx_CreateAndLockVb(VERTEX_FORMAT_P3FT2FC4B, edges_vertices, &edges_vb); data = Gfx_CreateAndLockVb(VERTEX_FORMAT_TEXTURED, edges_vertices, &edges_vb);
edges_fullBright = Blocks.FullBright[block]; edges_fullBright = Blocks.FullBright[block];
col = edges_fullBright ? white : Env.SunCol; col = edges_fullBright ? white : Env.SunCol;
@ -778,7 +778,7 @@ static void UpdateAll(void) {
Gfx_DeleteDynamicVb(&weather_vb); Gfx_DeleteDynamicVb(&weather_vb);
if (Gfx.LostContext) return; if (Gfx.LostContext) return;
/* TODO: Don't allocate unless used? */ /* TODO: Don't allocate unless used? */
weather_vb = Gfx_CreateDynamicVb(VERTEX_FORMAT_P3FT2FC4B, WEATHER_VERTS_COUNT); weather_vb = Gfx_CreateDynamicVb(VERTEX_FORMAT_TEXTURED, WEATHER_VERTS_COUNT);
/* TODO: Don't need to do this on every new map */ /* TODO: Don't need to do this on every new map */
UpdateBorderTextures(); UpdateBorderTextures();
} }

134
src/Graphics.c
View File

@ -22,7 +22,7 @@ struct _GfxData Gfx;
GfxResourceID Gfx_defaultIb; GfxResourceID Gfx_defaultIb;
GfxResourceID Gfx_quadVb, Gfx_texVb; GfxResourceID Gfx_quadVb, Gfx_texVb;
static const int gfx_strideSizes[2] = { 16, 24 }; static const int strideSizes[2] = { SIZEOF_VERTEX_COLOURED, SIZEOF_VERTEX_TEXTURED };
static int gfx_batchStride, gfx_batchFormat = -1; static int gfx_batchStride, gfx_batchFormat = -1;
static cc_bool gfx_vsync, gfx_fogEnabled; static cc_bool gfx_vsync, gfx_fogEnabled;
@ -63,8 +63,8 @@ static void InitDefaultResources(void) {
MakeIndices(indices, GFX_MAX_INDICES); MakeIndices(indices, GFX_MAX_INDICES);
Gfx_defaultIb = Gfx_CreateIb(indices, GFX_MAX_INDICES); Gfx_defaultIb = Gfx_CreateIb(indices, GFX_MAX_INDICES);
Gfx_quadVb = Gfx_CreateDynamicVb(VERTEX_FORMAT_P3FC4B, 4); Gfx_quadVb = Gfx_CreateDynamicVb(VERTEX_FORMAT_COLOURED, 4);
Gfx_texVb = Gfx_CreateDynamicVb(VERTEX_FORMAT_P3FT2FC4B, 4); Gfx_texVb = Gfx_CreateDynamicVb(VERTEX_FORMAT_TEXTURED, 4);
} }
static void FreeDefaultResources(void) { static void FreeDefaultResources(void) {
@ -129,7 +129,7 @@ void Gfx_Draw2DFlat(int x, int y, int width, int height, PackedCol col) {
v->X = (float)(x + width); v->Y = (float)(y + height); v->Z = 0; v->Col = col; v++; v->X = (float)(x + width); v->Y = (float)(y + height); v->Z = 0; v->Col = col; v++;
v->X = (float)x; v->Y = (float)(y + height); v->Z = 0; v->Col = col; v++; v->X = (float)x; v->Y = (float)(y + height); v->Z = 0; v->Col = col; v++;
Gfx_SetVertexFormat(VERTEX_FORMAT_P3FC4B); Gfx_SetVertexFormat(VERTEX_FORMAT_COLOURED);
Gfx_UpdateDynamicVb_IndexedTris(Gfx_quadVb, verts, 4); Gfx_UpdateDynamicVb_IndexedTris(Gfx_quadVb, verts, 4);
} }
@ -142,7 +142,7 @@ void Gfx_Draw2DGradient(int x, int y, int width, int height, PackedCol top, Pack
v->X = (float)(x + width); v->Y = (float)(y + height); v->Z = 0; v->Col = bottom; v++; v->X = (float)(x + width); v->Y = (float)(y + height); v->Z = 0; v->Col = bottom; v++;
v->X = (float)x; v->Y = (float)(y + height); v->Z = 0; v->Col = bottom; v++; v->X = (float)x; v->Y = (float)(y + height); v->Z = 0; v->Col = bottom; v++;
Gfx_SetVertexFormat(VERTEX_FORMAT_P3FC4B); Gfx_SetVertexFormat(VERTEX_FORMAT_COLOURED);
Gfx_UpdateDynamicVb_IndexedTris(Gfx_quadVb, verts, 4); Gfx_UpdateDynamicVb_IndexedTris(Gfx_quadVb, verts, 4);
} }
@ -150,7 +150,7 @@ void Gfx_Draw2DTexture(const struct Texture* tex, PackedCol col) {
VertexP3fT2fC4b texVerts[4]; VertexP3fT2fC4b texVerts[4];
VertexP3fT2fC4b* ptr = texVerts; VertexP3fT2fC4b* ptr = texVerts;
Gfx_Make2DQuad(tex, col, &ptr); Gfx_Make2DQuad(tex, col, &ptr);
Gfx_SetVertexFormat(VERTEX_FORMAT_P3FT2FC4B); Gfx_SetVertexFormat(VERTEX_FORMAT_TEXTURED);
Gfx_UpdateDynamicVb_IndexedTris(Gfx_texVb, texVerts, 4); Gfx_UpdateDynamicVb_IndexedTris(Gfx_texVb, texVerts, 4);
} }
@ -720,7 +720,7 @@ void Gfx_DeleteIb(GfxResourceID* ib) { D3D9_FreeResource(ib); }
static IDirect3DVertexBuffer9* D3D9_AllocVertexBuffer(VertexFormat fmt, int count, DWORD usage) { static IDirect3DVertexBuffer9* D3D9_AllocVertexBuffer(VertexFormat fmt, int count, DWORD usage) {
IDirect3DVertexBuffer9* vbuffer; IDirect3DVertexBuffer9* vbuffer;
cc_result res; cc_result res;
int size = count * gfx_strideSizes[fmt]; int size = count * strideSizes[fmt];
for (;;) { for (;;) {
res = IDirect3DDevice9_CreateVertexBuffer(device, size, usage, res = IDirect3DDevice9_CreateVertexBuffer(device, size, usage,
@ -746,7 +746,7 @@ static void D3D9_SetVbData(IDirect3DVertexBuffer9* buffer, void* data, int size,
static void* D3D9_LockVb(GfxResourceID vb, VertexFormat fmt, int count, int lockFlags) { static void* D3D9_LockVb(GfxResourceID vb, VertexFormat fmt, int count, int lockFlags) {
IDirect3DVertexBuffer9* buffer = (IDirect3DVertexBuffer9*)vb; IDirect3DVertexBuffer9* buffer = (IDirect3DVertexBuffer9*)vb;
void* dst = NULL; void* dst = NULL;
int size = count * gfx_strideSizes[fmt]; int size = count * strideSizes[fmt];
cc_result res = IDirect3DVertexBuffer9_Lock(buffer, 0, size, &dst, lockFlags); cc_result res = IDirect3DVertexBuffer9_Lock(buffer, 0, size, &dst, lockFlags);
if (res) Logger_Abort2(res, "D3D9_LockVb"); if (res) Logger_Abort2(res, "D3D9_LockVb");
@ -782,7 +782,7 @@ void Gfx_SetVertexFormat(VertexFormat fmt) {
res = IDirect3DDevice9_SetFVF(device, d3d9_formatMappings[fmt]); res = IDirect3DDevice9_SetFVF(device, d3d9_formatMappings[fmt]);
if (res) Logger_Abort2(res, "D3D9_SetBatchFormat"); if (res) Logger_Abort2(res, "D3D9_SetBatchFormat");
gfx_batchStride = gfx_strideSizes[fmt]; gfx_batchStride = strideSizes[fmt];
} }
void Gfx_DrawVb_Lines(int verticesCount) { void Gfx_DrawVb_Lines(int verticesCount) {
@ -1254,7 +1254,7 @@ void Gfx_DeleteVb(GfxResourceID* vb) {
} }
void* Gfx_LockVb(GfxResourceID vb, VertexFormat fmt, int count) { void* Gfx_LockVb(GfxResourceID vb, VertexFormat fmt, int count) {
return FastAllocTempMem(count * gfx_strideSizes[fmt]); return FastAllocTempMem(count * strideSizes[fmt]);
} }
void Gfx_UnlockVb(GfxResourceID vb) { void Gfx_UnlockVb(GfxResourceID vb) {
@ -1293,7 +1293,7 @@ static int tmpCount;
void* Gfx_LockVb(GfxResourceID vb, VertexFormat fmt, int count) { void* Gfx_LockVb(GfxResourceID vb, VertexFormat fmt, int count) {
tmpFormat = fmt; tmpFormat = fmt;
tmpCount = count; tmpCount = count;
return FastAllocTempMem(count * gfx_strideSizes[fmt]); return FastAllocTempMem(count * strideSizes[fmt]);
} }
void Gfx_UnlockVb(GfxResourceID vb) { void Gfx_UnlockVb(GfxResourceID vb) {
@ -1318,13 +1318,13 @@ GfxResourceID Gfx_CreateDynamicVb(VertexFormat fmt, int maxVertices) {
if (Gfx.LostContext) return 0; if (Gfx.LostContext) return 0;
id = GL_GenAndBind(GL_ARRAY_BUFFER); id = GL_GenAndBind(GL_ARRAY_BUFFER);
size = maxVertices * gfx_strideSizes[fmt]; size = maxVertices * strideSizes[fmt];
_glBufferData(GL_ARRAY_BUFFER, size, NULL, GL_DYNAMIC_DRAW); _glBufferData(GL_ARRAY_BUFFER, size, NULL, GL_DYNAMIC_DRAW);
return id; return id;
} }
void* Gfx_LockDynamicVb(GfxResourceID vb, VertexFormat fmt, int count) { void* Gfx_LockDynamicVb(GfxResourceID vb, VertexFormat fmt, int count) {
return FastAllocTempMem(count * gfx_strideSizes[fmt]); return FastAllocTempMem(count * strideSizes[fmt]);
} }
void Gfx_UnlockDynamicVb(GfxResourceID vb) { void Gfx_UnlockDynamicVb(GfxResourceID vb) {
@ -1339,7 +1339,7 @@ void Gfx_SetDynamicVbData(GfxResourceID vb, void* vertices, int vCount) {
} }
#else #else
GfxResourceID Gfx_CreateDynamicVb(VertexFormat fmt, int maxVertices) { GfxResourceID Gfx_CreateDynamicVb(VertexFormat fmt, int maxVertices) {
return (GfxResourceID)Mem_Alloc(maxVertices, gfx_strideSizes[fmt], "creating dynamic vb"); return (GfxResourceID)Mem_Alloc(maxVertices, strideSizes[fmt], "creating dynamic vb");
} }
void Gfx_BindDynamicVb(GfxResourceID vb) { void Gfx_BindDynamicVb(GfxResourceID vb) {
@ -1691,7 +1691,7 @@ static void SwitchProgram(void) {
if (gfx_fogMode >= 1) index += 6; /* exp fog */ if (gfx_fogMode >= 1) index += 6; /* exp fog */
} }
if (gfx_batchFormat == VERTEX_FORMAT_P3FT2FC4B) index += 2; if (gfx_batchFormat == VERTEX_FORMAT_TEXTURED) index += 2;
if (gfx_texTransform) index += 2; if (gfx_texTransform) index += 2;
if (gfx_alphaTest) index += 1; if (gfx_alphaTest) index += 1;
@ -1789,43 +1789,43 @@ static void Gfx_RestoreState(void) {
} }
cc_bool Gfx_WarnIfNecessary(void) { return false; } cc_bool Gfx_WarnIfNecessary(void) { return false; }
static void GL_SetupVbPos3fCol4b(void) { static void GL_SetupVbColoured(void) {
glVertexAttribPointer(0, 3, GL_FLOAT, false, sizeof(VertexP3fC4b), (void*)0); glVertexAttribPointer(0, 3, GL_FLOAT, false, SIZEOF_VERTEX_COLOURED, (void*)0);
glVertexAttribPointer(1, 4, GL_UNSIGNED_BYTE, true, sizeof(VertexP3fC4b), (void*)12); glVertexAttribPointer(1, 4, GL_UNSIGNED_BYTE, true, SIZEOF_VERTEX_COLOURED, (void*)12);
} }
static void GL_SetupVbPos3fTex2fCol4b(void) { static void GL_SetupVbTextured(void) {
glVertexAttribPointer(0, 3, GL_FLOAT, false, sizeof(VertexP3fT2fC4b), (void*)0); glVertexAttribPointer(0, 3, GL_FLOAT, false, SIZEOF_VERTEX_TEXTURED, (void*)0);
glVertexAttribPointer(1, 4, GL_UNSIGNED_BYTE, true, sizeof(VertexP3fT2fC4b), (void*)12); glVertexAttribPointer(1, 4, GL_UNSIGNED_BYTE, true, SIZEOF_VERTEX_TEXTURED, (void*)12);
glVertexAttribPointer(2, 2, GL_FLOAT, false, sizeof(VertexP3fT2fC4b), (void*)16); glVertexAttribPointer(2, 2, GL_FLOAT, false, SIZEOF_VERTEX_TEXTURED, (void*)16);
} }
static void GL_SetupVbPos3fCol4b_Range(int startVertex) { static void GL_SetupVbColoured_Range(int startVertex) {
cc_uint32 offset = startVertex * (cc_uint32)sizeof(VertexP3fC4b); cc_uint32 offset = startVertex * SIZEOF_VERTEX_COLOURED;
glVertexAttribPointer(0, 3, GL_FLOAT, false, sizeof(VertexP3fC4b), (void*)(offset)); glVertexAttribPointer(0, 3, GL_FLOAT, false, SIZEOF_VERTEX_COLOURED, (void*)(offset));
glVertexAttribPointer(1, 4, GL_UNSIGNED_BYTE, true, sizeof(VertexP3fC4b), (void*)(offset + 12)); glVertexAttribPointer(1, 4, GL_UNSIGNED_BYTE, true, SIZEOF_VERTEX_COLOURED, (void*)(offset + 12));
} }
static void GL_SetupVbPos3fTex2fCol4b_Range(int startVertex) { static void GL_SetupVbTextured_Range(int startVertex) {
cc_uint32 offset = startVertex * (cc_uint32)sizeof(VertexP3fT2fC4b); cc_uint32 offset = startVertex * SIZEOF_VERTEX_TEXTURED;
glVertexAttribPointer(0, 3, GL_FLOAT, false, sizeof(VertexP3fT2fC4b), (void*)(offset)); glVertexAttribPointer(0, 3, GL_FLOAT, false, SIZEOF_VERTEX_TEXTURED, (void*)(offset));
glVertexAttribPointer(1, 4, GL_UNSIGNED_BYTE, true, sizeof(VertexP3fT2fC4b), (void*)(offset + 12)); glVertexAttribPointer(1, 4, GL_UNSIGNED_BYTE, true, SIZEOF_VERTEX_TEXTURED, (void*)(offset + 12));
glVertexAttribPointer(2, 2, GL_FLOAT, false, sizeof(VertexP3fT2fC4b), (void*)(offset + 16)); glVertexAttribPointer(2, 2, GL_FLOAT, false, SIZEOF_VERTEX_TEXTURED, (void*)(offset + 16));
} }
void Gfx_SetVertexFormat(VertexFormat fmt) { void Gfx_SetVertexFormat(VertexFormat fmt) {
if (fmt == gfx_batchFormat) return; if (fmt == gfx_batchFormat) return;
gfx_batchFormat = fmt; gfx_batchFormat = fmt;
gfx_batchStride = gfx_strideSizes[fmt]; gfx_batchStride = strideSizes[fmt];
if (fmt == VERTEX_FORMAT_P3FT2FC4B) { if (fmt == VERTEX_FORMAT_TEXTURED) {
glEnableVertexAttribArray(2); glEnableVertexAttribArray(2);
gfx_setupVBFunc = GL_SetupVbPos3fTex2fCol4b; gfx_setupVBFunc = GL_SetupVbTextured;
gfx_setupVBRangeFunc = GL_SetupVbPos3fTex2fCol4b_Range; gfx_setupVBRangeFunc = GL_SetupVbTextured_Range;
} else { } else {
glDisableVertexAttribArray(2); glDisableVertexAttribArray(2);
gfx_setupVBFunc = GL_SetupVbPos3fCol4b; gfx_setupVBFunc = GL_SetupVbColoured;
gfx_setupVBRangeFunc = GL_SetupVbPos3fCol4b_Range; gfx_setupVBRangeFunc = GL_SetupVbColoured_Range;
} }
SwitchProgram(); SwitchProgram();
} }
@ -1846,10 +1846,10 @@ void Gfx_DrawVb_IndexedTris(int verticesCount) {
} }
void Gfx_DrawIndexedVb_TrisT2fC4b(int verticesCount, int startVertex) { void Gfx_DrawIndexedVb_TrisT2fC4b(int verticesCount, int startVertex) {
cc_uint32 offset = startVertex * (cc_uint32)sizeof(VertexP3fT2fC4b); cc_uint32 offset = startVertex * SIZEOF_VERTEX_TEXTURED;
glVertexAttribPointer(0, 3, GL_FLOAT, false, sizeof(VertexP3fT2fC4b), (void*)(offset)); glVertexAttribPointer(0, 3, GL_FLOAT, false, SIZEOF_VERTEX_TEXTURED, (void*)(offset));
glVertexAttribPointer(1, 4, GL_UNSIGNED_BYTE, true, sizeof(VertexP3fT2fC4b), (void*)(offset + 12)); glVertexAttribPointer(1, 4, GL_UNSIGNED_BYTE, true, SIZEOF_VERTEX_TEXTURED, (void*)(offset + 12));
glVertexAttribPointer(2, 2, GL_FLOAT, false, sizeof(VertexP3fT2fC4b), (void*)(offset + 16)); glVertexAttribPointer(2, 2, GL_FLOAT, false, SIZEOF_VERTEX_TEXTURED, (void*)(offset + 16));
glDrawElements(GL_TRIANGLES, ICOUNT(verticesCount), GL_UNSIGNED_SHORT, NULL); glDrawElements(GL_TRIANGLES, ICOUNT(verticesCount), GL_UNSIGNED_SHORT, NULL);
} }
#endif #endif
@ -1956,43 +1956,43 @@ cc_bool Gfx_WarnIfNecessary(void) {
#define IB_PTR NULL #define IB_PTR NULL
#endif #endif
static void GL_SetupVbPos3fCol4b(void) { static void GL_SetupVbColoured(void) {
glVertexPointer(3, GL_FLOAT, sizeof(VertexP3fC4b), (void*)(VB_PTR + 0)); glVertexPointer(3, GL_FLOAT, SIZEOF_VERTEX_COLOURED, (void*)(VB_PTR + 0));
glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(VertexP3fC4b), (void*)(VB_PTR + 12)); glColorPointer(4, GL_UNSIGNED_BYTE, SIZEOF_VERTEX_COLOURED, (void*)(VB_PTR + 12));
} }
static void GL_SetupVbPos3fTex2fCol4b(void) { static void GL_SetupVbTextured(void) {
glVertexPointer(3, GL_FLOAT, sizeof(VertexP3fT2fC4b), (void*)(VB_PTR + 0)); glVertexPointer(3, GL_FLOAT, SIZEOF_VERTEX_TEXTURED, (void*)(VB_PTR + 0));
glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(VertexP3fT2fC4b), (void*)(VB_PTR + 12)); glColorPointer(4, GL_UNSIGNED_BYTE, SIZEOF_VERTEX_TEXTURED, (void*)(VB_PTR + 12));
glTexCoordPointer(2, GL_FLOAT, sizeof(VertexP3fT2fC4b), (void*)(VB_PTR + 16)); glTexCoordPointer(2, GL_FLOAT, SIZEOF_VERTEX_TEXTURED, (void*)(VB_PTR + 16));
} }
static void GL_SetupVbPos3fCol4b_Range(int startVertex) { static void GL_SetupVbColoured_Range(int startVertex) {
cc_uint32 offset = startVertex * (cc_uint32)sizeof(VertexP3fC4b); cc_uint32 offset = startVertex * SIZEOF_VERTEX_COLOURED;
glVertexPointer(3, GL_FLOAT, sizeof(VertexP3fC4b), (void*)(VB_PTR + offset)); glVertexPointer(3, GL_FLOAT, SIZEOF_VERTEX_COLOURED, (void*)(VB_PTR + offset));
glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(VertexP3fC4b), (void*)(VB_PTR + offset + 12)); glColorPointer(4, GL_UNSIGNED_BYTE, SIZEOF_VERTEX_COLOURED, (void*)(VB_PTR + offset + 12));
} }
static void GL_SetupVbPos3fTex2fCol4b_Range(int startVertex) { static void GL_SetupVbTextured_Range(int startVertex) {
cc_uint32 offset = startVertex * (cc_uint32)sizeof(VertexP3fT2fC4b); cc_uint32 offset = startVertex * SIZEOF_VERTEX_TEXTURED;
glVertexPointer(3, GL_FLOAT, sizeof(VertexP3fT2fC4b), (void*)(VB_PTR + offset)); glVertexPointer(3, GL_FLOAT, SIZEOF_VERTEX_TEXTURED, (void*)(VB_PTR + offset));
glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(VertexP3fT2fC4b), (void*)(VB_PTR + offset + 12)); glColorPointer(4, GL_UNSIGNED_BYTE, SIZEOF_VERTEX_TEXTURED, (void*)(VB_PTR + offset + 12));
glTexCoordPointer(2, GL_FLOAT, sizeof(VertexP3fT2fC4b), (void*)(VB_PTR + offset + 16)); glTexCoordPointer(2, GL_FLOAT, SIZEOF_VERTEX_TEXTURED, (void*)(VB_PTR + offset + 16));
} }
void Gfx_SetVertexFormat(VertexFormat fmt) { void Gfx_SetVertexFormat(VertexFormat fmt) {
if (fmt == gfx_batchFormat) return; if (fmt == gfx_batchFormat) return;
gfx_batchFormat = fmt; gfx_batchFormat = fmt;
gfx_batchStride = gfx_strideSizes[fmt]; gfx_batchStride = strideSizes[fmt];
if (fmt == VERTEX_FORMAT_P3FT2FC4B) { if (fmt == VERTEX_FORMAT_TEXTURED) {
glEnableClientState(GL_TEXTURE_COORD_ARRAY); glEnableClientState(GL_TEXTURE_COORD_ARRAY);
gfx_setupVBFunc = GL_SetupVbPos3fTex2fCol4b; gfx_setupVBFunc = GL_SetupVbTextured;
gfx_setupVBRangeFunc = GL_SetupVbPos3fTex2fCol4b_Range; gfx_setupVBRangeFunc = GL_SetupVbTextured_Range;
} else { } else {
glDisableClientState(GL_TEXTURE_COORD_ARRAY); glDisableClientState(GL_TEXTURE_COORD_ARRAY);
gfx_setupVBFunc = GL_SetupVbPos3fCol4b; gfx_setupVBFunc = GL_SetupVbColoured;
gfx_setupVBRangeFunc = GL_SetupVbPos3fCol4b_Range; gfx_setupVBRangeFunc = GL_SetupVbColoured_Range;
} }
} }
@ -2019,10 +2019,10 @@ void Gfx_DrawVb_IndexedTris(int verticesCount) {
#ifndef CC_BUILD_GL11 #ifndef CC_BUILD_GL11
void Gfx_DrawIndexedVb_TrisT2fC4b(int verticesCount, int startVertex) { void Gfx_DrawIndexedVb_TrisT2fC4b(int verticesCount, int startVertex) {
cc_uint32 offset = startVertex * (cc_uint32)sizeof(VertexP3fT2fC4b); cc_uint32 offset = startVertex * SIZEOF_VERTEX_TEXTURED;
glVertexPointer(3, GL_FLOAT, sizeof(VertexP3fT2fC4b), (void*)(offset)); glVertexPointer(3, GL_FLOAT, SIZEOF_VERTEX_TEXTURED, (void*)(offset));
glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(VertexP3fT2fC4b), (void*)(offset + 12)); glColorPointer(4, GL_UNSIGNED_BYTE, SIZEOF_VERTEX_TEXTURED, (void*)(offset + 12));
glTexCoordPointer(2, GL_FLOAT, sizeof(VertexP3fT2fC4b), (void*)(offset + 16)); glTexCoordPointer(2, GL_FLOAT, SIZEOF_VERTEX_TEXTURED, (void*)(offset + 16));
glDrawElements(GL_TRIANGLES, ICOUNT(verticesCount), GL_UNSIGNED_SHORT, NULL); glDrawElements(GL_TRIANGLES, ICOUNT(verticesCount), GL_UNSIGNED_SHORT, NULL);
} }

5
src/Graphics.h
View File

@ -11,7 +11,7 @@
struct Stream; struct Stream;
typedef enum VertexFormat_ { typedef enum VertexFormat_ {
VERTEX_FORMAT_P3FC4B, VERTEX_FORMAT_P3FT2FC4B VERTEX_FORMAT_COLOURED, VERTEX_FORMAT_TEXTURED
} VertexFormat; } VertexFormat;
typedef enum FogFunc_ { typedef enum FogFunc_ {
FOG_LINEAR, FOG_EXP, FOG_EXP2 FOG_LINEAR, FOG_EXP, FOG_EXP2
@ -20,6 +20,9 @@ typedef enum MatrixType_ {
MATRIX_PROJECTION, MATRIX_VIEW, MATRIX_TEXTURE MATRIX_PROJECTION, MATRIX_VIEW, MATRIX_TEXTURE
} MatrixType; } MatrixType;
#define SIZEOF_VERTEX_TEXTURED 24
#define SIZEOF_VERTEX_COLOURED 16
void Gfx_Init(void); void Gfx_Init(void);
void Gfx_Free(void); void Gfx_Free(void);

4
src/MapRenderer.c
View File

@ -189,7 +189,7 @@ void MapRenderer_RenderNormal(double delta) {
int batch; int batch;
if (!mapChunks) return; if (!mapChunks) return;
Gfx_SetVertexFormat(VERTEX_FORMAT_P3FT2FC4B); Gfx_SetVertexFormat(VERTEX_FORMAT_TEXTURED);
Gfx_SetTexturing(true); Gfx_SetTexturing(true);
Gfx_SetAlphaTest(true); Gfx_SetAlphaTest(true);
@ -266,7 +266,7 @@ void MapRenderer_RenderTranslucent(double delta) {
/* First fill depth buffer */ /* First fill depth buffer */
vertices = Game_Vertices; vertices = Game_Vertices;
Gfx_SetVertexFormat(VERTEX_FORMAT_P3FT2FC4B); Gfx_SetVertexFormat(VERTEX_FORMAT_TEXTURED);
Gfx_SetTexturing(false); Gfx_SetTexturing(false);
Gfx_SetAlphaBlending(false); Gfx_SetAlphaBlending(false);
Gfx_SetColWriteMask(false, false, false, false); Gfx_SetColWriteMask(false, false, false, false);

4
src/Menus.c
View File

@ -3092,7 +3092,7 @@ static void TexIdsOverlay_BuildMesh(void* screen) {
VertexP3fT2fC4b* data; VertexP3fT2fC4b* data;
VertexP3fT2fC4b** ptr; VertexP3fT2fC4b** ptr;
data = (VertexP3fT2fC4b*)Gfx_LockDynamicVb(s->vb, VERTEX_FORMAT_P3FT2FC4B, s->maxVertices); data = (VertexP3fT2fC4b*)Gfx_LockDynamicVb(s->vb, VERTEX_FORMAT_TEXTURED, s->maxVertices);
ptr = &data; ptr = &data;
Widget_BuildMesh(&s->title, ptr); Widget_BuildMesh(&s->title, ptr);
@ -3142,7 +3142,7 @@ static void TexIdsOverlay_Render(void* screen, double delta) {
Menu_RenderBounds(); Menu_RenderBounds();
Gfx_SetTexturing(true); Gfx_SetTexturing(true);
Gfx_SetVertexFormat(VERTEX_FORMAT_P3FT2FC4B); Gfx_SetVertexFormat(VERTEX_FORMAT_TEXTURED);
Gfx_BindDynamicVb(s->vb); Gfx_BindDynamicVb(s->vb);
offset = Widget_Render2(&s->title, offset); offset = Widget_Render2(&s->title, offset);

6
src/Model.c
View File

@ -99,7 +99,7 @@ void Model_Render(struct Model* model, struct Entity* entity) {
if (model->bobbing) pos.Y += entity->Anim.BobbingModel; if (model->bobbing) pos.Y += entity->Anim.BobbingModel;
Model_SetupState(model, entity); Model_SetupState(model, entity);
Gfx_SetVertexFormat(VERTEX_FORMAT_P3FT2FC4B); Gfx_SetVertexFormat(VERTEX_FORMAT_TEXTURED);
model->GetTransform(entity, pos, &entity->Transform); model->GetTransform(entity, pos, &entity->Transform);
Matrix_Mul(&m, &entity->Transform, &Gfx.View); Matrix_Mul(&m, &entity->Transform, &Gfx.View);
@ -246,7 +246,7 @@ void Model_RenderArm(struct Model* model, struct Entity* entity) {
if (model->bobbing) pos.Y += entity->Anim.BobbingModel; if (model->bobbing) pos.Y += entity->Anim.BobbingModel;
Model_SetupState(model, entity); Model_SetupState(model, entity);
Gfx_SetVertexFormat(VERTEX_FORMAT_P3FT2FC4B); Gfx_SetVertexFormat(VERTEX_FORMAT_TEXTURED);
Model_ApplyTexture(entity); Model_ApplyTexture(entity);
if (Models.ClassicArms) { if (Models.ClassicArms) {
@ -377,7 +377,7 @@ static void Models_ContextLost(void* obj) {
} }
static void Models_ContextRecreated(void* obj) { static void Models_ContextRecreated(void* obj) {
Models.Vb = Gfx_CreateDynamicVb(VERTEX_FORMAT_P3FT2FC4B, Models.MaxVertices); Models.Vb = Gfx_CreateDynamicVb(VERTEX_FORMAT_TEXTURED, Models.MaxVertices);
} }
static void MakeModel(struct Model* model) { static void MakeModel(struct Model* model) {

10
src/Particle.c
View File

@ -160,7 +160,7 @@ static void Rain_Render(float t) {
int i; int i;
if (!rain_count) return; if (!rain_count) return;
data = (VertexP3fT2fC4b*)Gfx_LockDynamicVb(Particles_VB, VERTEX_FORMAT_P3FT2FC4B, rain_count * 4); data = (VertexP3fT2fC4b*)Gfx_LockDynamicVb(Particles_VB, VERTEX_FORMAT_TEXTURED, rain_count * 4);
for (i = 0; i < rain_count; i++) { for (i = 0; i < rain_count; i++) {
RainParticle_Render(&rain_Particles[i], t, data); RainParticle_Render(&rain_Particles[i], t, data);
data += 4; data += 4;
@ -253,7 +253,7 @@ static void Terrain_Render(float t) {
int i, index; int i, index;
if (!terrain_count) return; if (!terrain_count) return;
data = (VertexP3fT2fC4b*)Gfx_LockDynamicVb(Particles_VB, VERTEX_FORMAT_P3FT2FC4B, terrain_count * 4); data = (VertexP3fT2fC4b*)Gfx_LockDynamicVb(Particles_VB, VERTEX_FORMAT_TEXTURED, terrain_count * 4);
Terrain_Update1DCounts(); Terrain_Update1DCounts();
for (i = 0; i < terrain_count; i++) { for (i = 0; i < terrain_count; i++) {
index = Atlas1D_Index(terrain_particles[i].texLoc); index = Atlas1D_Index(terrain_particles[i].texLoc);
@ -358,7 +358,7 @@ static void Custom_Render(float t) {
int i; int i;
if (!custom_count) return; if (!custom_count) return;
data = (VertexP3fT2fC4b*)Gfx_LockDynamicVb(Particles_VB, VERTEX_FORMAT_P3FT2FC4B, custom_count * 4); data = (VertexP3fT2fC4b*)Gfx_LockDynamicVb(Particles_VB, VERTEX_FORMAT_TEXTURED, custom_count * 4);
for (i = 0; i < custom_count; i++) { for (i = 0; i < custom_count; i++) {
CustomParticle_Render(&custom_particles[i], t, data); CustomParticle_Render(&custom_particles[i], t, data);
data += 4; data += 4;
@ -396,7 +396,7 @@ void Particles_Render(float t) {
Gfx_SetTexturing(true); Gfx_SetTexturing(true);
Gfx_SetAlphaTest(true); Gfx_SetAlphaTest(true);
Gfx_SetVertexFormat(VERTEX_FORMAT_P3FT2FC4B); Gfx_SetVertexFormat(VERTEX_FORMAT_TEXTURED);
Terrain_Render(t); Terrain_Render(t);
Rain_Render(t); Rain_Render(t);
Custom_Render(t); Custom_Render(t);
@ -573,7 +573,7 @@ static void OnContextLost(void* obj) {
Gfx_DeleteDynamicVb(&Particles_VB); Gfx_DeleteDynamicVb(&Particles_VB);
} }
static void OnContextRecreated(void* obj) { static void OnContextRecreated(void* obj) {
Particles_VB = Gfx_CreateDynamicVb(VERTEX_FORMAT_P3FT2FC4B, PARTICLES_MAX * 4); Particles_VB = Gfx_CreateDynamicVb(VERTEX_FORMAT_TEXTURED, PARTICLES_MAX * 4);
} }
static void OnBreakBlockEffect_Handler(void* obj, IVec3 coords, BlockID old, BlockID now) { static void OnBreakBlockEffect_Handler(void* obj, IVec3 coords, BlockID old, BlockID now) {
Particles_BreakBlockEffect(coords, old, now); Particles_BreakBlockEffect(coords, old, now);

6
src/PickedPosRenderer.c
View File

@ -75,7 +75,7 @@ static void BuildMesh(struct RayTracer* selected) {
Vec3_Add1(&coords[3], &selected->Max, offset); Vec3_Add1(&coords[3], &selected->Max, offset);
Vec3_Add1(&coords[2], &coords[3], -size); Vec3_Add1(&coords[2], &coords[3], -size);
ptr = (VertexP3fC4b*)Gfx_LockDynamicVb(pickedPos_vb, VERTEX_FORMAT_P3FC4B, PICKEDPOS_NUM_VERTICES); ptr = (VertexP3fC4b*)Gfx_LockDynamicVb(pickedPos_vb, VERTEX_FORMAT_COLOURED, PICKEDPOS_NUM_VERTICES);
for (i = 0; i < Array_Elems(indices); i += 3, ptr++) { for (i = 0; i < Array_Elems(indices); i += 3, ptr++) {
ptr->X = coords[indices[i + 0]].X; ptr->X = coords[indices[i + 0]].X;
ptr->Y = coords[indices[i + 1]].Y; ptr->Y = coords[indices[i + 1]].Y;
@ -90,7 +90,7 @@ void PickedPosRenderer_Render(struct RayTracer* selected, cc_bool dirty) {
Gfx_SetAlphaBlending(true); Gfx_SetAlphaBlending(true);
Gfx_SetDepthWrite(false); Gfx_SetDepthWrite(false);
Gfx_SetVertexFormat(VERTEX_FORMAT_P3FC4B); Gfx_SetVertexFormat(VERTEX_FORMAT_COLOURED);
if (dirty) BuildMesh(selected); if (dirty) BuildMesh(selected);
else Gfx_BindDynamicVb(pickedPos_vb); else Gfx_BindDynamicVb(pickedPos_vb);
@ -109,7 +109,7 @@ static void OnContextLost(void* obj) {
} }
static void OnContextRecreated(void* obj) { static void OnContextRecreated(void* obj) {
pickedPos_vb = Gfx_CreateDynamicVb(VERTEX_FORMAT_P3FC4B, PICKEDPOS_NUM_VERTICES); pickedPos_vb = Gfx_CreateDynamicVb(VERTEX_FORMAT_COLOURED, PICKEDPOS_NUM_VERTICES);
} }
static void PickedPosRenderer_Init(void) { static void PickedPosRenderer_Init(void) {

8
src/Screens.c
View File

@ -67,7 +67,7 @@ void Screen_Render2Widgets(void* screen, double delta) {
struct Widget** widgets = s->widgets; struct Widget** widgets = s->widgets;
int i, offset = 0; int i, offset = 0;
Gfx_SetVertexFormat(VERTEX_FORMAT_P3FT2FC4B); Gfx_SetVertexFormat(VERTEX_FORMAT_TEXTURED);
Gfx_BindDynamicVb(s->vb); Gfx_BindDynamicVb(s->vb);
for (i = 0; i < s->numWidgets; i++) { for (i = 0; i < s->numWidgets; i++) {
@ -101,7 +101,7 @@ void Screen_ContextLost(void* screen) {
void Screen_CreateVb(void* screen) { void Screen_CreateVb(void* screen) {
struct Screen* s = (struct Screen*)screen; struct Screen* s = (struct Screen*)screen;
s->vb = Gfx_CreateDynamicVb(VERTEX_FORMAT_P3FT2FC4B, s->maxVertices); s->vb = Gfx_CreateDynamicVb(VERTEX_FORMAT_TEXTURED, s->maxVertices);
} }
void Screen_BuildMesh(void* screen) { void Screen_BuildMesh(void* screen) {
@ -111,7 +111,7 @@ void Screen_BuildMesh(void* screen) {
VertexP3fT2fC4b** ptr; VertexP3fT2fC4b** ptr;
int i; int i;
data = (VertexP3fT2fC4b*)Gfx_LockDynamicVb(s->vb, VERTEX_FORMAT_P3FT2FC4B, s->maxVertices); data = (VertexP3fT2fC4b*)Gfx_LockDynamicVb(s->vb, VERTEX_FORMAT_TEXTURED, s->maxVertices);
ptr = &data; ptr = &data;
for (i = 0; i < s->numWidgets; i++) { for (i = 0; i < s->numWidgets; i++) {
@ -1588,7 +1588,7 @@ static void LoadingScreen_UpdateBackgroundVB(VertexP3fT2fC4b* vertices, int coun
Gfx_BindTexture(Atlas1D.TexIds[atlasIndex]); Gfx_BindTexture(Atlas1D.TexIds[atlasIndex]);
} }
Gfx_SetVertexFormat(VERTEX_FORMAT_P3FT2FC4B); Gfx_SetVertexFormat(VERTEX_FORMAT_TEXTURED);
/* TODO: Do we need to use a separate VB here? */ /* TODO: Do we need to use a separate VB here? */
Gfx_UpdateDynamicVb_IndexedTris(Models.Vb, vertices, count); Gfx_UpdateDynamicVb_IndexedTris(Models.Vb, vertices, count);
} }

10
src/SelectionBox.c
View File

@ -144,8 +144,8 @@ static void Selections_ContextLost(void* obj) {
static void Selections_ContextRecreated(void* obj) { static void Selections_ContextRecreated(void* obj) {
if (!selections_used) return; if (!selections_used) return;
selections_VB = Gfx_CreateDynamicVb(VERTEX_FORMAT_P3FC4B, SELECTIONS_MAX_VERTICES); selections_VB = Gfx_CreateDynamicVb(VERTEX_FORMAT_COLOURED, SELECTIONS_MAX_VERTICES);
selections_LineVB = Gfx_CreateDynamicVb(VERTEX_FORMAT_P3FC4B, SELECTIONS_MAX_VERTICES); selections_LineVB = Gfx_CreateDynamicVb(VERTEX_FORMAT_COLOURED, SELECTIONS_MAX_VERTICES);
} }
static void Selections_QuickSort(int left, int right) { static void Selections_QuickSort(int left, int right) {
@ -186,16 +186,16 @@ void Selections_Render(void) {
Selections_ContextRecreated(NULL); Selections_ContextRecreated(NULL);
} }
count = selections_count * SELECTIONS_VERTICES; count = selections_count * SELECTIONS_VERTICES;
Gfx_SetVertexFormat(VERTEX_FORMAT_P3FC4B); Gfx_SetVertexFormat(VERTEX_FORMAT_COLOURED);
data = (VertexP3fC4b*)Gfx_LockDynamicVb(selections_LineVB, VERTEX_FORMAT_P3FC4B, count); data = (VertexP3fC4b*)Gfx_LockDynamicVb(selections_LineVB, VERTEX_FORMAT_COLOURED, count);
for (i = 0; i < selections_count; i++, data += SELECTIONS_VERTICES) { for (i = 0; i < selections_count; i++, data += SELECTIONS_VERTICES) {
SelectionBox_RenderEdges(&selections_list[i], data); SelectionBox_RenderEdges(&selections_list[i], data);
} }
Gfx_UnlockDynamicVb(selections_LineVB); Gfx_UnlockDynamicVb(selections_LineVB);
Gfx_DrawVb_Lines(count); Gfx_DrawVb_Lines(count);
data = (VertexP3fC4b*)Gfx_LockDynamicVb(selections_VB, VERTEX_FORMAT_P3FC4B, count); data = (VertexP3fC4b*)Gfx_LockDynamicVb(selections_VB, VERTEX_FORMAT_COLOURED, count);
for (i = 0; i < selections_count; i++, data += SELECTIONS_VERTICES) { for (i = 0; i < selections_count; i++, data += SELECTIONS_VERTICES) {
SelectionBox_RenderFaces(&selections_list[i], data); SelectionBox_RenderFaces(&selections_list[i], data);
} }

4
src/Widgets.c
View File

@ -680,7 +680,7 @@ static void TableWidget_Render(void* widget, double delta) {
size, size, topSelCol, bottomSelCol); size, size, topSelCol, bottomSelCol);
} }
Gfx_SetTexturing(true); Gfx_SetTexturing(true);
Gfx_SetVertexFormat(VERTEX_FORMAT_P3FT2FC4B); Gfx_SetVertexFormat(VERTEX_FORMAT_TEXTURED);
IsometricDrawer_BeginBatch(vertices, w->vb); IsometricDrawer_BeginBatch(vertices, w->vb);
for (i = 0; i < w->blocksCount; i++) { for (i = 0; i < w->blocksCount; i++) {
@ -715,7 +715,7 @@ static void TableWidget_Free(void* widget) {
void TableWidget_Recreate(struct TableWidget* w) { void TableWidget_Recreate(struct TableWidget* w) {
Elem_TryFree(w); Elem_TryFree(w);
w->vb = Gfx_CreateDynamicVb(VERTEX_FORMAT_P3FT2FC4B, TABLE_MAX_VERTICES); w->vb = Gfx_CreateDynamicVb(VERTEX_FORMAT_TEXTURED, TABLE_MAX_VERTICES);
TableWidget_RecreateDescTex(w); TableWidget_RecreateDescTex(w);
} }