void TopicModel::saveTopicData(QString qname, int k) {
DataManager *datamanager = new DataManager();
sleep(1);
connect(datamanager, SIGNAL(saveTick(int)), this, SIGNAL(saveTick(int)));
emit changeStatus("Saving");
/*************************************/
// Save parameters
/*************************************/
datamanager->saveInt(qname, "M", "M", M);
/*************************************/
// Save Theta
/*************************************/
if(k == 0) {
datamanager->saveArray(qname, "Theta", "feature", "probability", Theta0);
} else {
datamanager->saveArray(qname, "Theta", "feature", "probability", Theta[k-1]);
}
emit changeStatus("Ready");
disconnect(datamanager, SIGNAL(loadTick(int)), this, SIGNAL(loadTick(int)));
delete datamanager;
}
void main(int argc, char** argv)
{
omsg("OmicronSDK - SAGEInputServer");
omsg("Copyright (C) 2010-2015 Electronic Visualization Laboratory\nUniversity of Illinois at Chicago");
omsg("======================================================");
omsg("");
SAGEInputServer app;
// Read config file name from command line or use default one.
const char* cfgName = "sageTouch.cfg";
if(argc == 2) cfgName = argv[1];
Config* cfg = new Config(cfgName);
DataManager* dm = DataManager::getInstance();
// Add a default filesystem data source using current work dir.
dm->addSource(new FilesystemDataSource("./"));
dm->addSource(new FilesystemDataSource(OMICRON_DATA_PATH));
ServiceManager* sm = new ServiceManager();
sm->setupAndStart(cfg);
Sleep(1000);
Setting& stRoot = cfg->getRootSetting()["config"];
if( stRoot.exists("sagePort") )
{
DIM_PORT = cfg->getIntValue("sagePort", stRoot, 20005);
ofmsg("SAGE port set to %1%", %DIM_PORT);
}
bool set_time(int id)
{
if(id < 0)
return false;
DataManager* data = DataManager::instanceOf();
for(int i = 0; i < 3; ++i)
{
string tmp;
int hour, min, sec;
cout << "podaj dokladny czas" << endl;
cout << "teraz podaj: godzine" << endl;
hour = get_from_stdin();
cout << "podaj: minute" << endl;
min = get_from_stdin();
cout << "podaj: sekunde" << endl;
sec = get_from_stdin();
try{
if( data->getList().find(id)->setTime(hour,min,sec) )
{
return true;
}
}
catch(invalid_argument e)
{
cerr << "bledny czas" << endl;
}
}
return false;
}
bool set_date(int id)
{
if(id < 0)
return false;
DataManager* data = DataManager::instanceOf();
for(int i = 0; i < 3; ++i)
{
string tmp;
int day, month, year;
cout << "podaj date" << endl;
cout << "teraz podaj: dzien" << endl;
day = get_from_stdin();
cout << "podaj: miesiac" << endl;
month = get_from_stdin();
cout << "podaj: rok" << endl;
year = get_from_stdin();
try{
if( data->getList().find(id)->setDate(day,month,year) )
{
return true;
}
}
catch(invalid_argument e)
{
cerr << "bledna data" << endl;
}
}
return false;
}
MovableProducer::MovableProducer(DataManager &dm, const gamedata::unit_movable *um)
:
ObjectProducer(dm, um),
unit_data(*um),
on_move{dm.get_sound(this->unit_data.move_sound)},
on_attack{dm.get_sound(this->unit_data.move_sound)},
projectile{dm.get_type(this->unit_data.projectile_unit_id)} {
// extra graphics if available
// villagers have invalid attack and walk graphics
// it seems these come from the command data instead
auto walk = dm.get_unit_texture(this->unit_data.walking_graphics0);
if (!walk) {
// use standing instead
walk = this->graphics[graphic_type::standing];
}
this->graphics[graphic_type::walking] = walk;
// reuse as carry graphic if not already set
if (this->graphics.count(graphic_type::carrying) == 0) {
this->graphics[graphic_type::carrying] = walk;
}
auto attack = dm.get_unit_texture(this->unit_data.attack_graphic);
if (attack && attack->is_valid()) {
this->graphics[graphic_type::attack] = attack;
}
// extra abilities
this->type_abilities.emplace_back(std::make_shared<MoveAbility>(this->on_move));
this->type_abilities.emplace_back(std::make_shared<AttackAbility>(this->on_attack));
}
bool GUIManager::handleDSActivation ( CEGUI::EventArgs const & e )
{
CEGUI::Window *tab =
static_cast<CEGUI::WindowEventArgs const &>(e).window->getParent();
CEGUI::Listbox *lb = static_cast<CEGUI::Listbox *>(tab->getChild(0));
ListboxItem *item = static_cast<ListboxItem *>(lb->getFirstSelectedItem());
if (item != NULL) {
DataManager *dm = static_cast<DataManager *>(item->getUserData());
CEGUI::Scrollbar *sb = static_cast<CEGUI::Scrollbar *>(tab->getChild(2));
std::vector<unsigned int> const & dims = dm->getDimensions();
unsigned int dim = dims[int(sb->getScrollPosition()*(dims.size()-1))];
float scrollPos = sb->getScrollPosition();
dm->activate(dim);
// Enable global scrollbar
CEGUI::WindowManager & wm = CEGUI::WindowManager::getSingleton();
sb = static_cast<CEGUI::Scrollbar *>(wm.getWindow("Sheet/DimensionSlider"));
sb->enable();
CEGUI::WindowEventArgs w(sb);
sb->fireEvent(CEGUI::Scrollbar::EventScrollPositionChanged, w);
// Set the global scrollbar to the right position.
sb->setScrollPosition(scrollPos);
CEGUI::Window *desc = wm.getWindow("Sheet/DimensionText");
desc->show();
}
// TODO handle else-error
return true;
}
void RootUI::Init()
{
CEGUI::WindowManager& wmgr = CEGUI::WindowManager::getSingleton();
Root = wmgr.loadLayoutFromFile("ui.layout");
CEGUI::System::getSingleton().getDefaultGUIContext().setRootWindow(Root);
Controller * ctrl = static_cast<Controller*>(GetManager()->Get("Controller"));
DataManager * dm = static_cast<DataManager*>(GetManager()->Get("DataManager"));
ResourceLoader * res = static_cast<ResourceLoader*>(dm->Get("Resources"));
root_settings = new RootSettings(res, Root);
top_root = new TopRoot(dm, Root);
}
void TerrainWrapper::Enable()
{
Controller * ctrl = static_cast<Controller*>(GetManager()->Get("Controller"));
DataManager * dm = static_cast<DataManager*>(GetManager()->Get("DataManager"));
Techniques * tech = static_cast<Techniques*>(dm->Get("Techniques"));
ResourceLoader * res = static_cast<ResourceLoader*>(dm->Get("Resources"));
Environment * env = static_cast<Environment*>(res->Get("Environment"));
Camera * camera = static_cast<Camera*>(ctrl->Get("Camera"));
View * view = camera->GetView();
ViewInfo * info = camera->GetInfo();
Shader::Enable();
Shader::Set("myTextureSampler", 0);
Shader::Set("myTextureSampler2", 1);
Shader::Set("myTextureSampler3", 2);
Shader::Set("shadow_map", 3);
TerrainShader::SendTextureAttributes(terra->GetTextureAttributes(), 4);
/**
Raising to power for gamma correction
*/
getLight()->SetFog(glm::pow(env->fog_color, glm::vec3(2.2)), env->fog_density);
getLight()->SetDirectionalLight(env->terrain_bright*
glm::pow(env->sun_color, glm::vec3(2.2)),
env->sun_dir,
env->terrain_ambient,
env->terrain_diffuse);
Set("LightMatrix", Math::GetBiasMatrix()*
tech->GetShadow()->GetDirectionalShadow(env, info, view));
tech->GetShadow()->GetShadowMap()->BindTexture(0, GL_TEXTURE3);
tech->GetShadow()->GetShadowMap()->ResetTextureState();
ManagePlayerCollision(ctrl, false);
}
//ゲットしたアイテムの状態をNEWに
void TreasureEffect::GetItemStatusChange(void){
DataManager *data = &DataManager::GetInstance();
if(data->m_MogllStatus.treasureStatus != -1 && data->m_MogllStatus.treasureStatus < 60){
data->m_SaveData.itemStatus[data->m_MogllStatus.treasureStatus] = DataManager::ITEM_NEW;
data->SaveData();
}
}
void ColocalizationDlg::LoadVolumes()
{
VRenderFrame* vr_frame = (VRenderFrame*)m_frame;
if (!vr_frame) return;
DataManager* mgr = vr_frame->GetDataManager();
if (!mgr) return;
m_vol_a = mgr->GetVolumeData(m_calc_a_text->GetValue());
m_vol_b = mgr->GetVolumeData(m_calc_b_text->GetValue());
}
void DataListCtrl::EndEdit(bool update)
{
if (!m_rename_text->IsShown())
return;
if (update)
{
wxString new_name = m_rename_text->GetValue();
long item = GetNextItem(-1,
wxLIST_NEXT_ALL,
wxLIST_STATE_SELECTED);
VRenderFrame* vr_frame = (VRenderFrame*)m_frame;
DataManager* mgr = vr_frame?vr_frame->GetDataManager():0;
if (item != -1 && mgr)
{
wxString name = GetText(item, 1);
if (new_name != name)
{
wxString new_name2 = new_name;
for (int i=1; mgr->CheckNames(new_name2); i++)
new_name2 = new_name+wxString::Format("_%d", i);
if (GetItemText(item) == "Volume")
{
VolumeData* vd = mgr->GetVolumeData(name);
if (vd)
vd->SetName(new_name2);
}
else if (GetItemText(item) == "Mesh")
{
MeshData* md = mgr->GetMeshData(name);
if (md)
md->SetName(new_name2);
}
else if (GetItemText(item) == "Annotations")
{
Annotations* ann = mgr->GetAnnotations(name);
if (ann)
ann->SetName(new_name2);
}
//update ui
SetText(item, 1, new_name2);
vr_frame->UpdateTree();
}
}
}
m_rename_text->Hide();
}
void TerrainWrapper::Render()
{
Controller * ctrl = static_cast<Controller*>(GetManager()->Get("Controller"));
DataManager * dm = static_cast<DataManager*>(GetManager()->Get("DataManager"));
Techniques * tech = static_cast<Techniques*>(dm->Get("Techniques"));
ResourceLoader * res = static_cast<ResourceLoader*>(dm->Get("Resources"));
Environment * env = static_cast<Environment*>(res->Get("Environment"));
Camera * camera = static_cast<Camera*>(ctrl->Get("Camera"));
View * view = camera->GetView();
ViewInfo * info = camera->GetInfo();
if (tech->GetSSAO()->OnGeometryPass())
{
tech->GetSSAO()->SetGeometryPassUniforms(view->getCamera(),
view->getViewMatrix());
}
else if (tech->GetShadow()->OnShadowPass())
{
tech->GetShadow()->UniformMVP(tech->GetShadow()->GetDirectionalShadow(env, info, view));
}
else
{
Space(glm::mat4(1.0), view);
}
terra->Render(camera->GetFrustum(), false);
}
int main(int argc, char** argv)
{
SoundTest app;
// Read config file name from command line or use default one.
const char* cfgName = "soundTest.cfg";
if(argc == 2) cfgName = argv[1];
Config* cfg = new Config(cfgName);
DataManager* dm = DataManager::getInstance();
// Add a default filesystem data source using current work dir.
dm->addSource(new FilesystemDataSource("./"));
dm->addSource(new FilesystemDataSource(OMICRON_DATA_PATH));
ServiceManager* sm = new ServiceManager();
sm->setupAndStart(cfg);
float delay = -0.01f; // Seconds to delay sending events (<= 0 disables delay)
#ifdef _DEBUG
bool printOutput = true;
#else
bool printOutput = false;
#endif
while(true)
{
sm->poll();
// Get events
int av = sm->getAvailableEvents();
if(av != 0)
{
// TODO: Instead of copying the event list, we can lock the main one.
Event evts[OMICRON_MAX_EVENTS];
sm->getEvents(evts, OMICRON_MAX_EVENTS);
for( int evtNum = 0; evtNum < av; evtNum++)
{
app.handleEvent(evts[evtNum]);
}
app.update();
//if( printOutput )
// printf("------------------------------------------------------------------------------\n");
}
}
sm->stop();
delete sm;
delete cfg;
delete dm;
return 0;
}
// DEPRECATED, gnuplot.cpp will be removed soon
int main(void)
{
DataManager dm;
std::shared_ptr<
std::set<std::shared_ptr<Track> >
> result = dm.computeTracks();
std::cout << "Tracks:" << std::endl;
for (auto t : *result)
{
std::cout << "Track: " << t->getLongitude() <<","<<t->getLatitude() << std::endl;
}
return 0;
}
bool GUIManager::handleDSSelection ( CEGUI::EventArgs const & e )
{
CEGUI::Window *tab =
static_cast<CEGUI::WindowEventArgs const &>(e).window->getParent();
CEGUI::Listbox *lb = static_cast<CEGUI::Listbox *>(tab->getChild(0));
CEGUI::Scrollbar *sb = static_cast<CEGUI::Scrollbar *>(tab->getChild(2));
DataManager *dm = static_cast<DataManager *>(
lb->getFirstSelectedItem()->getUserData());
_selectedDM = dm;
std::vector<unsigned int> const & dim = dm->getDimensions();
sb->setStepSize(1.0/float(dim.size()-1));
sb->enable();
CEGUI::WindowEventArgs w(sb);
sb->fireEvent(CEGUI::Scrollbar::EventScrollPositionChanged, w);
return true;
}
// function that reads in data from file into data maps
static bool readFromFile(DataManager<T>& data,
const std::string& dataPath) {
// declare vector for saving file names
std::vector<std::string> fileList;
try {
// get file list
getFileList(fileList, dataPath);
// count number of files
size_t noOfFiles{fileList.size()};
// loop through all files
for (size_t i{}; i < noOfFiles; ++i) {
// declare experiment object
Experiment<T> userExperiment;
// pass file name to experiment read from file function
userExperiment.readFromFile(fileList[i]);
// insert data into maps
data.insertExperiment(userExperiment);
}
}
catch (const std::invalid_argument& e) {
ErrorMsg::print(e.what());
return false;
}
return true;
}
// function that reads in data from screen into data maps
static bool readFromScreen(DataManager<T>& data) {
bool finished{false};
while (!finished) {
// declare experiment object
Experiment<T> experiment;
try {
// call read from screen function
experiment.readFromScreen();
}
catch (const std::invalid_argument& e) {
ErrorMsg::print(e.what());
return false;
}
// insert data into maps
data.insertExperiment(experiment);
ScreenMsg::print("Type <y> to add another experiment ");
ScreenMsg::print("or any other letter to finish >> ");
std::string reply{getInput<std::string>()};
// convert to uppercase letters in case user used upper case
std::transform(reply.begin(), reply.end(), reply.begin(), ::toupper);
// check reply
if (reply == "Y") {
continue;
} else {
finished = true;
break;
}
}
return true;
}
ProjectileProducer::ProjectileProducer(DataManager &dm, const gamedata::unit_projectile *pd)
:
unit_data{*pd},
tex{dm.get_unit_texture(this->unit_data.graphic_standing0)},
sh{dm.get_unit_texture(3379)}, // 3379 = general arrow shadow
destroyed{dm.get_unit_texture(this->unit_data.graphic_dying0)} {
// graphic set
this->graphics[graphic_type::standing] = this->tex;
this->graphics[graphic_type::shadow] = this->sh;
if (destroyed) {
this->graphics[graphic_type::dying] = destroyed;
}
// outline
terrain_outline = radial_outline(pd->radius_size1);
}
bool Config::load()
{
if(!myIsLoaded)
{
myCfgFile = new libconfig::Config();
bool useFile = true;
DataManager* dm = DataManager::getInstance();
DataStream* stream = NULL;
if(myCfgFilename[0] != '@')
{
stream = dm->openStream(myCfgFilename, DataStream::Read);
if(stream == NULL)
{
oferror("Config::Load - Opening file failed: %1%", %myCfgFilename);
return false;
}
bool GUIManager::handleScrollbarChanged ( CEGUI::EventArgs const & e )
{
CEGUI::Window *tab =
static_cast<CEGUI::WindowEventArgs const &>(e).window->getParent();
CEGUI::Scrollbar *scrollbar =
static_cast<CEGUI::Scrollbar *>(tab->getChild(2));
CEGUI::Listbox *lb = static_cast<CEGUI::Listbox *>(tab->getChild(0));
CEGUI::Window *desc = tab->getChild(1);
DataManager *dm = static_cast<DataManager *>(
lb->getFirstSelectedItem()->getUserData());
std::vector<unsigned int> const & dims = dm->getDimensions();
float f = static_cast<CEGUI::Scrollbar *>(scrollbar)->getScrollPosition();
unsigned int dim = dims[int(f*(dims.size()-1))];
std::ostringstream ss; ss << "Dimension: " << dim;
desc->setText(ss.str());
return true;
}
void SkyWrapper::Enable()
{
Controller * ctrl = static_cast<Controller*>(GetManager()->Get("Controller"));
DataManager * dm = static_cast<DataManager*>(GetManager()->Get("DataManager"));
ResourceLoader * res = static_cast<ResourceLoader*>(dm->Get("Resources"));
Environment * env = static_cast<Environment*>(res->Get("Environment"));
Camera * camera = static_cast<Camera*>(ctrl->Get("Camera"));
ViewInfo * info = camera->GetInfo();
View * view = camera->GetView();
glm::mat4 m_rot = Math::Rotate(0, glfwGetTime() / 150.0, 0);
glm::mat4 ModelMatrix = Math::Translation(info->getCameraPos() - info->getDirection()*info->getDistance())*
m_rot*
Math::Scale(glm::vec3(info->getRenderDistance()));
Shader::Enable();
Shader::Set("cube", 0);
Shader::Set("MVP", view->getCamera()*ModelMatrix);
Shader::Set("MV", view->getViewMatrix() * ModelMatrix);
glm::vec4 f = glm::vec4(env->fog_color, 1.0);
Shader::Set("fog_color", f);
SkyRender::Enable();
Shader::Stop();
}
//метод парсит json-строку
void DataManager::fromJsonString(QString jsonString)
{
QJsonDocument parser = QJsonDocument::fromJson(jsonString.toUtf8());
DataManager temp = fromVariant(parser.toVariant()); //QVariant - единственный более-менее удобный для работы формат,
//в который стандартные средства позполяют
//сконвертировать объекты типа QJsonDocument
setType(temp.getType());
//qDebug() << "[]: Null node " << getParent();
qDebug() << "[]: first node " << this;
switch(temp.getType())
{
case T_STRING:
{
stringValue = temp.stringValue;
break;
}
case T_INT:
{
intValue = temp.intValue;
break;
}
case T_DOUBLE:
{
doubleValue = temp.doubleValue;
break;
}
case T_BOOL:
{
boolValue = temp.boolValue;
break;
}
case T_MAP:
{
object = temp.object;
break;
}
case T_LIST:
{
array = temp.array;
break;
}
}
}
void TopicModel::loadTopicData(QString qname, int k) {
int j;
vector < double > storage;
DataManager *datamanager = new DataManager();
sleep(1);
connect(datamanager, SIGNAL(saveTick(int)), this, SIGNAL(saveTick(int)));
emit changeStatus("Saving");
/*************************************/
// Load parameters
/*************************************/
if(M != datamanager->loadDouble(qname, "M")) {
qDebug() << "Load failure: mismatched number of features.";
}
/*************************************/
// Load Theta
/*************************************/
datamanager->loadDoubleArray(qname, "Theta", "probability", storage);
if(k == 0) {
for(j=0; j < M; j++) {
Theta0[j] = storage[j];
}
} else {
for(j=0; j < M; j++) {
Theta[k-1][j] = storage[j];
}
}
emit changeStatus("Ready");
disconnect(datamanager, SIGNAL(loadTick(int)), this, SIGNAL(loadTick(int)));
delete datamanager;
}
int APIENTRY WinMain(HINSTANCE hInstance,
HINSTANCE /*hPrevInstance*/,
LPSTR /*lpCmdLine*/,
int /*nCmdShow*/)
{
appInstance = hInstance;
OleInitialize(NULL);
INITCOMMONCONTROLSEX icx;
icx.dwSize = sizeof(INITCOMMONCONTROLSEX);
icx.dwICC = ICC_DATE_CLASSES | ICC_LISTVIEW_CLASSES|ICC_WIN95_CLASSES;
InitCommonControlsEx(&icx);
resInstance = LoadLibrary(_T("TaskRes.dll"));
CryptoUtil::GetCryptoUtil();
NetInit();
DataManager * pMM = DataManager::Get();
// hAccelTable = LoadAccelerators(hInstance, (LPCTSTR)IDC_XMLTREE);
CTaskMainWnd *pAppWnd = new CTaskMainWnd(hInstance, pMM);
RECT r = {
pMM->GetConfiguration()->GetConfigurationInt(_T("mainWindowLeft"), 40),
pMM->GetConfiguration()->GetConfigurationInt(_T("mainWindowTop"), 40),
pMM->GetConfiguration()->GetConfigurationInt(_T("mainWindowRight"), 750),
pMM->GetConfiguration()->GetConfigurationInt(_T("mainWindowBottom"), 550)
};
mainAppHWND = pAppWnd->Create(NULL, r, WS_OVERLAPPEDWINDOW | WS_VISIBLE);
MSG msg;
ZeroMemory(&msg, sizeof(MSG));
// Main message loop:
while (GetMessage(&msg, NULL, 0, 0))
{
//TODO: review why translate accelerator is not being used..
// if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
// {
TranslateMessage(&msg);
DispatchMessage(&msg);
// }
}
pMM->Save(pMM->GetFileManager()->GetUserPlanFilename());
delete pAppWnd;
mainAppHWND = NULL;
NetConclude();
OleUninitialize();
return msg.wParam;
}
bool GUIManager::handleDSDeactivation ( CEGUI::EventArgs const & e )
{
CEGUI::Window *tab =
static_cast<CEGUI::WindowEventArgs const &>(e).window->getParent();
CEGUI::Listbox *lb = static_cast<CEGUI::Listbox *>(tab->getChild(0));
ListboxItem *item = static_cast<ListboxItem *>(lb->getFirstSelectedItem());
if (item != NULL) {
DataManager *dm = static_cast<DataManager *>(item->getUserData());
dm->deactivate();
// Enable global scrollbar
CEGUI::WindowManager & wm = CEGUI::WindowManager::getSingleton();
CEGUI::Scrollbar *sb = static_cast<CEGUI::Scrollbar *>(tab->getChild(2));
sb = static_cast<CEGUI::Scrollbar *>(wm.getWindow("Sheet/DimensionSlider"));
sb->disable();
CEGUI::Window *desc = wm.getWindow("Sheet/DimensionText");
desc->hide();
}
// TODO handle else-error
return true;
}
void MappingXMLParser::parse() {
QDomNodeList modules = documentElement().elementsByTagName("module");
for (int mi = 0; mi != modules.size(); mi++) {
QDomElement mE = modules.item(mi).toElement();
Q_ASSERT(mE.hasAttribute("name"));
QString moduleName = nameAttribute(modules.item(mi));
QDomNodeList classes = mE.elementsByTagName("class");
for (int ci = 0; ci != classes.size(); ci++) {
QDomElement cE = classes.item(ci).toElement();
Q_ASSERT(cE.hasAttribute("name"));
Q_ASSERT(cE.hasAttribute("table_name"));
Q_ASSERT(cE.hasAttribute("manager_class_name"));
QString qualifiedTableName = cE.attribute("table_name");
QString schemaName = qualifiedTableName.split(".")[0];
QString tableName = qualifiedTableName.split(".")[1];
QString className = nameAttribute(classes.item(ci));
QString managerClassName = cE.attribute("manager_class_name");
DataManager* manager = createManager(getApp(), moduleName,
className,
schemaName,
tableName,
managerClassName);
QDomNodeList pl = cE.elementsByTagName("property");
Schema* schema = getApp()->databaseModel()->schema(schemaName);
Q_CHECK_PTR(schema);
Table* table = schema->table(tableName);
Q_CHECK_PTR(table);
for (int i = 0; i != pl.size(); i++) {
QDomElement pe = pl.item(i).toElement();
Q_ASSERT(pe.hasAttribute("property_name"));
Q_ASSERT(pe.hasAttribute("column_name"));
TableColumn* col = table->column(pe.attribute("column_name"));
Q_CHECK_PTR(col);
qDebug() << QString("'%1' --> '%2'").arg(pe.attribute("property_name")).arg(col->pathName());
(void) new Property(manager->mapping(), pe.attribute("property_name"), col);
}
}
}
}
void TerrainWrapper::Init()
{
DataManager * dm = static_cast<DataManager*>(GetManager()->Get("DataManager"));
ResourceLoader * res = static_cast<ResourceLoader*>(dm->Get("Resources"));
terra = new Terrain();
terra->LoadChunks(res->GetTerrainFile());
terra->LoadColorFiles(res->GetColorFile(),
res->GetTFile(),
res->GetNFile(),
res->GetAFile());
dm->SetTree(terra->GetTree());
}
void MeshDrawer::Render()
{
Controller * ctrl = static_cast<Controller*>(GetManager()->Get("Controller"));
DataManager * dm = static_cast<DataManager*>(GetManager()->Get("DataManager"));
MeshShader * shader = static_cast<MeshShader*>((GetManager()->Get("Pipeline"))->Get("MeshWrapper"));
Techniques * tech = static_cast<Techniques*>(dm->Get("Techniques"));
EntityManager * entity_manager = static_cast<EntityManager*>(Get("EntityManager"));
EntityPalette * entity_palette = static_cast<EntityPalette*>(Get("EntityPalette"));
shader->SetSpecular(0.0f, 1.0f);
if (tech->GetShadow()->OnShadowPass())
{
glCullFace(GL_FRONT);
entity_manager->Enable();
entity_palette->Enable();
glCullFace(GL_BACK);
}
else
{
entity_manager->Enable();
entity_palette->Enable();
}
}
//метод добавляет к текущему узлу дерева новый узел
void DataManager::append(DataManager node, QString nName)
{
using namespace std;
switch(nodeType)
{
case T_MAP:
{
node.setName(nName);
//node.setParent(&object.first());
object.insert(nName, node);
break;
}
case T_LIST:
{
if(node.getType() == T_LIST)
{
for(int i=0; i<node.size(); i++)
{
//node.at(i).setParent(&array.first());
array.append(node.at(i));
}
}
else
{
//node.setParent(&array.first());
array.append(node);
}
break;
}
default:
{
cout << "[DataManager::append()] node " << nName.toStdString() << " data type mismatch!\n";
break;
}
}
}
Todos::iterator get_task_by_id()
{
int i;
string input;
Todos::iterator it;
DataManager* data = DataManager::instanceOf();
cout << "podaj id" << endl;
i = get_from_stdin();
if(i < 0)
{
it = data->getList().end();
cerr << "blad: nie ma takiego id" << endl;
}
else
{
it = data->find(i);
if(it == data->getList().end())
{
cerr << "blad: Zadanie o podanym id nie istnieje" << endl;
}
}
return it;
}
