From cd2d70bd8cca84d807f013379585cb2eeab99662 Mon Sep 17 00:00:00 2001 From: UnknownShadow200 Date: Sat, 24 Nov 2018 11:45:02 +1100 Subject: [PATCH] Combine Graphics/GraphicsCommon --- src/AxisLinesRenderer.c | 5 +- src/Bitmap.c | 1 + src/Chat.c | 1 - src/ClassiCube.vcxproj | 2 - src/ClassiCube.vcxproj.filters | 6 - src/Core.h | 7 + src/Drawer2D.c | 1 - src/Entity.c | 7 +- src/Entity.h | 2 +- src/EntityComponents.c | 5 +- src/EnvRenderer.c | 17 +- src/Game.c | 3 +- src/Graphics.c | 281 ++++++++++++++++++++++++++++++--- src/Graphics.h | 124 ++++++++++++++- src/GraphicsCommon.c | 242 ---------------------------- src/GraphicsCommon.h | 56 ------- src/Gui.c | 7 +- src/Gui.h | 2 +- src/HeldBlockRenderer.c | 5 +- src/IsometricDrawer.c | 3 +- src/MapRenderer.c | 4 +- src/Menus.c | 19 ++- src/Model.c | 7 +- src/Particle.c | 5 +- src/PickedPosRenderer.c | 5 +- src/Screens.c | 19 ++- src/SelectionBox.c | 7 +- src/Widgets.c | 29 ++-- 28 files changed, 456 insertions(+), 416 deletions(-) delete mode 100644 src/GraphicsCommon.c delete mode 100644 src/GraphicsCommon.h diff --git a/src/AxisLinesRenderer.c b/src/AxisLinesRenderer.c index 202e0f8e4..613f797fc 100644 --- a/src/AxisLinesRenderer.c +++ b/src/AxisLinesRenderer.c @@ -1,7 +1,6 @@ #include "AxisLinesRenderer.h" #include "Graphics.h" #include "Game.h" -#include "GraphicsCommon.h" #include "SelectionBox.h" #include "PackedCol.h" #include "Camera.h" @@ -71,6 +70,6 @@ void AxisLinesRenderer_Render(double delta) { ptr->Col = cols[i >> 2]; } - Gfx_SetBatchFormat(VERTEX_FORMAT_P3FC4B); - GfxCommon_UpdateDynamicVb_IndexedTris(axisLines_vb, vertices, count); + Gfx_SetVertexFormat(VERTEX_FORMAT_P3FC4B); + Gfx_UpdateDynamicVb_IndexedTris(axisLines_vb, vertices, count); } diff --git a/src/Bitmap.c b/src/Bitmap.c index e456cf349..e8b402ae3 100644 --- a/src/Bitmap.c +++ b/src/Bitmap.c @@ -320,6 +320,7 @@ static void Png_ComputeTransparency(Bitmap* bmp, BitmapCol col) { /* Most bits per sample is 16. Most samples per pixel is 4. Add 1 for filter byte. */ /* Need to store both current and prior row, per PNG specification. */ #define PNG_BUFFER_SIZE ((PNG_MAX_DIMS * 2 * 4 + 1) * 2) + /* TODO: Test a lot of .png files and ensure output is right */ ReturnCode Png_Decode(Bitmap* bmp, struct Stream* stream) { uint8_t tmp[PNG_PALETTE * 3]; diff --git a/src/Chat.c b/src/Chat.c index 76634cb5f..ddeaf0b8a 100644 --- a/src/Chat.c +++ b/src/Chat.c @@ -10,7 +10,6 @@ #include "Entity.h" #include "Window.h" #include "Graphics.h" -#include "GraphicsCommon.h" #include "Funcs.h" #include "Block.h" #include "EnvRenderer.h" diff --git a/src/ClassiCube.vcxproj b/src/ClassiCube.vcxproj index c0f290b7f..707102fcb 100644 --- a/src/ClassiCube.vcxproj +++ b/src/ClassiCube.vcxproj @@ -239,7 +239,6 @@ - @@ -286,7 +285,6 @@ - diff --git a/src/ClassiCube.vcxproj.filters b/src/ClassiCube.vcxproj.filters index faba2819b..0917ef396 100644 --- a/src/ClassiCube.vcxproj.filters +++ b/src/ClassiCube.vcxproj.filters @@ -141,9 +141,6 @@ Header Files\Math - - Header Files\Graphics - Header Files\Graphics @@ -320,9 +317,6 @@ Source Files\Math - - Source Files\Graphics - Source Files\Math diff --git a/src/Core.h b/src/Core.h index b79ede10e..fbd14b37b 100644 --- a/src/Core.h +++ b/src/Core.h @@ -105,4 +105,11 @@ typedef void* GfxResourceID; typedef uint32_t GfxResourceID; #define GFX_NULL 0 #endif + +/* Contains the information to describe a 2D textured quad. */ +struct Texture { + GfxResourceID ID; + int16_t X, Y; uint16_t Width, Height; + TextureRec uv; +}; #endif diff --git a/src/Drawer2D.c b/src/Drawer2D.c index 9857d851d..4b3e3882d 100644 --- a/src/Drawer2D.c +++ b/src/Drawer2D.c @@ -4,7 +4,6 @@ #include "Platform.h" #include "ExtMath.h" #include "ErrorHandler.h" -#include "GraphicsCommon.h" #include "Bitmap.h" #include "Game.h" diff --git a/src/Entity.c b/src/Entity.c index ced780f89..f71d1bbf9 100644 --- a/src/Entity.c +++ b/src/Entity.c @@ -11,7 +11,6 @@ #include "Lighting.h" #include "Drawer2D.h" #include "Particle.h" -#include "GraphicsCommon.h" #include "AsyncDownloader.h" #include "Chat.h" #include "Model.h" @@ -388,7 +387,7 @@ void Entities_DrawShadows(void) { Gfx_SetAlphaBlending(true); Gfx_SetTexturing(true); - Gfx_SetBatchFormat(VERTEX_FORMAT_P3FT2FC4B); + Gfx_SetVertexFormat(VERTEX_FORMAT_P3FT2FC4B); ShadowComponent_Draw(Entities_List[ENTITIES_SELF_ID]); if (Entities_ShadowMode == SHADOW_MODE_CIRCLE_ALL) { @@ -558,8 +557,8 @@ static void Player_DrawName(struct Player* p) { } Particle_DoRender(&size, &pos, &p->NameTex.uv, col, vertices); - Gfx_SetBatchFormat(VERTEX_FORMAT_P3FT2FC4B); - GfxCommon_UpdateDynamicVb_IndexedTris(GfxCommon_texVb, vertices, 4); + Gfx_SetVertexFormat(VERTEX_FORMAT_P3FT2FC4B); + Gfx_UpdateDynamicVb_IndexedTris(Gfx_texVb, vertices, 4); } static struct Player* Player_FirstOtherWithSameSkin(struct Player* player) { diff --git a/src/Entity.h b/src/Entity.h index 606fcaf48..7c6db3da0 100644 --- a/src/Entity.h +++ b/src/Entity.h @@ -3,8 +3,8 @@ #include "EntityComponents.h" #include "Physics.h" #include "Constants.h" -#include "GraphicsCommon.h" #include "Input.h" +#include "PackedCol.h" /* Represents an in-game entity. Copyright 2014-2017 ClassicalSharp | Licensed under BSD-3 */ diff --git a/src/EntityComponents.c b/src/EntityComponents.c index c396fd7f0..6a72bcbd6 100644 --- a/src/EntityComponents.c +++ b/src/EntityComponents.c @@ -10,7 +10,6 @@ #include "Funcs.h" #include "VertexStructs.h" #include "Graphics.h" -#include "GraphicsCommon.h" #include "Physics.h" #include "Model.h" #include "Audio.h" @@ -642,7 +641,7 @@ void ShadowComponent_Draw(struct Entity* e) { /* TODO: Should shadow component use its own VB? */ ptr = vertices; if (Entities_ShadowMode == SHADOW_MODE_SNAP_TO_BLOCK) { - vb = GfxCommon_texVb; + vb = Gfx_texVb; x1 = Math_Floor(pos.X); z1 = Math_Floor(pos.Z); if (!ShadowComponent_GetBlocks(e, x1, y, z1, data)) return; @@ -675,7 +674,7 @@ void ShadowComponent_Draw(struct Entity* e) { } count = (int)(ptr - vertices); - GfxCommon_UpdateDynamicVb_IndexedTris(vb, vertices, count); + Gfx_UpdateDynamicVb_IndexedTris(vb, vertices, count); } diff --git a/src/EnvRenderer.c b/src/EnvRenderer.c index 629ed1a5e..2070554db 100644 --- a/src/EnvRenderer.c +++ b/src/EnvRenderer.c @@ -12,7 +12,6 @@ #include "ErrorHandler.h" #include "Stream.h" #include "Block.h" -#include "GraphicsCommon.h" #include "Event.h" #include "TerrainAtlas.h" #include "Platform.h" @@ -143,7 +142,7 @@ void EnvRenderer_RenderClouds(double deltaTime) { Gfx_SetAlphaTest(true); Gfx_SetTexturing(true); Gfx_BindTexture(clouds_tex); - Gfx_SetBatchFormat(VERTEX_FORMAT_P3FT2FC4B); + Gfx_SetVertexFormat(VERTEX_FORMAT_P3FT2FC4B); Gfx_BindVb(clouds_vb); Gfx_DrawVb_IndexedTris(clouds_vertices); Gfx_SetAlphaTest(false); @@ -221,7 +220,7 @@ void EnvRenderer_RenderSky(double deltaTime) { normY = (float)World_Height + 8.0f; skyY = max(Camera_CurrentPos.Y + 8.0f, normY); - Gfx_SetBatchFormat(VERTEX_FORMAT_P3FC4B); + Gfx_SetVertexFormat(VERTEX_FORMAT_P3FC4B); Gfx_BindVb(sky_vb); if (skyY == normY) { @@ -303,7 +302,7 @@ void EnvRenderer_RenderSkybox(double deltaTime) { Gfx_SetDepthWrite(false); Gfx_SetTexturing(true); Gfx_BindTexture(skybox_tex); - Gfx_SetBatchFormat(VERTEX_FORMAT_P3FT2FC4B); + Gfx_SetVertexFormat(VERTEX_FORMAT_P3FT2FC4B); /* Base skybox rotation */ m = Matrix_Identity; @@ -527,9 +526,9 @@ void EnvRenderer_RenderWeather(double deltaTime) { Gfx_SetDepthWrite(false); Gfx_SetAlphaArgBlend(true); - Gfx_SetBatchFormat(VERTEX_FORMAT_P3FT2FC4B); + Gfx_SetVertexFormat(VERTEX_FORMAT_P3FT2FC4B); vCount = (int)(ptr - vertices); - GfxCommon_UpdateDynamicVb_IndexedTris(weather_vb, vertices, vCount); + Gfx_UpdateDynamicVb_IndexedTris(weather_vb, vertices, vCount); Gfx_SetAlphaArgBlend(false); Gfx_SetDepthWrite(true); @@ -549,16 +548,16 @@ void EnvRenderer_RenderBorders(BlockID block, GfxResourceID vb, GfxResourceID te if (!vb) return; Gfx_SetTexturing(true); - GfxCommon_SetupAlphaState(Block_Draw[block]); + Gfx_SetupAlphaState(Block_Draw[block]); Gfx_EnableMipmaps(); Gfx_BindTexture(tex); - Gfx_SetBatchFormat(VERTEX_FORMAT_P3FT2FC4B); + Gfx_SetVertexFormat(VERTEX_FORMAT_P3FT2FC4B); Gfx_BindVb(vb); Gfx_DrawVb_IndexedTris(count); Gfx_DisableMipmaps(); - GfxCommon_RestoreAlphaState(Block_Draw[block]); + Gfx_RestoreAlphaState(Block_Draw[block]); Gfx_SetTexturing(false); } diff --git a/src/Game.c b/src/Game.c index 351fbadb5..aaeb142c5 100644 --- a/src/Game.c +++ b/src/Game.c @@ -30,7 +30,6 @@ #include "EnvRenderer.h" #include "HeldBlockRenderer.h" #include "PickedPosRenderer.h" -#include "GraphicsCommon.h" #include "Menus.h" #include "Audio.h" #include "Stream.h" @@ -684,7 +683,7 @@ static void Game_RenderFrame(double delta) { frameStart = Stopwatch_Measure(); Gfx_BeginFrame(); - Gfx_BindIb(GfxCommon_defaultIb); + Gfx_BindIb(Gfx_defaultIb); Game_Accumulator += delta; Game_Vertices = 0; diff --git a/src/Graphics.c b/src/Graphics.c index b4407bc35..ad9801b1b 100644 --- a/src/Graphics.c +++ b/src/Graphics.c @@ -2,13 +2,13 @@ #include "ErrorHandler.h" #include "Platform.h" #include "Window.h" -#include "GraphicsCommon.h" #include "Funcs.h" #include "Chat.h" #include "Game.h" #include "ExtMath.h" -#include "Bitmap.h" #include "Event.h" +#include "Block.h" +#include "ExtMath.h" #define WIN32_LEAN_AND_MEAN #define NOSERVICE @@ -21,6 +21,245 @@ static int gfx_batchStride, gfx_batchFormat = -1; static bool gfx_vsync, gfx_fogEnabled; bool Gfx_GetFog(void) { return gfx_fogEnabled; } +/*########################################################################################################################* +*------------------------------------------------------Generic/Common-----------------------------------------------------* +*#########################################################################################################################*/ +static char Gfx_ApiBuffer[7][STRING_SIZE]; +String Gfx_ApiInfo[7] = { + String_FromArray(Gfx_ApiBuffer[0]), String_FromArray(Gfx_ApiBuffer[1]), + String_FromArray(Gfx_ApiBuffer[2]), String_FromArray(Gfx_ApiBuffer[3]), + String_FromArray(Gfx_ApiBuffer[4]), String_FromArray(Gfx_ApiBuffer[5]), + String_FromArray(Gfx_ApiBuffer[6]), +}; + +CC_NOINLINE static void Gfx_InitDefaultResources(void) { + uint16_t indices[GFX_MAX_INDICES]; + Gfx_MakeIndices(indices, GFX_MAX_INDICES); + Gfx_defaultIb = Gfx_CreateIb(indices, GFX_MAX_INDICES); + + Gfx_quadVb = Gfx_CreateDynamicVb(VERTEX_FORMAT_P3FC4B, 4); + Gfx_texVb = Gfx_CreateDynamicVb(VERTEX_FORMAT_P3FT2FC4B, 4); +} + +CC_NOINLINE static void Gfx_FreeDefaultResources(void) { + Gfx_DeleteVb(&Gfx_quadVb); + Gfx_DeleteVb(&Gfx_texVb); + Gfx_DeleteIb(&Gfx_defaultIb); +} + +void Gfx_LoseContext(const char* reason) { + Gfx_LostContext = true; + Platform_Log1("Lost graphics context: %c", reason); + + Event_RaiseVoid(&GfxEvents_ContextLost); + Gfx_FreeDefaultResources(); +} + +void Gfx_RecreateContext(void) { + Gfx_LostContext = false; + Platform_LogConst("Recreating graphics context"); + + Event_RaiseVoid(&GfxEvents_ContextRecreated); + Gfx_InitDefaultResources(); +} + + +void Gfx_UpdateDynamicVb_Lines(GfxResourceID vb, void* vertices, int vCount) { + Gfx_SetDynamicVbData(vb, vertices, vCount); + Gfx_DrawVb_Lines(vCount); +} + +void Gfx_UpdateDynamicVb_IndexedTris(GfxResourceID vb, void* vertices, int vCount) { + Gfx_SetDynamicVbData(vb, vertices, vCount); + Gfx_DrawVb_IndexedTris(vCount); +} + +void Gfx_Draw2DFlat(int x, int y, int width, int height, PackedCol col) { + VertexP3fC4b verts[4]; + VertexP3fC4b v; v.Z = 0.0f; v.Col = col; + + v.X = (float)x; v.Y = (float)y; verts[0] = v; + v.X = (float)(x + width); verts[1] = v; + v.Y = (float)(y + height); verts[2] = v; + v.X = (float)x; verts[3] = v; + + Gfx_SetVertexFormat(VERTEX_FORMAT_P3FC4B); + Gfx_UpdateDynamicVb_IndexedTris(Gfx_quadVb, verts, 4); +} + +void Gfx_Draw2DGradient(int x, int y, int width, int height, PackedCol top, PackedCol bottom) { + VertexP3fC4b verts[4]; + VertexP3fC4b v; v.Z = 0.0f; + + v.X = (float)x; v.Y = (float)y; v.Col = top; verts[0] = v; + v.X = (float)(x + width); verts[1] = v; + v.Y = (float)(y + height); v.Col = bottom; verts[2] = v; + v.X = (float)x; verts[3] = v; + + Gfx_SetVertexFormat(VERTEX_FORMAT_P3FC4B); + Gfx_UpdateDynamicVb_IndexedTris(Gfx_quadVb, verts, 4); +} + +void Gfx_Draw2DTexture(const struct Texture* tex, PackedCol col) { + VertexP3fT2fC4b texVerts[4]; + VertexP3fT2fC4b* ptr = texVerts; + Gfx_Make2DQuad(tex, col, &ptr); + Gfx_SetVertexFormat(VERTEX_FORMAT_P3FT2FC4B); + Gfx_UpdateDynamicVb_IndexedTris(Gfx_texVb, texVerts, 4); +} + +void Gfx_Make2DQuad(const struct Texture* tex, PackedCol col, VertexP3fT2fC4b** vertices) { + float x1 = (float)tex->X, x2 = (float)(tex->X + tex->Width); + float y1 = (float)tex->Y, y2 = (float)(tex->Y + tex->Height); +#ifdef CC_BUILD_D3D9 + /* NOTE: see "https://msdn.microsoft.com/en-us/library/windows/desktop/bb219690(v=vs.85).aspx", */ + /* i.e. the msdn article called "Directly Mapping Texels to Pixels (Direct3D 9)" for why we have to do this. */ + x1 -= 0.5f; x2 -= 0.5f; + y1 -= 0.5f; y2 -= 0.5f; +#endif + + VertexP3fT2fC4b* ptr = *vertices; + VertexP3fT2fC4b v; v.Z = 0.0f; v.Col = col; + v.X = x1; v.Y = y1; v.U = tex->uv.U1; v.V = tex->uv.V1; ptr[0] = v; + v.X = x2; v.U = tex->uv.U2; ptr[1] = v; + v.Y = y2; v.V = tex->uv.V2; ptr[2] = v; + v.X = x1; v.U = tex->uv.U1; ptr[3] = v; + *vertices += 4; +} + +static bool gfx_hadFog; +void Gfx_Mode2D(int width, int height) { + struct Matrix ortho; + Gfx_CalcOrthoMatrix((float)width, (float)height, &ortho); + + Gfx_SetMatrixMode(MATRIX_TYPE_PROJECTION); + Gfx_LoadMatrix(&ortho); + Gfx_SetMatrixMode(MATRIX_TYPE_VIEW); + Gfx_LoadIdentityMatrix(); + + Gfx_SetDepthTest(false); + Gfx_SetAlphaBlending(true); + gfx_hadFog = Gfx_GetFog(); + if (gfx_hadFog) Gfx_SetFog(false); +} + +void Gfx_Mode3D(void) { + Gfx_SetMatrixMode(MATRIX_TYPE_PROJECTION); + Gfx_LoadMatrix(&Gfx_Projection); + Gfx_SetMatrixMode(MATRIX_TYPE_VIEW); + Gfx_LoadMatrix(&Gfx_View); + + Gfx_SetDepthTest(true); + Gfx_SetAlphaBlending(false); + if (gfx_hadFog) Gfx_SetFog(true); +} + +void Gfx_MakeIndices(uint16_t* indices, int iCount) { + int element = 0, i; + + for (i = 0; i < iCount; i += 6) { + indices[0] = (uint16_t)(element + 0); + indices[1] = (uint16_t)(element + 1); + indices[2] = (uint16_t)(element + 2); + + indices[3] = (uint16_t)(element + 2); + indices[4] = (uint16_t)(element + 3); + indices[5] = (uint16_t)(element + 0); + + indices += 6; element += 4; + } +} + +void Gfx_SetupAlphaState(uint8_t draw) { + if (draw == DRAW_TRANSLUCENT) Gfx_SetAlphaBlending(true); + if (draw == DRAW_TRANSPARENT) Gfx_SetAlphaTest(true); + if (draw == DRAW_TRANSPARENT_THICK) Gfx_SetAlphaTest(true); + if (draw == DRAW_SPRITE) Gfx_SetAlphaTest(true); +} + +void Gfx_RestoreAlphaState(uint8_t draw) { + if (draw == DRAW_TRANSLUCENT) Gfx_SetAlphaBlending(false); + if (draw == DRAW_TRANSPARENT) Gfx_SetAlphaTest(false); + if (draw == DRAW_TRANSPARENT_THICK) Gfx_SetAlphaTest(false); + if (draw == DRAW_SPRITE) Gfx_SetAlphaTest(false); +} + + +/* Quoted from http://www.realtimerendering.com/blog/gpus-prefer-premultiplication/ + The short version: if you want your renderer to properly handle textures with alphas when using + bilinear interpolation or mipmapping, you need to premultiply your PNG color data by their (unassociated) alphas. */ +static BitmapCol GfxCommon_Average(BitmapCol p1, BitmapCol p2) { + uint32_t a1, a2, aSum; + uint32_t b1, g1, r1; + uint32_t b2, g2, r2; + BitmapCol ave; + + a1 = p1.A; a2 = p2.A; + aSum = (a1 + a2); + aSum = aSum > 0 ? aSum : 1; /* avoid divide by 0 below */ + + /* Convert RGB to pre-multiplied form */ + b1 = p1.B * a1; g1 = p1.G * a1; r1 = p1.R * a1; + b2 = p2.B * a2; g2 = p2.G * a2; r2 = p2.R * a2; + + /* https://stackoverflow.com/a/347376 + We need to convert RGB back from the pre-multiplied average into normal form + ((r1 + r2) / 2) / ((a1 + a2) / 2) + but we just cancel out the / 2*/ + ave.B = (b1 + b2) / aSum; + ave.G = (g1 + g2) / aSum; + ave.R = (r1 + r2) / aSum; + ave.A = aSum >> 1; + return ave; +} + +void Gfx_GenMipmaps(int width, int height, uint8_t* lvlScan0, uint8_t* scan0) { + BitmapCol* baseSrc = (BitmapCol*)scan0; + BitmapCol* baseDst = (BitmapCol*)lvlScan0; + int srcWidth = width << 1; + + int x, y; + for (y = 0; y < height; y++) { + int srcY = (y << 1); + BitmapCol* src0 = baseSrc + srcY * srcWidth; + BitmapCol* src1 = src0 + srcWidth; + BitmapCol* dst = baseDst + y * width; + + for (x = 0; x < width; x++) { + int srcX = (x << 1); + BitmapCol src00 = src0[srcX], src01 = src0[srcX + 1]; + BitmapCol src10 = src1[srcX], src11 = src1[srcX + 1]; + + /* bilinear filter this mipmap */ + BitmapCol ave0 = GfxCommon_Average(src00, src01); + BitmapCol ave1 = GfxCommon_Average(src10, src11); + dst[x] = GfxCommon_Average(ave0, ave1); + } + } +} + +int Gfx_MipmapsLevels(int width, int height) { + int lvlsWidth = Math_Log2(width), lvlsHeight = Math_Log2(height); + if (Gfx_CustomMipmapsLevels) { + int lvls = min(lvlsWidth, lvlsHeight); + return min(lvls, 4); + } else { + return max(lvlsWidth, lvlsHeight); + } +} + +void Texture_Render(const struct Texture* tex) { + PackedCol white = PACKEDCOL_WHITE; + Gfx_BindTexture(tex->ID); + Gfx_Draw2DTexture(tex, white); +} + +void Texture_RenderShaded(const struct Texture* tex, PackedCol shadeCol) { + Gfx_BindTexture(tex->ID); + Gfx_Draw2DTexture(tex, shadeCol); +} + + /*########################################################################################################################* *--------------------------------------------------------Direct3D9--------------------------------------------------------* *#########################################################################################################################*/ @@ -116,7 +355,7 @@ static void D3D9_RecreateDevice(void) { D3D9_SetDefaultRenderStates(); D3D9_RestoreRenderStates(); - GfxCommon_RecreateContext(); + Gfx_RecreateContext(); } void Gfx_Init(void) { @@ -150,11 +389,11 @@ void Gfx_Init(void) { Gfx_CustomMipmapsLevels = true; D3D9_SetDefaultRenderStates(); - GfxCommon_Init(); + Gfx_InitDefaultResources(); } void Gfx_Free(void) { - GfxCommon_Free(); + Gfx_FreeDefaultResources(); D3D9_FreeResource(&device); D3D9_FreeResource(&d3d); } @@ -205,7 +444,7 @@ static void D3D9_DoMipmaps(IDirect3DTexture9* texture, int x, int y, Bitmap* bmp uint8_t* cur; Bitmap mipmap; - int lvls = GfxCommon_MipmapsLevels(bmp->Width, bmp->Height); + int lvls = Gfx_MipmapsLevels(bmp->Width, bmp->Height); int lvl, width = bmp->Width, height = bmp->Height; for (lvl = 1; lvl <= lvls; lvl++) { @@ -214,7 +453,7 @@ static void D3D9_DoMipmaps(IDirect3DTexture9* texture, int x, int y, Bitmap* bmp if (height > 1) height /= 2; cur = Mem_Alloc(width * height, BITMAP_SIZEOF_PIXEL, "mipmaps"); - GfxCommon_GenMipmaps(width, height, cur, prev); + Gfx_GenMipmaps(width, height, cur, prev); Bitmap_Create(&mipmap, width, height, cur); if (partial) { @@ -232,7 +471,7 @@ static void D3D9_DoMipmaps(IDirect3DTexture9* texture, int x, int y, Bitmap* bmp GfxResourceID Gfx_CreateTexture(Bitmap* bmp, bool managedPool, bool mipmaps) { IDirect3DTexture9* tex; ReturnCode res; - int mipmapsLevels = GfxCommon_MipmapsLevels(bmp->Width, bmp->Height); + int mipmapsLevels = Gfx_MipmapsLevels(bmp->Width, bmp->Height); int levels = 1 + (mipmaps ? mipmapsLevels : 0); if (!Math_IsPowOf2(bmp->Width) || !Math_IsPowOf2(bmp->Height)) { @@ -531,7 +770,7 @@ void Gfx_BindIb(GfxResourceID ib) { void Gfx_DeleteVb(GfxResourceID* vb) { D3D9_FreeResource(vb); } void Gfx_DeleteIb(GfxResourceID* ib) { D3D9_FreeResource(ib); } -void Gfx_SetBatchFormat(VertexFormat fmt) { +void Gfx_SetVertexFormat(VertexFormat fmt) { if (fmt == gfx_batchFormat) return; gfx_batchFormat = fmt; @@ -654,7 +893,7 @@ void Gfx_SetVSync(bool value) { if (gfx_vsync == value) return; gfx_vsync = value; - GfxCommon_LoseContext(" (toggling VSync)"); + Gfx_LoseContext(" (toggling VSync)"); D3D9_RecreateDevice(); } @@ -672,7 +911,7 @@ void Gfx_EndFrame(void) { if (res != D3DERR_DEVICELOST) ErrorHandler_Fail2(res, "D3D9_EndFrame"); /* TODO: Make sure this actually works on all graphics cards.*/ - GfxCommon_LoseContext(" (Direct3D9 device lost)"); + Gfx_LoseContext(" (Direct3D9 device lost)"); D3D9_LoopUntilRetrieved(); D3D9_RecreateDevice(); } @@ -724,7 +963,7 @@ void Gfx_UpdateApiInfo(void) { } void Gfx_OnWindowResize(void) { - GfxCommon_LoseContext(" (resizing window)"); + Gfx_LoseContext(" (resizing window)"); D3D9_RecreateDevice(); } #endif @@ -823,7 +1062,7 @@ void Gfx_Init(void) { Gfx_CustomMipmapsLevels = true; GL_CheckVboSupport(); #endif - GfxCommon_Init(); + Gfx_InitDefaultResources(); glHint(GL_FOG_HINT, GL_NICEST); glEnableClientState(GL_VERTEX_ARRAY); @@ -831,7 +1070,7 @@ void Gfx_Init(void) { } void Gfx_Free(void) { - GfxCommon_Free(); + Gfx_FreeDefaultResources(); GLContext_Free(); } @@ -845,7 +1084,7 @@ static void GL_DoMipmaps(GfxResourceID texId, int x, int y, Bitmap* bmp, bool pa uint8_t* prev = bmp->Scan0; uint8_t* cur; - int lvls = GfxCommon_MipmapsLevels(bmp->Width, bmp->Height); + int lvls = Gfx_MipmapsLevels(bmp->Width, bmp->Height); int lvl, width = bmp->Width, height = bmp->Height; for (lvl = 1; lvl <= lvls; lvl++) { @@ -854,7 +1093,7 @@ static void GL_DoMipmaps(GfxResourceID texId, int x, int y, Bitmap* bmp, bool pa if (height > 1) height /= 2; cur = Mem_Alloc(width * height, BITMAP_SIZEOF_PIXEL, "mipmaps"); - GfxCommon_GenMipmaps(width, height, cur, prev); + Gfx_GenMipmaps(width, height, cur, prev); if (partial) { glTexSubImage2D(GL_TEXTURE_2D, lvl, x, y, width, height, GL_BGRA_EXT, GL_UNSIGNED_BYTE, cur); @@ -881,7 +1120,7 @@ GfxResourceID Gfx_CreateTexture(Bitmap* bmp, bool managedPool, bool mipmaps) { if (mipmaps) { glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_LINEAR); if (Gfx_CustomMipmapsLevels) { - int lvls = GfxCommon_MipmapsLevels(bmp->Width, bmp->Height); + int lvls = Gfx_MipmapsLevels(bmp->Width, bmp->Height); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, lvls); } } else { @@ -1043,14 +1282,14 @@ GfxResourceID Gfx_CreateDynamicVb(VertexFormat fmt, int maxVertices) { return gl GfxResourceID Gfx_CreateVb(void* vertices, VertexFormat fmt, int count) { /* We need to setup client state properly when building the list */ int curFormat = gfx_batchFormat, stride; - Gfx_SetBatchFormat(fmt); + Gfx_SetVertexFormat(fmt); GfxResourceID list = glGenLists(1); glNewList(list, GL_COMPILE); count &= ~0x01; /* Need to get rid of the 1 extra element, see comment in chunk mesh builder for why */ uint16_t indices[GFX_MAX_INDICES]; - GfxCommon_MakeIndices(indices, ICOUNT(count)); + Gfx_MakeIndices(indices, ICOUNT(count)); stride = Gfx_strideSizes[fmt]; glVertexPointer(3, GL_FLOAT, stride, vertices); @@ -1061,7 +1300,7 @@ GfxResourceID Gfx_CreateVb(void* vertices, VertexFormat fmt, int count) { glDrawElements(GL_TRIANGLES, ICOUNT(count), GL_UNSIGNED_SHORT, indices); glEndList(); - Gfx_SetBatchFormat(curFormat); + Gfx_SetVertexFormat(curFormat); return list; } @@ -1101,7 +1340,7 @@ void GL_SetupVbPos3fTex2fCol4b_Range(int startVertex) { glTexCoordPointer(2, GL_FLOAT, sizeof(VertexP3fT2fC4b), (void*)(offset + 16)); } -void Gfx_SetBatchFormat(VertexFormat fmt) { +void Gfx_SetVertexFormat(VertexFormat fmt) { if (fmt == gfx_batchFormat) return; if (gfx_batchFormat == VERTEX_FORMAT_P3FT2FC4B) { diff --git a/src/Graphics.h b/src/Graphics.h index db9e2bfe6..46089c326 100644 --- a/src/Graphics.h +++ b/src/Graphics.h @@ -4,6 +4,7 @@ #include "Vectors.h" #include "GameStructs.h" #include "Bitmap.h" +#include "VertexStructs.h" /* Abstracts a 3D graphics rendering API. Copyright 2014-2017 ClassicalSharp | Licensed under BSD-3 @@ -40,6 +41,10 @@ bool Gfx_Mipmaps; bool Gfx_CustomMipmapsLevels; struct Matrix Gfx_View, Gfx_Projection; +extern String Gfx_ApiInfo[7]; +GfxResourceID Gfx_defaultIb; +GfxResourceID Gfx_quadVb, Gfx_texVb; + #define ICOUNT(verticesCount) (((verticesCount) >> 2) * 6) #define GFX_MAX_INDICES (65536 / 4 * 6) #define GFX_MAX_VERTICES 65536 @@ -47,65 +52,176 @@ struct Matrix Gfx_View, Gfx_Projection; /* Callback invoked when the context is lost. Repeatedly invoked until a context can be retrieved. */ ScheduledTaskCallback Gfx_LostContextFunction; +/* Creates a new texture. (and also generates mipmaps if mipmaps) */ +/* NOTE: Only set mipmaps to true if Gfx_Mipmaps is also true, because whether textures +use mipmapping may be either a per-texture or global state depending on the backend. */ GfxResourceID Gfx_CreateTexture(Bitmap* bmp, bool managedPool, bool mipmaps); +/* Updates a region of the given texture. (and mipmapped regions if mipmaps) */ void Gfx_UpdateTexturePart(GfxResourceID texId, int x, int y, Bitmap* part, bool mipmaps); +/* Sets the currently active texture. */ void Gfx_BindTexture(GfxResourceID texId); +/* Deletes the given texture, then sets it to GFX_NULL. */ void Gfx_DeleteTexture(GfxResourceID* texId); +/* Sets whether texture colour is used when rendering vertices. */ void Gfx_SetTexturing(bool enabled); +/* Turns on mipmapping. (if Gfx_Mipmaps is enabled) */ +/* NOTE: You must have created textures with mipmaps true for this to work. */ void Gfx_EnableMipmaps(void); +/* Turns off mipmapping. (if GfX_Mipmaps is enabled) */ +/* NOTE: You must have created textures with mipmaps true for this to work. */ void Gfx_DisableMipmaps(void); +/* Returns whether fog blending is enabled. */ bool Gfx_GetFog(void); +/* Sets whether fog blending is enabled. */ void Gfx_SetFog(bool enabled); +/* Sets the colour of the blended fog. */ void Gfx_SetFogCol(PackedCol col); +/* Sets thickness of fog for FOG_EXP/FOG_EXP2 modes. */ void Gfx_SetFogDensity(float value); +/* Sets extent/end of fog for FOG_LINEAR mode. */ void Gfx_SetFogEnd(float value); +/* Sets in what way fog is blended. */ void Gfx_SetFogMode(FogFunc func); +/* Sets whether backface culling is performed. */ void Gfx_SetFaceCulling(bool enabled); +/* Sets whether new pixels may be discarded based on their alpha. */ void Gfx_SetAlphaTest(bool enabled); +/* Sets in what way pixels may be discarded based on their alpha. */ void Gfx_SetAlphaTestFunc(CompareFunc func, float refValue); +/* Sets whether existing and new pixels are blended together. */ void Gfx_SetAlphaBlending(bool enabled); +/* Sets in what way existing and new pixels are blended. */ void Gfx_SetAlphaBlendFunc(BlendFunc srcFunc, BlendFunc dstFunc); -/* Sets whether blending between the alpha components of the texture and vertex colour is performed. */ +/* Sets whether blending between the alpha components of texture and vertex colour is performed. */ void Gfx_SetAlphaArgBlend(bool enabled); +/* Clears the colour and depth buffer to default. */ void Gfx_Clear(void); +/* Sets the colour that the colour buffer is cleared to. */ void Gfx_ClearCol(PackedCol col); +/* Sets whether pixels may be discard based on z/depth. */ void Gfx_SetDepthTest(bool enabled); +/* Sets in what may pixels may be discarded based on z/depth. */ void Gfx_SetDepthTestFunc(CompareFunc func); +/* Sets whether R/G/B/A of pixels are actually written to the colour buffer channels. */ void Gfx_SetColWriteMask(bool r, bool g, bool b, bool a); +/* Sets whether z/depth of pixels is actually written to the depth buffer. */ void Gfx_SetDepthWrite(bool enabled); +/* Creates a new dynamic vertex buffer, whose contents can be updated later. */ GfxResourceID Gfx_CreateDynamicVb(VertexFormat fmt, int maxVertices); +/* Creates a new vertex buffer and fills out its contents. */ GfxResourceID Gfx_CreateVb(void* vertices, VertexFormat fmt, int count); +/* Creates a new index buffer and fills out its contents. */ GfxResourceID Gfx_CreateIb(void* indices, int indicesCount); +/* Sets the currently active vertex buffer. */ void Gfx_BindVb(GfxResourceID vb); +/* Sets the currently active index buffer. */ void Gfx_BindIb(GfxResourceID ib); +/* Deletes the given vertex buffer, then sets it to GFX_NULL. */ void Gfx_DeleteVb(GfxResourceID* vb); +/* Deletes the given index buffer, then sets it to GFX_NULL. */ void Gfx_DeleteIb(GfxResourceID* ib); -void Gfx_SetBatchFormat(VertexFormat fmt); +/* Sets the format of the rendered vertices. */ +void Gfx_SetVertexFormat(VertexFormat fmt); +/* Updates the data of a dynamic vertex buffer. */ void Gfx_SetDynamicVbData(GfxResourceID vb, void* vertices, int vCount); +/* Renders vertices from the currently bound vertex buffer as lines. */ void Gfx_DrawVb_Lines(int verticesCount); +/* Renders vertices from the currently bound vertex and index buffer as triangles. */ +/* NOTE: Offsets each index by startVertex. */ void Gfx_DrawVb_IndexedTris_Range(int verticesCount, int startVertex); +/* Renders vertices from the currently bound vertex and index buffer as triangles. */ void Gfx_DrawVb_IndexedTris(int verticesCount); +/* Special case Gfx_DrawVb_IndexedTris_Range for map renderer */ void Gfx_DrawIndexedVb_TrisT2fC4b(int verticesCount, int startVertex); +/* Sets the currently active matrix. */ void Gfx_SetMatrixMode(MatrixType type); +/* Loads the given matrix over the currently active matrix. */ void Gfx_LoadMatrix(struct Matrix* matrix); +/* Loads the identity matrix over the currently active matrix. */ void Gfx_LoadIdentityMatrix(void); +/* Calculates an orthographic matrix suitable with this backend. (usually for 2D) */ void Gfx_CalcOrthoMatrix(float width, float height, struct Matrix* matrix); +/* Calculates a projection matrix suitable with this backend. (usually for 3D) */ void Gfx_CalcPerspectiveMatrix(float fov, float aspect, float zNear, float zFar, struct Matrix* matrix); -/* Outputs a .png screenshot of the backbuffer */ +/* Outputs a .png screenshot of the backbuffer. */ ReturnCode Gfx_TakeScreenshot(struct Stream* output, int width, int height); -/* Warns if this graphics API has problems with the user's GPU. Returns whether legacy rendering mode is needed. */ +/* Warns in chat if the backend has problems with the user's GPU. /* +/* Returns whether legacy rendering mode for borders/sky/clouds is needed. */ bool Gfx_WarnIfNecessary(void); +/* Sets up state for rendering a new frame. */ void Gfx_BeginFrame(void); +/* Finishes rendering a frame, and swaps it with the back buffer. */ void Gfx_EndFrame(void); +/* Sets whether to synchronise with monitor refresh to avoid tearing. */ +/* NOTE: This setting may be unsupported or just ignored. */ void Gfx_SetVSync(bool value); +/* Updates state when the window's dimensions have changed. */ +/* NOTE: This may require recreating the context depending on the backend. */ void Gfx_OnWindowResize(void); +/* Fills Gfx_ApiInfo with information about the backend state and the user's GPU. */ void Gfx_MakeApiInfo(void); +/* Updates Gfx_ApiInfo with current backend state information. */ +/* NOTE: This is information such as current free memory, etc. */ void Gfx_UpdateApiInfo(void); + +/* Raises ContextLost event and updates state for lost contexts. */ +void Gfx_LoseContext(const char* reason); +/* Raises ContextRecreated event and restores state from lost contexts. */ +void Gfx_RecreateContext(void); + +/* Binds and draws the specified subset of the vertices in the current dynamic vertex buffer. */ +/* NOTE: This replaces the dynamic vertex buffer's data first with the given vertices before drawing. */ +void Gfx_UpdateDynamicVb_Lines(GfxResourceID vb, void* vertices, int vCount); +/* Binds and draws the specified subset of the vertices in the current dynamic vertex buffer. */ +/* NOTE: This replaces the dynamic vertex buffer's data first with the given vertices before drawing. */ +void Gfx_UpdateDynamicVb_IndexedTris(GfxResourceID vb, void* vertices, int vCount); + +/* Renders a 2D flat coloured rectangle. */ +void Gfx_Draw2DFlat(int x, int y, int width, int height, PackedCol col); +/* Renders a 2D flat vertical gradient rectangle. */ +void Gfx_Draw2DGradient(int x, int y, int width, int height, PackedCol top, PackedCol bottom); +/* Renders a 2D coloured texture. */ +void Gfx_Draw2DTexture(const struct Texture* tex, PackedCol col); +/* Fills out the vertices for rendering a 2D coloured texture. */ +void Gfx_Make2DQuad(const struct Texture* tex, PackedCol col, VertexP3fT2fC4b** vertices); + +/* Switches state to be suitable for drawing 2D graphics. */ +/* NOTE: This means turning off fog/depth test, changing matrices, etc.*/ +void Gfx_Mode2D(int width, int height); +/* Switches state to be suitable for drawing 3D graphics. */ +/* NOTE: This means restoring fog/depth test, restoring matrices, etc. */ +void Gfx_Mode3D(void); + +/* Fills out indices array with {0,1,2} {2,3,0}, {4,5,6} {6,7,4} etc. */ +void Gfx_MakeIndices(uint16_t* indices, int iCount); +/* Sets appropriate alpha test/blending for given block draw type. */ +void Gfx_SetupAlphaState(uint8_t draw); +/* Undoes changes to alpha test/blending state by Gfx_SetupAlphaState. */ +void Gfx_RestoreAlphaState(uint8_t draw); +/* Generates the next mipmaps level bitmap for the given bitmap. */ +void Gfx_GenMipmaps(int width, int height, uint8_t* lvlScan0, uint8_t* scan0); +/* Returns the maximum number of mipmaps levels used for given size. */ +int Gfx_MipmapsLevels(int width, int height); + +/* Statically initialises the position and dimensions of this texture */ +#define Tex_Rect(x,y, width,height) x,y,width,height +/* Statically initialises the texture coordinate corners of this texture */ +#define Tex_UV(u1,v1, u2,v2) u1,v1,u2,v2 +/* Sets the position and dimensions of this texture */ +#define Tex_SetRect(tex, x,y, width, height) tex.X = x; tex.Y = y; tex.Width = width; tex.Height = height; +/* Sets texture coordinate corners of this texture */ +/* Useful to only draw a sub-region of the texture's pixels */ +#define Tex_SetUV(tex, u1,v1, u2,v2) tex.uv.U1 = u1; tex.uv.V1 = v1; tex.uv.U2 = u2; tex.uv.V2 = v2; + +/* Binds then renders the given texture. */ +void Texture_Render(const struct Texture* tex); +/* Binds then renders the given texture. */ +void Texture_RenderShaded(const struct Texture* tex, PackedCol shadeCol); #endif diff --git a/src/GraphicsCommon.c b/src/GraphicsCommon.c deleted file mode 100644 index 9a7e30367..000000000 --- a/src/GraphicsCommon.c +++ /dev/null @@ -1,242 +0,0 @@ -#include "GraphicsCommon.h" -#include "Graphics.h" -#include "Platform.h" -#include "Block.h" -#include "Event.h" -#include "Funcs.h" -#include "ExtMath.h" - -static char Gfx_ApiBuffer[7][STRING_SIZE]; -String Gfx_ApiInfo[7] = { - String_FromArray(Gfx_ApiBuffer[0]), String_FromArray(Gfx_ApiBuffer[1]), - String_FromArray(Gfx_ApiBuffer[2]), String_FromArray(Gfx_ApiBuffer[3]), - String_FromArray(Gfx_ApiBuffer[4]), String_FromArray(Gfx_ApiBuffer[5]), - String_FromArray(Gfx_ApiBuffer[6]), -}; - -void GfxCommon_Init(void) { - uint16_t indices[GFX_MAX_INDICES]; - GfxCommon_MakeIndices(indices, GFX_MAX_INDICES); - GfxCommon_defaultIb = Gfx_CreateIb(indices, GFX_MAX_INDICES); - - GfxCommon_quadVb = Gfx_CreateDynamicVb(VERTEX_FORMAT_P3FC4B, 4); - GfxCommon_texVb = Gfx_CreateDynamicVb(VERTEX_FORMAT_P3FT2FC4B, 4); -} - -void GfxCommon_Free(void) { - Gfx_DeleteVb(&GfxCommon_quadVb); - Gfx_DeleteVb(&GfxCommon_texVb); - Gfx_DeleteIb(&GfxCommon_defaultIb); -} - -void GfxCommon_LoseContext(const char* reason) { - Gfx_LostContext = true; - Platform_Log1("Lost graphics context: %c", reason); - - Event_RaiseVoid(&GfxEvents_ContextLost); - GfxCommon_Free(); -} - -void GfxCommon_RecreateContext(void) { - Gfx_LostContext = false; - Platform_LogConst("Recreating graphics context"); - - Event_RaiseVoid(&GfxEvents_ContextRecreated); - GfxCommon_Init(); -} - - -void GfxCommon_UpdateDynamicVb_Lines(GfxResourceID vb, void* vertices, int vCount) { - Gfx_SetDynamicVbData(vb, vertices, vCount); - Gfx_DrawVb_Lines(vCount); -} - -void GfxCommon_UpdateDynamicVb_IndexedTris(GfxResourceID vb, void* vertices, int vCount) { - Gfx_SetDynamicVbData(vb, vertices, vCount); - Gfx_DrawVb_IndexedTris(vCount); -} - -void GfxCommon_Draw2DFlat(int x, int y, int width, int height, PackedCol col) { - VertexP3fC4b verts[4]; - VertexP3fC4b v; v.Z = 0.0f; v.Col = col; - - v.X = (float)x; v.Y = (float)y; verts[0] = v; - v.X = (float)(x + width); verts[1] = v; - v.Y = (float)(y + height); verts[2] = v; - v.X = (float)x; verts[3] = v; - - Gfx_SetBatchFormat(VERTEX_FORMAT_P3FC4B); - GfxCommon_UpdateDynamicVb_IndexedTris(GfxCommon_quadVb, verts, 4); -} - -void GfxCommon_Draw2DGradient(int x, int y, int width, int height, PackedCol top, PackedCol bottom) { - VertexP3fC4b verts[4]; - VertexP3fC4b v; v.Z = 0.0f; - - v.X = (float)x; v.Y = (float)y; v.Col = top; verts[0] = v; - v.X = (float)(x + width); verts[1] = v; - v.Y = (float)(y + height); v.Col = bottom; verts[2] = v; - v.X = (float)x; verts[3] = v; - - Gfx_SetBatchFormat(VERTEX_FORMAT_P3FC4B); - GfxCommon_UpdateDynamicVb_IndexedTris(GfxCommon_quadVb, verts, 4); -} - -void GfxCommon_Draw2DTexture(const struct Texture* tex, PackedCol col) { - VertexP3fT2fC4b texVerts[4]; - VertexP3fT2fC4b* ptr = texVerts; - GfxCommon_Make2DQuad(tex, col, &ptr); - Gfx_SetBatchFormat(VERTEX_FORMAT_P3FT2FC4B); - GfxCommon_UpdateDynamicVb_IndexedTris(GfxCommon_texVb, texVerts, 4); -} - -void GfxCommon_Make2DQuad(const struct Texture* tex, PackedCol col, VertexP3fT2fC4b** vertices) { - float x1 = (float)tex->X, x2 = (float)(tex->X + tex->Width); - float y1 = (float)tex->Y, y2 = (float)(tex->Y + tex->Height); -#ifdef CC_BUILD_D3D9 - /* NOTE: see "https://msdn.microsoft.com/en-us/library/windows/desktop/bb219690(v=vs.85).aspx", */ - /* i.e. the msdn article called "Directly Mapping Texels to Pixels (Direct3D 9)" for why we have to do this. */ - x1 -= 0.5f; x2 -= 0.5f; - y1 -= 0.5f; y2 -= 0.5f; -#endif - - VertexP3fT2fC4b* ptr = *vertices; - VertexP3fT2fC4b v; v.Z = 0.0f; v.Col = col; - v.X = x1; v.Y = y1; v.U = tex->uv.U1; v.V = tex->uv.V1; ptr[0] = v; - v.X = x2; v.U = tex->uv.U2; ptr[1] = v; - v.Y = y2; v.V = tex->uv.V2; ptr[2] = v; - v.X = x1; v.U = tex->uv.U1; ptr[3] = v; - *vertices += 4; -} - -static bool gfx_hadFog; -void GfxCommon_Mode2D(int width, int height) { - struct Matrix ortho; - Gfx_CalcOrthoMatrix((float)width, (float)height, &ortho); - - Gfx_SetMatrixMode(MATRIX_TYPE_PROJECTION); - Gfx_LoadMatrix(&ortho); - Gfx_SetMatrixMode(MATRIX_TYPE_VIEW); - Gfx_LoadIdentityMatrix(); - - Gfx_SetDepthTest(false); - Gfx_SetAlphaBlending(true); - gfx_hadFog = Gfx_GetFog(); - if (gfx_hadFog) Gfx_SetFog(false); -} - -void GfxCommon_Mode3D(void) { - Gfx_SetMatrixMode(MATRIX_TYPE_PROJECTION); - Gfx_LoadMatrix(&Gfx_Projection); - Gfx_SetMatrixMode(MATRIX_TYPE_VIEW); - Gfx_LoadMatrix(&Gfx_View); - - Gfx_SetDepthTest(true); - Gfx_SetAlphaBlending(false); - if (gfx_hadFog) Gfx_SetFog(true); -} - -void GfxCommon_MakeIndices(uint16_t* indices, int iCount) { - int element = 0, i; - - for (i = 0; i < iCount; i += 6) { - indices[0] = (uint16_t)(element + 0); - indices[1] = (uint16_t)(element + 1); - indices[2] = (uint16_t)(element + 2); - - indices[3] = (uint16_t)(element + 2); - indices[4] = (uint16_t)(element + 3); - indices[5] = (uint16_t)(element + 0); - - indices += 6; element += 4; - } -} - -void GfxCommon_SetupAlphaState(uint8_t draw) { - if (draw == DRAW_TRANSLUCENT) Gfx_SetAlphaBlending(true); - if (draw == DRAW_TRANSPARENT) Gfx_SetAlphaTest(true); - if (draw == DRAW_TRANSPARENT_THICK) Gfx_SetAlphaTest(true); - if (draw == DRAW_SPRITE) Gfx_SetAlphaTest(true); -} - -void GfxCommon_RestoreAlphaState(uint8_t draw) { - if (draw == DRAW_TRANSLUCENT) Gfx_SetAlphaBlending(false); - if (draw == DRAW_TRANSPARENT) Gfx_SetAlphaTest(false); - if (draw == DRAW_TRANSPARENT_THICK) Gfx_SetAlphaTest(false); - if (draw == DRAW_SPRITE) Gfx_SetAlphaTest(false); -} - - -/* Quoted from http://www.realtimerendering.com/blog/gpus-prefer-premultiplication/ - The short version: if you want your renderer to properly handle textures with alphas when using - bilinear interpolation or mipmapping, you need to premultiply your PNG color data by their (unassociated) alphas. */ -static BitmapCol GfxCommon_Average(BitmapCol p1, BitmapCol p2) { - uint32_t a1, a2, aSum; - uint32_t b1, g1, r1; - uint32_t b2, g2, r2; - BitmapCol ave; - - a1 = p1.A; a2 = p2.A; - aSum = (a1 + a2); - aSum = aSum > 0 ? aSum : 1; /* avoid divide by 0 below */ - - /* Convert RGB to pre-multiplied form */ - b1 = p1.B * a1; g1 = p1.G * a1; r1 = p1.R * a1; - b2 = p2.B * a2; g2 = p2.G * a2; r2 = p2.R * a2; - - /* https://stackoverflow.com/a/347376 - We need to convert RGB back from the pre-multiplied average into normal form - ((r1 + r2) / 2) / ((a1 + a2) / 2) - but we just cancel out the / 2*/ - ave.B = (b1 + b2) / aSum; - ave.G = (g1 + g2) / aSum; - ave.R = (r1 + r2) / aSum; - ave.A = aSum >> 1; - return ave; -} - -void GfxCommon_GenMipmaps(int width, int height, uint8_t* lvlScan0, uint8_t* scan0) { - BitmapCol* baseSrc = (BitmapCol*)scan0; - BitmapCol* baseDst = (BitmapCol*)lvlScan0; - int srcWidth = width << 1; - - int x, y; - for (y = 0; y < height; y++) { - int srcY = (y << 1); - BitmapCol* src0 = baseSrc + srcY * srcWidth; - BitmapCol* src1 = src0 + srcWidth; - BitmapCol* dst = baseDst + y * width; - - for (x = 0; x < width; x++) { - int srcX = (x << 1); - BitmapCol src00 = src0[srcX], src01 = src0[srcX + 1]; - BitmapCol src10 = src1[srcX], src11 = src1[srcX + 1]; - - /* bilinear filter this mipmap */ - BitmapCol ave0 = GfxCommon_Average(src00, src01); - BitmapCol ave1 = GfxCommon_Average(src10, src11); - dst[x] = GfxCommon_Average(ave0, ave1); - } - } -} - -int GfxCommon_MipmapsLevels(int width, int height) { - int lvlsWidth = Math_Log2(width), lvlsHeight = Math_Log2(height); - if (Gfx_CustomMipmapsLevels) { - int lvls = min(lvlsWidth, lvlsHeight); - return min(lvls, 4); - } else { - return max(lvlsWidth, lvlsHeight); - } -} - -void Texture_Render(const struct Texture* tex) { - PackedCol white = PACKEDCOL_WHITE; - Gfx_BindTexture(tex->ID); - GfxCommon_Draw2DTexture(tex, white); -} - -void Texture_RenderShaded(const struct Texture* tex, PackedCol shadeCol) { - Gfx_BindTexture(tex->ID); - GfxCommon_Draw2DTexture(tex, shadeCol); -} diff --git a/src/GraphicsCommon.h b/src/GraphicsCommon.h deleted file mode 100644 index 852a2bc67..000000000 --- a/src/GraphicsCommon.h +++ /dev/null @@ -1,56 +0,0 @@ -#ifndef CC_GFXCOMMON_H -#define CC_GFXCOMMON_H -#include "VertexStructs.h" - -/* Provides common/shared methods for a 3D graphics rendering API. - Copyright 2014-2017 ClassicalSharp | Licensed under BSD-3 -*/ -extern String Gfx_ApiInfo[7]; -GfxResourceID GfxCommon_defaultIb; - -/* Contains the information necessary to describe a 2D textured quad. */ -struct Texture { - GfxResourceID ID; - int16_t X, Y; uint16_t Width, Height; - TextureRec uv; -}; -/* Statically initialises the position and dimensions of this texture */ -#define Tex_Rect(x,y, width,height) x,y,width,height -/* Statically initialises the texture coordinate corners of this texture */ -#define Tex_UV(u1,v1, u2,v2) u1,v1,u2,v2 -/* Sets the position and dimensions of this texture */ -#define Tex_SetRect(tex, x,y, width, height) tex.X = x; tex.Y = y; tex.Width = width; tex.Height = height; -/* Sets texture coordinate corners of this texture */ -/* Useful to only draw a sub-region of the texture's pixels */ -#define Tex_SetUV(tex, u1,v1, u2,v2) tex.uv.U1 = u1; tex.uv.V1 = v1; tex.uv.U2 = u2; tex.uv.V2 = v2; - -void GfxCommon_Init(void); -void GfxCommon_Free(void); -void GfxCommon_LoseContext(const char* reason); -void GfxCommon_RecreateContext(void); - -/* Binds and draws the specified subset of the vertices in the current dynamic vertex buffer -This method also replaces the dynamic vertex buffer's data first with the given vertices before drawing. */ -void GfxCommon_UpdateDynamicVb_Lines(GfxResourceID vb, void* vertices, int vCount); -/*Binds and draws the specified subset of the vertices in the current dynamic vertex buffer -This method also replaces the dynamic vertex buffer's data first with the given vertices before drawing. */ -void GfxCommon_UpdateDynamicVb_IndexedTris(GfxResourceID vb, void* vertices, int vCount); - -GfxResourceID GfxCommon_quadVb, GfxCommon_texVb; -void GfxCommon_Draw2DFlat(int x, int y, int width, int height, PackedCol col); -void GfxCommon_Draw2DGradient(int x, int y, int width, int height, PackedCol top, PackedCol bottom); -void GfxCommon_Draw2DTexture(const struct Texture* tex, PackedCol col); -void GfxCommon_Make2DQuad(const struct Texture* tex, PackedCol col, VertexP3fT2fC4b** vertices); - -void GfxCommon_Mode2D(int width, int height); -void GfxCommon_Mode3D(void); - -void GfxCommon_MakeIndices(uint16_t* indices, int iCount); -void GfxCommon_SetupAlphaState(uint8_t draw); -void GfxCommon_RestoreAlphaState(uint8_t draw); - -void GfxCommon_GenMipmaps(int width, int height, uint8_t* lvlScan0, uint8_t* scan0); -int GfxCommon_MipmapsLevels(int width, int height); -void Texture_Render(const struct Texture* tex); -void Texture_RenderShaded(const struct Texture* tex, PackedCol shadeCol); -#endif diff --git a/src/Gui.c b/src/Gui.c index 73c500440..a53f8a673 100644 --- a/src/Gui.c +++ b/src/Gui.c @@ -1,7 +1,6 @@ #include "Gui.h" #include "Window.h" #include "Game.h" -#include "GraphicsCommon.h" #include "Graphics.h" #include "Event.h" #include "Drawer2D.h" @@ -203,7 +202,7 @@ void Gui_FreeOverlay(void* overlay) { void Gui_RenderGui(double delta) { bool showHUD, hudBefore; - GfxCommon_Mode2D(Game_Width, Game_Height); + Gfx_Mode2D(Game_Width, Game_Height); showHUD = !Gui_Active || !Gui_Active->HidesHUD; hudBefore = !Gui_Active || !Gui_Active->RenderHUDOver; @@ -214,7 +213,7 @@ void Gui_RenderGui(double delta) { if (showHUD && !hudBefore) { Elem_Render(Gui_HUD, delta); } if (Gui_OverlaysCount) { Elem_Render(Gui_Overlays[0], delta); } - GfxCommon_Mode3D(); + Gfx_Mode3D(); } void Gui_OnResize(void) { @@ -287,7 +286,7 @@ void TextAtlas_Add(struct TextAtlas* atlas, int charI, VertexP3fT2fC4b** vertice part.uv.U2 = part.uv.U1 + width * atlas->uScale; atlas->CurX += width; - GfxCommon_Make2DQuad(&part, white, vertices); + Gfx_Make2DQuad(&part, white, vertices); } void TextAtlas_AddInt(struct TextAtlas* atlas, int value, VertexP3fT2fC4b** vertices) { diff --git a/src/Gui.h b/src/Gui.h index b46fb6615..3d8bd4bda 100644 --- a/src/Gui.h +++ b/src/Gui.h @@ -1,8 +1,8 @@ #ifndef CC_GUI_H #define CC_GUI_H #include "Input.h" -#include "GraphicsCommon.h" #include "Event.h" +#include "VertexStructs.h" /* Describes and manages 2D GUI elements on screen. Copyright 2014-2017 ClassicalSharp | Licensed under BSD-3 */ diff --git a/src/HeldBlockRenderer.c b/src/HeldBlockRenderer.c index a896c49f0..785166b9f 100644 --- a/src/HeldBlockRenderer.c +++ b/src/HeldBlockRenderer.c @@ -3,7 +3,6 @@ #include "Game.h" #include "Inventory.h" #include "Graphics.h" -#include "GraphicsCommon.h" #include "Camera.h" #include "ExtMath.h" #include "Event.h" @@ -39,9 +38,9 @@ static void HeldBlockRenderer_RenderModel(void) { model = Model_Get(&block); held_entity.ModelScale = Vector3_Create1(0.4f); - GfxCommon_SetupAlphaState(Block_Draw[held_block]); + Gfx_SetupAlphaState(Block_Draw[held_block]); Model_Render(model, &held_entity); - GfxCommon_RestoreAlphaState(Block_Draw[held_block]); + Gfx_RestoreAlphaState(Block_Draw[held_block]); } Gfx_SetTexturing(false); diff --git a/src/IsometricDrawer.c b/src/IsometricDrawer.c index e4d70359d..c425d5858 100644 --- a/src/IsometricDrawer.c +++ b/src/IsometricDrawer.c @@ -1,6 +1,5 @@ #include "IsometricDrawer.h" #include "Drawer.h" -#include "GraphicsCommon.h" #include "Graphics.h" #include "PackedCol.h" #include "ExtMath.h" @@ -55,7 +54,7 @@ static void IsometricDrawer_Flush(void) { if (iso_lastTexIndex != -1) { Gfx_BindTexture(Atlas1D_TexIds[iso_lastTexIndex]); count = (int)(iso_vertices - iso_vertices_base); - GfxCommon_UpdateDynamicVb_IndexedTris(iso_vb, iso_vertices_base, count); + Gfx_UpdateDynamicVb_IndexedTris(iso_vb, iso_vertices_base, count); } iso_lastTexIndex = iso_texIndex; diff --git a/src/MapRenderer.c b/src/MapRenderer.c index b7b2bbb7c..376abc56b 100644 --- a/src/MapRenderer.c +++ b/src/MapRenderer.c @@ -161,7 +161,7 @@ void MapRenderer_RenderNormal(double delta) { int batch; if (!mapChunks) return; - Gfx_SetBatchFormat(VERTEX_FORMAT_P3FT2FC4B); + Gfx_SetVertexFormat(VERTEX_FORMAT_P3FT2FC4B); Gfx_SetTexturing(true); Gfx_SetAlphaTest(true); @@ -240,7 +240,7 @@ void MapRenderer_RenderTranslucent(double delta) { /* First fill depth buffer */ vertices = Game_Vertices; - Gfx_SetBatchFormat(VERTEX_FORMAT_P3FT2FC4B); + Gfx_SetVertexFormat(VERTEX_FORMAT_P3FT2FC4B); Gfx_SetTexturing(false); Gfx_SetAlphaBlending(false); Gfx_SetColWriteMask(false, false, false, false); diff --git a/src/Menus.c b/src/Menus.c index ccbfb503f..fccf7242e 100644 --- a/src/Menus.c +++ b/src/Menus.c @@ -2,7 +2,6 @@ #include "Widgets.h" #include "Game.h" #include "Event.h" -#include "GraphicsCommon.h" #include "Platform.h" #include "Inventory.h" #include "Drawer2D.h" @@ -233,7 +232,7 @@ static void Menu_RenderBounds(void) { Then using wolfram alpha to solve the glblendfunc equation */ PackedCol topCol = PACKEDCOL_CONST(24, 24, 24, 105); PackedCol bottomCol = PACKEDCOL_CONST(51, 51, 98, 162); - GfxCommon_Draw2DGradient(0, 0, Game_Width, Game_Height, topCol, bottomCol); + Gfx_Draw2DGradient(0, 0, Game_Width, Game_Height, topCol, bottomCol); } static int Menu_DoMouseDown(void* screen, int x, int y, MouseButton btn) { @@ -900,8 +899,8 @@ static void EditHotkeyScreen_Render(void* screen, double delta) { MenuScreen_Render(screen, delta); x = Game_Width / 2; y = Game_Height / 2; - GfxCommon_Draw2DFlat(x - 250, y - 65, 500, 2, grey); - GfxCommon_Draw2DFlat(x - 250, y + 45, 500, 2, grey); + Gfx_Draw2DFlat(x - 250, y - 65, 500, 2, grey); + Gfx_Draw2DFlat(x - 250, y + 45, 500, 2, grey); } static void EditHotkeyScreen_Free(void* screen) { @@ -1311,7 +1310,7 @@ static void SaveLevelScreen_Render(void* screen, double delta) { MenuScreen_Render(screen, delta); x = Game_Width / 2; y = Game_Height / 2; - GfxCommon_Draw2DFlat(x - 250, y + 90, 500, 2, grey); + Gfx_Draw2DFlat(x - 250, y + 90, 500, 2, grey); } static void SaveLevelScreen_Free(void* screen) { @@ -1979,7 +1978,7 @@ static void MenuOptionsScreen_Render(void* screen, double delta) { if (!s->ExtHelp.LinesCount) return; w = &s->ExtHelp; - GfxCommon_Draw2DFlat(w->X - EXTHELP_PAD, w->Y - EXTHELP_PAD, + Gfx_Draw2DFlat(w->X - EXTHELP_PAD, w->Y - EXTHELP_PAD, w->Width + EXTHELP_PAD * 2, w->Height + EXTHELP_PAD * 2, tableCol); Gfx_SetTexturing(true); @@ -2996,12 +2995,12 @@ static void TexIdsOverlay_RenderTerrain(struct TexIdsOverlay* s) { tex.uv.V1 = Atlas1D_RowId(i + s->BaseTexLoc) * Atlas1D_InvTileSize; tex.uv.V2 = tex.uv.V1 + UV2_Scale * Atlas1D_InvTileSize; - GfxCommon_Make2DQuad(&tex, col, &ptr); + Gfx_Make2DQuad(&tex, col, &ptr); } Gfx_BindTexture(Atlas1D_TexIds[idx]); count = (int)(ptr - vertices); - GfxCommon_UpdateDynamicVb_IndexedTris(s->DynamicVb, vertices, count); + Gfx_UpdateDynamicVb_IndexedTris(s->DynamicVb, vertices, count); } } @@ -3028,7 +3027,7 @@ static void TexIdsOverlay_RenderTextOverlay(struct TexIdsOverlay* s) { Gfx_BindTexture(idAtlas->Tex.ID); count = (int)(ptr - vertices); - GfxCommon_UpdateDynamicVb_IndexedTris(s->DynamicVb, vertices, count); + Gfx_UpdateDynamicVb_IndexedTris(s->DynamicVb, vertices, count); ptr = vertices; } } @@ -3045,7 +3044,7 @@ static void TexIdsOverlay_Render(void* screen, double delta) { Menu_RenderBounds(); Gfx_SetTexturing(true); - Gfx_SetBatchFormat(VERTEX_FORMAT_P3FT2FC4B); + Gfx_SetVertexFormat(VERTEX_FORMAT_P3FT2FC4B); Menu_Render(s, delta); origXOffset = s->XOffset; diff --git a/src/Model.c b/src/Model.c index 244164024..696a9febd 100644 --- a/src/Model.c +++ b/src/Model.c @@ -2,7 +2,6 @@ #include "ExtMath.h" #include "Funcs.h" #include "Game.h" -#include "GraphicsCommon.h" #include "Graphics.h" #include "Entity.h" #include "Camera.h" @@ -108,7 +107,7 @@ void Model_Render(struct Model* model, struct Entity* entity) { if (model->Bobbing) pos.Y += entity->Anim.BobbingModel; Model_SetupState(model, entity); - Gfx_SetBatchFormat(VERTEX_FORMAT_P3FT2FC4B); + Gfx_SetVertexFormat(VERTEX_FORMAT_P3FT2FC4B); model->GetTransform(entity, pos, &entity->Transform); Matrix_Mul(&m, &entity->Transform, &Gfx_View); @@ -153,7 +152,7 @@ void Model_SetupState(struct Model* model, struct Entity* entity) { void Model_UpdateVB(void) { struct Model* model = Model_ActiveModel; - GfxCommon_UpdateDynamicVb_IndexedTris(Model_Vb, Model_Vertices, model->index); + Gfx_UpdateDynamicVb_IndexedTris(Model_Vb, Model_Vertices, model->index); model->index = 0; } @@ -255,7 +254,7 @@ void Model_RenderArm(struct Model* model, struct Entity* entity) { if (model->Bobbing) pos.Y += entity->Anim.BobbingModel; Model_SetupState(model, entity); - Gfx_SetBatchFormat(VERTEX_FORMAT_P3FT2FC4B); + Gfx_SetVertexFormat(VERTEX_FORMAT_P3FT2FC4B); Model_ApplyTexture(entity); if (Game_ClassicArmModel) { diff --git a/src/Particle.c b/src/Particle.c index 21673ff85..3ca7f8084 100644 --- a/src/Particle.c +++ b/src/Particle.c @@ -6,7 +6,6 @@ #include "Entity.h" #include "TerrainAtlas.h" #include "Graphics.h" -#include "GraphicsCommon.h" #include "Funcs.h" #include "Game.h" #include "Event.h" @@ -183,7 +182,7 @@ static void Rain_Render(float t) { } Gfx_BindTexture(Particles_TexId); - GfxCommon_UpdateDynamicVb_IndexedTris(Particles_VB, vertices, rain_count * 4); + Gfx_UpdateDynamicVb_IndexedTris(Particles_VB, vertices, rain_count * 4); } static void Rain_RemoveAt(int index) { @@ -369,7 +368,7 @@ void Particles_Render(double delta, float t) { Gfx_SetTexturing(true); Gfx_SetAlphaTest(true); - Gfx_SetBatchFormat(VERTEX_FORMAT_P3FT2FC4B); + Gfx_SetVertexFormat(VERTEX_FORMAT_P3FT2FC4B); Terrain_Render(t); Rain_Render(t); diff --git a/src/PickedPosRenderer.c b/src/PickedPosRenderer.c index ab86740fa..273120545 100644 --- a/src/PickedPosRenderer.c +++ b/src/PickedPosRenderer.c @@ -2,7 +2,6 @@ #include "PackedCol.h" #include "VertexStructs.h" #include "Graphics.h" -#include "GraphicsCommon.h" #include "Game.h" #include "Event.h" #include "Picking.h" @@ -38,9 +37,9 @@ void PickedPosRenderer_Render(double delta) { Gfx_SetAlphaBlending(true); Gfx_SetDepthWrite(false); - Gfx_SetBatchFormat(VERTEX_FORMAT_P3FC4B); + Gfx_SetVertexFormat(VERTEX_FORMAT_P3FC4B); - GfxCommon_UpdateDynamicVb_IndexedTris(pickedPos_vb, pickedPos_vertices, PICKEDPOS_NUM_VERTICES); + Gfx_UpdateDynamicVb_IndexedTris(pickedPos_vb, pickedPos_vertices, PICKEDPOS_NUM_VERTICES); Gfx_SetDepthWrite(true); Gfx_SetAlphaBlending(false); } diff --git a/src/Screens.c b/src/Screens.c index 84534ec0d..d28263971 100644 --- a/src/Screens.c +++ b/src/Screens.c @@ -2,7 +2,6 @@ #include "Widgets.h" #include "Game.h" #include "Event.h" -#include "GraphicsCommon.h" #include "Platform.h" #include "Inventory.h" #include "Drawer2D.h" @@ -299,7 +298,7 @@ static void StatusScreen_DrawPosition(struct StatusScreen* s) { /* Make "Position: " prefix */ tex = atlas->Tex; tex.X = 2; tex.Width = atlas->Offset; - GfxCommon_Make2DQuad(&tex, col, &ptr); + Gfx_Make2DQuad(&tex, col, &ptr); Vector3I_Floor(&pos, &LocalPlayer_Instance.Base.Position); atlas->CurX = atlas->Offset + 2; @@ -316,7 +315,7 @@ static void StatusScreen_DrawPosition(struct StatusScreen* s) { Gfx_BindTexture(atlas->Tex.ID); /* TODO: Do we need to use a separate VB here? */ count = (int)(ptr - vertices); - GfxCommon_UpdateDynamicVb_IndexedTris(Model_Vb, vertices, count); + Gfx_UpdateDynamicVb_IndexedTris(Model_Vb, vertices, count); } static bool StatusScreen_HacksChanged(struct StatusScreen* s) { @@ -524,9 +523,9 @@ static void LoadingScreen_UpdateBackgroundVB(VertexP3fT2fC4b* vertices, int coun Gfx_BindTexture(Atlas1D_TexIds[atlasIndex]); } - Gfx_SetBatchFormat(VERTEX_FORMAT_P3FT2FC4B); + Gfx_SetVertexFormat(VERTEX_FORMAT_P3FT2FC4B); /* TODO: Do we need to use a separate VB here? */ - GfxCommon_UpdateDynamicVb_IndexedTris(Model_Vb, vertices, count); + Gfx_UpdateDynamicVb_IndexedTris(Model_Vb, vertices, count); } #define LOADING_TILE_SIZE 64 @@ -548,7 +547,7 @@ static void LoadingScreen_DrawBackground(void) { for (y = 0; y < Game_Height; y += LOADING_TILE_SIZE) { tex.Y = y; - GfxCommon_Make2DQuad(&tex, col, &ptr); + Gfx_Make2DQuad(&tex, col, &ptr); count += 4; if (count < Array_Elems(vertices)) continue; @@ -590,8 +589,8 @@ static void LoadingScreen_Render(void* screen, double delta) { y = Gui_CalcPos(ANCHOR_CENTRE, 34, PROG_BAR_HEIGHT, Game_Height); progWidth = (int)(PROG_BAR_WIDTH * s->Progress); - GfxCommon_Draw2DFlat(x, y, PROG_BAR_WIDTH, PROG_BAR_HEIGHT, backCol); - GfxCommon_Draw2DFlat(x, y, progWidth, PROG_BAR_HEIGHT, progCol); + Gfx_Draw2DFlat(x, y, PROG_BAR_WIDTH, PROG_BAR_HEIGHT, backCol); + Gfx_Draw2DFlat(x, y, progWidth, PROG_BAR_HEIGHT, progCol); } static void LoadingScreen_Free(void* screen) { @@ -861,7 +860,7 @@ static void ChatScreen_RenderBackground(struct ChatScreen* s) { if (height > 0) { PackedCol backCol = PACKEDCOL_CONST(0, 0, 0, 127); - GfxCommon_Draw2DFlat(x - 5, y - 5, width + 10, height + 10, backCol); + Gfx_Draw2DFlat(x - 5, y - 5, width + 10, height + 10, backCol); } } @@ -1490,7 +1489,7 @@ static void DisconnectScreen_Render(void* screen, double delta) { PackedCol bottom = PACKEDCOL_CONST(80, 16, 16, 255); if (s->CanReconnect) { DisconnectScreen_UpdateDelayLeft(s, delta); } - GfxCommon_Draw2DGradient(0, 0, Game_Width, Game_Height, top, bottom); + Gfx_Draw2DGradient(0, 0, Game_Width, Game_Height, top, bottom); Gfx_SetTexturing(true); Elem_Render(&s->Title, delta); diff --git a/src/SelectionBox.c b/src/SelectionBox.c index f7b4330f4..d3d49c893 100644 --- a/src/SelectionBox.c +++ b/src/SelectionBox.c @@ -1,7 +1,6 @@ #include "SelectionBox.h" #include "ExtMath.h" #include "Graphics.h" -#include "GraphicsCommon.h" #include "Event.h" #include "Funcs.h" #include "Game.h" @@ -192,13 +191,13 @@ void Selections_Render(double delta) { SelectionBox_Render(&selections_list[i], &facesPtr, &edgesPtr); } - Gfx_SetBatchFormat(VERTEX_FORMAT_P3FC4B); - GfxCommon_UpdateDynamicVb_Lines(selections_LineVB, edgeVertices, + Gfx_SetVertexFormat(VERTEX_FORMAT_P3FC4B); + Gfx_UpdateDynamicVb_Lines(selections_LineVB, edgeVertices, selections_count * SELECTIONS_VERTICES); Gfx_SetDepthWrite(false); Gfx_SetAlphaBlending(true); - GfxCommon_UpdateDynamicVb_IndexedTris(selections_VB, faceVertices, + Gfx_UpdateDynamicVb_IndexedTris(selections_VB, faceVertices, selections_count * SELECTIONS_VERTICES); Gfx_SetDepthWrite(true); Gfx_SetAlphaBlending(false); diff --git a/src/Widgets.c b/src/Widgets.c index b6d51dec7..441b34ba8 100644 --- a/src/Widgets.c +++ b/src/Widgets.c @@ -1,7 +1,6 @@ #include "Widgets.h" #include "Graphics.h" #include "Drawer2D.h" -#include "GraphicsCommon.h" #include "ExtMath.h" #include "Funcs.h" #include "Window.h" @@ -141,11 +140,11 @@ static void ButtonWidget_Render(void* widget, double delta) { back.Width = (w->Width / 2); back.uv.U1 = 0.0f; back.uv.U2 = BUTTON_uWIDTH * scale; - GfxCommon_Draw2DTexture(&back, white); + Gfx_Draw2DTexture(&back, white); back.X += (w->Width / 2); back.uv.U1 = BUTTON_uWIDTH * (1.0f - scale); back.uv.U2 = BUTTON_uWIDTH; - GfxCommon_Draw2DTexture(&back, white); + Gfx_Draw2DTexture(&back, white); } if (!w->Texture.ID) return; @@ -225,7 +224,7 @@ static void ScrollbarWidget_Render(void* widget, double delta) { bool hovered; x = w->X; width = w->Width; - GfxCommon_Draw2DFlat(x, w->Y, width, w->Height, Scroll_BackCol); + Gfx_Draw2DFlat(x, w->Y, width, w->Height, Scroll_BackCol); ScrollbarWidget_GetScrollbarCoords(w, &y, &height); x += SCROLL_BORDER; y += w->Y; @@ -233,15 +232,15 @@ static void ScrollbarWidget_Render(void* widget, double delta) { hovered = Gui_Contains(x, y, width, height, Mouse_X, Mouse_Y); barCol = hovered ? Scroll_HoverCol : Scroll_BarCol; - GfxCommon_Draw2DFlat(x, y, width, height, barCol); + Gfx_Draw2DFlat(x, y, width, height, barCol); if (height < 20) return; x += SCROLL_NUBS_WIDTH; y += (height / 2); width -= SCROLL_NUBS_WIDTH * 2; - GfxCommon_Draw2DFlat(x, y - 1 - 4, width, SCROLL_BORDER, Scroll_BackCol); - GfxCommon_Draw2DFlat(x, y - 1, width, SCROLL_BORDER, Scroll_BackCol); - GfxCommon_Draw2DFlat(x, y - 1 + 4, width, SCROLL_BORDER, Scroll_BackCol); + Gfx_Draw2DFlat(x, y - 1 - 4, width, SCROLL_BORDER, Scroll_BackCol); + Gfx_Draw2DFlat(x, y - 1, width, SCROLL_BORDER, Scroll_BackCol); + Gfx_Draw2DFlat(x, y - 1 + 4, width, SCROLL_BORDER, Scroll_BackCol); } static bool ScrollbarWidget_MouseDown(void* widget, int x, int y, MouseButton btn) { @@ -334,7 +333,7 @@ static void HotbarWidget_RenderHotbarOutline(struct HotbarWidget* w) { w->SelTex.ID = tex; w->SelTex.X = (int)(x - w->SelBlockSize / 2); - GfxCommon_Draw2DTexture(&w->SelTex, white); + Gfx_Draw2DTexture(&w->SelTex, white); } static void HotbarWidget_RenderHotbarBlocks(struct HotbarWidget* w) { @@ -655,7 +654,7 @@ static void TableWidget_Render(void* widget, double delta) { PackedCol topSelCol = PACKEDCOL_CONST(255, 255, 255, 142); PackedCol bottomSelCol = PACKEDCOL_CONST(255, 255, 255, 192); - GfxCommon_Draw2DGradient(Table_X(w), Table_Y(w), + Gfx_Draw2DGradient(Table_X(w), Table_Y(w), Table_Width(w), Table_Height(w), topBackCol, bottomBackCol); if (w->RowsCount > TABLE_MAX_ROWS_DISPLAYED) { @@ -668,11 +667,11 @@ static void TableWidget_Render(void* widget, double delta) { off = cellSize * 0.1f; size = (int)(cellSize + off * 2); - GfxCommon_Draw2DGradient((int)(x - off), (int)(y - off), + Gfx_Draw2DGradient((int)(x - off), (int)(y - off), size, size, topSelCol, bottomSelCol); } Gfx_SetTexturing(true); - Gfx_SetBatchFormat(VERTEX_FORMAT_P3FT2FC4B); + Gfx_SetVertexFormat(VERTEX_FORMAT_P3FT2FC4B); IsometricDrawer_BeginBatch(vertices, w->VB); for (i = 0; i < w->ElementsCount; i++) { @@ -1465,7 +1464,7 @@ static void MenuInputWidget_Render(void* widget, double delta) { PackedCol backCol = PACKEDCOL_CONST(30, 30, 30, 200); Gfx_SetTexturing(false); - GfxCommon_Draw2DFlat(w->X, w->Y, w->Width, w->Height, backCol); + Gfx_Draw2DFlat(w->X, w->Y, w->Width, w->Height, backCol); Gfx_SetTexturing(true); Texture_Render(&w->InputTex); @@ -1642,7 +1641,7 @@ static void ChatInputWidget_Render(void* widget, double delta) { /* Cover whole window width to match original classic behaviour */ if (Game_PureClassic) { width = max(width, Game_Width - x * 4); } - GfxCommon_Draw2DFlat(x, y, width + w->Padding * 2, w->PrefixHeight, backCol); + Gfx_Draw2DFlat(x, y, width + w->Padding * 2, w->PrefixHeight, backCol); y += w->LineSizes[i].Height; } @@ -2169,7 +2168,7 @@ static void PlayerListWidget_Render(void* widget, double delta) { Gfx_SetTexturing(false); offset = title->Height + 10; height = max(300, w->Height + title->Height); - GfxCommon_Draw2DGradient(w->X, w->Y - offset, w->Width, height, topCol, bottomCol); + Gfx_Draw2DGradient(w->X, w->Y - offset, w->Width, height, topCol, bottomCol); Gfx_SetTexturing(true); title->YOffset = w->Y - offset + 5;