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

Redesign C client event handling, now with 1.24% less reliance on global variables

Browse Source
This commit is contained in:
UnknownShadow200 2018-01-20 11:39:14 +11:00
parent f6391555fe
commit 9c77405f3c
18 changed files with 294 additions and 287 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/Client/AxisLinesRenderer.c
View File

@ -14,17 +14,17 @@ GfxResourceID axisLines_vb;
#define axisLines_size (1.0f / 32.0f)
#define axisLines_length 3.0f
void AxisLinesRenderer_ContextLost(void) {
void AxisLinesRenderer_ContextLost(void* obj) {
Gfx_DeleteVb(&axisLines_vb);
}
void AxisLinesRenderer_Init(void) {
Event_RegisterVoid(&GfxEvents_ContextLost, AxisLinesRenderer_ContextLost);
Event_RegisterVoid(&GfxEvents_ContextLost, NULL, AxisLinesRenderer_ContextLost);
}
void AxisLinesRenderer_Free(void) {
AxisLinesRenderer_ContextLost();
Event_UnregisterVoid(&GfxEvents_ContextLost, AxisLinesRenderer_ContextLost);
AxisLinesRenderer_ContextLost(NULL);
Event_UnregisterVoid(&GfxEvents_ContextLost, NULL, AxisLinesRenderer_ContextLost);
}
IGameComponent AxisLinesRenderer_MakeGameComponent(void) {

37
src/Client/BordersRenderer.c
View File

@ -79,7 +79,7 @@ void BordersRenderer_CalculateRects(Int32 extent) {
borders_rects[3] = Rectangle2D_Make(World_Width, 0, extent, World_Length);
}
void BordersRenderer_ResetTextures(void) {
void BordersRenderer_ResetTextures(void* obj) {
borders_lastEdgeTexLoc = UInt8_MaxValue;
borders_lastSideTexLoc = UInt8_MaxValue;
BordersRenderer_MakeTexture(&borders_edgeTexId, &borders_lastEdgeTexLoc, WorldEnv_EdgeBlock);
@ -256,25 +256,28 @@ void BordersRenderer_ResetEdges(void) {
BordersRenderer_RebuildEdges(WorldEnv_EdgeHeight, BordersRenderer_Legacy ? 128 : 65536);
}
void BordersRenderer_ContextLost(void) {
void BordersRenderer_ContextLost(void* obj) {
Gfx_DeleteVb(&borders_sidesVb);
Gfx_DeleteVb(&borders_edgesVb);
Gfx_DeleteTexture(&borders_edgeTexId);
Gfx_DeleteTexture(&borders_sideTexId);
}
void BordersRenderer_ContextRecreated(void) {
void BordersRenderer_ContextRecreated(void* obj) {
BordersRenderer_ResetSides();
BordersRenderer_ResetEdges();
BordersRenderer_ResetTextures();
BordersRenderer_ResetTextures(NULL);
}
void BordersRenderer_ResetSidesAndEdges(void) {
BordersRenderer_CalculateRects((Int32)Game_ViewDistance);
BordersRenderer_ContextRecreated();
BordersRenderer_ContextRecreated(NULL);
}
void BordersRenderer_ResetSidesAndEdges_Handler(void* obj) {
BordersRenderer_ResetSidesAndEdges();
}
void BordersRenderer_EnvVariableChanged(Int32 envVar) {
void BordersRenderer_EnvVariableChanged(void* obj, Int32 envVar) {
if (envVar == ENV_VAR_EDGE_BLOCK) {
BordersRenderer_MakeTexture(&borders_edgeTexId, &borders_lastEdgeTexLoc, WorldEnv_EdgeBlock);
BordersRenderer_ResetEdges();
@ -296,20 +299,20 @@ void BordersRenderer_UseLegacyMode(bool legacy) {
}
void BordersRenderer_Init(void) {
Event_RegisterInt32(&WorldEvents_EnvVarChanged, BordersRenderer_EnvVariableChanged);
Event_RegisterVoid(&GfxEvents_ViewDistanceChanged, BordersRenderer_ResetSidesAndEdges);
Event_RegisterVoid(&TextureEvents_AtlasChanged, BordersRenderer_ResetTextures);
Event_RegisterVoid(&GfxEvents_ContextLost, BordersRenderer_ContextLost);
Event_RegisterVoid(&GfxEvents_ContextRecreated, BordersRenderer_ContextRecreated);
Event_RegisterInt32(&WorldEvents_EnvVarChanged, NULL, BordersRenderer_EnvVariableChanged);
Event_RegisterVoid(&GfxEvents_ViewDistanceChanged, NULL, BordersRenderer_ResetSidesAndEdges_Handler);
Event_RegisterVoid(&TextureEvents_AtlasChanged, NULL, BordersRenderer_ResetTextures);
Event_RegisterVoid(&GfxEvents_ContextLost, NULL, BordersRenderer_ContextLost);
Event_RegisterVoid(&GfxEvents_ContextRecreated, NULL, BordersRenderer_ContextRecreated);
}
void BordersRenderer_Free(void) {
BordersRenderer_ContextLost();
Event_UnregisterInt32(&WorldEvents_EnvVarChanged, BordersRenderer_EnvVariableChanged);
Event_UnregisterVoid(&GfxEvents_ViewDistanceChanged, BordersRenderer_ResetSidesAndEdges);
Event_UnregisterVoid(&TextureEvents_AtlasChanged, BordersRenderer_ResetTextures);
Event_UnregisterVoid(&GfxEvents_ContextLost, BordersRenderer_ContextLost);
Event_UnregisterVoid(&GfxEvents_ContextRecreated, BordersRenderer_ContextRecreated);
BordersRenderer_ContextLost(NULL);
Event_UnregisterInt32(&WorldEvents_EnvVarChanged, NULL, BordersRenderer_EnvVariableChanged);
Event_UnregisterVoid(&GfxEvents_ViewDistanceChanged, NULL, BordersRenderer_ResetSidesAndEdges_Handler);
Event_UnregisterVoid(&TextureEvents_AtlasChanged, NULL, BordersRenderer_ResetTextures);
Event_UnregisterVoid(&GfxEvents_ContextLost, NULL, BordersRenderer_ContextLost);
Event_UnregisterVoid(&GfxEvents_ContextRecreated, NULL, BordersRenderer_ContextRecreated);
}
void BordersRenderer_Reset(void) {

58
src/Client/ChunkUpdater.c
View File

@ -32,7 +32,7 @@ Vector3 cu_lastCamPos;
Real32 cu_lastHeadY, cu_lastHeadX;
Int32 cu_elementsPerBitmap;
void ChunkUpdater_EnvVariableChanged(Int32 envVar) {
void ChunkUpdater_EnvVariableChanged(void* obj, Int32 envVar) {
if (envVar == ENV_VAR_SUN_COL || envVar == ENV_VAR_SHADOW_COL) {
ChunkUpdater_Refresh();
} else if (envVar == ENV_VAR_EDGE_HEIGHT || envVar == ENV_VAR_SIDES_OFFSET) {
@ -45,7 +45,7 @@ void ChunkUpdater_EnvVariableChanged(Int32 envVar) {
}
}
void ChunkUpdater_TerrainAtlasChanged(void) {
void ChunkUpdater_TerrainAtlasChanged(void* obj) {
if (MapRenderer_1DUsedCount != 0) {
bool refreshRequired = cu_elementsPerBitmap != Atlas1D_ElementsPerBitmap;
if (refreshRequired) ChunkUpdater_Refresh();
@ -56,17 +56,17 @@ void ChunkUpdater_TerrainAtlasChanged(void) {
ChunkUpdater_ResetPartFlags();
}
void ChunkUpdater_BlockDefinitionChanged(void) {
void ChunkUpdater_BlockDefinitionChanged(void* obj) {
MapRenderer_1DUsedCount = Atlas1D_UsedAtlasesCount();
ChunkUpdater_ResetPartFlags();
ChunkUpdater_Refresh();
}
void ChunkUpdater_ProjectionChanged(void) {
void ChunkUpdater_ProjectionChanged(void* obj) {
ChunkUpdater_ChunkPos = Vector3I_Create1(Int32_MaxValue);
}
void ChunkUpdater_ViewDistanceChanged(void) {
void ChunkUpdater_ViewDistanceChanged(void* obj) {
ChunkUpdater_ChunkPos = Vector3I_Create1(Int32_MaxValue);
}
@ -78,6 +78,9 @@ void ChunkUpdater_Refresh(void) {
}
ChunkUpdater_ResetPartCounts();
}
void ChunkUpdater_Refresh_Handler(void* obj) {
ChunkUpdater_Refresh();
}
void ChunkUpdater_RefreshBorders(Int32 clipLevel) {
ChunkUpdater_ChunkPos = Vector3I_Create1(Int32_MaxValue);
@ -135,7 +138,7 @@ void ChunkUpdater_PerformAllocations(void) {
Platform_MemSet(MapRenderer_PartsBuffer, 0, partsSize);
}
void ChunkUpdater_OnNewMap(void) {
void ChunkUpdater_OnNewMap(void* obj) {
Game_ChunkUpdates = 0;
ChunkUpdater_ClearChunkCache();
ChunkUpdater_ResetPartCounts();
@ -143,7 +146,7 @@ void ChunkUpdater_OnNewMap(void) {
ChunkUpdater_FreeAllocations();
}
void ChunkUpdater_OnNewMapLoaded(void) {
void ChunkUpdater_OnNewMapLoaded(void* obj) {
MapRenderer_ChunksX = (World_Width + CHUNK_MAX) >> CHUNK_SHIFT;
MapRenderer_ChunksY = (World_Height + CHUNK_MAX) >> CHUNK_SHIFT;
MapRenderer_ChunksZ = (World_Length + CHUNK_MAX) >> CHUNK_SHIFT;
@ -306,6 +309,9 @@ void ChunkUpdater_ClearChunkCache(void) {
}
ChunkUpdater_ResetPartCounts();
}
void ChunkUpdater_ClearChunkCache_Handler(void* obj) {
ChunkUpdater_ClearChunkCache();
}
#define ChunkUpdater_DeleteParts(parts, partsCount)\
@ -416,32 +422,32 @@ void ChunkUpdater_UpdateSortOrder(void) {
}
void ChunkUpdater_Init(void) {
Event_RegisterVoid(&TextureEvents_AtlasChanged, ChunkUpdater_TerrainAtlasChanged);
Event_RegisterVoid(&WorldEvents_NewMap, ChunkUpdater_OnNewMap);
Event_RegisterVoid(&WorldEvents_MapLoaded, ChunkUpdater_OnNewMapLoaded);
Event_RegisterInt32(&WorldEvents_EnvVarChanged, ChunkUpdater_EnvVariableChanged);
Event_RegisterVoid(&TextureEvents_AtlasChanged, NULL, ChunkUpdater_TerrainAtlasChanged);
Event_RegisterVoid(&WorldEvents_NewMap, NULL, ChunkUpdater_OnNewMap);
Event_RegisterVoid(&WorldEvents_MapLoaded, NULL, ChunkUpdater_OnNewMapLoaded);
Event_RegisterInt32(&WorldEvents_EnvVarChanged, NULL, ChunkUpdater_EnvVariableChanged);
Event_RegisterVoid(&BlockEvents_BlockDefChanged, ChunkUpdater_BlockDefinitionChanged);
Event_RegisterVoid(&GfxEvents_ViewDistanceChanged, ChunkUpdater_ViewDistanceChanged);
Event_RegisterVoid(&GfxEvents_ProjectionChanged, ChunkUpdater_ProjectionChanged);
Event_RegisterVoid(&GfxEvents_ContextLost, ChunkUpdater_ClearChunkCache);
Event_RegisterVoid(&GfxEvents_ContextRecreated, ChunkUpdater_Refresh);
Event_RegisterVoid(&BlockEvents_BlockDefChanged, NULL, ChunkUpdater_BlockDefinitionChanged);
Event_RegisterVoid(&GfxEvents_ViewDistanceChanged, NULL, ChunkUpdater_ViewDistanceChanged);
Event_RegisterVoid(&GfxEvents_ProjectionChanged, NULL, ChunkUpdater_ProjectionChanged);
Event_RegisterVoid(&GfxEvents_ContextLost, NULL, ChunkUpdater_ClearChunkCache_Handler);
Event_RegisterVoid(&GfxEvents_ContextRecreated, NULL, ChunkUpdater_Refresh_Handler);
ChunkUpdater_ChunkPos = Vector3I_Create1(Int32_MaxValue);
ChunkUpdater_ApplyMeshBuilder();
}
void ChunkUpdater_Free(void) {
Event_UnregisterVoid(&TextureEvents_AtlasChanged, ChunkUpdater_TerrainAtlasChanged);
Event_UnregisterVoid(&WorldEvents_NewMap, ChunkUpdater_OnNewMap);
Event_UnregisterVoid(&WorldEvents_MapLoaded, ChunkUpdater_OnNewMapLoaded);
Event_UnregisterInt32(&WorldEvents_EnvVarChanged, ChunkUpdater_EnvVariableChanged);
Event_UnregisterVoid(&TextureEvents_AtlasChanged, NULL, ChunkUpdater_TerrainAtlasChanged);
Event_UnregisterVoid(&WorldEvents_NewMap, NULL, ChunkUpdater_OnNewMap);
Event_UnregisterVoid(&WorldEvents_MapLoaded, NULL, ChunkUpdater_OnNewMapLoaded);
Event_UnregisterInt32(&WorldEvents_EnvVarChanged, NULL, ChunkUpdater_EnvVariableChanged);
Event_UnregisterVoid(&BlockEvents_BlockDefChanged, ChunkUpdater_BlockDefinitionChanged);
Event_UnregisterVoid(&GfxEvents_ViewDistanceChanged, ChunkUpdater_ViewDistanceChanged);
Event_UnregisterVoid(&GfxEvents_ProjectionChanged, ChunkUpdater_ProjectionChanged);
Event_UnregisterVoid(&GfxEvents_ContextLost, ChunkUpdater_ClearChunkCache);
Event_UnregisterVoid(&GfxEvents_ContextRecreated, ChunkUpdater_Refresh);
Event_UnregisterVoid(&BlockEvents_BlockDefChanged, NULL, ChunkUpdater_BlockDefinitionChanged);
Event_UnregisterVoid(&GfxEvents_ViewDistanceChanged, NULL, ChunkUpdater_ViewDistanceChanged);
Event_UnregisterVoid(&GfxEvents_ProjectionChanged, NULL, ChunkUpdater_ProjectionChanged);
Event_UnregisterVoid(&GfxEvents_ContextLost, NULL, ChunkUpdater_ClearChunkCache_Handler);
Event_UnregisterVoid(&GfxEvents_ContextRecreated, NULL, ChunkUpdater_Refresh_Handler);
ChunkUpdater_OnNewMap();
ChunkUpdater_OnNewMap(NULL);
}

18
src/Client/Entity.c
View File

@ -286,7 +286,7 @@ void Entities_RenderHoveredNames(Real64 delta) {
if (hadFog) Gfx_SetFog(true);
}
void Entities_ContextLost(void) {
void Entities_ContextLost(void* obj) {
UInt32 i;
for (i = 0; i < ENTITIES_MAX_COUNT; i++) {
if (Entities_List[i] == NULL) continue;
@ -295,7 +295,7 @@ void Entities_ContextLost(void) {
Gfx_DeleteTexture(&ShadowComponent_ShadowTex);
}
void Entities_ContextRecreated(void) {
void Entities_ContextRecreated(void* obj) {
UInt32 i;
for (i = 0; i < ENTITIES_MAX_COUNT; i++) {
if (Entities_List[i] == NULL) continue;
@ -303,7 +303,7 @@ void Entities_ContextRecreated(void) {
}
}
void Entities_ChatFontChanged(void) {
void Entities_ChatFontChanged(void* obj) {
UInt32 i;
for (i = 0; i < ENTITIES_MAX_COUNT; i++) {
if (Entities_List[i] == NULL) continue;
@ -313,9 +313,9 @@ void Entities_ChatFontChanged(void) {
}
void Entities_Init(void) {
Event_RegisterVoid(&GfxEvents_ContextLost, Entities_ContextLost);
Event_RegisterVoid(&GfxEvents_ContextRecreated, Entities_ContextRecreated);
Event_RegisterVoid(&ChatEvents_FontChanged, Entities_ChatFontChanged);
Event_RegisterVoid(&GfxEvents_ContextLost, NULL, Entities_ContextLost);
Event_RegisterVoid(&GfxEvents_ContextRecreated, NULL, Entities_ContextRecreated);
Event_RegisterVoid(&ChatEvents_FontChanged, NULL, Entities_ChatFontChanged);
Entities_NameMode = Options_GetEnum(OPTION_NAMES_MODE, NAME_MODE_HOVERED,
NameMode_Names, Array_NumElements(NameMode_Names));
@ -333,9 +333,9 @@ void Entities_Free(void) {
Entities_Remove((EntityID)i);
}
Event_UnregisterVoid(&GfxEvents_ContextLost, Entities_ContextLost);
Event_UnregisterVoid(&GfxEvents_ContextRecreated, Entities_ContextRecreated);
Event_UnregisterVoid(&ChatEvents_FontChanged, Entities_ChatFontChanged);
Event_UnregisterVoid(&GfxEvents_ContextLost, NULL, Entities_ContextLost);
Event_UnregisterVoid(&GfxEvents_ContextRecreated, NULL, Entities_ContextRecreated);
Event_UnregisterVoid(&ChatEvents_FontChanged, NULL, Entities_ChatFontChanged);
if (ShadowComponent_ShadowTex != NULL) {
Gfx_DeleteTexture(&ShadowComponent_ShadowTex);

40
src/Client/EnvRenderer.c
View File

@ -249,13 +249,13 @@ void EnvRenderer_ResetSky(void) {
EnvRenderer_RebuildSky((Int32)Game_ViewDistance, EnvRenderer_Legacy ? 128 : 65536);
}
void EnvRenderer_ContextLost(void) {
void EnvRenderer_ContextLost(void* obj) {
Gfx_DeleteVb(&env_skyVb);
Gfx_DeleteVb(&env_cloudsVb);
}
void EnvRenderer_ContextRecreated(void) {
EnvRenderer_ContextLost();
void EnvRenderer_ContextRecreated(void* obj) {
EnvRenderer_ContextLost(NULL);
Gfx_SetFog(!EnvRenderer_Minimal);
if (EnvRenderer_Minimal) {
@ -267,12 +267,12 @@ void EnvRenderer_ContextRecreated(void) {
}
}
void EnvRenderer_ResetAllEnv(void) {
void EnvRenderer_ResetAllEnv(void* obj) {
EnvRenderer_UpdateFog();
EnvRenderer_ContextRecreated();
EnvRenderer_ContextRecreated(NULL);
}
void EnvRenderer_EnvVariableChanged(Int32 envVar) {
void EnvRenderer_EnvVariableChanged(void* obj, Int32 envVar) {
if (EnvRenderer_Minimal) return;
if (envVar == ENV_VAR_SKY_COL) {
@ -290,39 +290,39 @@ void EnvRenderer_EnvVariableChanged(Int32 envVar) {
void EnvRenderer_UseLegacyMode(bool legacy) {
EnvRenderer_Legacy = legacy;
EnvRenderer_ContextRecreated();
EnvRenderer_ContextRecreated(NULL);
}
void EnvRenderer_UseMinimalMode(bool minimal) {
EnvRenderer_Minimal = minimal;
EnvRenderer_ContextRecreated();
EnvRenderer_ContextRecreated(NULL);
}
void EnvRenderer_Init(void) {
EnvRenderer_ResetAllEnv();
Event_RegisterVoid(&GfxEvents_ViewDistanceChanged, EnvRenderer_ResetAllEnv);
Event_RegisterVoid(&GfxEvents_ContextLost, EnvRenderer_ContextLost);
Event_RegisterVoid(&GfxEvents_ContextRecreated, EnvRenderer_ContextRecreated);
Event_RegisterInt32(&WorldEvents_EnvVarChanged, EnvRenderer_EnvVariableChanged);
EnvRenderer_ResetAllEnv(NULL);
Event_RegisterVoid(&GfxEvents_ViewDistanceChanged, NULL, EnvRenderer_ResetAllEnv);
Event_RegisterVoid(&GfxEvents_ContextLost, NULL, EnvRenderer_ContextLost);
Event_RegisterVoid(&GfxEvents_ContextRecreated, NULL, EnvRenderer_ContextRecreated);
Event_RegisterInt32(&WorldEvents_EnvVarChanged, NULL, EnvRenderer_EnvVariableChanged);
Game_SetViewDistance(Game_UserViewDistance, false);
}
void EnvRenderer_OnNewMap(void) {
Gfx_SetFog(false);
EnvRenderer_ContextLost();
EnvRenderer_ContextLost(NULL);
}
void EnvRenderer_OnNewMapLoaded(void) {
Gfx_SetFog(!EnvRenderer_Minimal);
EnvRenderer_ResetAllEnv();
EnvRenderer_ResetAllEnv(NULL);
}
void EnvRenderer_Free(void) {
EnvRenderer_ContextLost();
Event_UnregisterVoid(&GfxEvents_ViewDistanceChanged, EnvRenderer_ResetAllEnv);
Event_UnregisterVoid(&GfxEvents_ContextLost, EnvRenderer_ContextLost);
Event_UnregisterVoid(&GfxEvents_ContextRecreated, EnvRenderer_ContextRecreated);
Event_UnregisterInt32(&WorldEvents_EnvVarChanged, EnvRenderer_EnvVariableChanged);
EnvRenderer_ContextLost(NULL);
Event_UnregisterVoid(&GfxEvents_ViewDistanceChanged, NULL, EnvRenderer_ResetAllEnv);
Event_UnregisterVoid(&GfxEvents_ContextLost, NULL, EnvRenderer_ContextLost);
Event_UnregisterVoid(&GfxEvents_ContextRecreated, NULL, EnvRenderer_ContextRecreated);
Event_UnregisterInt32(&WorldEvents_EnvVarChanged, NULL, EnvRenderer_EnvVariableChanged);
}
IGameComponent EnvRenderer_MakeGameComponent(void) {

94
src/Client/Event.c
View File

@ -1,10 +1,12 @@
#include "Event.h"
#include "ErrorHandler.h"
void Event_RegisterImpl(Event_Void* handlers, Event_Void_Callback handler) {
void Event_RegisterImpl(Event_Void* handlers, void* obj, Event_Void_Callback handler) {
UInt32 i;
for (i = 0; i < handlers->Count; i++) {
if (handlers->Handlers[i] == handler) return;
if (handlers->Handlers[i] == handler && handlers->Objs[i] == obj) {
ErrorHandler_Fail("Attempt to register event handler that was already registered");
}
}
if (handlers->Count == EVENT_MAX_CALLBACKS) {
@ -15,124 +17,126 @@ void Event_RegisterImpl(Event_Void* handlers, Event_Void_Callback handler) {
}
}
void Event_UnregisterImpl(Event_Void* handlers, Event_Void_Callback handler) {
void Event_UnregisterImpl(Event_Void* handlers, void* obj, Event_Void_Callback handler) {
UInt32 i, j;
for (i = 0; i < handlers->Count; i++) {
if (handlers->Handlers[i] != handler) continue;
if (handlers->Handlers[i] != handler || handlers->Objs[i] != obj) continue;
/* Remove this handler from the list, by shifting all following handlers left */
for (j = i; j < handlers->Count - 1; j++) {
handlers->Handlers[j] = handlers->Handlers[j + 1];
handlers->Objs[j] = handlers->Objs[j + 1];
}
handlers->Handlers[handlers->Count - 1] = NULL;
handlers->Objs[handlers->Count - 1] = NULL;
handlers->Count--;
return;
}
ErrorHandler_Fail("Unregistering event handler that was not registered to begin with");
ErrorHandler_Fail("Attempt to unregister event handler that was not registered to begin with");
}
void Event_RaiseVoid(Event_Void* handlers) {
UInt32 i;
for (i = 0; i < handlers->Count; i++) {
handlers->Handlers[i]();
handlers->Handlers[i](handlers->Objs[i]);
}
}
void Event_RegisterVoid(Event_Void* handlers, Event_Void_Callback handler) {
Event_RegisterImpl(handlers, handler);
void Event_RegisterVoid(Event_Void* handlers, void* obj, Event_Void_Callback handler) {
Event_RegisterImpl(handlers, obj, handler);
}
void Event_UnregisterVoid(Event_Void* handlers, Event_Void_Callback handler) {
Event_UnregisterImpl(handlers, handler);
void Event_UnregisterVoid(Event_Void* handlers, void* obj, Event_Void_Callback handler) {
Event_UnregisterImpl(handlers, obj, handler);
}
void Event_RaiseInt32(Event_Int32* handlers, Int32 arg) {
UInt32 i;
for (i = 0; i < handlers->Count; i++) {
handlers->Handlers[i](arg);
handlers->Handlers[i](handlers->Objs[i], arg);
}
}
void Event_RegisterInt32(Event_Int32* handlers,Event_Int32_Callback handler) {
Event_RegisterImpl((Event_Void*)handlers, (Event_Void_Callback)handler);
void Event_RegisterInt32(Event_Int32* handlers, void* obj, Event_Int32_Callback handler) {
Event_RegisterImpl((Event_Void*)handlers, obj, (Event_Void_Callback)handler);
}
void Event_UnregisterInt32(Event_Int32* handlers, Event_Int32_Callback handler) {
Event_UnregisterImpl((Event_Void*)handlers, (Event_Void_Callback)handler);
void Event_UnregisterInt32(Event_Int32* handlers, void* obj, Event_Int32_Callback handler) {
Event_UnregisterImpl((Event_Void*)handlers, obj, (Event_Void_Callback)handler);
}
void Event_RaiseReal32(Event_Real32* handlers, Real32 arg) {
UInt32 i;
for (i = 0; i < handlers->Count; i++) {
handlers->Handlers[i](arg);
handlers->Handlers[i](handlers->Objs[i], arg);
}
}
void Event_RegisterReal32(Event_Real32* handlers, Event_Real32_Callback handler) {
Event_RegisterImpl((Event_Void*)handlers, (Event_Void_Callback)handler);
void Event_RegisterReal32(Event_Real32* handlers, void* obj, Event_Real32_Callback handler) {
Event_RegisterImpl((Event_Void*)handlers, obj, (Event_Void_Callback)handler);
}
void Event_UnregisterReal32(Event_Real32* handlers, Event_Real32_Callback handler) {
Event_UnregisterImpl((Event_Void*)handlers, (Event_Void_Callback)handler);
void Event_UnregisterReal32(Event_Real32* handlers, void* obj, Event_Real32_Callback handler) {
Event_UnregisterImpl((Event_Void*)handlers, obj, (Event_Void_Callback)handler);
}
void Event_RaiseEntityID(Event_EntityID* handlers, EntityID arg) {
UInt32 i;
for (i = 0; i < handlers->Count; i++) {
handlers->Handlers[i](arg);
handlers->Handlers[i](handlers->Objs[i], arg);
}
}
void Event_RegisterEntityID(Event_EntityID* handlers, Event_EntityID_Callback handler) {
Event_RegisterImpl((Event_Void*)handlers, (Event_Void_Callback)handler);
void Event_RegisterEntityID(Event_EntityID* handlers, void* obj, Event_EntityID_Callback handler) {
Event_RegisterImpl((Event_Void*)handlers, obj, (Event_Void_Callback)handler);
}
void Event_UnregisterEntityID(Event_EntityID* handlers, Event_EntityID_Callback handler) {
Event_UnregisterImpl((Event_Void*)handlers, (Event_Void_Callback)handler);
void Event_UnregisterEntityID(Event_EntityID* handlers, void* obj, Event_EntityID_Callback handler) {
Event_UnregisterImpl((Event_Void*)handlers, obj, (Event_Void_Callback)handler);
}
void Event_RaiseStream(Event_Stream* handlers, Stream* stream) {
UInt32 i;
for (i = 0; i < handlers->Count; i++) {
handlers->Handlers[i](stream);
handlers->Handlers[i](handlers->Objs[i], stream);
}
}
void Event_RegisterStream(Event_Stream* handlers, Event_Stream_Callback handler) {
Event_RegisterImpl((Event_Void*)handlers, (Event_Void_Callback)handler);
void Event_RegisterStream(Event_Stream* handlers, void* obj, Event_Stream_Callback handler) {
Event_RegisterImpl((Event_Void*)handlers, obj, (Event_Void_Callback)handler);
}
void Event_UnregisterStream(Event_Stream* handlers, Event_Stream_Callback handler) {
Event_UnregisterImpl((Event_Void*)handlers, (Event_Void_Callback)handler);
void Event_UnregisterStream(Event_Stream* handlers, void* obj, Event_Stream_Callback handler) {
Event_UnregisterImpl((Event_Void*)handlers, obj, (Event_Void_Callback)handler);
}
void Event_RaiseBlock(Event_Block* handlers, Vector3I coords, BlockID oldBlock, BlockID block) {
UInt32 i;
for (i = 0; i < handlers->Count; i++) {
handlers->Handlers[i](coords, oldBlock, block);
handlers->Handlers[i](handlers->Objs[i], coords, oldBlock, block);
}
}
void Event_RegisterBlock(Event_Block* handlers, Event_Block_Callback handler) {
Event_RegisterImpl((Event_Void*)handlers, (Event_Void_Callback)handler);
void Event_RegisterBlock(Event_Block* handlers, void* obj, Event_Block_Callback handler) {
Event_RegisterImpl((Event_Void*)handlers, obj, (Event_Void_Callback)handler);
}
void Event_UnregisterBlock(Event_Block* handlers, Event_Block_Callback handler) {
Event_UnregisterImpl((Event_Void*)handlers, (Event_Void_Callback)handler);
void Event_UnregisterBlock(Event_Block* handlers, void* obj, Event_Block_Callback handler) {
Event_UnregisterImpl((Event_Void*)handlers, obj, (Event_Void_Callback)handler);
}
void Event_RaiseMouseMove(Event_MouseMove* handlers, Int32 xDelta, Int32 yDelta) {
UInt32 i;
for (i = 0; i < handlers->Count; i++) {
handlers->Handlers[i](xDelta, yDelta);
handlers->Handlers[i](handlers->Objs[i], xDelta, yDelta);
}
}
void Event_RegisterMouseMove(Event_MouseMove* handlers, Event_MouseMove_Callback handler) {
Event_RegisterImpl((Event_Void*)handlers, (Event_Void_Callback)handler);
void Event_RegisterMouseMove(Event_MouseMove* handlers, void* obj, Event_MouseMove_Callback handler) {
Event_RegisterImpl((Event_Void*)handlers, obj, (Event_Void_Callback)handler);
}
void Event_UnregisterMouseMove(Event_MouseMove* handlers, Event_MouseMove_Callback handler) {
Event_UnregisterImpl((Event_Void*)handlers, (Event_Void_Callback)handler);
void Event_UnregisterMouseMove(Event_MouseMove* handlers, void* obj, Event_MouseMove_Callback handler) {
Event_UnregisterImpl((Event_Void*)handlers, obj, (Event_Void_Callback)handler);
}
void Event_RaiseChat(Event_Chat* handlers, String* msg, UInt8 msgType) {
UInt32 i;
for (i = 0; i < handlers->Count; i++) {
handlers->Handlers[i](msg, msgType);
handlers->Handlers[i](handlers->Objs[i], msg, msgType);
}
}
void Event_RegisterChat(Event_Chat* handlers, Event_Chat_Callback handler) {
Event_RegisterImpl((Event_Void*)handlers, (Event_Void_Callback)handler);
void Event_RegisterChat(Event_Chat* handlers, void* obj, Event_Chat_Callback handler) {
Event_RegisterImpl((Event_Void*)handlers, obj, (Event_Void_Callback)handler);
}
void Event_UnregisterChat(Event_Chat* handlers, Event_Chat_Callback handler) {
Event_UnregisterImpl((Event_Void*)handlers, (Event_Void_Callback)handler);
void Event_UnregisterChat(Event_Chat* handlers, void* obj, Event_Chat_Callback handler) {
Event_UnregisterImpl((Event_Void*)handlers, obj, (Event_Void_Callback)handler);
}

72
src/Client/Event.h
View File

@ -11,77 +11,85 @@
/* Maximum number of event handlers that can be registered. */
#define EVENT_MAX_CALLBACKS 32
typedef void(*Event_Void_Callback)(void);
typedef void(*Event_Void_Callback)(void* obj);
typedef struct Event_Void_ {
Event_Void_Callback Handlers[EVENT_MAX_CALLBACKS]; UInt32 Count;
Event_Void_Callback Handlers[EVENT_MAX_CALLBACKS];
void* Objs[EVENT_MAX_CALLBACKS]; UInt32 Count;
} Event_Void;
typedef void(*Event_Int32_Callback)(Int32 argument);
typedef void (*Event_Int32_Callback)(void* obj, Int32 argument);
typedef struct Event_Int32_ {
Event_Int32_Callback Handlers[EVENT_MAX_CALLBACKS]; UInt32 Count;
Event_Int32_Callback Handlers[EVENT_MAX_CALLBACKS];
void* Objs[EVENT_MAX_CALLBACKS]; UInt32 Count;
} Event_Int32;
typedef void(*Event_Real32_Callback)(Real32 argument);
typedef void (*Event_Real32_Callback)(void* obj, Real32 argument);
typedef struct Event_Real32_ {
Event_Real32_Callback Handlers[EVENT_MAX_CALLBACKS]; UInt32 Count;
Event_Real32_Callback Handlers[EVENT_MAX_CALLBACKS];
void* Objs[EVENT_MAX_CALLBACKS]; UInt32 Count;
} Event_Real32;
typedef void(*Event_EntityID_Callback)(EntityID argument);
typedef void (*Event_EntityID_Callback)(void* obj, EntityID argument);
typedef struct Event_EntityID_ {
Event_EntityID_Callback Handlers[EVENT_MAX_CALLBACKS]; UInt32 Count;
Event_EntityID_Callback Handlers[EVENT_MAX_CALLBACKS];
void* Objs[EVENT_MAX_CALLBACKS]; UInt32 Count;
} Event_EntityID;
typedef void(*Event_Stream_Callback)(Stream* stream);
typedef void (*Event_Stream_Callback)(void* obj, Stream* stream);
typedef struct Event_Stream_ {
Event_Stream_Callback Handlers[EVENT_MAX_CALLBACKS]; UInt32 Count;
Event_Stream_Callback Handlers[EVENT_MAX_CALLBACKS];
void* Objs[EVENT_MAX_CALLBACKS]; UInt32 Count;
} Event_Stream;
typedef void(*Event_Block_Callback)(Vector3I coords, BlockID oldBlock, BlockID block);
typedef void (*Event_Block_Callback)(void* obj, Vector3I coords, BlockID oldBlock, BlockID block);
typedef struct Event_Block_ {
Event_Block_Callback Handlers[EVENT_MAX_CALLBACKS]; UInt32 Count;
Event_Block_Callback Handlers[EVENT_MAX_CALLBACKS];
void* Objs[EVENT_MAX_CALLBACKS]; UInt32 Count;
} Event_Block;
typedef void(*Event_MouseMove_Callback)(Int32 xDelta, Int32 yDelta);
typedef void (*Event_MouseMove_Callback)(void* obj, Int32 xDelta, Int32 yDelta);
typedef struct Event_MouseMove_ {
Event_MouseMove_Callback Handlers[EVENT_MAX_CALLBACKS]; UInt32 Count;
Event_MouseMove_Callback Handlers[EVENT_MAX_CALLBACKS];
void* Objs[EVENT_MAX_CALLBACKS]; UInt32 Count;
} Event_MouseMove;
typedef void(*Event_Chat_Callback)(String* msg, UInt8 msgType);
typedef void (*Event_Chat_Callback)(void* obj, String* msg, UInt8 msgType);
typedef struct Event_Chat_ {
Event_Chat_Callback Handlers[EVENT_MAX_CALLBACKS]; UInt32 Count;
Event_Chat_Callback Handlers[EVENT_MAX_CALLBACKS];
void* Objs[EVENT_MAX_CALLBACKS]; UInt32 Count;
} Event_Chat;
void Event_RaiseVoid(Event_Void* handlers);
void Event_RegisterVoid(Event_Void* handlers, Event_Void_Callback handler);
void Event_UnregisterVoid(Event_Void* handlers, Event_Void_Callback handler);
void Event_RegisterVoid(Event_Void* handlers, void* obj, Event_Void_Callback handler);
void Event_UnregisterVoid(Event_Void* handlers, void* obj, Event_Void_Callback handler);
void Event_RaiseInt32(Event_Int32* handlers, Int32 arg);
void Event_RegisterInt32(Event_Int32* handlers, Event_Int32_Callback handler);
void Event_UnregisterInt32(Event_Int32* handlers, Event_Int32_Callback handler);
void Event_RegisterInt32(Event_Int32* handlers, void* obj, Event_Int32_Callback handler);
void Event_UnregisterInt32(Event_Int32* handlers, void* obj, Event_Int32_Callback handler);
void Event_RaiseReal32(Event_Real32* handlers, Real32 arg);
void Event_RegisterReal32(Event_Real32* handlers, Event_Real32_Callback handler);
void Event_UnregisterReal32(Event_Real32* handlers, Event_Real32_Callback handler);
void Event_RegisterReal32(Event_Real32* handlers, void* obj, Event_Real32_Callback handler);
void Event_UnregisterReal32(Event_Real32* handlers, void* obj, Event_Real32_Callback handler);
void Event_RaiseEntityID(Event_EntityID* handlers, EntityID arg);
void Event_RegisterEntityID(Event_EntityID* handlers, Event_EntityID_Callback handler);
void Event_UnregisterEntityID(Event_EntityID* handlers, Event_EntityID_Callback handler);
void Event_RegisterEntityID(Event_EntityID* handlers, void* obj, Event_EntityID_Callback handler);
void Event_UnregisterEntityID(Event_EntityID* handlers, void* obj, Event_EntityID_Callback handler);
void Event_RaiseStream(Event_Stream* handlers, Stream* stream);
void Event_RegisterStream(Event_Stream* handlers, Event_Stream_Callback handler);
void Event_UnregisterStream(Event_Stream* handlers, Event_Stream_Callback handler);
void Event_RegisterStream(Event_Stream* handlers, void* obj, Event_Stream_Callback handler);
void Event_UnregisterStream(Event_Stream* handlers, void* obj, Event_Stream_Callback handler);
void Event_RaiseBlock(Event_Block* handlers, Vector3I coords, BlockID oldBlock, BlockID block);
void Event_RegisterBlock(Event_Block* handlers, Event_Block_Callback handler);
void Event_UnregisterBlock(Event_Block* handlers, Event_Block_Callback handler);
void Event_RegisterBlock(Event_Block* handlers, void* obj, Event_Block_Callback handler);
void Event_UnregisterBlock(Event_Block* handlers, void* obj, Event_Block_Callback handler);
void Event_RaiseMouseMove(Event_MouseMove* handlers, Int32 xDelta, Int32 yDelta);
void Event_RegisterMouseMove(Event_MouseMove* handlers, Event_MouseMove_Callback handler);
void Event_UnregisterMouseMove(Event_MouseMove* handlers, Event_MouseMove_Callback handler);
void Event_RegisterMouseMove(Event_MouseMove* handlers, void* obj, Event_MouseMove_Callback handler);
void Event_UnregisterMouseMove(Event_MouseMove* handlers, void* obj, Event_MouseMove_Callback handler);
void Event_RaiseChat(Event_Chat* handlers, String* msg, UInt8 msgType);
void Event_RegisterChat(Event_Chat* handlers, Event_Chat_Callback handler);
void Event_UnregisterChat(Event_Chat* handlers, Event_Chat_Callback handler);
void Event_RegisterChat(Event_Chat* handlers, void* obj, Event_Chat_Callback handler);
void Event_UnregisterChat(Event_Chat* handlers, void* obj, Event_Chat_Callback handler);
Event_EntityID EntityEvents_Added; /* Entity is spawned in the current world. */

6
src/Client/Gui.c
View File

@ -73,7 +73,7 @@ bool Gui_Contains(Int32 recX, Int32 recY, Int32 width, Int32 height, Int32 x, In
return x >= recX && y >= recY && x < recX + width && y < recY + height;
}
void Gui_FileChanged(Stream* stream) {
void Gui_FileChanged(void* obj, Stream* stream) {
String gui = String_FromConst("gui.png");
String guiClassic = String_FromConst("gui_classic.png");
String icons = String_FromConst("icons.png");
@ -88,7 +88,7 @@ void Gui_FileChanged(Stream* stream) {
}
void Gui_Init(void) {
Event_RegisterStream(&TextureEvents_FileChanged, Gui_FileChanged);
Event_RegisterStream(&TextureEvents_FileChanged, NULL, Gui_FileChanged);
Gui_Status = StatusScreen_MakeInstance();
game.Components.Add(statusScreen);
hudScreen = new HudScreen(game);
@ -104,7 +104,7 @@ void Gui_Reset(void) {
}
void Gui_Free(void) {
Event_UnregisterStream(&TextureEvents_FileChanged, Gui_FileChanged);
Event_UnregisterStream(&TextureEvents_FileChanged, NULL, Gui_FileChanged);
Gui_SetNewScreen(NULL);
Gui_Status->Base.Free(&Gui_Status->Base);

6
src/Client/Lighting.c
View File

@ -22,7 +22,7 @@ void Lighting_SetShadow(PackedCol col) {
&shadowZSide, &shadowYBottom);
}
void Lighting_EnvVariableChanged(Int32 envVar) {
void Lighting_EnvVariableChanged(void* obj, Int32 envVar) {
if (envVar == ENV_VAR_SUN_COL) {
Lighting_SetSun(WorldEnv_SunCol);
} else if (envVar == ENV_VAR_SHADOW_COL) {
@ -311,7 +311,7 @@ void Lighting_LightHint(Int32 startX, Int32 startZ) {
void Lighting_Init(void) {
Event_RegisterInt32(&WorldEvents_EnvVarChanged, &Lighting_EnvVariableChanged);
Event_RegisterInt32(&WorldEvents_EnvVarChanged, NULL, &Lighting_EnvVariableChanged);
Lighting_SetSun(WorldEnv_DefaultSunCol);
Lighting_SetShadow(WorldEnv_DefaultShadowCol);
}
@ -339,7 +339,7 @@ void Lighting_OnNewMapLoaded(void) {
}
void Lighting_Free(void) {
Event_UnregisterInt32(&WorldEvents_EnvVarChanged, &Lighting_EnvVariableChanged);
Event_UnregisterInt32(&WorldEvents_EnvVarChanged, NULL, &Lighting_EnvVariableChanged);
Lighting_Reset();
}

22
src/Client/ModelCache.c
View File

@ -11,11 +11,11 @@
String ModelCache_charPngString = String_FromConst("char.png");
Int32 ModelCache_texCount, ModelCache_modelCount;
void ModelCache_ContextLost(void) {
void ModelCache_ContextLost(void* obj) {
Gfx_DeleteVb(&ModelCache_Vb);
}
void ModelCache_ContextRecreated(void) {
void ModelCache_ContextRecreated(void* obj) {
ModelCache_Vb = Gfx_CreateDynamicVb(VERTEX_FORMAT_P3FT2FC4B, MODELCACHE_MAX_VERTICES);
}
@ -73,7 +73,7 @@ void ModelCache_RegisterTexture(STRING_REF const UInt8* texName) {
}
static void ModelCache_TextureChanged(Stream* stream) {
static void ModelCache_TextureChanged(void* obj, Stream* stream) {
Int32 i;
for (i = 0; i < ModelCache_texCount; i++) {
CachedTexture* tex = &ModelCache_Textures[i];
@ -1327,11 +1327,11 @@ static void ModelCache_RegisterDefaultModels(void) {
void ModelCache_Init(void) {
ModelCache_RegisterDefaultModels();
ModelCache_ContextRecreated();
ModelCache_ContextRecreated(NULL);
Event_RegisterStream(&TextureEvents_FileChanged, ModelCache_TextureChanged);
Event_RegisterVoid(&GfxEvents_ContextLost, ModelCache_ContextLost);
Event_RegisterVoid(&GfxEvents_ContextRecreated, ModelCache_ContextRecreated);
Event_RegisterStream(&TextureEvents_FileChanged, NULL, ModelCache_TextureChanged);
Event_RegisterVoid(&GfxEvents_ContextLost, NULL, ModelCache_ContextLost);
Event_RegisterVoid(&GfxEvents_ContextRecreated, NULL, ModelCache_ContextRecreated);
}
void ModelCache_Free(void) {
@ -1340,9 +1340,9 @@ void ModelCache_Free(void) {
CachedTexture* tex = &ModelCache_Textures[i];
Gfx_DeleteTexture(&tex->TexID);
}
ModelCache_ContextLost();
ModelCache_ContextLost(NULL);
Event_UnregisterStream(&TextureEvents_FileChanged, ModelCache_TextureChanged);
Event_UnregisterVoid(&GfxEvents_ContextLost, ModelCache_ContextLost);
Event_UnregisterVoid(&GfxEvents_ContextRecreated, ModelCache_ContextRecreated);
Event_UnregisterStream(&TextureEvents_FileChanged, NULL, ModelCache_TextureChanged);
Event_UnregisterVoid(&GfxEvents_ContextLost, NULL, ModelCache_ContextLost);
Event_UnregisterVoid(&GfxEvents_ContextRecreated, NULL, ModelCache_ContextRecreated);
}

32
src/Client/Particle.c
View File

@ -170,38 +170,44 @@ UInt16 Terrain_1DCount[ATLAS1D_MAX_ATLASES_COUNT];
UInt16 Terrain_1DIndices[ATLAS1D_MAX_ATLASES_COUNT];
Random rnd;
void Particles_FileChanged(Stream* stream) {
void Particles_FileChanged(void* obj, Stream* stream) {
String particlesPng = String_FromConst("particles.png");
if (String_Equals(&stream->Name, &particlesPng)) {
//Game_UpdateTexture(&Particles_TexId, stream, false);
}
}
void Particles_ContextLost(void) { Gfx_DeleteVb(&Particles_VB); }
void Particles_ContextRecreated(void) {
void Particles_ContextLost(void* obj) {
Gfx_DeleteVb(&Particles_VB);
}
void Particles_ContextRecreated(void* obj) {
Particles_VB = Gfx_CreateDynamicVb(VERTEX_FORMAT_P3FT2FC4B, PARTICLES_MAX * 4);
}
void Particles_BreakBlockEffect_Handler(void* obj, Vector3I coords, BlockID oldBlock, BlockID block) {
Particles_BreakBlockEffect(coords, oldBlock, block);
}
void Particles_Init(void) {
Random_InitFromCurrentTime(&rnd);
Event_RegisterBlock(&UserEvents_BlockChanged, Particles_BreakBlockEffect);
Event_RegisterStream(&TextureEvents_FileChanged, Particles_FileChanged);
Particles_ContextRecreated(NULL);
Particles_ContextRecreated();
Event_RegisterVoid(&GfxEvents_ContextLost, Particles_ContextLost);
Event_RegisterVoid(&GfxEvents_ContextRecreated, Particles_ContextRecreated);
Event_RegisterBlock(&UserEvents_BlockChanged, NULL, Particles_BreakBlockEffect_Handler);
Event_RegisterStream(&TextureEvents_FileChanged, NULL, Particles_FileChanged);
Event_RegisterVoid(&GfxEvents_ContextLost, NULL, Particles_ContextLost);
Event_RegisterVoid(&GfxEvents_ContextRecreated, NULL, Particles_ContextRecreated);
}
void Particles_Reset(void) { Rain_Count = 0; Terrain_Count = 0; }
void Particles_Free(void) {
Gfx_DeleteTexture(&Particles_TexId);
Event_UnregisterBlock(&UserEvents_BlockChanged, Particles_BreakBlockEffect);
Event_UnregisterStream(&TextureEvents_FileChanged, Particles_FileChanged);
Particles_ContextLost(NULL);
Particles_ContextLost();
Event_UnregisterVoid(&GfxEvents_ContextLost, Particles_ContextLost);
Event_UnregisterVoid(&GfxEvents_ContextRecreated, Particles_ContextRecreated);
Event_UnregisterBlock(&UserEvents_BlockChanged, NULL, Particles_BreakBlockEffect_Handler);
Event_UnregisterStream(&TextureEvents_FileChanged, NULL, Particles_FileChanged);
Event_UnregisterVoid(&GfxEvents_ContextLost, NULL, Particles_ContextLost);
Event_UnregisterVoid(&GfxEvents_ContextRecreated, NULL, Particles_ContextRecreated);
}

14
src/Client/Physics.c
View File

@ -93,7 +93,7 @@ TickQueue physics_lavaQ, physics_waterQ;
#define physics_defLavaTick (30UL << physics_tickShift)
#define physics_defWaterTick (5UL << physics_tickShift)
void Physics_OnNewMapLoaded(void) {
void Physics_OnNewMapLoaded(void* obj) {
TickQueue_Clear(&physics_lavaQ);
TickQueue_Clear(&physics_waterQ);
@ -109,7 +109,7 @@ void Physics_OnNewMapLoaded(void) {
void Physics_SetEnabled(bool enabled) {
Physics_Enabled = enabled;
Physics_OnNewMapLoaded();
Physics_OnNewMapLoaded(NULL);
}
void Physics_ActivateNeighbours(Int32 x, Int32 y, Int32 z, Int32 index) {
@ -136,7 +136,7 @@ bool Physics_IsEdgeWater(Int32 x, Int32 y, Int32 z) {
}
void Physics_BlockChanged(Vector3I p, BlockID oldBlock, BlockID block) {
void Physics_BlockChanged(void* obj, Vector3I p, BlockID oldBlock, BlockID block) {
if (!Physics_Enabled) return;
Int32 index = World_Pack(p.X, p.Y, p.Z);
@ -492,8 +492,8 @@ void Physics_HandleTnt(Int32 index, BlockID block) {
}
void Physics_Init(void) {
Event_RegisterVoid(&WorldEvents_MapLoaded, Physics_OnNewMapLoaded);
Event_RegisterBlock(&UserEvents_BlockChanged, Physics_BlockChanged);
Event_RegisterVoid(&WorldEvents_MapLoaded, NULL, Physics_OnNewMapLoaded);
Event_RegisterBlock(&UserEvents_BlockChanged, NULL, Physics_BlockChanged);
Physics_Enabled = Options_GetBool(OPTION_BLOCK_PHYSICS, true);
TickQueue_Init(&physics_lavaQ);
TickQueue_Init(&physics_waterQ);
@ -536,8 +536,8 @@ void Physics_Init(void) {
}
void Physics_Free(void) {
Event_UnregisterVoid(&WorldEvents_MapLoaded, Physics_OnNewMapLoaded);
Event_UnregisterBlock(&UserEvents_BlockChanged, Physics_BlockChanged);
Event_UnregisterVoid(&WorldEvents_MapLoaded, NULL, Physics_OnNewMapLoaded);
Event_UnregisterBlock(&UserEvents_BlockChanged, NULL, Physics_BlockChanged);
}
void Physics_Tick(void) {

16
src/Client/PickedPosRenderer.c
View File

@ -13,25 +13,25 @@ PackedCol pickedPos_col;
VertexP3fC4b pickedPos_vertices[pickedPos_numVertices];
VertexP3fC4b* pickedPos_ptr;
void PickedPosRenderer_ContextLost(void) {
void PickedPosRenderer_ContextLost(void* obj) {
Gfx_DeleteVb(&pickedPos_vb);
}
void PickedPosRenderer_ContextRecreated(void) {
void PickedPosRenderer_ContextRecreated(void* obj) {
pickedPos_vb = Gfx_CreateDynamicVb(VERTEX_FORMAT_P3FC4B, pickedPos_numVertices);
}
void PickedPosRenderer_Init(void) {
pickedPos_col = PackedCol_Create4(0, 0, 0, 102);
PickedPosRenderer_ContextRecreated();
Event_RegisterVoid(&GfxEvents_ContextLost, PickedPosRenderer_ContextLost);
Event_RegisterVoid(&GfxEvents_ContextRecreated, PickedPosRenderer_ContextRecreated);
PickedPosRenderer_ContextRecreated(NULL);
Event_RegisterVoid(&GfxEvents_ContextLost, NULL, PickedPosRenderer_ContextLost);
Event_RegisterVoid(&GfxEvents_ContextRecreated, NULL, PickedPosRenderer_ContextRecreated);
}
void PickedPosRenderer_Free(void) {
PickedPosRenderer_ContextLost();
Event_UnregisterVoid(&GfxEvents_ContextLost, PickedPosRenderer_ContextLost);
Event_UnregisterVoid(&GfxEvents_ContextRecreated, PickedPosRenderer_ContextRecreated);
PickedPosRenderer_ContextLost(NULL);
Event_UnregisterVoid(&GfxEvents_ContextLost, NULL, PickedPosRenderer_ContextLost);
Event_UnregisterVoid(&GfxEvents_ContextRecreated, NULL, PickedPosRenderer_ContextRecreated);
}
void PickedPosRenderer_Render(Real64 delta) {

79
src/Client/Screens.c
View File

@ -138,17 +138,20 @@ typedef struct InventoryScreen_ {
} InventoryScreen;
InventoryScreen InventoryScreen_Instance;
void InventoryScreen_OnBlockChanged(void) {
TableWidget_OnInventoryChanged(&InventoryScreen_Instance.Table);
void InventoryScreen_OnBlockChanged(void* obj) {
InventoryScreen* screen = (InventoryScreen*)obj;
TableWidget_OnInventoryChanged(&screen->Table);
}
void InventoryScreen_ContextLost(void) {
GuiElement* elem = &InventoryScreen_Instance.Table.Base.Base;
void InventoryScreen_ContextLost(void* obj) {
InventoryScreen* screen = (InventoryScreen*)obj;
GuiElement* elem = &screen->Table.Base.Base;
elem->Free(elem);
}
void InventoryScreen_ContextRecreated(void) {
GuiElement* elem = &InventoryScreen_Instance.Table.Base.Base;
void InventoryScreen_ContextRecreated(void* obj) {
InventoryScreen* screen = (InventoryScreen*)obj;
GuiElement* elem = &screen->Table.Base.Base;
elem->Recreate(elem);
}
@ -163,10 +166,10 @@ void InventoryScreen_Init(GuiElement* elem) {
elem->Init(elem);
Key_KeyRepeat = true;
Event_RegisterVoid(&BlockEvents_PermissionsChanged, InventoryScreen_OnBlockChanged);
Event_RegisterVoid(&BlockEvents_BlockDefChanged, InventoryScreen_OnBlockChanged);
Event_RegisterVoid(&GfxEvents_ContextLost, InventoryScreen_ContextLost);
Event_RegisterVoid(&GfxEvents_ContextRecreated, InventoryScreen_ContextRecreated);
Event_RegisterVoid(&BlockEvents_PermissionsChanged, screen, InventoryScreen_OnBlockChanged);
Event_RegisterVoid(&BlockEvents_BlockDefChanged, screen, InventoryScreen_OnBlockChanged);
Event_RegisterVoid(&GfxEvents_ContextLost, screen, InventoryScreen_ContextLost);
Event_RegisterVoid(&GfxEvents_ContextRecreated, screen, InventoryScreen_ContextRecreated);
}
void InventoryScreen_Render(GuiElement* elem, Real64 delta) {
@ -188,10 +191,10 @@ void InventoryScreen_Free(GuiElement* elem) {
elem->Free(elem);
Key_KeyRepeat = false;
Event_UnregisterVoid(&BlockEvents_PermissionsChanged, InventoryScreen_OnBlockChanged);
Event_UnregisterVoid(&BlockEvents_BlockDefChanged, InventoryScreen_OnBlockChanged);
Event_UnregisterVoid(&GfxEvents_ContextLost, InventoryScreen_ContextLost);
Event_UnregisterVoid(&GfxEvents_ContextRecreated, InventoryScreen_ContextRecreated);
Event_UnregisterVoid(&BlockEvents_PermissionsChanged, screen, InventoryScreen_OnBlockChanged);
Event_UnregisterVoid(&BlockEvents_BlockDefChanged, screen, InventoryScreen_OnBlockChanged);
Event_UnregisterVoid(&GfxEvents_ContextLost, screen, InventoryScreen_ContextLost);
Event_UnregisterVoid(&GfxEvents_ContextRecreated, screen, InventoryScreen_ContextRecreated);
}
bool InventoryScreen_HandlesKeyDown(GuiElement* elem, Key key) {
@ -351,14 +354,14 @@ void StatusScreen_Render(GuiElement* elem, Real64 delta) {
}
void StatusScreen_OnResize(Screen* screen) { }
void StatusScreen_ChatFontChanged(void) {
StatusScreen* screen = &StatusScreen_Instance;
void StatusScreen_ChatFontChanged(void* obj) {
StatusScreen* screen = (StatusScreen*)obj;
GuiElement* elem = &screen->Base.Base;
elem->Recreate(elem);
}
void StatusScreen_ContextLost(void) {
StatusScreen* screen = &StatusScreen_Instance;
void StatusScreen_ContextLost(void* obj) {
StatusScreen* screen = (StatusScreen*)obj;
TextAtlas_Free(&screen->PosAtlas);
GuiElement* elem;
@ -368,8 +371,8 @@ void StatusScreen_ContextLost(void) {
elem->Free(elem);
}
void StatusScreen_ContextRecreated(void) {
StatusScreen* screen = &StatusScreen_Instance;
void StatusScreen_ContextRecreated(void* obj) {
StatusScreen* screen = (StatusScreen*)obj;
TextWidget* status = &screen->Status; TextWidget_Make(status, &screen->Font);
Widget_SetLocation(&status->Base, ANCHOR_LEFT_OR_TOP, ANCHOR_LEFT_OR_TOP, 2, 2);
@ -393,21 +396,21 @@ void StatusScreen_ContextRecreated(void) {
void StatusScreen_Init(GuiElement* elem) {
StatusScreen* screen = (StatusScreen*)elem;
Platform_MakeFont(&screen->Font, &Game_FontName, 16, FONT_STYLE_NORMAL);
StatusScreen_ContextRecreated();
StatusScreen_ContextRecreated(screen);
Event_RegisterVoid(&ChatEvents_FontChanged, StatusScreen_ChatFontChanged);
Event_RegisterVoid(&GfxEvents_ContextLost, StatusScreen_ContextLost);
Event_RegisterVoid(&GfxEvents_ContextRecreated, StatusScreen_ContextRecreated);
Event_RegisterVoid(&ChatEvents_FontChanged, screen, StatusScreen_ChatFontChanged);
Event_RegisterVoid(&GfxEvents_ContextLost, screen, StatusScreen_ContextLost);
Event_RegisterVoid(&GfxEvents_ContextRecreated, screen, StatusScreen_ContextRecreated);
}
void StatusScreen_Free(GuiElement* elem) {
StatusScreen* screen = (StatusScreen*)elem;
Platform_FreeFont(&screen->Font);
StatusScreen_ContextLost();
StatusScreen_ContextLost(screen);
Event_UnregisterVoid(&ChatEvents_FontChanged, StatusScreen_ChatFontChanged);
Event_UnregisterVoid(&GfxEvents_ContextLost, StatusScreen_ContextLost);
Event_UnregisterVoid(&GfxEvents_ContextRecreated, StatusScreen_ContextRecreated);
Event_UnregisterVoid(&ChatEvents_FontChanged, screen, StatusScreen_ChatFontChanged);
Event_UnregisterVoid(&GfxEvents_ContextLost, screen, StatusScreen_ContextLost);
Event_UnregisterVoid(&GfxEvents_ContextRecreated, screen, StatusScreen_ContextRecreated);
}
void StatusScreen_DrawPosition(StatusScreen* screen) {
@ -558,13 +561,13 @@ void FilesScreen_MoveForwards(GuiElement* elem, Int32 x, Int32 y, MouseButton bt
if (btn == MouseButton_Left) FilesScreen_PageClick(true);
}
void FilesScreen_ContextLost(void) {
FilesScreen* screen = &FilesScreen_Instance;
void FilesScreen_ContextLost(void* obj) {
FilesScreen* screen = (FilesScreen*)obj;
Screen_FreeWidgets(screen->Widgets, Array_NumElements(screen->Widgets));
}
void FilesScreen_ContextRecreated(void) {
FilesScreen* screen = &FilesScreen_Instance;
void FilesScreen_ContextRecreated(void* obj) {
FilesScreen* screen = (FilesScreen*)obj;
TextWidget_Create(&screen->Title, &screen->TitleText, &screen->Font);
Widget_SetLocation(&screen->Title.Base, ANCHOR_CENTRE, ANCHOR_CENTRE, 0, -155);
@ -591,9 +594,9 @@ void FilesScreen_ContextRecreated(void) {
void FilesScreen_Init(GuiElement* elem) {
FilesScreen* screen = (FilesScreen*)elem;
Platform_MakeFont(&screen->Font, &Game_FontName, 16, FONT_STYLE_BOLD);
FilesScreen_ContextRecreated();
Event_RegisterVoid(&GfxEvents_ContextLost, FilesScreen_ContextLost);
Event_RegisterVoid(&GfxEvents_ContextRecreated, FilesScreen_ContextRecreated);
FilesScreen_ContextRecreated(screen);
Event_RegisterVoid(&GfxEvents_ContextLost, screen, FilesScreen_ContextLost);
Event_RegisterVoid(&GfxEvents_ContextRecreated, screen, FilesScreen_ContextRecreated);
}
void FilesScreen_Render(GuiElement* elem, Real64 delta) {
@ -607,9 +610,9 @@ void FilesScreen_Render(GuiElement* elem, Real64 delta) {
void FilesScreen_Free(GuiElement* elem) {
FilesScreen* screen = (FilesScreen*)elem;
Platform_FreeFont(&screen->Font);
FilesScreen_ContextLost();
Event_UnregisterVoid(&GfxEvents_ContextLost, FilesScreen_ContextLost);
Event_UnregisterVoid(&GfxEvents_ContextRecreated, FilesScreen_ContextRecreated);
FilesScreen_ContextLost(screen);
Event_UnregisterVoid(&GfxEvents_ContextLost, screen, FilesScreen_ContextLost);
Event_UnregisterVoid(&GfxEvents_ContextRecreated, screen, FilesScreen_ContextRecreated);
}
bool FilesScreen_HandlesKeyDown(GuiElement* elem, Key key) {

1
src/Client/Searcher.c
View File

@ -4,6 +4,7 @@
#include "Platform.h"
#include "ExtMath.h"
#include "Funcs.h"
#include "ErrorHandler.h"
void SearcherState_Init(SearcherState* state, Int32 x, Int32 y, Int32 z, BlockID block, Real32 tSquared) {
state->X = (x << 3) | (block & 0x07);

32
src/Client/SkyboxRenderer.c
View File

@ -18,12 +18,12 @@ bool SkyboxRenderer_ShouldRender(void) {
return skybox_tex > 0 && !EnvRenderer_Minimal;
}
void SkyboxRenderer_TexturePackChanged(void) {
void SkyboxRenderer_TexturePackChanged(void* obj) {
Gfx_DeleteTexture(&skybox_tex);
WorldEnv_SkyboxClouds = false;
}
void SkyboxRenderer_FileChanged(Stream* src) {
void SkyboxRenderer_FileChanged(void* obj, Stream* src) {
String skybox = String_FromConst("skybox.png");
String useclouds = String_FromConst("useclouds");
@ -121,33 +121,33 @@ void SkyboxRenderer_MakeVb(void) {
skybox_vb = Gfx_CreateVb(vertices, VERTEX_FORMAT_P3FT2FC4B, SKYBOX_COUNT);
}
void SkyboxRenderer_ContextLost(void) { Gfx_DeleteVb(&skybox_vb); }
void SkyboxRenderer_ContextRecreated(void) { SkyboxRenderer_MakeVb(); }
void SkyboxRenderer_ContextLost(void* obj) { Gfx_DeleteVb(&skybox_vb); }
void SkyboxRenderer_ContextRecreated(void* obj) { SkyboxRenderer_MakeVb(); }
void SkyboxRenderer_EnvVariableChanged(Int32 envVar) {
void SkyboxRenderer_EnvVariableChanged(void* obj, Int32 envVar) {
if (envVar != ENV_VAR_CLOUDS_COL) return;
SkyboxRenderer_MakeVb();
}
void SkyboxRenderer_Init(void) {
Event_RegisterStream(&TextureEvents_FileChanged, &SkyboxRenderer_FileChanged);
Event_RegisterVoid(&TextureEvents_PackChanged, &SkyboxRenderer_TexturePackChanged);
Event_RegisterInt32(&WorldEvents_EnvVarChanged, &SkyboxRenderer_EnvVariableChanged);
Event_RegisterVoid(&GfxEvents_ContextLost, &SkyboxRenderer_ContextLost);
Event_RegisterVoid(&GfxEvents_ContextRecreated, &SkyboxRenderer_ContextRecreated);
Event_RegisterStream(&TextureEvents_FileChanged, NULL, &SkyboxRenderer_FileChanged);
Event_RegisterVoid(&TextureEvents_PackChanged, NULL, &SkyboxRenderer_TexturePackChanged);
Event_RegisterInt32(&WorldEvents_EnvVarChanged, NULL, &SkyboxRenderer_EnvVariableChanged);
Event_RegisterVoid(&GfxEvents_ContextLost, NULL, &SkyboxRenderer_ContextLost);
Event_RegisterVoid(&GfxEvents_ContextRecreated, NULL, &SkyboxRenderer_ContextRecreated);
}
void SkyboxRenderer_Reset(void) { Gfx_DeleteTexture(&skybox_tex); }
void SkyboxRenderer_Free(void) {
Gfx_DeleteTexture(&skybox_tex);
SkyboxRenderer_ContextLost();
SkyboxRenderer_ContextLost(NULL);
Event_UnregisterStream(&TextureEvents_FileChanged, &SkyboxRenderer_FileChanged);
Event_UnregisterVoid(&TextureEvents_PackChanged, &SkyboxRenderer_TexturePackChanged);
Event_UnregisterInt32(&WorldEvents_EnvVarChanged, &SkyboxRenderer_EnvVariableChanged);
Event_UnregisterVoid(&GfxEvents_ContextLost, &SkyboxRenderer_ContextLost);
Event_UnregisterVoid(&GfxEvents_ContextRecreated, &SkyboxRenderer_ContextRecreated);
Event_UnregisterStream(&TextureEvents_FileChanged, NULL, &SkyboxRenderer_FileChanged);
Event_UnregisterVoid(&TextureEvents_PackChanged, NULL, &SkyboxRenderer_TexturePackChanged);
Event_UnregisterInt32(&WorldEvents_EnvVarChanged, NULL, &SkyboxRenderer_EnvVariableChanged);
Event_UnregisterVoid(&GfxEvents_ContextLost, NULL, &SkyboxRenderer_ContextLost);
Event_UnregisterVoid(&GfxEvents_ContextRecreated, NULL, &SkyboxRenderer_ContextRecreated);
}
IGameComponent SkyboxRenderer_MakeGameComponent(void) {

22
src/Client/WeatherRenderer.c
View File

@ -84,11 +84,11 @@ void WeatherRenderer_OnBlockChanged(Int32 x, Int32 y, Int32 z, BlockID oldBlock,
}
}
void WeatherRenderer_ContextLost(void) {
void WeatherRenderer_ContextLost(void* obj) {
Gfx_DeleteVb(&weather_vb);
}
void WeatherRenderer_ContextRecreated(void) {
void WeatherRenderer_ContextRecreated(void* obj) {
weather_vb = Gfx_CreateDynamicVb(VERTEX_FORMAT_P3FT2FC4B, weather_verticesCount);
}
@ -181,7 +181,7 @@ void WeatherRenderer_Render(Real64 deltaTime) {
Gfx_SetAlphaTest(false);
}
void WeatherRenderer_FileChanged(Stream* stream) {
void WeatherRenderer_FileChanged(void* obj, Stream* stream) {
String snow = String_FromConst("snow.png");
String rain = String_FromConst("rain.png");
@ -193,12 +193,12 @@ void WeatherRenderer_FileChanged(Stream* stream) {
}
void WeatherRenderer_Init(void) {
Event_RegisterStream(&TextureEvents_FileChanged, &WeatherRenderer_FileChanged);
weather_lastPos = Vector3I_Create1(Int32_MaxValue);
WeatherRenderer_ContextRecreated(NULL);
WeatherRenderer_ContextRecreated();
Event_RegisterVoid(&GfxEvents_ContextLost, &WeatherRenderer_ContextLost);
Event_RegisterVoid(&GfxEvents_ContextRecreated, &WeatherRenderer_ContextRecreated);
Event_RegisterStream(&TextureEvents_FileChanged, NULL, &WeatherRenderer_FileChanged);
Event_RegisterVoid(&GfxEvents_ContextLost, NULL, &WeatherRenderer_ContextLost);
Event_RegisterVoid(&GfxEvents_ContextRecreated, NULL, &WeatherRenderer_ContextRecreated);
}
void WeatherRenderer_Reset(void) {
@ -210,12 +210,12 @@ void WeatherRenderer_Reset(void) {
void WeatherRenderer_Free(void) {
Gfx_DeleteTexture(&weather_rainTex);
Gfx_DeleteTexture(&weather_snowTex);
WeatherRenderer_ContextLost();
WeatherRenderer_ContextLost(NULL);
WeatherRenderer_Reset();
Event_UnregisterStream(&TextureEvents_FileChanged, &WeatherRenderer_FileChanged);
Event_UnregisterVoid(&GfxEvents_ContextLost, &WeatherRenderer_ContextLost);
Event_UnregisterVoid(&GfxEvents_ContextRecreated, &WeatherRenderer_ContextRecreated);
Event_UnregisterStream(&TextureEvents_FileChanged, NULL, &WeatherRenderer_FileChanged);
Event_UnregisterVoid(&GfxEvents_ContextLost, NULL, &WeatherRenderer_ContextLost);
Event_UnregisterVoid(&GfxEvents_ContextRecreated, NULL, &WeatherRenderer_ContextRecreated);
}
IGameComponent WeatherRenderer_MakeGameComponent(void) {

24
src/Client/Widgets.c
View File

@ -1533,27 +1533,3 @@ void InputWidget_Create(InputWidget* widget, FontDesc* font, STRING_REF String*
widget->PrefixWidth = (UInt16)size.Width; widget->Base.Width = size.Width;
widget->PrefixHeight = (UInt16)size.Height; widget->Base.Height = size.Height;
}
void PlayerListWidget_Init(void);
void PlayerListWidget_Render(Real64 delta);
void PlayerListWidget_Dispose(void);
String* PlayerListWidget_GetNameUnder(Int32 mouseX, Int32 mouseY);
void PlayerListWidget_RepositionColumns(void);
void PlayerListWidget_UpdateTableDimensions(void);
Int32 PlayerListWidget_GetColumnWidth(Int32 column);
Int32 PlayerListWidget_GetColumnHeight(Int32 column);
void PlayerListWidget_SetColumnPos(Int32 column, Int32 x, Int32 y);
void PlayerListWidget_RecalcYOffset(void);
void PlayerListWidget_Reposition(void);
void PlayerListWidget_AddName(UInt8 id, Int32 index);
void PlayerListWidget_TabEntryAdded(Object* sender, IdEventArgs* e);
void PlayerListWidget_TabEntryChanged(Object* sender, IdEventArgs* e);
void PlayerListWidget_TabEntryRemoved(Object* sender, IdEventArgs* e);
void PlayerListWidget_DeleteAt(Int32 i);
void PlayerListWidget_SortAndReposition(void);
Texture* PlayerListWidget_DrawName(String* name);
void PlayerListWidget_SortEntries(void);
void PlayerListWidget_DeleteGroup(Int32&* i);
void PlayerListWidget_AddGroup(UInt16 id, Int32&* index);
Int32 PlayerListWidget_GetGroupCount(UInt16 id, Int32 idx);