C++ createMesh函数代码示例

void createInnerWalls(){
	// create large room walls
	scale.x = 5.0f;   scale.y = 4.0f; scale.z = 0.5f;
	trans.x = 11.0f;    trans.y = 0.0f; trans.z = 0.0f;
	innerWalls[0] = createMesh(scale, trans, wallHeight, 1); // left wall

	scale.x = 5.0f;   scale.y = 4.0f; scale.z = 0.5f;
	trans.x = 1.0f;    trans.y = 0.0f; trans.z = 0.0f;
	innerWalls[1] = createMesh(scale, trans, wallHeight, 1); // left wall

	scale.x = 3.0f;   scale.y = 4.0f; scale.z = 0.5f;
	trans.x = -13.0f; trans.y = 0.0f;  trans.z = 0.0f;
	innerWalls[2] = createMesh(scale, trans, wallHeight, 1); // front wall

	// create small room walls
	scale.x = 0.5f;   scale.y = 4.0f; scale.z = 3.0f;
	trans.x = 0.0f;  trans.y = 0.0f; trans.z = -13.0f;
	innerWalls[3] = createMesh(scale, trans, wallHeight, 1); // right wall

	scale.x = 0.5f;   scale.y = 4.0f; scale.z = 3.0f;
	trans.x = 0.0f;  trans.y = 0.0f; trans.z = -3.0f;
	innerWalls[4] = createMesh(scale, trans, wallHeight, 1); // right wall

	numInnerWalls = 5;
}

void fj::SurfaceConstruction::execute(const fj::Scalar &timestep, fj::ParticleSystem *particleSystem)
{
    for (auto& isosurface : m_surfaces)
    {
        isosurface.Mesh = createMesh(timestep, particleSystem, isosurface.getLevel());
    }
}

MStatus animCube::compute(const MPlug& plug, MDataBlock& data)

{
	MStatus returnStatus;

	if (plug == outputMesh) {
		/* Get time */
		MDataHandle timeData = data.inputValue( time, &returnStatus ); 
		McheckErr(returnStatus, "Error getting time data handle\n");
		MTime time = timeData.asTime();

		/* Get output object */

		MDataHandle outputHandle = data.outputValue(outputMesh, &returnStatus);
		McheckErr(returnStatus, "ERROR getting polygon data handle\n");

		MFnMeshData dataCreator;
		MObject newOutputData = dataCreator.create(&returnStatus);
		McheckErr(returnStatus, "ERROR creating outputData");

		createMesh(time, newOutputData, returnStatus);
		McheckErr(returnStatus, "ERROR creating new Cube");

		outputHandle.set(newOutputData);
		data.setClean( plug );
	} else
		return MS::kUnknownParameter;

	return MS::kSuccess;
}

const Mesh* MeshManager::createIcosahedron(std::string id)
{
    if(exists(id))
    {
        Logger::getInstance()->logWarning("MeshManager:: Mesh with id \"" + id + "\" already exists!");
        return nullptr;
    }

    // Code from OpenGL Programming Guide, Version 3
    const float x = 0.525731112119133606;
    const float z = 0.850650808352039932;

    glm::vec3 vertices[12] = {
        {-x, 0.0, z}, {x, 0.0, z}, {-x, 0.0, -z}, {x, 0.0, -z},
        {0.0, z, x}, {0.0, z, -x}, {0.0, -z, x}, {0.0, -z, -x},
        {z, x, 0.0}, {-z, x, 0.0}, {z, -x, 0.0}, {-z, -x, 0.0}
    };


    GLuint indices[20][3] = {
        {1, 4, 0}, {4, 9, 0}, {4, 5, 9}, {8, 5, 4},	{1, 8, 4},
        {1, 10, 8}, {10, 3, 8}, {8, 3, 5}, {3, 2, 5}, {3, 7, 2},
        {3, 10, 7}, {10, 6, 7}, {6, 11, 7}, {6, 0, 11},	{6, 1, 0},
        {10, 1, 6}, {11, 0, 9}, {2, 11, 9}, {5, 2, 9}, {11, 2, 7},
    };

    // Create the mesh
    const Mesh* mesh = createMesh(id, 12, vertices, 60, &indices[0][0]);
    return  mesh;
}

ResourceId CResourceManager::loadMesh(const std::string& file)
{
    auto entry = m_meshFiles.find(file);
    if (entry != m_meshFiles.end())
    {
        return entry->second;
    }

    // Load mesh
	SMesh mesh;
	if (!load(file, mesh))
	{
		LOG_ERROR("Failed to load mesh from file %s.", file.c_str());
		return invalidResource;
	}

    // Create mesh resource
    ResourceId meshId = createMesh(mesh.m_vertices, mesh.m_indices, mesh.m_normals, mesh.m_uvs, mesh.m_type);
    if (meshId == invalidResource)
    {
        LOG_ERROR("Failed to create mesh resource id from file %s.", file.c_str());
        return invalidResource;
    }
    m_meshFiles[file] = meshId;
    return meshId;
}

Mesh* HUDImageRenderer::getMesh(const G3MRenderContext* rc) {
  if (_mesh == NULL) {
    if (!_creatingMesh) {
      if (_image == NULL) {
        _creatingMesh = true;

        const Camera* camera = rc->getCurrentCamera();

        const int width  = camera->getWidth();
        const int height = camera->getHeight();

        _imageFactory->create(rc,
                              width, height,
                              new HUDImageRenderer::ImageListener(this),
                              true);
      }
    }

    if (_image != NULL) {
      _mesh = createMesh(rc);
    }
  }
  
  return _mesh;
}

void StCvOpDistort::setup(){
    gui = new ofxUICanvas();
    gui->init(212, 10, 200, 200);
    gui->addSpacer();
    gui->addLabel("OPTICAL PARTICLE");
    gui->addSpacer();
    gui->addSlider("PYR SCALE", 0, 0.99, 0.5);
    gui->addIntSlider("LEVELS", 1, 10, 5);
    gui->addIntSlider("WIN SIZE", 1, 100, 30);
    gui->addIntSlider("ITERATION", 1, 20, 2);
    gui->addToggle("GAUSS", false);
    gui->addSpacer();
    gui->addSlider("THRESH", 0, 2.0, 1.0);
    gui->addIntSlider("SKIP", 1, 10, 1);
    gui->addSlider("TOP SHIFT", 0, 100.0, 50.0);
    gui->addSpacer();
    gui->addSlider("HUE", 0, 2.0, 1.0);
    gui->addSlider("SAT", 0, 2.0, 1.0);
    gui->addSlider("BR", 0, 2.0, 1.0);
    gui->addSpacer();
    gui->addButton("SAVE SETTINGS", false);
    gui->loadSettings("StCvOpDistort.xml");
    gui->autoSizeToFitWidgets();
    gui->setVisible(false);
    ofAddListener(gui->newGUIEvent,this,&StCvOpDistort::guiEvent);
    
    app = ((ofApp*)ofGetAppPtr());
    
    createMesh();
}

//initialise the display settings
void myInit()
{
    createMesh();
    generateWinterMesh();
    generateFallMesh();
    generateSummerMesh();
    generateSpringMesh();
	produceTrees_spring();
	produceTrees_summer();
	produceTrees_autumn();
	produceTrees_winter();
  generateCloud();
	drawTrees();
    GLfloat lightIntensity[] = { 0.8, 0.8, 0.8, 1.0f};
	GLfloat lightIntensity2[] = { 0.8, 0.8, 0.8, 1.0f };
    GLfloat lightPosition[] = {0.0f, 1.0f, 0.0f, 0.0f};
	GLfloat lightPosition2[] = { 0.0f, -1.0f, 0.0f, 0.0f };
    glLightfv(GL_LIGHT0, GL_POSITION, lightPosition);
    glLightfv(GL_LIGHT0, GL_AMBIENT, lightIntensity);
	glLightfv(GL_LIGHT1, GL_POSITION, lightPosition2);
	glLightfv(GL_LIGHT1, GL_AMBIENT, lightIntensity2);
    Point3 eye, look;
    Vector3 up;
    eye.set(1,1,1); //set the eye location
    look.set(0,0,0); //set the look at coord
    up.set(0,1,0); //specify the up vector
    cam.set(eye, look, up); // make the initial camera
    cam.slide(0,0, 1.5);
    cam.setShape(30.0f, 1.0f, 0.5f, 50.0f);
}

void hapticsLoop(void* a_pUserData)
{
    if (create_mesh_flag == 1)
    {
        createMesh();
        create_mesh_flag = 0;
    }

    syncPoses();
    cursor->computeGlobalPositions(1);

    // read the position of the haptic device
    cursor->updatePose();

    // compute forces between the cursor and the environment
    cursor->computeForces();

    // send forces to haptic device
    cursor->applyForces();

    inContact = -1;
    for (unsigned int i=0; i<cursor->m_pointForceAlgos.size(); i++)
    {
        cProxyPointForceAlgo* cur_proxy = dynamic_cast<cProxyPointForceAlgo*>(cursor->m_pointForceAlgos[i]);
        if ((cur_proxy != NULL) && (cur_proxy->getContactObject() != NULL)) 
        {      
            lastContactPoint = cur_proxy->getContactPoint();
            lastForce = cursor->m_lastComputedGlobalForce;
            inContact = i;
            break;
        }
    }
    
}

void Shape2D::update()
{
    if (_isMeshDirty)
    {
        createMesh();
    }
}

void StFftSphereRibbon::setup(){
    gui = new ofxUICanvas();
    gui->init(212, 10, 200, 200);
    gui->addSpacer();
    gui->addLabel("STRIPE SPHERE");
    gui->addSpacer();
    gui->addSlider("NOISE SCALE", 0.0, 5.0, 1.0);
    gui->addSlider("SHIFT SPEED", 0.0, 2.0, 1.0);
    gui->addSlider("INTERPORATION", 0.0, 1.0, 0.2);
    gui->addSlider("RIBBON WIDTH", 0.0, 10.0, 4.0);
    gui->addSlider("ZOOM", 0.0, 3.0, 1.0);
    gui->addSpacer();
    gui->addSlider("HUE", 0, 2.0, 1.0);
    gui->addSlider("SAT", 0, 2.0, 1.0);
    gui->addSlider("BR", 0, 2.0, 1.0);
    gui->addSpacer();
    gui->addButton("SAVE SETTINGS", false);
    gui->loadSettings("StFftSphereRibbon.xml");
    gui->autoSizeToFitWidgets();
    gui->setVisible(false);
    ofAddListener(gui->newGUIEvent,this,&StFftSphereRibbon::guiEvent);
    app = ((ofApp*)ofGetAppPtr());
    
    post.init(app->drawFbo->width, app->drawFbo->height);
    post.createPass<BloomPass>()->setEnabled(true);

    createMesh();
}

void Object::create()
{
  clearObject();

  scale_.x = bounding_box_lwh_.x;
  scale_.y = bounding_box_lwh_.y;
  scale_.z = bounding_box_lwh_.z;

  object_.header.frame_id = frame_id_;
  object_.name = name_;
  //object_.description = description_;
  object_.pose = pose_;
  object_.scale = maxScale(scale_);

  createMesh();

  control_.name = "object_control";
  control_.interaction_mode = InteractiveMarkerControl::BUTTON;
  control_.always_visible = true;
  control_.markers.push_back(mesh_);

  object_.controls.clear();
  object_.controls.push_back(control_);

  if (scale_.x != 0.0f && scale_.y != 0.0f && scale_.z != 0.0f)
    BoundingBox::createBoundingBoxControl(0.0f, 0.0f, 0.0f);

  createMenu();
}

// -------------------------------------------------------------------
//	Set a new material definition as the current material.
void ObjFileParser::getNewMaterial()
{
	m_DataIt = getNextToken<DataArrayIt>(m_DataIt, m_DataItEnd);
	m_DataIt = getNextWord<DataArrayIt>(m_DataIt, m_DataItEnd);
    if( m_DataIt == m_DataItEnd ) {
        return;
    }

	char *pStart = &(*m_DataIt);
	std::string strMat( pStart, *m_DataIt );
    while( m_DataIt != m_DataItEnd && isSeparator( *m_DataIt ) ) {
        ++m_DataIt;
    }
	std::map<std::string, ObjFile::Material*>::iterator it = m_pModel->m_MaterialMap.find( strMat );
	if ( it == m_pModel->m_MaterialMap.end() )
	{
		// Show a warning, if material was not found
		DefaultLogger::get()->warn("OBJ: Unsupported material requested: " + strMat);
		m_pModel->m_pCurrentMaterial = m_pModel->m_pDefaultMaterial;
	}
	else
	{
		// Set new material
		if ( needsNewMesh( strMat ) )
		{
			createMesh();	
		}
		m_pModel->m_pCurrentMesh->m_uiMaterialIndex = getMaterialIndex( strMat );
	}

	m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine );
}

void AwarenessVisualizer::buildVisualizationForAllTiles()
{
	std::function<void(unsigned int, dtTileCachePolyMesh&, float* origin, float cellsize, float cellheight, dtTileCacheLayer& layer)> processor = [this](unsigned int tileRef, dtTileCachePolyMesh& pmesh, float* origin, float cellsize, float cellheight, dtTileCacheLayer& layer) {
		createMesh(tileRef, pmesh, origin, cellsize, cellheight, layer);
	};

	mAwareness.processAllTiles(processor);
}

Icosahedron::Icosahedron( string iName, real ir, const Material& mat ) 
{
  r = ir ;
  name = iName ;
  material = mat ;

  createMesh( defaultMeshType, defaultVertexType ) ;
}