diguyAuthorVisualWaypoint.h

Go to the documentation of this file.

/*********************************************************************
 ** Copyright (c) 1992-2019 VT MAK
 ** All rights reserved. 
 *********************************************************************/


#ifndef __diguyAuthorVisualWaypoint_H
#define __diguyAuthorVisualWaypoint_H

#include <diguy_typedefs.h>
#include <declspec_diguy.h>
class diguyAuthorVisualMaterial;
class diguyAuthorVisualWaypoint;
class diguyWaypoint;
class bdiBeadWaypoint;


/*l
 **  Function for setting the create function for waypoint visual subclass
 **  objects.  This should be called after diguy_author_initialize(), but
 **  before any scenario is created of loaded.
 */
BDI_DECLSPEC_diguy void diguy_author_set_waypoint_visual_create_func(diguyAuthorVisualWaypointCreateFunc* func);


/*********************************************************************/
class BDI_DECLSPEC_diguy diguyAuthorVisualWaypoint
{

public:

        /*l
         **  Returns the visual material to be used for rendering this object.
         */
        diguyAuthorVisualMaterial* get_visual_material();

        /*l
         **  Returns 1 if this visual should be visible, else 0.
         */
        int get_visible();

        /*l
         **  Returns a pointer to the waypoint this visual is associated with.
         **  Most of the information needed to create the visual can be retrieved
         **  using diguyWaypoint function calls.
         */
        diguyWaypoint* get_waypoint();




/*****************************************************************************/
        /*l
         *b  Description:
         **
         **    build() will be called by DI-Guy when it is time for a
         **    renderer-specific visual object to be created.  All information
         **    necessary to build the visual should be available via the Accessor
         **    Functions above when this function is called.
         **
         **    It is common for build() and update() to use the same internal,
         **    user-written function for creating geometry.
         **
         **    Waypoints are typically represented by relatively complex set of
         **    cylinders and cones.  The provided reference implementation
         **    diguyAuthorVisualWaypoint subclass should be consulted for how to
         **    create waypoint visual components.
         **
         *i  Immediate Mode:
         **
         **    Immediate mode renderers may override this function to create an
         **    object, for example a vertex array, that may be used when draw() is
         **    called.
         **
         *i  Scene Graph:
         **
         **    Scene graph renderers almost always override this function to
         **    create a scene graph node object that is attached to the scene
         **    graph and updated when update() is called.
         */
        virtual void build();

        /*l
         *b  Description:
         **
         **    unbuild() will be called by DI-Guy when it is time for a
         **    renderer-specific visual object to be destroyed.
         **
         **    In general this function should undo all operations and deallocate
         **    all objects created during the build() function call.
         */
        virtual void unbuild();

        /*l
         *b  Description:
         **
         **    update() will be called by DI-Guy when this visual has changed
         **    state and needs to be updated in some way.
         **
         **    The update_flags argument will be a value from the
         **    diguyAuthorVisualUpdateFlag enumeration:
         **
         *i    DIGUY_GRAPHICS_VISUAL_UPDATE_GEOMETRY
         **
         **      The overall geometry of the visual needs to be updated.  This
         **      means that polygons, lines, and whatever other graphics
         **      primitives the visual uses need to be recreated.
         **
         *i    DIGUY_GRAPHICS_VISUAL_UPDATE_POSITION
         **
         **      The position and/or orientation of the visual needs to be
         **      updated.  The overall geometry of the visual (polygons, lines,
         **      etc.) remains unchanged, and don't need to be recreated.
         **
         **      If the visual can be relocated via changing the offset of a
         **      scene graph node it can save time to not recreate a lot of
         **      geometry.
         **
         **      If the visual can't be relocated in such a way, the entire set
         **      of geometry used by the visual; essentially, doing the same
         **      operation as for DIGUY_GRAPHICS_VISUAL_UPDATE_GEOMETRY.
         **
         *i    DIGUY_GRAPHICS_VISUAL_UPDATE_MATERIAL
         **
         **      The material of the visual needs to be updated.  This can include
         **      color, fill options, line width, etc.  The geometry and position
         **      of the visual remain the same.  The get_visual_material()
         **      function should be called to retrieve the updated materials.
         **
         **      For some renderers it can make more sense to just recreate all of
         **      the visual geometry with the updated material settings.
         **
         *i    DIGUY_GRAPHICS_VISUAL_UPDATE_ALL
         **
         **      All aspects of the visual need to be updated.
         */
        virtual void update(int update_flags);

        /*l
         *b  Description:
         **
         **    draw() will be called by DI-Guy when it is time for a
         **    renderer-specific visual object to be drawn.
         **
         *i  Immediate Mode:
         **
         **    Immediate mode renderers almost always override this function, to
         **    draw the visual.
         **
         *i  Scene Graph:
         **
         **    Scene graph renderers usually do not override this function, as
         **    draw operations are usually taken care of automatically by the
         **    scene graph.
         */
        virtual void draw();

        /*l
         *b  Description:
         **
         **    show() will be called by DI-Guy if the visibility status of this
         **    visual has changed to be visible.
         */
        virtual void show();

        /*l
         *b  Description:
         **
         **    hide() will be called by DI-Guy if the visibility status of this
         **    visual has changed to be not visible.
         */
        virtual void hide();



/****************************************************************************/
/****************************************************************************/

protected:

        diguyAuthorVisualWaypoint(void* internal_data);
        virtual ~diguyAuthorVisualWaypoint();

public:
        static diguyAuthorVisualWaypointCreateFunc* s_create_func;
protected:

        bdiBeadWaypoint* m_scripted_object;
        bdiBeadWaypoint* get_scripted_object() {return m_scripted_object;}

        diguyAuthorVisualMaterial* m_visual_material;

        virtual void internal_get_position(float* tx, float* ty, float* tz);
        virtual void internal_get_orientation(float* rz, float* rx, float* ry);

        friend class diguyWaypoint;
        friend class bdiBeadWaypoint;
};


#endif /* __diguyAuthorVisualWaypoint_H */