1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
|
#include "interpolators.cginc"
#include "globals.cginc"
#include "math.cginc"
#ifndef __CLONES_INC
#define __CLONES_INC
#if defined(_CLONES)
void rotate_triangle(inout v2f tri_in[3], const float pid_rand, const float phase)
{
if (phase < 1E-6) {
return;
}
float3 avg_pos = (tri_in[0].worldPos + tri_in[1].worldPos + tri_in[2].worldPos) * .33333333;
tri_in[0].worldPos -= avg_pos;
tri_in[1].worldPos -= avg_pos;
tri_in[2].worldPos -= avg_pos;
if (phase > 1E-6) {
float theta = phase * 3.14159 * 4 + phase * (sin(_Time[1] * (1 + pid_rand) * 0.5 + pid_rand) + cos(_Time[1] * (1 + pid_rand) * .16393442 + pid_rand) * 2) * pid_rand * 2;
float3 axis = normalize(float3(
rand((int) ((tri_in[0].uv0.x + tri_in[0].uv0.y + pid_rand) * 1E9)) * 2 - 1,
rand((int) ((tri_in[1].uv0.x + tri_in[1].uv0.y + pid_rand) * 1E9)) * 2 - 1,
rand((int) ((tri_in[2].uv0.x + tri_in[2].uv0.y + pid_rand) * 1E9)) * 2 - 1));
float4 quat = get_quaternion(axis, theta);
tri_in[0].worldPos = rotate_vector(tri_in[0].worldPos, quat);
tri_in[1].worldPos = rotate_vector(tri_in[1].worldPos, quat);
tri_in[2].worldPos = rotate_vector(tri_in[2].worldPos, quat);
}
tri_in[0].worldPos *= _Clones_Scale.xyz;
tri_in[1].worldPos *= _Clones_Scale.xyz;
tri_in[2].worldPos *= _Clones_Scale.xyz;
tri_in[0].worldPos += avg_pos;
tri_in[1].worldPos += avg_pos;
tri_in[2].worldPos += avg_pos;
float3 v0_objPos = mul(unity_WorldToObject, float4(tri_in[0].worldPos, 1));
float3 v1_objPos = mul(unity_WorldToObject, float4(tri_in[1].worldPos, 1));
float3 v2_objPos = mul(unity_WorldToObject, float4(tri_in[2].worldPos, 1));
// Perf hack: Normal gets normalized in fragment shader anyway xdd
// TODO add a toggle to normalize in fragment or not; and use it to gate this
// optimization.
float3 n = cross(tri_in[1].worldPos - tri_in[0].worldPos, tri_in[2].worldPos - tri_in[0].worldPos);
tri_in[0].normal = n;
tri_in[1].normal = n;
tri_in[2].normal = n;
tri_in[0].pos = UnityObjectToClipPos(v0_objPos);
tri_in[1].pos = UnityObjectToClipPos(v1_objPos);
tri_in[2].pos = UnityObjectToClipPos(v2_objPos);
tri_in[0].objPos = v0_objPos;
tri_in[1].objPos = v1_objPos;
tri_in[2].objPos = v2_objPos;
}
void add_clones(in v2f clone_verts[3], inout TriangleStream<v2f> tri_out,
float pid_rand, float explode_phase)
{
if (_Clones_dx < 1E-6 &&
_Clones_dy < 1E-6 &&
_Clones_dz < 1E-6) {
return;
}
#if 0
float factor = _Tess_Factor;
if (_Clones_Dist_Cutoff > 0 && length(_WorldSpaceCameraPos - clone_verts[0].worldPos) > _Clones_Dist_Cutoff) {
factor = 1;
}
#endif
uint n_clones = (uint) round(_Clones_Count);
for (uint i = 0; i < (uint) n_clones; i++) {
v2f mod_verts[3] = clone_verts;
float3 offset = i;
offset = ((offset % 2) * 2 - 1) * (((offset) * 0.5) + 1) *
float3(_Clones_dx, _Clones_dy, _Clones_dz);
for (uint j = 0; j < 3; j++) {
#if 0
float3 objPos = mul(unity_WorldToObject, float4(mod_verts[j].worldPos, 1)).xyz;
objPos += offset;
mod_verts[j].worldPos = mul(unity_ObjectToWorld, float4(objPos, 1)).xyz;
#else
mod_verts[j].worldPos += offset;
#endif
}
#if 1
rotate_triangle(mod_verts, rand(pid_rand+i), /*phase=*/1);
#else
mod_verts[0].objPos = mul(unity_WorldToObject, float4(mod_verts[0].worldPos, 1));
mod_verts[1].objPos = mul(unity_WorldToObject, float4(mod_verts[1].worldPos, 1));
mod_verts[2].objPos = mul(unity_WorldToObject, float4(mod_verts[2].worldPos, 1));
mod_verts[0].pos = UnityObjectToClipPos(mod_verts[0].objPos);
mod_verts[1].pos = UnityObjectToClipPos(mod_verts[1].objPos);
mod_verts[2].pos = UnityObjectToClipPos(mod_verts[2].objPos);
#endif
tri_out.Append(mod_verts[0]);
tri_out.Append(mod_verts[1]);
tri_out.Append(mod_verts[2]);
tri_out.RestartStrip();
}
}
#endif // _CLONES
#endif // __CLONES_INC
|
