简单的粒子系统

已于 2024-09-09 22:16:52 修改
阅读量311 收藏 4
点赞数 5
分类专栏： FPS射击游戏技术专栏 文章标签： 游戏
于 2024-09-09 22:16:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33060405/article/details/142070850
版权

下面是一个简单的游戏渲染管线架构设计的 C# 版本。我们将使用 OpenGL 和 C# 的 OpenTK 库来实现这个渲染管线。这个示例将包括一个基本的渲染管线架构，支持加载着色器、纹理和渲染简单的粒子系统。

项目结构

project/
│
├── Program.cs
├── Shader.cs
├── Texture.cs
├── Particle.cs
├── ParticleEmitter.cs
└── particle.png

Program.cs

using System;
using OpenTK;
using OpenTK.Graphics.OpenGL4;
using OpenTK.Input;

namespace ParticleSystem
{
    class Program : GameWindow
    {
        private Shader shader;
        private Texture texture;
        private ParticleEmitter emitter;

        protected override void OnLoad(EventArgs e)
        {
            base.OnLoad(e);
            GL.ClearColor(0.0f, 0.0f, 0.0f, 1.0f);
            GL.Enable(EnableCap.Blend);
            GL.BlendFunc(BlendingFactor.SrcAlpha, BlendingFactor.OneMinusSrcAlpha);

            shader = new Shader("vertex_shader.glsl", "fragment_shader.glsl");
            texture = new Texture("particle.png");

            emitter = new ParticleEmitter(new Vector2(400, 300), 10, 2.0f, new Vector4(1, 0, 0, 1), new Vector4(0, 0, 1, 1), 5, 10);
        }

        protected override void OnRenderFrame(FrameEventArgs e)
        {
            base.OnRenderFrame(e);
            GL.Clear(ClearBufferMask.ColorBufferBit);

            shader.Use();
            texture.Bind();

            emitter.Update((float)e.Time);
            emitter.Render(shader);

            SwapBuffers();
        }

        protected override void OnUpdateFrame(FrameEventArgs e)
        {
            base.OnUpdateFrame(e);
            if (Keyboard.GetState().IsKeyDown(Key.Escape))
            {
                Exit();
            }
        }

        [STAThread]
        static void Main()
        {
            using (var program = new Program())
            {
                program.Run(60.0);
            }
        }
    }
}

Shader.cs

using System;
using System.IO;
using OpenTK.Graphics.OpenGL4;

namespace ParticleSystem
{
    public class Shader
    {
        public int Handle;

        public Shader(string vertexPath, string fragmentPath)
        {
            var vertexShader = LoadShader(vertexPath, ShaderType.VertexShader);
            var fragmentShader = LoadShader(fragmentPath, ShaderType.FragmentShader);

            Handle = GL.CreateProgram();
            GL.AttachShader(Handle, vertexShader);
            GL.AttachShader(Handle, fragmentShader);
            GL.LinkProgram(Handle);

            GL.DetachShader(Handle, vertexShader);
            GL.DetachShader(Handle, fragmentShader);
            GL.DeleteShader(vertexShader);
            GL.DeleteShader(fragmentShader);
        }

        private int LoadShader(string path, ShaderType type)
        {
            var shaderSource = File.ReadAllText(path);
            var shader = GL.CreateShader(type);
            GL.ShaderSource(shader, shaderSource);
            GL.CompileShader(shader);

            GL.GetShader(shader, ShaderParameter.CompileStatus, out int success);
            if (success == 0)
            {
                var infoLog = GL.GetShaderInfoLog(shader);
                throw new Exception($"Error compiling shader of type {type}: {infoLog}");
            }

            return shader;
        }

        public void Use()
        {
            GL.UseProgram(Handle);
        }
    }
}

Texture.cs

using System;
using System.Drawing;
using System.Drawing.Imaging;
using OpenTK.Graphics.OpenGL4;

namespace ParticleSystem
{
    public class Texture
    {
        public int Handle;

        public Texture(string path)
        {
            Handle = GL.GenTexture();
            GL.BindTexture(TextureTarget.Texture2D, Handle);

            using (var image = new Bitmap(path))
            {
                var data = image.LockBits(new Rectangle(0, 0, image.Width, image.Height), ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
                GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba, image.Width, image.Height, 0, OpenTK.Graphics.OpenGL4.PixelFormat.Bgra, PixelType.UnsignedByte, data.Scan0);
                image.UnlockBits(data);
            }

            GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Linear);
            GL.TexParameter(TextureTarget.Texture2D,好的，让我们继续完成 `Texture.cs` 文件，并实现 
            GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Linear);
            GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear);
            GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapS, (int)TextureWrapMode.ClampToEdge);
            GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapT, (int)TextureWrapMode.ClampToEdge);

            GL.BindTexture(TextureTarget.Texture2D, 0);
        }

        public void Bind(TextureUnit unit = TextureUnit.Texture0)
        {
            GL.ActiveTexture(unit);
            GL.BindTexture(TextureTarget.Texture2D, Handle);
        }
    }
}

Particle.cs

using OpenTK;
using System;

namespace ParticleSystem
{
    public class Particle
    {
        public Vector2 Position;
        public Vector2 Velocity;
        public float Lifetime;
        public float Age;
        public Vector4 StartColor;
        public Vector4 EndColor;
        public float StartSize;
        public float EndSize;

        public Particle(Vector2 position, Vector2 velocity, float lifetime, Vector4 startColor, Vector4 endColor, float startSize, float endSize)
        {
            Position = position;
            Velocity = velocity;
            Lifetime = lifetime;
            Age = 0.0f;
            StartColor = startColor;
            EndColor = endColor;
            StartSize = startSize;
            EndSize = endSize;
        }

        public void Update(float deltaTime, Vector2 gravity, Vector2 wind)
        {
            Age += deltaTime;
            if (Age < Lifetime)
            {
                Velocity += gravity * deltaTime;
                Velocity += wind * deltaTime;
                Position += Velocity * deltaTime;
            }
        }

        public Vector4 Color
        {
            get
            {
                float t = Age / Lifetime;
                return Vector4.Lerp(StartColor, EndColor, t);
            }
        }

        public float Size
        {
            get
            {
                float t = Age / Lifetime;
                return MathHelper.Lerp(StartSize, EndSize, t);
            }
        }
    }
}

ParticleEmitter.cs

using System;
using System.Collections.Generic;
using OpenTK;
using OpenTK.Graphics.OpenGL4;

namespace ParticleSystem
{
    public class ParticleEmitter
    {
        private List<Particle> particles;
        private Vector2 position;
        private int rate;
        private float particleLifetime;
        private Vector4 startColor;
        private Vector4 endColor;
        private float startSize;
        private float endSize;
        private Random random;
        private Vector2 gravity;
        private Vector2 wind;

        public ParticleEmitter(Vector2 position, int rate, float particleLifetime, Vector4 startColor, Vector4 endColor, float startSize, float endSize)
        {
            this.position = position;
            this.rate = rate;
            this.particleLifetime = particleLifetime;
            this.startColor = startColor;
            this.endColor = endColor;
            this.startSize = startSize;
            this.endSize = endSize;
            particles = new List<Particle>();
            random = new Random();
            gravity = new Vector2(0, -9.8f);
            wind = new Vector2(0.5f, 0);
        }

        public void Emit()
        {
            for (int i = 0; i < rate; i++)
            {
                Vector2 velocity = new Vector2((float)(random.NextDouble() * 2 - 1), (float)(random.NextDouble() * 2 - 1));
                particles.Add(new Particle(position, velocity, particleLifetime, startColor, endColor, startSize, endSize));
            }
        }

        public void Update(float deltaTime)
        {
            Emit();
            for (int i = particles.Count - 1; i >= 0; i--)
            {
                particles[i].Update(deltaTime, gravity, wind);
                if (particles[i].Age >= particles[i].Lifetime)
                {
                    particles.RemoveAt(i);
                }
            }
        }

        public void Render(Shader shader)
        {
            foreach (var particle in particles)
            {
                if (particle.Age < particle.Lifetime)
                {
                    GL.PointSize(particle.Size);
                    GL.Begin(PrimitiveType.Points);
                    GL.Color4(particle.Color);
                    GL.Vertex2(particle.Position);
                    GL.End();
                }
            }
        }
    }
}

好的，让我们继续完成着色器文件的内容。

vertex_shader.glsl

#version 330 core

layout(location = 0) in vec2 inPosition;
layout(location = 1) in vec4 inColor;
layout(location = 2) in float inSize;

out vec4 fragColor;

void main()
{
    gl_Position = vec4(inPosition / vec2(400.0, 300.0) - 1.0, 0.0, 1.0);
    gl_PointSize = inSize;
    fragColor = inColor;
}

fragment_shader.glsl

#version 330 core

in vec4 fragColor;
out vec4 outColor;

uniform sampler2D particleTexture;

void main()
{
    vec4 texColor = texture(particleTexture, gl_PointCoord);
    outColor = fragColor * texColor;
}

纹理文件（particle.png）

确保 particle.png 是一个包含粒子图案的图像文件。你可以使用任何图像编辑工具创建一个简单的粒子图案，例如一个白色的圆形，保存为 PNG 格式。

运行代码

确保所有文件都在正确的位置，然后运行 Program.cs。你应该会看到一个粒子系统在屏幕上运行，粒子从发射器位置发射出来，并受到重力和风力的影响。

总结

通过以上步骤，我们实现了一个基本的粒子系统，并进行了多线程优化和 GPU 加速。我们还添加了重力和风力效果，使粒子系统更加逼真。可以根据需要进一步扩展和优化。

如果你有任何问题或需要进一步的帮助，请随时告诉我！

项目: 互动粒子仿真
辉小歌的博客
08-11 768
目录一、二、静态小球的初始化显示三、小球的运动与反弹四、小球运动的规范化五、鼠标的吸引力 一、 二、静态小球的初始化显示 代码如下： #include<stdio.h> #include<string.h> #include<graphics.h> #include<time.h> #include<math.h> #define WIDTH 1024 //屏幕的宽 #define HEIGHT 768 //屏幕的高 #define NUM_MO
【Visual C++】游戏开发笔记二十三 游戏基础物理建模(五) 粒子系统模拟(二)
编程资料大全
05-28 247
本系列文章由zhmxy555（毛星云）编写，转载请注明出处。 http://blog.csdn.net/zhmxy555/article/details/7607916 作者：毛星云 邮箱： happylifemxy@qq.com 期待着与志同道合的朋友们相互交流 本节在笔记二十二的基础上继续讲解了例子系统的模拟与实际运用，着重讲解和分析了基于例子系统的一个“星光绽放 demo...
基于Windows API的粒子随机运动C++实现
alaclp的专栏
04-15 2038
基于Windows API编写Windows动画演示程序，具有便捷、不依赖于IDE的特点。 以随机运动粒子系统为例，实现了该动画框架，C++代码与效果图像如下：
unity实现简单粒子系统
weixin_51376828的博客
11-08 544
unity实现简单粒子系统
opengl编写简单粒子系统
weixin_49656075的博客
06-02 1081
opengl实现简单的粒子系统
粒子系统实现与原理
微小的鱼的博客
09-30 4643
先简单讲述粒子的基本概念，包括分类等等，结合本人做过，在公司实现的粒子系统的思路、总结等等，包括未来也是比较新的粒子系统实现方式，根据需求制作一个粒子系统。
Unity的粒子系统
Ctrl+CV九段手
08-19 2072
Unity的粒子系统（Particle System）是一种强大的工具，用于在游戏和应用程序中创建各种视觉效果。它能够模拟并渲染许多称为粒子的小图像或网格，以产生火焰、烟雾、爆炸等自然现象和其他特效。
Unity粒子系统-粒子光环
qq_20549085的博客
11-05 1006
Unity粒子系统-粒子光环 前言 这是中山大学数据科学与计算机学院2019年3D游戏编程与设计的第八次作业 所有项目与代码已上传至github当中，欢迎大家访问。 github个人主页: https://starashzero.github.io 3D游戏编程与设计主页: https://starashzero.github.io/3DGameDesign 本次作业项目地址: https://g...
粒子系统属性总结
weixin_43052748的博客
10-16 1861
我们先来看看Particle System在Inspector视窗中的属性： 粒子总共有个Transform组件和Particle System组件。 一:Particle System 1.Transform：可以控制粒子在世界或者本地坐标的改变。但是有点注意的是，如果你改变Scale属性值是不会影响粒子的大小缩放的。所以我们想改变粒子大小不能这么改。 2.Particle System：改变粒...
unity-粒子系统
m0_74462339的博客
07-22 1011
在Unity中，粒子系统（Particle System）是一种用于模拟复杂效果的工具，比如火焰、烟雾、雨、雪、爆炸等。粒子系统通过生成和控制大量小粒子来创建这些效果，每个粒子都是一个独立的图像或3D对象，具有独立的属性和行为。
Particles:带有 OpenGL 和 Qt 的简单粒子系统
06-12
使用 OpenGL 和 Qt 构建的简单粒子系统，支持渲染器、初始化器和运算符以进行类分配。 这个项目真的很有趣。 这是我第一次接触 OpenGL。 我将其公开作为参考。 它应该可以与 Qt 和 GCC 一起编译而不会出现问题。 ...
opengles简单粒子系统的实现
05-18
在"opengles简单粒子系统的实现"这个主题中，我们将探讨如何使用OpenGL ES来构建一个基础的粒子系统。粒子系统由大量的个体——粒子组成，每个粒子都有自己的属性，如位置、速度、大小、颜色和生命周期。通过控制...
粒子系统简单框架实现
05-03
粒子系统的一个简单框架 class CParticleSystem; class CParticle { public: enum TYPE { VISTUAL, PARTICLE_SYSTEM }; public: CParticle(VOID); virtual ~CParticle(VOID); public: INT liveFrame; // ...
简单的粒子系统实现
04-14
在本文中，我们将深入探讨如何在Win32环境下实现一个简单的粒子系统。 首先，我们需要理解粒子系统的基本概念。粒子系统是通过大量小而简单的个体——粒子来模拟复杂视觉效果的方法。每个粒子都有自己的属性，如...
【零基础入门unity游戏开发——unity通用篇34】不同坐标系和坐标转换（基于unity6开发介绍）
最新发布
向宇
01-16 203
不同坐标系和坐标转换（基于unity6开发介绍）
Unity Protobuf实践
qilin598866753的博客
01-14 505
unity使用protobuf
【Unity3D日常开发】Unity3D中打开Window文件对话框打开文件（PC版）
CSDN博客专家，Unity3D高级软件工程师，《Unity 3D从入门到实战》作者。
01-13 984
这篇文章继续讲如何使用Unity3D打开Window文件对话框选择文件。【Unity3D日常开发】Unity3D中适用WEBGL打开Window文件对话框打开/上传文件是基于WEBGL的。这篇文章是基于PC端的，也就是打包后是exe的版本。
Win32汇编学习笔记11.游戏辅助的实现
彭于晏长沙分晏
01-13 891
您会发现显示的竟然是 Tutorial.exe+60C34 而不是 00460c34 这是为什么呢？其实 Tutorial.exe+60C34 就等于 00460c34一般来说游戏在电脑中申请的地址是从00400000开始的，Tutorial.exe代表的就是 00400000 然后加上 60c34 自然就等于 00460c34。但是在某些情况下游戏的起始地址并不是从00400000开始的，或者说每次启动申请的地址都不相同；
UnityDemo-TheBrave-制作笔记
lastXuanGod的博客
01-12 897
至此我们完成了玩家需求的基本功能：我们的玩家可以操控角色移动，跳跃，进行攻击以及受到攻击，会死亡，所有配套的动画都已经做好，现在让我们开始做敌人的需求。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

你一身傲骨怎能输

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值