Пример #1
0
        public void General(float r, float g, float b, TextureParam output, ShaderOp _shaderOp)
        {
            System.Diagnostics.Stopwatch timer = new System.Diagnostics.Stopwatch();
            timer.Start();

            Material mat = GetMaterial("CreateTexture");

            mat.SetVector("_Multiply", new Vector4(r, g, b, m_Value4));
            mat.SetVector("_Multiply2", new Vector4(m_Value5, m_Value6, m_Value7 * m_Value5, m_Value8 * m_Value6));
            SetCommonVars(mat);
            mat.SetFloat("_Frequency", m_frequency);
            mat.SetFloat("_Lacunarity", m_lacunarity);
            mat.SetFloat("_Gain", m_gain);
            mat.SetFloat("_Jitter", m_jitter);
            mat.SetFloat("_Octaves", m_Octaves);

            if (m_perlin != null)
            {
                mat.SetTexture("_PermTable1D", m_perlin.GetPermutationTable1D());
                mat.SetTexture("_Gradient2D", m_perlin.GetGradient2D());
            }
            m_debugGradient = m_perlin.GetGradient2D();
            RenderTexture destination = CreateRenderDestination(output);

            Graphics.Blit(null, destination, GetMaterial("CreateTexture"), (int)_shaderOp);
//        Debug.LogError(""+_shaderOp+" time: " + timer.ElapsedMilliseconds + " ms");
        }
Пример #2
0
    void Start()
    {
        m_perlin = new ImprovedPerlinNoise(m_seed);

        m_perlin.LoadResourcesFor2DNoise();

        GetComponent <Renderer>().material.SetTexture("_PermTable1D", m_perlin.GetPermutationTable1D());
        GetComponent <Renderer>().material.SetTexture("_Gradient2D", m_perlin.GetGradient2D());
    }
    // Use this for initialization
    void Start()
    {
        twoPowDimensionWidth = (int)Mathf.Pow(2, powerOfTwoSize);
        m_perlin             = new ImprovedPerlinNoise(m_seed);

        m_perlin.LoadResourcesFor2DNoise();
        compShade.SetTexture(compShade.FindKernel("CSProcGen"), "_Gradient2D", m_perlin.GetGradient2D());
        compShade.SetTexture(compShade.FindKernel("CSProcGen"), "_PermTable1D", m_perlin.GetPermutationTable1D());


        buffer[READ]  = new ComputeBuffer(twoPowDimensionWidth * twoPowDimensionWidth, sizeof(float), ComputeBufferType.Default);
        buffer[WRITE] = new ComputeBuffer(twoPowDimensionWidth * twoPowDimensionWidth, sizeof(float), ComputeBufferType.Default);
    }
Пример #4
0
    void InitMaps()
    {
        RTUtility.ClearColor(m_terrainField);
        RTUtility.ClearColor(m_waterOutFlow);
        RTUtility.ClearColor(m_waterVelocity);
        RTUtility.ClearColor(m_advectSediment);
        RTUtility.ClearColor(m_waterField);
        RTUtility.ClearColor(m_sedimentField);
        RTUtility.ClearColor(m_regolithField);
        RTUtility.ClearColor(m_regolithOutFlow);
        RTUtility.ClearColor(m_lavaOutFlow);
        RTUtility.ClearColor(m_lavaVelocity);
        RTUtility.ClearColor(m_lavaField);

        RenderTexture[] noiseTex = new RenderTexture[2];

        noiseTex[0]            = new RenderTexture(TEX_SIZE, TEX_SIZE, 0, RenderTextureFormat.RFloat);
        noiseTex[0].wrapMode   = TextureWrapMode.Clamp;
        noiseTex[0].filterMode = FilterMode.Bilinear;

        noiseTex[1]            = new RenderTexture(TEX_SIZE, TEX_SIZE, 0, RenderTextureFormat.RFloat);
        noiseTex[1].wrapMode   = TextureWrapMode.Clamp;
        noiseTex[1].filterMode = FilterMode.Bilinear;

        m_noiseMat.SetTexture("_PermTable1D", m_perlin.GetPermutationTable1D());
        m_noiseMat.SetTexture("_Gradient2D", m_perlin.GetGradient2D());

        for (int j = 0; j < 1; j++)
        {
            m_noiseMat.SetFloat("_Offset", m_offset[j]);

            float amp  = 0.5f;
            float freq = m_frequency[j];

            //Must clear noise from last pass
            RTUtility.ClearColor(noiseTex);

            //write noise into texture with the settings for this layer
            for (int i = 0; i < m_octaves[j]; i++)
            {
                m_noiseMat.SetFloat("_Frequency", freq);
                m_noiseMat.SetFloat("_Amp", amp);
                m_noiseMat.SetFloat("_Pass", (float)i);

                Graphics.Blit(noiseTex[READ], noiseTex[WRITE], m_noiseMat, (int)m_layerStyle[j]);
                RTUtility.Swap(noiseTex);

                freq *= m_lacunarity[j];
                amp  *= m_gain[j];
            }

            float useAbs = 0.0f;
            if (m_finalNosieIsAbs[j])
            {
                useAbs = 1.0f;
            }

            //Mask the layers that we dont want to write into
            Vector4 mask = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
            mask[j] = 1.0f;

            m_initTerrainMat.SetFloat("_Amp", m_amp[j]);
            m_initTerrainMat.SetFloat("_UseAbs", useAbs);
            m_initTerrainMat.SetVector("_Mask", mask);
            m_initTerrainMat.SetTexture("_NoiseTex", noiseTex[READ]);
            m_initTerrainMat.SetFloat("_Height", TERRAIN_HEIGHT);

            //Apply the noise for this layer to the terrain field
            Graphics.Blit(m_terrainField[READ], m_terrainField[WRITE], m_initTerrainMat);
            RTUtility.Swap(m_terrainField);
        }

        //dont need this tex anymore
        noiseTex[0] = null;
        noiseTex[1] = null;

        /*Texture2D myTexture2D = new Texture2D(1024,1024,TextureFormat.RGBAFloat,false);
         * string path = "Assets\\Textures\\terrain.raw";
         * myTexture2D.LoadRawTextureData(File.ReadAllBytes(path));
         * myTexture2D.Apply();
         * m_gridLand[0].AddComponent<GUITexture>();
         * m_gridLand[0].GetComponent<GUITexture>().texture = myTexture2D;
         * Graphics.Blit(myTexture2D, m_terrainField[READ]);*/
    }