Operator2Expr.cpp

Go to the documentation of this file.

// Operator2Expr.cpp: implementation of the COperator2Expr 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.
 *
 */
// 31 dec 1998 - big update: try to use the cached data for updating, instead of
// rebuilding completely it from left and right node. Modified flags and bounding boxes
// have to do the trick
// when expression is cached, there will be a call to UpdateCalc() instead of Calc()

#include "Operator2Expr.h"
#include "StringValue.h"
#include "VoidValue.h"

// Construction/Destruction

COperator2Expr::COperator2Expr(VALUE_OPERATOR op, CExpression *lhs, CExpression *rhs)
:       
m_rhs(rhs),
m_lhs(lhs),
m_cached_calculate(NULL),
m_op(op)
/*
pre:
effect: constucts a COperator2Expr with op, lhs and rhs in it
*/
{

}

COperator2Expr::COperator2Expr():
m_rhs(NULL),
m_lhs(NULL),
m_cached_calculate(NULL)

/*
pre:
effect: constucts an empty COperator2Expr
*/
{
        
}

COperator2Expr::~COperator2Expr()
/*
pre:
effect: deletes the object
*/
{
        if (m_lhs)
                m_lhs->Release();
        if (m_rhs)
                m_rhs->Release();
        if (m_cached_calculate)
                m_cached_calculate->Release();
        
}
CValue* COperator2Expr::Calculate()
/*
pre:
ret: a new object containing the result of applying operator m_op to m_lhs
and m_rhs
*/
{
        
        bool leftmodified,rightmodified;
        leftmodified = m_lhs->NeedsRecalculated();
        rightmodified = m_rhs->NeedsRecalculated();
        
        // if no modifications on both left and right subtree, and result is already calculated
        // then just return cached result...
        if (!leftmodified && !rightmodified && (m_cached_calculate))
        {
                // not modified, just return m_cached_calculate
        } else {
                // if not yet calculated, or modified...
                
                
                if (m_cached_calculate) {
                        m_cached_calculate->Release();
                        m_cached_calculate=NULL;
                }
                
                CValue* ffleft = m_lhs->Calculate();
                CValue* ffright = m_rhs->Calculate();
                
                ffleft->SetOwnerExpression(this);//->m_pOwnerExpression=this;
                ffright->SetOwnerExpression(this);//->m_pOwnerExpression=this;
                
                m_cached_calculate = ffleft->Calc(m_op,ffright);
                
                //if (m_cached_calculate)                               
                //      m_cached_calculate->Action(CValue::SETOWNEREXPR,&CVoidValue(this,false,CValue::STACKVALUE));

                ffleft->Release();
                ffright->Release();
        }
        
        return m_cached_calculate->AddRef();
        
}

/*
bool COperator2Expr::IsInside(float x, float y, float z,bool bBorderInclude)
{
        bool inside;
        inside = false;
        
        switch (m_op) 
        {
        case VALUE_ADD_OPERATOR: {
        //      inside = first || second; // optimized with early out if first is inside
                // todo: calculate smallest leaf first ! is much faster...
                        
                bool second;//first ;//,second;
                
                //first = m_lhs->IsInside(x,y,z) ;
                second = m_rhs->IsInside(x,y,z,bBorderInclude) ;
                if (second)
                        return true; //early out
        
        //      second = m_rhs->IsInside(x,y,z) ;

                return m_lhs->IsInside(x,y,z,bBorderInclude) ;
                        
                break;
                                                         }
                
        case VALUE_SUB_OPERATOR: {
                //inside = first && !second; // optimized with early out
                // todo: same as with add_operator: calc smallest leaf first

                bool second;//first ;//,second;
                //first = m_lhs->IsInside(x,y,z) ;
                second = m_rhs->IsInside(x,y,z,bBorderInclude);
                if (second)
                        return false;

                // second space get subtracted -> negate!
                //second = m_rhs->IsInside(x,y,z);

                return (m_lhs->IsInside(x,y,z,bBorderInclude));

                
                break;
                                                         }
        default:{
                assert(false);
                // not yet implemented, only add or sub csg operations
                        }
        }
        
        return inside;  
}



bool COperator2Expr::IsRightInside(float x, float y, float z,bool bBorderInclude) {
        
        return m_rhs->IsInside(x,y,z,bBorderInclude) ;
        
}

bool COperator2Expr::IsLeftInside(float x, float y, float z,bool bBorderInclude) {
        return m_lhs->IsInside(x,y,z,bBorderInclude);
}
*/
bool COperator2Expr::NeedsRecalculated() {
        // added some lines, just for debugging purposes, it could be a one-liner :)
        //bool modleft
        //bool modright;
        assertd(m_lhs);
        assertd(m_rhs);

        //modright = m_rhs->NeedsRecalculated();
        if (m_rhs->NeedsRecalculated()) // early out
                return true;
        return m_lhs->NeedsRecalculated();
        //modleft = m_lhs->NeedsRecalculated();
        //return (modleft || modright);
        
}



CExpression* COperator2Expr::CheckLink(std::vector<CBrokenLinkInfo*>& brokenlinks) {
// if both children are 'dead', return NULL
// if only one child is alive, return that child
// if both childresn are alive, return this


//      bool leftalive = true,rightalive=true;
        /* Does this mean the function will always bomb? */
        assertd(false);
        assert(m_lhs);
        assert(m_rhs);
/*
        if (m_cached_calculate)
                m_cached_calculate->Action(CValue::REFRESH_CACHE);
        
        CExpression* newlhs = m_lhs->CheckLink(brokenlinks);
        CExpression* newrhs = m_rhs->CheckLink(brokenlinks);

        if (m_lhs != newlhs)
        {
                brokenlinks.push_back(new CBrokenLinkInfo(&m_lhs,m_lhs));
        }

        if (m_rhs != newrhs)
        {
                brokenlinks.push_back(new CBrokenLinkInfo(&m_rhs,m_rhs));
        }



        m_lhs = newlhs;
        m_rhs = newrhs;

        if (m_lhs && m_rhs) {
                return this;
        }
        
        AddRef();
        if (m_lhs) 
                return Release(m_lhs->AddRef());
        
        if (m_rhs)
                return Release(m_rhs->AddRef());
/               

  */
  return Release();

  
        
}


bool COperator2Expr::MergeExpression(CExpression *otherexpr)
{
        if (m_lhs)
        {
                if (m_lhs->GetExpressionID() == CExpression::CCONSTEXPRESSIONID)
                {
                        // cross fingers ;) replace constexpr by new tree...
                        m_lhs->Release();
                        m_lhs = otherexpr->AddRef();
                        return true;
                }
        }

        assertd(false);
        return false;
}


void COperator2Expr::BroadcastOperators(VALUE_OPERATOR op)
{
        if (m_lhs)
                m_lhs->BroadcastOperators(m_op);
        if (m_rhs)
                m_rhs->BroadcastOperators(m_op);
}