public Generator(World world)
{
myWorld = world;
myBiomeMap = new Texture(WorldParameters.theWorldSize, WorldParameters.theWorldSize, PixelInternalFormat.Rgba32f);
myBiomeMap.setName("Biome Map");
//setup shaders
List <ShaderDescriptor> shadersDesc = new List <ShaderDescriptor>();
shadersDesc.Add(new ShaderDescriptor(ShaderType.ComputeShader, "World Editor.shaders.applyElevation-cs.glsl"));
ShaderProgramDescriptor sd = new ShaderProgramDescriptor(shadersDesc);
myApplyElevationShader = Renderer.resourceManager.getResource(sd) as ShaderProgram;
shadersDesc = new List <ShaderDescriptor>();
shadersDesc.Add(new ShaderDescriptor(ShaderType.ComputeShader, "World Editor.shaders.applyHeat-cs.glsl"));
sd = new ShaderProgramDescriptor(shadersDesc);
myApplyHeatShader = Renderer.resourceManager.getResource(sd) as ShaderProgram;
shadersDesc = new List <ShaderDescriptor>();
shadersDesc.Add(new ShaderDescriptor(ShaderType.ComputeShader, "World Editor.shaders.applyMoisture-cs.glsl"));
sd = new ShaderProgramDescriptor(shadersDesc);
myApplyMoistureShader = Renderer.resourceManager.getResource(sd) as ShaderProgram;
shadersDesc = new List <ShaderDescriptor>();
shadersDesc.Add(new ShaderDescriptor(ShaderType.ComputeShader, "World Editor.shaders.applyBiome-cs.glsl"));
sd = new ShaderProgramDescriptor(shadersDesc);
myGenerateBiomeShader = Renderer.resourceManager.getResource(sd) as ShaderProgram;
//setup generators
load("../data/terrain/worldDefinitions/terrain.lua");
}
public TerrainRenderManager(World w)
{
world = w;
world.chunkAdded += handleChunkAdded;
world.chunkRemoved += handleChunkRemoved;
world.chunksReset += handleChunksReset;
TriangleVisualizer vis = new TriangleVisualizer(this);
Renderer.registerVisualizer("terrain", vis);
ShaderProgramDescriptor sd;
ShaderProgram sp;
List <ShaderDescriptor> desc = new List <ShaderDescriptor>();
desc.Add(new ShaderDescriptor(ShaderType.VertexShader, "..\\src\\Terrain\\rendering\\shaders\\terrainTri-vs.glsl", ShaderDescriptor.Source.File));
desc.Add(new ShaderDescriptor(ShaderType.GeometryShader, "..\\src\\Terrain\\rendering\\shaders\\terrainTri-gs.glsl", ShaderDescriptor.Source.File));
desc.Add(new ShaderDescriptor(ShaderType.FragmentShader, "..\\src\\Terrain\\rendering\\shaders\\terrainTri-ps.glsl", ShaderDescriptor.Source.File));
sd = new ShaderProgramDescriptor(desc, null, "terrain:perpixel");
sp = Renderer.resourceManager.getResource(sd) as ShaderProgram;
vis.registerEffect("forward-lighting", new PerPixelSolidEffect(sp));
vis.registerEffect("forward-lighting", new PerPixelTransparentEffect(sp));
desc.Clear();
desc.Add(new ShaderDescriptor(ShaderType.VertexShader, "..\\src\\Terrain\\rendering\\shaders\\terrainTri-vs.glsl", ShaderDescriptor.Source.File));
desc.Add(new ShaderDescriptor(ShaderType.GeometryShader, "..\\src\\Terrain\\rendering\\shaders\\terrainTri-gs.glsl", ShaderDescriptor.Source.File));
desc.Add(new ShaderDescriptor(ShaderType.FragmentShader, "..\\src\\Terrain\\rendering\\shaders\\water-ps.glsl", ShaderDescriptor.Source.File));
sd = new ShaderProgramDescriptor(desc, null, "terrain:water");
sp = Renderer.resourceManager.getResource(sd) as ShaderProgram;
vis.registerEffect("forward-lighting", new PerPixelWaterEffect(sp));
}
static Canvas()
{
ShaderProgramDescriptor desc = new ShaderProgramDescriptor("UI.shaders.ui-vs.glsl", "UI.shaders.ui-ps.glsl");
theShader = Renderer.resourceManager.getResource(desc) as ShaderProgram;
//we're expecting a sheet that is 32x32 glyphs each 32pix x 32pix in size. (1024 x 1024 texture)
theDefaultTexture = Graphics.Util.getEmbeddedTexture("UI.data.fontIconSheet.png");
theDefaultTexture.setMinMagFilters(TextureMinFilter.NearestMipmapNearest, TextureMagFilter.Nearest);
theGlyphs = new List <Glyph>(1024);
float width = theDefaultTexture.width;
float height = theDefaultTexture.height;
float step = 1.0f / 32.0f;
for (int i = 0; i < 1024; i++)
{
float cx = (float)(i % 32) / 32.0f; // X Position Of Current Character
float cy = (float)(i / 32) / 32.0f; // Y Position Of Current Character
Glyph g = new Glyph();
g.size = new Vector2(32, 32);
g.minTexCoord.X = cx;
g.minTexCoord.Y = 1 - cy - step;
g.maxTexCoord.X = cx + step;
g.maxTexCoord.Y = 1 - cy;
g.advance = g.size * 0.6f;
theGlyphs.Add(g);
}
}
public Planet(Camera c)
{
myCamera = c;
for (int i = 0; i < MAX_TRI; i++)
{
myTris.Add(new Tri());
}
myFov = MathHelper.DegreesToRadians(myCamera.fieldOfView);
mySinFov = (float)Math.Sin(myFov);
myCosFov = (float)Math.Cos(myFov);
init();
myTextureManager.init();
//setup the shader
List <ShaderDescriptor> desc = new List <ShaderDescriptor>();
desc.Add(new ShaderDescriptor(ShaderType.VertexShader, "Test IcoPlanet.shaders.draw-planet-vs.glsl"));
desc.Add(new ShaderDescriptor(ShaderType.GeometryShader, "Test IcoPlanet.shaders.draw-planet-gs.glsl"));
desc.Add(new ShaderDescriptor(ShaderType.FragmentShader, "Test IcoPlanet.shaders.draw-planet-ps.glsl"));
ShaderProgramDescriptor sd = new ShaderProgramDescriptor(desc);
ShaderProgram shader = Renderer.resourceManager.getResource(sd) as ShaderProgram;
myRenderCommand = new StatelessDrawElementsCommand(PrimitiveType.Triangles, (int)myIndexCount, 0, IndexBufferObject.IndexBufferDatatype.UnsignedInt);
myRenderCommand.pipelineState.shaderState.shaderProgram = shader;
myRenderCommand.pipelineState.vaoState.vao = new VertexArrayObject();
myRenderCommand.pipelineState.vaoState.vao.bindVertexFormat <V3F1>(shader);
myRenderCommand.pipelineState.generateId();
myHeightTexture = new Texture("../data/textures/EarthLookupTable.png");
}
public void updateShader()
{
String src = shader.Replace("FUNC", myFunction);
List <ShaderDescriptor> shadersDesc = new List <ShaderDescriptor>();
shadersDesc.Add(new ShaderDescriptor(ShaderType.ComputeShader, src, ShaderDescriptor.Source.String));
shadersDesc.Add(new ShaderDescriptor(ShaderType.ComputeShader, "GpuNoise.shaders.function-cs.glsl"));
ShaderProgramDescriptor sd = new ShaderProgramDescriptor(shadersDesc);
myShaderProgram = Renderer.resourceManager.getResource(sd) as ShaderProgram;
}
public Combiner(int x, int y) : base(Type.Combiner, x, y)
{
output = new Texture(x, y, PixelInternalFormat.R32f);
output.setName("Combiner output");
List <ShaderDescriptor> shadersDesc = new List <ShaderDescriptor>();
shadersDesc.Add(new ShaderDescriptor(ShaderType.ComputeShader, "GpuNoise.shaders.combiner-cs.glsl"));
ShaderProgramDescriptor sd = new ShaderProgramDescriptor(shadersDesc);
myShaderProgram = Renderer.resourceManager.getResource(sd) as ShaderProgram;
}
public MainWindow(GameWindow window, World world)
{
myGameWindow = window;
myWorld = world;
List <ShaderDescriptor> shadersDesc = new List <ShaderDescriptor>();
shadersDesc.Add(new ShaderDescriptor(ShaderType.VertexShader, "Graphics.shaders.draw-vs.glsl"));
shadersDesc.Add(new ShaderDescriptor(ShaderType.FragmentShader, "World Editor.shaders.display-biome-ps.glsl"));
ShaderProgramDescriptor sd = new ShaderProgramDescriptor(shadersDesc);
myDisplayBiomeShader = Renderer.resourceManager.getResource(sd) as ShaderProgram;
}
public Generator()
{
for (int i = 0; i < 6; i++)
{
myElevationTex[i] = new Texture(WorldParameters.theWorldTextureSize, WorldParameters.theWorldTextureSize, PixelInternalFormat.R32f);
myElevationTex[i].setName(String.Format("Elevation Tex {0}", i));
myBiomeTex[i] = new Texture(WorldParameters.theWorldTextureSize, WorldParameters.theWorldTextureSize, PixelInternalFormat.Rgba32f);
myBiomeTex[i].setName(String.Format("Biome Tex {0}", i));
}
myElevationMap = new CubemapTexture(WorldParameters.theWorldTextureSize, WorldParameters.theWorldTextureSize, PixelInternalFormat.R32f);
myElevationMap.setName("Elevation Cubemap");
myBiomeMap = new CubemapTexture(WorldParameters.theWorldTextureSize, WorldParameters.theWorldTextureSize, PixelInternalFormat.Rgba32f);
myBiomeMap.setName("Biome Cubemap");
List <ShaderDescriptor> shadersDesc = new List <ShaderDescriptor>();
shadersDesc.Add(new ShaderDescriptor(ShaderType.ComputeShader, "World Editor.shaders.applyElevation-cs.glsl"));
ShaderProgramDescriptor sd = new ShaderProgramDescriptor(shadersDesc);
myApplyElevationShader = Renderer.resourceManager.getResource(sd) as ShaderProgram;
shadersDesc = new List <ShaderDescriptor>();
shadersDesc.Add(new ShaderDescriptor(ShaderType.ComputeShader, "World Editor.shaders.applyHeat-cs.glsl"));
sd = new ShaderProgramDescriptor(shadersDesc);
myApplyHeatShader = Renderer.resourceManager.getResource(sd) as ShaderProgram;
shadersDesc = new List <ShaderDescriptor>();
shadersDesc.Add(new ShaderDescriptor(ShaderType.ComputeShader, "World Editor.shaders.applyMoisture-cs.glsl"));
sd = new ShaderProgramDescriptor(shadersDesc);
myApplyMoistureShader = Renderer.resourceManager.getResource(sd) as ShaderProgram;
shadersDesc = new List <ShaderDescriptor>();
shadersDesc.Add(new ShaderDescriptor(ShaderType.ComputeShader, "World Editor.shaders.applyBiome-cs.glsl"));
sd = new ShaderProgramDescriptor(shadersDesc);
myGenerateBiomeShader = Renderer.resourceManager.getResource(sd) as ShaderProgram;
//setup generators
myElevationGenerator = new ModuleTree(WorldParameters.theWorldTextureSize, WorldParameters.theWorldTextureSize);
myElevationFractals[0] = myElevationGenerator.addModule(Module.Type.Fractal, "fractal0") as Fractal;
myElevationFractals[1] = myElevationGenerator.addModule(Module.Type.Fractal, "fractal") as Fractal;
myElevationFractals[2] = myElevationGenerator.addModule(Module.Type.Fractal, "fractal2") as Fractal;
myElevationFractals[3] = myElevationGenerator.addModule(Module.Type.Fractal, "fractal3") as Fractal;
myElevationFractals[4] = myElevationGenerator.addModule(Module.Type.Fractal, "fractal4") as Fractal;
myElevationFractals[5] = myElevationGenerator.addModule(Module.Type.Fractal, "fractal5") as Fractal;
AutoCorrect Eac = myElevationGenerator.addModule(Module.Type.AutoCorect, "autocorrect") as AutoCorrect;
myHeatGenerator = createHeatGenerator();
myMoistureGenerator = createMoistureGenerator();
}
public void init()
{
world.chunkAdded += handleChunkAdded;
world.chunkRemoved += handleChunkRemoved;
world.chunksReset += handleChunksReset;
Vector2 size = new Vector2(1920, 1280);
myWaterColorBuffer = new Texture((int)size.X, (int)size.Y, PixelInternalFormat.Rgba8);
myWaterDepthBuffer = new Texture((int)size.X, (int)size.Y, PixelInternalFormat.DepthComponent32f);
List <RenderTargetDescriptor> rtdesc = new List <RenderTargetDescriptor>();
rtdesc.Add(new RenderTargetDescriptor()
{
attach = FramebufferAttachment.ColorAttachment0, tex = myWaterColorBuffer
}); //uses an existing texture
rtdesc.Add(new RenderTargetDescriptor()
{
attach = FramebufferAttachment.DepthAttachment, tex = myWaterDepthBuffer
}); //uses an existing texture
myWaterRenderTarget = new RenderTarget((int)size.X, (int)size.Y, rtdesc);
TriangleVisualizer vis = new TriangleVisualizer(this);
Renderer.registerVisualizer("terrain", vis);
ShaderProgramDescriptor sd;
ShaderProgram sp;
List <ShaderDescriptor> desc = new List <ShaderDescriptor>();
desc.Add(new ShaderDescriptor(ShaderType.VertexShader, "..\\src\\Terrain\\rendering\\shaders\\terrainTri-vs.glsl", ShaderDescriptor.Source.File));
desc.Add(new ShaderDescriptor(ShaderType.GeometryShader, "..\\src\\Terrain\\rendering\\shaders\\terrainTri-gs.glsl", ShaderDescriptor.Source.File));
desc.Add(new ShaderDescriptor(ShaderType.FragmentShader, "..\\src\\Terrain\\rendering\\shaders\\terrainTri-ps.glsl", ShaderDescriptor.Source.File));
sd = new ShaderProgramDescriptor(desc, null, "terrain:perpixel");
sp = Renderer.resourceManager.getResource(sd) as ShaderProgram;
vis.registerEffect("forward-lighting", new PerPixelSolidEffect(sp));
vis.registerEffect("forward-lighting", new PerPixelTransparentEffect(sp));
desc.Clear();
desc.Add(new ShaderDescriptor(ShaderType.VertexShader, "..\\src\\Terrain\\rendering\\shaders\\terrainTri-vs.glsl", ShaderDescriptor.Source.File));
desc.Add(new ShaderDescriptor(ShaderType.GeometryShader, "..\\src\\Terrain\\rendering\\shaders\\terrainTri-gs.glsl", ShaderDescriptor.Source.File));
desc.Add(new ShaderDescriptor(ShaderType.FragmentShader, "..\\src\\Terrain\\rendering\\shaders\\water-ps.glsl", ShaderDescriptor.Source.File));
sd = new ShaderProgramDescriptor(desc, null, "terrain:water");
sp = Renderer.resourceManager.getResource(sd) as ShaderProgram;
vis.registerEffect("forward-lighting", new PerPixelWaterEffect(sp));
}
static Canvas()
{
ShaderProgramDescriptor desc = new ShaderProgramDescriptor("UI.shaders.ui-vs.glsl", "UI.shaders.ui-ps.glsl");
theShader = Renderer.resourceManager.getResource(desc) as ShaderProgram;
//a single white pixel
Texture.PixelData pd = new Texture.PixelData()
{
pixelFormat = PixelFormat.Rgba,
dataType = PixelType.UnsignedByte,
data = new byte[] { 255, 255, 255, 255 }
};
theDefaultTexture = new Texture(1, 1, PixelInternalFormat.Rgba8, pd);
theDefaultTexture.setMinMagFilters(TextureMinFilter.Linear, TextureMagFilter.Linear);
theDefaultTexture.setWrapping(TextureWrapMode.Repeat, TextureWrapMode.Repeat, TextureWrapMode.Repeat);
}
public void init(LuaObject config)
{
myBiome = new Texture((int)WorldParameters.theRegionSize, (int)WorldParameters.theRegionSize, PixelInternalFormat.Rgba32f);
myBiome.setName("Biome Map");
mySampler = new Sampler2D(myBiome);
LuaObject genConfig = config["generator"];
myElevationGenerator = ModuleFactory.create(genConfig["elevation"]);
myHeatGenerator = ModuleFactory.create(genConfig["heat"]);
myMoistureGenerator = ModuleFactory.create(genConfig["moisture"]);
//setup shaders
List <ShaderDescriptor> shadersDesc = new List <ShaderDescriptor>();
shadersDesc.Add(new ShaderDescriptor(ShaderType.ComputeShader, "Terrain.shaders.applyElevation-cs.glsl"));
ShaderProgramDescriptor sd = new ShaderProgramDescriptor(shadersDesc);
myApplyElevationShader = Renderer.resourceManager.getResource(sd) as ShaderProgram;
shadersDesc = new List <ShaderDescriptor>();
shadersDesc.Add(new ShaderDescriptor(ShaderType.ComputeShader, "Terrain.shaders.applyHeat-cs.glsl"));
sd = new ShaderProgramDescriptor(shadersDesc);
myApplyHeatShader = Renderer.resourceManager.getResource(sd) as ShaderProgram;
shadersDesc = new List <ShaderDescriptor>();
shadersDesc.Add(new ShaderDescriptor(ShaderType.ComputeShader, "Terrain.shaders.applyMoisture-cs.glsl"));
sd = new ShaderProgramDescriptor(shadersDesc);
myApplyMoistureShader = Renderer.resourceManager.getResource(sd) as ShaderProgram;
shadersDesc = new List <ShaderDescriptor>();
shadersDesc.Add(new ShaderDescriptor(ShaderType.ComputeShader, "Terrain.shaders.applyBiome-cs.glsl"));
sd = new ShaderProgramDescriptor(shadersDesc);
myGenerateBiomeShader = Renderer.resourceManager.getResource(sd) as ShaderProgram;
update();
}
public AutoCorrect(int x, int y) : base(Type.AutoCorect, x, y)
{
output = new Texture(x, y, PixelInternalFormat.R32f);
output.setName("AutoCorrect output");
List <ShaderDescriptor> shadersDesc = new List <ShaderDescriptor>();
shadersDesc.Add(new ShaderDescriptor(ShaderType.ComputeShader, "GpuNoise.shaders.minmax-cs.glsl"));
ShaderProgramDescriptor sd = new ShaderProgramDescriptor(shadersDesc);
myMinMaxShader = Renderer.resourceManager.getResource(sd) as ShaderProgram;
shadersDesc = new List <ShaderDescriptor>();
shadersDesc.Add(new ShaderDescriptor(ShaderType.ComputeShader, "GpuNoise.shaders.minmax-pass2-cs.glsl"));
sd = new ShaderProgramDescriptor(shadersDesc);
myMinMaxPass2Shader = Renderer.resourceManager.getResource(sd) as ShaderProgram;
shadersDesc = new List <ShaderDescriptor>();
shadersDesc.Add(new ShaderDescriptor(ShaderType.ComputeShader, "GpuNoise.shaders.autocorrect-cs.glsl"));
sd = new ShaderProgramDescriptor(shadersDesc);
myAutoCorrectShader = Renderer.resourceManager.getResource(sd) as ShaderProgram;
reset();
}
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.Samples = 8;
}
var 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, 0));
vertexFormat.AppendAttribute(new VertexAttribute("color", Format.RGBA8UNorm, 1));
var vertices = new []
{
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.BindFlags = BindFlags.VertexBuffer;
vertexBufferDesc.Size = vertexFormat.Attributes[0].Stride * (ulong)vertices.Length;
vertexBufferDesc.VertexAttribs = vertexFormat.Attributes;
}
var vertexBuffer = renderer.CreateBuffer(vertexBufferDesc, vertices);
// Create shaders
var vsDesc = new ShaderDescriptor(
type: ShaderType.Vertex,
sourceType: ShaderSourceType.CodeString,
source: @"
#version 330 core
in vec4 coord;
in vec4 color;
out vec4 vColor;
void main() {
gl_Position = coord;
vColor = color;
}
"
);
vsDesc.Vertex.InputAttribs = vertexFormat.Attributes;
var fsDesc = new ShaderDescriptor(
type: ShaderType.Fragment,
sourceType: ShaderSourceType.CodeString,
source: @"
#version 330 core
in vec4 vColor;
out vec4 fColor;
void main() {
fColor = vColor;
}
"
);
var vertShader = renderer.CreateShader(vsDesc);
var fragShader = renderer.CreateShader(fsDesc);
var shaderProgramDesc = new ShaderProgramDescriptor();
{
shaderProgramDesc.VertexShader = vertShader;
shaderProgramDesc.FragmentShader = fragShader;
}
var shaderProgram = renderer.CreateShaderProgram(shaderProgramDesc);
if (shaderProgram.HasErrors)
{
throw new System.IO.InvalidDataException(shaderProgram.Report);
}
// Create graphics pipeline
var pipelineDesc = new GraphicsPipelineDescriptor();
{
pipelineDesc.ShaderProgram = shaderProgram;
pipelineDesc.Rasterizer.MultiSampleEnabled = true;
}
var pipeline = renderer.CreatePipelineState(pipelineDesc);
// Get command queue
var cmdQueue = renderer.CommandQueue;
var 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.SetPipelineState(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);
}
}
static RenderCubemapSphere()
{
theOrientation = Matrix4.CreateFromQuaternion(new Quaternion(0f, 0f, 0f));
List <ShaderDescriptor> shadersDesc = new List <ShaderDescriptor>();
shadersDesc.Add(new ShaderDescriptor(ShaderType.VertexShader, "GpuNoise.shaders.cube-vs.glsl"));
shadersDesc.Add(new ShaderDescriptor(ShaderType.FragmentShader, "GpuNoise.shaders.cube-ps.glsl"));
ShaderProgramDescriptor sd = new ShaderProgramDescriptor(shadersDesc);
theShader = Renderer.resourceManager.getResource(sd) as ShaderProgram;
theVBO = new VertexBufferObject <V3>(BufferUsageHint.StaticDraw);
theIBO = new IndexBufferObject(BufferUsageHint.StaticDraw);
int lats = 25;
int longs = 25;
int vertIdx = 0;
V3[] verts = new V3[(lats + 1) * (longs + 1)];
ushort[] index = new ushort[lats * longs * 6];
for (int i = 0; i <= lats; i++)
{
float theta = (float)i * (float)Math.PI / lats;
float sinTheta = (float)Math.Sin(theta);
float cosTheta = (float)Math.Cos(theta);
for (int j = 0; j <= longs; j++)
{
float phi = (float)j * (float)(Math.PI * 2) / longs;
float sinPhi = (float)Math.Sin(phi);
float cosPhi = (float)Math.Cos(phi);
float x = cosPhi * sinTheta;
float y = sinPhi * sinTheta;
float z = cosTheta;
// float u = 1 - (j / longs);
// float v = 1- (i / lats);
V3 temp = new V3();
temp.Position = new Vector3(x, y, z);
verts[vertIdx++] = temp;
}
}
int indexIdx = 0;
for (int i = 0; i < lats; i++)
{
for (int j = 0; j < longs; j++)
{
ushort first = (ushort)((i * (longs + 1)) + j);
ushort second = (ushort)(first + longs + 1);
index[indexIdx++] = first; index[indexIdx++] = second; index[indexIdx++] = (ushort)(first + 1);
index[indexIdx++] = second; index[indexIdx++] = (ushort)(second + 1); index[indexIdx++] = (ushort)(first + 1);
}
}
theVBO.setData(verts);
theIBO.setData(index);
theVAO = new VertexArrayObject();
theVAO.bindVertexFormat <V3>(theShader);
thePipeline = new PipelineState();
thePipeline.shaderState.shaderProgram = theShader;
thePipeline.vaoState.vao = theVAO;
thePipeline.generateId();
}
