Fix T41067: Muted nodes still do data type conversions.
authorLukas Tönne <lukas.toenne@gmail.com>
Tue, 15 Jul 2014 08:55:49 +0000 (10:55 +0200)
committerLukas Tönne <lukas.toenne@gmail.com>
Tue, 15 Jul 2014 09:03:07 +0000 (11:03 +0200)
Proxy operations from muted nodes would still create conversion
operations where the datatypes don't match, which creates unexpected
behavior. Arguably datatype conversion could still happen even when the
main operation is muted, but this would be a design change and so is
disabled now.

source/blender/compositor/intern/COM_NodeConverter.cpp
source/blender/compositor/intern/COM_NodeConverter.h
source/blender/compositor/intern/COM_NodeGraph.cpp
source/blender/compositor/intern/COM_NodeOperation.h
source/blender/compositor/intern/COM_NodeOperationBuilder.cpp
source/blender/compositor/nodes/COM_SocketProxyNode.cpp
source/blender/compositor/nodes/COM_SocketProxyNode.h
source/blender/compositor/nodes/COM_SwitchNode.cpp
source/blender/compositor/operations/COM_SocketProxyOperation.cpp
source/blender/compositor/operations/COM_SocketProxyOperation.h

index 81a10a58cc57ade19c0617336f3083e9b44e1d0d..208a3db812fd6a7e94781d0ecdbd426e85e7ea78 100644 (file)
@@ -83,9 +83,9 @@ NodeOperation *NodeConverter::setInvalidOutput(NodeOutput *output)
        return operation;
 }
 
-NodeOperationOutput *NodeConverter::addInputProxy(NodeInput *input)
+NodeOperationOutput *NodeConverter::addInputProxy(NodeInput *input, bool use_conversion)
 {
-       SocketProxyOperation *proxy = new SocketProxyOperation(input->getDataType());
+       SocketProxyOperation *proxy = new SocketProxyOperation(input->getDataType(), use_conversion);
        m_builder->addOperation(proxy);
        
        m_builder->mapInputSocket(input, proxy->getInputSocket(0));
@@ -93,9 +93,9 @@ NodeOperationOutput *NodeConverter::addInputProxy(NodeInput *input)
        return proxy->getOutputSocket();
 }
 
-NodeOperationInput *NodeConverter::addOutputProxy(NodeOutput *output)
+NodeOperationInput *NodeConverter::addOutputProxy(NodeOutput *output, bool use_conversion)
 {
-       SocketProxyOperation *proxy = new SocketProxyOperation(output->getDataType());
+       SocketProxyOperation *proxy = new SocketProxyOperation(output->getDataType(), use_conversion);
        m_builder->addOperation(proxy);
        
        m_builder->mapOutputSocket(output, proxy->getOutputSocket());
index e5e7629f39a7a844870d613a719ef7409f78a95a..414b4f1ee9525e81335780f8f57735539867d96f 100644 (file)
@@ -70,12 +70,12 @@ public:
         *  This operation will be removed later and replaced
         *  by direct links between the connected operations.
         */
-       NodeOperationOutput *addInputProxy(NodeInput *input);
+       NodeOperationOutput *addInputProxy(NodeInput *input, bool use_conversion);
        /** Create a proxy operation for a node output.
         *  This operation will be removed later and replaced
         *  by direct links between the connected operations.
         */
-       NodeOperationInput *addOutputProxy(NodeOutput *output);
+       NodeOperationInput *addOutputProxy(NodeOutput *output, bool use_conversion);
        
        /** Define a constant input value. */
        void addInputValue(NodeOperationInput *input, float value);
index cbe47238249567e9c3f8ee3833d8954d56e97d70..2dcf419d81bba1dfd2ef1afbdb19201669dafdd3 100644 (file)
@@ -202,7 +202,7 @@ void NodeGraph::add_bNodeLink(const NodeRange &node_range, bNodeLink *b_nodelink
 void NodeGraph::add_proxies_mute(bNodeTree *b_ntree, bNode *b_node, bNodeInstanceKey key, bool is_active_group)
 {
        for (bNodeLink *b_link = (bNodeLink *)b_node->internal_links.first; b_link; b_link = b_link->next) {
-               SocketProxyNode *proxy = new SocketProxyNode(b_node, b_link->fromsock, b_link->tosock);
+               SocketProxyNode *proxy = new SocketProxyNode(b_node, b_link->fromsock, b_link->tosock, false);
                add_node(proxy, b_ntree, key, is_active_group);
        }
 }
@@ -219,7 +219,7 @@ void NodeGraph::add_proxies_skip(bNodeTree *b_ntree, bNode *b_node, bNodeInstanc
                }
                
                if (input) {
-                       SocketProxyNode *proxy = new SocketProxyNode(b_node, input, output);
+                       SocketProxyNode *proxy = new SocketProxyNode(b_node, input, output, true);
                        add_node(proxy, b_ntree, key, is_active_group);
                }
        }
@@ -237,7 +237,7 @@ void NodeGraph::add_proxies_group_inputs(bNode *b_node, bNode *b_node_io)
        for (bNodeSocket *b_sock_io = (bNodeSocket *)b_node_io->outputs.first; b_sock_io; b_sock_io = b_sock_io->next) {
                bNodeSocket *b_sock_group = find_b_node_input(b_node, b_sock_io->identifier);
                if (b_sock_group) {
-                       SocketProxyNode *proxy = new SocketProxyNode(b_node_io, b_sock_group, b_sock_io);
+                       SocketProxyNode *proxy = new SocketProxyNode(b_node_io, b_sock_group, b_sock_io, true);
                        add_node(proxy, b_group_tree, key, is_active_group);
                }
        }
@@ -260,7 +260,7 @@ void NodeGraph::add_proxies_group_outputs(bNode *b_node, bNode *b_node_io, bool
                                add_node(buffer, b_group_tree, key, is_active_group);
                        }
                        else {
-                               SocketProxyNode *proxy = new SocketProxyNode(b_node_io, b_sock_io, b_sock_group);
+                               SocketProxyNode *proxy = new SocketProxyNode(b_node_io, b_sock_io, b_sock_group, true);
                                add_node(proxy, b_group_tree, key, is_active_group);
                        }
                }
@@ -294,6 +294,6 @@ void NodeGraph::add_proxies_group(const CompositorContext &context, bNode *b_nod
 
 void NodeGraph::add_proxies_reroute(bNodeTree *b_ntree, bNode *b_node, bNodeInstanceKey key, bool is_active_group)
 {
-       SocketProxyNode *proxy = new SocketProxyNode(b_node, (bNodeSocket *)b_node->inputs.first, (bNodeSocket *)b_node->outputs.first);
+       SocketProxyNode *proxy = new SocketProxyNode(b_node, (bNodeSocket *)b_node->inputs.first, (bNodeSocket *)b_node->outputs.first, false);
        add_node(proxy, b_ntree, key, is_active_group);
 }
index 3f636dff63cec1aa7211d5bd508ede3ad0e615f9..b2b8f03c4762a1db55c52be71e1c4d98151e8164 100644 (file)
@@ -288,6 +288,8 @@ public:
        virtual bool isFileOutputOperation() const { return false; }
        virtual bool isProxyOperation() const { return false; }
        
+       virtual bool useDatatypeConversion() const { return true; }
+       
        inline bool isBreaked() const {
                return this->m_btree->test_break(this->m_btree->tbh);
        }
index 6554926991cbc8f716824317ebf5d2ebd504b866..0c8c3ed53a79be64b754e4f0d1d42800fb628900 100644 (file)
@@ -269,6 +269,13 @@ 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);
        }
index f750a44a788f61fd621d38abedaa16c518fed240..48c8acfc6a1109ed8ddf052030e253473df3fcba 100644 (file)
@@ -29,7 +29,9 @@
 #include "COM_WriteBufferOperation.h"
 #include "COM_ReadBufferOperation.h"
 
-SocketProxyNode::SocketProxyNode(bNode *editorNode, bNodeSocket *editorInput, bNodeSocket *editorOutput) : Node(editorNode, false)
+SocketProxyNode::SocketProxyNode(bNode *editorNode, bNodeSocket *editorInput, bNodeSocket *editorOutput, bool use_conversion) :
+    Node(editorNode, false),
+    m_use_conversion(use_conversion)
 {
        DataType dt;
 
@@ -46,7 +48,7 @@ SocketProxyNode::SocketProxyNode(bNode *editorNode, bNodeSocket *editorInput, bN
 
 void SocketProxyNode::convertToOperations(NodeConverter &converter, const CompositorContext &context) const
 {
-       NodeOperationOutput *proxy_output = converter.addInputProxy(getInputSocket(0));
+       NodeOperationOutput *proxy_output = converter.addInputProxy(getInputSocket(0), m_use_conversion);
        converter.mapOutputSocket(getOutputSocket(), proxy_output);
 }
 
index 2fbaa71421cedaaed00b6e30529989737e2febf1..5dbf39382cca2847bce78970b21fbbafd3706a7d 100644 (file)
  */
 class SocketProxyNode : public Node {
 public:
-       SocketProxyNode(bNode *editorNode, bNodeSocket *editorInput, bNodeSocket *editorOutput);
+       SocketProxyNode(bNode *editorNode, bNodeSocket *editorInput, bNodeSocket *editorOutput, bool use_conversion);
        void convertToOperations(NodeConverter &converter, const CompositorContext &context) const;
+       
+       bool getUseConversion() const { return m_use_conversion; }
+       void setUseConversion(bool use_conversion) { m_use_conversion = use_conversion; }
+       
+private:
+       /** If true, the proxy will convert input and output data to/from the proxy socket types. */
+       bool m_use_conversion;
 };
 
 
index 692b8d743f6df2bdc66a5e3d5e2fb3691a1f8cc2..10f0ee3821de53527a57cf4c8e3618806cedf84c 100644 (file)
@@ -33,9 +33,9 @@ void SwitchNode::convertToOperations(NodeConverter &converter, const CompositorC
        
        NodeOperationOutput *result;
        if (!condition)
-               result = converter.addInputProxy(getInputSocket(0));
+               result = converter.addInputProxy(getInputSocket(0), false);
        else
-               result = converter.addInputProxy(getInputSocket(1));
+               result = converter.addInputProxy(getInputSocket(1), false);
        
        converter.mapOutputSocket(getOutputSocket(0), result);
 }
index da345b282fd1781f66dba8ce42baafc887024997..21d2f28332e9612b88f2c51fb7ea840663ecca6a 100644 (file)
@@ -22,7 +22,9 @@
 
 #include "COM_SocketProxyOperation.h"
 
-SocketProxyOperation::SocketProxyOperation(DataType type) : NodeOperation()
+SocketProxyOperation::SocketProxyOperation(DataType type, bool use_conversion) :
+    NodeOperation(),
+    m_use_conversion(use_conversion)
 {
        this->addInputSocket(type);
        this->addOutputSocket(type);
index 9733a1fbeecc901f027ded0d6542c784c3547e2b..c9d6cb6ef9e5fc88fee04e85f1d37e5a0f1f1575 100644 (file)
 
 class SocketProxyOperation : public NodeOperation {
 public:
-       SocketProxyOperation(DataType type);
+       SocketProxyOperation(DataType type, bool use_conversion);
        
        bool isProxyOperation() const { return true; }
+       bool useDatatypeConversion() const { return m_use_conversion; }
+       
+       bool getUseConversion() const { return m_use_conversion; }
+       void setUseConversion(bool use_conversion) { m_use_conversion = use_conversion; }
+       
+private:
+       bool m_use_conversion;
 };
 
 #endif