//------------------------------------------------------------------------------
// 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 MESH_H_
#define MESH_H_

#include <Graphics/Scene/SceneObject.h>
#include <Graphics/System/GraphicsDeviceObjectHolder.h>
#include <Core/Container/ArrayList.h>

namespace Lamp{

class Model;
class MeshData;
class Material;
class RigidMesh;
class CharacterMesh;

//------------------------------------------------------------------------------
/**
 * メッシュ
 */
class Mesh : public SceneObject , public GraphicsDeviceObjectHolder{
friend class SceneObjectManagerTemplate<Mesh>;
friend class Renderer;
friend class MeshManager;
friend class Model;
friend class Shader;
friend class FixedShader;
public:
	/**
	 * リファレンスカウントの取得
	 * @return リファレンスカウント
	 */
	virtual int getReferenceCount() const{
		if(parent_ != NULL){ return 1; }
		return 0;
	}

	//--------------------------------------------------------------------------
	/**
	 * コピー
	 * @param copyMask コピーマスク
	 * @return コピーされたメッシュ
	 */
	virtual Mesh* copy(u_int copyMask = 0) const = 0;

	/**
	 * 再帰的破棄
	 * @param mesh 破棄するメッシュ
	 * @return 破棄したオブジェクト数
	 */
	static int recursiveDestroy(Mesh* mesh);

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

	//--------------------------------------------------------------------------
	/**
	 * グローバルでスケールを使用しているか
	 * @return グローバルでスケールを使用しているならtrue
	 */
	virtual bool isGlobalScaled() const{ return globalScaled_; }

	/**
	 * 法線の正規化を必要とするか
	 * @return 法線の正規化を必要とするならtrue
	 */
	virtual bool requireNormalize() const{ return false; }

	//--------------------------------------------------------------------------
	// バウンディングスフィア
	//--------------------------------------------------------------------------
	/**
	 * バウンディングスフィアの設定
	 * @param boundingSphere 設定するバウンディングスフィア
	 */
	virtual void setBoundingSphere(const Sphere& boundingSphere);

	/**
	 * バウンディングスフィアの取得
	 * @return バウンディングスフィア
	 */
	virtual const Sphere& getBoundingSphere() const;

	/**
	 * ワールドバウンディングスフィアの取得
	 * @return ワールドバウンディングスフィア
	 */
	virtual const Sphere& getWorldBoundingSphere() const{
		return worldBoundingSphere_;
	}

	//--------------------------------------------------------------------------
	// バウンディングボックス
	//--------------------------------------------------------------------------
	/**
	 * バウンディングボックスの設定
	 * @param boundingBox 設定するバウンディングボックス
	 */
	virtual void setBoundingBox(const AxisAlignedBox& boundingBox);

	/**
	 * バウンディングボックスの取得
	 * @return バウンディングボックス
	 */
	virtual const AxisAlignedBox& getBoundingBox() const;

	/**
	 * ワールドバウンディングボックスの取得
	 * @return ワールドバウンディングボックス
	 */
	virtual const AxisAlignedBox& getWorldBoundingBox() const{
		return worldBoundingBox_;
	}

	//--------------------------------------------------------------------------
	// 中心
	//--------------------------------------------------------------------------
	/**
	 * 中心の取得
	 * @return 中心
	 */
	virtual const Vector3& getCenter() const;

	/**
	 * ワールド中心の取得
	 * @return ワールド中心
	 */
	virtual const Vector3& getWorldCenter() const{
		return worldBoundingSphere_.getCenter();
	}

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

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

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

	//--------------------------------------------------------------------------
	// メッシュデータインターフェース
	//--------------------------------------------------------------------------
	/**
	 * メッシュデータの設定
	 * @param meshData 設定するメッシュデータ
	 */
	virtual void setMeshData(MeshData* meshData);

	/**
	 * メッシュデータの取得
	 * @return メッシュデータ
	 */
	virtual MeshData* getMeshData() const{ return meshData_; }

	/**
	 * メッシュデータの削除
	 */
	virtual void removeMeshData(){ setMeshData(NULL); }

	//--------------------------------------------------------------------------
	// マテリアルインターフェース
	//--------------------------------------------------------------------------
	/**
	 * マテリアルの設定
	 * @param material 設定するマテリアル
	 */
	virtual void setMaterial(Material* material);

	/**
	 * マテリアルの取得
	 * @return マテリアル
	 */
	virtual Material* getMaterial() const{ return material_; }

	/**
	 * マテリアルの削除
	 */
	virtual void removeMaterial(){ setMaterial(NULL); }

	//--------------------------------------------------------------------------
	// プリミティブタイプ
	//--------------------------------------------------------------------------
	/// プリミティブタイプ
	enum PrimitiveType{
		/// トライアングルリスト
		triangleList = 0,
		/// インデックストライアングルリスト
		indexedTriangleList,
		/// プリミティブタイプ最大値
		ptMax,
	};

	/**
	 * プリミティブタイプがインデックスを持つかどうか
	 * @param primitiveType プリミティブタイプ
	 * @return プリミティブタイプがインデックスを持つならtrue
	 */
	static bool primitiveTypeHasIndex(PrimitiveType primitiveType);

	/**
	 * プリミティブタイプから文字列への変換
	 * @param primitiveType プリミティブタイプ
	 * @return プリミティブタイプ文字列
	 */
	static String primitiveTypeToString(PrimitiveType primitiveType);

	/**
	 * 文字列からプリミティブタイプへの変換
	 * @param primitiveTypeString プリミティブタイプ文字列
	 * @return プリミティブタイプ
	 */
	static PrimitiveType primitiveTypeFromString(
		const String& primitiveTypeString);

	//--------------------------------------------------------------------------
	// メッシュインターフェース
	//--------------------------------------------------------------------------
	/**
	 * プリミティブタイプの設定
	 * @param primitiveType プリミティブタイプ
	 */
	virtual void setPrimitiveType(Mesh::PrimitiveType primitiveType);

	/**
	 * プリミティブタイプの取得
	 * @return プリミティブタイプ
	 */
	virtual Mesh::PrimitiveType getPrimitiveType() const;

	/**
	 * プリミティブカウントの取得
	 * @return プリミティブカウント
	 */
	virtual int getPrimitiveCount() const;

	/**
	 * 三角の取得
	 * @param index プリミティブインデックス
	 * @return 三角
	 */
	virtual Triangle getTriangle(int index) const;

	//--------------------------------------------------------------------------
	/**
	 * 頂点インデックスを持つかどうか
	 * @return 頂点インデックスを持つならtrue
	 */
	virtual bool hasVertexIndices() const;

	/**
	 * 頂点インデックス数の設定
	 * @param vertexIndexCount 頂点インデックス数
	 */
	virtual void setVertexIndexCount(int vertexIndexCount);

	/**
	 * 頂点インデックス数の取得
	 * @return 頂点インデックス数
	 */
	virtual int getVertexIndexCount() const;

	/**
	 * 頂点インデックスの設定
	 * @param index インデックス
	 * @param vertexIndex 頂点インデックス
	 */
	virtual void setVertexIndex(int index, int vertexIndex);

	/**
	 * 頂点インデックスの取得
	 * @param index インデックス
	 * @return 頂点インデックス
	 */
	virtual int getVertexIndex(int index) const;

	/**
	 * 頂点インデックス配列の取得
	 * @return 頂点インデックス配列
	 */
	virtual const u_short* getVertexIndexArray();

	//--------------------------------------------------------------------------
	/**
	 * 頂点数の設定
	 * @param vertexCount 頂点数
	 */
	virtual void setVertexCount(int vertexCount);

	/**
	 * 頂点数の取得
	 * @return 頂点数
	 */
	virtual int getVertexCount() const;

	//--------------------------------------------------------------------------
	/**
	 * 位置の設定
	 * @param index インデックス
	 * @param position 位置
	 */
	virtual void setPosition(int index, const Vector3& position);

	/**
	 * 位置の取得
	 * @param index インデックス
	 * @return 位置
	 */
	virtual const Vector3& getPosition(int index) const;

	/**
	 * 位置配列の取得
	 * @return 位置配列
	 */
	virtual const Vector3* getPositionArray() const;

	//--------------------------------------------------------------------------
	/**
	 * 法線を有効にするかどうか
	 * @param normalFlag trueなら法線が有効になる
	 */
	virtual void enableNormal(bool normalFlag);

	/**
	 * 法線が有効かどうか
	 * @return 法線が有効ならtrue
	 */
	virtual bool hasNormal() const;

	/**
	 * 法線の設定
	 * @param index インデックス
	 * @param normal 法線
	 */
	virtual void setNormal(int index, const Vector3& normal);

	/**
	 * 法線の取得
	 * @param index インデックス
	 * @return 法線
	 */
	virtual const Vector3& getNormal(int index) const;

	/**
	 * 法線配列の取得
	 * @return 法線配列
	 */
	virtual const Vector3* getNormalArray() const;

	//--------------------------------------------------------------------------
	/**
	 * カラーを有効にするかどうか
	 * @param colorFlag trueならカラーが有効になる
	 */
	virtual void enableColor(bool colorFlag);

	/**
	 * カラーが有効かどうか
	 * @return カラーが有効ならtrue
	 */
	virtual bool hasColor() const;

	/**
	 * カラーの設定
	 * @param index インデックス
	 * @param color カラー
	 */
	virtual void setColor(int index, const Color4c& color);

	/**
	 * カラーの取得
	 * @param index インデックス
	 * @return カラー
	 */
	virtual const Color4c& getColor(int index) const;

	/**
	 * カラー配列の取得
	 * @return カラー配列
	 */
	virtual const Color4c* getColorArray() const;

	//--------------------------------------------------------------------------
	/**
	 * テクスチャ座標セット数の設定
	 * @param texCoordSetCount テクスチャ座標セット数
	 */
	virtual void setTexCoordSetCount(int texCoordSetCount);

	/**
	 * テクスチャ座標セット数の設定
	 * @return テクスチャ座標セット数
	 */
	virtual int getTexCoordSetCount() const;

	//--------------------------------------------------------------------------
	/**
	 * テクスチャ座標タイプの設定
	 * @param texCoordSet テクスチャ座標セット
	 * @param texCoordType テクスチャ座標タイプ
	 */
	virtual void setTexCoordType(int texCoordSet, TexCoord::Type texCoordType);

	/**
	 * テクスチャ座標タイプの取得
	 * @param texCoordSet テクスチャ座標セット
	 * @return テクスチャ座標タイプ
	 */
	virtual TexCoord::Type getTexCoordType(int texCoordSet) const;

	/**
	 * テクスチャ座標タイプ配列の取得
	 * @return テクスチャ座標タイプ配列
	 */
	virtual const TexCoord::Type* getTexCoordTypeArray() const;

	//--------------------------------------------------------------------------
	/**
	 * テクスチャ座標の設定
	 * @param index インデックス
	 * @param texCoordSet テクスチャ座標セット
	 * @param texCoord テクスチャ座標
	 * @param numTexCoord いくつのテクスチャ座標か
	 */
	virtual void setTexCoord(
		int index, int texCoordSet, const float* texCoord, int numTexCoord);

	/**
	 * テクスチャ座標配列の取得
	 * @return テクスチャ座標配列
	 */
	virtual const float* const* getTexCoordArray() const;

	/**
	 * テクスチャ座標配列の取得
	 * @param texCoordSet テクスチャ座標セット
	 * @return テクスチャ座標配列
	 */
	virtual const float* getTexCoordArray(int texCoordSet) const;

	/**
	 * テクスチャ座標配列サイズの取得
	 * @param texCoordSet テクスチャ座標セット
	 * @return テクスチャ座標配列サイズ
	 */
	virtual int getTexCoordArraySize(int texCoordSet) const;

	//--------------------------------------------------------------------------
	/**
	 * 一次元テクスチャ座標の設定
	 * @param index インデックス
	 * @param texCoordSet テクスチャ座標セット
	 * @param texCoord 一次元テクスチャ座標
	 */
	virtual void setTexCoord1(
		int index, int texCoordSet, const TexCoord1& texCoord);

	/**
	 * 一次元テクスチャ座標の取得
	 * @param index インデックス
	 * @param texCoordSet テクスチャ座標セット
	 * @return 一次元テクスチャ座標
	 */
	virtual const TexCoord1& getTexCoord1(int index, int texCoordSet) const;

	/**
	 * 一次元テクスチャ座標配列の取得
	 * @param texCoordSet テクスチャ座標セット
	 * @return 一次元テクスチャ座標配列
	 */
	virtual const TexCoord1* getTexCoord1Array(int texCoordSet) const;

	//--------------------------------------------------------------------------
	/**
	 * 二次元テクスチャ座標の設定
	 * @param index インデックス
	 * @param texCoordSet テクスチャ座標セット
	 * @param texCoord 二次元テクスチャ座標
	 */
	virtual void setTexCoord2(
		int index, int texCoordSet, const TexCoord2& texCoord);

	/**
	 * 二次元テクスチャ座標の取得
	 * @param index インデックス
	 * @param texCoordSet テクスチャ座標セット
	 * @return 二次元テクスチャ座標
	 */
	virtual const TexCoord2& getTexCoord2(int index, int texCoordSet) const;

	/**
	 * 二次元テクスチャ座標配列の取得
	 * @param texCoordSet テクスチャ座標セット
	 * @return 二次元テクスチャ座標配列
	 */
	virtual const TexCoord2* getTexCoord2Array(int texCoordSet) const;

	//--------------------------------------------------------------------------
	/**
	 * 三次元テクスチャ座標の設定
	 * @param index インデックス
	 * @param texCoordSet テクスチャ座標セット
	 * @param texCoord 三次元テクスチャ座標
	 */
	virtual void setTexCoord3(
		int index, int texCoordSet, const TexCoord3& texCoord);

	/**
	 * 三次元テクスチャ座標の取得
	 * @param index インデックス
	 * @param texCoordSet テクスチャ座標セット
	 * @return 三次元テクスチャ座標
	 */
	virtual const TexCoord3& getTexCoord3(int index, int texCoordSet) const;

	/**
	 * 三次元テクスチャ座標配列の取得
	 * @param texCoordSet テクスチャ座標セット
	 * @return 三次元テクスチャ座標配列
	 */
	virtual const TexCoord3* getTexCoord3Array(int texCoordSet) const;

	//--------------------------------------------------------------------------
	/**
	 * 四次元テクスチャ座標の設定
	 * @param index インデックス
	 * @param texCoordSet テクスチャ座標セット
	 * @param texCoord 四次元テクスチャ座標
	 */
	virtual void setTexCoord4(
		int index, int texCoordSet, const TexCoord4& texCoord);

	/**
	 * 四次元テクスチャ座標の取得
	 * @param index インデックス
	 * @param texCoordSet テクスチャ座標セット
	 * @return 四次元テクスチャ座標
	 */
	virtual const TexCoord4& getTexCoord4(int index, int texCoordSet) const;

	/**
	 * 四次元テクスチャ座標配列の取得
	 * @param texCoordSet テクスチャ座標セット
	 * @return 四次元テクスチャ座標配列
	 */
	virtual const TexCoord4* getTexCoord4Array(int texCoordSet) const;

	//--------------------------------------------------------------------------
	/**
	 * 頂点あたりボーン数の設定
	 * @param bonesPerVertex 頂点あたりボーン数
	 */
	virtual void setBonesPerVertex(int bonesPerVertex);

	/**
	 * 頂点あたりボーン数の取得
	 * @return 頂点あたりボーン数
	 */
	virtual int getBonesPerVertex() const;

	/**
	 * ボーンインデックスが有効かどうか
	 * @return ボーンインデックスが有効ならtrue
	 */
	virtual bool hasBoneIndex() const;

	/**
	 * ボーンインデックスの設定
	 * @param vertexIndex 頂点インデックス
	 * @param boneNumber ボーン番号
	 * @param boneIndex ボーンインデックス
	 */
	virtual void setBoneIndex(
		int vertexIndex, int boneNumber, u_char boneIndex);

	/**
	 * ボーンインデックスの設定
	 * @param vertexIndex 頂点インデックス
	 * @param boneIndex ボーンインデックス
	 */
	virtual void setBoneIndex(int vertexIndex, u_char boneIndex);

	/**
	 * ボーンインデックスの取得
	 * @param vertexIndex 頂点インデックス
	 * @param boneNumber ボーン番号
	 * @return ボーンインデックス
	 */
	virtual u_char getBoneIndex(int vertexIndex, int boneNumber) const;

	/**
	 * ボーンインデックスの取得
	 * @param vertexIndex 頂点インデックス
	 * @return ボーンインデックス
	 */
	virtual u_char getBoneIndex(int vertexIndex) const;

	/**
	 * ボーンインデックス配列の取得
	 * @return ボーンインデックス配列
	 */
	virtual const u_char* getBoneIndexArray() const;

	//--------------------------------------------------------------------------
	/**
	 * 頂点当たりウェイト数の取得
	 * @return 頂点あたりウェイト数
	 */
	virtual int getWeightsPerVertex() const;

	/**
	 * ウェイトが有効かどうか
	 * @return ウェイトが有効ならtrue
	 */
	virtual bool hasWeight() const;

	/**
	 * ウェイトの設定
	 * @param vertexIndex 頂点インデックス
	 * @param boneNumber ボーン番号
	 * @param weight ウェイト
	 */
	virtual void setWeight(int vertexIndex, int boneNumber, float weight);

	/**
	 * ウェイトの取得
	 * @param vertexIndex 頂点インデックス
	 * @param boneNumber ボーン番号
	 * @return ウェイト
	 */
	virtual float getWeight(int vertexIndex, int boneNumber) const;

	/**
	 * ウェイト配列の取得
	 * @return ウェイト配列
	 */
	virtual const float* getWeightArray() const;

	//--------------------------------------------------------------------------
	/**
	 * デバイスオブジェクトの初期化
	 * @return 成功したらtrueを返す
	 */
	virtual bool initializeGraphicsDeviceObjects(){ return true; }

	/**
	 * デバイスオブジェクトの削除
	 */
	virtual void deleteGraphicsDeviceObjects(){}

	/**
	 * デバイスオブジェクトのリストア
	 * @return 成功したらtrueを返す
	 */
	virtual bool restoreGraphicsDeviceObjects(){ return true; }

	/**
	 * デバイスオブジェクトの無効化
	 */
	virtual void invalidateGraphicsDeviceObjects(){}

	//--------------------------------------------------------------------------
	// RTTI
	//--------------------------------------------------------------------------
	/**
	 * メッシュかどうか
	 * @return メッシュならtrue
	 */
	virtual bool isMesh() const{ return true; }

	//--------------------------------------------------------------------------
	/**
	 * 剛体メッシュかどうか
	 * @return 剛体メッシュならtrue
	 */
	virtual bool isRigidMesh() const{ return false; }

	/**
	 * 剛体メッシュへのキャスト
	 * @return 剛体メッシュ。型が違えばNULLを返す。
	 */
	virtual RigidMesh* castRigidMesh() const{
		if(isRigidMesh()){ return (RigidMesh*)this; }
		return NULL;
	}

	//--------------------------------------------------------------------------
	/**
	 * キャラクタメッシュかどうか
	 * @return キャラクタメッシュならtrue
	 */
	virtual bool isCharacterMesh() const{ return false; }

	/**
	 * キャラクタメッシュへのキャスト
	 * @return キャラクタメッシュ。型が違えばNULLを返す。
	 */
	virtual CharacterMesh* castCharacterMesh() const{
		if(isCharacterMesh()){ return (CharacterMesh*)this; }
		return NULL;
	}

	//--------------------------------------------------------------------------
protected:
	/**
	 * コンストラクタ
	 * @param name 名前
	 * @param scene シーン
	 */
	Mesh(const String& name, Scene* scene);

	/**
	 * デストラクタ
	 */
	virtual ~Mesh();

	/**
	 * メッシュの値コピー
	 * @param destination コピー先メッシュ
	 * @param copyMask コピーマスク
	 */
	virtual void copyMeshValue(Mesh* destination, u_int copyMask) const;

	//--------------------------------------------------------------------------
	// バッファアクセス
	//--------------------------------------------------------------------------
	/**
	 * インデックスバッファの取得
	 * @return インデックスバッファ
	 */
	virtual Direct3DIndexBuffer* getIndexBuffer();

	/**
	 * 頂点記述の取得
	 * @return 頂点記述
	 */
	virtual Direct3DVertexDeclaration* getVertexDeclaration();

	/**
	 * 頂点サイズの取得
	 * @return 頂点サイズ
	 */
	virtual int getVertexSize();

	/**
	 * 頂点バッファの構築
	 * @return 頂点バッファ
	 */
	virtual Direct3DVertexBuffer* getVertexBuffer();

	//--------------------------------------------------------------------------
	// キャラクタ変形
	//--------------------------------------------------------------------------
	/**
	 * キャラクタ変形
	 * @return キャラクタ変形を行ったらtrue
	 */
	virtual bool characterDeform(){ return false; }

	//--------------------------------------------------------------------------
	// 変形バッファアクセス
	//--------------------------------------------------------------------------
	/**
	 * 変形頂点記述の取得
	 * @return 変形頂点記述
	 */
	virtual Direct3DVertexDeclaration* getDeformedVertexDeclaration(){
		Assert(false);
		return NULL;
	}

	/**
	 * 変形頂点サイズの取得
	 * @return 変形頂点サイズ
	 */
	virtual int getDeformedVertexSize(){
		Assert(false);
		return 0;
	}

	/**
	 * 変形頂点バッファの構築
	 * @return 変形頂点バッファ
	 */
	virtual Direct3DVertexBuffer* getDeformedVertexBuffer(){
		Assert(false);
		return NULL;
	}

	//--------------------------------------------------------------------------
	/**
	 * レンダリングテンポラリデータの設定
	 * @param renderingTemporaryData レンダリングテンポラリデータ
	 */
	virtual void setRenderingTemporaryData(float renderingTemporaryData){
		renderingTemporaryData_ = renderingTemporaryData;
	}

	/**
	 * レンダリングテンポラリデータの取得
	 */
	virtual float getRenderingTemporaryData() const{
		return renderingTemporaryData_;
	}

	//--------------------------------------------------------------------------
	/**
	 * 親の設定
	 * @param parent 設定する親
	 */
	virtual void setParent(Model* parent){
		Assert(parent != NULL);
		Assert(parent_ == NULL);
		parent_ = parent;
		globalEnabled_ = false;
	}

	/**
	 * 親の削除
	 * @param parent 削除する親
	 */
	virtual void removeParent(Model* parent){
		Assert(parent_ != NULL);
		Assert(parent_ == parent);
		parent_ = NULL;
		globalEnabled_ = false;
	}

protected:
	//--------------------------------------------------------------------------
	/**
	 * 走査
	 * @param parentMatrix 親行列
	 * @param parentEnabled 親が有効か
	 * @param parentScaled 親がスケールを使用しているか
	 * @param parentChanged 親に変更があったか
	 */
	virtual void traverse(const Matrix34& parentMatrix, bool parentEnabled,
		bool parentScaled, bool parentChanged);

private:
	//--------------------------------------------------------------------------
	// 親
	Model* parent_;
	// メッシュデータ
	MeshData* meshData_;
	// マテリアル
	Material* material_;
	// ワールドバウンディングスフィア
	Sphere worldBoundingSphere_;
	// ワールドバウンディングボックス
	AxisAlignedBox worldBoundingBox_;
	// レンダリングテンポラリデータ
	float renderingTemporaryData_;
	// 有効、無効フラグ
	bool enabled_;
	// グローバルでの有効無効フラグ
	bool globalEnabled_;
	// グローバルでのスケールフラグ
	bool globalScaled_;

	// プリミティブタイプ文字列テーブル
	static const String primitiveTypeStringTable[];

};

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

