diguyOsgUtil.h

Go to the documentation of this file.

/*
 *  Copyright (C) 1992-2013 Boston Dynamics
 *  ALL RIGHTS RESERVED.
 *
 *  These coded instructions, statements, and computer programs
 *  contain unpublished proprietary information of Boston Dynamics
 *  and are protected by Copyright Laws of the United States.
 *  They may not be used, duplicated, or disclosed in any form, in
 *  whole or in part, without the prior written consent from Boston
 *  Dynamics.
 *
 *  RESTRICTED RIGHTS LEGEND
 *  Use, duplication, or disclosure by the government is subject
 *  to restrictions as set forth in FAR 52.227.19(c)(2) or
 *  subparagraph (c)(1)(ii) of the Rights in Technical Data and
 *  Computer Software clause at DFARS 252.227-7013 and/or in
 *  similar or successor clauses in the FAR, or the DOD or NASA
 *  FAR Supplement, or to subparagraphs (c)(1) and (c)(2) of the
 *  Commercial Computer Software--Restricted Rights at 48 CFR
 *  52.227-19, as applicable.  Unpublished-rights reserved under
 *  the Copyright Laws of the United States.
 *  Contractor/Manufacturer is:
 *  Boston Dynamics/78 Fourth Avenue/Waltham MA 02451.
 */

/*********************************************************************
 **
 *t  diguyOsgUtil
 **
 *b  Summary:
 **
 **    The diguyOsgUtil class provides some useful functions
 **    for implementing DI-Guy Author objects.
 */

#pragma once

#include <osg/Geometry>
#include <osg/Object>
#include <osg/StateSet>

#include <diguy_constants.h>
#include <diguy_vector_classes.h>
#include <diguyAuthorVisualMaterial.h>

class diguyAuthorInterface;


/****************************************************************************/
class diguyOsgUtil
{

public:

   /*
    *  Mask flags.
    */
   enum
   {
      MASK_TERRAIN          = 0x1,
      MASK_CHARACTER        = 0x2,
      MASK_GRAPHICS_VISUALS = 0x4
   };

   /*
    *  Convenience functions for unref-ing a node.  The functions below
    *   remove the child from all parents, and then set the ref_ptr to NULL.
    *   In many cases this will bring the ref count to 0 and delete the
    *   child.
    */
    static void detachAndNull(osg::ref_ptr<osg::MatrixTransform>& child);
    static void detachAndNull(osg::ref_ptr<osg::Group>& child);
   static void detachAndNull(osg::ref_ptr<osg::Geode>& child);
   static void detachAndNull(osg::Geode* geode, osg::ref_ptr<osg::Geometry>& drawable);

   static void dumpStateSet( osg::StateSet * stateSet, const char * indent );

   /*
    *  Drawable creation functions.
    */
   static osg::Geometry* create_sphere_solid(float radius,
      int slices,
      int layers,
      const diguyVec4f & color);

   static osg::Geometry* create_sphere_wireframe(float radius,
      int slices,
      int layers,
      const diguyVec4f & color,
      float line_width,
      bool lit);

   static osg::Geometry* create_cone_solid(float radius,
      float height,
      int slices,
      int layers,
      const diguyVec3f & position_offset,
      const diguyVec3f & orientation,
      const diguyVec4f & color);

   static osg::Geometry* create_cone_wireframe(float radius,
      float height,
      int slices,
      int layers,
      const diguyVec3f & position_offset,
      const diguyVec3f & orientation,
      const diguyVec4f & color,
      float line_width,
      bool lit);

   static osg::Geometry* create_cylinder_solid(float radius,
      float height,
      int slices,
      int layers,
      const diguyVec3f & position_offset,
      const diguyVec3f & orientation,
      const diguyVec4f & color);

   static osg::Geometry* create_cylinder_wireframe(float radius,
      float height,
      int slices,
      int layers,
      const diguyVec3f & position_offset,
      const diguyVec3f & orientation,
      const diguyVec4f & color,
      float line_width,
      bool lit);

   static osg::Geometry* create_box_solid(const diguyVec3f & min,
      const diguyVec3f & max,
      const diguyVec3f & position_offset,
      const diguyVec3f & orientation,
      const diguyVec4f & color);

   static osg::Geometry* create_box_wireframe(const diguyVec3f & min,
      const diguyVec3f & max,
      const diguyVec3f & position_offset,
      const diguyVec3f & orientation,
      const diguyVec4f & color,
      float line_width,
      bool lit);

   static osg::Geometry * create_line_primitive( const osg::Vec4 & color );
   static osg::Geometry * create_coord_sys_primitive();

   static void set_name_from_uid(osg::Object* object, long uid);

   /*
    *  Material functions.
    */
   static osg::StateSet* create_material_state_set(const diguyVec4f & color, bool lit);
   static osg::StateSet* create_material_state_set(diguyAuthorVisualMaterial* visual_material);

   /*
    *  Vector conversion functions.
    */
   static osg::Vec3 diguyVec3_to_osgVec3(const diguyVec3f & diguy_vec3);
   static osg::Vec4 diguyVec4_to_osgVec4(const diguyVec4f & diguy_vec4);
   static osg::Quat diguy_euler_zxy_radians_to_osgQuat(const diguyVec3f & diguy_euler);
   static osg::Quat diguy_euler_zxy_degrees_to_osgQuat(const diguyVec3f & diguy_euler);
   static osg::Matrixd yrp_to_matrix(double yaw, double roll, double pitch);

   static diguyVec3f osgVec3_to_diguyVec3(const osg::Vec3& osg_vec3);
   static diguyVec4f osgVec4_to_diguyVec4(const osg::Vec4& osg_vec4);


      /*
    *  ...
    */
   static bool check_visual_update_flag(int update_flags, diguyAuthorVisualUpdateFlag flag)
   {
      if ((update_flags & (int) flag) != 0)
         return true;
      return false;
   }

   static bool check_visual_update_flag2(int update_flags,
      diguyAuthorVisualUpdateFlag flag1,
      diguyAuthorVisualUpdateFlag flag2)
   {
      if (((update_flags & (int) flag1) != 0) ||
         ((update_flags & (int) flag2) != 0))
         return true;
      return false;
   }

   static bool check_visual_update_flag3(int update_flags,
      diguyAuthorVisualUpdateFlag flag1,
      diguyAuthorVisualUpdateFlag flag2,
      diguyAuthorVisualUpdateFlag flag3)
   {
      if (((update_flags & (int) flag1) != 0) ||
         ((update_flags & (int) flag2) != 0) ||
         ((update_flags & (int) flag3) != 0))
         return true;
      return false;
   }

   static void raise_visual_update_flag(int& update_flags,
      diguyAuthorVisualUpdateFlag flag)
   {
      update_flags |= (int) flag;
   }
};