Class Color4

Class used to hold a RBGA color

Hierarchy

Color4

Constructors

constructor

new Color4(r?: number, g?: number, b?: number, a?: number): Color4
Creates a new Color4 object from red, green, blue values, all between 0 and 1
Parameters
- Optional r: number
  
  defines the red component (between 0 and 1, default is 0)
- Optional g: number
  
  defines the green component (between 0 and 1, default is 0)
- Optional b: number
  
  defines the blue component (between 0 and 1, default is 0)
- Optional a: number
  
  defines the alpha component (between 0 and 1, default is 1)
Returns Color4
- Defined in node_modules/@babylonjs/core/Maths/math.color.d.ts:415

Properties

a

a: number

Defines the alpha component (between 0 and 1, default is 1)

b

b: number

Defines the blue component (between 0 and 1, default is 0)

g

g: number

Defines the green component (between 0 and 1, default is 0)

r

r: number

Defines the red component (between 0 and 1, default is 0)

Methods

add

add(right: DeepImmutableObject<Color4>): Color4
Creates a new Color4 set with the added values of the current Color4 and of the given one

Returns
a new Color4 object
Parameters
- right: DeepImmutableObject<Color4>
  
  defines the second operand
Returns Color4
- Defined in node_modules/@babylonjs/core/Maths/math.color.d.ts:468

addInPlace

addInPlace(right: DeepImmutableObject<Color4>): Color4
Adds in place the given Color4 values to the current Color4 object

Returns
the current updated Color4 object
Parameters
- right: DeepImmutableObject<Color4>
  
  defines the second operand
Returns Color4
- Defined in node_modules/@babylonjs/core/Maths/math.color.d.ts:437

asArray

asArray(): number[]
Creates a new array populated with 4 numeric elements : red, green, blue, alpha values

Returns
the new array

Returns number[]
- Defined in node_modules/@babylonjs/core/Maths/math.color.d.ts:442

clampToRef

clampToRef(min: undefined | number, max: undefined | number, result: Color4): Color4
Clamps the rgb values by the min and max values and stores the result into "result"

Returns
the current Color4
Parameters
- min: undefined | number
  
  defines minimum clamping value (default is 0)
- max: undefined | number
  
  defines maximum clamping value (default is 1)
- result: Color4
  
  defines color to store the result into.
Returns Color4
- Defined in node_modules/@babylonjs/core/Maths/math.color.d.ts:515

clone

clone(): Color4
Creates a new Color4 copied from the current one

Returns
a new Color4 object

Returns Color4
- Defined in node_modules/@babylonjs/core/Maths/math.color.d.ts:548

copyFrom

copyFrom(source: Color4): Color4
Copies the given Color4 values into the current one

Returns
the current updated Color4 object
Parameters
- source: Color4
  
  defines the source Color4 object
Returns Color4
- Defined in node_modules/@babylonjs/core/Maths/math.color.d.ts:554

copyFromFloats

copyFromFloats(r: number, g: number, b: number, a: number): Color4
Copies the given float values into the current one

Returns
the current updated Color4 object
Parameters
- r: number
  
  defines the red component to read from
- g: number
  
  defines the green component to read from
- b: number
  
  defines the blue component to read from
- a: number
  
  defines the alpha component to read from
Returns Color4
- Defined in node_modules/@babylonjs/core/Maths/math.color.d.ts:563

equals

equals(otherColor: DeepImmutableObject<Color4>): boolean
Determines equality between Color4 objects

Returns
true if the rgba values are equal to the given ones
Parameters
- otherColor: DeepImmutableObject<Color4>
  
  defines the second operand
Returns boolean
- Defined in node_modules/@babylonjs/core/Maths/math.color.d.ts:462

fromArray

fromArray(array: DeepImmutableObject<ArrayLike<number>>, offset?: number): Color4
Update the current color with values stored in an array from the starting index of the given array

Returns
the current Color4 object
Parameters
- array: DeepImmutableObject<ArrayLike<number>>
  
  defines the source array
- Optional offset: number
  
  defines an offset in the source array
Returns Color4
- Defined in node_modules/@babylonjs/core/Maths/math.color.d.ts:456

getClassName

getClassName(): string
Returns the string "Color4"

Returns
"Color4"

Returns string
- Defined in node_modules/@babylonjs/core/Maths/math.color.d.ts:538

getHashCode

getHashCode(): number
Compute the Color4 hash code

Returns
an unique number that can be used to hash Color4 objects

Returns number
- Defined in node_modules/@babylonjs/core/Maths/math.color.d.ts:543

multiply

multiply(color: Color4): Color4
Multiply an Color4 value by another and return a new Color4 object

Returns
a new Color4 object
Parameters
- color: Color4
  
  defines the Color4 value to multiply by
Returns Color4
- Defined in node_modules/@babylonjs/core/Maths/math.color.d.ts:521

multiplyToRef

multiplyToRef(color: Color4, result: Color4): Color4
Multiply a Color4 value by another and push the result in a reference value

Returns
the result Color4
Parameters
- color: Color4
  
  defines the Color4 value to multiply by
- result: Color4
  
  defines the Color4 to fill the result in
Returns Color4
- Defined in node_modules/@babylonjs/core/Maths/math.color.d.ts:528

scale

scale(scale: number): Color4
Creates a new Color4 with the current Color4 values multiplied by scale

Returns
a new Color4 object
Parameters
- scale: number
  
  defines the scaling factor to apply
Returns Color4
- Defined in node_modules/@babylonjs/core/Maths/math.color.d.ts:487

scaleAndAddToRef

scaleAndAddToRef(scale: number, result: Color4): Color4
Scale the current Color4 values by a factor and add the result to a given Color4

Returns
the unmodified current Color4
Parameters
- scale: number
  
  defines the scale factor
- result: Color4
  
  defines the Color4 object where to store the result
Returns Color4
- Defined in node_modules/@babylonjs/core/Maths/math.color.d.ts:507

scaleInPlace

scaleInPlace(scale: number): Color4
Multiplies the Color4 values by the float "scale"

Returns
the current updated Color4
Parameters
- scale: number
  
  defines the scaling factor to apply
Returns Color4
- Defined in node_modules/@babylonjs/core/Maths/math.color.d.ts:493

scaleToRef

scaleToRef(scale: number, result: Color4): Color4
Multiplies the current Color4 values by scale and stores the result in "result"

Returns
the current unmodified Color4
Parameters
- scale: number
  
  defines the scaling factor to apply
- result: Color4
  
  defines the Color4 object where to store the result
Returns Color4
- Defined in node_modules/@babylonjs/core/Maths/math.color.d.ts:500

set

set(r: number, g: number, b: number, a: number): Color4
Copies the given float values into the current one

Returns
the current updated Color4 object
Parameters
- r: number
  
  defines the red component to read from
- g: number
  
  defines the green component to read from
- b: number
  
  defines the blue component to read from
- a: number
  
  defines the alpha component to read from
Returns Color4
- Defined in node_modules/@babylonjs/core/Maths/math.color.d.ts:572

subtract

subtract(right: DeepImmutableObject<Color4>): Color4
Creates a new Color4 set with the subtracted values of the given one from the current Color4

Returns
a new Color4 object
Parameters
- right: DeepImmutableObject<Color4>
  
  defines the second operand
Returns Color4
- Defined in node_modules/@babylonjs/core/Maths/math.color.d.ts:474

subtractToRef

subtractToRef(right: DeepImmutableObject<Color4>, result: Color4): Color4
Subtracts the given ones from the current Color4 values and stores the results in "result"

Returns
the current Color4 object
Parameters
- right: DeepImmutableObject<Color4>
  
  defines the second operand
- result: Color4
  
  defines the Color4 object where to store the result
Returns Color4
- Defined in node_modules/@babylonjs/core/Maths/math.color.d.ts:481

toArray

toArray(array: FloatArray, index?: number): Color4
Stores from the starting index in the given array the Color4 successive values

Returns
the current Color4 object
Parameters
- array: FloatArray
  
  defines the array where to store the r,g,b components
- Optional index: number
  
  defines an optional index in the target array to define where to start storing values
Returns Color4
- Defined in node_modules/@babylonjs/core/Maths/math.color.d.ts:449

toGammaSpace

toGammaSpace(exact?: boolean): Color4
Computes a new Color4 converted from the current one to gamma space

Returns
a new Color4 object
Parameters
- Optional exact: boolean
  
  defines if the conversion will be done in an exact way which is slower but more accurate (default is false)
Returns Color4
- Defined in node_modules/@babylonjs/core/Maths/math.color.d.ts:597

toGammaSpaceToRef

toGammaSpaceToRef(convertedColor: Color4, exact?: boolean): Color4
Converts the Color4 values to gamma space and stores the result in "convertedColor"

Returns
the unmodified Color4
Parameters
- convertedColor: Color4
  
  defines the Color4 object where to store the gamma space version
- Optional exact: boolean
  
  defines if the conversion will be done in an exact way which is slower but more accurate (default is false)
Returns Color4
- Defined in node_modules/@babylonjs/core/Maths/math.color.d.ts:604

toHexString

toHexString(returnAsColor3?: boolean): string
Compute the Color4 hexadecimal code as a string

Returns
a string containing the hexadecimal representation of the Color4 object
Parameters
- Optional returnAsColor3: boolean
  
  defines if the string should only contains RGB values (off by default)
Returns string
- Defined in node_modules/@babylonjs/core/Maths/math.color.d.ts:578

toLinearSpace

toLinearSpace(exact?: boolean): Color4
Computes a new Color4 converted from the current one to linear space

Returns
a new Color4 object
Parameters
- Optional exact: boolean
  
  defines if the conversion will be done in an exact way which is slower but more accurate (default is false)
Returns Color4
- Defined in node_modules/@babylonjs/core/Maths/math.color.d.ts:584

toLinearSpaceToRef

toLinearSpaceToRef(convertedColor: Color4, exact?: boolean): Color4
Converts the Color4 values to linear space and stores the result in "convertedColor"

Returns
the unmodified Color4
Parameters
- convertedColor: Color4
  
  defines the Color4 object where to store the linear space version
- Optional exact: boolean
  
  defines if the conversion will be done in an exact way which is slower but more accurate (default is false)
Returns Color4
- Defined in node_modules/@babylonjs/core/Maths/math.color.d.ts:591

toString

toString(): string
Creates a string with the Color4 current values

Returns
the string representation of the Color4 object

Returns string
- Defined in node_modules/@babylonjs/core/Maths/math.color.d.ts:533

`Static` CheckColors4

CheckColors4(colors: number[], count: number): number[]
Check the content of a given array and convert it to an array containing RGBA data If the original array was already containing count * 4 values then it is returned directly

Returns
an array containing count * 4 values (RGBA)
Parameters
- colors: number[]
  
  defines the array to check
- count: number
  
  defines the number of RGBA data to expect
Returns number[]
- Defined in node_modules/@babylonjs/core/Maths/math.color.d.ts:703

`Static` FromArray

FromArray(array: DeepImmutableObject<ArrayLike<number>>, offset?: number): Color4
Creates a new Color4 from the starting index element of the given array

Returns
a new Color4 object
Parameters
- array: DeepImmutableObject<ArrayLike<number>>
  
  defines the source array to read from
- Optional offset: number
  
  defines the offset in the source array
Returns Color4
- Defined in node_modules/@babylonjs/core/Maths/math.color.d.ts:679

`Static` FromArrayToRef

FromArrayToRef(array: DeepImmutableObject<ArrayLike<number>>, offset: undefined | number, result: Color4): void
Creates a new Color4 from the starting index element of the given array
Parameters
- array: DeepImmutableObject<ArrayLike<number>>
  
  defines the source array to read from
- offset: undefined | number
  
  defines the offset in the source array
- result: Color4
  
  defines the target Color4 object
Returns void
- Defined in node_modules/@babylonjs/core/Maths/math.color.d.ts:686

`Static` FromColor3

FromColor3(color3: DeepImmutableObject<Color3>, alpha?: number): Color4
Creates a new Color4 from a Color3 and an alpha value

Returns
a new Color4 object
Parameters
- color3: DeepImmutableObject<Color3>
  
  defines the source Color3 to read from
- Optional alpha: number
  
  defines the alpha component (1.0 by default)
Returns Color4
- Defined in node_modules/@babylonjs/core/Maths/math.color.d.ts:672

`Static` FromHexString

FromHexString(hex: string): Color4
Creates a new Color4 from the string containing valid hexadecimal values.

A valid hex string is either in the format #RRGGBB or #RRGGBBAA.

When a hex string without alpha is passed, the resulting Color4 has its alpha value set to 1.0.

An invalid string results in a Color with all its channels set to 0.0, i.e. "transparent black".

Returns
a new Color4 object
Parameters
- hex: string
  
  defines a string containing valid hexadecimal values
Returns Color4
- Defined in node_modules/@babylonjs/core/Maths/math.color.d.ts:619

`Static` FromInts

FromInts(r: number, g: number, b: number, a: number): Color4
Creates a new Color3 from integer values (< 256)

Returns
a new Color3 object
Parameters
- r: number
  
  defines the red component to read from (value between 0 and 255)
- g: number
  
  defines the green component to read from (value between 0 and 255)
- b: number
  
  defines the blue component to read from (value between 0 and 255)
- a: number
  
  defines the alpha component to read from (value between 0 and 255)
Returns Color4
- Defined in node_modules/@babylonjs/core/Maths/math.color.d.ts:695

`Static` Hermite

Hermite(value1: DeepImmutableObject<Color4>, tangent1: DeepImmutableObject<Color4>, value2: DeepImmutableObject<Color4>, tangent2: DeepImmutableObject<Color4>, amount: number): Color4
Interpolate between two Color4 using Hermite interpolation

Returns
the new interpolated Color4
Parameters
- value1: DeepImmutableObject<Color4>
  
  defines first Color4
- tangent1: DeepImmutableObject<Color4>
  
  defines the incoming tangent
- value2: DeepImmutableObject<Color4>
  
  defines second Color4
- tangent2: DeepImmutableObject<Color4>
  
  defines the outgoing tangent
- amount: number
  
  defines the target Color4
Returns Color4
- Defined in node_modules/@babylonjs/core/Maths/math.color.d.ts:645

`Static` Hermite1stDerivative

Hermite1stDerivative(value1: DeepImmutableObject<Color4>, tangent1: DeepImmutableObject<Color4>, value2: DeepImmutableObject<Color4>, tangent2: DeepImmutableObject<Color4>, time: number): Color4
Returns a new Color4 which is the 1st derivative of the Hermite spline defined by the colors "value1", "value2", "tangent1", "tangent2".

Returns
1st derivative
Parameters
- value1: DeepImmutableObject<Color4>
  
  defines the first control point
- tangent1: DeepImmutableObject<Color4>
  
  defines the first tangent
- value2: DeepImmutableObject<Color4>
  
  defines the second control point
- tangent2: DeepImmutableObject<Color4>
  
  defines the second tangent
- time: number
  
  define where the derivative must be done
Returns Color4
- Defined in node_modules/@babylonjs/core/Maths/math.color.d.ts:655

`Static` Hermite1stDerivativeToRef

Hermite1stDerivativeToRef(value1: DeepImmutableObject<Color4>, tangent1: DeepImmutableObject<Color4>, value2: DeepImmutableObject<Color4>, tangent2: DeepImmutableObject<Color4>, time: number, result: Color4): void
Update a Color4 with the 1st derivative of the Hermite spline defined by the colors "value1", "value2", "tangent1", "tangent2".
Parameters
- value1: DeepImmutableObject<Color4>
  
  defines the first control point
- tangent1: DeepImmutableObject<Color4>
  
  defines the first tangent
- value2: DeepImmutableObject<Color4>
  
  defines the second control point
- tangent2: DeepImmutableObject<Color4>
  
  defines the second tangent
- time: number
  
  define where the derivative must be done
- result: Color4
  
  define where to store the derivative
Returns void
- Defined in node_modules/@babylonjs/core/Maths/math.color.d.ts:665

`Static` Lerp

Lerp(left: DeepImmutableObject<Color4>, right: DeepImmutableObject<Color4>, amount: number): Color4
Creates a new Color4 object set with the linearly interpolated values of "amount" between the left Color4 object and the right Color4 object

Returns
a new Color4 object
Parameters
- left: DeepImmutableObject<Color4>
  
  defines the start value
- right: DeepImmutableObject<Color4>
  
  defines the end value
- amount: number
  
  defines the gradient factor
Returns Color4
- Defined in node_modules/@babylonjs/core/Maths/math.color.d.ts:627

`Static` LerpToRef

LerpToRef(left: DeepImmutableObject<Color4>, right: DeepImmutableObject<Color4>, amount: number, result: Color4): void
Set the given "result" with the linearly interpolated values of "amount" between the left Color4 object and the right Color4 object
Parameters
- left: DeepImmutableObject<Color4>
  
  defines the start value
- right: DeepImmutableObject<Color4>
  
  defines the end value
- amount: number
  
  defines the gradient factor
- result: Color4
  
  defines the Color4 object where to store data
Returns void
- Defined in node_modules/@babylonjs/core/Maths/math.color.d.ts:635

Class Color4

Hierarchy

Index

Constructors

Properties

Methods

Constructors

constructor

Parameters

Optional r: number

Optional g: number

Optional b: number

Optional a: number

Returns Color4

Properties

a

b

g

r

Methods

add

Returns

Parameters

right: DeepImmutableObject<Color4>

Returns Color4

addInPlace

Returns

Parameters

right: DeepImmutableObject<Color4>

Returns Color4

asArray

Returns

Returns number[]

clampToRef

Returns

Parameters

min: undefined | number

max: undefined | number

result: Color4

Returns Color4

clone

Returns

Returns Color4

copyFrom

Returns

Parameters

source: Color4

Returns Color4

copyFromFloats

Returns

Parameters

r: number

g: number

b: number

a: number

Returns Color4

equals

Returns

Parameters

otherColor: DeepImmutableObject<Color4>

Returns boolean

fromArray

Returns

Parameters

array: DeepImmutableObject<ArrayLike<number>>

Optional offset: number

Returns Color4

getClassName

Returns

Returns string

getHashCode

Returns

Returns number

multiply

Returns

Parameters

color: Color4

Returns Color4

multiplyToRef

Returns

`Optional` r: number

`Optional` g: number

`Optional` b: number

`Optional` a: number

`Optional` offset: number

`Optional` index: number

`Optional` exact: boolean

`Optional` exact: boolean

`Optional` returnAsColor3: boolean