Changeset 1041


Ignore:
Timestamp:
Oct 31, 2011, 9:19:09 AM (9 years ago)
Author:
sam
Message:

core: new combinations of integer vectors (unsigned, 8-bit, etc.), dot and
cross product, normalize, etc.

Location:
trunk
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/half.h

    r882 r1041  
    2929     * instead of calling routines with the hidden "this" parameter. */
    3030    inline half() { }
     31    inline half(int f) { *this = makefast(f); }
    3132    inline half(float f) { *this = makefast(f); }
     33    inline half(double f) { *this = makefast(f); }
    3234
    3335    inline int is_nan() const
     
    5153    }
    5254
    53     /* Cast to other types */
     55    /* Cast to other types -- always inline, see constructors */
     56    inline half &operator =(int f) { return *this = makefast(f); }
     57    inline half &operator =(float f) { return *this = makefast(f); }
     58    inline half &operator =(double f) { return *this = makefast(f); }
     59    inline operator int() const { return (int)tofloat(*this); }
    5460    inline operator float() const { return tofloat(*this); }
    55     inline operator int() const { return (int)tofloat(*this); }
    5661
    5762    static float tofloat(half h);
  • trunk/src/matrix.cpp

    r939 r1041  
    2323{
    2424
     25template<> float dot(vec2 v1, vec2 v2)
     26{
     27    return v1.x * v2.x + v1.y * v2.y;
     28}
     29
     30template<> float dot(vec3 v1, vec3 v2)
     31{
     32    return v1.x * v2.x + v1.y * v2.y + v1.z * v2.z;
     33}
     34
     35template<> float dot(vec4 v1, vec4 v2)
     36{
     37    return v1.x * v2.x + v1.y * v2.y + v1.z * v2.z + v1.w * v2.w;
     38}
     39
     40template<> vec3 cross(vec3 v1, vec3 v2)
     41{
     42    return vec3(v1.y * v2.z - v1.z * v2.y,
     43                v1.z * v2.x - v1.x * v2.z,
     44                v1.x * v2.y - v1.y * v2.x);
     45}
     46
     47template<> vec2 normalize(vec2 v)
     48{
     49    float norm = v.sqlen();
     50    if (!norm)
     51        return vec2(0);
     52    return v / norm;
     53}
     54
     55template<> vec3 normalize(vec3 v)
     56{
     57    float norm = v.sqlen();
     58    if (!norm)
     59        return vec3(0);
     60    return v / norm;
     61}
     62
     63template<> vec4 normalize(vec4 v)
     64{
     65    float norm = v.sqlen();
     66    if (!norm)
     67        return vec4(0);
     68    return v / norm;
     69}
     70
    2571static inline float det3(float a, float b, float c,
    2672                         float d, float e, float f,
     
    67113}
    68114
     115template<> void vec2::printf() const
     116{
     117    Log::Debug("[ %6.6f %6.6f ]\n", x, y);
     118}
     119
     120template<> void vec3::printf() const
     121{
     122    Log::Debug("[ %6.6f %6.6f %6.6f ]\n", x, y, z);
     123}
     124
     125template<> void vec4::printf() const
     126{
     127    Log::Debug("[ %6.6f %6.6f %6.6f %6.6f ]\n", x, y, z, w);
     128}
     129
    69130template<> void mat4::printf() const
    70131{
     
    164225}
    165226
    166 template<> mat4 mat4::perspective(float theta, float width,
    167                                   float height, float near, float far)
    168 {
    169     float t1 = tanf(theta / 2.0f);
    170     float t2 = t1 * height / width;
    171 
    172     return frustum(-near * t1, near * t1, -near * t2, near * t2, near, far);
    173 }
    174 
    175227template<> mat4 mat4::translate(float x, float y, float z)
    176228{
     
    180232    ret[3][2] = z;
    181233    return ret;
     234}
     235
     236template<> mat4 mat4::translate(vec3 v)
     237{
     238    return translate(v.x, v.y, v.z);
     239}
     240
     241template<> mat4 mat4::lookat(vec3 eye, vec3 center, vec3 up)
     242{
     243    vec3 f = normalize(center - eye);
     244    vec3 u = normalize(up);
     245    vec3 s = normalize(cross(f, u));
     246    u = cross(s, f);
     247
     248    mat4 ret(1.0f);
     249    ret[0][0] = s.x;
     250    ret[0][1] = s.y;
     251    ret[0][2] = s.z;
     252    ret[1][0] = u.x;
     253    ret[1][1] = u.y;
     254    ret[1][2] = u.z;
     255    ret[2][0] =-f.x;
     256    ret[2][1] =-f.y;
     257    ret[2][2] =-f.z;
     258    return ret * mat4::translate(-eye);
     259}
     260
     261template<> mat4 mat4::perspective(float theta, float width,
     262                                  float height, float near, float far)
     263{
     264    float t1 = tanf(theta * 0.5f);
     265    float t2 = t1 * height / width;
     266
     267    return frustum(-near * t1, near * t1, -near * t2, near * t2, near, far);
    182268}
    183269
     
    214300}
    215301
     302template<> mat4 mat4::rotate(float theta, vec3 v)
     303{
     304    return rotate(theta, v.x, v.y, v.z);
     305}
     306
    216307} /* namespace lol */
    217308
  • trunk/src/matrix.h

    r1035 r1041  
    114114        using namespace std; \
    115115        return sqrtf((float)sqlen()); \
    116     }
     116    } \
     117    \
     118    template<typename U> \
     119    friend U dot(Vec##elems<U>, Vec##elems<U>); \
     120    template<typename U> \
     121    friend Vec##elems<U> normalize(Vec##elems<U>); \
     122    \
     123    void printf() const;
    117124
    118125#define SWIZZLE2(e1, e2) \
     
    206213};
    207214
     215typedef Vec2<half> f16vec2;
    208216typedef Vec2<float> vec2;
    209 typedef Vec2<int> ivec2;
     217typedef Vec2<int8_t> i8vec2;
     218typedef Vec2<uint8_t> u8vec2;
     219typedef Vec2<int16_t> i16vec2;
     220typedef Vec2<uint16_t> u16vec2;
     221typedef Vec2<int32_t> ivec2;
     222typedef Vec2<uint32_t> uvec2;
     223typedef Vec2<int64_t> i64vec2;
     224typedef Vec2<uint64_t> u64vec2;
    210225
    211226/*
     
    227242    SWIZZLE4333(x); SWIZZLE4333(y); SWIZZLE4333(z);
    228243
     244    template<typename U>
     245    friend Vec3<U> cross(Vec3<U>, Vec3<U>);
     246
    229247#if !defined __ANDROID__
    230248    template<typename U>
     
    237255};
    238256
     257typedef Vec3<half> f16vec3;
    239258typedef Vec3<float> vec3;
    240 typedef Vec3<int> ivec3;
     259typedef Vec3<int8_t> i8vec3;
     260typedef Vec3<uint8_t> u8vec3;
     261typedef Vec3<int16_t> i16vec3;
     262typedef Vec3<uint16_t> u16vec3;
     263typedef Vec3<int32_t> ivec3;
     264typedef Vec3<uint32_t> uvec3;
     265typedef Vec3<int64_t> i64vec3;
     266typedef Vec3<uint64_t> u64vec3;
    241267
    242268/*
     
    273299};
    274300
     301typedef Vec4<half> f16vec4;
    275302typedef Vec4<float> vec4;
    276 typedef Vec4<int> ivec4;
     303typedef Vec4<int8_t> i8vec4;
     304typedef Vec4<uint8_t> u8vec4;
     305typedef Vec4<int16_t> i16vec4;
     306typedef Vec4<uint16_t> u16vec4;
     307typedef Vec4<int32_t> ivec4;
     308typedef Vec4<uint32_t> uvec4;
     309typedef Vec4<int64_t> i64vec4;
     310typedef Vec4<uint64_t> u64vec4;
    277311
    278312#define SCALAR_GLOBAL(elems, op, U) \
     
    327361    static Mat4<T> ortho(T left, T right, T bottom, T top, T near, T far);
    328362    static Mat4<T> frustum(T left, T right, T bottom, T top, T near, T far);
     363    static Mat4<T> lookat(Vec3<T> eye, Vec3<T> center, Vec3<T> up);
    329364    static Mat4<T> perspective(T theta, T width, T height, T near, T far);
    330365    static Mat4<T> translate(T x, T y, T z);
     366    static Mat4<T> translate(Vec3<T> v);
    331367    static Mat4<T> rotate(T theta, T x, T y, T z);
     368    static Mat4<T> rotate(T theta, Vec3<T> v);
    332369
    333370    void printf() const;
     
    401438};
    402439
     440typedef Mat4<half> f16mat4;
    403441typedef Mat4<float> mat4;
    404 typedef Mat4<int> imat4;
     442typedef Mat4<int8_t> i8mat4;
     443typedef Mat4<uint8_t> u8mat4;
     444typedef Mat4<int16_t> i16mat4;
     445typedef Mat4<uint16_t> u16mat4;
     446typedef Mat4<int32_t> imat4;
     447typedef Mat4<uint32_t> umat4;
     448typedef Mat4<int64_t> i64mat4;
     449typedef Mat4<uint64_t> u64mat4;
    405450
    406451} /* namespace lol */
  • trunk/test/unit/build.cpp

    r1028 r1041  
    2121LOLUNIT_FIXTURE(BuildTest)
    2222{
     23    LOLUNIT_TEST(TypeSize)
     24    {
     25        LOLUNIT_ASSERT_EQUAL(sizeof(half), 2);
     26        //LOLUNIT_ASSERT_EQUAL(sizeof(f16vec2), 4);
     27        //LOLUNIT_ASSERT_EQUAL(sizeof(f16vec3), 6);
     28        //LOLUNIT_ASSERT_EQUAL(sizeof(f16vec4), 8);
     29        //LOLUNIT_ASSERT_EQUAL(sizeof(f16mat4), 32);
     30
     31        LOLUNIT_ASSERT_EQUAL(sizeof(float), 4);
     32        LOLUNIT_ASSERT_EQUAL(sizeof(vec2), 8);
     33        LOLUNIT_ASSERT_EQUAL(sizeof(vec3), 12);
     34        LOLUNIT_ASSERT_EQUAL(sizeof(vec4), 16);
     35
     36        LOLUNIT_ASSERT_EQUAL(sizeof(i8vec2), 2);
     37        LOLUNIT_ASSERT_EQUAL(sizeof(u8vec2), 2);
     38        LOLUNIT_ASSERT_EQUAL(sizeof(i16vec2), 4);
     39        LOLUNIT_ASSERT_EQUAL(sizeof(u16vec2), 4);
     40        LOLUNIT_ASSERT_EQUAL(sizeof(ivec2), 8);
     41        LOLUNIT_ASSERT_EQUAL(sizeof(uvec2), 8);
     42        LOLUNIT_ASSERT_EQUAL(sizeof(i64vec2), 16);
     43        LOLUNIT_ASSERT_EQUAL(sizeof(u64vec2), 16);
     44
     45        LOLUNIT_ASSERT_EQUAL(sizeof(i8vec3), 3);
     46        LOLUNIT_ASSERT_EQUAL(sizeof(u8vec3), 3);
     47        LOLUNIT_ASSERT_EQUAL(sizeof(i16vec3), 6);
     48        LOLUNIT_ASSERT_EQUAL(sizeof(u16vec3), 6);
     49        LOLUNIT_ASSERT_EQUAL(sizeof(ivec3), 12);
     50        LOLUNIT_ASSERT_EQUAL(sizeof(uvec3), 12);
     51        LOLUNIT_ASSERT_EQUAL(sizeof(i64vec3), 24);
     52        LOLUNIT_ASSERT_EQUAL(sizeof(u64vec3), 24);
     53
     54        LOLUNIT_ASSERT_EQUAL(sizeof(i8vec4), 4);
     55        LOLUNIT_ASSERT_EQUAL(sizeof(u8vec4), 4);
     56        LOLUNIT_ASSERT_EQUAL(sizeof(i16vec4), 8);
     57        LOLUNIT_ASSERT_EQUAL(sizeof(u16vec4), 8);
     58        LOLUNIT_ASSERT_EQUAL(sizeof(ivec4), 16);
     59        LOLUNIT_ASSERT_EQUAL(sizeof(uvec4), 16);
     60        LOLUNIT_ASSERT_EQUAL(sizeof(i64vec4), 32);
     61        LOLUNIT_ASSERT_EQUAL(sizeof(u64vec4), 32);
     62
     63        LOLUNIT_ASSERT_EQUAL(sizeof(i8mat4), 16);
     64        LOLUNIT_ASSERT_EQUAL(sizeof(u8mat4), 16);
     65        LOLUNIT_ASSERT_EQUAL(sizeof(i16mat4), 32);
     66        LOLUNIT_ASSERT_EQUAL(sizeof(u16mat4), 32);
     67        LOLUNIT_ASSERT_EQUAL(sizeof(imat4), 64);
     68        LOLUNIT_ASSERT_EQUAL(sizeof(umat4), 64);
     69        LOLUNIT_ASSERT_EQUAL(sizeof(i64mat4), 128);
     70        LOLUNIT_ASSERT_EQUAL(sizeof(u64mat4), 128);
     71    }
     72
    2373#if !defined LOL_DEBUG
    2474    LOLUNIT_TEST(FastMath)
Note: See TracChangeset for help on using the changeset viewer.