#ifndef EGGGROUPNODE_H

#define EGGGROUPNODE_H

#include "pandabase.h"

#include "eggNode.h"

#include "eggVertexPool.h"

#include "coordinateSystem.h"

#include "typedObject.h"

#include "pointerTo.h"

#include "luse.h"

#include "globPattern.h"

#include "plist.h"

#include "bamCacheRecord.h"

class EggTextureCollection;

class EggMaterialCollection;

class EggPolygon;

class EggVertex;

class EggVertexPool;

class DSearchPath;

class EXPCL_PANDA_EGG EggGroupNode : public EggNode {

// This is a bit of private interface stuff that must be here as a forward

// reference. This allows us to define the EggGroupNode as an STL

// container.

// We define the list of children as a list and not a vector, so we can

// avoid the bad iterator-invalidating properties of vectors as we

// insertdelete elements.

typedef plist< PT(EggNode) > Children;

// Here begins the actual public interface to EggGroupNode.

PUBLISHED:

explicit EggGroupNode(const std::string &name = "") : EggNode(name) { }

EggGroupNode(const EggGroupNode &copy);

EggGroupNode &operator = (const EggGroupNode &copy);

virtual ~EggGroupNode();

virtual void write(std::ostream &out, int indent_level) const;

// The EggGroupNode itself appears to be an STL container of pointers to

// EggNodes. The set of children is read-only, however, except through the

// limited add_childremove_child or inserterase interface. The following

// implements this.

#if defined(WIN32_VC) || defined(WIN64_VC)

typedef const PT(EggNode) *pointer;

typedef const PT(EggNode) *const_pointer;

#else

typedef Children::const_pointer pointer;

typedef Children::const_pointer const_pointer;

#endif

typedef Children::const_reference reference;

typedef Children::const_reference const_reference;

typedef Children::const_iterator iterator;

typedef Children::const_iterator const_iterator;

typedef Children::const_reverse_iterator reverse_iterator;

typedef Children::const_reverse_iterator const_reverse_iterator;

typedef Children::size_type size_type;

typedef Children::difference_type difference_type;

iterator begin() const;

iterator end() const;

reverse_iterator rbegin() const;

reverse_iterator rend() const;

iterator insert(iterator position, PT(EggNode) x);

iterator erase(iterator position);

iterator erase(iterator first, iterator last);

void replace(iterator position, PT(EggNode) x);

PUBLISHED:

bool empty() const;

size_type size() const;

void clear();

// This is an alternate way to traverse the list of children. It is mainly

// provided for scripting code, which can't use the iterators defined above

// (they don't export through interrogate very well). These are, of course,

// non-thread-safe.

EggNode *get_first_child();

EggNode *get_next_child();

EXTENSION(PyObject *get_children() const);

MAKE_PROPERTY(children, get_children);

EggNode *add_child(EggNode *node);

PT(EggNode) remove_child(EggNode *node);

void steal_children(EggGroupNode &other);

EggNode *find_child(const std::string &name) const;

bool has_absolute_pathnames() const;

void resolve_filenames(const DSearchPath &searchpath);

void force_filenames(const Filename &directory);

void reverse_vertex_ordering();

void recompute_vertex_normals(double threshold, CoordinateSystem cs = CS_default);

void recompute_polygon_normals(CoordinateSystem cs = CS_default);

void strip_normals();

bool recompute_tangent_binormal(const GlobPattern &uv_name);

bool recompute_tangent_binormal(const vector_string &names);

bool recompute_tangent_binormal_auto();

enum TriangulateFlags {

};

int triangulate_polygons(int flags);

void mesh_triangles(int flags);

void make_point_primitives();

int rename_nodes(vector_string strip_prefix, bool recurse);

int remove_unused_vertices(bool recurse);

int remove_invalid_primitives(bool recurse);

void clear_connected_shading();

void get_connected_shading();

void unify_attributes(bool use_connected_shading, bool allow_per_primitive,

bool recurse);

void apply_last_attribute(bool recurse);

void apply_first_attribute(bool recurse);

void post_apply_flat_attribute(bool recurse);

virtual bool has_primitives() const;

virtual bool joint_has_primitives() const;

virtual bool has_normals() const;

void rebuild_vertex_pools(EggVertexPools &vertex_pools,

unsigned int max_vertices,

bool recurse);

virtual void update_under(int depth_offset);

virtual void r_transform(const LMatrix4d &mat, const LMatrix4d &inv,

CoordinateSystem to_cs);

virtual void r_transform_vertices(const LMatrix4d &mat);

virtual void r_mark_coordsys(CoordinateSystem cs);

virtual void r_flatten_transforms();

virtual void r_apply_texmats(EggTextureCollection &textures);

CoordinateSystem find_coordsys_entry();

int find_textures(EggTextureCollection *collection);

int find_materials(EggMaterialCollection *collection);

bool r_load_externals(const DSearchPath &searchpath,

CoordinateSystem coordsys,

BamCacheRecord *record);

PUBLISHED:

INLINE static bool is_right(const LVector2d &v1, const LVector2d &v2);

Children _children;

const_iterator _gnc_iterator;

// Don't try to use these private functions. User code should add and

// remove children via add_child()remove_child(), or via the STL-like

// push_back()pop_back() or insert()erase(), above.

void prepare_add_child(EggNode *node);

void prepare_remove_child(EggNode *node);

// This bit is in support of recompute_vertex_normals().

class NVertexReference {

};

typedef pvector<NVertexReference> NVertexGroup;

typedef pmap<LVertexd, NVertexGroup> NVertexCollection;

void r_collect_vertex_normals(NVertexCollection &collection,

double threshold, CoordinateSystem cs);

void do_compute_vertex_normals(const NVertexGroup &group);

// This bit is in support of recompute_tangent_binormal().

class TBNVertexReference {

};

class TBNVertexValue {

};

typedef pvector<TBNVertexReference> TBNVertexGroup;

typedef pmap<TBNVertexValue, TBNVertexGroup> TBNVertexCollection;

void r_collect_tangent_binormal(const GlobPattern &uv_name,

TBNVertexCollection &collection);

void do_compute_tangent_binormal(const TBNVertexValue &value,

const TBNVertexGroup &group);

static TypeHandle get_class_type() {

return _type_handle;

}

static void init_type() {

}

virtual TypeHandle get_type() const {

return get_class_type();

}

virtual TypeHandle force_init_type() {init_type(); return get_class_type();}

static TypeHandle _type_handle;

friend class EggTextureCollection;

friend class EggMaterialCollection;

};

#include "eggGroupNode.I"

#endif