SideVerifier::SideVerifier(Ogre::SceneNode* parent, std::string name) { mGroup = parent->createChildSceneNode(name + "group"); mVerifier0 = createSceneNode(mGroup, name + "0", Ogre::Vector3(-SIDE_SIZE, -SIDE_SIZE, 0)); mVerifier1 = createSceneNode(mGroup, name + "1", Ogre::Vector3(-SIDE_SIZE, SIDE_SIZE, 0)); mVerifier2 = createSceneNode(mGroup, name + "2", Ogre::Vector3(SIDE_SIZE, -SIDE_SIZE, 0)); mVerifier3 = createSceneNode(mGroup, name + "3", Ogre::Vector3(SIDE_SIZE, SIDE_SIZE, 0)); }
//! //! Constructor of the Model2SceneNode class. //! //! \param name The name to give the new mesh node. //! \param parameterRoot A copy of the parameter tree specific for the type of the node. //! Model2SceneNode::Model2SceneNode ( const QString &name, ParameterGroup *parameterRoot ) : GeometryNode(name, parameterRoot, "SceneNode"), m_sceneNode(0), m_entity(0), m_entityContainer(0), m_oldResourceGroupName(""), m_size(1.0,1.0,1.0) { // create the mandatory vtk table input parameter - multiplicity ONE OR MORE VTKTableParameter * inputVTKTableParameter = new VTKTableParameter(m_inputVTKTableParameterName); inputVTKTableParameter->setMultiplicity(1); inputVTKTableParameter->setPinType(Parameter::PT_Input); inputVTKTableParameter->setSelfEvaluating(true); parameterRoot->addParameter(inputVTKTableParameter); connect(inputVTKTableParameter, SIGNAL(dirtied()), SLOT(processScene())); // set affections and functions addAffection("Geometry File", m_outputGeometryName); setChangeFunction("Geometry File", SLOT(geometryFileChanged())); setCommandFunction("Geometry File", SLOT(geometryFileChanged())); connect(this, SIGNAL(frameChanged(int)), SLOT(updateAll())); // set affections and functions setChangeFunction("Size", SLOT(sizeChanged())); setCommandFunction("Size", SLOT(sizeChanged())); createSceneNode(); INC_INSTANCE_COUNTER }
TerrainBlock::TerrainBlock(MapIO::BlockData &data): m_mapPosition(Ogre::Vector3(Ogre::Real(data.gridX), Ogre::Real(data.gridY), Ogre::Real(data.gridZ))), m_blockType(data.blockType), m_terrainType(data.blockTerrain) { createSceneNode(); loadContent(); }
void WorldObjectAbstract::initWorldObject(Ogre::SceneManager* m_pSceneMgr, PhysicsWrapper* physics) { createRigidBody(physics); createSceneNode(m_pSceneMgr); if(physics != NULL) attachToDynamicWorld(physics); }
//! //! Processes the node's input data to generate the node's output table. //! void Model2SceneNode::processScene() { // load the input vtk parameter VTKTableParameter * inputParameter = dynamic_cast<VTKTableParameter*>(getParameter(m_inputVTKTableParameterName)); if (!inputParameter || !inputParameter->isConnected()) return; // get the source parameter (output of source node) connected to the input parameter VTKTableParameter * sourceParameter = dynamic_cast<VTKTableParameter*>(inputParameter->getConnectedParameter()); inputParameter->setVTKTable(sourceParameter->getVTKTable()); vtkTable * xyzTable = inputParameter->getVTKTable(); if (!m_sceneNode) createSceneNode(); if (!m_entity || !xyzTable || !m_sceneNode) return; //Get columns named "NodeID", "X", "Y" and "Z" vtkIdTypeArray *colNodeId = dynamic_cast<vtkIdTypeArray*>(xyzTable->GetColumnByName("NodeId")); vtkDoubleArray *colX = dynamic_cast<vtkDoubleArray*>(xyzTable->GetColumnByName("X")); vtkDoubleArray *colY = dynamic_cast<vtkDoubleArray*>(xyzTable->GetColumnByName("Y")); vtkDoubleArray *colZ = dynamic_cast<vtkDoubleArray*>(xyzTable->GetColumnByName("Z")); destroyAllAttachedMovableObjects(m_sceneNode); destroyAllChildren(m_sceneNode); Ogre::String idPrefix(QString(m_name + ":").toStdString()); Ogre::SceneManager *sceneManager = OgreManager::getSceneManager(); for (int i=0; i<xyzTable->GetNumberOfRows(); i++) { int colIDValue = colNodeId->GetValue(i); Ogre::String nodeID(idPrefix + Ogre::StringConverter::toString(colIDValue)); // create new scene node for each item Ogre::SceneNode *sceneItem = sceneManager->createSceneNode(nodeID); // create new entity for each item Ogre::Entity *entityItem = m_entity->clone(nodeID); sceneItem->attachObject(entityItem); double x = colX->GetValue(i); double y = colY->GetValue(i); double z = colZ->GetValue(i); sceneItem->setPosition(Ogre::Real(x), Ogre::Real(y), Ogre::Real(z)); sceneItem->setScale(m_size); m_sceneNode->addChild(sceneItem); } }
void Camera::create (int iWindow, Movable *parent) { RadXML *ogrGame = RadXML::getSingletonPtr (); Ogre::SceneManager *mSceneMgr = ogrGame->getSceneManager (); camCamera = mSceneMgr->createCamera ("cam" + name); camCamera->setFocalLength (focalLength); camCamera->setNearClipDistance (nearClipDistance); camCamera->setFarClipDistance (farClipDistance); Ogre::TextureManager::getSingleton().setDefaultNumMipmaps (numMipMaps); if (enabled == true) { ogrGame->setupCamera (camCamera, bgColor); ogrGame->setCurrentCamera (camCamera); } setParent (parent); createSceneNode (camCamera, parent); }
int main(int argc, char** argv) { GLFWwindow* window = initGLWindow(); movement = new CameraMovement(window); initGL(); int width, height; glfwGetFramebufferSize(window, &width, &height); renderer.init(width, height); camera.init(width/(float)height, 60.f, .1f, 100.f); camera.setCameraProjection(PROJECTION_PERSPECTIVE); // Floor std::shared_ptr<Mesh> floorMesh = std::make_shared<Mesh>(UnitQuad::CreateUnitQuad()); floorMesh->material.diffuse = glm::vec4(0.3f, 0.6f, 0.7f, 1.0f); floorMesh->material.ambient = glm::vec4(0.01f, 0.01f, 0.01f, 1.0f); floorMesh->material.specular = glm::vec4(0.1f, 0.1f, 0.1f, 1.0f); floorMesh->material.shininess = 100.0f; std::shared_ptr<SceneNode> floor(new SceneNode); floor->init(floorMesh); floor->position = glm::vec3(0.0,-1.0, 0.0); floor->rotation = glm::rotate(glm::mat4(1.0f),-90.0f, glm::vec3(1.0, 0.0, 0.0)); floor->scale = glm::scale(glm::mat4(1.0), glm::vec3(100.0f)); LightProperties lightProperties = LightFactory::Bright(glm::vec3(1.0, 1.0, 1.0)); lightProperties.position = glm::vec4(-2.0f, 2.0f, -1.0f, 1.0); lightProperties.direction = glm::vec4(0.0, -0.1, -1.0, 0.0); std::shared_ptr<Light> light(new Light); light->properties = lightProperties; renderer.lights.push_back(light); LightProperties lightProperties1 = LightFactory::Bright(glm::vec3(1.0, 1.0, 1.0)); lightProperties1.position = glm::vec4(4.0f, 2.0f, -3.0f, 1.0); lightProperties1.direction = glm::vec4(-1.0, -0.1, 0.0, 0.0); std::shared_ptr<Light> light1(new Light); light1->properties = lightProperties1; renderer.lights.push_back(light1); std::string path(MODEL_PATH); path.append("cooldragon.off"); auto node = createSceneNode(path); node->position = glm::vec3(0.0f, 0.0f, -3.0f); renderer.nodes.push_back(node); renderer.nodes.push_back(floor); std::thread first (startGui, argc, argv); glfwSwapInterval(1); //0 to disable vsync, 1 to enable it while (!glfwWindowShouldClose(window)) { if(shouldFlipNormals) { renderer.nodes[0]->mesh->flipNormals(); shouldFlipNormals = false; } if(shouldLoadFile) { std::string path(MODEL_PATH); path.append(filename); renderer.nodes[0] = createSceneNode(path); renderer.nodes[0]->position = glm::vec3(-2.0f, -0.5f, -3.0f); gui->material = &renderer.nodes[0]->mesh->material; shouldLoadFile = false; } updateInput(window); glClearColor(0.0, 0.0, 0.0, 1.0); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); glClearColor(0.0, 0.0, 0.0, 0.0); light->properties.position = glm::translate(glm::mat4(1.0f), glm::vec3(-2.5f + cosf(glfwGetTime()), 0.5f, -0.0f)) * glm::vec4(1.0f); camera.position = movement->position; camera.target = camera.position + movement->lookatDirection; camera.update(); renderer.proj = camera.getCameraProjectionTransform(); renderer.view = camera.getCameraViewTransform(); renderer.renderScene(); glfwSwapBuffers(window); glfwPollEvents(); } delete movement; glfwDestroyWindow(window); glfwTerminate(); exit(EXIT_SUCCESS); }
void MapView::createTerrain() { unsigned int sizeX = mMap->getTerrainSize().x; unsigned int sizeZ = mMap->getTerrainSize().z; mTileX = 33; mTileZ = 33; unsigned int tileCount = ((sizeX - 1) / (mTileX - 1)) * ((sizeZ - 1) / (mTileZ - 1)); unsigned int vertexPerTile = mTileX * mTileZ; unsigned int trianglesPerTile = (mTileX - 1) * (mTileZ - 1) * 2; mMeshes.resize(tileCount); mEntities.resize(tileCount); mSceneNodes.resize(tileCount); // vertexPerTile * 3 vertices * 2 texture coordinates * 3 colours * 3 normals VertexVector vertices(vertexPerTile * 11); // trianglesPerTile * 3 indices per each triangle IndexVector indices[3] = { IndexVector(trianglesPerTile * 3 ), IndexVector(trianglesPerTile * 3 / 4), IndexVector(trianglesPerTile * 3 / 8) }; unsigned int vertexIndex, indexIndex = 0, tileIndex = 0; for (unsigned int zIndex = 0; zIndex < mTileZ - 1; ++zIndex) { for (unsigned int xIndex = 0; xIndex < mTileX - 1; ++xIndex) { indices[0][indexIndex++] = zIndex * mTileX + xIndex; indices[0][indexIndex++] = (zIndex + 1) * mTileX + xIndex; indices[0][indexIndex++] = zIndex * mTileX + xIndex + 1; indices[0][indexIndex++] = (zIndex + 1) * mTileX + xIndex; indices[0][indexIndex++] = (zIndex + 1) * mTileX + xIndex + 1; indices[0][indexIndex++] = zIndex * mTileX + xIndex + 1; } } indexIndex = 0; for (unsigned int zIndex = 0; zIndex < mTileZ - 1; zIndex += 2) { for (unsigned int xIndex = 0; xIndex < mTileX - 1; xIndex += 2) { indices[1][indexIndex++] = zIndex * mTileX + xIndex; indices[1][indexIndex++] = (zIndex + 2) * mTileX + xIndex; indices[1][indexIndex++] = zIndex * mTileX + xIndex + 2; indices[1][indexIndex++] = (zIndex + 2) * mTileX + xIndex; indices[1][indexIndex++] = (zIndex + 2) * mTileX + xIndex + 2; indices[1][indexIndex++] = zIndex * mTileX + xIndex + 2; } } indexIndex = 0; for (unsigned int zIndex = 0; zIndex < mTileZ - 1; zIndex += 4) { for (unsigned int xIndex = 0; xIndex < mTileX - 1; xIndex += 4) { indices[2][indexIndex++] = zIndex * mTileX + xIndex; indices[2][indexIndex++] = (zIndex + 4) * mTileX + xIndex; indices[2][indexIndex++] = zIndex * mTileX + xIndex + 4; indices[2][indexIndex++] = (zIndex + 4) * mTileX + xIndex; indices[2][indexIndex++] = (zIndex + 4) * mTileX + xIndex + 4; indices[2][indexIndex++] = zIndex * mTileX + xIndex + 4; } } float scaleX = mMap->getSize().x / (float)(sizeX - 1); float scaleZ = mMap->getSize().z / (float)(sizeZ - 1); for (unsigned int zTile = 0; zTile < (sizeZ - 1); zTile += (mTileZ - 1)) { for (unsigned int xTile = 0; xTile < (sizeX - 1); xTile += (mTileX - 1)) { vertexIndex = 0; for (unsigned int zVertex = zTile; zVertex < zTile + mTileZ; ++zVertex) { for (unsigned int xVertex = xTile; xVertex < xTile + mTileX; ++xVertex) { float yVertex = mMap->getTerrainData()[zVertex * sizeX + xVertex]; vertices[vertexIndex++] = (float)xVertex * scaleX; vertices[vertexIndex++] = (float)yVertex; vertices[vertexIndex++] = (float)zVertex * scaleZ; vertices[vertexIndex++] = (float)xVertex / (float)(sizeX - 1); vertices[vertexIndex++] = (float)zVertex / (float)(sizeZ - 1); vertices[vertexIndex++] = 1.0f; vertices[vertexIndex++] = 1.0f; vertices[vertexIndex++] = 1.0f; vertices[vertexIndex++] = 0.0f; vertices[vertexIndex++] = 1.0f; vertices[vertexIndex++] = 0.0f; } } std::string name = "MapView_" + Convert::ToString(mID) + "_Tile_" + Convert::ToString(tileIndex); // Create mesh. mMeshes[tileIndex] = Ogre::MeshManager::getSingleton().createManual( name, "General").get(); // Create one submesh. Ogre::SubMesh* subMesh = mMeshes[tileIndex]->createSubMesh(); // Create vertex data structure for vertices shared between submeshes. mMeshes[tileIndex]->sharedVertexData = new Ogre::VertexData(); mMeshes[tileIndex]->sharedVertexData->vertexCount = vertexPerTile; // Create declaration (memory format) of vertex data. Ogre::VertexDeclaration* decl = mMeshes[tileIndex]->sharedVertexData->vertexDeclaration; size_t offset = 0; // 1st buffer decl->addElement(0, offset, Ogre::VET_FLOAT3, Ogre::VES_POSITION); offset += Ogre::VertexElement::getTypeSize(Ogre::VET_FLOAT3); decl->addElement(0, offset, Ogre::VET_FLOAT2, Ogre::VES_TEXTURE_COORDINATES); offset += Ogre::VertexElement::getTypeSize(Ogre::VET_FLOAT2); decl->addElement(0, offset, Ogre::VET_FLOAT3, Ogre::VES_DIFFUSE); offset += Ogre::VertexElement::getTypeSize(Ogre::VET_FLOAT3); decl->addElement(0, offset, Ogre::VET_FLOAT3, Ogre::VES_NORMAL); offset += Ogre::VertexElement::getTypeSize(Ogre::VET_FLOAT3); // Allocate vertex buffer of the requested number of vertices (vertexPerTile) // and bytes per vertex (offset). Ogre::HardwareVertexBufferSharedPtr vbuf = Ogre::HardwareBufferManager::getSingleton().createVertexBuffer( offset, vertexPerTile, Ogre::HardwareBuffer::HBU_STATIC_WRITE_ONLY); // Upload the vertex data to the card vbuf->writeData(0, vbuf->getSizeInBytes(), &(vertices.front()), true); // Set vertex buffer binding so buffer 0 is bound to our vertex buffer. Ogre::VertexBufferBinding* bind = mMeshes[tileIndex]->sharedVertexData->vertexBufferBinding; bind->setBinding(0, vbuf); // Allocate index buffer of the requested number of vertices . Ogre::HardwareIndexBufferSharedPtr ibuf = Ogre::HardwareBufferManager::getSingleton(). createIndexBuffer( Ogre::HardwareIndexBuffer::IT_16BIT, trianglesPerTile * 3, Ogre::HardwareBuffer::HBU_STATIC_WRITE_ONLY); // Upload the index data to the card. ibuf->writeData(0, ibuf->getSizeInBytes(), &(indices[0].front()), true); /// Set parameters of the submesh subMesh->useSharedVertices = true; subMesh->indexData->indexBuffer = ibuf; subMesh->indexData->indexCount = indices[0].size(); subMesh->indexData->indexStart = 0; subMesh->setMaterialName("terrain"); float xMin = vertices[0]; float yMin = vertices[1]; float zMin = vertices[2]; float xMax = vertices[0]; float yMax = vertices[1]; float zMax = vertices[2]; for (unsigned int i = 0; i < vertexPerTile * 11; i += 11) { if (vertices[i ] < xMin) xMin = vertices[i ]; else if (vertices[i ] > xMax) xMax = vertices[i ]; if (vertices[i + 1] < yMin) yMin = vertices[i + 1]; else if (vertices[i + 1] > yMax) yMax = vertices[i + 1]; if (vertices[i + 2] < zMin) zMin = vertices[i + 2]; else if (vertices[i + 2] > zMax) zMax = vertices[i + 2]; } // Set bounding information (for culling). mMeshes[tileIndex]->_setBounds(Ogre::AxisAlignedBox(xMin, yMin, zMin, xMax, yMax, zMax)); mMeshes[tileIndex]->_setBoundingSphereRadius(1.0f); // Notify Mesh object that it has been loaded. mMeshes[tileIndex]->load(); // Create entity. mEntities[tileIndex] = createEntity(name, name); mEntities[tileIndex]->setCastShadows(false); mEntities[tileIndex]->setUserAny(Ogre::Any(this)); // Create scene node. mSceneNodes[tileIndex] = createSceneNode(); mSceneNodes[tileIndex]->attachObject(mEntities[tileIndex]); // Advance to next tile. tileIndex++; } } }
SceneNode* SceneManager::getRootSceneNode() { if (!mSceneGraph.root) { mSceneGraph.root = createSceneNode(kDefaultSceneNodeClass, ""); } return mSceneGraph.root; }
SceneNode* SceneManager::createChildSceneNode(const string& nodeClassName, SceneNode* parent, const string& nodeNameSuffix) { SceneNode* node = createSceneNode(nodeClassName, nodeNameSuffix); parent->addChild(node); return node; }
TerrainBlock::TerrainBlock(Ogre::Vector3 position): m_mapPosition(position), m_blockType(BlockType::Flat), m_terrainType(BlockTerrain::Normal) { createSceneNode(); loadContent(); }