mirror of
https://github.com/PixarAnimationStudios/OpenSubdiv
synced 2024-12-12 20:10:12 +00:00
258 lines
8.8 KiB
C++
258 lines
8.8 KiB
C++
//
|
|
// Copyright 2013 Nvidia
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "Apache License")
|
|
// with the following modification; you may not use this file except in
|
|
// compliance with the Apache License and the following modification to it:
|
|
// Section 6. Trademarks. is deleted and replaced with:
|
|
//
|
|
// 6. Trademarks. This License does not grant permission to use the trade
|
|
// names, trademarks, service marks, or product names of the Licensor
|
|
// and its affiliates, except as required to comply with Section 4(c) of
|
|
// the License and to reproduce the content of the NOTICE file.
|
|
//
|
|
// You may obtain a copy of the Apache License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the Apache License with the above modification is
|
|
// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
|
// KIND, either express or implied. See the Apache License for the specific
|
|
// language governing permissions and limitations under the Apache License.
|
|
//
|
|
|
|
|
|
#include "./sky.h"
|
|
|
|
#include "../common/d3d11Utils.h"
|
|
|
|
#include <cassert>
|
|
#include <vector>
|
|
|
|
static const char *g_skyShaderSource =
|
|
#include "skyshader.gen.h"
|
|
;
|
|
|
|
#define SAFE_RELEASE(p) { if(p) { (p)->Release(); (p)=NULL; } }
|
|
|
|
// shader constants
|
|
__declspec(align(16)) struct CB_CONSTANTS {
|
|
float ModelViewMatrix[16];
|
|
};
|
|
|
|
|
|
Sky::Sky(ID3D11Device * device, ID3D11Texture2D * environmentMap) :
|
|
numIndices(0),
|
|
vertexShader(0),
|
|
pixelShader(0),
|
|
shaderConstants(0),
|
|
texture(environmentMap), // we do not own this - we do not release it !
|
|
textureSRV(0),
|
|
textureSS(0),
|
|
inputLayout(0),
|
|
rasterizerState(0),
|
|
depthStencilState(0),
|
|
sphere(0),
|
|
sphereIndices(0) {
|
|
|
|
initialize(device);
|
|
}
|
|
|
|
Sky::~Sky() {
|
|
SAFE_RELEASE(vertexShader);
|
|
SAFE_RELEASE(pixelShader);
|
|
SAFE_RELEASE(shaderConstants);
|
|
SAFE_RELEASE(inputLayout);
|
|
SAFE_RELEASE(rasterizerState);
|
|
SAFE_RELEASE(depthStencilState);
|
|
SAFE_RELEASE(textureSS);
|
|
SAFE_RELEASE(textureSRV);
|
|
SAFE_RELEASE(sphere);
|
|
SAFE_RELEASE(sphereIndices);
|
|
}
|
|
|
|
void
|
|
Sky::initialize(ID3D11Device * device) {
|
|
|
|
// compile shaders
|
|
ID3DBlob * pVSBlob = D3D11Utils::CompileShader(g_skyShaderSource, "vs_main", "vs_5_0"),
|
|
* pPSBlob = D3D11Utils::CompileShader(g_skyShaderSource, "ps_main", "ps_5_0");
|
|
assert(pVSBlob && pPSBlob);
|
|
|
|
device->CreateVertexShader(pVSBlob->GetBufferPointer(),
|
|
pVSBlob->GetBufferSize(), NULL, &vertexShader);
|
|
assert(vertexShader);
|
|
|
|
device->CreatePixelShader(pPSBlob->GetBufferPointer(),
|
|
pPSBlob->GetBufferSize(), NULL, &pixelShader);
|
|
assert(pixelShader);
|
|
|
|
// VBO layout
|
|
D3D11_INPUT_ELEMENT_DESC inputElementDesc[] = {
|
|
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
|
|
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, sizeof(float)*3, D3D11_INPUT_PER_VERTEX_DATA, 0 },
|
|
};
|
|
device->CreateInputLayout(inputElementDesc, ARRAYSIZE(inputElementDesc),
|
|
pVSBlob->GetBufferPointer(), pVSBlob->GetBufferSize(), &inputLayout);
|
|
assert(inputLayout);
|
|
|
|
// shader constants
|
|
D3D11_BUFFER_DESC cbDesc;
|
|
ZeroMemory(&cbDesc, sizeof(cbDesc));
|
|
cbDesc.Usage = D3D11_USAGE_DYNAMIC;
|
|
cbDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
|
|
cbDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
|
|
cbDesc.MiscFlags = 0;
|
|
cbDesc.ByteWidth = sizeof(CB_CONSTANTS);
|
|
device->CreateBuffer(&cbDesc, NULL, &shaderConstants);
|
|
assert(shaderConstants);
|
|
|
|
// texture SRV
|
|
assert(texture);
|
|
D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc;
|
|
ZeroMemory(&srvDesc, sizeof(srvDesc));
|
|
srvDesc.Format = DXGI_FORMAT_R32G32B32A32_FLOAT;
|
|
srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
|
|
srvDesc.Texture2D.MostDetailedMip = 0;
|
|
srvDesc.Texture2D.MipLevels = 1;
|
|
device->CreateShaderResourceView(texture, &srvDesc, &textureSRV);
|
|
assert(textureSRV);
|
|
|
|
// texture sampler
|
|
D3D11_SAMPLER_DESC samplerDesc;
|
|
ZeroMemory(&samplerDesc, sizeof(samplerDesc));
|
|
samplerDesc.Filter = D3D11_FILTER_MIN_MAG_LINEAR_MIP_POINT;
|
|
samplerDesc.AddressU = samplerDesc.AddressV = samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
|
|
samplerDesc.MaxAnisotropy = 0;
|
|
samplerDesc.ComparisonFunc = D3D11_COMPARISON_NEVER;
|
|
samplerDesc.MinLOD = 0;
|
|
samplerDesc.MaxLOD = D3D11_FLOAT32_MAX;
|
|
samplerDesc.BorderColor[0] = samplerDesc.BorderColor[1] = samplerDesc.BorderColor[2] = samplerDesc.BorderColor[3] = 0.0f;
|
|
device->CreateSamplerState(&samplerDesc, &textureSS);
|
|
|
|
// depth stencil state
|
|
D3D11_DEPTH_STENCIL_DESC depthStencilDesc;
|
|
ZeroMemory(&depthStencilDesc, sizeof(depthStencilDesc));
|
|
depthStencilDesc.DepthEnable = true;
|
|
depthStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ZERO;
|
|
depthStencilDesc.DepthFunc = D3D11_COMPARISON_LESS_EQUAL;
|
|
depthStencilDesc.StencilEnable = false;
|
|
device->CreateDepthStencilState(&depthStencilDesc, &depthStencilState);
|
|
|
|
// rasterizer state
|
|
D3D11_RASTERIZER_DESC rasDesc;
|
|
rasDesc.FillMode = D3D11_FILL_SOLID;
|
|
rasDesc.CullMode = D3D11_CULL_NONE;
|
|
rasDesc.FrontCounterClockwise = FALSE;
|
|
rasDesc.DepthBias = 0;
|
|
rasDesc.DepthBiasClamp = 0;
|
|
rasDesc.DepthClipEnable = FALSE;
|
|
rasDesc.SlopeScaledDepthBias = 0.0f;
|
|
rasDesc.ScissorEnable = FALSE;
|
|
rasDesc.MultisampleEnable = FALSE;
|
|
rasDesc.AntialiasedLineEnable = FALSE;
|
|
device->CreateRasterizerState(&rasDesc, &rasterizerState);
|
|
assert(rasterizerState);
|
|
|
|
const int U_DIV = 20,
|
|
V_DIV = 20;
|
|
|
|
std::vector<float> vbo;
|
|
std::vector<int> indices;
|
|
for (int u = 0; u <= U_DIV; ++u) {
|
|
for (int v = 0; v < V_DIV; ++v) {
|
|
float s = float(2*M_PI*float(u)/U_DIV);
|
|
float t = float(M_PI*float(v)/(V_DIV-1));
|
|
vbo.push_back(-sinf(t)*sinf(s));
|
|
vbo.push_back(cosf(t));
|
|
vbo.push_back(-sinf(t)*cosf(s));
|
|
vbo.push_back(u/float(U_DIV));
|
|
vbo.push_back(v/float(V_DIV));
|
|
|
|
if (v > 0 && u > 0) {
|
|
indices.push_back((u-1)*V_DIV+v-1);
|
|
indices.push_back(u*V_DIV+v-1);
|
|
indices.push_back((u-1)*V_DIV+v);
|
|
indices.push_back((u-1)*V_DIV+v);
|
|
indices.push_back(u*V_DIV+v-1);
|
|
indices.push_back(u*V_DIV+v);
|
|
}
|
|
}
|
|
}
|
|
|
|
D3D11_BUFFER_DESC bufferDesc;
|
|
D3D11_SUBRESOURCE_DATA subData;
|
|
|
|
// topology indices
|
|
ZeroMemory(&bufferDesc, sizeof(bufferDesc));
|
|
bufferDesc.ByteWidth = (int)indices.size() * sizeof(int);
|
|
bufferDesc.Usage = D3D11_USAGE_DEFAULT;
|
|
bufferDesc.BindFlags = D3D11_BIND_INDEX_BUFFER;
|
|
bufferDesc.CPUAccessFlags = 0;
|
|
bufferDesc.MiscFlags = 0;
|
|
bufferDesc.StructureByteStride = sizeof(int);
|
|
|
|
ZeroMemory(&subData, sizeof(subData));
|
|
subData.pSysMem = &indices[0];
|
|
subData.SysMemPitch = 0;
|
|
subData.SysMemSlicePitch = 0;
|
|
device->CreateBuffer(&bufferDesc, &subData, &sphereIndices);
|
|
assert(sphereIndices);
|
|
|
|
// VBO
|
|
ZeroMemory(&bufferDesc, sizeof(bufferDesc));
|
|
bufferDesc.ByteWidth = (int)vbo.size() * sizeof(float);
|
|
bufferDesc.Usage = D3D11_USAGE_DEFAULT;
|
|
bufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
|
|
bufferDesc.CPUAccessFlags = 0;
|
|
bufferDesc.MiscFlags = 0;
|
|
|
|
ZeroMemory(&subData, sizeof(subData));
|
|
subData.pSysMem = &vbo[0];
|
|
device->CreateBuffer(&bufferDesc, &subData, &sphere);
|
|
assert(sphere);
|
|
|
|
numIndices = (int)indices.size();
|
|
}
|
|
|
|
void
|
|
Sky::Draw(ID3D11DeviceContext * deviceContext, float const mvp[16]) {
|
|
|
|
if (vertexShader==0 || pixelShader==0 || shaderConstants==0) return;
|
|
|
|
if (texture==0 || textureSRV==0 || textureSS==0) return;
|
|
|
|
if (sphere==0 || sphereIndices==0) return;
|
|
|
|
// update shader constants
|
|
D3D11_MAPPED_SUBRESOURCE MappedResource;
|
|
deviceContext->Map(shaderConstants, 0, D3D11_MAP_WRITE_DISCARD, 0, &MappedResource);
|
|
CB_CONSTANTS* pData = (CB_CONSTANTS*)MappedResource.pData;
|
|
|
|
memcpy(pData->ModelViewMatrix, mvp, 16*sizeof(float));
|
|
|
|
deviceContext->Unmap(shaderConstants, 0);
|
|
|
|
// draw
|
|
deviceContext->RSSetState(rasterizerState);
|
|
deviceContext->OMSetDepthStencilState(depthStencilState, 1);
|
|
|
|
deviceContext->VSSetShader(vertexShader, NULL, 0);
|
|
deviceContext->VSSetConstantBuffers(0, 1, &shaderConstants);
|
|
|
|
deviceContext->PSSetShader(pixelShader, NULL, 0);
|
|
deviceContext->PSSetShaderResources(0, 1, &textureSRV);
|
|
deviceContext->PSSetSamplers(0, 1, &textureSS);
|
|
|
|
UINT hStrides = 5*sizeof(float);
|
|
UINT hOffsets = 0;
|
|
deviceContext->IASetVertexBuffers(0, 1, &sphere, &hStrides, &hOffsets);
|
|
deviceContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
|
|
deviceContext->IASetInputLayout(inputLayout);
|
|
|
|
deviceContext->IASetIndexBuffer(sphereIndices, DXGI_FORMAT_R32_UINT, 0);
|
|
|
|
deviceContext->DrawIndexed(numIndices, 0, 0);
|
|
}
|