private void OnDisable()
{
if (_previewMode != PreviewMode.None)
{
_tween.progress = 0f;
_tween.direction = 1;
_tween.Apply();
EditorApplication.update -= UpdatePreview;
}
_previewMode = PreviewMode.None;
}
void InitPreview()
{
if (m_PreviewInitialized)
{
return;
}
m_PreviewValid = false;
m_PreviewInitialized = true;
m_PreviewTexture = null;
m_PreviewMipLevel = 0;
m_PreviewMode = PreviewMode.RGB;
if (!ShaderUtil.hardwareSupportsRectRenderTexture)
{
return; // various inspector related preview functionality inside Unity requires this
}
if (!SystemInfo.supports3DTextures)
{
return;
}
var shader = Shader.Find("Hidden/Internal-Texture3D-Preview");
if (shader == null)
{
return;
}
m_PreviewMaterial = new Material(shader);
if (m_PreviewMaterial == null)
{
return;
}
var importer = target as AssetImporter;
if (importer == null)
{
return;
}
m_PreviewTexture = AssetDatabase.LoadAssetAtPath <Texture3D>(importer.assetPath);
if (m_PreviewTexture == null)
{
return;
}
m_PreviewValid = true;
}
private void OnSwapTiles(object sender, EventArgs eventArgs)
{
switch (m_previewMode)
{
case PreviewMode.Preview:
m_groupBoxQuickSettings.Enabled = m_groupBoxCustomSettings.Enabled = false;
m_buttonSwapTiles.Visible = false;
m_buttonDoneSwapping.Visible = true;
m_previewMode = PreviewMode.PickFirst;
break;
}
}
public bool LoadHalo2ModelTag(TagFileName filename)
{
try
{
int index = MdxRender.MM.RegisterModel(filename);
Model3D model = MdxRender.MM.GetModel(index);
//MdxRender.Camera.UpdateCameraByBoundingBox(ref model.m_BoundingBox, 2.0f, 5.0f);
m_PreviewMode = PreviewMode.H2Model;
return(true);
}
catch
{
}
return(false);
}
private void DrawPauseButton()
{
bool shouldBeActive = _previewMode == PreviewMode.Playing || _previewMode == PreviewMode.Paused;
EditorGUI.BeginDisabledGroup(!shouldBeActive);
bool before = _previewMode == PreviewMode.Paused;
bool after = GUILayout.Toggle(before, _pauseContent, _middleStyle);
if (before != after)
{
_previewMode = after ? PreviewMode.Paused : PreviewMode.Playing;
}
EditorGUI.EndDisabledGroup();
}
public bool LoadModelTag(TagFileName tfn)
{
try
{
int index = MdxRender.MM.RegisterModel(tfn);
m_ActiveModel = new Instance3D(MdxRender.MM.GetModel(index));
m_ActiveModel.Model.LevelOfDetail = eLOD.CAUSES_FIRES;
MdxRender.Camera.UpdateCameraByBoundingBox(ref m_ActiveModel.Model.m_BoundingBox, 2.0f, 5.0f);
m_PreviewMode = PreviewMode.Model;
}
catch
{
}
return(false);
}
private void OnDialogLoad(object sender, EventArgs eventArgs)
{
m_textBoxId.Text = m_tileSheet.Id;
m_textBoxDescription.Text = m_tileSheet.Description;
m_textBoxImageSource.Text = m_tileSheet.ImageSource;
m_textBoxTileWidth.Value = m_tileSheet.TileWidth;
m_textBoxTileHeight.Value = m_tileSheet.TileHeight;
m_textBoxLeftMargin.Value = m_tileSheet.MarginWidth;
m_textBoxTopMargin.Value = m_tileSheet.MarginHeight;
m_textBoxSpacingX.Value = m_tileSheet.SpacingWidth;
m_textBoxSpacingY.Value = m_tileSheet.SpacingHeight;
UpdateComboBoxes();
m_customPropertyGrid.LoadProperties(m_tileSheet);
m_bitmapImageSource = null;
m_imageSourceErrorMessge = null;
m_bitmapImageSource = null;
m_imageSourceErrorMessge = null;
try
{
m_bitmapImageSource = LoadUnlockedBitmap(m_tileSheet.ImageSource);
}
catch (Exception exception)
{
m_bitmapImageSource = null;
m_imageSourceErrorMessge = exception.Message;
}
m_previewMode = PreviewMode.Preview;
m_previewMouseDown = false;
m_previewOffset = PointF.Empty;
m_previewGrip = xTile.Dimensions.Location.Origin;
if (m_isNewTileSheet)
{
MarkAsModified();
}
else
{
MarkAsApplied();
}
}
private void UpdatePreview()
{
// if we are paused we dont want to do anything
if (_previewMode != PreviewMode.Playing)
{
return;
}
// keep our delta time to 30fps as unity likes to have a massive delay for our first frame
float dt = Mathf.Min(Time.deltaTime, 0.033f);
_tween.Tick(dt);
if (_tween.progress >= 1f && _tween.wrapMode == WrapMode.Once)
{
_previewMode = PreviewMode.None;
EditorApplication.update -= UpdatePreview;
}
}
private void imageModeButton_Click(object sender, EventArgs e)
{
if (mode == PreviewMode.Zoom)
{
mode = PreviewMode.Fill;
previewPictureBox.Size = panel1.Size;
previewPictureBox.SizeMode = GetFillMode();;
panel1.AutoScrollMinSize = Size.Empty;
panel1.AutoScroll = false;
imageModeButton.Image = Properties.Resources.zoomin;
}
else
{
mode = PreviewMode.Zoom;
previewPictureBox.Size = image.Size;
previewPictureBox.SizeMode = PictureBoxSizeMode.CenterImage;
panel1.AutoScrollMinSize = image.Size;
panel1.AutoScroll = true;
imageModeButton.Image = Properties.Resources.zoomout;
}
}
private void InitializeComponent()
{
this.pictureTracker = new PictureTracker();
this.scalablePictureBoxImpNew1 = new scalablePictureBoxImpNew();
this.SuspendLayout();
//
// pictureTracker
//
this.pictureTracker.BackColor = System.Drawing.Color.Lavender;
this.pictureTracker.Location = new System.Drawing.Point(394, 291);
this.pictureTracker.Name = "pictureTracker";
this.pictureTracker.Size = new System.Drawing.Size(137, 102);
this.pictureTracker.TabIndex = 0;
this.pictureTracker.ZoomRate = 0D;
this.pictureTracker.MouseDown += new System.Windows.Forms.MouseEventHandler(this.pictureTracker_MouseDown);
this.pictureTracker.MouseMove += new System.Windows.Forms.MouseEventHandler(this.pictureTracker_MouseMove);
this.pictureTracker.MouseUp += new System.Windows.Forms.MouseEventHandler(this.pictureTracker_MouseUp);
//
// scalablePictureBoxImpNew1
//
this.scalablePictureBoxImpNew1.AutoScroll = true;
this.scalablePictureBoxImpNew1.AutoScrollMinSize = new System.Drawing.Size(0, 8);
this.scalablePictureBoxImpNew1.CurrentImage = null;
this.scalablePictureBoxImpNew1.Dock = System.Windows.Forms.DockStyle.Fill;
this.scalablePictureBoxImpNew1.Document = null;
this.scalablePictureBoxImpNew1.ImagePreviewMode = PreviewMode.PAN;
this.scalablePictureBoxImpNew1.Location = new System.Drawing.Point(0, 0);
this.scalablePictureBoxImpNew1.Name = "scalablePictureBoxImpNew1";
this.scalablePictureBoxImpNew1.Size = new System.Drawing.Size(586, 417);
this.scalablePictureBoxImpNew1.TabIndex = 1;
this.scalablePictureBoxImpNew1.ZoomMode = ZoomMode.PageWidth;
//
// HTFImageViewerNew
//
this.Controls.Add(this.pictureTracker);
this.Controls.Add(this.scalablePictureBoxImpNew1);
this.Name = "HTFImageViewerNew";
this.Size = new System.Drawing.Size(586, 417);
this.ResumeLayout(false);
}
public void TriangualtePreview(PreviewMode previewMode, CubeOrientate orientate, CubeData data,
CharacherCubeControlType type)
{
mode = previewMode;
PreviewOrientate = orientate;
controlType = type;
Clear();
if (mode == PreviewMode.cube)
{
TriangulateCube(transform.position, data);
}
else
{
TriangulatePreviewWire(orientate);
if (controlType == CharacherCubeControlType.add)
{
TriangualteAllCubes(orientate);
}
}
Apply();
}
public bool LoadAnimationTag(TagFileName tfn)
{
m_AnimationLoaded = false;
try
{
m_activeAnimationTag = new Animations();
m_activeAnimationTag.LoadTagBuffer(tfn);
m_activeAnimationTag.LoadTagData();
m_ActiveModel.InitializeAnimationProcessing();
m_activeAnimationTag.ActivateAnimation(0);
m_PreviewMode = PreviewMode.Animation;
}
catch (Exception ex)
{
throw new PrometheusException(
"Error loading animation tag: " + tfn.RelativePath,
ex,
true);
}
m_AnimationLoaded = true;
return(false);
}
void DrawPreviewControls()
{
GUIStyle foldoutStyle = EditorStyles.foldout;
foldoutStyle.fontStyle = FontStyle.Bold;
// Preview settings.
GUILayout.Space(5);
previewSettingsFoldout = EditorGUILayout.BeginFoldoutHeaderGroup(previewSettingsFoldout, "Preview settings", foldoutStyle);
if (previewSettingsFoldout)
{
EditorGUI.indentLevel++;
previewType = (PreviewType)EditorGUILayout.EnumPopup("Preview type", previewType);
EditorGUI.indentLevel++;
if (currentWindowTab == 0)
{
textureModule.DrawPreviewControls(previewType);
}
else
{
toolsModule.DrawPreviewControls(previewType);
}
EditorGUI.indentLevel--;
previewMode = (PreviewMode)EditorGUILayout.Popup("Live preview", (int)previewMode, previewModeStrings);
EditorGUI.indentLevel--;
}
EditorGUILayout.EndFoldoutHeaderGroup();
GUILayout.Space(5);
}
private void OnDoneSwapping(object sender, EventArgs eventArgs)
{
m_previewMode = PreviewMode.Preview;
m_buttonDoneSwapping.Visible = false;
m_buttonSwapTiles.Visible = true;
m_groupBoxQuickSettings.Enabled = m_groupBoxCustomSettings.Enabled = true;
m_customTabControl.Enabled = true;
}
public override void OnPreviewSettings()
{
if (IsCubemap())
{
m_CubemapPreview.OnPreviewSettings(targets);
return;
}
if (IsTexture2DArray() && !SystemInfo.supports2DArrayTextures)
{
return;
}
if (s_Styles == null)
{
s_Styles = new Styles();
}
// TextureInspector code is reused for RenderTexture and Cubemap inspectors.
// Make sure we can handle the situation where target is just a Texture and
// not a Texture2D. It's also used for large popups for mini texture fields,
// and while it's being shown the actual texture object might disappear --
// make sure to handle null targets.
Texture tex = target as Texture;
bool alphaOnly = false;
bool hasAlpha = true;
int mipCount = 1;
if (target is Texture2D)
{
alphaOnly = true;
hasAlpha = false;
}
foreach (Texture t in targets)
{
if (t == null) // texture might have disappeared while we're showing this in a preview popup
{
continue;
}
TextureFormat format = 0;
bool checkFormat = false;
if (t is Texture2D)
{
format = (t as Texture2D).format;
checkFormat = true;
}
if (checkFormat)
{
if (!TextureUtil.IsAlphaOnlyTextureFormat(format))
{
alphaOnly = false;
}
if (TextureUtil.HasAlphaTextureFormat(format))
{
TextureUsageMode mode = TextureUtil.GetUsageMode(t);
if (mode == TextureUsageMode.Default) // all other texture usage modes don't displayable alpha
{
hasAlpha = true;
}
}
}
mipCount = Mathf.Max(mipCount, TextureUtil.GetMipmapCount(t));
}
List <PreviewMode> previewCandidates = new List <PreviewMode>(5);
previewCandidates.Add(PreviewMode.RGB);
previewCandidates.Add(PreviewMode.R);
previewCandidates.Add(PreviewMode.G);
previewCandidates.Add(PreviewMode.B);
previewCandidates.Add(PreviewMode.A);
if (alphaOnly)
{
previewCandidates.Clear();
previewCandidates.Add(PreviewMode.A);
m_PreviewMode = PreviewMode.A;
}
else if (!hasAlpha)
{
previewCandidates.Remove(PreviewMode.A);
}
if (previewCandidates.Count > 1 && tex != null && !IsNormalMap(tex))
{
int selectedIndex = previewCandidates.IndexOf(m_PreviewMode);
if (selectedIndex == -1)
{
selectedIndex = 0;
}
if (previewCandidates.Contains(PreviewMode.RGB))
{
m_PreviewMode = GUILayout.Toggle(m_PreviewMode == PreviewMode.RGB, s_Styles.previewButtonContents[0], s_Styles.toolbarButton)
? PreviewMode.RGB
: m_PreviewMode;
}
if (previewCandidates.Contains(PreviewMode.R))
{
m_PreviewMode = GUILayout.Toggle(m_PreviewMode == PreviewMode.R, s_Styles.previewButtonContents[1], s_Styles.toolbarButton)
? PreviewMode.R
: m_PreviewMode;
}
if (previewCandidates.Contains(PreviewMode.G))
{
m_PreviewMode = GUILayout.Toggle(m_PreviewMode == PreviewMode.G, s_Styles.previewButtonContents[2], s_Styles.toolbarButton)
? PreviewMode.G
: m_PreviewMode;
}
if (previewCandidates.Contains(PreviewMode.B))
{
m_PreviewMode = GUILayout.Toggle(m_PreviewMode == PreviewMode.B, s_Styles.previewButtonContents[3], s_Styles.toolbarButton)
? PreviewMode.B
: m_PreviewMode;
}
if (previewCandidates.Contains(PreviewMode.A))
{
m_PreviewMode = GUILayout.Toggle(m_PreviewMode == PreviewMode.A, s_Styles.previewButtonContents[4], s_Styles.toolbarButton)
? PreviewMode.A
: m_PreviewMode;
}
}
if (mipCount > 1)
{
GUILayout.Box(s_Styles.smallZoom, s_Styles.previewLabel);
GUI.changed = false;
m_MipLevel = Mathf.Round(GUILayout.HorizontalSlider(m_MipLevel, mipCount - 1, 0, s_Styles.previewSlider, s_Styles.previewSliderThumb, GUILayout.MaxWidth(64)));
//For now, we don't have mipmaps smaller than the tile size when using VT.
if (EditorGUI.UseVTMaterial(tex))
{
int numMipsOfTile = (int)Mathf.Log(VirtualTexturing.EditorHelpers.tileSize, 2) + 1;
m_MipLevel = Mathf.Min(m_MipLevel, Mathf.Max(mipCount - numMipsOfTile, 0));
}
GUILayout.Box(s_Styles.largeZoom, s_Styles.previewLabel);
}
}
public void InitView(PreviewMode pMode, String languageCode, lm.Comol.Core.DomainModel.Languages.ItemObjectTranslation content, SmtpServiceConfig smtpConfig, String recipients = "", List <String> modules = null, List <lm.Comol.Core.TemplateMessages.Domain.ChannelSettings> notifications = null, Int32 idCommunity = -1, ModuleObject obj = null)
{
InitView(pMode, languageCode, content, smtpConfig, recipients, modules, (notifications != null && notifications.Where(n => n.Channel == lm.Comol.Core.Notification.Domain.NotificationChannel.Mail).Any()) ? notifications.Where(n => n.Channel == lm.Comol.Core.Notification.Domain.NotificationChannel.Mail).Select(n => n.MailSettings).FirstOrDefault() : null, idCommunity, obj);
}
private void OnPreviewMouseDown(object sender, MouseEventArgs mouseEventArgs)
{
if (mouseEventArgs.Button == MouseButtons.Left)
{
switch (m_previewMode)
{
case PreviewMode.Preview:
m_previewMouseDown = true;
m_previewGrip.X = mouseEventArgs.X;
m_previewGrip.Y = mouseEventArgs.Y;
break;
case PreviewMode.PickFirst:
{
Location pixelLocation = new Location(mouseEventArgs.X, mouseEventArgs.Y);
pixelLocation.X /= m_trackBarZoom.Value;
pixelLocation.Y /= m_trackBarZoom.Value;
pixelLocation.X -= (int)m_previewOffset.X;
pixelLocation.Y -= (int)m_previewOffset.Y;
m_swapTileIndex1 = m_tileSheet.GetTileIndex(pixelLocation);
m_previewMode = PreviewMode.PickSecond;
m_panelImage.Invalidate();
}
break;
case PreviewMode.PickSecond:
{
Cursor oldCursor = this.Cursor;
this.Cursor = Cursors.WaitCursor;
Location pixelLocation = new Location(mouseEventArgs.X, mouseEventArgs.Y);
pixelLocation.X /= m_trackBarZoom.Value;
pixelLocation.Y /= m_trackBarZoom.Value;
pixelLocation.X -= (int)m_previewOffset.X;
pixelLocation.Y -= (int)m_previewOffset.Y;
m_swapTileIndex2 = m_tileSheet.GetTileIndex(pixelLocation);
if (m_swapTileIndex1 != m_swapTileIndex2)
{
Command command = new TileSheetSwapTilesCommand(m_tileSheet, m_swapTileIndex1, m_swapTileIndex2);
CommandHistory.Instance.Do(command);
m_bitmapImageSource = LoadUnlockedBitmap(m_tileSheet.ImageSource);
}
this.Cursor = oldCursor;
m_previewMode = PreviewMode.PickFirst;
m_panelImage.Invalidate();
}
break;
}
}
}
private void imageModeButton_Click(object sender, EventArgs e)
{
if (mode == PreviewMode.Zoom) {
mode = PreviewMode.Fill;
previewPictureBox.Size = panel1.Size;
previewPictureBox.SizeMode = GetFillMode(); ;
panel1.AutoScrollMinSize = Size.Empty;
panel1.AutoScroll = false;
imageModeButton.Image = Properties.Resources.zoomin;
}
else {
mode = PreviewMode.Zoom;
previewPictureBox.Size = image.Size;
previewPictureBox.SizeMode = PictureBoxSizeMode.CenterImage;
panel1.AutoScrollMinSize = image.Size;
panel1.AutoScroll = true;
imageModeButton.Image = Properties.Resources.zoomout;
}
}
public abstract void SetPreviewMode(PreviewMode mode);
//public static bool cacheTiling = false;
public static async Task DoUpscale(string inpath, string outpath, ModelData mdl, bool cacheSplitDepth, bool alpha, PreviewMode mode, Backend backend, bool showTileProgress = true)
{
Program.cancelled = false; // Reset cancel flag
try
{
if (backend == Backend.NCNN)
{
Program.lastModelName = mdl.model1Name;
await RunNcnn(inpath, outpath, mdl.model1Path);
}
else
{
Program.mainForm.SetProgress(2f, "Starting ESRGAN...");
File.Delete(Paths.progressLogfile);
string modelArg = GetModelArg(mdl);
await RunJoey(inpath, outpath, modelArg, cacheSplitDepth, alpha, showTileProgress);
}
if (mode == PreviewMode.Cutout)
{
await ScalePreviewOutput();
Program.mainForm.SetProgress(100f, "Merging into preview...");
await Program.PutTaskDelay();
PreviewMerger.Merge();
Program.mainForm.SetHasPreview(true);
}
if (mode == PreviewMode.FullImage)
{
await ScalePreviewOutput();
Program.mainForm.SetProgress(100f, "Merging into preview...");
await Program.PutTaskDelay();
Image outImg = ImgUtils.GetImage(Directory.GetFiles(Paths.previewOutPath, "preview.*", SearchOption.AllDirectories)[0]);
Image inputImg = ImgUtils.GetImage(Paths.tempImgPath);
PreviewUI.previewImg.Image = outImg;
PreviewUI.currentOriginal = inputImg;
PreviewUI.currentOutput = outImg;
PreviewUI.currentScale = ImgUtils.GetScaleFloat(inputImg, outImg);
PreviewUI.previewImg.ZoomToFit();
Program.mainForm.SetHasPreview(true);
//Program.mainForm.SetProgress(0f, "Done.");
}
}
catch (Exception e)
{
Program.mainForm.SetProgress(0f, "Cancelled.");
if (Program.cancelled)
{
return;
}
if (e.Message.Contains("No such file"))
{
Program.ShowMessage("An error occured during upscaling.\nThe upscale process seems to have exited before completion!", "Error");
}
else
{
Program.ShowMessage("An error occured during upscaling.", "Error");
}
Logger.Log("[ESRGAN] Upscaling Error: " + e.Message + "\n" + e.StackTrace);
}
}
private void DrawAnimationStatePreview()
{
EditorUtilities.Splitter();
var oldPreviewMode = previewMode;
EditorUtilities.DrawHorizontal(() =>
{
EditorGUILayout.LabelField("Preview mode");
EditorGUI.BeginDisabledGroup(previewMode == PreviewMode.Automatic);
if (GUILayout.Button("Automatic"))
{
previewMode = PreviewMode.Automatic;
}
EditorGUI.EndDisabledGroup();
EditorGUI.BeginDisabledGroup(previewMode == PreviewMode.Manual);
if (GUILayout.Button("Manual"))
{
previewMode = PreviewMode.Manual;
}
EditorGUI.EndDisabledGroup();
});
if (oldPreviewMode == PreviewMode.Manual && previewMode == PreviewMode.Automatic)
{
automaticPreviewLastTime = Time.realtimeSinceStartup;
}
if (previewMode == PreviewMode.Manual)
{
var oldPreviewTime = previewTime;
previewTime = EditorGUILayout.Slider(previewTime, 0f, currentPreviewedState.Duration);
previewGraph.Evaluate(previewTime - oldPreviewTime);
}
else
{
var currentTime = Time.realtimeSinceStartup;
var deltaTime = currentTime - automaticPreviewLastTime;
automaticPreviewLastTime = currentTime;
previewTime = (previewTime + deltaTime) % currentPreviewedState.Duration;
previewGraph.Evaluate(deltaTime);
var oldVal = previewTime;
previewTime = EditorGUILayout.Slider(previewTime, 0f, currentPreviewedState.Duration);
if (oldVal != previewTime)
{
previewMode = PreviewMode.Manual;
}
}
SceneView.RepaintAll();
if (GUILayout.Button("Stop preview"))
{
StopPreviewing();
}
}
public static extern void getCameraMode(ref PreviewMode Mode);
public void DoRenderPreview(RenderTexture renderTexture, Material mat, Mesh mesh, PreviewMode mode, bool allowSRP, float time, MaterialPropertyBlock properties = null)
{
if (mat == null || mat.shader == null)
{
return;
}
m_Camera.targetTexture = renderTexture;
if (mode == PreviewMode.Preview3D)
{
m_Camera.transform.position = -Vector3.forward * 5;
m_Camera.transform.rotation = Quaternion.identity;
m_Camera.orthographic = false;
}
else
{
m_Camera.transform.position = -Vector3.forward * 2;
m_Camera.transform.rotation = Quaternion.identity;
m_Camera.orthographicSize = 1;
m_Camera.orthographic = true;
}
m_Camera.targetTexture = renderTexture;
var previousRenderTexure = RenderTexture.active;
RenderTexture.active = renderTexture;
GL.Clear(true, true, Color.black);
Graphics.Blit(Texture2D.whiteTexture, renderTexture, m_CheckerboardMaterial);
EditorUtility.SetCameraAnimateMaterialsTime(m_Camera, time);
Light0.enabled = true;
Light0.intensity = 1.0f;
Light0.transform.rotation = Quaternion.Euler(50f, 50f, 0);
Light1.enabled = true;
Light1.intensity = 1.0f;
m_Camera.clearFlags = CameraClearFlags.Depth;
Mesh previewMesh = mesh == null ? s_Meshes[0] : mesh;
Graphics.DrawMesh(
mode == PreviewMode.Preview3D ? previewMesh : quad,
mode == PreviewMode.Preview3D ? Matrix4x4.TRS(-previewMesh.bounds.center, Quaternion.identity, Vector3.one) : Matrix4x4.identity,
mat,
1,
m_Camera,
0,
properties,
ShadowCastingMode.Off,
false,
null,
false);
var oldAllowPipes = Unsupported.useScriptableRenderPipeline;
Unsupported.useScriptableRenderPipeline = allowSRP;
m_Camera.Render();
Unsupported.useScriptableRenderPipeline = oldAllowPipes;
RenderTexture.active = previousRenderTexure;
Light0.enabled = false;
Light1.enabled = false;
}
private void OnDialogLoad(object sender, EventArgs eventArgs)
{
m_textBoxId.Text = m_tileSheet.Id;
m_textBoxDescription.Text = m_tileSheet.Description;
m_textBoxImageSource.Text = m_tileSheet.ImageSource;
m_textBoxTileWidth.Value = m_tileSheet.TileWidth;
m_textBoxTileHeight.Value = m_tileSheet.TileHeight;
m_textBoxLeftMargin.Value = m_tileSheet.MarginWidth;
m_textBoxTopMargin.Value = m_tileSheet.MarginHeight;
m_textBoxSpacingX.Value = m_tileSheet.SpacingWidth;
m_textBoxSpacingY.Value = m_tileSheet.SpacingHeight;
UpdateComboBoxes();
m_customPropertyGrid.LoadProperties(m_tileSheet);
m_bitmapImageSource = null;
m_imageSourceErrorMessge = null;
m_bitmapImageSource = null;
m_imageSourceErrorMessge = null;
try
{
m_bitmapImageSource = LoadUnlockedBitmap(m_tileSheet.ImageSource);
}
catch (Exception exception)
{
m_bitmapImageSource = null;
m_imageSourceErrorMessge = exception.Message;
}
m_previewMode = PreviewMode.Preview;
m_previewMouseDown = false;
m_previewOffset = PointF.Empty;
m_previewGrip = xTile.Dimensions.Location.Origin;
if (m_isNewTileSheet)
MarkAsModified();
else
MarkAsApplied();
}
private void OnSwapTiles(object sender, EventArgs eventArgs)
{
switch (m_previewMode)
{
case PreviewMode.Preview:
m_groupBoxQuickSettings.Enabled = m_groupBoxCustomSettings.Enabled = false;
m_buttonSwapTiles.Visible = false;
m_buttonDoneSwapping.Visible = true;
m_previewMode = PreviewMode.PickFirst;
break;
}
}
public static async Task DoUpscale(string inpath, string outpath, ModelData mdl, string tilesize, bool alpha, PreviewMode mode, Backend backend, bool showTileProgress = true)
{
bool useJoey = Config.GetInt("esrganVer") == 0;
try
{
if (backend == Backend.NCNN)
{
Program.mainForm.SetProgress(1f, "Loading ESRGAN-NCNN...");
DialogForm dialogForm = new DialogForm("Loading ESRGAN-NCNN...\nThis should take 10-25 seconds.", 14);
Program.lastModelName = mdl.model1Name;
await RunNcnn(inpath, outpath, mdl.model1Path);
}
else
{
Program.mainForm.SetProgress(4f, "Starting ESRGAN...");
File.Delete(Paths.progressLogfile);
string modelArg = GetModelArg(mdl, useJoey);
if (useJoey)
{
await RunJoey(inpath, outpath, modelArg, tilesize, alpha, showTileProgress);
}
else
{
await Run(inpath, outpath, modelArg, tilesize, alpha, showTileProgress);
}
}
if (mode == PreviewMode.Cutout)
{
await ScalePreviewOutput();
Program.mainForm.SetProgress(100f, "Merging into preview...");
await Program.PutTaskDelay();
PreviewMerger.Merge();
Program.mainForm.SetHasPreview(true);
}
if (mode == PreviewMode.FullImage)
{
await ScalePreviewOutput();
Program.mainForm.SetProgress(100f, "Merging into preview...");
await Program.PutTaskDelay();
Image outImg = ImgUtils.GetImage(Directory.GetFiles(Paths.previewOutPath, "*.png.*", SearchOption.AllDirectories)[0]);
Image inputImg = ImgUtils.GetImage(Paths.tempImgPath);
MainUIHelper.previewImg.Image = outImg;
MainUIHelper.currentOriginal = inputImg;
MainUIHelper.currentOutput = outImg;
MainUIHelper.currentScale = ImgUtils.GetScaleFloat(inputImg, outImg);
MainUIHelper.previewImg.ZoomToFit();
Program.mainForm.SetHasPreview(true);
//Program.mainForm.SetProgress(0f, "Done.");
}
}
catch (Exception e)
{
if (e.Message.Contains("No such file"))
{
Program.ShowMessage("An error occured during upscaling.\nThe upscale process seems to have exited before completion!", "Error");
}
else
{
Program.ShowMessage("An error occured during upscaling.", "Error");
}
Logger.Log("[ESRGAN] Upscaling Error: " + e.Message + "\n" + e.StackTrace);
Program.mainForm.SetProgress(0f, "Cancelled.");
}
}
public void SetPreviewMode(PreviewMode mode)
{
m_PreviewMode = mode;
}
public static extern void setCameraMode(PreviewMode Mode);
private void pn3D_DeviceCreated( object sender, EventArgs e )
{
Device dev = pn3D.Device;
Caps caps = dev.DeviceCaps;
btnShadedView.Enabled = vi3DShowShaded.Enabled =
caps.VertexShaderVersion >= new Version( 2, 0 ) &&
caps.PixelShaderVersion >= new Version( 2, 0 );
if( !btnShadedView.Enabled && previewMode == PreviewMode.Shaded )
PreviewMode = PreviewMode.Surfaces;
if( model.Model == null )
return;
lineVertDecl = new VertexDeclaration( dev, LineVertex.DeclarationElements );
if( model.Model.Vertices.Count != 0 )
colorsVb = new VertexBuffer( dev, sizeof( int ) * model.Model.Vertices.Count, Usage.None, VertexFormats.None, Pool.Managed );
{
List<VertexElement> elems = new List<VertexElement>( ModelRenderHelper.ModelVertexPosNormTanBin.DeclarationElements );
elems.Insert( elems.Count - 1, new VertexElement( 1, 0, DeclarationType.Color, DeclarationMethod.Default, DeclarationUsage.Color, 0 ) );
modelVertWithColorDecl = new VertexDeclaration( dev, elems.ToArray() );
}
utilPlane = Mesh.Polygon( dev, 25, 12 );
utilSphere = Mesh.Sphere( dev, 1.0F, 25, 25 );
utilBox = Mesh.Box( dev, 1, 1, 1 );
InitTopoBuffers();
}
