DXLibをラップするトピ

[しょこらふれっくす]

例えば画像ならこんな感じで
これは相当省略してるけど、こういう風にラップして利便性を図ったりDXLib臭を消したりすることが目的のトピでござる。

コード:

class Image
{
int m_Handle;
public:
	Image()
	{
		m_Handle = 0;
	}
	~Image()
	{
		DeleteGraph( m_Handle );
	}
	void Load( const char* filename )
	{
		m_Handle = LoadGraph( filename );
	}
	void Draw( int x , int y , bool trans = true )
	{
		DrawGraph( x , y , m_handle , trans );
	}
};

[h2so5]

以前作ったXtalラッパー。

３DのモデルデータなどもRGSS風に扱うことができる。

コード:

#include <vector>

#include "DxLib.h"
#include "xtal.h"
#include "xtal_bind.h"
#include "xtal_macro.h"
#include "xdxlib.h"
#include "zoofile.h"
#include "xdxerror.h"

using namespace xtal; 

	class xModel;

	typedef SmartPtr<xModel> ModelPtr;

	AnyPtr c2x_mtx(DxLib::MATRIX mtx);
	AnyPtr c2x_vec(DxLib::VECTOR vec);
	AnyPtr c2x_col_f(DxLib::COLOR_F col);

	int trow_exp( const TCHAR *Message ){
		XTAL_SET_EXCEPT(Message);
		return 0;
	}

	AnyPtr c2x(DxLib::MATRIX mtx){return c2x_mtx(mtx);};
	AnyPtr c2x(DxLib::VECTOR vec){return c2x_vec(vec);};
	AnyPtr c2x(DxLib::COLOR_F col){return c2x_col_f(col);};


	//Modelクラス
	class xModel{
	private:
		int address;

	public:
		int lighting;

		bool operator< (xModel & lhs){
			return (semitrans() < lhs.semitrans());
		}


		//C++

		xModel(const TCHAR* filename){
			address = DxLib::MV1LoadModel(filename);
			if(address == -1)
				throw xdxEroor(DXLIB,"Loading Model Failed.");
			lighting = 1;
		}

		~xModel(){
			dispose();
		}

		int dispose(){
			return DxLib::MV1DeleteModel(address);
		}

		int draw(){
			return DxLib::MV1DrawModel(address);
		}

		int set_pos(DxLib::VECTOR vec){
			return DxLib::MV1SetPosition(address,vec);
		}

		DxLib::VECTOR pos(){
			return DxLib::MV1GetPosition(address);
		}

		int set_scl(DxLib::VECTOR vec){
			return DxLib::MV1SetScale(address,vec);
		}

		DxLib::VECTOR scl(){
			return DxLib::MV1GetScale(address);
		}

		int set_rot(DxLib::VECTOR vec){
			return DxLib::MV1SetRotationXYZ(address,vec);
		}

		DxLib::VECTOR rot(){
			return DxLib::MV1GetRotationXYZ(address);
		}

		int set_visible(int flag){
			return DxLib::MV1SetVisible(address,flag);
		}

		int visible(){
			return DxLib::MV1GetVisible(address);
		}

		int set_mtx(DxLib::MATRIX mtx){
			return DxLib::MV1SetMatrix(address,mtx);
		}

		DxLib::MATRIX mtx(){
			return DxLib::MV1GetMatrix(address);
		}

		int set_opacity(float opa){
			return DxLib::MV1SetOpacityRate(address,opa);
		}

		float opacity(){
			return DxLib::MV1GetOpacityRate(address);
		}

		int semitrans(){
			return DxLib::MV1GetSemiTransState(address);
		}
		
		
		//Xtal

		xModel(const AnyPtr& filename,const AnyPtr& zoo){
			if (zoo == null){
				address = DxLib::MV1LoadModel(filename->to_s()->c_str());
			}else{
				address = unchecked_ptr_cast<zoofile>(zoo)->LoadModel(filename->to_s()->c_str());
			}
			if(address == -1)
				trow_exp("Loading Model Failed.");
			lighting = 1;
		}


		int Xdispose(){
			return DxLib::MV1DeleteModel(address);
		}

		AnyPtr Xdraw(){
			return DxLib::MV1DrawModel(address);
		}

		AnyPtr Xset_pos(AnyPtr& vec){
			return xdx::MV1SetPosition(address,vec);
		}

		AnyPtr Xpos(){
			return xdx::MV1GetPosition(address);
		}

		AnyPtr Xset_scl(AnyPtr& vec){
			return xdx::MV1SetScale(address,vec);
		}

		AnyPtr Xscl(){
			return xdx::MV1GetScale(address);
		}

		AnyPtr Xset_rot(AnyPtr& vec){
			return xdx::MV1SetRotationXYZ(address,vec);
		}

		AnyPtr Xrot(){
			return xdx::MV1GetRotationXYZ(address);
		}

		AnyPtr Xset_visible(AnyPtr& flag){
			return xdx::MV1SetVisible(address,flag);
		}

		AnyPtr Xvisible(){
			return xdx::MV1GetVisible(address);
		}

		AnyPtr Xset_mtx(AnyPtr& mtx){
			return xdx::MV1SetMatrix(address,mtx);
		}

		AnyPtr Xmtx(){
			return xdx::MV1GetMatrix(address);
		}

		AnyPtr Xset_opacity(AnyPtr opa){
			return xdx::MV1SetOpacityRate(address,opa);
		}

		AnyPtr Xopacity(){
			return xdx::MV1GetOpacityRate(address);
		}

		AnyPtr Xsemitrans(){
			return xdx::MV1GetSemiTransState(address);
		}

	};

	XTAL_PREBIND(xModel){
		it->def_ctor2<xModel, AnyPtr&, AnyPtr&>()->param(2, Xid(zoo), null);
	}

	XTAL_BIND(xModel){
		it->def_var(Xid(lighting), &xModel::lighting);
		it->def_method(Xid(dispose), &xModel::Xdispose);
		it->def_method(Xid(draw), &xModel::Xdraw);
		it->def_method(Xid(set_pos), &xModel::Xset_pos);
		it->def_method(Xid(pos), &xModel::Xpos);
		it->def_method(Xid(set_scl), &xModel::Xset_scl);
		it->def_method(Xid(scl), &xModel::Xscl);
		it->def_method(Xid(set_rot), &xModel::Xset_rot);
		it->def_method(Xid(rot), &xModel::Xrot);
		it->def_method(Xid(set_visible), &xModel::Xset_visible);
		it->def_method(Xid(visible), &xModel::Xvisible);
		it->def_method(Xid(set_mtx), &xModel::Xset_mtx);
		it->def_method(Xid(mtx), &xModel::Xmtx);
		it->def_method(Xid(set_opacity), &xModel::Xset_opacity);
		it->def_method(Xid(opacity), &xModel::Xopacity);
		it->def_method(Xid(semitrans), &xModel::Xsemitrans);
	}

	//cameraクラス

	class Camera{

	private:

		Camera(){}
		Camera(const Camera& rhs);
		Camera& operator=(const Camera& rhs);


	public:

		static Camera* GetInstance()
		{
    		static Camera instance;
    		return &instance;
		}


		//C++

		int set_near(float f){
			return DxLib::SetCameraNearFar(f,cfar());
		}

		float cnear(){
			return DxLib::GetCameraNear();
		}

		int set_far(float f){
			return DxLib::SetCameraNearFar(cnear(),f);
		}

		float cfar(){
			return DxLib::GetCameraFar();
		}

		int set_pos(DxLib::VECTOR vec){
			return DxLib::SetCameraPositionAndTarget_UpVecY(vec,target());
		}

		DxLib::VECTOR pos(){
			return DxLib::GetCameraPosition();
		}

		int set_target(DxLib::VECTOR vec){
			return DxLib::SetCameraPositionAndTarget_UpVecY(pos(),vec);
		}

		DxLib::VECTOR target(){
			return DxLib::GetCameraTarget();
		}

		int set_upvector(DxLib::VECTOR vec){
			return DxLib::SetCameraPositionAndTargetAndUpVec(pos(),target(),vec);
		}

		DxLib::VECTOR upvector(){
			return DxLib::GetCameraUpVector();
		}
	};

			//Camera* cd = Camera::GetInstance();
			//cd->pos();
	

	//cameraクラス(singleton)
	class xCamera{
	private:

	public:

		//Xtal

		AnyPtr Xset_near(AnyPtr& f){
			return xdx::SetCameraNearFar(f,Xcfar());
		}

		AnyPtr Xcnear(){
			return xdx::GetCameraNear();
		}

		AnyPtr Xset_far(AnyPtr& f){
			return xdx::SetCameraNearFar(Xcnear(),f);
		}

		AnyPtr Xcfar(){
			return xdx::GetCameraFar();
		}

		AnyPtr Xset_pos(AnyPtr& vec){
			return xdx::SetCameraPositionAndTarget_UpVecY(vec,Xtarget());
		}

		AnyPtr Xpos(){
			return xdx::GetCameraPosition();
		}

		AnyPtr Xset_target(AnyPtr& vec){
			return xdx::SetCameraPositionAndTarget_UpVecY(Xpos(),vec);
		}

		AnyPtr Xtarget(){
			return xdx::GetCameraTarget();
		}

		AnyPtr Xset_upvector(AnyPtr& vec){
			return xdx::SetCameraPositionAndTargetAndUpVec(Xpos(),Xtarget(),vec);
		}

		AnyPtr Xupvector(){
			return xdx::GetCameraUpVector();
		}


	};

	XTAL_PREBIND(xCamera){
		Xsingleton();
	}

	XTAL_BIND(xCamera){
		it->def_method(Xid(set_near), &xCamera::Xset_near);
		it->def_method(Xid(near), &xCamera::Xcnear);
		it->def_method(Xid(set_far), &xCamera::Xset_far);
		it->def_method(Xid(far), &xCamera::Xcfar);
		it->def_method(Xid(set_pos), &xCamera::Xset_pos);
		it->def_method(Xid(pos), &xCamera::Xpos);
		it->def_method(Xid(set_target), &xCamera::Xset_target);
		it->def_method(Xid(target), &xCamera::Xtarget);
		it->def_method(Xid(set_upvector), &xCamera::Xset_upvector);
		it->def_method(Xid(upvector), &xCamera::Xupvector);
	}

	bool comp(ModelPtr & a,ModelPtr & b){
		return a->semitrans() < b->semitrans();
	}

	//DrawListクラス
	class xDrawList{
	public:
		AnyPtr list;

		xDrawList(){
			list = xnew<Array>(0);
		}

		//C++


	public:


		int draw(){
			int size,i;

			std::vector<ModelPtr> mgdlist;

			size = list->to_a()->size();

			for(i = 0; i < size; i++){
				ModelPtr model = unchecked_ptr_cast<xModel>(list->to_a()->at(i));
				mgdlist.push_back(model);
			}
			

			std::vector<ModelPtr>::iterator mit = mgdlist.begin();

			std::sort(mgdlist.begin(),mgdlist.end(),comp);

			while( mit != mgdlist.end() )
			{

				ModelPtr model = mit->get();

				if(model->lighting == 0){
					DxLib::SetUseLighting(0);
				}else{
					DxLib::SetUseLighting(1);
				}

				model->draw();
				++mit;
			}


			return 0;
		}

		//Xtal

	public:
		AnyPtr Xdraw(){
			return draw();
		}
	};

	XTAL_PREBIND(xDrawList){
		it->def_ctor0<xDrawList>();
	}

	XTAL_BIND(xDrawList){
		it->def_var(Xid(list), &xDrawList::list);
		it->def_method(Xid(draw), &xDrawList::Xdraw);
	}

	//MATRIXのラップクラス
	class xMatrix{
		public:
		DxLib::MATRIX m;

		xMatrix(DxLib::MATRIX m)
		:m(m){}
	};

	XTAL_PREBIND(xMatrix){
		it->def_ctor1<xMatrix, DxLib::MATRIX>();
	}

	XTAL_BIND(xMatrix){

		it->def_var(Xid(m), &xMatrix::m);
	}

	//VECTOR のラップクラス

	class xVector{
		public:
		DxLib::VECTOR v;

		float x(){return v.x;}
		float y(){return v.y;}
		float z(){return v.z;}
		//void set_x(const AnyPtr& f){v.x = f->to_f();}
		//void set_y(const AnyPtr& f){v.y = f->to_f();}
		//void set_z(const AnyPtr& f){v.z = f->to_f();}

		xVector(DxLib::VECTOR v)
		:v(v){
		}
		

		xVector(float x,float y,float z){
			DxLib::VECTOR n = {x,y,z};
			v = n;
		}
	};

	XTAL_PREBIND(xVector){
		it->def_ctor3<xVector, float, float, float>();
	}
	XTAL_BIND(xVector){

		it->def_var(Xid(v), &xVector::v);
	   it->def_method(Xid(x), &xVector::x);
	   it->def_method(Xid(y), &xVector::y);
	   it->def_method(Xid(z), &xVector::z);
	}

	//COLOR_F のラップクラス

	class xColor_f{
		public:
		DxLib::COLOR_F c;

		xColor_f(DxLib::COLOR_F c)
		:c(c){}

		xColor_f(float r,float g,float b,float a){
			DxLib::COLOR_F n = {r,g,b,a};
			c = n;
		}
	};

	XTAL_PREBIND(xColor_f){
		it->def_ctor4<xColor_f, float, float, float, float>();
	}

	XTAL_BIND(xColor_f){

		it->def_var(Xid(c), &xColor_f::c);
	}

	//変換関数
	DxLib::MATRIX x2c_mtx(const AnyPtr& mtx){
		return ptr_cast<xMatrix>(mtx)->m;
	}

	AnyPtr c2x_mtx(DxLib::MATRIX mtx){
		return XNew<xMatrix>(mtx);
	}

	DxLib::VECTOR x2c_vec(const AnyPtr& vec){
		return ptr_cast<xVector>(vec)->v;
	}

	AnyPtr c2x_vec(DxLib::VECTOR vec){
		return XNew<xVector>(vec);
	}

	DxLib::COLOR_F x2c_col_f(const AnyPtr& col){
		return ptr_cast<xColor_f>(col)->c;
	}

	AnyPtr c2x_col_f(DxLib::COLOR_F col){
		return XNew<xColor_f>(col);
	}

[しょこらふれっくす]

Xtalってなんぞ？

[h2so5]

組み込みスクリプト言語です。
オブジェクト指向のLuaのような感じ。

http://code.google.com/p/xtal-language/

[naohiro19]

スマートポインタを使ってラッピングする例です。

コード:

#pragma once

#include <DxLib.h>
#include <string>
#include <boost/shared_ptr.hpp>
namespace std {
	typedef basic_string<TCHAR, char_traits<TCHAR>, allocator<TCHAR> > tstring;
}
class Handle {
protected:
	int handle;
public:
	Handle(){ this->handle = -1; }
	Handle(int handle){ this->handle = handle; }
	virtual ~Handle() {}
	void setHandle(int handle){ this->handle = handle; }
	int getHandle() const { return this->handle; }
	int operator*() { return this->handle; }
};

class Image : public Handle {
public:
    Image(int handle) : Handle(handle){};
    ~Image(){ DeleteGraph(handle); }
};

typedef boost::shared_ptr<Image> ImagePtr;

inline ImagePtr LoadGraphPtr(const std::tstring&  filename){
    return ImagePtr(new Image(DxLib::LoadGraph(filename.c_str() ) ) );
}
inline int DrawGraphPtr(int x, int y, ImagePtr mHandle, int TransFlag = TRUE ){
    return DxLib::DrawGraph(x, y, mHandle->getHandle(), TransFlag)
}

のようにロード関数を書いておいて

コード:

ImagePtr grHandle = LoadGraphPtr("画像/キャラクタ01.png"); //画像のロード
DrawGraphPtr(0,0,  grHandle,TRUE); //画像の描画

のように書けば自動的に使われなくなったらDeleteGraphが呼ばれるのでメモリを気にする必要はありません。
[hr]

• inline キーワードを追加(2011/11/29)。
• DrawGraphの使用を扱いやすくするため ImagePtr を渡すように変更(2011/11/30)。
• std::stringもしくは std::wstring を使うように変更(2012/5/25)。

[神御田]

DXライブラリのラップは実際GitHub上にラッパープロジェクトがありますよ

https://github.com/Nagarei/DxLibEx