nel/tools/3d/object_viewer/dup_ps.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
  20 #include "nel/3d/ps_located.h"
  21 #include "nel/3d/particle_system.h"
  22
  23
  24 #include "nel/misc/stream.h"
  25 #include "nel/misc/mem_stream.h"
  26
  27 #include "dup_ps.h"
  28
  29 #include <memory>
  30
  31 using namespace NL3D;
  32
  33 //=======================================================================
  34
  35
  36
  37 /** This can duplicate any serializable type by using a serialization policy (polymorphic, non polymorphic ..)
  38   * The serialization policy must have a method to serial a pointer on the object (see example below)
  39   * NB : of course this is slow (but convenient) way of performing a copy
  40   * TODO maybe this could be used elsewhere ?
  41   */
  42 template <class TSerializePolicy, typename T>
  43 static T        *DupSerializable(const T *in)
  44 {
  45         NLMISC::CMemStream ms;
  46         nlassert(!ms.isReading());
  47         T *nonConstIn = const_cast<T *>(in);
  48         TSerializePolicy::serial(nonConstIn, ms);
  49         std::vector<uint8> datas(ms.length());
  50         std::copy(ms.buffer(), ms.buffer() + ms.length(), datas.begin());
  51         ms.resetPtrTable();
  52         ms.invert();
  53         ms.fill(&datas[0], (uint32)datas.size());
  54         nlassert(ms.isReading());
  55         T *newObj = NULL;
  56         TSerializePolicy::serial(newObj, ms);
  57         return newObj;
  58 }
  59
  60 /** A policy to duplicate a non-polymorphic type
  61   */
  62 struct CDupObjPolicy
  63 {
  64         template <typename T>
  65         static void serial(T *&obj, NLMISC::IStream &dest)
  66         {
  67                 dest.serialPtr(obj);
  68                 /*if (dest.isReading())
  69                 {
  70                         CUniquePtr<T> newObj(new T);
  71                         newObj->serialPtr(dest);
  72                         delete obj;
  73                         obj = newObj.release();
  74                 }
  75                 else
  76                 {
  77                         obj->serial(dest);
  78                 }*/
  79         }
  80 };
  81
  82 /** A policy to duplicate a polymorphic type
  83   */
  84 struct CDupPolymorphicObjPolicy
  85 {
  86         template <typename T>
  87         static void serial(T *&obj, NLMISC::IStream &dest)
  88         {
  89                 dest.serialPolyPtr(obj);
  90         }
  91 };
  92
  93
  94
  95 //=======================================================================
  96 /////////////////////////////////////////
  97 // temp until there is a clone method  //
  98 /////////////////////////////////////////
  99 NL3D::CParticleSystemProcess    *DupPSLocated(const CParticleSystemProcess *in)
 100 {
 101         if (!in) return NULL;
 102         try
 103         {
 104                 // if the located doesn't belon to a system, copy it direclty
 105                 if (in->getOwner() == NULL)
 106                 {
 107                         return DupSerializable<CDupPolymorphicObjPolicy>(in);
 108                 }
 109                 else
 110                 {
 111                         uint index = in->getOwner()->getIndexOf(*in);
 112                         /** Duplicate the system, and detach.
 113                           * We can't duplicate the object direclty (it may be referencing other objects in the system, so these objects will be copied too...)
 114                           */
 115                          CUniquePtr<CParticleSystem> newPS(DupSerializable<CDupObjPolicy>(in->getOwner()));
 116                          // scene pointer is not serialised, but 'detach' may need the scene to be specified
 117                          newPS->setScene(in->getOwner()->getScene());
 118                         return newPS->detach(index);
 119                 }
 120         }
 121         catch (const NLMISC::EStream &e)
 122         {
 123                 nlwarning (e.what());
 124                 return NULL;
 125         }
 126 }
 127
 128 //=======================================================================
 129 /////////////////////////////////////////
 130 // temp until there is a clone method  //
 131 /////////////////////////////////////////
 132 NL3D::CPSLocatedBindable        *DupPSLocatedBindable(CPSLocatedBindable *in)
 133 {
 134         if (!in) return NULL;
 135         try
 136         {
 137                 // if no owner, can copy the object directy
 138                 if (in->getOwner() == NULL)
 139                 {
 140                         return DupSerializable<CDupPolymorphicObjPolicy>(in);
 141                 }
 142                 else
 143                 {
 144                         CParticleSystem *srcPS = in->getOwner()->getOwner();
 145                         CUniquePtr<CParticleSystem> newPS(DupSerializable<CDupObjPolicy>(srcPS));
 146                         // scene pointer is not serialised, but 'detach' may need the scene to be specified
 147                         newPS->setScene(in->getOwner()->getOwner()->getScene());
 148                         //
 149                         uint index        = srcPS->getIndexOf(*(in->getOwner()));
 150                         uint subIndex = in->getOwner()->getIndexOf(in);
 151                         //
 152                         newPS->setScene(in->getOwner()->getScene()); // 'unbind' require the scene to be attached
 153                         CPSLocated *loc = NLMISC::safe_cast<CPSLocated *>(newPS->getProcess(index));
 154                         return loc->unbind(subIndex);
 155                 }
 156         }
 157         catch (const NLMISC::EStream &e)
 158         {
 159                 nlwarning (e.what());
 160                 return NULL;
 161         }
 162 }