Public API Reference

ivideo/shader/shader.h

Go to the documentation of this file.

/*
    Copyright (C) 2002 by Marten Svanfeldt
                          Anders Stenberg

    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_IVIDEO_SHADER_H__
#define __CS_IVIDEO_SHADER_H__

#include "csutil/scf.h"

#include "iutil/array.h"

#include "csgfx/shadervar.h"
#include "csutil/array.h"
#include "csutil/refarr.h"
#include "csutil/set.h"
#include "csutil/strset.h"

struct iDocumentNode;
struct iLight;
struct iObject;
struct iLoaderContext;

struct csRenderMesh;
class csShaderVariable;

struct iShader;
struct iShaderCompiler;
struct iShaderManager;


typedef csArray<csShaderVariable*> csShaderVarStack;
struct iShaderVarStack : public iArrayChangeAll<csShaderVariable*>
{
  SCF_IARRAYCHANGEALL_INTERFACE (iShaderVarStack);
};


static inline csShaderVariable* csGetShaderVariableFromStack 
  (const csShaderVarStack& stack, const csStringID &name)
{
  if ((name != csInvalidStringID) &&
      (name < (csStringID)stack.Length ()))
  {
    return stack[name];
  }
  return 0;
}
static inline csShaderVariable* csGetShaderVariableFromStack 
  (const iShaderVarStack* stack, const csStringID &name)
{
  if ((name != csInvalidStringID) &&
      (name < (csStringID)stack->GetSize ()))
  {
    return static_cast<const iArrayReadOnly<csShaderVariable*>*> (stack)
      ->Get (name);
  }
  return 0;
}

struct iShaderVariableContext : public virtual iBase
{
  SCF_INTERFACE(iShaderVariableContext, 2, 1, 1);

  virtual void AddVariable (csShaderVariable *variable) = 0;
  
  virtual csShaderVariable* GetVariable (csStringID name) const = 0;

  csShaderVariable* GetVariableAdd (csStringID name)
  {
    csShaderVariable* sv;
    sv = GetVariable (name);
    if (sv == 0)
    {
      csRef<csShaderVariable> nsv (
        csPtr<csShaderVariable> (new csShaderVariable (name)));
      AddVariable (nsv);
      sv = nsv; // OK, sv won't be destructed, SV context takes ownership
    }
    return sv;
  }

  virtual const csRefArray<csShaderVariable>& GetShaderVariables () const = 0;

  virtual void PushVariables (iShaderVarStack* stacks) const = 0;

  virtual bool IsEmpty () const = 0;

  virtual void ReplaceVariable (csShaderVariable* variable) = 0;
  
  virtual void Clear() = 0;

  virtual bool RemoveVariable (csShaderVariable* variable) = 0;
};

enum csShaderTagPresence
{
  TagNeutral,
  TagForbidden,
  TagRequired
};

struct iShaderManager : public virtual iShaderVariableContext
{
  SCF_INTERFACE (iShaderManager, 1, 1, 0);
  virtual void RegisterShader (iShader* shader) = 0;
  virtual void UnregisterShader (iShader* shader) = 0;
  virtual iShader* GetShader (const char* name) = 0;
  virtual const csRefArray<iShader> &GetShaders ()  = 0;

  virtual void RegisterCompiler (iShaderCompiler* compiler) = 0;
  virtual iShaderCompiler* GetCompiler(const char* name) = 0;

  virtual iShaderVarStack* GetShaderVariableStack () = 0;

  virtual void SetTagOptions (csStringID tag, csShaderTagPresence presence, 
    int priority = 0) = 0;
  virtual void GetTagOptions (csStringID tag, csShaderTagPresence& presence, 
    int& priority) = 0;

  virtual const csSet<csStringID>& GetTags (csShaderTagPresence presence,
    int& count) = 0;

  virtual void SetActiveLights (const csArray<iLight*>& lights) = 0;

  virtual const csArray<iLight*>& GetActiveLights () const = 0;
};

struct csShaderMetadata
{
  char *description;

  uint numberOfLights;

  csShaderMetadata ()
    : description (0), numberOfLights (0)
  {}
};

struct iShader : public virtual iShaderVariableContext
{
  SCF_INTERFACE(iShader, 3, 1, 0);

  virtual iObject* QueryObject () = 0;

  virtual const char* GetFileName () = 0;

  virtual void SetFileName (const char* filename) = 0;

  virtual size_t GetTicket (const csRenderMeshModes& modes,
    const iShaderVarStack* stacks) = 0;

  virtual size_t GetNumberOfPasses (size_t ticket) = 0;

  virtual bool ActivatePass (size_t ticket, size_t number) = 0;

  virtual bool SetupPass (size_t ticket, const csRenderMesh *mesh,
    csRenderMeshModes& modes,
    const iShaderVarStack* stacks) = 0;

  virtual bool TeardownPass (size_t ticket) = 0;

  virtual bool DeactivatePass (size_t ticket) = 0;

  virtual const csShaderMetadata& GetMetadata (size_t ticket) const = 0;
};


struct iShaderPriorityList : public virtual iBase
{
  SCF_INTERFACE (iShaderPriorityList, 1,0,0);
  virtual size_t GetCount () const = 0;
  virtual int GetPriority (size_t idx) const = 0;
};

struct iShaderCompiler : public virtual iBase
{
  SCF_INTERFACE (iShaderCompiler, 0,0,1);
  virtual const char* GetName() = 0;

  virtual csPtr<iShader> CompileShader (
        iLoaderContext* ldr_context, iDocumentNode *templ,
        int forcepriority = -1) = 0;

  virtual bool ValidateTemplate (iDocumentNode *templ) = 0;

  virtual bool IsTemplateToCompiler (iDocumentNode *templ) = 0;

  virtual csPtr<iShaderPriorityList> GetPriorities (
                  iDocumentNode* templ) = 0;
};

#endif // __CS_IVIDEO_SHADER_H__

---