text: /*=========================================================================
  
    Program:   Visualization Toolkit
    Module:    vtkRIBProperty.cxx
  
    Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
    All rights reserved.
    See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
  
       This software is distributed WITHOUT ANY WARRANTY; without even
       the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
       PURPOSE.  See the above copyright notice for more information.
  
  =========================================================================*/
  #include "vtkRIBProperty.h"
  #include "vtkObjectFactory.h"
  
  vtkStandardNewMacro(vtkRIBProperty);
  
  vtkRIBProperty::vtkRIBProperty ()
  {
    this->Declarations = nullptr;
    this->SurfaceShaderParameters = nullptr;
    this->DisplacementShaderParameters = nullptr;
    this->SurfaceShader = new char[strlen("plastic") + 1];
    strcpy (this->SurfaceShader, "plastic");
    this->DisplacementShader = nullptr;
    this->SurfaceShaderUsesDefaultParameters = true;
  
    // create a vtkProperty that can be rendered
    this->Property = vtkProperty::New ();
  }
  
  vtkRIBProperty::~vtkRIBProperty()
  {
    delete [] this->SurfaceShader;
    delete [] this->DisplacementShader;
    delete [] this->Declarations;
  
    if (this->Property)
    {
      this->Property->Delete ();
    }
  
    delete [] this->SurfaceShaderParameters;
    delete [] this->DisplacementShaderParameters;
  }
  
  void vtkRIBProperty::Render(vtkActor *anActor, vtkRenderer *ren)
  {
    int ref;
  
    // Copy this property's ivars into the property to be rendered
    ref = this->Property->GetReferenceCount();
    this->Property->DeepCopy(this);
    this->Property->SetReferenceCount(ref);
  
    // Render the property
    this->Property->Render (anActor, ren);
  }
  
  void vtkRIBProperty::SetVariable (const char *variable, const char *value)
  {
    delete [] this->Declarations;
  
    // format of line is: Declare "variable" "type"\n
    size_t length = strlen ("Declare ") +
                    strlen (variable) +
                    strlen (value) +
                    8;
    this->Declarations = new char [length];
  
    snprintf (this->Declarations, length, "Declare \"%s\" \"%s\"\n", variable, value);
    this->Modified ();
  }
  
  void vtkRIBProperty::AddVariable (const char *variable, const char *value)
  {
    if (this->Declarations == nullptr)
    {
      this->SetVariable (variable, value);
    }
    else
    {
      size_t length = strlen ("Declare ") +
                      strlen (variable) +
                      strlen (value) +
                      8;
      char *newVariable = new char [length];
  
      snprintf (newVariable, length, "Declare \"%s\" \"%s\"\n", variable, value);
      char *oldDeclarations = this->Declarations;
  
      this->Declarations = new char [strlen (oldDeclarations) + strlen (newVariable) + 1];
      strcpy (this->Declarations, oldDeclarations);
      strcat (this->Declarations, newVariable);
      delete [] oldDeclarations;
      delete [] newVariable;
      this->Modified ();
    }
  }
  
  void vtkRIBProperty::SetParameter (const char *parameter, const char *value)
  {
    vtkWarningMacro("vtkRIBProperty::SetParameter is deprecated. Using SetSurfaceShaderParameter instead.");
    this->SetSurfaceShaderParameter(parameter, value);
  }
  
  void vtkRIBProperty::SetSurfaceShaderParameter (const char *parameter, const char *value)
  {
    delete [] this->SurfaceShaderParameters;
  
    // format of line is: "parameter" "value"
    size_t length = strlen (parameter) +
                    strlen (value) +
                    7;
    this->SurfaceShaderParameters = new char [length];
  
    snprintf (this->SurfaceShaderParameters, length, " \"%s\" [%s]", parameter, value);
    this->Modified ();
  }
  
  void vtkRIBProperty::SetDisplacementShaderParameter (const char *parameter, const char *value)
  {
    delete [] this->DisplacementShaderParameters;
  
    // format of line is: "parameter" "value"
    size_t length = strlen (parameter) +
                     strlen (value) +
                     7;
    this->DisplacementShaderParameters = new char [length];
  
    snprintf (this->DisplacementShaderParameters, length, " \"%s\" [%s]", parameter, value);
    this->Modified ();
  }
  
  void vtkRIBProperty::AddParameter (const char *parameter, const char *value)
  {
    vtkWarningMacro("vtkRIBProperty::AddParameter is deprecated. Using AddSurfaceShaderParameter instead.");
    this->AddSurfaceShaderParameter(parameter, value);
  }
  
  void vtkRIBProperty::AddSurfaceShaderParameter (const char *SurfaceShaderParameter, const char *value)
  {
    if (this->SurfaceShaderParameters == nullptr)
    {
      this->SetSurfaceShaderParameter (SurfaceShaderParameter, value);
    }
    else
    {
      size_t length = strlen (SurfaceShaderParameter) +
                      strlen (value) +
                      7;
      char *newSurfaceShaderParameter = new char [length];
  
      snprintf (newSurfaceShaderParameter, length, " \"%s\" [%s]", SurfaceShaderParameter, value);
      char *oldSurfaceShaderParameters = this->SurfaceShaderParameters;
  
      this->SurfaceShaderParameters = new char [strlen (oldSurfaceShaderParameters) + strlen (newSurfaceShaderParameter) + 1];
      strcpy (this->SurfaceShaderParameters, oldSurfaceShaderParameters);
      strcat (this->SurfaceShaderParameters, newSurfaceShaderParameter);
      delete [] oldSurfaceShaderParameters;
      delete [] newSurfaceShaderParameter;
      this->Modified ();
    }
  }
  
  void vtkRIBProperty::AddDisplacementShaderParameter (const char *DisplacementShaderParameter, const char *value)
  {
    if (this->DisplacementShaderParameters == nullptr)
    {
      this->SetDisplacementShaderParameter (DisplacementShaderParameter, value);
    }
    else
    {
      size_t length = strlen (DisplacementShaderParameter) +
                      strlen (value) +
                      7;
      char *newDisplacementShaderParameter = new char [length];
  
      snprintf (newDisplacementShaderParameter, length, " \"%s\" [%s]", DisplacementShaderParameter, value);
      char *oldDisplacementShaderParameters = this->DisplacementShaderParameters;
  
      this->DisplacementShaderParameters = new char [strlen (oldDisplacementShaderParameters) + strlen (newDisplacementShaderParameter) + 1];
      strcpy (this->DisplacementShaderParameters, oldDisplacementShaderParameters);
      strcat (this->DisplacementShaderParameters, newDisplacementShaderParameter);
      delete [] oldDisplacementShaderParameters;
      delete [] newDisplacementShaderParameter;
      this->Modified ();
    }
  }
  
  char *vtkRIBProperty::GetParameters ()
  {
    vtkWarningMacro("vtkRIBProperty::GetParameters is deprecated. Using GetSurfaceShaderParameter instead.");
    return this->GetSurfaceShaderParameters();
  }
  
  char *vtkRIBProperty::GetSurfaceShaderParameters ()
  {
    return this->SurfaceShaderParameters;
  }
  
  char *vtkRIBProperty::GetDisplacementShaderParameters ()
  {
    return this->DisplacementShaderParameters;
  }
  
  char *vtkRIBProperty::GetDeclarations ()
  {
    return this->Declarations;
  }
  
  void vtkRIBProperty::PrintSelf(ostream& os, vtkIndent indent)
  {
    this->Superclass::PrintSelf(os,indent);
  
    if (this->SurfaceShader)
    {
      os << indent << "SurfaceShader: " << this->SurfaceShader << "\n";
    }
    else
    {
      os << indent << "SurfaceShader: (none)\n";
    }
    if (this->DisplacementShader)
    {
      os << indent << "DisplacementShader: " << this->DisplacementShader << "\n";
    }
    else
    {
      os << indent << "DisplacementShader: (none)\n";
    }
    if (this->Declarations)
    {
      os << indent << "Declarations: " << this->Declarations;
    }
    else
    {
      os << indent << "Declarations: (none)\n";
    }
    if (this->SurfaceShaderParameters)
    {
      os << indent << "SurfaceShaderParameters: " << this->SurfaceShaderParameters;
    }
    else
    {
      os << indent << "SurfaceShaderParameters: (none)\n";
    }
    if (this->DisplacementShaderParameters)
    {
      os << indent << "DisplacementShaderParameters: " << this->DisplacementShaderParameters;
    }
    else
    {
      os << indent << "DisplacementShaderParameters: (none)\n";
    }
    os << indent << "SurfaceShaderUsesDefaultParameters: "
       << this->GetSurfaceShaderUsesDefaultParameters() << std::endl;
  }
  
  