tmaq
/
tornavis
1
0
Fork 0
Code Issues 2 Pull Requests 29 Packages Projects 24 Releases Wiki Activity

Cleanup: replace doxy @ with backslash 

The rest of Blender uses backslashes.
This commit is contained in:
Campbell Barton 2018-09-05 14:56:29 +10:00
parent 1be265afc0
commit 44d4a61ed0
130 changed files with 817 additions and 817 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

126
source/blender/compositor/COM_compositor.h
View File

@ -31,26 +31,26 @@ extern "C" {
#include "DNA_node_types.h" #include "DNA_node_types.h"
/** /**
* @defgroup Model The data model of the compositor * \defgroup Model The data model of the compositor
* @defgroup Memory The memory management stuff * \defgroup Memory The memory management stuff
* @defgroup Execution The execution logic * \defgroup Execution The execution logic
* @defgroup Conversion Conversion logic * \defgroup Conversion Conversion logic
* @defgroup Node All nodes of the compositor * \defgroup Node All nodes of the compositor
* @defgroup Operation All operations of the compositor * \defgroup Operation All operations of the compositor
* *
* @page Introduction of the Blender Compositor * \page Introduction of the Blender Compositor
* *
* @section bcomp Blender compositor * \section bcomp Blender compositor
* This project redesigns the internals of Blender's compositor. The project has been executed in 2011 by At Mind. * This project redesigns the internals of Blender's compositor. The project has been executed in 2011 by At Mind.
* At Mind is a technology company located in Amsterdam, The Netherlands. * At Mind is a technology company located in Amsterdam, The Netherlands.
* The project has been crowd-funded. This code has been released under GPL2 to be used in Blender. * The project has been crowd-funded. This code has been released under GPL2 to be used in Blender.
* *
* @section goals The goals of the project * \section goals The goals of the project
* the new compositor has 2 goals. * the new compositor has 2 goals.
* - Make a faster compositor (speed of calculation) * - Make a faster compositor (speed of calculation)
* - Make the compositor work faster for you (workflow) * - Make the compositor work faster for you (workflow)
* *
* @section speed Faster compositor * \section speed Faster compositor
* The speedup has been done by making better use of the hardware Blenders is working on. The previous compositor only * The speedup has been done by making better use of the hardware Blenders is working on. The previous compositor only
* used a single threaded model to calculate a node. The only exception to this is the Defocus node. * used a single threaded model to calculate a node. The only exception to this is the Defocus node.
* Only when it is possible to calculate two full nodes in parallel a second thread was used. * Only when it is possible to calculate two full nodes in parallel a second thread was used.
@ -59,27 +59,27 @@ extern "C" {
* In the new compositor we want to use as much of threads as possible. Even new OpenCL capable GPU-hardware can be * In the new compositor we want to use as much of threads as possible. Even new OpenCL capable GPU-hardware can be
* used for calculation. * used for calculation.
* *
* @section workflow Work faster * \section workflow Work faster
* The previous compositor only showed the final image. The compositor could wait a long time before seeing the result * The previous compositor only showed the final image. The compositor could wait a long time before seeing the result
* of his work. The new compositor will work in a way that it will focus on getting information back to the user. * of his work. The new compositor will work in a way that it will focus on getting information back to the user.
* It will prioritize its work to get earlier user feedback. * It will prioritize its work to get earlier user feedback.
* *
* @page memory Memory model * \page memory Memory model
* The main issue is the type of memory model to use. Blender is used by consumers and professionals. * The main issue is the type of memory model to use. Blender is used by consumers and professionals.
* Ranging from low-end machines to very high-end machines. * Ranging from low-end machines to very high-end machines.
* The system should work on high-end machines and on low-end machines. * The system should work on high-end machines and on low-end machines.
* *
* *
* @page executing Executing * \page executing Executing
* @section prepare Prepare execution * \section prepare Prepare execution
* *
* during the preparation of the execution All ReadBufferOperation will receive an offset. * during the preparation of the execution All ReadBufferOperation will receive an offset.
* This offset is used during execution as an optimization trick * This offset is used during execution as an optimization trick
* Next all operations will be initialized for execution @see NodeOperation.initExecution * Next all operations will be initialized for execution \see NodeOperation.initExecution
* Next all ExecutionGroup's will be initialized for execution @see ExecutionGroup.initExecution * Next all ExecutionGroup's will be initialized for execution \see ExecutionGroup.initExecution
* this all is controlled from @see ExecutionSystem.execute * this all is controlled from \see ExecutionSystem.execute
* *
* @section priority Render priority * \section priority Render priority
* Render priority is an priority of an output node. A user has a different need of Render priorities of output nodes * Render priority is an priority of an output node. A user has a different need of Render priorities of output nodes
* than during editing. * than during editing.
* for example. the Active ViewerNode has top priority during editing, but during rendering a CompositeNode has. * for example. the Active ViewerNode has top priority during editing, but during rendering a CompositeNode has.
@ -88,11 +88,11 @@ extern "C" {
* priority do match. * priority do match.
* When match the ExecutionGroup will be executed (this happens in serial) * When match the ExecutionGroup will be executed (this happens in serial)
* *
* @see ExecutionSystem.execute control of the Render priority * \see ExecutionSystem.execute control of the Render priority
* @see NodeOperation.getRenderPriority receive the render priority * \see NodeOperation.getRenderPriority receive the render priority
* @see ExecutionGroup.execute the main loop to execute a whole ExecutionGroup * \see ExecutionGroup.execute the main loop to execute a whole ExecutionGroup
* *
* @section order Chunk order * \section order Chunk order
* *
* When a ExecutionGroup is executed, first the order of chunks are determined. * When a ExecutionGroup is executed, first the order of chunks are determined.
* The settings are stored in the ViewerNode inside the ExecutionGroup. ExecutionGroups that have no viewer-node, * The settings are stored in the ViewerNode inside the ExecutionGroup. ExecutionGroups that have no viewer-node,
@ -109,11 +109,11 @@ extern "C" {
* - [@ref ChunkExecutionState.COM_ES_SCHEDULED]: All dependencies are met, chunk is scheduled, but not finished * - [@ref ChunkExecutionState.COM_ES_SCHEDULED]: All dependencies are met, chunk is scheduled, but not finished
* - [@ref ChunkExecutionState.COM_ES_EXECUTED]: Chunk is finished * - [@ref ChunkExecutionState.COM_ES_EXECUTED]: Chunk is finished
* *
* @see ExecutionGroup.execute * \see ExecutionGroup.execute
* @see ViewerOperation.getChunkOrder * \see ViewerOperation.getChunkOrder
* @see OrderOfChunks * \see OrderOfChunks
* *
* @section interest Area of interest * \section interest Area of interest
* An ExecutionGroup can have dependencies to other ExecutionGroup's. Data passing from one ExecutionGroup to another * An ExecutionGroup can have dependencies to other ExecutionGroup's. Data passing from one ExecutionGroup to another
* one are stored in 'chunks'. * one are stored in 'chunks'.
* If not all input chunks are available the chunk execution will not be scheduled. * If not all input chunks are available the chunk execution will not be scheduled.
@ -206,40 +206,40 @@ extern "C" {
* *
* </pre> * </pre>
* *
* @see ExecutionGroup.execute Execute a complete ExecutionGroup. Halts until finished or breaked by user * \see ExecutionGroup.execute Execute a complete ExecutionGroup. Halts until finished or breaked by user
* @see ExecutionGroup.scheduleChunkWhenPossible Tries to schedule a single chunk, * \see ExecutionGroup.scheduleChunkWhenPossible Tries to schedule a single chunk,
* checks if all input data is available. Can trigger dependent chunks to be calculated * checks if all input data is available. Can trigger dependent chunks to be calculated
* @see ExecutionGroup.scheduleAreaWhenPossible Tries to schedule an area. This can be multiple chunks * \see ExecutionGroup.scheduleAreaWhenPossible Tries to schedule an area. This can be multiple chunks
* (is called from [@ref ExecutionGroup.scheduleChunkWhenPossible]) * (is called from [@ref ExecutionGroup.scheduleChunkWhenPossible])
* @see ExecutionGroup.scheduleChunk Schedule a chunk on the WorkScheduler * \see ExecutionGroup.scheduleChunk Schedule a chunk on the WorkScheduler
* @see NodeOperation.determineDependingAreaOfInterest Influence the area of interest of a chunk. * \see NodeOperation.determineDependingAreaOfInterest Influence the area of interest of a chunk.
* @see WriteBufferOperation Operation to write to a MemoryProxy/MemoryBuffer * \see WriteBufferOperation Operation to write to a MemoryProxy/MemoryBuffer
* @see ReadBufferOperation Operation to read from a MemoryProxy/MemoryBuffer * \see ReadBufferOperation Operation to read from a MemoryProxy/MemoryBuffer
* @see MemoryProxy proxy for information about memory image (a image consist out of multiple chunks) * \see MemoryProxy proxy for information about memory image (a image consist out of multiple chunks)
* @see MemoryBuffer Allocated memory for a single chunk * \see MemoryBuffer Allocated memory for a single chunk
* *
* @section workscheduler WorkScheduler * \section workscheduler WorkScheduler
* the WorkScheduler is implemented as a static class. the responsibility of the WorkScheduler is to balance * the WorkScheduler is implemented as a static class. the responsibility of the WorkScheduler is to balance
* WorkPackages to the available and free devices. * WorkPackages to the available and free devices.
* the work-scheduler can work in 2 states. For witching these between the state you need to recompile blender * the work-scheduler can work in 2 states. For witching these between the state you need to recompile blender
* *
* @subsection multithread Multi threaded * \subsection multithread Multi threaded
* Default the work-scheduler will place all work as WorkPackage in a queue. * Default the work-scheduler will place all work as WorkPackage in a queue.
* For every CPUcore a working thread is created. These working threads will ask the WorkScheduler if there is work * For every CPUcore a working thread is created. These working threads will ask the WorkScheduler if there is work
* for a specific Device. * for a specific Device.
* the work-scheduler will find work for the device and the device will be asked to execute the WorkPackage * the work-scheduler will find work for the device and the device will be asked to execute the WorkPackage
* *
* @subsection singlethread Single threaded * \subsection singlethread Single threaded
* For debugging reasons the multi-threading can be disabled. This is done by changing the COM_CURRENT_THREADING_MODEL * For debugging reasons the multi-threading can be disabled. This is done by changing the COM_CURRENT_THREADING_MODEL
* to COM_TM_NOTHREAD. When compiling the work-scheduler * to COM_TM_NOTHREAD. When compiling the work-scheduler
* will be changes to support no threading and run everything on the CPU. * will be changes to support no threading and run everything on the CPU.
* *
* @section devices Devices * \section devices Devices
* A Device within the compositor context is a Hardware component that can used to calculate chunks. * A Device within the compositor context is a Hardware component that can used to calculate chunks.
* This chunk is encapsulated in a WorkPackage. * This chunk is encapsulated in a WorkPackage.
* the WorkScheduler controls the devices and selects the device where a WorkPackage will be calculated. * the WorkScheduler controls the devices and selects the device where a WorkPackage will be calculated.
* *
* @subsection WS_Devices Workscheduler * \subsection WS_Devices Workscheduler
* The WorkScheduler controls all Devices. When initializing the compositor the WorkScheduler selects * The WorkScheduler controls all Devices. When initializing the compositor the WorkScheduler selects
* all devices that will be used during compositor. * all devices that will be used during compositor.
* There are two types of Devices, CPUDevice and OpenCLDevice. * There are two types of Devices, CPUDevice and OpenCLDevice.
@ -251,63 +251,63 @@ extern "C" {
* *
* A thread will read the work-list and sends a workpackage to its device. * A thread will read the work-list and sends a workpackage to its device.
* *
* @see WorkScheduler.schedule method that is called to schedule a chunk * \see WorkScheduler.schedule method that is called to schedule a chunk
* @see Device.execute method called to execute a chunk * \see Device.execute method called to execute a chunk
* *
* @subsection CPUDevice CPUDevice * \subsection CPUDevice CPUDevice
* When a CPUDevice gets a WorkPackage the Device will get the inputbuffer that is needed to calculate the chunk. * When a CPUDevice gets a WorkPackage the Device will get the inputbuffer that is needed to calculate the chunk.
* Allocation is already done by the ExecutionGroup. * Allocation is already done by the ExecutionGroup.
* The outputbuffer of the chunk is being created. * The outputbuffer of the chunk is being created.
* The OutputOperation of the ExecutionGroup is called to execute the area of the outputbuffer. * The OutputOperation of the ExecutionGroup is called to execute the area of the outputbuffer.
* *
* @see ExecutionGroup * \see ExecutionGroup
* @see NodeOperation.executeRegion executes a single chunk of a NodeOperation * \see NodeOperation.executeRegion executes a single chunk of a NodeOperation
* @see CPUDevice.execute * \see CPUDevice.execute
* *
* @subsection GPUDevice OpenCLDevice * \subsection GPUDevice OpenCLDevice
* *
* To be completed! * To be completed!
* @see NodeOperation.executeOpenCLRegion * \see NodeOperation.executeOpenCLRegion
* @see OpenCLDevice.execute * \see OpenCLDevice.execute
* *
* @section executePixel executing a pixel * \section executePixel executing a pixel
* Finally the last step, the node functionality :) * Finally the last step, the node functionality :)
* *
* @page newnode Creating new nodes * \page newnode Creating new nodes
*/ */
/** /**
* @brief The main method that is used to execute the compositor tree. * \brief The main method that is used to execute the compositor tree.
* It can be executed during editing (blenkernel/node.c) or rendering * It can be executed during editing (blenkernel/node.c) or rendering
* (renderer/pipeline.c) * (renderer/pipeline.c)
* *
* @param rd [struct RenderData] * \param rd [struct RenderData]
* Render data for this composite, this won't always belong to a scene. * Render data for this composite, this won't always belong to a scene.
* *
* @param editingtree [struct bNodeTree] * \param editingtree [struct bNodeTree]
* reference to the compositor editing tree * reference to the compositor editing tree
* *
* @param rendering [true false] * \param rendering [true false]
* This parameter determines whether the function is called from rendering (true) or editing (false). * This parameter determines whether the function is called from rendering (true) or editing (false).
* based on this setting the system will work differently: * based on this setting the system will work differently:
* - during rendering only Composite & the File output node will be calculated * - during rendering only Composite & the File output node will be calculated
* @see NodeOperation.isOutputProgram(int rendering) of the specific operations * \see NodeOperation.isOutputProgram(int rendering) of the specific operations
* *
* - during editing all output nodes will be calculated * - during editing all output nodes will be calculated
* @see NodeOperation.isOutputProgram(int rendering) of the specific operations * \see NodeOperation.isOutputProgram(int rendering) of the specific operations
* *
* - another quality setting can be used bNodeTree. The quality is determined by the bNodeTree fields. * - another quality setting can be used bNodeTree. The quality is determined by the bNodeTree fields.
* quality can be modified by the user from within the node panels. * quality can be modified by the user from within the node panels.
* @see bNodeTree.edit_quality * \see bNodeTree.edit_quality
* @see bNodeTree.render_quality * \see bNodeTree.render_quality
* *
* - output nodes can have different priorities in the WorkScheduler. * - output nodes can have different priorities in the WorkScheduler.
* This is implemented in the COM_execute function. * This is implemented in the COM_execute function.
* *
* @param viewSettings * \param viewSettings
* reference to view settings used for color management * reference to view settings used for color management
* *
* @param displaySettings * \param displaySettings
* reference to display settings used for color management * reference to display settings used for color management
* *
* OCIO_TODO: this options only used in rare cases, namely in output file node, * OCIO_TODO: this options only used in rare cases, namely in output file node,
@ -320,13 +320,13 @@ void COM_execute(RenderData *rd, Scene *scene, bNodeTree *editingtree, int rende
const char *viewName); const char *viewName);
/** /**
* @brief Deinitialize the compositor caches and allocated memory. * \brief Deinitialize the compositor caches and allocated memory.
* Use COM_clearCaches to only free the caches. * Use COM_clearCaches to only free the caches.
*/ */
void COM_deinitialize(void); void COM_deinitialize(void);
/** /**
* @brief Clear all compositor caches. (Compositor system will still remain available). * \brief Clear all compositor caches. (Compositor system will still remain available).
* To deinitialize the compositor use the COM_deinitialize method. * To deinitialize the compositor use the COM_deinitialize method.
*/ */
// void COM_clearCaches(void); // NOT YET WRITTEN // void COM_clearCaches(void); // NOT YET WRITTEN

44
source/blender/compositor/COM_defines.h
View File

@ -24,42 +24,42 @@
#define __COM_DEFINES_H__ #define __COM_DEFINES_H__
/** /**
* @brief possible data types for sockets * \brief possible data types for sockets
* @ingroup Model * \ingroup Model
*/ */
typedef enum DataType { typedef enum DataType {
/** @brief Value data type */ /** \brief Value data type */
COM_DT_VALUE = 1, COM_DT_VALUE = 1,
/** @brief Vector data type */ /** \brief Vector data type */
COM_DT_VECTOR = 2, COM_DT_VECTOR = 2,
/** @brief Color data type */ /** \brief Color data type */
COM_DT_COLOR = 4 COM_DT_COLOR = 4
} DataType; } DataType;
/** /**
* @brief Possible quality settings * \brief Possible quality settings
* @see CompositorContext.quality * \see CompositorContext.quality
* @ingroup Execution * \ingroup Execution
*/ */
typedef enum CompositorQuality { typedef enum CompositorQuality {
/** @brief High quality setting */ /** \brief High quality setting */
COM_QUALITY_HIGH = 0, COM_QUALITY_HIGH = 0,
/** @brief Medium quality setting */ /** \brief Medium quality setting */
COM_QUALITY_MEDIUM = 1, COM_QUALITY_MEDIUM = 1,
/** @brief Low quality setting */ /** \brief Low quality setting */
COM_QUALITY_LOW = 2 COM_QUALITY_LOW = 2
} CompositorQuality; } CompositorQuality;
/** /**
* @brief Possible priority settings * \brief Possible priority settings
* @ingroup Execution * \ingroup Execution
*/ */
typedef enum CompositorPriority { typedef enum CompositorPriority {
/** @brief High quality setting */ /** \brief High quality setting */
COM_PRIORITY_HIGH = 2, COM_PRIORITY_HIGH = 2,
/** @brief Medium quality setting */ /** \brief Medium quality setting */
COM_PRIORITY_MEDIUM = 1, COM_PRIORITY_MEDIUM = 1,
/** @brief Low quality setting */ /** \brief Low quality setting */
COM_PRIORITY_LOW = 0 COM_PRIORITY_LOW = 0
} CompositorPriority; } CompositorPriority;
@ -87,17 +87,17 @@ typedef enum CompositorPriority {
#define COM_CURRENT_THREADING_MODEL COM_TM_QUEUE #define COM_CURRENT_THREADING_MODEL COM_TM_QUEUE
// chunk order // chunk order
/** /**
* @brief The order of chunks to be scheduled * \brief The order of chunks to be scheduled
* @ingroup Execution * \ingroup Execution
*/ */
typedef enum OrderOfChunks { typedef enum OrderOfChunks {
/** @brief order from a distance to centerX/centerY */ /** \brief order from a distance to centerX/centerY */
COM_TO_CENTER_OUT = 0, COM_TO_CENTER_OUT = 0,
/** @brief order randomly */ /** \brief order randomly */
COM_TO_RANDOM = 1, COM_TO_RANDOM = 1,
/** @brief no ordering */ /** \brief no ordering */
COM_TO_TOP_DOWN = 2, COM_TO_TOP_DOWN = 2,
/** @brief experimental ordering with 9 hotspots */ /** \brief experimental ordering with 9 hotspots */
COM_TO_RULE_OF_THIRDS = 3 COM_TO_RULE_OF_THIRDS = 3
} OrderOfChunks; } OrderOfChunks;

8
source/blender/compositor/intern/COM_CPUDevice.h
View File

@ -26,16 +26,16 @@
#include "COM_Device.h" #include "COM_Device.h"
/** /**
* @brief class representing a CPU device. * \brief class representing a CPU device.
* @note for every hardware thread in the system a CPUDevice instance will exist in the workscheduler * \note for every hardware thread in the system a CPUDevice instance will exist in the workscheduler
*/ */
class CPUDevice : public Device { class CPUDevice : public Device {
public: public:
CPUDevice(int thread_id); CPUDevice(int thread_id);
/** /**
* @brief execute a WorkPackage * \brief execute a WorkPackage
* @param work the WorkPackage to execute * \param work the WorkPackage to execute
*/ */
void execute(WorkPackage *work); void execute(WorkPackage *work);

68
source/blender/compositor/intern/COM_CompositorContext.h
View File

@ -32,98 +32,98 @@
#include "COM_defines.h" #include "COM_defines.h"
/** /**
* @brief Overall context of the compositor * \brief Overall context of the compositor
*/ */
class CompositorContext { class CompositorContext {
private: private:
/** /**
* @brief The rendering field describes if we are rendering (F12) or if we are editing (Node editor) * \brief The rendering field describes if we are rendering (F12) or if we are editing (Node editor)
* This field is initialized in ExecutionSystem and must only be read from that point on. * This field is initialized in ExecutionSystem and must only be read from that point on.
* @see ExecutionSystem * \see ExecutionSystem
*/ */
bool m_rendering; bool m_rendering;
/** /**
* @brief The quality of the composite. * \brief The quality of the composite.
* This field is initialized in ExecutionSystem and must only be read from that point on. * This field is initialized in ExecutionSystem and must only be read from that point on.
* @see ExecutionSystem * \see ExecutionSystem
*/ */
CompositorQuality m_quality; CompositorQuality m_quality;
Scene *m_scene; Scene *m_scene;
/** /**
* @brief Reference to the render data that is being composited. * \brief Reference to the render data that is being composited.
* This field is initialized in ExecutionSystem and must only be read from that point on. * This field is initialized in ExecutionSystem and must only be read from that point on.
* @see ExecutionSystem * \see ExecutionSystem
*/ */
RenderData *m_rd; RenderData *m_rd;
/** /**
* @brief reference to the bNodeTree * \brief reference to the bNodeTree
* This field is initialized in ExecutionSystem and must only be read from that point on. * This field is initialized in ExecutionSystem and must only be read from that point on.
* @see ExecutionSystem * \see ExecutionSystem
*/ */
bNodeTree *m_bnodetree; bNodeTree *m_bnodetree;
/** /**
* @brief Preview image hash table * \brief Preview image hash table
* This field is initialized in ExecutionSystem and must only be read from that point on. * This field is initialized in ExecutionSystem and must only be read from that point on.
*/ */
bNodeInstanceHash *m_previews; bNodeInstanceHash *m_previews;
/** /**
* @brief does this system have active opencl devices? * \brief does this system have active opencl devices?
*/ */
bool m_hasActiveOpenCLDevices; bool m_hasActiveOpenCLDevices;
/** /**
* @brief Skip slow nodes * \brief Skip slow nodes
*/ */
bool m_fastCalculation; bool m_fastCalculation;
/* @brief color management settings */ /* \brief color management settings */
const ColorManagedViewSettings *m_viewSettings; const ColorManagedViewSettings *m_viewSettings;
const ColorManagedDisplaySettings *m_displaySettings; const ColorManagedDisplaySettings *m_displaySettings;
/** /**
* @brief active rendering view name * \brief active rendering view name
*/ */
const char *m_viewName; const char *m_viewName;
public: public:
/** /**
* @brief constructor initializes the context with default values. * \brief constructor initializes the context with default values.
*/ */
CompositorContext(); CompositorContext();
/** /**
* @brief set the rendering field of the context * \brief set the rendering field of the context
*/ */
void setRendering(bool rendering) { this->m_rendering = rendering; } void setRendering(bool rendering) { this->m_rendering = rendering; }
/** /**
* @brief get the rendering field of the context * \brief get the rendering field of the context
*/ */
bool isRendering() const { return this->m_rendering; } bool isRendering() const { return this->m_rendering; }
/** /**
* @brief set the scene of the context * \brief set the scene of the context
*/ */
void setRenderData(RenderData *rd) { this->m_rd = rd; } void setRenderData(RenderData *rd) { this->m_rd = rd; }
/** /**
* @brief set the bnodetree of the context * \brief set the bnodetree of the context
*/ */
void setbNodeTree(bNodeTree *bnodetree) { this->m_bnodetree = bnodetree; } void setbNodeTree(bNodeTree *bnodetree) { this->m_bnodetree = bnodetree; }
/** /**
* @brief get the bnodetree of the context * \brief get the bnodetree of the context
*/ */
const bNodeTree *getbNodeTree() const { return this->m_bnodetree; } const bNodeTree *getbNodeTree() const { return this->m_bnodetree; }
/** /**
* @brief get the scene of the context * \brief get the scene of the context
*/ */
const RenderData *getRenderData() const { return this->m_rd; } const RenderData *getRenderData() const { return this->m_rd; }
@ -131,67 +131,67 @@ public:
Scene *getScene() const { return m_scene; } Scene *getScene() const { return m_scene; }
/** /**
* @brief set the preview image hash table * \brief set the preview image hash table
*/ */
void setPreviewHash(bNodeInstanceHash *previews) { this->m_previews = previews; } void setPreviewHash(bNodeInstanceHash *previews) { this->m_previews = previews; }
/** /**
* @brief get the preview image hash table * \brief get the preview image hash table
*/ */
bNodeInstanceHash *getPreviewHash() const { return this->m_previews; } bNodeInstanceHash *getPreviewHash() const { return this->m_previews; }
/** /**
* @brief set view settings of color color management * \brief set view settings of color color management
*/ */
void setViewSettings(const ColorManagedViewSettings *viewSettings) { this->m_viewSettings = viewSettings; } void setViewSettings(const ColorManagedViewSettings *viewSettings) { this->m_viewSettings = viewSettings; }
/** /**
* @brief get view settings of color color management * \brief get view settings of color color management
*/ */
const ColorManagedViewSettings *getViewSettings() const { return this->m_viewSettings; } const ColorManagedViewSettings *getViewSettings() const { return this->m_viewSettings; }
/** /**
* @brief set display settings of color color management * \brief set display settings of color color management
*/ */
void setDisplaySettings(const ColorManagedDisplaySettings *displaySettings) { this->m_displaySettings = displaySettings; } void setDisplaySettings(const ColorManagedDisplaySettings *displaySettings) { this->m_displaySettings = displaySettings; }
/** /**
* @brief get display settings of color color management * \brief get display settings of color color management
*/ */
const ColorManagedDisplaySettings *getDisplaySettings() const { return this->m_displaySettings; } const ColorManagedDisplaySettings *getDisplaySettings() const { return this->m_displaySettings; }
/** /**
* @brief set the quality * \brief set the quality
*/ */
void setQuality(CompositorQuality quality) { this->m_quality = quality; } void setQuality(CompositorQuality quality) { this->m_quality = quality; }
/** /**
* @brief get the quality * \brief get the quality
*/ */
const CompositorQuality getQuality() const { return this->m_quality; } const CompositorQuality getQuality() const { return this->m_quality; }
/** /**
* @brief get the current framenumber of the scene in this context * \brief get the current framenumber of the scene in this context
*/ */
const int getFramenumber() const; const int getFramenumber() const;
/** /**
* @brief has this system active openclDevices? * \brief has this system active openclDevices?
*/ */
const bool getHasActiveOpenCLDevices() const { return this->m_hasActiveOpenCLDevices; } const bool getHasActiveOpenCLDevices() const { return this->m_hasActiveOpenCLDevices; }
/** /**
* @brief set has this system active openclDevices? * \brief set has this system active openclDevices?
*/ */
void setHasActiveOpenCLDevices(bool hasAvtiveOpenCLDevices) { this->m_hasActiveOpenCLDevices = hasAvtiveOpenCLDevices; } void setHasActiveOpenCLDevices(bool hasAvtiveOpenCLDevices) { this->m_hasActiveOpenCLDevices = hasAvtiveOpenCLDevices; }
/** /**
* @brief get the active rendering view * \brief get the active rendering view
*/ */
const char *getViewName() const { return this->m_viewName; } const char *getViewName() const { return this->m_viewName; }
/** /**
* @brief set the active rendering view * \brief set the active rendering view
*/ */
void setViewName(const char *viewName) { this->m_viewName = viewName; } void setViewName(const char *viewName) { this->m_viewName = viewName; }

32
source/blender/compositor/intern/COM_Converter.h
View File

@ -36,48 +36,48 @@ class NodeOperationOutput;
class NodeOperationBuilder; class NodeOperationBuilder;
/** /**
* @brief Conversion methods for the compositor * \brief Conversion methods for the compositor
*/ */
class Converter { class Converter {
public: public:
/** /**
* @brief Convert/wraps a bNode in its Node instance. * \brief Convert/wraps a bNode in its Node instance.
* *
* For all nodetypes a wrapper class is created. * For all nodetypes a wrapper class is created.
* *
* @note When adding a new node to blender, this method needs to be changed to return the correct Node instance. * \note When adding a new node to blender, this method needs to be changed to return the correct Node instance.
* *
* @see Node * \see Node
*/ */
static Node *convert(bNode *b_node); static Node *convert(bNode *b_node);
/** /**
* @brief True if the node is considered 'fast'. * \brief True if the node is considered 'fast'.
* *
* Slow nodes will be skipped if fast execution is required. * Slow nodes will be skipped if fast execution is required.
*/ */
static bool is_fast_node(bNode *b_node); static bool is_fast_node(bNode *b_node);
/** /**
* @brief This method will add a datetype conversion rule when the to-socket does not support the from-socket actual data type. * \brief This method will add a datetype conversion rule when the to-socket does not support the from-socket actual data type.
* *
* @note this method is called when conversion is needed. * \note this method is called when conversion is needed.
* *
* @param link the NodeLink what needs conversion * \param link the NodeLink what needs conversion
* @param system the ExecutionSystem to add the conversion to. * \param system the ExecutionSystem to add the conversion to.
* @see NodeLink - a link between two sockets * \see NodeLink - a link between two sockets
*/ */
static NodeOperation *convertDataType(NodeOperationOutput *from, NodeOperationInput *to); static NodeOperation *convertDataType(NodeOperationOutput *from, NodeOperationInput *to);
/** /**
* @brief This method will add a resolution rule based on the settings of the NodeInput. * \brief This method will add a resolution rule based on the settings of the NodeInput.
* *
* @note Conversion logic is implemented in this method * \note Conversion logic is implemented in this method
* @see InputSocketResizeMode for the possible conversions. * \see InputSocketResizeMode for the possible conversions.
* *
* @param link the NodeLink what needs conversion * \param link the NodeLink what needs conversion
* @param system the ExecutionSystem to add the conversion to. * \param system the ExecutionSystem to add the conversion to.
* @see NodeLink - a link between two sockets * \see NodeLink - a link between two sockets
*/ */
static void convertResolution(NodeOperationBuilder &builder, NodeOperationOutput *fromSocket, NodeOperationInput *toSocket); static void convertResolution(NodeOperationBuilder &builder, NodeOperationOutput *fromSocket, NodeOperationInput *toSocket);

14
source/blender/compositor/intern/COM_Device.h
View File

@ -26,7 +26,7 @@
#include "COM_WorkPackage.h" #include "COM_WorkPackage.h"
/** /**
* @brief Abstract class for device implementations to be used by the Compositor. * \brief Abstract class for device implementations to be used by the Compositor.
* devices are queried, initialized and used by the WorkScheduler. * devices are queried, initialized and used by the WorkScheduler.
* work are packaged as a WorkPackage instance. * work are packaged as a WorkPackage instance.
*/ */
@ -34,24 +34,24 @@ class Device {
public: public:
/** /**
* @brief Declaration of the virtual destructor * \brief Declaration of the virtual destructor
* @note resolve warning gcc 4.7 * \note resolve warning gcc 4.7
*/ */
virtual ~Device() {} virtual ~Device() {}
/** /**
* @brief initialize the device * \brief initialize the device
*/ */
virtual bool initialize() { return true; } virtual bool initialize() { return true; }
/** /**
* @brief deinitialize the device * \brief deinitialize the device
*/ */
virtual void deinitialize() {} virtual void deinitialize() {}
/** /**
* @brief execute a WorkPackage * \brief execute a WorkPackage
* @param work the WorkPackage to execute * \param work the WorkPackage to execute
*/ */
virtual void execute(WorkPackage *work) = 0; virtual void execute(WorkPackage *work) = 0;

6
source/blender/compositor/intern/COM_ExecutionGroup.cpp
View File

@ -185,9 +185,9 @@ void ExecutionGroup::execute(ExecutionSystem *graph)
{ {
const CompositorContext &context = graph->getContext(); const CompositorContext &context = graph->getContext();
const bNodeTree *bTree = context.getbNodeTree(); const bNodeTree *bTree = context.getbNodeTree();
if (this->m_width == 0 || this->m_height == 0) {return; } /// @note: break out... no pixels to calculate. if (this->m_width == 0 || this->m_height == 0) {return; } /// \note: break out... no pixels to calculate.
if (bTree->test_break && bTree->test_break(bTree->tbh)) {return; } /// @note: early break out for blur and preview nodes if (bTree->test_break && bTree->test_break(bTree->tbh)) {return; } /// \note: early break out for blur and preview nodes
if (this->m_numberOfChunks == 0) {return; } /// @note: early break out if (this->m_numberOfChunks == 0) {return; } /// \note: early break out
unsigned int chunkNumber; unsigned int chunkNumber;
this->m_executionStartTime = PIL_check_seconds_timer(); this->m_executionStartTime = PIL_check_seconds_timer();

248
source/blender/compositor/intern/COM_ExecutionGroup.h
View File

@ -39,28 +39,28 @@ class ReadBufferOperation;
class Device; class Device;
/** /**
* @brief the execution state of a chunk in an ExecutionGroup * \brief the execution state of a chunk in an ExecutionGroup
* @ingroup Execution * \ingroup Execution
*/ */
typedef enum ChunkExecutionState { typedef enum ChunkExecutionState {
/** /**
* @brief chunk is not yet scheduled * \brief chunk is not yet scheduled
*/ */
COM_ES_NOT_SCHEDULED = 0, COM_ES_NOT_SCHEDULED = 0,
/** /**
* @brief chunk is scheduled, but not yet executed * \brief chunk is scheduled, but not yet executed
*/ */
COM_ES_SCHEDULED = 1, COM_ES_SCHEDULED = 1,
/** /**
* @brief chunk is executed. * \brief chunk is executed.
*/ */
COM_ES_EXECUTED = 2 COM_ES_EXECUTED = 2
} ChunkExecutionState; } ChunkExecutionState;
/** /**
* @brief Class ExecutionGroup is a group of Operations that are executed as one. * \brief Class ExecutionGroup is a group of Operations that are executed as one.
* This grouping is used to combine Operations that can be executed as one whole when multi-processing. * This grouping is used to combine Operations that can be executed as one whole when multi-processing.
* @ingroup Execution * \ingroup Execution
*/ */
class ExecutionGroup { class ExecutionGroup {
public: public:
@ -70,86 +70,86 @@ private:
// fields // fields
/** /**
* @brief list of operations in this ExecutionGroup * \brief list of operations in this ExecutionGroup
*/ */
Operations m_operations; Operations m_operations;
/** /**
* @brief is this ExecutionGroup an input ExecutionGroup * \brief is this ExecutionGroup an input ExecutionGroup
* an input execution group is a group that is at the end of the calculation (the output is important for the user) * an input execution group is a group that is at the end of the calculation (the output is important for the user)
*/ */
int m_isOutput; int m_isOutput;
/** /**
* @brief Width of the output * \brief Width of the output
*/ */
unsigned int m_width; unsigned int m_width;
/** /**
* @brief Height of the output * \brief Height of the output
*/ */
unsigned int m_height; unsigned int m_height;
/** /**
* @brief size of a single chunk, being Width or of height * \brief size of a single chunk, being Width or of height
* a chunk is always a square, except at the edges of the MemoryBuffer * a chunk is always a square, except at the edges of the MemoryBuffer
*/ */
unsigned int m_chunkSize; unsigned int m_chunkSize;
/** /**
* @brief number of chunks in the x-axis * \brief number of chunks in the x-axis
*/ */
unsigned int m_numberOfXChunks; unsigned int m_numberOfXChunks;
/** /**
* @brief number of chunks in the y-axis * \brief number of chunks in the y-axis
*/ */
unsigned int m_numberOfYChunks; unsigned int m_numberOfYChunks;
/** /**
* @brief total number of chunks * \brief total number of chunks
*/ */
unsigned int m_numberOfChunks; unsigned int m_numberOfChunks;
/** /**
* @brief contains this ExecutionGroup a complex NodeOperation. * \brief contains this ExecutionGroup a complex NodeOperation.
*/ */
bool m_complex; bool m_complex;
/** /**
* @brief can this ExecutionGroup be scheduled on an OpenCLDevice * \brief can this ExecutionGroup be scheduled on an OpenCLDevice
*/ */
bool m_openCL; bool m_openCL;
/** /**
* @brief Is this Execution group SingleThreaded * \brief Is this Execution group SingleThreaded
*/ */
bool m_singleThreaded; bool m_singleThreaded;
/** /**
* @brief what is the maximum number field of all ReadBufferOperation in this ExecutionGroup. * \brief what is the maximum number field of all ReadBufferOperation in this ExecutionGroup.
* @note this is used to construct the MemoryBuffers that will be passed during execution. * \note this is used to construct the MemoryBuffers that will be passed during execution.
*/ */
unsigned int m_cachedMaxReadBufferOffset; unsigned int m_cachedMaxReadBufferOffset;
/** /**
* @brief a cached vector of all read operations in the execution group. * \brief a cached vector of all read operations in the execution group.
*/ */
Operations m_cachedReadOperations; Operations m_cachedReadOperations;
/** /**
* @brief reference to the original bNodeTree, this field is only set for the 'top' execution group. * \brief reference to the original bNodeTree, this field is only set for the 'top' execution group.
* @note can only be used to call the callbacks for progress, status and break * \note can only be used to call the callbacks for progress, status and break
*/ */
const bNodeTree *m_bTree; const bNodeTree *m_bTree;
/** /**
* @brief total number of chunks that have been calculated for this ExecutionGroup * \brief total number of chunks that have been calculated for this ExecutionGroup
*/ */
unsigned int m_chunksFinished; unsigned int m_chunksFinished;
/** /**
* @brief the chunkExecutionStates holds per chunk the execution state. this state can be * \brief the chunkExecutionStates holds per chunk the execution state. this state can be
* - COM_ES_NOT_SCHEDULED: not scheduled * - COM_ES_NOT_SCHEDULED: not scheduled
* - COM_ES_SCHEDULED: scheduled * - COM_ES_SCHEDULED: scheduled
* - COM_ES_EXECUTED: executed * - COM_ES_EXECUTED: executed
@ -157,92 +157,92 @@ private:
ChunkExecutionState *m_chunkExecutionStates; ChunkExecutionState *m_chunkExecutionStates;
/** /**
* @brief indicator when this ExecutionGroup has valid Operations in its vector for Execution * \brief indicator when this ExecutionGroup has valid Operations in its vector for Execution
* @note When building the ExecutionGroup Operations are added via recursion. First a WriteBufferOperations is added, then the * \note When building the ExecutionGroup Operations are added via recursion. First a WriteBufferOperations is added, then the
* @note Operation containing the settings that is important for the ExecutiongGroup is added, * \note Operation containing the settings that is important for the ExecutiongGroup is added,
* @note When this occurs, these settings are copied over from the node to the ExecutionGroup * \note When this occurs, these settings are copied over from the node to the ExecutionGroup
* @note and the Initialized flag is set to true. * \note and the Initialized flag is set to true.
* @see complex * \see complex
* @see openCL * \see openCL
*/ */
bool m_initialized; bool m_initialized;
/** /**
* @brief denotes boundary for border compositing * \brief denotes boundary for border compositing
* @note measured in pixel space * \note measured in pixel space
*/ */
rcti m_viewerBorder; rcti m_viewerBorder;
/** /**
* @brief start time of execution * \brief start time of execution
*/ */
double m_executionStartTime; double m_executionStartTime;
// methods // methods
/** /**
* @brief check whether parameter operation can be added to the execution group * \brief check whether parameter operation can be added to the execution group
* @param operation the operation to be added * \param operation the operation to be added
*/ */
bool canContainOperation(NodeOperation *operation); bool canContainOperation(NodeOperation *operation);
/** /**
* @brief calculate the actual chunk size of this execution group. * \brief calculate the actual chunk size of this execution group.
* @note A chunk size is an unsigned int that is both the height and width of a chunk. * \note A chunk size is an unsigned int that is both the height and width of a chunk.
* @note The chunk size will not be stored in the chunkSize field. This needs to be done * \note The chunk size will not be stored in the chunkSize field. This needs to be done
* @note by the calling method. * \note by the calling method.
*/ */
unsigned int determineChunkSize(); unsigned int determineChunkSize();
/** /**
* @brief Determine the rect (minx, maxx, miny, maxy) of a chunk at a position. * \brief Determine the rect (minx, maxx, miny, maxy) of a chunk at a position.
* @note Only gives useful results ater the determination of the chunksize * \note Only gives useful results ater the determination of the chunksize
* @see determineChunkSize() * \see determineChunkSize()
*/ */
void determineChunkRect(rcti *rect, const unsigned int xChunk, const unsigned int yChunk) const; void determineChunkRect(rcti *rect, const unsigned int xChunk, const unsigned int yChunk) const;
/** /**
* @brief determine the number of chunks, based on the chunkSize, width and height. * \brief determine the number of chunks, based on the chunkSize, width and height.
* @note The result are stored in the fields numberOfChunks, numberOfXChunks, numberOfYChunks * \note The result are stored in the fields numberOfChunks, numberOfXChunks, numberOfYChunks
*/ */
void determineNumberOfChunks(); void determineNumberOfChunks();
/** /**
* @brief try to schedule a specific chunk. * \brief try to schedule a specific chunk.
* @note scheduling succeeds when all input requirements are met and the chunks hasn't been scheduled yet. * \note scheduling succeeds when all input requirements are met and the chunks hasn't been scheduled yet.
* @param graph * \param graph
* @param xChunk * \param xChunk
* @param yChunk * \param yChunk
* @return [true:false] * \return [true:false]
* true: package(s) are scheduled * true: package(s) are scheduled
* false: scheduling is deferred (depending workpackages are scheduled) * false: scheduling is deferred (depending workpackages are scheduled)
*/ */
bool scheduleChunkWhenPossible(ExecutionSystem *graph, int xChunk, int yChunk); bool scheduleChunkWhenPossible(ExecutionSystem *graph, int xChunk, int yChunk);
/** /**
* @brief try to schedule a specific area. * \brief try to schedule a specific area.
* @note Check if a certain area is available, when not available this are will be checked. * \note Check if a certain area is available, when not available this are will be checked.
* @note This method is called from other ExecutionGroup's. * \note This method is called from other ExecutionGroup's.
* @param graph * \param graph
* @param rect * \param rect
* @return [true:false] * \return [true:false]
* true: package(s) are scheduled * true: package(s) are scheduled
* false: scheduling is deferred (depending workpackages are scheduled) * false: scheduling is deferred (depending workpackages are scheduled)
*/ */
bool scheduleAreaWhenPossible(ExecutionSystem *graph, rcti *rect); bool scheduleAreaWhenPossible(ExecutionSystem *graph, rcti *rect);
/** /**
* @brief add a chunk to the WorkScheduler. * \brief add a chunk to the WorkScheduler.
* @param chunknumber * \param chunknumber
*/ */
bool scheduleChunk(unsigned int chunkNumber); bool scheduleChunk(unsigned int chunkNumber);
/** /**
* @brief determine the area of interest of a certain input area * \brief determine the area of interest of a certain input area
* @note This method only evaluates a single ReadBufferOperation * \note This method only evaluates a single ReadBufferOperation
* @param input the input area * \param input the input area
* @param readOperation The ReadBufferOperation where the area needs to be evaluated * \param readOperation The ReadBufferOperation where the area needs to be evaluated
* @param output the area needed of the ReadBufferOperation. Result * \param output the area needed of the ReadBufferOperation. Result
*/ */
void determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output); void determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output);
@ -253,116 +253,116 @@ public:
// methods // methods
/** /**
* @brief add an operation to this ExecutionGroup * \brief add an operation to this ExecutionGroup
* @note this method will add input of the operations recursively * \note this method will add input of the operations recursively
* @note this method can create multiple ExecutionGroup's * \note this method can create multiple ExecutionGroup's
* @param system * \param system
* @param operation * \param operation
* @return True if the operation was successfully added * \return True if the operation was successfully added
*/ */
bool addOperation(NodeOperation *operation); bool addOperation(NodeOperation *operation);
/** /**
* @brief is this ExecutionGroup an output ExecutionGroup * \brief is this ExecutionGroup an output ExecutionGroup
* @note An OutputExecution group are groups containing a * \note An OutputExecution group are groups containing a
* @note ViewerOperation, CompositeOperation, PreviewOperation. * \note ViewerOperation, CompositeOperation, PreviewOperation.
* @see NodeOperation.isOutputOperation * \see NodeOperation.isOutputOperation
*/ */
const int isOutputExecutionGroup() const { return this->m_isOutput; } const int isOutputExecutionGroup() const { return this->m_isOutput; }
/** /**
* @brief set whether this ExecutionGroup is an output * \brief set whether this ExecutionGroup is an output
* @param isOutput * \param isOutput
*/ */
void setOutputExecutionGroup(int isOutput) { this->m_isOutput = isOutput; } void setOutputExecutionGroup(int isOutput) { this->m_isOutput = isOutput; }
/** /**
* @brief determine the resolution of this ExecutionGroup * \brief determine the resolution of this ExecutionGroup
* @param resolution * \param resolution
*/ */
void determineResolution(unsigned int resolution[2]); void determineResolution(unsigned int resolution[2]);
/** /**
* @brief set the resolution of this executiongroup * \brief set the resolution of this executiongroup
* @param resolution * \param resolution
*/ */
void setResolution(unsigned int resolution[2]) { this->m_width = resolution[0]; this->m_height = resolution[1]; } void setResolution(unsigned int resolution[2]) { this->m_width = resolution[0]; this->m_height = resolution[1]; }
/** /**
* @brief get the width of this execution group * \brief get the width of this execution group
*/ */
unsigned int getWidth() const { return m_width; } unsigned int getWidth() const { return m_width; }
/** /**
* @brief get the height of this execution group * \brief get the height of this execution group
*/ */
unsigned int getHeight() const { return m_height; } unsigned int getHeight() const { return m_height; }
/** /**
* @brief does this ExecutionGroup contains a complex NodeOperation * \brief does this ExecutionGroup contains a complex NodeOperation
*/ */
bool isComplex() const { return m_complex; } bool isComplex() const { return m_complex; }
/** /**
* @brief get the output operation of this ExecutionGroup * \brief get the output operation of this ExecutionGroup
* @return NodeOperation *output operation * \return NodeOperation *output operation
*/ */
NodeOperation *getOutputOperation() const; NodeOperation *getOutputOperation() const;
/** /**
* @brief compose multiple chunks into a single chunk * \brief compose multiple chunks into a single chunk
* @return Memorybuffer *consolidated chunk * \return Memorybuffer *consolidated chunk
*/ */
MemoryBuffer *constructConsolidatedMemoryBuffer(MemoryProxy *memoryProxy, rcti *output); MemoryBuffer *constructConsolidatedMemoryBuffer(MemoryProxy *memoryProxy, rcti *output);
/** /**
* @brief initExecution is called just before the execution of the whole graph will be done. * \brief initExecution is called just before the execution of the whole graph will be done.
* @note The implementation will calculate the chunkSize of this execution group. * \note The implementation will calculate the chunkSize of this execution group.
*/ */
void initExecution(); void initExecution();
/** /**
* @brief get all inputbuffers needed to calculate an chunk * \brief get all inputbuffers needed to calculate an chunk
* @note all inputbuffers must be executed * \note all inputbuffers must be executed
* @param chunkNumber the chunk to be calculated * \param chunkNumber the chunk to be calculated
* @return (MemoryBuffer **) the inputbuffers * \return (MemoryBuffer **) the inputbuffers
*/ */
MemoryBuffer **getInputBuffersCPU(); MemoryBuffer **getInputBuffersCPU();
/** /**
* @brief get all inputbuffers needed to calculate an chunk * \brief get all inputbuffers needed to calculate an chunk
* @note all inputbuffers must be executed * \note all inputbuffers must be executed
* @param chunkNumber the chunk to be calculated * \param chunkNumber the chunk to be calculated
* @return (MemoryBuffer **) the inputbuffers * \return (MemoryBuffer **) the inputbuffers
*/ */
MemoryBuffer **getInputBuffersOpenCL(int chunkNumber); MemoryBuffer **getInputBuffersOpenCL(int chunkNumber);
/** /**
* @brief allocate the outputbuffer of a chunk * \brief allocate the outputbuffer of a chunk
* @param chunkNumber the number of the chunk in the ExecutionGroup * \param chunkNumber the number of the chunk in the ExecutionGroup
* @param rect the rect of that chunk * \param rect the rect of that chunk
* @see determineChunkRect * \see determineChunkRect
*/ */
MemoryBuffer *allocateOutputBuffer(int chunkNumber, rcti *rect); MemoryBuffer *allocateOutputBuffer(int chunkNumber, rcti *rect);
/** /**
* @brief after a chunk is executed the needed resources can be freed or unlocked. * \brief after a chunk is executed the needed resources can be freed or unlocked.
* @param chunknumber * \param chunknumber
* @param memorybuffers * \param memorybuffers
*/ */
void finalizeChunkExecution(int chunkNumber, MemoryBuffer **memoryBuffers); void finalizeChunkExecution(int chunkNumber, MemoryBuffer **memoryBuffers);
/** /**
* @brief deinitExecution is called just after execution the whole graph. * \brief deinitExecution is called just after execution the whole graph.
* @note It will release all needed resources * \note It will release all needed resources
*/ */
void deinitExecution(); void deinitExecution();
/** /**
* @brief schedule an ExecutionGroup * \brief schedule an ExecutionGroup
* @note this method will return when all chunks have been calculated, or the execution has breaked (by user) * \note this method will return when all chunks have been calculated, or the execution has breaked (by user)
* *
* first the order of the chunks will be determined. This is determined by finding the ViewerOperation and get the relevant information from it. * first the order of the chunks will be determined. This is determined by finding the ViewerOperation and get the relevant information from it.
* - ChunkOrdering * - ChunkOrdering
@ -371,43 +371,43 @@ public:
* *
* After determining the order of the chunks the chunks will be scheduled * After determining the order of the chunks the chunks will be scheduled
* *
* @see ViewerOperation * \see ViewerOperation
* @param system * \param system
*/ */
void execute(ExecutionSystem *system); void execute(ExecutionSystem *system);
/** /**
* @brief this method determines the MemoryProxy's where this execution group depends on. * \brief this method determines the MemoryProxy's where this execution group depends on.
* @note After this method determineDependingAreaOfInterest can be called to determine * \note After this method determineDependingAreaOfInterest can be called to determine
* @note the area of the MemoryProxy.creator that has to be executed. * \note the area of the MemoryProxy.creator that has to be executed.
* @param memoryProxies result * \param memoryProxies result
*/ */
void determineDependingMemoryProxies(vector<MemoryProxy *> *memoryProxies); void determineDependingMemoryProxies(vector<MemoryProxy *> *memoryProxies);
/** /**
* @brief Determine the rect (minx, maxx, miny, maxy) of a chunk. * \brief Determine the rect (minx, maxx, miny, maxy) of a chunk.
* @note Only gives useful results ater the determination of the chunksize * \note Only gives useful results ater the determination of the chunksize
* @see determineChunkSize() * \see determineChunkSize()
*/ */
void determineChunkRect(rcti *rect, const unsigned int chunkNumber) const; void determineChunkRect(rcti *rect, const unsigned int chunkNumber) const;
/** /**
* @brief can this ExecutionGroup be scheduled on an OpenCLDevice * \brief can this ExecutionGroup be scheduled on an OpenCLDevice
* @see WorkScheduler.schedule * \see WorkScheduler.schedule
*/ */
bool isOpenCL(); bool isOpenCL();
void setChunksize(int chunksize) { this->m_chunkSize = chunksize; } void setChunksize(int chunksize) { this->m_chunkSize = chunksize; }
/** /**
* @brief get the Render priority of this ExecutionGroup * \brief get the Render priority of this ExecutionGroup
* @see ExecutionSystem.execute * \see ExecutionSystem.execute
*/ */
CompositorPriority getRenderPriotrity(); CompositorPriority getRenderPriotrity();
/** /**
* @brief set border for viewer operation * \brief set border for viewer operation
* @note all the coordinates are assumed to be in normalized space * \note all the coordinates are assumed to be in normalized space
*/ */
void setViewerBorder(float xmin, float xmax, float ymin, float ymax); void setViewerBorder(float xmin, float xmax, float ymin, float ymax);

56
source/blender/compositor/intern/COM_ExecutionSystem.h
View File

@ -33,23 +33,23 @@ class ExecutionGroup;
#include "COM_NodeOperation.h" #include "COM_NodeOperation.h"
/** /**
* @page execution Execution model * \page execution Execution model
* In order to get to an efficient model for execution, several steps are being done. these steps are explained below. * In order to get to an efficient model for execution, several steps are being done. these steps are explained below.
* *
* @section EM_Step1 Step 1: translating blender node system to the new compsitor system * \section EM_Step1 Step 1: translating blender node system to the new compsitor system
* Blenders node structure is based on C structs (DNA). These structs are not efficient in the new architecture. * Blenders node structure is based on C structs (DNA). These structs are not efficient in the new architecture.
* We want to use classes in order to simplify the system. * We want to use classes in order to simplify the system.
* during this step the blender node_tree is evaluated and converted to a CPP node system. * during this step the blender node_tree is evaluated and converted to a CPP node system.
* *
* @see ExecutionSystem * \see ExecutionSystem
* @see Converter.convert * \see Converter.convert
* @see Node * \see Node
* *
* @section EM_Step2 Step2: translating nodes to operations * \section EM_Step2 Step2: translating nodes to operations
* Ungrouping the GroupNodes. Group nodes are node_tree's in node_tree's. * Ungrouping the GroupNodes. Group nodes are node_tree's in node_tree's.
* The new system only supports a single level of node_tree. We will 'flatten' the system in a single level. * The new system only supports a single level of node_tree. We will 'flatten' the system in a single level.
* @see GroupNode * \see GroupNode
* @see ExecutionSystemHelper.ungroup * \see ExecutionSystemHelper.ungroup
* *
* Every node has the ability to convert itself to operations. The node itself is responsible to create a correct * Every node has the ability to convert itself to operations. The node itself is responsible to create a correct
* NodeOperation setup based on its internal settings. * NodeOperation setup based on its internal settings.
@ -59,11 +59,11 @@ class ExecutionGroup;
* based on the selected Mixtype a different operation will be used. * based on the selected Mixtype a different operation will be used.
* for more information see the page about creating new Nodes. [@subpage newnode] * for more information see the page about creating new Nodes. [@subpage newnode]
* *
* @see ExecutionSystem.convertToOperations * \see ExecutionSystem.convertToOperations
* @see Node.convertToOperations * \see Node.convertToOperations
* @see NodeOperation base class for all operations in the system * \see NodeOperation base class for all operations in the system
* *
* @section EM_Step3 Step3: add additional conversions to the operation system * \section EM_Step3 Step3: add additional conversions to the operation system
* - Data type conversions: the system has 3 data types COM_DT_VALUE, COM_DT_VECTOR, COM_DT_COLOR. * - Data type conversions: the system has 3 data types COM_DT_VALUE, COM_DT_VECTOR, COM_DT_COLOR.
* The user can connect a Value socket to a color socket. * The user can connect a Value socket to a color socket.
* As values are ordered differently than colors a conversion happens. * As values are ordered differently than colors a conversion happens.
@ -77,10 +77,10 @@ class ExecutionGroup;
* - [@ref InputSocketResizeMode.COM_SC_STRETCH]: The width and the height of both images are aligned * - [@ref InputSocketResizeMode.COM_SC_STRETCH]: The width and the height of both images are aligned
* - [@ref InputSocketResizeMode.COM_SC_NO_RESIZE]: bottom left of the images are aligned. * - [@ref InputSocketResizeMode.COM_SC_NO_RESIZE]: bottom left of the images are aligned.
* *
* @see Converter.convertDataType Datatype conversions * \see Converter.convertDataType Datatype conversions
* @see Converter.convertResolution Image size conversions * \see Converter.convertResolution Image size conversions
* *
* @section EM_Step4 Step4: group operations in executions groups * \section EM_Step4 Step4: group operations in executions groups
* ExecutionGroup are groups of operations that are calculated as being one bigger operation. * ExecutionGroup are groups of operations that are calculated as being one bigger operation.
* All operations will be part of an ExecutionGroup. * All operations will be part of an ExecutionGroup.
* Complex nodes will be added to separate groups. Between ExecutionGroup's the data will be stored in MemoryBuffers. * Complex nodes will be added to separate groups. Between ExecutionGroup's the data will be stored in MemoryBuffers.
@ -101,14 +101,14 @@ class ExecutionGroup;
* |cFAA | |cFAA | |cFAA | |cFAA | * |cFAA | |cFAA | |cFAA | |cFAA |
* +------+ +------+ +-------+ +-------+ * +------+ +------+ +-------+ +-------+
* </pre> * </pre>
* @see ExecutionSystem.groupOperations method doing this step * \see ExecutionSystem.groupOperations method doing this step
* @see ExecutionSystem.addReadWriteBufferOperations * \see ExecutionSystem.addReadWriteBufferOperations
* @see NodeOperation.isComplex * \see NodeOperation.isComplex
* @see ExecutionGroup class representing the ExecutionGroup * \see ExecutionGroup class representing the ExecutionGroup
*/ */
/** /**
* @brief the ExecutionSystem contains the whole compositor tree. * \brief the ExecutionSystem contains the whole compositor tree.
*/ */
class ExecutionSystem { class ExecutionSystem {
public: public:
@ -117,17 +117,17 @@ public:
private: private:
/** /**
* @brief the context used during execution * \brief the context used during execution
*/ */
CompositorContext m_context; CompositorContext m_context;
/** /**
* @brief vector of operations * \brief vector of operations
*/ */
Operations m_operations; Operations m_operations;
/** /**
* @brief vector of groups * \brief vector of groups
*/ */
Groups m_groups; Groups m_groups;
@ -144,11 +144,11 @@ private: //methods
public: public:
/** /**
* @brief Create a new ExecutionSystem and initialize it with the * \brief Create a new ExecutionSystem and initialize it with the
* editingtree. * editingtree.
* *
* @param editingtree [bNodeTree *] * \param editingtree [bNodeTree *]
* @param rendering [true false] * \param rendering [true false]
*/ */
ExecutionSystem(RenderData *rd, Scene *scene, bNodeTree *editingtree, bool rendering, bool fastcalculation, ExecutionSystem(RenderData *rd, Scene *scene, bNodeTree *editingtree, bool rendering, bool fastcalculation,
const ColorManagedViewSettings *viewSettings, const ColorManagedDisplaySettings *displaySettings, const ColorManagedViewSettings *viewSettings, const ColorManagedDisplaySettings *displaySettings,
@ -162,7 +162,7 @@ public:
void set_operations(const Operations &operations, const Groups &groups); void set_operations(const Operations &operations, const Groups &groups);
/** /**
* @brief execute this system * \brief execute this system
* - initialize the NodeOperation's and ExecutionGroup's * - initialize the NodeOperation's and ExecutionGroup's
* - schedule the output ExecutionGroup's based on their priority * - schedule the output ExecutionGroup's based on their priority
* - deinitialize the ExecutionGroup's and NodeOperation's * - deinitialize the ExecutionGroup's and NodeOperation's
@ -170,7 +170,7 @@ public:
void execute(); void execute();
/** /**
* @brief get the reference to the compositor context * \brief get the reference to the compositor context
*/ */
const CompositorContext &getContext() const { return this->m_context; } const CompositorContext &getContext() const { return this->m_context; }

58
source/blender/compositor/intern/COM_MemoryBuffer.h
View File

@ -35,15 +35,15 @@ extern "C" {
} }
/** /**
* @brief state of a memory buffer * \brief state of a memory buffer
* @ingroup Memory * \ingroup Memory
*/ */
typedef enum MemoryBufferState { typedef enum MemoryBufferState {
/** @brief memory has been allocated on creator device and CPU machine, but kernel has not been executed */ /** \brief memory has been allocated on creator device and CPU machine, but kernel has not been executed */
COM_MB_ALLOCATED = 1, COM_MB_ALLOCATED = 1,
/** @brief memory is available for use, content has been created */ /** \brief memory is available for use, content has been created */
COM_MB_AVAILABLE = 2, COM_MB_AVAILABLE = 2,
/** @brief chunk is consolidated from other chunks. special state.*/ /** \brief chunk is consolidated from other chunks. special state.*/
COM_MB_TEMPORARILY = 6 COM_MB_TEMPORARILY = 6
} MemoryBufferState; } MemoryBufferState;
@ -56,44 +56,44 @@ typedef enum MemoryBufferExtend {
class MemoryProxy; class MemoryProxy;
/** /**
* @brief a MemoryBuffer contains access to the data of a chunk * \brief a MemoryBuffer contains access to the data of a chunk
*/ */
class MemoryBuffer { class MemoryBuffer {
private: private:
/** /**
* @brief proxy of the memory (same for all chunks in the same buffer) * \brief proxy of the memory (same for all chunks in the same buffer)
*/ */
MemoryProxy *m_memoryProxy; MemoryProxy *m_memoryProxy;
/** /**
* @brief the type of buffer COM_DT_VALUE, COM_DT_VECTOR, COM_DT_COLOR * \brief the type of buffer COM_DT_VALUE, COM_DT_VECTOR, COM_DT_COLOR
*/ */
DataType m_datatype; DataType m_datatype;
/** /**
* @brief region of this buffer inside relative to the MemoryProxy * \brief region of this buffer inside relative to the MemoryProxy
*/ */
rcti m_rect; rcti m_rect;
/** /**
* brief refers to the chunknumber within the executiongroup where related to the MemoryProxy * brief refers to the chunknumber within the executiongroup where related to the MemoryProxy
* @see memoryProxy * \see memoryProxy
*/ */
unsigned int m_chunkNumber; unsigned int m_chunkNumber;
/** /**
* @brief state of the buffer * \brief state of the buffer
*/ */
MemoryBufferState m_state; MemoryBufferState m_state;
/** /**
* @brief the actual float buffer/data * \brief the actual float buffer/data
*/ */
float *m_buffer; float *m_buffer;
/** /**
* @brief the number of channels of a single value in the buffer. * \brief the number of channels of a single value in the buffer.
* For value buffers this is 1, vector 3 and color 4 * For value buffers this is 1, vector 3 and color 4
*/ */
unsigned int m_num_channels; unsigned int m_num_channels;
@ -103,40 +103,40 @@ private:
public: public:
/** /**
* @brief construct new MemoryBuffer for a chunk * \brief construct new MemoryBuffer for a chunk
*/ */
MemoryBuffer(MemoryProxy *memoryProxy, unsigned int chunkNumber, rcti *rect); MemoryBuffer(MemoryProxy *memoryProxy, unsigned int chunkNumber, rcti *rect);
/** /**
* @brief construct new temporarily MemoryBuffer for an area * \brief construct new temporarily MemoryBuffer for an area
*/ */
MemoryBuffer(MemoryProxy *memoryProxy, rcti *rect); MemoryBuffer(MemoryProxy *memoryProxy, rcti *rect);
/** /**
* @brief construct new temporarily MemoryBuffer for an area * \brief construct new temporarily MemoryBuffer for an area
*/ */
MemoryBuffer(DataType datatype, rcti *rect); MemoryBuffer(DataType datatype, rcti *rect);
/** /**
* @brief destructor * \brief destructor
*/ */
~MemoryBuffer(); ~MemoryBuffer();
/** /**
* @brief read the ChunkNumber of this MemoryBuffer * \brief read the ChunkNumber of this MemoryBuffer
*/ */
unsigned int getChunkNumber() { return this->m_chunkNumber; } unsigned int getChunkNumber() { return this->m_chunkNumber; }
unsigned int get_num_channels() { return this->m_num_channels; } unsigned int get_num_channels() { return this->m_num_channels; }
/** /**
* @brief get the data of this MemoryBuffer * \brief get the data of this MemoryBuffer
* @note buffer should already be available in memory * \note buffer should already be available in memory
*/ */
float *getBuffer() { return this->m_buffer; } float *getBuffer() { return this->m_buffer; }
/** /**
* @brief after execution the state will be set to available by calling this method * \brief after execution the state will be set to available by calling this method
*/ */
void setCreatedState() void setCreatedState()
{ {
@ -273,36 +273,36 @@ public:
void readEWA(float *result, const float uv[2], const float derivatives[2][2]); void readEWA(float *result, const float uv[2], const float derivatives[2][2]);
/** /**
* @brief is this MemoryBuffer a temporarily buffer (based on an area, not on a chunk) * \brief is this MemoryBuffer a temporarily buffer (based on an area, not on a chunk)
*/ */
inline const bool isTemporarily() const { return this->m_state == COM_MB_TEMPORARILY; } inline const bool isTemporarily() const { return this->m_state == COM_MB_TEMPORARILY; }
/** /**
* @brief add the content from otherBuffer to this MemoryBuffer * \brief add the content from otherBuffer to this MemoryBuffer
* @param otherBuffer source buffer * \param otherBuffer source buffer
* *
* @note take care when running this on a new buffer since it wont fill in * \note take care when running this on a new buffer since it wont fill in
* uninitialized values in areas where the buffers don't overlap. * uninitialized values in areas where the buffers don't overlap.
*/ */
void copyContentFrom(MemoryBuffer *otherBuffer); void copyContentFrom(MemoryBuffer *otherBuffer);
/** /**
* @brief get the rect of this MemoryBuffer * \brief get the rect of this MemoryBuffer
*/ */
rcti *getRect() { return &this->m_rect; } rcti *getRect() { return &this->m_rect; }
/** /**
* @brief get the width of this MemoryBuffer * \brief get the width of this MemoryBuffer
*/ */
int getWidth() const; int getWidth() const;
/** /**
* @brief get the height of this MemoryBuffer * \brief get the height of this MemoryBuffer
*/ */
int getHeight() const; int getHeight() const;
/** /**
* @brief clear the buffer. Make all pixels black transparent. * \brief clear the buffer. Make all pixels black transparent.
*/ */
void clear(); void clear();

36
source/blender/compositor/intern/COM_MemoryProxy.h
View File

@ -31,40 +31,40 @@ class ExecutionGroup;
class WriteBufferOperation; class WriteBufferOperation;
/** /**
* @brief A MemoryProxy is a unique identifier for a memory buffer. * \brief A MemoryProxy is a unique identifier for a memory buffer.
* A single MemoryProxy is used among all chunks of the same buffer, * A single MemoryProxy is used among all chunks of the same buffer,
* the MemoryBuffer only stores the data of a single chunk. * the MemoryBuffer only stores the data of a single chunk.
* @ingroup Memory * \ingroup Memory
*/ */
class MemoryProxy { class MemoryProxy {
private: private:
/** /**
* @brief reference to the ouput operation of the executiongroup * \brief reference to the ouput operation of the executiongroup
*/ */
WriteBufferOperation *m_writeBufferOperation; WriteBufferOperation *m_writeBufferOperation;
/** /**
* @brief reference to the executor. the Execution group that can fill a chunk * \brief reference to the executor. the Execution group that can fill a chunk
*/ */
ExecutionGroup *m_executor; ExecutionGroup *m_executor;
/** /**
* @brief datatype of this MemoryProxy * \brief datatype of this MemoryProxy
*/ */
/* DataType m_datatype; */ /* UNUSED */ /* DataType m_datatype; */ /* UNUSED */
/** /**
* @brief channel information of this buffer * \brief channel information of this buffer
*/ */
/* ChannelInfo m_channelInfo[COM_NUMBER_OF_CHANNELS]; */ /* UNUSED */ /* ChannelInfo m_channelInfo[COM_NUMBER_OF_CHANNELS]; */ /* UNUSED */
/** /**
* @brief the allocated memory * \brief the allocated memory
*/ */
MemoryBuffer *m_buffer; MemoryBuffer *m_buffer;
/** /**
* @brief datatype of this MemoryProxy * \brief datatype of this MemoryProxy
*/ */
DataType m_datatype; DataType m_datatype;
@ -72,40 +72,40 @@ public:
MemoryProxy(DataType type); MemoryProxy(DataType type);
/** /**
* @brief set the ExecutionGroup that can be scheduled to calculate a certain chunk. * \brief set the ExecutionGroup that can be scheduled to calculate a certain chunk.
* @param group the ExecutionGroup to set * \param group the ExecutionGroup to set
*/ */
void setExecutor(ExecutionGroup *executor) { this->m_executor = executor; } void setExecutor(ExecutionGroup *executor) { this->m_executor = executor; }
/** /**
* @brief get the ExecutionGroup that can be scheduled to calculate a certain chunk. * \brief get the ExecutionGroup that can be scheduled to calculate a certain chunk.
*/ */
ExecutionGroup *getExecutor() { return this->m_executor; } ExecutionGroup *getExecutor() { return this->m_executor; }
/** /**
* @brief set the WriteBufferOperation that is responsible for writing to this MemoryProxy * \brief set the WriteBufferOperation that is responsible for writing to this MemoryProxy
* @param operation * \param operation
*/ */
void setWriteBufferOperation(WriteBufferOperation *operation) { this->m_writeBufferOperation = operation; } void setWriteBufferOperation(WriteBufferOperation *operation) { this->m_writeBufferOperation = operation; }
/** /**
* @brief get the WriteBufferOperation that is responsible for writing to this MemoryProxy * \brief get the WriteBufferOperation that is responsible for writing to this MemoryProxy
* @return WriteBufferOperation * \return WriteBufferOperation
*/ */
WriteBufferOperation *getWriteBufferOperation() { return this->m_writeBufferOperation; } WriteBufferOperation *getWriteBufferOperation() { return this->m_writeBufferOperation; }
/** /**
* @brief allocate memory of size width x height * \brief allocate memory of size width x height
*/ */
void allocate(unsigned int width, unsigned int height); void allocate(unsigned int width, unsigned int height);
/** /**
* @brief free the allocated memory * \brief free the allocated memory
*/ */
void free(); void free();
/** /**
* @brief get the allocated memory * \brief get the allocated memory
*/ */
inline MemoryBuffer *getBuffer() { return this->m_buffer; } inline MemoryBuffer *getBuffer() { return this->m_buffer; }

78
source/blender/compositor/intern/COM_Node.h
View File

@ -48,43 +48,43 @@ public:
private: private:
/** /**
* @brief stores the reference to the SDNA bNode struct * \brief stores the reference to the SDNA bNode struct
*/ */
bNodeTree *m_editorNodeTree; bNodeTree *m_editorNodeTree;
/** /**
* @brief stores the reference to the SDNA bNode struct * \brief stores the reference to the SDNA bNode struct
*/ */
bNode *m_editorNode; bNode *m_editorNode;
/** /**
* @brief the list of actual inputsockets @see NodeInput * \brief the list of actual inputsockets \see NodeInput
*/ */
Inputs m_inputsockets; Inputs m_inputsockets;
/** /**
* @brief the list of actual outputsockets @see NodeOutput * \brief the list of actual outputsockets \see NodeOutput
*/ */
Outputs m_outputsockets; Outputs m_outputsockets;
/** /**
* @brief Is this node part of the active group * \brief Is this node part of the active group
*/ */
bool m_inActiveGroup; bool m_inActiveGroup;
/** /**
* @brief Instance key to identify the node in an instance hash table * \brief Instance key to identify the node in an instance hash table
*/ */
bNodeInstanceKey m_instanceKey; bNodeInstanceKey m_instanceKey;
protected: protected:
/** /**
* @brief get access to the vector of input sockets * \brief get access to the vector of input sockets
*/ */
const Inputs &getInputSockets() const { return this->m_inputsockets; } const Inputs &getInputSockets() const { return this->m_inputsockets; }
/** /**
* @brief get access to the vector of input sockets * \brief get access to the vector of input sockets
*/ */
const Outputs &getOutputSockets() const { return this->m_outputsockets; } const Outputs &getOutputSockets() const { return this->m_outputsockets; }
@ -93,55 +93,55 @@ public:
virtual ~Node(); virtual ~Node();
/** /**
* @brief get the reference to the SDNA bNode struct * \brief get the reference to the SDNA bNode struct
*/ */
bNode *getbNode() const {return m_editorNode;} bNode *getbNode() const {return m_editorNode;}
/** /**
* @brief get the reference to the SDNA bNodeTree struct * \brief get the reference to the SDNA bNodeTree struct
*/ */
bNodeTree *getbNodeTree() const {return m_editorNodeTree;} bNodeTree *getbNodeTree() const {return m_editorNodeTree;}
/** /**
* @brief set the reference to the bNode * \brief set the reference to the bNode
* @note used in Node instances to receive the storage/settings and complex node for highlight during execution * \note used in Node instances to receive the storage/settings and complex node for highlight during execution
* @param bNode * \param bNode
*/ */
void setbNode(bNode *node) {this->m_editorNode = node;} void setbNode(bNode *node) {this->m_editorNode = node;}
/** /**
* @brief set the reference to the bNodeTree * \brief set the reference to the bNodeTree
* @param bNodeTree * \param bNodeTree
*/ */
void setbNodeTree(bNodeTree *nodetree) {this->m_editorNodeTree = nodetree;} void setbNodeTree(bNodeTree *nodetree) {this->m_editorNodeTree = nodetree;}
/** /**
* @brief Return the number of input sockets of this node. * \brief Return the number of input sockets of this node.
*/ */
const unsigned int getNumberOfInputSockets() const { return this->m_inputsockets.size(); } const unsigned int getNumberOfInputSockets() const { return this->m_inputsockets.size(); }
/** /**
* @brief Return the number of output sockets of this node. * \brief Return the number of output sockets of this node.
*/ */
const unsigned int getNumberOfOutputSockets() const { return this->m_outputsockets.size(); } const unsigned int getNumberOfOutputSockets() const { return this->m_outputsockets.size(); }
/** /**
* get the reference to a certain outputsocket * get the reference to a certain outputsocket
* @param index * \param index
* the index of the needed outputsocket * the index of the needed outputsocket
*/ */
NodeOutput *getOutputSocket(const unsigned int index) const; NodeOutput *getOutputSocket(const unsigned int index) const;
/** /**
* get the reference to the first outputsocket * get the reference to the first outputsocket
* @param index * \param index
* the index of the needed outputsocket * the index of the needed outputsocket
*/ */
inline NodeOutput *getOutputSocket() const { return getOutputSocket(0); } inline NodeOutput *getOutputSocket() const { return getOutputSocket(0); }
/** /**
* get the reference to a certain inputsocket * get the reference to a certain inputsocket
* @param index * \param index
* the index of the needed inputsocket * the index of the needed inputsocket
*/ */
NodeInput *getInputSocket(const unsigned int index) const; NodeInput *getInputSocket(const unsigned int index) const;
@ -152,26 +152,26 @@ public:
bool isInputNode() const { return m_inputsockets.empty(); } bool isInputNode() const { return m_inputsockets.empty(); }
/** /**
* @brief Is this node in the active group (the group that is being edited) * \brief Is this node in the active group (the group that is being edited)
* @param isInActiveGroup * \param isInActiveGroup
*/ */
void setIsInActiveGroup(bool value) { this->m_inActiveGroup = value; } void setIsInActiveGroup(bool value) { this->m_inActiveGroup = value; }
/** /**
* @brief Is this node part of the active group * \brief Is this node part of the active group
* the active group is the group that is currently being edited. When no group is edited, * the active group is the group that is currently being edited. When no group is edited,
* the active group will be the main tree (all nodes that are not part of a group will be active) * the active group will be the main tree (all nodes that are not part of a group will be active)
* @return bool [false:true] * \return bool [false:true]
*/ */
inline bool isInActiveGroup() const { return this->m_inActiveGroup; } inline bool isInActiveGroup() const { return this->m_inActiveGroup; }
/** /**
* @brief convert node to operation * \brief convert node to operation
* *
* @todo this must be described further * \todo this must be described further
* *
* @param system the ExecutionSystem where the operations need to be added * \param system the ExecutionSystem where the operations need to be added
* @param context reference to the CompositorContext * \param context reference to the CompositorContext
*/ */
virtual void convertToOperations(NodeConverter &converter, const CompositorContext &context) const = 0; virtual void convertToOperations(NodeConverter &converter, const CompositorContext &context) const = 0;
@ -191,17 +191,17 @@ public:
protected: protected:
/** /**
* @brief add an NodeInput to the collection of inputsockets * \brief add an NodeInput to the collection of inputsockets
* @note may only be called in an constructor * \note may only be called in an constructor
* @param socket the NodeInput to add * \param socket the NodeInput to add
*/ */
void addInputSocket(DataType datatype); void addInputSocket(DataType datatype);
void addInputSocket(DataType datatype, bNodeSocket *socket); void addInputSocket(DataType datatype, bNodeSocket *socket);
/** /**
* @brief add an NodeOutput to the collection of outputsockets * \brief add an NodeOutput to the collection of outputsockets
* @note may only be called in an constructor * \note may only be called in an constructor
* @param socket the NodeOutput to add * \param socket the NodeOutput to add
*/ */
void addOutputSocket(DataType datatype); void addOutputSocket(DataType datatype);
void addOutputSocket(DataType datatype, bNodeSocket *socket); void addOutputSocket(DataType datatype, bNodeSocket *socket);
@ -212,8 +212,8 @@ protected:
/** /**
* @brief NodeInput are sockets that can receive data/input * \brief NodeInput are sockets that can receive data/input
* @ingroup Model * \ingroup Model
*/ */
class NodeInput { class NodeInput {
private: private:
@ -223,7 +223,7 @@ private:
DataType m_datatype; DataType m_datatype;
/** /**
* @brief link connected to this NodeInput. * \brief link connected to this NodeInput.
* An input socket can only have a single link * An input socket can only have a single link
*/ */
NodeOutput *m_link; NodeOutput *m_link;
@ -246,8 +246,8 @@ public:
/** /**
* @brief NodeOutput are sockets that can send data/input * \brief NodeOutput are sockets that can send data/input
* @ingroup Model * \ingroup Model
*/ */
class NodeOutput { class NodeOutput {
private: private:

2
source/blender/compositor/intern/COM_NodeGraph.cpp
View File

@ -176,7 +176,7 @@ NodeOutput *NodeGraph::find_output(const NodeRange &node_range, bNodeSocket *b_s
void NodeGraph::add_bNodeLink(const NodeRange &node_range, bNodeLink *b_nodelink) void NodeGraph::add_bNodeLink(const NodeRange &node_range, bNodeLink *b_nodelink)
{ {
/// @note: ignore invalid links /// \note: ignore invalid links
if (!(b_nodelink->flag & NODE_LINK_VALID)) if (!(b_nodelink->flag & NODE_LINK_VALID))
return; return;
if ((b_nodelink->fromsock->flag & SOCK_UNAVAIL) || (b_nodelink->tosock->flag & SOCK_UNAVAIL)) if ((b_nodelink->fromsock->flag & SOCK_UNAVAIL) || (b_nodelink->tosock->flag & SOCK_UNAVAIL))

166
source/blender/compositor/intern/COM_NodeOperation.h
View File

@ -52,30 +52,30 @@ class NodeOperationInput;
class NodeOperationOutput; class NodeOperationOutput;
/** /**
* @brief Resize modes of inputsockets * \brief Resize modes of inputsockets
* How are the input and working resolutions matched * How are the input and working resolutions matched
* @ingroup Model * \ingroup Model
*/ */
typedef enum InputResizeMode { typedef enum InputResizeMode {
/** @brief Center the input image to the center of the working area of the node, no resizing occurs */ /** \brief Center the input image to the center of the working area of the node, no resizing occurs */
COM_SC_CENTER = NS_CR_CENTER, COM_SC_CENTER = NS_CR_CENTER,
/** @brief The bottom left of the input image is the bottom left of the working area of the node, no resizing occurs */ /** \brief The bottom left of the input image is the bottom left of the working area of the node, no resizing occurs */
COM_SC_NO_RESIZE = NS_CR_NONE, COM_SC_NO_RESIZE = NS_CR_NONE,
/** @brief Fit the width of the input image to the width of the working area of the node */ /** \brief Fit the width of the input image to the width of the working area of the node */
COM_SC_FIT_WIDTH = NS_CR_FIT_WIDTH, COM_SC_FIT_WIDTH = NS_CR_FIT_WIDTH,
/** @brief Fit the height of the input image to the height of the working area of the node */ /** \brief Fit the height of the input image to the height of the working area of the node */
COM_SC_FIT_HEIGHT = NS_CR_FIT_HEIGHT, COM_SC_FIT_HEIGHT = NS_CR_FIT_HEIGHT,
/** @brief Fit the width or the height of the input image to the width or height of the working area of the node, image will be larger than the working area */ /** \brief Fit the width or the height of the input image to the width or height of the working area of the node, image will be larger than the working area */
COM_SC_FIT = NS_CR_FIT, COM_SC_FIT = NS_CR_FIT,
/** @brief Fit the width and the height of the input image to the width and height of the working area of the node, image will be equally larger than the working area */ /** \brief Fit the width and the height of the input image to the width and height of the working area of the node, image will be equally larger than the working area */
COM_SC_STRETCH = NS_CR_STRETCH COM_SC_STRETCH = NS_CR_STRETCH
} InputResizeMode; } InputResizeMode;
/** /**
* @brief NodeOperation contains calculation logic * \brief NodeOperation contains calculation logic
* *
* Subclasses needs to implement the execution method (defined in SocketReader) to implement logic. * Subclasses needs to implement the execution method (defined in SocketReader) to implement logic.
* @ingroup Model * \ingroup Model
*/ */
class NodeOperation : public SocketReader { class NodeOperation : public SocketReader {
public: public:
@ -87,12 +87,12 @@ private:
Outputs m_outputs; Outputs m_outputs;
/** /**
* @brief the index of the input socket that will be used to determine the resolution * \brief the index of the input socket that will be used to determine the resolution
*/ */
unsigned int m_resolutionInputSocketIndex; unsigned int m_resolutionInputSocketIndex;
/** /**
* @brief is this operation a complex one. * \brief is this operation a complex one.
* *
* Complex operations are typically doing many reads to calculate the output of a single pixel. * 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. * Mostly Filter types (Blurs, Convolution, Defocus etc) need this to be set to true.
@ -100,29 +100,29 @@ private:
bool m_complex; bool m_complex;
/** /**
* @brief can this operation be scheduled on an OpenCL device. * \brief can this operation be scheduled on an OpenCL device.
* @note Only applicable if complex is True * \note Only applicable if complex is True
*/ */
bool m_openCL; bool m_openCL;
/** /**
* @brief mutex reference for very special node initializations * \brief mutex reference for very special node initializations
* @note only use when you really know what you are doing. * \note only use when you really know what you are doing.
* this mutex is used to share data among chunks in the same operation * this mutex is used to share data among chunks in the same operation
* @see TonemapOperation for an example of usage * \see TonemapOperation for an example of usage
* @see NodeOperation.initMutex initializes this mutex * \see NodeOperation.initMutex initializes this mutex
* @see NodeOperation.deinitMutex deinitializes this mutex * \see NodeOperation.deinitMutex deinitializes this mutex
* @see NodeOperation.getMutex retrieve a pointer to this mutex. * \see NodeOperation.getMutex retrieve a pointer to this mutex.
*/ */
ThreadMutex m_mutex; ThreadMutex m_mutex;
/** /**
* @brief reference to the editing bNodeTree, used for break and update callback * \brief reference to the editing bNodeTree, used for break and update callback
*/ */
const bNodeTree *m_btree; const bNodeTree *m_btree;
/** /**
* @brief set to truth when resolution for this operation is set * \brief set to truth when resolution for this operation is set
*/ */
bool m_isResolutionSet; bool m_isResolutionSet;
@ -141,25 +141,25 @@ public:
bool isInputOperation() const { return m_inputs.empty(); } bool isInputOperation() const { return m_inputs.empty(); }
/** /**
* @brief determine the resolution of this node * \brief determine the resolution of this node
* @note this method will not set the resolution, this is the responsibility of the caller * \note this method will not set the resolution, this is the responsibility of the caller
* @param resolution the result of this operation * \param resolution the result of this operation
* @param preferredResolution the preferable resolution as no resolution could be determined * \param preferredResolution the preferable resolution as no resolution could be determined
*/ */
virtual void determineResolution(unsigned int resolution[2], unsigned int preferredResolution[2]); virtual void determineResolution(unsigned int resolution[2], unsigned int preferredResolution[2]);
/** /**
* @brief isOutputOperation determines whether this operation is an output of the ExecutionSystem during rendering or editing. * \brief isOutputOperation determines whether this operation is an output of the ExecutionSystem during rendering or editing.
* *
* Default behaviour if not overridden, this operation will not be evaluated as being an output of the ExecutionSystem. * Default behaviour if not overridden, this operation will not be evaluated as being an output of the ExecutionSystem.
* *
* @see ExecutionSystem * \see ExecutionSystem
* @group check * \group check
* @param rendering [true false] * \param rendering [true false]
* true: rendering * true: rendering
* false: editing * false: editing
* *
* @return bool the result of this method * \return bool the result of this method
*/ */
virtual bool isOutputOperation(bool /*rendering*/) const { return false; } virtual bool isOutputOperation(bool /*rendering*/) const { return false; }
@ -169,26 +169,26 @@ public:
virtual void initExecution(); virtual void initExecution();
/** /**
* @brief when a chunk is executed by a CPUDevice, this method is called * \brief when a chunk is executed by a CPUDevice, this method is called
* @ingroup execution * \ingroup execution
* @param rect the rectangle of the chunk (location and size) * \param rect the rectangle of the chunk (location and size)
* @param chunkNumber the chunkNumber to be calculated * \param chunkNumber the chunkNumber to be calculated
* @param memoryBuffers all input MemoryBuffer's needed * \param memoryBuffers all input MemoryBuffer's needed
*/ */
virtual void executeRegion(rcti * /*rect*/, virtual void executeRegion(rcti * /*rect*/,
unsigned int /*chunkNumber*/) {} unsigned int /*chunkNumber*/) {}
/** /**
* @brief when a chunk is executed by an OpenCLDevice, this method is called * \brief when a chunk is executed by an OpenCLDevice, this method is called
* @ingroup execution * \ingroup execution
* @note this method is only implemented in WriteBufferOperation * \note this method is only implemented in WriteBufferOperation
* @param context the OpenCL context * \param context the OpenCL context
* @param program the OpenCL program containing all compositor kernels * \param program the OpenCL program containing all compositor kernels
* @param queue the OpenCL command queue of the device the chunk is executed on * \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 rect the rectangle of the chunk (location and size)
* @param chunkNumber the chunkNumber to be calculated * \param chunkNumber the chunkNumber to be calculated
* @param memoryBuffers all input MemoryBuffer's needed * \param memoryBuffers all input MemoryBuffer's needed
* @param outputBuffer the outputbuffer to write to * \param outputBuffer the outputbuffer to write to
*/ */
virtual void executeOpenCLRegion(OpenCLDevice * /*device*/, virtual void executeOpenCLRegion(OpenCLDevice * /*device*/,
rcti * /*rect*/, rcti * /*rect*/,
@ -197,16 +197,16 @@ public:
MemoryBuffer * /*outputBuffer*/) {} MemoryBuffer * /*outputBuffer*/) {}
/** /**
* @brief custom handle to add new tasks to the OpenCL command queue in order to execute a chunk on an GPUDevice * \brief custom handle to add new tasks to the OpenCL command queue in order to execute a chunk on an GPUDevice
* @ingroup execution * \ingroup execution
* @param context the OpenCL context * \param context the OpenCL context
* @param program the OpenCL program containing all compositor kernels * \param program the OpenCL program containing all compositor kernels
* @param queue the OpenCL command queue of the device the chunk is executed on * \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 outputMemoryBuffer the allocated memory buffer in main CPU memory
* @param clOutputBuffer the allocated memory buffer in OpenCLDevice memory * \param clOutputBuffer the allocated memory buffer in OpenCLDevice memory
* @param inputMemoryBuffers all input MemoryBuffer's needed * \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 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 * \param clKernelsToCleanUp all created cl_kernel references must be added to this list. Framework will clean this after execution
*/ */
virtual void executeOpenCL(OpenCLDevice * /*device*/, virtual void executeOpenCL(OpenCLDevice * /*device*/,
MemoryBuffer * /*outputMemoryBuffer*/, MemoryBuffer * /*outputMemoryBuffer*/,
@ -221,8 +221,8 @@ public:
} }
/** /**
* @brief set the resolution * \brief set the resolution
* @param resolution the resolution to set * \param resolution the resolution to set
*/ */
void setResolution(unsigned int resolution[2]) { void setResolution(unsigned int resolution[2]) {
if (!isResolutionSet()) { if (!isResolutionSet()) {
@ -236,7 +236,7 @@ public:
void getConnectedInputSockets(Inputs *sockets); void getConnectedInputSockets(Inputs *sockets);
/** /**
* @brief is this operation complex * \brief is this operation complex
* *
* Complex operations are typically doing many reads to calculate the output of a single pixel. * 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. * Mostly Filter types (Blurs, Convolution, Defocus etc) need this to be set to true.
@ -246,46 +246,46 @@ public:
virtual bool isSetOperation() const { return false; } virtual bool isSetOperation() const { return false; }
/** /**
* @brief is this operation of type ReadBufferOperation * \brief is this operation of type ReadBufferOperation
* @return [true:false] * \return [true:false]
* @see ReadBufferOperation * \see ReadBufferOperation
*/ */
virtual const bool isReadBufferOperation() const { return false; } virtual const bool isReadBufferOperation() const { return false; }
/** /**
* @brief is this operation of type WriteBufferOperation * \brief is this operation of type WriteBufferOperation
* @return [true:false] * \return [true:false]
* @see WriteBufferOperation * \see WriteBufferOperation
*/ */
virtual const bool isWriteBufferOperation() const { return false; } virtual const bool isWriteBufferOperation() const { return false; }
/** /**
* @brief is this operation the active viewer output * \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) * user can select an ViewerNode to be active (the result of this node will be drawn on the backdrop)
* @return [true:false] * \return [true:false]
* @see BaseViewerOperation * \see BaseViewerOperation
*/ */
virtual const bool isActiveViewerOutput() const { return false; } virtual const bool isActiveViewerOutput() const { return false; }
virtual bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output); 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 * \brief set the index of the input socket that will determine the resolution of this operation
* @param index the index to set * \param index the index to set
*/ */
void setResolutionInputSocketIndex(unsigned int index); void setResolutionInputSocketIndex(unsigned int index);
/** /**
* @brief get the render priority of this node. * \brief get the render priority of this node.
* @note only applicable for output operations like ViewerOperation * \note only applicable for output operations like ViewerOperation
* @return CompositorPriority * \return CompositorPriority
*/ */
virtual const CompositorPriority getRenderPriority() const { return COM_PRIORITY_LOW; } virtual const CompositorPriority getRenderPriority() const { return COM_PRIORITY_LOW; }
/** /**
* @brief can this NodeOperation be scheduled on an OpenCLDevice * \brief can this NodeOperation be scheduled on an OpenCLDevice
* @see WorkScheduler.schedule * \see WorkScheduler.schedule
* @see ExecutionGroup.addOperation * \see ExecutionGroup.addOperation
*/ */
bool isOpenCL() const { return this->m_openCL; } bool isOpenCL() const { return this->m_openCL; }
@ -321,7 +321,7 @@ protected:
void unlockMutex(); void unlockMutex();
/** /**
* @brief set whether this operation is complex * \brief set whether this operation is complex
* *
* Complex operations are typically doing many reads to calculate the output of a single pixel. * 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. * Mostly Filter types (Blurs, Convolution, Defocus etc) need this to be set to true.
@ -329,7 +329,7 @@ protected:
void setComplex(bool complex) { this->m_complex = complex; } void setComplex(bool complex) { this->m_complex = complex; }
/** /**
* @brief set if this NodeOperation can be scheduled on a OpenCLDevice * \brief set if this NodeOperation can be scheduled on a OpenCLDevice
*/ */
void setOpenCL(bool openCL) { this->m_openCL = openCL; } void setOpenCL(bool openCL) { this->m_openCL = openCL; }
@ -347,7 +347,7 @@ private:
NodeOperation *m_operation; NodeOperation *m_operation;
/** Datatype of this socket. Is used for automatically data transformation. /** Datatype of this socket. Is used for automatically data transformation.
* @section data-conversion * \section data-conversion
*/ */
DataType m_datatype; DataType m_datatype;
@ -385,7 +385,7 @@ private:
NodeOperation *m_operation; NodeOperation *m_operation;
/** Datatype of this socket. Is used for automatically data transformation. /** Datatype of this socket. Is used for automatically data transformation.
* @section data-conversion * \section data-conversion
*/ */
DataType m_datatype; DataType m_datatype;
@ -396,9 +396,9 @@ public:
DataType getDataType() const { return m_datatype; } DataType getDataType() const { return m_datatype; }
/** /**
* @brief determine the resolution of this data going through this socket * \brief determine the resolution of this data going through this socket
* @param resolution the result of this operation * \param resolution the result of this operation
* @param preferredResolution the preferable resolution as no resolution could be determined * \param preferredResolution the preferable resolution as no resolution could be determined
*/ */
void determineResolution(unsigned int resolution[2], unsigned int preferredResolution[2]); void determineResolution(unsigned int resolution[2], unsigned int preferredResolution[2]);

36
source/blender/compositor/intern/COM_OpenCLDevice.h
View File

@ -33,70 +33,70 @@ class OpenCLDevice;
using std::list; using std::list;
/** /**
* @brief device representing an GPU OpenCL device. * \brief device representing an GPU OpenCL device.
* an instance of this class represents a single cl_device * an instance of this class represents a single cl_device
*/ */
class OpenCLDevice : public Device { class OpenCLDevice : public Device {
private: private:
/** /**
* @brief opencl context * \brief opencl context
*/ */
cl_context m_context; cl_context m_context;
/** /**
* @brief opencl device * \brief opencl device
*/ */
cl_device_id m_device; cl_device_id m_device;
/** /**
* @brief opencl program * \brief opencl program
*/ */
cl_program m_program; cl_program m_program;
/** /**
* @brief opencl command queue * \brief opencl command queue
*/ */
cl_command_queue m_queue; cl_command_queue m_queue;
/** /**
* @brief opencl vendor ID * \brief opencl vendor ID
*/ */
cl_int m_vendorID; cl_int m_vendorID;
public: public:
/** /**
* @brief constructor with opencl device * \brief constructor with opencl device
* @param context * \param context
* @param device * \param device
* @param program * \param program
* @param vendorID * \param vendorID
*/ */
OpenCLDevice(cl_context context, cl_device_id device, cl_program program, cl_int vendorId); OpenCLDevice(cl_context context, cl_device_id device, cl_program program, cl_int vendorId);
/** /**
* @brief initialize the device * \brief initialize the device
* During initialization the OpenCL cl_command_queue is created * During initialization the OpenCL cl_command_queue is created
* the command queue is stored in the field queue. * the command queue is stored in the field queue.
* @see queue * \see queue
*/ */
bool initialize(); bool initialize();
/** /**
* @brief deinitialize the device * \brief deinitialize the device
* During deintiialization the command queue is cleared * During deintiialization the command queue is cleared
*/ */
void deinitialize(); void deinitialize();
/** /**
* @brief execute a WorkPackage * \brief execute a WorkPackage
* @param work the WorkPackage to execute * \param work the WorkPackage to execute
*/ */
void execute(WorkPackage *work); void execute(WorkPackage *work);
/** /**
* @brief determine an image format * \brief determine an image format
* @param memorybuffer * \param memorybuffer
*/ */
static const cl_image_format *determineImageFormat(MemoryBuffer *memoryBuffer); static const cl_image_format *determineImageFormat(MemoryBuffer *memoryBuffer);

50
source/blender/compositor/intern/COM_SocketReader.h
View File

@ -37,31 +37,31 @@ typedef enum PixelSampler {
class MemoryBuffer; class MemoryBuffer;
/** /**
* @brief Helper class for reading socket data. * \brief Helper class for reading socket data.
* Only use this class for dispatching (un-ary and n-ary) executions. * Only use this class for dispatching (un-ary and n-ary) executions.
* @ingroup Execution * \ingroup Execution
*/ */
class SocketReader { class SocketReader {
private: private:
protected: protected:
/** /**
* @brief Holds the width of the output of this operation. * \brief Holds the width of the output of this operation.
*/ */
unsigned int m_width; unsigned int m_width;
/** /**
* @brief Holds the height of the output of this operation. * \brief Holds the height of the output of this operation.
*/ */
unsigned int m_height; unsigned int m_height;
/** /**
* @brief calculate a single pixel * \brief calculate a single pixel
* @note this method is called for non-complex * \note this method is called for non-complex
* @param result is a float[4] array to store the result * \param result is a float[4] array to store the result
* @param x the x-coordinate of the pixel to calculate in image space * \param x the x-coordinate of the pixel to calculate in image space
* @param y the y-coordinate of the pixel to calculate in image space * \param y the y-coordinate of the pixel to calculate in image space
* @param inputBuffers chunks that can be read by their ReadBufferOperation. * \param inputBuffers chunks that can be read by their ReadBufferOperation.
*/ */
virtual void executePixelSampled(float /*output*/[4], virtual void executePixelSampled(float /*output*/[4],
float /*x*/, float /*x*/,
@ -69,27 +69,27 @@ protected:
PixelSampler /*sampler*/) { } PixelSampler /*sampler*/) { }
/** /**
* @brief calculate a single pixel * \brief calculate a single pixel
* @note this method is called for complex * \note this method is called for complex
* @param result is a float[4] array to store the result * \param result is a float[4] array to store the result
* @param x the x-coordinate of the pixel to calculate in image space * \param x the x-coordinate of the pixel to calculate in image space
* @param y the y-coordinate of the pixel to calculate in image space * \param y the y-coordinate of the pixel to calculate in image space
* @param inputBuffers chunks that can be read by their ReadBufferOperation. * \param inputBuffers chunks that can be read by their ReadBufferOperation.
* @param chunkData chunk specific data a during execution time. * \param chunkData chunk specific data a during execution time.
*/ */
virtual void executePixel(float output[4], int x, int y, void * /*chunkData*/) { virtual void executePixel(float output[4], int x, int y, void * /*chunkData*/) {
executePixelSampled(output, x, y, COM_PS_NEAREST); executePixelSampled(output, x, y, COM_PS_NEAREST);
} }
/** /**
* @brief calculate a single pixel using an EWA filter * \brief calculate a single pixel using an EWA filter
* @note this method is called for complex * \note this method is called for complex
* @param result is a float[4] array to store the result * \param result is a float[4] array to store the result
* @param x the x-coordinate of the pixel to calculate in image space * \param x the x-coordinate of the pixel to calculate in image space
* @param y the y-coordinate of the pixel to calculate in image space * \param y the y-coordinate of the pixel to calculate in image space
* @param dx * \param dx
* @param dy * \param dy
* @param inputBuffers chunks that can be read by their ReadBufferOperation. * \param inputBuffers chunks that can be read by their ReadBufferOperation.
*/ */
virtual void executePixelFiltered(float /*output*/[4], virtual void executePixelFiltered(float /*output*/[4],
float /*x*/, float /*y*/, float /*x*/, float /*y*/,

16
source/blender/compositor/intern/COM_WorkPackage.h
View File

@ -28,35 +28,35 @@ class ExecutionGroup;
#include "COM_ExecutionGroup.h" #include "COM_ExecutionGroup.h"
/** /**
* @brief contains data about work that can be scheduled * \brief contains data about work that can be scheduled
* @see WorkScheduler * \see WorkScheduler
*/ */
class WorkPackage { class WorkPackage {
private: private:
/** /**
* @brief executionGroup with the operations-setup to be evaluated * \brief executionGroup with the operations-setup to be evaluated
*/ */
ExecutionGroup *m_executionGroup; ExecutionGroup *m_executionGroup;
/** /**
* @brief number of the chunk to be executed * \brief number of the chunk to be executed
*/ */
unsigned int m_chunkNumber; unsigned int m_chunkNumber;
public: public:
/** /**
* constructor * constructor
* @param group the ExecutionGroup * \param group the ExecutionGroup
* @param chunkNumber the number of the chunk * \param chunkNumber the number of the chunk
*/ */
WorkPackage(ExecutionGroup *group, unsigned int chunkNumber); WorkPackage(ExecutionGroup *group, unsigned int chunkNumber);
/** /**
* @brief get the ExecutionGroup * \brief get the ExecutionGroup
*/ */
ExecutionGroup *getExecutionGroup() const { return this->m_executionGroup; } ExecutionGroup *getExecutionGroup() const { return this->m_executionGroup; }
/** /**
* @brief get the number of the chunk * \brief get the number of the chunk
*/ */
unsigned int getChunkNumber() const { return this->m_chunkNumber; } unsigned int getChunkNumber() const { return this->m_chunkNumber; }

12
source/blender/compositor/intern/COM_WorkScheduler.cpp
View File

@ -49,25 +49,25 @@
#endif #endif
/// @brief list of all CPUDevices. for every hardware thread an instance of CPUDevice is created /// \brief list of all CPUDevices. for every hardware thread an instance of CPUDevice is created
static vector<CPUDevice*> g_cpudevices; static vector<CPUDevice*> g_cpudevices;
static ThreadLocal(CPUDevice *) g_thread_device; static ThreadLocal(CPUDevice *) g_thread_device;
#if COM_CURRENT_THREADING_MODEL == COM_TM_QUEUE #if COM_CURRENT_THREADING_MODEL == COM_TM_QUEUE
/// @brief list of all thread for every CPUDevice in cpudevices a thread exists /// \brief list of all thread for every CPUDevice in cpudevices a thread exists
static ListBase g_cputhreads; static ListBase g_cputhreads;
static bool g_cpuInitialized = false; static bool g_cpuInitialized = false;
/// @brief all scheduled work for the cpu /// \brief all scheduled work for the cpu
static ThreadQueue *g_cpuqueue; static ThreadQueue *g_cpuqueue;
static ThreadQueue *g_gpuqueue; static ThreadQueue *g_gpuqueue;
#ifdef COM_OPENCL_ENABLED #ifdef COM_OPENCL_ENABLED
static cl_context g_context; static cl_context g_context;
static cl_program g_program; static cl_program g_program;
/// @brief list of all OpenCLDevices. for every OpenCL GPU device an instance of OpenCLDevice is created /// \brief list of all OpenCLDevices. for every OpenCL GPU device an instance of OpenCLDevice is created
static vector<OpenCLDevice *> g_gpudevices; static vector<OpenCLDevice *> g_gpudevices;
/// @brief list of all thread for every GPUDevice in cpudevices a thread exists /// \brief list of all thread for every GPUDevice in cpudevices a thread exists
static ListBase g_gputhreads; static ListBase g_gputhreads;
/// @brief all scheduled work for the gpu /// \brief all scheduled work for the gpu
#ifdef COM_OPENCL_ENABLED #ifdef COM_OPENCL_ENABLED
static bool g_openclActive = false; static bool g_openclActive = false;
static bool g_openclInitialized = false; static bool g_openclInitialized = false;

36
source/blender/compositor/intern/COM_WorkScheduler.h
View File

@ -31,43 +31,43 @@ extern "C" {
#include "COM_defines.h" #include "COM_defines.h"
#include "COM_Device.h" #include "COM_Device.h"
/** @brief the workscheduler /** \brief the workscheduler
* @ingroup execution * \ingroup execution
*/ */
class WorkScheduler { class WorkScheduler {
#if COM_CURRENT_THREADING_MODEL == COM_TM_QUEUE #if COM_CURRENT_THREADING_MODEL == COM_TM_QUEUE
/** /**
* @brief are we being stopped. * \brief are we being stopped.
*/ */
static bool isStopping(); static bool isStopping();
/** /**
* @brief main thread loop for cpudevices * \brief main thread loop for cpudevices
* inside this loop new work is queried and being executed * inside this loop new work is queried and being executed
*/ */
static void *thread_execute_cpu(void *data); static void *thread_execute_cpu(void *data);
/** /**
* @brief main thread loop for gpudevices * \brief main thread loop for gpudevices
* inside this loop new work is queried and being executed * inside this loop new work is queried and being executed
*/ */
static void *thread_execute_gpu(void *data); static void *thread_execute_gpu(void *data);
#endif #endif
public: public:
/** /**
* @brief schedule a chunk of a group to be calculated. * \brief schedule a chunk of a group to be calculated.
* An execution group schedules a chunk in the WorkScheduler * An execution group schedules a chunk in the WorkScheduler
* when ExecutionGroup.isOpenCL is set the work will be handled by a OpenCLDevice * when ExecutionGroup.isOpenCL is set the work will be handled by a OpenCLDevice
* otherwise the work is scheduled for an CPUDevice * otherwise the work is scheduled for an CPUDevice
* @see ExecutionGroup.execute * \see ExecutionGroup.execute
* @param group the execution group * \param group the execution group
* @param chunkNumber the number of the chunk in the group to be executed * \param chunkNumber the number of the chunk in the group to be executed
*/ */
static void schedule(ExecutionGroup *group, int chunkNumber); static void schedule(ExecutionGroup *group, int chunkNumber);
/** /**
* @brief initialize the WorkScheduler * \brief initialize the WorkScheduler
* *
* during initialization the mutexes are initialized. * during initialization the mutexes are initialized.
* there are two mutexes (for every device type one) * there are two mutexes (for every device type one)
@ -80,36 +80,36 @@ public:
static void initialize(bool use_opencl, int num_cpu_threads); static void initialize(bool use_opencl, int num_cpu_threads);
/** /**
* @brief deinitialize the WorkScheduler * \brief deinitialize the WorkScheduler
* free all allocated resources * free all allocated resources
*/ */
static void deinitialize(); static void deinitialize();
/** /**
* @brief Start the execution * \brief Start the execution
* this methods will start the WorkScheduler. Inside this method all threads are initialized. * this methods will start the WorkScheduler. Inside this method all threads are initialized.
* for every device a thread is created. * for every device a thread is created.
* @see initialize Initialization and query of the number of devices * \see initialize Initialization and query of the number of devices
*/ */
static void start(CompositorContext &context); static void start(CompositorContext &context);
/** /**
* @brief stop the execution * \brief stop the execution
* All created thread by the start method are destroyed. * All created thread by the start method are destroyed.
* @see start * \see start
*/ */
static void stop(); static void stop();
/** /**
* @brief wait for all work to be completed. * \brief wait for all work to be completed.
*/ */
static void finish(); static void finish();
/** /**
* @brief Are there OpenCL capable GPU devices initialized? * \brief Are there OpenCL capable GPU devices initialized?
* the result of this method is stored in the CompositorContext * the result of this method is stored in the CompositorContext
* A node can generate a different operation tree when OpenCLDevices exists. * A node can generate a different operation tree when OpenCLDevices exists.
* @see CompositorContext.getHasActiveOpenCLDevices * \see CompositorContext.getHasActiveOpenCLDevices
*/ */
static bool hasGPUDevices(); static bool hasGPUDevices();

4
source/blender/compositor/nodes/COM_AlphaOverNode.h
View File

@ -26,8 +26,8 @@
#include "COM_Node.h" #include "COM_Node.h"
/** /**
* @brief AlphaOverNode * \brief AlphaOverNode
* @ingroup Node * \ingroup Node
*/ */
class AlphaOverNode : public Node { class AlphaOverNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_BilateralBlurNode.h
View File

@ -26,8 +26,8 @@
#include "COM_Node.h" #include "COM_Node.h"
/** /**
* @brief BilateralBlurNode * \brief BilateralBlurNode
* @ingroup Node * \ingroup Node
*/ */
class BilateralBlurNode : public Node { class BilateralBlurNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_BlurNode.h
View File

@ -26,8 +26,8 @@
#include "COM_Node.h" #include "COM_Node.h"
/** /**
* @brief BlurNode * \brief BlurNode
* @ingroup Node * \ingroup Node
*/ */
class BlurNode : public Node { class BlurNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_BokehBlurNode.h
View File

@ -26,8 +26,8 @@
#include "COM_Node.h" #include "COM_Node.h"
/** /**
* @brief BokehBlurNode * \brief BokehBlurNode
* @ingroup Node * \ingroup Node
*/ */
class BokehBlurNode : public Node { class BokehBlurNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_BokehImageNode.h
View File

@ -26,8 +26,8 @@
#include "COM_Node.h" #include "COM_Node.h"
/** /**
* @brief BokehImageNode * \brief BokehImageNode
* @ingroup Node * \ingroup Node
*/ */
class BokehImageNode : public Node { class BokehImageNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_BoxMaskNode.h
View File

@ -26,8 +26,8 @@
#include "COM_Node.h" #include "COM_Node.h"
/** /**
* @brief BoxMaskNode * \brief BoxMaskNode
* @ingroup Node * \ingroup Node
*/ */
class BoxMaskNode : public Node { class BoxMaskNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_BrightnessNode.h
View File

@ -26,8 +26,8 @@
#include "COM_Node.h" #include "COM_Node.h"
/** /**
* @brief BrightnessNode * \brief BrightnessNode
* @ingroup Node * \ingroup Node
*/ */
class BrightnessNode : public Node { class BrightnessNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_ChannelMatteNode.h
View File

@ -25,8 +25,8 @@
#include "COM_Node.h" #include "COM_Node.h"
/** /**
* @brief ChannelMatteNode * \brief ChannelMatteNode
* @ingroup Node * \ingroup Node
*/ */
class ChannelMatteNode : public Node { class ChannelMatteNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_ChromaMatteNode.h
View File

@ -25,8 +25,8 @@
#include "COM_Node.h" #include "COM_Node.h"
/** /**
* @brief ChromaMatteNode * \brief ChromaMatteNode
* @ingroup Node * \ingroup Node
*/ */
class ChromaMatteNode : public Node { class ChromaMatteNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_ColorBalanceNode.h
View File

@ -26,8 +26,8 @@
#include "COM_Node.h" #include "COM_Node.h"
/** /**
* @brief ColorBalanceNode * \brief ColorBalanceNode
* @ingroup Node * \ingroup Node
*/ */
class ColorBalanceNode : public Node { class ColorBalanceNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_ColorCorrectionNode.h
View File

@ -26,8 +26,8 @@
#include "COM_Node.h" #include "COM_Node.h"
/** /**
* @brief ColorCorrectionNode * \brief ColorCorrectionNode
* @ingroup Node * \ingroup Node
*/ */
class ColorCorrectionNode : public Node { class ColorCorrectionNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_ColorCurveNode.h
View File

@ -26,8 +26,8 @@
#include "COM_Node.h" #include "COM_Node.h"
/** /**
* @brief ColorCurveNode * \brief ColorCurveNode
* @ingroup Node * \ingroup Node
*/ */
class ColorCurveNode : public Node { class ColorCurveNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_ColorMatteNode.h
View File

@ -25,8 +25,8 @@
#include "COM_Node.h" #include "COM_Node.h"
/** /**
* @brief ColorMatteNode * \brief ColorMatteNode
* @ingroup Node * \ingroup Node
*/ */
class ColorMatteNode : public Node { class ColorMatteNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_ColorNode.h
View File

@ -26,8 +26,8 @@
#include "COM_Node.h" #include "COM_Node.h"
/** /**
* @brief ColorNode * \brief ColorNode
* @ingroup Node * \ingroup Node
*/ */
class ColorNode : public Node { class ColorNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_ColorRampNode.h
View File

@ -26,8 +26,8 @@
#include "COM_Node.h" #include "COM_Node.h"
/** /**
* @brief ColorRampNode * \brief ColorRampNode
* @ingroup Node * \ingroup Node
*/ */
class ColorRampNode : public Node { class ColorRampNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_ColorSpillNode.h
View File

@ -26,8 +26,8 @@
#include "COM_Node.h" #include "COM_Node.h"
/** /**
* @brief ColorSpillNode * \brief ColorSpillNode
* @ingroup Node * \ingroup Node
*/ */
class ColorSpillNode : public Node { class ColorSpillNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_ColorToBWNode.h
View File

@ -26,8 +26,8 @@
#include "COM_Node.h" #include "COM_Node.h"
#include "DNA_node_types.h" #include "DNA_node_types.h"
/** /**
* @brief ColorToBWNode * \brief ColorToBWNode
* @ingroup Node * \ingroup Node
*/ */
class ColorToBWNode : public Node { class ColorToBWNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_CompositorNode.h
View File

@ -26,8 +26,8 @@
#include "COM_Node.h" #include "COM_Node.h"
#include "DNA_node_types.h" #include "DNA_node_types.h"
/** /**
* @brief CompositorNode * \brief CompositorNode
* @ingroup Node * \ingroup Node
*/ */
class CompositorNode : public Node { class CompositorNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_ConvertAlphaNode.h
View File

@ -25,8 +25,8 @@
#include "COM_Node.h" #include "COM_Node.h"
/** /**
* @brief ConvertAlphaNode * \brief ConvertAlphaNode
* @ingroup Node * \ingroup Node
*/ */
class ConvertAlphaNode : public Node { class ConvertAlphaNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_CornerPinNode.h
View File

@ -29,8 +29,8 @@ extern "C" {
} }
/** /**
* @brief CornerPinNode * \brief CornerPinNode
* @ingroup Node * \ingroup Node
*/ */
class CornerPinNode : public Node { class CornerPinNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_CropNode.h
View File

@ -26,8 +26,8 @@
#include "COM_Node.h" #include "COM_Node.h"
/** /**
* @brief CropNode * \brief CropNode
* @ingroup Node * \ingroup Node
*/ */
class CropNode : public Node { class CropNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_CryptomatteNode.h
View File

@ -25,8 +25,8 @@
#include "COM_Node.h" #include "COM_Node.h"
/** /**
* @brief CryptomatteNode * \brief CryptomatteNode
* @ingroup Node * \ingroup Node
*/ */
class CryptomatteNode : public Node { class CryptomatteNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_DefocusNode.h
View File

@ -26,8 +26,8 @@
#include "COM_Node.h" #include "COM_Node.h"
/** /**
* @brief DefocusNode * \brief DefocusNode
* @ingroup Node * \ingroup Node
*/ */
class DefocusNode : public Node { class DefocusNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_DespeckleNode.h
View File

@ -24,8 +24,8 @@
#include "COM_Node.h" #include "COM_Node.h"
/** /**
* @brief DespeckleNode * \brief DespeckleNode
* @ingroup Node * \ingroup Node
*/ */
class DespeckleNode : public Node { class DespeckleNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_DifferenceMatteNode.h
View File

@ -26,8 +26,8 @@
#include "COM_Node.h" #include "COM_Node.h"
/** /**
* @brief DifferenceMatteNode * \brief DifferenceMatteNode
* @ingroup Node * \ingroup Node
*/ */
class DifferenceMatteNode : public Node { class DifferenceMatteNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_DilateErodeNode.h
View File

@ -26,8 +26,8 @@
#include "COM_Node.h" #include "COM_Node.h"
/** /**
* @brief DilateErodeNode * \brief DilateErodeNode
* @ingroup Node * \ingroup Node
*/ */
class DilateErodeNode : public Node { class DilateErodeNode : public Node {
NodeBlurData m_alpha_blur; /* only used for blurring alpha, since the dilate/erode node doesnt have this */ NodeBlurData m_alpha_blur; /* only used for blurring alpha, since the dilate/erode node doesnt have this */

4
source/blender/compositor/nodes/COM_DirectionalBlurNode.h
View File

@ -26,8 +26,8 @@
#include "COM_Node.h" #include "COM_Node.h"
/** /**
* @brief DirectionalBlurNode * \brief DirectionalBlurNode
* @ingroup Node * \ingroup Node
*/ */
class DirectionalBlurNode : public Node { class DirectionalBlurNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_DisplaceNode.h
View File

@ -25,8 +25,8 @@
#include "COM_Node.h" #include "COM_Node.h"
/** /**
* @brief DisplaceNode * \brief DisplaceNode
* @ingroup Node * \ingroup Node
*/ */
class DisplaceNode : public Node { class DisplaceNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_DistanceMatteNode.h
View File

@ -25,8 +25,8 @@
#include "COM_Node.h" #include "COM_Node.h"
/** /**
* @brief DistanceMatteNode * \brief DistanceMatteNode
* @ingroup Node * \ingroup Node
*/ */
class DistanceMatteNode : public Node { class DistanceMatteNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_DoubleEdgeMaskNode.h
View File

@ -26,8 +26,8 @@
#include "COM_Node.h" #include "COM_Node.h"
/** /**
* @brief DoubleEdgeMaskNode * \brief DoubleEdgeMaskNode
* @ingroup Node * \ingroup Node
*/ */
class DoubleEdgeMaskNode : public Node { class DoubleEdgeMaskNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_EllipseMaskNode.h
View File

@ -26,8 +26,8 @@
#include "COM_Node.h" #include "COM_Node.h"
/** /**
* @brief EllipseMaskNode * \brief EllipseMaskNode
* @ingroup Node * \ingroup Node
*/ */
class EllipseMaskNode : public Node { class EllipseMaskNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_FilterNode.h
View File

@ -26,8 +26,8 @@
#include "COM_Node.h" #include "COM_Node.h"
/** /**
* @brief FilterNode * \brief FilterNode
* @ingroup Node * \ingroup Node
*/ */
class FilterNode : public Node { class FilterNode : public Node {
public: public:

2
source/blender/compositor/nodes/COM_FlipNode.cpp
View File

@ -36,7 +36,7 @@ void FlipNode::convertToOperations(NodeConverter &converter, const CompositorCon
NodeOutput *outputSocket = this->getOutputSocket(0); NodeOutput *outputSocket = this->getOutputSocket(0);
FlipOperation *operation = new FlipOperation(); FlipOperation *operation = new FlipOperation();
switch (this->getbNode()->custom1) { switch (this->getbNode()->custom1) {
case 0: /// @TODO: I didn't find any constants in the old implementation, should I introduce them. case 0: /// \TODO: I didn't find any constants in the old implementation, should I introduce them.
operation->setFlipX(true); operation->setFlipX(true);
operation->setFlipY(false); operation->setFlipY(false);
break; break;

4
source/blender/compositor/nodes/COM_FlipNode.h
View File

@ -26,8 +26,8 @@
#include "COM_Node.h" #include "COM_Node.h"
/** /**
* @brief FlipNode * \brief FlipNode
* @ingroup Node * \ingroup Node
*/ */
class FlipNode : public Node { class FlipNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_GammaNode.h
View File

@ -26,8 +26,8 @@
#include "COM_Node.h" #include "COM_Node.h"
/** /**
* @brief GammaNode * \brief GammaNode
* @ingroup Node * \ingroup Node
*/ */
class GammaNode : public Node { class GammaNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_GlareNode.h
View File

@ -26,8 +26,8 @@
#include "COM_Node.h" #include "COM_Node.h"
/** /**
* @brief GlareNode * \brief GlareNode
* @ingroup Node * \ingroup Node
*/ */
class GlareNode : public Node { class GlareNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_HueSaturationValueCorrectNode.h
View File

@ -26,8 +26,8 @@
#include "COM_Node.h" #include "COM_Node.h"
/** /**
* @brief HueSaturationValueCorrectNode * \brief HueSaturationValueCorrectNode
* @ingroup Node * \ingroup Node
*/ */
class HueSaturationValueCorrectNode : public Node { class HueSaturationValueCorrectNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_HueSaturationValueNode.h
View File

@ -26,8 +26,8 @@
#include "COM_Node.h" #include "COM_Node.h"
/** /**
* @brief HueSaturationValueNode * \brief HueSaturationValueNode
* @ingroup Node * \ingroup Node
*/ */
class HueSaturationValueNode : public Node { class HueSaturationValueNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_IDMaskNode.h
View File

@ -26,8 +26,8 @@
#include "COM_Node.h" #include "COM_Node.h"
/** /**
* @brief IDMaskNode * \brief IDMaskNode
* @ingroup Node * \ingroup Node
*/ */
class IDMaskNode : public Node { class IDMaskNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_ImageNode.h
View File

@ -30,8 +30,8 @@ extern "C" {
} }
/** /**
* @brief ImageNode * \brief ImageNode
* @ingroup Node * \ingroup Node
*/ */
class ImageNode : public Node { class ImageNode : public Node {
private: private:

4
source/blender/compositor/nodes/COM_InpaintNode.h
View File

@ -26,8 +26,8 @@
#include "COM_Node.h" #include "COM_Node.h"
/** /**
* @brief InpaintNode * \brief InpaintNode
* @ingroup Node * \ingroup Node
*/ */
class InpaintNode : public Node { class InpaintNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_InvertNode.h
View File

@ -26,8 +26,8 @@
#include "COM_Node.h" #include "COM_Node.h"
/** /**
* @brief InvertNode * \brief InvertNode
* @ingroup Node * \ingroup Node
*/ */
class InvertNode : public Node { class InvertNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_KeyingNode.h
View File

@ -24,8 +24,8 @@
#include "COM_Node.h" #include "COM_Node.h"
/** /**
* @brief KeyingNode * \brief KeyingNode
* @ingroup Node * \ingroup Node
*/ */
class KeyingNode : public Node { class KeyingNode : public Node {
protected: protected:

4
source/blender/compositor/nodes/COM_KeyingScreenNode.h
View File

@ -25,8 +25,8 @@
#include "DNA_node_types.h" #include "DNA_node_types.h"
/** /**
* @brief KeyingScreenNode * \brief KeyingScreenNode
* @ingroup Node * \ingroup Node
*/ */
class KeyingScreenNode : public Node { class KeyingScreenNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_LensDistortionNode.h
View File

@ -26,8 +26,8 @@
#include "COM_Node.h" #include "COM_Node.h"
/** /**
* @brief LensDistortionNode * \brief LensDistortionNode
* @ingroup Node * \ingroup Node
*/ */
class LensDistortionNode : public Node { class LensDistortionNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_LuminanceMatteNode.h
View File

@ -25,8 +25,8 @@
#include "COM_Node.h" #include "COM_Node.h"
/** /**
* @brief LuminanceMatteNode * \brief LuminanceMatteNode
* @ingroup Node * \ingroup Node
*/ */
class LuminanceMatteNode : public Node { class LuminanceMatteNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_MapRangeNode.h
View File

@ -26,8 +26,8 @@
#include "COM_Node.h" #include "COM_Node.h"
#include "DNA_node_types.h" #include "DNA_node_types.h"
/** /**
* @brief MapRangeNode * \brief MapRangeNode
* @ingroup Node * \ingroup Node
*/ */
class MapRangeNode : public Node { class MapRangeNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_MapUVNode.h
View File

@ -25,8 +25,8 @@
#include "COM_Node.h" #include "COM_Node.h"
/** /**
* @brief MapUVNode * \brief MapUVNode
* @ingroup Node * \ingroup Node
*/ */
class MapUVNode : public Node { class MapUVNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_MapValueNode.h
View File

@ -26,8 +26,8 @@
#include "COM_Node.h" #include "COM_Node.h"
#include "DNA_node_types.h" #include "DNA_node_types.h"
/** /**
* @brief MapValueNode * \brief MapValueNode
* @ingroup Node * \ingroup Node
*/ */
class MapValueNode : public Node { class MapValueNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_MaskNode.h
View File

@ -28,8 +28,8 @@
#include "DNA_node_types.h" #include "DNA_node_types.h"
/** /**
* @brief MaskNode * \brief MaskNode
* @ingroup Node * \ingroup Node
*/ */
class MaskNode : public Node { class MaskNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_MathNode.h
View File

@ -26,8 +26,8 @@
#include "COM_Node.h" #include "COM_Node.h"
/** /**
* @brief MathNode * \brief MathNode
* @ingroup Node * \ingroup Node
*/ */
class MathNode : public Node { class MathNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_MixNode.h
View File

@ -26,8 +26,8 @@
#include "COM_Node.h" #include "COM_Node.h"
#include "DNA_node_types.h" #include "DNA_node_types.h"
/** /**
* @brief MixNode * \brief MixNode
* @ingroup Node * \ingroup Node
*/ */
class MixNode : public Node { class MixNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_MovieClipNode.h
View File

@ -27,8 +27,8 @@
#include "DNA_node_types.h" #include "DNA_node_types.h"
/** /**
* @brief MovieClipNode * \brief MovieClipNode
* @ingroup Node * \ingroup Node
*/ */
class MovieClipNode : public Node { class MovieClipNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_MovieDistortionNode.h
View File

@ -26,8 +26,8 @@
#include "COM_Node.h" #include "COM_Node.h"
/** /**
* @brief MovieDistortionNode * \brief MovieDistortionNode
* @ingroup Node * \ingroup Node
*/ */
class MovieDistortionNode : public Node { class MovieDistortionNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_NormalNode.h
View File

@ -26,8 +26,8 @@
#include "COM_Node.h" #include "COM_Node.h"
/** /**
* @brief NormalNode * \brief NormalNode
* @ingroup Node * \ingroup Node
*/ */
class NormalNode : public Node { class NormalNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_NormalizeNode.h
View File

@ -25,8 +25,8 @@
#include "COM_Node.h" #include "COM_Node.h"
/** /**
* @brief NormalizeNode * \brief NormalizeNode
* @ingroup Node * \ingroup Node
*/ */
class NormalizeNode : public Node { class NormalizeNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_OutputFileNode.h
View File

@ -28,8 +28,8 @@
#include "DNA_node_types.h" #include "DNA_node_types.h"
/** /**
* @brief OutputFileNode * \brief OutputFileNode
* @ingroup Node * \ingroup Node
*/ */
class OutputFileNode : public Node { class OutputFileNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_PixelateNode.h
View File

@ -26,8 +26,8 @@
#include "COM_Node.h" #include "COM_Node.h"
/** /**
* @brief PixelateNode * \brief PixelateNode
* @ingroup Node * \ingroup Node
*/ */
class PixelateNode : public Node { class PixelateNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_PlaneTrackDeformNode.h
View File

@ -27,8 +27,8 @@ extern "C" {
} }
/** /**
* @brief PlaneTrackDeformNode * \brief PlaneTrackDeformNode
* @ingroup Node * \ingroup Node
*/ */
class PlaneTrackDeformNode : public Node { class PlaneTrackDeformNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_RenderLayersNode.h
View File

@ -27,8 +27,8 @@
struct Render; struct Render;
/** /**
* @brief RenderLayersNode * \brief RenderLayersNode
* @ingroup Node * \ingroup Node
*/ */
class RenderLayersNode : public Node { class RenderLayersNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_RotateNode.h
View File

@ -26,8 +26,8 @@
#include "COM_Node.h" #include "COM_Node.h"
/** /**
* @brief RotateNode * \brief RotateNode
* @ingroup Node * \ingroup Node
*/ */
class RotateNode : public Node { class RotateNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_ScaleNode.h
View File

@ -26,8 +26,8 @@
#include "COM_Node.h" #include "COM_Node.h"
/** /**
* @brief ScaleNode * \brief ScaleNode
* @ingroup Node * \ingroup Node
*/ */
class ScaleNode : public Node { class ScaleNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_SetAlphaNode.h
View File

@ -26,8 +26,8 @@
#include "COM_Node.h" #include "COM_Node.h"
/** /**
* @brief SetAlphaNode * \brief SetAlphaNode
* @ingroup Node * \ingroup Node
*/ */
class SetAlphaNode : public Node { class SetAlphaNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_SocketProxyNode.h
View File

@ -26,8 +26,8 @@
#include "COM_Node.h" #include "COM_Node.h"
/** /**
* @brief SocketProxyNode * \brief SocketProxyNode
* @ingroup Node * \ingroup Node
*/ */
class SocketProxyNode : public Node { class SocketProxyNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_SplitViewerNode.h
View File

@ -26,8 +26,8 @@
#include "COM_Node.h" #include "COM_Node.h"
#include "DNA_node_types.h" #include "DNA_node_types.h"
/** /**
* @brief SplitViewerNode * \brief SplitViewerNode
* @ingroup Node * \ingroup Node
*/ */
class SplitViewerNode : public Node { class SplitViewerNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_Stabilize2dNode.h
View File

@ -27,8 +27,8 @@
#include "DNA_node_types.h" #include "DNA_node_types.h"
/** /**
* @brief Stabilize2dNode * \brief Stabilize2dNode
* @ingroup Node * \ingroup Node
*/ */
class Stabilize2dNode : public Node { class Stabilize2dNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_SunBeamsNode.h
View File

@ -25,8 +25,8 @@
#include "COM_Node.h" #include "COM_Node.h"
/** /**
* @brief SunBeamsNode * \brief SunBeamsNode
* @ingroup Node * \ingroup Node
*/ */
class SunBeamsNode : public Node { class SunBeamsNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_SwitchNode.h
View File

@ -27,8 +27,8 @@
#include "COM_NodeOperation.h" #include "COM_NodeOperation.h"
#include "DNA_node_types.h" #include "DNA_node_types.h"
/** /**
* @brief SwitchNode * \brief SwitchNode
* @ingroup Node * \ingroup Node
*/ */
class SwitchNode : public Node { class SwitchNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_SwitchViewNode.h
View File

@ -26,8 +26,8 @@
#include "COM_NodeOperation.h" #include "COM_NodeOperation.h"
#include "DNA_node_types.h" #include "DNA_node_types.h"
/** /**
* @brief SwitchViewNode * \brief SwitchViewNode
* @ingroup Node * \ingroup Node
*/ */
class SwitchViewNode : public Node { class SwitchViewNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_TextureNode.h
View File

@ -24,8 +24,8 @@
#include "DNA_node_types.h" #include "DNA_node_types.h"
/** /**
* @brief TextureNode * \brief TextureNode
* @ingroup Node * \ingroup Node
*/ */
class TextureNode : public Node { class TextureNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_TimeNode.h
View File

@ -26,8 +26,8 @@
#include "COM_Node.h" #include "COM_Node.h"
/** /**
* @brief TimeNode * \brief TimeNode
* @ingroup Node * \ingroup Node
*/ */
class TimeNode : public Node { class TimeNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_TonemapNode.h
View File

@ -26,8 +26,8 @@
#include "COM_Node.h" #include "COM_Node.h"
/** /**
* @brief TonemapNode * \brief TonemapNode
* @ingroup Node * \ingroup Node
*/ */
class TonemapNode : public Node { class TonemapNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_TrackPositionNode.h
View File

@ -25,8 +25,8 @@
#include "DNA_node_types.h" #include "DNA_node_types.h"
/** /**
* @brief TrackPositionNode * \brief TrackPositionNode
* @ingroup Node * \ingroup Node
*/ */
class TrackPositionNode : public Node { class TrackPositionNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_TransformNode.h
View File

@ -27,8 +27,8 @@
#include "DNA_node_types.h" #include "DNA_node_types.h"
/** /**
* @brief TransformNode * \brief TransformNode
* @ingroup Node * \ingroup Node
*/ */
class TransformNode : public Node { class TransformNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_TranslateNode.h
View File

@ -26,8 +26,8 @@
#include "COM_Node.h" #include "COM_Node.h"
/** /**
* @brief TranslateNode * \brief TranslateNode
* @ingroup Node * \ingroup Node
*/ */
class TranslateNode : public Node { class TranslateNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_ValueNode.h
View File

@ -26,8 +26,8 @@
#include "COM_Node.h" #include "COM_Node.h"
/** /**
* @brief ValueNode * \brief ValueNode
* @ingroup Node * \ingroup Node
*/ */
class ValueNode : public Node { class ValueNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_VectorBlurNode.h
View File

@ -26,8 +26,8 @@
#include "COM_Node.h" #include "COM_Node.h"
/** /**
* @brief VectorBlurNode * \brief VectorBlurNode
* @ingroup Node * \ingroup Node
*/ */
class VectorBlurNode : public Node { class VectorBlurNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_VectorCurveNode.h
View File

@ -26,8 +26,8 @@
#include "COM_Node.h" #include "COM_Node.h"
/** /**
* @brief VectorCurveNode * \brief VectorCurveNode
* @ingroup Node * \ingroup Node
*/ */
class VectorCurveNode : public Node { class VectorCurveNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_ViewLevelsNode.h
View File

@ -26,8 +26,8 @@
#include "COM_Node.h" #include "COM_Node.h"
/** /**
* @brief ViewLevelsNode * \brief ViewLevelsNode
* @ingroup Node * \ingroup Node
*/ */
class ViewLevelsNode : public Node { class ViewLevelsNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_ViewerNode.h
View File

@ -26,8 +26,8 @@
#include "COM_Node.h" #include "COM_Node.h"
#include "DNA_node_types.h" #include "DNA_node_types.h"
/** /**
* @brief ViewerNode * \brief ViewerNode
* @ingroup Node * \ingroup Node
*/ */
class ViewerNode : public Node { class ViewerNode : public Node {
public: public:

4
source/blender/compositor/nodes/COM_ZCombineNode.h
View File

@ -26,8 +26,8 @@
#include "COM_Node.h" #include "COM_Node.h"
/** /**
* @brief ZCombineNode * \brief ZCombineNode
* @ingroup Node * \ingroup Node
*/ */
class ZCombineNode : public Node { class ZCombineNode : public Node {
public: public:

Some files were not shown because too many files have changed in this diff Show More