/******************************************************************************

* The MIT License (MIT)

*

* Copyright (c) 2015-2017 Baldur Karlsson

* Copyright (c) 2014 Crytek

*

* Permission is hereby granted, free of charge, to any person obtaining a copy

* of this software and associated documentation files (the "Software"), to deal

* in the Software without restriction, including without limitation the rights

* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

* copies of the Software, and to permit persons to whom the Software is

* furnished to do so, subject to the following conditions:

*

* The above copyright notice and this permission notice shall be included in

* all copies or substantial portions of the Software.

*

* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

* THE SOFTWARE.

******************************************************************************/

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Drawing;

using System.Linq;

using System.Text;

using System.IO;

using System.Windows.Forms;

using WeifenLuo.WinFormsUI.Docking;

using renderdocui.Code;

using renderdocui.Controls;

using renderdocui.Windows.Dialogs;

using renderdoc;

using System.Threading;

namespace renderdocui.Windows

{

public partial class TextureViewer : DockContent, ILogViewerForm

{

#region Privates

private Core m_Core;

private ReplayOutput m_Output = null;

private Dialogs.TextureGoto m_Goto = null;

private TextureDisplay m_TexDisplay = new TextureDisplay();

private ToolStripControlHost depthStencilToolstrip = null;

private DockContent m_PreviewPanel = null;

private DockContent m_TexlistDockPanel = null;

private FileSystemWatcher m_FSWatcher = null;

private int m_HighWaterStatusLength = 0;

public enum FollowType { OutputColour, OutputDepth, ReadWrite, ReadOnly }

struct Following

{

public FollowType Type;

public ShaderStageType Stage;

public int index;

public int arrayEl;

public static Following Default = new Following(FollowType.OutputColour, ShaderStageType.Pixel, 0, 0);

public Following(FollowType t, ShaderStageType s, int i, int a) { Type = t; Stage = s; index = i; arrayEl = a; }

public override int GetHashCode()

{

return Type.GetHashCode() +

Stage.GetHashCode() +

index.GetHashCode();

}

public override bool Equals(object obj)

{

return obj is Following && this == (Following)obj;

}

public static bool operator ==(Following s1, Following s2)

{

return s1.Type == s2.Type &&

s1.Stage == s2.Stage &&

s1.index == s2.index;

}

public static bool operator !=(Following s1, Following s2)

{

return !(s1 == s2);

}

public static void GetDrawContext(Core core, out bool copy, out bool compute)

{

var curDraw = core.CurDrawcall;

copy = curDraw != null && (curDraw.flags & (DrawcallFlags.Copy | DrawcallFlags.Resolve | DrawcallFlags.Present)) != 0;

compute = curDraw != null && (curDraw.flags & DrawcallFlags.Dispatch) != 0 &&

core.CurPipelineState.GetShader(ShaderStageType.Compute) != ResourceId.Null;

}

public int GetHighestMip(Core core)

{

var curDraw = core.CurDrawcall;

bool copy, compute;

GetDrawContext(core, out copy, out compute);

return GetBoundResource(core, arrayEl).HighestMip;

}

public int GetFirstArraySlice(Core core)

{

var curDraw = core.CurDrawcall;

bool copy, compute;

GetDrawContext(core, out copy, out compute);

return GetBoundResource(core, arrayEl).FirstSlice;

}

public FormatComponentType GetTypeHint(Core core)

{

var curDraw = core.CurDrawcall;

bool copy, compute;

GetDrawContext(core, out copy, out compute);

return GetBoundResource(core, arrayEl).typeHint;

}

public ResourceId GetResourceId(Core core)

{

return GetBoundResource(core, arrayEl).Id;

}

public BoundResource GetBoundResource(Core core, int arrayIdx)

{

BoundResource ret = new BoundResource();

if (Type == FollowType.OutputColour)

{

var outputs = GetOutputTargets(core);

if (index < outputs.Length)

ret = outputs[index];

}

else if (Type == FollowType.OutputDepth)

{

ret = GetDepthTarget(core);

}

else if (Type == FollowType.ReadWrite)

{

var rw = GetReadWriteResources(core);

var mapping = GetMapping(core);

if (index < mapping.ReadWriteResources.Length)

{

var key = mapping.ReadWriteResources[index];

if (rw.ContainsKey(key))

ret = rw[key][arrayIdx];

}

}

else if (Type == FollowType.ReadOnly)

{

var res = GetReadOnlyResources(core);

var mapping = GetMapping(core);

if (index < mapping.ReadOnlyResources.Length)

{

var key = mapping.ReadOnlyResources[index];

if (res.ContainsKey(key))

ret = res[key][arrayIdx];

}

}

return ret;

}

public static BoundResource[] GetOutputTargets(Core core)

{

var curDraw = core.CurDrawcall;

bool copy, compute;

GetDrawContext(core, out copy, out compute);

if (copy)

return new BoundResource[] { new BoundResource(curDraw.copyDestination) };

else if(compute)

return new BoundResource[0];

else

{

var ret = core.CurPipelineState.GetOutputTargets();

if (ret.Length == 0 && curDraw != null && (curDraw.flags & DrawcallFlags.Present) != 0)

{

if (curDraw.copyDestination != ResourceId.Null)

return new BoundResource[] { new BoundResource(curDraw.copyDestination) };

foreach (var t in core.CurTextures)

if ((t.creationFlags & TextureCreationFlags.SwapBuffer) != 0)

return new BoundResource[] { new BoundResource(t.ID) };

}

return ret;

}

}

public static BoundResource GetDepthTarget(Core core)

{

var curDraw = core.CurDrawcall;

bool copy, compute;

GetDrawContext(core, out copy, out compute);

if (copy || compute)

return new BoundResource(ResourceId.Null);

else

return core.CurPipelineState.GetDepthTarget();

}

public Dictionary<BindpointMap, BoundResource[]> GetReadWriteResources(Core core)

{

return GetReadWriteResources(core, Stage);

}

public static Dictionary<BindpointMap, BoundResource[]> GetReadWriteResources(Core core, ShaderStageType stage)

{

var curDraw = core.CurDrawcall;

bool copy, compute;

GetDrawContext(core, out copy, out compute);

if (copy)

{

return new Dictionary<BindpointMap, BoundResource[]>();

}

else if (compute)

{

// only return compute resources for one stage

if (stage == ShaderStageType.Pixel || stage == ShaderStageType.Compute)

return core.CurPipelineState.GetReadWriteResources(ShaderStageType.Compute);

else

return new Dictionary<BindpointMap, BoundResource[]>();

}

else

{

return core.CurPipelineState.GetReadWriteResources(stage);

}

}

public Dictionary<BindpointMap, BoundResource[]> GetReadOnlyResources(Core core)

{

return GetReadOnlyResources(core, Stage);

}

public static Dictionary<BindpointMap, BoundResource[]> GetReadOnlyResources(Core core, ShaderStageType stage)

{

var curDraw = core.CurDrawcall;

bool copy, compute;

GetDrawContext(core, out copy, out compute);

if (copy)

{

var ret = new Dictionary<BindpointMap, BoundResource[]>();

// only return copy source for one stage

if(stage == ShaderStageType.Pixel)

ret.Add(new BindpointMap(0, 0), new BoundResource[] { new BoundResource(curDraw.copySource) });

return ret;

}

else if (compute)

{

// only return compute resources for one stage

if (stage == ShaderStageType.Pixel || stage == ShaderStageType.Compute)

return core.CurPipelineState.GetReadOnlyResources(ShaderStageType.Compute);

else

return new Dictionary<BindpointMap, BoundResource[]>();

}

else

{

return core.CurPipelineState.GetReadOnlyResources(stage);

}

}

public ShaderReflection GetReflection(Core core)

{

return GetReflection(core, Stage);

}

public static ShaderReflection GetReflection(Core core, ShaderStageType stage)

{

var curDraw = core.CurDrawcall;

bool copy, compute;

GetDrawContext(core, out copy, out compute);

if (copy)

return null;

else if (compute)

return core.CurPipelineState.GetShaderReflection(ShaderStageType.Compute);

else

return core.CurPipelineState.GetShaderReflection(stage);

}

public ShaderBindpointMapping GetMapping(Core core)

{

return GetMapping(core, Stage);

}

public static ShaderBindpointMapping GetMapping(Core core, ShaderStageType stage)

{

var curDraw = core.CurDrawcall;

bool copy, compute;

GetDrawContext(core, out copy, out compute);

if (copy)

{

ShaderBindpointMapping mapping = new ShaderBindpointMapping();

mapping.ConstantBlocks = new BindpointMap[0];

mapping.ReadWriteResources = new BindpointMap[0];

mapping.InputAttributes = new int[0];

// for PS only add a single mapping to get the copy source

if (stage == ShaderStageType.Pixel)

mapping.ReadOnlyResources = new BindpointMap[] { new BindpointMap(0, 0) };

else

mapping.ReadOnlyResources = new BindpointMap[0];

return mapping;

}

else if (compute)

{

return core.CurPipelineState.GetBindpointMapping(ShaderStageType.Compute);

}

else

{

return core.CurPipelineState.GetBindpointMapping(stage);

}

}

}

private Following m_Following = Following.Default;

public class TexSettings

{

public TexSettings()

{

r = g = b = true; a = false;

mip = 0; slice = 0;

minrange = 0.0f; maxrange = 1.0f;

typeHint = FormatComponentType.None;

}

public int displayType; // RGBA, RGBM, Custom

public string customShader;

public bool r, g, b, a;

public bool depth, stencil;

public int mip, slice;

public float minrange, maxrange;

public FormatComponentType typeHint;

}

private Dictionary<ResourceId, TexSettings> m_TextureSettings = new Dictionary<ResourceId, TexSettings>();

#endregion

public TextureViewer(Core core)

{

m_Core = core;

InitializeComponent();

if (SystemInformation.HighContrast)

{

dockPanel.Skin = Helpers.MakeHighContrastDockPanelSkin();

zoomStrip.Renderer = new ToolStripSystemRenderer();

overlayStrip.Renderer = new ToolStripSystemRenderer();

subStrip.Renderer = new ToolStripSystemRenderer();

rangeStrip.Renderer = new ToolStripSystemRenderer();

channelStrip.Renderer = new ToolStripSystemRenderer();

actionsStrip.Renderer = new ToolStripSystemRenderer();

}

m_Goto = new Dialogs.TextureGoto(GotoLocation);

textureList.Font =

texturefilter.Font =

rangeBlack.Font =

rangeWhite.Font =

customShader.Font =

hdrMul.Font =

channels.Font =

mipLevel.Font =

sliceFace.Font =

zoomOption.Font =

core.Config.PreferredFont;

Icon = global::renderdocui.Properties.Resources.icon;

textureList.m_Core = core;

textureList.GoIconClick += new EventHandler<GoIconClickEventArgs>(textureList_GoIconClick);

UI_SetupToolstrips();

UI_SetupDocks();

UI_UpdateTextureDetails();

statusLabel.Text = "";

zoomOption.SelectedText = "";

mipLevel.Enabled = false;

sliceFace.Enabled = false;

rangeBlack.ResizeToFit = false;

rangeWhite.ResizeToFit = false;

PixelPicked = false;

mainLayout.Dock = DockStyle.Fill;

saveTex.Enabled = gotoLocationButton.Enabled = viewTexBuffer.Enabled = false;

DockHandler.GetPersistStringCallback = PersistString;

renderContainer.MouseWheelHandler = render_MouseWheel;

renderContainer.MouseDown += render_MouseClick;

renderContainer.MouseMove += render_MouseMove;

RecreateRenderPanel();

RecreateContextPanel();

rangeHistogram.RangeUpdated += new EventHandler<RangeHistogramEventArgs>(rangeHistogram_RangeUpdated);

this.DoubleBuffered = true;

SetStyle(ControlStyles.OptimizedDoubleBuffer, true);

channels.SelectedIndex = 0;

FitToWindow = true;

overlay.SelectedIndex = 0;

m_Following = Following.Default;

texturefilter.SelectedIndex = 0;

}

private void UI_SetupDocks()

{

m_PreviewPanel = Helpers.WrapDockContent(dockPanel, renderToolstripContainer, "Current");

m_PreviewPanel.DockState = DockState.Document;

m_PreviewPanel.AllowEndUserDocking = false;

m_PreviewPanel.Show();

m_PreviewPanel.CloseButton = false;

m_PreviewPanel.CloseButtonVisible = false;

m_PreviewPanel.DockHandler.TabPageContextMenuStrip = tabContextMenu;

dockPanel.ActiveDocumentChanged += new EventHandler(dockPanel_ActiveDocumentChanged);

var w3 = Helpers.WrapDockContent(dockPanel, roPanel, "Inputs");

w3.DockAreas &= ~DockAreas.Document;

w3.DockState = DockState.DockRight;

w3.Show();

w3.CloseButton = false;

w3.CloseButtonVisible = false;

var w5 = Helpers.WrapDockContent(dockPanel, rwPanel, "Outputs");

w5.DockAreas &= ~DockAreas.Document;

w5.DockState = DockState.DockRight;

w5.Show(w3.Pane, w3);

w5.CloseButton = false;

w5.CloseButtonVisible = false;

m_TexlistDockPanel = Helpers.WrapDockContent(dockPanel, texlistContainer, "Texture List");

m_TexlistDockPanel.DockAreas &= ~DockAreas.Document;

m_TexlistDockPanel.DockState = DockState.DockLeft;

m_TexlistDockPanel.Hide();

m_TexlistDockPanel.HideOnClose = true;

var w4 = Helpers.WrapDockContent(dockPanel, pixelContextPanel, "Pixel Context");

w4.DockAreas &= ~DockAreas.Document;

w4.Show(w3.Pane, DockAlignment.Bottom, 0.3);

w4.CloseButton = false;

w4.CloseButtonVisible = false;

}

private void UI_SetupToolstrips()

{

int idx = rangeStrip.Items.IndexOf(rangeWhite);

rangeStrip.Items.Insert(idx, new ToolStripControlHost(rangeHistogram));

for (int i = 0; i < channelStrip.Items.Count; i++)

{

if (channelStrip.Items[i] == mulSep)

{

depthStencilToolstrip = new ToolStripControlHost(depthstencilPanel);

channelStrip.Items.Insert(i, depthStencilToolstrip);

break;

}

}

}

public class PersistData

{

public static int currentPersistVersion = 4;

public int persistVersion = currentPersistVersion;

public string panelLayout;

public FloatVector darkBack = new FloatVector(0, 0, 0, 0);

public FloatVector lightBack = new FloatVector(0, 0, 0, 0);

public static PersistData GetDefaults()

{

PersistData data = new PersistData();

data.panelLayout = "";

data.darkBack = new FloatVector(0, 0, 0, 0);

data.lightBack = new FloatVector(0, 0, 0, 0);

return data;

}

}

public void InitFromPersistString(string str)

{

PersistData data = null;

try

{

if (str.Length > GetType().ToString().Length)

{

var reader = new StringReader(str.Substring(GetType().ToString().Length));

System.Xml.Serialization.XmlSerializer xs = new System.Xml.Serialization.XmlSerializer(typeof(PersistData));

data = (PersistData)xs.Deserialize(reader);

reader.Close();

}

}

catch (System.Xml.XmlException)

{

}

catch(InvalidOperationException)

{

// don't need to handle it. Leave data null and pick up defaults below

}

if (data == null || data.persistVersion != PersistData.currentPersistVersion)

{

data = PersistData.GetDefaults();

}

// fixup old incorrect checkerboard colours

if (data.lightBack.x != data.darkBack.x)

{

TextureDisplay defaults = new TextureDisplay();

data.lightBack = defaults.lightBackgroundColour;

data.darkBack = defaults.darkBackgroundColour;

}

ApplyPersistData(data);

}

private IDockContent GetContentFromPersistString(string persistString)

{

Control[] persistors = {

renderToolstripContainer,

roPanel,

rwPanel,

texlistContainer,

pixelContextPanel

};

foreach(var p in persistors)

if (persistString == p.Name && p.Parent is IDockContent && (p.Parent as DockContent).DockPanel == null)

return p.Parent as IDockContent;

// backwards compatibilty for rename

if(persistString == "texPanel")

return roPanel.Parent as IDockContent;

if(persistString == "rtPanel")

return rwPanel.Parent as IDockContent;

return null;

}

private string onloadLayout = "";

private FloatVector darkBack = new FloatVector(0, 0, 0, 0);

private FloatVector lightBack = new FloatVector(0, 0, 0, 0);

private void ApplyPersistData(PersistData data)

{

onloadLayout = data.panelLayout;

darkBack = data.darkBack;

lightBack = data.lightBack;

}

private void TextureViewer_Load(object sender, EventArgs e)

{

if (onloadLayout.Length > 0)

{

Control[] persistors = {

renderToolstripContainer,

roPanel,

rwPanel,

texlistContainer,

pixelContextPanel

};

foreach (var p in persistors)

(p.Parent as DockContent).DockPanel = null;

var enc = new UnicodeEncoding();

using (var strm = new MemoryStream(enc.GetBytes(onloadLayout)))

{

strm.Flush();

strm.Position = 0;

try

{

dockPanel.LoadFromXml(strm, new DeserializeDockContent(GetContentFromPersistString));

}

catch (System.Exception)

{

// on error, go back to default layout

UI_SetupDocks();

}

}

onloadLayout = "";

}

if (darkBack.x != lightBack.x)

{

backcolorPick.Checked = false;

checkerBack.Checked = true;

}

else

{

backcolorPick.Checked = true;

checkerBack.Checked = false;

colorDialog.Color = Color.FromArgb((int)(255 * darkBack.x),

(int)(255 * darkBack.y),

(int)(255 * darkBack.z));

}

}

private string PersistString()

{

var writer = new StringWriter();

writer.Write(GetType().ToString());

PersistData data = new PersistData();

// passing in a MemoryStream gets disposed - can't see a way to retrieve this

// in-memory.

var enc = new UnicodeEncoding();

var path = Path.GetTempFileName();

dockPanel.SaveAsXml(path, "", enc);

try

{

data.panelLayout = File.ReadAllText(path, enc);

File.Delete(path);

}

catch (System.Exception)

{

// can't recover

return writer.ToString();

}

data.darkBack = darkBack;

data.lightBack = lightBack;

System.Xml.Serialization.XmlSerializer xs = new System.Xml.Serialization.XmlSerializer(typeof(PersistData));

xs.Serialize(writer, data);

return writer.ToString();

}

#region Public Functions

private Dictionary<ResourceId, DockContent> lockedTabs = new Dictionary<ResourceId, DockContent>();

public void GotoLocation(int x, int y)

{

if(!m_Core.LogLoaded || CurrentTexture == null)

return;

m_PickedPoint = new Point(x, y);

uint mipHeight = Math.Max(1, CurrentTexture.height >> (int)m_TexDisplay.mip);

if (m_Core.APIProps.pipelineType == GraphicsAPI.OpenGL)

m_PickedPoint.Y = (int)(mipHeight - 1) - m_PickedPoint.Y;

if (m_TexDisplay.FlipY)

m_PickedPoint.Y = (int)(mipHeight - 1) - m_PickedPoint.Y;

m_Core.Renderer.BeginInvoke((ReplayRenderer r) =>

{

if (m_Output != null)

RT_PickPixelsAndUpdate(m_PickedPoint.X, m_PickedPoint.Y, true);

RT_UpdateAndDisplay(r);

});

UI_UpdateStatusText();

}

public void ViewTexture(ResourceId ID, bool focus)

{

if (this.InvokeRequired)

{

this.BeginInvoke(new Action(() => { this.ViewTexture(ID, focus); }));

return;

}

TextureViewer_Load(null, null);

if (lockedTabs.ContainsKey(ID))

{

if (!lockedTabs[ID].IsDisposed && !lockedTabs[ID].IsHidden)

{

if (focus)

Show();

lockedTabs[ID].Show();

m_Core.Renderer.BeginInvoke(RT_UpdateAndDisplay);

return;

}

lockedTabs.Remove(ID);

}

for (int i = 0; i < m_Core.CurTextures.Length; i++)

{

if (m_Core.CurTextures[i].ID == ID)

{

FetchTexture current = m_Core.CurTextures[i];

var newPanel = Helpers.WrapDockContent(dockPanel, renderToolstripContainer, current.name);

newPanel.DockState = DockState.Document;

newPanel.AllowEndUserDocking = false;

newPanel.Icon = Icon.FromHandle(global::renderdocui.Properties.Resources.page_white_link.GetHicon());

newPanel.Tag = current;

newPanel.DockHandler.TabPageContextMenuStrip = tabContextMenu;

newPanel.FormClosing += new FormClosingEventHandler(PreviewPanel_FormClosing);

newPanel.Show(m_PreviewPanel.Pane, null);

newPanel.Show();

if (focus)

Show();

lockedTabs.Add(ID, newPanel);

m_Core.Renderer.BeginInvoke(RT_UpdateAndDisplay);

return;

}

}

for (int i = 0; i < m_Core.CurBuffers.Length; i++)

{

if (m_Core.CurBuffers[i].ID == ID)

{

var viewer = new BufferViewer(m_Core, false);

viewer.ViewRawBuffer(true, 0, ulong.MaxValue, ID);

viewer.Show(DockPanel);

return;

}

}

}

#endregion

#region Custom Shader handling

private List<string> m_CustomShadersBusy = new List<string>();

private Dictionary<string, ResourceId> m_CustomShaders = new Dictionary<string, ResourceId>();

private Dictionary<string, ShaderViewer> m_CustomShaderEditor = new Dictionary<string, ShaderViewer>();

private void ReloadCustomShaders(string filter)

{

if (!m_Core.LogLoaded) return;

if (filter.Length > 0)

{

var shaders = m_CustomShaders.Values.ToArray();

m_Core.Renderer.BeginInvoke((ReplayRenderer r) =>

{

foreach (var s in shaders)

r.FreeCustomShader(s);

});

customShader.Items.Clear();

m_CustomShaders.Clear();

}

else

{

var fn = Path.GetFileNameWithoutExtension(filter);

var key = fn.ToUpperInvariant();

if (m_CustomShaders.ContainsKey(key))

{

if (m_CustomShadersBusy.Contains(key))

return;

ResourceId freed = m_CustomShaders[key];

m_Core.Renderer.BeginInvoke((ReplayRenderer r) =>

{

r.FreeCustomShader(freed);

});

m_CustomShaders.Remove(key);

var text = customShader.Text;

for (int i = 0; i < customShader.Items.Count; i++)

{

if (customShader.Items[i].ToString() == fn)

{

customShader.Items.RemoveAt(i);

break;

}

}

customShader.Text = text;

}

}

foreach (var f in Directory.EnumerateFiles(Core.ConfigDirectory, "*" + m_Core.APIProps.ShaderExtension))

{

var fn = Path.GetFileNameWithoutExtension(f);

var key = fn.ToUpperInvariant();

if (!m_CustomShaders.ContainsKey(key) && !m_CustomShadersBusy.Contains(key))

{

try

{

string source = File.ReadAllText(f);

m_CustomShaders.Add(key, ResourceId.Null);

m_CustomShadersBusy.Add(key);

m_Core.Renderer.BeginInvoke((ReplayRenderer r) =>

{

string errors = "";

ResourceId id = r.BuildCustomShader("main", source, 0, ShaderStageType.Pixel, out errors);

if (m_CustomShaderEditor.ContainsKey(key))

{

BeginInvoke((MethodInvoker)delegate

{

m_CustomShaderEditor[key].ShowErrors(errors);

});

}

BeginInvoke((MethodInvoker)delegate

{

customShader.Items.Add(fn);

m_CustomShaders[key] = id;

m_CustomShadersBusy.Remove(key);

customShader.AutoCompleteSource = AutoCompleteSource.None;

customShader.AutoCompleteSource = AutoCompleteSource.ListItems;

UI_UpdateChannels();

});

});

}

catch (System.Exception)

{

// just continue, skip this file

}

}

}

}

private void customCreate_Click(object sender, EventArgs e)

{

if (customShader.Text == null || customShader.Text.Length == 0)

{

MessageBox.Show("No name entered.\nEnter a name in the textbox.", "Error Creating Shader", MessageBoxButtons.OK, MessageBoxIcon.Error);

return;

}

if (m_CustomShaders.ContainsKey(customShader.Text.ToUpperInvariant()))

{

MessageBox.Show("Selected shader already exists.\nEnter a new name in the textbox.", "Error Creating Shader", MessageBoxButtons.OK, MessageBoxIcon.Error);

customShader.Text = "";

UI_UpdateChannels();

return;

}

var path = Path.Combine(Core.ConfigDirectory, customShader.Text + m_Core.APIProps.ShaderExtension);

string src = "";

if (m_Core.APIProps.pipelineType.IsD3D())

{

src = String.Format(

"float4 main(float4 pos : SV_Position, float4 uv : TEXCOORD0) : SV_Target0{0}" +

"{{{0}" +

" return float4(0,0,0,1);{0}" +

"}}{0}"

, Environment.NewLine);

}

else if (m_Core.APIProps.pipelineType == GraphicsAPI.OpenGL ||

m_Core.APIProps.pipelineType == GraphicsAPI.Vulkan)

{

src = String.Format(

"#version 420 core{0}{0}" +

"layout (location = 0) in vec2 uv;{0}{0}" +

"layout (location = 0) out vec4 color_out;{0}{0}" +

"void main(){0}" +

"{{{0}" +

" color_out = vec4(0,0,0,1);{0}" +

"}}{0}"

, Environment.NewLine);

}

try

{

File.WriteAllText(path, src);

}

catch (System.Exception)

{

// ignore this file

}

// auto-open edit window

customEdit_Click(sender, e);

}

private void customEdit_Click(object sender, EventArgs e)

{

var filename = customShader.Text;

var key = filename.ToUpperInvariant();

string src = "";

try

{

src = File.ReadAllText(Path.Combine(Core.ConfigDirectory, filename + m_Core.APIProps.ShaderExtension));

}

catch (System.Exception ex)

{

MessageBox.Show("Couldn't open file for shader " + filename + Environment.NewLine + ex.ToString(), "Cannot open shader",

MessageBoxButtons.OK, MessageBoxIcon.Error);

return;

}

var files = new Dictionary<string, string>();

files.Add(filename, src);

ShaderViewer s = new ShaderViewer(m_Core, true, "Custom Shader", files,

// Save Callback

(ShaderViewer viewer, Dictionary<string, string> updatedfiles) =>

{

foreach (var f in updatedfiles)

{

var path = Path.Combine(Core.ConfigDirectory, f.Key + m_Core.APIProps.ShaderExtension);

try

{

File.WriteAllText(path, f.Value);

}

catch (System.Exception ex)

{

MessageBox.Show("Couldn't save file for shader " + filename + Environment.NewLine + ex.ToString(), "Cannot save shader",

MessageBoxButtons.OK, MessageBoxIcon.Error);

return;

}

}

},

// Close Callback

() =>

{

m_CustomShaderEditor.Remove(key);

});

m_CustomShaderEditor[key] = s;

s.Show(this.DockPanel);

}

private void customDelete_Click(object sender, EventArgs e)

{

if (customShader.Text == null || customShader.Text.Length == 0)

{