ZFX + Developia

Code: Alles auswählen

#ifdef NOISE_FBM
    //Good FBM values
    #define     NoiseOctaves    4
    #define     NoiseFrequency    0.0003    // 0.0003 for 6371 radius
    #define     NoiseAmplitude    1.0
    #define     NoiseLacunarity    2.418
    #define     NoiseGain        0.5
#endif

//An FBM [Fractal Brownian Motion] noise call
float FBM(float3 p, int octaves, float frequency, float amplitude, float lacunarity, float gain)
{
	float noise = 0.0f;           
	for (int i = 0; i < octaves; ++i)
	{
			noise += snoise(p.xyz * frequency) * amplitude;         
			frequency *= lacunarity;
			amplitude *= gain;
	}
    return noise;
}


//The kernel for this compute shader, each thread group contains a number of threads specified by numthreads(x,y,z)
//We lookup the the index into the flat array by using x + y * x_stride
//The position is calculated from the thread index and then the z component is shifted by the Wave function
//[numthreads(threadsPerGroup_X,threadsPerGroup_Y,1)]
[numthreads(1,1,1)]

// Do position calculations
void CSMain1 (uint3 id : SV_DispatchThreadID)
{
	...

	// Next we generate the noise value using the patch's 'real-world' coordinate (patchCoord)
	#ifdef NOISE_FBM
		float noise = FBM(patchCoord, NoiseOctaves + constants.nodeLevel, NoiseFrequency, NoiseAmplitude, 	NoiseLacunarity, NoiseGain);
	#elif defined NOISE_VORONOI
		float noise = Voronoi(patchCoord, NoiseOctaves, NoiseFrequency, NoiseAmplitude, NoiseLacunarity, NoiseGain);
	#elif defined NOISE_SIMPLEXNOISE
		float noise = SimplexNoise(patchCoord,NoiseFrequency,NoiseAmplitude);
	#endif

	...
}

Code: Alles auswählen

    /// <summary>
    /// Called for rendering the planet each frame. It sets the material and calls the shader to draw all elements in the QuadtreeTerrainRenderQueue
    /// </summary>
    void OnRenderObject()
    {
        for (int i = 0; i < this.QuadtreeTerrainRenderQueue.Count; i++)
        {
            QuadtreeTerrain quadtreeTerrain = (QuadtreeTerrain)this.QuadtreeTerrainRenderQueue[i];
            if (quadtreeTerrain.quadtreeTerrainState == QuadtreeTerrain.QuadtreeTerrainState.READY)
            {
                quadtreeTerrain.material.SetBuffer("patchGeneratedFinalDataBuffer", quadtreeTerrain.patchGeneratedFinalDataBuffer);
                Graphics.DrawMesh(this.prototypeMesh, transform.localToWorldMatrix, quadtreeTerrain.material, LayerMask.NameToLayer(GlobalVariablesManager.Instance.layerLocalSpaceName), null, 0, null, true, true);
            }
        }
    }

Code: Alles auswählen

float w = 32
float h = 32;
float3 normalRGB = float3(id.x/w,id.y/h,1);
patchGeneratedNormalMapTexture[id] = float4(normalRGB,1);

Code: Alles auswählen

o.uv_MainTex = v.texcoord.xy;

Code: Alles auswählen

fixed3 crgb = tex2D(MainTex, IN.uvMainTex).rgb;
fixed4 c = float4(crgb, 1);
o.Albedo = clamp(c.rgb, fixed3(0, 0, 0), fixed3(1, 1, 1));

Code: Alles auswählen

float3 normalRGB = float3(1,0,0);
[i]oder[/i]
float3 normalRGB = float3(0,1,0);
[i]oder[/i]
float3 normalRGB = float3(0,0,1);
patchGeneratedNormalMapTexture[id] = float4(normalRGB,1);

Code: Alles auswählen

float3 normalRGB = float3(noise,noise,noise);
patchGeneratedNormalMapTexture[id] = float4(normalRGB,1);

Code: Alles auswählen

float3 normalRGB = normal.xyz;
patchGeneratedNormalMapTexture[id] = float4(normalRGB,1);

Code: Alles auswählen

float3 normalRGB = normal.xyz;
patchGeneratedNormalMapTexture[id] = float4(normalRGB,1);

Code: Alles auswählen

o.uv_NormalMap = v.texcoord.xy;

Code: Alles auswählen

fixed3 normal = tex2D(NormalMap, IN.uvNormalMap);
o.Normal = normal;

Code: Alles auswählen

uint2 normalMapID = uint2(id.y,id.x);
patchGeneratedNormalMapTexture[normalMapID] = float4(normalRGB,1);

Code: Alles auswählen

using UnityEngine;
using System.Collections.Generic;

/// <summary>
/// Author: Joerg Zdarsky | joerg.zdarsky@gmx.de
/// Date: 2016-08-05
/// SharedTexture includes a Texture2D object that is meant to be used across different slots. Thus, it is larger in one dimension as the textures used "in the outer context".
/// The first segment of the texture is meant to have index 0.
/// The Width of the texture is always the same (applied in the constructor), while the height extends with the number of indexes.
/// E.g. a texture with width=64 can be 64x64 (slots=1) or 64x128 (slots=2) or 64x196 (slots=3) and so on. Its dimension only increases at the height.
/// </summary>
public class SharedTexture : MonoBehaviour {

    public string UUID;
    public RenderTexture texture;       // The core texture that is shared across
    public bool[] isUsable;             // Array of bools, where each bool marks if a slot is usable
    private int singleWidth;            // Width of single texture area among the shared texture
    private int slotsWidth;             // Number of texture slots in width direction
    private int slotsHeight;            // Number of texture slots in height direction

    /// <summary>
    /// Constructor
    /// </summary>
    /// <param name="singleWidth">Width of texture</param>
    /// <param name="slotsHeight">Maximum number of texture slots among the shared texture. 1 slot means that the texture is only used once while 2 slots means a shared texture is used twice.</param>
    public SharedTexture(int singleWidth, int slotsWidth, int slotsHeight, RenderTextureFormat renderTextureFormat)
    {
        // Check parameters
        if (singleWidth * slotsWidth > 8192)
            Debug.LogWarning("SharedTexture::With the provided values of single texture width and slots your texture width exceeds 8192 pixels which is not supported on most graphic cards.");
        if (singleWidth * slotsHeight > 8192)
            Debug.LogWarning("SharedTexture::With the provided values of single texture width and slots your texture height exceeds 8192 pixels which is not supported on most graphic cards.");
        if (singleWidth > 8192)
            Debug.LogWarning("SharedTexture::Your width exceeds 8192 pixels which is not supported on most graphic cards.");
        if (singleWidth < 32)
            Debug.LogWarning("SharedTexture::Your width is below 32 pixels which is not recommended for efficiency reasons.");
        if (singleWidth < 1)
            Debug.LogError("SharedTexture::You width is below 1 pixel.");

        // Set the core variables
        this.UUID = new System.Guid().ToString();
        this.singleWidth = singleWidth;
        this.slotsWidth = slotsWidth;
        this.slotsHeight = slotsHeight;

        // Initialize texture
        this.texture = new RenderTexture(singleWidth * slotsWidth, singleWidth * slotsHeight, 0, renderTextureFormat);
        this.texture.enableRandomWrite = true;
        this.texture.Create();

        // Initialize Slot Indicator array
        this.isUsable = new bool[slotsWidth * slotsHeight];
        for (int i = 0; i < isUsable.Length; i++)
            this.isUsable[i] = true;
        Debug.Log("SharedTexture::Initialized with constructor. Overall texture dimension=" + texture.width+"x"+texture.height+". Slots="+this.isUsable.Length);
    }

    /// <summary>
    /// Returns if the texture is being used in one of its slots.
    /// </summary>
    /// <returns>true if one of the texture slots of the shared texture is being used, false if none of the texture slots are being used.</returns>
    public bool isTextureUsed()
    {
        bool result = false;
        for (int i = 0; i < isUsable.Length; i++)
            if (this.isUsable[i] == false) return true;
        return result;
    }

    /// <summary>
    /// Returns if the texture slot is usable (free and not out of array).
    /// </summary>
    /// <param name="slot">index of the slot (0 to n)</param>
    /// <returns>returns if the texture slot at the provided index is usable</returns>
    public bool isSlotUsable(int slot)
    {
        if (slot < 0 || slot > isUsable.Length - 1)
            Debug.LogError("SharedTexture::An isSlotUsable() was requested with the provided slot index being out of bounds. array=0 to " + (this.isUsable.Length - 1) + ", slot=" + slot);
        if (slot < 0 || slot > isUsable.Length - 1) return false;
        else return this.isUsable[slot];
    }

    /// <summary>
    /// Returns the PixelOffset vector of the requested index.
    /// </summary>
    /// <param name="slot">index of the slot (0 to n)</param>
    /// <returns>UVOffset Vector2</returns>
    public Vector2 PixelOffset(int slot)
    {
        if (slot < 0 || slot > isUsable.Length - 1)
            Debug.LogError("SharedTexture::PixelOffset(...) was requested with the provided slot index being out of bounds. array=0 to " + (this.isUsable.Length-1) + ", slot=" + slot);
        // Convert into 2d-index
        int x = slot % this.slotsWidth; 
        int y = slot / this.slotsWidth;
        Vector2 result = new Vector2(this.singleWidth * x, this.singleWidth * y);
        return result;
    }

    /// <summary>
    /// Returns the UVOffset vector of the requested index.
    /// </summary>
    /// <param name="slot">index of the slot (0 to n)</param>
    /// <returns>UVOffset Vector2</returns>
    public Vector2 UVOffset(int slot)
    {
        if (slot < 0 || slot > isUsable.Length - 1)
            Debug.LogError("SharedTexture::UVOffset(...) was requested with the provided slot index being out of bounds. array=0 to " + (this.isUsable.Length - 1) + ", slot=" + slot);
        // Convert into 2d-index
        int x = slot % this.slotsWidth;
        int y = slot / this.slotsWidth;
        Vector2 pixelOffset = this.PixelOffset(slot);
        float UVx = pixelOffset.x / (float)this.Width();
        float UVy = pixelOffset.y / (float)this.Height();
        Vector2 result = new Vector2(UVx, UVy);
        return result;
    }

    /// <summary>
    /// Returns the scaling and offset in a vector4
    /// </summary>
    /// <returns>x contains X tiling dimension value, y contains Y tiling dimension value, z contains X offset value, w contains Y offset value.
    /// Tiling dimension is the amount a slot is smaller than the overall texture dimension in width and height direction.</returns>
    public Vector4 Offset(int slot)
    {
        if (slot < 0 || slot > isUsable.Length - 1)
            Debug.LogError("SharedTexture::Offset(...) was requested with the provided slot index being out of bounds. array=0 to " + (this.isUsable.Length - 1) + ", slot=" + slot);
        Vector2 UVOffset = this.UVOffset(slot);
        Vector2 Scaling = new Vector2(1.0f / (float)this.slotsWidth, 1.0f / (float)this.slotsHeight);
        Vector4 result = new Vector4(Scaling.x, Scaling.y, UVOffset.x, UVOffset.y);
        return result;
    }

    /// <summary>
    /// Returns texture width
    /// </summary>
    /// <returns></returns>
    public int Width()
    {
        return texture.width;
    }

    /// <summary>
    /// Returns texture height
    /// </summary>
    /// <returns></returns>
    public int Height()
    {
        return texture.height;
    }

    /// <summary>
    /// Returns number of slots
    /// </summary>
    /// <returns></returns>
    public int Slots()
    {
        return this.isUsable.Length;
    }
}

Code: Alles auswählen

using UnityEngine;
using System.Collections.Generic;

/// <summary>
/// Author: Joerg Zdarsky | joerg.zdarsky@gmx.de
/// Date: 2016-08-05
/// SharedTextureManager manages the list of SharedTexture instances, and instanciates SharedTextureSlot instances.
/// It is taking care if a free slot is available in any of the SharedTexture instances, and does housekeeping if a SharedTextureSlot is being released.
/// </summary>
public class SharedTextureManager {

    public List<SharedTexture> sharedTextureList = new List<SharedTexture>();   // List of sharedTextures
    public int width;                                                           // Width of each SharedTexture. It also represents the height of a single texture slot.
    public int slotsWidth;                                                      // Number of slots of each SharedTexture in width direction
    public int slotsHeight;                                                     // Number of slots of each SharedTexture in height direction
    private RenderTextureFormat renderTextureFormat;                            // Type of RenderTextureFormat the shared textures are of
    private object type;

    /// <summary>
    /// Constructor
    /// </summary>
    /// <param name="slotsHeight">maximum slots per texture</param>
    /// <param name="width">width of the texture</param>
    public SharedTextureManager(int width, int slotsWidth, int slotsHeight, RenderTextureFormat renderTextureFormat)
    {
        this.sharedTextureList = new List<SharedTexture>();
        this.width = width;
        this.slotsWidth = slotsWidth;
        this.slotsHeight = slotsHeight;
        this.renderTextureFormat = renderTextureFormat;
        Debug.Log("SharedTextureManager::Initialized with constructor");
    }

    /// <summary>
    /// Returns a new SharedTextureSlot object
    /// </summary>
    /// <returns></returns>
    public SharedTextureSlot GetSharedTextureSlot()
    {
        // Create the new result object
        SharedTextureSlot sharedTextureSlot;

        // Try to find a free texture slot in the current list of SharedTextures and return it.
        for (int i=0;i<this.sharedTextureList.Count;i++)
        {
            for (int j=0;j< this.sharedTextureList[i].isUsable.Length;j++)
            {
                if (this.sharedTextureList[i].isUsable[j] == true)
                {
                    this.sharedTextureList[i].isUsable[j] = false;
                    sharedTextureSlot = new SharedTextureSlot(this.sharedTextureList[i],j, this);
                    return sharedTextureSlot;
                }
                    
            }
        }

        // If in the above query no free texture slot has been found, create a new SharedTexture, put it in the list and return it as result.
        Debug.Log("SharedTextureManager::No free slot in existing textures in sharedTextureList found. Adding new SharedTexture.");
        SharedTexture sharedTexture = new SharedTexture(this.width, this.slotsWidth, this.slotsHeight, this.renderTextureFormat);
        sharedTexture.isUsable[0] = false;
        this.sharedTextureList.Add(sharedTexture);
        sharedTextureSlot = new SharedTextureSlot(sharedTexture, 0, this);
        return sharedTextureSlot;
    }

    /// <summary>
    /// Releases the slot of the sharedTexture. Furthermore, if the texture is completely unused, it is nulled and removed from the sharedTextureList.
    /// </summary>
    /// <param name="sharedTextureSlot"></param>
    public void ReleaseSharedTextureSlot(SharedTextureSlot sharedTextureSlot)
    {
        // Release slot
        int slot = sharedTextureSlot.slot;
        sharedTextureSlot.sharedTexture.isUsable[slot] = true;
        // Check if housekeeping is possible
        if (sharedTextureSlot.sharedTexture.isTextureUsed() == false)
        {
            Debug.Log("SharedTextureManager::While releasing a SharedTextureSlot, the whole texture has been removed");
            sharedTextureSlot.sharedTexture.texture.Release(); 
            this.sharedTextureList.Remove(sharedTextureSlot.sharedTexture);
        }
        sharedTextureSlot = null;
    }
}

Code: Alles auswählen

using UnityEngine;
using System.Collections;

/// <summary>
/// Author: Joerg Zdarsky | joerg.zdarsky@gmx.de
/// Date: 2016-08-05
/// SharedTextureSlot is an instance of a shared texture (RenderTexture) which is managed in the background.
/// The dimension of the shared texture managed in the background is width x width*slots.
/// The idea is that, if e.g. multiple textures of 128x128 are required, these are stored in a single background texture in 128x128*slots texture.
/// The purpose is performance, as this single texture is uploaded once to the GPU and the GPU does not have to switch states when rendering multiple different objects.
/// </summary>
public class SharedTextureSlot : MonoBehaviour {

    public SharedTexture sharedTexture;
    public int slot;
    private SharedTextureManager sharedTextureManager;

    /// <summary>
    /// Constructor
    /// </summary>
    /// <param name="sharedTexture"></param>
    /// <param name="slot"></param>
    /// <param name="sharedTextureManager"></param>
    public SharedTextureSlot(SharedTexture sharedTexture, int slot, SharedTextureManager sharedTextureManager)
    {
        this.sharedTexture = sharedTexture;
        this.slot = slot;
        this.sharedTextureManager = sharedTextureManager;
    }

    /// <summary>
    /// Releases the shared texture.
    /// </summary>
    public void Release()
    {
        this.sharedTextureManager.ReleaseSharedTextureSlot(this);
    }

    /// <summary>
    /// Returns the shared texture.
    /// </summary>
    /// <returns></returns>
    public RenderTexture Texture()
    {
        return this.sharedTexture.texture;
    }

    /// <summary>
    /// Returns the PixelOffset of the shared texture.
    /// </summary>
    /// <returns></returns>
    public Vector2 PixelOffset()
    {
        return this.sharedTexture.PixelOffset(this.slot);
    }

    /// <summary>
    /// Returns the scaling and offset in a vector4
    /// </summary>
    /// <returns>x contains X tiling dimension value, y contains Y tiling dimension value, z contains X offset value, w contains Y offset value.
    /// Tiling dimension is the amount a slot is smaller than the overall texture dimension in width and height direction.</returns>
    public Vector4 Offset()
    {
        return this.sharedTexture.Offset(this.slot);
    }
}

Code: Alles auswählen

RWTexture2D<float4> patchGeneratedNormalMapTexture;

// Do normal calculation and create NormalMap and SurfaceTexture
void CSMain2 (uint2 id : SV_DispatchThreadID)
{
	// Get the constants
	GenerationConstantsStruct constants = generationConstantsBuffer[0];

	... calulcate normal....

	// Prepare Texture ID
	//uint2 textureID = uint2(id.y,id.x);
	uint2 textureID = uint2(id.y+constants.sharedNormalMapTextureSlotPixelOffset.x,id.x+constants.sharedNormalMapTextureSlotPixelOffset.y);

	// Create the ObjectSpace NormalMap
	....
	float3 normalRGB = normal.xyz /2;
	patchGeneratedNormalMapTexture[textureID] = float4(normalRGB,1);
}

Code: Alles auswählen

quadtreeTerrain.material.SetVector("_NormalMapOffset", quadtreeTerrain.sharedNormalMapTextureSlot.Offset());

Code: Alles auswählen

Shader "Custom/ProceduralPatch" {
	Properties{
		_MaterialTex("Albedo (RGB)", 2D) = "white" {}
		_SurfaceMap("Albedo (RGB)", 2D) = "white" {}
		_NormalMap("Albedo (RGB)", 2D) = "bump" {}
	}
	SubShader{
		Tags{ "RenderType" = "Opaque" }
		LOD 200

		CGPROGRAM

		#include "UnityCG.cginc"

		#pragma surface surf Standard fullforwardshadows
		#pragma vertex vert
		
		struct appdata_full_compute {
			float4 vertex : POSITION;
			float4 tangent : TANGENT;
			float3 normal : NORMAL;
			float4 texcoord : TEXCOORD0;
			float4 texcoord1 : TEXCOORD1;
			float4 texcoord2 : TEXCOORD2;
			float4 texcoord3 : TEXCOORD3;
			#if defined(SHADER_API_XBOX360)
				half4 texcoord4 : TEXCOORD4;
				half4 texcoord5 : TEXCOORD5;
			#endif
				fixed4 color : COLOR;
			#ifdef SHADER_API_D3D11
				uint id: SV_VertexID;
			#endif
		};

		struct OutputStruct {
			float4 position;
			float3 patchCenter;
		};

		float globalNoise;

		#pragma target 5.0
		sampler2D _MaterialTex;
		sampler2D _SurfaceMap;
		sampler2D _NormalMap;

		#ifdef SHADER_API_D3D11
				StructuredBuffer<OutputStruct>	patchGeneratedFinalDataBuffer;
		#endif

		struct Input {
			float2 uv_MaterialTex;
			float2 uv_SurfaceMap;
			float2 uv_NormalMap;
			float3 worldPos;
			float3 objPos;
		};

		uniform float4 _NormalMapOffset; // E.g. (1.0,0.25,0.0,0.5) for the third 64x64 texture slot in a 64x265 texture 

		void vert(inout appdata_full_compute v, out Input o)
		{
			UNITY_INITIALIZE_OUTPUT(Input, o);
			#ifdef SHADER_API_D3D11
				// Read Data from buffer
				float4 position = patchGeneratedFinalDataBuffer[v.id].position;
				float3 patchCenter = patchGeneratedFinalDataBuffer[v.id].patchCenter;

				// Perform changes to the data
				// Translate the patch to its 'planet-space' center:
				position.xyz += patchCenter;

				// Apply data
				v.vertex = float4(position);
				o.uv_MaterialTex = v.texcoord.xy;
				o.uv_SurfaceMap = v.texcoord.xy;
				o.uv_NormalMap = v.texcoord.xy;
				o.worldPos = mul(unity_ObjectToWorld, v.vertex);
				o.objPos = v.vertex;
			#endif
		}
	
		void surf(Input IN, inout SurfaceOutputStandard o)
		{
			// Apply normalmap
			fixed3 normal = tex2D(_NormalMap, IN.uv_NormalMap * _NormalMapOffset.xy + _NormalMapOffset.zw);
			o.Normal = normal;

			// Apply materialtexture
			fixed3 crgb = tex2D(_MaterialTex, IN.uv_MaterialTex).rgb;
			fixed4 c = fixed4(crgb, 1);

			o.Albedo = c;
			o.Alpha = c.a;
			
		}
		ENDCG
	}
FallBack "Diffuse"
}