Exemplo n.º 1
0
    public WaveSpectrumCPU(int size, float windSpeed, float waveAmp, float omega, int ansio, Vector4 gridSizes)
    {
        if (!Mathf.IsPowerOfTwo(size))
        {
            Debug.Log("WaveSpectrumCPU::WaveSpectrumCPU	- fourier grid size must be pow2 number, changing to nearest pow2 number");
            size = Mathf.NextPowerOfTwo(size);
        }

        //These are the recommend limits of wind speed and wave age, if you exceed them you may see artifacts or objects not floating at wave height
        if (windSpeed > 8.0f)
        {
            Debug.Log("WaveSpectrumCPU::WaveSpectrumCPU	- wind speed must be <= 8.0, changing to 8.0");
            windSpeed = 8.0f;
        }

        if (omega < 0.8f)
        {
            Debug.Log("WaveSpectrumCPU::WaveSpectrumCPU	- inverse wave age must be >= 0.8, changing to 0.8");
            m_omega = 0.8f;
        }

        if (waveAmp < 0.0 || waveAmp > 1.0)
        {
            Debug.Log("WaveSpectrumCPU::WaveSpectrumCPU	- wave amp must be between 0 and 1, clamping");
            Mathf.Clamp01(waveAmp);
        }

        m_size      = size;
        m_waveAmp   = waveAmp;
        m_windSpeed = windSpeed;
        m_omega     = omega;
        m_gridSizes = gridSizes;

        m_fsize        = (float)m_size;
        m_mipMapLevels = Mathf.Log(m_fsize) / Mathf.Log(2.0f);

        float factor = 2.0f * Mathf.PI * m_fsize;

        m_inverseGridSizes = new Vector4(factor / m_gridSizes.x, factor / m_gridSizes.y, factor / m_gridSizes.z, factor / m_gridSizes.w);

        m_heights        = new Vector2[m_size * m_size];
        m_fourierBuffer0 = new Vector2[2, m_size *m_size];
        m_fourierBuffer1 = new Vector4[2, m_size *m_size];
        m_fourierBuffer2 = new Vector4[2, m_size *m_size];

        m_fourier = new FourierCPU(m_size);

        m_map0            = new Texture2D(m_size, m_size, TextureFormat.RGB24, true, true);
        m_map0.wrapMode   = TextureWrapMode.Repeat;
        m_map0.filterMode = FilterMode.Trilinear;
        m_map0.anisoLevel = ansio;

        m_map1            = new Texture2D(m_size, m_size, TextureFormat.ARGB32, true, true);
        m_map1.wrapMode   = TextureWrapMode.Repeat;
        m_map1.filterMode = FilterMode.Trilinear;
        m_map1.anisoLevel = ansio;

        m_map2            = new Texture2D(m_size, m_size, TextureFormat.ARGB32, true, true);
        m_map2.wrapMode   = TextureWrapMode.Repeat;
        m_map2.filterMode = FilterMode.Trilinear;
        m_map2.anisoLevel = ansio;

        GenerateWavesSpectrum();
        CreateWTabele();
    }
Exemplo n.º 2
0
    float m_windSpeed = 8.0f; //A higher wind speed gives greater swell to the waves

    #endregion Fields

    #region Constructors

    public WaveSpectrumCPU(int size, float windSpeed, float waveAmp, float omega, int ansio, Vector4 gridSizes)
    {
        if(!Mathf.IsPowerOfTwo(size))
        {
            Debug.Log("WaveSpectrumCPU::WaveSpectrumCPU	- fourier grid size must be pow2 number, changing to nearest pow2 number");
            size = Mathf.NextPowerOfTwo(size);
        }

        //These are the recommend limits of wind speed and wave age, if you exceed them you may see artifacts or objects not floating at wave height
        if(windSpeed > 8.0f)
        {
            Debug.Log("WaveSpectrumCPU::WaveSpectrumCPU	- wind speed must be <= 8.0, changing to 8.0");
            windSpeed = 8.0f;
        }

        if(omega < 0.8f)
        {
            Debug.Log("WaveSpectrumCPU::WaveSpectrumCPU	- inverse wave age must be >= 0.8, changing to 0.8");
            m_omega = 0.8f;
        }

        if(waveAmp < 0.0 || waveAmp > 1.0)
        {
            Debug.Log("WaveSpectrumCPU::WaveSpectrumCPU	- wave amp must be between 0 and 1, clamping");
            Mathf.Clamp01(waveAmp);
        }

        m_size = size;
        m_waveAmp = waveAmp;
        m_windSpeed = windSpeed;
        m_omega = omega;
        m_gridSizes = gridSizes;

        m_fsize = (float)m_size;
        m_mipMapLevels = Mathf.Log(m_fsize)/Mathf.Log(2.0f);

        float factor = 2.0f * Mathf.PI * m_fsize;
        m_inverseGridSizes = new Vector4(factor/m_gridSizes.x, factor/m_gridSizes.y, factor/m_gridSizes.z, factor/m_gridSizes.w);

        m_heights = new Vector2[m_size*m_size];
        m_fourierBuffer0 = new Vector2[2, m_size*m_size];
        m_fourierBuffer1 = new Vector4[2, m_size*m_size];
        m_fourierBuffer2 = new Vector4[2, m_size*m_size];

        m_fourier = new FourierCPU(m_size);

        m_map0 = new Texture2D(m_size, m_size, TextureFormat.RGB24, true, true);
        m_map0.wrapMode = TextureWrapMode.Repeat;
        m_map0.filterMode = FilterMode.Trilinear;
        m_map0.anisoLevel = ansio;

        m_map1 = new Texture2D(m_size, m_size, TextureFormat.ARGB32, true, true);
        m_map1.wrapMode = TextureWrapMode.Repeat;
        m_map1.filterMode = FilterMode.Trilinear;
        m_map1.anisoLevel = ansio;

        m_map2 = new Texture2D(m_size, m_size, TextureFormat.ARGB32, true, true);
        m_map2.wrapMode = TextureWrapMode.Repeat;
        m_map2.filterMode = FilterMode.Trilinear;
        m_map2.anisoLevel = ansio;

        GenerateWavesSpectrum();
        CreateWTabele();
    }
Exemplo n.º 3
0
    void Start()
    {
        Nplus1 = N + 1;

        m_fourier = new FourierCPU(N);

        m_windDirection = new Vector2(m_windSpeed.x, m_windSpeed.y);
        m_windDirection.Normalize();

        m_dispersionTable = new float[Nplus1 * Nplus1];

        for (int m_prime = 0; m_prime < Nplus1; m_prime++)
        {
            for (int n_prime = 0; n_prime < Nplus1; n_prime++)
            {
                int index = m_prime * Nplus1 + n_prime;
                m_dispersionTable[index] = Dispersion(n_prime, m_prime);
            }
        }

        m_heightBuffer       = new Vector2[2, N *N];
        m_slopeBuffer        = new Vector4[2, N *N];
        m_displacementBuffer = new Vector4[2, N *N];

        m_spectrum      = new Vector2[Nplus1 * Nplus1];
        m_spectrum_conj = new Vector2[Nplus1 * Nplus1];
        m_position      = new Vector3[Nplus1 * Nplus1];

        m_mesh = MakeMesh(Nplus1);

        m_oceanGrid = new GameObject[m_numGridsX * m_numGridsZ];

        for (int x = 0; x < m_numGridsX; x++)
        {
            for (int z = 0; z < m_numGridsZ; z++)
            {
                int idx = x + z * m_numGridsX;

                m_oceanGrid[idx] = new GameObject("Ocean grid " + idx.ToString());
                m_oceanGrid[idx].AddComponent <MeshFilter>();
                m_oceanGrid[idx].AddComponent <MeshRenderer>();
                m_oceanGrid[idx].renderer.material = m_mat;
                m_oceanGrid[idx].GetComponent <MeshFilter>().mesh = m_mesh;
                m_oceanGrid[idx].transform.Translate(new Vector3(x * m_length - m_numGridsX * m_length / 2, 0.0f, z * m_length - m_numGridsZ * m_length / 2));
                m_oceanGrid[idx].transform.parent = this.transform;
            }
        }

        Random.seed = 0;

        Vector3[] vertices = m_mesh.vertices;

        for (int m_prime = 0; m_prime < Nplus1; m_prime++)
        {
            for (int n_prime = 0; n_prime < Nplus1; n_prime++)
            {
                int index = m_prime * Nplus1 + n_prime;

                m_spectrum[index] = GetSpectrum(n_prime, m_prime);

                m_spectrum_conj[index]    = GetSpectrum(-n_prime, -m_prime);
                m_spectrum_conj[index].y *= -1.0f;

                m_position[index].x = vertices[index].x = n_prime * m_length / N;
                m_position[index].y = vertices[index].y = 0.0f;
                m_position[index].z = vertices[index].z = m_prime * m_length / N;
            }
        }

        m_mesh.vertices = vertices;
        m_mesh.RecalculateBounds();

        CreateFresnelLookUp();
    }