void doStar(StarFormat *star) {
int nx,ny;
if (star->z > 0) {
nx = ((star->x<<7) / star->z) + Xoff;
ny = ((star->y<<7) / star->z) + Yoff;
if (nx>0 && nx<320 && ny>0 && ny<200) {
SetPixel(nx,ny, Colour(star->z));
star->ox = nx;
star->oy = ny;
star->z -= WarpSpeed;
}
else CreateStar(star);
} else CreateStar(star);
}
void InitializeStars() {
int i;
StarFormat *star;
needup=0;
star = &Stars[0];
for (i=0;i<MaxStars;i++,star++) {
CreateStar(star);
star->z = Random(255);
}
}
/**
* Det star incarnate creation function
*/
snet_stream_t *SNetStarDetIncarnate(snet_stream_t *input,
snet_info_t *info,
int location,
snet_variant_list_t *exit_patterns,
snet_expr_list_t *guards,
snet_startup_fun_t box_a,
snet_startup_fun_t box_b)
{
return CreateStar( input, info, location, exit_patterns, guards, box_a, box_b,
true, /* is incarnate */
true /* is det */
);
}
/**
* Star creation function
*/
snet_stream_t *SNetStar( snet_stream_t *input,
snet_info_t *info,
int location,
snet_variant_list_t *exit_patterns,
snet_expr_list_t *guards,
snet_startup_fun_t box_a,
snet_startup_fun_t box_b)
{
return CreateStar( input, info, location, exit_patterns, guards, box_a, box_b,
false, /* not incarnate */
false /* not det */
);
}
/* Det Star creation function */
snet_stream_t *SNetStarDet(snet_stream_t *input,
snet_info_t *info,
int location,
snet_variant_list_t *exit_patterns,
snet_expr_list_t *guards,
snet_startup_fun_t box_a,
snet_startup_fun_t box_b)
{
snet_stream_t *outstream;
trace(__func__);
SNetDetIncrLevel();
outstream = CreateStar( input, info, location, exit_patterns, guards, box_a, box_b,
false, /* not incarnate */
true); /* is det */
SNetDetDecrLevel();
return outstream;
}
void Space::GenBody(double time, SystemBody* sbody, Frame* f)
{
Entity e = m_entities->create();
if (sbody->GetType() != SystemBody::TYPE_GRAVPOINT) {
if (sbody->GetSuperType() == SystemBody::SUPERTYPE_STAR) {
CreateStar(e, sbody);
} else if ((sbody->GetType() == SystemBody::TYPE_STARPORT_ORBITAL) ||
(sbody->GetType() == SystemBody::TYPE_STARPORT_SURFACE)) {
//SpaceStation *ss = new SpaceStation(sbody);
//b = ss;
return;
} else {
CreatePlanet(e, sbody);
}
e.assign<NameComponent>(sbody->GetName());
e.assign<PosOrientComponent>(vector3d(0.0), matrix3x3d(1.0));
}
f = MakeFrameFor(time, sbody, e, f);
for (SystemBody* child : sbody->GetChildren())
GenBody(time, child, f);
}
DEMO::DEMO(HINSTANCE hinst, WNDPROC proc)
{
// ****************** BEGIN WARNING ***********************//
application = hinst;
appWndProc = proc;
WNDCLASSEX wndClass;
ZeroMemory(&wndClass, sizeof(wndClass));
wndClass.cbSize = sizeof(WNDCLASSEX);
wndClass.lpfnWndProc = appWndProc;
wndClass.lpszClassName = L"DirectXApplication";
wndClass.hInstance = application;
wndClass.hCursor = LoadCursor(NULL, IDC_ARROW);
wndClass.hbrBackground = (HBRUSH)(COLOR_WINDOWFRAME);
//wndClass.hIcon = LoadIcon(GetModuleHandle(NULL), MAKEINTRESOURCE(IDI_FSICON));
RegisterClassEx(&wndClass);
RECT window_size = { 0, 0, (long)BACKBUFFER_WIDTH, (long)BACKBUFFER_HEIGHT };
AdjustWindowRect(&window_size, WS_OVERLAPPEDWINDOW, false);
window = CreateWindow(L"DirectXApplication", L"Mockingbird", WS_OVERLAPPEDWINDOW /*& ~(WS_THICKFRAME | WS_MAXIMIZEBOX)*/,
CW_USEDEFAULT, CW_USEDEFAULT, window_size.right - window_size.left, window_size.bottom - window_size.top,
NULL, NULL, application, this);
ShowWindow(window, SW_SHOW);
//********************* END WARNING ************************//
//D3D Init
DXGI_SWAP_CHAIN_DESC swapchain_DESC;
ZeroMemory(&swapchain_DESC, sizeof(swapchain_DESC));
swapchain_DESC.BufferCount = 1;
swapchain_DESC.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
swapchain_DESC.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT | DXGI_USAGE_SHADER_INPUT;
swapchain_DESC.BufferDesc.Width = (UINT)BACKBUFFER_WIDTH;
swapchain_DESC.BufferDesc.Height = (UINT)BACKBUFFER_HEIGHT;
swapchain_DESC.BufferDesc.RefreshRate.Numerator = 60;
swapchain_DESC.BufferDesc.RefreshRate.Denominator = 1;
swapchain_DESC.OutputWindow = window;
#if MSAA
swapchain_DESC.SampleDesc.Count = MSAA_COUNT;
#else
swapchain_DESC.SampleDesc.Count = 1;
#endif
swapchain_DESC.SampleDesc.Quality = D3D11_STANDARD_MULTISAMPLE_PATTERN;
swapchain_DESC.Windowed = TRUE;
//Create Device and Swapchain DEBUG
D3D_FEATURE_LEVEL FeatureLevel = D3D_FEATURE_LEVEL_11_0;
HRESULT hr = D3D11CreateDeviceAndSwapChain(
NULL,
D3D_DRIVER_TYPE_HARDWARE,
NULL,
D3D11_CREATE_DEVICE_DEBUG,
&FeatureLevel,
1,
D3D11_SDK_VERSION,
&swapchain_DESC,
&pSwapchain,
&pDevice,
&featureLevel,
&pDeviceContext);
pDevice->CreateDeferredContext(0, &pDeferredDeviceContext);
//Create Render Target View from back buffer
ID3D11Texture2D* pBackBuffer = nullptr;
pSwapchain->GetBuffer(0, __uuidof(ID3D11Texture2D), reinterpret_cast<void**>(&pBackBuffer));
pDevice->CreateRenderTargetView(pBackBuffer, 0, &pRenderTargetView);
SecureRelease(pBackBuffer);
D3D11_TEXTURE2D_DESC renderToTextureDesc;
ZeroMemory(&renderToTextureDesc, sizeof(renderToTextureDesc));
renderToTextureDesc.Usage = D3D11_USAGE_DEFAULT;
renderToTextureDesc.BindFlags = D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE;
renderToTextureDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
renderToTextureDesc.Height = swapchain_DESC.BufferDesc.Height;
renderToTextureDesc.Width = swapchain_DESC.BufferDesc.Width;
renderToTextureDesc.SampleDesc.Count = 1;
renderToTextureDesc.ArraySize = 1;
renderToTextureDesc.MipLevels = 1;
pDevice->CreateTexture2D(&renderToTextureDesc, NULL, &pQuad_texture);
pDevice->CreateRenderTargetView(pQuad_texture, 0, &pQuadRTV);
quadDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
quadDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
quadDesc.Texture2D.MipLevels = 1;
quadDesc.Texture2D.MostDetailedMip = 0;
pDevice->CreateShaderResourceView(pQuad_texture, &quadDesc, &pQuadSRV);
//Set up view port
ZeroMemory(&viewport, sizeof(viewport));
viewport.MaxDepth = 1;
viewport.MinDepth = 0;
viewport.TopLeftX = 0;
viewport.TopLeftY = 0;
viewport.Width = (float)swapchain_DESC.BufferDesc.Width / 2.0f;
viewport.Height = (float)swapchain_DESC.BufferDesc.Height;
ZeroMemory(&another_viewport, sizeof(another_viewport));
another_viewport.MaxDepth = 1;
another_viewport.MinDepth = 0;
another_viewport.TopLeftX = (float)swapchain_DESC.BufferDesc.Width / 2.0f;
another_viewport.TopLeftY = 0;
another_viewport.Width = (float)swapchain_DESC.BufferDesc.Width / 2.0f;
another_viewport.Height = (float)swapchain_DESC.BufferDesc.Height;
//Set up Depth Buffer
D3D11_TEXTURE2D_DESC ZBufferdesc;
ZBufferdesc.Width = swapchain_DESC.BufferDesc.Width;
ZBufferdesc.Height = swapchain_DESC.BufferDesc.Height;
ZBufferdesc.MipLevels = 1;
ZBufferdesc.ArraySize = 1;
ZBufferdesc.Format = DXGI_FORMAT_D32_FLOAT;
ZBufferdesc.SampleDesc.Count = swapchain_DESC.SampleDesc.Count;
ZBufferdesc.SampleDesc.Quality = swapchain_DESC.SampleDesc.Quality;
ZBufferdesc.Usage = D3D11_USAGE_DEFAULT;
ZBufferdesc.BindFlags = D3D11_BIND_DEPTH_STENCIL;
ZBufferdesc.CPUAccessFlags = 0;
ZBufferdesc.MiscFlags = 0;
pDevice->CreateTexture2D(&ZBufferdesc, 0, &pZBuffer);
pDevice->CreateDepthStencilView(pZBuffer, NULL, &pDepthStencilView);
pDeviceContext->OMSetRenderTargets(1, &pRenderTargetView, pDepthStencilView);
//Load Star
MyVertex* star = CreateStar();
D3D11_BUFFER_DESC starBufferDesc;
ZeroMemory(&starBufferDesc, sizeof(starBufferDesc));
starBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
starBufferDesc.ByteWidth = sizeof(MyVertex) * 12;
starBufferDesc.CPUAccessFlags = NULL;
starBufferDesc.Usage = D3D11_USAGE_IMMUTABLE;
starBufferDesc.MiscFlags = 0;
starBufferDesc.StructureByteStride = 0;
D3D11_SUBRESOURCE_DATA starVerticesData;
ZeroMemory(&starVerticesData, sizeof(starVerticesData));
starVerticesData.pSysMem = star;
pDevice->CreateBuffer(&starBufferDesc, &starVerticesData, &pStar);
delete star;
//Create Star Shaders
pDevice->CreateVertexShader(Star_VS, sizeof(Star_VS), NULL, &pStar_VSShader);
pDevice->CreatePixelShader(Star_PS, sizeof(Star_PS), NULL, &pStar_PSShader);
//Create Star InputLayout
D3D11_INPUT_ELEMENT_DESC starInputLayout[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
};
pDevice->CreateInputLayout(starInputLayout, 2, Star_VS, sizeof(Star_VS), &pStar_inputLayout);
#pragma region starIndex
unsigned int starIndex[60];
for (size_t i = 0; i < 30; i++)
{
if (i % 3 == 0)
{
starIndex[i] = 0;
}
}
for (size_t i = 29; i < 60; i++)
{
if (i % 3 == 0)
{
starIndex[i] = 11;
}
}
starIndex[1] = 1;
starIndex[2] = 2;
starIndex[4] = 2;
starIndex[5] = 3;
starIndex[7] = 3;
starIndex[8] = 4;
starIndex[10] = 4;
starIndex[11] = 5;
starIndex[13] = 5;
starIndex[14] = 6;
starIndex[16] = 6;
starIndex[17] = 7;
starIndex[19] = 7;
starIndex[20] = 8;
starIndex[22] = 8;
starIndex[23] = 9;
starIndex[25] = 9;
starIndex[26] = 10;
starIndex[28] = 10;
starIndex[29] = 1;
starIndex[31] = 1;
starIndex[32] = 10;
starIndex[34] = 10;
starIndex[35] = 9;
starIndex[37] = 9;
starIndex[38] = 8;
starIndex[40] = 8;
starIndex[41] = 7;
starIndex[43] = 7;
starIndex[44] = 6;
starIndex[46] = 6;
starIndex[47] = 5;
starIndex[49] = 5;
starIndex[50] = 4;
starIndex[52] = 4;
starIndex[53] = 3;
starIndex[55] = 3;
starIndex[56] = 2;
starIndex[58] = 2;
starIndex[59] = 1;
#pragma endregion
//Create Star Index Buffer
D3D11_BUFFER_DESC starIndexBufferDesc;
ZeroMemory(&starIndexBufferDesc, sizeof(starIndexBufferDesc));
starIndexBufferDesc.BindFlags = D3D11_BIND_INDEX_BUFFER;
starIndexBufferDesc.ByteWidth = sizeof(unsigned int) * 60;
starIndexBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
starIndexBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
starIndexBufferDesc.MiscFlags = 0;
starIndexBufferDesc.StructureByteStride = 0;
D3D11_SUBRESOURCE_DATA starIndexBufferData;
ZeroMemory(&starIndexBufferData, sizeof(starIndexBufferData));
starIndexBufferData.pSysMem = starIndex;
pDevice->CreateBuffer(&starIndexBufferDesc, &starIndexBufferData, &pStar_indexBuffer);
//Heli
//Create Heli Shaders
pDevice->CreateVertexShader(Cube_VS, sizeof(Cube_VS), NULL, &pHeli_VSShader);
pDevice->CreatePixelShader(Cube_PS, sizeof(Cube_PS), NULL, &pHeli_PSShader);
pDevice->CreateVertexShader(SkyBox_VS, sizeof(SkyBox_VS), NULL, &pskybox_VSShader);
pDevice->CreatePixelShader(SkyBox_PS, sizeof(SkyBox_PS), NULL, &pskybox_PSShader);
thread load = thread(&DEMO::Load, this);
load.join();
//Load Quad
quad_worldMatrix = XMMatrixIdentity();
D3D11_BUFFER_DESC quadBufferDesc;
ZeroMemory(&quadBufferDesc, sizeof(quadBufferDesc));
quadBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
quadBufferDesc.ByteWidth = sizeof(XMFLOAT4);
quadBufferDesc.CPUAccessFlags = NULL;
quadBufferDesc.Usage = D3D11_USAGE_IMMUTABLE;
quadBufferDesc.MiscFlags = 0;
quadBufferDesc.StructureByteStride = 0;
D3D11_SUBRESOURCE_DATA quadData;
ZeroMemory(&quadData, sizeof(quadData));
quadData.pSysMem = &quad_pos;
pDevice->CreateBuffer(&quadBufferDesc, &quadData, &pQuadBuffer);
pDevice->CreateVertexShader(Quad_VS, sizeof(Quad_VS), NULL, &pQuad_VSShader);
pDevice->CreateGeometryShader(Quad_GS, sizeof(Quad_GS), NULL, &pQuad_GSShader);
pDevice->CreatePixelShader(Quad_PS, sizeof(Quad_PS), NULL, &pQuad_PSShader);
D3D11_INPUT_ELEMENT_DESC quadInputLayout[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
};
pDevice->CreateInputLayout(quadInputLayout, 1, Quad_VS, sizeof(Quad_VS), &pQuadInputLayout);
//Load Cube
D3D11_BUFFER_DESC cubeBufferDesc;
ZeroMemory(&cubeBufferDesc, sizeof(cubeBufferDesc));
cubeBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
cubeBufferDesc.ByteWidth = sizeof(_OBJ_VERT_) * 776;
cubeBufferDesc.CPUAccessFlags = NULL;
cubeBufferDesc.Usage = D3D11_USAGE_IMMUTABLE;
cubeBufferDesc.MiscFlags = 0;
cubeBufferDesc.StructureByteStride = 0;
D3D11_SUBRESOURCE_DATA cubeVerticesData;
ZeroMemory(&cubeVerticesData, sizeof(cubeVerticesData));
cubeVerticesData.pSysMem = Cube_data;
pDevice->CreateBuffer(&cubeBufferDesc, &cubeVerticesData, &pCube);
//Create Cube Shaders
pDevice->CreateVertexShader(Projection_VS, sizeof(Projection_VS), NULL, &pProjection_VSShader);
pDevice->CreatePixelShader(Trivial_PS, sizeof(Trivial_PS), NULL, &pCube_PSShader);
//Create Cube InputLayout
D3D11_INPUT_ELEMENT_DESC cubeInputLayout[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "WORLD", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 1, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_INSTANCE_DATA, 1 },
{ "WORLD", 1, DXGI_FORMAT_R32G32B32A32_FLOAT, 1, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_INSTANCE_DATA, 1 },
{ "WORLD", 2, DXGI_FORMAT_R32G32B32A32_FLOAT, 1, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_INSTANCE_DATA, 1 },
{ "WORLD", 3, DXGI_FORMAT_R32G32B32A32_FLOAT, 1, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_INSTANCE_DATA, 1 },
};
pDevice->CreateInputLayout(cubeInputLayout, 7, Projection_VS, sizeof(Projection_VS), &pCube_inputLayout);
//Create Cube Index Buffer
D3D11_BUFFER_DESC cubeIndexBufferDesc;
ZeroMemory(&cubeIndexBufferDesc, sizeof(cubeIndexBufferDesc));
cubeIndexBufferDesc.BindFlags = D3D11_BIND_INDEX_BUFFER;
cubeIndexBufferDesc.ByteWidth = sizeof(unsigned int) * 1692;
cubeIndexBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
cubeIndexBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
cubeIndexBufferDesc.MiscFlags = 0;
cubeIndexBufferDesc.StructureByteStride = 0;
D3D11_SUBRESOURCE_DATA cubeIndexBufferData;
ZeroMemory(&cubeIndexBufferData, sizeof(cubeIndexBufferData));
cubeIndexBufferData.pSysMem = Cube_indicies;
pDevice->CreateBuffer(&cubeIndexBufferDesc, &cubeIndexBufferData, &pCube_indexBuffer);
//Instancing Cube
XMFLOAT4X4 temp;
/*for (size_t i = 0; i < 3; i++)
{
XMStoreFloat4x4(&temp, XMMatrixTranslation( 1.5f*cosf(i), 1.0f, 1.5f*sinf(i)));
cubeInstancedData.push_back(temp);
}*/
XMStoreFloat4x4(&temp, XMMatrixTranslation(2.0f, 1.0f, 2.0f));
cubeInstancedData.push_back(temp);
XMStoreFloat4x4(&temp, XMMatrixTranslation(0.0f, 1.0f, 0.0f));
cubeInstancedData.push_back(temp);
XMStoreFloat4x4(&temp, XMMatrixTranslation(-2.0f, 1.0f, -2.0f));
cubeInstancedData.push_back(temp);
D3D11_BUFFER_DESC cubeInstanceBufferDESC;
cubeInstanceBufferDESC.Usage = D3D11_USAGE_DYNAMIC;
cubeInstanceBufferDESC.ByteWidth = sizeof(XMFLOAT4X4) * (unsigned int)cubeInstancedData.size();
cubeInstanceBufferDESC.BindFlags = D3D11_BIND_VERTEX_BUFFER;
cubeInstanceBufferDESC.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
cubeInstanceBufferDESC.MiscFlags = 0;
cubeInstanceBufferDESC.StructureByteStride = 0;
D3D11_SUBRESOURCE_DATA instData;
ZeroMemory(&instData, sizeof(instData));
instData.pSysMem = cubeInstancedData.data();
pDevice->CreateBuffer(&cubeInstanceBufferDESC, &instData, &pCubeInstanceBuffer);
//Create Constant buffer
D3D11_BUFFER_DESC constbufferObjectDesc;
ZeroMemory(&constbufferObjectDesc, sizeof(constbufferObjectDesc));
constbufferObjectDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
constbufferObjectDesc.ByteWidth = sizeof(XMMATRIX);
constbufferObjectDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
constbufferObjectDesc.Usage = D3D11_USAGE_DYNAMIC;
constbufferObjectDesc.MiscFlags = 0;
constbufferObjectDesc.StructureByteStride = 0;
pDevice->CreateBuffer(&constbufferObjectDesc, NULL, &pConstantObjectBuffer);
D3D11_BUFFER_DESC constbufferStarDesc;
ZeroMemory(&constbufferStarDesc, sizeof(constbufferStarDesc));
constbufferStarDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
constbufferStarDesc.ByteWidth = sizeof(XMMATRIX);
constbufferStarDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
constbufferStarDesc.Usage = D3D11_USAGE_DYNAMIC;
constbufferStarDesc.MiscFlags = 0;
constbufferStarDesc.StructureByteStride = 0;
pDevice->CreateBuffer(&constbufferStarDesc, NULL, &pConstantStarBuffer);
D3D11_BUFFER_DESC constbufferSceneDesc;
ZeroMemory(&constbufferSceneDesc, sizeof(constbufferSceneDesc));
constbufferSceneDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
constbufferSceneDesc.ByteWidth = sizeof(Scene);
constbufferSceneDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
constbufferSceneDesc.Usage = D3D11_USAGE_DYNAMIC;
constbufferSceneDesc.MiscFlags = 0;
constbufferSceneDesc.StructureByteStride = 0;
pDevice->CreateBuffer(&constbufferSceneDesc, NULL, &pConstantSceneBuffer);
D3D11_BUFFER_DESC constbufferQuadDesc;
ZeroMemory(&constbufferQuadDesc, sizeof(constbufferQuadDesc));
constbufferQuadDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
constbufferQuadDesc.ByteWidth = sizeof(Scene);
constbufferQuadDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
constbufferQuadDesc.Usage = D3D11_USAGE_DYNAMIC;
constbufferQuadDesc.MiscFlags = 0;
constbufferQuadDesc.StructureByteStride = 0;
pDevice->CreateBuffer(&constbufferQuadDesc, NULL, &pConstantQuadBuffer);
D3D11_BUFFER_DESC constbufferTimeDesc;
ZeroMemory(&constbufferTimeDesc, sizeof(constbufferTimeDesc));
constbufferTimeDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
constbufferTimeDesc.ByteWidth = sizeof(float) * 4;
constbufferTimeDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
constbufferTimeDesc.Usage = D3D11_USAGE_DYNAMIC;
constbufferTimeDesc.MiscFlags = 0;
constbufferTimeDesc.StructureByteStride = 0;
pDevice->CreateBuffer(&constbufferTimeDesc, NULL, &pConstantTimeBuffer);
//Create Cube Texture Sampler
D3D11_SAMPLER_DESC cubeTextureSamplerDESC;
ZeroMemory(&cubeTextureSamplerDESC, sizeof(cubeTextureSamplerDESC));
cubeTextureSamplerDESC.Filter = D3D11_FILTER_ANISOTROPIC;
cubeTextureSamplerDESC.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
cubeTextureSamplerDESC.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
cubeTextureSamplerDESC.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
cubeTextureSamplerDESC.ComparisonFunc = D3D11_COMPARISON_NEVER;
cubeTextureSamplerDESC.MinLOD = 0;
cubeTextureSamplerDESC.MaxLOD = D3D11_FLOAT32_MAX;
pDevice->CreateSamplerState(&cubeTextureSamplerDESC, &pCubeTextureSampler);
//Create Cube RasterState
D3D11_RASTERIZER_DESC cubeRasterDESC;
ZeroMemory(&cubeRasterDESC, sizeof(cubeRasterDESC));
cubeRasterDESC.AntialiasedLineEnable = true;
cubeRasterDESC.FillMode = D3D11_FILL_SOLID;
cubeRasterDESC.CullMode = D3D11_CULL_FRONT;
pDevice->CreateRasterizerState(&cubeRasterDESC, &pCubeRSf);
ZeroMemory(&cubeRasterDESC, sizeof(cubeRasterDESC));
cubeRasterDESC.AntialiasedLineEnable = true;
cubeRasterDESC.FillMode = D3D11_FILL_SOLID;
cubeRasterDESC.CullMode = D3D11_CULL_BACK;
pDevice->CreateRasterizerState(&cubeRasterDESC, &pCubeRSb);
//Create Blend State
D3D11_BLEND_DESC blendDESC;
ZeroMemory(&blendDESC, sizeof(blendDESC));
blendDESC.AlphaToCoverageEnable = true;
blendDESC.RenderTarget[0].BlendEnable = true;
blendDESC.RenderTarget[0].SrcBlend = D3D11_BLEND_SRC_ALPHA;
blendDESC.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_ONE;
blendDESC.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA;
blendDESC.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_ZERO;
blendDESC.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD;
blendDESC.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD;
blendDESC.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL;
pDevice->CreateBlendState(&blendDESC, &pBlendState);
GetCursorPos(&lastPos);
cube_matrix = XMMatrixTranslation(0.0f, 0.0f, 5.0f);
star_matrix = XMMatrixScaling(1.0f, 1.0f, 1.0f) * XMMatrixTranslation(0.0f, 0.5f, 5.0f);
another_camera.UpdateProjection(60.0f, (float)swapchain_DESC.BufferDesc.Width / (float)2, (float)swapchain_DESC.BufferDesc.Height, NEAR_PLANE, FAR_PLANE);
another_camera.SetPosition({ 10.0f, 1.0f, 0.0f });
another_camera.RotateY(-90.0f);
another_camera.UpdateView();
camera.UpdateProjection(60.0f, (float)swapchain_DESC.BufferDesc.Width / (float)2, (float)swapchain_DESC.BufferDesc.Height, NEAR_PLANE, FAR_PLANE);
heli.GO_worldMatrix = XMMatrixScaling(0.1f, 0.1f, 0.1f) *XMMatrixTranslation(0.0f, 5.0f, 0.0f);
ground.GO_worldMatrix = XMMatrixTranslation(0.0f, -1.0f, 0.0f);
skybox.GO_worldMatrix = XMMatrixIdentity();
parkLight.GO_worldMatrix = XMMatrixTranslation(0.0f, -1.0f, 0.0f);
//Lights
allLights.amLight.lightColor = { 0.58f, 0.58f, 0.58f,1.0f };
allLights.dLight.lightColor = { 1.0f, 1.0f, 1.0f,1.0f };
allLights.dLight.lightDirection = { 0.58f, -0.58f, 0.58f,1.0f };
allLights.pLight.lightColor = { 0.0f,1.0f,0.0f,1.0f };
allLights.pLight.lightPosition = { 5.0f,3.0f,0.0f,1.0f };
allLights.sLight.lightPosition = { camera.GetPosition().x,camera.GetPosition().y,camera.GetPosition().z,1.0f };
allLights.sLight.lightColor = { 0.0f,0.0f,1.0f,1.0f };
allLights.sLight.coneDirAndRatio = { camera.GetForward().x,camera.GetForward().y,camera.GetForward().z,0.8f };
//Light Constant Buffer
D3D11_BUFFER_DESC constbufferLightDesc;
ZeroMemory(&constbufferLightDesc, sizeof(constbufferLightDesc));
constbufferLightDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
constbufferLightDesc.ByteWidth = sizeof(allLights);
constbufferLightDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
constbufferLightDesc.Usage = D3D11_USAGE_DYNAMIC;
constbufferLightDesc.MiscFlags = 0;
constbufferLightDesc.StructureByteStride = 0;
pDevice->CreateBuffer(&constbufferLightDesc, NULL, &pLightingBuffer);
scene.percent = 0.0f;
}
