Main Page | Namespace List | Class Hierarchy | Alphabetical List | Compound List | File List | Namespace Members | Compound Members | File Members

MeshData.h

Go to the documentation of this file.
00001 //------------------------------------------------------------------------------
00002 // Lamp : Open source game middleware
00003 // Copyright (C) 2004  Junpei Ohtani ( Email : junpee@users.sourceforge.jp )
00004 //
00005 // This library is free software; you can redistribute it and/or
00006 // modify it under the terms of the GNU Lesser General Public
00007 // License as published by the Free Software Foundation; either
00008 // version 2.1 of the License, or (at your option) any later version.
00009 //
00010 // This library is distributed in the hope that it will be useful,
00011 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00012 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00013 // Lesser General Public License for more details.
00014 //
00015 // You should have received a copy of the GNU Lesser General Public
00016 // License along with this library; if not, write to the Free Software
00017 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00018 //------------------------------------------------------------------------------
00019 
00020 /** @file
00021  * メッシュデータヘッダ
00022  * @author Junpee
00023  */
00024 
00025 #ifndef MESH_DATA_H_
00026 #define MESH_DATA_H_
00027 
00028 #include <Graphics/Scene/SceneObject.h>
00029 #include <Graphics/System/GraphicsDeviceObjectHolder.h>
00030 #include <Core/Container/ArrayList.h>
00031 #include <Graphics/Mesh/Mesh.h>// PrimitiveTypeを分離すればはずせる
00032 
00033 namespace Lamp{
00034 
00035 class Mesh;
00036 
00037 //------------------------------------------------------------------------------
00038 /**
00039  * メッシュデータ
00040  */
00041 class MeshData : public SceneObject , public GraphicsDeviceObjectHolder{
00042 friend class SceneObjectManagerTemplate<MeshData>;
00043 friend class MeshDataManager;
00044 friend class Mesh;
00045 public:
00046     /**
00047      * リファレンスカウントの取得
00048      * @return リファレンスカウント
00049      */
00050     virtual int getReferenceCount() const{ return parents_.getCount(); }
00051 
00052     //--------------------------------------------------------------------------
00053     /**
00054      * コピー
00055      */
00056     virtual MeshData* copy() const;
00057 
00058     /**
00059      * 破棄
00060      * @param meshData 破棄するメッシュデータ
00061      * @return 破棄したオブジェクト数
00062      */
00063     static int destroy(MeshData* meshData);
00064 
00065     //--------------------------------------------------------------------------
00066     // 親
00067     //--------------------------------------------------------------------------
00068     /**
00069      * 親のサイズ取得
00070      * @return 親のサイズ
00071      */
00072     virtual int getParentCount() const{ return parents_.getCount(); }
00073 
00074     /**
00075      * 親の取得
00076      * @param index 親のインデックス
00077      * @return 親
00078      */
00079     virtual Mesh* getParent(int index) const{
00080         Assert((index >= 0) && (index < getParentCount()));
00081         return parents_.get(index);
00082     }
00083 
00084     //--------------------------------------------------------------------------
00085     // バウンディング
00086     //--------------------------------------------------------------------------
00087     /**
00088      * バウンディングスフィアの設定
00089      * @param boundingSphere 設定するバウンディングスフィア
00090      */
00091     virtual void setBoundingSphere(const Sphere& boundingSphere){
00092         boundingSphere_ = boundingSphere;
00093         boundingChanged_ = true;
00094     }
00095 
00096     /**
00097      * バウンディングスフィアの取得
00098      * @return バウンディングスフィア
00099      */
00100     virtual const Sphere& getBoundingSphere() const{ return boundingSphere_; }
00101 
00102     //--------------------------------------------------------------------------
00103     /**
00104      * バウンディングボックスの設定
00105      * @param boundingBox 設定するバウンディングボックス
00106      */
00107     virtual void setBoundingBox(const AxisAlignedBox& boundingBox){
00108         boundingBox_ = boundingBox;
00109         boundingChanged_ = true;
00110     }
00111 
00112     /**
00113      * バウンディングボックスの取得
00114      * @return バウンディングボックス
00115      */
00116     virtual const AxisAlignedBox& getBoundingBox() const{ return boundingBox_; }
00117 
00118     //--------------------------------------------------------------------------
00119     /**
00120      * バウンディング変更フラグの取得
00121      * @return バウンディング変更フラグ
00122      */
00123     virtual bool isBoundingChanged() const{ return boundingChanged_; }
00124 
00125     /**
00126      * バウンディング変更フラグのクリア
00127      */
00128     virtual void clearBoundingChanged(){ boundingChanged_ = false; }
00129 
00130     //--------------------------------------------------------------------------
00131     // プリミティブタイプ
00132     //--------------------------------------------------------------------------
00133     /**
00134      * プリミティブタイプの設定
00135      * @param primitiveType プリミティブタイプ
00136      */
00137     virtual void setPrimitiveType(Mesh::PrimitiveType primitiveType);
00138 
00139     /**
00140      * プリミティブタイプの取得
00141      * @return プリミティブタイプ
00142      */
00143     virtual Mesh::PrimitiveType getPrimitiveType() const{
00144         return primitiveType_;
00145     }
00146 
00147     /**
00148      * プリミティブカウントの取得
00149      * @return プリミティブカウント
00150      */
00151     virtual int getPrimitiveCount() const;
00152 
00153     /**
00154      * 三角の取得
00155      * @param index プリミティブインデックス
00156      * @return 三角
00157      */
00158     virtual Triangle getTriangle(int index) const;
00159 
00160     //--------------------------------------------------------------------------
00161     // インデックス
00162     //--------------------------------------------------------------------------
00163     /**
00164      * 頂点インデックスを持つかどうか
00165      * @return 頂点インデックスを持つならtrue
00166      */
00167     virtual bool hasVertexIndices() const{
00168         return Mesh::primitiveTypeHasIndex(primitiveType_);
00169     }
00170 
00171     /**
00172      * 頂点インデックス数の設定
00173      * @param vertexIndexCount 頂点インデックス数
00174      */
00175     virtual void setVertexIndexCount(int vertexIndexCount);
00176 
00177     /**
00178      * 頂点インデックス数の取得
00179      * @return 頂点インデックス数
00180      */
00181     virtual int getVertexIndexCount() const{ return vertexIndexCount_; }
00182 
00183     /**
00184      * 頂点インデックスの設定
00185      * @param index インデックス
00186      * @param vertexIndex 頂点インデックス
00187      */
00188     virtual void setVertexIndex(int index, u_short vertexIndex){
00189         Assert(hasVertexIndices());
00190         Assert((index >= 0) && (index < vertexIndexCount_));
00191         vertexIndexArray_[index] = vertexIndex;
00192         indexBufferChanged_ = true;
00193     }
00194 
00195     /**
00196      * 頂点インデックスの取得
00197      * @param index インデックス
00198      * @return 頂点インデックス
00199      */
00200     virtual u_short getVertexIndex(int index) const{
00201         Assert(hasVertexIndices());
00202         Assert((index >= 0) && (index < vertexIndexCount_));
00203         return vertexIndexArray_[index];
00204     }
00205 
00206     /**
00207      * 頂点インデックス配列の取得
00208      * @return 頂点インデックス配列
00209      */
00210     virtual const u_short* getVertexIndexArray(){ return vertexIndexArray_; }
00211 
00212     //--------------------------------------------------------------------------
00213     // 頂点数
00214     //--------------------------------------------------------------------------
00215     /**
00216      * 頂点数の設定
00217      * @param vertexCount 頂点数
00218      */
00219     virtual void setVertexCount(int vertexCount);
00220 
00221     /**
00222      * 頂点数の取得
00223      * @return 頂点数
00224      */
00225     virtual int getVertexCount() const{ return vertexCount_; }
00226 
00227     //--------------------------------------------------------------------------
00228     // 位置
00229     //--------------------------------------------------------------------------
00230     /**
00231      * 位置の設定
00232      * @param index インデックス
00233      * @param position 位置
00234      */
00235     virtual void setPosition(int index, const Vector3& position){
00236         Assert((index >= 0) && (index < vertexCount_));
00237         positions_[index] = position;
00238         vertexBufferChanged_ = true;
00239     }
00240 
00241     /**
00242      * 位置の取得
00243      * @param index インデックス
00244      * @return 位置
00245      */
00246     virtual const Vector3& getPosition(int index) const{
00247         Assert((index >= 0) && (index < vertexCount_));
00248         return positions_[index];
00249     }
00250 
00251     /**
00252      * 位置配列の取得
00253      * @return 位置配列
00254      */
00255     virtual const Vector3* getPositionArray() const{ return positions_; }
00256 
00257     //--------------------------------------------------------------------------
00258     // 法線
00259     //--------------------------------------------------------------------------
00260     /**
00261      * 法線を有効にするかどうか
00262      * @param normalFlag trueなら法線が有効になる
00263      */
00264     virtual void enableNormal(bool normalFlag);
00265 
00266     /**
00267      * 法線が有効かどうか
00268      * @return 法線が有効ならtrue
00269      */
00270     virtual bool hasNormal() const{ return normalFlag_; }
00271 
00272     /**
00273      * 法線の設定
00274      * @param index インデックス
00275      * @param normal 法線
00276      */
00277     virtual void setNormal(int index, const Vector3& normal){
00278         Assert(hasNormal());
00279         Assert((index >= 0) && (index < vertexCount_));
00280         normals_[index] = normal;
00281         vertexBufferChanged_ = true;
00282     }
00283 
00284     /**
00285      * 法線の取得
00286      * @param index インデックス
00287      * @return 法線
00288      */
00289     virtual const Vector3& getNormal(int index) const{
00290         Assert(hasNormal());
00291         Assert((index >= 0) && (index < vertexCount_));
00292         return normals_[index];
00293     }
00294 
00295     /**
00296      * 法線配列の取得
00297      * @return 法線配列
00298      */
00299     virtual const Vector3* getNormalArray() const{ return normals_; }
00300 
00301     //--------------------------------------------------------------------------
00302     // カラー
00303     //--------------------------------------------------------------------------
00304     /**
00305      * カラーを有効にするかどうか
00306      * @param colorFlag trueならカラーが有効になる
00307      */
00308     virtual void enableColor(bool colorFlag);
00309 
00310     /**
00311      * カラーが有効かどうか
00312      * @return カラーが有効ならtrue
00313      */
00314     virtual bool hasColor() const{ return colorFlag_; }
00315 
00316     /**
00317      * カラーの設定
00318      * @param index インデックス
00319      * @param color カラー
00320      */
00321     virtual void setColor(int index, const Color4c& color){
00322         Assert(hasColor());
00323         Assert((index >= 0) && (index < vertexCount_));
00324         colors_[index] = color;
00325         vertexBufferChanged_ = true;
00326     }
00327 
00328     /**
00329      * カラーの取得
00330      * @param index インデックス
00331      * @return カラー
00332      */
00333     virtual const Color4c& getColor(int index) const{
00334         Assert(hasColor());
00335         Assert((index >= 0) && (index < vertexCount_));
00336         return colors_[index];
00337     }
00338 
00339     /**
00340      * カラー配列の取得
00341      * @return カラー配列
00342      */
00343     virtual const Color4c* getColorArray() const{ return colors_; }
00344 
00345     //--------------------------------------------------------------------------
00346     // テクスチャ座標
00347     //--------------------------------------------------------------------------
00348     /**
00349      * テクスチャ座標セット数の設定
00350      * @param texCoordSetCount テクスチャ座標セット数
00351      */
00352     virtual void setTexCoordSetCount(int texCoordSetCount);
00353 
00354     /**
00355      * テクスチャ座標セット数の設定
00356      * @return テクスチャ座標セット数
00357      */
00358     virtual int getTexCoordSetCount() const{ return texCoordSetCount_; }
00359 
00360     //--------------------------------------------------------------------------
00361     /**
00362      * テクスチャ座標タイプの設定
00363      * @param texCoordSet テクスチャ座標セット
00364      * @param texCoordType テクスチャ座標タイプ
00365      */
00366     virtual void setTexCoordType(int texCoordSet, TexCoord::Type texCoordType);
00367 
00368     /**
00369      * テクスチャ座標タイプの取得
00370      * @param texCoordSet テクスチャ座標セット
00371      * @return テクスチャ座標タイプ
00372      */
00373     virtual TexCoord::Type getTexCoordType(int texCoordSet) const{
00374         Assert((texCoordSet >= 0) && (texCoordSet < texCoordSetCount_));
00375         return texCoordTypes_[texCoordSet];
00376     }
00377 
00378     /**
00379      * テクスチャ座標タイプ配列の取得
00380      * @return テクスチャ座標タイプ配列
00381      */
00382     virtual const TexCoord::Type* getTexCoordTypeArray() const{
00383         return texCoordTypes_;
00384     }
00385 
00386     //--------------------------------------------------------------------------
00387     /**
00388      * テクスチャ座標の設定
00389      * @param index インデックス
00390      * @param texCoordSet テクスチャ座標セット
00391      * @param texCoord テクスチャ座標
00392      * @param numTexCoord いくつのテクスチャ座標か
00393      */
00394     virtual void setTexCoord(
00395         int index, int texCoordSet, const float* texCoord, int numTexCoord){
00396         Assert((index >= 0) && (index < vertexCount_));
00397         Assert((texCoordSet >= 0) && (texCoordSet < texCoordSetCount_));
00398         Assert(texCoordTypes_[texCoordSet] == numTexCoord);
00399         float* destination = texCoords_[texCoordSet] + (index * numTexCoord);
00400         std::memcpy(destination, texCoord, sizeof(float) * numTexCoord);
00401         vertexBufferChanged_ = true;
00402     }
00403 
00404     /**
00405      * テクスチャ座標配列の取得
00406      * @return テクスチャ座標配列
00407      */
00408     virtual const float* const* getTexCoordArray() const{ return texCoords_; }
00409 
00410     /**
00411      * テクスチャ座標配列の取得
00412      * @param texCoordSet テクスチャ座標セット
00413      * @return テクスチャ座標配列
00414      */
00415     virtual const float* getTexCoordArray(int texCoordSet) const{
00416         Assert((texCoordSet >= 0) && (texCoordSet < texCoordSetCount_));
00417         return texCoords_[texCoordSet];
00418     }
00419 
00420     /**
00421      * テクスチャ座標配列サイズの取得
00422      * @param texCoordSet テクスチャ座標セット
00423      * @return テクスチャ座標配列サイズ
00424      */
00425     virtual int getTexCoordArraySize(int texCoordSet) const{
00426         Assert((texCoordSet >= 0) && (texCoordSet < texCoordSetCount_));
00427         return sizeof(float) * texCoordTypes_[texCoordSet] * vertexCount_;
00428     }
00429 
00430     //--------------------------------------------------------------------------
00431     /**
00432      * 一次元テクスチャ座標の設定
00433      * @param index インデックス
00434      * @param texCoordSet テクスチャ座標セット
00435      * @param texCoord 一次元テクスチャ座標
00436      */
00437     virtual void setTexCoord1(
00438         int index, int texCoordSet, const TexCoord1& texCoord){
00439         Assert((index >= 0) && (index < vertexCount_));
00440         Assert((texCoordSet >= 0) && (texCoordSet < texCoordSetCount_));
00441         Assert(texCoordTypes_[texCoordSet] == TexCoord::type1);
00442         ((TexCoord1*)texCoords_[texCoordSet])[index] = texCoord;
00443         vertexBufferChanged_ = true;
00444     }
00445 
00446     /**
00447      * 一次元テクスチャ座標の取得
00448      * @param index インデックス
00449      * @param texCoordSet テクスチャ座標セット
00450      * @return 一次元テクスチャ座標
00451      */
00452     virtual const TexCoord1& getTexCoord1(int index, int texCoordSet) const{
00453         Assert((index >= 0) && (index < vertexCount_));
00454         Assert((texCoordSet >= 0) && (texCoordSet < texCoordSetCount_));
00455         Assert(texCoordTypes_[texCoordSet] == TexCoord::type1);
00456         return ((TexCoord1*)texCoords_[texCoordSet])[index];
00457     }
00458 
00459     /**
00460      * 一次元テクスチャ座標配列の取得
00461      * @param texCoordSet テクスチャ座標セット
00462      * @return 一次元テクスチャ座標配列
00463      */
00464     virtual const TexCoord1* getTexCoord1Array(int texCoordSet) const{
00465         Assert((texCoordSet >= 0) && (texCoordSet < texCoordSetCount_));
00466         Assert(texCoordTypes_[texCoordSet] == TexCoord::type1);
00467         return (TexCoord1*)texCoords_[texCoordSet];
00468     }
00469 
00470     //--------------------------------------------------------------------------
00471     /**
00472      * 二次元テクスチャ座標の設定
00473      * @param index インデックス
00474      * @param texCoordSet テクスチャ座標セット
00475      * @param texCoord 二次元テクスチャ座標
00476      */
00477     virtual void setTexCoord2(
00478         int index, int texCoordSet, const TexCoord2& texCoord){
00479         Assert((index >= 0) && (index < vertexCount_));
00480         Assert((texCoordSet >= 0) && (texCoordSet < texCoordSetCount_));
00481         Assert(texCoordTypes_[texCoordSet] == TexCoord::type2);
00482         ((TexCoord2*)texCoords_[texCoordSet])[index] = texCoord;
00483         vertexBufferChanged_ = true;
00484     }
00485 
00486     /**
00487      * 二次元テクスチャ座標の取得
00488      * @param index インデックス
00489      * @param texCoordSet テクスチャ座標セット
00490      * @return 二次元テクスチャ座標
00491      */
00492     virtual const TexCoord2& getTexCoord2(int index, int texCoordSet) const{
00493         Assert((index >= 0) && (index < vertexCount_));
00494         Assert((texCoordSet >= 0) && (texCoordSet < texCoordSetCount_));
00495         Assert(texCoordTypes_[texCoordSet] == TexCoord::type2);
00496         return ((TexCoord2*)texCoords_[texCoordSet])[index];
00497     }
00498 
00499     /**
00500      * 二次元テクスチャ座標配列の取得
00501      * @param texCoordSet テクスチャ座標セット
00502      * @return 二次元テクスチャ座標配列
00503      */
00504     virtual const TexCoord2* getTexCoord2Array(int texCoordSet) const{
00505         Assert((texCoordSet >= 0) && (texCoordSet < texCoordSetCount_));
00506         Assert(texCoordTypes_[texCoordSet] == TexCoord::type2);
00507         return (TexCoord2*)texCoords_[texCoordSet];
00508     }
00509 
00510     //--------------------------------------------------------------------------
00511     /**
00512      * 三次元テクスチャ座標の設定
00513      * @param index インデックス
00514      * @param texCoordSet テクスチャ座標セット
00515      * @param texCoord 三次元テクスチャ座標
00516      */
00517     virtual void setTexCoord3(
00518         int index, int texCoordSet, const TexCoord3& texCoord){
00519         Assert((index >= 0) && (index < vertexCount_));
00520         Assert((texCoordSet >= 0) && (texCoordSet < texCoordSetCount_));
00521         Assert(texCoordTypes_[texCoordSet] == TexCoord::type3);
00522         ((TexCoord3*)texCoords_[texCoordSet])[index] = texCoord;
00523         vertexBufferChanged_ = true;
00524     }
00525 
00526     /**
00527      * 三次元テクスチャ座標の取得
00528      * @param index インデックス
00529      * @param texCoordSet テクスチャ座標セット
00530      * @return 三次元テクスチャ座標
00531      */
00532     virtual const TexCoord3& getTexCoord3(int index, int texCoordSet) const{
00533         Assert((index >= 0) && (index < vertexCount_));
00534         Assert((texCoordSet >= 0) && (texCoordSet < texCoordSetCount_));
00535         Assert(texCoordTypes_[texCoordSet] == TexCoord::type3);
00536         return ((TexCoord3*)texCoords_[texCoordSet])[index];
00537     }
00538 
00539     /**
00540      * 三次元テクスチャ座標配列の取得
00541      * @param texCoordSet テクスチャ座標セット
00542      * @return 三次元テクスチャ座標配列
00543      */
00544     virtual const TexCoord3* getTexCoord3Array(int texCoordSet) const{
00545         Assert((texCoordSet >= 0) && (texCoordSet < texCoordSetCount_));
00546         Assert(texCoordTypes_[texCoordSet] == TexCoord::type3);
00547         return (TexCoord3*)texCoords_[texCoordSet];
00548     }
00549 
00550     //--------------------------------------------------------------------------
00551     /**
00552      * 四次元テクスチャ座標の設定
00553      * @param index インデックス
00554      * @param texCoordSet テクスチャ座標セット
00555      * @param texCoord 四次元テクスチャ座標
00556      */
00557     virtual void setTexCoord4(
00558         int index, int texCoordSet, const TexCoord4& texCoord){
00559         Assert((index >= 0) && (index < vertexCount_));
00560         Assert((texCoordSet >= 0) && (texCoordSet < texCoordSetCount_));
00561         Assert(texCoordTypes_[texCoordSet] == TexCoord::type4);
00562         ((TexCoord4*)texCoords_[texCoordSet])[index] = texCoord;
00563         vertexBufferChanged_ = true;
00564     }
00565 
00566     /**
00567      * 四次元テクスチャ座標の取得
00568      * @param index インデックス
00569      * @param texCoordSet テクスチャ座標セット
00570      * @return 四次元テクスチャ座標
00571      */
00572     virtual const TexCoord4& getTexCoord4(int index, int texCoordSet) const{
00573         Assert((index >= 0) && (index < vertexCount_));
00574         Assert((texCoordSet >= 0) && (texCoordSet < texCoordSetCount_));
00575         Assert(texCoordTypes_[texCoordSet] == TexCoord::type4);
00576         return ((TexCoord4*)texCoords_[texCoordSet])[index];
00577     }
00578 
00579     /**
00580      * 四次元テクスチャ座標配列の取得
00581      * @param texCoordSet テクスチャ座標セット
00582      * @return 四次元テクスチャ座標配列
00583      */
00584     virtual const TexCoord4* getTexCoord4Array(int texCoordSet) const{
00585         Assert((texCoordSet >= 0) && (texCoordSet < texCoordSetCount_));
00586         Assert(texCoordTypes_[texCoordSet] == TexCoord::type4);
00587         return (TexCoord4*)texCoords_[texCoordSet];
00588     }
00589 
00590     //--------------------------------------------------------------------------
00591     // ボーン
00592     //--------------------------------------------------------------------------
00593     /**
00594      * 頂点あたりボーン数の設定
00595      * @param bonesPerVertex 頂点あたりボーン数
00596      */
00597     virtual void setBonesPerVertex(int bonesPerVertex);
00598 
00599     /**
00600      * 頂点あたりボーン数の取得
00601      * @return 頂点あたりボーン数
00602      */
00603     virtual int getBonesPerVertex() const{ return bonesPerVertex_; }
00604 
00605     /**
00606      * ボーンインデックスが有効かどうか
00607      * @return ボーンインデックスが有効ならtrue
00608      */
00609     virtual bool hasBoneIndex() const{ return (bonesPerVertex_ > 0); }
00610 
00611     /**
00612      * ボーンインデックスの設定
00613      * @param vertexIndex 頂点インデックス
00614      * @param boneNumber ボーン番号
00615      * @param boneIndex ボーンインデックス
00616      */
00617     virtual void setBoneIndex(
00618         int vertexIndex, int boneNumber, u_char boneIndex){
00619         Assert(hasBoneIndex());
00620         Assert((vertexIndex >= 0) && (vertexIndex < vertexCount_));
00621         Assert((boneNumber >= 0) && (boneNumber < bonesPerVertex_));
00622         boneIndices_[vertexIndex * bonesPerVertex_ + boneNumber] =
00623             boneIndex;
00624         vertexBufferChanged_ = true;
00625     }
00626 
00627     /**
00628      * ボーンインデックスの設定
00629      * @param vertexIndex 頂点インデックス
00630      * @param boneIndex ボーンインデックス
00631      */
00632     virtual void setBoneIndex(int vertexIndex, u_char boneIndex){
00633         Assert(bonesPerVertex_ == 1);
00634         Assert((vertexIndex >= 0) && (vertexIndex < vertexCount_));
00635         boneIndices_[vertexIndex] = boneIndex;
00636         vertexBufferChanged_ = true;
00637     }
00638 
00639     /**
00640      * ボーンインデックスの取得
00641      * @param vertexIndex 頂点インデックス
00642      * @param boneNumber ボーン番号
00643      * @return ボーンインデックス
00644      */
00645     virtual u_char getBoneIndex(int vertexIndex, int boneNumber) const{
00646         Assert(hasBoneIndex());
00647         Assert((vertexIndex >= 0) && (vertexIndex < vertexCount_));
00648         Assert((boneNumber >= 0) && (boneNumber < bonesPerVertex_));
00649         return boneIndices_[vertexIndex * bonesPerVertex_ + boneNumber];
00650     }
00651 
00652     /**
00653      * ボーンインデックスの取得
00654      * @param vertexIndex 頂点インデックス
00655      * @return ボーンインデックス
00656      */
00657     virtual u_char getBoneIndex(int vertexIndex) const{
00658         Assert(bonesPerVertex_ == 1);
00659         Assert((vertexIndex >= 0) && (vertexIndex < vertexCount_));
00660         return boneIndices_[vertexIndex];
00661     }
00662 
00663     /**
00664      * ボーンインデックス配列の取得
00665      * @return ボーンインデックス配列
00666      */
00667     virtual const u_char* getBoneIndexArray() const{ return boneIndices_; }
00668 
00669     //--------------------------------------------------------------------------
00670     // ウェイト
00671     //--------------------------------------------------------------------------
00672     /**
00673      * 頂点当たりウェイト数の取得
00674      * @return 頂点あたりウェイト数
00675      */
00676     virtual int getWeightsPerVertex() const{ return weightsPerVertex_; }
00677 
00678     /**
00679      * ウェイトが有効かどうか
00680      * @return ウェイトが有効ならtrue
00681      */
00682     virtual bool hasWeight() const{ return (weightsPerVertex_ > 0); }
00683 
00684     /**
00685      * ウェイトの設定
00686      * @param vertexIndex 頂点インデックス
00687      * @param boneNumber ボーン番号
00688      * @param weight ウェイト
00689      */
00690     virtual void setWeight(int vertexIndex, int boneNumber, float weight){
00691         Assert(hasWeight());
00692         Assert((vertexIndex >= 0) && (vertexIndex < vertexCount_));
00693         Assert((boneNumber >= 0) && (boneNumber < bonesPerVertex_));
00694         weights_[vertexIndex * weightsPerVertex_ + boneNumber] = weight;
00695         vertexBufferChanged_ = true;
00696     }
00697 
00698     /**
00699      * ウェイトの取得
00700      * @param vertexIndex 頂点インデックス
00701      * @param boneNumber ボーン番号
00702      * @return ウェイト
00703      */
00704     virtual float getWeight(int vertexIndex, int boneNumber) const{
00705         Assert(hasWeight());
00706         Assert((vertexIndex >= 0) && (vertexIndex < vertexCount_));
00707         Assert((boneNumber >= 0) && (boneNumber < bonesPerVertex_));
00708         return weights_[vertexIndex * weightsPerVertex_ + boneNumber];
00709     }
00710 
00711     /**
00712      * ウェイト配列の取得
00713      * @return ウェイト配列
00714      */
00715     virtual const float* getWeightArray() const{ return weights_; }
00716 
00717     //--------------------------------------------------------------------------
00718     // デバイスオブジェクト
00719     //--------------------------------------------------------------------------
00720     /**
00721      * デバイスオブジェクトの初期化
00722      * @return 成功したらtrueを返す
00723      */
00724     virtual bool initializeGraphicsDeviceObjects(){ return true; }
00725 
00726     /**
00727      * デバイスオブジェクトの削除
00728      */
00729     virtual void deleteGraphicsDeviceObjects(){}
00730 
00731     /**
00732      * デバイスオブジェクトのリストア
00733      * @return 成功したらtrueを返す
00734      */
00735     virtual bool restoreGraphicsDeviceObjects(){ return true; }
00736 
00737     /**
00738      * デバイスオブジェクトの無効化
00739      */
00740     virtual void invalidateGraphicsDeviceObjects(){
00741         SafeRelease(indexBuffer_);
00742         SafeRelease(vertexBuffer_);
00743         vertexSize_ = 0;
00744         SafeRelease(vertexDeclaration_);
00745     }
00746 
00747     //--------------------------------------------------------------------------
00748     // RTTI
00749     //--------------------------------------------------------------------------
00750     /**
00751      * メッシュデータかどうか
00752      * @return メッシュデータならtrue
00753      */
00754     virtual bool isMeshData() const{ return true; }
00755 
00756 protected:
00757     //--------------------------------------------------------------------------
00758     /**
00759      * コンストラクタ
00760      * @param name 名前
00761      * @param scene シーン
00762      */
00763     MeshData(const String& name, Scene* scene);
00764 
00765     /**
00766      * デストラクタ
00767      */
00768     virtual ~MeshData();
00769 
00770     /**
00771      * メッシュデータの値コピー
00772      * @param destination コピー先メッシュデータ
00773      */
00774     virtual void copyMeshDataValue(MeshData* destination) const;
00775 
00776     //--------------------------------------------------------------------------
00777     // グラフィックスバッファ
00778     //--------------------------------------------------------------------------
00779     /**
00780      * インデックスバッファの取得
00781      * @return インデックスバッファ
00782      */
00783     virtual Direct3DIndexBuffer* getIndexBuffer();
00784 
00785     /**
00786      * 頂点記述の取得
00787      * @return 頂点記述
00788      */
00789     virtual Direct3DVertexDeclaration* getVertexDeclaration();
00790 
00791     /**
00792      * 頂点サイズの取得
00793      * @return 頂点サイズ
00794      */
00795     virtual int getVertexSize();
00796 
00797     /**
00798      * 頂点バッファの構築
00799      * @return 頂点バッファ
00800      */
00801     virtual Direct3DVertexBuffer* getVertexBuffer();
00802 
00803     //--------------------------------------------------------------------------
00804     /**
00805      * 参照の追加
00806      * @param parent 親
00807      * @return 参照カウント
00808      */
00809     virtual int addReference(Mesh* parent){
00810         parents_.add(parent);
00811         return getParentCount();
00812     }
00813 
00814     /**
00815      * 参照の削除
00816      * @param parent 親
00817      * @return 参照カウント
00818      */
00819     virtual int removeReference(Mesh* parent){
00820         parents_.removeByValue(parent);
00821         return getParentCount();
00822     }
00823 
00824     //--------------------------------------------------------------------------
00825 private:
00826     // 親配列
00827     ArrayList<Mesh*> parents_;
00828     // バウンディングスフィア
00829     Sphere boundingSphere_;
00830     // バウンディングボックス
00831     AxisAlignedBox boundingBox_;
00832 
00833     // インデックスバッファ
00834     Direct3DIndexBuffer* indexBuffer_;
00835     // 頂点記述
00836     Direct3DVertexDeclaration* vertexDeclaration_;
00837     // 頂点サイズ
00838     int vertexSize_;
00839     // 頂点バッファ
00840     Direct3DVertexBuffer* vertexBuffer_;
00841 
00842     // プリミティブタイプ
00843     Mesh::PrimitiveType primitiveType_;
00844     // 頂点インデックス数
00845     int vertexIndexCount_;
00846     // 頂点インデックス配列
00847     u_short* vertexIndexArray_;
00848     // 頂点数
00849     int vertexCount_;
00850     // 位置
00851     Vector3* positions_;
00852     // 法線
00853     Vector3* normals_;
00854     // 色
00855     Color4c* colors_;
00856     // テクスチャ座標セット数
00857     int texCoordSetCount_;
00858     // テクスチャ座標タイプ
00859     TexCoord::Type texCoordTypes_[TexCoord::maxSetCount];
00860     // テクスチャ座標
00861     float* texCoords_[TexCoord::maxSetCount];
00862     // 頂点あたりボーン数
00863     int bonesPerVertex_;
00864     // ボーンインデックス
00865     u_char* boneIndices_;
00866     // 頂点あたりウェイト数
00867     int weightsPerVertex_;
00868     // ウェイト
00869     float* weights_;
00870     // 法線フラグ
00871     bool normalFlag_;
00872     // 色フラグ
00873     bool colorFlag_;
00874     // UVフラグ
00875     bool uvFlag_;
00876 
00877     // 頂点バッファ変更フラグ
00878     bool vertexBufferChanged_;
00879     // インデックスバッファ変更フラグ
00880     bool indexBufferChanged_;
00881     // バウンディング変更フラグ
00882     bool boundingChanged_;
00883 
00884 };
00885 
00886 //------------------------------------------------------------------------------
00887 } // End of namespace Lamp
00888 #endif // End of MESH_DATA_H_
00889 //------------------------------------------------------------------------------

Generated on Wed Mar 16 10:29:33 2005 for Lamp by doxygen 1.3.2