コード例 #1
0
ファイル: RayModel.cpp プロジェクト: mhdsedighi/SOFA
void RayModel::computeBoundingTree(int maxDepth)
{
    CubeModel* cubeModel = createPrevious<CubeModel>();

    if (!isMoving() && !cubeModel->empty()) return; // No need to recompute BBox if immobile

    Vector3 minElem, maxElem;

    cubeModel->resize(size);
    if (!empty())
    {
        for (int i=0; i<size; i++)
        {
            Ray r(this, i);
            const Vector3& o = r.origin();
            const Vector3& d = r.direction();
            const SReal l = r.l();
            for (int c=0; c<3; c++)
            {
                if (d[c]<0)
                {
                    minElem[c] = o[c] + d[c]*l;
                    maxElem[c] = o[c];
                }
                else
                {
                    minElem[c] = o[c];
                    maxElem[c] = o[c] + d[c]*l;
                }
            }
            cubeModel->setParentOf(i, minElem, maxElem);
        }
        cubeModel->computeBoundingTree(maxDepth);
    }

}
コード例 #2
0
ファイル: PlaneModel.cpp プロジェクト: ruttyj/GraphicsAhoy
void PlaneModel::MakeRudder(){
	


	//########################################################################################

	//Rudder
	GroupModel* rudder = new GroupModel();
	vec3 rudderSize = vec3(0.07f,1.15f, 1.0f);
	vec3 rudderColor = vec3(1,0,0);
	if(1){//Right
		GroupModel* group = new GroupModel();
			CubeModel* model = new CubeModel(rudderColor);
			model->SetPosition(vec3(0.0f,0.5f,-2.0f));
			model->SetRotation(vec3(1.0f,0.0f,0.0f), -30.0f);	
			model->SetScaling(rudderSize);
		group->AddChild(model);
		group->SetRotation(vec3(0,0,1), 45.0f);
		rudder->AddChild(group);
	}
	if(1){//Left
		GroupModel* group = new GroupModel();
			CubeModel* model = new CubeModel(rudderColor);
			model->SetPosition(vec3(0.0f,0.5f,-2.0f));
			model->SetRotation(vec3(1.0f,0.0f,0.0f), -30.0f);	
			model->SetScaling(rudderSize);
		group->AddChild(model);
		group->SetRotation(vec3(0,0,1), -45.0f);
		rudder->AddChild(group);
	}
	rudder->SetRotation(vec3(0.0f,0.0f,1.0f), 0.0f);
	AddChild("rudder",rudder);
	//*////////////////////////////////////////////////////
	//$#%^$#$^Y$T#%^&%$#W$^&$#%^&%$#%^&&%^$#$%^&%%$#$$^%#$%
	//Model Testing :: Transforms on multiple layers
	


	//########################################################################################
}
コード例 #3
0
ファイル: CubeModel.cpp プロジェクト: tanjil/COMP371
void CubeModel::handleBeginContact(q3Box * box){
	if (mBreakable){
		
		std::cout << "Breakable model contact" << std::endl;
		
		// Queue this object's removal
		World::GetInstance()->RemoveModel(this);

		// break into 8 evenly sized pieces
		vec3 size = mScaling / 2.0f;
		vec3 pos = size / 2.0f;
		for (int x = 0; x < 2; ++x){
			for (int y = 0; y < 2; ++y){
				for (int z = 0; z < 2; ++z){
					CubeModel *shard = new CubeModel();
					shard->SetPosition(mPosition +
						glm::vec3(
							pos.x * (x ? 1 : -1),
							pos.y * (y ? 1 : -1),
							pos.z * (z ? 1 : -1)
						));
					shard->SetScaling(size);
					shard->SetPhysicsType(Dynamic);
					shard->SetBreakable(false);

					auto body = new q3BodyDef(shard->GetBodyDef());
					auto box = new q3BoxDef(shard->GetBoxDef());

					auto transform = mBody->GetTransform();
					transform.position = { 0, 0, 0 };

					box->Set(transform, g2q(size));

					World::GetInstance()->AddModel(shard, body, box);
				}
			}
		}

	}
}
コード例 #4
0
ファイル: World.cpp プロジェクト: tawjaw/IslandAdventures
void World::LoadScene(const char * scene_path)
{
	// Using case-insensitive strings and streams for easier parsing
	ci_ifstream input;
	input.open(scene_path, ios::in);

	// Invalid file
	if(input.fail() )
	{	 
		fprintf(stderr, "Error loading file: %s\n", scene_path);
		getchar();
		exit(-1);
	}

	ci_string item;
	while( std::getline( input, item, '[' ) )   
	{
        ci_istringstream iss( item );

		ci_string result;
		if( std::getline( iss, result, ']') )
		{
			if( result == "cube" )
			{
				// Box attributes
				CubeModel* cube = new CubeModel();
				cube->Load(iss);
				mModel.push_back(cube);
			}
            else if( result == "sphere" )
            {
                SphereModel* sphere = new SphereModel();
                sphere->Load(iss);
                mModel.push_back(sphere);
            }
            else if( result == "path" )
			{
				Path* path = new Path();
				path->Load(iss);
                mPath.push_back(path);
			}
            else if( result == "spline" )
			{
				BSpline* path = new BSpline();
				path->Load(iss);
                mSpline.push_back(path);
			}
		
			else if ( result.empty() == false && result[0] == '#')
			{
				// this is a comment line
			}
			else
			{
				fprintf(stderr, "Error loading scene file... !");
				getchar();
				exit(-1);
			}
	    }
	}
	input.close();

	// Set PATH vertex buffers
	for (vector<Path*>::iterator it = mPath.begin(); it < mPath.end(); ++it)
	{
		// Draw model
		(*it)->CreateVertexBuffer();
	}

    // Set B-SPLINE vertex buffers
    for (vector<BSpline*>::iterator it = mSpline.begin(); it < mSpline.end(); ++it)
	{
		// Draw model
		(*it)->CreateVertexBuffer();
	}

	//LOAD DAT OBJ MODEL YO
	vector<OBJModel*> pokemon = PokemonGenerator::GeneratePokemon();
	for (int i = 0; i < pokemon.size(); i++)
		mModel.push_back(pokemon[i]);
	srand(20);

	OBJModel* grass = new OBJModel("../Models/Grass_02.obj");
	for (int i = 0; i < 50; i++){

		OBJModel* newgrass = new OBJModel(*grass);
		newgrass->SetPosition(vec3(rand() % 150 - 75, 0, rand() % 150 - 75));
		newgrass->SetScaling(vec3(1, 1, 1));
		mModel.push_back(newgrass);
	}

	// DAYTIME - default
	groundDay = new SkyboxModel("../Models/cube.obj");
	groundDay->SetSwitch(true);
	groundDay->SetPosition(vec3(0, -2.5, 0));
	groundDay->SetScaling(vec3(150, 5, 150));
	mModel.push_back(groundDay);

	skyboxDay = new SkyboxModel("../Models/ds.obj");
	skyboxDay->SetSwitch(true);
	skyboxDay->SetPosition(vec3(0, 60, 0));
	skyboxDay->SetScaling(vec3(80, 80, 80));
	mModel.push_back(skyboxDay);
	
	// NIGHTTIME
	groundNight = new SkyboxModel("../Models/cube2.obj");
	groundNight->SetSwitch(false);
	groundNight->SetPosition(vec3(0, -2.5, 0));
	groundNight->SetScaling(vec3(150, 5, 150));
	mModel.push_back(groundNight);

	skyboxNight = new SkyboxModel("../Models/ns.obj");
	skyboxNight->SetSwitch(false);
	skyboxNight->SetPosition(vec3(0, 60, 0));
	skyboxNight->SetScaling(vec3(80, 80, 80));
	mModel.push_back(skyboxNight);

	
    LoadCameras();
}
コード例 #5
0
void World::LoadScene(const char * scene_path)
{
	// Using case-insensitive strings and streams for easier parsing
	ci_ifstream input;
	input.open(scene_path, ios::in);

	// Invalid file
	if(input.fail() )
	{	 
		fprintf(stderr, "Error loading file: %s\n", scene_path);
		getchar();
		exit(-1);
	}

	ci_string item;
	while( std::getline( input, item, '[' ) )   
	{
        ci_istringstream iss( item );

		ci_string result;
		if( std::getline( iss, result, ']') )
		{
			if( result == "cube" )
			{
				// Box attributes
				CubeModel* cube = new CubeModel();
				cube->Load(iss);
				mModel.push_back(cube);
			}
			else if( result == "tank" )
			{
				// Box attributes
				tank = new TankModel();
				tank->Load(iss);
				mModel.push_back(tank);
				mCamera.at(0)->setTarget(tank);
				mCamera.at(1)->setTarget(tank);
			}
			else if (result == "alien")
			{
				// Box attributes
				AlienModel* alien = new AlienModel();
				Missile* mis = new Missile(tank);
				AlienCubeModel* pos = new AlienCubeModel();
				pos->SetMissile(mis);
				pos->Load(iss);
				alien->Load(iss);
				mModel.push_back(mis);
				mModel.push_back(pos);
				mModel.push_back(alien);
			}
			else if( result == "vehicle" )
			{
				// Box attributes
				VehicleModel* vehicle = new VehicleModel();
				vehicle->Load(iss);
				mModel.push_back(vehicle);
			}
            else if( result == "sphere" )
            {
                SphereModel* sphere = new SphereModel();
                sphere->Load(iss);
                mModel.push_back(sphere);
            }
            else if( result == "light" )
            {
                LightModel* light = new LightModel();
                light->Load(iss);
                mLightModels.push_back(light);
            }
			else if( result == "sun" )
            {
                SunModel* sun = new SunModel();
                sun->Load(iss);
                mModel.push_back(sun);
				LightModel* light = new LightModel(sun);
                light->Load(iss);
                mLightModels.push_back(light);
            }
			else if( result == "moon" )
            {
                MoonModel* moon = new MoonModel();
                moon->Load(iss);
                mModel.push_back(moon);
            }
            else if( result == "bspline" )
            {
                BSpline* bSpline = new BSpline();
                bSpline->Load(iss);
                mBSplineModels.push_back(bSpline);
            }
			else if (result == "textured_cube")
			{
				TexturedCube* texturedCube = new TexturedCube();
				texturedCube->Load(iss);
				mModel.push_back(texturedCube);
			}
            else if (result == "triangle")
            {
                TriangleModel* triangle = new TriangleModel();
                triangle->Load(iss);
                mModel.push_back(triangle);
            }
            else if (result == "particleEmitter")
            {
                ParticleEmitter* particleEmitter = new ParticleEmitter(vec4(1.0f, 0.0f, 0.0f, 0.0f), vec4(1.0f, 0.0f, 0.0f, 0.0f));
                particleEmitter->Load(iss);
                mModel.push_back(particleEmitter);
                mParticleEmitterModels.push_back(particleEmitter);
                particleEmitter->SetLightSource(mLightModels.back());
                particleEmitter->GenerateParticles();
            }
            else if (result == "cubesm")
            {
                CubeModelSM* cubesm = new CubeModelSM();
                cubesm->Load(iss);
                mModel.push_back(cubesm);
            }
			else if ( result.empty() == false && result[0] == '#')
			{
				// this is a comment line
			}
			else
			{
				fprintf(stderr, "Error loading scene file... !");
				getchar();
				exit(-1);
			}
	    }
	}
	input.close();

    for (vector<Model*>::iterator it = mModel.begin(); it < mModel.end(); ++it)
	{
        // Temporary for single light source
		(*it)->SetLightSource(mLightModels.back());
	}
}
コード例 #6
0
void World::LoadScene(const char * scene_path)
{
	// Using case-insensitive strings and streams for easier parsing
	ci_ifstream input;
	input.open(scene_path, ios::in);

	// Invalid file
	if (input.fail())
	{
		fprintf(stderr, "Error loading file: %s\n", scene_path);
		getchar();
		exit(-1);
	}

	ci_string item;
	while (std::getline(input, item, '['))
	{
		ci_istringstream iss(item);

		ci_string result;
		if (std::getline(iss, result, ']'))
		{
			if (result == "player")
			{
				// Box attributes
				PlayerModel* player = new PlayerModel();
				player->Load(iss);
				mModel.push_back(player);

				mPlayerModel = player;
			}
			else if (result == "discoball")
			{
				// Box attributes
				Discoball* discoBallz = new Discoball();
				discoBallz->Load(iss);
				mModel.push_back(discoBallz);
			}
			else if (result == "bunnny")
			{
				// Box attributes
				BunnyModel* bunny = new BunnyModel();
				bunny->Load(iss);
				mModel.push_back(bunny);
			}
			else if (result == "barrel")
			{
				// Box attributes
				BarrelModel* barrel = new BarrelModel();
				barrel->Load(iss);
				mModel.push_back(barrel);
			}
			else if (result == "cube")
			{
				// Box attributes
				CubeModel* cube = new CubeModel();
				cube->Load(iss);
				mModel.push_back(cube);
			}
			else if (result == "sphere")
			{
				SphereModel* sphere = new SphereModel();
				sphere->Load(iss);
				mModel.push_back(sphere);
			}
			else if (result == "animationkey")
			{
				AnimationKey* key = new AnimationKey();
				key->Load(iss);
				mAnimationKey.push_back(key);
			}
			else if (result == "animation")
			{
				Animation* anim = new Animation();
				anim->Load(iss);
				mAnimation.push_back(anim);
			}
			else if (result.empty() == false && result[0] == '#')
			{
				// this is a comment line
			}
			else
			{
				fprintf(stderr, "Error loading scene file... !");
				getchar();
				exit(-1);
			}
		}
	}
	input.close();

	if (DRAW_ANIM_PATH) {
		for (vector<Animation*>::iterator it = mAnimation.begin(); it < mAnimation.end(); ++it)
		{
			(*it)->CreateVertexBuffer();
		}
	}
}
コード例 #7
0
void TriangleOctreeModel::computeBoundingTree(int maxDepth)
{
    const helper::vector<topology::Triangle>& tri = *triangles;
    if(octreeRoot)
    {
        delete octreeRoot;
        octreeRoot=NULL;
    }

    CubeModel* cubeModel = createPrevious<CubeModel>();
    updateFromTopology();

    if (!isMoving() && !cubeModel->empty()) return; // No need to recompute BBox if immobile
    int size2=mstate->getSize();
    pNorms.resize(size2);
    for(int i=0; i<size2; i++)
    {
        pNorms[i]=defaulttype::Vector3(0,0,0);
    }
    defaulttype::Vector3 minElem, maxElem;
    maxElem[0]=minElem[0]=mstate->read(core::ConstVecCoordId::position())->getValue()[0][0];
    maxElem[1]=minElem[1]=mstate->read(core::ConstVecCoordId::position())->getValue()[0][1];
    maxElem[2]=minElem[2]=mstate->read(core::ConstVecCoordId::position())->getValue()[0][2];

    cubeModel->resize(1);  // size = number of triangles
    for (int i=1; i<size; i++)
    {
        Triangle t(this,i);
        pNorms[tri[i][0]]+=t.n();
        pNorms[tri[i][1]]+=t.n();
        pNorms[tri[i][2]]+=t.n();
        const defaulttype::Vector3* pt[3];
        pt[0] = &t.p1();
        pt[1] = &t.p2();
        pt[2] = &t.p3();
        t.n() = cross(*pt[1]-*pt[0],*pt[2]-*pt[0]);
        t.n().normalize();

        for (int p=0; p<3; p++)
        {


            for(int c=0; c<3; c++)
            {
                if ((*pt[p])[c] > maxElem[c]) maxElem[c] = (*pt[p])[c];
                if ((*pt[p])[c] < minElem[c]) minElem[c] = (*pt[p])[c];

            }
        }

    }

    cubeModel->setParentOf(0, minElem, maxElem); // define the bounding box of the current triangle
    cubeModel->computeBoundingTree(maxDepth);
    for(int i=0; i<size2; i++)
    {
        pNorms[i].normalize();
    }
#if 0
    if(!pTri.size())
    {
        /*creates the list of triangles that are associated to a point*/
        pTri.resize(size2);
        for(int i=0; i<size; i++)
        {
            pTri[tri[i][0]].push_back(i);

            pTri[tri[i][1]].push_back(i);
            pTri[tri[i][2]].push_back(i);
        }
    }
#endif

}
コード例 #8
0
VehicleModel::VehicleModel()
{
	angularSpeedXAxis = 900.0f;
	angularSpeedYAxis = 720.0f;
	
	// @TODO 5 - Layout your vehicle in a hierarchy
	CubeModel * mBody = new CubeModel(this);
	CubeModel * mFront = new CubeModel(mBody);
	CubeModel * mTail = new CubeModel(mBody);
	CubeModel * mTailWing = new CubeModel(mTail);
	CubeModel * mShaft = new CubeModel(mBody);
	CubeModel * mBlade1 = new CubeModel(mShaft);
	CubeModel * mBlade2 = new CubeModel(mShaft);
	CubeModel * mTailBlade1 = new CubeModel(mTailWing);
	CubeModel * mTailBlade2 = new CubeModel(mTailWing);

	// Body
	container.push_back(mBody);

    // Front
    mFront->SetPosition(glm::vec3(0.0f, -0.25f, 0.75f));
    mFront->SetScaling(glm::vec3(1.0f, 0.5f, 0.75f));
    container.push_back(mFront);

    // Tail
    mTail->SetPosition(glm::vec3(0.0f, -0.0f, -1.4f));
    mTail->SetScaling(glm::vec3(0.25f, 0.5f, 1.9f));
    container.push_back(mTail);

    // Tail Wing
    mTailWing->SetPosition(glm::vec3(0.0f, 0.25f, -0.7f));
    mTailWing->SetScaling(glm::vec3(1.0f, 1.5f, 0.4f));
    container.push_back(mTailWing);

    // Shaft
    mShaft->SetPosition(glm::vec3(0.0f, 0.55f, 0.0f));
    mShaft->SetScaling(glm::vec3(0.1f, 0.5f, 0.1f));
    container.push_back(mShaft);

    // Blade1
    mBlade1->SetPosition(glm::vec3(0.0f, 0.5f, 0.0f));
    mBlade1->SetScaling(glm::vec3(35.0f, 0.1f, 1.0f));
    container.push_back(mBlade1);
    rotatingYAxis.push_back(mBlade1);

    // Blade2
    mBlade2->SetPosition(glm::vec3(0.0f, 0.5f, 0.0f));
    mBlade2->SetScaling(glm::vec3(1.0f, 0.1f, 35.0f));
    container.push_back(mBlade2);
    rotatingYAxis.push_back(mBlade2);

    // TailBlade1
    mTailBlade1->SetPosition(glm::vec3(0.65f, 0.35f, -0.35f));
    mTailBlade1->SetScaling(glm::vec3(0.2f, 2.25f, 0.15f));
    container.push_back(mTailBlade1);
    rotatingXAxis.push_back(mTailBlade1);

    // TailBlade2
    mTailBlade2->SetPosition(glm::vec3(0.65f, 0.35f, -0.35f));
    mTailBlade2->SetScaling(glm::vec3(0.2f, 0.15f, 2.25f));
    container.push_back(mTailBlade2);
    rotatingXAxis.push_back(mTailBlade2);
}
コード例 #9
0
void World::LoadScene(const char * scene_path)
{
	// Using case-insensitive strings and streams for easier parsing
	ci_ifstream input;
	input.open(scene_path, ios::in);

	// Invalid file
	if (input.fail())
	{
		fprintf(stderr, "Error loading file: %s\n", scene_path);
		getchar();
		exit(-1);
	}

	ci_string item;
	while (std::getline(input, item, '['))
	{
		ci_istringstream iss(item);

		ci_string result;
		if (std::getline(iss, result, ']'))
		{
			if (result == "cube")
			{
				CubeModel* cube = new CubeModel();
				cube->Load(iss);
				mModel.push_back(cube);
			}
			else if (result == "sphere")
			{
#if defined(PLATFORM_OSX)
				int sphereTextureID = TextureLoader::LoadTexture("Textures/moonTexture.jpg");
#else
				int sphereTextureID = TextureLoader::LoadTexture("../Assets/Textures/moonTexture.jpg");
#endif

				SphereModel* moon = new SphereModel(sphereTextureID, vec3(10.0f, 10.0f, 10.0f));
				moon->Load(iss);
				mModel.push_back(moon);
			}
			else if (result == "animationkey")
			{
				AnimationKey* key = new AnimationKey();
				key->Load(iss);
				mAnimationKey.push_back(key);
			}
			else if (result == "animation")
			{
				Animation* anim = new Animation();
				anim->Load(iss);
				mAnimation.push_back(anim);
			}
			else if (result.empty() == false && result[0] == '#')
			{
				// this is a comment line
			}
			else
			{
				fprintf(stderr, "Error loading scene file... !");
				getchar();
				exit(-1);
			}
		}
	}
	input.close();

	// Set Animation vertex buffers
	for (vector<Animation*>::iterator it = mAnimation.begin(); it < mAnimation.end(); ++it)
	{
		// Draw model
		(*it)->CreateVertexBuffer();
	}
}
コード例 #10
0
void CubeModel::computeBoundingTree(int maxDepth)
{
//    if(maxDepth <= 0)
//        return;

    //sout << ">CubeModel::computeBoundingTree("<<maxDepth<<")"<<sendl;
    std::list<CubeModel*> levels;
    levels.push_front(createPrevious<CubeModel>());
    for (int i=0; i<maxDepth; i++)
        levels.push_front(levels.front()->createPrevious<CubeModel>());
    CubeModel* root = levels.front();
    //if (isStatic() && root->getPrevious() == NULL && !root->empty()) return; // No need to recompute BBox if immobile

    if (root->empty() || root->getPrevious() != NULL)
    {
        // Tree must be reconstructed
        //sout << "Building Tree with depth "<<maxDepth<<" from "<<size<<" elements."<<sendl;
        // First remove extra levels
        while(root->getPrevious()!=NULL)
        {
            core::CollisionModel::SPtr m = root->getPrevious();
            root->setPrevious(m->getPrevious());
            if (m->getMaster()) m->getMaster()->removeSlave(m);
            //delete m;
            m.reset();
        }
        // Then clear all existing levels
        {
            for (std::list<CubeModel*>::iterator it = levels.begin(); it != levels.end(); ++it)
                (*it)->resize(0);
        }
        // Then build root cell
        //sout << "CubeModel: add root cube"<<sendl;
        root->addCube(Cube(this,0),Cube(this,size));
        // Construct tree by splitting cells along their biggest dimension
        std::list<CubeModel*>::iterator it = levels.begin();
        CubeModel* level = *it;
        ++it;
        int lvl = 0;
        while(it != levels.end())
        {
            //sout << "CubeModel: split level "<<lvl<<sendl;
            CubeModel* clevel = *it;
            clevel->elems.reserve(level->size*2);
            for(Cube cell = Cube(level->begin()); level->end() != cell; ++cell)
            {
                const std::pair<Cube,Cube>& subcells = cell.subcells();
                int ncells = subcells.second.getIndex() - subcells.first.getIndex();
                //sout << "CubeModel: level "<<lvl<<" cell "<<cell.getIndex()<<": current subcells "<<subcells.first.getIndex() << " - "<<subcells.second.getIndex()<<sendl;
                if (ncells > 4)
                {
                    // Only split cells with more than 4 childs
                    // Find the biggest dimension
                    int splitAxis;
                    Vector3 l = cell.maxVect()-cell.minVect();
                    int middle = subcells.first.getIndex()+(ncells+1)/2;
                    if(l[0]>l[1])
                        if (l[0]>l[2])
                            splitAxis = 0;
                        else
                            splitAxis = 2;
                    else if (l[1]>l[2])
                        splitAxis = 1;
                    else
                        splitAxis = 2;

                    // Separate cells on each side of the median cell

#if defined(__GNUC__) && (__GNUC__ == 4)
// && (__GNUC_MINOR__ == 1) && (__GNUC_PATCHLEVEL__ == 1)
                    // there is apparently a bug in std::sort with GCC 4.x
                    if (splitAxis == 0)
                        qsort(&(elems[subcells.first.getIndex()]), subcells.second.getIndex()-subcells.first.getIndex(), sizeof(elems[0]), CubeSortPredicate::sortCube<0>);
                    else if (splitAxis == 1)
                        qsort(&(elems[subcells.first.getIndex()]), subcells.second.getIndex()-subcells.first.getIndex(), sizeof(elems[0]), CubeSortPredicate::sortCube<1>);
                    else
                        qsort(&(elems[subcells.first.getIndex()]), subcells.second.getIndex()-subcells.first.getIndex(), sizeof(elems[0]), CubeSortPredicate::sortCube<2>);
#else
                    CubeSortPredicate sortpred(splitAxis);
                    //std::nth_element(elems.begin()+subcells.first.getIndex(),elems.begin()+middle,elems.begin()+subcells.second.getIndex(), sortpred);
                    std::sort(elems.begin()+subcells.first.getIndex(),elems.begin()+subcells.second.getIndex(), sortpred);
#endif

                    // Create the two new subcells
                    Cube cmiddle(this, middle);
                    int c1 = clevel->addCube(subcells.first, cmiddle);
                    int c2 = clevel->addCube(cmiddle, subcells.second);
                    //sout << "L"<<lvl<<" cell "<<cell.getIndex()<<" split along "<<(splitAxis==0?'X':splitAxis==1?'Y':'Z')<<" in cell "<<c1<<" size "<<middle-subcells.first.getIndex()<<" and cell "<<c2<<" size "<<subcells.second.getIndex()-middle<<"."<<sendl;
                    //level->elems[cell.getIndex()].subcells = std::make_pair(Cube(clevel,c1),Cube(clevel,c2+1));
                    level->elems[cell.getIndex()].subcells.first = Cube(clevel,c1);
                    level->elems[cell.getIndex()].subcells.second = Cube(clevel,c2+1);
                }
            }
            ++it;
            level = clevel;
            ++lvl;
        }
        if (!parentOf.empty())
        {
            // Finally update parentOf to reflect new cell order
            for (int i=0; i<size; i++)
                parentOf[elems[i].children.first.getIndex()] = i;
        }
    }
    else
    {
        // Simply update the existing tree, starting from the bottom
        int lvl = 0;
        for (std::list<CubeModel*>::reverse_iterator it = levels.rbegin(); it != levels.rend(); ++it)
        {
            //sout << "CubeModel: update level "<<lvl<<sendl;
            (*it)->updateCubes();
            ++lvl;
        }
    }
    //sout << "<CubeModel::computeBoundingTree("<<maxDepth<<")"<<sendl;
}
コード例 #11
0
ファイル: World.cpp プロジェクト: vivigao/shang
void World::LoadScene(const char * scene_path){
	// Using case-insensitive strings and streams for easier parsing
	ci_ifstream input;
	input.open(scene_path, ios::in);

	// Invalid file
	if(input.fail() ){	 
		fprintf(stderr, "Error loading file: %s\n", scene_path);
		getchar();
		exit(-1);
	}

	ci_string item;
	while( std::getline( input, item, '[' ) ){
        ci_istringstream iss( item );

		ci_string result;
		if( std::getline( iss, result, ']') ){
			if( result == "cube" ){
				// Box attributes
				//CubeModel* cube = new CubeModel();
				ourGuy->Load(iss);
				mModel.push_back(ourGuy);
			}
			else if( result == "ground" ){
				// Box attributes
				CubeModel* cube = new CubeModel();
				cube->Load(iss);
				mModel.push_back(cube);
			}
            else if( result == "sphere" ){
                //SphereModel* sphere = new SphereModel();
                ourSphere->Load(iss);
                mModel.push_back(ourSphere);
            }
			else if ( result == "animationkey" ){
				AnimationKey* key = new AnimationKey();
				key->Load(iss);
				mAnimationKey.push_back(key);
			}
			else if (result == "animation"){
				Animation* anim = new Animation();
				anim->Load(iss);
				mAnimation.push_back(anim);
			}//*/
			else if (result == "bspline"){
				BSpline* spline = new BSpline();
				spline->Load(iss);
				mBSpline.push_back(spline);
			}//*/
			else if ( result.empty() == false && result[0] == '#'){
				// this is a comment line
			}
			else{
				fprintf(stderr, "Error loading scene file... !");
				getchar();
				exit(-1);
			}
	    }
	}
	input.close();

	// Set Animation vertex buffers
	for (vector<Animation*>::iterator it = mAnimation.begin(); it < mAnimation.end(); ++it)
		// Draw model
		(*it)->CreateVertexBuffer();
}
コード例 #12
0
void TetrahedronModel::computeBoundingTree(int maxDepth)
{
    CubeModel* cubeModel = createPrevious<CubeModel>();
    if (!mstate || !_topology) return;
    if (!isMoving() && !cubeModel->empty()) return; // No need to recompute BBox if immobile

    Vector3 minElem, maxElem;
    const VecCoord& x = this->mstate->read(core::ConstVecCoordId::position())->getValue();

    for (int i=0; i<size; i++)
    {
        Tetrahedron t(this,i);
        const Vector3& pt1 = x[t.p1Index()];
        const Vector3& pt2 = x[t.p2Index()];
        const Vector3& pt3 = x[t.p3Index()];
        const Vector3& pt4 = x[t.p4Index()];
        Matrix3 m, minv;
        m[0] = pt2-pt1;
        m[1] = pt3-pt1;
        m[2] = pt4-pt1;
        m.transpose();
        minv.invert(m);
        elems[i].coord0 = pt1;
        elems[i].bary2coord = m;
        elems[i].coord2bary = minv;
    }

    if (maxDepth == 0)
    {
        // no hierarchy
        if (empty())
            cubeModel->resize(0);
        else
        {
            cubeModel->resize(1);
            minElem = x[0];
            maxElem = x[0];
            for (unsigned i=1; i<x.size(); i++)
            {
                const Vector3& pt1 = x[i];
                if (pt1[0] > maxElem[0]) maxElem[0] = pt1[0];
                else if (pt1[0] < minElem[0]) minElem[0] = pt1[0];
                if (pt1[1] > maxElem[1]) maxElem[1] = pt1[1];
                else if (pt1[1] < minElem[1]) minElem[1] = pt1[1];
                if (pt1[2] > maxElem[2]) maxElem[2] = pt1[2];
                else if (pt1[2] < minElem[2]) minElem[2] = pt1[2];
            }
            cubeModel->setLeafCube(0, std::make_pair(this->begin(),this->end()), minElem, maxElem); // define the bounding box of the current Tetrahedron
        }
    }
    else
    {
        cubeModel->resize(size);  // size = number of Tetrahedrons
        if (!empty())
        {
            for (int i=0; i<size; i++)
            {
                Tetrahedron t(this,i);
                const Vector3& pt1 = x[t.p1Index()];
                const Vector3& pt2 = x[t.p2Index()];
                const Vector3& pt3 = x[t.p3Index()];
                const Vector3& pt4 = x[t.p4Index()];
                for (int c = 0; c < 3; c++)
                {
                    minElem[c] = pt1[c];
                    maxElem[c] = pt1[c];
                    if (pt2[c] > maxElem[c]) maxElem[c] = pt2[c];
                    else if (pt2[c] < minElem[c]) minElem[c] = pt2[c];
                    if (pt3[c] > maxElem[c]) maxElem[c] = pt3[c];
                    else if (pt3[c] < minElem[c]) minElem[c] = pt3[c];
                    if (pt4[c] > maxElem[c]) maxElem[c] = pt4[c];
                    else if (pt4[c] < minElem[c]) minElem[c] = pt4[c];
                }
                cubeModel->setParentOf(i, minElem, maxElem); // define the bounding box of the current Tetrahedron
            }
            cubeModel->computeBoundingTree(maxDepth);
        }
    }
}