Messages

1

DotNet / Re: Crash during resize of UserControl with embedded RenderWindow

« on: April 07, 2015, 08:01:50 pm »

Thanks for the tips!

Why don't you resize the view like you are supposed to do?

I don't know how I missed that section of the View tutorial, but that would probably do the trick. Ideally the RenderControl would work when its DockStyle was set to fill, but that caused a lot of trouble initially... I'll give this a try and report back.

You never dispose the old window

Good catch. Ran into trouble when testing before I'd finished the class, and must have missed that.

Not to mention SFML doesn't exactly play nicely with threads in some situations, so I don't understand why you have all these monitor calls all over

This control will eventually be incorporated into an application where rendering runs in a separate thread than the GUI, as is necessary to keep the GUI from hanging when using a rendering loop. After I shifted construction of all OpenGL-related objects to the rendering thread I haven't had any trouble when using SFML in my multithreaded app... if you have/know of any specific concerns, I'd be happy to hear them, though!

As for their purpose: if the GUI thread calls Destroy/Create at the same time the rendering thread calls Draw (or something) then we might have a race - if m_Window.Dispose had been called but m_Window hadn't yet been set to null, for example, we might try to draw to the disposed object (right...?). These will probably be converted into something more elegant, but during testing they will stay there.

Why don't you just store a context setting struct as a member variable

I had been considering making these changeable, but then I noticed that SFML doesn't let you do this and figured I shouldn't either. In retrospect I don't really know why you'd want to change them anyway. That will be fixed as soon as the more important bits are taken care of.



EDIT: Altering the view as suggested in that tutorial works wonderfully - thanks for the link.
At this point, zsbzsb, I practically owe you a co-author credit on my application

As it stands I believe the class to be fully functional - if there are other concerns to be considered in a multithreaded application, though, I might need to make some changes (e.g. I am not entirely sure which of the built-in RenderWindow functions won't lead to a race, so some uses of Monitor might be unnecessary). I might just do away with the Monitor stuff entirely and assume that it will be handled externally (if needed), as this is more in line with what is expected of SFML.

Feel free to toss any other suggestions my way - revised code below.

(click to show/hide)

using SFML.Graphics;
using SFML.Window;
using System;
using System.Threading;
using System.Windows.Forms;

namespace RenderControl
{
    public partial class RenderControl : UserControl
    {
        private RenderWindow m_Window = null;
        private ContextSettings m_Context;

        public RenderControl(uint depth = 0, uint stencil = 0, uint antialiasing = 0, uint major = 2, uint minor = 0)
        {
            InitializeComponent();

            this.m_Context = new ContextSettings(depth, stencil, antialiasing, major, minor);
            this.SizeChanged += new EventHandler(RenderControl_SizeChanged);
        }
        ~RenderControl()
        {
            this.m_Window.Dispose();
        }

        #region interface

        public void Create()
        {
            Monitor.Enter(this);

            if(this.m_Window != null)
                this.m_Window.Dispose();
            this.m_Window = new RenderWindow(this.Handle, this.m_Context);
            this.m_Window.SetVerticalSyncEnabled(true);

            Monitor.Exit(this);
        }
        public void Destroy()
        {
            Monitor.Enter(this);

            if (this.m_Window != null)
            {
                this.m_Window.Close();
                this.m_Window.Dispose();
                this.m_Window = null;
            }

            Monitor.Exit(this);
        }

        public void DispatchEvents()
        {
            Monitor.Enter(this);

            if (this.m_Window != null)
                this.m_Window.DispatchEvents();

            Monitor.Exit(this);
        }

        public void SetActive(bool active = true)
        {
            Monitor.Enter(this);

            if(this.m_Window != null)
                this.m_Window.SetActive(active);

            Monitor.Exit(this);
        }

        public void Clear()
        {
            Monitor.Enter(this);

            if (this.m_Window != null)
                this.m_Window.Clear(Color.Black);

            Monitor.Exit(this);
        }
        public void Clear(Color color)
        {
            Monitor.Enter(this);

            if (this.m_Window != null)
                this.m_Window.Clear(color);

            Monitor.Exit(this);
        }

        public void Draw(Drawable drawable)
        {
            Monitor.Enter(this);

            if (this.m_Window != null)
                this.m_Window.Draw(drawable);

            Monitor.Exit(this);
        }
        public void Draw(Drawable drawable, RenderStates states)
        {
            Monitor.Enter(this);

            if (this.m_Window != null)
                this.m_Window.Draw(drawable, states);

            Monitor.Exit(this);
        }
        public void Draw(Vertex[] vertices, PrimitiveType type)
        {
            Monitor.Enter(this);

            if (this.m_Window != null)
                this.m_Window.Draw(vertices, type);

            Monitor.Exit(this);
        }
        public void Draw(Vertex[] vertices, PrimitiveType type, RenderStates states)
        {
            Monitor.Enter(this);

            if (this.m_Window != null)
                this.m_Window.Draw(vertices, type, states);

            Monitor.Exit(this);
        }
        public void Draw(Vertex[] vertices, uint start, uint count, PrimitiveType type)
        {
            Monitor.Enter(this);

            if (this.m_Window != null)
                this.m_Window.Draw(vertices, start, count, type);

            Monitor.Exit(this);
        }
        public void Draw(Vertex[] vertices, uint start, uint count, PrimitiveType type, RenderStates states)
        {
            Monitor.Enter(this);

            if (this.m_Window != null)
                this.m_Window.Draw(vertices, start, count, type, states);

            Monitor.Exit(this);
        }

        public void Display()
        {
            Monitor.Enter(this);

            if (this.m_Window != null)
                this.m_Window.Display();

            this.Refresh();

            Monitor.Exit(this);
        }

        #endregion

        #region paint overrides
        protected override void OnPaint(PaintEventArgs e)
        {
            //don't call base method!
            //base.OnPaint(e);
        }
        protected override void OnPaintBackground(PaintEventArgs e)
        {
            //don't call base method!
            //base.OnPaintBackground(e);
        }
        #endregion

        void RenderControl_SizeChanged(object sender, EventArgs e)
        {
            Monitor.Enter(this);

            //need to recreate view when the window changes
            if(this.m_Window != null)
            {
                this.m_Window.SetView(new SFML.Graphics.View(new FloatRect(0f, 0f, this.Size.Width, this.Size.Height)));
            }

            Monitor.Exit(this);
        }
    }
}

2

DotNet / Crash during resize of UserControl with embedded RenderWindow

« on: April 07, 2015, 05:50:17 am »

I'm creating a UserControl for use in a WinForms application which embeds and displays a RenderWindow using the method suggested in this forum post. Everything works well so far except when the control is resized. When the control is resized I want to recreate the embedded RenderWindow with a VideoMode that won't result in stretching, but this often results in the program crashing with no exceptions thrown... VS2013 gives me nothing to work with but a "vshost.exe has stopped working" message. I'm at a complete loss - any ideas for troubleshooting or fixing this are very, very welcome. The pertinent code is below.

(click to show/hide)

using SFML.Graphics;
using SFML.System;
using System;
using System.Windows.Forms;

namespace RenderControl
{
    public partial class Form1 : Form
    {
        RenderControl m_RenderControl = new RenderControl();
        RectangleShape m_Square = new RectangleShape(new Vector2f(20f, 20f));

        public Form1()
        {
            InitializeComponent();
            this.splitContainer1.Panel1.Controls.Add(this.m_RenderControl);
            this.m_RenderControl.Size = this.splitContainer1.Panel1.ClientSize;
            this.m_RenderControl.Create();

            this.m_Square.OutlineColor = Color.Transparent;
            this.m_Square.FillColor = Color.White;

            this.timer1.Start();
        }

        private void timer1_Tick(object sender, EventArgs e)
        {
            this.m_RenderControl.DispatchEvents();
            this.m_RenderControl.Clear();
            this.m_RenderControl.Draw(this.m_Square);
            this.m_RenderControl.Display();
        }

        private void splitContainer1_SplitterMoved(object sender, SplitterEventArgs e)
        {
            this.m_RenderControl.Size = this.splitContainer1.Panel1.ClientSize;
        }
    }
}
 

(click to show/hide)

namespace RenderControl
{
    partial class Form1
    {
        /// <summary>
        /// Required designer variable.
        /// </summary>
        private System.ComponentModel.IContainer components = null;

        /// <summary>
        /// Clean up any resources being used.
        /// </summary>
        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
        protected override void Dispose(bool disposing)
        {
            if (disposing && (components != null))
            {
                components.Dispose();
            }
            base.Dispose(disposing);
        }

        #region Windows Form Designer generated code

        /// <summary>
        /// Required method for Designer support - do not modify
        /// the contents of this method with the code editor.
        /// </summary>
        private void InitializeComponent()
        {
            this.components = new System.ComponentModel.Container();
            this.splitContainer1 = new System.Windows.Forms.SplitContainer();
            this.timer1 = new System.Windows.Forms.Timer(this.components);
            ((System.ComponentModel.ISupportInitialize)(this.splitContainer1)).BeginInit();
            this.splitContainer1.SuspendLayout();
            this.SuspendLayout();
            //
            // splitContainer1
            //
            this.splitContainer1.Dock = System.Windows.Forms.DockStyle.Fill;
            this.splitContainer1.Location = new System.Drawing.Point(0, 0);
            this.splitContainer1.Name = "splitContainer1";
            this.splitContainer1.Size = new System.Drawing.Size(284, 262);
            this.splitContainer1.SplitterDistance = 202;
            this.splitContainer1.TabIndex = 0;
            this.splitContainer1.SplitterMoved += new System.Windows.Forms.SplitterEventHandler(this.splitContainer1_SplitterMoved);
            //
            // timer1
            //
            this.timer1.Interval = 250;
            this.timer1.Tick += new System.EventHandler(this.timer1_Tick);
            //
            // Form1
            //
            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
            this.ClientSize = new System.Drawing.Size(284, 262);
            this.Controls.Add(this.splitContainer1);
            this.Name = "Form1";
            this.Text = "Form1";
            ((System.ComponentModel.ISupportInitialize)(this.splitContainer1)).EndInit();
            this.splitContainer1.ResumeLayout(false);
            this.ResumeLayout(false);

        }

        #endregion

        private System.Windows.Forms.SplitContainer splitContainer1;
        private System.Windows.Forms.Timer timer1;
    }
}

 

(click to show/hide)

using SFML.Graphics;
using SFML.Window;
using System;
using System.Threading;
using System.Windows.Forms;

namespace RenderControl
{
    public partial class RenderControl : UserControl
    {
        private RenderWindow m_Window = null;
        private uint m_Depth = 0;
        private uint m_Stencil = 0;
        private uint m_Antialiasing = 0;
        private uint m_Major = 2;
        private uint m_Minor = 0;

        public RenderControl(uint depth = 0, uint stencil = 0, uint antialiasing = 0, uint major = 2, uint minor = 0)
        {
            InitializeComponent();
            this.SizeChanged += new EventHandler(RenderControl_SizeChanged);

            this.m_Depth = depth;
            this.m_Stencil = stencil;
            this.m_Antialiasing = antialiasing;
            this.m_Major = major;
            this.m_Minor = minor;
        }
        ~RenderControl()
        {
            this.m_Window.Dispose();
        }

        #region interface

        public void Create()
        {
            Monitor.Enter(this);

            this.m_Window = new RenderWindow(this.Handle, new ContextSettings(this.m_Depth, this.m_Stencil, this.m_Antialiasing
                                                                            , this.m_Major, this.m_Minor));
            this.m_Window.SetVerticalSyncEnabled(true);

            Monitor.Exit(this);
        }
        public void Destroy()
        {
            Monitor.Enter(this);

            if (this.m_Window != null)
            {
                this.m_Window.Close();
                this.m_Window.Dispose();
                this.m_Window = null;
            }

            Monitor.Exit(this);
        }

        public void DispatchEvents()
        {
            Monitor.Enter(this);

            if (this.m_Window != null)
                this.m_Window.DispatchEvents();

            Monitor.Exit(this);
        }

        public void SetActive(bool active = true)
        {
            Monitor.Enter(this);

            if(this.m_Window != null)
                this.m_Window.SetActive(active);

            Monitor.Exit(this);
        }

        public void Clear()
        {
            Monitor.Enter(this);

            if (this.m_Window != null)
                this.m_Window.Clear(Color.Black);

            Monitor.Exit(this);
        }
        public void Clear(Color color)
        {
            Monitor.Enter(this);

            if (this.m_Window != null)
                this.m_Window.Clear(color);

            Monitor.Exit(this);
        }

        public void Draw(Drawable drawable)
        {
            Monitor.Enter(this);

            if (this.m_Window != null)
                this.m_Window.Draw(drawable);

            Monitor.Exit(this);
        }
        public void Draw(Drawable drawable, RenderStates states)
        {
            Monitor.Enter(this);

            if (this.m_Window != null)
                this.m_Window.Draw(drawable, states);

            Monitor.Exit(this);
        }
        public void Draw(Vertex[] vertices, PrimitiveType type)
        {
            Monitor.Enter(this);

            if (this.m_Window != null)
                this.m_Window.Draw(vertices, type);

            Monitor.Exit(this);
        }
        public void Draw(Vertex[] vertices, PrimitiveType type, RenderStates states)
        {
            Monitor.Enter(this);

            if (this.m_Window != null)
                this.m_Window.Draw(vertices, type, states);

            Monitor.Exit(this);
        }
        public void Draw(Vertex[] vertices, uint start, uint count, PrimitiveType type)
        {
            Monitor.Enter(this);

            if (this.m_Window != null)
                this.m_Window.Draw(vertices, start, count, type);

            Monitor.Exit(this);
        }
        public void Draw(Vertex[] vertices, uint start, uint count, PrimitiveType type, RenderStates states)
        {
            Monitor.Enter(this);

            if (this.m_Window != null)
                this.m_Window.Draw(vertices, start, count, type, states);

            Monitor.Exit(this);
        }

        public void Display()
        {
            Monitor.Enter(this);

            if (this.m_Window != null)
                this.m_Window.Display();

            this.Refresh();

            Monitor.Exit(this);
        }

        #endregion

        #region paint overrides
        protected override void OnPaint(PaintEventArgs e)
        {
            //don't call base method!
            //base.OnPaint(e);
        }
        protected override void OnPaintBackground(PaintEventArgs e)
        {
            //don't call base method!
            //base.OnPaintBackground(e);
        }
        #endregion

        void RenderControl_SizeChanged(object sender, EventArgs e)
        {
            Monitor.Enter(this);

            if(this.m_Window != null)
            {
                this.Create();
            }

            Monitor.Exit(this);
        }
    }
}
 

3

DotNet / Re: Runtime error R6025 when using SoundRecorder in WinForms app

« on: April 02, 2015, 12:03:17 am »

I haven't been able to produce a short, verifiable example, but it is looking like this might be related to using SoundRecorder instances as members of a form (likely WinForms being a pain, I figure?). Adding the following to the form's closing event fixes the issue:

private void FFTWindow_FormClosing(object sender, FormClosingEventArgs e)
{
    this.sampler.Stop();
}

As long as the processing thread is stopped directly as above, no trouble. Not entirely sure why this would happen, but I don't mind needing this workaround.

4

DotNet / Re: Runtime error R6025 when using SoundRecorder in WinForms app

« on: April 01, 2015, 05:53:00 pm »

Which doesn't make much sense considering the dtor is empty.

Hmm... there is the possibly that this is a problem with my implementation, since it appears that SoundRecorder::OnProcessSamples is the only abstract function in the class and that SoundRecorder is the root of that portion of the class hierarchy.

I don't know how or why this error would occur, though, since I've provided an override for the function within my class. Given the contents of the error and the fact that it occurs during cleanup, it seems that destroying the object somehow results in the processing thread calling the abstract SoundRecorder::OnProcessSamples instead of my override - I'm never calling the function outside the processing thread.

I'll begin working on a test case within an hour or so. If I'm unable to make one I'll put my code up somewhere, as it's nothing sensitive (just a little bulky due to the FFT logic).

5

DotNet / Runtime error R6025 when using SoundRecorder in WinForms app

« on: April 01, 2015, 05:33:31 am »

I'm building a WinForms control which uses a SoundRecorder subclass to provide Fast Fourier Transform data to my application. When closing my test application an error window appears stating:

Microsoft Visual C++ Runtime Library
---------------------------------------------------
Runtime Error!
[filepath]
R6025
- pure virtual function call

The error is not caused by an exception that can be caught by managed C#.

Having researched this error a bit, I believe this might be caused by an issue with the destructor for SoundRecorder - I am too unfamiliar with the nuances of connecting managed C# to unmanaged C/C++ to say whether this is surely the case. I will be actively working on a more minimal example, hoping to post tomorrow if no one is able to solve this sooner.

6

DotNet / Re: Fragment shader render-to-texture not working as expected

« on: March 24, 2015, 06:59:11 pm »

As expected, the problem was due to my noobishness with regard to OpenGL/GLSL. I'd assumed (in error) that texture coordinates being uploaded in pixels inferred that GLSL wouldn't follow the typical 0...1 standards for texture sampling. Kinda silly in retrospect. Output is a little stuttered, but I'm also using Intel HD Graphics on a three-year-old laptop, so whatevs.

zsbzsb and Laurent - I won't say my introduction to GLSL was painless by any means, but with your help it was at least palatable. Many thanks!

Sample output using exponential zoom, warping, color dampening, and a square for input is attached. Unfortunately I can't upload a video displaying how awesome this looks (re: Intel HD Graphics).

7

DotNet / Re: Fragment shader render-to-texture not working as expected

« on: March 21, 2015, 07:20:05 pm »

Figured that was the case, since the documentation doesn't mention anything. Bummer! Doubt I have the OpenGL know-how to extend anything but the most simple portions of the SFML graphics library at present... For now I guess I'll just have a little extra trig in my shaders. Thanks Laurent.

8

DotNet / Re: Fragment shader render-to-texture not working as expected

« on: March 21, 2015, 06:41:29 pm »

Out of curiosity: do SFML or SFML.NET possess any methods that allow 4-component (or multiple) texture vertices to be added to a VertexArray? It would be LOVELY if I could add polar coordinates to simplify a couple shader calculations I have planned.

9

DotNet / Re: Fragment shader render-to-texture not working as expected

« on: March 21, 2015, 12:25:26 am »

You are forced to get the compiler-generated one, which sadly puts zeroes everywhere, which isn't suitable for all properties of RenderStates.

Ah, yeah, that makes sense. I imagine that'd end up trying to use a bunch of null pointers - not good.

We have results, though they're incorrect!

Must have messed up the shader somewhere, as it appears I've made a starfield generator. Working on it, but I am pretty rightly confused at this point... probably come back to it fresh in the morning. Feel free to peruse my code - tex coords mimic screen coords in all VertexArrays.

(click to show/hide)

uniform sampler2D texture;      //last texture
uniform vec4 sv_Aspect;         //aspect: [width, height, 1/width, 1/height]
uniform float sv_AspectMajor; //smaller of 1/width, 1/height
uniform vec2 sv_Zoom;               //zoom: [zoom, zoom_exp]
uniform vec2 sv_CenRot;         //center of rotation: [cen_x, cen_y]
uniform vec2 sv_Stretch;                //stretching: [stretch_x, stretch_y]
uniform vec2 sv_Rot;                //rotation: [cos(rot), sin(rot)]
uniform vec2 sv_Trans;          //translation: [dx, dy]
uniform vec4 sv_ColDamp;                //color dampening: [color add, color mult, alpha add, alpha mult]

void main()
{
    //get initial tex coord
    vec2 sv_UV = gl_TexCoord[0].xy;

    //set origin to center and calculate rad
    sv_UV -= 0.5 * sv_Aspect.xy;
    float sv_Rad = sqrt((2 * sv_UV.x * sv_AspectMajor) * (2 * sv_UV.x * sv_AspectMajor)
                        + (2 * sv_UV.y * sv_AspectMajor) * (2 * sv_UV.y * sv_AspectMajor));

    //apply zoom
    sv_UV /= pow(sv_Zoom.x, pow(sv_Zoom.y, sv_Rad));

    //center to center of rotation
    vec2 sv_AdjCenRot = sv_Aspect.xy * (sv_CenRot - vec2(0.5, 0.5));
    sv_UV += sv_AdjCenRot;

    //apply stretching and rotation
    sv_UV /= sv_Stretch;
    sv_UV = vec2(sv_UV.x * sv_Rot.x - sv_UV.y * sv_Rot.y
            , sv_UV.x * sv_Rot.y + sv_UV.y * sv_Rot.x);
                   
    //return to  0, 0 center and apply translation
    sv_UV -= sv_AdjCenRot;
    sv_UV -= sv_Aspect.xy * sv_Trans;

    //convert to regular coords, and sample
    sv_UV += 0.5 * sv_Aspect.xy;
    vec4 pixel = texture2D(texture, sv_UV);
                   
    //apply color dampening and output
    pixel.rgb = sv_ColDamp.y * (pixel.rgb - sv_ColDamp.xxx);
    pixel.a = sv_ColDamp.w * (pixel.a - sv_ColDamp.z);
    gl_FragColor = pixel;
}
 

(click to show/hide)

static void LoadShader()
{
    m_Shader = Shader.FromString(null, m_FragShader);

    //aspect info (for scaling)
    m_Shader.SetParameter("sv_Aspect", (float)m_Width, (float)m_Height, 1f / (float)m_Width, 1f / (float)m_Height);
    m_Shader.SetParameter("sv_AspectMajor", ((m_Width > m_Height) ? 1f / (float)m_Width : 1f / (float)m_Height));

    //MOTION VARS
    //EACH EFFECT PROCESSED 1/FRAME
    //
    //  zoom: > 0
    //      0 < zoom < 1 - zooms out
    //      1 < zoom - zooms in
    //  zoom_exp: > 0
    //  cen_x/cen_y: each in 0...1
    //      0 is far left/top
    //      1 is far right/bottom
    //  stretch_x/stretch_y: both > 0
    //      0 < stretch < 1 - compresses
    //      1 < stretch - stretches
    //  rot:
    //      rot < 0 - cw
    //      rot > 0 - ccw
    //  trans_x/trans_y:
    //      trans < 0 moves left/up
    //      trans > 0 moves right/down
    //  color dampening: each in 0...1
    //      subtractive removes linearly from color/alpha
    //      multiplicative scales color/alpha towards 0

    //zoom: [zoom, zoom_exp]
    m_Shader.SetParameter("sv_Zoom", 1f, 1f);

    //center of rotation: [cen_x, cen_y]
    m_Shader.SetParameter("sv_CenRot", 0.5f, 0.5f);

    //stretching: [stretch_x, stretch_y]
    m_Shader.SetParameter("sv_Stretch", 1f, 1f);

    //rotation: [cos(rot), sin(rot)]
    float rot = 0.2f;
    m_Shader.SetParameter("sv_Rot", (float)Math.Cos(rot), (float)Math.Sin(rot));

    //translation: [trans_x, trans_y]
    m_Shader.SetParameter("sv_Trans", 0f, 0f);

    //color dampening: [color subtractive, color multiplicative, alpha subtractive, alpha multiplicative]
    m_Shader.SetParameter("sv_ColDamp", 0f, 1f, 0f, 1f);
}
 

(click to show/hide)

static void Run()
{
    m_BufferTexture1.Texture.Smooth = true;
    m_BufferTexture2.Texture.Smooth = true;
    m_BufferTexture1.Texture.Repeated = true;
    m_BufferTexture2.Texture.Repeated = true;

    Clock timer = new Clock();
    while (m_Window.IsOpen)
    {
        //check for close request (esc)
        m_Window.DispatchEvents();


        //Console.WriteLine((1 / timer.ElapsedTime.AsSeconds()).ToString());
        timer.Restart();

        //create states and draw to texture
        RenderStates states = new RenderStates();
        states.Shader = m_Shader;

        //note: mesh is m-by-n set of adjacent quads
        if (m_DrawToBuffTex1)
        {
            //apply motion and color dampening to the existing image
            m_Shader.SetParameter("texture", m_BufferTexture2.Texture);
            m_BufferTexture1.Draw(m_Mesh, new RenderStates(m_Shader));

            //draw the square on the existing image and display on texture
            m_BufferTexture1.Draw(m_Square);
            m_BufferTexture1.Display();
        }
        else
        {
            //apply motion and color dampening to the existing image
            m_Shader.SetParameter("texture", m_BufferTexture1.Texture);
            m_BufferTexture2.Draw(m_Mesh, new RenderStates(m_Shader));

            //draw the square on the existing image and display on texture
            m_BufferTexture2.Draw(m_Square);
            m_BufferTexture2.Display();
        }

        //clear the screen, render the texture to the full-screen quad, and display
        m_Window.Clear(Color.Black);
        if (m_DrawToBuffTex1)
            m_Window.Draw(m_ScreenQuad, new RenderStates(m_BufferTexture1.Texture));
        else
            m_Window.Draw(m_ScreenQuad, new RenderStates(m_BufferTexture2.Texture));
        m_Window.Display();

        m_DrawToBuffTex1 = !m_DrawToBuffTex1;
    }
}
 

10

DotNet / Re: Fragment shader render-to-texture not working as expected

« on: March 20, 2015, 10:38:46 pm »

Mm, that seems to have fixed it, though the got-dang shader still isn't working.

I take it RenderStates' default constructor doesn't just default to the "normal" states? Have a couple C++ projects that need some code changes, in that case. Odd that I haven't run into this before.

11

DotNet / Re: Fragment shader render-to-texture not working as expected

« on: March 20, 2015, 10:26:31 pm »

You say that like you could stop me, haha.

Might be a minute... currently getting no output from my self-implemented buffer (code below, if you're interested).

(click to show/hide)

        static void Run()
        {
            m_BufferTexture1.Smooth = true;
            m_BufferTexture2.Smooth = true;
            m_BufferTexture1.Texture.Repeated = true;
            m_BufferTexture2.Texture.Repeated = true;

            while (m_Window.IsOpen)
            {
                //check for close request (esc)
                m_Window.DispatchEvents();

                //create states and draw to texture
                RenderStates states = new RenderStates();
                states.Shader = m_Shader;

                if(m_DrawToBuffTex1)
                {
                    //apply motion and color dampening to the existing image
                    //m_Shader.SetParameter("texture", m_BufferTexture2.Texture);
                    //m_BufferTexture1.Draw(m_Mesh, states);

                    //draw the square on the existing image and display on texture
                    m_BufferTexture1.Draw(m_Square);
                    m_BufferTexture1.Display();
                }
                else
                {
                    //apply motion and color dampening to the existing image
                    //m_Shader.SetParameter("texture", m_BufferTexture1.Texture);
                    //m_BufferTexture2.Draw(m_Mesh, states);

                    //draw the square on the existing image and display on texture
                    m_BufferTexture2.Draw(m_Square);
                    m_BufferTexture2.Display();
                }

                //clear the screen, render the texture to the full-screen quad, and display
                states.Shader = null;
                if (m_DrawToBuffTex1)
                    states.Texture = m_BufferTexture1.Texture;
                else
                    states.Texture = m_BufferTexture2.Texture;

                m_Window.Clear(Color.Black);
                m_Window.Draw(m_ScreenQuad, states);
                m_Window.Display();

                m_DrawToBuffTex1 = !m_DrawToBuffTex1;
            }
        }
 

12

DotNet / Re: Fragment shader render-to-texture not working as expected

« on: March 20, 2015, 09:18:39 pm »

...and here I was hoping I'd found a gloriously simple loophole. I just KNEW this was gonna be trouble. I am now curious as to why RenderTexture.Display() is a thing. What's going on there?

Compositing on another texture should be fine (love that solution, btw, zsbzsb). Am I correct in assuming that when I call

target.draw(array, states)

'Shader.CurrentTexture' allows states.Shader to reference states.Texture?

EDIT: after further reading I think I've worked this out. It's not working yet, but I think I'm on the right track...

13

DotNet / Re: Fragment shader render-to-texture not working as expected

« on: March 20, 2015, 09:00:28 pm »

Perhaps I am missing the point of the function

m_Shader.SetParameter("texture", Shader.CurrentTexture);

then? I thought that could cause trouble, but it looked like RenderTextures were double buffered and I figured that'd take care of the obvious problems... It'd be easy enough to fix this with another texture for "buffering" the new render, I guess, though afaik the inability to do a deep copy could result in a fair amount of overhead. If it's not prohibitively difficult to explain why this is the case, I'd love to know.

14

DotNet / Fragment shader render-to-texture not working as expected

« on: March 20, 2015, 08:37:38 pm »

I am creating a program which uses the previously rendered frame to create an illusion of movement. In essence:

• Objects are drawn on a RenderTexture
• The RenderTexture is drawn to a RenderWindow using a full-screen quad
• The RenderTexture is re-rendered to itself with a handful of shader effects

For those familiar with the WinAmp visualizer 'Milkdrop', this process should be relatively familiar... the outcome should be more or less identical.

For testing, I am drawing a square to the RenderTexture. The square renders just fine, but the shader effects don't seem to ever be applied... This is my first time working with GLSL within any SFML program (.NET or otherwise), so I'm likely missing something (and it's probably something stupid - apologies in advance). Code below:

(click to show/hide)

(click to show/hide)

        static string m_FragShader =
            @"uniform sampler2D texture;        //new texture
              uniform vec4 sv_Aspect;           //aspect: [width, height, 1/width, 1/height]
              uniform vec2 sv_Zoom;                 //zoom: [zoom, zoom_exp]
              uniform vec2 sv_CenRot;           //center of rotation: [cen_x, cen_y]
              uniform vec2 sv_Stretch;          //stretching: [stretch_x, stretch_y]
              uniform vec2 sv_Rot;                  //rotation: [cos(rot), sin(rot)]
              uniform vec2 sv_Trans;            //translation: [dx, dy]
              uniform vec4 sv_ColDamp;          //color dampening: [color add, color mult, alpha add, alpha mult]

              void main()
              {
                //get initial tex coord
                vec2 uv = gl_TexCoord[0].xy;

                //scale to [-1, 1] and calculate radius
                uv = 2 * uv * sv_Aspect.zw - vec2(1, 1);
                float rad = sqrt(uv.x * uv.x + uv.y * uv.y);

                //apply zoom
                uv /= pow(sv_Zoom.x, pow(sv_Zoom.y, rad));

                //center to center of rotation
                vec2 CR = 2 * (sv_CenRot - vec2(0.5, 0.5));
                uv -= CR;

                //apply stretching and rotation
                uv /= sv_Stretch;
                uv = vec2(uv.x * sv_Rot.x - uv.y * sv_Rot.y
                        , uv.x * sv_Rot.y + uv.y * sv_Rot.x);
                   
                //return to  0, 0 center and apply translation
                uv += CR;
                uv += 2 * sv_Trans;

                //convert to regular coords, and sample
                uv = 0.5 * sv_Aspect.xy * (uv + vec2(1, 1));
                vec4 pixel = texture2D(texture, uv);
                   
                //apply color dampening and output
                pixel.rgb = sv_ColDamp.y * (pixel.rgb - sv_ColDamp.xxx);
                pixel.a = sv_ColDamp.w * (pixel.a - sv_ColDamp.z);
                gl_FragColor = pixel;
              }";
//...

        static void LoadShader()
        {
            m_Shader = Shader.FromString(null, m_FragShader);
            m_Shader.SetParameter("texture", Shader.CurrentTexture);

            //aspect info (for scaling)
            m_Shader.SetParameter("sv_Aspect", (float)m_Width, (float)m_Height, 1f / (float)m_Width, 1f / (float)m_Height);

            //MOTION VARS
            //EACH EFFECT PROCESSED 1/FRAME
            //
            //  zoom: > 0
            //      0 < zoom < 1 - zooms out
            //      1 < zoom - zooms in
            //  zoom_exp: > 0
            //  cen_x/cen_y: each in 0...1
            //      0 is far left/top
            //      1 is far right/bottom
            //  stretch_x/stretch_y: both > 0
            //      0 < stretch < 1 - compresses
            //      1 < stretch - stretches
            //  rot:
            //      rot < 0 - cw
            //      rot > 0 - ccw
            //  trans_x/trans_y:
            //      trans < 0 moves left/up
            //      trans > 0 moves right/down
            //  color dampening: each in 0...1
            //      subtractive removes linearly from color/alpha
            //      multiplicative scales color/alpha towards 0 (after subtraction)

            //zoom: [zoom, zoom_exp]
            m_Shader.SetParameter("sv_Zoom", 1f, 1f);

            //center of rotation: [cen_x, cen_y]
            m_Shader.SetParameter("sv_CenRot", 0.5f, 0.5f);

            //stretching: [stretch_x, stretch_y]
            m_Shader.SetParameter("sv_Stretch", 1f, 1f);

            //rotation: [cos(rot), sin(rot)]
            float rot = 0f;
            m_Shader.SetParameter("sv_Rot", (float)Math.Cos(rot), (float)Math.Sin(rot));

            //translation: [trans_x, trans_y]
            m_Shader.SetParameter("sv_Trans", 0f, 0f);

            //color dampening: [color subtractive, color multiplicative, alpha subtractive, alpha multiplicative]
            m_Shader.SetParameter("sv_ColDamp", 0.002f, 0.98f, 0f, 1f);
        }
 

(click to show/hide)

        static void Run()
        {
            while (m_Window.IsOpen)
            {
                //check for close request (esc)
                m_Window.DispatchEvents();

                //apply motion and color dampening to the existing image
                RenderStates states = new RenderStates
                states.Shader = m_Shader;
                m_Texture.Draw(m_Mesh, states);

                //draw the square on the existing image and display on texture
                m_Texture.Draw(m_Square);
                m_Texture.Display();

                //clear the screen, render the texture to the full-screen quad, and display
                states = new RenderStates();
                states.Texture = m_Texture.Texture;
                m_Window.Clear(Color.Black);
                m_Window.Draw(m_ScreenQuad, states);
                m_Window.Display();
            }
        }
 

(click to show/hide)

using SFML.Graphics;
using SFML.System;
using SFML.Window;
using System;

namespace ShaderTesting
{
    class Program
    {
        #region frag shader
        static string m_FragShader =
            @"uniform sampler2D texture;        //new texture
              uniform vec4 sv_Aspect;           //aspect: [width, height, 1/width, 1/height]
              uniform vec2 sv_Zoom;                 //zoom: [zoom, zoom_exp]
              uniform vec2 sv_CenRot;           //center of rotation: [cen_x, cen_y]
              uniform vec2 sv_Stretch;          //stretching: [stretch_x, stretch_y]
              uniform vec2 sv_Rot;                  //rotation: [cos(rot), sin(rot)]
              uniform vec2 sv_Trans;            //translation: [dx, dy]
              uniform vec4 sv_ColDamp;          //color dampening: [color add, color mult, alpha add, alpha mult]

              void main()
              {
                //get initial tex coord
                vec2 uv = gl_TexCoord[0].xy;

                //scale to [-1, 1] and calculate radius
                uv = 2 * uv * sv_Aspect.zw - vec2(1, 1);
                float rad = sqrt(uv.x * uv.x + uv.y * uv.y);

                //apply zoom
                uv /= pow(sv_Zoom.x, pow(sv_Zoom.y, rad));

                //center to center of rotation
                vec2 CR = 2 * (sv_CenRot - vec2(0.5, 0.5));
                uv -= CR;

                //apply stretching and rotation
                uv /= sv_Stretch;
                uv = vec2(uv.x * sv_Rot.x - uv.y * sv_Rot.y
                        , uv.x * sv_Rot.y + uv.y * sv_Rot.x);
                   
                //return to  0, 0 center and apply translation
                uv += CR;
                uv += 2 * sv_Trans;

                //convert to regular coords, and sample
                uv = 0.5 * sv_Aspect.xy * (uv + vec2(1, 1));
                vec4 pixel = texture2D(texture, uv);
                   
                //apply color dampening and output
                pixel.rgb = sv_ColDamp.y * (pixel.rgb - sv_ColDamp.xxx);
                pixel.a = sv_ColDamp.w * (pixel.a - sv_ColDamp.z);
                gl_FragColor = pixel;
              }";
        #endregion

        static uint m_Width = VideoMode.DesktopMode.Width;
        static uint m_Height = VideoMode.DesktopMode.Height;
        static RenderWindow m_Window = new RenderWindow(VideoMode.DesktopMode, "Shader Testing", Styles.Fullscreen);
        static RenderTexture m_Texture = new RenderTexture(m_Width, m_Height);
        static Shader m_Shader;
        static VertexArray m_Mesh;
        static VertexArray m_ScreenQuad;
        static RectangleShape m_Square = new RectangleShape(new Vector2f(50, 50));

        static void Main(string[] args)
        {
            m_Window.KeyPressed += m_Window_KeyPressed;
            m_Window.SetFramerateLimit(60);
            m_Window.SetVerticalSyncEnabled(true);

            //load shader and set shader vars
            //  MESS WITH THE CONTENTS OF THIS FUNCTION
            //  CHANGING VARS SHOULD CAUSE MOTION OVER TIME
            LoadShader();

            //create an m-by-n mesh of quads covering the screen
            CreateMesh(2, 2);

            //create a full-screen quad
            CreateQuad();

            //set square parameters
            PrepareSquare();

            //run the render loop
            Run();
        }
        static void Run()
        {
            while (m_Window.IsOpen)
            {
                //check for close request (esc)
                m_Window.DispatchEvents();

                //apply motion and color dampening to the existing image
                RenderStates states = new RenderStates
                states.Shader = m_Shader;
                m_Texture.Draw(m_Mesh, states);

                //draw the square on the existing image and display on texture
                m_Texture.Draw(m_Square);
                m_Texture.Display();

                //clear the screen, render the texture to the full-screen quad, and display
                states = new RenderStates();
                states.Texture = m_Texture.Texture;
                m_Window.Clear(Color.Black);
                m_Window.Draw(m_ScreenQuad, states);
                m_Window.Display();
            }
        }

        static void LoadShader()
        {
            m_Shader = Shader.FromString(null, m_FragShader);
            m_Shader.SetParameter("texture", Shader.CurrentTexture);

            //aspect info (for scaling)
            m_Shader.SetParameter("sv_Aspect", (float)m_Width, (float)m_Height, 1f / (float)m_Width, 1f / (float)m_Height);

            //MOTION VARS
            //EACH EFFECT PROCESSED 1/FRAME
            //
            //  zoom: > 0
            //      0 < zoom < 1 - zooms out
            //      1 < zoom - zooms in
            //  zoom_exp: > 0
            //  cen_x/cen_y: each in 0...1
            //      0 is far left/top
            //      1 is far right/bottom
            //  stretch_x/stretch_y: both > 0
            //      0 < stretch < 1 - compresses
            //      1 < stretch - stretches
            //  rot:
            //      rot < 0 - cw
            //      rot > 0 - ccw
            //  trans_x/trans_y:
            //      trans < 0 moves left/up
            //      trans > 0 moves right/down
            //  color dampening: each in 0...1
            //      subtractive removes linearly from color/alpha
            //      multiplicative scales color/alpha towards 0 (after subtraction)

            //zoom: [zoom, zoom_exp]
            m_Shader.SetParameter("sv_Zoom", 1f, 1f);

            //center of rotation: [cen_x, cen_y]
            m_Shader.SetParameter("sv_CenRot", 0.5f, 0.5f);

            //stretching: [stretch_x, stretch_y]
            m_Shader.SetParameter("sv_Stretch", 1f, 1f);

            //rotation: [cos(rot), sin(rot)]
            float rot = 0f;
            m_Shader.SetParameter("sv_Rot", (float)Math.Cos(rot), (float)Math.Sin(rot));

            //translation: [trans_x, trans_y]
            m_Shader.SetParameter("sv_Trans", 0f, 0f);

            //color dampening: [color subtractive, color multiplicative, alpha subtractive, alpha multiplicative]
            m_Shader.SetParameter("sv_ColDamp", 0.002f, 0.98f, 0f, 1f);
        }
        static void CreateMesh(uint x, uint y)
        {
            m_Mesh = new VertexArray(PrimitiveType.Quads, 4 * x * y);
            float xPix = m_Width / x;
            float yPix = m_Height / y;

            uint vIdx = 0;
            for(int yIdx = 0; yIdx < y; ++yIdx)
            {
                for(int xIdx = 0; xIdx < x; ++xIdx)
                {
                    m_Mesh[vIdx++] = new Vertex(new Vector2f(xIdx * xPix, yIdx * yPix)
                                                , new Vector2f(xIdx * xPix, yIdx * yPix));
                    m_Mesh[vIdx++] = new Vertex(new Vector2f((xIdx + 1) * xPix, yIdx * yPix)
                                                , new Vector2f((xIdx + 1) * xPix, yIdx * yPix));
                    m_Mesh[vIdx++] = new Vertex(new Vector2f((xIdx + 1) * xPix, (yIdx + 1) * yPix)
                                                , new Vector2f((xIdx + 1) * xPix, (yIdx + 1) * yPix));
                    m_Mesh[vIdx++] = new Vertex(new Vector2f(xIdx * xPix, (yIdx + 1) * yPix)
                                                , new Vector2f(xIdx * xPix, (yIdx + 1) * yPix));
                }
            }
        }
        static void CreateQuad()
        {
            m_ScreenQuad = new VertexArray(PrimitiveType.Quads, 4);
            m_ScreenQuad[0] = new Vertex(new Vector2f(0f, 0f), new Vector2f(0f, 0f));
            m_ScreenQuad[1] = new Vertex(new Vector2f((float)m_Width, 0f), new Vector2f((float)m_Width, 0f));
            m_ScreenQuad[2] = new Vertex(new Vector2f((float)m_Width, (float)m_Height), new Vector2f((float)m_Width, (float)m_Height));
            m_ScreenQuad[3] = new Vertex(new Vector2f(0f, (float)m_Height), new Vector2f(0f, (float)m_Height));
        }
        static void PrepareSquare()
        {
            m_Square.Position = new Vector2f(0.5f * (m_Width - m_Square.Size.X), 0.5f * (m_Height - m_Square.Size.Y));
            m_Square.OutlineThickness = 3;
            m_Square.OutlineColor = Color.White;
            m_Square.FillColor = Color.Transparent;
        }

        static void m_Window_KeyPressed(object sender, KeyEventArgs e)
        {
            if (e.Code == Keyboard.Key.Escape)
                m_Window.Close();
        }
    }
}

 

15

DotNet / Re: Failure in Draw call in multithreaded WinForms app

« on: March 20, 2015, 07:51:01 pm »

Spent a good portion of yesterday creating a self-contained subset of the code, and accidentally ran across the solution to my problem. Last time I work off a version of CSFML I've compiled myself, I think *sigh*