SNCH_Object_Data.h

Go to the documentation of this file.

#ifndef SNCH_OBJECT_DATA_H
#define SNCH_OBJECT_DATA_H

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

using namespace vrecko;

namespace APSpacePartitioning {

// Flags for SNCH_Object_Data::FaceSNCH::dwSNCHFlags:
#define SNCH_FACE_DEGENERATED       0x00000001
    // The triangle is degenerated. In our context it might mean not only that
    // two points have the same coordinates, but also that triangle has surface
    // of size 0.


// Flags for SNCH_Object_Data::FaceSNCH::edgeFlags:
#define SNCH_EDGE_CONCAVE_BREAK     0x00000001
    // The edge forms a concave seam or the edge is a terminating one (belongs to only a single triangle)


// Id for no face group
#define FACESNCH_NO_GROUP           0xFFFFFFFF
    // SNCH_Object_Data::createFaceGroups() method performs optimizations based on the fact,
    // that FACESNCH_NO_GROUP is last unsigned int value... so DON'T CHANGE IT


class SNCH_Object_Data: public SphereBVH_Object_Data {
public:
    //
    // constructors / destructors
    //
    SNCH_Object_Data();
    ~SNCH_Object_Data();

    virtual bool isHierarchyCreated() { return bSNCHierarchyCreated; }

    struct VertexSNCH : public VertexBase {
        std::vector<unsigned long> faces;
            // ONLY for representants!
            // A list of faces containing this vertex, sorted CLOCKWISE.
        osg::Vec3 averageNormal;
        unsigned long dwRepresentant;
            // if several vertices lie on the same position, one of the vertices
            // is chosen as a representant and all of the vertices are pointing
            // to the selected vertex. ONLY that vertex will have correct information
            // in the [faces] array.
            // The representant itself and any vertex that is not sharing position with other vertex,
            // are pointing to itself (being its own representant).
    };
    virtual unsigned long getVertexStructureSize() { return sizeof(VertexSNCH); }
    virtual void allocateVertexArray(unsigned long numVertices) { vertices = new VertexSNCH[numVertices]; vertex_size = getVertexStructureSize(); }
    virtual void deallocateVertexArray() { if (vertices) { delete[] ((VertexSNCH*)vertices); } }
    virtual bool saveVerticesToFile(vrecko::BufferedFileWrite *bfile);
    virtual bool loadVerticesFromFile(vrecko::BufferedFile *bfile);

    inline VertexSNCH* getSNCHVertex(unsigned long index) { return (VertexSNCH*)getVertex(index); }

    struct FaceSNCH : public FaceBase {
        unsigned long dwSNCHFlags; // combination of SNCH_FACE_*
        unsigned long fIndex[3]; // neighbouring faces (0xFFFFFFFF if none)
        unsigned long edgeFlags[3]; // combination of SNCH_EDGE_*

        unsigned long dwGroup;
            // Id of a group that contains given face. (FACESNCH_NO_GROUP is for "no group", though this will not be used in any face.)
    };
    virtual unsigned long getFaceStructureSize() { return sizeof(FaceSNCH); }
    virtual void allocateFaceArray(unsigned long numFaces) { faces = new FaceSNCH[numFaces]; face_size = getFaceStructureSize(); }
    virtual void deallocateFaceArray() { if (faces) { delete[] ((FaceSNCH*)faces); }}
    virtual bool saveFacesToFile(vrecko::BufferedFileWrite *bfile);
    virtual bool loadFacesFromFile(vrecko::BufferedFile *bfile);

    inline FaceSNCH* getSNCHFace(unsigned long index) { return (FaceSNCH*)getFace(index); }


    struct STNodeSNCH : public STNodeSphere {
        osg::Vec3 cone_axis;
        float half_spread_angle; // radians perhaps?

        // NOTE: face_index variable from STNodeSphere is also used here FOR NON-LEAF NODES.
            // It represents the "best" triangle, that will be used for quick answer if the subsequent
            // tree tests were assumed unnecessary.
    };
    virtual void* allocateSTNode() { return new STNodeSNCH; }
    virtual unsigned long getSTNodeStructureSize() { return sizeof(STNodeSNCH); }
    virtual bool saveTreeNodeToFile(void* node, vrecko::BufferedFileWrite *bfile);
    virtual bool loadTreeNodeFromFile(void* node, vrecko::BufferedFile *bfile);

//  typedef std::map<osg::Vec3, osg::Vec3> NormalsMap;

protected:

    bool bSNCHierarchyCreated;

//  NormalsMap edge_normal;

//  virtual void createTreeFromGeometry(osg::Node *pNode);

    bool calculateGeometryProperties(void);
        // Calculates the triangle flags etc.
        // (= which triangle is degenerated, ...)
    
    bool generateVertexNeighbourhood(void);
        // Iterates through all the vertices and generates a list of triangles in the neigbourhood
        // of each vertex.
        // Also fills out correct info into [dwRepresentant] and [averageNormal] vertex variables.

    bool createEdgeGroups(void);
        // Considers all edges and searches for concave breaks.

    bool createFaceGroups(void);
        // Assigns a group to every triangle based on some criteria.
        // _PROBABLY_ mostly: similarity with nearby vertices.
        //          Neighbouring vertices with similar normal will be in the same group.
        // ASSUMES that the face normals are normalized.

    bool computeSNCH(void *pSTNode);

    void calcSubtreeTriangleRepresentant(void *pNode, osg::Vec3 *axis, unsigned long *triangle, float *bestValue = NULL);
        // Which triangle best represents the given subtree?
        // [bestValue] is a temporary variable to help with the calculation. Must be NULL at start.

    struct DebugLevelStats {
        DebugLevelStats() : cntNodes(0), cntAngle(0.0f), cntRadius(0.0f) {};

        int cntNodes;
        float cntAngle;
        float cntRadius;
    };

    struct DebugStats {
        DebugStats() : totalNodes(0), twoTotal(0), twoNeighbours(0) {};

        int totalNodes;
        int twoTotal;
        int twoNeighbours;
        DynamicArray<DebugLevelStats> levels;
    };

    void writeDebugStatistics();

    void wdsInfoRec(void *pSTNode, int level, DebugStats *ds);


    virtual bool constructCacheDataName(char *pOutDataName, int* version);
    virtual bool loadDataFromPersistentCache_Init();


    virtual bool coreHierarchyCreation(void);
};

}

#endif