FrsMaterial.h

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2023 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
 
#pragma once

 
#include "../system/FreestyleConfig.h"
 
#include "MEM_guardedalloc.h"
 
namespace Freestyle {

class FrsMaterial {
 public:
  inline FrsMaterial();

  inline FrsMaterial(const float *iLine,
                     const float *iDiffuse,
                     const float *iAmbiant,
                     const float *iSpecular,
                     const float *iEmission,
                     float iShininess,
                     int iPriority);

  inline FrsMaterial(const FrsMaterial &m);

  virtual ~FrsMaterial() {}

  inline const float *line() const
  {
    return Line;
  }

  inline float lineR() const
  {
    return Line[0];
  }

  inline float lineG() const
  {
    return Line[1];
  }

  inline float lineB() const
  {
    return Line[2];
  }

  inline float lineA() const
  {
    return Line[3];
  }

  inline const float *diffuse() const
  {
    return Diffuse;
  }

  inline float diffuseR() const
  {
    return Diffuse[0];
  }

  inline float diffuseG() const
  {
    return Diffuse[1];
  }

  inline float diffuseB() const
  {
    return Diffuse[2];
  }

  inline float diffuseA() const
  {
    return Diffuse[3];
  }

  inline const float *specular() const
  {
    return Specular;
  }

  inline float specularR() const
  {
    return Specular[0];
  }

  inline float specularG() const
  {
    return Specular[1];
  }

  inline float specularB() const
  {
    return Specular[2];
  }

  inline float specularA() const
  {
    return Specular[3];
  }

  inline const float *ambient() const
  {
    return Ambient;
  }

  inline float ambientR() const
  {
    return Ambient[0];
  }

  inline float ambientG() const
  {
    return Ambient[1];
  }

  inline float ambientB() const
  {
    return Ambient[2];
  }

  inline float ambientA() const
  {
    return Ambient[3];
  }

  inline const float *emission() const
  {
    return Emission;
  }

  inline float emissionR() const
  {
    return Emission[0];
  }

  inline float emissionG() const
  {
    return Emission[1];
  }

  inline float emissionB() const
  {
    return Emission[2];
  }

  inline float emissionA() const
  {
    return Emission[3];
  }

  inline float shininess() const
  {
    return Shininess;
  }

  inline int priority() const
  {
    return Priority;
  }

  inline void setLine(float r, float g, float b, float a);

  inline void setDiffuse(float r, float g, float b, float a);

  inline void setSpecular(float r, float g, float b, float a);

  inline void setAmbient(float r, float g, float b, float a);

  inline void setEmission(float r, float g, float b, float a);

  inline void setShininess(float s);

  inline void setPriority(int priority);
 
  /* operators */
  inline FrsMaterial &operator=(const FrsMaterial &m);
  inline bool operator!=(const FrsMaterial &m) const;
  inline bool operator==(const FrsMaterial &m) const;
 
 private:
  float Line[4];
  float Diffuse[4];
  float Specular[4];
  float Ambient[4];
  float Emission[4];
  float Shininess;
  int Priority;
 
  MEM_CXX_CLASS_ALLOC_FUNCS("Freestyle:FrsMaterial")
};
 
FrsMaterial::FrsMaterial()
{
  Line[0] = Line[1] = Line[2] = 0.0f;
  Line[3] = 1.0f;
 
  Ambient[0] = Ambient[1] = Ambient[2] = 0.2f;
  Ambient[3] = 1.0f;
 
  Diffuse[0] = Diffuse[1] = Diffuse[2] = 0.8f;
  Diffuse[3] = 1.0f;
 
  Emission[0] = Emission[1] = Emission[2] = 0.0f;
  Emission[3] = 1.0f;
 
  Specular[0] = Specular[1] = Specular[2] = 0.0f;
  Specular[3] = 1.0f;
 
  Shininess = 0.0f;
  Priority = 0;
}
 
FrsMaterial::FrsMaterial(const float *iLine,
                         const float *iDiffuse,
                         const float *iAmbiant,
                         const float *iSpecular,
                         const float *iEmission,
                         const float iShininess,
                         const int iPriority)
{
  for (int i = 0; i < 4; i++) {
    Line[i] = iLine[i];
    Diffuse[i] = iDiffuse[i];
    Specular[i] = iSpecular[i];
    Ambient[i] = iAmbiant[i];
    Emission[i] = iEmission[i];
  }
 
  Shininess = iShininess;
  Priority = iPriority;
}
 
FrsMaterial::FrsMaterial(const FrsMaterial &m)
{
  for (int i = 0; i < 4; i++) {
    Line[i] = m.line()[i];
    Diffuse[i] = m.diffuse()[i];
    Specular[i] = m.specular()[i];
    Ambient[i] = m.ambient()[i];
    Emission[i] = m.emission()[i];
  }
 
  Shininess = m.shininess();
  Priority = m.priority();
}
 
void FrsMaterial::setLine(const float r, const float g, const float b, const float a)
{
  Line[0] = r;
  Line[1] = g;
  Line[2] = b;
  Line[3] = a;
}
 
void FrsMaterial::setDiffuse(const float r, const float g, const float b, const float a)
{
  Diffuse[0] = r;
  Diffuse[1] = g;
  Diffuse[2] = b;
  Diffuse[3] = a;
}
 
void FrsMaterial::setSpecular(const float r, const float g, const float b, const float a)
{
  Specular[0] = r;
  Specular[1] = g;
  Specular[2] = b;
  Specular[3] = a;
}
 
void FrsMaterial::setAmbient(const float r, const float g, const float b, const float a)
{
  Ambient[0] = r;
  Ambient[1] = g;
  Ambient[2] = b;
  Ambient[3] = a;
}
 
void FrsMaterial::setEmission(const float r, const float g, const float b, const float a)
{
  Emission[0] = r;
  Emission[1] = g;
  Emission[2] = b;
  Emission[3] = a;
}
 
void FrsMaterial::setShininess(const float s)
{
  Shininess = s;
}
 
void FrsMaterial::setPriority(const int priority)
{
  Priority = priority;
}
 
FrsMaterial &FrsMaterial::operator=(const FrsMaterial &m)
{
  for (int i = 0; i < 4; i++) {
    Line[i] = m.line()[i];
    Diffuse[i] = m.diffuse()[i];
    Specular[i] = m.specular()[i];
    Ambient[i] = m.ambient()[i];
    Emission[i] = m.emission()[i];
  }
 
  Shininess = m.shininess();
  Priority = m.priority();
  return *this;
}
 
bool FrsMaterial::operator!=(const FrsMaterial &m) const
{
  if (Shininess != m.shininess()) {
    return true;
  }
  if (Priority != m.priority()) {
    return true;
  }
 
  for (int i = 0; i < 4; i++) {
    if (Line[i] != m.line()[i]) {
      return true;
    }
    if (Diffuse[i] != m.diffuse()[i]) {
      return true;
    }
    if (Specular[i] != m.specular()[i]) {
      return true;
    }
    if (Ambient[i] != m.ambient()[i]) {
      return true;
    }
    if (Emission[i] != m.emission()[i]) {
      return true;
    }
  }
 
  return false;
}
 
bool FrsMaterial::operator==(const FrsMaterial &m) const
{
  return (!((*this) != m));
}
 
} /* namespace Freestyle */