void UINode::renderDebug (int x, int y, int textY) const
{
const int panelX = getRenderX();
const int panelY = getRenderY();
const int w = getRenderWidth(false);
const int h = getRenderHeight(false);
const Color* color[5];
color[0] = &colorGreen;
color[1] = &colorBlue;
color[2] = &colorRed;
color[3] = &colorYellow;
color[4] = &colorCyan;
const int index = (panelX * 22 * h + panelY * 23 * w) % 5;
renderRect(x + getRenderX(false), y + getRenderY(false), w, h, *color[index]);
if (!fequals(_padding, 0.0f)) {
renderRect(x + panelX, y + panelY, getRenderWidth(), getRenderHeight(), *color[index]);
}
renderFilledRect(x + getRenderCenterX(), y + getRenderCenterY(), 4, 4, colorRed);
renderFilledRect(x + panelX, y + panelY, 4, 4, colorBlue);
const BitmapFontPtr& font = getFont(MEDIUM_FONT);
int panelTextY = textY;
for (UINodeListConstIter i = _nodes.begin(); i != _nodes.end(); ++i) {
const UINode* nodePtr = *i;
if (!nodePtr->hasFocus())
continue;
nodePtr->renderDebug(x + panelX, y + panelY, panelTextY);
const std::string debugInfo = "[id=" + nodePtr->getId() + "]";
_frontend->renderFilledRect(x - 1, panelTextY + 1, font->getTextWidth(debugInfo) + 2, font->getTextHeight(debugInfo) + 2, colorGrayAlpha);
font->print(debugInfo, colorCyan, x, panelTextY);
panelTextY += font->getTextHeight(debugInfo);
}
}
UINodeBackgroundScene::UINodeBackgroundScene (IFrontend *frontend) :
UINode(frontend), _reason(&MapFailedReasons::FAILED_NO), _theme(&ThemeTypes::ROCK)
{
setPadding(getScreenPadding());
setSize(1.0, 1.0f);
setBackgroundColor(colorBlack);
_caveOffIce = loadTexture("ui-scene-cave-ice");
_caveArtIce = loadTexture("ui-scene-caveart-ice");
_caveOffRock = loadTexture("ui-scene-cave-rock");
_caveArtRock = loadTexture("ui-scene-caveart-rock");
_imageWidth = _caveOffIce->getWidth();
_imageHeight = _caveOffIce->getHeight();
_amountHorizontal = getRenderWidth(false) / _imageWidth + 1;
_amountVertical = getRenderHeight(false) / _imageHeight + 1;
_tilesIce.push_back(loadTexture("ui-scene-tile1-ice"));
_tilesIce.push_back(loadTexture("ui-scene-tile2-ice"));
_groundsIce.push_back(loadTexture("ui-scene-ground1-ice"));
_groundsIce.push_back(loadTexture("ui-scene-ground2-ice"));
_tilesRock.push_back(loadTexture("ui-scene-tile1-rock"));
_tilesRock.push_back(loadTexture("ui-scene-tile2-rock"));
_groundsRock.push_back(loadTexture("ui-scene-ground1-rock"));
_groundsRock.push_back(loadTexture("ui-scene-ground2-rock"));
_failed[&MapFailedReasons::FAILED_WATER_HEIGHT] = loadTexture("dead-waterheight");
_failed[&MapFailedReasons::FAILED_HITPOINTS] = loadTexture("dead-hitpoints");
_failed[&MapFailedReasons::FAILED_SIDESCROLL] = loadTexture("dead-hitpoints");
_failed[&MapFailedReasons::FAILED_NPC_FLYING] = loadTexture("dead-npc-flying");
_failed[&MapFailedReasons::FAILED_NPC_WALKING] = loadTexture("dead-npc-walking");
_failed[&MapFailedReasons::FAILED_NPC_FISH] = loadTexture("dead-npc-fish");
_failed[&MapFailedReasons::FAILED_NPC_MAMMUT] = loadTexture("dead-npc-mammut");
_failed[&MapFailedReasons::FAILED_NO_MORE_PLAYERS] = loadTexture("dead-hitpoints");
}
UINodeBackground::UINodeBackground (IFrontend *frontend, const std::string& title, bool showVehicle) :
UINode(frontend), _showVehicle(showVehicle), _title(title)
{
setPadding(getScreenPadding());
setSize(1.0, 1.0f);
setBackgroundColor(colorBlack);
_cave = loadTexture("ui-scene-cave-ice");
_vehicle = loadTexture("ui-scene-player");
_caveArt = loadTexture("ui-scene-caveart-ice");
_imageWidth = _cave->getWidth();
_imageHeight = _cave->getHeight();
_amountHorizontal = _imageWidth <= 0 ? 1 : getRenderWidth(false) / _imageWidth + 1;
_amountVertical = _imageHeight <= 0 ? 1 : getRenderHeight(false) / _imageHeight + 1;
const TexturePtr& tile1 = loadTexture("ui-scene-tile1-ice");
if (tile1)
_tiles.push_back(tile1);
const TexturePtr& tile2 = loadTexture("ui-scene-tile2-ice");
if (tile2)
_tiles.push_back(tile2);
_font = getFont(LARGE_FONT);
Vector4Set(colorWhite, _fontColor);
_textWidth = _font->getTextWidth(_title);
_textHeight = _font->getTextHeight(_title);
}
void UINode::renderMiddle (int x, int y) const
{
if (!_texture)
return;
const int childX = x + getRenderX();
const int childY = y + getRenderY();
renderImage(_texture, childX, childY, getRenderWidth(), getRenderHeight(), _alpha);
}
void UINode::renderBack (int x, int y) const
{
const int w = getRenderWidth(false);
const int h = getRenderHeight(false);
if (_backgroundColor[3] > 0.001f) {
renderFilledRect(x + getRenderX(false), y + getRenderY(false), w, h, _backgroundColor);
}
}
void IUINodeMap::render (int x, int y) const
{
renderFilledRect(getRenderX(), getRenderY(), getRenderWidth(), getRenderHeight(), colorBlack);
if (_map.isActive())
_map.render();
UINode::render(0, 0);
if (_map.isStarted())
return;
const BitmapFontPtr& font = getFont(HUGE_FONT);
y += getRenderHeight() / 10;
x += getRenderWidth() / 10;
y += font->print(tr("Players:"), colorWhite, x, y) + font->getCharHeight();
for (std::vector<std::string>::const_iterator i = _players.begin(); i != _players.end(); ++i) {
y += font->print(*i, colorWhite, x + 10, y) + font->getCharHeight();
}
}
void UINodeCheckbox::render (int x, int y) const
{
UINodeButton::render(x, y);
if (_label.empty())
return;
x += getRenderX() + getRenderWidth() + getPadding() * _frontend->getWidth();
y += getRenderCenterY() - _font->getTextHeight(_label) / 2;
_font->print(_label, _fontColor, x, y);
}
void UINodeSlider::render (int x, int y) const
{
UINode::render(x, y);
x += getRenderX();
y += getRenderY();
const int w = getRenderWidth();
const int h = getRenderHeight();
const int deltaHeight = h / 2;
const float steps = _max - _min + 1.0f;
const float stepDelta = w / steps * (_stepWidth < 1.0f ? 1.0f : _stepWidth);
const int sliderX = x + (_value - _min) / steps * w;
renderLine(x, y + deltaHeight, x + w, y + deltaHeight, _lineColor);
renderFilledRect(sliderX, y, stepDelta, h, _sliderColor);
}
void ofxApp::addTransformControls(int panelNum, int panelCol) {
if(_bTransformControls)
return;
if(panelNum < 0) {
controlPanel.addPanel("Transformer", 1, false);
controlPanel.setWhichPanel(controlPanel.panels.size()-1);
}
else {
controlPanel.setWhichPanel(panelNum);
}
controlPanel.setWhichColumn(panelCol);
controlPanel.addSlider2D("position", "transformPosition", 0, 0,
-getRenderWidth(), getRenderWidth(),
-getRenderHeight(), getRenderHeight(), false);
controlPanel.addSlider("z", "transformZ", 0, -1000, 200, false);
controlPanel.addToggle("keep aspect", "transformAspect", false);
controlPanel.addToggle("center rendering", "transformCenter", false);
controlPanel.addToggle("mirror x", "transformMirrorX", false);
controlPanel.addToggle("mirror y", "transformMirrorY", false);
controlPanel.addToggle("enable quad warper", "transformEnableQuadWarper", false);
controlPanel.addToggle("edit quad warper", "transformEditQuadWarper", false);
controlPanel.addToggle("save quad warper", "transformSaveQuadWarper", false);
_bTransformControls = true;
}
//--------------------------------------------------------------
void ofApp::draw() {
// the current scene is automatically drawn before this function
// show the render area edges with a white rect
if(isDebug()) {
ofNoFill();
ofSetColor(255);
ofSetRectMode(OF_RECTMODE_CORNER);
ofDrawRectangle(1, 1, getRenderWidth()-2, getRenderHeight()-2);
ofFill();
}
// drop out of the auto transform space back to OF screen space
transformer.pop();
#ifdef HAVE_OFX_GUI
// draw the transform panel when in debug mode
if(isDebug()) {
panel.draw();
}
#endif
// draw current scene info using the ofxBitmapString stream interface
// to ofDrawBitmapString
ofSetColor(200);
ofxBitmapString(12, ofGetHeight()-8)
<< "Current Scene: " << sceneManager.getCurrentSceneIndex()
<< " " << sceneManager.getCurrentSceneName() << endl;
// go back to the auto transform space
//
// this is actually done automatically if the transformer is set but
// included here for completeness
transformer.push();
// the warp editor is drawn automatically after this function
}
void UINode::renderTop (int x, int y) const
{
const int childX = x + getRenderX();
const int childY = y + getRenderY();
if (_renderBorder) {
const int w = getRenderWidth(false);
const int h = getRenderHeight(false);
renderRect(x + getRenderX(false), y + getRenderY(false), w, h, _borderColor);
}
int textYOffset = 0;
for (DelayedTextsConstIter i = _texts.begin(); i != _texts.end(); ++i) {
const UINodeDelayedText& t = *i;
const int fontX = t.pos.x > 0.00001f ? (t.pos.x * _frontend->getWidth()) : (getRenderCenterX() - t.font->getTextWidth(t.text) / 2.0f);
int fontY;
if (t.pos.y > 0.00001f) {
fontY = t.pos.y * _frontend->getHeight();
} else {
const int textHeight = t.font->getTextHeight(t.text);
fontY = textYOffset + getRenderCenterY() - textHeight / 2.0f;
textYOffset += textHeight;
}
t.font->print(t.text, colorWhite, fontX, fontY);
}
const bool debug = Config.isDebugUI();
const bool focus = hasFocus();
if (debug && focus)
renderDebug(x, y, y + 20);
for (UINodeListConstIter i = _nodes.begin(); i != _nodes.end(); ++i) {
const UINode* nodePtr = *i;
if (!nodePtr->isVisible())
continue;
nodePtr->render(childX, childY);
}
}
inline float UINodeSlider::calculateValue (int32_t x) const
{
const int steps = _max - _min + 1;
const float value = _min + (x - getRenderX(false)) * steps / static_cast<float>(getRenderWidth(false));
return clamp(value - static_cast<float>(fmod(value, _stepWidth)), _min, _max);
}
int UINodeServerSelector::getPlayersX () const
{
return getRenderWidth() - _headlineFont->getTextWidth(PLAYERS_HEADLINE);
}
int UINodeServerSelector::getMapX () const
{
return getRenderWidth() / 2;
}
