void StartGameWidget::SetBodyText() { if (sectors.Empty()) return; const SectorData* sd = sectors[currentSector]; Weather* weather = Weather::Instance(); Vector2I pos = sd->CoreLoc(); Vector2F pos2 = ToWorld2F(pos); GLASSERT(weather); const float AREA = float(SECTOR_SIZE*SECTOR_SIZE); int nPorts = 0; for (int i = 0; i < 4; ++i) { if ((1 << i) & sd->ports) { nPorts++; } } int bioFlora = 0; int flowers = 0; Rectangle2I bi = sd->InnerBounds(); for (Rectangle2IIterator it(bi); !it.Done(); it.Next()) { const WorldGrid& wg = worldMap->GetWorldGrid(it.Pos().x, it.Pos().y); if (wg.Plant() >= 7) { flowers++; } else if (wg.Plant()) { bioFlora++; } } CStr<400> str; str.Format("%s\nTemperature=%d%% Rain=%d%% Land=%d%% Water=%d%% nPorts=%d\n" "bioFlora=%d%% flowers=%d%%", sd->name.c_str(), LRint(weather->Temperature(pos2.x, pos2.y) * 100.0f), LRint(weather->RainFraction(pos2.x, pos2.y) * 100.0f), LRint(100.0f*float(sd->area) / AREA), LRint(100.0f*float(AREA - sd->area) / AREA), nPorts, LRint(100.0f*float(bioFlora) / AREA), LRint(100.0f*float(flowers) / AREA)); bodyLabel.SetText(str.c_str()); str.Format("%d/%d", currentSector+1, sectors.Size()); countLabel.SetText(str.c_str()); }
int CDB::count(const char* tableName, const char* condition) { CStr sql; sql << "select count(*) from " << tableName; if(condition != NULL) sql << " where " << condition; struct Field* field = selectOneField(sql.c_str()); if(field == NULL) { UniERROR("EXEC SQL: '%s', no valid field selected ", sql.c_str()); return -1; } int count; switch(field->type) { case T_INT: count = field->value.intValue; break; case T_UINT: count = field->value.uintValue; break; case T_LONGLONG: count = field->value.longlongValue; break; case T_FLOAT: count = (int)field->value.floatValue; break; default: UniERROR("EXEC SQL: '%s' field type is %d", sql.c_str(), field->type); return -1; } return count; }
void IGUIObject::RegisterScriptHandler(const CStr& Action, const CStr& Code, CGUI* pGUI) { if(!GetGUI()) throw PSERROR_GUI_OperationNeedsGUIObject(); JSContext* cx = pGUI->GetScriptInterface()->GetContext(); JSAutoRequest rq(cx); JS::RootedValue globalVal(cx, pGUI->GetGlobalObject()); JS::RootedObject globalObj(cx, &globalVal.toObject()); const int paramCount = 1; const char* paramNames[paramCount] = { "mouse" }; // Location to report errors from CStr CodeName = GetName()+" "+Action; // Generate a unique name static int x = 0; char buf[64]; sprintf_s(buf, ARRAY_SIZE(buf), "__eventhandler%d (%s)", x++, Action.c_str()); JS::CompileOptions options(cx); options.setFileAndLine(CodeName.c_str(), 0); options.setCompileAndGo(true); JS::RootedFunction func(cx, JS_CompileFunction(cx, globalObj, buf, paramCount, paramNames, Code.c_str(), Code.length(), options)); if (!func) return; // JS will report an error message JS::RootedObject funcObj(cx, JS_GetFunctionObject(func)); SetScriptHandler(Action, funcObj); }
bool Convert(const VfsPath& daeFilename, const VfsPath& pmdFilename, CColladaManager::FileType type) { // To avoid always loading the DLL when it's usually not going to be // used (and to do the same on Linux where delay-loading won't help), // and to avoid compile-time dependencies (because it's a minor pain // to get all the right libraries to build the COLLADA DLL), we load // it dynamically when it is required, instead of using the exported // functions and binding at link-time. if (!dll.IsLoaded()) { if (!TryLoadDLL()) return false; if (!LoadSkeletonDefinitions()) { dll.Unload(); // Error should have been logged already return false; } } // Set the filename for the logger to report set_logger(ColladaLog, const_cast<void*>(static_cast<const void*>(&daeFilename))); // We need to null-terminate the buffer, so do it (possibly inefficiently) // by converting to a CStr CStr daeData; { CVFSFile daeFile; if (daeFile.Load(m_VFS, daeFilename) != PSRETURN_OK) return false; daeData = daeFile.GetAsString(); } // Do the conversion into a memory buffer // We need to check the result, as archive builder needs to know if the source dae // was sucessfully converted to .pmd/psa int result = -1; WriteBuffer writeBuffer; switch (type) { case CColladaManager::PMD: result = convert_dae_to_pmd(daeData.c_str(), ColladaOutput, &writeBuffer); break; case CColladaManager::PSA: result = convert_dae_to_psa(daeData.c_str(), ColladaOutput, &writeBuffer); break; } // don't create zero-length files (as happens in test_invalid_dae when // we deliberately pass invalid XML data) because the VFS caching // logic warns when asked to load such. if (writeBuffer.Size()) { Status ret = m_VFS->CreateFile(pmdFilename, writeBuffer.Data(), writeBuffer.Size()); ENSURE(ret == INFO::OK); } return (result == 0); }
void CmColorQua::TestColorQuantize(CStr &inImgs, CStr &outDir) { printf("Quantize images '%s' and save results to '%s'\n", inImgs.c_str(), outDir.c_str()); CmFile::MkDir(outDir); string inDir; vecS names; int imgNum = CmFile::GetNames(inImgs, names, inDir); #pragma omp parallel for for (int i = 0; i < imgNum; i++){ printf("Processing %-40s\r", names[i].c_str()); string nameNE = CmFile::GetNameNE(names[i]); Mat img = imread(inDir + names[i]); imwrite(outDir + nameNE + ".jpg", img); img.convertTo(img, CV_32FC3, 1/255.f); Mat idx, rImg3f; for (int j = 0; j < S_Q_NUM; j++){ S_Quantize(img, idx, j); S_Recover(idx, rImg3f, j); imwrite(outDir + nameNE + descr[j] + ".jpg", rImg3f * 255); S_Quantize(img, idx, j); S_Recover(idx, rImg3f, j, img); imwrite(outDir + nameNE + descr[j] + "2.jpg", rImg3f * 255); } //Mat avgColor, colorNum; //D_Quantize(img, idx, avgColor, colorNum, 256); //D_Recover(idx, rImg3f, avgColor); //imwrite(outDir + nameNE + "D_BGR.jpg", rImg3f*255); } printf("Test color quantization finished\t\t\t\n"); /* Vec3f color; Mat org(100, 200, CV_32FC3), dst(100, 200, CV_32FC3), idx; while (scanf("%f %f %f", &color[0], &color[1], &color[2])) { printf("Org: %f, %f, %f\t", color[0], color[1], color[2]); org = Scalar(color); S_Quantize(org, idx); S_Recover(idx, dst); color = dst.at<Vec3f>(0, 0); printf("Dst: %f, %f, %f\n", color[0], color[1], color[2]); cvtColor(org, org, CV_Lab2BGR); cvtColor(dst, dst, CV_Lab2BGR); imshow("Org", org); imshow("Dst", dst); waitKey(1); } //*/ }
void SFX::readIgniteRetract() { uint8_t nChannels = 0; uint32_t samples = 0; CStr<25> path; if (m_location[SFX_POWER_ON].InUse()) { filePath(&path, m_location[SFX_POWER_ON].start); readHeader(path.c_str(), &nChannels, &samples, &m_igniteTime); } if (m_location[SFX_POWER_OFF].InUse()) filePath(&path, m_location[SFX_POWER_OFF].start); readHeader(path.c_str(), &nChannels, &samples, &m_retractTime); }
void LumosGame::ItemToButton( const GameItem* item, gamui::Button* button ) { CStr<64> text; // Set the text to the proper name, if we have it. // Then an icon for what it is, and a check // mark if the object is in use. int value = item->GetValue(); const char* name = item->ProperName() ? item->ProperName() : item->Name(); if ( value ) { text.Format( "%s\n%d", name, value ); } else { text.Format( "%s\n ", name ); } button->SetText( text.c_str() ); IString decoName = item->keyValues.GetIString( "uiIcon" ); RenderAtom atom = LumosGame::CalcUIIconAtom( decoName.c_str(), true ); atom.renderState = (const void*) UIRenderer::RENDERSTATE_UI_DECO_DISABLED; RenderAtom atomD = LumosGame::CalcUIIconAtom( decoName.c_str(), false ); atomD.renderState = (const void*) UIRenderer::RENDERSTATE_UI_DECO_DISABLED; button->SetDeco( atom, atomD ); }
bool CNetClientSession::Connect(u16 port, const CStr& server) { ENSURE(!m_Host); ENSURE(!m_Server); // Create ENet host ENetHost* host = enet_host_create(NULL, 1, CHANNEL_COUNT, 0, 0); if (!host) return false; // Bind to specified host ENetAddress addr; addr.port = port; if (enet_address_set_host(&addr, server.c_str()) < 0) return false; // Initiate connection to server ENetPeer* peer = enet_host_connect(host, &addr, CHANNEL_COUNT, 0); if (!peer) return false; m_Host = host; m_Server = peer; m_Stats = new CNetStatsTable(m_Server); if (CProfileViewer::IsInitialised()) g_ProfileViewer.AddRootTable(m_Stats); return true; }
bool Compile(GLuint target, const char* targetName, GLuint program, const VfsPath& file, const CStr& code) { ogl_WarnIfError(); pglBindProgramARB(target, program); ogl_WarnIfError(); pglProgramStringARB(target, GL_PROGRAM_FORMAT_ASCII_ARB, (GLsizei)code.length(), code.c_str()); if (ogl_SquelchError(GL_INVALID_OPERATION)) { GLint errPos = 0; glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &errPos); int errLine = std::count(code.begin(), code.begin() + std::min((int)code.length(), errPos + 1), '\n') + 1; char* errStr = (char*)glGetString(GL_PROGRAM_ERROR_STRING_ARB); LOGERROR(L"Failed to compile %hs program '%ls' (line %d):\n%hs", targetName, file.string().c_str(), errLine, errStr); return false; } pglBindProgramARB(target, 0); ogl_WarnIfError(); return true; }
JSBool JSI_GUISize::toString(JSContext* cx, uint argc, jsval* vp) { UNUSED2(argc); CStr buffer; try { ScriptInterface* pScriptInterface = ScriptInterface::GetScriptInterfaceAndCBData(cx)->pScriptInterface; double val, valr; #define SIDE(side) \ pScriptInterface->GetProperty(JS_THIS_VALUE(cx, vp), #side, val); \ pScriptInterface->GetProperty(JS_THIS_VALUE(cx, vp), "r"#side, valr); \ buffer += ToPercentString(val, valr); SIDE(left); buffer += " "; SIDE(top); buffer += " "; SIDE(right); buffer += " "; SIDE(bottom); #undef SIDE } catch (PSERROR_Scripting_ConversionFailed&) { JS_SET_RVAL(cx, vp, STRING_TO_JSVAL(JS_NewStringCopyZ(cx, "<Error converting value to numbers>"))); return JS_TRUE; } JS_SET_RVAL(cx, vp, STRING_TO_JSVAL(JS_NewStringCopyZ(cx, buffer.c_str()))); return JS_TRUE; }
void MapScene::EnableButtons() { Vector2I v = data->destSector; CoreScript* cs = CoreScript::GetCore(v); CoreScript* homeCore = lumosChitBag->GetHomeCore(); if (!homeCore) { warButton.SetEnabled(false); peaceButton.SetEnabled(false); peaceButton.SetText("Peace Treaty"); return; } warButton.SetEnabled(Team::Instance()->War(cs, homeCore, false, &lumosChitBag->GetSim()->GetCachedWeb())); int peace = Team::Instance()->Peace(cs, homeCore, false, &lumosChitBag->GetSim()->GetCachedWeb()); const Wallet* wallet = homeCore->ParentChit()->GetWallet(); if (peace > 0 && wallet->HasGold(peace)) { CStr<64> str; str.Format("Peace Treaty %d Au", peace); peaceButton.SetEnabled(true); peaceButton.SetText(str.c_str()); } else { peaceButton.SetEnabled(false); peaceButton.SetText("Peace Treaty"); } }
void CmEvaluation::PrintVector(FILE *f, const vecD &v, CStr &name) { fprintf(f, "%s = [", name.c_str()); for (size_t i = 0; i < v.size(); i++) fprintf(f, "%g ", v[i]); fprintf(f, "];\n"); }
// Reads Custom Color void CGUI::Xeromyces_ReadColor(XMBElement Element, CXeromyces* pFile) { // Read the color and stor in m_PreDefinedColors XMBAttributeList attributes = Element.GetAttributes(); //IGUIObject* object = new CTooltip; CColor color; CStr name = attributes.GetNamedItem(pFile->GetAttributeID("name")); // Try parsing value CStr value (Element.GetText()); if (! value.empty()) { // Try setting color to value if (!color.ParseString(value, 255.f)) { LOGERROR(L"GUI: Unable to create custom color '%hs'. Invalid color syntax.", name.c_str()); } else { // input color m_PreDefinedColors[name] = color; } } }
PSRETURN GUI<T>::GetSettingPointer(const IGUIObject* pObject, const CStr& Setting, T*& Value) { ENSURE(pObject != NULL); std::map<CStr, SGUISetting>::const_iterator it = pObject->m_Settings.find(Setting); if (it == pObject->m_Settings.end()) { LOGWARNING("setting %s was not found on object %s", Setting.c_str(), pObject->GetPresentableName().c_str()); return PSRETURN_GUI_InvalidSetting; } if (it->second.m_pSetting == NULL) return PSRETURN_GUI_InvalidSetting; #ifndef NDEBUG CheckType<T>(pObject, Setting); #endif // Get value Value = (T*)(it->second.m_pSetting); return PSRETURN_OK; }
void GUITooltip::HideTooltip(const CStr& style, CGUI* gui) { // Ignore attempts to use tooltip "" if (style.empty()) return; IGUIObject* tooltipobj = gui->FindObjectByName("__tooltip_"+style); if (! tooltipobj) { LOGERROR(L"Cannot find tooltip named '%hs'", style.c_str()); return; } CStr usedObjectName; if (GUI<CStr>::GetSetting(tooltipobj, "use_object", usedObjectName) == PSRETURN_OK && !usedObjectName.empty()) { IGUIObject* usedobj = gui->FindObjectByName(usedObjectName); if (! usedobj) { LOGERROR(L"Cannot find object named '%hs' used by tooltip '%hs'", usedObjectName.c_str(), style.c_str()); return; } // Clear the caption usedobj->SetSetting("caption", L""); SGUIMessage msg(GUIM_SETTINGS_UPDATED, "caption"); usedobj->HandleMessage(msg); bool hideobject = true; GUI<bool>::GetSetting(tooltipobj, "hide_object", hideobject); // If hide_object was enabled, hide it if (hideobject) GUI<bool>::SetSetting(usedobj, "hidden", true); } else { GUI<bool>::SetSetting(tooltipobj, "hidden", true); } }
int EvaluateMain(int argc, char* argv[]) { int fId = atoi(argv[1]); CStr wkDir = argv[2]; CStr imgFolder = argv[3]; CStr rstFolder = argv[4]; CStr methodNam = argv[5]; vecS des; des.push_back(methodNam); if (argc == 7) { int nr = atoi(argv[6]); vecS rstDirs; for (int i = 0; i < nr; i++) { char outFile[50]; sprintf_s(outFile, "%s%d", rstFolder.c_str(), i); rstDirs.push_back(std::string(outFile)); } CmEvaluation::EvalueMaskProposals(wkDir, imgFolder, rstDirs, des, wkDir + "\\Results.m"); } else { switch (fId) { case 0: CmEvaluation::EvalueMask(wkDir + imgFolder + "\\*.png", wkDir + "\\" + rstFolder + "\\", des, wkDir + "\\Results.m"); break; case 1: CmEvaluation::DebugEvalueMask(wkDir, imgFolder, rstFolder, des, wkDir + "CutRes.m"); break; case 2: CmEvaluation::EvalueMaskProposals(wkDir, imgFolder, rstFolder, des, wkDir + "CutRes.m"); break; case 3: ChooseWeight(); break; default: break; } } //des.push_back("HC"); //des.push_back("RC"); //des.push_back("SF"); des.push_back("SalPIF"); //CmEvaluation::EvalueMask(wkDir + imgFolder + "\\*.png", wkDir + "\\" + rstFolder+"\\", des, wkDir + "\\Results.m"); //CmEvaluation::EvalueMaskProposals(wkDir, imgFolder, rstFolder, des, wkDir + "CutRes.m"); //CmEvaluation::DebugEvalueMask(wkDir, imgFolder, rstFolder, des, wkDir + "CutRes.m"); return 1; }
void Surface::Load( const gamedb::Item* node ) { GLASSERT( node->GetBool( "isImage" ) == true ); if ( !node->GetBool( "isImage" ) ) return; name = node->Name(); CStr<16> formatBuf = node->GetString( "format" ); format = QueryFormat( formatBuf.c_str() ); w = node->GetInt( "width" ); h = node->GetInt( "height" ); Set( Surface::QueryFormat( formatBuf.c_str() ), w, h ); int size = node->GetDataSize( "pixels" ); GLASSERT( size == BytesInImage() ); node->GetData( "pixels", Pixels(), size ); }
InReaction IGUIObject::SendEvent(EGUIMessageType type, const CStr& EventName) { PROFILE2_EVENT("gui event"); PROFILE2_ATTR("type: %s", EventName.c_str()); PROFILE2_ATTR("object: %s", m_Name.c_str()); SGUIMessage msg(type); HandleMessage(msg); ScriptEvent(EventName); return (msg.skipped ? IN_PASS : IN_HANDLED); }
const GameItem* PlantScript::PlantDef(int plant0Based) { GLASSERT(plant0Based >= 0 && plant0Based < NUM_EXTENDED_PLANT_TYPES); if (plantDef[0] == 0) { for (int i = 0; i < NUM_EXTENDED_PLANT_TYPES; ++i) { CStr<32> str; str.Format("plant%d", i); plantDef[i] = &ItemDefDB::Instance()->Get(str.c_str()); } } GLASSERT(plantDef[plant0Based]); return plantDef[plant0Based]; }
static int GetTooltipDelay(CStr& style, CGUI* gui) { int delay = 500; // default value (in msec) IGUIObject* tooltipobj = gui->FindObjectByName("__tooltip_"+style); if (! tooltipobj) { LOGERROR(L"Cannot find tooltip object named '%hs'", style.c_str()); return delay; } GUI<int>::GetSetting(tooltipobj, "delay", delay); return delay; }
const char* Game::GamePath( const char* type, int slot, const char* extension ) const { CStr<256> str; //str = "save/"; str += type; if ( slot > 0 ) { str += "-"; str += '0' + slot; } str += "."; str += extension; return StringPool::Intern( str.c_str() ).c_str(); }
//------------------------------------------------------------------------------ /// \brief //------------------------------------------------------------------------------ void NativeExpMf6Nam::WriteChdFile () { MfGlobal *g = m_pack->GetGlobal(); if (!g) return; Mf2kNative* n = m_pack->GetNative(); if (!n) return; CStr baseName = n->FileName(); util::StripExtensionFromFilename(baseName, baseName); baseName += ".chd"; std::vector<CStr> fieldStrings; int MAXBOUND(0); CStr chdStr = MfExportUtil::Mf6IboundToChd(g, MAXBOUND, fieldStrings); std::vector<CStr> lines; lines.push_back(MfExportUtil::GetMf6CommentHeader()); lines.push_back("BEGIN OPTIONS"); int saveFlows(0); if (g->GetIntVar("MF6_SAVE_FLOWS", saveFlows) && saveFlows) { lines.push_back(" SAVE_FLOWS"); } lines.push_back("END OPTIONS"); lines.push_back(""); lines.push_back("BEGIN DIMENSIONS"); CStr dimStr; dimStr.Format(" MAXBOUND %d", MAXBOUND); lines.push_back(dimStr); lines.push_back("END DIMENSIONS"); lines.push_back(""); lines.push_back("BEGIN PERIOD 1"); lines.push_back(chdStr); lines.push_back("END PERIOD 1"); FILE *fp = fopen(baseName.c_str(), "w"); if (fp) { for (size_t i=0; i<lines.size(); ++i) { fprintf(fp, "%s\n", lines[i].c_str()); } fclose(fp); } } // NativeExpMf6Nam::WriteChdFile
CTerrainPropertiesPtr CTerrainProperties::FromXML(const CTerrainPropertiesPtr& parent, const VfsPath& pathname) { CXeromyces XeroFile; if (XeroFile.Load(g_VFS, pathname) != PSRETURN_OK) return CTerrainPropertiesPtr(); XMBElement root = XeroFile.GetRoot(); CStr rootName = XeroFile.GetElementString(root.GetNodeName()); // Check that we've got the right kind of xml document if (rootName != "Terrains") { LOGERROR( L"TerrainProperties: Loading %ls: Root node is not terrains (found \"%hs\")", pathname.string().c_str(), rootName.c_str()); return CTerrainPropertiesPtr(); } #define ELMT(x) int el_##x = XeroFile.GetElementID(#x) ELMT(terrain); #undef ELMT // Ignore all non-terrain nodes, loading the first terrain node and // returning it. // Really, we only expect there to be one child and it to be of the right // type, though. XERO_ITER_EL(root, child) { if (child.GetNodeName() == el_terrain) { CTerrainPropertiesPtr ret (new CTerrainProperties(parent)); ret->LoadXml(child, &XeroFile, pathname); return ret; } else { LOGWARNING( L"TerrainProperties: Loading %ls: Unexpected node %hs\n", pathname.string().c_str(), XeroFile.GetElementString(child.GetNodeName()).c_str()); // Keep reading - typos shouldn't be showstoppers } } return CTerrainPropertiesPtr(); }
//------------------------------------------------------------------------------ /// \brief //------------------------------------------------------------------------------ bool NativeExpMf6Nam::ValidPackage (const CStr& a_ftype) { const int NUMTYPES = 21; std::string types[NUMTYPES] = { "DIS", "DISV", "DISU", "IC", "OC", "NPF", "HFB", "STO", "CHD", "WEL", "DRN", "RIV", "GHB", "RCH", "EVT", "MAW", "SFR", "LAK", "UZF", "MVR", "GNC" }; std::set<std::string> setTypes(&types[0], &types[NUMTYPES]); if (setTypes.find(a_ftype) != setTypes.end()) { return true; } CStr msg; msg.Format("WARNING: Package %s is not supported for conversion to MF6.", a_ftype); printf("%s\n", msg.c_str()); return false; } // NativeExpMf6Nam::ValidPackage
PSRETURN GUI<T>::SetSetting(IGUIObject *pObject, const CStr& Setting, const T &Value, const bool& SkipMessage) { ENSURE(pObject != NULL); if (!pObject->SettingExists(Setting)) { LOGWARNING(L"setting %hs was not found on object %hs", Setting.c_str(), pObject->GetPresentableName().c_str()); return PSRETURN_GUI_InvalidSetting; } #ifndef NDEBUG CheckType<T>(pObject, Setting); #endif // Set value *(T*)pObject->m_Settings[Setting].m_pSetting = Value; // // Some settings needs special attention at change // // If setting was "size", we need to re-cache itself and all children if (Setting == "size") { RecurseObject(0, pObject, &IGUIObject::UpdateCachedSize); } else if (Setting == "hidden") { // Hiding an object requires us to reset it and all children if (IsBoolTrue(Value)) QueryResetting(pObject); } if (!SkipMessage) { SGUIMessage msg(GUIM_SETTINGS_UPDATED, Setting); HandleMessage(pObject, msg); } return PSRETURN_OK; }
Chit* LumosChitBag::NewLawnOrnament(const Vector2I& pos, const char* name, int team) { const ChitContext* context = Context(); Chit* chit = NewChit(); GameItem* rootItem = ItemDefDB::Instance()->Get(name).Clone(); // Hack...how to do this better?? if (rootItem->IResourceName() == "ruins1.0") { CStr<32> str; str.Format("ruins1.%d", random.Rand(2)); rootItem->SetResource(str.c_str()); } int size = 1; rootItem->keyValues.Get(ISC::size, &size); MapSpatialComponent* msc = new MapSpatialComponent(); msc->SetBuilding(size, false, 0); msc->SetBlocks((rootItem->flags & GameItem::PATH_NON_BLOCKING) ? false : true); chit->Add(msc); MapSpatialComponent::SetMapPosition(chit, pos.x, pos.y); chit->Add(new RenderComponent(rootItem->ResourceName())); chit->Add(new HealthComponent()); AddItem(rootItem, chit, context->engine, team, 0); IString proc = rootItem->keyValues.GetIString("procedural"); if (!proc.empty()) { ProcRenderInfo info; AssignProcedural(chit->GetItem(), &info); chit->GetRenderComponent()->SetProcedural(0, info); } context->engine->particleSystem->EmitPD(ISC::constructiondone, ToWorld3F(pos), V3F_UP, 0); if (XenoAudio::Instance()) { Vector3F pos3 = ToWorld3F(pos); XenoAudio::Instance()->PlayVariation(ISC::rezWAV, random.Rand(), &pos3); } return chit; }
void IGUIObject::ScriptEvent(const CStr& Action, JS::HandleValue Argument) { auto it = m_ScriptHandlers.find(Action); if (it == m_ScriptHandlers.end()) return; JSContext* cx = m_pGUI->GetScriptInterface()->GetContext(); JSAutoRequest rq(cx); JS::AutoValueVector paramData(cx); paramData.append(Argument.get()); JS::RootedObject obj(cx, GetJSObject()); JS::RootedValue handlerVal(cx, JS::ObjectValue(*it->second)); JS::RootedValue result(cx); bool ok = JS_CallFunctionValue(cx, obj, handlerVal, paramData, &result); if (!ok) { JS_ReportError(cx, "Errors executing script action \"%s\"", Action.c_str()); } }
const ModelResource* PlantScript::PlantRes(int plant0Based, int stage) { GLASSERT(plant0Based >= 0 && plant0Based < NUM_EXTENDED_PLANT_TYPES); GLASSERT(stage >= 0 && stage < MAX_PLANT_STAGES); if (plantResource[0][0] == 0) { for (int i = 0; i < NUM_EXTENDED_PLANT_TYPES; ++i) { const int nStage = PlantIsFlower(i) ? PLANT_BLOCKING_STAGE : MAX_PLANT_STAGES; for (int j = 0; j < nStage; ++j) { CStr<32> str; str.Format("plant%d.%d", i, j); plantResource[i][j] = ModelResourceManager::Instance()->GetModelResource(str.c_str(), false); GLASSERT(plantResource[i][j]); } } } GLASSERT(plantResource[plant0Based][stage]); return plantResource[plant0Based][stage]; }
void CGUI::Xeromyces_ReadColor(XMBElement Element, CXeromyces* pFile) { XMBAttributeList attributes = Element.GetAttributes(); CColor color; CStr name = attributes.GetNamedItem(pFile->GetAttributeID("name")); // Try parsing value CStr value(Element.GetText()); if (value.empty()) return; // Try setting color to value if (!color.ParseString(value)) { LOGERROR("GUI: Unable to create custom color '%s'. Invalid color syntax.", name.c_str()); return; } m_PreDefinedColors[name] = color; }
bool Compile(GLhandleARB shader, const VfsPath& file, const CStr& code) { TIMER_ACCRUE(tc_ShaderGLSLCompile); ogl_WarnIfError(); const char* code_string = code.c_str(); GLint code_length = code.length(); pglShaderSourceARB(shader, 1, &code_string, &code_length); pglCompileShaderARB(shader); GLint ok = 0; pglGetShaderiv(shader, GL_COMPILE_STATUS, &ok); GLint length = 0; pglGetShaderiv(shader, GL_INFO_LOG_LENGTH, &length); // Apparently sometimes GL_INFO_LOG_LENGTH is incorrectly reported as 0 // (http://code.google.com/p/android/issues/detail?id=9953) if (!ok && length == 0) length = 4096; if (length > 1) { char* infolog = new char[length]; pglGetShaderInfoLog(shader, length, NULL, infolog); if (ok) LOGMESSAGE(L"Info when compiling shader '%ls':\n%hs", file.string().c_str(), infolog); else LOGERROR(L"Failed to compile shader '%ls':\n%hs", file.string().c_str(), infolog); delete[] infolog; } ogl_WarnIfError(); return (ok ? true : false); }