/*
-Copyright (C) 2001-2006, William Joseph.
-All Rights Reserved.
+ Copyright (C) 2001-2006, William Joseph.
+ All Rights Reserved.
-This file is part of GtkRadiant.
+ 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 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.
+ 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
-*/
+ 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
+ */
#include "selection.h"
+#include "globaldefs.h"
#include "debugging/debugging.h"
#include "grid.h"
-TextOutputStream& ostream_write(TextOutputStream& t, const Vector4& v)
+TextOutputStream &ostream_write(TextOutputStream &t, const Vector4 &v)
{
- return t << "[ " << v.x() << " " << v.y() << " " << v.z() << " " << v.w() << " ]";
+ return t << "[ " << v.x() << " " << v.y() << " " << v.z() << " " << v.w() << " ]";
}
-TextOutputStream& ostream_write(TextOutputStream& t, const Matrix4& m)
+TextOutputStream &ostream_write(TextOutputStream &t, const Matrix4 &m)
{
- return t << "[ " << m.x() << " " << m.y() << " " << m.z() << " " << m.t() << " ]";
+ return t << "[ " << m.x() << " " << m.y() << " " << m.z() << " " << m.t() << " ]";
}
-struct Pivot2World
-{
- Matrix4 m_worldSpace;
- Matrix4 m_viewpointSpace;
- Matrix4 m_viewplaneSpace;
- Vector3 m_axis_screen;
-
- void update(const Matrix4& pivot2world, const Matrix4& modelview, const Matrix4& projection, const Matrix4& viewport)
- {
- Pivot2World_worldSpace(m_worldSpace, pivot2world, modelview, projection, viewport);
- Pivot2World_viewpointSpace(m_viewpointSpace, m_axis_screen, pivot2world, modelview, projection, viewport);
- Pivot2World_viewplaneSpace(m_viewplaneSpace, pivot2world, modelview, projection, viewport);
- }
+struct Pivot2World {
+ Matrix4 m_worldSpace;
+ Matrix4 m_viewpointSpace;
+ Matrix4 m_viewplaneSpace;
+ Vector3 m_axis_screen;
+
+ void
+ update(const Matrix4 &pivot2world, const Matrix4 &modelview, const Matrix4 &projection, const Matrix4 &viewport)
+ {
+ Pivot2World_worldSpace(m_worldSpace, pivot2world, modelview, projection, viewport);
+ Pivot2World_viewpointSpace(m_viewpointSpace, m_axis_screen, pivot2world, modelview, projection, viewport);
+ Pivot2World_viewplaneSpace(m_viewplaneSpace, pivot2world, modelview, projection, viewport);
+ }
};
-void point_for_device_point(Vector3& point, const Matrix4& device2object, const float x, const float y, const float z)
+void point_for_device_point(Vector3 &point, const Matrix4 &device2object, const float x, const float y, const float z)
{
- // transform from normalised device coords to object coords
- point = vector4_projected(matrix4_transformed_vector4(device2object, Vector4(x, y, z, 1)));
+ // transform from normalised device coords to object coords
+ point = vector4_projected(matrix4_transformed_vector4(device2object, Vector4(x, y, z, 1)));
}
-void ray_for_device_point(Ray& ray, const Matrix4& device2object, const float x, const float y)
+void ray_for_device_point(Ray &ray, const Matrix4 &device2object, const float x, const float y)
{
// point at x, y, zNear
- point_for_device_point(ray.origin, device2object, x, y, -1);
+ point_for_device_point(ray.origin, device2object, x, y, -1);
- // point at x, y, zFar
- point_for_device_point(ray.direction, device2object, x, y, 1);
+ // point at x, y, zFar
+ point_for_device_point(ray.direction, device2object, x, y, 1);
- // construct ray
- vector3_subtract(ray.direction, ray.origin);
- vector3_normalise(ray.direction);
+ // construct ray
+ vector3_subtract(ray.direction, ray.origin);
+ vector3_normalise(ray.direction);
}
-bool sphere_intersect_ray(const Vector3& origin, float radius, const Ray& ray, Vector3& intersection)
+bool sphere_intersect_ray(const Vector3 &origin, float radius, const Ray &ray, Vector3 &intersection)
{
- intersection = vector3_subtracted(origin, ray.origin);
- const double a = vector3_dot(intersection, ray.direction);
- const double d = radius * radius - (vector3_dot(intersection, intersection) - a * a);
-
- if(d > 0)
- {
- intersection = vector3_added(ray.origin, vector3_scaled(ray.direction, a - sqrt(d)));
- return true;
- }
- else
- {
- intersection = vector3_added( ray.origin, vector3_scaled(ray.direction, a));
- return false;
- }
+ intersection = vector3_subtracted(origin, ray.origin);
+ const double a = vector3_dot(intersection, ray.direction);
+ const double d = radius * radius - (vector3_dot(intersection, intersection) - a * a);
+
+ if (d > 0) {
+ intersection = vector3_added(ray.origin, vector3_scaled(ray.direction, a - sqrt(d)));
+ return true;
+ } else {
+ intersection = vector3_added(ray.origin, vector3_scaled(ray.direction, a));
+ return false;
+ }
}
-void ray_intersect_ray(const Ray& ray, const Ray& other, Vector3& intersection)
+void ray_intersect_ray(const Ray &ray, const Ray &other, Vector3 &intersection)
{
- intersection = vector3_subtracted(ray.origin, other.origin);
- //float a = 1;//vector3_dot(ray.direction, ray.direction); // always >= 0
- double dot = vector3_dot(ray.direction, other.direction);
- //float c = 1;//vector3_dot(other.direction, other.direction); // always >= 0
- double d = vector3_dot(ray.direction, intersection);
- double e = vector3_dot(other.direction, intersection);
- double D = 1 - dot*dot;//a*c - dot*dot; // always >= 0
-
- if (D < 0.000001)
- {
- // the lines are almost parallel
- intersection = vector3_added(other.origin, vector3_scaled(other.direction, e));
- }
- else
- {
- intersection = vector3_added(other.origin, vector3_scaled(other.direction, (e - dot*d) / D));
- }
+ intersection = vector3_subtracted(ray.origin, other.origin);
+ //float a = 1;//vector3_dot(ray.direction, ray.direction); // always >= 0
+ double dot = vector3_dot(ray.direction, other.direction);
+ //float c = 1;//vector3_dot(other.direction, other.direction); // always >= 0
+ double d = vector3_dot(ray.direction, intersection);
+ double e = vector3_dot(other.direction, intersection);
+ double D = 1 - dot * dot; //a*c - dot*dot; // always >= 0
+
+ if (D < 0.000001) {
+ // the lines are almost parallel
+ intersection = vector3_added(other.origin, vector3_scaled(other.direction, e));
+ } else {
+ intersection = vector3_added(other.origin, vector3_scaled(other.direction, (e - dot * d) / D));
+ }
}
const Vector3 g_origin(0, 0, 0);
const float g_radius = 64;
-void point_on_sphere(Vector3& point, const Matrix4& device2object, const float x, const float y)
+void point_on_sphere(Vector3 &point, const Matrix4 &device2object, const float x, const float y)
{
- Ray ray;
- ray_for_device_point(ray, device2object, x, y);
- sphere_intersect_ray(g_origin, g_radius, ray, point);
+ Ray ray;
+ ray_for_device_point(ray, device2object, x, y);
+ sphere_intersect_ray(g_origin, g_radius, ray, point);
}
-void point_on_axis(Vector3& point, const Vector3& axis, const Matrix4& device2object, const float x, const float y)
+void point_on_axis(Vector3 &point, const Vector3 &axis, const Matrix4 &device2object, const float x, const float y)
{
- Ray ray;
- ray_for_device_point(ray, device2object, x, y);
- ray_intersect_ray(ray, Ray(Vector3(0, 0, 0), axis), point);
+ Ray ray;
+ ray_for_device_point(ray, device2object, x, y);
+ ray_intersect_ray(ray, Ray(Vector3(0, 0, 0), axis), point);
}
-void point_on_plane(Vector3& point, const Matrix4& device2object, const float x, const float y)
+void point_on_plane(Vector3 &point, const Matrix4 &device2object, const float x, const float y)
{
- Matrix4 object2device(matrix4_full_inverse(device2object));
- point = vector4_projected(matrix4_transformed_vector4(device2object, Vector4(x, y, object2device[14] / object2device[15], 1)));
+ Matrix4 object2device(matrix4_full_inverse(device2object));
+ point = vector4_projected(
+ matrix4_transformed_vector4(device2object, Vector4(x, y, object2device[14] / object2device[15], 1)));
}
//! a and b are unit vectors .. returns angle in radians
-inline float angle_between(const Vector3& a, const Vector3& b)
+inline float angle_between(const Vector3 &a, const Vector3 &b)
{
- return static_cast<float>(2.0 * atan2(
- vector3_length(vector3_subtracted(a, b)),
- vector3_length(vector3_added(a, b))
- ));
+ return static_cast<float>( 2.0 * atan2(
+ vector3_length(vector3_subtracted(a, b)),
+ vector3_length(vector3_added(a, b))
+ ));
}
-#if defined(_DEBUG)
-class test_quat
-{
+#if GDEF_DEBUG
+
+class test_quat {
public:
- test_quat(const Vector3& from, const Vector3& to)
- {
- Vector4 quaternion(quaternion_for_unit_vectors(from, to));
- Matrix4 matrix(matrix4_rotation_for_quaternion(quaternion_multiplied_by_quaternion(quaternion, c_quaternion_identity)));
- }
+ test_quat(const Vector3 &from, const Vector3 &to)
+ {
+ Vector4 quaternion(quaternion_for_unit_vectors(from, to));
+ Matrix4 matrix(matrix4_rotation_for_quaternion(
+ quaternion_multiplied_by_quaternion(quaternion, c_quaternion_identity)));
+ }
+
private:
};
#endif
//! axis is a unit vector
-inline void constrain_to_axis(Vector3& vec, const Vector3& axis)
+inline void constrain_to_axis(Vector3 &vec, const Vector3 &axis)
{
- vec = vector3_normalised(vector3_added(vec, vector3_scaled(axis, -vector3_dot(vec, axis))));
+ vec = vector3_normalised(vector3_added(vec, vector3_scaled(axis, -vector3_dot(vec, axis))));
}
//! a and b are unit vectors .. a and b must be orthogonal to axis .. returns angle in radians
-float angle_for_axis(const Vector3& a, const Vector3& b, const Vector3& axis)
+float angle_for_axis(const Vector3 &a, const Vector3 &b, const Vector3 &axis)
{
- if(vector3_dot(axis, vector3_cross(a, b)) > 0.0)
- return angle_between(a, b);
- else
- return -angle_between(a, b);
+ if (vector3_dot(axis, vector3_cross(a, b)) > 0.0) {
+ return angle_between(a, b);
+ } else {
+ return -angle_between(a, b);
+ }
}
-float distance_for_axis(const Vector3& a, const Vector3& b, const Vector3& axis)
+float distance_for_axis(const Vector3 &a, const Vector3 &b, const Vector3 &axis)
{
- return static_cast<float>(vector3_dot(b, axis) - vector3_dot(a, axis));
+ return static_cast<float>( vector3_dot(b, axis) - vector3_dot(a, axis));
}
-class Manipulatable
-{
+class Manipulatable {
public:
- virtual void Construct(const Matrix4& device2manip, const float x, const float y) = 0;
- virtual void Transform(const Matrix4& manip2object, const Matrix4& device2manip, const float x, const float y) = 0;
+ virtual void Construct(const Matrix4 &device2manip, const float x, const float y) = 0;
+
+ virtual void Transform(const Matrix4 &manip2object, const Matrix4 &device2manip, const float x, const float y) = 0;
};
-void transform_local2object(Matrix4& object, const Matrix4& local, const Matrix4& local2object)
+void transform_local2object(Matrix4 &object, const Matrix4 &local, const Matrix4 &local2object)
{
- object = matrix4_multiplied_by_matrix4(
- matrix4_multiplied_by_matrix4(local2object, local),
- matrix4_full_inverse(local2object)
- );
+ object = matrix4_multiplied_by_matrix4(
+ matrix4_multiplied_by_matrix4(local2object, local),
+ matrix4_full_inverse(local2object)
+ );
}
-class Rotatable
-{
+class Rotatable {
public:
- virtual void rotate(const Quaternion& rotation) = 0;
+ virtual ~Rotatable() = default;
+
+ virtual void rotate(const Quaternion &rotation) = 0;
};
-class RotateFree : public Manipulatable
-{
- Vector3 m_start;
- Rotatable& m_rotatable;
+class RotateFree : public Manipulatable {
+ Vector3 m_start;
+ Rotatable &m_rotatable;
public:
- RotateFree(Rotatable& rotatable)
- : m_rotatable(rotatable)
- {
- }
- void Construct(const Matrix4& device2manip, const float x, const float y)
- {
- point_on_sphere(m_start, device2manip, x, y);
- vector3_normalise(m_start);
- }
- void Transform(const Matrix4& manip2object, const Matrix4& device2manip, const float x, const float y)
- {
- Vector3 current;
-
- point_on_sphere(current, device2manip, x, y);
- vector3_normalise(current);
-
- m_rotatable.rotate(quaternion_for_unit_vectors(m_start, current));
- }
+ RotateFree(Rotatable &rotatable)
+ : m_rotatable(rotatable)
+ {
+ }
+
+ void Construct(const Matrix4 &device2manip, const float x, const float y)
+ {
+ point_on_sphere(m_start, device2manip, x, y);
+ vector3_normalise(m_start);
+ }
+
+ void Transform(const Matrix4 &manip2object, const Matrix4 &device2manip, const float x, const float y)
+ {
+ Vector3 current;
+
+ point_on_sphere(current, device2manip, x, y);
+ vector3_normalise(current);
+
+ m_rotatable.rotate(quaternion_for_unit_vectors(m_start, current));
+ }
};
-class RotateAxis : public Manipulatable
-{
- Vector3 m_axis;
- Vector3 m_start;
- Rotatable& m_rotatable;
+class RotateAxis : public Manipulatable {
+ Vector3 m_axis;
+ Vector3 m_start;
+ Rotatable &m_rotatable;
public:
- RotateAxis(Rotatable& rotatable)
- : m_rotatable(rotatable)
- {
- }
- void Construct(const Matrix4& device2manip, const float x, const float y)
- {
- point_on_sphere(m_start, device2manip, x, y);
- constrain_to_axis(m_start, m_axis);
- }
- /// \brief Converts current position to a normalised vector orthogonal to axis.
- void Transform(const Matrix4& manip2object, const Matrix4& device2manip, const float x, const float y)
- {
- Vector3 current;
- point_on_sphere(current, device2manip, x, y);
- constrain_to_axis(current, m_axis);
-
- m_rotatable.rotate(quaternion_for_axisangle(m_axis, angle_for_axis(m_start, current, m_axis)));
- }
-
- void SetAxis(const Vector3& axis)
- {
- m_axis = axis;
- }
+ RotateAxis(Rotatable &rotatable)
+ : m_rotatable(rotatable)
+ {
+ }
+
+ void Construct(const Matrix4 &device2manip, const float x, const float y)
+ {
+ point_on_sphere(m_start, device2manip, x, y);
+ constrain_to_axis(m_start, m_axis);
+ }
+
+/// \brief Converts current position to a normalised vector orthogonal to axis.
+ void Transform(const Matrix4 &manip2object, const Matrix4 &device2manip, const float x, const float y)
+ {
+ Vector3 current;
+ point_on_sphere(current, device2manip, x, y);
+ constrain_to_axis(current, m_axis);
+
+ m_rotatable.rotate(quaternion_for_axisangle(m_axis, angle_for_axis(m_start, current, m_axis)));
+ }
+
+ void SetAxis(const Vector3 &axis)
+ {
+ m_axis = axis;
+ }
};
-void translation_local2object(Vector3& object, const Vector3& local, const Matrix4& local2object)
+void translation_local2object(Vector3 &object, const Vector3 &local, const Matrix4 &local2object)
{
- object = matrix4_get_translation_vec3(
- matrix4_multiplied_by_matrix4(
- matrix4_translated_by_vec3(local2object, local),
- matrix4_full_inverse(local2object)
- )
- );
+ object = matrix4_get_translation_vec3(
+ matrix4_multiplied_by_matrix4(
+ matrix4_translated_by_vec3(local2object, local),
+ matrix4_full_inverse(local2object)
+ )
+ );
}
-class Translatable
-{
+class Translatable {
public:
- virtual void translate(const Vector3& translation) = 0;
+ virtual ~Translatable() = default;
+
+ virtual void translate(const Vector3 &translation) = 0;
};
-class TranslateAxis : public Manipulatable
-{
- Vector3 m_start;
- Vector3 m_axis;
- Translatable& m_translatable;
+class TranslateAxis : public Manipulatable {
+ Vector3 m_start;
+ Vector3 m_axis;
+ Translatable &m_translatable;
public:
- TranslateAxis(Translatable& translatable)
- : m_translatable(translatable)
- {
- }
- void Construct(const Matrix4& device2manip, const float x, const float y)
- {
- point_on_axis(m_start, m_axis, device2manip, x, y);
- }
- void Transform(const Matrix4& manip2object, const Matrix4& device2manip, const float x, const float y)
- {
- Vector3 current;
- point_on_axis(current, m_axis, device2manip, x, y);
- current = vector3_scaled(m_axis, distance_for_axis(m_start, current, m_axis));
-
- translation_local2object(current, current, manip2object);
- vector3_snap(current, GetGridSize());
-
- m_translatable.translate(current);
- }
-
- void SetAxis(const Vector3& axis)
- {
- m_axis = axis;
- }
+ TranslateAxis(Translatable &translatable)
+ : m_translatable(translatable)
+ {
+ }
+
+ void Construct(const Matrix4 &device2manip, const float x, const float y)
+ {
+ point_on_axis(m_start, m_axis, device2manip, x, y);
+ }
+
+ void Transform(const Matrix4 &manip2object, const Matrix4 &device2manip, const float x, const float y)
+ {
+ Vector3 current;
+ point_on_axis(current, m_axis, device2manip, x, y);
+ current = vector3_scaled(m_axis, distance_for_axis(m_start, current, m_axis));
+
+ translation_local2object(current, current, manip2object);
+ vector3_snap(current, GetSnapGridSize());
+
+ m_translatable.translate(current);
+ }
+
+ void SetAxis(const Vector3 &axis)
+ {
+ m_axis = axis;
+ }
};
-class TranslateFree : public Manipulatable
-{
+class TranslateFree : public Manipulatable {
private:
- Vector3 m_start;
- Translatable& m_translatable;
+ Vector3 m_start;
+ Translatable &m_translatable;
public:
- TranslateFree(Translatable& translatable)
- : m_translatable(translatable)
- {
- }
- void Construct(const Matrix4& device2manip, const float x, const float y)
- {
- point_on_plane(m_start, device2manip, x, y);
- }
- void Transform(const Matrix4& manip2object, const Matrix4& device2manip, const float x, const float y)
- {
- Vector3 current;
- point_on_plane(current, device2manip, x, y);
- current = vector3_subtracted(current, m_start);
-
- translation_local2object(current, current, manip2object);
- vector3_snap(current, GetGridSize());
-
- m_translatable.translate(current);
- }
-};
+ TranslateFree(Translatable &translatable)
+ : m_translatable(translatable)
+ {
+ }
+ void Construct(const Matrix4 &device2manip, const float x, const float y)
+ {
+ point_on_plane(m_start, device2manip, x, y);
+ }
-class Scalable
-{
-public:
- virtual void scale(const Vector3& scaling) = 0;
+ void Transform(const Matrix4 &manip2object, const Matrix4 &device2manip, const float x, const float y)
+ {
+ Vector3 current;
+ point_on_plane(current, device2manip, x, y);
+ current = vector3_subtracted(current, m_start);
+
+ translation_local2object(current, current, manip2object);
+ vector3_snap(current, GetSnapGridSize());
+
+ m_translatable.translate(current);
+ }
};
-class ScaleAxis : public Manipulatable
-{
-private:
- Vector3 m_start;
- Vector3 m_axis;
- Scalable& m_scalable;
+class Scalable {
public:
- ScaleAxis(Scalable& scalable)
- : m_scalable(scalable)
- {
- }
- void Construct(const Matrix4& device2manip, const float x, const float y)
- {
- point_on_axis(m_start, m_axis, device2manip, x, y);
- }
- void Transform(const Matrix4& manip2object, const Matrix4& device2manip, const float x, const float y)
- {
- Vector3 current;
- point_on_axis(current, m_axis, device2manip, x, y);
- Vector3 delta = vector3_subtracted(current, m_start);
-
- translation_local2object(delta, delta, manip2object);
- vector3_snap(delta, GetGridSize());
-
- Vector3 start(vector3_snapped(m_start, GetGridSize()));
- Vector3 scale(
- start[0] == 0 ? 1 : 1 + delta[0] / start[0],
- start[1] == 0 ? 1 : 1 + delta[1] / start[1],
- start[2] == 0 ? 1 : 1 + delta[2] / start[2]
- );
- m_scalable.scale(scale);
- }
+ virtual ~Scalable() = default;
- void SetAxis(const Vector3& axis)
- {
- m_axis = axis;
- }
+ virtual void scale(const Vector3 &scaling) = 0;
};
-class ScaleFree : public Manipulatable
-{
+
+class ScaleAxis : public Manipulatable {
private:
- Vector3 m_start;
- Scalable& m_scalable;
+ Vector3 m_start;
+ Vector3 m_axis;
+ Scalable &m_scalable;
public:
- ScaleFree(Scalable& scalable)
- : m_scalable(scalable)
- {
- }
- void Construct(const Matrix4& device2manip, const float x, const float y)
- {
- point_on_plane(m_start, device2manip, x, y);
- }
- void Transform(const Matrix4& manip2object, const Matrix4& device2manip, const float x, const float y)
- {
- Vector3 current;
- point_on_plane(current, device2manip, x, y);
- Vector3 delta = vector3_subtracted(current, m_start);
-
- translation_local2object(delta, delta, manip2object);
- vector3_snap(delta, GetGridSize());
-
- Vector3 start(vector3_snapped(m_start, GetGridSize()));
- Vector3 scale(
- start[0] == 0 ? 1 : 1 + delta[0] / start[0],
- start[1] == 0 ? 1 : 1 + delta[1] / start[1],
- start[2] == 0 ? 1 : 1 + delta[2] / start[2]
- );
- m_scalable.scale(scale);
- }
-};
+ ScaleAxis(Scalable &scalable)
+ : m_scalable(scalable)
+ {
+ }
+ void Construct(const Matrix4 &device2manip, const float x, const float y)
+ {
+ point_on_axis(m_start, m_axis, device2manip, x, y);
+ }
+ void Transform(const Matrix4 &manip2object, const Matrix4 &device2manip, const float x, const float y)
+ {
+ Vector3 current;
+ point_on_axis(current, m_axis, device2manip, x, y);
+ Vector3 delta = vector3_subtracted(current, m_start);
+ translation_local2object(delta, delta, manip2object);
+ vector3_snap(delta, GetSnapGridSize());
+ Vector3 start(vector3_snapped(m_start, GetSnapGridSize()));
+ Vector3 scale(
+ start[0] == 0 ? 1 : 1 + delta[0] / start[0],
+ start[1] == 0 ? 1 : 1 + delta[1] / start[1],
+ start[2] == 0 ? 1 : 1 + delta[2] / start[2]
+ );
+ m_scalable.scale(scale);
+ }
+ void SetAxis(const Vector3 &axis)
+ {
+ m_axis = axis;
+ }
+};
+class ScaleFree : public Manipulatable {
+private:
+ Vector3 m_start;
+ Scalable &m_scalable;
+public:
+ ScaleFree(Scalable &scalable)
+ : m_scalable(scalable)
+ {
+ }
+ void Construct(const Matrix4 &device2manip, const float x, const float y)
+ {
+ point_on_plane(m_start, device2manip, x, y);
+ }
+ void Transform(const Matrix4 &manip2object, const Matrix4 &device2manip, const float x, const float y)
+ {
+ Vector3 current;
+ point_on_plane(current, device2manip, x, y);
+ Vector3 delta = vector3_subtracted(current, m_start);
+ translation_local2object(delta, delta, manip2object);
+ vector3_snap(delta, GetSnapGridSize());
-class RenderableClippedPrimitive : public OpenGLRenderable
-{
- struct primitive_t
- {
- PointVertex m_points[9];
- std::size_t m_count;
- };
- Matrix4 m_inverse;
- std::vector<primitive_t> m_primitives;
+ Vector3 start(vector3_snapped(m_start, GetSnapGridSize()));
+ Vector3 scale(
+ start[0] == 0 ? 1 : 1 + delta[0] / start[0],
+ start[1] == 0 ? 1 : 1 + delta[1] / start[1],
+ start[2] == 0 ? 1 : 1 + delta[2] / start[2]
+ );
+ m_scalable.scale(scale);
+ }
+};
+
+
+class RenderableClippedPrimitive : public OpenGLRenderable {
+ struct primitive_t {
+ PointVertex m_points[9];
+ std::size_t m_count;
+ };
+ Matrix4 m_inverse;
+ std::vector<primitive_t> m_primitives;
public:
- Matrix4 m_world;
+ Matrix4 m_world;
+
+ void render(RenderStateFlags state) const
+ {
+ for (std::size_t i = 0; i < m_primitives.size(); ++i) {
+ glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(PointVertex), &m_primitives[i].m_points[0].colour);
+ glVertexPointer(3, GL_FLOAT, sizeof(PointVertex), &m_primitives[i].m_points[0].vertex);
+ switch (m_primitives[i].m_count) {
+ case 1:
+ break;
+ case 2:
+ glDrawArrays(GL_LINES, 0, GLsizei(m_primitives[i].m_count));
+ break;
+ default:
+ glDrawArrays(GL_POLYGON, 0, GLsizei(m_primitives[i].m_count));
+ break;
+ }
+ }
+ }
- void render(RenderStateFlags state) const
- {
- for(std::size_t i=0; i<m_primitives.size(); ++i)
+ void construct(const Matrix4 &world2device)
{
- glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(PointVertex), &m_primitives[i].m_points[0].colour);
- glVertexPointer(3, GL_FLOAT, sizeof(PointVertex), &m_primitives[i].m_points[0].vertex);
- switch(m_primitives[i].m_count)
- {
- case 1: break;
- case 2: glDrawArrays(GL_LINES, 0, GLsizei(m_primitives[i].m_count)); break;
- default: glDrawArrays(GL_POLYGON, 0, GLsizei(m_primitives[i].m_count)); break;
- }
+ m_inverse = matrix4_full_inverse(world2device);
+ m_world = g_matrix4_identity;
}
- }
- void construct(const Matrix4& world2device)
- {
- m_inverse = matrix4_full_inverse(world2device);
- m_world = g_matrix4_identity;
- }
+ void insert(const Vector4 clipped[9], std::size_t count)
+ {
+ add_one();
- void insert(const Vector4 clipped[9], std::size_t count)
- {
- add_one();
+ m_primitives.back().m_count = count;
+ for (std::size_t i = 0; i < count; ++i) {
+ Vector3 world_point(vector4_projected(matrix4_transformed_vector4(m_inverse, clipped[i])));
+ m_primitives.back().m_points[i].vertex = vertex3f_for_vector3(world_point);
+ }
+ }
- m_primitives.back().m_count = count;
- for(std::size_t i=0; i<count; ++i)
+ void destroy()
{
- Vector3 world_point(vector4_projected(matrix4_transformed_vector4(m_inverse, clipped[i])));
- m_primitives.back().m_points[i].vertex = vertex3f_for_vector3(world_point);
+ m_primitives.clear();
}
- }
- void destroy()
- {
- m_primitives.clear();
- }
private:
- void add_one()
- {
- m_primitives.push_back(primitive_t());
+ void add_one()
+ {
+ m_primitives.push_back(primitive_t());
- const Colour4b colour_clipped(255, 127, 0, 255);
+ const Colour4b colour_clipped(255, 127, 0, 255);
- for(std::size_t i=0; i<9; ++i)
- m_primitives.back().m_points[i].colour = colour_clipped;
- }
+ for (std::size_t i = 0; i < 9; ++i) {
+ m_primitives.back().m_points[i].colour = colour_clipped;
+ }
+ }
};
-#if defined(_DEBUG)
+#if GDEF_DEBUG
#define DEBUG_SELECTION
#endif
-#if defined(DEBUG_SELECTION)
-Shader* g_state_clipped;
+#if defined( DEBUG_SELECTION )
+Shader *g_state_clipped;
RenderableClippedPrimitive g_render_clipped;
#endif
#if 0
-// dist_Point_to_Line(): get the distance of a point to a line.
+ // dist_Point_to_Line(): get the distance of a point to a line.
// Input: a Point P and a Line L (in any dimension)
// Return: the shortest distance from P to L
float
-dist_Point_to_Line( Point P, Line L)
-{
- Vector v = L.P1 - L.P0;
- Vector w = P - L.P0;
+dist_Point_to_Line( Point P, Line L ){
+ Vector v = L.P1 - L.P0;
+ Vector w = P - L.P0;
- double c1 = dot(w,v);
- double c2 = dot(v,v);
- double b = c1 / c2;
+ double c1 = dot( w,v );
+ double c2 = dot( v,v );
+ double b = c1 / c2;
- Point Pb = L.P0 + b * v;
- return d(P, Pb);
+ Point Pb = L.P0 + b * v;
+ return d( P, Pb );
}
#endif
-class Segment3D
-{
- typedef Vector3 point_type;
+class Segment3D {
+ typedef Vector3 point_type;
public:
- Segment3D(const point_type& _p0, const point_type& _p1)
- : p0(_p0), p1(_p1)
- {
- }
+ Segment3D(const point_type &_p0, const point_type &_p1)
+ : p0(_p0), p1(_p1)
+ {
+ }
- point_type p0, p1;
+ point_type p0, p1;
};
typedef Vector3 Point3D;
-inline double vector3_distance_squared(const Point3D& a, const Point3D& b)
+inline double vector3_distance_squared(const Point3D &a, const Point3D &b)
{
- return vector3_length_squared(b - a);
+ return vector3_length_squared(b - a);
}
// get the distance of a point to a segment.
-Point3D segment_closest_point_to_point(const Segment3D& segment, const Point3D& point)
+Point3D segment_closest_point_to_point(const Segment3D &segment, const Point3D &point)
{
- Vector3 v = segment.p1 - segment.p0;
- Vector3 w = point - segment.p0;
+ Vector3 v = segment.p1 - segment.p0;
+ Vector3 w = point - segment.p0;
- double c1 = vector3_dot(w,v);
- if ( c1 <= 0 )
- return segment.p0;
+ double c1 = vector3_dot(w, v);
+ if (c1 <= 0) {
+ return segment.p0;
+ }
- double c2 = vector3_dot(v,v);
- if ( c2 <= c1 )
- return segment.p1;
+ double c2 = vector3_dot(v, v);
+ if (c2 <= c1) {
+ return segment.p1;
+ }
- return Point3D(segment.p0 + v * (c1 / c2));
+ return Point3D(segment.p0 + v * (c1 / c2));
}
-double segment_dist_to_point_3d(const Segment3D& segment, const Point3D& point)
+double segment_dist_to_point_3d(const Segment3D &segment, const Point3D &point)
{
- return vector3_distance_squared(point, segment_closest_point_to_point(segment, point));
+ return vector3_distance_squared(point, segment_closest_point_to_point(segment, point));
}
typedef Vector3 point_t;
-typedef const Vector3* point_iterator_t;
+typedef const Vector3 *point_iterator_t;
// crossing number test for a point in a polygon
// This code is patterned after [Franklin, 2000]
-bool point_test_polygon_2d( const point_t& P, point_iterator_t start, point_iterator_t finish )
-{
- std::size_t crossings = 0;
-
- // loop through all edges of the polygon
- for(point_iterator_t prev = finish-1, cur = start; cur != finish; prev = cur, ++cur)
- { // edge from (*prev) to (*cur)
- if ((((*prev)[1] <= P[1]) && ((*cur)[1] > P[1])) // an upward crossing
- || (((*prev)[1] > P[1]) && ((*cur)[1] <= P[1])))
- { // a downward crossing
- // compute the actual edge-ray intersect x-coordinate
- float vt = (float)(P[1] - (*prev)[1]) / ((*cur)[1] - (*prev)[1]);
- if (P[0] < (*prev)[0] + vt * ((*cur)[0] - (*prev)[0])) // P[0] < intersect
- {
- ++crossings; // a valid crossing of y=P[1] right of P[0]
- }
- }
- }
- return (crossings & 0x1) != 0; // 0 if even (out), and 1 if odd (in)
+bool point_test_polygon_2d(const point_t &P, point_iterator_t start, point_iterator_t finish)
+{
+ std::size_t crossings = 0;
+
+ // loop through all edges of the polygon
+ for (point_iterator_t prev = finish - 1, cur = start;
+ cur != finish; prev = cur, ++cur) { // edge from (*prev) to (*cur)
+ if ((((*prev)[1] <= P[1]) && ((*cur)[1] > P[1])) // an upward crossing
+ || (((*prev)[1] > P[1]) && ((*cur)[1] <= P[1]))) { // a downward crossing
+ // compute the actual edge-ray intersect x-coordinate
+ float vt = (float) (P[1] - (*prev)[1]) / ((*cur)[1] - (*prev)[1]);
+ if (P[0] < (*prev)[0] + vt * ((*cur)[0] - (*prev)[0])) { // P[0] < intersect
+ ++crossings; // a valid crossing of y=P[1] right of P[0]
+ }
+ }
+ }
+ return (crossings & 0x1) != 0; // 0 if even (out), and 1 if odd (in)
}
-inline double triangle_signed_area_XY(const Vector3& p0, const Vector3& p1, const Vector3& p2)
+inline double triangle_signed_area_XY(const Vector3 &p0, const Vector3 &p1, const Vector3 &p2)
{
- return ((p1[0] - p0[0]) * (p2[1] - p0[1])) - ((p2[0] - p0[0]) * (p1[1] - p0[1]));
+ return ((p1[0] - p0[0]) * (p2[1] - p0[1])) - ((p2[0] - p0[0]) * (p1[1] - p0[1]));
}
-enum clipcull_t
-{
- eClipCullNone,
- eClipCullCW,
- eClipCullCCW,
+enum clipcull_t {
+ eClipCullNone,
+ eClipCullCW,
+ eClipCullCCW,
};
-inline SelectionIntersection select_point_from_clipped(Vector4& clipped)
+inline SelectionIntersection select_point_from_clipped(Vector4 &clipped)
{
- return SelectionIntersection(clipped[2] / clipped[3], static_cast<float>(vector3_length_squared(Vector3(clipped[0] / clipped[3], clipped[1] / clipped[3], 0))));
+ return SelectionIntersection(clipped[2] / clipped[3], static_cast<float>( vector3_length_squared(
+ Vector3(clipped[0] / clipped[3], clipped[1] / clipped[3], 0))));
}
-void BestPoint(std::size_t count, Vector4 clipped[9], SelectionIntersection& best, clipcull_t cull)
+void BestPoint(std::size_t count, Vector4 clipped[9], SelectionIntersection &best, clipcull_t cull)
{
- Vector3 normalised[9];
-
- {
- for(std::size_t i=0; i<count; ++i)
- {
- normalised[i][0] = clipped[i][0] / clipped[i][3];
- normalised[i][1] = clipped[i][1] / clipped[i][3];
- normalised[i][2] = clipped[i][2] / clipped[i][3];
- }
- }
-
- if(cull != eClipCullNone && count > 2)
- {
- double signed_area = triangle_signed_area_XY(normalised[0], normalised[1], normalised[2]);
-
- if((cull == eClipCullCW && signed_area > 0)
- || (cull == eClipCullCCW && signed_area < 0))
- return;
- }
-
- if(count == 2)
- {
- Segment3D segment(normalised[0], normalised[1]);
- Point3D point = segment_closest_point_to_point(segment, Vector3(0, 0, 0));
- assign_if_closer(best, SelectionIntersection(point.z(), 0));
- }
- else if(count > 2 && !point_test_polygon_2d(Vector3(0, 0, 0), normalised, normalised + count))
- {
- point_iterator_t end = normalised + count;
- for(point_iterator_t previous = end-1, current = normalised; current != end; previous = current, ++current)
- {
- Segment3D segment(*previous, *current);
- Point3D point = segment_closest_point_to_point(segment, Vector3(0, 0, 0));
- float depth = point.z();
- point.z() = 0;
- float distance = static_cast<float>(vector3_length_squared(point));
-
- assign_if_closer(best, SelectionIntersection(depth, distance));
- }
- }
- else if(count > 2)
- {
- assign_if_closer(
- best,
- SelectionIntersection(
- static_cast<float>(ray_distance_to_plane(
- Ray(Vector3(0, 0, 0), Vector3(0, 0, 1)),
- plane3_for_points(normalised[0], normalised[1], normalised[2])
- )),
- 0
- )
- );
- }
+ Vector3 normalised[9];
+
+ {
+ for (std::size_t i = 0; i < count; ++i) {
+ normalised[i][0] = clipped[i][0] / clipped[i][3];
+ normalised[i][1] = clipped[i][1] / clipped[i][3];
+ normalised[i][2] = clipped[i][2] / clipped[i][3];
+ }
+ }
+
+ if (cull != eClipCullNone && count > 2) {
+ double signed_area = triangle_signed_area_XY(normalised[0], normalised[1], normalised[2]);
+
+ if ((cull == eClipCullCW && signed_area > 0)
+ || (cull == eClipCullCCW && signed_area < 0)) {
+ return;
+ }
+ }
-#if defined(DEBUG_SELECTION)
- if(count >= 2)
- g_render_clipped.insert(clipped, count);
+ if (count == 2) {
+ Segment3D segment(normalised[0], normalised[1]);
+ Point3D point = segment_closest_point_to_point(segment, Vector3(0, 0, 0));
+ assign_if_closer(best, SelectionIntersection(point.z(), 0));
+ } else if (count > 2 && !point_test_polygon_2d(Vector3(0, 0, 0), normalised, normalised + count)) {
+ point_iterator_t end = normalised + count;
+ for (point_iterator_t previous = end - 1, current = normalised; current != end; previous = current, ++current) {
+ Segment3D segment(*previous, *current);
+ Point3D point = segment_closest_point_to_point(segment, Vector3(0, 0, 0));
+ float depth = point.z();
+ point.z() = 0;
+ float distance = static_cast<float>( vector3_length_squared(point));
+
+ assign_if_closer(best, SelectionIntersection(depth, distance));
+ }
+ } else if (count > 2) {
+ assign_if_closer(
+ best,
+ SelectionIntersection(
+ static_cast<float>( ray_distance_to_plane(
+ Ray(Vector3(0, 0, 0), Vector3(0, 0, 1)),
+ plane3_for_points(normalised[0], normalised[1], normalised[2])
+ )),
+ 0
+ )
+ );
+ }
+
+#if defined( DEBUG_SELECTION )
+ if (count >= 2) {
+ g_render_clipped.insert(clipped, count);
+ }
#endif
}
-void LineStrip_BestPoint(const Matrix4& local2view, const PointVertex* vertices, const std::size_t size, SelectionIntersection& best)
+void LineStrip_BestPoint(const Matrix4 &local2view, const PointVertex *vertices, const std::size_t size,
+ SelectionIntersection &best)
{
- Vector4 clipped[2];
- for(std::size_t i = 0; (i + 1) < size; ++i)
- {
- const std::size_t count = matrix4_clip_line(local2view, vertex3f_to_vector3(vertices[i].vertex), vertex3f_to_vector3(vertices[i + 1].vertex), clipped);
- BestPoint(count, clipped, best, eClipCullNone);
- }
+ Vector4 clipped[2];
+ for (std::size_t i = 0; (i + 1) < size; ++i) {
+ const std::size_t count = matrix4_clip_line(local2view, vertex3f_to_vector3(vertices[i].vertex),
+ vertex3f_to_vector3(vertices[i + 1].vertex), clipped);
+ BestPoint(count, clipped, best, eClipCullNone);
+ }
}
-void LineLoop_BestPoint(const Matrix4& local2view, const PointVertex* vertices, const std::size_t size, SelectionIntersection& best)
+void LineLoop_BestPoint(const Matrix4 &local2view, const PointVertex *vertices, const std::size_t size,
+ SelectionIntersection &best)
{
- Vector4 clipped[2];
- for(std::size_t i = 0; i < size; ++i)
- {
- const std::size_t count = matrix4_clip_line(local2view, vertex3f_to_vector3(vertices[i].vertex), vertex3f_to_vector3(vertices[(i+1)%size].vertex), clipped);
- BestPoint(count, clipped, best, eClipCullNone);
- }
+ Vector4 clipped[2];
+ for (std::size_t i = 0; i < size; ++i) {
+ const std::size_t count = matrix4_clip_line(local2view, vertex3f_to_vector3(vertices[i].vertex),
+ vertex3f_to_vector3(vertices[(i + 1) % size].vertex), clipped);
+ BestPoint(count, clipped, best, eClipCullNone);
+ }
}
-void Line_BestPoint(const Matrix4& local2view, const PointVertex vertices[2], SelectionIntersection& best)
+void Line_BestPoint(const Matrix4 &local2view, const PointVertex vertices[2], SelectionIntersection &best)
{
- Vector4 clipped[2];
- const std::size_t count = matrix4_clip_line(local2view, vertex3f_to_vector3(vertices[0].vertex), vertex3f_to_vector3(vertices[1].vertex), clipped);
- BestPoint(count, clipped, best, eClipCullNone);
+ Vector4 clipped[2];
+ const std::size_t count = matrix4_clip_line(local2view, vertex3f_to_vector3(vertices[0].vertex),
+ vertex3f_to_vector3(vertices[1].vertex), clipped);
+ BestPoint(count, clipped, best, eClipCullNone);
}
-void Circle_BestPoint(const Matrix4& local2view, clipcull_t cull, const PointVertex* vertices, const std::size_t size, SelectionIntersection& best)
+void Circle_BestPoint(const Matrix4 &local2view, clipcull_t cull, const PointVertex *vertices, const std::size_t size,
+ SelectionIntersection &best)
{
- Vector4 clipped[9];
- for(std::size_t i=0; i<size; ++i)
- {
- const std::size_t count = matrix4_clip_triangle(local2view, g_vector3_identity, vertex3f_to_vector3(vertices[i].vertex), vertex3f_to_vector3(vertices[(i+1)%size].vertex), clipped);
- BestPoint(count, clipped, best, cull);
- }
+ Vector4 clipped[9];
+ for (std::size_t i = 0; i < size; ++i) {
+ const std::size_t count = matrix4_clip_triangle(local2view, g_vector3_identity,
+ vertex3f_to_vector3(vertices[i].vertex),
+ vertex3f_to_vector3(vertices[(i + 1) % size].vertex), clipped);
+ BestPoint(count, clipped, best, cull);
+ }
}
-void Quad_BestPoint(const Matrix4& local2view, clipcull_t cull, const PointVertex* vertices, SelectionIntersection& best)
+void
+Quad_BestPoint(const Matrix4 &local2view, clipcull_t cull, const PointVertex *vertices, SelectionIntersection &best)
{
- Vector4 clipped[9];
- {
- const std::size_t count = matrix4_clip_triangle(local2view, vertex3f_to_vector3(vertices[0].vertex), vertex3f_to_vector3(vertices[1].vertex), vertex3f_to_vector3(vertices[3].vertex), clipped);
- BestPoint(count, clipped, best, cull);
- }
- {
- const std::size_t count = matrix4_clip_triangle(local2view, vertex3f_to_vector3(vertices[1].vertex), vertex3f_to_vector3(vertices[2].vertex), vertex3f_to_vector3(vertices[3].vertex), clipped);
- BestPoint(count, clipped, best, cull);
- }
+ Vector4 clipped[9];
+ {
+ const std::size_t count = matrix4_clip_triangle(local2view, vertex3f_to_vector3(vertices[0].vertex),
+ vertex3f_to_vector3(vertices[1].vertex),
+ vertex3f_to_vector3(vertices[3].vertex), clipped);
+ BestPoint(count, clipped, best, cull);
+ }
+ {
+ const std::size_t count = matrix4_clip_triangle(local2view, vertex3f_to_vector3(vertices[1].vertex),
+ vertex3f_to_vector3(vertices[2].vertex),
+ vertex3f_to_vector3(vertices[3].vertex), clipped);
+ BestPoint(count, clipped, best, cull);
+ }
}
-struct FlatShadedVertex
-{
- Vertex3f vertex;
- Colour4b colour;
- Normal3f normal;
+struct FlatShadedVertex {
+ Vertex3f vertex;
+ Colour4b colour;
+ Normal3f normal;
- FlatShadedVertex()
- {
- }
+ FlatShadedVertex()
+ {
+ }
};
-typedef FlatShadedVertex* FlatShadedVertexIterator;
-void Triangles_BestPoint(const Matrix4& local2view, clipcull_t cull, FlatShadedVertexIterator first, FlatShadedVertexIterator last, SelectionIntersection& best)
+typedef FlatShadedVertex *FlatShadedVertexIterator;
+
+void Triangles_BestPoint(const Matrix4 &local2view, clipcull_t cull, FlatShadedVertexIterator first,
+ FlatShadedVertexIterator last, SelectionIntersection &best)
{
- for(FlatShadedVertexIterator x(first), y(first+1), z(first+2); x != last; x += 3, y += 3, z +=3)
- {
- Vector4 clipped[9];
- BestPoint(
- matrix4_clip_triangle(
- local2view,
- reinterpret_cast<const Vector3&>((*x).vertex),
- reinterpret_cast<const Vector3&>((*y).vertex),
- reinterpret_cast<const Vector3&>((*z).vertex),
- clipped
- ),
- clipped,
- best,
- cull
- );
- }
+ for (FlatShadedVertexIterator x(first), y(first + 1), z(first + 2); x != last; x += 3, y += 3, z += 3) {
+ Vector4 clipped[9];
+ BestPoint(
+ matrix4_clip_triangle(
+ local2view,
+ reinterpret_cast<const Vector3 &>((*x).vertex ),
+ reinterpret_cast<const Vector3 &>((*y).vertex ),
+ reinterpret_cast<const Vector3 &>((*z).vertex ),
+ clipped
+ ),
+ clipped,
+ best,
+ cull
+ );
+ }
}
-typedef std::multimap<SelectionIntersection, Selectable*> SelectableSortedSet;
+typedef std::multimap<SelectionIntersection, Selectable *> SelectableSortedSet;
-class SelectionPool : public Selector
-{
- SelectableSortedSet m_pool;
- SelectionIntersection m_intersection;
- Selectable* m_selectable;
+class SelectionPool : public Selector {
+ SelectableSortedSet m_pool;
+ SelectionIntersection m_intersection;
+ Selectable *m_selectable;
public:
- void pushSelectable(Selectable& selectable)
- {
- m_intersection = SelectionIntersection();
- m_selectable = &selectable;
- }
- void popSelectable()
- {
- addSelectable(m_intersection, m_selectable);
- m_intersection = SelectionIntersection();
- }
- void addIntersection(const SelectionIntersection& intersection)
- {
- assign_if_closer(m_intersection, intersection);
- }
- void addSelectable(const SelectionIntersection& intersection, Selectable* selectable)
- {
- if(intersection.valid())
- {
- m_pool.insert(SelectableSortedSet::value_type(intersection, selectable));
- }
- }
-
- typedef SelectableSortedSet::iterator iterator;
-
- iterator begin()
- {
- return m_pool.begin();
- }
- iterator end()
- {
- return m_pool.end();
- }
-
- bool failed()
- {
- return m_pool.empty();
- }
+ void pushSelectable(Selectable &selectable)
+ {
+ m_intersection = SelectionIntersection();
+ m_selectable = &selectable;
+ }
+
+ void popSelectable()
+ {
+ addSelectable(m_intersection, m_selectable);
+ m_intersection = SelectionIntersection();
+ }
+
+ void addIntersection(const SelectionIntersection &intersection)
+ {
+ assign_if_closer(m_intersection, intersection);
+ }
+
+ void addSelectable(const SelectionIntersection &intersection, Selectable *selectable)
+ {
+ if (intersection.valid()) {
+ m_pool.insert(SelectableSortedSet::value_type(intersection, selectable));
+ }
+ }
+
+ typedef SelectableSortedSet::iterator iterator;
+
+ iterator begin()
+ {
+ return m_pool.begin();
+ }
+
+ iterator end()
+ {
+ return m_pool.end();
+ }
+
+ bool failed()
+ {
+ return m_pool.empty();
+ }
};
const Colour4b g_colour_screen(0, 255, 255, 255);
const Colour4b g_colour_selected(255, 255, 0, 255);
-inline const Colour4b& colourSelected(const Colour4b& colour, bool selected)
+inline const Colour4b &colourSelected(const Colour4b &colour, bool selected)
{
- return (selected) ? g_colour_selected : colour;
+ return (selected) ? g_colour_selected : colour;
}
template<typename remap_policy>
-inline void draw_semicircle(const std::size_t segments, const float radius, PointVertex* vertices, remap_policy remap)
+inline void draw_semicircle(const std::size_t segments, const float radius, PointVertex *vertices, remap_policy remap)
{
- const double increment = c_pi / double(segments << 2);
+ const double increment = c_pi / double(segments << 2);
- std::size_t count = 0;
- float x = radius;
- float y = 0;
- remap_policy::set(vertices[segments << 2].vertex, -radius, 0, 0);
- while(count < segments)
- {
- PointVertex* i = vertices + count;
- PointVertex* j = vertices + ((segments << 1) - (count + 1));
+ std::size_t count = 0;
+ float x = radius;
+ float y = 0;
+ remap_policy::set(vertices[segments << 2].vertex, -radius, 0, 0);
+ while (count < segments) {
+ PointVertex *i = vertices + count;
+ PointVertex *j = vertices + ((segments << 1) - (count + 1));
- PointVertex* k = i + (segments << 1);
- PointVertex* l = j + (segments << 1);
+ PointVertex *k = i + (segments << 1);
+ PointVertex *l = j + (segments << 1);
#if 0
- PointVertex* m = i + (segments << 2);
- PointVertex* n = j + (segments << 2);
- PointVertex* o = k + (segments << 2);
- PointVertex* p = l + (segments << 2);
+ PointVertex* m = i + ( segments << 2 );
+ PointVertex* n = j + ( segments << 2 );
+ PointVertex* o = k + ( segments << 2 );
+ PointVertex* p = l + ( segments << 2 );
#endif
- remap_policy::set(i->vertex, x,-y, 0);
- remap_policy::set(k->vertex,-y,-x, 0);
+ remap_policy::set(i->vertex, x, -y, 0);
+ remap_policy::set(k->vertex, -y, -x, 0);
#if 0
- remap_policy::set(m->vertex,-x, y, 0);
- remap_policy::set(o->vertex, y, x, 0);
+ remap_policy::set( m->vertex,-x, y, 0 );
+ remap_policy::set( o->vertex, y, x, 0 );
#endif
- ++count;
+ ++count;
- {
- const double theta = increment * count;
- x = static_cast<float>(radius * cos(theta));
- y = static_cast<float>(radius * sin(theta));
- }
+ {
+ const double theta = increment * count;
+ x = static_cast<float>( radius * cos(theta));
+ y = static_cast<float>( radius * sin(theta));
+ }
- remap_policy::set(j->vertex, y,-x, 0);
- remap_policy::set(l->vertex,-x,-y, 0);
+ remap_policy::set(j->vertex, y, -x, 0);
+ remap_policy::set(l->vertex, -x, -y, 0);
#if 0
- remap_policy::set(n->vertex,-y, x, 0);
- remap_policy::set(p->vertex, x, y, 0);
+ remap_policy::set( n->vertex,-y, x, 0 );
+ remap_policy::set( p->vertex, x, y, 0 );
#endif
- }
+ }
}
-class Manipulator
-{
+class Manipulator {
public:
- virtual Manipulatable* GetManipulatable() = 0;
- virtual void testSelect(const View& view, const Matrix4& pivot2world)
- {
- }
- virtual void render(Renderer& renderer, const VolumeTest& volume, const Matrix4& pivot2world)
- {
- }
- virtual void setSelected(bool select) = 0;
- virtual bool isSelected() const = 0;
+ virtual Manipulatable *GetManipulatable() = 0;
+
+ virtual void testSelect(const View &view, const Matrix4 &pivot2world)
+ {
+ }
+
+ virtual void render(Renderer &renderer, const VolumeTest &volume, const Matrix4 &pivot2world)
+ {
+ }
+
+ virtual void setSelected(bool select) = 0;
+
+ virtual bool isSelected() const = 0;
};
-inline Vector3 normalised_safe(const Vector3& self)
+inline Vector3 normalised_safe(const Vector3 &self)
{
- if(vector3_equal(self, g_vector3_identity))
- {
- return g_vector3_identity;
- }
- return vector3_normalised(self);
+ if (vector3_equal(self, g_vector3_identity)) {
+ return g_vector3_identity;
+ }
+ return vector3_normalised(self);
}
-class RotateManipulator : public Manipulator
-{
- struct RenderableCircle : public OpenGLRenderable
- {
- Array<PointVertex> m_vertices;
+class RotateManipulator : public Manipulator {
+ struct RenderableCircle : public OpenGLRenderable {
+ Array<PointVertex> m_vertices;
- RenderableCircle(std::size_t size) : m_vertices(size)
- {
- }
- void render(RenderStateFlags state) const
- {
- glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(PointVertex), &m_vertices.data()->colour);
- glVertexPointer(3, GL_FLOAT, sizeof(PointVertex), &m_vertices.data()->vertex);
- glDrawArrays(GL_LINE_LOOP, 0, GLsizei(m_vertices.size()));
- }
- void setColour(const Colour4b& colour)
- {
- for(Array<PointVertex>::iterator i = m_vertices.begin(); i != m_vertices.end(); ++i)
- {
- (*i).colour = colour;
- }
- }
- };
+ RenderableCircle(std::size_t size) : m_vertices(size)
+ {
+ }
- struct RenderableSemiCircle : public OpenGLRenderable
- {
- Array<PointVertex> m_vertices;
+ void render(RenderStateFlags state) const
+ {
+ glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(PointVertex), &m_vertices.data()->colour);
+ glVertexPointer(3, GL_FLOAT, sizeof(PointVertex), &m_vertices.data()->vertex);
+ glDrawArrays(GL_LINE_LOOP, 0, GLsizei(m_vertices.size()));
+ }
- RenderableSemiCircle(std::size_t size) : m_vertices(size)
- {
- }
- void render(RenderStateFlags state) const
- {
- glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(PointVertex), &m_vertices.data()->colour);
- glVertexPointer(3, GL_FLOAT, sizeof(PointVertex), &m_vertices.data()->vertex);
- glDrawArrays(GL_LINE_STRIP, 0, GLsizei(m_vertices.size()));
- }
- void setColour(const Colour4b& colour)
- {
- for(Array<PointVertex>::iterator i = m_vertices.begin(); i != m_vertices.end(); ++i)
- {
- (*i).colour = colour;
- }
- }
- };
-
- RotateFree m_free;
- RotateAxis m_axis;
- Vector3 m_axis_screen;
- RenderableSemiCircle m_circle_x;
- RenderableSemiCircle m_circle_y;
- RenderableSemiCircle m_circle_z;
- RenderableCircle m_circle_screen;
- RenderableCircle m_circle_sphere;
- SelectableBool m_selectable_x;
- SelectableBool m_selectable_y;
- SelectableBool m_selectable_z;
- SelectableBool m_selectable_screen;
- SelectableBool m_selectable_sphere;
- Pivot2World m_pivot;
- Matrix4 m_local2world_x;
- Matrix4 m_local2world_y;
- Matrix4 m_local2world_z;
- bool m_circle_x_visible;
- bool m_circle_y_visible;
- bool m_circle_z_visible;
-public:
- static Shader* m_state_outer;
-
- RotateManipulator(Rotatable& rotatable, std::size_t segments, float radius) :
- m_free(rotatable),
- m_axis(rotatable),
- m_circle_x((segments << 2) + 1),
- m_circle_y((segments << 2) + 1),
- m_circle_z((segments << 2) + 1),
- m_circle_screen(segments<<3),
- m_circle_sphere(segments<<3)
- {
- draw_semicircle(segments, radius, m_circle_x.m_vertices.data(), RemapYZX());
- draw_semicircle(segments, radius, m_circle_y.m_vertices.data(), RemapZXY());
- draw_semicircle(segments, radius, m_circle_z.m_vertices.data(), RemapXYZ());
+ void setColour(const Colour4b &colour)
+ {
+ for (Array<PointVertex>::iterator i = m_vertices.begin(); i != m_vertices.end(); ++i) {
+ (*i).colour = colour;
+ }
+ }
+ };
- draw_circle(segments, radius * 1.15f, m_circle_screen.m_vertices.data(), RemapXYZ());
- draw_circle(segments, radius, m_circle_sphere.m_vertices.data(), RemapXYZ());
- }
+ struct RenderableSemiCircle : public OpenGLRenderable {
+ Array<PointVertex> m_vertices;
+ RenderableSemiCircle(std::size_t size) : m_vertices(size)
+ {
+ }
+
+ void render(RenderStateFlags state) const
+ {
+ glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(PointVertex), &m_vertices.data()->colour);
+ glVertexPointer(3, GL_FLOAT, sizeof(PointVertex), &m_vertices.data()->vertex);
+ glDrawArrays(GL_LINE_STRIP, 0, GLsizei(m_vertices.size()));
+ }
- void UpdateColours()
- {
- m_circle_x.setColour(colourSelected(g_colour_x, m_selectable_x.isSelected()));
- m_circle_y.setColour(colourSelected(g_colour_y, m_selectable_y.isSelected()));
- m_circle_z.setColour(colourSelected(g_colour_z, m_selectable_z.isSelected()));
- m_circle_screen.setColour(colourSelected(g_colour_screen, m_selectable_screen.isSelected()));
- m_circle_sphere.setColour(colourSelected(g_colour_sphere, false));
- }
-
- void updateCircleTransforms()
- {
- Vector3 localViewpoint(matrix4_transformed_direction(matrix4_transposed(m_pivot.m_worldSpace), vector4_to_vector3(m_pivot.m_viewpointSpace.z())));
+ void setColour(const Colour4b &colour)
+ {
+ for (Array<PointVertex>::iterator i = m_vertices.begin(); i != m_vertices.end(); ++i) {
+ (*i).colour = colour;
+ }
+ }
+ };
+
+ RotateFree m_free;
+ RotateAxis m_axis;
+ Vector3 m_axis_screen;
+ RenderableSemiCircle m_circle_x;
+ RenderableSemiCircle m_circle_y;
+ RenderableSemiCircle m_circle_z;
+ RenderableCircle m_circle_screen;
+ RenderableCircle m_circle_sphere;
+ SelectableBool m_selectable_x;
+ SelectableBool m_selectable_y;
+ SelectableBool m_selectable_z;
+ SelectableBool m_selectable_screen;
+ SelectableBool m_selectable_sphere;
+ Pivot2World m_pivot;
+ Matrix4 m_local2world_x;
+ Matrix4 m_local2world_y;
+ Matrix4 m_local2world_z;
+ bool m_circle_x_visible;
+ bool m_circle_y_visible;
+ bool m_circle_z_visible;
+public:
+ static Shader *m_state_outer;
- m_circle_x_visible = !vector3_equal_epsilon(g_vector3_axis_x, localViewpoint, 1e-6f);
- if(m_circle_x_visible)
+ RotateManipulator(Rotatable &rotatable, std::size_t segments, float radius) :
+ m_free(rotatable),
+ m_axis(rotatable),
+ m_circle_x((segments << 2) + 1),
+ m_circle_y((segments << 2) + 1),
+ m_circle_z((segments << 2) + 1),
+ m_circle_screen(segments << 3),
+ m_circle_sphere(segments << 3)
{
- m_local2world_x = g_matrix4_identity;
- vector4_to_vector3(m_local2world_x.y()) = normalised_safe(
- vector3_cross(g_vector3_axis_x, localViewpoint)
- );
- vector4_to_vector3(m_local2world_x.z()) = normalised_safe(
- vector3_cross(vector4_to_vector3(m_local2world_x.x()), vector4_to_vector3(m_local2world_x.y()))
- );
- matrix4_premultiply_by_matrix4(m_local2world_x, m_pivot.m_worldSpace);
+ draw_semicircle(segments, radius, m_circle_x.m_vertices.data(), RemapYZX());
+ draw_semicircle(segments, radius, m_circle_y.m_vertices.data(), RemapZXY());
+ draw_semicircle(segments, radius, m_circle_z.m_vertices.data(), RemapXYZ());
+
+ draw_circle(segments, radius * 1.15f, m_circle_screen.m_vertices.data(), RemapXYZ());
+ draw_circle(segments, radius, m_circle_sphere.m_vertices.data(), RemapXYZ());
}
- m_circle_y_visible = !vector3_equal_epsilon(g_vector3_axis_y, localViewpoint, 1e-6f);
- if(m_circle_y_visible)
+
+ void UpdateColours()
{
- m_local2world_y = g_matrix4_identity;
- vector4_to_vector3(m_local2world_y.z()) = normalised_safe(
- vector3_cross(g_vector3_axis_y, localViewpoint)
- );
- vector4_to_vector3(m_local2world_y.x()) = normalised_safe(
- vector3_cross(vector4_to_vector3(m_local2world_y.y()), vector4_to_vector3(m_local2world_y.z()))
- );
- matrix4_premultiply_by_matrix4(m_local2world_y, m_pivot.m_worldSpace);
+ m_circle_x.setColour(colourSelected(g_colour_x, m_selectable_x.isSelected()));
+ m_circle_y.setColour(colourSelected(g_colour_y, m_selectable_y.isSelected()));
+ m_circle_z.setColour(colourSelected(g_colour_z, m_selectable_z.isSelected()));
+ m_circle_screen.setColour(colourSelected(g_colour_screen, m_selectable_screen.isSelected()));
+ m_circle_sphere.setColour(colourSelected(g_colour_sphere, false));
}
- m_circle_z_visible = !vector3_equal_epsilon(g_vector3_axis_z, localViewpoint, 1e-6f);
- if(m_circle_z_visible)
+ void updateCircleTransforms()
{
- m_local2world_z = g_matrix4_identity;
- vector4_to_vector3(m_local2world_z.x()) = normalised_safe(
- vector3_cross(g_vector3_axis_z, localViewpoint)
- );
- vector4_to_vector3(m_local2world_z.y()) = normalised_safe(
- vector3_cross(vector4_to_vector3(m_local2world_z.z()), vector4_to_vector3(m_local2world_z.x()))
- );
- matrix4_premultiply_by_matrix4(m_local2world_z, m_pivot.m_worldSpace);
+ Vector3 localViewpoint(matrix4_transformed_direction(matrix4_transposed(m_pivot.m_worldSpace),
+ vector4_to_vector3(m_pivot.m_viewpointSpace.z())));
+
+ m_circle_x_visible = !vector3_equal_epsilon(g_vector3_axis_x, localViewpoint, 1e-6f);
+ if (m_circle_x_visible) {
+ m_local2world_x = g_matrix4_identity;
+ vector4_to_vector3(m_local2world_x.y()) = normalised_safe(
+ vector3_cross(g_vector3_axis_x, localViewpoint)
+ );
+ vector4_to_vector3(m_local2world_x.z()) = normalised_safe(
+ vector3_cross(vector4_to_vector3(m_local2world_x.x()), vector4_to_vector3(m_local2world_x.y()))
+ );
+ matrix4_premultiply_by_matrix4(m_local2world_x, m_pivot.m_worldSpace);
+ }
+
+ m_circle_y_visible = !vector3_equal_epsilon(g_vector3_axis_y, localViewpoint, 1e-6f);
+ if (m_circle_y_visible) {
+ m_local2world_y = g_matrix4_identity;
+ vector4_to_vector3(m_local2world_y.z()) = normalised_safe(
+ vector3_cross(g_vector3_axis_y, localViewpoint)
+ );
+ vector4_to_vector3(m_local2world_y.x()) = normalised_safe(
+ vector3_cross(vector4_to_vector3(m_local2world_y.y()), vector4_to_vector3(m_local2world_y.z()))
+ );
+ matrix4_premultiply_by_matrix4(m_local2world_y, m_pivot.m_worldSpace);
+ }
+
+ m_circle_z_visible = !vector3_equal_epsilon(g_vector3_axis_z, localViewpoint, 1e-6f);
+ if (m_circle_z_visible) {
+ m_local2world_z = g_matrix4_identity;
+ vector4_to_vector3(m_local2world_z.x()) = normalised_safe(
+ vector3_cross(g_vector3_axis_z, localViewpoint)
+ );
+ vector4_to_vector3(m_local2world_z.y()) = normalised_safe(
+ vector3_cross(vector4_to_vector3(m_local2world_z.z()), vector4_to_vector3(m_local2world_z.x()))
+ );
+ matrix4_premultiply_by_matrix4(m_local2world_z, m_pivot.m_worldSpace);
+ }
}
- }
- void render(Renderer& renderer, const VolumeTest& volume, const Matrix4& pivot2world)
- {
- m_pivot.update(pivot2world, volume.GetModelview(), volume.GetProjection(), volume.GetViewport());
- updateCircleTransforms();
+ void render(Renderer &renderer, const VolumeTest &volume, const Matrix4 &pivot2world)
+ {
+ m_pivot.update(pivot2world, volume.GetModelview(), volume.GetProjection(), volume.GetViewport());
+ updateCircleTransforms();
- // temp hack
- UpdateColours();
+ // temp hack
+ UpdateColours();
- renderer.SetState(m_state_outer, Renderer::eWireframeOnly);
- renderer.SetState(m_state_outer, Renderer::eFullMaterials);
+ renderer.SetState(m_state_outer, Renderer::eWireframeOnly);
+ renderer.SetState(m_state_outer, Renderer::eFullMaterials);
- renderer.addRenderable(m_circle_screen, m_pivot.m_viewpointSpace);
- renderer.addRenderable(m_circle_sphere, m_pivot.m_viewpointSpace);
+ renderer.addRenderable(m_circle_screen, m_pivot.m_viewpointSpace);
+ renderer.addRenderable(m_circle_sphere, m_pivot.m_viewpointSpace);
- if(m_circle_x_visible)
- {
- renderer.addRenderable(m_circle_x, m_local2world_x);
- }
- if(m_circle_y_visible)
- {
- renderer.addRenderable(m_circle_y, m_local2world_y);
+ if (m_circle_x_visible) {
+ renderer.addRenderable(m_circle_x, m_local2world_x);
+ }
+ if (m_circle_y_visible) {
+ renderer.addRenderable(m_circle_y, m_local2world_y);
+ }
+ if (m_circle_z_visible) {
+ renderer.addRenderable(m_circle_z, m_local2world_z);
+ }
}
- if(m_circle_z_visible)
+
+ void testSelect(const View &view, const Matrix4 &pivot2world)
{
- renderer.addRenderable(m_circle_z, m_local2world_z);
- }
- }
- void testSelect(const View& view, const Matrix4& pivot2world)
- {
- m_pivot.update(pivot2world, view.GetModelview(), view.GetProjection(), view.GetViewport());
- updateCircleTransforms();
+ m_pivot.update(pivot2world, view.GetModelview(), view.GetProjection(), view.GetViewport());
+ updateCircleTransforms();
- SelectionPool selector;
+ SelectionPool selector;
- {
- {
- Matrix4 local2view(matrix4_multiplied_by_matrix4(view.GetViewMatrix(), m_local2world_x));
+ {
+ {
+ Matrix4 local2view(matrix4_multiplied_by_matrix4(view.GetViewMatrix(), m_local2world_x));
-#if defined(DEBUG_SELECTION)
- g_render_clipped.construct(view.GetViewMatrix());
+#if defined( DEBUG_SELECTION )
+ g_render_clipped.construct(view.GetViewMatrix());
#endif
- SelectionIntersection best;
- LineStrip_BestPoint(local2view, m_circle_x.m_vertices.data(), m_circle_x.m_vertices.size(), best);
- selector.addSelectable(best, &m_selectable_x);
- }
+ SelectionIntersection best;
+ LineStrip_BestPoint(local2view, m_circle_x.m_vertices.data(), m_circle_x.m_vertices.size(), best);
+ selector.addSelectable(best, &m_selectable_x);
+ }
- {
- Matrix4 local2view(matrix4_multiplied_by_matrix4(view.GetViewMatrix(), m_local2world_y));
+ {
+ Matrix4 local2view(matrix4_multiplied_by_matrix4(view.GetViewMatrix(), m_local2world_y));
-#if defined(DEBUG_SELECTION)
- g_render_clipped.construct(view.GetViewMatrix());
+#if defined( DEBUG_SELECTION )
+ g_render_clipped.construct(view.GetViewMatrix());
#endif
- SelectionIntersection best;
- LineStrip_BestPoint(local2view, m_circle_y.m_vertices.data(), m_circle_y.m_vertices.size(), best);
- selector.addSelectable(best, &m_selectable_y);
- }
+ SelectionIntersection best;
+ LineStrip_BestPoint(local2view, m_circle_y.m_vertices.data(), m_circle_y.m_vertices.size(), best);
+ selector.addSelectable(best, &m_selectable_y);
+ }
- {
- Matrix4 local2view(matrix4_multiplied_by_matrix4(view.GetViewMatrix(), m_local2world_z));
+ {
+ Matrix4 local2view(matrix4_multiplied_by_matrix4(view.GetViewMatrix(), m_local2world_z));
-#if defined(DEBUG_SELECTION)
- g_render_clipped.construct(view.GetViewMatrix());
+#if defined( DEBUG_SELECTION )
+ g_render_clipped.construct(view.GetViewMatrix());
#endif
- SelectionIntersection best;
- LineStrip_BestPoint(local2view, m_circle_z.m_vertices.data(), m_circle_z.m_vertices.size(), best);
- selector.addSelectable(best, &m_selectable_z);
- }
- }
+ SelectionIntersection best;
+ LineStrip_BestPoint(local2view, m_circle_z.m_vertices.data(), m_circle_z.m_vertices.size(), best);
+ selector.addSelectable(best, &m_selectable_z);
+ }
+ }
- {
- Matrix4 local2view(matrix4_multiplied_by_matrix4(view.GetViewMatrix(), m_pivot.m_viewpointSpace));
+ {
+ Matrix4 local2view(matrix4_multiplied_by_matrix4(view.GetViewMatrix(), m_pivot.m_viewpointSpace));
- {
- SelectionIntersection best;
- LineLoop_BestPoint(local2view, m_circle_screen.m_vertices.data(), m_circle_screen.m_vertices.size(), best);
- selector.addSelectable(best, &m_selectable_screen);
- }
+ {
+ SelectionIntersection best;
+ LineLoop_BestPoint(local2view, m_circle_screen.m_vertices.data(), m_circle_screen.m_vertices.size(),
+ best);
+ selector.addSelectable(best, &m_selectable_screen);
+ }
- {
- SelectionIntersection best;
- Circle_BestPoint(local2view, eClipCullCW, m_circle_sphere.m_vertices.data(), m_circle_sphere.m_vertices.size(), best);
- selector.addSelectable(best, &m_selectable_sphere);
- }
- }
+ {
+ SelectionIntersection best;
+ Circle_BestPoint(local2view, eClipCullCW, m_circle_sphere.m_vertices.data(),
+ m_circle_sphere.m_vertices.size(), best);
+ selector.addSelectable(best, &m_selectable_sphere);
+ }
+ }
- m_axis_screen = m_pivot.m_axis_screen;
+ m_axis_screen = m_pivot.m_axis_screen;
- if(!selector.failed())
- {
- (*selector.begin()).second->setSelected(true);
+ if (!selector.failed()) {
+ (*selector.begin()).second->setSelected(true);
+ }
}
- }
- Manipulatable* GetManipulatable()
- {
- if(m_selectable_x.isSelected())
- {
- m_axis.SetAxis(g_vector3_axis_x);
- return &m_axis;
- }
- else if(m_selectable_y.isSelected())
- {
- m_axis.SetAxis(g_vector3_axis_y);
- return &m_axis;
+ Manipulatable *GetManipulatable()
+ {
+ if (m_selectable_x.isSelected()) {
+ m_axis.SetAxis(g_vector3_axis_x);
+ return &m_axis;
+ } else if (m_selectable_y.isSelected()) {
+ m_axis.SetAxis(g_vector3_axis_y);
+ return &m_axis;
+ } else if (m_selectable_z.isSelected()) {
+ m_axis.SetAxis(g_vector3_axis_z);
+ return &m_axis;
+ } else if (m_selectable_screen.isSelected()) {
+ m_axis.SetAxis(m_axis_screen);
+ return &m_axis;
+ } else {
+ return &m_free;
+ }
}
- else if(m_selectable_z.isSelected())
+
+ void setSelected(bool select)
{
- m_axis.SetAxis(g_vector3_axis_z);
- return &m_axis;
+ m_selectable_x.setSelected(select);
+ m_selectable_y.setSelected(select);
+ m_selectable_z.setSelected(select);
+ m_selectable_screen.setSelected(select);
}
- else if(m_selectable_screen.isSelected())
+
+ bool isSelected() const
{
- m_axis.SetAxis(m_axis_screen);
- return &m_axis;
+ return m_selectable_x.isSelected()
+ | m_selectable_y.isSelected()
+ | m_selectable_z.isSelected()
+ | m_selectable_screen.isSelected()
+ | m_selectable_sphere.isSelected();
}
- else
- return &m_free;
- }
-
- void setSelected(bool select)
- {
- m_selectable_x.setSelected(select);
- m_selectable_y.setSelected(select);
- m_selectable_z.setSelected(select);
- m_selectable_screen.setSelected(select);
- }
- bool isSelected() const
- {
- return m_selectable_x.isSelected()
- | m_selectable_y.isSelected()
- | m_selectable_z.isSelected()
- | m_selectable_screen.isSelected()
- | m_selectable_sphere.isSelected();
- }
};
-Shader* RotateManipulator::m_state_outer;
+Shader *RotateManipulator::m_state_outer;
const float arrowhead_length = 16;
const float arrowhead_radius = 4;
-inline void draw_arrowline(const float length, PointVertex* line, const std::size_t axis)
+inline void draw_arrowline(const float length, PointVertex *line, const std::size_t axis)
{
- (*line++).vertex = vertex3f_identity;
- (*line).vertex = vertex3f_identity;
- vertex3f_to_array((*line).vertex)[axis] = length - arrowhead_length;
+ (*line++).vertex = vertex3f_identity;
+ (*line).vertex = vertex3f_identity;
+ vertex3f_to_array((*line).vertex)[axis] = length - arrowhead_length;
}
template<typename VertexRemap, typename NormalRemap>
-inline void draw_arrowhead(const std::size_t segments, const float length, FlatShadedVertex* vertices, VertexRemap, NormalRemap)
+inline void
+draw_arrowhead(const std::size_t segments, const float length, FlatShadedVertex *vertices, VertexRemap, NormalRemap)
{
- std::size_t head_tris = (segments << 3);
- const double head_segment = c_2pi / head_tris;
- for(std::size_t i = 0; i < head_tris; ++i)
- {
- {
- FlatShadedVertex& point = vertices[i*6+0];
- VertexRemap::x(point.vertex) = length - arrowhead_length;
- VertexRemap::y(point.vertex) = arrowhead_radius * static_cast<float>(cos(i * head_segment));
- VertexRemap::z(point.vertex) = arrowhead_radius * static_cast<float>(sin(i * head_segment));
- NormalRemap::x(point.normal) = arrowhead_radius / arrowhead_length;
- NormalRemap::y(point.normal) = static_cast<float>(cos(i * head_segment));
- NormalRemap::z(point.normal) = static_cast<float>(sin(i * head_segment));
- }
- {
- FlatShadedVertex& point = vertices[i*6+1];
- VertexRemap::x(point.vertex) = length;
- VertexRemap::y(point.vertex) = 0;
- VertexRemap::z(point.vertex) = 0;
- NormalRemap::x(point.normal) = arrowhead_radius / arrowhead_length;
- NormalRemap::y(point.normal) = static_cast<float>(cos((i + 0.5) * head_segment));
- NormalRemap::z(point.normal) = static_cast<float>(sin((i + 0.5) * head_segment));
- }
- {
- FlatShadedVertex& point = vertices[i*6+2];
- VertexRemap::x(point.vertex) = length - arrowhead_length;
- VertexRemap::y(point.vertex) = arrowhead_radius * static_cast<float>(cos((i+1) * head_segment));
- VertexRemap::z(point.vertex) = arrowhead_radius * static_cast<float>(sin((i+1) * head_segment));
- NormalRemap::x(point.normal) = arrowhead_radius / arrowhead_length;
- NormalRemap::y(point.normal) = static_cast<float>(cos((i+1) * head_segment));
- NormalRemap::z(point.normal) = static_cast<float>(sin((i+1) * head_segment));
- }
-
- {
- FlatShadedVertex& point = vertices[i*6+3];
- VertexRemap::x(point.vertex) = length - arrowhead_length;
- VertexRemap::y(point.vertex) = 0;
- VertexRemap::z(point.vertex) = 0;
- NormalRemap::x(point.normal) = -1;
- NormalRemap::y(point.normal) = 0;
- NormalRemap::z(point.normal) = 0;
- }
- {
- FlatShadedVertex& point = vertices[i*6+4];
- VertexRemap::x(point.vertex) = length - arrowhead_length;
- VertexRemap::y(point.vertex) = arrowhead_radius * static_cast<float>(cos(i * head_segment));
- VertexRemap::z(point.vertex) = arrowhead_radius * static_cast<float>(sin(i * head_segment));
- NormalRemap::x(point.normal) = -1;
- NormalRemap::y(point.normal) = 0;
- NormalRemap::z(point.normal) = 0;
- }
- {
- FlatShadedVertex& point = vertices[i*6+5];
- VertexRemap::x(point.vertex) = length - arrowhead_length;
- VertexRemap::y(point.vertex) = arrowhead_radius * static_cast<float>(cos((i+1) * head_segment));
- VertexRemap::z(point.vertex) = arrowhead_radius * static_cast<float>(sin((i+1) * head_segment));
- NormalRemap::x(point.normal) = -1;
- NormalRemap::y(point.normal) = 0;
- NormalRemap::z(point.normal) = 0;
- }
- }
+ std::size_t head_tris = (segments << 3);
+ const double head_segment = c_2pi / head_tris;
+ for (std::size_t i = 0; i < head_tris; ++i) {
+ {
+ FlatShadedVertex &point = vertices[i * 6 + 0];
+ VertexRemap::x(point.vertex) = length - arrowhead_length;
+ VertexRemap::y(point.vertex) = arrowhead_radius * static_cast<float>( cos(i * head_segment));
+ VertexRemap::z(point.vertex) = arrowhead_radius * static_cast<float>( sin(i * head_segment));
+ NormalRemap::x(point.normal) = arrowhead_radius / arrowhead_length;
+ NormalRemap::y(point.normal) = static_cast<float>( cos(i * head_segment));
+ NormalRemap::z(point.normal) = static_cast<float>( sin(i * head_segment));
+ }
+ {
+ FlatShadedVertex &point = vertices[i * 6 + 1];
+ VertexRemap::x(point.vertex) = length;
+ VertexRemap::y(point.vertex) = 0;
+ VertexRemap::z(point.vertex) = 0;
+ NormalRemap::x(point.normal) = arrowhead_radius / arrowhead_length;
+ NormalRemap::y(point.normal) = static_cast<float>( cos((i + 0.5) * head_segment));
+ NormalRemap::z(point.normal) = static_cast<float>( sin((i + 0.5) * head_segment));
+ }
+ {
+ FlatShadedVertex &point = vertices[i * 6 + 2];
+ VertexRemap::x(point.vertex) = length - arrowhead_length;
+ VertexRemap::y(point.vertex) = arrowhead_radius * static_cast<float>( cos((i + 1) * head_segment));
+ VertexRemap::z(point.vertex) = arrowhead_radius * static_cast<float>( sin((i + 1) * head_segment));
+ NormalRemap::x(point.normal) = arrowhead_radius / arrowhead_length;
+ NormalRemap::y(point.normal) = static_cast<float>( cos((i + 1) * head_segment));
+ NormalRemap::z(point.normal) = static_cast<float>( sin((i + 1) * head_segment));
+ }
+
+ {
+ FlatShadedVertex &point = vertices[i * 6 + 3];
+ VertexRemap::x(point.vertex) = length - arrowhead_length;
+ VertexRemap::y(point.vertex) = 0;
+ VertexRemap::z(point.vertex) = 0;
+ NormalRemap::x(point.normal) = -1;
+ NormalRemap::y(point.normal) = 0;
+ NormalRemap::z(point.normal) = 0;
+ }
+ {
+ FlatShadedVertex &point = vertices[i * 6 + 4];
+ VertexRemap::x(point.vertex) = length - arrowhead_length;
+ VertexRemap::y(point.vertex) = arrowhead_radius * static_cast<float>( cos(i * head_segment));
+ VertexRemap::z(point.vertex) = arrowhead_radius * static_cast<float>( sin(i * head_segment));
+ NormalRemap::x(point.normal) = -1;
+ NormalRemap::y(point.normal) = 0;
+ NormalRemap::z(point.normal) = 0;
+ }
+ {
+ FlatShadedVertex &point = vertices[i * 6 + 5];
+ VertexRemap::x(point.vertex) = length - arrowhead_length;
+ VertexRemap::y(point.vertex) = arrowhead_radius * static_cast<float>( cos((i + 1) * head_segment));
+ VertexRemap::z(point.vertex) = arrowhead_radius * static_cast<float>( sin((i + 1) * head_segment));
+ NormalRemap::x(point.normal) = -1;
+ NormalRemap::y(point.normal) = 0;
+ NormalRemap::z(point.normal) = 0;
+ }
+ }
}
template<typename Triple>
-class TripleRemapXYZ
-{
+class TripleRemapXYZ {
public:
- static float& x(Triple& triple)
- {
- return triple.x();
- }
- static float& y(Triple& triple)
- {
- return triple.y();
- }
- static float& z(Triple& triple)
- {
- return triple.z();
- }
-};
+ static float &x(Triple &triple)
+ {
+ return triple.x();
+ }
-template<typename Triple>
-class TripleRemapYZX
-{
-public:
- static float& x(Triple& triple)
- {
- return triple.y();
- }
- static float& y(Triple& triple)
- {
- return triple.z();
- }
- static float& z(Triple& triple)
- {
- return triple.x();
- }
+ static float &y(Triple &triple)
+ {
+ return triple.y();
+ }
+
+ static float &z(Triple &triple)
+ {
+ return triple.z();
+ }
};
template<typename Triple>
-class TripleRemapZXY
-{
+class TripleRemapYZX {
public:
- static float& x(Triple& triple)
- {
- return triple.z();
- }
- static float& y(Triple& triple)
- {
- return triple.x();
- }
- static float& z(Triple& triple)
- {
- return triple.y();
- }
-};
-
-void vector3_print(const Vector3& v)
-{
- globalOutputStream() << "( " << v.x() << " " << v.y() << " " << v.z() << " )";
-}
-
-class TranslateManipulator : public Manipulator
-{
- struct RenderableArrowLine : public OpenGLRenderable
- {
- PointVertex m_line[2];
-
- RenderableArrowLine()
+ static float &x(Triple &triple)
{
+ return triple.y();
}
- void render(RenderStateFlags state) const
+
+ static float &y(Triple &triple)
{
- glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(PointVertex), &m_line[0].colour);
- glVertexPointer(3, GL_FLOAT, sizeof(PointVertex), &m_line[0].vertex);
- glDrawArrays(GL_LINES, 0, 2);
+ return triple.z();
}
- void setColour(const Colour4b& colour)
+
+ static float &z(Triple &triple)
{
- m_line[0].colour = colour;
- m_line[1].colour = colour;
+ return triple.x();
}
- };
- struct RenderableArrowHead : public OpenGLRenderable
- {
- Array<FlatShadedVertex> m_vertices;
+};
- RenderableArrowHead(std::size_t size)
- : m_vertices(size)
+template<typename Triple>
+class TripleRemapZXY {
+public:
+ static float &x(Triple &triple)
{
+ return triple.z();
}
- void render(RenderStateFlags state) const
+
+ static float &y(Triple &triple)
{
- glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(FlatShadedVertex), &m_vertices.data()->colour);
- glVertexPointer(3, GL_FLOAT, sizeof(FlatShadedVertex), &m_vertices.data()->vertex);
- glNormalPointer(GL_FLOAT, sizeof(FlatShadedVertex), &m_vertices.data()->normal);
- glDrawArrays(GL_TRIANGLES, 0, GLsizei(m_vertices.size()));
+ return triple.x();
}
- void setColour(const Colour4b& colour)
+
+ static float &z(Triple &triple)
{
- for(Array<FlatShadedVertex>::iterator i = m_vertices.begin(); i != m_vertices.end(); ++i)
- {
- (*i).colour = colour;
- }
+ return triple.y();
}
- };
- struct RenderableQuad : public OpenGLRenderable
- {
- PointVertex m_quad[4];
- void render(RenderStateFlags state) const
- {
- glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(PointVertex), &m_quad[0].colour);
- glVertexPointer(3, GL_FLOAT, sizeof(PointVertex), &m_quad[0].vertex);
- glDrawArrays(GL_LINE_LOOP, 0, 4);
- }
- void setColour(const Colour4b& colour)
- {
- m_quad[0].colour = colour;
- m_quad[1].colour = colour;
- m_quad[2].colour = colour;
- m_quad[3].colour = colour;
- }
- };
-
- TranslateFree m_free;
- TranslateAxis m_axis;
- RenderableArrowLine m_arrow_x;
- RenderableArrowLine m_arrow_y;
- RenderableArrowLine m_arrow_z;
- RenderableArrowHead m_arrow_head_x;
- RenderableArrowHead m_arrow_head_y;
- RenderableArrowHead m_arrow_head_z;
- RenderableQuad m_quad_screen;
- SelectableBool m_selectable_x;
- SelectableBool m_selectable_y;
- SelectableBool m_selectable_z;
- SelectableBool m_selectable_screen;
- Pivot2World m_pivot;
-public:
- static Shader* m_state_wire;
- static Shader* m_state_fill;
+};
+
+void vector3_print(const Vector3 &v)
+{
+ globalOutputStream() << "( " << v.x() << " " << v.y() << " " << v.z() << " )";
+}
- TranslateManipulator(Translatable& translatable, std::size_t segments, float length) :
- m_free(translatable),
- m_axis(translatable),
- m_arrow_head_x(3 * 2 * (segments << 3)),
- m_arrow_head_y(3 * 2 * (segments << 3)),
- m_arrow_head_z(3 * 2 * (segments << 3))
- {
- draw_arrowline(length, m_arrow_x.m_line, 0);
- draw_arrowhead(segments, length, m_arrow_head_x.m_vertices.data(), TripleRemapXYZ<Vertex3f>(), TripleRemapXYZ<Normal3f>());
- draw_arrowline(length, m_arrow_y.m_line, 1);
- draw_arrowhead(segments, length, m_arrow_head_y.m_vertices.data(), TripleRemapYZX<Vertex3f>(), TripleRemapYZX<Normal3f>());
- draw_arrowline(length, m_arrow_z.m_line, 2);
- draw_arrowhead(segments, length, m_arrow_head_z.m_vertices.data(), TripleRemapZXY<Vertex3f>(), TripleRemapZXY<Normal3f>());
+class TranslateManipulator : public Manipulator {
+ struct RenderableArrowLine : public OpenGLRenderable {
+ PointVertex m_line[2];
- draw_quad(16, m_quad_screen.m_quad);
- }
+ RenderableArrowLine()
+ {
+ }
+
+ void render(RenderStateFlags state) const
+ {
+ glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(PointVertex), &m_line[0].colour);
+ glVertexPointer(3, GL_FLOAT, sizeof(PointVertex), &m_line[0].vertex);
+ glDrawArrays(GL_LINES, 0, 2);
+ }
- void UpdateColours()
- {
- m_arrow_x.setColour(colourSelected(g_colour_x, m_selectable_x.isSelected()));
- m_arrow_head_x.setColour(colourSelected(g_colour_x, m_selectable_x.isSelected()));
- m_arrow_y.setColour(colourSelected(g_colour_y, m_selectable_y.isSelected()));
- m_arrow_head_y.setColour(colourSelected(g_colour_y, m_selectable_y.isSelected()));
- m_arrow_z.setColour(colourSelected(g_colour_z, m_selectable_z.isSelected()));
- m_arrow_head_z.setColour(colourSelected(g_colour_z, m_selectable_z.isSelected()));
- m_quad_screen.setColour(colourSelected(g_colour_screen, m_selectable_screen.isSelected()));
- }
+ void setColour(const Colour4b &colour)
+ {
+ m_line[0].colour = colour;
+ m_line[1].colour = colour;
+ }
+ };
- bool manipulator_show_axis(const Pivot2World& pivot, const Vector3& axis)
- {
- return fabs(vector3_dot(pivot.m_axis_screen, axis)) < 0.95;
- }
+ struct RenderableArrowHead : public OpenGLRenderable {
+ Array<FlatShadedVertex> m_vertices;
- void render(Renderer& renderer, const VolumeTest& volume, const Matrix4& pivot2world)
- {
- m_pivot.update(pivot2world, volume.GetModelview(), volume.GetProjection(), volume.GetViewport());
+ RenderableArrowHead(std::size_t size)
+ : m_vertices(size)
+ {
+ }
- // temp hack
- UpdateColours();
+ void render(RenderStateFlags state) const
+ {
+ glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(FlatShadedVertex), &m_vertices.data()->colour);
+ glVertexPointer(3, GL_FLOAT, sizeof(FlatShadedVertex), &m_vertices.data()->vertex);
+ glNormalPointer(GL_FLOAT, sizeof(FlatShadedVertex), &m_vertices.data()->normal);
+ glDrawArrays(GL_TRIANGLES, 0, GLsizei(m_vertices.size()));
+ }
- Vector3 x = vector3_normalised(vector4_to_vector3(m_pivot.m_worldSpace.x()));
- bool show_x = manipulator_show_axis(m_pivot, x);
+ void setColour(const Colour4b &colour)
+ {
+ for (Array<FlatShadedVertex>::iterator i = m_vertices.begin(); i != m_vertices.end(); ++i) {
+ (*i).colour = colour;
+ }
+ }
+ };
- Vector3 y = vector3_normalised(vector4_to_vector3(m_pivot.m_worldSpace.y()));
- bool show_y = manipulator_show_axis(m_pivot, y);
+ struct RenderableQuad : public OpenGLRenderable {
+ PointVertex m_quad[4];
- Vector3 z = vector3_normalised(vector4_to_vector3(m_pivot.m_worldSpace.z()));
- bool show_z = manipulator_show_axis(m_pivot, z);
+ void render(RenderStateFlags state) const
+ {
+ glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(PointVertex), &m_quad[0].colour);
+ glVertexPointer(3, GL_FLOAT, sizeof(PointVertex), &m_quad[0].vertex);
+ glDrawArrays(GL_LINE_LOOP, 0, 4);
+ }
- renderer.SetState(m_state_wire, Renderer::eWireframeOnly);
- renderer.SetState(m_state_wire, Renderer::eFullMaterials);
+ void setColour(const Colour4b &colour)
+ {
+ m_quad[0].colour = colour;
+ m_quad[1].colour = colour;
+ m_quad[2].colour = colour;
+ m_quad[3].colour = colour;
+ }
+ };
+
+ TranslateFree m_free;
+ TranslateAxis m_axis;
+ RenderableArrowLine m_arrow_x;
+ RenderableArrowLine m_arrow_y;
+ RenderableArrowLine m_arrow_z;
+ RenderableArrowHead m_arrow_head_x;
+ RenderableArrowHead m_arrow_head_y;
+ RenderableArrowHead m_arrow_head_z;
+ RenderableQuad m_quad_screen;
+ SelectableBool m_selectable_x;
+ SelectableBool m_selectable_y;
+ SelectableBool m_selectable_z;
+ SelectableBool m_selectable_screen;
+ Pivot2World m_pivot;
+public:
+ static Shader *m_state_wire;
+ static Shader *m_state_fill;
- if(show_x)
+ TranslateManipulator(Translatable &translatable, std::size_t segments, float length) :
+ m_free(translatable),
+ m_axis(translatable),
+ m_arrow_head_x(3 * 2 * (segments << 3)),
+ m_arrow_head_y(3 * 2 * (segments << 3)),
+ m_arrow_head_z(3 * 2 * (segments << 3))
{
- renderer.addRenderable(m_arrow_x, m_pivot.m_worldSpace);
+ draw_arrowline(length, m_arrow_x.m_line, 0);
+ draw_arrowhead(segments, length, m_arrow_head_x.m_vertices.data(), TripleRemapXYZ<Vertex3f>(),
+ TripleRemapXYZ<Normal3f>());
+ draw_arrowline(length, m_arrow_y.m_line, 1);
+ draw_arrowhead(segments, length, m_arrow_head_y.m_vertices.data(), TripleRemapYZX<Vertex3f>(),
+ TripleRemapYZX<Normal3f>());
+ draw_arrowline(length, m_arrow_z.m_line, 2);
+ draw_arrowhead(segments, length, m_arrow_head_z.m_vertices.data(), TripleRemapZXY<Vertex3f>(),
+ TripleRemapZXY<Normal3f>());
+
+ draw_quad(16, m_quad_screen.m_quad);
}
- if(show_y)
+
+ void UpdateColours()
{
- renderer.addRenderable(m_arrow_y, m_pivot.m_worldSpace);
+ m_arrow_x.setColour(colourSelected(g_colour_x, m_selectable_x.isSelected()));
+ m_arrow_head_x.setColour(colourSelected(g_colour_x, m_selectable_x.isSelected()));
+ m_arrow_y.setColour(colourSelected(g_colour_y, m_selectable_y.isSelected()));
+ m_arrow_head_y.setColour(colourSelected(g_colour_y, m_selectable_y.isSelected()));
+ m_arrow_z.setColour(colourSelected(g_colour_z, m_selectable_z.isSelected()));
+ m_arrow_head_z.setColour(colourSelected(g_colour_z, m_selectable_z.isSelected()));
+ m_quad_screen.setColour(colourSelected(g_colour_screen, m_selectable_screen.isSelected()));
}
- if(show_z)
+
+ bool manipulator_show_axis(const Pivot2World &pivot, const Vector3 &axis)
{
- renderer.addRenderable(m_arrow_z, m_pivot.m_worldSpace);
+ return fabs(vector3_dot(pivot.m_axis_screen, axis)) < 0.95;
}
- renderer.addRenderable(m_quad_screen, m_pivot.m_viewplaneSpace);
+ void render(Renderer &renderer, const VolumeTest &volume, const Matrix4 &pivot2world)
+ {
+ m_pivot.update(pivot2world, volume.GetModelview(), volume.GetProjection(), volume.GetViewport());
- renderer.SetState(m_state_fill, Renderer::eWireframeOnly);
- renderer.SetState(m_state_fill, Renderer::eFullMaterials);
+ // temp hack
+ UpdateColours();
- if(show_x)
- {
- renderer.addRenderable(m_arrow_head_x, m_pivot.m_worldSpace);
- }
- if(show_y)
- {
- renderer.addRenderable(m_arrow_head_y, m_pivot.m_worldSpace);
- }
- if(show_z)
- {
- renderer.addRenderable(m_arrow_head_z, m_pivot.m_worldSpace);
- }
- }
- void testSelect(const View& view, const Matrix4& pivot2world)
- {
- m_pivot.update(pivot2world, view.GetModelview(), view.GetProjection(), view.GetViewport());
+ Vector3 x = vector3_normalised(vector4_to_vector3(m_pivot.m_worldSpace.x()));
+ bool show_x = manipulator_show_axis(m_pivot, x);
+
+ Vector3 y = vector3_normalised(vector4_to_vector3(m_pivot.m_worldSpace.y()));
+ bool show_y = manipulator_show_axis(m_pivot, y);
- SelectionPool selector;
+ Vector3 z = vector3_normalised(vector4_to_vector3(m_pivot.m_worldSpace.z()));
+ bool show_z = manipulator_show_axis(m_pivot, z);
- Vector3 x = vector3_normalised(vector4_to_vector3(m_pivot.m_worldSpace.x()));
- bool show_x = manipulator_show_axis(m_pivot, x);
+ renderer.SetState(m_state_wire, Renderer::eWireframeOnly);
+ renderer.SetState(m_state_wire, Renderer::eFullMaterials);
- Vector3 y = vector3_normalised(vector4_to_vector3(m_pivot.m_worldSpace.y()));
- bool show_y = manipulator_show_axis(m_pivot, y);
+ if (show_x) {
+ renderer.addRenderable(m_arrow_x, m_pivot.m_worldSpace);
+ }
+ if (show_y) {
+ renderer.addRenderable(m_arrow_y, m_pivot.m_worldSpace);
+ }
+ if (show_z) {
+ renderer.addRenderable(m_arrow_z, m_pivot.m_worldSpace);
+ }
- Vector3 z = vector3_normalised(vector4_to_vector3(m_pivot.m_worldSpace.z()));
- bool show_z = manipulator_show_axis(m_pivot, z);
+ renderer.addRenderable(m_quad_screen, m_pivot.m_viewplaneSpace);
- {
- Matrix4 local2view(matrix4_multiplied_by_matrix4(view.GetViewMatrix(), m_pivot.m_viewpointSpace));
+ renderer.SetState(m_state_fill, Renderer::eWireframeOnly);
+ renderer.SetState(m_state_fill, Renderer::eFullMaterials);
- {
- SelectionIntersection best;
- Quad_BestPoint(local2view, eClipCullCW, m_quad_screen.m_quad, best);
- if(best.valid())
- {
- best = SelectionIntersection(0, 0);
- selector.addSelectable(best, &m_selectable_screen);
+ if (show_x) {
+ renderer.addRenderable(m_arrow_head_x, m_pivot.m_worldSpace);
+ }
+ if (show_y) {
+ renderer.addRenderable(m_arrow_head_y, m_pivot.m_worldSpace);
+ }
+ if (show_z) {
+ renderer.addRenderable(m_arrow_head_z, m_pivot.m_worldSpace);
}
- }
}
+ void testSelect(const View &view, const Matrix4 &pivot2world)
{
- Matrix4 local2view(matrix4_multiplied_by_matrix4(view.GetViewMatrix(), m_pivot.m_worldSpace));
+ m_pivot.update(pivot2world, view.GetModelview(), view.GetProjection(), view.GetViewport());
+
+ SelectionPool selector;
+
+ Vector3 x = vector3_normalised(vector4_to_vector3(m_pivot.m_worldSpace.x()));
+ bool show_x = manipulator_show_axis(m_pivot, x);
+
+ Vector3 y = vector3_normalised(vector4_to_vector3(m_pivot.m_worldSpace.y()));
+ bool show_y = manipulator_show_axis(m_pivot, y);
+
+ Vector3 z = vector3_normalised(vector4_to_vector3(m_pivot.m_worldSpace.z()));
+ bool show_z = manipulator_show_axis(m_pivot, z);
+
+ {
+ Matrix4 local2view(matrix4_multiplied_by_matrix4(view.GetViewMatrix(), m_pivot.m_viewpointSpace));
+
+ {
+ SelectionIntersection best;
+ Quad_BestPoint(local2view, eClipCullCW, m_quad_screen.m_quad, best);
+ if (best.valid()) {
+ best = SelectionIntersection(0, 0);
+ selector.addSelectable(best, &m_selectable_screen);
+ }
+ }
+ }
-#if defined(DEBUG_SELECTION)
- g_render_clipped.construct(view.GetViewMatrix());
+ {
+ Matrix4 local2view(matrix4_multiplied_by_matrix4(view.GetViewMatrix(), m_pivot.m_worldSpace));
+
+#if defined( DEBUG_SELECTION )
+ g_render_clipped.construct(view.GetViewMatrix());
#endif
- if(show_x)
- {
- SelectionIntersection best;
- Line_BestPoint(local2view, m_arrow_x.m_line, best);
- Triangles_BestPoint(local2view, eClipCullCW, m_arrow_head_x.m_vertices.begin(), m_arrow_head_x.m_vertices.end(), best);
- selector.addSelectable(best, &m_selectable_x);
- }
+ if (show_x) {
+ SelectionIntersection best;
+ Line_BestPoint(local2view, m_arrow_x.m_line, best);
+ Triangles_BestPoint(local2view, eClipCullCW, m_arrow_head_x.m_vertices.begin(),
+ m_arrow_head_x.m_vertices.end(), best);
+ selector.addSelectable(best, &m_selectable_x);
+ }
+
+ if (show_y) {
+ SelectionIntersection best;
+ Line_BestPoint(local2view, m_arrow_y.m_line, best);
+ Triangles_BestPoint(local2view, eClipCullCW, m_arrow_head_y.m_vertices.begin(),
+ m_arrow_head_y.m_vertices.end(), best);
+ selector.addSelectable(best, &m_selectable_y);
+ }
- if(show_y)
- {
- SelectionIntersection best;
- Line_BestPoint(local2view, m_arrow_y.m_line, best);
- Triangles_BestPoint(local2view, eClipCullCW, m_arrow_head_y.m_vertices.begin(), m_arrow_head_y.m_vertices.end(), best);
- selector.addSelectable(best, &m_selectable_y);
- }
+ if (show_z) {
+ SelectionIntersection best;
+ Line_BestPoint(local2view, m_arrow_z.m_line, best);
+ Triangles_BestPoint(local2view, eClipCullCW, m_arrow_head_z.m_vertices.begin(),
+ m_arrow_head_z.m_vertices.end(), best);
+ selector.addSelectable(best, &m_selectable_z);
+ }
+ }
- if(show_z)
- {
- SelectionIntersection best;
- Line_BestPoint(local2view, m_arrow_z.m_line, best);
- Triangles_BestPoint(local2view, eClipCullCW, m_arrow_head_z.m_vertices.begin(), m_arrow_head_z.m_vertices.end(), best);
- selector.addSelectable(best, &m_selectable_z);
- }
+ if (!selector.failed()) {
+ (*selector.begin()).second->setSelected(true);
+ }
}
- if(!selector.failed())
+ Manipulatable *GetManipulatable()
{
- (*selector.begin()).second->setSelected(true);
+ if (m_selectable_x.isSelected()) {
+ m_axis.SetAxis(g_vector3_axis_x);
+ return &m_axis;
+ } else if (m_selectable_y.isSelected()) {
+ m_axis.SetAxis(g_vector3_axis_y);
+ return &m_axis;
+ } else if (m_selectable_z.isSelected()) {
+ m_axis.SetAxis(g_vector3_axis_z);
+ return &m_axis;
+ } else {
+ return &m_free;
+ }
}
- }
- Manipulatable* GetManipulatable()
- {
- if(m_selectable_x.isSelected())
- {
- m_axis.SetAxis(g_vector3_axis_x);
- return &m_axis;
- }
- else if(m_selectable_y.isSelected())
+ void setSelected(bool select)
{
- m_axis.SetAxis(g_vector3_axis_y);
- return &m_axis;
+ m_selectable_x.setSelected(select);
+ m_selectable_y.setSelected(select);
+ m_selectable_z.setSelected(select);
+ m_selectable_screen.setSelected(select);
}
- else if(m_selectable_z.isSelected())
- {
- m_axis.SetAxis(g_vector3_axis_z);
- return &m_axis;
- }
- else
+
+ bool isSelected() const
{
- return &m_free;
+ return m_selectable_x.isSelected()
+ | m_selectable_y.isSelected()
+ | m_selectable_z.isSelected()
+ | m_selectable_screen.isSelected();
}
- }
-
- void setSelected(bool select)
- {
- m_selectable_x.setSelected(select);
- m_selectable_y.setSelected(select);
- m_selectable_z.setSelected(select);
- m_selectable_screen.setSelected(select);
- }
- bool isSelected() const
- {
- return m_selectable_x.isSelected()
- | m_selectable_y.isSelected()
- | m_selectable_z.isSelected()
- | m_selectable_screen.isSelected();
- }
};
-Shader* TranslateManipulator::m_state_wire;
-Shader* TranslateManipulator::m_state_fill;
+Shader *TranslateManipulator::m_state_wire;
+Shader *TranslateManipulator::m_state_fill;
-class ScaleManipulator : public Manipulator
-{
- struct RenderableArrow : public OpenGLRenderable
- {
- PointVertex m_line[2];
+class ScaleManipulator : public Manipulator {
+ struct RenderableArrow : public OpenGLRenderable {
+ PointVertex m_line[2];
- void render(RenderStateFlags state) const
+ void render(RenderStateFlags state) const
+ {
+ glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(PointVertex), &m_line[0].colour);
+ glVertexPointer(3, GL_FLOAT, sizeof(PointVertex), &m_line[0].vertex);
+ glDrawArrays(GL_LINES, 0, 2);
+ }
+
+ void setColour(const Colour4b &colour)
+ {
+ m_line[0].colour = colour;
+ m_line[1].colour = colour;
+ }
+ };
+
+ struct RenderableQuad : public OpenGLRenderable {
+ PointVertex m_quad[4];
+
+ void render(RenderStateFlags state) const
+ {
+ glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(PointVertex), &m_quad[0].colour);
+ glVertexPointer(3, GL_FLOAT, sizeof(PointVertex), &m_quad[0].vertex);
+ glDrawArrays(GL_QUADS, 0, 4);
+ }
+
+ void setColour(const Colour4b &colour)
+ {
+ m_quad[0].colour = colour;
+ m_quad[1].colour = colour;
+ m_quad[2].colour = colour;
+ m_quad[3].colour = colour;
+ }
+ };
+
+ ScaleFree m_free;
+ ScaleAxis m_axis;
+ RenderableArrow m_arrow_x;
+ RenderableArrow m_arrow_y;
+ RenderableArrow m_arrow_z;
+ RenderableQuad m_quad_screen;
+ SelectableBool m_selectable_x;
+ SelectableBool m_selectable_y;
+ SelectableBool m_selectable_z;
+ SelectableBool m_selectable_screen;
+ Pivot2World m_pivot;
+public:
+ ScaleManipulator(Scalable &scalable, std::size_t segments, float length) :
+ m_free(scalable),
+ m_axis(scalable)
{
- glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(PointVertex), &m_line[0].colour);
- glVertexPointer(3, GL_FLOAT, sizeof(PointVertex), &m_line[0].vertex);
- glDrawArrays(GL_LINES, 0, 2);
+ draw_arrowline(length, m_arrow_x.m_line, 0);
+ draw_arrowline(length, m_arrow_y.m_line, 1);
+ draw_arrowline(length, m_arrow_z.m_line, 2);
+
+ draw_quad(16, m_quad_screen.m_quad);
}
- void setColour(const Colour4b& colour)
+
+ Pivot2World &getPivot()
{
- m_line[0].colour = colour;
- m_line[1].colour = colour;
+ return m_pivot;
}
- };
- struct RenderableQuad : public OpenGLRenderable
- {
- PointVertex m_quad[4];
- void render(RenderStateFlags state) const
+
+ void UpdateColours()
{
- glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(PointVertex), &m_quad[0].colour);
- glVertexPointer(3, GL_FLOAT, sizeof(PointVertex), &m_quad[0].vertex);
- glDrawArrays(GL_QUADS, 0, 4);
- }
- void setColour(const Colour4b& colour)
- {
- m_quad[0].colour = colour;
- m_quad[1].colour = colour;
- m_quad[2].colour = colour;
- m_quad[3].colour = colour;
- }
- };
-
- ScaleFree m_free;
- ScaleAxis m_axis;
- RenderableArrow m_arrow_x;
- RenderableArrow m_arrow_y;
- RenderableArrow m_arrow_z;
- RenderableQuad m_quad_screen;
- SelectableBool m_selectable_x;
- SelectableBool m_selectable_y;
- SelectableBool m_selectable_z;
- SelectableBool m_selectable_screen;
- Pivot2World m_pivot;
-public:
- ScaleManipulator(Scalable& scalable, std::size_t segments, float length) :
- m_free(scalable),
- m_axis(scalable)
- {
- draw_arrowline(length, m_arrow_x.m_line, 0);
- draw_arrowline(length, m_arrow_y.m_line, 1);
- draw_arrowline(length, m_arrow_z.m_line, 2);
-
- draw_quad(16, m_quad_screen.m_quad);
- }
-
- Pivot2World& getPivot()
- {
- return m_pivot;
- }
-
- void UpdateColours()
- {
- m_arrow_x.setColour(colourSelected(g_colour_x, m_selectable_x.isSelected()));
- m_arrow_y.setColour(colourSelected(g_colour_y, m_selectable_y.isSelected()));
- m_arrow_z.setColour(colourSelected(g_colour_z, m_selectable_z.isSelected()));
- m_quad_screen.setColour(colourSelected(g_colour_screen, m_selectable_screen.isSelected()));
- }
-
- void render(Renderer& renderer, const VolumeTest& volume, const Matrix4& pivot2world)
- {
- m_pivot.update(pivot2world, volume.GetModelview(), volume.GetProjection(), volume.GetViewport());
-
- // temp hack
- UpdateColours();
-
- renderer.addRenderable(m_arrow_x, m_pivot.m_worldSpace);
- renderer.addRenderable(m_arrow_y, m_pivot.m_worldSpace);
- renderer.addRenderable(m_arrow_z, m_pivot.m_worldSpace);
-
- renderer.addRenderable(m_quad_screen, m_pivot.m_viewpointSpace);
- }
- void testSelect(const View& view, const Matrix4& pivot2world)
- {
- m_pivot.update(pivot2world, view.GetModelview(), view.GetProjection(), view.GetViewport());
-
- SelectionPool selector;
-
- {
- Matrix4 local2view(matrix4_multiplied_by_matrix4(view.GetViewMatrix(), m_pivot.m_worldSpace));
-
-#if defined(DEBUG_SELECTION)
- g_render_clipped.construct(view.GetViewMatrix());
-#endif
+ m_arrow_x.setColour(colourSelected(g_colour_x, m_selectable_x.isSelected()));
+ m_arrow_y.setColour(colourSelected(g_colour_y, m_selectable_y.isSelected()));
+ m_arrow_z.setColour(colourSelected(g_colour_z, m_selectable_z.isSelected()));
+ m_quad_screen.setColour(colourSelected(g_colour_screen, m_selectable_screen.isSelected()));
+ }
+ void render(Renderer &renderer, const VolumeTest &volume, const Matrix4 &pivot2world)
{
- SelectionIntersection best;
- Line_BestPoint(local2view, m_arrow_x.m_line, best);
- selector.addSelectable(best, &m_selectable_x);
- }
+ m_pivot.update(pivot2world, volume.GetModelview(), volume.GetProjection(), volume.GetViewport());
- {
- SelectionIntersection best;
- Line_BestPoint(local2view, m_arrow_y.m_line, best);
- selector.addSelectable(best, &m_selectable_y);
- }
+ // temp hack
+ UpdateColours();
- {
- SelectionIntersection best;
- Line_BestPoint(local2view, m_arrow_z.m_line, best);
- selector.addSelectable(best, &m_selectable_z);
- }
+ renderer.addRenderable(m_arrow_x, m_pivot.m_worldSpace);
+ renderer.addRenderable(m_arrow_y, m_pivot.m_worldSpace);
+ renderer.addRenderable(m_arrow_z, m_pivot.m_worldSpace);
+
+ renderer.addRenderable(m_quad_screen, m_pivot.m_viewpointSpace);
}
+ void testSelect(const View &view, const Matrix4 &pivot2world)
{
- Matrix4 local2view(matrix4_multiplied_by_matrix4(view.GetViewMatrix(), m_pivot.m_viewpointSpace));
+ m_pivot.update(pivot2world, view.GetModelview(), view.GetProjection(), view.GetViewport());
- {
- SelectionIntersection best;
- Quad_BestPoint(local2view, eClipCullCW, m_quad_screen.m_quad, best);
- selector.addSelectable(best, &m_selectable_screen);
- }
- }
+ SelectionPool selector;
- if(!selector.failed())
- {
- (*selector.begin()).second->setSelected(true);
+ {
+ Matrix4 local2view(matrix4_multiplied_by_matrix4(view.GetViewMatrix(), m_pivot.m_worldSpace));
+
+#if defined( DEBUG_SELECTION )
+ g_render_clipped.construct(view.GetViewMatrix());
+#endif
+
+ {
+ SelectionIntersection best;
+ Line_BestPoint(local2view, m_arrow_x.m_line, best);
+ selector.addSelectable(best, &m_selectable_x);
+ }
+
+ {
+ SelectionIntersection best;
+ Line_BestPoint(local2view, m_arrow_y.m_line, best);
+ selector.addSelectable(best, &m_selectable_y);
+ }
+
+ {
+ SelectionIntersection best;
+ Line_BestPoint(local2view, m_arrow_z.m_line, best);
+ selector.addSelectable(best, &m_selectable_z);
+ }
+ }
+
+ {
+ Matrix4 local2view(matrix4_multiplied_by_matrix4(view.GetViewMatrix(), m_pivot.m_viewpointSpace));
+
+ {
+ SelectionIntersection best;
+ Quad_BestPoint(local2view, eClipCullCW, m_quad_screen.m_quad, best);
+ selector.addSelectable(best, &m_selectable_screen);
+ }
+ }
+
+ if (!selector.failed()) {
+ (*selector.begin()).second->setSelected(true);
+ }
}
- }
- Manipulatable* GetManipulatable()
- {
- if(m_selectable_x.isSelected())
+ Manipulatable *GetManipulatable()
{
- m_axis.SetAxis(g_vector3_axis_x);
- return &m_axis;
+ if (m_selectable_x.isSelected()) {
+ m_axis.SetAxis(g_vector3_axis_x);
+ return &m_axis;
+ } else if (m_selectable_y.isSelected()) {
+ m_axis.SetAxis(g_vector3_axis_y);
+ return &m_axis;
+ } else if (m_selectable_z.isSelected()) {
+ m_axis.SetAxis(g_vector3_axis_z);
+ return &m_axis;
+ } else {
+ return &m_free;
+ }
}
- else if(m_selectable_y.isSelected())
+
+ void setSelected(bool select)
{
- m_axis.SetAxis(g_vector3_axis_y);
- return &m_axis;
+ m_selectable_x.setSelected(select);
+ m_selectable_y.setSelected(select);
+ m_selectable_z.setSelected(select);
+ m_selectable_screen.setSelected(select);
}
- else if(m_selectable_z.isSelected())
+
+ bool isSelected() const
{
- m_axis.SetAxis(g_vector3_axis_z);
- return &m_axis;
+ return m_selectable_x.isSelected()
+ | m_selectable_y.isSelected()
+ | m_selectable_z.isSelected()
+ | m_selectable_screen.isSelected();
}
- else
- return &m_free;
- }
-
- void setSelected(bool select)
- {
- m_selectable_x.setSelected(select);
- m_selectable_y.setSelected(select);
- m_selectable_z.setSelected(select);
- m_selectable_screen.setSelected(select);
- }
- bool isSelected() const
- {
- return m_selectable_x.isSelected()
- | m_selectable_y.isSelected()
- | m_selectable_z.isSelected()
- | m_selectable_screen.isSelected();
- }
};
-inline PlaneSelectable* Instance_getPlaneSelectable(scene::Instance& instance)
+inline PlaneSelectable *Instance_getPlaneSelectable(scene::Instance &instance)
{
- return InstanceTypeCast<PlaneSelectable>::cast(instance);
+
return InstanceTypeCast<PlaneSelectable>::cast(instance);
}
-class PlaneSelectableSelectPlanes : public scene::Graph::Walker
-{
- Selector& m_selector;
- SelectionTest& m_test;
- PlaneCallback m_selectedPlaneCallback;
+class PlaneSelectableSelectPlanes : public scene::Graph::Walker {
+ Selector &m_selector;
+ SelectionTest &m_test;
+ PlaneCallback m_selectedPlaneCallback;
public:
- PlaneSelectableSelectPlanes(Selector& selector, SelectionTest& test, const PlaneCallback& selectedPlaneCallback)
- : m_selector(selector), m_test(test), m_selectedPlaneCallback(selectedPlaneCallback)
- {
- }
- bool pre(const scene::Path& path, scene::Instance& instance) const
- {
- if(path.top().get().visible())
- {
- Selectable* selectable = Instance_getSelectable(instance);
- if(selectable != 0 && selectable->isSelected())
- {
- PlaneSelectable* planeSelectable = Instance_getPlaneSelectable(instance);
- if(planeSelectable != 0)
- {
- planeSelectable->selectPlanes(m_selector, m_test, m_selectedPlaneCallback);
+ PlaneSelectableSelectPlanes(Selector &selector, SelectionTest &test, const PlaneCallback &selectedPlaneCallback)
+ : m_selector(selector), m_test(test), m_selectedPlaneCallback(selectedPlaneCallback)
+ {
+ }
+
+ bool pre(const scene::Path &path, scene::Instance &instance) const
+ {
+ if (path.top().get().visible()) {
+ Selectable *selectable = Instance_getSelectable(instance);
+ if (selectable != 0 && selectable->isSelected()) {
+ PlaneSelectable *planeSelectable = Instance_getPlaneSelectable(instance);
+ if (planeSelectable != 0) {
+ planeSelectable->selectPlanes(m_selector, m_test, m_selectedPlaneCallback);
+ }
+ }
}
- }
+ return true;
}
- return true;
- }
};
-class PlaneSelectableSelectReversedPlanes : public scene::Graph::Walker
-{
- Selector& m_selector;
- const SelectedPlanes& m_selectedPlanes;
+class PlaneSelectableSelectReversedPlanes : public scene::Graph::Walker {
+ Selector &m_selector;
+ const SelectedPlanes &m_selectedPlanes;
public:
- PlaneSelectableSelectReversedPlanes(Selector& selector, const SelectedPlanes& selectedPlanes)
- : m_selector(selector), m_selectedPlanes(selectedPlanes)
- {
- }
- bool pre(const scene::Path& path, scene::Instance& instance) const
- {
- if(path.top().get().visible())
- {
- Selectable* selectable = Instance_getSelectable(instance);
- if(selectable != 0 && selectable->isSelected())
- {
- PlaneSelectable* planeSelectable = Instance_getPlaneSelectable(instance);
- if(planeSelectable != 0)
- {
- planeSelectable->selectReversedPlanes(m_selector, m_selectedPlanes);
+ PlaneSelectableSelectReversedPlanes(Selector &selector, const SelectedPlanes &selectedPlanes)
+ : m_selector(selector), m_selectedPlanes(selectedPlanes)
+ {
+ }
+
+ bool pre(const scene::Path &path, scene::Instance &instance) const
+ {
+ if (path.top().get().visible()) {
+ Selectable *selectable = Instance_getSelectable(instance);
+ if (selectable != 0 && selectable->isSelected()) {
+ PlaneSelectable *planeSelectable = Instance_getPlaneSelectable(instance);
+ if (planeSelectable != 0) {
+ planeSelectable->selectReversedPlanes(m_selector, m_selectedPlanes);
+ }
+ }
}
- }
+ return true;
}
- return true;
- }
};
-void Scene_forEachPlaneSelectable_selectPlanes(scene::Graph& graph, Selector& selector, SelectionTest& test, const PlaneCallback& selectedPlaneCallback)
+void Scene_forEachPlaneSelectable_selectPlanes(scene::Graph &graph, Selector &selector, SelectionTest &test,
+ const PlaneCallback &selectedPlaneCallback)
{
- graph.traverse(PlaneSelectableSelectPlanes(selector, test, selectedPlaneCallback));
+ graph.traverse(PlaneSelectableSelectPlanes(selector, test, selectedPlaneCallback));
}
-void Scene_forEachPlaneSelectable_selectReversedPlanes(scene::Graph& graph, Selector& selector, const SelectedPlanes& selectedPlanes)
+void Scene_forEachPlaneSelectable_selectReversedPlanes(scene::Graph &graph, Selector &selector,
+ const SelectedPlanes &selectedPlanes)
{
- graph.traverse(PlaneSelectableSelectReversedPlanes(selector, selectedPlanes));
+ graph.traverse(PlaneSelectableSelectReversedPlanes(selector, selectedPlanes));
}
-class PlaneLess
-{
+class PlaneLess {
public:
- bool operator()(const Plane3& plane, const Plane3& other) const
- {
- if(plane.a < other.a)
+ bool operator()(const Plane3 &plane, const Plane3 &other) const
{
- return true;
- }
- if(other.a < plane.a)
- {
- return false;
- }
+ if (plane.a < other.a) {
+ return true;
+ }
+ if (other.a < plane.a) {
+ return false;
+ }
- if(plane.b < other.b)
- {
- return true;
- }
- if(other.b < plane.b)
- {
- return false;
- }
+ if (plane.b < other.b) {
+ return true;
+ }
+ if (other.b < plane.b) {
+ return false;
+ }
- if(plane.c < other.c)
- {
- return true;
- }
- if(other.c < plane.c)
- {
- return false;
- }
+ if (plane.c < other.c) {
+ return true;
+ }
+ if (other.c < plane.c) {
+ return false;
+ }
- if(plane.d < other.d)
- {
- return true;
- }
- if(other.d < plane.d)
- {
- return false;
- }
+ if (plane.d < other.d) {
+ return true;
+ }
+ if (other.d < plane.d) {
+ return false;
+ }
- return false;
- }
+ return false;
+ }
};
typedef std::set<Plane3, PlaneLess> PlaneSet;
-inline void PlaneSet_insert(PlaneSet& self, const Plane3& plane)
+inline void PlaneSet_insert(PlaneSet &self, const Plane3 &plane)
{
- self.insert(plane);
+ self.insert(plane);
}
-inline bool PlaneSet_contains(const PlaneSet& self, const Plane3& plane)
+inline bool PlaneSet_contains(const PlaneSet &self, const Plane3 &plane)
{
- return self.find(plane) != self.end();
+ return self.find(plane) != self.end();
}
-class SelectedPlaneSet : public SelectedPlanes
-{
- PlaneSet m_selectedPlanes;
+class SelectedPlaneSet : public SelectedPlanes {
+ PlaneSet m_selectedPlanes;
public:
- bool empty() const
- {
- return m_selectedPlanes.empty();
- }
-
- void insert(const Plane3& plane)
- {
- PlaneSet_insert(m_selectedPlanes, plane);
- }
- bool contains(const Plane3& plane) const
- {
- return PlaneSet_contains(m_selectedPlanes, plane);
- }
- typedef MemberCaller1<SelectedPlaneSet, const Plane3&, &SelectedPlaneSet::insert> InsertCaller;
+ bool empty() const
+ {
+ return m_selectedPlanes.empty();
+ }
+
+ void insert(const Plane3 &plane)
+ {
+ PlaneSet_insert(m_selectedPlanes, plane);
+ }
+
+ bool contains(const Plane3 &plane) const
+ {
+ return PlaneSet_contains(m_selectedPlanes, plane);
+ }
+
+ typedef MemberCaller<SelectedPlaneSet, void(const Plane3 &), &SelectedPlaneSet::insert> InsertCaller;
};
-bool Scene_forEachPlaneSelectable_selectPlanes(scene::Graph& graph, Selector& selector, SelectionTest& test)
+bool Scene_forEachPlaneSelectable_selectPlanes(scene::Graph &graph, Selector &selector, SelectionTest &test)
{
- SelectedPlaneSet selectedPlanes;
+ SelectedPlaneSet selectedPlanes;
- Scene_forEachPlaneSelectable_selectPlanes(graph, selector, test, SelectedPlaneSet::InsertCaller(selectedPlanes));
- Scene_forEachPlaneSelectable_selectReversedPlanes(graph, selector, selectedPlanes);
+ Scene_forEachPlaneSelectable_selectPlanes(graph, selector, test, SelectedPlaneSet::InsertCaller(selectedPlanes));
+ Scene_forEachPlaneSelectable_selectReversedPlanes(graph, selector, selectedPlanes);
- return !selectedPlanes.empty();
+ return !selectedPlanes.empty();
}
-void Scene_Translate_Component_Selected(scene::Graph& graph, const Vector3& translation);
-void Scene_Translate_Selected(scene::Graph& graph, const Vector3& translation);
-void Scene_TestSelect_Primitive(Selector& selector, SelectionTest& test, const VolumeTest& volume);
-void Scene_TestSelect_Component(Selector& selector, SelectionTest& test, const VolumeTest& volume, SelectionSystem::EComponentMode componentMode);
-void Scene_TestSelect_Component_Selected(Selector& selector, SelectionTest& test, const VolumeTest& volume, SelectionSystem::EComponentMode componentMode);
-void Scene_SelectAll_Component(bool select, SelectionSystem::EComponentMode componentMode);
+void Scene_Translate_Component_Selected(scene::Graph &graph, const Vector3 &translation);
-class ResizeTranslatable : public Translatable
-{
- void translate(const Vector3& translation)
- {
- Scene_Translate_Component_Selected(GlobalSceneGraph(), translation);
- }
-};
+void Scene_Translate_Selected(scene::Graph &graph, const Vector3 &translation);
-class DragTranslatable : public Translatable
-{
- void translate(const Vector3& translation)
- {
- if(GlobalSelectionSystem().Mode() == SelectionSystem::eComponent)
+void Scene_TestSelect_Primitive(Selector &selector, SelectionTest &test, const VolumeTest &volume);
+
+void Scene_TestSelect_Component(Selector &selector, SelectionTest &test, const VolumeTest &volume,
+ SelectionSystem::EComponentMode componentMode);
+
+void Scene_TestSelect_Component_Selected(Selector &selector, SelectionTest &test, const VolumeTest &volume,
+ SelectionSystem::EComponentMode componentMode);
+
+void Scene_SelectAll_Component(bool select, SelectionSystem::EComponentMode componentMode);
+
+class ResizeTranslatable : public Translatable {
+ void translate(const Vector3 &translation)
{
- Scene_Translate_Component_Selected(GlobalSceneGraph(), translation);
+ Scene_Translate_Component_Selected(GlobalSceneGraph(), translation);
}
- else
+};
+
+class DragTranslatable : public Translatable {
+ void translate(const Vector3 &translation)
{
- Scene_Translate_Selected(GlobalSceneGraph(), translation);
+ if (GlobalSelectionSystem().Mode() == SelectionSystem::eComponent) {
+ Scene_Translate_Component_Selected(GlobalSceneGraph(), translation);
+ } else {
+ Scene_Translate_Selected(GlobalSceneGraph(), translation);
+ }
}
- }
};
-class SelectionVolume : public SelectionTest
-{
- Matrix4 m_local2view;
- const View& m_view;
- clipcull_t m_cull;
- Vector3 m_near;
- Vector3 m_far;
+class SelectionVolume : public SelectionTest {
+ Matrix4 m_local2view;
+ const View &m_view;
+ clipcull_t m_cull;
+ Vector3 m_near;
+ Vector3 m_far;
public:
- SelectionVolume(const View& view)
- : m_view(view)
- {
- }
-
- const VolumeTest& getVolume() const
- {
- return m_view;
- }
-
- const Vector3& getNear() const
- {
- return m_near;
- }
- const Vector3& getFar() const
- {
- return m_far;
- }
-
- void BeginMesh(const Matrix4& localToWorld, bool twoSided)
- {
- m_local2view = matrix4_multiplied_by_matrix4(m_view.GetViewMatrix(), localToWorld);
-
- // Cull back-facing polygons based on winding being clockwise or counter-clockwise.
- // Don't cull if the view is wireframe and the polygons are two-sided.
- m_cull = twoSided && !m_view.fill() ? eClipCullNone : (matrix4_handedness(localToWorld) == MATRIX4_RIGHTHANDED) ? eClipCullCW : eClipCullCCW;
-
- {
- Matrix4 screen2world(matrix4_full_inverse(m_local2view));
-
- m_near = vector4_projected(
- matrix4_transformed_vector4(
- screen2world,
- Vector4(0, 0, -1, 1)
- )
- );
-
- m_far = vector4_projected(
- matrix4_transformed_vector4(
- screen2world,
- Vector4(0, 0, 1, 1)
- )
- );
- }
-
-#if defined(DEBUG_SELECTION)
- g_render_clipped.construct(m_view.GetViewMatrix());
-#endif
- }
- void TestPoint(const Vector3& point, SelectionIntersection& best)
- {
- Vector4 clipped;
- if(matrix4_clip_point(m_local2view, point, clipped) == c_CLIP_PASS)
+ SelectionVolume(const View &view)
+ : m_view(view)
{
- best = select_point_from_clipped(clipped);
}
- }
- void TestPolygon(const VertexPointer& vertices, std::size_t count, SelectionIntersection& best)
- {
- Vector4 clipped[9];
- for(std::size_t i=0; i+2<count; ++i)
- {
- BestPoint(
- matrix4_clip_triangle(
- m_local2view,
- reinterpret_cast<const Vector3&>(vertices[0]),
- reinterpret_cast<const Vector3&>(vertices[i+1]),
- reinterpret_cast<const Vector3&>(vertices[i+2]),
- clipped
- ),
- clipped,
- best,
- m_cull
- );
- }
- }
- void TestLineLoop(const VertexPointer& vertices, std::size_t count, SelectionIntersection& best)
- {
- if(count == 0)
- return;
- Vector4 clipped[9];
- for(VertexPointer::iterator i = vertices.begin(), end = i + count, prev = i + (count-1); i != end; prev = i, ++i)
- {
- BestPoint(
- matrix4_clip_line(
- m_local2view,
- reinterpret_cast<const Vector3&>((*prev)),
- reinterpret_cast<const Vector3&>((*i)),
- clipped
- ),
- clipped,
- best,
- m_cull
- );
- }
- }
- void TestLineStrip(const VertexPointer& vertices, std::size_t count, SelectionIntersection& best)
- {
- if(count == 0)
- return;
- Vector4 clipped[9];
- for(VertexPointer::iterator i = vertices.begin(), end = i + count, next = i + 1; next != end; i = next, ++next)
- {
- BestPoint(
- matrix4_clip_line(
- m_local2view,
- reinterpret_cast<const Vector3&>((*i)),
- reinterpret_cast<const Vector3&>((*next)),
- clipped
- ),
- clipped,
- best,
- m_cull
- );
- }
- }
- void TestLines(const VertexPointer& vertices, std::size_t count, SelectionIntersection& best)
- {
- if(count == 0)
- return;
- Vector4 clipped[9];
- for(VertexPointer::iterator i = vertices.begin(), end = i + count; i != end; i += 2)
- {
- BestPoint(
- matrix4_clip_line(
- m_local2view,
- reinterpret_cast<const Vector3&>((*i)),
- reinterpret_cast<const Vector3&>((*(i+1))),
- clipped
- ),
- clipped,
- best,
- m_cull
- );
- }
- }
- void TestTriangles(const VertexPointer& vertices, const IndexPointer& indices, SelectionIntersection& best)
- {
- Vector4 clipped[9];
- for(IndexPointer::iterator i(indices.begin()); i != indices.end(); i += 3)
- {
- BestPoint(
- matrix4_clip_triangle(
- m_local2view,
- reinterpret_cast<const Vector3&>(vertices[*i]),
- reinterpret_cast<const Vector3&>(vertices[*(i+1)]),
- reinterpret_cast<const Vector3&>(vertices[*(i+2)]),
- clipped
- ),
- clipped,
- best,
- m_cull
- );
- }
- }
- void TestQuads(const VertexPointer& vertices, const IndexPointer& indices, SelectionIntersection& best)
- {
- Vector4 clipped[9];
- for(IndexPointer::iterator i(indices.begin()); i != indices.end(); i += 4)
- {
- BestPoint(
- matrix4_clip_triangle(
- m_local2view,
- reinterpret_cast<const Vector3&>(vertices[*i]),
- reinterpret_cast<const Vector3&>(vertices[*(i+1)]),
- reinterpret_cast<const Vector3&>(vertices[*(i+3)]),
- clipped
- ),
- clipped,
- best,
- m_cull
- );
- BestPoint(
- matrix4_clip_triangle(
- m_local2view,
- reinterpret_cast<const Vector3&>(vertices[*(i+1)]),
- reinterpret_cast<const Vector3&>(vertices[*(i+2)]),
- reinterpret_cast<const Vector3&>(vertices[*(i+3)]),
- clipped
- ),
- clipped,
- best,
- m_cull
- );
- }
- }
- void TestQuadStrip(const VertexPointer& vertices, const IndexPointer& indices, SelectionIntersection& best)
- {
- Vector4 clipped[9];
- for(IndexPointer::iterator i(indices.begin()); i+2 != indices.end(); i += 2)
- {
- BestPoint(
- matrix4_clip_triangle(
- m_local2view,
- reinterpret_cast<const Vector3&>(vertices[*i]),
- reinterpret_cast<const Vector3&>(vertices[*(i+1)]),
- reinterpret_cast<const Vector3&>(vertices[*(i+2)]),
- clipped
- ),
- clipped,
- best,
- m_cull
- );
- BestPoint(
- matrix4_clip_triangle(
- m_local2view,
- reinterpret_cast<const Vector3&>(vertices[*(i+2)]),
- reinterpret_cast<const Vector3&>(vertices[*(i+1)]),
- reinterpret_cast<const Vector3&>(vertices[*(i+3)]),
- clipped
- ),
- clipped,
- best,
- m_cull
- );
- }
- }
-};
-class SelectionCounter
-{
-public:
- typedef const Selectable& first_argument_type;
-
- SelectionCounter(const SelectionChangeCallback& onchanged)
- : m_count(0), m_onchanged(onchanged)
- {
- }
- void operator()(const Selectable& selectable)
- {
- if(selectable.isSelected())
- {
- ++m_count;
- }
- else
- {
- ASSERT_MESSAGE(m_count != 0, "selection counter underflow");
- --m_count;
- }
-
- m_onchanged(selectable);
- }
- bool empty() const
- {
- return m_count == 0;
- }
- std::size_t size() const
- {
- return m_count;
- }
-private:
- std::size_t m_count;
- SelectionChangeCallback m_onchanged;
-};
+ const VolumeTest &getVolume() const
+ {
+ return m_view;
+ }
-inline void ConstructSelectionTest(View& view, const rect_t selection_box)
-{
- view.EnableScissor(selection_box.min[0], selection_box.max[0], selection_box.min[1], selection_box.max[1]);
-}
+ const Vector3 &getNear() const
+ {
+ return m_near;
+ }
+
+ const Vector3 &getFar() const
+ {
+ return m_far;
+ }
+
+ void BeginMesh(const Matrix4 &localToWorld, bool twoSided)
+ {
+ m_local2view = matrix4_multiplied_by_matrix4(m_view.GetViewMatrix(), localToWorld);
+
+ // Cull back-facing polygons based on winding being clockwise or counter-clockwise.
+ // Don't cull if the view is wireframe and the polygons are two-sided.
+ m_cull = twoSided && !m_view.fill() ? eClipCullNone : (matrix4_handedness(localToWorld) == MATRIX4_RIGHTHANDED)
+ ? eClipCullCW : eClipCullCCW;
+
+ {
+ Matrix4 screen2world(matrix4_full_inverse(m_local2view));
+
+ m_near = vector4_projected(
+ matrix4_transformed_vector4(
+ screen2world,
+ Vector4(0, 0, -1, 1)
+ )
+ );
+
+ m_far = vector4_projected(
+ matrix4_transformed_vector4(
+ screen2world,
+ Vector4(0, 0, 1, 1)
+ )
+ );
+ }
+
+#if defined( DEBUG_SELECTION )
+ g_render_clipped.construct(m_view.GetViewMatrix());
+#endif
+ }
+
+ void TestPoint(const Vector3 &point, SelectionIntersection &best)
+ {
+ Vector4 clipped;
+ if (matrix4_clip_point(m_local2view, point, clipped) == c_CLIP_PASS) {
+ best = select_point_from_clipped(clipped);
+ }
+ }
+
+ void TestPolygon(const VertexPointer &vertices, std::size_t count, SelectionIntersection &best)
+ {
+ Vector4 clipped[9];
+ for (std::size_t i = 0; i + 2 < count; ++i) {
+ BestPoint(
+ matrix4_clip_triangle(
+ m_local2view,
+ reinterpret_cast<const Vector3 &>( vertices[0] ),
+ reinterpret_cast<const Vector3 &>( vertices[i + 1] ),
+ reinterpret_cast<const Vector3 &>( vertices[i + 2] ),
+ clipped
+ ),
+ clipped,
+ best,
+ m_cull
+ );
+ }
+ }
+
+ void TestLineLoop(const VertexPointer &vertices, std::size_t count, SelectionIntersection &best)
+ {
+ if (count == 0) {
+ return;
+ }
+ Vector4 clipped[9];
+ for (VertexPointer::iterator i = vertices.begin(), end = i + count, prev = i + (count - 1);
+ i != end; prev = i, ++i) {
+ BestPoint(
+ matrix4_clip_line(
+ m_local2view,
+ reinterpret_cast<const Vector3 &>((*prev)),
+ reinterpret_cast<const Vector3 &>((*i)),
+ clipped
+ ),
+ clipped,
+ best,
+ m_cull
+ );
+ }
+ }
+
+ void TestLineStrip(const VertexPointer &vertices, std::size_t count, SelectionIntersection &best)
+ {
+ if (count == 0) {
+ return;
+ }
+ Vector4 clipped[9];
+ for (VertexPointer::iterator i = vertices.begin(), end = i + count, next = i + 1;
+ next != end; i = next, ++next) {
+ BestPoint(
+ matrix4_clip_line(
+ m_local2view,
+ reinterpret_cast<const Vector3 &>((*i)),
+ reinterpret_cast<const Vector3 &>((*next)),
+ clipped
+ ),
+ clipped,
+ best,
+ m_cull
+ );
+ }
+ }
+
+ void TestLines(const VertexPointer &vertices, std::size_t count, SelectionIntersection &best)
+ {
+ if (count == 0) {
+ return;
+ }
+ Vector4 clipped[9];
+ for (VertexPointer::iterator i = vertices.begin(), end = i + count; i != end; i += 2) {
+ BestPoint(
+ matrix4_clip_line(
+ m_local2view,
+ reinterpret_cast<const Vector3 &>((*i)),
+ reinterpret_cast<const Vector3 &>((*(i + 1))),
+ clipped
+ ),
+ clipped,
+ best,
+ m_cull
+ );
+ }
+ }
+
+ void TestTriangles(const VertexPointer &vertices, const IndexPointer &indices, SelectionIntersection &best)
+ {
+ Vector4 clipped[9];
+ for (IndexPointer::iterator i(indices.begin()); i != indices.end(); i += 3) {
+ BestPoint(
+ matrix4_clip_triangle(
+ m_local2view,
+ reinterpret_cast<const Vector3 &>( vertices[*i] ),
+ reinterpret_cast<const Vector3 &>( vertices[*(i + 1)] ),
+ reinterpret_cast<const Vector3 &>( vertices[*(i + 2)] ),
+ clipped
+ ),
+ clipped,
+ best,
+ m_cull
+ );
+ }
+ }
+
+ void TestQuads(const VertexPointer &vertices, const IndexPointer &indices, SelectionIntersection &best)
+ {
+ Vector4 clipped[9];
+ for (IndexPointer::iterator i(indices.begin()); i != indices.end(); i += 4) {
+ BestPoint(
+ matrix4_clip_triangle(
+ m_local2view,
+ reinterpret_cast<const Vector3 &>( vertices[*i] ),
+ reinterpret_cast<const Vector3 &>( vertices[*(i + 1)] ),
+ reinterpret_cast<const Vector3 &>( vertices[*(i + 3)] ),
+ clipped
+ ),
+ clipped,
+ best,
+ m_cull
+ );
+ BestPoint(
+ matrix4_clip_triangle(
+ m_local2view,
+ reinterpret_cast<const Vector3 &>( vertices[*(i + 1)] ),
+ reinterpret_cast<const Vector3 &>( vertices[*(i + 2)] ),
+ reinterpret_cast<const Vector3 &>( vertices[*(i + 3)] ),
+ clipped
+ ),
+ clipped,
+ best,
+ m_cull
+ );
+ }
+ }
+
+ void TestQuadStrip(const VertexPointer &vertices, const IndexPointer &indices, SelectionIntersection &best)
+ {
+ Vector4 clipped[9];
+ for (IndexPointer::iterator i(indices.begin()); i + 2 != indices.end(); i += 2) {
+ BestPoint(
+ matrix4_clip_triangle(
+ m_local2view,
+ reinterpret_cast<const Vector3 &>( vertices[*i] ),
+ reinterpret_cast<const Vector3 &>( vertices[*(i + 1)] ),
+ reinterpret_cast<const Vector3 &>( vertices[*(i + 2)] ),
+ clipped
+ ),
+ clipped,
+ best,
+ m_cull
+ );
+ BestPoint(
+ matrix4_clip_triangle(
+ m_local2view,
+ reinterpret_cast<const Vector3 &>( vertices[*(i + 2)] ),
+ reinterpret_cast<const Vector3 &>( vertices[*(i + 1)] ),
+ reinterpret_cast<const Vector3 &>( vertices[*(i + 3)] ),
+ clipped
+ ),
+ clipped,
+ best,
+ m_cull
+ );
+ }
+ }
+};
+
+class SelectionCounter {
+public:
+ using func = void(const Selectable &);
+
+ SelectionCounter(const SelectionChangeCallback &onchanged)
+ : m_count(0), m_onchanged(onchanged)
+ {
+ }
+
+ void operator()(const Selectable &selectable)
+ {
+ if (selectable.isSelected()) {
+ ++m_count;
+ } else {
+ ASSERT_MESSAGE(m_count != 0, "selection counter underflow");
+ --m_count;
+ }
+
+ m_onchanged(selectable);
+ }
+
+ bool empty() const
+ {
+ return m_count == 0;
+ }
+
+ std::size_t size() const
+ {
+ return m_count;
+ }
+
+private:
+ std::size_t m_count;
+ SelectionChangeCallback m_onchanged;
+};
+
+inline void ConstructSelectionTest(View &view, const rect_t selection_box)
+{
+ view.EnableScissor(selection_box.min[0], selection_box.max[0], selection_box.min[1], selection_box.max[1]);
+}
inline const rect_t SelectionBoxForPoint(const float device_point[2], const float device_epsilon[2])
{
- rect_t selection_box;
- selection_box.min[0] = device_point[0] - device_epsilon[0];
- selection_box.min[1] = device_point[1] - device_epsilon[1];
- selection_box.max[0] = device_point[0] + device_epsilon[0];
- selection_box.max[1] = device_point[1] + device_epsilon[1];
- return selection_box;
+ rect_t selection_box;
+ selection_box.min[0] = device_point[0] - device_epsilon[0];
+ selection_box.min[1] = device_point[1] - device_epsilon[1];
+ selection_box.max[0] = device_point[0] + device_epsilon[0];
+ selection_box.max[1] = device_point[1] + device_epsilon[1];
+ return selection_box;
}
inline const rect_t SelectionBoxForArea(const float device_point[2], const float device_delta[2])
{
- rect_t selection_box;
- selection_box.min[0] = (device_delta[0] < 0) ? (device_point[0] + device_delta[0]) : (device_point[0]);
- selection_box.min[1] = (device_delta[1] < 0) ? (device_point[1] + device_delta[1]) : (device_point[1]);
- selection_box.max[0] = (device_delta[0] > 0) ? (device_point[0] + device_delta[0]) : (device_point[0]);
- selection_box.max[1] = (device_delta[1] > 0) ? (device_point[1] + device_delta[1]) : (device_point[1]);
- return selection_box;
+ rect_t selection_box;
+ selection_box.min[0] = (device_delta[0] < 0) ? (device_point[0] + device_delta[0]) : (device_point[0]);
+ selection_box.min[1] = (device_delta[1] < 0) ? (device_point[1] + device_delta[1]) : (device_point[1]);
+ selection_box.max[0] = (device_delta[0] > 0) ? (device_point[0] + device_delta[0]) : (device_point[0]);
+ selection_box.max[1] = (device_delta[1] > 0) ? (device_point[1] + device_delta[1]) : (device_point[1]);
+ return selection_box;
}
-Quaternion construct_local_rotation(const Quaternion& world, const Quaternion& localToWorld)
+Quaternion construct_local_rotation(const Quaternion &world, const Quaternion &localToWorld)
{
- return quaternion_normalised(quaternion_multiplied_by_quaternion(
- quaternion_normalised(quaternion_multiplied_by_quaternion(
- quaternion_inverse(localToWorld),
- world
- )),
- localToWorld
- ));
+ return quaternion_normalised(quaternion_multiplied_by_quaternion(
+ quaternion_normalised(quaternion_multiplied_by_quaternion(
+ quaternion_inverse(localToWorld),
+ world
+ )),
+ localToWorld
+ ));
}
-inline void matrix4_assign_rotation(Matrix4& matrix, const Matrix4& other)
+inline void matrix4_assign_rotation(Matrix4 &matrix, const Matrix4 &other)
{
- matrix[0] = other[0];
- matrix[1] = other[1];
- matrix[2] = other[2];
- matrix[4] = other[4];
- matrix[5] = other[5];
- matrix[6] = other[6];
- matrix[8] = other[8];
- matrix[9] = other[9];
- matrix[10] = other[10];
+ matrix[0] = other[0];
+ matrix[1] = other[1];
+ matrix[2] = other[2];
+ matrix[4] = other[4];
+ matrix[5] = other[5];
+ matrix[6] = other[6];
+ matrix[8] = other[8];
+ matrix[9] = other[9];
+ matrix[10] = other[10];
}
-void matrix4_assign_rotation_for_pivot(Matrix4& matrix, scene::Instance& instance)
+void matrix4_assign_rotation_for_pivot(Matrix4 &matrix, scene::Instance &instance)
{
- Editable* editable = Node_getEditable(instance.path().top());
- if(editable != 0)
- {
- matrix4_assign_rotation(matrix, matrix4_multiplied_by_matrix4(instance.localToWorld(), editable->getLocalPivot()));
- }
- else
- {
- matrix4_assign_rotation(matrix, instance.localToWorld());
- }
+ Editable *editable = Node_getEditable(instance.path().top());
+ if (editable != 0) {
+ matrix4_assign_rotation(matrix,
+ matrix4_multiplied_by_matrix4(instance.localToWorld(), editable->getLocalPivot()));
+ } else {
+ matrix4_assign_rotation(matrix, instance.localToWorld());
+ }
}
-inline bool Instance_isSelectedComponents(scene::Instance& instance)
+inline bool Instance_isSelectedComponents(scene::Instance &instance)
{
- ComponentSelectionTestable* componentSelectionTestable = Instance_getComponentSelectionTestable(instance);
- return componentSelectionTestable != 0
- && componentSelectionTestable->isSelectedComponents();
+ ComponentSelectionTestable *componentSelectionTestable = Instance_getComponentSelectionTestable(instance);
+ return componentSelectionTestable != 0
+ && componentSelectionTestable->isSelectedComponents();
}
-class TranslateSelected : public SelectionSystem::Visitor
-{
- const Vector3& m_translate;
+class TranslateSelected : public SelectionSystem::Visitor {
+ const Vector3 &m_translate;
public:
- TranslateSelected(const Vector3& translate)
- : m_translate(translate)
- {
- }
- void visit(scene::Instance& instance) const
- {
- Transformable* transform = Instance_getTransformable(instance);
- if(transform != 0)
- {
- transform->setType(TRANSFORM_PRIMITIVE);
- transform->setTranslation(m_translate);
- }
- }
+ TranslateSelected(const Vector3 &translate)
+ : m_translate(translate)
+ {
+ }
+
+ void visit(scene::Instance &instance) const
+ {
+ Transformable *transform = Instance_getTransformable(instance);
+ if (transform != 0) {
+ transform->setType(TRANSFORM_PRIMITIVE);
+ transform->setTranslation(m_translate);
+ }
+ }
};
-void Scene_Translate_Selected(scene::Graph& graph, const Vector3& translation)
+void Scene_Translate_Selected(scene::Graph &graph, const Vector3 &translation)
{
- if(GlobalSelectionSystem().countSelected() != 0)
- {
- GlobalSelectionSystem().foreachSelected(TranslateSelected(translation));
- }
+ if (GlobalSelectionSystem().countSelected() != 0) {
+ GlobalSelectionSystem().foreachSelected(TranslateSelected(translation));
+ }
}
-Vector3 get_local_pivot(const Vector3& world_pivot, const Matrix4& localToWorld)
+Vector3 get_local_pivot(const Vector3 &world_pivot, const Matrix4 &localToWorld)
{
- return Vector3(
- matrix4_transformed_point(
- matrix4_full_inverse(localToWorld),
- world_pivot
- )
- );
+ return Vector3(
+ matrix4_transformed_point(
+ matrix4_full_inverse(localToWorld),
+ world_pivot
+ )
+ );
}
-void translation_for_pivoted_rotation(Vector3& parent_translation, const Quaternion& local_rotation, const Vector3& world_pivot, const Matrix4& localToWorld, const Matrix4& localToParent)
-{
- Vector3 local_pivot(get_local_pivot(world_pivot, localToWorld));
-
- Vector3 translation(
- vector3_added(
- local_pivot,
- matrix4_transformed_point(
- matrix4_rotation_for_quaternion_quantised(local_rotation),
- vector3_negated(local_pivot)
- )
- )
- );
-
- //globalOutputStream() << "translation: " << translation << "\n";
+void translation_for_pivoted_matrix_transform(Vector3 &parent_translation, const Matrix4 &local_transform,
+ const Vector3 &world_pivot, const Matrix4 &localToWorld,
+ const Matrix4 &localToParent)
+{
+ // we need a translation inside the parent system to move the origin of this object to the right place
+
+ // mathematically, it must fulfill:
+ //
+ // local_translation local_transform local_pivot = local_pivot
+ // local_translation = local_pivot - local_transform local_pivot
+ //
+ // or maybe?
+ // local_transform local_translation local_pivot = local_pivot
+ // local_translation local_pivot = local_transform^-1 local_pivot
+ // local_translation + local_pivot = local_transform^-1 local_pivot
+ // local_translation = local_transform^-1 local_pivot - local_pivot
+
+ Vector3 local_pivot(get_local_pivot(world_pivot, localToWorld));
+
+ Vector3 local_translation(
+ vector3_subtracted(
+ local_pivot,
+ matrix4_transformed_point(
+ local_transform,
+ local_pivot
+ )
+ /*
+ matrix4_transformed_point(
+ matrix4_full_inverse(local_transform),
+ local_pivot
+ ),
+ local_pivot
+ */
+ )
+ );
- translation_local2object(parent_translation, translation, localToParent);
+ translation_local2object(parent_translation, local_translation, localToParent);
- //globalOutputStream() << "parent_translation: " << parent_translation << "\n";
+ /*
+ // verify it!
+ globalOutputStream() << "World pivot is at " << world_pivot << "\n";
+ globalOutputStream() << "Local pivot is at " << local_pivot << "\n";
+ globalOutputStream() << "Transformation " << local_transform << " moves it to: " << matrix4_transformed_point(local_transform, local_pivot) << "\n";
+ globalOutputStream() << "Must move by " << local_translation << " in the local system" << "\n";
+ globalOutputStream() << "Must move by " << parent_translation << " in the parent system" << "\n";
+ */
}
-void translation_for_pivoted_scale(Vector3& parent_translation, const Vector3& local_scale, const Vector3& world_pivot, const Matrix4& localToWorld, const Matrix4& localToParent)
+void translation_for_pivoted_rotation(Vector3 &parent_translation, const Quaternion &local_rotation,
+ const Vector3 &world_pivot, const Matrix4 &localToWorld,
+ const Matrix4 &localToParent)
{
- Vector3 local_pivot(get_local_pivot(world_pivot, localToWorld));
-
- Vector3 translation(
- vector3_added(
- local_pivot,
- vector3_scaled(
- vector3_negated(local_pivot),
- local_scale
- )
- )
- );
-
- translation_local2object(parent_translation, translation, localToParent);
+ translation_for_pivoted_matrix_transform(parent_translation,
+ matrix4_rotation_for_quaternion_quantised(local_rotation), world_pivot,
+ localToWorld, localToParent);
}
-class rotate_selected : public SelectionSystem::Visitor
+void translation_for_pivoted_scale(Vector3 &parent_translation, const Vector3 &world_scale, const Vector3 &world_pivot,
+ const Matrix4 &localToWorld, const Matrix4 &localToParent)
{
- const Quaternion& m_rotate;
- const Vector3& m_world_pivot;
+ Matrix4 local_transform(
+ matrix4_multiplied_by_matrix4(
+ matrix4_full_inverse(localToWorld),
+ matrix4_multiplied_by_matrix4(
+ matrix4_scale_for_vec3(world_scale),
+ localToWorld
+ )
+ )
+ );
+ local_transform.tx() = local_transform.ty() = local_transform.tz() = 0; // cancel translation parts
+ translation_for_pivoted_matrix_transform(parent_translation, local_transform, world_pivot, localToWorld,
+ localToParent);
+}
+
+class rotate_selected : public SelectionSystem::Visitor {
+ const Quaternion &m_rotate;
+ const Vector3 &m_world_pivot;
public:
- rotate_selected(const Quaternion& rotation, const Vector3& world_pivot)
- : m_rotate(rotation), m_world_pivot(world_pivot)
- {
- }
- void visit(scene::Instance& instance) const
- {
- TransformNode* transformNode = Node_getTransformNode(instance.path().top());
- if(transformNode != 0)
- {
- Transformable* transform = Instance_getTransformable(instance);
- if(transform != 0)
- {
- transform->setType(TRANSFORM_PRIMITIVE);
- transform->setScale(c_scale_identity);
- transform->setTranslation(c_translation_identity);
-
- transform->setType(TRANSFORM_PRIMITIVE);
- transform->setRotation(m_rotate);
+ rotate_selected(const Quaternion &rotation, const Vector3 &world_pivot)
+ : m_rotate(rotation), m_world_pivot(world_pivot)
+ {
+ }
- {
- Editable* editable = Node_getEditable(instance.path().top());
- const Matrix4& localPivot = editable != 0 ? editable->getLocalPivot() : g_matrix4_identity;
+ void visit(scene::Instance &instance) const
+ {
+ TransformNode *transformNode = Node_getTransformNode(instance.path().top());
+ if (transformNode != 0) {
+ Transformable *transform = Instance_getTransformable(instance);
+ if (transform != 0) {
+ transform->setType(TRANSFORM_PRIMITIVE);
+ transform->setScale(c_scale_identity);
+ transform->setTranslation(c_translation_identity);
- Vector3 parent_translation;
- translation_for_pivoted_rotation(
- parent_translation,
- m_rotate,
- m_world_pivot,
- matrix4_multiplied_by_matrix4(instance.localToWorld(), localPivot),
- matrix4_multiplied_by_matrix4(transformNode->localToParent(), localPivot)
- );
+ transform->setType(TRANSFORM_PRIMITIVE);
+ transform->setRotation(m_rotate);
- transform->setTranslation(parent_translation);
+ {
+ Editable *editable = Node_getEditable(instance.path().top());
+ const Matrix4 &localPivot = editable != 0 ? editable->getLocalPivot() : g_matrix4_identity;
+
+ Vector3 parent_translation;
+ translation_for_pivoted_rotation(
+ parent_translation,
+ m_rotate,
+ m_world_pivot,
+ matrix4_multiplied_by_matrix4(instance.localToWorld(), localPivot),
+ matrix4_multiplied_by_matrix4(transformNode->localToParent(), localPivot)
+ );
+
+ transform->setTranslation(parent_translation);
+ }
+ }
}
- }
}
- }
};
-void Scene_Rotate_Selected(scene::Graph& graph, const Quaternion& rotation, const Vector3& world_pivot)
+void Scene_Rotate_Selected(scene::Graph &graph, const Quaternion &rotation, const Vector3 &world_pivot)
{
- if(GlobalSelectionSystem().countSelected() != 0)
- {
- GlobalSelectionSystem().foreachSelected(rotate_selected(rotation, world_pivot));
- }
+ if (GlobalSelectionSystem().countSelected() != 0) {
+ GlobalSelectionSystem().foreachSelected(rotate_selected(rotation, world_pivot));
+ }
}
-class scale_selected : public SelectionSystem::Visitor
-{
- const Vector3& m_scale;
- const Vector3& m_world_pivot;
+class scale_selected : public SelectionSystem::Visitor {
+ const Vector3 &m_scale;
+ const Vector3 &m_world_pivot;
public:
- scale_selected(const Vector3& scaling, const Vector3& world_pivot)
- : m_scale(scaling), m_world_pivot(world_pivot)
- {
- }
- void visit(scene::Instance& instance) const
- {
- TransformNode* transformNode = Node_getTransformNode(instance.path().top());
- if(transformNode != 0)
- {
- Transformable* transform = Instance_getTransformable(instance);
- if(transform != 0)
- {
- Matrix4 previousTransform = instance.localToWorld();
-
- transform->setType(TRANSFORM_PRIMITIVE);
- transform->setScale(c_scale_identity);
- transform->setTranslation(c_translation_identity);
-
- transform->setType(TRANSFORM_PRIMITIVE);
- transform->setScale(m_scale);
- {
- Editable* editable = Node_getEditable(instance.path().top());
- const Matrix4& localPivot = editable != 0 ? editable->getLocalPivot() : g_matrix4_identity;
+ scale_selected(const Vector3 &scaling, const Vector3 &world_pivot)
+ : m_scale(scaling), m_world_pivot(world_pivot)
+ {
+ }
+
+ void visit(scene::Instance &instance) const
+ {
+ TransformNode *transformNode = Node_getTransformNode(instance.path().top());
+ if (transformNode != 0) {
+ Transformable *transform = Instance_getTransformable(instance);
+ if (transform != 0) {
+ transform->setType(TRANSFORM_PRIMITIVE);
+ transform->setScale(c_scale_identity);
+ transform->setTranslation(c_translation_identity);
- Vector3 previousOrigin = matrix4_get_translation_vec3(matrix4_multiplied_by_matrix4(previousTransform, localPivot));
- Vector3 currentOrigin = matrix4_get_translation_vec3(matrix4_multiplied_by_matrix4(instance.localToWorld(), localPivot));
- Vector3 wishOrigin = vector3_added(m_world_pivot, vector3_scaled(vector3_subtracted(previousOrigin, m_world_pivot), m_scale));
- transform->setTranslation(vector3_subtracted(wishOrigin, currentOrigin));
+ transform->setType(TRANSFORM_PRIMITIVE);
+ transform->setScale(m_scale);
+ {
+ Editable *editable = Node_getEditable(instance.path().top());
+ const Matrix4 &localPivot = editable != 0 ? editable->getLocalPivot() : g_matrix4_identity;
+
+ Vector3 parent_translation;
+ translation_for_pivoted_scale(
+ parent_translation,
+ m_scale,
+ m_world_pivot,
+ matrix4_multiplied_by_matrix4(instance.localToWorld(), localPivot),
+ matrix4_multiplied_by_matrix4(transformNode->localToParent(), localPivot)
+ );
+
+ transform->setTranslation(parent_translation);
+ }
+ }
}
- }
}
- }
};
-void Scene_Scale_Selected(scene::Graph& graph, const Vector3& scaling, const Vector3& world_pivot)
+void Scene_Scale_Selected(scene::Graph &graph, const Vector3 &scaling, const Vector3 &world_pivot)
{
- if(GlobalSelectionSystem().countSelected() != 0)
- {
- GlobalSelectionSystem().foreachSelected(scale_selected(scaling, world_pivot));
- }
+ if (GlobalSelectionSystem().countSelected() != 0) {
+ GlobalSelectionSystem().foreachSelected(scale_selected(scaling, world_pivot));
+ }
}
-class translate_component_selected : public SelectionSystem::Visitor
-{
- const Vector3& m_translate;
+class translate_component_selected : public SelectionSystem::Visitor {
+ const Vector3 &m_translate;
public:
- translate_component_selected(const Vector3& translate)
- : m_translate(translate)
- {
- }
- void visit(scene::Instance& instance) const
- {
- Transformable* transform = Instance_getTransformable(instance);
- if(transform != 0)
- {
- transform->setType(TRANSFORM_COMPONENT);
- transform->setTranslation(m_translate);
- }
- }
+ translate_component_selected(const Vector3 &translate)
+ : m_translate(translate)
+ {
+ }
+
+ void visit(scene::Instance &instance) const
+ {
+ Transformable *transform = Instance_getTransformable(instance);
+ if (transform != 0) {
+ transform->setType(TRANSFORM_COMPONENT);
+ transform->setTranslation(m_translate);
+ }
+ }
};
-void Scene_Translate_Component_Selected(scene::Graph& graph, const Vector3& translation)
+void Scene_Translate_Component_Selected(scene::Graph &graph, const Vector3 &translation)
{
- if(GlobalSelectionSystem().countSelected() != 0)
- {
- GlobalSelectionSystem().foreachSelectedComponent(translate_component_selected(translation));
- }
+ if (GlobalSelectionSystem().countSelected() != 0) {
+ GlobalSelectionSystem().foreachSelectedComponent(translate_component_selected(translation));
+ }
}
-class rotate_component_selected : public SelectionSystem::Visitor
-{
- const Quaternion& m_rotate;
- const Vector3& m_world_pivot;
+class rotate_component_selected : public SelectionSystem::Visitor {
+ const Quaternion &m_rotate;
+ const Vector3 &m_world_pivot;
public:
- rotate_component_selected(const Quaternion& rotation, const Vector3& world_pivot)
- : m_rotate(rotation), m_world_pivot(world_pivot)
- {
- }
- void visit(scene::Instance& instance) const
- {
- Transformable* transform = Instance_getTransformable(instance);
- if(transform != 0)
- {
- Vector3 parent_translation;
- translation_for_pivoted_rotation(parent_translation, m_rotate, m_world_pivot, instance.localToWorld(), Node_getTransformNode(instance.path().top())->localToParent());
-
- transform->setType(TRANSFORM_COMPONENT);
- transform->setRotation(m_rotate);
- transform->setTranslation(parent_translation);
- }
- }
+ rotate_component_selected(const Quaternion &rotation, const Vector3 &world_pivot)
+ : m_rotate(rotation), m_world_pivot(world_pivot)
+ {
+ }
+
+ void visit(scene::Instance &instance) const
+ {
+ Transformable *transform = Instance_getTransformable(instance);
+ if (transform != 0) {
+ Vector3 parent_translation;
+ translation_for_pivoted_rotation(parent_translation, m_rotate, m_world_pivot, instance.localToWorld(),
+ Node_getTransformNode(instance.path().top())->localToParent());
+
+ transform->setType(TRANSFORM_COMPONENT);
+ transform->setRotation(m_rotate);
+ transform->setTranslation(parent_translation);
+ }
+ }
};
-void Scene_Rotate_Component_Selected(scene::Graph& graph, const Quaternion& rotation, const Vector3& world_pivot)
+void Scene_Rotate_Component_Selected(scene::Graph &graph, const Quaternion &rotation, const Vector3 &world_pivot)
{
- if(GlobalSelectionSystem().countSelectedComponents() != 0)
- {
- GlobalSelectionSystem().foreachSelectedComponent(rotate_component_selected(rotation, world_pivot));
- }
+ if (GlobalSelectionSystem().countSelectedComponents() != 0) {
+ GlobalSelectionSystem().foreachSelectedComponent(rotate_component_selected(rotation, world_pivot));
+ }
}
-class scale_component_selected : public SelectionSystem::Visitor
-{
- const Vector3& m_scale;
- const Vector3& m_world_pivot;
+class scale_component_selected : public SelectionSystem::Visitor {
+ const Vector3 &m_scale;
+ const Vector3 &m_world_pivot;
public:
- scale_component_selected(const Vector3& scaling, const Vector3& world_pivot)
- : m_scale(scaling), m_world_pivot(world_pivot)
- {
- }
- void visit(scene::Instance& instance) const
- {
- Transformable* transform = Instance_getTransformable(instance);
- if(transform != 0)
- {
- Vector3 parent_translation;
- translation_for_pivoted_scale(parent_translation, m_scale, m_world_pivot, instance.localToWorld(), Node_getTransformNode(instance.path().top())->localToParent());
-
- transform->setType(TRANSFORM_COMPONENT);
- transform->setScale(m_scale);
- transform->setTranslation(parent_translation);
- }
- }
+ scale_component_selected(const Vector3 &scaling, const Vector3 &world_pivot)
+ : m_scale(scaling), m_world_pivot(world_pivot)
+ {
+ }
+
+ void visit(scene::Instance &instance) const
+ {
+ Transformable *transform = Instance_getTransformable(instance);
+ if (transform != 0) {
+ Vector3 parent_translation;
+ translation_for_pivoted_scale(parent_translation, m_scale, m_world_pivot, instance.localToWorld(),
+ Node_getTransformNode(instance.path().top())->localToParent());
+
+ transform->setType(TRANSFORM_COMPONENT);
+ transform->setScale(m_scale);
+ transform->setTranslation(parent_translation);
+ }
+ }
};
-void Scene_Scale_Component_Selected(scene::Graph& graph, const Vector3& scaling, const Vector3& world_pivot)
+void Scene_Scale_Component_Selected(scene::Graph &graph, const Vector3 &scaling, const Vector3 &world_pivot)
{
- if(GlobalSelectionSystem().countSelectedComponents() != 0)
- {
- GlobalSelectionSystem().foreachSelectedComponent(scale_component_selected(scaling, world_pivot));
- }
+ if (GlobalSelectionSystem().countSelectedComponents() != 0) {
+ GlobalSelectionSystem().foreachSelectedComponent(scale_component_selected(scaling, world_pivot));
+ }
}
-class BooleanSelector : public Selector
-{
- bool m_selected;
- SelectionIntersection m_intersection;
- Selectable* m_selectable;
+class BooleanSelector : public Selector {
+ bool m_selected;
+ SelectionIntersection m_intersection;
+ Selectable *m_selectable;
public:
- BooleanSelector() : m_selected(false)
- {
- }
-
- void pushSelectable(Selectable& selectable)
- {
- m_intersection = SelectionIntersection();
- m_selectable = &selectable;
- }
- void popSelectable()
- {
- if(m_intersection.valid())
- {
- m_selected = true;
- }
- m_intersection = SelectionIntersection();
- }
- void addIntersection(const SelectionIntersection& intersection)
- {
- if(m_selectable->isSelected())
- {
- assign_if_closer(m_intersection, intersection);
- }
- }
-
- bool isSelected()
- {
- return m_selected;
- }
+ BooleanSelector() : m_selected(false)
+ {
+ }
+
+ void pushSelectable(Selectable &selectable)
+ {
+ m_intersection = SelectionIntersection();
+ m_selectable = &selectable;
+ }
+
+ void popSelectable()
+ {
+ if (m_intersection.valid()) {
+ m_selected = true;
+ }
+ m_intersection = SelectionIntersection();
+ }
+
+ void addIntersection(const SelectionIntersection &intersection)
+ {
+ if (m_selectable->isSelected()) {
+ assign_if_closer(m_intersection, intersection);
+ }
+ }
+
+ bool isSelected()
+ {
+ return m_selected;
+ }
};
-class BestSelector : public Selector
-{
- SelectionIntersection m_intersection;
- Selectable* m_selectable;
- SelectionIntersection m_bestIntersection;
- std::list<Selectable*> m_bestSelectable;
+class BestSelector : public Selector {
+ SelectionIntersection m_intersection;
+ Selectable *m_selectable;
+ SelectionIntersection m_bestIntersection;
+ std::list<Selectable *> m_bestSelectable;
public:
- BestSelector() : m_bestIntersection(SelectionIntersection()), m_bestSelectable(0)
- {
- }
-
- void pushSelectable(Selectable& selectable)
- {
- m_intersection = SelectionIntersection();
- m_selectable = &selectable;
- }
- void popSelectable()
- {
- if(m_intersection.equalEpsilon(m_bestIntersection, 0.25f, 0.001f))
- {
- m_bestSelectable.push_back(m_selectable);
- m_bestIntersection = m_intersection;
- }
- else if(m_intersection < m_bestIntersection)
- {
- m_bestSelectable.clear();
- m_bestSelectable.push_back(m_selectable);
- m_bestIntersection = m_intersection;
- }
- m_intersection = SelectionIntersection();
- }
- void addIntersection(const SelectionIntersection& intersection)
- {
- assign_if_closer(m_intersection, intersection);
- }
-
- std::list<Selectable*>& best()
- {
- return m_bestSelectable;
- }
+ BestSelector() : m_bestIntersection(SelectionIntersection()), m_bestSelectable(0)
+ {
+ }
+
+ void pushSelectable(Selectable &selectable)
+ {
+ m_intersection = SelectionIntersection();
+ m_selectable = &selectable;
+ }
+
+ void popSelectable()
+ {
+ if (m_intersection.equalEpsilon(m_bestIntersection, 0.25f, 0.001f)) {
+ m_bestSelectable.push_back(m_selectable);
+ m_bestIntersection = m_intersection;
+ } else if (m_intersection < m_bestIntersection) {
+ m_bestSelectable.clear();
+ m_bestSelectable.push_back(m_selectable);
+ m_bestIntersection = m_intersection;
+ }
+ m_intersection = SelectionIntersection();
+ }
+
+ void addIntersection(const SelectionIntersection &intersection)
+ {
+ assign_if_closer(m_intersection, intersection);
+ }
+
+ std::list<Selectable *> &best()
+ {
+ return m_bestSelectable;
+ }
};
-class DragManipulator : public Manipulator
-{
- TranslateFree m_freeResize;
- TranslateFree m_freeDrag;
- ResizeTranslatable m_resize;
- DragTranslatable m_drag;
- SelectableBool m_dragSelectable;
+class DragManipulator : public Manipulator {
+ TranslateFree m_freeResize;
+ TranslateFree m_freeDrag;
+ ResizeTranslatable m_resize;
+ DragTranslatable m_drag;
+ SelectableBool m_dragSelectable;
public:
- bool m_selected;
+ bool m_selected;
- DragManipulator() : m_freeResize(m_resize), m_freeDrag(m_drag), m_selected(false)
- {
- }
+ DragManipulator() : m_freeResize(m_resize), m_freeDrag(m_drag), m_selected(false)
+ {
+ }
+
+ Manipulatable *GetManipulatable()
+ {
+ return m_dragSelectable.isSelected() ? &m_freeDrag : &m_freeResize;
+ }
- Manipulatable* GetManipulatable()
- {
- return m_dragSelectable.isSelected() ? &m_freeDrag : &m_freeResize;
- }
+ void testSelect(const View &view, const Matrix4 &pivot2world)
+ {
+ SelectionPool selector;
- void testSelect(const View& view, const Matrix4& pivot2world)
- {
- SelectionPool selector;
+ SelectionVolume test(view);
- SelectionVolume test(view);
+ if (GlobalSelectionSystem().Mode() == SelectionSystem::ePrimitive) {
+ BooleanSelector booleanSelector;
- if(GlobalSelectionSystem().Mode() == SelectionSystem::ePrimitive)
- {
- BooleanSelector booleanSelector;
+ Scene_TestSelect_Primitive(booleanSelector, test, view);
- Scene_TestSelect_Primitive(booleanSelector, test, view);
+ if (booleanSelector.isSelected()) {
+ selector.addSelectable(SelectionIntersection(0, 0), &m_dragSelectable);
+ m_selected = false;
+ } else {
+ m_selected = Scene_forEachPlaneSelectable_selectPlanes(GlobalSceneGraph(), selector, test);
+ }
+ } else {
+ BestSelector bestSelector;
+ Scene_TestSelect_Component_Selected(bestSelector, test, view, GlobalSelectionSystem().ComponentMode());
+ for (std::list<Selectable *>::iterator i = bestSelector.best().begin();
+ i != bestSelector.best().end(); ++i) {
+ if (!(*i)->isSelected()) {
+ GlobalSelectionSystem().setSelectedAllComponents(false);
+ }
+ m_selected = false;
+ selector.addSelectable(SelectionIntersection(0, 0), (*i));
+ m_dragSelectable.setSelected(true);
+ }
+ }
- if(booleanSelector.isSelected())
- {
- selector.addSelectable(SelectionIntersection(0, 0), &m_dragSelectable);
- m_selected = false;
- }
- else
- {
- m_selected = Scene_forEachPlaneSelectable_selectPlanes(GlobalSceneGraph(), selector, test);
- }
+ for (SelectionPool::iterator i = selector.begin(); i != selector.end(); ++i) {
+ (*i).second->setSelected(true);
+ }
}
- else
+
+ void setSelected(bool select)
{
- BestSelector bestSelector;
- Scene_TestSelect_Component_Selected(bestSelector, test, view, GlobalSelectionSystem().ComponentMode());
- for(std::list<Selectable*>::iterator i = bestSelector.best().begin(); i != bestSelector.best().end(); ++i)
- {
- if(!(*i)->isSelected())
- {
- GlobalSelectionSystem().setSelectedAllComponents(false);
- }
- m_selected = false;
- selector.addSelectable(SelectionIntersection(0, 0), (*i));
- m_dragSelectable.setSelected(true);
- }
+ m_selected = select;
+ m_dragSelectable.setSelected(select);
}
- for(SelectionPool::iterator i = selector.begin(); i != selector.end(); ++i)
+ bool isSelected() const
{
- (*i).second->setSelected(true);
+ return m_selected || m_dragSelectable.isSelected();
}
- }
-
- void setSelected(bool select)
- {
- m_selected = select;
- m_dragSelectable.setSelected(select);
- }
- bool isSelected() const
- {
- return m_selected || m_dragSelectable.isSelected();
- }
};
-class ClipManipulator : public Manipulator
-{
+class ClipManipulator : public Manipulator {
public:
- Manipulatable* GetManipulatable()
- {
- ERROR_MESSAGE("clipper is not manipulatable");
- return 0;
- }
-
- void setSelected(bool select)
- {
- }
- bool isSelected() const
- {
- return false;
- }
+ Manipulatable *GetManipulatable()
+ {
+ ERROR_MESSAGE("clipper is not manipulatable");
+ return 0;
+ }
+
+ void setSelected(bool select)
+ {
+ }
+
+ bool isSelected() const
+ {
+ return false;
+ }
};
-class select_all : public scene::Graph::Walker
-{
- bool m_select;
+class select_all : public scene::Graph::Walker {
+ bool m_select;
public:
- select_all(bool select)
- : m_select(select)
- {
- }
- bool pre(const scene::Path& path, scene::Instance& instance) const
- {
- Selectable* selectable = Instance_getSelectable(instance);
- if(selectable != 0)
- {
- selectable->setSelected(m_select);
- }
- return true;
- }
+ select_all(bool select)
+ : m_select(select)
+ {
+ }
+
+ bool pre(const scene::Path &path, scene::Instance &instance) const
+ {
+ Selectable *selectable = Instance_getSelectable(instance);
+ if (selectable != 0) {
+ selectable->setSelected(m_select);
+ }
+ return true;
+ }
};
-class select_all_component : public scene::Graph::Walker
-{
- bool m_select;
- SelectionSystem::EComponentMode m_mode;
+class select_all_component : public scene::Graph::Walker {
+ bool m_select;
+ SelectionSystem::EComponentMode m_mode;
public:
- select_all_component(bool select, SelectionSystem::EComponentMode mode)
- : m_select(select), m_mode(mode)
- {
- }
- bool pre(const scene::Path& path, scene::Instance& instance) const
- {
- ComponentSelectionTestable* componentSelectionTestable = Instance_getComponentSelectionTestable(instance);
- if(componentSelectionTestable)
- {
- componentSelectionTestable->setSelectedComponents(m_select, m_mode);
- }
- return true;
- }
+ select_all_component(bool select, SelectionSystem::EComponentMode mode)
+ : m_select(select), m_mode(mode)
+ {
+ }
+
+ bool pre(const scene::Path &path, scene::Instance &instance) const
+ {
+ ComponentSelectionTestable *componentSelectionTestable = Instance_getComponentSelectionTestable(instance);
+ if (componentSelectionTestable) {
+ componentSelectionTestable->setSelectedComponents(m_select, m_mode);
+ }
+ return true;
+ }
};
void Scene_SelectAll_Component(bool select, SelectionSystem::EComponentMode componentMode)
{
- GlobalSceneGraph().traverse(select_all_component(select, componentMode));
+ GlobalSceneGraph().traverse(select_all_component(select, componentMode));
}
// RadiantSelectionSystem
class RadiantSelectionSystem :
- public SelectionSystem,
- public Translatable,
- public Rotatable,
- public Scalable,
- public Renderable
-{
- mutable Matrix4 m_pivot2world;
- Matrix4 m_pivot2world_start;
- Matrix4 m_manip2pivot_start;
- Translation m_translation;
- Rotation m_rotation;
- Scale m_scale;
+ public SelectionSystem,
+ public Translatable,
+ public Rotatable,
+ public Scalable,
+ public Renderable {
+ mutable Matrix4 m_pivot2world;
+ Matrix4 m_pivot2world_start;
+ Matrix4 m_manip2pivot_start;
+ Translation m_translation;
+ Rotation m_rotation;
+ Scale m_scale;
public:
- static Shader* m_state;
+ static Shader *m_state;
private:
- EManipulatorMode m_manipulator_mode;
- Manipulator* m_manipulator;
+ EManipulatorMode m_manipulator_mode;
+ Manipulator *m_manipulator;
- // state
- bool m_undo_begun;
- EMode m_mode;
- EComponentMode m_componentmode;
+// state
+ bool m_undo_begun;
+ EMode m_mode;
+ EComponentMode m_componentmode;
- SelectionCounter m_count_primitive;
- SelectionCounter m_count_component;
+ SelectionCounter m_count_primitive;
+ SelectionCounter m_count_component;
- TranslateManipulator m_translate_manipulator;
- RotateManipulator m_rotate_manipulator;
- ScaleManipulator m_scale_manipulator;
- DragManipulator m_drag_manipulator;
- ClipManipulator m_clip_manipulator;
+ TranslateManipulator m_translate_manipulator;
+ RotateManipulator m_rotate_manipulator;
+ ScaleManipulator m_scale_manipulator;
+ DragManipulator m_drag_manipulator;
+ ClipManipulator m_clip_manipulator;
- typedef SelectionList<scene::Instance> selection_t;
- selection_t m_selection;
- selection_t m_component_selection;
+ typedef SelectionList<scene::Instance> selection_t;
+ selection_t m_selection;
+ selection_t m_component_selection;
- Signal1<const Selectable&> m_selectionChanged_callbacks;
+ Signal1<const Selectable &> m_selectionChanged_callbacks;
- void ConstructPivot() const;
- mutable bool m_pivotChanged;
- bool m_pivot_moving;
+ void ConstructPivot() const;
- void Scene_TestSelect(Selector& selector, SelectionTest& test, const View& view, SelectionSystem::EMode mode, SelectionSystem::EComponentMode componentMode);
+ mutable bool m_pivotChanged;
+ bool m_pivot_moving;
- bool nothingSelected() const
- {
- return (Mode() == eComponent && m_count_component.empty())
- || (Mode() == ePrimitive && m_count_primitive.empty());
- }
+ void Scene_TestSelect(Selector &selector, SelectionTest &test, const View &view, SelectionSystem::EMode mode,
+ SelectionSystem::EComponentMode componentMode);
+
+ bool nothingSelected() const
+ {
+ return (Mode() == eComponent && m_count_component.empty())
+ || (Mode() == ePrimitive && m_count_primitive.empty());
+ }
public:
- enum EModifier
- {
- eManipulator,
- eToggle,
- eReplace,
- eCycle,
- };
-
- RadiantSelectionSystem() :
- m_undo_begun(false),
- m_mode(ePrimitive),
- m_componentmode(eDefault),
- m_count_primitive(SelectionChangedCaller(*this)),
- m_count_component(SelectionChangedCaller(*this)),
- m_translate_manipulator(*this, 2, 64),
- m_rotate_manipulator(*this, 8, 64),
- m_scale_manipulator(*this, 0, 64),
- m_pivotChanged(false),
- m_pivot_moving(false)
- {
- SetManipulatorMode(eTranslate);
- pivotChanged();
- addSelectionChangeCallback(PivotChangedSelectionCaller(*this));
- AddGridChangeCallback(PivotChangedCaller(*this));
- }
- void pivotChanged() const
- {
- m_pivotChanged = true;
- SceneChangeNotify();
- }
- typedef ConstMemberCaller<RadiantSelectionSystem, &RadiantSelectionSystem::pivotChanged> PivotChangedCaller;
- void pivotChangedSelection(const Selectable& selectable)
- {
- pivotChanged();
- }
- typedef MemberCaller1<RadiantSelectionSystem, const Selectable&, &RadiantSelectionSystem::pivotChangedSelection> PivotChangedSelectionCaller;
-
- void SetMode(EMode mode)
- {
- if(m_mode != mode)
- {
- m_mode = mode;
- pivotChanged();
- }
- }
- EMode Mode() const
- {
- return m_mode;
- }
- void SetComponentMode(EComponentMode mode)
- {
- m_componentmode = mode;
- }
- EComponentMode ComponentMode() const
- {
- return m_componentmode;
- }
- void SetManipulatorMode(EManipulatorMode mode)
- {
- m_manipulator_mode = mode;
- switch(m_manipulator_mode)
- {
- case eTranslate: m_manipulator = &m_translate_manipulator; break;
- case eRotate: m_manipulator = &m_rotate_manipulator; break;
- case eScale: m_manipulator = &m_scale_manipulator; break;
- case eDrag: m_manipulator = &m_drag_manipulator; break;
- case eClip: m_manipulator = &m_clip_manipulator; break;
+ enum EModifier {
+ eManipulator,
+ eToggle,
+ eReplace,
+ eCycle,
+ };
+
+ RadiantSelectionSystem() :
+ m_undo_begun(false),
+ m_mode(ePrimitive),
+ m_componentmode(eDefault),
+ m_count_primitive(SelectionChangedCaller(*this)),
+ m_count_component(SelectionChangedCaller(*this)),
+ m_translate_manipulator(*this, 2, 64),
+ m_rotate_manipulator(*this, 8, 64),
+ m_scale_manipulator(*this, 0, 64),
+ m_pivotChanged(false),
+ m_pivot_moving(false)
+ {
+ SetManipulatorMode(eTranslate);
+ pivotChanged();
+ addSelectionChangeCallback(PivotChangedSelectionCaller(*this));
+ AddGridChangeCallback(PivotChangedCaller(*this));
+ }
+
+ void pivotChanged() const
+ {
+ m_pivotChanged = true;
+ SceneChangeNotify();
+ }
+
+ typedef ConstMemberCaller<RadiantSelectionSystem, void(), &RadiantSelectionSystem::pivotChanged> PivotChangedCaller;
+
+ void pivotChangedSelection(const Selectable &selectable)
+ {
+ pivotChanged();
+ }
+
+ typedef MemberCaller<RadiantSelectionSystem, void(
+ const Selectable &), &RadiantSelectionSystem::pivotChangedSelection> PivotChangedSelectionCaller;
+
+ void SetMode(EMode mode)
+ {
+ if (m_mode != mode) {
+ m_mode = mode;
+ pivotChanged();
+ }
+ }
+
+ EMode Mode() const
+ {
+ return m_mode;
+ }
+
+ void SetComponentMode(EComponentMode mode)
+ {
+ m_componentmode = mode;
+ }
+
+ EComponentMode ComponentMode() const
+ {
+ return m_componentmode;
+ }
+
+ void SetManipulatorMode(EManipulatorMode mode)
+ {
+ m_manipulator_mode = mode;
+ switch (m_manipulator_mode) {
+ case eTranslate:
+ m_manipulator = &m_translate_manipulator;
+ break;
+ case eRotate:
+ m_manipulator = &m_rotate_manipulator;
+ break;
+ case eScale:
+ m_manipulator = &m_scale_manipulator;
+ break;
+ case eDrag:
+ m_manipulator = &m_drag_manipulator;
+ break;
+ case eClip:
+ m_manipulator = &m_clip_manipulator;
+ break;
+ }
+ pivotChanged();
+ }
+
+ EManipulatorMode ManipulatorMode() const
+ {
+ return m_manipulator_mode;
+ }
+
+ SelectionChangeCallback getObserver(EMode mode)
+ {
+ if (mode == ePrimitive) {
+ return makeCallback(m_count_primitive);
+ } else {
+ return makeCallback(m_count_component);
+ }
+ }
+
+ std::size_t countSelected() const
+ {
+ return m_count_primitive.size();
+ }
+
+ std::size_t countSelectedComponents() const
+ {
+ return m_count_component.size();
+ }
+
+ void onSelectedChanged(scene::Instance &instance, const Selectable &selectable)
+ {
+ if (selectable.isSelected()) {
+ m_selection.append(instance);
+ } else {
+ m_selection.erase(instance);
+ }
+
+ ASSERT_MESSAGE(m_selection.size() == m_count_primitive.size(), "selection-tracking error");
+ }
+
+ void onComponentSelection(scene::Instance &instance, const Selectable &selectable)
+ {
+ if (selectable.isSelected()) {
+ m_component_selection.append(instance);
+ } else {
+ m_component_selection.erase(instance);
+ }
+
+ ASSERT_MESSAGE(m_component_selection.size() == m_count_component.size(), "selection-tracking error");
+ }
+
+ scene::Instance &ultimateSelected() const
+ {
+ ASSERT_MESSAGE(m_selection.size() > 0, "no instance selected");
+ return m_selection.back();
+ }
+
+ scene::Instance &penultimateSelected() const
+ {
+ ASSERT_MESSAGE(m_selection.size() > 1, "only one instance selected");
+ return *(*(--(--m_selection.end())));
+ }
+
+ void setSelectedAll(bool selected)
+ {
+ GlobalSceneGraph().traverse(select_all(selected));
+
+ m_manipulator->setSelected(selected);
+ }
+
+ void setSelectedAllComponents(bool selected)
+ {
+ Scene_SelectAll_Component(selected, SelectionSystem::eVertex);
+ Scene_SelectAll_Component(selected, SelectionSystem::eEdge);
+ Scene_SelectAll_Component(selected, SelectionSystem::eFace);
+
+ m_manipulator->setSelected(selected);
+ }
+
+ void foreachSelected(const Visitor &visitor) const
+ {
+ selection_t::const_iterator i = m_selection.begin();
+ while (i != m_selection.end()) {
+ visitor.visit(*(*(i++)));
+ }
+ }
+
+ void foreachSelectedComponent(const Visitor &visitor) const
+ {
+ selection_t::const_iterator i = m_component_selection.begin();
+ while (i != m_component_selection.end()) {
+ visitor.visit(*(*(i++)));
+ }
+ }
+
+ void addSelectionChangeCallback(const SelectionChangeHandler &handler)
+ {
+ m_selectionChanged_callbacks.connectLast(handler);
+ }
+
+ void selectionChanged(const Selectable &selectable)
+ {
+ m_selectionChanged_callbacks(selectable);
+ }
+
+ typedef MemberCaller<RadiantSelectionSystem, void(
+ const Selectable &), &RadiantSelectionSystem::selectionChanged> SelectionChangedCaller;
+
+
+ void startMove()
+ {
+ m_pivot2world_start = GetPivot2World();
+ }
+
+ bool SelectManipulator(const View &view, const float device_point[2], const float device_epsilon[2])
+ {
+ if (!nothingSelected() || (ManipulatorMode() == eDrag && Mode() == eComponent)) {
+#if defined ( DEBUG_SELECTION )
+ g_render_clipped.destroy();
+#endif
+
+ m_manipulator->setSelected(false);
+
+ if (!nothingSelected() || (ManipulatorMode() == eDrag && Mode() == eComponent)) {
+ View scissored(view);
+ ConstructSelectionTest(scissored, SelectionBoxForPoint(device_point, device_epsilon));
+ m_manipulator->testSelect(scissored, GetPivot2World());
+ }
+
+ startMove();
+
+ m_pivot_moving = m_manipulator->isSelected();
+
+ if (m_pivot_moving) {
+ Pivot2World pivot;
+ pivot.update(GetPivot2World(), view.GetModelview(), view.GetProjection(), view.GetViewport());
+
+ m_manip2pivot_start = matrix4_multiplied_by_matrix4(matrix4_full_inverse(m_pivot2world_start),
+ pivot.m_worldSpace);
+
+ Matrix4 device2manip;
+ ConstructDevice2Manip(device2manip, m_pivot2world_start, view.GetModelview(), view.GetProjection(),
+ view.GetViewport());
+ m_manipulator->GetManipulatable()->Construct(device2manip, device_point[0], device_point[1]);
+
+ m_undo_begun = false;
+ }
+
+ SceneChangeNotify();
+ }
+
+ return m_pivot_moving;
+ }
+
+ void deselectAll()
+ {
+ if (Mode() == eComponent) {
+ setSelectedAllComponents(false);
+ } else {
+ setSelectedAll(false);
+ }
+ }
+
+ void SelectPoint(const View &view, const float device_point[2], const float device_epsilon[2],
+ RadiantSelectionSystem::EModifier modifier, bool face)
+ {
+ ASSERT_MESSAGE(fabs(device_point[0]) <= 1.0f && fabs(device_point[1]) <= 1.0f, "point-selection error");
+ if (modifier == eReplace) {
+ if (face) {
+ setSelectedAllComponents(false);
+ } else {
+ deselectAll();
+ }
+ }
+
+#if defined ( DEBUG_SELECTION )
+ g_render_clipped.destroy();
+#endif
+
+ {
+ View scissored(view);
+ ConstructSelectionTest(scissored, SelectionBoxForPoint(device_point, device_epsilon));
+
+ SelectionVolume volume(scissored);
+ SelectionPool selector;
+ if (face) {
+ Scene_TestSelect_Component(selector, volume, scissored, eFace);
+ } else {
+ Scene_TestSelect(selector, volume, scissored, Mode(), ComponentMode());
+ }
+
+ if (!selector.failed()) {
+ switch (modifier) {
+ case RadiantSelectionSystem::eToggle: {
+ SelectableSortedSet::iterator best = selector.begin();
+ // toggle selection of the object with least depth
+ if ((*best).second->isSelected()) {
+ (*best).second->setSelected(false);
+ } else {
+ (*best).second->setSelected(true);
+ }
+ }
+ break;
+ // if cycle mode not enabled, enable it
+ case RadiantSelectionSystem::eReplace: {
+ // select closest
+ (*selector.begin()).second->setSelected(true);
+ }
+ break;
+ // select the next object in the list from the one already selected
+ case RadiantSelectionSystem::eCycle: {
+ SelectionPool::iterator i = selector.begin();
+ while (i != selector.end()) {
+ if ((*i).second->isSelected()) {
+ (*i).second->setSelected(false);
+ ++i;
+ if (i != selector.end()) {
+ i->second->setSelected(true);
+ } else {
+ selector.begin()->second->setSelected(true);
+ }
+ break;
+ }
+ ++i;
+ }
+ }
+ break;
+ default:
+ break;
+ }
+ }
+ }
+ }
+
+ void SelectArea(const View &view, const float device_point[2], const float device_delta[2],
+ RadiantSelectionSystem::EModifier modifier, bool face)
+ {
+ if (modifier == eReplace) {
+ if (face) {
+ setSelectedAllComponents(false);
+ } else {
+ deselectAll();
+ }
+ }
+
+#if defined ( DEBUG_SELECTION )
+ g_render_clipped.destroy();
+#endif
+
+ {
+ View scissored(view);
+ ConstructSelectionTest(scissored, SelectionBoxForArea(device_point, device_delta));
+
+ SelectionVolume volume(scissored);
+ SelectionPool pool;
+ if (face) {
+ Scene_TestSelect_Component(pool, volume, scissored, eFace);
+ } else {
+ Scene_TestSelect(pool, volume, scissored, Mode(), ComponentMode());
+ }
+
+ for (SelectionPool::iterator i = pool.begin(); i != pool.end(); ++i) {
+ (*i).second->setSelected(!(modifier == RadiantSelectionSystem::eToggle && (*i).second->isSelected()));
+ }
+ }
+ }
+
+
+ void translate(const Vector3 &translation)
+ {
+ if (!nothingSelected()) {
+ //ASSERT_MESSAGE(!m_pivotChanged, "pivot is invalid");
+
+ m_translation = translation;
+
+ m_pivot2world = m_pivot2world_start;
+ matrix4_translate_by_vec3(m_pivot2world, translation);
+
+ if (Mode() == eComponent) {
+ Scene_Translate_Component_Selected(GlobalSceneGraph(), m_translation);
+ } else {
+ Scene_Translate_Selected(GlobalSceneGraph(), m_translation);
+ }
+
+ SceneChangeNotify();
+ }
+ }
+
+ void outputTranslation(TextOutputStream &ostream)
+ {
+ ostream << " -xyz " << m_translation.x() << " " << m_translation.y() << " " << m_translation.z();
}
- pivotChanged();
- }
- EManipulatorMode ManipulatorMode() const
- {
- return m_manipulator_mode;
- }
-
- SelectionChangeCallback getObserver(EMode mode)
- {
- if(mode == ePrimitive)
- {
- return makeCallback1(m_count_primitive);
- }
- else
- {
- return makeCallback1(m_count_component);
- }
- }
- std::size_t countSelected() const
- {
- return m_count_primitive.size();
- }
- std::size_t countSelectedComponents() const
- {
- return m_count_component.size();
- }
- void onSelectedChanged(scene::Instance& instance, const Selectable& selectable)
- {
- if(selectable.isSelected())
- {
- m_selection.append(instance);
- }
- else
- {
- m_selection.erase(instance);
- }
-
- ASSERT_MESSAGE(m_selection.size() == m_count_primitive.size(), "selection-tracking error");
- }
- void onComponentSelection(scene::Instance& instance, const Selectable& selectable)
- {
- if(selectable.isSelected())
- {
- m_component_selection.append(instance);
- }
- else
- {
- m_component_selection.erase(instance);
- }
-
- ASSERT_MESSAGE(m_component_selection.size() == m_count_component.size(), "selection-tracking error");
- }
- scene::Instance& ultimateSelected() const
- {
- ASSERT_MESSAGE(m_selection.size() > 0, "no instance selected");
- return m_selection.back();
- }
- scene::Instance& penultimateSelected() const
- {
- ASSERT_MESSAGE(m_selection.size() > 1, "only one instance selected");
- return *(*(--(--m_selection.end())));
- }
- void setSelectedAll(bool selected)
- {
- GlobalSceneGraph().traverse(select_all(selected));
-
- m_manipulator->setSelected(selected);
- }
- void setSelectedAllComponents(bool selected)
- {
- Scene_SelectAll_Component(selected, SelectionSystem::eVertex);
- Scene_SelectAll_Component(selected, SelectionSystem::eEdge);
- Scene_SelectAll_Component(selected, SelectionSystem::eFace);
-
- m_manipulator->setSelected(selected);
- }
-
- void foreachSelected(const Visitor& visitor) const
- {
- selection_t::const_iterator i = m_selection.begin();
- while(i != m_selection.end())
- {
- visitor.visit(*(*(i++)));
- }
- }
- void foreachSelectedComponent(const Visitor& visitor) const
- {
- selection_t::const_iterator i = m_component_selection.begin();
- while(i != m_component_selection.end())
- {
- visitor.visit(*(*(i++)));
- }
- }
-
- void addSelectionChangeCallback(const SelectionChangeHandler& handler)
- {
- m_selectionChanged_callbacks.connectLast(handler);
- }
- void selectionChanged(const Selectable& selectable)
- {
- m_selectionChanged_callbacks(selectable);
- }
- typedef MemberCaller1<RadiantSelectionSystem, const Selectable&, &RadiantSelectionSystem::selectionChanged> SelectionChangedCaller;
-
-
- void startMove()
- {
- m_pivot2world_start = GetPivot2World();
- }
- bool SelectManipulator(const View& view, const float device_point[2], const float device_epsilon[2])
- {
- if(!nothingSelected() || (ManipulatorMode() == eDrag && Mode() == eComponent))
- {
-#if defined (DEBUG_SELECTION)
- g_render_clipped.destroy();
-#endif
+ void rotate(const Quaternion &rotation)
+ {
+ if (!nothingSelected()) {
+ //ASSERT_MESSAGE(!m_pivotChanged, "pivot is invalid");
- m_manipulator->setSelected(false);
+ m_rotation = rotation;
- if(!nothingSelected() || (ManipulatorMode() == eDrag && Mode() == eComponent))
- {
- View scissored(view);
- ConstructSelectionTest(scissored, SelectionBoxForPoint(device_point, device_epsilon));
- m_manipulator->testSelect(scissored, GetPivot2World());
- }
+ if (Mode() == eComponent) {
+ Scene_Rotate_Component_Selected(GlobalSceneGraph(), m_rotation, vector4_to_vector3(m_pivot2world.t()));
- startMove();
+ matrix4_assign_rotation_for_pivot(m_pivot2world, m_component_selection.back());
+ } else {
+ Scene_Rotate_Selected(GlobalSceneGraph(), m_rotation, vector4_to_vector3(m_pivot2world.t()));
- m_pivot_moving = m_manipulator->isSelected();
+ matrix4_assign_rotation_for_pivot(m_pivot2world, m_selection.back());
+ }
- if(m_pivot_moving)
- {
- Pivot2World pivot;
- pivot.update(GetPivot2World(), view.GetModelview(), view.GetProjection(), view.GetViewport());
+ SceneChangeNotify();
+ }
+ }
- m_manip2pivot_start = matrix4_multiplied_by_matrix4(matrix4_full_inverse(m_pivot2world_start), pivot.m_worldSpace);
+ void outputRotation(TextOutputStream &ostream)
+ {
+ ostream << " -eulerXYZ " << m_rotation.x() << " " << m_rotation.y() << " " << m_rotation.z();
+ }
- Matrix4 device2manip;
- ConstructDevice2Manip(device2manip, m_pivot2world_start, view.GetModelview(), view.GetProjection(), view.GetViewport());
- m_manipulator->GetManipulatable()->Construct(device2manip, device_point[0], device_point[1]);
+ void scale(const Vector3 &scaling)
+ {
+ if (!nothingSelected()) {
+ m_scale = scaling;
- m_undo_begun = false;
- }
+ if (Mode() == eComponent) {
+ Scene_Scale_Component_Selected(GlobalSceneGraph(), m_scale, vector4_to_vector3(m_pivot2world.t()));
+ } else {
+ Scene_Scale_Selected(GlobalSceneGraph(), m_scale, vector4_to_vector3(m_pivot2world.t()));
+ }
- SceneChangeNotify();
+ SceneChangeNotify();
+ }
}
- return m_pivot_moving;
- }
+ void outputScale(TextOutputStream &ostream)
+ {
+ ostream << " -scale " << m_scale.x() << " " << m_scale.y() << " " << m_scale.z();
+ }
- void deselectAll()
- {
- if(Mode() == eComponent)
+ void rotateSelected(const Quaternion &rotation)
{
- setSelectedAllComponents(false);
+ startMove();
+ rotate(rotation);
+ freezeTransforms();
}
- else
+
+ void translateSelected(const Vector3 &translation)
{
- setSelectedAll(false);
+ startMove();
+ translate(translation);
+ freezeTransforms();
}
- }
- void SelectPoint(const View& view, const float device_point[2], const float device_epsilon[2], RadiantSelectionSystem::EModifier modifier, bool face)
- {
- ASSERT_MESSAGE(fabs(device_point[0]) <= 1.0f && fabs(device_point[1]) <= 1.0f, "point-selection error");
- if(modifier == eReplace)
+ void scaleSelected(const Vector3 &scaling)
{
- if(face)
- {
- setSelectedAllComponents(false);
- }
- else
- {
- deselectAll();
- }
+ startMove();
+ scale(scaling);
+ freezeTransforms();
}
- #if defined (DEBUG_SELECTION)
- g_render_clipped.destroy();
- #endif
+ void MoveSelected(const View &view, const float device_point[2])
+ {
+ if (m_manipulator->isSelected()) {
+ if (!m_undo_begun) {
+ m_undo_begun = true;
+ GlobalUndoSystem().start();
+ }
+
+ Matrix4 device2manip;
+ ConstructDevice2Manip(device2manip, m_pivot2world_start, view.GetModelview(), view.GetProjection(),
+ view.GetViewport());
+ m_manipulator->GetManipulatable()->Transform(m_manip2pivot_start, device2manip, device_point[0],
+ device_point[1]);
+ }
+ }
+/// \todo Support view-dependent nudge.
+ void NudgeManipulator(const Vector3 &nudge, const Vector3 &view)
{
- View scissored(view);
- ConstructSelectionTest(scissored, SelectionBoxForPoint(device_point, device_epsilon));
+ if (ManipulatorMode() == eTranslate || ManipulatorMode() == eDrag) {
+ translateSelected(nudge);
+ }
+ }
- SelectionVolume volume(scissored);
- SelectionPool selector;
- if(face)
- {
- Scene_TestSelect_Component(selector, volume, scissored, eFace);
- }
- else
- {
- Scene_TestSelect(selector, volume, scissored, Mode(), ComponentMode());
- }
+ void endMove();
- if(!selector.failed())
- {
- switch(modifier)
- {
- case RadiantSelectionSystem::eToggle:
- {
- SelectableSortedSet::iterator best = selector.begin();
- // toggle selection of the object with least depth
- if((*best).second->isSelected())
- (*best).second->setSelected(false);
- else
- (*best).second->setSelected(true);
- }
- break;
- // if cycle mode not enabled, enable it
- case RadiantSelectionSystem::eReplace:
- {
- // select closest
- (*selector.begin()).second->setSelected(true);
- }
- break;
- // select the next object in the list from the one already selected
- case RadiantSelectionSystem::eCycle:
- {
- SelectionPool::iterator i = selector.begin();
- while(i != selector.end())
- {
- if((*i).second->isSelected())
- {
- (*i).second->setSelected(false);
- ++i;
- if(i != selector.end())
- {
- i->second->setSelected(true);
- }
- else
- {
- selector.begin()->second->setSelected(true);
- }
- break;
- }
- ++i;
- }
- }
- break;
- default:
- break;
- }
- }
- }
- }
-
- void SelectArea(const View& view, const float device_point[2], const float device_delta[2], RadiantSelectionSystem::EModifier modifier, bool face)
- {
- if(modifier == eReplace)
- {
- if(face)
- {
- setSelectedAllComponents(false);
- }
- else
- {
- deselectAll();
- }
- }
-
- #if defined (DEBUG_SELECTION)
- g_render_clipped.destroy();
- #endif
-
- {
- View scissored(view);
- ConstructSelectionTest(scissored, SelectionBoxForArea(device_point, device_delta));
-
- SelectionVolume volume(scissored);
- SelectionPool pool;
- if(face)
- {
- Scene_TestSelect_Component(pool, volume, scissored, eFace);
- }
- else
- {
- Scene_TestSelect(pool, volume, scissored, Mode(), ComponentMode());
- }
-
- for(SelectionPool::iterator i = pool.begin(); i != pool.end(); ++i)
- {
- (*i).second->setSelected(!(modifier == RadiantSelectionSystem::eToggle && (*i).second->isSelected()));
- }
- }
- }
-
-
- void translate(const Vector3& translation)
- {
- if(!nothingSelected())
- {
- //ASSERT_MESSAGE(!m_pivotChanged, "pivot is invalid");
-
- m_translation = translation;
-
- m_pivot2world = m_pivot2world_start;
- matrix4_translate_by_vec3(m_pivot2world, translation);
-
- if(Mode() == eComponent)
- {
- Scene_Translate_Component_Selected(GlobalSceneGraph(), m_translation);
- }
- else
- {
- Scene_Translate_Selected(GlobalSceneGraph(), m_translation);
- }
-
- SceneChangeNotify();
- }
- }
- void outputTranslation(TextOutputStream& ostream)
- {
- ostream << " -xyz " << m_translation.x() << " " << m_translation.y() << " " << m_translation.z();
- }
- void rotate(const Quaternion& rotation)
- {
- if(!nothingSelected())
- {
- //ASSERT_MESSAGE(!m_pivotChanged, "pivot is invalid");
-
- m_rotation = rotation;
-
- if(Mode() == eComponent)
- {
- Scene_Rotate_Component_Selected(GlobalSceneGraph(), m_rotation, vector4_to_vector3(m_pivot2world.t()));
-
- matrix4_assign_rotation_for_pivot(m_pivot2world, m_component_selection.back());
- }
- else
- {
- Scene_Rotate_Selected(GlobalSceneGraph(), m_rotation, vector4_to_vector3(m_pivot2world.t()));
-
- matrix4_assign_rotation_for_pivot(m_pivot2world, m_selection.back());
- }
-
- SceneChangeNotify();
- }
- }
- void outputRotation(TextOutputStream& ostream)
- {
- ostream << " -eulerXYZ " << m_rotation.x() << " " << m_rotation.y() << " " << m_rotation.z();
- }
- void scale(const Vector3& scaling)
- {
- if(!nothingSelected())
- {
- m_scale = scaling;
-
- if(Mode() == eComponent)
- {
- Scene_Scale_Component_Selected(GlobalSceneGraph(), m_scale, vector4_to_vector3(m_pivot2world.t()));
- }
- else
- {
- Scene_Scale_Selected(GlobalSceneGraph(), m_scale, vector4_to_vector3(m_pivot2world.t()));
- }
-
- SceneChangeNotify();
- }
- }
- void outputScale(TextOutputStream& ostream)
- {
- ostream << " -scale " << m_scale.x() << " " << m_scale.y() << " " << m_scale.z();
- }
-
- void rotateSelected(const Quaternion& rotation)
- {
- startMove();
- rotate(rotation);
- freezeTransforms();
- }
- void translateSelected(const Vector3& translation)
- {
- startMove();
- translate(translation);
- freezeTransforms();
- }
- void scaleSelected(const Vector3& scaling)
- {
- startMove();
- scale(scaling);
- freezeTransforms();
- }
-
- void MoveSelected(const View& view, const float device_point[2])
- {
- if(m_manipulator->isSelected())
- {
- if(!m_undo_begun)
- {
- m_undo_begun = true;
- GlobalUndoSystem().start();
- }
-
- Matrix4 device2manip;
- ConstructDevice2Manip(device2manip, m_pivot2world_start, view.GetModelview(), view.GetProjection(), view.GetViewport());
- m_manipulator->GetManipulatable()->Transform(m_manip2pivot_start, device2manip, device_point[0], device_point[1]);
- }
- }
-
- /// \todo Support view-dependent nudge.
- void NudgeManipulator(const Vector3& nudge, const Vector3& view)
- {
- if(ManipulatorMode() == eTranslate || ManipulatorMode() == eDrag)
- {
- translateSelected(nudge);
- }
- }
-
- void endMove();
- void freezeTransforms();
-
- void renderSolid(Renderer& renderer, const VolumeTest& volume) const;
- void renderWireframe(Renderer& renderer, const VolumeTest& volume) const
- {
- renderSolid(renderer, volume);
- }
-
- const Matrix4& GetPivot2World() const
- {
- ConstructPivot();
- return m_pivot2world;
- }
-
- static void constructStatic()
- {
- m_state = GlobalShaderCache().capture("$POINT");
- #if defined(DEBUG_SELECTION)
- g_state_clipped = GlobalShaderCache().capture("$DEBUG_CLIPPED");
- #endif
- TranslateManipulator::m_state_wire = GlobalShaderCache().capture("$WIRE_OVERLAY");
- TranslateManipulator::m_state_fill = GlobalShaderCache().capture("$FLATSHADE_OVERLAY");
- RotateManipulator::m_state_outer = GlobalShaderCache().capture("$WIRE_OVERLAY");
- }
-
- static void destroyStatic()
- {
- #if defined(DEBUG_SELECTION)
- GlobalShaderCache().release("$DEBUG_CLIPPED");
- #endif
- GlobalShaderCache().release("$WIRE_OVERLAY");
- GlobalShaderCache().release("$FLATSHADE_OVERLAY");
- GlobalShaderCache().release("$WIRE_OVERLAY");
- GlobalShaderCache().release("$POINT");
- }
+ void freezeTransforms();
+
+ void renderSolid(Renderer &renderer, const VolumeTest &volume) const;
+
+ void renderWireframe(Renderer &renderer, const VolumeTest &volume) const
+ {
+ renderSolid(renderer, volume);
+ }
+
+ const Matrix4 &GetPivot2World() const
+ {
+ ConstructPivot();
+ return m_pivot2world;
+ }
+
+ static void constructStatic()
+ {
+ m_state = GlobalShaderCache().capture("$POINT");
+#if defined( DEBUG_SELECTION )
+ g_state_clipped = GlobalShaderCache().capture("$DEBUG_CLIPPED");
+#endif
+ TranslateManipulator::m_state_wire = GlobalShaderCache().capture("$WIRE_OVERLAY");
+ TranslateManipulator::m_state_fill = GlobalShaderCache().capture("$FLATSHADE_OVERLAY");
+ RotateManipulator::m_state_outer = GlobalShaderCache().capture("$WIRE_OVERLAY");
+ }
+
+ static void destroyStatic()
+ {
+#if defined( DEBUG_SELECTION )
+ GlobalShaderCache().release("$DEBUG_CLIPPED");
+#endif
+ GlobalShaderCache().release("$WIRE_OVERLAY");
+ GlobalShaderCache().release("$FLATSHADE_OVERLAY");
+ GlobalShaderCache().release("$WIRE_OVERLAY");
+ GlobalShaderCache().release("$POINT");
+ }
};
-Shader* RadiantSelectionSystem::m_state = 0;
+Shader *RadiantSelectionSystem::m_state = 0;
-namespace
-{
- RadiantSelectionSystem* g_RadiantSelectionSystem;
+namespace {
+ RadiantSelectionSystem *g_RadiantSelectionSystem;
- inline RadiantSelectionSystem& getSelectionSystem()
- {
- return *g_RadiantSelectionSystem;
- }
+ inline RadiantSelectionSystem &getSelectionSystem()
+ {
+ return *g_RadiantSelectionSystem;
+ }
}
-
-class testselect_entity_visible : public scene::Graph::Walker
-{
- Selector& m_selector;
- SelectionTest& m_test;
+class testselect_entity_visible : public scene::Graph::Walker {
+ Selector &m_selector;
+ SelectionTest &m_test;
public:
- testselect_entity_visible(Selector& selector, SelectionTest& test)
- : m_selector(selector), m_test(test)
- {
- }
- bool pre(const scene::Path& path, scene::Instance& instance) const
- {
- Selectable* selectable = Instance_getSelectable(instance);
- if(selectable != 0
- && Node_isEntity(path.top()))
+ testselect_entity_visible(Selector &selector, SelectionTest &test)
+ : m_selector(selector), m_test(test)
{
- m_selector.pushSelectable(*selectable);
}
- SelectionTestable* selectionTestable = Instance_getSelectionTestable(instance);
- if(selectionTestable)
+ bool pre(const scene::Path &path, scene::Instance &instance) const
{
- selectionTestable->testSelect(m_selector, m_test);
+ Selectable *selectable = Instance_getSelectable(instance);
+ if (selectable != 0
+ && Node_isEntity(path.top())) {
+ m_selector.pushSelectable(*selectable);
+ }
+
+ SelectionTestable *selectionTestable = Instance_getSelectionTestable(instance);
+ if (selectionTestable) {
+ selectionTestable->testSelect(m_selector, m_test);
+ }
+
+ return true;
}
- return true;
- }
- void post(const scene::Path& path, scene::Instance& instance) const
- {
- Selectable* selectable = Instance_getSelectable(instance);
- if(selectable != 0
- && Node_isEntity(path.top()))
+ void post(const scene::Path &path, scene::Instance &instance) const
{
- m_selector.popSelectable();
+ Selectable *selectable = Instance_getSelectable(instance);
+ if (selectable != 0
+ && Node_isEntity(path.top())) {
+ m_selector.popSelectable();
+ }
}
- }
};
-class testselect_primitive_visible : public scene::Graph::Walker
-{
- Selector& m_selector;
- SelectionTest& m_test;
+class testselect_primitive_visible : public scene::Graph::Walker {
+ Selector &m_selector;
+ SelectionTest &m_test;
public:
- testselect_primitive_visible(Selector& selector, SelectionTest& test)
- : m_selector(selector), m_test(test)
- {
- }
- bool pre(const scene::Path& path, scene::Instance& instance) const
- {
- Selectable* selectable = Instance_getSelectable(instance);
- if(selectable != 0)
+ testselect_primitive_visible(Selector &selector, SelectionTest &test)
+ : m_selector(selector), m_test(test)
{
- m_selector.pushSelectable(*selectable);
}
- SelectionTestable* selectionTestable = Instance_getSelectionTestable(instance);
- if(selectionTestable)
+ bool pre(const scene::Path &path, scene::Instance &instance) const
{
- selectionTestable->testSelect(m_selector, m_test);
+ Selectable *selectable = Instance_getSelectable(instance);
+ if (selectable != 0) {
+ m_selector.pushSelectable(*selectable);
+ }
+
+ SelectionTestable *selectionTestable = Instance_getSelectionTestable(instance);
+ if (selectionTestable) {
+ selectionTestable->testSelect(m_selector, m_test);
+ }
+
+ return true;
}
- return true;
- }
- void post(const scene::Path& path, scene::Instance& instance) const
- {
- Selectable* selectable = Instance_getSelectable(instance);
- if(selectable != 0)
+ void post(const scene::Path &path, scene::Instance &instance) const
{
- m_selector.popSelectable();
+ Selectable *selectable = Instance_getSelectable(instance);
+ if (selectable != 0) {
+ m_selector.popSelectable();
+ }
}
- }
};
-class testselect_component_visible : public scene::Graph::Walker
-{
- Selector& m_selector;
- SelectionTest& m_test;
- SelectionSystem::EComponentMode m_mode;
+class testselect_component_visible : public scene::Graph::Walker {
+ Selector &m_selector;
+ SelectionTest &m_test;
+ SelectionSystem::EComponentMode m_mode;
public:
- testselect_component_visible(Selector& selector, SelectionTest& test, SelectionSystem::EComponentMode mode)
- : m_selector(selector), m_test(test), m_mode(mode)
- {
- }
- bool pre(const scene::Path& path, scene::Instance& instance) const
- {
- ComponentSelectionTestable* componentSelectionTestable = Instance_getComponentSelectionTestable(instance);
- if(componentSelectionTestable)
+ testselect_component_visible(Selector &selector, SelectionTest &test, SelectionSystem::EComponentMode mode)
+ : m_selector(selector), m_test(test), m_mode(mode)
{
- componentSelectionTestable->testSelectComponents(m_selector, m_test, m_mode);
}
- return true;
- }
+ bool pre(const scene::Path &path, scene::Instance &instance) const
+ {
+ ComponentSelectionTestable *componentSelectionTestable = Instance_getComponentSelectionTestable(instance);
+ if (componentSelectionTestable) {
+ componentSelectionTestable->testSelectComponents(m_selector, m_test, m_mode);
+ }
+
+ return true;
+ }
};
-class testselect_component_visible_selected : public scene::Graph::Walker
-{
- Selector& m_selector;
- SelectionTest& m_test;
- SelectionSystem::EComponentMode m_mode;
+class testselect_component_visible_selected : public scene::Graph::Walker {
+ Selector &m_selector;
+ SelectionTest &m_test;
+ SelectionSystem::EComponentMode m_mode;
public:
- testselect_component_visible_selected(Selector& selector, SelectionTest& test, SelectionSystem::EComponentMode mode)
- : m_selector(selector), m_test(test), m_mode(mode)
- {
- }
- bool pre(const scene::Path& path, scene::Instance& instance) const
- {
- Selectable* selectable = Instance_getSelectable(instance);
- if(selectable != 0 && selectable->isSelected())
- {
- ComponentSelectionTestable* componentSelectionTestable = Instance_getComponentSelectionTestable(instance);
- if(componentSelectionTestable)
- {
- componentSelectionTestable->testSelectComponents(m_selector, m_test, m_mode);
- }
- }
-
- return true;
- }
+ testselect_component_visible_selected(Selector &selector, SelectionTest &test, SelectionSystem::EComponentMode mode)
+ : m_selector(selector), m_test(test), m_mode(mode)
+ {
+ }
+
+ bool pre(const scene::Path &path, scene::Instance &instance) const
+ {
+ Selectable *selectable = Instance_getSelectable(instance);
+ if (selectable != 0 && selectable->isSelected()) {
+ ComponentSelectionTestable *componentSelectionTestable = Instance_getComponentSelectionTestable(instance);
+ if (componentSelectionTestable) {
+ componentSelectionTestable->testSelectComponents(m_selector, m_test, m_mode);
+ }
+ }
+
+ return true;
+ }
};
-void Scene_TestSelect_Primitive(Selector& selector, SelectionTest& test, const VolumeTest& volume)
+void Scene_TestSelect_Primitive(Selector &selector, SelectionTest &test, const VolumeTest &volume)
{
- Scene_forEachVisible(GlobalSceneGraph(), volume, testselect_primitive_visible(selector, test));
+ Scene_forEachVisible(GlobalSceneGraph(), volume, testselect_primitive_visible(selector, test));
}
-void Scene_TestSelect_Component_Selected(Selector& selector, SelectionTest& test, const VolumeTest& volume, SelectionSystem::EComponentMode componentMode)
+void Scene_TestSelect_Component_Selected(Selector &selector, SelectionTest &test, const VolumeTest &volume,
+ SelectionSystem::EComponentMode componentMode)
{
- Scene_forEachVisible(GlobalSceneGraph(), volume, testselect_component_visible_selected(selector, test, componentMode));
+ Scene_forEachVisible(GlobalSceneGraph(), volume,
+ testselect_component_visible_selected(selector, test, componentMode));
}
-void Scene_TestSelect_Component(Selector& selector, SelectionTest& test, const VolumeTest& volume, SelectionSystem::EComponentMode componentMode)
+void Scene_TestSelect_Component(Selector &selector, SelectionTest &test, const VolumeTest &volume,
+ SelectionSystem::EComponentMode componentMode)
{
- Scene_forEachVisible(GlobalSceneGraph(), volume, testselect_component_visible(selector, test, componentMode));
+ Scene_forEachVisible(GlobalSceneGraph(), volume, testselect_component_visible(selector, test, componentMode));
}
-void RadiantSelectionSystem::Scene_TestSelect(Selector& selector, SelectionTest& test, const View& view, SelectionSystem::EMode mode, SelectionSystem::EComponentMode componentMode)
+void RadiantSelectionSystem::Scene_TestSelect(Selector &selector, SelectionTest &test, const View &view,
+ SelectionSystem::EMode mode,
+ SelectionSystem::EComponentMode componentMode)
{
- switch(mode)
- {
- case eEntity:
- {
- Scene_forEachVisible(GlobalSceneGraph(), view, testselect_entity_visible(selector, test));
- }
- break;
- case ePrimitive:
- Scene_TestSelect_Primitive(selector, test, view);
- break;
- case eComponent:
- Scene_TestSelect_Component_Selected(selector, test, view, componentMode);
- break;
- }
+ switch (mode) {
+ case eEntity: {
+ Scene_forEachVisible(GlobalSceneGraph(), view, testselect_entity_visible(selector, test));
+ }
+ break;
+ case ePrimitive:
+ Scene_TestSelect_Primitive(selector, test, view);
+ break;
+ case eComponent:
+ Scene_TestSelect_Component_Selected(selector, test, view, componentMode);
+ break;
+ }
}
-class FreezeTransforms : public scene::Graph::Walker
-{
+class FreezeTransforms : public scene::Graph::Walker {
public:
- bool pre(const scene::Path& path, scene::Instance& instance) const
- {
- TransformNode* transformNode = Node_getTransformNode(path.top());
- if(transformNode != 0)
- {
- Transformable* transform = Instance_getTransformable(instance);
- if(transform != 0)
- {
- transform->freezeTransform();
- }
- }
- return true;
- }
+ bool pre(const scene::Path &path, scene::Instance &instance) const
+ {
+ TransformNode *transformNode = Node_getTransformNode(path.top());
+ if (transformNode != 0) {
+ Transformable *transform = Instance_getTransformable(instance);
+ if (transform != 0) {
+ transform->freezeTransform();
+ }
+ }
+ return true;
+ }
};
void RadiantSelectionSystem::freezeTransforms()
{
- GlobalSceneGraph().traverse(FreezeTransforms());
+ GlobalSceneGraph().traverse(FreezeTransforms());
}
void RadiantSelectionSystem::endMove()
{
- freezeTransforms();
+ freezeTransforms();
- if(Mode() == ePrimitive)
- {
- if(ManipulatorMode() == eDrag)
- {
- Scene_SelectAll_Component(false, SelectionSystem::eFace);
+ if (Mode() == ePrimitive) {
+ if (ManipulatorMode() == eDrag) {
+ Scene_SelectAll_Component(false, SelectionSystem::eFace);
+ }
}
- }
- m_pivot_moving = false;
- pivotChanged();
+ m_pivot_moving = false;
+ pivotChanged();
- SceneChangeNotify();
+ SceneChangeNotify();
- if(m_undo_begun)
- {
- StringOutputStream command;
+ if (m_undo_begun) {
+ StringOutputStream command;
+
+ if (ManipulatorMode() == eTranslate) {
+ command << "translateTool";
+ outputTranslation(command);
+ } else if (ManipulatorMode() == eRotate) {
+ command << "rotateTool";
+ outputRotation(command);
+ } else if (ManipulatorMode() == eScale) {
+ command << "scaleTool";
+ outputScale(command);
+ } else if (ManipulatorMode() == eDrag) {
+ command << "dragTool";
+ }
- if(ManipulatorMode() == eTranslate)
- {
- command << "translateTool";
- outputTranslation(command);
- }
- else if(ManipulatorMode() == eRotate)
- {
- command << "rotateTool";
- outputRotation(command);
- }
- else if(ManipulatorMode() == eScale)
- {
- command << "scaleTool";
- outputScale(command);
- }
- else if(ManipulatorMode() == eDrag)
- {
- command << "dragTool";
+ GlobalUndoSystem().finish(command.c_str());
}
- GlobalUndoSystem().finish(command.c_str());
- }
-
}
-inline AABB Instance_getPivotBounds(scene::Instance& instance)
+inline AABB Instance_getPivotBounds(scene::Instance &instance)
{
- Entity* entity = Node_getEntity(instance.path().top());
- if(entity != 0
- && (entity->getEntityClass().fixedsize
- || !node_is_group(instance.path().top())))
- {
- Editable* editable = Node_getEditable(instance.path().top());
- if(editable != 0)
- {
- return AABB(vector4_to_vector3(matrix4_multiplied_by_matrix4(instance.localToWorld(), editable->getLocalPivot()).t()), Vector3(0, 0, 0));
- }
- else
- {
- return AABB(vector4_to_vector3(instance.localToWorld().t()), Vector3(0, 0, 0));
+ Entity *entity = Node_getEntity(instance.path().top());
+ if (entity != 0
+ && (entity->getEntityClass().fixedsize
+ || !node_is_group(instance.path().top()))) {
+ Editable *editable = Node_getEditable(instance.path().top());
+ if (editable != 0) {
+ return AABB(vector4_to_vector3(
+ matrix4_multiplied_by_matrix4(instance.localToWorld(), editable->getLocalPivot()).t()),
+ Vector3(0, 0, 0));
+ } else {
+ return AABB(vector4_to_vector3(instance.localToWorld().t()), Vector3(0, 0, 0));
+ }
}
- }
- return instance.worldAABB();
+ return instance.worldAABB();
}
-class bounds_selected : public scene::Graph::Walker
-{
- AABB& m_bounds;
+class bounds_selected : public scene::Graph::Walker {
+ AABB &m_bounds;
public:
- bounds_selected(AABB& bounds)
- : m_bounds(bounds)
- {
- m_bounds = AABB();
- }
- bool pre(const scene::Path& path, scene::Instance& instance) const
- {
- Selectable* selectable = Instance_getSelectable(instance);
- if(selectable != 0
- && selectable->isSelected())
- {
- aabb_extend_by_aabb_safe(m_bounds, Instance_getPivotBounds(instance));
- }
- return true;
- }
+ bounds_selected(AABB &bounds)
+ : m_bounds(bounds)
+ {
+ m_bounds = AABB();
+ }
+
+ bool pre(const scene::Path &path, scene::Instance &instance) const
+ {
+ Selectable *selectable = Instance_getSelectable(instance);
+ if (selectable != 0
+ && selectable->isSelected()) {
+ aabb_extend_by_aabb_safe(m_bounds, Instance_getPivotBounds(instance));
+ }
+ return true;
+ }
};
-class bounds_selected_component : public scene::Graph::Walker
-{
- AABB& m_bounds;
+class bounds_selected_component : public scene::Graph::Walker {
+ AABB &m_bounds;
public:
- bounds_selected_component(AABB& bounds)
- : m_bounds(bounds)
- {
- m_bounds = AABB();
- }
- bool pre(const scene::Path& path, scene::Instance& instance) const
- {
- Selectable* selectable = Instance_getSelectable(instance);
- if(selectable != 0
- && selectable->isSelected())
- {
- ComponentEditable* componentEditable = Instance_getComponentEditable(instance);
- if(componentEditable)
- {
- aabb_extend_by_aabb_safe(m_bounds, aabb_for_oriented_aabb_safe(componentEditable->getSelectedComponentsBounds(), instance.localToWorld()));
- }
- }
- return true;
- }
+ bounds_selected_component(AABB &bounds)
+ : m_bounds(bounds)
+ {
+ m_bounds = AABB();
+ }
+
+ bool pre(const scene::Path &path, scene::Instance &instance) const
+ {
+ Selectable *selectable = Instance_getSelectable(instance);
+ if (selectable != 0
+ && selectable->isSelected()) {
+ ComponentEditable *componentEditable = Instance_getComponentEditable(instance);
+ if (componentEditable) {
+ aabb_extend_by_aabb_safe(m_bounds,
+ aabb_for_oriented_aabb_safe(componentEditable->getSelectedComponentsBounds(),
+ instance.localToWorld()));
+ }
+ }
+ return true;
+ }
};
-void Scene_BoundsSelected(scene::Graph& graph, AABB& bounds)
+void Scene_BoundsSelected(scene::Graph &graph, AABB &bounds)
{
- graph.traverse(bounds_selected(bounds));
+ graph.traverse(bounds_selected(bounds));
}
-void Scene_BoundsSelectedComponent(scene::Graph& graph, AABB& bounds)
+void Scene_BoundsSelectedComponent(scene::Graph &graph, AABB &bounds)
{
- graph.traverse(bounds_selected_component(bounds));
+ graph.traverse(bounds_selected_component(bounds));
}
#if 0
-inline void pivot_for_node(Matrix4& pivot, scene::Node& node, scene::Instance& instance)
-{
- ComponentEditable* componentEditable = Instance_getComponentEditable(instance);
- if(GlobalSelectionSystem().Mode() == SelectionSystem::eComponent
- && componentEditable != 0)
- {
- pivot = matrix4_translation_for_vec3(componentEditable->getSelectedComponentsBounds().origin);
- }
- else
- {
- Bounded* bounded = Instance_getBounded(instance);
- if(bounded != 0)
- {
- pivot = matrix4_translation_for_vec3(bounded->localAABB().origin);
- }
- else
- {
- pivot = g_matrix4_identity;
- }
- }
+ inline void pivot_for_node( Matrix4& pivot, scene::Node& node, scene::Instance& instance ){
+ ComponentEditable* componentEditable = Instance_getComponentEditable( instance );
+ if ( GlobalSelectionSystem().Mode() == SelectionSystem::eComponent
+ && componentEditable != 0 ) {
+ pivot = matrix4_translation_for_vec3( componentEditable->getSelectedComponentsBounds().origin );
+ }
+ else
+ {
+ Bounded* bounded = Instance_getBounded( instance );
+ if ( bounded != 0 ) {
+ pivot = matrix4_translation_for_vec3( bounded->localAABB().origin );
+ }
+ else
+ {
+ pivot = g_matrix4_identity;
+ }
+ }
}
#endif
void RadiantSelectionSystem::ConstructPivot() const
{
- if(!m_pivotChanged || m_pivot_moving)
- return;
- m_pivotChanged = false;
-
- Vector3 m_object_pivot;
-
- if(!nothingSelected())
- {
- {
- AABB bounds;
- if(Mode() == eComponent)
- {
- Scene_BoundsSelectedComponent(GlobalSceneGraph(), bounds);
- }
- else
- {
- Scene_BoundsSelected(GlobalSceneGraph(), bounds);
- }
- m_object_pivot = bounds.origin;
- }
-
- vector3_snap(m_object_pivot, GetGridSize());
- m_pivot2world = matrix4_translation_for_vec3(m_object_pivot);
-
- switch(m_manipulator_mode)
- {
- case eTranslate:
- break;
- case eRotate:
- if(Mode() == eComponent)
- {
- matrix4_assign_rotation_for_pivot(m_pivot2world, m_component_selection.back());
- }
- else
- {
- matrix4_assign_rotation_for_pivot(m_pivot2world, m_selection.back());
- }
- break;
- case eScale:
- if(Mode() == eComponent)
- {
- matrix4_assign_rotation_for_pivot(m_pivot2world, m_component_selection.back());
- }
- else
- {
- matrix4_assign_rotation_for_pivot(m_pivot2world, m_selection.back());
- }
- break;
- default:
- break;
- }
- }
+ if (!m_pivotChanged || m_pivot_moving) {
+ return;
+ }
+ m_pivotChanged = false;
+
+ Vector3 m_object_pivot;
+
+ if (!nothingSelected()) {
+ {
+ AABB bounds;
+ if (Mode() == eComponent) {
+ Scene_BoundsSelectedComponent(GlobalSceneGraph(), bounds);
+ } else {
+ Scene_BoundsSelected(GlobalSceneGraph(), bounds);
+ }
+ m_object_pivot = bounds.origin;
+ }
+
+ vector3_snap(m_object_pivot, GetSnapGridSize());
+ m_pivot2world = matrix4_translation_for_vec3(m_object_pivot);
+
+ switch (m_manipulator_mode) {
+ case eTranslate:
+ break;
+ case eRotate:
+ if (Mode() == eComponent) {
+ matrix4_assign_rotation_for_pivot(m_pivot2world, m_component_selection.back());
+ } else {
+ matrix4_assign_rotation_for_pivot(m_pivot2world, m_selection.back());
+ }
+ break;
+ case eScale:
+ if (Mode() == eComponent) {
+ matrix4_assign_rotation_for_pivot(m_pivot2world, m_component_selection.back());
+ } else {
+ matrix4_assign_rotation_for_pivot(m_pivot2world, m_selection.back());
+ }
+ break;
+ default:
+ break;
+ }
+ }
}
-void RadiantSelectionSystem::renderSolid(Renderer& renderer, const VolumeTest& volume) const
+void RadiantSelectionSystem::renderSolid(Renderer &renderer, const VolumeTest &volume) const
{
- //if(view->TestPoint(m_object_pivot))
- if(!nothingSelected())
- {
- renderer.Highlight(Renderer::ePrimitive, false);
- renderer.Highlight(Renderer::eFace, false);
-
- renderer.SetState(m_state, Renderer::eWireframeOnly);
- renderer.SetState(m_state, Renderer::eFullMaterials);
-
- m_manipulator->render(renderer, volume, GetPivot2World());
- }
-
-#if defined(DEBUG_SELECTION)
- renderer.SetState(g_state_clipped, Renderer::eWireframeOnly);
- renderer.SetState(g_state_clipped, Renderer::eFullMaterials);
- renderer.addRenderable(g_render_clipped, g_render_clipped.m_world);
+ //if(view->TestPoint(m_object_pivot))
+ if (!nothingSelected()) {
+ renderer.Highlight(Renderer::ePrimitive, false);
+ renderer.Highlight(Renderer::eFace, false);
+
+ renderer.SetState(m_state, Renderer::eWireframeOnly);
+ renderer.SetState(m_state, Renderer::eFullMaterials);
+
+ m_manipulator->render(renderer, volume, GetPivot2World());
+ }
+
+#if defined( DEBUG_SELECTION )
+ renderer.SetState(g_state_clipped, Renderer::eWireframeOnly);
+ renderer.SetState(g_state_clipped, Renderer::eFullMaterials);
+ renderer.addRenderable(g_render_clipped, g_render_clipped.m_world);
#endif
}
void SelectionSystem_OnBoundsChanged()
{
- getSelectionSystem().pivotChanged();
+ getSelectionSystem().pivotChanged();
}
void SelectionSystem_Construct()
{
- RadiantSelectionSystem::constructStatic();
+ RadiantSelectionSystem::constructStatic();
- g_RadiantSelectionSystem = new RadiantSelectionSystem;
+ g_RadiantSelectionSystem = new RadiantSelectionSystem;
- SelectionSystem_boundsChanged = GlobalSceneGraph().addBoundsChangedCallback(FreeCaller<SelectionSystem_OnBoundsChanged>());
+ SelectionSystem_boundsChanged = GlobalSceneGraph().addBoundsChangedCallback(
+ FreeCaller<void(), SelectionSystem_OnBoundsChanged>());
- GlobalShaderCache().attachRenderable(getSelectionSystem());
+ GlobalShaderCache().attachRenderable(getSelectionSystem());
}
void SelectionSystem_Destroy()
{
- GlobalShaderCache().detachRenderable(getSelectionSystem());
+ GlobalShaderCache().detachRenderable(getSelectionSystem());
- GlobalSceneGraph().removeBoundsChangedCallback(SelectionSystem_boundsChanged);
+ GlobalSceneGraph().removeBoundsChangedCallback(SelectionSystem_boundsChanged);
- delete g_RadiantSelectionSystem;
+ delete g_RadiantSelectionSystem;
- RadiantSelectionSystem::destroyStatic();
+ RadiantSelectionSystem::destroyStatic();
}
-
-
inline float screen_normalised(float pos, std::size_t size)
{
- return ((2.0f * pos) / size) - 1.0f;
+ return ((2.0f * pos) / size) - 1.0f;
}
typedef Vector2 DeviceVector;
inline DeviceVector window_to_normalised_device(WindowVector window, std::size_t width, std::size_t height)
{
- return DeviceVector(screen_normalised(window.x(), width), screen_normalised(height - 1 - window.y(), height));
+ return DeviceVector(screen_normalised(window.x(), width), screen_normalised(height - 1 - window.y(), height));
}
inline float device_constrained(float pos)
{
- return std::min(1.0f, std::max(-1.0f, pos));
+ return std::min(1.0f, std::max(-1.0f, pos));
}
inline DeviceVector device_constrained(DeviceVector device)
{
- return DeviceVector(device_constrained(device.x()), device_constrained(device.y()));
+ return DeviceVector(device_constrained(device.x()), device_constrained(device.y()));
}
inline float window_constrained(float pos, std::size_t origin, std::size_t size)
{
- return std::min(static_cast<float>(origin + size), std::max(static_cast<float>(origin), pos));
+ return std::min(static_cast<float>( origin + size ), std::max(static_cast<float>( origin ), pos));
}
-inline WindowVector window_constrained(WindowVector window, std::size_t x, std::size_t y, std::size_t width, std::size_t height)
+inline WindowVector
+window_constrained(WindowVector window, std::size_t x, std::size_t y, std::size_t width, std::size_t height)
{
- return WindowVector(window_constrained(window.x(), x, width), window_constrained(window.y(), y, height));
+ return WindowVector(window_constrained(window.x(), x, width), window_constrained(window.y(), y, height));
}
-typedef Callback1<DeviceVector> MouseEventCallback;
+typedef Callback<void(DeviceVector)> MouseEventCallback;
Single<MouseEventCallback> g_mouseMovedCallback;
Single<MouseEventCallback> g_mouseUpCallback;
const ModifierFlags c_modifier_replace = c_modifierShift | c_modifierAlt;
const ModifierFlags c_modifier_face = c_modifierControl;
#else
-const ButtonIdentifier c_button_select = c_buttonLeft;
+ const ButtonIdentifier c_button_select = c_buttonLeft;
const ModifierFlags c_modifier_manipulator = c_modifierNone;
const ModifierFlags c_modifier_toggle = c_modifierControl;
const ModifierFlags c_modifier_replace = c_modifierNone;
const ModifierFlags c_modifier_replace_face = c_modifier_replace | c_modifier_face;
const ButtonIdentifier c_button_texture = c_buttonMiddle;
-const ModifierFlags c_modifier_apply_texture = c_modifierControl | c_modifierShift;
+const ModifierFlags c_modifier_apply_texture1 = c_modifierControl | c_modifierShift;
+const ModifierFlags c_modifier_apply_texture2 = c_modifierControl;
+const ModifierFlags c_modifier_apply_texture3 = c_modifierShift;
const ModifierFlags c_modifier_copy_texture = c_modifierNone;
-class Selector_
-{
- RadiantSelectionSystem::EModifier modifier_for_state(ModifierFlags state)
- {
- if(state == c_modifier_toggle || state == c_modifier_toggle_face)
+class Selector_ {
+ RadiantSelectionSystem::EModifier modifier_for_state(ModifierFlags state)
{
- return RadiantSelectionSystem::eToggle;
+ if (state == c_modifier_toggle || state == c_modifier_toggle_face) {
+ return RadiantSelectionSystem::eToggle;
+ }
+ if (state == c_modifier_replace || state == c_modifier_replace_face) {
+ return RadiantSelectionSystem::eReplace;
+ }
+ return RadiantSelectionSystem::eManipulator;
}
- if(state == c_modifier_replace || state == c_modifier_replace_face)
+
+ rect_t getDeviceArea() const
{
- return RadiantSelectionSystem::eReplace;
+ DeviceVector delta(m_current - m_start);
+ if (selecting() && fabs(delta.x()) > m_epsilon.x() && fabs(delta.y()) > m_epsilon.y()) {
+ return SelectionBoxForArea(&m_start[0], &delta[0]);
+ } else {
+ rect_t default_area = {{0, 0,},
+ {0, 0,},};
+ return default_area;
+ }
}
- return RadiantSelectionSystem::eManipulator;
- }
- rect_t getDeviceArea() const
- {
- DeviceVector delta(m_current - m_start);
- if(selecting() && fabs(delta.x()) > m_epsilon.x() && fabs(delta.y()) > m_epsilon.y())
+public:
+ DeviceVector m_start;
+ DeviceVector m_current;
+ DeviceVector m_epsilon;
+ std::size_t m_unmoved_replaces;
+ ModifierFlags m_state;
+ const View *m_view;
+ RectangleCallback m_window_update;
+
+ Selector_() : m_start(0.0f, 0.0f), m_current(0.0f, 0.0f), m_unmoved_replaces(0), m_state(c_modifierNone)
{
- return SelectionBoxForArea(&m_start[0], &delta[0]);
}
- else
+
+ void draw_area()
{
- rect_t default_area = { { 0, 0, }, { 0, 0, }, };
- return default_area;
+ m_window_update(getDeviceArea());
}
- }
-public:
- DeviceVector m_start;
- DeviceVector m_current;
- DeviceVector m_epsilon;
- std::size_t m_unmoved_replaces;
- ModifierFlags m_state;
- const View* m_view;
- RectangleCallback m_window_update;
-
- Selector_() : m_start(0.0f, 0.0f), m_current(0.0f, 0.0f), m_unmoved_replaces(0), m_state(c_modifierNone)
- {
- }
-
- void draw_area()
- {
- m_window_update(getDeviceArea());
- }
-
- void testSelect(DeviceVector position)
- {
- RadiantSelectionSystem::EModifier modifier = modifier_for_state(m_state);
- if(modifier != RadiantSelectionSystem::eManipulator)
- {
- DeviceVector delta(position - m_start);
- if(fabs(delta.x()) > m_epsilon.x() && fabs(delta.y()) > m_epsilon.y())
- {
- DeviceVector delta(position - m_start);
- getSelectionSystem().SelectArea(*m_view, &m_start[0], &delta[0], modifier, (m_state & c_modifier_face) != c_modifierNone);
- }
- else
- {
- if(modifier == RadiantSelectionSystem::eReplace && m_unmoved_replaces++ > 0)
- {
- modifier = RadiantSelectionSystem::eCycle;
- }
- getSelectionSystem().SelectPoint(*m_view, &position[0], &m_epsilon[0], modifier, (m_state & c_modifier_face) != c_modifierNone);
- }
- }
-
- m_start = m_current = DeviceVector(0.0f, 0.0f);
- draw_area();
- }
-
- bool selecting() const
- {
- return m_state != c_modifier_manipulator;
- }
-
- void setState(ModifierFlags state)
- {
- bool was_selecting = selecting();
- m_state = state;
- if(was_selecting ^ selecting())
- {
- draw_area();
- }
- }
-
- ModifierFlags getState() const
- {
- return m_state;
- }
-
- void modifierEnable(ModifierFlags type)
- {
- setState(bitfield_enable(getState(), type));
- }
- void modifierDisable(ModifierFlags type)
- {
- setState(bitfield_disable(getState(), type));
- }
-
- void mouseDown(DeviceVector position)
- {
- m_start = m_current = device_constrained(position);
- }
-
- void mouseMoved(DeviceVector position)
- {
- m_current = device_constrained(position);
- draw_area();
- }
- typedef MemberCaller1<Selector_, DeviceVector, &Selector_::mouseMoved> MouseMovedCaller;
-
- void mouseUp(DeviceVector position)
- {
- testSelect(device_constrained(position));
-
- g_mouseMovedCallback.clear();
- g_mouseUpCallback.clear();
- }
- typedef MemberCaller1<Selector_, DeviceVector, &Selector_::mouseUp> MouseUpCaller;
+ void testSelect(DeviceVector position)
+ {
+ RadiantSelectionSystem::EModifier modifier = modifier_for_state(m_state);
+ if (modifier != RadiantSelectionSystem::eManipulator) {
+ DeviceVector delta(position - m_start);
+ if (fabs(delta.x()) > m_epsilon.x() && fabs(delta.y()) > m_epsilon.y()) {
+ DeviceVector delta(position - m_start);
+ getSelectionSystem().SelectArea(*m_view, &m_start[0], &delta[0], modifier,
+ (m_state & c_modifier_face) != c_modifierNone);
+ } else {
+ if (modifier == RadiantSelectionSystem::eReplace && m_unmoved_replaces++ > 0) {
+ modifier = RadiantSelectionSystem::eCycle;
+ }
+ getSelectionSystem().SelectPoint(*m_view, &position[0], &m_epsilon[0], modifier,
+ (m_state & c_modifier_face) != c_modifierNone);
+ }
+ }
+
+ m_start = m_current = DeviceVector(0.0f, 0.0f);
+ draw_area();
+ }
+
+ bool selecting() const
+ {
+ return m_state != c_modifier_manipulator;
+ }
+
+ void setState(ModifierFlags state)
+ {
+ bool was_selecting = selecting();
+ m_state = state;
+ if (was_selecting ^ selecting()) {
+ draw_area();
+ }
+ }
+
+ ModifierFlags getState() const
+ {
+ return m_state;
+ }
+
+ void modifierEnable(ModifierFlags type)
+ {
+ setState(bitfield_enable(getState(), type));
+ }
+
+ void modifierDisable(ModifierFlags type)
+ {
+ setState(bitfield_disable(getState(), type));
+ }
+
+ void mouseDown(DeviceVector position)
+ {
+ m_start = m_current = device_constrained(position);
+ }
+
+ void mouseMoved(DeviceVector position)
+ {
+ m_current = device_constrained(position);
+ draw_area();
+ }
+
+ typedef MemberCaller<Selector_, void(DeviceVector), &Selector_::mouseMoved> MouseMovedCaller;
+
+ void mouseUp(DeviceVector position)
+ {
+ testSelect(device_constrained(position));
+
+ g_mouseMovedCallback.clear();
+ g_mouseUpCallback.clear();
+ }
+
+ typedef MemberCaller<Selector_, void(DeviceVector), &Selector_::mouseUp> MouseUpCaller;
};
-class Manipulator_
-{
+class Manipulator_ {
public:
- DeviceVector m_epsilon;
- const View* m_view;
-
- bool mouseDown(DeviceVector position)
- {
- return getSelectionSystem().SelectManipulator(*m_view, &position[0], &m_epsilon[0]);
- }
-
- void mouseMoved(DeviceVector position)
- {
- getSelectionSystem().MoveSelected(*m_view, &position[0]);
- }
- typedef MemberCaller1<Manipulator_, DeviceVector, &Manipulator_::mouseMoved> MouseMovedCaller;
-
- void mouseUp(DeviceVector position)
- {
- getSelectionSystem().endMove();
- g_mouseMovedCallback.clear();
- g_mouseUpCallback.clear();
- }
- typedef MemberCaller1<Manipulator_, DeviceVector, &Manipulator_::mouseUp> MouseUpCaller;
+ DeviceVector m_epsilon;
+ const View *m_view;
+
+ bool mouseDown(DeviceVector position)
+ {
+ return getSelectionSystem().SelectManipulator(*m_view, &position[0], &m_epsilon[0]);
+ }
+
+ void mouseMoved(DeviceVector position)
+ {
+ getSelectionSystem().MoveSelected(*m_view, &position[0]);
+ }
+
+ typedef MemberCaller<Manipulator_, void(DeviceVector), &Manipulator_::mouseMoved> MouseMovedCaller;
+
+ void mouseUp(DeviceVector position)
+ {
+ getSelectionSystem().endMove();
+ g_mouseMovedCallback.clear();
+ g_mouseUpCallback.clear();
+ }
+
+ typedef MemberCaller<Manipulator_, void(DeviceVector), &Manipulator_::mouseUp> MouseUpCaller;
};
-void Scene_copyClosestTexture(SelectionTest& test);
-void Scene_applyClosestTexture(SelectionTest& test);
+void Scene_copyClosestTexture(SelectionTest &test);
-class RadiantWindowObserver : public SelectionSystemWindowObserver
-{
- enum
- {
- SELECT_EPSILON = 8,
- };
+void Scene_applyClosestTexture(SelectionTest &test);
- int m_width;
- int m_height;
+class RadiantWindowObserver : public SelectionSystemWindowObserver {
+ enum {
+ SELECT_EPSILON = 8,
+ };
- bool m_mouse_down;
+ int m_width;
+ int m_height;
+
+ bool m_mouse_down;
public:
- Selector_ m_selector;
- Manipulator_ m_manipulator;
-
- RadiantWindowObserver() : m_mouse_down(false)
- {
- }
- void release()
- {
- delete this;
- }
- void setView(const View& view)
- {
- m_selector.m_view = &view;
- m_manipulator.m_view = &view;
- }
- void setRectangleDrawCallback(const RectangleCallback& callback)
- {
- m_selector.m_window_update = callback;
- }
- void onSizeChanged(int width, int height)
- {
- m_width = width;
- m_height = height;
- DeviceVector epsilon(SELECT_EPSILON / static_cast<float>(m_width), SELECT_EPSILON / static_cast<float>(m_height));
- m_selector.m_epsilon = m_manipulator.m_epsilon = epsilon;
- }
- void onMouseDown(const WindowVector& position, ButtonIdentifier button, ModifierFlags modifiers)
- {
- if(button == c_button_select)
- {
- m_mouse_down = true;
-
- DeviceVector devicePosition(window_to_normalised_device(position, m_width, m_height));
- if(modifiers == c_modifier_manipulator && m_manipulator.mouseDown(devicePosition))
- {
- g_mouseMovedCallback.insert(MouseEventCallback(Manipulator_::MouseMovedCaller(m_manipulator)));
- g_mouseUpCallback.insert(MouseEventCallback(Manipulator_::MouseUpCaller(m_manipulator)));
- }
- else
- {
- m_selector.mouseDown(devicePosition);
- g_mouseMovedCallback.insert(MouseEventCallback(Selector_::MouseMovedCaller(m_selector)));
- g_mouseUpCallback.insert(MouseEventCallback(Selector_::MouseUpCaller(m_selector)));
- }
- }
- else if(button == c_button_texture)
- {
- DeviceVector devicePosition(device_constrained(window_to_normalised_device(position, m_width, m_height)));
-
- View scissored(*m_selector.m_view);
- ConstructSelectionTest(scissored, SelectionBoxForPoint(&devicePosition[0], &m_selector.m_epsilon[0]));
- SelectionVolume volume(scissored);
-
- if(modifiers == c_modifier_apply_texture)
- {
- Scene_applyClosestTexture(volume);
- }
- else if(modifiers == c_modifier_copy_texture)
- {
- Scene_copyClosestTexture(volume);
- }
- }
- }
- void onMouseMotion(const WindowVector& position, ModifierFlags modifiers)
- {
- m_selector.m_unmoved_replaces = 0;
-
- if(m_mouse_down && !g_mouseMovedCallback.empty())
- {
- g_mouseMovedCallback.get()(window_to_normalised_device(position, m_width, m_height));
- }
- }
- void onMouseUp(const WindowVector& position, ButtonIdentifier button, ModifierFlags modifiers)
- {
- if(button == c_button_select && !g_mouseUpCallback.empty())
- {
- m_mouse_down = false;
-
- g_mouseUpCallback.get()(window_to_normalised_device(position, m_width, m_height));
- }
- }
- void onModifierDown(ModifierFlags type)
- {
- m_selector.modifierEnable(type);
- }
- void onModifierUp(ModifierFlags type)
- {
- m_selector.modifierDisable(type);
- }
-};
+ Selector_ m_selector;
+ Manipulator_ m_manipulator;
+
+ RadiantWindowObserver() : m_mouse_down(false)
+ {
+ }
+
+ void release()
+ {
+ delete this;
+ }
+
+ void setView(const View &view)
+ {
+ m_selector.m_view = &view;
+ m_manipulator.m_view = &view;
+ }
+
+ void setRectangleDrawCallback(const RectangleCallback &callback)
+ {
+ m_selector.m_window_update = callback;
+ }
+
+ void onSizeChanged(int width, int height)
+ {
+ m_width = width;
+ m_height = height;
+ DeviceVector epsilon(SELECT_EPSILON / static_cast<float>( m_width ),
+ SELECT_EPSILON / static_cast<float>( m_height ));
+ m_selector.m_epsilon = m_manipulator.m_epsilon = epsilon;
+ }
+
+ void onMouseDown(const WindowVector &position, ButtonIdentifier button, ModifierFlags modifiers)
+ {
+ if (button == c_button_select) {
+ m_mouse_down = true;
+
+ DeviceVector devicePosition(window_to_normalised_device(position, m_width, m_height));
+ if (modifiers == c_modifier_manipulator && m_manipulator.mouseDown(devicePosition)) {
+ g_mouseMovedCallback.insert(MouseEventCallback(Manipulator_::MouseMovedCaller(m_manipulator)));
+ g_mouseUpCallback.insert(MouseEventCallback(Manipulator_::MouseUpCaller(m_manipulator)));
+ } else {
+ m_selector.mouseDown(devicePosition);
+ g_mouseMovedCallback.insert(MouseEventCallback(Selector_::MouseMovedCaller(m_selector)));
+ g_mouseUpCallback.insert(MouseEventCallback(Selector_::MouseUpCaller(m_selector)));
+ }
+ } else if (button == c_button_texture) {
+ DeviceVector devicePosition(device_constrained(window_to_normalised_device(position, m_width, m_height)));
+
+ View scissored(*m_selector.m_view);
+ ConstructSelectionTest(scissored, SelectionBoxForPoint(&devicePosition[0], &m_selector.m_epsilon[0]));
+ SelectionVolume volume(scissored);
+
+ if (modifiers == c_modifier_apply_texture1 || modifiers == c_modifier_apply_texture2 ||
+ modifiers == c_modifier_apply_texture3) {
+ Scene_applyClosestTexture(volume);
+ } else if (modifiers == c_modifier_copy_texture) {
+ Scene_copyClosestTexture(volume);
+ }
+ }
+ }
+
+ void onMouseMotion(const WindowVector &position, ModifierFlags modifiers)
+ {
+ m_selector.m_unmoved_replaces = 0;
+
+ if (m_mouse_down && !g_mouseMovedCallback.empty()) {
+ g_mouseMovedCallback.get()(window_to_normalised_device(position, m_width, m_height));
+ }
+ }
+
+ void onMouseUp(const WindowVector &position, ButtonIdentifier button, ModifierFlags modifiers)
+ {
+ if (button == c_button_select && !g_mouseUpCallback.empty()) {
+ m_mouse_down = false;
+
+ g_mouseUpCallback.get()(window_to_normalised_device(position, m_width, m_height));
+ }
+ }
+ void onModifierDown(ModifierFlags type)
+ {
+ m_selector.modifierEnable(type);
+ }
+
+ void onModifierUp(ModifierFlags type)
+ {
+ m_selector.modifierDisable(type);
+ }
+};
-SelectionSystemWindowObserver* NewWindowObserver()
+SelectionSystemWindowObserver *NewWindowObserver()
{
- return new RadiantWindowObserver;
+ return new RadiantWindowObserver;
}
-
#include "modulesystem/singletonmodule.h"
#include "modulesystem/moduleregistry.h"
class SelectionDependencies :
- public GlobalSceneGraphModuleRef,
- public GlobalShaderCacheModuleRef,
- public GlobalOpenGLModuleRef
-{
+ public GlobalSceneGraphModuleRef,
+ public GlobalShaderCacheModuleRef,
+ public GlobalOpenGLModuleRef {
};
-class SelectionAPI : public TypeSystemRef
-{
- SelectionSystem* m_selection;
+class SelectionAPI : public TypeSystemRef {
+ SelectionSystem *m_selection;
public:
- typedef SelectionSystem Type;
- STRING_CONSTANT(Name, "*");
-
- SelectionAPI()
- {
- SelectionSystem_Construct();
-
- m_selection = &getSelectionSystem();
- }
- ~SelectionAPI()
- {
- SelectionSystem_Destroy();
- }
- SelectionSystem* getTable()
- {
- return m_selection;
- }
+ typedef SelectionSystem Type;
+
+ STRING_CONSTANT(Name, "*");
+
+ SelectionAPI()
+ {
+ SelectionSystem_Construct();
+
+ m_selection = &getSelectionSystem();
+ }
+
+ ~SelectionAPI()
+ {
+ SelectionSystem_Destroy();
+ }
+
+ SelectionSystem *getTable()
+ {
+ return m_selection;
+ }
};
typedef SingletonModule<SelectionAPI, SelectionDependencies> SelectionModule;
projects / xonotic / netradiant.git / blobdiff