SbColor4f Class Reference
Base Classes

The SbColor4f class contains the red, green, blue and alpha components which make up a color value. More...

`#include <Inventor/SbColor4f.h>`

Inheritance diagram for SbColor4f:

## Public Member Functions

| SbColor4f (void)
| SbColor4f (const SbColor &rgb, const float alpha=1.0f)
| SbColor4f (const SbVec4f &v)
| SbColor4f (const float *const rgba)
| SbColor4f (const float r, const float g, const float b, const float a=1.0f)
void | setValue (const float r, const float g, const float b, const float a=1.0f)
void | setValue (const float col[4])
const float * | getValue () const
void | getValue (float &r, float &g, float &b, float &a)
SbColor4f & | setRGB (const SbColor &col)
void | getRGB (SbColor &color)
SbColor4f & | setHSVValue (float h, float s, float v, float a=1.0f)
SbColor4f & | setHSVValue (const float hsv[3], float alpha=1.0f)
void | getHSVValue (float &h, float &s, float &v) const
void | getHSVValue (float hsv[3]) const
SbColor4f & | setPackedValue (const uint32_t rgba)
uint32_t | getPackedValue () const
float | operator[] (const int idx) const
float & | operator[] (const int idx)
SbColor4f & | operator*= (const float d)
SbColor4f & | operator/= (const float d)
SbColor4f & | operator+= (const SbColor4f &c)
SbColor4f & | operator-= (const SbColor4f &c)
Public Member Functions inherited from SbVec4f
| SbVec4f (void)
| SbVec4f (const float v[4])
| SbVec4f (float x, float y, float z, float w)
| SbVec4f (const SbVec4d &v)
| SbVec4f (const SbVec4b &v)
| SbVec4f (const SbVec4s &v)
| SbVec4f (const SbVec4i32 &v)
SbVec4f & | setValue (const float v[4])
SbVec4f & | setValue (float x, float y, float z, float w)
SbVec4f & | setValue (const SbVec4d &v)
SbVec4f & | setValue (const SbVec4b &v)
SbVec4f & | setValue (const SbVec4s &v)
SbVec4f & | setValue (const SbVec4i32 &v)
const float * | getValue (void) const
void | getValue (float &x, float &y, float &z, float &w) const
float & | operator[] (int i)
const float & | operator[] (int i) const
SbBool | equals (const SbVec4f &v, float tolerance) const
float | dot (const SbVec4f &v) const
void | getReal (SbVec3f &v) const
float | length (void) const
float | sqrLength (void) const
void | negate (void)
float | normalize (void)
SbVec4f & | operator*= (float d)
SbVec4f & | operator/= (float d)
SbVec4f & | operator+= (const SbVec4f &v)
SbVec4f & | operator-= (const SbVec4f &v)
SbVec4f | operator- (void) const
void | print (FILE *fp) const

## Additional Inherited Members

Protected Attributes inherited from SbVec4f
float | vec [4]
Related Symbols inherited from SbVec4f
SbVec4f | operator* (const SbVec4f &v, float d)
SbVec4f | operator* (float d, const SbVec4f &v)
SbVec4f | operator/ (const SbVec4f &v, float d)
SbVec4f | operator+ (const SbVec4f &v1, const SbVec4f &v2)
SbVec4f | operator- (const SbVec4f &v1, const SbVec4f &v2)
int | operator== (const SbVec4f &v1, const SbVec4f &v2)
int | operator!= (const SbVec4f &v1, const SbVec4f &v2)

## Detailed Description

The SbColor4f class contains the red, green, blue and alpha components which make up a color value.

This class is used internally within other classes in Coin. It contains a 4 component vector as a position in the RGB cube with an additional transparency value.

The red, green and blue values should be between 0.0 and 1.0, where 0.0 is interpreted as minimum intensity, and 1.0 is maximum intensity. The transparency value is also between 0.0 and 1.0.

SbColor4f contains methods for convenient handling of setting and getting color values as 32 bit packed values or as HSV values.

Note: this class is not part of Open Inventor, but is an extension to the API. Don't use it if you want your code to be compatible with Open Inventor.

See also
  SbColor

## Constructor & Destructor Documentation

## SbColor4f() [1/5]

SbColor4f::SbColor4f | ( | void |  | ) |

Default constructor. The color value will be uninitialized until explicitly set.

## SbColor4f() [2/5]

SbColor4f::SbColor4f | ( | const SbColor & | rgb,
|  | const float | alpha = 1.0f )

Construct and initialize an SbColor4f with the red, green and blue components from the SbColor `rgb`, and the alpha value from the supplied `alpha` argument.

## SbColor4f() [3/5]

SbColor4f::SbColor4f | ( | const SbVec4f & | v | ) |

Construct and initialize an SbColor4f with the red, green, blue and alpha values given by the `v` vector.

## SbColor4f() [4/5]

SbColor4f::SbColor4f | ( | const float *const | rgba | ) |

Construct and initialize an SbColor4f with the red, green, blue and alpha taken from given `rgba` array

## SbColor4f() [5/5]

SbColor4f::SbColor4f | ( | const float | r,
|  | const float | g,
|  | const float | b,
|  | const float | a = 1.0f )

Construct and initialize an SbColor4f with the given red, green, blue and alpha values.

## Member Function Documentation

## setValue() [1/2]

void SbColor4f::setValue | ( | const float | r,
|  | const float | g,
|  | const float | b,
|  | const float | a = 1.0f )

Set a new color.

## setValue() [2/2]

void SbColor4f::setValue | ( | const float | col[4] | ) |

Set a new color. The elements of the array will be read in turned as red, green, blue and transparency.

## getValue() [1/2]

const float * SbColor4f::getValue | ( | void |  | ) | const

Return pointer to array of 4 float values representing the red, green, blue and transparency values of the color.

## getValue() [2/2]

void SbColor4f::getValue | ( | float & | r,
|  | float & | g,
|  | float & | b,
|  | float & | a )

Return components of the stored color.

## setRGB()

SbColor4f & SbColor4f::setRGB | ( | const SbColor & | col | ) |

Sets the RGB components of the color. The alpha component is left unchanged.

## getRGB()

void SbColor4f::getRGB | ( | SbColor & | color | ) |

Returns the RGB components of this color.

## setHSVValue() [1/2]

SbColor4f & SbColor4f::setHSVValue | ( | float | hue,
|  | float | saturation,
|  | float | value,
|  | float | alpha = 1.0f )

Set the color as a `hue`, `saturation`, `value` triplet. The hue component should be normalized to within [0, 1] before you call this method, where a value of 0 corresponds to 0 degrees and a value of 1 corresponds to 360 degrees.

See also
  getHSVValue().

## setHSVValue() [2/2]

SbColor4f & SbColor4f::setHSVValue | ( | const float | hsv[3],
|  | float | a = 1.0f )

Set the color as a `hue`, `saturation`, `value` triplet. The hue component should be normalized to within [0, 1] before you call this method, where a value of 0 corresponds to 0 degrees and a value of 1 corresponds to 360 degrees.

See also
  getHSVValue().

## getHSVValue() [1/2]

void SbColor4f::getHSVValue | ( | float & | h,
|  | float & | s,
|  | float & | v ) const

Return the color as a `hue`, `saturation`, `value` triplet. Alpha component is ignored.

See also
  setHSVValue().

## getHSVValue() [2/2]

void SbColor4f::getHSVValue | ( | float | hsv[3] | ) | const

Return the color as a `hue`, `saturation`, `value` triplet. Alpha component is ignored.

See also
  setHSVValue().

## setPackedValue()

SbColor4f & SbColor4f::setPackedValue | ( | const uint32_t | rgba | ) |

Set the color value as a 32 bit combined red/green/blue/alpha value. Each component is 8 bit wide (i.e. from 0x00 to 0xff), and the red value should be stored leftmost, like this: 0xRRGGBBAA.

See also
  getPackedValue().

## getPackedValue()

uint32_t SbColor4f::getPackedValue | ( |  | ) | const

Return color as a 32 bit packed integer in the form 0xRRGGBBAA.

See also
  setPackedValue().

## operator[]() [1/2]

float SbColor4f::operator[] | ( | const int | idx | ) | const

Returns the color component represented by the given index idx. 0 is red, 1 is green, 2 is blue and 3 is the transparency value.

## operator[]() [2/2]

float & SbColor4f::operator[] | ( | const int | idx | ) |

Returns the color component represented by the given index idx. 0 is red, 1 is green, 2 is blue and 3 is the transparency value.

## operator*=()

SbColor4f & SbColor4f::operator*= | ( | const float | d | ) |

Multiplies the RGB components by `d`. The alpha component is left unchanged.

## operator/=()

SbColor4f & SbColor4f::operator/= | ( | const float | d | ) |

Divides the RGB components by `d`. The alpha component is left unchanged.

## operator+=()

SbColor4f & SbColor4f::operator+= | ( | const SbColor4f & | c | ) |

Adds the RGB components. Alpha is ignored.

## operator-=()

SbColor4f & SbColor4f::operator-= | ( | const SbColor4f & | c | ) |

Subtracts the RGB components. Alpha is ignored.

The documentation for this class was generated from the following files:

- SbColor4f.h
- SbColor4f.cpp