List <ShaderAsset> loadShaders() { var shaders = new List <ShaderAsset>(); if (!Directory.Exists(metadataPath + "Shaders")) { Directory.CreateDirectory(metadataPath + "Shaders"); } foreach (var filename in Directory.EnumerateFiles(metadataPath + "Shaders")) { var metadata = File.ReadAllLines(filename); var shader = new ShaderAsset(); shader.Name = System.IO.Path.GetFileNameWithoutExtension(filename); shader.Description = metadata[0].Split('=')[1].Trim(); shader.Combination = (ShaderCombination)Enum.Parse(typeof(ShaderCombination), metadata[1].Split('=')[1].Trim()); shader.LastUpdated = parseLastUpdatedDate(metadata[2].Split('=')[1].Trim(), "shader", shader.Name); shader.SourceFilename = metadata[3].Split('=')[1].Trim(); shader.ImportedFilename = metadata[4].Split('=')[1].Trim(); shader.ImporterVersion = int.Parse(metadata[5].Split('=')[1].Trim()); shaders.Add(shader); } return(shaders); }
public ShaderAssetControl(ShaderAsset asset) { InitializeComponent(); Handler = new ShaderAssetControlHandler(asset, this); Data.DataContext = asset; }
private IMaterialAsset TransformMaterial(Material material, string id, ReaderContext context) { var materialAsset = new MaterialAsset(id); materialAsset.AlphaCutoff = material.AlphaCutoff; materialAsset.Alpha = GetAlphaMode(material.Alpha); materialAsset.DoubleSided = material.DoubleSided; materialAsset.Unlit = material.Unlit; var shaderParameters = material.Channels.Select(_ => TransformShaderParameter(_, context)).SelectMany(_ => _) .ToDictionary(_ => _.Key, _ => _); var metallicRoughness = 0; var specularGlossiness = 0; foreach (var shaderParameter in shaderParameters) { switch (shaderParameter.Key) { case ShaderParameterKey.BaseColorFactor: case ShaderParameterKey.BaseColorTexture: case ShaderParameterKey.MetallicFactor: case ShaderParameterKey.MetallicRoughnessTexture: ++metallicRoughness; break; case ShaderParameterKey.DiffuseFactor: case ShaderParameterKey.DiffuseTexture: case ShaderParameterKey.SpecularFactor: case ShaderParameterKey.GlossinessFactor: case ShaderParameterKey.SpecularGlossinessTexture: ++specularGlossiness; break; } } if (metallicRoughness > 0 && specularGlossiness == 0) { var shader = new MetallicRoughnessShader(); materialAsset.Shader = shader; } else if (metallicRoughness == 0 && specularGlossiness >= 0) { var shader = new SpecularGlossinessShader(); materialAsset.Shader = shader; } else { var shader = new ShaderAsset(); materialAsset.Shader = shader; } foreach (var shaderParameter in shaderParameters) { materialAsset.Shader.Set(shaderParameter.Value); } return(materialAsset); }
public VanillaInputLayout(ShaderAsset shader) { InputLayout = new InputLayout(shader.Device, shader.Signature, new[] { new InputElement("POSITION", 0, Format.R32G32B32A32_Float, 0, 0), new InputElement("NORMAL", 0, Format.R32G32B32A32_Float, 16, 0), new InputElement("COLOR", 0, Format.R32G32B32A32_Float, 32, 0), new InputElement("TEXCOORD", 0, Format.R32G32B32A32_Float, 48, 0), }); }
//FOR TESTING public bool CreateShaderGraphAsset(string name, SharpDX.D3DCompiler.ShaderBytecode bytecode) { BaseAsset asset = new ShaderAsset() { Name = name, ShaderType = ShaderTypeEnum.Pixel, Bytecode = bytecode, }; return(FSWorker.CreateAssetFile(asset, true)); }
static internal void createShaderMetadata(ShaderAsset shader) { var metadata = new StringBuilder(); metadata.AppendLine("Description= " + shader.Description) .AppendLine("Combination= " + shader.Combination.ToString()) .AppendLine("LastUpdated= " + shader.LastUpdated.ToString("o")) .AppendLine("SourceFilename= " + shader.SourceFilename) .AppendLine("ImportedFilename= " + shader.ImportedFilename) .AppendLine("ImporterVersion= " + shader.ImporterVersion); File.WriteAllText(MetadataPath + "Shaders/" + shader.Name + ".meta", metadata.ToString()); }
public override Effect Init(EffectDescription description) { base.Init(description); var mode = _demo.SetupModel.Mode; _greetingsRenderTarget = _disposer.Add(new RenderTarget( device: _demo.Device, width: mode.Width, // TODO(mstrandh): Honor setupmodel? height: mode.Height, // TODO(mstrandh): Honor setupmodel? sampleCount: 1, // TODO(mstrandh): Honor setupmodel? sampleQuality: 0, // TODO(mstrandh): Honor setupmodel? format: Format.R8G8B8A8_UNorm // TODO(mstrandh): Honor setupmodel? )); CreateCylinderBuffers(); var texture = _textures[0]; _textureHeight = texture.Texture.Description.Height; _tubeVertexShader = _demo.ShaderManager["greetingsTube.vs.cso"]; _tubePixelShader = _demo.ShaderManager["greetingsTube.ps.cso"]; _tubeInputLayout = _disposer.Add(new InputLayout(_demo.Device, _tubeVertexShader.Signature, new[] { new InputElement("POSITION", 0, Format.R32G32B32_Float, 0, 0), new InputElement("TEXCOORD", 0, Format.R32G32_Float, 12, 0), })); _greetingsTexture = _resourceViews[0]; _renderedCylinderTexture = _greetingsRenderTarget.ShaderResourceView; // Create the depth buffer var depthBuffer = _disposer.Add(new Texture2D(_demo.Device, new Texture2DDescription { Format = Format.D32_Float_S8X24_UInt, ArraySize = 1, MipLevels = 1, Width = mode.Width, Height = mode.Height, SampleDescription = new SampleDescription { Count = 1, Quality = 0 }, Usage = ResourceUsage.Default, BindFlags = BindFlags.DepthStencil, CpuAccessFlags = CpuAccessFlags.None, OptionFlags = ResourceOptionFlags.None })); // Create the depth buffer view _greetingsDepthView = _disposer.Add(new DepthStencilView(_demo.Device, depthBuffer)); return this; }
public VanillaEffect Init() { // vertex stuff VertexShader = _demo.ShaderManager["vanillaPlane.vs.cso"]; InputLayout = _disposer.Add(new VanillaInputLayout(VertexShader)); PrimitiveTopology = PrimitiveTopology.TriangleList; // pixel stuff // todo: perhaps add pixelshader PixelShader = null; // return this; }
public void Load() { // Load assets _ubuntuFontAsset = Engine.AssetLoader.Get <FontAsset>(RESOURCE_NAME_FONT_UBUNTU).GetAtlas(12); _tileTexture = Engine.AssetLoader.Get <TextureAsset>(RESOURCE_NAME_TEXTURE_TILE_OUTLINED_CARDINAL); _shader = Engine.AssetLoader.Get <ShaderAsset>(RESOURCE_NAME_SHADER); // tile count is vertexCount-1, because end vertices are included in only 1 tile (per axis). tiles = new Quadrilateral[MAP_WIDTH - 1, MAP_HEIGHT - 1]; // Generate a random-ish height map. for (var x = 0; x < MAP_WIDTH; x++) { for (var y = 0; y < MAP_HEIGHT; y++) { // Assign in height map @ appropriate position, storing for later use _heightMap[x, y] = _random.Next((int)TileSize.Z); } } for (var y = 0; y < MAP_HEIGHT - 1; y++) { for (var x = 0; x < MAP_WIDTH - 1; x++) { // Assign in height map @ appropriate position, storing for later use var quad = new Quadrilateral( Vector3.Transform(new Vector3(x * TileSize.X, y * TileSize.Y, _heightMap[x, y]), _rotationMatrix), Vector3.Transform(new Vector3((x + 1) * TileSize.X, y * TileSize.Y, _heightMap[x + 1, y]), _rotationMatrix), Vector3.Transform(new Vector3((x + 1) * TileSize.X, (y + 1) * TileSize.Y, _heightMap[x + 1, y + 1]), _rotationMatrix), Vector3.Transform(new Vector3(x * TileSize.X, (y + 1) * TileSize.Y, _heightMap[x, y + 1]), _rotationMatrix) ); tiles[x, y] = quad; } } Rectangle boundsOfMap = Rectangle.BoundsFromPolygonPoints(new[] { tiles[0, 0].Vertex0.ToVec2(), tiles[MAP_WIDTH - 2, 0].Vertex1.ToVec2(), tiles[MAP_WIDTH - 2, MAP_HEIGHT - 2].Vertex2.ToVec2(), tiles[0, MAP_HEIGHT - 2].Vertex3.ToVec2(), }); quadTree = new QuadTree <Quadrilateral>(boundsOfMap, 100); foreach (var tile in tiles) { quadTree.Add(tile); } }
private void SetupDefaultShader(Material material, ShaderAsset shader, WriterContext context) { if (TrySetupTexture(material, "Normal", shader.NormalTexture, context)) { material.WithChannelParameter("Normal", new Vector4(shader.NormalTextureScale, 0, 0, 0)); } if (TrySetupTexture(material, "Occlusion", shader.OcclusionTexture, context)) { material.WithChannelParameter("Occlusion", new Vector4(shader.OcclusionTextureStrength, 0, 0, 0)); } TrySetupTexture(material, "Emissive", shader.EmissiveTexture, context); material.WithChannelParameter("Emissive", new Vector4(shader.EmissiveFactor, 0)); }
/// <summary> /// Unload previously loaded shader /// </summary> /// <param name="asset">Shader asset</param> public void ShaderUnload(ShaderAsset asset) { if (asset == null) { return; } // Abort any existing async load for this asset AbortAsyncShaderLoad(asset); asset.InternalSetErrorStatus(RB.AssetStatus.Invalid, RB.Result.Undefined); if (asset.shader != null) { asset.shader = null; } }
public void Initialize(ShaderAsset asset) { ShaderName.Text = asset.AssetName; bool isPathValid = asset.EditorPath.IsPathValid(); string basePath = isPathValid ? Path.GetFileName(asset.EditorPath) : asset.EditorPath; VertexFileName.Text = isPathValid ? basePath.Replace(".glsl", "_vertex.glsl") : asset.EditorPath; FragmentFileName.Text = isPathValid ? basePath.Replace(".glsl", "_fragment.glsl") : asset.EditorPath; if (isPathValid) { PreviewVertexTextBox.Text = File.ReadAllText(asset.EditorPath.Replace(".glsl", "_vertex.glsl")); PreviewFragmentTextBox.Text = File.ReadAllText(asset.EditorPath.Replace(".glsl", "_fragment.glsl")); } }
static public void LoadShader(string assetName) { ShaderAsset SA = AssetsManagerInstance.GetManager().LoadAsset <ShaderAsset>(assetName); Debug.Log("AssetManager", SA.ShaderType.ToString() + " Shader " + assetName + " loaded. "); ShaderPlusSignature pack = new ShaderPlusSignature(); ShaderBytecode sb = new ShaderBytecode(SA.Bytecode); switch (SA.ShaderType) { case ShaderTypeEnum.Vertex: pack.shader = new VertexShader(RenderBackend.Device, sb); break; case ShaderTypeEnum.Pixel: pack.shader = new PixelShader(RenderBackend.Device, sb); break; case ShaderTypeEnum.Geometry: pack.shader = new GeometryShader(RenderBackend.Device, sb); break; case ShaderTypeEnum.Compute: pack.shader = new ComputeShader(RenderBackend.Device, sb); break; case ShaderTypeEnum.Hull: pack.shader = new HullShader(RenderBackend.Device, sb); break; case ShaderTypeEnum.Domain: pack.shader = new DomainShader(RenderBackend.Device, sb); break; default: break; } ; SA = null; pack.shader.DebugName = assetName; pack.signature = ShaderSignature.GetInputSignature(sb); Shaders.Add(assetName, pack); }
private void AbortAsyncShaderLoad(ShaderAsset asset) { /* Check if any of the existing pending async assets are loading for the same slot, if so we abandon them */ for (int i = mASyncShaders.Count - 1; i >= 0; i--) { if (mASyncShaders[i].shaderAsset == asset) { // If it was already loaded then be sure to release resources if (mASyncShaders[i].shaderAsset.status == RB.AssetStatus.Ready) { mASyncShaders[i].shaderAsset.shader = null; } mASyncShaders.RemoveAt(i); // There should never be more than one break; } } }
public virtual Effect Init(EffectDescription description) { // vertex stuff VertexShader = _demo.ShaderManager[description.VertexShaderName ?? "vanillaPlane.vs.cso"]; InputLayout = _disposer.Add(new VanillaInputLayout(VertexShader)); PrimitiveTopology = PrimitiveTopology.TriangleList; // pixel stuff var addressMode = GetTextureAddressMode(); PixelShader = _demo.ShaderManager[description.PixelShaderName]; _textures = (description.TextureNames ?? new string[0]) .Select(textureName => string.IsNullOrEmpty(textureName) ? null : _demo.TextureManager[textureName]) .ToArray(); _resourceViews = _textures .Select(texture => (texture == null) ? null : _disposer.Add(new ShaderResourceView(_demo.Device, texture.Texture))) .ToArray(); _samplers = _textures .Select(texture => (texture == null) ? null : _disposer.Add(new SamplerState(_demo.Device, new SamplerStateDescription() { Filter = Filter.Anisotropic, AddressU = addressMode, AddressV = addressMode, AddressW = addressMode, BorderColor = Color.Black, ComparisonFunction = Comparison.Never, MaximumAnisotropy = 1, // 16 MipLodBias = 0, MinimumLod = 0, MaximumLod = 1, // 16 }))) .ToArray(); // return this; }
public void ShaderFallback() { ShaderAsset shader = null; // Create scene for this test. TestScene extScene = new TestScene { // Load a shader. Also tests whether loading of shaders within another thread works. ExtLoad = () => { shader = Engine.AssetLoader.Get <ShaderAsset>("Shaders/BrokenShaderWithFallback.xml"); }, // Until will unload the shaders. ExtUnload = () => { Engine.AssetLoader.Destroy(shader.Name); }, // Draw all textures in a grid. ExtDraw = () => { Engine.Renderer.SetShader(shader.Shader); // Render a blank square. Engine.Renderer.Render(new Vector3(10, 10, 0), new Vector2(10, 10), Color.White); // Reset to default shader. Engine.Renderer.SetShader(); } }; // Load scene. Helpers.LoadScene(extScene); // The shader should've loaded its fallback. Assert.NotNull(shader.Shader); Assert.True(shader.IsFallback); // Check if what is currently on screen is what is expected. Assert.Equal("PKlb8X5gkVtCWie3LIKpcYzEc5nNjr2Xrz/gCqs54yA=", Helpers.TakeScreenshot()); // Cleanup. Helpers.UnloadScene(); // Ensure the shaders are unloaded. Assert.DoesNotContain(shader.Name, Engine.AssetLoader.LoadedAssets.Select(x => x.Name)); }
public void ShaderBrokenLoad() { ShaderAsset shader = null; // Create scene for this test. TestScene extScene = new TestScene { // Load a shader. Also tests whether loading of shaders within another thread works. ExtLoad = () => { shader = Engine.AssetLoader.Get <ShaderAsset>("Shaders/BrokenShader.xml"); }, // Until will unload the shaders. ExtUnload = () => { Engine.AssetLoader.Destroy(shader.Name); }, // Draw all textures in a grid. ExtDraw = () => { Engine.Renderer.SetShader(shader.Shader); // Render a blank square. Engine.Renderer.Render(new Vector3(10, 10, 0), new Vector2(10, 10), Color.White); // Reset to default shader. Engine.Renderer.SetShader(); } }; // Load scene. Helpers.LoadScene(extScene); // Even though the shader is broken, and it doesn't specify a fallback, it should load the compat shader. Assert.NotNull(shader.Shader); Assert.True(shader.IsFallback); // Check if what is currently on screen is what is expected. Assert.Equal("hC87cJBgdgR51XN76cIe14vmU1vlUWXgN3xxrp8WOdM=", Helpers.TakeScreenshot()); // Cleanup. Helpers.UnloadScene(); // Ensure the shaders are unloaded. Assert.DoesNotContain(shader.Name, Engine.AssetLoader.LoadedAssets.Select(x => x.Name)); }
/// <summary> /// Load a shader asset from given location /// </summary> /// <param name="fileName">Filename</param> /// <param name="asset">Asset object to load into</param> /// <param name="source">Source type</param> /// <returns>True if successful</returns> public bool ShaderLoad(string fileName, ShaderAsset asset, RB.AssetSource source) { if (asset == null) { return(false); } asset.progress = 0; if (asset.shader != null) { asset.shader = null; } // Abort any existing async load for this asset AbortAsyncShaderLoad(asset); if (fileName == null) { Debug.LogError("Shader filename is null!"); asset.InternalSetErrorStatus(RB.AssetStatus.Failed, RB.Result.BadParam); return(false); } fileName.Replace('\\', '/'); var asyncResource = new RBShaderLoader(); asyncResource.Load(fileName, asset, source); if (asset.status == RB.AssetStatus.Ready) { return(true); } // Always add to async queue, even if immediately failed. This gives out consistent async method of error checking mASyncShaders.Add(asyncResource); return(true); }
/// <summary> /// Set a custom shader effect /// </summary> /// <param name="shader">Shader asset to use</param> public void EffectShaderSet(ShaderAsset shader) { ParamsGet((RB.Effect)TOTAL_EFFECTS).Shader = shader; }
public static Shader CreateShader(this Graphics graphics, ShaderAsset shaderAsset) { return graphics.CreateShader (shaderAsset.Declaration, shaderAsset.Format, shaderAsset.Source); }
internal void setAsset(ShaderAsset newAsset) { asset = newAsset; this.DataContext = asset; }
public void SetShader(ShaderAsset rShader) { Properties.Shader = rShader; Agk.SetObjectShader(Properties.ResourceNumber, Properties.Shader.ResourceNumber); }
public bool ImportShaderAsset(string Path, string Name, string EntryPoint, Dictionary <string, object> Macro, bool Rewrite, out BaseAsset assetRes) { string[] arr = Path.Split('.'); string ext = arr[arr.Length - 1].ToLower(); assetRes = null; if (!shaderExts.Contains(ext)) { return(false); } BaseAsset asset; ShaderTypeEnum ST = ShaderTypeEnum.Vertex; if (Name.EndsWith("VS")) { ST = ShaderTypeEnum.Vertex; } else if (Name.EndsWith("PS")) { ST = ShaderTypeEnum.Pixel; } else if (Name.EndsWith("GS")) { ST = ShaderTypeEnum.Geometry; } else if (Name.EndsWith("CS")) { ST = ShaderTypeEnum.Compute; } else if (Name.EndsWith("HS")) { ST = ShaderTypeEnum.Hull; } else if (Name.EndsWith("DS")) { ST = ShaderTypeEnum.Domain; } else { Console.WriteLine("Unknown shader type, please add correct postfix e.g. VS"); return(false); } asset = new ShaderAsset() { Name = Name, ShaderType = ST, EntryPoint = EntryPoint, Macro = Macro, }; if (!asset.ImportAsset(Path, ext)) { return(false); } assetRes = asset; return(FSWorker.CreateAssetFile(asset, Rewrite)); }
static internal void deleteShaderMetadata(ShaderAsset shader) { deleteMetadata(shader, "Shaders/"); }
public static bool UpdateAsset(Object asset, out string error, out string successMessage) { error = ""; successMessage = ""; if (asset is MeshAsset) { MeshAsset mesh = asset as MeshAsset; var result = ImportMesh.import(mesh.SourceFilename, mesh.ImportedFilename); if (string.IsNullOrEmpty(result)) { successMessage = "Successfully updated mesh: " + mesh.Name; mesh.LastUpdated = DateTime.Now; AssetMetadata.createMeshMetadata(mesh); return(true); } } else if (asset is TextureAsset) { TextureAsset texture = asset as TextureAsset; var result = ImportTexture.import(texture.Format, texture.ChannelMappings, texture.ImportedFilename); if (string.IsNullOrEmpty(result)) { successMessage = "Successfully updated texture: " + texture.Name; texture.LastUpdated = DateTime.Now; AssetMetadata.createTextureMetadata(texture); return(true); } else { error = "ERROR: Updating texture: " + texture.Name + " failed!" + Environment.NewLine + result; } } else if (asset is ShaderAsset) { ShaderAsset shader = asset as ShaderAsset; var result = ImportShader.import(shader.SourceFilename, shader.ImportedFilename); if (string.IsNullOrEmpty(result)) { successMessage = "Successfully updated shader: " + shader.Name; shader.LastUpdated = DateTime.Now; AssetMetadata.createShaderMetadata(shader); return(true); } else { error = "ERROR: Updating shader: " + shader.Name + " failed!" + Environment.NewLine + result; } } else if (asset is MaterialAsset) { MaterialAsset material = asset as MaterialAsset; var result = MaterialImporter.Import(material); if (result) { successMessage = "Successfully updated material: " + material.Name; material.LastUpdated = DateTime.Now; AssetMetadata.createMaterialMetadata(material); return(true); } else { error = "ERROR: Updating material: " + material.Name + " failed!" + Environment.NewLine; } } else if (asset is StateGroupAsset) { var stateGroup = asset as StateGroupAsset; var result = StateGroupImporter.Import(stateGroup); if (result) { successMessage = "Successfully updated state group: " + stateGroup.Name; stateGroup.LastUpdated = DateTime.Now; AssetMetadata.createStateGroupMetadata(stateGroup); return(true); } else { error = "ERROR: Updating state group: " + stateGroup.Name + " failed!" + Environment.NewLine + result; } } return(false); }
/// <summary> /// Load shader asset /// </summary> /// <param name="path">Path to load from</param> /// <param name="asset">ShaderAsset to load into</param> /// <param name="source">Source type</param> /// <returns>True if successful</returns> public bool Load(string path, ShaderAsset asset, RB.AssetSource source) { shaderAsset = asset; this.path = path; if (path == null) { shaderAsset.InternalSetErrorStatus(RB.AssetStatus.Failed, RB.Result.BadParam); } if (asset == null) { Debug.LogError("ShaderAsset is null!"); return(false); } if (source == RB.AssetSource.Resources) { // Synchronous load if (path == null) { Debug.LogError("Shader filename is null!"); shaderAsset.InternalSetErrorStatus(RB.AssetStatus.Failed, RB.Result.BadParam); return(false); } var shader = Resources.Load <Shader>(path); if (shader == null) { Debug.LogError("Could not load shader from " + path + ", make sure the resource is placed somehwere in Assets/Resources folder"); shaderAsset.InternalSetErrorStatus(RB.AssetStatus.Failed, RB.Result.NotFound); return(false); } return(FinalizeShader(shader)); } else if (source == RB.AssetSource.WWW) { // Not a supported source, should never get here shaderAsset.InternalSetErrorStatus(RB.AssetStatus.Failed, RB.Result.NotSupported); return(false); } else if (source == RB.AssetSource.ResourcesAsync) { // Finally attempt async resource load mResourceRequest = Resources.LoadAsync <Shader>(this.path); if (mResourceRequest == null) { shaderAsset.InternalSetErrorStatus(RB.AssetStatus.Failed, RB.Result.NoResources); return(false); } shaderAsset.progress = 0; shaderAsset.InternalSetErrorStatus(RB.AssetStatus.Loading, RB.Result.Pending); } #if ADDRESSABLES_PACKAGE_AVAILABLE else if (source == RB.AssetSource.AddressableAssets) { // Exceptions on LoadAssetAsync can't actually be caught... this might work in the future so leaving it here try { mAddressableRequest = Addressables.LoadAssetAsync <Shader>(this.path); } catch (UnityEngine.AddressableAssets.InvalidKeyException e) { RBUtil.Unused(e); shaderAsset.SetErrorStatus(RB.AssetStatus.Failed, RB.Result.NotFound); return(false); } catch (Exception e) { RBUtil.Unused(e); shaderAsset.SetErrorStatus(RB.AssetStatus.Failed, RB.Result.Undefined); return(false); } // Check for an immediate failure if (mAddressableRequest.Status == AsyncOperationStatus.Failed) { Addressables.Release(mAddressableRequest); shaderAsset.SetErrorStatus(RB.AssetStatus.Failed, RB.Result.Undefined); return(false); } shaderAsset.SetErrorStatus(RB.AssetStatus.Loading, RB.Result.Pending); shaderAsset.progress = 0; return(true); } #endif else { shaderAsset.InternalSetErrorStatus(RB.AssetStatus.Failed, RB.Result.NotSupported); return(false); } return(true); }