{{tag>proxy part}}
{{htmlmetatags>metatag-keywords=(pac3, wiki, part, proxy, expression)
metatag-description=(Alters a value based on a mathematical expression.)
metatag-og:title=(Proxy | Part)
metatag-og:description=(Alters a value based on a mathematical expression.)
}}

====== Proxy ======
Alters a value based on a mathematical expression.

<block box compact>
{{fa>info?color=#3bb0ff&fw&lg}} Easy setup is useless, learn expressions.
</block> 


===== Location =====
This part can be found under: 
  * :poseparameter: **Modifier** > [[:part:proxy]]

{{page>:includes#location}}

===== Usage & Examples =====
<block box>
==== Basic proxy ====
  * Add a [[:part:proxy]] part to an existing part
  * Enter the name of the value with you want changed into <span code>[[#variable name]]</span> or click the (...) button to browse available part parameters
  * Enter a value or mathematical expression into <span code>[[#expression]]</span> (such as <span code>2+2</span> or <span code>sin(time())</span>)

<block box compact>
{{fa>download?color=#7ab353&fw&lg}} **Download:** {{:part:proxy:proxy_basic.txt}}
</block>
</block>

<block box>
==== Proxy targets ====
Proxies can affect parts that are not directly connected to them. Enter the name of the part into <span code>[[#target-part]]</span> or select it with the (...) button.

<block box compact>
{{fa>download?color=#7ab353&fw&lg}} **Download:** {{:part:proxy:proxy_target.txt}}
</block>
</block>


<block box>
==== Button Controlled Proxy - Simple Switch ====
Simple proxy switch. Press <span code>R</span> and <span code>T</span> to change size.

<block box compact>
{{fa>download?color=#7ab353&fw&lg}} **Download:** {{:part:proxy:proxy_button.txt}}
</block>
</block>

<block box>
==== Button Controlled Proxy - Feedback + Command ====
The <wrap code>command()</wrap> proxy can be changed at any time by using console commands, it can be used together with <wrap code>feedback()</wrap> to affect the previous proxy value. Below you'll find a simple example that lets you change the scale of a model using buttons (Hold <span code>F</span> to scale up and <span code>R</span> to scale down.)

<block box compact>
{{fa>download?color=#7ab353&fw&lg}} **Download:** {{:part:proxy:proxy_button_feedback.txt}}
</block>
</block>

<block box>
==== Affect children ====
<span code>[[#Affect children]]</span> sets the proxy to affect all of its children instead of the parent. This also disables the <span code>[[#target part]]</span> field.
</block>

<block box>
==== Multiple axes ====
Each proxy can use up to 3 <span code>[[#expression|expressions]]</span>, one for each axis (**X**, **Y**, **Z**). 
These expressions need to be separated with a comma <span code>,</span> Setting a value as <span code>nil</span> or <span code>null</span> will ignore the given axis.

Expression set to <span code>time(), null, 2+2</span> will set the **X** axis to **time()**, ignore the **Y** axis and set the **Z** axis to **4**. 

<block box compact>
{{fa>download?color=#7ab353&fw&lg}} **Download:** {{:part:proxy:proxy_axis.txt}}
</block>
<block box compact>
{{fa>fas fa-exclamation-circle?color=#ff9900&fw&lg}} This method conflicts with the <span code>[[#axis]]</span> field, if you wanna use it make sure that the <span code>[[#axis]]</span> field is empty.
</block>
</block>

===== Functions and Operations =====
The following is a list of operations/functions available to use in the <span code>[[#expression]]</span>

^**//Operation//** ^ **//Operator//** ^ **//Example//** ^
|Multiplication | <span code>*</span> | <span code>time()*2</span> |
|Division | <span code>/</span> | <span code>time()/2</span> |
|Addition | <span code>+</span> | <span code>time()+2</span> |
|Subtraction | <span code>-</span> | <span code>time()-2</span> |
|Parentheses | <span code>()</span> | <span code>3*(time()+2)</span> |
|Exponent |<span code><nowiki> ^ </nowiki></span>| <span code>time()<nowiki>^</nowiki>2</span> |
|[[https://en.wikipedia.org/wiki/Modular_arithmetic|Modulus]] | <span code>%</span> | <span code>time()%2</span> |

\\
//To use, enter an input value or expression between the parenthesis. Remember to respect the number of arguments in the function, since not all functions have one argument. <span code>clamp(x, %%min%%, %%max%%)</span> for example has three arguments.//
^**//Function//** ^ **//Explanation//** ^
|<span code>**abs(<text type="warning">x</text>)**</span>| Returns the [[https://en.wikipedia.org/wiki/Absolute_value|absolute value]] of a given number. \\ <span code><text type="warning">**x**</text></span> --- a number|
|<span code>**sgn(<text type="warning">**x**</text>)**</span>| Returns the sign of the given number (-1 for values below 0, 0 for 0 and 1 for values above 0). \\ <span code><text type="warning">**x**</text></span> --- a number|
^  ^^
|<span code>**ceil(<text type="warning">**x**</text>)**</span>| Rounds a number up. \\ <span code><text type="warning">**x**</text></span> --- a number|
|<span code>**floor(<text type="warning">**x**</text>)**</span>| Rounds a number down. \\ <span code><text type="warning">x</text></span> --- a number|
^  ^^
|<span code>**min(<text type="warning">**numbers**</text>)**</span>| Returns the smallest value of all arguments. \\ <span code><text type="warning">**numbers**</text></span> --- numbers to get the smallest from, separated with a comma (**,**) |
|<span code>**max(<text type="warning">**numbers**</text>)**</span>| Returns the largest value of all arguments. \\ <span code><text type="warning">**numbers**</text></span> - numbers to get the largest from, separated with a comma (**,**) |
|<span code>**clamp(<text type="warning">**x**</text>, <text type="warning">**%%min%%**</text>, <text type="warning">**%%max%%**</text>)**</span>| Clamps a number between a minimum and maximum value. \\ <span code><text type="warning">**x**</text></span> - the input value/function \\ <span code><text type="warning">**%%min%%**</text></span> - the minimum value that the function can return \\ <span code><text type="warning">**%%max%%**</text></span> - the maximum value that the function can return |
^  ^^
|<span code>**PI**</span>| This is **NOT** a function, it's a variable containing the mathematical constant pi: 3.1416...|
|<span code>**log(<text type="warning">x</text>, <text type="info">base</text>)**</span>| With one argument, returns the natural logarithm of <text type="warning">**x**</text> (to base e). With two arguments, returns the logarithm of <text type="warning">**x**</text> to the given <text type="info">**base**</text>. \\ <text type="warning">**x**</text> - a number\\ <text type="info">**base**</text> - the logarithmic base, optional|
|<span code>**log10(<text type="warning">x</text>)**</span>| Returns the base-10 logarithm of <span code><text type="warning">**x**</text></span>. This is usually more accurate than <span code>**log(<text type="warning">**x**</text>, 10)**</span>. \\ <span code><text type="warning">**x**</text></span> --- a number|
|**sqrt(<text type="warning">**x**</text>)**| Returns the square root of the number. \\ <text type="warning">**x**</text> - a number|
|**rand(<text type="info">**m**</text>, <text type="info">**n**</text>)**| When called without arguments returns a random float between 0 and 1. When called with one argument (<text type="info">**m**</text>) returns an integer between 1 and <text type="info">**m**</text>. When called with both arguments (<text type="info">**m**</text> and <text type="info">**n**</text>) returns an integer between <text type="info">**m**</text> and <text type="info">**n**</text>.\\ <text type="info">**m**</text> - lower limit (two arguments) or upper limit (one argument) \\ <text type="info">**n**</text> - upper limit|
|**randx(<text type="warning">**min**</text>, <text type="warning">**max**</text>)**| Returns a random float between min and max. \\ <text type="warning">**min**</text> - the minimum value \\ <text type="warning">**max**</text> - the maximum value|
^  ^^
|**rad(<text type="warning">x</text>)**| Returns the value converted to radians. \\ <text type="warning">**x**</text> - the angle measured in degrees |
|**deg(<text type="warning">x</text>)**| Returns the value converted to degrees. \\ <text type="warning">**x**</text> - the angle measured in radians  |
^  ^^
|**sin(<text type="warning">x</text>)**| Returns the [[http://en.wikipedia.org/wiki/sine|sine]] of a given angle. \\ <text type="warning">**x**</text> - angle in radians|
|**asin(<text type="warning">sin</text>)**| Returns the [[http://en.wikipedia.org/wiki/arc_sine|arc sine]] (an angle in radians, between -PI/2 and PI/2, which has the given sine value). NaN if the argument is out of range.  \\ <text type="warning">**sin**</text> - sine value in range of -1 to 1|
|**sinh(<text type="warning">x</text>)**| Returns the [[http://en.wikipedia.org/wiki/hyperbolic_sine|hyperbolic sine]] of the given angle. \\ <text type="warning">**x**</text> - angle in radians|
^  ^^
|**cos(<text type="warning">x</text>)**| Returns the [[http://en.wikipedia.org/wiki/cosine|cosine]] of a given angle. \\ <text type="warning">**x**</text> - angle in radians|
|**acos(<text type="warning">cos</text>)**| Returns the [[http://en.wikipedia.org/wiki/arc_cosine|arc cosine]] (an angle in radians, between 0 and PI, which has the given cosine value). NaN if the argument is out of range.  \\ <text type="warning">**cos**</text> - cosine value in range of -1 to 1|
|**cosh(<text type="warning">x</text>)**| Returns the [[http://en.wikipedia.org/wiki/hyperbolic_cosine|hyperbolic cosine]] of the given angle. \\ <text type="warning">**x**</text> - angle in radians|
^  ^^
|**tan(<text type="warning">x</text>)**| Returns the [[http://en.wikipedia.org/wiki/tangent_(trigonometry)|tangent]] of a given angle. \\ <text type="warning">**x**</text> - angle in radians|
|**atan(<text type="warning">tan</text>)**| Returns the [[http://en.wikipedia.org/wiki/arc_tangent|arc tangent]] (an angle in radians, between -pi/2 and pi/2, which has the given tangent value). \\ <text type="warning">**tan**</text> - a tangent value|
|**atan2(<text type="warning">y</text>, <text type="warning">x</text>)**| Returns the [[https://en.wikipedia.org/wiki/Atan2|2-argument arc tangent]] (the angle of the line from (0, 0) to (x, y) in radians, between -PI and PI). \\ <text type="warning">**y**</text> - Y coordinate \\ <text type="warning">**x**</text> - X coordinate|
|**tanh(<text type="warning">x</text>)**| Returns the [[http://en.wikipedia.org/wiki/hyperbolic_tangents|hyperbolic tangent]] of the given angle. \\ <text type="warning">**x**</text> - angle in radians|

\\
===== Miscellaneous Functions =====
//Remember to include the parentheses for each function even if there is nothing between them. Most of these are nullary functions (without arguments) but they are nevertheless Lua functions that need to be written with proper syntax to be interpreted as such.//


<block box compact>{{fa>info?color=#3bb0ff&fw&lg}} For the full list, you may consult the code here in case we missed some or add more in the future: https://github.com/CapsAdmin/pac3/blob/develop/lua/pac3/core/client/parts/proxy.lua</block>

<datatables responsive="true" paging="false" auto-width="true">



^**//Function//** ^ **//Explanation//** ^
|<span code>**aim_length()**</span>| Returns the distance between a model and the point it is aiming at (aim direction is defined by the red arrow). Maximum distance is 16000.|
|<span code>**aim_length_fraction()**</span>| Same as above but outputs a fraction calculated from <span code>distance/16000</span>.|
|<span code>**part_distance(<text type="warning">uid1</text>, <text type="warning">uid2</text>)**</span> | Measures the distance between two base_movable parts (models, bones, sprites, etc). You can find out a part's Unique ID by selecting the part and going to tools - "copy global id". \\ <span code><text type="warning">**uid1**</text></span> - the first Unique ID to search for a part. \\ <span code><text type="warning">**uid2**</text></span> - the second Unique ID to search for a part.|
|<span code>**event_alternative(<text type="warning">**event_uid**</text>, <text type="warning">**a**</text>, <text type="warning">**b**</text>)**</span> | A simple if/else statement. Searches a part's UID and tries to get its state if it's an event. If the event is showing, returns <text type="warning">**a**</text>, otherwise returns <text type="warning">**b**</text>.|
|<span code>**number_operator_alternative(<text type="warning">**number1**</text>, <text type="warning">**operator**</text>, <text type="warning">**number2**</text>, <text type="warning">**a**</text>, <text type="warning">**b**</text>)**</span> | A simple if/else statement. Computes a number comparison based on <text type="warning">**number1**</text>, <text type="warning">**operator**</text> and <text type="warning">**number2**</text>. If it's true, returns <text type="warning">**a**</text>, otherwise returns <text type="warning">**b**</text>. \\ For example: number_operator_alternative(1,">",0,2,3) means if 1 is above 0 (which it is), returns 2, otherwise returns 3. Different choices for the operator: \\ equal: "=", "==", "equal" \\ above: ">", "above", "greater", "greater than" \\ equal or above: ">=", "above or equal", "greater or equal", "greater than or equal" \\ below: "<", "below", "less", "less than" \\ equal or below: "<=", "below or equal", "less or equal", "less than or equal" \\ not equal: "~=", "not equal"|
|<span code>**ambient_light_r()**</span>| Returns the RED color value of the ambient color of the map.|
|<span code>**ambient_light_g()**</span>| Returns the GREEN color value of the ambient color of the map.|
|<span code>**ambient_light_b()**</span>| Returns the BLUE color value of the ambient color of the map.|
|<span code>**command()**</span> | Can be controlled by the <span code>pac_proxy <name> <value></span> console command.\\ <span code><name></span> is name of the proxy part you want to affect\\ <span code><value></span> is the value you want to set it to.|
|<span code>**command(<text type="warning">**name**</text>)**</span> | The same as command(), controlled by the same <span code>pac_proxy <name> <value></span> console command, but with this extra string argument, the function will search for the registered value by <text type="warning">**name**</text> directly instead of requiring the proxy part to be named.|
|<span code>**eye_angle_distance()**</span> | Returns the normalized distance between the object and the view angle. Looking directly at the object equals 0.5, looking away from the object lowers the value. There is no negative values so an object that is directly behind your view angle also equals 0.5. |
|<span code>**eye_position_distance()**</span> | Returns the distance between the object and the view position. |
|<span code>**feedback()**</span> | Returns the proxy's previous value. |
|<span code>**feedback_x()**</span> or <span code>**feedback_y()**</span> or <span code>**feedback_z()**</span> | Returns the proxy's previous value on a given axis. |
|<span code>**framenumber()**</span> or <span code>**fnumber()**</span> | Returns the number of frames rendered since the game was launched. |
|<span code>**frametime()** or **ftime()**</span> | Returns the time in seconds it took to render the last frame. Equal to [[https://wiki.garrysmod.com/page/Global/FrameTime|FrameTime]] |
|<span code>**hsv_to_color(<text type="warning">h</text>, <text type="info">s</text>, <text type="info">v</text>)**</span> | Converts {{ :asset:hsv.png?linkonly|HSV}} formatted color into RGB formatted color. Returns red, green, blue. \\ <span code><text type="warning">**h**</text></span> - color hue, from 0 to 360 \\ <span code><text type="info">**s**</text></span> - color saturation, optional, from 0 to 1, default is 1 \\ <span code><text type="info">**v**</text></span> - color value, optional, from 0 to 1, default is 1  |
|<span code>**lerp(<text type="warning">f</text>, <text type="warning">start</text>, <text type="warning">end</text>)**</span> | Linear interpolation from one value to another. \\ <span code><text type="warning">**f**</text></span> - the fraction for finding the result \\ <span code><text type="warning">**start**</text></span> - the starting number, the result will be equal to this when <span code><text type="warning">**f**</text></span> is 0 \\ <span code><text type="warning">**end**</text></span> - the ending number, the result will be equal to this when <span code><text type="warning">**f**</text></span> is 1|
|The Ease Library. \\ <span code>**Ease<X>(<text type="warning">f</text>, <text type="warning">start</text>, <text type="warning">end</text>)**</span> | Similar to lerp but more special. Interpolates from one value to another with more choices of curves that lead to more dynamic movement. https://wiki.facepunch.com/gmod/math.ease \\ <span code><text type="warning">**f**</text></span> - the fraction for finding the result \\ <span code><text type="warning">**start**</text></span> - the starting number, the result will be equal to this when <span code><text type="warning">**f**</text></span> is 0 \\ <span code><text type="warning">**end**</text></span> - the ending number, the result will be equal to this when <span code><text type="warning">**f**</text></span> is 1 \\ For every type of interpolation (InSine, InOutSine, OutSine, InElastic, ...), there are different ways to access it for convenience: easeX, ease_X, X. \\ For instance, InSine, easeInSine and ease_InSine are all aliases that lead to the same function. |
|<span code>**light_amount_r()**</span>| Returns the RED color value of the light amount at the current position of the object.|
|<span code>**light_amount_g()**</span>| Returns the GREEN color value of the light amount at the current position of the object.|
|<span code>**light_amount_b()**</span>| Returns the BLUE color value of the light amount at the current position of the object.|
|<span code>**light_value()**</span>| Returns the light value in 0 to 1 range.|
|<span code>**owner_armor()**</span>| Returns the amount of player's armor.|
|<span code>**owner_eye_angle_pitch()**</span>| Returns the pitch value of the owner's eye angle in the -0.0056179768 (looking down) to 1.0056179768 (looking up) range. This is limited to 0-1 (89°) for players.|
|<span code>**owner_eye_angle_yaw()**</span>| Returns the yaw value of the owner's eye angle in the -2 to 2 range. Multiply by 90 to match object's yaw to owner's yaw.|
|<span code>**owner_eye_angle_roll()**</span>| Returns the roll value of the owner's eye angle in the -2 to 2 range. Multiply by 90 to match object's roll to owner's roll.|
|<span code>**owner_fov()**</span>| Returns the owner's field of view value.|
|<span code>**owner_health()**</span>| Returns the owner's health value.|
|<span code>**owner_max_health()**</span>| Returns the owner's maximum health value.|
|<span code>**owner_position()**</span>| Returns the owner's X,Y,Z position.|
|<span code>**owner_position_x()**</span>| Returns the owner's X position.|
|<span code>**owner_position_y()**</span>| Returns the owner's Y position.|
|<span code>**owner_position_z()**</span>| Returns the owner's Z position.|
|<span code>**owner_scale_x()**</span> or <span code>**owner_scale_y()**</span> or <span code>**owner_scale_z()**</span>| Returns the owner's scale on a given axis. |
</datatables>

|**visible()**| Outputs whether the part is visible within a radius. Morphs between 0 and 1. | radius | x |
|**time()** | Outputs a time value that is not synced/affected by the game ( equal to [[https://wiki.garrysmod.com/page/Global/RealTime|RealTime]] ) |  | x |
|**synced_time()** | Outputs a time value that is synced to the game ( equal to [[https://wiki.garrysmod.com/page/Global/CurTime|CurTime]] ) |  | x |
|**systime()** or **stime()** | Returns a highly accurate time in seconds since the start up |
|**frametime()** or **ftime()** | Returns the [[https://wiki.garrysmod.com/page/Global/CurTime|CurTime]]-based time in seconds it took to render the last frame. Equal to [[https://wiki.garrysmod.com/page/Global/FrameTime|FrameTime]] |
|**framenumber()** or **fnumber()**| Returns the number of frames rendered since the game was launched. |
|**random()** | Quickly outputs random numbers between 0 and 1 |  | x |
|**random(<text type="warning">**min**</text>, <text type="warning">**max**</text>)** | The same as random(), but with additional optional arguments, similar to rand(m,n) \\ <span code><text type="warning">**min**</text></span> - minimum value, if specified. otherwise 0 \\ <span code><text type="warning">**max**</text></span> - maximum value, if specified. otherwise 1|  | x |
|**random_once(<text type="warning">**id**</text>, <text type="warning">**min**</text>, <text type="warning">**max**</text>)** | generates a random value only once, and the part can reuse this value many times as long as it's identified with a "seed" (although it's not technically a seed for predictable number generation, it's just an unique identifier we have to use in case we want more separate random values) \\ For example, we might have <span code>50*random_once(),50*random_once(),50*random_once()</span> but it would output the same values e.g. <span code>35.6123,35.6123,35.6123</span> because of the limitations of the part and the code. <span code>50*random_once(1),50*random_once(2),50*random_once(3)</span> would yield separate generations e.g. <span code>35.6123,83.41263,15.2142</span> \\ <span code><text type="warning">**min**</text></span> - minimum value, if specified. otherwise 0 \\ <span code><text type="warning">**max**</text></span> - maximum value, if specified. otherwise 1 |  | x |
|**timeex()** | Outputs a time value that begins to count the seconds when the proxy is shown |  | x |
|**eye_position_distance()** | Outputs the distance between the part and eye position |  | x |
|**eye_angle_distance()** | Outputs the distance between the part and eye angle |  | x |

|**owner_velocity_length()** | Outputs the velocity of the owner, in any direction |  | x |
|**owner_velocity_forward()** | Outputs the velocity of the owner, either forwards or backwards |  | x |
|**owner_velocity_right()** | Outputs the velocity of the owner, either right or left |  | x |
|**owner_velocity_up()** | Outputs the velocity of the owner, either up or down |  | x |
|**owner_velocity_length_increase()** | Outputs the velocity of the owner, in any direction ( additive ) |  | x |
|**owner_velocity_forward_increase()** | Outputs the velocity of the owner, either forwards or backwards ( additive )|  | x |
|**owner_velocity_right_increase()** | Outputs the velocity of the owner, either right or left ( additive ) |  | x |
|**owner_velocity_up_increase()** | Outputs the velocity of the owner, either up or down ( additive )|  | x |
|**parent_velocity_length()** | Outputs the velocity of the parent part, in any direction |  | x |
|**parent_velocity_forward()** | Outputs the velocity of the parent part, either forwards or backwards |  | x |
|**parent_velocity_right()** | Outputs the velocity of the parent part, either right or left |  | x |
|**parent_velocity_up()** | Outputs the velocity of the parent part, either up or down |  | x |
|**voice_volume()** | Outputs a number between 0 and 1 based on the owner's voice chat microphone input |  | x |
|**pose_parameter(<text type="warning">**name**</text>)** | Returns the value of the owner's pose parameter <text type="warning">**name**</text>, but normalized between 0 and 1 \\ For example you need a <span code>(-1+2*pose_parameter("head_yaw"))</span> unit to make a symmetrical value range based on your head's yaw. |  | x |
|**pose_parameter_true(<text type="warning">**name**</text>)** | Returns the value of the  owner's pose parameter <text type="warning">**name**</text>, but unnormalized to its actual value. |  | x |
|**owner_health()** | Outputs how much health the owner has |  | x |
|**owner_armor()** | Outputs how much armor the owner has |  | x |
|**owner_max_armor()** | Outputs the maximum armor of the owner |  | x |
|**owner_max_health()** | Outputs the maximum health of the owner |  | x |
|**owner_health_fraction()** | Outputs the health of the owner as a fraction (0 to 1) |  | x |
|**owner_armor_fraction()** | Outputs the armor of the owner as a fraction (0 to 1) |  | x |
|**player_color_r()** | Outputs the red value of the owner's player color ( between 0 and 1 ) |  | x |
|**player_color_g()** | Outputs the green value of the owner's player color ( between 0 and 1 ) |  | y |
|**player_color_b()** | Outputs the blue value of the owner's player color ( between 0 and 1 ) |  | z |
|**weapon_color_r()** | Outputs the red value of the owner's weapon color ( between 0 and 1 ) |  | x |
|**weapon_color_g()** | Outputs the green value of the owner's weapon color ( between 0 and 1 ) |  | y |
|**weapon_color_b()** | Outputs the blue value of the owner's weapon color ( between 0 and 1 ) |  | z |


Remember that all of the functions above can be mixed together, you can use one function as input for another, add functions together, etc.

===== Expression Examples =====

<block box>
==== Clamp (Min/Max Value) ====
Example: <span code>clamp(5 + timeex(), 5, 10)</span>

When shown, the proxy starts at 5 and moves up over time thanks to <span code>timeex()</span>, <span code>clamp(input, min, max)</span> is used to limit the output so the value never goes above 10.

</block>

<block box>
<block right 7.4em nop>
<html>
 <video width="560" height="315" preload="auto" autoplay muted loop>
   <source src="https://wiki.pac3.info/_media/part/proxy/proxy_rainbow.mp4" type="video/mp4">
  </video>
</html>
</block>
==== Rainbow Color ====
Example: <span code>hsv_to_color(timeex() * 50)</span>

Here <span code>timeex()</span> is used as the (h)ue input for <span code>hsv_to_color(h, s, v)</span> which changes the color over time. Multiplying the <span code>timeex()</span> by 50 speeds up the color transition.

<block box compact>
{{fa>download?color=#7ab353&fw&lg}} **Download:** {{:part:proxy:hsv.txt}}
</block>
</block>



\\
===== Properties =====
^//**easy setup**// ^^
|input | //Select a miscellaneous function// |
|function | //Select a math function to act on the miscellaneous function ( none = use misc. function directly )// |
|axis | //(??)// FIXME |
|min | //Sets the minimum value that the function may be ( if a sine or cosine )// |
|max | //Sets the maximum value that the function may be ( if a sine or cosine )// |
|offset | //Sets the horizontal offset ( adding/removing the input before applying the function, ie. sin(time()-2) )// |
|input multiplier | //Multiplies the input before applying the function, ie. sin(time()*2))// |
|input divider | //Divides the input before applying the function, ie. sin(time()/2))// |
|pow | //Raises the entire expression up by an exponential power, ie. sin(time())<nowiki>^</nowiki>2// |
^//**behavior**//^^
|additive | //Determines whether to output normally ( disabled ) or add each output to the previous output ( enabled )// |
|player angles | //(??)// FIXME |
|zero eye pitch | //(??)// FIXME |
|reset velocities on hide | //Determines whether to treat velocity functions normally ( disabled ) or set them to 0 upon hiding/unhiding ( enabled )// |
|velocity roughness | //Sets how quickly velocity functions change their value// |
^//**generic**// ^^
|variable name | //The name of the value you'd like the proxy to alter// |
|root owner | //(??)// FIXME |
|target part name | //Name of a part to be affected by the proxy ( leave empty to affect the parent or child of the proxy )// |
|affect children | //Determines whether to affect a target part or parent ( disabled ) or affect all of the proxy's children ( enabled )// |
|expression | //A mathematical expression to alter the value ( overrides ''easy setup'' )// |
|name | //The name of the proxy ( not altering this will allow the proxy to display its output )// |
|hide | //Determines whether to render the proxy or ignore/hide it// |
|is disturbing | //Determines whether to hide the proxy for players who have pac_hide_disturbing set to 1// |
^//**orientation**// ^^
|parent name | //The name of the proxy's parent part ( the proxy will move under said part if you decide to change this )// |

----

~~AUTHORS~~