static void ARX_SPEECH_Render() {
long igrec = 14;
Vec2i sSize = hFontInBook->getTextSize("p");
sSize.y *= 3;
int iEnd = igrec + sSize.y;
for(size_t i = 0; i < MAX_SPEECH; i++) {
if(speech[i].timecreation == 0 || speech[i].text.empty()) {
continue;
}
Rectf rect(
Vec2f(120 * g_sizeRatio.x - 16 * minSizeRatio(), igrec),
16 * minSizeRatio(),
16 * minSizeRatio()
);
GRenderer->SetRenderState(Renderer::AlphaBlending, true);
GRenderer->SetBlendFunc(Renderer::BlendSrcAlpha, Renderer::BlendInvSrcAlpha);
EERIEDrawBitmap(rect, .00001f, arx_logo_tc, Color::white);
igrec += ARX_UNICODE_DrawTextInRect(hFontInBook, Vec2f(120.f * g_sizeRatio.x, igrec), 500 * g_sizeRatio.x,
' ' + speech[i].text, Color::white, NULL);
if(igrec > iEnd && !isLastSpeech(i)) {
ARX_SPEECH_MoveUp();
break;
}
}
GRenderer->SetRenderState(Renderer::AlphaBlending, false);
}
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() && 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);
}
characterCreationAddDescription(m_desc_quickgen);
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();
}
characterCreationAddDescription(m_desc_skin);
color = Color::white;
} else {
color = Color::rgb(0.91f, 0.8f, 0.56f);
}
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);
}
}
characterCreationAddDescription(m_desc_done);
} 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 ARX_MAGICAL_FLARES_Update() {
if(!flarenum)
return;
shinum++;
if(shinum >= 10) {
shinum = 1;
}
long TICKS = long(arxtime) - FRAMETICKS;
FRAMETICKS = (unsigned long)(arxtime);
if(TICKS < 0) {
return;
}
bool key = !GInput->actionPressed(CONTROLS_CUST_MAGICMODE);
RenderMaterial mat;
mat.setBlendType(RenderMaterial::Additive);
EERIE_LIGHT * light = lightHandleGet(torchLightHandle);
for(long j = 1; j < 5; j++) {
TextureContainer * surf;
switch(j) {
case 2: surf = flaretc.lumignon; break;
case 3: surf = flaretc.lumignon2; break;
case 4: surf = flaretc.plasm; break;
default: surf = flaretc.shine[shinum]; break;
}
mat.setTexture(surf);
for(size_t i = 0; i < MAX_FLARES; i++) {
FLARES & flare = magicFlares[i];
if(!flare.exist || flare.type != j) {
continue;
}
flare.tolive -= float(TICKS * 2);
if(flare.flags & 1) {
flare.tolive -= float(TICKS * 4);
} else if (key) {
flare.tolive -= float(TICKS * 6);
}
float z = (flare.tolive * 0.00025f);
float s;
if(flare.type == 1) {
s = flare.size * 2 * z;
} else if(flare.type == 4) {
s = flare.size * 2.f * z + 10.f;
} else {
s = flare.size;
}
if(flare.tolive <= 0.f || flare.pos.y < -64.f || s < 3.f) {
removeFlare(flare);
continue;
}
if(flare.type == 1 && z < 0.6f) {
z = 0.6f;
}
Color3f c = flare.rgb * z;
flare.tv.color = c.toRGB();
flare.v.p = flare.tv.p;
light->rgb = componentwise_max(light->rgb, c);
if(lightHandleIsValid(flare.dynlight)) {
EERIE_LIGHT * el = lightHandleGet(flare.dynlight);
el->pos = flare.v.p;
el->rgb = c;
}
mat.setDepthTest(flare.io != NULL);
if(flare.bDrawBitmap) {
s *= 2.f * minSizeRatio();
EERIEAddBitmap(mat, flare.v.p, s, s, surf, Color::fromRGBA(flare.tv.color));
} else {
EERIEAddSprite(mat, flare.v.p, s * 0.025f + 1.f,
Color::fromRGBA(flare.tv.color), 2.f);
}
}
}
light->rgb = componentwise_min(light->rgb, Color3f::white);
}
void LoadLevelScreen(long num) {
// resets status
if(num < -1) {
delete tc, tc = NULL;
lastloadednum = -1;
lastnum = -1;
PROGRESS_BAR_TOTAL = 0;
return;
}
if(num == -1) {
num = lastnum;
}
lastnum = num;
if(num < 0) {
return;
}
static u32 last_progress_bar_update = platform::getTimeMs();
// only update if time since last update to progress bar > 16ms
// and progress bar's value has actually changed
if (platform::getElapsedMs(last_progress_bar_update) > 16 &&
OLD_PROGRESS_BAR_COUNT != PROGRESS_BAR_COUNT)
{
GRenderer->GetTextureStage(0)->setMinFilter(TextureStage::FilterLinear);
GRenderer->GetTextureStage(0)->setMagFilter(TextureStage::FilterLinear);
float ratio = (PROGRESS_BAR_TOTAL > 0.f ? PROGRESS_BAR_COUNT / PROGRESS_BAR_TOTAL : 0);
ratio = glm::clamp(ratio, 0.f, 1.f);
GRenderer->Clear(Renderer::ColorBuffer | Renderer::DepthBuffer);
GRenderer->SetRenderState(Renderer::DepthTest, true);
GRenderer->SetCulling(Renderer::CullNone);
GRenderer->SetRenderState(Renderer::DepthWrite, true);
GRenderer->SetRenderState(Renderer::Fog, false);
GRenderer->SetRenderState(Renderer::AlphaBlending, false);
if (num == 10) {
pbar = TextureContainer::LoadUI("graph/interface/menus/load_full");
} else {
pbar = TextureContainer::LoadUI("graph/interface/menus/load_full_level");
}
nopbar = 1;
if(num != lastloadednum) {
delete tc, tc = NULL;
lastloadednum = num;
char temp[256];
char tx[256];
GetLevelNameByNum(num, tx);
sprintf(temp, "graph/levels/level%s/loading", tx);
tc = TextureContainer::LoadUI(temp, TextureContainer::NoColorKey);
}
float scale = minSizeRatio();
if(tc) {
GRenderer->SetRenderState(Renderer::ColorKey, false);
Vec2f size = (num == 10) ? Vec2f(640, 480) : Vec2f(320, 390);
size *= scale;
Vec2f pos = Vec2f(g_size.center());
pos += -size * 0.5f;
EERIEDrawBitmap2(Rectf(pos, size.x, size.y), 0.001f, tc, Color::white);
GRenderer->SetRenderState(Renderer::ColorKey, true);
}
if(pbar) {
Vec2f pos = Vec2f(g_size.center());
pos += Vec2f(-100 * scale, ((num == 10) ? 221 : 35) * scale);
Vec2f size = Vec2f(ratio * 200 * scale, 8 * scale);
EERIEDrawBitmap_uv(Rectf(pos, size.x, size.y), 0.f, pbar, Color::white, 0.f, 0.f, ratio, 1.f);
}
mainApp->getWindow()->showFrame();
OLD_PROGRESS_BAR_COUNT = PROGRESS_BAR_COUNT;
last_progress_bar_update = platform::getTimeMs();
}
}
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;
}
void ARX_MAGICAL_FLARES_Update() {
if(!g_magicFlaresCount)
return;
shinum++;
if(shinum >= 10) {
shinum = 1;
}
float diff = toMs(g_platformTime.lastFrameDuration());
bool key = !GInput->actionPressed(CONTROLS_CUST_MAGICMODE);
RenderMaterial mat;
mat.setBlendType(RenderMaterial::Additive);
EERIE_LIGHT * light = lightHandleGet(torchLightHandle);
for(long j = 1; j < 5; j++) {
TextureContainer * surf;
switch(j) {
case 2: surf = g_magicFlareTextures.lumignon; break;
case 3: surf = g_magicFlareTextures.lumignon2; break;
case 4: surf = g_magicFlareTextures.plasm; break;
default: surf = g_magicFlareTextures.shine[shinum]; break;
}
mat.setTexture(surf);
for(size_t i = 0; i < g_magicFlaresMax; i++) {
MagicFlare & flare = g_magicFlares[i];
if(!flare.exist || flare.type != j) {
continue;
}
flare.tolive -= diff * 2.f;
if(flare.flags & 1) {
flare.tolive -= diff * 4.f;
} else if (key) {
flare.tolive -= diff * 6.f;
}
float z = (flare.tolive * 0.00025f);
float size;
if(flare.type == 1) {
size = flare.size * 2 * z;
} else if(flare.type == 4) {
size = flare.size * 2.f * z + 10.f;
} else {
size = flare.size;
}
if(flare.tolive <= 0.f || flare.pos.y < -64.f || size < 3.f) {
removeFlare(flare);
continue;
}
if(flare.type == 1 && z < 0.6f) {
z = 0.6f;
}
Color3f c = flare.rgb * z;
flare.tv.color = c.toRGB();
flare.v.p = flare.tv.p;
light->rgb = componentwise_max(light->rgb, c);
EERIE_LIGHT * el = lightHandleGet(flare.dynlight);
if(el) {
el->pos = flare.v.p;
el->rgb = c;
}
mat.setDepthTest(flare.io != NULL);
if(flare.bDrawBitmap) {
size *= 2.f * minSizeRatio();
EERIEAddBitmap(mat, flare.v.p, size, size, surf, Color::fromRGBA(flare.tv.color));
} else {
EERIEAddSprite(mat, flare.v.p, size * 0.025f + 1.f,
Color::fromRGBA(flare.tv.color), 2.f);
}
}
}
light->rgb = componentwise_min(light->rgb, Color3f::white);
}
