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 //------------------------------------------------------------------------------