cobj.h

Go to the documentation of this file.

 
#pragma once
#include <b8/type.h>
#include <b8/assert.h>
#include <b8/ppu.h>
#include <b8/misc.h>
#include <handle.h>
#include <vector>
 
typedef unsigned long HObj;
class CObj{
  friend  void  CObjHolder_Step( b8PpuCmd* cmd_ );
 
  // id
  private:  u32 _id_cobj;
  public:   u32 GetId() const {
    return  _id_cobj;
  }
 
  // step
  private:  u32 _cnt_step_called = 0;
  private:  virtual void  vOnStep() = 0;
  private:   void  Step();
 
  // touch
  private:  virtual void  vOnTouch(){}
  private:  void  Touch();
 
  // draw
  private:  virtual void  vOnDraw( b8PpuCmd* cmd_ ){
    UNUSED(cmd_);
  }
  private:  void  Draw( b8PpuCmd* cmd_ );
 
  // handle
  private:  HObj  _hObj = HANDLE_NULL;
  public:   HObj  GetHandle() const {
    return _hObj;
  }
 
  public: void  SetHandle( HObj hObj_ ){
    _hObj = hObj_;
  }
 
  // priority
  private:  u32  _priority = 0;
  public:   void  SetPriority( u32 priority_ ){
    _priority = priority_;
  }
  public:   u32   GetPriority() const {
    return  _priority;
  }
 
  // kill
  private:    bool _req_kill = false;
  public:     void  ReqKill(){
    _req_kill = true;
  }
  public:     bool  IsReqKill() const {
    return _req_kill;
  }
 
  // type of
  private:    u32 _type_id = 0x00000000;
  protected:  void  SetTypeId( u32 type_id_ ){
    _type_id = type_id_;
  }
  public:     u32  GetTypeId(){
    return  _type_id;
  }
  public:     bool IsTypeOf( u32 type_id_ ){
    return _type_id == type_id_ ? true : false;
  }
 
  public:
    CObj();
    virtual ~CObj();
};
 
extern  void  CObjHolder_Reset();
extern  HObj  CObjHolder_Entry( CObj* obj , u32 priority );
extern  void  CObjHolder_Remove( HObj hObj );
extern  void  CObjHolder_Enum( std::vector< HObj >& dest_ , u32 prio_ , u32 type_id_ );
extern  void  CObjHolder_Step( b8PpuCmd* cmd_ );
extern  void  CObjHolder_Pause( s32 cnt_pause_ );
extern  CObj* cobj( HObj hObj );
template <class T>
class Handle {
  HObj  _h = HANDLE_NULL;
  T*    _p = nullptr;
 
  void  _DynamicCast(){
    _p = dynamic_cast< T* >( cobj( _h ) );
    _ASSERT( _p , "failed dynamic_cast" );
  }
 
public:
  inline    T* operator -> (){
    if( nullptr == _p ){
      _ASSERT( 0 , "failed dynamic_cast" );
    }
    return _p;
  }
 
  Handle<T> operator = ( HObj h_ ){
    _h = h_;
    _DynamicCast();
    return *this;
  }
 
  Handle<T> operator = ( Handle<T> x_ ){
    _h = x_._h;
    _DynamicCast();
    return *this;
  }
 
  Handle( HObj hObj_ )
  {
    _h = hObj_;
    _DynamicCast();
  }
 
  Handle(){}
};