/// <summary> /// Explore the ShaderSource and add the necessary shaders /// </summary> /// <param name="shaderSource">the ShaderSource to explore</param> /// <param name="macros">the macros used</param> /// <returns></returns> public HashSet<ModuleMixinInfo> LoadShaderSource(ShaderSource shaderSource, SiliconStudio.Shaders.Parser.ShaderMacro[] macros) { var mixinsToAnalyze = new HashSet<ModuleMixinInfo>(); ExtendLibrary(shaderSource, macros, mixinsToAnalyze); ReplaceMixins(mixinsToAnalyze); // no longer replace mixin, redo analysis everytime since there is no way to correctly detect something changed return mixinsToAnalyze; }
public CompilerResults Compile(ShaderSource shaderSource, CompilerParameters compilerParameters) { ShaderMixinSource mixinToCompile; var shaderMixinGeneratorSource = shaderSource as ShaderMixinGeneratorSource; if (shaderMixinGeneratorSource != null) { mixinToCompile = ShaderMixinManager.Generate(shaderMixinGeneratorSource.Name, compilerParameters); } else { mixinToCompile = shaderSource as ShaderMixinSource; var shaderClassSource = shaderSource as ShaderClassSource; if (shaderClassSource != null) { mixinToCompile = new ShaderMixinSource { Name = shaderClassSource.ClassName }; mixinToCompile.Mixins.Add(shaderClassSource); } if (mixinToCompile == null) { throw new ArgumentException("Unsupported ShaderSource type [{0}]. Supporting only ShaderMixinSource/pdxfx, ShaderClassSource", "shaderSource"); } if (string.IsNullOrEmpty(mixinToCompile.Name)) { throw new ArgumentException("ShaderMixinSource must have a name", "shaderSource"); } } // Copy global parameters to used Parameters by default, as it is used by the compiler mixinToCompile.UsedParameters.Set(CompilerParameters.GraphicsPlatformKey, compilerParameters.Platform); mixinToCompile.UsedParameters.Set(CompilerParameters.GraphicsProfileKey, compilerParameters.Profile); mixinToCompile.UsedParameters.Set(CompilerParameters.DebugKey, compilerParameters.Debug); // Compile the whole mixin tree var compilerResults = new CompilerResults { Module = string.Format("EffectCompile [{0}]", mixinToCompile.Name) }; var bytecode = Compile(mixinToCompile, compilerParameters); // Since bytecode.Result is a struct, we check if any of its member has been set to know if it's valid if (bytecode.Result.CompilationLog != null || bytecode.Task != null) { if (bytecode.Result.CompilationLog != null) { bytecode.Result.CompilationLog.CopyTo(compilerResults); } compilerResults.Bytecode = bytecode; compilerResults.UsedParameters = mixinToCompile.UsedParameters; } return compilerResults; }
/// <summary> /// create the context for each composition by cloning their dependencies /// </summary> /// <param name="shaderSource">the entry ShaderSource (root)</param> /// <param name="dictionary">the ouputed compositions</param> /// <param name="compilationContext">the compilation context</param> /// <param name="cloneContext">The clone context.</param> /// <returns>a list of all the needed mixins</returns> private static List <ModuleMixin> BuildCompositionsDictionary(ShaderSource shaderSource, CompositionDictionary dictionary, ShaderCompilationContext compilationContext, CloneContext cloneContext, LoggerResult log) { if (shaderSource is ShaderMixinSource) { var shaderMixinSource = shaderSource as ShaderMixinSource; var finalModule = compilationContext.GetModuleMixinFromShaderSource(shaderSource); //PerformanceLogger.Start(PerformanceStage.DeepClone); finalModule = finalModule.DeepClone(new CloneContext(cloneContext)); //PerformanceLogger.Pause(PerformanceStage.DeepClone); foreach (var composition in shaderMixinSource.Compositions) { //look for the key var foundVars = finalModule.FindAllVariablesByName(composition.Key).Where(value => value.Variable.Qualifiers.Contains(XenkoStorageQualifier.Compose)).ToList(); if (foundVars.Count > 1) { log.Error(XenkoMessageCode.ErrorAmbiguousComposition, new SourceSpan(), composition.Key); } else if (foundVars.Count > 0) { Variable foundVar = foundVars[0].Variable; var moduleMixins = BuildCompositionsDictionary(composition.Value, dictionary, compilationContext, cloneContext, log); if (moduleMixins == null) { return(null); } dictionary.Add(foundVar, moduleMixins); } else { // No matching variable was found // TODO: log a message? } } return(new List <ModuleMixin> { finalModule }); } if (shaderSource is ShaderClassSource) { var finalModule = compilationContext.GetModuleMixinFromShaderSource(shaderSource); //PerformanceLogger.Start(PerformanceStage.DeepClone); finalModule = finalModule.DeepClone(new CloneContext(cloneContext)); //PerformanceLogger.Pause(PerformanceStage.DeepClone); return(new List <ModuleMixin> { finalModule }); } if (shaderSource is ShaderArraySource) { var shaderArraySource = shaderSource as ShaderArraySource; var compositionArray = new List <ModuleMixin>(); foreach (var shader in shaderArraySource.Values) { var mixin = BuildCompositionsDictionary(shader, dictionary, compilationContext, cloneContext, log); if (mixin == null) { return(null); } compositionArray.AddRange(mixin); } return(compositionArray); } return(null); }
static void Main(string[] args) { Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); var form = new Form { ClientSize = new Size(800, 600), Text = "Tutorial 21: Specular Mapping", }; using (var device = LightDevice.Create(form)) { //--------------------- // Target & Pipeline //--------------------- var target = new RenderTarget(device.GetDefaultTarget(), device.CreateDefaultDepthStencilTarget()); target.Apply(); Pipeline pipeline = device.CompilePipeline(InputTopology.Triangle, ShaderSource.FromResource("SpecMap_vs.fx", ShaderType.Vertex), ShaderSource.FromResource("SpecMap_ps.fx", ShaderType.Pixel)); pipeline.Apply(); //--------------------- // Vertex buffer //--------------------- var vertexDataProcessor = pipeline.CreateVertexDataProcessor <ModelVertex>(); VertexBuffer vertexBuffer; using (var stream = Assembly.GetEntryAssembly().GetManifestResourceStream("Tutorial21.cube.txt")) { vertexBuffer = vertexDataProcessor.CreateImmutableBuffer(Model.ReadModelFile(stream)); } //--------------------- // Constant buffer (Matrix, VS) //--------------------- var matrixBuffer = pipeline.CreateConstantBuffer <MatrixBuffer>(); pipeline.SetConstant(ShaderType.Vertex, 0, matrixBuffer); void SetupProjMatrix() { matrixBuffer.Value.Projection = device.CreatePerspectiveFieldOfView((float)Math.PI / 4).Transpose(); } device.ResolutionChanged += (sender, e) => SetupProjMatrix(); matrixBuffer.Value.World = Matrix4x4.Identity.Transpose(); SetupProjMatrix(); //--------------------- // Constant buffer (Camera, VS) //--------------------- var cameraBuffer = pipeline.CreateConstantBuffer <CameraBuffer>(); pipeline.SetConstant(ShaderType.Vertex, 1, cameraBuffer); //--------------------- // Constant buffer (Light, PS) //--------------------- var lightBuffer = pipeline.CreateConstantBuffer <LightBuffer>(); pipeline.SetConstant(ShaderType.Pixel, 0, lightBuffer); lightBuffer.Value.DiffuseColor = Color.White.WithAlpha(1); lightBuffer.Value.LightDirection = Vector3.Normalize(new Vector3(0, 0, 1)); lightBuffer.Value.SpecularColor = Color.White.WithAlpha(1); lightBuffer.Value.SpecularPower = 16; lightBuffer.Update(); //--------------------- // Texture //--------------------- Texture2D CreateTextureFromResource(string name) { using (var stream = Assembly.GetEntryAssembly().GetManifestResourceStream($"Tutorial21.{name}.dds")) { return(device.CreateTexture2D(stream)); } } var tex1 = CreateTextureFromResource("stone02"); var tex2 = CreateTextureFromResource("bump02"); var tex3 = CreateTextureFromResource("spec02"); pipeline.SetResource(0, tex1); pipeline.SetResource(1, tex2); pipeline.SetResource(2, tex3); //--------------------- // Camera //--------------------- var camera = new Camera(); //--------------------- // Start main loop //--------------------- form.Show(); var frameCounter = new FrameCounter(); frameCounter.Start(); device.RunMultithreadLoop(delegate() { // Update matrix buffer var time = frameCounter.NextFrame() / 1000; Matrix4x4 rotate = Matrix4x4.CreateRotationX(time * 3) * Matrix4x4.CreateRotationY(time * 6) * Matrix4x4.CreateRotationZ(time * 4); matrixBuffer.Value.World *= rotate; matrixBuffer.Value.View = camera.GetViewMatrix().Transpose(); matrixBuffer.Update(); // Update camera buffer cameraBuffer.Value.CameraPosition = camera.Position; cameraBuffer.Update(); // Clear and draw target.ClearAll(); vertexBuffer.DrawAll(); device.Present(true); }); } }
public LightSkyBoxShaderGroup(ShaderSource mixin) : base(mixin) { HasEffectPermutations = true; }
/// <summary> /// Get the module mixin based on the ShaderSource /// </summary> /// <param name="shaderSource">the ShaderSource</param> /// <returns>the ModuleMixin</returns> public ModuleMixin GetModuleMixinFromShaderSource(ShaderSource shaderSource) { var found = MixinInfos.FirstOrDefault(x => x.ShaderSource.Equals(shaderSource)); return found == null ? null : found.Mixin; }
/// <summary> /// Explore the ShaderSource and add the necessary shaders /// </summary> /// <param name="shaderSource">the ShaderSource to explore</param> /// <param name="macros">the macros used</param> private void ExtendLibrary(ShaderSource shaderSource, SiliconStudio.Shaders.Parser.ShaderMacro[] macros, HashSet<ModuleMixinInfo> mixinToAnalyze) { if (shaderSource is ShaderMixinSource) { var newMacros = MergeMacroSets((ShaderMixinSource)shaderSource, macros); mixinToAnalyze.Add(GetModuleMixinInfo(shaderSource, newMacros)); foreach (var composition in ((ShaderMixinSource)shaderSource).Compositions) ExtendLibrary(composition.Value, newMacros, mixinToAnalyze); } else if (shaderSource is ShaderClassSource) mixinToAnalyze.Add(GetModuleMixinInfo(shaderSource, macros)); else if (shaderSource is ShaderArraySource) { foreach (var shader in ((ShaderArraySource)shaderSource).Values) ExtendLibrary(shader, macros, mixinToAnalyze); } }
private void CanvasLoad(object sender, EventArgs e) { GL.ClearColor(0.59f, 0.59f, 0.59f, 1.0f); GL.Enable(EnableCap.DepthTest); var LightPos = new Vector3(0.0f, -0.5f, 0.5f); var pointLight = new PointLight { Ambient = new Vector3(0.2f, 0.4f, 0.6f), Diffuse = new Vector3(0.8f, 0.9f, 0.5f), Specular = new Vector3(1.0f, 0.8f, 1.0f), Position = new Vector3(0.0f, -0.5f, 0.5f), Constant = 1.0f, Linear = 0.35f, Quadratic = 0.44f, Source = new Cube(LightPos, 0.05f, Material.LightSource, Matrix4.Identity), }; var spotLight = new SpotLight { Ambient = new Vector3(0.2f, 0.4f, 0.6f), Diffuse = new Vector3(0.8f, 0.9f, 0.5f), Specular = new Vector3(1.0f, 0.8f, 1.0f), Position = LightPos, Direction = new Vector3(-0.2f, 0.45f, 0.0f) - LightPos, Constant = 1.0f, Linear = 0.35f, Quadratic = 0.44f, CutOff = (float)Math.Cos(MathHelper.DegreesToRadians(18.5)), OuterCutOff = (float)Math.Cos(MathHelper.DegreesToRadians(29.5)), }; var spotLight1 = new SpotLight { Ambient = new Vector3(0.2f, 0.4f, 0.6f), Diffuse = new Vector3(0.8f, 0.9f, 0.5f), Specular = new Vector3(1.0f, 0.8f, 1.0f), Position = LightPos, Direction = new Vector3(0.2f, -0.9f, 0.0f) - LightPos, Constant = 1.0f, Linear = 0.35f, Quadratic = 0.44f, CutOff = (float)Math.Cos(MathHelper.DegreesToRadians(18.5)), OuterCutOff = (float)Math.Cos(MathHelper.DegreesToRadians(29.5)), }; Matrix4 model = Matrix4.Identity; Matrix4 cylinder = Matrix4.Mult(Matrix4.CreateTranslation(0.4f, 0.0f, 0.0f), model); cylinder = Matrix4.Mult(Matrix4.CreateTranslation(0.0f, 0.1f, 0.0f), cylinder); Matrix4 conus = Matrix4.Mult(Matrix4.CreateTranslation(-0.4f, 0.4f, 0.0f), model); Matrix4 cube = Matrix4.Mult(Matrix4.CreateTranslation(0.1f, 0.5f, 0.0f), model); GraphicScene = new Scene(ShaderSource.Phong(1, 0)) { Shapes = new List <Shape> { new Cone(new Vector3(0.0f, 0.0f, 0.0f), 0.1f, 0.3f, Material.Ruby, conus), new Cube(new Vector3(0.0f, 0.0f, 0.15f), 0.3f, Material.Pearl, cube), new Cylinder(new Vector3(0.0f, 0.0f, 0.0f), 0.1f, 0.3f, Material.Bronze, cylinder), new Sheet(new Vector3(1.0f, -1.0f, 0.0f), new Vector3(1.0f, 1.0f, 0.0f), new Vector3(-1.0f, -1.0f, 0.0f), new Vector3(-1.0f, 1.0f, 0.0f), Material.YellowPlastic, Matrix4.Identity), new Sheet(new Vector3(1.0f, 1.0f, 0.0f), new Vector3(1.0f, -1.0f, 0.0f), new Vector3(1.0f, 1.0f, 1.0f), new Vector3(1.0f, -1.0f, 1.0f), Material.YellowPlastic, Matrix4.Identity), new Sheet(new Vector3(-1.0f, 1.0f, 0.0f), new Vector3(1.0f, 1.0f, 0.0f), new Vector3(-1.0f, 1.0f, 1.0f), new Vector3(1.0f, 1.0f, 1.0f), Material.YellowPlastic, Matrix4.Identity), }, //Lights = new List<LightSource> //{ // pointLight, //}, }; GraphicScene.Add(pointLight); //GraphicScene.Add(spotLight); //GraphicScene.Add(spotLight1); isLoad = true; Status.Text = "Готово"; }
public bool AreEqual(ShaderSource shaderSource, Xenko.Core.Shaders.Parser.ShaderMacro[] macros) { return(ShaderSource.Equals(shaderSource) && macros.All(macro => Macros.Any(x => x.Name == macro.Name && x.Definition == macro.Definition)) && Macros.All(macro => macros.Any(x => x.Name == macro.Name && x.Definition == macro.Definition))); }
static void Main(string[] args) { Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); var form = new Form { ClientSize = new Size(800, 600), Text = "Tutorial 7: 3D Model Rendering", }; using (var device = LightDevice.Create(form)) { //--------------------- // Target & Pipeline //--------------------- var target = new RenderTarget(device.GetDefaultTarget(), device.CreateDefaultDepthStencilTarget()); target.Apply(); Pipeline pipeline = device.CompilePipeline(InputTopology.Triangle, ShaderSource.FromResource("Light_vs.fx", ShaderType.Vertex), ShaderSource.FromResource("Light_ps.fx", ShaderType.Pixel)); pipeline.Apply(); //--------------------- // Vertex buffer //--------------------- var vertexDataProcessor = pipeline.CreateVertexDataProcessor <ModelVertex>(); VertexBuffer vertexBuffer; using (var stream = Assembly.GetEntryAssembly().GetManifestResourceStream("Tutorial07.Cube.txt")) { vertexBuffer = vertexDataProcessor.CreateImmutableBuffer(Model.ReadModelFile(stream)); } //--------------------- // Constant buffer (VS) //--------------------- var constantBufferVS = pipeline.CreateConstantBuffer <VSConstants>(); pipeline.SetConstant(ShaderType.Vertex, 0, constantBufferVS); void SetupProjMatrix() { constantBufferVS.Value.Projection = device.CreatePerspectiveFieldOfView((float)Math.PI / 4).Transpose(); } device.ResolutionChanged += (sender, e) => SetupProjMatrix(); constantBufferVS.Value.World = Matrix4x4.Identity.Transpose(); SetupProjMatrix(); //--------------------- // Constant buffer (PS) //--------------------- var constantBufferPS = pipeline.CreateConstantBuffer <PSConstants>(); pipeline.SetConstant(ShaderType.Pixel, 0, constantBufferPS); constantBufferPS.Value.Diffuse = Color.White.WithAlpha(1); constantBufferPS.Value.LightDir = Vector3.Normalize(new Vector3(-3f, -4f, 6f)); constantBufferPS.Update(); //--------------------- // Texture //--------------------- Texture2D tex; using (var stream = Assembly.GetEntryAssembly().GetManifestResourceStream("Tutorial07.seafloor.dds")) { tex = device.CreateTexture2D(stream); } pipeline.SetResource(0, tex); //--------------------- // Camera //--------------------- var camera = new Camera(); //--------------------- // Start main loop //--------------------- form.Show(); var frameCounter = new FrameCounter(); frameCounter.Start(); device.RunMultithreadLoop(delegate() { // Update matrix var time = frameCounter.NextFrame() / 1000; Matrix4x4 rotate = Matrix4x4.CreateRotationX(time * 3) * Matrix4x4.CreateRotationY(time * 6) * Matrix4x4.CreateRotationZ(time * 4); constantBufferVS.Value.World *= rotate; constantBufferVS.Value.View = camera.GetViewMatrix().Transpose(); constantBufferVS.Update(); // Clear and draw target.ClearAll(); vertexBuffer.DrawAll(); device.Present(true); }); } }
static void Main() { Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); var form = new Form(); form.ClientSize = new Size(800, 600); using (var device = LightDevice.Create(form)) { var target = new RenderTargetList(device.GetDefaultTarget()); target.Apply(); Pipeline pipeline = device.CompilePipeline(InputTopology.Triangle, ShaderSource.FromResource("Shader.fx", ShaderType.Vertex | ShaderType.Pixel)); Texture2D texture; using (var stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("TextureTriangle.Hiyori.png")) { using (var bitmap = new Bitmap(stream)) { texture = device.CreateTexture2D(bitmap); pipeline.SetResource(0, texture); } } pipeline.Apply(); var input = pipeline.CreateVertexDataProcessor <Vertex>(); var buffer = input.CreateImmutableBuffer(new[] { new Vertex { TexCoord = new Vector4(0, 0, 0, 0), Position = new Vector4(-0.5f, 0.5f, 0.5f, 1.0f) }, new Vertex { TexCoord = new Vector4(1, 0, 0, 0), Position = new Vector4(0.5f, 0.5f, 0.5f, 1.0f) }, new Vertex { TexCoord = new Vector4(0, 1, 0, 0), Position = new Vector4(-0.5f, -0.5f, 0.5f, 1.0f) }, new Vertex { TexCoord = new Vector4(0, 1, 0, 0), Position = new Vector4(-0.5f, -0.5f, 0.5f, 1.0f) }, new Vertex { TexCoord = new Vector4(1, 0, 0, 0), Position = new Vector4(0.5f, 0.5f, 0.5f, 1.0f) }, new Vertex { TexCoord = new Vector4(1, 1, 0, 0), Position = new Vector4(0.5f, -0.5f, 0.5f, 1.0f) }, }); form.Show(); device.RunMultithreadLoop(delegate() { target.ClearAll(); buffer.DrawAll(); device.Present(true); }); } }
//Deferred Renderer Rework - New GBuffer - //32:32:32 WorldPos, (16b:SPARE, 16b:materialIdx) //8:8:8 Norm, 8:SPARE //reproject z buffer and recompute chain for culling public DeferredRenderer(Framebuffer[] fbufs, LightManager man) { lMan = man; InfoBindings = new TextureBinding[fbufs.Length]; InfoBindings2 = new TextureBinding[fbufs.Length]; DepthBindings = new TextureBinding[fbufs.Length]; Framebuffers = new Framebuffer[fbufs.Length]; HiZMap = new TextureView[fbufs.Length][]; views = new ViewData[fbufs.Length]; HiZMapUBO = new UniformBuffer(false); unsafe { int off = 0; float *fp = (float *)HiZMapUBO.Update(); fp += 4; for (int i = 0; i < views.Length; i++) { views[i] = new ViewData() { depthBuf = new Texture() { Width = fbufs[i].Width, Height = fbufs[i].Height, Depth = 1, Format = PixelInternalFormat.DepthComponent32f, GenerateMipmaps = false, LayerCount = 1, LevelCount = 1, Target = TextureTarget.Texture2D }.Build(), infoTex = new Texture() { Width = fbufs[i].Width, Height = fbufs[i].Height, Depth = 1, Format = PixelInternalFormat.Rgba32f, GenerateMipmaps = false, LayerCount = 1, LevelCount = 1, Target = TextureTarget.Texture2D }.Build(), infoTex2 = new Texture() { Width = fbufs[i].Width, Height = fbufs[i].Height, Depth = 1, Format = PixelInternalFormat.Rgba8, GenerateMipmaps = false, LayerCount = 1, LevelCount = 1, Target = TextureTarget.Texture2D }.Build(), hiZ = new Texture() { Width = fbufs[i].Width, Height = fbufs[i].Height, Depth = 1, Format = PixelInternalFormat.Rg32f, GenerateMipmaps = false, LayerCount = 1, LevelCount = (int)(MathHelper.Log2((ulong)Math.Max(fbufs[i].Width, fbufs[i].Height)) + 1), Target = TextureTarget.Texture2D }.Build(), gbuffer = new Framebuffer(fbufs[i].Width, fbufs[i].Height), }; views[i].depthView = new TextureView() { BaseLayer = 0, BaseLevel = 0, Format = PixelInternalFormat.DepthComponent32f, LayerCount = 1, LevelCount = 1, Target = TextureTarget.Texture2D }.Build(views[i].depthBuf); views[i].infoView = new TextureView() { BaseLayer = 0, BaseLevel = 0, Format = PixelInternalFormat.Rgba32f, LayerCount = 1, LevelCount = 1, Target = TextureTarget.Texture2D }.Build(views[i].infoTex); views[i].infoView2 = new TextureView() { BaseLayer = 0, BaseLevel = 0, Format = PixelInternalFormat.Rgba8, LayerCount = 1, LevelCount = 1, Target = TextureTarget.Texture2D }.Build(views[i].infoTex2); views[i].hiZView = new TextureView[views[i].hiZ.LevelCount]; for (int j = 0; j < views[i].hiZView.Length; j++) { views[i].hiZView[j] = new TextureView() { BaseLayer = 0, BaseLevel = j, Format = PixelInternalFormat.Rg32f, LayerCount = 1, LevelCount = 1, Target = TextureTarget.Texture2D, }.Build(views[i].hiZ); var f_arr = (float[])views[i].hiZView[j].GetImageHandle().SetResidency(Residency.Resident, AccessMode.ReadWrite); for (int q = 0; q < f_arr.Length; q++) { *(fp++) = f_arr[q]; } fp += 2; } views[i].hiZTex = new TextureView() { BaseLayer = 0, BaseLevel = 0, Format = PixelInternalFormat.Rg32f, LayerCount = 1, LevelCount = views[i].hiZView.Length, Target = TextureTarget.Texture2D }.Build(views[i].hiZ); var sampler = new TextureSampler(); sampler.SetEnableLinearFilter(false, true, false); sampler.MinReadLevel = 0; sampler.MaxReadLevel = views[i].hiZView.Length; sampler.SetTileMode(TileMode.ClampToBorder, TileMode.ClampToBorder); views[i].hiZBinding = new TextureBinding() { View = views[i].hiZTex, Sampler = sampler }; var f_arr_ = (float[])views[i].hiZBinding.GetTextureHandle().SetResidency(Residency.Resident); for (int q = 0; q < f_arr_.Length; q++) { *(fp++) = f_arr_[q]; } fp += 2; views[i].gbuffer[FramebufferAttachment.DepthAttachment] = views[i].depthView; views[i].gbuffer[FramebufferAttachment.ColorAttachment0] = views[i].infoView; views[i].gbuffer[FramebufferAttachment.ColorAttachment1] = views[i].infoView2; Framebuffers[i] = views[i].gbuffer; views[i].program = new ShaderProgram( ShaderSource.Load(ShaderType.VertexShader, "Shaders/RenderToTexture/FrameBufferTriangle/vertex.glsl"), ShaderSource.Load(ShaderType.FragmentShader, "Shaders/RenderToTexture/FrameBufferTriangle/fragment.glsl") ); views[i].copy = new ShaderProgram( ShaderSource.Load(ShaderType.ComputeShader, "Shaders/HiZ/copy.glsl", $"#define MIP_COUNT {views[i].hiZView.Length}") ); views[i].copyState = new RenderState(null, views[i].copy, null, new UniformBuffer[] { Engine.GlobalParameters, HiZMapUBO }, false, false, DepthFunc.Always, InverseDepth.Far, InverseDepth.Near, BlendFactor.SrcAlpha, BlendFactor.OneMinusSrcAlpha, Vector4.Zero, InverseDepth.ClearDepth, CullFaceMode.Back); views[i].mipchain = new ShaderProgram( ShaderSource.Load(ShaderType.ComputeShader, "Shaders/HiZ/mipchain.glsl", $"#define MIP_COUNT {views[i].hiZView.Length}") ); views[i].mipchainState = new RenderState(null, views[i].mipchain, null, new UniformBuffer[] { Engine.GlobalParameters, HiZMapUBO }, false, false, DepthFunc.Always, InverseDepth.Far, InverseDepth.Near, BlendFactor.SrcAlpha, BlendFactor.OneMinusSrcAlpha, Vector4.Zero, InverseDepth.ClearDepth, CullFaceMode.Back); views[i].state = new RenderState(fbufs[i], views[i].program, null, new UniformBuffer[] { Engine.GlobalParameters }, false, true, DepthFunc.Always, InverseDepth.Far, InverseDepth.Near, BlendFactor.SrcAlpha, BlendFactor.OneMinusSrcAlpha, Vector4.Zero, InverseDepth.ClearDepth, CullFaceMode.None); InfoBindings[i] = new TextureBinding() { View = views[i].infoView, Sampler = TextureSampler.Default }; InfoBindings[i].GetTextureHandle().SetResidency(Residency.Resident); InfoBindings2[i] = new TextureBinding() { View = views[i].infoView2, Sampler = TextureSampler.Default }; InfoBindings2[i].GetTextureHandle().SetResidency(Residency.Resident); DepthBindings[i] = new TextureBinding() { View = views[i].depthView, Sampler = TextureSampler.Default, }; DepthBindings[i].GetTextureHandle().SetResidency(Residency.Resident); HiZMap[i] = views[i].hiZView; views[i].cBuffer = new CommandBuffer(); views[i].cBuffer.SetRenderState(views[i].state); views[i].cBuffer.Draw(PrimitiveType.Triangles, 0, 3, 1, 0); } HiZMapUBO.UpdateDone(); } }
public static void Run() { GraphicsContext context = new GraphicsContext() { Camera = new FirstPersonCamera(new Vector3(4, 3, 3), Vector3.UnitY) }; Matrix4 World = Matrix4.Identity; VoxelTypeMap v = new VoxelTypeMap(); v[0] = new VoxelTypeMap.VoxelTypeData() { Color = Vector4.One, Visible = false }; v[1] = new VoxelTypeMap.VoxelTypeData() { Color = Vector4.UnitY * 0.7f + Vector4.UnitW, Visible = true }; v[2] = new VoxelTypeMap.VoxelTypeData() { Color = Vector4.UnitX + Vector4.UnitW, Visible = true }; BlockManager man = new BlockManager(); man.Side = 32; man.VoxelTypes = v; //Rendering stuff ShaderProgram prog = null; GraphicsDevice.Load += () => { //GraphicsDevice.Winding = FaceWinding.Clockwise; GraphicsDevice.CullMode = OpenTK.Graphics.OpenGL4.CullFaceMode.Back; GraphicsDevice.DepthTestEnabled = true; GraphicsDevice.Window.KeyUp += (k, e) => { if (e.Key == OpenTK.Input.Key.Z) { GraphicsDevice.Wireframe = !GraphicsDevice.Wireframe; } else if (e.Key == OpenTK.Input.Key.C) { GraphicsDevice.CullEnabled = !GraphicsDevice.CullEnabled; } }; Random rng = new Random(0); double n = 64; v.UpdateBuffers(); GraphicsDevice.SetBufferTexture(0, v.ColorData); ShaderSource vShader = ShaderSource.Load(OpenTK.Graphics.OpenGL4.ShaderType.VertexShader, "Testing/VoxTest/vertex.glsl"); ShaderSource fShader = ShaderSource.Load(OpenTK.Graphics.OpenGL4.ShaderType.FragmentShader, "Testing/VoxTest/fragment.glsl"); prog = new ShaderProgram(vShader, fShader); prog.Set("materialColors", 0); }; GraphicsDevice.Update += (e) => { context.Update(e); //World *= Matrix4.CreateRotationY(0.01f); prog.Set("World", Matrix4.Identity); prog.Set("View", context.View); prog.Set("Proj", context.Projection); prog.Set("Fcoef", (float)(2.0f / Math.Log(1000001) / Math.Log(2))); prog.Set("lightDir", new Vector3(5, 10, 5).Normalized()); }; GraphicsDevice.Render += (e) => { GraphicsDevice.Clear(); for (int k = -2; k < 0; k++) { Vector3 a = new Vector3(); a.Y = k * man.Side; for (int i = -5; i <= 5; i++) { a.Z = i * man.Side; for (int j = -5; j <= 5; j++) { a.X = j * man.Side; Vector3 dir = (context.Camera as FirstPersonCamera).Direction; if (Vector3.Dot(dir.Normalized(), a.Normalized()) >= -0.3) { //Chunk c = man.Draw(-Vector3.UnitY * 123, out World); Chunk c = man.Draw(context.Camera.Position + a, out World); if (c.ChunkReady) { c.Bind(); prog.Set("World", World); prog.Set("range1", c.NormalOffsets[1]); prog.Set("range2", c.NormalOffsets[2]); prog.Set("range3", c.NormalOffsets[3]); prog.Set("range4", c.NormalOffsets[4]); prog.Set("range5", c.NormalOffsets[5]); GraphicsDevice.SetShaderProgram(prog); GraphicsDevice.Draw(OpenTK.Graphics.OpenGL4.PrimitiveType.Triangles, 0, c.NormalGroupSizes[6]); } } } } } GraphicsDevice.SwapBuffers(); }; GraphicsDevice.Name = "Voxel Test"; GraphicsDevice.Run(60, 0); if (GraphicsDevice.Cleanup != null) { GraphicsDevice.Cleanup(); } }
public static void Run() { ShaderProgram prog = null, terrProg = null; Texture tex = null, t2 = null; GraphicsContext context = new GraphicsContext() { Camera = new FirstPersonCamera(new Vector3(4, 3, 3), Vector3.UnitY) }; BitmapTextureSource bmpTex, b2, b3; bmpTex = TextDrawer.CreateWriter("Times New Roman", FontStyle.Regular).Write("Hello!", 200, System.Drawing.Color.White); b2 = new BitmapTextureSource("test.jpg", 0); b3 = new BitmapTextureSource("test.png", 0); Texture fbufTex = null, t3 = null; FramebufferTextureSource fbufTexSrc = new FramebufferTextureSource(256, 256, 0); Framebuffer fbuf = null; Matrix4 World = Matrix4.Identity; EngineObject eObj = null, fsq = null; float timer = 0; CubeMapTextureSource tFace = new CubeMapTextureSource(CubeMapTextureSource.CubeMapFace.PositiveY, b3), bFace = new CubeMapTextureSource(CubeMapTextureSource.CubeMapFace.PositiveX, b3), lFace = new CubeMapTextureSource(CubeMapTextureSource.CubeMapFace.PositiveZ, b3), rFace = new CubeMapTextureSource(CubeMapTextureSource.CubeMapFace.NegativeX, b3), fFace = new CubeMapTextureSource(CubeMapTextureSource.CubeMapFace.NegativeY, b3), hFace = new CubeMapTextureSource(CubeMapTextureSource.CubeMapFace.NegativeZ, b3); GraphicsDevice.Load += () => { // setup settings, load textures, sounds GraphicsDevice.Wireframe = false; GraphicsDevice.AlphaEnabled = true; GraphicsDevice.DepthTestEnabled = true; GraphicsDevice.CullEnabled = false; GraphicsDevice.CullMode = CullFaceMode.Back; eObj = new EngineObject(); float[] data = { -1, -1, 1, 1, -1, 1, 0, 1, 1 }; uint[] indexData = new uint[] { 0, 1, 2 }; ShaderSource vert = ShaderSource.Load(ShaderType.VertexShader, "Testing/TG_A/vertex.glsl"); ShaderSource frag = ShaderSource.Load(ShaderType.FragmentShader, "Testing/TG_A/fragment.glsl"); ShaderSource tctrl = ShaderSource.Load(ShaderType.TessControlShader, "Testing/TG_A/tesscontrol.glsl"); ShaderSource teval = ShaderSource.Load(ShaderType.TessEvaluationShader, "Testing/TG_A/tessdomain.glsl"); ShaderSource vA = ShaderSource.Load(ShaderType.VertexShader, "Shaders/TerrainGen/vertex.glsl"); ShaderSource fA = ShaderSource.Load(ShaderType.FragmentShader, "Shaders/TerrainGen/fragment.glsl"); terrProg = new ShaderProgram(vA, fA); terrProg.Set("World", Matrix4.Identity); fbuf = new Framebuffer(256, 256); fbufTex = new Texture(); fbufTex.SetData(fbufTexSrc); fbuf[FramebufferAttachment.ColorAttachment0] = fbufTex; fsq = FullScreenQuadFactory.Create(); t3 = new Texture(); t3.SetData(tFace); t3.SetData(bFace); t3.SetData(lFace); t3.SetData(rFace); t3.SetData(fFace); t3.SetData(hFace); t3.SetEnableLinearFilter(true); t3.SetAnisotropicFilter(Texture.MaxAnisotropy); tex = new Texture(); tex.SetData(bmpTex); tex.SetAnisotropicFilter(Texture.MaxAnisotropy); t2 = new Texture(); t2.SetData(b3); t2.SetAnisotropicFilter(Texture.MaxAnisotropy); prog = new ShaderProgram(vert, tctrl, teval, frag); prog.Set("img", 0); prog.Set("heightmap", 1); prog.Set("World", World); vert.Dispose(); frag.Dispose(); tctrl.Dispose(); teval.Dispose(); //eObj = FullScreenQuadFactory.Create(); eObj = CubeFactory.Create(); eObj.SetTexture(0, t2); eObj.SetTexture(1, t3); b3.Dispose(); }; bool eyePosStill = false; GraphicsDevice.Update += (e) => { // add game logic, input handling if (GraphicsDevice.Keyboard[Key.Escape]) { GraphicsDevice.Exit(); } if (GraphicsDevice.Keyboard[Key.Z]) { GraphicsDevice.Wireframe = !GraphicsDevice.Wireframe; //GraphicsDevice.CullEnabled = !GraphicsDevice.Wireframe; } if (GraphicsDevice.Keyboard[Key.F]) { eyePosStill = !eyePosStill; Console.WriteLine("EyePosStill = " + eyePosStill); } context.Update(e); //context.Projection = Matrix4.Identity; //context.View = Matrix4.Identity; prog.Set("View", context.View); prog.Set("Proj", context.Projection); if (!eyePosStill) { prog.Set("eyePos", context.Camera.Position); } prog.Set("Fcoef", (float)(2.0f / Math.Log(1000001) / Math.Log(2))); //timer += 0.001f; //World = Matrix4.RotateY(timer); World = Matrix4.CreateScale(10); prog.Set("World", World); prog.Set("timer", timer); terrProg.Set("timer", timer); }; bool te1 = false; GraphicsDevice.Render += (e) => { GraphicsDevice.SetFramebuffer(fbuf); GraphicsDevice.Clear(); fsq.Bind(); GraphicsDevice.SetShaderProgram(terrProg); GraphicsDevice.SetViewport(0, 0, 256, 256); GraphicsDevice.Draw(PrimitiveType.Triangles, 0, fsq.IndexCount); eObj.Bind(); GraphicsDevice.SetShaderProgram(prog); GraphicsDevice.SetViewport(0, 0, GraphicsDevice.WindowSize.Width, GraphicsDevice.WindowSize.Height); GraphicsDevice.PatchCount = 3; GraphicsDevice.Draw(PrimitiveType.Patches, 0, eObj.IndexCount); GraphicsDevice.SwapBuffers(); if (!te1) { te1 = true; GraphicsDevice.SaveTexture(fbufTex, "test1.png"); } }; GraphicsDevice.Name = "The Julis Faction"; // Run the game at 60 updates per second GraphicsDevice.Run(60.0, 60.0); if (GraphicsDevice.Cleanup != null) { GraphicsDevice.Cleanup(); } }
protected LightShaderGroupAndDataPool(ShaderSource mixin, string compositionName, ILightShadowMapShaderGroupData shadowGroupData) : base(mixin, compositionName, shadowGroupData) { dataPool = new PoolListStruct <T>(4, CreateData); }
public void LoadGLEntryPoints() { /* Basic entry points. If you don't have these, you're screwed. */ try { INTERNAL_glGetString = (GetString) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glGetString"), typeof(GetString) ); glGetIntegerv = (GetIntegerv) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glGetIntegerv"), typeof(GetIntegerv) ); glEnable = (Enable) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glEnable"), typeof(Enable) ); glDisable = (Disable) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glDisable"), typeof(Disable) ); glViewport = (G_Viewport) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glViewport"), typeof(G_Viewport) ); glDepthRange = (DepthRange) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glDepthRange"), typeof(DepthRange) ); glScissor = (Scissor) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glScissor"), typeof(Scissor) ); glBlendColor = (BlendColor) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glBlendColor"), typeof(BlendColor) ); glBlendFuncSeparate = (BlendFuncSeparate) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glBlendFuncSeparate"), typeof(BlendFuncSeparate) ); glBlendEquationSeparate = (BlendEquationSeparate) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glBlendEquationSeparate"), typeof(BlendEquationSeparate) ); glColorMask = (ColorMask) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glColorMask"), typeof(ColorMask) ); glDepthMask = (DepthMask) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glDepthMask"), typeof(DepthMask) ); glDepthFunc = (DepthFunc) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glDepthFunc"), typeof(DepthFunc) ); glStencilMask = (StencilMask) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glStencilMask"), typeof(StencilMask) ); glStencilFuncSeparate = (StencilFuncSeparate) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glStencilFuncSeparate"), typeof(StencilFuncSeparate) ); glStencilOpSeparate = (StencilOpSeparate) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glStencilOpSeparate"), typeof(StencilOpSeparate) ); glStencilFunc = (StencilFunc) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glStencilFunc"), typeof(StencilFunc) ); glStencilOp = (StencilOp) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glStencilOp"), typeof(StencilOp) ); glCullFace = (CullFace) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glCullFace"), typeof(CullFace) ); glFrontFace = (FrontFace) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glFrontFace"), typeof(FrontFace) ); glPolygonMode = (PolygonMode) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glPolygonMode"), typeof(PolygonMode) ); glPolygonOffset = (PolygonOffset) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glPolygonOffset"), typeof(PolygonOffset) ); glGenTextures = (GenTextures) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glGenTextures"), typeof(GenTextures) ); glDeleteTextures = (DeleteTextures) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glDeleteTextures"), typeof(DeleteTextures) ); glBindTexture = (G_BindTexture) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glBindTexture"), typeof(G_BindTexture) ); glTexImage2D = (TexImage2D) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glTexImage2D"), typeof(TexImage2D) ); glTexSubImage2D = (TexSubImage2D) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glTexSubImage2D"), typeof(TexSubImage2D) ); glCompressedTexImage2D = (CompressedTexImage2D) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glCompressedTexImage2D"), typeof(CompressedTexImage2D) ); glCompressedTexSubImage2D = (CompressedTexSubImage2D) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glCompressedTexSubImage2D"), typeof(CompressedTexSubImage2D) ); glTexImage3D = (TexImage3D) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glTexImage3D"), typeof(TexImage3D) ); glTexSubImage3D = (TexSubImage3D) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glTexSubImage3D"), typeof(TexSubImage3D) ); glGetTexImage = (GetTexImage) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glGetTexImage"), typeof(GetTexImage) ); glTexParameteri = (TexParameteri) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glTexParameteri"), typeof(TexParameteri) ); glTexParameterf = (TexParameterf) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glTexParameterf"), typeof(TexParameterf) ); glActiveTexture = (ActiveTexture) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glActiveTexture"), typeof(ActiveTexture) ); glGetTexLevelParameteriv = (GetTexLevelParameteriv) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glGetTexLevelParameteriv"), typeof(GetTexLevelParameteriv) ); glPixelStorei = (PixelStorei) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glPixelStorei"), typeof(PixelStorei) ); glGenBuffers = (GenBuffers) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glGenBuffers"), typeof(GenBuffers) ); glDeleteBuffers = (DeleteBuffers) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glDeleteBuffers"), typeof(DeleteBuffers) ); glBindBuffer = (BindBuffer) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glBindBuffer"), typeof(BindBuffer) ); glBufferData = (BufferData) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glBufferData"), typeof(BufferData) ); glBufferSubData = (BufferSubData) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glBufferSubData"), typeof(BufferSubData) ); glMapBuffer = (MapBuffer) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glMapBuffer"), typeof(MapBuffer) ); glUnmapBuffer = (UnmapBuffer) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glUnmapBuffer"), typeof(UnmapBuffer) ); glEnableVertexAttribArray = (EnableVertexAttribArray) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glEnableVertexAttribArray"), typeof(EnableVertexAttribArray) ); glDisableVertexAttribArray = (DisableVertexAttribArray) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glDisableVertexAttribArray"), typeof(DisableVertexAttribArray) ); glVertexAttribPointer = (G_VertexAttribPointer) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glVertexAttribPointer"), typeof(G_VertexAttribPointer) ); glClearColor = (ClearColor) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glClearColor"), typeof(ClearColor) ); glClearDepth = (ClearDepth) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glClearDepth"), typeof(ClearDepth) ); glClearStencil = (ClearStencil) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glClearStencil"), typeof(ClearStencil) ); glClear = (G_Clear) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glClear"), typeof(G_Clear) ); glDrawBuffers = (DrawBuffers) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glDrawBuffers"), typeof(DrawBuffers) ); glReadPixels = (ReadPixels) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glReadPixels"), typeof(ReadPixels) ); glDrawRangeElements = (DrawRangeElements) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glDrawRangeElements"), typeof(DrawRangeElements) ); glDrawArrays = (DrawArrays) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glDrawArrays"), typeof(DrawArrays) ); glGenQueries = (GenQueries) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glGenQueries"), typeof(GenQueries) ); glDeleteQueries = (DeleteQueries) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glDeleteQueries"), typeof(DeleteQueries) ); glBeginQuery = (BeginQuery) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glBeginQuery"), typeof(BeginQuery) ); glEndQuery = (EndQuery) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glEndQuery"), typeof(EndQuery) ); glGetQueryObjectiv = (GetQueryObjectiv) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glGetQueryObjectiv"), typeof(GetQueryObjectiv) ); glCreateShader = (CreateShader) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glCreateShader"), typeof(CreateShader) ); glDeleteShader = (DeleteShader) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glDeleteShader"), typeof(DeleteShader) ); glShaderSource = (ShaderSource) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glShaderSource"), typeof(ShaderSource) ); glCompileShader = (CompileShader) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glCompileShader"), typeof(CompileShader) ); glCreateProgram = (CreateProgram) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glCreateProgram"), typeof(CreateProgram) ); glDeleteProgram = (DeleteProgram) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glDeleteProgram"), typeof(DeleteProgram) ); glAttachShader = (AttachShader) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glAttachShader"), typeof(AttachShader) ); glDetachShader = (DetachShader) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glDetachShader"), typeof(DetachShader) ); glLinkProgram = (LinkProgram) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glLinkProgram"), typeof(LinkProgram) ); glUseProgram = (UseProgram) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glUseProgram"), typeof(UseProgram) ); glUniform1i = (Uniform1i) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glUniform1i"), typeof(Uniform1i) ); glUniform4fv = (Uniform4fv) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glUniform4fv"), typeof(Uniform4fv) ); glGetShaderiv = (GetShaderiv) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glGetShaderiv"), typeof(GetShaderiv) ); glGetProgramiv = (GetProgramiv) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glGetProgramiv"), typeof(GetProgramiv) ); glGetUniformLocation = (GetUniformLocation) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glGetUniformLocation"), typeof(GetUniformLocation) ); glGetAttribLocation = (GetAttribLocation) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glGetAttribLocation"), typeof(GetAttribLocation) ); glBindAttribLocation = (BindAttribLocation) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glBindAttribLocation"), typeof(BindAttribLocation) ); glIsShader = (IsShader) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glIsShader"), typeof(IsShader) ); glIsProgram = (IsProgram) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glIsProgram"), typeof(IsProgram) ); glGetShaderInfoLog = (GetShaderInfoLog) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glGetShaderInfoLog"), typeof(GetShaderInfoLog) ); glGetProgramInfoLog = (GetProgramInfoLog) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glGetProgramInfoLog"), typeof(GetProgramInfoLog) ); glFlush = (Flush) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glFlush"), typeof(Flush) ); } catch { throw new NoSuitableGraphicsDeviceException("OpenGL 2.1 support is required!"); } /* ARB_framebuffer_object. We're flexible, but not _that_ flexible. */ try { glGenFramebuffers = (GenFramebuffers) Marshal.GetDelegateForFunctionPointer( TryGetFramebufferEP("glGenFramebuffers"), typeof(GenFramebuffers) ); glDeleteFramebuffers = (DeleteFramebuffers) Marshal.GetDelegateForFunctionPointer( TryGetFramebufferEP("glDeleteFramebuffers"), typeof(DeleteFramebuffers) ); glBindFramebuffer = (G_BindFramebuffer) Marshal.GetDelegateForFunctionPointer( TryGetFramebufferEP("glBindFramebuffer"), typeof(G_BindFramebuffer) ); glFramebufferTexture2D = (FramebufferTexture2D) Marshal.GetDelegateForFunctionPointer( TryGetFramebufferEP("glFramebufferTexture2D"), typeof(FramebufferTexture2D) ); glFramebufferRenderbuffer = (FramebufferRenderbuffer) Marshal.GetDelegateForFunctionPointer( TryGetFramebufferEP("glFramebufferRenderbuffer"), typeof(FramebufferRenderbuffer) ); #if !DISABLE_FAUXBACKBUFFER glBlitFramebuffer = (BlitFramebuffer) Marshal.GetDelegateForFunctionPointer( TryGetFramebufferEP("glBlitFramebuffer"), typeof(BlitFramebuffer) ); #endif glGenRenderbuffers = (GenRenderbuffers) Marshal.GetDelegateForFunctionPointer( TryGetFramebufferEP("glGenRenderbuffers"), typeof(GenRenderbuffers) ); glDeleteRenderbuffers = (DeleteRenderbuffers) Marshal.GetDelegateForFunctionPointer( TryGetFramebufferEP("glDeleteRenderbuffers"), typeof(DeleteRenderbuffers) ); glBindRenderbuffer = (BindRenderbuffer) Marshal.GetDelegateForFunctionPointer( TryGetFramebufferEP("glBindRenderbuffer"), typeof(BindRenderbuffer) ); glRenderbufferStorage = (RenderbufferStorage) Marshal.GetDelegateForFunctionPointer( TryGetFramebufferEP("glRenderbufferStorage"), typeof(RenderbufferStorage) ); } catch { throw new NoSuitableGraphicsDeviceException("OpenGL framebuffer support is required!"); } /* ARB_instanced_arrays/ARB_draw_instanced are almost optional. */ SupportsHardwareInstancing = true; try { glVertexAttribDivisor = (VertexAttribDivisor) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glVertexAttribDivisor"), typeof(VertexAttribDivisor) ); glDrawElementsInstanced = (DrawElementsInstanced) Marshal.GetDelegateForFunctionPointer( SDL.SDL_GL_GetProcAddress("glDrawElementsInstanced"), typeof(DrawElementsInstanced) ); } catch { SupportsHardwareInstancing = false; } #if DEBUG /* ARB_debug_output, for debug contexts */ IntPtr messageCallback = SDL.SDL_GL_GetProcAddress("glDebugMessageCallbackARB"); IntPtr messageControl = SDL.SDL_GL_GetProcAddress("glDebugMessageControlARB"); if (messageCallback == IntPtr.Zero || messageControl == IntPtr.Zero) { System.Console.WriteLine("ARB_debug_output not supported!"); } else { glDebugMessageCallbackARB = (DebugMessageCallback) Marshal.GetDelegateForFunctionPointer( messageCallback, typeof(DebugMessageCallback) ); glDebugMessageControlARB = (DebugMessageControl) Marshal.GetDelegateForFunctionPointer( messageControl, typeof(DebugMessageControl) ); glDebugMessageCallbackARB(DebugCall, IntPtr.Zero); glDebugMessageControlARB( GLenum.GL_DONT_CARE, GLenum.GL_DONT_CARE, GLenum.GL_DONT_CARE, 0, IntPtr.Zero, true ); glDebugMessageControlARB( GLenum.GL_DONT_CARE, GLenum.GL_DEBUG_TYPE_OTHER_ARB, GLenum.GL_DEBUG_SEVERITY_LOW_ARB, 0, IntPtr.Zero, false ); } /* GREMEDY_string_marker, for apitrace */ IntPtr stringMarkerCallback = SDL.SDL_GL_GetProcAddress("glStringMarkerGREMEDY"); if (stringMarkerCallback == IntPtr.Zero) { System.Console.WriteLine("GREMEDY_string_marker not supported!"); } else { glStringMarkerGREMEDY = (StringMarkerGREMEDY) Marshal.GetDelegateForFunctionPointer( stringMarkerCallback, typeof(StringMarkerGREMEDY) ); } #endif }
public CompilerResults Compile(ShaderSource shaderSource, CompilerParameters compilerParameters, HashSet <string> modifiedShaders, HashSet <string> recentlyModifiedShaders) { ShaderMixinSourceTree mixinTree; var shaderMixinGeneratorSource = shaderSource as ShaderMixinGeneratorSource; var mainUsedParameters = new ShaderMixinParameters(); var usedParameters = new List <ShaderMixinParameters>(); string effectName = null; if (shaderMixinGeneratorSource != null) { effectName = shaderMixinGeneratorSource.Name; // getting the effect from the used parameters only makes sense when the source files are the same // TODO: improve this by updating earlyCompilerCache - cache can still be relevant if (modifiedShaders == null || modifiedShaders.Count == 0) { // perform an early test only based on the parameters var foundCompilerResults = GetShaderFromParameters(effectName, compilerParameters); if (foundCompilerResults != null) { var earlyCompilerResults = new CompilerResults(); earlyCompilerResults.Module = string.Format("EffectCompile [{0}]", effectName); earlyCompilerResults.MainBytecode = foundCompilerResults.MainBytecode; earlyCompilerResults.MainUsedParameters = foundCompilerResults.MainUsedParameters; foreach (var foundBytecode in foundCompilerResults.Bytecodes) { earlyCompilerResults.Bytecodes.Add(foundBytecode.Key, foundBytecode.Value); } foreach (var foundUsedParameters in foundCompilerResults.UsedParameters) { earlyCompilerResults.UsedParameters.Add(foundUsedParameters.Key, foundUsedParameters.Value); } return(earlyCompilerResults); } } mixinTree = ShaderMixinManager.Generate(effectName, compilerParameters, out mainUsedParameters, out usedParameters); } else { effectName = "Effect"; var shaderMixinSource = shaderSource as ShaderMixinSource; var shaderClassSource = shaderSource as ShaderClassSource; if (shaderClassSource != null) { shaderMixinSource = new ShaderMixinSource(); shaderMixinSource.Mixins.Add(shaderClassSource); } if (shaderMixinSource != null) { mixinTree = new ShaderMixinSourceTree() { Mixin = shaderMixinSource }; } else { throw new ArgumentException("Unsupported ShaderSource type [{0}]. Supporting only ShaderMixinSource/pdxfx, ShaderClassSource", "shaderSource"); } } // Copy global parameters to used Parameters by default, as it is used by the compiler mainUsedParameters.Set(CompilerParameters.GraphicsPlatformKey, compilerParameters.Platform); mainUsedParameters.Set(CompilerParameters.GraphicsProfileKey, compilerParameters.Profile); mainUsedParameters.Set(CompilerParameters.DebugKey, compilerParameters.Debug); foreach (var parameters in usedParameters) { parameters.Set(CompilerParameters.GraphicsPlatformKey, compilerParameters.Platform); parameters.Set(CompilerParameters.GraphicsProfileKey, compilerParameters.Profile); parameters.Set(CompilerParameters.DebugKey, compilerParameters.Debug); } // Compile the whole mixin tree var compilerResults = new CompilerResults(); compilerResults.Module = string.Format("EffectCompile [{0}]", effectName); var wasCompiled = Compile(string.Empty, effectName, mixinTree, mainUsedParameters, usedParameters, modifiedShaders, recentlyModifiedShaders, compilerResults); if (wasCompiled && shaderMixinGeneratorSource != null) { lock (earlyCompilerCache) { List <CompilerResults> effectCompilerResults; if (!earlyCompilerCache.TryGetValue(effectName, out effectCompilerResults)) { effectCompilerResults = new List <CompilerResults>(); earlyCompilerCache.Add(effectName, effectCompilerResults); } // Register bytecode used parameters so that they are checked when another effect is instanced effectCompilerResults.Add(compilerResults); } } return(compilerResults); }
static void Main(string[] args) { GraphicsDevice.AppName = "Vulkan Test"; GraphicsDevice.EnableValidation = true; GraphicsDevice.RebuildShaders = true; GraphicsDevice.Init(); graph = new FrameGraph(0); var vertS = new SpecializedShader() { Name = "FST_Vert", Shader = ShaderSource.Load(ShaderType.VertexShader, "FullScreenTriangle/vertex.glsl"), SpecializationData = null }; var fragS = new SpecializedShader() { Name = "UVR_Frag", Shader = ShaderSource.Load(ShaderType.FragmentShader, "UVRenderer/fragment.glsl"), SpecializationData = null, }; graph.RegisterShader(vertS); graph.RegisterShader(fragS); for (int i = 0; i < GraphicsDevice.MaxFramesInFlight; i++) { var out_img = GraphicsDevice.DefaultFramebuffer[i].ColorAttachments[0]; graph.RegisterResource(out_img); } var gpass = new GraphicsPass("main_pass") { Shaders = new string[] { vertS.Name, fragS.Name }, ViewportWidth = GraphicsDevice.Width, ViewportHeight = GraphicsDevice.Height, ViewportDynamic = false, DepthWriteEnable = false, CullMode = CullMode.None, RenderLayout = new RenderLayout() { Color = new RenderLayoutEntry[] { new RenderLayoutEntry() { DesiredLayout = ImageLayout.ColorAttachmentOptimal, FirstLoadStage = PipelineStage.ColorAttachOut, Format = GraphicsDevice.DefaultFramebuffer[GraphicsDevice.CurrentFrameID].ColorAttachments[0].Format, LastStoreStage = PipelineStage.ColorAttachOut, LoadOp = AttachmentLoadOp.DontCare, StoreOp = AttachmentStoreOp.Store, }, }, Depth = null, }, DescriptorSetup = new DescriptorSetup() { Descriptors = null, PushConstants = null, }, }; graph.RegisterGraphicsPass(gpass); graph.GatherDescriptors(); GraphicsDevice.Window.Render += Window_Render; GraphicsDevice.Window.Run(60); /* * var fbuf = new Framegraph(0); * fbuf.RegisterAttachment(new AttachmentInfo() * { * Name = "output", * BaseSize = SizeClass.ScreenRelative, * SizeX = 1, * SizeY = 1, * Format = ImageFormat.B8G8R8A8Unorm, * Layers = 1, * UseMipMaps = false, * Usage = ImageUsage.ColorAttachment | ImageUsage.Sampled, * }); * fbuf.RegisterAttachment(new AttachmentInfo() * { * Name = "output_dpth", * BaseSize = SizeClass.ScreenRelative, * SizeX = 1, * SizeY = 1, * Format = ImageFormat.Depth32f, * Layers = 1, * UseMipMaps = false, * Usage = ImageUsage.DepthAttachment | ImageUsage.TransferSrc, * }); * fbuf.RegisterShaderParams(new ShaderParameterSet() * { * Name = "output_shader_params", * Buffers = null, * SampledAttachments = null, * Textures = null, * }); * fbuf.RegisterPass(new GraphicsPass() * { * Name = "main_pass", * CullMode = CullMode.None, * DepthAttachment = new AttachmentUsageInfo() * { * Name = "output_dpth", * Usage = AttachmentUsage.WriteOnly * }, * AttachmentUsage = new AttachmentUsageInfo[]{ * new AttachmentUsageInfo(){ * Name = "output", * Usage = AttachmentUsage.WriteOnly * } * }, * DepthClamp = false, * DepthTest = DepthTest.Always, * EnableBlending = false, * LineWidth = 1, * PassDependencies = null, * RasterizerDiscard = false, * Shaders = new ShaderSource[] { vert, frag }, * Topology = PrimitiveType.Triangle, * DrawCmd = new PlainDrawCmd() * { * BaseInstance = 0, * BaseVertex = 0, * InstanceCount = 1, * VertexCount = 3 * } * }); * fbuf.SetOutputPass("output"); * fbuf.Compile(); * while (!GraphicsDevice.Window.IsExiting) * { * fbuf.Execute(true); * GraphicsDevice.Window.PollEvents(); * }*/ }
/// <summary> /// create the context for each composition by cloning their dependencies /// </summary> /// <param name="shaderSource">the entry ShaderSource (root)</param> /// <param name="dictionary">the ouputed compositions</param> /// <param name="compilationContext">the compilation context</param> /// <param name="cloneContext">The clone context.</param> /// <returns>a list of all the needed mixins</returns> private static List<ModuleMixin> BuildCompositionsDictionary(ShaderSource shaderSource, CompositionDictionary dictionary, ShaderCompilationContext compilationContext, CloneContext cloneContext, LoggerResult log) { if (shaderSource is ShaderMixinSource) { var shaderMixinSource = shaderSource as ShaderMixinSource; var finalModule = compilationContext.GetModuleMixinFromShaderSource(shaderSource); //PerformanceLogger.Start(PerformanceStage.DeepClone); finalModule = finalModule.DeepClone(new CloneContext(cloneContext)); //PerformanceLogger.Pause(PerformanceStage.DeepClone); foreach (var composition in shaderMixinSource.Compositions) { //look for the key var foundVars = finalModule.FindAllVariablesByName(composition.Key).Where(value => value.Variable.Qualifiers.Contains(ParadoxStorageQualifier.Compose)).ToList(); if (foundVars.Count > 1) { log.Error(ParadoxMessageCode.ErrorAmbiguousComposition, new SourceSpan(), composition.Key); } else if (foundVars.Count > 0) { Variable foundVar = foundVars[0].Variable; var moduleMixins = BuildCompositionsDictionary(composition.Value, dictionary, compilationContext, cloneContext, log); if (moduleMixins == null) return null; dictionary.Add(foundVar, moduleMixins); } else { // No matching variable was found // TODO: log a message? } } return new List<ModuleMixin> { finalModule }; } if (shaderSource is ShaderClassSource) { var finalModule = compilationContext.GetModuleMixinFromShaderSource(shaderSource); //PerformanceLogger.Start(PerformanceStage.DeepClone); finalModule = finalModule.DeepClone(new CloneContext(cloneContext)); //PerformanceLogger.Pause(PerformanceStage.DeepClone); return new List<ModuleMixin> { finalModule }; } if (shaderSource is ShaderArraySource) { var shaderArraySource = shaderSource as ShaderArraySource; var compositionArray = new List<ModuleMixin>(); foreach (var shader in shaderArraySource.Values) { var mixin = BuildCompositionsDictionary(shader, dictionary, compilationContext, cloneContext, log); if (mixin == null) return null; compositionArray.AddRange(mixin); } return compositionArray; } return null; }
public SkyBoxPlugin(string name, ShaderSource skyBoxComposition) : base(name) { Texture = null; SkyBoxColor = skyBoxComposition; }
public void AddShading <T>(T shadingModel, ShaderSource shaderSource) where T : class, IMaterialShadingModelFeature { currentLayerContext.ShadingModels.Add(shadingModel, shaderSource); }
/// <summary> /// Get the module mixin based on the ShaderSource /// </summary> /// <param name="shaderSource">the ShaderSource</param> /// <returns>the ModuleMixin</returns> public ModuleMixin GetModuleMixinFromShaderSource(ShaderSource shaderSource) { var found = MixinInfos.FirstOrDefault(x => x.ShaderSource.Equals(shaderSource)); return(found == null ? null : found.Mixin); }
protected override Shader.Platform CreateShader(ShaderSource source) { return(new GL_Shader(this, source)); }
/// <summary> /// Build the ModuleMixinInfo class /// </summary> /// <param name="shaderSource">the ShaderSource to load</param> /// <param name="macros">the macros applied on the source</param> /// <returns>the ModuleMixinInfo</returns> private ModuleMixinInfo BuildMixinInfo(ShaderSource shaderSource, SiliconStudio.Shaders.Parser.ShaderMacro[] macros) { ModuleMixinInfo mixinInfo = null; if (shaderSource is ShaderClassSource) { var shaderClassSource = shaderSource as ShaderClassSource; mixinInfo = new ModuleMixinInfo { ShaderSource = shaderClassSource, Macros = macros }; LoadMixinFromClassSource(mixinInfo); } else if (shaderSource is ShaderMixinSource) { var shaderMixinSource = shaderSource as ShaderMixinSource; var shaderName = "Mix" + lastMixIndex; ++lastMixIndex; var fakeAst = new ShaderClassType(shaderName); foreach (var classSource in shaderMixinSource.Mixins) { Identifier name; if (classSource.GenericArguments != null && classSource.GenericArguments.Length > 0) name = new IdentifierGeneric(classSource.ClassName, classSource.GenericArguments.Select(x => new Identifier(x.ToString())).ToArray()); else name = new Identifier(classSource.ClassName); fakeAst.BaseClasses.Add(new TypeName(name)); } mixinInfo = new ModuleMixinInfo { MixinGenericName = shaderName, Macros = macros, MixinAst = fakeAst, ShaderSource = shaderSource, SourceHash = ObjectId.FromBytes(Encoding.UTF8.GetBytes(shaderName)), Instanciated = true }; } return mixinInfo; }
protected LightShaderGroup(ShaderSource mixin) { ShaderSource = mixin; }
public DefaultEffectMixinProvider(string name) { shaderSource = new ShaderClassSource(name); }
/// <summary> /// Get the ModuleMixinInfo based on the ShaderSource and the macros. Creates the needed shader if necessary /// </summary> /// <param name="shaderSource">the ShaderSource</param> /// <param name="macros">the macros</param> /// <param name="macrosString">the name of the macros</param> /// <returns>ModuleMixinInfo.</returns> private ModuleMixinInfo GetModuleMixinInfo(ShaderSource shaderSource, SiliconStudio.Shaders.Parser.ShaderMacro[] macros, string macrosString = null) { if (macros == null) macros = new SiliconStudio.Shaders.Parser.ShaderMacro[0]; if (macrosString == null) { macrosString = string.Join(",", macros.OrderBy(x => x.Name)); } List<ModuleMixinInfo> context; if (!mapMacrosToMixins.TryGetValue(macrosString, out context)) { context = new List<ModuleMixinInfo>(); mapMacrosToMixins.Add(macrosString, context); } var mixinInfo = context.FirstOrDefault(x => x.AreEqual(shaderSource, macros)); if (mixinInfo == null) { mixinInfo = BuildMixinInfo(shaderSource, macros); if (mixinInfo.Instanciated) { MixinInfos.Add(mixinInfo); mapMacrosToMixins[macrosString].Add(mixinInfo); mixinInfo.MinimalContext.Add(mixinInfo); if (!mixinInfo.Log.HasErrors) { LoadNecessaryShaders(mixinInfo, macros, macrosString); } mixinInfo.MinimalContext = new HashSet<ModuleMixinInfo>(mixinInfo.MinimalContext.Distinct()); } } return mixinInfo; }
public static void InitGL_2_0(OpenGLContext ctx) { glBlendEquationSeparate = ctx.GetProc<BlendEquationSeparate>("glBlendEquationSeparate"); glDrawBuffers = ctx.GetProc<DrawBuffers>("glDrawBuffers"); glStencilOpSeparate = ctx.GetProc<StencilOpSeparate>("glStencilOpSeparate"); glStencilFuncSeparate = ctx.GetProc<StencilFuncSeparate>("glStencilFuncSeparate"); glStencilMaskSeparate = ctx.GetProc<StencilMaskSeparate>("glStencilMaskSeparate"); glAttachShader = ctx.GetProc<AttachShader>("glAttachShader"); glBindAttribLocation = ctx.GetProc<BindAttribLocation>("glBindAttribLocation"); glCompileShader = ctx.GetProc<CompileShader>("glCompileShader"); glCreateProgram = ctx.GetProc<CreateProgram>("glCreateProgram"); glCreateShader = ctx.GetProc<CreateShader>("glCreateShader"); glDeleteProgram = ctx.GetProc<DeleteProgram>("glDeleteProgram"); glDeleteShader = ctx.GetProc<DeleteShader>("glDeleteShader"); glDetachShader = ctx.GetProc<DetachShader>("glDetachShader"); glDisableVertexAttribArray = ctx.GetProc<DisableVertexAttribArray>("glDisableVertexAttribArray"); glEnableVertexAttribArray = ctx.GetProc<EnableVertexAttribArray>("glEnableVertexAttribArray"); glGetActiveAttrib = ctx.GetProc<GetActiveAttrib>("glGetActiveAttrib"); glGetActiveUniform = ctx.GetProc<GetActiveUniform>("glGetActiveUniform"); glGetAttachedShaders = ctx.GetProc<GetAttachedShaders>("glGetAttachedShaders"); glGetAttribLocation = ctx.GetProc<GetAttribLocation>("glGetAttribLocation"); glGetProgramiv = ctx.GetProc<GetProgramiv>("glGetProgramiv"); glGetProgramInfoLog = ctx.GetProc<GetProgramInfoLog>("glGetProgramInfoLog"); glGetShaderiv = ctx.GetProc<GetShaderiv>("glGetShaderiv"); glGetShaderInfoLog = ctx.GetProc<GetShaderInfoLog>("glGetShaderInfoLog"); glGetShaderSource = ctx.GetProc<GetShaderSource>("glGetShaderSource"); glGetUniformLocation = ctx.GetProc<GetUniformLocation>("glGetUniformLocation"); glGetUniformfv = ctx.GetProc<GetUniformfv>("glGetUniformfv"); glGetUniformiv = ctx.GetProc<GetUniformiv>("glGetUniformiv"); glGetVertexAttribdv = ctx.GetProc<GetVertexAttribdv>("glGetVertexAttribdv"); glGetVertexAttribfv = ctx.GetProc<GetVertexAttribfv>("glGetVertexAttribfv"); glGetVertexAttribiv = ctx.GetProc<GetVertexAttribiv>("glGetVertexAttribiv"); glGetVertexAttribPointerv = ctx.GetProc<GetVertexAttribPointerv>("glGetVertexAttribPointerv"); glIsProgram = ctx.GetProc<IsProgram>("glIsProgram"); glIsShader = ctx.GetProc<IsShader>("glIsShader"); glLinkProgram = ctx.GetProc<LinkProgram>("glLinkProgram"); glShaderSource = ctx.GetProc<ShaderSource>("glShaderSource"); glUseProgram = ctx.GetProc<UseProgram>("glUseProgram"); glUniform1f = ctx.GetProc<Uniform1f>("glUniform1f"); glUniform2f = ctx.GetProc<Uniform2f>("glUniform2f"); glUniform3f = ctx.GetProc<Uniform3f>("glUniform3f"); glUniform4f = ctx.GetProc<Uniform4f>("glUniform4f"); glUniform1i = ctx.GetProc<Uniform1i>("glUniform1i"); glUniform2i = ctx.GetProc<Uniform2i>("glUniform2i"); glUniform3i = ctx.GetProc<Uniform3i>("glUniform3i"); glUniform4i = ctx.GetProc<Uniform4i>("glUniform4i"); glUniform1fv = ctx.GetProc<Uniform1fv>("glUniform1fv"); glUniform2fv = ctx.GetProc<Uniform2fv>("glUniform2fv"); glUniform3fv = ctx.GetProc<Uniform3fv>("glUniform3fv"); glUniform4fv = ctx.GetProc<Uniform4fv>("glUniform4fv"); glUniform1iv = ctx.GetProc<Uniform1iv>("glUniform1iv"); glUniform2iv = ctx.GetProc<Uniform2iv>("glUniform2iv"); glUniform3iv = ctx.GetProc<Uniform3iv>("glUniform3iv"); glUniform4iv = ctx.GetProc<Uniform4iv>("glUniform4iv"); glUniformMatrix2fv = ctx.GetProc<UniformMatrix2fv>("glUniformMatrix2fv"); glUniformMatrix3fv = ctx.GetProc<UniformMatrix3fv>("glUniformMatrix3fv"); glUniformMatrix4fv = ctx.GetProc<UniformMatrix4fv>("glUniformMatrix4fv"); glValidateProgram = ctx.GetProc<ValidateProgram>("glValidateProgram"); glVertexAttrib1d = ctx.GetProc<VertexAttrib1d>("glVertexAttrib1d"); glVertexAttrib1dv = ctx.GetProc<VertexAttrib1dv>("glVertexAttrib1dv"); glVertexAttrib1f = ctx.GetProc<VertexAttrib1f>("glVertexAttrib1f"); glVertexAttrib1fv = ctx.GetProc<VertexAttrib1fv>("glVertexAttrib1fv"); glVertexAttrib1s = ctx.GetProc<VertexAttrib1s>("glVertexAttrib1s"); glVertexAttrib1sv = ctx.GetProc<VertexAttrib1sv>("glVertexAttrib1sv"); glVertexAttrib2d = ctx.GetProc<VertexAttrib2d>("glVertexAttrib2d"); glVertexAttrib2dv = ctx.GetProc<VertexAttrib2dv>("glVertexAttrib2dv"); glVertexAttrib2f = ctx.GetProc<VertexAttrib2f>("glVertexAttrib2f"); glVertexAttrib2fv = ctx.GetProc<VertexAttrib2fv>("glVertexAttrib2fv"); glVertexAttrib2s = ctx.GetProc<VertexAttrib2s>("glVertexAttrib2s"); glVertexAttrib2sv = ctx.GetProc<VertexAttrib2sv>("glVertexAttrib2sv"); glVertexAttrib3d = ctx.GetProc<VertexAttrib3d>("glVertexAttrib3d"); glVertexAttrib3dv = ctx.GetProc<VertexAttrib3dv>("glVertexAttrib3dv"); glVertexAttrib3f = ctx.GetProc<VertexAttrib3f>("glVertexAttrib3f"); glVertexAttrib3fv = ctx.GetProc<VertexAttrib3fv>("glVertexAttrib3fv"); glVertexAttrib3s = ctx.GetProc<VertexAttrib3s>("glVertexAttrib3s"); glVertexAttrib3sv = ctx.GetProc<VertexAttrib3sv>("glVertexAttrib3sv"); glVertexAttrib4Nbv = ctx.GetProc<VertexAttrib4Nbv>("glVertexAttrib4Nbv"); glVertexAttrib4Niv = ctx.GetProc<VertexAttrib4Niv>("glVertexAttrib4Niv"); glVertexAttrib4Nsv = ctx.GetProc<VertexAttrib4Nsv>("glVertexAttrib4Nsv"); glVertexAttrib4Nub = ctx.GetProc<VertexAttrib4Nub>("glVertexAttrib4Nub"); glVertexAttrib4Nubv = ctx.GetProc<VertexAttrib4Nubv>("glVertexAttrib4Nubv"); glVertexAttrib4Nuiv = ctx.GetProc<VertexAttrib4Nuiv>("glVertexAttrib4Nuiv"); glVertexAttrib4Nusv = ctx.GetProc<VertexAttrib4Nusv>("glVertexAttrib4Nusv"); glVertexAttrib4bv = ctx.GetProc<VertexAttrib4bv>("glVertexAttrib4bv"); glVertexAttrib4d = ctx.GetProc<VertexAttrib4d>("glVertexAttrib4d"); glVertexAttrib4dv = ctx.GetProc<VertexAttrib4dv>("glVertexAttrib4dv"); glVertexAttrib4f = ctx.GetProc<VertexAttrib4f>("glVertexAttrib4f"); glVertexAttrib4fv = ctx.GetProc<VertexAttrib4fv>("glVertexAttrib4fv"); glVertexAttrib4iv = ctx.GetProc<VertexAttrib4iv>("glVertexAttrib4iv"); glVertexAttrib4s = ctx.GetProc<VertexAttrib4s>("glVertexAttrib4s"); glVertexAttrib4sv = ctx.GetProc<VertexAttrib4sv>("glVertexAttrib4sv"); glVertexAttrib4ubv = ctx.GetProc<VertexAttrib4ubv>("glVertexAttrib4ubv"); glVertexAttrib4uiv = ctx.GetProc<VertexAttrib4uiv>("glVertexAttrib4uiv"); glVertexAttrib4usv = ctx.GetProc<VertexAttrib4usv>("glVertexAttrib4usv"); glVertexAttribPointer = ctx.GetProc<VertexAttribPointer>("glVertexAttribPointer"); }
static void Main() { Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); var form = new Form(); form.ClientSize = new Size(800, 600); using (var device = LightDevice.Create(form)) { var target = new RenderTargetList(device.GetDefaultTarget()); target.Apply(); Pipeline pipeline = device.CompilePipeline(InputTopology.Triangle, ShaderSource.FromResource("Shader.fx", ShaderType.Vertex | ShaderType.Pixel)); pipeline.Apply(); var inputGroup = pipeline.CreateVertexDataProcessors(new[] { typeof(VertexP), typeof(VertexC), }); var input1 = inputGroup.GetVertexDataProcessor <VertexP>(); var input2 = inputGroup.GetVertexDataProcessor <VertexC>(); var buffer1 = input1.CreateDynamicBuffer(3); var vertexPosData = new[] { new VertexP { Position = new Vector4(0, 0, 0.5f, 1) }, new VertexP { Position = new Vector4(0, 0, 0.5f, 1) }, new VertexP { Position = new Vector4(0, 0, 0.5f, 1) }, }; var buffer2 = input2.CreateImmutableBuffer(new[] { new VertexC { Color = Color.Green.WithAlpha(1) }, new VertexC { Color = Color.Red.WithAlpha(1) }, new VertexC { Color = Color.Blue.WithAlpha(1) }, }); var bufferGroup = new[] { buffer1, buffer2 }; var indexBuffer = pipeline.CreateImmutableIndexBuffer(new uint[] { 0, 1, 2 }); var constantBuffer = pipeline.CreateConstantBuffer <ConstantBuffer>(); pipeline.SetConstant(ShaderType.Vertex, 0, constantBuffer); pipeline.SetConstant(ShaderType.Pixel, 0, constantBuffer); constantBuffer.Value.GlobalAlpha = new Vector4(1, 1, 1, 1); form.Show(); var i = 0; var rand = new Random(); var clock = Stopwatch.StartNew(); device.RunMultithreadLoop(delegate() { var angle = -clock.Elapsed.TotalSeconds * Math.PI / 3; var distance = Math.PI * 2 / 3; SetCoordinate(device, ref vertexPosData[0].Position, angle); SetCoordinate(device, ref vertexPosData[1].Position, angle - distance); SetCoordinate(device, ref vertexPosData[2].Position, angle + distance); buffer1.Update(vertexPosData); constantBuffer.Value.Time = ((float)clock.Elapsed.TotalSeconds % 2) / 2; if (++i == 60) { i = 0; constantBuffer.Value.GlobalAlpha.X = (float)rand.NextDouble() * 0.5f + 0.5f; constantBuffer.Value.GlobalAlpha.Y = (float)rand.NextDouble() * 0.5f + 0.5f; constantBuffer.Value.GlobalAlpha.Z = (float)rand.NextDouble() * 0.5f + 0.5f; } constantBuffer.Update(); target.ClearAll(); indexBuffer.DrawAll(inputGroup, bufferGroup); device.Present(true); }); } }
static void Main(string[] args) { Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); var form = new Form { ClientSize = new Size(800, 600), Text = "Tutorial 4: Buffers, Shaders, and HLSL", }; using (var device = LightDevice.Create(form)) { //--------------------- // Target & Pipeline //--------------------- var target = new RenderTarget(device.GetDefaultTarget()); target.Apply(); Pipeline pipeline = device.CompilePipeline(InputTopology.Triangle, ShaderSource.FromResource("Color_vs.fx", ShaderType.Vertex), ShaderSource.FromResource("Color_ps.fx", ShaderType.Pixel)); pipeline.Apply(); //--------------------- // Vertex buffer //--------------------- var vertexDataProcessor = pipeline.CreateVertexDataProcessor <Vertex>(); var vertexBuffer = vertexDataProcessor.CreateImmutableBuffer(new[] { new Vertex { Position = new Vector4(-1, -1, 0, 1), Color = new Vector4(0, 1, 0, 1) }, new Vertex { Position = new Vector4(0, 1, 0, 1), Color = new Vector4(0, 1, 0, 1) }, new Vertex { Position = new Vector4(1, -1, 0, 1), Color = new Vector4(0, 1, 0, 1) }, }); //--------------------- // Index buffer //--------------------- var indexBuffer = pipeline.CreateImmutableIndexBuffer(new uint[] { 0, 1, 2 }); //--------------------- // Constant buffer (VS) //--------------------- var constantBuffer = pipeline.CreateConstantBuffer <Constants>(); pipeline.SetConstant(ShaderType.Vertex, 0, constantBuffer); void SetupProjMatrix() { constantBuffer.Value.Projection = device.CreatePerspectiveFieldOfView((float)Math.PI / 4).Transpose(); } device.ResolutionChanged += (sender, e) => SetupProjMatrix(); constantBuffer.Value.World = Matrix4x4.Identity.Transpose(); SetupProjMatrix(); //--------------------- // Camera //--------------------- var camera = new Camera(); //--------------------- // Start main loop //--------------------- form.Show(); device.RunMultithreadLoop(delegate() { // Update matrix constantBuffer.Value.View = camera.GetViewMatrix().Transpose(); constantBuffer.Update(); // Clear and draw target.ClearAll(); indexBuffer.DrawAll(vertexBuffer); device.Present(true); }); } }
/// <inheritdoc/> public override String Process(ContentManager manager, IContentProcessorMetadata metadata, String input) { return(ShaderSource.ProcessRawSource(manager, metadata, input)?.Source ?? String.Empty); }
public void SetStream(MaterialShaderStage stage, string stream, MaterialStreamType streamType, ShaderSource classSource) { if (stream == null) { throw new ArgumentNullException(nameof(stream)); } // Blend stream is not part of the stream used if (stream != MaterialBlendLayer.BlendStream) { GetContextPerStage(stage).Streams.Add(stream); } string channel; switch (streamType) { case MaterialStreamType.Float: channel = "r"; break; case MaterialStreamType.Float2: channel = "rg"; break; case MaterialStreamType.Float3: channel = "rgb"; break; case MaterialStreamType.Float4: channel = "rgba"; break; default: throw new NotSupportedException("StreamType [{0}] is not supported".ToFormat(streamType)); } var mixin = new ShaderMixinSource(); mixin.Mixins.Add(new ShaderClassSource("MaterialSurfaceSetStreamFromComputeColor", stream, channel)); mixin.AddComposition("computeColorSource", classSource); GetContextPerStage(stage).ShaderSources.Add(mixin); }
static void Main(string[] args) { Engine.AppName = "Test"; Engine.EnableValidation = true; Engine.RebuildShaders = true; Engine.Initialize(); var graph = new FrameGraph(0); Engine.RenderGraph = graph; int trace_side = 1024; var objLoaderFactory = new ObjLoaderFactory(); var objLoader = objLoaderFactory.Create(); using (var fs = File.OpenRead("sponza.obj")) { var obj_loaded = objLoader.Load(fs); ulong idxCount = 0; for (int i = 0; i < obj_loaded.Groups.Count; i++) { idxCount += (ulong)obj_loaded.Groups[i].Faces.Count * 3; } vertexBuffer = new StreamableBuffer("vbo", (ulong)obj_loaded.Vertices.Count * 3 * sizeof(float), BufferUsage.Storage); indexBuffer = new StreamableBuffer("ibo", idxCount * sizeof(uint), BufferUsage.Index | BufferUsage.Storage); rayIntersections = new RayIntersections("rayInter", (uint)trace_side * (uint)trace_side, 0); geometry = new RayGeometry("rayGeom", (uint)obj_loaded.Vertices.Count); unsafe { float *fp = (float *)vertexBuffer.BeginBufferUpdate(); for (int i = 0; i < obj_loaded.Vertices.Count; i++) { fp[0] = obj_loaded.Vertices[i].X; fp[1] = obj_loaded.Vertices[i].Y; fp[2] = obj_loaded.Vertices[i].Z; fp += 3; } vertexBuffer.EndBufferUpdate(); uint *ui = (uint *)indexBuffer.BeginBufferUpdate(); for (int i = 0; i < obj_loaded.Groups.Count; i++) { for (int j = 0; j < obj_loaded.Groups[i].Faces.Count; j++) { ui[0] = (uint)(obj_loaded.Groups[i].Faces[j][0].VertexIndex - 1); ui[1] = (uint)(obj_loaded.Groups[i].Faces[j][1].VertexIndex - 1); ui[2] = (uint)(obj_loaded.Groups[i].Faces[j][2].VertexIndex - 1); ui += 3; } } indexBuffer.EndBufferUpdate(); float *rp = (float *)rayIntersections.RayBuffer.BeginBufferUpdate(); for (uint x = 0; x < trace_side; x++) { for (uint y = 0; y < trace_side; y++) { //uint i = 0; //for(int j = 0; j < 15; j++) //{ // i |= ((x & (1u << j)) << j) | ((y & (1u << j)) << (j + 1)); //} //i *= 8; uint i = ((uint)trace_side * y + x) * 8; rp[i + 0] = 0.0f; rp[i + 1] = 15.0f; rp[i + 2] = 0.0f; rp[i + 4] = -1.0f; rp[i + 5] = -1.0f + (2.0f / trace_side) * y; rp[i + 6] = -1.0f + (2.0f / trace_side) * x; rp[i + 3] = 0.001f; rp[i + 7] = 100000.0f; } } rayIntersections.RayBuffer.EndBufferUpdate(); geometry.SetupBuild(0, (uint)(idxCount / 3), vertexBuffer.LocalBuffer, 0, indexBuffer.LocalBuffer, 0, false); } } vertS = new SpecializedShader() { Name = "FST_Vert", Shader = ShaderSource.Load(ShaderType.VertexShader, "FullScreenTriangle/vertex.glsl"), SpecializationData = null }; fragS = new SpecializedShader() { Name = "UVR_Frag", Shader = ShaderSource.Load(ShaderType.FragmentShader, "FullScreenTriangle/clear_frag.glsl"), SpecializationData = null, }; depthImages = new Image[GraphicsDevice.MaxFramesInFlight]; depthImageViews = new ImageView[GraphicsDevice.MaxFramesInFlight]; for (int i = 0; i < GraphicsDevice.MaxFramesInFlight; i++) { depthImages[i] = new Image($"depthImage_{i}") { Cubemappable = false, Width = GraphicsDevice.Width, Height = GraphicsDevice.Height, Depth = 1, Dimensions = 2, InitialLayout = ImageLayout.Undefined, Layers = 1, Levels = 1, MemoryUsage = MemoryUsage.GpuOnly, Usage = ImageUsage.DepthAttachment | ImageUsage.Sampled, Format = ImageFormat.Depth32f, }; depthImages[i].Build(0); depthImageViews[i] = new ImageView($"depthImageView_{i}") { BaseLayer = 0, BaseLevel = 0, Format = ImageFormat.Depth32f, LayerCount = 1, LevelCount = 1, ViewType = ImageViewType.View2D, }; depthImageViews[i].Build(depthImages[i]); } Engine.OnRebuildGraph += Engine_OnRebuildGraph; Engine.OnRender += Engine_OnRender; Engine.OnUpdate += Engine_OnUpdate; Engine.Start(0); }
public LightVoxelShaderGroup(ShaderSource mixin) : base(mixin) { HasEffectPermutations = true; traceAttribute = null; }
internal GL_Shader(GL_Graphics graphics, ShaderSource source) { this.graphics = graphics; if (graphics.MainThreadId != Thread.CurrentThread.ManagedThreadId) { lock (graphics.BackgroundContext) { graphics.System.SetCurrentGLContext(graphics.BackgroundContext); Create(); GL.Flush(); graphics.System.SetCurrentGLContext(null); } } else { Create(); } void Create() { ID = GL.CreateProgram(); Span <uint> shaders = stackalloc uint[2]; // vertex shader if (source.Vertex != null) { uint shaderId = GL.CreateShader(GLEnum.VERTEX_SHADER); shaders[0] = shaderId; string glsl = Encoding.UTF8.GetString(source.Vertex); GL.ShaderSource(shaderId, 1, new[] { glsl }, new int[] { glsl.Length }); GL.CompileShader(shaderId); string?errorMessage = GL.GetShaderInfoLog(shaderId); if (!string.IsNullOrEmpty(errorMessage)) { throw new Exception(errorMessage); } GL.AttachShader(ID, shaderId); } // fragment shader if (source.Fragment != null) { uint shaderId = GL.CreateShader(GLEnum.FRAGMENT_SHADER); shaders[1] = shaderId; string glsl = Encoding.UTF8.GetString(source.Fragment); GL.ShaderSource(shaderId, 1, new[] { glsl }, new int[] { glsl.Length }); GL.CompileShader(shaderId); string?errorMessage = GL.GetShaderInfoLog(shaderId); if (!string.IsNullOrEmpty(errorMessage)) { throw new Exception(errorMessage); } GL.AttachShader(ID, shaderId); } GL.LinkProgram(ID); string?programError = GL.GetProgramInfoLog(ID); if (!string.IsNullOrEmpty(programError)) { throw new Exception(programError); } // get attributes GL.GetProgramiv(ID, GLEnum.ACTIVE_ATTRIBUTES, out int attributeCount); for (int i = 0; i < attributeCount; i++) { GL.GetActiveAttrib(ID, (uint)i, out _, out _, out string name); int location = GL.GetAttribLocation(ID, name); if (location >= 0) { Attributes.Add(name, new ShaderAttribute(name, (uint)location)); } } // get uniforms GL.GetProgramiv(ID, GLEnum.ACTIVE_UNIFORMS, out int uniformCount); for (int i = 0; i < uniformCount; i++) { GL.GetActiveUniform(ID, (uint)i, out int size, out GLEnum type, out string name); int location = GL.GetUniformLocation(ID, name); if (location >= 0) { if (size > 1 && name.EndsWith("[0]")) { name = name.Substring(0, name.Length - 3); } Uniforms.Add(name, new GL_Uniform(this, name, size, location, type)); } } // dispose shaders for (int i = 0; i < shaders.Length; i++) { if (shaders[i] != 0) { GL.DetachShader(ID, shaders[i]); GL.DeleteShader(shaders[i]); } } } }
public void UseStreamWithCustomBlend(MaterialShaderStage stage, string stream, ShaderSource blendStream) { if (stream == null) { throw new ArgumentNullException(nameof(stream)); } UseStream(stage, stream); registeredStreamBlend[stream] = blendStream; }
static void Main() { const float BlockSize = 0.02f; Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); var form = new Form(); form.ClientSize = new Size(800, 600); var func = MakeFunction(1 / BlockSize); var meshGenerator = new DCSolver(func, (int)(4 / BlockSize)); var rawMesh = meshGenerator.Solve(); rawMesh = new MeshSimplifier(rawMesh, ClusterSizeHelper.GetSampleAverage(rawMesh, 3)).Run(); var m = NormalMesh.MakeNormal(rawMesh); using (var device = LightDevice.Create(form)) { var target = new RenderTargetList(device.GetDefaultTarget(Color.AliceBlue.WithAlpha(1)), device.CreateDepthStencilTarget()); target.Apply(); Pipeline pipeline = device.CompilePipeline(InputTopology.Triangle, ShaderSource.FromResource("Viewer.Shader.fx", ShaderType.Vertex | ShaderType.Pixel)); pipeline.Apply(); var vertexConstant = pipeline.CreateConstantBuffer <Matrix4x4>(); pipeline.SetConstant(ShaderType.Vertex, 0, vertexConstant); var input = pipeline.CreateVertexDataProcessor <Vertex>(); var vb = input.CreateImmutableBuffer(m.Vertices.Select(vv => new Vertex { Position = new Vector4(m.Positions[vv.Position] * BlockSize, 1), Normal = new Vector4(vv.Normal, 0), }).ToArray()); var ib = pipeline.CreateImmutableIndexBuffer(m.Triangles.SelectMany(tt => new[] { tt.Va, tt.Vb, tt.Vc }).ToArray()); var camera = new Camera(new Vector3(10, 0, 0)); camera.SetForm(form); var proj = device.CreatePerspectiveFieldOfView((float)Math.PI / 4).Transpose(); vertexConstant.Value = proj * camera.GetViewMatrix(); var pt = new Vector4(0, 0, 0, 0); var r = Vector4.Transform(pt, vertexConstant.Value); form.Show(); device.RunMultithreadLoop(delegate() { target.ClearAll(); camera.Step(); var view = camera.GetViewMatrix(); vertexConstant.Value = proj * view; vertexConstant.Update(); ib.DrawAll(vb); device.Present(true); }); } }
public void SetStream(MaterialShaderStage stage, string stream, MaterialStreamType streamType, ShaderSource shaderSource) { currentLayerContext.SetStream(stage, stream, streamType, shaderSource); }
public bool AreEqual(ShaderSource shaderSource, SiliconStudio.Shaders.Parser.ShaderMacro[] macros) { return ShaderSource.Equals(shaderSource) && macros.All(macro => Macros.Any(x => x.Name == macro.Name && x.Definition == macro.Definition)) && Macros.All(macro => macros.Any(x => x.Name == macro.Name && x.Definition == macro.Definition)); }
/// <summary> /// create the context for each composition by cloning their dependencies /// </summary> /// <param name="shaderSource">the entry ShaderSource (root)</param> /// <param name="dictionary">the ouputed compositions</param> /// <param name="compilationContext">the compilation context</param> /// <param name="cloneContext">The clone context.</param> /// <returns>a list of all the needed mixins</returns> private List <ModuleMixin> BuildCompositionsDictionary(ShaderSource shaderSource, Dictionary <Variable, List <ModuleMixin> > dictionary, ShaderCompilationContext compilationContext, CloneContext cloneContext) { if (shaderSource is ShaderMixinSource) { var shaderMixinSource = shaderSource as ShaderMixinSource; var finalModule = compilationContext.GetModuleMixinFromShaderSource(shaderSource); //PerformanceLogger.Start(PerformanceStage.DeepClone); finalModule = finalModule.DeepClone(new CloneContext(cloneContext)); //PerformanceLogger.Pause(PerformanceStage.DeepClone); foreach (var composition in shaderMixinSource.Compositions) { //look for the key var foundVars = finalModule.FindAllVariablesByName(composition.Key).Where(value => value.Variable.Qualifiers.Contains(ParadoxStorageQualifier.Compose)).ToList(); if (foundVars.Count > 0) { Variable foundVar = foundVars[0].Variable; var moduleMixins = BuildCompositionsDictionary(composition.Value, dictionary, compilationContext, cloneContext); if (moduleMixins == null) { return(null); } dictionary.Add(foundVar, moduleMixins); } else { // TODO: log an error? } } return(new List <ModuleMixin> { finalModule }); } if (shaderSource is ShaderClassSource) { var finalModule = compilationContext.GetModuleMixinFromShaderSource(shaderSource); //PerformanceLogger.Start(PerformanceStage.DeepClone); finalModule = finalModule.DeepClone(new CloneContext(cloneContext)); //PerformanceLogger.Pause(PerformanceStage.DeepClone); return(new List <ModuleMixin> { finalModule }); } if (shaderSource is ShaderArraySource) { var shaderArraySource = shaderSource as ShaderArraySource; var compositionArray = new List <ModuleMixin>(); foreach (var shader in shaderArraySource.Values) { var mixin = BuildCompositionsDictionary(shader, dictionary, compilationContext, cloneContext); if (mixin == null) { return(null); } compositionArray.AddRange(mixin); } return(compositionArray); } return(null); }