2010-11-20 10:37:14 +00:00
|
|
|
/* (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. */
|
2010-05-29 07:25:38 +00:00
|
|
|
#include <engine/graphics.h>
|
2010-09-07 00:06:11 +00:00
|
|
|
#include <engine/keys.h>
|
2010-10-19 11:37:36 +00:00
|
|
|
#include <engine/demo.h>
|
2010-09-07 00:06:11 +00:00
|
|
|
#include <engine/serverbrowser.h>
|
2010-05-29 07:25:38 +00:00
|
|
|
#include <engine/shared/config.h>
|
2010-09-07 00:06:11 +00:00
|
|
|
#include <engine/storage.h>
|
2009-10-27 14:38:53 +00:00
|
|
|
|
2010-05-29 07:25:38 +00:00
|
|
|
#include <game/layers.h>
|
|
|
|
#include <game/client/gameclient.h>
|
|
|
|
#include <game/client/component.h>
|
|
|
|
#include <game/client/render.h>
|
2008-08-27 15:48:50 +00:00
|
|
|
|
2010-05-29 07:25:38 +00:00
|
|
|
#include <game/client/components/camera.h>
|
|
|
|
#include <game/client/components/mapimages.h>
|
2008-08-27 15:48:50 +00:00
|
|
|
|
2017-09-12 18:22:18 +00:00
|
|
|
#include <game/generated/client_data.h>
|
2009-10-27 14:38:53 +00:00
|
|
|
|
2010-05-29 07:25:38 +00:00
|
|
|
#include "maplayers.h"
|
2008-08-27 15:48:50 +00:00
|
|
|
|
2010-05-29 07:25:38 +00:00
|
|
|
CMapLayers::CMapLayers(int t)
|
2008-08-27 15:48:50 +00:00
|
|
|
{
|
2010-05-29 07:25:38 +00:00
|
|
|
m_Type = t;
|
|
|
|
m_pLayers = 0;
|
2011-12-04 13:04:12 +00:00
|
|
|
m_CurrentLocalTick = 0;
|
|
|
|
m_LastLocalTick = 0;
|
|
|
|
m_EnvelopeUpdate = false;
|
2008-08-27 15:48:50 +00:00
|
|
|
}
|
|
|
|
|
2010-05-29 07:25:38 +00:00
|
|
|
void CMapLayers::OnInit()
|
|
|
|
{
|
|
|
|
m_pLayers = Layers();
|
2017-09-12 18:22:18 +00:00
|
|
|
m_pImages = m_pClient->m_pMapimages;
|
2010-05-29 07:25:38 +00:00
|
|
|
}
|
2008-08-27 15:48:50 +00:00
|
|
|
|
2011-12-04 13:04:12 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-05-29 07:25:38 +00:00
|
|
|
|
2010-10-17 08:43:27 +00:00
|
|
|
void CMapLayers::MapScreenToGroup(float CenterX, float CenterY, CMapItemGroup *pGroup, float Zoom)
|
2008-08-27 15:48:50 +00:00
|
|
|
{
|
2010-05-29 07:25:38 +00:00
|
|
|
float Points[4];
|
2019-04-02 23:05:38 +00:00
|
|
|
RenderTools()->MapscreenToWorld(CenterX, CenterY, pGroup->m_ParallaxX, pGroup->m_ParallaxY,
|
2010-10-17 08:43:27 +00:00
|
|
|
pGroup->m_OffsetX, pGroup->m_OffsetY, Graphics()->ScreenAspect(), Zoom, Points);
|
2010-05-29 07:25:38 +00:00
|
|
|
Graphics()->MapScreen(Points[0], Points[1], Points[2], Points[3]);
|
2008-08-27 15:48:50 +00:00
|
|
|
}
|
|
|
|
|
2010-05-29 07:25:38 +00:00
|
|
|
void CMapLayers::EnvelopeEval(float TimeOffset, int Env, float *pChannels, void *pUser)
|
2008-08-27 15:48:50 +00:00
|
|
|
{
|
2010-05-29 07:25:38 +00:00
|
|
|
CMapLayers *pThis = (CMapLayers *)pUser;
|
|
|
|
pChannels[0] = 0;
|
|
|
|
pChannels[1] = 0;
|
|
|
|
pChannels[2] = 0;
|
|
|
|
pChannels[3] = 0;
|
2008-08-27 15:48:50 +00:00
|
|
|
|
2010-06-09 16:24:38 +00:00
|
|
|
CEnvPoint *pPoints = 0;
|
2008-08-27 15:48:50 +00:00
|
|
|
|
|
|
|
{
|
2010-05-29 07:25:38 +00:00
|
|
|
int Start, Num;
|
|
|
|
pThis->m_pLayers->Map()->GetType(MAPITEMTYPE_ENVPOINTS, &Start, &Num);
|
|
|
|
if(Num)
|
|
|
|
pPoints = (CEnvPoint *)pThis->m_pLayers->Map()->GetItem(Start, 0, 0);
|
2008-08-27 15:48:50 +00:00
|
|
|
}
|
2011-04-13 18:37:12 +00:00
|
|
|
|
2010-05-29 07:25:38 +00:00
|
|
|
int Start, Num;
|
|
|
|
pThis->m_pLayers->Map()->GetType(MAPITEMTYPE_ENVELOPE, &Start, &Num);
|
2011-04-13 18:37:12 +00:00
|
|
|
|
2010-05-29 07:25:38 +00:00
|
|
|
if(Env >= Num)
|
2008-08-27 15:48:50 +00:00
|
|
|
return;
|
2011-04-13 18:37:12 +00:00
|
|
|
|
2010-05-29 07:25:38 +00:00
|
|
|
CMapItemEnvelope *pItem = (CMapItemEnvelope *)pThis->m_pLayers->Map()->GetItem(Start+Env, 0, 0);
|
2011-04-13 18:37:12 +00:00
|
|
|
|
2012-01-09 23:49:31 +00:00
|
|
|
static float s_Time = 0.0f;
|
|
|
|
static float s_LastLocalTime = pThis->Client()->LocalTime();
|
2010-10-19 11:37:36 +00:00
|
|
|
if(pThis->Client()->State() == IClient::STATE_DEMOPLAYBACK)
|
|
|
|
{
|
|
|
|
const IDemoPlayer::CInfo *pInfo = pThis->DemoPlayer()->BaseInfo();
|
2015-07-09 00:08:14 +00:00
|
|
|
|
2011-12-04 13:04:12 +00:00
|
|
|
if(!pInfo->m_Paused || pThis->m_EnvelopeUpdate)
|
2011-12-01 17:36:51 +00:00
|
|
|
{
|
2011-12-04 13:04:12 +00:00
|
|
|
if(pThis->m_CurrentLocalTick != pInfo->m_CurrentTick)
|
2011-12-01 17:36:51 +00:00
|
|
|
{
|
2011-12-04 13:04:12 +00:00
|
|
|
pThis->m_LastLocalTick = pThis->m_CurrentLocalTick;
|
|
|
|
pThis->m_CurrentLocalTick = pInfo->m_CurrentTick;
|
2011-12-01 17:36:51 +00:00
|
|
|
}
|
2011-04-13 18:37:12 +00:00
|
|
|
|
2012-01-09 23:49:31 +00:00
|
|
|
s_Time = mix(pThis->m_LastLocalTick / (float)pThis->Client()->GameTickSpeed(),
|
2011-12-04 13:04:12 +00:00
|
|
|
pThis->m_CurrentLocalTick / (float)pThis->Client()->GameTickSpeed(),
|
2011-12-01 17:36:51 +00:00
|
|
|
pThis->Client()->IntraGameTick());
|
|
|
|
}
|
2011-04-13 18:37:12 +00:00
|
|
|
|
2012-01-09 23:49:31 +00:00
|
|
|
pThis->RenderTools()->RenderEvalEnvelope(pPoints+pItem->m_StartPoint, pItem->m_NumPoints, 4, s_Time+TimeOffset, pChannels);
|
2010-10-19 11:37:36 +00:00
|
|
|
}
|
|
|
|
else
|
2011-04-17 20:07:59 +00:00
|
|
|
{
|
2014-10-31 15:10:09 +00:00
|
|
|
if(pThis->m_pClient->m_Snap.m_pGameInfoObj) // && !(pThis->m_pClient->m_Snap.m_pGameInfoObj->m_GameStateFlags&GAMESTATEFLAG_PAUSED))
|
2011-12-04 13:34:27 +00:00
|
|
|
{
|
2012-01-09 23:49:31 +00:00
|
|
|
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(),
|
2011-12-04 13:34:27 +00:00
|
|
|
(pThis->Client()->GameTick()-pThis->m_pClient->m_Snap.m_pGameInfoObj->m_RoundStartTick) / (float)pThis->Client()->GameTickSpeed(),
|
|
|
|
pThis->Client()->IntraGameTick());
|
2012-01-09 23:49:31 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
s_Time += pThis->Client()->LocalTime()-s_LastLocalTime;
|
2011-12-04 13:34:27 +00:00
|
|
|
}
|
2012-01-09 23:49:31 +00:00
|
|
|
pThis->RenderTools()->RenderEvalEnvelope(pPoints+pItem->m_StartPoint, pItem->m_NumPoints, 4, s_Time+TimeOffset, pChannels);
|
|
|
|
s_LastLocalTime = pThis->Client()->LocalTime();
|
2011-04-17 20:07:59 +00:00
|
|
|
}
|
2008-08-27 15:48:50 +00:00
|
|
|
}
|
|
|
|
|
2017-11-17 23:24:44 +00:00
|
|
|
struct STmpTile
|
|
|
|
{
|
2017-09-12 18:22:18 +00:00
|
|
|
vec2 m_TopLeft;
|
|
|
|
vec2 m_TopRight;
|
|
|
|
vec2 m_BottomRight;
|
2017-09-27 10:20:23 +00:00
|
|
|
vec2 m_BottomLeft;
|
2017-09-12 18:22:18 +00:00
|
|
|
};
|
2017-11-17 23:24:44 +00:00
|
|
|
struct STmpTileTexCoord
|
|
|
|
{
|
2017-09-13 18:33:58 +00:00
|
|
|
STmpTileTexCoord()
|
|
|
|
{
|
2017-09-12 18:22:18 +00:00
|
|
|
m_TexCoordTopLeftRightOrBottom[0] = m_TexCoordTopLeftRightOrBottom[1] = 0;
|
|
|
|
m_TexCoordBottomLeftRightOrBottom[0] = 0; m_TexCoordBottomLeftRightOrBottom[1] = 1;
|
|
|
|
m_TexCoordTopRightRightOrBottom[0] = 1; m_TexCoordTopRightRightOrBottom[1] = 0;
|
|
|
|
m_TexCoordBottomRightRightOrBottom[0] = m_TexCoordBottomRightRightOrBottom[1] = 1;
|
|
|
|
}
|
|
|
|
unsigned char m_TexCoordTopLeft[2];
|
|
|
|
unsigned char m_TexCoordTopLeftRightOrBottom[2];
|
|
|
|
unsigned char m_TexCoordTopRight[2];
|
|
|
|
unsigned char m_TexCoordTopRightRightOrBottom[2];
|
|
|
|
unsigned char m_TexCoordBottomRight[2];
|
|
|
|
unsigned char m_TexCoordBottomRightRightOrBottom[2];
|
2017-09-27 10:20:23 +00:00
|
|
|
unsigned char m_TexCoordBottomLeft[2];
|
|
|
|
unsigned char m_TexCoordBottomLeftRightOrBottom[2];
|
2017-09-12 18:22:18 +00:00
|
|
|
};
|
|
|
|
|
2017-09-13 18:33:58 +00:00
|
|
|
void FillTmpTileSpeedup(STmpTile* pTmpTile, STmpTileTexCoord* pTmpTex, unsigned char Flags, unsigned char Index, int x, int y, int Scale, CMapItemGroup* pGroup, short AngleRotate)
|
|
|
|
{
|
|
|
|
if(pTmpTex)
|
|
|
|
{
|
2017-09-12 18:22:18 +00:00
|
|
|
unsigned char x0 = 0;
|
|
|
|
unsigned char y0 = 0;
|
|
|
|
unsigned char x1 = 16;
|
|
|
|
unsigned char y1 = 0;
|
|
|
|
unsigned char x2 = 16;
|
|
|
|
unsigned char y2 = 16;
|
|
|
|
unsigned char x3 = 0;
|
|
|
|
unsigned char y3 = 16;
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2017-09-12 18:22:18 +00:00
|
|
|
unsigned char bx0 = 0;
|
|
|
|
unsigned char by0 = 0;
|
|
|
|
unsigned char bx1 = 1;
|
|
|
|
unsigned char by1 = 0;
|
|
|
|
unsigned char bx2 = 1;
|
|
|
|
unsigned char by2 = 1;
|
|
|
|
unsigned char bx3 = 0;
|
|
|
|
unsigned char by3 = 1;
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2017-09-12 18:22:18 +00:00
|
|
|
pTmpTex->m_TexCoordTopLeft[0] = x0;
|
|
|
|
pTmpTex->m_TexCoordTopLeft[1] = y0;
|
|
|
|
pTmpTex->m_TexCoordBottomLeft[0] = x3;
|
|
|
|
pTmpTex->m_TexCoordBottomLeft[1] = y3;
|
|
|
|
pTmpTex->m_TexCoordTopRight[0] = x1;
|
|
|
|
pTmpTex->m_TexCoordTopRight[1] = y1;
|
|
|
|
pTmpTex->m_TexCoordBottomRight[0] = x2;
|
|
|
|
pTmpTex->m_TexCoordBottomRight[1] = y2;
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2017-09-12 18:22:18 +00:00
|
|
|
pTmpTex->m_TexCoordTopLeftRightOrBottom[0] = bx0;
|
|
|
|
pTmpTex->m_TexCoordTopLeftRightOrBottom[1] = by0;
|
|
|
|
pTmpTex->m_TexCoordBottomLeftRightOrBottom[0] = bx3;
|
|
|
|
pTmpTex->m_TexCoordBottomLeftRightOrBottom[1] = by3;
|
|
|
|
pTmpTex->m_TexCoordTopRightRightOrBottom[0] = bx1;
|
|
|
|
pTmpTex->m_TexCoordTopRightRightOrBottom[1] = by1;
|
|
|
|
pTmpTex->m_TexCoordBottomRightRightOrBottom[0] = bx2;
|
|
|
|
pTmpTex->m_TexCoordBottomRightRightOrBottom[1] = by2;
|
|
|
|
}
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2017-09-12 18:22:18 +00:00
|
|
|
//same as in rotate from Graphics()
|
|
|
|
float Angle = (float)AngleRotate*(3.14159265f/180.0f);
|
|
|
|
float c = cosf(Angle);
|
|
|
|
float s = sinf(Angle);
|
|
|
|
float xR, yR;
|
|
|
|
int i;
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2017-09-12 18:22:18 +00:00
|
|
|
int ScaleSmaller = 2;
|
|
|
|
pTmpTile->m_TopLeft.x = x*Scale + ScaleSmaller;
|
|
|
|
pTmpTile->m_TopLeft.y = y*Scale + ScaleSmaller;
|
|
|
|
pTmpTile->m_BottomLeft.x = x*Scale + ScaleSmaller;
|
|
|
|
pTmpTile->m_BottomLeft.y = y*Scale + Scale - ScaleSmaller;
|
|
|
|
pTmpTile->m_TopRight.x = x*Scale + Scale - ScaleSmaller;
|
|
|
|
pTmpTile->m_TopRight.y = y*Scale + ScaleSmaller;
|
|
|
|
pTmpTile->m_BottomRight.x = x*Scale + Scale - ScaleSmaller;
|
|
|
|
pTmpTile->m_BottomRight.y = y*Scale + Scale - ScaleSmaller;
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2017-09-12 18:22:18 +00:00
|
|
|
float* pTmpTileVertices = (float*)pTmpTile;
|
|
|
|
|
|
|
|
vec2 Center;
|
|
|
|
Center.x = pTmpTile->m_TopLeft.x + (Scale-ScaleSmaller)/2.f;
|
|
|
|
Center.y = pTmpTile->m_TopLeft.y + (Scale-ScaleSmaller)/2.f;
|
2018-03-13 20:57:46 +00:00
|
|
|
|
|
|
|
for(i = 0; i < 4; i++)
|
2017-09-12 18:22:18 +00:00
|
|
|
{
|
|
|
|
xR = pTmpTileVertices[i*2] - Center.x;
|
|
|
|
yR = pTmpTileVertices[i*2+1] - Center.y;
|
|
|
|
pTmpTileVertices[i*2] = xR * c - yR * s + Center.x;
|
|
|
|
pTmpTileVertices[i*2+1] = xR * s + yR * c + Center.y;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-09-13 18:33:58 +00:00
|
|
|
void FillTmpTile(STmpTile* pTmpTile, STmpTileTexCoord* pTmpTex, unsigned char Flags, unsigned char Index, int x, int y, int Scale, CMapItemGroup* pGroup)
|
|
|
|
{
|
|
|
|
if(pTmpTex)
|
|
|
|
{
|
2017-09-12 18:22:18 +00:00
|
|
|
unsigned char tx = Index%16;
|
|
|
|
unsigned char ty = Index/16;
|
|
|
|
unsigned char x0 = tx;
|
|
|
|
unsigned char y0 = ty;
|
|
|
|
unsigned char x1 = tx+1;
|
|
|
|
unsigned char y1 = ty;
|
|
|
|
unsigned char x2 = tx+1;
|
|
|
|
unsigned char y2 = ty+1;
|
|
|
|
unsigned char x3 = tx;
|
|
|
|
unsigned char y3 = ty+1;
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2017-09-12 18:22:18 +00:00
|
|
|
unsigned char bx0 = 0;
|
|
|
|
unsigned char by0 = 0;
|
|
|
|
unsigned char bx1 = 1;
|
|
|
|
unsigned char by1 = 0;
|
|
|
|
unsigned char bx2 = 1;
|
|
|
|
unsigned char by2 = 1;
|
|
|
|
unsigned char bx3 = 0;
|
|
|
|
unsigned char by3 = 1;
|
2019-03-26 18:15:24 +00:00
|
|
|
|
|
|
|
|
2017-09-12 18:22:18 +00:00
|
|
|
|
|
|
|
if(Flags&TILEFLAG_VFLIP)
|
|
|
|
{
|
|
|
|
x0 = x2;
|
|
|
|
x1 = x3;
|
|
|
|
x2 = x3;
|
|
|
|
x3 = x0;
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2017-09-12 18:22:18 +00:00
|
|
|
bx0 = bx2;
|
|
|
|
bx1 = bx3;
|
|
|
|
bx2 = bx3;
|
|
|
|
bx3 = bx0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(Flags&TILEFLAG_HFLIP)
|
|
|
|
{
|
|
|
|
y0 = y3;
|
|
|
|
y2 = y1;
|
|
|
|
y3 = y1;
|
|
|
|
y1 = y0;
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2017-09-12 18:22:18 +00:00
|
|
|
by0 = by3;
|
|
|
|
by2 = by1;
|
|
|
|
by3 = by1;
|
|
|
|
by1 = by0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(Flags&TILEFLAG_ROTATE)
|
|
|
|
{
|
|
|
|
unsigned char Tmp = x0;
|
|
|
|
x0 = x3;
|
|
|
|
x3 = x2;
|
|
|
|
x2 = x1;
|
|
|
|
x1 = Tmp;
|
|
|
|
Tmp = y0;
|
|
|
|
y0 = y3;
|
|
|
|
y3 = y2;
|
|
|
|
y2 = y1;
|
|
|
|
y1 = Tmp;
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2017-09-12 18:22:18 +00:00
|
|
|
Tmp = bx0;
|
|
|
|
bx0 = bx3;
|
|
|
|
bx3 = bx2;
|
|
|
|
bx2 = bx1;
|
|
|
|
bx1 = Tmp;
|
|
|
|
Tmp = by0;
|
|
|
|
by0 = by3;
|
|
|
|
by3 = by2;
|
|
|
|
by2 = by1;
|
|
|
|
by1 = Tmp;
|
|
|
|
}
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2017-09-12 18:22:18 +00:00
|
|
|
pTmpTex->m_TexCoordTopLeft[0] = x0;
|
|
|
|
pTmpTex->m_TexCoordTopLeft[1] = y0;
|
|
|
|
pTmpTex->m_TexCoordBottomLeft[0] = x3;
|
|
|
|
pTmpTex->m_TexCoordBottomLeft[1] = y3;
|
|
|
|
pTmpTex->m_TexCoordTopRight[0] = x1;
|
|
|
|
pTmpTex->m_TexCoordTopRight[1] = y1;
|
|
|
|
pTmpTex->m_TexCoordBottomRight[0] = x2;
|
|
|
|
pTmpTex->m_TexCoordBottomRight[1] = y2;
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2017-09-12 18:22:18 +00:00
|
|
|
pTmpTex->m_TexCoordTopLeftRightOrBottom[0] = bx0;
|
|
|
|
pTmpTex->m_TexCoordTopLeftRightOrBottom[1] = by0;
|
|
|
|
pTmpTex->m_TexCoordBottomLeftRightOrBottom[0] = bx3;
|
|
|
|
pTmpTex->m_TexCoordBottomLeftRightOrBottom[1] = by3;
|
|
|
|
pTmpTex->m_TexCoordTopRightRightOrBottom[0] = bx1;
|
|
|
|
pTmpTex->m_TexCoordTopRightRightOrBottom[1] = by1;
|
|
|
|
pTmpTex->m_TexCoordBottomRightRightOrBottom[0] = bx2;
|
|
|
|
pTmpTex->m_TexCoordBottomRightRightOrBottom[1] = by2;
|
|
|
|
}
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2017-09-12 18:22:18 +00:00
|
|
|
pTmpTile->m_TopLeft.x = x*Scale;
|
|
|
|
pTmpTile->m_TopLeft.y = y*Scale;
|
|
|
|
pTmpTile->m_BottomLeft.x = x*Scale;
|
|
|
|
pTmpTile->m_BottomLeft.y = y*Scale + Scale;
|
|
|
|
pTmpTile->m_TopRight.x = x*Scale + Scale;
|
|
|
|
pTmpTile->m_TopRight.y = y*Scale;
|
|
|
|
pTmpTile->m_BottomRight.x = x*Scale + Scale;
|
|
|
|
pTmpTile->m_BottomRight.y = y*Scale + Scale;
|
|
|
|
}
|
|
|
|
|
2019-03-26 18:15:24 +00:00
|
|
|
bool CMapLayers::STileLayerVisuals::Init(unsigned int Width, unsigned int Height)
|
2017-09-27 10:20:23 +00:00
|
|
|
{
|
|
|
|
m_Width = Width;
|
|
|
|
m_Height = Height;
|
2018-03-13 20:57:46 +00:00
|
|
|
if(Width == 0 || Height == 0)
|
|
|
|
return false;
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2018-01-16 08:35:28 +00:00
|
|
|
m_TilesOfLayer = new CMapLayers::STileLayerVisuals::STileVisual[Height*Width];
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2017-09-27 12:52:06 +00:00
|
|
|
if(Width > 2)
|
|
|
|
{
|
2017-09-27 10:20:23 +00:00
|
|
|
m_BorderTop = new CMapLayers::STileLayerVisuals::STileVisual[Width-2];
|
|
|
|
m_BorderBottom = new CMapLayers::STileLayerVisuals::STileVisual[Width-2];
|
|
|
|
}
|
2017-09-27 12:52:06 +00:00
|
|
|
if(Height > 2)
|
|
|
|
{
|
2017-09-27 10:20:23 +00:00
|
|
|
m_BorderLeft = new CMapLayers::STileLayerVisuals::STileVisual[Height-2];
|
|
|
|
m_BorderRight = new CMapLayers::STileLayerVisuals::STileVisual[Height-2];
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2019-03-26 18:15:24 +00:00
|
|
|
CMapLayers::STileLayerVisuals::~STileLayerVisuals()
|
2017-09-27 10:20:23 +00:00
|
|
|
{
|
2017-09-27 12:52:06 +00:00
|
|
|
if(m_TilesOfLayer)
|
|
|
|
{
|
2017-09-27 10:20:23 +00:00
|
|
|
delete[] m_TilesOfLayer;
|
|
|
|
}
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2018-03-13 20:57:46 +00:00
|
|
|
if(m_BorderTop)
|
|
|
|
delete[] m_BorderTop;
|
|
|
|
if(m_BorderBottom)
|
|
|
|
delete[] m_BorderBottom;
|
|
|
|
if(m_BorderLeft)
|
|
|
|
delete[] m_BorderLeft;
|
|
|
|
if(m_BorderRight)
|
|
|
|
delete[] m_BorderRight;
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2017-09-27 10:20:23 +00:00
|
|
|
m_TilesOfLayer = NULL;
|
|
|
|
m_BorderTop = NULL;
|
|
|
|
m_BorderBottom = NULL;
|
|
|
|
m_BorderLeft = NULL;
|
|
|
|
m_BorderRight = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool AddTile(std::vector<STmpTile>& TmpTiles, std::vector<STmpTileTexCoord>& TmpTileTexCoords, unsigned char Index, unsigned char Flags, int x, int y, CMapItemGroup* pGroup, bool DoTextureCoords, bool FillSpeedup = false, int AngleRotate = -1)
|
|
|
|
{
|
|
|
|
if(Index)
|
|
|
|
{
|
|
|
|
TmpTiles.push_back(STmpTile());
|
|
|
|
STmpTile& Tile = TmpTiles.back();
|
|
|
|
STmpTileTexCoord* pTileTex = NULL;
|
|
|
|
if(DoTextureCoords)
|
|
|
|
{
|
|
|
|
TmpTileTexCoords.push_back(STmpTileTexCoord());
|
|
|
|
STmpTileTexCoord& TileTex = TmpTileTexCoords.back();
|
|
|
|
pTileTex = &TileTex;
|
|
|
|
}
|
2018-03-13 20:57:46 +00:00
|
|
|
if(FillSpeedup)
|
|
|
|
FillTmpTileSpeedup(&Tile, pTileTex, Flags, 0, x, y, 32.f, pGroup, AngleRotate);
|
|
|
|
else
|
|
|
|
FillTmpTile(&Tile, pTileTex, Flags, Index, x, y, 32.f, pGroup);
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2017-09-27 10:20:23 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2018-03-13 20:57:46 +00:00
|
|
|
struct STmpQuadVertexTextured
|
|
|
|
{
|
|
|
|
float m_X, m_Y, m_CenterX, m_CenterY;
|
|
|
|
float m_U, m_V;
|
|
|
|
unsigned char m_R, m_G, m_B, m_A;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct STmpQuadVertex
|
|
|
|
{
|
|
|
|
float m_X, m_Y, m_CenterX, m_CenterY;
|
|
|
|
unsigned char m_R, m_G, m_B, m_A;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct STmpQuad
|
|
|
|
{
|
|
|
|
STmpQuadVertex m_aVertices[4];
|
|
|
|
};
|
|
|
|
|
|
|
|
struct STmpQuadTextured
|
|
|
|
{
|
|
|
|
STmpQuadVertexTextured m_aVertices[4];
|
|
|
|
};
|
|
|
|
|
|
|
|
void mem_copy_special(void *pDest, void *pSource, size_t Size, size_t Count, size_t Steps)
|
|
|
|
{
|
|
|
|
size_t CurStep = 0;
|
|
|
|
for(size_t i = 0; i < Count; ++i)
|
|
|
|
{
|
|
|
|
mem_copy(((char*)pDest) + CurStep + i * Size, ((char*)pSource) + i * Size, Size);
|
|
|
|
CurStep += Steps;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-09-12 18:22:18 +00:00
|
|
|
void CMapLayers::OnMapLoad()
|
|
|
|
{
|
2018-03-13 20:57:46 +00:00
|
|
|
if(!Graphics()->IsBufferingEnabled())
|
|
|
|
return;
|
2017-09-12 18:22:18 +00:00
|
|
|
//clear everything and destroy all buffers
|
2017-09-13 18:33:58 +00:00
|
|
|
if(m_TileLayerVisuals.size() != 0)
|
|
|
|
{
|
2017-09-12 18:22:18 +00:00
|
|
|
int s = m_TileLayerVisuals.size();
|
2017-09-13 18:33:58 +00:00
|
|
|
for(int i = 0; i < s; ++i)
|
|
|
|
{
|
2019-03-26 18:15:24 +00:00
|
|
|
Graphics()->DeleteBufferContainer(m_TileLayerVisuals[i]->m_BufferContainerIndex, true);
|
2017-09-27 10:20:23 +00:00
|
|
|
delete m_TileLayerVisuals[i];
|
2017-09-12 18:22:18 +00:00
|
|
|
}
|
|
|
|
m_TileLayerVisuals.clear();
|
|
|
|
}
|
2018-03-13 20:57:46 +00:00
|
|
|
if(m_QuadLayerVisuals.size() != 0)
|
|
|
|
{
|
|
|
|
int s = m_QuadLayerVisuals.size();
|
|
|
|
for(int i = 0; i < s; ++i)
|
|
|
|
{
|
|
|
|
Graphics()->DeleteBufferContainer(m_QuadLayerVisuals[i]->m_BufferContainerIndex, true);
|
|
|
|
delete m_QuadLayerVisuals[i];
|
|
|
|
}
|
|
|
|
m_QuadLayerVisuals.clear();
|
|
|
|
}
|
|
|
|
|
2017-09-12 18:22:18 +00:00
|
|
|
bool PassedGameLayer = false;
|
2019-03-26 18:15:24 +00:00
|
|
|
//prepare all visuals for all tile layers
|
2017-09-12 18:22:18 +00:00
|
|
|
std::vector<STmpTile> tmpTiles;
|
|
|
|
std::vector<STmpTileTexCoord> tmpTileTexCoords;
|
2017-09-27 10:20:23 +00:00
|
|
|
std::vector<STmpTile> tmpBorderTopTiles;
|
|
|
|
std::vector<STmpTileTexCoord> tmpBorderTopTilesTexCoords;
|
|
|
|
std::vector<STmpTile> tmpBorderLeftTiles;
|
|
|
|
std::vector<STmpTileTexCoord> tmpBorderLeftTilesTexCoords;
|
|
|
|
std::vector<STmpTile> tmpBorderRightTiles;
|
|
|
|
std::vector<STmpTileTexCoord> tmpBorderRightTilesTexCoords;
|
|
|
|
std::vector<STmpTile> tmpBorderBottomTiles;
|
|
|
|
std::vector<STmpTileTexCoord> tmpBorderBottomTilesTexCoords;
|
|
|
|
std::vector<STmpTile> tmpBorderCorners;
|
|
|
|
std::vector<STmpTileTexCoord> tmpBorderCornersTexCoords;
|
2018-01-16 08:35:28 +00:00
|
|
|
|
2018-03-13 20:57:46 +00:00
|
|
|
std::vector<STmpQuad> tmpQuads;
|
|
|
|
std::vector<STmpQuadTextured> tmpQuadsTextured;
|
|
|
|
|
2017-09-12 18:22:18 +00:00
|
|
|
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;
|
|
|
|
}
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2017-09-12 18:22:18 +00:00
|
|
|
for(int l = 0; l < pGroup->m_NumLayers; l++)
|
|
|
|
{
|
|
|
|
CMapItemLayer *pLayer = m_pLayers->GetLayer(pGroup->m_StartLayer+l);
|
|
|
|
bool IsFrontLayer = false;
|
|
|
|
bool IsSwitchLayer = false;
|
|
|
|
bool IsTeleLayer = false;
|
|
|
|
bool IsSpeedupLayer = false;
|
|
|
|
bool IsTuneLayer = false;
|
|
|
|
bool IsGameLayer = false;
|
|
|
|
bool IsEntityLayer = false;
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2017-09-12 18:22:18 +00:00
|
|
|
if(pLayer == (CMapItemLayer*)m_pLayers->GameLayer())
|
|
|
|
{
|
|
|
|
IsGameLayer = true;
|
|
|
|
IsEntityLayer = true;
|
|
|
|
PassedGameLayer = true;
|
|
|
|
}
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2018-01-16 08:35:28 +00:00
|
|
|
if(pLayer == (CMapItemLayer*)m_pLayers->FrontLayer())
|
2017-09-12 18:22:18 +00:00
|
|
|
IsEntityLayer = IsFrontLayer = true;
|
|
|
|
|
2018-01-16 08:35:28 +00:00
|
|
|
if(pLayer == (CMapItemLayer*)m_pLayers->SwitchLayer())
|
2017-09-12 18:22:18 +00:00
|
|
|
IsEntityLayer = IsSwitchLayer = true;
|
|
|
|
|
2018-01-16 08:35:28 +00:00
|
|
|
if(pLayer == (CMapItemLayer*)m_pLayers->TeleLayer())
|
2017-09-12 18:22:18 +00:00
|
|
|
IsEntityLayer = IsTeleLayer = true;
|
|
|
|
|
2018-01-16 08:35:28 +00:00
|
|
|
if(pLayer == (CMapItemLayer*)m_pLayers->SpeedupLayer())
|
2017-09-12 18:22:18 +00:00
|
|
|
IsEntityLayer = IsSpeedupLayer = true;
|
|
|
|
|
2018-01-16 08:35:28 +00:00
|
|
|
if(pLayer == (CMapItemLayer*)m_pLayers->TuneLayer())
|
2017-09-12 18:22:18 +00:00
|
|
|
IsEntityLayer = IsTuneLayer = true;
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2017-09-12 18:22:18 +00:00
|
|
|
if(m_Type <= TYPE_BACKGROUND_FORCE)
|
|
|
|
{
|
|
|
|
if(PassedGameLayer)
|
|
|
|
return;
|
|
|
|
}
|
2018-01-16 08:35:28 +00:00
|
|
|
else if(m_Type == TYPE_FOREGROUND)
|
|
|
|
{
|
|
|
|
if(!PassedGameLayer)
|
|
|
|
continue;
|
|
|
|
}
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2017-09-12 18:22:18 +00:00
|
|
|
if(pLayer->m_Type == LAYERTYPE_TILES)
|
2019-03-26 18:15:24 +00:00
|
|
|
{
|
2017-09-12 18:22:18 +00:00
|
|
|
bool DoTextureCoords = false;
|
|
|
|
CMapItemLayerTilemap *pTMap = (CMapItemLayerTilemap *)pLayer;
|
|
|
|
if(pTMap->m_Image == -1)
|
|
|
|
{
|
|
|
|
if(IsEntityLayer)
|
|
|
|
DoTextureCoords = true;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
DoTextureCoords = true;
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2017-09-12 18:22:18 +00:00
|
|
|
|
|
|
|
int DataIndex = 0;
|
2017-09-27 12:52:06 +00:00
|
|
|
unsigned int TileSize = 0;
|
2017-09-12 18:22:18 +00:00
|
|
|
int OverlayCount = 0;
|
2018-01-16 08:35:28 +00:00
|
|
|
if(IsFrontLayer)
|
2017-09-13 18:33:58 +00:00
|
|
|
{
|
2017-09-12 18:22:18 +00:00
|
|
|
DataIndex = pTMap->m_Front;
|
|
|
|
TileSize = sizeof(CTile);
|
|
|
|
}
|
2018-01-16 08:35:28 +00:00
|
|
|
else if(IsSwitchLayer)
|
2017-09-13 18:33:58 +00:00
|
|
|
{
|
2017-09-12 18:22:18 +00:00
|
|
|
DataIndex = pTMap->m_Switch;
|
|
|
|
TileSize = sizeof(CSwitchTile);
|
|
|
|
OverlayCount = 2;
|
|
|
|
}
|
2018-01-16 08:35:28 +00:00
|
|
|
else if(IsTeleLayer)
|
2017-09-13 18:33:58 +00:00
|
|
|
{
|
2017-09-12 18:22:18 +00:00
|
|
|
DataIndex = pTMap->m_Tele;
|
|
|
|
TileSize = sizeof(CTeleTile);
|
|
|
|
OverlayCount = 1;
|
|
|
|
}
|
2018-01-16 08:35:28 +00:00
|
|
|
else if(IsSpeedupLayer)
|
2017-09-13 18:33:58 +00:00
|
|
|
{
|
2017-09-12 18:22:18 +00:00
|
|
|
DataIndex = pTMap->m_Speedup;
|
|
|
|
TileSize = sizeof(CSpeedupTile);
|
|
|
|
OverlayCount = 2;
|
|
|
|
}
|
2018-01-16 08:35:28 +00:00
|
|
|
else if(IsTuneLayer)
|
2017-09-13 18:33:58 +00:00
|
|
|
{
|
2017-09-12 18:22:18 +00:00
|
|
|
DataIndex = pTMap->m_Tune;
|
|
|
|
TileSize = sizeof(CTuneTile);
|
|
|
|
}
|
2017-09-13 18:33:58 +00:00
|
|
|
else
|
|
|
|
{
|
2017-09-12 18:22:18 +00:00
|
|
|
DataIndex = pTMap->m_Data;
|
|
|
|
TileSize = sizeof(CTile);
|
|
|
|
}
|
|
|
|
unsigned int Size = m_pLayers->Map()->GetDataSize(DataIndex);
|
2019-04-11 10:21:42 +00:00
|
|
|
void* pTiles = m_pLayers->Map()->GetData(DataIndex);
|
2017-09-12 18:22:18 +00:00
|
|
|
|
2018-01-16 08:35:28 +00:00
|
|
|
if(Size >= pTMap->m_Width*pTMap->m_Height*TileSize)
|
2017-09-12 18:22:18 +00:00
|
|
|
{
|
|
|
|
int CurOverlay = 0;
|
2017-09-13 18:33:58 +00:00
|
|
|
while(CurOverlay < OverlayCount + 1)
|
|
|
|
{
|
2018-02-04 15:00:47 +00:00
|
|
|
// We can later just count the tile layers to get the idx in the vector
|
2017-09-27 10:20:23 +00:00
|
|
|
m_TileLayerVisuals.push_back(new STileLayerVisuals());
|
|
|
|
STileLayerVisuals& Visuals = *m_TileLayerVisuals.back();
|
2018-03-13 20:57:46 +00:00
|
|
|
if(!Visuals.Init(pTMap->m_Width, pTMap->m_Height))
|
|
|
|
{
|
|
|
|
++CurOverlay;
|
|
|
|
continue;
|
|
|
|
}
|
2017-09-12 18:22:18 +00:00
|
|
|
Visuals.m_IsTextured = DoTextureCoords;
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2017-09-12 18:22:18 +00:00
|
|
|
tmpTiles.clear();
|
|
|
|
tmpTileTexCoords.clear();
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2017-09-27 10:20:23 +00:00
|
|
|
tmpBorderTopTiles.clear();
|
|
|
|
tmpBorderLeftTiles.clear();
|
|
|
|
tmpBorderRightTiles.clear();
|
2019-03-26 18:15:24 +00:00
|
|
|
tmpBorderBottomTiles.clear();
|
|
|
|
tmpBorderCorners.clear();
|
2017-09-27 10:20:23 +00:00
|
|
|
tmpBorderTopTilesTexCoords.clear();
|
|
|
|
tmpBorderLeftTilesTexCoords.clear();
|
|
|
|
tmpBorderRightTilesTexCoords.clear();
|
2019-03-26 18:15:24 +00:00
|
|
|
tmpBorderBottomTilesTexCoords.clear();
|
2017-09-27 10:20:23 +00:00
|
|
|
tmpBorderCornersTexCoords.clear();
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2017-09-12 18:22:18 +00:00
|
|
|
int x = 0;
|
|
|
|
int y = 0;
|
2017-09-27 10:20:23 +00:00
|
|
|
for(y = 0; y < pTMap->m_Height; ++y)
|
2017-09-13 18:33:58 +00:00
|
|
|
{
|
2017-09-27 10:20:23 +00:00
|
|
|
for(x = 0; x < pTMap->m_Width; ++x)
|
2017-09-12 18:22:18 +00:00
|
|
|
{
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2017-09-27 10:20:23 +00:00
|
|
|
unsigned char Index = 0;
|
|
|
|
unsigned char Flags = 0;
|
|
|
|
int AngleRotate = -1;
|
|
|
|
if(IsEntityLayer)
|
2019-03-26 18:15:24 +00:00
|
|
|
{
|
2017-09-27 10:20:23 +00:00
|
|
|
if(IsGameLayer)
|
2019-03-26 18:15:24 +00:00
|
|
|
{
|
2017-09-27 10:20:23 +00:00
|
|
|
Index = ((CTile*)pTiles)[y*pTMap->m_Width+x].m_Index;
|
|
|
|
Flags = ((CTile*)pTiles)[y*pTMap->m_Width+x].m_Flags;
|
2019-07-31 19:22:11 +00:00
|
|
|
if(!GameClient()->m_GameInfo.m_DontMaskEntities && !IsValidGameTile(Index))
|
2017-10-25 13:42:06 +00:00
|
|
|
Index = 0;
|
2017-09-27 10:20:23 +00:00
|
|
|
}
|
|
|
|
if(IsFrontLayer)
|
2019-03-26 18:15:24 +00:00
|
|
|
{
|
2017-09-12 18:22:18 +00:00
|
|
|
Index = ((CTile*)pTiles)[y*pTMap->m_Width+x].m_Index;
|
|
|
|
Flags = ((CTile*)pTiles)[y*pTMap->m_Width+x].m_Flags;
|
2019-07-31 19:22:11 +00:00
|
|
|
if(!GameClient()->m_GameInfo.m_DontMaskEntities && !IsValidFrontTile(Index))
|
2017-10-25 13:42:06 +00:00
|
|
|
Index = 0;
|
2017-09-12 18:22:18 +00:00
|
|
|
}
|
2017-09-27 10:20:23 +00:00
|
|
|
if(IsSwitchLayer)
|
2017-09-12 18:22:18 +00:00
|
|
|
{
|
2017-09-27 10:20:23 +00:00
|
|
|
Flags = 0;
|
|
|
|
Index = ((CSwitchTile*)pTiles)[y*pTMap->m_Width+x].m_Type;
|
2019-08-06 21:43:11 +00:00
|
|
|
if(!IsValidSwitchTile(Index))
|
2017-10-25 13:42:06 +00:00
|
|
|
Index = 0;
|
2017-10-24 18:41:11 +00:00
|
|
|
else if(CurOverlay == 0)
|
2017-09-13 18:33:58 +00:00
|
|
|
{
|
2017-09-27 10:20:23 +00:00
|
|
|
Flags = ((CSwitchTile*)pTiles)[y*pTMap->m_Width+x].m_Flags;
|
|
|
|
if(Index == TILE_SWITCHTIMEDOPEN) Index = 8;
|
2017-09-12 18:22:18 +00:00
|
|
|
}
|
2017-10-25 13:42:06 +00:00
|
|
|
else if(CurOverlay == 1)
|
|
|
|
Index = ((CSwitchTile*)pTiles)[y*pTMap->m_Width+x].m_Number;
|
|
|
|
else if(CurOverlay == 2)
|
|
|
|
Index = ((CSwitchTile*)pTiles)[y*pTMap->m_Width+x].m_Delay;
|
2017-09-27 10:20:23 +00:00
|
|
|
}
|
|
|
|
if(IsTeleLayer)
|
|
|
|
{
|
|
|
|
Index = ((CTeleTile*)pTiles)[y*pTMap->m_Width+x].m_Type;
|
|
|
|
Flags = 0;
|
2019-08-06 21:43:11 +00:00
|
|
|
if(!IsValidTeleTile(Index))
|
2017-10-25 13:42:06 +00:00
|
|
|
Index = 0;
|
2017-10-24 18:41:11 +00:00
|
|
|
else if(CurOverlay == 1)
|
2017-09-13 18:33:58 +00:00
|
|
|
{
|
2017-09-27 10:20:23 +00:00
|
|
|
if(Index != TILE_TELECHECKIN && Index != TILE_TELECHECKINEVIL)
|
|
|
|
Index = ((CTeleTile*)pTiles)[y*pTMap->m_Width+x].m_Number;
|
|
|
|
else Index = 0;
|
2017-09-12 18:22:18 +00:00
|
|
|
}
|
|
|
|
}
|
2017-09-27 10:20:23 +00:00
|
|
|
if(IsSpeedupLayer)
|
|
|
|
{
|
|
|
|
Index = ((CSpeedupTile*)pTiles)[y*pTMap->m_Width+x].m_Type;
|
|
|
|
Flags = 0;
|
2017-10-24 18:41:11 +00:00
|
|
|
AngleRotate = ((CSpeedupTile*)pTiles)[y*pTMap->m_Width + x].m_Angle;
|
2019-08-06 21:43:11 +00:00
|
|
|
if(!IsValidSpeedupTile(Index) || ((CSpeedupTile*)pTiles)[y*pTMap->m_Width+x].m_Force == 0)
|
2017-10-25 13:42:06 +00:00
|
|
|
Index = 0;
|
|
|
|
else if(CurOverlay == 1)
|
|
|
|
Index = ((CSpeedupTile*)pTiles)[y*pTMap->m_Width+x].m_Force;
|
|
|
|
else if(CurOverlay == 2)
|
|
|
|
Index = ((CSpeedupTile*)pTiles)[y*pTMap->m_Width+x].m_MaxSpeed;
|
2017-09-27 10:20:23 +00:00
|
|
|
}
|
|
|
|
if(IsTuneLayer)
|
2019-03-26 18:15:24 +00:00
|
|
|
{
|
2017-09-27 10:20:23 +00:00
|
|
|
Index = ((CTuneTile*)pTiles)[y*pTMap->m_Width+x].m_Type;
|
2019-08-06 21:43:11 +00:00
|
|
|
if(!IsValidTuneTile(Index))
|
2019-03-26 18:15:24 +00:00
|
|
|
Index = 0;
|
2017-09-27 10:20:23 +00:00
|
|
|
Flags = 0;
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
{
|
|
|
|
Index = ((CTile*)pTiles)[y*pTMap->m_Width+x].m_Index;
|
|
|
|
Flags = ((CTile*)pTiles)[y*pTMap->m_Width+x].m_Flags;
|
|
|
|
}
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2017-09-27 10:20:23 +00:00
|
|
|
//the amount of tiles handled before this tile
|
|
|
|
int TilesHandledCount = tmpTiles.size();
|
2018-01-16 09:18:14 +00:00
|
|
|
Visuals.m_TilesOfLayer[y*pTMap->m_Width + x].SetIndexBufferByteOffset((offset_ptr32)(TilesHandledCount*6*sizeof(unsigned int)));
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2017-10-27 22:52:54 +00:00
|
|
|
bool AddAsSpeedup = false;
|
2018-01-16 08:35:28 +00:00
|
|
|
if(IsSpeedupLayer && CurOverlay == 0)
|
2017-10-27 22:52:54 +00:00
|
|
|
AddAsSpeedup = true;
|
|
|
|
|
|
|
|
if(AddTile(tmpTiles, tmpTileTexCoords, Index, Flags, x, y, pGroup, DoTextureCoords, AddAsSpeedup, AngleRotate))
|
2018-01-16 08:35:28 +00:00
|
|
|
Visuals.m_TilesOfLayer[y*pTMap->m_Width + x].Draw(true);
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2017-09-27 10:20:23 +00:00
|
|
|
//do the border tiles
|
|
|
|
if(x == 0)
|
|
|
|
{
|
|
|
|
if(y == 0)
|
|
|
|
{
|
2018-01-16 09:18:14 +00:00
|
|
|
Visuals.m_BorderTopLeft.SetIndexBufferByteOffset((offset_ptr32)(tmpBorderCorners.size()*6*sizeof(unsigned int)));
|
2017-10-27 22:52:54 +00:00
|
|
|
if(AddTile(tmpBorderCorners, tmpBorderCornersTexCoords, Index, Flags, x, y, pGroup, DoTextureCoords, AddAsSpeedup, AngleRotate))
|
2018-01-16 08:35:28 +00:00
|
|
|
Visuals.m_BorderTopLeft.Draw(true);
|
2018-03-13 20:57:46 +00:00
|
|
|
}
|
|
|
|
else if(y == pTMap->m_Height - 1)
|
2017-09-27 10:20:23 +00:00
|
|
|
{
|
2018-01-16 09:18:14 +00:00
|
|
|
Visuals.m_BorderBottomLeft.SetIndexBufferByteOffset((offset_ptr32)(tmpBorderCorners.size()*6*sizeof(unsigned int)));
|
2017-10-27 22:52:54 +00:00
|
|
|
if(AddTile(tmpBorderCorners, tmpBorderCornersTexCoords, Index, Flags, x, y, pGroup, DoTextureCoords, AddAsSpeedup, AngleRotate))
|
2018-01-16 08:35:28 +00:00
|
|
|
Visuals.m_BorderBottomLeft.Draw(true);
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2018-03-13 20:57:46 +00:00
|
|
|
}
|
2019-03-26 18:15:24 +00:00
|
|
|
else
|
2017-09-27 10:20:23 +00:00
|
|
|
{
|
2018-01-16 09:18:14 +00:00
|
|
|
Visuals.m_BorderLeft[y-1].SetIndexBufferByteOffset((offset_ptr32)(tmpBorderLeftTiles.size()*6*sizeof(unsigned int)));
|
2017-10-27 22:52:54 +00:00
|
|
|
if(AddTile(tmpBorderLeftTiles, tmpBorderLeftTilesTexCoords, Index, Flags, x, y, pGroup, DoTextureCoords, AddAsSpeedup, AngleRotate))
|
2018-01-16 08:35:28 +00:00
|
|
|
Visuals.m_BorderLeft[y-1].Draw(true);
|
2017-09-27 10:20:23 +00:00
|
|
|
}
|
2018-03-13 20:57:46 +00:00
|
|
|
}
|
|
|
|
else if(x == pTMap->m_Width - 1)
|
2017-09-27 10:20:23 +00:00
|
|
|
{
|
|
|
|
if(y == 0)
|
|
|
|
{
|
2018-01-16 09:18:14 +00:00
|
|
|
Visuals.m_BorderTopRight.SetIndexBufferByteOffset((offset_ptr32)(tmpBorderCorners.size()*6*sizeof(unsigned int)));
|
2017-10-27 22:52:54 +00:00
|
|
|
if(AddTile(tmpBorderCorners, tmpBorderCornersTexCoords, Index, Flags, x, y, pGroup, DoTextureCoords, AddAsSpeedup, AngleRotate))
|
2018-01-16 08:35:28 +00:00
|
|
|
Visuals.m_BorderTopRight.Draw(true);
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2018-03-13 20:57:46 +00:00
|
|
|
}
|
|
|
|
else if(y == pTMap->m_Height - 1)
|
2017-09-27 10:20:23 +00:00
|
|
|
{
|
2018-01-16 09:18:14 +00:00
|
|
|
Visuals.m_BorderBottomRight.SetIndexBufferByteOffset((offset_ptr32)(tmpBorderCorners.size()*6*sizeof(unsigned int)));
|
2017-10-27 22:52:54 +00:00
|
|
|
if(AddTile(tmpBorderCorners, tmpBorderCornersTexCoords, Index, Flags, x, y, pGroup, DoTextureCoords, AddAsSpeedup, AngleRotate))
|
2018-01-16 08:35:28 +00:00
|
|
|
Visuals.m_BorderBottomRight.Draw(true);
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2018-03-13 20:57:46 +00:00
|
|
|
}
|
|
|
|
else
|
2017-09-27 10:20:23 +00:00
|
|
|
{
|
2018-01-16 09:18:14 +00:00
|
|
|
Visuals.m_BorderRight[y-1].SetIndexBufferByteOffset((offset_ptr32)(tmpBorderRightTiles.size()*6*sizeof(unsigned int)));
|
2017-10-27 22:52:54 +00:00
|
|
|
if(AddTile(tmpBorderRightTiles, tmpBorderRightTilesTexCoords, Index, Flags, x, y, pGroup, DoTextureCoords, AddAsSpeedup, AngleRotate))
|
2018-01-16 08:35:28 +00:00
|
|
|
Visuals.m_BorderRight[y-1].Draw(true);
|
2017-09-27 10:20:23 +00:00
|
|
|
}
|
2018-03-13 20:57:46 +00:00
|
|
|
}
|
|
|
|
else if(y == 0)
|
2017-09-27 10:20:23 +00:00
|
|
|
{
|
|
|
|
if(x > 0 && x < pTMap->m_Width - 1)
|
|
|
|
{
|
2018-01-16 09:18:14 +00:00
|
|
|
Visuals.m_BorderTop[x-1].SetIndexBufferByteOffset((offset_ptr32)(tmpBorderTopTiles.size()*6*sizeof(unsigned int)));
|
2017-10-27 22:52:54 +00:00
|
|
|
if(AddTile(tmpBorderTopTiles, tmpBorderTopTilesTexCoords, Index, Flags, x, y, pGroup, DoTextureCoords, AddAsSpeedup, AngleRotate))
|
2018-01-16 08:35:28 +00:00
|
|
|
Visuals.m_BorderTop[x-1].Draw(true);
|
2017-09-27 10:20:23 +00:00
|
|
|
}
|
2018-03-13 20:57:46 +00:00
|
|
|
}
|
|
|
|
else if(y == pTMap->m_Height - 1)
|
2017-09-27 10:20:23 +00:00
|
|
|
{
|
|
|
|
if(x > 0 && x < pTMap->m_Width - 1)
|
|
|
|
{
|
2018-01-16 09:18:14 +00:00
|
|
|
Visuals.m_BorderBottom[x-1].SetIndexBufferByteOffset((offset_ptr32)(tmpBorderBottomTiles.size()*6*sizeof(unsigned int)));
|
2017-10-27 22:52:54 +00:00
|
|
|
if(AddTile(tmpBorderBottomTiles, tmpBorderBottomTilesTexCoords, Index, Flags, x, y, pGroup, DoTextureCoords, AddAsSpeedup, AngleRotate))
|
2018-01-16 08:35:28 +00:00
|
|
|
Visuals.m_BorderBottom[x-1].Draw(true);
|
2017-09-27 10:20:23 +00:00
|
|
|
}
|
2017-09-12 18:22:18 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2017-09-12 18:22:18 +00:00
|
|
|
//append one kill tile to the gamelayer
|
2017-09-13 18:33:58 +00:00
|
|
|
if(IsGameLayer)
|
|
|
|
{
|
2018-01-16 09:18:14 +00:00
|
|
|
Visuals.m_BorderKillTile.SetIndexBufferByteOffset((offset_ptr32)(tmpTiles.size() * 6 * sizeof(unsigned int)));
|
2019-03-26 18:15:24 +00:00
|
|
|
if(AddTile(tmpTiles, tmpTileTexCoords, TILE_DEATH, 0, 0, 0, pGroup, DoTextureCoords))
|
2018-01-16 08:35:28 +00:00
|
|
|
Visuals.m_BorderKillTile.Draw(true);
|
2017-09-12 18:22:18 +00:00
|
|
|
}
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2017-09-27 10:20:23 +00:00
|
|
|
//add the border corners, then the borders and fix their byte offsets
|
|
|
|
int TilesHandledCount = tmpTiles.size();
|
2018-01-16 08:35:28 +00:00
|
|
|
Visuals.m_BorderTopLeft.AddIndexBufferByteOffset(TilesHandledCount*6*sizeof(unsigned int));
|
|
|
|
Visuals.m_BorderTopRight.AddIndexBufferByteOffset(TilesHandledCount*6*sizeof(unsigned int));
|
|
|
|
Visuals.m_BorderBottomLeft.AddIndexBufferByteOffset(TilesHandledCount*6*sizeof(unsigned int));
|
|
|
|
Visuals.m_BorderBottomRight.AddIndexBufferByteOffset(TilesHandledCount*6*sizeof(unsigned int));
|
2017-09-27 10:20:23 +00:00
|
|
|
//add the Corners to the tiles
|
|
|
|
tmpTiles.insert(tmpTiles.end(), tmpBorderCorners.begin(), tmpBorderCorners.end());
|
|
|
|
tmpTileTexCoords.insert(tmpTileTexCoords.end(), tmpBorderCornersTexCoords.begin(), tmpBorderCornersTexCoords.end());
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2017-09-27 10:20:23 +00:00
|
|
|
//now the borders
|
|
|
|
TilesHandledCount = tmpTiles.size();
|
|
|
|
if(pTMap->m_Width > 2)
|
2017-09-13 18:33:58 +00:00
|
|
|
{
|
2017-09-27 10:20:23 +00:00
|
|
|
for(int i = 0; i < pTMap->m_Width-2; ++i)
|
2017-09-13 18:33:58 +00:00
|
|
|
{
|
2018-01-16 08:35:28 +00:00
|
|
|
Visuals.m_BorderTop[i].AddIndexBufferByteOffset(TilesHandledCount * 6 * sizeof(unsigned int));
|
2017-09-12 18:22:18 +00:00
|
|
|
}
|
|
|
|
}
|
2017-09-27 10:20:23 +00:00
|
|
|
tmpTiles.insert(tmpTiles.end(), tmpBorderTopTiles.begin(), tmpBorderTopTiles.end());
|
|
|
|
tmpTileTexCoords.insert(tmpTileTexCoords.end(), tmpBorderTopTilesTexCoords.begin(), tmpBorderTopTilesTexCoords.end());
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2017-09-27 10:20:23 +00:00
|
|
|
TilesHandledCount = tmpTiles.size();
|
|
|
|
if(pTMap->m_Width > 2)
|
2017-09-13 18:33:58 +00:00
|
|
|
{
|
2017-09-27 10:20:23 +00:00
|
|
|
for(int i = 0; i < pTMap->m_Width-2; ++i)
|
|
|
|
{
|
2018-01-16 08:35:28 +00:00
|
|
|
Visuals.m_BorderBottom[i].AddIndexBufferByteOffset(TilesHandledCount * 6 * sizeof(unsigned int));
|
2017-09-27 10:20:23 +00:00
|
|
|
}
|
2017-09-12 18:22:18 +00:00
|
|
|
}
|
2017-09-27 10:20:23 +00:00
|
|
|
tmpTiles.insert(tmpTiles.end(), tmpBorderBottomTiles.begin(), tmpBorderBottomTiles.end());
|
|
|
|
tmpTileTexCoords.insert(tmpTileTexCoords.end(), tmpBorderBottomTilesTexCoords.begin(), tmpBorderBottomTilesTexCoords.end());
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2017-09-27 10:20:23 +00:00
|
|
|
TilesHandledCount = tmpTiles.size();
|
|
|
|
if(pTMap->m_Height > 2)
|
2017-09-13 18:33:58 +00:00
|
|
|
{
|
2017-09-27 10:20:23 +00:00
|
|
|
for(int i = 0; i < pTMap->m_Height-2; ++i)
|
|
|
|
{
|
2018-01-16 08:35:28 +00:00
|
|
|
Visuals.m_BorderLeft[i].AddIndexBufferByteOffset(TilesHandledCount * 6 * sizeof(unsigned int));
|
2017-09-27 10:20:23 +00:00
|
|
|
}
|
2017-09-12 18:22:18 +00:00
|
|
|
}
|
2017-09-27 10:20:23 +00:00
|
|
|
tmpTiles.insert(tmpTiles.end(), tmpBorderLeftTiles.begin(), tmpBorderLeftTiles.end());
|
|
|
|
tmpTileTexCoords.insert(tmpTileTexCoords.end(), tmpBorderLeftTilesTexCoords.begin(), tmpBorderLeftTilesTexCoords.end());
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2017-09-27 10:20:23 +00:00
|
|
|
TilesHandledCount = tmpTiles.size();
|
|
|
|
if(pTMap->m_Height > 2)
|
2017-09-13 18:33:58 +00:00
|
|
|
{
|
2017-09-27 10:20:23 +00:00
|
|
|
for(int i = 0; i < pTMap->m_Height-2; ++i)
|
|
|
|
{
|
2018-01-16 08:35:28 +00:00
|
|
|
Visuals.m_BorderRight[i].AddIndexBufferByteOffset(TilesHandledCount * 6 * sizeof(unsigned int));
|
2017-09-27 10:20:23 +00:00
|
|
|
}
|
2017-09-12 18:22:18 +00:00
|
|
|
}
|
2017-09-27 10:20:23 +00:00
|
|
|
tmpTiles.insert(tmpTiles.end(), tmpBorderRightTiles.begin(), tmpBorderRightTiles.end());
|
|
|
|
tmpTileTexCoords.insert(tmpTileTexCoords.end(), tmpBorderRightTilesTexCoords.begin(), tmpBorderRightTilesTexCoords.end());
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2017-09-12 18:22:18 +00:00
|
|
|
//setup params
|
|
|
|
float* pTmpTiles = (tmpTiles.size() == 0) ? NULL : (float*)&tmpTiles[0];
|
|
|
|
unsigned char* pTmpTileTexCoords = (tmpTileTexCoords.size() == 0) ? NULL : (unsigned char*)&tmpTileTexCoords[0];
|
2018-03-13 20:57:46 +00:00
|
|
|
|
|
|
|
size_t UploadDataSize = tmpTileTexCoords.size() * sizeof(STmpTileTexCoord) + tmpTiles.size() * sizeof(STmpTile);
|
|
|
|
char* pUploadData = new char[UploadDataSize];
|
|
|
|
|
|
|
|
mem_copy_special(pUploadData, pTmpTiles, sizeof(vec2), tmpTiles.size() * 4, (DoTextureCoords ? (sizeof(unsigned char) * 2 * 2) : 0));
|
|
|
|
if(DoTextureCoords)
|
|
|
|
{
|
|
|
|
mem_copy_special(pUploadData + sizeof(vec2), pTmpTileTexCoords, sizeof(unsigned char) * 2 * 2, tmpTiles.size() * 4, (DoTextureCoords ? (sizeof(vec2)) : 0));
|
|
|
|
}
|
|
|
|
|
|
|
|
// first create the buffer object
|
|
|
|
int BufferObjectIndex = Graphics()->CreateBufferObject(UploadDataSize, pUploadData);
|
|
|
|
delete[] pUploadData;
|
|
|
|
|
|
|
|
// then create the buffer container
|
|
|
|
SBufferContainerInfo ContainerInfo;
|
|
|
|
ContainerInfo.m_Stride = (DoTextureCoords ? (sizeof(float) * 2 + sizeof(unsigned char) * 2 * 2) : 0);
|
|
|
|
ContainerInfo.m_Attributes.push_back(SBufferContainerInfo::SAttribute());
|
|
|
|
SBufferContainerInfo::SAttribute* pAttr = &ContainerInfo.m_Attributes.back();
|
|
|
|
pAttr->m_DataTypeCount = 2;
|
|
|
|
pAttr->m_Type = GRAPHICS_TYPE_FLOAT;
|
|
|
|
pAttr->m_Normalized = false;
|
|
|
|
pAttr->m_pOffset = 0;
|
|
|
|
pAttr->m_FuncType = 0;
|
|
|
|
pAttr->m_VertBufferBindingIndex = BufferObjectIndex;
|
|
|
|
if(DoTextureCoords)
|
|
|
|
{
|
|
|
|
ContainerInfo.m_Attributes.push_back(SBufferContainerInfo::SAttribute());
|
|
|
|
pAttr = &ContainerInfo.m_Attributes.back();
|
|
|
|
pAttr->m_DataTypeCount = 2;
|
|
|
|
pAttr->m_Type = GRAPHICS_TYPE_UNSIGNED_BYTE;
|
|
|
|
pAttr->m_Normalized = false;
|
|
|
|
pAttr->m_pOffset = (void*)(sizeof(vec2));
|
|
|
|
pAttr->m_FuncType = 0;
|
|
|
|
pAttr->m_VertBufferBindingIndex = BufferObjectIndex;
|
|
|
|
|
|
|
|
ContainerInfo.m_Attributes.push_back(SBufferContainerInfo::SAttribute());
|
|
|
|
pAttr = &ContainerInfo.m_Attributes.back();
|
|
|
|
pAttr->m_DataTypeCount = 2;
|
|
|
|
pAttr->m_Type = GRAPHICS_TYPE_UNSIGNED_BYTE;
|
|
|
|
pAttr->m_Normalized = false;
|
|
|
|
pAttr->m_pOffset = (void*)(sizeof(vec2) + sizeof(unsigned char) * 2);
|
|
|
|
pAttr->m_FuncType = 1;
|
|
|
|
pAttr->m_VertBufferBindingIndex = BufferObjectIndex;
|
|
|
|
}
|
|
|
|
|
|
|
|
Visuals.m_BufferContainerIndex = Graphics()->CreateBufferContainer(&ContainerInfo);
|
|
|
|
// and finally inform the backend how many indices are required
|
|
|
|
Graphics()->IndicesNumRequiredNotify(tmpTiles.size() * 6);
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2017-09-12 18:22:18 +00:00
|
|
|
++CurOverlay;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2018-03-13 20:57:46 +00:00
|
|
|
else if(pLayer->m_Type == LAYERTYPE_QUADS)
|
|
|
|
{
|
|
|
|
CMapItemLayerQuads *pQLayer = (CMapItemLayerQuads *)pLayer;
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2018-03-13 20:57:46 +00:00
|
|
|
m_QuadLayerVisuals.push_back(new SQuadLayerVisuals());
|
|
|
|
SQuadLayerVisuals* pQLayerVisuals = m_QuadLayerVisuals.back();
|
|
|
|
|
|
|
|
bool Textured = (pQLayer->m_Image == -1 ? false : true);
|
|
|
|
|
|
|
|
tmpQuads.clear();
|
|
|
|
tmpQuadsTextured.clear();
|
|
|
|
|
|
|
|
if(Textured)
|
|
|
|
tmpQuadsTextured.resize(pQLayer->m_NumQuads);
|
|
|
|
else
|
|
|
|
tmpQuads.resize(pQLayer->m_NumQuads);
|
|
|
|
|
|
|
|
CQuad *pQuads = (CQuad *)m_pLayers->Map()->GetDataSwapped(pQLayer->m_Data);
|
|
|
|
for(int i = 0; i < pQLayer->m_NumQuads; ++i)
|
|
|
|
{
|
|
|
|
CQuad *q = &pQuads[i];
|
|
|
|
for(int j = 0; j < 4; ++j)
|
|
|
|
{
|
|
|
|
int QuadIDX = j;
|
|
|
|
if(j == 2)
|
|
|
|
QuadIDX = 3;
|
|
|
|
else if(j == 3)
|
|
|
|
QuadIDX = 2;
|
|
|
|
if(!Textured)
|
|
|
|
{
|
2018-07-10 09:29:02 +00:00
|
|
|
// ignore the conversion for the position coordinates
|
2018-03-13 20:57:46 +00:00
|
|
|
tmpQuads[i].m_aVertices[j].m_X = (q->m_aPoints[QuadIDX].x);
|
|
|
|
tmpQuads[i].m_aVertices[j].m_Y = (q->m_aPoints[QuadIDX].y);
|
|
|
|
tmpQuads[i].m_aVertices[j].m_CenterX = (q->m_aPoints[4].x);
|
|
|
|
tmpQuads[i].m_aVertices[j].m_CenterY = (q->m_aPoints[4].y);
|
|
|
|
tmpQuads[i].m_aVertices[j].m_R = (unsigned char)q->m_aColors[QuadIDX].r;
|
|
|
|
tmpQuads[i].m_aVertices[j].m_G = (unsigned char)q->m_aColors[QuadIDX].g;
|
|
|
|
tmpQuads[i].m_aVertices[j].m_B = (unsigned char)q->m_aColors[QuadIDX].b;
|
|
|
|
tmpQuads[i].m_aVertices[j].m_A = (unsigned char)q->m_aColors[QuadIDX].a;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2018-07-10 09:29:02 +00:00
|
|
|
// ignore the conversion for the position coordinates
|
2018-03-13 20:57:46 +00:00
|
|
|
tmpQuadsTextured[i].m_aVertices[j].m_X = (q->m_aPoints[QuadIDX].x);
|
|
|
|
tmpQuadsTextured[i].m_aVertices[j].m_Y = (q->m_aPoints[QuadIDX].y);
|
|
|
|
tmpQuadsTextured[i].m_aVertices[j].m_CenterX = (q->m_aPoints[4].x);
|
|
|
|
tmpQuadsTextured[i].m_aVertices[j].m_CenterY = (q->m_aPoints[4].y);
|
|
|
|
tmpQuadsTextured[i].m_aVertices[j].m_U = fx2f(q->m_aTexcoords[QuadIDX].x);
|
|
|
|
tmpQuadsTextured[i].m_aVertices[j].m_V = fx2f(q->m_aTexcoords[QuadIDX].y);
|
|
|
|
tmpQuadsTextured[i].m_aVertices[j].m_R = (unsigned char)q->m_aColors[QuadIDX].r;
|
|
|
|
tmpQuadsTextured[i].m_aVertices[j].m_G = (unsigned char)q->m_aColors[QuadIDX].g;
|
|
|
|
tmpQuadsTextured[i].m_aVertices[j].m_B = (unsigned char)q->m_aColors[QuadIDX].b;
|
|
|
|
tmpQuadsTextured[i].m_aVertices[j].m_A = (unsigned char)q->m_aColors[QuadIDX].a;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
size_t UploadDataSize = 0;
|
|
|
|
if(Textured)
|
|
|
|
UploadDataSize = tmpQuadsTextured.size() * sizeof(STmpQuadTextured);
|
|
|
|
else
|
|
|
|
UploadDataSize = tmpQuads.size() * sizeof(STmpQuad);
|
|
|
|
|
|
|
|
if(UploadDataSize > 0) {
|
|
|
|
void* pUploadData = NULL;
|
|
|
|
if(Textured)
|
|
|
|
pUploadData = &tmpQuadsTextured[0];
|
|
|
|
else
|
|
|
|
pUploadData = &tmpQuads[0];
|
|
|
|
// create the buffer object
|
|
|
|
int BufferObjectIndex = Graphics()->CreateBufferObject(UploadDataSize, pUploadData);
|
|
|
|
// then create the buffer container
|
|
|
|
SBufferContainerInfo ContainerInfo;
|
|
|
|
ContainerInfo.m_Stride = (Textured ? (sizeof(STmpQuadTextured) / 4) : (sizeof(STmpQuad) / 4));
|
|
|
|
ContainerInfo.m_Attributes.push_back(SBufferContainerInfo::SAttribute());
|
|
|
|
SBufferContainerInfo::SAttribute* pAttr = &ContainerInfo.m_Attributes.back();
|
|
|
|
pAttr->m_DataTypeCount = 4;
|
|
|
|
pAttr->m_Type = GRAPHICS_TYPE_FLOAT;
|
|
|
|
pAttr->m_Normalized = false;
|
|
|
|
pAttr->m_pOffset = 0;
|
|
|
|
pAttr->m_FuncType = 0;
|
|
|
|
pAttr->m_VertBufferBindingIndex = BufferObjectIndex;
|
|
|
|
if(Textured)
|
|
|
|
{
|
|
|
|
ContainerInfo.m_Attributes.push_back(SBufferContainerInfo::SAttribute());
|
|
|
|
pAttr = &ContainerInfo.m_Attributes.back();
|
|
|
|
pAttr->m_DataTypeCount = 2;
|
|
|
|
pAttr->m_Type = GRAPHICS_TYPE_FLOAT;
|
|
|
|
pAttr->m_Normalized = false;
|
|
|
|
pAttr->m_pOffset = (void*)(sizeof(float) * 4);
|
|
|
|
pAttr->m_FuncType = 0;
|
|
|
|
pAttr->m_VertBufferBindingIndex = BufferObjectIndex;
|
|
|
|
}
|
|
|
|
ContainerInfo.m_Attributes.push_back(SBufferContainerInfo::SAttribute());
|
|
|
|
pAttr = &ContainerInfo.m_Attributes.back();
|
|
|
|
pAttr->m_DataTypeCount = 4;
|
|
|
|
pAttr->m_Type = GRAPHICS_TYPE_UNSIGNED_BYTE;
|
|
|
|
pAttr->m_Normalized = true;
|
|
|
|
pAttr->m_pOffset = (void*)(sizeof(float) * 4 + (Textured ? (sizeof(float) * 2) : 0));
|
|
|
|
pAttr->m_FuncType = 0;
|
|
|
|
pAttr->m_VertBufferBindingIndex = BufferObjectIndex;
|
|
|
|
|
|
|
|
pQLayerVisuals->m_BufferContainerIndex = Graphics()->CreateBufferContainer(&ContainerInfo);
|
|
|
|
// and finally inform the backend how many indices are required
|
|
|
|
Graphics()->IndicesNumRequiredNotify(pQLayer->m_NumQuads * 6);
|
|
|
|
}
|
|
|
|
}
|
2017-09-12 18:22:18 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-04-26 22:11:15 +00:00
|
|
|
void CMapLayers::RenderTileLayer(int LayerIndex, ColorRGBA* pColor, CMapItemLayerTilemap* pTileLayer, CMapItemGroup* pGroup)
|
2017-09-13 18:33:58 +00:00
|
|
|
{
|
2017-09-27 10:20:23 +00:00
|
|
|
STileLayerVisuals& Visuals = *m_TileLayerVisuals[LayerIndex];
|
2018-03-13 20:57:46 +00:00
|
|
|
if(Visuals.m_BufferContainerIndex == -1)
|
|
|
|
return; //no visuals were created
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2017-09-12 18:22:18 +00:00
|
|
|
float ScreenX0, ScreenY0, ScreenX1, ScreenY1;
|
|
|
|
Graphics()->GetScreen(&ScreenX0, &ScreenY0, &ScreenX1, &ScreenY1);
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2017-09-12 18:22:18 +00:00
|
|
|
float r=1, g=1, b=1, a=1;
|
|
|
|
if(pTileLayer->m_ColorEnv >= 0)
|
|
|
|
{
|
|
|
|
float aChannels[4];
|
|
|
|
EnvelopeEval(pTileLayer->m_ColorEnvOffset/1000.0f, pTileLayer->m_ColorEnv, aChannels, this);
|
|
|
|
r = aChannels[0];
|
|
|
|
g = aChannels[1];
|
|
|
|
b = aChannels[2];
|
|
|
|
a = aChannels[3];
|
|
|
|
}
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2017-09-12 18:22:18 +00:00
|
|
|
int BorderX0, BorderY0, BorderX1, BorderY1;
|
|
|
|
bool DrawBorder = false;
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2018-08-02 16:26:12 +00:00
|
|
|
int Y0 = BorderY0 = (int)floorf((ScreenY0)/32);
|
|
|
|
int X0 = BorderX0 = (int)floorf((ScreenX0)/32);
|
|
|
|
int Y1 = BorderY1 = (int)floorf((ScreenY1)/32);
|
|
|
|
int X1 = BorderX1 = (int)floorf((ScreenX1)/32);
|
2019-03-26 18:15:24 +00:00
|
|
|
|
|
|
|
if(X0 <= 0)
|
2017-09-13 18:33:58 +00:00
|
|
|
{
|
2017-09-12 18:22:18 +00:00
|
|
|
X0 = 0;
|
|
|
|
DrawBorder = true;
|
|
|
|
}
|
2018-08-02 16:26:12 +00:00
|
|
|
if(Y0 <= 0)
|
2017-09-13 18:33:58 +00:00
|
|
|
{
|
2017-09-12 18:22:18 +00:00
|
|
|
Y0 = 0;
|
|
|
|
DrawBorder = true;
|
|
|
|
}
|
2018-08-02 16:26:12 +00:00
|
|
|
if(X1 >= pTileLayer->m_Width - 1)
|
2017-09-13 18:33:58 +00:00
|
|
|
{
|
2017-09-12 18:22:18 +00:00
|
|
|
X1 = pTileLayer->m_Width - 1;
|
|
|
|
DrawBorder = true;
|
|
|
|
}
|
2018-08-02 16:26:12 +00:00
|
|
|
if(Y1 >= pTileLayer->m_Height - 1)
|
2017-09-13 18:33:58 +00:00
|
|
|
{
|
2017-09-12 18:22:18 +00:00
|
|
|
Y1 = pTileLayer->m_Height - 1;
|
|
|
|
DrawBorder = true;
|
|
|
|
}
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2017-09-12 21:16:01 +00:00
|
|
|
bool DrawLayer = true;
|
2018-03-13 20:57:46 +00:00
|
|
|
if(X1 < 0)
|
|
|
|
DrawLayer = false;
|
|
|
|
if(Y1 < 0)
|
|
|
|
DrawLayer = false;
|
|
|
|
if(X0 >= pTileLayer->m_Width)
|
|
|
|
DrawLayer = false;
|
|
|
|
if(Y0 >= pTileLayer->m_Height)
|
|
|
|
DrawLayer = false;
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2017-09-13 18:33:58 +00:00
|
|
|
if(DrawLayer)
|
|
|
|
{
|
2017-09-12 21:16:01 +00:00
|
|
|
//create the indice buffers we want to draw -- reuse them
|
2017-09-27 12:52:06 +00:00
|
|
|
static std::vector<char*> s_IndexOffsets;
|
|
|
|
static std::vector<unsigned int> s_DrawCounts;
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2017-09-27 12:52:06 +00:00
|
|
|
s_IndexOffsets.clear();
|
|
|
|
s_DrawCounts.clear();
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2017-09-27 10:20:23 +00:00
|
|
|
unsigned long long Reserve = absolute(Y1 - Y0) + 1;
|
2017-09-27 12:52:06 +00:00
|
|
|
s_IndexOffsets.reserve(Reserve);
|
|
|
|
s_DrawCounts.reserve(Reserve);
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2017-09-27 10:20:23 +00:00
|
|
|
for(int y = Y0; y <= Y1; ++y)
|
2017-09-13 18:33:58 +00:00
|
|
|
{
|
2019-03-26 18:15:24 +00:00
|
|
|
if(X0 > X1)
|
2018-01-16 08:35:28 +00:00
|
|
|
continue;
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2018-01-16 08:35:28 +00:00
|
|
|
dbg_assert(Visuals.m_TilesOfLayer[y*pTileLayer->m_Width + X1].IndexBufferByteOffset() >= Visuals.m_TilesOfLayer[y*pTileLayer->m_Width + X0].IndexBufferByteOffset(), "Tile count wrong.");
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2018-01-16 08:35:28 +00:00
|
|
|
unsigned int NumVertices = ((Visuals.m_TilesOfLayer[y*pTileLayer->m_Width + X1].IndexBufferByteOffset() - Visuals.m_TilesOfLayer[y*pTileLayer->m_Width + X0].IndexBufferByteOffset()) / sizeof(unsigned int)) + (Visuals.m_TilesOfLayer[y*pTileLayer->m_Width + X1].DoDraw() ? 6lu : 0lu);
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2017-09-27 12:52:06 +00:00
|
|
|
if(NumVertices)
|
|
|
|
{
|
2018-01-16 08:35:28 +00:00
|
|
|
s_IndexOffsets.push_back((offset_ptr_size)Visuals.m_TilesOfLayer[y*pTileLayer->m_Width + X0].IndexBufferByteOffset());
|
2017-09-27 12:52:06 +00:00
|
|
|
s_DrawCounts.push_back(NumVertices);
|
2017-09-12 21:16:01 +00:00
|
|
|
}
|
2017-09-12 18:22:18 +00:00
|
|
|
}
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2017-09-12 21:16:01 +00:00
|
|
|
pColor->x *= r;
|
|
|
|
pColor->y *= g;
|
|
|
|
pColor->z *= b;
|
|
|
|
pColor->w *= a;
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2017-09-27 12:52:06 +00:00
|
|
|
int DrawCount = s_IndexOffsets.size();
|
|
|
|
if(DrawCount != 0)
|
|
|
|
{
|
2018-03-13 20:57:46 +00:00
|
|
|
Graphics()->RenderTileLayer(Visuals.m_BufferContainerIndex, (float*)pColor, &s_IndexOffsets[0], &s_DrawCounts[0], DrawCount);
|
2017-09-27 10:20:23 +00:00
|
|
|
}
|
2017-09-12 18:22:18 +00:00
|
|
|
}
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2018-08-02 16:26:12 +00:00
|
|
|
if(DrawBorder)
|
|
|
|
RenderTileBorder(LayerIndex, pColor, pTileLayer, pGroup, BorderX0, BorderY0, BorderX1, BorderY1, (int)(-floorf((-ScreenX1) / 32.f)) - BorderX0, (int)(-floorf((-ScreenY1) / 32.f)) - BorderY0);
|
2017-09-12 18:22:18 +00:00
|
|
|
}
|
|
|
|
|
2018-10-29 21:09:11 +00:00
|
|
|
void CMapLayers::RenderTileBorderCornerTiles(int WidthOffsetToOrigin, int HeightOffsetToOrigin, int TileCountWidth, int TileCountHeight, int BufferContainerIndex, float* pColor, offset_ptr_size IndexBufferOffset, float* pOffset, float* pDir)
|
|
|
|
{
|
|
|
|
// if border is still in range of the original corner, it doesn't needs to be redrawn
|
|
|
|
bool CornerVisible = (WidthOffsetToOrigin - 1 < TileCountWidth) && (HeightOffsetToOrigin - 1 < TileCountHeight);
|
2018-10-29 07:44:55 +00:00
|
|
|
|
2019-04-26 19:36:49 +00:00
|
|
|
int CountX = minimum(WidthOffsetToOrigin, TileCountWidth);
|
|
|
|
int CountY = minimum(HeightOffsetToOrigin, TileCountHeight);
|
2018-10-29 07:44:55 +00:00
|
|
|
|
2018-10-29 21:09:11 +00:00
|
|
|
int Count = (CountX * CountY) - (CornerVisible ? 1 : 0); // Don't draw the corner again
|
2018-10-29 07:44:55 +00:00
|
|
|
|
2018-10-29 21:09:11 +00:00
|
|
|
Graphics()->RenderBorderTiles(BufferContainerIndex, pColor, IndexBufferOffset, pOffset, pDir, CountX, Count);
|
2018-10-29 07:44:55 +00:00
|
|
|
}
|
|
|
|
|
2019-04-26 22:11:15 +00:00
|
|
|
void CMapLayers::RenderTileBorder(int LayerIndex, ColorRGBA* pColor, CMapItemLayerTilemap* pTileLayer, CMapItemGroup* pGroup, int BorderX0, int BorderY0, int BorderX1, int BorderY1, int ScreenWidthTileCount, int ScreenHeightTileCount)
|
2017-09-13 18:33:58 +00:00
|
|
|
{
|
2017-09-27 10:20:23 +00:00
|
|
|
STileLayerVisuals& Visuals = *m_TileLayerVisuals[LayerIndex];
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2017-09-12 18:22:18 +00:00
|
|
|
int Y0 = BorderY0;
|
|
|
|
int X0 = BorderX0;
|
|
|
|
int Y1 = BorderY1;
|
|
|
|
int X1 = BorderX1;
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2018-08-02 16:26:12 +00:00
|
|
|
int CountWidth = ScreenWidthTileCount;
|
|
|
|
int CountHeight = ScreenHeightTileCount;
|
|
|
|
|
2018-03-13 20:57:46 +00:00
|
|
|
if(X0 < 1)
|
|
|
|
X0 = 1;
|
|
|
|
if(Y0 < 1)
|
|
|
|
Y0 = 1;
|
|
|
|
if(X1 >= pTileLayer->m_Width - 1)
|
|
|
|
X1 = pTileLayer->m_Width - 2;
|
|
|
|
if(Y1 >= pTileLayer->m_Height - 1)
|
|
|
|
Y1 = pTileLayer->m_Height - 2;
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2018-08-02 16:26:12 +00:00
|
|
|
if(BorderX0 <= 0)
|
2017-09-13 18:33:58 +00:00
|
|
|
{
|
2018-02-04 15:00:47 +00:00
|
|
|
// Draw corners on left side
|
2018-08-02 16:26:12 +00:00
|
|
|
if(BorderY0 <= 0)
|
2017-09-13 18:33:58 +00:00
|
|
|
{
|
2018-01-16 08:35:28 +00:00
|
|
|
if(Visuals.m_BorderTopLeft.DoDraw())
|
2017-09-13 18:33:58 +00:00
|
|
|
{
|
2017-09-12 18:22:18 +00:00
|
|
|
vec2 Offset;
|
|
|
|
Offset.x = BorderX0 * 32.f;
|
|
|
|
Offset.y = BorderY0 * 32.f;
|
|
|
|
vec2 Dir;
|
|
|
|
Dir.x = 32.f;
|
|
|
|
Dir.y = 32.f;
|
|
|
|
|
2018-10-29 07:44:55 +00:00
|
|
|
RenderTileBorderCornerTiles(absolute(BorderX0) + 1, absolute(BorderY0) + 1, CountWidth, CountHeight, Visuals.m_BufferContainerIndex, (float*)pColor, (offset_ptr_size)Visuals.m_BorderTopLeft.IndexBufferByteOffset(), (float*)&Offset, (float*)&Dir);
|
2017-09-12 18:22:18 +00:00
|
|
|
}
|
|
|
|
}
|
2018-08-02 16:26:12 +00:00
|
|
|
if(BorderY1 >= pTileLayer->m_Height - 1)
|
2017-09-13 18:33:58 +00:00
|
|
|
{
|
2018-01-16 08:35:28 +00:00
|
|
|
if(Visuals.m_BorderBottomLeft.DoDraw())
|
2017-09-13 18:33:58 +00:00
|
|
|
{
|
2017-09-12 18:22:18 +00:00
|
|
|
vec2 Offset;
|
|
|
|
Offset.x = BorderX0 * 32.f;
|
2018-08-02 16:26:12 +00:00
|
|
|
Offset.y = (BorderY1 - (pTileLayer->m_Height - 1)) * 32.f;
|
2017-09-12 18:22:18 +00:00
|
|
|
vec2 Dir;
|
|
|
|
Dir.x = 32.f;
|
|
|
|
Dir.y = -32.f;
|
|
|
|
|
2018-10-29 07:44:55 +00:00
|
|
|
RenderTileBorderCornerTiles(absolute(BorderX0) + 1, (BorderY1 - (pTileLayer->m_Height - 1)) + 1, CountWidth, CountHeight, Visuals.m_BufferContainerIndex, (float*)pColor, (offset_ptr_size)Visuals.m_BorderBottomLeft.IndexBufferByteOffset(), (float*)&Offset, (float*)&Dir);
|
2017-09-12 18:22:18 +00:00
|
|
|
}
|
|
|
|
}
|
2018-08-02 16:26:12 +00:00
|
|
|
}
|
|
|
|
if(BorderX0 < 0)
|
|
|
|
{
|
2018-02-04 15:00:47 +00:00
|
|
|
// Draw left border
|
2017-09-13 18:33:58 +00:00
|
|
|
if(Y0 < pTileLayer->m_Height - 1 && Y1 > 0)
|
|
|
|
{
|
2018-08-02 16:26:12 +00:00
|
|
|
unsigned int DrawNum = ((Visuals.m_BorderLeft[Y1 - 1].IndexBufferByteOffset() - Visuals.m_BorderLeft[Y0 - 1].IndexBufferByteOffset()) / sizeof(unsigned int)) + (Visuals.m_BorderLeft[Y1 - 1].DoDraw() ? 6lu : 0lu);
|
2018-01-16 08:35:28 +00:00
|
|
|
offset_ptr_size pOffset = (offset_ptr_size)Visuals.m_BorderLeft[Y0-1].IndexBufferByteOffset();
|
2018-08-02 16:26:12 +00:00
|
|
|
vec2 Offset;
|
|
|
|
Offset.x = 32.f * BorderX0;
|
|
|
|
Offset.y = 0.f;
|
2017-09-12 18:22:18 +00:00
|
|
|
vec2 Dir;
|
2018-08-02 16:26:12 +00:00
|
|
|
Dir.x = 32.f;
|
2017-09-12 18:22:18 +00:00
|
|
|
Dir.y = 0.f;
|
2019-04-26 19:36:49 +00:00
|
|
|
Graphics()->RenderBorderTileLines(Visuals.m_BufferContainerIndex, (float*)pColor, pOffset, (float*)&Offset, (float*)&Dir, DrawNum, minimum(absolute(BorderX0), CountWidth));
|
2017-09-12 18:22:18 +00:00
|
|
|
}
|
|
|
|
}
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2018-08-02 16:26:12 +00:00
|
|
|
if(BorderX1 >= pTileLayer->m_Width - 1)
|
2017-09-13 18:33:58 +00:00
|
|
|
{
|
2018-02-04 15:00:47 +00:00
|
|
|
// Draw corners on right side
|
2018-08-02 16:26:12 +00:00
|
|
|
if(BorderY0 <= 0)
|
2017-09-13 18:33:58 +00:00
|
|
|
{
|
2018-01-16 08:35:28 +00:00
|
|
|
if(Visuals.m_BorderTopRight.DoDraw())
|
2017-09-13 18:33:58 +00:00
|
|
|
{
|
2017-09-12 18:22:18 +00:00
|
|
|
vec2 Offset;
|
2018-08-02 16:26:12 +00:00
|
|
|
Offset.x = (BorderX1 - (pTileLayer->m_Width - 1)) * 32.f;
|
2017-09-12 18:22:18 +00:00
|
|
|
Offset.y = BorderY0 * 32.f;
|
|
|
|
vec2 Dir;
|
|
|
|
Dir.x = -32.f;
|
|
|
|
Dir.y = 32.f;
|
|
|
|
|
2018-10-29 07:44:55 +00:00
|
|
|
RenderTileBorderCornerTiles((BorderX1 - (pTileLayer->m_Width - 1)) + 1, absolute(BorderY0) + 1, CountWidth, CountHeight, Visuals.m_BufferContainerIndex, (float*)pColor, (offset_ptr_size)Visuals.m_BorderTopRight.IndexBufferByteOffset(), (float*)&Offset, (float*)&Dir);
|
2017-09-12 18:22:18 +00:00
|
|
|
}
|
|
|
|
}
|
2018-08-02 16:26:12 +00:00
|
|
|
if(BorderY1 >= pTileLayer->m_Height - 1)
|
2017-09-13 18:33:58 +00:00
|
|
|
{
|
2018-01-16 08:35:28 +00:00
|
|
|
if(Visuals.m_BorderBottomRight.DoDraw())
|
2017-09-13 18:33:58 +00:00
|
|
|
{
|
2017-09-12 18:22:18 +00:00
|
|
|
vec2 Offset;
|
2018-08-02 16:26:12 +00:00
|
|
|
Offset.x = (BorderX1 - (pTileLayer->m_Width - 1)) * 32.f;
|
|
|
|
Offset.y = (BorderY1 - (pTileLayer->m_Height - 1)) * 32.f;
|
2017-09-12 18:22:18 +00:00
|
|
|
vec2 Dir;
|
|
|
|
Dir.x = -32.f;
|
|
|
|
Dir.y = -32.f;
|
|
|
|
|
2018-10-29 07:44:55 +00:00
|
|
|
RenderTileBorderCornerTiles((BorderX1 - (pTileLayer->m_Width - 1)) + 1, (BorderY1 - (pTileLayer->m_Height - 1)) + 1, CountWidth, CountHeight, Visuals.m_BufferContainerIndex, (float*)pColor, (offset_ptr_size)Visuals.m_BorderBottomRight.IndexBufferByteOffset(), (float*)&Offset, (float*)&Dir);
|
2017-09-12 18:22:18 +00:00
|
|
|
}
|
2018-08-02 16:26:12 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if(BorderX1 > pTileLayer->m_Width - 1)
|
|
|
|
{
|
2018-02-04 15:00:47 +00:00
|
|
|
// Draw right border
|
2017-09-13 18:33:58 +00:00
|
|
|
if(Y0 < pTileLayer->m_Height - 1 && Y1 > 0)
|
|
|
|
{
|
2018-08-02 16:26:12 +00:00
|
|
|
unsigned int DrawNum = ((Visuals.m_BorderRight[Y1 - 1].IndexBufferByteOffset() - Visuals.m_BorderRight[Y0 - 1].IndexBufferByteOffset()) / sizeof(unsigned int)) + (Visuals.m_BorderRight[Y1 - 1].DoDraw() ? 6lu : 0lu);
|
2018-01-16 08:35:28 +00:00
|
|
|
offset_ptr_size pOffset = (offset_ptr_size)Visuals.m_BorderRight[Y0-1].IndexBufferByteOffset();
|
2018-08-02 16:26:12 +00:00
|
|
|
vec2 Offset;
|
|
|
|
Offset.x = 32.f * (BorderX1 - (pTileLayer->m_Width - 1));
|
|
|
|
Offset.y = 0.f;
|
2017-09-12 18:22:18 +00:00
|
|
|
vec2 Dir;
|
2018-08-02 16:26:12 +00:00
|
|
|
Dir.x = -32.f;
|
2017-09-12 18:22:18 +00:00
|
|
|
Dir.y = 0.f;
|
2019-04-26 19:36:49 +00:00
|
|
|
Graphics()->RenderBorderTileLines(Visuals.m_BufferContainerIndex, (float*)pColor, pOffset, (float*)&Offset, (float*)&Dir, DrawNum, minimum((BorderX1 - (pTileLayer->m_Width - 1)), CountWidth));
|
2017-09-12 18:22:18 +00:00
|
|
|
}
|
|
|
|
}
|
2017-09-13 18:33:58 +00:00
|
|
|
if(BorderY0 < 0)
|
|
|
|
{
|
2018-02-04 15:00:47 +00:00
|
|
|
// Draw top border
|
2017-09-13 18:33:58 +00:00
|
|
|
if(X0 < pTileLayer->m_Width - 1 && X1 > 0)
|
2019-03-26 18:15:24 +00:00
|
|
|
{
|
2018-08-02 16:26:12 +00:00
|
|
|
unsigned int DrawNum = ((Visuals.m_BorderTop[X1 - 1].IndexBufferByteOffset() - Visuals.m_BorderTop[X0 - 1].IndexBufferByteOffset()) / sizeof(unsigned int)) + (Visuals.m_BorderTop[X1 - 1].DoDraw() ? 6lu : 0lu);
|
2018-01-16 08:35:28 +00:00
|
|
|
offset_ptr_size pOffset = (offset_ptr_size)Visuals.m_BorderTop[X0-1].IndexBufferByteOffset();
|
2018-08-02 16:26:12 +00:00
|
|
|
vec2 Offset;
|
|
|
|
Offset.x = 0.f;
|
|
|
|
Offset.y = 32.f * BorderY0;
|
2017-09-12 18:22:18 +00:00
|
|
|
vec2 Dir;
|
|
|
|
Dir.x = 0.f;
|
2018-08-02 16:26:12 +00:00
|
|
|
Dir.y = 32.f;
|
2019-04-26 19:36:49 +00:00
|
|
|
Graphics()->RenderBorderTileLines(Visuals.m_BufferContainerIndex, (float*)pColor, pOffset, (float*)&Offset, (float*)&Dir, DrawNum, minimum(absolute(BorderY0), CountHeight));
|
2017-09-12 18:22:18 +00:00
|
|
|
}
|
|
|
|
}
|
2017-09-13 18:33:58 +00:00
|
|
|
if(BorderY1 >= pTileLayer->m_Height)
|
|
|
|
{
|
2018-02-04 15:00:47 +00:00
|
|
|
// Draw bottom border
|
2017-09-13 18:33:58 +00:00
|
|
|
if(X0 < pTileLayer->m_Width - 1 && X1 > 0)
|
|
|
|
{
|
2018-08-02 16:26:12 +00:00
|
|
|
unsigned int DrawNum = ((Visuals.m_BorderBottom[X1 - 1].IndexBufferByteOffset() - Visuals.m_BorderBottom[X0 - 1].IndexBufferByteOffset()) / sizeof(unsigned int)) + (Visuals.m_BorderBottom[X1 - 1].DoDraw() ? 6lu : 0lu);
|
2018-01-16 08:35:28 +00:00
|
|
|
offset_ptr_size pOffset = (offset_ptr_size)Visuals.m_BorderBottom[X0-1].IndexBufferByteOffset();
|
2018-08-02 16:26:12 +00:00
|
|
|
vec2 Offset;
|
|
|
|
Offset.x = 0.f;
|
|
|
|
Offset.y = 32.f * (BorderY1 - (pTileLayer->m_Height - 1));
|
2017-09-12 18:22:18 +00:00
|
|
|
vec2 Dir;
|
|
|
|
Dir.x = 0.f;
|
2018-08-02 16:26:12 +00:00
|
|
|
Dir.y = -32.f;
|
2019-04-26 19:36:49 +00:00
|
|
|
Graphics()->RenderBorderTileLines(Visuals.m_BufferContainerIndex, (float*)pColor, pOffset, (float*)&Offset, (float*)&Dir, DrawNum, minimum((BorderY1 - (pTileLayer->m_Height - 1)), CountHeight));
|
2017-09-12 18:22:18 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-04-26 22:11:15 +00:00
|
|
|
void CMapLayers::RenderKillTileBorder(int LayerIndex, ColorRGBA* pColor, CMapItemLayerTilemap* pTileLayer, CMapItemGroup* pGroup)
|
2017-09-13 18:33:58 +00:00
|
|
|
{
|
2017-09-27 10:20:23 +00:00
|
|
|
STileLayerVisuals& Visuals = *m_TileLayerVisuals[LayerIndex];
|
2018-03-13 20:57:46 +00:00
|
|
|
if(Visuals.m_BufferContainerIndex == -1) return; //no visuals were created
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2017-09-12 18:22:18 +00:00
|
|
|
float ScreenX0, ScreenY0, ScreenX1, ScreenY1;
|
|
|
|
Graphics()->GetScreen(&ScreenX0, &ScreenY0, &ScreenX1, &ScreenY1);
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2017-09-12 18:22:18 +00:00
|
|
|
bool DrawBorder = false;
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2017-09-12 18:22:18 +00:00
|
|
|
int BorderY0 = (int)(ScreenY0/32)-1;
|
|
|
|
int BorderX0 = (int)(ScreenX0/32)-1;
|
|
|
|
int BorderY1 = (int)(ScreenY1/32)+1;
|
|
|
|
int BorderX1 = (int)(ScreenX1/32)+1;
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2018-03-13 20:57:46 +00:00
|
|
|
if(BorderX0 < -201)
|
|
|
|
DrawBorder = true;
|
|
|
|
if(BorderY0 < -201)
|
|
|
|
DrawBorder = true;
|
|
|
|
if(BorderX1 >= pTileLayer->m_Width + 201)
|
|
|
|
DrawBorder = true;
|
|
|
|
if(BorderY1 >= pTileLayer->m_Height + 201)
|
|
|
|
DrawBorder = true;
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2018-03-13 20:57:46 +00:00
|
|
|
if(!DrawBorder)
|
|
|
|
return;
|
|
|
|
if(!Visuals.m_BorderKillTile.DoDraw())
|
|
|
|
return;
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2018-03-13 20:57:46 +00:00
|
|
|
if(BorderX0 < -300)
|
|
|
|
BorderX0 = -300;
|
|
|
|
if(BorderY0 < -300)
|
|
|
|
BorderY0 = -300;
|
|
|
|
if(BorderX1 >= pTileLayer->m_Width + 300)
|
|
|
|
BorderX1 = pTileLayer->m_Width + 299;
|
|
|
|
if(BorderY1 >= pTileLayer->m_Height + 300)
|
2019-03-26 18:15:24 +00:00
|
|
|
BorderY1 = pTileLayer->m_Height + 299;
|
|
|
|
|
2018-03-13 20:57:46 +00:00
|
|
|
if(BorderX1 < -300)
|
|
|
|
BorderX1 = -300;
|
|
|
|
if(BorderY1 < -300)
|
|
|
|
BorderY1 = -300;
|
|
|
|
if(BorderX0 >= pTileLayer->m_Width + 300)
|
|
|
|
BorderX0 = pTileLayer->m_Width + 299;
|
|
|
|
if(BorderY0 >= pTileLayer->m_Height + 300)
|
2019-03-26 18:15:24 +00:00
|
|
|
BorderY0 = pTileLayer->m_Height + 299;
|
|
|
|
|
2018-02-04 15:00:47 +00:00
|
|
|
// Draw left kill tile border
|
2017-09-13 18:33:58 +00:00
|
|
|
if(BorderX0 < -201)
|
|
|
|
{
|
2017-09-12 18:22:18 +00:00
|
|
|
vec2 Offset;
|
|
|
|
Offset.x = BorderX0 * 32.f;
|
|
|
|
Offset.y = BorderY0 * 32.f;
|
|
|
|
vec2 Dir;
|
|
|
|
Dir.x = 32.f;
|
|
|
|
Dir.y = 32.f;
|
|
|
|
|
2017-09-27 10:20:23 +00:00
|
|
|
int Count = (absolute(BorderX0) - 201) * (BorderY1 - BorderY0);
|
2017-09-12 18:22:18 +00:00
|
|
|
|
2018-03-13 20:57:46 +00:00
|
|
|
Graphics()->RenderBorderTiles(Visuals.m_BufferContainerIndex, (float*)pColor, (offset_ptr_size)Visuals.m_BorderKillTile.IndexBufferByteOffset(), (float*)&Offset, (float*)&Dir, (absolute(BorderX0) - 201), Count);
|
2017-09-12 18:22:18 +00:00
|
|
|
}
|
2018-02-04 15:00:47 +00:00
|
|
|
// Draw top kill tile border
|
2017-09-13 18:33:58 +00:00
|
|
|
if(BorderY0 < -201)
|
|
|
|
{
|
2017-09-12 18:22:18 +00:00
|
|
|
vec2 Offset;
|
|
|
|
int OffX0 = (BorderX0 < -201 ? -201 : BorderX0);
|
|
|
|
int OffX1 = (BorderX1 >= pTileLayer->m_Width + 201 ? pTileLayer->m_Width + 201 : BorderX1);
|
|
|
|
Offset.x = OffX0 * 32.f;
|
|
|
|
Offset.y = BorderY0 * 32.f;
|
|
|
|
vec2 Dir;
|
|
|
|
Dir.x = 32.f;
|
|
|
|
Dir.y = 32.f;
|
|
|
|
|
2017-09-27 10:20:23 +00:00
|
|
|
int Count = (OffX1 - OffX0) * (absolute(BorderY0)-201);
|
2017-09-12 18:22:18 +00:00
|
|
|
|
2018-03-13 20:57:46 +00:00
|
|
|
Graphics()->RenderBorderTiles(Visuals.m_BufferContainerIndex, (float*)pColor, (offset_ptr_size)Visuals.m_BorderKillTile.IndexBufferByteOffset(), (float*)&Offset, (float*)&Dir, (OffX1 - OffX0), Count);
|
2017-09-12 18:22:18 +00:00
|
|
|
}
|
2017-09-13 18:33:58 +00:00
|
|
|
if(BorderX1 >= pTileLayer->m_Width + 201)
|
|
|
|
{
|
2017-09-12 18:22:18 +00:00
|
|
|
vec2 Offset;
|
|
|
|
Offset.x = (pTileLayer->m_Width + 201) * 32.f;
|
|
|
|
Offset.y = BorderY0 * 32.f;
|
|
|
|
vec2 Dir;
|
|
|
|
Dir.x = 32.f;
|
|
|
|
Dir.y = 32.f;
|
|
|
|
|
2017-09-27 10:20:23 +00:00
|
|
|
int Count = (BorderX1 - (pTileLayer->m_Width + 201)) * (BorderY1 - BorderY0);
|
2017-09-12 18:22:18 +00:00
|
|
|
|
2018-03-13 20:57:46 +00:00
|
|
|
Graphics()->RenderBorderTiles(Visuals.m_BufferContainerIndex, (float*)pColor, (offset_ptr_size)Visuals.m_BorderKillTile.IndexBufferByteOffset(), (float*)&Offset, (float*)&Dir, (BorderX1 - (pTileLayer->m_Width + 201)), Count);
|
2017-09-12 18:22:18 +00:00
|
|
|
}
|
2017-09-13 18:33:58 +00:00
|
|
|
if(BorderY1 >= pTileLayer->m_Height + 201)
|
|
|
|
{
|
2017-09-12 18:22:18 +00:00
|
|
|
vec2 Offset;
|
|
|
|
int OffX0 = (BorderX0 < -201 ? -201 : BorderX0);
|
|
|
|
int OffX1 = (BorderX1 >= pTileLayer->m_Width + 201 ? pTileLayer->m_Width + 201 : BorderX1);
|
|
|
|
Offset.x = OffX0 * 32.f;
|
|
|
|
Offset.y = (pTileLayer->m_Height + 201) * 32.f;
|
|
|
|
vec2 Dir;
|
|
|
|
Dir.x = 32.f;
|
|
|
|
Dir.y = 32.f;
|
|
|
|
|
2017-10-14 14:37:48 +00:00
|
|
|
int Count = (OffX1 - OffX0) * (BorderY1-(pTileLayer->m_Height + 201));
|
2017-09-12 18:22:18 +00:00
|
|
|
|
2018-03-13 20:57:46 +00:00
|
|
|
Graphics()->RenderBorderTiles(Visuals.m_BufferContainerIndex, (float*)pColor, (offset_ptr_size)Visuals.m_BorderKillTile.IndexBufferByteOffset(), (float*)&Offset, (float*)&Dir, (OffX1 - OffX0), Count);
|
2017-09-12 18:22:18 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-03-13 20:57:46 +00:00
|
|
|
void CMapLayers::RenderQuadLayer(int LayerIndex, CMapItemLayerQuads* pQuadLayer, CMapItemGroup* pGroup, bool Force)
|
|
|
|
{
|
|
|
|
SQuadLayerVisuals& Visuals = *m_QuadLayerVisuals[LayerIndex];
|
|
|
|
if(Visuals.m_BufferContainerIndex == -1)
|
|
|
|
return; //no visuals were created
|
|
|
|
|
|
|
|
if(!Force && (!g_Config.m_ClShowQuads || g_Config.m_ClOverlayEntities == 100))
|
|
|
|
return;
|
|
|
|
|
|
|
|
CQuad *pQuads = (CQuad *)m_pLayers->Map()->GetDataSwapped(pQuadLayer->m_Data);
|
|
|
|
|
|
|
|
static std::vector<SQuadRenderInfo> s_QuadRenderInfo;
|
|
|
|
|
|
|
|
s_QuadRenderInfo.resize(pQuadLayer->m_NumQuads);
|
|
|
|
for(int i = 0; i < pQuadLayer->m_NumQuads; ++i)
|
|
|
|
{
|
|
|
|
CQuad *q = &pQuads[i];
|
|
|
|
|
|
|
|
float aColor[4];
|
|
|
|
aColor[0] = aColor[1] = aColor[2] = aColor[3] = 1.f;
|
|
|
|
if(q->m_ColorEnv >= 0)
|
|
|
|
{
|
|
|
|
EnvelopeEval(q->m_ColorEnvOffset / 1000.0f, q->m_ColorEnv, aColor, this);
|
|
|
|
}
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2018-03-13 20:57:46 +00:00
|
|
|
float OffsetX = 0;
|
|
|
|
float OffsetY = 0;
|
|
|
|
float Rot = 0;
|
|
|
|
|
|
|
|
if(q->m_PosEnv >= 0)
|
|
|
|
{
|
|
|
|
float aChannels[4];
|
|
|
|
EnvelopeEval(q->m_PosEnvOffset / 1000.0f, q->m_PosEnv, aChannels, this);
|
|
|
|
OffsetX = aChannels[0];
|
|
|
|
OffsetY = aChannels[1];
|
|
|
|
Rot = aChannels[2] / 180.0f*pi;
|
|
|
|
}
|
|
|
|
|
|
|
|
SQuadRenderInfo& QInfo = s_QuadRenderInfo[i];
|
|
|
|
mem_copy(QInfo.m_aColor, aColor, sizeof(aColor));
|
|
|
|
QInfo.m_aOffsets[0] = OffsetX;
|
|
|
|
QInfo.m_aOffsets[1] = OffsetY;
|
|
|
|
QInfo.m_Rotation = Rot;
|
|
|
|
}
|
|
|
|
Graphics()->RenderQuadLayer(Visuals.m_BufferContainerIndex, &s_QuadRenderInfo[0], pQuadLayer->m_NumQuads);
|
|
|
|
}
|
|
|
|
|
|
|
|
void CMapLayers::LayersOfGroupCount(CMapItemGroup* pGroup, int& TileLayerCount, int& QuadLayerCount, bool& PassedGameLayer)
|
2019-03-26 18:15:24 +00:00
|
|
|
{
|
2017-09-12 18:22:18 +00:00
|
|
|
int TileLayerCounter = 0;
|
2018-03-13 20:57:46 +00:00
|
|
|
int QuadLayerCounter = 0;
|
2017-09-12 18:22:18 +00:00
|
|
|
for(int l = 0; l < pGroup->m_NumLayers; l++)
|
|
|
|
{
|
|
|
|
CMapItemLayer *pLayer = m_pLayers->GetLayer(pGroup->m_StartLayer+l);
|
|
|
|
bool IsFrontLayer = false;
|
|
|
|
bool IsSwitchLayer = false;
|
|
|
|
bool IsTeleLayer = false;
|
|
|
|
bool IsSpeedupLayer = false;
|
|
|
|
bool IsTuneLayer = false;
|
|
|
|
|
|
|
|
if(pLayer == (CMapItemLayer*)m_pLayers->GameLayer())
|
|
|
|
{
|
|
|
|
PassedGameLayer = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(pLayer == (CMapItemLayer*)m_pLayers->FrontLayer())
|
2017-09-27 13:01:38 +00:00
|
|
|
IsFrontLayer = true;
|
2017-09-12 18:22:18 +00:00
|
|
|
|
|
|
|
if(pLayer == (CMapItemLayer*)m_pLayers->SwitchLayer())
|
2017-09-27 13:01:38 +00:00
|
|
|
IsSwitchLayer = true;
|
2017-09-12 18:22:18 +00:00
|
|
|
|
|
|
|
if(pLayer == (CMapItemLayer*)m_pLayers->TeleLayer())
|
2017-09-27 13:01:38 +00:00
|
|
|
IsTeleLayer = true;
|
2017-09-12 18:22:18 +00:00
|
|
|
|
|
|
|
if(pLayer == (CMapItemLayer*)m_pLayers->SpeedupLayer())
|
2017-09-27 13:01:38 +00:00
|
|
|
IsSpeedupLayer = true;
|
2017-09-12 18:22:18 +00:00
|
|
|
|
|
|
|
if(pLayer == (CMapItemLayer*)m_pLayers->TuneLayer())
|
2017-09-27 13:01:38 +00:00
|
|
|
IsTuneLayer = true;
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2018-01-16 08:35:28 +00:00
|
|
|
|
|
|
|
if(m_Type <= TYPE_BACKGROUND_FORCE)
|
2017-09-12 18:22:18 +00:00
|
|
|
{
|
|
|
|
if(PassedGameLayer)
|
2018-03-13 20:57:46 +00:00
|
|
|
break;
|
2017-09-12 18:22:18 +00:00
|
|
|
}
|
2018-01-16 08:35:28 +00:00
|
|
|
else if(m_Type == TYPE_FOREGROUND)
|
|
|
|
{
|
|
|
|
if(!PassedGameLayer)
|
|
|
|
continue;
|
|
|
|
}
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2017-09-12 18:22:18 +00:00
|
|
|
if(pLayer->m_Type == LAYERTYPE_TILES)
|
|
|
|
{
|
|
|
|
CMapItemLayerTilemap *pTMap = (CMapItemLayerTilemap *)pLayer;
|
|
|
|
int DataIndex = 0;
|
2017-09-27 12:52:06 +00:00
|
|
|
unsigned int TileSize = 0;
|
2017-09-12 18:22:18 +00:00
|
|
|
int TileLayerAndOverlayCount = 0;
|
2018-01-16 08:35:28 +00:00
|
|
|
if(IsFrontLayer)
|
2017-09-13 18:33:58 +00:00
|
|
|
{
|
2017-09-12 18:22:18 +00:00
|
|
|
DataIndex = pTMap->m_Front;
|
|
|
|
TileSize = sizeof(CTile);
|
|
|
|
TileLayerAndOverlayCount = 1;
|
|
|
|
}
|
2019-03-26 18:15:24 +00:00
|
|
|
else if(IsSwitchLayer)
|
2017-09-13 18:33:58 +00:00
|
|
|
{
|
2017-09-12 18:22:18 +00:00
|
|
|
DataIndex = pTMap->m_Switch;
|
|
|
|
TileSize = sizeof(CSwitchTile);
|
|
|
|
TileLayerAndOverlayCount = 3;
|
|
|
|
}
|
2019-03-26 18:15:24 +00:00
|
|
|
else if(IsTeleLayer)
|
2017-09-13 18:33:58 +00:00
|
|
|
{
|
2017-09-12 18:22:18 +00:00
|
|
|
DataIndex = pTMap->m_Tele;
|
|
|
|
TileSize = sizeof(CTeleTile);
|
|
|
|
TileLayerAndOverlayCount = 2;
|
|
|
|
}
|
2019-03-26 18:15:24 +00:00
|
|
|
else if(IsSpeedupLayer)
|
2017-09-13 18:33:58 +00:00
|
|
|
{
|
2017-09-12 18:22:18 +00:00
|
|
|
DataIndex = pTMap->m_Speedup;
|
|
|
|
TileSize = sizeof(CSpeedupTile);
|
|
|
|
TileLayerAndOverlayCount = 3;
|
|
|
|
}
|
2019-03-26 18:15:24 +00:00
|
|
|
else if(IsTuneLayer)
|
2017-09-13 18:33:58 +00:00
|
|
|
{
|
2017-09-12 18:22:18 +00:00
|
|
|
DataIndex = pTMap->m_Tune;
|
|
|
|
TileSize = sizeof(CTuneTile);
|
|
|
|
TileLayerAndOverlayCount = 1;
|
|
|
|
}
|
2019-03-26 18:15:24 +00:00
|
|
|
else
|
2017-09-13 18:33:58 +00:00
|
|
|
{
|
2017-09-12 18:22:18 +00:00
|
|
|
DataIndex = pTMap->m_Data;
|
|
|
|
TileSize = sizeof(CTile);
|
|
|
|
TileLayerAndOverlayCount = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned int Size = m_pLayers->Map()->GetDataSize(DataIndex);
|
2018-01-16 08:35:28 +00:00
|
|
|
if(Size >= pTMap->m_Width*pTMap->m_Height*TileSize)
|
2017-09-12 18:22:18 +00:00
|
|
|
{
|
|
|
|
TileLayerCounter += TileLayerAndOverlayCount;
|
|
|
|
}
|
|
|
|
}
|
2018-03-13 20:57:46 +00:00
|
|
|
else if(pLayer->m_Type == LAYERTYPE_QUADS)
|
|
|
|
{
|
|
|
|
++QuadLayerCounter;
|
|
|
|
}
|
2017-09-12 18:22:18 +00:00
|
|
|
}
|
2018-03-13 20:57:46 +00:00
|
|
|
|
|
|
|
TileLayerCount += TileLayerCounter;
|
|
|
|
QuadLayerCount += QuadLayerCounter;
|
2017-09-12 18:22:18 +00:00
|
|
|
}
|
|
|
|
|
2010-05-29 07:25:38 +00:00
|
|
|
void CMapLayers::OnRender()
|
2008-08-27 15:48:50 +00:00
|
|
|
{
|
2010-05-29 07:25:38 +00:00
|
|
|
if(Client()->State() != IClient::STATE_ONLINE && Client()->State() != IClient::STATE_DEMOPLAYBACK)
|
2008-08-30 09:16:29 +00:00
|
|
|
return;
|
2011-04-13 18:37:12 +00:00
|
|
|
|
2010-05-29 07:25:38 +00:00
|
|
|
CUIRect Screen;
|
|
|
|
Graphics()->GetScreen(&Screen.x, &Screen.y, &Screen.w, &Screen.h);
|
2011-04-13 18:37:12 +00:00
|
|
|
|
2010-05-29 07:25:38 +00:00
|
|
|
vec2 Center = m_pClient->m_pCamera->m_Center;
|
2011-04-13 18:37:12 +00:00
|
|
|
|
2010-05-29 07:25:38 +00:00
|
|
|
bool PassedGameLayer = false;
|
2017-09-12 18:22:18 +00:00
|
|
|
int TileLayerCounter = 0;
|
2018-03-13 20:57:46 +00:00
|
|
|
int QuadLayerCounter = 0;
|
2011-04-13 18:37:12 +00:00
|
|
|
|
2010-05-29 07:25:38 +00:00
|
|
|
for(int g = 0; g < m_pLayers->NumGroups(); g++)
|
2008-08-27 15:48:50 +00:00
|
|
|
{
|
2010-05-29 07:25:38 +00:00
|
|
|
CMapItemGroup *pGroup = m_pLayers->GetGroup(g);
|
2011-04-13 18:37:12 +00:00
|
|
|
|
2011-02-17 09:24:11 +00:00
|
|
|
if(!pGroup)
|
|
|
|
{
|
2016-05-02 19:35:32 +00:00
|
|
|
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");
|
2011-02-17 09:24:11 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2010-05-29 07:25:38 +00:00
|
|
|
if(!g_Config.m_GfxNoclip && pGroup->m_Version >= 2 && pGroup->m_UseClipping)
|
2008-08-27 15:48:50 +00:00
|
|
|
{
|
|
|
|
// set clipping
|
2010-05-29 07:25:38 +00:00
|
|
|
float Points[4];
|
2010-10-17 08:43:27 +00:00
|
|
|
MapScreenToGroup(Center.x, Center.y, m_pLayers->GameGroup(), m_pClient->m_pCamera->m_Zoom);
|
2010-05-29 07:25:38 +00:00
|
|
|
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]);
|
2017-02-21 16:10:08 +00:00
|
|
|
|
2018-01-16 08:35:28 +00:00
|
|
|
if(x1 < 0.0f || x0 > 1.0f || y1 < 0.0f || y0 > 1.0f)
|
2017-09-13 18:33:58 +00:00
|
|
|
{
|
2017-09-12 18:22:18 +00:00
|
|
|
//check tile layer count of this group
|
2018-03-13 20:57:46 +00:00
|
|
|
LayersOfGroupCount(pGroup, TileLayerCounter, QuadLayerCounter, PassedGameLayer);
|
2017-01-05 09:24:52 +00:00
|
|
|
continue;
|
2017-09-12 18:22:18 +00:00
|
|
|
}
|
2011-04-13 18:37:12 +00:00
|
|
|
|
2009-10-27 14:38:53 +00:00
|
|
|
Graphics()->ClipEnable((int)(x0*Graphics()->ScreenWidth()), (int)(y0*Graphics()->ScreenHeight()),
|
|
|
|
(int)((x1-x0)*Graphics()->ScreenWidth()), (int)((y1-y0)*Graphics()->ScreenHeight()));
|
2011-04-13 18:37:12 +00:00
|
|
|
}
|
|
|
|
|
2017-09-13 18:33:58 +00:00
|
|
|
if(!g_Config.m_ClZoomBackgroundLayers && !pGroup->m_ParallaxX && !pGroup->m_ParallaxY)
|
|
|
|
{
|
2019-07-08 21:08:42 +00:00
|
|
|
MapScreenToGroup(Center.x, Center.y, pGroup, 1.0f);
|
2017-09-12 18:22:18 +00:00
|
|
|
} else
|
2014-09-29 19:13:35 +00:00
|
|
|
MapScreenToGroup(Center.x, Center.y, pGroup, m_pClient->m_pCamera->m_Zoom);
|
2011-04-13 18:37:12 +00:00
|
|
|
|
2010-05-29 07:25:38 +00:00
|
|
|
for(int l = 0; l < pGroup->m_NumLayers; l++)
|
2008-08-27 15:48:50 +00:00
|
|
|
{
|
2010-05-29 07:25:38 +00:00
|
|
|
CMapItemLayer *pLayer = m_pLayers->GetLayer(pGroup->m_StartLayer+l);
|
|
|
|
bool Render = false;
|
|
|
|
bool IsGameLayer = false;
|
2011-03-16 17:48:16 +00:00
|
|
|
bool IsFrontLayer = false;
|
|
|
|
bool IsSwitchLayer = false;
|
|
|
|
bool IsTeleLayer = false;
|
|
|
|
bool IsSpeedupLayer = false;
|
2014-07-26 10:33:25 +00:00
|
|
|
bool IsTuneLayer = false;
|
2017-09-12 18:22:18 +00:00
|
|
|
bool IsEntityLayer = false;
|
2011-04-13 18:37:12 +00:00
|
|
|
|
2010-05-29 07:25:38 +00:00
|
|
|
if(pLayer == (CMapItemLayer*)m_pLayers->GameLayer())
|
2008-08-27 15:48:50 +00:00
|
|
|
{
|
2017-09-12 18:22:18 +00:00
|
|
|
IsEntityLayer = IsGameLayer = true;
|
2015-10-05 10:51:19 +00:00
|
|
|
PassedGameLayer = true;
|
2008-08-27 15:48:50 +00:00
|
|
|
}
|
2011-04-13 18:37:12 +00:00
|
|
|
|
2011-03-16 17:48:16 +00:00
|
|
|
if(pLayer == (CMapItemLayer*)m_pLayers->FrontLayer())
|
2017-09-12 18:22:18 +00:00
|
|
|
IsEntityLayer = IsFrontLayer = true;
|
2011-03-16 17:48:16 +00:00
|
|
|
|
|
|
|
if(pLayer == (CMapItemLayer*)m_pLayers->SwitchLayer())
|
2017-09-12 18:22:18 +00:00
|
|
|
IsEntityLayer = IsSwitchLayer = true;
|
2011-03-16 17:48:16 +00:00
|
|
|
|
|
|
|
if(pLayer == (CMapItemLayer*)m_pLayers->TeleLayer())
|
2017-09-12 18:22:18 +00:00
|
|
|
IsEntityLayer = IsTeleLayer = true;
|
2011-03-16 17:48:16 +00:00
|
|
|
|
|
|
|
if(pLayer == (CMapItemLayer*)m_pLayers->SpeedupLayer())
|
2017-09-12 18:22:18 +00:00
|
|
|
IsEntityLayer = IsSpeedupLayer = true;
|
2014-03-23 16:44:02 +00:00
|
|
|
|
2014-03-12 23:11:25 +00:00
|
|
|
if(pLayer == (CMapItemLayer*)m_pLayers->TuneLayer())
|
2017-09-12 18:22:18 +00:00
|
|
|
IsEntityLayer = IsTuneLayer = true;
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2010-05-29 07:25:38 +00:00
|
|
|
if(m_Type == -1)
|
|
|
|
Render = true;
|
2017-09-12 18:22:18 +00:00
|
|
|
else if(m_Type <= TYPE_BACKGROUND_FORCE)
|
2008-08-27 15:48:50 +00:00
|
|
|
{
|
2010-05-29 07:25:38 +00:00
|
|
|
if(PassedGameLayer)
|
2008-08-27 15:48:50 +00:00
|
|
|
return;
|
2010-05-29 07:25:38 +00:00
|
|
|
Render = true;
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2017-09-13 18:33:58 +00:00
|
|
|
if(m_Type == TYPE_BACKGROUND_FORCE)
|
|
|
|
{
|
2017-09-12 18:22:18 +00:00
|
|
|
if(pLayer->m_Type == LAYERTYPE_TILES && !g_Config.m_ClBackgroundShowTilesLayers)
|
|
|
|
continue;
|
|
|
|
}
|
2008-08-27 15:48:50 +00:00
|
|
|
}
|
2015-10-05 10:51:19 +00:00
|
|
|
else // TYPE_FOREGROUND
|
2008-08-27 15:48:50 +00:00
|
|
|
{
|
2010-05-29 07:25:38 +00:00
|
|
|
if(PassedGameLayer && !IsGameLayer)
|
|
|
|
Render = true;
|
2008-08-27 15:48:50 +00:00
|
|
|
}
|
2011-04-13 18:37:12 +00:00
|
|
|
|
2016-04-30 18:11:26 +00:00
|
|
|
if(Render && pLayer->m_Type == LAYERTYPE_TILES && Input()->KeyIsPressed(KEY_LCTRL) && Input()->KeyIsPressed(KEY_LSHIFT) && Input()->KeyPress(KEY_KP_0))
|
2010-05-29 07:25:38 +00:00
|
|
|
{
|
|
|
|
CMapItemLayerTilemap *pTMap = (CMapItemLayerTilemap *)pLayer;
|
|
|
|
CTile *pTiles = (CTile *)m_pLayers->Map()->GetData(pTMap->m_Data);
|
2010-09-07 00:06:11 +00:00
|
|
|
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);
|
2010-10-06 21:07:35 +00:00
|
|
|
IOHANDLE File = Storage()->OpenFile(aFilename, IOFLAG_WRITE, IStorage::TYPE_SAVE);
|
2010-09-07 00:06:11 +00:00
|
|
|
if(File)
|
2010-05-29 07:25:38 +00:00
|
|
|
{
|
2010-09-07 00:06:11 +00:00
|
|
|
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));
|
2011-12-29 22:36:53 +00:00
|
|
|
io_write_newline(File);
|
2010-09-07 00:06:11 +00:00
|
|
|
}
|
|
|
|
io_close(File);
|
2010-05-29 07:25:38 +00:00
|
|
|
}
|
2011-04-13 18:37:12 +00:00
|
|
|
}
|
|
|
|
|
2018-01-16 08:35:28 +00:00
|
|
|
if((Render || IsGameLayer) && pLayer->m_Type == LAYERTYPE_TILES)
|
2017-09-12 18:22:18 +00:00
|
|
|
{
|
|
|
|
CMapItemLayerTilemap *pTMap = (CMapItemLayerTilemap *)pLayer;
|
|
|
|
int DataIndex = 0;
|
2017-09-27 12:52:06 +00:00
|
|
|
unsigned int TileSize = 0;
|
2017-09-12 18:22:18 +00:00
|
|
|
int TileLayerAndOverlayCount = 0;
|
2018-01-16 08:35:28 +00:00
|
|
|
if(IsFrontLayer)
|
2017-09-13 18:33:58 +00:00
|
|
|
{
|
2017-09-12 18:22:18 +00:00
|
|
|
DataIndex = pTMap->m_Front;
|
|
|
|
TileSize = sizeof(CTile);
|
|
|
|
TileLayerAndOverlayCount = 1;
|
|
|
|
}
|
2018-01-16 08:35:28 +00:00
|
|
|
else if(IsSwitchLayer)
|
2017-09-13 18:33:58 +00:00
|
|
|
{
|
2017-09-12 18:22:18 +00:00
|
|
|
DataIndex = pTMap->m_Switch;
|
|
|
|
TileSize = sizeof(CSwitchTile);
|
|
|
|
TileLayerAndOverlayCount = 3;
|
|
|
|
}
|
2018-01-16 08:35:28 +00:00
|
|
|
else if(IsTeleLayer)
|
2017-09-13 18:33:58 +00:00
|
|
|
{
|
2017-09-12 18:22:18 +00:00
|
|
|
DataIndex = pTMap->m_Tele;
|
|
|
|
TileSize = sizeof(CTeleTile);
|
|
|
|
TileLayerAndOverlayCount = 2;
|
|
|
|
}
|
2018-01-16 08:35:28 +00:00
|
|
|
else if(IsSpeedupLayer)
|
2017-09-13 18:33:58 +00:00
|
|
|
{
|
2017-09-12 18:22:18 +00:00
|
|
|
DataIndex = pTMap->m_Speedup;
|
|
|
|
TileSize = sizeof(CSpeedupTile);
|
|
|
|
TileLayerAndOverlayCount = 3;
|
|
|
|
}
|
2018-01-16 08:35:28 +00:00
|
|
|
else if(IsTuneLayer)
|
2017-09-13 18:33:58 +00:00
|
|
|
{
|
2017-09-12 18:22:18 +00:00
|
|
|
DataIndex = pTMap->m_Tune;
|
|
|
|
TileSize = sizeof(CTuneTile);
|
|
|
|
TileLayerAndOverlayCount = 1;
|
|
|
|
}
|
2017-09-13 18:33:58 +00:00
|
|
|
else
|
|
|
|
{
|
2017-09-12 18:22:18 +00:00
|
|
|
DataIndex = pTMap->m_Data;
|
|
|
|
TileSize = sizeof(CTile);
|
|
|
|
TileLayerAndOverlayCount = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned int Size = m_pLayers->Map()->GetDataSize(DataIndex);
|
2018-01-16 08:35:28 +00:00
|
|
|
if(Size >= pTMap->m_Width*pTMap->m_Height*TileSize)
|
2017-09-12 18:22:18 +00:00
|
|
|
{
|
|
|
|
TileLayerCounter += TileLayerAndOverlayCount;
|
|
|
|
}
|
|
|
|
}
|
2018-03-13 20:57:46 +00:00
|
|
|
else if(Render && pLayer->m_Type == LAYERTYPE_QUADS)
|
|
|
|
{
|
|
|
|
++QuadLayerCounter;
|
|
|
|
}
|
2017-09-12 18:22:18 +00:00
|
|
|
|
|
|
|
// skip rendering if detail layers if not wanted, or is entity layer and we are a background map
|
2018-01-16 08:35:28 +00:00
|
|
|
if((pLayer->m_Flags&LAYERFLAG_DETAIL && !g_Config.m_GfxHighDetail && !IsGameLayer) || (m_Type == TYPE_BACKGROUND_FORCE && IsEntityLayer))
|
2017-09-12 18:22:18 +00:00
|
|
|
continue;
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2017-09-12 18:22:18 +00:00
|
|
|
if((Render && g_Config.m_ClOverlayEntities < 100 && !IsGameLayer && !IsFrontLayer && !IsSwitchLayer && !IsTeleLayer && !IsSpeedupLayer && !IsTuneLayer) || (g_Config.m_ClOverlayEntities && IsGameLayer) || (m_Type == TYPE_BACKGROUND_FORCE))
|
2008-08-27 15:48:50 +00:00
|
|
|
{
|
2010-05-29 07:25:38 +00:00
|
|
|
if(pLayer->m_Type == LAYERTYPE_TILES)
|
2008-08-27 15:48:50 +00:00
|
|
|
{
|
2010-05-29 07:25:38 +00:00
|
|
|
CMapItemLayerTilemap *pTMap = (CMapItemLayerTilemap *)pLayer;
|
|
|
|
if(pTMap->m_Image == -1)
|
2011-03-16 12:48:16 +00:00
|
|
|
{
|
2014-05-01 15:44:35 +00:00
|
|
|
if(!IsGameLayer)
|
2011-03-16 12:48:16 +00:00
|
|
|
Graphics()->TextureSet(-1);
|
|
|
|
else
|
2017-09-12 18:22:18 +00:00
|
|
|
Graphics()->TextureSet(m_pImages->GetEntities());
|
2011-03-16 12:48:16 +00:00
|
|
|
}
|
2008-08-27 15:48:50 +00:00
|
|
|
else
|
2017-09-12 18:22:18 +00:00
|
|
|
Graphics()->TextureSet(m_pImages->Get(pTMap->m_Image));
|
2011-04-13 18:37:12 +00:00
|
|
|
|
2010-05-29 07:25:38 +00:00
|
|
|
CTile *pTiles = (CTile *)m_pLayers->Map()->GetData(pTMap->m_Data);
|
2017-08-30 06:36:17 +00:00
|
|
|
unsigned int Size = m_pLayers->Map()->GetDataSize(pTMap->m_Data);
|
2014-02-10 18:19:49 +00:00
|
|
|
|
2018-01-16 08:35:28 +00:00
|
|
|
if(Size >= pTMap->m_Width*pTMap->m_Height*sizeof(CTile))
|
2014-02-10 18:19:49 +00:00
|
|
|
{
|
2019-04-26 22:11:15 +00:00
|
|
|
ColorRGBA Color = ColorRGBA(pTMap->m_Color.r/255.0f, pTMap->m_Color.g/255.0f, pTMap->m_Color.b/255.0f, pTMap->m_Color.a/255.0f);
|
2014-05-01 15:44:35 +00:00
|
|
|
if(IsGameLayer && g_Config.m_ClOverlayEntities)
|
2019-04-26 22:11:15 +00:00
|
|
|
Color = ColorRGBA(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);
|
2017-09-12 18:22:18 +00:00
|
|
|
else if(!IsGameLayer && g_Config.m_ClOverlayEntities && !(m_Type == TYPE_BACKGROUND_FORCE))
|
2019-04-26 22:11:15 +00:00
|
|
|
Color = ColorRGBA(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);
|
2017-09-13 18:33:58 +00:00
|
|
|
if(!Graphics()->IsBufferingEnabled())
|
2018-03-13 20:57:46 +00:00
|
|
|
{
|
2017-09-12 18:22:18 +00:00
|
|
|
Graphics()->BlendNone();
|
|
|
|
RenderTools()->RenderTilemap(pTiles, pTMap->m_Width, pTMap->m_Height, 32.0f, Color, TILERENDERFLAG_EXTEND|LAYERRENDERFLAG_OPAQUE,
|
|
|
|
EnvelopeEval, this, pTMap->m_ColorEnv, pTMap->m_ColorEnvOffset);
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2017-09-12 18:22:18 +00:00
|
|
|
Graphics()->BlendNormal();
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2017-09-12 18:22:18 +00:00
|
|
|
// draw kill tiles outside the entity clipping rectangle
|
|
|
|
if(IsGameLayer)
|
2019-03-26 18:15:24 +00:00
|
|
|
{
|
2017-09-12 18:22:18 +00:00
|
|
|
// slow blinking to hint that it's not a part of the map
|
|
|
|
double Seconds = time_get()/(double)time_freq();
|
2019-07-08 21:08:42 +00:00
|
|
|
ColorRGBA ColorHint = ColorRGBA(1.0f, 1.0f, 1.0f, 0.3f + 0.7f*(1.0f+sin(2.0f*pi*Seconds/3.f))/2.0f);
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2017-09-12 18:22:18 +00:00
|
|
|
RenderTools()->RenderTileRectangle(-201, -201, pTMap->m_Width+402, pTMap->m_Height+402,
|
|
|
|
0, TILE_DEATH, // display air inside, death outside
|
2019-04-26 22:11:15 +00:00
|
|
|
32.0f, Color.v4()*ColorHint.v4(), TILERENDERFLAG_EXTEND|LAYERRENDERFLAG_TRANSPARENT,
|
2017-09-12 18:22:18 +00:00
|
|
|
EnvelopeEval, this, pTMap->m_ColorEnv, pTMap->m_ColorEnvOffset);
|
|
|
|
}
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2017-09-12 18:22:18 +00:00
|
|
|
RenderTools()->RenderTilemap(pTiles, pTMap->m_Width, pTMap->m_Height, 32.0f, Color, TILERENDERFLAG_EXTEND|LAYERRENDERFLAG_TRANSPARENT,
|
|
|
|
EnvelopeEval, this, pTMap->m_ColorEnv, pTMap->m_ColorEnvOffset);
|
2017-09-13 18:33:58 +00:00
|
|
|
} else
|
|
|
|
{
|
2017-09-12 18:22:18 +00:00
|
|
|
Graphics()->BlendNormal();
|
|
|
|
// draw kill tiles outside the entity clipping rectangle
|
2018-01-16 08:35:28 +00:00
|
|
|
if(IsGameLayer)
|
2017-09-12 18:22:18 +00:00
|
|
|
{
|
|
|
|
// slow blinking to hint that it's not a part of the map
|
|
|
|
double Seconds = time_get() / (double)time_freq();
|
2019-04-26 22:11:15 +00:00
|
|
|
ColorRGBA ColorHint = ColorRGBA(1.0f, 1.0f, 1.0f, 0.3f + 0.7f*(1.0 + sin(2.0f*pi*Seconds / 3.f)) / 2.0f);
|
2017-09-12 18:22:18 +00:00
|
|
|
|
2019-04-26 22:11:15 +00:00
|
|
|
ColorRGBA ColorKill(Color.x*ColorHint.x,Color.y*ColorHint.y,Color.z*ColorHint.z,Color.w*ColorHint.w);
|
2018-03-13 20:57:46 +00:00
|
|
|
RenderKillTileBorder(TileLayerCounter-1, &ColorKill, pTMap, pGroup);
|
2019-03-26 18:15:24 +00:00
|
|
|
}
|
2017-09-12 18:22:18 +00:00
|
|
|
RenderTileLayer(TileLayerCounter-1, &Color, pTMap, pGroup);
|
2017-03-15 11:06:13 +00:00
|
|
|
}
|
2014-02-10 18:19:49 +00:00
|
|
|
}
|
2008-08-27 15:48:50 +00:00
|
|
|
}
|
2010-05-29 07:25:38 +00:00
|
|
|
else if(pLayer->m_Type == LAYERTYPE_QUADS)
|
2008-08-27 15:48:50 +00:00
|
|
|
{
|
2010-05-29 07:25:38 +00:00
|
|
|
CMapItemLayerQuads *pQLayer = (CMapItemLayerQuads *)pLayer;
|
|
|
|
if(pQLayer->m_Image == -1)
|
2009-10-27 14:38:53 +00:00
|
|
|
Graphics()->TextureSet(-1);
|
2008-08-27 15:48:50 +00:00
|
|
|
else
|
2017-09-12 18:22:18 +00:00
|
|
|
Graphics()->TextureSet(m_pImages->Get(pQLayer->m_Image));
|
2008-08-27 15:48:50 +00:00
|
|
|
|
2010-05-29 07:25:38 +00:00
|
|
|
CQuad *pQuads = (CQuad *)m_pLayers->Map()->GetDataSwapped(pQLayer->m_Data);
|
2019-03-26 18:15:24 +00:00
|
|
|
if(m_Type == TYPE_BACKGROUND_FORCE)
|
2017-09-13 18:33:58 +00:00
|
|
|
{
|
|
|
|
if(g_Config.m_ClShowQuads)
|
|
|
|
{
|
2018-03-13 20:57:46 +00:00
|
|
|
if(!Graphics()->IsBufferingEnabled())
|
|
|
|
{
|
|
|
|
//Graphics()->BlendNone();
|
|
|
|
//RenderTools()->ForceRenderQuads(pQuads, pQLayer->m_NumQuads, LAYERRENDERFLAG_OPAQUE, EnvelopeEval, this, 1.f);
|
|
|
|
Graphics()->BlendNormal();
|
|
|
|
RenderTools()->ForceRenderQuads(pQuads, pQLayer->m_NumQuads, LAYERRENDERFLAG_TRANSPARENT, EnvelopeEval, this, 1.f);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
RenderQuadLayer(QuadLayerCounter-1, pQLayer, pGroup, true);
|
|
|
|
}
|
2019-03-26 18:15:24 +00:00
|
|
|
}
|
|
|
|
} else
|
2017-09-13 18:33:58 +00:00
|
|
|
{
|
2018-03-13 20:57:46 +00:00
|
|
|
if(!Graphics()->IsBufferingEnabled())
|
|
|
|
{
|
|
|
|
//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
|
|
|
|
{
|
|
|
|
RenderQuadLayer(QuadLayerCounter-1, pQLayer, pGroup, false);
|
|
|
|
}
|
2017-09-12 18:22:18 +00:00
|
|
|
}
|
2008-08-27 15:48:50 +00:00
|
|
|
}
|
|
|
|
}
|
2015-10-05 10:51:19 +00:00
|
|
|
else if(Render && g_Config.m_ClOverlayEntities && IsFrontLayer)
|
2011-04-19 14:32:42 +00:00
|
|
|
{
|
|
|
|
CMapItemLayerTilemap *pTMap = (CMapItemLayerTilemap *)pLayer;
|
2017-09-12 18:22:18 +00:00
|
|
|
Graphics()->TextureSet(m_pImages->GetEntities());
|
2011-04-19 14:32:42 +00:00
|
|
|
|
|
|
|
CTile *pFrontTiles = (CTile *)m_pLayers->Map()->GetData(pTMap->m_Front);
|
2017-08-30 06:36:17 +00:00
|
|
|
unsigned int Size = m_pLayers->Map()->GetDataSize(pTMap->m_Front);
|
2014-02-10 18:19:49 +00:00
|
|
|
|
2018-01-16 08:35:28 +00:00
|
|
|
if(Size >= pTMap->m_Width*pTMap->m_Height*sizeof(CTile))
|
2014-02-10 18:19:49 +00:00
|
|
|
{
|
2019-04-26 22:11:15 +00:00
|
|
|
ColorRGBA Color = ColorRGBA(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);
|
2017-09-13 18:33:58 +00:00
|
|
|
if(!Graphics()->IsBufferingEnabled())
|
2019-03-26 18:15:24 +00:00
|
|
|
{
|
2017-09-12 18:22:18 +00:00
|
|
|
Graphics()->BlendNone();
|
|
|
|
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,
|
2019-03-26 18:15:24 +00:00
|
|
|
EnvelopeEval, this, pTMap->m_ColorEnv, pTMap->m_ColorEnvOffset);
|
|
|
|
}
|
2017-09-27 12:52:06 +00:00
|
|
|
else
|
|
|
|
{
|
2019-03-26 18:15:24 +00:00
|
|
|
Graphics()->BlendNormal();
|
2017-09-12 18:22:18 +00:00
|
|
|
RenderTileLayer(TileLayerCounter-1, &Color, pTMap, pGroup);
|
|
|
|
}
|
2014-02-10 18:19:49 +00:00
|
|
|
}
|
2011-04-19 14:32:42 +00:00
|
|
|
}
|
2015-10-05 10:51:19 +00:00
|
|
|
else if(Render && g_Config.m_ClOverlayEntities && IsSwitchLayer)
|
2011-04-19 14:32:42 +00:00
|
|
|
{
|
|
|
|
CMapItemLayerTilemap *pTMap = (CMapItemLayerTilemap *)pLayer;
|
2017-09-12 18:22:18 +00:00
|
|
|
Graphics()->TextureSet(m_pImages->GetEntities());
|
2011-04-19 14:32:42 +00:00
|
|
|
|
|
|
|
CSwitchTile *pSwitchTiles = (CSwitchTile *)m_pLayers->Map()->GetData(pTMap->m_Switch);
|
2017-08-30 06:36:17 +00:00
|
|
|
unsigned int Size = m_pLayers->Map()->GetDataSize(pTMap->m_Switch);
|
2014-02-10 18:19:49 +00:00
|
|
|
|
2018-01-16 08:35:28 +00:00
|
|
|
if(Size >= pTMap->m_Width*pTMap->m_Height*sizeof(CSwitchTile))
|
2014-02-10 18:19:49 +00:00
|
|
|
{
|
2019-04-26 22:11:15 +00:00
|
|
|
ColorRGBA Color = ColorRGBA(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);
|
2017-09-13 18:33:58 +00:00
|
|
|
if(!Graphics()->IsBufferingEnabled())
|
|
|
|
{
|
2017-09-12 18:22:18 +00:00
|
|
|
Graphics()->BlendNone();
|
|
|
|
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);
|
2019-03-26 18:15:24 +00:00
|
|
|
}
|
2017-09-27 12:52:06 +00:00
|
|
|
else
|
|
|
|
{
|
2019-03-26 18:15:24 +00:00
|
|
|
Graphics()->BlendNormal();
|
2017-09-12 18:22:18 +00:00
|
|
|
RenderTileLayer(TileLayerCounter-3, &Color, pTMap, pGroup);
|
2017-09-27 10:20:23 +00:00
|
|
|
if(g_Config.m_ClTextEntities)
|
|
|
|
{
|
|
|
|
Graphics()->TextureSet(m_pImages->GetOverlayBottom());
|
|
|
|
RenderTileLayer(TileLayerCounter-2, &Color, pTMap, pGroup);
|
|
|
|
Graphics()->TextureSet(m_pImages->GetOverlayTop());
|
|
|
|
RenderTileLayer(TileLayerCounter-1, &Color, pTMap, pGroup);
|
|
|
|
}
|
2017-09-12 18:22:18 +00:00
|
|
|
}
|
2014-02-10 18:19:49 +00:00
|
|
|
}
|
2011-04-19 14:32:42 +00:00
|
|
|
}
|
2015-10-05 10:51:19 +00:00
|
|
|
else if(Render && g_Config.m_ClOverlayEntities && IsTeleLayer)
|
2011-04-19 14:32:42 +00:00
|
|
|
{
|
|
|
|
CMapItemLayerTilemap *pTMap = (CMapItemLayerTilemap *)pLayer;
|
2017-09-12 18:22:18 +00:00
|
|
|
Graphics()->TextureSet(m_pImages->GetEntities());
|
2011-04-19 14:32:42 +00:00
|
|
|
|
|
|
|
CTeleTile *pTeleTiles = (CTeleTile *)m_pLayers->Map()->GetData(pTMap->m_Tele);
|
2017-08-30 06:36:17 +00:00
|
|
|
unsigned int Size = m_pLayers->Map()->GetDataSize(pTMap->m_Tele);
|
2014-02-10 18:19:49 +00:00
|
|
|
|
2018-01-16 08:35:28 +00:00
|
|
|
if(Size >= pTMap->m_Width*pTMap->m_Height*sizeof(CTeleTile))
|
2014-02-10 18:19:49 +00:00
|
|
|
{
|
2019-04-26 22:11:15 +00:00
|
|
|
ColorRGBA Color = ColorRGBA(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);
|
2017-09-13 18:33:58 +00:00
|
|
|
if(!Graphics()->IsBufferingEnabled())
|
|
|
|
{
|
2017-09-12 18:22:18 +00:00
|
|
|
Graphics()->BlendNone();
|
|
|
|
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);
|
2017-09-27 12:52:06 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2017-09-12 18:22:18 +00:00
|
|
|
Graphics()->BlendNormal();
|
|
|
|
RenderTileLayer(TileLayerCounter-2, &Color, pTMap, pGroup);
|
2017-09-27 10:20:23 +00:00
|
|
|
if(g_Config.m_ClTextEntities)
|
|
|
|
{
|
|
|
|
Graphics()->TextureSet(m_pImages->GetOverlayCenter());
|
|
|
|
RenderTileLayer(TileLayerCounter-1, &Color, pTMap, pGroup);
|
|
|
|
}
|
2017-09-12 18:22:18 +00:00
|
|
|
}
|
2014-02-10 18:19:49 +00:00
|
|
|
}
|
2011-04-19 14:32:42 +00:00
|
|
|
}
|
2015-10-05 10:51:19 +00:00
|
|
|
else if(Render && g_Config.m_ClOverlayEntities && IsSpeedupLayer)
|
2011-04-19 14:32:42 +00:00
|
|
|
{
|
|
|
|
CMapItemLayerTilemap *pTMap = (CMapItemLayerTilemap *)pLayer;
|
2017-09-12 18:22:18 +00:00
|
|
|
Graphics()->TextureSet(m_pImages->GetEntities());
|
2011-04-19 14:32:42 +00:00
|
|
|
|
|
|
|
CSpeedupTile *pSpeedupTiles = (CSpeedupTile *)m_pLayers->Map()->GetData(pTMap->m_Speedup);
|
2017-08-30 06:36:17 +00:00
|
|
|
unsigned int Size = m_pLayers->Map()->GetDataSize(pTMap->m_Speedup);
|
2014-02-10 18:19:49 +00:00
|
|
|
|
2018-01-16 08:35:28 +00:00
|
|
|
if(Size >= pTMap->m_Width*pTMap->m_Height*sizeof(CSpeedupTile))
|
2014-02-10 18:19:49 +00:00
|
|
|
{
|
2019-04-26 22:11:15 +00:00
|
|
|
ColorRGBA Color = ColorRGBA(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);
|
2017-09-13 18:33:58 +00:00
|
|
|
if(!Graphics()->IsBufferingEnabled())
|
|
|
|
{
|
2017-09-12 18:22:18 +00:00
|
|
|
Graphics()->BlendNone();
|
|
|
|
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);
|
2019-03-26 18:15:24 +00:00
|
|
|
}
|
2017-09-27 12:52:06 +00:00
|
|
|
else
|
|
|
|
{
|
2017-09-12 18:22:18 +00:00
|
|
|
Graphics()->BlendNormal();
|
2019-03-26 18:15:24 +00:00
|
|
|
|
2017-10-10 10:08:36 +00:00
|
|
|
// draw arrow -- clamp to the edge of the arrow image
|
|
|
|
Graphics()->WrapClamp();
|
2017-09-12 18:22:18 +00:00
|
|
|
Graphics()->TextureSet(g_pData->m_aImages[IMAGE_SPEEDUP_ARROW].m_Id);
|
2019-03-26 18:15:24 +00:00
|
|
|
RenderTileLayer(TileLayerCounter-3, &Color, pTMap, pGroup);
|
2017-10-10 10:08:36 +00:00
|
|
|
Graphics()->WrapNormal();
|
2017-09-27 10:20:23 +00:00
|
|
|
if(g_Config.m_ClTextEntities)
|
|
|
|
{
|
|
|
|
Graphics()->TextureSet(m_pImages->GetOverlayBottom());
|
|
|
|
RenderTileLayer(TileLayerCounter-2, &Color, pTMap, pGroup);
|
|
|
|
Graphics()->TextureSet(m_pImages->GetOverlayTop());
|
|
|
|
RenderTileLayer(TileLayerCounter-1, &Color, pTMap, pGroup);
|
|
|
|
}
|
2017-09-12 18:22:18 +00:00
|
|
|
}
|
2014-02-10 18:19:49 +00:00
|
|
|
}
|
2011-04-19 14:32:42 +00:00
|
|
|
}
|
2015-10-05 10:51:19 +00:00
|
|
|
else if(Render && g_Config.m_ClOverlayEntities && IsTuneLayer)
|
2014-03-12 23:11:25 +00:00
|
|
|
{
|
|
|
|
CMapItemLayerTilemap *pTMap = (CMapItemLayerTilemap *)pLayer;
|
2017-09-12 18:22:18 +00:00
|
|
|
Graphics()->TextureSet(m_pImages->GetEntities());
|
2014-03-12 23:11:25 +00:00
|
|
|
|
|
|
|
CTuneTile *pTuneTiles = (CTuneTile *)m_pLayers->Map()->GetData(pTMap->m_Tune);
|
2017-08-30 06:36:17 +00:00
|
|
|
unsigned int Size = m_pLayers->Map()->GetDataSize(pTMap->m_Tune);
|
2014-03-12 23:11:25 +00:00
|
|
|
|
2018-01-16 08:35:28 +00:00
|
|
|
if(Size >= pTMap->m_Width*pTMap->m_Height*sizeof(CTuneTile))
|
2014-03-12 23:11:25 +00:00
|
|
|
{
|
2019-04-26 22:11:15 +00:00
|
|
|
ColorRGBA Color = ColorRGBA(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);
|
2017-09-13 18:33:58 +00:00
|
|
|
if(!Graphics()->IsBufferingEnabled())
|
|
|
|
{
|
2017-09-12 18:22:18 +00:00
|
|
|
Graphics()->BlendNone();
|
|
|
|
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);
|
2019-03-26 18:15:24 +00:00
|
|
|
}
|
2017-09-27 12:52:06 +00:00
|
|
|
else
|
|
|
|
{
|
2019-03-26 18:15:24 +00:00
|
|
|
Graphics()->BlendNormal();
|
2017-09-12 18:22:18 +00:00
|
|
|
RenderTileLayer(TileLayerCounter-1, &Color, pTMap, pGroup);
|
|
|
|
}
|
2014-03-12 23:11:25 +00:00
|
|
|
}
|
|
|
|
}
|
2008-08-27 15:48:50 +00:00
|
|
|
}
|
2010-05-29 07:25:38 +00:00
|
|
|
if(!g_Config.m_GfxNoclip)
|
2009-10-27 14:38:53 +00:00
|
|
|
Graphics()->ClipDisable();
|
2008-08-27 15:48:50 +00:00
|
|
|
}
|
2011-04-13 18:37:12 +00:00
|
|
|
|
2010-05-29 07:25:38 +00:00
|
|
|
if(!g_Config.m_GfxNoclip)
|
2009-10-27 14:38:53 +00:00
|
|
|
Graphics()->ClipDisable();
|
2011-04-13 18:37:12 +00:00
|
|
|
|
2009-01-12 14:43:39 +00:00
|
|
|
// reset the screen like it was before
|
2010-05-29 07:25:38 +00:00
|
|
|
Graphics()->MapScreen(Screen.x, Screen.y, Screen.w, Screen.h);
|
2008-08-27 15:48:50 +00:00
|
|
|
}
|