static bool powerup_help_render(float t) {
if(t != 0.0f)
game_update_empty();
UIElement* element = uidesc_get("powerup_help");
UIElement* text_elem2 = uidesc_get_child(element, "text2");
UIElement* text_elem3 = uidesc_get_child(element, "text3");
UIElement* star = uidesc_get_child(element, "star");
UIElement* item = uidesc_get_child(element, "item");
UIElement* button_quit = uidesc_get_child(element, "button_quit");
float state_alpha = 1.0f-fabsf(t);
byte a = lrintf(255.0f * state_alpha);
Color col = COLOR_RGBA(255, 255, 255, a);
spr_draw("blue_shade", hud_layer-1, rectf(0.0f, 0.0f, v_width, v_height), col);
static float xpos = 0.0f;
static float inc = 600.0f;
xpos = hud_scroll(xpos, inc, item_count, t);
for(uint i = 0; i < item_count; ++i) {
Vector2 off = vec2(xpos + i * inc, 0.0f);
float d = normalize(fabsf(off.x), 0.0f, inc * (item_count-1));
float scroll_alpha = 1.0f / exp(PI*d);
byte a2 = lrintf(255.0f * scroll_alpha * state_alpha);
Color col2 = COLOR_RGBA(255, 255, 255, a2);
// Star
spr_draw_cntr_h(star->spr, hud_layer, vec2_add(off, star->vec2), time_s()/10.0f, 1.0f, col2);
// Item
const char* item_img = powerup_params[i].unlocked_spr;
spr_draw_cntr(item_img, hud_layer, vec2_add(off, item->vec2), 0.0f, 1.0f, col2);
// Description text
const char* text3 = powerup_params[i].description;
vfont_select(FONT_NAME, 32.0f);
Vector2 half_size3 = vec2_scale(vfont_size(text3), 0.5f);
vfont_draw(text3, hud_layer+1, vec2_add(off, vec2_sub(text_elem3->vec2,half_size3)), col2);
// Item name
const char* text2 = powerup_params[i].name;
vfont_select(FONT_NAME, 48.0f);
Vector2 half_size2 = vec2_scale(vfont_size(text2), 0.5f);
vfont_draw(text2, hud_layer+1, vec2_add(off, vec2_sub(text_elem2->vec2,half_size2)), col2);
}
// Quit button
if(hud_button(button_quit, col, t)) {
malka_states_pop();
}
return true;
}
//==========================================
// AITools_ShowPlinks
// Draws lines from the current node to it's plinks nodes
//==========================================
static void AITools_ShowPlinks( edict_t *target )
{
static unsigned int debugdrawplinks_timeout;
int current_node;
int plink_node;
int i;
nav_ents_t *goalEnt;
if( !target || !target->r.client || !target->r.client->level.showPLinks )
return;
//do it
current_node = AI_FindClosestReachableNode( target->s.origin, target, NODE_DENSITY * 3, NODE_ALL );
// draw the axis where the node is
if( nodes[current_node].flags & NODEFLAGS_SERVERLINK )
AITools_DrawAxis( nodes[current_node].origin, COLOR_RGBA( 255, 25, 25, 255 ) );
else
AITools_DrawAxis( nodes[current_node].origin, COLOR_RGBA( 210, 250, 250, 255 ) );
//don't draw the links every frame (flood)
if( level.time < debugdrawplinks_timeout )
return;
debugdrawplinks_timeout = level.time + 4 * game.snapFrameTime;
if( nav.editmode || !nav.loaded )
return;
FOREACH_GOALENT( goalEnt )
{
i = goalEnt->id;
if( goalEnt->node == current_node )
{
if( !goalEnt->ent->classname )
G_CenterPrintMsg( target, "no classname" );
else
G_CenterPrintMsg( target, "%s", goalEnt->ent->classname );
break;
}
}
// no links to draw
if( !pLinks[current_node].numLinks )
return;
for( i = 0; i < pLinks[current_node].numLinks; i++ )
{
plink_node = pLinks[current_node].nodes[i];
if( pLinks[current_node].moveType[i] == LINK_ROCKETJUMP )
AITools_DrawColorLine( nodes[current_node].origin,
nodes[plink_node].origin, COLOR_RGBA( 0xff, 0x00, 0x00, 0x80 ), 0 );
else if( pLinks[current_node].moveType[i] == LINK_JUMP )
AITools_DrawColorLine( nodes[current_node].origin,
nodes[plink_node].origin, COLOR_RGBA( 0x00, 0x00, 0xff, 0x80 ), 0 );
else
AITools_DrawColorLine( nodes[current_node].origin,
nodes[plink_node].origin, COLOR_RGBA( 0x00, 0xff, 0x00, 0x80 ), 0 );
}
}
void target_laser_start( edict_t *self )
{
edict_t *ent;
self->movetype = MOVETYPE_NONE;
self->r.solid = SOLID_NOT;
self->s.type = ET_BEAM;
self->s.modelindex = 1; // must be non-zero
self->r.svflags = SVF_TRANSMITORIGIN2;
// set the beam diameter
if( self->spawnflags & 64 )
self->s.frame = 16;
else
self->s.frame = 4;
// set the color
if( self->spawnflags & 2 )
self->s.colorRGBA = COLOR_RGBA( 220, 0, 0, 76 );
else if( self->spawnflags & 4 )
self->s.colorRGBA = COLOR_RGBA( 0, 220, 0, 76 );
else if( self->spawnflags & 8 )
self->s.colorRGBA = COLOR_RGBA( 0, 0, 220, 76 );
else if( self->spawnflags & 16 )
self->s.colorRGBA = COLOR_RGBA( 220, 220, 0, 76 );
else if( self->spawnflags & 32 )
self->s.colorRGBA = COLOR_RGBA( 255, 255, 0, 76 );
if( !self->enemy )
{
if( self->target )
{
ent = G_Find( NULL, FOFS( targetname ), self->target );
if( !ent )
if( developer->integer )
G_Printf( "%s at %s: %s is a bad target\n", self->classname, vtos( self->s.origin ), self->target );
self->enemy = ent;
}
else
{
G_SetMovedir( self->s.angles, self->moveinfo.movedir );
}
}
self->use = target_laser_use;
self->think = target_laser_think;
if( !self->dmg )
self->dmg = 1;
if( self->spawnflags & 1 )
target_laser_on( self );
else
target_laser_off( self );
}
//=================================================================================================
void PickServerPanel::Draw(ControlDrawData*)
{
// t³o
GUI.DrawSpriteFull(tBackground, COLOR_RGBA(255,255,255,128));
// panel
GUI.DrawItem(tDialog, global_pos, size, COLOR_RGBA(255,255,255,222), 16);
// przyciski
for(int i=0; i<2; ++i)
bts[i].Draw();
// grid
grid.Draw();
}
//=================================================================================================
void DialogBox::Draw(ControlDrawData*)
{
GUI.DrawSpriteFull(tBackground, COLOR_RGBA(255, 255, 255, 128));
pos = (GUI.wnd_size - size) / 2;
GUI.DrawItem(tDialog, pos, size, COLOR_RGBA(255, 255, 255, 222), 16);
for(uint i = 0; i < bts.size(); ++i)
{
bts[i].global_pos = bts[i].pos + pos;
bts[i].Draw();
}
Rect r = { pos.x + 12, pos.y + 12, pos.x + size.x - 12, pos.y + size.y - 12 };
GUI.DrawText(GUI.default_font, text, DT_CENTER, BLACK, r);
}
static void obj_deco_construct(GameObject* self, Vector2 pos, void* user_data) {
SprHandle spr_handle = (SprHandle)user_data;
Vector2 size = sprsheet_get_size_h(spr_handle);
RectF dest = {
pos.x, pos.y - size.y,
pos.x + size.x, pos.y
};
// Render
RenderComponent* render = self->render;
render->world_dest = dest;
render->color = COLOR_RGBA(255, 255, 255, 255);
render->anim_frame = MAX_UINT16;
render->spr = spr_handle;
switch(self->type){
case OBJ_FG_DECO_TYPE:
render->layer = ground_layer;
render->camera = 0;
break;
default:
render->layer = bg_mushrooms_layer;
render->camera = 1;
break;
}
}
void ai_debug_vis_draw(NavMesh* navmesh, uint layer) {
assert(navmesh);
assert(navmesh->vis_bitmap);
Color c = COLOR_RGBA(196, 196, 196, 96);
// Draw, join horizontal runs into spans
for(uint y = 0; y < vis_bitmap_height; ++y) {
RectF dest = {
0.0f, (float)y * vis_cell_height,
0.0f, (float)(y+1) * vis_cell_height
};
for(uint x = 0; x < vis_bitmap_width; ++x) {
if(_query_vis_bitmap(navmesh, x, y)) {
dest.right += vis_cell_width;
}
else {
if(rectf_width(&dest) > 0.0f)
video_draw_rect(0, layer, NULL, &dest, c);
dest.left = dest.right = (float)(x+1) * vis_cell_width;
}
}
if(rectf_width(&dest) > 0.0f)
video_draw_rect(0, layer, NULL, &dest, c);
}
}
//=================================================================================================
void DialogWithImage::Draw(ControlDrawData*)
{
GUI.DrawSpriteFull(tBackground, COLOR_RGBA(255, 255, 255, 128));
pos = (GUI.wnd_size - size) / 2;
GUI.DrawItem(tDialog, pos, size, COLOR_RGBA(255, 255, 255, 222), 16);
for(uint i = 0; i < bts.size(); ++i)
{
bts[i].global_pos = bts[i].pos + pos;
bts[i].Draw();
}
Rect r = text_rect + pos;
GUI.DrawText(GUI.default_font, text, DT_CENTER, BLACK, r);
GUI.DrawSprite(img, img_pos + pos);
}
void OGLRender::SetFogColor(uint32_t r, uint32_t g, uint32_t b, uint32_t a)
{
gRDP.fogColor = COLOR_RGBA(r, g, b, a);
gRDP.fvFogColor[0] = r/255.0f; //r
gRDP.fvFogColor[1] = g/255.0f; //g
gRDP.fvFogColor[2] = b/255.0f; //b
gRDP.fvFogColor[3] = a/255.0f; //a
}
//=================================================================================================
void GetNumberDialog::Draw(ControlDrawData* cdd/* =nullptr */)
{
GUI.DrawSpriteFull(tBackground, COLOR_RGBA(255, 255, 255, 128));
GUI.DrawItem(tDialog, global_pos, size, COLOR_RGBA(255, 255, 255, 222), 16);
for(int i = 0; i < 2; ++i)
bts[i].Draw();
Rect r = { global_pos.x + 16,global_pos.y + 16,global_pos.x + size.x,global_pos.y + size.y };
GUI.DrawText(GUI.default_font, text, DT_CENTER, BLACK, r);
textBox.Draw();
scrollbar.Draw();
Rect r2 = { global_pos.x + 16,global_pos.y + 124,global_pos.x + size.x - 16,global_pos.y + size.y };
GUI.DrawText(GUI.default_font, Format("%d", min_value), DT_LEFT, BLACK, r2);
GUI.DrawText(GUI.default_font, Format("%d", max_value), DT_RIGHT, BLACK, r2);
}
//=================================================================================================
void GamePanel::DrawBoxInternal()
{
int alpha = int(box_alpha*222),
alpha2 = int(box_alpha*255);
// box
GUI.DrawItem(tDialog, box_pos, box_size, COLOR_RGBA(255,255,255,alpha), 12);
// obrazek
if(box_img)
GUI.DrawSprite(box_img, box_img_pos, COLOR_RGBA(255,255,255,alpha2));
// du¿y tekst
GUI.DrawText(GUI.default_font, box_text, 0, COLOR_RGBA(0,0,0,alpha2), box_big);
// ma³y tekst
if(!box_text_small.empty())
GUI.DrawText(GUI.fSmall, box_text_small, 0, COLOR_RGBA(0,0,0,alpha2), box_small);
}
CClient3DMarker::CClient3DMarker ( CClientMarker * pThis )
{
// Init
m_pThis = pThis;
m_bMarkerStreamedIn = false;
m_bVisible = true;
m_rgbaColor = COLOR_RGBA ( 255, 0, 0, 128 );
m_fSize = 4.0f;
m_dwType = MARKER3D_CYLINDER2;
m_pMarker = NULL;
m_ulIdentifier = (DWORD)this;
}
void draw_grid(uint layer, float spacing) {
const Color grid_col1 = COLOR_RGBA(196, 196, 196, 128);
const Color grid_col2 = COLOR_RGBA(128, 128, 128, 128);
Vector2 start, end;
uint n = 0;
float x = screen_width / 2.0f;
while(x > 0.0f) {
start = vec2(x, 0.0f);
end = vec2(x, screen_height);
video_draw_line(layer, &start, &end, (n++ % 5)==0 ? grid_col1 : grid_col2);
x -= spacing;
}
n = 0;
x = screen_width / 2.0f;
while(x < screen_width) {
start = vec2(x, 0.0f);
end = vec2(x, screen_height);
video_draw_line(layer, &start, &end, (n++ % 5)==0 ? grid_col1 : grid_col2);
x += spacing;
}
n = 0;
float y = screen_height / 2.0f;
while(y > 0.0f) {
start = vec2(0.0f, y);
end = vec2(screen_width, y);
video_draw_line(layer, &start, &end, (n++ % 5)==0 ? grid_col1 : grid_col2);
y -= spacing;
}
n = 0;
y = screen_height / 2.0f;
while(y < screen_height) {
start = vec2(0.0f, y);
end = vec2(screen_width, y);
video_draw_line(layer, &start, &end, (n++ % 5)==0 ? grid_col1 : grid_col2);
y += spacing;
}
}
//=================================================================================================
void MultiplayerPanel::Draw(ControlDrawData*)
{
// t³o
GUI.DrawSpriteFull(tBackground, COLOR_RGBA(255, 255, 255, 128));
// panel
GUI.DrawItem(tDialog, global_pos, size, COLOR_RGBA(255, 255, 255, 222), 16);
// tekst
Rect r = { global_pos.x + 12, global_pos.y + 8, global_pos.x + size.x - 12, global_pos.y + size.y };
GUI.DrawText(GUI.fBig, txMultiplayerGame, DT_TOP | DT_CENTER, BLACK, r);
// tekst nick
r.Top() += 60;
GUI.DrawText(GUI.default_font, txNick, 0, BLACK, r);
// textbox
textbox.Draw();
// przyciski
for(int i = 0; i < 5; ++i)
bts[i].Draw();
}
//=================================================================================================
void ListBox::Draw(ControlDrawData*)
{
if(extended)
{
// box
GUI.DrawItem(GUI.tBox, global_pos, size, WHITE, 8, 32);
// element
if(selected != -1)
{
RECT rc = {global_pos.x+2, global_pos.y+2, global_pos.x+size.x-12, global_pos.y+size.y-2};
GUI.DrawText(GUI.default_font, *texts[selected], DT_SINGLELINE, BLACK, rc, &rc);
}
// obrazek
GUI.DrawSprite(GUI.tDown, INT2(global_pos.x+size.x-10, global_pos.y+(size.y-10)/2));
// powinno byæ tu ale wtedy by³a by z³a kolejnoœæ rysowania
//if(menu->visible)
// menu->Draw();
}
else
{
// box
GUI.DrawItem(GUI.tBox, global_pos, real_size, WHITE, 8, 32);
// zaznaczenie
RECT rc = {global_pos.x, global_pos.y, global_pos.x+real_size.x, global_pos.y+real_size.y};
if(selected != -1)
{
RECT rs = {global_pos.x+2, global_pos.y-int(scrollbar.offset)+2+selected*20, global_pos.x+real_size.x-2};
rs.bottom = rs.top + 20;
RECT out;
if(IntersectRect(&out, &rs, &rc))
GUI.DrawSpriteRect(GUI.tPix, out, COLOR_RGBA(0,255,0,128));
}
// elementy
RECT r = {global_pos.x+2, global_pos.y-int(scrollbar.offset)+2, global_pos.x+real_size.x-2, rc.bottom-2};
for(vector<string*>::iterator it = texts.begin(), end = texts.end(); it != end; ++it)
{
if(!GUI.DrawText(GUI.default_font, **it, DT_SINGLELINE, BLACK, r, &rc))
break;
r.top += 20;
}
// pasek przewijania
scrollbar.Draw();
}
}
int CLuaFunctionDefs::tocolor ( lua_State* luaVM )
{
// int tocolor ( int red, int green, int blue [, int alpha = 255] )
int iRed; int iGreen; int iBlue; int iAlpha;
CScriptArgReader argStream ( luaVM );
argStream.ReadNumber ( iRed );
argStream.ReadNumber ( iGreen );
argStream.ReadNumber ( iBlue );
argStream.ReadNumber ( iAlpha, 255 );
if ( !argStream.HasErrors () )
{
// Make it into an unsigned long
unsigned long ulColor = COLOR_RGBA ( iRed, iGreen, iBlue, iAlpha );
lua_pushinteger ( luaVM, static_cast < lua_Integer > ( ulColor ) );
return 1;
}
// Make it black so funcs dont break
unsigned long ulColor = COLOR_RGBA ( 0, 0, 0, 255 );
lua_pushnumber ( luaVM, static_cast < lua_Number > ( ulColor ) );
return 1;
}
//=================================================================================================
void FlowContainer::Draw(ControlDrawData*)
{
GUI.DrawItem(GUI.tBox, global_pos, size - Int2(16, 0), WHITE, 8, 32);
scroll.Draw();
int sizex = size.x - 16;
Rect rect;
Rect clip = Rect::Create(global_pos + Int2(2, 2), Int2(sizex - 2, size.y - 2));
int offset = (int)scroll.offset;
DWORD flags = (word_warp ? 0 : DT_SINGLELINE) | DT_PARSE_SPECIAL;
for(FlowItem* fi : items)
{
if(fi->type != FlowItem::Button)
{
rect = Rect::Create(global_pos + fi->pos - Int2(0, offset), fi->size);
// text above box
if(rect.Bottom() < global_pos.y)
continue;
if(fi->state == Button::DOWN)
{
Rect rs = { global_pos.x + 2, rect.Top(), global_pos.x + sizex, rect.Bottom() };
Rect out;
if(Rect::Intersect(rs, clip, out))
GUI.DrawSpriteRect(GUI.tPix, out, COLOR_RGBA(0, 255, 0, 128));
}
if(!GUI.DrawText(fi->type == FlowItem::Section ? GUI.fBig : GUI.default_font, fi->text, flags,
(fi->state != Button::DISABLED ? BLACK : COLOR_RGB(64, 64, 64)), rect, &clip))
break;
}
else
{
// button above or below box
if(global_pos.y + fi->pos.y - offset + fi->size.y < global_pos.y ||
global_pos.y + fi->pos.y - offset > global_pos.y + size.y)
continue;
GUI.DrawSprite(button_tex[fi->tex_id].tex[fi->state], global_pos + fi->pos - Int2(0, offset), WHITE, &clip);
}
}
}
//=================================================================================================
void CreateCharacterPanel::Draw(ControlDrawData*)
{
// t³o
GUI.DrawSpriteFull(tBackground, COLOR_RGBA(255,255,255,128));
// panel
GUI.DrawItem(tDialog, global_pos, size, COLOR_RGBA(255,255,255,222), 16);
// napis u góry
RECT rect0 = {12+pos.x, 12+pos.y, pos.x+size.x-12, 12+pos.y+72};
GUI.DrawText(GUI.fBig, txCharacterCreation, DT_NOCLIP|DT_CENTER|DT_VCENTER, BLACK, rect0);
// postaæ
GUI.DrawSprite(game->tChar, INT2(pos.x+228,pos.y+94));
RECT rect;
MATRIX mat;
if(mode == PickClass)
{
// przyciski
for(int i=0; i<5; ++i)
bts[i].Draw();
// paski atrybutów
for(int i=0; i<A_MAX; ++i)
{
D3DXMatrixTransformation2D(&mat, NULL, 0.f, &VEC2(180.f/256,17.f/32), NULL, 0.f, &VEC2(float(388+pos.x),float(97+pos.y+19*i)));
RECT r = {0,0,int(float(unit->attrib[i]-50)/20*256),32};
GUI.DrawSpriteTransformPart(game->tKlasaCecha, mat, r);
}
// paski umiejêtnoœci
for(int i=0; i<S_MAX; ++i)
{
D3DXMatrixTransformation2D(&mat, NULL, 0.f, &VEC2(180.f/256,17.f/32), NULL, 0.f, &VEC2(float(388+pos.x),float(173+pos.y+19*i)));
RECT r = {0,0,int(float(unit->skill[i])/25*256),32};
GUI.DrawSpriteTransformPart(game->tKlasaCecha, mat, r);
}
// wartoœci atrybutów / umiejêtnoœci
rect.left = 390+int(pos.x);
rect.right = size.x-12+int(pos.x);
rect.top = 96+int(pos.y);
rect.bottom = size.y-112+int(pos.y);
UnitData& ud = *FindUnitData(g_classes[clas].id);
LocalString s;
for(int i=0; i<A_MAX; ++i)
s += Format("%s: %d\n", g_attribute_info[i].name, ud.attrib[i].x);
s += "\n";
for(int i=0; i<S_MAX; ++i)
s += Format("%s: %d\n", skill_infos[i].name, ud.skill[i].x);
GUI.DrawText(GUI.default_font, s, 0, BLACK, rect);
// opis klasy
RECT rect2 = {130+int(pos.x), 344+int(pos.y)};
rect2.right = rect2.left + 341;
rect2.bottom = rect2.top + 93;
GUI.DrawText(GUI.default_font, g_classes[clas].desc, 0, BLACK, rect2);
}
else
{
for(int i=0; i<2; ++i)
bts2[i].Draw();
if(!game->IsOnline())
checkbox.Draw();
for(int i=0; i<5; ++i)
slider[i].Draw();
}
}
//=================================================================================================
void GamePanel::Draw(ControlDrawData*)
{
GUI.DrawItem(tBackground, pos, size, COLOR_RGBA(255,255,255,222), 16);
}
#include "Eagle.h"
const float EAGLE_CONSOLE_DEPTH = 0.01;
const float EAGLE_CONSOLE_HEIGHT = 240;
const float EAGLE_CONSOLE_INFORMATION_PANEL_HEIGHT = 30;
const float EAGLE_CONSOLE_CHARACTER_HEIGHT = 17;
const float EAGLE_FONT_LINE_SPACING = 1.0 / 17.0;
const float EAGLE_CONSOLE_FONT_DEPTH_OFFSET = 0.00;
#define EAGLE_CONSOLE_RESTORE_SPEED (15.0 * EAGLE_CONSOLE_HEIGHT * eagle.getFrameTime())
#define EAGLE_CONSOLE_INFORMATION_PANEL_RESTORE_SPEED (15.0 * EAGLE_CONSOLE_INFORMATION_PANEL_HEIGHT * eagle.getFrameTime());
const int CONSOLE_MAX_LINE_COUNT = 256;
const ColorValue CONSOLE_OUTPUT_COLOR_DEFAULT = COLOR_RGBA(1, 1, 1, 1);
const ColorValue CONSOLE_OUTPUT_COLOR_SUCCESS = COLOR_RGBA(0, 1, 0, 1);
const ColorValue CONSOLE_OUTPUT_COLOR_WARNING = COLOR_RGBA(1, 0, 0, 1);
namespace ProjectEagle
{
Script commandHandler;
Console::Console()
{
initialized = 0;
showing = 0;
mainPanelLocked = 0;
informationPanelLocked = 0;
}
bool Console::initialize()
{
topColor = COLOR_RGBA(0.1, 0.1, 0.1, 0.9);
bottomColor = COLOR_RGBA(0.1, 0.1, 0.1, 0.9);
informationPanelBottomColor = COLOR_RGBA(0.1, 0.1, 0.1, 0.8);
position.y = graphics.getScreenHeight();
informationPanelPosition.y = -EAGLE_CONSOLE_INFORMATION_PANEL_HEIGHT;
height = EAGLE_CONSOLE_HEIGHT;
informationPanelHeight = EAGLE_CONSOLE_INFORMATION_PANEL_HEIGHT;
fontOffset.set(5, 5);
#ifndef PLATFORM_WP8
if(!font.loadImage("Data/Fonts/Arial/Arial.png"))
{
return 0;
}
#else
if(!font.loadImage("Data/Fonts/Arial/Arial.dds"))
{
return 0;
}
#endif
font.detectCharacterDimensionsFromTexture();
if(!font.loadWidthData("Data/Fonts/Arial/Arial.dat"))
{
return 0;
}
#ifndef PLATFORM_WP8
font.setScale((float)(EAGLE_CONSOLE_CHARACTER_HEIGHT) / font.getCharacterHeight());
#else
font.setScale((float)(EAGLE_CONSOLE_CHARACTER_HEIGHT) / font.getCharacterHeight() * 1.5);
#endif
#ifndef PLATFORM_WP8
if(!textBox.getFont()->loadImage("Data/Fonts/Arial/Arial.png"))
{
return 0;
}
#else
if(!textBox.getFont()->loadImage("Data/Fonts/Arial/Arial.dds"))
{
return 0;
}
#endif
textBox.getFont()->detectCharacterDimensionsFromTexture();
if(!textBox.getFont()->loadWidthData("Data/Fonts/Arial/Arial.dat"))
{
return 0;
}
#ifndef PLATFORM_WP8
textBox.getFont()->setScale((float)(EAGLE_CONSOLE_CHARACTER_HEIGHT) / font.getCharacterHeight() * 1.2);
#else
textBox.getFont()->setScale((float)(EAGLE_CONSOLE_CHARACTER_HEIGHT) / font.getCharacterHeight() * 1.7);
#endif
lineCount = (EAGLE_CONSOLE_HEIGHT * 0.9) / ((font.getCharacterHeight() * font.getScale().x + EAGLE_FONT_LINE_SPACING)) - 1;
if(lineCount > CONSOLE_MAX_LINE_COUNT)
{
lineCount = CONSOLE_MAX_LINE_COUNT;
}
for(int i = 0; i < lineCount; ++i)
{
outputStringList.push_back("");
outputTypeList.push_back(ConsoleOutput_Default);
}
textBox.setMaxLength(128);
textBox.setOffset(0, 0);
font.setColor(COLOR_RGBA(1, 1, 1, 1));
textBox.getFont()->setColor(COLOR_RGBA(1, 1, 1, 1));
selectedEntryIndex = 0;
initialized = 1;
return 1;
}
//! Render piclist texture
void Storm3D_Scene_PicList_Picture::Render()
{
IStorm3D_Material::ATYPE alphaType = IStorm3D_Material::ATYPE_NONE;
if(material)
{
alphaType = material->GetAlphaType();
if(alpha < 0.99f && alphaType == IStorm3D_Material::ATYPE_NONE)
material->SetAlphaType(IStorm3D_Material::ATYPE_USE_TEXTRANSPARENCY);
// Apply the texture
material->ApplyBaseTextureExtOnly();
if(wrap)
{
glActiveTexture(GL_TEXTURE0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
} else {
glActiveTexture(GL_TEXTURE0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
}
// Animate
{
IStorm3D_Texture *ti = material->GetBaseTexture();
// FIXED: crashed to null pointer here. -jpk
if (ti != NULL)
{
Storm3D_Texture *t = static_cast<Storm3D_Texture *> (ti);
t->AnimateVideo();
}
}
}
// FIXME: ugly hack to work around disappearing grenade throw meter
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
// Create 3d-vector
VC3 pos(position.x,position.y,0);
// Create color (color+alpha)
DWORD col = 0xFFFFFFFF;
if(material)
{
COL c(1.f, 1.f, 1.f);
float newAlpha = 1.f;
c = material->GetColor();
newAlpha = alpha * (1-material->GetTransparency());
col=COLOR_RGBA((int)(c.r*255.0f),(int)(c.g*255.0f),(int)(c.b*255.0f),(int)(newAlpha*255.0f));
//col = COLOR_RGBA(c.r, c.g, c.b, newAlpha);
}
// Render it
frozenbyte::storm::VertexShader::disable();
// render with custom shape
if(customShape && customShape->vertices)
{
// use combined alpha
float alpha_mul = 1.0f;
if(material)
{
alpha_mul = alpha * (1.0f - material->GetTransparency());
}
for(int i = 0; i < customShape->numVertices; i++)
{
DWORD c = customShape->vertices[i].color;
int newAlpha = (int)((c >> 24) * alpha_mul);
c &= 0x00FFFFFF;
c |= (newAlpha & 0xFF) << 24;
customShape->vertices[i].color = c;
customShape->vertices[i].position.x -= .5f;
customShape->vertices[i].position.y -= .5f;
}
glEnableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);
glEnableClientState(GL_VERTEX_ARRAY);
glClientActiveTexture(GL_TEXTURE0);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glVertexPointer(3, GL_FLOAT, sizeof(VXFORMAT_2D), &customShape->vertices[0].position);
glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(VXFORMAT_2D), &customShape->vertices[0].color);
glTexCoordPointer(2, GL_FLOAT, sizeof(VXFORMAT_2D), &customShape->vertices[0].texcoords);
glDrawArrays(GL_TRIANGLES, 0, customShape->numVertices);
scene->AddPolyCounter(customShape->numVertices/3);
}
void video_present(void) {
uint i, j;
#ifndef NO_DEVMODE
v_stats.frame = frame+1;
v_stats.active_textures = textures.size;
v_stats.frame_layer_sorts = v_stats.frame_batches = v_stats.frame_rects = 0;
v_stats.frame_lines = v_stats.frame_texture_switches = 0;
for(i = 0; i < bucket_count; ++i) {
v_stats.layer_rects[i] = rect_buckets[i].size;
v_stats.layer_lines[i] = line_buckets[i].size;
}
#endif
// Sort rects to reduce batch count
for(i = 0; i < bucket_count; ++i) {
if(rect_buckets[i].size > 2) {
_sort_rects(rect_buckets[i]);
#ifndef NO_DEVMODE
v_stats.frame_layer_sorts++;
#endif
}
}
Vertex* vb = DARRAY_DATA_PTR(vertex_buffer, Vertex);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
if(!rect_draw_state) {
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
glVertexPointer(2, GL_FLOAT, sizeof(Vertex), &vb[0].x);
glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(Vertex), &vb[0].color);
glTexCoordPointer(2, GL_SHORT, sizeof(Vertex), &vb[0].u);
rect_draw_state = true;
}
// Render loop
Texture* texs = DARRAY_DATA_PTR(textures, Texture);
uint active_tex = ~0;
byte r, g, b, a;
Color c;
for(i = 0; i < bucket_count; ++i) {
// Switch blend modes if neccessary
if(rect_buckets[i].size > 0 && blend_modes[i] != last_blend_mode) {
if(vertex_buffer.size > 0) {
assert(vertex_buffer.size % 4 == 0);
uint tri_count = vertex_buffer.size / 2;
glDrawElements(GL_TRIANGLES, tri_count*3, GL_UNSIGNED_SHORT, index_buffer);
vertex_buffer.size = 0;
#ifndef NO_DEVMODE
v_stats.frame_batches++;
#endif
}
_set_blendmode(blend_modes[i]);
last_blend_mode = blend_modes[i];
}
// Draw rects
TexturedRectDesc* rects = DARRAY_DATA_PTR(rect_buckets[i], TexturedRectDesc);
for(j = 0; j < rect_buckets[i].size; ++j) {
if(rects[j].tex != active_tex) {
if(vertex_buffer.size > 0) {
assert(vertex_buffer.size % 4 == 0);
uint tri_count = vertex_buffer.size / 2;
glDrawElements(GL_TRIANGLES, tri_count*3, GL_UNSIGNED_SHORT,
index_buffer);
vertex_buffer.size = 0;
#ifndef NO_DEVMODE
v_stats.frame_batches++;
#endif
}
active_tex = rects[j].tex;
glBindTexture(GL_TEXTURE_2D, texs[active_tex].gl_id);
#ifndef NO_DEVMODE
v_stats.frame_texture_switches++;
#endif
}
COLOR_DECONSTRUCT(rects[j].tint, r, g, b, a);
r = (r * a) >> 8;
g = (g * a) >> 8;
b = (b * a) >> 8;
c = COLOR_RGBA(r, g, b, a);
size_t k = vertex_buffer.size;
vertex_buffer.size += 4;
assert(vertex_buffer.size <= vertex_buffer.reserved);
Vector2 points[4] = {
{rects[j].dest.left, rects[j].dest.top},
{rects[j].dest.right, rects[j].dest.top},
{rects[j].dest.right, rects[j].dest.bottom},
{rects[j].dest.left, rects[j].dest.bottom}
};
if(rects[j].rotation != 0.0f) {
float rot = rects[j].rotation;
Vector2 cnt = vec2((rects[j].dest.left + rects[j].dest.right) * 0.5f,
(rects[j].dest.top + rects[j].dest.bottom) * 0.5f);
float dx, dy;
float s = sinf(rot);
float c = cosf(rot);
for(uint l = 0; l < 4; ++l) {
dx = points[l].x - cnt.x;
dy = points[l].y - cnt.y;
points[l].x = c * dx - s * dy + cnt.x;
points[l].y = s * dx + c * dy + cnt.y;
}
}
if(transform[i] != NULL)
gfx_matmul(points, 4, transform[i]);
Vector2 src[4] = {
{rects[j].src_l, rects[j].src_t},
{rects[j].src_r, rects[j].src_t},
{rects[j].src_r, rects[j].src_b},
{rects[j].src_l, rects[j].src_b}
};
for(uint l = 0; l < 4; ++l) {
vb[k+l].x = points[l].x;
vb[k+l].y = points[l].y;
vb[k+l].color = c;
vb[k+l].u = src[l].x;
vb[k+l].v = src[l].y;
}
}
if(vertex_buffer.size > 0) {
assert(vertex_buffer.size % 4 == 0);
uint tri_count = vertex_buffer.size / 2;
glDrawElements(GL_TRIANGLES, tri_count*3, GL_UNSIGNED_SHORT,
index_buffer);
vertex_buffer.size = 0;
#ifndef NO_DEVMODE
v_stats.frame_batches++;
#endif
}
// TODO: gfx debug mode
// Draw lines
if(line_buckets[i].size) {
glDisable(GL_TEXTURE_2D);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glVertexPointer(2, GL_FLOAT, sizeof(Vertex), &vb[0].x);
glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(Vertex), &vb[0].color);
LineDesc* lines = DARRAY_DATA_PTR(line_buckets[i], LineDesc);
vertex_buffer.size += line_buckets[i].size * 2;
size_t k = 0;
for(j = 0; j < line_buckets[i].size; ++j) {
COLOR_DECONSTRUCT(lines[j].color, r, g, b, a);
r = (r * a) << 8;
g = (g * a) << 8;
b = (b * a) << 8;
c = COLOR_RGBA(r, g, b, a);
Vector2 points[2] = {
{lines[j].start.x, lines[j].start.y},
{lines[j].end.x, lines[j].end.y}
};
if(transform[i] != NULL)
gfx_matmul(points, 2, transform[i]);
vb[k].x = points[0].x;
vb[k].y = points[0].y;
vb[k].color = c;
k++;
vb[k].x = points[1].x;
vb[k].y = points[1].y;
vb[k].color = c;
k++;
}
glDrawArrays(GL_LINES, 0, k);
vertex_buffer.size = 0;
glEnable(GL_TEXTURE_2D);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glVertexPointer(2, GL_FLOAT, sizeof(Vertex), &vb[0].x);
glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(Vertex), &vb[0].color);
glTexCoordPointer(2, GL_SHORT, sizeof(Vertex), &vb[0].u);
}
#ifndef NO_DEVMODE
v_stats.frame_rects += rect_buckets[i].size;
v_stats.frame_lines += line_buckets[i].size;
#endif
}
_sys_present();
/*
if(has_discard_extension) {
const GLenum discards[] = {GL_COLOR_ATTACHMENT0_OES, GL_DEPTH_ATTACHMENT_OES};
glDiscardFramebufferEXT(GL_FRAMEBUFFER_OES, 2, discards);
}
*/
frame++;
for(i = 0; i < bucket_count; ++i) {
rect_buckets[i].size = 0;
line_buckets[i].size = 0;
}
}
void ConvertRGBA32(CTexture *pTexture, const TxtrInfo &tinfo)
{
DrawInfo dInfo;
if (!pTexture->StartUpdate(&dInfo))
return;
uint32 * pSrc = (uint32*)(tinfo.pPhysicalAddress);
if( options.bUseFullTMEM )
{
Tile &tile = gRDP.tiles[tinfo.tileNo];
uint32 *pWordSrc;
if( tinfo.tileNo >= 0 )
{
pWordSrc = (uint32*)&g_Tmem.g_Tmem64bit[tile.dwTMem];
for (uint32 y = 0; y < tinfo.HeightToLoad; y++)
{
uint32 * dwDst = (uint32 *)((uint8 *)dInfo.lpSurface + y*dInfo.lPitch);
uint32 nFiddle = ( y&1 )? 0x2 : 0;
int idx = tile.dwLine*4*y;
for (uint32 x = 0; x < tinfo.WidthToLoad; x++, idx++)
{
uint32 w = pWordSrc[idx^nFiddle];
uint8* psw = (uint8*)&w;
uint8* pdw = (uint8*)&dwDst[x];
pdw[0] = psw[2]; // Blue
pdw[1] = psw[1]; // Green
pdw[2] = psw[0]; // Red
pdw[3] = psw[3]; // Alpha
}
}
}
}
else
{
if (tinfo.bSwapped)
{
for (uint32 y = 0; y < tinfo.HeightToLoad; y++)
{
if ((y%2) == 0)
{
uint8 *pDst = (uint8 *)dInfo.lpSurface + y * dInfo.lPitch;
uint8 *pS = (uint8 *)pSrc + (y+tinfo.TopToLoad) * tinfo.Pitch + (tinfo.LeftToLoad*4);
for (uint32 x = 0; x < tinfo.WidthToLoad; x++)
{
pDst[0] = pS[1]; // Blue
pDst[1] = pS[2]; // Green
pDst[2] = pS[3]; // Red
pDst[3] = pS[0]; // Alpha
pS+=4;
pDst+=4;
}
}
else
{
uint32 *pDst = (uint32 *)((uint8 *)dInfo.lpSurface + y * dInfo.lPitch);
uint8 *pS = (uint8 *)pSrc;
LONG n;
n = (y+tinfo.TopToLoad) * tinfo.Pitch + (tinfo.LeftToLoad*4);
for (uint32 x = 0; x < tinfo.WidthToLoad; x++)
{
*pDst++ = COLOR_RGBA(pS[(n+3)^0x8],
pS[(n+2)^0x8],
pS[(n+1)^0x8],
pS[(n+0)^0x8]);
n += 4;
}
}
}
}
else
{
for (uint32 y = 0; y < tinfo.HeightToLoad; y++)
{
uint8 *pDst = (uint8 *)dInfo.lpSurface + y * dInfo.lPitch;
uint8 *pS = (uint8 *)pSrc + (y+tinfo.TopToLoad) * tinfo.Pitch + (tinfo.LeftToLoad*4);
for (uint32 x = 0; x < tinfo.WidthToLoad; x++)
{
pDst[0] = pS[1]; // Blue
pDst[1] = pS[2]; // Green
pDst[2] = pS[3]; // Red
pDst[3] = pS[0]; // Alpha
pS+=4;
pDst+=4;
}
}
}
}
pTexture->EndUpdate(&dInfo);
pTexture->SetOthersVariables();
}
void TBaseShape::SetNormalColor(uchar red, uchar green, uchar blue, uchar alpha)
{
VisibleNormalsColorsUINT[0]=COLOR_RGBA(red, green, blue, alpha);
}
void TBaseShape::SetColors(uchar red, uchar green, uchar blue, uchar alpha, uchar red2, uchar green2, uchar blue2, uchar alpha2)
{
ColorsUINT[0]=COLOR_RGBA(red, green, blue, alpha);
ColorsUINT[1]=COLOR_RGBA(red2, blue2, green2, alpha2);
}
COLOR CColorCombiner::GetConstFactor(uint32 colorFlag, uint32 alphaFlag, uint32 defaultColor)
{
// Allows a combine mode to select what TFACTOR should be
uint32 color = defaultColor;
uint32 alpha = defaultColor;
switch (colorFlag & MUX_MASK)
{
case MUX_0:
break;
case MUX_FORCE_0:
color = 0;
break;
case MUX_1:
color = 0xFFFFFFFF;
break;
case MUX_PRIM:
color = gRDP.primitiveColor;
break;
case MUX_ENV:
color = gRDP.envColor;
break;
case MUX_LODFRAC:
color = COLOR_RGBA(gRDP.LODFrac, gRDP.LODFrac, gRDP.LODFrac, gRDP.LODFrac);
break;
case MUX_PRIMLODFRAC:
color = COLOR_RGBA(gRDP.primLODFrac, gRDP.primLODFrac, gRDP.primLODFrac, gRDP.primLODFrac);
break;
case MUX_PRIM_ALPHA:
{
IColor col(gRDP.primitiveColor);
col.AlphaReplicate();
color = (COLOR)col;
}
break;
case MUX_ENV_ALPHA:
{
IColor col(gRDP.envColor);
col.AlphaReplicate();
color = (COLOR)col;
}
break;
case MUX_K5:
color = 0xFFFFFFFF;
break;
case MUX_UNK:
color = defaultColor;
if(options.enableHackForGames == HACK_FOR_CONKER)
{
color = 0xFFFFFFFF;
}
break;
default:
color = defaultColor;
break;
}
if (colorFlag & MUX_COMPLEMENT)
{
color = 0xFFFFFFFF - color;
}
if (colorFlag & MUX_ALPHAREPLICATE)
{
color = color>>24;
color = color | (color<<8) | (color <<16) | (color<<24);
}
void ProcessVertexDataNoSSE(uint32_t dwAddr, uint32_t dwV0, uint32_t dwNum)
{
UpdateCombinedMatrix();
// This function is called upon SPvertex
// - do vertex matrix transform
// - do vertex lighting
// - do texture coordinate transform if needed
// - calculate normal vector
// Output: - g_vecProjected[i] -> transformed vertex x,y,z
// - g_vecProjected[i].w -> saved vertex 1/w
// - g_dwVtxFlags[i] -> flags
// - g_dwVtxDifColor[i] -> vertex color
// - g_fVtxTxtCoords[i] -> vertex texture coordinates
uint8_t *rdram_u8 = (uint8_t*)gfx_info.RDRAM;
FiddledVtx * pVtxBase = (FiddledVtx*)(rdram_u8 + dwAddr);
g_pVtxBase = pVtxBase;
for (uint32_t i = dwV0; i < dwV0 + dwNum; i++)
{
SP_Timing(RSP_GBI0_Vtx);
FiddledVtx & vert = pVtxBase[i - dwV0];
g_vtxNonTransformed[i].x = (float)vert.x;
g_vtxNonTransformed[i].y = (float)vert.y;
g_vtxNonTransformed[i].z = (float)vert.z;
Vec3Transform(&g_vtxTransformed[i], (XVECTOR3*)&g_vtxNonTransformed[i], &gRSPworldProject); // Convert to w=1
g_vecProjected[i].w = 1.0f / g_vtxTransformed[i].w;
g_vecProjected[i].x = g_vtxTransformed[i].x * g_vecProjected[i].w;
g_vecProjected[i].y = g_vtxTransformed[i].y * g_vecProjected[i].w;
if ((g_curRomInfo.bPrimaryDepthHack || options.enableHackForGames == HACK_FOR_NASCAR ) && gRDP.otherMode.depth_source )
{
g_vecProjected[i].z = gRDP.fPrimitiveDepth;
g_vtxTransformed[i].z = gRDP.fPrimitiveDepth*g_vtxTransformed[i].w;
}
else
{
g_vecProjected[i].z = g_vtxTransformed[i].z * g_vecProjected[i].w;
}
if( gRSP.bFogEnabled )
{
g_fFogCoord[i] = g_vecProjected[i].z;
if( g_vecProjected[i].w < 0 || g_vecProjected[i].z < 0 || g_fFogCoord[i] < gRSPfFogMin )
g_fFogCoord[i] = gRSPfFogMin;
}
RSP_Vtx_Clipping(i);
if( gRSP.bLightingEnable )
{
g_normal.x = (float)vert.norma.nx;
g_normal.y = (float)vert.norma.ny;
g_normal.z = (float)vert.norma.nz;
Vec3TransformNormal(g_normal, gRSPmodelViewTop);
g_dwVtxDifColor[i] = LightVert(g_normal, i);
*(((uint8_t*)&(g_dwVtxDifColor[i]))+3) = vert.rgba.a; // still use alpha from the vertex
}
else
{
if( (gRDP.geometryMode & G_SHADE) == 0 && gRSP.ucode < 5 ) //Shade is disabled
{
//FLAT shade
g_dwVtxDifColor[i] = gRDP.primitiveColor;
}
else
{
register IColor &color = *(IColor*)&g_dwVtxDifColor[i];
color.b = vert.rgba.r;
color.g = vert.rgba.g;
color.r = vert.rgba.b;
color.a = vert.rgba.a;
}
}
if( options.bWinFrameMode )
{
g_dwVtxDifColor[i] = COLOR_RGBA(vert.rgba.r, vert.rgba.g, vert.rgba.b, vert.rgba.a);
}
ReplaceAlphaWithFogFactor(i);
// Update texture coords n.b. need to divide tu/tv by bogus scale on addition to buffer
// If the vertex is already lit, then there is no normal (and hence we
// can't generate tex coord)
if (gRSP.bTextureGen && gRSP.bLightingEnable )
{
TexGen(g_fVtxTxtCoords[i].x, g_fVtxTxtCoords[i].y);
}
else
{
g_fVtxTxtCoords[i].x = (float)vert.tu;
g_fVtxTxtCoords[i].y = (float)vert.tv;
}
}
}
void dgreed_preinit(void) {
video_clear_color(COLOR_RGBA(188, 188, 188, 255));
}
static void wiiu_font_render_msg(
video_frame_info_t *video_info,
void* data, const char* msg,
const struct font_params *params)
{
float x, y, scale, drop_mod, drop_alpha;
int drop_x, drop_y;
unsigned max_glyphs;
enum text_alignment text_align;
unsigned color, color_dark, r, g, b,
alpha, r_dark, g_dark, b_dark, alpha_dark;
wiiu_font_t *font = (wiiu_font_t*)data;
unsigned width = video_info->width;
unsigned height = video_info->height;
if (!font || !msg || !*msg)
return;
if (params)
{
x = params->x;
y = params->y;
scale = params->scale;
text_align = params->text_align;
drop_x = params->drop_x;
drop_y = params->drop_y;
drop_mod = params->drop_mod;
drop_alpha = params->drop_alpha;
r = FONT_COLOR_GET_RED(params->color);
g = FONT_COLOR_GET_GREEN(params->color);
b = FONT_COLOR_GET_BLUE(params->color);
alpha = FONT_COLOR_GET_ALPHA(params->color);
color = params->color;
}
else
{
x = video_info->font_msg_pos_x;
y = video_info->font_msg_pos_y;
scale = 1.0f;
text_align = TEXT_ALIGN_LEFT;
r = (video_info->font_msg_color_r * 255);
g = (video_info->font_msg_color_g * 255);
b = (video_info->font_msg_color_b * 255);
alpha = 255;
color = COLOR_RGBA(r, g, b, alpha);
drop_x = -2;
drop_y = -2;
drop_mod = 0.3f;
drop_alpha = 1.0f;
}
max_glyphs = strlen(msg);
if (drop_x || drop_y)
max_glyphs *= 2;
if (drop_x || drop_y)
{
r_dark = r * drop_mod;
g_dark = g * drop_mod;
b_dark = b * drop_mod;
alpha_dark = alpha * drop_alpha;
color_dark = COLOR_RGBA(r_dark, g_dark, b_dark, alpha_dark);
wiiu_font_render_message(video_info, font, msg, scale, color_dark,
x + scale * drop_x / width, y +
scale * drop_y / height, text_align);
}
wiiu_font_render_message(video_info, font, msg, scale,
color, x, y, text_align);
}
