mirror of
https://github.com/ddnet/ddnet.git
synced 2024-09-21 18:14:19 +00:00
388 lines
16 KiB
C++
388 lines
16 KiB
C++
/* (c) Magnus Auvinen. See licence.txt in the root of the distribution for more information. */
|
|
/* If you are missing that file, acquire a complete release at teeworlds.com. */
|
|
#include <engine/graphics.h>
|
|
#include <engine/keys.h>
|
|
#include <engine/demo.h>
|
|
#include <engine/serverbrowser.h>
|
|
#include <engine/shared/config.h>
|
|
#include <engine/storage.h>
|
|
|
|
#include <game/layers.h>
|
|
#include <game/client/gameclient.h>
|
|
#include <game/client/component.h>
|
|
#include <game/client/render.h>
|
|
|
|
#include <game/client/components/camera.h>
|
|
#include <game/client/components/mapimages.h>
|
|
|
|
|
|
#include "maplayers.h"
|
|
|
|
CMapLayers::CMapLayers(int t)
|
|
{
|
|
m_Type = t;
|
|
m_pLayers = 0;
|
|
m_CurrentLocalTick = 0;
|
|
m_LastLocalTick = 0;
|
|
m_EnvelopeUpdate = false;
|
|
}
|
|
|
|
void CMapLayers::OnInit()
|
|
{
|
|
m_pLayers = Layers();
|
|
}
|
|
|
|
void CMapLayers::EnvelopeUpdate()
|
|
{
|
|
if(Client()->State() == IClient::STATE_DEMOPLAYBACK)
|
|
{
|
|
const IDemoPlayer::CInfo *pInfo = DemoPlayer()->BaseInfo();
|
|
m_CurrentLocalTick = pInfo->m_CurrentTick;
|
|
m_LastLocalTick = pInfo->m_CurrentTick;
|
|
m_EnvelopeUpdate = true;
|
|
}
|
|
}
|
|
|
|
|
|
void CMapLayers::MapScreenToGroup(float CenterX, float CenterY, CMapItemGroup *pGroup, float Zoom)
|
|
{
|
|
float Points[4];
|
|
RenderTools()->MapscreenToWorld(CenterX, CenterY, pGroup->m_ParallaxX/100.0f, pGroup->m_ParallaxY/100.0f,
|
|
pGroup->m_OffsetX, pGroup->m_OffsetY, Graphics()->ScreenAspect(), Zoom, Points);
|
|
Graphics()->MapScreen(Points[0], Points[1], Points[2], Points[3]);
|
|
}
|
|
|
|
void CMapLayers::EnvelopeEval(float TimeOffset, int Env, float *pChannels, void *pUser)
|
|
{
|
|
CMapLayers *pThis = (CMapLayers *)pUser;
|
|
pChannels[0] = 0;
|
|
pChannels[1] = 0;
|
|
pChannels[2] = 0;
|
|
pChannels[3] = 0;
|
|
|
|
CEnvPoint *pPoints = 0;
|
|
|
|
{
|
|
int Start, Num;
|
|
pThis->m_pLayers->Map()->GetType(MAPITEMTYPE_ENVPOINTS, &Start, &Num);
|
|
if(Num)
|
|
pPoints = (CEnvPoint *)pThis->m_pLayers->Map()->GetItem(Start, 0, 0);
|
|
}
|
|
|
|
int Start, Num;
|
|
pThis->m_pLayers->Map()->GetType(MAPITEMTYPE_ENVELOPE, &Start, &Num);
|
|
|
|
if(Env >= Num)
|
|
return;
|
|
|
|
CMapItemEnvelope *pItem = (CMapItemEnvelope *)pThis->m_pLayers->Map()->GetItem(Start+Env, 0, 0);
|
|
|
|
static float s_Time = 0.0f;
|
|
static float s_LastLocalTime = pThis->Client()->LocalTime();
|
|
if(pThis->Client()->State() == IClient::STATE_DEMOPLAYBACK)
|
|
{
|
|
const IDemoPlayer::CInfo *pInfo = pThis->DemoPlayer()->BaseInfo();
|
|
|
|
if(!pInfo->m_Paused || pThis->m_EnvelopeUpdate)
|
|
{
|
|
if(pThis->m_CurrentLocalTick != pInfo->m_CurrentTick)
|
|
{
|
|
pThis->m_LastLocalTick = pThis->m_CurrentLocalTick;
|
|
pThis->m_CurrentLocalTick = pInfo->m_CurrentTick;
|
|
}
|
|
|
|
s_Time = mix(pThis->m_LastLocalTick / (float)pThis->Client()->GameTickSpeed(),
|
|
pThis->m_CurrentLocalTick / (float)pThis->Client()->GameTickSpeed(),
|
|
pThis->Client()->IntraGameTick());
|
|
}
|
|
|
|
pThis->RenderTools()->RenderEvalEnvelope(pPoints+pItem->m_StartPoint, pItem->m_NumPoints, 4, s_Time+TimeOffset, pChannels);
|
|
}
|
|
else
|
|
{
|
|
if(pThis->m_pClient->m_Snap.m_pGameInfoObj) // && !(pThis->m_pClient->m_Snap.m_pGameInfoObj->m_GameStateFlags&GAMESTATEFLAG_PAUSED))
|
|
{
|
|
if(pItem->m_Version < 2 || pItem->m_Synchronized)
|
|
{
|
|
s_Time = mix((pThis->Client()->PrevGameTick()-pThis->m_pClient->m_Snap.m_pGameInfoObj->m_RoundStartTick) / (float)pThis->Client()->GameTickSpeed(),
|
|
(pThis->Client()->GameTick()-pThis->m_pClient->m_Snap.m_pGameInfoObj->m_RoundStartTick) / (float)pThis->Client()->GameTickSpeed(),
|
|
pThis->Client()->IntraGameTick());
|
|
}
|
|
else
|
|
s_Time += pThis->Client()->LocalTime()-s_LastLocalTime;
|
|
}
|
|
pThis->RenderTools()->RenderEvalEnvelope(pPoints+pItem->m_StartPoint, pItem->m_NumPoints, 4, s_Time+TimeOffset, pChannels);
|
|
s_LastLocalTime = pThis->Client()->LocalTime();
|
|
}
|
|
}
|
|
|
|
void CMapLayers::OnRender()
|
|
{
|
|
if(Client()->State() != IClient::STATE_ONLINE && Client()->State() != IClient::STATE_DEMOPLAYBACK)
|
|
return;
|
|
|
|
CUIRect Screen;
|
|
Graphics()->GetScreen(&Screen.x, &Screen.y, &Screen.w, &Screen.h);
|
|
|
|
vec2 Center = m_pClient->m_pCamera->m_Center;
|
|
|
|
bool PassedGameLayer = false;
|
|
|
|
for(int g = 0; g < m_pLayers->NumGroups(); g++)
|
|
{
|
|
CMapItemGroup *pGroup = m_pLayers->GetGroup(g);
|
|
|
|
if(!pGroup)
|
|
{
|
|
dbg_msg("maplayers", "error group was null, group number = %d, total groups = %d", g, m_pLayers->NumGroups());
|
|
dbg_msg("maplayers", "this is here to prevent a crash but the source of this is unknown, please report this for it to get fixed");
|
|
dbg_msg("maplayers", "we need mapname and crc and the map that caused this if possible, and anymore info you think is relevant");
|
|
continue;
|
|
}
|
|
|
|
if(!g_Config.m_GfxNoclip && pGroup->m_Version >= 2 && pGroup->m_UseClipping)
|
|
{
|
|
// set clipping
|
|
float Points[4];
|
|
MapScreenToGroup(Center.x, Center.y, m_pLayers->GameGroup(), m_pClient->m_pCamera->m_Zoom);
|
|
Graphics()->GetScreen(&Points[0], &Points[1], &Points[2], &Points[3]);
|
|
float x0 = (pGroup->m_ClipX - Points[0]) / (Points[2]-Points[0]);
|
|
float y0 = (pGroup->m_ClipY - Points[1]) / (Points[3]-Points[1]);
|
|
float x1 = ((pGroup->m_ClipX+pGroup->m_ClipW) - Points[0]) / (Points[2]-Points[0]);
|
|
float y1 = ((pGroup->m_ClipY+pGroup->m_ClipH) - Points[1]) / (Points[3]-Points[1]);
|
|
|
|
if(x1 < 0.0f || x0 > 1.0f || y1 < 0.0f || y0 > 1.0f)
|
|
continue;
|
|
|
|
Graphics()->ClipEnable((int)(x0*Graphics()->ScreenWidth()), (int)(y0*Graphics()->ScreenHeight()),
|
|
(int)((x1-x0)*Graphics()->ScreenWidth()), (int)((y1-y0)*Graphics()->ScreenHeight()));
|
|
}
|
|
|
|
if(!g_Config.m_ClZoomBackgroundLayers && !pGroup->m_ParallaxX && !pGroup->m_ParallaxY)
|
|
MapScreenToGroup(Center.x, Center.y, pGroup, 1.0);
|
|
else
|
|
MapScreenToGroup(Center.x, Center.y, pGroup, m_pClient->m_pCamera->m_Zoom);
|
|
|
|
for(int l = 0; l < pGroup->m_NumLayers; l++)
|
|
{
|
|
CMapItemLayer *pLayer = m_pLayers->GetLayer(pGroup->m_StartLayer+l);
|
|
bool Render = false;
|
|
bool IsGameLayer = false;
|
|
bool IsFrontLayer = false;
|
|
bool IsSwitchLayer = false;
|
|
bool IsTeleLayer = false;
|
|
bool IsSpeedupLayer = false;
|
|
bool IsTuneLayer = false;
|
|
|
|
if(pLayer == (CMapItemLayer*)m_pLayers->GameLayer())
|
|
{
|
|
IsGameLayer = true;
|
|
PassedGameLayer = true;
|
|
}
|
|
|
|
if(pLayer == (CMapItemLayer*)m_pLayers->FrontLayer())
|
|
IsFrontLayer = true;
|
|
|
|
if(pLayer == (CMapItemLayer*)m_pLayers->SwitchLayer())
|
|
IsSwitchLayer = true;
|
|
|
|
if(pLayer == (CMapItemLayer*)m_pLayers->TeleLayer())
|
|
IsTeleLayer = true;
|
|
|
|
if(pLayer == (CMapItemLayer*)m_pLayers->SpeedupLayer())
|
|
IsSpeedupLayer = true;
|
|
|
|
if(pLayer == (CMapItemLayer*)m_pLayers->TuneLayer())
|
|
IsTuneLayer = true;
|
|
|
|
// skip rendering if detail layers if not wanted
|
|
if(pLayer->m_Flags&LAYERFLAG_DETAIL && !g_Config.m_GfxHighDetail && !IsGameLayer)
|
|
continue;
|
|
|
|
if(m_Type == -1)
|
|
Render = true;
|
|
else if(m_Type == TYPE_BACKGROUND)
|
|
{
|
|
if(PassedGameLayer)
|
|
return;
|
|
Render = true;
|
|
}
|
|
else // TYPE_FOREGROUND
|
|
{
|
|
if(PassedGameLayer && !IsGameLayer)
|
|
Render = true;
|
|
}
|
|
|
|
if(Render && pLayer->m_Type == LAYERTYPE_TILES && Input()->KeyIsPressed(KEY_LCTRL) && Input()->KeyIsPressed(KEY_LSHIFT) && Input()->KeyPress(KEY_KP_0))
|
|
{
|
|
CMapItemLayerTilemap *pTMap = (CMapItemLayerTilemap *)pLayer;
|
|
CTile *pTiles = (CTile *)m_pLayers->Map()->GetData(pTMap->m_Data);
|
|
CServerInfo CurrentServerInfo;
|
|
Client()->GetServerInfo(&CurrentServerInfo);
|
|
char aFilename[256];
|
|
str_format(aFilename, sizeof(aFilename), "dumps/tilelayer_dump_%s-%d-%d-%dx%d.txt", CurrentServerInfo.m_aMap, g, l, pTMap->m_Width, pTMap->m_Height);
|
|
IOHANDLE File = Storage()->OpenFile(aFilename, IOFLAG_WRITE, IStorage::TYPE_SAVE);
|
|
if(File)
|
|
{
|
|
for(int y = 0; y < pTMap->m_Height; y++)
|
|
{
|
|
for(int x = 0; x < pTMap->m_Width; x++)
|
|
io_write(File, &(pTiles[y*pTMap->m_Width + x].m_Index), sizeof(pTiles[y*pTMap->m_Width + x].m_Index));
|
|
io_write_newline(File);
|
|
}
|
|
io_close(File);
|
|
}
|
|
}
|
|
|
|
if((Render && g_Config.m_ClOverlayEntities < 100 && !IsGameLayer && !IsFrontLayer && !IsSwitchLayer && !IsTeleLayer && !IsSpeedupLayer && !IsTuneLayer) || (g_Config.m_ClOverlayEntities && IsGameLayer))
|
|
{
|
|
if(pLayer->m_Type == LAYERTYPE_TILES)
|
|
{
|
|
CMapItemLayerTilemap *pTMap = (CMapItemLayerTilemap *)pLayer;
|
|
if(pTMap->m_Image == -1)
|
|
{
|
|
if(!IsGameLayer)
|
|
Graphics()->TextureSet(-1);
|
|
else
|
|
Graphics()->TextureSet(m_pClient->m_pMapimages->GetEntities());
|
|
}
|
|
else
|
|
Graphics()->TextureSet(m_pClient->m_pMapimages->Get(pTMap->m_Image));
|
|
|
|
CTile *pTiles = (CTile *)m_pLayers->Map()->GetData(pTMap->m_Data);
|
|
unsigned int Size = m_pLayers->Map()->GetUncompressedDataSize(pTMap->m_Data);
|
|
|
|
if (Size >= pTMap->m_Width*pTMap->m_Height*sizeof(CTile))
|
|
{
|
|
Graphics()->BlendNone();
|
|
vec4 Color = vec4(pTMap->m_Color.r/255.0f, pTMap->m_Color.g/255.0f, pTMap->m_Color.b/255.0f, pTMap->m_Color.a/255.0f);
|
|
if(IsGameLayer && g_Config.m_ClOverlayEntities)
|
|
Color = vec4(pTMap->m_Color.r/255.0f, pTMap->m_Color.g/255.0f, pTMap->m_Color.b/255.0f, pTMap->m_Color.a/255.0f*g_Config.m_ClOverlayEntities/100.0f);
|
|
if(!IsGameLayer && g_Config.m_ClOverlayEntities)
|
|
Color = vec4(pTMap->m_Color.r/255.0f, pTMap->m_Color.g/255.0f, pTMap->m_Color.b/255.0f, pTMap->m_Color.a/255.0f*(100-g_Config.m_ClOverlayEntities)/100.0f);
|
|
RenderTools()->RenderTilemap(pTiles, pTMap->m_Width, pTMap->m_Height, 32.0f, Color, TILERENDERFLAG_EXTEND|LAYERRENDERFLAG_OPAQUE,
|
|
EnvelopeEval, this, pTMap->m_ColorEnv, pTMap->m_ColorEnvOffset);
|
|
Graphics()->BlendNormal();
|
|
RenderTools()->RenderTilemap(pTiles, pTMap->m_Width, pTMap->m_Height, 32.0f, Color, TILERENDERFLAG_EXTEND|LAYERRENDERFLAG_TRANSPARENT,
|
|
EnvelopeEval, this, pTMap->m_ColorEnv, pTMap->m_ColorEnvOffset);
|
|
}
|
|
}
|
|
else if(pLayer->m_Type == LAYERTYPE_QUADS)
|
|
{
|
|
CMapItemLayerQuads *pQLayer = (CMapItemLayerQuads *)pLayer;
|
|
if(pQLayer->m_Image == -1)
|
|
Graphics()->TextureSet(-1);
|
|
else
|
|
Graphics()->TextureSet(m_pClient->m_pMapimages->Get(pQLayer->m_Image));
|
|
|
|
CQuad *pQuads = (CQuad *)m_pLayers->Map()->GetDataSwapped(pQLayer->m_Data);
|
|
|
|
Graphics()->BlendNone();
|
|
RenderTools()->RenderQuads(pQuads, pQLayer->m_NumQuads, LAYERRENDERFLAG_OPAQUE, EnvelopeEval, this);
|
|
Graphics()->BlendNormal();
|
|
RenderTools()->RenderQuads(pQuads, pQLayer->m_NumQuads, LAYERRENDERFLAG_TRANSPARENT, EnvelopeEval, this);
|
|
}
|
|
}
|
|
else if(Render && g_Config.m_ClOverlayEntities && IsFrontLayer)
|
|
{
|
|
CMapItemLayerTilemap *pTMap = (CMapItemLayerTilemap *)pLayer;
|
|
Graphics()->TextureSet(m_pClient->m_pMapimages->GetEntities());
|
|
|
|
CTile *pFrontTiles = (CTile *)m_pLayers->Map()->GetData(pTMap->m_Front);
|
|
unsigned int Size = m_pLayers->Map()->GetUncompressedDataSize(pTMap->m_Front);
|
|
|
|
if (Size >= pTMap->m_Width*pTMap->m_Height*sizeof(CTile))
|
|
{
|
|
Graphics()->BlendNone();
|
|
vec4 Color = vec4(pTMap->m_Color.r/255.0f, pTMap->m_Color.g/255.0f, pTMap->m_Color.b/255.0f, pTMap->m_Color.a/255.0f*g_Config.m_ClOverlayEntities/100.0f);
|
|
RenderTools()->RenderTilemap(pFrontTiles, pTMap->m_Width, pTMap->m_Height, 32.0f, Color, TILERENDERFLAG_EXTEND|LAYERRENDERFLAG_OPAQUE,
|
|
EnvelopeEval, this, pTMap->m_ColorEnv, pTMap->m_ColorEnvOffset);
|
|
Graphics()->BlendNormal();
|
|
RenderTools()->RenderTilemap(pFrontTiles, pTMap->m_Width, pTMap->m_Height, 32.0f, Color, TILERENDERFLAG_EXTEND|LAYERRENDERFLAG_TRANSPARENT,
|
|
EnvelopeEval, this, pTMap->m_ColorEnv, pTMap->m_ColorEnvOffset);
|
|
}
|
|
}
|
|
else if(Render && g_Config.m_ClOverlayEntities && IsSwitchLayer)
|
|
{
|
|
CMapItemLayerTilemap *pTMap = (CMapItemLayerTilemap *)pLayer;
|
|
Graphics()->TextureSet(m_pClient->m_pMapimages->GetEntities());
|
|
|
|
CSwitchTile *pSwitchTiles = (CSwitchTile *)m_pLayers->Map()->GetData(pTMap->m_Switch);
|
|
unsigned int Size = m_pLayers->Map()->GetUncompressedDataSize(pTMap->m_Switch);
|
|
|
|
if (Size >= pTMap->m_Width*pTMap->m_Height*sizeof(CSwitchTile))
|
|
{
|
|
Graphics()->BlendNone();
|
|
vec4 Color = vec4(pTMap->m_Color.r/255.0f, pTMap->m_Color.g/255.0f, pTMap->m_Color.b/255.0f, pTMap->m_Color.a/255.0f*g_Config.m_ClOverlayEntities/100.0f);
|
|
RenderTools()->RenderSwitchmap(pSwitchTiles, pTMap->m_Width, pTMap->m_Height, 32.0f, Color, TILERENDERFLAG_EXTEND|LAYERRENDERFLAG_OPAQUE);
|
|
Graphics()->BlendNormal();
|
|
RenderTools()->RenderSwitchmap(pSwitchTiles, pTMap->m_Width, pTMap->m_Height, 32.0f, Color, TILERENDERFLAG_EXTEND|LAYERRENDERFLAG_TRANSPARENT);
|
|
RenderTools()->RenderSwitchOverlay(pSwitchTiles, pTMap->m_Width, pTMap->m_Height, 32.0f, g_Config.m_ClOverlayEntities/100.0f);
|
|
}
|
|
}
|
|
else if(Render && g_Config.m_ClOverlayEntities && IsTeleLayer)
|
|
{
|
|
CMapItemLayerTilemap *pTMap = (CMapItemLayerTilemap *)pLayer;
|
|
Graphics()->TextureSet(m_pClient->m_pMapimages->GetEntities());
|
|
|
|
CTeleTile *pTeleTiles = (CTeleTile *)m_pLayers->Map()->GetData(pTMap->m_Tele);
|
|
unsigned int Size = m_pLayers->Map()->GetUncompressedDataSize(pTMap->m_Tele);
|
|
|
|
if (Size >= pTMap->m_Width*pTMap->m_Height*sizeof(CTeleTile))
|
|
{
|
|
Graphics()->BlendNone();
|
|
vec4 Color = vec4(pTMap->m_Color.r/255.0f, pTMap->m_Color.g/255.0f, pTMap->m_Color.b/255.0f, pTMap->m_Color.a/255.0f*g_Config.m_ClOverlayEntities/100.0f);
|
|
RenderTools()->RenderTelemap(pTeleTiles, pTMap->m_Width, pTMap->m_Height, 32.0f, Color, TILERENDERFLAG_EXTEND|LAYERRENDERFLAG_OPAQUE);
|
|
Graphics()->BlendNormal();
|
|
RenderTools()->RenderTelemap(pTeleTiles, pTMap->m_Width, pTMap->m_Height, 32.0f, Color, TILERENDERFLAG_EXTEND|LAYERRENDERFLAG_TRANSPARENT);
|
|
RenderTools()->RenderTeleOverlay(pTeleTiles, pTMap->m_Width, pTMap->m_Height, 32.0f, g_Config.m_ClOverlayEntities/100.0f);
|
|
}
|
|
}
|
|
else if(Render && g_Config.m_ClOverlayEntities && IsSpeedupLayer)
|
|
{
|
|
CMapItemLayerTilemap *pTMap = (CMapItemLayerTilemap *)pLayer;
|
|
Graphics()->TextureSet(m_pClient->m_pMapimages->GetEntities());
|
|
|
|
CSpeedupTile *pSpeedupTiles = (CSpeedupTile *)m_pLayers->Map()->GetData(pTMap->m_Speedup);
|
|
unsigned int Size = m_pLayers->Map()->GetUncompressedDataSize(pTMap->m_Speedup);
|
|
|
|
if (Size >= pTMap->m_Width*pTMap->m_Height*sizeof(CSpeedupTile))
|
|
{
|
|
Graphics()->BlendNone();
|
|
vec4 Color = vec4(pTMap->m_Color.r/255.0f, pTMap->m_Color.g/255.0f, pTMap->m_Color.b/255.0f, pTMap->m_Color.a/255.0f*g_Config.m_ClOverlayEntities/100.0f);
|
|
RenderTools()->RenderSpeedupmap(pSpeedupTiles, pTMap->m_Width, pTMap->m_Height, 32.0f, Color, TILERENDERFLAG_EXTEND|LAYERRENDERFLAG_OPAQUE);
|
|
Graphics()->BlendNormal();
|
|
RenderTools()->RenderSpeedupmap(pSpeedupTiles, pTMap->m_Width, pTMap->m_Height, 32.0f, Color, TILERENDERFLAG_EXTEND|LAYERRENDERFLAG_TRANSPARENT);
|
|
RenderTools()->RenderSpeedupOverlay(pSpeedupTiles, pTMap->m_Width, pTMap->m_Height, 32.0f, g_Config.m_ClOverlayEntities/100.0f);
|
|
}
|
|
}
|
|
else if(Render && g_Config.m_ClOverlayEntities && IsTuneLayer)
|
|
{
|
|
CMapItemLayerTilemap *pTMap = (CMapItemLayerTilemap *)pLayer;
|
|
Graphics()->TextureSet(m_pClient->m_pMapimages->GetEntities());
|
|
|
|
CTuneTile *pTuneTiles = (CTuneTile *)m_pLayers->Map()->GetData(pTMap->m_Tune);
|
|
unsigned int Size = m_pLayers->Map()->GetUncompressedDataSize(pTMap->m_Tune);
|
|
|
|
if (Size >= pTMap->m_Width*pTMap->m_Height*sizeof(CTuneTile))
|
|
{
|
|
Graphics()->BlendNone();
|
|
vec4 Color = vec4(pTMap->m_Color.r/255.0f, pTMap->m_Color.g/255.0f, pTMap->m_Color.b/255.0f, pTMap->m_Color.a/255.0f*g_Config.m_ClOverlayEntities/100.0f);
|
|
RenderTools()->RenderTunemap(pTuneTiles, pTMap->m_Width, pTMap->m_Height, 32.0f, Color, TILERENDERFLAG_EXTEND|LAYERRENDERFLAG_OPAQUE);
|
|
Graphics()->BlendNormal();
|
|
RenderTools()->RenderTunemap(pTuneTiles, pTMap->m_Width, pTMap->m_Height, 32.0f, Color, TILERENDERFLAG_EXTEND|LAYERRENDERFLAG_TRANSPARENT);
|
|
//RenderTools()->RenderTuneOverlay(pTuneTiles, pTMap->m_Width, pTMap->m_Height, 32.0f, g_Config.m_ClOverlayEntities/100.0f);
|
|
}
|
|
}
|
|
}
|
|
if(!g_Config.m_GfxNoclip)
|
|
Graphics()->ClipDisable();
|
|
}
|
|
|
|
if(!g_Config.m_GfxNoclip)
|
|
Graphics()->ClipDisable();
|
|
|
|
// reset the screen like it was before
|
|
Graphics()->MapScreen(Screen.x, Screen.y, Screen.w, Screen.h);
|
|
}
|