GsCullingVolume.h

Go to the documentation of this file.

// Copyright (C) 2002-2017, Open Design Alliance (the "Alliance"). 
// All rights reserved. 
// 
// This software and its documentation and related materials are owned by 
// the Alliance. The software may only be incorporated into application 
// programs owned by members of the Alliance, subject to a signed 
// Membership Agreement and Supplemental Software License Agreement with the
// Alliance. The structure and organization of this software are the valuable  
// trade secrets of the Alliance and its suppliers. The software is also 
// protected by copyright law and international treaty provisions. Application  
// programs incorporating this software must include the following statement 
// with their copyright notices:
//   
//   This application incorporates Teigha(R) software pursuant to a license 
//   agreement with Open Design Alliance.
//   Teigha(R) Copyright (C) 2002-2017 by Open Design Alliance. 
//   All rights reserved.
//
// By use of this software, its documentation or related materials, you 
// acknowledge and accept the above terms.
 
#ifndef _ODGSCULLINGVOLUME_H_INCLUDED_
#define _ODGSCULLINGVOLUME_H_INCLUDED_
 
#include "OdaCommon.h"
#include "RxObject.h"
#include "Gs/GsExport.h"
#include "Ge/GeBoundBlock3d.h"
#include "Ge/GeExtents3d.h"
#include "Ge/GePoint3d.h"
#include "Ge/GeSphere.h"
#include "Ge/GeVector3d.h"
 
#include "TD_PackPush.h"
 
// Culling primitives:
// BBox (AABB - Axis Aligned Bounding Box)
// BSphere (Bounding Sphere)
// OBBox (OBB - Oriented Bounding Box)
 
class GS_TOOLKIT_EXPORT OdGsCullingPrimitive
{
  public:
    enum PrimitiveType
    {
      kPrimBBox,
      kPrimBSphere,
      kPrimOBBox
    };
  public:
    OdGsCullingPrimitive()
    {
    }
 
    virtual ~OdGsCullingPrimitive()
    {
    }
 
    virtual PrimitiveType primitiveType() const = 0;
};
 
class GS_TOOLKIT_EXPORT OdGsCullingBBox : public OdGsCullingPrimitive, public OdGeExtents3d
{
  public:
    OdGsCullingBBox()
      : OdGsCullingPrimitive()
      , OdGeExtents3d()
    {
    }
 
    OdGsCullingBBox(const OdGePoint3d &min, const OdGePoint3d &max)
      : OdGsCullingPrimitive()
      , OdGeExtents3d(min, max)
    {
    }
 
    OdGsCullingBBox(const OdGeExtents3d &ext)
      : OdGsCullingPrimitive()
      , OdGeExtents3d(ext.minPoint(), ext.maxPoint())
    {
    }
 
    OdGsCullingBBox(const OdGsCullingBBox &aabb)
      : OdGsCullingPrimitive()
      , OdGeExtents3d(aabb.minPoint(), aabb.maxPoint())
    {
    }
 
    ~OdGsCullingBBox()
    {
    }
 
    OdGsCullingBBox &operator =(const OdGeExtents3d &ext)
    {
      set(ext.minPoint(), ext.maxPoint());
      return *this;
    }
 
    OdGsCullingBBox &operator =(const OdGsCullingBBox &aabb)
    {
      set(aabb.minPoint(), aabb.maxPoint());
      return *this;
    }
 
    // OdGsCullingPrimitive overrides
 
    PrimitiveType primitiveType() const
    {
      return kPrimBBox;
    }
};
 
class GS_TOOLKIT_EXPORT OdGsCullingBSphere : public OdGsCullingPrimitive, public OdGeSphere // GeSphere has many unnecessary data for culling
{
  public:
    OdGsCullingBSphere()
      : OdGsCullingPrimitive()
      , OdGeSphere()
    {
    }
 
    OdGsCullingBSphere(double radius, const OdGePoint3d &center)
      : OdGsCullingPrimitive()
      , OdGeSphere(radius, center)
    {
    }
 
    OdGsCullingBSphere(const OdGeSphere &sphere)
      : OdGsCullingPrimitive()
      , OdGeSphere(sphere)
    {
    }
 
    OdGsCullingBSphere(const OdGsCullingBSphere &bsphere)
      : OdGsCullingPrimitive()
      , OdGeSphere(bsphere)
    {
    }
 
    ~OdGsCullingBSphere()
    {
    }
 
    OdGsCullingBSphere &operator =(const OdGeSphere &sphere)
    {
      set(sphere.radius(), sphere.center());
      return *this;
    }
 
    OdGsCullingBSphere &operator =(const OdGsCullingBSphere &bsphere)
    {
      set(bsphere.radius(), bsphere.center());
      return *this;
    }
 
    // OdGsCullingPrimitive overrides
 
    PrimitiveType primitiveType() const
    {
      return kPrimBSphere;
    }
};
 
class GS_TOOLKIT_EXPORT OdGsCullingOBBox : public OdGsCullingPrimitive, public OdGeBoundBlock3d
{
  public:
    OdGsCullingOBBox()
      : OdGsCullingPrimitive()
      , OdGeBoundBlock3d()
    {
    }
 
    OdGsCullingOBBox(const OdGePoint3d &base, const OdGeVector3d &xAxis, const OdGeVector3d &yAxis, const OdGeVector3d &zAxis)
      : OdGsCullingPrimitive()
      , OdGeBoundBlock3d(base, xAxis, yAxis, zAxis)
    {
    }
 
    OdGsCullingOBBox(const OdGeBoundBlock3d &bb)
      : OdGsCullingPrimitive()
      , OdGeBoundBlock3d(bb)
    {
    }
 
    OdGsCullingOBBox(const OdGsCullingOBBox &obb)
      : OdGsCullingPrimitive()
      , OdGeBoundBlock3d(obb)
    {
    }
 
    ~OdGsCullingOBBox()
    {
    }
 
    OdGsCullingOBBox &operator =(const OdGeBoundBlock3d &bb)
    {
      OdGePoint3d base; OdGeVector3d side1, side2, side3;
      bb.get(base, side1, side2, side3);
      set(base, side1, side2, side3);
      return *this;
    }
 
    OdGsCullingOBBox &operator =(const OdGsCullingOBBox &obb)
    {
      OdGePoint3d base; OdGeVector3d side1, side2, side3;
      obb.get(base, side1, side2, side3);
      set(base, side1, side2, side3);
      return *this;
    }
 
    // OdGsCullingPrimitive overrides
 
    PrimitiveType primitiveType() const
    {
      return kPrimOBBox;
    }
};
 
// Projection culling primitives:
// Ortho (Orthogonal culling box merged with optimization for 2d mode)
// Frustum (Perspective culling box without near and far culling planes)
 
class GS_TOOLKIT_EXPORT OdGsCullingVolume : public OdRxObject
{
  public:
    enum ProjectionType
    {
      kProjOrtho,
      kProjPerspective
    };
    enum IntersectionStatus
    {
      kIntersectNot, // No intersection detected
      kIntersectOk, // Intersects with projection boundary
      kIntersectIn // Primitive completely inside projection boundary
    };
  public:
    ODRX_DECLARE_MEMBERS(OdGsCullingVolume);
 
    virtual ProjectionType projectionType() const = 0;
 
    virtual bool intersectWithOpt(const OdGsCullingPrimitive &prim) const = 0;
    virtual IntersectionStatus intersectWith(const OdGsCullingPrimitive &prim) const = 0;
 
    virtual void transformBy(const OdGeMatrix3d& xfm) = 0;
};
 
typedef OdSmartPtr<OdGsCullingVolume> OdGsCullingVolumePtr;
 
class GS_TOOLKIT_EXPORT OdGsOrthoCullingVolume : public OdGsCullingVolume
{
  public:
    ODRX_DECLARE_MEMBERS(OdGsOrthoCullingVolume);
 
    virtual void init(const OdGePoint3d &position, const OdGeVector3d &direction, const OdGeVector3d &upVector,
                      double volumeWidth, double volumeHeight) = 0;
};
 
typedef OdSmartPtr<OdGsOrthoCullingVolume> OdGsOrthoCullingVolumePtr;
 
class GS_TOOLKIT_EXPORT OdGsFrustumCullingVolume : public OdGsCullingVolume
{
  public:
    ODRX_DECLARE_MEMBERS(OdGsFrustumCullingVolume);
 
    virtual void init(const OdGePoint3d &position, const OdGeVector3d &direction, const OdGeVector3d &upVector,
                      double fovY, double aspect, OdUInt32 nPlanes = 4, double nearZ = 1.0, double farZ = 1e20) = 0;
    virtual void init(const OdGePoint3d &position, const OdGeVector3d &direction, const OdGeVector3d &upVector,
                      double fovX, bool aspect, double fovY, OdUInt32 nPlanes = 4, double nearZ = 1.0, double farZ = 1e20) = 0;
};
 
typedef OdSmartPtr<OdGsFrustumCullingVolume> OdGsFrustumCullingVolumePtr;
 
#include "TD_PackPop.h"
 
#endif // _ODGSCULLINGVOLUME_H_INCLUDED_