nCine::Primitives namespace

Primitives.

Namespaces

namespace Literals
Literals for primitives.

Classes

template<class S>
class AABB
Axis-Aligned Bounding Box in a two dimensional space.
class Color
Four-channels color with 8-bits integer per component.
class Colorf
Four-channels normalized color with float per component.
class Half
Half-precision float literal.
template<class T>
class Matrix4x4
Four-by-four matrix.
struct NoInitT
No initialization tag type.
template<class T>
class Quaternion
Quaternion.
template<class T>
class Rect
Rectangle in a two dimensional space.
template<class T>
class Vector2
Two-component vector.
template<class T>
class Vector3
Three-component vector.
template<class T>
class Vector4
Four-component vector.

Typedefs

using AABBf = AABB<float>
Axis-Aligned Bounding Box in a two dimensional space of floats.
using AABBi = AABB<int>
Axis-Aligned Bounding Box in a two dimensional space of 32-bit integers.
using Matrix4x4f = Matrix4x4<float>
Four-by-four matrix of floats.
using Quaternionf = Quaternion<float>
Quaternion of floats.
using Rectf = Rect<float>
Rectangle in a two dimensional space of floats.
using Recti = Rect<int>
Rectangle in a two dimensional space of 32-bit integers.
using Vector2f = Vector2<float>
Two-component vector of floats.
using Vector2i = Vector2<int>
Two-component vector of 32-bit integers.
using Vector3f = Vector3<float>
Three-component vector of floats.
using Vector3i = Vector3<int>
Three-component vector of 32-bit integers.
using Vector4f = Vector4<float>
Four-component vector of floats.
using Vector4i = Vector4<int>
Four-component vector of 32-bit integers.

Functions

template<class S>
auto operator*(const Vector4<S>& v, const Matrix4x4<S>& m) -> Vector4<S>
template<class S>
auto operator*(const Vector3<S>& v, const Matrix4x4<S>& m) -> Vector3<S>
template<class S>
auto operator*(S s, const Matrix4x4<S>& m) -> Matrix4x4<S>
template<class S>
auto operator*(S s, const Vector2<S>& v) -> Vector2<S>
template<class S>
auto operator*(S s, const Vector3<S>& v) -> Vector3<S>
template<class S>
auto operator*(S s, const Vector4<S>& v) -> Vector4<S>

Typedef documentation

using nCine::Primitives::AABBf = AABB<float>
#include <nCine/Primitives/AABB.h>

Axis-Aligned Bounding Box in a two dimensional space of floats.

using nCine::Primitives::AABBi = AABB<int>
#include <nCine/Primitives/AABB.h>

Axis-Aligned Bounding Box in a two dimensional space of 32-bit integers.

using nCine::Primitives::Matrix4x4f = Matrix4x4<float>
#include <nCine/Primitives/Matrix4x4.h>

Four-by-four matrix of floats.

using nCine::Primitives::Quaternionf = Quaternion<float>
#include <nCine/Primitives/Quaternion.h>

Quaternion of floats.

using nCine::Primitives::Rectf = Rect<float>
#include <nCine/Primitives/Rect.h>

Rectangle in a two dimensional space of floats.

using nCine::Primitives::Recti = Rect<int>
#include <nCine/Primitives/Rect.h>

Rectangle in a two dimensional space of 32-bit integers.

using nCine::Primitives::Vector2f = Vector2<float>
#include <nCine/Primitives/Vector2.h>

Two-component vector of floats.

using nCine::Primitives::Vector2i = Vector2<int>
#include <nCine/Primitives/Vector2.h>

Two-component vector of 32-bit integers.

using nCine::Primitives::Vector3f = Vector3<float>
#include <nCine/Primitives/Vector3.h>

Three-component vector of floats.

using nCine::Primitives::Vector3i = Vector3<int>
#include <nCine/Primitives/Vector3.h>

Three-component vector of 32-bit integers.

using nCine::Primitives::Vector4f = Vector4<float>
#include <nCine/Primitives/Vector4.h>

Four-component vector of floats.

using nCine::Primitives::Vector4i = Vector4<int>
#include <nCine/Primitives/Vector4.h>

Four-component vector of 32-bit integers.

Function documentation

#include <nCine/Primitives/Matrix4x4.h>
template<class S>
Vector4<S> nCine::Primitives::operator*(const Vector4<S>& v, const Matrix4x4<S>& m)

#include <nCine/Primitives/Matrix4x4.h>
template<class S>
Vector3<S> nCine::Primitives::operator*(const Vector3<S>& v, const Matrix4x4<S>& m)

#include <nCine/Primitives/Matrix4x4.h>
template<class S>
Matrix4x4<S> nCine::Primitives::operator*(S s, const Matrix4x4<S>& m)

#include <nCine/Primitives/Vector2.h>
template<class S>
Vector2<S> nCine::Primitives::operator*(S s, const Vector2<S>& v)

#include <nCine/Primitives/Vector3.h>
template<class S>
Vector3<S> nCine::Primitives::operator*(S s, const Vector3<S>& v)

#include <nCine/Primitives/Vector4.h>
template<class S>
Vector4<S> nCine::Primitives::operator*(S s, const Vector4<S>& v)