vsDisplayList *
vsDisplayList::Load( const vsString &filename )
{
// int vec = filename.find(".vec");
// int obj = filename.find(".obj");
vsDisplayList *result = NULL;
// check for a precompiled version of this file.
{
if ( vsFile::Exists(filename + vsString(".vec")) )
{
result = Load_Vec(filename);
//result->Write_CVec(filename);
}
else if ( vsFile::Exists(filename + vsString(".obj")) )
{
result = Load_Obj(filename);
//result->Write_CVec(filename);
}
}
vsAssert(result, vsFormatString("Unable to load %s", filename.c_str()) );
return result;
}
void
daModeTitleScreen::Init()
{
m_menuItemSelected = 0;
m_menu = new utMenu( MENU_MAX, 25.0f, 35.0f, 20.0f );
m_menu->SetItemLabel(NewGame, "New Game");
m_menu->SetItemLabel(HowToPlay, "How To Play");
m_menu->SetItemLabel(Options, "Options");
m_menu->SetItemLabel(Credits, "Credits");
m_menu->SetItemLabel(Quit, "Quit");
m_menuThump = new sndSample("thump_4.wav");
m_title = new vsSprite( NULL );
vsSprite *timed = new vsSprite(vsBuiltInFont::CreateString(vsString("Ill-Timed"), 30.0f, 80.0f, Justification_Right));
vsSprite *petition = new vsSprite(vsBuiltInFont::CreateString(vsString("Petition"), 60.0f, 80.0f, Justification_Right));
vsSprite *damsel = new vsSprite(vsBuiltInFont::CreateString(vsString("Damsel"), 90.0f, 90.0f, Justification_Right));
timed->SetPosition( vsVector2D(0.0f,0.0f) );
petition->SetPosition( vsVector2D(0.0f,80.0f) );
damsel->SetPosition( vsVector2D(0.0f,180.0f) );
m_title->AddChild(timed);
m_title->AddChild(petition);
m_title->AddChild(damsel);
m_background = new daLevelBackground;
m_background->SetPosition(vsVector2D(-400.0f,100.0f));
m_background->RegisterOnLayer(0);
m_background->FadeIn();
m_title->RegisterOnLayer(1);
m_menu->Enter();
m_menu->RegisterOnLayer(1);
m_transitioningIn = true;
m_transitioningOut = false;
m_transitionTimer = 0.f;
titlePos.x = vsScreen::Instance()->GetLayer(1)->GetTopRightCorner().x - 100.f;
m_iniTitlePos = titlePos;
m_iniMenuPos = menuPos;
m_iniTitlePos.y = vsScreen::Instance()->GetLayer(1)->GetTopLeftCorner().y - 300.f;
m_iniMenuPos.x = vsScreen::Instance()->GetLayer(1)->GetTopLeftCorner().x - 400.0f;
m_menu->SetPosition(m_iniMenuPos);
m_title->SetPosition(m_iniTitlePos);
m_title->SetColor(vsColor::Black);
m_game->PlayMusic( daGame::Music_Title );
}
vsDisplayList *
vsDisplayList::Load_Vec( const vsString &filename )
{
vsDisplayList *loader = new vsDisplayList(1024 * 50); // 50k should be enough to load in just about anything. (famous last words)
vsFile *file = new vsFile(filename + vsString(".vec"));
vsRecord r;
vsMaterial *materialList[MAX_OWNED_MATERIALS];
int materialCount = 0;
while( file->Record(&r) )
{
Load_Vec_SingleRecord( loader, &r );
}
delete file;
vsAssert(loader->GetSize() > 0.f, "Didn't get any operations in a loaded display list!" )
vsDisplayList *result = new vsDisplayList( loader->GetSize() );
for ( int i = 0; i < materialCount; i++ )
{
result->m_material[i] = materialList[i];
result->m_materialCount = materialCount;
}
result->Append(*loader);
delete loader;
return result;
}
void
vsDisplayList::Write_CVec( const vsString &filename )
{
vsFile *file = new vsFile(filename + vsString(".cvec"), vsFile::MODE_Write);
file->Store(m_fifo);
vsDelete( file );
}
vsDisplayList *
vsDisplayList::Load_Obj( const vsString &filename )
{
int vertCount = 0;
int faceIndexCount = 0;
vsDisplayList *loader = new vsDisplayList(1024 * 200); // 50k should be enough to load in just about anything. (famous last words)
vsFile *file = new vsFile(filename + vsString(".obj"));
vsRecord r;
vsString faceStr("f");
vsString vertStr("v");
while( file->Record(&r) )
{
vsString label = r.GetLabel().AsString();
if ( label == vertStr )
vertCount++;
if ( label == faceStr )
faceIndexCount+=3;
}
file->Rewind();
vsVector3D *vertexPos = new vsVector3D[vertCount];
int *triangleIndex = new int[faceIndexCount];
int v = 0;
int f = 0;
while( file->Record(&r) )
{
vsString label = r.GetLabel().AsString();
if ( label == vertStr )
vertexPos[v++].Set(r.GetToken(0).AsFloat(), -r.GetToken(1).AsFloat(), 0.f);
if ( label == faceStr )
{
triangleIndex[f++] = r.GetToken(0).AsInteger()-1;
triangleIndex[f++] = r.GetToken(1).AsInteger()-1;
triangleIndex[f++] = r.GetToken(2).AsInteger()-1;
}
}
loader->VertexArray( vertexPos, vertCount );
loader->TriangleListArray( triangleIndex, faceIndexCount );
delete file;
vsAssert(loader->GetSize() > 0, "Didn't get any operations in a loaded display list!" )
vsLog("Display list is %d bytes", loader->GetSize());
vsDisplayList *result = new vsDisplayList( loader->GetSize() );
result->Append(*loader);
delete loader;
vsDeleteArray(vertexPos);
vsDeleteArray(triangleIndex);
return result;
}
bool CShader::CreateFromCompiledFile(EInputLayoutType type, const wchar* psPath, const wchar* vsPath, const wchar* gsPath, const wchar* dsPath, const wchar* hsPath)
{
HRESULT hr;
CompileFromFile(type, L"../assets/parallaxPS.fx", L"../assets/parallaxVS.fx");
// D3DReadFileToBlob(vsPath, &m_vsBlob);
std::ifstream vsStream(vsPath, std::ifstream::binary);
if(vsStream.fail()) assert(false);
std::string vsString((std::istreambuf_iterator<char>(vsStream)), std::istreambuf_iterator<char>());
int vsSize = vsString.size();
// hr = GetDevice()->CreateVertexShader(m_vsBlob->GetBufferPointer(), m_vsBlob->GetBufferSize(), NULL, &m_vs);
hr = GetDX11Device()->CreateVertexShader(vsString.c_str(), vsSize, NULL, &m_vs);
if(FAILED(hr)) assert(false);
switch(type)
{
case EInputLayoutType::Position:
hr = GetDX11Device()->CreateInputLayout(layoutPos, ARRAYSIZE(layoutPos), vsString.c_str(), vsSize, &m_inputLayout);
break;
case EInputLayoutType::PositionTexture:
hr = GetDX11Device()->CreateInputLayout(layoutPosTex, ARRAYSIZE(layoutPosTex), vsString.c_str(), vsSize, &m_inputLayout);
break;
case EInputLayoutType::PositionTextureNormal:
hr = GetDX11Device()->CreateInputLayout(layoutPosTexNorm, ARRAYSIZE(layoutPosTexNorm), vsString.c_str(), vsSize, &m_inputLayout);
break;
case EInputLayoutType::PositionTextureNormalTangentBinormal:
hr = GetDX11Device()->CreateInputLayout(layoutPosTexNormalBitangentTangent, ARRAYSIZE(layoutPosTexNormalBitangentTangent), vsString.c_str(), vsSize, &m_inputLayout);
break;
case EInputLayoutType::PositionTextureNormalTangentSkinned:
hr = GetDX11Device()->CreateInputLayout(layoutPosTexNormalTangentSkinned, ARRAYSIZE(layoutPosTexNormalTangentSkinned), vsString.c_str(), vsSize, &m_inputLayout);
break;
case EInputLayoutType::BasicParticle:
hr = GetDX11Device()->CreateInputLayout(basicParticlelayout, ARRAYSIZE(basicParticlelayout), vsString.c_str(), vsSize, &m_inputLayout);
break;
case EInputLayoutType::TerrainLayout:
hr = GetDX11Device()->CreateInputLayout(layoutTerrain, ARRAYSIZE(layoutTerrain), vsString.c_str(), vsSize, &m_inputLayout);
break;
}
if(FAILED(hr)) assert(false);
vsStream.close();
////////////////////////////////////////////
std::ifstream psStream(psPath, std::ifstream::binary);
if(psStream.fail()) assert(false);
std::string psString((std::istreambuf_iterator<char>(psStream)), std::istreambuf_iterator<char>());
int psSize = psString.size();
hr = GetDX11Device()->CreatePixelShader(psString.c_str(), psSize, NULL, &m_ps);
if(FAILED(hr)) assert(false);
psStream.close();
/////////////////////////////////////////////
if(gsPath != nullptr)
{
std::ifstream gsStream(gsPath, std::ifstream::binary);
if(gsStream.fail()) assert(false);
std::string gsString((std::istreambuf_iterator<char>(gsStream)), std::istreambuf_iterator<char>());
int gsSize = gsString.size();
hr = GetDX11Device()->CreateGeometryShader(gsString.c_str(), gsSize, NULL, &m_gs);
if(FAILED(hr)) assert(false);
gsStream.close();
}
if(hsPath != nullptr)
{
std::ifstream hsStream(hsPath, std::ifstream::binary);
if(hsStream.fail()) assert(false);
std::string hsString((std::istreambuf_iterator<char>(hsStream)), std::istreambuf_iterator<char>());
int hsSize = hsString.size();
hr = GetDX11Device()->CreateHullShader(hsString.c_str(), hsSize, NULL, &m_hs);
if(FAILED(hr)) assert(false);
hsStream.close();
}
if(dsPath != nullptr)
{
std::ifstream dsStream(dsPath, std::ifstream::binary);
if(dsStream.fail()) assert(false);
std::string dsString((std::istreambuf_iterator<char>(dsStream)), std::istreambuf_iterator<char>());
int dsSize = dsString.size();
hr = GetDX11Device()->CreateDomainShader(dsString.c_str(), dsSize, NULL, &m_ds);
if(FAILED(hr)) assert(false);
dsStream.close();
}
return true;
}
void CRtwShadowRenderer::InitImportanceShaders()
{
HRESULT hr;
{
std::ifstream vsStream("..\\assets\\importanceMapVS.cso", std::ifstream::binary);
if(vsStream.fail()) assert(false);
std::string vsString((std::istreambuf_iterator<char>(vsStream)), std::istreambuf_iterator<char>());
int vsSize = vsString.size();
hr = Globals::Get().device.m_device->CreateVertexShader(vsString.c_str(), vsSize, NULL, &m_importanceVS);
ASSERT_ON_FAIL(hr);
hr = Globals::Get().device.m_device->CreateInputLayout(layoutPosTexNormalBitangentTangent, ARRAYSIZE(layoutPosTexNormalBitangentTangent), vsString.c_str(), vsSize, &m_inputLayout);
ASSERT_ON_FAIL(hr);
}
////////////////////////////////////////////
{
std::ifstream psStream("..\\assets\\importanceMapPS.cso", std::ifstream::binary);
if(psStream.fail()) assert(false);
std::string psString((std::istreambuf_iterator<char>(psStream)), std::istreambuf_iterator<char>());
int psSize = psString.size();
hr = GetDX11Device()->CreatePixelShader(psString.c_str(), psSize, NULL, &m_importancePS);
ASSERT_ON_FAIL(hr);
psStream.close();
}
/////////////////////////////////////////////
{
std::ifstream vsStream("..\\assets\\shadowmapRtwVS.cso", std::ifstream::binary);
if(vsStream.fail()) assert(false);
std::string vsString((std::istreambuf_iterator<char>(vsStream)), std::istreambuf_iterator<char>());
int vsSize = vsString.size();
hr = Globals::Get().device.m_device->CreateVertexShader(vsString.c_str(), vsSize, NULL, &m_shadowMapRtwVS);
ASSERT_ON_FAIL(hr);
}
////////////////////////////////////////////
{
std::ifstream psStream("..\\assets\\shadowmapRtwPS.cso", std::ifstream::binary);
if(psStream.fail()) assert(false);
std::string psString((std::istreambuf_iterator<char>(psStream)), std::istreambuf_iterator<char>());
int psSize = psString.size();
hr = GetDX11Device()->CreatePixelShader(psString.c_str(), psSize, NULL, &m_shadowMapRtwPS);
ASSERT_ON_FAIL(hr);
psStream.close();
}
///////////////////////////////////////////
{
std::ifstream vsStream("..\\assets\\renderFinalVS.cso", std::ifstream::binary);
if(vsStream.fail()) assert(false);
std::string vsString((std::istreambuf_iterator<char>(vsStream)), std::istreambuf_iterator<char>());
int vsSize = vsString.size();
hr = Globals::Get().device.m_device->CreateVertexShader(vsString.c_str(), vsSize, NULL, &m_finalVS);
ASSERT_ON_FAIL(hr);
}
////////////////////////////////////////////
{
std::ifstream psStream("..\\assets\\renderFinalPS.cso", std::ifstream::binary);
if(psStream.fail()) assert(false);
std::string psString((std::istreambuf_iterator<char>(psStream)), std::istreambuf_iterator<char>());
int psSize = psString.size();
hr = GetDX11Device()->CreatePixelShader(psString.c_str(), psSize, NULL, &m_finalPS);
ASSERT_ON_FAIL(hr);
psStream.close();
}
{
std::ifstream psStream("..\\assets\\warpMapPS.cso", std::ifstream::binary);
if(psStream.fail()) assert(false);
std::string psString((std::istreambuf_iterator<char>(psStream)), std::istreambuf_iterator<char>());
int psSize = psString.size();
hr = GetDX11Device()->CreatePixelShader(psString.c_str(), psSize, NULL, &m_calculateWarpPS);
ASSERT_ON_FAIL(hr);
psStream.close();
}
////////////////////////////////////////////
{
std::ifstream vsStream("..\\assets\\depthOnly.cso", std::ifstream::binary);
if(vsStream.fail()) assert(false);
std::string vsString((std::istreambuf_iterator<char>(vsStream)), std::istreambuf_iterator<char>());
int vsSize = vsString.size();
hr = Globals::Get().device.m_device->CreateVertexShader(vsString.c_str(), vsSize, NULL, &m_depthVS);
if(FAILED(hr)) assert(false);
}
}
void InitQuad()
{
ID3D11VertexShader* m_fullScreenQuadVS;
ID3D11InputLayout* m_fullScreenQuadInputLayout;
ID3D11Buffer* m_quadVB;
ID3D11Buffer* m_quadIB;
D3D11_INPUT_ELEMENT_DESC layout[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
};
HRESULT hr;
{
std::ifstream vsStream("..\\assets\\fullScreenQuadVS.cso", std::ifstream::binary);
if(vsStream.fail()) assert(false);
std::string vsString((std::istreambuf_iterator<char>(vsStream)), std::istreambuf_iterator<char>());
int vsSize = vsString.size();
hr = Globals::Get().device.m_device->CreateVertexShader(vsString.c_str(), vsSize, NULL, &m_fullScreenQuadVS);
ASSERT_ON_FAIL(hr);
hr = Globals::Get().device.m_device->CreateInputLayout(layout, ARRAYSIZE(layoutPosTexNormalBitangentTangent), vsString.c_str(), vsSize, &m_fullScreenQuadInputLayout);
ASSERT_ON_FAIL(hr);
}
QuadVertex verts[4] =
{
{ XMFLOAT4( 1, 1, 1, 1), XMFLOAT2(1, 0) },
{ XMFLOAT4( 1, -1, 1, 1), XMFLOAT2(1, 1) },
{ XMFLOAT4(-1, -1, 1, 1), XMFLOAT2(0, 1) },
{ XMFLOAT4(-1, 1, 1, 1), XMFLOAT2(0, 0) }
};
D3D11_BUFFER_DESC desc;
desc.Usage = D3D11_USAGE_IMMUTABLE;
desc.ByteWidth = sizeof(verts);
desc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
desc.CPUAccessFlags = 0;
desc.MiscFlags = 0;
D3D11_SUBRESOURCE_DATA initData;
initData.pSysMem = verts;
initData.SysMemPitch = 0;
initData.SysMemSlicePitch = 0;
hr = GetDX11Device()->CreateBuffer(&desc, &initData, &m_quadVB);
unsigned short indices[6] = { 0, 1, 2, 2, 3, 0 };
desc.Usage = D3D11_USAGE_IMMUTABLE;
desc.ByteWidth = sizeof(indices);
desc.BindFlags = D3D11_BIND_INDEX_BUFFER;
desc.CPUAccessFlags = 0;
initData.pSysMem = indices;
hr = GetDX11Device()->CreateBuffer(&desc, &initData, &m_quadIB);
//////////////////////////
GetDX11Context()->IASetInputLayout(m_fullScreenQuadInputLayout);
UINT stride = sizeof(QuadVertex);
UINT offset = 0;
ID3D11Buffer* vertexBuffers[1] = { m_quadVB };
GetDX11Context()->IASetVertexBuffers(0, 1, vertexBuffers, &stride, &offset);
GetDX11Context()->IASetIndexBuffer(m_quadIB, DXGI_FORMAT_R16_UINT, 0);
GetDX11Context()->DrawIndexed(6, 0, 0);
}
