Nomor acak hlsl

Bagaimana Anda menghasilkan angka acak di HLSL?

Saya bertanya karena saya ingin mencoba penelusuran gpu ray . Anda perlu membuat arah acak dalam shader piksel. Jadi saya ingin randFloat(), di mana hasilnya adalah angka acak antara -1 dan +1.

Juga, apa masalahnya dengan instruksi kebisingan hlsl ? Dokumen mengatakan itu dihapus dari HLSL 2.0 dan lebih tinggi. Mengapa ?

Saya membaca tentang pendekatan di mana Anda mengisi tekstur dengan nilai acak, kemudian memiliki koordinat tekstur di setiap titik yang memiliki indeks ke dalam tekstur itu. Tapi itu per vertex , saya butuh instruksi yang bisa saya panggil dalam pixel shader. Plus pendekatan ini membutuhkan "reseeding" texcoords per-vertex jika Anda ingin nilai yang berbeda setiap frame, dan yang memerlukan buffer vertex memperbarui setiap frame (yang bisa mahal!)

Dengan detail, bagaimana Anda bisa dengan murah menghasilkan angka acak pada GPU?

Angka acak semu dalam pixel shader tidak mudah diperoleh. Generator angka acak semu pada CPU akan memiliki beberapa status yang dibaca dan ditulis, pada setiap panggilan ke fungsi. Anda tidak dapat melakukannya dalam pixel shader.

Berikut beberapa opsi:

1. Gunakan compute shader dan bukan pixel shader - mereka mendukung akses baca-tulis ke buffer, sehingga Anda dapat mengimplementasikan PRNG standar apa pun.

2. Sampel dari satu atau lebih tekstur yang berisi data acak, berdasarkan parameter seperti posisi ruang layar. Anda juga dapat melakukan beberapa matematika pada posisi sebelum menggunakannya untuk melihat ke dalam tekstur, yang seharusnya memungkinkan Anda menggunakan kembali tekstur jika matematika melibatkan konstanta shader acak-per-gambar-panggilan.

3. Temukan beberapa fungsi matematika dari posisi ruang layar, yang memberikan hasil yang 'cukup acak'.

Pencarian google cepat menemukan halaman ini dengan fungsi-fungsi ini:

float rand_1_05(in float2 uv)
{
    float2 noise = (frac(sin(dot(uv ,float2(12.9898,78.233)*2.0)) * 43758.5453));
    return abs(noise.x + noise.y) * 0.5;
}

float2 rand_2_10(in float2 uv) {
    float noiseX = (frac(sin(dot(uv, float2(12.9898,78.233) * 2.0)) * 43758.5453));
    float noiseY = sqrt(1 - noiseX * noiseX);
    return float2(noiseX, noiseY);
}

float2 rand_2_0004(in float2 uv)
{
    float noiseX = (frac(sin(dot(uv, float2(12.9898,78.233)      )) * 43758.5453));
    float noiseY = (frac(sin(dot(uv, float2(12.9898,78.233) * 2.0)) * 43758.5453));
    return float2(noiseX, noiseY) * 0.004;
}

Inilah cara saya menghasilkan angka acak semu untuk efek partikel saya dengan penghitung komputasi. Tidak yakin seberapa benar acak kode ini, tetapi berfungsi cukup baik untuk tujuan saya.

Kunci untuk memberikan setiap kernel GPU urutan acak itu sendiri adalah untuk memberi makan penghitung benih awal acak dari CPU. Setiap kernel kemudian menggunakan seed ini untuk memutus generator nomor menggunakan id utas itu sebagai hitungan. Dari sana, setiap utas harus memiliki benih uniknya sendiri untuk menghasilkan nilai unik.

// Source
// http://www.gamedev.net/topic/592001-random-number-generation-based-on-time-in-hlsl/
// Supposebly from the NVidia Direct3D10 SDK
// Slightly modified for my purposes
#define RANDOM_IA 16807
#define RANDOM_IM 2147483647
#define RANDOM_AM (1.0f/float(RANDOM_IM))
#define RANDOM_IQ 127773u
#define RANDOM_IR 2836
#define RANDOM_MASK 123459876

struct NumberGenerator {
    int seed; // Used to generate values.

    // Returns the current random float.
    float GetCurrentFloat() {
        Cycle();
        return RANDOM_AM * seed;
    }

    // Returns the current random int.
    int GetCurrentInt() {
        Cycle();
        return seed;
    }

    // Generates the next number in the sequence.
    void Cycle() {  
        seed ^= RANDOM_MASK;
        int k = seed / RANDOM_IQ;
        seed = RANDOM_IA * (seed - k * RANDOM_IQ ) - RANDOM_IR * k;

        if (seed < 0 ) 
            seed += RANDOM_IM;

        seed ^= RANDOM_MASK;
    }

    // Cycles the generator based on the input count. Useful for generating a thread unique seed.
    // PERFORMANCE - O(N)
    void Cycle(const uint _count) {
        for (uint i = 0; i < _count; ++i)
            Cycle();
    }

    // Returns a random float within the input range.
    float GetRandomFloat(const float low, const float high) {
        float v = GetCurrentFloat();
        return low * ( 1.0f - v ) + high * v;
    }

    // Sets the seed
    void SetSeed(const uint value) {
        seed = int(value);
        Cycle();
    }
};