diguyGraphicsShape.h

Go to the documentation of this file.

/****************************************************************************
 * Copyright (c) 2024 MAK Technologies, Inc.
 * All rights reserved.
 ****************************************************************************/

/*********************************************************************/
#pragma once

#ifdef SWIG
%module diguyGraphicsShape
#else
#define CPLUSPLUS_ONLY
#endif

#ifdef CPLUSPLUS_ONLY
#include <diguy_constants.h>

class bdiShape;
class diguyCharacter;
class diguyGraphicsFile;
class diguyGraphicsLink;
class diguyGraphicsMesh;
class diguyGraphicsShape;
class diguyGraphicsState;

#endif

#include <declspec_diguy.h>

/*****************************************************************************/
class BDI_DECLSPEC_diguy diguyGraphicsShape
{

public:


/*****************************************************************************/
   /*l
    *b  Description:
    **
    **    This function returns the name of the shape.  The returned pointer
    **    will never be NULL.
    **
    *b  Returns:
    **
    **    name of the shape as C string
    */
   const char* get_name();

   /*l
    *b  Description:
    **
    **    All shapes are assigned a unique identifier, or uid.  This function
    **    returns this shape's uid.
    **
    **    *Note*: unique identifiers can change between DI-Guy runs.
    **
    *b  Returns:
    **
    **    unique identifier of object
    */
   long get_uid();

   /*l
    *b  Description:
    **
    **    This function returns a pointer to the diguyCharacter to which this
    **    shape belongs.
    **
    *b  Returns:
    **
    **    pointer of type diguyCharacter
    */
   diguyCharacter* get_character();


   /*l
    *b  Description:
    **
    **    This function returns the name of the shape set of which this shape
    **    is a part.
    **
    **    A shape set is a collection of shapes that are related, coming from
    **    a set of related geometry files, sometimes one file per LOD.
    **
    **    A shape is a collection of parts each representing the same thing
    **    at varying levels of detail.
    **
    **    For example, in its config files DI-Guy has a shape set named
    **    "firefighter", which references five OpenFlight files named
    **    firefighter_LOD1.flt through firefighter_LOD5.flt.  The firefighter
    **    shape set contains separate shapes for the head, arms, legs, etc.,
    **    at five different levels of detail.
    **
    **    Use the function get_shape_set_filename_for_lod() to get the actual
    **    geometry filenames that should be used for each LOD.
    **
    *b  Returns:
    **
    **    shape set of shape as C string
    */
   const char* get_shape_set_name();

   /*l
    *b  Description:
    **
    **    This function returns the name of the shape.  This name identifies
    **    which pieces of geometry out of the shape set should comprise the
    **    shape.
    **
    *b  Returns:
    **
    **    shape name of shape as C string
    */
   const char* get_shape_set_shape_name();

   /*l
    *b  Description:
    **
    **    This function returns the name of the link to which this shape is
    **    typically attached.
    **
    **    Use the function get_link() to get a pointer to the actual link to
    **    which this shape is attached.
    **
    *b  Returns:
    **
    **    name of recommended attachment link as C string
    */
   const char* get_recommended_attachment_link_name();

   /*l
    *b  Description:
    **
    **    This function returns how many LODs this shape has.  This will be a
    **    number between 1 and 7.
    **
    *b  Returns:
    **
    **    number of LODs
    */
   int get_num_lods();

#ifdef CPLUSPLUS_ONLY

   /*l
    *b  Description:
    **
    **    This function returns the LOD ranges of this shape.  The returned
    **    pointer points to an array of eight floats, which represent ranges
    **    in meters at which LODs should be shown.
    **
    *b  Returns:
    **
    **    LOD ranges
    **
    *b  Only Callable From C++
    */
   float* get_lod_ranges();

#endif

   /*l
    *b  Description:
    **
    **    This function returns the most recent lod setting as set by
    **    set_graphics_lod(), or as set by
    **    diguyCharacter::set_graphics_lod().
    **
    *b  Returns:
    **
    **    LOD index; integer from 1 to get_num_lods()
    */
   int get_graphics_lod();

   float get_graphics_lod_fraction();

   bool get_lod_fades_out(int lod);

   void get_blend_shape_data(int lod, float fraction, float weights[4], int indexes[4]);

   /*l
    *b  Description:
    **
    **    This function returns the filename of the geometry file from which
    **    the shape is read for a specific LOD.
    **
    *b  Arguments:
    **
    *a    lod - level of detail; a number between 1 and get_num_lods()
    **
    *b  Returns:
    **
    **    geometry filename as C string
    */
   const char* get_shape_set_filename_for_lod(int lod);

   /*l
    *b  Description:
    **
    **    This function returns the number of low-level geometry meshes that
    **    comprise this shape.
    **
    *b  Arguments:
    **
    *a    lod - level of detail; a number between 1 and get_num_lods()
    **
    *b  Returns:
    **
    **    number of meshes in this shape
    */
   int get_num_meshes(int lod);

   /*l
    *b  Description:
    **
    **    This function returns a pointer to one of the low-level geometry
    **    mesh objects that comprise this shape.
    **
    *b  Arguments:
    **
    *a    index - index of mesh; a number between 0 and get_num_meshes() - 1
    *a    lod   - level of detail; a number between 1 and get_num_lods()
    **
    *b  Returns:
    **
    **    pointer to object of type diguyGraphicsMesh; NULL on error
    */
   diguyGraphicsMesh* get_mesh_at_index_for_lod(int index, int lod);

   /*l
    *b  Description:
    **
    **    This function fills out the accumulated xform data for the low-level geometry
    **    mesh objects that comprise this shape.
    **
    *b  Arguments:
    **
    *a    index - index of mesh; a number between 0 and get_num_meshes() - 1
    *a    lod   - level of detail; a number between 1 and get_num_lods()
    *a    matrix - 4x4 matrix to fill out typically will be identity
    *a    transpose - flips the data depending on desired layout
    **
    *b  Returns:
    **
    **    0 on success
    */
   int get_mesh_transform_at_index_for_lod(int index, int lod, float* matrix, int transpose = 0);

   /*l
    *b  Description:
    **
    **    This function returns a pointer to the link to which this shape is
    **    actually attached.
    **
    *b  Arguments:
    **
    *a    index - index of mesh; a number between 0 and get_num_meshes() - 1
    *a    lod   - level of detail; a number between 1 and get_num_lods()
    **
    *b  Returns:
    **
    **    pointer to object of type diguyGraphicsMesh; NULL on error
    */
   diguyGraphicsLink* get_link();

   /*l
    *b  Description:
    **
    **    This function returns the name of the DI-Guy motion data variable
    **    that controls whether this shape should be visible.
    **
    **    The returned pointer will be NULL if there is no associated
    **    variable.
    **    This visiblity can be overridden by calling diguyGraphicsLink::set_shape_switch_override()
    **    on the parent link.
    **
    *b  Returns:
    **
    **    name of the variable; NULL if there is no variable
    */
   const char* get_switch_var_name();

   /*l
    *b  Description:
    **
    **    This function returns the value of the DI-Guy motion data variable
    **    for which the shape should be visible.
    **
    **    Note that the variable in the motion data is a float, but gets cast
    **    to an integer and compared against this number during shape
    **    updates.
    **
    *b  Returns:
    **
    **    number representing value for which shape should be visible
    */
   int get_switch_value();

   /*l
    *b  Description:
    **
    **    This function returns whether this shape should currently be hidden
    **    or shown, based on the value of the shape's switch variable (if
    **    any).
    **
    *b  Returns:
    **
    **    1 if shape is hidden, 0 if not
    */
   int get_is_hidden() const;

   int set_is_hidden(int hidden);

   const char * get_class_type() const;

   const char * get_object_type() const;

   const char * get_material_type() const;

   int get_is_pbr_ready() const;

   /*l
    *b  Description:
    **
    **    This function returns the geometry file from which geometry for the
    **    shape was read.  Each LOD of the shape may potentially come from a
    **    different file.
    **
    **    Note that if a diguyGraphicsFile create function has not been
    **    registered with a call to diguy_graphics_set_file_create_func(),
    **    this function will return NULL.
    **
    *b  Arguments:
    **
    *a    lod   - level of detail; a number between 1 and get_num_lods()
    **
    *b  Returns:
    **
    **    object of type diguyGraphicsFile
    */
   diguyGraphicsFile* get_diguy_graphics_file(int lod);

#ifdef CPLUSPLUS_ONLY

   /*l
    *b  Description:
    **
    **    This function returns a pointer to an object that represents the
    **    geometry for the shape.  The returned object is an object that has
    **    been returned by a previous call to diguyGraphicsFile::find_part(),
    **    and can be safely cast to the type of object that has been so
    **    returned.
    **
    **    Note that if a diguyGraphicsFile create function has not been
    **    registered with a call to diguy_graphics_set_file_create_func(),
    **    this function will return NULL.
    **
    *b  Arguments:
    **
    *a    lod   - level of detail; a number between 1 and get_num_lods()
    **
    *b  Returns:
    **
    **    generic object which must be cast appropriately
    **
    *b  Only Callable From C++
    */
   void* get_diguy_graphics_file_part(int lod);

#endif

   /*l
    *b  Description:
    **
    **    Some shapes have meshes that have multiple selectable graphics
    **    states, including materials and textures.  This function returns
    **    the value that specifies which graphics state to use for meshes of
    **    this shape.
    **
    **    This is different than get_switch_value(), which returns the value
    **    of the switch that controls whether or not meshes of this state are
    **    shown.
    **
    *b  Returns:
    **
    **    value of state switch; -1 if there is no state switch
    */
   int get_graphics_state_switch_index();

   /*l
    *b  Description:
    **
    **    Returns the number of switched graphics states available to this
    **    shape.  See get_graphics_state_switch_index().
    **
    *b  Returns:
    **
    **    number of switched graphics states
    */
   int get_num_switched_graphics_states();

   /*l
    *b  Description:
    **
    **    Returns the graphics state associated with the passed switch value.
    **
    *b  Returns:
    **
    **    pointer to type diguyGraphicsState
    */
   diguyGraphicsState* get_switched_graphics_state(int switch_value = -1);

   int set_state_switch_index(int index);

   /*l
    *b  Description:
    **
    **    Returns in the passed pointers the unique color of this shape. All
    **    shapes in a DI-Guy appearance are assigned a unique RGB color that
    **    can be used in pick/selection operations.
    **
    **    Also see diguyScenario::map_color_to_impact().
    **
    **    See programming_examples/diguy_graphics_api/ogl_examples/intersection_test
    **    for an example of its usage.
    **
    *b  Returns:
    **
    **    0 on success, -1 on failure
    */
   int get_unique_color(unsigned char* r, unsigned char* g, unsigned char* b);

   /*l
    *b  Description:
    **
    **    This function identifies if this shape has skinned data.  Scene
    **    graph renderers will need to know this in the build phase to help
    **    set up the matrix data shader functionality.
    **
    *b  Returns:
    **
    **    1 if contains at lease one file with skinned data, 0 if not
    */
   int get_contains_skinned_file();

   /*l
    *b  Description:
    **
    **    Returns the value of the configured parameter with the given name.
    **
    *b  Returns:
    **
    **    The parameter value as a string, or NULL if there's no parameter with the given name.
    */
   const char* find_appearance_parameter( const char* parameter_name ) const;

/***************************************************************************************
 *2  Per shape material uniform API
 **/
   /*l
    *b  Description:
    **
    **    By default DI-Guy allows per shape uniforms that will be restored to <0,0,0,0> after a draw call.
    **    These can be used by end users to customize the appearance of
    **    characters via shaders and misc textures.  You can see a
    **    demonstration of this in the Exface_sales_demo.dss file where an
    **    additional texture is used.
    **
    *b   Example:
    **
    *e   local character = this_scenario:get_character_at_index(0);
    *e   local link = character:get_link_at_index(0);
    *e   local shape = link:find_shape_by_class_type("head");
    *e   shape:set_material_parameter_4f("ufrm_blood_color",1,.1,.1,.5, 1);
    */
   int set_material_parameter_4f(const char* parameter_name,
      float x, float y, float z, float w,
      float blend_time = 0.0);

   /*l
    *b  Description:
    **
    **    Allow access to the current values of a material parameter, accounting
    **    for value blending. Returns -1 if the parameter can't be found.
    */
   int get_material_parameter_4f(const char* parameter_name,
      float* x, float* y, float* z, float* w);

/***************************************************************************************
 *2  Texture Variation API
 **/

   /*l
    *b  Description:
    **
    **    Returns a char * of length get_variation_texture_size() that represents
    **    the pixels in a unique per shape texture. Typically a Retained mode
    **    renderer would need to use this to load a state node with the texture
    **    see diguyOsgGraphicsShape.cpp for an example. For an immediate mode
    **    renderer we push the texture to the object via update_variation_texture()
    */
   unsigned char * get_variation_texture();

   int get_variation_texture_size();

   static int get_shared_variation_texture_size();

   int get_num_variations();

   const char * get_variation_name(int variation_index);

   int set_variation_index(int variation_index);

   int get_has_custom_variation();

   int get_num_variation_components();

   const char * get_variation_component_name(int index);

   int get_variation_component_row(const char * name);

   int set_variation_component_value(int index, float color_shift_r, float color_shift_g, float color_shift_b);

   int get_variation_texture_row();

   void set_variation_texture_data( unsigned char* texture_data );

#ifdef CPLUSPLUS_ONLY

   /*l
    *b  Description:
    **
    **    This function is typically called by scene graph renderers as part
    **    of diguyGraphicsShape::update().  Scene graph renderers should
    **    queue up this data to be sent to the graphics card at the
    **    appropriate time.
    **
    **    Note that the format of the data in mat_data will be affected by
    **    the bdiGraphicsInitGraphicsAPI variable transpose_shader_matrices
    **    value.
    **
    *b  Callable From:
    **
    *-    C++
    */
   int get_shader_matrix_data( int* num_matrices, const float** matrix_data );

#endif

   /*l
    *b  Description:
    **
    **     Returns the transpose state of the shader matrices.
    **
    *b  Returns:
    **
    **    1 if shader matrices are transposed, 0 otherwise.
    */
   int get_are_shader_matrices_transposed();


/*****************************************************************************/
#ifdef CPLUSPLUS_ONLY

   /*l
    *b  Description:
    **
    **    This function will be called by DI-Guy when it is time for
    **    renderer-specific shape objects to be created.  All information
    **    necessary to build the shape should be available via the Accessor
    **    Functions above when this function is called.
    **
    **    The build() function for the link to which a shape is attached
    **    will be called before the shape's build() function.
    **
    *i  Immediate Mode:
    **
    **    Immediate mode renderers can override this function, to create a
    **    pre-compiled object that expedites the draw().  Display lists in
    **    OpenGL are an example of this.
    **
    *i  Scene Graph:
    **
    **    Scene graph renderers usually do override this function, to create
    **    scene graph nodes that will hold geometry nodes of meshes attached
    **    to the shape.
    **
    **    The following nodes are typically created:
    **
    *-    - a switch node to control showing and hiding of the shape
    *-    - an LOD node to control which meshes are shown due to
    *-      LOD calculations
    *-    - a geometry parent or group-type object to which mesh
    *-      nodes can be attached
    **
    **    The scene graph nodes created by this function should be attached
    **    to the nodes of the link to which the shape is attached.   Use the
    **    get_link() function to get a pointer to the link.
    **
    **    In addition, the scene graph objects of meshes attached to the
    **    shape should be retrieved and attached to the shape's nodes.  Use
    **    the get_mesh_at_index_for_lod() function to get pointers to the
    **    meshes.
    **
    *b  Callable From:
    **
    *-    - N/A (automatically called by DI-Guy Graphics API during
    *-      the Build Stage)
    */
   virtual void build();

   /*l
    *b  Description:
    **
    **    This function will be called by DI-Guy when it is time for the
    **    renderer-specific shape objects created during the build() call to
    **    be destroyed.
    **
    **    The unbuild() function for the shape will be called before the
    **    unbuild() function of the link to which the shape is attached.
    **
    *i  Immediate Mode:
    **
    **    Scene graph renderers can override this function, to destroy the
    **    scene graph nodes created by build().
    **
    *i  Scene Graph:
    **
    **    Scene graph renderers usually do override this function, to
    **    destroy the scene graph nodes created by build().
    **
    *b  Callable From:
    **
    *-    - N/A (automatically called by DI-Guy Graphics API during
    *-      the Unbuild Stage)
    */
   virtual void unbuild();

   /*l
    *b  Description:
    **
    **    This function will be called by DI-Guy when it is time for
    **    renderer-specific shape objects created during the build() call to
    **    be updated with new data.
    **
    **    Shape updates control whether the shape is visible based on motion
    **    data.  The DI-Guy Graphics software looks at the switch value and
    **    calls show() or hide() as appropriate, so it is likely that this
    **    function does not need to be overridden in immediate mode.
    **
    **    The update() function for the link to which a shape is attached
    **    will be called before the shape's update() function.
    **
    *i  Immediate Mode:
    **
    **    Immediate mode renderers usually do not override this function.
    **
    *i  Scene Graph:
    **
    **    Scene graph renderers should override this function if they are
    **    supporting skinned characters.  Each skinned shape can potentially
    **    have different uniforms that need to be sent to the video card; see
    **    get_shader_matrix_data().
    **
    *b  Callable From:
    **
    *-    - N/A (automatically called by DI-Guy Graphics API during
    *-      Update Stage)
    */
   virtual void update();

   /*l
    *b  Description:
    **
    **    This function will be called by DI-Guy when the shape should be
    **    shown, typically due to a change in the motion data that controls
    **    the switch.  See get_switch_var_name() and get_switch_value().
    **
    *i  Immediate Mode:
    **
    **    Immediate mode renderers usually do not override this function.
    **    DI-Guy does not call the draw() function of hidden shapes.
    **
    *i  Scene Graph:
    **
    **    Scene graph renderers usually do override this function, to update
    **    the state of the switch node created during the build() call.
    **
    *b  Callable From:
    **
    *-    - N/A (automatically called by DI-Guy Graphics API during
    *-      Update Stage)
    */
   virtual void show();

   /*l
    *b  Description:
    **
    **    This function will be called by DI-Guy when the shape should be
    **    hidden, typically due to a change in the motion data that controls
    **    the switch.  See get_switch_var_name() and get_switch_value().
    **
    *i  Immediate Mode:
    **
    **    Immediate mode renderers usually do not override this function.
    **    DI-Guy does not call the draw() function of hidden shapes.
    **
    *i  Scene Graph:
    **
    **    Scene graph renderers usually do override this function, to update
    **    the state of the switch node created during the build() call.
    **
    *b  Callable From:
    **
    *-    - N/A (automatically called by DI-Guy Graphics API during
    *-      Update Stage)
    */
   virtual void hide();


   /*l
    *b  Description:
    **
    **    This function will be called by DI-Guy when it is time for the
    **    geometry of this shape to be drawn.
    **
    *i  Immediate Mode:
    **
    **    Immediate mode renderers usually do not override this function.
    **    The actual draw calls happen in diguyGraphicsMesh::draw() calls.
    **
    *i  Scene Graph:
    **
    **    Scene graph renderers usually do not override this function;
    **    drawing is handled automatically by scene graphs.
    **
    *b  Callable From:
    **
    *-    - N/A (automatically called by DI-Guy Graphics API during
    *-      Draw Stage)
    */
   virtual void draw(int lod);

   /*l
    *b  Description:
    **
    **    This function will be called by DI-Guy when the LOD ranges of this
    **    shape need to be updated after the shape has initially been built
    **    in the Build Stage.
    **
    *b  Arguments:
    **
    *a    lod_ranges - new lod ranges for this shape
    **
    **    See diguyScenario::set_default_lod_ranges() for a description of
    **    what will be in the lod_ranges argument.
    **
    *i  Immediate Mode:
    **
    **    Immediate mode renderers usually do not override this function.
    **    Instead, they use the lod passed into the draw() function.
    **
    *i  Scene Graph:
    **
    **    Scene graph renderers can override this function, to update the
    **    ranges of LOD nodes created in the Build Stage, if any.
    **
    **    If there were LOD-type nodes created in the Build Stage, their
    **    ranges should be updated based on the passed values.
    **
    **    If no LOD-type nodes were created in the Build Stage, this
    **    function should have no effect.
    **
    **    Typically only one of set_graphics_lod_ranges() or
    **    set_graphics_lod() is implemented.
    **
    *b  Callable From:
    **
    *-    - N/A (automatically called by DI-Guy Graphics API when the
    *-      DI-Guy API function diguyCharacter::set_lod_ranges() is
    *-      called)
    */
   virtual void set_graphics_lod_ranges(float* ranges);

   /*l
    *b  Description:
    **
    **    This function will be called by DI-Guy when the LOD of this link
    **    is "manually" set by a diguyCharacter::set_graphics_lod() function
    **    call.
    **
    *i  Immediate Mode:
    **
    **    Immediate mode renderers usually do not override this function.
    **    Instead, they use the lod passed into the draw() function.
    **
    *i  Scene Graph:
    **
    **    Scene graph renderers sometimes override this function, to update
    **    the state of switch nodes created in the Build Stage.
    **
    **    Typically only one of set_graphics_lod_ranges() or
    **    set_graphics_lod() is implemented.
    **
    *b  Callable From:
    **
    *-    - N/A (automatically called by DI-Guy Graphics API when the
    *-      DI-Guy API function diguyCharacter::set_graphics_lod() is
    *-      called)
    */
   virtual void set_graphics_lod(int lod);


   /*l
    *b  Description:
    **
    **    Pushes a char * pixel buffer of length num_pixels that represents
    **    the unique per shape texture. Typically a Immediate mode renderer
    **    would need to use this to create or update a texture
    **    see diguyOglGraphicsShape.cpp for an example. For an retained mode
    **    renderer we have get_variation_texture() as an accessor.
    **
    *b  Callable From:
    **
    *-    - N/A (automatically called by DI-Guy Graphics API during
    *-      Build Stage)
    */
   virtual void update_variation_texture(int num_pixels, unsigned char * pixel_data);


   /*l
    *b  Description:
    **  creates a decal texture with a name (accessed by get_decal_text()) see sample implementation for a
    **  render to texture based implementation
    **/
   virtual void update_name_texture();


/*****************************************************************************/
   int get_decal_index() const;
   void set_decal_index(int index);

   const char* get_decal_text();

   /*l
    *b  Description:
    **
    **  Returns the unique color of the character links.  All links in a
    **  DI-Guy appearance are assigned a unique RGB color that can be used
    **  in pick/selection operations.  The data returned in color_data is
    **  an array of length num_colors with 4 floats per entry (r, g, b, a).
    **
    **  See programming_examples/diguy_graphics_api/osg_2_examples/intersection_test
    ** for an example of its usage.
    **
    *b  Returns:
    **
    **    0 on success, -1 on failure
    */
   int get_bind_color_array(int* num_colors, const float** color_data);

   /*b  Description:
    **
    **    This function will be called by DI-Guy when the the character changes
    **    instancing state. This allows additional work to be done to manage
    **    instancing. Note this hasn't been needed, for any of our sample implementations.
    */
   virtual void instancing_state_changed(int val);

#endif

#ifdef CPLUSPLUS_ONLY

   // EXPERIMENTAL
   // FIXME: Added to access quats directly instead of shader matrices
   // for Unity optimization.  [Marc 11/22/2013]
   int get_link_to_matrix_table(int* num_matrices, const float** lookup_data);

   int get_bone_index_from_link_index(int link_index);

#endif

   int get_has_offset_matrix() const;

   int get_offset_matrix_4x4_ptr(float* matrix, int transpose = 0) const;


   /*l
   *b  Description:
   **
   **    This function fills out the passed float array with the
   **    character-local-coordinate system transformation matrix of this
   **    shape, will only be different from it's parent link if it has an offset matrix.
   */
   int get_local_transformation_matrix_4x4_ptr(float* matrix, int transpose = 0) const;

   /*l
   *b  Description:
   **
   **    This function fills out the passed float array with the
   **    character-local-coordinate system transformation matrix of this
   **    shape, will only be different from it's parent link if it has an offset matrix,
   **    or complex hierarchy
   */
   int get_local_transformation_matrix_4x4_ptr( float* matrix, int lod, int transpose ) const;

   int get_bounding_box( float* bbox_min_x, float* bbox_min_y, float* bbox_min_z,
      float* bbox_max_x, float* bbox_max_y, float* bbox_max_z );


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

#ifdef CPLUSPLUS_ONLY

   bdiShape* get_scripted_object() {return m_scripted_object;}

protected:

   /*l
    **    A protected constructor.  Constructors are called automatically
    **    by DI-Guy.
    */
   diguyGraphicsShape(void* internal_data);

   /*l
    **    A protected destructor.  Destructors are called automatically
    **    by DI-Guy.
    */
   virtual ~diguyGraphicsShape();

private:

   /*l
    **    A pointer to internal data.
    */
   bdiShape* m_scripted_object;

   friend class bdiShape;
   friend class bdiGraphicsFactory;

#endif

};