CL_String CL_Clipboard_X11::get_clipboard_text() const
{
if ( ( atom_CLIPBOARD == None ) )
{
// X Server does not have clipboard support
return CL_String();
}
XConvertSelection(disp, atom_CLIPBOARD, XA_STRING, atom_CLIPBOARD, window, CurrentTime);
XFlush(disp);
XEvent event;
if (!x11_window->get_xevent( event, SelectionNotify ))
{
return CL_String();
}
Atom actual_type;
int actual_format;
unsigned long number_items;
unsigned char *read_data = x11_window->get_property(window, atom_CLIPBOARD, &number_items, &actual_format, &actual_type);
if ( (actual_format != 8) || (actual_type != XA_STRING) || (number_items <=0) || (read_data==NULL) )
{
if (read_data)
{
XFree(read_data);
}
return CL_String();
}
CL_String buffer( (char *) read_data);
XFree(read_data);
return buffer;
}
CL_String CL_TimeOfDay::PrintString (TimePrintForm form) const
{
CL_String time_string;
long hour = Hour();
long min = Minute();
long sec = Second();
switch (form) {
case Time_Military:
{
CL_String smin (min, 2, '0'), ssec (sec, 2, '0');
time_string = CL_String(hour, 2, '0') + ":" + smin + ":" + ssec;
break;
}
case Time_Normal:
default:
{
CL_String tmin (min, 2);
if (hour > 12) {
hour -= 12;
time_string = CL_String(hour) + ":" + tmin + " pm";
}
else if (hour == 12)
time_string = CL_String(hour) + ":" + tmin + " pm";
else
time_string = CL_String(hour) + ":" + tmin + " am";
break;
}
}
return time_string;
}
void WriteObjects (const char* name)
{
CL_ObjectSequence obj_seq;
CL_BinaryFile file (name, TRUE);
long i;
// First, create a sample sequence of objects
for (i = 0; i < 20; i++) {
obj_seq.Add (new TestClass (i*13 % 7));
}
// Save the sequence
file << obj_seq;
obj_seq.DestroyContents ();
// Now create a set of strings
CL_StringSet some_set;
for (i = 0; i < 12; i++)
some_set.Add ("String in set: " + CL_String (i, 4, '$'));
file << some_set;
// Next, create a few sample map objects
CL_IntPtrMap map1;
for (i = 0; i < 20; i++) {
long n = i*13 % 7;
TestClass* p = new TestClass (n);
if (!map1.Add (n, p))
delete p; // Guard against memory leaks
}
CL_StringStringMap map2;
for (i = 0; i < 30; i++) {
long n = i*13 % 7;
map2.Add (CL_String (i), CL_String (n));
}
// Save the maps
file << map1 << map2;
map1.DestroyContents ();
map2.DestroyContents ();
{
CL_String* p1, *p2, *p3;
p1 = new CL_String ("String1");
p2 = new CL_String ("String2");
CL_ObjectSequence sq(5);
sq[0] = p2;
sq[1] = p1;
sq[2] = p2;
sq[3] = p2;
sq[4] = 0;
file.Remember (); // Need to do this explicitly when saving
// multi-linked structures
file << sq;
delete p1;
delete p2;
file.Forget ();
}
}
CL_String CL_Integer::AsString () const
{
char buffer[15];
short num_digits;
long w;
long v = _value;
short sign = 1;
if (_value == 0)
return CL_String ("0");
if (_value < 0) {
sign = -1;
v = -_value;
}
w = v;
for (num_digits = 0; w > 0; num_digits++) {
w /= 10;
}
if (sign == -1) num_digits++;
buffer[num_digits] = '\0';
for (w = v; w > 0; w /= 10) {
buffer[--num_digits] = (char) ('0' + (w % 10));
}
return CL_String (buffer);
}
CL_String CL_PathHelp::get_fullpath(
const CL_String &filename,
PathType path_type)
{
if (path_type == path_type_file)
{
CL_String::size_type pos = filename.find_last_of("/\\");
if (pos == CL_String::npos)
{
#ifdef WIN32
if (filename.length() >= 2 && filename[1] == ':')
return filename.substr(0, 2);
#endif
return CL_String();
}
return filename.substr(0, pos+1);
}
else
{
CL_String::size_type pos = filename.find_last_of('/');
if (pos == CL_String::npos)
return CL_String();
return filename.substr(0, pos+1);
}
}
void CL_StringFormat::set_arg(int index, long unsigned int value, int min_length)
{
CL_String t = CL_StringHelp::ull_to_text(value);
if ((int) t.length() < min_length)
t = CL_String(min_length-t.length(), '0') + t;
set_arg(index, t);
}
CL_String RadialMenu::get_item(int index) const
{
if(index >= 0 && index < (int)items.size())
return items[index].text;
else
return CL_String();
}
void show_specific_user(CL_SqliteConnection &connection, int user_id)
{
CL_Console::write_line("User info for user %1: ", user_id);
CL_DBCommand command = connection.create_command("SELECT UserId, UserName, Password, RealName, CreateDate, LastLoginDate FROM Users WHERE UserId=?1");
command.set_input_parameter_int(1, user_id);
CL_DBReader reader = connection.execute_reader(command);
while (reader.retrieve_row())
{
int user_id = reader.get_column_int(0);
CL_String user_name = reader.get_column_string(1);
CL_String password = reader.get_column_string(2);
CL_String real_name = reader.get_column_string(3);
CL_DateTime create_date = reader.get_column_datetime(4);
CL_DateTime last_login_date = reader.get_column_datetime(5);
CL_Console::write_line("- User id: %1", user_id);
CL_Console::write_line("- Username: %1", user_name);
CL_Console::write_line("- Password: %1", password);
CL_Console::write_line("- Real name: %1", real_name);
CL_Console::write_line("- Create date: %1", create_date.to_short_datetime_string());
if(!last_login_date.is_null())
CL_Console::write_line("- Last login date: %1", last_login_date.to_short_datetime_string());
else
CL_Console::write_line("- Last login date: NULL");
}
reader.close();
CL_Console::write_line(CL_String());
}
CL_String CL_PgsqlReaderProvider::get_column_name(int index) const
{
const char *const string = PQfname(result, index);
if (string == nullptr)
throw ("Index out of range");
return CL_String(string);
}
void CL_GUIComponent::set_id_name(const CL_StringRef &name)
{
impl->id_name = name;
impl->element_name = CL_String(); // force update of cached element name
if (!impl->func_style_changed.is_null())
impl->func_style_changed.invoke();
}
CL_String CL_CSSLayoutNode_Impl::print_node(CL_CSSBoxNode *node, int indent)
{
CL_String output_string;
output_string += CL_String(indent*2, ' ');
CL_CSSBoxElement *element = dynamic_cast<CL_CSSBoxElement*>(node);
CL_CSSBoxText *text = dynamic_cast<CL_CSSBoxText*>(node);
if (element)
{
//if (element->computed_properties.font_family.names.empty())
output_string += cl_format("%1 { display: %2; float: %3; width: %4 }\r\n", element->name, to_string(element->computed_properties.display), to_string(element->computed_properties.float_box), to_string(element->computed_properties.width));
//else
// output_string += cl_format("%1 { font-family: %2 }\r\n", element->name, element->computed_properties.font_family.names[0].name);
}
else if (text)
{
output_string += cl_format("[%1]\r\n", escape_text(text->text));
}
else
{
output_string += cl_format("unknown\r\n");
}
CL_CSSBoxNode *cur = node->get_first_child();
while (cur)
{
output_string += print_node(cur, indent+1);
cur = cur->get_next_sibling();
}
return output_string;
}
CL_String CL_CSSLayoutText::get_text() const
{
if (!is_null())
return static_cast<const CL_CSSBoxText*>(impl->box_node)->get_text();
else
return CL_String();
}
CL_String CL_PathHelp::get_extension(
const CL_String &fullname,
PathType path_type)
{
CL_String filename = get_filename(fullname, path_type);
CL_String::size_type pos = filename.find_last_of('.');
if (pos == CL_String::npos)
return CL_String();
#ifndef WIN32
// Files beginning with a dot is not a filename extension in Unix.
// This is different from Windows where it is considered the extension.
if (path_type == path_type_file && pos == 0)
return CL_String();
#endif
if (path_type == path_type_virtual && pos == 0)
return CL_String();
return filename.substr(pos + 1);
}
CL_String CL_InputDeviceProvider_Win32Keyboard::get_key_name(int virtual_key) const
{
throw_if_disposed();
TCHAR name[1024];
UINT scancode = MapVirtualKey(virtual_key, 0);
int length = GetKeyNameText(scancode << 16, name, 1024);
return CL_String(name, length);
}
void delete_specific_user(CL_SqliteConnection &connection, int user_id)
{
CL_Console::write_line("Deleting user %1", user_id);
CL_DBTransaction transaction = connection.begin_transaction();
CL_DBCommand command = connection.create_command("DELETE FROM Users Where UserId=?1");
command.set_input_parameter_int(1, user_id);
connection.execute_non_query(command);
transaction.commit();
CL_Console::write_line(CL_String());
}
void update_user_realname(CL_SqliteConnection &connection, int user_id, CL_String real_name)
{
CL_Console::write_line("Updating realname of user %1 with realname %2", user_id, real_name);
CL_DBTransaction transaction = connection.begin_transaction();
CL_DBCommand command = connection.create_command("UPDATE Users SET RealName=?2 WHERE UserId=?1");
command.set_input_parameter_int(1, user_id);
command.set_input_parameter_string(2, real_name);
connection.execute_non_query(command);
transaction.commit();
CL_Console::write_line(CL_String());
}
void show_all_users(CL_SqliteConnection &connection)
{
CL_Console::write_line("All available users:");
CL_DBCommand command = connection.create_command("SELECT UserId, UserName FROM Users");
CL_DBReader reader = connection.execute_reader(command);
while (reader.retrieve_row())
{
int user_id = reader.get_column_int(0);
CL_String user_name = reader.get_column_string(1);
CL_Console::write_line("- Id: %1 Username: %2", user_id, user_name);
}
reader.close();
CL_Console::write_line(CL_String());
}
void show_specific_user_characters(CL_SqliteConnection &connection, int user_id)
{
CL_Console::write_line("Characters for user %1: ", user_id);
CL_DBCommand command = connection.create_command("SELECT Characters.CharacterId, Characters.Name, Users.UserName FROM Characters INNER JOIN Users ON Characters.UserId = Users.UserId WHERE Characters.UserId=?1");
command.set_input_parameter_int(1, user_id);
CL_DBReader reader = connection.execute_reader(command);
while (reader.retrieve_row())
{
int character_id = reader.get_column_int(0);
CL_String character_name = reader.get_column_string(1);
CL_String user_name = reader.get_column_string(2);
CL_Console::write_line("- (Username %3) - Character id: %1 name: %2 ", character_id, character_name, user_name);
}
reader.close();
CL_Console::write_line(CL_String());
}
static int main(const std::vector<CL_String> &args)
{
CL_SetupCore setup_core;
CL_SetupDisplay setup_display;
CL_SetupGL1 setup_opengl1;
CL_SetupSWRender setup_swrender;
bool fullscreen = false;
for (auto it = args.begin(); it != args.end(); ++it) {
if (*it == CL_String("--fullscreen")) {
fullscreen = true;
continue;
}
}
MainWindow w;
w.run(640, 480, fullscreen);
return 0;
}
int create_new_user(CL_SqliteConnection &connection, CL_String user_name, CL_String password, CL_String real_name)
{
CL_Console::write_line("Creating new user: %1", user_name);
CL_DBTransaction transaction = connection.begin_transaction();
CL_DBCommand command = connection.create_command("INSERT INTO Users (UserName, Password, RealName) VALUES (?1,?2,?3)");
command.set_input_parameter_string(1, user_name);
command.set_input_parameter_string(2, password);
command.set_input_parameter_string(3, real_name);
connection.execute_non_query(command);
transaction.commit();
int id = command.get_output_last_insert_rowid();
CL_Console::write_line("New user created with id %1", id);
CL_Console::write_line(CL_String());
return id;
}
CL_PixelBuffer CL_ImageProviderFactory::load(
const CL_String &filename,
const CL_VirtualDirectory &directory,
const CL_String &type
)
{
if (type != "")
{
if (types.find(type) == types.end()) throw CL_Exception("Unknown image provider type " + type);
CL_ImageProviderType *factory = types[type];
return factory->load(filename, directory);
}
// Determine file extension and use it to lookup type.
CL_String ext = CL_PathHelp::get_extension(filename, CL_PathHelp::path_type_virtual);
ext = CL_StringHelp::text_to_lower(ext);
if (types.find(ext) == types.end()) throw CL_Exception(CL_String("Unknown image provider type ") + ext);
CL_ImageProviderType *factory = types[ext];
return factory->load(filename, directory);
}
CL_String CL_PathHelp::get_basepath(
const CL_String &fullname,
PathType path_type)
{
CL_String path = get_fullpath(fullname, path_type);
#ifdef WIN32
if (path_type == path_type_file && path.length() >= 2)
{
if (path[1] == ':')
return path.substr(2);
if (path[0] == '\\' && path[1] == '\\')
{
CL_String::size_type pos = path.find_first_of("/\\", 2);
if (pos == CL_String::npos)
return CL_String();
else
return path.substr(pos);
}
}
#endif
return path;
}
void TestApp::test_resources(void)
{
CL_Console::write_line(" Header: resource.h");
CL_Console::write_line(" Class: CL_Resource");
// Construct resource manager. This will cause sig_resource_added() to be signalled for each
// resource object located in the resource file. This means ResourceApp::on_resource_added will
// get called for each resource.
CL_ResourceManager resources("resources.xml");
// Lets try to access some of the clanlib objects in the resource file:
CL_String config_name = resources.get_string_resource("Configuration/name", "");
int config_width = resources.get_integer_resource("Configuration/width", 0 );
int config_height = resources.get_integer_resource("Configuration/height", 0 );
CL_Console::write_line(CL_String("name = ") + config_name );
CL_Console::write_line(CL_String("width = ") + CL_StringHelp::int_to_text(config_width));
CL_Console::write_line(CL_String("height = ") + CL_StringHelp::int_to_text(config_height));
// Get a list over all classes
std::vector<CL_String> v = resources.get_resource_names_of_type("uclass", "Classes");
std::vector<CL_String>::iterator it;
for(it = v.begin(); it != v.end(); ++it)
{
// Get one of our custom resources:
CL_Resource resource = resources.get_resource(*it);
// Its possible to access the dom element object in the resource:
CL_DomElement element = resource.get_element();
int strength = CL_StringHelp::text_to_int(element.get_attribute("strength"));
int magic = CL_StringHelp::text_to_int(element.get_attribute("magic"));
CL_Console::write_line(CL_String("\n") + "name = " + resource.get_name());
CL_Console::write_line(CL_String("strength = ") + CL_StringHelp::int_to_text(strength));
CL_Console::write_line(CL_String("magic = ") + CL_StringHelp::int_to_text(magic) );
}
}
int CL_Event::wait(int count, CL_Event const * const * events, int timeout)
{
#ifdef WIN32
DWORD timeout_win32 = (timeout == -1) ? INFINITE : timeout;
int index_events;
int num_events = 0;
for (index_events = 0; index_events < count; index_events++)
{
bool flagged = events[index_events]->impl->provider->check_before_wait();
if (flagged)
return index_events;
num_events += events[index_events]->impl->provider->get_num_event_handles();
}
if (num_events == 0)
{
WaitForMultipleObjects(0, 0, FALSE, timeout_win32);
return -1;
}
else if (num_events == 1 && count == 1)
{
HANDLE handle = events[0]->impl->provider->get_event_handle(0);
while (true)
{
DWORD result = WaitForSingleObject(handle, timeout_win32);
if (result == WAIT_TIMEOUT)
break;
bool flagged = events[0]->impl->provider->check_after_wait(0);
if (flagged)
return 0;
}
return -1;
}
else
{
std::vector<HANDLE> handles;
for (index_events = 0; index_events < count; index_events++)
{
int num_handles = events[index_events]->impl->provider->get_num_event_handles();
for (int i=0; i<num_handles; i++)
handles.push_back(events[index_events]->impl->provider->get_event_handle(i));
}
while (true)
{
DWORD result = WaitForMultipleObjects(handles.size(), &handles[0], FALSE, timeout_win32);
DWORD index = 0;
if (result == WAIT_TIMEOUT)
break;
else if (result == WAIT_FAILED)
throw CL_Exception("WaitForMultipleObjects failed");
else if (result >= WAIT_OBJECT_0 && result < WAIT_OBJECT_0 + num_events)
index = result - WAIT_OBJECT_0;
else if (result >= WAIT_ABANDONED_0 && result < WAIT_ABANDONED_0 + num_events)
index = result - WAIT_ABANDONED_0;
else
continue;
for (index_events = 0; index_events < count; index_events++)
{
int num_handles = events[index_events]->impl->provider->get_num_event_handles();
if (index < (DWORD) num_handles)
{
bool flagged = events[index_events]->impl->provider->check_after_wait((int) index);
if (flagged)
return index_events;
break;
}
index -= (DWORD) num_handles;
}
}
return -1;
}
#else
int index_events;
for (index_events = 0; index_events < count; index_events++)
{
CL_EventProvider *provider = events[index_events]->impl->provider;
if (provider == 0)
throw CL_Exception("CL_Event's CL_EventProvider is a null pointer!");
bool flagged = provider->check_before_wait();
if (flagged)
return index_events;
}
if (timeout == -1) // Wait forever
timeout = 0x7FFFFFFF;
// Placing the timeval struct here allows linux systems to more
// correctly resume a select if it was awaken by a complex event.
// On non-linux unixes (those that do not update timeval), the
// timeout precision will be more inaccurate for manual reset
// events with multiple listeners.
// -- mbn 4 nov 2004
timeval tv;
tv.tv_sec = timeout / 1000;
tv.tv_usec = (timeout % 1000) * 1000;
while (true)
{
bool reads = false;
bool writes = false;
bool exceptions = false;
int highest_fd = -1;
fd_set rfds, wfds, efds;
FD_ZERO(&rfds);
FD_ZERO(&wfds);
FD_ZERO(&efds);
for (index_events = 0; index_events < count; index_events++)
{
CL_EventProvider *provider = events[index_events]->impl->provider;
if (provider == 0)
throw CL_Exception("CL_Event's CL_EventProvider is a null pointer!");
int num_handles = provider->get_num_event_handles();
for (int i=0; i<num_handles; i++)
{
int handle = provider->get_event_handle(i);
switch (provider->get_event_type(i))
{
case CL_EventProvider::type_fd_read:
FD_SET(handle, &rfds);
if (handle > highest_fd)
highest_fd = handle;
reads = true;
break;
case CL_EventProvider::type_fd_write:
FD_SET(handle, &wfds);
if (handle > highest_fd)
highest_fd = handle;
writes = true;
break;
case CL_EventProvider::type_fd_exception:
FD_SET(handle, &efds);
if (handle > highest_fd)
highest_fd = handle;
exceptions = true;
break;
}
}
}
int result;
rerun_eintr:
result = select(highest_fd+1,
reads ? &rfds : 0,
writes ? &wfds : 0,
exceptions ? &efds : 0,
(timeout == -1) ? 0 : &tv);
if (result == -1) // Error occoured
{
if(errno == EINTR) //The syscall was interrupted. Try again
goto rerun_eintr;
else
throw CL_Exception(CL_String("Event wait failed! Unix Error: ") + strerror(errno));
}
else if (result == 0) // Timed out
{
return -1;
}
else // Got a message
{
// find the flagged sockets
for (index_events = 0; index_events < count; index_events++)
{
CL_EventProvider *provider = events[index_events]->impl->provider;
if (provider == 0)
throw CL_Exception("CL_Event's CL_EventProvider is a null pointer!");
int num_handles = provider->get_num_event_handles();
for (int i=0; i<num_handles; i++)
{
int handle = provider->get_event_handle(i);
bool flagged = false;
switch (provider->get_event_type(i))
{
case CL_EventProvider::type_fd_read:
if (FD_ISSET(handle, &rfds))
flagged = true;
break;
case CL_EventProvider::type_fd_write:
if (FD_ISSET(handle, &wfds))
flagged = true;
break;
case CL_EventProvider::type_fd_exception:
if (FD_ISSET(handle, &efds))
flagged = true;
break;
}
if (flagged)
{
flagged = provider->check_after_wait(i);
if (flagged)
return index_events;
}
}
}
}
}
return -1;
#endif
}
void DebugTool::PrintFps(void){
std::stringstream stream;
stream << fps;
Engine &ObjEngine = Engine::GetEngine();
consoleFont.draw_text(ObjEngine.graphicContext, 10, 10, CL_String(stream.str()));
}
void DebugTool::PrintMemoryUsage(void){
std::stringstream stream;
stream << memoryUsage;
Engine &ObjEngine = Engine::GetEngine();
consoleFont.draw_text(ObjEngine.graphicContext, 10, 20, CL_String(stream.str() + " MB"));
}
CL_String CL_SecurityIdentifier::get_domain_name() const
{
return CL_String();
}
int ConsoleProgram::main(const std::vector<CL_String> &args)
{
// Setup clanCore:
CL_SetupCore setup_core;
// Initialize the ClanLib display component
CL_SetupDisplay setup_display;
// Create a console Window if one does not exist:
CL_ConsoleWindow console_window("Console", 80, 600);
try
{
//получение параметра запуска
for (std::vector<CL_String>::const_iterator iter_args = args.begin(); iter_args != args.end(); ++iter_args)
CL_Console::write_line( *iter_args );
//получение имени директории для сохранения
CL_String workDirectoryName;
if (args.size() > 1)
{
//полное имя рабочей директории
workDirectoryName = args[1];
//конвертирование из CP-1251 в UTF-8 имени рабочей директории
workDirectoryName = decode(workDirectoryName);
}
else
{
//получение полного пути к текущему каталогу
workDirectoryName = CL_Directory::get_current();
}
CL_Console::write_line("workDirectoryName: %1", workDirectoryName);
//получение имени последней директории
CL_String locationName = CL_PathHelp::remove_trailing_slash(workDirectoryName);
locationName = CL_PathHelp::get_filename(locationName);
CL_Console::write_line("locationName: %1", locationName);
CL_String tempDir = CL_PathHelp::add_trailing_slash(workDirectoryName) + "temp\\";
CL_DirectoryScanner directoryScanner;
directoryScanner.scan(tempDir, "*.export");
while (directoryScanner.next())
{
//имя обрабатываемого файла
CL_String fileName;
if (directoryScanner.is_directory())
continue;
//получение полного имени файла экспорта
fileName = directoryScanner.get_pathname();
//конвертирование из CP-1251 в UTF-8
fileName = decode(fileName);
CL_Console::write_line("find: %1", fileName);
//открытие XML файла
CL_File fileXML;
bool is_opened = fileXML.open(fileName);
if( !is_opened )
return PrintError( CL_String("Can't open file: ") + fileName );
//Создание объекта DOM парсера
CL_DomDocument document(fileXML);
//получение root узла
CL_DomElement root = document.get_document_element();
if( root.get_local_name() != "resources")
{
CL_Console::write_line("Root name can't be: %1", root.get_local_name().c_str());
return PrintError("");
}
//цикл по потомкам "resources"
for (CL_DomNode cur = root.get_first_child(); !cur.is_null(); cur = cur.get_next_sibling())
{
//загрузка только спрайтов
if (cur.get_node_name() != "sprite")
continue;
CL_DomElement element = cur.to_element();
//проверка на обязательные параметры
if (!element.has_attribute("name"))
return PrintError("Error: can't find parametr \"name\"");
CL_DomString name = element.get_attribute("name");
int x = element.get_attribute_int("x");
int y = element.get_attribute_int("y");
//добавление спрайта
sprites.push_back( S_Sprite(name, CL_Vec2i(x, y) ) );
//цикл по "image" (формирование списка имен файлов)
for (CL_DomNode cur_image = cur.get_first_child(); !cur_image.is_null(); cur_image = cur_image.get_next_sibling())
{
//загрузка только image
if (cur_image.get_node_name() != "image")
continue;
CL_DomElement element_image = cur_image.to_element();
CL_DomString file = element_image.get_attribute("file");
//конвертирование из CP-1251 в UTF-8 имени файла изображения
file = decode(file);
//добавление изображения для обработки
(sprites.end()-1)->AddImage(file);
}
//цикл по "frame" (дополнение списка информацией о файле)
for (CL_DomNode cur_frame = cur.get_first_child(); !cur_frame.is_null(); cur_frame = cur_frame.get_next_sibling())
{
if (cur_frame.get_node_name() != "frame")
continue;
CL_DomElement element_frame = cur_frame.to_element();
//проверка на обязательные параметры
if (!element_frame.has_attribute("nr"))
return PrintError("Error: can't find parameter \"nr\"");
size_t nr = element_frame.get_attribute_int("nr");
int speed = element_frame.get_attribute_int("speed");
int x_image = element_frame.get_attribute_int("x");
int y_image = element_frame.get_attribute_int("y");
(sprites.end()-1)->SetAnimationsParam(nr, speed, CL_Vec2i(x_image, y_image));
}
}
fileXML.close();
}
//CL_Console::wait_for_key();
// TODO:
//проверка на перекрытие ресурсных имен
//return PrintError( CL_String("Error: This resourse already exist") );
//декодирование имени спрайта и генерация с декодированием полных имен файлов
for(T_Sprites::iterator iter_sprites = sprites.begin(); iter_sprites != sprites.end(); ++iter_sprites)
{
for(S_Sprite::T_Images::iterator iter_images = iter_sprites->mImages.begin(); iter_images != iter_sprites->mImages.end(); ++iter_images)
{
//CL_Console::write_line("processing: %1 pos = %2 %3", iter_sprites->mName, iter_sprites->mPos.x, iter_sprites->mPos.y);
//генерация полного имени файла
iter_images->mSourceFullName = CL_PathHelp::make_absolute(tempDir, iter_images->mSourceFileName);
//CL_Console::write_line("image: %1 pos = %2 %3", iter_images->mSourceFileName, iter_images->mOffset.x, iter_images->mOffset.y);
CL_Console::write_line("image fullname: %1", iter_images->mSourceFullName);
}
}
//CL_Console::wait_for_key();
//загрузка файлов-картинок
for(T_Sprites::iterator iter_sprites = sprites.begin(); iter_sprites != sprites.end(); ++iter_sprites)
for(S_Sprite::T_Images::iterator iter_images = iter_sprites->mImages.begin(); iter_images != iter_sprites->mImages.end(); ++iter_images)
iter_images->mImage = CL_ImageProviderFactory::load(iter_images->mSourceFullName).to_format(cl_rgba8);
//CL_Console::wait_for_key();
//проход по всем спрайтам для определения необходимости разрезки на несколько спрайтов
for(T_Sprites::size_type iSprites = 0; iSprites < sprites.size(); ++iSprites)
{
for(S_Sprite::T_Images::size_type iImages = 0; iImages < sprites[iSprites].mImages.size(); ++iImages)
{
//определение размеров
CL_Size image_size = sprites[iSprites].mImages[iImages].mImage.get_size();
//Определение наличия прозрачности
sprites[iSprites].mImages[iImages].mNoTransparent = testAlpha(sprites[iSprites].mImages[iImages].mImage);
//высота превышает допустимую
if(image_size.height > MAX_HEIGHT)
return PrintError( CL_String("Error: image height is more then 1024") );
//ширина превышает допустимую
if(image_size.width > MAX_WIDTH)
{
CL_Console::write_line("scussor: sprites[iSprites].mName: %1", sprites[iSprites].mName);
//проверка на то что у этого спрайта один image
if(sprites[iSprites].mImages.size() > 1)
return PrintError( CL_String("Error: animation size can't be more than MAX_WIDTH*MAX_HEIGHT (1024*1024)") );
//сохранение высоты и ширины
int h = image_size.height;
int w = image_size.width;
//определение кол-ва частей на разрезку
int n; //кол-во частей на разрезку
for(n = 2; n < 10; ++n)
if (w > (n-1)*MAX_WIDTH - 2*(n-2) && w <= (n)*MAX_WIDTH - 2*(n-1))
break;
T_Sprites::iterator addedSprite;
switch (n)
{
case 2: //две части
//спрайт слева (задание имени и позиции спрайта)
addedSprite = sprites.insert( sprites.begin()+iSprites+1,
S_Sprite(CL_String(sprites[iSprites].mName)+CL_StringHelp::int_to_text(0), sprites[iSprites].mPos+CL_Vec2i(0, 0) ) );
//создание одного Image в добавленом спрайте
addedSprite->AddImage(sprites[iSprites].mImages[iImages].mSourceFileName);
//создание изображения (задание зазмеров спрайта)
addedSprite->mImages[0].mImage = CL_PixelBuffer(MAX_WIDTH, h, cl_rgba8);
//наследование флага отсутствия прозрачности
addedSprite->mImages[0].mNoTransparent = sprites[iSprites].mImages[iImages].mNoTransparent;
//копирование куска изображения
sprites[iSprites].mImages[iImages].mImage.convert(addedSprite->mImages[0].mImage,
//(dst Rect, src Rect)
CL_Rect(0, 0, MAX_WIDTH, h), CL_Rect(0, 0, MAX_WIDTH, h));
addedSprite->mImages[0].mDeltaGrid.left = 0;
addedSprite->mImages[0].mDeltaGrid.right = -1;
//спрайт справа (задание имени и позиции спрайта)
addedSprite = sprites.insert( sprites.begin()+iSprites+1,
S_Sprite(CL_String(sprites[iSprites].mName)+CL_StringHelp::int_to_text(1), sprites[iSprites].mPos+CL_Vec2i(MAX_WIDTH-1, 0) ) );
//создание одного Image в добавленом спрайте
addedSprite->AddImage(sprites[iSprites].mImages[iImages].mSourceFileName);
//создание изображения (задание зазмеров спрайта)
addedSprite->mImages[0].mImage = CL_PixelBuffer(w-MAX_WIDTH+2, h, cl_rgba8);
//наследование флага отсутствия прозрачности
addedSprite->mImages[0].mNoTransparent = sprites[iSprites].mImages[iImages].mNoTransparent;
//копирование куска изображения
sprites[iSprites].mImages[iImages].mImage.convert(addedSprite->mImages[0].mImage,
//(dst Rect, src Rect)
CL_Rect(0, 0, w-MAX_WIDTH+2, h), CL_Rect(MAX_WIDTH-2, 0, w, h));
addedSprite->mImages[0].mDeltaGrid.left = +1;
addedSprite->mImages[0].mDeltaGrid.right = -1;
break;
default:
return PrintError( CL_String("Error: scussored on >2 part is't writen by C++ programmer") );
break;
}
/*
//разделение изображения на части
int x = 1;
int residual = image_size.width;
int left, right;
int i = 0;
do
{
x -= 1;
left = x;
x += min(MAX_WIDTH, residual);
right = x;
residual -= (right-left-1);
i++;
//добавление куска
T_Sprites::iterator addedSprite =
sprites.insert( sprites.begin()+iSprites+1,
S_Sprite(CL_String(sprites[iSprites].mName)+CL_StringHelp::int_to_text(i), sprites[iSprites].mPos+CL_Vec2i(left, 0) ) );
//создание одного Image в добавленом спрайте
addedSprite->AddImage(sprites[iSprites].mImages[iImages].mSourceFileName);
//создание изображения
addedSprite->mImages[0].mImage = CL_PixelBuffer(right-left, h, cl_rgba8);
//наследование флага отсутствия прозрачности
addedSprite->mImages[0].mNoTransparent = sprites[iSprites].mImages[iImages].mNoTransparent;
//копирование куска изображения
sprites[iSprites].mImages[iImages].mImage.convert(addedSprite->mImages[0].mImage, CL_Rect(0,0,right-left,h), CL_Rect(left, 0, right, h));
}
while(residual != 1);
*/
//удаление исходного разрезаемого изображения
sprites.erase( sprites.begin() + iSprites );
}
}
}
// for(T_Sprites::iterator iter_sprites = sprites.begin(); iter_sprites != sprites.end(); ++iter_sprites)
// {
// //определение размеров
// CL_Size imageSize = iter_sprites->mImage.get_size();
// //Добавление несколько пикселей для границы спрайтов с дублированием граничных пикселей
// iter_sprites->image = CL_PixelBufferHelp::add_border(iter_sprites->image, ADDING_BORDER, CL_Rect(0, 0, image_size.width, image_size.height) );
// }
///////////////////////////////////////////////////////
//распределение картинок на текстурном атласе
///////////////////////////////////////////////////////
for(T_Sprites::size_type iSprites = 0; iSprites < sprites.size(); ++iSprites)
{
for(S_Sprite::T_Images::size_type iImages = 0; iImages < sprites[iSprites].mImages.size(); ++iImages)
{
//переполучение размера
CL_Size image_size = sprites[iSprites].mImages[iImages].mImage.get_size();
//помещение в отсортированый список указателя на image
sortedList.insert( std::make_pair( max(image_size.width, image_size.height), S_ImagePointer(iSprites, iImages) ) );
}
}
//Проверка сортировки
//for(T_SortedList::iterator iter_sortedList = sortedList.begin(); iter_sortedList != sortedList.end(); ++iter_sortedList)
// CL_Console::write_line("sorted: %1, key=(%2, %3)", iter_sortedList->first, iter_sortedList->second.iSprite, iter_sortedList->second.iImage);
//проход по всем спрайтам по убыванию большей стороны
for(T_SortedList::reverse_iterator iter_sortedList = sortedList.rbegin(); iter_sortedList != sortedList.rend(); ++iter_sortedList)
{
//номер спрайта
T_Sprites::size_type iSprite = iter_sortedList->second.iSprite;
//номер изображения в спрайте
S_Sprite::T_Images::size_type iImage = iter_sortedList->second.iImage;
if( !sprites[iSprite].mImages[iImage].mNoTransparent )
pngNodes.ConnectTexture( S_ImagePointer(iSprite, iImage) );
else
jpgNodes.ConnectTexture( S_ImagePointer(iSprite, iImage) );
//проверка добавления
CL_Console::write_line("rects are %1 %2 %3 %4", sprites[iSprite].mImages[iImage].mSrcRect.left, sprites[iSprite].mImages[iImage].mSrcRect.top, sprites[iSprite].mImages[iImage].mSrcRect.right, sprites[iSprite].mImages[iImage].mSrcRect.bottom);
}
size_t textureW = MAX_WIDTH;
size_t textureH = MAX_HEIGHT;
//список текстур PNG
std::vector<CL_PixelBuffer> endTexturesPNG;
//список текстур JPG
std::vector<CL_PixelBuffer> endTexturesJPG;
//физическое создание конечных текстур
size_t nTexture = pngNodes.GetNumberTextures();
for(size_t iTexture = 0; iTexture < nTexture; ++iTexture)
endTexturesPNG.push_back( CL_PixelBuffer(textureW, textureH, cl_rgba8) );
nTexture = jpgNodes.GetNumberTextures();
for(size_t iTexture = 0; iTexture < nTexture; ++iTexture)
endTexturesJPG.push_back( CL_PixelBuffer(textureW, textureH, cl_rgb8) );
//обнуление цвета и альфы конечных текстур PNG
for(std::vector<CL_PixelBuffer>::iterator iterEndTexture = endTexturesPNG.begin(); iterEndTexture != endTexturesPNG.end(); ++iterEndTexture)
memset( (void *)iterEndTexture->get_data(), 0, iterEndTexture->get_pitch()*iterEndTexture->get_height() );
//обнуление цвета конечных текстуры JPG
for(std::vector<CL_PixelBuffer>::iterator iterEndTexture = endTexturesJPG.begin(); iterEndTexture != endTexturesJPG.end(); ++iterEndTexture)
memset( (void *)iterEndTexture->get_data(), 0, iterEndTexture->get_pitch()*iterEndTexture->get_height() );
//копирование подтекстур в конечные текстуры
for(T_Sprites::iterator iter_sprites = sprites.begin(); iter_sprites != sprites.end(); ++iter_sprites)
{
for(S_Sprite::T_Images::iterator iter_images = iter_sprites->mImages.begin(); iter_images != iter_sprites->mImages.end(); ++iter_images)
{
//размеры добавляемого прямоугольника
CL_Rect srcRect = CL_Rect(0, 0, iter_images->mImage.get_width(), iter_images->mImage.get_height());
//номер текстуры
size_t iTexture = iter_images->mITexture;
if( !iter_images->mNoTransparent )
iter_images->mImage.convert(endTexturesPNG[iTexture], iter_images->mSrcRect, srcRect);
else
iter_images->mImage.convert(endTexturesJPG[iTexture], iter_images->mSrcRect, srcRect);
}
}
//сохранение текстур PNG
std::vector<CL_PixelBuffer>::size_type iEndTexture, nEndTexture;
nEndTexture = endTexturesPNG.size();
for(iEndTexture = 0; iEndTexture < nEndTexture; ++iEndTexture)
{
//Предумножение на альфу
endTexturesPNG[iEndTexture].premultiply_alpha();
//сохранение
CL_PNGProvider::save(endTexturesPNG[iEndTexture], CL_PathHelp::make_absolute(workDirectoryName, OUTPUT_TEXTURE_NAME + CL_StringHelp::int_to_text(iEndTexture) + ".png") );
CL_Console::write_line("saved %1", CL_PathHelp::make_absolute(workDirectoryName, OUTPUT_TEXTURE_NAME + CL_StringHelp::int_to_text(iEndTexture) + ".png"));
}
//сохранение текстур JPG
nEndTexture = endTexturesJPG.size();
for(iEndTexture = 0; iEndTexture < nEndTexture; ++iEndTexture)
{
//сохранение
CL_JPEGProvider::save(endTexturesJPG[iEndTexture], CL_PathHelp::make_absolute(workDirectoryName, OUTPUT_TEXTURE_NAME + CL_StringHelp::int_to_text(iEndTexture) + ".jpg"));
CL_Console::write_line("saved %1", CL_PathHelp::make_absolute(workDirectoryName, OUTPUT_TEXTURE_NAME + CL_StringHelp::int_to_text(iEndTexture) + ".jpg"));
}
//CL_Console::wait_for_key();
#if SAVE_COLLISION != 0
//Запись файлов - контуров////////////////////////////////////////////////////////
//удаление старых файлов
for(T_Sprites::iterator iter_sprites = sprites.begin(); iter_sprites != sprites.end(); ++iter_sprites)
{
for(S_Sprite::T_Images::iterator iter_images = iter_sprites->mImages.begin(); iter_images != iter_sprites->mImages.end(); ++iter_images)
{
CL_String currentOutlineFileName = iter_images->mCollision.GetCollisionFileName();
if ( CL_FileHelp::file_exists(currentOutlineFileName) )
CL_FileHelp::delete_file(currentOutlineFileName);
}
}
//объекты файлов для записи в них данных контуров
std::map<CL_String, CL_File> outlineFiles;
//открытие файлов
for(T_Sprites::iterator iter_sprites = sprites.begin(); iter_sprites != sprites.end(); ++iter_sprites)
{
for(S_Sprite::T_Images::iterator iter_images = iter_sprites->mImages.begin(); iter_images != iter_sprites->mImages.end(); ++iter_images)
{
CL_String currentOutlineFileName = iter_images->mCollision.GetCollisionFileName();
std::map<CL_String, CL_File>::iterator iterOutlineFiles = outlineFiles.find(currentOutlineFileName);
if (iterOutlineFiles == outlineFiles.end())
{
CL_File outlineFile;
//формирование полного имени файла
CL_String currentOutlineFullName = CL_PathHelp::make_absolute(workDirectoryName, currentOutlineFileName);
//открытие файла
CL_Console::write_line("open outline file: %1", currentOutlineFullName);
bool is_opened = outlineFile.open(currentOutlineFullName, CL_File::open_always, CL_File::access_write);
if (!is_opened)
return PrintError( CL_String("I Can't open file: ") + currentOutlineFullName );
//добавление файла в список открытых файлов
outlineFiles.insert( std::make_pair(currentOutlineFileName, outlineFile) );
CL_Console::write_line("-inserted %1", currentOutlineFileName);
}
}
}
//сохранение в бинарные файлы данных о контуре
for(T_Sprites::iterator iter_sprites = sprites.begin(); iter_sprites != sprites.end(); ++iter_sprites)
{
for(S_Sprite::T_Images::iterator iter_images = iter_sprites->mImages.begin(); iter_images != iter_sprites->mImages.end(); ++iter_images)
{
CL_String currentOutlineFileName = iter_images->mCollision.GetCollisionFileName();
//сохранение информации о коллизии
saveCollision(iter_images->mImage, outlineFiles[currentOutlineFileName]);
//установка смещения для последующих таких имён
for(T_Sprites::iterator iter_sprites2 = iter_sprites; iter_sprites2 != sprites.end(); ++iter_sprites2)
{
S_Sprite::T_Images::iterator iter_images2;
if(iter_sprites2 == iter_sprites)
iter_images2 = iter_images + 1;
else
iter_images2 = iter_sprites2->mImages.begin();
for(; iter_images2 != iter_sprites2->mImages.end(); ++iter_images2)
if(iter_images->mCollision.GetCollisionFileName() == iter_images2->mCollision.GetCollisionFileName())
//CL_Console::write_line("+size %1", outlineFiles[currentOutlineFileName].get_position() );
iter_images2->mCollision.mFileOffset = outlineFiles[currentOutlineFileName].get_position();
}
CL_Console::write_line("saved %1: %2 %3", iter_images->mSourceFileName, currentOutlineFileName, iter_images->mCollision.mFileOffset);
}
}
//закрытие файлов
for(std::map<CL_String, CL_File>::iterator iterOutlineFiles = outlineFiles.begin(); iterOutlineFiles != outlineFiles.end(); ++iterOutlineFiles)
iterOutlineFiles->second.close();
#endif
//CL_Console::wait_for_key();
//////////////////////////////////////////////////////////
//формирование имени файла
//CL_String fileResourceName = CL_PathHelp::make_absolute(workDirectoryName, locationName + ".xml");
CL_String fileResourceName = CL_PathHelp::make_absolute(workDirectoryName, RESOURCES_FILE_NAME);
CL_Console::write_line("fileResourceName: %1", fileResourceName);
//открытие файла XML
CL_File fileResourceXML;
bool is_opened = fileResourceXML.open(fileResourceName, CL_File::create_always, CL_File::access_write);
if( !is_opened )
return PrintError( CL_String("I Can't open file: ") + fileResourceName );
//запись файл заголовка
fileResourceXML.write_string_text("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
//Создание объекта DOM парсера
CL_DomDocument resourceXML;
//корневой узел - resources
CL_DomElement resourcesElement(resourceXML, "resources");
resourceXML.append_child(resourcesElement);
//узлы bitmap
std::map<CL_String, CL_String> complianceCollisions;
//формирование map-ы bitmap
for(T_Sprites::iterator iter_sprites = sprites.begin(); iter_sprites != sprites.end(); ++iter_sprites)
for(S_Sprite::T_Images::iterator iter_images = iter_sprites->mImages.begin(); iter_images != iter_sprites->mImages.end(); ++iter_images)
complianceCollisions.insert( std::make_pair(iter_images->mCollision.GetCollisionFileName(), iter_images->mCollision.GetCollisionName()) );
#if SAVE_COLLISION != 0
//запись в XML файл ресурсов битовых масок
for(std::map<CL_String, CL_String>::iterator iterComplianceCollisions = complianceCollisions.begin(); iterComplianceCollisions != complianceCollisions.end(); ++iterComplianceCollisions)
{
CL_DomElement bitmapElement(resourceXML, "bitmap");
bitmapElement.set_attribute("name", iterComplianceCollisions->second);
bitmapElement.set_attribute("file", iterComplianceCollisions->first);
resourcesElement.append_child(bitmapElement);
}
#endif
//запись в XML файл ресурсов результирующих прямоугольников
for(T_Sprites::iterator iter_sprites = sprites.begin(); iter_sprites != sprites.end(); ++iter_sprites)
{
CL_String currentResourceName = iter_sprites->mName;
//узел - sprite
CL_DomElement spriteElement(resourceXML, "sprite");
spriteElement.set_attribute("name", currentResourceName);
resourcesElement.append_child(spriteElement);
//тэг image
for(S_Sprite::T_Images::iterator iter_images = iter_sprites->mImages.begin(); iter_images != iter_sprites->mImages.end(); ++iter_images)
{
CL_Rect currentSrcRect = iter_images->mSrcRect;
//узел - image
CL_DomElement imageElement(resourceXML, "image");
if( !iter_images->mNoTransparent )
imageElement.set_attribute("file", OUTPUT_TEXTURE_NAME + CL_StringHelp::int_to_text(iter_images->mITexture) + ".png");
else
imageElement.set_attribute("file", OUTPUT_TEXTURE_NAME + CL_StringHelp::int_to_text(iter_images->mITexture) + ".jpg");
spriteElement.append_child(imageElement);
#if SAVE_COLLISION != 0
//сохранение коллизий
imageElement.set_attribute("bitmap", iter_images->mCollision.GetCollisionName());
imageElement.set_attribute_int("offset", iter_images->mCollision.mFileOffset);
#endif
//элемент grid
CL_DomElement GridElement(resourceXML, "grid");
GridElement.set_attribute("pos", cl_format("%1,%2", currentSrcRect.left + iter_images->mDeltaGrid.left, currentSrcRect.top + iter_images->mDeltaGrid.top) );
GridElement.set_attribute("size", cl_format("%1,%2", currentSrcRect.right-currentSrcRect.left + iter_images->mDeltaGrid.right, currentSrcRect.bottom-currentSrcRect.top + iter_images->mDeltaGrid.bottom) );
imageElement.append_child(GridElement);
}
//прервать выполнение сохранения, если анимации нет
if (!iter_sprites->mIsFrame)
continue;
for(S_Sprite::T_Images::iterator iter_images = iter_sprites->mImages.begin(); iter_images != iter_sprites->mImages.end(); ++iter_images)
{
//элемент frame
CL_DomElement frameElement(resourceXML, "frame");
frameElement.set_attribute_int("nr", iter_images - iter_sprites->mImages.begin());
if (iter_images->mDelay != 0)
frameElement.set_attribute_int("speed", iter_images->mDelay);
frameElement.set_attribute_int("x", iter_images->mOffset.x);
frameElement.set_attribute_int("y", iter_images->mOffset.y);
spriteElement.append_child(frameElement);
}
}
//подключение всех файлов с дополнительными ресурсами
directoryScanner.scan(workDirectoryName, "*.xml");
while (directoryScanner.next())
{
//проверка валидности файла
if (directoryScanner.is_directory() || directoryScanner.get_name() == RESOURCES_FILE_NAME)
continue;
//открытие ресурсного XML файла
CL_Console::write_line("include xml file: " + directoryScanner.get_pathname());
CL_File file(directoryScanner.get_pathname());
CL_DomDocument doc(file);
CL_DomElement root = doc.get_document_element();
if (root.get_tag_name() != "resources")
{
CL_Console::write_line("Root name can't be: %1", root.get_tag_name());
return PrintError("");
}
//добавление всех ресурсов в текущий документ
for (CL_DomElement element = root.get_first_child_element(); !element.is_null(); element = element.get_next_sibling_element())
resourcesElement.append_child(cloneElement(element, resourceXML));
}
//сохранение в файл XML структуры
resourceXML.save(fileResourceXML);
//закрытие файла
fileResourceXML.close();
//сохранение координат спрайтов и инициализации/деинициализации в lua скрипте
//формирование имени файла
//CL_String luaFileName = CL_PathHelp::make_absolute(workDirectoryName, locationName + ".lua");
CL_String luaFileName = CL_PathHelp::make_absolute(workDirectoryName, LUA_SCRIPT_NAME);
CL_File luaFile;
is_opened = luaFile.open(luaFileName, CL_File::create_always, CL_File::access_write);
if( !is_opened )
return PrintError( CL_String("Can't open file: ") + luaFileName);
luaFile.write_string_text( cl_format("function %1_createSprites()", locationName) );
//запись в XML файл ресурсов результирующих прямоугольников
for(T_Sprites::iterator iter_sprites = sprites.begin(); iter_sprites != sprites.end(); ++iter_sprites)
{
CL_String currentResourceName = iter_sprites->mName;
int x = iter_sprites->mPos.x;
int y = iter_sprites->mPos.y;
luaFile.write_string_text( cl_format("\t%1 = Sprite(\"%2\", %3, %4)", currentResourceName, currentResourceName, x, y) );
}
luaFile.write_string_text( cl_format("end") );
luaFile.write_string_text(CL_String(""));
luaFile.write_string_text( cl_format("function %1_deleteSprites()", locationName) );
//запись в XML файл ресурсов результирующих прямоугольников
for(T_Sprites::iterator iter_sprites = sprites.begin(); iter_sprites != sprites.end(); ++iter_sprites)
{
CL_String currentResourceName = iter_sprites->mName;
luaFile.write_string_text( cl_format("\t%1 = nil", currentResourceName) );
}
luaFile.write_string_text( cl_format("end") );
/*
function Location01_createSprites()
sprite1 = Sprite("sprite1", 10, 20)
sprite2 = Sprite("sprite2", 13, 666)
...
spriten = Sprite("spriten", 999, 0)
end
function Location01_deleteSprites()
sprite1 = nil
sprite2 = nil
...
spriten = nil
end
*/
luaFile.close();
CL_Console::write_line("Press any key...");
CL_Console::wait_for_key();
}
catch(CL_Exception &exception)
{
CL_Console::write_line("Exception caught: " + exception.get_message_and_stack_trace());
CL_Console::wait_for_key();
return -1;
}
return 0;
}
int App::start(const std::vector<CL_String> &args)
{
CL_OpenGLWindowDescription description;
description.set_title("NightVision Shader");
description.set_size(CL_Size(1024, 768), true);
CL_DisplayWindow window(description);
CL_InputDevice keyboard = window.get_ic().get_keyboard();
CL_GraphicContext gc = window.get_gc();
CL_Slot slot_input_up = (window.get_ic().get_keyboard()).sig_key_up().connect(this, &App::on_input_up);
CL_Slot slot_window_close = window.sig_window_close().connect(this, &App::window_close);
// Create offscreen texture
CL_Texture texture_offscreen(gc, gc.get_width(), gc.get_height());
texture_offscreen.set_min_filter(cl_filter_nearest);
texture_offscreen.set_mag_filter(cl_filter_nearest);
CL_Texture texture_mask(gc, gc.get_width(), gc.get_height());
texture_mask.set_min_filter(cl_filter_nearest);
texture_mask.set_mag_filter(cl_filter_nearest);
// Create offscreen framebuffer
CL_FrameBuffer framebuffer_offscreen(gc);
framebuffer_offscreen.attach_color_buffer(0, texture_offscreen);
CL_FrameBuffer framebuffer_mask(gc);
framebuffer_mask.attach_color_buffer(0, texture_mask);
CL_Image background(gc, "../PostProcessing/Resources/background.png");
CL_Image ball(gc, "../PostProcessing/Resources/ball.png");
ball.set_alignment(origin_center);
CL_Texture noise_texture(gc, "Resources/noise_texture_0001.png");
noise_texture.set_wrap_mode(cl_wrap_repeat, cl_wrap_repeat);
// Load and link shaders
CL_ProgramObject shader = CL_ProgramObject::load(gc, "Resources/vertex_shader.glsl", "Resources/fragment_shader.glsl");
shader.bind_attribute_location(0, "Position");
shader.bind_attribute_location(2, "TexCoord0");
if (!shader.link())
throw CL_Exception("Unable to link shader program: Error:" + shader.get_info_log());
quit = false;
float amount = 0.0f;
float timer = 0.0f;
float scale = 1.0f;
CL_Font font(gc, "tahoma", 32);
// Shader based on: http://www.geeks3d.com/20091009/shader-library-night-vision-post-processing-filter-glsl/
elapsedTime = 0.0f; // seconds
luminanceThreshold = 0.2f;
colorAmplification = 4.0f;
effectCoverage = 0.65f;
// Render the mask
gc.set_frame_buffer(framebuffer_mask);
gc.clear();
for (float offset=0.0f; offset<=1.0f; offset+=0.01f)
{
CL_Draw::circle(gc, gc.get_width() / 2.0f, gc.get_height() / 2.0f, 400.0f - offset * 64.0f, CL_Colorf(offset, offset, offset, 1.0f));
}
gc.reset_frame_buffer();
unsigned int startTime = CL_System::get_time();
while (!quit)
{
timer = (CL_System::get_time() - startTime) / 1000.0f;
elapsedTime = timer;
// Render standard image to offscreen buffer
gc.set_frame_buffer(framebuffer_offscreen);
background.draw(gc, 0, 0);
ball.draw(gc, gc.get_width() / 2 + 200 * sinf(timer / 2.0f), gc.get_height() / 2 + 200 * cosf(timer / 2.0f));
gc.reset_frame_buffer();
render_night_vision(gc, texture_offscreen, texture_mask, noise_texture, shader);
const int gap = 32;
font.draw_text(gc, 10, 64+gap*0, CL_String("luminanceThreshold : " + CL_StringHelp::float_to_text(luminanceThreshold) + " (Press Q,W)" ));
font.draw_text(gc, 10, 64+gap*1, CL_String("colorAmplification : " + CL_StringHelp::float_to_text(colorAmplification) + " (Press A,S)" ));
font.draw_text(gc, 10, 64+gap*2, CL_String("effectCoverage : " + CL_StringHelp::float_to_text(effectCoverage) + " (Press Z,X)" ));
window.flip();
CL_System::sleep(10);
CL_KeepAlive::process();
}
return 0;
}
void ReferenceFunction::parse_memberdef(CL_DomElement memberdef)
{
CL_DomElement element_name = memberdef.named_item("name").to_element();
if (element_name.is_null() || element_name.get_text() != name)
return;
CL_String type, type_formatted, definition, argsstring;
std::vector<CL_String> cur_params;
CL_DomNode cur_node;
for (cur_node = memberdef.get_first_child(); !cur_node.is_null(); cur_node = cur_node.get_next_sibling())
{
CL_DomElement cur_element = cur_node.to_element();
if (cur_element.is_null()) continue;
CL_String tag_name = cur_element.get_tag_name();
if (tag_name == "type")
{
type = cur_element.get_text();
type_formatted = ReferenceDocs::get_formatted(cur_element);
}
else if (tag_name == "definition")
{
definition = CL_StringHelp::trim(ReferenceDocs::escape_code(cur_element.get_text()));
}
else if (tag_name == "argsstring")
{
argsstring = cur_element.get_text();
}
else if (tag_name == "param")
{
CL_String param_type = ReferenceDocs::get_formatted(cur_element.named_item("type").to_element());
CL_String param_name = cur_element.named_item("declname").to_element().get_text();
CL_String param_defval = ReferenceDocs::get_formatted(cur_element.named_item("defval").to_element());
CL_String param_text = param_type + " " + param_name;
if (!param_defval.empty())
param_text += CL_String(" = ") + param_defval;
cur_params.push_back(param_text);
}
else if (tag_name == "briefdescription")
{
brief_description = ReferenceDocs::get_formatted(cur_element);
}
else if (tag_name == "detaileddescription")
{
detailed_description = ReferenceDocs::get_formatted(cur_element);
get_params_list(cur_element);
}
}
CL_String cur_declaration;
cur_declaration += cl_format("\t%1(", definition);
for (unsigned int index_params = 0; index_params < cur_params.size(); index_params++)
{
if (index_params > 0)
cur_declaration += ",";
cur_declaration += cl_format("\n\t\t%1", cur_params[index_params]);
}
cur_declaration += ");\n";
if (!declaration.empty())
declaration += "\n";
declaration += cur_declaration;
}
