Cleanup: Change extension .cpp to .cc

1 files changed, 0 insertions, 722 deletions

diff --git a/source/blender/compositor/intern/COM_NodeOperationBuilder.cpp b/source/blender/compositor/intern/COM_NodeOperationBuilder.cpp
deleted file mode 100644
index 688b693080f..00000000000
--- a/source/blender/compositor/intern/COM_NodeOperationBuilder.cpp
+++ /dev/null
@@ -1,722 +0,0 @@
-/*
- * 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 2013, Blender Foundation.
- */
-
-#include "BLI_utildefines.h"
-
-#include "COM_Converter.h"
-#include "COM_Debug.h"
-#include "COM_ExecutionSystem.h"
-#include "COM_Node.h"
-#include "COM_NodeConverter.h"
-#include "COM_SocketProxyNode.h"
-
-#include "COM_NodeOperation.h"
-#include "COM_PreviewOperation.h"
-#include "COM_ReadBufferOperation.h"
-#include "COM_SetColorOperation.h"
-#include "COM_SetValueOperation.h"
-#include "COM_SetVectorOperation.h"
-#include "COM_SocketProxyOperation.h"
-#include "COM_ViewerOperation.h"
-#include "COM_WriteBufferOperation.h"
-
-#include "COM_NodeOperationBuilder.h" /* own include */
-
-NodeOperationBuilder::NodeOperationBuilder(const CompositorContext *context, bNodeTree *b_nodetree)
-    : m_context(context), m_current_node(nullptr), m_active_viewer(nullptr)
-{
-  m_graph.from_bNodeTree(*context, b_nodetree);
-}
-
-NodeOperationBuilder::~NodeOperationBuilder()
-{
-}
-
-void NodeOperationBuilder::convertToOperations(ExecutionSystem *system)
-{
-  /* interface handle for nodes */
-  NodeConverter converter(this);
-
-  for (int index = 0; index < m_graph.nodes().size(); index++) {
-    Node *node = (Node *)m_graph.nodes()[index];
-
-    m_current_node = node;
-
-    DebugInfo::node_to_operations(node);
-    node->convertToOperations(converter, *m_context);
-  }
-
-  m_current_node = nullptr;
-
-  /* The input map constructed by nodes maps operation inputs to node inputs.
-   * Inverting yields a map of node inputs to all connected operation inputs,
-   * so multiple operations can use the same node input.
-   */
-  OpInputInverseMap inverse_input_map;
-  for (InputSocketMap::const_iterator it = m_input_map.begin(); it != m_input_map.end(); ++it) {
-    inverse_input_map[it->second].push_back(it->first);
-  }
-
-  for (const NodeGraph::Link &link : m_graph.links()) {
-    NodeOutput *from = link.from;
-    NodeInput *to = link.to;
-
-    NodeOperationOutput *op_from = find_operation_output(m_output_map, from);
-    const OpInputs &op_to_list = find_operation_inputs(inverse_input_map, to);
-    if (!op_from || op_to_list.empty()) {
-      /* XXX allow this? error/debug message? */
-      // BLI_assert(false);
-      /* XXX note: this can happen with certain nodes (e.g. OutputFile)
-       * which only generate operations in certain circumstances (rendering)
-       * just let this pass silently for now ...
-       */
-      continue;
-    }
-
-    for (OpInputs::const_iterator it = op_to_list.begin(); it != op_to_list.end(); ++it) {
-      NodeOperationInput *op_to = *it;
-      addLink(op_from, op_to);
-    }
-  }
-
-  add_operation_input_constants();
-
-  resolve_proxies();
-
-  add_datatype_conversions();
-
-  determineResolutions();
-
-  /* surround complex ops with read/write buffer */
-  add_complex_operation_buffers();
-
-  /* links not available from here on */
-  /* XXX make m_links a local variable to avoid confusion! */
-  m_links.clear();
-
-  prune_operations();
-
-  /* ensure topological (link-based) order of nodes */
-  /*sort_operations();*/ /* not needed yet */
-
-  /* create execution groups */
-  group_operations();
-
-  /* transfer resulting operations to the system */
-  system->set_operations(m_operations, m_groups);
-}
-
-void NodeOperationBuilder::addOperation(NodeOperation *operation)
-{
-  m_operations.append(operation);
-}
-
-void NodeOperationBuilder::mapInputSocket(NodeInput *node_socket,
-                                          NodeOperationInput *operation_socket)
-{
-  BLI_assert(m_current_node);
-  BLI_assert(node_socket->getNode() == m_current_node);
-
-  /* note: this maps operation sockets to node sockets.
-   * for resolving links the map will be inverted first in convertToOperations,
-   * to get a list of links for each node input socket.
-   */
-  m_input_map[operation_socket] = node_socket;
-}
-
-void NodeOperationBuilder::mapOutputSocket(NodeOutput *node_socket,
-                                           NodeOperationOutput *operation_socket)
-{
-  BLI_assert(m_current_node);
-  BLI_assert(node_socket->getNode() == m_current_node);
-
-  m_output_map[node_socket] = operation_socket;
-}
-
-void NodeOperationBuilder::addLink(NodeOperationOutput *from, NodeOperationInput *to)
-{
-  if (to->isConnected()) {
-    return;
-  }
-
-  m_links.push_back(Link(from, to));
-
-  /* register with the input */
-  to->setLink(from);
-}
-
-void NodeOperationBuilder::removeInputLink(NodeOperationInput *to)
-{
-  for (Links::iterator it = m_links.begin(); it != m_links.end(); ++it) {
-    Link &link = *it;
-    if (link.to() == to) {
-      /* unregister with the input */
-      to->setLink(nullptr);
-
-      m_links.erase(it);
-      return;
-    }
-  }
-}
-
-NodeInput *NodeOperationBuilder::find_node_input(const InputSocketMap &map,
-                                                 NodeOperationInput *op_input)
-{
-  InputSocketMap::const_iterator it = map.find(op_input);
-  return (it != map.end() ? it->second : NULL);
-}
-
-const NodeOperationBuilder::OpInputs &NodeOperationBuilder::find_operation_inputs(
-    const OpInputInverseMap &map, NodeInput *node_input)
-{
-  static const OpInputs empty_list;
-  OpInputInverseMap::const_iterator it = map.find(node_input);
-  return (it != map.end() ? it->second : empty_list);
-}
-
-NodeOperationOutput *NodeOperationBuilder::find_operation_output(const OutputSocketMap &map,
-                                                                 NodeOutput *node_output)
-{
-  OutputSocketMap::const_iterator it = map.find(node_output);
-  return (it != map.end() ? it->second : NULL);
-}
-
-PreviewOperation *NodeOperationBuilder::make_preview_operation() const
-{
-  BLI_assert(m_current_node);
-
-  if (!(m_current_node->getbNode()->flag & NODE_PREVIEW)) {
-    return nullptr;
-  }
-  /* previews only in the active group */
-  if (!m_current_node->isInActiveGroup()) {
-    return nullptr;
-  }
-  /* do not calculate previews of hidden nodes */
-  if (m_current_node->getbNode()->flag & NODE_HIDDEN) {
-    return nullptr;
-  }
-
-  bNodeInstanceHash *previews = m_context->getPreviewHash();
-  if (previews) {
-    PreviewOperation *operation = new PreviewOperation(m_context->getViewSettings(),
-                                                       m_context->getDisplaySettings());
-    operation->setbNodeTree(m_context->getbNodeTree());
-    operation->verifyPreview(previews, m_current_node->getInstanceKey());
-    return operation;
-  }
-
-  return nullptr;
-}
-
-void NodeOperationBuilder::addPreview(NodeOperationOutput *output)
-{
-  PreviewOperation *operation = make_preview_operation();
-  if (operation) {
-    addOperation(operation);
-
-    addLink(output, operation->getInputSocket(0));
-  }
-}
-
-void NodeOperationBuilder::addNodeInputPreview(NodeInput *input)
-{
-  PreviewOperation *operation = make_preview_operation();
-  if (operation) {
-    addOperation(operation);
-
-    mapInputSocket(input, operation->getInputSocket(0));
-  }
-}
-
-void NodeOperationBuilder::registerViewer(ViewerOperation *viewer)
-{
-  if (m_active_viewer) {
-    if (m_current_node->isInActiveGroup()) {
-      /* deactivate previous viewer */
-      m_active_viewer->setActive(false);
-
-      m_active_viewer = viewer;
-      viewer->setActive(true);
-    }
-  }
-  else {
-    if (m_current_node->getbNodeTree() == m_context->getbNodeTree()) {
-      m_active_viewer = viewer;
-      viewer->setActive(true);
-    }
-  }
-}
-
-/****************************
- **** Optimization Steps ****
- ****************************/
-
-void NodeOperationBuilder::add_datatype_conversions()
-{
-  Links convert_links;
-  for (Links::const_iterator it = m_links.begin(); it != m_links.end(); ++it) {
-    const Link &link = *it;
-
-    /* proxy operations can skip data type conversion */
-    NodeOperation *from_op = &link.from()->getOperation();
-    NodeOperation *to_op = &link.to()->getOperation();
-    if (!(from_op->useDatatypeConversion() || to_op->useDatatypeConversion())) {
-      continue;
-    }
-
-    if (link.from()->getDataType() != link.to()->getDataType()) {
-      convert_links.push_back(link);
-    }
-  }
-  for (Links::const_iterator it = convert_links.begin(); it != convert_links.end(); ++it) {
-    const Link &link = *it;
-    NodeOperation *converter = COM_convert_data_type(*link.from(), *link.to());
-    if (converter) {
-      addOperation(converter);
-
-      removeInputLink(link.to());
-      addLink(link.from(), converter->getInputSocket(0));
-      addLink(converter->getOutputSocket(0), link.to());
-    }
-  }
-}
-
-void NodeOperationBuilder::add_operation_input_constants()
-{
-  /* Note: unconnected inputs cached first to avoid modifying
-   *       m_operations while iterating over it
-   */
-  using Inputs = std::vector<NodeOperationInput *>;
-  Inputs pending_inputs;
-  for (NodeOperation *op : m_operations) {
-    for (int k = 0; k < op->getNumberOfInputSockets(); ++k) {
-      NodeOperationInput *input = op->getInputSocket(k);
-      if (!input->isConnected()) {
-        pending_inputs.push_back(input);
-      }
-    }
-  }
-  for (Inputs::const_iterator it = pending_inputs.begin(); it != pending_inputs.end(); ++it) {
-    NodeOperationInput *input = *it;
-    add_input_constant_value(input, find_node_input(m_input_map, input));
-  }
-}
-
-void NodeOperationBuilder::add_input_constant_value(NodeOperationInput *input,
-                                                    NodeInput *node_input)
-{
-  switch (input->getDataType()) {
-    case COM_DT_VALUE: {
-      float value;
-      if (node_input && node_input->getbNodeSocket()) {
-        value = node_input->getEditorValueFloat();
-      }
-      else {
-        value = 0.0f;
-      }
-
-      SetValueOperation *op = new SetValueOperation();
-      op->setValue(value);
-      addOperation(op);
-      addLink(op->getOutputSocket(), input);
-      break;
-    }
-    case COM_DT_COLOR: {
-      float value[4];
-      if (node_input && node_input->getbNodeSocket()) {
-        node_input->getEditorValueColor(value);
-      }
-      else {
-        zero_v4(value);
-      }
-
-      SetColorOperation *op = new SetColorOperation();
-      op->setChannels(value);
-      addOperation(op);
-      addLink(op->getOutputSocket(), input);
-      break;
-    }
-    case COM_DT_VECTOR: {
-      float value[3];
-      if (node_input && node_input->getbNodeSocket()) {
-        node_input->getEditorValueVector(value);
-      }
-      else {
-        zero_v3(value);
-      }
-
-      SetVectorOperation *op = new SetVectorOperation();
-      op->setVector(value);
-      addOperation(op);
-      addLink(op->getOutputSocket(), input);
-      break;
-    }
-  }
-}
-
-void NodeOperationBuilder::resolve_proxies()
-{
-  Links proxy_links;
-  for (Links::const_iterator it = m_links.begin(); it != m_links.end(); ++it) {
-    const Link &link = *it;
-    /* don't replace links from proxy to proxy, since we may need them for replacing others! */
-    if (link.from()->getOperation().isProxyOperation() &&
-        !link.to()->getOperation().isProxyOperation()) {
-      proxy_links.push_back(link);
-    }
-  }
-
-  for (Links::const_iterator it = proxy_links.begin(); it != proxy_links.end(); ++it) {
-    const Link &link = *it;
-
-    NodeOperationInput *to = link.to();
-    NodeOperationOutput *from = link.from();
-    do {
-      /* walk upstream bypassing the proxy operation */
-      from = from->getOperation().getInputSocket(0)->getLink();
-    } while (from && from->getOperation().isProxyOperation());
-
-    removeInputLink(to);
-    /* we may not have a final proxy input link,
-     * in that case it just gets dropped
-     */
-    if (from) {
-      addLink(from, to);
-    }
-  }
-}
-
-void NodeOperationBuilder::determineResolutions()
-{
-  /* determine all resolutions of the operations (Width/Height) */
-  for (NodeOperation *op : m_operations) {
-    if (op->isOutputOperation(m_context->isRendering()) && !op->isPreviewOperation()) {
-      unsigned int resolution[2] = {0, 0};
-      unsigned int preferredResolution[2] = {0, 0};
-      op->determineResolution(resolution, preferredResolution);
-      op->setResolution(resolution);
-    }
-  }
-
-  for (NodeOperation *op : m_operations) {
-    if (op->isOutputOperation(m_context->isRendering()) && op->isPreviewOperation()) {
-      unsigned int resolution[2] = {0, 0};
-      unsigned int preferredResolution[2] = {0, 0};
-      op->determineResolution(resolution, preferredResolution);
-      op->setResolution(resolution);
-    }
-  }
-
-  /* add convert resolution operations when needed */
-  {
-    Links convert_links;
-    for (Links::const_iterator it = m_links.begin(); it != m_links.end(); ++it) {
-      const Link &link = *it;
-
-      if (link.to()->getResizeMode() != COM_SC_NO_RESIZE) {
-        NodeOperation &from_op = link.from()->getOperation();
-        NodeOperation &to_op = link.to()->getOperation();
-        if (from_op.getWidth() != to_op.getWidth() || from_op.getHeight() != to_op.getHeight()) {
-          convert_links.push_back(link);
-        }
-      }
-    }
-    for (Links::const_iterator it = convert_links.begin(); it != convert_links.end(); ++it) {
-      const Link &link = *it;
-      COM_convert_resolution(*this, link.from(), link.to());
-    }
-  }
-}
-
-NodeOperationBuilder::OpInputs NodeOperationBuilder::cache_output_links(
-    NodeOperationOutput *output) const
-{
-  OpInputs inputs;
-  for (Links::const_iterator it = m_links.begin(); it != m_links.end(); ++it) {
-    const Link &link = *it;
-    if (link.from() == output) {
-      inputs.push_back(link.to());
-    }
-  }
-  return inputs;
-}
-
-WriteBufferOperation *NodeOperationBuilder::find_attached_write_buffer_operation(
-    NodeOperationOutput *output) const
-{
-  for (Links::const_iterator it = m_links.begin(); it != m_links.end(); ++it) {
-    const Link &link = *it;
-    if (link.from() == output) {
-      NodeOperation &op = link.to()->getOperation();
-      if (op.isWriteBufferOperation()) {
-        return (WriteBufferOperation *)(&op);
-      }
-    }
-  }
-  return nullptr;
-}
-
-void NodeOperationBuilder::add_input_buffers(NodeOperation * /*operation*/,
-                                             NodeOperationInput *input)
-{
-  if (!input->isConnected()) {
-    return;
-  }
-
-  NodeOperationOutput *output = input->getLink();
-  if (output->getOperation().isReadBufferOperation()) {
-    /* input is already buffered, no need to add another */
-    return;
-  }
-
-  /* this link will be replaced below */
-  removeInputLink(input);
-
-  /* check of other end already has write operation, otherwise add a new one */
-  WriteBufferOperation *writeoperation = find_attached_write_buffer_operation(output);
-  if (!writeoperation) {
-    writeoperation = new WriteBufferOperation(output->getDataType());
-    writeoperation->setbNodeTree(m_context->getbNodeTree());
-    addOperation(writeoperation);
-
-    addLink(output, writeoperation->getInputSocket(0));
-
-    writeoperation->readResolutionFromInputSocket();
-  }
-
-  /* add readbuffer op for the input */
-  ReadBufferOperation *readoperation = new ReadBufferOperation(output->getDataType());
-  readoperation->setMemoryProxy(writeoperation->getMemoryProxy());
-  this->addOperation(readoperation);
-
-  addLink(readoperation->getOutputSocket(), input);
-
-  readoperation->readResolutionFromWriteBuffer();
-}
-
-void NodeOperationBuilder::add_output_buffers(NodeOperation *operation,
-                                              NodeOperationOutput *output)
-{
-  /* cache connected sockets, so we can safely remove links first before replacing them */
-  OpInputs targets = cache_output_links(output);
-  if (targets.empty()) {
-    return;
-  }
-
-  WriteBufferOperation *writeOperation = nullptr;
-  for (OpInputs::const_iterator it = targets.begin(); it != targets.end(); ++it) {
-    NodeOperationInput *target = *it;
-
-    /* try to find existing write buffer operation */
-    if (target->getOperation().isWriteBufferOperation()) {
-      BLI_assert(writeOperation == nullptr); /* there should only be one write op connected */
-      writeOperation = (WriteBufferOperation *)(&target->getOperation());
-    }
-    else {
-      /* remove all links to other nodes */
-      removeInputLink(target);
-    }
-  }
-
-  /* if no write buffer operation exists yet, create a new one */
-  if (!writeOperation) {
-    writeOperation = new WriteBufferOperation(operation->getOutputSocket()->getDataType());
-    writeOperation->setbNodeTree(m_context->getbNodeTree());
-    addOperation(writeOperation);
-
-    addLink(output, writeOperation->getInputSocket(0));
-  }
-
-  writeOperation->readResolutionFromInputSocket();
-
-  /* add readbuffer op for every former connected input */
-  for (OpInputs::const_iterator it = targets.begin(); it != targets.end(); ++it) {
-    NodeOperationInput *target = *it;
-    if (&target->getOperation() == writeOperation) {
-      continue; /* skip existing write op links */
-    }
-
-    ReadBufferOperation *readoperation = new ReadBufferOperation(
-        operation->getOutputSocket()->getDataType());
-    readoperation->setMemoryProxy(writeOperation->getMemoryProxy());
-    addOperation(readoperation);
-
-    addLink(readoperation->getOutputSocket(), target);
-
-    readoperation->readResolutionFromWriteBuffer();
-  }
-}
-
-void NodeOperationBuilder::add_complex_operation_buffers()
-{
-  /* note: complex ops and get cached here first, since adding operations
-   * will invalidate iterators over the main m_operations
-   */
-  blender::Vector<NodeOperation *> complex_ops;
-  for (NodeOperation *operation : m_operations) {
-    if (operation->isComplex()) {
-      complex_ops.append(operation);
-    }
-  }
-
-  for (NodeOperation *op : complex_ops) {
-    DebugInfo::operation_read_write_buffer(op);
-
-    for (int index = 0; index < op->getNumberOfInputSockets(); index++) {
-      add_input_buffers(op, op->getInputSocket(index));
-    }
-
-    for (int index = 0; index < op->getNumberOfOutputSockets(); index++) {
-      add_output_buffers(op, op->getOutputSocket(index));
-    }
-  }
-}
-
-using Tags = std::set<NodeOperation *>;
-
-static void find_reachable_operations_recursive(Tags &reachable, NodeOperation *op)
-{
-  if (reachable.find(op) != reachable.end()) {
-    return;
-  }
-  reachable.insert(op);
-
-  for (int i = 0; i < op->getNumberOfInputSockets(); i++) {
-    NodeOperationInput *input = op->getInputSocket(i);
-    if (input->isConnected()) {
-      find_reachable_operations_recursive(reachable, &input->getLink()->getOperation());
-    }
-  }
-
-  /* associated write-buffer operations are executed as well */
-  if (op->isReadBufferOperation()) {
-    ReadBufferOperation *read_op = (ReadBufferOperation *)op;
-    MemoryProxy *memproxy = read_op->getMemoryProxy();
-    find_reachable_operations_recursive(reachable, memproxy->getWriteBufferOperation());
-  }
-}
-
-void NodeOperationBuilder::prune_operations()
-{
-  Tags reachable;
-  for (NodeOperation *op : m_operations) {
-    /* output operations are primary executed operations */
-    if (op->isOutputOperation(m_context->isRendering())) {
-      find_reachable_operations_recursive(reachable, op);
-    }
-  }
-
-  /* delete unreachable operations */
-  blender::Vector<NodeOperation *> reachable_ops;
-  for (NodeOperation *op : m_operations) {
-    if (reachable.find(op) != reachable.end()) {
-      reachable_ops.append(op);
-    }
-    else {
-      delete op;
-    }
-  }
-  /* finally replace the operations list with the pruned list */
-  m_operations = reachable_ops;
-}
-
-/* topological (depth-first) sorting of operations */
-static void sort_operations_recursive(blender::Vector<NodeOperation *> &sorted,
-                                      Tags &visited,
-                                      NodeOperation *op)
-{
-  if (visited.find(op) != visited.end()) {
-    return;
-  }
-  visited.insert(op);
-
-  for (int i = 0; i < op->getNumberOfInputSockets(); i++) {
-    NodeOperationInput *input = op->getInputSocket(i);
-    if (input->isConnected()) {
-      sort_operations_recursive(sorted, visited, &input->getLink()->getOperation());
-    }
-  }
-
-  sorted.append(op);
-}
-
-void NodeOperationBuilder::sort_operations()
-{
-  blender::Vector<NodeOperation *> sorted;
-  sorted.reserve(m_operations.size());
-  Tags visited;
-
-  for (NodeOperation *operation : m_operations) {
-    sort_operations_recursive(sorted, visited, operation);
-  }
-
-  m_operations = sorted;
-}
-
-static void add_group_operations_recursive(Tags &visited, NodeOperation *op, ExecutionGroup *group)
-{
-  if (visited.find(op) != visited.end()) {
-    return;
-  }
-  visited.insert(op);
-
-  if (!group->addOperation(op)) {
-    return;
-  }
-
-  /* add all eligible input ops to the group */
-  for (int i = 0; i < op->getNumberOfInputSockets(); i++) {
-    NodeOperationInput *input = op->getInputSocket(i);
-    if (input->isConnected()) {
-      add_group_operations_recursive(visited, &input->getLink()->getOperation(), group);
-    }
-  }
-}
-
-ExecutionGroup *NodeOperationBuilder::make_group(NodeOperation *op)
-{
-  ExecutionGroup *group = new ExecutionGroup();
-  m_groups.append(group);
-
-  Tags visited;
-  add_group_operations_recursive(visited, op, group);
-
-  return group;
-}
-
-void NodeOperationBuilder::group_operations()
-{
-  for (NodeOperation *op : m_operations) {
-    if (op->isOutputOperation(m_context->isRendering())) {
-      ExecutionGroup *group = make_group(op);
-      group->setOutputExecutionGroup(true);
-    }
-
-    /* add new groups for associated memory proxies where needed */
-    if (op->isReadBufferOperation()) {
-      ReadBufferOperation *read_op = (ReadBufferOperation *)op;
-      MemoryProxy *memproxy = read_op->getMemoryProxy();
-
-      if (memproxy->getExecutor() == nullptr) {
-        ExecutionGroup *group = make_group(memproxy->getWriteBufferOperation());
-        memproxy->setExecutor(group);
-      }
-    }
-  }
-}