Khaganat-NeL/khanat-opennel-code
2
0
Fork 0
Code Issues 21 Pull requests Projects Releases 1 Packages Wiki Activity
khanat-opennel-code/code/nel/tools/3d/object_viewer/attrib_dlg.cpp

1649 lines
50 KiB
C++
Raw Normal View History

merge from default
2013-10-23 17:08:09 +00:00
// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
// Copyright (C) 2010 Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// attrib_dlg.cpp : implementation file
//
#include "std_afx.h"
#include "object_viewer.h"
#include "attrib_dlg.h"
#include "editable_range.h"
#include "color_edit.h"
#include "basis_edit.h"
#include "value_blender_dlg.h"
#include "value_gradient_dlg.h"
#include "value_from_emitter_dlg.h"
#include "bin_op_dlg.h"
#include "edit_user_param.h"
#include "edit_spinner.h"
#include "edit_follow_path.h"
#include "scheme_bank_dlg.h"
#include "scheme_manager.h"
#include "choose_name.h"
#include "curve_edit.h"
#include "nel/3d/ps_attrib_maker.h"
#include "nel/3d/ps_float.h"
#include "nel/3d/ps_int.h"
#include "nel/3d/ps_color.h"
#include "nel/3d/ps_plane_basis.h"
#include "nel/3d/ps_plane_basis_maker.h"
/*static char trace_buf[200];
#define NL_TRACE sprintf(trace_buf, "%d", __LINE__); \
::MessageBox(NULL, trace_buf, NULL, MB_OK);
*/
/////////////////////////////////////////////////////////////////////
// WRAPPERS to set / retrieve the NbCycles parameter of a scheme //
/////////////////////////////////////////////////////////////////////
static float NbCyclesReader(void *lParam) { return ((CAttribDlg *) lParam)->getSchemeNbCycles(); }
static void NbCyclesWriter(float value, void *lParam) { ((CAttribDlg *) lParam)->setSchemeNbCycles(value); }
///////////////////////////////////////////
// GENERAL INTERFACE FOR BLENDER EDITION //
///////////////////////////////////////////
/** T is the type to be edited (color, float, etc..),
* even if it is unused
*/
template <typename T>
class CValueBlenderDlgClientT : public IValueBlenderDlgClient
{
public:
std::string Id; // the Id of each of the dialog (it will be followed by %1 or %2)
// must be filled by the user
// the scheme being used. Must be set by the user
NL3D::CPSValueBlendFuncBase<T> *SchemeFunc;
protected:
virtual CEditAttribDlg *createDialog(uint index, CParticleWorkspace::CNode *ownerNode)
{
std::string id = Id;
if (index == 0) id += "%1"; else id += "%2";
_ValueInfos[index].ValueIndex = index;
_ValueInfos[index].SchemeFunc = SchemeFunc;
_ValueInfos[index].OwnerNode = ownerNode;
return newDialog(id, &_ValueInfos[index]);
}
// construct a dialog with the given wrapper and id
virtual CEditAttribDlg *newDialog(const std::string &id, IPSWrapper<T> *wrapper) = 0;
// inherited from IPSWrapper<T>
struct COneValueInfo : public IPSWrapper<T>
{
// value 0 or 1 being edited
uint ValueIndex;
// the scheme being edited
NL3D::CPSValueBlendFuncBase<T> *SchemeFunc;
virtual T get(void) const
{
T t1, t2;
SchemeFunc->getValues(t1, t2);
return ValueIndex == 0 ? t1 : t2;
}
virtual void set(const T &value)
{
T t1, t2;
SchemeFunc->getValues(t1, t2);
if (ValueIndex == 0 ) t1 = value; else t2 = value;
SchemeFunc->setValues(t1, t2);
}
};
COneValueInfo _ValueInfos[2];
};
////////////////////////////////////////////
// GENERAL INTERFACE FOR GRADIENT EDITION //
////////////////////////////////////////////
/** This template generate an interface that is used with the gradient edition dialog
* T is the type to be edited (color, floet, etc..)
*/
template <typename T>
class CValueGradientDlgClientT : public IValueGradientDlgClient, public IPSWrapper<T>
{
public:
std::string Id; // the Id of each of the dialog (it will be followed by %1 or %2)
// must be filled by the user
// the gradient being edited, must be filled by the instancier
NL3D::CPSValueGradientFunc<T> *Scheme;
// the gradient dialog, must be filled by the instancier
CValueGradientDlg *GradDlg;
// the difault value for new values creation. Must be filled by the instancier
T DefaultValue;
/// a function that can display a value in a gradient, with the given offset. Deriver must define this
virtual void displayValue(CDC *dc, uint index, sint x, sint y) = 0;
/// inherited from IPSWrapper
virtual T get(void) const { return Scheme->getValue(_CurrentEditedIndex); }
virtual void set(const T &v)
{
T *tab = new T[Scheme->getNumValues()];
Scheme->getValues(tab);
tab[_CurrentEditedIndex] = v;
Scheme->setValues(tab, Scheme->getNumValues(), Scheme->getNumStages());
delete[] tab;
GradDlg->invalidateGrad();
}
/** must provide a dialog for the edition of one value (only ONE exist at a time)
* \param index the index of the value in the dialog
* \grad the dlg that called this method (deriver can ask a redraw then)
*/
virtual CEditAttribDlg *createDialog(uint index, CValueGradientDlg *grad, CParticleWorkspace::CNode *ownerNode)
{
OwnerNode = ownerNode;
_CurrentEditedIndex = index;
return newDialog(Id, this);
}
/// create a new dialog with given id and wrapper
virtual CEditAttribDlg *newDialog(const std::string &id, IPSWrapper<T> *wrapper) = 0;
/// a function that can add, remove, or insert a new element in the gradient
virtual void modifyGradient(TAction action, uint index)
{
T *tab = new T[Scheme->getNumValues() + 1]; // +1 is for the add / insert case
Scheme->getValues(tab);
switch(action)
{
case IValueGradientDlgClient::Add:
tab[Scheme->getNumValues()] = DefaultValue;
Scheme->setValues(tab, Scheme->getNumValues() + 1, Scheme->getNumStages());
break;
case IValueGradientDlgClient::Insert:
::memmove(tab + (index + 1), tab + index, sizeof(T) * (Scheme->getNumValues() - index));
tab[index] = DefaultValue;
Scheme->setValues(tab, Scheme->getNumValues() + 1, Scheme->getNumStages());
break;
case IValueGradientDlgClient::Delete:
::memmove(tab + index, tab + index + 1, sizeof(T) * (Scheme->getNumValues() - index - 1));
Scheme->setValues(tab, Scheme->getNumValues() - 1, Scheme->getNumStages());
break;
case IValueGradientDlgClient::Up:
nlassert(index > 0);
std::swap(tab[index], tab[index - 1]);
Scheme->setValues(tab, Scheme->getNumValues(), Scheme->getNumStages());
break;
case IValueGradientDlgClient::Down:
nlassert(index < Scheme->getNumValues() - 1);
std::swap(tab[index], tab[index + 1]);
Scheme->setValues(tab, Scheme->getNumValues(), Scheme->getNumStages());
break;
}
delete[] tab;
}
virtual uint32 getSchemeSize(void) const { return Scheme->getNumValues(); }
// get the number of interpolation step
uint32 getNbSteps(void) const
{
return Scheme->getNumStages();
}
// set the number of interpolation steps
void setNbSteps(uint32 value)
{
Scheme->setNumStages(value);
}
protected:
// index of the value OF the current dialog that exist
uint32 _CurrentEditedIndex;
};
/////////////////////////////////////////////////////////////////////////////
// CAttribDlg dialog
//*************************************************************************************************************
CAttribDlg::CAttribDlg(const std::string &valueID, CParticleWorkspace::CNode *ownerNode, bool enableConstantValue /* = true*/)
: _CstValueDlg(NULL),
_Node(ownerNode),
_FirstDrawing(true),
_EnableConstantValue(enableConstantValue),
_DisableMemoryScheme(false),
_SchemeEditionDlg(NULL),
_NbCycleEnabled(true),
_NbCyclesDlg(NULL),
_ValueID(valueID),
_SrcInputEnabled(true)
{
//{{AFX_DATA_INIT(CAttribDlg)
m_AttribName = _T("");
m_Clamp = FALSE;
//}}AFX_DATA_INIT
}
//*************************************************************************************************************
void CAttribDlg::closeEditWindow()
{
childPopupClosed(NULL);
}
//*************************************************************************************************************
BOOL CAttribDlg::EnableWindow( BOOL bEnable)
{
if (_CstValueDlg)
{
_CstValueDlg->EnableWindow(bEnable);
}
if (_NbCyclesDlg)
{
_NbCyclesDlg->EnableWindow(bEnable);
}
m_UseScheme.EnableWindow(bEnable);
m_AttrBitmap.EnableWindow(bEnable);
if (useScheme())
{
m_Scheme.EnableWindow(bEnable);
m_SchemeInput.EnableWindow(hasSchemeCustomInput() ? bEnable : FALSE);
m_EditScheme.EnableWindow(bEnable);
m_GetScheme.EnableWindow(bEnable);
m_PutScheme.EnableWindow(bEnable);
m_ClampCtrl.EnableWindow(bEnable);
}
else
{
m_ClampCtrl.EnableWindow(FALSE);
}
UpdateData(FALSE);
return CDialog::EnableWindow(bEnable);
}
//*************************************************************************************************************
CAttribDlg::~CAttribDlg()
{
if (_NbCyclesDlg)
{
_NbCyclesDlg->DestroyWindow();
delete _NbCyclesDlg;
}
if (_CstValueDlg)
{
_CstValueDlg->DestroyWindow();
delete _CstValueDlg;
}
}
//*************************************************************************************************************
void CAttribDlg::update()
{
_FirstDrawing = true;
if (useScheme())
{
schemeValueUpdate();
}
else
{
nlassert(_EnableConstantValue);
cstValueUpdate();
}
}
//*************************************************************************************************************
void CAttribDlg::init(HBITMAP bitmap, sint x, sint y, CWnd *pParent)
{
Create(IDD_ATTRIB_DLG, pParent);
RECT r, ro;
GetClientRect(&r);
m_AttrBitmap.SendMessage(BM_SETIMAGE, IMAGE_BITMAP, (LPARAM) bitmap);
MoveWindow(x, y, r.right, r.bottom);
m_NbCyclePos.GetWindowRect(&r);
GetWindowRect(&ro);
if (_NbCycleEnabled)
{
_NbCyclesDlg = new CEditableRangeFloat(_ValueID + "%%NB_CYCLE_INFO", _Node, 0.1f, 10.1f);
_NbCyclesDlg->init(r.left - ro.left, r.top - ro.top, this);
}
// fill the combo box with the list of available scheme
m_Scheme.InitStorage(getNumScheme(), 32); // 32 char per string pre-allocated
for (uint k = 0; k < getNumScheme(); ++k)
{
m_Scheme.InsertString(k, getSchemeName(k).c_str());
}
update();
if (!_EnableConstantValue)
{
m_UseScheme.ShowWindow(SW_HIDE);
}
if (!_NbCyclesDlg)
{
GetDlgItem(IDC_INPUT_MULTIPLIER_TXT)->ShowWindow(SW_HIDE);
GetDlgItem(IDC_CLAMP_ATTRIB)->ShowWindow(SW_HIDE);
}
if (!_SrcInputEnabled)
{
GetDlgItem(IDC_SRC_INPUT_TXT)->ShowWindow(SW_HIDE);
GetDlgItem(IDC_EDIT_INPUT)->ShowWindow(SW_HIDE);
GetDlgItem(IDC_SCHEME_INPUT)->ShowWindow(SW_HIDE);
}
inputValueUpdate();
ShowWindow(SW_SHOW);
}
//*************************************************************************************************************
void CAttribDlg::DoDataExchange(CDataExchange* pDX)
{
CDialog::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CAttribDlg)
DDX_Control(pDX, IDC_PUT_SCHEME, m_PutScheme);
DDX_Control(pDX, IDC_GET_SCHEME, m_GetScheme);
DDX_Control(pDX, IDC_EDIT_INPUT, m_EditUserParam);
DDX_Control(pDX, IDC_SCHEME_INPUT, m_SchemeInput);
DDX_Control(pDX, IDC_CONSTANT_VALUE_POS, m_CstValuePos);
DDX_Control(pDX, IDC_ATTRIB_NB_CYCLES, m_NbCyclePos);
DDX_Control(pDX, IDC_ATTR_BITMAP, m_AttrBitmap);
DDX_Control(pDX, IDC_CLAMP_ATTRIB, m_ClampCtrl);
DDX_Control(pDX, IDC_EDIT_SCHEME, m_EditScheme);
DDX_Control(pDX, IDC_USE_SCHEME, m_UseScheme);
DDX_Control(pDX, IDC_SCHEME, m_Scheme);
DDX_Check(pDX, IDC_CLAMP_ATTRIB, m_Clamp);
//}}AFX_DATA_MAP
}
//*************************************************************************************************************
void CAttribDlg::inputValueUpdate(void)
{
if (useScheme() && getSchemeInput().InputType == NL3D::CPSInputType::attrUserParam)
{
m_EditUserParam.EnableWindow(TRUE);
}
else
{
m_EditUserParam.EnableWindow(FALSE);
}
}
//*************************************************************************************************************
void CAttribDlg::cstValueUpdate()
{
if (!_FirstDrawing && !useScheme()) return;
m_ClampCtrl.EnableWindow(FALSE);
if (_NbCyclesDlg)
{
_NbCyclesDlg->EnableWindow(FALSE);
_NbCyclesDlg->emptyDialog();
}
GetDlgItem(IDC_INPUT_MULTIPLIER_TXT)->EnableWindow(FALSE);
m_EditScheme.EnableWindow(FALSE);
m_PutScheme.EnableWindow(FALSE);
m_GetScheme.EnableWindow(FALSE);
m_EditScheme.ShowWindow(SW_HIDE);
m_GetScheme.ShowWindow(SW_HIDE);
m_PutScheme.ShowWindow(SW_HIDE);
m_Scheme.EnableWindow(FALSE);
m_Scheme.ShowWindow(SW_HIDE);
m_SchemeInput.EnableWindow(FALSE);
m_SchemeInput.ShowWindow(SW_HIDE);
if (!_FirstDrawing) resetCstValue();
m_UseScheme.SetCurSel(0);
_CstValueDlg = createConstantValueDlg();
CRect r, ro;
m_CstValuePos.GetWindowRect(&r);
GetWindowRect(&ro);
_CstValueDlg->init(r.left - ro.left, r.top - ro.top, this);
UpdateData(FALSE);
_FirstDrawing = false;
}
//*************************************************************************************************************
void CAttribDlg::schemeValueUpdate()
{
//if (!_FirstDrawing && useScheme()) return;
if (_CstValueDlg)
{
_CstValueDlg->DestroyWindow();
delete _CstValueDlg;
_CstValueDlg = NULL;
}
m_EditScheme.EnableWindow(TRUE);
m_GetScheme.EnableWindow(TRUE);
m_PutScheme.EnableWindow(TRUE);
m_EditScheme.ShowWindow(SW_SHOW);
m_GetScheme.ShowWindow(SW_SHOW);
m_PutScheme.ShowWindow(SW_SHOW);
m_Scheme.EnableWindow(TRUE);
m_Scheme.ShowWindow(SW_SHOW);
m_SchemeInput.EnableWindow(TRUE);
m_SchemeInput.ShowWindow(SW_SHOW);
m_UseScheme.SetCurSel(1);
sint k = getCurrentScheme();
if (k == -1) // unknow scheme ...
{
setCurrentScheme(0);
k = 0;
}
m_Scheme.SetCurSel(k);
if (hasSchemeCustomInput())
{
m_SchemeInput.EnableWindow();
m_SchemeInput.SetCurSel((uint) getSchemeInput().InputType);
inputValueUpdate();
if (_NbCyclesDlg)
{
_NbCyclesDlg->EnableWindow(TRUE);
}
m_ClampCtrl.EnableWindow(isClampingSupported());
GetDlgItem(IDC_INPUT_MULTIPLIER_TXT)->EnableWindow(isClampingSupported());
}
else
{
m_SchemeInput.EnableWindow(FALSE);
m_SchemeInput.SetCurSel(0);
if (_NbCyclesDlg)
{
_NbCyclesDlg->EnableWindow(FALSE);
}
m_ClampCtrl.EnableWindow(FALSE);
GetDlgItem(IDC_INPUT_MULTIPLIER_TXT)->EnableWindow(FALSE);
}
if (_NbCyclesDlg)
{
_NbCyclesWrapper.OwnerNode = _Node;
_NbCyclesDlg->setWrapper(&_NbCyclesWrapper);
_NbCyclesWrapper.Dlg = this;
_NbCyclesDlg->updateRange();
_NbCyclesDlg->updateValueFromReader();
}
if (isClampingSupported())
{
m_Clamp = isSchemeClamped();
}
UpdateData(FALSE);
_FirstDrawing = false;
}
//*************************************************************************************************************
void CAttribDlg::OnSelchangeUseScheme()
{
if (m_UseScheme.GetCurSel() == 0)
{
cstValueUpdate();
}
else
{
schemeValueUpdate();
}
}
//*************************************************************************************************************
void CAttribDlg::OnSelchangeScheme()
{
UpdateData();
setCurrentScheme(m_Scheme.GetCurSel());
schemeValueUpdate();
}
//*************************************************************************************************************
void CAttribDlg::OnEditScheme()
{
_SchemeEditionDlg = editScheme();
if (_SchemeEditionDlg)
{
EnableWindow(FALSE);
}
}
//*************************************************************************************************************
void CAttribDlg::childPopupClosed(CWnd *child)
{
EnableWindow(TRUE);
if (!_SchemeEditionDlg) return;
_SchemeEditionDlg->DestroyWindow();
delete _SchemeEditionDlg;
_SchemeEditionDlg = NULL;
}
//*************************************************************************************************************
void CAttribDlg::OnGetScheme()
{
CSchemeBankDlg sbd(getCurrentSchemePtr()->getType(), this);
if (sbd.DoModal() == IDOK && sbd.getSelectedScheme())
{
setCurrentSchemePtr(sbd.getSelectedScheme()->clone());
_FirstDrawing = true;
schemeValueUpdate();
}
}
//*************************************************************************************************************
void CAttribDlg::OnPutScheme()
{
CChooseName cn("new scheme", this);
if (cn.DoModal() == IDOK)
{
SchemeManager.insertScheme(cn.getName(), getCurrentSchemePtr()->clone());
}
}
//*************************************************************************************************************
void CAttribDlg::OnSelchangeSchemeInput()
{
UpdateData();
NL3D::CPSInputType it;
it.InputType = (NL3D::CPSInputType::TInputType) m_SchemeInput.GetCurSel();
if (it.InputType == NL3D::CPSInputType::attrUserParam)
{
it.UserParamNum = 0;
}
setSchemeInput(it);
inputValueUpdate();
}
//*************************************************************************************************************
void CAttribDlg::OnClampAttrib()
{
UpdateData();
clampScheme(m_Clamp ? true : false /* avoid performance warning */);
}
//*************************************************************************************************************
void CAttribDlg::OnEditInput()
{
switch (getSchemeInput().InputType)
{
case NL3D::CPSInputType::attrUserParam:
{
CEditUserParam ep(getSchemeInput().UserParamNum);
if (ep.DoModal() == IDOK)
{
NL3D::CPSInputType it = getSchemeInput();
it.UserParamNum = ep.getUserParamIndex();
setSchemeInput(it);
}
}
break;
}
}
BEGIN_MESSAGE_MAP(CAttribDlg, CDialog)
//{{AFX_MSG_MAP(CAttribDlg)
ON_CBN_SELCHANGE(IDC_USE_SCHEME, OnSelchangeUseScheme)
ON_CBN_SELCHANGE(IDC_SCHEME, OnSelchangeScheme)
ON_BN_CLICKED(IDC_EDIT_SCHEME, OnEditScheme)
ON_CBN_SELCHANGE(IDC_SCHEME_INPUT, OnSelchangeSchemeInput)
ON_BN_CLICKED(IDC_CLAMP_ATTRIB, OnClampAttrib)
ON_BN_CLICKED(IDC_EDIT_INPUT, OnEditInput)
ON_BN_CLICKED(IDC_GET_SCHEME, OnGetScheme)
ON_BN_CLICKED(IDC_PUT_SCHEME, OnPutScheme)
ON_WM_DESTROY()
ON_WM_CLOSE()
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CAttribDlg message handlers
////////////////////////////////////
// CAttribDlgFloat implementation //
////////////////////////////////////
//////////////////////////////////////////////////////////
// FLOAT BLENDER EDITION INTERFACE //
//////////////////////////////////////////////////////////
class CFloatBlenderDlgClient : public CValueBlenderDlgClientT<float>
{
public:
CEditAttribDlg *newDialog(const std::string &id, IPSWrapperFloat *wrapper)
{
CEditableRangeFloat *erf = new CEditableRangeFloat(id, wrapper->OwnerNode, MinRange, MaxRange);
erf->setWrapper(wrapper);
BoundChecker.duplicateBoundChecker(*erf);
return erf;
}
CBoundCheckerFloat BoundChecker;
float MinRange, MaxRange;
};
//////////////////////////////////////////////////////////
// FLOAT GRADIENT EDITION INTERFACE //
//////////////////////////////////////////////////////////
//*************************************************************************************************************
class CFloatGradientDlgWrapper : public CValueGradientDlgClientT<float>
{
public:
/// a function that can display a value in a gradient, with the given offset. Deriver must define this
void displayValue(CDC *dc, uint index, sint x, sint y)
{
CString out;
out.Format("%g", Scheme->getValue(index) );
dc->TextOut(x + 10, y + 4, out);
}
CEditAttribDlg *newDialog(const std::string &id, IPSWrapperFloat *wrapper)
{
CEditableRangeFloat *erf = new CEditableRangeFloat(id, wrapper->OwnerNode, MinRange, MaxRange);
erf->setWrapper(wrapper);
BoundChecker.duplicateBoundChecker(*erf);
return erf;
}
CBoundCheckerFloat BoundChecker;
float MinRange, MaxRange;
};
//*************************************************************************************************************
CAttribDlgFloat::CAttribDlgFloat(const std::string &valueID, CParticleWorkspace::CNode *node, float minRange, float maxRange)
: CAttribDlgT<float>(valueID, node), _MinRange(minRange), _MaxRange(maxRange)
{
_CstValueId = valueID;
}
//*************************************************************************************************************
CEditAttribDlg *CAttribDlgFloat::createConstantValueDlg()
{
CEditableRangeFloat *erf = new CEditableRangeFloat(_CstValueId, _Node, _MinRange, _MaxRange);
erf->setWrapper(_Wrapper);
duplicateBoundChecker(*erf);
return erf;
}
//*************************************************************************************************************
uint CAttribDlgFloat::getNumScheme(void) const
{
return _DisableMemoryScheme ? 3 : 5;
}
//*************************************************************************************************************
std::string CAttribDlgFloat::getSchemeName(uint index) const
{
const char *types[] = { "value blender", "values gradient", "curve", "value computed from emitter", "binary operator"};
nlassert(index < 5);
return std::string(types[index]);
}
//*************************************************************************************************************
CWnd *CAttribDlgFloat::editScheme(void)
{
NL3D::CPSAttribMaker<float> *scheme = _SchemeWrapper->getScheme();
if (dynamic_cast<NL3D::CPSFloatBlender *>(scheme))
{
CFloatBlenderDlgClient *myInterface = new CFloatBlenderDlgClient;
this->duplicateBoundChecker(myInterface->BoundChecker);
myInterface->MinRange = _MinRange;
myInterface->MaxRange = _MaxRange;
myInterface->Id = _CstValueId+ std::string("%%FLOAT_BLENDER");
myInterface->SchemeFunc = & ((NL3D::CPSValueBlenderSample<float, 64> *) scheme)->_F;
CValueBlenderDlg *vb = new CValueBlenderDlg(myInterface, true, this, this, _Node);
vb->init(this);
return vb;
}
if (dynamic_cast<NL3D::CPSFloatGradient *>(scheme))
{
CFloatGradientDlgWrapper *wrapper = new CFloatGradientDlgWrapper;
this->duplicateBoundChecker(wrapper->BoundChecker);
wrapper->MinRange = _MinRange;
wrapper->MaxRange = _MaxRange;
wrapper->Scheme = &(((NL3D::CPSFloatGradient *) (_SchemeWrapper->getScheme()) )->_F);
CValueGradientDlg *gd = new CValueGradientDlg(wrapper, _Node, true, this, this);
wrapper->GradDlg = gd;
wrapper->DefaultValue = 0.f;
wrapper->Id = _CstValueId+ std::string("%%FLOAT GRADIENT");
gd->init(this);
return gd;
}
if (dynamic_cast<NL3D::CPSFloatMemory *>(scheme))
{
CAttribDlgFloat *adf = new CAttribDlgFloat(_CstValueId, _Node, _MinRange, _MaxRange);
this->duplicateBoundChecker(*adf);
CValueFromEmitterDlgT<float> *vfe = new CValueFromEmitterDlgT<float>( (NL3D::CPSFloatMemory *)(scheme),
adf,
this,
m_AttrBitmap.GetBitmap()
);
vfe->init(this);
return vfe;
}
if (dynamic_cast<NL3D::CPSFloatBinOp *>(scheme))
{
CAttribDlgFloat *ad[2] = { NULL, NULL};
for (uint k = 0; k <2; ++k)
{
ad[k] = new CAttribDlgFloat(_CstValueId, _Node, _MinRange, _MaxRange);
this->duplicateBoundChecker(*ad[k]);
}
CBinOpDlgT<float> *bod = new CBinOpDlgT<float>( (NL3D::CPSFloatBinOp *)(scheme),
(CAttribDlgT<float> **) ad,
this,
m_AttrBitmap.GetBitmap());
bod->init(this);
return bod;
}
if (dynamic_cast<NL3D::CPSFloatCurve *>(scheme))
{
CurveEdit *ce = new CurveEdit(&(dynamic_cast<NL3D::CPSFloatCurve *>(scheme)->_F), _Node, this, this);
ce->init(this);
return ce;
}
return NULL;
}
//*************************************************************************************************************
sint CAttribDlgFloat::getCurrentScheme(void) const
{
const NL3D::CPSAttribMaker<float> *scheme = _SchemeWrapper->getScheme();
if (dynamic_cast<const NL3D::CPSFloatBlender *>(scheme)) return 0;
if (dynamic_cast<const NL3D::CPSFloatGradient *>(scheme)) return 1;
if (dynamic_cast<const NL3D::CPSFloatCurve *>(scheme)) return 2;
if (dynamic_cast<const NL3D::CPSFloatMemory *>(scheme)) return 3;
if (dynamic_cast<const NL3D::CPSFloatBinOp *>(scheme)) return 4;
return -1;
}
//*************************************************************************************************************
void CAttribDlgFloat::setCurrentScheme(uint index)
{
nlassert(index < 5);
NL3D::CPSAttribMaker<float> *scheme = NULL;
switch (index)
{
case 0:
scheme = new NL3D::CPSFloatBlender(_MinRange, _MaxRange);
break;
case 1:
{
static const float values[2] = { 0.1f, 1.f };
scheme = new NL3D::CPSFloatGradient(values, 2, 16, 1.f);
}
break;
case 2:
{
NL3D::CPSFloatCurve *curve = new NL3D::CPSFloatCurve;
curve->_F.setNumSamples(128);
curve->_F.addControlPoint(NL3D::CPSFloatCurveFunctor::CCtrlPoint(0, 0.5f));
curve->_F.addControlPoint(NL3D::CPSFloatCurveFunctor::CCtrlPoint(1, 0.5f));
scheme = curve;
}
break;
case 3:
scheme = new NL3D::CPSFloatMemory;
((NL3D::CPSAttribMakerMemory<float> *) scheme)->setScheme(new NL3D::CPSFloatBlender(_MinRange, _MaxRange));
break;
case 4 :
scheme = new NL3D::CPSFloatBinOp;
((NL3D::CPSFloatBinOp *) scheme)->setArg(0, new NL3D::CPSFloatBlender);
((NL3D::CPSFloatBinOp *) scheme)->setArg(1, new NL3D::CPSFloatBlender);
break;
default:
break;
}
if (scheme)
{
_SchemeWrapper->setSchemeAndUpdateModifiedFlag(scheme);
}
}
////////////////////////////////////
// CAttribDlgUInt implementation //
////////////////////////////////////
class CUIntBlenderDlgClient : public CValueBlenderDlgClientT<uint32>
{
public:
CEditAttribDlg *newDialog(const std::string &id, IPSWrapperUInt *wrapper)
{
CEditableRangeUInt *eru = new CEditableRangeUInt(id, wrapper->OwnerNode, MinRange, MaxRange);
eru->setWrapper(wrapper);
BoundChecker.duplicateBoundChecker(*eru);
return eru;
}
CBoundCheckerUInt BoundChecker;
uint32 MinRange, MaxRange;
};
//////////////////////////////////////////////////////////
// UINT GRADIENT EDITION INTERFACE //
//////////////////////////////////////////////////////////
//*************************************************************************************************************
class CUIntGradientDlgWrapper : public CValueGradientDlgClientT<uint32>
{
public:
/// a function that can display a value in a gradient, with the given offset. Deriver must define this
void displayValue(CDC *dc, uint index, sint x, sint y)
{
CString out;
out.Format("%d", Scheme->getValue(index) );
dc->TextOut(x + 10, y + 4, out);
}
CEditAttribDlg *newDialog(const std::string &id, IPSWrapperUInt *wrapper)
{
CEditableRangeUInt *eru = new CEditableRangeUInt(id, wrapper->OwnerNode, MinRange, MaxRange);
eru->setWrapper(wrapper);
BoundChecker.duplicateBoundChecker(*eru);
return eru;
}
CBoundCheckerUInt BoundChecker;
uint32 MinRange, MaxRange;
};
//*************************************************************************************************************
CAttribDlgUInt::CAttribDlgUInt(const std::string &valueID, CParticleWorkspace::CNode *node, uint32 minRange, uint32 maxRange)
: CAttribDlgT<uint32>(valueID, node), _MinRange(minRange), _MaxRange(maxRange)
{
_CstValueId = valueID;
}
//*************************************************************************************************************
CEditAttribDlg *CAttribDlgUInt::createConstantValueDlg()
{
CEditableRangeUInt *erf = new CEditableRangeUInt(_CstValueId, _Node, _MinRange, _MaxRange);
erf->setWrapper(_Wrapper);
duplicateBoundChecker(*erf);
return erf;
}
//*************************************************************************************************************
uint CAttribDlgUInt::getNumScheme(void) const
{
return _DisableMemoryScheme ? 2 : 4;
}
//*************************************************************************************************************
std::string CAttribDlgUInt::getSchemeName(uint index) const
{
const char *types[] = { "value blender", "values gradient", "values computed from emitter", "binary operator" };
nlassert(index < 4);
return std::string(types[index]);
}
//*************************************************************************************************************
CWnd *CAttribDlgUInt::editScheme(void)
{
const NL3D::CPSAttribMaker<uint32> *scheme = _SchemeWrapper->getScheme();
if (dynamic_cast<const NL3D::CPSUIntBlender *>(scheme))
{
CUIntBlenderDlgClient *myInterface = new CUIntBlenderDlgClient ;
duplicateBoundChecker(myInterface->BoundChecker);
myInterface->MinRange = _MinRange;
myInterface->MaxRange = _MaxRange;
myInterface->Id = _CstValueId+ std::string("%%UINT_BLENDER");
myInterface->SchemeFunc = & ((NL3D::CPSValueBlenderSample<uint32, 64> *) scheme)->_F;
CValueBlenderDlg *vb = new CValueBlenderDlg(myInterface, true, this, this, _Node);
vb->init(this);
return vb;
}
if (dynamic_cast<const NL3D::CPSUIntGradient *>(scheme))
{
CUIntGradientDlgWrapper *wrapper = new CUIntGradientDlgWrapper;
this->duplicateBoundChecker(wrapper->BoundChecker);
wrapper->MinRange = _MinRange;
wrapper->MaxRange = _MaxRange;
wrapper->Scheme = &(((NL3D::CPSUIntGradient *) (_SchemeWrapper->getScheme()) )->_F);
CValueGradientDlg *gd = new CValueGradientDlg(wrapper, _Node, true, this, this);
wrapper->GradDlg = gd;
wrapper->DefaultValue = 0;
wrapper->Id = _CstValueId+ std::string("%%UINT GRADIENT");
gd->init(this);
return gd;
}
if (dynamic_cast<const NL3D::CPSUIntMemory *>(scheme))
{
CAttribDlgUInt *adu = new CAttribDlgUInt(_CstValueId, _Node, _MinRange, _MaxRange);
this->duplicateBoundChecker(*adu);
CValueFromEmitterDlgT<uint32> *vfe = new CValueFromEmitterDlgT<uint32>( (NL3D::CPSUIntMemory *)(scheme),
adu,
this,
m_AttrBitmap.GetBitmap());
vfe->init(this);
return vfe;
}
if (dynamic_cast<const NL3D::CPSUIntBinOp *>(scheme))
{
CAttribDlgUInt *ad[2] = { NULL, NULL};
for (uint k = 0; k <2; ++k)
{
ad[k] = new CAttribDlgUInt(_CstValueId, _Node, _MinRange, _MaxRange);
this->duplicateBoundChecker(*ad[k]);
}
CBinOpDlgT<uint32> *bod = new CBinOpDlgT<uint32>( (NL3D::CPSUIntBinOp *)(scheme),
(CAttribDlgT<uint32> **) ad,
this,
m_AttrBitmap.GetBitmap());
bod->init(this);
return bod;
}
return NULL;
}
//*************************************************************************************************************
sint CAttribDlgUInt::getCurrentScheme(void) const
{
const NL3D::CPSAttribMaker<uint32> *scheme = _SchemeWrapper->getScheme();
if (dynamic_cast<const NL3D::CPSUIntBlender *>(scheme)) return 0;
if (dynamic_cast<const NL3D::CPSUIntGradient *>(scheme)) return 1;
if (dynamic_cast<const NL3D::CPSUIntMemory *>(scheme)) return 2;
if (dynamic_cast<const NL3D::CPSUIntBinOp *>(scheme)) return 3;
return -1;
}
//*************************************************************************************************************
void CAttribDlgUInt::setCurrentScheme(uint index)
{
nlassert(index < 4);
NL3D::CPSAttribMaker<uint32> *scheme = NULL;
switch (index)
{
case 0 :
scheme = new NL3D::CPSUIntBlender(_MinRange, _MaxRange);
break;
case 1 :
scheme = new NL3D::CPSUIntGradient;
break;
case 2 :
scheme = new NL3D::CPSUIntMemory;
((NL3D::CPSAttribMakerMemory<uint32> *) scheme)->setScheme(new NL3D::CPSUIntBlender(_MinRange, _MaxRange) );
break;
case 3 :
scheme = new NL3D::CPSUIntBinOp;
((NL3D::CPSUIntBinOp *) scheme)->setArg(0, new NL3D::CPSUIntBlender);
((NL3D::CPSUIntBinOp *) scheme)->setArg(1, new NL3D::CPSUIntBlender);
break;
default:
break;
}
if (scheme)
{
_SchemeWrapper->setSchemeAndUpdateModifiedFlag(scheme);
}
}
////////////////////////////////////
// CAttribDlgInt implementation //
////////////////////////////////////
class CIntBlenderDlgClient : public CValueBlenderDlgClientT<sint32>
{
public:
CEditAttribDlg *newDialog(const std::string &id, IPSWrapper<sint32> *wrapper)
{
CEditableRangeInt *eri = new CEditableRangeInt(id, wrapper->OwnerNode, MinRange, MaxRange);
eri->setWrapper(wrapper);
BoundChecker.duplicateBoundChecker(*eri);
return eri;
}
CBoundCheckerInt BoundChecker;
sint32 MinRange, MaxRange;
};
//////////////////////////////////////////////////////////
// INT GRADIENT EDITION INTERFACE //
//////////////////////////////////////////////////////////
//*************************************************************************************************************
class CIntGradientDlgWrapper : public CValueGradientDlgClientT<sint32>
{
public:
/// a function that can display a value in a gradient, with the given offset. Deriver must define this
void displayValue(CDC *dc, uint index, sint x, sint y)
{
CString out;
out.Format("%d", Scheme->getValue(index) );
dc->TextOut(x + 10, y + 4, out);
}
CEditAttribDlg *newDialog(const std::string &id, IPSWrapper<sint32> *wrapper)
{
CEditableRangeInt *eri = new CEditableRangeInt(id, wrapper->OwnerNode, MinRange, MaxRange);
eri->setWrapper(wrapper);
BoundChecker.duplicateBoundChecker(*eri);
return eri;
}
CBoundCheckerInt BoundChecker;
sint32 MinRange, MaxRange;
};
//*************************************************************************************************************
CAttribDlgInt::CAttribDlgInt(const std::string &valueID, CParticleWorkspace::CNode *node, sint32 minRange, sint32 maxRange)
: CAttribDlgT<sint32>(valueID, node), _MinRange(minRange), _MaxRange(maxRange)
{
_CstValueId = valueID;
}
//*************************************************************************************************************
CEditAttribDlg *CAttribDlgInt::createConstantValueDlg()
{
CEditableRangeInt *erf = new CEditableRangeInt(_CstValueId, _Node, _MinRange, _MaxRange);
erf->setWrapper(_Wrapper);
duplicateBoundChecker(*erf);
return erf;
}
//*************************************************************************************************************
uint CAttribDlgInt::getNumScheme(void) const
{
return _DisableMemoryScheme ? 2 : 4;
}
//*************************************************************************************************************
std::string CAttribDlgInt::getSchemeName(uint index) const
{
const char *types[] = { "value exact blender", "values gradient", "values computed from emitter", "binary operator" };
nlassert(index < 4);
return std::string(types[index]);
}
//*************************************************************************************************************
CWnd *CAttribDlgInt::editScheme(void)
{
const NL3D::CPSAttribMaker<sint32> *scheme = _SchemeWrapper->getScheme();
if (dynamic_cast<const NL3D::CPSIntBlender *>(scheme))
{
CIntBlenderDlgClient *myInterface = new CIntBlenderDlgClient;
this->duplicateBoundChecker(myInterface->BoundChecker);
myInterface->MinRange = _MinRange;
myInterface->MaxRange = _MaxRange;
myInterface->Id = _CstValueId+ std::string("%%INT_BLENDER");
myInterface->SchemeFunc = & ((NL3D::CPSValueBlenderSample<sint32, 64> *) scheme)->_F;
CValueBlenderDlg *vb = new CValueBlenderDlg(myInterface, true, this, this, _Node);
vb->init(this);
return vb;
}
if (dynamic_cast<const NL3D::CPSIntGradient *>(scheme))
{
CIntGradientDlgWrapper *wrapper = new CIntGradientDlgWrapper;
this->duplicateBoundChecker(wrapper->BoundChecker);
wrapper->MinRange = _MinRange;
wrapper->MaxRange = _MaxRange;
wrapper->Scheme = &(((NL3D::CPSIntGradient *) (_SchemeWrapper->getScheme()) )->_F);
CValueGradientDlg *gd = new CValueGradientDlg(wrapper, _Node, true, this, this);
wrapper->GradDlg = gd;
wrapper->DefaultValue = 0;
wrapper->Id = _CstValueId+ std::string("%%INT GRADIENT");
gd->init(this);
return gd;
}
if (dynamic_cast<const NL3D::CPSIntMemory *>(scheme))
{
CAttribDlgInt *adi = new CAttribDlgInt(_CstValueId, _Node, _MinRange, _MaxRange);
this->duplicateBoundChecker(*adi);
CValueFromEmitterDlgT<sint32> *vfe = new CValueFromEmitterDlgT<sint32>((NL3D::CPSIntMemory *) _SchemeWrapper->getScheme(),
adi,
this,
m_AttrBitmap.GetBitmap() );
vfe->init(this);
return vfe;
}
/* if (dynamic_cast<const NL3D::CPSIntMemory *>(scheme))
{
CValueFromEmitterDlgT<float, CAttribDlgFloat> vfe( (NL3D::CPSFloatMemory *)(scheme), std::string("UINT SCHEME"), m_AttrBitmap.GetBitmap());
vfe.DoModal();
}*/
if (dynamic_cast<const NL3D::CPSIntBinOp *>(scheme))
{
CAttribDlgInt *ad[2] = { NULL, NULL};
for (uint k = 0; k <2; ++k)
{
ad[k] = new CAttribDlgInt(_CstValueId, _Node, _MinRange, _MaxRange);
this->duplicateBoundChecker(*ad[k]);
}
CBinOpDlgT<sint32> *bod = new CBinOpDlgT<sint32>( (NL3D::CPSIntBinOp *)(scheme),
(CAttribDlgT<sint32> **) ad,
this,
m_AttrBitmap.GetBitmap());
bod->init(this);
return bod;
}
return NULL;
}
//*************************************************************************************************************
sint CAttribDlgInt::getCurrentScheme(void) const
{
const NL3D::CPSAttribMaker<sint32> *scheme = _SchemeWrapper->getScheme();
if (dynamic_cast<const NL3D::CPSIntBlender *>(scheme)) return 0;
if (dynamic_cast<const NL3D::CPSIntGradient *>(scheme)) return 1;
if (dynamic_cast<const NL3D::CPSIntMemory *>(scheme)) return 2;
if (dynamic_cast<const NL3D::CPSIntBinOp *>(scheme)) return 3;
return -1;
}
//*************************************************************************************************************
void CAttribDlgInt::setCurrentScheme(uint index)
{
nlassert(index < 4);
NL3D::CPSAttribMaker<sint32> *scheme = NULL;
switch (index)
{
case 0 :
scheme = new NL3D::CPSIntBlender;
break;
case 1 :
scheme = new NL3D::CPSIntGradient;
break;
case 2 :
scheme = new NL3D::CPSIntMemory;
((NL3D::CPSAttribMakerMemory<sint32> *) scheme)->setScheme(new NL3D::CPSIntBlender(_MinRange, _MaxRange));
break;
case 3 :
scheme = new NL3D::CPSIntBinOp;
((NL3D::CPSIntBinOp *) scheme)->setArg(0, new NL3D::CPSIntBlender);
((NL3D::CPSIntBinOp *) scheme)->setArg(1, new NL3D::CPSIntBlender);
break;
default:
break;
}
if (scheme)
{
_SchemeWrapper->setSchemeAndUpdateModifiedFlag(scheme);
}
}
///////////////////////
// CRGBA attributes //
///////////////////////
class CRGBABlenderDlgClient : public CValueBlenderDlgClientT<NLMISC::CRGBA>
{
public:
CEditAttribDlg *newDialog(const std::string &id, IPSWrapper<NLMISC::CRGBA> *wrapper)
{
CColorEdit *ce = new CColorEdit;
ce->setWrapper(wrapper);
return ce;
}
};
//////////////////////////////////////////////////////////
// COLOR GRADIENT EDITION INTERFACE //
//////////////////////////////////////////////////////////
//*************************************************************************************************************
class CColorGradientDlgWrapper : public CValueGradientDlgClientT<CRGBA>
{
public:
/// a function that can display a value in a gradient, with the given offset. Deriver must define this
void displayValue(CDC *dc, uint index, sint x, sint y)
{
CRGBA col = Scheme->getValue(index);
RECT r;
r.left = x + 10;
r.top = y + 10;
r.right = x + 53;
r.bottom = y + 29;
CBrush b;
b.CreateSolidBrush(RGB(col.R, col.G, col.B));
dc->FillRect(&r, &b);
b.DeleteObject();
b.CreateSolidBrush(RGB(0, 0, 0));
CGdiObject *old = dc->SelectObject(&b);
r.top = y + 10; r. bottom = y + 29;
r.right = x + 53; r.left = x + 10;
dc->FrameRect(&r, &b);
dc->SelectObject(old);
b.DeleteObject();
}
CEditAttribDlg *newDialog(const std::string &id, IPSWrapper<NLMISC::CRGBA> *wrapper)
{
CColorEdit *ce = new CColorEdit;
ce->setWrapper(wrapper);
return ce;
}
};
////////////////////////////
//*************************************************************************************************************
CAttribDlgRGBA::CAttribDlgRGBA(const std::string &valueID, CParticleWorkspace::CNode *node) : CAttribDlgT<CRGBA>(valueID, node)
{
}
//*************************************************************************************************************
uint CAttribDlgRGBA::getNumScheme(void) const
{
return _DisableMemoryScheme ? 3 : 5;
}
//*************************************************************************************************************
std::string CAttribDlgRGBA::getSchemeName(uint index) const
{
const char *types[] = { "color sampled blender", "color gradient", "color exact blender", "values computed from emitter", "binary operator" };
nlassert(index < 5);
return std::string(types[index]);
}
//*************************************************************************************************************
CWnd *CAttribDlgRGBA::editScheme(void)
{
const NL3D::CPSAttribMaker<CRGBA> *scheme = _SchemeWrapper->getScheme();
if (dynamic_cast<const NL3D::CPSColorBlender *>(scheme))
{
CRGBABlenderDlgClient *myInterface = new CRGBABlenderDlgClient;
myInterface->Id = std::string("RGBA_BLENDER");
myInterface->SchemeFunc = & ((NL3D::CPSValueBlenderSample<CRGBA, 64> *) scheme)->_F;
CValueBlenderDlg *vb = new CValueBlenderDlg(myInterface, true, this, this, _Node);
vb->init(this);
return vb;
}
if (dynamic_cast<const NL3D::CPSColorGradient *>(scheme))
{
CColorGradientDlgWrapper *wrapper = new CColorGradientDlgWrapper;
wrapper->Scheme = &(((NL3D::CPSColorGradient *) (_SchemeWrapper->getScheme()) )->_F);
CValueGradientDlg *gd = new CValueGradientDlg(wrapper, _Node, true, this, this);
wrapper->GradDlg = gd;
wrapper->DefaultValue = CRGBA::White;
wrapper->Id = std::string("RGBA_GRADIENT");
gd->init(this);
return gd;
}
if (dynamic_cast<const NL3D::CPSColorBlenderExact *>(scheme))
{
return NULL;
}
if (dynamic_cast<const NL3D::CPSColorMemory *>(scheme))
{
CAttribDlgRGBA *ad = new CAttribDlgRGBA(_CstValueId, _Node);
CValueFromEmitterDlgT<CRGBA> *vfe = new CValueFromEmitterDlgT<CRGBA>( (NL3D::CPSColorMemory *)(scheme),
ad,
this,
m_AttrBitmap.GetBitmap());
vfe->init(this);
return vfe;
}
if (dynamic_cast<const NL3D::CPSColorBinOp *>(scheme))
{
CAttribDlgRGBA *ad[2] = { NULL, NULL};
for (uint k = 0; k <2; ++k)
{
ad[k] = new CAttribDlgRGBA(_CstValueId, _Node);
}
CBinOpDlgT<CRGBA> *bod = new CBinOpDlgT<CRGBA>( (NL3D::CPSColorBinOp *)(scheme),
(CAttribDlgT<CRGBA> **) ad,
this,
m_AttrBitmap.GetBitmap());
bod->init(this);
return bod;
}
return NULL;
}
//*************************************************************************************************************
void CAttribDlgRGBA::setCurrentScheme(uint index)
{
nlassert(index < 5);
NL3D::CPSAttribMaker<CRGBA> *scheme = NULL;
switch (index)
{
case 0 :
scheme = new NL3D::CPSColorBlender;
break;
case 1 :
scheme = new NL3D::CPSColorGradient(NL3D::CPSColorGradient::_DefaultGradient, 2, 16, 1.f);
break;
case 2 :
scheme = new NL3D::CPSColorBlenderExact;
break;
case 3 :
scheme = new NL3D::CPSColorMemory;
((NL3D::CPSAttribMakerMemory<CRGBA> *) scheme)->setScheme(new NL3D::CPSColorBlender);
break;
case 4 :
scheme = new NL3D::CPSColorBinOp;
((NL3D::CPSColorBinOp *) scheme)->setArg(0, new NL3D::CPSColorBlender);
((NL3D::CPSColorBinOp *) scheme)->setArg(1, new NL3D::CPSColorBlender);
break;
default:
break;
}
if (scheme)
{
_SchemeWrapper->setSchemeAndUpdateModifiedFlag(scheme);
}
}
//*************************************************************************************************************
sint CAttribDlgRGBA::getCurrentScheme(void) const
{
const NL3D::CPSAttribMaker<CRGBA> *scheme = _SchemeWrapper->getScheme();
if (dynamic_cast<const NL3D::CPSColorBlender *>(scheme)) return 0;
if (dynamic_cast<const NL3D::CPSColorGradient *>(scheme)) return 1;
if (dynamic_cast<const NL3D::CPSColorBlenderExact *>(scheme)) return 2;
if (dynamic_cast<const NL3D::CPSColorMemory *>(scheme)) return 3;
if (dynamic_cast<const NL3D::CPSColorBinOp *>(scheme)) return 4;
return -1;
}
//*************************************************************************************************************
CEditAttribDlg *CAttribDlgRGBA::createConstantValueDlg()
{
CColorEdit *ce = new CColorEdit;
ce->setWrapper(_Wrapper);
return ce;
}
/////////////////////////////
// plane basis attributes //
/////////////////////////////
//////////////////////////////////////////////////////////
// PLANE BASIS GRADIENT EDITION INTERFACE //
//////////////////////////////////////////////////////////
class CPlaneBasisGradientDlgWrapper : public CValueGradientDlgClientT<NL3D::CPlaneBasis>
{
public:
/// a function that can display a value in a gradient, with the given offset. Deriver must define this
void displayValue(CDC *dc, uint index, sint x, sint y)
{
NLMISC::CRGBA c1[] ={ NLMISC::CRGBA::Black, NLMISC::CRGBA::Black, NLMISC::CRGBA::Black };
NLMISC::CRGBA c2[] ={ NLMISC::CRGBA::Green, NLMISC::CRGBA::Green, NLMISC::CRGBA::Red };
// read plane basis
NL3D::CPlaneBasis pb = Scheme->getValue(index);
CPoint center(x + 20, y + 25);
NLMISC::CMatrix m;
m.setRot(pb.X, pb.Y, pb.X ^ pb.Y);
DrawBasisInDC(center, 12, m, *dc, c2);
}
CEditAttribDlg *newDialog(const std::string &id, IPSWrapper<NL3D::CPlaneBasis> *wrapper)
{
CBasisEdit *be = new CBasisEdit;
be->setWrapper(wrapper);
return be;
}
};
//*************************************************************************************************************
CAttribDlgPlaneBasis::CAttribDlgPlaneBasis(const std::string &valueID, CParticleWorkspace::CNode *node) : CAttribDlgT<NL3D::CPlaneBasis>(valueID, node)
{
}
uint CAttribDlgPlaneBasis::getNumScheme(void) const
{
return _DisableMemoryScheme ? 3 : 5;
}
std::string CAttribDlgPlaneBasis::getSchemeName(uint index) const
{
const char *types[] = { "basis gradient", "follow path", "spinner", "values computed from emitter", "binary operator" };
nlassert(index < 5);
return std::string(types[index]);
}
//*************************************************************************************************************
CWnd *CAttribDlgPlaneBasis::editScheme(void)
{
NL3D::CPSAttribMaker<NL3D::CPlaneBasis> *scheme = _SchemeWrapper->getScheme();
if (dynamic_cast<NL3D::CPSPlaneBasisGradient *>(scheme))
{
CPlaneBasisGradientDlgWrapper *wrapper = new CPlaneBasisGradientDlgWrapper;
wrapper->Scheme = &(((NL3D::CPSPlaneBasisGradient *) (_SchemeWrapper->getScheme()) )->_F);
CValueGradientDlg *gd = new CValueGradientDlg(wrapper, _Node, true, this, this);
wrapper->GradDlg = gd;
wrapper->DefaultValue = NL3D::CPlaneBasis(NLMISC::CVector::K);
wrapper->Id = std::string("PLANE_BASIS_GRADIENT");
gd->init(this);
return gd;
}
if (dynamic_cast<NL3D::CPSPlaneBasisFollowSpeed *>(scheme))
{
CEditFollowPath *efp = new CEditFollowPath((NL3D::CPSPlaneBasisFollowSpeed *) scheme, _Node, this, this);
efp->init(this);
return efp;
}
if (dynamic_cast<NL3D::CPSPlaneBasisMemory *>(scheme))
{
CAttribDlgPlaneBasis *ad = new CAttribDlgPlaneBasis(_CstValueId, _Node);
CValueFromEmitterDlgT<NL3D::CPlaneBasis> *vfe = new CValueFromEmitterDlgT<NL3D::CPlaneBasis>
( (NL3D::CPSPlaneBasisMemory *)(scheme),
ad,
this,
m_AttrBitmap.GetBitmap());
vfe->init(this);
return vfe;
}
if (dynamic_cast<NL3D::CPSPlaneBasisBinOp *>(scheme))
{
CAttribDlgPlaneBasis *ad[2] = { NULL, NULL};
for (uint k = 0; k <2; ++k)
{
ad[k] = new CAttribDlgPlaneBasis(_CstValueId, _Node);
}
CBinOpDlgT<NL3D::CPlaneBasis> *bod = new CBinOpDlgT<NL3D::CPlaneBasis>( (NL3D::CPSPlaneBasisBinOp *)(scheme),
(CAttribDlgT<NL3D::CPlaneBasis> **) ad,
this,
m_AttrBitmap.GetBitmap());
bod->init(this);
return bod;
}
if (dynamic_cast<NL3D::CPSBasisSpinner *>(scheme))
{
CEditSpinner *es = new CEditSpinner(static_cast<NL3D::CPSBasisSpinner *>(scheme), _Node, this, this);
es->init(this);
return es;
}
return NULL;
}
//*************************************************************************************************************
void CAttribDlgPlaneBasis::setCurrentScheme(uint index)
{
nlassert(index < 5);
NL3D::CPSAttribMaker<NL3D::CPlaneBasis> *scheme = NULL;
switch (index)
{
case 0:
scheme = new NL3D::CPSPlaneBasisGradient;
break;
case 1:
scheme = new NL3D::CPSPlaneBasisFollowSpeed;
break;
case 2:
scheme = new NL3D::CPSBasisSpinner;
static_cast<NL3D::CPSBasisSpinner *>(scheme)->_F.setNumSamples(16);
break;
case 3:
scheme = new NL3D::CPSPlaneBasisMemory;
((NL3D::CPSAttribMakerMemory<NL3D::CPlaneBasis> *) scheme)->setScheme(new NL3D::CPSPlaneBasisFollowSpeed);
if (_Node)
{
_Node->setModified(true);
}
break;
case 4 :
scheme = new NL3D::CPSPlaneBasisBinOp;
((NL3D::CPSPlaneBasisBinOp *) scheme)->setArg(0, new NL3D::CPSPlaneBasisFollowSpeed);
((NL3D::CPSPlaneBasisBinOp *) scheme)->setArg(1, new NL3D::CPSPlaneBasisFollowSpeed);
break;
default:
break;
}
if (scheme)
{
_SchemeWrapper->setSchemeAndUpdateModifiedFlag(scheme);
}
}
//*************************************************************************************************************
sint CAttribDlgPlaneBasis::getCurrentScheme(void) const
{
const NL3D::CPSAttribMaker<NL3D::CPlaneBasis> *scheme = _SchemeWrapper->getScheme();
if (dynamic_cast<const NL3D::CPSPlaneBasisGradient *>(scheme)) return 0;
if (dynamic_cast<const NL3D::CPSPlaneBasisFollowSpeed *>(scheme)) return 1;
if (dynamic_cast<const NL3D::CPSBasisSpinner *>(scheme)) return 2;
if (dynamic_cast<const NL3D::CPSPlaneBasisMemory *>(scheme)) return 3;
if (dynamic_cast<const NL3D::CPSPlaneBasisBinOp *>(scheme)) return 4;
return -1;
}
//*************************************************************************************************************
CEditAttribDlg *CAttribDlgPlaneBasis::createConstantValueDlg()
{
CBasisEdit *ce = new CBasisEdit;
ce->setWrapper(_Wrapper);
return ce;
}
//*************************************************************************************************************
void CAttribDlg::OnDestroy()
{
if (_SchemeEditionDlg)
{
CWnd *wnd = _SchemeEditionDlg;
_SchemeEditionDlg = NULL;
wnd ->DestroyWindow();
delete wnd ;
}
CDialog::OnDestroy();
}
//*************************************************************************************************************
void CAttribDlg::OnClose()
{
CDialog::OnClose();
}
Reference in a new issue Copy permalink