GL instanced shader problem.

@willmotil wrote:

Im using vs2017 on win7 i have created the same project for the crossplatform template gl and windows dx

So i have a example Instanced DX shader that i have trimmed down to simplify it so i can understand it better. this works under the Dx 4_0 profile with hi def set under the windows template.

However

The same shader under GL 3_0 on hi-def, while it does show a window and it doesn't error or crash ect... Nothing is drawn all i get is a black screen.

Im at a loss as to why ?...

Here is the shader followed by the full code you need a texture to run the example.

,,, the shader ,,

#if OPENGL
//#define SV_POSITION POSITION
#define VS_SHADERMODEL vs_3_0
#define PS_SHADERMODEL ps_3_0
#else
#define VS_SHADERMODEL vs_4_0
#define PS_SHADERMODEL ps_4_0
#endif

static const float PI = 3.14159265359;
static const float EIGHT_PI = 25.1327412287;


float Life;
float TotalTime;
//int MaxNumOfParticles;
//float2 RadiusRange;

matrix WorldViewProjection;

Texture2D ParticleTexture : register(t0);
sampler TexSampler : register(s0);

//__________________________________________________________
//__________________________________________________________

struct VSVertexInputSimple
{
    float4 Position : SV_POSITION;
    float2 TexCoord : TEXCOORD0;
    //uint InstanceId : SV_InstanceId;
};

struct VSInstanceInputSimple
{
    float3 RandomIntervals : POSITION1;
    float ParticleTime : BLENDWEIGHT0;
};

struct VSOutputSimple
{
    float4 Position : SV_POSITION;
    float2 TexCoord : TEXCOORD0;
    float4 Color : COLOR0;
};

VSOutputSimple MainVSSimple(in VSVertexInputSimple vertexInput, VSInstanceInputSimple instanceInput)
{
    //VSOutput output = (VSOutput)0;
    VSOutputSimple output; //= (VSOutput)0;

    float3 randomIntervals = instanceInput.RandomIntervals;
    float particleTime = instanceInput.ParticleTime;

    float timeFraction = fmod((particleTime + TotalTime) / (float)Life, 1.0f);

    output.Position = vertexInput.Position;
    output.Position.xy += randomIntervals;
    output.Position.y += timeFraction * 100;
    output.Position.z = 0;//vertexInput.InstanceId * 10 / (float)MaxNumOfParticles;
    output.Position = mul(output.Position, WorldViewProjection);

    // Set colour of particle using the other two passed-in random intervals 
    float4 endColor = lerp(float4(0.0, 0.5, 1.0, 0.8), float4(1.0, 1.0, 1.0, 0.8), randomIntervals.y);
    float4 startColor = lerp(float4(1.0, 0.0, 0.0, 0.8), float4(0.3, 0.0, 1.0, 1.0), randomIntervals.z);

    output.Color = lerp(startColor, endColor, timeFraction);
    output.Color *= (-4 * pow(timeFraction - 0.5, 2) + 1);

    output.TexCoord = vertexInput.TexCoord;

    return output;
}

float4 MainPSSimple(VSOutputSimple input) : COLOR0
{
    return input.Color * ParticleTexture.Sample(TexSampler, input.TexCoord);
}

technique ParticleDrawingSimple
{
    pass P0
    {
        VertexShader = compile VS_SHADERMODEL MainVSSimple();
        PixelShader = compile PS_SHADERMODEL MainPSSimple();
    }
};

,,, the code ,, All the classes and structs have been placed in one cs file for simplicity...

using System;
using System.Collections.Generic;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using System.Runtime.InteropServices;

namespace Game1
{
    [StructLayout(LayoutKind.Sequential)]
    public struct InstanceData : IVertexType
    {
        public static readonly VertexDeclaration VertexDeclaration;

        public Vector3 RandomIntervals;
        public float Time;

        VertexDeclaration IVertexType.VertexDeclaration
        {
            get { return VertexDeclaration; }
        }

        static InstanceData()
        {
            var elements = new VertexElement[]
                {
                    new VertexElement(0, VertexElementFormat.Vector3, VertexElementUsage.Position, 0),
                    new VertexElement(12, VertexElementFormat.Single, VertexElementUsage.BlendWeight, 0)
                };
            VertexDeclaration = new VertexDeclaration(elements);
        }
    }

    [StructLayout(LayoutKind.Sequential)]
    public struct VertexData : IVertexType
    {
        public static readonly VertexDeclaration VertexDeclaration;

        public Vector3 Position;
        public Vector2 TexCoords;

        VertexDeclaration IVertexType.VertexDeclaration
        {
            get { return VertexDeclaration; }
        }

        static VertexData()
        {
            var elements = new VertexElement[]
                {
                    new VertexElement(0, VertexElementFormat.Vector3, VertexElementUsage.Position, 0),
                    new VertexElement(12, VertexElementFormat.Vector2, VertexElementUsage.TextureCoordinate, 0),
                };
            VertexDeclaration = new VertexDeclaration(elements);
        }
    }

    public class Game1 : Game
    {
        GraphicsDeviceManager graphics;
        ParticleSystem02 particleSystem;
        Matrix worldViewProj;

        public Game1()
        {
            graphics = new GraphicsDeviceManager(this);
            graphics.GraphicsProfile = GraphicsProfile.HiDef;
            graphics.PreferMultiSampling = false;
            Window.AllowUserResizing = true;
            // Set the default resolution to be 1024x768
            graphics.PreferredBackBufferWidth = 1024;
            graphics.PreferredBackBufferHeight = 768;
            Content.RootDirectory = "Content";
        }

        protected override void Initialize()
        {
            base.Initialize();

            // Setup the worldViewProj matrix
            float width = GraphicsDevice.PresentationParameters.BackBufferWidth;
            float height = GraphicsDevice.PresentationParameters.BackBufferHeight;
            float aspect = width / height;

            // Create our camera that's looking straight at the center
            Matrix viewMatrix = Matrix.CreateLookAt(new Vector3(0.0f, 0.0f, 5.0f), Vector3.Zero, Vector3.Up);

            // Create a projection matrix so that the world dimensions have the same aspect ratio as our window size
            Matrix projMatrix = Matrix.CreateOrthographic(aspect * 300, 300, 0.1f, 10000);

            worldViewProj = viewMatrix * projMatrix;
        }

        protected override void LoadContent()
        {
            Effect particlesEffect = Content.Load<Effect>("ParticleFx02");
            Texture2D particleTexture = Content.Load<Texture2D>("particle");

            particleSystem = new ParticleSystem02(particlesEffect)
            {
                ParticleSize = new Vector2(3.0f, 3.0f),
                ParticleTexture = particleTexture,
                Life = 20.0f,
                EmitRate = 12500,
                Radius = 180.0f,
                RadiusDeviation = new Vector2(40.0f, 100.0f),
            };

            particleSystem.RefreshParticleSystemBuffers(GraphicsDevice);

        }

        protected override void UnloadContent()
        {
            Content.Unload();
        }

        protected override void Update(GameTime gameTime)
        {
            base.Update(gameTime);

            particleSystem.UpdateParticleTime((float)gameTime.ElapsedGameTime.TotalSeconds);

            if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed || Keyboard.GetState().IsKeyDown(Keys.Escape))
                Exit();
        }

        protected override void Draw(GameTime gameTime)
        {
            base.Draw(gameTime);

            GraphicsDevice.Clear(ClearOptions.DepthBuffer | ClearOptions.Target, Color.Black, 1.0f, 0);
            GraphicsDevice.BlendState = BlendState.Additive;
            GraphicsDevice.DepthStencilState = DepthStencilState.Default;

            particleSystem.DrawParticles(ref worldViewProj, GraphicsDevice);
        }
    }
    class ParticleSystem02
    {
        // Vertex data
        VertexBuffer vertexBuffer;
        IndexBuffer indexBuffer;
        VertexBufferBinding vertexBufferBinding;

        // Instance data
        int numInstancesToDraw;
        InstanceData[] instanceData;
        VertexBuffer instanceBuffer;
        VertexBufferBinding instanceBufferBinding;

        Effect particlesEffect;

        Vector2 radiusRange;

        float totalTime = 0;

        #region Properties
        public Vector2 ParticleSize { get; set; }
        public Texture2D ParticleTexture { get; set; }
        public float Life { get; set; }
        public uint EmitRate { get; set; }
        public float Radius { get; set; }
        public Vector2 RadiusDeviation { get; set; }

        public int MaxVisibleParticles
        {
            get; private set;
        }

        #endregion Properties

        #region Initilisation
        public ParticleSystem02(Effect effect)
        {
            particlesEffect = effect;
        }

        public void RefreshParticleSystemBuffers(GraphicsDevice graphicsDevice)
        {
            // Create a single quad centered at the origin
            float halfWidth = ParticleSize.X / 2;
            float halfHeight = ParticleSize.Y / 2;

            VertexData[] vertices = new VertexData[4];
            vertices[0].Position = new Vector3(-halfWidth, -halfHeight, 0);
            vertices[1].Position = new Vector3(halfWidth, -halfHeight, 0);
            vertices[2].Position = new Vector3(-halfWidth, halfHeight, 0);
            vertices[3].Position = new Vector3(halfWidth, halfHeight, 0);

            vertices[0].TexCoords = new Vector2(0.0f, 0.0f);
            vertices[1].TexCoords = new Vector2(1.0f, 0.0f);
            vertices[2].TexCoords = new Vector2(0.0f, 1.0f);
            vertices[3].TexCoords = new Vector2(1.0f, 1.0f);

            vertexBuffer = new VertexBuffer(graphicsDevice, VertexData.VertexDeclaration, 4, BufferUsage.WriteOnly);
            vertexBuffer.SetData(vertices);

            vertexBufferBinding = new VertexBufferBinding(vertexBuffer);

            int[] indices = new int[6];
            indices[0] = 1;
            indices[1] = 0;
            indices[2] = 2;
            indices[3] = 3;
            indices[4] = 1;
            indices[5] = 2;

            indexBuffer = new IndexBuffer(graphicsDevice, typeof(int), 6, BufferUsage.WriteOnly);
            indexBuffer.SetData(indices);

            MaxVisibleParticles = (int)Math.Max(Math.Ceiling(Life * EmitRate), 1);

            instanceData = new InstanceData[MaxVisibleParticles];
            instanceBuffer = new VertexBuffer(graphicsDevice, InstanceData.VertexDeclaration, MaxVisibleParticles, BufferUsage.WriteOnly);
            instanceBufferBinding = new VertexBufferBinding(instanceBuffer, 0, 1);

            Random rnd = new Random();

            // Initialise our instance buffer
            for (int i = 0; i < MaxVisibleParticles; ++i)
            {
                // instance data float time
                instanceData[i].Time = -(i + 1) / (float)EmitRate;
                // instance data float position
                instanceData[i].RandomIntervals = new Vector3
                    (
                    (rnd.Next(0, 300) - 150),
                    -.001f,
                    rnd.Next(0, MaxVisibleParticles + 1) / (float)MaxVisibleParticles
                    );
            }

            instanceBuffer.SetData(instanceData);

            radiusRange = new Vector2(Radius + RadiusDeviation.X, Radius + RadiusDeviation.Y);
        }

        #endregion Initilisation

        public void UpdateParticleTime(float seconds)
        {
            // Potentially, you could adjust the number of 
            // particles rendered based on the time
            // However, here we're simply using the maximal number
            numInstancesToDraw = MaxVisibleParticles;

            // Update the total running time
            totalTime += seconds;
        }

        public void DrawParticles(ref Matrix worldViewProj, GraphicsDevice graphicsDevice)
        {
            particlesEffect.CurrentTechnique = particlesEffect.Techniques["ParticleDrawingSimple"];
            // Initialise our shader constants
            particlesEffect.Parameters["WorldViewProjection"].SetValue(worldViewProj);
            particlesEffect.Parameters["Life"].SetValue(Life);
            //particlesEffect.Parameters["RadiusRange"].SetValue(radiusRange);
            //particlesEffect.Parameters["MaxNumOfParticles"].SetValue(MaxVisibleParticles);
            particlesEffect.Parameters["TotalTime"].SetValue((float)totalTime);
            particlesEffect.CurrentTechnique.Passes[0].Apply();

            // Set textures and buffers
            graphicsDevice.Textures[0] = ParticleTexture;
            graphicsDevice.SamplerStates[0] = SamplerState.LinearClamp;
            graphicsDevice.SetVertexBuffers(vertexBufferBinding, instanceBufferBinding);
            graphicsDevice.Indices = indexBuffer;

            graphicsDevice.DrawInstancedPrimitives(PrimitiveType.TriangleList, 0, 0, 6, 0, 2, numInstancesToDraw);
        }
    }
}

Posts: 4

Participants: 2

Read full topic