Public API Reference

csgfx/shadervar.h

Go to the documentation of this file.

/*
    Copyright (C) 2003 by Mat Sutcliffe <[email protected]>
                          Marten Svanfeldt

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the Free
    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#ifndef __CS_GFX_SHADERVAR_H__
#define __CS_GFX_SHADERVAR_H__

#include "csextern.h"

#include "csgeom/transfrm.h"
#include "csgeom/vector2.h"
#include "csgeom/vector3.h"
#include "csgeom/vector4.h"
#include "csgfx/rgbpixel.h"
#include "csutil/cscolor.h"
#include "csutil/leakguard.h"
#include "csutil/refarr.h"
#include "csutil/refcount.h"
#include "csutil/strset.h"

#include "iengine/texture.h"
#include "ivideo/texture.h"
#include "ivideo/rndbuf.h"

struct iTextureHandle;
struct iTextureWrapper;
struct csShaderVariableWrapper;

class csShaderVariable;

struct iShaderVariableAccessor : public virtual iBase
{
  SCF_INTERFACE (iShaderVariableAccessor, 2, 0, 0);

  virtual void PreGetValue (csShaderVariable *variable) = 0;
};

class CS_CRYSTALSPACE_EXPORT csShaderVariable : public csRefCount
{
public:
  enum VariableType
  {
    UNKNOWN = 0,
    INT = 1,
    FLOAT,
    COLOR,
    TEXTURE,
    RENDERBUFFER,
    VECTOR2,
    VECTOR3,
    VECTOR4,
    MATRIX,
    TRANSFORM,
    ARRAY
  };

  //CS_LEAKGUARD_DECLARE (csShaderVariable);
private:

  VariableType Type;

  csRef<iTextureHandle> TextureHandValue;
  csRef<iTextureWrapper> TextureWrapValue;
  csRef<iRenderBuffer> RenderBuffer;
  csVector4 VectorValue;

  int Int;
  csMatrix3* MatrixValuePtr;
  csReversibleTransform* TransformPtr;

  csRef<iShaderVariableAccessor> accessor;

  csRefArray<csShaderVariable> *array;

  csStringID Name;
public:

  csShaderVariable ();
  csShaderVariable (csStringID name);
  csShaderVariable (const csShaderVariable& other) : csRefCount(),
    MatrixValuePtr(0), TransformPtr (0), array(0) { *this = other; }
  virtual ~csShaderVariable ()
  {
    delete MatrixValuePtr;
    delete TransformPtr;
    delete array;
  }

  csShaderVariable& operator= (const csShaderVariable& copyFrom);

  VariableType GetType() 
  { 
    /* The accessor should be called at least once so the var has a proper
     * type set */
    if ((Type == UNKNOWN) && accessor) accessor->PreGetValue (this);
    return Type; 
  }
  void SetType (VariableType t) { Type = t; }

  void SetAccessor (iShaderVariableAccessor* a) { accessor = a;}

  void SetName (csStringID newName) { Name = newName; }
  
  csStringID GetName () const { return Name; }

  bool GetValue (int& value)
  { 
    if (accessor) accessor->PreGetValue (this);
    value = Int; 
    return true; 
  }

  bool GetValue (float& value)
  { 
    if (accessor) accessor->PreGetValue (this);
    value = VectorValue.x; 
    return true; 
  }

  bool GetValue (csRGBpixel& value)
  {
    if (accessor) accessor->PreGetValue (this);
    value.red = (char) VectorValue.x;
    value.green = (char) VectorValue.y;
    value.blue = (char) VectorValue.z;
    value.alpha = (char) VectorValue.w;
    return true;
  }

  bool GetValue (iTextureHandle*& value)
  {
    if (accessor) accessor->PreGetValue (this);
    value = TextureHandValue;
    if (!value && TextureWrapValue)
      value = TextureHandValue = TextureWrapValue->GetTextureHandle ();
    return true;
  }

  bool GetValue (iTextureWrapper*& value)
  {
    if (accessor) accessor->PreGetValue (this);
    value = TextureWrapValue;
    return true;
  }

  bool GetValue (iRenderBuffer*& value)
  {
    if (accessor) accessor->PreGetValue (this);
    value = RenderBuffer;
    return true;
  }

  bool GetValue (csVector2& value)
  {
    if (accessor) accessor->PreGetValue (this);
    value.Set (VectorValue.x, VectorValue.y);
    return true;
  }

  bool GetValue (csVector3& value)
  { 
    if (accessor) accessor->PreGetValue (this);
    value.Set (VectorValue.x, VectorValue.y, VectorValue.z);
    return true; 
  }

  bool GetValue (csColor& value)
  { 
    if (accessor) accessor->PreGetValue (this);
    value.Set (VectorValue.x, VectorValue.y, VectorValue.z);
    return true; 
  }

  bool GetValue (csVector4& value)
  { 
    if (accessor) accessor->PreGetValue (this);
    value = VectorValue; 
    return true; 
  }

  bool GetValue (csMatrix3& value)
  {
    if (accessor) accessor->PreGetValue (this);
    if (MatrixValuePtr)
    {
      value = *MatrixValuePtr;
      return true;
    }
    else
    {
      value = csMatrix3();
    }
    return false;
  }

  bool GetValue (csReversibleTransform& value)
  {
    if (accessor) accessor->PreGetValue (this);
    if (TransformPtr)
    {
      value = *TransformPtr;
      return true;
    }
    else
    {
      value = csReversibleTransform();
    }
    return false;
  }


  bool SetValue (int value) 
  { 
    Type = INT; 
    Int = value; 
    float f = (float)value;
    VectorValue.Set (f, f, f, f);
    return true; 
  }

  bool SetValue (float value)
  { 
    Type = FLOAT; 
    Int = (int)value;
    VectorValue.Set (value, value, value, value);
    return true; 
  }

  bool SetValue (const csRGBpixel &value)
  {
    Type = COLOR;
    VectorValue.x = (float) value.red;
    VectorValue.y = (float) value.green;
    VectorValue.z = (float) value.blue;
    VectorValue.w = (float) value.alpha;
    return true;
  }

  bool SetValue (iTextureHandle* value)
  {
    Type = TEXTURE;
    TextureHandValue = value;
    return true;
  }

  bool SetValue (iTextureWrapper* value)
  {
    Type = TEXTURE;
    TextureWrapValue = value;
    return true;
  }

  bool SetValue (iRenderBuffer* value)
  {
    Type = RENDERBUFFER;
    RenderBuffer = value;
    return true;
  }

  bool SetValue (const csVector2 &value)
  {
    Type = VECTOR2;
    VectorValue.Set (value.x, value.y, 0.0f, 1.0f);
    Int = (int)value.x;
    return true;
  }

  bool SetValue (const csVector3 &value)
  { 
    Type = VECTOR3; 
    VectorValue.Set (value.x, value.y, value.z, 1.0f);
    Int = (int)value.x;
    return true; 
  }

  bool SetValue (const csColor& value)
  { 
    Type = VECTOR3; 
    VectorValue.Set (value.red, value.green, value.blue, 1.0f);
    Int = (int)value.red;
    return true; 
  }

  bool SetValue (const csVector4 &value)
  { 
    Type = VECTOR4; 
    VectorValue.Set (value.x, value.y, value.z, value.w);
    Int = (int)value.x;
    return true; 
  }

  bool SetValue (const csMatrix3 &value)
  {
    Type = MATRIX;
    if (MatrixValuePtr)
    {
      *MatrixValuePtr = value;
    }
    else
    {
      MatrixValuePtr = new csMatrix3 (value);
    }
    return true;
  }

  bool SetValue (const csReversibleTransform &value)
  {
    Type = TRANSFORM;
    if (TransformPtr)
    {
      *TransformPtr = value;
    }
    else
    {
      TransformPtr = new csReversibleTransform (value);
    }
    return true;
  }

  void AddVariableToArray (csShaderVariable *variable)
  {
    if (array) array->Push (variable);
  }

  void RemoveFromArray (size_t element)
  {
    if (array) array->DeleteIndex (element);
  }

  void SetArraySize (size_t size)
  {
    if (array == 0)
    {
      array = new csRefArray<csShaderVariable>;
    }
    array->SetSize (size);
  }

  size_t GetArraySize ()
  {
    if (array == 0)
      return 0;
    else
      return array->Length ();
  }

  csShaderVariable *GetArrayElement (size_t element)
  {
    if (array != 0 && element<array->Length ())
    {
      return array->Get (element);
    }
    return 0;
  }

  void SetArrayElement (size_t element, csShaderVariable *variable)
  {
    array->Put (element, variable);
  }
};

namespace CS
{
  struct ShaderVarName
  {
    csStringID name;
    
    ShaderVarName() : name (csInvalidStringID) {}
    ShaderVarName (iStringSet* strings, const char* name) 
    { this->name = strings->Request (name); }
    
    operator csStringID () const { return name; }
  };
  
} // namespace CS

#endif

---