Sistem Partikel GPU Login

GPUSicing menawarkan peningkatan kinerja besar dibandingkan dengan rendering CPU. Anda dapat menggunakannya jika Anda ingin particle systemKomponen yang mensimulasikan entitas fluida seperti cairan, awan dan nyala dengan menghasilkan dan memikat sejumlah besar gambar 2D kecil di tempat kejadian. More info
Lihat di Glossary Anda untuk membuat partikel MeshGrafik utama primitif Unity. Mesh membuat sebagian besar dunia 3D Anda. Unity mendukung mesh poligon triangulat atau Quadrangulasi. Nurbs, Nurms, permukaan Subdiv harus dikonversi ke poligon. More info
Lihat di Glossary (selain dengan default mode rendering dari rendering partikel billboardObjek 2D bertekstur yang berputar sehingga selalu menghadapi Kamera. More info
Lihat di Glossary).

Untuk dapat menggunakan GPU dengan sistem partikel Anda:

• Login Mode renderer Sistem Partikel hingga Mesh

• Gunakan bahan shaderProgram yang berjalan di GPU. More info
  Lihat di Glossary untuk bahan renderer yang mendukung GPU Instancing

• Jalankan proyek Anda di platform yang mendukung GPUlawcing

Untuk mengaktifkan GPU tenggelam untuk sistem partikel, Anda harus mengaktifkan kotak centang Enable GPU Instancing dalam modul Renderer sistem partikel Anda.

Unity dilengkapi dengan naungan partikel built-in yang mendukung GPU tenggelam, tetapi bahan partikel default tidak menggunakannya, sehingga Anda harus mengubah ini untuk menggunakan GPU baycing. Partikel naungan yang mendukung GPU bayangan disebut Particles/Standard Surface. Untuk menggunakannya, Anda harus membuat materialAset yang menentukan bagaimana permukaan harus diberikan. More info
Lihat di Glossary baru Anda sendiri, dan mengatur warna material ke Particles/Standard Surface. Anda kemudian harus menetapkan materi baru ini ke bidang material dalam modul renderer Sistem Partikel.

Jika Anda menggunakan naungan yang berbeda untuk partikel Anda, itu harus menggunakan '#pragma target 4.5' atau lebih tinggi. Lihat Target Kompile untuk rincian lebih lanjut. Persyaratan ini lebih tinggi daripada GPU Instancing biasa dalam Unity karena Sistem Partikel menulis semua data instancenya ke penyanggaan besar tunggal, daripada memecah peninggalan ke beberapa panggilan menarik.

Contoh warna kustom

Anda juga dapat menulis warna kustom yang menggunakan GPU Instancing. Lihat bagian berikut untuk informasi lebih lanjut:

• Sistem partikel GPU Peningkatan dalam Shader Permukaan
• Sistem partikel GPU Mengimbangi Shader Kustom
• Mengkustomisasi data instance yang digunakan oleh Sistem Partikel (untuk bekerja bersama Custom Vertex Streams)

Sistem partikel GPU Peningkatan dalam Shader Permukaan

Berikut adalah contoh kerja lengkap dari Permukaan Shader menggunakan Sistem Partikel GPU Instancing:

Shader "Instanced/ParticleMeshesSurface" {
    Properties {
        _Color ("Color", Color) = (1,1,1,1)
        _MainTex ("Albedo (RGB)", 2D) = "white" {}
        _Glossiness ("Smoothness", Range(0,1)) = 0.5
        _Metallic ("Metallic", Range(0,1)) = 0.0
    }
    SubShader {
        Tags { "RenderType"="Opaque" }
        LOD 200

        CGPROGRAM
        // Physically based Standard lighting model, and enable shadows on all light types
        // And generate the shadow pass with instancing support
        #pragma surface surf Standard nolightmap nometa noforwardadd keepalpha fullforwardshadows addshadow vertex:vert
        // Enable instancing for this shader
        #pragma multi_compile_instancing
        #pragma instancing_options procedural:vertInstancingSetup
        #pragma exclude_renderers gles
        #include "UnityStandardParticleInstancing.cginc"
        sampler2D _MainTex;
        struct Input {
            float2 uv_MainTex;
            fixed4 vertexColor;
        };
        fixed4 _Color;
        half _Glossiness;
        half _Metallic;
        void vert (inout appdata_full v, out Input o)
        {
            UNITY_INITIALIZE_OUTPUT(Input, o);
            vertInstancingColor(o.vertexColor);
            vertInstancingUVs(v.texcoord, o.uv_MainTex);
        }

        void surf (Input IN, inout SurfaceOutputStandard o) {
            // Albedo comes from a texture tinted by color
            fixed4 c = tex2D (_MainTex, IN.uv_MainTex) * IN.vertexColor * _Color;
            o.Albedo = c.rgb;
            // Metallic and smoothness come from slider variables
            o.Metallic = _Metallic;
            o.Smoothness = _Glossiness;
            o.Alpha = c.a;
        }
        ENDCG
    }
    FallBack "Diffuse"
}

Ada sejumlah perbedaan kecil untuk Permukaan ShaderCara merampingkan naungan menulis untuk Pipeline Render Built-in. More info
Lihat di Glossary biasa dalam contoh di atas, yang membuatnya bekerja dengan partikel peninggalan.

Pertama, Anda harus menambahkan dua baris berikut untuk mengaktifkan Peningkatan Instancing, dan menentukan fungsi pengaturan simpul built-in. Fungsi ini hidup di UnityStandardParticleInstancing.cginc, dan memuat data posisi per-instance (per-partikel):

        #pragma instancing_options procedural:vertInstancingSetup
        #include "UnityStandardParticleInstancing.cginc"

Modifikasi lain dalam contohnya adalah fungsi Vertex, yang memiliki dua garis tambahan yang menerapkan atribut per-instance, khusus, warna partikel dan koordinasi tekstur Tekstur Lembar Animasi:

            vertInstancingColor(o.vertexColor);
            vertInstancingUVs(v.texcoord, o.uv_MainTex);

Sistem Partikel GPU Mengimbangi Shader Kustom

Berikut ini adalah contoh kerja lengkap dari Shader kustom menggunakan sistem partikel GPU bayangan. Shader kustom ini menambahkan fitur yang diwarnai partikel standar tidak memiliki - fade antara bingkai individu dari lembar tekstur animasi.

Shader "Instanced/ParticleMeshesCustom"
{
    Properties
    {
        _MainTex("Albedo", 2D) = "white" {}
        [Toggle(_TSANIM_BLENDING)] _TSAnimBlending("Texture Sheet Animation Blending", Int) = 0
    }
    SubShader
    {
        Tags{ "RenderType" = "Opaque" }
        LOD 100
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #pragma multi_compile __ _TSANIM_BLENDING
            #pragma multi_compile_instancing
            #pragma instancing_options procedural:vertInstancingSetup
            #include "UnityCG.cginc"
            #include "UnityStandardParticleInstancing.cginc"
            struct appdata
            {
                float4 vertex : POSITION;
                fixed4 color : COLOR;
                float2 texcoord : TEXCOORD0;
                UNITY_VERTEX_INPUT_INSTANCE_ID
            };
            struct v2f
            {
                float4 vertex : SV_POSITION;
                fixed4 color : COLOR;
                float2 texcoord : TEXCOORD0;
#ifdef _TSANIM_BLENDING
                float3 texcoord2AndBlend : TEXCOORD1;   
#endif
            };
            sampler2D _MainTex;
            float4 _MainTex_ST;
            fixed4 readTexture(sampler2D tex, v2f IN)
            {
                fixed4 color = tex2D(tex, IN.texcoord);
#ifdef _TSANIM_BLENDING
                fixed4 color2 = tex2D(tex, IN.texcoord2AndBlend.xy);
                color = lerp(color, color2, IN.texcoord2AndBlend.z);
#endif
                return color;
            }
            v2f vert(appdata v)
            {
                v2f o;
                UNITY_SETUP_INSTANCE_ID(v);
                o.color = v.color;
                o.texcoord = v.texcoord;
                vertInstancingColor(o.color);
#ifdef _TSANIM_BLENDING
                vertInstancingUVs(v.texcoord, o.texcoord, o.texcoord2AndBlend);
#else
                vertInstancingUVs(v.texcoord, o.texcoord);
#endif
                o.vertex = UnityObjectToClipPos(v.vertex);
                return o;
            }
            fixed4 frag(v2f i) : SV_Target
            {
                half4 albedo = readTexture(_MainTex, i);
                return i.color * albedo;
            }
            ENDCG
        }
    }
}

Contoh ini mengandung kode set-up yang sama sebagai Shader Permukaan untuk memuat data posisi:

        #pragma instancing_options procedural:vertInstancingSetup
        #include "UnityStandardParticleInstancing.cginc"

Modifikasi fungsi simpul sangat mirip dengan permukaan Shader juga:

                vertInstancingColor(o.color);
#ifdef _TSANIM_BLENDING
                vertInstancingUVs(v.texcoord, o.texcoord, o.texcoord2AndBlend);
#else
                vertInstancingUVs(v.texcoord, o.texcoord);
#endif

Satu-satunya perbedaan di sini, dibandingkan dengan contoh pertama di atas, adalah campuran animasi lembar tekstur. Ini berarti bahwa naungan membutuhkan set ekstra dari koordinat tekstur untuk membaca dua bingkai dari animasi lembar tekstur bukan hanya satu, dan memadukannya bersama.

Akhirnya, naungan fragmen membaca tekstur dan menghitung warna akhir.

Sistem partikel Login Mengimbangi aliran vertex kustom

Contoh di atas hanya menggunakan pengaturan aliran vertex default untuk partikel. Ini termasuk posisi, warna normal, dan satu UV. Namun, dengan menggunakan aliran vertex kustom, Anda dapat mengirim data lain ke naungan, seperti velocities, rotasi dan ukuran.

Dalam contoh berikutnya, warna dirancang untuk menampilkan efek khusus, yang membuat partikel yang lebih cepat tampak lebih cerah, dan partikel yang lebih lambat redup. Ada beberapa kode ekstra yang mencerahkan partikel sesuai dengan kecepatan mereka, menggunakan Speed Vertex Stream. Juga, karena naungan ini mengasumsikan efek tidak akan menggunakan animasi lembar tekstur, itu dihilangkan dari struct aliran kustom.

Berikut adalah Shader penuh:

Shader "Instanced/ParticleMeshesCustomStreams"
{
    Properties
    {
        _MainTex("Albedo", 2D) = "white" {}
    }
    SubShader
    {
        Tags{ "RenderType" = "Opaque" }
        LOD 100
        Pass
        {
            CGPROGRAM
#pragma exclude_renderers gles
            #pragma vertex vert
            #pragma fragment frag
            #pragma multi_compile_instancing
            #pragma instancing_options procedural:vertInstancingSetup
            #define UNITY_PARTICLE_INSTANCE_DATA MyParticleInstanceData
            #define UNITY_PARTICLE_INSTANCE_DATA_NO_ANIM_FRAME
            struct MyParticleInstanceData
            {
                float3x4 transform;
                uint color;
                float speed;
            };
            #include "UnityCG.cginc"
            #include "UnityStandardParticleInstancing.cginc"
            struct appdata
            {
                float4 vertex : POSITION;
                fixed4 color : COLOR;
                float2 texcoord : TEXCOORD0;
                UNITY_VERTEX_INPUT_INSTANCE_ID
            };
            struct v2f
            {
                float4 vertex : SV_POSITION;
                fixed4 color : COLOR;
                float2 texcoord : TEXCOORD0;
            };
            sampler2D _MainTex;
            float4 _MainTex_ST;
            v2f vert(appdata v)
            {
                v2f o;
                UNITY_SETUP_INSTANCE_ID(v);
                o.color = v.color;
                o.texcoord = v.texcoord;
                vertInstancingColor(o.color);
                vertInstancingUVs(v.texcoord, o.texcoord);
#if defined(UNITY_PARTICLE_INSTANCING_ENABLED)
                UNITY_PARTICLE_INSTANCE_DATA data = unity_ParticleInstanceData[unity_InstanceID];
                o.color.rgb += data.speed;
#endif
                o.vertex = UnityObjectToClipPos(v.vertex);
                return o;
            }
            fixed4 frag(v2f i) : SV_Target
            {
                half4 albedo = tex2D(_MainTex, i.texcoord);
                return i.color * albedo;
            }
            ENDCG
        }
    }
}

Naungan termasuk UnityStandardParticleInstancing.cginc, yang mengandung tata letak data default untuk ketika Custom Vertex Streams tidak digunakan. Jadi, ketika menggunakan aliran kustom, Anda harus menimpa beberapa default yang didefinisikan dalam header itu. Overrides ini harus datang before termasuk. Contoh di atas mengatur override kustom berikut:

Pertama, ada garis yang memberitahu Unity untuk menggunakan struct kustom yang disebut 'MyParticleInstanceData' untuk data aliran kustom, menggunakan UNITY_PARTICLE_INSTANCE_DATA macro:

            #define UNITY_PARTICLE_INSTANCE_DATA MyParticleInstanceData

Selanjutnya, yang lain mendefinisikan memberitahukan sistem peninggalan yang Anim Frame Stream tidak diperlukan dalam naungan ini, karena efek dalam contoh ini tidak dimaksudkan untuk digunakan dengan animasi lembar tekstur:

            #define UNITY_PARTICLE_INSTANCE_DATA_NO_ANIM_FRAME

Ketiga, struct untuk data aliran kustom diumumkan:

            struct MyParticleInstanceData
            {
                float3x4 transform;
                uint color;
                float speed;
            };

Ini menimpa semua datang sebelum UnityStandardParticleInstancing.cginc disertakan, sehingga naungan tidak menggunakan default sendiri untuk mereka mendefinisikan.

Ketika menulis struct Anda, variabel harus mencocokkan aliran simpul yang tercantum dalam modul renderer Sistem Partikel. Ini berarti Anda harus memilih aliran yang ingin Anda gunakan dalam modul Renderer InspectorJendela Unity yang menampilkan informasi tentang Pengaturan GameObject yang dipilih saat ini, aset atau proyek, memungkinkan Anda untuk memeriksa dan mengedit nilai. More info
Lihat di Glossary, dan menambahkannya ke definisi variabel dalam merusak data aliran kustom Anda dalam urutan yang sama, sehingga mereka cocok:UI(User Interface) Memungkinkan pengguna untuk berinteraksi dengan aplikasi Anda. Unity saat ini mendukung tiga sistem UI. More info
Lihat di Glossary, and add them to variable definitions in your custom stream data struct in the same order, so that they match:

Item pertama (Position) wajib, sehingga Anda tidak dapat menghapusnya. Anda dapat dengan bebas menambahkan / menghapus entri lain menggunakan tombol plus dan minus untuk menyesuaikan data aliran vertex Anda.

Entries dalam daftar yang diikuti oleh INSTANCED mengandung data instance, sehingga Anda harus memasukkannya dalam data instance partikel Anda. Jumlah langsung yang diajukan ke kata INSTANCED (misalnya nol dalam INSTANCED0 dan satu dalam INSTANCED1) menunjukkan urutan di mana variabel harus muncul di struct Anda, after variabel "transform". Huruf trailing (.x .xy .xyz atau .xyzw) menunjukkan jenis variabel dan peta untuk mengapung, mengapung2, mengapung3 dan mengapung4 jenis variabel dalam kode naungan Anda.

Anda dapat mengosongkan data aliran vertex lainnya yang muncul dalam daftar, tetapi itu melakukan not have kata INSTANCED setelah itu, dari contoh partikel data merusak, karena tidak dicontoh data yang diproses oleh naungan. Data ini termasuk dalam jaring sumber, misalnya UV, Normal dan Tangents.

Langkah terakhir untuk menyelesaikan contoh kami adalah untuk menerapkan kecepatan ke warna partikel di dalam Vertex ShaderProgram yang berjalan pada setiap simpul model 3D ketika model sedang diberikan. More info
Lihat di Glossary:

#if defined(UNITY_PARTICLE_INSTANCING_ENABLED)
                UNITY_PARTICLE_INSTANCE_DATA data = unity_ParticleInstanceData[unity_InstanceID];
                o.color.rgb += data.speed;
#endif

Anda harus membungkus semua kode penjahitan di dalam cek untuk UNITY_PARTICLE_INSTANCING_ENABLED, sehingga dapat mengkompilasi ketika peninggalan tidak digunakan.

Pada titik ini, jika Anda ingin melewati data ke Shader Fragment, Anda dapat menulis data ke dalam struct v2f, seperti Anda akan dengan data naungan lainnya.

Contoh ini menjelaskan cara memodifikasi Shader Kustom untuk digunakan dengan Custom Vertex Streams, tetapi Anda dapat menerapkan pendekatan yang sama dengan Permukaan Shader untuk mencapai fungsi yang sama.

---

• 2018–03–28 Sitemap

• Sistem Partikel GPU tenggelam ditambahkan dalam Unity 2018.1 Oktober 2018