//------------------------------------------------------------------------------
// Lamp : Open source game middleware
// Copyright (C) 2004  Junpei Ohtani ( Email : junpee@users.sourceforge.jp )
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//------------------------------------------------------------------------------

/** @file
 * コリジョンオブジェクトヘッダ
 * @author Junpee
 */

#ifndef COLLISION_OBJECT_H_
#define COLLISION_OBJECT_H_

namespace Lamp{

class CollisionScene;
class CollisionNode;
class CollisionLeaf;
class StaticCollisionLeaf;
class StaticSphereCollision;
class StaticDeformedMeshCollision;
class DynamicCollisionLeaf;

//------------------------------------------------------------------------------
/**
 * コリジョンオブジェクト
 */
class CollisionObject{
friend class CollisionScene;
friend class CollisionNode;
public:
	//--------------------------------------------------------------------------
	// 走査
	//--------------------------------------------------------------------------
	/**
	 * 走査
	 */
	virtual void traverse();

	//--------------------------------------------------------------------------
	// メンバアクセサ
	//--------------------------------------------------------------------------
	/**
	 * 名前の取得
	 * @return 名前
	 */
	virtual const String& getName() const{ return name_; }

	//--------------------------------------------------------------------------
	/**
	 * シーンの取得
	 * @return シーン
	 */
	virtual CollisionScene* getScene() const{ return scene_; }

	//--------------------------------------------------------------------------
	/**
	 * 親の取得
	 * @return 親
	 */
	virtual CollisionNode* getParent() const{ return parent_; }

	//--------------------------------------------------------------------------
	// 有効、無効
	//--------------------------------------------------------------------------
	/**
	 * 有効、無効の設定
	 * @param enabled trueなら有効、falseなら無効
	 */
	virtual void setEnabled(bool enabled){
		enabled_ = enabled;
		setChanged(true);
	}

	/**
	 * 有効、無効の取得
	 * @return trueなら有効、falseなら無効
	 */
	virtual bool isEnabled() const{ return enabled_; }

	/**
	 * グローバルでの有効、無効の取得
	 * @return trueなら有効、falseなら無効
	 */
	virtual bool isGlobalEnabled() const{ return globalEnabled_; }

	//--------------------------------------------------------------------------
	// ユーザデータ
	//--------------------------------------------------------------------------
	/**
	 * ユーザデータの設定
	 * @param userData ユーザデータ
	 */
	virtual void setUserData(void* userData){ userData_ = userData; }

	/**
	 * ユーザデータの取得
	 * @return ユーザデータ
	 */
	virtual void* getUserData(){ return userData_; }

	//--------------------------------------------------------------------------
	// 変更フラグ
	//--------------------------------------------------------------------------
	/**
	 * グローバルでの変更フラグの取得
	 * @return グローバルで変更されていればtrue
	 */
	virtual bool isGlobalChanged() const{ return globalChanged_; }

	//--------------------------------------------------------------------------
	// コピー
	//--------------------------------------------------------------------------
	/**
	 * コピー
	 * @return コピーされたコリジョンオブジェクト
	 */
	virtual CollisionObject* copy() const = 0;

	/**
	 * 再帰的破棄
	 * @param collisionObject 破棄するコリジョンオブジェクト
	 * @return 破棄したオブジェクト数
	 */
	static int recursiveDestroy(CollisionObject* collisionObject);

	//--------------------------------------------------------------------------
	// RTTI
	//--------------------------------------------------------------------------
	/**
	 * コリジョンノードかどうか
	 * @return コリジョンノードならtrue
	 */
	virtual bool isCollisionNode() const{ return false; }

	/**
	 * コリジョンノードへのキャスト
	 * @return コリジョンノード。型が違えばNULLを返す。
	 */
	virtual CollisionNode* castCollisionNode() const{
		if(isCollisionNode()){ return (CollisionNode*)this; }
		return NULL;
	}

	//--------------------------------------------------------------------------
	/**
	 * コリジョンリーフかどうか
	 * @return コリジョンリーフならtrue
	 */
	virtual bool isCollisionLeaf() const{ return false; }

	/**
	 * コリジョンリーフへのキャスト
	 * @return コリジョンリーフ。型が違えばNULLを返す。
	 */
	virtual CollisionLeaf* castCollisionLeaf() const{
		if(isCollisionLeaf()){ return (CollisionLeaf*)this; }
		return NULL;
	}

	//--------------------------------------------------------------------------
	// 静的コリジョンリーフRTTI
	//--------------------------------------------------------------------------
	/**
	 * 静的コリジョンリーフかどうか
	 * @return 静的コリジョンリーフならtrue
	 */
	virtual bool isStaticCollisionLeaf() const{ return false; }

	/**
	 * 静的コリジョンリーフへのキャスト
	 * @return 静的コリジョンリーフ。型が違えばNULLを返す。
	 */
	virtual StaticCollisionLeaf* castStaticCollisionLeaf() const{
		if(isStaticCollisionLeaf()){ return (StaticCollisionLeaf*)this; }
		return NULL;
	}

	//--------------------------------------------------------------------------
	/**
	 * 静的球コリジョンかどうか
	 * @return 静的球コリジョンならtrue
	 */
	virtual bool isStaticSphereCollision() const{ return false; }

	/**
	 * 静的球コリジョンへのキャスト
	 * @return 静的球コリジョン。型が違えばNULLを返す。
	 */
	virtual StaticSphereCollision* castStaticSphereCollision() const{
		if(isStaticSphereCollision()){ return (StaticSphereCollision*)this; }
		return NULL;
	}

	//--------------------------------------------------------------------------
	/**
	 * 静的変形メッシュコリジョンかどうか
	 * @return 静的変形メッシュコリジョンならtrue
	 */
	virtual bool isStaticDeformedMeshCollision() const{ return false; }

	/**
	 * 静的変形メッシュコリジョンへのキャスト
	 * @return 静的変形メッシュコリジョン。型が違えばNULLを返す。
	 */
	virtual StaticDeformedMeshCollision*
		castStaticDeformedMeshCollision() const{
		if(isStaticDeformedMeshCollision()){
			return (StaticDeformedMeshCollision*)this;
		}
		return NULL;
	}

	//--------------------------------------------------------------------------
	// 動的コリジョンリーフRTTI
	//--------------------------------------------------------------------------
	/**
	 * 動的コリジョンリーフかどうか
	 * @return 動的コリジョンリーフならtrue
	 */
	virtual bool isDynamicCollisionLeaf() const{ return false; }

	/**
	 * 動的コリジョンリーフへのキャスト
	 * @return 動的コリジョンリーフ。型が違えばNULLを返す。
	 */
	virtual DynamicCollisionLeaf* castDynamicCollisionLeaf() const{
		if(isDynamicCollisionLeaf()){ return (DynamicCollisionLeaf*)this; }
		return NULL;
	}

protected:
	//--------------------------------------------------------------------------
	// 生成、破棄
	//--------------------------------------------------------------------------
	/**
	 * コンストラクタ
	 * @param name 名前
	 * @param scene シーン
	 */
	CollisionObject(const String& name, CollisionScene* scene) :
		name_(name), scene_(scene), parent_(NULL), userData_(NULL),
		enabled_(true), changed_(true), globalChanged_(true){
		// globalEnabled_の初期値はNodeかLeafかで違う
	}

	/**
	 * デストラクタ
	 */
	virtual ~CollisionObject(){}

	//--------------------------------------------------------------------------
	// コピー
	//--------------------------------------------------------------------------
	/**
	 * コリジョンオブジェクトの値コピー
	 * @param destination コピー先コリジョンオブジェクト
	 */
	virtual void copyCollisionObjectValue(CollisionObject* destination) const{
		destination->enabled_ = enabled_;
		Assert(destination->changed_);
	}

	//--------------------------------------------------------------------------
	// 走査
	//--------------------------------------------------------------------------
	/**
	 * 走査
	 * @param parentMatrix 親行列
	 * @param parentEnabled 親が有効か
	 * @param parentScaled 親がスケールを使用しているか
	 * @param parentChanged 親に変更があったか
	 */
	// なぜかtraverse()だとオーバーロードされない、publicのtraverseが隠蔽される
	virtual void traverseImplement(const Matrix34& parentMatrix,
		bool parentEnabled, bool parentScaled, bool parentChanged) = 0;

	//--------------------------------------------------------------------------
	// 有効、無効
	//--------------------------------------------------------------------------
	/**
	 * グローバルでの有効、無効の設定
	 * @param globalEnabled trueなら有効、falseなら無効
	 */
	virtual void setGlobalEnabled(bool globalEnabled){
		globalEnabled_ = globalEnabled;
	}

	//--------------------------------------------------------------------------
	// 変更フラグ
	//--------------------------------------------------------------------------
	/**
	 * 変更フラグの取得
	 * @return 変更されていればtrue
	 */
	virtual bool isChanged() const{ return changed_; }

	/**
	 * 変更フラグの設定
	 * @param changed trueなら有効、falseなら無効
	 */
	virtual void setChanged(bool changed){ changed_ = changed; }

	/**
	 * グローバルでの変更フラグの設定
	 * @param globalChanged trueなら有効、falseなら無効
	 */
	virtual void setGlobalChanged(bool globalChanged){
		globalChanged_ = globalChanged;
	}

	//--------------------------------------------------------------------------
	// 親
	//--------------------------------------------------------------------------
	/**
	 * 親の設定
	 * @param parent 設定する親
	 */
	virtual void setParent(CollisionNode* parent){
		Assert(parent != NULL);
		Assert(parent_ == NULL);
		parent_ = parent;
		setChanged(true);
		// globalEnabled_をNodeとLeafで設定する
	}

	/**
	 * 親の削除
	 * @param parent 削除する親
	 */
	virtual void removeParent(CollisionNode* parent){
		Assert(parent_ != NULL);
		Assert(parent_ == parent);
		parent_ = NULL;
		setChanged(true);
		// globalEnabled_をNodeとLeafで設定する
	}

private:
	//--------------------------------------------------------------------------
	// コピーコンストラクタの隠蔽
	CollisionObject(const CollisionObject& copy);

	// 代入コピーの隠蔽
	void operator =(const CollisionObject& copy);

	//--------------------------------------------------------------------------
	// 名前
	String name_;
	// シーン
	CollisionScene* scene_;
	// 親
	CollisionNode* parent_;
	// ユーザデータ
	void* userData_;
	// 有効、無効フラグ
	bool enabled_;
	// グローバルでの有効無効フラグ
	bool globalEnabled_;
	// 変更フラグ
	bool changed_;
	// グローバルでの変更フラグ
	bool globalChanged_;

};

//------------------------------------------------------------------------------
} // End of namespace Lamp
#endif // End of COLLISION_OBJECT_H_
//------------------------------------------------------------------------------
