addSphereSceneNode with a parent [SOLVED]

pilesofspam · Post by **pilesofspam** » Mon Mar 22, 2010 4:29 am

Got an application where I'm creating a fun little solar system. The sun is at the center of the irrlicht universe (0,0,0) and I've got a bunch of planets rotating around it. All of this was pretty easy with irrlicht up until I started adding some moons around the planets. I'm using addSphereSceneNode, which allows you to specify a parent. I thought that specifying a parent would be an ideal way to make the moon circle the planet, meaning that everything I set for the moon would be relative to the planet's position and rotation.

Here's the applicable code. I call PlanetMaker first. When I set the moon parent to 0, it works fine orbiting around 0,0,0. When I set the moon parent to whatever is returned by PlanetMaker (Which should be the pointer to the planet scene node), I don't see it. Does anybody see anything obvious that I'm missing?

Here's PlanetMaker, which creates a planet rotating and orbiting a set distance above or below the planetary plane.

Code: Select all

scene::ISceneNode* PlanetMaker (ISceneManager* smgr,
                                IVideoDriver* driver,
                                f32 PlanetScale,
                                const char* texturename,
                                f32 DistanceFromCenterOfSun,
                                f32 RotationSpeed,
                                f32 OrbitSpeed,
                                f32 Ydistance,
                                f32 startposition)
{
    scene::ISceneNode* Planet = smgr->addSphereSceneNode(1.0,64,0, -1, core::vector3df(0, Ydistance, 0), core::vector3df(0, 0, 0),
        core::vector3df(PlanetScale, PlanetScale, PlanetScale));
    if (Planet)
    {
        Planet->setMaterialTexture(0, driver->getTexture(texturename));
        Planet->setMaterialFlag(video::EMF_LIGHTING, false);
    }
    //make it rotate!
    rotateanim =
                smgr->createRotationAnimator(core::vector3df(0, RotationSpeed, 0));
                Planet->addAnimator(rotateanim);
                rotateanim->drop();
    //now make it orbit!
    orbitanim =
			smgr->createFlyCircleAnimator(core::vector3df(0.f, Ydistance, 0.f), DistanceFromCenterOfSun, OrbitSpeed, core::vector3df(0.f, 1.f, 0.f), startposition);
            Planet->addAnimator(orbitanim);
            orbitanim->drop();

    return(Planet);
}

And here's the MoonMaker function, basically the same thing except it calls for a planet parent and you're stuck on the orbital disk of the planet.

Code: Select all

scene::ISceneNode* MoonMaker (ISceneNode* ParentPlanet,
                                ISceneManager* smgr,
                                IVideoDriver* driver,
                                f32 MoonScale,
                                const char* texturename,
                                f32 DistanceFromPlanet,
                                f32 RotationSpeed,
                                f32 OrbitSpeed,
                                f32 startposition)
{
    scene::ISceneNode* Moon = smgr->addSphereSceneNode(1.0,64, ParentPlanet, -1, core::vector3df(0, 0, 0), core::vector3df(0, 0, 0),
        core::vector3df(MoonScale, MoonScale, MoonScale));
    if (Moon)
    {
        Moon->setMaterialTexture(0, driver->getTexture(texturename));
        Moon->setMaterialFlag(video::EMF_LIGHTING, false);
    }
    //make it rotate!
    rotateanim =
                smgr->createRotationAnimator(core::vector3df(0, RotationSpeed, 0));
                Moon->addAnimator(rotateanim);
                rotateanim->drop();
    //now make it orbit!
    orbitanim =
			smgr->createFlyCircleAnimator(core::vector3df(0.f, 0.f, 0.f), DistanceFromPlanet, OrbitSpeed, core::vector3df(0.f, 1.f, 0.f), startposition);
            Moon->addAnimator(orbitanim);
            orbitanim->drop();
    //Moon->setParent(ParentPlanet);
    return(Moon);
}

Thanks in advance for any help you can offer.

Edit: One other thing- I spent a few hours searching the forums and api docs for the answer. I feel like I'm missing something obvious but I can't figure out what it is.

zillion42 · Post by **zillion42** » Mon Mar 22, 2010 11:30 am

it's quite a mess, probably speckled with stupid ways of doing things and it wont work for you unless you'd have my whole source, but it works at least for the solar system creation part. I figured it might help to read it a little. I'll upload the whole source soon. Well, like I said, hope it helps .

Code: Select all

void createSolarSystem()
{
	/*After quite a long excursion from this code I came back and decided it's time to comment
	a little more on what's going on.
	*/

	//stars1();
	stars2();


	//create stars and nebula with a skybox
	scene::ISceneNode* SkyBox = smgr->addSkyBoxSceneNode (
		driver->getTexture("../data/star_top.jpg"),
		driver->getTexture("../data/star_bot.jpg"),
		driver->getTexture("../data/star4.jpg"),
		driver->getTexture("../data/star2.jpg"),
		driver->getTexture("../data/star3.jpg"),
		driver->getTexture("../data/star1.jpg"));

	/*
	//create stars and nebula with a skybox
	scene::ISceneNode* SkyBox = smgr->addSkyBoxSceneNode (
	driver->getTexture("../data/gridFarbe.jpg"),
	driver->getTexture("../data/gridFarbe.jpg"),
	driver->getTexture("../data/gridFarbe.jpg"),
	driver->getTexture("../data/gridFarbe.jpg"),
	driver->getTexture("../data/gridFarbe.jpg"),
	driver->getTexture("../data/gridFarbe.jpg"));
	*/

	// make a 1024x1024 texture RTT skybox
	sky = new scene::CRTTSkyBoxSceneNode(core::dimension2d<u32>(1024,1024), smgr->getRootSceneNode(),smgr,0);

	// render stars and nebula to new skybox with default blue bg
	sky->renderToSkyBox(core::vector3df(0,0,0));

	// hide billboard stars and old Skybox
	allstars->setVisible(false);
	SkyBox->setVisible(false);

	//Create a huge world axis for debug purposes
	axis = smgr->addEmptySceneNode();
	scene::IMesh* axisM = smgr->getMesh("../data/axis.b3d");
	axisM->setHardwareMappingHint(scene::EHM_STATIC);
	axis = smgr->addMeshSceneNode(axisM);
	axis->setMaterialFlag(video::EMF_LIGHTING, false);
	axis->setMaterialFlag(video::EMF_BACK_FACE_CULLING, false);
	axis->setMaterialFlag(video::EMF_WIREFRAME, true);
	axis->setScale(core::vector3df(2,2,2));
	

	//Initialize orbitalElements
	offsetDouble[0] = 0.0;
	offsetDouble[1] = 0.0;
	offsetDouble[2] = 0.0;
	
	setSolarOffset(offsetDouble);
	
	SS->updateAtDay((f64)Day,-1);

	orbitsM = smgr->addEmptySceneNode();
	u32 x;
	u32 y;
	u32 j;
	
	for(u32 p=0; p<9; p++)
	{
		core::array<scene::ISceneNode*> pOLine = makeEllipse( (SS->OrbitalElements[p][0]*AU)/scaleF, 
											  SS->OrbitalElements[p][1], 
											  SS->OrbitalElements[p][2]*core::RADTODEG64 , 
											  SS->OrbitalElements[p][3]*core::RADTODEG64,
											  SS->OrbitalElements[p][4]*core::RADTODEG64,
											  OrbitCol[p], 
											  3.0,
											  720,
											  true);
		
		OrbitPlanes.push_back(pOLine);
		
	}
	
	
	f64 moonIn360Steps = 27.321582/360.0;
	f64 orbitsDay = Day;
	core::array<core::vector3df> mPosA;

	for(u32 i=0; i<361; i++)
	{
		f64 lambda;
		core::vector3df mPos;
		moonpos(orbitsDay,&mPos,&lambda);
		mPosA.push_back(mPos/scaleF);
		orbitsDay += moonIn360Steps;
	}
	
	scene::ISceneNode * mOLine = makeLine(mPosA,video::SColor(255,180,180,180),3);
																							//110.30347,238.92881,17.14175   224.06676
	//debugPlane = createDebugPlane(core::vector3df(300,300,300),core::vector3df(-17.14175,-110.30347,0));
	/*
	//The new orbits are loaded as a model
	scene::IMesh* orbitsM = smgr->getMesh("../data/orbits.obj");
	orbitsM->setHardwareMappingHint(scene::EHM_STATIC);
	scene::ISceneNode* orbits = smgr->addMeshSceneNode(orbitsM);
	orbits->setMaterialFlag(video::EMF_LIGHTING, false);
	orbits->setMaterialFlag(video::EMF_POINTCLOUD, true);
	orbits->setMaterialFlag(video::EMF_BACK_FACE_CULLING, false);
	orbits->setScale(core::vector3df((scaleF/100000.0f)*-1,scaleF/100000.0f,scaleF/100000.0f));
	orbits->setPosition(orbits->getPosition()+core::vector3df(0,-0.08,0));
	*/
	closestBodySim = createDebugAxis(core::vector3df(0.15,0.15,0.15));
	closestBodySim->setParent(orbitsM);
	closestBodySim2 = createDebugAxis(core::vector3df(0.15,0.15,0.15));
	closestBodySim2->setParent(orbitsM);
	
	//load all the textures
	video::ITexture *tex1 =  driver->getTexture("../data/mercurymap.jpg");
	video::ITexture *tex2 =  driver->getTexture("../data/mercurybump.jpg");
	video::ITexture *tex3 =  driver->getTexture("../data/venusmap.jpg");
	video::ITexture *tex4 =  driver->getTexture("../data/venusbump.jpg");
	video::ITexture *tex5 =  driver->getTexture("../data/earthmap1k.jpg");
	video::ITexture *tex6 =  driver->getTexture("../data/earthbump1k.jpg");
	video::ITexture *tex7 =  driver->getTexture("../data/mars_1k_color.jpg");
	video::ITexture *tex8 =  driver->getTexture("../data/mars_1k_topo.jpg");
	video::ITexture *tex9 =  driver->getTexture("../data/jupitermap.jpg");
	video::ITexture *tex10 =  driver->getTexture("../data/nobump.jpg");
	video::ITexture *tex11 =  driver->getTexture("../data/saturnmap.jpg");
	video::ITexture *tex13 =  driver->getTexture("../data/uranusmap.jpg");
	video::ITexture *tex15 =  driver->getTexture("../data/neptunemap.jpg");
	video::ITexture *tex17 =  driver->getTexture("../data/plutomap1k.jpg");
	video::ITexture *tex18 =  driver->getTexture("../data/plutobump1k.jpg");
	video::ITexture *tex19 =  driver->getTexture("../data/earthcloudmap.tga");
	video::ITexture *tex20 =  driver->getTexture("../data/ebill.jpg");
	video::ITexture *tex21 =  driver->getTexture("../data/saturnringcolor.tga");
	video::ITexture *tex22 =  driver->getTexture("../data/moon512.jpg");
	video::ITexture *tex23 =  driver->getTexture("../data/moon_height.jpg");
	video::ITexture *tex24 =  driver->getTexture("../data/io.jpg");
	video::ITexture *tex25 =  driver->getTexture("../data/io_height.jpg");
	video::ITexture *tex26 =  driver->getTexture("../data/europa.jpg");
	video::ITexture *tex27 =  driver->getTexture("../data/europa_height.jpg");
	video::ITexture *tex28 =  driver->getTexture("../data/ganymede.jpg");
	video::ITexture *tex29 =  driver->getTexture("../data/ganymede_height.jpg");
	video::ITexture *tex30 =  driver->getTexture("../data/callisto.jpg");
	video::ITexture *tex31 =  driver->getTexture("../data/europa_height.jpg");
	//video::ITexture *tex35 =  driver->getTexture("../data/earthcloudmaptrans.jpg");
	video::ITexture *sunbill =  driver->getTexture("../data/bill.jpg");
	video::ITexture *sun =  driver->getTexture("../data/diffuse.jpg");

	video::ITexture *checktex =  driver->getTexture("../data/gridFarbe2.jpg");

	//make space to hold the meshes
	scene::IAnimatedMesh* ringMesh;
	scene::IAnimatedMesh* planetMesh;
	scene::IAnimatedMesh* moonMesh;
	scene::IAnimatedMesh* sunMesh;
	scene::IAnimatedMesh* atmoMesh;
	scene::IAnimatedMesh* SOIMesh;
	
	/*debug
	scene::IAnimatedMesh* exportMesh;
	exportMesh = smgr->getMesh("../data/sphere1.x");
	exportMesh->setHardwareMappingHint(scene::EHM_STATIC);
	
	checkmesh = smgr->addMeshSceneNode(exportMesh);
	checkmesh->setMaterialTexture(0,checktex);
	checkmesh->setMaterialFlag(video::EMF_LIGHTING, false);
	
	scene::ISceneNode* checkmeshW = smgr->addMeshSceneNode(exportMesh,checkmesh);
	checkmeshW->setMaterialFlag(video::EMF_WIREFRAME, true);
	*/

	scene::IMesh* tangentMesh;
	scene::IBillboardSceneNode* earthBill;
	scene::ISceneNodeAnimator* rota;

	scene::IMesh* PlanetNodeAxisM;
	scene::IMesh* PlanetAxisM;
	scene::IMesh* PlanetAxisM2;
	
	core::matrix4 transformMesh;
	//create the SceneNodes for hierarchy as follows
	/*

	planetNode		= is driven by solar.cpp and pushed into array<scene::ISceneNode*> planets
	|
	|--->planet		= is rotated according to sideral rotation period and pushed into array<scene::ISceneNode*> planetsR
	|	 |--->atmo
	|	 |--->ring
	|
	|---->moonNode	= is positioned according to moons orbital period and pushed into array<scene::ISceneNode*> moons
	|--->moon  = is rotated according to moons sideral rotation period and pushed into array<scene::ISceneNode*> moonsR
	*/
	
	u32 i;
	for(i=0; i<9; i++){

		scene::ISceneNode* planetNode;
		scene::ISceneNode* SOInode;
		scene::ISceneNode* planet;
		scene::ISceneNode* atmo;
		scene::ISceneNode* ring;
		scene::ISceneNode* moonNode;
		scene::ISceneNode* moon;

		scene::ISceneNode* PlanetNodeAxis;
		scene::ISceneNode* PlanetAxis;
		scene::ISceneNode* PlanetAxis2;

		core::matrix4 mTmatr;
		core::vector3df scale;
		core::vector3df SOIscale;

		core::vector3df pos;
		f64 lambda;
		core::stringw date; 

		switch(i){
	case 0:
		planetNode = smgr->addEmptySceneNode();
		planetMesh = smgr->addSphereMesh("Mercury",1.0,48,48);
		
		tangentMesh = smgr->getMeshManipulator()->createMeshWithTangents(planetMesh,false,true);
		tangentMesh->setHardwareMappingHint(scene::EHM_STATIC);
		scale = core::vector3df((planetSize[i]/scaleF),(planetSize[i]/scaleF),(planetSize[i]/scaleF));
		smgr->getMeshManipulator()->scale(tangentMesh,scale);

		planet = smgr->addMeshSceneNode(tangentMesh);
		planet->setMaterialFlag(video::EMF_NORMALIZE_NORMALS, true);
		planet->setMaterialType(video::EMT_NORMAL_MAP_SOLID);
		planet->setMaterialTexture(0,tex1);
		planet->setMaterialTexture(1,tex2);
		//planet->getMaterial(0).SpecularColor.set(255,255,255,255);
		//planet->getMaterial(0).Shininess = 3800;
		planet->setRotation(core::vector3df(0,0,-0.1));
		planetNode->setName("mercury");

		SOInode = smgr->addEmptySceneNode();
		SOIMesh = smgr->addSphereMesh("SOI",1.0,48,48);
		SOIMesh->setHardwareMappingHint(scene::EHM_STATIC);
		smgr->getMeshManipulator()->setVertexColors(SOIMesh,OrbitCol[i]);
		SOIscale = core::vector3df((pSOI[i]/scaleF),(pSOI[i]/scaleF),(pSOI[i]/scaleF));
		smgr->getMeshManipulator()->scale(SOIMesh,SOIscale);
		SOInode = smgr->addMeshSceneNode(SOIMesh);
		SOInode->setMaterialFlag(video::EMF_WIREFRAME, true);
		SOInode->setMaterialFlag(video::EMF_BACK_FACE_CULLING, false);
		SOInode->setVisible(false);
		SOInode->setParent(planetNode);
		SOINodes.push_back(SOInode);

		planet->setParent(planetNode);
		planets.push_back(planetNode);
		planetsR.push_back(planet);
		tangentMesh->drop();
		break;
	case 1:
		planetNode = smgr->addEmptySceneNode();
		planetMesh = smgr->addSphereMesh("Venus",1.0,48,48);
		
		tangentMesh = smgr->getMeshManipulator()->createMeshWithTangents(planetMesh,false,true);
		tangentMesh->setHardwareMappingHint(scene::EHM_STATIC);
		scale = core::vector3df((planetSize[i]/scaleF),(planetSize[i]/scaleF),(planetSize[i]/scaleF));
		smgr->getMeshManipulator()->scale(tangentMesh,scale);
		
		planet = smgr->addMeshSceneNode(tangentMesh);
		planet->setMaterialFlag(video::EMF_NORMALIZE_NORMALS, true);
		planet->setMaterialType(video::EMT_NORMAL_MAP_SOLID);
		planet->setMaterialTexture(0,tex3);
		planet->setMaterialTexture(1,tex4);
		planet->setRotation(core::vector3df(0,0,3));
		planetNode->setName("venus");
		
		SOInode = smgr->addEmptySceneNode();
		SOIMesh = smgr->addSphereMesh("SOI1",1.0,48,48);
		SOIMesh->setHardwareMappingHint(scene::EHM_STATIC);
		smgr->getMeshManipulator()->setVertexColors(SOIMesh,OrbitCol[i]);
		SOIscale = core::vector3df((pSOI[i]/scaleF),(pSOI[i]/scaleF),(pSOI[i]/scaleF));
		smgr->getMeshManipulator()->scale(SOIMesh,SOIscale);
		SOInode = smgr->addMeshSceneNode(SOIMesh);
		SOInode->setMaterialFlag(video::EMF_WIREFRAME, true);
		SOInode->setMaterialFlag(video::EMF_BACK_FACE_CULLING, false);
		SOInode->setVisible(false);
		SOInode->setParent(planetNode);
		SOINodes.push_back(SOInode);

		planet->setParent(planetNode);
		planets.push_back(planetNode);
		planetsR.push_back(planet);
		tangentMesh->drop();
		break;
	case 2:
		planetNode = smgr->addEmptySceneNode();
		planetMesh = smgr->addSphereMesh("Earth",1.0,64,64);

		tangentMesh = smgr->getMeshManipulator()->createMeshWithTangents(planetMesh,false,true);
		tangentMesh->setHardwareMappingHint(scene::EHM_STATIC);
		scale = core::vector3df((planetSize[i]/scaleF),(planetSize[i]/scaleF),(planetSize[i]/scaleF));
		smgr->getMeshManipulator()->scale(tangentMesh,scale);

		planet = smgr->addMeshSceneNode(tangentMesh);
		planet->setMaterialFlag(video::EMF_NORMALIZE_NORMALS, true);
		planet->setMaterialType(video::EMT_NORMAL_MAP_SOLID);
		planet->setMaterialTexture(0,tex5);
		planet->setMaterialTexture(1,tex6);
		planet->setRotation(core::vector3df(0,0,-23.439281));
		planetNode->setName("earth");

		SOInode = smgr->addEmptySceneNode();
		SOIMesh = smgr->addSphereMesh("SOI2",1.0,48,48);
		SOIMesh->setHardwareMappingHint(scene::EHM_STATIC);
		smgr->getMeshManipulator()->setVertexColors(SOIMesh,OrbitCol[i]);
		SOIscale = core::vector3df((pSOI[i]/scaleF),(pSOI[i]/scaleF),(pSOI[i]/scaleF));
		smgr->getMeshManipulator()->scale(SOIMesh,SOIscale);
		SOInode = smgr->addMeshSceneNode(SOIMesh);
		SOInode->setMaterialFlag(video::EMF_WIREFRAME, true);
		SOInode->setMaterialFlag(video::EMF_BACK_FACE_CULLING, false);
		SOInode->setVisible(false);
		SOInode->setParent(planetNode);
		SOINodes.push_back(SOInode);

		planet->setParent(planetNode);
		planets.push_back(planetNode);
		planetsR.push_back(planet);
		tangentMesh->drop();
		
		atmoMesh = smgr->addSphereMesh("EarthAtmo",1.0,64,64);
		smgr->getMeshManipulator()->scale(atmoMesh,scale*1.0001);
		atmo = smgr->addMeshSceneNode(atmoMesh,planet);
		atmo->setScale(core::vector3df(1.005,1.005,1.005));
		atmo->setMaterialFlag(video::EMF_NORMALIZE_NORMALS, true);
		atmo->setMaterialType(video::EMT_TRANSPARENT_ALPHA_CHANNEL);
		atmo->setMaterialTexture(0,tex19);
		atmo->setName("earth-atmo");
		atmo->getMaterial(0).SpecularColor.set(255,255,255,255);
		atmo->getMaterial(0).Shininess = 200;
		//rota = smgr->createRotationAnimator(core::vector3df(0.0042,0.015,0.0042));
		//atmo->addAnimator(rota);
		//rota->drop();

		moonNode = smgr->addEmptySceneNode(planetNode);
		moonMesh = smgr->addSphereMesh("Moon0",1.0,48,48);
		
		tangentMesh = smgr->getMeshManipulator()->createMeshWithTangents(moonMesh,false,true);
		tangentMesh->setHardwareMappingHint(scene::EHM_STATIC);
		scale = core::vector3df((mSize[0]/scaleF),(mSize[0]/scaleF),(mSize[0]/scaleF));
		smgr->getMeshManipulator()->scale(tangentMesh,scale);
		
		moon = smgr->addMeshSceneNode(tangentMesh,moonNode);
		moon->setMaterialFlag(video::EMF_NORMALIZE_NORMALS, true);
		moonNode->setRotation(core::vector3df(0,0,5.14));
		moon->setMaterialType(video::EMT_NORMAL_MAP_SOLID);
		//moon->setMaterialFlag(video::EMF_LIGHTING, false);
		moonpos(Day, &pos, &lambda);
		//date = SS->J2000ToGreg(Day);
		//printf("\n\nL A M B D A : %f , %f\n\n",lambda,Day);
		moon->setRotation(core::vector3df(0,360.0-lambda,-6.58));
		//moon->setScale(core::vector3df((mSize[0]/scaleF),(mSize[0]/scaleF),(mSize[0]/scaleF)));
		moon->setMaterialTexture(0,tex22);
		moon->setMaterialTexture(1,tex23);
		moon->setName("Moon");
		moons.push_back(moonNode);
		moonsR.push_back(moon);
		tangentMesh->drop();

		mOLine->setParent(planetNode);
		earthBill = smgr->addBillboardSceneNode(planetNode,core::dimension2df((planetSize[i]/scaleF)*2.5f,(planetSize[i]/scaleF)*2.5f));
		earthBill->setMaterialFlag(video::EMF_LIGHTING, false);
		earthBill->setMaterialType(video::EMT_TRANSPARENT_ADD_COLOR);
		earthBill->setMaterialTexture(0,tex20);
		earthBill->setName("earth-bill");

		/*
		PlanetAxis = smgr->addEmptySceneNode();
		PlanetAxisM = smgr->getMesh("../data/axis.b3d");
		PlanetAxisM->setHardwareMappingHint(scene::EHM_STATIC);
		PlanetAxisM->setMaterialFlag(video::EMF_LIGHTING, false);
		PlanetAxisM->setMaterialFlag(video::EMF_WIREFRAME, true);
		PlanetAxisM->setMaterialFlag(video::EMF_BACK_FACE_CULLING, false);
		PlanetAxis = smgr->addMeshSceneNode(PlanetAxisM);
		PlanetAxis->setPosition(planetNode->getPosition());
		PlanetAxis->setParent(planet);
		PlanetAxis->setScale(core::vector3df(2.1f,2.1f,2.1f));
		
		PlanetAxis2 = smgr->addEmptySceneNode();
		PlanetAxisM2 = smgr->getMesh("../data/axis.b3d");
		PlanetAxisM2->setHardwareMappingHint(scene::EHM_STATIC);
		PlanetAxisM2->setMaterialFlag(video::EMF_LIGHTING, false);
		PlanetAxisM2->setMaterialFlag(video::EMF_WIREFRAME, true);
		PlanetAxisM2->setMaterialFlag(video::EMF_BACK_FACE_CULLING, false);
		PlanetAxis2 = smgr->addMeshSceneNode(PlanetAxisM2);
		PlanetAxis2->setPosition(planetNode->getPosition());
		PlanetAxis2->setParent(planetNode);
		PlanetAxis2->setScale(core::vector3df(0.006f,0.006f,0.006f));
		*/
		break;
	case 3:
		planetNode = smgr->addEmptySceneNode();
		planetMesh = smgr->addSphereMesh("Mars",1.0,48,48);

		tangentMesh = smgr->getMeshManipulator()->createMeshWithTangents(planetMesh,false,true);
		tangentMesh->setHardwareMappingHint(scene::EHM_STATIC);
		scale = core::vector3df((planetSize[i]/scaleF),(planetSize[i]/scaleF),(planetSize[i]/scaleF));
		smgr->getMeshManipulator()->scale(tangentMesh,scale);

		planet = smgr->addMeshSceneNode(tangentMesh);
		planet->setMaterialFlag(video::EMF_NORMALIZE_NORMALS, true);
		planet->setMaterialType(video::EMT_NORMAL_MAP_SOLID);
		planet->setMaterialTexture(0,tex7);
		planet->setMaterialTexture(1,tex8);
		planet->setRotation(core::vector3df(0,0,-25));
		planetNode->setName("mars");

		SOInode = smgr->addEmptySceneNode();
		SOIMesh = smgr->addSphereMesh("SOI3",1.0,48,48);
		SOIMesh->setHardwareMappingHint(scene::EHM_STATIC);
		smgr->getMeshManipulator()->setVertexColors(SOIMesh,OrbitCol[i]);
		SOIscale = core::vector3df((pSOI[i]/scaleF),(pSOI[i]/scaleF),(pSOI[i]/scaleF));
		smgr->getMeshManipulator()->scale(SOIMesh,SOIscale);
		SOInode = smgr->addMeshSceneNode(SOIMesh);
		SOInode->setMaterialFlag(video::EMF_WIREFRAME, true);
		SOInode->setMaterialFlag(video::EMF_BACK_FACE_CULLING, false);
		SOInode->setVisible(false);
		SOInode->setParent(planetNode);
		SOINodes.push_back(SOInode);

		planet->setParent(planetNode);
		planets.push_back(planetNode);
		planetsR.push_back(planet);
		tangentMesh->drop();
		break;
	case 4:
		planetNode = smgr->addEmptySceneNode();
		planetMesh = smgr->addSphereMesh("Jupiter",20.0,48,48);

		tangentMesh = smgr->getMeshManipulator()->createMeshWithTangents(planetMesh,false,true);
		tangentMesh->setHardwareMappingHint(scene::EHM_STATIC);
		scale = core::vector3df((planetSize[i]/scaleF/20.0),(planetSize[i]/scaleF/20.0),(planetSize[i]/scaleF/20.0));
		smgr->getMeshManipulator()->scale(tangentMesh,scale);

		planet = smgr->addMeshSceneNode(tangentMesh);
		planet->setMaterialFlag(video::EMF_NORMALIZE_NORMALS, true);
		planet->setMaterialType(video::EMT_NORMAL_MAP_SOLID);
		planet->setMaterialTexture(0,tex9);
		planet->setMaterialTexture(1,tex10);
		planet->setRotation(core::vector3df(0,0,-3));
		planetNode->setName("jupiter");

		SOInode = smgr->addEmptySceneNode();
		SOIMesh = smgr->addSphereMesh("SOI4",1.0,48,48);
		SOIMesh->setHardwareMappingHint(scene::EHM_STATIC);
		smgr->getMeshManipulator()->setVertexColors(SOIMesh,OrbitCol[i]);
		SOIscale = core::vector3df((pSOI[i]/scaleF),(pSOI[i]/scaleF),(pSOI[i]/scaleF));
		smgr->getMeshManipulator()->scale(SOIMesh,SOIscale);
		SOInode = smgr->addMeshSceneNode(SOIMesh);
		SOInode->setMaterialFlag(video::EMF_WIREFRAME, true);
		SOInode->setMaterialFlag(video::EMF_BACK_FACE_CULLING, false);
		SOInode->setVisible(false);
		SOInode->setParent(planetNode);
		SOINodes.push_back(SOInode);

		planet->setParent(planetNode);
		planets.push_back(planetNode);
		planetsR.push_back(planet);
		tangentMesh->drop();

		moonNode = smgr->addEmptySceneNode(planetNode);
		moonMesh = smgr->addSphereMesh("Moon1",1.0,48,48);
		
		tangentMesh = smgr->getMeshManipulator()->createMeshWithTangents(moonMesh,false,true);
		tangentMesh->setHardwareMappingHint(scene::EHM_STATIC);
		scale = core::vector3df((mSize[1]/scaleF),(mSize[1]/scaleF),(mSize[1]/scaleF));
		smgr->getMeshManipulator()->scale(tangentMesh,scale);

		moon = smgr->addMeshSceneNode(tangentMesh,moonNode);
		moonNode->setPosition(core::vector3df(0,0,mDist[1]));
		moon->setMaterialType(video::EMT_NORMAL_MAP_SOLID);
		moon->setMaterialTexture(0,tex24);
		moon->setMaterialTexture(1,tex25);
		moon->setName("Io");
		moons.push_back(moonNode);
		moonsR.push_back(moon);
		tangentMesh->drop();

		moonNode = smgr->addEmptySceneNode(planetNode);
		moonMesh = smgr->addSphereMesh("Moon2",1.0,48,48);
		
		tangentMesh = smgr->getMeshManipulator()->createMeshWithTangents(moonMesh,false,true);
		tangentMesh->setHardwareMappingHint(scene::EHM_STATIC);
		scale = core::vector3df((mSize[2]/scaleF),(mSize[2]/scaleF),(mSize[2]/scaleF));
		smgr->getMeshManipulator()->scale(tangentMesh,scale);

		moon = smgr->addMeshSceneNode(tangentMesh,moonNode);
		moonNode->setPosition(core::vector3df(0,0,mDist[2]));
		moon->setMaterialType(video::EMT_NORMAL_MAP_SOLID);
		moon->setMaterialTexture(0,tex26);
		moon->setMaterialTexture(1,tex27);
		moon->setName("Europa");
		moons.push_back(moonNode);
		moonsR.push_back(moon);
		tangentMesh->drop();

		moonNode = smgr->addEmptySceneNode(planetNode);
		moonMesh = smgr->addSphereMesh("Moon3",1.0,48,48);
		
		tangentMesh = smgr->getMeshManipulator()->createMeshWithTangents(moonMesh,false,true);
		tangentMesh->setHardwareMappingHint(scene::EHM_STATIC);
		scale = core::vector3df((mSize[3]/scaleF),(mSize[3]/scaleF),(mSize[3]/scaleF));
		smgr->getMeshManipulator()->scale(tangentMesh,scale);
		
		moon = smgr->addMeshSceneNode(tangentMesh,moonNode);
		moonNode->setPosition(core::vector3df(0,0,mDist[3]));
		moon->setMaterialType(video::EMT_NORMAL_MAP_SOLID);
		moon->setMaterialTexture(0,tex28);
		moon->setMaterialTexture(1,tex29);
		moon->setName("Ganymede");
		moons.push_back(moonNode);
		moonsR.push_back(moon);
		tangentMesh->drop();

		moonNode = smgr->addEmptySceneNode(planetNode);
		moonMesh = smgr->addSphereMesh("Moon4",1.0,48,48);

		tangentMesh = smgr->getMeshManipulator()->createMeshWithTangents(moonMesh,false,true);
		tangentMesh->setHardwareMappingHint(scene::EHM_STATIC);
		scale = core::vector3df((mSize[4]/scaleF),(mSize[4]/scaleF),(mSize[4]/scaleF));
		smgr->getMeshManipulator()->scale(tangentMesh,scale);

		moon = smgr->addMeshSceneNode(tangentMesh,moonNode);
		moonNode->setPosition(core::vector3df(0,0,mDist[4]));
		moon->setMaterialType(video::EMT_NORMAL_MAP_SOLID);
		moon->setMaterialTexture(0,tex30);
		//moon->setMaterialTexture(1,tex27);
		moon->setName("Callisto");
		moons.push_back(moonNode);
		moonsR.push_back(moon);
		tangentMesh->drop();
		break;
	case 5:
		planetNode = smgr->addEmptySceneNode();
		planetMesh = smgr->addSphereMesh("Saturn",20.0,48,48);

		tangentMesh = smgr->getMeshManipulator()->createMeshWithTangents(planetMesh,false,true);
		tangentMesh->setHardwareMappingHint(scene::EHM_STATIC);
		scale = core::vector3df((planetSize[i]/scaleF/20.0),(planetSize[i]/scaleF/20.0),(planetSize[i]/scaleF/20.0));
		smgr->getMeshManipulator()->scale(tangentMesh,scale);

		planet = smgr->addMeshSceneNode(tangentMesh);
		planet->setMaterialFlag(video::EMF_NORMALIZE_NORMALS, true);
		planet->setMaterialType(video::EMT_NORMAL_MAP_SOLID);
		planet->setMaterialTexture(0,tex11);
		planet->setMaterialTexture(1,tex10);
		tangentMesh->drop();

		moonNode = smgr->addEmptySceneNode(planetNode);
		moonMesh = smgr->addSphereMesh("Moon5",1.0,48,48);
		
		tangentMesh = smgr->getMeshManipulator()->createMeshWithTangents(moonMesh,false,true);
		tangentMesh->setHardwareMappingHint(scene::EHM_STATIC);
		scale = core::vector3df((mSize[5]/scaleF),(mSize[5]/scaleF),(mSize[5]/scaleF));
		smgr->getMeshManipulator()->scale(tangentMesh,scale);
		
		moon = smgr->addMeshSceneNode(tangentMesh,moonNode);
		moonNode->setPosition(core::vector3df(0,0,mDist[5]));
		moon->setMaterialType(video::EMT_NORMAL_MAP_SOLID);
		moon->setMaterialTexture(0,tex28);
		moon->setMaterialTexture(1,tex29);
		moon->setName("Mimas");
		moons.push_back(moonNode);
		moonsR.push_back(moon);
		tangentMesh->drop();

		moonNode = smgr->addEmptySceneNode(planetNode);
		moonMesh = smgr->addSphereMesh("Moon6",1.0,48,48);
		
		tangentMesh = smgr->getMeshManipulator()->createMeshWithTangents(moonMesh,false,true);
		tangentMesh->setHardwareMappingHint(scene::EHM_STATIC);
		scale = core::vector3df((mSize[6]/scaleF),(mSize[6]/scaleF),(mSize[6]/scaleF));
		smgr->getMeshManipulator()->scale(tangentMesh,scale);
		
		moon = smgr->addMeshSceneNode(tangentMesh,moonNode);
		moonNode->setPosition(core::vector3df(0,0,mDist[6]));
		moon->setMaterialType(video::EMT_NORMAL_MAP_SOLID);
		moon->setMaterialTexture(0,tex28);
		moon->setMaterialTexture(1,tex29);
		moon->setName("Enceladus");
		moons.push_back(moonNode);
		moonsR.push_back(moon);
		tangentMesh->drop();

		moonNode = smgr->addEmptySceneNode(planetNode);
		moonMesh = smgr->addSphereMesh("Moon7",1.0,48,48);
		
		tangentMesh = smgr->getMeshManipulator()->createMeshWithTangents(moonMesh,false,true);
		tangentMesh->setHardwareMappingHint(scene::EHM_STATIC);
		scale = core::vector3df((mSize[7]/scaleF),(mSize[7]/scaleF),(mSize[7]/scaleF));
		smgr->getMeshManipulator()->scale(tangentMesh,scale);
		
		moon = smgr->addMeshSceneNode(tangentMesh,moonNode);
		moonNode->setPosition(core::vector3df(0,0,mDist[7]));
		moon->setMaterialType(video::EMT_NORMAL_MAP_SOLID);
		moon->setMaterialTexture(0,tex28);
		moon->setMaterialTexture(1,tex29);
		moon->setName("Tethys");
		moons.push_back(moonNode);
		moonsR.push_back(moon);
		tangentMesh->drop();

		moonNode = smgr->addEmptySceneNode(planetNode);
		moonMesh = smgr->addSphereMesh("Moon8",1.0,48,48);
		
		tangentMesh = smgr->getMeshManipulator()->createMeshWithTangents(moonMesh,false,true);
		tangentMesh->setHardwareMappingHint(scene::EHM_STATIC);
		scale = core::vector3df((mSize[8]/scaleF),(mSize[8]/scaleF),(mSize[8]/scaleF));
		smgr->getMeshManipulator()->scale(tangentMesh,scale);

		moon = smgr->addMeshSceneNode(tangentMesh,moonNode);
		moonNode->setPosition(core::vector3df(0,0,mDist[8]));
		moon->setMaterialType(video::EMT_NORMAL_MAP_SOLID);
		moon->setMaterialTexture(0,tex28);
		moon->setMaterialTexture(1,tex29);
		moon->setName("Dione");
		moons.push_back(moonNode);
		moonsR.push_back(moon);
		tangentMesh->drop();

		moonNode = smgr->addEmptySceneNode(planetNode);
		moonMesh = smgr->addSphereMesh("Moon9",1.0,48,48);
		
		tangentMesh = smgr->getMeshManipulator()->createMeshWithTangents(moonMesh,false,true);
		tangentMesh->setHardwareMappingHint(scene::EHM_STATIC);
		scale = core::vector3df((mSize[9]/scaleF),(mSize[9]/scaleF),(mSize[9]/scaleF));
		smgr->getMeshManipulator()->scale(tangentMesh,scale);

		moon = smgr->addMeshSceneNode(tangentMesh,moonNode);
		moonNode->setPosition(core::vector3df(0,0,mDist[9]));
		moon->setMaterialType(video::EMT_NORMAL_MAP_SOLID);
		moon->setMaterialTexture(0,tex28);
		moon->setMaterialTexture(1,tex29);
		moon->setName("Rhea");
		moons.push_back(moonNode);
		moonsR.push_back(moon);
		tangentMesh->drop();

		moonNode = smgr->addEmptySceneNode(planetNode);
		moonMesh = smgr->addSphereMesh("Moon10",1.0,48,48);
		
		tangentMesh = smgr->getMeshManipulator()->createMeshWithTangents(moonMesh,false,true);
		tangentMesh->setHardwareMappingHint(scene::EHM_STATIC);
		scale = core::vector3df((mSize[10]/scaleF),(mSize[10]/scaleF),(mSize[10]/scaleF));
		smgr->getMeshManipulator()->scale(tangentMesh,scale);

		moon = smgr->addMeshSceneNode(tangentMesh,moonNode);
		moonNode->setPosition(core::vector3df(0,0,mDist[10]));
		moon->setMaterialType(video::EMT_NORMAL_MAP_SOLID);
		moon->setMaterialTexture(0,tex28);
		moon->setMaterialTexture(1,tex29);
		moon->setName("Titan");
		moons.push_back(moonNode);
		moonsR.push_back(moon);
		tangentMesh->drop();

		moonNode = smgr->addEmptySceneNode(planetNode);
		moonMesh = smgr->addSphereMesh("Moon11",1.0,48,48);
		
		tangentMesh = smgr->getMeshManipulator()->createMeshWithTangents(moonMesh,false,true);
		tangentMesh->setHardwareMappingHint(scene::EHM_STATIC);
		scale = core::vector3df((mSize[11]/scaleF),(mSize[11]/scaleF),(mSize[11]/scaleF));
		smgr->getMeshManipulator()->scale(tangentMesh,scale);

		moon = smgr->addMeshSceneNode(tangentMesh,moonNode);
		moonNode->setPosition(core::vector3df(0,0,mDist[11]));
		moon->setMaterialType(video::EMT_NORMAL_MAP_SOLID);
		moon->setMaterialTexture(0,tex28);
		moon->setMaterialTexture(1,tex29);
		moon->setName("Iapetus");
		moons.push_back(moonNode);
		moonsR.push_back(moon);
		tangentMesh->drop();

		ringMesh = smgr->getMesh("../data/ring.obj");
		ring = smgr->addMeshSceneNode(ringMesh,planetNode);
		ring->setParent(planet);
		ring->setScale(core::vector3df(1,0.1,1)*0.016);
		ring->setMaterialType(video::EMT_TRANSPARENT_ALPHA_CHANNEL);
		ring->setMaterialTexture(0,tex21);
		ring->setMaterialFlag(video::EMF_LIGHTING,false);
		ring->setName("saturn-ring");

		planet->setRotation(core::vector3df(0,0,-26.44));
		planetNode->setName("saturn");

		SOInode = smgr->addEmptySceneNode();
		SOIMesh = smgr->addSphereMesh("SOI5",1.0,48,48);
		SOIMesh->setHardwareMappingHint(scene::EHM_STATIC);
		smgr->getMeshManipulator()->setVertexColors(SOIMesh,OrbitCol[i]);
		SOIscale = core::vector3df((pSOI[i]/scaleF),(pSOI[i]/scaleF),(pSOI[i]/scaleF));
		smgr->getMeshManipulator()->scale(SOIMesh,SOIscale);
		SOInode = smgr->addMeshSceneNode(SOIMesh);
		SOInode->setMaterialFlag(video::EMF_WIREFRAME, true);
		SOInode->setMaterialFlag(video::EMF_BACK_FACE_CULLING, false);
		SOInode->setVisible(false);
		SOInode->setParent(planetNode);
		SOINodes.push_back(SOInode);

		planet->setParent(planetNode);
		planets.push_back(planetNode);
		planetsR.push_back(planet);
		break;
	case 6:
		planetNode = smgr->addEmptySceneNode();
		planetMesh = smgr->addSphereMesh("Uranus",20.0,48,48);

		tangentMesh = smgr->getMeshManipulator()->createMeshWithTangents(planetMesh,false,true);
		tangentMesh->setHardwareMappingHint(scene::EHM_STATIC);
		scale = core::vector3df((planetSize[i]/scaleF/20.0),(planetSize[i]/scaleF/20.0),(planetSize[i]/scaleF/20.0));
		smgr->getMeshManipulator()->scale(tangentMesh,scale);

		planet = smgr->addMeshSceneNode(tangentMesh);
		planet->setMaterialFlag(video::EMF_NORMALIZE_NORMALS, true);
		planet->setMaterialType(video::EMT_NORMAL_MAP_SOLID);
		planet->setMaterialTexture(0,tex13);
		planet->setMaterialTexture(1,tex10);
		planet->setRotation(core::vector3df(0,0,-98));
		planetNode->setName("uranus");

		SOInode = smgr->addEmptySceneNode();
		SOIMesh = smgr->addSphereMesh("SOI6",1.0,48,48);
		SOIMesh->setHardwareMappingHint(scene::EHM_STATIC);
		smgr->getMeshManipulator()->setVertexColors(SOIMesh,OrbitCol[i]);
		SOIscale = core::vector3df((pSOI[i]/scaleF),(pSOI[i]/scaleF),(pSOI[i]/scaleF));
		smgr->getMeshManipulator()->scale(SOIMesh,SOIscale);
		SOInode = smgr->addMeshSceneNode(SOIMesh);
		SOInode->setMaterialFlag(video::EMF_WIREFRAME, true);
		SOInode->setMaterialFlag(video::EMF_BACK_FACE_CULLING, false);
		SOInode->setVisible(false);
		SOInode->setParent(planetNode);
		SOINodes.push_back(SOInode);

		planet->setParent(planetNode);
		planets.push_back(planetNode);
		planetsR.push_back(planet);
		tangentMesh->drop();

		moonNode = smgr->addEmptySceneNode(planetNode);
		moonMesh = smgr->addSphereMesh("Moon12",1.0,48,48);
		
		tangentMesh = smgr->getMeshManipulator()->createMeshWithTangents(moonMesh,false,true);
		tangentMesh->setHardwareMappingHint(scene::EHM_STATIC);
		scale = core::vector3df((mSize[12]/scaleF),(mSize[12]/scaleF),(mSize[12]/scaleF));
		smgr->getMeshManipulator()->scale(tangentMesh,scale);

		moon = smgr->addMeshSceneNode(tangentMesh,moonNode);
		moonNode->setPosition(core::vector3df(0,0,mDist[12]));
		moon->setMaterialType(video::EMT_NORMAL_MAP_SOLID);
		moon->setMaterialTexture(0,tex28);
		moon->setMaterialTexture(1,tex29);
		moon->setName("Puck");
		moons.push_back(moonNode);
		moonsR.push_back(moon);
		tangentMesh->drop();

		moonNode = smgr->addEmptySceneNode(planetNode);
		moonMesh = smgr->addSphereMesh("Moon13",1.0,48,48);
		
		tangentMesh = smgr->getMeshManipulator()->createMeshWithTangents(moonMesh,false,true);
		tangentMesh->setHardwareMappingHint(scene::EHM_STATIC);
		scale = core::vector3df((mSize[13]/scaleF),(mSize[13]/scaleF),(mSize[13]/scaleF));
		smgr->getMeshManipulator()->scale(tangentMesh,scale);

		moon = smgr->addMeshSceneNode(tangentMesh,moonNode);
		moonNode->setPosition(core::vector3df(0,0,mDist[13]));
		moon->setMaterialType(video::EMT_NORMAL_MAP_SOLID);
		moon->setMaterialTexture(0,tex28);
		moon->setMaterialTexture(1,tex29);
		moon->setName("Miranda");
		moons.push_back(moonNode);
		moonsR.push_back(moon);
		tangentMesh->drop();

		moonNode = smgr->addEmptySceneNode(planetNode);
		moonMesh = smgr->addSphereMesh("Moon14",1.0,48,48);
		
		tangentMesh = smgr->getMeshManipulator()->createMeshWithTangents(moonMesh,false,true);
		tangentMesh->setHardwareMappingHint(scene::EHM_STATIC);
		scale = core::vector3df((mSize[14]/scaleF),(mSize[14]/scaleF),(mSize[14]/scaleF));
		smgr->getMeshManipulator()->scale(tangentMesh,scale);

		moon = smgr->addMeshSceneNode(tangentMesh,moonNode);
		moonNode->setPosition(core::vector3df(0,0,mDist[14]));
		moon->setMaterialType(video::EMT_NORMAL_MAP_SOLID);
		moon->setMaterialTexture(0,tex28);
		moon->setMaterialTexture(1,tex29);
		moon->setName("Ariel");
		moons.push_back(moonNode);
		moonsR.push_back(moon);
		tangentMesh->drop();

		moonNode = smgr->addEmptySceneNode(planetNode);
		moonMesh = smgr->addSphereMesh("Moon15",1.0,48,48);
		
		tangentMesh = smgr->getMeshManipulator()->createMeshWithTangents(moonMesh,false,true);
		tangentMesh->setHardwareMappingHint(scene::EHM_STATIC);
		scale = core::vector3df((mSize[15]/scaleF),(mSize[15]/scaleF),(mSize[15]/scaleF));
		smgr->getMeshManipulator()->scale(tangentMesh,scale);

		moon = smgr->addMeshSceneNode(tangentMesh,moonNode);
		moonNode->setPosition(core::vector3df(0,0,mDist[15]));
		moon->setMaterialType(video::EMT_NORMAL_MAP_SOLID);
		moon->setMaterialTexture(0,tex28);
		moon->setMaterialTexture(1,tex29);
		moon->setName("Umbriel");
		moons.push_back(moonNode);
		moonsR.push_back(moon);
		tangentMesh->drop();

		moonNode = smgr->addEmptySceneNode(planetNode);
		moonMesh = smgr->addSphereMesh("Moon16",1.0,48,48);
		
		tangentMesh = smgr->getMeshManipulator()->createMeshWithTangents(moonMesh,false,true);
		tangentMesh->setHardwareMappingHint(scene::EHM_STATIC);
		scale = core::vector3df((mSize[16]/scaleF),(mSize[16]/scaleF),(mSize[16]/scaleF));
		smgr->getMeshManipulator()->scale(tangentMesh,scale);
		
		moon = smgr->addMeshSceneNode(tangentMesh,moonNode);
		moonNode->setPosition(core::vector3df(0,0,mDist[16]));
		moon->setMaterialType(video::EMT_NORMAL_MAP_SOLID);
		moon->setMaterialTexture(0,tex28);
		moon->setMaterialTexture(1,tex29);
		moon->setName("Titania");
		moons.push_back(moonNode);
		moonsR.push_back(moon);
		tangentMesh->drop();

		moonNode = smgr->addEmptySceneNode(planetNode);
		moonMesh = smgr->addSphereMesh("Moon17",1.0,48,48);
		
		tangentMesh = smgr->getMeshManipulator()->createMeshWithTangents(moonMesh,false,true);
		tangentMesh->setHardwareMappingHint(scene::EHM_STATIC);
		scale = core::vector3df((mSize[17]/scaleF),(mSize[17]/scaleF),(mSize[17]/scaleF));
		smgr->getMeshManipulator()->scale(tangentMesh,scale);
		
		moon = smgr->addMeshSceneNode(tangentMesh,moonNode);
		moonNode->setPosition(core::vector3df(0,0,mDist[17]));
		moon->setMaterialType(video::EMT_NORMAL_MAP_SOLID);
		moon->setMaterialTexture(0,tex28);
		moon->setMaterialTexture(1,tex29);
		moon->setName("Oberon");
		moons.push_back(moonNode);
		moonsR.push_back(moon);
		tangentMesh->drop();
		break;
	case 7:
		planetNode = smgr->addEmptySceneNode();
		planetMesh = smgr->addSphereMesh("Neptune",20.0,48,48);

		tangentMesh = smgr->getMeshManipulator()->createMeshWithTangents(planetMesh,false,true);
		tangentMesh->setHardwareMappingHint(scene::EHM_STATIC);
		scale = core::vector3df((planetSize[i]/scaleF/20.0),(planetSize[i]/scaleF/20.0),(planetSize[i]/scaleF/20.0));
		smgr->getMeshManipulator()->scale(tangentMesh,scale);

		planet = smgr->addMeshSceneNode(tangentMesh);
		planet->setMaterialFlag(video::EMF_NORMALIZE_NORMALS, true);
		planet->setMaterialType(video::EMT_NORMAL_MAP_SOLID);
		planet->setMaterialTexture(0,tex15);
		planet->setMaterialTexture(1,tex10);
		planet->setRotation(core::vector3df(0,0,-30));
		planetNode->setName("neptune");

		SOInode = smgr->addEmptySceneNode();
		SOIMesh = smgr->addSphereMesh("SOI7",1.0,48,48);
		SOIMesh->setHardwareMappingHint(scene::EHM_STATIC);
		smgr->getMeshManipulator()->setVertexColors(SOIMesh,OrbitCol[i]);
		SOIscale = core::vector3df((pSOI[i]/scaleF),(pSOI[i]/scaleF),(pSOI[i]/scaleF));
		smgr->getMeshManipulator()->scale(SOIMesh,SOIscale);
		SOInode = smgr->addMeshSceneNode(SOIMesh);
		SOInode->setMaterialFlag(video::EMF_WIREFRAME, true);
		SOInode->setMaterialFlag(video::EMF_BACK_FACE_CULLING, false);
		SOInode->setVisible(false);
		SOInode->setParent(planetNode);
		SOINodes.push_back(SOInode);

		planet->setParent(planetNode);
		planets.push_back(planetNode);
		planetsR.push_back(planet);
		tangentMesh->drop();
		break;
	case 8:
		planetNode = smgr->addEmptySceneNode();
		planetMesh = smgr->addSphereMesh("Pluto",20.0,48,48);

		tangentMesh = smgr->getMeshManipulator()->createMeshWithTangents(planetMesh,false,true);
		tangentMesh->setHardwareMappingHint(scene::EHM_STATIC);
		scale = core::vector3df((planetSize[i]/scaleF/20.0),(planetSize[i]/scaleF/20.0),(planetSize[i]/scaleF/20.0));
		smgr->getMeshManipulator()->scale(tangentMesh,scale);

		planet = smgr->addMeshSceneNode(tangentMesh);
		planet->setMaterialFlag(video::EMF_NORMALIZE_NORMALS, true);
		planet->setMaterialType(video::EMT_NORMAL_MAP_SOLID);
		planet->setMaterialTexture(0,tex17);
		planet->setMaterialTexture(1,tex18);
		planet->setRotation(core::vector3df(0,0,-120));
		planetNode->setName("pluto");

		SOInode = smgr->addEmptySceneNode();
		SOIMesh = smgr->addSphereMesh("SOI8",1.0,48,48);
		SOIMesh->setHardwareMappingHint(scene::EHM_STATIC);
		smgr->getMeshManipulator()->setVertexColors(SOIMesh,OrbitCol[i]);
		SOIscale = core::vector3df((pSOI[i]/scaleF),(pSOI[i]/scaleF),(pSOI[i]/scaleF));
		smgr->getMeshManipulator()->scale(SOIMesh,SOIscale);
		SOInode = smgr->addMeshSceneNode(SOIMesh);
		SOInode->setMaterialFlag(video::EMF_WIREFRAME, true);
		SOInode->setMaterialFlag(video::EMF_BACK_FACE_CULLING, false);
		SOInode->setVisible(false);
		SOInode->setParent(planetNode);
		SOINodes.push_back(SOInode);

		planet->setParent(planetNode);
		planets.push_back(planetNode);
		planetsR.push_back(planet);
		tangentMesh->drop();
		break;
		}
	}
	sunMesh = smgr->addSphereMesh("Sun",20.0,48,48);
	scene::ISceneNode* Sun = smgr->addMeshSceneNode(sunMesh);
	Sun->setScale(core::vector3df(planetSize[9]/scaleF/20.0,planetSize[9]/scaleF/20.0,planetSize[9])/scaleF/20.0);
	Sun->setMaterialFlag(video::EMF_LIGHTING, false);
	Sun->setMaterialType(video::EMT_LIGHTMAP);
	Sun->setMaterialTexture(0,sun);
	
	scene::IBillboardSceneNode* sunBill = smgr->addBillboardSceneNode(Sun,core::dimension2df(planetSize[9]/scaleF,planetSize[9]/scaleF)*15.5);
	sunBill->setMaterialFlag(video::EMF_LIGHTING, false);
	sunBill->setMaterialType(video::EMT_TRANSPARENT_ADD_COLOR);
	sunBill->setMaterialTexture(0,sunbill);

	planets.push_back(Sun);

}

pilesofspam · Post by **pilesofspam** » Mon Mar 22, 2010 8:59 pm

@zillion42- Thanks! I'll spend some time going over it in more detail tonight, but it looks like you're doing a much more physically detailed version of the solar system. I'm going back to basics- if I take the specific case of planet 2 (earth) it appears that you create an empty scene node (planetNode) then make that the parent of the planet. Later on you create a moonNode, which also has planetNode as the parent, but then moon is child of moonNode.

Holy cow!

What I was trying to do is make a scene node sphere planet with no parent, then make a scene node sphere moon with the planet as parent. Here's a simplified version (one planet, one moon) of what I'm doing:

Code: Select all

scene::ISceneNode* Planet = smgr->addSphereSceneNode(1.0,64,0, -1, core::vector3df(0, 0, 0), core::vector3df(0, 0, 0),
        core::vector3df(2000, 2000, 2000));

if (Planet)
    {
        Planet->setMaterialTexture(0, driver->getTexture(texturename));
        Planet->setMaterialFlag(video::EMF_LIGHTING, false);
    }
    //make it rotate!
    rotateanim =               smgr->createRotationAnimator(core::vector3df(0, RotationSpeed, 0));
                Planet->addAnimator(rotateanim);
                rotateanim->drop();
    //now make it orbit!
    orbitanim =
         smgr->createFlyCircleAnimator(core::vector3df(0.f, 0.f, 0.f), 6000, .0001f, core::vector3df(0.f, 1.f, 0.f), 0);
            Planet->addAnimator(orbitanim);
            orbitanim->drop(); 

//add a moon!


scene::ISceneNode* Moon = smgr->addSphereSceneNode(1.0,64, Planet, -1, core::vector3df(0, 0, 0), core::vector3df(0, 0, 0),
        core::vector3df(400, 400, 400)); 

if (Moon)
    {
        Moon->setMaterialTexture(0, driver->getTexture(texturename));
        Moon->setMaterialFlag(video::EMF_LIGHTING, false);
    }

But my moon doesn't appear when I specify the planet as parent. It works fine if I specify 0 as the parent. Do I need to specify a parent, and then apply the planet and the moon as children?

pilesofspam · Post by **pilesofspam** » Tue Mar 23, 2010 12:48 am

Many thanks to zillion42, I've got something pretty simple that I can work with. Here's an example that makes the moon rotate around the earth. Create an empty Iscenenode, make it the parent of both the planet and the moon. Then do a flycircleanimator on the empty parent scene node to make it orbit the center of the universe. Do a rotationanimator on it to make the planet rotate (the moon will rotate with it) and do an additional createflycircleanimator on the moon to make it orbit the planet (which is located at the same place as the empty scene node). Here's the code:

Code: Select all

scene::ISceneNode* PlanetNode = smgr->addEmptySceneNode();
scene::ISceneNode* Planet = smgr->addSphereSceneNode(1.0,64,PlanetNode, -1, core::vector3df(0, 0, 0), core::vector3df(0, 0, 0),
        core::vector3df(2000, 2000, 2000));

if (Planet)
    {
        Planet->setMaterialTexture(0, driver->getTexture("./textures/earthmap1k.jpg"));
        Planet->setMaterialFlag(video::EMF_LIGHTING, false);
    }
    //make it rotate!
    rotateanim =               smgr->createRotationAnimator(core::vector3df(0, 0.5f, 0));
                PlanetNode->addAnimator(rotateanim);
                rotateanim->drop();
    //now make it orbit!
    orbitanim =
         smgr->createFlyCircleAnimator(core::vector3df(0.f, 0.f, 0.f), 20000, .0001f, core::vector3df(0.f, 1.f, 0.f), 0);
            PlanetNode->addAnimator(orbitanim);
            orbitanim->drop();

//add a moon!


scene::ISceneNode* Moon = smgr->addSphereSceneNode(1.0,64, PlanetNode, -1, core::vector3df(0, 0, 0), core::vector3df(0, 0, 0),
        core::vector3df(400, 400, 400));

if (Moon)
    {
        Moon->setMaterialTexture(0, driver->getTexture("./textures/moonmap1k.jpg"));
        Moon->setMaterialFlag(video::EMF_LIGHTING, false);

        orbitanim =
         smgr->createFlyCircleAnimator(core::vector3df(0.f, 0.f, 0.f), 5000, .001f, core::vector3df(0.f, 1.f, 0.f), 0);
            Moon->addAnimator(orbitanim);
            orbitanim->drop();
    }