ddnet/src/game/client/render_map.cpp

779 lines
19 KiB
C++
Raw Normal View History

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. */
2008-08-30 21:09:13 +00:00
#include <math.h>
2010-05-29 07:25:38 +00:00
#include <base/math.h>
#include <engine/graphics.h>
2008-08-30 21:09:13 +00:00
2010-05-29 07:25:38 +00:00
#include "render.h"
2008-01-12 17:09:00 +00:00
#include <engine/textrender.h>
#include <engine/shared/config.h>
#include <game/generated/protocol.h>
#include <game/generated/client_data.h>
2008-08-30 21:09:13 +00:00
2010-05-29 07:25:38 +00:00
void CRenderTools::RenderEvalEnvelope(CEnvPoint *pPoints, int NumPoints, int Channels, float Time, float *pResult)
2008-01-17 23:09:49 +00:00
{
2010-05-29 07:25:38 +00:00
if(NumPoints == 0)
2008-01-17 23:09:49 +00:00
{
2010-05-29 07:25:38 +00:00
pResult[0] = 0;
pResult[1] = 0;
pResult[2] = 0;
pResult[3] = 0;
2008-01-17 23:09:49 +00:00
return;
}
2010-05-29 07:25:38 +00:00
if(NumPoints == 1)
2008-01-17 23:09:49 +00:00
{
2010-05-29 07:25:38 +00:00
pResult[0] = fx2f(pPoints[0].m_aValues[0]);
pResult[1] = fx2f(pPoints[0].m_aValues[1]);
pResult[2] = fx2f(pPoints[0].m_aValues[2]);
pResult[3] = fx2f(pPoints[0].m_aValues[3]);
2008-01-17 23:09:49 +00:00
return;
}
2010-05-29 07:25:38 +00:00
Time = fmod(Time, pPoints[NumPoints-1].m_Time/1000.0f)*1000.0f;
for(int i = 0; i < NumPoints-1; i++)
2008-01-17 23:09:49 +00:00
{
2010-05-29 07:25:38 +00:00
if(Time >= pPoints[i].m_Time && Time <= pPoints[i+1].m_Time)
2008-01-17 23:09:49 +00:00
{
2010-05-29 07:25:38 +00:00
float Delta = pPoints[i+1].m_Time-pPoints[i].m_Time;
float a = (Time-pPoints[i].m_Time)/Delta;
2008-01-17 23:09:49 +00:00
2010-05-29 07:25:38 +00:00
if(pPoints[i].m_Curvetype == CURVETYPE_SMOOTH)
2008-01-17 23:09:49 +00:00
a = -2*a*a*a + 3*a*a; // second hermite basis
2010-05-29 07:25:38 +00:00
else if(pPoints[i].m_Curvetype == CURVETYPE_SLOW)
2008-01-17 23:09:49 +00:00
a = a*a*a;
2010-05-29 07:25:38 +00:00
else if(pPoints[i].m_Curvetype == CURVETYPE_FAST)
2008-01-17 23:09:49 +00:00
{
a = 1-a;
a = 1-a*a*a;
}
2010-05-29 07:25:38 +00:00
else if (pPoints[i].m_Curvetype == CURVETYPE_STEP)
2008-01-17 23:09:49 +00:00
a = 0;
else
{
// linear
}
2010-05-29 07:25:38 +00:00
for(int c = 0; c < Channels; c++)
2008-01-17 23:09:49 +00:00
{
2010-05-29 07:25:38 +00:00
float v0 = fx2f(pPoints[i].m_aValues[c]);
float v1 = fx2f(pPoints[i+1].m_aValues[c]);
pResult[c] = v0 + (v1-v0) * a;
2008-01-17 23:09:49 +00:00
}
2008-01-17 23:09:49 +00:00
return;
}
}
2010-05-29 07:25:38 +00:00
pResult[0] = fx2f(pPoints[NumPoints-1].m_aValues[0]);
pResult[1] = fx2f(pPoints[NumPoints-1].m_aValues[1]);
pResult[2] = fx2f(pPoints[NumPoints-1].m_aValues[2]);
pResult[3] = fx2f(pPoints[NumPoints-1].m_aValues[3]);
2008-01-17 23:09:49 +00:00
return;
}
2010-05-29 07:25:38 +00:00
static void Rotate(CPoint *pCenter, CPoint *pPoint, float Rotation)
2008-01-12 17:09:00 +00:00
{
2010-05-29 07:25:38 +00:00
int x = pPoint->x - pCenter->x;
int y = pPoint->y - pCenter->y;
pPoint->x = (int)(x * cosf(Rotation) - y * sinf(Rotation) + pCenter->x);
pPoint->y = (int)(x * sinf(Rotation) + y * cosf(Rotation) + pCenter->y);
2008-01-12 17:09:00 +00:00
}
void CRenderTools::RenderQuads(CQuad *pQuads, int NumQuads, int RenderFlags, ENVELOPE_EVAL pfnEval, void *pUser)
2008-01-12 17:09:00 +00:00
{
2013-11-14 15:26:25 +00:00
if(!g_Config.m_ClShowQuads || (g_Config.m_ClShowEntities && g_Config.m_ClDDRaceCheats))
return;
2009-10-27 14:38:53 +00:00
Graphics()->QuadsBegin();
2010-05-29 07:25:38 +00:00
float Conv = 1/255.0f;
for(int i = 0; i < NumQuads; i++)
2008-01-12 17:09:00 +00:00
{
2010-05-29 07:25:38 +00:00
CQuad *q = &pQuads[i];
2008-03-29 11:44:03 +00:00
float r=1, g=1, b=1, a=1;
2010-05-29 07:25:38 +00:00
if(q->m_ColorEnv >= 0)
2008-03-29 11:44:03 +00:00
{
2010-05-29 07:25:38 +00:00
float aChannels[4];
pfnEval(q->m_ColorEnvOffset/1000.0f, q->m_ColorEnv, aChannels, pUser);
r = aChannels[0];
g = aChannels[1];
b = aChannels[2];
a = aChannels[3];
}
2010-05-29 07:25:38 +00:00
bool Opaque = false;
if(a < 0.01f || (q->m_aColors[0].a < 0.01f && q->m_aColors[1].a < 0.01f && q->m_aColors[2].a < 0.01f && q->m_aColors[3].a < 0.01f))
Opaque = true;
2010-05-29 07:25:38 +00:00
if(Opaque && !(RenderFlags&LAYERRENDERFLAG_OPAQUE))
2008-03-29 11:44:03 +00:00
continue;
2010-05-29 07:25:38 +00:00
if(!Opaque && !(RenderFlags&LAYERRENDERFLAG_TRANSPARENT))
2008-03-29 11:44:03 +00:00
continue;
2009-10-27 14:38:53 +00:00
Graphics()->QuadsSetSubsetFree(
2010-05-29 07:25:38 +00:00
fx2f(q->m_aTexcoords[0].x), fx2f(q->m_aTexcoords[0].y),
fx2f(q->m_aTexcoords[1].x), fx2f(q->m_aTexcoords[1].y),
fx2f(q->m_aTexcoords[2].x), fx2f(q->m_aTexcoords[2].y),
fx2f(q->m_aTexcoords[3].x), fx2f(q->m_aTexcoords[3].y)
2008-01-12 17:09:00 +00:00
);
2010-05-29 07:25:38 +00:00
float OffsetX = 0;
float OffsetY = 0;
float Rot = 0;
2008-01-12 17:09:00 +00:00
// TODO: fix this
2010-05-29 07:25:38 +00:00
if(q->m_PosEnv >= 0)
2008-01-12 17:09:00 +00:00
{
2010-05-29 07:25:38 +00:00
float aChannels[4];
pfnEval(q->m_PosEnvOffset/1000.0f, q->m_PosEnv, aChannels, pUser);
OffsetX = aChannels[0];
OffsetY = aChannels[1];
Rot = aChannels[2]/360.0f*pi*2;
2008-01-17 23:09:49 +00:00
}
2010-05-29 07:25:38 +00:00
IGraphics::CColorVertex Array[4] = {
IGraphics::CColorVertex(0, q->m_aColors[0].r*Conv*r, q->m_aColors[0].g*Conv*g, q->m_aColors[0].b*Conv*b, q->m_aColors[0].a*Conv*a),
IGraphics::CColorVertex(1, q->m_aColors[1].r*Conv*r, q->m_aColors[1].g*Conv*g, q->m_aColors[1].b*Conv*b, q->m_aColors[1].a*Conv*a),
IGraphics::CColorVertex(2, q->m_aColors[2].r*Conv*r, q->m_aColors[2].g*Conv*g, q->m_aColors[2].b*Conv*b, q->m_aColors[2].a*Conv*a),
IGraphics::CColorVertex(3, q->m_aColors[3].r*Conv*r, q->m_aColors[3].g*Conv*g, q->m_aColors[3].b*Conv*b, q->m_aColors[3].a*Conv*a)};
Graphics()->SetColorVertex(Array, 4);
2008-01-12 17:09:00 +00:00
2010-05-29 07:25:38 +00:00
CPoint *pPoints = q->m_aPoints;
2010-05-29 07:25:38 +00:00
if(Rot != 0)
2008-01-12 17:09:00 +00:00
{
2010-05-29 07:25:38 +00:00
static CPoint aRotated[4];
aRotated[0] = q->m_aPoints[0];
aRotated[1] = q->m_aPoints[1];
aRotated[2] = q->m_aPoints[2];
aRotated[3] = q->m_aPoints[3];
pPoints = aRotated;
2010-05-29 07:25:38 +00:00
Rotate(&q->m_aPoints[4], &aRotated[0], Rot);
Rotate(&q->m_aPoints[4], &aRotated[1], Rot);
Rotate(&q->m_aPoints[4], &aRotated[2], Rot);
Rotate(&q->m_aPoints[4], &aRotated[3], Rot);
2008-01-12 17:09:00 +00:00
}
2010-05-29 07:25:38 +00:00
IGraphics::CFreeformItem Freeform(
fx2f(pPoints[0].x)+OffsetX, fx2f(pPoints[0].y)+OffsetY,
fx2f(pPoints[1].x)+OffsetX, fx2f(pPoints[1].y)+OffsetY,
fx2f(pPoints[2].x)+OffsetX, fx2f(pPoints[2].y)+OffsetY,
fx2f(pPoints[3].x)+OffsetX, fx2f(pPoints[3].y)+OffsetY);
Graphics()->QuadsDrawFreeform(&Freeform, 1);
2008-01-12 17:09:00 +00:00
}
Graphics()->QuadsEnd();
2008-01-12 17:09:00 +00:00
}
void CRenderTools::RenderTilemap(CTile *pTiles, int w, int h, float Scale, vec4 Color, int RenderFlags,
ENVELOPE_EVAL pfnEval, void *pUser, int ColorEnv, int ColorEnvOffset)
2008-01-12 17:09:00 +00:00
{
2009-10-27 14:38:53 +00:00
//Graphics()->TextureSet(img_get(tmap->image));
2010-05-29 07:25:38 +00:00
float ScreenX0, ScreenY0, ScreenX1, ScreenY1;
Graphics()->GetScreen(&ScreenX0, &ScreenY0, &ScreenX1, &ScreenY1);
2009-10-27 14:38:53 +00:00
//Graphics()->MapScreen(screen_x0-50, screen_y0-50, screen_x1+50, screen_y1+50);
2008-01-12 17:09:00 +00:00
// calculate the final pixelsize for the tiles
2010-05-29 07:25:38 +00:00
float TilePixelSize = 1024/32.0f;
float FinalTileSize = Scale/(ScreenX1-ScreenX0) * Graphics()->ScreenWidth();
float FinalTilesetScale = FinalTileSize/TilePixelSize;
float r=1, g=1, b=1, a=1;
if(ColorEnv >= 0)
{
float aChannels[4];
pfnEval(ColorEnvOffset/1000.0f, ColorEnv, aChannels, pUser);
r = aChannels[0];
g = aChannels[1];
b = aChannels[2];
a = aChannels[3];
}
2009-10-27 14:38:53 +00:00
Graphics()->QuadsBegin();
Graphics()->SetColor(Color.r*r, Color.g*g, Color.b*b, Color.a*a);
2010-05-29 07:25:38 +00:00
int StartY = (int)(ScreenY0/Scale)-1;
int StartX = (int)(ScreenX0/Scale)-1;
int EndY = (int)(ScreenY1/Scale)+1;
int EndX = (int)(ScreenX1/Scale)+1;
2008-01-12 17:09:00 +00:00
// adjust the texture shift according to mipmap level
2010-05-29 07:25:38 +00:00
float TexSize = 1024.0f;
float Frac = (1.25f/TexSize) * (1/FinalTilesetScale);
float Nudge = (0.5f/TexSize) * (1/FinalTilesetScale);
2008-01-12 17:09:00 +00:00
2010-05-29 07:25:38 +00:00
for(int y = StartY; y < EndY; y++)
for(int x = StartX; x < EndX; x++)
2008-01-12 17:09:00 +00:00
{
int mx = x;
int my = y;
2010-05-29 07:25:38 +00:00
if(RenderFlags&TILERENDERFLAG_EXTEND)
{
if(mx<0)
mx = 0;
if(mx>=w)
mx = w-1;
if(my<0)
my = 0;
if(my>=h)
my = h-1;
}
else
{
if(mx<0)
continue; // mx = 0;
if(mx>=w)
continue; // mx = w-1;
if(my<0)
continue; // my = 0;
if(my>=h)
continue; // my = h-1;
}
2008-01-12 17:09:00 +00:00
int c = mx + my*w;
2010-05-29 07:25:38 +00:00
unsigned char Index = pTiles[c].m_Index;
if(Index)
2008-01-12 17:09:00 +00:00
{
2010-05-29 07:25:38 +00:00
unsigned char Flags = pTiles[c].m_Flags;
2010-05-29 07:25:38 +00:00
bool Render = false;
if(Flags&TILEFLAG_OPAQUE)
2008-01-12 17:09:00 +00:00
{
2010-05-29 07:25:38 +00:00
if(RenderFlags&LAYERRENDERFLAG_OPAQUE)
Render = true;
2008-01-12 17:09:00 +00:00
}
2008-03-29 11:44:03 +00:00
else
2008-01-12 17:09:00 +00:00
{
2010-05-29 07:25:38 +00:00
if(RenderFlags&LAYERRENDERFLAG_TRANSPARENT)
Render = true;
2008-01-12 17:09:00 +00:00
}
2010-05-29 07:25:38 +00:00
if(Render)
2008-03-29 11:44:03 +00:00
{
2010-05-29 07:25:38 +00:00
int tx = Index%16;
int ty = Index/16;
int Px0 = tx*(1024/16);
int Py0 = ty*(1024/16);
2010-08-05 18:55:51 +00:00
int Px1 = Px0+(1024/16)-1;
int Py1 = Py0+(1024/16)-1;
float x0 = Nudge + Px0/TexSize+Frac;
float y0 = Nudge + Py0/TexSize+Frac;
float x1 = Nudge + Px1/TexSize-Frac;
float y1 = Nudge + Py0/TexSize+Frac;
float x2 = Nudge + Px1/TexSize-Frac;
float y2 = Nudge + Py1/TexSize-Frac;
float x3 = Nudge + Px0/TexSize+Frac;
float y3 = Nudge + Py1/TexSize-Frac;
2010-05-29 07:25:38 +00:00
if(Flags&TILEFLAG_VFLIP)
2008-03-29 11:44:03 +00:00
{
x0 = x2;
x1 = x3;
x2 = x3;
x3 = x0;
2008-03-29 11:44:03 +00:00
}
2008-01-12 17:09:00 +00:00
2010-05-29 07:25:38 +00:00
if(Flags&TILEFLAG_HFLIP)
2008-03-29 11:44:03 +00:00
{
y0 = y3;
y2 = y1;
y3 = y1;
y1 = y0;
2008-03-29 11:44:03 +00:00
}
if(Flags&TILEFLAG_ROTATE)
{
float Tmp = x0;
x0 = x3;
x3 = x2;
x2 = x1;
x1 = Tmp;
Tmp = y0;
y0 = y3;
y3 = y2;
y2 = y1;
y1 = Tmp;
}
Graphics()->QuadsSetSubsetFree(x0, y0, x1, y1, x2, y2, x3, y3);
2010-05-29 07:25:38 +00:00
IGraphics::CQuadItem QuadItem(x*Scale, y*Scale, Scale, Scale);
Graphics()->QuadsDrawTL(&QuadItem, 1);
2008-03-29 11:44:03 +00:00
}
2008-01-12 17:09:00 +00:00
}
2010-05-29 07:25:38 +00:00
x += pTiles[c].m_Skip;
2008-01-12 17:09:00 +00:00
}
2009-10-27 14:38:53 +00:00
Graphics()->QuadsEnd();
2010-05-29 07:25:38 +00:00
Graphics()->MapScreen(ScreenX0, ScreenY0, ScreenX1, ScreenY1);
2008-01-12 17:09:00 +00:00
}
2011-04-19 14:32:42 +00:00
void CRenderTools::RenderTeleOverlay(CTeleTile *pTele, int w, int h, float Scale)
{
float ScreenX0, ScreenY0, ScreenX1, ScreenY1;
Graphics()->GetScreen(&ScreenX0, &ScreenY0, &ScreenX1, &ScreenY1);
int StartY = (int)(ScreenY0/Scale)-1;
int StartX = (int)(ScreenX0/Scale)-1;
int EndY = (int)(ScreenY1/Scale)+1;
int EndX = (int)(ScreenX1/Scale)+1;
for(int y = StartY; y < EndY; y++)
for(int x = StartX; x < EndX; x++)
{
int mx = x;
int my = y;
if(mx<0)
continue; // mx = 0;
if(mx>=w)
continue; // mx = w-1;
if(my<0)
continue; // my = 0;
if(my>=h)
continue; // my = h-1;
int c = mx + my*w;
unsigned char Index = pTele[c].m_Number;
if(Index)
{
char aBuf[16];
str_format(aBuf, sizeof(aBuf), "%d", Index);
UI()->TextRender()->Text(0, mx*Scale-2, my*Scale-4, Scale-5, aBuf, -1);
}
}
Graphics()->MapScreen(ScreenX0, ScreenY0, ScreenX1, ScreenY1);
}
2011-04-19 14:32:42 +00:00
void CRenderTools::RenderSpeedupOverlay(CSpeedupTile *pSpeedup, int w, int h, float Scale)
{
float ScreenX0, ScreenY0, ScreenX1, ScreenY1;
Graphics()->GetScreen(&ScreenX0, &ScreenY0, &ScreenX1, &ScreenY1);
int StartY = (int)(ScreenY0/Scale)-1;
int StartX = (int)(ScreenX0/Scale)-1;
int EndY = (int)(ScreenY1/Scale)+1;
int EndX = (int)(ScreenX1/Scale)+1;
for(int y = StartY; y < EndY; y++)
for(int x = StartX; x < EndX; x++)
{
int mx = x;
int my = y;
if(mx<0)
continue; // mx = 0;
if(mx>=w)
continue; // mx = w-1;
if(my<0)
continue; // my = 0;
if(my>=h)
continue; // my = h-1;
int c = mx + my*w;
int Force = (int)pSpeedup[c].m_Force;
int MaxSpeed = (int)pSpeedup[c].m_MaxSpeed;
if(Force)
{
// draw arrow
Graphics()->TextureSet(g_pData->m_aImages[IMAGE_SPEEDUP_ARROW].m_Id);
Graphics()->QuadsBegin();
SelectSprite(SPRITE_SPEEDUP_ARROW);
Graphics()->QuadsSetRotation(pSpeedup[c].m_Angle*(3.14159265f/180.0f));
DrawSprite(mx*Scale+16, my*Scale+16, 35.0f);
Graphics()->QuadsEnd();
// draw force
char aBuf[16];
str_format(aBuf, sizeof(aBuf), "%d", Force);
UI()->TextRender()->Text(0, mx*Scale, my*Scale+16, Scale-20, aBuf, -1);
if(MaxSpeed)
{
str_format(aBuf, sizeof(aBuf), "%d", MaxSpeed);
UI()->TextRender()->Text(0, mx*Scale, my*Scale-2, Scale-20, aBuf, -1);
}
}
}
Graphics()->MapScreen(ScreenX0, ScreenY0, ScreenX1, ScreenY1);
}
2011-04-19 14:32:42 +00:00
void CRenderTools::RenderSwitchOverlay(CSwitchTile *pSwitch, int w, int h, float Scale)
{
float ScreenX0, ScreenY0, ScreenX1, ScreenY1;
Graphics()->GetScreen(&ScreenX0, &ScreenY0, &ScreenX1, &ScreenY1);
int StartY = (int)(ScreenY0/Scale)-1;
int StartX = (int)(ScreenX0/Scale)-1;
int EndY = (int)(ScreenY1/Scale)+1;
int EndX = (int)(ScreenX1/Scale)+1;
for(int y = StartY; y < EndY; y++)
for(int x = StartX; x < EndX; x++)
{
int mx = x;
int my = y;
if(mx<0)
continue; // mx = 0;
if(mx>=w)
continue; // mx = w-1;
if(my<0)
continue; // my = 0;
if(my>=h)
continue; // my = h-1;
int c = mx + my*w;
unsigned char Index = pSwitch[c].m_Number;
if(Index)
{
char aBuf[16];
str_format(aBuf, sizeof(aBuf), "%d", Index);
2010-11-22 20:43:22 +00:00
UI()->TextRender()->Text(0, mx*Scale, my*Scale+16, Scale-20, aBuf, -1);
}
unsigned char Delay = pSwitch[c].m_Delay;
if(Delay)
{
char aBuf[16];
str_format(aBuf, sizeof(aBuf), "%d", Delay);
UI()->TextRender()->Text(0, mx*Scale, my*Scale-2, Scale-20, aBuf, -1);
}
}
Graphics()->MapScreen(ScreenX0, ScreenY0, ScreenX1, ScreenY1);
2011-03-16 12:48:16 +00:00
}
2011-04-19 14:32:42 +00:00
void CRenderTools::RenderTelemap(CTeleTile *pTele, int w, int h, float Scale, vec4 Color, int RenderFlags)
{
float ScreenX0, ScreenY0, ScreenX1, ScreenY1;
Graphics()->GetScreen(&ScreenX0, &ScreenY0, &ScreenX1, &ScreenY1);
// calculate the final pixelsize for the tiles
float TilePixelSize = 1024/32.0f;
float FinalTileSize = Scale/(ScreenX1-ScreenX0) * Graphics()->ScreenWidth();
float FinalTilesetScale = FinalTileSize/TilePixelSize;
Graphics()->QuadsBegin();
Graphics()->SetColor(Color.r, Color.g, Color.b, Color.a);
int StartY = (int)(ScreenY0/Scale)-1;
int StartX = (int)(ScreenX0/Scale)-1;
int EndY = (int)(ScreenY1/Scale)+1;
int EndX = (int)(ScreenX1/Scale)+1;
// adjust the texture shift according to mipmap level
float TexSize = 1024.0f;
float Frac = (1.25f/TexSize) * (1/FinalTilesetScale);
float Nudge = (0.5f/TexSize) * (1/FinalTilesetScale);
for(int y = StartY; y < EndY; y++)
for(int x = StartX; x < EndX; x++)
{
int mx = x;
int my = y;
if(RenderFlags&TILERENDERFLAG_EXTEND)
{
if(mx<0)
mx = 0;
if(mx>=w)
mx = w-1;
if(my<0)
my = 0;
if(my>=h)
my = h-1;
}
else
{
if(mx<0)
continue; // mx = 0;
if(mx>=w)
continue; // mx = w-1;
if(my<0)
continue; // my = 0;
if(my>=h)
continue; // my = h-1;
}
int c = mx + my*w;
unsigned char Index = pTele[c].m_Type;
if(Index)
{
bool Render = false;
if(RenderFlags&LAYERRENDERFLAG_TRANSPARENT)
Render = true;
if(Render)
{
int tx = Index%16;
int ty = Index/16;
int Px0 = tx*(1024/16);
int Py0 = ty*(1024/16);
int Px1 = Px0+(1024/16)-1;
int Py1 = Py0+(1024/16)-1;
float x0 = Nudge + Px0/TexSize+Frac;
float y0 = Nudge + Py0/TexSize+Frac;
float x1 = Nudge + Px1/TexSize-Frac;
float y1 = Nudge + Py0/TexSize+Frac;
float x2 = Nudge + Px1/TexSize-Frac;
float y2 = Nudge + Py1/TexSize-Frac;
float x3 = Nudge + Px0/TexSize+Frac;
float y3 = Nudge + Py1/TexSize-Frac;
Graphics()->QuadsSetSubsetFree(x0, y0, x1, y1, x2, y2, x3, y3);
IGraphics::CQuadItem QuadItem(x*Scale, y*Scale, Scale, Scale);
Graphics()->QuadsDrawTL(&QuadItem, 1);
}
}
}
Graphics()->QuadsEnd();
Graphics()->MapScreen(ScreenX0, ScreenY0, ScreenX1, ScreenY1);
}
void CRenderTools::RenderSpeedupmap(CSpeedupTile *pSpeedupTile, int w, int h, float Scale, vec4 Color, int RenderFlags)
{
//Graphics()->TextureSet(img_get(tmap->image));
float ScreenX0, ScreenY0, ScreenX1, ScreenY1;
Graphics()->GetScreen(&ScreenX0, &ScreenY0, &ScreenX1, &ScreenY1);
//Graphics()->MapScreen(screen_x0-50, screen_y0-50, screen_x1+50, screen_y1+50);
// calculate the final pixelsize for the tiles
float TilePixelSize = 1024/32.0f;
float FinalTileSize = Scale/(ScreenX1-ScreenX0) * Graphics()->ScreenWidth();
float FinalTilesetScale = FinalTileSize/TilePixelSize;
Graphics()->QuadsBegin();
Graphics()->SetColor(Color.r, Color.g, Color.b, Color.a);
int StartY = (int)(ScreenY0/Scale)-1;
int StartX = (int)(ScreenX0/Scale)-1;
int EndY = (int)(ScreenY1/Scale)+1;
int EndX = (int)(ScreenX1/Scale)+1;
// adjust the texture shift according to mipmap level
float TexSize = 1024.0f;
float Frac = (1.25f/TexSize) * (1/FinalTilesetScale);
float Nudge = (0.5f/TexSize) * (1/FinalTilesetScale);
for(int y = StartY; y < EndY; y++)
for(int x = StartX; x < EndX; x++)
{
int mx = x;
int my = y;
if(RenderFlags&TILERENDERFLAG_EXTEND)
{
if(mx<0)
mx = 0;
if(mx>=w)
mx = w-1;
if(my<0)
my = 0;
if(my>=h)
my = h-1;
}
else
{
if(mx<0)
continue; // mx = 0;
if(mx>=w)
continue; // mx = w-1;
if(my<0)
continue; // my = 0;
if(my>=h)
continue; // my = h-1;
}
int c = mx + my*w;
unsigned char Index = pSpeedupTile[c].m_Type;
if(Index)
{
bool Render = false;
if(RenderFlags&LAYERRENDERFLAG_TRANSPARENT)
Render = true;
if(Render)
{
int tx = Index%16;
int ty = Index/16;
int Px0 = tx*(1024/16);
int Py0 = ty*(1024/16);
int Px1 = Px0+(1024/16)-1;
int Py1 = Py0+(1024/16)-1;
float x0 = Nudge + Px0/TexSize+Frac;
float y0 = Nudge + Py0/TexSize+Frac;
float x1 = Nudge + Px1/TexSize-Frac;
float y1 = Nudge + Py0/TexSize+Frac;
float x2 = Nudge + Px1/TexSize-Frac;
float y2 = Nudge + Py1/TexSize-Frac;
float x3 = Nudge + Px0/TexSize+Frac;
float y3 = Nudge + Py1/TexSize-Frac;
Graphics()->QuadsSetSubsetFree(x0, y0, x1, y1, x2, y2, x3, y3);
IGraphics::CQuadItem QuadItem(x*Scale, y*Scale, Scale, Scale);
Graphics()->QuadsDrawTL(&QuadItem, 1);
}
}
}
Graphics()->QuadsEnd();
Graphics()->MapScreen(ScreenX0, ScreenY0, ScreenX1, ScreenY1);
}
void CRenderTools::RenderSwitchmap(CSwitchTile *pSwitchTile, int w, int h, float Scale, vec4 Color, int RenderFlags)
{
//Graphics()->TextureSet(img_get(tmap->image));
float ScreenX0, ScreenY0, ScreenX1, ScreenY1;
Graphics()->GetScreen(&ScreenX0, &ScreenY0, &ScreenX1, &ScreenY1);
//Graphics()->MapScreen(screen_x0-50, screen_y0-50, screen_x1+50, screen_y1+50);
// calculate the final pixelsize for the tiles
float TilePixelSize = 1024/32.0f;
float FinalTileSize = Scale/(ScreenX1-ScreenX0) * Graphics()->ScreenWidth();
float FinalTilesetScale = FinalTileSize/TilePixelSize;
Graphics()->QuadsBegin();
Graphics()->SetColor(Color.r, Color.g, Color.b, Color.a);
int StartY = (int)(ScreenY0/Scale)-1;
int StartX = (int)(ScreenX0/Scale)-1;
int EndY = (int)(ScreenY1/Scale)+1;
int EndX = (int)(ScreenX1/Scale)+1;
// adjust the texture shift according to mipmap level
float TexSize = 1024.0f;
float Frac = (1.25f/TexSize) * (1/FinalTilesetScale);
float Nudge = (0.5f/TexSize) * (1/FinalTilesetScale);
for(int y = StartY; y < EndY; y++)
for(int x = StartX; x < EndX; x++)
{
int mx = x;
int my = y;
if(RenderFlags&TILERENDERFLAG_EXTEND)
{
if(mx<0)
mx = 0;
if(mx>=w)
mx = w-1;
if(my<0)
my = 0;
if(my>=h)
my = h-1;
}
else
{
if(mx<0)
continue; // mx = 0;
if(mx>=w)
continue; // mx = w-1;
if(my<0)
continue; // my = 0;
if(my>=h)
continue; // my = h-1;
}
int c = mx + my*w;
unsigned char Index = pSwitchTile[c].m_Type;
if(Index)
{
unsigned char Flags = pSwitchTile[c].m_Flags;
bool Render = false;
if(Flags&TILEFLAG_OPAQUE)
{
if(RenderFlags&LAYERRENDERFLAG_OPAQUE)
Render = true;
}
else
{
if(RenderFlags&LAYERRENDERFLAG_TRANSPARENT)
Render = true;
}
if(Render)
{
int tx = Index%16;
int ty = Index/16;
int Px0 = tx*(1024/16);
int Py0 = ty*(1024/16);
int Px1 = Px0+(1024/16)-1;
int Py1 = Py0+(1024/16)-1;
float x0 = Nudge + Px0/TexSize+Frac;
float y0 = Nudge + Py0/TexSize+Frac;
float x1 = Nudge + Px1/TexSize-Frac;
float y1 = Nudge + Py0/TexSize+Frac;
float x2 = Nudge + Px1/TexSize-Frac;
float y2 = Nudge + Py1/TexSize-Frac;
float x3 = Nudge + Px0/TexSize+Frac;
float y3 = Nudge + Py1/TexSize-Frac;
if(Flags&TILEFLAG_VFLIP)
{
x0 = x2;
x1 = x3;
x2 = x3;
x3 = x0;
}
if(Flags&TILEFLAG_HFLIP)
{
y0 = y3;
y2 = y1;
y3 = y1;
y1 = y0;
}
if(Flags&TILEFLAG_ROTATE)
{
float Tmp = x0;
x0 = x3;
x3 = x2;
x2 = x1;
x1 = Tmp;
Tmp = y0;
y0 = y3;
y3 = y2;
y2 = y1;
y1 = Tmp;
}
Graphics()->QuadsSetSubsetFree(x0, y0, x1, y1, x2, y2, x3, y3);
IGraphics::CQuadItem QuadItem(x*Scale, y*Scale, Scale, Scale);
Graphics()->QuadsDrawTL(&QuadItem, 1);
}
}
}
Graphics()->QuadsEnd();
Graphics()->MapScreen(ScreenX0, ScreenY0, ScreenX1, ScreenY1);
}