DirectXLib

#pragma once

struct Color3{

unsigned char red;

unsigned char green;

unsigned char blue;

};

struct iRectSt{

int left;

int top;

int right;

int bottom;

};

struct IRectSt{

int textureno;

int left;

int top;

int right;

int bottom;

};

struct IwRectSt{

int w; //０：１ライン

int left;

int top;

int right;

int bottom;

};

struct IlRectSt{

int line; //－１０:手前,０:中,１０:奥,１００:なし

int left;

int top;

int right;

int bottom;

};

//描画用の矩形

struct DrawSt{

IRectSt *p_srcrect; //描画元ポインタ

IlRectSt destrect; //描画先

};

//２次元座標

struct Positionif2DSt{

int ix;

float fy;

};

//攻撃リスト

struct AttackListSt{

IlRectSt lrect[3]; //矩形+ライン

int ATK; //攻撃力

int ATKAGI; //命中

int ATKMGC; //魔法攻撃

int *phit_flg; //当たりフラグポインタ

int propty; //属性

int state_kind; //状態攻撃の種類

int state_number; //状態攻撃の強さ

int fly; //浮き

int move; //吹っ飛び

int hard; //硬直

int down; //ダウン

int cred_x; //発動した座標（吹っ飛び方向に使う）

bool P_or_E;

};

//ダメージ描画リスト

struct DrawDamageListSt{

int damage;//ダメージ

int x;//横位置

int y;//縦位置

int cntframe;//描画時間のカウント

};

void SetCol3(Color3 *color3,unsigned char red,unsigned char green,unsigned char blue);

//描画登録用

void SetSrcImageInfo(IRectSt &ImageInfo,int left,int top,int right,int bottom);

void SetSrcImageInfo(IRectSt &ImageInfo,int textureno,int left,int top,int right,int bottom);

void SetDestImageInfo(DrawSt &SetImage,int left,int top,int right,int bottom);

void SetDestImageInfo(DrawSt &SetImage,int line,int left,int top,int right,int bottom);

#include "UtilStruct.h"

void SetCol3(Color3 *color3,unsigned char red,unsigned char green,unsigned char blue)

{

color3->red = red;

color3->green = green;

color3->blue = blue;

}

void SetSrcImageInfo(IRectSt &ImageInfo,int left,int top,int right,int bottom)

{

ImageInfo.left = left;

ImageInfo.top = top;

ImageInfo.right = right;

ImageInfo.bottom = bottom;

}

void SetSrcImageInfo(IRectSt &ImageInfo,int textureno,int left,int top,int right,int bottom)

{

ImageInfo.textureno = textureno;

ImageInfo.left = left;

ImageInfo.top = top;

ImageInfo.right = right;

ImageInfo.bottom = bottom;

}

void SetDestImageInfo(DrawSt &SetImage,int left,int top,int right,int bottom)

{

SetImage.destrect.left = left;

SetImage.destrect.top = top;

SetImage.destrect.right = right;

SetImage.destrect.bottom = bottom;

SetImage.destrect.line = 0;

}

void SetDestImageInfo(DrawSt &SetImage,int line,int left,int top,int right,int bottom)

{

SetImage.destrect.left = left;

SetImage.destrect.top = top;

SetImage.destrect.right = right;

SetImage.destrect.bottom = bottom;

SetImage.destrect.line = line;

}

#pragma once

#include <d3d9.h>

#include <d3dx9.h>

//#include <dxerr9.h>

#include <DxErr.h>

#include "UtilStruct.h"

#define adapter D3DADAPTER_DEFAULT

#define RELEASE(x) if(x){x->Release(); x=NULL;}

#define TEXTURE_MAX 500

#define FVF2 (D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_TEX1)

#define FVF3 (D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX1)

struct V2D{

float x,y,z;

float rhw;

D3DCOLOR col;

float tu,tv;

};

struct V3D{

float x,y,z;

D3DCOLOR col;

float tu,tv;

};

class DXG{

private:

LPDIRECT3D9 pD3D; //IDirect3D9インターフェイス

D3DPRESENT_PARAMETERS deviceSt;//デバイス構造体

LPDIRECT3DDEVICE9 device; //デバイスポインタ

D3DVIEWPORT9 vp; //ビューポート

Color3 BackCol; //背景

LPD3DXSPRITE Sprite; //スプライト

LPDIRECT3DTEXTURE9 Texture[TEXTURE_MAX];//テクスチャ

int colorkeyflg[TEXTURE_MAX];

V2D v2D[4]; //２Ｄ用頂点

V3D v3D[4]; //３Ｄ用頂点

D3DXMATRIX matW; // ワールド変換行列

D3DXMATRIX matV; // ビュー変換行列

D3DXMATRIX matP; //プロジェクション変換行列

D3DXMATRIX matX,matY,matZ,matTrans;

HRESULT hr; //エラー用

char cbuffer[100];

//カラーキーか半透明かを設定

void SetColorKey(int Tno);

public:

BOOL Init(HWND hWnd,unsigned char red,unsigned char green,unsigned char blue);

BOOL SetTexture(char *Tname,int Tno,D3DCOLOR ARGB);

void ReleaseTexture(int Tno);

BOOL DrawBegin(void);

HRESULT DrawEnd(void);

//頂点の設定

void SetV2D(float Lx,float Uy,float Rx,float Dy);

void SetV3D(float Lx,float Uy,float Rx,float Dy,float z);

//アルファブレンディングの設定

void SetAlpha(int src,int des);

void AlphaOn(void);

void AlphaOff(void);

//Ｚバッファの設定

void ZbufferOn(void);

void ZbufferOff(void);

void ZbufferClear(void);

//頂点フォーマットの設定

void FVF2D(void);

void FVF3D(void);

//ワールド行列の設定

void SetMatW(float Rx,float Ry,float Rz,float Tx,float Ty,float Tz);

void SetMatWtr(float Tx,float Ty,float Tz,float Rx,float Ry,float Rz);

//２Ｄ描画

void SpriteDraw(int Tno,float Mx,float My,D3DCOLOR ARGB);

void SpriteDraw(int Tno,float Sx,float Sy,float Mx,float My,D3DCOLOR ARGB);

void SpriteDraw(int Tno,float Sx,float Sy,float Mx,float My,float rad,D3DCOLOR ARGB);

void SpriteDraw(int Tno,float Sx,float Sy,float Cx,float Cy,

float Mx,float My,float rad,D3DCOLOR ARGB);

void DrawPU2D(void);

void DrawPU2D(int Tno);

void DrawPU2D(int Tno,unsigned char alpha);

//３Ｄ描画

void DrawPU3D(void);

void DrawPU3D(int Tno);

void DrawPU3D(int Tno,unsigned char alpha);

//テクスチャの描画範囲

void SetUV2D(float left,float top,float right,float bottom);

void SetUV2D();

void SetUV3D(float left,float top,float right,float bottom);

void SetUV3D();

//終了

void End(void);

//高速化用

// void multiMat(D3DXMATRIX *mat1,D3DXMATRIX *mat2);

void eqMat(D3DXMATRIX *mat1,D3DXMATRIX *mat2);

};

//extern g_hWindow;

//Rect winRect;

//初期化

BOOL DXG::Init(HWND hWnd,unsigned char red,unsigned char green,unsigned char blue)

{

//float asp;

SetCol3(&BackCol,red,green,blue);

//IDirect3D9インターフェース取得

pD3D = Direct3DCreate9(D3D_SDK_VERSION);

ZeroMemory(&deviceSt, sizeof(deviceSt));

deviceSt.BackBufferWidth = 0;

deviceSt.BackBufferHeight = 0;

deviceSt.BackBufferFormat = D3DFMT_UNKNOWN;

deviceSt.BackBufferCount = 1;

deviceSt.MultiSampleType = D3DMULTISAMPLE_NONE;

deviceSt.MultiSampleQuality = 0;

deviceSt.SwapEffect = D3DSWAPEFFECT_FLIP;

deviceSt.hDeviceWindow = hWnd;

deviceSt.Windowed = TRUE;

deviceSt.EnableAutoDepthStencil = TRUE; // バックバッファ用

deviceSt.AutoDepthStencilFormat = D3DFMT_D16; // バックバッファ有り

deviceSt.Flags = 0;

deviceSt.FullScreen_RefreshRateInHz = 0;

// deviceSt.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;// 処理中断しない

deviceSt.PresentationInterval = D3DPRESENT_INTERVAL_ONE; // fpsを６０にする

//デバイスインターフェイス取得

if (FAILED(pD3D->CreateDevice(adapter,D3DDEVTYPE_HAL,hWnd,D3DCREATE_HARDWARE_VERTEXPROCESSING,&deviceSt,&device)))

{

// 失敗したので HAL で試行

if (FAILED(pD3D->CreateDevice(adapter,D3DDEVTYPE_HAL,hWnd,D3DCREATE_SOFTWARE_VERTEXPROCESSING,&deviceSt,&device)))

{

// 失敗したので REF で試行

if (FAILED(pD3D->CreateDevice(adapter,D3DDEVTYPE_REF,hWnd,D3DCREATE_SOFTWARE_VERTEXPROCESSING,&deviceSt,&device)))

{

// 結局失敗した

MessageBox(NULL,"Direct3D の初期化に失敗しました。","aaa",MB_OK | MB_ICONSTOP);

RELEASE(pD3D);

return FALSE;

}

}

}

//ビューポートの設定

vp.X =0;

vp.Y =0;

vp.Width =deviceSt.BackBufferWidth;

vp.Height=deviceSt.BackBufferHeight;

vp.MinZ =0.0f;

vp.MaxZ =1.0f;

device->SetViewport(&vp);

//ビュー行列の設定

D3DXMatrixLookAtLH(&matV,&D3DXVECTOR3(0,0,0),&D3DXVECTOR3(0,0,1),&D3DXVECTOR3(0,1,0));

device->SetTransform(D3DTS_VIEW,&matV);

//プロジェクション行列の設定

D3DXMatrixPerspectiveFovLH(&matP,60.0f * 3.141592f /180.0f,1.0f,0.01f,10.0f);

device->SetTransform(D3DTS_PROJECTION,&matP);

//テクスチャの初期化

for(int i=0;i < TEXTURE_MAX;i++)

{

Texture[i] = NULL;

}

//頂点の初期化

for(int i = 0;i < 4;++i)

{

v2D[i].x = 0; v2D[i].y = 0; v2D[i].z = 0;

v2D[i].rhw = 1.0;

v2D[i].col = 0xffffffff;

v2D[i].tu = 0; v2D[i].tv = 0;

v3D[i].x = 0; v3D[i].y = 0; v3D[i].z = 0;

v3D[i].col = 0xffffffff;

v3D[i].tu = 0; v3D[i].tv = 0;

}

v2D[1].tu = 1;

v2D[2].tv = 1;

v2D[3].tu = 1;

v2D[3].tv = 1;

v3D[0].x = -1; v3D[0].y = -1;

v3D[1].x = 1; v3D[1].y = -1;

v3D[2].x = -1; v3D[2].y = 1;

v3D[3].x = 1; v3D[3].y = 1;

v3D[1].tu = 1;

v3D[2].tv = 1;

v3D[3].tu = 1;

v3D[3].tv = 1;

//スプライトの作成

D3DXCreateSprite(device,&Sprite);

//頂点フォーマットの設定

device->SetFVF(FVF2);

//ライトの無効化

device->SetRenderState(D3DRS_LIGHTING,FALSE);

//カリングの設定

device->SetRenderState(D3DRS_CULLMODE,D3DCULL_NONE);

//アルファ値の設定(カラー抜き)

// device->SetRenderState(D3DRS_ALPHAREF,0x00000066);

// device->SetRenderState(D3DRS_ALPHATESTENABLE,TRUE);

// device->SetRenderState(D3DRS_ALPHAFUNC,D3DCMP_GREATEREQUAL);

return TRUE;

}

//描画開始

BOOL DXG::DrawBegin(void)

{

device->Clear(0,NULL,D3DCLEAR_TARGET,D3DCOLOR_XRGB(BackCol.red,BackCol.green,BackCol.blue),1.0f,0);

return SUCCEEDED(device->BeginScene());

}

//描画終了

HRESULT DXG::DrawEnd(void)

{

device->EndScene();

return device->Present(NULL,NULL,NULL,NULL);

}

//解放処理

void DXG::End(void)

{

for(int i = 0;i < TEXTURE_MAX;++i){

RELEASE(Texture[i]);

}

RELEASE(device);

RELEASE(pD3D);

}

//テクスチャ読み込み

BOOL DXG::SetTexture(char *Tname,int Tno,D3DCOLOR ARGB){

//D3DCOLOR colornull = 0;

if(Tno >=0 && Tno < TEXTURE_MAX){

hr = D3DXCreateTextureFromFileEx(device,Tname,0,0,0,0,

D3DFMT_A8R8G8B8,D3DPOOL_MANAGED,D3DX_FILTER_LINEAR,D3DX_FILTER_LINEAR,ARGB,

NULL,NULL,&Texture[Tno]);

if(ARGB == 0){//カラーキーを設定していない

colorkeyflg[Tno] = 0;

}else{//カラーキーを設定している

colorkeyflg[Tno] = 1;

}

if(FAILED(hr)){

sprintf(cbuffer,"テクスチャの読み込みが失敗しました。\nテクスチャ No%d\0",Tno);

MSGB(cbuffer);

return 0;

}

return 1;

}

return 0;

}

//テクスチャの解放

void DXG::ReleaseTexture(int Tno)

{

RELEASE(Texture[Tno]);

}

//スプライトの描画 １

void DXG::SpriteDraw(int Tno,float Mx,float My,D3DCOLOR ARGB)

{

D3DXVECTOR2 Translation(Mx,My);

Sprite->Begin(0);

Sprite->Draw(Texture[Tno],NULL,NULL,NULL,0,&Translation,ARGB);

Sprite->End();

}

void DXG::SpriteDraw(int Tno,float Sx,float Sy,float Mx,float My,D3DCOLOR ARGB)

{

D3DXVECTOR2 Scaling(Sx,Sy);

D3DXVECTOR2 Translation(Mx,My);

Sprite->Begin(0);

// Sprite->Draw(Texture[Tno],NULL,&Scaling,NULL,0.0,&Translation,ARGB);

Sprite->Draw(Texture[Tno],NULL,&Scaling,NULL,0.0);

Sprite->End();

}

void DXG::SpriteDraw(int Tno,float Sx,float Sy,float Mx,float My,float rad,D3DCOLOR ARGB)

{

D3DXVECTOR2 Scaling(Sx,Sy);

D3DXVECTOR2 Translation(Mx,My);

Sprite->Begin(0);

// Sprite->Draw(Texture[Tno],NULL,&Scaling,NULL,rad,&Translation,ARGB);

Sprite->Draw(Texture[Tno],NULL,&Scaling,NULL,rad);

Sprite->End();

}

void DXG::SpriteDraw(int Tno,float Sx,float Sy,float Cx,float Cy,float Mx,float My,float rad,D3DCOLOR ARGB)

{

D3DXVECTOR2 Scaling(Sx,Sy);

D3DXVECTOR2 RotationCenter(Cx,Cy);

D3DXVECTOR2 Translation(Mx,My);

Sprite->Begin(0);

Sprite->Draw(Texture[Tno],NULL,&Scaling,&RotationCenter,rad,&Translation,ARGB);

Sprite->End();

}

//DrawPrimitiveUPで２Ｄ画像を描画

void DXG::DrawPU2D(void)

{

device->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP,2,v2D,sizeof(V2D));

}

void DXG::DrawPU2D(int Tno)

{

SetColorKey(Tno);//カラーキーか半透明化を設定

device->SetRenderState(D3DRS_ALPHABLENDENABLE,FALSE);

device->SetTexture(0,Texture[Tno]);

device->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP,2,v2D,sizeof(V2D));

}

void DXG::DrawPU2D(int Tno,unsigned char alpha)

{

SetColorKey(Tno);//カラーキーか半透明化を設定

device->SetRenderState(D3DRS_ALPHABLENDENABLE,TRUE);

device->SetTexture(0,Texture[Tno]);

v2D[0].col = D3DCOLOR_ARGB(alpha,255,255,255);

v2D[1].col = D3DCOLOR_ARGB(alpha,255,255,255);

v2D[2].col = D3DCOLOR_ARGB(alpha,255,255,255);

v2D[3].col = D3DCOLOR_ARGB(alpha,255,255,255);

device->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP,2,v2D,sizeof(V2D));

}

//DrawPrimitiveUPで３Ｄ画像を描画

void DXG::DrawPU3D(void)

{

device->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP,2,v3D,sizeof(V3D));

}

void DXG::DrawPU3D(int Tno)

{

// device->SetRenderState(D3DRS_ALPHABLENDENABLE,FALSE);

device->SetTexture(0,Texture[Tno]);

device->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP,2,v3D,sizeof(V3D));

}

void DXG::DrawPU3D(int Tno,unsigned char alpha)

{

device->SetRenderState(D3DRS_ALPHABLENDENABLE,TRUE);

device->SetTexture(0,Texture[Tno]);

v3D[0].col = D3DCOLOR_ARGB(alpha,255,255,255);

v3D[1].col = D3DCOLOR_ARGB(alpha,255,255,255);

v3D[2].col = D3DCOLOR_ARGB(alpha,255,255,255);

v3D[3].col = D3DCOLOR_ARGB(alpha,255,255,255);

device->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP,2,v3D,sizeof(V3D));

}

//アルファブレンディングの方法

void DXG::SetAlpha(int src,int des)

{

if(src){

device->SetRenderState(D3DRS_SRCBLEND,D3DBLEND_SRCALPHA);

}else{

device->SetRenderState(D3DRS_SRCBLEND,D3DBLEND_ONE);

}

if(des){

device->SetRenderState(D3DRS_DESTBLEND,D3DBLEND_INVSRCALPHA);

}else{

device->SetRenderState(D3DRS_DESTBLEND,D3DBLEND_ONE);

}

}

//アルファブレンディング オフ

void DXG::AlphaOff()

{

device->SetRenderState(D3DRS_ALPHABLENDENABLE,FALSE);

}

//アルファブレンディング オン

void DXG::AlphaOn()

{

device->SetRenderState(D3DRS_ALPHABLENDENABLE,TRUE);

}

//頂点の設定 ２Ｄ

void DXG::SetV2D(float Lx,float Uy,float Rx,float Dy)

{

v2D[0].x = Lx; v2D[0].y = Uy;

v2D[1].x = Rx; v2D[1].y = Uy;

v2D[2].x = Lx; v2D[2].y = Dy;

v2D[3].x = Rx; v2D[3].y = Dy;

}

//頂点の設定 ３Ｄ

void DXG::SetV3D(float Lx,float Uy,float Rx,float Dy,float z){

v3D[0].x = Lx; v3D[0].y = Uy; v3D[0].z = z;

v3D[1].x = Rx; v3D[1].y = Uy; v3D[1].z = z;

v3D[2].x = Lx; v3D[2].y = Dy; v3D[2].z = z;

v3D[3].x = Rx; v3D[3].y = Dy; v3D[3].z = z;

}

//頂点フォーマットの設定

void DXG::FVF2D(void)

{

device->SetFVF(FVF2);

}

void DXG::FVF3D(void)

{

device->SetFVF(FVF3);

}

//Ｚバッファの設定

void DXG::ZbufferOn(void)

{

device->SetRenderState(D3DRS_ZENABLE,D3DZB_TRUE);

}

void DXG::ZbufferOff(void)

{

device->SetRenderState(D3DRS_ZENABLE,D3DZB_FALSE);

}

void DXG::ZbufferClear(void)

{

device->Clear( 0,NULL,D3DCLEAR_ZBUFFER, 0, 1.0f, 0);

}

//高速化用

void DXG::eqMat(D3DXMATRIX *mat1,D3DXMATRIX *mat2)

{

mat1->_11 = mat2->_11; mat1->_12 = mat2->_12; mat1->_13 = mat2->_13; mat1->_14 = mat2->_14;

mat1->_21 = mat2->_21; mat1->_22 = mat2->_22; mat1->_23 = mat2->_23; mat1->_24 = mat2->_24;

mat1->_31 = mat2->_31; mat1->_32 = mat2->_32; mat1->_33 = mat2->_33; mat1->_34 = mat2->_34;

mat1->_41 = mat2->_41; mat1->_42 = mat2->_42; mat1->_43 = mat2->_43; mat1->_44 = mat2->_44;

}

//ワールド行列の設定

void DXG::SetMatW(float Rx,float Ry,float Rz,float Tx,float Ty,float Tz)

{

D3DXMatrixRotationX(&matX,Rx);

D3DXMatrixRotationY(&matY,Ry);

D3DXMatrixRotationZ(&matZ,Rz);

D3DXMatrixTranslation(&matTrans,Tx,Ty,Tz);

D3DXMatrixMultiply(&matW, &matX, &matY);

D3DXMatrixMultiply(&matW, &matW, &matZ);

D3DXMatrixMultiply(&matW, &matW, &matTrans);

device->SetTransform(D3DTS_WORLD,&matW);

}

void DXG::SetMatWtr(float Tx,float Ty,float Tz,float Rx,float Ry,float Rz)

{

D3DXMatrixRotationX(&matX,Rx);

D3DXMatrixRotationY(&matX,Ry);

D3DXMatrixRotationZ(&matX,Rz);

D3DXMatrixTranslation(&matTrans,Tx,Ty,Tz);

D3DXMatrixMultiply(&matW, &matX, &matTrans);

D3DXMatrixMultiply(&matW, &matW, &matY);

D3DXMatrixMultiply(&matW, &matW, &matZ);

device->SetTransform(D3DTS_WORLD,&matW);

}

//テクスチャの描画範囲

void DXG::SetUV2D(float left,float top,float right,float bottom)

{

v2D[0].tu = left; v2D[0].tv = top;

v2D[1].tu = right; v2D[1].tv = top;

v2D[2].tu = left; v2D[2].tv = bottom;

v2D[3].tu = right; v2D[3].tv = bottom;

}

void DXG::SetUV2D()

{

v2D[0].tu = 0; v2D[0].tv = 0;

v2D[1].tu = 1; v2D[1].tv = 0;

v2D[2].tu = 0; v2D[2].tv = 1;

v2D[3].tu = 1; v2D[3].tv = 1;

}

void DXG::SetUV3D(float left,float top,float right,float bottom)

{

v3D[0].tu = left; v3D[0].tv = top;

v3D[1].tu = right; v3D[1].tv = top;

v3D[2].tu = left; v3D[2].tv = bottom;

v3D[3].tu = right; v3D[3].tv = bottom;

}

void DXG::SetUV3D()

{

v3D[0].tu = 0; v3D[0].tv = 0;

v3D[1].tu = 1; v3D[1].tv = 0;

v3D[2].tu = 0; v3D[2].tv = 1;

v3D[3].tu = 1; v3D[3].tv = 1;

}

void DXG::SetColorKey(int Tno)

{

static int ColorKeyFlg = 1;

if(ColorKeyFlg != colorkeyflg[Tno]){//変更の必要あり

if(colorkeyflg[Tno]){

device->SetTextureStageState(0,D3DTSS_ALPHAARG1,D3DTA_TEXTURE);//カラー抜き可（半透明処理不可）

ColorKeyFlg = 1;

}else{

device->SetTextureStageState(0,D3DTSS_ALPHAARG1,D3DTA_DIFFUSE);//半透明処理可（カラー抜き不可）

ColorKeyFlg = 0;

}

}

}