ic
/
magnum
mirror of https://github.com/mosra/magnum.git
6
0
Fork 0
Code Issues Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1509 Commits
21 Branches
19 Tags
70 MiB
Tree: 3ad264893e
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '3ad264893e'
${ noResults }
magnum/src/Math/Point3D.h

100 lines
3.2 KiB
Raw Normal View History Unescape

Point*D Vector* subclasses for homogeneous coordinates. Vector4 doesn't set W component to one by default anymore, this is now handled by Point*D itself. This finally allows creating of 2D primitives and 2D position vectors without messing explicitly with Z = 1. All classes which should use Point instead of Vector were updated to use Point instead.
14 years ago
#ifndef Magnum_Math_Point3D_h
#define Magnum_Math_Point3D_h
/*
Copyright © 2010, 2011, 2012 Vladimír Vondruš <mosra@centrum.cz>
This file is part of Magnum.
Magnum is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License version 3
only, as published by the Free Software Foundation.
Magnum 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 Lesser General Public License version 3 for more details.
*/
/** @file
* @brief Class Magnum::Math::Point3D
*/
#include "Vector4.h"
namespace Magnum { namespace Math {
/**
@brief Three-dimensional homogeneous coordinates
@tparam T Data type
Same as Vector4, except that constructors have default value for W component
set to one. See also @ref matrix-vector for brief introduction.
Doc++ Crosslinked types from Math namespace with typedefs in Magnum namespace.
14 years ago
@see Magnum::Point3D, Point2D
Point*D Vector* subclasses for homogeneous coordinates. Vector4 doesn't set W component to one by default anymore, this is now handled by Point*D itself. This finally allows creating of 2D primitives and 2D position vectors without messing explicitly with Z = 1. All classes which should use Point instead of Vector were updated to use Point instead.
14 years ago
@configurationvalueref{Magnum::Math::Point3D}
*/
template<class T> class Point3D: public Vector4<T> {
public:
/**
* @brief Default constructor
*
* X, Y and Z components are set to zero, W is set to one.
*/
Marking all constructors explicit, except for matrix and vector classes. It prevents unwanted implicit conversions from e.g. nullptr to Camera, Vector2 to Physics::Point etc. By making all the constructors explicit it is easier to routinely add the keyword to all new classes instead of thinking about cases when to add and when not to.
14 years ago
inline constexpr /*implicit*/ Point3D(): Vector4<T>(T(0), T(0), T(0), T(1)) {}
Point*D Vector* subclasses for homogeneous coordinates. Vector4 doesn't set W component to one by default anymore, this is now handled by Point*D itself. This finally allows creating of 2D primitives and 2D position vectors without messing explicitly with Z = 1. All classes which should use Point instead of Vector were updated to use Point instead.
14 years ago
/**
* @brief Constructor
* @param x X component
* @param y Y component
* @param z Z component
* @param w W component
*/
Marking all constructors explicit, except for matrix and vector classes. It prevents unwanted implicit conversions from e.g. nullptr to Camera, Vector2 to Physics::Point etc. By making all the constructors explicit it is easier to routinely add the keyword to all new classes instead of thinking about cases when to add and when not to.
14 years ago
inline constexpr /*implicit*/ Point3D(T x, T y, T z, T w = T(1)): Vector4<T>(x, y, z, w) {}
Point*D Vector* subclasses for homogeneous coordinates. Vector4 doesn't set W component to one by default anymore, this is now handled by Point*D itself. This finally allows creating of 2D primitives and 2D position vectors without messing explicitly with Z = 1. All classes which should use Point instead of Vector were updated to use Point instead.
14 years ago
/**
* @brief Constructor
* @param xyz Three-component vector
* @param w W component
*/
Math: explicit one-parameter Point*D constructor. Was causing improper implicit conversions, such as here (example directly from unit tests, where it was unintentionally used): Vector3 normal; Matrix4 transformation; auto transformedNormal = transformation*normal; Not only that it was possible to multiply 4x4 matrix with 3-component vector, but the resulting type was Point3D which was absolutely confusing. Currently it must be explicitly converted: transformedNormal = transformation*Point3D(normal);
13 years ago
inline constexpr /*implicit*/ Point3D(const Vector3<T>& xyz, T w): Vector4<T>(xyz, w) {}
/**
* @brief Construct 3D point from 3D vector
*
* W component is set to `1`.
*/
inline constexpr explicit Point3D(const Vector3<T>& xyz): Vector4<T>(xyz, T(1)) {}
Marking all constructors explicit, except for matrix and vector classes. It prevents unwanted implicit conversions from e.g. nullptr to Camera, Vector2 to Physics::Point etc. By making all the constructors explicit it is easier to routinely add the keyword to all new classes instead of thinking about cases when to add and when not to.
14 years ago
Math: matrix/vector rework, part 3: conversion as explicit constructor. Also updated all dependent classes to follow the change, such as Color and Rectangle. Backwards compatibility for GCC 4.6 (with lack of support for delegating constructors) will be done as non-constexpr constructor using operator=().
13 years ago
/** @copydoc Vector::Vector(const Vector<size, U>&) */
template<class U> inline constexpr explicit Point3D(const Vector<4, U>& other): Vector4<T>(other) {}
Marking all constructors explicit, except for matrix and vector classes. It prevents unwanted implicit conversions from e.g. nullptr to Camera, Vector2 to Physics::Point etc. By making all the constructors explicit it is easier to routinely add the keyword to all new classes instead of thinking about cases when to add and when not to.
14 years ago
/** @brief Copy constructor */
Math: matrix/vector rework, part 2: matrix as array of column vectors. Overall architecture is simplififed with this change and also it's not needed to use reinterpret_cast in matrix internals anymore, thus there is no need for operator() and [][] works now always as expected without any risk of GCC misoptimizations. On the other side, constructing matrix from list of elements is not possible anymore. You have to specify the elements as list of column vectors, which might be less convenient to write, but it helps to distinguish what is column and what is row: Matrix<2, int> a(1, 2, // before 3, 4); Matrix<2, int> a(Vector<2, int>(1, 2), // now Vector<2, int>(3, 4)); For some matrix specializations (i.e. Matrix3 and Matrix4) it is possible to use list-initialization instead of explicit type specification: Matrix<3, int>({1, 2, 3}, {4, 5, 6}, {7, 8, 9}); I didn't yet figure out how to properly implement the general (constexpr) constructor to also take lists, so it's a bit ugly for now. Matrix operations are now done column-wise, which should help with future SIMD implementations, documentation is also updated accordingly. I also removed forgotten remains of matrix/matrix operator*=(), which can be confusing, as the multiplication is not commutative. Why it is not present is explained in d9c900f076f2f87c7b7ba3f37a3179c0c0e4a02c.
13 years ago
inline constexpr Point3D(const Vector<4, T>& other): Vector4<T>(other) {}
Overloaded operators also for Point2D and Point3D.
14 years ago
Added Point*D::vector() function. Equivalent to xy() and xyz(), useful for seamless 2D/3D integration.
14 years ago
/**
* @brief Vector part of the point
*
* Equivalent to calling xyz(). Useful for seamless 2D/3D integration.
* @see Point2D::vector()
*/
inline Vector3<T>& vector() { return Vector4<T>::xyz(); }
inline constexpr Vector3<T> vector() const { return Vector4<T>::xyz(); } /**< @overload */
Overloaded operators also for Point2D and Point3D.
14 years ago
MAGNUM_VECTOR_SUBCLASS_IMPLEMENTATION(Point3D, 4)
Point*D Vector* subclasses for homogeneous coordinates. Vector4 doesn't set W component to one by default anymore, this is now handled by Point*D itself. This finally allows creating of 2D primitives and 2D position vectors without messing explicitly with Z = 1. All classes which should use Point instead of Vector were updated to use Point instead.
14 years ago
};
Overloaded operators also for Point2D and Point3D.
14 years ago
MAGNUM_VECTOR_SUBCLASS_OPERATOR_IMPLEMENTATION(Point3D, 4)
Point*D Vector* subclasses for homogeneous coordinates. Vector4 doesn't set W component to one by default anymore, this is now handled by Point*D itself. This finally allows creating of 2D primitives and 2D position vectors without messing explicitly with Z = 1. All classes which should use Point instead of Vector were updated to use Point instead.
14 years ago
/** @debugoperator{Magnum::Math::Point3D} */
Code cleanup.
14 years ago
template<class T> inline Corrade::Utility::Debug operator<<(Corrade::Utility::Debug debug, const Point3D<T>& value) {
return debug << static_cast<const Vector<4, T>&>(value);
Point*D Vector* subclasses for homogeneous coordinates. Vector4 doesn't set W component to one by default anymore, this is now handled by Point*D itself. This finally allows creating of 2D primitives and 2D position vectors without messing explicitly with Z = 1. All classes which should use Point instead of Vector were updated to use Point instead.
14 years ago
}
}}
namespace Corrade { namespace Utility {
/** @configurationvalue{Magnum::Math::Point3D} */
template<class T> struct ConfigurationValue<Magnum::Math::Point3D<T>>: public ConfigurationValue<Magnum::Math::Vector<4, T>> {};
}}
#endif