void AddRealtimeFields(MixtureNode node, MixtureGraphView owner)
{
doubleBuffered = new Toggle("Double Buffered")
{
value = node.rtSettings.doubleBuffered,
};
doubleBuffered.RegisterValueChangedCallback(e => {
owner.RegisterCompleteObjectUndo("Set Double Buffered " + e.newValue);
node.rtSettings.doubleBuffered = e.newValue;
onChanged?.Invoke();
});
Add(doubleBuffered);
refreshMode = new EnumField("Refresh Mode", node.rtSettings.refreshMode);
refreshMode.RegisterValueChangedCallback(e => {
owner.RegisterCompleteObjectUndo("Set Refresh Mode " + e.newValue);
node.rtSettings.refreshMode = (RefreshMode)e.newValue;
onChanged?.Invoke();
});
Add(refreshMode);
period = new FloatField("Period")
{
value = node.rtSettings.period
};
period.RegisterValueChangedCallback(e => {
owner.RegisterCompleteObjectUndo("Set Period " + e.newValue);
node.rtSettings.period = e.newValue;
onChanged?.Invoke();
});
Add(period);
}
public override void OnOpen()
{
var settingsView = new MixtureSettingsView(graphView.graph.settings, graphView, "Graph Settings", false);
settingsView.AddToClassList("RTSettingsView");
settingsView.style.height = new StyleLength(new Length(100, LengthUnit.Percent));
settingsView.RegisterChangedCallback(() => graphView.ProcessGraph());
var otherHeader = new Label("Advanced Settings");
otherHeader.AddToClassList(MixtureSettingsView.headerStyleClass);
settingsView.Add(otherHeader);
var defaultInheritanceMode = new EnumField(graphView.graph.defaultNodeInheritanceMode)
{
label = "Node Inheritance Mode"
};
defaultInheritanceMode.RegisterValueChangedCallback(e => {
graphView.RegisterCompleteObjectUndo("Changed node inheritance mode");
graphView.graph.defaultNodeInheritanceMode = (NodeInheritanceMode)e.newValue;
graphView.graph.UpdateNodeInheritanceMode();
graphView.RefreshNodeSettings();
graphView.ProcessGraph();
});
settingsView.Add(defaultInheritanceMode);
editorWindow.rootVisualElement.Add(settingsView);
}
void AddRealtimeFields(MixtureNode node, MixtureGraphView owner)
{
doubleBuffered = new Toggle("Double Buffered")
{
value = node.rtSettings.doubleBuffered,
};
doubleBuffered.RegisterValueChangedCallback(e => {
owner.RegisterCompleteObjectUndo("Set Double Buffered " + e.newValue);
node.rtSettings.doubleBuffered = e.newValue;
onChanged?.Invoke();
});
Add(doubleBuffered);
}
void AddRealtimeFields(MixtureGraphView owner)
{
refreshMode = new EnumField("Refresh Mode", settings.refreshMode);
refreshMode.RegisterValueChangedCallback(e => {
owner.RegisterCompleteObjectUndo("Set Refresh Mode " + e.newValue);
settings.refreshMode = (RefreshMode)e.newValue;
onChanged?.Invoke();
});
Add(refreshMode);
period = new FloatField("Period")
{
value = settings.period
};
period.RegisterValueChangedCallback(e => {
owner.RegisterCompleteObjectUndo("Set Period " + e.newValue);
settings.period = e.newValue;
onChanged?.Invoke();
});
Add(period);
}
public HistogramView(HistogramData data, MixtureGraphView graphView, int height = 200)
{
var modeField = new EnumField("Histogram Mode", data.mode);
modeField.RegisterValueChangedCallback(e => {
graphView.RegisterCompleteObjectUndo("Changed histogram Mode");
data.mode = (HistogramMode)e.newValue;
});
Add(modeField);
var drawHistogram = new DrawHistogram(data, height);
Add(drawHistogram);
var minMaxLabel = new Label();
Add(minMaxLabel);
schedule.Execute(() => {
minMaxLabel.text = $"Luminance min: {data.minLuminance:F3}, max: {data.maxLuminance:F3}";
}).Every(20);
}
void InitializeView()
{
// Register callbacks
settingsButton.clicked += () => {
if (settingsButton.ClassListContains("ActiveButton"))
{
settingsButton.RemoveFromClassList("ActiveButton");
portSettings.style.display = DisplayStyle.None;
portNameField.style.display = DisplayStyle.None;
}
else
{
settingsButton.AddToClassList("ActiveButton");
portSettings.style.display = DisplayStyle.Flex;
portNameField.style.display = DisplayStyle.Flex;
}
};
portNameField.RegisterValueChangedCallback(name => {
graphView.RegisterCompleteObjectUndo("Change output name");
var uniqueName = ObjectNames.GetUniqueName(node.outputTextureSettings.Select(o => o.name).ToArray(), name.newValue);
targetSettings.name = uniqueName;
portName.text = uniqueName;
#if UNITY_EDITOR
if (graphView.graph.isRealtime)
{
graphView.graph.UpdateRealtimeAssetsOnDisk();
}
#endif
});
portNameField.value = targetSettings.name;
portName.text = targetSettings.name;
enableCompression.RegisterValueChangedCallback(enabled => {
graphView.RegisterCompleteObjectUndo($"Change {targetSettings.name} compression");
var textureDim = node.rtSettings.GetTextureDimension(graphView.graph);
if (textureDim == TextureDimension.Tex2D || textureDim == TextureDimension.Cube)
{
targetSettings.enableCompression = enabled.newValue;
if (enabled.newValue)
{
compressionFields.style.display = DisplayStyle.Flex;
}
else
{
compressionFields.style.display = DisplayStyle.None;
}
}
else
{
Debug.LogError("Compression is not yet supported for " + textureDim);
enableCompression.SetValueWithoutNotify(false);
}
});
enableCompression.value = targetSettings.enableCompression;
compressionFormat.RegisterValueChangedCallback(format => {
targetSettings.compressionFormat = (TextureFormat)format.newValue;
});
compressionQuality.RegisterValueChangedCallback(quality => {
targetSettings.compressionQuality = (MixtureCompressionQuality)quality.newValue;
});
compressionFormat.SetValueWithoutNotify(targetSettings.compressionFormat);
compressionQuality.SetValueWithoutNotify(targetSettings.compressionQuality);
createMipMapShaderButton.clicked += MixtureAssetCallbacks.CreateCustomMipMapShaderGraph;
// TODO: assign the created shader when finished
mipmapShaderField.objectType = typeof(Shader);
mipmapShaderField.value = targetSettings.customMipMapShader;
createMipMapShaderButton.style.display = targetSettings.customMipMapShader != null ? DisplayStyle.None : DisplayStyle.Flex;
mipmapShaderField.RegisterValueChangedCallback(e => {
graphView.RegisterCompleteObjectUndo("Changed Custom Mip Map Shader");
targetSettings.customMipMapShader = e.newValue as Shader;
createMipMapShaderButton.style.display = e.newValue != null ? DisplayStyle.None : DisplayStyle.Flex;;
});
enableMipMap.RegisterValueChangedCallback(e => {
targetSettings.hasMipMaps = e.newValue;
if (supportCustomMipMaps)
{
mipmapFields.style.display = targetSettings.hasMipMaps ? DisplayStyle.Flex : DisplayStyle.None;
}
// Processing the graph to update the previews with the new mipmaps
graphView.ProcessGraph();
});
enableMipMap.value = targetSettings.hasMipMaps;
removeOutputButton.clicked += () => {
node.RemoveTextureOutput(targetSettings);
nodeView.ForceUpdatePorts();
};
enableConversion.RegisterValueChangedCallback(e => {
graphView.RegisterCompleteObjectUndo("Changed Conversion value");
targetSettings.enableConversion = e.newValue;
conversionFormat.style.display = e.newValue ? DisplayStyle.Flex : DisplayStyle.None;
});
enableConversion.value = targetSettings.enableConversion;
conversionFormat.RegisterValueChangedCallback(e => {
graphView.RegisterCompleteObjectUndo("Changed Conversion Format");
targetSettings.conversionFormat = (ConversionFormat)e.newValue;
});
conversionFormat.value = targetSettings.conversionFormat;
sRGB.RegisterValueChangedCallback(e => {
graphView.RegisterCompleteObjectUndo("Changed sRGB");
targetSettings.sRGB = e.newValue;
// when updating sRGB flag, we need to process the graph to update the final copy material
graphView.ProcessGraph();
});
sRGB.value = targetSettings.sRGB;
// Initial view state
portSettings.style.display = DisplayStyle.None;
compressionFields.style.display = targetSettings.enableCompression ? DisplayStyle.Flex : DisplayStyle.None;
mipmapFields.style.display = targetSettings.hasMipMaps ? DisplayStyle.Flex : DisplayStyle.None;
portNameField.style.display = DisplayStyle.None;
conversionFormat.style.display = targetSettings.enableConversion ? DisplayStyle.Flex : DisplayStyle.None;
}
void ReloadSettingsView()
{
// Remove all old fields
Clear();
var title = new Label("Node Output Settings");
var dimension = node.rtSettings.GetTextureDimension(graph);
title.AddToClassList("PropertyEditorTitle");
this.Add(title);
// Wrap and Filter Modes
smpHeader = new Label("Sampler States");
smpHeader.AddToClassList(headerStyleClass);
this.Add(smpHeader);
wrapMode = new EnumField(node.rtSettings.wrapMode)
{
label = "Wrap Mode",
};
wrapMode.RegisterValueChangedCallback(e =>
{
owner.RegisterCompleteObjectUndo("Updated Wrap Mode " + e.newValue);
node.rtSettings.wrapMode = (TextureWrapMode)e.newValue;
onChanged?.Invoke();
});
filterMode = new EnumField(node.rtSettings.filterMode)
{
label = "Filter Mode",
};
filterMode.RegisterValueChangedCallback(e =>
{
owner.RegisterCompleteObjectUndo("Updated Filter Mode " + e.newValue);
node.rtSettings.filterMode = (FilterMode)e.newValue;
onChanged?.Invoke();
});
this.Add(wrapMode);
this.Add(filterMode);
// Size Modes
sizeHeader = new Label("Size Properties");
sizeHeader.AddToClassList(headerStyleClass);
this.Add(sizeHeader);
outputWidthMode = new EnumField(node.rtSettings.widthMode)
{
label = "Width Mode",
};
outputWidthMode.RegisterValueChangedCallback(e => {
owner.RegisterCompleteObjectUndo("Updated Texture Dimension " + e.newValue);
node.rtSettings.widthMode = (OutputSizeMode)e.newValue;
onChanged?.Invoke();
UpdateFieldVisibility(node);
});
this.Add(outputWidthMode);
if (dimension != TextureDimension.Cube)
{
outputHeightMode = new EnumField(node.rtSettings.heightMode)
{
label = "Height Mode",
};
outputHeightMode.RegisterValueChangedCallback(e => {
owner.RegisterCompleteObjectUndo("Updated Texture Dimension " + e.newValue);
node.rtSettings.heightMode = (OutputSizeMode)e.newValue;
onChanged?.Invoke();
UpdateFieldVisibility(node);
});
this.Add(outputHeightMode);
if (dimension == TextureDimension.Tex3D)
{
outputDepthMode = new EnumField(node.rtSettings.depthMode)
{
label = "Depth Mode",
};
outputDepthMode.RegisterValueChangedCallback(e => {
owner.RegisterCompleteObjectUndo("Updated Texture Dimension " + e.newValue);
node.rtSettings.depthMode = (OutputSizeMode)e.newValue;
onChanged?.Invoke();
UpdateFieldVisibility(node);
});
this.Add(outputDepthMode);
}
}
potSize = new EnumField(node.rtSettings.potSize)
{
value = node.rtSettings.potSize,
label = "Resolution",
};
potSize.RegisterValueChangedCallback(e =>
{
owner.RegisterCompleteObjectUndo("Updated Size " + e.newValue);
var size = (POTSize)e.newValue;
node.rtSettings.potSize = size;
if (size != POTSize.Custom)
{
node.rtSettings.width = (int)size;
node.rtSettings.height = (int)size;
node.rtSettings.sliceCount = (int)size;
}
else
{
node.rtSettings.width = outputWidth.value;
node.rtSettings.height = outputHeight.value;
node.rtSettings.sliceCount = outputDepth.value;
}
onChanged?.Invoke();
UpdateFieldVisibility(node);
});
this.Add(potSize);
outputWidth = new IntegerField()
{
value = node.rtSettings.width,
label = "Width",
isDelayed = true,
};
outputWidth.RegisterValueChangedCallback(e =>
{
owner.RegisterCompleteObjectUndo("Updated Width " + e.newValue);
node.rtSettings.width = e.newValue;
onChanged?.Invoke();
});
this.Add(outputWidth);
outputWidthPercentage = new FloatField()
{
value = node.rtSettings.widthPercent,
label = "Width Percentage",
isDelayed = true,
};
outputWidthPercentage.RegisterValueChangedCallback(e =>
{
owner.RegisterCompleteObjectUndo("Updated Width " + e.newValue);
node.rtSettings.widthPercent = e.newValue;
onChanged?.Invoke();
});
this.Add(outputWidthPercentage);
if (dimension != TextureDimension.Cube)
{
outputHeight = new IntegerField()
{
value = node.rtSettings.height,
label = "Height",
isDelayed = true,
};
outputHeight.RegisterValueChangedCallback(e =>
{
owner.RegisterCompleteObjectUndo("Updated Height " + e.newValue);
node.rtSettings.height = e.newValue;
onChanged?.Invoke();
});
this.Add(outputHeight);
outputHeightPercentage = new FloatField()
{
value = node.rtSettings.heightPercent,
label = "Height Percentage",
isDelayed = true,
};
outputHeightPercentage.RegisterValueChangedCallback(e =>
{
owner.RegisterCompleteObjectUndo("Updated Height " + e.newValue);
node.rtSettings.heightPercent = e.newValue;
onChanged?.Invoke();
});
this.Add(outputHeightPercentage);
if (dimension == TextureDimension.Tex3D)
{
outputDepth = new IntegerField()
{
value = node.rtSettings.sliceCount,
label = "Depth",
isDelayed = true,
};
outputDepth.RegisterValueChangedCallback(e =>
{
owner.RegisterCompleteObjectUndo("Updated Depth " + e.newValue);
node.rtSettings.sliceCount = e.newValue;
onChanged?.Invoke();
});
this.Add(outputDepth);
outputDepthPercentage = new FloatField()
{
value = node.rtSettings.depthPercent,
label = "Depth Percentage",
isDelayed = true,
};
outputDepthPercentage.RegisterValueChangedCallback(e =>
{
owner.RegisterCompleteObjectUndo("Updated Depth " + e.newValue);
node.rtSettings.depthPercent = e.newValue;
onChanged?.Invoke();
});
this.Add(outputDepthPercentage);
}
}
// Dimension and Pixel Format
formatHeader = new Label("Format");
formatHeader.AddToClassList(headerStyleClass);
this.Add(formatHeader);
outputDimension = new EnumField(node.rtSettings.dimension)
{
label = "Dimension",
};
outputDimension.RegisterValueChangedCallback(e => {
owner.RegisterCompleteObjectUndo("Updated Texture Dimension " + e.newValue);
// Check if the new texture is not too high res:
node.rtSettings.dimension = (OutputDimension)e.newValue;
if (node.rtSettings.dimension == OutputDimension.Texture3D)
{
long pixelCount = node.rtSettings.GetWidth(graph) * node.rtSettings.GetHeight(graph) * node.rtSettings.GetDepth(graph);
// Above 16M pixels in a texture3D, processing can take too long and crash the GPU when a conversion happen
if (pixelCount > 16777216)
{
node.rtSettings.SetPOTSize(64);
}
}
onChanged?.Invoke();
});
outputChannels = new EnumField(node.rtSettings.outputChannels)
{
label = "Output Channels",
};
outputChannels.RegisterValueChangedCallback(e => {
owner.RegisterCompleteObjectUndo("Updated Output Channels " + e.newValue);
node.rtSettings.outputChannels = (OutputChannel)e.newValue;
onChanged?.Invoke();
});
outputPrecision = new EnumField(node.rtSettings.outputPrecision)
{
label = "Output Precision",
};
outputPrecision.RegisterValueChangedCallback(e => {
owner.RegisterCompleteObjectUndo("Updated Output Precision " + e.newValue);
node.rtSettings.outputPrecision = (OutputPrecision)e.newValue;
// outputPrecision.Init();
onChanged?.Invoke();
});
this.Add(outputDimension);
this.Add(outputChannels);
this.Add(outputPrecision);
UpdateFieldVisibility(node);
if (owner.graph.isRealtime)
{
// Realtime fields and refresh mode
otherHeader = new Label("Other");
otherHeader.AddToClassList(headerStyleClass);
this.Add(otherHeader);
AddRealtimeFields(node, owner);
}
}
void ReloadSettingsView()
{
// Remove all old fields
Clear();
var title = new Label("Node Output Settings");
var dimension = node.rtSettings.GetTextureDimension(graph);
title.AddToClassList("PropertyEditorTitle");
this.Add(title);
// Wrap and Filter Modes
var smpHeader = new Label("Sampler States");
smpHeader.AddToClassList("PropertyEditorHeader");
this.Add(smpHeader);
wrapMode = new EnumField(node.rtSettings.wrapMode)
{
label = "Wrap Mode",
};
wrapMode.RegisterValueChangedCallback(e =>
{
owner.RegisterCompleteObjectUndo("Updated Wrap Mode " + e.newValue);
node.rtSettings.wrapMode = (TextureWrapMode)e.newValue;
onChanged?.Invoke();
});
filterMode = new EnumField(node.rtSettings.filterMode)
{
label = "Filter Mode",
};
filterMode.RegisterValueChangedCallback(e =>
{
owner.RegisterCompleteObjectUndo("Updated Filter Mode " + e.newValue);
node.rtSettings.filterMode = (FilterMode)e.newValue;
onChanged?.Invoke();
});
this.Add(wrapMode);
this.Add(filterMode);
// Size Modes
var sizeHeader = new Label("Size Properties");
sizeHeader.AddToClassList("PropertyEditorHeader");
this.Add(sizeHeader);
outputWidthMode = new EnumField(node.rtSettings.widthMode)
{
label = "Width Mode",
};
outputWidthMode.RegisterValueChangedCallback(e => {
owner.RegisterCompleteObjectUndo("Updated Texture Dimension " + e.newValue);
node.rtSettings.widthMode = (OutputSizeMode)e.newValue;
onChanged?.Invoke();
UpdateFieldVisibility(node);
});
this.Add(outputWidthMode);
if (dimension != TextureDimension.Cube)
{
outputHeightMode = new EnumField(node.rtSettings.heightMode)
{
label = "Height Mode",
};
outputHeightMode.RegisterValueChangedCallback(e => {
owner.RegisterCompleteObjectUndo("Updated Texture Dimension " + e.newValue);
node.rtSettings.heightMode = (OutputSizeMode)e.newValue;
onChanged?.Invoke();
UpdateFieldVisibility(node);
});
this.Add(outputHeightMode);
if (dimension == TextureDimension.Tex3D)
{
outputDepthMode = new EnumField(node.rtSettings.depthMode)
{
label = "Depth Mode",
};
outputDepthMode.RegisterValueChangedCallback(e => {
owner.RegisterCompleteObjectUndo("Updated Texture Dimension " + e.newValue);
node.rtSettings.depthMode = (OutputSizeMode)e.newValue;
onChanged?.Invoke();
UpdateFieldVisibility(node);
});
this.Add(outputDepthMode);
}
}
potSize = new EnumField(node.rtSettings.potSize)
{
value = node.rtSettings.potSize,
label = "Resolution",
};
potSize.RegisterValueChangedCallback(e =>
{
owner.RegisterCompleteObjectUndo("Updated Size " + e.newValue);
var size = (POTSize)e.newValue;
node.rtSettings.potSize = size;
if (size != POTSize.Custom)
{
node.rtSettings.width = (int)size;
node.rtSettings.height = (int)size;
node.rtSettings.sliceCount = (int)size;
}
else
{
node.rtSettings.width = outputWidth.value;
node.rtSettings.height = outputHeight.value;
node.rtSettings.sliceCount = outputDepth.value;
}
onChanged?.Invoke();
UpdateFieldVisibility(node);
});
this.Add(potSize);
outputWidth = new IntegerField()
{
value = node.rtSettings.width,
label = "Width",
isDelayed = true,
};
outputWidth.RegisterValueChangedCallback(e =>
{
owner.RegisterCompleteObjectUndo("Updated Width " + e.newValue);
node.rtSettings.width = e.newValue;
onChanged?.Invoke();
});
this.Add(outputWidth);
outputWidthPercentage = new FloatField()
{
value = node.rtSettings.widthPercent,
label = "Width Percentage",
isDelayed = true,
};
outputWidthPercentage.RegisterValueChangedCallback(e =>
{
owner.RegisterCompleteObjectUndo("Updated Width " + e.newValue);
node.rtSettings.widthPercent = e.newValue;
onChanged?.Invoke();
});
this.Add(outputWidthPercentage);
if (dimension != TextureDimension.Cube)
{
outputHeight = new IntegerField()
{
value = node.rtSettings.height,
label = "Height",
isDelayed = true,
};
outputHeight.RegisterValueChangedCallback(e =>
{
owner.RegisterCompleteObjectUndo("Updated Height " + e.newValue);
node.rtSettings.height = e.newValue;
onChanged?.Invoke();
});
this.Add(outputHeight);
outputHeightPercentage = new FloatField()
{
value = node.rtSettings.heightPercent,
label = "Height Percentage",
isDelayed = true,
};
outputHeightPercentage.RegisterValueChangedCallback(e =>
{
owner.RegisterCompleteObjectUndo("Updated Height " + e.newValue);
node.rtSettings.heightPercent = e.newValue;
onChanged?.Invoke();
});
this.Add(outputHeightPercentage);
if (dimension == TextureDimension.Tex3D)
{
outputDepth = new IntegerField()
{
value = node.rtSettings.sliceCount,
label = "Depth",
isDelayed = true,
};
outputDepth.RegisterValueChangedCallback(e =>
{
owner.RegisterCompleteObjectUndo("Updated Depth " + e.newValue);
node.rtSettings.sliceCount = e.newValue;
onChanged?.Invoke();
});
this.Add(outputDepth);
outputDepthPercentage = new FloatField()
{
value = node.rtSettings.depthPercent,
label = "Depth Percentage",
isDelayed = true,
};
outputDepthPercentage.RegisterValueChangedCallback(e =>
{
owner.RegisterCompleteObjectUndo("Updated Depth " + e.newValue);
node.rtSettings.depthPercent = e.newValue;
onChanged?.Invoke();
});
this.Add(outputDepthPercentage);
}
}
// Dimension and Pixel Format
var formatHeader = new Label("Format");
formatHeader.AddToClassList("PropertyEditorHeader");
this.Add(formatHeader);
outputDimension = new EnumField(node.rtSettings.dimension)
{
label = "Dimension",
};
outputDimension.RegisterValueChangedCallback(e => {
owner.RegisterCompleteObjectUndo("Updated Texture Dimension " + e.newValue);
node.rtSettings.dimension = (OutputDimension)e.newValue;
onChanged?.Invoke();
});
outputFormat = new EnumField(node.rtSettings.targetFormat)
{
label = "Pixel Format",
};
outputFormat.RegisterValueChangedCallback(e => {
owner.RegisterCompleteObjectUndo("Updated Graphics Format " + e.newValue);
node.rtSettings.targetFormat = (OutputFormat)e.newValue;
onChanged?.Invoke();
});
this.Add(outputDimension);
this.Add(outputFormat);
UpdateFieldVisibility(node);
if (owner.graph.isRealtime)
{
AddRealtimeFields(node, owner);
}
}
void ReloadSettingsView()
{
// Remove all old fields
Clear();
if (title != null)
{
var titleLabel = new Label(title);
titleLabel.AddToClassList("PropertyEditorTitle");
this.Add(titleLabel);
}
var dimension = settings.GetResolvedTextureDimension(graph);
// Wrap and Filter Modes
smpHeader = new Label("Sampler States");
smpHeader.AddToClassList(headerStyleClass);
this.Add(smpHeader);
wrapMode = showSettingsForNode ? new EnumField(settings.wrapMode) : new EnumField((GraphOutputWrapMode)settings.wrapMode);
wrapMode.label = "Wrap Mode";
wrapMode.RegisterValueChangedCallback(e =>
{
owner.RegisterCompleteObjectUndo("Updated Wrap Mode " + e.newValue);
settings.wrapMode = (OutputWrapMode)e.newValue;
onChanged?.Invoke();
});
filterMode = showSettingsForNode ? new EnumField(settings.filterMode) : new EnumField((GraphOutputFilterMode)settings.filterMode);
filterMode.label = "Filter Mode";
filterMode.RegisterValueChangedCallback(e =>
{
owner.RegisterCompleteObjectUndo("Updated Filter Mode " + e.newValue);
settings.filterMode = (OutputFilterMode)e.newValue;
onChanged?.Invoke();
});
this.Add(wrapMode);
this.Add(filterMode);
// Size Modes
sizeHeader = new Label("Size Properties");
sizeHeader.AddToClassList(headerStyleClass);
this.Add(sizeHeader);
outputSizeMode = showSettingsForNode ? new EnumField(settings.sizeMode) : new EnumField((GraphOutputSizeMode)settings.sizeMode);
outputSizeMode.label = "Size Mode";
outputSizeMode.RegisterValueChangedCallback((EventCallback <ChangeEvent <Enum> >)(e => {
owner.RegisterCompleteObjectUndo("Updated Size mode " + e.newValue);
settings.sizeMode = (OutputSizeMode)e.newValue;
onChanged?.Invoke();
ReloadSettingsView();
UpdateFieldVisibility(settings);
}));
this.Add(outputSizeMode);
potSize = new EnumField(settings.potSize)
{
value = settings.potSize,
label = "Resolution",
};
potSize.RegisterValueChangedCallback(e =>
{
owner.RegisterCompleteObjectUndo("Updated Size " + e.newValue);
var size = (POTSize)e.newValue;
settings.potSize = size;
if (size != POTSize.Custom)
{
settings.width = (int)size;
settings.height = (int)size;
settings.depth = (int)size;
}
else
{
settings.width = outputWidth.value;
settings.height = outputHeight.value;
if (outputDepth != null)
{
settings.depth = outputDepth.value;
}
}
onChanged?.Invoke();
ReloadSettingsView();
UpdateFieldVisibility(settings);
});
this.Add(potSize);
outputWidth = new IntegerField()
{
value = settings.width,
label = "Width",
isDelayed = true,
};
outputWidth.RegisterValueChangedCallback(e =>
{
owner.RegisterCompleteObjectUndo("Updated Width " + e.newValue);
settings.width = e.newValue;
onChanged?.Invoke();
});
this.Add(outputWidth);
outputWidthScale = CreateSizeScaleSlider(settings.widthScale, (v) => settings.widthScale = v, "Width Scale");
this.Add(outputWidthScale);
if (dimension != TextureDimension.Cube)
{
outputHeight = new IntegerField()
{
value = settings.height,
label = "Height",
isDelayed = true,
};
outputHeight.RegisterValueChangedCallback(e =>
{
owner.RegisterCompleteObjectUndo("Updated Height " + e.newValue);
settings.height = e.newValue;
onChanged?.Invoke();
});
this.Add(outputHeight);
outputHeightScale = CreateSizeScaleSlider(settings.heightScale, v => settings.heightScale = v, "Height Scale");
this.Add(outputHeightScale);
if (dimension == TextureDimension.Tex3D)
{
outputDepth = new IntegerField()
{
value = settings.depth,
label = "Depth",
isDelayed = true,
};
outputDepth.RegisterValueChangedCallback(e =>
{
owner.RegisterCompleteObjectUndo("Updated Depth " + e.newValue);
settings.depth = e.newValue;
onChanged?.Invoke();
});
this.Add(outputDepth);
outputDepthScale = CreateSizeScaleSlider(settings.depthScale, v => settings.depthScale = v, "Depth Scale");
this.Add(outputDepthScale);
}
}
SliderInt CreateSizeScaleSlider(float defaultValue, Action <float> setter, string propertyName)
{
var slider = new SliderInt(0, (int)(Mathf.Log(k_MaxSizeScale, 2) * 2))
{
value = SizeScaleToInt(settings.heightScale),
label = propertyName,
};
slider.RegisterValueChangedCallback(e =>
{
owner.RegisterCompleteObjectUndo(propertyName + " " + e.newValue);
setter(IntToSizeScale(e.newValue));
onChanged?.Invoke();
});
return(slider);
}
// Dimension and Pixel Format
formatHeader = new Label("Format");
formatHeader.AddToClassList(headerStyleClass);
this.Add(formatHeader);
outputDimension = showSettingsForNode ? new EnumField(settings.dimension) : new EnumField((GraphOutputDimension)settings.dimension);
outputDimension.label = "Dimension";
outputDimension.RegisterValueChangedCallback(e => {
owner.RegisterCompleteObjectUndo("Updated Texture Dimension " + e.newValue);
// Check if the new texture is not too high res:
settings.dimension = (OutputDimension)e.newValue;
if (settings.dimension == OutputDimension.Texture3D)
{
long pixelCount = settings.GetResolvedWidth(graph) * settings.GetResolvedHeight(graph) * settings.GetResolvedDepth(graph);
// Above 16M pixels in a texture3D, processing can take too long and crash the GPU when a conversion happen
if (pixelCount > 16777216)
{
settings.sizeMode = OutputSizeMode.Absolute;
settings.SetPOTSize(64);
}
}
onChanged?.Invoke();
ReloadSettingsView();
});
outputChannels = showSettingsForNode ? new EnumField(settings.outputChannels) : new EnumField((GraphOutputChannel)settings.outputChannels);
outputChannels.label = "Output Channels";
outputChannels.RegisterValueChangedCallback(e => {
owner.RegisterCompleteObjectUndo("Updated Output Channels " + e.newValue);
settings.outputChannels = (OutputChannel)e.newValue;
onChanged?.Invoke();
});
outputPrecision = showSettingsForNode ? new EnumField(settings.outputPrecision) : new EnumField((GraphOutputPrecision)settings.outputPrecision);
outputPrecision.label = "Output Precision";
outputPrecision.RegisterValueChangedCallback(e => {
owner.RegisterCompleteObjectUndo("Updated Output Precision " + e.newValue);
settings.outputPrecision = (OutputPrecision)e.newValue;
// outputPrecision.Init();
onChanged?.Invoke();
});
this.Add(outputDimension);
this.Add(outputChannels);
this.Add(outputPrecision);
UpdateFieldVisibility(settings);
if (showSettingsForNode)
{
// Realtime fields and refresh mode
otherHeader = new Label("Other");
otherHeader.AddToClassList(headerStyleClass);
this.Add(otherHeader);
doubleBuffered = new Toggle("Double Buffered")
{
value = settings.doubleBuffered,
};
doubleBuffered.RegisterValueChangedCallback(e => {
owner.RegisterCompleteObjectUndo("Set Double Buffered " + e.newValue);
settings.doubleBuffered = e.newValue;
onChanged?.Invoke();
});
Add(doubleBuffered);
}
else if (graph.type == MixtureGraphType.Realtime)
{
otherHeader = new Label("Realtime");
otherHeader.AddToClassList(headerStyleClass);
this.Add(otherHeader);
AddRealtimeFields(owner);
}
}