#ifndef SPEEDTREENODE_H

#define SPEEDTREENODE_H

#include "pandabase.h"

#include "pandaNode.h"

#include "pointerTo.h"

#include "stTree.h"

#include "stTransform.h"

#include "stTerrain.h"

#include "callbackObject.h"

#include "loaderOptions.h"

#include "transformState.h"

#include "nodePath.h"

#include "pStatCollector.h"

#include "randomizer.h"

#include "speedtree_api.h"

class Loader;

#if SPEEDTREE_VERSION_MAJOR > 5 || (SPEEDTREE_VERSION_MAJOR == 5 && SPEEDTREE_VERSION_MINOR >= 3)

#undef ST_DELETE_FOREST_HACK

#else

#define ST_DELETE_FOREST_HACK

#endif

class EXPCL_PANDASPEEDTREE SpeedTreeNode : public PandaNode {

// This definition is required by InstanceList, below.

typedef pvector<SpeedTree::CInstance> STInstances;

PUBLISHED:

// This nested class keeps a linear list of transforms, for the purpose of

// recording instances of a particular STTree. It is used below.

class InstanceList {

};

PUBLISHED:

explicit SpeedTreeNode(const std::string &name);

virtual ~SpeedTreeNode();

INLINE bool is_valid() const;

INLINE int get_num_trees() const;

INLINE const STTree *get_tree(int n) const;

MAKE_SEQ(get_trees, get_num_trees, get_tree);

const InstanceList &get_instance_list(int n) const;

MAKE_SEQ(get_instance_lists, get_num_trees, get_instance_list);

INLINE STTree *modify_tree(int n);

int count_total_instances() const;

InstanceList &add_tree(const STTree *tree);

int remove_tree(const STTree *tree);

void remove_all_trees();

bool has_instance_list(const STTree *tree) const;

const InstanceList &get_instance_list(const STTree *tree) const;

InstanceList &modify_instance_list(const STTree *tree);

void add_instance(const STTree *tree, const STTransform &transform);

void add_instances(const NodePath &root, const TransformState *transform = TransformState::make_identity());

void add_instances_from(const SpeedTreeNode *other);

void add_instances_from(const SpeedTreeNode *other, const TransformState *transform);

void add_random_instances(const STTree *tree, int quantity,

PN_stdfloat x_min, PN_stdfloat x_max,

PN_stdfloat y_min, PN_stdfloat y_max,

PN_stdfloat scale_min, PN_stdfloat scale_max,

PN_stdfloat height_min, PN_stdfloat height_max,

PN_stdfloat slope_min, PN_stdfloat slope_max,

Randomizer &randomizer = Randomizer());

bool add_from_stf(const Filename &stf_filename,

const LoaderOptions &options = LoaderOptions());

bool add_from_stf(std::istream &in, const Filename &pathname,

const LoaderOptions &options = LoaderOptions(),

Loader *loader = nullptr);

bool setup_terrain(const Filename &terrain_file);

void set_terrain(STTerrain *terrain);

INLINE void clear_terrain();

INLINE bool has_terrain() const;

INLINE STTerrain *get_terrain() const;

void snap_to_terrain();

void reload_config();

void set_wind(double strength, const LVector3 &direction);

INLINE void set_time_delta(double delta);

INLINE double get_time_delta() const;

INLINE static void set_global_time_delta(double delta);

INLINE static double get_global_time_delta();

MAKE_PROPERTY(time_delta, get_time_delta, set_time_delta);

MAKE_PROPERTY(global_time_delta, get_global_time_delta,

set_global_time_delta);

static bool authorize(const std::string &license = "");

SpeedTreeNode(const SpeedTreeNode &copy);

virtual PandaNode *make_copy() const;

virtual PandaNode *combine_with(PandaNode *other);

virtual void apply_attribs_to_vertices(const AccumulatedAttribs &attribs,

int attrib_types,

GeomTransformer &transformer);

virtual bool cull_callback(CullTraverser *trav, CullTraverserData &data);

virtual bool is_renderable() const;

virtual void add_for_draw(CullTraverser *trav, CullTraverserData &data);

void prepare_scene(GraphicsStateGuardianBase *gsgbase, const RenderState *net_state);

virtual void compute_internal_bounds(CPT(BoundingVolume) &internal_bounds,

int &internal_vertices,

int pipeline_stage,

Thread *current_thread) const;

virtual void output(std::ostream &out) const;

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

static void write_error(std::ostream &out);

void set_transparent_texture_mode(SpeedTree::ETextureAlphaRenderMode eMode) const;

void init_node();

void r_add_instances(PandaNode *node, const TransformState *transform,

Thread *current_thread);

void repopulate();

void update_terrain_cells();

bool validate_api(GraphicsStateGuardian *gsg);

void draw_callback(CallbackData *cbdata);

void render_forest_into_shadow_maps();

void setup_for_render(GraphicsStateGuardian *gsg);

void cull_forest();

void print_forest_stats(const SpeedTree::CForest::SPopulationStats &forest_stats) const;

class DrawCallback : public CallbackObject {

};

std::string _os_shaders_dir;

// A list of instances per each unique tree.

typedef ov_set<InstanceList *, IndirectLess<InstanceList> > Trees;

Trees _trees;

#ifdef ST_DELETE_FOREST_HACK

SpeedTree::CForestRender &_forest_render;

#else

SpeedTree::CForestRender _forest_render;

#endif // ST_DELETE_FOREST_HACK

SpeedTree::CView _view;

SpeedTree::SForestCullResultsRender _visible_trees;

SpeedTree::CForest::SPopulationStats _population_stats;

bool _needs_repopulate;

bool _is_valid;

PT(STTerrain) _terrain;

SpeedTree::CTerrainRender _terrain_render;

SpeedTree::STerrainCullResults _visible_terrain;

SpeedTree::Vec3 _light_dir;

class ShadowInfo {

};

typedef pvector<ShadowInfo> ShadowInfos;

ShadowInfos _shadow_infos;

double _time_delta;

static double _global_time_delta;

static bool _authorized;

static bool _done_first_init;

static PStatCollector _cull_speedtree_pcollector;

static PStatCollector _cull_speedtree_shadows_pcollector;

static PStatCollector _cull_speedtree_trees_pcollector;

static PStatCollector _cull_speedtree_terrain_pcollector;

static PStatCollector _draw_speedtree_pcollector;

static PStatCollector _draw_speedtree_shadows_pcollector;

static PStatCollector _draw_speedtree_trees_pcollector;

static PStatCollector _draw_speedtree_terrain_pcollector;

static PStatCollector _draw_speedtree_terrain_update_pcollector;

static void register_with_read_factory();

virtual void write_datagram(BamWriter *manager, Datagram &dg);

static TypedWritable *make_from_bam(const FactoryParams &params);

void fillin(DatagramIterator &scan, BamReader *manager);

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 SpeedTreeNode::DrawCallback;

};

INLINE std::ostream &operator << (std::ostream &out, const SpeedTreeNode::InstanceList &instances) {

instances.output(out);

return out;

}

#include "speedTreeNode.I"

#endif