Custom Shader Effector

float Freq_X < string propertyName = "Freq X"; > = 1.0f;
float Freq_Y < string propertyName = "Freq Y"; > = 0.0f;
float Freq_Z < string propertyName = "Freq Z"; > = 1.0f;
float Rotate_All = 0.0f;
float Scale_All = 0.0f;

// Would create a slider named Freq Y, which has the default range of -10.0 to 10,0, and a default value of 0.
float Freq_Y <
string propertyName = "Freq Y";
float propertyMin = -10.0f;
float propertyMax = 10.0f;
> = 0.0f;

// Would create a menu with options displayed as small and big, and would return 0 and 1 respectively.
float Size_Object <
string propertyName = "Size";
string propertyEnums[] = { "Small", "Big" };
> = 0.0f;

// Only process this clone if it's within the valid range and hasn't been killed
if (cloneIndex < numClones && RWCloneIndexBuffer[cloneIndex] != CLONE_KILLED_INDEX)
{
// Transform clone's local position into world space using the parent cloner's transform
float3 clonePos = mul(float4(RWClonePositionBuffer[cloneIndex], 1.0f), CloneParentTransformBuffer[cloneIndex]);

// Transform world position into the falloff node's local space for sampling
float3 falloffPos = mul(float4(clonePos, 1.0f), FalloffTransform).xyz;

// Sample the falloff value (0 yp1) at this clone's world position — defines the effector's region of influence
float falloff = GetFalloff(clonePos);

// Build a wave pattern across XYZ using sine/cosine of position * frequency + time, creating animated ripple movement
float effectArea = sin(falloffPos.x * Freq_X + AnimationTime) + cos(falloffPos.z * Freq_Z + AnimationTime) + sin(cos(falloffPos.y * Freq_Y + AnimationTime));

// Clamp effectArea to 0-1 so it can be safely used as a blend weight
effectArea = saturate(effectArea);

// Final influence amount — combines the spatial wave pattern with the falloff mask
float amt = effectArea * falloff;

// Target rotation: full spin on X (2π), quarter turn on Y (0.5π), no Z rotation
float3 rot = float3(2.0f * kPI, 0.5f * kPI, 0.0f);

// Blend clone's current rotation toward the target rotation based on effect influence
RWCloneRotationBuffer[cloneIndex] = lerp(RWCloneRotationBuffer[cloneIndex], rot, amt);

// Apply a global rotation offset on top of the blended result
RWCloneRotationBuffer[cloneIndex] +=
Rotate_All;

// Blend clone's scale toward Scale_All — note inverted weight (1-amt), so unaffected clones get scaled
RWCloneScaleBuffer[cloneIndex] = lerp(RWCloneScaleBuffer[cloneIndex], float3(1.0f, 1.0f, 1.0f) * Scale_All, 1.0f - amt);

// Blend clone colour toward a blue tint based on how strongly the effect is influencing this clone
RWCloneColourBuffer[cloneIndex] = lerp(RWCloneColourBuffer[cloneIndex], float4(0.50f, 0.50f, 1.0f, 1.0f), amt);

// If influence has effectively dropped to zero, kill this clone to remove it from the simulation
if (amt < 1e-4)
{
    RWCloneIndexBuffer[cloneIndex] =
CLONE_KILLED_INDEX;
}

#if 1
#include "FalloffShaderDef.h"
// Falloff API
// float GetFalloff(float3 pos);
// float4x4 FalloffTransform;
#endif

#define kPI	3.1415926535897932f

StructuredBuffer <uint> CloneCountBuffer : CLONECOUNTBUFFER;

// transform of the cloner node (could be from a cloned cloners chain)
StructuredBuffer<float4x4> CloneParentTransformBuffer : CLONEPARENTTRANSFORMBUFFER;

#define CLONE_KILLED_INDEX 0xFFFFFFFF
// cloned item index number, CLONE_KILLED_INDEX for removed clones
RWStructuredBuffer<uint> RWCloneIndexBuffer : RWCLONEINDEXBUFFER;

// cloner child node object index number
RWStructuredBuffer<uint> RWCloneObjectIndexBuffer : RWCLONEOBJECTINDEXBUFFER;

RWStructuredBuffer<float3> RWClonePositionBuffer : RWCLONEPOSITIONBUFFER;
RWStructuredBuffer<float3> RWCloneRotationBuffer : RWCLONEROTATIONBUFFER;
RWStructuredBuffer<float3> RWCloneScaleBuffer : RWCLONESCALEBUFFER;

RWStructuredBuffer<float4> RWCloneColourBuffer : RWCLONECOLOURBUFFER;
RWStructuredBuffer<float2> RWCloneUVScaleBuffer : RWCLONEUVSCALEBUFFER;
RWStructuredBuffer<float2> RWCloneUVOffsetBuffer : RWCLONEUVOFFSETBUFFER;


float4x4 EffectorWorldTransform : EFFECTORWORLDTRANSFORM;

float AnimationTime : ANIMATIONTIME;
float TimeDelta : TIMEDELTA;

sampler LinearClampSampler
{
	Filter = Min_Mag_Mip_Linear;
	AddressU = Clamp;
	AddressV = Clamp;
};
sampler LinearWrapSampler
{
	Filter = Min_Mag_Mip_Linear;
	AddressU = Wrap;
	AddressV = Wrap;
};


// -- Custom Shader Parameters --
// Set your custom shader parameters here. All global parameters without semantic ( : PARAM) binding are user params.
// The property name can be set with < ... > annotations or underscores like below (the underscores are converted as spaces in the name).
// The default values given here (= 1.0f; etc) propagate into the Notch property editor for new parameters.
// Supported annotations for properties:
// * string propertyName							- name shown in the Notch property editor
// * float propertyMin								- controls the default min range of the slider property
// * float propertyMax								- controls the default max range of the slider property
// * string propertyType = "colour" / "checkbox"	- when not given, float slider is used as default
// * string propertyEnums[] = { "Small", "Big" }	- a list of property enums, gives values 0,1,.. to the shader code

float Freq_X < string propertyName = "Freq X"; > = 1.0f;
float Freq_Y < string propertyName = "Freq Y"; > = 0.0f;
float Freq_Z < string propertyName = "Freq Z"; > = 1.0f;

float Rotate_All = 0.0f;
float Scale_All = 0.0f;

// Custom buffers can be used for state updates across frames.
// By default, each clone has one dedicated entry in the buffer (index with cloneIndex).
// The buffer content is cleared once to 0, and on node Reset input signal.
// The size of a buffer item has to be defined with the byteSize annotation like below.
RWStructuredBuffer<float> RWCustomCloneBuffer <int byteSize=4;>;



[numthreads(64,1,1)] void CS_ApplyEffector(uint3 GroupId : SV_GroupID, 
						uint3 DispatchThreadId : SV_DispatchThreadID,
						uint3 GroupThreadId : SV_GroupThreadID,
						uint GroupIndex : SV_GroupIndex)
{
	int cloneIndex = DispatchThreadId.x;
	uint numClones = CloneCountBuffer[0];

	if (cloneIndex < numClones && RWCloneIndexBuffer[cloneIndex] != CLONE_KILLED_INDEX)
	{
		float3 clonePos = mul(float4(RWClonePositionBuffer[cloneIndex], 1.0f), CloneParentTransformBuffer[cloneIndex]);
	
		float3 falloffPos = mul(float4(clonePos, 1.0f), FalloffTransform).xyz;
		float falloff = GetFalloff(clonePos);
		float effectArea = sin(falloffPos.x * Freq_X + AnimationTime) + cos(falloffPos.z * Freq_Z + AnimationTime) + sin(cos(falloffPos.y * Freq_Y + AnimationTime));
		effectArea = saturate(effectArea);

		float amt = effectArea * falloff;
	
		float3 rot = float3(2.0f * kPI, 0.5f * kPI, 0.0f);
	
		RWCloneRotationBuffer[cloneIndex] = lerp(RWCloneRotationBuffer[cloneIndex], rot, amt);
		RWCloneRotationBuffer[cloneIndex] += Rotate_All;
	
		RWCloneScaleBuffer[cloneIndex] = lerp(RWCloneScaleBuffer[cloneIndex], float3(1.0f, 1.0f, 1.0f) * Scale_All, 1.0f - amt);
		RWCloneColourBuffer[cloneIndex] = lerp(RWCloneColourBuffer[cloneIndex], float4(0.50f, 0.50f, 1.0f, 1.0f), amt);
	
		if (amt < 1e-4)
		{
			RWCloneIndexBuffer[cloneIndex] = CLONE_KILLED_INDEX;
		}
	}
}

technique11 ApplyEffector
{
	pass p0
	{
		SetComputeShader(CompileShader(cs_5_0, CS_ApplyEffector()));
	}
};

#if 1
#include "FalloffShaderDef.h"
#endif

#define kPI 3.1415926535897932f

StructuredBuffer<uint> CloneCountBuffer : CLONECOUNTBUFFER;
StructuredBuffer<float4x4> CloneParentTransformBuffer : CLONEPARENTTRANSFORMBUFFER;

#define CLONE_KILLED_INDEX 0xFFFFFFFF
RWStructuredBuffer<uint> RWCloneIndexBuffer : RWCLONEINDEXBUFFER;
RWStructuredBuffer<uint> RWCloneObjectIndexBuffer : RWCLONEOBJECTINDEXBUFFER;
RWStructuredBuffer<float3> RWClonePositionBuffer : RWCLONEPOSITIONBUFFER;
RWStructuredBuffer<float3> RWCloneRotationBuffer : RWCLONEROTATIONBUFFER;
RWStructuredBuffer<float3> RWCloneScaleBuffer : RWCLONESCALEBUFFER;
RWStructuredBuffer<float4> RWCloneColourBuffer : RWCLONECOLOURBUFFER;
RWStructuredBuffer<float2> RWCloneUVScaleBuffer : RWCLONEUVSCALEBUFFER;
RWStructuredBuffer<float2> RWCloneUVOffsetBuffer : RWCLONEUVOFFSETBUFFER;

float4x4 EffectorWorldTransform : EFFECTORWORLDTRANSFORM;
float AnimationTime : ANIMATIONTIME;
float TimeDelta : TIMEDELTA;

sampler LinearClampSampler
{
    Filter = Min_Mag_Mip_Linear;
    AddressU = Clamp;
    AddressV = Clamp;
};
sampler LinearWrapSampler
{
    Filter = Min_Mag_Mip_Linear;
    AddressU = Wrap;
    AddressV = Wrap;
};

// -- Custom Shader Parameters --

float Num_Clone_Types < 
    string propertyName = "Num Clone Types"; 
    float propertyMin = 1.0f; 
    float propertyMax = 10.0f; 
> = 2.0f;

float Weight_Clone_0 < string propertyName = "Weight Clone 0"; float propertyMin = 0.0f; float propertyMax = 1.0f; > = 0.1f;
float Weight_Clone_1 < string propertyName = "Weight Clone 1"; float propertyMin = 0.0f; float propertyMax = 1.0f; > = 0.1f;
float Weight_Clone_2 < string propertyName = "Weight Clone 2"; float propertyMin = 0.0f; float propertyMax = 1.0f; > = 0.1f;
float Weight_Clone_3 < string propertyName = "Weight Clone 3"; float propertyMin = 0.0f; float propertyMax = 1.0f; > = 0.1f;
float Weight_Clone_4 < string propertyName = "Weight Clone 4"; float propertyMin = 0.0f; float propertyMax = 1.0f; > = 0.1f;
float Weight_Clone_5 < string propertyName = "Weight Clone 5"; float propertyMin = 0.0f; float propertyMax = 1.0f; > = 0.1f;
float Weight_Clone_6 < string propertyName = "Weight Clone 6"; float propertyMin = 0.0f; float propertyMax = 1.0f; > = 0.1f;
float Weight_Clone_7 < string propertyName = "Weight Clone 7"; float propertyMin = 0.0f; float propertyMax = 1.0f; > = 0.1f;
float Weight_Clone_8 < string propertyName = "Weight Clone 8"; float propertyMin = 0.0f; float propertyMax = 1.0f; > = 0.1f;
float Weight_Clone_9 < string propertyName = "Weight Clone 9"; float propertyMin = 0.0f; float propertyMax = 1.0f; > = 0.1f;

// Per-clone assigned object index, persisted across frames so assignment is stable
RWStructuredBuffer<float> RWAssignedCloneType <int byteSize=4;>;


// -- Helper: Hash a uint to a float in 0-1 range --
// Used to generate a stable per-clone random value without a texture lookup
float HashToFloat(uint seed)
{
    seed = (seed ^ 61u) ^ (seed >> 16u);
    seed *= 9u;
    seed ^= seed >> 4u;
    seed *= 0x27d4eb2du;
    seed ^= seed >> 15u;
    return (float) (seed & 0x00FFFFFFu) / (float) 0x01000000u;
}


[numthreads(64, 1, 1)]void CS_ApplyEffector(uint3 GroupId : SV_GroupID,
                        uint3 DispatchThreadId : SV_DispatchThreadID,
                        uint3 GroupThreadId : SV_GroupThreadID,
                        uint GroupIndex : SV_GroupIndex)
{
    int cloneIndex = DispatchThreadId.x;
    uint numClones = CloneCountBuffer[0];

    if (cloneIndex < numClones && RWCloneIndexBuffer[cloneIndex] != CLONE_KILLED_INDEX)
    {
        // -- Build the weights array from individual parameters --
        float weights[10];
        weights[0] = Weight_Clone_0;
        weights[1] = Weight_Clone_1;
        weights[2] = Weight_Clone_2;
        weights[3] = Weight_Clone_3;
        weights[4] = Weight_Clone_4;
        weights[5] = Weight_Clone_5;
        weights[6] = Weight_Clone_6;
        weights[7] = Weight_Clone_7;
        weights[8] = Weight_Clone_8;
        weights[9] = Weight_Clone_9;

        int numTypes = (int) clamp(Num_Clone_Types, 1.0f, 10.0f);

        // -- Sum only the active weights so we can normalise against them --
        float totalWeight = 0.0f;
        for (int i = 0; i < numTypes; i++)
        {
            totalWeight += weights[i];
        }

        // -- Generate a stable random value for this clone based on its index --
        float randVal = HashToFloat((uint) cloneIndex) * totalWeight;

        // -- Walk the cumulative weight bands to pick a clone type --
        // e.g. weights [0.9, 0.1]: band 0 = 0.0-0.9, band 1 = 0.9-1.0
        // A randVal of 0.95 falls in band 1, so clone type 1 is selected
        uint selectedType = (uint) (numTypes - 1); // fallback to last type
        float cumulative = 0.0f;
        for (int j = 0; j < numTypes; j++)
        {
            cumulative += weights[j];
            if (randVal < cumulative)
            {
                selectedType = (uint) j;
                break;
            }
        }

        // -- Write the selected object index --
        RWCloneObjectIndexBuffer[cloneIndex] = selectedType;

        // -- Persist the assignment so it remains stable across frames --
        RWAssignedCloneType[cloneIndex] = (float) selectedType;
    }
}

technique11 ApplyEffector
{
    pass p0
    {
        SetComputeShader(CompileShader(cs_5_0, CS_ApplyEffector()));
    }
};