#include "stdfx/shaderfx.h"

// TnzStdfx includes

#include "stdfx.h"

#include "stdfx/shaderinterface.h"

#include "stdfx/shadingcontext.h"

// TnzBase includes

#include "tfxparam.h"

#include "tparamset.h"

#include "trenderresourcemanager.h"

#include "trenderer.h"

// TnzCore includes

#include "tthread.h"

#include "tfilepath.h"

#include "tstream.h"

#include "tfunctorinvoker.h"

#include "tmsgcore.h"

// Qt includes

#include <qdir></qdir>

#include <qopenglshaderprogram></qopenglshaderprogram>

#include <qcoreapplication></qcoreapplication>

#include <qoffscreensurface></qoffscreensurface>

// Glew include

#include <gl glew.h=""></gl>

// Boost includes

#include <boost any.hpp=""></boost>

#include <boost iterator="" transform_iterator.hpp=""></boost>

#include <boost ptr_container="" ptr_vector.hpp=""></boost>

// Diagnostics include

// #define DIAGNOSTICS

#ifdef DIAGNOSTICS

#include "diagnostics.h"

#endif

//===================================================

//    Forward Declarations

class ShaderFxDeclaration;

//===================================================

//****************************************************************************

//    Local Namespace  stuff

//****************************************************************************

namespace {

// Classes

struct ContextLocker {

  ShadingContext &m_ctx;

  bool m_locked;

public:

  ContextLocker(ShadingContext &ctx) : m_ctx(ctx), m_locked(false) { relock(); }

  ~ContextLocker() {

    if (m_locked) unlock();

  }

  void relock() {

    assert(!m_locked), m_locked = true;

    m_ctx.makeCurrent();

  }

  void unlock() {

    assert(m_locked), m_locked = false;

    m_ctx.doneCurrent();

  }

};

struct ProgramBinder {

  QOpenGLShaderProgram *m_prog;

public:

  ProgramBinder(QOpenGLShaderProgram *prog) : m_prog(prog) { m_prog->bind(); }

  ~ProgramBinder() {

    glUseProgram(0);  // m_prog->release();

  }

};

struct RectF {

  GLfloat m_val[4];

  RectF(GLfloat x0, GLfloat y0, GLfloat x1, GLfloat y1) {

    m_val[0] = x0, m_val[1] = y0, m_val[2] = x1, m_val[3] = y1;

  }

  RectF(const TRectD &rect) {

    m_val[0] = rect.x0, m_val[1] = rect.y0, m_val[2] = rect.x1,

    m_val[3] = rect.y1;

  }

  operator TRectD() const {

    return TRectD(m_val[0], m_val[1], m_val[2], m_val[3]);

  }

  bool operator==(const RectF &rect) const {

    return (memcmp(m_val, rect.m_val, sizeof(this)) == 0);

  }

};

struct AffineF {

  GLfloat m_val[9];

  operator TAffine() const {

    return TAffine(m_val[0], m_val[3], m_val[6], m_val[1], m_val[4], m_val[7]);

  }

  // Observe that mat3 from GLSL stores elements column-wise; this explains the

  // weird indexing

};

// Global Variables

typedef std::map<qstring, *="" shaderfxdeclaration=""> FxDeclarationsMap;</qstring,>

FxDeclarationsMap l_shaderFxDeclarations;

enum Measures { NONE, PERCENT, LENGTH, ANGLE, MEASURESCOUNT };

static const std::string l_measureNames[MEASURESCOUNT] = {"", "percentage",

                                                          "fxLength", "angle"};

static const TParamUIConcept::Type

    l_conceptTypes[ShaderInterface::CONCEPTSCOUNT -

                   ShaderInterface::UI_CONCEPTS] = {

        TParamUIConcept::RADIUS,  TParamUIConcept::WIDTH,

        TParamUIConcept::ANGLE,   TParamUIConcept::POINT,

        TParamUIConcept::POINT_2, TParamUIConcept::VECTOR,

        TParamUIConcept::POLAR,   TParamUIConcept::SIZE,

        TParamUIConcept::QUAD,    TParamUIConcept::RECT,

        TParamUIConcept::COMPASS, TParamUIConcept::COMPASS_SPIN};

// Functions

inline bool isObsolete(const TFilePath &fp, const QDateTime &lastModified) {

  QFileInfo fInfo(QString::fromStdWString(fp.getWideString()));

  return (lastModified != fInfo.lastModified());

}

inline TRectD tileRect(const TTile &tile) {

  const TDimension &dim = tile.getRaster()->getSize();

  return TRectD(tile.m_pos, TDimensionD(dim.lx, dim.ly));

}

inline void ceilRect(TRectD &rect) {

  rect.x0 = tfloor(rect.x0), rect.y0 = tfloor(rect.y0);

  rect.x1 = tceil(rect.x1), rect.y1 = tceil(rect.y1);

}

}  // namespace

//****************************************************************************

//    Shader Fx  declaration

//****************************************************************************

class ShaderFx final : public TStandardZeraryFx {

  FX_PLUGIN_DECLARATION(ShaderFx)

  const ShaderInterface *m_shaderInterface;  //!< Shader fx 'description'.

  std::vector<boost::any></boost::any>

      m_params;  //!< Parameters for the shader fx. The actual parameter

                 //!< type depends on the shader interface declaration.

  std::vector<tparamuiconcept></tparamuiconcept>

      m_uiConcepts;  //!< UI concepts related to m_params.

  boost::ptr_vector<trasterfxport></trasterfxport>

      m_inputPorts;  //!< Input ports for the shader fx.

public:

  ShaderFx() : m_shaderInterface() {

    assert(false);

  }  // Necessary due to TPersist inheritance, but must NOT be used

  ShaderFx(const ShaderInterface *shaderInterface)

      : m_shaderInterface(shaderInterface) {

    initialize();

  }

  // void setShaderInterface(const ShaderInterface& shaderInterface);

  void initialize();

  void getParamUIs(TParamUIConcept *¶ms, int &length) override;

  bool doGetBBox(double frame, TRectD &bBox,

                 const TRenderSettings &info) override;

  bool canHandle(const TRenderSettings &info, double frame) override;

  void doDryCompute(TRectD &rect, double frame,

                    const TRenderSettings &ri) override;

  void doCompute(TTile &tile, double frame, const TRenderSettings &ri) override;

private:

  QOpenGLShaderProgram *touchShaderProgram(

      const ShaderInterface::ShaderData &sd, ShadingContext &context,

      int varyingsCount = 0, const GLchar **varyings = 0);

  void bindParameters(QOpenGLShaderProgram *shaderProgram, double frame);

  void bindWorldTransform(QOpenGLShaderProgram *shaderProgram,

                          const TAffine &worldToDst);

  void getInputData(const TRectD &rect, double frame, const TRenderSettings &ri,

                    std::vector<trectd> &inputRects,</trectd>

                    std::vector<taffine> &inputAffines,</taffine>

                    ShadingContext &context);

};

//****************************************************************************

//    ShaderFxDeclaration  definition

//****************************************************************************

class ShaderFxDeclaration final : public TFxDeclaration {

  ShaderInterface m_shaderInterface;

public:

  ShaderFxDeclaration(const ShaderInterface &shaderInterface)

      : TFxDeclaration(

            TFxInfo(shaderInterface.mainShader().m_name.toStdString(), false))

      , m_shaderInterface(shaderInterface) {}

  TPersist *create() const override { return new ShaderFx(&m_shaderInterface); }

};

//****************************************************************************

//    ShadingContextManager  definition

//****************************************************************************

class ShadingContextManager final : public QObject {

  mutable QMutex m_mutex;

  std::unique_ptr<shadingcontext> m_shadingContext;</shadingcontext>

  TAtomicVar m_activeRenderInstances;

  std::unique_ptr<qoffscreensurface> m_surface;</qoffscreensurface>

public:

  ShadingContextManager() {

    /*

The ShadingContext's QGLPixelBuffer must be destroyed *before* the global

QApplication

is. So, we will attach to a suitable parent object whose lifespan is shorter.

FYI - yes, this approach was adopted after a long and PAINFUL wrestling session

with Qt.

Suggestions are welcome as this is a tad beyond ridiculous...

*/

    QObject *mainScopeBoundObject =

        QCoreApplication::instance()->findChild<qobject *="">("mainScope");</qobject>

    assert(thread() ==

           mainScopeBoundObject

               ->thread());  // Parent object must be in the same thread,

    // setParent(mainScopeBoundObject);  // otherwise reparenting fails

    m_surface.reset(new QOffscreenSurface());

    m_surface->create();

    m_shadingContext.reset(new ShadingContext(m_surface.get()));

  }

  static ShadingContextManager *instance() {

    static ShadingContextManager *theManager = new ShadingContextManager;

    return theManager;

  }

  QMutex *mutex() const { return &m_mutex; }

  const ShadingContext &shadingContext() const { return *m_shadingContext; }

  ShadingContext &shadingContext() { return *m_shadingContext; }

  void onRenderInstanceStart() { ++m_activeRenderInstances; }

  void onRenderInstanceEnd() {

    if (--m_activeRenderInstances == 0) {

      QMutexLocker mLocker(&m_mutex);

      // Release the shading context's output buffer

      ::ContextLocker cLocker(*m_shadingContext);

      m_shadingContext->resize(0, 0);

#ifdef DIAGNOSTICS

      DIAGNOSTICS_DUMP("ShaderLogs");

      DIAGNOSTICS_CLEAR;

#endif

    }

  }

  ShadingContext::Support touchSupport() {

    struct {

      ShadingContextManager *m_this;

      ShadingContext::Support support() {

        QMutexLocker mLocker(&m_this->m_mutex);

        ::ContextLocker cLocker(*m_this->m_shadingContext);

        return ShadingContext::support();

      }

    } locals = {this};

    static ShadingContext::Support sup = locals.support();

    static bool sentMsg = false;

    if (!sentMsg) {

      switch (sup) {

      case ShadingContext::NO_PIXEL_BUFFER:

        DVGui::warning(QOpenGLShaderProgram::tr(

            "This system configuration does not support OpenGL Pixel Buffers. "

            "Shader Fxs will not be able to render."));

        break;

      case ShadingContext::NO_SHADERS:

        DVGui::warning(QOpenGLShaderProgram::tr(

            "This system configuration does not support OpenGL Shader "

            "Programs. Shader Fxs will not be able to render."));

        break;

      default:

        break;

      }

      sentMsg = true;

    }

    return sup;

  }

  QOffscreenSurface *getSurface() { return m_surface.get(); }

};

template class DV_EXPORT_API TFxDeclarationT<shaderfx>;</shaderfx>

//****************************************************************************

//    ShadingContextManagerDelegate  definition

//****************************************************************************

class MessageCreateContext final : public TThread::Message {

  ShadingContextManager *man;

public:

  MessageCreateContext(ShadingContextManager *ctx) : man(ctx) {}

  void onDeliver() override { man->onRenderInstanceEnd(); }

  TThread::Message *clone() const override {

    return new MessageCreateContext(*this);

  }

};

class SCMDelegate final : public TRenderResourceManager {

  T_RENDER_RESOURCE_MANAGER

  void onRenderInstanceStart(unsigned long id) override {

    ShadingContextManager::instance()->onRenderInstanceStart();

  }

  void onRenderInstanceEnd(unsigned long id) override {

    if (!TThread::isMainThread()) {

      /* tofflinegl のときとは逆で main thread に dispatch する */

      MessageCreateContext(ShadingContextManager::instance()).sendBlocking();

    } else {

      ShadingContextManager::instance()->onRenderInstanceEnd();

    }

  }

};

//-------------------------------------------------------------------

class SCMDelegateGenerator final : public TRenderResourceManagerGenerator {

public:

  SCMDelegateGenerator() : TRenderResourceManagerGenerator(false) {

    /*

Again, this has to do with the manager's lifetime issue.

The SCM must be created in the MAIN THREAD, but NOT BEFORE the

QCoreApplication itself has been created. The easiest way to do so

is scheduling a slot to be executed as soon as event processing starts.

*/

    struct InstanceSCM final : public TFunctorInvoker::BaseFunctor {

      void operator()() override { ShadingContextManager::instance(); }

    };

    TFunctorInvoker::instance()->invokeQueued(new InstanceSCM);

  }

  TRenderResourceManager *operator()() override { return new SCMDelegate; }

};

MANAGER_FILESCOPE_DECLARATION(SCMDelegate, SCMDelegateGenerator)

//****************************************************************************

//    Shader Fx  implementation

//****************************************************************************

void ShaderFx::initialize() {

  struct {

    ShaderFx *m_this;

    inline void addUiConcept(const ShaderInterface::Parameter &siParam,

                             const TParamP ¶m) {

      if (siParam.m_concept.m_type >= ShaderInterface::UI_CONCEPTS &&

          siParam.m_concept.m_type < ShaderInterface::CONCEPTSCOUNT) {

        m_this->m_uiConcepts.push_back(TParamUIConcept());

        TParamUIConcept &uiConcept = m_this->m_uiConcepts.back();

        uiConcept.m_type           = ::l_conceptTypes[siParam.m_concept.m_type -

                                            ShaderInterface::UI_CONCEPTS];

        uiConcept.m_label          = siParam.m_concept.m_label.toStdString();

        uiConcept.m_params.push_back(param);

      }

    }

    inline void addUiConcept(const ShaderInterface::ParameterConcept &concept) {

      if (!concept.isUI() || concept.m_parameterNames.empty()) return;

      TParamUIConcept uiConcept = {

          ::l_conceptTypes[concept.m_type - ShaderInterface::UI_CONCEPTS],

          concept.m_label.toStdString()};

      int n, nCount = int(concept.m_parameterNames.size());

      for (n = 0; n != nCount; ++n) {

        TParam *param = m_this->getParams()->getParam(

            concept.m_parameterNames[n].toStdString());

        if (!param) break;

        uiConcept.m_params.push_back(param);

      }

      if (uiConcept.m_params.size() == concept.m_parameterNames.size())

        m_this->m_uiConcepts.push_back(uiConcept);

    }

  } locals = {this};

  assert(m_params.empty());  // Interfaces should not be re-set

  // Allocate parameters following the specified interface

  const std::vector<shaderinterface::parameter> &siParams =</shaderinterface::parameter>

      m_shaderInterface->parameters();

  int p, pCount = int(siParams.size());

  m_params.reserve(pCount);

  for (p = 0; p != pCount; ++p) {

    const ShaderInterface::Parameter &siParam = siParams[p];

    switch (siParam.m_type) {

    case ShaderInterface::BOOL: {

      TBoolParamP param(siParam.m_default.m_bool);

      m_params.push_back(param);

      bindParam(this, siParam.m_name.toStdString(),

                *boost::unsafe_any_cast<tboolparamp>(&m_params.back()));</tboolparamp>

      break;

    }

    case ShaderInterface::FLOAT: {

      TDoubleParamP param(siParam.m_default.m_float);

      param->setValueRange(siParam.m_range[0].m_float,

                           siParam.m_range[1].m_float);

      locals.addUiConcept(siParam, param);

      switch (siParam.m_concept.m_type) {

      case ShaderInterface::PERCENT:

        param->setMeasureName(l_measureNames[PERCENT]);

        break;

      case ShaderInterface::LENGTH:

      case ShaderInterface::RADIUS_UI:

      case ShaderInterface::WIDTH_UI:

      case ShaderInterface::SIZE_UI:

        param->setMeasureName(l_measureNames[LENGTH]);

        break;

      case ShaderInterface::ANGLE:

      case ShaderInterface::ANGLE_UI:

        param->setMeasureName(l_measureNames[ANGLE]);

        break;

      default:

        break;

      }

      m_params.push_back(param);

      bindParam(this, siParam.m_name.toStdString(),

                *boost::unsafe_any_cast<tdoubleparamp>(&m_params.back()));</tdoubleparamp>

      break;

    }

    case ShaderInterface::VEC2: {

      TPointParamP param(

          TPointD(siParam.m_default.m_vec2[0], siParam.m_default.m_vec2[1]));

      param->getX()->setValueRange(siParam.m_range[0].m_vec2[0],

                                   siParam.m_range[1].m_vec2[0]);

      param->getY()->setValueRange(siParam.m_range[0].m_vec2[1],

                                   siParam.m_range[1].m_vec2[1]);

      locals.addUiConcept(siParam, param);

      switch (siParam.m_concept.m_type) {

      case ShaderInterface::PERCENT:

        param->getX()->setMeasureName(l_measureNames[PERCENT]);

        param->getY()->setMeasureName(l_measureNames[PERCENT]);

        break;

      case ShaderInterface::LENGTH:

      case ShaderInterface::POINT:

      case ShaderInterface::POINT_UI:

      case ShaderInterface::VECTOR_UI:

      case ShaderInterface::WIDTH_UI:

      case ShaderInterface::SIZE_UI:

        param->getX()->setMeasureName(l_measureNames[LENGTH]);

        param->getY()->setMeasureName(l_measureNames[LENGTH]);

        break;

      case ShaderInterface::ANGLE:

      case ShaderInterface::ANGLE_UI:

        param->getX()->setMeasureName(l_measureNames[ANGLE]);

        param->getY()->setMeasureName(l_measureNames[ANGLE]);

        break;

      default:

        break;

      }

      m_params.push_back(param);

      bindParam(this, siParam.m_name.toStdString(),

                *boost::unsafe_any_cast<tpointparamp>(&m_params.back()));</tpointparamp>

      break;

    }

    case ShaderInterface::INT: {

      TIntParamP param(siParam.m_default.m_int);

      param->setValueRange(siParam.m_range[0].m_int, siParam.m_range[1].m_int);

      m_params.push_back(param);

      bindParam(this, siParam.m_name.toStdString(),

                *boost::unsafe_any_cast<tintparamp>(&m_params.back()));</tintparamp>

      break;

    }

    case ShaderInterface::RGBA: {

      TPixelParamP param(

          TPixel32(siParam.m_default.m_rgba[0], siParam.m_default.m_rgba[1],

                   siParam.m_default.m_rgba[2], siParam.m_default.m_rgba[3]));

      m_params.push_back(param);

      bindParam(this, siParam.m_name.toStdString(),

                *boost::unsafe_any_cast<tpixelparamp>(&m_params.back()));</tpixelparamp>

      break;

    }

    case ShaderInterface::RGB: {

      TPixelParamP param(TPixel32(siParam.m_default.m_rgb[0],

                                  siParam.m_default.m_rgb[1],

                                  siParam.m_default.m_rgb[2]));

      param->enableMatte(false);

      m_params.push_back(param);

      bindParam(this, siParam.m_name.toStdString(),

                *boost::unsafe_any_cast<tpixelparamp>(&m_params.back()));</tpixelparamp>

      break;

    }

    default:

      break;

    }

  }

  // Add composite UI concepts

  const std::vector<shaderinterface::parameterconcept> &parConcepts =</shaderinterface::parameterconcept>

      m_shaderInterface->m_parConcepts;

  int c, cCount = int(parConcepts.size());

  for (c = 0; c != cCount; ++c) locals.addUiConcept(parConcepts[c]);

  // Add input ports

  const std::vector<qstring> &inputPorts = m_shaderInterface->inputPorts();</qstring>

  int i, iCount = int(inputPorts.size());

  m_inputPorts.reserve(iCount);

  for (i = 0; i != iCount; ++i) {

    m_inputPorts.push_back(new TRasterFxPort);

    addInputPort(inputPorts[i].toStdString(), m_inputPorts[i]);

  }

}

//-------------------------------------------------------------------

void ShaderFx::getParamUIs(TParamUIConcept *¶ms, int &length) {

  length = int(m_uiConcepts.size());

  params = new TParamUIConcept[length];

  std::copy(m_uiConcepts.begin(), m_uiConcepts.end(), params);

}

//-------------------------------------------------------------------

bool ShaderFx::doGetBBox(double frame, TRectD &bbox,

                         const TRenderSettings &info) {

  static const ::RectF infiniteRectF(-(std::numeric_limits<glfloat>::max)(),</glfloat>

                                     -(std::numeric_limits<glfloat>::max)(),</glfloat>

                                     (std::numeric_limits<glfloat>::max)(),</glfloat>

                                     (std::numeric_limits<glfloat>::max)());</glfloat>

  bbox = TConsts::infiniteRectD;

  const ShaderInterface::ShaderData &sd = m_shaderInterface->bboxShader();

  if (!sd.isValid()) return true;

  ShadingContextManager *manager = ShadingContextManager::instance();

  if (manager->touchSupport() != ShadingContext::OK) return true;

  // Remember: info.m_affine MUST NOT BE CONSIDERED in doGetBBox's

  // implementation

  ::RectF bboxF(infiniteRectF);

  QMutexLocker mLocker(manager->mutex());

  // ShadingContext& context = manager->shadingContext();

  std::shared_ptr<shadingcontext> shadingContextPtr(</shadingcontext>

      new ShadingContext(manager->getSurface()));

  ShadingContext &context = *shadingContextPtr.get();

  ::ContextLocker cLocker(context);

  // Build the varyings data

  QOpenGLShaderProgram *prog = 0;

  {

    const GLchar *varyingNames[] = {"outputBBox"};

    prog = touchShaderProgram(sd, context, 1, &varyingNames[0]);

  }

  int pCount = getInputPortCount();

  std::vector<rectf> inputBBoxes(pCount, ::RectF(TRectD()));</rectf>

  for (int p = 0; p != pCount; ++p) {

    TRasterFxPort &port = m_inputPorts[p];

    if (port.isConnected()) {

      TRectD inputBBox;

      cLocker.unlock();

      mLocker.unlock();

      if (port->doGetBBox(frame, inputBBox, info))

        inputBBoxes[p] = (inputBBox == TConsts::infiniteRectD)

                             ? infiniteRectF

                             : ::RectF(inputBBox);

      mLocker.relock();

      cLocker.relock();

    }

  }

  {

    ProgramBinder progBinder(prog);

    // Bind uniform parameters

    bindParameters(prog, frame);

    prog->setUniformValue("infiniteRect", infiniteRectF.m_val[0],

                          infiniteRectF.m_val[1], infiniteRectF.m_val[2],

                          infiniteRectF.m_val[3]);

    prog->setUniformValueArray("inputBBox", inputBBoxes[0].m_val,

                               int(inputBBoxes.size()), 4);

    // Perform transform feedback

    const GLsizeiptr varyingSizes[] = {sizeof(::RectF)};

    GLvoid *bufs[]                  = {bboxF.m_val};

    context.transformFeedback(1, varyingSizes, bufs);

  }

  // Finalize output

  bbox = (bboxF == infiniteRectF) ? TConsts::infiniteRectD : TRectD(bboxF);

  return true;

}

//-------------------------------------------------------------------

bool ShaderFx::canHandle(const TRenderSettings &info, double frame) {

  return (m_shaderInterface->hwtType() == ShaderInterface::ANY)

             ? true

             : isAlmostIsotropic(info.m_affine);

}

//-------------------------------------------------------------------

QOpenGLShaderProgram *ShaderFx::touchShaderProgram(

    const ShaderInterface::ShaderData &sd, ShadingContext &context,

    int varyingsCount, const GLchar **varyings) {

  typedef std::pair<qopenglshaderprogram *,="" qdatetime=""> CompiledShader;</qopenglshaderprogram>

  struct locals {

    inline static void logCompilation(QOpenGLShaderProgram *program) {

      // Log shaders - observe that we'll look into the program's *children*,

      // not its

      // shaders. This is necessary as uncompiled shaders are not added to the

      // program.

      const QObjectList &children = program->children();

      int c, cCount = children.size();

      for (c = 0; c != cCount; ++c) {

        if (QOpenGLShader *shader =

                dynamic_cast<qopenglshader *="">(children[c])) {</qopenglshader>

          const QString &log = shader->log();

          if (!log.isEmpty()) DVGui::info(log);

        }

      }

      // ShaderProgram linking logs

      const QString &log = program->log();

      if (!log.isEmpty()) DVGui::info(log);

    }

  };  // locals

  // ShadingContext& context =

  // ShadingContextManager::instance()->shadingContext();

  CompiledShader cs = context.shaderData(sd.m_name);

  if (!cs.first || ::isObsolete(sd.m_path, cs.second)) {

    cs = m_shaderInterface->makeProgram(sd, varyingsCount, varyings);

    context.addShaderProgram(sd.m_name, cs.first, cs.second);

    locals::logCompilation(cs.first);

  }

  assert(cs.first);

  return cs.first;

}

//-------------------------------------------------------------------

void ShaderFx::bindParameters(QOpenGLShaderProgram *program, double frame) {

  // Bind fx parameters

  const std::vector<shaderinterface::parameter> &siParams =</shaderinterface::parameter>

      m_shaderInterface->parameters();

  assert(siParams.size() == m_params.size());

  int p, pCount = int(siParams.size());

  for (p = 0; p != pCount; ++p) {

    const ShaderInterface::Parameter &siParam = siParams[p];

    switch (siParam.m_type) {

    case ShaderInterface::BOOL: {

      const TBoolParamP ¶m =

          *boost::unsafe_any_cast<tboolparamp>(&m_params[p]);</tboolparamp>

      program->setUniformValue(siParam.m_name.toUtf8().data(),

                               (GLboolean)param->getValue());

      break;

    }

    case ShaderInterface::FLOAT: {

      const TDoubleParamP ¶m =

          *boost::unsafe_any_cast<tdoubleparamp>(&m_params[p]);</tdoubleparamp>

      program->setUniformValue(siParam.m_name.toUtf8().data(),

                               (GLfloat)param->getValue(frame));

      break;

    }

    case ShaderInterface::VEC2: {

      const TPointParamP ¶m =

          *boost::unsafe_any_cast<tpointparamp>(&m_params[p]);</tpointparamp>

      const TPointD &value = param->getValue(frame);

      program->setUniformValue(siParam.m_name.toUtf8().data(), (GLfloat)value.x,

                               (GLfloat)value.y);

      break;

    }

    case ShaderInterface::INT: {

      const TIntParamP ¶m =

          *boost::unsafe_any_cast<tintparamp>(&m_params[p]);</tintparamp>

      program->setUniformValue(siParam.m_name.toUtf8().data(),

                               (GLint)param->getValue());

      break;

    }

    case ShaderInterface::RGBA:

    case ShaderInterface::RGB: {

      const TPixelParamP ¶m =

          *boost::unsafe_any_cast<tpixelparamp>(&m_params[p]);</tpixelparamp>

      const TPixel32 &value = param->getValue(frame);

      program->setUniformValue(

          siParam.m_name.toUtf8().data(), (GLfloat)value.r / 255.0f,

          (GLfloat)value.g / 255.0f, (GLfloat)value.b / 255.0f,

          (GLfloat)value.m / 255.0f);

      break;

    }

    default:

      break;

    }

  }

}

//-------------------------------------------------------------------

void ShaderFx::bindWorldTransform(QOpenGLShaderProgram *program,

                                  const TAffine &worldToDst) {

  // Bind transformation affine

  float qwToD[9] = {static_cast<float>(worldToDst.a11),</float>

                    static_cast<float>(worldToDst.a12),</float>

                    static_cast<float>(worldToDst.a13),</float>

                    static_cast<float>(worldToDst.a21),</float>

                    static_cast<float>(worldToDst.a22),</float>

                    static_cast<float>(worldToDst.a23),</float>

                    0.0f,

                    0.0f,

                    1.0f};

  program->setUniformValue("worldToOutput", QMatrix3x3(qwToD));

  const TAffine &dToW = worldToDst.inv();

  float qdToW[9]      = {static_cast<float>(dToW.a11),</float>

                         static_cast<float>(dToW.a12),</float>

                         static_cast<float>(dToW.a13),</float>

                         static_cast<float>(dToW.a21),</float>

                         static_cast<float>(dToW.a22),</float>

                         static_cast<float>(dToW.a23),</float>

                         0.0f,

                         0.0f,

                         1.0f};

  program->setUniformValue("outputToWorld", QMatrix3x3(qdToW));

}

//-------------------------------------------------------------------

void ShaderFx::getInputData(const TRectD &rect, double frame,

                            const TRenderSettings &ri,

                            std::vector<trectd> &inputRects,</trectd>

                            std::vector<taffine> &inputAffines,</taffine>

                            ShadingContext &context) {

  struct locals {

    static inline void addNames(std::vector<std::string> &names,</std::string>

                                const char *prefix, int pCount) {

      for (int p = 0; p != pCount; ++p)

        names.push_back((prefix + QString("[%1]").arg(p)).toStdString());

    }

  };

  const ShaderInterface::ShaderData &sd = m_shaderInterface->inputPortsShader();

  if (!sd.isValid()) {

    inputRects.resize(getInputPortCount());

    std::fill(inputRects.begin(), inputRects.end(), rect);

    inputAffines.resize(getInputPortCount());

    std::fill(inputAffines.begin(), inputAffines.end(), ri.m_affine);

    return;

  }

  // ShadingContext& context =

  // ShadingContextManager::instance()->shadingContext();

  std::vector<glfloat> buf;</glfloat>

  int pCount = getInputPortCount();

  // Build the varyings data

  QOpenGLShaderProgram *prog = 0;

  {

    // Unsubscripted varying arrays on transform feedback seems to be

    // unsupported

    // on ATI cards. We have to declare EACH array name - e.g. inputRect[0],

    // intputRect[1], etc..

    const GLchar *varyingPrefixes[] = {"inputRect", "worldToInput"};

    const int varyingsCount = sizeof(varyingPrefixes) / sizeof(GLchar *);

    std::vector<std::string> varyingStrings;</std::string>

    varyingStrings.reserve(varyingsCount);

    for (int v = 0; v != varyingsCount; ++v)

      locals::addNames(varyingStrings, varyingPrefixes[v], pCount);

#if defined(__APPLE_CC__)

    /* OSX10.8 の clang -stdlib=libc++ だと link 時 &std::string::c_str が

     * undefined になってしまう */