nel/tools/3d/object_viewer/texture_anim_dlg.cpp

   1 // NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This program is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU Affero General Public License as
   6 // published by the Free Software Foundation, either version 3 of the
   7 // License, or (at your option) any later version.
   8 //
   9 // This program is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU Affero General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU Affero General Public License
  15 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17
  18 #include "std_afx.h"
  19 #include "object_viewer.h"
  20 #include "texture_anim_dlg.h"
  21 #include "attrib_dlg.h"
  22 #include "texture_chooser.h"
  23 #include "nel/3d/ps_particle.h"
  24 #include "nel/3d/ps_particle_basic.h"
  25 #include "nel/3d/texture_grouped.h"
  26 #include "nel/3d/texture_file.h"
  27
  28
  29 #include "nel/misc/smart_ptr.h"
  30 #include "multi_tex_dlg.h"
  31
  32
  33 /////////////////////////////////////////////////////////////////////////////
  34 // CTextureAnimDlg dialog
  35
  36
  37 CTextureAnimDlg::CTextureAnimDlg(CParticleWorkspace::CNode *ownerNode,
  38                                                                  NL3D::CPSTexturedParticle *p,
  39                                                                  NL3D::CPSMultiTexturedParticle *mtp /*= NULL*/)
  40                                                                 : _Node(ownerNode),
  41                                                                   _EditedParticle(p),
  42                                                                   _TextureChooser(NULL),
  43                                                                   _TextureIndexDialog(NULL),
  44                                                                   _MTP(mtp),
  45                                                                   _MultiTexDlg(NULL)
  46 {
  47         nlassert(p);
  48         //{{AFX_DATA_INIT(CTextureAnimDlg)
  49         m_EnableTextureAnim = p->getTextureGroup() ? TRUE : FALSE;
  50         m_MultiTexEnable = FALSE;
  51         //}}AFX_DATA_INIT
  52 }
  53
  54 CTextureAnimDlg::~CTextureAnimDlg()
  55 {
  56         if (_MultiTexDlg)
  57         {
  58                 _MultiTexDlg->DestroyWindow();
  59                 delete _MultiTexDlg;
  60         }
  61         cleanCtrl();
  62 }
  63
  64
  65
  66 BOOL CTextureAnimDlg::EnableWindow( BOOL bEnable)
  67 {
  68         if (_TextureChooser) _TextureChooser->EnableWindow(bEnable);
  69         GetDlgItem(IDC_CHOOSE_TEXTURES)->EnableWindow(bEnable & m_EnableTextureAnim);
  70         GetDlgItem(IDC_ENABLE_TEXTURE_ANIM)->EnableWindow(bEnable);
  71         if (_MTP)
  72         {
  73                 ((CButton *) GetDlgItem(IDC_MULTITEX))->EnableWindow(bEnable);
  74                 GetDlgItem(IDC_EDIT_MULTITEX)->EnableWindow(bEnable & (_MTP->isMultiTextureEnabled() ? 1 : 0));
  75         }
  76         if (_TextureIndexDialog)
  77         {
  78                 _TextureIndexDialog->EnableWindow(bEnable);
  79         }
  80         return CDialog::EnableWindow(bEnable);
  81 }
  82
  83 void CTextureAnimDlg::init(sint x, sint y, CWnd *pParent)
  84 {
  85         Create(IDD_TEXTURE_ANIM, pParent);
  86         RECT r;
  87         GetClientRect(&r);
  88         MoveWindow(x, y, x + r.right, y + r.bottom);
  89         setupCtrl();
  90         if (!_MTP)
  91         {
  92                 GetDlgItem(IDC_MULTITEX)->ShowWindow(FALSE);
  93                 GetDlgItem(IDC_EDIT_MULTITEX)->ShowWindow(FALSE);
  94                 GetDlgItem(IDC_MULTITEX_BORDER)->ShowWindow(FALSE);
  95         }
  96         ShowWindow(SW_SHOW);
  97 }
  98
  99 void CTextureAnimDlg::cleanCtrl(void)
 100 {
 101         if (_TextureChooser)
 102         {
 103                 _TextureChooser->DestroyWindow();
 104                 delete _TextureChooser;
 105                 _TextureChooser = NULL;
 106         }
 107         if (_TextureIndexDialog)
 108         {
 109                 _TextureIndexDialog->DestroyWindow();
 110                 delete _TextureIndexDialog;
 111                 _TextureIndexDialog = NULL;
 112         }
 113 }
 114
 115
 116 void CTextureAnimDlg::setupCtrl(void)
 117 {
 118         // is there an animation ?
 119         if (_EditedParticle->getTextureGroup())
 120         {
 121                 if (!_TextureIndexDialog)
 122                 {
 123
 124                         _TextureIndexDialog = new CAttribDlgInt("TEXTURE_INDEX", _Node, 0, _EditedParticle->getTextureGroup()->getNbTextures() - 1);
 125                         _TextureIndexWrapper.P = _EditedParticle;
 126                         _TextureIndexDialog->setWrapper(&_TextureIndexWrapper );
 127                         _TextureIndexDialog->setSchemeWrapper(&_TextureIndexWrapper );
 128
 129                         HBITMAP bmh = LoadBitmap(::AfxGetInstanceHandle(), MAKEINTRESOURCE(IDB_ANIM_SEQUENCE));
 130                         _TextureIndexDialog->init(bmh, 0, 30, this);
 131                         m_ChooseTextures.EnableWindow(TRUE);
 132                 }
 133                 if (_MTP)
 134                 {
 135                         int display = _MTP->isMultiTextureEnabled() ? 1 : 0;
 136                         m_MultiTexEnable = display;
 137                         GetDlgItem(IDC_EDIT_MULTITEX)->EnableWindow(display);
 138                         GetDlgItem(IDC_MULTITEX)->EnableWindow(TRUE);
 139                 }
 140         }
 141         else // no animation, just show a texture chooser
 142         {
 143                 _TextureChooser = new CTextureChooser(_MTP, _Node);
 144                 _TextureWrapper.P = _EditedParticle;
 145                 _TextureChooser->setWrapper(&_TextureWrapper);
 146                 _TextureChooser->init(0, 30, this);
 147                 m_ChooseTextures.EnableWindow(FALSE);
 148
 149                 if (_MTP)
 150                 {
 151
 152                         ((CButton *) GetDlgItem(IDC_MULTITEX))->SetCheck(0);
 153                         GetDlgItem(IDC_EDIT_MULTITEX)->EnableWindow(0);
 154                         GetDlgItem(IDC_MULTITEX)->EnableWindow(0);
 155                 }
 156         }
 157
 158         UpdateData(FALSE);
 159 }
 160
 161
 162
 163
 164 void CTextureAnimDlg::DoDataExchange(CDataExchange* pDX)
 165 {
 166         CDialog::DoDataExchange(pDX);
 167         //{{AFX_DATA_MAP(CTextureAnimDlg)
 168         DDX_Control(pDX, IDC_CHOOSE_TEXTURES, m_ChooseTextures);
 169         DDX_Check(pDX, IDC_ENABLE_TEXTURE_ANIM, m_EnableTextureAnim);
 170         DDX_Check(pDX, IDC_MULTITEX, m_MultiTexEnable);
 171         //}}AFX_DATA_MAP
 172 }
 173
 174
 175 BEGIN_MESSAGE_MAP(CTextureAnimDlg, CDialog)
 176         //{{AFX_MSG_MAP(CTextureAnimDlg)
 177         ON_BN_CLICKED(IDC_CHOOSE_TEXTURES, OnChooseTextures)
 178         ON_BN_CLICKED(IDC_ENABLE_TEXTURE_ANIM, OnEnableTextureAnim)
 179         ON_BN_CLICKED(IDC_MULTITEX, OnMultiTex)
 180         ON_BN_CLICKED(IDC_EDIT_MULTITEX, OnEditMultitex)
 181         //}}AFX_MSG_MAP
 182 END_MESSAGE_MAP()
 183
 184 /////////////////////////////////////////////////////////////////////////////
 185 // CTextureAnimDlg message handlers
 186
 187 void CTextureAnimDlg::OnChooseTextures()
 188 {
 189
 190         _GradientInterface.P = _EditedParticle;
 191         CValueGradientDlg vd(&_GradientInterface, _Node, false, this, NULL, false, 1);
 192         _GradientInterface.Dlg = &vd;
 193         vd.DoModal();
 194 }
 195
 196 void CTextureAnimDlg::OnEnableTextureAnim()
 197 {
 198         UpdateData();
 199         if (!m_EnableTextureAnim)
 200         {
 201                 _EditedParticle->setTexture(NULL);
 202         }
 203         else
 204         {
 205                 // put a dummy texture as a first texture
 206                 NLMISC::CSmartPtr<NL3D::ITexture> tex = (NL3D::ITexture *) new NL3D::CTextureFile(std::string(""));
 207                 NL3D::CTextureGrouped *tg = new NL3D::CTextureGrouped;
 208                 tg->setTextures(&tex, 1);
 209                 _EditedParticle->setTextureGroup(tg);
 210                 _EditedParticle->setTextureIndex(0);
 211         }
 212         cleanCtrl();
 213         setupCtrl();
 214         updateModifiedFlag();
 215 }
 216
 217
 218 ////////////////////////////////////////////////////////
 219 // CTextureAnimDlg::CGradientInterface implementation //
 220 ////////////////////////////////////////////////////////
 221
 222
 223
 224 CEditAttribDlg *CTextureAnimDlg::CGradientInterface::createDialog(uint index, CValueGradientDlg *grad, CParticleWorkspace::CNode *ownerNode)
 225 {
 226         CTextureChooser *tc = new CTextureChooser(NULL, ownerNode);
 227         _TextureWrapper.P = P;
 228         _TextureWrapper.Dlg = Dlg;
 229         _TextureWrapper.Index = index;
 230         _TextureWrapper.OwnerNode = ownerNode;
 231         tc->setWrapper(&_TextureWrapper);
 232         return tc;
 233 }
 234 void CTextureAnimDlg::CGradientInterface::modifyGradient(TAction action, uint index)
 235 {
 236         nlassert(P);
 237         nlassert(P->getTextureGroup());
 238         std::vector< NLMISC::CSmartPtr<NL3D::ITexture> > textureList;
 239         textureList.resize(P->getTextureGroup()->getNbTextures());
 240         P->getTextureGroup()->getTextures(&textureList[0]);
 241
 242         switch(action)
 243         {
 244                 case IValueGradientDlgClient::Add:
 245                 {
 246                         // we duplicate the last texture, so that they have the same size
 247                         NLMISC::CSmartPtr<NL3D::ITexture> lastTex = textureList[textureList.size() - 1];
 248                         textureList.push_back(lastTex);
 249                 }
 250                 break;
 251                 case IValueGradientDlgClient::Insert:
 252                 {
 253                         // we duplicate the current texture, so that they have the same size
 254                         NLMISC::CSmartPtr<NL3D::ITexture> tex = textureList[index];
 255                         textureList.insert(textureList.begin() + index, tex);
 256                 }
 257                 break;
 258                 case IValueGradientDlgClient::Delete:
 259                         textureList.erase(textureList.begin() + index);
 260                 break;
 261         }
 262
 263         P->getTextureGroup()->setTextures(&textureList[0], (uint)textureList.size());
 264 }
 265 void CTextureAnimDlg::CGradientInterface::displayValue(CDC *dc, uint index, sint x, sint y)
 266 {
 267         const uint tSize = 20;
 268         NLMISC::CSmartPtr<NL3D::ITexture> tex = P->getTextureGroup()->getTexture(index);
 269         tex->generate();
 270
 271         // make copy of the texture
 272         NLMISC::CBitmap cb(* ((NL3D::ITexture *) tex));
 273
 274         cb.convertToType(NLMISC::CBitmap::RGBA);
 275         cb.resample(tSize, tSize);
 276
 277
 278         uint32 *dat  = (uint32 *) &(cb.getPixels()[0]);
 279
 280         HBITMAP myBitmap = ::CreateBitmap(tSize, tSize, 1, 32, dat);
 281
 282         HDC bitmapDc = ::CreateCompatibleDC(dc->m_hDC);
 283         HGDIOBJ old = ::SelectObject(bitmapDc, myBitmap);
 284
 285         // display the texture
 286         ::BitBlt(dc->m_hDC, x + 20, y + 10, tSize, tSize, bitmapDc, 0, 0, SRCCOPY);
 287
 288         // free resources
 289         ::SelectObject(bitmapDc, old);
 290         ::DeleteDC(bitmapDc);
 291         ::DeleteObject(myBitmap);
 292
 293 }
 294 uint32 CTextureAnimDlg::CGradientInterface::getSchemeSize(void) const
 295 {
 296         nlassert(P->getTextureGroup());
 297         return P->getTextureGroup()->getNbTextures();
 298 }
 299 uint32 CTextureAnimDlg::CGradientInterface::getNbSteps(void) const
 300 {
 301         return 1;
 302 }
 303 void CTextureAnimDlg::CGradientInterface::setNbSteps(uint32 value)
 304 {
 305         // this should never be called, as we don't allow nbsteps to be called
 306         nlassert(false);
 307 }
 308
 309
 310 ///////////////////////////////////////////////////////////////////////////
 311 // CTextureAnimDlg::CGradientInterface::CTextureWrapper implementation //
 312 ///////////////////////////////////////////////////////////////////////////
 313
 314
 315 NL3D::ITexture *CTextureAnimDlg::CGradientInterface::CTextureWrapper::get(void)
 316 {
 317         nlassert(P);
 318         nlassert(P->getTextureGroup());
 319         return P->getTextureGroup()->getTexture(Index);
 320 }
 321 void CTextureAnimDlg::CGradientInterface::CTextureWrapper::set(NL3D::ITexture *t)
 322 {
 323         nlassert(P);
 324         nlassert(P->getTextureGroup());
 325
 326         // if a texture is added, it must have the same size than other textures
 327         if (P->getTextureGroup()->getNbTextures() > 1)
 328         {
 329                 NLMISC::CSmartPtr<NL3D::ITexture> tex = P->getTextureGroup()->getTexture(0);
 330                 tex->generate();
 331                 t->generate();
 332
 333                 if (t->getWidth() != tex->getWidth() || t->getHeight() != tex->getHeight())
 334                 {
 335                         ::MessageBox(NULL, _T("All textures must have the same size !"), _T("error"), MB_OK);
 336                         return;
 337                 }
 338
 339                 if (t->PixelFormat != tex->PixelFormat)
 340                 {
 341                         ::MessageBox(NULL, _T("All textures must have the same pixel format !"), _T("error"), MB_OK);
 342                         return;
 343                 }
 344         }
 345
 346         std::vector< NLMISC::CSmartPtr<NL3D::ITexture> > textureList;
 347         textureList.resize(P->getTextureGroup()->getNbTextures());
 348         P->getTextureGroup()->getTextures(&textureList[0]);
 349
 350         textureList[Index] = t;
 351
 352
 353         P->getTextureGroup()->setTextures(&textureList[0], (uint)textureList.size());
 354
 355         Dlg->invalidateGrad();
 356 }
 357
 358 void CTextureAnimDlg::OnMultiTex()
 359 {
 360         UpdateData();
 361         _MTP->enableMultiTexture(m_MultiTexEnable ? true : false /* VC WARNING */);
 362         setupCtrl();
 363         updateModifiedFlag();
 364 }
 365
 366 void CTextureAnimDlg::childPopupClosed(CWnd *child)
 367 {
 368         nlassert(_MultiTexDlg == child);
 369         _MultiTexDlg->DestroyWindow();
 370         delete _MultiTexDlg;
 371         _MultiTexDlg = NULL;
 372         EnableWindow(TRUE);
 373 }
 374
 375 void CTextureAnimDlg::OnEditMultitex()
 376 {
 377         EnableWindow(FALSE);
 378         _MultiTexDlg = new      CMultiTexDlg(_Node, _MTP, this, this);
 379         _MultiTexDlg->init(this);
 380 }