C# 클래스 UnityEngine.Mathf

파일 보기 프로젝트 열기: jbruening/UnEngine 1 사용 예제들

공개 메소드들

메소드 설명
Abs ( float f ) : float

Abs ( int value ) : int

Acos ( float f ) : float

Approximately ( float a, float b ) : bool

Asin ( float f ) : float

Atan ( float f ) : float

Atan2 ( float y, float x ) : float

Ceil ( float f ) : float

CeilToInt ( float f ) : int

Clamp ( float value, float min, float max ) : float

Clamp ( int value, int min, int max ) : int

Clamp01 ( float value ) : float

Cos ( float f ) : float

DeltaAngle ( float current, float target ) : float

Exp ( float power ) : float

Floor ( float f ) : float

FloorToInt ( float f ) : int

Gamma ( float value, float absmax, float gamma ) : float

InverseLerp ( float from, float to, float value ) : float

Lerp ( float from, float to, float t ) : float

faster than unity's lerp

LerpAngle ( float a, float b, float t ) : float

Log ( float f ) : float

Log ( float f, float p ) : float

Log10 ( float f ) : float

Max ( ) : float

Max ( float a, float b ) : float

Max ( ) : int

Max ( int a, int b ) : int

Min ( ) : float

Min ( float a, float b ) : float

Min ( ) : int

Min ( int a, int b ) : int

MoveTowards ( float current, float target, float maxDelta ) : float

MoveTowardsAngle ( float current, float target, float maxDelta ) : float

PingPong ( float t, float length ) : float

Pow ( float f, float p ) : float

Repeat ( float t, float length ) : float

Round ( float f ) : float

RoundToInt ( float f ) : int

Sign ( float f ) : float

Sin ( float f ) : float

SmoothDamp ( float current, float target, float &currentVelocity, float smoothTime ) : float

SmoothDamp ( float current, float target, float &currentVelocity, float smoothTime, float maxSpeed ) : float

SmoothDamp ( float current, float target, float &currentVelocity, float smoothTime, float maxSpeed, float deltaTime ) : float

SmoothDampAngle ( float current, float target, float &currentVelocity, float smoothTime ) : float

SmoothDampAngle ( float current, float target, float &currentVelocity, float smoothTime, float maxSpeed ) : float

SmoothDampAngle ( float current, float target, float &currentVelocity, float smoothTime, float maxSpeed, float deltaTime ) : float

SmoothStep ( float from, float to, float t ) : float

Sqrt ( float f ) : float

Tan ( float f ) : float

메소드 상세

Abs() 공개 정적인 메소드

public static Abs ( float f ) : float
f float
리턴 float

Abs() 공개 정적인 메소드

public static Abs ( int value ) : int
value int
리턴 int

Acos() 공개 정적인 메소드

public static Acos ( float f ) : float
f float
리턴 float

Approximately() 공개 정적인 메소드

public static Approximately ( float a, float b ) : bool
a float
b float
리턴 bool

Asin() 공개 정적인 메소드

public static Asin ( float f ) : float
f float
리턴 float

Atan() 공개 정적인 메소드

public static Atan ( float f ) : float
f float
리턴 float

Atan2() 공개 정적인 메소드

public static Atan2 ( float y, float x ) : float
y float
x float
리턴 float

Ceil() 공개 정적인 메소드

public static Ceil ( float f ) : float
f float
리턴 float

CeilToInt() 공개 정적인 메소드

public static CeilToInt ( float f ) : int
f float
리턴 int

Clamp() 공개 정적인 메소드

public static Clamp ( float value, float min, float max ) : float
value float
min float
max float
리턴 float

Clamp() 공개 정적인 메소드

public static Clamp ( int value, int min, int max ) : int
value int
min int
max int
리턴 int

Clamp01() 공개 정적인 메소드

public static Clamp01 ( float value ) : float
value float
리턴 float

Cos() 공개 정적인 메소드

public static Cos ( float f ) : float
f float
리턴 float

DeltaAngle() 공개 정적인 메소드

public static DeltaAngle ( float current, float target ) : float
current float
target float
리턴 float

Exp() 공개 정적인 메소드

public static Exp ( float power ) : float
power float
리턴 float

Floor() 공개 정적인 메소드

public static Floor ( float f ) : float
f float
리턴 float

FloorToInt() 공개 정적인 메소드

public static FloorToInt ( float f ) : int
f float
리턴 int

Gamma() 공개 정적인 메소드

public static Gamma ( float value, float absmax, float gamma ) : float
value float
absmax float
gamma float
리턴 float

InverseLerp() 공개 정적인 메소드

public static InverseLerp ( float from, float to, float value ) : float
from float
to float
value float
리턴 float

Lerp() 공개 정적인 메소드

faster than unity's lerp
public static Lerp ( float from, float to, float t ) : float
from float
to float
t float
리턴 float

LerpAngle() 공개 정적인 메소드

public static LerpAngle ( float a, float b, float t ) : float
a float
b float
t float
리턴 float

Log() 공개 정적인 메소드

public static Log ( float f ) : float
f float
리턴 float

Log() 공개 정적인 메소드

public static Log ( float f, float p ) : float
f float
p float
리턴 float

Log10() 공개 정적인 메소드

public static Log10 ( float f ) : float
f float
리턴 float

Max() 공개 정적인 메소드

public static Max ( ) : float
리턴 float

Max() 공개 정적인 메소드

public static Max ( float a, float b ) : float
a float
b float
리턴 float

Max() 공개 정적인 메소드

public static Max ( ) : int
리턴 int

Max() 공개 정적인 메소드

public static Max ( int a, int b ) : int
a int
b int
리턴 int

Min() 공개 정적인 메소드

public static Min ( ) : float
리턴 float

Min() 공개 정적인 메소드

public static Min ( float a, float b ) : float
a float
b float
리턴 float

Min() 공개 정적인 메소드

public static Min ( ) : int
리턴 int

Min() 공개 정적인 메소드

public static Min ( int a, int b ) : int
a int
b int
리턴 int

MoveTowards() 공개 정적인 메소드

public static MoveTowards ( float current, float target, float maxDelta ) : float
current float
target float
maxDelta float
리턴 float

MoveTowardsAngle() 공개 정적인 메소드

public static MoveTowardsAngle ( float current, float target, float maxDelta ) : float
current float
target float
maxDelta float
리턴 float

PingPong() 공개 정적인 메소드

public static PingPong ( float t, float length ) : float
t float
length float
리턴 float

Pow() 공개 정적인 메소드

public static Pow ( float f, float p ) : float
f float
p float
리턴 float

Repeat() 공개 정적인 메소드

public static Repeat ( float t, float length ) : float
t float
length float
리턴 float

Round() 공개 정적인 메소드

public static Round ( float f ) : float
f float
리턴 float

RoundToInt() 공개 정적인 메소드

public static RoundToInt ( float f ) : int
f float
리턴 int

Sign() 공개 정적인 메소드

public static Sign ( float f ) : float
f float
리턴 float

Sin() 공개 정적인 메소드

public static Sin ( float f ) : float
f float
리턴 float

SmoothDamp() 공개 정적인 메소드

public static SmoothDamp ( float current, float target, float &currentVelocity, float smoothTime ) : float
current float
target float
currentVelocity float
smoothTime float
리턴 float

SmoothDamp() 공개 정적인 메소드

public static SmoothDamp ( float current, float target, float &currentVelocity, float smoothTime, float maxSpeed ) : float
current float
target float
currentVelocity float
smoothTime float
maxSpeed float
리턴 float

SmoothDamp() 공개 정적인 메소드

public static SmoothDamp ( float current, float target, float &currentVelocity, float smoothTime, float maxSpeed, float deltaTime ) : float
current float
target float
currentVelocity float
smoothTime float
maxSpeed float
deltaTime float
리턴 float

SmoothDampAngle() 공개 정적인 메소드

public static SmoothDampAngle ( float current, float target, float &currentVelocity, float smoothTime ) : float
current float
target float
currentVelocity float
smoothTime float
리턴 float

SmoothDampAngle() 공개 정적인 메소드

public static SmoothDampAngle ( float current, float target, float &currentVelocity, float smoothTime, float maxSpeed ) : float
current float
target float
currentVelocity float
smoothTime float
maxSpeed float
리턴 float

SmoothDampAngle() 공개 정적인 메소드

public static SmoothDampAngle ( float current, float target, float &currentVelocity, float smoothTime, float maxSpeed, float deltaTime ) : float
current float
target float
currentVelocity float
smoothTime float
maxSpeed float
deltaTime float
리턴 float

SmoothStep() 공개 정적인 메소드

public static SmoothStep ( float from, float to, float t ) : float
from float
to float
t float
리턴 float

Sqrt() 공개 정적인 메소드

public static Sqrt ( float f ) : float
f float
리턴 float

Tan() 공개 정적인 메소드

public static Tan ( float f ) : float
f float
리턴 float