cuboid.cpp

Go to the documentation of this file.

/*
 * This work is licensed under a Creative Commons 
 * Attribution-Noncommercial-Share Alike 3.0 United States License.
 * 
 *    http://creativecommons.org/licenses/by-nc-sa/3.0/us/
 * 
 * You are free:
 * 
 *    to Share - to copy, distribute, display, and perform the work
 *    to Remix - to make derivative works
 * 
 * Under the following conditions:
 * 
 *    Attribution. You must attribute the work in the manner specified by the
 *    author or licensor (but not in any way that suggests that they endorse you
 *    or your use of the work).
 * 
 *    Noncommercial. You may not use this work for commercial purposes.
 * 
 *    Share Alike. If you alter, transform, or build upon this work, you may
 *    distribute the resulting work only under the same or similar license to
 *    this one.
 * 
 * For any reuse or distribution, you must make clear to others the license
 * terms of this work. The best way to do this is by including this header.
 * 
 * Any of the above conditions can be waived if you get permission from the
 * copyright holder.
 * 
 * Apart from the remix rights granted under this license, nothing in this
 * license impairs or restricts the author's moral rights.
 */


#include <jwsc++/config.h>

#include <cassert>
#include <inttypes.h>

#include <jwsc/vector/vector.h>
#include <jwsc/matrix/matrix.h>
#include <jwsc/matrix/matrix_math.h>

#include <jwsc++/base/exception.h>
#include <jwsc++/graphics/parapiped.h>
#include <jwsc++/graphics/cuboid.h>

#ifdef JWSCXX_HAVE_DMALLOC
#include <dmalloc.h>
#endif


using namespace jwscxx::base;
using namespace jwscxx::graphics;


Cuboid_f::Cuboid_f(float width, float height, float length)
    throw (jwscxx::base::Arg_error)
    : Parapiped_f(0,0,0, width,0,0, width,height,0, width,height,length)
{
    if (width <= 0 || height <= 0 || length <= 0)
    {
        throw Arg_error("Cuboid dimensions not positive");
    }
}


Cuboid_f::Cuboid_f
(
    float width,  
    float height, 
    float length, 
    float x, 
    float y, 
    float z
)
throw (jwscxx::base::Arg_error)
: Parapiped_f(x,y,z, x+width,y,z, x+width,y+height,z, x+width,y+height,z+length)
{
    if (width <= 0 || height <= 0 || length <= 0)
    {
        throw Arg_error("Cuboid dimensions not positive");
    }
}


Cuboid_f::Cuboid_f
(
    float width, 
    float height, 
    float length,
    const jwsc::Vector_f* p
)
throw (jwscxx::base::Arg_error)
: Parapiped_f(0,0,0, width,0,0, width,height,0, width,height,length)
{
    using namespace jwsc;

    if (width <= 0 || height <= 0 || length <= 0)
    {
        throw Arg_error("Cuboid dimensions not positive");
    }

    if (p->num_elts != 3)
    {
        throw Arg_error("Cuboid position vector not 3D");
    }

    Matrix_f* T = 0;
    assert(create_3d_homo_translation_matrix_1_f(&T, p) == 0);
    transform(T);
    free_matrix_f(T);
}


Cuboid_f::Cuboid_f(const Cuboid_f& c) : Parapiped_f(c)
{
}


Cuboid_f::Cuboid_f(const char* fname) 
    throw (jwscxx::base::Arg_error, jwscxx::base::IO_error)
    : Parapiped_f(0,0,0, 1,0,0, 1,1,0, 1,1,1)
{
    jwscxx::base::Readable::read(fname);
}


Cuboid_f::Cuboid_f(std::istream& in)
    throw (jwscxx::base::Arg_error, jwscxx::base::IO_error)
    : Parapiped_f(0,0,0, 1,0,0, 1,1,0, 1,1,1)
{
    read(in);
}


Cuboid_f::~Cuboid_f()
{ 
}


Cuboid_f& Cuboid_f::operator= (const Cuboid_f& c)
{
    Parapiped_f::operator=(c);

    return *this;
}


Cuboid_f* Cuboid_f::clone() const
{
    return new Cuboid_f(*this);
}


Cuboid_d::Cuboid_d(double width, double height, double length)
    throw (jwscxx::base::Arg_error)
    : Parapiped_d(0,0,0, width,0,0, width,height,0, width,height,length)
{
    if (width <= 0 || height <= 0 || length <= 0)
    {
        throw Arg_error("Cuboid dimensions not positive");
    }
}


Cuboid_d::Cuboid_d
(
    double width,  
    double height, 
    double length, 
    double x, 
    double y, 
    double z
)
throw (jwscxx::base::Arg_error)
: Parapiped_d(x,y,z, x+width,y,z, x+width,y+height,z, x+width,y+height,z+length)
{
    if (width <= 0 || height <= 0 || length <= 0)
    {
        throw Arg_error("Cuboid dimensions not positive");
    }
}


Cuboid_d::Cuboid_d
(
    double width, 
    double height, 
    double length,
    const jwsc::Vector_d* p
)
throw (jwscxx::base::Arg_error)
: Parapiped_d(0,0,0, width,0,0, width,height,0, width,height,length)
{
    using namespace jwsc;

    if (width <= 0 || height <= 0 || length <= 0)
    {
        throw Arg_error("Cuboid dimensions not positive");
    }

    if (p->num_elts != 3)
    {
        throw Arg_error("Cuboid position vector not 3D");
    }

    Matrix_d* T = 0;
    assert(create_3d_homo_translation_matrix_1_d(&T, p) == 0);
    transform(T);
    free_matrix_d(T);
}


Cuboid_d::Cuboid_d(const Cuboid_d& c) : Parapiped_d(c)
{
}


Cuboid_d::Cuboid_d(const char* fname) 
    throw (jwscxx::base::Arg_error, jwscxx::base::IO_error)
    : Parapiped_d(0,0,0, 1,0,0, 1,1,0, 1,1,1)
{
    jwscxx::base::Readable::read(fname);
}


Cuboid_d::Cuboid_d(std::istream& in)
    throw (jwscxx::base::Arg_error, jwscxx::base::IO_error)
    : Parapiped_d(0,0,0, 1,0,0, 1,1,0, 1,1,1)
{
    read(in);
}


Cuboid_d::~Cuboid_d()
{
}


Cuboid_d& Cuboid_d::operator= (const Cuboid_d& c)
{
    Parapiped_d::operator=(c);

    return *this;
}


Cuboid_d* Cuboid_d::clone() const
{
    return new Cuboid_d(*this);
}