/home/chochlik/devel/mirror-lib/src/mirror/example/factories/tetrahedron.hpp

Go to the documentation of this file.

#ifndef MIRROR_EXAMPLE_FACTORIES_TETRAHEDRON_1011291729_HPP
#define MIRROR_EXAMPLE_FACTORIES_TETRAHEDRON_1011291729_HPP

#include <cmath>
#include <mirror/meta_class.hpp>
#include <mirror/pre_registered/type/native.hpp>

namespace test {

struct vector
{
    double x,y,z;

    vector(double _x, double _y, double _z)
     : x(_x)
     , y(_y)
     , z(_z)
    { }

    vector(double _w)
     : x(_w)
     , y(_w)
     , z(_w)
    { }

    vector(void)
     : x(0.0)
     , y(0.0)
     , z(0.0)
    { }

    // addition
    friend vector operator + (const vector& a, const vector& b)
    {
        return vector(a.x + b.x, a.y + b.y, a.z + b.z);
    }

    // subtraction
    friend vector operator - (const vector& a, const vector& b)
    {
        return vector(a.x - b.x, a.y - b.y, a.z - b.z);
    }

    // cross product
    friend vector operator % (const vector& a, const vector& b)
    {
        return vector(
            a.y * b.z - a.z * b.y,
            a.z * b.x - a.x * b.z,
            a.x * b.y - a.y * b.x
        );
    }

    // dot product
    friend double operator * (const vector& a, const vector& b)
    {
        return a.x*b.x + a.y*b.y + a.z*b.z;
    }

    double length(void) const
    {
        return std::sqrt(x*x + y*y + z*z);
    }
};

struct triangle
{
    vector a, b, c;

    triangle(const vector& _a, const vector& _b, const vector& _c)
     : a(_a)
     , b(_b)
     , c(_c)
    { }

    triangle(void){ }


    double area(void) const
    {
        return ((b-a)%(c-a)).length()/2.0;
    }
};

struct tetrahedron
{
    triangle base;
    vector apex;

    tetrahedron(const triangle& _base, const vector& _apex)
     : base(_base)
     , apex(_apex)
    { }

    tetrahedron(
        const vector& a,
        const vector& b,
        const vector& c,
        const vector& d
    ): base(a, b, c)
     , apex(d)
    { }

    const vector& a(void) const {return base.a;}
    const vector& b(void) const {return base.b;}
    const vector& c(void) const {return base.c;}
    const vector& d(void) const {return apex;}

    void reset_apex(const vector& _apex)
    {
        apex = _apex;
    }

    void reset_apex(double x, double y, double z)
    {
        apex = vector(x, y, z);
    }

    double volume(void) const
    {
        return std::fabs(((a()-d())*((b()-d())%(c()-d()))))/6.0;
    }
};


} // namespace test


MIRROR_REG_BEGIN

// register the ::test namespace
MIRROR_QREG_GLOBAL_SCOPE_NAMESPACE(test)

// register the test::vector struct
MIRROR_REG_CLASS_BEGIN(struct, test, vector)
  MIRROR_REG_CLASS_MEM_VARS_BEGIN
    MIRROR_REG_CLASS_MEM_VAR(_, _, _, x)
    MIRROR_REG_CLASS_MEM_VAR(_, _, _, y)
    MIRROR_REG_CLASS_MEM_VAR(_, _, _, z)
  MIRROR_REG_CLASS_MEM_VARS_END

  MIRROR_REG_CONSTRUCTORS_BEGIN
    MIRROR_REG_CONSTRUCTOR_BEGIN(public, xyz)
      MIRROR_REG_CONSTRUCTOR_PARAM(_, x)
      MIRROR_REG_CONSTRUCTOR_PARAM(_, y)
      MIRROR_REG_CONSTRUCTOR_PARAM(_, z)
    MIRROR_REG_CONSTRUCTOR_END(xyz)

    MIRROR_REG_CONSTRUCTOR_BEGIN(public, w)
      MIRROR_REG_CONSTRUCTOR_PARAM(double, w)
    MIRROR_REG_CONSTRUCTOR_END(w)

    MIRROR_REG_DEFAULT_CONSTRUCTOR(_)
    MIRROR_REG_COPY_CONSTRUCTOR(_)
  MIRROR_REG_CONSTRUCTORS_END
MIRROR_REG_CLASS_END

// register the test::triangle struct
MIRROR_REG_CLASS_BEGIN(struct, test, triangle)
  MIRROR_REG_CLASS_MEM_VARS_BEGIN
    MIRROR_REG_CLASS_MEM_VAR(_, _, _, a)
    MIRROR_REG_CLASS_MEM_VAR(_, _, _, b)
    MIRROR_REG_CLASS_MEM_VAR(_, _, _, c)
  MIRROR_REG_CLASS_MEM_VARS_END

  MIRROR_REG_CONSTRUCTORS_BEGIN
    MIRROR_REG_CONSTRUCTOR_BEGIN(public, abc)
      MIRROR_REG_CONSTRUCTOR_PARAM(_, a)
      MIRROR_REG_CONSTRUCTOR_PARAM(_, b)
      MIRROR_REG_CONSTRUCTOR_PARAM(_, c)
    MIRROR_REG_CONSTRUCTOR_END(abc)

    MIRROR_REG_DEFAULT_CONSTRUCTOR(_)
    MIRROR_REG_COPY_CONSTRUCTOR(_)
  MIRROR_REG_CONSTRUCTORS_END
MIRROR_REG_CLASS_END

// register the test::tetrahedron struct
MIRROR_REG_CLASS_BEGIN(struct, test, tetrahedron)
  MIRROR_REG_CLASS_MEM_VARS_BEGIN
    MIRROR_REG_CLASS_MEM_VAR(_, _, _, base)
    MIRROR_REG_CLASS_MEM_VAR(_, _, _, apex)
  MIRROR_REG_CLASS_MEM_VARS_END

  MIRROR_REG_CONSTRUCTORS_BEGIN
    MIRROR_REG_CONSTRUCTOR_BEGIN(public, ba)
      MIRROR_REG_CONSTRUCTOR_PARAM(_, base)
      MIRROR_REG_CONSTRUCTOR_PARAM(_, apex)
    MIRROR_REG_CONSTRUCTOR_END(ba)

    MIRROR_REG_CONSTRUCTOR_BEGIN(public, abcd)
      MIRROR_REG_CONSTRUCTOR_PARAM(test::vector, a)
      MIRROR_REG_CONSTRUCTOR_PARAM(test::vector, b)
      MIRROR_REG_CONSTRUCTOR_PARAM(test::vector, c)
      MIRROR_REG_CONSTRUCTOR_PARAM(test::vector, d)
    MIRROR_REG_CONSTRUCTOR_END(abcd)

    MIRROR_REG_COPY_CONSTRUCTOR(_)
  MIRROR_REG_CONSTRUCTORS_END

  MIRROR_REG_MEM_FUNCTIONS_BEGIN
    MIRROR_REG_MEM_OVLD_FUNC_BEGIN(reset_apex)
    MIRROR_REG_MEM_FUNCTION_BEGIN(public, _, void, reset_apex, 1)
      MIRROR_REG_MEM_FUNCTION_PARAM(_, apex)
    MIRROR_REG_MEM_FUNCTION_END(1, _)
    MIRROR_REG_MEM_FUNCTION_BEGIN(public, _, void, reset_apex, 2)
      MIRROR_REG_MEM_FUNCTION_PARAM(double, x)
      MIRROR_REG_MEM_FUNCTION_PARAM(double, y)
      MIRROR_REG_MEM_FUNCTION_PARAM(double, z)
    MIRROR_REG_MEM_FUNCTION_END(2, _)
    MIRROR_REG_MEM_OVLD_FUNC_END(reset_apex)
  MIRROR_REG_MEM_FUNCTIONS_END
MIRROR_REG_CLASS_END

MIRROR_REG_END

#endif