Sorry your browser is not supported!

myTerrain->Scale.X = 10;
myTerrain->Scale.Y = 10;

class PlanetManager
{
public:
// Method(s)
	static	PlanetManager&	get(); // Get a singleton of this class
	
	Planet&		createPlanet( const std::string& name );
	void		destroyPlanet( Planet& );
	void		killAll();
	bool		destroying( Planet& );
	
	void	update( f32 elapsed );
	
private:
// Constructor(s)/Destructor
	PlanetManager();
	PlanetManager( PlanetManager const& ); // Hide
	~PlanetManager();
	
// Assignment operator(s)
	PlanetManager& operator = ( PlanetManager const& ); // Hide
	
// Data member(s)
	std::vector<Planet*>	planetList_;
	Planet*					currentlyDestroying_;
	gdk::DynamicIdHandler	planetID_;
};

PlanetManager& PlanetManager::get()
{
	static PlanetManager singleton;
	return singleton;
}

Planet& PlanetManager::createPlanet( const std::string& name )
{
	Planet* instance = new Planet( planetID_.getFreeID(), name );
	gdk::autoResizeVector( planetList_, instance->getIndex() );
	planetList_[instance->getIndex()] = instance;
	return *instance;
}

void PlanetManager::destroyPlanet( Planet& instance )
{
	THROW_IF( instance.getRefCount() == 1, "Ref count must be 1 to destroy the planet" );
	currentlyDestroying_ = &instance;
	planetList_[instance.getIndex()] = nullptr;
	planetID_.addFreeID( instance.getIndex() );
	instance.release();
}

Planet::~Planet()
{
	THROW_IF( PlanetManager::get().destroying( *this ), "Planet must be destroyed via PlanetManager::destroyPlanet" );
	
	...blah blah, rest of cleanup code...
}

class ObjectManager
{
public:
// Method(s)
	static ObjectManager&	get(); // Get a singleton of this class
	
	// Creation/destruction
	Object&	createObject( u32 vertCount, u32 indexCount, u32 FVF ); // Create a raw object from an FVF format
	Object&	createObject( Object::PrimType = Object::PRIM_CUSTOM ); // Create a primitive object
	Object&	createObject( const std::string& meshPath, bool associatePath = false ); // Create an object from file
	
	void	destroyObject( Object* ); // Destroy an object via ptr, checks against 'nullptr' first - Requires: refCount == 1
	void	destroyObject( Object& ); // Destroy an object via reference - Requires: refCount == 1
	
	// Set
	void	setObserver( const Camera&, bool update = false ); // Specify which camera is currently observing the objects
	
	// Get
	const Camera*	getObserver() const;
	const Camera&	getObserverRef() const;
	
	// Other
	void	updateObserver(); // Move all objects around the observer
	Object*	findObject( const std::string& handle );
	Object&	findObjectRef( const std::string& handle );
	
private:
// Constructor(s)/Destructor
	ObjectManager();
	ObjectManager( ObjectManager const& ); // Hide
	~ObjectManager();
	
// Assignment operator(s)
	ObjectManager& operator = ( ObjectManager const& ); // Hide
	
// Method(s)
	void	updateObserver( Object&, const Position& ); // Move a specific object around the camera
	void	registerObject( Object& );
	void	unregisterObject( Object& );
	
	bool	destroying( Object& ); // Check which object is currently being destroyed
	void	freeResources(); // Deallocate everything
	
// Data member(s)
	std::vector<Object*>			objectList_;
	std::map<std::string,Object*>	objectAssociationMap_;
	gdk::DynamicIdHandler			objectId_;
	Object*							currentlyDestroying_;
	const Camera*					observer_;
	
// Access
	friend class Object;
	friend class Application;
};

class BaseObj
{
public:
	BaseObj(void);
	BaseObj(const BaseObj&);
	~BaseObj(void);

	BaseObj& operator=(const BaseObj&);

	ObjType Type;

	char* Name;

	int ID;

	virtual void Delete(void);
	virtual void Load(char* filename) = 0;
};

class BaseObj
{
private:
	ObjType Type;
	char* Name;
	int ID;
public:
	BaseObj(void);
	BaseObj(const BaseObj&);
	~BaseObj(void);

	BaseObj& operator=(const BaseObj&);

	virtual void Delete(void);
	virtual void Load(char* filename) = 0;
};

int TerrainObj::Make(void)
{
	dbMakeObjectTerrain(this->ID);
	dbSetTerrainScale(this->ID, this->HightMapScale.getX(), this->HightMapScale.getY(), this->HightMapScale.getZ());
	dbSetTerrainSplit(this->ID, this->Split);
	dbSetTerrainTiling(this->ID, this->Tiling);
	dbSetTerrainLight(this->ID,
		this->Lighting.getDirection().XDir, this->Lighting.getDirection().YDir, this->Lighting.getDirection().ZDir,
		this->Lighting.getColor().Red, this->Lighting.getColor().Green, this->Lighting.getColor().Blue,
		this->Lighting.getScale());
	if(this->HightMapFile)
	{
		dbSetTerrainHeightMap(this->ID, this->HightMapFile);
	}
	else
	{
		return 1;
	}
	if(this->BaseTexture && this->DetailTexture)
	{
		dbSetTerrainTexture(this->ID, this->BaseTexture->ID, this->DetailTexture->ID);
	}
	else
	{
		return 2;
	}
	return 0;
}

int TerrainObj::Build(void)
{
	int maker = this->Make();
	if(maker == 0)
	{
		dbBuildTerrain(this->ID);
		this->Width = dbGetTerrainXSize(this->ID);
		this->Depth = dbGetTerrainZSize(this->ID);
	}
	else
	{
		return maker;
	}
	return 0;
}