Nebula
Loading...
Searching...
No Matches
Im3d Namespace Reference

Namespaces

namespace  internal
 

Classes

struct  AppData
 
struct  Capsule
 
struct  Color
 
struct  Context
 
struct  DrawList
 
class  Im3dContext
 
class  Im3dInputHandler
 
struct  Im3dState
 
struct  Line
 
struct  LineSegment
 
struct  Mat3
 
struct  Mat4
 
struct  Plane
 
struct  Ray
 
struct  Sphere
 
struct  TextData
 
struct  TextDrawList
 
struct  Vec2
 
struct  Vec3
 
struct  Vec4
 
struct  Vector
 
struct  VertexData
 

Typedefs

typedef unsigned int U32
 
typedef U32 Id
 
typedef void DrawPrimitivesCallback(const DrawList &_drawList)
 

Enumerations

enum  DrawPrimitiveType { DrawPrimitive_Triangles , DrawPrimitive_Lines , DrawPrimitive_Points , DrawPrimitive_Count }
 
enum  TextFlags {
  TextFlags_AlignLeft = (1 << 0) , TextFlags_AlignRight = (1 << 1) , TextFlags_AlignTop = (1 << 3) , TextFlags_AlignBottom = (1 << 4) ,
  TextFlags_Default = 0
}
 
enum  Key {
  Mouse_Left , Key_L , Key_R , Key_S ,
  Key_T , Key_Count , Action_Select = Mouse_Left , Action_GizmoLocal = Key_L ,
  Action_GizmoRotation = Key_R , Action_GizmoScale = Key_S , Action_GizmoTranslation = Key_T , Action_Count
}
 
enum  FrustumPlane {
  FrustumPlane_Near , FrustumPlane_Far , FrustumPlane_Top , FrustumPlane_Right ,
  FrustumPlane_Bottom , FrustumPlane_Left , FrustumPlane_Count
}
 
enum  PrimitiveMode {
  PrimitiveMode_None , PrimitiveMode_Points , PrimitiveMode_Lines , PrimitiveMode_LineStrip ,
  PrimitiveMode_LineLoop , PrimitiveMode_Triangles , PrimitiveMode_TriangleStrip
}
 
enum  GizmoMode { GizmoMode_Translation , GizmoMode_Rotation , GizmoMode_Scale }
 
enum  RenderFlag {
  CheckDepth = 0x1 , AlwaysOnTop = 0x2 , Wireframe = 0x4 , Solid = 0x8 ,
  NumDepthFlags
}
 

Functions

IM3D_API AppDataGetAppData ()
 
IM3D_API void NewFrame ()
 
IM3D_API void EndFrame ()
 
IM3D_API const DrawListGetDrawLists ()
 
IM3D_API U32 GetDrawListCount ()
 
IM3D_API const TextDrawListGetTextDrawLists ()
 
IM3D_API U32 GetTextDrawListCount ()
 
IM3D_API void Draw ()
 
IM3D_API void BeginPoints ()
 
IM3D_API void BeginLines ()
 
IM3D_API void BeginLineLoop ()
 
IM3D_API void BeginLineStrip ()
 
IM3D_API void BeginTriangles ()
 
IM3D_API void BeginTriangleStrip ()
 
IM3D_API void End ()
 
IM3D_API void Vertex (const Vec3 &_position)
 
IM3D_API void Vertex (const Vec3 &_position, Color _color)
 
IM3D_API void Vertex (const Vec3 &_position, float _size)
 
IM3D_API void Vertex (const Vec3 &_position, float _size, Color _color)
 
IM3D_API void Vertex (float _x, float _y, float _z)
 
IM3D_API void Vertex (float _x, float _y, float _z, Color _color)
 
IM3D_API void Vertex (float _x, float _y, float _z, float _size)
 
IM3D_API void Vertex (float _x, float _y, float _z, float _size, Color _color)
 
IM3D_API void PushColor ()
 
IM3D_API void PushColor (Color _color)
 
IM3D_API void PopColor ()
 
IM3D_API void SetColor (Color _color)
 
IM3D_API void SetColor (float _r, float _g, float _b, float _a=1.0f)
 
IM3D_API Color GetColor ()
 
IM3D_API void PushAlpha ()
 
IM3D_API void PushAlpha (float _alpha)
 
IM3D_API void PopAlpha ()
 
IM3D_API void SetAlpha (float _alpha)
 
IM3D_API float GetAlpha ()
 
IM3D_API void PushSize ()
 
IM3D_API void PushSize (float _size)
 
IM3D_API void PopSize ()
 
IM3D_API void SetSize (float _size)
 
IM3D_API float GetSize ()
 
IM3D_API void PushEnableSorting ()
 
IM3D_API void PushEnableSorting (bool _enable)
 
IM3D_API void PopEnableSorting ()
 
IM3D_API void EnableSorting (bool _enable)
 
IM3D_API void PushDrawState ()
 
IM3D_API void PopDrawState ()
 
IM3D_API void PushMatrix ()
 
IM3D_API void PushMatrix (const Mat4 &_mat4)
 
IM3D_API void PopMatrix ()
 
IM3D_API void SetMatrix (const Mat4 &_mat4)
 
IM3D_API void SetIdentity ()
 
IM3D_API void MulMatrix (const Mat4 &_mat4)
 
IM3D_API void Translate (float _x, float _y, float _z)
 
IM3D_API void Translate (const Vec3 &_vec3)
 
IM3D_API void Rotate (const Vec3 &_axis, float _angle)
 
IM3D_API void Rotate (const Mat3 &_rotation)
 
IM3D_API void Scale (float _x, float _y, float _z)
 
IM3D_API void DrawXyzAxes ()
 
IM3D_API void DrawPoint (const Vec3 &_position, float _size, Color _color)
 
IM3D_API void DrawLine (const Vec3 &_a, const Vec3 &_b, float _size, Color _color)
 
IM3D_API void DrawQuad (const Vec3 &_a, const Vec3 &_b, const Vec3 &_c, const Vec3 &_d)
 
IM3D_API void DrawQuad (const Vec3 &_origin, const Vec3 &_normal, const Vec2 &_size)
 
IM3D_API void DrawQuadFilled (const Vec3 &_a, const Vec3 &_b, const Vec3 &_c, const Vec3 &_d)
 
IM3D_API void DrawQuadFilled (const Vec3 &_origin, const Vec3 &_normal, const Vec2 &_size)
 
IM3D_API void DrawCircle (const Vec3 &_origin, const Vec3 &_normal, float _radius, int _detail=-1)
 
IM3D_API void DrawCircleFilled (const Vec3 &_origin, const Vec3 &_normal, float _radius, int _detail=-1)
 
IM3D_API void DrawSphere (const Vec3 &_origin, float _radius, int _detail=-1)
 
IM3D_API void DrawSphereFilled (const Vec3 &_origin, float _radius, int _detail=-1)
 
IM3D_API void DrawAlignedBox (const Vec3 &_min, const Vec3 &_max)
 
IM3D_API void DrawAlignedBoxFilled (const Vec3 &_min, const Vec3 &_max)
 
IM3D_API void DrawCylinder (const Vec3 &_start, const Vec3 &_end, float _radius, int _detail=-1)
 
IM3D_API void DrawCapsule (const Vec3 &_start, const Vec3 &_end, float _radius, int _detail=-1)
 
IM3D_API void DrawPrism (const Vec3 &_start, const Vec3 &_end, float _radius, int _sides)
 
IM3D_API void DrawArrow (const Vec3 &_start, const Vec3 &_end, float _headLength=-1.0f, float _headThickness=-1.0f)
 
IM3D_API void Text (const Vec3 &_position, U32 _textFlags, const char *_text,...)
 
IM3D_API void Text (const Vec3 &_position, float _size, Color _color, U32 _textFlags, const char *_text,...)
 
IM3D_API Id MakeId (const char *_str)
 
IM3D_API Id MakeId (const void *_ptr)
 
IM3D_API Id MakeId (int _i)
 
IM3D_API void PushId ()
 
IM3D_API void PushId (Id _id)
 
IM3D_API void PushId (const char *_str)
 
IM3D_API void PushId (const void *_ptr)
 
IM3D_API void PushId (int _i)
 
IM3D_API void PopId ()
 
IM3D_API Id GetId ()
 
IM3D_API void PushLayerId (Id _layer)
 
IM3D_API void PushLayerId (const char *_str)
 
IM3D_API void PopLayerId ()
 
IM3D_API Id GetLayerId ()
 
IM3D_API bool GizmoTranslation (const char *_id, float _translation_[3], bool _local=false)
 
IM3D_API bool GizmoRotation (const char *_id, float _rotation_[3 *3], bool _local=false)
 
IM3D_API bool GizmoScale (const char *_id, float _scale_[3])
 
IM3D_API bool Gizmo (const char *_id, float _translation_[3], float _rotation_[3 *3], float _scale_[3])
 
IM3D_API bool Gizmo (const char *_id, float _transform_[4 *4])
 
IM3D_API bool GizmoTranslation (Id _id, float _translation_[3], bool _local=false)
 
IM3D_API bool GizmoRotation (Id _id, float _rotation_[3 *3], bool _local=false)
 
IM3D_API bool GizmoScale (Id _id, float _scale_[3])
 
IM3D_API bool Gizmo (Id _id, float _transform_[4 *4])
 
IM3D_API bool Gizmo (Id _id, float _translation_[3], float _rotation_[3 *3], float _scale_[3])
 
IM3D_API Id GetActiveId ()
 
IM3D_API Id GetHotId ()
 
IM3D_API bool IsVisible (const Vec3 &_origin, float _radius)
 
IM3D_API bool IsVisible (const Vec3 &_min, const Vec3 &_max)
 
IM3D_API ContextGetContext ()
 
IM3D_API void SetContext (Context &_ctx)
 
IM3D_API void MergeContexts (Context &_dst_, const Context &_src)
 
void PushLayerId ()
 
Vec2 operator+ (const Vec2 &_lhs, const Vec2 &_rhs)
 
Vec2 operator- (const Vec2 &_lhs, const Vec2 &_rhs)
 
Vec2 operator* (const Vec2 &_lhs, const Vec2 &_rhs)
 
Vec2 operator/ (const Vec2 &_lhs, const Vec2 &_rhs)
 
Vec2 operator* (const Vec2 &_lhs, float _rhs)
 
Vec2 operator/ (const Vec2 &_lhs, float _rhs)
 
Vec2 operator- (const Vec2 &_v)
 
float Dot (const Vec2 &_lhs, const Vec2 &_rhs)
 
float Length (const Vec2 &_v)
 
float Length2 (const Vec2 &_v)
 
Vec2 Abs (const Vec2 &_v)
 
Vec2 Normalize (const Vec2 &_v)
 
Vec3 operator+ (const Vec3 &_lhs, const Vec3 &_rhs)
 
Vec3 operator- (const Vec3 &_lhs, const Vec3 &_rhs)
 
Vec3 operator* (const Vec3 &_lhs, const Vec3 &_rhs)
 
Vec3 operator/ (const Vec3 &_lhs, const Vec3 &_rhs)
 
Vec3 operator* (const Vec3 &_lhs, float _rhs)
 
Vec3 operator/ (const Vec3 &_lhs, float _rhs)
 
Vec3 operator- (const Vec3 &_v)
 
float Dot (const Vec3 &_lhs, const Vec3 &_rhs)
 
float Length (const Vec3 &_v)
 
float Length2 (const Vec3 &_v)
 
Vec3 Abs (const Vec3 &_v)
 
Vec3 Normalize (const Vec3 &_v)
 
Vec3 Cross (const Vec3 &_a, const Vec3 &_b)
 
Vec4 operator+ (const Vec4 &_lhs, const Vec4 &_rhs)
 
Vec4 operator- (const Vec4 &_lhs, const Vec4 &_rhs)
 
Vec4 operator* (const Vec4 &_lhs, const Vec4 &_rhs)
 
Vec4 operator/ (const Vec4 &_lhs, const Vec4 &_rhs)
 
Vec4 operator* (const Vec4 &_lhs, float _rhs)
 
Vec4 operator/ (const Vec4 &_lhs, float _rhs)
 
Vec4 operator- (const Vec4 &_v)
 
float Dot (const Vec4 &_lhs, const Vec4 &_rhs)
 
float Length (const Vec4 &_v)
 
float Length2 (const Vec4 &_v)
 
Vec4 Abs (const Vec4 &_v)
 
Vec4 Normalize (const Vec4 &_v)
 
Mat3 operator* (const Mat3 &_lhs, const Mat3 &_rhs)
 
Vec3 operator* (const Mat3 &_m, const Vec3 &_v)
 
Vec4 operator* (const Mat3 &_m, const Vec4 &_v)
 
Mat3 Transpose (const Mat3 &_m)
 
Vec3 ToEulerXYZ (const Mat3 &_m)
 
Mat3 FromEulerXYZ (Vec3 &_xyz)
 
Mat3 Rotation (const Vec3 &_axis, float _rads)
 
Mat3 Scale (const Vec3 &_s)
 
Mat4 operator* (const Mat4 &_lhs, const Mat4 &_rhs)
 
Vec3 operator* (const Mat4 &_m, const Vec3 &_pos)
 
Vec4 operator* (const Mat4 &_m, const Vec4 &_v)
 
Mat4 Inverse (const Mat4 &_m)
 
Mat4 Transpose (const Mat4 &_m)
 
Mat4 Translation (const Vec3 &_t)
 
Mat4 AlignZ (const Vec3 &_axis, const Vec3 &_up=Vec3(0.0f, 1.0f, 0.0f))
 
Mat4 LookAt (const Vec3 &_from, const Vec3 &_to, const Vec3 &_up=Vec3(0.0f, 1.0f, 0.0f))
 
bool Intersects (const Ray &_ray, const Plane &_plane)
 
bool Intersect (const Ray &_ray, const Plane &_plane, float &t0_)
 
bool Intersects (const Ray &_ray, const Sphere &_sphere)
 
bool Intersect (const Ray &_ray, const Sphere &_sphere, float &t0_, float &t1_)
 
bool Intersects (const Ray &_ray, const Capsule &_capsule)
 
bool Intersect (const Ray &_ray, const Capsule &_capsule, float &t0_, float &t1_)
 
void Nearest (const Line &_line0, const Line &_line1, float &t0_, float &t1_)
 
void Nearest (const Ray &_ray, const Line &_line, float &tr_, float &tl_)
 
Vec3 Nearest (const Ray &_ray, const LineSegment &_segment, float &tr_)
 
float Distance2 (const Ray &_ray, const LineSegment &_segment)
 
float Distance (const Vec4 &_plane, const Vec3 &_point)
 
float Radians (float _degrees)
 
float Degrees (float _radians)
 
template<typename T >
bool AllLess (const T &_a, const T &_b)
 
template<typename T >
Max (T _a, T _b)
 
template<typename T >
Min (T _a, T _b)
 
template<typename T >
Clamp (T _a, T _min, T _max)
 
float Remap (float _x, float _start, float _end)
 
 __ImplementClass (Im3d::Im3dInputHandler, 'IM3H', Input::InputHandler)
 
 __ImplementPluginContext (Im3dContext)
 
template<typename filterFunc >
static void CollectByFilter (const CoreGraphics::CmdBufferId cmdBuf, const PipelineId pipeline, PrimitiveTopology::Code topology, IndexT &vertexBufferOffset, IndexT &vertexCount, filterFunc &&filter)
 

Variables

constexpr Id Id_Invalid = 0
 
constexpr Color Color_Black = Color(0x000000ff)
 
constexpr Color Color_White = Color(0xffffffff)
 
constexpr Color Color_Gray = Color(0x808080ff)
 
constexpr Color Color_Red = Color(0xff0000ff)
 
constexpr Color Color_Green = Color(0x00ff00ff)
 
constexpr Color Color_Blue = Color(0x0000ffff)
 
constexpr Color Color_Magenta = Color(0xff00ffff)
 
constexpr Color Color_Yellow = Color(0xffff00ff)
 
constexpr Color Color_Cyan = Color(0x00ffffff)
 
constexpr Color Color_Pink = Color(0xffc0cbff)
 
constexpr Color Color_Orange = Color(0xffa500ff)
 
constexpr Color Color_Gold = Color(0xffd700ff)
 
constexpr Color Color_Brown = Color(0x8b4513ff)
 
constexpr Color Color_Purple = Color(0x800080ff)
 
constexpr Color Color_Teal = Color(0x008080ff)
 
constexpr Color Color_Navy = Color(0x000080ff)
 
constexpr float Pi = 3.14159265359f
 
constexpr float TwoPi = 2.0f * Pi
 
constexpr float HalfPi = 0.5f * Pi
 
static Im3dState imState
 

Typedef Documentation

◆ DrawPrimitivesCallback

typedef void Im3d::DrawPrimitivesCallback(const DrawList &_drawList)

◆ Id

typedef U32 Im3d::Id

◆ U32

typedef unsigned int Im3d::U32

Enumeration Type Documentation

◆ DrawPrimitiveType

Enumerator
DrawPrimitive_Triangles 
DrawPrimitive_Lines 
DrawPrimitive_Points 
DrawPrimitive_Count 

◆ FrustumPlane

Enumerator
FrustumPlane_Near 
FrustumPlane_Far 
FrustumPlane_Top 
FrustumPlane_Right 
FrustumPlane_Bottom 
FrustumPlane_Left 
FrustumPlane_Count 

◆ GizmoMode

Enumerator
GizmoMode_Translation 
GizmoMode_Rotation 
GizmoMode_Scale 

◆ Key

enum Im3d::Key
Enumerator
Mouse_Left 
Key_L 
Key_R 
Key_S 
Key_T 
Key_Count 
Action_Select 
Action_GizmoLocal 
Action_GizmoRotation 
Action_GizmoScale 
Action_GizmoTranslation 
Action_Count 

◆ PrimitiveMode

Enumerator
PrimitiveMode_None 
PrimitiveMode_Points 
PrimitiveMode_Lines 
PrimitiveMode_LineStrip 
PrimitiveMode_LineLoop 
PrimitiveMode_Triangles 
PrimitiveMode_TriangleStrip 

◆ RenderFlag

Enumerator
CheckDepth 
AlwaysOnTop 
Wireframe 
Solid 
NumDepthFlags 

◆ TextFlags

Enumerator
TextFlags_AlignLeft 
TextFlags_AlignRight 
TextFlags_AlignTop 
TextFlags_AlignBottom 
TextFlags_Default 

Function Documentation

◆ __ImplementClass()

Im3d::__ImplementClass ( Im3d::Im3dInputHandler ,
'IM3H' ,
Input::InputHandler  )

◆ __ImplementPluginContext()

Im3d::__ImplementPluginContext ( Im3dContext )

◆ Abs() [1/3]

Vec2 Im3d::Abs ( const Vec2 & _v)
inline

◆ Abs() [2/3]

Vec3 Im3d::Abs ( const Vec3 & _v)
inline

◆ Abs() [3/3]

Vec4 Im3d::Abs ( const Vec4 & _v)
inline

◆ AlignZ()

Mat4 Im3d::AlignZ ( const Vec3 & _axis,
const Vec3 & _up = Vec3(0.0f, 1.0f, 0.0f) )

◆ AllLess()

template<typename T >
bool Im3d::AllLess ( const T & _a,
const T & _b )
inline

◆ BeginLineLoop()

void Im3d::BeginLineLoop ( )
inline

◆ BeginLines()

void Im3d::BeginLines ( )
inline

◆ BeginLineStrip()

void Im3d::BeginLineStrip ( )
inline

◆ BeginPoints()

void Im3d::BeginPoints ( )
inline

◆ BeginTriangles()

void Im3d::BeginTriangles ( )
inline

◆ BeginTriangleStrip()

void Im3d::BeginTriangleStrip ( )
inline

◆ Clamp()

template<typename T >
T Im3d::Clamp ( T _a,
T _min,
T _max )
inline

◆ CollectByFilter()

template<typename filterFunc >
static void Im3d::CollectByFilter ( const CoreGraphics::CmdBufferId cmdBuf,
const PipelineId pipeline,
PrimitiveTopology::Code topology,
IndexT & vertexBufferOffset,
IndexT & vertexCount,
filterFunc && filter )
inlinestatic

◆ Cross()

Vec3 Im3d::Cross ( const Vec3 & _a,
const Vec3 & _b )
inline

◆ Degrees()

float Im3d::Degrees ( float _radians)
inline

◆ Distance()

float Im3d::Distance ( const Vec4 & _plane,
const Vec3 & _point )
inline

◆ Distance2()

float Im3d::Distance2 ( const Ray & _ray,
const LineSegment & _segment )

◆ Dot() [1/3]

float Im3d::Dot ( const Vec2 & _lhs,
const Vec2 & _rhs )
inline

◆ Dot() [2/3]

float Im3d::Dot ( const Vec3 & _lhs,
const Vec3 & _rhs )
inline

◆ Dot() [3/3]

float Im3d::Dot ( const Vec4 & _lhs,
const Vec4 & _rhs )
inline

◆ Draw()

void Im3d::Draw ( )
inline

◆ DrawAlignedBox()

void Im3d::DrawAlignedBox ( const Vec3 & _min,
const Vec3 & _max )

◆ DrawAlignedBoxFilled()

void Im3d::DrawAlignedBoxFilled ( const Vec3 & _min,
const Vec3 & _max )

◆ DrawArrow()

void Im3d::DrawArrow ( const Vec3 & _start,
const Vec3 & _end,
float _headLength = -1.0f,
float _headThickness = -1.0f )

◆ DrawCapsule()

void Im3d::DrawCapsule ( const Vec3 & _start,
const Vec3 & _end,
float _radius,
int _detail = -1 )

◆ DrawCircle()

void Im3d::DrawCircle ( const Vec3 & _origin,
const Vec3 & _normal,
float _radius,
int _detail = -1 )

◆ DrawCircleFilled()

void Im3d::DrawCircleFilled ( const Vec3 & _origin,
const Vec3 & _normal,
float _radius,
int _detail = -1 )

◆ DrawCylinder()

void Im3d::DrawCylinder ( const Vec3 & _start,
const Vec3 & _end,
float _radius,
int _detail = -1 )

◆ DrawLine()

void Im3d::DrawLine ( const Vec3 & _a,
const Vec3 & _b,
float _size,
Color _color )

◆ DrawPoint()

void Im3d::DrawPoint ( const Vec3 & _position,
float _size,
Color _color )

◆ DrawPrism()

void Im3d::DrawPrism ( const Vec3 & _start,
const Vec3 & _end,
float _radius,
int _sides )

◆ DrawQuad() [1/2]

void Im3d::DrawQuad ( const Vec3 & _a,
const Vec3 & _b,
const Vec3 & _c,
const Vec3 & _d )

◆ DrawQuad() [2/2]

void Im3d::DrawQuad ( const Vec3 & _origin,
const Vec3 & _normal,
const Vec2 & _size )

◆ DrawQuadFilled() [1/2]

void Im3d::DrawQuadFilled ( const Vec3 & _a,
const Vec3 & _b,
const Vec3 & _c,
const Vec3 & _d )

◆ DrawQuadFilled() [2/2]

void Im3d::DrawQuadFilled ( const Vec3 & _origin,
const Vec3 & _normal,
const Vec2 & _size )

◆ DrawSphere()

void Im3d::DrawSphere ( const Vec3 & _origin,
float _radius,
int _detail = -1 )

◆ DrawSphereFilled()

void Im3d::DrawSphereFilled ( const Vec3 & _origin,
float _radius,
int _detail = -1 )

◆ DrawXyzAxes()

void Im3d::DrawXyzAxes ( )

◆ EnableSorting()

void Im3d::EnableSorting ( bool _enable)
inline

◆ End()

void Im3d::End ( )
inline

◆ EndFrame()

void Im3d::EndFrame ( )
inline

◆ FromEulerXYZ()

Mat3 Im3d::FromEulerXYZ ( Vec3 & _xyz)

◆ GetActiveId()

Id Im3d::GetActiveId ( )
inline

◆ GetAlpha()

float Im3d::GetAlpha ( )
inline

◆ GetAppData()

AppData & Im3d::GetAppData ( )
inline

◆ GetColor()

Color Im3d::GetColor ( )
inline

◆ GetContext()

Context & Im3d::GetContext ( )
inline

◆ GetDrawListCount()

U32 Im3d::GetDrawListCount ( )
inline

◆ GetDrawLists()

const DrawList * Im3d::GetDrawLists ( )
inline

◆ GetHotId()

Id Im3d::GetHotId ( )
inline

◆ GetId()

Id Im3d::GetId ( )
inline

◆ GetLayerId()

Id Im3d::GetLayerId ( )
inline

◆ GetSize()

float Im3d::GetSize ( )
inline

◆ GetTextDrawListCount()

U32 Im3d::GetTextDrawListCount ( )
inline

◆ GetTextDrawLists()

const TextDrawList * Im3d::GetTextDrawLists ( )
inline

◆ Gizmo() [1/4]

bool Im3d::Gizmo ( const char * _id,
float _transform_[4 *4] )
inline

◆ Gizmo() [2/4]

bool Im3d::Gizmo ( const char * _id,
float _translation_[3],
float _rotation_[3 *3],
float _scale_[3] )
inline

◆ Gizmo() [3/4]

bool Im3d::Gizmo ( Id _id,
float _transform_[4 *4] )

◆ Gizmo() [4/4]

bool Im3d::Gizmo ( Id _id,
float _translation_[3],
float _rotation_[3 *3],
float _scale_[3] )

◆ GizmoRotation() [1/2]

bool Im3d::GizmoRotation ( const char * _id,
float _rotation_[3 *3],
bool _local = false )
inline

◆ GizmoRotation() [2/2]

bool Im3d::GizmoRotation ( Id _id,
float _rotation_[3 *3],
bool _local = false )

◆ GizmoScale() [1/2]

bool Im3d::GizmoScale ( const char * _id,
float _scale_[3] )
inline

◆ GizmoScale() [2/2]

bool Im3d::GizmoScale ( Id _id,
float _scale_[3] )

◆ GizmoTranslation() [1/2]

bool Im3d::GizmoTranslation ( const char * _id,
float _translation_[3],
bool _local = false )
inline

◆ GizmoTranslation() [2/2]

bool Im3d::GizmoTranslation ( Id _id,
float _translation_[3],
bool _local = false )

◆ Intersect() [1/3]

bool Im3d::Intersect ( const Ray & _ray,
const Capsule & _capsule,
float & t0_,
float & t1_ )

◆ Intersect() [2/3]

bool Im3d::Intersect ( const Ray & _ray,
const Plane & _plane,
float & t0_ )

◆ Intersect() [3/3]

bool Im3d::Intersect ( const Ray & _ray,
const Sphere & _sphere,
float & t0_,
float & t1_ )

◆ Intersects() [1/3]

bool Im3d::Intersects ( const Ray & _ray,
const Capsule & _capsule )

◆ Intersects() [2/3]

bool Im3d::Intersects ( const Ray & _ray,
const Plane & _plane )

◆ Intersects() [3/3]

bool Im3d::Intersects ( const Ray & _ray,
const Sphere & _sphere )

◆ Inverse()

Mat4 Im3d::Inverse ( const Mat4 & _m)

◆ IsVisible() [1/2]

bool Im3d::IsVisible ( const Vec3 & _min,
const Vec3 & _max )
inline

◆ IsVisible() [2/2]

bool Im3d::IsVisible ( const Vec3 & _origin,
float _radius )
inline

◆ Length() [1/3]

float Im3d::Length ( const Vec2 & _v)
inline

◆ Length() [2/3]

float Im3d::Length ( const Vec3 & _v)
inline

◆ Length() [3/3]

float Im3d::Length ( const Vec4 & _v)
inline

◆ Length2() [1/3]

float Im3d::Length2 ( const Vec2 & _v)
inline

◆ Length2() [2/3]

float Im3d::Length2 ( const Vec3 & _v)
inline

◆ Length2() [3/3]

float Im3d::Length2 ( const Vec4 & _v)
inline

◆ LookAt()

Mat4 Im3d::LookAt ( const Vec3 & _from,
const Vec3 & _to,
const Vec3 & _up = Vec3(0.0f, 1.0f, 0.0f) )

◆ MakeId() [1/3]

Im3d::Id Im3d::MakeId ( const char * _str)

◆ MakeId() [2/3]

Im3d::Id Im3d::MakeId ( const void * _ptr)

◆ MakeId() [3/3]

Im3d::Id Im3d::MakeId ( int _i)

◆ Max()

template<typename T >
T Im3d::Max ( T _a,
T _b )
inline

◆ MergeContexts()

void Im3d::MergeContexts ( Context & _dst_,
const Context & _src )
inline

◆ Min()

template<typename T >
T Im3d::Min ( T _a,
T _b )
inline

◆ MulMatrix()

void Im3d::MulMatrix ( const Mat4 & _mat4)

◆ Nearest() [1/3]

void Im3d::Nearest ( const Line & _line0,
const Line & _line1,
float & t0_,
float & t1_ )

◆ Nearest() [2/3]

void Im3d::Nearest ( const Ray & _ray,
const Line & _line,
float & tr_,
float & tl_ )

◆ Nearest() [3/3]

Vec3 Im3d::Nearest ( const Ray & _ray,
const LineSegment & _segment,
float & tr_ )

◆ NewFrame()

void Im3d::NewFrame ( )
inline

◆ Normalize() [1/3]

Vec2 Im3d::Normalize ( const Vec2 & _v)
inline

◆ Normalize() [2/3]

Vec3 Im3d::Normalize ( const Vec3 & _v)
inline

◆ Normalize() [3/3]

Vec4 Im3d::Normalize ( const Vec4 & _v)
inline

◆ operator*() [1/12]

Mat3 Im3d::operator* ( const Mat3 & _lhs,
const Mat3 & _rhs )
inline

◆ operator*() [2/12]

Vec3 Im3d::operator* ( const Mat3 & _m,
const Vec3 & _v )
inline

◆ operator*() [3/12]

Vec4 Im3d::operator* ( const Mat3 & _m,
const Vec4 & _v )
inline

◆ operator*() [4/12]

Mat4 Im3d::operator* ( const Mat4 & _lhs,
const Mat4 & _rhs )
inline

◆ operator*() [5/12]

Vec3 Im3d::operator* ( const Mat4 & _m,
const Vec3 & _pos )
inline

◆ operator*() [6/12]

Vec4 Im3d::operator* ( const Mat4 & _m,
const Vec4 & _v )
inline

◆ operator*() [7/12]

Vec2 Im3d::operator* ( const Vec2 & _lhs,
const Vec2 & _rhs )
inline

◆ operator*() [8/12]

Vec2 Im3d::operator* ( const Vec2 & _lhs,
float _rhs )
inline

◆ operator*() [9/12]

Vec3 Im3d::operator* ( const Vec3 & _lhs,
const Vec3 & _rhs )
inline

◆ operator*() [10/12]

Vec3 Im3d::operator* ( const Vec3 & _lhs,
float _rhs )
inline

◆ operator*() [11/12]

Vec4 Im3d::operator* ( const Vec4 & _lhs,
const Vec4 & _rhs )
inline

◆ operator*() [12/12]

Vec4 Im3d::operator* ( const Vec4 & _lhs,
float _rhs )
inline

◆ operator+() [1/3]

Vec2 Im3d::operator+ ( const Vec2 & _lhs,
const Vec2 & _rhs )
inline

◆ operator+() [2/3]

Vec3 Im3d::operator+ ( const Vec3 & _lhs,
const Vec3 & _rhs )
inline

◆ operator+() [3/3]

Vec4 Im3d::operator+ ( const Vec4 & _lhs,
const Vec4 & _rhs )
inline

◆ operator-() [1/6]

Vec2 Im3d::operator- ( const Vec2 & _lhs,
const Vec2 & _rhs )
inline

◆ operator-() [2/6]

Vec2 Im3d::operator- ( const Vec2 & _v)
inline

◆ operator-() [3/6]

Vec3 Im3d::operator- ( const Vec3 & _lhs,
const Vec3 & _rhs )
inline

◆ operator-() [4/6]

Vec3 Im3d::operator- ( const Vec3 & _v)
inline

◆ operator-() [5/6]

Vec4 Im3d::operator- ( const Vec4 & _lhs,
const Vec4 & _rhs )
inline

◆ operator-() [6/6]

Vec4 Im3d::operator- ( const Vec4 & _v)
inline

◆ operator/() [1/6]

Vec2 Im3d::operator/ ( const Vec2 & _lhs,
const Vec2 & _rhs )
inline

◆ operator/() [2/6]

Vec2 Im3d::operator/ ( const Vec2 & _lhs,
float _rhs )
inline

◆ operator/() [3/6]

Vec3 Im3d::operator/ ( const Vec3 & _lhs,
const Vec3 & _rhs )
inline

◆ operator/() [4/6]

Vec3 Im3d::operator/ ( const Vec3 & _lhs,
float _rhs )
inline

◆ operator/() [5/6]

Vec4 Im3d::operator/ ( const Vec4 & _lhs,
const Vec4 & _rhs )
inline

◆ operator/() [6/6]

Vec4 Im3d::operator/ ( const Vec4 & _lhs,
float _rhs )
inline

◆ PopAlpha()

void Im3d::PopAlpha ( )
inline

◆ PopColor()

void Im3d::PopColor ( )
inline

◆ PopDrawState()

void Im3d::PopDrawState ( )
inline

◆ PopEnableSorting()

void Im3d::PopEnableSorting ( )
inline

◆ PopId()

void Im3d::PopId ( )
inline

◆ PopLayerId()

void Im3d::PopLayerId ( )
inline

◆ PopMatrix()

void Im3d::PopMatrix ( )
inline

◆ PopSize()

void Im3d::PopSize ( )
inline

◆ PushAlpha() [1/2]

void Im3d::PushAlpha ( )
inline

◆ PushAlpha() [2/2]

void Im3d::PushAlpha ( float _alpha)
inline

◆ PushColor() [1/2]

void Im3d::PushColor ( )
inline

◆ PushColor() [2/2]

void Im3d::PushColor ( Color _color)
inline

◆ PushDrawState()

void Im3d::PushDrawState ( )
inline

◆ PushEnableSorting() [1/2]

void Im3d::PushEnableSorting ( )
inline

◆ PushEnableSorting() [2/2]

void Im3d::PushEnableSorting ( bool _enable)
inline

◆ PushId() [1/5]

void Im3d::PushId ( )
inline

◆ PushId() [2/5]

void Im3d::PushId ( const char * _str)
inline

◆ PushId() [3/5]

void Im3d::PushId ( const void * _ptr)
inline

◆ PushId() [4/5]

void Im3d::PushId ( Id _id)
inline

◆ PushId() [5/5]

void Im3d::PushId ( int _i)
inline

◆ PushLayerId() [1/3]

void Im3d::PushLayerId ( )
inline

◆ PushLayerId() [2/3]

void Im3d::PushLayerId ( const char * _str)
inline

◆ PushLayerId() [3/3]

void Im3d::PushLayerId ( Id _layer)
inline

◆ PushMatrix() [1/2]

void Im3d::PushMatrix ( )
inline

◆ PushMatrix() [2/2]

void Im3d::PushMatrix ( const Mat4 & _mat4)
inline

◆ PushSize() [1/2]

void Im3d::PushSize ( )
inline

◆ PushSize() [2/2]

void Im3d::PushSize ( float _size)
inline

◆ Radians()

float Im3d::Radians ( float _degrees)
inline

◆ Remap()

float Im3d::Remap ( float _x,
float _start,
float _end )
inline

◆ Rotate() [1/2]

void Im3d::Rotate ( const Mat3 & _rotation)

◆ Rotate() [2/2]

void Im3d::Rotate ( const Vec3 & _axis,
float _angle )

◆ Rotation()

Mat3 Im3d::Rotation ( const Vec3 & _axis,
float _rads )

◆ Scale() [1/2]

Mat3 Im3d::Scale ( const Vec3 & _s)

◆ Scale() [2/2]

void Im3d::Scale ( float _x,
float _y,
float _z )

◆ SetAlpha()

void Im3d::SetAlpha ( float _alpha)
inline

◆ SetColor() [1/2]

void Im3d::SetColor ( Color _color)
inline

◆ SetColor() [2/2]

void Im3d::SetColor ( float _r,
float _g,
float _b,
float _a = 1.0f )
inline

◆ SetContext()

void Im3d::SetContext ( Context & _ctx)
inline

◆ SetIdentity()

void Im3d::SetIdentity ( )
inline

◆ SetMatrix()

void Im3d::SetMatrix ( const Mat4 & _mat4)
inline

◆ SetSize()

void Im3d::SetSize ( float _size)
inline

◆ Text() [1/2]

void Im3d::Text ( const Vec3 & _position,
float _size,
Color _color,
U32 _textFlags,
const char * _text,
... )

◆ Text() [2/2]

void Im3d::Text ( const Vec3 & _position,
U32 _textFlags,
const char * _text,
... )

◆ ToEulerXYZ()

Vec3 Im3d::ToEulerXYZ ( const Mat3 & _m)

◆ Translate() [1/2]

void Im3d::Translate ( const Vec3 & _vec3)

◆ Translate() [2/2]

void Im3d::Translate ( float _x,
float _y,
float _z )

◆ Translation()

Mat4 Im3d::Translation ( const Vec3 & _t)

◆ Transpose() [1/2]

Mat3 Im3d::Transpose ( const Mat3 & _m)

◆ Transpose() [2/2]

Mat4 Im3d::Transpose ( const Mat4 & _m)

◆ Vertex() [1/8]

void Im3d::Vertex ( const Vec3 & _position)
inline

◆ Vertex() [2/8]

void Im3d::Vertex ( const Vec3 & _position,
Color _color )
inline

◆ Vertex() [3/8]

void Im3d::Vertex ( const Vec3 & _position,
float _size )
inline

◆ Vertex() [4/8]

void Im3d::Vertex ( const Vec3 & _position,
float _size,
Color _color )
inline

◆ Vertex() [5/8]

void Im3d::Vertex ( float _x,
float _y,
float _z )
inline

◆ Vertex() [6/8]

void Im3d::Vertex ( float _x,
float _y,
float _z,
Color _color )
inline

◆ Vertex() [7/8]

void Im3d::Vertex ( float _x,
float _y,
float _z,
float _size )
inline

◆ Vertex() [8/8]

void Im3d::Vertex ( float _x,
float _y,
float _z,
float _size,
Color _color )
inline

Variable Documentation

◆ Color_Black

Color Im3d::Color_Black = Color(0x000000ff)
constexpr

◆ Color_Blue

Color Im3d::Color_Blue = Color(0x0000ffff)
constexpr

◆ Color_Brown

Color Im3d::Color_Brown = Color(0x8b4513ff)
constexpr

◆ Color_Cyan

Color Im3d::Color_Cyan = Color(0x00ffffff)
constexpr

◆ Color_Gold

Color Im3d::Color_Gold = Color(0xffd700ff)
constexpr

◆ Color_Gray

Color Im3d::Color_Gray = Color(0x808080ff)
constexpr

◆ Color_Green

Color Im3d::Color_Green = Color(0x00ff00ff)
constexpr

◆ Color_Magenta

Color Im3d::Color_Magenta = Color(0xff00ffff)
constexpr

◆ Color_Navy

Color Im3d::Color_Navy = Color(0x000080ff)
constexpr

◆ Color_Orange

Color Im3d::Color_Orange = Color(0xffa500ff)
constexpr

◆ Color_Pink

Color Im3d::Color_Pink = Color(0xffc0cbff)
constexpr

◆ Color_Purple

Color Im3d::Color_Purple = Color(0x800080ff)
constexpr

◆ Color_Red

Color Im3d::Color_Red = Color(0xff0000ff)
constexpr

◆ Color_Teal

Color Im3d::Color_Teal = Color(0x008080ff)
constexpr

◆ Color_White

Color Im3d::Color_White = Color(0xffffffff)
constexpr

◆ Color_Yellow

Color Im3d::Color_Yellow = Color(0xffff00ff)
constexpr

◆ HalfPi

float Im3d::HalfPi = 0.5f * Pi
constexpr

◆ Id_Invalid

Id Im3d::Id_Invalid = 0
constexpr

◆ imState

Im3dState Im3d::imState
static

◆ Pi

float Im3d::Pi = 3.14159265359f
constexpr

◆ TwoPi

float Im3d::TwoPi = 2.0f * Pi
constexpr