Cleanup: replace doxy @ with backslash
authorCampbell Barton <ideasman42@gmail.com>
Wed, 5 Sep 2018 04:56:29 +0000 (14:56 +1000)
committerCampbell Barton <ideasman42@gmail.com>
Wed, 5 Sep 2018 04:56:29 +0000 (14:56 +1000)
The rest of Blender uses backslashes.

130 files changed:
source/blender/compositor/COM_compositor.h
source/blender/compositor/COM_defines.h
source/blender/compositor/intern/COM_CPUDevice.h
source/blender/compositor/intern/COM_CompositorContext.h
source/blender/compositor/intern/COM_Converter.h
source/blender/compositor/intern/COM_Device.h
source/blender/compositor/intern/COM_ExecutionGroup.cpp
source/blender/compositor/intern/COM_ExecutionGroup.h
source/blender/compositor/intern/COM_ExecutionSystem.h
source/blender/compositor/intern/COM_MemoryBuffer.h
source/blender/compositor/intern/COM_MemoryProxy.h
source/blender/compositor/intern/COM_Node.h
source/blender/compositor/intern/COM_NodeGraph.cpp
source/blender/compositor/intern/COM_NodeOperation.h
source/blender/compositor/intern/COM_OpenCLDevice.h
source/blender/compositor/intern/COM_SocketReader.h
source/blender/compositor/intern/COM_WorkPackage.h
source/blender/compositor/intern/COM_WorkScheduler.cpp
source/blender/compositor/intern/COM_WorkScheduler.h
source/blender/compositor/nodes/COM_AlphaOverNode.h
source/blender/compositor/nodes/COM_BilateralBlurNode.h
source/blender/compositor/nodes/COM_BlurNode.h
source/blender/compositor/nodes/COM_BokehBlurNode.h
source/blender/compositor/nodes/COM_BokehImageNode.h
source/blender/compositor/nodes/COM_BoxMaskNode.h
source/blender/compositor/nodes/COM_BrightnessNode.h
source/blender/compositor/nodes/COM_ChannelMatteNode.h
source/blender/compositor/nodes/COM_ChromaMatteNode.h
source/blender/compositor/nodes/COM_ColorBalanceNode.h
source/blender/compositor/nodes/COM_ColorCorrectionNode.h
source/blender/compositor/nodes/COM_ColorCurveNode.h
source/blender/compositor/nodes/COM_ColorMatteNode.h
source/blender/compositor/nodes/COM_ColorNode.h
source/blender/compositor/nodes/COM_ColorRampNode.h
source/blender/compositor/nodes/COM_ColorSpillNode.h
source/blender/compositor/nodes/COM_ColorToBWNode.h
source/blender/compositor/nodes/COM_CompositorNode.h
source/blender/compositor/nodes/COM_ConvertAlphaNode.h
source/blender/compositor/nodes/COM_CornerPinNode.h
source/blender/compositor/nodes/COM_CropNode.h
source/blender/compositor/nodes/COM_CryptomatteNode.h
source/blender/compositor/nodes/COM_DefocusNode.h
source/blender/compositor/nodes/COM_DespeckleNode.h
source/blender/compositor/nodes/COM_DifferenceMatteNode.h
source/blender/compositor/nodes/COM_DilateErodeNode.h
source/blender/compositor/nodes/COM_DirectionalBlurNode.h
source/blender/compositor/nodes/COM_DisplaceNode.h
source/blender/compositor/nodes/COM_DistanceMatteNode.h
source/blender/compositor/nodes/COM_DoubleEdgeMaskNode.h
source/blender/compositor/nodes/COM_EllipseMaskNode.h
source/blender/compositor/nodes/COM_FilterNode.h
source/blender/compositor/nodes/COM_FlipNode.cpp
source/blender/compositor/nodes/COM_FlipNode.h
source/blender/compositor/nodes/COM_GammaNode.h
source/blender/compositor/nodes/COM_GlareNode.h
source/blender/compositor/nodes/COM_HueSaturationValueCorrectNode.h
source/blender/compositor/nodes/COM_HueSaturationValueNode.h
source/blender/compositor/nodes/COM_IDMaskNode.h
source/blender/compositor/nodes/COM_ImageNode.h
source/blender/compositor/nodes/COM_InpaintNode.h
source/blender/compositor/nodes/COM_InvertNode.h
source/blender/compositor/nodes/COM_KeyingNode.h
source/blender/compositor/nodes/COM_KeyingScreenNode.h
source/blender/compositor/nodes/COM_LensDistortionNode.h
source/blender/compositor/nodes/COM_LuminanceMatteNode.h
source/blender/compositor/nodes/COM_MapRangeNode.h
source/blender/compositor/nodes/COM_MapUVNode.h
source/blender/compositor/nodes/COM_MapValueNode.h
source/blender/compositor/nodes/COM_MaskNode.h
source/blender/compositor/nodes/COM_MathNode.h
source/blender/compositor/nodes/COM_MixNode.h
source/blender/compositor/nodes/COM_MovieClipNode.h
source/blender/compositor/nodes/COM_MovieDistortionNode.h
source/blender/compositor/nodes/COM_NormalNode.h
source/blender/compositor/nodes/COM_NormalizeNode.h
source/blender/compositor/nodes/COM_OutputFileNode.h
source/blender/compositor/nodes/COM_PixelateNode.h
source/blender/compositor/nodes/COM_PlaneTrackDeformNode.h
source/blender/compositor/nodes/COM_RenderLayersNode.h
source/blender/compositor/nodes/COM_RotateNode.h
source/blender/compositor/nodes/COM_ScaleNode.h
source/blender/compositor/nodes/COM_SetAlphaNode.h
source/blender/compositor/nodes/COM_SocketProxyNode.h
source/blender/compositor/nodes/COM_SplitViewerNode.h
source/blender/compositor/nodes/COM_Stabilize2dNode.h
source/blender/compositor/nodes/COM_SunBeamsNode.h
source/blender/compositor/nodes/COM_SwitchNode.h
source/blender/compositor/nodes/COM_SwitchViewNode.h
source/blender/compositor/nodes/COM_TextureNode.h
source/blender/compositor/nodes/COM_TimeNode.h
source/blender/compositor/nodes/COM_TonemapNode.h
source/blender/compositor/nodes/COM_TrackPositionNode.h
source/blender/compositor/nodes/COM_TransformNode.h
source/blender/compositor/nodes/COM_TranslateNode.h
source/blender/compositor/nodes/COM_ValueNode.h
source/blender/compositor/nodes/COM_VectorBlurNode.h
source/blender/compositor/nodes/COM_VectorCurveNode.h
source/blender/compositor/nodes/COM_ViewLevelsNode.h
source/blender/compositor/nodes/COM_ViewerNode.h
source/blender/compositor/nodes/COM_ZCombineNode.h
source/blender/compositor/operations/COM_AntiAliasOperation.h
source/blender/compositor/operations/COM_BokehImageOperation.h
source/blender/compositor/operations/COM_CalculateMeanOperation.h
source/blender/compositor/operations/COM_CalculateStandardDeviationOperation.h
source/blender/compositor/operations/COM_CompositorOperation.h
source/blender/compositor/operations/COM_ConvertColorProfileOperation.h
source/blender/compositor/operations/COM_DotproductOperation.cpp
source/blender/compositor/operations/COM_GaussianAlphaXBlurOperation.h
source/blender/compositor/operations/COM_GaussianAlphaYBlurOperation.h
source/blender/compositor/operations/COM_GaussianXBlurOperation.h
source/blender/compositor/operations/COM_GaussianYBlurOperation.h
source/blender/compositor/operations/COM_GlareBaseOperation.h
source/blender/compositor/operations/COM_GlareThresholdOperation.h
source/blender/compositor/operations/COM_ImageOperation.h
source/blender/compositor/operations/COM_MapValueOperation.h
source/blender/compositor/operations/COM_NormalizeOperation.h
source/blender/compositor/operations/COM_PixelateOperation.h
source/blender/compositor/operations/COM_PreviewOperation.h
source/blender/compositor/operations/COM_ReadBufferOperation.cpp
source/blender/compositor/operations/COM_RenderLayersProg.h
source/blender/compositor/operations/COM_TextureOperation.h
source/blender/compositor/operations/COM_TonemapOperation.h
source/blender/compositor/operations/COM_VectorBlurOperation.h
source/blender/compositor/operations/COM_WriteBufferOperation.h
source/blender/freestyle/intern/stroke/AdvancedStrokeShaders.h
source/blender/freestyle/intern/stroke/BasicStrokeShaders.h
source/blender/freestyle/intern/stroke/Stroke.h
source/gameengine/Ketsji/KX_GameObject.h
source/gameengine/Rasterizer/RAS_ICanvas.cpp
source/gameengine/Rasterizer/RAS_ICanvas.h

index 10b62070978a82a6c373a13e1d64b84bea064f3d..f9fd0999acc697a571d9131ba7c7fd47c80e3fc7 100644 (file)
@@ -31,26 +31,26 @@ extern "C" {
 #include "DNA_node_types.h"
 
 /**
- * @defgroup Model The data model of the compositor
- * @defgroup Memory The memory management stuff
- * @defgroup Execution The execution logic
- * @defgroup Conversion Conversion logic
- * @defgroup Node All nodes of the compositor
- * @defgroup Operation All operations of the compositor
+ * \defgroup Model The data model of the compositor
+ * \defgroup Memory The memory management stuff
+ * \defgroup Execution The execution logic
+ * \defgroup Conversion Conversion logic
+ * \defgroup Node All nodes 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.
  * 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.
  *
- * @section goals The goals of the project
+ * \section goals The goals of the project
  * the new compositor has 2 goals.
  *   - Make a faster compositor (speed of calculation)
  *   - 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
  * 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.
@@ -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
  * 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
  * 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.
  *
- * @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.
  * Ranging from low-end machines to very high-end machines.
  * The system should work on high-end machines and on low-end machines.
  *
  *
- * @page executing Executing
- * @section prepare Prepare execution
+ * \page executing Executing
+ * \section prepare Prepare execution
  *
  * during the preparation of the execution All ReadBufferOperation will receive an offset.
  * This offset is used during execution as an optimization trick
- * Next all operations will be initialized for execution @see NodeOperation.initExecution
- * Next all ExecutionGroup's will be initialized for execution @see ExecutionGroup.initExecution
- * this all is controlled from @see ExecutionSystem.execute
+ * Next all operations will be initialized for execution \see NodeOperation.initExecution
+ * Next all ExecutionGroup's will be initialized for execution \see ExecutionGroup.initExecution
+ * 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
  * than during editing.
  * 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.
  * When match the ExecutionGroup will be executed (this happens in serial)
  *
- * @see ExecutionSystem.execute control of the Render priority
- * @see NodeOperation.getRenderPriority receive the render priority
- * @see ExecutionGroup.execute the main loop to execute a whole ExecutionGroup
+ * \see ExecutionSystem.execute control of the Render priority
+ * \see NodeOperation.getRenderPriority receive the render priority
+ * \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.
  * 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_EXECUTED]: Chunk is finished
  *
- * @see ExecutionGroup.execute
- * @see ViewerOperation.getChunkOrder
- * @see OrderOfChunks
+ * \see ExecutionGroup.execute
+ * \see ViewerOperation.getChunkOrder
+ * \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
  * one are stored in 'chunks'.
  * If not all input chunks are available the chunk execution will not be scheduled.
@@ -206,40 +206,40 @@ extern "C" {
  *
  * </pre>
  *
- * @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.execute Execute a complete ExecutionGroup. Halts until finished or breaked by user
+ * \see ExecutionGroup.scheduleChunkWhenPossible Tries to schedule a single chunk,
  * 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])
- * @see ExecutionGroup.scheduleChunk Schedule a chunk on the WorkScheduler
- * @see NodeOperation.determineDependingAreaOfInterest Influence the area of interest of a chunk.
- * @see WriteBufferOperation Operation to write to 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 MemoryBuffer Allocated memory for a single chunk
- *
- * @section workscheduler WorkScheduler
+ * \see ExecutionGroup.scheduleChunk Schedule a chunk on the WorkScheduler
+ * \see NodeOperation.determineDependingAreaOfInterest Influence the area of interest of a chunk.
+ * \see WriteBufferOperation Operation to write to 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 MemoryBuffer Allocated memory for a single chunk
+ *
+ * \section workscheduler WorkScheduler
  * the WorkScheduler is implemented as a static class. the responsibility of the WorkScheduler is to balance
  * 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
  *
- * @subsection multithread Multi threaded
+ * \subsection multithread Multi threaded
  * 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 a specific Device.
  * 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
  * to COM_TM_NOTHREAD. When compiling the work-scheduler
  * 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.
  * This chunk is encapsulated in a WorkPackage.
  * 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
  * all devices that will be used during compositor.
  * 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.
  *
- * @see WorkScheduler.schedule method that is called to schedule a chunk
- * @see Device.execute method called to execute a chunk
+ * \see WorkScheduler.schedule method that is called to schedule 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.
  * Allocation is already done by the ExecutionGroup.
  * The outputbuffer of the chunk is being created.
  * The OutputOperation of the ExecutionGroup is called to execute the area of the outputbuffer.
  *
- * @see ExecutionGroup
- * @see NodeOperation.executeRegion executes a single chunk of a NodeOperation
- * @see CPUDevice.execute
+ * \see ExecutionGroup
+ * \see NodeOperation.executeRegion executes a single chunk of a NodeOperation
+ * \see CPUDevice.execute
  *
- * @subsection GPUDevice OpenCLDevice
+ * \subsection GPUDevice OpenCLDevice
  *
  * To be completed!
- * @see NodeOperation.executeOpenCLRegion
- * @see OpenCLDevice.execute
+ * \see NodeOperation.executeOpenCLRegion
+ * \see OpenCLDevice.execute
  *
- * @section executePixel executing a pixel
+ * \section executePixel executing a pixel
  * 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
  * (renderer/pipeline.c)
  *
- * @param rd [struct RenderData]
+ * \param rd [struct RenderData]
  *   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
  *
- * @param rendering [true false]
+ * \param rendering [true false]
  *    This parameter determines whether the function is called from rendering (true) or editing (false).
  *    based on this setting the system will work differently:
  *     - 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
- * @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.
  *       quality can be modified by the user from within the node panels.
- * @see bNodeTree.edit_quality
- * @see bNodeTree.render_quality
+ * \see bNodeTree.edit_quality
+ * \see bNodeTree.render_quality
  *
  *     - output nodes can have different priorities in the WorkScheduler.
  * This is implemented in the COM_execute function.
  *
- * @param viewSettings
+ * \param viewSettings
  *   reference to view settings used for color management
  *
- * @param displaySettings
+ * \param displaySettings
  *   reference to display settings used for color management
  *
  * 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);
 
 /**
- * @brief Deinitialize the compositor caches and allocated memory.
+ * \brief Deinitialize the compositor caches and allocated memory.
  * Use COM_clearCaches to only free the caches.
  */
 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.
  */
 // void COM_clearCaches(void); // NOT YET WRITTEN
index 67b7f9b592ba8b399e4f669974b3b78cc29de5dc..c8e924da6a2a2b411a45b93e5501b990bbf64cff 100644 (file)
 #define __COM_DEFINES_H__
 
 /**
- * @brief possible data types for sockets
- * @ingroup Model
+ * \brief possible data types for sockets
+ * \ingroup Model
  */
 typedef enum DataType {
-       /** @brief Value data type */
+       /** \brief Value data type */
        COM_DT_VALUE   = 1,
-       /** @brief Vector data type */
+       /** \brief Vector data type */
        COM_DT_VECTOR  = 2,
-       /** @brief Color data type */
+       /** \brief Color data type */
        COM_DT_COLOR   = 4
 } DataType;
 
 /**
- * @brief Possible quality settings
- * @see CompositorContext.quality
- * @ingroup Execution
+ * \brief Possible quality settings
+ * \see CompositorContext.quality
+ * \ingroup Execution
  */
 typedef enum CompositorQuality {
-       /** @brief High quality setting */
+       /** \brief High quality setting */
        COM_QUALITY_HIGH   = 0,
-       /** @brief Medium quality setting */
+       /** \brief Medium quality setting */
        COM_QUALITY_MEDIUM = 1,
-       /** @brief Low quality setting */
+       /** \brief Low quality setting */
        COM_QUALITY_LOW    = 2
 } CompositorQuality;
 
 /**
- * @brief Possible priority settings
- * @ingroup Execution
+ * \brief Possible priority settings
+ * \ingroup Execution
  */
 typedef enum CompositorPriority {
-       /** @brief High quality setting */
+       /** \brief High quality setting */
        COM_PRIORITY_HIGH   = 2,
-       /** @brief Medium quality setting */
+       /** \brief Medium quality setting */
        COM_PRIORITY_MEDIUM = 1,
-       /** @brief Low quality setting */
+       /** \brief Low quality setting */
        COM_PRIORITY_LOW    = 0
 } CompositorPriority;
 
@@ -87,17 +87,17 @@ typedef enum CompositorPriority {
 #define COM_CURRENT_THREADING_MODEL COM_TM_QUEUE
 // chunk order
 /**
- * @brief The order of chunks to be scheduled
- * @ingroup Execution
+ * \brief The order of chunks to be scheduled
+ * \ingroup Execution
  */
 typedef enum OrderOfChunks {
-       /** @brief order from a distance to centerX/centerY */
+       /** \brief order from a distance to centerX/centerY */
        COM_TO_CENTER_OUT = 0,
-       /** @brief order randomly */
+       /** \brief order randomly */
        COM_TO_RANDOM = 1,
-       /** @brief no ordering */
+       /** \brief no ordering */
        COM_TO_TOP_DOWN = 2,
-       /** @brief experimental ordering with 9 hotspots */
+       /** \brief experimental ordering with 9 hotspots */
        COM_TO_RULE_OF_THIRDS = 3
 } OrderOfChunks;
 
index b938b5fc5880ac138346c5b8b4a59897b352494f..8d4d5f1c3240c6f58be95ea00d90a0aa42cef26b 100644 (file)
 #include "COM_Device.h"
 
 /**
- * @brief class representing a CPU device.
- * @note for every hardware thread in the system a CPUDevice instance will exist in the workscheduler
+ * \brief class representing a CPU device.
+ * \note for every hardware thread in the system a CPUDevice instance will exist in the workscheduler
  */
 class CPUDevice : public Device {
 public:
        CPUDevice(int thread_id);
 
        /**
-        * @brief execute a WorkPackage
-        * @param work the WorkPackage to execute
+        * \brief execute a WorkPackage
+        * \param work the WorkPackage to execute
         */
        void execute(WorkPackage *work);
 
index b43e163870c4378d29cace7fffbc7fb64d8161bd..e7889b11f5b2cae2effbac594965325497fdbf8e 100644 (file)
 #include "COM_defines.h"
 
 /**
- * @brief Overall context of the compositor
+ * \brief Overall context of the compositor
  */
 class CompositorContext {
 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.
-        * @see ExecutionSystem
+        * \see ExecutionSystem
         */
        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.
-        * @see ExecutionSystem
+        * \see ExecutionSystem
         */
        CompositorQuality m_quality;
 
        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.
-        * @see ExecutionSystem
+        * \see ExecutionSystem
         */
        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.
-        * @see ExecutionSystem
+        * \see ExecutionSystem
         */
        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.
         */
        bNodeInstanceHash *m_previews;
 
        /**
-        * @brief does this system have active opencl devices?
+        * \brief does this system have active opencl devices?
         */
        bool m_hasActiveOpenCLDevices;
 
        /**
-        * @brief Skip slow nodes
+        * \brief Skip slow nodes
         */
        bool m_fastCalculation;
 
-       /* @brief color management settings */
+       /* \brief color management settings */
        const ColorManagedViewSettings *m_viewSettings;
        const ColorManagedDisplaySettings *m_displaySettings;
 
        /**
-        * @brief active rendering view name
+        * \brief active rendering view name
         */
        const char *m_viewName;
 
 public:
        /**
-        * @brief constructor initializes the context with default values.
+        * \brief constructor initializes the context with default values.
         */
        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; }
 
        /**
-        * @brief get the rendering field of the context
+        * \brief get the rendering field of the context
         */
        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; }
 
        /**
-        * @brief set the bnodetree of the context
+        * \brief set the bnodetree of the context
         */
        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; }
 
        /**
-        * @brief get the scene of the context
+        * \brief get the scene of the context
         */
        const RenderData *getRenderData() const { return this->m_rd; }
 
@@ -131,67 +131,67 @@ public:
        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; }
 
        /**
-        * @brief get the preview image hash table
+        * \brief get the preview image hash table
         */
        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; }
 
        /**
-        * @brief get view settings of color color management
+        * \brief get view settings of color color management
         */
        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; }
 
        /**
-        * @brief get display settings of color color management
+        * \brief get display settings of color color management
         */
        const ColorManagedDisplaySettings *getDisplaySettings() const { return this->m_displaySettings; }
 
        /**
-        * @brief set the quality
+        * \brief set the 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; }
 
        /**
-        * @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;
 
        /**
-        * @brief has this system active openclDevices?
+        * \brief has this system active openclDevices?
         */
        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; }
 
        /**
-        * @brief get the active rendering view
+        * \brief get the active rendering view
         */
        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; }
 
index d0b888e24a0f85a10ed74601a33f790b4d1d5452..05d23eb3e7ec952ae29bcfb578c4ac7c1c99b9e8 100644 (file)
@@ -36,48 +36,48 @@ class NodeOperationOutput;
 class NodeOperationBuilder;
 
 /**
- * @brief Conversion methods for the compositor
+ * \brief Conversion methods for the compositor
  */
 class Converter {
 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.
         *
-        * @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);
 
        /**
-        * @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.
         */
        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 system the ExecutionSystem to add the conversion to.
-        * @see NodeLink - a link between two sockets
+        * \param link the NodeLink what needs conversion
+        * \param system the ExecutionSystem to add the conversion to.
+        * \see NodeLink - a link between two sockets
         */
        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
-        * @see InputSocketResizeMode for the possible conversions.
+        * \note Conversion logic is implemented in this method
+        * \see InputSocketResizeMode for the possible conversions.
         *
-        * @param link the NodeLink what needs conversion
-        * @param system the ExecutionSystem to add the conversion to.
-        * @see NodeLink - a link between two sockets
+        * \param link the NodeLink what needs conversion
+        * \param system the ExecutionSystem to add the conversion to.
+        * \see NodeLink - a link between two sockets
         */
        static void convertResolution(NodeOperationBuilder &builder, NodeOperationOutput *fromSocket, NodeOperationInput *toSocket);
 
index 202ca1d0b4f92a9f8bee9a1e1b4229e40e589c6f..8cb1cbebf7ffdb789ca2522301b6e81e448af22c 100644 (file)
@@ -26,7 +26,7 @@
 #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.
  * work are packaged as a WorkPackage instance.
  */
@@ -34,24 +34,24 @@ class Device {
 
 public:
        /**
-        * @brief Declaration of the virtual destructor
-        * @note resolve warning gcc 4.7
+        * \brief Declaration of the virtual destructor
+        * \note resolve warning gcc 4.7
         */
        virtual ~Device() {}
 
        /**
-        * @brief initialize the device
+        * \brief initialize the device
         */
        virtual bool initialize() { return true; }
 
        /**
-        * @brief deinitialize the device
+        * \brief deinitialize the device
         */
        virtual void deinitialize() {}
 
        /**
-        * @brief execute a WorkPackage
-        * @param work the WorkPackage to execute
+        * \brief execute a WorkPackage
+        * \param work the WorkPackage to execute
         */
        virtual void execute(WorkPackage *work) = 0;
 
index 5a651f07868566d92ab8535a60423e396dd1fc3a..c4ef21d1f13502dc935a7467bee6c947eab5b5ec 100644 (file)
@@ -185,9 +185,9 @@ void ExecutionGroup::execute(ExecutionSystem *graph)
 {
        const CompositorContext &context = graph->getContext();
        const bNodeTree *bTree = context.getbNodeTree();
-       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 (this->m_numberOfChunks == 0) {return; } /// @note: early break out
+       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 (this->m_numberOfChunks == 0) {return; } /// \note: early break out
        unsigned int chunkNumber;
 
        this->m_executionStartTime = PIL_check_seconds_timer();
index 88c702b84775dcdc6148f7508d9753a6dadee26c..da57c89a89465e2ee19f2b4ae0e5184fb7c7cb67 100644 (file)
@@ -39,28 +39,28 @@ class ReadBufferOperation;
 class Device;
 
 /**
- * @brief the execution state of a chunk in an ExecutionGroup
- * @ingroup Execution
+ * \brief the execution state of a chunk in an ExecutionGroup
+ * \ingroup Execution
  */
 typedef enum ChunkExecutionState {
        /**
-        * @brief chunk is not yet scheduled
+        * \brief chunk is not yet scheduled
         */
        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,
        /**
-        * @brief chunk is executed.
+        * \brief chunk is executed.
         */
        COM_ES_EXECUTED = 2
 } 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.
- * @ingroup Execution
+ * \ingroup Execution
  */
 class ExecutionGroup {
 public:
@@ -70,86 +70,86 @@ private:
        // fields
 
        /**
-        * @brief list of operations in this ExecutionGroup
+        * \brief list of operations in this ExecutionGroup
         */
        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)
         */
        int m_isOutput;
 
        /**
-        * @brief Width of the output
+        * \brief Width of the output
         */
        unsigned int m_width;
 
        /**
-        * @brief Height of the output
+        * \brief Height of the output
         */
        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
         */
        unsigned int m_chunkSize;
 
        /**
-        * @brief number of chunks in the x-axis
+        * \brief number of chunks in the x-axis
         */
        unsigned int m_numberOfXChunks;
 
        /**
-        * @brief number of chunks in the y-axis
+        * \brief number of chunks in the y-axis
         */
        unsigned int m_numberOfYChunks;
 
        /**
-        * @brief total number of chunks
+        * \brief total number of chunks
         */
        unsigned int m_numberOfChunks;
 
        /**
-        * @brief contains this ExecutionGroup a complex NodeOperation.
+        * \brief contains this ExecutionGroup a complex NodeOperation.
         */
        bool m_complex;
 
        /**
-        * @brief can this ExecutionGroup be scheduled on an OpenCLDevice
+        * \brief can this ExecutionGroup be scheduled on an OpenCLDevice
         */
        bool m_openCL;
 
        /**
-        * @brief Is this Execution group SingleThreaded
+        * \brief Is this Execution group SingleThreaded
         */
        bool m_singleThreaded;
 
        /**
-        * @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.
+        * \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.
         */
        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;
 
        /**
-        * @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
+        * \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
         */
        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;
 
        /**
-        * @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_SCHEDULED: scheduled
         *   - COM_ES_EXECUTED: executed
@@ -157,92 +157,92 @@ private:
        ChunkExecutionState *m_chunkExecutionStates;
 
        /**
-        * @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 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 and the Initialized flag is set to true.
-        * @see complex
-        * @see openCL
+        * \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 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 and the Initialized flag is set to true.
+        * \see complex
+        * \see openCL
         */
        bool m_initialized;
 
        /**
-        * @brief denotes boundary for border compositing
-        * @note measured in pixel space
+        * \brief denotes boundary for border compositing
+        * \note measured in pixel space
         */
        rcti m_viewerBorder;
 
        /**
-        * @brief start time of execution
+        * \brief start time of execution
         */
        double m_executionStartTime;
 
        // methods
        /**
-        * @brief check whether parameter operation can be added to the execution group
-        * @param operation the operation to be added
+        * \brief check whether parameter operation can be added to the execution group
+        * \param operation the operation to be added
         */
        bool canContainOperation(NodeOperation *operation);
 
        /**
-        * @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 The chunk size will not be stored in the chunkSize field. This needs to be done
-        * @note by the calling method.
+        * \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 The chunk size will not be stored in the chunkSize field. This needs to be done
+        * \note by the calling method.
         */
        unsigned int determineChunkSize();
 
 
        /**
-        * @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
-        * @see determineChunkSize()
+        * \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
+        * \see determineChunkSize()
         */
        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.
-        * @note The result are stored in the fields numberOfChunks, numberOfXChunks, numberOfYChunks
+        * \brief determine the number of chunks, based on the chunkSize, width and height.
+        * \note The result are stored in the fields numberOfChunks, numberOfXChunks, numberOfYChunks
         */
        void determineNumberOfChunks();
 
        /**
-        * @brief try to schedule a specific chunk.
-        * @note scheduling succeeds when all input requirements are met and the chunks hasn't been scheduled yet.
-        * @param graph
-        * @param xChunk
-        * @param yChunk
-        * @return [true:false]
+        * \brief try to schedule a specific chunk.
+        * \note scheduling succeeds when all input requirements are met and the chunks hasn't been scheduled yet.
+        * \param graph
+        * \param xChunk
+        * \param yChunk
+        * \return [true:false]
         * true: package(s) are scheduled
         * false: scheduling is deferred (depending workpackages are scheduled)
         */
        bool scheduleChunkWhenPossible(ExecutionSystem *graph, int xChunk, int yChunk);
 
        /**
-        * @brief try to schedule a specific area.
-        * @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.
-        * @param graph
-        * @param rect
-        * @return [true:false]
+        * \brief try to schedule a specific area.
+        * \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.
+        * \param graph
+        * \param rect
+        * \return [true:false]
         * true: package(s) are scheduled
         * false: scheduling is deferred (depending workpackages are scheduled)
         */
        bool scheduleAreaWhenPossible(ExecutionSystem *graph, rcti *rect);
 
        /**
-        * @brief add a chunk to the WorkScheduler.
-        * @param chunknumber
+        * \brief add a chunk to the WorkScheduler.
+        * \param chunknumber
         */
        bool scheduleChunk(unsigned int chunkNumber);
 
        /**
-        * @brief determine the area of interest of a certain input area
-        * @note This method only evaluates a single ReadBufferOperation
-        * @param input the input area
-        * @param readOperation The ReadBufferOperation where the area needs to be evaluated
-        * @param output the area needed of the ReadBufferOperation. Result
+        * \brief determine the area of interest of a certain input area
+        * \note This method only evaluates a single ReadBufferOperation
+        * \param input the input area
+        * \param readOperation The ReadBufferOperation where the area needs to be evaluated
+        * \param output the area needed of the ReadBufferOperation. Result
         */
        void determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output);
 
@@ -253,116 +253,116 @@ public:
 
        // methods
        /**
-        * @brief add an operation to this ExecutionGroup
-        * @note this method will add input of the operations recursively
-        * @note this method can create multiple ExecutionGroup's
-        * @param system
-        * @param operation
-        * @return True if the operation was successfully added
+        * \brief add an operation to this ExecutionGroup
+        * \note this method will add input of the operations recursively
+        * \note this method can create multiple ExecutionGroup's
+        * \param system
+        * \param operation
+        * \return True if the operation was successfully added
         */
        bool addOperation(NodeOperation *operation);
 
        /**
-        * @brief is this ExecutionGroup an output ExecutionGroup
-        * @note An OutputExecution group are groups containing a
-        * @note ViewerOperation, CompositeOperation, PreviewOperation.
-        * @see NodeOperation.isOutputOperation
+        * \brief is this ExecutionGroup an output ExecutionGroup
+        * \note An OutputExecution group are groups containing a
+        * \note ViewerOperation, CompositeOperation, PreviewOperation.
+        * \see NodeOperation.isOutputOperation
         */
        const int isOutputExecutionGroup() const { return this->m_isOutput; }
 
        /**
-        * @brief set whether this ExecutionGroup is an output
-        * @param isOutput
+        * \brief set whether this ExecutionGroup is an output
+        * \param isOutput
         */
        void setOutputExecutionGroup(int isOutput) { this->m_isOutput = isOutput; }
 
        /**
-        * @brief determine the resolution of this ExecutionGroup
-        * @param resolution
+        * \brief determine the resolution of this ExecutionGroup
+        * \param resolution
         */
        void determineResolution(unsigned int resolution[2]);
 
        /**
-        * @brief set the resolution of this executiongroup
-        * @param resolution
+        * \brief set the resolution of this executiongroup
+        * \param resolution
         */
        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; }
 
        /**
-        * @brief get the height of this execution group
+        * \brief get the height of this execution group
         */
        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; }
 
 
        /**
-        * @brief get the output operation of this ExecutionGroup
-        * @return NodeOperation *output operation
+        * \brief get the output operation of this ExecutionGroup
+        * \return NodeOperation *output operation
         */
        NodeOperation *getOutputOperation() const;
 
        /**
-        * @brief compose multiple chunks into a single chunk
-        * @return Memorybuffer *consolidated chunk
+        * \brief compose multiple chunks into a single chunk
+        * \return Memorybuffer *consolidated chunk
         */
        MemoryBuffer *constructConsolidatedMemoryBuffer(MemoryProxy *memoryProxy, rcti *output);
 
        /**
-        * @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.
+        * \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.
         */
        void initExecution();
 
        /**
-        * @brief get all inputbuffers needed to calculate an chunk
-        * @note all inputbuffers must be executed
-        * @param chunkNumber the chunk to be calculated
-        * @return (MemoryBuffer **) the inputbuffers
+        * \brief get all inputbuffers needed to calculate an chunk
+        * \note all inputbuffers must be executed
+        * \param chunkNumber the chunk to be calculated
+        * \return (MemoryBuffer **) the inputbuffers
         */
        MemoryBuffer **getInputBuffersCPU();
 
        /**
-        * @brief get all inputbuffers needed to calculate an chunk
-        * @note all inputbuffers must be executed
-        * @param chunkNumber the chunk to be calculated
-        * @return (MemoryBuffer **) the inputbuffers
+        * \brief get all inputbuffers needed to calculate an chunk
+        * \note all inputbuffers must be executed
+        * \param chunkNumber the chunk to be calculated
+        * \return (MemoryBuffer **) the inputbuffers
         */
        MemoryBuffer **getInputBuffersOpenCL(int chunkNumber);
 
        /**
-        * @brief allocate the outputbuffer of a chunk
-        * @param chunkNumber the number of the chunk in the ExecutionGroup
-        * @param rect the rect of that chunk
-        * @see determineChunkRect
+        * \brief allocate the outputbuffer of a chunk
+        * \param chunkNumber the number of the chunk in the ExecutionGroup
+        * \param rect the rect of that chunk
+        * \see determineChunkRect
         */
        MemoryBuffer *allocateOutputBuffer(int chunkNumber, rcti *rect);
 
        /**
-        * @brief after a chunk is executed the needed resources can be freed or unlocked.
-        * @param chunknumber
-        * @param memorybuffers
+        * \brief after a chunk is executed the needed resources can be freed or unlocked.
+        * \param chunknumber
+        * \param memorybuffers
         */
        void finalizeChunkExecution(int chunkNumber, MemoryBuffer **memoryBuffers);
 
        /**
-        * @brief deinitExecution is called just after execution the whole graph.
-        * @note It will release all needed resources
+        * \brief deinitExecution is called just after execution the whole graph.
+        * \note It will release all needed resources
         */
        void deinitExecution();
 
 
        /**
-        * @brief schedule an ExecutionGroup
-        * @note this method will return when all chunks have been calculated, or the execution has breaked (by user)
+        * \brief schedule an ExecutionGroup
+        * \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.
         *   - ChunkOrdering
@@ -371,43 +371,43 @@ public:
         *
         * After determining the order of the chunks the chunks will be scheduled
         *
-        * @see ViewerOperation
-        * @param system
+        * \see ViewerOperation
+        * \param system
         */
        void execute(ExecutionSystem *system);
 
        /**
-        * @brief this method determines the MemoryProxy's where this execution group depends on.
-        * @note After this method determineDependingAreaOfInterest can be called to determine
-        * @note the area of the MemoryProxy.creator that has to be executed.
-        * @param memoryProxies result
+        * \brief this method determines the MemoryProxy's where this execution group depends on.
+        * \note After this method determineDependingAreaOfInterest can be called to determine
+        * \note the area of the MemoryProxy.creator that has to be executed.
+        * \param memoryProxies result
         */
        void determineDependingMemoryProxies(vector<MemoryProxy *> *memoryProxies);
 
        /**
-        * @brief Determine the rect (minx, maxx, miny, maxy) of a chunk.
-        * @note Only gives useful results ater the determination of the chunksize
-        * @see determineChunkSize()
+        * \brief Determine the rect (minx, maxx, miny, maxy) of a chunk.
+        * \note Only gives useful results ater the determination of the chunksize
+        * \see determineChunkSize()
         */
        void determineChunkRect(rcti *rect, const unsigned int chunkNumber) const;
 
        /**
-        * @brief can this ExecutionGroup be scheduled on an OpenCLDevice
-        * @see WorkScheduler.schedule
+        * \brief can this ExecutionGroup be scheduled on an OpenCLDevice
+        * \see WorkScheduler.schedule
         */
        bool isOpenCL();
 
        void setChunksize(int chunksize) { this->m_chunkSize = chunksize; }
 
        /**
-        * @brief get the Render priority of this ExecutionGroup
-        * @see ExecutionSystem.execute
+        * \brief get the Render priority of this ExecutionGroup
+        * \see ExecutionSystem.execute
         */
        CompositorPriority getRenderPriotrity();
 
        /**
-        * @brief set border for viewer operation
-        * @note all the coordinates are assumed to be in normalized space
+        * \brief set border for viewer operation
+        * \note all the coordinates are assumed to be in normalized space
         */
        void setViewerBorder(float xmin, float xmax, float ymin, float ymax);
 
index 0990df31c559ee3ee43bef3f6a93d2170b75fdec..5b0d36ebacdec5fc06d5419d12ea5942a13462b5 100644 (file)
@@ -33,23 +33,23 @@ class ExecutionGroup;
 #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.
  *
- * @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.
  * 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.
  *
- * @see ExecutionSystem
- * @see Converter.convert
- * @see Node
+ * \see ExecutionSystem
+ * \see Converter.convert
+ * \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.
  * The new system only supports a single level of node_tree. We will 'flatten' the system in a single level.
- * @see GroupNode
- * @see ExecutionSystemHelper.ungroup
+ * \see GroupNode
+ * \see ExecutionSystemHelper.ungroup
  *
  * 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.
@@ -59,11 +59,11 @@ class ExecutionGroup;
  * based on the selected Mixtype a different operation will be used.
  * for more information see the page about creating new Nodes. [@subpage newnode]
  *
- * @see ExecutionSystem.convertToOperations
- * @see Node.convertToOperations
- * @see NodeOperation base class for all operations in the system
+ * \see ExecutionSystem.convertToOperations
+ * \see Node.convertToOperations
+ * \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.
  *     The user can connect a Value socket to a color socket.
  *     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_NO_RESIZE]: bottom left of the images are aligned.
  *
- * @see Converter.convertDataType Datatype conversions
- * @see Converter.convertResolution Image size conversions
+ * \see Converter.convertDataType Datatype 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.
  * 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.
@@ -101,14 +101,14 @@ class ExecutionGroup;
  * |cFAA  |           |cFAA  |         |cFAA   |           |cFAA   |
  * +------+           +------+         +-------+           +-------+
  * </pre>
- * @see ExecutionSystem.groupOperations method doing this step
- * @see ExecutionSystem.addReadWriteBufferOperations
- * @see NodeOperation.isComplex
- * @see ExecutionGroup class representing the ExecutionGroup
+ * \see ExecutionSystem.groupOperations method doing this step
+ * \see ExecutionSystem.addReadWriteBufferOperations
+ * \see NodeOperation.isComplex
+ * \see ExecutionGroup class representing the ExecutionGroup
  */
 
 /**
- * @brief the ExecutionSystem contains the whole compositor tree.
+ * \brief the ExecutionSystem contains the whole compositor tree.
  */
 class ExecutionSystem {
 public:
@@ -117,17 +117,17 @@ public:
 
 private:
        /**
-        * @brief the context used during execution
+        * \brief the context used during execution
         */
        CompositorContext m_context;
 
        /**
-        * @brief vector of operations
+        * \brief vector of operations
         */
        Operations m_operations;
 
        /**
-        * @brief vector of groups
+        * \brief vector of groups
         */
        Groups m_groups;
 
@@ -144,11 +144,11 @@ private: //methods
 
 public:
        /**
-        * @brief Create a new ExecutionSystem and initialize it with the
+        * \brief Create a new ExecutionSystem and initialize it with the
         * editingtree.
         *
-        * @param editingtree [bNodeTree *]
-        * @param rendering [true false]
+        * \param editingtree [bNodeTree *]
+        * \param rendering [true false]
         */
        ExecutionSystem(RenderData *rd, Scene *scene, bNodeTree *editingtree, bool rendering, bool fastcalculation,
                        const ColorManagedViewSettings *viewSettings, const ColorManagedDisplaySettings *displaySettings,
@@ -162,7 +162,7 @@ public:
        void set_operations(const Operations &operations, const Groups &groups);
 
        /**
-        * @brief execute this system
+        * \brief execute this system
         *  - initialize the NodeOperation's and ExecutionGroup's
         *  - schedule the output ExecutionGroup's based on their priority
         *  - deinitialize the ExecutionGroup's and NodeOperation's
@@ -170,7 +170,7 @@ public:
        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; }
 
index 5f6485475d04e0fa514ea8e2e9f78ee6e5b2ec8d..e8c71d0fd554e7548eca7cfeea23f7e280e4260c 100644 (file)
@@ -35,15 +35,15 @@ extern "C" {
 }
 
 /**
- * @brief state of a memory buffer
- * @ingroup Memory
+ * \brief state of a memory buffer
+ * \ingroup Memory
  */
 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,
-       /** @brief memory is available for use, content has been created */
+       /** \brief memory is available for use, content has been created */
        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
 } MemoryBufferState;
 
@@ -56,44 +56,44 @@ typedef enum MemoryBufferExtend {
 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 {
 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;
 
        /**
-        * @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;
 
 
        /**
-        * @brief region of this buffer inside relative to the MemoryProxy
+        * \brief region of this buffer inside relative to the MemoryProxy
         */
        rcti m_rect;
 
        /**
         * brief refers to the chunknumber within the executiongroup where related to the MemoryProxy
-        * @see memoryProxy
+        * \see memoryProxy
         */
        unsigned int m_chunkNumber;
 
        /**
-        * @brief state of the buffer
+        * \brief state of the buffer
         */
        MemoryBufferState m_state;
 
        /**
-        * @brief the actual float buffer/data
+        * \brief the actual float buffer/data
         */
        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
         */
        unsigned int m_num_channels;
@@ -103,40 +103,40 @@ private:
 
 public:
        /**
-        * @brief construct new MemoryBuffer for a chunk
+        * \brief construct new MemoryBuffer for a chunk
         */
        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);
 
        /**
-        * @brief construct new temporarily MemoryBuffer for an area
+        * \brief construct new temporarily MemoryBuffer for an area
         */
        MemoryBuffer(DataType datatype, rcti *rect);
 
        /**
-        * @brief destructor
+        * \brief destructor
         */
        ~MemoryBuffer();
 
        /**
-        * @brief read the ChunkNumber of this MemoryBuffer
+        * \brief read the ChunkNumber of this MemoryBuffer
         */
        unsigned int getChunkNumber() { return this->m_chunkNumber; }
 
        unsigned int get_num_channels() { return this->m_num_channels; }
 
        /**
-        * @brief get the data of this MemoryBuffer
-        * @note buffer should already be available in memory
+        * \brief get the data of this MemoryBuffer
+        * \note buffer should already be available in memory
         */
        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()
        {
@@ -273,36 +273,36 @@ public:
        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; }
 
        /**
-        * @brief add the content from otherBuffer to this MemoryBuffer
-        * @param otherBuffer source buffer
+        * \brief add the content from otherBuffer to this MemoryBuffer
+        * \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.
         */
        void copyContentFrom(MemoryBuffer *otherBuffer);
 
        /**
-        * @brief get the rect of this MemoryBuffer
+        * \brief get the rect of this MemoryBuffer
         */
        rcti *getRect() { return &this->m_rect; }
 
        /**
-        * @brief get the width of this MemoryBuffer
+        * \brief get the width of this MemoryBuffer
         */
        int getWidth() const;
 
        /**
-        * @brief get the height of this MemoryBuffer
+        * \brief get the height of this MemoryBuffer
         */
        int getHeight() const;
 
        /**
-        * @brief clear the buffer. Make all pixels black transparent.
+        * \brief clear the buffer. Make all pixels black transparent.
         */
        void clear();
 
index a628c09fa1f4369bb71baa1073fcebcc1c6e81ca..884b32fd6fff586ed1e5df267d3bbc68597816b5 100644 (file)
@@ -31,40 +31,40 @@ class ExecutionGroup;
 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,
  * the MemoryBuffer only stores the data of a single chunk.
- * @ingroup Memory
+ * \ingroup Memory
  */
 class MemoryProxy {
 private:
        /**
-        * @brief reference to the ouput operation of the executiongroup
+        * \brief reference to the ouput operation of the executiongroup
         */
        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;
 
        /**
-        * @brief datatype of this MemoryProxy
+        * \brief datatype of this MemoryProxy
         */
        /* DataType m_datatype; */ /* UNUSED */
 
        /**
-        * @brief channel information of this buffer
+        * \brief channel information of this buffer
         */
        /* ChannelInfo m_channelInfo[COM_NUMBER_OF_CHANNELS]; */ /* UNUSED */
 
        /**
-        * @brief the allocated memory
+        * \brief the allocated memory
         */
        MemoryBuffer *m_buffer;
 
        /**
-        * @brief datatype of this MemoryProxy
+        * \brief datatype of this MemoryProxy
         */
        DataType m_datatype;
 
@@ -72,40 +72,40 @@ public:
        MemoryProxy(DataType type);
 
        /**
-        * @brief set the ExecutionGroup that can be scheduled to calculate a certain chunk.
-        * @param group the ExecutionGroup to set
+        * \brief set the ExecutionGroup that can be scheduled to calculate a certain chunk.
+        * \param group the ExecutionGroup to set
         */
        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; }
 
        /**
-        * @brief set the WriteBufferOperation that is responsible for writing to this MemoryProxy
-        * @param operation
+        * \brief set the WriteBufferOperation that is responsible for writing to this MemoryProxy
+        * \param operation
         */
        void setWriteBufferOperation(WriteBufferOperation *operation) { this->m_writeBufferOperation = operation; }
 
        /**
-        * @brief get the WriteBufferOperation that is responsible for writing to this MemoryProxy
-        * @return WriteBufferOperation
+        * \brief get the WriteBufferOperation that is responsible for writing to this MemoryProxy
+        * \return 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);
 
        /**
-        * @brief free the allocated memory
+        * \brief free the allocated memory
         */
        void free();
 
        /**
-        * @brief get the allocated memory
+        * \brief get the allocated memory
         */
        inline MemoryBuffer *getBuffer() { return this->m_buffer; }
 
index 1b78e7fec6d3692ccea7a02094c313b8af0ac31d..f57568350c095bb742a09400c5dcaf33d62f277b 100644 (file)
@@ -48,43 +48,43 @@ public:
 
 private:
        /**
-        * @brief stores the reference to the SDNA bNode struct
+        * \brief stores the reference to the SDNA bNode struct
         */
        bNodeTree *m_editorNodeTree;
 
        /**
-        * @brief stores the reference to the SDNA bNode struct
+        * \brief stores the reference to the SDNA bNode struct
         */
        bNode *m_editorNode;
 
        /**
-        * @brief the list of actual inputsockets @see NodeInput
+        * \brief the list of actual inputsockets \see NodeInput
         */
        Inputs m_inputsockets;
 
        /**
-        * @brief the list of actual outputsockets @see NodeOutput
+        * \brief the list of actual outputsockets \see NodeOutput
         */
        Outputs m_outputsockets;
 
        /**
-        * @brief Is this node part of the active group
+        * \brief Is this node part of the active group
         */
        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;
 
 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; }
 
        /**
-        * @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; }
 
@@ -93,55 +93,55 @@ public:
        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;}
 
        /**
-        * @brief get the reference to the SDNA bNodeTree struct
+        * \brief get the reference to the SDNA bNodeTree struct
         */
        bNodeTree *getbNodeTree() const {return m_editorNodeTree;}
 
        /**
-        * @brief set the reference to the bNode
-        * @note used in Node instances to receive the storage/settings and complex node for highlight during execution
-        * @param 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
+        * \param bNode
         */
        void setbNode(bNode *node) {this->m_editorNode = node;}
 
        /**
-        * @brief set the reference to the bNodeTree
-        * @param bNodeTree
+        * \brief set the reference to the bNodeTree
+        * \param bNodeTree
         */
        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(); }
 
        /**
-        * @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(); }
 
        /**
         * get the reference to a certain outputsocket
-        * @param index
+        * \param index
         * the index of the needed outputsocket
         */
        NodeOutput *getOutputSocket(const unsigned int index) const;
 
        /**
         * get the reference to the first outputsocket
-        * @param index
+        * \param index
         * the index of the needed outputsocket
         */
        inline NodeOutput *getOutputSocket() const { return getOutputSocket(0); }
 
        /**
         * get the reference to a certain inputsocket
-        * @param index
+        * \param index
         * the index of the needed inputsocket
         */
        NodeInput *getInputSocket(const unsigned int index) const;
@@ -152,26 +152,26 @@ public:
        bool isInputNode() const { return m_inputsockets.empty(); }
 
        /**
-        * @brief Is this node in the active group (the group that is being edited)
-        * @param isInActiveGroup
+        * \brief Is this node in the active group (the group that is being edited)
+        * \param isInActiveGroup
         */
        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 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; }
 
        /**
-        * @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 context reference to the CompositorContext
+        * \param system the ExecutionSystem where the operations need to be added
+        * \param context reference to the CompositorContext
         */
        virtual void convertToOperations(NodeConverter &converter, const CompositorContext &context) const = 0;
 
@@ -191,17 +191,17 @@ public:
 
 protected:
        /**
-        * @brief add an NodeInput to the collection of inputsockets
-        * @note may only be called in an constructor
-        * @param socket the NodeInput to add
+        * \brief add an NodeInput to the collection of inputsockets
+        * \note may only be called in an constructor
+        * \param socket the NodeInput to add
         */
        void addInputSocket(DataType datatype);
        void addInputSocket(DataType datatype, bNodeSocket *socket);
 
        /**
-        * @brief add an NodeOutput to the collection of outputsockets
-        * @note may only be called in an constructor
-        * @param socket the NodeOutput to add
+        * \brief add an NodeOutput to the collection of outputsockets
+        * \note may only be called in an constructor
+        * \param socket the NodeOutput to add
         */
        void addOutputSocket(DataType datatype);
        void addOutputSocket(DataType datatype, bNodeSocket *socket);
@@ -212,8 +212,8 @@ protected:
 
 
 /**
- * @brief NodeInput are sockets that can receive data/input
- * @ingroup Model
+ * \brief NodeInput are sockets that can receive data/input
+ * \ingroup Model
  */
 class NodeInput {
 private:
@@ -223,7 +223,7 @@ private:
        DataType m_datatype;
 
        /**
-        * @brief link connected to this NodeInput.
+        * \brief link connected to this NodeInput.
         * An input socket can only have a single link
         */
        NodeOutput *m_link;
@@ -246,8 +246,8 @@ public:
 
 
 /**
- * @brief NodeOutput are sockets that can send data/input
- * @ingroup Model
+ * \brief NodeOutput are sockets that can send data/input
+ * \ingroup Model
  */
 class NodeOutput {
 private:
index d78450074ed713325a831b15839b4a21493cfbfc..94af8543eb046112d2f5637b9ac62853121db059 100644 (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)
 {
-       /// @note: ignore invalid links
+       /// \note: ignore invalid links
        if (!(b_nodelink->flag & NODE_LINK_VALID))
                return;
        if ((b_nodelink->fromsock->flag & SOCK_UNAVAIL) || (b_nodelink->tosock->flag & SOCK_UNAVAIL))
index 9ab9156e7e4586b41812666d1f145414fdfabb2a..e5c27be5c5b02e6dcbb205865090eaa7c676222f 100644 (file)
@@ -52,30 +52,30 @@ class NodeOperationInput;
 class NodeOperationOutput;
 
 /**
- * @brief Resize modes of inputsockets
+ * \brief Resize modes of inputsockets
  * How are the input and working resolutions matched
- * @ingroup Model
+ * \ingroup Model
  */
 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,
-       /** @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,
-       /** @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,
-       /** @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,
-       /** @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,
-       /** @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
 } InputResizeMode;
 
 /**
- * @brief NodeOperation contains calculation logic
+ * \brief NodeOperation contains calculation logic
  *
  * Subclasses needs to implement the execution method (defined in SocketReader) to implement logic.
- * @ingroup Model
+ * \ingroup Model
  */
 class NodeOperation : public SocketReader {
 public:
@@ -87,12 +87,12 @@ private:
        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;
 
        /**
-        * @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.
         * Mostly Filter types (Blurs, Convolution, Defocus etc) need this to be set to true.
@@ -100,29 +100,29 @@ private:
        bool m_complex;
 
        /**
-        * @brief can this operation be scheduled on an OpenCL device.
-        * @note Only applicable if complex is True
+        * \brief can this operation be scheduled on an OpenCL device.
+        * \note Only applicable if complex is True
         */
        bool m_openCL;
 
        /**
-        * @brief mutex reference for very special node initializations
-        * @note only use when you really know what you are doing.
+        * \brief mutex reference for very special node initializations
+        * \note only use when you really know what you are doing.
         * this mutex is used to share data among chunks in the same operation
-        * @see TonemapOperation for an example of usage
-        * @see NodeOperation.initMutex initializes this mutex
-        * @see NodeOperation.deinitMutex deinitializes this mutex
-        * @see NodeOperation.getMutex retrieve a pointer to this mutex.
+        * \see TonemapOperation for an example of usage
+        * \see NodeOperation.initMutex initializes this mutex
+        * \see NodeOperation.deinitMutex deinitializes this mutex
+        * \see NodeOperation.getMutex retrieve a pointer to this mutex.
         */
        ThreadMutex 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;
 
        /**
-        * @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;
 
@@ -141,25 +141,25 @@ public:
        bool isInputOperation() const { return m_inputs.empty(); }
 
        /**
-        * @brief determine the resolution of this node
-        * @note this method will not set the resolution, this is the responsibility of the caller
-        * @param resolution the result of this operation
-        * @param preferredResolution the preferable resolution as no resolution could be determined
+        * \brief determine the resolution of this node
+        * \note this method will not set the resolution, this is the responsibility of the caller
+        * \param resolution the result of this operation
+        * \param preferredResolution the preferable resolution as no resolution could be determined
         */
        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.
         *
-        * @see ExecutionSystem
-        * @group check
-        * @param rendering [true false]
+        * \see ExecutionSystem
+        * \group check
+        * \param rendering [true false]
         *  true: rendering
         *  false: editing
         *
-        * @return bool the result of this method
+        * \return bool the result of this method
         */
        virtual bool isOutputOperation(bool /*rendering*/) const { return false; }
 
@@ -169,26 +169,26 @@ public:
        virtual void initExecution();
 
        /**
-        * @brief when a chunk is executed by a CPUDevice, this method is called
-        * @ingroup execution
-        * @param rect the rectangle of the chunk (location and size)
-        * @param chunkNumber the chunkNumber to be calculated
-        * @param memoryBuffers all input MemoryBuffer's needed
+        * \brief when a chunk is executed by a CPUDevice, this method is called
+        * \ingroup execution
+        * \param rect the rectangle of the chunk (location and size)
+        * \param chunkNumber the chunkNumber to be calculated
+        * \param memoryBuffers all input MemoryBuffer's needed
         */
        virtual void executeRegion(rcti * /*rect*/,
                                   unsigned int /*chunkNumber*/) {}
 
        /**
-        * @brief when a chunk is executed by an OpenCLDevice, this method is called
-        * @ingroup execution
-        * @note this method is only implemented in WriteBufferOperation
-        * @param context the OpenCL context
-        * @param program the OpenCL program containing all compositor kernels
-        * @param queue the OpenCL command queue of the device the chunk is executed on
-        * @param rect the rectangle of the chunk (location and size)
-        * @param chunkNumber the chunkNumber to be calculated
-        * @param memoryBuffers all input MemoryBuffer's needed
-        * @param outputBuffer the outputbuffer to write to
+        * \brief when a chunk is executed by an OpenCLDevice, this method is called
+        * \ingroup execution
+        * \note this method is only implemented in WriteBufferOperation
+        * \param context the OpenCL context
+        * \param program the OpenCL program containing all compositor kernels
+        * \param queue the OpenCL command queue of the device the chunk is executed on
+        * \param rect the rectangle of the chunk (location and size)
+        * \param chunkNumber the chunkNumber to be calculated
+        * \param memoryBuffers all input MemoryBuffer's needed
+        * \param outputBuffer the outputbuffer to write to
         */
        virtual void executeOpenCLRegion(OpenCLDevice * /*device*/,
                                         rcti * /*rect*/,
@@ -197,16 +197,16 @@ public:
                                         MemoryBuffer * /*outputBuffer*/) {}
 
        /**
-        * @brief custom handle to add new tasks to the OpenCL command queue in order to execute a chunk on an GPUDevice
-        * @ingroup execution
-        * @param context the OpenCL context
-        * @param program the OpenCL program containing all compositor kernels
-        * @param queue the OpenCL command queue of the device the chunk is executed on
-        * @param outputMemoryBuffer the allocated memory buffer in main CPU memory
-        * @param clOutputBuffer the allocated memory buffer in OpenCLDevice memory
-        * @param inputMemoryBuffers all input MemoryBuffer's needed
-        * @param clMemToCleanUp all created cl_mem references must be added to this list. Framework will clean this after execution
-        * @param clKernelsToCleanUp all created cl_kernel references must be added to this list. Framework will clean this after execution
+        * \brief custom handle to add new tasks to the OpenCL command queue in order to execute a chunk on an GPUDevice
+        * \ingroup execution
+        * \param context the OpenCL context
+        * \param program the OpenCL program containing all compositor kernels
+        * \param queue the OpenCL command queue of the device the chunk is executed on
+        * \param outputMemoryBuffer the allocated memory buffer in main CPU memory
+        * \param clOutputBuffer the allocated memory buffer in OpenCLDevice memory
+        * \param inputMemoryBuffers all input MemoryBuffer's needed
+        * \param clMemToCleanUp all created cl_mem references must be added to this list. Framework will clean this after execution
+        * \param clKernelsToCleanUp all created cl_kernel references must be added to this list. Framework will clean this after execution
         */
        virtual void executeOpenCL(OpenCLDevice * /*device*/,
                                   MemoryBuffer * /*outputMemoryBuffer*/,
@@ -221,8 +221,8 @@ public:
        }
 
        /**
-        * @brief set the resolution
-        * @param resolution the resolution to set
+        * \brief set the resolution
+        * \param resolution the resolution to set
         */
        void setResolution(unsigned int resolution[2]) {
                if (!isResolutionSet()) {
@@ -236,7 +236,7 @@ public:
        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.
         * 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; }
 
        /**
-        * @brief is this operation of type ReadBufferOperation
-        * @return [true:false]
-        * @see ReadBufferOperation
+        * \brief is this operation of type ReadBufferOperation
+        * \return [true:false]
+        * \see ReadBufferOperation
         */
        virtual const bool isReadBufferOperation() const { return false; }
 
        /**
-        * @brief is this operation of type WriteBufferOperation
-        * @return [true:false]
-        * @see WriteBufferOperation
+        * \brief is this operation of type WriteBufferOperation
+        * \return [true:false]
+        * \see WriteBufferOperation
         */
        virtual const bool isWriteBufferOperation() const { return false; }
 
        /**
-        * @brief is this operation the active viewer output
+        * \brief is this operation the active viewer output
         * user can select an ViewerNode to be active (the result of this node will be drawn on the backdrop)
-        * @return [true:false]
-        * @see BaseViewerOperation
+        * \return [true:false]
+        * \see BaseViewerOperation
         */
        virtual const bool isActiveViewerOutput() const { return false; }
 
        virtual bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output);
 
        /**
-        * @brief set the index of the input socket that will determine the resolution of this operation
-        * @param index the index to set
+        * \brief set the index of the input socket that will determine the resolution of this operation
+        * \param index the index to set
         */
        void setResolutionInputSocketIndex(unsigned int index);
 
        /**
-        * @brief get the render priority of this node.
-        * @note only applicable for output operations like ViewerOperation
-        * @return CompositorPriority
+        * \brief get the render priority of this node.
+        * \note only applicable for output operations like ViewerOperation
+        * \return CompositorPriority
         */
        virtual const CompositorPriority getRenderPriority() const { return COM_PRIORITY_LOW; }
 
        /**
-        * @brief can this NodeOperation be scheduled on an OpenCLDevice
-        * @see WorkScheduler.schedule
-        * @see ExecutionGroup.addOperation
+        * \brief can this NodeOperation be scheduled on an OpenCLDevice
+        * \see WorkScheduler.schedule
+        * \see ExecutionGroup.addOperation
         */
        bool isOpenCL() const { return this->m_openCL; }
 
@@ -321,7 +321,7 @@ protected:
        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.
         * 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; }
 
        /**
-        * @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; }
 
@@ -347,7 +347,7 @@ private:
        NodeOperation *m_operation;
 
        /** Datatype of this socket. Is used for automatically data transformation.
-        * @section data-conversion
+        * \section data-conversion
         */
        DataType m_datatype;
 
@@ -385,7 +385,7 @@ private:
        NodeOperation *m_operation;
 
        /** Datatype of this socket. Is used for automatically data transformation.
-        * @section data-conversion
+        * \section data-conversion
         */
        DataType m_datatype;
 
@@ -396,9 +396,9 @@ public:
        DataType getDataType() const { return m_datatype; }
 
        /**
-        * @brief determine the resolution of this data going through this socket
-        * @param resolution the result of this operation
-        * @param preferredResolution the preferable resolution as no resolution could be determined
+        * \brief determine the resolution of this data going through this socket
+        * \param resolution the result of this operation
+        * \param preferredResolution the preferable resolution as no resolution could be determined
         */
        void determineResolution(unsigned int resolution[2], unsigned int preferredResolution[2]);
 
index a3a5cd36902f7d608ccd14660895fc3765b556c5..f8dd3750d428766393c5fde01c811b1a204ae4f7 100644 (file)
@@ -33,70 +33,70 @@ class OpenCLDevice;
 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
  */
 class OpenCLDevice : public Device {
 private:
        /**
-        * @brief opencl context
+        * \brief opencl context
         */
        cl_context m_context;
 
        /**
-        * @brief opencl device
+        * \brief opencl device
         */
        cl_device_id m_device;
 
        /**
-        * @brief opencl program
+        * \brief opencl program
         */
        cl_program m_program;
 
        /**
-        * @brief opencl command queue
+        * \brief opencl command queue
         */
        cl_command_queue m_queue;
 
        /**
-        * @brief opencl vendor ID
+        * \brief opencl vendor ID
         */
        cl_int m_vendorID;
 
 public:
        /**
-        * @brief constructor with opencl device
-        * @param context
-        * @param device
-        * @param program
-        * @param vendorID
+        * \brief constructor with opencl device
+        * \param context
+        * \param device
+        * \param program
+        * \param 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
         * the command queue is stored in the field queue.
-        * @see queue
+        * \see queue
         */
        bool initialize();
 
        /**
-        * @brief deinitialize the device
+        * \brief deinitialize the device
         * During deintiialization the command queue is cleared
         */
        void deinitialize();
 
        /**
-        * @brief execute a WorkPackage
-        * @param work the WorkPackage to execute
+        * \brief execute a WorkPackage
+        * \param work the WorkPackage to execute
         */
        void execute(WorkPackage *work);
 
        /**
-        * @brief determine an image format
-        * @param memorybuffer
+        * \brief determine an image format
+        * \param memorybuffer
         */
        static const cl_image_format *determineImageFormat(MemoryBuffer *memoryBuffer);
 
index af6b891e7abfc56afe1d05e1ec2cc5018143bf50..170b9e1bd35c13b9ca854e3e8edec6c2df3bedff 100644 (file)
@@ -37,31 +37,31 @@ typedef enum PixelSampler {
 
 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.
- * @ingroup Execution
+ * \ingroup Execution
  */
 class SocketReader {
 private:
 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;
 
        /**
-        * @brief Holds the height of the output of this operation.
+        * \brief Holds the height of the output of this operation.
         */
        unsigned int m_height;
 
 
        /**
-        * @brief calculate a single pixel
-        * @note this method is called for non-complex
-        * @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 y the y-coordinate of the pixel to calculate in image space
-        * @param inputBuffers chunks that can be read by their ReadBufferOperation.
+        * \brief calculate a single pixel
+        * \note this method is called for non-complex
+        * \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 y the y-coordinate of the pixel to calculate in image space
+        * \param inputBuffers chunks that can be read by their ReadBufferOperation.
         */
        virtual void executePixelSampled(float /*output*/[4],
                                         float /*x*/,
@@ -69,27 +69,27 @@ protected:
                                         PixelSampler /*sampler*/) { }
 
        /**
-        * @brief calculate a single pixel
-        * @note this method is called for complex
-        * @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 y the y-coordinate of the pixel to calculate in image space
-        * @param inputBuffers chunks that can be read by their ReadBufferOperation.
-        * @param chunkData chunk specific data a during execution time.
+        * \brief calculate a single pixel
+        * \note this method is called for complex
+        * \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 y the y-coordinate of the pixel to calculate in image space
+        * \param inputBuffers chunks that can be read by their ReadBufferOperation.
+        * \param chunkData chunk specific data a during execution time.
         */
        virtual void executePixel(float output[4], int x, int y, void * /*chunkData*/) {
                executePixelSampled(output, x, y, COM_PS_NEAREST);
        }
 
        /**
-        * @brief calculate a single pixel using an EWA filter
-        * @note this method is called for complex
-        * @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 y the y-coordinate of the pixel to calculate in image space
-        * @param dx
-        * @param dy
-        * @param inputBuffers chunks that can be read by their ReadBufferOperation.
+        * \brief calculate a single pixel using an EWA filter
+        * \note this method is called for complex
+        * \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 y the y-coordinate of the pixel to calculate in image space
+        * \param dx
+        * \param dy
+        * \param inputBuffers chunks that can be read by their ReadBufferOperation.
         */
        virtual void executePixelFiltered(float /*output*/[4],
                                          float /*x*/, float /*y*/,
index b0a74a1b0ee0c16f7064ccb9f99f7ad23c2b5dd3..72677c4e1128e7fdfe78d851817a9f65a25c6059 100644 (file)
@@ -28,35 +28,35 @@ class ExecutionGroup;
 #include "COM_ExecutionGroup.h"
 
 /**
- * @brief contains data about work that can be scheduled
- * @see WorkScheduler
+ * \brief contains data about work that can be scheduled
+ * \see WorkScheduler
  */
 class WorkPackage {
 private:
        /**
-        * @brief executionGroup with the operations-setup to be evaluated
+        * \brief executionGroup with the operations-setup to be evaluated
         */
        ExecutionGroup *m_executionGroup;
 
        /**
-        * @brief number of the chunk to be executed
+        * \brief number of the chunk to be executed
         */
        unsigned int m_chunkNumber;
 public:
        /**
         * constructor
-        * @param group the ExecutionGroup
-        * @param chunkNumber the number of the chunk
+        * \param group the ExecutionGroup
+        * \param chunkNumber the number of the chunk
         */
        WorkPackage(ExecutionGroup *group, unsigned int chunkNumber);
 
        /**
-        * @brief get the ExecutionGroup
+        * \brief get the 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; }
 
index 4136983e13cee46f1c8a582ca16e029aec91e2a3..5be76d84e33e179cdcbc7bb764f4ef70d0a20775 100644 (file)
 #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 ThreadLocal(CPUDevice *) g_thread_device;
 
 #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 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_gpuqueue;
 #ifdef COM_OPENCL_ENABLED
 static cl_context g_context;
 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;
-/// @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;
-/// @brief all scheduled work for the gpu
+/// \brief all scheduled work for the gpu
 #ifdef COM_OPENCL_ENABLED
 static bool g_openclActive = false;
 static bool g_openclInitialized = false;
index a08b3856a8b67c62688c387764db0279b4069e30..a6de517983eaabf5662f02abc7589a50ceee8ff9 100644 (file)
@@ -31,43 +31,43 @@ extern "C" {
 #include "COM_defines.h"
 #include "COM_Device.h"
 
-/** @brief the workscheduler
- * @ingroup execution
+/** \brief the workscheduler
+ * \ingroup execution
  */
 class WorkScheduler {
 
 #if COM_CURRENT_THREADING_MODEL == COM_TM_QUEUE
        /**
-        * @brief are we being stopped.
+        * \brief are we being stopped.
         */
        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
         */
        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
         */
        static void *thread_execute_gpu(void *data);
 #endif
 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
         * when ExecutionGroup.isOpenCL is set the work will be handled by a OpenCLDevice
         * otherwise the work is scheduled for an CPUDevice
-        * @see ExecutionGroup.execute
-        * @param group the execution group
-        * @param chunkNumber the number of the chunk in the group to be executed
+        * \see ExecutionGroup.execute
+        * \param group the execution group
+        * \param chunkNumber the number of the chunk in the group to be executed
         */
        static void schedule(ExecutionGroup *group, int chunkNumber);
 
        /**
-        * @brief initialize the WorkScheduler
+        * \brief initialize the WorkScheduler
         *
         * during initialization the mutexes are initialized.
         * there are two mutexes (for every device type one)
@@ -80,36 +80,36 @@ public:
        static void initialize(bool use_opencl, int num_cpu_threads);
 
        /**
-        * @brief deinitialize the WorkScheduler
+        * \brief deinitialize the WorkScheduler
         * free all allocated resources
         */
        static void deinitialize();
 
        /**
-        * @brief Start the execution
+        * \brief Start the execution
         * this methods will start the WorkScheduler. Inside this method all threads are initialized.
         * 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);
 
        /**
-        * @brief stop the execution
+        * \brief stop the execution
         * All created thread by the start method are destroyed.
-        * @see start
+        * \see start
         */
        static void stop();
 
        /**
-        * @brief wait for all work to be completed.
+        * \brief wait for all work to be completed.
         */
        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
         * A node can generate a different operation tree when OpenCLDevices exists.
-        * @see CompositorContext.getHasActiveOpenCLDevices
+        * \see CompositorContext.getHasActiveOpenCLDevices
         */
        static bool hasGPUDevices();
 
index 0af2ea3310ddd7eea3afc488d5c5bf7695e5eac6..04155a9bad7db2f572291d094c1d14faf53c1c42 100644 (file)
@@ -26,8 +26,8 @@
 #include "COM_Node.h"
 
 /**
- * @brief AlphaOverNode
- * @ingroup Node
+ * \brief AlphaOverNode
+ * \ingroup Node
  */
 class AlphaOverNode : public Node {
 public:
index babb558e0d1832980eb33fc46ea13e0dc3c5cfd2..928aff65f360732e7c5129b4f22f7e1753afd5b1 100644 (file)
@@ -26,8 +26,8 @@
 #include "COM_Node.h"
 
 /**
- * @brief BilateralBlurNode
- * @ingroup Node
+ * \brief BilateralBlurNode
+ * \ingroup Node
  */
 class BilateralBlurNode : public Node {
 public:
index 9a5f5ea1efdd8d50ebf50ccad9f91f559bdfdfa9..703e85c9bcc336d3b0fa27883fd1969ab99b146e 100644 (file)
@@ -26,8 +26,8 @@
 #include "COM_Node.h"
 
 /**
- * @brief BlurNode
- * @ingroup Node
+ * \brief BlurNode
+ * \ingroup Node
  */
 class BlurNode : public Node {
 public:
index 48cd661a7bf71513a6eeaa6869a69f5789f9842f..299fe742dd21686cc5f0c927adc6d2bea7283b1d 100644 (file)
@@ -26,8 +26,8 @@
 #include "COM_Node.h"
 
 /**
- * @brief BokehBlurNode
- * @ingroup Node
+ * \brief BokehBlurNode
+ * \ingroup Node
  */
 class BokehBlurNode : public Node {
 public:
index 70f363b8cf6d2771bfa7cd9eb5a1f996008ac60a..810602ed5fbefec403b88539ae5a74cea64e78f8 100644 (file)
@@ -26,8 +26,8 @@
 #include "COM_Node.h"
 
 /**
- * @brief BokehImageNode
- * @ingroup Node
+ * \brief BokehImageNode
+ * \ingroup Node
  */
 class BokehImageNode : public Node {
 public:
index 01557229be92213d28c32a961dd757609833968a..f7ce0eed46497a9d73b7ab0290377027ff0bb15b 100644 (file)
@@ -26,8 +26,8 @@
 #include "COM_Node.h"
 
 /**
- * @brief BoxMaskNode
- * @ingroup Node
+ * \brief BoxMaskNode
+ * \ingroup Node
  */
 class BoxMaskNode : public Node {
 public:
index 27155e27774080789e87a6d244d55cd5c17ca563..2625334800ef4fae6b0e100f5f06c6422bb33daa 100644 (file)
@@ -26,8 +26,8 @@
 #include "COM_Node.h"
 
 /**
- * @brief BrightnessNode
- * @ingroup Node
+ * \brief BrightnessNode
+ * \ingroup Node
  */
 class BrightnessNode : public Node {
 public:
index c5f062cb215808fc0f4be07cc82b8f0f5b84f6a1..84f01c25ef3c71d9674c13aee664c9c19a1b9950 100644 (file)
@@ -25,8 +25,8 @@
 #include "COM_Node.h"
 
 /**
- * @brief ChannelMatteNode
- * @ingroup Node
+ * \brief ChannelMatteNode
+ * \ingroup Node
  */
 class ChannelMatteNode : public Node {
 public:
index 7d0b34ecf5dcdf957ae36fec6a82d7059be7907f..48488a9be4719b44eaf2f6bafe75437d349f5040 100644 (file)
@@ -25,8 +25,8 @@
 #include "COM_Node.h"
 
 /**
- * @brief ChromaMatteNode
- * @ingroup Node
+ * \brief ChromaMatteNode
+ * \ingroup Node
  */
 class ChromaMatteNode : public Node {
 public:
index d203fef20f449b6803312d58473111382c644fa7..120e745473ee14658409d91fbab11e3eed139cac 100644 (file)
@@ -26,8 +26,8 @@
 #include "COM_Node.h"
 
 /**
- * @brief ColorBalanceNode
- * @ingroup Node
+ * \brief ColorBalanceNode
+ * \ingroup Node
  */
 class ColorBalanceNode : public Node {
 public:
index fcbd7631cb48476a54066e6c1d442ffa9b7fc2a4..2599983e76c171975b18a0d2e723734dd79c0773 100644 (file)
@@ -26,8 +26,8 @@
 #include "COM_Node.h"
 
 /**
- * @brief ColorCorrectionNode
- * @ingroup Node
+ * \brief ColorCorrectionNode
+ * \ingroup Node
  */
 class ColorCorrectionNode : public Node {
 public:
index ad51611d1cf051b89d40280392ce983f3c1ee9ea..eb8ff1ae787a124988cb71e92e03464738bcb0c1 100644 (file)
@@ -26,8 +26,8 @@
 #include "COM_Node.h"
 
 /**
- * @brief ColorCurveNode
- * @ingroup Node
+ * \brief ColorCurveNode
+ * \ingroup Node
  */
 class ColorCurveNode : public Node {
 public:
index f2c3c08beeadd0c7e2c36adfc626e518d2d031b6..d2979ab022d582fa506a37e8abc766404eaac1a0 100644 (file)
@@ -25,8 +25,8 @@
 #include "COM_Node.h"
 
 /**
- * @brief ColorMatteNode
- * @ingroup Node
+ * \brief ColorMatteNode
+ * \ingroup Node
  */
 class ColorMatteNode : public Node {
 public:
index 205f4d0713536f0b24a8299845c7b439f527f74f..139f50e3848dce19c97fbecf2b7d6b46d5f2eb15 100644 (file)
@@ -26,8 +26,8 @@
 #include "COM_Node.h"
 
 /**
- * @brief ColorNode
- * @ingroup Node
+ * \brief ColorNode
+ * \ingroup Node
  */
 class ColorNode : public Node {
 public:
index 4332d831e31a4ab8669d8cf1d233dcb6b2bf57c7..6457828753aa4925ff4980d40830734a44a35afc 100644 (file)
@@ -26,8 +26,8 @@
 #include "COM_Node.h"
 
 /**
- * @brief ColorRampNode
- * @ingroup Node
+ * \brief ColorRampNode
+ * \ingroup Node
  */
 class ColorRampNode : public Node {
 public:
index cb2cd8a2ea3148e3373a9f350cdcce06f0f6e67c..a476163224bec001365f9d13b7936ec76b0cf21e 100644 (file)
@@ -26,8 +26,8 @@
 #include "COM_Node.h"
 
 /**
- * @brief ColorSpillNode
- * @ingroup Node
+ * \brief ColorSpillNode
+ * \ingroup Node
  */
 class ColorSpillNode : public Node {
 public:
index 05f937eb555c4bf3c32b34681531e816c885086a..b4e8493d69bc01dde6840017f39cc8423859c66c 100644 (file)
@@ -26,8 +26,8 @@
 #include "COM_Node.h"
 #include "DNA_node_types.h"
 /**
- * @brief ColorToBWNode
- * @ingroup Node
+ * \brief ColorToBWNode
+ * \ingroup Node
  */
 class ColorToBWNode : public Node {
 public:
index a21013f2ce2ca5dbc9d747a210f0aeb73081c167..54c1997313406fcd43a77a61f3587c3399acbbc6 100644 (file)
@@ -26,8 +26,8 @@
 #include "COM_Node.h"
 #include "DNA_node_types.h"
 /**
- * @brief CompositorNode
- * @ingroup Node
+ * \brief CompositorNode
+ * \ingroup Node
  */
 class CompositorNode : public Node {
 public:
index 37482d66269f7596b2b21cf87597f75ab85eedc4..3da009aec026ce6dc5ac140c57ddfcaf6f48d83f 100644 (file)
@@ -25,8 +25,8 @@
 #include "COM_Node.h"
 
 /**
- * @brief ConvertAlphaNode
- * @ingroup Node
+ * \brief ConvertAlphaNode
+ * \ingroup Node
  */
 class ConvertAlphaNode : public Node {
 public:
index 63428fa653b22ff7253b44f28a73175e1ba98d48..ab89107fe8a4c7279d70ed6b1e7caa557f9d2a8e 100644 (file)
@@ -29,8 +29,8 @@ extern "C" {
 }
 
 /**
- * @brief CornerPinNode
- * @ingroup Node
+ * \brief CornerPinNode
+ * \ingroup Node
  */
 class CornerPinNode : public Node {
 public:
index a7d529c426fb9ff287afd2bd4d6687414e71295a..f30acac9fd217c211c3403b93c88ddc367a93a21 100644 (file)
@@ -26,8 +26,8 @@
 #include "COM_Node.h"
 
 /**
- * @brief CropNode
- * @ingroup Node
+ * \brief CropNode
+ * \ingroup Node
  */
 class CropNode : public Node {
 public:
index 2e1784dedb9fa3f402f5622e888c3e244a3f6985..f1e446dee20476e123de471f7e36e9a3877c3e03 100644 (file)
@@ -25,8 +25,8 @@
 #include "COM_Node.h"
 
 /**
- * @brief CryptomatteNode
- * @ingroup Node
+ * \brief CryptomatteNode
+ * \ingroup Node
  */
 class CryptomatteNode : public Node {
 public:
index 99efdd15b3709398e9e974cd99e479242a09d1d4..d80384ac01fa9805f0b7d9be1b9ac6efad1cafd3 100644 (file)
@@ -26,8 +26,8 @@
 #include "COM_Node.h"
 
 /**
- * @brief DefocusNode
- * @ingroup Node
+ * \brief DefocusNode
+ * \ingroup Node
  */
 class DefocusNode : public Node {
 public:
index e8097be35dd6e39a44818c6a4eb22abbbd4495ac..7c91ef2d3843544854a6d667d1cff9a591d9f934 100644 (file)
@@ -24,8 +24,8 @@
 #include "COM_Node.h"
 
 /**
- * @brief DespeckleNode
- * @ingroup Node
+ * \brief DespeckleNode
+ * \ingroup Node
  */
 class DespeckleNode : public Node {
 public:
index ea3da8d2fca2043e8bdf8b880bfc6ae7f01f1e11..d2235c8148da46d0b10e294fb7c8a7caff95c376 100644 (file)
@@ -26,8 +26,8 @@
 #include "COM_Node.h"
 
 /**
- * @brief DifferenceMatteNode
- * @ingroup Node
+ * \brief DifferenceMatteNode
+ * \ingroup Node
  */
 class DifferenceMatteNode : public Node {
 public:
index aff3ecbb4b0b200319c9a27e018f41b9d9e76209..a3d26ada95b2c1de4c9b463bb834bbe6bcdbd714 100644 (file)
@@ -26,8 +26,8 @@
 #include "COM_Node.h"
 
 /**
- * @brief DilateErodeNode
- * @ingroup Node
+ * \brief DilateErodeNode
+ * \ingroup Node
  */
 class DilateErodeNode : public Node {
        NodeBlurData m_alpha_blur; /* only used for blurring alpha, since the dilate/erode node doesnt have this */
index eef51e140bc7a3bb39b9a44a1e6427a09c2aac43..26e5573e586c6029a60e5a08a7a9f96ec55047e5 100644 (file)
@@ -26,8 +26,8 @@
 #include "COM_Node.h"
 
 /**
- * @brief DirectionalBlurNode
- * @ingroup Node
+ * \brief DirectionalBlurNode
+ * \ingroup Node
  */
 class DirectionalBlurNode : public Node {
 public:
index 28105fd596373a46ae7d9dcd9fd6090496d4d7f7..58a77527f5b707be90da12a1517a076703d263d2 100644 (file)
@@ -25,8 +25,8 @@
 #include "COM_Node.h"
 
 /**
- * @brief DisplaceNode
- * @ingroup Node
+ * \brief DisplaceNode
+ * \ingroup Node
  */
 class DisplaceNode : public Node {
 public:
index e7bd3c57dfa731338eb94925717a647f90b7d44e..e5976455371f7825f23c7b98810048541cddd454 100644 (file)
@@ -25,8 +25,8 @@
 #include "COM_Node.h"
 
 /**
- * @brief DistanceMatteNode
- * @ingroup Node
+ * \brief DistanceMatteNode
+ * \ingroup Node
  */
 class DistanceMatteNode : public Node {
 public:
index 91a230051289216f9a0a8619c1979c3b98da569d..c01772ea533857fa521b96d67d35338128e3b090 100644 (file)
@@ -26,8 +26,8 @@
 #include "COM_Node.h"
 
 /**
- * @brief DoubleEdgeMaskNode
- * @ingroup Node
+ * \brief DoubleEdgeMaskNode
+ * \ingroup Node
  */
 class DoubleEdgeMaskNode : public Node {
 public:
index e5e9861b2d936871d2acafd6de24d70a3d13dbc7..64f0a319195045ad0f87537b6683d52848bdb27a 100644 (file)
@@ -26,8 +26,8 @@
 #include "COM_Node.h"
 
 /**
- * @brief EllipseMaskNode
- * @ingroup Node
+ * \brief EllipseMaskNode
+ * \ingroup Node
  */
 class EllipseMaskNode : public Node {
 public:
index 0991b256ebbfa59d2e124bc566ea169872ccd0b0..6b2e0281627f7cd43009ebc235672a0b2cc671cf 100644 (file)
@@ -26,8 +26,8 @@
 #include "COM_Node.h"
 
 /**
- * @brief FilterNode
- * @ingroup Node
+ * \brief FilterNode
+ * \ingroup Node
  */
 class FilterNode : public Node {
 public:
index 2d1b60b784e560711032e72209e9598e1839709c..98703a220125fb36c7744f3afaa4569235a32673 100644 (file)
@@ -36,7 +36,7 @@ void FlipNode::convertToOperations(NodeConverter &converter, const CompositorCon
        NodeOutput *outputSocket = this->getOutputSocket(0);
        FlipOperation *operation = new FlipOperation();
        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->setFlipY(false);
                        break;
index 8c9a78df85d3526a59e40d6a7f9cb7ab500d1c14..f13abe3df5323e91836fe7809bc43efc9fcbfe9e 100644 (file)
@@ -26,8 +26,8 @@
 #include "COM_Node.h"
 
 /**
- * @brief FlipNode
- * @ingroup Node
+ * \brief FlipNode
+ * \ingroup Node
  */
 class FlipNode : public Node {
 public:
index 8b6434b9c6a56bc947229b96a0f3c538f7e01be6..97bdeffcaa3e396addb9122d225d745f4164d22e 100644 (file)
@@ -26,8 +26,8 @@
 #include "COM_Node.h"
 
 /**
- * @brief GammaNode
- * @ingroup Node
+ * \brief GammaNode
+ * \ingroup Node
  */
 class GammaNode : public Node {
 public:
index 93f923138351ecf87ff68c2c644371ec2770493d..723e13b783693acd9bdf282d12f13a5aa478ce69 100644 (file)
@@ -26,8 +26,8 @@
 #include "COM_Node.h"
 
 /**
- * @brief GlareNode
- * @ingroup Node
+ * \brief GlareNode
+ * \ingroup Node
  */
 class GlareNode : public Node {
 public:
index f940a20e0dab2d39ca844f78f2f268146a525eae..d5ff55b6d1fdd41a21f49c28db7a8fc6ff434bc1 100644 (file)
@@ -26,8 +26,8 @@
 #include "COM_Node.h"
 
 /**
- * @brief HueSaturationValueCorrectNode
- * @ingroup Node
+ * \brief HueSaturationValueCorrectNode
+ * \ingroup Node
  */
 class HueSaturationValueCorrectNode : public Node {
 public:
index f09164de34fef94292ddcd3c1a6e8cd0bc09da33..2d1a3346cc3460c30b8c83b631df6a33958e7bc8 100644 (file)
@@ -26,8 +26,8 @@
 #include "COM_Node.h"
 
 /**
- * @brief HueSaturationValueNode
- * @ingroup Node
+ * \brief HueSaturationValueNode
+ * \ingroup Node
  */
 class HueSaturationValueNode : public Node {
 public:
index 8a6e55a946e4aa95f30eef059ef5b50e96c5baab..7fbcbce204f455585a073bd2f53d488d211f99bc 100644 (file)
@@ -26,8 +26,8 @@
 #include "COM_Node.h"
 
 /**
- * @brief IDMaskNode
- * @ingroup Node
+ * \brief IDMaskNode
+ * \ingroup Node
  */
 class IDMaskNode : public Node {
 public:
index d8bf3ea3122a76a494e4a65e21a5c06e5e841fc6..11857ed98bfc45d51a334a907fad9beac2eeb8be 100644 (file)
@@ -30,8 +30,8 @@ extern "C" {
 }
 
 /**
- * @brief ImageNode
- * @ingroup Node
+ * \brief ImageNode
+ * \ingroup Node
  */
 class ImageNode : public Node {
 private:
index dcc563234bef2cf303921c01eb6d3c20d19ec0ac..2a57d4f4b504ae1ca87e7ce6ac06a7f1eae5e142 100644 (file)
@@ -26,8 +26,8 @@
 #include "COM_Node.h"
 
 /**
- * @brief InpaintNode
- * @ingroup Node
+ * \brief InpaintNode
+ * \ingroup Node
  */
 class InpaintNode : public Node {
 public:
index 9ca774e76004291b27c8fbd589237766c4ee9af7..27719dd39db17bf194114ea44ed8a3d6ea951fd2 100644 (file)
@@ -26,8 +26,8 @@
 #include "COM_Node.h"
 
 /**
- * @brief InvertNode
- * @ingroup Node
+ * \brief InvertNode
+ * \ingroup Node
  */
 class InvertNode : public Node {
 public:
index f4a6c02aa56b8e2586b5524bcea64dd1c467e6a4..d712eeb0a8b7a9a08fc2967c88ba95fd0e0d07e9 100644 (file)
@@ -24,8 +24,8 @@
 #include "COM_Node.h"
 
 /**
- * @brief KeyingNode
- * @ingroup Node
+ * \brief KeyingNode
+ * \ingroup Node
  */
 class KeyingNode : public Node {
 protected:
index be29b93969061e7ad9253cf817f64e2024632823..29619a670970cbf97e5d9d6d93ccd1de296e104a 100644 (file)
@@ -25,8 +25,8 @@
 #include "DNA_node_types.h"
 
 /**
- * @brief KeyingScreenNode
- * @ingroup Node
+ * \brief KeyingScreenNode
+ * \ingroup Node
  */
 class KeyingScreenNode : public Node {
 public:
index ee0f9f1bc0679d2ae95168bc2bf113dfd729ed42..40752d3fc9e20472fc14a64072e49c47a3091f4e 100644 (file)
@@ -26,8 +26,8 @@
 #include "COM_Node.h"
 
 /**
- * @brief LensDistortionNode
- * @ingroup Node
+ * \brief LensDistortionNode
+ * \ingroup Node
  */
 class LensDistortionNode : public Node {
 public:
index a36e6f2e732ef91446113413809ac2bbd533bd3e..cc57f4a39f1a1e44c78856cb094cc5ec65b20c48 100644 (file)
@@ -25,8 +25,8 @@
 #include "COM_Node.h"
 
 /**
- * @brief LuminanceMatteNode
- * @ingroup Node
+ * \brief LuminanceMatteNode
+ * \ingroup Node
  */
 class LuminanceMatteNode : public Node {
 public:
index 8c2b8d1f80752c004eed3fec1d5b62aa4d3e3ff5..74bb1e006b3ded74ccae523ca456abad780350fc 100644 (file)
@@ -26,8 +26,8 @@
 #include "COM_Node.h"
 #include "DNA_node_types.h"
 /**
- * @brief MapRangeNode
- * @ingroup Node
+ * \brief MapRangeNode
+ * \ingroup Node
  */
 class MapRangeNode : public Node {
 public:
index 245a31ce83cc8f9e29c01e86b97908027fdeed8c..04036df6a24a23f41a71cfba9b01749d3aae4359 100644 (file)
@@ -25,8 +25,8 @@
 #include "COM_Node.h"
 
 /**
- * @brief MapUVNode
- * @ingroup Node
+ * \brief MapUVNode
+ * \ingroup Node
  */
 class MapUVNode : public Node {
 public:
index dca1657ce0bb7e548700b9d9fe40e4371d216a6a..230e8134f245729ae8daa93b7c3fd93a47102f94 100644 (file)
@@ -26,8 +26,8 @@
 #include "COM_Node.h"
 #include "DNA_node_types.h"
 /**
- * @brief MapValueNode
- * @ingroup Node
+ * \brief MapValueNode
+ * \ingroup Node
  */
 class MapValueNode : public Node {
 public:
index 834c421ac08597c3a3a1d642243831a1ca94ee3a..55c47c7a7d268536948e3aa1e9174f580d9792b3 100644 (file)
@@ -28,8 +28,8 @@
 #include "DNA_node_types.h"
 
 /**
- * @brief MaskNode
- * @ingroup Node
+ * \brief MaskNode
+ * \ingroup Node
  */
 class MaskNode : public Node {
 public:
index cf92765f6da9d220e7908f374f6ede7ec1685bb9..86bb1a3f683ddb44e184f60ab9231b70f9c229c9 100644 (file)
@@ -26,8 +26,8 @@
 #include "COM_Node.h"
 
 /**
- * @brief MathNode
- * @ingroup Node
+ * \brief MathNode
+ * \ingroup Node
  */
 class MathNode : public Node {
 public:
index 10954080a51bfd45df0df75030ab758e8d486a8a..d9edc9e570aa638e821a02e60668d6db65683749 100644 (file)
@@ -26,8 +26,8 @@
 #include "COM_Node.h"
 #include "DNA_node_types.h"
 /**
- * @brief MixNode
- * @ingroup Node
+ * \brief MixNode
+ * \ingroup Node
  */
 class MixNode : public Node {
 public:
index 78fcf24de35dc06c6271b13effc7be93d0877a56..addee1a4ff87c0c3803715913e3a554933934a84 100644 (file)
@@ -27,8 +27,8 @@
 #include "DNA_node_types.h"
 
 /**
- * @brief MovieClipNode
- * @ingroup Node
+ * \brief MovieClipNode
+ * \ingroup Node
  */
 class MovieClipNode : public Node {
 public:
index 97cfaec57c8d1c73f2c51e4f4a123f89440837cc..59a8980bedabac13541ea6415dac9a1e48dd4225 100644 (file)
@@ -26,8 +26,8 @@
 #include "COM_Node.h"
 
 /**
- * @brief MovieDistortionNode
- * @ingroup Node
+ * \brief MovieDistortionNode
+ * \ingroup Node
  */
 class MovieDistortionNode : public Node {
 public:
index 4e1dbe553603f59ff4d8812188ff867d4e6d7434..74422007e0ee05d0fb1e680c7bf4d1355ec96dc9 100644 (file)
@@ -26,8 +26,8 @@
 #include "COM_Node.h"
 
 /**
- * @brief NormalNode
- * @ingroup Node
+ * \brief NormalNode
+ * \ingroup Node
  */
 class NormalNode : public Node {
 public:
index 02f413c6ae420f8e1da723dd510b330e10c550b4..540fbfcfb7b20f83b454de3533b3f89c5061aabf 100644 (file)
@@ -25,8 +25,8 @@
 #include "COM_Node.h"
 
 /**
- * @brief NormalizeNode
- * @ingroup Node
+ * \brief NormalizeNode
+ * \ingroup Node
  */
 class NormalizeNode : public Node {
 public:
index b246dd2a5411b6802365d417f63fb76a7c20887a..562e8ca5b9f01b0026925a76bb5dd3b5ce77d4cb 100644 (file)
@@ -28,8 +28,8 @@
 #include "DNA_node_types.h"
 
 /**
- * @brief OutputFileNode
- * @ingroup Node
+ * \brief OutputFileNode
+ * \ingroup Node
  */
 class OutputFileNode : public Node {
 public:
index b43c15b01dacdf42c1a1e757f7dae2425b63235a..c31a09a0cbe4c40f6b4761ab9a9a109f0931889e 100644 (file)
@@ -26,8 +26,8 @@
 #include "COM_Node.h"
 
 /**
- * @brief PixelateNode
- * @ingroup Node
+ * \brief PixelateNode
+ * \ingroup Node
  */
 class PixelateNode : public Node {
 public:
index 653100ce6a4a2ffea57d7de111b3b2646e6a1776..4e3445b1581aa3749958fc12337076731fc513a1 100644 (file)
@@ -27,8 +27,8 @@ extern "C" {
 }
 
 /**
- * @brief PlaneTrackDeformNode
- * @ingroup Node
+ * \brief PlaneTrackDeformNode
+ * \ingroup Node
  */
 class PlaneTrackDeformNode : public Node {
 public:
index edbc91fff700d5db6bfd8ceec9fac51b270cf2f8..0ecf4c60c437f8a72f01e741d077c52051a084d7 100644 (file)
@@ -27,8 +27,8 @@
 struct Render;
 
 /**
- * @brief RenderLayersNode
- * @ingroup Node
+ * \brief RenderLayersNode
+ * \ingroup Node
  */
 class RenderLayersNode : public Node {
 public:
index e3c9710891be68104f501109305323c59ce1e692..77d3879e530679c47eb2098a396e9b85bf84ac21 100644 (file)
@@ -26,8 +26,8 @@
 #include "COM_Node.h"
 
 /**
- * @brief RotateNode
- * @ingroup Node
+ * \brief RotateNode
+ * \ingroup Node
  */
 class RotateNode : public Node {
 public:
index b1695aab9661aa9435b3e7812fea131d014fa034..2ae07e5ab9b4b38637b3f617c195e363dd5c80ac 100644 (file)
@@ -26,8 +26,8 @@
 #include "COM_Node.h"
 
 /**
- * @brief ScaleNode
- * @ingroup Node
+ * \brief ScaleNode
+ * \ingroup Node
  */
 class ScaleNode : public Node {
 public:
index f71d743c1d47fec728d73649ebb4a705e5f02b5b..f5482c91f135acdb9cf66648294a358bfa5e7dc7 100644 (file)
@@ -26,8 +26,8 @@
 #include "COM_Node.h"
 
 /**
- * @brief SetAlphaNode
- * @ingroup Node
+ * \brief SetAlphaNode
+ * \ingroup Node
  */
 class SetAlphaNode : public Node {
 public:
index ce19a9abd7da4eab28a5dc12b2952deb792f69bb..2cf4c4afac54eaaf950592d4f5bb01491f3395b2 100644 (file)
@@ -26,8 +26,8 @@
 #include "COM_Node.h"
 
 /**
- * @brief SocketProxyNode
- * @ingroup Node
+ * \brief SocketProxyNode
+ * \ingroup Node
  */
 class SocketProxyNode : public Node {
 public:
index c073713f21f2ebad9b9304b438b0a51ea5f86fea..695313e5d9c3a431c7216b5fa29be3b36e37dab3 100644 (file)
@@ -26,8 +26,8 @@
 #include "COM_Node.h"
 #include "DNA_node_types.h"
 /**
- * @brief SplitViewerNode
- * @ingroup Node
+ * \brief SplitViewerNode
+ * \ingroup Node
  */
 class SplitViewerNode : public Node {
 public:
index 2859432fac7e1cfae4811b9f53a0cf8e16b6df50..4c45b2f6db0d0221e87aecb54abbe7ed7b2244b7 100644 (file)
@@ -27,8 +27,8 @@
 #include "DNA_node_types.h"
 
 /**
- * @brief Stabilize2dNode
- * @ingroup Node
+ * \brief Stabilize2dNode
+ * \ingroup Node
  */
 class Stabilize2dNode : public Node {
 public:
index 425b97061ca8bd26795e4bf40c9d65ea2d8f76ad..bb8c2e5defc1695c3edfbf059d3c78dcc8d3e7a5 100644 (file)
@@ -25,8 +25,8 @@
 #include "COM_Node.h"
 
 /**
- * @brief SunBeamsNode
- * @ingroup Node
+ * \brief SunBeamsNode
+ * \ingroup Node
  */
 class SunBeamsNode : public Node {
 public:
index 5967bbd5dd0540f43af2ca15dadd1370d9b3f395..96abef60f2102abad4cd8df2029a8e04712befd4 100644 (file)
@@ -27,8 +27,8 @@
 #include "COM_NodeOperation.h"
 #include "DNA_node_types.h"
 /**
- * @brief SwitchNode
- * @ingroup Node
+ * \brief SwitchNode
+ * \ingroup Node
  */
 class SwitchNode : public Node {
 public:
index f41719408807a48bd9b967a4acb428263f581851..9a89103a11ec7ac17dfffa9aa4588eda02a55181 100644 (file)
@@ -26,8 +26,8 @@
 #include "COM_NodeOperation.h"
 #include "DNA_node_types.h"
 /**
- * @brief SwitchViewNode
- * @ingroup Node
+ * \brief SwitchViewNode
+ * \ingroup Node
  */
 class SwitchViewNode : public Node {
 public:
index 4809f8a781ec79d45535ec6cbf050a9f75fafc0a..206b1ab102b76ce95901a5ced570e9f8d989a296 100644 (file)
@@ -24,8 +24,8 @@
 #include "DNA_node_types.h"
 
 /**
- * @brief TextureNode
- * @ingroup Node
+ * \brief TextureNode
+ * \ingroup Node
  */
 class TextureNode : public Node {
 public:
index 7ebc6f2cc67f88feb044eb0f2a292bc49a0fcef4..7d5eef7434ed3c73a1704b15fce93f7f06527288 100644 (file)
@@ -26,8 +26,8 @@
 #include "COM_Node.h"
 
 /**
- * @brief TimeNode
- * @ingroup Node
+ * \brief TimeNode
+ * \ingroup Node
  */
 class TimeNode : public Node {
 public:
index 13e51acf3fe0ee502784c709b55824e27cf645a7..309cd56e58036ec4d748cbd47b264149830c0d59 100644 (file)
@@ -26,8 +26,8 @@
 #include "COM_Node.h"
 
 /**
- * @brief TonemapNode
- * @ingroup Node
+ * \brief TonemapNode
+ * \ingroup Node
  */
 class TonemapNode : public Node {
 public:
index 375e28b6f8feba80d1df02caa56f3c0fd35d86da..04c3814605a32a4b2043dcbf1e5a0f180d1e1c1a 100644 (file)
@@ -25,8 +25,8 @@
 #include "DNA_node_types.h"
 
 /**
- * @brief TrackPositionNode
- * @ingroup Node
+ * \brief TrackPositionNode
+ * \ingroup Node
  */
 class TrackPositionNode : public Node {
 public:
index 9a7c415cc5de8bfe16f39391f2f0136dff42aa89..ad1935dcf230cc4618aa7bf8a96f8223d3773faa 100644 (file)
@@ -27,8 +27,8 @@
 #include "DNA_node_types.h"
 
 /**
- * @brief TransformNode
- * @ingroup Node
+ * \brief TransformNode
+ * \ingroup Node
  */
 class TransformNode : public Node {
 public:
index 51d969dbb046472c379b72ea71ef5287e4e6be41..535bd11c3b7761eb2393dbff80aaedf11a6b2068 100644 (file)
@@ -26,8 +26,8 @@
 #include "COM_Node.h"
 
 /**
- * @brief TranslateNode
- * @ingroup Node
+ * \brief TranslateNode
+ * \ingroup Node
  */
 class TranslateNode : public Node {
 public:
index e1b13c2d8aa0d80127e5cc265ce1571b49fcae6e..b7d80bcf393db4b1c7a9cb1671ad5fa954d0a18e 100644 (file)
@@ -26,8 +26,8 @@
 #include "COM_Node.h"
 
 /**
- * @brief ValueNode
- * @ingroup Node
+ * \brief ValueNode
+ * \ingroup Node
  */
 class ValueNode : public Node {
 public:
index 5f741ff0852ee0e6a3b85e3441396c6530c24b0e..93249a327faa7980b614bdca9802bb7ca19b8360 100644 (file)
@@ -26,8 +26,8 @@
 #include "COM_Node.h"
 
 /**
- * @brief VectorBlurNode
- * @ingroup Node
+ * \brief VectorBlurNode
+ * \ingroup Node
  */
 class VectorBlurNode : public Node {
 public:
index d8a2121a7c6159f6d4f678f3d5c810ba7ac50472..a95d505fa6dcd4f9d96ba6f3844452a1a6a4f603 100644 (file)
@@ -26,8 +26,8 @@
 #include "COM_Node.h"
 
 /**
- * @brief VectorCurveNode
- * @ingroup Node
+ * \brief VectorCurveNode
+ * \ingroup Node
  */
 class VectorCurveNode : public Node {
 public:
index 7fca060389a485e33e199cab9710217b80f7f8f4..b5b8a386051d7e5f61284c5895f99af1a7a5b1b9 100644 (file)
@@ -26,8 +26,8 @@
 #include "COM_Node.h"
 
 /**
- * @brief ViewLevelsNode
- * @ingroup Node
+ * \brief ViewLevelsNode
+ * \ingroup Node
  */
 class ViewLevelsNode : public Node {
 public:
index 67d6387a17c345fa434b1fc8f9363aedc4dcd54b..666bb55b6a565daa7daf3612a02458773a54fd32 100644 (file)
@@ -26,8 +26,8 @@
 #include "COM_Node.h"
 #include "DNA_node_types.h"
 /**
- * @brief ViewerNode
- * @ingroup Node
+ * \brief ViewerNode
+ * \ingroup Node
  */
 class ViewerNode : public Node {
 public:
index 8e166ddf1682cc4363bbcb07fe064ca7dd3d27b3..ee3558cd58f5a60d87656a089531fbea38dceb0c 100644 (file)
@@ -26,8 +26,8 @@
 #include "COM_Node.h"
 
 /**
- * @brief ZCombineNode
- * @ingroup Node
+ * \brief ZCombineNode
+ * \ingroup Node
  */
 class ZCombineNode : public Node {
 public:
index 34243cd34b618b7faef491ba17f9108ac86fa599..25781196b1f3d0e2b8d97a6116064636b8102f5e 100644 (file)
 #include "DNA_node_types.h"
 
 /**
- * @brief AntiAlias operations
+ * \brief AntiAlias operations
  * it only supports anti aliasing on BW buffers.
- * @ingroup operation
+ * \ingroup operation
  */
 class AntiAliasOperation : public NodeOperation {
 protected:
        /**
-        * @brief Cached reference to the reader
+        * \brief Cached reference to the reader
         */
        SocketReader *m_valueReader;
 public:
index c6ca7054352beee9738d7f26767eef2d1b780741..d26f3f7066c2aa576e038d8f80d7f22503ab1bc4 100644 (file)
@@ -25,7 +25,7 @@
 #include "COM_NodeOperation.h"
 
 /**
- * @brief The BokehImageOperation class is an operation that creates an image useful to mimic the internals
+ * \brief The BokehImageOperation class is an operation that creates an image useful to mimic the internals
  *of a camera.
  *
  * features:
 class BokehImageOperation : public NodeOperation {
 private:
        /**
-        * @brief Settings of the bokeh image
+        * \brief Settings of the bokeh image
         */
        NodeBokehImage *m_data;
 
        /**
-        * @brief precalced center of the image
+        * \brief precalced center of the image
         */
        float m_center[2];
 
        /**
-        * @brief 1.0-rounding
+        * \brief 1.0-rounding
         */
        float m_inverseRounding;
 
        /**
-        * @brief distance of a full circle lens
+        * \brief distance of a full circle lens
         */
        float m_circularDistance;
 
        /**
-        * @brief radius when the first flap starts
+        * \brief radius when the first flap starts
         */
        float m_flapRad;
 
        /**
-        * @brief radians of a single flap
+        * \brief radians of a single flap
         */
        float m_flapRadAdd;
 
        /**
-        * @brief should the m_data field by deleted when this operation is finished
+        * \brief should the m_data field by deleted when this operation is finished
         */
        bool m_deleteData;
 
        /**
-        * @brief determine the coordinate of a flap cornder
+        * \brief determine the coordinate of a flap cornder
         *
-        * @param r result in bokehimage space are stored [x,y]
-        * @param flapNumber the flap number to calculate
-        * @param distance the lens distance is used to simulate lens shifts
+        * \param r result in bokehimage space are stored [x,y]
+        * \param flapNumber the flap number to calculate
+        * \param distance the lens distance is used to simulate lens shifts
         */
        void detemineStartPointOfFlap(float r[2], int flapNumber, float distance);
 
        /**
-        * @brief Determine if a coordinate is inside the bokeh image
+        * \brief Determine if a coordinate is inside the bokeh image
         *
-        * @param distance the distance that will be used. This parameter is modified a bit to mimic lens shifts
-        * @param x the x coordinate of the pixel to evaluate
-        * @param y the y coordinate of the pixel to evaluate
-        * @return float range 0..1 0 is completely outside
+        * \param distance the distance that will be used. This parameter is modified a bit to mimic lens shifts
+        * \param x the x coordinate of the pixel to evaluate
+        * \param y the y coordinate of the pixel to evaluate
+        * \return float range 0..1 0 is completely outside
         */
        float isInsideBokeh(float distance, float x, float y);
 public:
        BokehImageOperation();
 
        /**
-        * @brief the inner loop of this program
+        * \brief the inner loop of this program
         */
        void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 
        /**
-        * @brief Initialize the execution
+        * \brief Initialize the execution
         */
        void initExecution();
 
        /**
-        * @brief Deinitialize the execution
+        * \brief Deinitialize the execution
         */
        void deinitExecution();
 
        /**
-        * @brief determine the resolution of this operation. currently fixed at [COM_BLUR_BOKEH_PIXELS, COM_BLUR_BOKEH_PIXELS]
-        * @param resolution
-        * @param preferredResolution
+        * \brief determine the resolution of this operation. currently fixed at [COM_BLUR_BOKEH_PIXELS, COM_BLUR_BOKEH_PIXELS]
+        * \param resolution
+        * \param preferredResolution
         */
        void determineResolution(unsigned int resolution[2], unsigned int preferredResolution[2]);
 
        /**
-        * @brief set the node data
-        * @param data
+        * \brief set the node data
+        * \param data
         */
        void setData(NodeBokehImage *data) { this->m_data = data; }
 
        /**
-        * @brief deleteDataOnFinish
+        * \brief deleteDataOnFinish
         *
         * There are cases that the compositor uses this operation on its own (see defocus node)
         * the deleteDataOnFinish must only be called when the data has been created by the compositor.
index 1872cb738b20b226982e91f5eb20b861eb284616..265057b6536d695e9b361a1d814f80c9cbc1d5c4 100644 (file)
 #include "DNA_node_types.h"
 
 /**
- * @brief base class of CalculateMean, implementing the simple CalculateMean
- * @ingroup operation
+ * \brief base class of CalculateMean, implementing the simple CalculateMean
+ * \ingroup operation
  */
 class CalculateMeanOperation : public NodeOperation {
 protected:
        /**
-        * @brief Cached reference to the reader
+        * \brief Cached reference to the reader
         */
        SocketReader *m_imageReader;
 
index 7089e40b210b125270c6e1677cd8123bd4fd18e9..2d357f30f7b09e33bcf83debf5105100c51f9ddc 100644 (file)
@@ -26,8 +26,8 @@
 #include "DNA_node_types.h"
 #include "COM_CalculateMeanOperation.h"
 /**
- * @brief base class of CalculateStandardDeviation, implementing the simple CalculateStandardDeviation
- * @ingroup operation
+ * \brief base class of CalculateStandardDeviation, implementing the simple CalculateStandardDeviation
+ * \ingroup operation
  */
 class CalculateStandardDeviationOperation : public CalculateMeanOperation {
 protected:
index 19ed3180ace031e59ca18e9270d827f86f4beaa2..2645c69579de91178a66ccd8bef0f48cc79521e0 100644 (file)
 struct Scene;
 
 /**
- * @brief Compositor output operation
+ * \brief Compositor output operation
  */
 class CompositorOperation : public NodeOperation {
 private:
        const struct Scene *m_scene;
        /**
-        * @brief Scene name, used for getting the render output, includes 'SC' prefix.
+        * \brief Scene name, used for getting the render output, includes 'SC' prefix.
         */
        char m_sceneName[MAX_ID_NAME];
 
        /**
-        * @brief local reference to the scene
+        * \brief local reference to the scene
         */
        const RenderData *m_rd;
 
        /**
-        * @brief reference to the output float buffer
+        * \brief reference to the output float buffer
         */
        float *m_outputBuffer;
 
        /**
-        * @brief reference to the output depth float buffer
+        * \brief reference to the output depth float buffer
         */
        float *m_depthBuffer;
 
        /**
-        * @brief local reference to the input image operation
+        * \brief local reference to the input image operation
         */
        SocketReader *m_imageInput;
 
        /**
-        * @brief local reference to the input alpha operation
+        * \brief local reference to the input alpha operation
         */
        SocketReader *m_alphaInput;
 
        /**
-        * @brief local reference to the depth operation
+        * \brief local reference to the depth operation
         */
        SocketReader *m_depthInput;
 
        /**
-        * @brief Ignore any alpha input
+        * \brief Ignore any alpha input
         */
        bool m_useAlphaInput;
 
        /**
-        * @brief operation is active for calculating final compo result
+        * \brief operation is active for calculating final compo result
         */
        bool m_active;
 
        /**
-        * @brief View name, used for multiview
+        * \brief View name, used for multiview
         */
        const char *m_viewName;
 public:
index 3dc7b67df8d768d78e8a676c257edca54d11f2f6..3b7272e86f632e2373936e4d9c4f96177f28cc1a 100644 (file)
@@ -37,17 +37,17 @@ private:
        SocketReader *m_inputOperation;
 
        /**
-        * @brief color profile where to convert from
+        * \brief color profile where to convert from
         */
        int m_fromProfile;
 
        /**
-        * @brief color profile where to convert to
+        * \brief color profile where to convert to
         */
        int m_toProfile;
 
        /**
-        * @brief is color predivided
+        * \brief is color predivided
         */
        bool m_predivided;
 public:
index e2e54ee4aa7df10810f3203c2fdaf298c7e29c8c..a0cde948d2593c254d346d2acf3491559614d525 100644 (file)
@@ -43,7 +43,7 @@ void DotproductOperation::deinitExecution()
        this->m_input2Operation = NULL;
 }
 
-/** @todo: current implementation is the inverse of a dotproduct. not 'logically' correct
+/** \todo: current implementation is the inverse of a dotproduct. not 'logically' correct
  */
 void DotproductOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
index 985f56e3ef623b7eb7c76807d387463d4e349a53..50b3d68426c108c7df1d1e40bec89e7cd6652a6a 100644 (file)
@@ -38,17 +38,17 @@ public:
        GaussianAlphaXBlurOperation();
 
        /**
-        * @brief the inner loop of this program
+        * \brief the inner loop of this program
         */
        void executePixel(float output[4], int x, int y, void *data);
 
        /**
-        * @brief initialize the execution
+        * \brief initialize the execution
         */
        void initExecution();
 
        /**
-        * @brief Deinitialize the execution
+        * \brief Deinitialize the execution
         */
        void deinitExecution();
 
index 3935dcd65689d3b527e2673c2128e4694a36d426..30672ad5ab2f0bbb8d55b820cd31812cbb61c861 100644 (file)
@@ -43,7 +43,7 @@ public:
        void executePixel(float output[4], int x, int y, void *data);
 
        /**
-        * @brief initialize the execution
+        * \brief initialize the execution
         */
        void initExecution();
 
index 88d8ed44de66f8337d2ab427441ab1eba6cbd235..6e7c9adbd9b254d1e570ae9882a381188f2d13d0 100644 (file)
@@ -37,7 +37,7 @@ public:
        GaussianXBlurOperation();
 
        /**
-        * @brief the inner loop of this program
+        * \brief the inner loop of this program
         */
        void executePixel(float output[4], int x, int y, void *data);
 
@@ -47,12 +47,12 @@ public:
                           list<cl_kernel> *clKernelsToCleanUp);
 
        /**
-        * @brief initialize the execution
+        * \brief initialize the execution
         */
        void initExecution();
 
        /**
-        * @brief Deinitialize the execution
+        * \brief Deinitialize the execution
         */
        void deinitExecution();
 
index 5df77eb28cebbba65897fb68b96030ff945faf39..00f9ebcd21f162d1723b290b8e7f778779a1f865 100644 (file)
@@ -47,7 +47,7 @@ public:
                           list<cl_kernel> *clKernelsToCleanUp);
 
        /**
-        * @brief initialize the execution
+        * \brief initialize the execution
         */
        void initExecution();
 
index 3fa676f4d316a2375008da3ee0c7e34ab9360b16..413d495f6704a0962f6d796fd7cfae48c52cd755 100644 (file)
@@ -39,12 +39,12 @@ typedef float fRGB[4];
 class GlareBaseOperation : public SingleThreadedOperation {
 private:
        /**
-        * @brief Cached reference to the inputProgram
+        * \brief Cached reference to the inputProgram
         */
        SocketReader *m_inputProgram;
 
        /**
-        * @brief settings of the glare node.
+        * \brief settings of the glare node.
         */
        NodeGlare *m_settings;
 public:
index 9a922a5889c19ccfc6f2a780d1acc813605c2e79..7934dd20524906747904ac996b5b1d4adcf10303 100644 (file)
 class GlareThresholdOperation : public NodeOperation {
 private:
        /**
-        * @brief Cached reference to the inputProgram
+        * \brief Cached reference to the inputProgram
         */
        SocketReader *m_inputProgram;
 
        /**
-        * @brief settings of the glare node.
+        * \brief settings of the glare node.
         */
        NodeGlare *m_settings;
 public:
index 60172eb6413681dd0c80ef5e0003337e0e8e53f0..40928484dbb0abaccd5e0d4a6b3b4cc7a969cbf5 100644 (file)
@@ -35,7 +35,7 @@ extern "C" {
 }
 
 /**
- * @brief Base class for all image operations
+ * \brief Base class for all image operations
  */
 class BaseImageOperation : public NodeOperation {
 protected:
index 33513c6f39ce87d3a131f0c0ae124daff67646ae..c057ffe606a9f040511e530263208c06f92bb5d7 100644 (file)
@@ -58,7 +58,7 @@ public:
        void deinitExecution();
 
        /**
-        * @brief set the TexMapping settings
+        * \brief set the TexMapping settings
         */
        void setSettings(TexMapping *settings) { this->m_settings = settings; }
 
index de1a23926f4fe8b0599dd263421b756c08c094c5..cebfad5dd17030e55a10b7cd8743971b4ae47c1c 100644 (file)
 #include "DNA_node_types.h"
 
 /**
- * @brief base class of normalize, implementing the simple normalize
- * @ingroup operation
+ * \brief base class of normalize, implementing the simple normalize
+ * \ingroup operation
  */
 class NormalizeOperation : public NodeOperation {
 protected:
        /**
-        * @brief Cached reference to the reader
+        * \brief Cached reference to the reader
         */
        SocketReader *m_imageReader;
 
        /**
-        * @brief temporarily cache of the execution storage
+        * \brief temporarily cache of the execution storage
         * it stores x->min and y->mult
         */
        NodeTwoFloats *m_cachedInstance;
index 5b08cb429f44eaffd39eb808d51c0c927b7b4dc6..59337f11b546e88f7fe3a2a70afc11f3c44967b9 100644 (file)
@@ -26,7 +26,7 @@
 #include "COM_NodeOperation.h"
 
 /**
- * @brief Pixelate operation
+ * \brief Pixelate operation
  *
  * The Tile compositor is by default sub-pixel accurate.
  * For some setups you don want this.
 class PixelateOperation : public NodeOperation {
 private:
        /**
-        * @brief cached reference to the input operation
+        * \brief cached reference to the input operation
         */
        SocketReader *m_inputOperation;
 public:
        /**
-        * @brief PixelateOperation
-        * @param dataType the datatype to create this operator for (saves datatype conversions)
+        * \brief PixelateOperation
+        * \param dataType the datatype to create this operator for (saves datatype conversions)
         */
        PixelateOperation(DataType dataType);
 
        /**
-        * @brief initialization of the execution
+        * \brief initialization of the execution
         */
        void initExecution();
 
        /**
-        * @brief de-initialization of the execution
+        * \brief de-initialization of the execution
         */
        void deinitExecution();
 
        /**
-        * @brief executePixel
-        * @param output result
-        * @param x x-coordinate
-        * @param y y-coordinate
-        * @param sampler sampler
+        * \brief executePixel
+        * \param output result
+        * \param x x-coordinate
+        * \param y y-coordinate
+        * \param sampler sampler
         */
        void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
index 753177488971d6cbf72ff9955173d1cc3d7163a1..cf447dd8e992ac19198010ff9d6abcdf34572b69 100644 (file)
@@ -33,7 +33,7 @@ protected:
        unsigned char *m_outputBuffer;
 
        /**
-        * @brief holds reference to the SDNA bNode, where this nodes will render the preview image for
+        * \brief holds reference to the SDNA bNode, where this nodes will render the preview image for
         */
        bNodePreview *m_preview;
        SocketReader *m_input;
index 6e7a32ba5a951c109c73bcea6d6c1d495a612b34..277b3606ff9ab6cea3fd5dec52e5b54787659c6b 100644 (file)
@@ -44,7 +44,7 @@ void ReadBufferOperation::determineResolution(unsigned int resolution[2], unsign
                operation->determineResolution(resolution, preferredResolution);
                operation->setResolution(resolution);
 
-               /// @todo: may not occur!, but does with blur node
+               /// \todo: may not occur!, but does with blur node
                if (this->m_memoryProxy->getExecutor()) {
                        this->m_memoryProxy->getExecutor()->setResolution(resolution);
                }
index 2a0f7efc9f8c4675a955ac6ff12ec74a8144a9da..b5946d44f74129f73545a81582806bcdd0c337b4 100644 (file)
@@ -36,7 +36,7 @@ extern "C" {
 /**
  * Base class for all renderlayeroperations
  *
- * @todo: rename to operation.
+ * \todo: rename to operation.
  */
 class RenderLayersProg : public NodeOperation {
 protected:
@@ -68,7 +68,7 @@ protected:
        int m_elementsize;
 
        /**
-        * @brief render data used for active rendering
+        * \brief render data used for active rendering
         */
        const RenderData *m_rd;
 
@@ -90,7 +90,7 @@ public:
        RenderLayersProg(const char *passName, DataType type, int elementsize);
        /**
         * setter for the scene field. Will be called from
-        * @see RenderLayerNode to set the actual scene where
+        * \see RenderLayerNode to set the actual scene where
         * the data will be retrieved from.
         */
        void setScene(Scene *scene) { this->m_scene = scene; }
index 9f0f539800d87dfaa3c4a53265afe597dd37271c..434f590a65d92b1e5ea1a06145fdce78e428cbd7 100644 (file)
@@ -37,7 +37,7 @@ extern "C" {
 /**
  * Base class for all renderlayeroperations
  *
- * @todo: rename to operation.
+ * \todo: rename to operation.
  */
 class TextureBaseOperation : public NodeOperation {
 private:
index 2b07ded7305284a54b908d33740a98925376ed6e..c205785b023113623606fa547bb661e217fe04ab 100644 (file)
@@ -26,8 +26,8 @@
 #include "DNA_node_types.h"
 
 /**
- * @brief temporarily storage during execution of Tonemap
- * @ingroup operation
+ * \brief temporarily storage during execution of Tonemap
+ * \ingroup operation
  */
 typedef struct AvgLogLum {
        float al;
@@ -38,23 +38,23 @@ typedef struct AvgLogLum {
 } AvgLogLum;
 
 /**
- * @brief base class of tonemap, implementing the simple tonemap
- * @ingroup operation
+ * \brief base class of tonemap, implementing the simple tonemap
+ * \ingroup operation
  */
 class TonemapOperation : public NodeOperation {
 protected:
        /**
-        * @brief Cached reference to the reader
+        * \brief Cached reference to the reader
         */
        SocketReader *m_imageReader;
 
        /**
-        * @brief settings of the Tonemap
+        * \brief settings of the Tonemap
         */
        NodeTonemap *m_data;
 
        /**
-        * @brief temporarily cache of the execution storage
+        * \brief temporarily cache of the execution storage
         */
        AvgLogLum *m_cachedInstance;
 
@@ -85,9 +85,9 @@ public:
 };
 
 /**
- * @brief class of tonemap, implementing the photoreceptor tonemap
+ * \brief class of tonemap, implementing the photoreceptor tonemap
  * most parts have already been done in TonemapOperation
- * @ingroup operation
+ * \ingroup operation
  */
 
 class PhotoreceptorTonemapOperation : public TonemapOperation {
index a33761166c65bff1785d96ce053c17bb13307157..fe8e9f20edbe54bb1bbb6e1803ccf721c1fc39e7 100644 (file)
 class VectorBlurOperation : public NodeOperation, public QualityStepHelper {
 private:
        /**
-        * @brief Cached reference to the inputProgram
+        * \brief Cached reference to the inputProgram
         */
        SocketReader *m_inputImageProgram;
        SocketReader *m_inputSpeedProgram;
        SocketReader *m_inputZProgram;
 
        /**
-        * @brief settings of the glare node.
+        * \brief settings of the glare node.
         */
        NodeBlurData *m_settings;
 
index 583d58e7b993522527d98ba38ec0cbcdfbf4d69f..639d1ba1d981eaff062b20559f1e4e15b2d82411 100644 (file)
@@ -27,8 +27,8 @@
 #include "COM_MemoryProxy.h"
 #include "COM_SocketReader.h"
 /**
- * @brief NodeOperation to write to a tile
- * @ingroup Operation
+ * \brief NodeOperation to write to a tile
+ * \ingroup Operation
  */
 class WriteBufferOperation : public NodeOperation {
        MemoryProxy *m_memoryProxy;
index 5ba96f31272ca66cb0881ba686e8328df2d53c81..50b55027de7cd38c8760af3bbc59fd165bcbe9fc 100644 (file)
@@ -68,7 +68,7 @@ protected:
 /*! [ Geometry Shader ].
  *  Spatial Noise stroke shader.
  *  Moves the vertices to make the stroke more noisy.
- *  @see \htmlonly <a href=noise/noise.html>noise/noise.html</a> \endhtmlonly
+ *  \see \htmlonly <a href=noise/noise.html>noise/noise.html</a> \endhtmlonly
  */
 class SpatialNoiseShader : public StrokeShader
 {
@@ -106,7 +106,7 @@ protected:
  *  (Moves the vertices to make the stroke smoother).
  *  Uses curvature flow to converge towards a curve of constant curvature. The diffusion method we use is anisotropic
  *  to prevent the diffusion accross corners.
- *  @see \htmlonly <a href=/smoothing/smoothing.html>smoothing/smoothing.html</a> \endhtmlonly
+ *  \see \htmlonly <a href=/smoothing/smoothing.html>smoothing/smoothing.html</a> \endhtmlonly
  */
 class SmoothingShader : public StrokeShader
 {
index d3d19beba95a8b1eee3c25efbfa04586b96e9fbd..1cdc754d725250445a2a6b442577ad7a8a56908f 100644 (file)
@@ -428,7 +428,7 @@ public:
 
 /*! [ Geometry Shader. ]
  *  Resamples the stroke.
- *  @see Stroke::Resample(float).
+ *  \see Stroke::Resample(float).
  */
 class SamplingShader: public StrokeShader
 {
@@ -479,7 +479,7 @@ public:
 /*! [ Geometry Shader ].
  *  Transforms the stroke backbone geometry so that it corresponds to a Bezier Curve approximation of the
  *  original backbone geometry.
- *  @see \htmlonly <a href=bezier/bezier.html>bezier/bezier.html</a> \endhtmlonly
+ *  \see \htmlonly <a href=bezier/bezier.html>bezier/bezier.html</a> \endhtmlonly
  */
 class BezierCurveShader : public StrokeShader
 {
index 60b8c21067f17773fa5dff6a29bd5a9c0f8507ca..ce63c528ac36b3c9ec440f53a6421a03211144ee 100644 (file)
@@ -583,8 +583,8 @@ public:
         *  \param iNVertices
         *    The number of StrokeVertices we eventually want in our Stroke.
         *  \return the sampling that must be used in the Resample(float) method.
-        *  @see Resample(int)
-        *  @see Resample(float)
+        *  \see Resample(int)
+        *  \see Resample(float)
         */
        float ComputeSampling(int iNVertices);
 
index 7a8243eb43d90990e11b5190e8bbc18dbbb7a2d2..2a38bff533d8c9b1f8ba1626762908eb7ab7754e 100644 (file)
@@ -523,7 +523,7 @@ public:
                m_pGraphicController = graphiccontroller;
        }
        /*
-        * @add/remove the graphic controller to the physic system
+        * add/remove the graphic controller to the physic system
         */
        void ActivateGraphicController(bool recurse);
 
index 808d257f8f0c10933fc5777c31f232e6282d9ef1..2e6e3809063f7ae46594928432b41939a7f2c217 100644 (file)
@@ -55,7 +55,7 @@ struct ScreenshotTaskData
  * Function that actually performs the image compression and saving to disk of a screenshot.
  * Run in a separate thread by RAS_ICanvas::save_screenshot().
  *
- * @param taskdata Must point to a ScreenshotTaskData object. This function takes ownership
+ * \param taskdata Must point to a ScreenshotTaskData object. This function takes ownership
  *                 of all pointers in the ScreenshotTaskData, and frees them.
  */
 void save_screenshot_thread_func(TaskPool *__restrict pool, void *taskdata, int threadid);
index 2c67f454df1e93f71f555fba1692c27d2258f400..1e4d22243d0759ff82cfde83d0de634b2d5b6361 100644 (file)
@@ -269,12 +269,12 @@ protected:
         * Saves screenshot data to a file. The actual compression and disk I/O is performed in
         * a separate thread.
         *
-        * @param filename name of the file, can contain "###" for sequential numbering. A copy of the string
+        * \param filename name of the file, can contain "###" for sequential numbering. A copy of the string
         *                 is made, so the pointer can be freed by the caller.
-        * @param dumpsx width in pixels.
-        * @param dumpsy height in pixels.
-        * @param dumprect pixel data; ownership is passed to this function, which also frees the data.
-        * @param im_format image format for the file; ownership is passed to this function, which also frees the data.
+        * \param dumpsx width in pixels.
+        * \param dumpsy height in pixels.
+        * \param dumprect pixel data; ownership is passed to this function, which also frees the data.
+        * \param im_format image format for the file; ownership is passed to this function, which also frees the data.
         */
        void save_screenshot(const char *filename, int dumpsx, int dumpsy, unsigned int *dumprect,
                             ImageFormatData * im_format);