C++ Object3D类代码示例

void Renderer::ImportObjFileCallback(string param)
{
	Object3D* obj = new Object3D(param);
	obj->glTranslate(ofGetWindowWidth()*0.5, ofGetWindowHeight()*0.5, 0);

	this->sceneStructure->AddElement(obj);
}

		/**
		 * Method is used to group object components.
		 * @param	object is source object.
		 * @param	vertices is other object vertices.
		 * @pram	indices is other object indices.
		 * @param	faceStatus1 is face status.
		 * @param	faceStatus2 is face status.
		 */
		void GeoModifier::groupObjectComponents(Object3D& object, VertexSet& vertices, IntSet& indices, int faceStatus1, int faceStatus2)
		{
			//for each face..
			for(int i = 0; i < object.getNumFaces(); ++i)
			{
				Face& face = *(object.getFace(i));

				if(face.getStatus()==faceStatus1 || face.getStatus()==faceStatus2)
				{
					VertexPointerSet faceVerts;
					faceVerts.add(face.v1);
					faceVerts.add(face.v2);
					faceVerts.add(face.v3);

					for(int j=0;j<faceVerts.length();j++)
					{
						if(vertices.contains(faceVerts[j]))
							indices.push_back(vertices.indexOf(faceVerts[j]));
						else
						{
							indices.push_back(vertices.length());
							vertices.AddVertex(*faceVerts[j]);
						}
					}
				}
			}
		}

void addSineCosine()
{
    mat4 Model = translate(mat4(1.0f), vec3(0.0f, -10.0f, 0.0f));

    vec2 x[] =
    {
        vec2(-20.0f, -20.0f), vec2(-20.0f, 20.0f), vec2(20.0f, 20.0f),
        vec2(-20.0f, -20.0f), vec2(20.0f, 20.0f), vec2(20.0f, -20.0f)
    };
    Mesh *mesh = new Mesh();
    FunctionGraph graph(new SineCosine());
    graph.generateGraph(x, 7, -1000.0f, mesh);
    graph.generateGraph(x+3, 7, -1000.0f, mesh);

    mesh->setOrientation(GL_CCW);
    mesh->applyIndexing();
    mesh->makeUpUVData();

    const Material mat(vec4(1.0f, 0.2f, 0.2f, 1.0f), vec4(0.1f, 0.1f, 0.1f, 1.0f), vec4(0.7f, 0.7f, 0.7f, 1.0f), 128.0f);

    Object3D *obj = new Object3D(mesh, mat);
    obj->setModelMatrix(Model);
    junk.push_back(obj);
    Engine::addToDisplayList(junk.back());

    //Engine::addToDisplayList(new NormalDrawer(*mesh, Model));
}

void GraphicsCore::UpdateObjectValues(Object3D object)
{
	vec3 up(0.0f, 1.0f, 0.0f);
	
    mat4 Projection = glm::perspective(fov, float(windowWidth) / (float)windowHeight, 0.1f, 200.f); 	
    mat4 Model = glm::translate(object.GetWorldPos());
	mat4 viewMatrix = mCam.GetRotationMatrix() * glm::lookAt(mEye, mTarget, up);
    mat4 ModelView =  viewMatrix * Model;   	
    mat4 MVP = Projection * ModelView;

	mat3 normalMatrix = glm::transpose(glm::inverse(mat3(ModelView)));
	
	uint shaderProgHandle = object.GetShaderID();

	uint location = glGetUniformLocation(shaderProgHandle, "NormalMatrix");	//gets the UniformLocation from shader.vertex
	if( location >= 0 ){ glUniformMatrix3fv(location, 1, GL_FALSE, &normalMatrix[0][0]); }

		location = glGetUniformLocation(shaderProgHandle, "ProjectionMatrix");	//gets the UniformLocation from shader.vertex
	if( location >= 0 ){ glUniformMatrix4fv(location, 1, GL_FALSE, &Projection[0][0]); }

	location = glGetUniformLocation(shaderProgHandle, "ViewMatrix");	//gets the UniformLocation from shader.vertex
	if( location >= 0 ){ glUniformMatrix4fv(location, 1, GL_FALSE, &viewMatrix[0][0]); }

	location = glGetUniformLocation(shaderProgHandle, "ModelViewMatrix");	//gets the UniformLocation from shader.vertex
	if( location >= 0 ){ glUniformMatrix4fv(location, 1, GL_FALSE, &ModelView[0][0]); }

	location = glGetUniformLocation(shaderProgHandle, "MVP");	//gets the UniformLocation from shader.vertex
	if( location >= 0 ){ glUniformMatrix4fv(location, 1, GL_FALSE, &MVP[0][0]); }

}

void DualQuaternionTransformationTest::resetTransformation() {
    Object3D o;
    o.setTransformation(DualQuaternion::rotation(Deg(17.0f), Vector3::xAxis()));
    CORRADE_VERIFY(o.transformationMatrix() != Matrix4());
    o.resetTransformation();
    CORRADE_COMPARE(o.transformationMatrix(), Matrix4());
}

void SceneTest::transformation() {
    Scene3D scene;

    Object3D* scenePointer = &scene;
    scenePointer->setTransformation(Matrix4::translation({1.0f, 1.0f, 1.0f}));
    CORRADE_COMPARE(scene.transformation(), Matrix4());
}

void RigidMatrixTransformation3DTest::resetTransformation() {
    Object3D o;
    o.setTransformation(Matrix4::rotationX(Deg(17.0f)));
    CORRADE_VERIFY(o.transformationMatrix() != Matrix4());
    o.resetTransformation();
    CORRADE_COMPARE(o.transformationMatrix(), Matrix4());
}

 virtual void visit(Object3D &theNode)
 {
     if(theNode.enabled() || !visit_only_enabled())
     {
         m_transform_stack.push(m_transform_stack.top() * theNode.transform());
         for (Object3DPtr &child : theNode.children()){child->accept(*this);}
         m_transform_stack.pop();
     }
 }

Vector3 CSGUnionIntersection::normal() {

    Vector3 local = iheap.intersection()->normal();

    Object3D* oc = static_cast<Object3D*>( iheap.object() );
    oc->transformNormalOut(local);

    return local;

}

void SceneTest::parent() {
    Scene3D scene;

    /* Scene parent cannot be changed */
    Object3D* scenePointer = &scene;
    Object3D object;
    scenePointer->setParent(&object);
    CORRADE_VERIFY(scene.parent() == nullptr);
    CORRADE_VERIFY(scene.children().isEmpty());
    CORRADE_VERIFY(object.children().isEmpty());
}

void Accelerator::init(const vector<Object3D*>& geometry, const vector<const Plane*>& scene_planes)
{
  for(unsigned int i = 0; i < geometry.size(); ++i)
  {
    Object3D* obj = geometry[i];
    unsigned int no_of_prims = primitives.size();
    primitives.resize(no_of_prims + obj->get_no_of_primitives());
    for(unsigned int j = 0; j < obj->get_no_of_primitives(); ++j)
      primitives[j + no_of_prims] = new AccObj(obj, j);
  }
  planes = scene_planes;
}

Object3D::Object3D(const Object3D& obj)
    : QObject(obj.parent()), m_center(obj.center()),
      m_translation(obj.translation()), m_rotations(obj.rotations()),
      m_interactiveQuartenion(obj.interactiveQuartenion()),
      m_slices(obj.slices()), m_stacks(obj.stacks()),
      m_texture(obj.texture()), m_inputType(obj.inputType())

{
}

void DrawObject3DAmbient ( std::string name, vec2 centre, float scale, float angle, float bank )
{
	Object3D* obj = GetObject3D(name);
	EnableTexturing();
	DisableBlending();
	obj->BindTextures();
	//glUniform3f(UniformLocation("Ambient"), ambient.red(), ambient.green(), ambient.blue());
	SetShader("3DBase");
	glUniform1f(UniformLocation("specularScale"), obj->SpecularScale());
	glUniform1f(UniformLocation("shininess"), obj->Shininess());
	Matrices::SetViewMatrix(matrix2x3::Translate(centre));
	obj->Draw(scale, angle, bank);
}

Intersection* CSGIntersect::intersectLocalLimitedTime(const Ray &shoot, DBL tmax) const {

    assert(isclosed);
    stat.eval();
    CSGIntersectIntersection* i = 0;

    // fill Array with initial values
    for(unsigned int j=0; j<objects->listsize; j++) {

        Object3D* current = static_cast<Object3D*>(objects->list[j]);
        
        double t;
        if ( (t=current->intersectBounding(shoot,tmax))!=INTERSECTION_TIME_EPSILON ) {

            if (t > INTERSECTION_TIME_EPSILON) {
                // boundingbox hit
                if (i == 0)  i = new CSGIntersectIntersection(this,shoot,tmax);
                i->put(0,t,current);
                continue;
            }

        } else {

            // there is no boundingbox or we are inside
            Intersection* ci = current->intersectLimitedTime(shoot,tmax);

            if (ci) {
                if (i == 0)  i = new CSGIntersectIntersection(this,shoot,tmax);
                i->put(ci,ci->currentTime(),current);
                continue;
            }

        }

        // no intersection with that object, test if we are inside
        Vector3 testpoint = Vector3::add( shoot.getOrigin(), shoot.getDirection() );
        if (static_cast<const Object3D*>(current)->isInsideAtBounded(testpoint)==false) {delete(i); return 0;}
        
    }

    if (i) {
        // build up structure 
        if (i->init() == false) {delete(i); return 0;}
        stat.success();
    }
    
    return i;

}

//temporary function
void GraphicsCore::UpdateLightValues(Object3D object)
{
	//lightinfos
	vec3 ambient = vec3(0.4, 0.4, 0.4);

	//material
	vec3 ambientRefl = vec3(1.0f, 1.0f, 1.0f);	
	vec3 diffuseRefl = vec3(0.9f, 0.9f, 0.9f);	
	vec3 specularRefl = vec3(0.4f, 0.4f, 0.4f);
	float shininess = 2.0;

	uint shaderProgHandle = object.GetShaderID();
	
	uint location = glGetUniformLocation(shaderProgHandle, "Light.La");	//gets the UniformLocation from shader.vertex
	glUniform3fv(location, 1, &ambient[0]);

	//-------------------
	location = glGetUniformLocation(shaderProgHandle, "Material.Ka");	//gets the UniformLocation from shader.vertex
	glUniform3fv(location, 1, &ambientRefl[0]);

	location = glGetUniformLocation(shaderProgHandle, "Material.Kd");	//gets the UniformLocation from shader.vertex
	glUniform3fv(location, 1, &diffuseRefl[0]);

	location = glGetUniformLocation(shaderProgHandle, "Material.Ks");	//gets the UniformLocation from shader.vertex
	glUniform3fv(location, 1, &specularRefl[0]);

	location = glGetUniformLocation(shaderProgHandle, "Material.Shininess");	//gets the UniformLocation from shader.vertex
	glUniform1fv(location, 1, &shininess);
	
}