RiskYourLife/Client
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial commit: ROW Client source code

Browse Source 
Game client codebase including:
- CharacterActionControl: Character and creature management
- GlobalScript: Network, items, skills, quests, utilities
- RYLClient: Main client application with GUI and event handlers
- Engine: 3D rendering engine (RYLGL)
- MemoryManager: Custom memory allocation
- Library: Third-party dependencies (DirectX, boost, etc.)
- Tools: Development utilities

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
tindevil
2025-11-29 16:24:34 +09:00
commit e067522598
5135 changed files with 1745744 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

684
Library/dxx8/samples/Multimedia/Demos/DMBoids/boids.cpp Normal file
View File

@@ -0,0 +1,684 @@
//-----------------------------------------------------------------------------
// File: Boids.cpp
//
// Desc:
//
// Copyright (c) 1995-2001 Microsoft Corporation. All rights reserved.
//-----------------------------------------------------------------------------
#define STRICT
#include <stdio.h>
#include <math.h>
#include <d3dx8.h>
#include "D3DApp.h"
#include "D3DFile.h"
#include "D3DFont.h"
#include "D3DUtil.h"
#include "DXUtil.h"
#include "boids.h"
#include "music.h"
//-----------------------------------------------------------------------------
// Defines, constants, and global variables
//-----------------------------------------------------------------------------
BoidMusic g_Music;
struct BOIDVERTEX
{
D3DXVECTOR3 p;
D3DXVECTOR3 n;
};
struct GRIDVERTEX
{
D3DXVECTOR3 pos;
D3DCOLOR color;
};
#define D3DFVF_BOIDVERTEX (D3DFVF_XYZ|D3DFVF_NORMAL)
#define D3DFVF_GRIDVERTEX (D3DFVF_XYZ|D3DFVF_DIFFUSE)
#define NUM_BOIDS 40
inline FLOAT rnd() { return (((FLOAT)rand())/RAND_MAX); }
inline FLOAT Min( D3DXVECTOR3 v )
{
if( v.x < v.y ) return (v.x < v.z ) ? v.x : v.z;
else return (v.y < v.z ) ? v.y : v.z;
}
inline FLOAT Max( D3DXVECTOR3 v )
{
if( v.x > v.y ) return (v.x > v.z ) ? v.x : v.z;
else return (v.y > v.z ) ? v.y : v.z;
}
BOOL g_bSeparation = FALSE;
BOOL g_bAlignment = FALSE;
BOOL g_bCohesion = FALSE;
BOOL g_bMigratory = FALSE;
BOOL g_bObstacle = FALSE;
//-----------------------------------------------------------------------------
// Name: class CMyD3DApplication
// Desc: Application class. The base class (CD3DApplication) provides the
// generic functionality needed in all Direct3D samples. CMyD3DApplication
// adds functionality specific to this sample program.
//-----------------------------------------------------------------------------
class CMyD3DApplication : public CD3DApplication
{
CD3DFont* m_pFont; // Font for drawing text
D3DXMATRIX m_matWorld; // Transform matrices
D3DXMATRIX m_matView;
D3DXMATRIX m_matProj;
D3DLIGHT8 m_Light1; // Lights and materials
D3DLIGHT8 m_Light2;
D3DMATERIAL8 m_mtrlBackground;
D3DMATERIAL8 m_mtrlGrid;
D3DMATERIAL8 m_mtrlBoid;
CD3DMesh* m_pSphere; // Spheres
FLOAT m_fSphereSpin;
LPDIRECT3DVERTEXBUFFER8 m_pBoidVB; // Boid mesh
LPDIRECT3DINDEXBUFFER8 m_pBoidIB;
BOIDVERTEX m_vBoidVertices[16];
WORD m_wBoidIndices[30];
DWORD m_dwNumBoidVertices;
DWORD m_dwNumBoidIndices;
CFlock m_Flock; // The flock structure
CD3DMesh* m_pSeaGull; // Seagull mesh
GRIDVERTEX m_vGridPattern1[25]; // Grid mesh
GRIDVERTEX m_vGridPattern2[9];
// Internal functions
HRESULT RenderFlock();
protected:
HRESULT OneTimeSceneInit();
HRESULT InitDeviceObjects();
HRESULT RestoreDeviceObjects();
HRESULT InvalidateDeviceObjects();
HRESULT DeleteDeviceObjects();
HRESULT FinalCleanup();
HRESULT Render();
HRESULT FrameMove();
public:
LRESULT MsgProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam );
CMyD3DApplication();
};
//-----------------------------------------------------------------------------
// Name: WinMain()
// Desc: Entry point to the program. Initializes everything, and goes into a
// message-processing loop. Idle time is used to render the scene.
//-----------------------------------------------------------------------------
INT WINAPI WinMain( HINSTANCE hInst, HINSTANCE, LPSTR, INT )
{
CMyD3DApplication d3dApp;
if( FAILED( d3dApp.Create( hInst ) ) )
return 0;
return d3dApp.Run();
}
//-----------------------------------------------------------------------------
// Name: CMyD3DApplication()
// Desc: Application constructor. Sets attributes for the app.
//-----------------------------------------------------------------------------
CMyD3DApplication::CMyD3DApplication()
:CD3DApplication()
{
m_strWindowTitle = _T("DMBoids: DMusic Flocking Boids Sample");
m_bUseDepthBuffer = TRUE;
m_fSphereSpin = 0.0f;
m_pBoidVB = NULL;
m_pBoidIB = NULL;
m_pSphere = new CD3DMesh();
m_pSeaGull = new CD3DMesh();
}
//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
HRESULT CMyD3DApplication::OneTimeSceneInit()
{
D3DXVECTOR3 vNorm;
// generate the boid data
m_dwNumBoidVertices = 16;
m_dwNumBoidIndices = 30;
// top
m_vBoidVertices[ 0].p = D3DXVECTOR3( 0.0f, 0.0f, 10.0f); D3DXVec3Normalize( &m_vBoidVertices[ 0].n, &D3DXVECTOR3( 0.2f, 1.0f, 0.0f) );
m_vBoidVertices[ 1].p = D3DXVECTOR3( 10.0f, 0.0f,-10.0f); D3DXVec3Normalize( &m_vBoidVertices[ 1].n, &D3DXVECTOR3( 0.1f, 1.0f, 0.0f) );
m_vBoidVertices[ 2].p = D3DXVECTOR3( 3.0f, 3.0f, -7.0f); D3DXVec3Normalize( &m_vBoidVertices[ 2].n, &D3DXVECTOR3( 0.0f, 1.0f, 0.0f) );
m_vBoidVertices[ 3].p = D3DXVECTOR3( -3.0f, 3.0f, -7.0f); D3DXVec3Normalize( &m_vBoidVertices[ 3].n, &D3DXVECTOR3(-0.1f, 1.0f, 0.0f) );
m_vBoidVertices[ 4].p = D3DXVECTOR3(-10.0f, 0.0f,-10.0f); D3DXVec3Normalize( &m_vBoidVertices[ 4].n, &D3DXVECTOR3(-0.2f, 1.0f, 0.0f) );
// bottom
m_vBoidVertices[ 5].p = D3DXVECTOR3( 0.0f, 0.0f, 10.0f); D3DXVec3Normalize( &m_vBoidVertices[ 5].n, &D3DXVECTOR3( 0.2f, -1.0f, 0.0f) );
m_vBoidVertices[ 6].p = D3DXVECTOR3( 10.0f, 0.0f,-10.0f); D3DXVec3Normalize( &m_vBoidVertices[ 6].n, &D3DXVECTOR3( 0.1f, -1.0f, 0.0f) );
m_vBoidVertices[ 7].p = D3DXVECTOR3( 3.0f,-3.0f, -7.0f); D3DXVec3Normalize( &m_vBoidVertices[ 7].n, &D3DXVECTOR3( 0.0f, -1.0f, 0.0f) );
m_vBoidVertices[ 8].p = D3DXVECTOR3( -3.0f,-3.0f, -7.0f); D3DXVec3Normalize( &m_vBoidVertices[ 8].n, &D3DXVECTOR3(-0.1f, -1.0f, 0.0f) );
m_vBoidVertices[ 9].p = D3DXVECTOR3(-10.0f, 0.0f,-10.0f); D3DXVec3Normalize( &m_vBoidVertices[ 9].n, &D3DXVECTOR3(-0.2f, -1.0f, 0.0f) );
// rear
m_vBoidVertices[10].p = D3DXVECTOR3( 10.0f, 0.0f,-10.0f); D3DXVec3Normalize( &m_vBoidVertices[10].n, &D3DXVECTOR3(-0.4f, 0.0f, -1.0f) );
m_vBoidVertices[11].p = D3DXVECTOR3( 3.0f, 3.0f, -7.0f); D3DXVec3Normalize( &m_vBoidVertices[11].n, &D3DXVECTOR3(-0.2f, 0.0f, -1.0f) );
m_vBoidVertices[12].p = D3DXVECTOR3( -3.0f, 3.0f, -7.0f); D3DXVec3Normalize( &m_vBoidVertices[12].n, &D3DXVECTOR3( 0.2f, 0.0f, -1.0f) );
m_vBoidVertices[13].p = D3DXVECTOR3(-10.0f, 0.0f,-10.0f); D3DXVec3Normalize( &m_vBoidVertices[13].n, &D3DXVECTOR3( 0.4f, 0.0f, -1.0f) );
m_vBoidVertices[14].p = D3DXVECTOR3( -3.0f,-3.0f, -7.0f); D3DXVec3Normalize( &m_vBoidVertices[14].n, &D3DXVECTOR3( 0.2f, 0.0f, -1.0f) );
m_vBoidVertices[15].p = D3DXVECTOR3( 3.0f,-3.0f, -7.0f); D3DXVec3Normalize( &m_vBoidVertices[15].n, &D3DXVECTOR3(-0.2f, 0.0f, -1.0f) );
// top
m_wBoidIndices[ 0] = 0; m_wBoidIndices[ 1] = 1; m_wBoidIndices[ 2] = 2;
m_wBoidIndices[ 3] = 0; m_wBoidIndices[ 4] = 2; m_wBoidIndices[ 5] = 3;
m_wBoidIndices[ 6] = 0; m_wBoidIndices[ 7] = 3; m_wBoidIndices[ 8] = 4;
// bottom
m_wBoidIndices[ 9] = 5; m_wBoidIndices[10] = 7; m_wBoidIndices[11] = 6;
m_wBoidIndices[12] = 5; m_wBoidIndices[13] = 8; m_wBoidIndices[14] = 7;
m_wBoidIndices[15] = 5; m_wBoidIndices[16] = 9; m_wBoidIndices[17] = 8;
// rear
m_wBoidIndices[18] = 10; m_wBoidIndices[19] = 15; m_wBoidIndices[20] = 11;
m_wBoidIndices[21] = 11; m_wBoidIndices[22] = 15; m_wBoidIndices[23] = 12;
m_wBoidIndices[24] = 12; m_wBoidIndices[25] = 15; m_wBoidIndices[26] = 14;
m_wBoidIndices[27] = 12; m_wBoidIndices[28] = 14; m_wBoidIndices[29] = 13;
// scale the boid to be unit length
for( DWORD i=0; i<16; i++ )
{
m_vBoidVertices[i].p.x /= 20.0f;
m_vBoidVertices[i].p.y /= 20.0f;
m_vBoidVertices[i].p.z /= 20.0f;
}
// seed the random number generator
srand( timeGetTime() );
// allocate the flock
m_Flock.m_Boids = new Boid[NUM_BOIDS];
m_Flock.m_dwNumBoids = NUM_BOIDS;
m_Flock.m_afDist = (FLOAT**)new LPVOID[NUM_BOIDS];
m_Flock.m_vGoal = D3DXVECTOR3( 0.0f, 0.0f, 0.0f );
for( i=0; i<m_Flock.m_dwNumBoids; i++ )
{
D3DXMatrixIdentity( &m_Flock.m_Boids[i].matWorld );
m_Flock.m_Boids[i].vPos = D3DXVECTOR3( 200.0f*(rnd()-rnd()), 100.0f*rnd(), 200.0f*(rnd()-rnd()) );
D3DXVec3Normalize( &m_Flock.m_Boids[i].vDir, &D3DXVECTOR3(rnd()-rnd(), rnd()-rnd(), rnd()-rnd()));
m_Flock.m_Boids[i].yaw = 0.0f;
m_Flock.m_Boids[i].pitch = 0.0f;
m_Flock.m_Boids[i].roll = 0.0f;
m_Flock.m_Boids[i].dyaw = 0.0f;
m_Flock.m_Boids[i].speed = 0.1f;
m_Flock.m_Boids[i].color = D3DXVECTOR3( rnd(), rnd(), rnd() );
m_Flock.m_Boids[i].color -= D3DXVECTOR3( Min(m_Flock.m_Boids[i].color), Min(m_Flock.m_Boids[i].color), Min(m_Flock.m_Boids[i].color) );
m_Flock.m_Boids[i].color /= Max( m_Flock.m_Boids[i].color );
m_Flock.m_afDist[i] = new FLOAT[NUM_BOIDS];
}
m_Flock.m_dwNumObstacles = 4;
m_Flock.m_Obstacles = new Obstacle[m_Flock.m_dwNumObstacles];
m_Flock.m_Obstacles[0].vPos = D3DXVECTOR3( 100.0f, 10.0f, 0.0f );
m_Flock.m_Obstacles[1].vPos = D3DXVECTOR3( 0.0f, 10.0f, 100.0f );
m_Flock.m_Obstacles[2].vPos = D3DXVECTOR3(-100.0f, 10.0f, 0.0f );
m_Flock.m_Obstacles[3].vPos = D3DXVECTOR3( 0.0f, 10.0f,-100.0f );
m_Flock.m_Obstacles[0].fRadius = 0.2f;
m_Flock.m_Obstacles[1].fRadius = 0.2f;
m_Flock.m_Obstacles[2].fRadius = 0.2f;
m_Flock.m_Obstacles[3].fRadius = 0.2f;
D3DCOLOR diffuse = D3DCOLOR_RGBA( 0, 0, 30, 128 );
D3DCOLOR specular = D3DCOLOR_RGBA( 0, 0, 0, 0 );
for( i=0; i<=24; i++ )
m_vGridPattern1[i].color = diffuse;
m_vGridPattern1[ 0].pos = D3DXVECTOR3(-25.0f, 0.0f, 35.0f );
m_vGridPattern1[ 1].pos = D3DXVECTOR3(-15.0f, 0.0f, 35.0f );
m_vGridPattern1[ 2].pos = D3DXVECTOR3( -5.0f, 0.0f, 25.0f );
m_vGridPattern1[ 3].pos = D3DXVECTOR3( 5.0f, 0.0f, 25.0f );
m_vGridPattern1[ 4].pos = D3DXVECTOR3( 15.0f, 0.0f, 35.0f );
m_vGridPattern1[ 5].pos = D3DXVECTOR3( 25.0f, 0.0f, 35.0f );
m_vGridPattern1[ 6].pos = D3DXVECTOR3( 35.0f, 0.0f, 25.0f );
m_vGridPattern1[ 7].pos = D3DXVECTOR3( 35.0f, 0.0f, 15.0f );
m_vGridPattern1[ 8].pos = D3DXVECTOR3( 25.0f, 0.0f, 5.0f );
m_vGridPattern1[ 9].pos = D3DXVECTOR3( 25.0f, 0.0f, -5.0f );
m_vGridPattern1[10].pos = D3DXVECTOR3( 35.0f, 0.0f,-15.0f );
m_vGridPattern1[11].pos = D3DXVECTOR3( 35.0f, 0.0f,-25.0f );
m_vGridPattern1[12].pos = D3DXVECTOR3( 25.0f, 0.0f,-35.0f );
m_vGridPattern1[13].pos = D3DXVECTOR3( 15.0f, 0.0f,-35.0f );
m_vGridPattern1[14].pos = D3DXVECTOR3( 5.0f, 0.0f,-25.0f );
m_vGridPattern1[15].pos = D3DXVECTOR3( -5.0f, 0.0f,-25.0f );
m_vGridPattern1[16].pos = D3DXVECTOR3(-15.0f, 0.0f,-35.0f );
m_vGridPattern1[17].pos = D3DXVECTOR3(-25.0f, 0.0f,-35.0f );
m_vGridPattern1[18].pos = D3DXVECTOR3(-35.0f, 0.0f,-25.0f );
m_vGridPattern1[19].pos = D3DXVECTOR3(-35.0f, 0.0f,-15.0f );
m_vGridPattern1[20].pos = D3DXVECTOR3(-25.0f, 0.0f, -5.0f );
m_vGridPattern1[21].pos = D3DXVECTOR3(-25.0f, 0.0f, 5.0f );
m_vGridPattern1[22].pos = D3DXVECTOR3(-35.0f, 0.0f, 15.0f );
m_vGridPattern1[23].pos = D3DXVECTOR3(-35.0f, 0.0f, 25.0f );
m_vGridPattern1[24].pos = D3DXVECTOR3(-25.0f, 0.0f, 35.0f );
for( i=0; i<=8; i++ )
m_vGridPattern2[i].color = diffuse;
m_vGridPattern2[0].pos = D3DXVECTOR3( -5.0f, 0.0f, 15.0f );
m_vGridPattern2[1].pos = D3DXVECTOR3( 5.0f, 0.0f, 15.0f );
m_vGridPattern2[2].pos = D3DXVECTOR3( 15.0f, 0.0f, 5.0f );
m_vGridPattern2[3].pos = D3DXVECTOR3( 15.0f, 0.0f, -5.0f );
m_vGridPattern2[4].pos = D3DXVECTOR3( 5.0f, 0.0f,-15.0f );
m_vGridPattern2[5].pos = D3DXVECTOR3( -5.0f, 0.0f,-15.0f );
m_vGridPattern2[6].pos = D3DXVECTOR3(-15.0f, 0.0f, -5.0f );
m_vGridPattern2[7].pos = D3DXVECTOR3(-15.0f, 0.0f, 5.0f );
m_vGridPattern2[8].pos = D3DXVECTOR3( -5.0f, 0.0f, 15.0f );
if( FAILED( g_Music.LoadMusic( m_hWnd ) ) )
{
OutputDebugString("Failed to initialize DirectMusic.\n");
return E_FAIL;
}
g_Music.StartMusic();
return S_OK;
}
//-----------------------------------------------------------------------------
// Name: FrameMove()
// Desc:
//-----------------------------------------------------------------------------
HRESULT CMyD3DApplication::FrameMove()
{
D3DXVECTOR3 vEyePt;
D3DXVECTOR3 vLookAtPt( 0.0f, 0.0f, 0.0f );
D3DXVECTOR3 vUp( 0.0f, 1.0f, 0.0f );
FLOAT fTime;
FLOAT fElapsedTime;
// The REF device is slow enough to throw off the animation
// in this sample, so if using the REF device, simulate
// running at 20fps regardless of actual rendering speed.
if( m_d3dCaps.DeviceType == D3DDEVTYPE_REF )
{
static FLOAT fTimePrev = 0.0f;
fElapsedTime = 0.05f;
fTime = fTimePrev + fElapsedTime;
fTimePrev = fTime;
}
else
{
fElapsedTime = m_fElapsedTime;
fTime = m_fTime;
}
// Move each boids to its new location
m_Flock.Update( fElapsedTime );
// LookAt point is the center of the flock
for( DWORD i=0; i<m_Flock.m_dwNumBoids; i++ )
vLookAtPt += m_Flock.m_Boids[i].vPos;
vLookAtPt /= (FLOAT)m_Flock.m_dwNumBoids;
vEyePt = vLookAtPt + 40 * D3DXVECTOR3( sinf(fTime*0.111f),
0.70f+0.75f*sinf(fTime*0.163f),
cosf(fTime*0.155f) );
D3DXMatrixLookAtLH( &m_matView, &vEyePt, &vLookAtPt, &vUp );
g_Music.SetDistance( D3DXVec3Length( &( vEyePt - vLookAtPt ) ) );
// Update the flock's goal
m_Flock.m_vGoal = 100.0f * D3DXVECTOR3( sinf(fTime*0.1f), 0.1f, cosf(fTime*0.1f) );
m_fSphereSpin = fTime;
g_Music.HandleNotifies();
return S_OK;
}
//-----------------------------------------------------------------------------
// Name: RenderFlock()
// Desc:
//-----------------------------------------------------------------------------
HRESULT CMyD3DApplication::RenderFlock()
{
// Set the view and projection matrices
m_pd3dDevice->SetTransform( D3DTS_VIEW, &m_matView );
m_pd3dDevice->SetTransform( D3DTS_PROJECTION, &m_matProj );
// Draw ground grid
m_pd3dDevice->SetMaterial( &m_mtrlGrid );
for (int dx= -2; dx<3; dx++)
{
for (int dz= -2; dz<3; dz++)
{
D3DXMatrixTranslation( &m_matWorld, dx*80.0f, 0.0f, dz*80.0f );
m_pd3dDevice->SetTransform( D3DTS_WORLD, &m_matWorld );
m_pd3dDevice->SetVertexShader( D3DFVF_GRIDVERTEX );
m_pd3dDevice->DrawPrimitiveUP( D3DPT_LINESTRIP, 24, m_vGridPattern1,
sizeof(GRIDVERTEX) );
m_pd3dDevice->DrawPrimitiveUP( D3DPT_LINESTRIP, 8, m_vGridPattern2,
sizeof(GRIDVERTEX) );
}
}
// Draw the boids
for( DWORD i=0; i<m_Flock.m_dwNumBoids; i++ )
{
// Most of the time display the boid
if( i%13 || m_d3dCaps.DeviceType == D3DDEVTYPE_REF )
{
// Set the boid's world matrix
m_pd3dDevice->SetTransform( D3DTS_WORLD, &m_Flock.m_Boids[i].matWorld );
// Set the boid's color
m_mtrlBoid.Diffuse.r = m_Flock.m_Boids[i].color.x;
m_mtrlBoid.Diffuse.g = m_Flock.m_Boids[i].color.y;
m_mtrlBoid.Diffuse.b = m_Flock.m_Boids[i].color.z;
m_pd3dDevice->SetMaterial( &m_mtrlBoid );
// Render the boid
m_pd3dDevice->SetVertexShader( D3DFVF_BOIDVERTEX );
m_pd3dDevice->SetStreamSource( 0, m_pBoidVB, sizeof(BOIDVERTEX) );
m_pd3dDevice->SetIndices( m_pBoidIB, 0L );
m_pd3dDevice->DrawIndexedPrimitive( D3DPT_TRIANGLELIST,
0, m_dwNumBoidVertices,
0, m_dwNumBoidIndices/3 );
}
else
{
// Set the matrix
D3DXMATRIX matWorld, matRotateY;
D3DXMatrixRotationY( &matRotateY, D3DX_PI );
D3DXMatrixMultiply( &matWorld, &matRotateY, &m_Flock.m_Boids[i].matWorld );
m_pd3dDevice->SetTransform( D3DTS_WORLD, &matWorld );
// Display a seagull
m_pSeaGull->Render( m_pd3dDevice );
}
}
for( i=0; i<m_Flock.m_dwNumObstacles; i++ )
{
D3DXMATRIX matRotate, matScale;
FLOAT fScale = m_Flock.m_Obstacles[i].fRadius;
D3DXMatrixRotationY( &matRotate, m_fSphereSpin );
D3DXMatrixScaling( &matScale, fScale, fScale, fScale );
D3DXMatrixMultiply( &m_matWorld, &matScale, &matRotate );
m_matWorld._41 = m_Flock.m_Obstacles[i].vPos.x;
m_matWorld._42 = m_Flock.m_Obstacles[i].vPos.y;
m_matWorld._43 = m_Flock.m_Obstacles[i].vPos.z;
m_pd3dDevice->SetTransform( D3DTS_WORLD, &m_matWorld );
m_pSphere->Render( m_pd3dDevice );
}
return S_OK;
}
//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
HRESULT CMyD3DApplication::Render()
{
// Clear the scene to black
m_pd3dDevice->Clear( 0L, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER,
0x00000000, 1.0f, 0L );
// Begin Scene
if( FAILED( m_pd3dDevice->BeginScene() ) )
return S_OK;
RenderFlock();
m_pd3dDevice->EndScene();
return S_OK;
}
//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
HRESULT CMyD3DApplication::InitDeviceObjects()
{
if( FAILED( m_pSphere->Create( m_pd3dDevice, _T("orbiter.x") ) ) )
return D3DAPPERR_MEDIANOTFOUND;
if( FAILED( m_pSeaGull->Create( m_pd3dDevice, _T("Shusui.x") ) ) )
return D3DAPPERR_MEDIANOTFOUND;
// Create a VB for the boids
if( FAILED( m_pd3dDevice->CreateVertexBuffer( m_dwNumBoidVertices*sizeof(BOIDVERTEX),
D3DUSAGE_WRITEONLY, D3DFVF_BOIDVERTEX,
D3DPOOL_MANAGED, &m_pBoidVB ) ) )
return E_FAIL;
BOIDVERTEX* v;
m_pBoidVB->Lock( 0, 0, (BYTE**)&v, 0 );
memcpy( v, m_vBoidVertices, m_dwNumBoidVertices*sizeof(BOIDVERTEX) );
m_pBoidVB->Unlock();
// Create an IB for the boids
if( FAILED( m_pd3dDevice->CreateIndexBuffer( m_dwNumBoidIndices*sizeof(WORD),
D3DUSAGE_WRITEONLY, D3DFMT_INDEX16,
D3DPOOL_MANAGED, &m_pBoidIB ) ) )
return E_FAIL;
WORD* i;
m_pBoidIB->Lock( 0, 0, (BYTE**)&i, 0 );
memcpy( i, m_wBoidIndices, m_dwNumBoidIndices*sizeof(WORD) );
m_pBoidIB->Unlock();
return S_OK;
}
//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
HRESULT CMyD3DApplication::RestoreDeviceObjects()
{
m_pSphere->RestoreDeviceObjects( m_pd3dDevice );
m_pSeaGull->RestoreDeviceObjects( m_pd3dDevice );
// Set up transform matrices
D3DXVECTOR3 vEyePt = D3DXVECTOR3( 0.0f, 0.0f, -100.0f );
D3DXVECTOR3 vLookAtPt = D3DXVECTOR3( 0.0f, 0.0f, 0.0f );
D3DXVECTOR3 vUp = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
D3DXMatrixIdentity( &m_matWorld );
D3DXMatrixLookAtLH( &m_matView, &vEyePt, &vLookAtPt, &vUp );
D3DXMatrixPerspectiveFovLH( &m_matProj, D3DX_PI/4, 1.0f, 5.0f, 400.0f );
// Setup materials
D3DUtil_InitMaterial( m_mtrlBackground, 0.0f, 0.0f, 0.0f );
D3DUtil_InitMaterial( m_mtrlGrid, 0.0f, 0.0f, 0.0f );
m_mtrlGrid.Emissive.r = 0.0f;
m_mtrlGrid.Emissive.g = 0.3f;
m_mtrlGrid.Emissive.b = 0.5f;
D3DUtil_InitMaterial( m_mtrlBoid, 1.0f, 1.0f, 1.0f );
// Create 2 lights
D3DUtil_InitLight( m_Light1, D3DLIGHT_DIRECTIONAL, -0.5f, -1.0f, -0.3f );
D3DUtil_InitLight( m_Light2, D3DLIGHT_DIRECTIONAL, 0.5f, 1.0f, 0.3f );
m_Light2.Diffuse.r = 0.5f;
m_Light2.Diffuse.g = 0.5f;
m_Light2.Diffuse.b = 0.5f;
m_pd3dDevice->SetLight( 0, &m_Light1 );
m_pd3dDevice->SetLight( 1, &m_Light2 );
m_pd3dDevice->LightEnable( 0, TRUE );
m_pd3dDevice->LightEnable( 1, TRUE );
// Set render state
m_pd3dDevice->SetRenderState( D3DRS_SPECULARENABLE, FALSE );
m_pd3dDevice->SetRenderState( D3DRS_ZENABLE, TRUE );
m_pd3dDevice->SetRenderState( D3DRS_DITHERENABLE, TRUE );
m_pd3dDevice->SetRenderState( D3DRS_AMBIENT, 0x11111111 );
return S_OK;
}
//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
HRESULT CMyD3DApplication::InvalidateDeviceObjects()
{
m_pSphere->InvalidateDeviceObjects();
m_pSeaGull->InvalidateDeviceObjects();
return S_OK;
}
//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
HRESULT CMyD3DApplication::DeleteDeviceObjects()
{
m_pSphere->Destroy();
m_pSeaGull->Destroy();
SAFE_RELEASE( m_pBoidVB );
SAFE_RELEASE( m_pBoidIB );
return S_OK;
}
//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
HRESULT CMyD3DApplication::FinalCleanup()
{
for( int i=0; i<NUM_BOIDS; i++ )
{
SAFE_DELETE_ARRAY( m_Flock.m_afDist[i] );
}
SAFE_DELETE_ARRAY( m_Flock.m_Boids );
SAFE_DELETE_ARRAY( m_Flock.m_afDist );
SAFE_DELETE_ARRAY( m_Flock.m_Obstacles );
SAFE_DELETE( m_pSphere );
SAFE_DELETE( m_pSeaGull );
g_Music.EndMusic();
return S_OK;
}
//-----------------------------------------------------------------------------
// Name: MsgProc()
// Desc: Message proc function to handle key and menu input
//-----------------------------------------------------------------------------
LRESULT CMyD3DApplication::MsgProc( HWND hWnd, UINT uMsg, WPARAM wParam,
LPARAM lParam )
{
// Handle menu commands
if( WM_KEYDOWN==uMsg || WM_KEYUP==uMsg )
{
switch( wParam )
{
case 'A':
g_bAlignment = (WM_KEYDOWN==uMsg);
break;
case 'C':
g_bCohesion = (WM_KEYDOWN==uMsg);
break;
case 'O':
g_bObstacle = (WM_KEYDOWN==uMsg);
break;
case 'M':
g_bMigratory = (WM_KEYDOWN==uMsg);
if( g_bMigratory )
g_Music.Migrate();
break;
case 'S':
g_bSeparation = (WM_KEYDOWN==uMsg);
if( g_bSeparation )
g_Music.Collapse();
else
g_Music.Expand();
break;
}
}
else if( WM_ACTIVATE==uMsg )
{
g_Music.Activate( LOWORD( wParam ) != WA_INACTIVE );
}
// Pass remaining messages to default handler
return CD3DApplication::MsgProc( hWnd, uMsg, wParam, lParam );
}