CMaterial.h

Go to the documentation of this file.

//==============================================================================
/*
    Software License Agreement (BSD License)
    Copyright (c) 2003-2016, CHAI3D.
    (www.chai3d.org)

    All rights reserved.

    Redistribution and use in source and binary forms, with or without
    modification, are permitted provided that the following conditions
    are met:

    * Redistributions of source code must retain the above copyright
    notice, this list of conditions and the following disclaimer.

    * Redistributions in binary form must reproduce the above
    copyright notice, this list of conditions and the following
    disclaimer in the documentation and/or other materials provided
    with the distribution.

    * Neither the name of CHAI3D nor the names of its contributors may
    be used to endorse or promote products derived from this software
    without specific prior written permission.

    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
    FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
    COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
    INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
    BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
    LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
    LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
    ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
    POSSIBILITY OF SUCH DAMAGE. 

    \author    <http://www.chai3d.org>
    \author    Francois Conti
    \version   3.2.0 $Rev: 1869 $
*/
//==============================================================================

//------------------------------------------------------------------------------
#ifndef CMaterialH
#define CMaterialH
//------------------------------------------------------------------------------
#include "audio/CAudioBuffer.h"
#include "graphics/CColor.h"
#include "graphics/CRenderOptions.h"
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
namespace chai3d {
//------------------------------------------------------------------------------

//==============================================================================
//==============================================================================

//------------------------------------------------------------------------------
struct cMaterial;
typedef std::shared_ptr<cMaterial> cMaterialPtr;
//------------------------------------------------------------------------------

//==============================================================================
//==============================================================================
struct cMaterial
{
    //--------------------------------------------------------------------------
    // CONSTRUCTOR & DESTRUCTOR:
    //--------------------------------------------------------------------------
 
public:

    cMaterial();

    virtual ~cMaterial() {};

    static cMaterialPtr create() { return (std::make_shared<cMaterial>()); }


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - COPY:
    //--------------------------------------------------------------------------

public:

    cMaterialPtr copy();

    void setModificationFlags(const bool a_value);

    void copyTo(cMaterialPtr a_material);


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - GRAPHIC PROPERTIES:
    //--------------------------------------------------------------------------

public:

    void setShininess(const GLuint a_shininess);

    GLuint getShininess() const { return (m_shininess); }

    void setTransparencyLevel(const float a_levelTransparency);

    inline bool isTransparent() const
    {
        return (m_ambient[4] < 1.0 ||
                m_diffuse[4] < 1.0 ||
                m_specular[4] < 1.0 ||
                m_emission[4]);
    }

    inline void backupColors()
    {
        m_ambient.copyTo(m_ambientBackup);
        m_diffuse.copyTo(m_diffuseBackup);
        m_specular.copyTo(m_specularBackup);
        m_emission.copyTo(m_emissionBackup);
    }

    inline void restoreColors()
    {
        m_ambientBackup.copyTo(m_ambient);
        m_diffuseBackup.copyTo(m_diffuse);
        m_specularBackup.copyTo(m_specular);
        m_emissionBackup.copyTo(m_emission);
    }

    virtual void render(cRenderOptions& a_options);


    //--------------------------------------------------------------------------
    // PUBLIC MEMBERS - GRAPHIC PROPERTIES:
    //--------------------------------------------------------------------------

public:

    cColorf m_ambient;

    cColorf m_diffuse;

    cColorf m_specular;

    cColorf m_emission;

    cColorf m_ambientBackup;

    cColorf m_diffuseBackup;

    cColorf m_specularBackup;

    cColorf m_emissionBackup;


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - HAPTIC EFFECTS PROPERTIES:
    //--------------------------------------------------------------------------

public:

    // SURFACE STIFFNESS

    void setStiffness(const double a_stiffness);

    inline double getStiffness() const { return (m_stiffness); }


    // VISCOSITY

    void setViscosity(const double a_viscosity);

    inline double getViscosity() const { return (m_viscosity); }


    // VIBRATION

    void setVibrationFrequency(const double a_vibrationFrequency);

    inline double getVibrationFrequency() const {return (m_vibrationFrequency); }

    void setVibrationAmplitude(const double a_vibrationAmplitude);

    inline double getVibrationAmplitude() const { return (m_vibrationAmplitude); }


    // MAGNET

    void setMagnetMaxForce(const double a_magnetMaxForce);

    inline double getMagnetMaxForce() const { return (m_magnetMaxForce); }

    void setMagnetMaxDistance(const double a_magnetMaxDistance);

    inline double getMagnetMaxDistance() const { return (m_magnetMaxDistance); }


    // STICK AND SLIP

    void setStickSlipForceMax(const double a_stickSlipForceMax);

    inline double getStickSlipForceMax() const { return (m_stickSlipForceMax); }

    void setStickSlipStiffness(double const a_stickSlipStiffness);

    inline double getStickSlipStiffness() const { return (m_stickSlipStiffness); }


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - HAPTIC PROPERTIES (MESH OBJECTS ONLY)
    //--------------------------------------------------------------------------

public:

    // DAMPING

    void setDamping(const double a_dampingCoefficient);

    inline double getDamping() const { return (m_damping); }


    // FRICTION

    void setUseHapticFriction(const bool a_useHapticFriction);

    inline bool getUseHapticFriction() const { return (m_useHapticFriction); }

    void setStaticFriction(const double a_friction);

    inline double getStaticFriction() const { return (m_staticFriction); }

    void setDynamicFriction(const double a_friction);

    inline double getDynamicFriction() const { return (m_dynamicFriction); }


    // TEXTURE

    void setUseHapticTexture(const bool a_useHapticTexture);

    inline bool getUseHapticTexture() const { return (m_useHapticTexture); }

    void setTextureLevel(const double a_textureLevel);

    inline double getTextureLevel() const { return (m_textureLevel); }


    // HAPTIC MODES

    void setUseHapticShading(const bool a_useHapticShading);

    inline bool getUseHapticShading() const { return (m_useHapticShading); }

    void setHapticTriangleFrontSide(const bool a_enabled);

    inline bool getHapticTriangleFrontSide() const { return (m_hapticFrontSideOfTriangles); }

    void setHapticTriangleBackSide(const bool a_enabled);

    inline bool getHapticTriangleBackSide() const { return (m_hapticBackSideOfTriangles); }

    void setHapticTriangleSides(const bool a_enableFrontSide, const bool a_enableBackSide);


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - AUDIO PROPERTIES
    //--------------------------------------------------------------------------

public:

    // AUDIO IMPACT

    void setAudioImpactBuffer(cAudioBuffer* a_audioImpactBuffer);

    inline cAudioBuffer* getAudioImpactBuffer() { return (m_audioImpactBuffer); }

    void setAudioImpactGain(const double a_audioImpactGain);

    inline double getAudioImpactGain() const { return (m_audioImpactGain); }


    // AUDIO FRICTION

    void setAudioFrictionBuffer(cAudioBuffer* a_audioFrictionBuffer);

    inline cAudioBuffer* getAudioFrictionBuffer() { return (m_audioFrictionBuffer); }

    void setAudioFrictionGain(const double a_audioFrictionGain);

    inline double getAudioFrictionGain() const { return (m_audioFrictionGain); }

    void setAudioFrictionPitchGain(const double a_audioFrictionPitchGain);

    inline double getAudioFrictionPitchGain() const { return (m_audioFrictionPitchGain); }

    void setAudioFrictionPitchOffset(const double a_audioFrictionPitchOffset);

    inline double getAudioFrictionPitchOffset() const { return (m_audioFrictionPitchOffset); }


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - COLOR PROPERTIES:
    //--------------------------------------------------------------------------

public:

    void setColor(cColorf& a_color);

    void setColor(cColorb& a_color);

    void setColorf(const GLfloat a_red,
        const GLfloat a_green,
        const GLfloat a_blue,
        const GLfloat a_alpha = 1.0f);


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - RED COLORS
    //--------------------------------------------------------------------------

public:

    inline void setRedIndian()              { m_diffuse.setb(0xCD, 0x5C, 0x5C); updateColors();} 

    inline void setRedLightCoral()          { m_diffuse.setb(0xF0, 0x80, 0x80); updateColors();}

    inline void setRedSalmon()              { m_diffuse.setb(0xFA, 0x80, 0x72); updateColors();}

    inline void setRedDarkSalmon()          { m_diffuse.setb(0xE9, 0x96, 0x7A); updateColors();}

    inline void setRedLightSalmon()         { m_diffuse.setb(0xFF, 0xA0, 0x7A); updateColors();}

    inline void setRedCrimson()             { m_diffuse.setb(0xDC, 0x14, 0x3C); updateColors();}

    inline void setRed()                    { m_diffuse.setb(0xFF, 0x00, 0x00); updateColors();}

    inline void setRedFireBrick()           { m_diffuse.setb(0xB2, 0x22, 0x22); updateColors();}

    inline void setRedDark()                { m_diffuse.setb(0x8B, 0x00, 0x00); updateColors();}

    
    //--------------------------------------------------------------------------
    // PUBLIC METHODS - PINK COLORS
    //--------------------------------------------------------------------------

    inline void setPink()                   { m_diffuse.setb(0xFF, 0xC0, 0xCB); updateColors();}

    inline void setPinkLight()              { m_diffuse.setb(0xFF, 0xB6, 0xC); updateColors();}

    inline void setPinkHot()                { m_diffuse.setb(0xFF, 0x69, 0xB4); updateColors();}

    inline void setPinkDeep()               { m_diffuse.setb(0xFF, 0x14, 0x93); updateColors();}

    inline void setPinkMediumVioletRed()    { m_diffuse.setb(0xC7, 0x15, 0x85); updateColors();}

    inline void setPinkPaleVioletRed()      { m_diffuse.setb(0xDB, 0x70, 0x93); updateColors();}


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - ORANGE COLORS
    //--------------------------------------------------------------------------

    inline void setOrangeLightSalmon()      { m_diffuse.setb(0xFF, 0xA0, 0x7A); updateColors();}

    inline void setOrangeCoral()            { m_diffuse.setb(0xFF, 0x7F, 0x50); updateColors();}

    inline void setOrangeTomato()           { m_diffuse.setb(0xFF, 0x63, 0x47); updateColors();}

    inline void setOrangeRed()              { m_diffuse.setb(0xFF, 0x45, 0x00); updateColors();}

    inline void setOrangeDark()             { m_diffuse.setb(0xFF, 0x8C, 0x00); updateColors();}

    inline void setOrange()                 { m_diffuse.setb(0xFF, 0xA5, 0x00); updateColors();}


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - YELLOW COLORS
    //--------------------------------------------------------------------------

    inline void setYellowGold()             { m_diffuse.setb(0xFF, 0xD7, 0x00); updateColors();}

    inline void setYellow()                 { m_diffuse.setb(0xFF, 0xFF, 0x00); updateColors();}

    inline void setYellowLight()            { m_diffuse.setb(0xFF, 0xFF, 0xE0); updateColors();}

    inline void setYellowLemonChiffon()     { m_diffuse.setb(0xFF, 0xFA, 0xCD); updateColors();}

    inline void setYellowLightGoldenrod()   { m_diffuse.setb(0xFA, 0xFA, 0xD); updateColors();}

    inline void setYellowPapayaWhip()       { m_diffuse.setb(0xFF, 0xEF, 0xD5); updateColors();}

    inline void setYellowMoccasin()         { m_diffuse.setb(0xFF, 0xE4, 0xB5); updateColors();}

    inline void setYellowPeachPuff()        { m_diffuse.setb(0xFF, 0xDA, 0xB9); updateColors();}

    inline void setYellowPaleGoldenrod()    { m_diffuse.setb(0xEE, 0xE8, 0xAA); updateColors();}

    inline void setYellowKhaki()            { m_diffuse.setb(0xF0, 0xE6, 0x8C); updateColors();}

    inline void setYellowDarkKhaki()        { m_diffuse.setb(0xBD, 0xB7, 0x6B); updateColors();}


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - PURPLE COLORS
    //--------------------------------------------------------------------------

    inline void setPurpleLavender()         { m_diffuse.setb(0xE6, 0xE6, 0xFA); updateColors();}

    inline void setPurpleThistle()          { m_diffuse.setb(0xD8, 0xBF, 0xD8); updateColors();}

    inline void setPurplePlum()             { m_diffuse.setb(0xDD, 0xA0, 0xDD); updateColors();}

    inline void setPurpleViolet()           { m_diffuse.setb(0xEE, 0x82, 0xEE); updateColors();}

    inline void setPurpleOrchid()           { m_diffuse.setb(0xDA, 0x70, 0xD6); updateColors();}

    inline void setPurpleFuchsia()          { m_diffuse.setb(0xFF, 0x00, 0xFF); updateColors();}

    inline void setPurpleMagenta()          { m_diffuse.setb(0xFF, 0x00, 0xFF); updateColors();}

    inline void setPurpleMediumOrchid()     { m_diffuse.setb(0xBA, 0x55, 0xD3); updateColors();}

    inline void setPurpleMedium()           { m_diffuse.setb(0x93, 0x70, 0xDB); updateColors();}

    inline void setPurpleAmethyst()         { m_diffuse.setb(0x99, 0x66, 0xCC); updateColors();}

    inline void setPurpleBlueViolet()       { m_diffuse.setb(0x8A, 0x2B, 0xE2); updateColors();}

    inline void setPurpleDarkViolet()       { m_diffuse.setb(0x94, 0x00, 0xD3); updateColors();}

    inline void setPurpleDarkOrchid()       { m_diffuse.setb(0x99, 0x32, 0xCC); updateColors();}

    inline void setPurpleDarkMagenta()      { m_diffuse.setb(0x8B, 0x00, 0x8B); updateColors();}

    inline void setPurple()                 { m_diffuse.setb(0x80, 0x00, 0x80); updateColors();}

    inline void setPurpleIndigo()           { m_diffuse.setb(0x4B, 0x00, 0x82); updateColors();}

    inline void setPurpleSlateBlue()        { m_diffuse.setb(0x6A, 0x5A, 0xCD); updateColors();}

    inline void setPurpleDarkSlateBlue()    { m_diffuse.setb(0x48, 0x3D, 0x8B); updateColors();}

    inline void setPurpleMediumSlateBlue()  { m_diffuse.setb(0x7B, 0x68, 0xEE); updateColors();}


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - GREEN COLORS
    //--------------------------------------------------------------------------

    inline void setGreenYellow()            { m_diffuse.setb(0xAD, 0xFF, 0x2F); updateColors();}

    inline void setGreenChartreuse()        { m_diffuse.setb(0x7F, 0xFF, 0x00); updateColors();}

    inline void setGreenLawn()              { m_diffuse.setb(0x7C, 0xFC, 0x00); updateColors();}

    inline void setGreenLime()              { m_diffuse.setb(0x00, 0xFF, 0x00); updateColors();}

    inline void setGreenLimeGreen()         { m_diffuse.setb(0x32, 0xCD, 0x32); updateColors();}

    inline void setGreenPale()              { m_diffuse.setb(0x98, 0xFB, 0x98); updateColors();}

    inline void setGreenLight()             { m_diffuse.setb(0x90, 0xEE, 0x90); updateColors();}

    inline void setGreenMediumSpring()      { m_diffuse.setb(0x00, 0xFA, 0x9A); updateColors();}

    inline void setGreenSpring()            { m_diffuse.setb(0x00, 0xFF, 0x7F); updateColors();}

    inline void setGreenMediumSea()         { m_diffuse.setb(0x3C, 0xB3, 0x71); updateColors();}

    inline void setGreenSea()               { m_diffuse.setb(0x2E, 0x8B, 0x57); updateColors();}

    inline void setGreenForest()            { m_diffuse.setb(0x22, 0x8B, 0x22); updateColors();}

    inline void setGreen()                  { m_diffuse.setb(0x00, 0x80, 0x00); updateColors();}

    inline void setGreenDark()              { m_diffuse.setb(0x00, 0x64, 0x00); updateColors();}

    inline void setGreenYellowGreen()       { m_diffuse.setb(0x9A, 0xCD, 0x32); updateColors();}

    inline void setGreenOliveDrab()         { m_diffuse.setb(0x6B, 0x8E, 0x23); updateColors();}

    inline void setGreenOlive()             { m_diffuse.setb(0x80, 0x80, 0x00); updateColors();}

    inline void setGreenDarkOlive()         { m_diffuse.setb(0x55, 0x6B, 0x2F); updateColors();}

    inline void setGreenMediumAquamarine()  { m_diffuse.setb(0x66, 0xCD, 0xAA); updateColors();}

    inline void setGreenDarkSea()           { m_diffuse.setb(0x8F, 0xBC, 0x8F); updateColors();}

    inline void setGreenLightSea()          { m_diffuse.setb(0x20, 0xB2, 0xAA); updateColors();}

    inline void setGreenDarkCyan()          { m_diffuse.setb(0x00, 0x8B, 0x8B); updateColors();}

    inline void setGreenTeal()              { m_diffuse.setb(0x00, 0x80, 0x80); updateColors();}


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - BLUE COLORS
    //--------------------------------------------------------------------------

    inline void setBlueAqua()               { m_diffuse.setb(0x00, 0xFF, 0xFF); updateColors();}

    inline void setBlueCyan()               { m_diffuse.setb(0x00, 0xFF, 0xFF); updateColors();}

    inline void setBlueLightCyan()          { m_diffuse.setb(0xE0, 0xFF, 0xFF); updateColors();}

    inline void setBluePaleTurquoise()      { m_diffuse.setb(0xAF, 0xEE, 0xEE); updateColors();}

    inline void setBlueAquamarine()         { m_diffuse.setb(0x7F, 0xFF, 0xD4); updateColors();}

    inline void setBlueTurquoise()          { m_diffuse.setb(0x40, 0xE0, 0xD0); updateColors();}

    inline void setBlueMediumTurquoise()    { m_diffuse.setb(0x48, 0xD1, 0xCC); updateColors();}

    inline void setBlueDarkTurquoise()      { m_diffuse.setb(0x00, 0xCE, 0xD1); updateColors();}

    inline void setBlueCadet()              { m_diffuse.setb(0x5F, 0x9E, 0xA0); updateColors();}

    inline void setBlueSteel()              { m_diffuse.setb(0x46, 0x82, 0xB4); updateColors();}

    inline void setBlueLightSteel()         { m_diffuse.setb(0xB0, 0xC4, 0xDE); updateColors();}

    inline void setBluePowder()             { m_diffuse.setb(0xB0, 0xE0, 0xE6); updateColors();}

    inline void setBlueLight()              { m_diffuse.setb(0xAD, 0xD8, 0xE6); updateColors();}

    inline void setBlueSky()                { m_diffuse.setb(0x87, 0xCE, 0xEB); updateColors();}

    inline void setBlueLightSky()           { m_diffuse.setb(0x87, 0xCE, 0xFA); updateColors();}

    inline void setBlueDeepSky()            { m_diffuse.setb(0x00, 0xBF, 0xFF); updateColors();}

    inline void setBlueDodger()             { m_diffuse.setb(0x1E, 0x90, 0xFF); updateColors();}

    inline void setBlueCornflower()         { m_diffuse.setb(0x64, 0x95, 0xED); updateColors();}

    inline void setBlueMediumSlate()        { m_diffuse.setb(0x7B, 0x68, 0xEE); updateColors();}

    inline void setBlueRoyal()              { m_diffuse.setb(0x41, 0x69, 0xE1); updateColors();}

    inline void setBlue()                   { m_diffuse.setb(0x00, 0x00, 0xFF); updateColors();}

    inline void setBlueMedium()             { m_diffuse.setb(0x00, 0x00, 0xCD); updateColors();}

    inline void setBlueDark()               { m_diffuse.setb(0x00, 0x00, 0x8B); updateColors();}

    inline void setBlueNavy()               { m_diffuse.setb(0x00, 0x00, 0x80); updateColors();}

    inline void setBlueMidnight()           { m_diffuse.setb(0x19, 0x19, 0x70); updateColors();}


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - BROWN COLORS
    //--------------------------------------------------------------------------

    inline void setBrownCornsilk()          { m_diffuse.setb(0xFF, 0xF8, 0xDC); updateColors();}

    inline void setBrownBlanchedAlmond()    { m_diffuse.setb(0xFF, 0xEB, 0xCD); updateColors();}

    inline void setBrownBisque()            { m_diffuse.setb(0xFF, 0xE4, 0xC4); updateColors();}

    inline void setBrownNavajoWhite()       { m_diffuse.setb(0xFF, 0xDE, 0xAD); updateColors();}

    inline void setBrownWheat()             { m_diffuse.setb(0xF5, 0xDE, 0xB3); updateColors();}

    inline void setBrownBurlyWood()         { m_diffuse.setb(0xDE, 0xB8, 0x87); updateColors();}

    inline void setBrownTan()               { m_diffuse.setb(0xD2, 0xB4, 0x8C); updateColors();}

    inline void setBrownRosy()              { m_diffuse.setb(0xBC, 0x8F, 0x8F); updateColors();}

    inline void setBrownSandy()             { m_diffuse.setb(0xF4, 0xA4, 0x60); updateColors();}

    inline void setBrownGoldenrod()         { m_diffuse.setb(0xDA, 0xA5, 0x20); updateColors();}

    inline void setBrownDarkGoldenrod()     { m_diffuse.setb(0xB8, 0x86, 0x0B); updateColors();}

    inline void setBrownPeru()              { m_diffuse.setb(0xCD, 0x85, 0x3F); updateColors();}

    inline void setBrownChocolate()         { m_diffuse.setb(0xD2, 0x69, 0x1E); updateColors();}

    inline void setBrownSaddle()            { m_diffuse.setb(0x8B, 0x45, 0x13); updateColors();}

    inline void setBrownSienna()            { m_diffuse.setb(0xA0, 0x52, 0x2D); updateColors();}

    inline void setBrown()                  { m_diffuse.setb(0xA5, 0x2A, 0x2A); updateColors();}

    inline void setBrownMaroon()            { m_diffuse.setb(0x80, 0x00, 0x00); updateColors();}


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - WHITE COLORS
    //--------------------------------------------------------------------------

    inline void setWhite()                  { m_diffuse.setb(0xFF, 0xFF, 0xFF); updateColors();}

    inline void setWhiteSnow()              { m_diffuse.setb(0xFF, 0xFA, 0xFA); updateColors();}

    inline void setWhiteHoneydew()          { m_diffuse.setb(0xF0, 0xFF, 0xF0); updateColors();}

    inline void setWhiteMintCream()         { m_diffuse.setb(0xF5, 0xFF, 0xFA); updateColors();}

    inline void setWhiteAzure()             { m_diffuse.setb(0xF0, 0xFF, 0xFF); updateColors();}

    inline void setWhiteAliceBlue()         { m_diffuse.setb(0xF0, 0xF8, 0xFF); updateColors();}

    inline void setWhiteGhost()             { m_diffuse.setb(0xF8, 0xF8, 0xFF); updateColors();}

    inline void setWhiteSmoke()             { m_diffuse.setb(0xF5, 0xF5, 0xF5); updateColors();}

    inline void setWhiteSeashell()          { m_diffuse.setb(0xFF, 0xF5, 0xEE); updateColors();}

    inline void setWhiteBeige()             { m_diffuse.setb(0xF5, 0xF5, 0xDC); updateColors();}

    inline void setWhiteOldLace()           { m_diffuse.setb(0xFD, 0xF5, 0xE6); updateColors();}

    inline void setWhiteFloral()            { m_diffuse.setb(0xFF, 0xFA, 0xF0); updateColors();}

    inline void setWhiteIvory()             { m_diffuse.setb(0xFF, 0xFF, 0xF0); updateColors();}

    inline void setWhiteAntique()           { m_diffuse.setb(0xFA, 0xEB, 0xD7); updateColors();}

    inline void setWhiteLinen()             { m_diffuse.setb(0xFA, 0xF0, 0xE6); updateColors();}

    inline void setWhiteLavenderBlush()     { m_diffuse.setb(0xFF, 0xF0, 0xF5); updateColors();}

    inline void setWhiteMistyRose()         { m_diffuse.setb(0xFF, 0xE4, 0xE1); updateColors();}


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - GRAY COLORS
    //--------------------------------------------------------------------------

    inline void setGrayGainsboro()          { m_diffuse.setb(0xDC, 0xDC, 0xDC); updateColors();}

    inline void setGrayLight()              { m_diffuse.setb(0xD3, 0xD3, 0xD3); updateColors();}

    inline void setGraySilver()             { m_diffuse.setb(0xC0, 0xC0, 0xC0); updateColors();}

    inline void setGrayDark()               { m_diffuse.setb(0xA9, 0xA9, 0xA9); updateColors();}

    inline void setGray()                   { m_diffuse.setb(0x80, 0x80, 0x80); updateColors();}

    inline void setGrayDim()                { m_diffuse.setb(0x69, 0x69, 0x69); updateColors();}

    inline void setGrayLightSlate()         { m_diffuse.setb(0x77, 0x88, 0x99); updateColors();}

    inline void setGraySlate()              { m_diffuse.setb(0x70, 0x80, 0x90); updateColors();}

    inline void setGrayDarkSlate()          { m_diffuse.setb(0x2F, 0x4F, 0x4F); updateColors();}

    inline void setBlack()                  { m_diffuse.setb(0x00, 0x00, 0x00); updateColors();}


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - CUSTOM GRAY COLOR
    //--------------------------------------------------------------------------

public:

    // This method sets a custom gray level.
    inline void setGrayLevel(const GLfloat a_level) { m_diffuse.set(a_level, a_level, a_level); updateColors(); }


    //--------------------------------------------------------------------------
    // PROTECTED METHODS - GRAPHICS:
    //--------------------------------------------------------------------------
    
protected:

    void updateColors();


    //--------------------------------------------------------------------------
    // PROTECTED MEMBERS - GRAPHICS PROPERTIES:
    //--------------------------------------------------------------------------

protected:

    GLuint m_shininess;

    bool m_flag_shininess;


    //--------------------------------------------------------------------------
    // PROTECTED MEMBERS - HAPTIC PROPERTIES:
    //--------------------------------------------------------------------------

protected:

    // SURFACE STIFFNESS

    double m_stiffness;

    bool m_flag_stiffness;


    // DAMPING

    // Damping level.
    double m_damping;

    bool m_flag_damping;


    // VISCOSITY

    double m_viscosity;

    bool m_flag_viscosity;


    // FRICTION

    double m_staticFriction;

    bool m_flag_staticFriction;

    double m_dynamicFriction;

    bool m_flag_dynamicFriction;


    // TEXTURE

    double m_textureLevel;

    bool m_flag_textureLevel;


    // VIBRATION

    double m_vibrationFrequency;

    bool m_flag_vibrationFrequency;

    double m_vibrationAmplitude;

    bool m_flag_vibrationAmplitude;
    

    // MAGNET

    double m_magnetMaxForce;

    bool m_flag_magnetMaxForce;

    double m_magnetMaxDistance;

    bool m_flag_magnetMaxDistance;
    

    // STICK AND SLIP

    double m_stickSlipForceMax;

    bool m_flag_stickSlipForceMax;

    double m_stickSlipStiffness;

    bool m_flag_stickSlipStiffness;


    // HAPTIC MODES

    bool m_useHapticFriction;

    bool m_flag_useHapticFriction;

    bool m_useHapticTexture;

    bool m_flag_useHapticTexture;

    bool m_useHapticShading;

    bool m_flag_useHapticShading;

    bool m_hapticFrontSideOfTriangles;

    bool m_flag_hapticFrontSideOfTriangles;

    bool m_hapticBackSideOfTriangles;

    bool m_flag_hapticBackSideOfTriangles;


    // SOUND PROPERTIES

    cAudioBuffer* m_audioImpactBuffer;

    bool m_flag_audioImpactBuffer;

    cAudioBuffer* m_audioFrictionBuffer;

    bool m_flag_audioFrictionBuffer;

    double m_audioImpactGain;

    bool m_flag_audioImpactGain;

    double m_audioFrictionGain;

    bool m_flag_audioFrictionGain;

    double m_audioFrictionPitchGain;

    bool m_flag_audioFrictionPitchGain;

    double m_audioFrictionPitchOffset;

    bool m_flag_audioFrictionPitchOffset;
};

//------------------------------------------------------------------------------
} // namespace chai3d
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
#endif
//------------------------------------------------------------------------------