oak-editor/app/render/shaderinfo.h

#ifndef SHADERINFO_H
#define SHADERINFO_H

#include <QMatrix4x4>

#include "codec/samplebuffer.h"
#include "common/filefunctions.h"
#include "node/input.h"
#include "node/inputarray.h"
#include "node/value.h"

OLIVE_NAMESPACE_ENTER

using NodeValueMap = QHash<QString, ShaderValue>;

class AcceleratedJob {
public:
  AcceleratedJob() = default;

  ShaderValue GetValue(NodeInput* input) const
  {
    return value_map_.value(input->id());
  }

  ShaderValue GetValue(const QString& input) const
  {
    return value_map_.value(input);
  }

  void InsertValue(NodeInput* input, NodeValueDatabase& value)
  {
    ShaderValue shader_val;

    shader_val.type = input->data_type();
    shader_val.array = input->IsArray();

    if (input->IsArray()) {
      NodeInputArray* array = static_cast<NodeInputArray*>(input);
      QVector<QVariant> values(array->GetSize());

      for (int j=0;j<array->GetSize();j++) {
        NodeInput* subparam = array->At(j);

        values[j] = value[subparam].Take(subparam->data_type());
      }

      shader_val.data = QVariant::fromValue(values);
    } else {
      NodeValue node_val = value[input].TakeWithMeta(input->data_type());
      shader_val.data = node_val.data();
      shader_val.tag = node_val.tag();
    }

    InsertValue(input->id(), shader_val);
  }

  void InsertValue(const QString& input, const ShaderValue& value)
  {
    value_map_.insert(input, value);
  }

  void InsertValue(NodeInput* input, const ShaderValue& value)
  {
    value_map_.insert(input->id(), value);
  }

  void InsertValue(NodeInput* input, const NodeValue& value)
  {
    ShaderValue s(value.data(), value.type());
    s.tag = value.tag();
    value_map_.insert(input->id(), s);
  }

  const NodeValueMap &GetValues() const
  {
    return value_map_;
  }

private:
  NodeValueMap value_map_;

};

class SampleJob : public AcceleratedJob {
public:
  SampleJob()
  {
    samples_ = nullptr;
  }

  SampleJob(const NodeValue& value)
  {
    samples_ = value.data().value<SampleBufferPtr>();
  }

  SampleJob(NodeInput* from, NodeValueDatabase& db)
  {
    samples_ = db[from].Take(NodeParam::kSamples).value<SampleBufferPtr>();
  }

  SampleBufferPtr samples() const
  {
    return samples_;
  }

  bool HasSamples() const
  {
    return samples_ && samples_->is_allocated();
  }

private:
  SampleBufferPtr samples_;

};

class GenerateJob : public AcceleratedJob {
public:
  GenerateJob()
  {
    alpha_channel_required_ = false;
  }

  bool GetAlphaChannelRequired() const
  {
    return alpha_channel_required_;
  }

  void SetAlphaChannelRequired(bool e)
  {
    alpha_channel_required_ = e;
  }

private:
  bool alpha_channel_required_;

};

class ShaderJob : public GenerateJob {
public:
  ShaderJob()
  {
    iterations_ = 1;
    iterative_input_ = nullptr;
    bilinear_ = true;
  }

  const QMatrix4x4& GetMatrix() const
  {
    return matrix_;
  }

  void SetMatrix(const QMatrix4x4& matrix)
  {
    matrix_ = matrix;
  }

  const QString& GetShaderID() const
  {
    return shader_id_;
  }

  void SetShaderID(const QString& id)
  {
    shader_id_ = id;
  }

  void SetIterations(int iterations, NodeInput* iterative_input)
  {
    SetIterations(iterations, iterative_input->id());
  }

  void SetIterations(int iterations, const QString& iterative_input)
  {
    iterations_ = iterations;
    iterative_input_ = iterative_input;
  }

  int GetIterationCount() const
  {
    return iterations_;
  }

  const QString& GetIterativeInput() const
  {
    return iterative_input_;
  }

  bool GetBilinearFiltering() const
  {
    return bilinear_;
  }

  void SetBilinearFiltering(bool e)
  {
    bilinear_ = e;
  }

private:
  QString shader_id_;

  int iterations_;

  QString iterative_input_;

  bool bilinear_;

  QMatrix4x4 matrix_;

};

class ShaderCode {
public:
  ShaderCode(const QString& frag_code, const QString& vert_code) :
    frag_code_(frag_code),
    vert_code_(vert_code)
  {
    if (frag_code_.isEmpty()) {
      frag_code_ = FileFunctions::ReadFileAsString(QStringLiteral(":/shaders/default.frag"));
    }

    if (vert_code_.isEmpty()) {
      vert_code_ = FileFunctions::ReadFileAsString(QStringLiteral(":/shaders/default.vert"));
    }
  }

  const QString& frag_code() const
  {
    return frag_code_;
  }

  const QString& vert_code() const
  {
    return vert_code_;
  }

private:
  QString frag_code_;

  QString vert_code_;

};

OLIVE_NAMESPACE_EXIT

Q_DECLARE_METATYPE(OLIVE_NAMESPACE::ShaderJob)
Q_DECLARE_METATYPE(OLIVE_NAMESPACE::SampleJob)
Q_DECLARE_METATYPE(OLIVE_NAMESPACE::GenerateJob)

#endif // SHADERINFO_H