RAS_MeshObject.h

Go to the documentation of this file.

/*
 * ***** BEGIN GPL LICENSE BLOCK *****
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
 * All rights reserved.
 *
 * The Original Code is: all of this file.
 *
 * Contributor(s): none yet.
 *
 * ***** END GPL LICENSE BLOCK *****
 */

#ifndef __RAS_MESHOBJECT
#define __RAS_MESHOBJECT

#if defined(WIN32) && !defined(FREE_WINDOWS)
// disable the STL warnings ("debug information length > 255")
#pragma warning (disable:4786)
#endif

#include <vector>
#include <set>
#include <list>

#include "RAS_Polygon.h"
#include "RAS_MaterialBucket.h"
#include "MT_Transform.h"

#include "CTR_HashedPtr.h"

struct Mesh;
class RAS_Deformer;

/* RAS_MeshObject is a mesh used for rendering. It stores polygons,
 * but the actual vertices and index arrays are stored in material
 * buckets, referenced by the list of RAS_MeshMaterials. */

class RAS_MeshObject
{
private:
    unsigned int                m_debugcolor;

    bool                        m_bModified;
    bool                        m_bMeshModified;

    STR_String                  m_name;
    static STR_String           s_emptyname;

    vector<class RAS_Polygon*>  m_Polygons;

    /* polygon sorting */
    struct polygonSlot;
    struct backtofront;
    struct fronttoback;

protected:
    vector<int>                     m_cacheWeightIndex;
    list<RAS_MeshMaterial>          m_materials;
    Mesh*                           m_mesh;

public:
    // for now, meshes need to be in a certain layer (to avoid sorting on lights in realtime)
    RAS_MeshObject(Mesh* mesh);
    virtual ~RAS_MeshObject();


    // for shape keys, 
    void CheckWeightCache(struct Object* obj);
    
    /* materials */
    int                 NumMaterials();
    const STR_String&   GetMaterialName(unsigned int matid);
    const STR_String&   GetTextureName(unsigned int matid);

    RAS_MeshMaterial*   GetMeshMaterial(unsigned int matid);
    RAS_MeshMaterial*   GetMeshMaterial(RAS_IPolyMaterial *mat);
    int                 GetMaterialId(RAS_IPolyMaterial *mat);

    list<RAS_MeshMaterial>::iterator GetFirstMaterial();
    list<RAS_MeshMaterial>::iterator GetLastMaterial();

    //unsigned int      GetLightLayer();

    /* name */
    void                SetName(const char *name);
    STR_String&         GetName();

    /* modification state */
    bool                MeshModified();
    void                SetMeshModified(bool v){m_bMeshModified = v;}

    /* original blender mesh */
    Mesh*               GetMesh() { return m_mesh; }

    /* mesh construction */
    
    virtual RAS_Polygon*    AddPolygon(RAS_MaterialBucket *bucket, int numverts);
    virtual void            AddVertex(RAS_Polygon *poly, int i,
                            const MT_Point3& xyz,
                            const MT_Point2& uv,
                            const MT_Point2& uv2,
                            const MT_Vector4& tangent,
                            const unsigned int rgbacolor,
                            const MT_Vector3& normal,
                            bool flat,
                            int origindex);

    void                    SchedulePolygons(int drawingmode);

    /* vertex and polygon acces */
    int                 NumVertices(RAS_IPolyMaterial* mat);
    RAS_TexVert*        GetVertex(unsigned int matid, unsigned int index);
    const float*        GetVertexLocation(unsigned int orig_index);

    int                 NumPolygons();
    RAS_Polygon*        GetPolygon(int num) const;
    
    /* buckets */
    virtual void        AddMeshUser(void *clientobj, SG_QList *head, RAS_Deformer* deformer);

    void                RemoveFromBuckets(void *clientobj);
    void                EndConversion() {
#if 0
        m_sharedvertex_map.clear(); // SharedVertex
        vector<vector<SharedVertex> >   shared_null(0);
        shared_null.swap( m_sharedvertex_map ); /* really free the memory */
#endif
    }

    /* colors */
    void                DebugColor(unsigned int abgr);
    void                SetVertexColor(RAS_IPolyMaterial* mat,MT_Vector4 rgba);
    
    /* polygon sorting by Z for alpha */
    void                SortPolygons(RAS_MeshSlot& ms, const MT_Transform &transform);


    bool                HasColliderPolygon() {
        int numpolys= NumPolygons();
        for (int p=0; p<numpolys; p++)
            if (m_Polygons[p]->IsCollider())
                return true;
        
        return false;
    }

    /* for construction to find shared vertices */
    struct SharedVertex {
        RAS_DisplayArray *m_darray;
        int m_offset;
    };

    vector<vector<SharedVertex> >   m_sharedvertex_map;
    
    
#ifdef WITH_CXX_GUARDEDALLOC
public:
    void *operator new(size_t num_bytes) { return MEM_mallocN(num_bytes, "GE:RAS_MeshObject"); }
    void operator delete( void *mem ) { MEM_freeN(mem); }
#endif
};

#endif //__RAS_MESHOBJECT