void GameOverState::load_gfx(CL_GraphicContext& gc, std::string skin)
{
unload_gfx();
// Getting skins resources
CL_VirtualFileSystem vfs(skin, true);
CL_VirtualDirectory vd(vfs, "./");
CL_ResourceManager gfx("menu_gameover.xml",vd);
_dialog_gameover = CL_Sprite(gc, "menu_gameover/dialog_gameover", &gfx);
_dialog_highscore = CL_Sprite(gc, "menu_gameover/dialog_highscore", &gfx);
_score1_x = CL_Integer_to_int("menu_gameover/score1_left", &gfx);
_score1_y = CL_Integer_to_int("menu_gameover/score1_top", &gfx);
_score2_x = CL_Integer_to_int("menu_gameover/score2_left", &gfx);
_score2_y = CL_Integer_to_int("menu_gameover/score2_top", &gfx);
_quit_choice_item.set_gfx(gc, gfx,
"menu_gameover/new_game_question/yes/unselected",
"menu_gameover/new_game_question/yes/selected",
"menu_gameover/new_game_question/no/unselected",
"menu_gameover/new_game_question/no/selected");
_quit_choice_item.set_x(
CL_Integer_to_int("menu_gameover/new_game_question/yes/left", &gfx));
_quit_choice_item.set_x2(
CL_Integer_to_int("menu_gameover/new_game_question/no/left", &gfx));
_quit_choice_item.set_y(
CL_Integer_to_int("menu_gameover/new_game_question/yes/top", &gfx));
_quit_choice_item.set_y2(
CL_Integer_to_int("menu_gameover/new_game_question/no/top", &gfx));
}
CreditsButton::CreditsButton(void){
spriteCursorOn = CL_Sprite(graphicContext, "credits_button_on", resources);
spriteCursorOff = CL_Sprite(graphicContext, "credits_button_off", resources);
sprite = spriteCursorOff;
height = 50.0f;
width = 360.0f;
}
void DualChoiceItem::set_gfx(CL_GraphicContext& gc, CL_ResourceManager& gfx,
std::string normal_left, std::string selected_left,
std::string normal_right, std::string selected_right)
{
unload_gfx();
_normal_sprite_left = CL_Sprite(gc, normal_left, &gfx);
_selected_sprite_left = CL_Sprite(gc, selected_left, &gfx);
_normal_sprite_right = CL_Sprite(gc, normal_right, &gfx);
_selected_sprite_right = CL_Sprite(gc, selected_right, &gfx);
}
CSprite::CSprite(const char* materialPath)
{
std::string newMaterialPath = Util::FixFilePath(materialPath, "materials/", ".png");
if (g_Files->IsLocal(newMaterialPath.c_str()))
m_sprite = CL_Sprite(g_Display->Graphics().Object(), newMaterialPath);
else
m_sprite = CL_Sprite(g_Display->Graphics().Object(), newMaterialPath, g_Game->GetVD());
m_addingFrames = false;
}
TileMap::TileMap(CL_GraphicContext& gc, CL_ResourceManager& resmgr, const CL_String& tileset)
: map_width(0), map_height(0), cur_map_x(0), cur_map_y(0) {
CL_Resource res = resmgr.get_resource(tileset);
if (res.get_type() != "tilemap")
throw CL_Exception(cl_format("Resource %1 is not a tilemap", tileset));
CL_DomElement element = res.get_element();
levelname = element.get_attribute("name");
CL_String resource_name = element.get_attribute("resource");
map_width = element.get_attribute_int("width");
map_height = element.get_attribute_int("height");
tiles = CL_Sprite(gc, resource_name, &resmgr);
float scalex, scaley;
tiles.get_scale(scalex, scaley);
tile_width = tiles.get_width() * scalex;
tile_height = tiles.get_height() * scaley;
auto layer_nodes = element.select_nodes("layer");
for (CL_DomNode& idx : layer_nodes) {
CL_DomElement layer_element = idx.to_element();
CL_String layer_tiles = layer_element.get_first_child().get_node_value();
std::vector<CL_String> tile_indices = CL_StringHelp::split_text(layer_tiles, ",");
MapLayer layer;
layer.map.reserve(tile_indices.size());
for (auto& tile : tile_indices)
layer.map.push_back(CL_StringHelp::text_to_int(tile));
layers.push_back(layer);
}
}
void RadialMenu::create_parts()
{
CL_GraphicContext gc = get_gc();
CL_ResourceManager resources = get_resources();
part_component = CL_GUIThemePart(this);
CL_GUIThemePart part_selected_item(this, "selected");
CL_GUIThemePartProperty prop_text_color("text-color");
CL_GUIThemePartProperty prop_pointer_image("pointer-image");
CL_GUIThemePartProperty prop_text_distance("text-distance");
normal_text_color = part_component.get_property(prop_text_color);
normal_font = part_component.get_font();
normal_text_distance = CL_StringHelp::text_to_float(part_component.get_property(prop_text_distance));
normal_font_height = normal_font.get_font_metrics().get_height();
selected_text_color = part_selected_item.get_property(prop_text_color);
selected_font = part_selected_item.get_font();
selected_text_distance = CL_StringHelp::text_to_float(part_selected_item.get_property(prop_text_distance));
selected_font_height = selected_font.get_font_metrics().get_height();
CL_String pointer_image_name = part_component.get_property(prop_pointer_image);
image_pointer = CL_Sprite(gc, pointer_image_name, &resources);
image_pointer.set_alignment(origin_center);
}
CL_Sprite::CL_Sprite(CL_GraphicContext &gc, const CL_StringRef &fullname, const CL_ImageImportDescription &import_desc)
{
CL_String path = CL_PathHelp::get_fullpath(fullname, CL_PathHelp::path_type_file);
CL_String filename = CL_PathHelp::get_filename(fullname, CL_PathHelp::path_type_file);
CL_VirtualFileSystem vfs(path);
CL_VirtualDirectory dir = vfs.get_root_directory();
*this = CL_Sprite(gc, filename, dir, import_desc);
}
void CSprite::FinishFrames()
{
if (m_addingFrames)
{
m_sprite = CL_Sprite(g_Display->Graphics().Object(), m_spriteDesc);
m_addingFrames = false;
}
}
void SpriteResource::load()
{
if (mSprite.is_null())
{
CL_ResourceManager manager = mResource.get_manager();
mSprite = CL_Sprite(Graphics::getSingleton().getWindow().get_gc(), mResource.get_name(), &manager);
}
}
CL_Sprite CL_ListViewIcon::get_sprite(CL_ListViewDisplayMode mode)
{
std::map<CL_ListViewDisplayMode, CL_Sprite>::iterator it;
it = impl->sprites.find(mode);
if (it != impl->sprites.end())
return impl->sprites[mode];
return CL_Sprite();
}
CQuaterPipeElement::CQuaterPipeElement() : CAbstractElement(QuaterPipe), simulation_(false)
{
collisionBody_ = CL_CollisionOutline("Resources/Image/qpipe_outline.png");
collisionBody_.set_alignment(origin_center);
sprite_ = CL_Sprite(IMApplication::getInstance().gameWorld()->gc(), "quaterpipe_sprite",
IMApplication::getInstance().resources());
physics_ = QuaterPipePhysics(new CQuaterPipePhysics(collisionBody_.get_height(), 49, 0.0f));
}
CRampElement::CRampElement() : CAbstractElement(Ramp), simulation_(false)
{
collisionBody_ = CL_CollisionOutline("Resources/Image/ramp.png");
collisionBody_.set_alignment(origin_center);
sprite_ = CL_Sprite(IMApplication::getInstance().gameWorld()->gc(), "ramp_sprite",
IMApplication::getInstance().resources());
physics_ = RampPhysics(new CRampPhysics(sprite_.get_width(), sprite_.get_height(), 0.0f));
}
void WorkerGC::worker_thread_loop()
{
CL_DisplayWindowDescription desc;
desc.set_title("ClanLib Worker Thread");
desc.set_size(CL_Size(320, 320), true);
//desc.set_visible(false);
window = CL_DisplayWindow(desc);
while (true)
{
int wakeup_reason = CL_Event::wait(event_start, event_stop);
if (wakeup_reason != 0)
break;
event_start.reset();
try
{
CL_GraphicContext gc = window.get_gc();
// Test code
unsigned int time_ms = CL_System::get_time();
while((CL_System::get_time() - time_ms) < 2000)
{
gc.clear(CL_Colorf(1.0f,0.0f,0.2f));
CL_KeepAlive::process();
window.flip(0);
}
window.set_visible(false, false);
retrieved_sprite = CL_Sprite(gc, sprite_name);
CL_OpenGL::set_active(gc);
glFlush();
}
catch (CL_Exception &error)
{
exception_set = true;
exception = error;
}
event_completed.set();
}
window = CL_DisplayWindow();
}
CL_Sprite
NetPanzerData::get_tilegroup_sprite(int index)
{
for(TileGroups::iterator i = tilegroups.begin(); i != tilegroups.end(); ++i)
{
if (index == i->start)
{
CL_Sprite sprite;
sprite.add_frame(i->get_surface(), CL_Rect(CL_Point(0, 0),
CL_Size(i->get_surface().get_width(),
i->get_surface().get_height())));
return sprite;
}
}
std::cout << "NetPanzerData: Couldn't get tilegroup_sprite for '" << index << "'" << std::endl;
return CL_Sprite();
}
void TileMap::load(CL_GraphicContext &gc, const CL_String &level, CL_ResourceManager &resources)
{
CL_Resource resource = resources.get_resource(level);
if (resource.get_type() != "tilemap")
throw CL_Exception(cl_format("Resource %1 is not of type tilemap!", level));
CL_DomElement element = resource.get_element();
CL_String level_name = element.get_attribute("name");
CL_String resource_name = element.get_attribute("resource");
map_width = element.get_attribute_int("width");
map_height = element.get_attribute_int("height");
cl_log_event("Debug", "Loading level %1 (%2x%3)", level_name, map_width, map_height);
sprite_tiles = CL_Sprite(gc, resource_name, &resources);
tile_width = sprite_tiles.get_width();
tile_height = sprite_tiles.get_height();
cl_log_event("Debug", "Loaded resource %1 with %2 tiles", resource_name, sprite_tiles.get_frame_count());
std::vector<CL_DomNode> layer_nodes = element.select_nodes("layer");
for (size_t layer_index = 0; layer_index < layer_nodes.size(); layer_index++)
{
CL_DomElement layer_element = layer_nodes[layer_index].to_element();
CL_String layer_name = layer_element.get_attribute("name");
CL_String layer_tiles = layer_element.get_first_child().get_node_value();
std::vector<CL_String> tile_indices = CL_StringHelp::split_text(layer_tiles, ",");
TileMapLayer layer;
layer.map.reserve(tile_indices.size());
for(size_t i = 0; i < tile_indices.size(); ++i)
layer.map.push_back(CL_StringHelp::text_to_int(tile_indices[i]));
layers.push_back(layer);
cl_log_event("Debug", "Loaded layer %1 with %2 tiles", layer_name, layer.map.size());
}
current_map_position_x = 0;
current_map_position_y = 0;
}
CL_Sprite WorkerGC::Get()
{
if (!worker_thread_processing)
throw CL_Exception("You forgot to start!");
worker_thread_processing = false;
event_completed.wait();
event_completed.reset();
if (exception_set)
{
throw exception;
}
CL_Sprite sprite = retrieved_sprite;
retrieved_sprite = CL_Sprite();
return sprite;
}
GameViewBattle::GameViewBattle(GameView *view, Client *client)
: CL_GUIComponent(view), view(view), client(client)
{
set_type_name("battle");
set_geometry(CL_Rect(view->get_width() - 400, 0, view->get_width(), 300));
set_visible(false);
func_render().set(this, &GameViewBattle::on_render);
func_process_message().set(this, &GameViewBattle::on_message);
timer_hide.func_expired().set(this, &GameViewBattle::on_timer_hide_expired);
CL_Texture texture_dice(get_gc(), "Resources/dices.png", CL_VirtualDirectory());
CL_SpriteDescription dice_description;
dice_description.add_gridclipped_frames(texture_dice, 0, 0, 42, 45, 6, 1);
sprite_dices = CL_Sprite(get_gc(), dice_description);
font_large = CL_Font(get_gc(), "Accidental Presidency", -40);
font_small = CL_Font(get_gc(), "Accidental Presidency", -30);
}
GameObject_Ghost::GameObject_Ghost(int x, int y, World *world) :
GameObject_Moving(x, y, world)
{
spr_ghost = CL_Sprite("Game/spr_ghost", world->resources);
move_dir = rand()%4;
red_ghost = false;
int anim_length = spr_ghost.get_frame_count() / 2;
anim_pos = rand()%anim_length;
anim_dir = rand()%2;
if (anim_dir == 0) anim_dir = -1;
if (anim_pos == 0) anim_dir = 1;
if (anim_pos == anim_length-1) anim_dir = -1;
set_speed(3.0);
}
GameObject_Pacman::GameObject_Pacman(int x, int y, World *world) :
GameObject_Moving(x, y, world)
{
spr_pacman = CL_Sprite(world->gc, "Game/spr_pacman", world->resources);
//sfx_start = CL_SoundBuffer("Game/sfx_start", world->resources);
//sfx_namnam = CL_SoundBuffer("Game/sfx_namnam", world->resources);
//sfx_powerup = CL_SoundBuffer("Game/sfx_powerup", world->resources);
//sfx_dead = CL_SoundBuffer("Game/sfx_dead", world->resources);
move_dir = 1;
wanted_dir = -1;
anim_pos = 0;
anim_dir = 1;
i_am_dead = false;
got_powerup = false;
set_speed(4.0);
//sfx_start.play();
}
CL_Sprite&
Tile::get_sprite()
{
if (impl->sprite)
{
return impl->sprite;
}
else
{
if (impl->provider)
{
impl->sprite = impl->provider.get_sprite();
}
else
{
CL_SpriteDescription desc;
desc.add_frame(CL_PixelBuffer(get_pixelbuffer()));
impl->sprite = CL_Sprite(desc);
}
return impl->sprite;
}
}
/*bool AGG::File::loadFile(const QString & fn)
{
if(isOpen()) close();
if(fn.isEmpty()) return false;
setFileName(fn);
if(open(QIODevice::ReadOnly))
{
qDebug() << "AGG::File::loadFile:" << qPrintable(fn);
quint16 countItems = readLE16();
qDebug() << "AGG::File::loadFile:" << "count items:" << countItems;
const int sizeName = 15;
for(int it = 0; it < countItems; ++it)
{
int posname = size() - sizeName * (countItems - it);
Item & item = items[QString(readBlock(sizeName, posname))];
seek(sizeof(countItems) + it * (3 * sizeof(quint32) // crcItem + offsetItem + sizeItem
));
item.crc = readLE32();
item.offset = readLE32();
item.size = readLE32();
}
return true;
}
else
qCritical() << "AGG::File::loadFile:" << "Can not read file " << qPrintable(fn);
return false;
}
*/
bool game_t::_load_h2_tiles(const std::string& filename)
{
const int num_tiles = 432;
_h2_tiles.reserve(432);
for(int i = 0; i < num_tiles; i++)
{
std::stringstream strm;
strm << "hr-" << std::setfill('0') << std::setw(3) << i << ".png";
string fname = filename + "/" + strm.str();
///!!
//it is best to load the map file first, combine all individual tiles together
//into one large bitmap, then run the hqx/xbrz algorithms, as they will cause
//banding artifacts to appear when only done a single tile at a time
///!!
/*const int scale = 2;
CL_PixelBuffer tile(fname);
CL_PixelBuffer pbuf(tile.get_height() * scale, tile.get_width() * scale, cl_rgba8);
if(pbuf.is_null())
throw;
//for(int i = 0; i < 256; i++)
// *((unsigned int*)pbuf.get_data()) = 0x77994433;
///xbrz::nearestNeighborScale(tile.get_data_uint32(), tile.get_width(), tile.get_height(), (unsigned int*)pbuf.get_data(), pbuf.get_width(), pbuf.get_height());
xbrz::scale(2, tile.get_data_uint32(), (unsigned int*)pbuf.get_data(), tile.get_width(), tile.get_height(), xbrz::ColorFormat::ARGB);
//CL_Image img(_gc, pbuf, CL_Rect(0, 0, pbuf.get_width(), pbuf.get_height()));
CL_SpriteDescription sd;
sd.add_frame(pbuf);
_h2_tiles.push_back(CL_Sprite(_gc, sd));*/
_h2_tiles.push_back(CL_Sprite(_gc, fname));
}
return true;
}
// The start of the Application
int App::main(int argc, char **argv)
{
quit = false;
running_test = 0;
// Initialize ClanLib base components
CL_SetupCore setup_core;
// Initialize the ClanLib display component
CL_SetupDisplay setup_display;
// Initilize the OpenGL drivers
CL_SetupGL setup_gl;
// Create a console window for text-output if not available
CL_ConsoleWindow console("Console", 80, 200);
console.redirect_stdio();
std::cout << "Press 1-5 for different tests! (Test 3 and 5 not applicable for ClanLib 0.8)" << std::endl;
try
{
// This opens a window, including the frame size
// If you want more control over the window, pass CL_DisplayWindowDescription to CL_DisplayWindow
// (This is useful to create a borderless window of a specific size)
// If you require target specific control over the window, use the derived CL_OpenGLWindowDescription
// (This contains the multisampling options)
CL_DisplayWindow window("ClanLib SpriteSpeed Test", 1000, 1000);
// Connect the Window close event
CL_Slot slot_quit = window.sig_window_close().connect(this, &App::on_window_close);
// Connect a keyboard handler to on_key_up()
CL_Slot slot_input_up = (window.get_ic()->get_keyboard()).sig_key_down().connect(this, &App::on_input_up);
CL_GraphicContext *gc = window.get_gc();
CL_ResourceManager resources("resources.xml");
explosion1 = CL_Sprite("Explosion1", &resources);
explosion2 = CL_Sprite("Explosion2", &resources);
explosions_same_tex.reserve(10000);
for(int i=0; i<10000; i++)
{
explosions_same_tex.push_back(CL_Sprite(explosion1));
if(i % 2 == 0)
explosions_diff_tex.push_back(CL_Sprite(explosion1));
else
explosions_diff_tex.push_back(CL_Sprite(explosion2));
}
// Run until someone presses escape
while (!quit)
{
float delta_time = dump_fps() / 1000.0f;
CL_Display::clear(CL_Color(0, 0, 51));
if(running_test == 0)
CL_System::sleep(100);
if(running_test == 1)
draw_equal_tex_equal_sprites(gc, 10000, delta_time);
if(running_test == 2)
draw_equal_tex_diff_sprites(gc, 10000, delta_time);
if(running_test == 3)
draw_equal_tex_diff_sprites_batch(gc, 10000, delta_time);
if(running_test == 4)
draw_diff_tex_diff_sprites(gc, 10000, delta_time);
if(running_test == 5)
draw_diff_tex_diff_sprites_batch(gc, 10000, delta_time);
// Flip the display, showing on the screen what we have drawed since last call to flip()
CL_Display::flip();
// This call processes user input and other events
CL_System::keep_alive(1);
}
explosions_same_tex.clear();
explosions_diff_tex.clear();
explosion1 = CL_Sprite();
explosion2 = CL_Sprite();
}
catch(CL_Error error)
{
std::cout << "Exception caught : " << error.message.c_str() << std::endl;
// Display console close message and wait for a key
console.display_close_message();
return -1;
}
return 0;
}
void MainMenuScene::load(CL_GraphicContext &p_gc)
{
m_logoSprite = CL_Sprite(p_gc, "menu/logo", Gfx::Stage::getResourceManager());
GuiScene::load(p_gc);
}
// The start of the Application
int App::start(const std::vector<CL_String> &args)
{
quit = false;
running_test = 0;
// Create a console window for text-output if not available
CL_ConsoleWindow console("Console", 80, 200);
CL_Console::write_line("Press 1-5 for different tests! (Test 3 and 5 not applicable for ClanLib 0.8)");
try
{
// This opens a window, including the frame size
// If you want more control over the window, pass CL_DisplayWindowDescription to CL_DisplayWindow
// (This is useful to create a borderless window of a specific size)
// If you require target specific control over the window, use the derived CL_OpenGLWindowDescription
// (This contains the multisampling options)
CL_DisplayWindow window("ClanLib SpriteSpeed Test", 1000, 1000);
// Connect the Window close event
CL_Slot slot_quit = window.sig_window_close().connect(this, &App::on_window_close);
// Connect a keyboard handler to on_key_up()
CL_Slot slot_input_up = (window.get_ic().get_keyboard()).sig_key_up().connect(this, &App::on_input_up);
// Get the graphic context
CL_GraphicContext gc = window.get_gc();
CL_ResourceManager resources("resources.xml");
explosion1 = CL_Sprite(gc, "Explosion1", &resources);
explosion2 = CL_Sprite(gc, "Explosion2", &resources);
explosions_same_tex.reserve(10000);
for(int i=0; i<10000; i++)
{
explosions_same_tex.push_back(CL_Sprite(explosion1));
if(i % 2 == 0)
explosions_diff_tex.push_back(CL_Sprite(explosion1));
else
explosions_diff_tex.push_back(CL_Sprite(explosion2));
}
// Run until someone presses escape
while (!quit)
{
float delta_time = dump_fps() / 1000.0f;
gc.clear(CL_Colorf(0.0f,0.0f,0.2f));
if(running_test == 0)
CL_System::sleep(100);
if(running_test == 1)
draw_equal_tex_equal_sprites(gc, 10000, delta_time);
if(running_test == 2)
draw_equal_tex_diff_sprites(gc, 10000, delta_time);
if(running_test == 3)
draw_equal_tex_diff_sprites_batch(gc, 10000, delta_time);
if(running_test == 4)
draw_diff_tex_diff_sprites(gc, 10000, delta_time);
if(running_test == 5)
draw_diff_tex_diff_sprites_batch(gc, 10000, delta_time);
// Flip the display, showing on the screen what we have drawed since last call to flip()
window.flip();
// This call processes user input and other events
CL_KeepAlive::process();
}
explosions_same_tex.clear();
explosions_diff_tex.clear();
explosion1 = CL_Sprite();
explosion2 = CL_Sprite();
}
catch(CL_Exception& exception)
{
CL_Console::write_line("Exception caught:");
CL_Console::write_line(exception.message);
// Display the stack trace (if available)
std::vector<CL_String> stacktrace = exception.get_stack_trace();
int size = stacktrace.size();
if (size > 0)
{
CL_Console::write_line("Stack Trace:");
for (int cnt=0; cnt < size; cnt++)
{
CL_Console::write_line(stacktrace[cnt]);
}
}
console.display_close_message();
return -1;
}
return 0;
}
void DecorationSprite::load(CL_GraphicContext &p_gc)
{
m_sprite = CL_Sprite(p_gc, m_spriteName, Stage::getResourceManager());
Drawable::load(p_gc);
}
CSprite::CSprite()
{
m_sprite = CL_Sprite(g_Display->Graphics().Object(), CL_SpriteDescription());
m_addingFrames = false;
}
//Textur und Animation der Figur initialisieren
void Character::setBody(CL_StringRef name, int animationGroups)
{
body = CL_Sprite(world->get_gc(), name, &world->resources);
animationLength = body.get_frame_count() / animationGroups;
}
