277 lines
7 KiB
C++
277 lines
7 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_SELECTABLE_H )
|
|
#define INCLUDED_SELECTABLE_H
|
|
|
|
#include <cstddef>
|
|
|
|
#include "generic/vector.h"
|
|
#include "scenelib.h"
|
|
#include "generic/callback.h"
|
|
|
|
class SelectionIntersection
|
|
{
|
|
float m_depth;
|
|
float m_distance;
|
|
public:
|
|
SelectionIntersection() : m_depth( 1 ), m_distance( 2 ){
|
|
}
|
|
SelectionIntersection( float depth, float distance ) : m_depth( depth ), m_distance( distance ){
|
|
}
|
|
bool operator<( const SelectionIntersection& other ) const {
|
|
if ( m_distance != other.m_distance ) {
|
|
return m_distance < other.m_distance;
|
|
}
|
|
if ( m_depth != other.m_depth ) {
|
|
return m_depth < other.m_depth;
|
|
}
|
|
return false;
|
|
}
|
|
bool equalEpsilon( const SelectionIntersection& other, float distanceEpsilon, float depthEpsilon ) const {
|
|
return float_equal_epsilon( m_distance, other.m_distance, distanceEpsilon )
|
|
&& float_equal_epsilon( m_depth, other.m_depth, depthEpsilon );
|
|
}
|
|
float depth() const {
|
|
return m_depth;
|
|
}
|
|
bool valid() const {
|
|
return depth() < 1;
|
|
}
|
|
};
|
|
|
|
// returns true if self is closer than other
|
|
inline bool SelectionIntersection_closer( const SelectionIntersection& self, const SelectionIntersection& other ){
|
|
return self < other;
|
|
}
|
|
|
|
// assigns other to best if other is closer than best
|
|
inline void assign_if_closer( SelectionIntersection& best, const SelectionIntersection& other ){
|
|
if ( SelectionIntersection_closer( other, best ) ) {
|
|
best = other;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
class VertexPointer
|
|
{
|
|
typedef const unsigned char* byte_pointer;
|
|
public:
|
|
typedef float elem_type;
|
|
typedef const elem_type* pointer;
|
|
typedef const elem_type& reference;
|
|
|
|
class iterator
|
|
{
|
|
public:
|
|
iterator() {
|
|
}
|
|
iterator( byte_pointer vertices, std::size_t stride )
|
|
: m_iter( vertices ), m_stride( stride ) {
|
|
}
|
|
|
|
bool operator==( const iterator& other ) const {
|
|
return m_iter == other.m_iter;
|
|
}
|
|
bool operator!=( const iterator& other ) const {
|
|
return !operator==( other );
|
|
}
|
|
|
|
iterator operator+( std::size_t i ){
|
|
return iterator( m_iter + i * m_stride, m_stride );
|
|
}
|
|
iterator operator+=( std::size_t i ){
|
|
m_iter += i * m_stride;
|
|
return *this;
|
|
}
|
|
iterator& operator++(){
|
|
m_iter += m_stride;
|
|
return *this;
|
|
}
|
|
iterator operator++( int ){
|
|
iterator tmp = *this;
|
|
m_iter += m_stride;
|
|
return tmp;
|
|
}
|
|
reference operator*() const {
|
|
return *reinterpret_cast<pointer>( m_iter );
|
|
}
|
|
private:
|
|
byte_pointer m_iter;
|
|
std::size_t m_stride;
|
|
};
|
|
|
|
VertexPointer( pointer vertices, std::size_t stride )
|
|
: m_vertices( reinterpret_cast<byte_pointer>( vertices ) ), m_stride( stride ) {
|
|
}
|
|
|
|
iterator begin() const {
|
|
return iterator( m_vertices, m_stride );
|
|
}
|
|
|
|
reference operator[]( std::size_t i ) const {
|
|
return *reinterpret_cast<pointer>( m_vertices + m_stride * i );
|
|
}
|
|
|
|
private:
|
|
byte_pointer m_vertices;
|
|
std::size_t m_stride;
|
|
};
|
|
|
|
class IndexPointer
|
|
{
|
|
public:
|
|
typedef unsigned int index_type;
|
|
typedef const index_type* pointer;
|
|
|
|
class iterator
|
|
{
|
|
public:
|
|
iterator( pointer iter ) : m_iter( iter ) {
|
|
}
|
|
|
|
bool operator==( const iterator& other ) const {
|
|
return m_iter == other.m_iter;
|
|
}
|
|
bool operator!=( const iterator& other ) const {
|
|
return !operator==( other );
|
|
}
|
|
|
|
iterator operator+( std::size_t i ){
|
|
return m_iter + i;
|
|
}
|
|
iterator operator+=( std::size_t i ){
|
|
return m_iter += i;
|
|
}
|
|
iterator operator++(){
|
|
return ++m_iter;
|
|
}
|
|
iterator operator++( int ){
|
|
return m_iter++;
|
|
}
|
|
const index_type& operator*() const {
|
|
return *m_iter;
|
|
}
|
|
private:
|
|
void increment(){
|
|
++m_iter;
|
|
}
|
|
pointer m_iter;
|
|
};
|
|
|
|
IndexPointer( pointer indices, std::size_t count )
|
|
: m_indices( indices ), m_finish( indices + count ) {
|
|
}
|
|
|
|
iterator begin() const {
|
|
return m_indices;
|
|
}
|
|
iterator end() const {
|
|
return m_finish;
|
|
}
|
|
|
|
private:
|
|
pointer m_indices;
|
|
pointer m_finish;
|
|
};
|
|
|
|
template<typename Element> class BasicVector3;
|
|
typedef BasicVector3<float> Vector3;
|
|
class Matrix4;
|
|
class VolumeTest;
|
|
|
|
class SelectionTest
|
|
{
|
|
public:
|
|
virtual void BeginMesh( const Matrix4& localToWorld, bool twoSided = false ) = 0;
|
|
virtual const VolumeTest& getVolume() const = 0;
|
|
virtual const Vector3& getNear() const = 0;
|
|
virtual const Vector3& getFar() const = 0;
|
|
virtual void TestPoint( const Vector3& point, SelectionIntersection& best ) = 0;
|
|
virtual void TestPolygon( const VertexPointer& vertices, std::size_t count, SelectionIntersection& best ) = 0;
|
|
virtual void TestLineLoop( const VertexPointer& vertices, std::size_t count, SelectionIntersection& best ) = 0;
|
|
virtual void TestLineStrip( const VertexPointer& vertices, std::size_t count, SelectionIntersection& best ) = 0;
|
|
virtual void TestLines( const VertexPointer& vertices, std::size_t count, SelectionIntersection& best ) = 0;
|
|
virtual void TestTriangles( const VertexPointer& vertices, const IndexPointer& indices, SelectionIntersection& best ) = 0;
|
|
virtual void TestQuads( const VertexPointer& vertices, const IndexPointer& indices, SelectionIntersection& best ) = 0;
|
|
virtual void TestQuadStrip( const VertexPointer& vertices, const IndexPointer& indices, SelectionIntersection& best ) = 0;
|
|
};
|
|
|
|
class Selectable;
|
|
|
|
class Selector
|
|
{
|
|
public:
|
|
virtual void pushSelectable( Selectable& selectable ) = 0;
|
|
virtual void popSelectable() = 0;
|
|
virtual void addIntersection( const SelectionIntersection& intersection ) = 0;
|
|
};
|
|
|
|
inline void Selector_add( Selector& selector, Selectable& selectable ){
|
|
selector.pushSelectable( selectable );
|
|
selector.addIntersection( SelectionIntersection( 0, 0 ) );
|
|
selector.popSelectable();
|
|
}
|
|
|
|
inline void Selector_add( Selector& selector, Selectable& selectable, const SelectionIntersection& intersection ){
|
|
selector.pushSelectable( selectable );
|
|
selector.addIntersection( intersection );
|
|
selector.popSelectable();
|
|
}
|
|
|
|
|
|
class VolumeTest;
|
|
class SelectionTestable
|
|
{
|
|
public:
|
|
STRING_CONSTANT( Name, "SelectionTestable" );
|
|
|
|
virtual void testSelect( Selector& selector, SelectionTest& test ) = 0;
|
|
};
|
|
|
|
inline SelectionTestable* Instance_getSelectionTestable( scene::Instance& instance ){
|
|
return InstanceTypeCast<SelectionTestable>::cast( instance );
|
|
}
|
|
|
|
|
|
class Plane3;
|
|
typedef Callback<void (const Plane3&)> PlaneCallback;
|
|
|
|
class SelectedPlanes
|
|
{
|
|
public:
|
|
virtual bool contains( const Plane3& plane ) const = 0;
|
|
};
|
|
|
|
class PlaneSelectable
|
|
{
|
|
public:
|
|
STRING_CONSTANT( Name, "PlaneSelectable" );
|
|
|
|
virtual void selectPlanes( Selector& selector, SelectionTest& test, const PlaneCallback& selectedPlaneCallback ) = 0;
|
|
virtual void selectReversedPlanes( Selector& selector, const SelectedPlanes& selectedPlanes ) = 0;
|
|
};
|
|
|
|
|
|
|
|
#endif
|