UndoUtil::UndoUtil(ScenePtr pScene) { if (pScene.isnull()) m_pUM=NULL; else m_pUM = pScene->getUndoMgr(); }
/** Loads data from a PDB file (command line parameter --pdb-file) */ void _loadPDBFile() { // Load PDB File GeometryParameters& geometryParameters = _parametersManager->getGeometryParameters(); BRAYNS_INFO << "Loading PDB file " << geometryParameters.getPDBFile() << std::endl; ProteinLoader proteinLoader( geometryParameters ); if( !proteinLoader.importPDBFile( geometryParameters.getPDBFile(), Vector3f( 0, 0, 0 ), 0, *_engine->getScene())) { BRAYNS_ERROR << "Failed to import " << geometryParameters.getPDBFile() << std::endl; } ScenePtr scene = _engine->getScene(); for( size_t i = 0; i < scene->getMaterials().size( ); ++i ) { float r,g,b; proteinLoader.getMaterialKd( i, r, g, b ); MaterialPtr material = scene->getMaterials()[i]; material->setColor( Vector3f( r, g, b )); } }
bool SceneSyncState::FillRequest(entity_id_t id) { changeRequest_.Reset(id); if (scene_.expired()) return false; ScenePtr scenePtr = scene_.lock(); if (!scenePtr.get()) { LogError("SceneSyncState::FillRequest(id): Scene is null!"); return false; } EntityPtr entityPtr = scenePtr->GetEntity(id); if (!entityPtr.get()) return false; // We trust the SyncManager mechanisms to stop local entities from ever getting here. // Print anyways if something starts to leak so at least we notice it here. if (!entityPtr->IsReplicated()) LogError("SceneSyncState::FillRequest(id): Entity " + QString::number(id) + " should not be replicated!"); changeRequest_.SetEntity(entityPtr.get()); return true; }
void SceneSyncState::AddPendingEntity(entity_id_t id) { if (!isServer_) return; if (scene_.expired()) return; ScenePtr scenePtr = scene_.lock(); if (!scenePtr.get()) { LogError("SceneSyncState::FillPendingComponents(id): Scene is null!"); return; } EntityPtr entityPtr = scenePtr->GetEntity(id); if (!entityPtr.get()) { LogError("SceneSyncState::FillPendingComponents(id): Entity is null, cannot fill components!"); return; } if (entityPtr->Components().empty()) return; if (!HasPendingEntity(id)) pendingEntities_.push_back(id); }
void MqoSceneExporter::write() { MqoDisplayContext *pmqodc = MB_NEW MqoDisplayContext(); ScenePtr pScene = getClient(); CameraPtr pCam = getCamera(); qlib::ensureNotNull(pCam.get()); // Main stream qlib::OutStream *pOutMqo = createOutStream(); pmqodc->init(pOutMqo); pmqodc->setGradSteps(m_nGradSteps); pmqodc->setClipZ(m_bUseClipZ); pmqodc->setPerspective(m_bPerspective); pmqodc->setBgColor(pScene->getBgColor()); pmqodc->setZoom(pCam->getZoom()); pmqodc->setSlabDepth(pCam->getSlabDepth()); pmqodc->setViewDist(pCam->getCamDist()); pmqodc->loadIdent(); pmqodc->rotate(pCam->m_rotQuat); pmqodc->translate(-(pCam->m_center)); pScene->display(pmqodc); delete pmqodc; // cleanup the created streams pOutMqo->close(); delete pOutMqo; }
void Client::HandleLoginReply(kNet::MessageConnection* /*source*/, const char *data, size_t numBytes) { DataDeserializer dd(data, numBytes); MsgLoginReply msg; msg.DeserializeFrom(dd); // Read optional protocol version // Server can downgrade what we sent, but never upgrade serverUserConnection_->protocolVersion = ProtocolOriginal; if (dd.BytesLeft()) serverUserConnection_->protocolVersion = (NetworkProtocolVersion)dd.ReadVLE<kNet::VLE8_16_32>(); if (msg.success) { loginstate_ = LoggedIn; client_id_ = msg.userID; LogInfo("Logged in successfully"); // Note: create scene & send info of login success only on first connection, not on reconnect if (!reconnect_) { // The connection is now live for use by eg. SyncManager serverUserConnection_->connection = MessageConnection(); // Create a non-authoritative scene for the client ScenePtr scene = framework_->Scene()->CreateScene("TundraClient", true, false); owner_->SyncManager()->RegisterToScene(scene); UserConnectedResponseData responseData; if (msg.loginReplyData.size() > 0) { String responseDataStr((const char *)&msg.loginReplyData[0], (int)msg.loginReplyData.size()); responseData.responseDataXml = new Urho3D::XMLFile(context_); responseData.responseDataXml->FromString(responseDataStr); } Connected.Emit(&responseData); } else { // If we are reconnecting, empty the scene, as the server will send everything again anyway // Note: when we move to unordered communication, we must guarantee that the server does not send // any scene data before the login reply ScenePtr scene = framework_->Scene()->SceneByName("TundraClient"); if (scene) scene->RemoveAllEntities(true, AttributeChange::LocalOnly); } reconnect_ = true; } else { String response((const char *)&msg.loginReplyData[0], (int)msg.loginReplyData.size()); if (!response.Empty()) SetLoginProperty("LoginFailed", response); DoLogout(true); } }
void setMaterials( const MaterialType materialType, const size_t nbMaterials ) { ScenePtr scene = _engine->getScene(); scene->setMaterials( materialType, nbMaterials ); scene->commit( ); }
UndoUtil::UndoUtil(qlib::uid_t nSceneID) { ScenePtr pScene = SceneManager::getSceneS(nSceneID); if (pScene.isnull()) m_pUM=NULL; else m_pUM = pScene->getUndoMgr(); }
void Viewport::deleteObject() { ScenePtr scene = m_gl_widget->scene(); if (!scene) return; foreach (ObjectPtr obj, scene->selection()) scene->remove(obj); }
void GLWidget::sceneChange(ScenePtr s) { m_scene = s; if (s) { setFormat(s->glFormat()); s->resize(size().width(), size().height()); } }
void TimeLine::_create_test() { ScenePtr scene = std::make_shared<Scene>(project_); scene->_create_test(); scenes_.push_back(scene); //CompositorPtr show(new SdlShowCompositor(renderer)); //comps_.push_back(show); }
bool SceneIO::processSceneTrajectory(rapidxml::xml_node<char>* sceneXMLNode, ScenePtr scene ) { THROW_VR_EXCEPTION_IF(!sceneXMLNode || !scene, "NULL data in processSceneTrajectory"); std::vector<RobotPtr> robs = scene->getRobots(); TrajectoryPtr o = BaseIO::processTrajectory(sceneXMLNode, robs); if (!o) return false; scene->registerTrajectory(o); return true; }
/////////////////////////////////////////////////////////////////////////////// // Open a zone that should be under the root. // ScenePtr SceneManager::OpenScene( SceneGraph::Viewport* viewport, Document* document, tstring& error ) { ScenePtr scene = NewScene( viewport, document ); if ( !scene->Load( document->GetPath() ) ) { error = TXT( "Failed to load scene from " ) + document->GetPath().Get() + TXT( "." ); RemoveScene( scene ); scene = NULL; } return scene; }
bool VolComputer::process(const ScenePtr scene){ if(!scene || scene->empty()){ __result = 0; return false; } real_t volume = 0; for(Scene::const_iterator _it=scene->begin(); _it!=scene->end(); _it++) if((*_it)->apply(*this)) volume+=__result; __result = volume; return true; }
void Engine::loadScene(const std::string & path) { try { ScenePtr scene = ModelLoader::loadScene(path); scene->init(); cout << scene->toString() << endl; m_camera = scene->getCamera(); m_camera->setScreenSize(m_screenSize.x, m_screenSize.y); m_renderer->setScene(std::move(scene)); } catch (const std::exception &e) { std::cout << "Impossible de charger la scène : " << e.what() << std::endl; } }
void SceneDirector::push(ScenePtr scene, PushType::Type pushType) { assert(scene != NULL); if(getDelegate()) { getDelegate()->onSceneWillBeAddedToStack(this, *scene); } _scenes.push_back(ScenePair(scene, pushType)); if(getDelegate()) { getDelegate()->onSceneHasBeenAddedToStack(this, *scene); } if(getDelegate()) { getDelegate()->onSceneWillBeInitialized(this, *scene); } // initialize the scene scene->initialize(); if(getDelegate()) { getDelegate()->onSceneHasBeenInitialized(this, *scene); } }
void ModelLoader::processNode(const aiScene *aiscene, ScenePtr &scene, aiNode * node, SceneObjectPtr &object, glm::mat4 accTransform) { //Transform object->transform = aiToGLM(node->mTransformation); accTransform = accTransform * object->transform; //Name object->name = node->mName.C_Str(); //Mesh object->meshes.reserve(node->mNumMeshes); for (int i = 0; i < node->mNumMeshes; i++) { aiMesh *mesh = aiscene->mMeshes[node->mMeshes[i]]; object->meshes.push_back(MeshPtr(new ModelMesh)); processMesh(aiscene, scene, mesh, object->meshes.back(), accTransform); //Bounding box object->bBox.fitWithAddingBbox(object->meshes.back()->bBox); } //Children for (int i = 0; i < node->mNumChildren; i++) { //Création d'un enfant SceneObjectPtr &newObject = object->createChild(); //Parent newObject->parent = object.get(); newObject->scene = scene.get(); processNode(aiscene, scene, node->mChildren[i], newObject, accTransform); //Bounding Box object->bBox.fitWithAddingBbox(newObject->bBox); } }
PhysicsWorld::PhysicsWorld(const ScenePtr &scene, bool isClient) : scene_(scene), collisionConfiguration_(0), collisionDispatcher_(0), broadphase_(0), solver_(0), world_(0), physicsUpdatePeriod_(1.0f / 60.0f), maxSubSteps_(6), // If fps is below 10, we start to slow down physics isClient_(isClient), runPhysics_(true), drawDebugManuallySet_(false), useVariableTimestep_(false), debugDrawMode_(0), cachedOgreWorld_(0) { #include "DisableMemoryLeakCheck.h" collisionConfiguration_ = new btDefaultCollisionConfiguration(); collisionDispatcher_ = new btCollisionDispatcher(collisionConfiguration_); broadphase_ = new btDbvtBroadphase(); solver_ = new btSequentialImpulseConstraintSolver(); world_ = new btDiscreteDynamicsWorld(collisionDispatcher_, broadphase_, solver_, collisionConfiguration_); world_->setDebugDrawer(this); world_->setInternalTickCallback(TickCallback, (void*)this, false); #include "EnableMemoryLeakCheck.h" if (scene->GetFramework()->HasCommandLineParameter("--variablephysicsstep")) useVariableTimestep_ = true; }
void render( const RenderInput& renderInput, RenderOutput& renderOutput ) { reshape( renderInput.windowSize ); _engine->preRender(); _engine->getCamera()->set( renderInput.position, renderInput.target, renderInput.up ); #if(BRAYNS_USE_DEFLECT || BRAYNS_USE_REST) if( !_extensionPluginFactory ) _intializeExtensionPluginFactory( ); _extensionPluginFactory->execute( ); #endif ScenePtr scene = _engine->getScene(); CameraPtr camera = _engine->getCamera(); FrameBufferPtr frameBuffer = _engine->getFrameBuffer(); const Vector2i& frameSize = frameBuffer->getSize(); if( _parametersManager->getRenderingParameters().getSunOnCamera() ) { LightPtr sunLight = scene->getLight( 0 ); DirectionalLight* sun = dynamic_cast< DirectionalLight* > ( sunLight.get() ); if( sun ) { sun->setDirection( camera->getTarget() - camera->getPosition() ); scene->commitLights(); } } camera->commit(); _render( ); uint8_t* colorBuffer = frameBuffer->getColorBuffer( ); size_t size = frameSize.x( ) * frameSize.y( ) * frameBuffer->getColorDepth( ); renderOutput.colorBuffer.assign( colorBuffer, colorBuffer + size ); float* depthBuffer = frameBuffer->getDepthBuffer( ); size = frameSize.x( ) * frameSize.y( ); renderOutput.depthBuffer.assign( depthBuffer, depthBuffer + size ); _engine->postRender(); }
void ScreenViewController::render_scene(const CanvasPtr &canvas, const ScenePtr &scene) { using namespace uicore; canvas->end(); GraphicContextPtr gc = canvas->gc(); Pointf viewport_pos = Vec2f(canvas->transform() * Vec4f(0.0f, 0.0f, 0.0f, 1.0f)); Sizef viewport_size = gc->size(); Size viewport_size_i = Size(viewport_size); scene->set_viewport(viewport_size_i); scene->render(gc); canvas->begin(); }
void initGraphics() { trackball(curquat, 0.0, 0.0, 0.0, 0.0); #ifdef __APPLE__ // Seems to be needed on Apple platforms using Intel // integrated graphics but not elsewhere // If you're getting unexpected seg faults on Apple, // comment this out and recompile // If you're not seeing the mesh on a Windows box that // uses Intel integrated graphics, try enabling this // for your machine glEnableClientState(GL_COLOR_ARRAY); #endif glEnableClientState(GL_VERTEX_ARRAY); glEnable(GL_DEPTH_TEST); glPixelStorei(GL_PACK_ALIGNMENT, 1); // avoid GL's dumb default of 4 glPixelStorei(GL_UNPACK_ALIGNMENT, 1); // avoid GL's dumb default of 4 glClearColor(0.1, 0.1, 0.2, 0.0); scene = ScenePtr(new Scene(Camera(40, 1, 0.1, 100), View(eye_vector, at_vector, up_vector))); material = MaterialPtr(new Material()); // A little hacky - pick initial values from menu items materialMenu(0); bumpyMenu(0); decalMenu(0); envMapMenu(0); Mesh2DPtr mesh2d = Mesh2DPtr(new Mesh2D(float2(0,0), float2(1,1), int2(4,4))); TorusPtr torus = TorusPtr(new Torus(Transform(), material)); scene->addObject(torus); light = LightPtr(new Light()); light->setCenter(float3(0,0,0)); light->setRadius(3.5); light->setAngleInDegrees(60.0); // A little hacky - pick initial value from menu item lightMenu(1); scene->addLight(light); }
bool InterestManager::CheckRelevance(UserConnectionPtr conn, Entity* changed_entity, SceneWeakPtr scene_, bool headless) { PROFILE(Interest_Management); ScenePtr scene = scene_.lock(); if (!scene) return true; EC_Placeable *entity_location = changed_entity->GetComponent<EC_Placeable>().get(); if(!conn->syncState->locationInitialized || !entity_location) //If the client hasn't informed the server about the orientation yet, do not proceed return true; bool accepted = false; //By default, we assume that the update will be rejected Quat client_orientation = conn->syncState->clientOrientation.Normalized(); params_.client_position = conn->syncState->clientLocation; //Client location vector params_.entity_position = entity_location->transform.Get().pos; //Entitys location vector float3 d = params_.client_position - params_.entity_position; float3 v = params_.entity_position - params_.client_position; //Calculate the vector between the player and the changed entity by substracting their location vectors float3 f = client_orientation.Mul(scene->ForwardVector()); //Calculate the forward vector of the client params_.headless = headless; params_.dot = v.Dot(f); //Finally the dot product is calculated so we know if the entity is in front of the player or not params_.distance = d.LengthSq(); params_.scene = scene; params_.changed_entity = changed_entity; params_.connection = conn; params_.relAccepted = false; if(activeFilter_ != 0) accepted = activeFilter_->Filter(params_); if(accepted) { UpdateLastUpdatedEntity(params_.connection, params_.changed_entity->Id()); return true; } else return false; }
void Client::HandleLoginReply(MessageConnection* /*source*/, const MsgLoginReply& msg) { if (msg.success) { loginstate_ = LoggedIn; client_id_ = msg.userID; ::LogInfo("Logged in successfully"); // Note: create scene & send info of login success only on first connection, not on reconnect if (!reconnect_) { // Create a non-authoritative scene for the client ScenePtr scene = framework_->Scene()->CreateScene("TundraClient", true, false); // framework_->Scene()->SetDefaultScene(scene); owner_->GetSyncManager()->RegisterToScene(scene); UserConnectedResponseData responseData; if (msg.loginReplyData.size() > 0) responseData.responseData.setContent(QByteArray((const char *)&msg.loginReplyData[0], (int)msg.loginReplyData.size())); emit Connected(&responseData); } else { // If we are reconnecting, empty the scene, as the server will send everything again anyway // Note: when we move to unordered communication, we must guarantee that the server does not send // any scene data before the login reply ScenePtr scene = framework_->Scene()->GetScene("TundraClient"); if (scene) scene->RemoveAllEntities(true, AttributeChange::LocalOnly); } reconnect_ = true; } else { QString response(QByteArray((const char *)&msg.loginReplyData[0], (int)msg.loginReplyData.size())); if (!response.isEmpty()) SetLoginProperty("LoginFailed", response); DoLogout(true); } }
void _setDefaultCamera() { ScenePtr scene = _engine->getScene(); CameraPtr camera = _engine->getCamera(); FrameBufferPtr frameBuffer = _engine->getFrameBuffer(); const Vector2i& frameSize = frameBuffer->getSize(); const Boxf& worldBounds = scene->getWorldBounds(); const Vector3f& target = worldBounds.getCenter(); const Vector3f& diag = worldBounds.getSize(); Vector3f position = target; position.z() -= diag.z(); const Vector3f up = Vector3f( 0.f, 1.f, 0.f ); camera->setInitialState( position, target, up ); camera->setAspectRatio( static_cast< float >( frameSize.x()) / static_cast< float >( frameSize.y())); }
Window::Window(RootObjectWeakPtr root) : BaseObject(root) { _type = "window"; ScenePtr scene = dynamic_pointer_cast<Scene>(root.lock()); GlWindowPtr w = scene->getNewSharedWindow(); if (w.get() == nullptr) return; _window = w; _isInitialized = setProjectionSurface(); if (!_isInitialized) Log::get() << Log::WARNING << "Window::" << __FUNCTION__ << " - Error while creating the Window" << Log::endl; else Log::get() << Log::MESSAGE << "Window::" << __FUNCTION__ << " - Window created successfully" << Log::endl; _viewProjectionMatrix = glm::ortho(-1.f, 1.f, -1.f, 1.f); setEventsCallbacks(); registerAttributes(); showCursor(false); // Get the default window size and position glfwGetWindowPos(_window->get(), &_windowRect[0], &_windowRect[1]); glfwGetFramebufferSize(_window->get(), &_windowRect[2], &_windowRect[3]); // Create the render FBO glGetError(); glGenFramebuffers(1, &_renderFbo); setupRenderFBO(); glBindFramebuffer(GL_FRAMEBUFFER, _renderFbo); GLenum _status = glCheckFramebufferStatus(GL_FRAMEBUFFER); if (_status != GL_FRAMEBUFFER_COMPLETE) Log::get() << Log::WARNING << "Window::" << __FUNCTION__ << " - Error while initializing render framebuffer object: " << _status << Log::endl; else Log::get() << Log::MESSAGE << "Window::" << __FUNCTION__ << " - Render framebuffer object successfully initialized" << Log::endl; glBindFramebuffer(GL_FRAMEBUFFER, 0); // And the read framebuffer setupReadFBO(); }
void LessonCube::update(float dt) { g_scene->update(dt); static float rotation = 0.0f; rotation += 0.1f*dt*1000; //----------- compute mvpMatrix --------------------- GameObject* cube1 = g_scene->getRoot()->getChildByTag(Tag_Cube1); Quaternion qx, qy; qx.fromAxisAngle(Vector3(1,0,0), -rotation * 0.25f); qy.fromAxisAngle(Vector3(0,1,0), rotation); cube1->getTransform()->setRotation(qy*qx); GameObject* camera = g_scene->getCurrentCamera(); camera->getTransform()->setPosition(10*sin(degreeToRadian(rotation*2)), 0, 10*cos(degreeToRadian(rotation*2))); }
int main () { printf ("Results of material_test:\n"); try { IDriver* bullet_driver = DriverManager::FindDriver (DRIVER_NAME); if (!bullet_driver) throw xtl::format_operation_exception ("", "Can't find driver '%s'", DRIVER_NAME); ScenePtr scene (bullet_driver->CreateScene (), false); ShapePtr sphere_shape (bullet_driver->CreateSphereShape (1.f), false); RigidBodyPtr body1 (scene->CreateRigidBody (sphere_shape.get (), 1), false), body2 (scene->CreateRigidBody (sphere_shape.get (), 1), false); printf ("body 1 material friction = %.2f, body 2 material friction = %.2f\n", body1->Material ()->Friction (), body2->Material ()->Friction ()); body2->Material ()->SetFriction (0.3f); printf ("body 1 material friction = %.2f, body 2 material friction = %.2f\n", body1->Material ()->Friction (), body2->Material ()->Friction ()); MaterialPtr material (bullet_driver->CreateMaterial (), false); body1->SetMaterial (material.get ()); body2->SetMaterial (material.get ()); printf ("body 1 material friction = %.2f, body 2 material friction = %.2f\n", body1->Material ()->Friction (), body2->Material ()->Friction ()); material->SetFriction (0.25f); printf ("body 1 material friction = %.2f, body 2 material friction = %.2f\n", body1->Material ()->Friction (), body2->Material ()->Friction ()); } catch (std::exception& exception) { printf ("exception: %s\n", exception.what ()); } return 0; }
bool SceneIO::processSceneManipulationObject(rapidxml::xml_node<char>* sceneXMLNode, ScenePtr scene, const std::string& basePath ) { THROW_VR_EXCEPTION_IF(!sceneXMLNode, "NULL data in processSceneManipulationObject"); ManipulationObjectPtr o = ObjectIO::processManipulationObject(sceneXMLNode,basePath); if (!o) return false; scene->registerManipulationObject(o); return true; }
bool SceneIO::processSceneObstacle(rapidxml::xml_node<char>* sceneXMLNode, ScenePtr scene, const std::string& basePath ) { THROW_VR_EXCEPTION_IF(!sceneXMLNode, "NULL data in processSceneObstacle"); ObstaclePtr o = ObjectIO::processObstacle(sceneXMLNode,basePath); if (!o) return false; scene->registerObstacle(o); return true; }
/////////////////////////////////////////////////////////////////////////////// // Callback for when the path of a scene changes. Since the scene manager // stores the scenes by their paths, the internal list has to be updated. // void SceneManager::DocumentPathChanged( const DocumentPathChangedArgs& args ) { M_SceneSmartPtr::iterator found = m_Scenes.find( args.m_OldPath ); if ( found != m_Scenes.end() ) { // Hold a reference to the scene while we re-add it to the list, otherwise // it will get deleted. ScenePtr scene = found->second; // remove the scene m_Scenes.erase( found ); // change the path of the scene scene->SetPath( args.m_Document->GetPath() ); // re-insert w/ new path Helium::StdInsert<M_SceneSmartPtr>::Result inserted = m_Scenes.insert( M_SceneSmartPtr::value_type( scene->GetPath().Get(), scene ) ); HELIUM_ASSERT( inserted.second ); } }