//
//  CompFab.cpp
//  voxelizer
//
//  Created by David Levin on 2/3/14.
//
//

#include "../include/CompFab.h"

using namespace CompFab;


CompFab::Vec3Struct::Vec3Struct()
{
    m_x = m_y = m_z = 0.0;
}

CompFab::Vec3Struct::Vec3Struct(double x, double y, double z)
{
    m_x = x;
    m_y = y;
    m_z = z;
}

void CompFab::Vec3Struct::normalize() {
    
    double magnitude = sqrt(m_x*m_x+m_y*m_y+m_z*m_z);
    
    if(magnitude > EPSILON)
    {
        m_x /= magnitude;
        m_y /= magnitude;
        m_z /= magnitude;
    }
}

//Data Types
CompFab::Vec3iStruct::Vec3iStruct()
{
    m_x = m_y = m_z = 0;
}

CompFab::Vec3iStruct::Vec3iStruct(int x, int y, int z)
{
    m_x = x;
    m_y = y;
    m_z = z;
}

CompFab::Vec3iStruct::Vec3iStruct(int i)
{
    m_x = i;
    m_y = i;
    m_z = i;
}


CompFab::Vec2fStruct::Vec2fStruct()
{
    m_x = m_y = 0.0;
}

CompFab::Vec2fStruct::Vec2fStruct(float x, float y)
{
    m_x = x;
    m_y = y;
}

CompFab::RayStruct::RayStruct()
{
    m_origin[0] = m_origin[1] = m_origin[2] = 0.0;
    m_direction[0] = 1.0;
    m_direction[1] = m_direction[2] = 0.0;
}

CompFab::RayStruct::RayStruct(Vec3 &origin, Vec3 &direction)
{
    m_origin = origin;
    m_direction = direction;
}

CompFab::TriangleStruct::TriangleStruct(Vec3 &v1, Vec3 &v2,Vec3 &v3)
{
    m_v1 = v1;
    m_v2 = v2;
    m_v3 = v3;
}

CompFab::Vec3 CompFab::operator-(const Vec3 &v1, const Vec3 &v2)
{
    Vec3 v3;
    v3[0] = v1[0] - v2[0];
    v3[1] = v1[1] - v2[1];
    v3[2] = v1[2] - v2[2];
    
    return v3;
}

CompFab::Vec3 CompFab::operator+(const Vec3 &v1, const Vec3 &v2)
{
    Vec3 v3;
    v3[0] = v1[0] + v2[0];
    v3[1] = v1[1] + v2[1];
    v3[2] = v1[2] + v2[2];
    
    return v3;
}

CompFab::Vec3i CompFab::operator+(const Vec3i &v1, const Vec3i &v2)
{
    Vec3i v3i;
    v3i[0] = v1[0] + v2[0];
    v3i[1] = v1[1] + v2[1];
    v3i[2] = v1[2] + v2[2];
    
    return v3i;
}

//Matrix multiplication
CompFab::Vec3 CompFab::mmult(const Vec3& v1, const Vec3& v2)
{
    return Vec3(v1.m_x*v2.m_x, v1.m_y*v2.m_y, v1.m_z*v2.m_z);
}

//Scalar multiplication
CompFab::Vec3 CompFab::smult(double s, const Vec3 & v)
{
    return mmult(CompFab::Vec3(s,s,s), v);
}

//Cross Product
CompFab::Vec3 CompFab::operator%(const Vec3 &v1, const Vec3 &v2)
{
    Vec3 v3;
    v3[0] = v1[1]*v2[2] - v1[2]*v2[1];
    v3[1] = v1[2]*v2[0] - v1[0]*v2[2];
    v3[2] = v1[0]*v2[1] - v1[1]*v2[0];
    
    return v3;
}

//Dot Product
double CompFab::operator*(const Vec3 &v1, const Vec3 &v2)
{
    return v1.m_x*v2.m_x + v1.m_y*v2.m_y+v1.m_z*v2.m_z;
}


//Grid structure for Voxels
CompFab::VoxelGridStruct::VoxelGridStruct(Vec3 corner, unsigned int numX, unsigned int numY, unsigned int numZ, double spacing)
{
    m_corner = corner;
    m_numX = numX;
    m_numY = numY;
    m_numZ = numZ;
    m_size = numX*numY*numZ;
    m_spacing = spacing;
    
    //Allocate Memory
    m_insideArray = new bool[m_size];
    
    for(unsigned int ii=0; ii<m_size; ++ii)
    {
        m_insideArray[ii] = false;
    }
    
}

CompFab::VoxelGridStruct::~VoxelGridStruct()
{
    delete[] m_insideArray;
}