/usr/include/libwildmagic/Wm5Culler.h is in libwildmagic-dev 5.13-1ubuntu3.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 | // Geometric Tools, LLC
// Copyright (c) 1998-2014
// Distributed under the Boost Software License, Version 1.0.
// http://www.boost.org/LICENSE_1_0.txt
// http://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
//
// File Version: 5.0.1 (2010/10/01)
#ifndef WM5CULLER_H
#define WM5CULLER_H
#include "Wm5GraphicsLIB.h"
#include "Wm5Camera.h"
#include "Wm5Spatial.h"
#include "Wm5VisibleSet.h"
namespace Wm5
{
class WM5_GRAPHICS_ITEM Culler
{
public:
// Construction and destruction. Culling requires a camera model. If the
// camera is not passed to the constructor, you should set it using
// SetCamera before calling ComputeVisibleSet.
Culler (const Camera* camera = 0);
virtual ~Culler ();
// Access to the camera, frustum copy, and potentially visible set.
inline void SetCamera (const Camera* camera);
inline const Camera* GetCamera () const;
void SetFrustum (const float* frustum);
inline const float* GetFrustum () const;
inline VisibleSet& GetVisibleSet ();
// The base class behavior is to append the visible object to the end of
// the visible set (stored as an array). Derived classes may override
// this behavior; for example, the array might be maintained as a sorted
// array for minimizing render state changes or it might be/ maintained
// as a unique list of objects for a portal system.
virtual void Insert (Spatial* visible);
// Access to the stack of world culling planes. You may push and pop
// planes to be used in addition to the view frustum planes. PushPlane
// requires the input plane to be in world coordinates. See the comments
// before data member mPlaneState about the bit system for enabling and
// disabling planes during culling.
enum { MAX_PLANE_QUANTITY = 32 };
inline int GetPlaneQuantity () const;
inline const HPlane* GetPlanes () const;
inline void SetPlaneState (unsigned int planeState);
inline unsigned int GetPlaneState () const;
inline void PushPlane (const HPlane& plane);
inline void PopPlane ();
// Compare the object's world bound against the culling planes. Only
// Spatial calls this function.
bool IsVisible (const Bound& bound);
// Support for Portal::GetVisibleSet.
bool IsVisible (int numVertices, const APoint* vertices,
bool ignoreNearPlane);
// Support for BspNode::GetVisibleSet. Determine whether the view frustum
// is fully on one side of a plane. The "positive side" of the plane is
// the half space to which the plane normal points. The "negative side"
// is the other half space. The function returns +1 if the view frustum
// is fully on the positive side of the plane, -1 if the view frustum is
// fully on the negative side of the plane, or 0 if the view frustum
// straddles the plane. The input plane is in world coordinates and the
// world camera coordinate system is used for the test.
int WhichSide (const HPlane& plane) const;
// This is the main function you should use for culling within a scene
// graph. Traverse the scene graph and construct the potentially visible
// set relative to the world planes.
void ComputeVisibleSet (Spatial* scene);
protected:
// The input camera has information that might be needed during the
// culling pass over the scene.
const Camera* mCamera;
// A copy of the view frustum for the input camera. This allows various
// subsystems to change the frustum parameters during culling (for
// example, the portal system) without affecting the camera, whose initial
// state is needed by the renderer.
float mFrustum[Camera::VF_QUANTITY];
// The world culling planes corresponding to the view frustum plus any
// additional user-defined culling planes. The member m_uiPlaneState
// represents bit flags to store whether or not a plane is active in the
// culling system. A bit of 1 means the plane is active, otherwise the
// plane is inactive. An active plane is compared to bounding volumes,
// whereas an inactive plane is not. This supports an efficient culling
// of a hierarchy. For example, if a node's bounding volume is inside
// the left plane of the view frustum, then the left plane is set to
// inactive because the children of the node are automatically all inside
// the left plane.
int mPlaneQuantity;
HPlane mPlane[MAX_PLANE_QUANTITY];
unsigned int mPlaneState;
// The potentially visible set for a call to GetVisibleSet.
VisibleSet mVisibleSet;
};
#include "Wm5Culler.inl"
}
#endif
|