C# 클래스 NewTOAPIA.Graphics.Processor.GPLang

GPLang represents the set of functions that are typically useful in the implementation of graphics related programs. The initial set follows the functions that are found in OpenGL Shader programming (GLSL - 1.4). The chapter references in the regions are from the second edition of the orange book. As they are generally useful, any effort related to graphics programming might find them to be handy. These functions are implemented as static methods for a couple of reasons: 1) There is no instance information needed 2) It makes it easy to subclass the GPLang class and have an interface that is easy to utilize without having to use '.' notation. This latter point is used by the GPShader class. You can essentially copy shader programs straight out of the 'Orange' book and implement them in C#. That's pretty cool. Similarly, if you want to use these routines from another context, there's not too much to type: GPLang.clamp(x, minVal, maxVal) etc.
파일 보기 프로젝트 열기: Wiladams/NewTOAPIA

공개 메소드들

메소드 설명
abs ( double x ) : float
abs ( float x ) : float
abs ( int x ) : int
abs ( ivec2 x ) : ivec2
abs ( ivec3 x ) : ivec3
abs ( ivec4 x ) : ivec4
abs ( vec2 x ) : vec2
abs ( vec3 x ) : vec3
abs ( vec4 x ) : vec4
acos ( float x ) : float
acos ( vec2 x ) : vec2
acos ( vec3 x ) : vec3
acos ( vec4 x ) : vec4
acosh ( float x ) : float
acosh ( vec2 x ) : vec2
acosh ( vec3 x ) : vec3
acosh ( vec4 x ) : vec4
all ( bvec2 x ) : bool
all ( bvec3 x ) : bool
all ( bvec4 x ) : bool
any ( bvec2 x ) : bool
any ( bvec3 x ) : bool
any ( bvec4 x ) : bool
asin ( float x ) : float
asin ( vec2 x ) : vec2
asin ( vec3 x ) : vec3
asin ( vec4 x ) : vec4
asinh ( float x ) : float
asinh ( vec2 x ) : vec2
asinh ( vec3 x ) : vec3
asinh ( vec4 x ) : vec4
atan ( float y_over_x ) : float
atan ( float y, float x ) : float
atan ( vec2 y_over_x ) : vec2
atan ( vec2 y, vec2 x ) : vec2
atan ( vec3 y_over_x ) : vec3
atan ( vec3 y, vec3 x ) : vec3
atan ( vec4 y_over_x ) : vec4
atan ( vec4 y, vec4 x ) : vec4
atanh ( float x ) : float
atanh ( vec2 x ) : vec2
atanh ( vec3 x ) : vec3
atanh ( vec4 x ) : vec4
ceil ( float x ) : float
ceil ( vec2 x ) : vec2
ceil ( vec3 x ) : vec3
ceil ( vec4 x ) : vec4
clamp ( float x, float minVal, float maxVal ) : float
clamp ( int x, int minVal, int maxVal ) : int
clamp ( ivec2 x, int minVal, int maxVal ) : ivec2
clamp ( ivec2 x, ivec2 minVal, ivec2 maxVal ) : ivec2
clamp ( ivec3 x, int minVal, int maxVal ) : ivec3
clamp ( ivec3 x, ivec3 minVal, ivec3 maxVal ) : ivec3
clamp ( ivec4 x, int minVal, int maxVal ) : ivec4
clamp ( ivec4 x, ivec4 minVal, ivec4 maxVal ) : ivec4
clamp ( uint x, uint minVal, uint maxVal ) : uint
clamp ( uvec2 x, uint minVal, uint maxVal ) : uvec2
clamp ( uvec2 x, uvec2 minVal, uvec2 maxVal ) : uvec2
clamp ( uvec3 x, uint minVal, uint maxVal ) : uvec3
clamp ( uvec3 x, uvec3 minVal, uvec3 maxVal ) : uvec3
clamp ( uvec4 x, uint minVal, uint maxVal ) : uvec4
clamp ( uvec4 x, uvec4 minVal, uvec4 maxVal ) : uvec4
clamp ( vec2 x, float minVal, float maxVal ) : vec2
clamp ( vec2 x, vec2 minVal, vec2 maxVal ) : vec2
clamp ( vec3 x, float minVal, float maxVal ) : vec3
clamp ( vec3 x, vec3 minVal, vec3 maxVal ) : vec3
clamp ( vec4 x, float minVal, float maxVal ) : vec4
clamp ( vec4 x, vec4 minVal, vec4 maxVal ) : vec4
cos ( float radians ) : float
cos ( vec2 radians ) : vec2
cos ( vec3 radians ) : vec3
cos ( vec4 radians ) : vec4
cosh ( float x ) : float
cosh ( vec2 x ) : vec2
cosh ( vec3 x ) : vec3
cosh ( vec4 x ) : vec4
cross ( vec3 x, vec3 y ) : vec3
degrees ( float radians ) : float
degrees ( vec2 radians ) : vec2
degrees ( vec3 radians ) : vec3
degrees ( vec4 radians ) : vec4
distance ( float p0, float p1 ) : float
distance ( vec2 p0, vec2 p1 ) : float
distance ( vec3 p0, vec3 p1 ) : float
distance ( vec4 p0, vec4 p1 ) : float
dot ( float x, float y ) : float
dot ( vec2 x, vec2 y ) : float
dot ( vec3 x, vec3 y ) : float
dot ( vec4 x, vec4 y ) : float
equal ( bvec2 x, bvec2 y ) : bvec2
equal ( ivec2 x, ivec2 y ) : bvec2
equal ( vec2 x, vec2 y ) : bvec2
equal ( bvec3 x, bvec3 y ) : bvec3
equal ( ivec3 x, ivec3 y ) : bvec3
equal ( vec3 x, vec3 y ) : bvec3
equal ( bvec4 x, bvec4 y ) : bvec4
equal ( ivec4 x, ivec4 y ) : bvec4
equal ( vec4 x, vec4 y ) : bvec4
exp ( float x ) : float
exp ( vec2 x ) : vec2
exp ( vec3 x ) : vec3
exp ( vec4 x ) : vec4
exp2 ( float x ) : float
exp2 ( vec2 x ) : vec2
exp2 ( vec3 x ) : vec3
exp2 ( vec4 x ) : vec4
faceforward ( float N, float I, float Nref ) : float
faceforward ( vec2 N, vec2 I, vec2 Nref ) : vec2
faceforward ( vec3 N, vec3 I, vec3 Nref ) : vec3
faceforward ( vec4 N, vec4 I, vec4 Nref ) : vec4
floor ( float x ) : float
floor ( vec2 x ) : vec2
floor ( vec3 x ) : vec3
floor ( vec4 x ) : vec4
fract ( float x ) : float
fract ( vec2 x ) : vec2
fract ( vec3 x ) : vec3
fract ( vec4 x ) : vec4
greaterThan ( ivec2 x, ivec2 y ) : bvec2
greaterThan ( vec2 x, vec2 y ) : bvec2
greaterThan ( ivec3 x, ivec3 y ) : bvec3
greaterThan ( vec3 x, vec3 y ) : bvec3
greaterThan ( ivec4 x, ivec4 y ) : bvec4
greaterThan ( vec4 x, vec4 y ) : bvec4
greaterThanEqual ( ivec2 x, ivec2 y ) : bvec2
greaterThanEqual ( vec2 x, vec2 y ) : bvec2
greaterThanEqual ( ivec3 x, ivec3 y ) : bvec3
greaterThanEqual ( vec3 x, vec3 y ) : bvec3
greaterThanEqual ( ivec4 x, ivec4 y ) : bvec4
greaterThanEqual ( vec4 x, vec4 y ) : bvec4
inverse ( mat2 m ) : mat2
inverse ( mat3 m ) : mat3
inverse ( mat4 m ) : mat4
inversesqrt ( float x ) : float
inversesqrt ( vec2 x ) : vec2
inversesqrt ( vec3 x ) : vec3
inversesqrt ( vec4 x ) : vec4
isinf ( float x ) : bool
isinf ( vec2 x ) : bvec2
isinf ( vec3 x ) : bvec3
isinf ( vec4 x ) : bvec4
isnan ( float x ) : bool
isnan ( vec2 x ) : bvec2
isnan ( vec3 x ) : bvec3
isnan ( vec4 x ) : bvec4
length ( float x ) : float
length ( vec2 x ) : float
length ( vec3 x ) : float
length ( vec4 x ) : float
lessThan ( ivec2 x, ivec2 y ) : bvec2
lessThan ( vec2 x, vec2 y ) : bvec2
lessThan ( ivec3 x, ivec3 y ) : bvec3
lessThan ( vec3 x, vec3 y ) : bvec3
lessThan ( ivec4 x, ivec4 y ) : bvec4
lessThan ( vec4 x, vec4 y ) : bvec4
lessThanEqual ( ivec2 x, ivec2 y ) : bvec2
lessThanEqual ( vec2 x, vec2 y ) : bvec2
lessThanEqual ( ivec3 x, ivec3 y ) : bvec3
lessThanEqual ( vec3 x, vec3 y ) : bvec3
lessThanEqual ( ivec4 x, ivec4 y ) : bvec4
lessThanEqual ( vec4 x, vec4 y ) : bvec4
log ( float x ) : float
log ( vec2 x ) : vec2
log ( vec3 x ) : vec3
log ( vec4 x ) : vec4
log2 ( float x ) : float
log2 ( vec2 x ) : vec2
log2 ( vec3 x ) : vec3
log2 ( vec4 x ) : vec4
matrixCompMult ( mat2 x, mat2 y ) : mat2
matrixCompMult ( mat3 x, mat3 y ) : mat3
matrixCompMult ( mat4 x, mat4 y ) : mat4
max ( float x, float y ) : float
max ( int x, int y ) : int
max ( ivec2 x, int y ) : ivec2
max ( ivec2 x, ivec2 y ) : ivec2
max ( ivec3 x, int y ) : ivec3
max ( ivec3 x, ivec3 y ) : ivec3
max ( ivec4 x, int y ) : ivec4
max ( ivec4 x, ivec4 y ) : ivec4
max ( uint x, uint y ) : uint
max ( uvec2 x, uint y ) : uvec2
max ( uvec2 x, uvec2 y ) : uvec2
max ( uvec3 x, uint y ) : uvec3
max ( uvec3 x, uvec3 y ) : uvec3
max ( uvec4 x, uint y ) : uvec4
max ( uvec4 x, uvec4 y ) : uvec4
max ( vec2 x, float y ) : vec2
max ( vec2 x, vec2 y ) : vec2
max ( vec3 x, float y ) : vec3
max ( vec3 x, vec3 y ) : vec3
max ( vec4 x, float y ) : vec4
max ( vec4 x, vec4 y ) : vec4
min ( float x, float y ) : float
min ( int x, int y ) : int
min ( ivec2 x, int y ) : ivec2
min ( ivec2 x, ivec2 y ) : ivec2
min ( ivec3 x, int y ) : ivec3
min ( ivec3 x, ivec3 y ) : ivec3
min ( ivec4 x, int y ) : ivec4
min ( ivec4 x, ivec4 y ) : ivec4
min ( uint x, uint y ) : uint
min ( uvec2 x, uint y ) : uvec2
min ( uvec2 x, uvec2 y ) : uvec2
min ( uvec3 x, uint y ) : uvec3
min ( uvec3 x, uvec3 y ) : uvec3
min ( uvec4 x, uint y ) : uvec4
min ( uvec4 x, uvec4 y ) : uvec4
min ( vec2 x, float y ) : vec2
min ( vec2 x, vec2 y ) : vec2
min ( vec3 x, float y ) : vec3
min ( vec3 x, vec3 y ) : vec3
min ( vec4 x, float y ) : vec4
min ( vec4 x, vec4 y ) : vec4
mix ( float x, float y, float a ) : float
mix ( vec2 x, vec2 y, float a ) : vec2
mix ( vec2 x, vec2 y, vec2 a ) : vec2
mix ( vec3 x, vec3 y, float a ) : vec3
mix ( vec3 x, vec3 y, vec3 a ) : vec3
mix ( vec4 x, vec4 y, float a ) : vec4
mix ( vec4 x, vec4 y, vec4 a ) : vec4
mod ( float x, float y ) : float
mod ( vec2 x, float y ) : vec2
mod ( vec2 x, vec2 y ) : vec2
mod ( vec3 x, float y ) : vec3
mod ( vec3 x, vec3 y ) : vec3
mod ( vec4 x, float y ) : vec4
mod ( vec4 x, vec4 y ) : vec4
noise1 ( float x ) : float
noise1 ( vec2 x ) : float
noise1 ( vec3 x ) : float
noise1 ( vec4 x ) : float
noise2 ( float x ) : vec2
noise2 ( vec2 x ) : vec2
noise2 ( vec3 x ) : vec2
noise2 ( vec4 x ) : vec2
noise3 ( float x ) : vec3
noise3 ( vec2 x ) : vec3
noise3 ( vec3 x ) : vec3
noise3 ( vec4 x ) : vec3
noise4 ( float x ) : vec4
noise4 ( vec2 x ) : vec4
noise4 ( vec3 x ) : vec4
noise4 ( vec4 x ) : vec4
normalize ( float x ) : float
normalize ( vec2 x ) : vec2
normalize ( vec3 x ) : vec3
normalize ( vec4 x ) : vec4
not ( bvec2 x ) : bvec2
not ( bvec3 x ) : bvec3
not ( bvec4 x ) : bvec4
notEqual ( bvec2 x, bvec2 y ) : bvec2
notEqual ( ivec2 x, ivec2 y ) : bvec2
notEqual ( vec2 x, vec2 y ) : bvec2
notEqual ( bvec3 x, bvec3 y ) : bvec3
notEqual ( ivec3 x, ivec3 y ) : bvec3
notEqual ( vec3 x, vec3 y ) : bvec3
notEqual ( bvec4 x, bvec4 y ) : bvec4
notEqual ( ivec4 x, ivec4 y ) : bvec4
notEqual ( vec4 x, vec4 y ) : bvec4
outerProcuct ( vec4 c, vec4 r ) : mat4
outerProduct ( vec2 c, vec2 r ) : mat2
outerProduct ( vec3 c, vec3 r ) : mat3
pow ( float x, float y ) : float
pow ( vec2 x, vec2 y ) : vec2
pow ( vec3 x, vec3 y ) : vec3
pow ( vec4 x, vec4 y ) : vec4
radians ( float degrees ) : float
radians ( vec2 degrees ) : vec2
radians ( vec3 degrees ) : vec3
radians ( vec4 degrees ) : vec4
reflect ( float I, float N ) : float
reflect ( vec2 I, vec2 N ) : vec2
reflect ( vec3 I, vec3 N ) : vec3
reflect ( vec4 I, vec4 N ) : vec4
refract ( float I, float N, float eta ) : float
refract ( vec2 I, vec2 N, float eta ) : vec2
refract ( vec3 I, vec3 N, float eta ) : vec3
refract ( vec4 I, vec4 N, float eta ) : vec4
round ( float x ) : float
round ( vec2 x ) : vec2
round ( vec3 x ) : vec3
round ( vec4 x ) : vec4
roundeven ( float x ) : float
roundeven ( vec2 x ) : vec2
roundeven ( vec3 x ) : vec3
roundeven ( vec4 x ) : vec4
sign ( float x ) : float
sign ( int x ) : int
sign ( ivec2 x ) : ivec2
sign ( ivec3 x ) : ivec3
sign ( ivec4 x ) : ivec4
sign ( vec2 x ) : vec2
sign ( vec3 x ) : vec3
sign ( vec4 x ) : vec4
sin ( float radians ) : float
sin ( vec2 radians ) : vec2
sin ( vec3 radians ) : vec3
sin ( vec4 radians ) : vec4
sinh ( float x ) : float
sinh ( vec2 x ) : vec2
sinh ( vec3 x ) : vec3
sinh ( vec4 x ) : vec4
smoothstep ( float edge0, float edge1, float x ) : float
smoothstep ( float edge0, float edge1, vec2 x ) : vec2
smoothstep ( vec2 edge0, vec2 edge1, vec2 x ) : vec2
smoothstep ( float edge0, float edge1, vec3 x ) : vec3
smoothstep ( vec3 edge0, vec3 edge1, vec3 x ) : vec3
smoothstep ( float edge0, float edge1, vec4 x ) : vec4
smoothstep ( vec4 edge0, vec4 edge1, vec4 x ) : vec4
sqrt ( float x ) : float
sqrt ( vec2 x ) : vec2
sqrt ( vec3 x ) : vec3
sqrt ( vec4 x ) : vec4
step ( float edge, float x ) : float
step ( float edge, vec2 x ) : vec2
step ( vec2 edge, vec2 x ) : vec2
step ( float edge, vec3 x ) : vec3
step ( vec3 edge, vec3 x ) : vec3
step ( float edge, vec4 x ) : vec4
step ( vec4 edge, vec4 x ) : vec4
tan ( float radians ) : float
tan ( vec2 radians ) : vec2
tan ( vec3 radians ) : vec3
tan ( vec4 radians ) : vec4
tanh ( float x ) : float
tanh ( vec2 x ) : vec2
tanh ( vec3 x ) : vec3
tanh ( vec4 x ) : vec4
texture ( sampler1D sampler, float coord ) : vec4
texture ( sampler2D sampler, vec2 coord ) : vec4
texture ( sampler3D sampler, vec3 coord ) : vec4
transpose ( mat2 m ) : mat2
transpose ( mat3x2 m ) : mat2x3
transpose ( mat4x2 m ) : mat2x4
transpose ( mat3 m ) : mat3
transpose ( mat2x3 m ) : mat3x2
transpose ( mat4x3 m ) : mat3x4
transpose ( mat4 m ) : mat4
transpose ( mat2x4 m ) : mat4x2
transpose ( mat3x4 m ) : mat4x3
trunc ( float x ) : float
trunc ( vec2 x ) : vec2
trunc ( vec3 x ) : vec3
trunc ( vec4 x ) : vec4

비공개 메소드들

메소드 설명
herm ( float edge0, float edge1, float x ) : float

메소드 상세

abs() 공개 정적인 메소드

public static abs ( double x ) : float
x double
리턴 float

abs() 공개 정적인 메소드

public static abs ( float x ) : float
x float
리턴 float

abs() 공개 정적인 메소드

public static abs ( int x ) : int
x int
리턴 int

abs() 공개 정적인 메소드

public static abs ( ivec2 x ) : ivec2
x NewTOAPIA.Graphics.ivec2
리턴 NewTOAPIA.Graphics.ivec2

abs() 공개 정적인 메소드

public static abs ( ivec3 x ) : ivec3
x NewTOAPIA.Graphics.ivec3
리턴 NewTOAPIA.Graphics.ivec3

abs() 공개 정적인 메소드

public static abs ( ivec4 x ) : ivec4
x NewTOAPIA.Graphics.ivec4
리턴 NewTOAPIA.Graphics.ivec4

abs() 공개 정적인 메소드

public static abs ( vec2 x ) : vec2
x vec2
리턴 vec2

abs() 공개 정적인 메소드

public static abs ( vec3 x ) : vec3
x vec3
리턴 vec3

abs() 공개 정적인 메소드

public static abs ( vec4 x ) : vec4
x vec4
리턴 vec4

acos() 공개 정적인 메소드

public static acos ( float x ) : float
x float
리턴 float

acos() 공개 정적인 메소드

public static acos ( vec2 x ) : vec2
x vec2
리턴 vec2

acos() 공개 정적인 메소드

public static acos ( vec3 x ) : vec3
x vec3
리턴 vec3

acos() 공개 정적인 메소드

public static acos ( vec4 x ) : vec4
x vec4
리턴 vec4

acosh() 공개 정적인 메소드

public static acosh ( float x ) : float
x float
리턴 float

acosh() 공개 정적인 메소드

public static acosh ( vec2 x ) : vec2
x vec2
리턴 vec2

acosh() 공개 정적인 메소드

public static acosh ( vec3 x ) : vec3
x vec3
리턴 vec3

acosh() 공개 정적인 메소드

public static acosh ( vec4 x ) : vec4
x vec4
리턴 vec4

all() 공개 정적인 메소드

public static all ( bvec2 x ) : bool
x bvec2
리턴 bool

all() 공개 정적인 메소드

public static all ( bvec3 x ) : bool
x bvec3
리턴 bool

all() 공개 정적인 메소드

public static all ( bvec4 x ) : bool
x bvec4
리턴 bool

any() 공개 정적인 메소드

public static any ( bvec2 x ) : bool
x bvec2
리턴 bool

any() 공개 정적인 메소드

public static any ( bvec3 x ) : bool
x bvec3
리턴 bool

any() 공개 정적인 메소드

public static any ( bvec4 x ) : bool
x bvec4
리턴 bool

asin() 공개 정적인 메소드

public static asin ( float x ) : float
x float
리턴 float

asin() 공개 정적인 메소드

public static asin ( vec2 x ) : vec2
x vec2
리턴 vec2

asin() 공개 정적인 메소드

public static asin ( vec3 x ) : vec3
x vec3
리턴 vec3

asin() 공개 정적인 메소드

public static asin ( vec4 x ) : vec4
x vec4
리턴 vec4

asinh() 공개 정적인 메소드

public static asinh ( float x ) : float
x float
리턴 float

asinh() 공개 정적인 메소드

public static asinh ( vec2 x ) : vec2
x vec2
리턴 vec2

asinh() 공개 정적인 메소드

public static asinh ( vec3 x ) : vec3
x vec3
리턴 vec3

asinh() 공개 정적인 메소드

public static asinh ( vec4 x ) : vec4
x vec4
리턴 vec4

atan() 공개 정적인 메소드

public static atan ( float y_over_x ) : float
y_over_x float
리턴 float

atan() 공개 정적인 메소드

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

atan() 공개 정적인 메소드

public static atan ( vec2 y_over_x ) : vec2
y_over_x vec2
리턴 vec2

atan() 공개 정적인 메소드

public static atan ( vec2 y, vec2 x ) : vec2
y vec2
x vec2
리턴 vec2

atan() 공개 정적인 메소드

public static atan ( vec3 y_over_x ) : vec3
y_over_x vec3
리턴 vec3

atan() 공개 정적인 메소드

public static atan ( vec3 y, vec3 x ) : vec3
y vec3
x vec3
리턴 vec3

atan() 공개 정적인 메소드

public static atan ( vec4 y_over_x ) : vec4
y_over_x vec4
리턴 vec4

atan() 공개 정적인 메소드

public static atan ( vec4 y, vec4 x ) : vec4
y vec4
x vec4
리턴 vec4

atanh() 공개 정적인 메소드

public static atanh ( float x ) : float
x float
리턴 float

atanh() 공개 정적인 메소드

public static atanh ( vec2 x ) : vec2
x vec2
리턴 vec2

atanh() 공개 정적인 메소드

public static atanh ( vec3 x ) : vec3
x vec3
리턴 vec3

atanh() 공개 정적인 메소드

public static atanh ( vec4 x ) : vec4
x vec4
리턴 vec4

ceil() 공개 정적인 메소드

public static ceil ( float x ) : float
x float
리턴 float

ceil() 공개 정적인 메소드

public static ceil ( vec2 x ) : vec2
x vec2
리턴 vec2

ceil() 공개 정적인 메소드

public static ceil ( vec3 x ) : vec3
x vec3
리턴 vec3

ceil() 공개 정적인 메소드

public static ceil ( vec4 x ) : vec4
x vec4
리턴 vec4

clamp() 공개 정적인 메소드

public static clamp ( float x, float minVal, float maxVal ) : float
x float
minVal float
maxVal float
리턴 float

clamp() 공개 정적인 메소드

public static clamp ( int x, int minVal, int maxVal ) : int
x int
minVal int
maxVal int
리턴 int

clamp() 공개 정적인 메소드

public static clamp ( ivec2 x, int minVal, int maxVal ) : ivec2
x NewTOAPIA.Graphics.ivec2
minVal int
maxVal int
리턴 NewTOAPIA.Graphics.ivec2

clamp() 공개 정적인 메소드

public static clamp ( ivec2 x, ivec2 minVal, ivec2 maxVal ) : ivec2
x NewTOAPIA.Graphics.ivec2
minVal NewTOAPIA.Graphics.ivec2
maxVal NewTOAPIA.Graphics.ivec2
리턴 NewTOAPIA.Graphics.ivec2

clamp() 공개 정적인 메소드

public static clamp ( ivec3 x, int minVal, int maxVal ) : ivec3
x NewTOAPIA.Graphics.ivec3
minVal int
maxVal int
리턴 NewTOAPIA.Graphics.ivec3

clamp() 공개 정적인 메소드

public static clamp ( ivec3 x, ivec3 minVal, ivec3 maxVal ) : ivec3
x NewTOAPIA.Graphics.ivec3
minVal NewTOAPIA.Graphics.ivec3
maxVal NewTOAPIA.Graphics.ivec3
리턴 NewTOAPIA.Graphics.ivec3

clamp() 공개 정적인 메소드

public static clamp ( ivec4 x, int minVal, int maxVal ) : ivec4
x NewTOAPIA.Graphics.ivec4
minVal int
maxVal int
리턴 NewTOAPIA.Graphics.ivec4

clamp() 공개 정적인 메소드

public static clamp ( ivec4 x, ivec4 minVal, ivec4 maxVal ) : ivec4
x NewTOAPIA.Graphics.ivec4
minVal NewTOAPIA.Graphics.ivec4
maxVal NewTOAPIA.Graphics.ivec4
리턴 NewTOAPIA.Graphics.ivec4

clamp() 공개 정적인 메소드

public static clamp ( uint x, uint minVal, uint maxVal ) : uint
x uint
minVal uint
maxVal uint
리턴 uint

clamp() 공개 정적인 메소드

public static clamp ( uvec2 x, uint minVal, uint maxVal ) : uvec2
x NewTOAPIA.Graphics.uvec2
minVal uint
maxVal uint
리턴 NewTOAPIA.Graphics.uvec2

clamp() 공개 정적인 메소드

public static clamp ( uvec2 x, uvec2 minVal, uvec2 maxVal ) : uvec2
x NewTOAPIA.Graphics.uvec2
minVal NewTOAPIA.Graphics.uvec2
maxVal NewTOAPIA.Graphics.uvec2
리턴 NewTOAPIA.Graphics.uvec2

clamp() 공개 정적인 메소드

public static clamp ( uvec3 x, uint minVal, uint maxVal ) : uvec3
x NewTOAPIA.Graphics.uvec3
minVal uint
maxVal uint
리턴 NewTOAPIA.Graphics.uvec3

clamp() 공개 정적인 메소드

public static clamp ( uvec3 x, uvec3 minVal, uvec3 maxVal ) : uvec3
x NewTOAPIA.Graphics.uvec3
minVal NewTOAPIA.Graphics.uvec3
maxVal NewTOAPIA.Graphics.uvec3
리턴 NewTOAPIA.Graphics.uvec3

clamp() 공개 정적인 메소드

public static clamp ( uvec4 x, uint minVal, uint maxVal ) : uvec4
x NewTOAPIA.Graphics.uvec4
minVal uint
maxVal uint
리턴 NewTOAPIA.Graphics.uvec4

clamp() 공개 정적인 메소드

public static clamp ( uvec4 x, uvec4 minVal, uvec4 maxVal ) : uvec4
x NewTOAPIA.Graphics.uvec4
minVal NewTOAPIA.Graphics.uvec4
maxVal NewTOAPIA.Graphics.uvec4
리턴 NewTOAPIA.Graphics.uvec4

clamp() 공개 정적인 메소드

public static clamp ( vec2 x, float minVal, float maxVal ) : vec2
x vec2
minVal float
maxVal float
리턴 vec2

clamp() 공개 정적인 메소드

public static clamp ( vec2 x, vec2 minVal, vec2 maxVal ) : vec2
x vec2
minVal vec2
maxVal vec2
리턴 vec2

clamp() 공개 정적인 메소드

public static clamp ( vec3 x, float minVal, float maxVal ) : vec3
x vec3
minVal float
maxVal float
리턴 vec3

clamp() 공개 정적인 메소드

public static clamp ( vec3 x, vec3 minVal, vec3 maxVal ) : vec3
x vec3
minVal vec3
maxVal vec3
리턴 vec3

clamp() 공개 정적인 메소드

public static clamp ( vec4 x, float minVal, float maxVal ) : vec4
x vec4
minVal float
maxVal float
리턴 vec4

clamp() 공개 정적인 메소드

public static clamp ( vec4 x, vec4 minVal, vec4 maxVal ) : vec4
x vec4
minVal vec4
maxVal vec4
리턴 vec4

cos() 공개 정적인 메소드

public static cos ( float radians ) : float
radians float
리턴 float

cos() 공개 정적인 메소드

public static cos ( vec2 radians ) : vec2
radians vec2
리턴 vec2

cos() 공개 정적인 메소드

public static cos ( vec3 radians ) : vec3
radians vec3
리턴 vec3

cos() 공개 정적인 메소드

public static cos ( vec4 radians ) : vec4
radians vec4
리턴 vec4

cosh() 공개 정적인 메소드

public static cosh ( float x ) : float
x float
리턴 float

cosh() 공개 정적인 메소드

public static cosh ( vec2 x ) : vec2
x vec2
리턴 vec2

cosh() 공개 정적인 메소드

public static cosh ( vec3 x ) : vec3
x vec3
리턴 vec3

cosh() 공개 정적인 메소드

public static cosh ( vec4 x ) : vec4
x vec4
리턴 vec4

cross() 공개 정적인 메소드

public static cross ( vec3 x, vec3 y ) : vec3
x vec3
y vec3
리턴 vec3

degrees() 공개 정적인 메소드

public static degrees ( float radians ) : float
radians float
리턴 float

degrees() 공개 정적인 메소드

public static degrees ( vec2 radians ) : vec2
radians vec2
리턴 vec2

degrees() 공개 정적인 메소드

public static degrees ( vec3 radians ) : vec3
radians vec3
리턴 vec3

degrees() 공개 정적인 메소드

public static degrees ( vec4 radians ) : vec4
radians vec4
리턴 vec4

distance() 공개 정적인 메소드

public static distance ( float p0, float p1 ) : float
p0 float
p1 float
리턴 float

distance() 공개 정적인 메소드

public static distance ( vec2 p0, vec2 p1 ) : float
p0 vec2
p1 vec2
리턴 float

distance() 공개 정적인 메소드

public static distance ( vec3 p0, vec3 p1 ) : float
p0 vec3
p1 vec3
리턴 float

distance() 공개 정적인 메소드

public static distance ( vec4 p0, vec4 p1 ) : float
p0 vec4
p1 vec4
리턴 float

dot() 공개 정적인 메소드

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

dot() 공개 정적인 메소드

public static dot ( vec2 x, vec2 y ) : float
x vec2
y vec2
리턴 float

dot() 공개 정적인 메소드

public static dot ( vec3 x, vec3 y ) : float
x vec3
y vec3
리턴 float

dot() 공개 정적인 메소드

public static dot ( vec4 x, vec4 y ) : float
x vec4
y vec4
리턴 float

equal() 공개 정적인 메소드

public static equal ( bvec2 x, bvec2 y ) : bvec2
x bvec2
y bvec2
리턴 bvec2

equal() 공개 정적인 메소드

public static equal ( ivec2 x, ivec2 y ) : bvec2
x NewTOAPIA.Graphics.ivec2
y NewTOAPIA.Graphics.ivec2
리턴 bvec2

equal() 공개 정적인 메소드

public static equal ( vec2 x, vec2 y ) : bvec2
x vec2
y vec2
리턴 bvec2

equal() 공개 정적인 메소드

public static equal ( bvec3 x, bvec3 y ) : bvec3
x bvec3
y bvec3
리턴 bvec3

equal() 공개 정적인 메소드

public static equal ( ivec3 x, ivec3 y ) : bvec3
x NewTOAPIA.Graphics.ivec3
y NewTOAPIA.Graphics.ivec3
리턴 bvec3

equal() 공개 정적인 메소드

public static equal ( vec3 x, vec3 y ) : bvec3
x vec3
y vec3
리턴 bvec3

equal() 공개 정적인 메소드

public static equal ( bvec4 x, bvec4 y ) : bvec4
x bvec4
y bvec4
리턴 bvec4

equal() 공개 정적인 메소드

public static equal ( ivec4 x, ivec4 y ) : bvec4
x NewTOAPIA.Graphics.ivec4
y NewTOAPIA.Graphics.ivec4
리턴 bvec4

equal() 공개 정적인 메소드

public static equal ( vec4 x, vec4 y ) : bvec4
x vec4
y vec4
리턴 bvec4

exp() 공개 정적인 메소드

public static exp ( float x ) : float
x float
리턴 float

exp() 공개 정적인 메소드

public static exp ( vec2 x ) : vec2
x vec2
리턴 vec2

exp() 공개 정적인 메소드

public static exp ( vec3 x ) : vec3
x vec3
리턴 vec3

exp() 공개 정적인 메소드

public static exp ( vec4 x ) : vec4
x vec4
리턴 vec4

exp2() 공개 정적인 메소드

public static exp2 ( float x ) : float
x float
리턴 float

exp2() 공개 정적인 메소드

public static exp2 ( vec2 x ) : vec2
x vec2
리턴 vec2

exp2() 공개 정적인 메소드

public static exp2 ( vec3 x ) : vec3
x vec3
리턴 vec3

exp2() 공개 정적인 메소드

public static exp2 ( vec4 x ) : vec4
x vec4
리턴 vec4

faceforward() 공개 정적인 메소드

public static faceforward ( float N, float I, float Nref ) : float
N float
I float
Nref float
리턴 float

faceforward() 공개 정적인 메소드

public static faceforward ( vec2 N, vec2 I, vec2 Nref ) : vec2
N vec2
I vec2
Nref vec2
리턴 vec2

faceforward() 공개 정적인 메소드

public static faceforward ( vec3 N, vec3 I, vec3 Nref ) : vec3
N vec3
I vec3
Nref vec3
리턴 vec3

faceforward() 공개 정적인 메소드

public static faceforward ( vec4 N, vec4 I, vec4 Nref ) : vec4
N vec4
I vec4
Nref vec4
리턴 vec4

floor() 공개 정적인 메소드

public static floor ( float x ) : float
x float
리턴 float

floor() 공개 정적인 메소드

public static floor ( vec2 x ) : vec2
x vec2
리턴 vec2

floor() 공개 정적인 메소드

public static floor ( vec3 x ) : vec3
x vec3
리턴 vec3

floor() 공개 정적인 메소드

public static floor ( vec4 x ) : vec4
x vec4
리턴 vec4

fract() 공개 정적인 메소드

public static fract ( float x ) : float
x float
리턴 float

fract() 공개 정적인 메소드

public static fract ( vec2 x ) : vec2
x vec2
리턴 vec2

fract() 공개 정적인 메소드

public static fract ( vec3 x ) : vec3
x vec3
리턴 vec3

fract() 공개 정적인 메소드

public static fract ( vec4 x ) : vec4
x vec4
리턴 vec4

greaterThan() 공개 정적인 메소드

public static greaterThan ( ivec2 x, ivec2 y ) : bvec2
x NewTOAPIA.Graphics.ivec2
y NewTOAPIA.Graphics.ivec2
리턴 bvec2

greaterThan() 공개 정적인 메소드

public static greaterThan ( vec2 x, vec2 y ) : bvec2
x vec2
y vec2
리턴 bvec2

greaterThan() 공개 정적인 메소드

public static greaterThan ( ivec3 x, ivec3 y ) : bvec3
x NewTOAPIA.Graphics.ivec3
y NewTOAPIA.Graphics.ivec3
리턴 bvec3

greaterThan() 공개 정적인 메소드

public static greaterThan ( vec3 x, vec3 y ) : bvec3
x vec3
y vec3
리턴 bvec3

greaterThan() 공개 정적인 메소드

public static greaterThan ( ivec4 x, ivec4 y ) : bvec4
x NewTOAPIA.Graphics.ivec4
y NewTOAPIA.Graphics.ivec4
리턴 bvec4

greaterThan() 공개 정적인 메소드

public static greaterThan ( vec4 x, vec4 y ) : bvec4
x vec4
y vec4
리턴 bvec4

greaterThanEqual() 공개 정적인 메소드

public static greaterThanEqual ( ivec2 x, ivec2 y ) : bvec2
x NewTOAPIA.Graphics.ivec2
y NewTOAPIA.Graphics.ivec2
리턴 bvec2

greaterThanEqual() 공개 정적인 메소드

public static greaterThanEqual ( vec2 x, vec2 y ) : bvec2
x vec2
y vec2
리턴 bvec2

greaterThanEqual() 공개 정적인 메소드

public static greaterThanEqual ( ivec3 x, ivec3 y ) : bvec3
x NewTOAPIA.Graphics.ivec3
y NewTOAPIA.Graphics.ivec3
리턴 bvec3

greaterThanEqual() 공개 정적인 메소드

public static greaterThanEqual ( vec3 x, vec3 y ) : bvec3
x vec3
y vec3
리턴 bvec3

greaterThanEqual() 공개 정적인 메소드

public static greaterThanEqual ( ivec4 x, ivec4 y ) : bvec4
x NewTOAPIA.Graphics.ivec4
y NewTOAPIA.Graphics.ivec4
리턴 bvec4

greaterThanEqual() 공개 정적인 메소드

public static greaterThanEqual ( vec4 x, vec4 y ) : bvec4
x vec4
y vec4
리턴 bvec4

inverse() 공개 정적인 메소드

public static inverse ( mat2 m ) : mat2
m NewTOAPIA.Graphics.mat2
리턴 NewTOAPIA.Graphics.mat2

inverse() 공개 정적인 메소드

public static inverse ( mat3 m ) : mat3
m NewTOAPIA.Graphics.mat3
리턴 NewTOAPIA.Graphics.mat3

inverse() 공개 정적인 메소드

public static inverse ( mat4 m ) : mat4
m NewTOAPIA.Graphics.mat4
리턴 NewTOAPIA.Graphics.mat4

inversesqrt() 공개 정적인 메소드

public static inversesqrt ( float x ) : float
x float
리턴 float

inversesqrt() 공개 정적인 메소드

public static inversesqrt ( vec2 x ) : vec2
x vec2
리턴 vec2

inversesqrt() 공개 정적인 메소드

public static inversesqrt ( vec3 x ) : vec3
x vec3
리턴 vec3

inversesqrt() 공개 정적인 메소드

public static inversesqrt ( vec4 x ) : vec4
x vec4
리턴 vec4

isinf() 공개 정적인 메소드

public static isinf ( float x ) : bool
x float
리턴 bool

isinf() 공개 정적인 메소드

public static isinf ( vec2 x ) : bvec2
x vec2
리턴 bvec2

isinf() 공개 정적인 메소드

public static isinf ( vec3 x ) : bvec3
x vec3
리턴 bvec3

isinf() 공개 정적인 메소드

public static isinf ( vec4 x ) : bvec4
x vec4
리턴 bvec4

isnan() 공개 정적인 메소드

public static isnan ( float x ) : bool
x float
리턴 bool

isnan() 공개 정적인 메소드

public static isnan ( vec2 x ) : bvec2
x vec2
리턴 bvec2

isnan() 공개 정적인 메소드

public static isnan ( vec3 x ) : bvec3
x vec3
리턴 bvec3

isnan() 공개 정적인 메소드

public static isnan ( vec4 x ) : bvec4
x vec4
리턴 bvec4

length() 공개 정적인 메소드

public static length ( float x ) : float
x float
리턴 float

length() 공개 정적인 메소드

public static length ( vec2 x ) : float
x vec2
리턴 float

length() 공개 정적인 메소드

public static length ( vec3 x ) : float
x vec3
리턴 float

length() 공개 정적인 메소드

public static length ( vec4 x ) : float
x vec4
리턴 float

lessThan() 공개 정적인 메소드

public static lessThan ( ivec2 x, ivec2 y ) : bvec2
x NewTOAPIA.Graphics.ivec2
y NewTOAPIA.Graphics.ivec2
리턴 bvec2

lessThan() 공개 정적인 메소드

public static lessThan ( vec2 x, vec2 y ) : bvec2
x vec2
y vec2
리턴 bvec2

lessThan() 공개 정적인 메소드

public static lessThan ( ivec3 x, ivec3 y ) : bvec3
x NewTOAPIA.Graphics.ivec3
y NewTOAPIA.Graphics.ivec3
리턴 bvec3

lessThan() 공개 정적인 메소드

public static lessThan ( vec3 x, vec3 y ) : bvec3
x vec3
y vec3
리턴 bvec3

lessThan() 공개 정적인 메소드

public static lessThan ( ivec4 x, ivec4 y ) : bvec4
x NewTOAPIA.Graphics.ivec4
y NewTOAPIA.Graphics.ivec4
리턴 bvec4

lessThan() 공개 정적인 메소드

public static lessThan ( vec4 x, vec4 y ) : bvec4
x vec4
y vec4
리턴 bvec4

lessThanEqual() 공개 정적인 메소드

public static lessThanEqual ( ivec2 x, ivec2 y ) : bvec2
x NewTOAPIA.Graphics.ivec2
y NewTOAPIA.Graphics.ivec2
리턴 bvec2

lessThanEqual() 공개 정적인 메소드

public static lessThanEqual ( vec2 x, vec2 y ) : bvec2
x vec2
y vec2
리턴 bvec2

lessThanEqual() 공개 정적인 메소드

public static lessThanEqual ( ivec3 x, ivec3 y ) : bvec3
x NewTOAPIA.Graphics.ivec3
y NewTOAPIA.Graphics.ivec3
리턴 bvec3

lessThanEqual() 공개 정적인 메소드

public static lessThanEqual ( vec3 x, vec3 y ) : bvec3
x vec3
y vec3
리턴 bvec3

lessThanEqual() 공개 정적인 메소드

public static lessThanEqual ( ivec4 x, ivec4 y ) : bvec4
x NewTOAPIA.Graphics.ivec4
y NewTOAPIA.Graphics.ivec4
리턴 bvec4

lessThanEqual() 공개 정적인 메소드

public static lessThanEqual ( vec4 x, vec4 y ) : bvec4
x vec4
y vec4
리턴 bvec4

log() 공개 정적인 메소드

public static log ( float x ) : float
x float
리턴 float

log() 공개 정적인 메소드

public static log ( vec2 x ) : vec2
x vec2
리턴 vec2

log() 공개 정적인 메소드

public static log ( vec3 x ) : vec3
x vec3
리턴 vec3

log() 공개 정적인 메소드

public static log ( vec4 x ) : vec4
x vec4
리턴 vec4

log2() 공개 정적인 메소드

public static log2 ( float x ) : float
x float
리턴 float

log2() 공개 정적인 메소드

public static log2 ( vec2 x ) : vec2
x vec2
리턴 vec2

log2() 공개 정적인 메소드

public static log2 ( vec3 x ) : vec3
x vec3
리턴 vec3

log2() 공개 정적인 메소드

public static log2 ( vec4 x ) : vec4
x vec4
리턴 vec4

matrixCompMult() 공개 정적인 메소드

public static matrixCompMult ( mat2 x, mat2 y ) : mat2
x NewTOAPIA.Graphics.mat2
y NewTOAPIA.Graphics.mat2
리턴 NewTOAPIA.Graphics.mat2

matrixCompMult() 공개 정적인 메소드

public static matrixCompMult ( mat3 x, mat3 y ) : mat3
x NewTOAPIA.Graphics.mat3
y NewTOAPIA.Graphics.mat3
리턴 NewTOAPIA.Graphics.mat3

matrixCompMult() 공개 정적인 메소드

public static matrixCompMult ( mat4 x, mat4 y ) : mat4
x NewTOAPIA.Graphics.mat4
y NewTOAPIA.Graphics.mat4
리턴 NewTOAPIA.Graphics.mat4

max() 공개 정적인 메소드

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

max() 공개 정적인 메소드

public static max ( int x, int y ) : int
x int
y int
리턴 int

max() 공개 정적인 메소드

public static max ( ivec2 x, int y ) : ivec2
x NewTOAPIA.Graphics.ivec2
y int
리턴 NewTOAPIA.Graphics.ivec2

max() 공개 정적인 메소드

public static max ( ivec2 x, ivec2 y ) : ivec2
x NewTOAPIA.Graphics.ivec2
y NewTOAPIA.Graphics.ivec2
리턴 NewTOAPIA.Graphics.ivec2

max() 공개 정적인 메소드

public static max ( ivec3 x, int y ) : ivec3
x NewTOAPIA.Graphics.ivec3
y int
리턴 NewTOAPIA.Graphics.ivec3

max() 공개 정적인 메소드

public static max ( ivec3 x, ivec3 y ) : ivec3
x NewTOAPIA.Graphics.ivec3
y NewTOAPIA.Graphics.ivec3
리턴 NewTOAPIA.Graphics.ivec3

max() 공개 정적인 메소드

public static max ( ivec4 x, int y ) : ivec4
x NewTOAPIA.Graphics.ivec4
y int
리턴 NewTOAPIA.Graphics.ivec4

max() 공개 정적인 메소드

public static max ( ivec4 x, ivec4 y ) : ivec4
x NewTOAPIA.Graphics.ivec4
y NewTOAPIA.Graphics.ivec4
리턴 NewTOAPIA.Graphics.ivec4

max() 공개 정적인 메소드

public static max ( uint x, uint y ) : uint
x uint
y uint
리턴 uint

max() 공개 정적인 메소드

public static max ( uvec2 x, uint y ) : uvec2
x NewTOAPIA.Graphics.uvec2
y uint
리턴 NewTOAPIA.Graphics.uvec2

max() 공개 정적인 메소드

public static max ( uvec2 x, uvec2 y ) : uvec2
x NewTOAPIA.Graphics.uvec2
y NewTOAPIA.Graphics.uvec2
리턴 NewTOAPIA.Graphics.uvec2

max() 공개 정적인 메소드

public static max ( uvec3 x, uint y ) : uvec3
x NewTOAPIA.Graphics.uvec3
y uint
리턴 NewTOAPIA.Graphics.uvec3

max() 공개 정적인 메소드

public static max ( uvec3 x, uvec3 y ) : uvec3
x NewTOAPIA.Graphics.uvec3
y NewTOAPIA.Graphics.uvec3
리턴 NewTOAPIA.Graphics.uvec3

max() 공개 정적인 메소드

public static max ( uvec4 x, uint y ) : uvec4
x NewTOAPIA.Graphics.uvec4
y uint
리턴 NewTOAPIA.Graphics.uvec4

max() 공개 정적인 메소드

public static max ( uvec4 x, uvec4 y ) : uvec4
x NewTOAPIA.Graphics.uvec4
y NewTOAPIA.Graphics.uvec4
리턴 NewTOAPIA.Graphics.uvec4

max() 공개 정적인 메소드

public static max ( vec2 x, float y ) : vec2
x vec2
y float
리턴 vec2

max() 공개 정적인 메소드

public static max ( vec2 x, vec2 y ) : vec2
x vec2
y vec2
리턴 vec2

max() 공개 정적인 메소드

public static max ( vec3 x, float y ) : vec3
x vec3
y float
리턴 vec3

max() 공개 정적인 메소드

public static max ( vec3 x, vec3 y ) : vec3
x vec3
y vec3
리턴 vec3

max() 공개 정적인 메소드

public static max ( vec4 x, float y ) : vec4
x vec4
y float
리턴 vec4

max() 공개 정적인 메소드

public static max ( vec4 x, vec4 y ) : vec4
x vec4
y vec4
리턴 vec4

min() 공개 정적인 메소드

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

min() 공개 정적인 메소드

public static min ( int x, int y ) : int
x int
y int
리턴 int

min() 공개 정적인 메소드

public static min ( ivec2 x, int y ) : ivec2
x NewTOAPIA.Graphics.ivec2
y int
리턴 NewTOAPIA.Graphics.ivec2

min() 공개 정적인 메소드

public static min ( ivec2 x, ivec2 y ) : ivec2
x NewTOAPIA.Graphics.ivec2
y NewTOAPIA.Graphics.ivec2
리턴 NewTOAPIA.Graphics.ivec2

min() 공개 정적인 메소드

public static min ( ivec3 x, int y ) : ivec3
x NewTOAPIA.Graphics.ivec3
y int
리턴 NewTOAPIA.Graphics.ivec3

min() 공개 정적인 메소드

public static min ( ivec3 x, ivec3 y ) : ivec3
x NewTOAPIA.Graphics.ivec3
y NewTOAPIA.Graphics.ivec3
리턴 NewTOAPIA.Graphics.ivec3

min() 공개 정적인 메소드

public static min ( ivec4 x, int y ) : ivec4
x NewTOAPIA.Graphics.ivec4
y int
리턴 NewTOAPIA.Graphics.ivec4

min() 공개 정적인 메소드

public static min ( ivec4 x, ivec4 y ) : ivec4
x NewTOAPIA.Graphics.ivec4
y NewTOAPIA.Graphics.ivec4
리턴 NewTOAPIA.Graphics.ivec4

min() 공개 정적인 메소드

public static min ( uint x, uint y ) : uint
x uint
y uint
리턴 uint

min() 공개 정적인 메소드

public static min ( uvec2 x, uint y ) : uvec2
x NewTOAPIA.Graphics.uvec2
y uint
리턴 NewTOAPIA.Graphics.uvec2

min() 공개 정적인 메소드

public static min ( uvec2 x, uvec2 y ) : uvec2
x NewTOAPIA.Graphics.uvec2
y NewTOAPIA.Graphics.uvec2
리턴 NewTOAPIA.Graphics.uvec2

min() 공개 정적인 메소드

public static min ( uvec3 x, uint y ) : uvec3
x NewTOAPIA.Graphics.uvec3
y uint
리턴 NewTOAPIA.Graphics.uvec3

min() 공개 정적인 메소드

public static min ( uvec3 x, uvec3 y ) : uvec3
x NewTOAPIA.Graphics.uvec3
y NewTOAPIA.Graphics.uvec3
리턴 NewTOAPIA.Graphics.uvec3

min() 공개 정적인 메소드

public static min ( uvec4 x, uint y ) : uvec4
x NewTOAPIA.Graphics.uvec4
y uint
리턴 NewTOAPIA.Graphics.uvec4

min() 공개 정적인 메소드

public static min ( uvec4 x, uvec4 y ) : uvec4
x NewTOAPIA.Graphics.uvec4
y NewTOAPIA.Graphics.uvec4
리턴 NewTOAPIA.Graphics.uvec4

min() 공개 정적인 메소드

public static min ( vec2 x, float y ) : vec2
x vec2
y float
리턴 vec2

min() 공개 정적인 메소드

public static min ( vec2 x, vec2 y ) : vec2
x vec2
y vec2
리턴 vec2

min() 공개 정적인 메소드

public static min ( vec3 x, float y ) : vec3
x vec3
y float
리턴 vec3

min() 공개 정적인 메소드

public static min ( vec3 x, vec3 y ) : vec3
x vec3
y vec3
리턴 vec3

min() 공개 정적인 메소드

public static min ( vec4 x, float y ) : vec4
x vec4
y float
리턴 vec4

min() 공개 정적인 메소드

public static min ( vec4 x, vec4 y ) : vec4
x vec4
y vec4
리턴 vec4

mix() 공개 정적인 메소드

public static mix ( float x, float y, float a ) : float
x float
y float
a float
리턴 float

mix() 공개 정적인 메소드

public static mix ( vec2 x, vec2 y, float a ) : vec2
x vec2
y vec2
a float
리턴 vec2

mix() 공개 정적인 메소드

public static mix ( vec2 x, vec2 y, vec2 a ) : vec2
x vec2
y vec2
a vec2
리턴 vec2

mix() 공개 정적인 메소드

public static mix ( vec3 x, vec3 y, float a ) : vec3
x vec3
y vec3
a float
리턴 vec3

mix() 공개 정적인 메소드

public static mix ( vec3 x, vec3 y, vec3 a ) : vec3
x vec3
y vec3
a vec3
리턴 vec3

mix() 공개 정적인 메소드

public static mix ( vec4 x, vec4 y, float a ) : vec4
x vec4
y vec4
a float
리턴 vec4

mix() 공개 정적인 메소드

public static mix ( vec4 x, vec4 y, vec4 a ) : vec4
x vec4
y vec4
a vec4
리턴 vec4

mod() 공개 정적인 메소드

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

mod() 공개 정적인 메소드

public static mod ( vec2 x, float y ) : vec2
x vec2
y float
리턴 vec2

mod() 공개 정적인 메소드

public static mod ( vec2 x, vec2 y ) : vec2
x vec2
y vec2
리턴 vec2

mod() 공개 정적인 메소드

public static mod ( vec3 x, float y ) : vec3
x vec3
y float
리턴 vec3

mod() 공개 정적인 메소드

public static mod ( vec3 x, vec3 y ) : vec3
x vec3
y vec3
리턴 vec3

mod() 공개 정적인 메소드

public static mod ( vec4 x, float y ) : vec4
x vec4
y float
리턴 vec4

mod() 공개 정적인 메소드

public static mod ( vec4 x, vec4 y ) : vec4
x vec4
y vec4
리턴 vec4

noise1() 공개 정적인 메소드

public static noise1 ( float x ) : float
x float
리턴 float

noise1() 공개 정적인 메소드

public static noise1 ( vec2 x ) : float
x vec2
리턴 float

noise1() 공개 정적인 메소드

public static noise1 ( vec3 x ) : float
x vec3
리턴 float

noise1() 공개 정적인 메소드

public static noise1 ( vec4 x ) : float
x vec4
리턴 float

noise2() 공개 정적인 메소드

public static noise2 ( float x ) : vec2
x float
리턴 vec2

noise2() 공개 정적인 메소드

public static noise2 ( vec2 x ) : vec2
x vec2
리턴 vec2

noise2() 공개 정적인 메소드

public static noise2 ( vec3 x ) : vec2
x vec3
리턴 vec2

noise2() 공개 정적인 메소드

public static noise2 ( vec4 x ) : vec2
x vec4
리턴 vec2

noise3() 공개 정적인 메소드

public static noise3 ( float x ) : vec3
x float
리턴 vec3

noise3() 공개 정적인 메소드

public static noise3 ( vec2 x ) : vec3
x vec2
리턴 vec3

noise3() 공개 정적인 메소드

public static noise3 ( vec3 x ) : vec3
x vec3
리턴 vec3

noise3() 공개 정적인 메소드

public static noise3 ( vec4 x ) : vec3
x vec4
리턴 vec3

noise4() 공개 정적인 메소드

public static noise4 ( float x ) : vec4
x float
리턴 vec4

noise4() 공개 정적인 메소드

public static noise4 ( vec2 x ) : vec4
x vec2
리턴 vec4

noise4() 공개 정적인 메소드

public static noise4 ( vec3 x ) : vec4
x vec3
리턴 vec4

noise4() 공개 정적인 메소드

public static noise4 ( vec4 x ) : vec4
x vec4
리턴 vec4

normalize() 공개 정적인 메소드

public static normalize ( float x ) : float
x float
리턴 float

normalize() 공개 정적인 메소드

public static normalize ( vec2 x ) : vec2
x vec2
리턴 vec2

normalize() 공개 정적인 메소드

public static normalize ( vec3 x ) : vec3
x vec3
리턴 vec3

normalize() 공개 정적인 메소드

public static normalize ( vec4 x ) : vec4
x vec4
리턴 vec4

not() 공개 정적인 메소드

public static not ( bvec2 x ) : bvec2
x bvec2
리턴 bvec2

not() 공개 정적인 메소드

public static not ( bvec3 x ) : bvec3
x bvec3
리턴 bvec3

not() 공개 정적인 메소드

public static not ( bvec4 x ) : bvec4
x bvec4
리턴 bvec4

notEqual() 공개 정적인 메소드

public static notEqual ( bvec2 x, bvec2 y ) : bvec2
x bvec2
y bvec2
리턴 bvec2

notEqual() 공개 정적인 메소드

public static notEqual ( ivec2 x, ivec2 y ) : bvec2
x ivec2
y ivec2
리턴 bvec2

notEqual() 공개 정적인 메소드

public static notEqual ( vec2 x, vec2 y ) : bvec2
x vec2
y vec2
리턴 bvec2

notEqual() 공개 정적인 메소드

public static notEqual ( bvec3 x, bvec3 y ) : bvec3
x bvec3
y bvec3
리턴 bvec3

notEqual() 공개 정적인 메소드

public static notEqual ( ivec3 x, ivec3 y ) : bvec3
x ivec3
y ivec3
리턴 bvec3

notEqual() 공개 정적인 메소드

public static notEqual ( vec3 x, vec3 y ) : bvec3
x vec3
y vec3
리턴 bvec3

notEqual() 공개 정적인 메소드

public static notEqual ( bvec4 x, bvec4 y ) : bvec4
x bvec4
y bvec4
리턴 bvec4

notEqual() 공개 정적인 메소드

public static notEqual ( ivec4 x, ivec4 y ) : bvec4
x ivec4
y ivec4
리턴 bvec4

notEqual() 공개 정적인 메소드

public static notEqual ( vec4 x, vec4 y ) : bvec4
x vec4
y vec4
리턴 bvec4

outerProcuct() 공개 정적인 메소드

public static outerProcuct ( vec4 c, vec4 r ) : mat4
c vec4
r vec4
리턴 mat4

outerProduct() 공개 정적인 메소드

public static outerProduct ( vec2 c, vec2 r ) : mat2
c vec2
r vec2
리턴 mat2

outerProduct() 공개 정적인 메소드

public static outerProduct ( vec3 c, vec3 r ) : mat3
c vec3
r vec3
리턴 mat3

pow() 공개 정적인 메소드

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

pow() 공개 정적인 메소드

public static pow ( vec2 x, vec2 y ) : vec2
x vec2
y vec2
리턴 vec2

pow() 공개 정적인 메소드

public static pow ( vec3 x, vec3 y ) : vec3
x vec3
y vec3
리턴 vec3

pow() 공개 정적인 메소드

public static pow ( vec4 x, vec4 y ) : vec4
x vec4
y vec4
리턴 vec4

radians() 공개 정적인 메소드

public static radians ( float degrees ) : float
degrees float
리턴 float

radians() 공개 정적인 메소드

public static radians ( vec2 degrees ) : vec2
degrees vec2
리턴 vec2

radians() 공개 정적인 메소드

public static radians ( vec3 degrees ) : vec3
degrees vec3
리턴 vec3

radians() 공개 정적인 메소드

public static radians ( vec4 degrees ) : vec4
degrees vec4
리턴 vec4

reflect() 공개 정적인 메소드

public static reflect ( float I, float N ) : float
I float
N float
리턴 float

reflect() 공개 정적인 메소드

public static reflect ( vec2 I, vec2 N ) : vec2
I vec2
N vec2
리턴 vec2

reflect() 공개 정적인 메소드

public static reflect ( vec3 I, vec3 N ) : vec3
I vec3
N vec3
리턴 vec3

reflect() 공개 정적인 메소드

public static reflect ( vec4 I, vec4 N ) : vec4
I vec4
N vec4
리턴 vec4

refract() 공개 정적인 메소드

public static refract ( float I, float N, float eta ) : float
I float
N float
eta float
리턴 float

refract() 공개 정적인 메소드

public static refract ( vec2 I, vec2 N, float eta ) : vec2
I vec2
N vec2
eta float
리턴 vec2

refract() 공개 정적인 메소드

public static refract ( vec3 I, vec3 N, float eta ) : vec3
I vec3
N vec3
eta float
리턴 vec3

refract() 공개 정적인 메소드

public static refract ( vec4 I, vec4 N, float eta ) : vec4
I vec4
N vec4
eta float
리턴 vec4

round() 공개 정적인 메소드

public static round ( float x ) : float
x float
리턴 float

round() 공개 정적인 메소드

public static round ( vec2 x ) : vec2
x vec2
리턴 vec2

round() 공개 정적인 메소드

public static round ( vec3 x ) : vec3
x vec3
리턴 vec3

round() 공개 정적인 메소드

public static round ( vec4 x ) : vec4
x vec4
리턴 vec4

roundeven() 공개 정적인 메소드

public static roundeven ( float x ) : float
x float
리턴 float

roundeven() 공개 정적인 메소드

public static roundeven ( vec2 x ) : vec2
x vec2
리턴 vec2

roundeven() 공개 정적인 메소드

public static roundeven ( vec3 x ) : vec3
x vec3
리턴 vec3

roundeven() 공개 정적인 메소드

public static roundeven ( vec4 x ) : vec4
x vec4
리턴 vec4

sign() 공개 정적인 메소드

public static sign ( float x ) : float
x float
리턴 float

sign() 공개 정적인 메소드

public static sign ( int x ) : int
x int
리턴 int

sign() 공개 정적인 메소드

public static sign ( ivec2 x ) : ivec2
x ivec2
리턴 ivec2

sign() 공개 정적인 메소드

public static sign ( ivec3 x ) : ivec3
x ivec3
리턴 ivec3

sign() 공개 정적인 메소드

public static sign ( ivec4 x ) : ivec4
x ivec4
리턴 ivec4

sign() 공개 정적인 메소드

public static sign ( vec2 x ) : vec2
x vec2
리턴 vec2

sign() 공개 정적인 메소드

public static sign ( vec3 x ) : vec3
x vec3
리턴 vec3

sign() 공개 정적인 메소드

public static sign ( vec4 x ) : vec4
x vec4
리턴 vec4

sin() 공개 정적인 메소드

public static sin ( float radians ) : float
radians float
리턴 float

sin() 공개 정적인 메소드

public static sin ( vec2 radians ) : vec2
radians vec2
리턴 vec2

sin() 공개 정적인 메소드

public static sin ( vec3 radians ) : vec3
radians vec3
리턴 vec3

sin() 공개 정적인 메소드

public static sin ( vec4 radians ) : vec4
radians vec4
리턴 vec4

sinh() 공개 정적인 메소드

public static sinh ( float x ) : float
x float
리턴 float

sinh() 공개 정적인 메소드

public static sinh ( vec2 x ) : vec2
x vec2
리턴 vec2

sinh() 공개 정적인 메소드

public static sinh ( vec3 x ) : vec3
x vec3
리턴 vec3

sinh() 공개 정적인 메소드

public static sinh ( vec4 x ) : vec4
x vec4
리턴 vec4

smoothstep() 공개 정적인 메소드

public static smoothstep ( float edge0, float edge1, float x ) : float
edge0 float
edge1 float
x float
리턴 float

smoothstep() 공개 정적인 메소드

public static smoothstep ( float edge0, float edge1, vec2 x ) : vec2
edge0 float
edge1 float
x vec2
리턴 vec2

smoothstep() 공개 정적인 메소드

public static smoothstep ( vec2 edge0, vec2 edge1, vec2 x ) : vec2
edge0 vec2
edge1 vec2
x vec2
리턴 vec2

smoothstep() 공개 정적인 메소드

public static smoothstep ( float edge0, float edge1, vec3 x ) : vec3
edge0 float
edge1 float
x vec3
리턴 vec3

smoothstep() 공개 정적인 메소드

public static smoothstep ( vec3 edge0, vec3 edge1, vec3 x ) : vec3
edge0 vec3
edge1 vec3
x vec3
리턴 vec3

smoothstep() 공개 정적인 메소드

public static smoothstep ( float edge0, float edge1, vec4 x ) : vec4
edge0 float
edge1 float
x vec4
리턴 vec4

smoothstep() 공개 정적인 메소드

public static smoothstep ( vec4 edge0, vec4 edge1, vec4 x ) : vec4
edge0 vec4
edge1 vec4
x vec4
리턴 vec4

sqrt() 공개 정적인 메소드

public static sqrt ( float x ) : float
x float
리턴 float

sqrt() 공개 정적인 메소드

public static sqrt ( vec2 x ) : vec2
x vec2
리턴 vec2

sqrt() 공개 정적인 메소드

public static sqrt ( vec3 x ) : vec3
x vec3
리턴 vec3

sqrt() 공개 정적인 메소드

public static sqrt ( vec4 x ) : vec4
x vec4
리턴 vec4

step() 공개 정적인 메소드

public static step ( float edge, float x ) : float
edge float
x float
리턴 float

step() 공개 정적인 메소드

public static step ( float edge, vec2 x ) : vec2
edge float
x vec2
리턴 vec2

step() 공개 정적인 메소드

public static step ( vec2 edge, vec2 x ) : vec2
edge vec2
x vec2
리턴 vec2

step() 공개 정적인 메소드

public static step ( float edge, vec3 x ) : vec3
edge float
x vec3
리턴 vec3

step() 공개 정적인 메소드

public static step ( vec3 edge, vec3 x ) : vec3
edge vec3
x vec3
리턴 vec3

step() 공개 정적인 메소드

public static step ( float edge, vec4 x ) : vec4
edge float
x vec4
리턴 vec4

step() 공개 정적인 메소드

public static step ( vec4 edge, vec4 x ) : vec4
edge vec4
x vec4
리턴 vec4

tan() 공개 정적인 메소드

public static tan ( float radians ) : float
radians float
리턴 float

tan() 공개 정적인 메소드

public static tan ( vec2 radians ) : vec2
radians vec2
리턴 vec2

tan() 공개 정적인 메소드

public static tan ( vec3 radians ) : vec3
radians vec3
리턴 vec3

tan() 공개 정적인 메소드

public static tan ( vec4 radians ) : vec4
radians vec4
리턴 vec4

tanh() 공개 정적인 메소드

public static tanh ( float x ) : float
x float
리턴 float

tanh() 공개 정적인 메소드

public static tanh ( vec2 x ) : vec2
x vec2
리턴 vec2

tanh() 공개 정적인 메소드

public static tanh ( vec3 x ) : vec3
x vec3
리턴 vec3

tanh() 공개 정적인 메소드

public static tanh ( vec4 x ) : vec4
x vec4
리턴 vec4

texture() 공개 정적인 메소드

public static texture ( sampler1D sampler, float coord ) : vec4
sampler sampler1D
coord float
리턴 vec4

texture() 공개 정적인 메소드

public static texture ( sampler2D sampler, vec2 coord ) : vec4
sampler sampler2D
coord vec2
리턴 vec4

texture() 공개 정적인 메소드

public static texture ( sampler3D sampler, vec3 coord ) : vec4
sampler sampler3D
coord vec3
리턴 vec4

transpose() 공개 정적인 메소드

public static transpose ( mat2 m ) : mat2
m mat2
리턴 mat2

transpose() 공개 정적인 메소드

public static transpose ( mat3x2 m ) : mat2x3
m mat3x2
리턴 mat2x3

transpose() 공개 정적인 메소드

public static transpose ( mat4x2 m ) : mat2x4
m mat4x2
리턴 mat2x4

transpose() 공개 정적인 메소드

public static transpose ( mat3 m ) : mat3
m mat3
리턴 mat3

transpose() 공개 정적인 메소드

public static transpose ( mat2x3 m ) : mat3x2
m mat2x3
리턴 mat3x2

transpose() 공개 정적인 메소드

public static transpose ( mat4x3 m ) : mat3x4
m mat4x3
리턴 mat3x4

transpose() 공개 정적인 메소드

public static transpose ( mat4 m ) : mat4
m mat4
리턴 mat4

transpose() 공개 정적인 메소드

public static transpose ( mat2x4 m ) : mat4x2
m mat2x4
리턴 mat4x2

transpose() 공개 정적인 메소드

public static transpose ( mat3x4 m ) : mat4x3
m mat3x4
리턴 mat4x3

trunc() 공개 정적인 메소드

public static trunc ( float x ) : float
x float
리턴 float

trunc() 공개 정적인 메소드

public static trunc ( vec2 x ) : vec2
x vec2
리턴 vec2

trunc() 공개 정적인 메소드

public static trunc ( vec3 x ) : vec3
x vec3
리턴 vec3

trunc() 공개 정적인 메소드

public static trunc ( vec4 x ) : vec4
x vec4
리턴 vec4