Exemple #1
0
        /// <summary>
        /// Handles the Click event of the ButtonImagePath control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param>
        private void ButtonImagePath_Click(object sender, EventArgs e)
        {
            Cursor.Current = Cursors.WaitCursor;

            IGorgonImage image = null;
            var          png   = new GorgonCodecPng();

            try
            {
                if (DialogOpenPng.ShowDialog(this) != DialogResult.OK)
                {
                    return;
                }

                TextImagePath.Text = DialogOpenPng.FileName;
                _sourceTexture?.Texture?.Dispose();
                _outputTexture?.Dispose();
                _sourceTexture = null;
                _outputTexture = null;

                image          = png.LoadFromFile(DialogOpenPng.FileName);
                _sourceTexture = image.ConvertToFormat(BufferFormat.R8G8B8A8_UNorm)
                                 .ToTexture2D(_graphics,
                                              new GorgonTexture2DLoadOptions
                {
                    Name =
                        Path.GetFileNameWithoutExtension(DialogOpenPng.FileName)
                }).GetShaderResourceView();

                _outputTexture = new GorgonTexture2D(_graphics,
                                                     new GorgonTexture2DInfo(_sourceTexture, "Output")
                {
                    Format  = BufferFormat.R8G8B8A8_Typeless,
                    Binding = TextureBinding.ShaderResource | TextureBinding.ReadWriteView
                });

                // Get an SRV for the output texture so we can render it later.
                _outputView = _outputTexture.GetShaderResourceView(BufferFormat.R8G8B8A8_UNorm);

                // Get a UAV for the output.
                _outputUav = _outputTexture.GetReadWriteView(BufferFormat.R32_UInt);

                // Process the newly loaded texture.
                _sobel.Process(_sourceTexture, _outputUav, TrackThickness.Value, TrackThreshold.Value / 100.0f);

                TrackThreshold.Enabled = TrackThickness.Enabled = true;
            }
            catch (Exception ex)
            {
                GorgonDialogs.ErrorBox(this, ex);
                TrackThreshold.Enabled = TrackThickness.Enabled = false;
            }
            finally
            {
                image?.Dispose();
                Cursor.Current = Cursors.Default;
            }
        }
Exemple #2
0
        public void Test2DStagingFail()
        {
            GorgonTexture2D texture = null;

            try
            {
                texture = _framework.Graphics.Textures.CreateTexture("Test2D",
                                                                     new GorgonTexture2DSettings
                {
                    Width      = 256,
                    Height     = 256,
                    ArrayCount = 1,
                    Format     = BufferFormat.R8G8B8A8,
                    MipCount   = 1,
                    AllowUnorderedAccessViews = false,
                    Usage = BufferUsage.Staging
                });

                texture.GetShaderView(BufferFormat.R8G8B8A8_Int);
            }
            finally
            {
                if (texture != null)
                {
                    texture.Dispose();
                }
            }
        }
Exemple #3
0
        /// <summary>
        /// Releases unmanaged and - optionally - managed resources.
        /// </summary>
        /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
        protected override void Dispose(bool disposing)
        {
            if (!_disposed)
            {
                if (disposing)
                {
                    if (_logo != null)
                    {
                        _logo.Dispose();
                    }

                    if (_2D != null)
                    {
                        _2D.Dispose();
                    }
                }
            }

            _container = null;
            _2D        = null;
            _logo      = null;
            _disposed  = true;

            base.Dispose(disposing);
        }
Exemple #4
0
        /// <summary>
        /// Function to clean up the renderer objects.
        /// </summary>
        private void CleanUpRenderer()
        {
            if (_renderer == null)
            {
                return;
            }

            if (_lastState != null)
            {
                _renderer.End2D(_lastState);
                _lastState = null;
            }

            if (_texture != null)
            {
                _texture.Dispose();
                _texture = null;
            }

            if (_defaultTexture != null)
            {
                _defaultTexture.Dispose();
                _defaultTexture = null;
            }

            if (_swapChain != null)
            {
                _swapChain.Dispose();
                _swapChain = null;
            }

            _clipper  = null;
            _graphics = null;
        }
Exemple #5
0
        /// <summary>
        /// Function to clean up resources used by the effect.
        /// </summary>
        public void FreeResources()
        {
            if (_randomTexture == null)
            {
                return;
            }

            _randomTexture.Dispose();
            _randomTexture = null;
        }
Exemple #6
0
        /// <summary>
        /// Releases unmanaged and - optionally - managed resources.
        /// </summary>
        /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
        protected override void Dispose(bool disposing)
        {
            if (!_disposed)
            {
                if (disposing)
                {
                    // Save our settings.
                    GorgonFontEditorPlugIn.Settings.Save();

                    if (_badGlyphTexture != null)
                    {
                        _badGlyphTexture.Dispose();
                    }

                    // Remove any externally linked dependencies.
                    EditorFile = null;

                    if (Font != null)
                    {
                        Font.Dispose();
                    }

                    if (Renderer != null)
                    {
                        Renderer.Dispose();
                    }

                    if (_textDisplay != null)
                    {
                        _textDisplay.Dispose();
                    }

                    if (_swap != null)
                    {
                        _swap.Dispose();
                    }
                }

                _swap        = null;
                Renderer     = null;
                Font         = null;
                _panel       = null;
                _textDisplay = null;
                _disposed    = true;
            }

            base.Dispose(disposing);
        }
Exemple #7
0
        public void Test2ViewsSameShaderStage()
        {
            GorgonTexture2D texture = null;

            _framework.CreateTestScene(Shaders, Shaders, true);

            try
            {
                using (var data = new GorgonImageData(new GorgonTexture2DSettings
                {
                    Width = 256,
                    Height = 256,
                    ArrayCount = 1,
                    Format = BufferFormat.R8G8B8A8,
                    MipCount = 1,
                    ShaderViewFormat = BufferFormat.R8G8B8A8_Int,
                    AllowUnorderedAccessViews = false,
                    Usage = BufferUsage.Default
                }))
                {
                    for (int i = 0; i < 5000; i++)
                    {
                        data.Buffers[0].Data.Position = ((GorgonRandom.RandomInt32(0, 256) * data.Buffers[0].PitchInformation.RowPitch)
                                                         + GorgonRandom.RandomInt32(0, 256) * 4);
                        data.Buffers[0].Data.Write((int)((GorgonRandom.RandomSingle() * 2.0f - 1.0f) * (Int32.MaxValue - 2)));
                    }

                    texture = _framework.Graphics.Textures.CreateTexture <GorgonTexture2D>("Test2D", data);
                }

                GorgonTextureShaderView view = texture.GetShaderView(BufferFormat.R8G8B8A8_UIntNormal);

                _framework.Graphics.Shaders.PixelShader.Resources[0] = texture;
                _framework.Graphics.Shaders.PixelShader.Resources[1] = view;

                Assert.IsTrue(_framework.Run() == DialogResult.Yes);
            }
            finally
            {
                if (texture != null)
                {
                    texture.Dispose();
                }
            }
        }
Exemple #8
0
        /// <summary>
        /// Function to convert the image to use our custom codec.
        /// </summary>
        private void ConvertImage()
        {
            // The path to our image file for our custom codec.
            string tempPath = Path.ChangeExtension(Path.GetTempPath().FormatDirectory(Path.DirectorySeparatorChar) + Path.GetRandomFileName(), "Useless");
            // The new texture holding image data read by the custom codec.
            GorgonTexture2D newTexture = null;

            try
            {
                // Save the current texture using our useless new custom codec.
                _image.Save(tempPath, _customCodec);

                newTexture = _graphics.Textures.FromFile <GorgonTexture2D>("UselessTexture", tempPath, _customCodec);

                // Free the old texture and assign to the new one.
                _image.Dispose();
                _image = newTexture;
            }
            catch
            {
                // Clean up the new texture should we have an exception (this shouldn't happen, better safe than sorry).
                if (newTexture != null)
                {
                    newTexture.Dispose();
                }

                throw;
            }
            finally
            {
                try
                {
                    File.Delete(tempPath);
                }
                // ReSharper disable once EmptyGeneralCatchClause
                catch
                {
                    // Intentionally left blank.
                    // If we can't clean up the temp file, then it's no big deal right now.
                }
            }
        }
Exemple #9
0
 /// <summary>Function to dispose any texture resources.</summary>
 protected override void OnDestroyTexture()
 {
     _texture?.Dispose();
     _texture     = null;
     _textureView = null;
 }
Exemple #10
0
        public void TestAutoSRV()
        {
            GorgonTexture1D _1D = null;
            GorgonTexture2D _2D = null;
            GorgonTexture3D _3D = null;

            try
            {
                _1D = _framework.Graphics.Textures.CreateTexture("Test1D",
                                                                 new GorgonTexture1DSettings
                {
                    Width                     = 256,
                    ArrayCount                = 1,
                    Format                    = BufferFormat.R8_UIntNormal,
                    MipCount                  = 1,
                    ShaderViewFormat          = BufferFormat.Unknown,
                    AllowUnorderedAccessViews = false,
                    Usage                     = BufferUsage.Default
                });

                Assert.IsNotNull((GorgonShaderView)_1D);
                Assert.AreEqual(_1D.Settings.Format, ((GorgonShaderView)_1D).Format);

                _2D = _framework.Graphics.Textures.CreateTexture("Test2D",
                                                                 new GorgonTexture2DSettings
                {
                    Width                     = 256,
                    Height                    = 256,
                    ArrayCount                = 1,
                    Format                    = BufferFormat.R8G8B8A8_UIntNormal,
                    MipCount                  = 1,
                    ShaderViewFormat          = BufferFormat.Unknown,
                    AllowUnorderedAccessViews = false,
                    Usage                     = BufferUsage.Default
                });

                Assert.IsNotNull((GorgonShaderView)_2D);
                Assert.AreEqual(_2D.Settings.Format, ((GorgonShaderView)_2D).Format);

                _3D = _framework.Graphics.Textures.CreateTexture("Test3D",
                                                                 new GorgonTexture3DSettings
                {
                    Width                     = 256,
                    Height                    = 256,
                    Depth                     = 64,
                    Format                    = BufferFormat.R8G8B8A8_UIntNormal,
                    MipCount                  = 1,
                    ShaderViewFormat          = BufferFormat.Unknown,
                    AllowUnorderedAccessViews = false,
                    Usage                     = BufferUsage.Default
                });

                Assert.IsNotNull((GorgonShaderView)_3D);
                Assert.AreEqual(_3D.Settings.Format, ((GorgonShaderView)_3D).Format);
            }
            finally
            {
                if (_1D != null)
                {
                    _1D.Dispose();
                }

                if (_2D != null)
                {
                    _2D.Dispose();
                }

                if (_3D != null)
                {
                    _3D.Dispose();
                }
            }
        }
Exemple #11
0
        static void Main()
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);

            try
            {
                Initialize();

                Gorgon.Run(_form, Idle);
            }
            catch (Exception ex)
            {
                GorgonException.Catch(ex, () => GorgonDialogs.ErrorBox(null, ex));
            }
            finally
            {
                if (_materialBuffer != null)
                {
                    _materialBuffer.Dispose();
                }

                if (_normalEarfMap != null)
                {
                    _normalEarfMap.Dispose();
                }

                if (_normalMap != null)
                {
                    _normalMap.Dispose();
                }

                if (_specEarfMap != null)
                {
                    _specEarfMap.Dispose();
                }

                if (_specMap != null)
                {
                    _specMap.Dispose();
                }

                if (_cloudMap != null)
                {
                    _cloudMap.Dispose();
                }

                if (_clouds != null)
                {
                    _clouds.Dispose();
                }

                if (_sphere != null)
                {
                    _sphere.Dispose();
                }

                if (_light != null)
                {
                    _light.Dispose();
                }

                if (_cube != null)
                {
                    _cube.Dispose();
                }

                if (_plane != null)
                {
                    _plane.Dispose();
                }

                if (_triangle != null)
                {
                    _triangle.Dispose();
                }

                if (_wvp != null)
                {
                    _wvp.Dispose();
                }

                if (_renderer2D != null)
                {
                    _renderer2D.Dispose();
                }

                if (_swapChain != null)
                {
                    _swapChain.Dispose();
                }

                if (_graphics != null)
                {
                    _graphics.Dispose();
                }
            }
        }
Exemple #12
0
        /// <summary>
        /// Handles the Click event of the buttonOpen control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param>
        private void buttonOpen_Click(object sender, EventArgs e)
        {
            DisableNumericLimits();

            numericWidth.ValueChanged  -= numericX_ValueChanged;
            numericHeight.ValueChanged -= numericX_ValueChanged;
            numericX.ValueChanged      -= numericX_ValueChanged;
            numericY.ValueChanged      -= numericX_ValueChanged;

            try
            {
                if (!string.IsNullOrWhiteSpace(GorgonFontEditorPlugIn.Settings.LastTextureImportPath))
                {
                    imageFileBrowser.StartDirectory = GorgonFontEditorPlugIn.Settings.LastTextureImportPath;
                }

                imageFileBrowser.FileTypes.Clear();
                imageFileBrowser.FileTypes.Add(ImageEditor.ContentType);

                imageFileBrowser.FileView = GorgonFontEditorPlugIn.Settings.LastTextureImportDialogView;

                if (imageFileBrowser.ShowDialog(ParentForm) == DialogResult.OK)
                {
                    // Don't load the same image.
                    if ((TextureBrushFile != null) &&
                        (string.Equals(TextureBrushFile.FilePath, imageFileBrowser.Files[0].FilePath)))
                    {
                        return;
                    }

                    Cursor.Current = Cursors.WaitCursor;

                    // Load the image.
                    using (Stream stream = imageFileBrowser.OpenFile())
                    {
                        using (IImageEditorContent imageContent = ImageEditor.ImportContent(imageFileBrowser.Files[0], stream))
                        {
                            if (imageContent.Image.Settings.ImageType != ImageType.Image2D)
                            {
                                GorgonDialogs.ErrorBox(ParentForm, string.Format(Resources.GORFNT_ERR_IMAGE_NOT_2D, imageContent.Name));
                                return;
                            }

                            if ((imageContent.Image.Settings.Format != BufferFormat.R8G8B8A8_UIntNormal_sRGB) &&
                                (imageContent.Image.Settings.Format != BufferFormat.R8G8B8A8_UIntNormal) &&
                                (imageContent.Image.Settings.Format != BufferFormat.B8G8R8A8_UIntNormal) &&
                                (imageContent.Image.Settings.Format != BufferFormat.B8G8R8A8_UIntNormal_sRGB))
                            {
                                GorgonDialogs.ErrorBox(ParentForm,
                                                       string.Format(Resources.GORFNT_BRUSH_IMAGE_WRONG_FORMAT, imageFileBrowser.Files[0].Filename, imageContent.Image.Settings.Format));
                                return;
                            }

                            // If we've loaded a texture previously and haven't committed it yet, then get rid of it.
                            if (_texture != null)
                            {
                                _texture.Dispose();
                            }

                            var settings = (GorgonTexture2DSettings)imageContent.Image.Settings.Clone();
                            _texture = _graphics.Textures.CreateTexture <GorgonTexture2D>(imageContent.Name,
                                                                                          imageContent.Image,
                                                                                          settings);
                            // Reset the texture brush settings.
                            numericWidth.Value  = settings.Width;
                            numericHeight.Value = settings.Height;
                            numericX.Value      = 0;
                            numericY.Value      = 0;
                            comboWrapMode.Text  = Resources.GORFNT_TEXT_TILE;

                            // Function to retrieve the transformation and node point values from the image.
                            InitializeClipper(_texture, new RectangleF(0, 0, settings.Width, settings.Height));

                            TextureBrushFile = imageFileBrowser.Files[0];

                            OnBrushChanged();
                        }
                    }

                    GorgonFontEditorPlugIn.Settings.LastTextureImportPath = Path.GetDirectoryName(imageFileBrowser.Files[0].FilePath).FormatDirectory('/');
                }

                GorgonFontEditorPlugIn.Settings.LastTextureImportDialogView = imageFileBrowser.FileView;
            }
            catch (Exception ex)
            {
                GorgonDialogs.ErrorBox(ParentForm, ex);
            }
            finally
            {
                EnableNumericLimits();

                numericWidth.ValueChanged  += numericX_ValueChanged;
                numericHeight.ValueChanged += numericX_ValueChanged;
                numericX.ValueChanged      += numericX_ValueChanged;
                numericY.ValueChanged      += numericX_ValueChanged;

                Cursor.Current = Cursors.Default;
                UpdateLabelInfo();
                ValidateCommands();
            }
        }