archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity

Cleanup: convert camelCase naming to snake_case in Compositor

Browse Source 
To convert old code to the current convention and
use a single code style.
This commit is contained in:
Manuel Castilla
2021-10-13 23:01:15 +02:00
parent a2ee3c3a9f
commit 1c42d4930a
456 changed files with 10870 additions and 10727 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -91,7 +91,7 @@ class NodeOperationInput {
DataType datatype_;
/** Resize mode of this socket */
ResizeMode resizeMode_;
ResizeMode resize_mode_;
/** Connected output */
NodeOperationOutput *link_;
@@ -99,40 +99,40 @@ class NodeOperationInput {
public:
NodeOperationInput(NodeOperation *op,
DataType datatype,
ResizeMode resizeMode = ResizeMode::Center);
ResizeMode resize_mode = ResizeMode::Center);
NodeOperation &getOperation() const
NodeOperation &get_operation() const
{
return *operation_;
}
DataType getDataType() const
DataType get_data_type() const
{
return datatype_;
}
void setLink(NodeOperationOutput *link)
void set_link(NodeOperationOutput *link)
{
link_ = link;
}
NodeOperationOutput *getLink() const
NodeOperationOutput *get_link() const
{
return link_;
}
bool isConnected() const
bool is_connected() const
{
return link_;
}
void setResizeMode(ResizeMode resizeMode)
void set_resize_mode(ResizeMode resize_mode)
{
resizeMode_ = resizeMode;
resize_mode_ = resize_mode;
}
ResizeMode getResizeMode() const
ResizeMode get_resize_mode() const
{
return resizeMode_;
return resize_mode_;
}
SocketReader *getReader();
SocketReader *get_reader();
bool determine_canvas(const rcti &preferred_area, rcti &r_area);
@@ -153,11 +153,11 @@ class NodeOperationOutput {
public:
NodeOperationOutput(NodeOperation *op, DataType datatype);
NodeOperation &getOperation() const
NodeOperation &get_operation() const
{
return *operation_;
}
DataType getDataType() const
DataType get_data_type() const
{
return datatype_;
}
@@ -334,9 +334,9 @@ class NodeOperation {
* \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 NodeOperation.init_mutex initializes this mutex
* \see NodeOperation.deinit_mutex deinitializes this mutex
* \see NodeOperation.get_mutex retrieve a pointer to this mutex.
*/
ThreadMutex mutex_;
@@ -395,28 +395,23 @@ class NodeOperation {
std::optional<NodeOperationHash> generate_hash();
unsigned int getNumberOfInputSockets() const
unsigned int get_number_of_input_sockets() const
{
return inputs_.size();
}
unsigned int getNumberOfOutputSockets() const
unsigned int get_number_of_output_sockets() const
{
return outputs_.size();
}
NodeOperationOutput *getOutputSocket(unsigned int index = 0);
NodeOperationInput *getInputSocket(unsigned int index);
NodeOperationOutput *get_output_socket(unsigned int index = 0);
NodeOperationInput *get_input_socket(unsigned int index);
NodeOperation *get_input_operation(int index)
{
/* TODO: Rename protected getInputOperation to get_input_operation and make it public replacing
* this method. */
return getInputOperation(index);
}
NodeOperation *get_input_operation(int index);
virtual void determine_canvas(const rcti &preferred_area, rcti &r_area);
/**
* \brief isOutputOperation determines whether this operation is an output of the
* \brief is_output_operation determines whether this operation is an output of the
* ExecutionSystem during rendering or editing.
*
* Default behavior if not overridden, this operation will not be evaluated as being an output
@@ -430,7 +425,7 @@ class NodeOperation {
*
* \return bool the result of this method
*/
virtual bool isOutputOperation(bool /*rendering*/) const
virtual bool is_output_operation(bool /*rendering*/) const
{
return false;
}
@@ -440,7 +435,7 @@ class NodeOperation {
execution_model_ = model;
}
void setbNodeTree(const bNodeTree *tree)
void set_bnodetree(const bNodeTree *tree)
{
btree_ = tree;
}
@@ -452,20 +447,20 @@ class NodeOperation {
/**
* Initializes operation data needed after operations are linked and resolutions determined. For
* rendering heap memory data use initExecution().
* rendering heap memory data use init_execution().
*/
virtual void init_data();
virtual void initExecution();
virtual void init_execution();
/**
* \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
* \param chunk_number: the chunk_number to be calculated
* \param memory_buffers: all input MemoryBuffer's needed
*/
virtual void executeRegion(rcti * /*rect*/, unsigned int /*chunkNumber*/)
virtual void execute_region(rcti * /*rect*/, unsigned int /*chunk_number*/)
{
}
@@ -477,15 +472,15 @@ class NodeOperation {
* \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
* \param chunk_number: the chunk_number to be calculated
* \param memory_buffers: all input MemoryBuffer's needed
* \param output_buffer: the outputbuffer to write to
*/
virtual void executeOpenCLRegion(OpenCLDevice * /*device*/,
rcti * /*rect*/,
unsigned int /*chunkNumber*/,
MemoryBuffer ** /*memoryBuffers*/,
MemoryBuffer * /*outputBuffer*/)
virtual void execute_opencl_region(OpenCLDevice * /*device*/,
rcti * /*rect*/,
unsigned int /*chunk_number*/,
MemoryBuffer ** /*memory_buffers*/,
MemoryBuffer * /*output_buffer*/)
{
}
@@ -496,23 +491,23 @@ class NodeOperation {
* \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.
* \param output_memory_buffer: the allocated memory buffer in main CPU memory
* \param cl_output_buffer: the allocated memory buffer in OpenCLDevice memory
* \param input_memory_buffers: all input MemoryBuffer's needed
* \param cl_mem_to_clean_up: 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.
* \param cl_kernels_to_clean_up: all created cl_kernel references must be added to this list.
* Framework will clean this after execution
*/
virtual void executeOpenCL(OpenCLDevice * /*device*/,
MemoryBuffer * /*outputMemoryBuffer*/,
cl_mem /*clOutputBuffer*/,
MemoryBuffer ** /*inputMemoryBuffers*/,
std::list<cl_mem> * /*clMemToCleanUp*/,
std::list<cl_kernel> * /*clKernelsToCleanUp*/)
virtual void execute_opencl(OpenCLDevice * /*device*/,
MemoryBuffer * /*output_memory_buffer*/,
cl_mem /*cl_output_buffer*/,
MemoryBuffer ** /*input_memory_buffers*/,
std::list<cl_mem> * /*cl_mem_to_clean_up*/,
std::list<cl_kernel> * /*cl_kernels_to_clean_up*/)
{
}
virtual void deinitExecution();
virtual void deinit_execution();
void set_canvas(const rcti &canvas_area);
const rcti &get_canvas() const;
@@ -525,14 +520,14 @@ class NodeOperation {
* \return [true:false]
* \see BaseViewerOperation
*/
virtual bool isActiveViewerOutput() const
virtual bool is_active_viewer_output() const
{
return false;
}
virtual bool determineDependingAreaOfInterest(rcti *input,
ReadBufferOperation *readOperation,
rcti *output);
virtual bool determine_depending_area_of_interest(rcti *input,
ReadBufferOperation *read_operation,
rcti *output);
/**
* \brief set the index of the input socket that will determine the canvas of this
@@ -554,58 +549,58 @@ class NodeOperation {
* \note only applicable for output operations like ViewerOperation
* \return eCompositorPriority
*/
virtual eCompositorPriority getRenderPriority() const
virtual eCompositorPriority get_render_priority() const
{
return eCompositorPriority::Low;
}
inline bool isBraked() const
inline bool is_braked() const
{
return btree_->test_break(btree_->tbh);
}
inline void updateDraw()
inline void update_draw()
{
if (btree_->update_draw) {
btree_->update_draw(btree_->udh);
}
}
unsigned int getWidth() const
unsigned int get_width() const
{
return BLI_rcti_size_x(&get_canvas());
}
unsigned int getHeight() const
unsigned int get_height() const
{
return BLI_rcti_size_y(&get_canvas());
}
inline void readSampled(float result[4], float x, float y, PixelSampler sampler)
inline void read_sampled(float result[4], float x, float y, PixelSampler sampler)
{
executePixelSampled(result, x, y, sampler);
execute_pixel_sampled(result, x, y, sampler);
}
inline void readFiltered(float result[4], float x, float y, float dx[2], float dy[2])
inline void read_filtered(float result[4], float x, float y, float dx[2], float dy[2])
{
executePixelFiltered(result, x, y, dx, dy);
execute_pixel_filtered(result, x, y, dx, dy);
}
inline void read(float result[4], int x, int y, void *chunkData)
inline void read(float result[4], int x, int y, void *chunk_data)
{
executePixel(result, x, y, chunkData);
execute_pixel(result, x, y, chunk_data);
}
virtual void *initializeTileData(rcti * /*rect*/)
virtual void *initialize_tile_data(rcti * /*rect*/)
{
return 0;
}
virtual void deinitializeTileData(rcti * /*rect*/, void * /*data*/)
virtual void deinitialize_tile_data(rcti * /*rect*/, void * /*data*/)
{
}
virtual MemoryBuffer *getInputMemoryBuffer(MemoryBuffer ** /*memoryBuffers*/)
virtual MemoryBuffer *get_input_memory_buffer(MemoryBuffer ** /*memory_buffers*/)
{
return 0;
}
@@ -614,7 +609,7 @@ class NodeOperation {
* Return the meta data associated with this branch.
*
* The return parameter holds an instance or is an nullptr. */
virtual std::unique_ptr<MetaData> getMetaData()
virtual std::unique_ptr<MetaData> get_meta_data()
{
return std::unique_ptr<MetaData>();
}
@@ -672,28 +667,27 @@ class NodeOperation {
combine_hashes(params_hash_, get_default_hash_3(param1, param2, param3));
}
void addInputSocket(DataType datatype, ResizeMode resize_mode = ResizeMode::Center);
void addOutputSocket(DataType datatype);
void add_input_socket(DataType datatype, ResizeMode resize_mode = ResizeMode::Center);
void add_output_socket(DataType datatype);
/* TODO(manzanilla): to be removed with tiled implementation. */
void setWidth(unsigned int width)
void set_width(unsigned int width)
{
canvas_.xmax = canvas_.xmin + width;
this->flags.is_canvas_set = true;
}
void setHeight(unsigned int height)
void set_height(unsigned int height)
{
canvas_.ymax = canvas_.ymin + height;
this->flags.is_canvas_set = true;
}
SocketReader *getInputSocketReader(unsigned int inputSocketindex);
NodeOperation *getInputOperation(unsigned int inputSocketindex);
SocketReader *get_input_socket_reader(unsigned int index);
void deinitMutex();
void initMutex();
void lockMutex();
void unlockMutex();
void deinit_mutex();
void init_mutex();
void lock_mutex();
void unlock_mutex();
/**
* \brief set whether this operation is complex
@@ -701,7 +695,7 @@ class NodeOperation {
* Complex operations are typically doing many reads to calculate the output of a single pixel.
* Mostly Filter types (Blurs, Convolution, Defocus etc) need this to be set to true.
*/
void setComplex(bool complex)
void set_complex(bool complex)
{
this->flags.complex = complex;
}
@@ -712,12 +706,12 @@ class NodeOperation {
* \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 input_buffers: chunks that can be read by their ReadBufferOperation.
*/
virtual void executePixelSampled(float /*output*/[4],
float /*x*/,
float /*y*/,
PixelSampler /*sampler*/)
virtual void execute_pixel_sampled(float /*output*/[4],
float /*x*/,
float /*y*/,
PixelSampler /*sampler*/)
{
}
@@ -727,12 +721,12 @@ class NodeOperation {
* \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.
* \param input_buffers: chunks that can be read by their ReadBufferOperation.
* \param chunk_data: chunk specific data a during execution time.
*/
virtual void executePixel(float output[4], int x, int y, void * /*chunkData*/)
virtual void execute_pixel(float output[4], int x, int y, void * /*chunk_data*/)
{
executePixelSampled(output, x, y, PixelSampler::Nearest);
execute_pixel_sampled(output, x, y, PixelSampler::Nearest);
}
/**
@@ -743,9 +737,9 @@ class NodeOperation {
* \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.
* \param input_buffers: chunks that can be read by their ReadBufferOperation.
*/
virtual void executePixelFiltered(
virtual void execute_pixel_filtered(
float /*output*/[4], float /*x*/, float /*y*/, float /*dx*/[2], float /*dy*/[2])
{
}