1501 lines
58 KiB
C++
1501 lines
58 KiB
C++
/*****************************************************************************\
|
|
FILE: room.cpp
|
|
|
|
DESCRIPTION:
|
|
|
|
BryanSt 12/24/2000
|
|
Copyright (C) Microsoft Corp 2000-2001. All rights reserved.
|
|
\*****************************************************************************/
|
|
|
|
#include "stdafx.h"
|
|
|
|
#include "main.h"
|
|
#include "room.h"
|
|
#include "util.h"
|
|
|
|
|
|
// Ref-counting on the room tree is involved because it's a doubly linked tree with the root node constantly changing, so
|
|
// we need this mechanism to make sure we get the ref-count correct and don't leak.
|
|
int g_nLeakCheck = 0;
|
|
|
|
float g_fRoomWidthX = 100.0f;
|
|
float g_fRoomDepthZ = 200.0f;
|
|
float g_fRoomHeightY = 40.0f;
|
|
|
|
float g_fPaintingHeightY = (g_fRoomHeightY * SIZE_MAXPAINTINGSIZE_INWALLPERCENT); // This is how much of the wall we want the painting to take up.
|
|
|
|
float g_fFudge = 0.1f; // This will cause one object to be above another.
|
|
|
|
#define MAX_ROOMWALK_PATHS 2
|
|
|
|
#define NORMAL_NEG_Z D3DXVECTOR3(0, 0, -1)
|
|
#define NORMAL_NEG_Y D3DXVECTOR3(0, -1, 0)
|
|
#define NORMAL_NEG_X D3DXVECTOR3(-1, 0, 0)
|
|
|
|
#define NORMAL_Z D3DXVECTOR3(0, 0, 1)
|
|
#define NORMAL_Y D3DXVECTOR3(0, 1, 0)
|
|
#define NORMAL_X D3DXVECTOR3(1, 0, 0)
|
|
|
|
#define NORMAL_NEG_Z D3DXVECTOR3(0, 0, -1)
|
|
#define NORMAL_NEG_Z D3DXVECTOR3(0, 0, -1)
|
|
|
|
|
|
PAINTING_LAYOUT g_LongRoomPaintings1[6]; // Both doors exist (1 & 2)
|
|
|
|
PAINTING_LAYOUT g_LongRoomPaintings2[7]; // Doors 0 & 1 exist (Must exit 1)
|
|
PAINTING_LAYOUT g_LongRoomPaintings3[7]; // Doors 0 & 1 exist (Must exit 2)
|
|
|
|
|
|
|
|
ROOM_FLOORPLANS g_RoomFloorPlans[] =
|
|
{
|
|
{0, 1, 0, TRUE, TRUE, TRUE, ARRAYSIZE(g_LongRoomPaintings1), g_LongRoomPaintings1},
|
|
{0, 1, 0, TRUE, TRUE, TRUE, ARRAYSIZE(g_LongRoomPaintings1), g_LongRoomPaintings1}, // Duplicate to increase odds
|
|
{0, 2, 0, TRUE, TRUE, TRUE, ARRAYSIZE(g_LongRoomPaintings1), g_LongRoomPaintings1},
|
|
{0, 2, 0, TRUE, TRUE, TRUE, ARRAYSIZE(g_LongRoomPaintings1), g_LongRoomPaintings1}, // Duplicate to increase odds
|
|
{0, 1, 0, TRUE, TRUE, FALSE, ARRAYSIZE(g_LongRoomPaintings2), g_LongRoomPaintings2},
|
|
{0, 2, 0, TRUE, FALSE, TRUE, ARRAYSIZE(g_LongRoomPaintings3), g_LongRoomPaintings3},
|
|
|
|
// These require entering door other than 0
|
|
// {1, 2, 1, TRUE, TRUE, TRUE, ARRAYSIZE(g_LongRoomPaintings1), g_LongRoomPaintings1},
|
|
// {2, 1, 1, TRUE, TRUE, TRUE, ARRAYSIZE(g_LongRoomPaintings1), g_LongRoomPaintings1},
|
|
|
|
// This requuires supporting leaving the first door
|
|
// {2, 0, TRUE, TRUE, FALSE, ARRAYSIZE(g_LongRoomPaintings2), g_LongRoomPaintings2},
|
|
};
|
|
|
|
ROOM_FLOORPLANS g_RoomFloorPlansLobby[] =
|
|
{
|
|
{0, 1, 0, FALSE, TRUE, TRUE, 0, NULL},
|
|
{0, 2, 0, FALSE, TRUE, TRUE, 0, NULL}
|
|
};
|
|
|
|
|
|
void InitLayout(void)
|
|
{
|
|
static BOOL fInited = FALSE;
|
|
|
|
if (!fInited)
|
|
{
|
|
int nIndex;
|
|
fInited = TRUE;
|
|
|
|
g_LongRoomPaintings1[0].vLocation = D3DXVECTOR3(g_fFudge, g_fPaintingHeightY, (g_fRoomDepthZ / 4.0f)); g_LongRoomPaintings1[0].vNormal = NORMAL_X; // Left Wall 1
|
|
g_LongRoomPaintings1[1].vLocation = D3DXVECTOR3(g_fFudge, g_fPaintingHeightY, (g_fRoomDepthZ * (2.0f / 4.0f))); g_LongRoomPaintings1[1].vNormal = NORMAL_X; // Left Wall 2
|
|
g_LongRoomPaintings1[2].vLocation = D3DXVECTOR3((g_fRoomWidthX * (1.0f / 3.0f)), g_fPaintingHeightY, g_fRoomDepthZ-g_fFudge); g_LongRoomPaintings1[2].vNormal = NORMAL_NEG_Z; // Front Wall 1
|
|
g_LongRoomPaintings1[3].vLocation = D3DXVECTOR3((g_fRoomWidthX * (2.0f / 3.0f)), g_fPaintingHeightY, g_fRoomDepthZ-g_fFudge); g_LongRoomPaintings1[3].vNormal = NORMAL_NEG_Z; // Front Wall 2
|
|
g_LongRoomPaintings1[4].vLocation = D3DXVECTOR3(g_fRoomWidthX-g_fFudge, g_fPaintingHeightY, (g_fRoomDepthZ / 4.0f)); g_LongRoomPaintings1[4].vNormal = NORMAL_NEG_X; // Right Wall 1
|
|
g_LongRoomPaintings1[5].vLocation = D3DXVECTOR3(g_fRoomWidthX-g_fFudge, g_fPaintingHeightY, (g_fRoomDepthZ * (2.0f / 4.0f) )); g_LongRoomPaintings1[5].vNormal = NORMAL_NEG_X; // Right Wall 2
|
|
|
|
// g_LongRoomPaintings2 is a copy of g_LongRoomPaintings1 plus another painting.
|
|
for (nIndex = 0; nIndex < ARRAYSIZE(g_LongRoomPaintings1); nIndex++)
|
|
{
|
|
g_LongRoomPaintings2[nIndex].vLocation = g_LongRoomPaintings1[nIndex].vLocation;
|
|
g_LongRoomPaintings2[nIndex].vNormal = g_LongRoomPaintings1[nIndex].vNormal;
|
|
}
|
|
g_LongRoomPaintings2[6].vLocation = D3DXVECTOR3(g_fRoomWidthX-g_fFudge, g_fPaintingHeightY, (g_fRoomDepthZ * (3.0f / 4.0f) )); g_LongRoomPaintings2[6].vNormal = NORMAL_NEG_X; // Right Wall 3
|
|
|
|
// g_LongRoomPaintings3 is a copy of g_LongRoomPaintings1 plus another painting.
|
|
for (nIndex = 0; nIndex < ARRAYSIZE(g_LongRoomPaintings1); nIndex++)
|
|
{
|
|
g_LongRoomPaintings3[nIndex].vLocation = g_LongRoomPaintings1[nIndex].vLocation;
|
|
g_LongRoomPaintings3[nIndex].vNormal = g_LongRoomPaintings1[nIndex].vNormal;
|
|
}
|
|
g_LongRoomPaintings3[6].vLocation = D3DXVECTOR3(g_fFudge, g_fPaintingHeightY, (g_fRoomDepthZ * (3.0f / 4.0f))); g_LongRoomPaintings3[6].vNormal = NORMAL_X; // Left Wall 3
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Name: CTheRoom()
|
|
// Desc: Constructor
|
|
//-----------------------------------------------------------------------------
|
|
CTheRoom::CTheRoom(BOOL fLobby, CMSLogoDXScreenSaver * pMain, CTheRoom * pEnterRoom, int nBatch)
|
|
: m_objWall1(pMain), m_objCeiling(pMain), m_objToeGuard1(pMain), m_objFloor(pMain),
|
|
m_theRug(pMain), m_thePowerSocket(pMain), m_nBatch(nBatch), m_cRef(1)
|
|
{
|
|
InitLayout();
|
|
|
|
// Initialize member variables
|
|
D3DXMatrixIdentity(&m_matIdentity);
|
|
m_pEnterRoom = NULL;
|
|
m_pFirstRoom = NULL;
|
|
m_pLeftRoom = NULL;
|
|
m_pRightRoom = NULL;
|
|
|
|
m_fRoomCreated = FALSE;
|
|
m_fVisible = FALSE;
|
|
m_fLowPriority = FALSE;
|
|
m_fLobby = fLobby;
|
|
m_pMain = pMain;
|
|
m_fCurrentRoom = FALSE;
|
|
IUnknown_Set((IUnknown **) &m_pEnterRoom, pEnterRoom);
|
|
|
|
if (fLobby)
|
|
{
|
|
m_pFloorPlan = &g_RoomFloorPlansLobby[GetRandomInt(0, ARRAYSIZE(g_RoomFloorPlansLobby)-1)];
|
|
}
|
|
else
|
|
{
|
|
m_pFloorPlan = &g_RoomFloorPlans[GetRandomInt(0, ARRAYSIZE(g_RoomFloorPlans)-1)]; // ARRAYSIZE(g_RoomFloorPlans)-1
|
|
}
|
|
|
|
for (int nIndex = 0; nIndex < ARRAYSIZE(m_pPaintings); nIndex++)
|
|
{
|
|
m_pPaintings[nIndex] = NULL;
|
|
}
|
|
|
|
g_nLeakCheck++;
|
|
}
|
|
|
|
|
|
CTheRoom::~CTheRoom()
|
|
{
|
|
for (int nIndex = 0; nIndex < ARRAYSIZE(m_pPaintings); nIndex++)
|
|
{
|
|
SAFE_DELETE(m_pPaintings[nIndex]);
|
|
}
|
|
|
|
FinalCleanup(); // Just in case someone forgot to call FinalCleanup() in an error condition.
|
|
g_nLeakCheck--;
|
|
}
|
|
|
|
|
|
HRESULT CTheRoom::_InitPaintings(void)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
if (!g_pPictureMgr || !m_pFloorPlan)
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
|
|
if (m_pPaintings[0])
|
|
{
|
|
return S_OK;
|
|
}
|
|
|
|
#define FRAMESIZE_X 0.062696f // This is the frame size for frame.bmp
|
|
#define FRAMESIZE_Y 0.087336f // This is the frame size for frame.bmp
|
|
|
|
float fMaxPaintingWH = (g_fRoomHeightY * 0.4f); // The picture can not be more than one half the size of the wall.
|
|
float fScale = 1.0f;
|
|
|
|
for (int nIndex = 0; (nIndex < ARRAYSIZE(m_pPaintings)) && (nIndex < m_pFloorPlan->nPaintings) && SUCCEEDED(hr); nIndex++)
|
|
{
|
|
m_pPaintings[nIndex] = new CPainting(m_pMain);
|
|
|
|
if (m_pPaintings[nIndex])
|
|
{
|
|
DWORD dwMaxPixelSize = ((3 * g_dwHeight) / 4);
|
|
CTexture * pPaintingTexture = NULL;
|
|
|
|
hr = g_pPictureMgr->GetPainting(m_nBatch, nIndex, 0, &pPaintingTexture);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
D3DXVECTOR3 vPaintingLoc = m_pFloorPlan->pPaintingsLayout[nIndex].vLocation;
|
|
D3DXVECTOR3 vPaintingNormal = m_pFloorPlan->pPaintingsLayout[nIndex].vNormal;
|
|
|
|
m_pPaintings[nIndex]->OneTimeSceneInit();
|
|
hr = m_pPaintings[nIndex]->SetPainting(m_pMain->GetGlobalTexture(ITEM_FRAME, &fScale), pPaintingTexture, vPaintingLoc, fMaxPaintingWH, FRAMESIZE_X, FRAMESIZE_Y, vPaintingNormal, dwMaxPixelSize);
|
|
pPaintingTexture->Release();
|
|
}
|
|
else
|
|
{
|
|
// This will fail if we can't load our pictures. This will cause us to come back later when
|
|
// the background thread may have an image.
|
|
SAFE_DELETE(m_pPaintings[nIndex]);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT CTheRoom::_AddWall(BOOL fWithDoor, D3DXVECTOR3 vLocation, D3DXVECTOR3 vWidth, D3DXVECTOR3 vHeight, D3DXVECTOR3 vNormal,
|
|
float fTotalHeight, float fDoorHeight, float fTotalWidth, float fDoorWidth, float fDoorStart)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
C3DObject * pobjNextWall = new C3DObject(m_pMain);
|
|
C3DObject * pobjNextToeGuard = new C3DObject(m_pMain);
|
|
if (pobjNextWall && pobjNextToeGuard && m_pMain)
|
|
{
|
|
if (fWithDoor)
|
|
{
|
|
hr = _AddWallWithDoor(pobjNextWall, pobjNextToeGuard, &m_objFloor, vLocation, vWidth, vHeight, vNormal, fTotalHeight, fDoorHeight, fTotalWidth, fDoorWidth, fDoorStart);
|
|
}
|
|
else
|
|
{
|
|
// Texture Coords
|
|
float fScale = 1.0f;
|
|
CTexture * pTexture = m_pMain->GetGlobalTexture(ITEM_WALLPAPER, &fScale);
|
|
float fTSWallpaperX = (TEXTURESCALE_WALLPAPER * fScale); // How many repeats per 1 unit.
|
|
float fTSWallpaperY = fTSWallpaperX * pTexture->GetSurfaceRatio();
|
|
|
|
D3DXVECTOR3 vSizeNoDoor = ((vWidth * fTotalWidth) + (vHeight * fTotalHeight));
|
|
hr = pobjNextWall->InitPlane(pTexture, m_pMain->GetD3DDevice(), vLocation, vSizeNoDoor, vNormal, 2, 2, fTSWallpaperX, fTSWallpaperY, 0, 10);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
CTexture * pToeGuardTexture = m_pMain->GetGlobalTexture(ITEM_TOEGUARD, &fScale);
|
|
float fTSToeGuardX = (TEXTURESCALE_TOEGUARD * fScale); // How many repeats per 1 unit.
|
|
float fTSToeGuardY = fTSToeGuardX * pToeGuardTexture->GetSurfaceRatio();
|
|
|
|
// Draw ToeGuard
|
|
vLocation += (g_fFudge * vNormal);
|
|
vSizeNoDoor = D3DXVECTOR3(vSizeNoDoor.x, TOEGUARD_HEIGHT, vSizeNoDoor.z);
|
|
hr = pobjNextToeGuard->InitPlane(pToeGuardTexture, m_pMain->GetD3DDevice(), vLocation, vSizeNoDoor, vNormal, 2, 2, fTSToeGuardX, fTSToeGuardY, 0, 0);
|
|
}
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = m_objWall1.CombineObject(m_pMain->GetD3DDevice(), pobjNextWall);
|
|
hr = m_objToeGuard1.CombineObject(m_pMain->GetD3DDevice(), pobjNextToeGuard);
|
|
}
|
|
}
|
|
SAFE_DELETE(pobjNextWall);
|
|
SAFE_DELETE(pobjNextToeGuard);
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT CTheRoom::_AddWallWithDoor(C3DObject * pobjWall, C3DObject * pobjToeGuard, C3DObject * pobjFloor, D3DXVECTOR3 vLocation, D3DXVECTOR3 vWidth, D3DXVECTOR3 vHeight, D3DXVECTOR3 vNormal,
|
|
float fTotalHeight, float fDoorHeight, float fTotalWidth, float fDoorWidth, float fDoorStart)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
float fScale = 1.0f;
|
|
float fYToeGuard = TOEGUARD_HEIGHT;
|
|
|
|
CTexture * pToeTexture = m_pMain->GetGlobalTexture(ITEM_TOEGUARD, &fScale);
|
|
float fTSToeGuardX = (TEXTURESCALE_TOEGUARD * fScale); // How many repeats per 1 unit.
|
|
float fTSToeGuardY = fTSToeGuardX * pToeTexture->GetSurfaceRatio();
|
|
|
|
CTexture * pTexture = m_pMain->GetGlobalTexture(ITEM_WALLPAPER, &fScale);
|
|
float fTSWallpaperX = (TEXTURESCALE_WALLPAPER * fScale); // How many repeats per 1 unit.
|
|
float fTSWallpaperY = fTSWallpaperX * pTexture->GetSurfaceRatio();
|
|
|
|
CTexture * pFloorTexture = m_pMain->GetGlobalTexture(ITEM_FLOOR, &fScale);
|
|
float fTSFloorX = (TEXTURESCALE_FLOOR * fScale); // How many repeats per 1 unit.
|
|
float fTSFloorY = fTSFloorX * pFloorTexture->GetSurfaceRatio();
|
|
|
|
// Create Main Wall
|
|
D3DXVECTOR3 vSize = ((fDoorStart * vWidth) + (fTotalHeight * vHeight));
|
|
|
|
hr = pobjWall->InitPlane(pTexture, m_pMain->GetD3DDevice(), vLocation, vSize, vNormal, 2, 2, fTSWallpaperX, fTSWallpaperY, 0, 10);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
D3DXVECTOR3 vToeLocation = (vLocation + (g_fFudge * vNormal)); // Offset the toeguard so it's above the wall.
|
|
vSize = D3DXVECTOR3(D3DXVec3Multiply(vSize, vWidth) + (vHeight * fYToeGuard)); // Replace the height component with the ToeGuard height)
|
|
|
|
hr = pobjToeGuard->InitPlane(pToeTexture, m_pMain->GetD3DDevice(), vToeLocation, vSize, vNormal, 2, 2, fTSToeGuardX, fTSToeGuardY, 0, 0);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
int nParts = 9;
|
|
D3DXVECTOR3 vNextLocation;
|
|
D3DXVECTOR3 vTempNormal;
|
|
|
|
while (nParts--) // We have 2 more wall parts and 1 more toeguards to add.
|
|
{
|
|
C3DObject * pNewObject = new C3DObject(m_pMain);
|
|
|
|
if (pNewObject)
|
|
{
|
|
switch (nParts)
|
|
{
|
|
case 8: // Floor at base of door way.
|
|
vNextLocation = (vLocation + (fDoorStart * vWidth));
|
|
vSize = (((-1.0f * DOORFRAME_DEPTH) * vNormal) + (fDoorWidth * vWidth));
|
|
vTempNormal = D3DXVECTOR3(0.0f, 1.0f, 0.0f); // Normal points up
|
|
hr = pNewObject->InitPlane(pFloorTexture, m_pMain->GetD3DDevice(), vNextLocation, vSize, vTempNormal, 2, 2, fTSFloorX, fTSFloorY, 0, 0);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = pobjFloor->CombineObject(m_pMain->GetD3DDevice(), pNewObject);
|
|
}
|
|
delete pNewObject;
|
|
break;
|
|
case 7: // Add the wallguard in the door way #2
|
|
vNextLocation = (vLocation + ((fDoorStart + g_fFudge) * vWidth) + (g_fFudge * vNormal));
|
|
vSize = (((-1.0f * (DOORFRAME_DEPTH + (2.0f * g_fFudge)) * vNormal)) + (fYToeGuard * vHeight));
|
|
vTempNormal = vWidth;
|
|
hr = pNewObject->InitPlane(pToeTexture, m_pMain->GetD3DDevice(), vNextLocation, vSize, vTempNormal, 2, 2, fTSToeGuardX, fTSToeGuardY, 0, 0);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = pobjToeGuard->CombineObject(m_pMain->GetD3DDevice(), pNewObject);
|
|
}
|
|
delete pNewObject;
|
|
break;
|
|
case 6: // Add the wallguard in the door way #1
|
|
vNextLocation = (vLocation + ((fDoorStart + fDoorWidth - g_fFudge) * vWidth) + (g_fFudge * vNormal));
|
|
vSize = (((-1.0f * (DOORFRAME_DEPTH + (2.0f * g_fFudge))) * vNormal) + (fYToeGuard * vHeight));
|
|
vTempNormal = (-1.0f * vWidth);
|
|
hr = pNewObject->InitPlane(pToeTexture, m_pMain->GetD3DDevice(), vNextLocation, vSize, vTempNormal, 2, 2, fTSToeGuardX, fTSToeGuardY, 0, 0);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = pobjToeGuard->CombineObject(m_pMain->GetD3DDevice(), pNewObject);
|
|
}
|
|
delete pNewObject;
|
|
break;
|
|
case 5: // Add door frame top
|
|
vNextLocation = (vLocation + (fDoorStart * vWidth) + (fDoorHeight * vHeight));
|
|
vSize = (((-1.0f * DOORFRAME_DEPTH) * vNormal) + (fDoorWidth * vWidth));
|
|
vTempNormal = D3DXVECTOR3(0.0f, -1.0f, 0.0f);
|
|
hr = pNewObject->InitPlane(pTexture, m_pMain->GetD3DDevice(), vNextLocation, vSize, vTempNormal, 2, 2, fTSWallpaperX, fTSWallpaperY, 0, 10);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = pobjWall->CombineObject(m_pMain->GetD3DDevice(), pNewObject);
|
|
}
|
|
delete pNewObject;
|
|
break;
|
|
case 4: // Add door frame #2
|
|
vNextLocation = (vLocation + (fDoorStart * vWidth));
|
|
vSize = (((-1.0f * DOORFRAME_DEPTH) * vNormal) + (fTotalHeight * vHeight));
|
|
vTempNormal = vWidth;
|
|
hr = pNewObject->InitPlane(pTexture, m_pMain->GetD3DDevice(), vNextLocation, vSize, vTempNormal, 2, 2, fTSWallpaperX, fTSWallpaperY, 0, 10);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = pobjWall->CombineObject(m_pMain->GetD3DDevice(), pNewObject);
|
|
}
|
|
delete pNewObject;
|
|
break;
|
|
case 3: // Add door frame #1
|
|
vNextLocation = (vLocation + ((fDoorStart + fDoorWidth) * vWidth));
|
|
vSize = (((-1.0f * DOORFRAME_DEPTH) * vNormal) + (fTotalHeight * vHeight));
|
|
vTempNormal = (-1.0f * vWidth);
|
|
hr = pNewObject->InitPlane(pToeTexture, m_pMain->GetD3DDevice(), vNextLocation, vSize, vTempNormal, 2, 2, fTSWallpaperX, fTSWallpaperY, 0, 10);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = pobjWall->CombineObject(m_pMain->GetD3DDevice(), pNewObject);
|
|
}
|
|
delete pNewObject;
|
|
break;
|
|
case 2: // Add the second wall part. (Wall over the door)
|
|
vNextLocation = (vLocation + (fDoorStart * vWidth) + (fDoorHeight * vHeight));
|
|
vSize = ((fDoorWidth * vWidth) + ((fTotalHeight - fDoorHeight) * vHeight));
|
|
hr = pNewObject->InitPlane(pTexture, m_pMain->GetD3DDevice(), vNextLocation, vSize, vNormal, 2, 2, fTSWallpaperX, fTSWallpaperY, 0, 10);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = pobjWall->CombineObject(m_pMain->GetD3DDevice(), pNewObject);
|
|
}
|
|
delete pNewObject;
|
|
break;
|
|
case 1: // Add the third wall part
|
|
vNextLocation = (vLocation + ((fDoorStart + fDoorWidth) * vWidth));
|
|
vSize = (((fTotalWidth - (fDoorStart + fDoorWidth)) * vWidth) + (fTotalHeight * vHeight));
|
|
hr = pNewObject->InitPlane(pTexture, m_pMain->GetD3DDevice(), vNextLocation, vSize, vNormal, 2, 2, fTSWallpaperX, fTSWallpaperY, 0, 10);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = pobjWall->CombineObject(m_pMain->GetD3DDevice(), pNewObject);
|
|
}
|
|
delete pNewObject;
|
|
break;
|
|
case 0: // Add the second Toe Guard
|
|
vNextLocation = (vLocation + ((fDoorStart + fDoorWidth) * vWidth) + (g_fFudge * vNormal));
|
|
vSize = (((fTotalWidth - (fDoorStart + fDoorWidth)) * vWidth) + (fYToeGuard * vHeight));
|
|
hr = pNewObject->InitPlane(pToeTexture, m_pMain->GetD3DDevice(), vNextLocation, vSize, vNormal, 2, 2, fTSToeGuardX, fTSToeGuardY, 0, 0);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = pobjToeGuard->CombineObject(m_pMain->GetD3DDevice(), pNewObject);
|
|
}
|
|
delete pNewObject;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT CTheRoom::_SetRotationMatrix(void)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
D3DXMATRIX matRotate;
|
|
D3DXMATRIX matTrans;
|
|
|
|
// We want to set the matricies to get us to the next room.
|
|
// Next Room
|
|
if (m_pFirstRoom)
|
|
{
|
|
D3DXMatrixRotationY(&matRotate, D3DXToRadian(180));
|
|
D3DXMatrixTranslation(&matTrans, ((g_fRoomWidthX / 2.0f) + (DOOR_WIDTH / 2.0f) + m_pFirstRoom->GetDoorOffset()), 0.0f, -1.0f);
|
|
D3DXMatrixMultiply(&m_matFirstRoom, &matRotate, &matTrans);
|
|
}
|
|
|
|
if (m_pLeftRoom)
|
|
{
|
|
D3DXMatrixRotationY(&matRotate, D3DXToRadian(270));
|
|
D3DXMatrixTranslation(&matTrans, -1.0f, 0.0f, WALL_WIDTHBEFOREDOOR + (DOOR_WIDTH / 2.0f) - m_pLeftRoom->GetDoorOffset());
|
|
D3DXMatrixMultiply(&m_matLeftRoom, &matRotate, &matTrans);
|
|
}
|
|
|
|
// Side Room
|
|
if (m_pRightRoom)
|
|
{
|
|
D3DXMatrixRotationY(&matRotate, D3DXToRadian(90));
|
|
D3DXMatrixTranslation(&matTrans, (g_fRoomWidthX + 1.0f), 0.0f, (WALL_WIDTHBEFOREDOOR + (DOOR_WIDTH / 2.0f) + m_pRightRoom->GetDoorOffset()));
|
|
D3DXMatrixMultiply(&m_matRightRoom, &matRotate, &matTrans);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT CTheRoom::_CreateLobbySign(void)
|
|
{
|
|
TCHAR szLine2[MAX_PATH];
|
|
TCHAR szUsername[MAX_PATH];
|
|
HRESULT hr = GetCurrentUserCustomName(szUsername, ARRAYSIZE(szUsername));
|
|
|
|
LoadString(HINST_THISDLL, IDS_LOBBY_TITLE2, szLine2, ARRAYSIZE(szLine2));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// TODO:
|
|
// 1. Create Sign backdrop. (Marble, wood?)
|
|
// 2. Render Text. (D3DXCreateTextW, etc.)
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT CTheRoom::_CreateRoom(void)
|
|
{
|
|
// TODO: For Square room, layout differently
|
|
HRESULT hr = S_OK;
|
|
|
|
D3DXVECTOR3 vNormalWall1(0, 0, -1);
|
|
D3DXVECTOR3 vNormalWall2(-1, 0, 0);
|
|
D3DXVECTOR3 vNormalWall3(0, 0, 1);
|
|
D3DXVECTOR3 vNormalWall4(1, 0, 0);
|
|
D3DXVECTOR3 vNormalFloor(0, 1, 0);
|
|
D3DXVECTOR3 vNormalCeiling(0, -1, 0);
|
|
DWORD dwRugMaxPixelSize = ((3 * g_dwHeight) / 4);
|
|
|
|
m_fCeiling = m_fToeGuard = m_fPaintings = m_fRug = m_fPower = m_fWalls = m_fFloor = TRUE;
|
|
m_fCeiling = !g_fOverheadViewTest;
|
|
|
|
// Locations
|
|
float fYToeGuard = TOEGUARD_HEIGHT;
|
|
|
|
// Rug
|
|
float fScale = 1.0f;
|
|
float fRugWidth = 40.0f;
|
|
float fRugDepth = (fRugWidth * (m_pMain->GetGlobalTexture(ITEM_RUG, &fScale))->GetSurfaceRatio()); // This will cause one object to be above another.
|
|
D3DXVECTOR3 vRugLoc(((g_fRoomWidthX - fRugWidth) / 2.0f), g_fFudge, ((g_fRoomDepthZ - fRugDepth) / 2.0f));
|
|
D3DXVECTOR3 vRugSize(fRugWidth, 0, fRugDepth);
|
|
|
|
// PowerSocket
|
|
float fPowerWidth = 2.5f;
|
|
float fPowerHeight = (fPowerWidth * (m_pMain->GetGlobalTexture(ITEM_POWEROUTLET, &fScale))->GetSurfaceRatio()); // This will cause one object to be above another.
|
|
D3DXVECTOR3 vPowerLoc(((g_fRoomWidthX - fPowerWidth) / 2.0f), 5.00f, (g_fRoomDepthZ - g_fFudge));
|
|
D3DXVECTOR3 vPowerSize(fPowerWidth, fPowerHeight, 0.0f);
|
|
|
|
// Texture Coords
|
|
CTexture * pTexture = m_pMain->GetGlobalTexture(ITEM_WALLPAPER, &fScale);
|
|
float fTSWallpaperX = (TEXTURESCALE_WALLPAPER * fScale); // How many repeats per 1 unit.
|
|
float fTSWallpaperY = fTSWallpaperX * pTexture->GetSurfaceRatio();
|
|
|
|
CTexture * pFloorTexture = m_pMain->GetGlobalTexture(ITEM_FLOOR, &fScale);
|
|
float fTSFloorX = (TEXTURESCALE_FLOOR * fScale); // How many repeats per 1 unit.
|
|
float fTSFloorY = fTSFloorX * pFloorTexture->GetSurfaceRatio();
|
|
|
|
CTexture * pToeGuardTexture = m_pMain->GetGlobalTexture(ITEM_TOEGUARD, &fScale);
|
|
float fTSToeGuardX = (TEXTURESCALE_TOEGUARD * fScale); // How many repeats per 1 unit.
|
|
float fTSToeGuardY = fTSToeGuardX * pToeGuardTexture->GetSurfaceRatio();
|
|
|
|
CTexture * pCeilingTexture = m_pMain->GetGlobalTexture(ITEM_CEILING, &fScale);
|
|
float fTSCeilingX = (TEXTURESCALE_CEILING * fScale); // How many repeats per 1 unit.
|
|
float fTSCeilingY = fTSCeilingX * pCeilingTexture->GetSurfaceRatio();
|
|
|
|
// Draw Floor
|
|
D3DXVECTOR3 vLocation(0.00f, 0.00f, 0.00f);
|
|
D3DXVECTOR3 vSize(g_fRoomWidthX, 0.00f, g_fRoomDepthZ);
|
|
hr = m_objFloor.InitPlane(pFloorTexture, m_pMain->GetD3DDevice(), vLocation, vSize, vNormalFloor, 2, 2, fTSFloorY, fTSFloorX, 0, 10);
|
|
|
|
|
|
// Draw Wall 1 (Facing Wall)
|
|
vLocation = D3DXVECTOR3(0.00f, 0.00f, g_fRoomDepthZ);
|
|
vSize = D3DXVECTOR3(g_fRoomWidthX, g_fRoomHeightY, 0.00f);
|
|
hr = m_objWall1.InitPlane(pTexture, m_pMain->GetD3DDevice(), vLocation, vSize, vNormalWall1, 2, 2, fTSWallpaperX, fTSWallpaperY, 0, 10);
|
|
|
|
// Draw ToeGuard 1
|
|
vLocation = D3DXVECTOR3(0.00f, 0.00f, g_fRoomDepthZ-g_fFudge);
|
|
vSize = D3DXVECTOR3(g_fRoomWidthX, fYToeGuard, 0.00f);
|
|
hr = m_objToeGuard1.InitPlane(pToeGuardTexture, m_pMain->GetD3DDevice(), vLocation, vSize, vNormalWall1, 2, 2, fTSToeGuardY, fTSToeGuardX, 0, 0);
|
|
|
|
|
|
// Draw Wall 2 (Right wall)
|
|
vLocation = D3DXVECTOR3(g_fRoomWidthX, 0.00f, 0.00f);
|
|
hr = _AddWall((NULL != m_pRightRoom), vLocation, D3DXVECTOR3(0.0f, 0.0f, 1.0f), D3DXVECTOR3(0.0f, 1.0f, 0.0f), vNormalWall2, g_fRoomHeightY,
|
|
DOOR_HEIGHT, g_fRoomDepthZ, DOOR_WIDTH, WALL_WIDTHBEFOREDOOR);
|
|
|
|
|
|
// Draw Wall 3 (Back Wall)
|
|
vLocation = D3DXVECTOR3(0.00f, 0.00f, 0.00f);
|
|
hr = _AddWall(FALSE, vLocation, D3DXVECTOR3(1.0f, 0.0f, 0.0f), D3DXVECTOR3(0.0f, 1.0f, 0.0f), vNormalWall3, g_fRoomHeightY,
|
|
DOOR_HEIGHT, g_fRoomWidthX, DOOR_WIDTH, ((g_fRoomWidthX - DOOR_WIDTH) / 2.0f));
|
|
|
|
|
|
// Draw Wall 4 (Left Wall)
|
|
vLocation = D3DXVECTOR3(0.00f, 0.00f, 0.00f);
|
|
hr = _AddWall((NULL != m_pLeftRoom), vLocation, D3DXVECTOR3(0.0f, 0.0f, 1.0f), D3DXVECTOR3(0.0f, 1.0f, 0.0f), vNormalWall4, g_fRoomHeightY,
|
|
DOOR_HEIGHT, g_fRoomDepthZ, DOOR_WIDTH, WALL_WIDTHBEFOREDOOR);
|
|
|
|
// Draw Ceiling
|
|
vLocation = D3DXVECTOR3(0.00f, g_fRoomHeightY, 0.00f);
|
|
vSize = D3DXVECTOR3(g_fRoomWidthX, 0.00f, g_fRoomDepthZ);
|
|
hr = m_objCeiling.InitPlane(pCeilingTexture, m_pMain->GetD3DDevice(), vLocation, vSize, vNormalCeiling, 2, 2, fTSCeilingY, fTSCeilingX, 0, 10);
|
|
|
|
|
|
// Room Items (Rug, Power Sockets, Benches)
|
|
hr = m_theRug.InitPlaneStretch(m_pMain->GetGlobalTexture(ITEM_RUG, &fScale), m_pMain->GetD3DDevice(), vRugLoc, vRugSize, vNormalFloor, 2, 2, dwRugMaxPixelSize);
|
|
|
|
if (m_fLobby)
|
|
{
|
|
hr = _CreateLobbySign();
|
|
}
|
|
else
|
|
{
|
|
// We don't want a powerplug in the lobby.
|
|
hr = m_thePowerSocket.InitPlaneStretch(m_pMain->GetGlobalTexture(ITEM_POWEROUTLET, &fScale), m_pMain->GetD3DDevice(), vPowerLoc, vPowerSize, vNormalWall1, 2, 2, 0);
|
|
}
|
|
|
|
hr = _SetRotationMatrix();
|
|
|
|
m_fWalls = TRUE;
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Name: OneTimeSceneInit()
|
|
// Desc: Called during initial app startup, this function performs all the
|
|
// permanent initialization.
|
|
//-----------------------------------------------------------------------------
|
|
HRESULT CTheRoom::OneTimeSceneInit(int nFutureRooms, BOOL fLowPriority)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
m_fLowPriority = fLowPriority;
|
|
if (!m_fRoomCreated)
|
|
{
|
|
// assert(!m_pFirstRoom); // This will cause a leak
|
|
// ASSERT(!m_pLeftRoom); //, TEXT("This will cause a leak"));
|
|
// ASSERT(!m_pRightRoom); // , TEXT("This will cause a leak"));
|
|
|
|
if (m_pFloorPlan->nEnterDoor == 0)
|
|
{
|
|
IUnknown_Set((IUnknown **) &m_pFirstRoom, m_pEnterRoom);
|
|
}
|
|
else
|
|
{
|
|
if (m_pFloorPlan->fDoor0)
|
|
{
|
|
m_pFirstRoom = new CTheRoom(FALSE, m_pMain, this, m_nBatch+1);
|
|
if (!m_pFirstRoom)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (m_pFloorPlan->nEnterDoor == 1)
|
|
{
|
|
IUnknown_Set((IUnknown **) &m_pLeftRoom, m_pEnterRoom);
|
|
}
|
|
else
|
|
{
|
|
if (m_pFloorPlan->fDoor1)
|
|
{
|
|
m_pLeftRoom = new CTheRoom(FALSE, m_pMain, this, m_nBatch+1);
|
|
if (!m_pLeftRoom)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (m_pFloorPlan->nEnterDoor == 2)
|
|
{
|
|
IUnknown_Set((IUnknown **) &m_pRightRoom, m_pEnterRoom);
|
|
}
|
|
else
|
|
{
|
|
if (m_pFloorPlan->fDoor2)
|
|
{
|
|
m_pRightRoom = new CTheRoom(FALSE, m_pMain, this, m_nBatch+1);
|
|
if (!m_pRightRoom)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (SUCCEEDED(hr) &&
|
|
(m_pFirstRoom || m_pLeftRoom || m_pRightRoom))
|
|
{
|
|
hr = _CreateRoom();
|
|
if (!m_fLobby && !g_fFirstFrame)
|
|
{
|
|
_InitPaintings();
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
m_fVisible = TRUE; // We have children to render.
|
|
m_fRoomCreated = TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
|
|
if (SUCCEEDED(hr) && (nFutureRooms > 0))
|
|
{
|
|
if (m_pLeftRoom)
|
|
{
|
|
hr = m_pLeftRoom->OneTimeSceneInit(nFutureRooms-1, FALSE);
|
|
}
|
|
if (SUCCEEDED(hr) && m_pRightRoom)
|
|
{
|
|
hr = m_pRightRoom->OneTimeSceneInit(nFutureRooms-1, FALSE);
|
|
} // TODO: Need first room?
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT CTheRoom::FreePictures(int nMaxBatch)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
if (-1 == nMaxBatch)
|
|
{
|
|
nMaxBatch = m_nBatch;
|
|
}
|
|
|
|
if (nMaxBatch >= m_nBatch)
|
|
{
|
|
if (g_pPictureMgr)
|
|
{
|
|
g_pPictureMgr->ReleaseBatch(m_nBatch);
|
|
m_nBatch = 0;
|
|
}
|
|
|
|
// Free our paintings
|
|
for (int nIndex = 0; (nIndex < ARRAYSIZE(m_pPaintings)); nIndex++)
|
|
{
|
|
SAFE_DELETE(m_pPaintings[nIndex]);
|
|
}
|
|
|
|
if (m_pFloorPlan)
|
|
{
|
|
if (m_pFirstRoom && (m_pFirstRoom != m_pEnterRoom) &&
|
|
(!m_fCurrentRoom || (0 != m_pFloorPlan->nExitDoor)))
|
|
{
|
|
hr = m_pFirstRoom->FreePictures(nMaxBatch);
|
|
}
|
|
|
|
if (m_pLeftRoom && (m_pLeftRoom != m_pEnterRoom) &&
|
|
(!m_fCurrentRoom || (1 != m_pFloorPlan->nExitDoor)))
|
|
{
|
|
hr = m_pLeftRoom->FreePictures(nMaxBatch);
|
|
}
|
|
|
|
if (m_pRightRoom && (m_pRightRoom != m_pEnterRoom) &&
|
|
(!m_fCurrentRoom || (2 != m_pFloorPlan->nExitDoor)))
|
|
{
|
|
hr = m_pRightRoom->FreePictures(nMaxBatch);
|
|
}
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT CTheRoom::SetCurrent(BOOL fCurrent)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
m_fCurrentRoom = fCurrent;
|
|
if (fCurrent)
|
|
{
|
|
if (m_pFirstRoom)
|
|
{
|
|
hr = m_pFirstRoom->OneTimeSceneInit(1, TRUE);
|
|
}
|
|
|
|
if (m_pLeftRoom)
|
|
{
|
|
hr = m_pLeftRoom->OneTimeSceneInit(1, TRUE);
|
|
}
|
|
|
|
if (m_pRightRoom)
|
|
{
|
|
hr = m_pRightRoom->OneTimeSceneInit(1, TRUE);
|
|
}
|
|
|
|
m_fVisible = TRUE;
|
|
}
|
|
else
|
|
{
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT CTheRoom::GetNextRoom(CTheRoom ** ppNextRoom)
|
|
{
|
|
// This function does two things:
|
|
// 1. Gives the caller a pointer to our next room, and
|
|
// 2. Changes the order so we free rooms we will no longer need.
|
|
// We want to take this opportunity to free our other rooms in case we come back into this room.
|
|
// TODO: Regen other rooms. Use Ref-counting with SetSite(NULL) in order to track memory correctly.
|
|
|
|
// We would need to re-generate m_pFloorPlan that has the same enter door as our exit door
|
|
// with the same floor plan if we want to walk into previous rooms.
|
|
switch (m_pFloorPlan->nExitDoor)
|
|
{
|
|
case 0: // Enter door
|
|
IUnknown_Set((IUnknown **) ppNextRoom, m_pFirstRoom);
|
|
IUnknown_Set((IUnknown **) &m_pEnterRoom, m_pFirstRoom);
|
|
break;
|
|
case 1: // Left door
|
|
IUnknown_Set((IUnknown **) ppNextRoom, m_pLeftRoom);
|
|
IUnknown_Set((IUnknown **) &m_pEnterRoom, m_pLeftRoom);
|
|
break;
|
|
case 2: // Right door
|
|
IUnknown_Set((IUnknown **) ppNextRoom, m_pRightRoom);
|
|
IUnknown_Set((IUnknown **) &m_pEnterRoom, m_pRightRoom);
|
|
break;
|
|
};
|
|
|
|
BOOL fReEnter = ((ppNextRoom && *ppNextRoom) ? ((*ppNextRoom)->GetEnterDoor() == (*ppNextRoom)->GetExitDoor()) : FALSE);
|
|
|
|
if (m_pFirstRoom != m_pEnterRoom)
|
|
{
|
|
if (m_pFirstRoom) m_pFirstRoom->FinalCleanup();
|
|
SAFE_RELEASE(m_pFirstRoom);
|
|
|
|
if (fReEnter)
|
|
{
|
|
m_pFirstRoom = new CTheRoom(FALSE, m_pMain, this, m_nBatch+1);
|
|
}
|
|
}
|
|
|
|
if (m_pLeftRoom != m_pEnterRoom)
|
|
{
|
|
if (m_pLeftRoom) m_pLeftRoom->FinalCleanup();
|
|
SAFE_RELEASE(m_pLeftRoom);
|
|
|
|
if (fReEnter)
|
|
{
|
|
m_pLeftRoom = new CTheRoom(FALSE, m_pMain, this, m_nBatch+1);
|
|
}
|
|
}
|
|
|
|
if (m_pRightRoom != m_pEnterRoom)
|
|
{
|
|
if (m_pRightRoom) m_pRightRoom->FinalCleanup();
|
|
SAFE_RELEASE(m_pRightRoom);
|
|
|
|
if (fReEnter)
|
|
{
|
|
m_pRightRoom = new CTheRoom(FALSE, m_pMain, this, m_nBatch+1);
|
|
}
|
|
}
|
|
|
|
return (*ppNextRoom ? S_OK : E_FAIL);
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Name: FinalCleanup()
|
|
// Desc: Called before the app exits, this function gives the app the chance
|
|
// to cleanup after itself.
|
|
//-----------------------------------------------------------------------------
|
|
HRESULT CTheRoom::FinalCleanup(void)
|
|
{
|
|
// This is where we break all the circular ref-counts
|
|
if (m_pFirstRoom && (m_pEnterRoom != m_pFirstRoom)) m_pFirstRoom->FinalCleanup();
|
|
if (m_pLeftRoom && (m_pEnterRoom != m_pLeftRoom)) m_pLeftRoom->FinalCleanup();
|
|
if (m_pRightRoom && (m_pEnterRoom != m_pRightRoom)) m_pRightRoom->FinalCleanup();
|
|
|
|
SAFE_RELEASE(m_pEnterRoom);
|
|
SAFE_RELEASE(m_pFirstRoom);
|
|
SAFE_RELEASE(m_pLeftRoom);
|
|
SAFE_RELEASE(m_pRightRoom);
|
|
|
|
m_theRug.FinalCleanup();
|
|
m_thePowerSocket.FinalCleanup();
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Name: DeleteDeviceObjects()
|
|
// Desc: Called when the app is exitting, or the device is being changed,
|
|
// this function deletes any device dependant objects.
|
|
//-----------------------------------------------------------------------------
|
|
HRESULT CTheRoom::DeleteDeviceObjects(void)
|
|
{
|
|
m_theRug.DeleteDeviceObjects();
|
|
m_thePowerSocket.DeleteDeviceObjects();
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
#define ABS(i) (((i) < 0) ? -(i) : (i))
|
|
|
|
|
|
HRESULT CTheRoom::_RenderThisRoom(IDirect3DDevice8 * pD3DDevice, int nRenderPhase, BOOL fFrontToBack)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
DWORD dwTesting = 0;
|
|
|
|
switch (nRenderPhase)
|
|
{
|
|
case 0: // Wallpaper
|
|
if (m_fWalls)
|
|
{
|
|
hr = m_objWall1.Render(pD3DDevice);
|
|
}
|
|
break;
|
|
|
|
case 1:
|
|
if (m_fFloor)
|
|
{
|
|
hr = m_objFloor.Render(pD3DDevice);
|
|
}
|
|
break;
|
|
|
|
|
|
case 2:
|
|
if (m_fToeGuard)
|
|
{
|
|
// pD3DDevice->SetRenderState(D3DRS_ZBIAS, 12); // Force the ToeGuard to appear above the wallpaper.
|
|
hr = m_objToeGuard1.Render(pD3DDevice);
|
|
}
|
|
break;
|
|
|
|
case 3: // Frames
|
|
case 4: // Pictures. (Here's where we blow the cache)
|
|
if (m_fPaintings)
|
|
{
|
|
if (m_fLobby)
|
|
{
|
|
// TODO: Paint lobby sign. (user name) Anything created in _CreateLobbySign().
|
|
}
|
|
else
|
|
{
|
|
// pD3DDevice->SetRenderState(D3DRS_ZBIAS, 13);
|
|
if (!m_pPaintings[0] && m_fVisible && !g_fFirstFrame) // Did the background thread not yet have any pictures for us?
|
|
{
|
|
hr = _InitPaintings(); // If so, see if they have anything yet?
|
|
}
|
|
|
|
for (int nIndex = ARRAYSIZE(m_pPaintings)-1; m_fVisible && (nIndex >= 0); nIndex--)
|
|
{
|
|
if (m_pPaintings[nIndex]) // May be NULL if out of memory or in lobby.
|
|
{
|
|
// We use fFrontToBack because we always want to render the frame first. This way
|
|
// the painting is always painted on top. We don't worry about blowing the texture
|
|
// cache on the video card because since we will render so many paintings and change
|
|
// the paintings we render so often, the cache will almost be certainly blown anyway.
|
|
// We always want 0 rendered first.
|
|
if (fFrontToBack)
|
|
{
|
|
m_pPaintings[nIndex]->Render(pD3DDevice, nRenderPhase-3);
|
|
}
|
|
else
|
|
{
|
|
m_pPaintings[nIndex]->Render(pD3DDevice, ((4 == nRenderPhase) ? 0 : 1));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 5:
|
|
if (m_fPower)
|
|
{
|
|
// pD3DDevice->SetRenderState(D3DRS_ZBIAS, 11);
|
|
m_thePowerSocket.Render(pD3DDevice);
|
|
}
|
|
break;
|
|
|
|
case 6:
|
|
if (m_fRug)
|
|
{
|
|
// pD3DDevice->SetRenderState(D3DRS_ZBIAS, 10);
|
|
m_theRug.Render(pD3DDevice);
|
|
}
|
|
break;
|
|
|
|
case 7:
|
|
if (m_fCeiling)
|
|
{
|
|
hr = m_objCeiling.Render(pD3DDevice);
|
|
}
|
|
break;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
//#define COLOR_DOORFRAME_GRAY D3DXCOLOR(0.78f, 0.78f, 0.78f, 1.0f)
|
|
#define COLOR_DOORFRAME_GRAY D3DXCOLOR(0.28f, 0.28f, 0.28f, 1.0f)
|
|
|
|
BOOL CTheRoom::_IsRoomVisible(IDirect3DDevice8 * pD3DDevice, int nRoomNumber)
|
|
{
|
|
D3DXVECTOR3 vMin;
|
|
D3DXVECTOR3 vMax;
|
|
D3DXMATRIX matWorld;
|
|
pD3DDevice->GetTransform(D3DTS_WORLD, &matWorld);
|
|
|
|
switch (nRoomNumber)
|
|
{
|
|
case 0: // First Door.
|
|
return FALSE; // we never look back at the first door
|
|
|
|
case 1: // Left Door.
|
|
vMin = D3DXVECTOR3( 0, 0, WALL_WIDTHBEFOREDOOR );
|
|
vMax = D3DXVECTOR3( 0, DOOR_HEIGHT, WALL_WIDTHBEFOREDOOR + DOOR_WIDTH );
|
|
return Is3DRectViewable( m_pMain->PCullInfo(), &matWorld, vMin, vMax );
|
|
|
|
case 2: // Right Door
|
|
vMin = D3DXVECTOR3( g_fRoomWidthX, 0, WALL_WIDTHBEFOREDOOR );
|
|
vMax = D3DXVECTOR3( g_fRoomWidthX, DOOR_HEIGHT, WALL_WIDTHBEFOREDOOR + DOOR_WIDTH );
|
|
return Is3DRectViewable( m_pMain->PCullInfo(), &matWorld, vMin, vMax );
|
|
|
|
default:
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Name: Render()
|
|
// Desc: Called once per frame, the call is the entry point for 3d
|
|
// rendering. This function sets up render states, clears the
|
|
// viewport, and renders the scene.
|
|
//-----------------------------------------------------------------------------
|
|
HRESULT CTheRoom::Render(IDirect3DDevice8 * pD3DDevice, int nRenderPhase, BOOL fFrontToBack)
|
|
{
|
|
HRESULT hr;
|
|
DWORD dwTesting = 0;
|
|
|
|
// Draw the obstacles
|
|
D3DMATERIAL8 mtrl = {0};
|
|
mtrl.Ambient.r = mtrl.Specular.r = mtrl.Diffuse.r = 1.0f;
|
|
mtrl.Ambient.g = mtrl.Specular.g = mtrl.Diffuse.g = 1.0f;
|
|
mtrl.Ambient.b = mtrl.Specular.b = mtrl.Diffuse.b = 1.0f;
|
|
mtrl.Ambient.a = mtrl.Specular.a = mtrl.Diffuse.a = 1.0f;
|
|
|
|
if (m_fCurrentRoom)
|
|
{
|
|
// DXUtil_Trace(TEXT("ROOM: m_nExitDoor=%d, m_pLeftRoom=%d, m_pRightRoom=%d\n"), m_pFloorPlan->nExitDoor, m_pLeftRoom, m_pRightRoom);
|
|
}
|
|
|
|
hr = pD3DDevice->SetMaterial(&mtrl);
|
|
|
|
if (SUCCEEDED(hr) && m_fVisible && (m_pEnterRoom || m_pLeftRoom || m_pRightRoom))
|
|
{
|
|
// We really want to do hit testing here otherwise we are really wasting our time.
|
|
D3DXMATRIX matPrevious;
|
|
D3DXMATRIX matNext;
|
|
|
|
hr = pD3DDevice->GetTransform(D3DTS_WORLD, &matPrevious);
|
|
|
|
if (m_pEnterRoom && _IsRoomVisible(pD3DDevice, 0) &&
|
|
(m_pEnterRoom != m_pFirstRoom))
|
|
{
|
|
D3DXMatrixMultiply(&matNext, &m_matFirstRoom, &matPrevious);
|
|
hr = pD3DDevice->SetTransform(D3DTS_WORLD, &matNext);
|
|
hr = m_pFirstRoom->Render(pD3DDevice, nRenderPhase, fFrontToBack);
|
|
hr = pD3DDevice->SetTransform(D3DTS_WORLD, &matPrevious);
|
|
}
|
|
|
|
if (m_pLeftRoom && _IsRoomVisible(pD3DDevice, 1) &&
|
|
(m_pEnterRoom != m_pLeftRoom))
|
|
{
|
|
D3DXMatrixMultiply(&matNext, &m_matLeftRoom, &matPrevious);
|
|
hr = pD3DDevice->SetTransform(D3DTS_WORLD, &matNext);
|
|
hr = m_pLeftRoom->Render(pD3DDevice, nRenderPhase, fFrontToBack);
|
|
hr = pD3DDevice->SetTransform(D3DTS_WORLD, &matPrevious);
|
|
}
|
|
|
|
if (m_pRightRoom && _IsRoomVisible(pD3DDevice, 2) &&
|
|
(m_pEnterRoom != m_pRightRoom))
|
|
{
|
|
D3DXMatrixMultiply(&matNext, &m_matRightRoom, &matPrevious);
|
|
hr = pD3DDevice->SetTransform(D3DTS_WORLD, &matNext);
|
|
hr = m_pRightRoom->Render(pD3DDevice, nRenderPhase, fFrontToBack);
|
|
hr = pD3DDevice->SetTransform(D3DTS_WORLD, &matPrevious);
|
|
}
|
|
}
|
|
|
|
hr = _RenderThisRoom(pD3DDevice, nRenderPhase, fFrontToBack);
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
#define DIST_TO_WALL_ON_ZOOM 10.0f
|
|
|
|
HRESULT CTheRoom::_AddPaintingToPaintingMovements(CCameraMove * ptheCamera, D3DXVECTOR3 vSourceLocIn, D3DXVECTOR3 vSourceTangentIn,
|
|
D3DXVECTOR3 vPainting, D3DXVECTOR3 * pvDestDir, float fDest, D3DXVECTOR3 * pvDestTangent,
|
|
int nBatch)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
float fDistToWall = 30.0f;
|
|
float fZoomDistToWall = DIST_TO_WALL_ON_ZOOM;
|
|
float fZoomDelta = (fDistToWall - fZoomDistToWall);
|
|
BOOL fExitLeft = ((1 == m_pFloorPlan->nExitDoor) ? TRUE : FALSE);
|
|
|
|
D3DXVECTOR3 vSourceLoc = vSourceLocIn;
|
|
D3DXVECTOR3 vSourceTangent = vSourceTangentIn;
|
|
D3DXVECTOR3 vDestLoc;
|
|
D3DXVECTOR3 vDestTangent;
|
|
|
|
// Move closer to the first painting so it's full screen
|
|
vDestLoc = (vSourceLoc + (vPainting * fZoomDelta));
|
|
vDestTangent = vSourceTangent;
|
|
hr = ptheCamera->CreateNextMove(vSourceLoc, vSourceTangent, vDestLoc, vDestTangent);
|
|
|
|
// Look at painting #1
|
|
hr = ptheCamera->CreateNextWait(m_nBatch+3, nBatch);
|
|
|
|
// Back up some and start moving to the next painting.
|
|
vSourceLoc = vDestLoc;
|
|
vSourceTangent = vDestTangent;
|
|
vDestLoc = (vSourceLocIn + (*pvDestDir * (fDest * 0.5f)));
|
|
vDestTangent = (*pvDestDir * fDest);
|
|
hr = ptheCamera->CreateNextMove(vSourceLoc, vSourceTangent, vDestLoc, vDestTangent);
|
|
|
|
// Now walk much closer to the next painting
|
|
vSourceLoc = vDestLoc;
|
|
vSourceTangent = vDestTangent;
|
|
vDestLoc = (vSourceLocIn + (*pvDestDir * (fDest * 0.90f)));
|
|
vDestTangent = vSourceTangent;
|
|
hr = ptheCamera->CreateNextMove(vSourceLoc, vSourceTangent, vDestLoc, vDestTangent);
|
|
|
|
// Now move close to the painting
|
|
vSourceLoc = vDestLoc;
|
|
vSourceTangent = vDestTangent;
|
|
vDestLoc = (vSourceLocIn + (vPainting * fZoomDelta) + (*pvDestDir * fDest));
|
|
vDestTangent = (vPainting * 5.0f) * 1000.0f;
|
|
hr = ptheCamera->CreateNextMove(vSourceLoc, vSourceTangent, vDestLoc, vDestTangent);
|
|
|
|
// Look at painting #2
|
|
hr = ptheCamera->CreateNextWait(m_nBatch+3, nBatch);
|
|
|
|
vSourceLoc = vDestLoc;
|
|
vSourceTangent = vDestTangent = vPainting;
|
|
vDestLoc = (vSourceLocIn + (*pvDestDir * fDest));
|
|
hr = ptheCamera->CreateNextMove(vSourceLoc, vSourceTangent, vDestLoc, vDestTangent);
|
|
|
|
*pvDestDir = vDestLoc;
|
|
*pvDestTangent = vDestTangent;
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT CTheRoom::_LongRoomEnterDoorMovements(CCameraMove * ptheCamera)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
float fDistant = 5.0f;
|
|
float fDistToWall = 30.0f;
|
|
float fWalkHeight = 20.0f;
|
|
|
|
D3DXVECTOR3 vSourceLoc((g_fRoomWidthX / 2.0f), fWalkHeight, 1.0f);
|
|
D3DXVECTOR3 vSourceTangent(0.0f, 0.0f, fDistant);
|
|
|
|
hr = ptheCamera->Init(vSourceLoc, vSourceTangent, D3DXVECTOR3(0.0f, 1.0f, 0.0f));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
BOOL fExitLeft = ((1 == m_pFloorPlan->nExitDoor) ? TRUE : FALSE);
|
|
|
|
// fExitLeft 1=Left
|
|
D3DXVECTOR3 vDestLoc((fExitLeft ? fDistToWall : g_fRoomWidthX-fDistToWall), fWalkHeight, (g_fRoomDepthZ * (1.0f / 4.0f)));
|
|
D3DXVECTOR3 vDestTangent((fExitLeft ? -fDistant : fDistant), 0.0f, 0.0f);
|
|
hr = ptheCamera->CreateNextMove(vSourceLoc, vSourceTangent, vDestLoc, vDestTangent);
|
|
|
|
vSourceLoc = vDestLoc;
|
|
vSourceTangent = vDestTangent;
|
|
vDestLoc = D3DXVECTOR3(0.0f, 0.0f, 1.0f);
|
|
hr = _AddPaintingToPaintingMovements(ptheCamera, vSourceLoc, vSourceTangent, D3DXVECTOR3((fExitLeft ? -1.0f : 1.0f), 0.0f, 0.0f),
|
|
&vDestLoc, (g_fRoomDepthZ * (1.0f / 4.0f)), &vDestTangent, 2);
|
|
|
|
vSourceLoc = vDestLoc;
|
|
vSourceTangent = vDestTangent;
|
|
vDestTangent = D3DXVECTOR3(0.0f, 0.0f, fDistant);
|
|
hr = ptheCamera->CreateNextRotate(vSourceLoc, vSourceTangent, vDestTangent);
|
|
|
|
vSourceTangent = vDestTangent;
|
|
vDestTangent = D3DXVECTOR3((fExitLeft ? fDistant : -fDistant), 0.0f, 0.0f);
|
|
hr = ptheCamera->CreateNextRotate(vSourceLoc, vSourceTangent, vDestTangent);
|
|
|
|
vSourceTangent = vDestTangent;
|
|
vDestLoc = D3DXVECTOR3((fExitLeft ? g_fRoomWidthX-fDistToWall : fDistToWall), fWalkHeight, (g_fRoomDepthZ * (2.0f / 4.0f)));
|
|
vDestTangent = vSourceTangent;
|
|
hr = ptheCamera->CreateNextMove(vSourceLoc, vSourceTangent, vDestLoc, vDestTangent);
|
|
|
|
// If we removed this door, then let us look at the painting that took it's place.
|
|
if (!m_pLeftRoom || !m_pRightRoom)
|
|
{
|
|
vSourceLoc = vDestLoc;
|
|
vSourceTangent = vDestTangent;
|
|
vDestLoc = D3DXVECTOR3(0.0f, 0.0f, 1.0f);
|
|
hr = _AddPaintingToPaintingMovements(ptheCamera, vSourceLoc, vSourceTangent, D3DXVECTOR3((fExitLeft ? 1.0f : -1.0f), 0.0f, 0.0f),
|
|
&vDestLoc, (g_fRoomDepthZ * (1.0f / 4.0f)), &vDestTangent, 1);
|
|
}
|
|
else
|
|
{
|
|
vSourceLoc = vDestLoc;
|
|
vSourceTangent = vDestTangent;
|
|
vDestLoc = D3DXVECTOR3((fExitLeft ? g_fRoomWidthX-DIST_TO_WALL_ON_ZOOM : DIST_TO_WALL_ON_ZOOM), fWalkHeight, (g_fRoomDepthZ * (2.0f / 4.0f)));
|
|
hr = ptheCamera->CreateNextMove(vSourceLoc, vSourceTangent, vDestLoc, vDestTangent);
|
|
|
|
// Look at painting #3
|
|
hr = ptheCamera->CreateNextWait(m_nBatch+3, 1);
|
|
|
|
vSourceLoc = vDestLoc;
|
|
vSourceTangent = vDestTangent;
|
|
vDestTangent = D3DXVECTOR3((fExitLeft ? fDistant : -fDistant), 0.0f, fDistant);
|
|
hr = ptheCamera->CreateNextRotate(vSourceLoc, vSourceTangent, vDestTangent);
|
|
}
|
|
|
|
// Now, walk from this painting close up to the location of the next painting
|
|
vSourceLoc = vDestLoc;
|
|
vSourceTangent = vDestTangent;
|
|
vDestLoc = D3DXVECTOR3((fExitLeft ? 2.0f : 1.0f) * (g_fRoomWidthX/3.0f), fWalkHeight, (g_fRoomDepthZ - fDistToWall));
|
|
vDestTangent = D3DXVECTOR3(0.0f, 0.0f, fDistant);
|
|
hr = ptheCamera->CreateNextMove(vSourceLoc, vSourceTangent, vDestLoc, vDestTangent);
|
|
|
|
vSourceLoc = vDestLoc;
|
|
vSourceTangent = vDestTangent;
|
|
vDestLoc = D3DXVECTOR3((fExitLeft ? -1.0f : 1.0f), 0.0f, 0.0f);
|
|
hr = _AddPaintingToPaintingMovements(ptheCamera, vSourceLoc, vSourceTangent, D3DXVECTOR3(0.0f, 0.0f, 1.0f),
|
|
&vDestLoc, (g_fRoomWidthX * (1.0f / 3.0f)), &vDestTangent, 1);
|
|
|
|
// Turn toward the door while walking.
|
|
vSourceLoc = vDestLoc;
|
|
vSourceTangent = D3DXVECTOR3(0.0f, 0.0f, fDistant);
|
|
vDestLoc = D3DXVECTOR3((fExitLeft ? 0.0f : g_fRoomWidthX), fWalkHeight, (WALL_WIDTHBEFOREDOOR + (DOOR_WIDTH / 2.0f)));
|
|
vDestTangent = D3DXVECTOR3((fExitLeft ? -fDistant : fDistant), 0.0f, 0.0f);
|
|
#define TURN_RATE 0.30f
|
|
D3DXVECTOR3 vTemp;
|
|
D3DXVec3Lerp(&vTemp, &vSourceLoc, &vDestLoc, TURN_RATE); // We want to do our turn towards the door while walking. We do it while walking 10% towards the door.
|
|
hr = ptheCamera->CreateNextMove(vSourceLoc, vSourceTangent, vTemp, vDestTangent);
|
|
vSourceLoc = vTemp;
|
|
|
|
|
|
// Finish walking to and thru the exit door.
|
|
vSourceTangent = vDestTangent;
|
|
vDestLoc = D3DXVECTOR3((fExitLeft ? 0.0f : g_fRoomWidthX), fWalkHeight, (WALL_WIDTHBEFOREDOOR + (DOOR_WIDTH / 2.0f)));
|
|
hr = ptheCamera->CreateNextMove(vSourceLoc, vSourceTangent, vDestLoc, vDestTangent);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT CTheRoom::_LongRoomSideEnterLeaveMovements(CCameraMove * ptheCamera)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
BOOL fExitLeft = ((1 == m_pFloorPlan->nExitDoor) ? TRUE : FALSE);
|
|
|
|
float fDistant = 5.0f;
|
|
float fDistToWall = 30.0f;
|
|
float fWalkHeight = 20.0f;
|
|
|
|
D3DXVECTOR3 vSourceLoc((fExitLeft ? g_fRoomWidthX : 0.0f), fWalkHeight, (WALL_WIDTHBEFOREDOOR + (DOOR_WIDTH / 2.0f)));
|
|
D3DXVECTOR3 vSourceTangent((fExitLeft ? -fDistant : fDistant), 0.0f, 0.0f);
|
|
|
|
hr = ptheCamera->Init(vSourceLoc, vSourceTangent, D3DXVECTOR3(0.0f, 1.0f, 0.0f));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
BOOL fExitLeft = ((1 == m_pFloorPlan->nExitDoor) ? TRUE : FALSE);
|
|
|
|
// fExitLeft 1=Left
|
|
D3DXVECTOR3 vDestLoc((fExitLeft ? g_fRoomWidthX-fDistToWall : fDistToWall), fWalkHeight, (WALL_WIDTHBEFOREDOOR + (DOOR_WIDTH / 2.0f)));
|
|
D3DXVECTOR3 vDestTangent((fExitLeft ? -fDistant : fDistant), 0.0f, 0.0f);
|
|
hr = ptheCamera->CreateNextMove(vSourceLoc, vSourceTangent, vDestLoc, vDestTangent);
|
|
|
|
vSourceLoc = vDestLoc;
|
|
vSourceTangent = vDestTangent;
|
|
vDestTangent = D3DXVECTOR3(0.0f, 0.0f, -fDistant);
|
|
hr = ptheCamera->CreateNextRotate(vSourceLoc, vSourceTangent, vDestTangent);
|
|
|
|
vSourceTangent = vDestTangent;
|
|
vDestLoc = D3DXVECTOR3((fExitLeft ? g_fRoomWidthX-fDistToWall : fDistToWall), fWalkHeight, (g_fRoomDepthZ * (3.0f / 4.0f)));
|
|
vDestTangent = vSourceTangent;
|
|
hr = ptheCamera->CreateNextMove(vSourceLoc, vSourceTangent, vDestLoc, vDestTangent);
|
|
|
|
vSourceLoc = vDestLoc;
|
|
vSourceTangent = vDestTangent;
|
|
vDestTangent = D3DXVECTOR3((fExitLeft ? fDistant : -fDistant), 0.0f, 0.0f);
|
|
hr = ptheCamera->CreateNextRotate(vSourceLoc, vSourceTangent, vDestTangent);
|
|
|
|
// Look at painting #1
|
|
hr = ptheCamera->CreateNextWait(m_nBatch+3, 2);
|
|
|
|
vSourceLoc = vDestLoc;
|
|
vSourceTangent = vDestTangent;
|
|
vDestTangent = D3DXVECTOR3(0.0f, 0.0f, -fDistant);
|
|
hr = ptheCamera->CreateNextRotate(vSourceLoc, vSourceTangent, vDestTangent);
|
|
|
|
vSourceTangent = vDestTangent;
|
|
vDestLoc = D3DXVECTOR3((fExitLeft ? g_fRoomWidthX-fDistToWall : fDistToWall), fWalkHeight, (g_fRoomDepthZ * (2.0f / 4.0f)));
|
|
vDestTangent = vSourceTangent;
|
|
hr = ptheCamera->CreateNextMove(vSourceLoc, vSourceTangent, vDestLoc, vDestTangent);
|
|
|
|
vSourceLoc = vDestLoc;
|
|
vSourceTangent = vDestTangent;
|
|
vDestTangent = D3DXVECTOR3((fExitLeft ? fDistant : -fDistant), 0.0f, 0.0f);
|
|
hr = ptheCamera->CreateNextRotate(vSourceLoc, vSourceTangent, vDestTangent);
|
|
|
|
// Look at painting #2
|
|
hr = ptheCamera->CreateNextWait(m_nBatch+3, 2);
|
|
|
|
vSourceLoc = vDestLoc;
|
|
vSourceTangent = vDestTangent;
|
|
vDestTangent = D3DXVECTOR3(0.0f, 0.0f, -fDistant);
|
|
hr = ptheCamera->CreateNextRotate(vSourceLoc, vSourceTangent, vDestTangent);
|
|
|
|
vSourceTangent = vDestTangent;
|
|
vDestLoc = D3DXVECTOR3((fExitLeft ? g_fRoomWidthX-fDistToWall : fDistToWall), fWalkHeight, (g_fRoomDepthZ * (1.0f / 4.0f)));
|
|
vDestTangent = vSourceTangent;
|
|
hr = ptheCamera->CreateNextMove(vSourceLoc, vSourceTangent, vDestLoc, vDestTangent);
|
|
|
|
vSourceLoc = vDestLoc;
|
|
vSourceTangent = vDestTangent;
|
|
vDestTangent = D3DXVECTOR3((fExitLeft ? fDistant : -fDistant), 0.0f, 0.0f);
|
|
hr = ptheCamera->CreateNextRotate(vSourceLoc, vSourceTangent, vDestTangent);
|
|
|
|
// Look at painting #3
|
|
hr = ptheCamera->CreateNextWait(m_nBatch+3, 1);
|
|
|
|
// Now do the 180 degree turn around
|
|
vSourceLoc = vDestLoc;
|
|
vSourceTangent = vDestTangent;
|
|
vDestTangent = D3DXVECTOR3(0.0f, 0.0f, (GetRandomInt(0, 1) ? -fDistant : fDistant));
|
|
hr = ptheCamera->CreateNextRotate(vSourceLoc, vSourceTangent, vDestTangent);
|
|
|
|
vSourceTangent = vDestTangent;
|
|
vDestTangent = D3DXVECTOR3((fExitLeft ? -fDistant : fDistant), 0.0f, 0.0f);
|
|
hr = ptheCamera->CreateNextRotate(vSourceLoc, vSourceTangent, vDestTangent);
|
|
|
|
vSourceLoc = vDestLoc;
|
|
vSourceTangent = vDestTangent;
|
|
vDestLoc = D3DXVECTOR3((fExitLeft ? fDistToWall : g_fRoomWidthX-fDistToWall), fWalkHeight, (g_fRoomDepthZ * (1.0f / 4.0f)));
|
|
vDestTangent = vSourceTangent;
|
|
hr = ptheCamera->CreateNextMove(vSourceLoc, vSourceTangent, vDestLoc, vDestTangent);
|
|
|
|
// Look at painting #4 (Front Wall #1)
|
|
hr = ptheCamera->CreateNextWait(m_nBatch+3, 1);
|
|
|
|
vSourceLoc = vDestLoc;
|
|
vSourceTangent = vDestTangent;
|
|
vDestTangent = D3DXVECTOR3(0.0f, 0.0f, fDistant);
|
|
hr = ptheCamera->CreateNextRotate(vSourceLoc, vSourceTangent, vDestTangent);
|
|
|
|
vSourceTangent = vDestTangent;
|
|
vDestLoc = D3DXVECTOR3((fExitLeft ? fDistToWall : g_fRoomWidthX-fDistToWall), fWalkHeight, (g_fRoomDepthZ * (2.0f / 4.0f)));
|
|
vDestTangent = vSourceTangent;
|
|
hr = ptheCamera->CreateNextMove(vSourceLoc, vSourceTangent, vDestLoc, vDestTangent);
|
|
|
|
vSourceLoc = vDestLoc;
|
|
vSourceTangent = vDestTangent;
|
|
vDestTangent = D3DXVECTOR3((fExitLeft ? -fDistant : fDistant), 0.0f, 0.0f);
|
|
hr = ptheCamera->CreateNextRotate(vSourceLoc, vSourceTangent, vDestTangent);
|
|
|
|
// Look at painting #5 (Front Wall #2)
|
|
hr = ptheCamera->CreateNextWait(m_nBatch+3, 1);
|
|
|
|
vSourceLoc = vDestLoc;
|
|
vSourceTangent = vDestTangent;
|
|
vDestTangent = D3DXVECTOR3(0.0f, 0.0f, fDistant);
|
|
hr = ptheCamera->CreateNextRotate(vSourceLoc, vSourceTangent, vDestTangent);
|
|
|
|
vSourceTangent = vDestTangent;
|
|
vDestLoc = D3DXVECTOR3((fExitLeft ? fDistToWall : g_fRoomWidthX-fDistToWall), fWalkHeight, (g_fRoomDepthZ * (3.0f / 4.0f)));
|
|
vDestTangent = vSourceTangent;
|
|
hr = ptheCamera->CreateNextMove(vSourceLoc, vSourceTangent, vDestLoc, vDestTangent);
|
|
|
|
vSourceLoc = vDestLoc;
|
|
vSourceTangent = vDestTangent;
|
|
vDestTangent = D3DXVECTOR3((fExitLeft ? -fDistant : fDistant), 0.0f, 0.0f);
|
|
hr = ptheCamera->CreateNextRotate(vSourceLoc, vSourceTangent, vDestTangent);
|
|
|
|
// Look at painting #6 (Front Wall #2)
|
|
hr = ptheCamera->CreateNextWait(m_nBatch+3, 1);
|
|
|
|
// Walk towards the door
|
|
vSourceLoc = vDestLoc;
|
|
vSourceTangent = vDestTangent;
|
|
vDestTangent = D3DXVECTOR3(0.0f, 0.0f, fDistant);
|
|
hr = ptheCamera->CreateNextRotate(vSourceLoc, vSourceTangent, vDestTangent);
|
|
|
|
vSourceTangent = vDestTangent;
|
|
vDestLoc = D3DXVECTOR3((fExitLeft ? fDistToWall : g_fRoomWidthX-fDistToWall), fWalkHeight, (WALL_WIDTHBEFOREDOOR + (DOOR_WIDTH / 2.0f)));
|
|
vDestTangent = vSourceTangent;
|
|
hr = ptheCamera->CreateNextMove(vSourceLoc, vSourceTangent, vDestLoc, vDestTangent);
|
|
|
|
// Now leave the room.
|
|
vSourceLoc = vDestLoc;
|
|
vSourceTangent = vDestTangent;
|
|
vDestTangent = D3DXVECTOR3((fExitLeft ? -fDistant : fDistant), 0.0f, 0.0f);
|
|
hr = ptheCamera->CreateNextRotate(vSourceLoc, vSourceTangent, vDestTangent);
|
|
|
|
vSourceTangent = vDestTangent;
|
|
vDestLoc = D3DXVECTOR3((fExitLeft ? 0.0f : g_fRoomWidthX), fWalkHeight, (WALL_WIDTHBEFOREDOOR + (DOOR_WIDTH / 2.0f)));
|
|
vDestTangent = vSourceTangent;
|
|
hr = ptheCamera->CreateNextMove(vSourceLoc, vSourceTangent, vDestLoc, vDestTangent);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT CTheRoom::LoadCameraMoves(CCameraMove * ptheCamera)
|
|
{ // TODO: We need to change this based on the room shape and the door entered.
|
|
HRESULT hr = S_OK;
|
|
|
|
if (m_fLobby)
|
|
{
|
|
hr = _LoadLobbyPath(ptheCamera);
|
|
}
|
|
else
|
|
{
|
|
switch (m_pFloorPlan->nMovementPattern)
|
|
{
|
|
case 0:
|
|
hr = _LongRoomEnterDoorMovements(ptheCamera);
|
|
break;
|
|
case 1:
|
|
hr = _LongRoomSideEnterLeaveMovements(ptheCamera);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT CTheRoom::_LoadLobbyPath(CCameraMove * ptheCamera)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
float fDistant = 5.0f;
|
|
float fDistToWall = 30.0f;
|
|
float fWalkHeight = 20.0f;
|
|
|
|
D3DXVECTOR3 vSourceLoc((g_fRoomWidthX / 2.0f), fWalkHeight, 1.0f);
|
|
D3DXVECTOR3 vSourceTangent(0.0f, 0.0f, fDistant);
|
|
|
|
hr = ptheCamera->Init(vSourceLoc, vSourceTangent, D3DXVECTOR3(0.0f, 1.0f, 0.0f));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// Walk down the middle of the room.
|
|
D3DXVECTOR3 vDestLoc((g_fRoomWidthX / 2.0f), fWalkHeight, (g_fRoomDepthZ * (2.0f / 4.0f)));
|
|
D3DXVECTOR3 vDestTangent(0.0f, 0.0f, 1.0f);
|
|
hr = ptheCamera->CreateNextMove(vSourceLoc, vSourceTangent, vDestLoc, vDestTangent);
|
|
|
|
// Now start walking toward the door.
|
|
vSourceLoc = vDestLoc;
|
|
vSourceTangent = vDestTangent;
|
|
|
|
// 1=Left
|
|
vDestTangent = D3DXVECTOR3(((1 == m_pFloorPlan->nExitDoor) ? -1.0f : 1.0f), 0.0f, 0.0f);
|
|
vDestLoc = D3DXVECTOR3(((1 == m_pFloorPlan->nExitDoor) ? 0.0f : g_fRoomWidthX), fWalkHeight, (WALL_WIDTHBEFOREDOOR + (DOOR_WIDTH / 2.0f)));
|
|
hr = ptheCamera->CreateNextMove(vSourceLoc, vSourceTangent, vDestLoc, vDestTangent);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
//===========================
|
|
// *** IUnknown Interface ***
|
|
//===========================
|
|
ULONG CTheRoom::AddRef()
|
|
{
|
|
return InterlockedIncrement(&m_cRef);
|
|
}
|
|
|
|
|
|
ULONG CTheRoom::Release()
|
|
{
|
|
if (InterlockedDecrement(&m_cRef))
|
|
return m_cRef;
|
|
|
|
delete this;
|
|
return 0;
|
|
}
|
|
|
|
|
|
HRESULT CTheRoom::QueryInterface(REFIID riid, void **ppvObj)
|
|
{
|
|
static const QITAB qit[] = {
|
|
QITABENT(CTheRoom, IUnknown),
|
|
{ 0 },
|
|
};
|
|
|
|
return QISearch(this, qit, riid, ppvObj);
|
|
}
|
|
|
|
|
|
|
|
int CTheRoom::GetEnterDoor(void)
|
|
{
|
|
int nDoor = 0;
|
|
|
|
if (m_pFloorPlan)
|
|
{
|
|
nDoor = m_pFloorPlan->nEnterDoor;
|
|
}
|
|
|
|
return nDoor;
|
|
}
|
|
|
|
|
|
int CTheRoom::GetExitDoor(void)
|
|
{
|
|
int nDoor = 0;
|
|
|
|
if (m_pFloorPlan)
|
|
{
|
|
nDoor = m_pFloorPlan->nExitDoor;
|
|
}
|
|
|
|
return nDoor;
|
|
}
|
|
|