mirror of https://github.com/TTimo/GtkRadiant.git
1104 lines
24 KiB
C++
1104 lines
24 KiB
C++
/*
|
|
Copyright (C) 2001-2006, William Joseph.
|
|
All Rights Reserved.
|
|
|
|
This file is part of GtkRadiant.
|
|
|
|
GtkRadiant is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
GtkRadiant is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with GtkRadiant; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
|
|
#if !defined (INCLUDED_SCENELIB_H)
|
|
#define INCLUDED_SCENELIB_H
|
|
|
|
#include "iscenegraph.h"
|
|
#include "iselection.h"
|
|
|
|
#include "warnings.h"
|
|
#include <cstddef>
|
|
#include <string.h>
|
|
|
|
#include "math/aabb.h"
|
|
#include "transformlib.h"
|
|
#include "generic/callback.h"
|
|
#include "generic/reference.h"
|
|
#include "container/stack.h"
|
|
#include "typesystem.h"
|
|
|
|
class Selector;
|
|
class SelectionTest;
|
|
class VolumeTest;
|
|
template<typename Element> class BasicVector3;
|
|
typedef BasicVector3<float> Vector3;
|
|
template<typename Element> class BasicVector4;
|
|
typedef BasicVector4<float> Vector4;
|
|
class Matrix4;
|
|
typedef Vector4 Quaternion;
|
|
class AABB;
|
|
|
|
class ComponentSelectionTestable
|
|
{
|
|
public:
|
|
STRING_CONSTANT(Name, "ComponentSelectionTestable");
|
|
|
|
virtual bool isSelectedComponents() const = 0;
|
|
virtual void setSelectedComponents(bool select, SelectionSystem::EComponentMode mode) = 0;
|
|
virtual void testSelectComponents(Selector& selector, SelectionTest& test, SelectionSystem::EComponentMode mode) = 0;
|
|
};
|
|
|
|
class ComponentEditable
|
|
{
|
|
public:
|
|
STRING_CONSTANT(Name, "ComponentEditable");
|
|
|
|
virtual const AABB& getSelectedComponentsBounds() const = 0;
|
|
};
|
|
|
|
class ComponentSnappable
|
|
{
|
|
public:
|
|
STRING_CONSTANT(Name, "ComponentSnappable");
|
|
|
|
virtual void snapComponents(float snap) = 0;
|
|
};
|
|
|
|
class Bounded
|
|
{
|
|
public:
|
|
STRING_CONSTANT(Name, "Bounded");
|
|
|
|
virtual const AABB& localAABB() const = 0;
|
|
};
|
|
|
|
class BrushDoom3
|
|
{
|
|
public:
|
|
STRING_CONSTANT(Name, "BrushDoom3");
|
|
|
|
virtual void setDoom3GroupOrigin(const Vector3& origin) = 0;
|
|
};
|
|
|
|
|
|
|
|
|
|
typedef TypeCastTable<NODETYPEID_MAX> NodeTypeCastTable;
|
|
|
|
template<typename Type>
|
|
class NodeType : public StaticTypeSystemInitialiser
|
|
{
|
|
TypeId m_typeId;
|
|
public:
|
|
typedef typename Type::Name Name;
|
|
NodeType() : m_typeId(NODETYPEID_NONE)
|
|
{
|
|
StaticTypeSystemInitialiser::instance().addInitialiser(InitialiseCaller(*this));
|
|
}
|
|
void initialise()
|
|
{
|
|
m_typeId = GlobalSceneGraph().getNodeTypeId(Name());
|
|
}
|
|
typedef MemberCaller<NodeType<Type>, &NodeType<Type>::initialise> InitialiseCaller;
|
|
TypeId getTypeId()
|
|
{
|
|
#if defined(_DEBUG)
|
|
ASSERT_MESSAGE(m_typeId != NODETYPEID_NONE, "node-type " << makeQuoted(Name()) << " used before being initialised");
|
|
#endif
|
|
return m_typeId;
|
|
}
|
|
};
|
|
|
|
template<typename Type>
|
|
class StaticNodeType
|
|
{
|
|
public:
|
|
enum unnamed0 { SIZE = NODETYPEID_MAX };
|
|
static TypeId getTypeId()
|
|
{
|
|
return Static< NodeType<Type> >::instance().getTypeId();
|
|
}
|
|
};
|
|
|
|
template<typename Type, typename Base>
|
|
class NodeStaticCast :
|
|
public CastInstaller<
|
|
StaticNodeType<Base>,
|
|
StaticCast<Type, Base>
|
|
>
|
|
{
|
|
};
|
|
|
|
template<typename Type, typename Contained>
|
|
class NodeContainedCast :
|
|
public CastInstaller<
|
|
StaticNodeType<Contained>,
|
|
ContainedCast<Type, Contained>
|
|
>
|
|
{
|
|
};
|
|
|
|
template<typename Type>
|
|
class NodeIdentityCast :
|
|
public CastInstaller<
|
|
StaticNodeType<Type>,
|
|
IdentityCast<Type>
|
|
>
|
|
{
|
|
};
|
|
|
|
namespace scene
|
|
{
|
|
class Node
|
|
{
|
|
public:
|
|
enum unnamed0 { eVisible = 0 };
|
|
enum unnamed1 { eHidden = 1 << 0 };
|
|
enum unnamed2 { eFiltered = 1 << 1 };
|
|
enum unnamed3 { eExcluded = 1 << 2 };
|
|
|
|
class Symbiot
|
|
{
|
|
public:
|
|
virtual void release() = 0;
|
|
};
|
|
|
|
private:
|
|
unsigned int m_state;
|
|
std::size_t m_refcount;
|
|
Symbiot* m_symbiot;
|
|
void* m_node;
|
|
NodeTypeCastTable& m_casts;
|
|
|
|
public:
|
|
bool m_isRoot;
|
|
|
|
bool isRoot()
|
|
{
|
|
return m_isRoot;
|
|
}
|
|
|
|
Node(Symbiot* symbiot, void* node, NodeTypeCastTable& casts) :
|
|
m_state(eVisible),
|
|
m_refcount(0),
|
|
m_symbiot(symbiot),
|
|
m_node(node),
|
|
m_casts(casts),
|
|
m_isRoot(false)
|
|
{
|
|
}
|
|
~Node()
|
|
{
|
|
}
|
|
|
|
void IncRef()
|
|
{
|
|
ASSERT_MESSAGE(m_refcount < (1 << 24), "Node::decref: uninitialised refcount");
|
|
++m_refcount;
|
|
}
|
|
void DecRef()
|
|
{
|
|
ASSERT_MESSAGE(m_refcount < (1 << 24), "Node::decref: uninitialised refcount");
|
|
if(--m_refcount == 0)
|
|
{
|
|
m_symbiot->release();
|
|
}
|
|
}
|
|
std::size_t getReferenceCount() const
|
|
{
|
|
return m_refcount;
|
|
}
|
|
|
|
void* cast(TypeId typeId) const
|
|
{
|
|
return m_casts.cast(typeId, m_node);
|
|
}
|
|
|
|
void enable(unsigned int state)
|
|
{
|
|
m_state |= state;
|
|
}
|
|
void disable(unsigned int state)
|
|
{
|
|
m_state &= ~state;
|
|
}
|
|
bool visible()
|
|
{
|
|
return m_state == eVisible;
|
|
}
|
|
bool excluded()
|
|
{
|
|
return (m_state & eExcluded) != 0;
|
|
}
|
|
};
|
|
|
|
class NullNode : public Node::Symbiot
|
|
{
|
|
NodeTypeCastTable m_casts;
|
|
Node m_node;
|
|
public:
|
|
NullNode() : m_node(this, 0, m_casts)
|
|
{
|
|
}
|
|
void release()
|
|
{
|
|
delete this;
|
|
}
|
|
scene::Node& node()
|
|
{
|
|
return m_node;
|
|
}
|
|
};
|
|
}
|
|
|
|
template<typename Type>
|
|
class NodeTypeCast
|
|
{
|
|
public:
|
|
static Type* cast(scene::Node& node)
|
|
{
|
|
return static_cast<Type*>(node.cast(StaticNodeType<Type>::getTypeId()));
|
|
}
|
|
static const Type* cast(const scene::Node& node)
|
|
{
|
|
return static_cast<const Type*>(node.cast(StaticNodeType<Type>::getTypeId()));
|
|
}
|
|
};
|
|
|
|
|
|
inline scene::Instantiable* Node_getInstantiable(scene::Node& node)
|
|
{
|
|
return NodeTypeCast<scene::Instantiable>::cast(node);
|
|
}
|
|
|
|
inline scene::Traversable* Node_getTraversable(scene::Node& node)
|
|
{
|
|
return NodeTypeCast<scene::Traversable>::cast(node);
|
|
}
|
|
|
|
inline void Node_traverseSubgraph(scene::Node& node, const scene::Traversable::Walker& walker)
|
|
{
|
|
if(walker.pre(node))
|
|
{
|
|
scene::Traversable* traversable = Node_getTraversable(node);
|
|
if(traversable != 0)
|
|
{
|
|
traversable->traverse(walker);
|
|
}
|
|
}
|
|
walker.post(node);
|
|
}
|
|
|
|
inline TransformNode* Node_getTransformNode(scene::Node& node)
|
|
{
|
|
return NodeTypeCast<TransformNode>::cast(node);
|
|
}
|
|
|
|
inline bool operator<(scene::Node& node, scene::Node& other)
|
|
{
|
|
return &node < &other;
|
|
}
|
|
inline bool operator==(scene::Node& node, scene::Node& other)
|
|
{
|
|
return &node == &other;
|
|
}
|
|
inline bool operator!=(scene::Node& node, scene::Node& other)
|
|
{
|
|
return !::operator==(node, other);
|
|
}
|
|
|
|
|
|
inline scene::Node& NewNullNode()
|
|
{
|
|
return (new scene::NullNode)->node();
|
|
}
|
|
|
|
inline void Path_deleteTop(const scene::Path& path)
|
|
{
|
|
Node_getTraversable(path.parent())->erase(path.top());
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
class delete_all : public scene::Traversable::Walker
|
|
{
|
|
scene::Node& m_parent;
|
|
public:
|
|
delete_all(scene::Node& parent) : m_parent(parent)
|
|
{
|
|
}
|
|
bool pre(scene::Node& node) const
|
|
{
|
|
return false;
|
|
}
|
|
void post(scene::Node& node) const
|
|
{
|
|
Node_getTraversable(m_parent)->erase(node);
|
|
}
|
|
};
|
|
|
|
inline void DeleteSubgraph(scene::Node& subgraph)
|
|
{
|
|
Node_getTraversable(subgraph)->traverse(delete_all(subgraph));
|
|
}
|
|
|
|
|
|
class EntityUndefined
|
|
{
|
|
public:
|
|
STRING_CONSTANT(Name, "Entity");
|
|
};
|
|
|
|
inline bool Node_isEntity(scene::Node& node)
|
|
{
|
|
return NodeTypeCast<EntityUndefined>::cast(node) != 0;
|
|
}
|
|
|
|
template<typename Functor>
|
|
class EntityWalker : public scene::Graph::Walker
|
|
{
|
|
const Functor& functor;
|
|
public:
|
|
EntityWalker(const Functor& functor) : functor(functor)
|
|
{
|
|
}
|
|
bool pre(const scene::Path& path, scene::Instance& instance) const
|
|
{
|
|
if(Node_isEntity(path.top()))
|
|
{
|
|
functor(instance);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
};
|
|
|
|
template<typename Functor>
|
|
inline const Functor& Scene_forEachEntity(const Functor& functor)
|
|
{
|
|
GlobalSceneGraph().traverse(EntityWalker<Functor>(functor));
|
|
return functor;
|
|
}
|
|
|
|
class BrushUndefined
|
|
{
|
|
public:
|
|
STRING_CONSTANT(Name, "Brush");
|
|
};
|
|
|
|
inline bool Node_isBrush(scene::Node& node)
|
|
{
|
|
return NodeTypeCast<BrushUndefined>::cast(node) != 0;
|
|
}
|
|
|
|
class PatchUndefined
|
|
{
|
|
public:
|
|
STRING_CONSTANT(Name, "Patch");
|
|
};
|
|
|
|
inline bool Node_isPatch(scene::Node& node)
|
|
{
|
|
return NodeTypeCast<PatchUndefined>::cast(node) != 0;
|
|
}
|
|
|
|
inline bool Node_isPrimitive(scene::Node& node)
|
|
{
|
|
#if 1
|
|
return Node_isBrush(node) || Node_isPatch(node);
|
|
#else
|
|
return !node.isRoot();
|
|
#endif
|
|
}
|
|
|
|
class ParentBrushes : public scene::Traversable::Walker
|
|
{
|
|
scene::Node& m_parent;
|
|
public:
|
|
ParentBrushes(scene::Node& parent)
|
|
: m_parent(parent)
|
|
{
|
|
}
|
|
bool pre(scene::Node& node) const
|
|
{
|
|
return false;
|
|
}
|
|
void post(scene::Node& node) const
|
|
{
|
|
if(Node_isPrimitive(node))
|
|
{
|
|
Node_getTraversable(m_parent)->insert(node);
|
|
}
|
|
}
|
|
};
|
|
|
|
inline void parentBrushes(scene::Node& subgraph, scene::Node& parent)
|
|
{
|
|
Node_getTraversable(subgraph)->traverse(ParentBrushes(parent));
|
|
}
|
|
|
|
class HasBrushes : public scene::Traversable::Walker
|
|
{
|
|
bool& m_hasBrushes;
|
|
public:
|
|
HasBrushes(bool& hasBrushes)
|
|
: m_hasBrushes(hasBrushes)
|
|
{
|
|
m_hasBrushes = true;
|
|
}
|
|
bool pre(scene::Node& node) const
|
|
{
|
|
if(!Node_isPrimitive(node))
|
|
{
|
|
m_hasBrushes = false;
|
|
}
|
|
return false;
|
|
}
|
|
};
|
|
|
|
inline bool node_is_group(scene::Node& node)
|
|
{
|
|
scene::Traversable* traversable = Node_getTraversable(node);
|
|
if(traversable != 0)
|
|
{
|
|
bool hasBrushes = false;
|
|
traversable->traverse(HasBrushes(hasBrushes));
|
|
return hasBrushes;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
typedef TypeCastTable<INSTANCETYPEID_MAX> InstanceTypeCastTable;
|
|
|
|
template<typename Type>
|
|
class InstanceType : public StaticTypeSystemInitialiser
|
|
{
|
|
TypeId m_typeId;
|
|
public:
|
|
typedef typename Type::Name Name;
|
|
InstanceType() : m_typeId(INSTANCETYPEID_NONE)
|
|
{
|
|
StaticTypeSystemInitialiser::instance().addInitialiser(InitialiseCaller(*this));
|
|
}
|
|
void initialise()
|
|
{
|
|
m_typeId = GlobalSceneGraph().getInstanceTypeId(Name());
|
|
}
|
|
typedef MemberCaller<InstanceType<Type>, &InstanceType<Type>::initialise> InitialiseCaller;
|
|
TypeId getTypeId()
|
|
{
|
|
#if defined(_DEBUG)
|
|
ASSERT_MESSAGE(m_typeId != INSTANCETYPEID_NONE, "instance-type " << makeQuoted(Name()) << " used before being initialised");
|
|
#endif
|
|
return m_typeId;
|
|
}
|
|
};
|
|
|
|
template<typename Type>
|
|
class StaticInstanceType
|
|
{
|
|
public:
|
|
enum unnamed0 { SIZE = INSTANCETYPEID_MAX };
|
|
static TypeId getTypeId()
|
|
{
|
|
return Static< InstanceType<Type> >::instance().getTypeId();
|
|
}
|
|
};
|
|
|
|
template<typename Type, typename Base>
|
|
class InstanceStaticCast :
|
|
public CastInstaller<
|
|
StaticInstanceType<Base>,
|
|
StaticCast<Type, Base>
|
|
>
|
|
{
|
|
};
|
|
|
|
template<typename Type, typename Contained>
|
|
class InstanceContainedCast :
|
|
public CastInstaller<
|
|
StaticInstanceType<Contained>,
|
|
ContainedCast<Type, Contained>
|
|
>
|
|
{
|
|
};
|
|
|
|
template<typename Type>
|
|
class InstanceIdentityCast :
|
|
public CastInstaller<
|
|
StaticInstanceType<Type>,
|
|
IdentityCast<Type>
|
|
>
|
|
{
|
|
};
|
|
|
|
|
|
inline Selectable* Instance_getSelectable(scene::Instance& instance);
|
|
inline const Selectable* Instance_getSelectable(const scene::Instance& instance);
|
|
|
|
inline Bounded* Instance_getBounded(scene::Instance& instance);
|
|
inline const Bounded* Instance_getBounded(const scene::Instance& instance);
|
|
|
|
namespace scene
|
|
{
|
|
class Instance
|
|
{
|
|
class AABBAccumulateWalker : public scene::Graph::Walker
|
|
{
|
|
AABB& m_aabb;
|
|
mutable std::size_t m_depth;
|
|
public:
|
|
AABBAccumulateWalker(AABB& aabb) : m_aabb(aabb), m_depth(0)
|
|
{
|
|
}
|
|
bool pre(const scene::Path& path, scene::Instance& instance) const
|
|
{
|
|
if(m_depth == 1)
|
|
{
|
|
aabb_extend_by_aabb_safe(m_aabb, instance.worldAABB());
|
|
}
|
|
return ++m_depth != 2;
|
|
}
|
|
void post(const scene::Path& path, scene::Instance& instance) const
|
|
{
|
|
--m_depth;
|
|
}
|
|
};
|
|
|
|
|
|
class TransformChangedWalker : public scene::Graph::Walker
|
|
{
|
|
public:
|
|
bool pre(const scene::Path& path, scene::Instance& instance) const
|
|
{
|
|
instance.transformChangedLocal();
|
|
return true;
|
|
}
|
|
};
|
|
|
|
class ParentSelectedChangedWalker : public scene::Graph::Walker
|
|
{
|
|
public:
|
|
bool pre(const scene::Path& path, scene::Instance& instance) const
|
|
{
|
|
instance.parentSelectedChanged();
|
|
return true;
|
|
}
|
|
};
|
|
|
|
class ChildSelectedWalker : public scene::Graph::Walker
|
|
{
|
|
bool& m_childSelected;
|
|
mutable std::size_t m_depth;
|
|
public:
|
|
ChildSelectedWalker(bool& childSelected) : m_childSelected(childSelected), m_depth(0)
|
|
{
|
|
m_childSelected = false;
|
|
}
|
|
bool pre(const scene::Path& path, scene::Instance& instance) const
|
|
{
|
|
if(m_depth == 1 && !m_childSelected)
|
|
{
|
|
m_childSelected = instance.isSelected() || instance.childSelected();
|
|
}
|
|
return ++m_depth != 2;
|
|
}
|
|
void post(const scene::Path& path, scene::Instance& instance) const
|
|
{
|
|
--m_depth;
|
|
}
|
|
};
|
|
|
|
Path m_path;
|
|
Instance* m_parent;
|
|
void* m_instance;
|
|
InstanceTypeCastTable& m_casts;
|
|
|
|
mutable Matrix4 m_local2world;
|
|
mutable AABB m_bounds;
|
|
mutable AABB m_childBounds;
|
|
mutable bool m_transformChanged;
|
|
mutable bool m_transformMutex;
|
|
mutable bool m_boundsChanged;
|
|
mutable bool m_boundsMutex;
|
|
mutable bool m_childBoundsChanged;
|
|
mutable bool m_childBoundsMutex;
|
|
mutable bool m_isSelected;
|
|
mutable bool m_isSelectedChanged;
|
|
mutable bool m_childSelected;
|
|
mutable bool m_childSelectedChanged;
|
|
mutable bool m_parentSelected;
|
|
mutable bool m_parentSelectedChanged;
|
|
Callback m_childSelectedChangedCallback;
|
|
Callback m_transformChangedCallback;
|
|
|
|
|
|
void evaluateTransform() const
|
|
{
|
|
if(m_transformChanged)
|
|
{
|
|
ASSERT_MESSAGE(!m_transformMutex, "re-entering transform evaluation");
|
|
m_transformMutex = true;
|
|
|
|
m_local2world = (m_parent != 0) ? m_parent->localToWorld() : g_matrix4_identity;
|
|
TransformNode* transformNode = Node_getTransformNode(m_path.top());
|
|
if(transformNode != 0)
|
|
{
|
|
matrix4_multiply_by_matrix4(m_local2world, transformNode->localToParent());
|
|
}
|
|
|
|
m_transformMutex = false;
|
|
m_transformChanged = false;
|
|
}
|
|
}
|
|
void evaluateChildBounds() const
|
|
{
|
|
if(m_childBoundsChanged)
|
|
{
|
|
ASSERT_MESSAGE(!m_childBoundsMutex, "re-entering bounds evaluation");
|
|
m_childBoundsMutex = true;
|
|
|
|
m_childBounds = AABB();
|
|
|
|
GlobalSceneGraph().traverse_subgraph(AABBAccumulateWalker(m_childBounds), m_path);
|
|
|
|
m_childBoundsMutex = false;
|
|
m_childBoundsChanged = false;
|
|
}
|
|
}
|
|
void evaluateBounds() const
|
|
{
|
|
if(m_boundsChanged)
|
|
{
|
|
ASSERT_MESSAGE(!m_boundsMutex, "re-entering bounds evaluation");
|
|
m_boundsMutex = true;
|
|
|
|
m_bounds = childBounds();
|
|
|
|
const Bounded* bounded = Instance_getBounded(*this);
|
|
if(bounded != 0)
|
|
{
|
|
aabb_extend_by_aabb_safe(
|
|
m_bounds,
|
|
aabb_for_oriented_aabb_safe(bounded->localAABB(), localToWorld())
|
|
);
|
|
}
|
|
|
|
m_boundsMutex = false;
|
|
m_boundsChanged = false;
|
|
}
|
|
}
|
|
|
|
Instance(const scene::Instance& other);
|
|
Instance& operator=(const scene::Instance& other);
|
|
public:
|
|
|
|
Instance(const scene::Path& path, Instance* parent, void* instance, InstanceTypeCastTable& casts) :
|
|
m_path(path),
|
|
m_parent(parent),
|
|
m_instance(instance),
|
|
m_casts(casts),
|
|
m_local2world(g_matrix4_identity),
|
|
m_transformChanged(true),
|
|
m_transformMutex(false),
|
|
m_boundsChanged(true),
|
|
m_boundsMutex(false),
|
|
m_childBoundsChanged(true),
|
|
m_childBoundsMutex(false),
|
|
m_isSelectedChanged(true),
|
|
m_childSelectedChanged(true),
|
|
m_parentSelectedChanged(true)
|
|
{
|
|
ASSERT_MESSAGE((parent == 0) == (path.size() == 1), "instance has invalid parent");
|
|
}
|
|
virtual ~Instance()
|
|
{
|
|
}
|
|
|
|
const scene::Path& path() const
|
|
{
|
|
return m_path;
|
|
}
|
|
|
|
void* cast(TypeId typeId) const
|
|
{
|
|
return m_casts.cast(typeId, m_instance);
|
|
}
|
|
|
|
const Matrix4& localToWorld() const
|
|
{
|
|
evaluateTransform();
|
|
return m_local2world;
|
|
}
|
|
void transformChangedLocal()
|
|
{
|
|
ASSERT_NOTNULL(m_parent);
|
|
m_transformChanged = true;
|
|
m_boundsChanged = true;
|
|
m_childBoundsChanged = true;
|
|
m_transformChangedCallback();
|
|
}
|
|
void transformChanged()
|
|
{
|
|
GlobalSceneGraph().traverse_subgraph(TransformChangedWalker(), m_path);
|
|
boundsChanged();
|
|
}
|
|
void setTransformChangedCallback(const Callback& callback)
|
|
{
|
|
m_transformChangedCallback = callback;
|
|
}
|
|
|
|
|
|
const AABB& worldAABB() const
|
|
{
|
|
evaluateBounds();
|
|
return m_bounds;
|
|
}
|
|
const AABB& childBounds() const
|
|
{
|
|
evaluateChildBounds();
|
|
return m_childBounds;
|
|
}
|
|
void boundsChanged()
|
|
{
|
|
m_boundsChanged = true;
|
|
m_childBoundsChanged = true;
|
|
if(m_parent != 0)
|
|
{
|
|
m_parent->boundsChanged();
|
|
}
|
|
GlobalSceneGraph().boundsChanged();
|
|
}
|
|
|
|
void childSelectedChanged()
|
|
{
|
|
m_childSelectedChanged = true;
|
|
m_childSelectedChangedCallback();
|
|
if(m_parent != 0)
|
|
{
|
|
m_parent->childSelectedChanged();
|
|
}
|
|
}
|
|
bool childSelected() const
|
|
{
|
|
if(m_childSelectedChanged)
|
|
{
|
|
m_childSelectedChanged = false;
|
|
GlobalSceneGraph().traverse_subgraph(ChildSelectedWalker(m_childSelected), m_path);
|
|
}
|
|
return m_childSelected;
|
|
}
|
|
|
|
void setChildSelectedChangedCallback(const Callback& callback)
|
|
{
|
|
m_childSelectedChangedCallback = callback;
|
|
}
|
|
void selectedChanged()
|
|
{
|
|
m_isSelectedChanged = true;
|
|
if(m_parent != 0)
|
|
{
|
|
m_parent->childSelectedChanged();
|
|
}
|
|
GlobalSceneGraph().traverse_subgraph(ParentSelectedChangedWalker(), m_path);
|
|
}
|
|
bool isSelected() const
|
|
{
|
|
if(m_isSelectedChanged)
|
|
{
|
|
m_isSelectedChanged = false;
|
|
const Selectable* selectable = Instance_getSelectable(*this);
|
|
m_isSelected = selectable != 0 && selectable->isSelected();
|
|
}
|
|
return m_isSelected;
|
|
}
|
|
|
|
void parentSelectedChanged()
|
|
{
|
|
m_parentSelectedChanged = true;
|
|
}
|
|
bool parentSelected() const
|
|
{
|
|
if(m_parentSelectedChanged)
|
|
{
|
|
m_parentSelectedChanged = false;
|
|
m_parentSelected = m_parent != 0 && (m_parent->isSelected() || m_parent->parentSelected());
|
|
}
|
|
return m_parentSelected;
|
|
}
|
|
};
|
|
}
|
|
|
|
template<typename Type>
|
|
class InstanceTypeCast
|
|
{
|
|
public:
|
|
static Type* cast(scene::Instance& instance)
|
|
{
|
|
return static_cast<Type*>(instance.cast(StaticInstanceType<Type>::getTypeId()));
|
|
}
|
|
static const Type* cast(const scene::Instance& instance)
|
|
{
|
|
return static_cast<const Type*>(instance.cast(StaticInstanceType<Type>::getTypeId()));
|
|
}
|
|
};
|
|
|
|
template<typename Functor>
|
|
class InstanceWalker : public scene::Graph::Walker
|
|
{
|
|
const Functor& m_functor;
|
|
public:
|
|
InstanceWalker(const Functor& functor) : m_functor(functor)
|
|
{
|
|
}
|
|
bool pre(const scene::Path& path, scene::Instance& instance) const
|
|
{
|
|
m_functor(instance);
|
|
return true;
|
|
}
|
|
};
|
|
|
|
template<typename Functor>
|
|
class ChildInstanceWalker : public scene::Graph::Walker
|
|
{
|
|
const Functor& m_functor;
|
|
mutable std::size_t m_depth;
|
|
public:
|
|
ChildInstanceWalker(const Functor& functor) : m_functor(functor), m_depth(0)
|
|
{
|
|
}
|
|
bool pre(const scene::Path& path, scene::Instance& instance) const
|
|
{
|
|
if(m_depth == 1)
|
|
{
|
|
m_functor(instance);
|
|
}
|
|
return ++m_depth != 2;
|
|
}
|
|
void post(const scene::Path& path, scene::Instance& instance) const
|
|
{
|
|
--m_depth;
|
|
}
|
|
};
|
|
|
|
template<typename Type, typename Functor>
|
|
class InstanceApply : public Functor
|
|
{
|
|
public:
|
|
InstanceApply(const Functor& functor) : Functor(functor)
|
|
{
|
|
}
|
|
void operator()(scene::Instance& instance) const
|
|
{
|
|
Type* result = InstanceTypeCast<Type>::cast(instance);
|
|
if(result != 0)
|
|
{
|
|
Functor::operator()(*result);
|
|
}
|
|
}
|
|
};
|
|
|
|
inline Selectable* Instance_getSelectable(scene::Instance& instance)
|
|
{
|
|
return InstanceTypeCast<Selectable>::cast(instance);
|
|
}
|
|
inline const Selectable* Instance_getSelectable(const scene::Instance& instance)
|
|
{
|
|
return InstanceTypeCast<Selectable>::cast(instance);
|
|
}
|
|
|
|
template<typename Functor>
|
|
inline void Scene_forEachChildSelectable(const Functor& functor, const scene::Path& path)
|
|
{
|
|
GlobalSceneGraph().traverse_subgraph(ChildInstanceWalker< InstanceApply<Selectable, Functor> >(functor), path);
|
|
}
|
|
|
|
class SelectableSetSelected
|
|
{
|
|
bool m_selected;
|
|
public:
|
|
SelectableSetSelected(bool selected) : m_selected(selected)
|
|
{
|
|
}
|
|
void operator()(Selectable& selectable) const
|
|
{
|
|
selectable.setSelected(m_selected);
|
|
}
|
|
};
|
|
|
|
inline Bounded* Instance_getBounded(scene::Instance& instance)
|
|
{
|
|
return InstanceTypeCast<Bounded>::cast(instance);
|
|
}
|
|
inline const Bounded* Instance_getBounded(const scene::Instance& instance)
|
|
{
|
|
return InstanceTypeCast<Bounded>::cast(instance);
|
|
}
|
|
|
|
inline Transformable* Instance_getTransformable(scene::Instance& instance)
|
|
{
|
|
return InstanceTypeCast<Transformable>::cast(instance);
|
|
}
|
|
inline const Transformable* Instance_getTransformable(const scene::Instance& instance)
|
|
{
|
|
return InstanceTypeCast<Transformable>::cast(instance);
|
|
}
|
|
|
|
|
|
inline ComponentSelectionTestable* Instance_getComponentSelectionTestable(scene::Instance& instance)
|
|
{
|
|
return InstanceTypeCast<ComponentSelectionTestable>::cast(instance);
|
|
}
|
|
|
|
inline ComponentEditable* Instance_getComponentEditable(scene::Instance& instance)
|
|
{
|
|
return InstanceTypeCast<ComponentEditable>::cast(instance);
|
|
}
|
|
|
|
inline ComponentSnappable* Instance_getComponentSnappable(scene::Instance& instance)
|
|
{
|
|
return InstanceTypeCast<ComponentSnappable>::cast(instance);
|
|
}
|
|
|
|
|
|
inline void Instance_setSelected(scene::Instance& instance, bool selected)
|
|
{
|
|
Selectable* selectable = Instance_getSelectable(instance);
|
|
if(selectable != 0)
|
|
{
|
|
selectable->setSelected(selected);
|
|
}
|
|
}
|
|
|
|
inline bool Instance_isSelected(scene::Instance& instance)
|
|
{
|
|
Selectable* selectable = Instance_getSelectable(instance);
|
|
if(selectable != 0)
|
|
{
|
|
return selectable->isSelected();
|
|
}
|
|
return false;
|
|
}
|
|
|
|
inline scene::Instance& findInstance(const scene::Path& path)
|
|
{
|
|
scene::Instance* instance = GlobalSceneGraph().find(path);
|
|
ASSERT_MESSAGE(instance != 0, "findInstance: path not found in scene-graph");
|
|
return *instance;
|
|
}
|
|
|
|
inline void selectPath(const scene::Path& path, bool selected)
|
|
{
|
|
Instance_setSelected(findInstance(path), selected);
|
|
}
|
|
|
|
class SelectChildren : public scene::Traversable::Walker
|
|
{
|
|
mutable scene::Path m_path;
|
|
public:
|
|
SelectChildren(const scene::Path& root)
|
|
: m_path(root)
|
|
{
|
|
}
|
|
bool pre(scene::Node& node) const
|
|
{
|
|
m_path.push(makeReference(node));
|
|
selectPath(m_path, true);
|
|
return false;
|
|
}
|
|
void post(scene::Node& node) const
|
|
{
|
|
m_path.pop();
|
|
}
|
|
};
|
|
|
|
inline void Entity_setSelected(scene::Instance& entity, bool selected)
|
|
{
|
|
scene::Node& node = entity.path().top();
|
|
if(node_is_group(node))
|
|
{
|
|
Node_getTraversable(node)->traverse(SelectChildren(entity.path()));
|
|
}
|
|
else
|
|
{
|
|
Instance_setSelected(entity, selected);
|
|
}
|
|
}
|
|
|
|
inline bool Entity_isSelected(scene::Instance& entity)
|
|
{
|
|
if(node_is_group(entity.path().top()))
|
|
{
|
|
return entity.childSelected();
|
|
}
|
|
return Instance_isSelected(entity);
|
|
}
|
|
|
|
|
|
|
|
class InstanceCounter
|
|
{
|
|
public:
|
|
unsigned int m_count;
|
|
InstanceCounter() : m_count(0)
|
|
{
|
|
}
|
|
};
|
|
|
|
|
|
class Counter
|
|
{
|
|
public:
|
|
virtual void increment() = 0;
|
|
virtual void decrement() = 0;
|
|
};
|
|
|
|
#include "generic/callback.h"
|
|
|
|
class SimpleCounter : public Counter
|
|
{
|
|
Callback m_countChanged;
|
|
std::size_t m_count;
|
|
public:
|
|
void setCountChangedCallback(const Callback& countChanged)
|
|
{
|
|
m_countChanged = countChanged;
|
|
}
|
|
void increment()
|
|
{
|
|
++m_count;
|
|
m_countChanged();
|
|
}
|
|
void decrement()
|
|
{
|
|
--m_count;
|
|
m_countChanged();
|
|
}
|
|
std::size_t get() const
|
|
{
|
|
return m_count;
|
|
}
|
|
};
|
|
|
|
|
|
template<typename Contained>
|
|
class ConstReference;
|
|
typedef ConstReference<scene::Path> PathConstReference;
|
|
|
|
#include "generic/referencecounted.h"
|
|
typedef SmartReference<scene::Node, IncRefDecRefCounter<scene::Node> > NodeSmartReference;
|
|
|
|
|
|
#endif
|