ShSyntax.hpp

Go to the documentation of this file.

// Sh: A GPU metaprogramming language.
//
// Copyright (c) 2003 University of Waterloo Computer Graphics Laboratory
// Project administrator: Michael D. McCool
// Authors: Zheng Qin, Stefanus Du Toit, Kevin Moule, Tiberiu S. Popa,
//          Michael D. McCool
// 
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
// 
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it
// freely, subject to the following restrictions:
// 
// 1. The origin of this software must not be misrepresented; you must
// not claim that you wrote the original software. If you use this
// software in a product, an acknowledgment in the product documentation
// would be appreciated but is not required.
// 
// 2. Altered source versions must be plainly marked as such, and must
// not be misrepresented as being the original software.
// 
// 3. This notice may not be removed or altered from any source
// distribution.
#ifndef SHSYNTAX_HPP
#define SHSYNTAX_HPP

#include "ShDllExport.hpp"
#include "ShProgram.hpp"
#include "ShUtility.hpp"



#define SH_PUSH_ARG_QUEUE ::SH::shPushArgQueue()
#define SH_PUSH_ARG ::SH::shPushArg()
#define SH_PROCESS_ARG(arg, internal_cond) ::SH::shProcessArg(arg, internal_cond)




#define SH_BEGIN_PROGRAM(target) ::SH::shBeginShader(target);

#define SH_END_PROGRAM         ::SH::shEndShader();


#define SH_END                 SH_END_PROGRAM

#define SH_BEGIN_VERTEX_PROGRAM ::SH::shBeginShader("gpu:vertex");
#define SH_BEGIN_FRAGMENT_PROGRAM ::SH::shBeginShader("gpu:fragment");



#define SH_IF(cond) { \
  bool sh__internal_cond; \
  ::SH::shIf(SH_PUSH_ARG_QUEUE && SH_PUSH_ARG && SH_PROCESS_ARG(cond, &sh__internal_cond)); \
  if (ShContext::current()->parsing() || sh__internal_cond) {{

#define SH_ELSE  \
  }} \
  ::SH::shElse(); \
  if (ShContext::current()->parsing() || !sh__internal_cond) {{

#define SH_ENDIF \
  }} \
  ::SH::shEndIf(); \
}




#define SH_WHILE(cond) { \
  bool sh__internal_cond; \
  ::SH::shWhile(SH_PUSH_ARG_QUEUE && SH_PUSH_ARG && SH_PROCESS_ARG(cond, &sh__internal_cond)); \
  bool sh__internal_firsttime = true; \
  while ((sh__internal_firsttime && (ShContext::current()->parsing() || sh__internal_cond)) \
         || (!ShContext::current()->parsing() && ::SH::shEvaluateCondition(cond))) {{{

#define SH_ENDWHILE \
    sh__internal_firsttime = false; \
  }}} \
  ::SH::shEndWhile(); \
}




#define SH_DO       { \
  ::SH::shDo(); \
  do {{{{

#define SH_UNTIL(cond) \
  }}}} while (!ShContext::current()->parsing() && ::SH::shEvaluateCondition(cond)); \
  if (ShContext::current()->parsing()) ::SH::shUntil(SH_PUSH_ARG_QUEUE && SH_PUSH_ARG && SH_PROCESS_ARG(cond, 0)); }




// TODO: It is possible to make declaring variables in init work. do so.
#define SH_FOR(init,cond,update) { \
  if (ShContext::current()->parsing()) \
    ::SH::shFor(SH_PUSH_ARG_QUEUE \
             && SH_PUSH_ARG && SH_PROCESS_ARG(init, 0) \
             && SH_PUSH_ARG && SH_PROCESS_ARG(cond, 0) \
             && SH_PUSH_ARG && SH_PROCESS_ARG(update, 0)); \
  if (!ShContext::current()->parsing()) init; \
  bool sh__internal_first_time = true; \
  while (1) {{{{{ \
    if (!ShContext::current()->parsing()) { \
      if (!sh__internal_first_time) { update; } \
      else { sh__internal_first_time = false; } \
      if (!shEvaluateCondition(cond)) break; \
    }                                                                                  

#define SH_ENDFOR \
    if (ShContext::current()->parsing()) break; \
  }}}}} \
  ::SH::shEndFor(); \
}




#define SH_BREAK    if (!ShContext::current()->parsing()) { break; } else { ::SH::shBreak(); }

#define SH_CONTINUE if (!ShContext::current()->parsing()) { continue; } else { ::SH::shBreak(); }




#define SH_NAME(var) do { var.name( # var); } while (0)

#define SH_DECL(var) var; var.name( # var ); ::SH::ShIgnore() & var

#define SH_NAMEDECL(var, varName) var; var.name( varName ); ::SH::ShIgnore() & var


namespace SH {

SH_DLLEXPORT
bool shProcessArg(const ShVariable& arg, bool* internal_cond);

SH_DLLEXPORT
bool shPushArg();

SH_DLLEXPORT
bool shPushArgQueue();

SH_DLLEXPORT
bool shEvaluateCondition(const ShVariable& arg);

SH_DLLEXPORT
ShProgram shBeginShader(const std::string& kind = "");
SH_DLLEXPORT
void shEndShader();

SH_DLLEXPORT
void shCompile(ShProgram& prg);
SH_DLLEXPORT
void shCompile(ShProgram& prg, const std::string& target);

SH_DLLEXPORT
void shCompileShader(ShProgram& prg);
SH_DLLEXPORT
void shCompileShader(ShProgram& prg, const std::string& target);

SH_DLLEXPORT
void shBind(ShProgram& prg);
SH_DLLEXPORT
void shBind(const std::string& target, ShProgram& shader);

SH_DLLEXPORT
void shBindShader(ShProgram& shader);
SH_DLLEXPORT
void shBindShader(const std::string& target, ShProgram& shader);

SH_DLLEXPORT
void shUpdate();

SH_DLLEXPORT
bool shSetBackend(const std::string& name);


SH_DLLEXPORT
void shInit();

SH_DLLEXPORT
void shIf(bool);
SH_DLLEXPORT
void shElse();
SH_DLLEXPORT
void shEndIf();

SH_DLLEXPORT
void shWhile(bool);
SH_DLLEXPORT
void shEndWhile();

SH_DLLEXPORT
void shDo();
SH_DLLEXPORT
void shUntil(bool);

SH_DLLEXPORT
void shFor(bool);
SH_DLLEXPORT
void shEndFor();

SH_DLLEXPORT
void shBreak();
SH_DLLEXPORT
void shContinue();

}

#endif

---