GeometryLoaderBase.h

Go to the documentation of this file.

#ifndef GEOMETRY_LOADER_BASE_H
#define GEOMETRY_LOADER_BASE_H


// THIS IS A DERIVATE of the original GeometryLoaderBase from the Phantom library (also in Vrecko solution)...
// try to use THAT ONE as a reference.



#include <vrecko/Ability.h>
#include <osg/Node>
#include <osg/Geode>
#include <osg/Geometry>

using namespace vrecko;

namespace APFFDEditor {

/*
    Basic class to load geometry from OpenSceneGraph node
*/

class GeometryLoaderBase {
public:
    GeometryLoaderBase();
    ~GeometryLoaderBase();
        // NOTE: Don't forget to call destroyGeometry() in your destructor.

    // The idea:
    // This class contains the basic loading routines.
    // Descendant classes can create their descendant versions of _VertexBase_ and _FaceBase_ classes
    // but in that case it is IMPORTANT to also override methods that take care of allocation
    // and returns the correct size of the used structure!
    // You have to also call destroyGeometry() in your destructor (of the GeometryLoaderBase descendant).

    virtual bool loadXMLParameters(XERCES_CPP_NAMESPACE_QUALIFIER DOMNode *node);
    
    struct VertexBase {
        osg::Vec3 pos;
        osg::Vec3 realPos;
        osg::Vec3 normal;
        osg::Vec3 relPosInGrid;
    };
    virtual unsigned long getVertexStructureSize() { return sizeof(VertexBase); }
    virtual void allocateVertexArray(unsigned long numVertices) { vertices = new VertexBase[numVertices]; vertex_size = getVertexStructureSize(); }
    virtual void deallocateVertexArray() { if (vertices) { delete[] ((VertexBase*)vertices); } }

    struct FaceBase {
        unsigned long vIndex[3]; // vertex indices (ordered clockwise)
        osg::Vec3 min; // minimum coordinate (used for sorting)
        osg::Vec3 normal;
//      int index_to_geometry;
    };
    virtual unsigned long getFaceStructureSize() { return sizeof(FaceBase); }
    virtual void allocateFaceArray(unsigned long numFaces) { faces = new FaceBase[numFaces]; face_size = getFaceStructureSize(); }
    virtual void deallocateFaceArray() { if (faces) { delete[] ((FaceBase*)faces); }}

    inline void* getFace(unsigned long index) { return (void*)(((unsigned char*)faces) + index * face_size); }
    inline void* getVertex(unsigned long index) { return (void*)(((unsigned char*)vertices) + index * vertex_size); }

    inline unsigned long getFaceCount() { return face_count; }
    inline unsigned long getVertexCount() { return vertex_count; }

    void debugWriteNormals();

protected:
    void *faces;
    unsigned long face_count;
    unsigned long face_size; // cached number from getFaceStructureSize()

    void *vertices;
    unsigned long vertex_count;
    unsigned long vertex_size;  // cached number from getVertexStructureSize()

    bool bRecalculateNormals;
    vrecko::EnvironmentObject *thisOwnerPtr;

    bool getOSGInitCounts(osg::Node *pNode, unsigned long &pVertexCount, unsigned long &pPrimitiveCount);
    
    // Fills the buffers with vertices and faces loaded from a given OSG node.
    virtual bool loadGeometry(osg::Node *pNode);
    bool loadGeometryHelper(osg::Node *pNode, osg::Matrix &transform, unsigned long &vertex_pos, unsigned long &face_pos);
    inline osg::Vec3 * getNormalByIndex(osg::Geometry::AttributeBinding normalBinding, osg::Vec3Array * pNormArray, osg::IndexArray * pNormIndices, unsigned long index);

    // Iterates throught all the faces and sorts vIndex-es clockwise
    void sortVerticesClockwise();

    // Deallocates loaded faces/vertices
    virtual void destroyGeometry();

    // Ignores the old normals and creates new ones.
    void recalculateNormals();

    
};

inline osg::Vec3 * GeometryLoaderBase::getNormalByIndex(osg::Geometry::AttributeBinding normalBinding, osg::Vec3Array * pNormArray, osg::IndexArray * pNormIndices, unsigned long index) {
    if (osg::Geometry::BIND_OFF == normalBinding)
        return ((osg::Vec3*)NULL);

    if (pNormIndices) {
        switch (pNormIndices->getDataType()) {
        case osg::Array::ByteArrayType:
            index = *(((char*)pNormIndices->getDataPointer()) + index);
            break;
        case osg::Array::ShortArrayType:
            index = *(((short*)pNormIndices->getDataPointer()) + index);
            break;
        case osg::Array::IntArrayType:
            index = *(((int*)pNormIndices->getDataPointer()) + index);
            break;
        case osg::Array::UByteArrayType:
            index = *(((unsigned char*)pNormIndices->getDataPointer()) + index);
            break;
        case osg::Array::UShortArrayType:
            index = *(((unsigned short*)pNormIndices->getDataPointer()) + index);
            break;
        case osg::Array::UIntArrayType:
            index = *(((unsigned int*)pNormIndices->getDataPointer()) + index);
            break;
        default:
            
            return (osg::Vec3*)NULL;
        }
    }

    return ((osg::Vec3*)pNormArray->getDataPointer()) + index;
}

}

#endif