VuoPoint4d.h

Go to the documentation of this file.

 
#ifndef VuoPoint4d_h
#define VuoPoint4d_h
 
#include <math.h>
#include "VuoPoint3d.h"
#include "VuoReal.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef float __attribute__((ext_vector_type(4))) VuoPoint4d;
 
#define VuoPoint4d_SUPPORTS_COMPARISON  
#include "VuoList_VuoPoint4d.h"
 
VuoPoint4d VuoPoint4d_makeFromJson(struct json_object * js);
struct json_object * VuoPoint4d_getJson(const VuoPoint4d value);
char * VuoPoint4d_getSummary(const VuoPoint4d value);
 
bool VuoPoint4d_areEqual(const VuoPoint4d value1, const VuoPoint4d value2);
bool VuoPoint4d_areEqualListWithinTolerance(VuoList_VuoPoint4d values, VuoPoint4d tolerance);
bool VuoPoint4d_isLessThan(const VuoPoint4d a, const VuoPoint4d b);
bool VuoPoint4d_isWithinRange(VuoPoint4d value, VuoPoint4d minimum, VuoPoint4d maximum);
 
VuoPoint4d VuoPoint4d_minList(VuoList_VuoPoint4d values, VuoInteger *outputPosition);
VuoPoint4d VuoPoint4d_maxList(VuoList_VuoPoint4d values, VuoInteger *outputPosition);
VuoPoint4d VuoPoint4d_average(VuoList_VuoPoint4d values);
 
VuoPoint4d VuoPoint4d_random(const VuoPoint4d minimum, const VuoPoint4d maximum);
VuoPoint4d VuoPoint4d_randomWithState(unsigned short state[3], const VuoPoint4d minimum, const VuoPoint4d maximum);
 
 
char * VuoPoint4d_getString(const VuoPoint4d value);
void VuoPoint4d_retain(VuoPoint4d value);
void VuoPoint4d_release(VuoPoint4d value);
 
static inline VuoPoint4d VuoPoint4d_make(float x, float y, float z, float w) __attribute__((const));
static inline VuoPoint4d VuoPoint4d_make(float x, float y, float z, float w)
{
    return (VuoPoint4d){x, y, z, w};
}
 
static inline VuoPoint4d VuoPoint4d_makeFromArray(float *f)
{
    return (VuoPoint4d){ f[0], f[1], f[2], f[3] };
}
 
static inline void VuoPoint4d_setArray(float *f, VuoPoint4d p)
{
    f[0] = p.x;
    f[1] = p.y;
    f[2] = p.z;
    f[3] = p.w;
}
 
static inline VuoPoint3d VuoPoint4d_to3d(VuoPoint4d p) __attribute__((const));
static inline VuoPoint3d VuoPoint4d_to3d(VuoPoint4d p)
{
    return (VuoPoint3d){p.x, p.y, p.z};
}
 
static inline VuoPoint4d VuoPoint3d_to4d1(VuoPoint3d p) __attribute__((const));
static inline VuoPoint4d VuoPoint3d_to4d1(VuoPoint3d p)
{
    return (VuoPoint4d){p.x, p.y, p.z, 1};
}
 
static inline VuoPoint4d VuoPoint4d_crossProduct(VuoPoint4d u, VuoPoint4d v) __attribute__((const));
static inline VuoPoint4d VuoPoint4d_crossProduct(VuoPoint4d u, VuoPoint4d v)
{
    return (VuoPoint4d){
        u.y*v.z - u.z*v.y,
        u.z*v.x - u.x*v.z,
        u.x*v.y - u.y*v.x,
        1.
    };
}
 
static inline float VuoPoint4d_dotProduct(VuoPoint4d u, VuoPoint4d v) __attribute__((const));
static inline float VuoPoint4d_dotProduct(VuoPoint4d u, VuoPoint4d v)
{
    return u.x*v.x + u.y*v.y + u.z*v.z + u.w*v.w;
}
 
 
static inline float VuoPoint4d_magnitude(VuoPoint4d a) __attribute__((const));
static inline float VuoPoint4d_magnitude(VuoPoint4d a)
{
    return sqrtf(a.x*a.x + a.y*a.y + a.z*a.z + a.w*a.w);
}
 
static inline VuoPoint4d VuoPoint4d_normalize3d(VuoPoint4d a) __attribute__((const));
static inline VuoPoint4d VuoPoint4d_normalize3d(VuoPoint4d a)
{
    VuoPoint3d p = a.xyz / sqrtf(a.x * a.x + a.y * a.y + a.z * a.z);
    return (VuoPoint4d){p.x, p.y, p.z, a.w};
}
 
static inline VuoPoint4d VuoPoint4d_normalize(VuoPoint4d a) __attribute__((const));
static inline VuoPoint4d VuoPoint4d_normalize(VuoPoint4d a)
{
    return a / sqrtf(a.x * a.x + a.y * a.y + a.z * a.z + a.w * a.w);
}
 
static inline VuoPoint4d VuoPoint4d_add(VuoPoint4d a, VuoPoint4d b) __attribute__((const));
static inline VuoPoint4d VuoPoint4d_add(VuoPoint4d a, VuoPoint4d b)
{
    return a + b;
}
 
static inline VuoPoint4d VuoPoint4d_subtract(VuoPoint4d a, VuoPoint4d b) __attribute__((const));
static inline VuoPoint4d VuoPoint4d_subtract(VuoPoint4d a, VuoPoint4d b)
{
    return a - b;
}
 
static inline float VuoPoint4d_squaredMagnitude(VuoPoint4d a) __attribute__((const));
static inline float VuoPoint4d_squaredMagnitude(VuoPoint4d a)
{
    return (a.x*a.x + a.y*a.y + a.z*a.z + a.w*a.w);
}
 
 
static inline VuoPoint4d VuoPoint4d_divide(VuoPoint4d a, VuoPoint4d b) __attribute__((const));
static inline VuoPoint4d VuoPoint4d_divide(VuoPoint4d a, VuoPoint4d b)
{
    return a / b;
}
 
static inline VuoPoint4d VuoPoint4d_multiply(VuoPoint4d a, float b) __attribute__((const));
static inline VuoPoint4d VuoPoint4d_multiply(VuoPoint4d a, float b)
{
    return a * b;
}
 
static inline VuoPoint4d VuoPoint4d_scale(VuoPoint4d a, VuoPoint4d b) __attribute__((const));
static inline VuoPoint4d VuoPoint4d_scale(VuoPoint4d a, VuoPoint4d b)
{
    return a * b;
}
 
static inline VuoPoint4d VuoPoint4d_makeNonzero(VuoPoint4d a) __attribute__((const));
static inline VuoPoint4d VuoPoint4d_makeNonzero(VuoPoint4d a)
{
    if (fabs(a.x) < 0.000001)
        a.x = copysign(0.000001, a.x);
    if (fabs(a.y) < 0.000001)
        a.y = copysign(0.000001, a.y);
    if (fabs(a.z) < 0.000001)
        a.z = copysign(0.000001, a.z);
    if (fabs(a.w) < 0.000001)
        a.w = copysign(0.000001, a.w);
    return a;
}
 
static inline float VuoPoint4d_distance(VuoPoint4d a, VuoPoint4d b) __attribute__((const));
static inline float VuoPoint4d_distance(VuoPoint4d a, VuoPoint4d b)
{
    return sqrtf((a.x-b.x)*(a.x-b.x) + (a.y-b.y)*(a.y-b.y) + (a.z-b.z)*(a.z-b.z) + (a.w-b.w)*(a.w-b.w));
}
 
static inline VuoPoint4d VuoPoint4d_min(const VuoPoint4d l, const VuoPoint4d r) __attribute__((const));
static inline VuoPoint4d VuoPoint4d_min(const VuoPoint4d l, const VuoPoint4d r)
{
    return (VuoPoint4d){
        fminf(l.x, r.x),
        fminf(l.y, r.y),
        fminf(l.z, r.z),
        fminf(l.w, r.w)};
}
 
static inline VuoPoint4d VuoPoint4d_max(const VuoPoint4d l, const VuoPoint4d r) __attribute__((const));
static inline VuoPoint4d VuoPoint4d_max(const VuoPoint4d l, const VuoPoint4d r)
{
    return (VuoPoint4d){
        fmaxf(l.x, r.x),
        fmaxf(l.y, r.y),
        fmaxf(l.z, r.z),
        fmaxf(l.w, r.w)};
}
 
static inline VuoPoint4d VuoPoint4d_snap(VuoPoint4d a, VuoPoint4d center, VuoPoint4d snap) __attribute__((const));
static inline VuoPoint4d VuoPoint4d_snap(VuoPoint4d a, VuoPoint4d center, VuoPoint4d snap)
{
    VuoPoint4d nonzeroSnap = VuoPoint4d_makeNonzero(snap);
    return (VuoPoint4d) {
            center.x + nonzeroSnap.x * (int)round((a.x-center.x) / nonzeroSnap.x),
            center.y + nonzeroSnap.y * (int)round((a.y-center.y) / nonzeroSnap.y),
            center.z + nonzeroSnap.z * (int)round((a.z-center.z) / nonzeroSnap.z),
            center.w + nonzeroSnap.w * (int)round((a.w-center.w) / nonzeroSnap.w)
        };
}
 
 
static inline VuoPoint4d VuoPoint4d_clampn(VuoPoint4d point, VuoPoint4d limitA, VuoPoint4d limitB)
{
    return (VuoPoint4d){
        (float)VuoReal_clamp(point.x, limitA.x, limitB.x),
        (float)VuoReal_clamp(point.y, limitA.y, limitB.y),
        (float)VuoReal_clamp(point.z, limitA.z, limitB.z),
        (float)VuoReal_clamp(point.w, limitA.w, limitB.w)
    };
}
 
#ifdef __cplusplus
}
#endif
 
#endif