protected bool UpdateTempRenderTexture(ref CustomRenderTexture target, bool hasMips = false, bool autoGenerateMips = false, CustomRenderTextureUpdateMode updateMode = CustomRenderTextureUpdateMode.OnDemand, bool depthBuffer = false, GraphicsFormat overrideGraphicsFormat = GraphicsFormat.None, bool hideAsset = true) { if (graph.mainOutputTexture == null) { return(false); } bool changed = false; int outputWidth = settings.GetResolvedWidth(graph); int outputHeight = settings.GetResolvedHeight(graph); int outputDepth = settings.GetResolvedDepth(graph); var filterMode = settings.GetResolvedFilterMode(graph); var wrapMode = settings.GetResolvedWrapMode(graph); GraphicsFormat targetFormat = overrideGraphicsFormat != GraphicsFormat.None ? overrideGraphicsFormat : settings.GetGraphicsFormat(graph); TextureDimension dimension = GetTempTextureDimension(); outputWidth = Mathf.Max(outputWidth, 1); outputHeight = Mathf.Max(outputHeight, 1); outputDepth = Mathf.Max(outputDepth, 1); if (dimension != TextureDimension.Tex3D) { outputDepth = 1; } if (dimension == TextureDimension.Cube) { outputHeight = outputDepth = outputWidth; // we only use the width for cubemaps } if (targetFormat == GraphicsFormat.None) { targetFormat = graph.mainOutputTexture.graphicsFormat; } if (dimension == TextureDimension.None) { dimension = TextureDimension.Tex2D; } if (dimension == TextureDimension.Tex3D) { depthBuffer = false; } if (target == null) { target = new CustomRenderTexture(outputWidth, outputHeight, targetFormat) { volumeDepth = Math.Max(1, outputDepth), depth = depthBuffer ? 32 : 0, dimension = dimension, name = $"Mixture Temp {name}", updateMode = CustomRenderTextureUpdateMode.OnDemand, doubleBuffered = settings.doubleBuffered, wrapMode = settings.GetResolvedWrapMode(graph), filterMode = settings.GetResolvedFilterMode(graph), useMipMap = hasMips, autoGenerateMips = autoGenerateMips, enableRandomWrite = true, hideFlags = hideAsset ? HideFlags.HideAndDontSave : HideFlags.None, updatePeriod = settings.GetUpdatePeriodInMilliseconds(), }; target.Create(); target.material = MixtureUtils.dummyCustomRenderTextureMaterial; return(true); } // TODO: check if format is supported by current system // Warning: here we use directly the settings from the if (target.width != outputWidth || target.height != outputHeight || target.graphicsFormat != targetFormat || target.dimension != dimension || target.volumeDepth != outputDepth || target.doubleBuffered != settings.doubleBuffered || target.useMipMap != hasMips || target.autoGenerateMips != autoGenerateMips) { target.Release(); target.width = outputWidth; target.height = outputHeight; target.graphicsFormat = (GraphicsFormat)targetFormat; target.dimension = dimension; target.volumeDepth = outputDepth; target.depth = depthBuffer ? 32 : 0; target.doubleBuffered = settings.doubleBuffered; target.useMipMap = hasMips; target.autoGenerateMips = autoGenerateMips; target.enableRandomWrite = true; target.hideFlags = hideAsset ? HideFlags.HideAndDontSave : HideFlags.None; target.Create(); if (target.material == null) { target.material = MixtureUtils.dummyCustomRenderTextureMaterial; } changed = true; } // Patch settings that don't require to re-create the texture target.updateMode = updateMode; target.updatePeriod = settings.GetUpdatePeriodInMilliseconds(); target.wrapMode = settings.GetResolvedWrapMode(graph); target.filterMode = settings.GetResolvedFilterMode(graph); if (target.doubleBuffered) { target.EnsureDoubleBufferConsistency(); var rt = target.GetDoubleBufferRenderTexture(); if (rt.enableRandomWrite != true) { rt.Release(); rt.enableRandomWrite = true; rt.Create(); } } if (!target.IsCreated()) { target.Create(); } return(changed); }
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); } }