COM_NodeOperation.h

Go to the documentation of this file.

/*
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 * Copyright 2011, Blender Foundation.
 */
 
#pragma once
 
#include <list>
#include <sstream>
#include <string>
 
#include "BLI_math_color.h"
#include "BLI_math_vector.h"
#include "BLI_threads.h"
 
#include "COM_Enums.h"
#include "COM_MemoryBuffer.h"
#include "COM_MemoryProxy.h"
#include "COM_MetaData.h"
#include "COM_Node.h"
 
#include "clew.h"
 
namespace blender::compositor {
 
class OpenCLDevice;
class ReadBufferOperation;
class WriteBufferOperation;
 
class NodeOperation;
typedef NodeOperation SocketReader;
 
static constexpr unsigned int RESOLUTION_INPUT_ANY = 999999;
 
enum class ResizeMode {
  Center = NS_CR_CENTER,
  None = NS_CR_NONE,
  FitWidth = NS_CR_FIT_WIDTH,
  FitHeight = NS_CR_FIT_HEIGHT,
  FitAny = NS_CR_FIT,
  Stretch = NS_CR_STRETCH,
};
 
enum class PixelSampler {
  Nearest = 0,
  Bilinear = 1,
  Bicubic = 2,
};
 
class NodeOperationInput {
 private:
  NodeOperation *m_operation;
 
  DataType m_datatype;
 
  ResizeMode m_resizeMode;
 
  NodeOperationOutput *m_link;
 
 public:
  NodeOperationInput(NodeOperation *op,
                     DataType datatype,
                     ResizeMode resizeMode = ResizeMode::Center);
 
  NodeOperation &getOperation() const
  {
    return *m_operation;
  }
  DataType getDataType() const
  {
    return m_datatype;
  }
 
  void setLink(NodeOperationOutput *link)
  {
    m_link = link;
  }
  NodeOperationOutput *getLink() const
  {
    return m_link;
  }
  bool isConnected() const
  {
    return m_link;
  }
 
  void setResizeMode(ResizeMode resizeMode)
  {
    this->m_resizeMode = resizeMode;
  }
  ResizeMode getResizeMode() const
  {
    return this->m_resizeMode;
  }
 
  SocketReader *getReader();
 
  void determineResolution(unsigned int resolution[2], unsigned int preferredResolution[2]);
 
#ifdef WITH_CXX_GUARDEDALLOC
  MEM_CXX_CLASS_ALLOC_FUNCS("COM:NodeOperation")
#endif
};
 
class NodeOperationOutput {
 private:
  NodeOperation *m_operation;
 
  DataType m_datatype;
 
 public:
  NodeOperationOutput(NodeOperation *op, DataType datatype);
 
  NodeOperation &getOperation() const
  {
    return *m_operation;
  }
  DataType getDataType() const
  {
    return m_datatype;
  }
 
  void determineResolution(unsigned int resolution[2], unsigned int preferredResolution[2]);
 
#ifdef WITH_CXX_GUARDEDALLOC
  MEM_CXX_CLASS_ALLOC_FUNCS("COM:NodeOperation")
#endif
};
 
struct NodeOperationFlags {
  bool complex : 1;
 
  bool open_cl : 1;
 
  bool single_threaded : 1;
 
  bool use_render_border : 1;
  bool use_viewer_border : 1;
 
  bool is_resolution_set : 1;
 
  bool is_set_operation : 1;
  bool is_write_buffer_operation : 1;
  bool is_read_buffer_operation : 1;
  bool is_proxy_operation : 1;
  bool is_viewer_operation : 1;
  bool is_preview_operation : 1;
 
  bool use_datatype_conversion : 1;
 
  NodeOperationFlags()
  {
    complex = false;
    single_threaded = false;
    open_cl = false;
    use_render_border = false;
    use_viewer_border = false;
    is_resolution_set = false;
    is_set_operation = false;
    is_read_buffer_operation = false;
    is_write_buffer_operation = false;
    is_proxy_operation = false;
    is_viewer_operation = false;
    is_preview_operation = false;
    use_datatype_conversion = true;
  }
};
 
class NodeOperation {
 private:
  int m_id;
  std::string m_name;
  Vector<NodeOperationInput> m_inputs;
  Vector<NodeOperationOutput> m_outputs;
 
  unsigned int m_resolutionInputSocketIndex;
 
  ThreadMutex m_mutex;
 
  const bNodeTree *m_btree;
 
 protected:
  unsigned int m_width;
 
  unsigned int m_height;
 
  NodeOperationFlags flags;
 
 public:
  virtual ~NodeOperation()
  {
  }
 
  void set_name(const std::string name)
  {
    m_name = name;
  }
 
  const std::string get_name() const
  {
    return m_name;
  }
 
  void set_id(const int id)
  {
    m_id = id;
  }
 
  const int get_id() const
  {
    return m_id;
  }
 
  const NodeOperationFlags get_flags() const
  {
    return flags;
  }
 
  unsigned int getNumberOfInputSockets() const
  {
    return m_inputs.size();
  }
  unsigned int getNumberOfOutputSockets() const
  {
    return m_outputs.size();
  }
  NodeOperationOutput *getOutputSocket(unsigned int index = 0);
  NodeOperationInput *getInputSocket(unsigned int index);
 
  virtual void determineResolution(unsigned int resolution[2],
                                   unsigned int preferredResolution[2]);
 
  virtual bool isOutputOperation(bool /*rendering*/) const
  {
    return false;
  }
 
  void setbNodeTree(const bNodeTree *tree)
  {
    this->m_btree = tree;
  }
  virtual void initExecution();
 
  virtual void executeRegion(rcti * /*rect*/, unsigned int /*chunkNumber*/)
  {
  }
 
  virtual void executeOpenCLRegion(OpenCLDevice * /*device*/,
                                   rcti * /*rect*/,
                                   unsigned int /*chunkNumber*/,
                                   MemoryBuffer ** /*memoryBuffers*/,
                                   MemoryBuffer * /*outputBuffer*/)
  {
  }
 
  virtual void executeOpenCL(OpenCLDevice * /*device*/,
                             MemoryBuffer * /*outputMemoryBuffer*/,
                             cl_mem /*clOutputBuffer*/,
                             MemoryBuffer ** /*inputMemoryBuffers*/,
                             std::list<cl_mem> * /*clMemToCleanUp*/,
                             std::list<cl_kernel> * /*clKernelsToCleanUp*/)
  {
  }
  virtual void deinitExecution();
 
  void setResolution(unsigned int resolution[2])
  {
    if (!this->flags.is_resolution_set) {
      this->m_width = resolution[0];
      this->m_height = resolution[1];
      this->flags.is_resolution_set = true;
    }
  }
 
  virtual bool isActiveViewerOutput() const
  {
    return false;
  }
 
  virtual bool determineDependingAreaOfInterest(rcti *input,
                                                ReadBufferOperation *readOperation,
                                                rcti *output);
 
  void setResolutionInputSocketIndex(unsigned int index);
 
  virtual eCompositorPriority getRenderPriority() const
  {
    return eCompositorPriority::Low;
  }
 
  inline bool isBraked() const
  {
    return this->m_btree->test_break(this->m_btree->tbh);
  }
 
  inline void updateDraw()
  {
    if (this->m_btree->update_draw) {
      this->m_btree->update_draw(this->m_btree->udh);
    }
  }
 
  unsigned int getWidth() const
  {
    return m_width;
  }
 
  unsigned int getHeight() const
  {
    return m_height;
  }
 
  inline void readSampled(float result[4], float x, float y, PixelSampler sampler)
  {
    executePixelSampled(result, x, y, sampler);
  }
 
  inline void readFiltered(float result[4], float x, float y, float dx[2], float dy[2])
  {
    executePixelFiltered(result, x, y, dx, dy);
  }
 
  inline void read(float result[4], int x, int y, void *chunkData)
  {
    executePixel(result, x, y, chunkData);
  }
 
  virtual void *initializeTileData(rcti * /*rect*/)
  {
    return 0;
  }
 
  virtual void deinitializeTileData(rcti * /*rect*/, void * /*data*/)
  {
  }
 
  virtual MemoryBuffer *getInputMemoryBuffer(MemoryBuffer ** /*memoryBuffers*/)
  {
    return 0;
  }
 
  virtual std::unique_ptr<MetaData> getMetaData()
  {
    return std::unique_ptr<MetaData>();
  }
 
 protected:
  NodeOperation();
 
  void addInputSocket(DataType datatype, ResizeMode resize_mode = ResizeMode::Center);
  void addOutputSocket(DataType datatype);
 
  void setWidth(unsigned int width)
  {
    this->m_width = width;
    this->flags.is_resolution_set = true;
  }
  void setHeight(unsigned int height)
  {
    this->m_height = height;
    this->flags.is_resolution_set = true;
  }
  SocketReader *getInputSocketReader(unsigned int inputSocketindex);
  NodeOperation *getInputOperation(unsigned int inputSocketindex);
 
  void deinitMutex();
  void initMutex();
  void lockMutex();
  void unlockMutex();
 
  void setComplex(bool complex)
  {
    this->flags.complex = complex;
  }
 
  virtual void executePixelSampled(float /*output*/[4],
                                   float /*x*/,
                                   float /*y*/,
                                   PixelSampler /*sampler*/)
  {
  }
 
  virtual void executePixel(float output[4], int x, int y, void * /*chunkData*/)
  {
    executePixelSampled(output, x, y, PixelSampler::Nearest);
  }
 
  virtual void executePixelFiltered(
      float /*output*/[4], float /*x*/, float /*y*/, float /*dx*/[2], float /*dy*/[2])
  {
  }
 
  /* allow the DebugInfo class to look at internals */
  friend class DebugInfo;
 
#ifdef WITH_CXX_GUARDEDALLOC
  MEM_CXX_CLASS_ALLOC_FUNCS("COM:NodeOperation")
#endif
};
 
std::ostream &operator<<(std::ostream &os, const NodeOperationFlags &node_operation_flags);
std::ostream &operator<<(std::ostream &os, const NodeOperation &node_operation);
 
}  // namespace blender::compositor