blender/source/gameengine/Expressions/Operator2Expr.cpp

276 lines
6.1 KiB
C++
Raw Normal View History

/** \file gameengine/Expressions/Operator2Expr.cpp
* \ingroup expressions
*/
2002-10-12 11:37:38 +00:00
// 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"
2002-10-12 11:37:38 +00:00
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
COperator2Expr::COperator2Expr(VALUE_OPERATOR op, CExpression *lhs, CExpression *rhs)
:
m_rhs(rhs),
2002-10-12 11:37:38 +00:00
m_lhs(lhs),
m_cached_calculate(NULL),
m_op(op)
2002-10-12 11:37:38 +00:00
/*
pre:
effect: constucts a COperator2Expr with op, lhs and rhs in it
*/
{
}
COperator2Expr::COperator2Expr():
m_rhs(NULL),
2002-10-12 11:37:38 +00:00
m_lhs(NULL),
m_cached_calculate(NULL)
2002-10-12 11:37:38 +00:00
/*
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;
2012-02-27 10:35:39 +00:00
//first = m_lhs->IsInside(x,y,z);
second = m_rhs->IsInside(x,y,z,bBorderInclude);
2002-10-12 11:37:38 +00:00
if (second)
return true; //early out
2012-02-27 10:35:39 +00:00
// second = m_rhs->IsInside(x,y,z);
2002-10-12 11:37:38 +00:00
2012-02-27 10:35:39 +00:00
return m_lhs->IsInside(x,y,z,bBorderInclude);
2002-10-12 11:37:38 +00:00
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;
2012-02-27 10:35:39 +00:00
//first = m_lhs->IsInside(x,y,z);
2002-10-12 11:37:38 +00:00
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;
}
2011-12-30 07:55:15 +00:00
bool COperator2Expr::IsRightInside(float x, float y, float z,bool bBorderInclude)
{
2012-02-27 10:35:39 +00:00
return m_rhs->IsInside(x,y,z,bBorderInclude);
2002-10-12 11:37:38 +00:00
}
2011-12-30 07:55:15 +00:00
bool COperator2Expr::IsLeftInside(float x, float y, float z,bool bBorderInclude)
{
2002-10-12 11:37:38 +00:00
return m_lhs->IsInside(x,y,z,bBorderInclude);
}
*/
2011-12-30 07:55:15 +00:00
bool COperator2Expr::NeedsRecalculated()
{
2002-10-12 11:37:38 +00:00
// 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)
{
2002-10-12 11:37:38 +00:00
// 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());
/
*/
2012-03-24 07:36:32 +00:00
return Release();
2002-10-12 11:37:38 +00:00
}
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);
}