____

`````|````` | |        |                        ..'''' 
     |      | |        |______               .''       
     |      | |        |                  ..'          
     |      | |_______ |___________ ....''             
               merge to TRUNK!

 * The old compositor is still available (Debug Menu: 200)

This commit was brought to you by:

Developers:
 * Monique Dewanchand
 * Jeroen Bakker
 * Dalai Felinto
 * Lukas Tönne

Review:
 * Brecht van Lommel

Testers:
 * Nate Wiebe
 * Wolfgang Faehnle
 * Carlo Andreacchio
 * Daniel Salazar
 * Artur Mag
 * Christian Krupa
 * Francesco Siddi
 * Dan McGrath
 * Bassam Kurdali

But mostly by the community:
Gold:

    Joshua Faulkner
    Michael Tiemann
    Francesco Paglia
    Blender Guru
    Blender Developers Fund

Silver:

    Pablo Vazquez
    Joel Heethaar
    Amrein Olivier
    Ilias Karasavvidis
    Thomas Kumlehn
    Sebastian Koenig
    Hannu Hoffrén
    Benjamin Dansie
    Fred M'ule
    Michel Vilain
    Bradley Cathey
    Gianmichele Mariani
    Gottfried Hofmann
    Bjørnar Frøyse
    Valentijn Bruning
    Paul Holmes
    Clemens Rudolph
    Juris Graphix
    David Strebel
    Ronan Zeegers
    François Tarlier
    Felipe Andres Esquivel Reed
    Olaf Beckman
    Jesus Alberto Olmos Linares
    Kajimba
    Maria Figueiredo
    Alexandr Galperin
    Francesco Siddi
    Julio Iglesias Lopez
    Kjartan Tysdal
    Thomas Torfs
    Film Works
    Teruyuki Nakamura
    Roger Luethi
    Benoit Bolsee
    Stefan Abrahamsen
    Andreas Mattijat
    Xavier Bouchoux
    Blender 3D Graphics and Animation
    Henk Vostermans
    Daniel Blanco Delgado
    BlenderDay/2011
    Bradley Cathey
    Matthieu Dupont de Dinechin
    Gianmichele Mariani
    Jérôme Scaillet

Bronze (Ivo Grigull, Dylan Urquidi, Philippe Derungs, Phil Beauchamp, Bruce Parrott, Mathieu Quiblier, Daniel Martinez, Leandro Inocencio, Lluc Romaní Brasó, 
Jonathan Williamson, Michael Ehlen, Karlis Stigis, Dreamsteep, Martin Lindelöf, Filippo Saracino, Douwe van der Veen, Olli Äkräs, Bruno D'Arcangeli, 
Francisco Sedrez Warmling, Watchmike.ca, peter lener, Matteo Novellino, Martin Kirsch, Austars Schnore, KC Elliott, Massimiliano Puliero, Karl Stein, 
Wood Design Studios, Omer Khan, Jyrki Kanto, Michał Krupa, Lars Brubaker, Neil Richmond, Adam Kalisz, Robert Garlington, Ian Wilson, Carlo Andreacchio, 
Jeremias Boos, Robert Holcomb, Gabriel Zöller, Robert Cude, Natibel de Leon, Nathan Turnage, Nicolas Vergnes, Philipp Kleinhenz, Norman Hartig, Louis Kreusel, 
Christopher Taylor, Giovanni Remondini, Daniel Rentzsch, Nico Partipilo, Thomas Ventresco, Johannes Schwarz, Александр Коротеев, Brendon Harvey, 
Marcelo G. Malheiros, Marius Giurgi, Richard Burns, Perttu Iso-Metsälä, Steve Bazin, Radoslav Borisov, Yoshiyuki Shida, Julien Guigner, Andrew Hunter, 
Philipp Oeser, Daniel Thul, Thobias Johansson, Mauro Bonecchi, Georg Piorczynski, Sebastian Michailidis, L M Weedy, Gen X, Stefan Hinze, Nicolò Zubbini, 
Erik Pusch, Rob Scott, Florian Koch, Charles Razack, Adrian Baker, Oliver Villar Diz, David Revoy, Julio Iglesias Lopez, Coen Spoor, Carlos Folch, 
Joseph Christie, Victor Hernández García, David Mcsween, James Finnerty, Cory Kruckenberg, Giacomo Graziosi, Olivier Saraja, Lars Brubaker, Eric Hudson, 
Johannes Schwarz, David Elguea, Marcus Schulderinsky, Karel De Bruijn, Lucas van Wijngaarden, Stefano Ciarrocchi, Mehmet Eribol, Thomas Berglund, Zuofei Song, 
Dylan Urquidi ) 

1 files changed, 247 insertions, 0 deletions

diff --git a/source/blender/compositor/intern/COM_NodeOperation.h b/source/blender/compositor/intern/COM_NodeOperation.h
new file mode 100644
index 00000000000..5dabc4db840
--- /dev/null
+++ b/source/blender/compositor/intern/COM_NodeOperation.h
@@ -0,0 +1,247 @@
+/*
+ * Copyright 2011, Blender Foundation.
+ *
+ * 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.
+ *
+ * Contributor: 
+ *		Jeroen Bakker 
+ *		Monique Dewanchand
+ */
+
+#ifndef _COM_NodeProgram_h
+#define _COM_NodeProgram_h
+
+class NodeOperation;
+
+#include "COM_Node.h"
+#include <string>
+#include <sstream>
+#include "COM_MemoryBuffer.h"
+#include "COM_MemoryProxy.h"
+#include "COM_SocketReader.h"
+#include "OCL_opencl.h"
+#include "list"
+
+class ReadBufferOperation;
+
+/**
+  * @brief NodeOperation are contains calculation logic
+  *
+  * Subclasses needs to implement the execution method (defined in SocketReader) to implement logic.
+  * @ingroup Model
+  */
+class NodeOperation : public NodeBase, public SocketReader {
+private:
+	/**
+	  * @brief the index of the input socket that will be used to determine the resolution
+	  */
+	unsigned int resolutionInputSocketIndex;
+
+	/**
+	  * @brief is this operation a complex one.
+	  *
+	  * Complex operations are typically doing many reads to calculate the output of a single pixel.
+	  * Mostly Filter types (Blurs, Convolution, Defocus etc) need this to be set to true.
+	  */
+	bool complex;
+
+	/**
+	  * @brief can this operation be scheduled on an OpenCL device.
+	  * @note Only applicable if complex is True
+	  */
+	bool openCL;
+
+	/**
+	  * @brief mutex reference for very special node initializations
+	  * @note only use when you really know what you are doing.
+	  * this mutex is used to share data among chunks in the same operation
+	  * @see TonemapOperation for an example of usage
+	  * @see NodeOperation.initMutex initializes this mutex
+	  * @see NodeOperation.deinitMutex deinitializes this mutex
+	  * @see NodeOperation.getMutex retrieve a pointer to this mutex.
+	  */
+	ThreadMutex mutex;
+
+public:
+	/**
+	  * @brief is this node an operation?
+	  * This is true when the instance is of the subclass NodeOperation.
+	  * @return [true:false]
+	  * @see NodeBase
+	  */
+	const int isOperation() const {return true;}
+
+	/**
+	  * @brief determine the resolution of this node
+	  * @note this method will not set the resolution, this is the responsibility of the caller
+	  * @param resolution the result of this operation
+	  * @param preferredResolution the preferrable resolution as no resolution could be determined
+	  */
+	virtual void determineResolution(unsigned int resolution[], unsigned int preferredResolution[]);
+
+	/**
+	  * @brief isOutputOperation determines whether this operation is an output of the ExecutionSystem during rendering or editing.
+	  *
+	  * Default behaviour if not overriden, this operation will not be evaluated as being an output of the ExecutionSystem.
+	  *
+	  * @see ExecutionSystem
+	  * @group check
+	  * @param rendering [true false]
+	  *  true: rendering
+	  *  false: editing
+	  *
+	  * @return bool the result of this method
+	  */
+	virtual bool isOutputOperation(bool rendering) const {return false;}
+
+	/**
+	  * isBufferOperation returns if this is an operation that work directly on buffers.
+	  *
+	  * there are only 2 implementation where this is true:
+	  * @see ReadBufferOperation
+	  * @see WriteBufferOperation
+	  * for all other operations this will result in false.
+	  */
+	virtual int isBufferOperation() {return false;}
+
+	virtual void initExecution();
+	void initMutex();
+	
+	/**
+	  * @brief when a chunk is executed by a CPUDevice, this method is called
+	  * @ingroup execution
+	  * @param rect the rectangle of the chunk (location and size)
+	  * @param chunkNumber the chunkNumber to be calculated
+	  * @param memoryBuffers all input MemoryBuffer's needed
+	  */
+	virtual void executeRegion(rcti *rect, unsigned int chunkNumber, MemoryBuffer** memoryBuffers) {}
+
+	/**
+	  * @brief when a chunk is executed by an OpenCLDevice, this method is called
+	  * @ingroup execution
+	  * @note this method is only implemented in WriteBufferOperation
+	  * @param context the OpenCL context
+	  * @param program the OpenCL program containing all compositor kernels
+	  * @param queue the OpenCL command queue of the device the chunk is executed on
+	  * @param rect the rectangle of the chunk (location and size)
+	  * @param chunkNumber the chunkNumber to be calculated
+	  * @param memoryBuffers all input MemoryBuffer's needed
+	  */
+	virtual void executeOpenCLRegion(cl_context context, cl_program program, cl_command_queue queue, rcti *rect, unsigned int chunkNumber, MemoryBuffer** memoryBuffers) {}
+
+	/**
+	  * @brief custom handle to add new tasks to the OpenCL command queue in order to execute a chunk on an GPUDevice
+	  * @ingroup execution
+	  * @param context the OpenCL context
+	  * @param program the OpenCL program containing all compositor kernels
+	  * @param queue the OpenCL command queue of the device the chunk is executed on
+	  * @param outputMemoryBuffer the allocated memory buffer in main CPU memory
+	  * @param clOutputBuffer the allocated memory buffer in OpenCLDevice memory
+	  * @param inputMemoryBuffers all input MemoryBuffer's needed
+	  * @param clMemToCleanUp all created cl_mem references must be added to this list. Framework will clean this after execution
+	  * @param clKernelsToCleanUp all created cl_kernel references must be added to this list. Framework will clean this after execution
+	  */
+	virtual void executeOpenCL(cl_context context,cl_program program, cl_command_queue queue, MemoryBuffer* outputMemoryBuffer, cl_mem clOutputBuffer, MemoryBuffer** inputMemoryBuffers, list<cl_mem> *clMemToCleanUp, list<cl_kernel> *clKernelsToCleanUp) {}
+	virtual void deinitExecution();
+	void deinitMutex();
+
+	/**
+	  * @brief set the resolution
+	  * @param resolution the resolution to set
+	  */
+	void setResolution(unsigned int resolution[]) {this->width = resolution[0];this->height = resolution[1];}
+	void getConnectedInputSockets(vector<InputSocket*> *sockets);
+
+	/**
+	  * @brief is this operation complex
+	  *
+	  * Complex operations are typically doing many reads to calculate the output of a single pixel.
+	  * Mostly Filter types (Blurs, Convolution, Defocus etc) need this to be set to true.
+	  */
+	const bool isComplex() const {return this->complex;}
+	virtual const bool isSetOperation() const {return false;}
+
+	/**
+	  * @brief is this operation of type ReadBufferOperation
+	  * @return [true:false]
+	  * @see ReadBufferOperation
+	  */
+	virtual const bool isReadBufferOperation() const {return false;}
+
+	/**
+	  * @brief is this operation of type WriteBufferOperation
+	  * @return [true:false]
+	  * @see WriteBufferOperation
+	  */
+	virtual const bool isWriteBufferOperation() const {return false;}
+
+	/**
+	  * @brief is this operation the active viewer output
+	  * user can select an ViewerNode to be active (the result of this node will be drawn on the backdrop)
+	  * @return [true:false]
+	  * @see BaseViewerOperation
+	  */
+	virtual const bool isActiveViewerOutput() const {return false;}
+
+	virtual bool determineDependingAreaOfInterest(rcti * input, ReadBufferOperation* readOperation, rcti* output);
+
+	/**
+	  * @brief set the index of the input socket that will determine the resolution of this operation
+	  * @param index the index to set
+	  */
+	void setResolutionInputSocketIndex(unsigned int index);
+
+	/**
+	  * @brief get the render priority of this node.
+	  * @note only applicable for output operations like ViewerOperation
+	  * @return [0:9] 9 is highest priority
+	  */
+	virtual const int getRenderPriority() const {return 0;}
+
+	/**
+	  * @brief can this NodeOperation be scheduled on an OpenCLDevice
+	  * @see WorkScheduler.schedule
+	  * @see ExecutionGroup.addOperation
+	  */
+	bool isOpenCL() { return this->openCL; }
+	
+	virtual bool isViewerOperation() {return false;}
+protected:
+	NodeOperation();
+
+	void setWidth(unsigned int width) {this->width = width;}
+	void setHeight(unsigned int height) {this->height= height;}
+	SocketReader* getInputSocketReader(unsigned int inputSocketindex);
+	NodeOperation* getInputOperation(unsigned int inputSocketindex);
+
+	inline ThreadMutex* getMutex() {return &this->mutex;}
+
+	/**
+	  * @brief set whether this operation is complex
+	  *
+	  * Complex operations are typically doing many reads to calculate the output of a single pixel.
+	  * Mostly Filter types (Blurs, Convolution, Defocus etc) need this to be set to true.
+	  */
+	void setComplex(bool complex) {this->complex = complex;}
+
+	/**
+	  * @brief set if this NodeOperation can be scheduled on a OpenCLDevice
+	  */
+	void setOpenCL(bool openCL) {this->openCL = openCL;}
+
+
+};
+
+#endif