TVector2 Str_Vector2N (const string &s) {
float x, y;
istringstream is(s);
is >> x >> y;
if (is.fail()) return MakeVector2 (0, 0);
else return MakeVector2 (x, y);
}
void PaletteView::Draw() {
Handle<IImage> img = renderer->RegisterImage("Gfx/Palette.png");
int sel = GetSelectedIndex();
float scrW = renderer->ScreenWidth();
float scrH = renderer->ScreenHeight();
for(size_t phase = 0; phase < 2; phase++){
for(size_t i = 0; i < colors.size(); i++){
if((sel == i) != (phase == 1))
continue;
int row = i / 8;
int col = i % 8;
bool selected = sel == i;
// draw color
IntVector3 icol = colors[i];
Vector4 cl;
cl.x = icol.x / 255.f;
cl.y = icol.y / 255.f;
cl.z = icol.z / 255.f;
cl.w = 1.f;
float x = scrW - 100.f + 10.f * col;
float y = scrH - 96.f + 10.f * row - 40.f;
renderer->SetColorAlphaPremultiplied(cl);
if(selected){
renderer->DrawImage(img,
MakeVector2(x, y),
AABB2(0, 16, 16, 16));
}else{
renderer->DrawImage(img,
MakeVector2(x, y),
AABB2(0, 0, 16, 16));
}
renderer->SetColorAlphaPremultiplied(MakeVector4(1, 1, 1, 1));
if(selected){
renderer->DrawImage(img,
MakeVector2(x, y),
AABB2(16, 16, 16, 16));
}else{
renderer->DrawImage(img,
MakeVector2(x, y),
AABB2(16, 0, 16, 16));
}
}
}
}
bool CKeyframe::Load (string dir, string filename) {
if (loaded && loadedfile == filename) return true;
CSPList list (1000);
int i;
string line;
TVector2 pp;
numFrames = 0;
TVector3 posit;
if (list.Load (dir, filename)) {
for (i=0; i<list.Count(); i++) {
line = list.Line (i);
frames[numFrames] = new (TKeyframe2);
frames[numFrames]->val[0] = SPFloatN (line, "time", 0);
posit = SPVector3N (line, "pos", MakeVector (0, 0, 0));
frames[numFrames]->val[1] = posit.x;
frames[numFrames]->val[2] = posit.y;
frames[numFrames]->val[3] = posit.z;
frames[numFrames]->val[4] = SPFloatN (line, "yaw", 0);
frames[numFrames]->val[5] = SPFloatN (line, "pitch", 0);
frames[numFrames]->val[6] = SPFloatN (line, "roll", 0);
frames[numFrames]->val[7] = SPFloatN (line, "neck", 0);
frames[numFrames]->val[8] = SPFloatN (line, "head", 0);
pp = SPVector2N (line, "sh", MakeVector2 (0, 0));
frames[numFrames]->val[9] = pp.x;
frames[numFrames]->val[10] = pp.y;
pp = SPVector2N (line, "arm", MakeVector2 (0, 0));
frames[numFrames]->val[11] = pp.x;
frames[numFrames]->val[12] = pp.y;
pp = SPVector2N (line, "hip", MakeVector2 (0, 0));
frames[numFrames]->val[13] = pp.x;
frames[numFrames]->val[14] = pp.y;
pp = SPVector2N (line, "knee", MakeVector2 (0, 0));
frames[numFrames]->val[15] = pp.x;
frames[numFrames]->val[16] = pp.y;
pp = SPVector2N (line, "ankle", MakeVector2 (0, 0));
frames[numFrames]->val[17] = pp.x;
frames[numFrames]->val[18] = pp.y;
numFrames++;
}
loaded = true;
loadedfile = filename;
return true;
} else {
MessageN ("keyframe not found:", filename);
loaded = false;
return false;
}
}
void HurtRingView::Draw(){
SPADES_MARK_FUNCTION();
Vector3 playerFront;
World *w = client->GetWorld();
if(!w){
ClearAll();
return;
}
Player *p = w->GetLocalPlayer();
if(p == NULL || !p->IsAlive()){
ClearAll();
return;
}
playerFront = p->GetFront2D();
float hurtRingSize = renderer->ScreenHeight() * .3f;
float cx = renderer->ScreenWidth() * .5f;
float cy = renderer->ScreenHeight() * .5f;
static const float coords[][2]={
{-1,-1},{1,-1},{-1,1}
};
std::list<Item>::iterator it;
for(it = items.begin(); it != items.end(); it++){
Item& item = *it;
float fade = item.fade * 2.f;
if(fade > 1.f)fade = 1.f;
Vector4 color = {1,1,1,fade};
renderer->SetColor(color);
Vector3 dir = -item.dir;
float c = dir.x * playerFront.x + dir.y * playerFront.y;
float s = dir.y * playerFront.x - dir.x * playerFront.y;
Vector2 verts[3];
for(int i = 0; i < 3; i++){
verts[i] = MakeVector2(coords[i][0] * c - coords[i][1] * s,
coords[i][0] * s + coords[i][1] * c);
verts[i] = verts[i] * hurtRingSize + MakeVector2(cx, cy);
}
renderer->DrawImage(image,
verts[0], verts[1], verts[2],
AABB2(0, 0, image->GetWidth(), image->GetHeight()));
}
}
void ChatWindow::Draw() {
SPADES_MARK_FUNCTION();
float winX = 4.f;
float winY = killfeed ? 8.f :
(float)renderer->ScreenHeight() * .5f;
std::list<ChatEntry>::iterator it;
float lHeight = GetLineHeight();
float y = firstY;
Vector4 shadowColor = {0, 0, 0, 0.5};
for(it = entries.begin(); it != entries.end(); it++){
ChatEntry& ent = *it;
std::string msg = ent.msg;
Vector4 color = GetColor(MsgColorRestore);
float tx = 0.f, ty = y;
float fade = ent.fade;
if(ent.timeFade < 1.f)
fade *= ent.timeFade;
shadowColor.w = .5f * fade;
color.w *= fade;
for(size_t i = 0; i < msg.size(); i++){
if(msg[i] == 13 || msg[i] == 10){
tx = 0.f; ty += lHeight;
}else if(msg[i] <= MsgColorMax){
color = GetColor(msg[i]);
color.w *= fade;
}else{
std::string ch(&msg[i], 1);
font->Draw(ch,
MakeVector2(tx + winX + 1.f,
ty + winY + 1.f),
1.f, shadowColor);
font->Draw(ch,
MakeVector2(tx + winX,
ty + winY),
1.f, color);
tx += font->Measure(ch).x;
}
}
y += ent.height;
}
}
void break_track_marks (void) {
track_quad_t *qprev, *qprevprev;
qprev = &track_marks.quads[(track_marks.current_mark-1)%MAX_TRACK_MARKS];
qprevprev = &track_marks.quads[(track_marks.current_mark-2)%MAX_TRACK_MARKS];
if (track_marks.current_mark > 0) {
qprev->track_type = TRACK_TAIL;
qprev->t1 = MakeVector2(0.0, 0.0);
qprev->t2 = MakeVector2(1.0, 0.0);
qprev->t3 = MakeVector2(0.0, 1.0);
qprev->t4 = MakeVector2(1.0, 1.0);
qprevprev->t3.y = max((int)(qprevprev->t3.y+0.5), (int)(qprevprev->t1.y+1));
qprevprev->t4.y = max((int)(qprevprev->t3.y+0.5), (int)(qprevprev->t1.y+1));
}
track_marks.last_mark_time = -99999;
track_marks.last_mark_pos = MakeVector(-9999, -9999, -9999);
continuing_track = false;
}
void GameOverMotionFunc (int x, int y) {
TVector2 old_pos;
if (Winsys.ModePending ()) return;
y = param.y_resolution - y;
old_pos = cursor_pos;
cursor_pos = MakeVector2 (x, y);
if (old_pos.x != x || old_pos.y != y) {
}
}
void CreditsMotionFunc (int x, int y ){
TVector2 old_pos;
if (Winsys.ModePending ()) return;
y = param.y_resolution - y;
old_pos = cursor_pos;
cursor_pos = MakeVector2 (x, y);
if (old_pos.x != x || old_pos.y != y) {
if (param.ui_snow) push_ui_snow (cursor_pos);
}
}
void EventMotionFunc (int x, int y ) {
TVector2 old_pos;
int dir, foc;
if (Winsys.ModePending ()) return;
GetFocus (x, y, &foc, &dir); // necessary for drawing the cursor
if (foc >= 0) curr_focus = foc;
y = param.y_resolution - y;
old_pos = cursor_pos;
cursor_pos = MakeVector2 (x, y);
if (old_pos.x != x || old_pos.y != y) {
if (param.ui_snow) push_ui_snow (cursor_pos);
}
}
void GameSelectMotionFunc (int x, int y) {
TVector2 old_pos;
int sc, dir;
if (Winsys.ModePending()) return;
GetFocus (x, y, &sc, &dir);
if (sc >= 0) scope = sc;
y = param.y_resolution - y;
old_pos = cursor_pos;
cursor_pos = MakeVector2 (x, y);
if (old_pos.x != x || old_pos.y != y) {
if (param.ui_snow) push_ui_snow (cursor_pos);
}
}
void CenterMessageView::Draw() {
SPADES_MARK_FUNCTION();
std::list<Entry>::iterator it;
for(it = entries.begin(); it != entries.end(); it++){
Entry& ent = *it;
Vector2 size = font->Measure(ent.msg);
float fade = ent.fade;
if(fade > 1.f)
fade = 1.f;
float y = 100.f + 32.f * (float)ent.line;
float x = (renderer->ScreenWidth() - size.x) * .5f;
Vector4 shadow = {0, 0, 0, fade * 0.5f};
Vector4 color = {1, 1, 1, fade};
font->Draw(ent.msg, MakeVector2(x + 1, y + 1),
1.f, shadow);
font->Draw(ent.msg, MakeVector2(x, y),
1.f, color);
}
}
void MainScreen::DrawStartupScreen() {
SPADES_MARK_FUNCTION();
Handle<client::IImage> img;
Vector2 scrSize = {renderer->ScreenWidth(),
renderer->ScreenHeight()};
renderer->SetColorAlphaPremultiplied(MakeVector4(0, 0, 0, 1.));
img = renderer->RegisterImage("Gfx/White.tga");
renderer->DrawImage(img, AABB2(0, 0,
scrSize.x, scrSize.y));
std::string str = _Tr("MainScreen", "NOW LOADING");
Vector2 size = font->Measure(str);
Vector2 pos = MakeVector2(scrSize.x - 16.f, scrSize.y - 16.f);
pos -= size;
font->DrawShadow(str, pos, 1.f, MakeVector4(1,1,1,1), MakeVector4(0,0,0,0.5));
renderer->FrameDone();
renderer->Flip();
}
void ScoreboardView::DrawPlayers(int team, float left, float top,
float width, float height){
IFont *font = client->textFont;
float rowHeight = 24.f;
char buf[256];
Vector2 size;
Vector4 white = { 1,1,1,1 };
int maxRows = (int)floorf(height / rowHeight);
int numPlayers = 0;
int cols;
std::vector<ScoreboardEntry> entries;
for(int i = 0; i < world->GetNumPlayerSlots(); i++){
Player *p = world->GetPlayer(i);
if(!p) continue;
if(p->GetTeamId() != team)
continue;
ScoreboardEntry ent;
ent.name = p->GetName();
ent.score = world->GetPlayerPersistent(i).kills;
ent.id = i;
entries.push_back(ent);
numPlayers++;
}
std::sort(entries.begin(), entries.end());
cols = (numPlayers + maxRows - 1) / maxRows;
if(cols == 0)cols = 1;
maxRows = (numPlayers + cols - 1) / cols;
int row = 0, col = 0;
float colWidth = (float)width / (float)cols;
for(int i = 0; i < numPlayers; i++){
ScoreboardEntry& ent = entries[i];
float rowY = top + 6.f + row * rowHeight;
float colX = left + width / (float)cols * (float)col;
Vector4 color = white;
if(ent.id == world->GetLocalPlayerIndex())
color = GetTeamColor(team);
sprintf(buf, "#%d", ent.id); // FIXME: 1-base?
size = font->Measure(buf);
font->Draw(buf, MakeVector2(colX + 35.f - size.x,
rowY),
1.f, color);
font->Draw(ent.name, MakeVector2(colX + 45.f,
rowY),
1.f, color);
sprintf(buf, "%d", ent.score);
size = font->Measure(buf);
font->Draw(buf, MakeVector2(colX + colWidth - 10.f - size.x,
rowY),
1.f, color);
row++;
if(row >= maxRows){
col++;
row = 0;
}
}
}
void MapView::Draw(){
World *world = client->GetWorld();
if(!world)
return;
Player *player = world->GetLocalPlayer();
if(client->IsFollowing()){
player = world->GetPlayer(client->followingPlayerId);
}
if(!player)
return;
if(largeMap)
if(zoomState < .0001f)
return;
GameMap *map = world->GetMap();
Vector2 mapSize = MakeVector2(map->Width(), map->Height());
Vector3 pos = player->GetPosition();;
if(player->GetTeamId() >= 2){
pos = client->followPos;
}
Vector2 center = {pos.x, pos.y};
float cfgMapSize = cg_minimapSize;
if(cfgMapSize < 32) cfgMapSize = 32;
if(cfgMapSize > 256) cfgMapSize = 256;
Vector2 mapWndSize = {cfgMapSize, cfgMapSize};
float scale = actualScale;
center = Mix(center,
mapSize * .5f,
zoomState);
Vector2 zoomedSize = {512, 512};
if(renderer->ScreenWidth() < 512.f ||
renderer->ScreenHeight() < 512.f)
zoomedSize = MakeVector2(256, 256);
if(largeMap){
float per = zoomState;
per = 1.f - per;
per *= per;
per = 1.f - per;
per = Mix(.7f, 1.f, per);
zoomedSize = Mix(MakeVector2(0, 0),
zoomedSize,
per);
mapWndSize = zoomedSize;
}
Vector2 inRange = mapWndSize * .5f * scale;
AABB2 inRect(center - inRange, center + inRange);
if(largeMap){
inRect.min = MakeVector2(0, 0);
inRect.max = mapSize;
}else{
if(inRect.GetMinX() < 0.f)
inRect = inRect.Translated(-inRect.GetMinX(), 0.f);
if(inRect.GetMinY() < 0.f)
inRect = inRect.Translated(0, -inRect.GetMinY());
if(inRect.GetMaxX() > mapSize.x)
inRect = inRect.Translated(mapSize.x - inRect.GetMaxX(), 0.f);
if(inRect.GetMaxY() > mapSize.y)
inRect = inRect.Translated(0, mapSize.y - inRect.GetMaxY());
}
AABB2 outRect(renderer->ScreenWidth() - mapWndSize.x - 16.f, 16.f,
mapWndSize.x,
mapWndSize.y);
if(largeMap){
outRect.min = MakeVector2((renderer->ScreenWidth() - zoomedSize.x) * .5f,
(renderer->ScreenHeight() - zoomedSize.y) * .5f);
outRect.max =MakeVector2((renderer->ScreenWidth() + zoomedSize.x) * .5f,
(renderer->ScreenHeight() + zoomedSize.y) * .5f);
}
float alpha = 1.f;
if(largeMap){
alpha = zoomState;
}
// fades bg
if(largeMap) {
Handle<IImage> bg = renderer->RegisterImage("Gfx/MapBg.png");
Vector2 scrSize = {renderer->ScreenWidth(),
renderer->ScreenHeight()};
float size = std::max(scrSize.x, scrSize.y);
renderer->SetColorAlphaPremultiplied(MakeVector4(0, 0, 0,alpha * .5f));
renderer->DrawImage(bg,
AABB2((scrSize.x - size) * .5f,
(scrSize.y - size) * .5f,
size, size));
}
// draw border
Handle<IImage> border;
float borderWidth;
AABB2 borderRect = outRect;
if(largeMap) {
border = renderer->RegisterImage("Gfx/MapBorder.png");
borderWidth = 3.f * outRect.GetHeight() / zoomedSize.y;
}else{
border = renderer->RegisterImage("Gfx/MinimapBorder.png");
borderWidth = 2.f;
}
borderRect = borderRect.Inflate(borderWidth - 8.f);
renderer->SetColorAlphaPremultiplied(MakeVector4(alpha,alpha,alpha,alpha));
renderer->DrawImage(border,
AABB2(borderRect.GetMinX()-16,
borderRect.GetMinY()-16,
16, 16),
AABB2(0, 0, 16, 16));
renderer->DrawImage(border,
AABB2(borderRect.GetMaxX(),
borderRect.GetMinY()-16,
16, 16),
AABB2(16, 0, 16, 16));
renderer->DrawImage(border,
AABB2(borderRect.GetMinX()-16,
borderRect.GetMaxY(),
16, 16),
AABB2(0, 16, 16, 16));
renderer->DrawImage(border,
AABB2(borderRect.GetMaxX(),
borderRect.GetMaxY(),
16, 16),
AABB2(16, 16, 16, 16));
renderer->DrawImage(border,
AABB2(borderRect.GetMinX(),
borderRect.GetMinY()-16,
borderRect.GetWidth(), 16),
AABB2(16, 0, 0, 16));
renderer->DrawImage(border,
AABB2(borderRect.GetMinX(),
borderRect.GetMaxY(),
borderRect.GetWidth(), 16),
AABB2(16, 16, 0, 16));
renderer->DrawImage(border,
AABB2(borderRect.GetMinX()-16,
borderRect.GetMinY(),
16, borderRect.GetHeight()),
AABB2(0, 16, 16, 0));
renderer->DrawImage(border,
AABB2(borderRect.GetMaxX(),
borderRect.GetMinY(),
16, borderRect.GetHeight()),
AABB2(16, 16, 16, 0));
// draw map
renderer->SetColorAlphaPremultiplied(MakeVector4(alpha,alpha,alpha,alpha));
renderer->DrawFlatGameMap(outRect, inRect);
this->inRect = inRect;
this->outRect = outRect;
// draw grid
renderer->SetColorAlphaPremultiplied(MakeVector4(0,0,0,0.8f*alpha));
Handle<IImage> dashLine = renderer->RegisterImage("Gfx/DashLine.tga");
for(float x = 64.f; x < map->Width(); x += 64.f){
float wx = (x - inRect.GetMinX()) / inRect.GetWidth();
if(wx < 0.f || wx >= 1.f)
continue;
wx = (wx * outRect.GetWidth()) + outRect.GetMinX();
wx = roundf(wx);
renderer->DrawImage(dashLine,
MakeVector2(wx, outRect.GetMinY()),
AABB2(0, 0, 1.f, outRect.GetHeight()));
}
for(float y = 64.f; y < map->Height(); y += 64.f){
float wy = (y - inRect.GetMinY()) / inRect.GetHeight();
if(wy < 0.f || wy >= 1.f)
continue;
wy = (wy * outRect.GetHeight()) + outRect.GetMinY();
wy = roundf(wy);
renderer->DrawImage(dashLine,
MakeVector2(outRect.GetMinX(), wy),
AABB2(0, 0, outRect.GetWidth(), 1.f));
}
// draw grid label
renderer->SetColorAlphaPremultiplied(MakeVector4(1,1,1,1)*(0.8f*alpha));
Handle<IImage> mapFont = renderer->RegisterImage("Gfx/Fonts/MapFont.tga");
for(int i = 0; i < 8; i++){
float startX = (float)i * 64.f;
float endX = startX + 64.f;
if(startX > inRect.GetMaxX() ||
endX < inRect.GetMinX())
continue;
float fade = std::min((std::min(endX, inRect.GetMaxX()) -
std::max(startX, inRect.GetMinX())) /
(endX - startX) * 2.f, 1.f);
renderer->SetColorAlphaPremultiplied(MakeVector4(1,1,1,1)*(fade * .8f * alpha));
float center = std::max(startX, inRect.GetMinX());
center = .5f * (center + std::min(endX, inRect.GetMaxX()));
float wx = (center - inRect.GetMinX()) / inRect.GetWidth();
wx = (wx * outRect.GetWidth()) + outRect.GetMinX();
wx = roundf(wx);
float fntX = static_cast<float>((i & 3) * 8);
float fntY = static_cast<float>((i >> 2) * 8);
renderer->DrawImage(mapFont,
MakeVector2(wx - 4.f, outRect.GetMinY() + 4),
AABB2(fntX, fntY, 8, 8));
}
for(int i = 0; i < 8; i++){
float startY = (float)i * 64.f;
float endY = startY + 64.f;
if(startY > inRect.GetMaxY() ||
endY < inRect.GetMinY())
continue;
float fade = std::min((std::min(endY, inRect.GetMaxY()) -
std::max(startY, inRect.GetMinY())) /
(endY - startY) * 2.f, 1.f);
renderer->SetColorAlphaPremultiplied(MakeVector4(1,1,1,1)*(fade * .8f * alpha));
float center = std::max(startY, inRect.GetMinY());
center = .5f * (center + std::min(endY, inRect.GetMaxY()));
float wy = (center - inRect.GetMinY()) / inRect.GetHeight();
wy = (wy * outRect.GetHeight()) + outRect.GetMinY();
wy = roundf(wy);
int fntX = (i & 3) * 8;
int fntY = (i >> 2) * 8 + 16;
renderer->DrawImage(mapFont,
MakeVector2(outRect.GetMinX() + 4, wy - 4.f),
AABB2(fntX, fntY, 8, 8));
}
//draw objects
std::string iconmode = cg_Minimap_Player_Icon;//import variable from configuration file
std::string colormode = cg_Minimap_Player_Color;//import variable from configuration file
Handle<IImage> playerSMG = renderer->RegisterImage("Gfx/Map/SMG.png");
Handle<IImage> playerRifle = renderer->RegisterImage("Gfx/Map/Rifle.png");
Handle<IImage> playerShotgun = renderer->RegisterImage("Gfx/Map/Shotgun.png");
Handle<IImage> playerIcon = renderer->RegisterImage("Gfx/Map/Player.png");
{
IntVector3 teamColor =
world->GetLocalPlayer()->GetTeamId() >= 2 ?
IntVector3::Make(200, 200, 200) :
world->GetTeam(world->GetLocalPlayer()->GetTeamId()).color;
Vector4 teamColorF = ModifyColor(teamColor);
teamColorF *= alpha;
// draw local player's view
{
Player *p = player;
Handle<IImage> viewIcon = renderer->RegisterImage("Gfx/Map/View.png");
if(p->IsAlive()) {
Vector3 front = p->GetFront2D();
float ang = atan2(front.x, -front.y);
if(player->GetTeamId() >= 2){
ang = client->followYaw - static_cast<float>(M_PI) * .5f;
}
renderer->SetColorAlphaPremultiplied(teamColorF * 0.9f);
DrawIcon(player->GetTeamId() >= 2 ?
client->followPos :
p->GetPosition(), viewIcon, ang);
}
}
// draw player's icon
for(int i = 0; i < world->GetNumPlayerSlots(); i++){
Player * p = world->GetPlayer(i);
if(p == nullptr ||
p->GetTeamId() != world->GetLocalPlayer()->GetTeamId() ||
!p->IsAlive())
continue;
Vector3 front = p->GetFront2D();
float ang = atan2(front.x, -front.y);
if(player->GetTeamId() >= 2){
ang = client->followYaw - static_cast<float>(M_PI) * .5f;
}
//use a spec color for each player
if ( colormode=="1"){
IntVector3 Colorplayer=IntVector3::Make(palette[i][0],palette[i][1],palette[i][2]);
Vector4 ColorplayerF = ModifyColor(Colorplayer);
ColorplayerF *=1.0f;
renderer->SetColorAlphaPremultiplied(ColorplayerF);
}
else {
renderer->SetColorAlphaPremultiplied(teamColorF);
}
//use a different icon in minimap according to weapon of player
if( iconmode=="1"){
WeaponType weapon=world->GetPlayer(i)->GetWeaponType();
if (weapon == WeaponType::SMG_WEAPON){
DrawIcon(player->GetTeamId() >= 2 ?
client->followPos :
p->GetPosition(),playerSMG , ang);
}
else if (weapon == WeaponType::RIFLE_WEAPON){
DrawIcon(player->GetTeamId() >= 2 ?
client->followPos :
p->GetPosition(), playerRifle, ang);
}
else if (weapon == WeaponType::SHOTGUN_WEAPON){
DrawIcon(player->GetTeamId() >= 2 ?
client->followPos :
p->GetPosition(), playerShotgun, ang);
}
}
else{//draw normal color
DrawIcon(player->GetTeamId() >= 2 ?
client->followPos :
p->GetPosition(), playerIcon, ang);
}
}
}
IGameMode* mode = world->GetMode();
if( mode && IGameMode::m_CTF == mode->ModeType() ) {
CTFGameMode *ctf = static_cast<CTFGameMode *>(mode);
Handle<IImage> intelIcon = renderer->RegisterImage("Gfx/Map/Intel.png");
Handle<IImage> baseIcon = renderer->RegisterImage("Gfx/Map/CommandPost.png");
for(int tId = 0; tId < 2; tId++){
CTFGameMode::Team& team = ctf->GetTeam(tId);
IntVector3 teamColor = world->GetTeam(tId).color;
Vector4 teamColorF = ModifyColor(teamColor);
teamColorF *= alpha;
// draw base
renderer->SetColorAlphaPremultiplied(teamColorF);
DrawIcon(team.basePos, baseIcon, 0.f);
// draw flag
if(!ctf->GetTeam(1-tId).hasIntel){
renderer->SetColorAlphaPremultiplied(teamColorF);
DrawIcon(team.flagPos, intelIcon, 0.f);
}else if(world->GetLocalPlayer()->GetTeamId() == 1-tId){
// local player's team is carrying
int cId = ctf->GetTeam(1-tId).carrier;
// in some game modes, carrier becomes invalid
if(cId < world->GetNumPlayerSlots()){
Player * carrier= world->GetPlayer(cId);
if(carrier && carrier->GetTeamId() ==
world->GetLocalPlayer()->GetTeamId()){
Vector4 col = teamColorF;
col *= fabsf(sinf(world->GetTime() * 4.f));
renderer->SetColorAlphaPremultiplied(col);
DrawIcon(carrier->GetPosition(), intelIcon, 0.f);
}
}
}
}
} else if( mode && IGameMode::m_TC == mode->ModeType() ) {
TCGameMode *tc = static_cast<TCGameMode *>(mode);
Handle<IImage> icon = renderer->RegisterImage("Gfx/Map/CommandPost.png");
int cnt = tc->GetNumTerritories();
for(int i = 0; i < cnt; i++){
TCGameMode::Territory *t = tc->GetTerritory(i);
IntVector3 teamColor = {128,128,128};
if(t->ownerTeamId < 2){
teamColor = world->GetTeam(t->ownerTeamId).color;
}
Vector4 teamColorF = ModifyColor(teamColor);
teamColorF *= alpha;
// draw base
renderer->SetColorAlphaPremultiplied(teamColorF);
DrawIcon(t->pos, icon, 0.f);
}
}
}
void IFont::DrawShadow( const std::string& message, const Vector2& offset, float scale, const Vector4& color, const Vector4& shadowColor )
{
Draw( message, offset + MakeVector2(1,1), scale, shadowColor );
Draw( message, offset, scale, color );
}
LimboView::LimboView(Client *client):
client(client), renderer(client->GetRenderer()){
// layout now!
float menuWidth = 200.f;
float menuHeight = menuWidth / 8.f;
float rowHeight = menuHeight + 3.f;
float left = (renderer->ScreenWidth() - contentsWidth) * .5f;
float top = renderer->ScreenHeight() - 150.f;
float teamX = left + 10.f;
float firstY = top + 35.f;
items.push_back(MenuItem(MenuTeam1,
AABB2(teamX,
firstY,
menuWidth, menuHeight),
"Team 1"));
items.push_back(MenuItem(MenuTeam2,
AABB2(teamX,
firstY + rowHeight,
menuWidth, menuHeight),
"Team 2")); // TODO: use team name
items.push_back(MenuItem(MenuTeamSpectator,
AABB2(teamX,
firstY + rowHeight * 2.f,
menuWidth, menuHeight),
"Spectator"));
float weapX = left + 260.f;
items.push_back(MenuItem(MenuWeaponRifle,
AABB2(weapX,
firstY,
menuWidth, menuHeight),
"Rifle"));
items.push_back(MenuItem(MenuWeaponSMG,
AABB2(weapX,
firstY + rowHeight,
menuWidth, menuHeight),
"SMG")); // TODO: use team name
items.push_back(MenuItem(MenuWeaponShotgun,
AABB2(weapX,
firstY + rowHeight * 2.f,
menuWidth, menuHeight),
"Shotgun"));
items.push_back(MenuItem(MenuSpawn,
AABB2(left + contentsWidth - 266.f,
firstY + 4.f,
256.f, 64.f),
"Spawn"));
cursorPos = MakeVector2(renderer->ScreenWidth()*.5f,
renderer->ScreenHeight()*.5f);
selectedTeam = 2;
selectedWeapon = RIFLE_WEAPON;
}
void LimboView::Draw() {
Handle<IImage> menuItemImage = renderer->RegisterImage("Gfx/Limbo/MenuItem.tga");
Handle<IImage> menuItemBigImage = renderer->RegisterImage("Gfx/Limbo/BigMenuItem.tga");
//Handle<IImage> menuItemRingImage = renderer->RegisterImage("Gfx/Limbo/MenuItemRing.tga");
IFont *font = client->textFont;
float left = (renderer->ScreenWidth() - contentsWidth) * .5f;
float top = renderer->ScreenHeight() - 150.f;
{
std::string msg = "Select Team:";
Vector2 pos;
pos.x = left + 10.f;
pos.y = top + 10.f;
font->Draw(msg, pos + MakeVector2(0, 1), 1.f, MakeVector4(0,0,0,0.4));
font->Draw(msg, pos, 1.f, MakeVector4(1, 1, 1, 1));
}
if(selectedTeam != 2){
std::string msg = "Select Weapon:";
Vector2 pos;
pos.x = left + 260.f;
pos.y = top + 10.f;
font->Draw(msg, pos + MakeVector2(0, 1), 1.f, MakeVector4(0,0,0,0.4));
font->Draw(msg, pos, 1.f, MakeVector4(1, 1, 1, 1));
}
for(size_t i = 0; i < items.size(); i++){
MenuItem& item = items[i];
bool selected = false;
if(!item.visible)
continue;
switch(item.type){
case MenuTeam1: selected = selectedTeam == 0; break;
case MenuTeam2: selected = selectedTeam == 1; break;
case MenuTeamSpectator: selected = selectedTeam == 2; break;
case MenuWeaponRifle:
selected = selectedWeapon == RIFLE_WEAPON; break;
case MenuWeaponSMG:
selected = selectedWeapon == SMG_WEAPON; break;
case MenuWeaponShotgun:
selected = selectedWeapon == SHOTGUN_WEAPON; break;
default:
selected = false;
}
Vector4 fillColor = {0.2, 0.2, 0.2, 0.5};
Vector4 ringColor = {0, 0, 0, 0};
if(item.hover){
fillColor = MakeVector4(.4f, .4f, .4f, .7f);
ringColor = MakeVector4(.8f, .8f, .8f, .7f);
}
if(selected){
fillColor = MakeVector4(.7f, .7f, .7f, .9f);
}
renderer->SetColor(fillColor);
if(item.type == MenuSpawn){
renderer->DrawImage(menuItemBigImage, item.rect);
std::string msg = item.text;
IFont *bFont = client->textFont;
Vector2 size = bFont->Measure(msg);
Vector2 pos;
pos.x = item.rect.GetMinX() + (item.rect.GetWidth() - size.x) / 2.f + 2.f;
pos.y = item.rect.GetMinY() + (item.rect.GetHeight() - size.y) / 2.f + 2.f;
bFont->Draw(msg, pos + MakeVector2(0, 2), 1.f, MakeVector4(0,0,0,0.4));
bFont->Draw(msg, pos, 1.f, MakeVector4(1, 1, 1, 1));
}else{
renderer->DrawImage(menuItemImage, item.rect);
std::string msg = item.text;
if(item.type == MenuTeam1)
msg = client->GetWorld()->GetTeam(0).name;
if(item.type == MenuTeam2)
msg = client->GetWorld()->GetTeam(1).name;
Vector2 size = font->Measure(msg);
Vector2 pos;
pos.x = item.rect.GetMinX() + 5.f;
pos.y = item.rect.GetMinY() + (item.rect.GetHeight() - size.y) / 2.f + 2.f;
font->Draw(msg, pos + MakeVector2(0, 1), 1.f, MakeVector4(0,0,0,0.4));
font->Draw(msg, pos, 1.f, MakeVector4(1, 1, 1, 1));
}
}
Handle<IImage> cursor = renderer->RegisterImage("Gfx/Limbo/Cursor.tga");
renderer->SetColor(MakeVector4(1, 1, 1, 1));
renderer->DrawImage(cursor, AABB2(cursorPos.x - 8,
cursorPos.y - 8,
32, 32));
}
void ScoreboardView::Draw() {
SPADES_MARK_FUNCTION();
world = client->GetWorld();
if(!world){
// no world
return;
}
ctf = dynamic_cast<CTFGameMode *>(world->GetMode());
tc = dynamic_cast<TCGameMode *>(world->GetMode());
Handle<IImage>image;
IFont *font;
Vector2 pos, size;
char buf[256];
std::string str;
float scrWidth = renderer->ScreenWidth();
float scrHeight = renderer->ScreenHeight();
const Vector4 whiteColor = {1,1,1,1};
Handle<IImage> whiteImage = renderer->RegisterImage("Gfx/White.tga");
float teamBarTop = 120.f;
float teamBarHeight = 60.f;
float contentsLeft = scrWidth * .5f - 400.f;
float contentsRight = scrWidth * .5f + 400.f;
float playersHeight = 300.f;
float playersTop = teamBarTop + teamBarHeight;
float playersBottom = playersTop + playersHeight;
// draw shadow
image = renderer->RegisterImage("Gfx/Scoreboard/TopShadow.tga");
size.y = 32.f;
renderer->SetColor(MakeVector4(0,0,0,0.2f));
renderer->DrawImage(image, AABB2(0, teamBarTop-size.y,
scrWidth, size.y));
renderer->SetColor(MakeVector4(0,0,0,0.2f));
renderer->DrawImage(image, AABB2(0, playersBottom + size.y,
scrWidth, -size.y));
// draw scores
image = renderer->RegisterImage("Gfx/Scoreboard/ScoresBg.tga");
size = MakeVector2(180.f, 32.f);
pos = MakeVector2((scrWidth - size.x) * .5f,
teamBarTop - size.y);
renderer->SetColor(MakeVector4(1.f, .45f, .2f, 1.f));
renderer->DrawImage(image, AABB2(pos.x,pos.y,size.x,size.y));
pos.y = pos.y + 5.f;
font = client->designFont;
sprintf(buf, "%d", GetTeamScore(0));
size = font->Measure(buf);
pos.x = scrWidth * .5f - size.x - 16.f;
font->Draw(buf, pos + MakeVector2(0, 1), 1.f,
MakeVector4(0, 0, 0, 0.3));
font->Draw(buf, pos, 1.f, whiteColor);
sprintf(buf, "%d", GetTeamScore(1));
size = font->Measure(buf);
pos.x = scrWidth * .5f + 16.f;
font->Draw(buf, pos + MakeVector2(0, 1), 1.f,
MakeVector4(0, 0, 0, 0.3));
font->Draw(buf, pos, 1.f, whiteColor);
sprintf(buf, "-");
size = font->Measure(buf);
pos.x = scrWidth * .5f - size.x * .5f;
font->Draw(buf, pos + MakeVector2(0, 1), 1.f,
MakeVector4(0, 0, 0, 0.3));
font->Draw(buf, pos, 1.f, whiteColor);
// draw team bar
image = whiteImage;
renderer->SetColor(AdjustColor(GetTeamColor(0), 0.8f, 0.3f));
renderer->DrawImage(image,
AABB2(0, teamBarTop,
scrWidth * .5f, teamBarHeight));
renderer->SetColor(AdjustColor(GetTeamColor(1), 0.8f, 0.3f));
renderer->DrawImage(image,
AABB2(scrWidth * .5f, teamBarTop,
scrWidth * .5f, teamBarHeight));
image = renderer->RegisterImage("Gfx/Scoreboard/Grunt.tga");
size.x = 120.f; size.y = 60.f;
renderer->DrawImage(image,
AABB2(contentsLeft, teamBarTop + teamBarHeight - size.y,
size.x, size.y));
renderer->DrawImage(image,
AABB2(contentsRight, teamBarTop + teamBarHeight - size.y,
-size.x, size.y));
font = client->bigTextFont;
str = world->GetTeam(0).name;
pos.x = contentsLeft + 110.f;
pos.y = teamBarTop + 5.f;
font->Draw(str, pos + MakeVector2(0, 2), 1.f,
MakeVector4(0, 0, 0, 0.5));
font->Draw(str, pos, 1.f, whiteColor);
str = world->GetTeam(1).name;
size = font->Measure(str);
pos.x = contentsRight - 110.f - size.x;
pos.y = teamBarTop + 5.f;
font->Draw(str, pos + MakeVector2(0, 2), 1.f,
MakeVector4(0, 0, 0, 0.5));
font->Draw(str, pos, 1.f, whiteColor);
// players background
image = renderer->RegisterImage("Gfx/Scoreboard/PlayersBg.tga");
renderer->SetColor(MakeVector4(0, 0, 0, 1.f));
renderer->DrawImage(image,
AABB2(0, playersTop,
scrWidth, playersHeight));
// draw players
DrawPlayers(0, contentsLeft, playersTop,
(contentsRight - contentsLeft) * .5f,
playersHeight);
DrawPlayers(1, scrWidth * .5f, playersTop,
(contentsRight - contentsLeft) * .5f,
playersHeight);
}
// --------------------------------------------------------------------
// add_track_mark
// --------------------------------------------------------------------
void add_track_mark (CControl *ctrl, int *id) {
TVector3 width_vector;
TVector3 left_vector;
TVector3 right_vector;
double magnitude;
track_quad_t *q, *qprev, *qprevprev;
TVector3 vel;
double speed;
TVector3 left_wing, right_wing;
double left_y, right_y;
double dist_from_surface;
TPlane surf_plane;
double comp_depth;
double tex_end;
double dist_from_last_mark;
TVector3 vector_from_last_mark;
TTerrType *TerrList = Course.TerrList;
if (param.perf_level < 3) return;
q = &track_marks.quads[track_marks.current_mark%MAX_TRACK_MARKS];
qprev = &track_marks.quads[(track_marks.current_mark-1)%MAX_TRACK_MARKS];
qprevprev = &track_marks.quads[(track_marks.current_mark-2)%MAX_TRACK_MARKS];
vector_from_last_mark = SubtractVectors (ctrl->cpos, track_marks.last_mark_pos);
dist_from_last_mark = NormVector (&vector_from_last_mark);
*id = Course.GetTerrainIdx (ctrl->cpos.x, ctrl->cpos.z, 0.5);
if (*id < 1) {
break_track_marks();
return;
}
if (TerrList[*id].trackmarks < 1) {
break_track_marks();
return;
}
vel = ctrl->cvel;
speed = NormVector (&vel);
if (speed < SPEED_TO_START_TRENCH) {
break_track_marks();
return;
}
width_vector = CrossProduct (ctrl->cdirection, MakeVector (0, 1, 0));
magnitude = NormVector (&width_vector);
if (magnitude == 0) {
break_track_marks();
return;
}
left_vector = ScaleVector (TRACK_WIDTH/2.0, width_vector);
right_vector = ScaleVector (-TRACK_WIDTH/2.0, width_vector);
left_wing = SubtractVectors (ctrl->cpos, left_vector);
right_wing = SubtractVectors (ctrl->cpos, right_vector);
left_y = Course.FindYCoord (left_wing.x, left_wing.z);
right_y = Course.FindYCoord (right_wing.x, right_wing.z);
if (fabs(left_y-right_y) > MAX_TRACK_DEPTH) {
break_track_marks();
return;
}
surf_plane = Course.GetLocalCoursePlane (ctrl->cpos);
dist_from_surface = DistanceToPlane (surf_plane, ctrl->cpos);
// comp_depth = get_compression_depth(Snow);
comp_depth = 0.1;
if (dist_from_surface >= (2 * comp_depth)) {
break_track_marks();
return;
}
if (!continuing_track) {
break_track_marks();
q->track_type = TRACK_HEAD;
q->v1 = MakeVector (left_wing.x, left_y + TRACK_HEIGHT, left_wing.z);
q->v2 = MakeVector (right_wing.x, right_y + TRACK_HEIGHT, right_wing.z);
q->n1 = Course.FindCourseNormal (q->v1.x, q->v1.z);
q->n2 = Course.FindCourseNormal (q->v2.x, q->v2.z);
q->t1 = MakeVector2(0.0, 0.0);
q->t2 = MakeVector2(1.0, 0.0);
track_marks.next_mark = track_marks.current_mark + 1;
} else {
if (track_marks.next_mark == track_marks.current_mark) {
q->v1 = qprev->v3;
q->v2 = qprev->v4;
q->n1 = qprev->n3;
q->n2 = qprev->n4;
q->t1 = qprev->t3;
q->t2 = qprev->t4;
if (qprev->track_type != TRACK_HEAD) qprev->track_type = TRACK_MARK;
q->track_type = TRACK_MARK;
}
q->v3 = MakeVector (left_wing.x, left_y + TRACK_HEIGHT, left_wing.z);
q->v4 = MakeVector (right_wing.x, right_y + TRACK_HEIGHT, right_wing.z);
q->n3 = Course.FindCourseNormal (q->v3.x, q->v3.z);
q->n4 = Course.FindCourseNormal (q->v4.x, q->v4.z);
tex_end = speed*g_game.time_step/TRACK_WIDTH;
if (q->track_type == TRACK_HEAD) {
q->t3= MakeVector2 (0.0, 1.0);
q->t4= MakeVector2 (1.0, 1.0);
} else {
q->t3 = MakeVector2 (0.0, q->t1.y + tex_end);
q->t4 = MakeVector2 (1.0, q->t2.y + tex_end);
}
track_marks.current_mark++;
track_marks.next_mark = track_marks.current_mark;
}
q->alpha = min ((2*comp_depth-dist_from_surface)/(4*comp_depth), 1.0);
track_marks.last_mark_time = g_game.time;
continuing_track = true;
}
GLColorBuffer GLDepthOfFieldFilter::Filter(GLColorBuffer input, float blurDepthRange, float vignetteBlur, float globalBlur) {
SPADES_MARK_FUNCTION();
IGLDevice *dev = renderer->GetGLDevice();
GLQuadRenderer qr(dev);
int w = dev->ScreenWidth();
int h = dev->ScreenHeight();
dev->Enable(IGLDevice::Blend, false);
GLColorBuffer coc;
globalBlur = std::min(globalBlur * 3.f, 1.f);
{
GLProfiler p(dev, "CoC Computation");
coc = GenerateCoC(blurDepthRange, vignetteBlur, globalBlur);
}
float maxCoc = (float)std::max(w, h) / 100.f;
float cos60 = cosf(static_cast<float>(M_PI) / 3.f);
float sin60 = sinf(static_cast<float>(M_PI) / 3.f);
maxCoc *= .7f + vignetteBlur * 0.5f;
maxCoc *= 1.f + 3.f * globalBlur;
// reduce resolution to make it faster
int divide = 1;
int siz = std::max(w, h);
GLColorBuffer lowbuf = input;
while(siz >= 768) {
divide <<= 1;
siz >>= 1;
lowbuf = UnderSample(lowbuf);
}
maxCoc /= (float)divide;
dev->Viewport(0, 0, w / divide, h / divide);
GLColorBuffer buf1, buf2;
{
GLProfiler p(dev, "Blur 1");
buf1 = Blur(lowbuf, coc,
MakeVector2(0.f, -1.f) * maxCoc);
}
{
GLProfiler p(dev, "Blur 2");
buf2 = Blur(lowbuf, coc,
MakeVector2(-sin60, cos60) * maxCoc);
lowbuf.Release();
}
{
GLProfiler p(dev, "Mix 1");
buf2 = AddMix(buf1, buf2);
}
//return buf2;
{
GLProfiler p(dev, "Blur 3");
buf1 = Blur(buf1, coc,
MakeVector2(-sin60, cos60) * maxCoc);
}
{
GLProfiler p(dev, "Blur 4");
buf2 = Blur(buf2, coc,
MakeVector2(sin60, cos60) * maxCoc);
}
dev->Viewport(0, 0, w, h);
{
GLProfiler p(dev, "Mix 2");
GLColorBuffer output = FinalMix(input,
buf1, buf2,
coc);
return output;
}
}
