VectorValue.cpp

Go to the documentation of this file.

// VectorValue.cpp: implementation of the CVectorValue class.
/*
 * Copyright (c) 1996-2000 Erwin Coumans <coockie@acm.org>
 *
 * Permission to use, copy, modify, distribute and sell this software
 * and its documentation for any purpose is hereby granted without fee,
 * provided that the above copyright notice appear in all copies and
 * that both that copyright notice and this permission notice appear
 * in supporting documentation.  Erwin Coumans makes no
 * representations about the suitability of this software for any
 * purpose.  It is provided "as is" without express or implied warranty.
 *
 */

#if defined(WIN32) && !defined(FREE_WINDOWS)
#pragma warning (disable:4786)
#endif

#include "Value.h"
#include "VectorValue.h"
#include "ErrorValue.h"
//#include "MatrixValue.h"
#include "VoidValue.h"
#include "StringValue.h"
//#include "FactoryManager.h"



// Construction/Destruction

CVectorValue::CVectorValue(float x,float y,float z, AllocationTYPE alloctype)
{
    SetCustomFlag1(false);//FancyOutput=false;
    
    if (alloctype == STACKVALUE)
    {
        CValue::DisableRefCount();
    };
    
    m_vec[KX_X] = m_transformedvec[KX_X] = x;
    m_vec[KX_Y] = m_transformedvec[KX_Y] = y;
    m_vec[KX_Z] = m_transformedvec[KX_Z] = z;
    
}
CVectorValue::CVectorValue(double vec[],const char *name,AllocationTYPE alloctype) {
    
    SetCustomFlag1(false);//FancyOutput=false;
    
    m_vec[KX_X] = m_transformedvec[KX_X] = vec[KX_X];
    m_vec[KX_Y] = m_transformedvec[KX_Y] = vec[KX_Y];
    m_vec[KX_Z] = m_transformedvec[KX_Z] = vec[KX_Z];
        
    if (alloctype == STACKVALUE)
    {
        CValue::DisableRefCount();
        
    }
    
    SetName(name);
}

CVectorValue::CVectorValue(double vec[],AllocationTYPE alloctype) {
    
    SetCustomFlag1(false);//FancyOutput=false;
    
    m_vec[KX_X] = m_transformedvec[KX_X] = vec[KX_X];
    m_vec[KX_Y] = m_transformedvec[KX_Y] = vec[KX_Y];
    m_vec[KX_Z] = m_transformedvec[KX_Z] = vec[KX_Z];
    
    if (alloctype == STACKVALUE)
    {
        CValue::DisableRefCount();
        
    }
    
    
}
CVectorValue::~CVectorValue()
{

}

CValue* CVectorValue::CalcFinal(VALUE_DATA_TYPE dtype, VALUE_OPERATOR op, CValue *val)
/*
pre: the type of val is dtype
ret: a new object containing the result of applying operator op to val and
this object
*/
{
    CValue *ret = NULL;
    
    switch(op)
    { 
    case VALUE_ADD_OPERATOR: 
        {
            switch (dtype)
            {
            case VALUE_EMPTY_TYPE:
            case VALUE_VECTOR_TYPE: 
                {
                    ret = new CVectorValue(
                        val->GetVector3()[KX_X] + GetVector3()[KX_X],
                        val->GetVector3()[KX_Y] + GetVector3()[KX_Y],
                        val->GetVector3()[KX_Z] + GetVector3()[KX_Z],
                        CValue::HEAPVALUE);
                    ret->SetName(GetName());
                    break;
                }
            
            default: 
                ret = new CErrorValue(val->GetText() + op2str(op) + GetText());
            }
            break;
        }
    case VALUE_MUL_OPERATOR:
        {
            switch (dtype)
            {
                
            case VALUE_EMPTY_TYPE:
            case VALUE_VECTOR_TYPE: 
                {
                    //MT_Vector3 supports 'scaling' by another vector, instead of using general transform, Gino?
                    //ret = new CVectorValue(val->GetVector3().Scaled(GetVector3()),GetName());
                    break;
                }
            case VALUE_FLOAT_TYPE: 
                {
                    ret = new CVectorValue(
                        val->GetVector3()[KX_X] * GetVector3()[KX_X],
                        val->GetVector3()[KX_Y] * GetVector3()[KX_Y],
                        val->GetVector3()[KX_Z] * GetVector3()[KX_Z],
                        CValue::HEAPVALUE);
                    ret->SetName(GetName());
                    break;
                }
            
            default: 
                ret = new CErrorValue(val->GetText() + op2str(op) + GetText());
            }
            break;

        }
    
    default:
        ret = new CErrorValue(val->GetText() + op2str(op) + GetText());
    }

    
    return ret;
}

double CVectorValue::GetNumber()
{
    return m_vec[KX_X];
}


double* CVectorValue::GetVector3(bool bGetTransformedVec)
{
    if (bGetTransformedVec)
        return m_transformedvec;
    // else 
    return m_vec;
}





void CVectorValue::SetVector(double newvec[])
{
    m_vec[KX_X] = m_transformedvec[KX_X] = newvec[KX_X];
    m_vec[KX_Y] = m_transformedvec[KX_Y] = newvec[KX_Y];
    m_vec[KX_Z] = m_transformedvec[KX_Z] = newvec[KX_Z];
    
    SetModified(true);
}


void CVectorValue::SetValue(CValue *newval)
{
    
    double* newvec = ((CVectorValue*)newval)->GetVector3();
    m_vec[KX_X] = m_transformedvec[KX_X] = newvec[KX_X];
    m_vec[KX_Y] = m_transformedvec[KX_Y] = newvec[KX_Y];
    m_vec[KX_Z] = m_transformedvec[KX_Z] = newvec[KX_Z];
    
    SetModified(true);
}

static const STR_String gstrVectorStr=STR_String();
const STR_String & CVectorValue::GetText()
{
    assertd(false);
    return gstrVectorStr;
}

CValue* CVectorValue::GetReplica() { 
    CVectorValue* replica = new CVectorValue(*this);
    replica->ProcessReplica();
    return replica;
};

/*void CVectorValue::Transform(rcMatrix4x4 mat)
{
    m_transformedvec = mat*m_vec;
}
*/