Esempio n. 1
0
void OpenGLWidget::setSurfaceMeshToRender(const PolyVox::SurfaceMesh<PositionMaterialNormal>& surfaceMesh)
{
	if((surfaceMesh.getNoOfIndices() == 0) || (surfaceMesh.getNoOfVertices() == 0))
	{
		//We don't have a valid mesh
		return;
	}

	//Convienient access to the vertices and indices
	const vector<uint32_t>& vecIndices = surfaceMesh.getIndices();
	const vector<PositionMaterialNormal>& vecVertices = surfaceMesh.getVertices();

	//Build an OpenGL index buffer
	glGenBuffers(1, &indexBuffer);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer);
	const GLvoid* pIndices = static_cast<const GLvoid*>(&(vecIndices[0]));		
	glBufferData(GL_ELEMENT_ARRAY_BUFFER, vecIndices.size() * sizeof(uint32_t), pIndices, GL_STATIC_DRAW);

	//Build an OpenGL vertex buffer
	glGenBuffers(1, &vertexBuffer);
	glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
	const GLvoid* pVertices = static_cast<const GLvoid*>(&(vecVertices[0]));	
	glBufferData(GL_ARRAY_BUFFER, vecVertices.size() * sizeof(PositionMaterialNormal), pVertices, GL_STATIC_DRAW);

	m_uBeginIndex = 0;
	m_uEndIndex = vecIndices.size();
	noOfIndices = surfaceMesh.getNoOfIndices();
}
Esempio n. 2
0
void VoxelTerrain::mesh()
{
  PolyVox::SurfaceMesh<PolyVox::PositionMaterialNormal> mesh;

  PolyVox::Region region(PolyVox::Vector3DInt32(0,0,0),
                         PolyVox::Vector3DInt32(120, 60, 120));
                         //PolyVox::Vector3DInt32(120, 130, 120));

  std::cout << "Begin extracting surface." << std::endl;
  //PolyVox::MarchingCubesSurfaceExtractor<PolyVox::LargeVolume<BYTE> >
    PolyVox::CubicSurfaceExtractorWithNormals<PolyVox::LargeVolume<BYTE> >
    surface_extractor(mVolumeData,
                      region,
                      &mesh);
  surface_extractor.execute();
  std::cout << "Done extracting surface." << std::endl;

  begin("Terrain", Ogre::RenderOperation::OT_TRIANGLE_LIST);
  {
    const std::vector<PolyVox::PositionMaterialNormal>& vecVertices =
      mesh.getVertices();
    const std::vector<uint32_t>& vecIndices = mesh.getIndices();
    unsigned int uLodLevel = 0;
    int beginIndex = mesh.m_vecLodRecords[uLodLevel].beginIndex;
    int endIndex = mesh.m_vecLodRecords[uLodLevel].endIndex;

    for(int index = beginIndex; index < endIndex; ++index) {
      const PolyVox::PositionMaterialNormal& vertex =
        vecVertices[vecIndices[index]];
      const PolyVox::Vector3DFloat& v3dVertexPos = vertex.getPosition();
      const PolyVox::Vector3DFloat& v3dVertexNormal = vertex.getNormal();
      const PolyVox::Vector3DFloat v3dFinalVertexPos =
        v3dVertexPos +
        static_cast<PolyVox::Vector3DFloat>(mesh.m_Region.getLowerCorner());
      position(v3dFinalVertexPos.getX(), v3dFinalVertexPos.getY(), v3dFinalVertexPos.getZ());
      normal(v3dVertexNormal.getX(), v3dVertexNormal.getY(), v3dVertexNormal.getZ());
      //colour(1, 0, 0, 0.5);
      textureCoord(v3dFinalVertexPos.getX()/4.0f, 
                   v3dFinalVertexPos.getY()/4.0f, 
                   v3dFinalVertexPos.getZ()/4.0f);
    }
  }
  end();
}
Esempio n. 3
0
// Called when the plugin is loaded.
void create()
{
   // Load Shader
   Graphics::ShaderAsset* shaderAsset = Link.Graphics.getShaderAsset("PolyVox:renderShader");
   if (shaderAsset)
      mShader = shaderAsset->getProgram();

   // Generate polyvox sphere.
   createSphereInVolume(volData, 30);
   PolyVox::SurfaceMesh<PolyVox::PositionMaterialNormal> surfaceMesh;
   PolyVox::CubicSurfaceExtractorWithNormals< PolyVox::SimpleVolume<U8> > surfaceExtractor(&volData, volData.getEnclosingRegion(), &surfaceMesh);
   surfaceExtractor.execute();

   // Verts
   const std::vector<PolyVox::PositionMaterialNormal>& vecVertices = surfaceMesh.getVertices();
   mVerts = new PosUVNormalVertex[vecVertices.size()];
   for (U32 i = 0; i < vecVertices.size(); ++i)
   {
      mVerts[mVertCount].m_x = vecVertices[i].position.getX();
      mVerts[mVertCount].m_y = vecVertices[i].position.getY();
      mVerts[mVertCount].m_z = vecVertices[i].position.getZ();

      mVerts[mVertCount].m_u = 0.0f;
      mVerts[mVertCount].m_v = 0.0f;

      mVerts[mVertCount].m_normal_x = vecVertices[i].normal.getX();
      mVerts[mVertCount].m_normal_y = vecVertices[i].normal.getY();
      mVerts[mVertCount].m_normal_z = vecVertices[i].normal.getZ();
      mVertCount++;
   }

   // Indices
   const std::vector<U32>& vecIndices = surfaceMesh.getIndices();
   mIndices = new U32[vecIndices.size()];
   for (U32 i = 0; i < vecIndices.size(); ++i)
   {
      mIndices[mIndexCount] = vecIndices[mIndexCount];
      mIndexCount++;
   }

   refresh();
}
Esempio n. 4
0
void ofxPolyvox::polyvoxToOfMesh(const PolyVox::SurfaceMesh<PositionMaterialNormal>& surfaceMesh, ofMesh& polyvxToOfMesh, bool setColor){

    //Convienient access to the vertices and indices
	const vector<uint32_t>& vecIndices = surfaceMesh.getIndices();
	const vector<PositionMaterialNormal>& vecVertices = surfaceMesh.getVertices();//surfaceMesh.getRawVertexData();

	ofIndexType ofVecIndices;
	const void* pIndices = static_cast<const void*>(&(vecIndices[0]));

	int* indices = (int*)pIndices;

    vector<int> indx;


     for (int i = 0; i < surfaceMesh.getNoOfIndices(); i++ ){

     indx.push_back(indices[i]);
     //cout << "indices:" << indices[i] << endl;
    polyvxToOfMesh.addIndex(indx[i]);
     }

	ofLog(OF_LOG_NOTICE, "ofMesh: number of indices is %d", polyvxToOfMesh.getNumIndices());

    ofVec3f ofVecVertices;


     for (int i = 0; i < surfaceMesh.getNoOfVertices(); i++ ){


    PositionMaterialNormal vert0 = vecVertices[i];


    ofVecVertices = ofVec3f(vert0.getPosition().getX(),vert0.getPosition().getY(),vert0.getPosition().getZ());

    polyvxToOfMesh.addVertex(ofVecVertices);

    }

	 ofLog(OF_LOG_NOTICE, "ofMesh: number of vertices is %d", polyvxToOfMesh.getNumVertices());

    ofVec3f ofVecNormals;

    for (int i = 0; i < surfaceMesh.getNoOfVertices(); i++ ){


    PositionMaterialNormal vert0 = vecVertices[i];


    ofVecNormals = ofVec3f(vert0.getNormal().getX(),vert0.getNormal().getY(),vert0.getNormal().getZ());

    polyvxToOfMesh.addNormal(ofVecNormals);

    }

	ofLog(OF_LOG_NOTICE, "ofMesh: number of normals is %d", polyvxToOfMesh.getNumNormals());


    if(setColor){

        for (int i = 0; i < surfaceMesh.getNoOfVertices(); i++ ){

        PositionMaterialNormal vert0 = vecVertices[i];

        uint8_t material = static_cast<uint8_t>(vert0.getMaterial() + 0.5);

        //cout << "material:" << int(material) << endl;

        ofFloatColor colour = convertMaterialIDToColour(material);

        //cout << colour << endl;

        polyvxToOfMesh.addColor(colour);

        bool col = polyvxToOfMesh.hasColors();

        //cout << "hasColors:" << col << endl;
        }

    }

}