public void CreatePipelineState()
{
string images = Constants.ImagesFile;
string fragment = Constants.ShadersFile + @"SpecularLighting\Fragment.hlsl";
string vertex = Constants.ShadersFile + @"SpecularLighting\Vertex.hlsl";
Image text1 = ImageFile.Load2DFromFile(Device, images + "UV_Grid_Sm.jpg");
Sampler sampler = new Sampler(Device);
GraphicsPipelineDescription Pipelinedescription0 = new();
Pipelinedescription0.SetFramebuffer(Framebuffer);
Pipelinedescription0.SetShader(new ShaderBytecode(fragment, ShaderStage.Fragment));
Pipelinedescription0.SetShader(new ShaderBytecode(vertex, ShaderStage.Vertex));
Pipelinedescription0.SetVertexBinding(VertexInputRate.Vertex, VertexPositionNormalTexture.Size);
Pipelinedescription0.SetVertexAttribute(VertexType.Position);
Pipelinedescription0.SetVertexAttribute(VertexType.Normal);
Pipelinedescription0.SetVertexAttribute(VertexType.TextureCoordinate);
//Pipelinedescription0.SetFillMode(VkPolygonMode.Line);
PipelineState_0 = new(Pipelinedescription0);
DescriptorData descriptorData_0 = new();
descriptorData_0.SetUniformBuffer(0, ConstBuffer);
descriptorData_0.SetImage(1, text1);
descriptorData_0.SetSampler(2, sampler);
descriptorData_0.SetUniformBuffer(3, ConstBuffer2);
DescriptorSet_0 = new(PipelineState_0, descriptorData_0);
}
private void CreateTextureFace()
{
textureFace = new TextureFace(Width, Height)
{
BackGround = new Vector4(1, 0, 0, 1)
};
Resource.heap1.AddResource(textureFace);
Resource.TextureFaceTable = new ResourceTable(Resource.heap1, 3);
Grid gridTexture = new Grid(20, 20, Resource.TextureTable);
Micos.Add(gridTexture);
Micos.Update();
GraphicsPipeline.Open(graphicsPipelineState, textureFace);
Micos.Exports();
GraphicsPipeline.Close();
GraphicsPipeline.WaitFlush();
Micos.Remove(gridTexture);
Micos.Update();
}
public MeshSpatialObject(GraphicsState graphics, SpatialState spatial, AssetFactoryState assets, Mesh mesh,
bool culling)
{
Graphics = graphics;
Spatial = spatial;
Mesh = mesh;
// TextureLayer = textureLayer;
VertexBuffer = new ArrayBuffer <Vertex>(graphics, BufferUsage.StructuredBufferReadOnly,
mesh.Vertices, ShaderStages.Compute);
WorldVertexBuffer = new ArrayBuffer <Vertex>(graphics, BufferUsage.StructuredBufferReadWrite,
mesh.Vertices.Length, ShaderStages.Compute | ShaderStages.Vertex);
ScreenCoordsBuffer = new ArrayBuffer <Vector3D>(graphics, BufferUsage.StructuredBufferReadWrite,
mesh.Vertices.Length, ShaderStages.Compute | ShaderStages.Vertex);
ParameterBuffer = new StructBuffer <Parameters>(graphics, BufferUsage.UniformBuffer,
ShaderStages.Compute);
// Texture = texture;
FaceBuffer = new ResourcelessArrayBuffer <Face>(graphics, BufferUsage.VertexBuffer, mesh.Faces);
TransformPipeline = new ComputePipeline(graphics,
assets.Get <ShaderSet>("Shaders.MeshSpatialObject.Transform"),
VertexBuffer, WorldVertexBuffer, ScreenCoordsBuffer, ParameterBuffer);
ColorPipeline = new GraphicsPipeline(graphics, Blend.Override, DepthTest.On, culling,
assets.Get <ShaderSet>("Shaders.MeshSpatialObject.Color"), graphics.IntermediateOutputDescription,
WorldVertexBuffer, ScreenCoordsBuffer);
Commands = new Commands(graphics);
}
public override void Render(GraphicsPipeline gPipeline)
{
gPipeline.BeginScene();
gDevice.RenderState.ZBufferEnable = false;
gDevice.VertexFormat = CustomVertex.PositionColored.Format;
gDevice.SetStreamSource(0, vBuffer, 0);
gDevice.DrawPrimitives(PrimitiveType.LineList, 0, 3);
if (Selected)
{
// just draw yellow line over selected axis
gDevice.SetStreamSource(0, selectionVBuffer, 0);
gDevice.DrawPrimitives(PrimitiveType.LineList, InternalSelectedValue - 1, 1);
// TODO: draw triangular tube on that axis
/*gDevice.Indices = selectionIBuffer;
* gDevice.SetStreamSource(0, selectionVBuffers[InternalSelectedValue - 1], 0);
* gDevice.DrawIndexedPrimitives(PrimitiveType.TriangleList, 0, 0, 6, 0, 6);*/
}
gDevice.RenderState.ZBufferEnable = true;
gPipeline.EndScene();
}
protected virtual void InitializeEnvironment(CommonDeviceInterface cdi, HashTableSettings localSettings)
{
// Get device settings
if (outCaps == null)
{
outCaps = GraphicsDeviceCaps.GetDefaultAdapterCaps(outProfile.RecommendedVariations[0]);
}
// find first recommended settings with full match
bool fullMatch = false;
outSettings = GraphicsDeviceSettings.CreateFromRequirements(outProfile.RecommendedVariation,
outCaps, outProfile.MinReqs,
out fullMatch);
// Set up the presentation parameters
presentParams.Windowed = outProfile.RecommendedVariations[0].Windowed;
presentParams.SwapEffect = SwapEffect.Discard;
presentParams.AutoDepthStencilFormat = outSettings.DepthFormat;
presentParams.EnableAutoDepthStencil = (outSettings.DepthFormat != DepthFormat.Unknown);
presentParams.MultiSample = outSettings.MultiSample;
CreateDevice();
devIf = new DeviceInterface(gDevice, cdi, localSettings);
gPipeline = new GraphicsPipeline(gDevice);
}
/// <summary>Binds a pipeline to the context.</summary>
/// <param name="pipeline">The pipeline to bind.</param>
/// <exception cref="ArgumentNullException"><paramref name="pipeline" /> is <c>null</c>.</exception>
public void BindPipeline(GraphicsPipeline pipeline)
{
ThrowIfNull(pipeline);
var d3d12GraphicsCommandList = D3D12GraphicsCommandList;
d3d12GraphicsCommandList->SetPipelineState(pipeline.D3D12PipelineState);
d3d12GraphicsCommandList->SetGraphicsRootSignature(pipeline.Signature.D3D12RootSignature);
}
public override void Render(GraphicsPipeline gPipeline)
{
gDevice.RenderState.Lighting = false;
gPipeline.BeginScene();
// just draw bounding box for now
//NuGenRenderCore.Rendering.BoundingBox.DrawWireframe(gDevice, bBox, Color.DarkRed.ToArgb());
// draw geometry
if (geom != null)
{
geom.UseDiffuseTexture = ((GeometryVisLayer)devIf.LocalSettings["GeometryVisLayer.Diffuse"]).Enabled;
ShaderInterface shader = null;
/*if ((bool)devIf.LocalSettings["GeometryVis.HeightShadingEnabled"])
* {
* shader = hClrShader;
* shader.Effect.SetValue("MinHeight", -0.5f);
* shader.Effect.SetValue("HeightScale", 1f);
* shader.Effect.SetValue("HeightClr", ColorValue.FromColor((Color)devIf.LocalSettings["GeometryVis.HeightShadingClr"]));
* }
* else if (((GeometryVisLayer)devIf.LocalSettings["GeometryVisLayer.Overlay"]).Enabled)
* {
* shader = defaultShader;
* shader.Effect.SetValue("OverlayTexture", overlayTexRz.Texture);
* }*/
shader = sm3Shader;
if (shader != null)
{
gPipeline.ShaderIf = shader;
gPipeline.ShaderEnabled = true;
/*shader.Effect.Begin(FX.None);
* shader.Effect.BeginPass(0);*/
geom.Render(gPipeline);
/*shader.Effect.EndPass();
* shader.Effect.End();*/
gPipeline.ShaderEnabled = false;
}
else
{
geom.Render(gPipeline);
}
//gDevice.SetTexture(1, null);
}
/*gDevice.VertexFormat = CustomVertex.PositionColored.Format;
* gDevice.DrawUserPrimitives(PrimitiveType.TriangleStrip, 2, clipBottomSideQuad);*/
gPipeline.EndScene();
}
public virtual void Render(GraphicsPipeline gPipeline)
{
if (selected)
{
gPipeline.BeginSceneKeepState();
BoundingBox.DrawWireframe(gDevice, bBox, Color.Yellow.ToArgb());
gPipeline.EndSceneKeepState();
}
}
public override void Render(GraphicsPipeline gPipeline)
{
gDevice.RenderState.ZBufferEnable = false;
gDevice.VertexFormat = CustomVertex.PositionColored.Format;
gDevice.SetStreamSource(0, vBuffer, 0);
for (int i = 0; i < 3; i++)
{
gDevice.DrawPrimitives(PrimitiveType.LineStrip, (detailCount + 1) * i, detailCount);
}
gDevice.RenderState.ZBufferEnable = true;
}
public override void RenderSceneFrame(GraphicsPipeline gPipeline, int width, int height)
{
// render scene graph
// TODO: sceneGraph.StreamAllInFrustum
gPipeline.PushAll();
foreach (KeyValuePair <uint, T> item in sceneGraphEntities)
{
SceneEntity entity = item.Value;
entity.PreRender(gPipeline);
entity.Render(gPipeline);
entity.PostRender(gPipeline);
}
gPipeline.PopAll();
// render post-scene world entities
gPipeline.PushAll();
foreach (IWorldEntity entity in postSceneWorldEntities)
{
entity.Render(gPipeline);
}
gPipeline.PopAll();
Matrix wvMat = gPipeline.WorldMatrix * gPipeline.ViewMatrix;
foreach (ViewSpaceEntity entity in postSceneViewEntities)
{
entity.UpdateView(gPipeline.WorldMatrix, gPipeline.ViewMatrix);
// z-compare
float z = 1000 - Vector3.Transform(entity.BoundingBox.Centre, wvMat).Z;
try
{
zCompareViewEntities.Add(z, entity);
}
catch { zCompareViewEntities.Add(z - 0.001f, entity); } // TODO: more robust feature?
}
foreach (KeyValuePair <float, ViewSpaceEntity> entity in zCompareViewEntities)
{
entity.Value.Render(gPipeline);
}
zCompareViewEntities.Clear();
// render post-scene screen entities
foreach (IScreenSpaceEntity entity in screenEntities)
{
// TODO: Detect matrix changes
entity.Update(gPipeline.WorldMatrix, gPipeline.ViewMatrix, gPipeline.ProjectionMatrix, gDevice.Viewport);
entity.Render();
}
}
public override void OnUpdate(object sender)
{
GraphicsPipeline.Open(graphicsPipelineState, presenter);
Micos.Exports();
Title = Program.AppName + " FPS: " + fpsCounter.Fps.ToString();
GraphicsPipeline.Close();
Micos.Update();
GraphicsPipeline.WaitFlush();
}
public void CreatePipelineState()
{
string fragment = Constants.ShadersFile + @"ComputeTexture\Fragment.hlsl";
string vertex = Constants.ShadersFile + @"ComputeTexture\Vertex.hlsl";
string compute = Constants.ShadersFile + @"ComputeTexture\Compute.hlsl";
Image image = new(Device, new()
{
ImageType = VkImageType.Image2D,
Usage = ResourceUsage.GPU_Only,
Flags = ImageFlags.ReadWriteImage | ImageFlags.ShaderResource,
Format = VkFormat.R8G8B8A8SNorm,
Width = Framebuffer.SwapChain.Width,
Height = Framebuffer.SwapChain.Height,
Depth = 1,
MipLevels = 1,
ArraySize = 1,
});
Sampler sampler = new Sampler(Device);
ComputePipelineDescription ComputePipelineDescription = new();
ComputePipelineDescription.Shader = new ShaderBytecode(compute, ShaderStage.Compute);
PipelineState_1 = new(Device, ComputePipelineDescription);
DescriptorData descriptorData_1 = new();
descriptorData_1.SetReadWriteImage(0, image);
DescriptorSet_1 = new(PipelineState_1, descriptorData_1);
GraphicsPipelineDescription Pipelinedescription0 = new();
Pipelinedescription0.SetFramebuffer(Framebuffer);
Pipelinedescription0.SetShader(new ShaderBytecode(fragment, ShaderStage.Fragment));
Pipelinedescription0.SetShader(new ShaderBytecode(vertex, ShaderStage.Vertex));
PipelineState_0 = new(Pipelinedescription0);
DescriptorData descriptorData_0 = new();
descriptorData_0.SetImage(1, image);
descriptorData_0.SetSampler(2, sampler);
DescriptorSet_0 = new(PipelineState_0, descriptorData_0);
}
protected override void OnExport(object Unknown = null)
{
passObject.world = Transform;
passObjectView.Update(ref passObject);
GraphicsPipeline.InputSlot[0] = CameraBuffer.View;
GraphicsPipeline.InputSlot[1] = passObjectView;
GraphicsPipeline.InputAssemblerStage.VertexBuffer = vertexBuffer;
GraphicsPipeline.InputAssemblerStage.IndexBuffer = indexBuffer;
GraphicsPipeline.InputAssemblerStage.PrimitiveType = PrimitiveType.TriangleList;
GraphicsPipeline.PutObjectIndexed(indexBuffer.Count);
base.OnExport(Unknown);
}
protected override void OnExport(object Unknown = null)
{
cubeBuffer.world = Transform;
cubeBufferUploader.Update(ref cubeBuffer);
GraphicsPipeline.InputSlot[0] = Resource.CameraBuffer;
GraphicsPipeline.InputSlot[1] = cubeBufferUploader;
GraphicsPipeline.InputAssemblerStage.VertexBuffer = vertexBuffer;
GraphicsPipeline.InputAssemblerStage.IndexBuffer = indexBuffer;
GraphicsPipeline.InputAssemblerStage.PrimitiveType = PrimitiveType.TriangleList;
GraphicsPipeline.Reset(graphicsPipelineState);
GraphicsPipeline.PutObjectIndexed(indexBuffer.Count);
}
protected override void OnExport(object Unknown = null)
{
gridBuffer = GridBuffer.FromTransform(Transform);
cameraBuffer = CameraBuffer.FromCamera(Micos.Camera);
Resource.GridBuffer.Update(ref gridBuffer);
Resource.CameraBuffer.Update(ref cameraBuffer);
GraphicsPipeline.SetHeaps(new ResourceHeap[] { Resource.heap1 }); //If you do not set this, the draw will be falled.
GraphicsPipeline.InputSlot[0] = Resource.ConstantBufferTable;
GraphicsPipeline.InputSlot[1] = textureTable;
GraphicsPipeline.InputAssemblerStage.VertexBuffer = vertexBuffer;
GraphicsPipeline.InputAssemblerStage.IndexBuffer = indexBuffer;
GraphicsPipeline.InputAssemblerStage.PrimitiveType = PrimitiveType.TriangleList;
GraphicsPipeline.PutObjectIndexed(indexBuffer.Count);
}
public void CreatePipelineState()
{
string shaders = Constants.ShadersFile;
GraphicsPipelineDescription pipelineStateDescription = new();
pipelineStateDescription.SetFramebuffer(Framebuffer);
pipelineStateDescription.SetShader(new ShaderBytecode(shaders + "LoadGLTF/Fragment.hlsl", ShaderStage.Fragment));
pipelineStateDescription.SetShader(new ShaderBytecode(shaders + "LoadGLTF/Vertex.hlsl", ShaderStage.Vertex));
pipelineStateDescription.SetVertexBinding(VertexInputRate.Vertex, VertexPositionNormal.Size);
pipelineStateDescription.SetVertexAttribute(VertexType.Position);
pipelineStateDescription.SetVertexAttribute(VertexType.Color);
PipelineState = new(pipelineStateDescription);
DescriptorData descriptorData = new();
descriptorData.SetUniformBuffer(0, ConstBuffer);
DescriptorSet = new DescriptorSet(PipelineState, descriptorData);
}
public virtual void PreRender(GraphicsPipeline gPipeline)
{
gPipeline.Push();
gPipeline.WorldMatrix = toWorldMatrixTotal * gPipeline.WorldMatrix;
}
public virtual void PostRender(GraphicsPipeline gPipeline)
{
gPipeline.Pop();
}
/// <summary>Initializes a new instance of the <see cref="GraphicsPrimitive" /> class.</summary>
/// <param name="pipeline">The pipeline for which the graphics primitive was created.</param>
/// <param name="vertexBufferView">The vertex buffer view for the primitive.</param>
/// <param name="indexBufferView">The index buffer view for the primitive or <c>null</c> if none exists.</param>
/// <param name="resourceViews">The resource views for the primitive or <c>empty</c> if none exists.</param>
public GraphicsPrimitive(GraphicsPipeline pipeline, GraphicsBufferView vertexBufferView, GraphicsBufferView?indexBufferView = null, ReadOnlySpan <GraphicsResourceView> resourceViews = default) : base(pipeline)
{
_indexBufferView = indexBufferView;
_pipelineDescriptorSet = !resourceViews.IsEmpty ? pipeline.CreateDescriptorSet(resourceViews) : null;
_vertexBufferView = vertexBufferView;
}
public IGraphicsService SetPipeline(GraphicsPipeline P)
{
Pipeline = P;
return(this);
}
public override void Render(GraphicsPipeline gPipeline)
{
gDevice.VertexFormat = CustomVertex.PositionColored.Format;
gDevice.DrawUserPrimitives(PrimitiveType.LineList, 1, ray);
}
public void CreatePipelineState()
{
string images = Constants.ImagesFile;
string fragment = Constants.ShadersFile + @"DiffuseLighting\Fragment.hlsl";
string vertex = Constants.ShadersFile + @"DiffuseLighting\Vertex.hlsl";
Image text1 = ImageFile.Load2DFromFile(Device, images + "UVCheckerMap08-512.png");
Image text2 = ImageFile.Load2DFromFile(Device, images + "UVCheckerMap02-512.png");
Image text3 = ImageFile.Load2DFromFile(Device, images + "UVCheckerMap09-512.png");
Sampler sampler = new Sampler(Device);
GraphicsPipelineDescription Pipelinedescription0 = new();
Pipelinedescription0.SetFramebuffer(Framebuffer);
Pipelinedescription0.SetShader(new ShaderBytecode(fragment, ShaderStage.Fragment));
Pipelinedescription0.SetShader(new ShaderBytecode(vertex, ShaderStage.Vertex));
Pipelinedescription0.SetVertexBinding(VertexInputRate.Vertex, VertexPositionNormalTexture.Size);
Pipelinedescription0.SetVertexAttribute(VertexType.Position);
Pipelinedescription0.SetVertexAttribute(VertexType.Normal);
Pipelinedescription0.SetVertexAttribute(VertexType.TextureCoordinate);
PipelineState_0 = new(Pipelinedescription0);
DescriptorData descriptorData_0 = new();
descriptorData_0.SetUniformBuffer(0, ConstBuffer);
descriptorData_0.SetImage(1, text1);
descriptorData_0.SetSampler(2, sampler);
descriptorData_0.SetUniformBuffer(3, ConstBuffer4);
DescriptorSet_0 = new(PipelineState_0, descriptorData_0);
GraphicsPipelineDescription Pipelinedescription1 = new();
Pipelinedescription1.SetFramebuffer(Framebuffer);
Pipelinedescription1.SetShader(new ShaderBytecode(fragment, ShaderStage.Fragment));
Pipelinedescription1.SetShader(new ShaderBytecode(vertex, ShaderStage.Vertex));
Pipelinedescription1.SetVertexBinding(VertexInputRate.Vertex, VertexPositionNormalTexture.Size);
Pipelinedescription1.SetVertexAttribute(VertexType.Position);
Pipelinedescription1.SetVertexAttribute(VertexType.Normal);
Pipelinedescription1.SetVertexAttribute(VertexType.TextureCoordinate);
PipelineState_1 = new(Pipelinedescription1);
DescriptorData descriptorData_1 = new();
descriptorData_1.SetUniformBuffer(0, ConstBuffer2);
descriptorData_1.SetImage(1, text2);
descriptorData_1.SetSampler(2, sampler);
descriptorData_1.SetUniformBuffer(3, ConstBuffer4);
DescriptorSet_1 = new(PipelineState_1, descriptorData_1);
GraphicsPipelineDescription Pipelinedescription2 = new();
Pipelinedescription2.SetFramebuffer(Framebuffer);
Pipelinedescription2.SetShader(new ShaderBytecode(fragment, ShaderStage.Fragment));
Pipelinedescription2.SetShader(new ShaderBytecode(vertex, ShaderStage.Vertex));
Pipelinedescription2.SetVertexBinding(VertexInputRate.Vertex, VertexPositionNormalTexture.Size);
Pipelinedescription2.SetVertexAttribute(VertexType.Position);
Pipelinedescription2.SetVertexAttribute(VertexType.Normal);
Pipelinedescription2.SetVertexAttribute(VertexType.TextureCoordinate);
PipelineState_2 = new(Pipelinedescription2);
DescriptorData descriptorData_2 = new();
descriptorData_2.SetUniformBuffer(0, ConstBuffer3);
descriptorData_2.SetImage(1, text3);
descriptorData_2.SetSampler(2, sampler);
descriptorData_2.SetUniformBuffer(3, ConstBuffer4);
DescriptorSet_2 = new(PipelineState_2, descriptorData_2);
}
public override void Render(GraphicsPipeline gPipe)
{
// draw visible tree
if (geomPlaneVerts != null)
{
gDevice.RenderState.Lighting = false;
gDevice.SetTexture(0, null);
ShaderInterface shader = gPipe.ShaderIf;
foreach (GpuDemSubGeometry subGeom in geometryTree)
{
//if (subGeom.Level != 2 || subGeom.Code == 60)
// continue;
gPipe.Push();
shader.Effect.Technique = shader.Effect.GetTechnique("Basic");
shader.Effect.Begin(FX.None);
shader.Effect.BeginPass(0);
// draw main chunks - i.e. the middles
gDevice.Indices = geomPlaneIndices;
gDevice.SetStreamSource(0, geomPlaneVerts, 0);
gDevice.VertexFormat = CustomVertex.PositionTextured.Format;
gPipe.ShaderIf.Effect.SetValue("dem_level", subGeom.Level);
gPipe.ShaderIf.Effect.SetValue("DiffuseTexture", texturesCache[subGeom.Code].Heights);
gPipe.ShaderIf.Effect.SetValue("NormalMapTexture", texturesCache[subGeom.Code].Normals);
gPipe.WorldMatrix = Matrix.Scaling(new Vector3(subGeom.Dimensions.X, 1, subGeom.Dimensions.Y)) *
Matrix.Translation(new Vector3(subGeom.Position.X, 0, subGeom.Position.Y)) *
gPipe.WorldMatrix;
gDevice.DrawIndexedPrimitives(PrimitiveType.TriangleList, 0, 0, 14 * 14, 0, 13 * 13 * 2);
// draw any non-blending patches - i.e. fill the gaps
//gDevice.VertexFormat = PlaneHelper.PatchVertex.Format;
gDevice.VertexFormat = CustomVertex.PositionColoredTextured.Format;
gDevice.SetStreamSource(0, geomPatchVerts, 0);
gDevice.Indices = geomPatchIndices;
if (subGeom.SideCodes[3] == ulong.MaxValue)
{
gDevice.DrawIndexedPrimitives(PrimitiveType.TriangleList, (16 * 4) /* + 2*/, 0, 16 * 2, 3 * 15 * 2, 15 * 2);
}
if (subGeom.SideCodes[2] == ulong.MaxValue)
{
gDevice.DrawIndexedPrimitives(PrimitiveType.TriangleList, (16 * 6) /* + 2*/, 0, 16 * 2, 3 * 15 * 2, 15 * 2);
}
if (subGeom.SideCodes[0] == ulong.MaxValue)
{
gDevice.DrawIndexedPrimitives(PrimitiveType.TriangleList, /*2*/ 0, 0, 16 * 2, 0, 15 * 2);
}
if (subGeom.SideCodes[1] == ulong.MaxValue)
{
gDevice.DrawIndexedPrimitives(PrimitiveType.TriangleList, (16 * 2) /* + 2*/, 0, 16 * 2, 0, 15 * 2);
}
shader.Effect.EndPass();
shader.Effect.End();
// draw patches required
if (subGeom.SideCodes[3] != ulong.MaxValue)
{
CachedTexture tex = texturesCache[subGeom.SideCodes[3]];
gPipe.ShaderIf.Effect.SetValue("NextLevelHeightTexture", tex.Heights);
if (tex.Level == subGeom.Level)
{
shader.Effect.Technique = shader.Effect.GetTechnique("Basic_Patch_Int");
shader.Effect.Begin(FX.None);
shader.Effect.BeginPass(0);
}
else
{
if (subGeom.ChildNum == 1)
{
shader.Effect.Technique = shader.Effect.GetTechnique("Basic_Patch_Inv");
shader.Effect.Begin(FX.None);
shader.Effect.BeginPass(0);
gPipe.ShaderIf.Effect.SetValue("shift", 0.5f);
gPipe.ShaderIf.Effect.SetValue("scale", 0.5f);
}
else
{
shader.Effect.Technique = shader.Effect.GetTechnique("Basic_Patch");
shader.Effect.Begin(FX.None);
shader.Effect.BeginPass(0);
gPipe.ShaderIf.Effect.SetValue("shift", 0);
gPipe.ShaderIf.Effect.SetValue("scale", 0.5f);
}
}
gPipe.ShaderIf.Effect.SetValue("NormalMapTexture", texturesCache[subGeom.Code].Normals);
gPipe.ShaderIf.Effect.SetValue("axis", 0);
gPipe.ShaderIf.Effect.CommitChanges();
gDevice.DrawIndexedPrimitives(PrimitiveType.TriangleList, (16 * 4) + 2, 0, 16 * 2, 3 * 15 * 2, 13 * 2);
shader.Effect.EndPass();
shader.Effect.End();
}
if (subGeom.SideCodes[2] != ulong.MaxValue)
{
CachedTexture tex = texturesCache[subGeom.SideCodes[2]];
gPipe.ShaderIf.Effect.SetValue("NextLevelHeightTexture", tex.Heights);
if (tex.Level == subGeom.Level)
{
shader.Effect.Technique = shader.Effect.GetTechnique("Basic_Patch_Int");
shader.Effect.Begin(FX.None);
shader.Effect.BeginPass(0);
}
else
{
if (subGeom.ChildNum == 3)
{
shader.Effect.Technique = shader.Effect.GetTechnique("Basic_Patch_Inv");
shader.Effect.Begin(FX.None);
shader.Effect.BeginPass(0);
gPipe.ShaderIf.Effect.SetValue("shift", 0.5f);
gPipe.ShaderIf.Effect.SetValue("scale", 0.5f);
}
else
{
shader.Effect.Technique = shader.Effect.GetTechnique("Basic_Patch");
shader.Effect.Begin(FX.None);
shader.Effect.BeginPass(0);
gPipe.ShaderIf.Effect.SetValue("shift", 0);
gPipe.ShaderIf.Effect.SetValue("scale", 0.5f);
}
}
gPipe.ShaderIf.Effect.SetValue("NormalMapTexture", texturesCache[subGeom.Code].Normals);
gPipe.ShaderIf.Effect.SetValue("axis", 0);
gPipe.ShaderIf.Effect.CommitChanges();
gDevice.DrawIndexedPrimitives(PrimitiveType.TriangleList, (16 * 6) + 2, 0, 16 * 2, 3 * 15 * 2, 13 * 2);
shader.Effect.EndPass();
shader.Effect.End();
}
if (subGeom.SideCodes[0] != ulong.MaxValue)
{
CachedTexture tex = texturesCache[subGeom.SideCodes[0]];
gPipe.ShaderIf.Effect.SetValue("NextLevelHeightTexture", tex.Heights);
if (tex.Level == subGeom.Level)
{
shader.Effect.Technique = shader.Effect.GetTechnique("Basic_Patch_Int");
shader.Effect.Begin(FX.None);
shader.Effect.BeginPass(0);
}
else
{
if (subGeom.ChildNum == 2)
{
shader.Effect.Technique = shader.Effect.GetTechnique("Basic_Patch_Inv");
shader.Effect.Begin(FX.None);
shader.Effect.BeginPass(0);
gPipe.ShaderIf.Effect.SetValue("shift", 0.5f);
gPipe.ShaderIf.Effect.SetValue("scale", 0.5f);
}
else
{
shader.Effect.Technique = shader.Effect.GetTechnique("Basic_Patch");
shader.Effect.Begin(FX.None);
shader.Effect.BeginPass(0);
gPipe.ShaderIf.Effect.SetValue("shift", 0);
gPipe.ShaderIf.Effect.SetValue("scale", 0.5f);
}
}
gPipe.ShaderIf.Effect.SetValue("NormalMapTexture", texturesCache[subGeom.Code].Normals);
gPipe.ShaderIf.Effect.SetValue("axis", 1);
gPipe.ShaderIf.Effect.CommitChanges();
gDevice.DrawIndexedPrimitives(PrimitiveType.TriangleList, 2, 0, 16 * 2, 0, 13 * 2);
shader.Effect.EndPass();
shader.Effect.End();
}
if (subGeom.SideCodes[1] != ulong.MaxValue)
{
CachedTexture tex = texturesCache[subGeom.SideCodes[1]];
gPipe.ShaderIf.Effect.SetValue("NextLevelHeightTexture", tex.Heights);
if (tex.Level == subGeom.Level)
{
shader.Effect.Technique = shader.Effect.GetTechnique("Basic_Patch_Int");
shader.Effect.Begin(FX.None);
shader.Effect.BeginPass(0);
}
else
{
if (subGeom.ChildNum == 0)
{
shader.Effect.Technique = shader.Effect.GetTechnique("Basic_Patch_Inv");
shader.Effect.Begin(FX.None);
shader.Effect.BeginPass(0);
gPipe.ShaderIf.Effect.SetValue("shift", 0.5f);
gPipe.ShaderIf.Effect.SetValue("scale", 0.5f);
}
else
{
shader.Effect.Technique = shader.Effect.GetTechnique("Basic_Patch");
shader.Effect.Begin(FX.None);
shader.Effect.BeginPass(0);
gPipe.ShaderIf.Effect.SetValue("shift", 0);
gPipe.ShaderIf.Effect.SetValue("scale", 0.5f);
}
}
gPipe.ShaderIf.Effect.SetValue("NormalMapTexture", texturesCache[subGeom.Code].Normals);
gPipe.ShaderIf.Effect.SetValue("axis", 1);
gPipe.ShaderIf.Effect.CommitChanges();
gDevice.DrawIndexedPrimitives(PrimitiveType.TriangleList, (16 * 2) + 2, 0, 16 * 2, 0, 13 * 2);
shader.Effect.EndPass();
shader.Effect.End();
}
//TextureLoader.Save("c:/" + subGeom.Code + ".jpg", ImageFileFormat.Jpg, texturesCache[subGeom.Code].Tex);
gPipe.Pop();
}
}
}
static RenderPass()
{
graphicsPipeline = new GraphicsPipeline();
CreateBuffer();
}
public void Run()
{
try
{
// Load renderer
renderer = RenderSystem.Load("OpenGL", debugger);
// Create render context
var contextDesc = new RenderContextDescriptor();
{
contextDesc.VideoMode.Resolution.Width = 800;
contextDesc.VideoMode.Resolution.Height = 600;
contextDesc.VideoMode.ColorBits = 32;
contextDesc.VideoMode.DepthBits = 24;
contextDesc.VideoMode.StencilBits = 8;
contextDesc.ProfileOpenGL.ContextProfile = OpenGLContextProfile.CoreProfile;
}
context = renderer.CreateRenderContext(contextDesc);
// Get context window
var window = context.Surface;
window.Shown = true;
window.Title = $"LLGL for C# - HelloTriangle ( {renderer.Name} )";
// Print renderer information
Console.WriteLine("Renderer Info:");
var info = renderer.Info;
{
Console.WriteLine($" Renderer: {info.RendererName}");
Console.WriteLine($" Device: {info.DeviceName}");
Console.WriteLine($" Vendor: {info.VendorName}");
Console.WriteLine($" Shading Language: {info.ShadingLanguageName}");
}
// Create vertex buffer
var vertexFormat = new VertexFormat();
vertexFormat.AppendAttribute(new VertexAttribute("coord", Format.RGBA32Float));
vertexFormat.AppendAttribute(new VertexAttribute("color", Format.RGBA8UNorm));
var vertices = new Vertex[]
{
new Vertex {
x = 0.0f, y = 0.5f, z = 0.0f, w = 1.0f, r = 255, g = 0, b = 0, a = 255
},
new Vertex {
x = 0.5f, y = -0.5f, z = 0.0f, w = 1.0f, r = 0, g = 255, b = 0, a = 255
},
new Vertex {
x = -0.5f, y = -0.5f, z = 0.0f, w = 1.0f, r = 0, g = 0, b = 255, a = 255
},
};
var vertexBufferDesc = new BufferDescriptor();
{
vertexBufferDesc.Type = BufferType.Vertex;
vertexBufferDesc.Size = vertexFormat.Stride * (ulong)vertices.Length;
vertexBufferDesc.VertexBuffer.Format = vertexFormat;
}
var vertexBuffer = renderer.CreateBuffer(vertexBufferDesc, vertices);
// Create shaders
var vertShader = renderer.CreateShader(
new ShaderDescriptor(
type: ShaderType.Vertex,
sourceType: ShaderSourceType.CodeString,
source: @"
#version 330 core
in vec4 coord;
in vec3 color;
out vec4 vColor;
void main() {
gl_Position = coord;
vColor = vec4(color, 1);
}
"
)
);
var fragShader = renderer.CreateShader(
new ShaderDescriptor
(
type: ShaderType.Fragment,
sourceType: ShaderSourceType.CodeString,
source: @"
#version 330 core
in vec4 vColor;
out vec4 fColor;
void main() {
fColor = vColor;
}
"
)
);
var shaderProgramDesc = new ShaderProgramDescriptor();
{
shaderProgramDesc.VertexFormats.Add(vertexFormat);
shaderProgramDesc.VertexShader = vertShader;
shaderProgramDesc.FragmentShader = fragShader;
}
var shaderProgram = renderer.CreateShaderProgram(shaderProgramDesc);
if (shaderProgram.HasErrors)
{
throw new Exception(shaderProgram.QueryInfoLog());
}
// Create graphics pipeline
var pipelineDesc = new GraphicsPipelineDescriptor();
{
pipelineDesc.ShaderProgram = shaderProgram;
}
pipeline = renderer.CreateGraphicsPipeline(pipelineDesc);
// Get command queue
cmdQueue = renderer.CommandQueue;
cmdBuffer = renderer.CreateCommandBuffer();
cmdBuffer.SetClearColor(0.1f, 0.1f, 0.2f, 1.0f);
// Render loop
while (window.ProcessEvents())
{
cmdBuffer.Begin();
{
cmdBuffer.SetVertexBuffer(vertexBuffer);
cmdBuffer.BeginRenderPass(context);
{
cmdBuffer.Clear(ClearFlags.Color);
cmdBuffer.SetViewport(new Viewport(context.Resolution));
cmdBuffer.SetGraphicsPipeline(pipeline);
cmdBuffer.Draw(3, 0);
}
cmdBuffer.EndRenderPass();
}
cmdBuffer.End();
cmdQueue.Submit(cmdBuffer);
context.Present();
}
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
Console.WriteLine("press any key to continue ...");
Console.ReadKey();
}
finally
{
RenderSystem.Unload(renderer);
}
}
public void Run()
{
try
{
// Load renderer
renderer = RenderSystem.Load("OpenGL", debugger);
// Create render context
var contextDesc = new RenderContextDescriptor();
{
contextDesc.VideoMode.Resolution.Width = 800;
contextDesc.VideoMode.Resolution.Height = 600;
contextDesc.VideoMode.ColorBits = 32;
contextDesc.VideoMode.DepthBits = 24;
contextDesc.VideoMode.StencilBits = 8;
}
context = renderer.CreateRenderContext(contextDesc);
// Get context window
var window = context.Surface;
window.Shown = true;
window.Title = $"LLGL for C# - Texturing ( {renderer.Name} )";
// Print renderer information
Console.WriteLine("Renderer Info:");
var info = renderer.Info;
{
Console.WriteLine($" Renderer: {info.RendererName}");
Console.WriteLine($" Device: {info.DeviceName}");
Console.WriteLine($" Vendor: {info.VendorName}");
Console.WriteLine($" Shading Language: {info.ShadingLanguageName}");
}
// Create vertex buffer
var vertexFormat = new VertexFormat();
vertexFormat.AppendAttribute(new VertexAttribute("coord", Format.RG32Float));
vertexFormat.AppendAttribute(new VertexAttribute("texCoord", Format.RG32Float));
const float uvScale = 10.0f;
var vertices = new Vertex[]
{
new Vertex(-0.5f, -0.5f, 0.0f, uvScale),
new Vertex(-0.5f, +0.5f, 0.0f, 0.0f),
new Vertex(+0.5f, -0.5f, uvScale, uvScale),
new Vertex(+0.5f, +0.5f, uvScale, 0.0f),
};
var vertexBufferDesc = new BufferDescriptor();
{
vertexBufferDesc.BindFlags = BindFlags.VertexBuffer;
vertexBufferDesc.Size = vertexFormat.Stride * (ulong)vertices.Length;
vertexBufferDesc.VertexBuffer.Format = vertexFormat;
}
var vertexBuffer = renderer.CreateBuffer(vertexBufferDesc, vertices);
// Create shaders
var vertShader = renderer.CreateShader(
new ShaderDescriptor(
type: ShaderType.Vertex,
sourceType: ShaderSourceType.CodeString,
source: @"
#version 330 core
in vec2 coord;
in vec2 texCoord;
out vec2 vTexCoord;
void main() {
gl_Position = vec4(coord, 0, 1);
vTexCoord = texCoord;
}
"
)
);
var fragShader = renderer.CreateShader(
new ShaderDescriptor
(
type: ShaderType.Fragment,
sourceType: ShaderSourceType.CodeString,
source: @"
#version 330 core
in vec2 vTexCoord;
out vec4 fColor;
uniform sampler2D tex;
void main() {
fColor = texture(tex, vTexCoord);
}
"
)
);
var shaderProgramDesc = new ShaderProgramDescriptor();
{
shaderProgramDesc.VertexFormats.Add(vertexFormat);
shaderProgramDesc.VertexShader = vertShader;
shaderProgramDesc.FragmentShader = fragShader;
}
var shaderProgram = renderer.CreateShaderProgram(shaderProgramDesc);
if (shaderProgram.HasErrors)
{
throw new Exception(shaderProgram.Report);
}
// Create pipeline layout
var pipelineLayoutDesc = new PipelineLayoutDescriptor();
{
pipelineLayoutDesc.Bindings.Add(
new BindingDescriptor(ResourceType.Texture, BindFlags.Sampled, StageFlags.FragmentStage, 0)
);
pipelineLayoutDesc.Bindings.Add(
new BindingDescriptor(ResourceType.Sampler, 0, StageFlags.FragmentStage, 0)
);
}
var pipelineLayout = renderer.CreatePipelineLayout(pipelineLayoutDesc);
// Create graphics pipeline
var pipelineDesc = new GraphicsPipelineDescriptor();
{
pipelineDesc.ShaderProgram = shaderProgram;
pipelineDesc.PipelineLayout = pipelineLayout;
pipelineDesc.PrimitiveTopology = PrimitiveTopology.TriangleStrip;
pipelineDesc.Blend.Targets[0].BlendEnabled = true;
}
pipeline = renderer.CreateGraphicsPipeline(pipelineDesc);
// Create texture
var imageDesc = new SrcImageDescriptor <RGBA>();
{
imageDesc.Format = ImageFormat.RGBA;
imageDesc.DataType = DataType.UInt8;
imageDesc.Data = new RGBA[4];
imageDesc.Data[0] = new RGBA(255, 0, 0, 255);
imageDesc.Data[1] = new RGBA(0, 255, 0, 255);
imageDesc.Data[2] = new RGBA(0, 0, 0, 0);
imageDesc.Data[3] = new RGBA(0, 0, 0, 0);
}
var textureDesc = new TextureDescriptor();
{
textureDesc.Type = TextureType.Texture2D;
textureDesc.Extent = new Extent3D(2, 2, 1);
}
var texture = renderer.CreateTexture(textureDesc, imageDesc);
// Create sampler
var samplerDesc = new SamplerDescriptor();
{
samplerDesc.MagFilter = SamplerFilter.Nearest;
}
var sampler = renderer.CreateSampler(samplerDesc);
// Create resource heap
var resourceHeapDesc = new ResourceHeapDescriptor();
{
resourceHeapDesc.PipelineLayout = pipelineLayout;
resourceHeapDesc.ResourceViews.Add(new ResourceViewDescriptor(texture));
resourceHeapDesc.ResourceViews.Add(new ResourceViewDescriptor(sampler));
}
var resourceHeap = renderer.CreateResourceHeap(resourceHeapDesc);
// Get command queue
cmdQueue = renderer.CommandQueue;
cmdBuffer = renderer.CreateCommandBuffer();
cmdBuffer.SetClearColor(0.1f, 0.1f, 0.2f, 1.0f);
// Render loop
while (window.ProcessEvents())
{
cmdBuffer.Begin();
{
cmdBuffer.SetVertexBuffer(vertexBuffer);
cmdBuffer.BeginRenderPass(context);
{
cmdBuffer.Clear(ClearFlags.Color);
cmdBuffer.SetViewport(new Viewport(0, 0, context.Resolution.Width, context.Resolution.Height));
cmdBuffer.SetGraphicsPipeline(pipeline);
cmdBuffer.SetGraphicsResourceHeap(resourceHeap);
cmdBuffer.Draw(4, 0);
}
cmdBuffer.EndRenderPass();
}
cmdBuffer.End();
cmdQueue.Submit(cmdBuffer);
context.Present();
}
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
Console.WriteLine("press any key to continue ...");
Console.ReadKey();
}
finally
{
RenderSystem.Unload(renderer);
}
}
public override void Render(GraphicsPipeline gPipe)
{
gDevice.VertexFormat = CustomVertex.PositionNormalTextured.Format;
//gDevice.RenderState.CullMode = Cull.None;
//gDevice.RenderState.FillMode = FillMode.WireFrame;
gDevice.SamplerState[0].AddressU = TextureAddress.Clamp;
gDevice.SamplerState[0].AddressV = TextureAddress.Clamp;
gDevice.SamplerState[0].MinFilter = TextureFilter.Linear;
gDevice.SamplerState[0].MagFilter = TextureFilter.Linear;
gDevice.SamplerState[0].MipFilter = TextureFilter.Anisotropic;
//gDevice.SamplerState[0].BorderColor = Color.Red;
gDevice.Lights[0].Type = LightType.Directional;
gDevice.Lights[0].Direction = new Vector3(1, -1, 1);
gDevice.Lights[0].DiffuseColor = ColorValue.FromColor(Color.White);
gDevice.Lights[0].Update();
gDevice.Lights[0].Enabled = true;
gDevice.RenderState.Lighting = true;
int gIdx = 0;
foreach (CpuDEMSubGeometry geom in subGeometry)
{
if (useDiffuseTex)
{
gDevice.SetTexture(0, tex[gIdx++]);
}
else
{
gDevice.SetTexture(0, null);
}
gDevice.SetStreamSource(0, geom.vBuffer, 0);
IndexBuffer[] indices;
if (geom.iBufSize.Width > numSamples)
{
indices = iBuffersLong2;
}
else
{
indices = iBuffers;
}
foreach (IndexBuffer iBuffer in indices)
{
gDevice.Indices = iBuffer;
gDevice.DrawIndexedPrimitives(PrimitiveType.TriangleStrip, 0, 0, geom.iBufSize.Width * 2, 0, (geom.iBufSize.Width - 1) * 2);
}
// draw any skirts
for (int i = 0; i < geom.skirts.Length; i++)
{
gDevice.Indices = geom.skirts[i];
gDevice.DrawIndexedPrimitives(PrimitiveType.TriangleStrip, 0, 0, geom.iBufSize.Width * 2, 0, (geom.iBufSize.Width - 1) * 2);
}
}
gDevice.SetTexture(0, null);
gDevice.RenderState.Lighting = false;
}
// public TextureSampler[] TextureSamplers
// {
// get { return textureSamples; }
// }
public abstract void Render(GraphicsPipeline gPipe);
/// <summary>Initializes a new instance of the <see cref="GraphicsPipelineObject" /> class.</summary>
/// <param name="pipeline">The pipeline for which the object is being created.</param>
/// <param name="name">The name of the object or <c>null</c> to use <see cref="MemberInfo.Name" />.</param>
/// <exception cref="ArgumentNullException"><paramref name="pipeline" /> is <c>null</c>.</exception>
protected GraphicsPipelineObject(GraphicsPipeline pipeline, string?name = null) : base(pipeline.RenderPass, name)
{
_pipeline = pipeline;
}
internal GraphicsPipelineDescriptorSet(GraphicsPipeline pipeline, in GraphicsPipelineDescriptorSetCreateOptions createOptions) : base(pipeline)
