//--------------------------------------------------------------------- int MilkshapePlugin::Execute (msModel* pModel) { // Do nothing if no model selected if (!pModel) return -1; Ogre::LogManager logMgr; logMgr.createLog("msOgreExporter.log", true); logMgr.logMessage("OGRE Milkshape Exporter Log"); logMgr.logMessage("---------------------------"); Ogre::ResourceGroupManager resGrpMgr; // // check, if we have something to export // if (msModel_GetMeshCount (pModel) == 0) { ::MessageBox (NULL, "The model is empty! Nothing exported!", "OGRE Export", MB_OK | MB_ICONWARNING); return 0; } if (!showOptions()) return 0; if (exportMesh) { doExportMesh(pModel); } return 0; }
void SoundFX::loadImpl() { Ogre::LogManager* pLogManager = Ogre::LogManager::getSingletonPtr(); // Ruta al archivo. Ogre::FileInfoListPtr info; info = Ogre::ResourceGroupManager::getSingleton().findResourceFileInfo(mGroup, mName); for (Ogre::FileInfoList::iterator i = info->begin(); i != info->end(); ++i) { _path = i->archive->getName() + "/" + i->filename; } // Archivo no encontrado... if (_path == "") { pLogManager->logMessage("SoundFX::loadImpl() Imposible encontrar el recurso."); throw (Ogre::Exception(Ogre::Exception::ERR_FILE_NOT_FOUND, "Imposible encontrar el recurso", "SoundFX::loadImpl()")); } // Cargar el efecto de sonido. if ((_pSound = Mix_LoadWAV(_path.c_str())) == NULL) { pLogManager->logMessage("SoundFX::loadImpl() Imposible cargar el efecto."); throw (Ogre::Exception(Ogre::Exception::ERR_INTERNAL_ERROR, "Imposible cargar el efecto", "SoundFX::loadImpl()")); } // Cálculo del tamaño del recurso de sonido. std::ifstream stream; char byteBuffer; stream.open(_path.c_str(), std::ios_base::binary); while (stream >> byteBuffer) { ++_size; } stream.close(); }
//------------------------------------------------------------------------------------- bool BaseApplication::setup(void) { Ogre::LogManager * lm = new Ogre::LogManager(); lm->createLog("Ogre.log", true, false, false); mRoot = new Ogre::Root(mPluginsCfg); setupResources(); bool carryOn = configure(); if (!carryOn) return false; chooseSceneManager(); createCamera(); createViewports(); // Set default mipmap level (NB some APIs ignore this) Ogre::TextureManager::getSingleton().setDefaultNumMipmaps(5); // Create any resource listeners (for loading screens) createResourceListener(); // Load resources loadResources(); // Create the scene createScene(); createFrameListener(); return true; };
void wxOgre::cameraTrackNode(Ogre::SceneNode* target) { static const wxString camCalcPosCaption(wxT("CalcCamPos:X:%08.4f, Y:%08.4f, Z:%08.4f")); static const wxString camRealPosCaption(wxT("CalcCamPos:X:%08.4f, Y:%08.4f, Z:%08.4f")); // TODO: Position camera somwehere sensible relative to object if (target) { Ogre::LogManager* logMgr = Ogre::LogManager::getSingletonPtr(); Ogre::Log* log(logMgr->getDefaultLog()); mTarget = target; Ogre::Vector3 size( target->getAttachedObject(0)->getBoundingBox().getSize() ); Ogre::Vector3 camPos(target->getPosition() + size * 1.2f); setZoomScale(size.length() / 30.0f); mCameraNode->setPosition(camPos); mCamera->lookAt(target->getPosition()); mDebugPanelOverlay->show(); wxString msg(wxString::Format(camCalcPosCaption, camPos.x, camPos.y, camPos.x)); log->logMessage(Ogre::String(msg.mb_str(wxConvUTF8))); Ogre::Vector3 camRealPos(mCamera->getRealPosition()); msg = wxString(wxString::Format(camCalcPosCaption, camRealPos.x, camRealPos.y, camRealPos.x)); log->logMessage(Ogre::String(msg.mb_str(wxConvUTF8))); } else { mTarget = NULL; } }
// Fachada de MixFadeOutMusic() void Track::fadeOut (int ms) { Ogre::LogManager* pLogManager = Ogre::LogManager::getSingletonPtr(); if (Mix_FadeOutMusic(ms) == -1) { pLogManager->logMessage("Track::fadeIn() Error al aplicar efecto de sonido."); throw (Ogre::Exception(Ogre::Exception::ERR_INTERNAL_ERROR, "Imposible aplicar suavizado de sonido", "Track::fadeIn()")); } }
/******************************************************************************************************** * Method to write data to OGRE format * ********************************************************************************************************/ MStatus OgreExporter::writeOgreData() { // Create singletons Ogre::LogManager logMgr; Ogre::ResourceGroupManager rgm; Ogre::MeshManager meshMgr; Ogre::SkeletonManager skelMgr; Ogre::MaterialManager matMgr; Ogre::DefaultHardwareBufferManager hardwareBufMgr; // Create a log logMgr.createLog("ogreMayaExporter.log", true); // Write mesh binary if (m_params.exportMesh) { std::cout << "Writing mesh binary...\n"; std::cout.flush(); stat = m_pMesh->writeOgreBinary(m_params); if (stat != MS::kSuccess) { std::cout << "Error writing mesh binary file\n"; std::cout.flush(); } } // Write skeleton binary if (m_params.exportSkeleton) { if (m_pMesh->getSkeleton()) { std::cout << "Writing skeleton binary...\n"; std::cout.flush(); stat = m_pMesh->getSkeleton()->writeOgreBinary(m_params); if (stat != MS::kSuccess) { std::cout << "Error writing mesh binary file\n"; std::cout.flush(); } } } // Write materials data if (m_params.exportMaterial) { std::cout << "Writing materials data...\n"; std::cout.flush(); stat = m_pMaterialSet->writeOgreScript(m_params); if (stat != MS::kSuccess) { std::cout << "Error writing materials file\n"; std::cout.flush(); } } return MS::kSuccess; }
ClientLog::ClientLog () : ::Log ("screamers.log"), Ogre::LogListener () { Ogre::LogManager *manager; if (Ogre::LogManager::getSingletonPtr () == NULL) manager = new Ogre::LogManager (); else manager = Ogre::LogManager::getSingletonPtr (); manager->addListener (this); manager->setLogDetail (Ogre::LL_BOREME); }
/** Setup a minimal ogre renderer * * \param custom_log Should we create a custom log * \param base_dir The path to the config and data files * (plugins.cfg and ogre.cfg * * \warning Incorrect base_dir could lead to a 'memory access violation' when * launched. * * \note The \c custom_log parameter is used to avoid an Ogre3D assertion * that occurs when creating our custom log. * */ void OgreMinimalSetup::setupOgre(const Ogre::String& base_dir, bool custom_log) { Ogre::Root *root; // The Ogre root singleton mListener = new SilentLogListener(); string dir= base_dir + "config/"; if (!dirExists(dir)){ throw "config directory '" + dir + "' does not exist."; } try{ if (custom_log == true) { Ogre::LogManager* logger = new Ogre::LogManager(); assert(logger && "Failed to create an Ogre Logger"); logger->createLog("log.log", true, false, true); Ogre::LogManager::getSingleton().getDefaultLog() ->addListener(mListener); } } catch(Ogre::Exception e){ cout << "setupOgre failed to initialize LogManager: "<< e.what() << endl; exit(1); } try { root = new Ogre::Root(dir + "plugins-unittests.cfg", dir + "ogre.cfg", dir + "ogre.log"); } catch(Ogre::Exception e){ cout << "setupOgre failed to initialize Ogre::Root : "<< e.what() << endl; exit(1); } assert(root && "Cannot initialize Ogre::Root"); assert(Ogre::Root::getSingletonPtr() && "Cannot initialize Ogre::Root"); // Select rendersystem Ogre::RenderSystemList list=Ogre::Root::getSingleton().getAvailableRenderers(); this->debugRenderList( list ); Ogre::Root::getSingleton().setRenderSystem(list[0]); Ogre::Root::getSingleton().initialise(false, "RainbruRPG blah"); Ogre::Root::getSingleton().addResourceLocation(base_dir + "data/", "FileSystem"); Ogre::Root::getSingleton().addResourceLocation(base_dir + "data/gui/fonts", "FileSystem"); mRenderWindow = Ogre::Root::getSingleton().getRenderSystem() ->_createRenderWindow(RW_NAME, 20, 20, false); Ogre::TextureManager::getSingleton().setDefaultNumMipmaps(5); }
int SoundFX::play(int loop) { int channel; Ogre::LogManager* pLogManager = Ogre::LogManager::getSingletonPtr(); // Si el primer parámetro es un -1, maneja nuevos canales para efectos simultáneos if ((channel = Mix_PlayChannel(1, _pSound, loop)) == -1) { pLogManager->logMessage("SoundFX::play() Imposible reproducir el efecto de sonido."); throw (Ogre::Exception(Ogre::Exception::ERR_INTERNAL_ERROR, "Imposible reproducir el efecto de sonido", "SoundFX::play()")); } return channel; }
bool OgreApplication::initStart(void) { mPluginsCfg = "../configs/plugins.cfg"; mResourcesCfg = "../configs/resources.cfg"; Ogre::LogManager * lm = new Ogre::LogManager(); lm->createLog("OgreLogfile.log", true, false, false); // construct Ogre::Root mRoot = new Ogre::Root(mPluginsCfg, "", ""); Ogre::ConfigFile cf; cf.load(mResourcesCfg); // Go through all sections & settings in the file Ogre::ConfigFile::SectionIterator seci = cf.getSectionIterator(); Ogre::String secName, typeName, archName; while (seci.hasMoreElements()) { secName = seci.peekNextKey(); Ogre::ConfigFile::SettingsMultiMap *settings = seci.getNext(); Ogre::ConfigFile::SettingsMultiMap::iterator i; for (i = settings->begin(); i != settings->end(); ++i) { typeName = i->first; archName = i->second; Ogre::ResourceGroupManager::getSingleton().addResourceLocation( archName, typeName, secName); } } Ogre::ResourceGroupManager::getSingleton().addResourceLocation("../assets/", "FileSystem"); Ogre::ResourceGroupManager::getSingleton().addResourceLocation("../assets/particles", "FileSystem"); // Do not add this to the application Ogre::RenderSystem *rs = mRoot->getRenderSystemByName("OpenGL Rendering Subsystem"); mRoot->setRenderSystem(rs); rs->setConfigOption("Full Screen", "No"); rs->setConfigOption("Video Mode", "800 x 600 @ 32-bit colour"); rs->setStencilCheckEnabled(true); mRoot->initialise(false); running = true; return true; }
void Track::play(int loop) { Ogre::LogManager* pLogManager = Ogre::LogManager::getSingletonPtr(); // Estaba pausada? if(Mix_PausedMusic()) { Mix_ResumeMusic(); // Reanudación. } // Si no, se reproduce desde el principio. else { if (Mix_PlayMusic(_pTrack, loop) == -1) { pLogManager->logMessage("Track::play() Error al reproducir el recurso de sonido."); throw (Ogre::Exception(Ogre::Exception::ERR_FILE_NOT_FOUND, "Imposible reproducir el recurso de sonido", "Track::play()")); } } }
void Client::StartupOgre() { Ogre::LogManager* logMgr = OGRE_NEW Ogre::LogManager; logMgr->createLog("DefaultLog", true, false, false); mOgreRoot = new Ogre::Root("../data/config/plugins.cfg"); // setup resources // Load resource paths from config file Ogre::ConfigFile cf; cf.load("../data/config/resources.cfg"); // Go through all sections & settings in the file Ogre::ConfigFile::SectionIterator seci = cf.getSectionIterator(); Ogre::String secName, typeName, archName; while(seci.hasMoreElements()) { secName = seci.peekNextKey(); Ogre::ConfigFile::SettingsMultiMap *settings = seci.getNext(); Ogre::ConfigFile::SettingsMultiMap::iterator i; for(i = settings->begin(); i != settings->end(); ++i) { typeName = i->first; archName = i->second; Ogre::ResourceGroupManager::getSingleton().addResourceLocation( archName, typeName, secName); } } // configure // Show the configuration dialog and initialise the system if(!(mOgreRoot->restoreConfig() || mOgreRoot->showConfigDialog())) { exit(0); } mWindow = mOgreRoot->initialise(true, "Client Window"); // Set default mipmap level (NB some APIs ignore this) Ogre::TextureManager::getSingleton().setDefaultNumMipmaps(5); // initialise all resource groups // Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups(); Ogre::ResourceGroupManager::getSingleton().initialiseResourceGroup("Basics"); Ogre::ResourceGroupManager::getSingleton().initialiseResourceGroup("GUI"); InitializeWindow(); // ogre loaded }
void Entresol::SetupLogging(const String& LogFileName) { /// @todo Allow the FrameScheduler Log target to be inspected and changed here Ogre::LogManager* OgreLogs = Ogre::LogManager::getSingletonPtr(); if( NULL == OgreLogs ) { OgreLogs = new Ogre::LogManager(); } if(!LogFileName.empty()) { OgreLogs->createLog(String("Graphics")+LogFileName,true,true); } else { OgreLogs->createLog("GraphicsMezzanine.log",true,true); } this->Aggregator = new Threading::LogAggregator(); Aggregator->SetAggregationTarget(&WorkScheduler); this->WorkScheduler.AddWorkUnitMain(Aggregator, "LogAggregator"); }
bool initOgreRoot(){ try{ // Create logs that funnel to android logs Ogre::LogManager *lm = OGRE_NEW Ogre::LogManager(); Ogre::Log *l = lm->createLog("AndroidLog", true, true, true); g_ll = OGRE_NEW AndroidLogListener(); l->addListener(g_ll); // Create a root object g_root = OGRE_NEW Ogre::Root("", "", ""); // Register the ES2 plugin g_gles2Plugin = OGRE_NEW Ogre::GLES2Plugin(); Ogre::Root::getSingleton().installPlugin(g_gles2Plugin); // Register particle plugin g_pfxPlugin = OGRE_NEW Ogre::ParticleFXPlugin(); Ogre::Root::getSingleton().installPlugin(g_pfxPlugin); // Grab the available render systems const Ogre::RenderSystemList &renderSystemList = g_root->getAvailableRenderers(); if(renderSystemList.empty()) { return false; } // Set the render system and init Ogre::RenderSystem *system = renderSystemList.front(); g_root->setRenderSystem(system); g_root->initialise(false); g_lastTime = g_timer.getMilliseconds(); return true; }catch(Ogre::Exception &e){ } return false; }
// Carga del recurso. void Track::loadImpl() { Ogre::LogManager* pLogManager = Ogre::LogManager::getSingletonPtr(); // Ruta al archivo. Ogre::FileInfoListPtr info; info = Ogre::ResourceGroupManager::getSingleton().findResourceFileInfo(mGroup, mName); for (Ogre::FileInfoList::const_iterator i = info->begin(); i != info->end(); ++i) { _path = i->archive->getName() + "/" + i->filename; } // Archivo no encontrado... if (_path == "") { pLogManager->logMessage("Track::loadImpl() Imposible cargar el recurso de sonido."); throw (Ogre::Exception(Ogre::Exception::ERR_FILE_NOT_FOUND, "Archivo no encontrado", "Track::loadImpl()")); } cout << "\n\nPath: " << _path << "\n\n" << endl; // Cargar el recurso de sonido. if ((_pTrack = Mix_LoadMUS(_path.c_str())) == NULL) { pLogManager->logMessage("Track::loadI() Imposible cargar el recurso de sonido."); throw (Ogre::Exception(Ogre::Exception::ERR_FILE_NOT_FOUND, "Archivo no encontrado", "Track::loadI()")); } // Cálculo del tamaño del recurso de sonido. std::ifstream stream; char byteBuffer; stream.open(_path.c_str(), std::ios_base::binary); while (stream >> byteBuffer) { _size++; } stream.close(); }
void OgreExporter_c::ExportLevel(const WadLevel_c &level, const WadFile_c &file) { this->ExportLevelMaterials(level, file); Ogre::DefaultHardwareBufferManager hardwareBufferManager; Ogre::ManualObject manualMesh(level.GetName()); const LineDef_s *lineDefs = level.GetLineDefs(); const size_t numLineDefs = level.GetNumLineDefs(); const SideDef_s *sideDefs = level.GetSideDefs(); const Sector_s *sectors = level.GetSectors(); const Vertex_s *vertices = level.GetVertices(); for(size_t i = 0;i < numLineDefs; ++i) { if(lineDefs[i].iLeftSideDef >= 0) { const SideDef_s &leftSide = sideDefs[lineDefs[i].iLeftSideDef]; const Sector_s &leftSideSector = sectors[leftSide.iSector]; const SideDef_s &rightSide = sideDefs[lineDefs[i].iRightSideDef]; const Sector_s &rightSideSector = sectors[rightSide.iSector]; if(leftSide.uMiddleTexture.uName != '-') { this->ExportWallMesh(manualMesh, leftSideSector.iFloorHeight, leftSideSector.iCeilHeight, leftSide.uMiddleTexture, leftSide.iOffsetX, leftSide.iOffsety, vertices, lineDefs[i], file); } if(leftSide.uLowerTexture.uName != '-') { this->ExportWallMesh(manualMesh, leftSideSector.iFloorHeight, leftSideSector.iFloorHeight, leftSide.uLowerTexture, leftSide.iOffsetX, leftSide.iOffsety, vertices, lineDefs[i], file); } if(leftSide.uUpperTexture.uName != '-') { this->ExportWallMesh(manualMesh, rightSideSector.iCeilHeight, leftSideSector.iCeilHeight, leftSide.uUpperTexture, leftSide.iOffsetX, leftSide.iOffsety, vertices, lineDefs[i], file); } } if(lineDefs[i].iRightSideDef >= 0) { const SideDef_s &rightSide = sideDefs[lineDefs[i].iRightSideDef]; const Sector_s &rightSideSector = sectors[rightSide.iSector]; if(rightSide.uLowerTexture.uName != '-') { const SideDef_s &leftSide = sideDefs[lineDefs[i].iLeftSideDef]; const Sector_s &leftSideSector = sectors[leftSide.iSector]; this->ExportWallMesh(manualMesh, rightSideSector.iFloorHeight, leftSideSector.iFloorHeight, rightSide.uLowerTexture, rightSide.iOffsetX, rightSide.iOffsety, vertices, lineDefs[i], file); } if(rightSide.uMiddleTexture.uName != '-') { this->ExportWallMesh(manualMesh, rightSideSector.iFloorHeight, rightSideSector.iCeilHeight, rightSide.uMiddleTexture, rightSide.iOffsetX, rightSide.iOffsety, vertices, lineDefs[i], file); } if(rightSide.uUpperTexture.uName != '-') { const SideDef_s &leftSide = sideDefs[lineDefs[i].iLeftSideDef]; const Sector_s &leftSideSector = sectors[leftSide.iSector]; this->ExportWallMesh(manualMesh, leftSideSector.iCeilHeight, rightSideSector.iCeilHeight, rightSide.uUpperTexture, rightSide.iOffsetX, rightSide.iOffsety, vertices, lineDefs[i], file); } } } namespace fs = boost::filesystem; fs::path path(strLevelDirectory); std::string levelName = level.GetName(); levelName += ".mesh"; path /= levelName; Ogre::LogManager logManager; logManager.createLog("ogre.log", true, true, false); Ogre::ResourceGroupManager resourceGroupManager; Ogre::MeshManager meshManager; Ogre::LodStrategyManager logStrategyManager; Ogre::MeshPtr mesh = manualMesh.convertToMesh(level.GetName()); Ogre::MeshSerializer serializer; serializer.exportMesh(mesh.get(), path.string()); mesh.setNull(); resourceGroupManager.shutdownAll(); this->CreateResourcesCfg(); }
void wxOgre::OnMouseMotion(wxMouseEvent& event) { static float speed = 0.0f; static bool dragStart = true; static const wxString posInfo(wxT("Pos:X:%03d, Y:%03d Change X:%03d Y:%03d")); static Ogre::Quaternion startRot(Ogre::Quaternion::IDENTITY); Ogre::LogManager* logMgr = Ogre::LogManager::getSingletonPtr(); Ogre::Log* log(logMgr->getDefaultLog()); int left, top, width, height; mCamera->getViewport()->getActualDimensions(left, top, width, height); wxPoint pos = event.GetPosition(); wxPoint change = pos - mPrevPos; Ogre::Vector2 changeNorm((Ogre::Real) change.x / (Ogre::Real) width, (Ogre::Real) -change.y / (Ogre::Real) height); if ((!dragStart) && ((!event.Dragging()) || (!event.LeftIsDown()))) { wxString msg(wxT("Drag End")); log->logMessage(Ogre::String(msg.mb_str(wxConvUTF8))); dragStart = true; } if(event.Dragging()) { if (event.LeftIsDown()) { if (mTarget) { Ogre::Vector3 objectCentre(mTarget == NULL ? Ogre::Vector3::ZERO : mTarget->getPosition()); if (dragStart) { Ogre::Vector3 cam2Object(mCameraNode->getPosition() - objectCentre); mDirection = cam2Object.normalisedCopy(); mRadius = cam2Object.length(); mChangePos = Ogre::Vector2::ZERO; dragStart = false; wxString msg(wxT("Drag Start")); log->logMessage(Ogre::String(msg.mb_str(wxConvUTF8))); } else { Ogre::Vector3 across; Ogre::Vector3 up; Ogre::Vector3 forward; mCamera->getRealOrientation().ToAxes(across, up, forward); mChangePos += changeNorm; Ogre::Quaternion roty(Ogre::Radian(mChangePos.y * Ogre::Math::PI / 12.0f), across); Ogre::Quaternion rotx(Ogre::Radian(mChangePos.x * Ogre::Math::PI / 12.0f), up); Ogre::Quaternion rot(roty * rotx); rot.normalise(); mCameraNode->setPosition(objectCentre + ((rot * mDirection) * mRadius)); mCamera->lookAt(objectCentre); } } } else if(event.MiddleIsDown()) { int left, top, width, height; mCamera->getViewport()->getActualDimensions(left, top, width, height); float speed = 1.0f; if (event.ShiftDown()) speed = 0.1f; if (event.ControlDown()) speed = 10.0f; float moveX = ((float)-change.x / (float)width) * mZoomScale * speed; float moveY = ((float)change.y / (float)height) * mZoomScale * speed; Ogre::Vector3 delta(mCamera->getRealOrientation().xAxis() * moveX); delta += mCamera->getRealOrientation().yAxis() * moveY; mCamera->setPosition(mCamera->getRealPosition() + delta); } } mPrevPos = pos; }
/** Callback event when clicking the export menu option. Adds an instance of the options dialog as a property, then uses the InspectObj XSI command to pop it up in a modal dialog. If it wasn't cancelled, performs an export. */ XSI::CStatus OnOgreMeshExportMenu( XSI::CRef& in_ref ) { Ogre::LogManager logMgr; logMgr.createLog("OgreXSIExporter.log", true); CString msg(L"OGRE Exporter Version "); msg += OGRE_XSI_EXPORTER_VERSION; LogOgreAndXSI(msg); Application app; CStatus st(CStatus::OK); Property prop = app.GetActiveSceneRoot().GetProperties().GetItem(exportPropertyDialogName); if (prop.IsValid()) { // Check version number CString currVersion(prop.GetParameterValue(L"version")); if (!currVersion.IsEqualNoCase(OGRE_XSI_EXPORTER_VERSION)) { DeleteObj(exportPropertyDialogName); prop.ResetObject(); } } if (!prop.IsValid()) { prop = app.GetActiveSceneRoot().AddProperty(exportPropertyDialogName); prop.PutParameterValue(L"version", CString(OGRE_XSI_EXPORTER_VERSION)); } try { // Popup Returns true if the command was cancelled otherwise it returns false. CStatus ret = Popup(exportPropertyDialogName,CValue(),L"OGRE Mesh / Skeleton Export",((LONG)siModal),true); if (ret == CStatus::OK) { Ogre::XsiMeshExporter meshExporter; Ogre::XsiSkeletonExporter skelExporter; // retrieve the parameters Parameter param = prop.GetParameters().GetItem(L"objectName"); CString objectName = param.GetValue(); param = prop.GetParameters().GetItem( L"targetMeshFileName" ); Ogre::String meshFileName = XSItoOgre(XSI::CString(param.GetValue())); if (meshFileName.empty()) { OGRE_EXCEPT(Ogre::Exception::ERR_INVALIDPARAMS, "You must supply a mesh file name", "OGRE Exporter"); } // fix any omission of '.mesh' if (!Ogre::StringUtil::endsWith(meshFileName, ".mesh")) { meshFileName += ".mesh"; } param = prop.GetParameters().GetItem( L"mergeSubmeshes" ); bool mergeSubmeshes = param.GetValue(); param = prop.GetParameters().GetItem( L"exportChildren" ); bool exportChildren = param.GetValue(); param = prop.GetParameters().GetItem( L"calculateEdgeLists" ); bool edgeLists = param.GetValue(); param = prop.GetParameters().GetItem( L"calculateTangents" ); bool tangents = param.GetValue(); param = prop.GetParameters().GetItem( L"tangentSemantic" ); CString tangentSemStr = param.GetValue(); Ogre::VertexElementSemantic tangentSemantic = (tangentSemStr == L"t")? Ogre::VES_TANGENT : Ogre::VES_TEXTURE_COORDINATES; param = prop.GetParameters().GetItem( L"tangentsSplitMirrored" ); bool tangentsSplitMirrored = param.GetValue(); param = prop.GetParameters().GetItem( L"tangentsSplitRotated" ); bool tangentsSplitRotated = param.GetValue(); param = prop.GetParameters().GetItem( L"tangentsUseParity" ); bool tangentsUseParity = param.GetValue(); param = prop.GetParameters().GetItem( L"numLodLevels" ); long numlods = (LONG)param.GetValue(); Ogre::XsiMeshExporter::LodData* lodData = 0; if (numlods > 0) { param = prop.GetParameters().GetItem( L"lodDistanceIncrement" ); float distanceInc = param.GetValue(); param = prop.GetParameters().GetItem(L"lodQuota"); CString quota = param.GetValue(); param = prop.GetParameters().GetItem(L"lodReduction"); float reduction = param.GetValue(); lodData = new Ogre::XsiMeshExporter::LodData; float currentInc = distanceInc; for (int l = 0; l < numlods; ++l) { lodData->distances.push_back(currentInc); currentInc += distanceInc; } lodData->quota = (quota == L"p") ? Ogre::ProgressiveMesh::VRQ_PROPORTIONAL : Ogre::ProgressiveMesh::VRQ_CONSTANT; if (lodData->quota == Ogre::ProgressiveMesh::VRQ_PROPORTIONAL) lodData->reductionValue = reduction * 0.01; else lodData->reductionValue = reduction; } param = prop.GetParameters().GetItem( L"exportSkeleton" ); bool exportSkeleton = param.GetValue(); param = prop.GetParameters().GetItem( L"exportVertexAnimation" ); bool exportVertexAnimation = param.GetValue(); param = prop.GetParameters().GetItem( L"exportMaterials" ); bool exportMaterials = param.GetValue(); param = prop.GetParameters().GetItem( L"copyTextures" ); bool copyTextures = param.GetValue(); // create singletons Ogre::ResourceGroupManager rgm; Ogre::MeshManager meshMgr; Ogre::SkeletonManager skelMgr; Ogre::MaterialManager matMgr; Ogre::DefaultHardwareBufferManager hardwareBufMgr; // determine number of exportsteps size_t numSteps = 3 + OGRE_XSI_NUM_MESH_STEPS; if (numlods > 0) numSteps++; if (edgeLists) numSteps++; if (tangents) numSteps++; if (exportSkeleton) numSteps += 3; Ogre::ProgressManager progressMgr(numSteps); // Any material prefix? We need that for mesh linking too param = prop.GetParameters().GetItem( L"materialPrefix" ); Ogre::String materialPrefix = XSItoOgre(XSI::CString(param.GetValue())); param = prop.GetParameters().GetItem( L"fps" ); float fps = param.GetValue(); if (fps == 0.0f) { OGRE_EXCEPT(Ogre::Exception::ERR_INVALIDPARAMS, "You must supply a valid value for 'FPS'", "OGRE Export"); } Ogre::AnimationList selAnimList; if (exportSkeleton || exportVertexAnimation) { param = prop.GetParameters().GetItem( L"animationList" ); GridData gd(param.GetValue()); for (int a = 0; a < gd.GetRowCount(); ++a) { if (gd.GetCell(ANIMATION_LIST_EXPORT_COL, a) == true) { Ogre::AnimationEntry ae; ae.animationName = XSItoOgre(XSI::CString(gd.GetCell(ANIMATION_LIST_NAME_COL, a))); ae.ikSampleInterval = gd.GetCell(ANIMATION_LIST_IKFREQ_COL, a); ae.startFrame = (LONG)gd.GetCell(ANIMATION_LIST_START_COL, a); ae.endFrame = (LONG)gd.GetCell(ANIMATION_LIST_END_COL, a); selAnimList.push_back(ae); } } } if (exportSkeleton) { param = prop.GetParameters().GetItem( L"targetSkeletonFileName" ); Ogre::String skeletonFileName = XSItoOgre(XSI::CString(param.GetValue())); if (skeletonFileName.empty()) { OGRE_EXCEPT(Ogre::Exception::ERR_INVALIDPARAMS, "You must supply a skeleton file name", "OGRE Exporter"); } // fix any omission of '.skeleton' if (!Ogre::StringUtil::endsWith(skeletonFileName, ".skeleton")) { skeletonFileName += ".skeleton"; } // Truncate the skeleton filename to just the name (no path) Ogre::String skelName = skeletonFileName; int pos = skeletonFileName.find_last_of("\\"); if (pos == Ogre::String::npos) { pos = skeletonFileName.find_last_of("/"); } if (pos != Ogre::String::npos) { skelName = skelName.substr(pos+1, skelName.size() - pos - 1); } // Do the mesh Ogre::DeformerMap& deformers = meshExporter.buildMeshForExport(mergeSubmeshes, exportChildren, edgeLists, tangents, tangentSemantic, tangentsSplitMirrored, tangentsSplitRotated, tangentsUseParity, exportVertexAnimation, selAnimList, fps, materialPrefix, lodData, skelName); // do the skeleton const Ogre::AxisAlignedBox& skelAABB = skelExporter.exportSkeleton(skeletonFileName, deformers, fps, selAnimList); // Do final mesh export meshExporter.exportMesh(meshFileName, skelAABB); } else { Ogre::AxisAlignedBox nullbb; // No skeleton meshExporter.buildMeshForExport(mergeSubmeshes, exportChildren, edgeLists, tangents, tangentSemantic, tangentsSplitMirrored, tangentsSplitRotated, tangentsUseParity, exportVertexAnimation, selAnimList, fps, materialPrefix, lodData); meshExporter.exportMesh(meshFileName, nullbb); } delete lodData; // Do we want to export materials too? if (exportMaterials) { param = prop.GetParameters().GetItem( L"targetMaterialFileName" ); Ogre::String materialFileName = XSItoOgre(XSI::CString(param.GetValue())); // fix any omission of '.material' if (!Ogre::StringUtil::endsWith(materialFileName, ".material")) { materialFileName += ".material"; } Ogre::XsiMaterialExporter matExporter; try { matExporter.exportMaterials(meshExporter.getMaterials(), meshExporter.getTextureProjectionMap(), materialFileName, copyTextures); } catch (Ogre::Exception& e) { // ignore, non-fatal and will be in log } } } } catch (Ogre::Exception& e) { // Will already have been logged to the Ogre log manager // Tell XSI app.LogMessage(OgretoXSI(e.getDescription()), XSI::siFatalMsg); app.LogMessage(OgretoXSI(e.getFullDescription()), XSI::siInfoMsg); } //DeleteObj( L"OgreMeshExportOptions" ); return st; }
// This function will set up everything required by Ogre // and it will ask the user for display settings // At the end of this function Ogre is ready to render. // This function is mostly taken from tutorials and sample programs. int CUIMain::SetupOgre(void) { //================= //Ogre defaultly logs to console // To prevent this the LogManager has to be created // before the Root object. //================= Ogre::LogManager* logMgr = OGRE_NEW Ogre::LogManager; logMgr->createLog("Ogre.log", true, false, false); //================= //Create the Ogre root object // It's possible to specify as parameters the paths to the: // plugin file (what render systems it has to load), config file (screen resolution etc) and log file //================= if( !mRoot ) mRoot = OGRE_NEW Ogre::Root(); //================= // Tell Ogre where all the needed resources are (rendersystems and so on) //================= Ogre::ConfigFile cf; cf.load("resources.cfg"); Ogre::String secName, typeName, archName; Ogre::ConfigFile::SectionIterator seci = cf.getSectionIterator(); while (seci.hasMoreElements()){ secName = seci.peekNextKey(); Ogre::ConfigFile::SettingsMultiMap *settings = seci.getNext(); Ogre::ConfigFile::SettingsMultiMap::iterator i; for (i = settings->begin(); i != settings->end(); ++i) { typeName = i->first; archName = i->second; Ogre::ResourceGroupManager::getSingleton().addResourceLocation(archName, typeName, secName); } } //================= // Set up the render system. // Ogre will ask the user for display settings //================= if( !mRoot->showConfigDialog() ) return 0; //The user probably clicked cancel mWindow = mRoot->initialise(true, "NNYv3"); //================= // Load all the resources. For now, just load all resources at once. The following is from a tutorial: // In a very large game or application, we may have hundreds or even thousands of resources // that our game uses - everything from meshes to textures to scripts. At any given time though, // we probably will only be using a small subset of these resources. To keep down memory requirements, // we can load only the resources that our application is using. We do this by dividing the resources // into sections and only initializing them as we go. //================= Ogre::TextureManager::getSingleton().setDefaultNumMipmaps(5); Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups(); //================= // Preparing the scene //================= mSceneMgr = mRoot->createSceneManager(Ogre::ST_EXTERIOR_CLOSE); //ST_EXTERIOR_CLOSE allows rendering terrain mCamera.Initialize(mSceneMgr); Ogre::Viewport* vp = mWindow->addViewport(mCamera.GetCamera()); vp->setBackgroundColour(Ogre::ColourValue(0.9,0.9,0.9)); //Fog will not work with sky ;) //mSceneMgr->setFog(Ogre::FOG_LINEAR, Ogre::ColourValue(0.9,0.9,0.9), 0.0, 50, 500); mCamera.GetCamera()->setAspectRatio(Ogre::Real(vp->getActualWidth()) / Ogre::Real(vp->getActualHeight())); //Set a moving cloud texture as background mSceneMgr->setSkyDome(true, "CloudySky", 5, 8); //Get a RaySceneQuery object. A SceneQuery object is a class that can query all //objects in a region or scene. RaySceneQuery has it as a base class. RaySceneQuery //can get all objects that intersect a ray. mQueryMouseMovement = mSceneMgr->createRayQuery(Ogre::Ray(), QUERY_MASK_MOUSE_MOVEMENT); mQueryMouseSelection = mSceneMgr->createRayQuery(Ogre::Ray(), QUERY_MASK_MOUSE_SELECTING); LoadWorld(); //================= // Set up the CEGUI system //================= mGUIHandler = new CGUIHandler(mWindow, mSceneMgr); //================= // Create the input handler //================= mInputHandler = new CInputHandler(mWorld, mCamera, mWindow, mSceneMgr); mRoot->addFrameListener(mInputHandler); mRoot->addFrameListener(this); //================= // Create the console overlay //================= mConsoleOverlay = new ConsoleOverlay(); return 1; }
//does all the initial setup of the window, camera, etc. void OgreDisplay::initialize() { //This code is used to stop ogre from spamming it's log to the command line. //It works by creating a dummy loglistener that doesn't output anything Ogre::LogManager* logger = new Ogre::LogManager(); QuietLog qlog; logger->createLog("ogre/ogre.log", true, false, true); if (!verbose) { Ogre::LogManager::getSingleton().getDefaultLog()->addListener(&qlog); } //use the files given root = new Root("ogre/plugins.cfg", "ogre/ogre.cfg", "ogre/ogre.log"); //this code chooses the renderer to use. without plugins.cfg, this won't work RenderSystemList* renderers = root->getAvailableRenderers(); assert( !renderers->empty() ); RenderSystem* renderSystems = renderers->at(0); root->setRenderSystem(renderSystems); //set up some options for our window root->getRenderSystem()->setConfigOption( "Full Screen", "No" ); root->getRenderSystem()->setConfigOption( "Video Mode", "1920x1000" ); root->getRenderSystem()->setConfigOption( "VSync", "Yes" ); root->saveConfig(); //FIXME: how can I get it to read this from resources.cfg instead of manually specifying it here? root->addResourceLocation("./content/", "FileSystem"); //if (root->showConfigDialog()) //FIXME: make it a command line thing to not show this? { renderWindow = root->initialise(true); } //choose scene manager, make camera and do clear colour sceneMgr = root->createSceneManager( ST_GENERIC, "PrototypeSceneManager"); camera = sceneMgr->createCamera("ViewCamera"); camera->setNearClipDistance(0.1); camera->setFarClipDistance(1000.0); viewport = renderWindow->addViewport(camera); viewport->setBackgroundColour(ColourValue(1, 1, 1)); camera->setAspectRatio( Real(viewport->getActualWidth()) / Real(viewport->getActualHeight()) ); //make a texture manager and resource groups TextureManager::getSingleton().setDefaultNumMipmaps(5); //ResourceGroupManager::getSingleton().createResourceGroup("procgen"); //root->addResourceLocation("../content", "FileSystem", "procgen", true); ResourceGroupManager::getSingleton().initialiseAllResourceGroups(); //some ambient light sceneMgr->setAmbientLight(ColourValue(0.0, 0.0, 0.0)); //set the shadow type we'll be using - commented out because it was causing a crash //sceneMgr->setShadowTechnique(Ogre::SHADOWTYPE_STENCIL_ADDITIVE); //put the camera looking at the origins camera->setPosition(0,0,0); camera->lookAt(Vector3(64,64,64)); //create a static geometry group for doing the voxels sceneMgr->createStaticGeometry("voxel_grid"); //make a billboard group. sceneMgr->createBillboardSet("voxel_grid"); sceneMgr->getRootSceneNode()->attachObject(sceneMgr->getBillboardSet("voxel_grid")); sceneMgr->getBillboardSet("voxel_grid")->setDefaultDimensions(1.0, 1.0); //enable this to rendering the voxels as points sceneMgr->getBillboardSet("voxel_grid")->setPointRenderingEnabled(true); sceneMgr->getBillboardSet("voxel_grid")->setMaterialName("basic/cube_default"); //do mesh setup stuff cubeCount = 0; cylinderCount = 0; this->createCubeMesh(); //use default arguments to make the default cube this->createCylinderMesh(); //use default arguments to make the default cylinder }
bool GraphicsController::onInit(Ogre::SceneManager* scnMgr, Ogre::Viewport* viewport, Ogre::Camera* camera, Ogre::int32 windowWidth, Ogre::int32 windowHeight) { _cam = camera; _scnMgr = scnMgr; _vp = viewport; //_dynLightsManager = packet->workspaceCtrl->getZWorkspace()->getWorldController()->getDynamicLightManager(); //generate random textures for(size_t i = 0; i < NUM_OF_BANDS * 4; i++) { _SHC_R[i] = 0.0f; _SHC_G[i] = 0.0f; _SHC_B[i] = 0.0f; } Ogre::LogManager* lm = Ogre::LogManager::getSingletonPtr(); lm->logMessage(Ogre::LML_TRIVIAL, "In GraphicsController::onInit()"); lm->logMessage(Ogre::LML_NORMAL, "Adding compositor bloom"); //First build the lights. _lightDir.normalise(); Vector3 lightdir(0.0, -0.5, 0.1); lightdir.normalise(); lightdir *= -1; _scnMgr->setAmbientLight(Ogre::ColourValue(0.5f, 0.5f, 0.5f)); light = _scnMgr->createLight("terrainLight"); light->setType(Light::LT_DIRECTIONAL); light->setCastShadows(true); light->setShadowFarClipDistance(256); Ogre::ColourValue fadeColour(1.0, 1.0, 1.0); _scnMgr->setFog(Ogre::FOG_NONE); _initBackgroundHdr(); _vp->setBackgroundColour(fadeColour); Ogre::CompositorManager& compMgr = Ogre::CompositorManager::getSingleton(); _hdrLogic = new HDRLogic(); compMgr.registerCompositorLogic("HDR", _hdrLogic); _ogreHdr = CompositorManager::getSingleton().addCompositor(_vp, "HDR", 0); Ogre::CompositorManager::getSingleton().setCompositorEnabled(_vp, "HDR", true); /* //setup the HDR options. auto sharedParams = Ogre::GpuProgramManager::getSingleton().getSharedParameters("HdrSharedParams"); ZGame::Graphics::GraphicsOptions gfxOptions; sharedParams->setNamedConstant("MIDDLE_GREY", gfxOptions.hdr_middle_grey); sharedParams->setNamedConstant("BRIGHT_LIMITER", gfxOptions.hdr_bright_limiter); sharedParams->setNamedConstant("FUDGE", gfxOptions.hdr_fudge_factor); */ _deferredGfx->initialize(_cam, windowWidth, windowHeight); //addTextureDebugOverlay(_deferredGfx->getLightBufferTex()->getName(), 1); //Ogre::OverlayManager::getSingleton().getByName("PRJZ/DebugOverlay")->show(); //addTextureDebugOverlay(_deferredGfx->getGBuffer1Tex()->getName(), 0); //addTextureDebugOverlay(_rtLum4->getName(), 0); //addTextureDebugOverlay(_deferredGfx->getNormalDepthTex()->getName(), 0); //Overlay* debugOverlay = OverlayManager::getSingleton().getByName("PRJZ/DebugOverlay"); //debugOverlay->show(); //addTextureDebugOverlay(_deferredGfx->getLightBufferTex()->getName(), 0); //addTextureDebugOverlay(_ssaoBlurY->getName(), 0); //addTextureDebugOverlay(_ssaoTarget->getName(), 0); //addTextureDebugOverlay(_hfaoTarget->getName(), 0); //addTextureDebugOverlay(_hfaoBlurY->getName(), 0); //addTextureDebugOverlay(_wendlandFilter->getName(), 0); //addTextureDebugOverlay(_ssaoTarget->getName(), 0); //addTextureDebugOverlay(_bitwiseLookupTex->getName(), 0); //addTextureDebugOverlay(_hfaoBlurY, 0); //setup the texture data textures. //setup lighting direction quad /* _directionLightQuad = new Ogre::Rectangle2D(true); _directionLightQuad->setCorners(-1, 1, 1, -1); _directionLightQuad->setBoundingBox(Ogre::AxisAlignedBox::BOX_INFINITE); //was 0xf0 _directionLightQuad->setVisibilityFlags(0xf0); //F**K: for mask see DynamicLightManager. We need to define these globally. _directionLightQuad->setCastShadows(false); _directionLightQuad->setRenderQueueGroup(Ogre::RENDER_QUEUE_6); _directionLightQuad->setVisible(true); _directionLightQuad->setMaterial("PRJZ/DirectionLightBuffer"); _scnMgr->getRootSceneNode()->attachObject(_directionLightQuad); */ return true; }
int main(int argc, char **argv) #endif { int ret = 0; Ogre::Log * log = NULL; Ogre::Root * root = NULL; GameManager* game = NULL; Ogre::LogManager * logMgr = NULL; bool configCreated = false; std::string ogreLogPath, ogreCfgPath; srand(time(NULL)); using namespace boost::filesystem; // Creates the Lost Marbles directory to write to path lostMarblesDir(utils::getLostMarblesWriteDir()); try { if(! exists(lostMarblesDir)) create_directories(lostMarblesDir); } catch(const filesystem_error& ex) { #if OGRE_PLATFORM == OGRE_PLATFORM_WIN32 MessageBoxA(NULL, ex.what(), "An exception has occurred!", MB_OK | MB_ICONERROR | MB_TASKMODAL); #else std::cerr << "An exception has occured: " << ex.what() << std::endl; #endif ret = 1; goto gracefulexit; } ogreLogPath = (lostMarblesDir / "Ogre.log").string(); logMgr = new Ogre::LogManager(); log = logMgr->createLog(ogreLogPath, true, true, false); ogreCfgPath = (lostMarblesDir / "Ogre.cfg").string(); root = new Ogre::Root("Plugins.cfg",ogreCfgPath); log->logMessage("Main Lost Marbles write directory " + lostMarblesDir.string()); log->logMessage("Log Path: " + ogreLogPath); log->logMessage("Config Path: " + ogreCfgPath); if(!root->restoreConfig()) { configCreated = root->showConfigDialog(); root->saveConfig(); } else configCreated = true; if(configCreated) { game = new GameManager(); try { // initialize the game and switch to the first state game->start(LogoState::getInstance()); } catch (Ogre::Exception& e) { #if OGRE_PLATFORM == OGRE_PLATFORM_WIN32 MessageBoxA(NULL, e.getFullDescription().c_str(), "An exception has occurred!", MB_OK | MB_ICONERROR | MB_TASKMODAL); #else std::cerr << "An exception has occured: " << e.getFullDescription() << std::endl; #endif ret = 1; goto gracefulexit; } } gracefulexit: if(game) delete game; if(root) delete root; if(logMgr) delete logMgr; return ret; }
void NativeEnginePrivate::initOgre() { #if !defined(NDEBUG) Ogre::String pluginsCfg = "plugins_d.cfg"; #else Ogre::String pluginsCfg = "plugins.cfg"; #endif Ogre::LogManager * lm = new Ogre::LogManager(); Ogre::Log *log = lm->createLog("", true, false, false); log->addListener(this); /* Initialize Ogre */ ogreRoot = new Ogre::Root(pluginsCfg); /* Set OpenGL render system on Ogre */ Ogre::RenderSystem *renderSystem = ogreRoot->getRenderSystemByName("OpenGL Rendering Subsystem"); if (!renderSystem) throw std::exception("Unable to find OpenGL Render System!"); renderSystem->setConfigOption("Colour Depth", "32"); renderSystem->setConfigOption("Fixed Pipeline Enabled", "Yes"); renderSystem->setConfigOption("VSync", "No"); ogreRoot->setRenderSystem(renderSystem); ogreRoot->initialise(false); /* Initialize the render window to use the GLWidget internally */ Ogre::NameValuePairList params; params["externalGLControl"] = "true"; params["externalGLContext"] = QString::number((uint)wglGetCurrentContext()).toStdString(); // TODO: Platform dependent params["externalWindowHandle"] = QString::number((uint)glWidget->winId()).toStdString(); ogreWindow = ogreRoot->createRenderWindow("", glWidget->width(), glWidget->height(), false, ¶ms); /* We don't use mip maps since our camera distance from all objects is fixed */ Ogre::TextureManager::getSingleton().setDefaultNumMipmaps(0); /* here we could load "builtin" resources, but all other resources should be controlled by c# */ /*Ogre::ResourceGroupManager &resourceManager = Ogre::ResourceGroupManager::getSingleton(); resourceManager.addResourceLocation("C:/Users/Sebastian/AppData/Local/EvilTemple/data.zip", "Zip", "General", true); resourceManager.initialiseAllResourceGroups();*/ /* Create the actual scene manager */ ogreRoot->addSceneManagerFactory(new SceneFactory); ogreRoot->addMovableObjectFactory(new GroundDiscFactory); sceneManager = static_cast<Scene*>(ogreRoot->createSceneManager("Scene")); sceneManager->resizeWindow(glWidget->width(), glWidget->height()); /* Create and initialize the main camera */ camera = sceneManager->getMainCamera(); /* Create the viewport */ viewport = ogreWindow->addViewport(camera); viewport->setBackgroundColour(Ogre::ColourValue(0.5, 0.5, 0.5)); sceneManager->setAmbientLight(Ogre::ColourValue(0, 0, 0)); /* TEST */ /*Ogre::Entity* model = sceneManager->createEntity("meshes/pcs/pc_human_male/pc_human_male.mesh"); Ogre::SceneNode* headNode = sceneManager->getRootSceneNode()->createChildSceneNode(); headNode->setPosition(0, 0, 0); headNode->attachObject(model); Ogre::AnimationState *animState = model->getAnimationState("unarmed_unarmed_idle"); animState->setEnabled(true); animState->setLoop(true); animState->setWeight(1.0f); sceneManager->setAmbientLight(Ogre::ColourValue(0, 0, 0)); // Create a light Ogre::Light* l = sceneManager->createLight("MainLight"); l->setType(Ogre::Light::LT_DIRECTIONAL); l->setDirection(-0.6324093645670703858428703903848, -0.77463436252716949786709498111783, 0);*/ /* /TEST */ }
void setupLog() { static Ogre::LogManager logManager; logManager.createLog("default", true, false, false); }
/**************************************************************************** ** ** Copyright (C) 2014 ** ** This file is generated by the Magus toolkit ** ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT ** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR ** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT ** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT ** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, ** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY ** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT ** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE ** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE." ** ****************************************************************************/ // Include #include "mainwindow.h" #include "Editor_dockwidget.h" #include "constants.h" #include "sme_asset_material.h" #include "sme_node_material.h" #include "sme_asset_technique.h" #include "sme_node_technique.h" #include "sme_asset_pass.h" #include "sme_node_pass.h" #include "sme_asset_texture_unit.h" #include "sme_node_texture_unit.h" //****************************************************************************/ EditorDockWidget::EditorDockWidget(QString title, MainWindow* parent, Qt::WindowFlags flags) : QDockWidget (title, parent, flags), mParent(parent) { mInnerMain = new QMainWindow(); setWidget(mInnerMain); // Perform standard functions createActions(); createMenus(); createToolBars(); // Create the node editor widget. mNodeEditor = new Magus::QtNodeEditor(this); mNodeEditor->setMenuSelectionToCompoundEnabled(false); // Enabling this makes it a bit more complicated mNodeEditor->setMenuExpandCompoundsEnabled(false); // No compounds are used connect(mNodeEditor, SIGNAL(nodeRemoved(QtNode*)), this, SLOT(nodeDeleted())); connect(mNodeEditor, SIGNAL(nodeSelected(QtNode*)), this, SLOT(nodeSelected(QtNode*))); mInnerMain->setCentralWidget(mNodeEditor); mMaterialNode = 0; } //****************************************************************************/ EditorDockWidget::~EditorDockWidget(void) { } //****************************************************************************/ void EditorDockWidget::createActions(void) { mMaterialHToolbarAction = new QAction(QIcon(ICON_MATERIAL), QString("Add a material node to the editor"), this); connect(mMaterialHToolbarAction, SIGNAL(triggered()), this, SLOT(doMaterialHToolbarAction())); mTechniqueHToolbarAction = new QAction(QIcon(ICON_TECHNIQUE), QString("Add a technique node to the editor"), this); connect(mTechniqueHToolbarAction, SIGNAL(triggered()), this, SLOT(doTechniqueHToolbarAction())); mPassHToolbarAction = new QAction(QIcon(ICON_PASS), QString("Add a pass node to the editor"), this); connect(mPassHToolbarAction, SIGNAL(triggered()), this, SLOT(doPassHToolbarAction())); mTextureHToolbarAction = new QAction(QIcon(ICON_TEXTURE), QString("Add a texture unit node to the editor"), this); connect(mTextureHToolbarAction, SIGNAL(triggered()), this, SLOT(doTextureHToolbarAction())); mCogHToolbarAction = new QAction(QIcon(ICON_COG), QString("Generate material"), this); connect(mCogHToolbarAction, SIGNAL(triggered()), this, SLOT(doCogHToolbarAction())); } //****************************************************************************/ void EditorDockWidget::createMenus(void) { } //****************************************************************************/ void EditorDockWidget::createToolBars(void) { mHToolBar = new QToolBar(); mInnerMain->addToolBar(Qt::TopToolBarArea, mHToolBar); mHToolBar->setMinimumHeight(TB_ICON_AND_SPACING); mHToolBar->setMinimumWidth(1200); mHToolBar->addAction(mMaterialHToolbarAction); mHToolBar->addAction(mTechniqueHToolbarAction); mHToolBar->addAction(mPassHToolbarAction); mHToolBar->addAction(mTextureHToolbarAction); mHToolBar->addAction(mCogHToolbarAction); } //****************************************************************************/ void EditorDockWidget::doMaterialHToolbarAction(void) { // Add a material node; only 1 is allowed if (!mMaterialNode) { mMaterialNode = new Magus::QtNodeMaterial(NODE_TITLE_MATERIAL); mNodeEditor->addNode(mMaterialNode); } } //****************************************************************************/ void EditorDockWidget::doTechniqueHToolbarAction(void) { // Add a technique node Magus::QtNodeTechnique* techniqueNode = new Magus::QtNodeTechnique(NODE_TITLE_TECHNIQUE); mNodeEditor->addNode(techniqueNode); } //****************************************************************************/ void EditorDockWidget::doPassHToolbarAction(void) { // Add a pass node Magus::QtNodePass* passNode = new Magus::QtNodePass(NODE_TITLE_PASS); mNodeEditor->addNode(passNode); } //****************************************************************************/ void EditorDockWidget::doTextureHToolbarAction(void) { // Add a texture unit node Magus::QtNodeTextureUnit* textureUnitNode = new Magus::QtNodeTextureUnit(NODE_TITLE_TEXTURE_UNIT); mNodeEditor->addNode(textureUnitNode); } //****************************************************************************/ void EditorDockWidget::doCogHToolbarAction(void) { if (!mMaterialNode) return; if (mMaterialNode->getMaterialName().isEmpty()) return; // ---------------------------------------- Create a material ---------------------------------------- Ogre::LogManager* logManager = Ogre::LogManager::getSingletonPtr(); Ogre::MaterialManager* materialManager = Ogre::MaterialManager::getSingletonPtr(); Ogre::String materialName = mMaterialNode->getMaterialName().toStdString(); // Convert to std format logManager->logMessage("SME: create Ogre material: " + materialName); Ogre::MaterialPtr material = materialManager->create(materialName, "General"); // Remark: Sceneblending is done for each pass individually, although it is defined on material level // ---------------------------------------- Add the technique ---------------------------------------- Magus::QtNode* node = mMaterialNode->getNodeConnectedToPort(PORT_TECHNIQUE_OUT); if (!node) { logManager->logMessage("SME: No technique node available"); return; } Magus::QtNodeTechnique* techniqueNode = static_cast<Magus::QtNodeTechnique*>(node); material->removeAllTechniques(); Ogre::Technique* technique = material->createTechnique(); technique->removeAllPasses(); logManager->logMessage("SME: Technique created" + Ogre::StringConverter::toString(material->getNumTechniques())); // ---------------------------------------- Add the passes ---------------------------------------- Magus::QtNodePass* passNode; Magus::QtNodeTextureUnit* textureUnitNode; Ogre::Pass* pass; Ogre::TextureUnitState* textureUnit; for (unsigned int i = 1; i < 5; ++i) { node = techniqueNode->getNodeConnectedToPort(PORT_PASS_OUT, i); // node with the same name if (node) { passNode = static_cast<Magus::QtNodePass*>(node); pass = technique->createPass(); pass->removeAllTextureUnitStates(); logManager->logMessage("SME: Pass on port nr. " + Ogre::StringConverter::toString(i) + " created"); propagatePassNodeData(passNode, pass); // ---------------------------------------- Add the texture units ---------------------------------------- for (unsigned int j = 1; j < 9; ++j) { node = passNode->getNodeConnectedToPort(PORT_TEXTURE_OUT, j); if (node) { logManager->logMessage("SME: Texture unit on port nr. " + Ogre::StringConverter::toString(j) + " of Pass port nr. " + Ogre::StringConverter::toString(i) + " created"); textureUnitNode = static_cast<Magus::QtNodeTextureUnit*>(node); textureUnit = pass->createTextureUnitState(); propagateTextureUnitNodeData(textureUnitNode, textureUnit); } } } } // Assign the material to the ogrehead material->compile(); material->load(); mParent->getOgreManager()->getOgreWidget(1)->mEntity->setMaterial(material); }