254 lines
7.1 KiB
C++
254 lines
7.1 KiB
C++
//--------------------------------------------------------------------------------------
|
|
// File: TemplateMain.cpp
|
|
//
|
|
// BTH-D3D-Template
|
|
//
|
|
// Copyright (c) Stefan Petersson 2011. All rights reserved.
|
|
//--------------------------------------------------------------------------------------
|
|
#include "Engine\Engine.h"
|
|
using namespace Oyster;
|
|
using namespace Oyster::Render;
|
|
//--------------------------------------------------------------------------------------
|
|
// Forward declarations
|
|
//--------------------------------------------------------------------------------------
|
|
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
|
|
bool InitDX11(HINSTANCE hInstance,int nCmdShow);
|
|
HRESULT Render(float deltaTime);
|
|
HRESULT Update(float deltaTime);
|
|
|
|
Oyster::Buffer *cb;
|
|
Oyster::Buffer *camBuffer1;
|
|
Oyster::Buffer *camBuffer2;
|
|
bool cam1Buffered = true;
|
|
Model m[2];
|
|
std::vector<Oyster::Render::Model> models = std::vector<Oyster::Render::Model>(10);
|
|
Oyster::Render::Camera cam = Oyster::Render::Camera();
|
|
|
|
struct PerObjectBuffer
|
|
{
|
|
Oyster::Math::Float4x4 matrix;
|
|
};
|
|
|
|
|
|
//--------------------------------------------------------------------------------------
|
|
// Entry point to the program. Initializes everything and goes into a message processing
|
|
// loop. Idle time is used to render the scene.
|
|
//--------------------------------------------------------------------------------------
|
|
int WINAPI wWinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR lpCmdLine, int nCmdShow )
|
|
{
|
|
if(!InitDX11(hInstance,nCmdShow))
|
|
return 0;
|
|
|
|
__int64 cntsPerSec = 0;
|
|
QueryPerformanceFrequency((LARGE_INTEGER*)&cntsPerSec);
|
|
float secsPerCnt = 1.0f / (float)cntsPerSec;
|
|
|
|
__int64 prevTimeStamp = 0;
|
|
QueryPerformanceCounter((LARGE_INTEGER*)&prevTimeStamp);
|
|
|
|
// Main message loop
|
|
MSG msg = {0};
|
|
while(WM_QUIT != msg.message)
|
|
{
|
|
if( PeekMessage( &msg, NULL, 0, 0, PM_REMOVE) )
|
|
{
|
|
TranslateMessage( &msg );
|
|
DispatchMessage( &msg );
|
|
}
|
|
else
|
|
{
|
|
__int64 currTimeStamp = 0;
|
|
QueryPerformanceCounter((LARGE_INTEGER*)&currTimeStamp);
|
|
float dt = (currTimeStamp - prevTimeStamp) * secsPerCnt;
|
|
|
|
//render
|
|
Update(dt);
|
|
::Render(dt);
|
|
|
|
prevTimeStamp = currTimeStamp;
|
|
}
|
|
}
|
|
|
|
return (int) msg.wParam;
|
|
}
|
|
|
|
bool InitDX11(HINSTANCE hInstance,int nCmdShow)
|
|
{
|
|
Engine::Init::Setup setup=Engine::Init::Setup();
|
|
setup.Window.appname = "OysterDemo";
|
|
setup.Window.classname = "OysterDemo";
|
|
setup.Window.hinstance = hInstance;
|
|
setup.Window.nCmdShow = nCmdShow;
|
|
setup.Window.wProc = &WndProc;
|
|
setup.Window.InitWindow = true;
|
|
setup.Common.Fullscreen = false;
|
|
if(!Oyster::Engine::Init::FullInit(setup))
|
|
return 0;
|
|
|
|
Oyster::Math::Float4x4 matrix = Oyster::Math::Float4x4();
|
|
cam.LookAt(Oyster::Math::Float3(0,0,-70),Oyster::Math::Float3(0,0,1),Oyster::Math::Float3(0,1,0));
|
|
//cam.SetLens(PI/4,1024.0f / 768.0f,1,200);
|
|
cam.SetLens(PI/4,1920.0f / 1080.0f,1,200);
|
|
cam.UpdateViewMatrix();
|
|
matrix=cam.ViewProj();
|
|
|
|
Oyster::Shader::ShaderEffect se;
|
|
se.Shaders.Vertex = Oyster::Shader::Get::GetVertex("VSObj");
|
|
se.Shaders.Pixel = Oyster::Shader::Get::GetPixel("PSObj");
|
|
se.IAStage.Topology = D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST;
|
|
|
|
ID3D11InputLayout* layout;
|
|
|
|
D3D11_INPUT_ELEMENT_DESC ElemDesc[] =
|
|
{
|
|
{"POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0},
|
|
{"NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0},
|
|
{"TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 24, D3D11_INPUT_PER_VERTEX_DATA, 0},
|
|
};
|
|
Oyster::Shader::CreateInputLayout(ElemDesc,3,Oyster::Shader::Get::GetVertex("VSObj"),layout);
|
|
se.IAStage.Layout = layout;
|
|
|
|
Oyster::Buffer::BUFFER_INIT_DESC desc;
|
|
|
|
desc.ElementSize=sizeof(Oyster::Math::Float4x4);
|
|
desc.NumElements = 1;
|
|
desc.Usage = Oyster::Buffer::BUFFER_CPU_WRITE_DISCARD;
|
|
desc.Type = Oyster::Buffer::CONSTANT_BUFFER_VS;
|
|
desc.InitData = matrix;
|
|
|
|
camBuffer1 = Oyster::Engine::Init::Buffers::CreateBuffer(desc);
|
|
se.CBuffers.Vertex.push_back(camBuffer1);
|
|
|
|
Oyster::Shader::SetShaderEffect(se);
|
|
|
|
//create Buffers
|
|
Oyster::FileLoaders::ObjReader *reader = Oyster::FileLoaders::ObjReader::LoadFile("bth.OBJ");
|
|
Oyster::FileLoaders::ObjReader::Vertex** vertex = new Oyster::FileLoaders::ObjReader::Vertex*[1];
|
|
int vcount;
|
|
std::map<std::string,ID3D11ShaderResourceView *> textures;
|
|
reader->GetVertexData(vertex,vcount,textures);
|
|
|
|
desc.ElementSize=sizeof(Oyster::FileLoaders::ObjReader::Vertex);
|
|
desc.NumElements = vcount;
|
|
desc.InitData = *vertex;
|
|
desc.Type = Oyster::Buffer::VERTEX_BUFFER;
|
|
desc.Usage = Oyster::Buffer::BUFFER_DEFAULT;
|
|
|
|
Oyster::Buffer *VB = Oyster::Engine::Init::Buffers::CreateBuffer(desc);
|
|
|
|
ID3D11ShaderResourceView *srv = textures["Diffuse"];
|
|
|
|
Oyster::Math::Float4x4 *world = new Oyster::Math::Float4x4();
|
|
Oyster::Math::identityMatrix(*world);
|
|
|
|
world->m43 = 20; // edited by Dan 04-19 : Still not good :/
|
|
world->m11 = 0.5f;
|
|
world->m22 = 0.5f;
|
|
world->m33 = 0.5f;
|
|
|
|
desc.ElementSize=64;
|
|
desc.NumElements=1;
|
|
desc.Type = Oyster::Buffer::CONSTANT_BUFFER_VS;
|
|
desc.Usage = Oyster::Buffer::BUFFER_CPU_WRITE_DISCARD;
|
|
desc.InitData = NULL;
|
|
|
|
cb = Oyster::Engine::Init::Buffers::CreateBuffer(desc);
|
|
|
|
m[0] = *(new Oyster::Render::Model());
|
|
|
|
m[0].World = world;
|
|
m[0].info->VertexCount = vcount;
|
|
m[0].info->Material.push_back(srv);
|
|
m[0].info->Indexed=false;
|
|
m[0].Visible=true;
|
|
m[0].info->Vertices=*VB;
|
|
|
|
models.push_back(m[0]);
|
|
|
|
world = new Oyster::Math::Float4x4(*world);
|
|
|
|
m[1] = * (new Oyster::Render::Model(m[0]));
|
|
world->m43 = 00;
|
|
m[1].World=world;
|
|
|
|
//models.push_back(m[1]);
|
|
|
|
return true;
|
|
}
|
|
|
|
HRESULT Update(float deltaTime)
|
|
{
|
|
//Early Exit
|
|
if(Oyster::Input::Controller::isKeyReleased(VK_ESCAPE))
|
|
PostQuitMessage(0);
|
|
if(Oyster::Input::Controller::isKeyDown(87))
|
|
cam.Walk(10*deltaTime);
|
|
if(Oyster::Input::Controller::isKeyDown(0x53))
|
|
cam.Walk(-10*deltaTime);
|
|
if(Oyster::Input::Controller::isKeyDown(0x41))
|
|
cam.Strafe(-10*deltaTime);
|
|
if(Oyster::Input::Controller::isKeyDown(0x44))
|
|
cam.Strafe(10*deltaTime);
|
|
if(Oyster::Input::Controller::isKeyDown(0x10))
|
|
cam.Fly(-10*deltaTime);
|
|
if(Oyster::Input::Controller::isKeyDown(0x20))
|
|
cam.Fly(10*deltaTime);
|
|
|
|
Matrix rot;
|
|
Oyster::Math::rotationMatrix_AxisY(rot,deltaTime*PI/4);
|
|
*(m[1].World) =rot * *(m[1].World);
|
|
|
|
Oyster::Math::rotationMatrix_AxisX(rot,deltaTime*PI/4);
|
|
*(m[0].World) = rot * *(m[0].World);
|
|
|
|
cam.UpdateViewMatrix();
|
|
|
|
|
|
void* temp = camBuffer1->Map();
|
|
if(temp)
|
|
{
|
|
memcpy(temp,&cam.ViewProj(),sizeof(Matrix));
|
|
camBuffer1->Unmap();
|
|
}
|
|
|
|
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT Render(float deltaTime)
|
|
{
|
|
Oyster::Engine::PrepareForRendering::ClearBackBuffer(Oyster::Math::Float4(0,0,1,1));
|
|
|
|
Oyster::Engine::Render::Geometry(m,2,cb,1);
|
|
|
|
Oyster::Engine::Render::PresentScene();
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------
|
|
// Called every time the application receives a message
|
|
//--------------------------------------------------------------------------------------
|
|
LRESULT CALLBACK WndProc( HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam )
|
|
{
|
|
PAINTSTRUCT ps;
|
|
HDC hdc;
|
|
|
|
switch (message)
|
|
{
|
|
case WM_PAINT:
|
|
hdc = BeginPaint(hWnd, &ps);
|
|
EndPaint(hWnd, &ps);
|
|
break;
|
|
|
|
case WM_DESTROY:
|
|
PostQuitMessage(0);
|
|
break;
|
|
|
|
default:
|
|
return DefWindowProc(hWnd, message, wParam, lParam);
|
|
}
|
|
|
|
return 0;
|
|
} |