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();
}