例えば画像ならこんな感じで
これは相当省略してるけど、こういう風にラップして利便性を図ったりDXLib臭を消したりすることが目的のトピでござる。
DXLibをラップするトピ
フォーラム(掲示板)ルール
ゆっくりつかってね!!!
ゆっくりつかってね!!!
Re: DXLibをラップするトピ
以前作ったXtalラッパー。
3DのモデルデータなどもRGSS風に扱うことができる。
3Dのモデルデータなども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);
}
Re: DXLibをラップするトピ
スマートポインタを使ってラッピングする例です。
のようにロード関数を書いておいて
のように書けば自動的に使われなくなったらDeleteGraphが呼ばれるのでメモリを気にする必要はありません。
[hr]
#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); //画像の描画
[hr]
- inline キーワードを追加(2011/11/29)。
- DrawGraphの使用を扱いやすくするため ImagePtr を渡すように変更(2011/11/30)。
- std::stringもしくは std::wstring を使うように変更(2012/5/25)。