public void CreateDeviceDependentResources(DeviceResources resources)
{
this.deviceResources = resources;
var d3dDevice = this.deviceResources.D3DDevice;
// Create the shaders
byte[] vertexShaderBytecode = File.ReadAllBytes("VertexShader.cso");
this.g_pVertexShader = d3dDevice.CreateVertexShader(vertexShaderBytecode, null);
this.g_pHullShaderInteger = d3dDevice.CreateHullShader(File.ReadAllBytes("HullShaderInteger.cso"), null);
this.g_pHullShaderFracEven = d3dDevice.CreateHullShader(File.ReadAllBytes("HullShaderFracEven.cso"), null);
this.g_pHullShaderFracOdd = d3dDevice.CreateHullShader(File.ReadAllBytes("HullShaderFracOdd.cso"), null);
this.g_pDomainShader = d3dDevice.CreateDomainShader(File.ReadAllBytes("DomainShader.cso"), null);
this.g_pPixelShader = d3dDevice.CreatePixelShader(File.ReadAllBytes("PixelShader.cso"), null);
this.g_pSolidColorPS = d3dDevice.CreatePixelShader(File.ReadAllBytes("SolidColorPS.cso"), null);
// Create our vertex input layout - this matches the BEZIER_CONTROL_POINT structure
D3D11InputElementDesc[] layoutDesc = new D3D11InputElementDesc[]
{
new D3D11InputElementDesc
{
SemanticName = "POSITION",
SemanticIndex = 0,
Format = DxgiFormat.R32G32B32Float,
InputSlot = 0,
AlignedByteOffset = 0,
InputSlotClass = D3D11InputClassification.PerVertexData,
InstanceDataStepRate = 0
}
};
this.g_pPatchLayout = this.deviceResources.D3DDevice.CreateInputLayout(layoutDesc, vertexShaderBytecode);
// Create constant buffers
this.g_pcbPerFrame = d3dDevice.CreateBuffer(new D3D11BufferDesc(ConstantBufferConstants.Size, D3D11BindOptions.ConstantBuffer));
// Create solid and wireframe rasterizer state objects
D3D11RasterizerDesc rasterDesc = D3D11RasterizerDesc.Default;
rasterDesc.CullMode = D3D11CullMode.None;
rasterDesc.IsDepthClipEnabled = true;
rasterDesc.FillMode = D3D11FillMode.Solid;
this.g_pRasterizerStateSolid = d3dDevice.CreateRasterizerState(rasterDesc);
rasterDesc.FillMode = D3D11FillMode.WireFrame;
this.g_pRasterizerStateWireframe = d3dDevice.CreateRasterizerState(rasterDesc);
D3D11BufferDesc vbdesc = D3D11BufferDesc.From(MobiusStrip.Points, D3D11BindOptions.VertexBuffer);
this.g_pControlPointVB = d3dDevice.CreateBuffer(vbdesc, MobiusStrip.Points, 0, 0);
XMFloat3 vecEye = new XMFloat3(1.0f, 1.5f, -3.5f);
XMFloat3 vecAt = new XMFloat3(0.0f, 0.0f, 0.0f);
XMFloat3 vecUp = new XMFloat3(0.0f, 1.0f, 0.0f);
this.ViewMatrix = XMMatrix.LookAtLH(vecEye, vecAt, vecUp);
this.EyePt = vecEye;
}
public void CreateDeviceDependentResources(DeviceResources resources)
{
this.deviceResources = resources;
//string fileName = Path.GetDirectoryName(this.OptFileName) + "\\" + Path.GetFileNameWithoutExtension(this.OptFileName) + "Exterior.opt";
//OptFile opt;
//if (File.Exists(fileName))
//{
// opt = OptFile.FromFile(fileName);
//}
//else
//{
// opt = OptFile.FromFile(this.OptFileName);
//}
OptFile opt = OptFile.FromFile(this.OptFileName);
this.OptSize = opt.Size * OptFile.ScaleFactor;
this.OptSpanSize = opt.SpanSize.Scale(OptFile.ScaleFactor, OptFile.ScaleFactor, OptFile.ScaleFactor);
Vector max = opt.MaxSize;
Vector min = opt.MinSize;
this.OptCenter = new Vector()
{
X = (max.X + min.X) / 2,
Y = (max.Y + min.Y) / 2,
Z = (max.Z + min.Z) / 2
}.Scale(OptFile.ScaleFactor, OptFile.ScaleFactor, OptFile.ScaleFactor);
this.CreateTextures(opt);
this.CreateMeshes(opt);
byte[] vertexShaderBytecode = File.ReadAllBytes("VertexShader.cso");
this.vertexShader = this.deviceResources.D3DDevice.CreateVertexShader(vertexShaderBytecode, null);
D3D11InputElementDesc[] basicVertexLayoutDesc = new D3D11InputElementDesc[]
{
new D3D11InputElementDesc
{
SemanticName = "POSITION",
SemanticIndex = 0,
Format = DxgiFormat.R32G32B32Float,
InputSlot = 0,
AlignedByteOffset = 0,
InputSlotClass = D3D11InputClassification.PerVertexData,
InstanceDataStepRate = 0
},
new D3D11InputElementDesc
{
SemanticName = "NORMAL",
SemanticIndex = 0,
Format = DxgiFormat.R32G32B32Float,
InputSlot = 0,
AlignedByteOffset = 12,
InputSlotClass = D3D11InputClassification.PerVertexData,
InstanceDataStepRate = 0
},
new D3D11InputElementDesc
{
SemanticName = "TEXCOORD",
SemanticIndex = 0,
Format = DxgiFormat.R32G32Float,
InputSlot = 0,
AlignedByteOffset = 24,
InputSlotClass = D3D11InputClassification.PerVertexData,
InstanceDataStepRate = 0
}
};
this.inputLayout = this.deviceResources.D3DDevice.CreateInputLayout(basicVertexLayoutDesc, vertexShaderBytecode);
byte[] pixelShaderBytecode = File.ReadAllBytes("PixelShader.cso");
this.pixelShader = this.deviceResources.D3DDevice.CreatePixelShader(pixelShaderBytecode, null);
var constantBufferDesc = new D3D11BufferDesc(ConstantBufferData.Size, D3D11BindOptions.ConstantBuffer);
this.constantBuffer = this.deviceResources.D3DDevice.CreateBuffer(constantBufferDesc);
D3D11SamplerDesc samplerDesc = new D3D11SamplerDesc(
D3D11Filter.Anisotropic,
D3D11TextureAddressMode.Wrap,
D3D11TextureAddressMode.Wrap,
D3D11TextureAddressMode.Wrap,
0.0f,
this.deviceResources.D3DFeatureLevel > D3D11FeatureLevel.FeatureLevel91 ? D3D11Constants.DefaultMaxAnisotropy : D3D11Constants.FeatureLevel91DefaultMaxAnisotropy,
D3D11ComparisonFunction.Never,
new float[] { 0.0f, 0.0f, 0.0f, 0.0f },
0.0f,
float.MaxValue);
this.sampler = this.deviceResources.D3DDevice.CreateSamplerState(samplerDesc);
D3D11RasterizerDesc rasterizerDesc = D3D11RasterizerDesc.Default;
rasterizerDesc.CullMode = D3D11CullMode.None;
this.rasterizerState = this.deviceResources.D3DDevice.CreateRasterizerState(rasterizerDesc);
this.depthStencilState0 = this.deviceResources.D3DDevice.CreateDepthStencilState(D3D11DepthStencilDesc.Default);
D3D11DepthStencilDesc depthStencilDesc = D3D11DepthStencilDesc.Default;
depthStencilDesc.DepthWriteMask = D3D11DepthWriteMask.Zero;
this.depthStencilState1 = this.deviceResources.D3DDevice.CreateDepthStencilState(depthStencilDesc);
this.blendState0 = this.deviceResources.D3DDevice.CreateBlendState(D3D11BlendDesc.Default);
D3D11BlendDesc blendDesc = D3D11BlendDesc.Default;
D3D11RenderTargetBlendDesc[] blendDescRenderTargets = blendDesc.GetRenderTargets();
blendDescRenderTargets[0].IsBlendEnabled = true;
blendDescRenderTargets[0].SourceBlend = D3D11BlendValue.SourceAlpha;
blendDescRenderTargets[0].DestinationBlend = D3D11BlendValue.InverseSourceAlpha;
blendDescRenderTargets[0].BlendOperation = D3D11BlendOperation.Add;
blendDescRenderTargets[0].SourceBlendAlpha = D3D11BlendValue.One;
blendDescRenderTargets[0].DestinationBlendAlpha = D3D11BlendValue.InverseSourceAlpha;
blendDescRenderTargets[0].BlendOperationAlpha = D3D11BlendOperation.Add;
blendDescRenderTargets[0].RenderTargetWriteMask = D3D11ColorWriteEnables.All;
blendDesc.SetRenderTargets(blendDescRenderTargets);
this.blendState1 = this.deviceResources.D3DDevice.CreateBlendState(blendDesc);
}
public void CreateDeviceDependentResources(DeviceResources resources)
{
this.deviceResources = resources;
var d3dDevice = this.deviceResources.D3DDevice;
this.tessellator.CreateDeviceDependentResources(this.deviceResources);
XMFloat4[] initData;
// Parse the .obj file. Both triangle faces and quad faces are supported.
// Only v and f tags are processed, other tags like vn, vt etc are ignored.
{
var initFile = ObjFile.FromFile("BaseMesh.obj");
var data = new List <XMFloat4>();
var v = new List <XMFloat4>();
for (int i = 0; i < initFile.Vertices.Count; i++)
{
ObjVector4 objPosition = initFile.Vertices[i].Position;
XMFloat4 pos = new XMFloat4(
objPosition.X,
objPosition.Y,
objPosition.Z,
1.0f);
v.Add(pos);
}
foreach (ObjFace face in initFile.Faces)
{
if (face.Vertices.Count < 3)
{
continue;
}
data.Add(v[face.Vertices[0].Vertex - 1]);
data.Add(v[face.Vertices[1].Vertex - 1]);
data.Add(v[face.Vertices[2].Vertex - 1]);
if (face.Vertices.Count >= 4)
{
data.Add(v[face.Vertices[2].Vertex - 1]);
data.Add(v[face.Vertices[3].Vertex - 1]);
data.Add(v[face.Vertices[0].Vertex - 1]);
}
}
initData = data.ToArray();
}
this.g_pBaseVB = d3dDevice.CreateBuffer(
D3D11BufferDesc.From(initData, D3D11BindOptions.ShaderResource | D3D11BindOptions.VertexBuffer),
initData,
0,
0);
this.tessellator.SetBaseMesh((uint)initData.Length, this.g_pBaseVB);
this.g_pVS = d3dDevice.CreateVertexShader(File.ReadAllBytes("RenderVertexShader.cso"), null);
{
byte[] shaderBytecode = File.ReadAllBytes("RenderBaseVertexShader.cso");
this.g_pBaseVS = d3dDevice.CreateVertexShader(shaderBytecode, null);
D3D11InputElementDesc[] layoutDesc = new[]
{
new D3D11InputElementDesc(
"POSITION",
0,
DxgiFormat.R32G32B32A32Float,
0,
0,
D3D11InputClassification.PerVertexData,
0)
};
this.g_pBaseVBLayout = d3dDevice.CreateInputLayout(layoutDesc, shaderBytecode);
}
this.g_pPS = d3dDevice.CreatePixelShader(File.ReadAllBytes("RenderPixelShader.cso"), null);
// Setup constant buffer
this.g_pVSCB = d3dDevice.CreateBuffer(new D3D11BufferDesc
{
BindOptions = D3D11BindOptions.ConstantBuffer,
ByteWidth = 4 * 16
});
// Rasterizer state
this.g_pRasWireFrame = d3dDevice.CreateRasterizerState(new D3D11RasterizerDesc
{
CullMode = D3D11CullMode.None,
FillMode = D3D11FillMode.WireFrame
});
}