History: PUDotNet

• «
• »

            PUDotNet.h
{CODE(wrap="1", colors="c++")}
#pragma once

#include <Ogre.h>
#include <ParticleUniverseSystem.h>
#include <ParticleUniverseSystemManager.h>

using namespace System;

namespace PUDotNet {

public ref class PUManager
{
    private:
      Mogre::SceneManager^ mScene;
      ParticleUniverse::ParticleSystemManager* mPUMgr;
      Collections::Generic::Dictionary<System::String^, IntPtr>^ mSystems;

    public:
      PUManager( Mogre::SceneManager^ _scene );
      !PUManager();
      ~PUManager();

      property bool IsDisposed { bool get(); }

      array<System::String^>^ GetTemplateNames();
      bool CreateParticleSystem( System::String^ _name, System::String^ _templateName );
      void DestroyParticleSystem( System::String^ _name );
      void AddToSceneNode( Mogre::SceneNode^ _node, System::String^ _name );
      void RemoveFromSceneNode( Mogre::SceneNode^ _node, System::String^ _name );
      void Start( System::String^ _name );
      void Stop( System::String^ _name );
      void Pause( System::String^ _name );
      void Resume( System::String^ _name );

    private:
      ParticleUniverse::ParticleSystem* GetByName( System::String^ _name );
};

}
{CODE}
PUDotNet.cpp
{CODE(wrap="1", colors="c++")}
#include "stdafx.h"

#include "PUDotNet.h"

namespace PUDotNet {

  PUManager::PUManager( Mogre::SceneManager^ _scene )
  {
    if( _scene == nullptr )
      throw gcnew System::ArgumentNullException( "_scene" );

    mScene = _scene;
    mPUMgr = ParticleUniverse::ParticleSystemManager::getSingletonPtr();
    mSystems = gcnew Collections::Generic::Dictionary<System::String^, IntPtr>();
  }

  PUManager::!PUManager()
  {
    if( mSystems != nullptr )
    {
      Collections::Generic::Dictionary<System::String^, IntPtr>::Enumerator it;
      it = mSystems->GetEnumerator();

      array<System::String^>^ names = gcnew array<System::String^>( mSystems->Keys->Count );
      int pos = 0;
      while( it.MoveNext() )
        names[ pos++ ] = it.Current.Key;

      for( int i = 0; i < names->Length; ++i )
        DestroyParticleSystem( names[i] );

      mSystems->Clear();
    }

    mSystems = nullptr;
    mPUMgr = NULL;
    mScene = nullptr;
  }

  PUManager::~PUManager()
  {
    this->!PUManager();
  }

  bool PUManager::IsDisposed::get()
  {
    return ( mPUMgr == NULL );
  }

  array<System::String^>^ PUManager::GetTemplateNames()
  {
    if( IsDisposed )
      throw gcnew System::ObjectDisposedException( "PUManager" );

    std::vector<Ogre::String> tNames;
    mPUMgr->particleSystemTemplateNames( tNames );

    array<System::String^>^ names = gcnew array<System::String^>( tNames.size() );

    std::vector<Ogre::String>::iterator it;
    int i = 0;
    for ( it = tNames.begin(); it != tNames.end(); ++it, ++i )
    {
      Ogre::String name = *it;
      names[ i ] = TO_CLR_STRING( name );
    }

    return names;
  }

  bool PUManager::CreateParticleSystem( System::String^ _name, System::String^ _templateName )
  {
    if( IsDisposed )
      throw gcnew System::ObjectDisposedException( "PUManager" );
    if( _name == nullptr )
      throw gcnew System::ArgumentNullException( "_name" );
    if( _templateName == nullptr )
      throw gcnew System::ArgumentNullException( "_templateName" );

    ParticleUniverse::ParticleSystem* psys;

    DECLARE_OGRE_STRING( name, _name )
    DECLARE_OGRE_STRING( templateName, _templateName )

    psys = mPUMgr->createParticleSystem( name, templateName, mScene );
    if( psys == NULL )
      return false;

    IntPtr psysPtr = IntPtr( psys );
    mSystems->Add( _name, psysPtr );

    return true;
  }

  void PUManager::DestroyParticleSystem( System::String^ _name )
  {
    if( IsDisposed )
      throw gcnew System::ObjectDisposedException( "PUManager" );
    if( _name == nullptr )
      throw gcnew System::ArgumentNullException( "_name" );

    ParticleUniverse::ParticleSystem* psys;
    psys = GetByName( _name );
    if( psys == NULL )
      return;
    mSystems->Remove( _name );

    Ogre::SceneNode* node = psys->getParentSceneNode();
    if( node != NULL )
      node->detachObject( psys );

    mPUMgr->destroyParticleSystem( psys, mScene );
  }

  void PUManager::AddToSceneNode( Mogre::SceneNode^ _node, System::String^ _name )
  {
    if( IsDisposed )
      throw gcnew System::ObjectDisposedException( "PUManager" );
    if( _node == nullptr )
      throw gcnew System::ArgumentNullException( "_node" );
    if( _name == nullptr )
      throw gcnew System::ArgumentNullException( "_name" );

    ParticleUniverse::ParticleSystem* psys;
    psys = GetByName( _name );
    if( psys == NULL )
      return;

    Ogre::SceneNode* node = (Ogre::SceneNode*) _node->NativePtr;
    if( node == NULL )
      return;

    node->attachObject( psys );
  }

  void PUManager::RemoveFromSceneNode( Mogre::SceneNode^ _node, System::String^ _name )
  {
    if( IsDisposed )
      throw gcnew System::ObjectDisposedException( "PUManager" );
    if( _node == nullptr )
      throw gcnew System::ArgumentNullException( "_node" );
    if( _name == nullptr )
      throw gcnew System::ArgumentNullException( "_name" );

    ParticleUniverse::ParticleSystem* psys;
    psys = GetByName( _name );
    if( psys == NULL )
      return;

    Ogre::SceneNode* node = (Ogre::SceneNode*) _node->NativePtr;
    if( node == NULL )
      return;

    node->detachObject( psys );
  }

  void PUManager::Start( System::String^ _name )
  {
    if( IsDisposed )
      throw gcnew System::ObjectDisposedException( "PUManager" );
    if( _name == nullptr )
      throw gcnew System::ArgumentNullException( "_name" );

    ParticleUniverse::ParticleSystem* psys;
    psys = GetByName( _name );
    if( psys == NULL )
      return;

    psys->start();
  }

  void PUManager::Stop( System::String^ _name )
  {
    if( IsDisposed )
      throw gcnew System::ObjectDisposedException( "PUManager" );
    if( _name == nullptr )
      throw gcnew System::ArgumentNullException( "_name" );

    ParticleUniverse::ParticleSystem* psys;
    psys = GetByName( _name );
    if( psys == NULL )
      return;

    psys->stop();
  }

  void PUManager::Pause( System::String^ _name )
  {
    if( IsDisposed )
      throw gcnew System::ObjectDisposedException( "PUManager" );
    if( _name == nullptr )
      throw gcnew System::ArgumentNullException( "_name" );

    ParticleUniverse::ParticleSystem* psys;
    psys = GetByName( _name );
    if( psys == NULL )
      return;

    psys->pause();
  }

  void PUManager::Resume( System::String^ _name )
  {
    if( IsDisposed )
      throw gcnew System::ObjectDisposedException( "PUManager" );
    if( _name == nullptr )
      throw gcnew System::ArgumentNullException( "_name" );

    ParticleUniverse::ParticleSystem* psys;
    psys = GetByName( _name );
    if( psys == NULL )
      return;

    psys->resume();
  }

  ParticleUniverse::ParticleSystem* PUManager::GetByName( System::String^ _name )
  {
    IntPtr sys;
    if( !mSystems->TryGetValue( _name, sys ) )
      return NULL;

    ParticleUniverse::ParticleSystem* psys = (ParticleUniverse::ParticleSystem*) sys.ToPointer();
    return psys;
  }

}
{CODE}