Red de conocimiento informático - Conocimiento de la instalación - Utilice el lenguaje C para simular el código fuente simple del movimiento del billar, no se requiere interfaz gráfica

Utilice el lenguaje C para simular el código fuente simple del movimiento del billar, no se requiere interfaz gráfica

Este código fuente debe tener una clase de tabla (Table), clase de pelota (Sphere), clase de juego, etc.

Yo uso C

#pragma una vez (Table.h)

#endif // _MSC_VER gt 1000

#include "Base.h"

#define MESH_D3DFVF_CUSTOMVERTEX (D3DFVF_XYZ|D3DFVF_NORMAL|D3DFVF_TEX1)

clase CTable: CBase pública

{

pública:

DWORD Render();

CTable(LPDIRECT3DDEVICE8 pD3DDevice, LPSTR pFilename);

virtual ~CTable();

LPD3DXMESH GetMeshTablePointer();

privado:

void TransformTable();

LPDIRECT3DDEVICE8 m_pD3DDevice;

DWORD m_dwNumMaterials;

LPD3DXMESH m_pMeshTable;

D3DMATERIAL8 *m_pMeshTableMaterials;

LPDIRECT3DTEXTURE8 *m_pMeshTableTextures;

};#endif

#include "Table.h" (Table.cpp)

CTable::CTable(LPDIRECT3DDEVICE8 pD3DDevice, LPSTR pFilename)

{

LPD3DXBUFFER pMaterialsBuffer=NULL;

LPD3DXMESH pMeshTable=NULL;

m_pD3DDevice=pD3DDevice;

if(FAILED(D3DXLoadMeshFromX(pFilename, D3DXMESH_MANAGED, m_pD3DDevice, NULL,

amp; pMaterialsBuffer, amp; m_dwNumMaterials, amp; pMeshTable) ))

{

m_pMeshTable=NULL

m_pMeshTableMaterials=NULL

m_pMeshTableTextures=NULL

LogError("lt;ligt;Error al cargar la malla de tabla",pFilename);

return;

}

D3DXMATERIAL *matMaterials=(D3DXMATERIAL *)pMaterialsBuffer-gt;GetBufferPointer();

//Crea dos matrices, una para contener los materiales.

y otro para contener las texturas

m_pMeshTableMaterials=new D3DMATERIAL8[m_dwNumMaterials];

m_pMeshTableTextures=new LPDIRECT3DTEXTURE8[m_dwNumMaterials];

for(DWORD i=0; ilt; m_dwNumMaterials; i )

{

//Copiar el material

m_pMeshTableMaterials[i]=matMaterials[i].MatD3D;

//Establece el color ambiental para el material (D3DX no hace esto)

m_pMeshTableMaterials[i].Ambient=m_pMeshTableMaterials[i].Diffuse;

D3DCOLORVALUE rgbaSpecular={ 0.0f, 0.0f, 0.0f, 0.0f};

m_pMeshTableMaterials[i].Specular=rgbaSpecular;

m_pMeshTableMaterials[i].Power=50.0f;

//Crea la textura

char buffer[255];

sprintf(buffer, "textures/s", matMaterials[i].pTextureFilename);

if(FAILED(D3DXCreateTextureFromFile(m_pD3DDevice,

buffer, amp; m_pMeshTableTextures[i])))

{

m_pMeshTableTextures[i]=NULL ;

}

}

//terminé con el buffer de material, así que libérelo

SafeRelease(pMaterialsBuffer);

//Asegúrese de que las normales estén configuradas para la malla

pMeshTable-gt; CloneMeshFVF(D3DXMESH_MANAGED, MESH_D3DFVF_CUSTOMVERTEX, m_pD3DDevice, amp; m_pMeshTable);

SafeRelease(pMeshTable) ;

// D3DXComputeNormals(m_pMesh);

LogInfo("lt;ligt;Mesh 's' cargado OK",pFilename);

}

CTable::~CTable()

{

SafeDelete(m_p

MeshTableMaterials);

if(m_pMeshTableTextures != NULL)

{

for(DWORD i=0; ilt; m_dwNumMaterials; i )

{

if(m_pMeshTableTextures[i])

SafeRelease(m_pMeshTableTextures[i]);

}

}

SafeDelete(m_pMeshTableTextures);

SafeRelease(m_pMeshTable);

LogInfo("lt;ligt;Table Mesh destruida OK");

}

DWORD CTable::Render()

{

TransformTable();

if(m_pMeshTable!=NULL) p>

{

for(DWORD i=0; ilt; m_dwNumMaterials; i )

{

m_pD3DDevice-gt; ; m_pMeshTableMaterials [i]);

m_pD3DDevice-gt; SetTexture(0, m_pMeshTableTextures[i]);

m_pMeshTable-gt; > }

devuelve m_pMeshTable-gt; GetNumFaces();

}

más

devuelve 0; >}

LPD3DXMESH CTable::GetMeshTablePointer()

{

return m_pMeshTable;

}

void CTable: :TransformTable()

{

D3DXMATRIX matWorld

D3DXMatrixTranslation(amp; matWorld, 0, 0, 0); > m_pD3DDevice -gt;SetTransform(D3DTS_WORLD,&matWorld);

}

(Sphere.h)

#if !definido (AFX_SPHERE_H__FC705F3B_568E_4973_B608_B8F7700D9ECE__INCLUDED_)

#define AFX_SPHERE_H__FC705F3B_568E_4973_B608_B8F7700D9ECE__INCLUDED_

#if _MSC_VER gt;p>

#pragma once

#endif // _MSC_VER gt; >#incluir "Base.h"

#define SPHERE_D3DFVF_CUSTOMVERTEX (D3DFVF_XYZ|D3DFVF_NORMAL|D3DFVF_TEX1)

clase CSphere: CBase pública

{

privada:

estructura SPHERE_CUSTOMVERTEX

{

float x, y, z; //Posición del vértice en el espacio 3D

float nx, ny, nz //Iluminación normal<; /p>

float tu, tv; //Coordenadas de textura

};

struct SPHERE_STATE

{

D3DXVECTOR3 sVector ; //Posición del centigramo en el espacio 3D

D3DXVECTOR3 vVector; //Dirección de la velocidad en el espacio 3D

float v //Velocidad de la esfera

} ;

SPHERE_STATE *m_pSphereState;

D3DXVECTOR3 m_vecSavePosition; //Guardar la posición de la esfera para la barra de colisión

D3DXVECTOR3 m_vecSavePosition2 //Guardar la posición de la esfera para la esfera de colisión

p>

público:

BOOL SetMaterial(D3DCOLORVALUE rgbaDiffuse, D3DCOLORVALUE rgbaAmbient,

D3DCOLORVALUE rgbaSpecular, D3DCOLORVALUE rgbaEmissive, float rPower

BOOL SetTexture( const char* szTextureFilePath);

DWORD Render();

CSphere(LPDIRECT3DDEVICE8 pD3DDevice, int iRings=20, int iSegments=20); p> void MoveSphere ();

void MoveSphereForUser(float x, float z);

virtual ~CSphere()

void SetSpherePosition(float x); , flotar y, flotar z)

{

m_pSphereState-gt; sVector.x=x

m_pSphereState-gt; /p>

m_pSphereState-gt;sVector.z=z;

};

inline void GetSpherePosition(D3DXVECTOR3 & vecSpherePos)

{

vecSpherePos=m_pSphereState-gt;sVector;

p>

};

inline void GetSavedSpherePosition(D3DXVECTOR3 & vecSavedSpherePos)

{

vecSavedSpherePos=m_vecSavePosition

} ;

inline void GetSavedSpherePosition2(D3DXVECTOR3 & vecSavedSpherePos)

{

vecSavedSpherePos=m_vecSavePosition2;

};

inline void SaveSpherePosition()

{

m_vecSavePosition=m_pSphereState-gt;

inline void; SaveSpherePosition2( )

{

m_vecSavePosition2=m_pSphereState-gt; sVector

}

inline void ContradictoryZv()

{

m_pSphereState-gt; vVector.z=-m_pSphereState-gt; vVector.z

}

vacío en línea ContradictoryXv();

{

m_pSphereState-gt; vVector.x=-m_pSphereState-gt; vVector.x

}

void MirrorVAoubtAxis; (D3DXVECTOR3 amp; n);

vacío en línea ReduceSphereVelocity(porcentaje flotante)

{

m_pSphereState-gt; v=m_pSphereState-gt;

p>

};

flotador en línea CheckSphereEnergy()

{

return m_pSphereState-gt; p>

};

vacío en línea SetSphereVelocityDir(const D3DXVECTOR3 amp; vDir)

{

m_pSphereState-gt; >

};

inline void SetSphereVelocity(const float amp; velocidad)

{

m_pSphereState-gt;

=velocidad;

};

vacío en línea GetSphereVelocityDir(D3DXVECTOR3 amp; vDir)

{

vDir=m_pSphereState-gt; ;

};

flotador en línea GetSphereVelocity()

{

return m_pSphereState-gt; > };

vacío en línea SetSphereStateToFalse()

{

m_bSphereInUse=FALSE

}; inline void SetSphereStateToTrue()

{

m_bSphereInUse=TRUE

}

inline BOOL GetSphereState()

{

return m_bSphereInUse;

};

void SetSphereVelocityAt_Y_NegativeAxis()

flotador en línea GetSpherePosAt_Y_Axis();

{

return m_pSphereState-gt; sVector.y;

};

privado:

BOOL CreateIndexBuffer();

BOOL UpdateVertices();

BOOL CreateVertexBuffer();

void TransformSphere()

void TransformSphereForUser(); p>

p>

void UpdateSpherePosition();

void FrictionReduseVelocity();

LPDIRECT3DDEVICE8 m_pD3DDevice

LPDIRECT3DVERTEXBUFFER8 m_pVertexBuffer; >

LPDIRECT3DTEXTURE8 m_pTexture;

D3DMATERIAL8 m_matMaterial;

LPDIRECT3DINDEXBUFFER8 m_pIndexBuffer

int m_iRings

int m_iSegments; >

float m_fTotalDis;

D3DXVECTOR3 m_vecSphereRotationAxis;

BOOL m_bSphereInUse;

DWORD m_dwNumOfVertices;

DWORD m_dwNumOfIndices;

DWORD m_dwNumOfPolygons;

};#endif