void WorldUIView::drawBg(){ color(Color(0, 140.0/255.0, 240.0/255.0)); drawSolidRect(Rectf(rect.x, rect.y, rect.xEnd, rect.yEnd)); }
void CharacterCreation::render() { arx_assert(ARXmenu.mode() == Mode_CharacterCreation); GRenderer->Clear(Renderer::ColorBuffer); //------------------------------------------------------------------------- arx_assert(BookBackground); { UseRenderState state(render2D()); EERIEDrawBitmap(Rectf(Vec2f(0, 0), g_size.width(), g_size.height()), 0.9f, BookBackground, Color::white); g_playerBook.stats.manageNewQuest(); bool DONE = (player.Skill_Redistribute == 0 && player.Attribute_Redistribute == 0); Color color = Color::none; Rectf book = g_playerBook.getArea(); Vec2f spacing = Vec2f(20.f, 30.f) * minSizeRatio(); Vec2f quickGenerateButtonSize(hFontMenu->getTextSize(str_button_quickgen).size()); Rectf quickGenerateButton(book.bottomLeft() + Vec2f(0.f, spacing.y), quickGenerateButtonSize.x, quickGenerateButtonSize.y); Vec2f doneButtonSize(hFontMenu->getTextSize(str_button_done).size()); Rectf doneButton(book.bottomRight() + Vec2f(-doneButtonSize.x, spacing.y), doneButtonSize.x, doneButtonSize.y); Vec2f skinButtonSize(hFontMenu->getTextSize(str_button_skin).size()); Rectf skinButton((quickGenerateButton.centerRight() + doneButton.centerLeft() - skinButtonSize) / 2.f, skinButtonSize.x, skinButtonSize.y); if(quickGenerateButton.right > skinButton.left - spacing.x) { quickGenerateButton.move(skinButton.left - spacing.x - quickGenerateButton.right, 0.f); } if(doneButton.left < skinButton.right + spacing.x) { doneButton.move(skinButton.right + spacing.x - doneButton.left, 0.f); } // Button QUICK GENERATION if(quickGenerateButton.contains(Vec2f(DANAEMouse))) { cursorSetInteraction(); if(eeMousePressed1()); else if (eeMouseUp1()) { m_cheatQuickGenButtonClickCount++; int iSkin = player.skin; ARX_SOUND_PlayMenu(g_snd.MENU_CLICK); if(bQuickGenFirstClick) { ARX_PLAYER_MakeAverageHero(); bQuickGenFirstClick = false; } else { ARX_PLAYER_QuickGeneration(); } player.skin = checked_range_cast<char>(iSkin); } color = Color::white; } else color = Color(232, 204, 143); ARX_UNICODE_DrawTextInRect(hFontMenu, quickGenerateButton.topLeft(), 999999, str_button_quickgen, color); // Button SKIN if(skinButton.contains(Vec2f(DANAEMouse))) { cursorSetInteraction(); if(eeMouseUp1()) { m_cheatSkinButtonClickCount++; ARX_SOUND_PlayMenu(g_snd.MENU_CLICK); player.skin++; if(player.skin > 3) player.skin = 0; ARX_PLAYER_Restore_Skin(); } color = Color::white; } else color = Color(232, 204, 143); ARX_UNICODE_DrawTextInRect(hFontMenu, skinButton.topLeft(), 999999, str_button_skin, color); // Button DONE if(doneButton.contains(Vec2f(DANAEMouse))) { if(DONE) cursorSetInteraction(); if(DONE && eeMouseUp1()) { if(m_cheatSkinButtonClickCount == 8 && m_cheatQuickGenButtonClickCount == 10) { m_cheatSkinButtonClickCount = -2; } else if(m_cheatSkinButtonClickCount == -1) { ARX_PLAYER_MakeSpHero(); player.skin = 4; ARX_PLAYER_Restore_Skin(); m_cheatSkinButtonClickCount = 0; SP_HEAD = 1; } else { if(SP_HEAD) { player.skin = 4; ARX_PLAYER_Restore_Skin(); SP_HEAD = 0; } ARX_SOUND_PlayMenu(g_snd.MENU_CLICK); MenuFader_start(Fade_In, Mode_InGame); } } else { if(DONE) { color = Color::white; } else { color = Color::gray(0.75f); } } } else { if(DONE) { color = Color(232, 204, 143); } else { color = Color::gray(0.75f); } } if(m_cheatSkinButtonClickCount < 0) { color = Color::magenta; } ARX_UNICODE_DrawTextInRect(hFontMenu, doneButton.topLeft(), 999999, str_button_done, color); } EERIE_LIGHT * light = lightHandleGet(torchLightHandle); light->pos.x = 0.f + GInput->getMousePosition().x - (g_size.width() >> 1); light->pos.y = 0.f + GInput->getMousePosition().y - (g_size.height() >> 1); if(pTextManage) { pTextManage->Update(g_platformTime.lastFrameDuration()); pTextManage->Render(); } ARX_INTERFACE_RenderCursor(true); if(MenuFader_process()) { if(iFadeAction == Mode_InGame) { ARX_MENU_NEW_QUEST_Clicked_QUIT(); MenuFader_reset(); if(pTextManage) { pTextManage->Clear(); } } } }
void add(const Rectf& rect, const C& c) { if (m_depth > 8) // FIXME: max_depth shouldn't be hardcode { Object obj; obj.rect = rect; obj.data = c; m_items.push_back(obj); } else { if (rect.right < m_center.x) // west { if (rect.bottom < m_center.y) // north { if (!m_nw.get()) { m_nw.reset(new QuadTreeNode(m_depth+1, Rectf(m_bounding_rect.left, m_bounding_rect.top, m_center.x, m_center.y))); } m_nw->add(rect, c); } else if(rect.top > m_center.y) // south { if (!m_sw.get()) { m_sw.reset(new QuadTreeNode(m_depth+1, Rectf(m_bounding_rect.left, m_center.y, m_center.x, m_bounding_rect.bottom))); } m_sw->add(rect, c); } else { Object obj; obj.rect = rect; obj.data = c; m_items.push_back(obj); } } else if (rect.left > m_center.x) // east { if (rect.bottom < m_center.y) // north { if (!m_ne.get()) { m_ne.reset(new QuadTreeNode(m_depth+1, Rectf(m_center.x, m_bounding_rect.top, m_bounding_rect.right, m_center.y))); } m_ne->add(rect, c); } else if(rect.top > m_center.y) // south { if (!m_se.get()) { m_se.reset(new QuadTreeNode(m_depth+1, Rectf(m_center.x, m_center.y, m_bounding_rect.right, m_bounding_rect.bottom))); } m_se->add(rect, c); } else { Object obj; obj.rect = rect; obj.data = c; m_items.push_back(obj); } } else { Object obj; obj.rect = rect; obj.data = c; m_items.push_back(obj); } } }
//----------------------------------------------------------------------------- // ARX Menu Rendering Func // returns false if no menu needs to be displayed //----------------------------------------------------------------------------- bool ARX_Menu_Render() { if(ARXmenu.currentmode == AMCM_OFF) return false; bool br = Menu2_Render(); if(br) return br; if(ARXmenu.currentmode == AMCM_OFF) return false; GRenderer->Clear(Renderer::ColorBuffer | Renderer::DepthBuffer); FLYING_OVER = 0; //------------------------------------------------------------------------- if(ARXmenu.currentmode == AMCM_NEWQUEST && ARXmenu.mda) { GRenderer->SetRenderState(Renderer::Fog, false); GRenderer->SetRenderState(Renderer::AlphaBlending, false); if(ARXmenu.mda->BookBackground != NULL) { GRenderer->SetRenderState(Renderer::AlphaBlending, false); GRenderer->SetRenderState(Renderer::Fog, false); GRenderer->SetRenderState(Renderer::DepthWrite, false); GRenderer->SetRenderState(Renderer::DepthTest, false); EERIEDrawBitmap2(Rectf(Vec2f(0, 0), g_size.width(), g_size.height()), 0.9f, ARXmenu.mda->BookBackground, Color::white); } BOOKZOOM = 1; ARX_INTERFACE_ManageOpenedBook(); if(ARXmenu.mda) { long DONE = 0; if(player.Skill_Redistribute == 0 && player.Attribute_Redistribute == 0) DONE = 1; if(!ARXmenu.mda->flyover[FLYING_OVER].empty() ) //=ARXmenu.mda->flyover[FLYING_OVER]; { if(FLYING_OVER != OLD_FLYING_OVER) { float fRandom = rnd() * 2; int t = checked_range_cast<int>(fRandom); pTextManage->Clear(); OLD_FLYING_OVER = FLYING_OVER; UNICODE_ARXDrawTextCenteredScroll(hFontInGame, (g_size.width() * 0.5f), 12, (g_size.center().x) * 0.82f, ARXmenu.mda->flyover[FLYING_OVER], Color(232 + t, 204 + t, 143 + t), 1000, 0.01f, 2); } } else { OLD_FLYING_OVER = -1; } Vec2f pos; pos.x = 0; pos.y = 313 * g_sizeRatio.y + (g_size.height() - 313 * g_sizeRatio.y) * 0.70f; Vec2f size = g_sizeRatio; size *= 100; Color color = Color::none; //--------------------------------------------------------------------- // Button QUICK GENERATION pos.x = (g_size.width() - (513 * g_sizeRatio.x)) * 0.5f; const Rectf quickGenerateButtonMouseTestRect( pos, size.x, size.y ); if(quickGenerateButtonMouseTestRect.contains(Vec2f(DANAEMouse))) { SpecialCursor = CURSOR_INTERACTION_ON; FLYING_OVER = BUTTON_QUICK_GENERATION; if(eeMousePressed1()); else if (eeMouseUp1()) { QUICK_MOD++; int iSkin = player.skin; ARX_SOUND_PlayMenu(SND_MENU_CLICK); if(bQuickGenFirstClick) { ARX_PLAYER_MakeAverageHero(); bQuickGenFirstClick = false; } else { ARX_PLAYER_QuickGeneration(); } player.skin = checked_range_cast<char>(iSkin); } color = Color(255, 255, 255); } else color = Color(232, 204, 143); pTextManage->AddText(hFontMenu, ARXmenu.mda->str_button_quickgen, static_cast<long>(pos.x), static_cast<long>(pos.y), color); //--------------------------------------------------------------------- // Button SKIN pos.x = g_size.width() * 0.5f; const Rectf skinButtonMouseTestRect( pos, size.x, size.y ); if(skinButtonMouseTestRect.contains(Vec2f(DANAEMouse))) { SpecialCursor = CURSOR_INTERACTION_ON; FLYING_OVER = BUTTON_SKIN; if(eeMouseUp1()) { SKIN_MOD++; BOOKZOOM = 1; ARX_SOUND_PlayMenu(SND_MENU_CLICK); player.skin++; if(player.skin > 3) player.skin = 0; ARX_PLAYER_Restore_Skin(); } color = Color(255, 255, 255); } else color = Color(232, 204, 143); pTextManage->AddText(hFontMenu, ARXmenu.mda->str_button_skin, static_cast<long>(pos.x), static_cast<long>(pos.y), color); //--------------------------------------------------------------------- // Button DONE pos.x = g_size.width() - (g_size.width() - 513 * g_sizeRatio.x) * 0.5f - 40 * g_sizeRatio.x; const Rectf doneButtonMouseTestRect( pos, size.x, size.y ); if(doneButtonMouseTestRect.contains(Vec2f(DANAEMouse))) { if(DONE) SpecialCursor = CURSOR_INTERACTION_ON; FLYING_OVER = BUTTON_DONE; if(DONE && eeMouseUp1()) { if(SKIN_MOD == 8 && QUICK_MOD == 10) { SKIN_MOD = -2; } else if(SKIN_MOD == -1) { ARX_PLAYER_MakeSpHero(); player.skin = 4; ARX_PLAYER_Restore_Skin(); SKIN_MOD = 0; SP_HEAD = 1; } else { if(SP_HEAD) { player.skin = 4; ARX_PLAYER_Restore_Skin(); SP_HEAD = 0; } ARX_SOUND_PlayMenu(SND_MENU_CLICK); bFadeInOut = true; //fade out bFade = true; //active le fade iFadeAction = AMCM_OFF; } } else { if(DONE) color = Color(255, 255, 255); else color = Color(192, 192, 192); } } else { if(DONE) color = Color(232, 204, 143); else color = Color(192, 192, 192); } if(SKIN_MOD < 0) color = Color(255, 0, 255); pTextManage->AddText(hFontMenu, ARXmenu.mda->str_button_done, static_cast<long>(pos.x), static_cast<long>(pos.y), color); } } EERIE_LIGHT * light = lightHandleGet(torchLightHandle); light->pos.x = 0.f + GInput->getMousePosAbs().x - (g_size.width() >> 1); light->pos.y = 0.f + GInput->getMousePosAbs().y - (g_size.height() >> 1); if(pTextManage) { pTextManage->Update(framedelay); pTextManage->Render(); } if(ARXmenu.currentmode != AMCM_CREDITS) ARX_INTERFACE_RenderCursor(true); if(ARXmenu.currentmode == AMCM_NEWQUEST) { if(ProcessFadeInOut(bFadeInOut, 0.1f)) { switch(iFadeAction) { case AMCM_OFF: arxtime.resume(); ARX_MENU_NEW_QUEST_Clicked_QUIT(); iFadeAction = -1; bFade = false; fFadeInOut = 0.f; if(pTextManage) pTextManage->Clear(); break; } } } return true; }
Rectf grown(float border) const { return Rectf(p1.x - border, p1.y - border, p2.x + border, p2.y + border); }
DataBuffer CursorProvider_Win32::create_ico_file(const PixelBuffer &image) { return create_ico_helper(image, Rectf(image.get_size()), 1, Point(0, 0)); }
Rectf get_bbox() const { return Rectf(get_tile_position(0, 0), get_tile_position(width, height)); }
void ButtonWidget::SetPos(Vec2f pos) { Vec2f scaledSize = RATIO_2(m_size); m_rect = Rectf(pos, scaledSize.x, scaledSize.y); }
void Text::ensureGeometryUpdates() const { if (!mGeometryNeedsUpdate) { return; } mGeometryNeedsUpdate = false; mVertices.clear(); mBounds = Rectf(); if (!mFont) { return; } if (mString.isEmpty()) { return; } bool bold = (mStyle & Bold) != 0; bool underlined = (mStyle & Underlined) != 0; bool strikeThrough = (mStyle & StrikeThrough) != 0; float italic = (mStyle & Italic) ? 0.208f : 0.f; float underlineOffset = mFont->getUnderlinePosition(mCharSize); float underlineThickness = mFont->getUnderlineThickness(mCharSize); Rectf xBounds = mFont->getGlyph(L'x', mCharSize, bold).bounds; float strikeThroughOffset = xBounds.top + xBounds.height / 2.f; float hspace = staticCastf(mFont->getGlyph(L'', mCharSize, bold).advance); float vspace = staticCastf(mFont->getLineSpacing(mCharSize)); float x = 0.f; float y = staticCastf(mCharSize); float minX = staticCastf(mCharSize); float minY = staticCastf(mCharSize); float maxX = 0.f; float maxY = 0.f; uint32 prevChar = 0; bool expextClosingBracket = false; Color color = mColor; uint32 foundWordEndPos = 0; bool wordFound = false; for (sizeT i = 0; i < mString.getSize(); ++i) { uint32 currChar = mString[i]; if (i != 0) { prevChar = mString[i - 1]; } uint32 nextChar = 0; if (i < mString.getSize()) { nextChar = mString[i + 1]; } x += staticCastf(mFont->getKerning(prevChar, currChar, mCharSize)); if (underlined && (currChar == L'\n')) { float top = std::floor(y + underlineOffset - (underlineThickness / 2) + 0.5f); float botttom = top + std::floor(underlineThickness + 0.5f); mVertices.append(Vertex(Vector2f(0, top), mColor, Vector2f(1, 1))); mVertices.append(Vertex(Vector2f(x, top), mColor, Vector2f(1, 1))); mVertices.append(Vertex(Vector2f(0, botttom), mColor, Vector2f(1, 1))); mVertices.append(Vertex(Vector2f(0, botttom), mColor, Vector2f(1, 1))); mVertices.append(Vertex(Vector2f(x, top), mColor, Vector2f(1, 1))); mVertices.append(Vertex(Vector2f(x, botttom), mColor, Vector2f(1, 1))); } if (strikeThrough && (currChar == L'\n')) { float top = std::floor(y + strikeThroughOffset - (underlineThickness / 2) + 0.5f); float botttom = top + std::floor(underlineThickness + 0.5f); mVertices.append(Vertex(Vector2f(0, top), mColor, Vector2f(1, 1))); mVertices.append(Vertex(Vector2f(x, top), mColor, Vector2f(1, 1))); mVertices.append(Vertex(Vector2f(0, botttom), mColor, Vector2f(1, 1))); mVertices.append(Vertex(Vector2f(0, botttom), mColor, Vector2f(1, 1))); mVertices.append(Vertex(Vector2f(x, top), mColor, Vector2f(1, 1))); mVertices.append(Vertex(Vector2f(x, botttom), mColor, Vector2f(1, 1))); } if (currChar == ' ' || currChar == '\t' || currChar == '\n') { minX = std::min(minX, x); minY = std::min(minY, y); switch (currChar) { case ' ': { x += hspace; } break; case '\t': { x += hspace * 4; } break; case '\n': { y += vspace; x = 0; } break; } maxX = std::max(maxX, x); maxY = std::max(maxY, y); continue; } //* if (mDoMultiColor) { if (currChar == '[' && prevChar != '\\') { String str = ""; while (currChar != ']') { currChar = mString[++i]; if (currChar != ']') { str += currChar; } } if (str == "red") { color = Color::Red; } else if (str == "blue") { color = Color::Blue; } else if (str == "white") { color = Color::White; } else if (str == "black") { color = Color::Black; } else if (str == "green") { color = Color::Green; } else if (str == "yellow") { color = Color::Yellow; } else if (str == "Magenta") { color = Color::Magenta; } else if (str == "cyan") { color = Color::Cyan; } else if (str == "transparent") { color = Color::Transparent; } else { if (str.contains(',')) { String newColorStr[4]; for (uint32 k = 0; k <= 3; ++k) { newColorStr[k] = "255"; } if (isdigit(str[0])) { newColorStr[0] = ""; } uint c = 0; for (uint32 j = 0; j < str.getLength(); ++j) { if (isdigit(str[j]) && c <= 3) { newColorStr[c] += str[j]; } else if (str[j] == ',') { ++c; if (j != str.getLength() - 1) { newColorStr[c] = ""; } } } color = Color(newColorStr[0].toUint8(), newColorStr[1].toUint8(), newColorStr[2].toUint8(), newColorStr[3].toUint8()); } else { color = mColor; } } continue; } } else { //Does not cause open file slowdown. uint32 wordWidth = 0; String word = mString.nextWord(i, wordWidth); if (!wordFound) { color = mColor; } if (mString.startsWith("#", true)) { color = Color(142, 192, 124); foundWordEndPos = mString.getLength(); wordFound = true; } else if (mString.startsWith("//", true) || mString.startsWith("--", true)) { color = Color(146, 131, 116); foundWordEndPos = mString.getLength(); wordFound = true; }/* else if (word == "uint32" || word == "int" || word == "float" || word == "char" || word == "void") { color = Color(242, 189, 47); foundWordEndPos = --wordWidth; wordFound = true; } else if (word == "if" || word == "else" || word == "return" || word == "for" || word == "break" || word == "switch" || word == "case" || word == "while" || word == "continue" || word =="do" || word == "goto" || word == "function" || word == "end" || word == "then" || word == "and" || word =="or") { color = Color(251, 73 ,44); foundWordEndPos = --wordWidth; wordFound = true; } else if (word == "true" || word == "false") { color = Color(211, 134, 155); foundWordEndPos = --wordWidth; wordFound = true; }//*/ //std::cerr << word.toStdString() << "\n"; if (i > foundWordEndPos) { color = mColor; wordFound = false; } } //*/ const Glyph &glyph = mFont->getGlyph(currChar, mCharSize, bold); float left = glyph.bounds.left; float top = glyph.bounds.top; float right = glyph.bounds.left + glyph.bounds.width; float bottom = glyph.bounds.top + glyph.bounds.height; float u1 = staticCastf(glyph.textureRect.left); float v1 = staticCastf(glyph.textureRect.top); float u2 = staticCastf(glyph.textureRect.left + glyph.textureRect.width); float v2 = staticCastf(glyph.textureRect.top + glyph.textureRect.height); mVertices.append(Vertex(Vector2f(x + left - italic * top, y + top), color, Vector2f(u1, v1))); mVertices.append(Vertex(Vector2f(x + right - italic * top, y + top), color, Vector2f(u2, v1))); mVertices.append(Vertex(Vector2f(x + left - italic * bottom, y + bottom), color, Vector2f(u1, v2))); mVertices.append(Vertex(Vector2f(x + left - italic * bottom, y + bottom), color, Vector2f(u1, v2))); mVertices.append(Vertex(Vector2f(x + right - italic * top, y + top), color, Vector2f(u2, v1))); mVertices.append(Vertex(Vector2f(x + right - italic * bottom, y + bottom), color, Vector2f(u2, v2))); minX = std::min(minX, x + left - italic * bottom); maxX = std::max(maxX, x + right - italic * top); minY = std::min(minY, y + top); maxY = std::max(maxY, y + bottom); x += glyph.advance; } if (underlined) { float top = std::floor(y + underlineOffset - (underlineThickness / 2) + 0.5f); float botttom = top + std::floor(underlineThickness + 0.5f); mVertices.append(Vertex(Vector2f(0, top), mColor, Vector2f(1, 1))); mVertices.append(Vertex(Vector2f(x, top), mColor, Vector2f(1, 1))); mVertices.append(Vertex(Vector2f(0, botttom), mColor, Vector2f(1, 1))); mVertices.append(Vertex(Vector2f(0, botttom), mColor, Vector2f(1, 1))); mVertices.append(Vertex(Vector2f(x, top), mColor, Vector2f(1, 1))); mVertices.append(Vertex(Vector2f(x, botttom), mColor, Vector2f(1, 1))); } if (strikeThrough) { float top = std::floor(y + strikeThroughOffset - (underlineThickness / 2) + 0.5f); float botttom = top + std::floor(underlineThickness + 0.5f); mVertices.append(Vertex(Vector2f(0, top), mColor, Vector2f(1, 1))); mVertices.append(Vertex(Vector2f(x, top), mColor, Vector2f(1, 1))); mVertices.append(Vertex(Vector2f(0, botttom), mColor, Vector2f(1, 1))); mVertices.append(Vertex(Vector2f(0, botttom), mColor, Vector2f(1, 1))); mVertices.append(Vertex(Vector2f(x, top), mColor, Vector2f(1, 1))); mVertices.append(Vertex(Vector2f(x, botttom), mColor, Vector2f(1, 1))); } mBounds.left = minX; mBounds.top = minY; mBounds.width = maxX - minX; mBounds.height = maxY - minY; }
void Dialog::draw(DrawingContext& context) { Rectf bg_rect(Vector(static_cast<float>(m_passive ? (static_cast<float>(context.get_width()) - m_text_size.width - 20.0f) : static_cast<float>(context.get_width()) / 2.0f - m_text_size.width / 2.0f), static_cast<float>(m_passive ? (static_cast<float>(context.get_height()) - m_text_size.height - 65.0f) : (static_cast<float>(context.get_height()) / 2.0f - m_text_size.height / 2.0f))), Sizef(m_text_size.width, m_text_size.height + 44)); // draw background rect context.color().draw_filled_rect(bg_rect.grown(12.0f), Color(0.2f, 0.3f, 0.4f, m_passive ? 0.3f : 0.8f), 16.0f, LAYER_GUI-10); context.color().draw_filled_rect(bg_rect.grown(8.0f), Color(0.6f, 0.7f, 0.8f, m_passive ? 0.2f : 0.5f), 16.0f, LAYER_GUI-10); // draw text context.color().draw_text(Resources::normal_font, m_text, Vector(bg_rect.get_left() + bg_rect.get_width()/2.0f, bg_rect.get_top()), ALIGN_CENTER, LAYER_GUI); if (m_passive) return; // draw HL line context.color().draw_filled_rect(Rectf(Vector(bg_rect.get_left(), bg_rect.get_bottom() - 35), Sizef(bg_rect.get_width(), 4)), Color(0.6f, 0.7f, 1.0f, 1.0f), LAYER_GUI); context.color().draw_filled_rect(Rectf(Vector(bg_rect.get_left(), bg_rect.get_bottom() - 35), Sizef(bg_rect.get_width(), 2)), Color(1.0f, 1.0f, 1.0f, 1.0f), LAYER_GUI); // draw buttons for (int i = 0; i < static_cast<int>(m_buttons.size()); ++i) { float segment_width = bg_rect.get_width() / static_cast<float>(m_buttons.size()); float button_width = segment_width; Vector pos(bg_rect.get_left() + segment_width/2.0f + static_cast<float>(i) * segment_width, bg_rect.get_bottom() - 12); if (i == m_selected_button) { float button_height = 24.0f; float blink = (sinf(g_real_time * math::PI * 1.0f)/2.0f + 0.5f) * 0.5f + 0.25f; context.color().draw_filled_rect(Rectf(Vector(pos.x - button_width/2, pos.y - button_height/2), Vector(pos.x + button_width/2, pos.y + button_height/2)).grown(2.0f), Color(1.0f, 1.0f, 1.0f, blink), 14.0f, LAYER_GUI-10); context.color().draw_filled_rect(Rectf(Vector(pos.x - button_width/2, pos.y - button_height/2), Vector(pos.x + button_width/2, pos.y + button_height/2)), Color(1.0f, 1.0f, 1.0f, 0.5f), 12.0f, LAYER_GUI-10); } context.color().draw_text(Resources::normal_font, m_buttons[i].text, Vector(pos.x, pos.y - static_cast<float>(int(Resources::normal_font->get_height() / 2))), ALIGN_CENTER, LAYER_GUI, i == m_selected_button ? ColorScheme::Menu::active_color : ColorScheme::Menu::default_color); } }
void DebugDrawer::draw( const BlobTrackerRef &blobTracker, const Area &bounds, const Options &options ) { if ( options.mDebugMode == Options::DebugMode::NONE ) { return; } gl::TextureRef tex; switch ( options.mDrawMode ) { case Options::DrawMode::ORIGINAL: { cv::Mat img = blobTracker->getImageInput(); if ( img.data ) { tex = gl::Texture::create( fromOcv( img ) ); } break; } case Options::DrawMode::BLURRED: { cv::Mat img = blobTracker->getImageBlurred(); if ( img.data ) { tex = gl::Texture::create( fromOcv( img ) ); } break; } case Options::DrawMode::THRESHOLDED: { cv::Mat img = blobTracker->getImageThresholded(); if ( img.data ) { tex = gl::Texture::create( fromOcv( img ) ); } break; } default: break; } if ( ! tex ) { return; } ci::gl::disableDepthRead(); ci::gl::disableDepthWrite(); bool blendingEnabled = options.mDebugMode == Options::DebugMode::BLENDED; auto ctx = gl::context(); ctx->pushBoolState( GL_BLEND, blendingEnabled ); ctx->pushBlendFuncSeparate( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); gl::ScopedColor color( ColorA::gray( 1.0f, 0.5f ) ); Area outputArea = bounds; if ( options.mDrawProportionalFit ) { outputArea = Area::proportionalFit( tex->getBounds(), bounds, true, true ); } gl::draw( tex, outputArea ); { const auto &trackerOptions = blobTracker->getOptions(); float s = trackerOptions.mNormalizationScale; RectMapping blobMapping( Rectf( 0.0f, 0.0f, s, s ), Rectf( outputArea ) ); Rectf roi = trackerOptions.mNormalizedRegionOfInterest * s; gl::color( ColorA( 0.0f, 1.0f, 0.0f, 0.8f ) ); gl::drawStrokedRect( blobMapping.map( roi ) ); vec2 offset = outputArea.getUL(); vec2 scale = vec2( outputArea.getSize() ) / vec2( s, s ); for ( const auto &blob : blobTracker->getBlobs() ) { gl::pushModelView(); gl::translate( offset ); gl::scale( scale ); if ( trackerOptions.mBoundsEnabled ) { gl::color( ColorA( 1.0f, 1.0f, 0.0f, 0.5f ) ); gl::drawStrokedRect( blob->mBounds ); } if ( trackerOptions.mConvexHullEnabled && blob->mConvexHull ) { gl::color( ColorA( 1.0f, 0.0f, 1.0f, 0.5f ) ); gl::draw( *blob->mConvexHull.get() ); } gl::popModelView(); vec2 pos = blobMapping.map( blob->mPos ); gl::drawSolidCircle( pos, 2.0f ); gl::drawString( toString< int32_t >( blob->mId ), pos + vec2( 3.0f, -3.0f ), ColorA( 1.0f, 0.0f, 0.0f, 0.9f ) ); } } ctx->popBoolState( GL_BLEND ); ctx->popBlendFuncSeparate(); }
Rectf Sprite::getLocalBounds() const { float w = staticCastf(std::abs(mTextureRect.width)); float h = staticCastf(std::abs(mTextureRect.height)); return Rectf(0.f, 0.f, w, h); }
bool TextFragment::format(vec2& location, float rect_width, bool limit_line_count, int& line_count, bool single_line) { bool abort = false; updateGlyphArrays(limit_line_count); // we are going to fill out the m_glyph_rendering_array // he is what is used to render in the draw() method. m_glyph_rendering_array.clear(); m_rect_array.clear(); size_t glyph_offset = 0; float line_begin = location.x; for(std::vector<WordInfo>::const_iterator word_info = m_glyph_words_array.begin(); word_info != m_glyph_words_array.end() && !abort; word_info++) { if(single_line) { for(size_t i = 0; !abort && i < word_info->m_glyph_count; i++) { if(location.x + m_glyph_widths_array[glyph_offset + i].second > rect_width) { abort = true; } else { addGlyphItemToRenderingArray(glyph_offset + i, location); } } } else { if(location.x + word_info->m_width > rect_width) { m_rect_array.push_back(Rectf(line_begin, location.y - g_skin.getBaselineDrop(), location.x, location.y + g_skin.getBaselineRise())); if(limit_line_count) { line_count--; if(line_count == 0) { abort = true; } } if(!abort) { moveLocationToNewline(location); line_begin = location.x; } } bool break_line_on_char = false; if(location.x == 0 && word_info->m_width > rect_width) { break_line_on_char = true; } for(size_t i = 0; i < word_info->m_glyph_count && !abort; i++) { if(break_line_on_char && location.x + m_glyph_widths_array[glyph_offset + i].second > rect_width) { m_rect_array.push_back(Rectf(line_begin, location.y - g_skin.getBaselineDrop(), location.x, location.y + g_skin.getBaselineRise())); if(limit_line_count) { line_count--; if(line_count == 0) { abort = true; } } if(!abort) { moveLocationToNewline(location); line_begin = location.x; } } addGlyphItemToRenderingArray(glyph_offset + i, location); } if(word_info->m_newline) { m_rect_array.push_back(Rectf(line_begin, location.y - g_skin.getBaselineDrop(), location.x, location.y + g_skin.getBaselineRise())); if(limit_line_count) { line_count--; if(line_count == 0) { abort = true; } } if(!abort) { moveLocationToNewline(location); line_begin = location.x; } } } glyph_offset += word_info->m_glyph_count; } m_rect_array.push_back(Rectf(line_begin, location.y - g_skin.getBaselineDrop(), location.x, location.y + g_skin.getBaselineRise())); m_cumulative_rect = m_rect_array.front(); for(size_t i = 1; i < m_rect_array.size(); i++) { m_cumulative_rect.include(m_rect_array[i]); } return abort; }
void WorldUIView::drawBorder(){ color(Color(0, 0, 0)); lineWidth(5); drawStrokedRect(Rectf(rect.x, rect.y, rect.xEnd, rect.yEnd)); }
// gets bounding box of element Rectf DXFCircle::GetBoundingBox(void) const { return Rectf(center.x - radius, center.y + radius, center.x + radius, center.y - radius); }
Rectf Sprite::get_current_hitbox() const { return Rectf(m_action->x_offset, m_action->y_offset, m_action->x_offset + m_action->hitbox_w, m_action->y_offset + m_action->hitbox_h); }
bool Note::allocate() { if(allocatedForRatio == sizeRatio()) { return background ? true : false; } deallocate(); // Allocate textures and calculate sizes Vec2f newPos; Vec2f newTextStart; Vec2f newTextEnd; Vec2f prevButtonOffset; Vec2f nextButtonOffset; size_t maxPages = 1; Vec2f scale = Vec2f(minSizeRatio(), minSizeRatio()); if(_type == QuestBook) { // TODO change this once the aspect ratio in character screen, spell book, etc. is fixed. scale = sizeRatio(); } switch(_type) { // TODO this information should not be hardcoded case Notice: { background = TextureContainer::LoadUI("graph/interface/book/notice"); if(background) { newPos = Vec2f(320 * Xratio - background->m_dwWidth * 0.5f * scale.x, 47.f * scale.y); newTextStart = Vec2f(50.f, 50.f); newTextEnd = Vec2f(background->size()) - Vec2f(50.f, 50.f); } break; } case SmallNote: { background = TextureContainer::LoadUI("graph/interface/book/bignote"); if(background) { newPos = Vec2f(320 * Xratio - background->m_dwWidth * 0.5f * scale.x, 47.f * scale.y); newTextStart = Vec2f(30.f, 30.f); newTextEnd = Vec2f(background->size()) - Vec2f(30.f, 40.f); } break; } case BigNote: { background = TextureContainer::LoadUI("graph/interface/book/very_bignote"); if(background) { newPos = Vec2f(320 * Xratio - background->m_dwWidth * 0.5f * scale.x, 47.f * scale.y); newTextStart = Vec2f(40.f, 40.f); newTextEnd = Vec2f(background->size()) * Vec2f(0.5f, 1.f) - Vec2f(10.f, 40.f); maxPages = 2; } break; } case Book: { background = TextureContainer::LoadUI("graph/interface/book/ingame_books"); prevPage = TextureContainer::LoadUI("graph/interface/book/left_corner"); nextPage = TextureContainer::LoadUI("graph/interface/book/right_corner"); if(background) { newPos = Vec2f(320 * Xratio - background->m_dwWidth * 0.5f * scale.x, 47.f * scale.y); newTextStart = Vec2f(40.f, 20.f); newTextEnd = Vec2f(background->size()) * Vec2f(0.5f, 1.f) - Vec2f(10.f, 40.f); maxPages = std::numeric_limits<size_t>::max(); prevButtonOffset = Vec2f(8.f, -6.f); nextButtonOffset = Vec2f(-15.f, -6.f); } break; } case QuestBook: { background = TextureContainer::LoadUI("graph/interface/book/questbook"); prevPage = TextureContainer::LoadUI("graph/interface/book/left_corner_original"); nextPage = TextureContainer::LoadUI("graph/interface/book/right_corner_original"); if(background) { newPos = Vec2f(97, 64) * scale; newTextStart = Vec2f(40.f, 40.f); newTextEnd = Vec2f(background->size()) * Vec2f(0.5f, 1.f) - Vec2f(10.f, 65.f); maxPages = std::numeric_limits<size_t>::max(); prevButtonOffset = Vec2f(8.f, -6.f); nextButtonOffset = Vec2f(-15.f, -6.f); } } case Undefined: break; // Cannot handle notes of undefined type. } if(!background) { allocatedForRatio = sizeRatio(); return false; } _area = Rectf(newPos, background->m_dwWidth * scale.x, background->m_dwHeight * scale.y); _textArea = Rect(Vec2i(newTextStart * scale), Vec2i(newTextEnd * scale)); _pageSpacing = 20 * scale.x; if(prevPage) { Vec2f pos = Vec2f(0.f, background->m_dwHeight - prevPage->m_dwHeight) + prevButtonOffset; pos *= scale; _prevPageButton = Rectf(newPos + pos, prevPage->m_dwWidth * scale.x, prevPage->m_dwHeight * scale.y); } if(nextPage) { Vec2f pos = Vec2f(background->size() - nextPage->size()) + nextButtonOffset; pos *= scale; _nextPageButton = Rectf(newPos + pos, nextPage->m_dwWidth * scale.x, nextPage->m_dwHeight * scale.y); } // Split text into pages // TODO This buffer and related string copies can be avoided by // using iterators for ARX_UNICODE_ForceFormattingInRect std::string buffer = _text; while(!buffer.empty()) { // Change the note type if the text is too long. if(pages.size() >= maxPages) { switch(_type) { case Notice: _type = SmallNote; break; case SmallNote: _type = BigNote; break; case BigNote: _type = Book; break; default: ARX_DEAD_CODE(); break; } return allocate(); } long pageSize = ARX_UNICODE_ForceFormattingInRect(hFontInGameNote, buffer, _textArea); if(pageSize <= 0) { LogWarning << "Error splitting note text into pages"; pages.push_back(buffer); break; } pages.push_back(buffer.substr(0, pageSize)); // Skip whitespace at the start of pages. while(size_t(pageSize) < buffer.size() && std::isspace(buffer[pageSize])) { pageSize++; } buffer = buffer.substr(pageSize); } // Clamp the current page to a valid page. setPage(_page); allocatedForRatio = sizeRatio(); return true; }
Rectf Touchable::getTouchableBounds() { return Rectf(0, 0, 0, 0); }
//----------------------------------------------------------------------------// void OpenGLFBOTextureTarget::declareRenderSize(const Sizef& sz) { setArea(Rectf(d_area.getPosition(), d_owner.getAdjustedTextureSize(sz))); resizeRenderTexture(); }
void Font::draw_text_ellipsis(Canvas &canvas, int dest_x, int dest_y, Rect content_box, const std::string &text, const Colorf &color) { draw_text_ellipsis(canvas, (float) dest_x, (float) dest_y, Rectf(content_box.left, content_box.top, content_box.right, content_box.bottom), text, color); }
Rectf get_tile_bbox(int x, int y) const { return Rectf(get_tile_position(x, y), get_tile_position(x+1, y+1)); }
ViewGeometry PositionedLayout::get_geometry(Canvas &canvas, View *view, const Rectf &containing_box) { bool definite_left = !view->style_cascade().computed_value("left").is_keyword("auto"); bool definite_right = !view->style_cascade().computed_value("right").is_keyword("auto"); bool definite_width = !view->style_cascade().computed_value("width").is_keyword("auto"); float computed_left = resolve_percentage(view->style_cascade().computed_value("left"), containing_box.get_width()); float computed_right = resolve_percentage(view->style_cascade().computed_value("right"), containing_box.get_width()); float computed_width = resolve_percentage(view->style_cascade().computed_value("width"), containing_box.get_width()); float x = 0.0f; float width = 0.0f; if (definite_left && definite_right) { x = computed_left; width = clan::max(containing_box.get_width() - computed_right - x, 0.0f); } else if (definite_left && definite_width) { x = computed_left; width = computed_width; } else if (definite_right && definite_width) { width = computed_width; x = containing_box.get_width() - computed_right - width; } else if (definite_left) { x = computed_left; width = view->preferred_width(canvas); // Note: in HTML there's an additional implicit "max-width: calc(100%-left)" rule active here. // We are not emulating this "feature" as it is most likely a bug that got standardized for backwards compatibility. // The user should add an max-width rule themselves if they want such an odd constraint active. } else if (definite_right) { width = view->preferred_width(canvas); x = containing_box.get_width() - computed_right - width; } else if (definite_width) { x = 0.0f; width = view->style_cascade().computed_value("width").number(); } else { x = 0.0f; width = view->preferred_width(canvas); } bool definite_top = !view->style_cascade().computed_value("top").is_keyword("auto"); bool definite_bottom = !view->style_cascade().computed_value("bottom").is_keyword("auto"); bool definite_height = !view->style_cascade().computed_value("height").is_keyword("auto"); float computed_top = resolve_percentage(view->style_cascade().computed_value("top"), containing_box.get_height()); float computed_bottom = resolve_percentage(view->style_cascade().computed_value("bottom"), containing_box.get_height()); float computed_height = resolve_percentage(view->style_cascade().computed_value("height"), containing_box.get_height()); float y = 0.0f; float height = 0.0f; if (definite_top && definite_bottom) { y = computed_top; height = clan::max(containing_box.get_height() - computed_bottom - y, 0.0f); } else if (definite_top && definite_height) { y = computed_top; height = computed_height; } else if (definite_bottom && definite_height) { height = computed_height; y = containing_box.get_height() - computed_bottom - height; } else if (definite_top) { y = computed_top; height = view->preferred_height(canvas, width); } else if (definite_bottom) { height = view->preferred_height(canvas, width); y = containing_box.get_height() - computed_bottom - height; } else if (definite_height) { y = 0.0f; height = computed_height; } else { y = 0.0f; height = view->preferred_height(canvas, width); } x += containing_box.left; y += containing_box.top; auto tl = canvas.grid_fit(Pointf(x, y)); auto br = canvas.grid_fit(Pointf(x + width, y + height)); Rectf box = Rectf(tl.x, tl.y, br.x, br.y); return ViewGeometry::from_content_box(view->style_cascade(), box); }
void ObjectIcon::draw(DrawingContext& context, Vector pos) { context.draw_surface_part(surface, Rectf(Vector(0,0), surface->get_size()), Rectf(pos + offset, pos + Vector(32,32) - offset), LAYER_GUI - 9); }
namespace tf { const Rectf PeerCircle::sWorldRect = Rectf( 0.f, 0.f, 1000.f, 1000.f ); PeerCircle::PeerCircle( int id, std::string address, float bearing, std::string location, TorrentRef tr ) : Peer( id, address, bearing, location, tr) { Vec2f bv = sWorldRect.getSize() * Vec2f( .3f, .0f ); bv.rotate( bearing ); mOldPos = mPos = sWorldRect.getCenter() + bv; //mDecay = Rand::randFloat( .95f, .99f ); mAttractorPos = sWorldRect.getCenter(); } void PeerCircle::update() { // attraction to torrent position Vec2f dir = mAttractorPos - mPos; float distSqrd = dir.lengthSquared(); float strength = 5.f; if ( distSqrd > 0.f ) { float minDistSqrd = 1000.f; if ( distSqrd < minDistSqrd ) { strength = lmap< float >( 1.f, minDistSqrd, 0.f, strength, distSqrd ); strength = math< float >::clamp( strength, 0.f, 5.f ); } float force = strength * mMass / distSqrd; Vec2f deltaForce = dir * force; moveBy( deltaForce * mInvMass, false ); } // repel other peers const std::vector< PeerRef > &peers = mTorrentRef->getPeers(); for ( PeerRef peer : peers ) { if ( peer->getId() == mId ) continue; auto other = std::static_pointer_cast< PeerCircle >( peer ); Vec2d dir = mPos - other->getPos(); float distSqrd = dir.lengthSquared(); if ( distSqrd > .0f ) { float force = .1f * mMass * other->getMass() / distSqrd; Vec2f deltaForce = dir * force; moveBy( deltaForce * mInvMass, false ); other->moveBy( - deltaForce * other->getInvMass(), false ); } } // do verlet Vec2f curPos = mPos; Vec2f vel = mPos - mOldPos; mPos += vel * mDrag; mOldPos = curPos; /* // TODO: attract actual torrent position Vec2d dir = Vec2d( 500, 500 ) - mPos; double distSqrd = dir.lengthSquared(); if ( distSqrd > 0. ) { double f = math< double >::sqrt( distSqrd ) * .00001; mAcc += dir.normalized() * f; } mVel += mAcc; mPos += mVel; mVel *= mDecay; mAcc.set( 0., 0. ); //mRadius = lerp< double, double >( mRadius, mRadiusOrig, .01 ); */ } void PeerCircle::draw( const Rectf &rect ) { RectMapping rm( sWorldRect, rect, true ); //app::console() << mId << ": " << mRadius << std::endl; gl::color( Color::white() ); gl::drawStrokedCircle( rm.map( mPos ), lmap< float >( 0.f, sWorldRect.getHeight(), 0.f, rect.getHeight(), mRadius ) ); } } // namespace tf
void Menu::draw_item(DrawingContext& context, int index) { float menu_height = get_height(); float menu_width = get_width(); MenuItem& pitem = *(items[index]); Color text_color = ColorScheme::Menu::default_color; float x_pos = pos.x; float y_pos = pos.y + 24*index - menu_height/2 + 12; int text_width = int(Resources::normal_font->get_text_width(pitem.text)); int input_width = int(Resources::normal_font->get_text_width(pitem.input) + 10); int list_width = 0; float left = pos.x - menu_width/2 + 16; float right = pos.x + menu_width/2 - 16; if(pitem.list.size() > 0) { list_width = (int) Resources::normal_font->get_text_width(pitem.list[pitem.selected]); } if (arrange_left) x_pos += 24 - menu_width/2 + (text_width + input_width + list_width)/2; if(index == active_item) { text_color = ColorScheme::Menu::active_color; } if(active_item == index) { float blink = (sinf(real_time * M_PI * 1.0f)/2.0f + 0.5f) * 0.5f + 0.25f; context.draw_filled_rect(Rectf(Vector(pos.x - menu_width/2 + 10 - 2, y_pos - 12 - 2), Vector(pos.x + menu_width/2 - 10 + 2, y_pos + 12 + 2)), Color(1.0f, 1.0f, 1.0f, blink), 14.0f, LAYER_GUI-10); context.draw_filled_rect(Rectf(Vector(pos.x - menu_width/2 + 10, y_pos - 12), Vector(pos.x + menu_width/2 - 10, y_pos + 12)), Color(1.0f, 1.0f, 1.0f, 0.5f), 12.0f, LAYER_GUI-10); } switch (pitem.kind) { case MN_INACTIVE: { context.draw_text(Resources::normal_font, pitem.text, Vector(pos.x, y_pos - int(Resources::normal_font->get_height()/2)), ALIGN_CENTER, LAYER_GUI, ColorScheme::Menu::inactive_color); break; } case MN_HL: { // TODO float x = pos.x - menu_width/2; float y = y_pos - 12; /* Draw a horizontal line with a little 3d effect */ context.draw_filled_rect(Vector(x, y + 6), Vector(menu_width, 4), Color(0.6f, 0.7f, 1.0f, 1.0f), LAYER_GUI); context.draw_filled_rect(Vector(x, y + 6), Vector(menu_width, 2), Color(1.0f, 1.0f, 1.0f, 1.0f), LAYER_GUI); break; } case MN_LABEL: { context.draw_text(Resources::big_font, pitem.text, Vector(pos.x, y_pos - int(Resources::big_font->get_height()/2)), ALIGN_CENTER, LAYER_GUI, ColorScheme::Menu::label_color); break; } case MN_TEXTFIELD: case MN_NUMFIELD: case MN_CONTROLFIELD: { if(pitem.kind == MN_TEXTFIELD || pitem.kind == MN_NUMFIELD) { if(active_item == index) context.draw_text(Resources::normal_font, pitem.get_input_with_symbol(true), Vector(right, y_pos - int(Resources::normal_font->get_height()/2)), ALIGN_RIGHT, LAYER_GUI, ColorScheme::Menu::field_color); else context.draw_text(Resources::normal_font, pitem.get_input_with_symbol(false), Vector(right, y_pos - int(Resources::normal_font->get_height()/2)), ALIGN_RIGHT, LAYER_GUI, ColorScheme::Menu::field_color); } else context.draw_text(Resources::normal_font, pitem.input, Vector(right, y_pos - int(Resources::normal_font->get_height()/2)), ALIGN_RIGHT, LAYER_GUI, ColorScheme::Menu::field_color); context.draw_text(Resources::normal_font, pitem.text, Vector(left, y_pos - int(Resources::normal_font->get_height()/2)), ALIGN_LEFT, LAYER_GUI, text_color); break; } case MN_STRINGSELECT: { float roff = Resources::arrow_left->get_width(); // Draw left side context.draw_text(Resources::normal_font, pitem.text, Vector(left, y_pos - int(Resources::normal_font->get_height()/2)), ALIGN_LEFT, LAYER_GUI, text_color); // Draw right side context.draw_surface(Resources::arrow_left, Vector(right - list_width - roff - roff, y_pos - 8), LAYER_GUI); context.draw_surface(Resources::arrow_right, Vector(right - roff, y_pos - 8), LAYER_GUI); context.draw_text(Resources::normal_font, pitem.list[pitem.selected], Vector(right - roff, y_pos - int(Resources::normal_font->get_height()/2)), ALIGN_RIGHT, LAYER_GUI, text_color); break; } case MN_BACK: { context.draw_text(Resources::normal_font, pitem.text, Vector(pos.x, y_pos - int(Resources::normal_font->get_height()/2)), ALIGN_CENTER, LAYER_GUI, text_color); context.draw_surface(Resources::back, Vector(x_pos + text_width/2 + 16, y_pos - 8), LAYER_GUI); break; } case MN_TOGGLE: { context.draw_text(Resources::normal_font, pitem.text, Vector(pos.x - menu_width/2 + 16, y_pos - (Resources::normal_font->get_height()/2)), ALIGN_LEFT, LAYER_GUI, text_color); if(pitem.toggled) context.draw_surface(Resources::checkbox_checked, Vector(x_pos + (menu_width/2-16) - Resources::checkbox->get_width(), y_pos - 8), LAYER_GUI + 1); else context.draw_surface(Resources::checkbox, Vector(x_pos + (menu_width/2-16) - Resources::checkbox->get_width(), y_pos - 8), LAYER_GUI + 1); break; } case MN_ACTION: context.draw_text(Resources::normal_font, pitem.text, Vector(pos.x, y_pos - int(Resources::normal_font->get_height()/2)), ALIGN_CENTER, LAYER_GUI, text_color); break; case MN_GOTO: context.draw_text(Resources::normal_font, pitem.text, Vector(pos.x, y_pos - int(Resources::normal_font->get_height()/2)), ALIGN_CENTER, LAYER_GUI, text_color); break; } }
EnemyShip1::EnemyShip1(int arrivalTime, float hp, float atkspd, float xpos, float ypos, float xvel, float yvel,PlayerShip* p) : EnemyShip(arrivalTime,hp,atkspd,xpos,ypos,xvel,yvel,46,46,p) { rec = Rectf( Vec2f(pos.x-width/2,pos.y-height/2), Vec2f(pos.x+width/2,pos.y+height/2)); bulletType = 1; }
void TextArea::updateModels() { if (!font.isValid()) { return; } for (auto && model : models) { getScene()->destroyModel(model); } models.clear(); meshes.clear(); // A text area may use multiple textures for different code point areas. A separate model is created for each texture. std::map<Ptr<render::Image>, std::vector<float>> meshVertices; std::map<Ptr<render::Image>, std::vector<unsigned int>> meshIndices; Vector2i cursor {0, font->getLineHeight()}; for (size_t i = 0; i < text.size();) { // Get the next character, move i forward. unsigned int c = getChar(text, i); if (c == '\n') { cursor[1] += font->getLineHeight(); cursor[0] = 0; continue; } else if (c == '\r') { continue; } else if (c == '\t') { cursor[0] += font->getLineHeight(); continue; } // Get the font information for the next character. render::Font::GlyphCoords const & glyphCoords = font->getGlyphCoordsFromChar(c); Ptr<render::Image> glyphImage = font->getImageFromChar(c); // Setup the vertice and indices for this glyph. Rectf glyphBounds; glyphBounds.min = Vector2f(cursor + glyphCoords.offset); glyphBounds.setSize(Vector2f(glyphCoords.uvBounds.getSize())); Rectf glyphUVBounds = Rectf(glyphCoords.uvBounds); glyphUVBounds.max += Vector2f {1, 1}; std::vector<float> & vertices = meshVertices[glyphImage]; int startingIndex = (int)vertices.size() / 4; vertices.push_back(glyphBounds.min[0]); vertices.push_back(glyphBounds.min[1]); vertices.push_back(glyphUVBounds.min[0]); vertices.push_back(glyphUVBounds.min[1]); vertices.push_back(glyphBounds.max[0]); vertices.push_back(glyphBounds.min[1]); vertices.push_back(glyphUVBounds.max[0]); vertices.push_back(glyphUVBounds.min[1]); vertices.push_back(glyphBounds.max[0]); vertices.push_back(glyphBounds.max[1]); vertices.push_back(glyphUVBounds.max[0]); vertices.push_back(glyphUVBounds.max[1]); vertices.push_back(glyphBounds.min[0]); vertices.push_back(glyphBounds.max[1]); vertices.push_back(glyphUVBounds.min[0]); vertices.push_back(glyphUVBounds.max[1]); std::vector<unsigned int> & indices = meshIndices[glyphImage]; indices.push_back(startingIndex + 0); indices.push_back(startingIndex + 2); indices.push_back(startingIndex + 1); indices.push_back(startingIndex + 0); indices.push_back(startingIndex + 3); indices.push_back(startingIndex + 2); cursor[0] += glyphCoords.advance; } // Construct the models form the text. for (auto const & pair : meshVertices) { auto image = pair.first; auto model = getScene()->createModel(); meshes.push_back(std::move(OwnPtr<render::Mesh>::returnNew())); auto & mesh = meshes.back(); meshes.back()->setVertices(0, meshVertices[image], sizeof(float) * 4, false); meshes.back()->setVertexComponent(0, 2, 0, 0); meshes.back()->setVertexComponent(1, 2, sizeof(float) * 2, 0); mesh->setIndices(meshIndices[image]); model->setMesh(mesh); model->setShader(getShader()); model->setImageAtSlot(image, 0); model->setUniformsFunction([this, image](Ptr<render::Shader> const & shader) { shader->setUniformValue<Vector2f>(originUniformLocation, (Vector2f)bounds.min); shader->setUniformValue<Vector2f>(imageSizeUniformLocation, (Vector2f)image->getSize()); shader->setUniformValue<int>(imageUniformLocation, 0); shader->setUniformValue<Vector4f>(colorUniformLocation, color); }); model->setDepth(depth); models.push_back(model); } }
void PretzelTextField::updateBounds(const ci::vec2 &offset, const ci::Rectf &parentBounds) { BasePretzel::updateBounds(offset, parentBounds); // this could be cleaner mTextFieldBounds = Rectf(mLabelSize.x + 25, mBounds.y1 + 5, mBounds.x2 - 10, mBounds.y2 - 5); }
void TextWidget::setText(const std::string & text) { m_text = text; Vec2i textSize = m_font->getTextSize(m_text); m_rect = Rectf(m_rect.topLeft(), float(textSize.x + 1), float(textSize.y + 1)); }
void EERIEAddBitmap(const RenderMaterial & mat, const Vec3f & p, float sx, float sy, TextureContainer * tex, Color color) { TexturedQuad s; CreateBitmap(s, Rectf(Vec2f(p.x, p.y), sx, sy), p.z, tex, color, false); RenderBatcher::getInstance().add(mat, s); }