Engine source until now:
;)
;)
#include "dxstdafx.h" #include "resource.h" ID3DXFont* g_pFont = NULL; // Font for drawing text ID3DXSprite* g_pTextSprite = NULL; // Sprite for batching draw text calls bool g_bShowHelp = true; // If true, it renders the UI control text CDXUTDialogResourceManager g_DialogResourceManager; // manager for shared resources of dialogs CD3DSettingsDlg g_SettingsDlg; // Device settings dialog CDXUTDialog g_HUD; // dialog for standard controls LPDIRECT3D9 D3D = NULL; LPDIRECT3DDEVICE9 Device = NULL; LPDIRECT3DSURFACE9 BackBuffer= NULL; struct D3DVERTEX { D3DXVECTOR3 p; D3DXVECTOR3 n; DWORD c; FLOAT tu, tv; static const DWORD FVF; }; const DWORD D3DVERTEX::FVF = D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_DIFFUSE | D3DFVF_TEX1; struct CAMERA { int ViewportX; int ViewportY; int ViewportWidth; int ViewportHeight; float ViewportN; float ViewportF; LPDIRECT3DSURFACE9 RenderTarget; char ClsColorR; char ClsColorG; char ClsColorB; D3DXMATRIXA16 ProjMatrix; }; struct MESH { CDXUTMesh Mesh; CDXUTMeshFrame MeshFrame; D3DMATERIAL9* Materials; LPDIRECT3DTEXTURE9* Textures; }; struct ENTITY { float px; float py; float pz; float rx; float ry; float rz; float sx; float sy; float sz; int Parent; char Class; CAMERA CPTR; MESH MPTR; }; ENTITY Entity[100000]; int EntityCNT = 0; int D3DWIDTH; int D3DHEIGHT; #define IDC_TOGGLEFULLSCREEN 1 #define IDC_TOGGLEREF 3 #define IDC_CHANGEDEVICE 4 bool CALLBACK IsDeviceAcceptable( D3DCAPS9* pCaps, D3DFORMAT AdapterFormat, D3DFORMAT BackBufferFormat, bool bWindowed, void* pUserContext ); bool CALLBACK ModifyDeviceSettings( DXUTDeviceSettings* pDeviceSettings, const D3DCAPS9* pCaps, void* pUserContext ); HRESULT CALLBACK OnCreateDevice( IDirect3DDevice9* pd3dDevice, const D3DSURFACE_DESC* pBackBufferSurfaceDesc, void* pUserContext ); HRESULT CALLBACK OnResetDevice( IDirect3DDevice9* pd3dDevice, const D3DSURFACE_DESC* pBackBufferSurfaceDesc, void* pUserContext ); void CALLBACK OnFrameMove( IDirect3DDevice9* pd3dDevice, double fTime, float fElapsedTime, void* pUserContext ); void CALLBACK OnFrameRender( IDirect3DDevice9* pd3dDevice, double fTime, float fElapsedTime, void* pUserContext ); LRESULT CALLBACK MsgProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, bool* pbNoFurtherProcessing, void* pUserContext ); void CALLBACK KeyboardProc( UINT nChar, bool bKeyDown, bool bAltDown, void* pUserContext ); void CALLBACK OnGUIEvent( UINT nEvent, int nControlID, CDXUTControl* pControl, void* pUserContext ); void CALLBACK OnLostDevice( void* pUserContext ); void CALLBACK OnDestroyDevice( void* pUserContext ); void InitApp(); void RenderText(double fTime); BOOL APIENTRY DllMain( HANDLE hModule, DWORD ul_reason_for_call, LPVOID lpReserved ) { return TRUE; } #define BBDECL extern "C" _declspec(dllexport) #define BBCALL _stdcall BBDECL int BBCALL Graphics3D( int w, int h, int d, int m ) { // Enable run-time memory check for debug builds. #if defined(DEBUG) | defined(_DEBUG) _CrtSetDbgFlag( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF ); #endif DXUTSetCallbackDeviceCreated( OnCreateDevice ); DXUTSetCallbackDeviceReset( OnResetDevice ); DXUTSetCallbackDeviceLost( OnLostDevice ); DXUTSetCallbackDeviceDestroyed( OnDestroyDevice ); DXUTSetCallbackMsgProc( MsgProc ); DXUTSetCallbackKeyboard( KeyboardProc ); DXUTSetCallbackFrameRender( OnFrameRender ); DXUTSetCallbackFrameMove( OnFrameMove ); // Show the cursor and clip it when in full screen DXUTSetCursorSettings( true, true ); InitApp(); bool Windowed; switch (m) { case 1: Windowed = false; case 2: Windowed = true; default: Windowed = true; } // Initialize DXUT and create the desired Win32 window and Direct3D // device for the application. Calling each of these functions is optional, but they // allow you to set several options which control the behavior of the framework. DXUTInit( true, true, true ); // Parse the command line, handle the default hotkeys, and show msgboxes DXUTCreateWindow( L"Nexus 3D Engine" ); DXUTDeviceSettings Settings; D3DPRESENT_PARAMETERS d3dpp; ZeroMemory( &d3dpp, sizeof(d3dpp) ); d3dpp.Windowed = Windowed; d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD; d3dpp.BackBufferFormat = D3DFMT_UNKNOWN; d3dpp.EnableAutoDepthStencil = TRUE; d3dpp.AutoDepthStencilFormat = D3DFMT_D16; d3dpp.BackBufferWidth = w; d3dpp.BackBufferHeight = h; Settings.AdapterFormat = D3DFMT_A8R8G8B8; Settings.AdapterOrdinal = D3DADAPTER_DEFAULT; Settings.BehaviorFlags = D3DCREATE_HARDWARE_VERTEXPROCESSING | D3DCREATE_PUREDEVICE; Settings.DeviceType = D3DDEVTYPE_HAL; Settings.pp = d3dpp; DXUTCreateDeviceFromSettings( &Settings ); Device = DXUTGetD3DDevice(); D3DWIDTH = w; D3DHEIGHT = h; return DXUTGetExitCode(); } //-------------------------------------------------------------------------------------- // Initialize the app //-------------------------------------------------------------------------------------- void InitApp() { // Initialize dialogs g_SettingsDlg.Init( &g_DialogResourceManager ); g_HUD.Init( &g_DialogResourceManager ); g_HUD.SetCallback( OnGUIEvent ); int iY = 10; g_HUD.AddButton( IDC_TOGGLEFULLSCREEN, L"Toggle full screen", 35, iY, 125, 22 ); g_HUD.AddButton( IDC_TOGGLEREF, L"Toggle REF (F3)", 35, iY += 24, 125, 22 ); g_HUD.AddButton( IDC_CHANGEDEVICE, L"Change device (F2)", 35, iY += 24, 125, 22, VK_F2 ); } //-------------------------------------------------------------------------------------- // Called during device initialization, this code checks the device for some // minimum set of capabilities, and rejects those that don't pass by returning false. //-------------------------------------------------------------------------------------- bool CALLBACK IsDeviceAcceptable( D3DCAPS9* pCaps, D3DFORMAT AdapterFormat, D3DFORMAT BackBufferFormat, bool bWindowed, void* pUserContext ) { // Skip backbuffer formats that don't support alpha blending IDirect3D9* pD3D = DXUTGetD3DObject(); if( FAILED( pD3D->CheckDeviceFormat( pCaps->AdapterOrdinal, pCaps->DeviceType, AdapterFormat, D3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING, D3DRTYPE_TEXTURE, BackBufferFormat ) ) ) return false; return true; } //-------------------------------------------------------------------------------------- // This callback function is called immediately before a device is created to allow the // application to modify the device settings. The supplied pDeviceSettings parameter // contains the settings that the framework has selected for the new device, and the // application can make any desired changes directly to this structure. Note however that // DXUT will not correct invalid device settings so care must be taken // to return valid device settings, otherwise IDirect3D9::CreateDevice() will fail. //-------------------------------------------------------------------------------------- bool CALLBACK ModifyDeviceSettings( DXUTDeviceSettings* pDeviceSettings, const D3DCAPS9* pCaps, void* pUserContext ) { // If device doesn't support HW T&L or doesn't support 1.1 vertex shaders in HW // then switch to SWVP. if( (pCaps->DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT) == 0 || pCaps->VertexShaderVersion < D3DVS_VERSION(1,1) ) { pDeviceSettings->BehaviorFlags = D3DCREATE_SOFTWARE_VERTEXPROCESSING; } // Debugging vertex shaders requires either REF or software vertex processing // and debugging pixel shaders requires REF. #ifdef DEBUG_VS if( pDeviceSettings->DeviceType != D3DDEVTYPE_REF ) { pDeviceSettings->BehaviorFlags &= ~D3DCREATE_HARDWARE_VERTEXPROCESSING; pDeviceSettings->BehaviorFlags &= ~D3DCREATE_PUREDEVICE; pDeviceSettings->BehaviorFlags |= D3DCREATE_SOFTWARE_VERTEXPROCESSING; } #endif #ifdef DEBUG_PS pDeviceSettings->DeviceType = D3DDEVTYPE_REF; #endif // For the first device created if its a REF device, optionally display a warning dialog box static bool s_bFirstTime = true; if( s_bFirstTime ) { s_bFirstTime = false; if( pDeviceSettings->DeviceType == D3DDEVTYPE_REF ) DXUTDisplaySwitchingToREFWarning(); } return true; } //-------------------------------------------------------------------------------------- // This callback function will be called immediately after the Direct3D device has been // created, which will happen during application initialization and windowed/full screen // toggles. This is the best location to create D3DPOOL_MANAGED resources since these // resources need to be reloaded whenever the device is destroyed. Resources created // here should be released in the OnDestroyDevice callback. //-------------------------------------------------------------------------------------- HRESULT CALLBACK OnCreateDevice( IDirect3DDevice9* pd3dDevice, const D3DSURFACE_DESC* pBackBufferSurfaceDesc, void* pUserContext ) { HRESULT hr; V_RETURN( g_DialogResourceManager.OnCreateDevice( pd3dDevice ) ); V_RETURN( g_SettingsDlg.OnCreateDevice( pd3dDevice ) ); // Initialize the font V_RETURN( D3DXCreateFont( pd3dDevice, 15, 0, FW_BOLD, 1, FALSE, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE, L"Verdana", &g_pFont ) ); // Setup the camera's view parameters //g_Camera.SetViewQuat( D3DXQUATERNION(-4.275f, 0.3f, 0.0f, 0.7f) ); return S_OK; } //-------------------------------------------------------------------------------------- // This callback function will be called immediately after the Direct3D device has been // reset, which will happen after a lost device scenario. This is the best location to // create D3DPOOL_DEFAULT resources since these resources need to be reloaded whenever // the device is lost. Resources created here should be released in the OnLostDevice // callback. //-------------------------------------------------------------------------------------- HRESULT CALLBACK OnResetDevice( IDirect3DDevice9* pd3dDevice, const D3DSURFACE_DESC* pBackBufferSurfaceDesc, void* pUserContext ) { HRESULT hr; V_RETURN( g_DialogResourceManager.OnResetDevice() ); V_RETURN( g_SettingsDlg.OnResetDevice() ); if( g_pFont ) V_RETURN( g_pFont->OnResetDevice() ); // Create a sprite to help batch calls when drawing many lines of text V_RETURN( D3DXCreateSprite( pd3dDevice, &g_pTextSprite ) ); // Setup render states pd3dDevice->SetRenderState( D3DRS_LIGHTING, FALSE ); //pd3dDevice->SetRenderState( D3DRS_CULLMODE, D3DCULL_ ); // Setup the camera's projection parameters float fAspectRatio = pBackBufferSurfaceDesc->Width / (FLOAT)pBackBufferSurfaceDesc->Height; g_HUD.SetLocation( pBackBufferSurfaceDesc->Width-170, 0 ); g_HUD.SetSize( 170, 170 ); return S_OK; } //-------------------------------------------------------------------------------------- // This callback function will be called once at the beginning of every frame. This is the // best location for your application to handle updates to the scene, but is not // intended to contain actual rendering calls, which should instead be placed in the // OnFrameRender callback. //-------------------------------------------------------------------------------------- void CALLBACK OnFrameMove( IDirect3DDevice9* pd3dDevice, double fTime, float fElapsedTime, void* pUserContext ) { } //-------------------------------------------------------------------------------------- // This callback function will be called at the end of every frame to perform all the // rendering calls for the scene, and it will also be called if the window needs to be // repainted. After this function has returned, DXUT will call // IDirect3DDevice9::Present to display the contents of the next buffer in the swap chain //-------------------------------------------------------------------------------------- void CALLBACK OnFrameRender( IDirect3DDevice9* pd3dDevice, double fTime, float fElapsedTime, void* pUserContext ) { HRESULT hr; D3DVIEWPORT9 View; D3DVIEWPORT9 OldView; D3DRECT Rect; D3DXMATRIXA16 Matrix; D3DXMATRIXA16 Matrix2; // If the settings dialog is being shown, then // render it instead of rendering the app's scene if( g_SettingsDlg.IsActive() ) { g_SettingsDlg.OnRender( fElapsedTime ); return; } Device->GetViewport(&OldView); Device->Clear( 0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER, D3DCOLOR_XRGB(0,0,0), 1000.0f, 0 ); for (int i=1; i<=EntityCNT; i++) { if (Entity[i].Class == 1) { View.X = Entity[i].CPTR.ViewportX; View.Y = Entity[i].CPTR.ViewportY; View.Width = Entity[i].CPTR.ViewportWidth; View.Height = Entity[i].CPTR.ViewportHeight; View.MinZ = Entity[i].CPTR.ViewportN; View.MaxZ = Entity[i].CPTR.ViewportF; Rect.x1 = Entity[i].CPTR.ViewportX; Rect.y1 = Entity[i].CPTR.ViewportY; Rect.x2 = Entity[i].CPTR.ViewportX + Entity[i].CPTR.ViewportWidth; Rect.y2 = Entity[i].CPTR.ViewportY + Entity[i].CPTR.ViewportHeight; //Device->SetRenderTarget(0,Entity[i].CPTR.RenderTarget); Device->SetViewport(&View); Device->Clear( 1, &Rect, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER, D3DCOLOR_XRGB(Entity[i].CPTR.ClsColorR,Entity[i].CPTR.ClsColorG,Entity[i].CPTR.ClsColorB), 1000.0f, 0 ); if( SUCCEEDED( pd3dDevice->BeginScene() ) ) { D3DXMatrixScaling(&Matrix,Entity[i].sx,Entity[i].sy,Entity[i].sz); D3DXMatrixTranslation(&Matrix2,-Entity[i].px,-Entity[i].py,-Entity[i].pz); D3DXMatrixMultiply(&Matrix,&Matrix,&Matrix2); D3DXMatrixRotationYawPitchRoll(&Matrix2,-Entity[i].ry,-Entity[i].rx,-Entity[i].rz); D3DXMatrixMultiply(&Matrix,&Matrix,&Matrix2); Device->SetTransform( D3DTS_VIEW, &Matrix ); Device->SetTransform( D3DTS_PROJECTION, &Entity[i].CPTR.ProjMatrix ); for (int cnt=1; cnt<=EntityCNT; cnt++) { if (Entity[cnt].Class == 2) { D3DXMatrixScaling(&Matrix,Entity[cnt].sx,Entity[cnt].sy,Entity[cnt].sz); D3DXMatrixTranslation(&Matrix2,Entity[cnt].px,Entity[cnt].py,Entity[cnt].pz); D3DXMatrixMultiply(&Matrix,&Matrix,&Matrix2); D3DXMatrixRotationYawPitchRoll(&Matrix2,Entity[cnt].ry,Entity[cnt].rx,Entity[cnt].rz); D3DXMatrixMultiply(&Matrix,&Matrix2,&Matrix); Device->SetTransform( D3DTS_WORLD, &Matrix ); Entity[cnt].MPTR.Mesh.Render(Device); } } Device->SetViewport(&OldView); RenderText(fTime); V( g_HUD.OnRender( fElapsedTime ) ); V( pd3dDevice->EndScene() ); } } } } //-------------------------------------------------------------------------------------- // Render the help and statistics text. This function uses the ID3DXFont interface for // efficient text rendering. //-------------------------------------------------------------------------------------- void RenderText(double fTime) { // The helper object simply helps keep track of text position, and color // and then it calls pFont->DrawText( g_pSprite, strMsg, -1, &rc, DT_NOCLIP, g_clr ); // If NULL is passed in as the sprite object, then it will work however the // pFont->DrawText() will not be batched together. Batching calls will improves performance. CDXUTTextHelper txtHelper( g_pFont, g_pTextSprite, 15 ); // Output statistics txtHelper.Begin(); txtHelper.SetInsertionPos( 5, 5 ); txtHelper.SetForegroundColor( D3DXCOLOR( 1.0f, 1.0f, 0.0f, 1.0f ) ); txtHelper.DrawTextLine( DXUTGetFrameStats(true) ); txtHelper.DrawTextLine( DXUTGetDeviceStats() ); txtHelper.SetForegroundColor( D3DXCOLOR( 1.0f, 1.0f, 1.0f, 1.0f ) ); txtHelper.SetForegroundColor( D3DXCOLOR( 1.0f, 1.0f, 1.0f, 1.0f ) ); txtHelper.DrawFormattedTextLine( L"fTime: %0.1f Tris Rendered: %i Faces", fTime, Entity[3].MPTR.Mesh.m_dwNumFaces ); // Draw help if( g_bShowHelp ) { const D3DSURFACE_DESC* pd3dsdBackBuffer = DXUTGetBackBufferSurfaceDesc(); txtHelper.SetInsertionPos( 10, pd3dsdBackBuffer->Height-15*6 ); txtHelper.SetForegroundColor( D3DXCOLOR( 1.0f, 0.75f, 0.0f, 1.0f ) ); txtHelper.DrawTextLine( L"Controls (F1 to hide):" ); txtHelper.SetInsertionPos( 40, pd3dsdBackBuffer->Height-15*5 ); txtHelper.DrawTextLine( L"Rotate model: Left mouse button\n" L"Rotate camera: Right mouse button\n" L"Zoom camera: Mouse wheel scroll\n" L"Hide help: F1" ); } else { txtHelper.SetForegroundColor( D3DXCOLOR( 1.0f, 1.0f, 1.0f, 1.0f ) ); txtHelper.DrawTextLine( L"Press F1 for help" ); } txtHelper.End(); } //-------------------------------------------------------------------------------------- // Before handling window messages, DXUT passes incoming windows // messages to the application through this callback function. If the application sets // *pbNoFurtherProcessing to TRUE, then DXUT will not process this message. //-------------------------------------------------------------------------------------- LRESULT CALLBACK MsgProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, bool* pbNoFurtherProcessing, void* pUserContext ) { // Always allow dialog resource manager calls to handle global messages // so GUI state is updated correctly *pbNoFurtherProcessing = g_DialogResourceManager.MsgProc( hWnd, uMsg, wParam, lParam ); if( *pbNoFurtherProcessing ) return 0; if( g_SettingsDlg.IsActive() ) { g_SettingsDlg.MsgProc( hWnd, uMsg, wParam, lParam ); return 0; } // Give the dialogs a chance to handle the message first *pbNoFurtherProcessing = g_HUD.MsgProc( hWnd, uMsg, wParam, lParam ); if( *pbNoFurtherProcessing ) return 0; // Pass all remaining windows messages to camera so it can respond to user input return 0; } //-------------------------------------------------------------------------------------- // As a convenience, DXUT inspects the incoming windows messages for // keystroke messages and decodes the message parameters to pass relevant keyboard // messages to the application. The framework does not remove the underlying keystroke // messages, which are still passed to the application's MsgProc callback. //-------------------------------------------------------------------------------------- void CALLBACK KeyboardProc( UINT nChar, bool bKeyDown, bool bAltDown, void* pUserContext ) { if( bKeyDown ) { switch( nChar ) { case VK_F1: g_bShowHelp = !g_bShowHelp; break; } } } //-------------------------------------------------------------------------------------- // Handles the GUI events //-------------------------------------------------------------------------------------- void CALLBACK OnGUIEvent( UINT nEvent, int nControlID, CDXUTControl* pControl, void* pUserContext ) { switch( nControlID ) { case IDC_TOGGLEFULLSCREEN: DXUTToggleFullScreen(); break; case IDC_TOGGLEREF: DXUTToggleREF(); break; case IDC_CHANGEDEVICE: g_SettingsDlg.SetActive( !g_SettingsDlg.IsActive() ); break; } } //-------------------------------------------------------------------------------------- // This callback function will be called immediately after the Direct3D device has // entered a lost state and before IDirect3DDevice9::Reset is called. Resources created // in the OnResetDevice callback should be released here, which generally includes all // D3DPOOL_DEFAULT resources. See the "Lost Devices" section of the documentation for // information about lost devices. //-------------------------------------------------------------------------------------- void CALLBACK OnLostDevice( void* pUserContext ) { g_DialogResourceManager.OnLostDevice(); g_SettingsDlg.OnLostDevice(); if( g_pFont ) g_pFont->OnLostDevice(); SAFE_RELEASE( g_pTextSprite ); } //-------------------------------------------------------------------------------------- // This callback function will be called immediately after the Direct3D device has // been destroyed, which generally happens as a result of application termination or // windowed/full screen toggles. Resources created in the OnCreateDevice callback // should be released here, which generally includes all D3DPOOL_MANAGED resources. //-------------------------------------------------------------------------------------- void CALLBACK OnDestroyDevice( void* pUserContext ) { g_DialogResourceManager.OnDestroyDevice(); g_SettingsDlg.OnDestroyDevice(); SAFE_RELEASE( g_pFont ); for (int i=0;i<=EntityCNT;i++) { if (Entity[i].Class == 2) { Entity[i].MPTR.Mesh.Destroy(); //Entity[i].MPTR.Mesh->Release(); } } } BBDECL int BBCALL RenderWorld() { if (SUCCEEDED(DXUTIsActive())) { DXUTRender3DEnvironment(); return 1; } return 0; } BBDECL int BBCALL CameraClsColor( int PTR, int r, int g, int b ) { Entity[PTR].CPTR.ClsColorR = r; Entity[PTR].CPTR.ClsColorG = g; Entity[PTR].CPTR.ClsColorB = b; return 1; } BBDECL int BBCALL CameraViewport( int PTR, int x, int y, int w, int h ) { Entity[PTR].CPTR.ViewportX = x; Entity[PTR].CPTR.ViewportY = y; Entity[PTR].CPTR.ViewportWidth = w; Entity[PTR].CPTR.ViewportHeight = h; return 1; } BBDECL int BBCALL CreateCamera() { EntityCNT = EntityCNT + 1; Entity[EntityCNT].Class = 1; Entity[EntityCNT].CPTR.ClsColorR = 0; Entity[EntityCNT].CPTR.ClsColorG = 0; Entity[EntityCNT].CPTR.ClsColorB = 0; Entity[EntityCNT].CPTR.RenderTarget = BackBuffer; Entity[EntityCNT].CPTR.ViewportX = 0; Entity[EntityCNT].CPTR.ViewportY = 0; Entity[EntityCNT].CPTR.ViewportWidth = D3DWIDTH; Entity[EntityCNT].CPTR.ViewportHeight = D3DHEIGHT; Entity[EntityCNT].CPTR.ViewportN = 0.0f; Entity[EntityCNT].CPTR.ViewportF = 1.0f; D3DXMatrixPerspectiveFovLH( &Entity[EntityCNT].CPTR.ProjMatrix, D3DX_PI/2.5f, 1.5f, 1.0f, 100.0f ); Entity[EntityCNT].sx = 1.0f; Entity[EntityCNT].sy = 1.0f; Entity[EntityCNT].sz = 1.0f; return EntityCNT; } BBDECL int BBCALL LoadMesh(char* fName) { //LPD3DXBUFFER D3DXMtrlBuffer; size_t origsize = strlen(fName) + 1; const size_t newsize = 100; size_t convertedChars = 0; wchar_t wcstring[newsize]; mbstowcs_s(&convertedChars, wcstring, origsize, fName, _TRUNCATE); EntityCNT = EntityCNT + 1; Entity[EntityCNT].sx = 1.0f; Entity[EntityCNT].sy = 1.0f; Entity[EntityCNT].sz = 1.0f; if ( FAILED(Entity[EntityCNT].MPTR.Mesh.Create(Device,wcstring))) { EntityCNT = EntityCNT - 1; return 0; } // Entity[EntityCNT].MPTR.Mesh.UseMeshMaterials(true); //D3DXMtrlBuffer->Release(); Entity[EntityCNT].Class = 2; return EntityCNT; } BBDECL char* BBCALL EntityClass(int PTR) { switch (Entity[PTR].Class) { case 1: return "Camera"; case 2: return "Mesh"; case 3: return "Light"; default: return ""; } return ""; } BBDECL void BBCALL PositionEntity(int PTR, float x, float y, float z) { Entity[PTR].px = x; Entity[PTR].py = y; Entity[PTR].pz = z; } BBDECL int BBCALL ScaleEntity(int PTR, float x, float y, float z) { Entity[PTR].sx = x; Entity[PTR].sy = y; Entity[PTR].sz = z; return 1; } BBDECL int BBCALL RotateEntity(int PTR, float x, float y, float z) { Entity[PTR].rx = x * (D3DX_PI / 180.0f); Entity[PTR].ry = y * (D3DX_PI / 180.0f); Entity[PTR].rz = z * (D3DX_PI / 180.0f); return 1; } BBDECL int BBCALL PointEntity(int PTR, int ENT) { D3DXMATRIXA16 Mat; D3DXVECTOR3 vEyePt( Entity[PTR].px, Entity[PTR].py, Entity[PTR].pz ); D3DXVECTOR3 vLookatPt( Entity[ENT].px, Entity[ENT].py, Entity[ENT].pz ); D3DXVECTOR3 vUpVec( 0.0f, 1.0f, 0.0f ); D3DXVECTOR3 Pos; D3DXQUATERNION Rot; D3DXVECTOR3 Scale; D3DXMatrixLookAtLH( &Mat, &vEyePt, &vLookatPt, &vUpVec ); D3DXMatrixDecompose(&Scale,&Rot,&Pos,&Mat); Entity[PTR].rx = Rot.x; Entity[PTR].ry = Rot.y; return 1; } BBDECL float BBCALL EntityPitch(int PTR) {return D3DXToDegree(Entity[PTR].rx);} BBDECL float BBCALL EntityYaw(int PTR) {return D3DXToDegree(Entity[PTR].ry);} BBDECL float BBCALL EntityRoll(int PTR) {return D3DXToDegree(Entity[PTR].rz);} BBDECL float BBCALL EntityX(int PTR) {return Entity[PTR].px;} BBDECL float BBCALL EntityY(int PTR) {return Entity[PTR].py;} BBDECL float BBCALL EntityZ(int PTR) {return Entity[PTR].pz;}