A game about forced loneliness, made by TACStudios
tacstudios.tngl.sh
1# Transform Node
2
3## Description
4
5Returns the result of transforming the input value (**In**) from one coordinate space to another. Select dropdown options on the node to define which spaces to transform from and to.
6
7## Ports
8
9| Name | Direction | Type | Description |
10|:-----|:----------|:---------|:-------------|
11| In | Input | Vector 3 | Input value |
12| Out | Output | Vector 3 | Output value |
13
14## Controls
15
16| Name | Type | Options | Description |
17|:-----|:---------|:-----------------------------------------------------|:------------|
18| From | Dropdown | Object, View, World, Tangent, Absolute World, Screen | Select the space to convert from. |
19| To | Dropdown | Object, View, World, Tangent, Absolute World, Screen | Select the space to convert to. |
20| Type | Dropdown | Position, Direction, Normal | Select how you want to handle the conversion. |
21
22## Node Settings Controls
23
24The following control appears on the Node Settings tab of the Graph Inspector when you select the **Direction** or **Normal** conversion types for the Transform Node. The Normalize Output setting helps to improve performance as you can disable it if the output is already normalized, or if you don't need the output to remain normalized.
25
26| Name | Type | Description |
27|:-----------------|:---------|:------------|
28| Normalize Output | Checkbox | Reduces the length of the output vector to 1. |
29
30## World and Absolute World
31
32Use the **World** and **Absolute World** space options to transform the coordinate space of [position](Position-Node.md) values. The **World** space option uses the Scriptable Render Pipeline default world space to convert position values. The **Absolute World** space option uses absolute world space to convert position values in all Scriptable Render Pipelines.
33
34If you use the **Transform Node** to convert coordinate spaces that aren't for position values, Unity recommends that you use the **World** space option. Using **Absolute World** on values that don't represent position might result in unexpected behavior.
35
36## Conversion type
37
38Select the **Position** type to apply translation to the transformation. Select **Direction** if the input doesn't describe a surface normal (the direction a surface faces). Select **Normal** if the input describes a surface normal (the direction the surface faces).
39
40
41## Generated Code Example
42
43The following example code represents one possible outcome of this node per **Base** mode.
44
45**World > World**
46
47```
48float3 _Transform_Out = In;
49```
50
51**World > Object**
52
53```
54float3 _Transform_Out = TransformWorldToObject(In);
55```
56
57**World > Tangent**
58
59```
60float3x3 tangentTransform_World = float3x3(IN.WorldSpaceTangent, IN.WorldSpaceBiTangent, IN.WorldSpaceNormal);
61float3 _Transform_Out = TransformWorldToTangent(In, tangentTransform_World);
62```
63
64**World > View**
65
66```
67float3 _Transform_Out = TransformWorldToView(In);
68```
69**World > Absolute World**
70
71```
72float3 _Transform_Out = GetAbsolutePositionWS(In);
73```
74
75**World > Screen**
76
77```
78float4 hclipPosition = TransformWorldToHClipDir(In);
79float3 screenPos = hclipPosition.xyz / hclipPosition.w;
80float3 _Transform_Out = float3(screenPos.xy * 0.5 + 0.5, screenPos.z);
81```
82
83**Object > World**
84
85```
86float3 _Transform_Out = TransformObjectToWorld(In);
87```
88
89**Object > Object**
90
91```
92float3 _Transform_Out = In;
93```
94
95**Object > Tangent**
96
97```
98float3x3 tangentTransform_World = float3x3(IN.WorldSpaceTangent, IN.WorldSpaceBiTangent, IN.WorldSpaceNormal);
99float3 _Transform_Out = TransformWorldToTangent(TransformObjectToWorld(In), tangentTransform_World);
100```
101
102**Object > View**
103
104```
105float3 _Transform_Out = TransformWorldToView(TransformObjectToWorld(In));
106```
107**Object > Absolute World**
108
109```
110float3 _Transform_Out = GetAbsolutePositionWS(TransformObjectToWorld(In));
111```
112**Object > Screen**
113
114```
115float4 hclipPosition = TransformObjectToHClip(In);
116float3 screenPos = hclipPosition.xyz / hclipPosition.w;
117float3 _Transform_Out = float3(screenPos.xy * 0.5 + 0.5, screenPos.z);
118```
119**Tangent > World**
120
121```
122float3x3 transposeTangent = transpose(float3x3(IN.WorldSpaceTangent, IN.WorldSpaceBiTangent, IN.WorldSpaceNormal));
123float3 _Transform_Out = mul(In, transposeTangent).xyz;
124```
125
126**Tangent > Object**
127
128```
129float3x3 transposeTangent = transpose(float3x3(IN.WorldSpaceTangent, IN.WorldSpaceBiTangent, IN.WorldSpaceNormal));
130float3 _Transform_Out = TransformWorldToObject(mul(In, transposeTangent).xyz);
131```
132
133**Tangent > Tangent**
134
135```
136float3 _Transform_Out = In;
137```
138
139**Tangent > View**
140
141```
142float3x3 transposeTangent = transpose(float3x3(IN.WorldSpaceTangent, IN.WorldSpaceBiTangent, IN.WorldSpaceNormal));
143float3 _Transform_Out = TransformWorldToView(mul(In, transposeTangent).xyz);
144```
145**Tangent > Absolute World**
146
147```
148float3x3 transposeTangent = transpose(float3x3(IN.WorldSpaceTangent, IN.WorldSpaceBiTangent, IN.WorldSpaceNormal));
149float3 _Transform_Out = GetAbsolutePositionWS(mul(In, transposeTangent)).xyz;
150```
151
152**Tangent > Screen**
153
154```
155float3x3 transposeTangent = transpose(float3x3(IN.WorldSpaceTangent, IN.WorldSpaceBiTangent, IN.WorldSpaceNormal));
156float4 hclipPosition = TransformWorldToHClipDir(mul(In, transposeTangent).xyz);
157float3 screenPos = hclipPosition.xyz / hclipPosition.w;
158float3 _Transform_Out = float3(screenPos.xy * 0.5 + 0.5, screenPos.z);
159```
160
161**View > World**
162
163```
164float3 _Transform_Out = mul(UNITY_MATRIX_I_V, float4(In, 1)).xyz;
165```
166
167**View > Object**
168
169```
170float3 _Transform_Out = TransformWorldToObject(mul(UNITY_MATRIX_I_V, float4(In, 1) ).xyz);
171```
172
173**View > Tangent**
174
175```
176float3x3 tangentTransform_World = float3x3(IN.WorldSpaceTangent, IN.WorldSpaceBiTangent, IN.WorldSpaceNormal);
177float3 _Transform_Out = TransformWorldToTangent(mul(UNITY_MATRIX_I_V, float4(In, 1) ).xyz, tangentTransform_World);
178```
179
180**View > View**
181
182```
183float3 _Transform_Out = In;
184```
185**View > Absolute World**
186
187```
188float3 _Transform_Out = GetAbsolutePositionWS(mul(UNITY_MATRIX_I_V, float4(In, 1))).xyz;
189```
190
191**View > Screen**
192
193```
194float4 hclipPosition = TransformWViewToHClip(In);
195float3 screenPos = hclipPosition.xyz / hclipPosition.w;
196float3 _Transform_Out = float3(screenPos.xy * 0.5 + 0.5, screenPos.z);
197```
198
199**Absolute World > World**
200
201```
202float3 _Transform_Out = GetCameraRelativePositionWS(In);
203```
204
205**Absolute World > Object**
206
207```
208float3 _Transform_Out = TransformWorldToObject(In);
209```
210
211**Absolute World > Object (in the High Definition Render Pipeline)**
212
213```
214float3 _Transform_Out = TransformWorldToObject(GetCameraRelativePositionWS(In));
215```
216
217**Absolute World > Tangent**
218
219```
220float3x3 tangentTransform_World = float3x3(IN.WorldSpaceTangent, IN.WorldSpaceBiTangent, IN.WorldSpaceNormal);
221float3 _Transform_Out = TransformWorldToTangent(In, tangentTransform_World);
222```
223
224**Absolute World > View**
225
226```
227float3 _Transform_Out = GetCameraRelativePositionWS(In)
228```
229**Absolute World > Absolute World**
230
231```
232float3 _Transform_Out = In;
233```
234
235**Absolute World > Screen**
236
237```
238float4 hclipPosition = TransformWorldToHClip(GetCameraRelativePositionWS(In));
239float3 screenPos = hclipPosition.xyz / hclipPosition.w;
240float3 _Transform_Out = float3(screenPos.xy * 0.5 + 0.5, screenPos.z);
241```
242**Screen > World**
243
244```
245float3 _Transform_Out = ComputeWorldSpacePosition(In.xy, In.z, UNITY_MATRIX_I_VP);
246```
247
248**Screen > Object**
249```
250float3 worldPos = ComputeWorldSpacePosition(In.xy, In.z, UNITY_MATRIX_I_VP);
251float3 _Transform_Out = TransformWorldToObject(worldPos);
252```
253
254**Screen > Tangent**
255```
256float3 worldPos = ComputeWorldSpacePosition(In.xy, In.z, UNITY_MATRIX_I_VP);
257float3x3 tangentTransform_World = float3x3(IN.WorldSpaceTangent, IN.WorldSpaceBiTangent, IN.WorldSpaceNormal);
258float3 _Transform_Out = TransformWorldToTangent(worldPos, tangentTransform_World);
259```
260
261**Screen > View**
262```
263float4 positionCS = ComputeClipSpacePosition(In.xy, In.z);
264float4 result = mul(UNITY_MATRIX_I_V, positionCS);
265float3 _Transform_Out = result.xyz / result.w;
266```
267
268**Screen > Absolute World**
269
270```
271float3 _Transform_Out = GetAbsolutePositionWS(ComputeWorldSpacePosition(In.xy, In.z, UNITY_MATRIX_I_VP));
272```