/**
** Draw message(s).
*/
void MessagesDisplay::DrawMessages()
{
// background so the text is easier to read
if (MessagesCount) {
Uint32 color = Video.MapRGB(TheScreen->format, 38, 38, 78);
Video.FillTransRectangleClip(color, UI.MapArea.X + 8, UI.MapArea.Y + 8,
UI.MapArea.EndX - UI.MapArea.X - 16, MessagesCount * (UI.MessageFont->Height() + 1) - MessagesScrollY, 0x80);
}
// Draw message line(s)
for (int z = 0; z < MessagesCount; ++z) {
if (z == 0) {
PushClipping();
SetClipping(UI.MapArea.X + 8, UI.MapArea.Y + 8, Video.Width - 1,
Video.Height - 1);
}
VideoDrawTextClip(UI.MapArea.X + 8,
UI.MapArea.Y + 8 + z * (UI.MessageFont->Height() + 1) - MessagesScrollY,
UI.MessageFont, Messages[z]);
if (z == 0) {
PopClipping();
}
}
if (MessagesCount < 1) {
MessagesSameCount = 0;
}
}
/**
** Draw status line.
*/
void CStatusLine::Draw()
{
if (!this->StatusLine.empty()) {
PushClipping();
SetClipping(this->TextX, this->TextY,
this->TextX + this->Width - 1, Video.Height - 1);
CLabel(*this->Font).DrawClip(this->TextX, this->TextY, this->StatusLine);
PopClipping();
}
}
/**
** Draw status line.
*/
void CStatusLine::Draw(void)
{
if (!this->StatusLine.empty()) {
PushClipping();
SetClipping(this->TextX, this->TextY,
this->TextX + this->Width - 1, Video.Height - 1);
VideoDrawTextClip(this->TextX, this->TextY, this->Font,
this->StatusLine);
PopClipping();
}
}
void CFont::drawString(gcn::Graphics *graphics, const std::string &txt,
int x, int y)
{
const gcn::ClipRectangle &r = graphics->getCurrentClipArea();
int right = std::min(r.x + r.width - 1, Video.Width - 1);
int bottom = std::min(r.y + r.height - 1, Video.Height - 1);
if (r.x > right || r.y > bottom) {
return;
}
PushClipping();
SetClipping(r.x, r.y, right, bottom);
VideoDrawTextClip(x + r.xOffset, y + r.yOffset, this, txt);
PopClipping();
}
/* virtual */ void CFont::drawString(gcn::Graphics *graphics, const std::string &txt, int x, int y)
{
DynamicLoad();
const gcn::ClipRectangle &r = graphics->getCurrentClipArea();
int right = std::min<int>(r.x + r.width - 1, Video.Width - 1);
int bottom = std::min<int>(r.y + r.height - 1, Video.Height - 1);
if (r.x > right || r.y > bottom) {
return;
}
PushClipping();
SetClipping(r.x, r.y, right, bottom);
CLabel(*this).DrawClip(x + r.xOffset, y + r.yOffset, txt);
PopClipping();
}
/**
** Draw message(s).
**
** @todo FIXME: make message font configurable.
*/
void DrawMessages(void)
{
// Draw message line(s)
for (int z = 0; z < MessagesCount; ++z) {
if (z == 0) {
PushClipping();
SetClipping(UI.MapArea.X + 8, UI.MapArea.Y + 8, Video.Width - 1,
Video.Height - 1);
}
VideoDrawTextClip(UI.MapArea.X + 8,
UI.MapArea.Y + 8 + z * (GameFont->Height() + 1) - MessagesScrollY,
GameFont, Messages[z]);
if (z == 0) {
PopClipping();
}
}
if (MessagesCount < 1) {
MessagesSameCount = 0;
}
}
void nuiGLDrawContext::DrawGradient(const nuiGradient& rGradient, const nuiRect& rEnclosingRect, nuiSize x1, nuiSize y1, nuiSize x2, nuiSize y2)
{
nglVector2f vec(x2 - x1, y2 - y1);
nglVector2f para(-vec[1], vec[0]);
nglVector2f vec1(vec);
nglVector2f para1(para);
vec1.Normalize();
para1.Normalize();
// What Quadrant are we in?:
// |
// a | b
// |
// ----------------
// |
// c | d
// |
float xa, xb, xc, xd;
float ya, yb, yc, yd;
float x, y;
float xp, yp;
float xx, yy;
float xxp, yyp;
xa = xc = rEnclosingRect.Left();
xb = xd = rEnclosingRect.Right();
ya = yb = rEnclosingRect.Top();
yc = yd = rEnclosingRect.Bottom();
if (x1 < x2)
{
// Go from a to d or c to b
if (y1 == y2)
{
x = xa; y = ya;
xp = xc; yp = yc;
xx = xd; yy = yd;
xxp= xb; yyp= yb;
}
else if (y1 < y2)
{
// a to d
IntersectLines(xa,ya, para1[0], para1[1], xb, yb, vec1[0], vec1[1], x, y);
IntersectLines(xa,ya, para1[0], para1[1], xc, yc, vec1[0], vec1[1], xp, yp);
IntersectLines(xd,yd, para1[0], para1[1], xc, yc, vec1[0], vec1[1], xx, yy);
IntersectLines(xd,yd, para1[0], para1[1], xb, yb, vec1[0], vec1[1], xxp, yyp);
}
else
{
// c to d
IntersectLines(xc,yc, para1[0], para1[1], xa, ya, vec1[0], vec1[1], x, y);
IntersectLines(xc,yc, para1[0], para1[1], xd, yd, vec1[0], vec1[1], xp, yp);
IntersectLines(xb,yb, para1[0], para1[1], xd, yd, vec1[0], vec1[1], xx, yy);
IntersectLines(xb,yb, para1[0], para1[1], xa, ya, vec1[0], vec1[1], xxp, yyp);
}
}
else
{
if (y1 == y2)
{
x = xd; y = yd;
xp = xb; yp = yb;
xx = xa; yy = ya;
xxp= xc; yyp= yc;
}
else if (y1 < y2)
{
// b to c
IntersectLines(xb,yb, para1[0], para1[1], xd, yd, vec1[0], vec1[1], x, y);
IntersectLines(xb,yb, para1[0], para1[1], xa, ya, vec1[0], vec1[1], xp, yp);
IntersectLines(xc,yc, para1[0], para1[1], xa, ya, vec1[0], vec1[1], xx, yy);
IntersectLines(xc,yc, para1[0], para1[1], xd, yd, vec1[0], vec1[1], xxp, yyp);
}
else
{
// d to a
IntersectLines(xd,yd, para1[0], para1[1], xc, yc, vec1[0], vec1[1], x, y);
IntersectLines(xd,yd, para1[0], para1[1], xb, yb, vec1[0], vec1[1], xp, yp);
IntersectLines(xa,ya, para1[0], para1[1], xb, yb, vec1[0], vec1[1], xx, yy);
IntersectLines(xa,ya, para1[0], para1[1], xc, yc, vec1[0], vec1[1], xxp, yyp);
}
}
float startx,starty;
float startxp,startyp;
float stopx,stopy;
float stopxp,stopyp;
if (y1 != y2)
{
IntersectLines(x1, y1, para1[0], para1[1], x, y, vec1[0], vec1[1], startx, starty);
IntersectLines(x1, y1, para1[0], para1[1], xp, yp, vec1[0], vec1[1], startxp, startyp);
IntersectLines(x2, y2, para1[0], para1[1], x, y, vec1[0], vec1[1], stopx, stopy);
IntersectLines(x2, y2, para1[0], para1[1], xp, yp, vec1[0], vec1[1], stopxp, stopyp);
}
else
{
startx = x1; starty = y;
startxp = x1; startyp = yp;
stopx = x2; stopy = y;
stopxp = x2; stopyp = yp;
}
nuiGradientStopList::const_iterator it = rGradient.GetStopList().begin();
nuiGradientStopList::const_iterator end = rGradient.GetStopList().end();
float px1, py1;
float px2, py2;
PushClipping();
nuiRect r = rEnclosingRect;
nglMatrixf m(GetMatrix());
nglVectorf v1(r.Left(), r.Top(), 0);
v1 = m * v1;
nglVectorf v2 = nglVectorf(r.Right(), r.Bottom(), 0);
v2 = m * v2;
r.Set(v1[0], v1[1], v2[0], v2[1], false);
Clip(r);
SetClipping(true);
std::vector<nuiShape::CacheElement::Vertex> vertices;
nuiColor col = it->second;
vertices.push_back(nuiShape::CacheElement::Vertex(x, y, col));
vertices.push_back(nuiShape::CacheElement::Vertex(xp, yp, col));
for ( ; it != end; ++it)
{
float r = it->first;
float rm = 1.0f - r;
px1 = startx * rm + stopx * r;
py1 = starty * rm + stopy * r;
px2 = startxp * rm + stopxp * r;
py2 = startyp * rm + stopyp * r;
col = it->second;
vertices.push_back(nuiShape::CacheElement::Vertex(px1, py1, col));
vertices.push_back(nuiShape::CacheElement::Vertex(px2, py2, col));
}
vertices.push_back(nuiShape::CacheElement::Vertex(xxp, yyp, col));
vertices.push_back(nuiShape::CacheElement::Vertex(xx, yy, col));
glEnableClientState(GL_COLOR_ARRAY);
glEnableClientState(GL_VERTEX_ARRAY);
glColorPointer(4, GL_FLOAT, sizeof(nuiShape::CacheElement::Vertex), vertices[0].mColor);
glVertexPointer(3, GL_FLOAT, sizeof(nuiShape::CacheElement::Vertex), vertices[0].mCoord);
glDrawArrays(GL_QUAD_STRIP, 0, vertices.size());
glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
PopClipping();
}
/**
** Draw a map viewport.
*/
void CViewport::Draw() const
{
PushClipping();
this->SetClipping();
/* this may take while */
this->DrawMapBackgroundInViewport();
CurrentViewport = this;
{
// Now we need to sort units, missiles, particles by draw level and draw them
std::vector<CUnit *> unittable;
std::vector<Missile *> missiletable;
std::vector<CParticle *> particletable;
FindAndSortUnits(*this, unittable);
const size_t nunits = unittable.size();
FindAndSortMissiles(*this, missiletable);
const size_t nmissiles = missiletable.size();
ParticleManager.prepareToDraw(*this, particletable);
const size_t nparticles = particletable.size();
size_t i = 0;
size_t j = 0;
size_t k = 0;
while ((i < nunits && j < nmissiles) || (i < nunits && k < nparticles)
|| (j < nmissiles && k < nparticles)) {
if (i == nunits) {
if (missiletable[j]->Type->DrawLevel < particletable[k]->getDrawLevel()) {
missiletable[j]->DrawMissile(*this);
++j;
} else {
particletable[k]->draw();
++k;
}
} else if (j == nmissiles) {
if (unittable[i]->Type->DrawLevel < particletable[k]->getDrawLevel()) {
unittable[i]->Draw(*this);
++i;
} else {
particletable[k]->draw();
++k;
}
} else if (k == nparticles) {
if (unittable[i]->Type->DrawLevel < missiletable[j]->Type->DrawLevel) {
unittable[i]->Draw(*this);
++i;
} else {
missiletable[j]->DrawMissile(*this);
++j;
}
} else {
if (unittable[i]->Type->DrawLevel <= missiletable[j]->Type->DrawLevel) {
if (unittable[i]->Type->DrawLevel < particletable[k]->getDrawLevel()) {
unittable[i]->Draw(*this);
++i;
} else {
particletable[k]->draw();
++k;
}
} else {
if (missiletable[j]->Type->DrawLevel < particletable[k]->getDrawLevel()) {
missiletable[j]->DrawMissile(*this);
++j;
} else {
particletable[k]->draw();
++k;
}
}
}
}
for (; i < nunits; ++i) {
unittable[i]->Draw(*this);
}
for (; j < nmissiles; ++j) {
missiletable[j]->DrawMissile(*this);
}
for (; k < nparticles; ++k) {
particletable[k]->draw();
}
ParticleManager.endDraw();
//Wyrmgus start
//draw fog of war below the "click missile"
this->DrawMapFogOfWar();
j = 0;
for (; j < nmissiles; ++j) {
if (!ClickMissile.empty() && ClickMissile == missiletable[j]->Type->Ident) {
missiletable[j]->DrawMissile(*this); //draw click missile again to make it appear on top of the fog of war
}
}
//Wyrmgus end
}
//Wyrmgus start
// this->DrawMapFogOfWar();
//Wyrmgus end
//
// Draw orders of selected units.
// Drawn here so that they are shown even when the unit is out of the screen.
//
if (!Preference.ShowOrders) {
} else if (Preference.ShowOrders < 0
|| (ShowOrdersCount >= GameCycle) || (KeyModifiers & ModifierShift)) {
for (size_t i = 0; i != Selected.size(); ++i) {
ShowOrder(*Selected[i]);
}
}
//Wyrmgus start
//if a selected unit has a rally point, show it
//better to not show it all the time, so that there's no clutter
/*
for (size_t i = 0; i != Selected.size(); ++i) {
if (!Selected[i]Destroyed && !Selected[i]Removed && Selected[i]->RallyPointPos.x != -1 && Selected[i]->RallyPointPos.y != -1) {
Video.FillCircleClip(ColorGreen, CurrentViewport->TilePosToScreen_Center(Selected[i]->RallyPointPos), 3);
}
}
*/
//Wyrmgus end
//
// Draw unit's name popup
//
//Wyrmgus start
/*
//Wyrmgus start
// if (CursorOn == CursorOnMap && Preference.ShowNameDelay && (ShowNameDelay < GameCycle) && (GameCycle < ShowNameTime)) {
if (CursorOn == CursorOnMap && (!Preference.ShowNameDelay || ShowNameDelay < GameCycle) && (!Preference.ShowNameTime || GameCycle < ShowNameTime)) {
//Wyrmgus end
const Vec2i tilePos = this->ScreenToTilePos(CursorScreenPos);
//Wyrmgus start
// const bool isMapFieldVisile = Map.Field(tilePos)->playerInfo.IsTeamVisible(*ThisPlayer);
const bool isMapFieldVisile = Map.Field(tilePos, UI.CurrentMapLayer->ID)->playerInfo.IsTeamVisible(*ThisPlayer);
//Wyrmgus end
if (UI.MouseViewport->IsInsideMapArea(CursorScreenPos) && UnitUnderCursor
//Wyrmgus start
// && ((isMapFieldVisile && !UnitUnderCursor->Type->BoolFlag[ISNOTSELECTABLE_INDEX].value) || ReplayRevealMap)) {
&& ((isMapFieldVisile && !UnitUnderCursor->Type->BoolFlag[ISNOTSELECTABLE_INDEX].value) || ReplayRevealMap) && UnitUnderCursor->IsAliveOnMap()) {
// ShowUnitName(*this, CursorScreenPos, UnitUnderCursor);
PixelPos unit_center_pos = Map.TilePosToMapPixelPos_TopLeft(UnitUnderCursor->tilePos, UnitUnderCursor->MapLayer);
unit_center_pos = MapToScreenPixelPos(unit_center_pos);
std::string unit_name;
if (UnitUnderCursor->Unique || UnitUnderCursor->Prefix || UnitUnderCursor->Suffix || UnitUnderCursor->Work || UnitUnderCursor->Elixir || UnitUnderCursor->Spell || UnitUnderCursor->Character != nullptr) {
if (!UnitUnderCursor->Identified) {
unit_name = UnitUnderCursor->GetTypeName() + " (" + _("Unidentified") + ")";
} else {
unit_name = UnitUnderCursor->GetName();
}
} else {
unit_name = UnitUnderCursor->GetTypeName();
}
if (UnitUnderCursor->Player->Index != PlayerNumNeutral) {
unit_name += " (" + UnitUnderCursor->Player->Name + ")";
}
//hackish way to make the popup appear correctly for the unit under cursor
ButtonAction *ba = new ButtonAction;
ba->Hint = unit_name;
ba->Action = ButtonUnit;
ba->Value = UnitNumber(*UnitUnderCursor);
ba->Popup = "popup-unit-under-cursor";
DrawPopup(*ba, unit_center_pos.x, unit_center_pos.y);
delete ba;
LastDrawnButtonPopup = nullptr;
//Wyrmgus end
//Wyrmgus start
// } else if (!isMapFieldVisile) {
// ShowUnitName(*this, CursorScreenPos, nullptr, true);
//Wyrmgus end
}
}
*/
//Wyrmgus end
DrawBorder();
PopClipping();
}
/**
** Draw cursor for selecting building position.
*/
local void DrawBuildingCursor(void)
{
int x;
int y;
int x1;
int y1;
int mx;
int my;
int color;
int f;
int w;
int w0;
int h;
int mask;
const Viewport* vp;
// Align to grid
vp = TheUI.MouseViewport;
x=CursorX-(CursorX - vp->X)%TileSizeX;
y=CursorY-(CursorY - vp->Y)%TileSizeY;
BuildingCursorSX = mx = Viewport2MapX(vp, x);
BuildingCursorSY = my = Viewport2MapY(vp, y);
//
// Draw building
//
PushClipping();
SetClipping(vp->X, vp->Y, vp->EndX, vp->EndY);
GraphicPlayerPixels(ThisPlayer,CursorBuilding->Sprite);
if( VideoGraphicFrames(CursorBuilding->Sprite)>5 ) {
DrawUnitType(CursorBuilding,4,x,y);
} else {
DrawUnitType(CursorBuilding,0,x,y);
}
PopClipping();
//
// Draw the allow overlay
//
f=CanBuildHere(CursorBuilding,mx,my);
mask = CursorBuilding->MovementMask;
h=CursorBuilding->TileHeight;
BuildingCursorEY=my+h-1;
if (my+h > vp->MapY + vp->MapHeight) { // reduce to view limits
h = vp->MapY + vp->MapHeight - my;
}
w0 = CursorBuilding->TileWidth; // reduce to view limits
BuildingCursorEX=mx+w0-1;
if (mx+w0 > vp->MapX + vp->MapWidth) {
w0 = vp->MapX + vp->MapWidth - mx;
}
while( h-- ) {
w=w0;
while( w-- ) {
int basex, basey;
// FIXME: The field is covered by fog of war!
if( f && CanBuildOn(mx+w,my+h,mask &
((Selected[0]
&& Selected[0]->X==mx+w && Selected[0]->Y==my+h)
? ~(MapFieldLandUnit|MapFieldSeaUnit) : -1))
&& IsMapFieldExplored(ThisPlayer,mx+w,my+h) ) {
color=ColorGreen;
} else {
color=ColorRed;
}
// FIXME: I could do this faster+better
/* latimerius: I'm not sure what you have in mind but I can
* at least move invariants out of the loops. */
basex = x + w*TileSizeX;
basey = y + h*TileSizeY;
for( y1=0; y1<TileSizeY; ++y1 ) {
int j = basey+y1;
for( x1=y1&1; x1<TileSizeX; x1+=2 ) {
int i = basex+x1;
if (i > vp->EndX)
break;
VideoDrawPixel (color, i, j);
}
if (j > vp->EndY)
break;
}
}
}
}
/**
** Draw message(s).
**
** @todo FIXME: make message font configurable.
*/
void MessagesDisplay::DrawMessages()
{
if (show && Preference.ShowMessages) {
CLabel label(*UI.MessageFont);
#ifdef DEBUG
if (showBuilList && ThisPlayer->Ai) {
char buffer[256];
int count = ThisPlayer->Ai->UnitTypeBuilt.size();
// Draw message line(s)
for (int z = 0; z < count; ++z) {
if (z == 0) {
PushClipping();
SetClipping(UI.MapArea.X + 8, UI.MapArea.Y + 8,
Video.Width - 1, Video.Height - 1);
}
snprintf(buffer, 256, "%s (%d/%d) Wait %lu [%d,%d]",
ThisPlayer->Ai->UnitTypeBuilt[z].Type->Name.c_str(),
ThisPlayer->Ai->UnitTypeBuilt[z].Made,
ThisPlayer->Ai->UnitTypeBuilt[z].Want,
ThisPlayer->Ai->UnitTypeBuilt[z].Wait,
ThisPlayer->Ai->UnitTypeBuilt[z].Pos.x,
ThisPlayer->Ai->UnitTypeBuilt[z].Pos.y);
label.DrawClip(UI.MapArea.X + 8,
UI.MapArea.Y + 8 + z * (UI.MessageFont->Height() + 1),
buffer);
if (z == 0) {
PopClipping();
}
}
} else {
#endif
// background so the text is easier to read
if (MessagesCount) {
int textHeight = MessagesCount * (UI.MessageFont->Height() + 1);
Uint32 color = Video.MapRGB(TheScreen->format, 38, 38, 78);
Video.FillTransRectangleClip(color, UI.MapArea.X + 7, UI.MapArea.Y + 7,
UI.MapArea.EndX - UI.MapArea.X - 16,
textHeight - MessagesScrollY + 1, 0x80);
Video.DrawRectangle(color, UI.MapArea.X + 6, UI.MapArea.Y + 6,
UI.MapArea.EndX - UI.MapArea.X - 15,
textHeight - MessagesScrollY + 2);
}
// Draw message line(s)
for (int z = 0; z < MessagesCount; ++z) {
if (z == 0) {
PushClipping();
SetClipping(UI.MapArea.X + 8, UI.MapArea.Y + 8, Video.Width - 1,
Video.Height - 1);
}
/*
* Due parallel drawing we have to force message copy due temp
* std::string(Messages[z]) creation because
* char * pointer may change during text drawing.
*/
label.DrawClip(UI.MapArea.X + 8,
UI.MapArea.Y + 8 +
z * (UI.MessageFont->Height() + 1) - MessagesScrollY,
std::string(Messages[z]));
if (z == 0) {
PopClipping();
}
}
if (MessagesCount < 1) {
MessagesSameCount = 0;
}
#ifdef DEBUG
}
#endif
}
}
void nuiDrawContext::DrawGradient(const nuiGradient& rGradient, const nuiRect& rEnclosingRect, nuiSize x1, nuiSize y1, nuiSize x2, nuiSize y2)
{
nuiVector2 vec(x2 - x1, y2 - y1);
nuiVector2 para(-vec[1], vec[0]);
nuiVector2 vec1(vec);
nuiVector2 para1(para);
vec1.Normalize();
para1.Normalize();
// What Quadrant are we in?:
// |
// a | b
// |
// ----------------
// |
// c | d
// |
float xa, xb, xc, xd;
float ya, yb, yc, yd;
float x, y;
float xp, yp;
float xx, yy;
float xxp, yyp;
xa = xc = rEnclosingRect.Left();
xb = xd = rEnclosingRect.Right();
ya = yb = rEnclosingRect.Top();
yc = yd = rEnclosingRect.Bottom();
if (x1 < x2)
{
// Go from a to d or c to b
if (y1 == y2)
{
x = xa; y = ya;
xp = xc; yp = yc;
xx = xd; yy = yd;
xxp= xb; yyp= yb;
}
else if (y1 < y2)
{
// a to d
IntersectLines(xa,ya, para1[0], para1[1], xb, yb, vec1[0], vec1[1], x, y);
IntersectLines(xa,ya, para1[0], para1[1], xc, yc, vec1[0], vec1[1], xp, yp);
IntersectLines(xd,yd, para1[0], para1[1], xc, yc, vec1[0], vec1[1], xx, yy);
IntersectLines(xd,yd, para1[0], para1[1], xb, yb, vec1[0], vec1[1], xxp, yyp);
}
else
{
// c to d
IntersectLines(xc,yc, para1[0], para1[1], xa, ya, vec1[0], vec1[1], x, y);
IntersectLines(xc,yc, para1[0], para1[1], xd, yd, vec1[0], vec1[1], xp, yp);
IntersectLines(xb,yb, para1[0], para1[1], xd, yd, vec1[0], vec1[1], xx, yy);
IntersectLines(xb,yb, para1[0], para1[1], xa, ya, vec1[0], vec1[1], xxp, yyp);
}
}
else
{
if (y1 == y2)
{
x = xd; y = yd;
xp = xb; yp = yb;
xx = xa; yy = ya;
xxp= xc; yyp= yc;
}
else if (y1 < y2)
{
// b to c
IntersectLines(xb,yb, para1[0], para1[1], xd, yd, vec1[0], vec1[1], x, y);
IntersectLines(xb,yb, para1[0], para1[1], xa, ya, vec1[0], vec1[1], xp, yp);
IntersectLines(xc,yc, para1[0], para1[1], xa, ya, vec1[0], vec1[1], xx, yy);
IntersectLines(xc,yc, para1[0], para1[1], xd, yd, vec1[0], vec1[1], xxp, yyp);
}
else
{
// d to a
IntersectLines(xd,yd, para1[0], para1[1], xc, yc, vec1[0], vec1[1], x, y);
IntersectLines(xd,yd, para1[0], para1[1], xb, yb, vec1[0], vec1[1], xp, yp);
IntersectLines(xa,ya, para1[0], para1[1], xb, yb, vec1[0], vec1[1], xx, yy);
IntersectLines(xa,ya, para1[0], para1[1], xc, yc, vec1[0], vec1[1], xxp, yyp);
}
}
float startx,starty;
float startxp,startyp;
float stopx,stopy;
float stopxp,stopyp;
if (y1 != y2)
{
IntersectLines(x1, y1, para1[0], para1[1], x, y, vec1[0], vec1[1], startx, starty);
IntersectLines(x1, y1, para1[0], para1[1], xp, yp, vec1[0], vec1[1], startxp, startyp);
IntersectLines(x2, y2, para1[0], para1[1], x, y, vec1[0], vec1[1], stopx, stopy);
IntersectLines(x2, y2, para1[0], para1[1], xp, yp, vec1[0], vec1[1], stopxp, stopyp);
}
else
{
startx = x1; starty = y;
startxp = x1; startyp = yp;
stopx = x2; stopy = y;
stopxp = x2; stopyp = yp;
}
nuiGradientStopList::const_iterator it = rGradient.GetStopList().begin();
nuiGradientStopList::const_iterator end = rGradient.GetStopList().end();
float px1, py1;
float px2, py2;
PushClipping();
Clip(rEnclosingRect);
EnableClipping(true);
nuiRenderArray* pArray = new nuiRenderArray(GL_TRIANGLE_STRIP);
pArray->EnableArray(nuiRenderArray::eVertex);
pArray->EnableArray(nuiRenderArray::eColor);
// nuiRenderArray Array(GL_LINES);
// pArray->SetVertexElements(3);
// pArray->SetColorElements(4);
nuiColor col = it->second;
pArray->SetVertex(x, y);
pArray->SetColor(col);
pArray->PushVertex();
pArray->SetVertex(xp, yp);
pArray->PushVertex();
for ( ; it != end; ++it)
{
float r = it->first;
float rm = 1.0f - r;
px1 = startx * rm + stopx * r;
py1 = starty * rm + stopy * r;
px2 = startxp * rm + stopxp * r;
py2 = startyp * rm + stopyp * r;
col = it->second;
pArray->SetColor(col);
pArray->SetVertex(px2, py2);
pArray->PushVertex();
pArray->SetVertex(px1, py1);
pArray->PushVertex();
}
pArray->SetVertex(xx, yy);
pArray->PushVertex();
pArray->SetVertex(xxp, yyp);
pArray->PushVertex();
DrawArray(pArray);
PopClipping();
}
/**
** Draw a map viewport.
*/
void CViewport::Draw() const
{
PushClipping();
this->SetClipping();
/* this may take while */
this->DrawMapBackgroundInViewport();
CurrentViewport = this;
{
// Now we need to sort units, missiles, particles by draw level and draw them
std::vector<CUnit *> unittable;
std::vector<Missile *> missiletable;
std::vector<CParticle *> particletable;
FindAndSortUnits(*this, unittable);
const size_t nunits = unittable.size();
FindAndSortMissiles(*this, missiletable);
const size_t nmissiles = missiletable.size();
ParticleManager.prepareToDraw(*this, particletable);
const size_t nparticles = particletable.size();
size_t i = 0;
size_t j = 0;
size_t k = 0;
while ((i < nunits && j < nmissiles) || (i < nunits && k < nparticles)
|| (j < nmissiles && k < nparticles)) {
if (i == nunits) {
if (missiletable[j]->Type->DrawLevel < particletable[k]->getDrawLevel()) {
missiletable[j]->DrawMissile(*this);
++j;
} else {
particletable[k]->draw();
++k;
}
} else if (j == nmissiles) {
if (unittable[i]->Type->DrawLevel < particletable[k]->getDrawLevel()) {
unittable[i]->Draw(*this);
++i;
} else {
particletable[k]->draw();
++k;
}
} else if (k == nparticles) {
if (unittable[i]->Type->DrawLevel < missiletable[j]->Type->DrawLevel) {
unittable[i]->Draw(*this);
++i;
} else {
missiletable[j]->DrawMissile(*this);
++j;
}
} else {
if (unittable[i]->Type->DrawLevel <= missiletable[j]->Type->DrawLevel) {
if (unittable[i]->Type->DrawLevel < particletable[k]->getDrawLevel()) {
unittable[i]->Draw(*this);
++i;
} else {
particletable[k]->draw();
++k;
}
} else {
if (missiletable[j]->Type->DrawLevel < particletable[k]->getDrawLevel()) {
missiletable[j]->DrawMissile(*this);
++j;
} else {
particletable[k]->draw();
++k;
}
}
}
}
for (; i < nunits; ++i) {
unittable[i]->Draw(*this);
}
for (; j < nmissiles; ++j) {
missiletable[j]->DrawMissile(*this);
}
for (; k < nparticles; ++k) {
particletable[k]->draw();
}
ParticleManager.endDraw();
}
this->DrawMapFogOfWar();
//
// Draw orders of selected units.
// Drawn here so that they are shown even when the unit is out of the screen.
//
if (!Preference.ShowOrders) {
} else if (Preference.ShowOrders < 0
|| (ShowOrdersCount >= GameCycle) || (KeyModifiers & ModifierShift)) {
for (int i = 0; i < NumSelected; ++i) {
ShowOrder(*Selected[i]);
}
}
//
// Draw unit's name popup
//
if (CursorOn == CursorOnMap && Preference.ShowNameDelay && (ShowNameDelay < GameCycle) && (GameCycle < ShowNameTime)) {
const Vec2i tilePos = this->ScreenToTilePos(CursorScreenPos);
const bool isMapFieldVisile = Map.Field(tilePos)->playerInfo.IsTeamVisible(*ThisPlayer);
if (UI.MouseViewport->IsInsideMapArea(CursorScreenPos) && UnitUnderCursor
&& ((isMapFieldVisile && !UnitUnderCursor->Type->BoolFlag[ISNOTSELECTABLE_INDEX].value) || ReplayRevealMap)) {
ShowUnitName(*this, CursorScreenPos, UnitUnderCursor);
} else if (!isMapFieldVisile) {
ShowUnitName(*this, CursorScreenPos, NULL, true);
}
}
DrawBorder();
PopClipping();
}
/**
** Draw a map viewport.
*/
void CViewport::Draw() const
{
PushClipping();
this->SetClipping();
/* this may take while */
this->DrawMapBackgroundInViewport();
CurrentViewport = this;
{
std::vector<CUnit *> unittable;
std::vector<Missile *> missiletable;
// We find and sort units after draw level.
FindAndSortUnits(*this, unittable);
const size_t nunits = unittable.size();
FindAndSortMissiles(*this, missiletable);
const size_t nmissiles = missiletable.size();
size_t i = 0;
size_t j = 0;
while (i < nunits && j < nmissiles) {
if (unittable[i]->Type->DrawLevel <= missiletable[j]->Type->DrawLevel) {
unittable[i]->Draw(*this);
++i;
} else {
missiletable[j]->DrawMissile(*this);
++j;
}
}
for (; i < nunits; ++i) {
unittable[i]->Draw(*this);
}
for (; j < nmissiles; ++j) {
missiletable[j]->DrawMissile(*this);
}
}
ParticleManager.draw(*this);
this->DrawMapFogOfWar();
//
// Draw orders of selected units.
// Drawn here so that they are shown even when the unit is out of the screen.
//
if (!Preference.ShowOrders) {
} else if (Preference.ShowOrders < 0
|| (ShowOrdersCount >= GameCycle) || (KeyModifiers & ModifierShift)) {
for (int i = 0; i < NumSelected; ++i) {
ShowOrder(*Selected[i]);
}
}
//
// Draw unit's name popup
//
if (CursorOn == CursorOnMap && Preference.ShowNameDelay && (ShowNameDelay < GameCycle) && (GameCycle < ShowNameTime)) {
const Vec2i tilePos = this->ScreenToTilePos(CursorScreenPos);
const bool isMapFieldVisile = Map.Field(tilePos)->playerInfo.IsTeamVisible(*ThisPlayer);
if (UI.MouseViewport->IsInsideMapArea(CursorScreenPos)
&& (isMapFieldVisile || ReplayRevealMap)) {
ShowUnitName(*this, CursorScreenPos, UnitUnderCursor);
} else if (!isMapFieldVisile) {
ShowUnitName(*this, CursorScreenPos, NULL, true);
}
}
DrawBorder();
PopClipping();
}
void nuiGLPainter::ApplyTexture(const nuiRenderState& rState, bool ForceApply)
{
// if ((rState.mTexturing && !rState.mpTexture) || (!rState.mTexturing && rState.mpTexture))
// {
// printf("bleh!\n");
// char* bleh = NULL;
// bleh[0] = 0;
// }
// 2D Textures:
std::map<nuiTexture*, TextureInfo>::const_iterator it = mTextures.find(rState.mpTexture);
bool uptodate = (it == mTextures.end()) ? false : ( !it->second.mReload && it->second.mTexture >= 0 );
if (ForceApply || (mState.mpTexture != rState.mpTexture) || (mState.mpTexture && !uptodate))
{
GLenum intarget = 0;
GLenum outtarget = 0;
if (mState.mpTexture)
{
outtarget = GetTextureTarget(mState.mpTexture->IsPowerOfTwo());
//mState.mpTexture->UnapplyGL(this); #TODO Un apply the texture
nuiCheckForGLErrors();
mState.mpTexture->Release();
nuiCheckForGLErrors();
}
//NGL_OUT(_T("Change texture to 0x%x (%ls)\n"), rState.mpTexture, rState.mpTexture?rState.mpTexture->GetSource().GetChars() : nglString::Empty.GetChars());
mState.mpTexture = rState.mpTexture ;
if (mState.mpTexture)
{
intarget = GetTextureTarget(mState.mpTexture->IsPowerOfTwo());
mState.mpTexture->Acquire();
nuiSurface* pSurface = mState.mpTexture->GetSurface();
if (pSurface)
{
std::map<nuiSurface*, FramebufferInfo>::const_iterator it = mFramebuffers.find(pSurface);
bool create = (it == mFramebuffers.end()) ? true : false;
if (create || pSurface->IsDirty())
{
PushClipping();
nuiRenderState s(mState);// PushState();
PushProjectionMatrix();
PushMatrix();
#ifdef _OPENGL_ES_
if (mpSurfaceStack.empty())
{
// mDefaultFramebuffer = 0;
// mDefaultRenderbuffer = 0;
glGetIntegerv(GL_FRAMEBUFFER_BINDING_NUI, &mDefaultFramebuffer);
glGetIntegerv(GL_RENDERBUFFER_BINDING_NUI, (GLint *) &mDefaultRenderbuffer);
}
#endif
PushSurface();
SetState(nuiRenderState());
ResetClipRect();
mClip.Set(0, 0, pSurface->GetWidth(), pSurface->GetHeight());
LoadMatrix(nglMatrixf());
NGL_ASSERT(pSurface);
SetSurface(pSurface);
//Set2DProjectionMatrix(nuiRect(0.0f, 0.0f, pSurface->GetWidth(), pSurface->GetHeight()));
nuiMatrix m;
m.Translate(-1.0f, 1.0f, 0.0f);
m.Scale(2.0f / pSurface->GetWidth(), -2.0f / pSurface->GetHeight(), 1.0f);
LoadProjectionMatrix(nuiRect(pSurface->GetWidth(), pSurface->GetHeight()), m);
// clear the surface with transparent black:
// nuiRenderState s2(mState);// PushState();
// mState.mClearColor = nuiColor(0.0f, 0.0f, 0.0f, 0.0f);
SetState(mState);
// ClearColor();
// SetState(s2);
//////////////////////////////
nuiDrawContext Ctx(nuiRect(pSurface->GetWidth(), pSurface->GetHeight()));
Ctx.SetPainter(this);
pSurface->Realize(&Ctx);
Ctx.SetPainter(NULL);
//////////////////////////////
PopSurface();
PopMatrix();
PopProjectionMatrix();
//PopState();
SetState(s);
PopClipping();
}
}
UploadTexture(mState.mpTexture);
nuiCheckForGLErrors();
}
//NGL_OUT(_T("Change texture type from 0x%x to 0x%x\n"), outtarget, intarget);
mTextureTarget = intarget;
if (intarget != outtarget)
{
// Texture Target has changed
if (outtarget)
{
glDisable(outtarget);
nuiCheckForGLErrors();
}
//NGL_OUT(_T("disable outtarget\n"));
if (intarget && mState.mTexturing && mState.mpTexture)
{
mState.mTexturing = rState.mTexturing;
//NGL_OUT(_T("enable intarget\n"));
glEnable(intarget);
nuiCheckForGLErrors();
}
}
else
{
// Texture Target have not changed
if (mState.mTexturing != rState.mTexturing) // Have texture on/off changed?
{
// Should enable or disable texturing
mState.mTexturing = rState.mTexturing;
if (mState.mTexturing)
{
glEnable(mTextureTarget);
nuiCheckForGLErrors();
}
else
{
glDisable(mTextureTarget);
nuiCheckForGLErrors();
}
}
}
}
if (ForceApply || (mState.mTexturing != rState.mTexturing))
{
// Texture have not changed, but texturing may have been enabled / disabled
mState.mTexturing = rState.mTexturing;
if (mState.mpTexture)
{
if (mTextureTarget && mState.mTexturing)
{
//NGL_OUT(_T("Enable 0x%x\n"), mTextureTarget);
glEnable(mTextureTarget);
nuiCheckForGLErrors();
}
else
{
//NGL_OUT(_T("Disable 0x%x\n"), mTextureTarget);
glDisable(mTextureTarget);
nuiCheckForGLErrors();
}
}
else
{
if (mTextureTarget)
{
//NGL_OUT(_T("Disable 0x%x\n"), mTextureTarget);
glDisable(mTextureTarget);
}
nuiCheckForGLErrors();
}
}
}