ColorShaders

Type Members

type ColorShader = (Vector3, Vector3, Vector2, Projection) ⇒ Color

A function that takes: (1) the point of the vertex, (2) the normal at the vertex, (3) the UV coordinate of the vertex, and (4) the projection from world coordinates to the eye, returning a color.

Value Members

final def !=(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def !=(arg0: Any): Boolean

Definition Classes
Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def ==(arg0: Any): Boolean

Definition Classes
Any
val DEFAULT: (Vector3, Vector3, Vector2, Projection) ⇒ Color
final def asInstanceOf[T0]: T0

Definition Classes
Any
def checker(c: (Vector3, Vector3, Vector2, Projection) ⇒ Color, d: (Vector3, Vector3, Vector2, Projection) ⇒ Color): (Vector3, Vector3, Vector2, Projection) ⇒ Color

Creates a shader with a checkerboard pattern that alternates between two shaders.
Creates a shader with a checkerboard pattern that alternates between two shaders.
c
the first shader
d
the second shader
returns
a checkboard shader
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def lambert(m: ColorMap, lights: Vector[Light]): (Vector3, Vector3, Vector2, Projection) ⇒ Color

Creates a diffuse (Lambertian) shader with the specified surface map and the specified light.
Creates a diffuse (Lambertian) shader with the specified surface map and the specified light.
m
the surface map sampled for colors
lights
the lights used as an illumination source
returns
a Lambert shader
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def phong(diffuse: ColorMap, specular: ColorMap, hardness: Float = 20.0f, lights: Vector[Light]): (Vector3, Vector3, Vector2, Projection) ⇒ Color

Creates a shiny (Phong) shader with the specified surface map and the specified light.
Creates a shiny (Phong) shader with the specified surface map and the specified light.
For best results, scale down the diffuse and specular maps so they add up to about 1.0; a ratio of 0.8 diffuse--0.2 specular is a good starting point.
diffuse
the surface map sampled for diffuse colors
specular
the surface map sampled for specular colors
hardness
the hardness of the specular reflection (the Phong cosine power)
lights
the lights used as an illumination source
returns
a Phong shader
def solid(c: Color): (Vector3, Vector3, Vector2, Projection) ⇒ Color

A solid color shader.
A solid color shader.
c
the color
returns
a shader
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
def toonLambert(m: ColorMap, e: ColorMap, levels: Int = 3, contour: Float = 0.5f, smoothness: Float = 0.1f, lights: Vector[Light]): (Vector3, Vector3, Vector2, Projection) ⇒ Color

Creates a toon/cel shader, using Lambertian reflectance only, with the specified surface map and the specified light.
Creates a toon/cel shader, using Lambertian reflectance only, with the specified surface map and the specified light.
Note: this shader guesses edges by comparing the surface normal with the vector from the camera; this causes surfaces nearly perpendicular to the camera to appear completely black (as edges).
m
the surface map sampled for non-edge colors
e
the surface map sampled for edge colors
levels
the number of levels of shading
contour
a factor that is proportional to the edge contour thickness; 0.0 = no contour, 1.0 = thickest contour
smoothness
a factor that controls how smooth the smoothness between the surface and contours; 0.0 = no smoothing, 1.0 = smoothed across entire surface
lights
the lights used as an illumination source
returns
a toon shader
def toonPhong(diffuse: ColorMap, specular: ColorMap, e: ColorMap, hardness: Float = 20.0f, levels: Int = 3, contour: Float = 0.5f, smoothness: Float = 0.1f, lights: Vector[Light]): (Vector3, Vector3, Vector2, Projection) ⇒ Color

Creates a toon/cel shader, using Lambertian reflectance only, with the specified surface map and the specified light.
Creates a toon/cel shader, using Lambertian reflectance only, with the specified surface map and the specified light.
Note: this shader guesses edges by comparing the surface normal with the vector from the camera; this causes surfaces nearly perpendicular to the camera to appear completely black (as edges).
diffuse
the surface map sampled for non-edge colors
specular
the surface map sampled for specular colors
e
the surface map sampled for edge colors
hardness
the size of the specular reflection (the Phong cosine power)
levels
the number of levels of shading
contour
a factor that is proportional to the edge contour thickness; 0.0 = no contour, 1.0 = thickest contour
smoothness
a factor that controls how smooth the smoothness between the surface and contours or highlights; 0.0 = no smoothing, 1.0 = smoothed across entire surface
lights
the lights used as an illumination source
returns
a toon shader
def uvTest: (Vector3, Vector3, Vector2, Projection) ⇒ Color

A shader for testing UV coordinates.
A shader for testing UV coordinates. U = 0 is the least saturated; U = 1 is the most saturated (sky blue color). V = 0 is the darkest; V = 1 is the lightest.
returns
a UV test shader
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

object ColorShaders

Type Members

type ColorShader = (Vector3, Vector3, Vector2, Projection) ⇒ Color

Value Members

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

val DEFAULT: (Vector3, Vector3, Vector2, Projection) ⇒ Color

final def asInstanceOf[T0]: T0

def checker(c: (Vector3, Vector3, Vector2, Projection) ⇒ Color, d: (Vector3, Vector3, Vector2, Projection) ⇒ Color): (Vector3, Vector3, Vector2, Projection) ⇒ Color

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def lambert(m: ColorMap, lights: Vector[Light]): (Vector3, Vector3, Vector2, Projection) ⇒ Color

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def phong(diffuse: ColorMap, specular: ColorMap, hardness: Float = 20.0f, lights: Vector[Light]): (Vector3, Vector3, Vector2, Projection) ⇒ Color

def solid(c: Color): (Vector3, Vector3, Vector2, Projection) ⇒ Color

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

def toonLambert(m: ColorMap, e: ColorMap, levels: Int = 3, contour: Float = 0.5f, smoothness: Float = 0.1f, lights: Vector[Light]): (Vector3, Vector3, Vector2, Projection) ⇒ Color

def toonPhong(diffuse: ColorMap, specular: ColorMap, e: ColorMap, hardness: Float = 20.0f, levels: Int = 3, contour: Float = 0.5f, smoothness: Float = 0.1f, lights: Vector[Light]): (Vector3, Vector3, Vector2, Projection) ⇒ Color

def uvTest: (Vector3, Vector3, Vector2, Projection) ⇒ Color

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

Inherited from AnyRef

Inherited from Any

Ungrouped