Removed parameter from executePixel and initializeTileData.
authorJeroen Bakker <j.bakker@atmind.nl>
Fri, 13 Jul 2012 12:24:42 +0000 (12:24 +0000)
committerJeroen Bakker <j.bakker@atmind.nl>
Fri, 13 Jul 2012 12:24:42 +0000 (12:24 +0000)
256 files changed:
source/blender/compositor/intern/COM_SingleThreadedNodeOperation.cpp
source/blender/compositor/intern/COM_SingleThreadedNodeOperation.h
source/blender/compositor/intern/COM_SocketReader.h
source/blender/compositor/operations/COM_AlphaOverKeyOperation.cpp
source/blender/compositor/operations/COM_AlphaOverKeyOperation.h
source/blender/compositor/operations/COM_AlphaOverMixedOperation.cpp
source/blender/compositor/operations/COM_AlphaOverMixedOperation.h
source/blender/compositor/operations/COM_AlphaOverPremultiplyOperation.cpp
source/blender/compositor/operations/COM_AlphaOverPremultiplyOperation.h
source/blender/compositor/operations/COM_AntiAliasOperation.cpp
source/blender/compositor/operations/COM_AntiAliasOperation.h
source/blender/compositor/operations/COM_BilateralBlurOperation.cpp
source/blender/compositor/operations/COM_BilateralBlurOperation.h
source/blender/compositor/operations/COM_BlurBaseOperation.cpp
source/blender/compositor/operations/COM_BlurBaseOperation.h
source/blender/compositor/operations/COM_BokehBlurOperation.cpp
source/blender/compositor/operations/COM_BokehBlurOperation.h
source/blender/compositor/operations/COM_BokehImageOperation.cpp
source/blender/compositor/operations/COM_BokehImageOperation.h
source/blender/compositor/operations/COM_BoxMaskOperation.cpp
source/blender/compositor/operations/COM_BoxMaskOperation.h
source/blender/compositor/operations/COM_BrightnessOperation.cpp
source/blender/compositor/operations/COM_BrightnessOperation.h
source/blender/compositor/operations/COM_CalculateMeanOperation.cpp
source/blender/compositor/operations/COM_CalculateMeanOperation.h
source/blender/compositor/operations/COM_CalculateStandardDeviationOperation.cpp
source/blender/compositor/operations/COM_CalculateStandardDeviationOperation.h
source/blender/compositor/operations/COM_ChangeHSVOperation.cpp
source/blender/compositor/operations/COM_ChangeHSVOperation.h
source/blender/compositor/operations/COM_ChannelMatteOperation.cpp
source/blender/compositor/operations/COM_ChannelMatteOperation.h
source/blender/compositor/operations/COM_ChromaMatteOperation.cpp
source/blender/compositor/operations/COM_ChromaMatteOperation.h
source/blender/compositor/operations/COM_ColorBalanceASCCDLOperation.cpp
source/blender/compositor/operations/COM_ColorBalanceASCCDLOperation.h
source/blender/compositor/operations/COM_ColorBalanceLGGOperation.cpp
source/blender/compositor/operations/COM_ColorBalanceLGGOperation.h
source/blender/compositor/operations/COM_ColorCorrectionOperation.cpp
source/blender/compositor/operations/COM_ColorCorrectionOperation.h
source/blender/compositor/operations/COM_ColorCurveOperation.cpp
source/blender/compositor/operations/COM_ColorCurveOperation.h
source/blender/compositor/operations/COM_ColorMatteOperation.cpp
source/blender/compositor/operations/COM_ColorMatteOperation.h
source/blender/compositor/operations/COM_ColorRampOperation.cpp
source/blender/compositor/operations/COM_ColorRampOperation.h
source/blender/compositor/operations/COM_ColorSpillOperation.cpp
source/blender/compositor/operations/COM_ColorSpillOperation.h
source/blender/compositor/operations/COM_CombineChannelsOperation.cpp
source/blender/compositor/operations/COM_CombineChannelsOperation.h
source/blender/compositor/operations/COM_CompositorOperation.cpp
source/blender/compositor/operations/COM_ConvertColorProfileOperation.cpp
source/blender/compositor/operations/COM_ConvertColorProfileOperation.h
source/blender/compositor/operations/COM_ConvertColorToBWOperation.cpp
source/blender/compositor/operations/COM_ConvertColorToBWOperation.h
source/blender/compositor/operations/COM_ConvertColorToValueProg.cpp
source/blender/compositor/operations/COM_ConvertColorToValueProg.h
source/blender/compositor/operations/COM_ConvertColorToVectorOperation.cpp
source/blender/compositor/operations/COM_ConvertColorToVectorOperation.h
source/blender/compositor/operations/COM_ConvertDepthToRadiusOperation.cpp
source/blender/compositor/operations/COM_ConvertDepthToRadiusOperation.h
source/blender/compositor/operations/COM_ConvertHSVToRGBOperation.cpp
source/blender/compositor/operations/COM_ConvertHSVToRGBOperation.h
source/blender/compositor/operations/COM_ConvertKeyToPremulOperation.cpp
source/blender/compositor/operations/COM_ConvertKeyToPremulOperation.h
source/blender/compositor/operations/COM_ConvertPremulToKeyOperation.cpp
source/blender/compositor/operations/COM_ConvertPremulToKeyOperation.h
source/blender/compositor/operations/COM_ConvertRGBToHSVOperation.cpp
source/blender/compositor/operations/COM_ConvertRGBToHSVOperation.h
source/blender/compositor/operations/COM_ConvertRGBToYCCOperation.cpp
source/blender/compositor/operations/COM_ConvertRGBToYCCOperation.h
source/blender/compositor/operations/COM_ConvertRGBToYUVOperation.cpp
source/blender/compositor/operations/COM_ConvertRGBToYUVOperation.h
source/blender/compositor/operations/COM_ConvertValueToColorProg.cpp
source/blender/compositor/operations/COM_ConvertValueToColorProg.h
source/blender/compositor/operations/COM_ConvertValueToVectorOperation.cpp
source/blender/compositor/operations/COM_ConvertValueToVectorOperation.h
source/blender/compositor/operations/COM_ConvertVectorToColorOperation.cpp
source/blender/compositor/operations/COM_ConvertVectorToColorOperation.h
source/blender/compositor/operations/COM_ConvertVectorToValueOperation.cpp
source/blender/compositor/operations/COM_ConvertVectorToValueOperation.h
source/blender/compositor/operations/COM_ConvertYCCToRGBOperation.cpp
source/blender/compositor/operations/COM_ConvertYCCToRGBOperation.h
source/blender/compositor/operations/COM_ConvertYUVToRGBOperation.cpp
source/blender/compositor/operations/COM_ConvertYUVToRGBOperation.h
source/blender/compositor/operations/COM_ConvolutionEdgeFilterOperation.cpp
source/blender/compositor/operations/COM_ConvolutionEdgeFilterOperation.h
source/blender/compositor/operations/COM_ConvolutionFilterOperation.cpp
source/blender/compositor/operations/COM_ConvolutionFilterOperation.h
source/blender/compositor/operations/COM_CropOperation.cpp
source/blender/compositor/operations/COM_CropOperation.h
source/blender/compositor/operations/COM_DifferenceMatteOperation.cpp
source/blender/compositor/operations/COM_DifferenceMatteOperation.h
source/blender/compositor/operations/COM_DilateErodeOperation.cpp
source/blender/compositor/operations/COM_DilateErodeOperation.h
source/blender/compositor/operations/COM_DirectionalBlurOperation.cpp
source/blender/compositor/operations/COM_DirectionalBlurOperation.h
source/blender/compositor/operations/COM_DisplaceOperation.cpp
source/blender/compositor/operations/COM_DisplaceOperation.h
source/blender/compositor/operations/COM_DisplaceSimpleOperation.cpp
source/blender/compositor/operations/COM_DisplaceSimpleOperation.h
source/blender/compositor/operations/COM_DistanceMatteOperation.cpp
source/blender/compositor/operations/COM_DistanceMatteOperation.h
source/blender/compositor/operations/COM_DotproductOperation.cpp
source/blender/compositor/operations/COM_DotproductOperation.h
source/blender/compositor/operations/COM_DoubleEdgeMaskOperation.cpp
source/blender/compositor/operations/COM_DoubleEdgeMaskOperation.h
source/blender/compositor/operations/COM_EllipseMaskOperation.cpp
source/blender/compositor/operations/COM_EllipseMaskOperation.h
source/blender/compositor/operations/COM_FastGaussianBlurOperation.cpp
source/blender/compositor/operations/COM_FastGaussianBlurOperation.h
source/blender/compositor/operations/COM_FlipOperation.cpp
source/blender/compositor/operations/COM_FlipOperation.h
source/blender/compositor/operations/COM_GammaCorrectOperation.cpp
source/blender/compositor/operations/COM_GammaCorrectOperation.h
source/blender/compositor/operations/COM_GammaOperation.cpp
source/blender/compositor/operations/COM_GammaOperation.h
source/blender/compositor/operations/COM_GaussianAlphaXBlurOperation.cpp
source/blender/compositor/operations/COM_GaussianAlphaXBlurOperation.h
source/blender/compositor/operations/COM_GaussianAlphaYBlurOperation.cpp
source/blender/compositor/operations/COM_GaussianAlphaYBlurOperation.h
source/blender/compositor/operations/COM_GaussianBokehBlurOperation.cpp
source/blender/compositor/operations/COM_GaussianBokehBlurOperation.h
source/blender/compositor/operations/COM_GaussianXBlurOperation.cpp
source/blender/compositor/operations/COM_GaussianXBlurOperation.h
source/blender/compositor/operations/COM_GaussianYBlurOperation.cpp
source/blender/compositor/operations/COM_GaussianYBlurOperation.h
source/blender/compositor/operations/COM_GlareBaseOperation.cpp
source/blender/compositor/operations/COM_GlareBaseOperation.h
source/blender/compositor/operations/COM_GlareThresholdOperation.cpp
source/blender/compositor/operations/COM_GlareThresholdOperation.h
source/blender/compositor/operations/COM_HueSaturationValueCorrectOperation.cpp
source/blender/compositor/operations/COM_HueSaturationValueCorrectOperation.h
source/blender/compositor/operations/COM_IDMaskOperation.cpp
source/blender/compositor/operations/COM_IDMaskOperation.h
source/blender/compositor/operations/COM_ImageOperation.cpp
source/blender/compositor/operations/COM_ImageOperation.h
source/blender/compositor/operations/COM_InvertOperation.cpp
source/blender/compositor/operations/COM_InvertOperation.h
source/blender/compositor/operations/COM_KeyingBlurOperation.cpp
source/blender/compositor/operations/COM_KeyingBlurOperation.h
source/blender/compositor/operations/COM_KeyingClipOperation.cpp
source/blender/compositor/operations/COM_KeyingClipOperation.h
source/blender/compositor/operations/COM_KeyingDespillOperation.cpp
source/blender/compositor/operations/COM_KeyingDespillOperation.h
source/blender/compositor/operations/COM_KeyingOperation.cpp
source/blender/compositor/operations/COM_KeyingOperation.h
source/blender/compositor/operations/COM_KeyingScreenOperation.cpp
source/blender/compositor/operations/COM_KeyingScreenOperation.h
source/blender/compositor/operations/COM_LuminanceMatteOperation.cpp
source/blender/compositor/operations/COM_LuminanceMatteOperation.h
source/blender/compositor/operations/COM_MapUVOperation.cpp
source/blender/compositor/operations/COM_MapUVOperation.h
source/blender/compositor/operations/COM_MapValueOperation.cpp
source/blender/compositor/operations/COM_MapValueOperation.h
source/blender/compositor/operations/COM_MaskOperation.cpp
source/blender/compositor/operations/COM_MaskOperation.h
source/blender/compositor/operations/COM_MathBaseOperation.cpp
source/blender/compositor/operations/COM_MathBaseOperation.h
source/blender/compositor/operations/COM_MixAddOperation.cpp
source/blender/compositor/operations/COM_MixAddOperation.h
source/blender/compositor/operations/COM_MixBaseOperation.cpp
source/blender/compositor/operations/COM_MixBaseOperation.h
source/blender/compositor/operations/COM_MixBlendOperation.cpp
source/blender/compositor/operations/COM_MixBlendOperation.h
source/blender/compositor/operations/COM_MixBurnOperation.cpp
source/blender/compositor/operations/COM_MixBurnOperation.h
source/blender/compositor/operations/COM_MixColorOperation.cpp
source/blender/compositor/operations/COM_MixColorOperation.h
source/blender/compositor/operations/COM_MixDarkenOperation.cpp
source/blender/compositor/operations/COM_MixDarkenOperation.h
source/blender/compositor/operations/COM_MixDifferenceOperation.cpp
source/blender/compositor/operations/COM_MixDifferenceOperation.h
source/blender/compositor/operations/COM_MixDivideOperation.cpp
source/blender/compositor/operations/COM_MixDivideOperation.h
source/blender/compositor/operations/COM_MixDodgeOperation.cpp
source/blender/compositor/operations/COM_MixDodgeOperation.h
source/blender/compositor/operations/COM_MixGlareOperation.cpp
source/blender/compositor/operations/COM_MixGlareOperation.h
source/blender/compositor/operations/COM_MixHueOperation.cpp
source/blender/compositor/operations/COM_MixHueOperation.h
source/blender/compositor/operations/COM_MixLightenOperation.cpp
source/blender/compositor/operations/COM_MixLightenOperation.h
source/blender/compositor/operations/COM_MixLinearLightOperation.cpp
source/blender/compositor/operations/COM_MixLinearLightOperation.h
source/blender/compositor/operations/COM_MixMultiplyOperation.cpp
source/blender/compositor/operations/COM_MixMultiplyOperation.h
source/blender/compositor/operations/COM_MixOverlayOperation.cpp
source/blender/compositor/operations/COM_MixOverlayOperation.h
source/blender/compositor/operations/COM_MixSaturationOperation.cpp
source/blender/compositor/operations/COM_MixSaturationOperation.h
source/blender/compositor/operations/COM_MixScreenOperation.cpp
source/blender/compositor/operations/COM_MixScreenOperation.h
source/blender/compositor/operations/COM_MixSoftLightOperation.cpp
source/blender/compositor/operations/COM_MixSoftLightOperation.h
source/blender/compositor/operations/COM_MixSubtractOperation.cpp
source/blender/compositor/operations/COM_MixSubtractOperation.h
source/blender/compositor/operations/COM_MixValueOperation.cpp
source/blender/compositor/operations/COM_MixValueOperation.h
source/blender/compositor/operations/COM_MovieClipAttributeOperation.cpp
source/blender/compositor/operations/COM_MovieClipAttributeOperation.h
source/blender/compositor/operations/COM_MovieClipOperation.cpp
source/blender/compositor/operations/COM_MovieClipOperation.h
source/blender/compositor/operations/COM_MovieDistortionOperation.cpp
source/blender/compositor/operations/COM_MovieDistortionOperation.h
source/blender/compositor/operations/COM_MultilayerImageOperation.cpp
source/blender/compositor/operations/COM_MultilayerImageOperation.h
source/blender/compositor/operations/COM_NormalizeOperation.cpp
source/blender/compositor/operations/COM_NormalizeOperation.h
source/blender/compositor/operations/COM_OutputFileOperation.cpp
source/blender/compositor/operations/COM_PreviewOperation.cpp
source/blender/compositor/operations/COM_ProjectorLensDistortionOperation.cpp
source/blender/compositor/operations/COM_ProjectorLensDistortionOperation.h
source/blender/compositor/operations/COM_ReadBufferOperation.cpp
source/blender/compositor/operations/COM_ReadBufferOperation.h
source/blender/compositor/operations/COM_RenderLayersAlphaProg.cpp
source/blender/compositor/operations/COM_RenderLayersAlphaProg.h
source/blender/compositor/operations/COM_RenderLayersBaseProg.cpp
source/blender/compositor/operations/COM_RenderLayersBaseProg.h
source/blender/compositor/operations/COM_RotateOperation.cpp
source/blender/compositor/operations/COM_RotateOperation.h
source/blender/compositor/operations/COM_ScaleOperation.cpp
source/blender/compositor/operations/COM_ScaleOperation.h
source/blender/compositor/operations/COM_ScreenLensDistortionOperation.cpp
source/blender/compositor/operations/COM_ScreenLensDistortionOperation.h
source/blender/compositor/operations/COM_SeparateChannelOperation.cpp
source/blender/compositor/operations/COM_SeparateChannelOperation.h
source/blender/compositor/operations/COM_SetAlphaOperation.cpp
source/blender/compositor/operations/COM_SetAlphaOperation.h
source/blender/compositor/operations/COM_SetColorOperation.cpp
source/blender/compositor/operations/COM_SetColorOperation.h
source/blender/compositor/operations/COM_SetSamplerOperation.cpp
source/blender/compositor/operations/COM_SetSamplerOperation.h
source/blender/compositor/operations/COM_SetValueOperation.cpp
source/blender/compositor/operations/COM_SetValueOperation.h
source/blender/compositor/operations/COM_SetVectorOperation.cpp
source/blender/compositor/operations/COM_SetVectorOperation.h
source/blender/compositor/operations/COM_SocketProxyOperation.cpp
source/blender/compositor/operations/COM_SocketProxyOperation.h
source/blender/compositor/operations/COM_SplitViewerOperation.cpp
source/blender/compositor/operations/COM_TextureOperation.cpp
source/blender/compositor/operations/COM_TextureOperation.h
source/blender/compositor/operations/COM_TonemapOperation.cpp
source/blender/compositor/operations/COM_TonemapOperation.h
source/blender/compositor/operations/COM_TranslateOperation.cpp
source/blender/compositor/operations/COM_TranslateOperation.h
source/blender/compositor/operations/COM_VariableSizeBokehBlurOperation.cpp
source/blender/compositor/operations/COM_VariableSizeBokehBlurOperation.h
source/blender/compositor/operations/COM_VectorBlurOperation.cpp
source/blender/compositor/operations/COM_VectorBlurOperation.h
source/blender/compositor/operations/COM_VectorCurveOperation.cpp
source/blender/compositor/operations/COM_VectorCurveOperation.h
source/blender/compositor/operations/COM_ViewerOperation.cpp
source/blender/compositor/operations/COM_WriteBufferOperation.cpp
source/blender/compositor/operations/COM_WriteBufferOperation.h
source/blender/compositor/operations/COM_ZCombineOperation.cpp
source/blender/compositor/operations/COM_ZCombineOperation.h

index 0496974c64ff45f6d07b3a70e24803b32a0ff13c..d14b8c48c89b2e602222d5dfe04741f61bfad7b2 100644 (file)
@@ -33,7 +33,7 @@ void SingleThreadedNodeOperation::initExecution()
        initMutex();
 }
 
-void SingleThreadedNodeOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void SingleThreadedNodeOperation::executePixel(float *color, int x, int y, void *data)
 {
        this->m_cachedInstance->readNoCheck(color, x, y);
 }
@@ -46,14 +46,14 @@ void SingleThreadedNodeOperation::deinitExecution()
                this->m_cachedInstance = NULL;
        }
 }
-void *SingleThreadedNodeOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
+void *SingleThreadedNodeOperation::initializeTileData(rcti *rect)
 {
        if (this->m_cachedInstance) return this->m_cachedInstance;
        
        lockMutex();
        if (this->m_cachedInstance == NULL) {
                //
-               this->m_cachedInstance = createMemoryBuffer(rect, memoryBuffers);
+               this->m_cachedInstance = createMemoryBuffer(rect);
        }
        unlockMutex();
        return this->m_cachedInstance;
index c6db5381f487022dfc5db193ec66bcbaae259161..68951eab5070f857e8550eb5b718386b5aac4419 100644 (file)
@@ -39,7 +39,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, int x, int y, MemoryBuffer * inputBuffers[], void *data);
+       void executePixel(float *color, int x, int y, void *data);
        
        /**
         * Initialize the execution
@@ -51,9 +51,9 @@ public:
         */
        void deinitExecution();
 
-       void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers);
+       void *initializeTileData(rcti *rect);
 
-       virtual MemoryBuffer *createMemoryBuffer(rcti *rect, MemoryBuffer **memoryBuffers) = 0;
+       virtual MemoryBuffer *createMemoryBuffer(rcti *rect) = 0;
        
        int isSingleThreaded() { return true; }
 };
index 0f35fcfb0dfe329d9040cd3788e7a10138f5d96e..736dd2fc8b6befe602e10f878779c70f9c089a02 100644 (file)
@@ -63,7 +63,7 @@ protected:
         * @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 executePixel(float *result, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) {}
+       virtual void executePixel(float *result, float x, float y, PixelSampler sampler) {}
 
        /**
         * @brief calculate a single pixel
@@ -74,8 +74,8 @@ protected:
         * @param inputBuffers chunks that can be read by their ReadBufferOperation.
         * @param chunkData chunk specific data a during execution time.
         */
-       virtual void executePixel(float *result, int x, int y, MemoryBuffer *inputBuffers[], void *chunkData) {
-               executePixel(result, x, y, COM_PS_NEAREST, inputBuffers);
+       virtual void executePixel(float *result, int x, int y, void *chunkData) {
+               executePixel(result, x, y, COM_PS_NEAREST);
        }
 
        /**
@@ -88,21 +88,21 @@ protected:
         * @param dy
         * @param inputBuffers chunks that can be read by their ReadBufferOperation.
         */
-       virtual void executePixel(float *result, float x, float y, float dx, float dy, MemoryBuffer *inputBuffers[]) {}
+       virtual void executePixel(float *result, float x, float y, float dx, float dy) {}
 
 public:
-       inline void read(float *result, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]) {
-               executePixel(result, x, y, sampler, inputBuffers);
+       inline void read(float *result, float x, float y, PixelSampler sampler) {
+               executePixel(result, x, y, sampler);
        }
-       inline void read(float *result, int x, int y, MemoryBuffer *inputBuffers[], void *chunkData) {
-               executePixel(result, x, y, inputBuffers, chunkData);
+       inline void read(float *result, int x, int y, void *chunkData) {
+               executePixel(result, x, y, chunkData);
        }
-       inline void read(float *result, float x, float y, float dx, float dy, MemoryBuffer *inputBuffers[]) {
-               executePixel(result, x, y, dx, dy, inputBuffers);
+       inline void read(float *result, float x, float y, float dx, float dy) {
+               executePixel(result, x, y, dx, dy);
        }
 
-       virtual void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers) { return 0; }
-       virtual void deinitializeTileData(rcti *rect, MemoryBuffer **memoryBuffers, void *data) {
+       virtual void *initializeTileData(rcti *rect) { return 0; }
+       virtual void deinitializeTileData(rcti *rect, void *data) {
        }
        
        virtual MemoryBuffer *getInputMemoryBuffer(MemoryBuffer **memoryBuffers) { return 0; }
index e688332a039726c1cc52fd3eb81a2825c9c718c2..406a98f81e9be1cededb24ae3d40785267249e01 100644 (file)
@@ -27,15 +27,15 @@ AlphaOverKeyOperation::AlphaOverKeyOperation() : MixBaseOperation()
        /* pass */
 }
 
-void AlphaOverKeyOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void AlphaOverKeyOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
        float inputColor1[4];
        float inputOverColor[4];
        float value[4];
        
-       this->m_inputValueOperation->read(value, x, y, sampler, inputBuffers);
-       this->m_inputColor1Operation->read(inputColor1, x, y, sampler, inputBuffers);
-       this->m_inputColor2Operation->read(inputOverColor, x, y, sampler, inputBuffers);
+       this->m_inputValueOperation->read(value, x, y, sampler);
+       this->m_inputColor1Operation->read(inputColor1, x, y, sampler);
+       this->m_inputColor2Operation->read(inputOverColor, x, y, sampler);
        
        if (inputOverColor[3] <= 0.0f) {
                copy_v4_v4(outputValue, inputColor1);
index 113ec245ee600768ada9afb0019d2aa6b791ba46..5f430efb98e717834102e5989aa74c68dc886f5f 100644 (file)
@@ -39,6 +39,6 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
 };
 #endif
index e56fb9151f2880d4432c68b335fffee6864856b5..b94486b5b4f06a2719a33b53ae54170c984959fc 100644 (file)
@@ -27,15 +27,15 @@ AlphaOverMixedOperation::AlphaOverMixedOperation() : MixBaseOperation()
        this->m_x = 0.0f;
 }
 
-void AlphaOverMixedOperation::executePixel(float outputValue[4], float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void AlphaOverMixedOperation::executePixel(float outputValue[4], float x, float y, PixelSampler sampler)
 {
        float inputColor1[4];
        float inputOverColor[4];
        float value[4];
        
-       this->m_inputValueOperation->read(value, x, y, sampler, inputBuffers);
-       this->m_inputColor1Operation->read(inputColor1, x, y, sampler, inputBuffers);
-       this->m_inputColor2Operation->read(inputOverColor, x, y, sampler, inputBuffers);
+       this->m_inputValueOperation->read(value, x, y, sampler);
+       this->m_inputColor1Operation->read(inputColor1, x, y, sampler);
+       this->m_inputColor2Operation->read(inputOverColor, x, y, sampler);
        
        if (inputOverColor[3] <= 0.0f) {
                copy_v4_v4(outputValue, inputColor1);
index 3c0b955e36078533b94ce141e5a31fab0f35fa6a..308f139884d67639fe90a41a8ace8a692cd6a301 100644 (file)
@@ -41,7 +41,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
        
        void setX(float x) { this->m_x = x; }
 };
index b2c40a058baa4d9006e26819063795363cdaa101..dad43f3b1792cea7e813ce6fdbd54378b97127ee 100644 (file)
@@ -27,15 +27,15 @@ AlphaOverPremultiplyOperation::AlphaOverPremultiplyOperation() : MixBaseOperatio
        /* pass */
 }
 
-void AlphaOverPremultiplyOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void AlphaOverPremultiplyOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
        float inputColor1[4];
        float inputOverColor[4];
        float value[4];
        
-       this->m_inputValueOperation->read(value, x, y, sampler, inputBuffers);
-       this->m_inputColor1Operation->read(inputColor1, x, y, sampler, inputBuffers);
-       this->m_inputColor2Operation->read(inputOverColor, x, y, sampler, inputBuffers);
+       this->m_inputValueOperation->read(value, x, y, sampler);
+       this->m_inputColor1Operation->read(inputColor1, x, y, sampler);
+       this->m_inputColor2Operation->read(inputOverColor, x, y, sampler);
        
        /* Zero alpha values should still permit an add of RGB data */
        if (inputOverColor[3] < 0.0f) {
index 7b7b9238794ce2358e9e9c53a645777cc5162931..37ddc6dcda5db3aa2757de81303043a50693a519 100644 (file)
@@ -39,7 +39,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
 
 };
 #endif
index 46fa07893e89738a49c6345f6ebe387ebb9f681c..27ba2ef51f62b1466d83cefa1f247649f3fa8265 100644 (file)
@@ -42,7 +42,7 @@ void AntiAliasOperation::initExecution()
        NodeOperation::initMutex();
 }
 
-void AntiAliasOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void AntiAliasOperation::executePixel(float *color, int x, int y, void *data)
 {
        if (y < 0 || (unsigned int)y >= this->m_height || x < 0 || (unsigned int)x >= this->m_width) {
                color[0] = 0.0f;
@@ -82,12 +82,12 @@ bool AntiAliasOperation::determineDependingAreaOfInterest(rcti *input, ReadBuffe
        return false;
 }
 
-void *AntiAliasOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
+void *AntiAliasOperation::initializeTileData(rcti *rect)
 {
        if (this->m_buffer) { return this->m_buffer; }
        lockMutex();
        if (this->m_buffer == NULL) {
-               MemoryBuffer *tile = (MemoryBuffer *)this->m_valueReader->initializeTileData(rect, memoryBuffers);
+               MemoryBuffer *tile = (MemoryBuffer *)this->m_valueReader->initializeTileData(rect);
                int size = tile->getHeight() * tile->getWidth();
                float *input = tile->getBuffer();
                char *valuebuffer = new char[size];
index 3d9bcf6d90a87d9b31b01bac9ce4a5bb50ae6fcd..7489d2e393a74ee2396bc773b2e5d901ad4ff0e1 100644 (file)
@@ -43,14 +43,14 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, int x, int y, MemoryBuffer * inputBuffers[], void *data);
+       void executePixel(float *color, int x, int y, void *data);
        
        /**
         * Initialize the execution
         */
        void initExecution();
        
-       void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers);
+       void *initializeTileData(rcti *rect);
        
        /**
         * Deinitialize the execution
index 4f7f5eea8a0a3e4cfddf04367ae286c9bd51a5df..1db3ecb2db85638f96cf9ed5fd0afd6ef4e19e73 100644 (file)
@@ -46,7 +46,7 @@ void BilateralBlurOperation::initExecution()
        QualityStepHelper::initExecution(COM_QH_INCREASE);
 }
 
-void BilateralBlurOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void BilateralBlurOperation::executePixel(float *color, int x, int y, void *data)
 {
        // read the determinator color at x, y, this will be used as the reference color for the determinator
        float determinatorReferenceColor[4];
@@ -61,20 +61,20 @@ void BilateralBlurOperation::executePixel(float *color, int x, int y, MemoryBuff
        int miny = floor(y - space);
        int maxy = ceil(y + space);
        float deltaColor;
-       this->m_inputDeterminatorProgram->read(determinatorReferenceColor, x, y, inputBuffers, data);
+       this->m_inputDeterminatorProgram->read(determinatorReferenceColor, x, y, data);
 
        zero_v4(blurColor);
        blurDivider = 0.0f;
        for (int yi = miny; yi < maxy; yi += QualityStepHelper::getStep()) {
                for (int xi = minx; xi < maxx; xi += QualityStepHelper::getStep()) {
                        // read determinator
-                       this->m_inputDeterminatorProgram->read(determinator, xi, yi, inputBuffers, data);
+                       this->m_inputDeterminatorProgram->read(determinator, xi, yi, data);
                        deltaColor = (fabsf(determinatorReferenceColor[0] - determinator[0]) +
                                      fabsf(determinatorReferenceColor[1] - determinator[1]) +
                                      fabsf(determinatorReferenceColor[2] - determinator[2])); // do not take the alpha channel into account
                        if (deltaColor < sigmacolor) {
                                // add this to the blur
-                               this->m_inputColorProgram->read(tempColor, xi, yi, inputBuffers, data);
+                               this->m_inputColorProgram->read(tempColor, xi, yi, data);
                                add_v4_v4(blurColor, tempColor);
                                blurDivider += 1.0f;
                        }
index be6ce7a221e888b15a7d19891b03b7e27433e8aa..c1b5f764f0198ac4815289fe83f54a24cff3df61 100644 (file)
@@ -38,7 +38,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, int x, int y, MemoryBuffer * inputBuffers[], void *data);
+       void executePixel(float *color, int x, int y, void *data);
        
        /**
         * Initialize the execution
index 696c0748d69122087a7bef8357c38d62c851940f..98aeba41ecbe304bee46889f1777eb57f995d0f6 100644 (file)
@@ -140,11 +140,11 @@ void BlurBaseOperation::deinitExecution()
        this->m_data = NULL;
 }
 
-void BlurBaseOperation::updateSize(MemoryBuffer **memoryBuffers)
+void BlurBaseOperation::updateSize()
 {
        if (!this->m_sizeavailable) {
                float result[4];
-               this->getInputSocketReader(1)->read(result, 0, 0, COM_PS_NEAREST, memoryBuffers);
+               this->getInputSocketReader(1)->read(result, 0, 0, COM_PS_NEAREST);
                this->m_size = result[0];
                this->m_sizeavailable = true;
        }
index 6d60abf09bffc0b059d1e3b4cb6189ddeda31424..d8729ad4394a63002b8aeab56d046655395e0969 100644 (file)
@@ -34,7 +34,7 @@ protected:
        float *make_gausstab(int rad);
        float *make_dist_fac_inverse(int rad, int falloff);
 
-       void updateSize(MemoryBuffer **memoryBuffers);
+       void updateSize();
 
        /**
         * Cached reference to the inputProgram
index a0cc8df826a816fb145c6311d75849096eecef55..ff9bfb73396ae4b532014b51614eaac09701dae9 100644 (file)
@@ -45,13 +45,13 @@ BokehBlurOperation::BokehBlurOperation() : NodeOperation()
        this->m_inputBoundingBoxReader = NULL;
 }
 
-void *BokehBlurOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
+void *BokehBlurOperation::initializeTileData(rcti *rect)
 {
        lockMutex();
        if (!this->m_sizeavailable) {
-               updateSize(memoryBuffers);
+               updateSize();
        }
-       void *buffer = getInputOperation(0)->initializeTileData(NULL, memoryBuffers);
+       void *buffer = getInputOperation(0)->initializeTileData(NULL);
        unlockMutex();
        return buffer;
 }
@@ -79,13 +79,13 @@ void BokehBlurOperation::initExecution()
        QualityStepHelper::initExecution(COM_QH_INCREASE);
 }
 
-void BokehBlurOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void BokehBlurOperation::executePixel(float *color, int x, int y, void *data)
 {
        float color_accum[4];
        float tempBoundingBox[4];
        float bokeh[4];
 
-       this->m_inputBoundingBoxReader->read(tempBoundingBox, x, y, COM_PS_NEAREST, inputBuffers);
+       this->m_inputBoundingBoxReader->read(tempBoundingBox, x, y, COM_PS_NEAREST);
        if (tempBoundingBox[0] > 0.0f) {
                float multiplier_accum[4] = {0.0f, 0.0f, 0.0f, 0.0f};
                MemoryBuffer *inputBuffer = (MemoryBuffer *)data;
@@ -95,7 +95,7 @@ void BokehBlurOperation::executePixel(float *color, int x, int y, MemoryBuffer *
                int bufferstarty = inputBuffer->getRect()->ymin;
                int pixelSize = this->m_size * this->getWidth() / 100.0f;
                if (pixelSize==0){
-                       this->m_inputProgram->read(color, x, y, COM_PS_NEAREST, inputBuffers);
+                       this->m_inputProgram->read(color, x, y, COM_PS_NEAREST);
                        return;
                }
                int miny = y - pixelSize;
@@ -118,7 +118,7 @@ void BokehBlurOperation::executePixel(float *color, int x, int y, MemoryBuffer *
                        for (int nx = minx; nx < maxx; nx += step) {
                                float u = this->m_bokehMidX - (nx - x) * m;
                                float v = this->m_bokehMidY - (ny - y) * m;
-                               this->m_inputBokehProgram->read(bokeh, u, v, COM_PS_NEAREST, inputBuffers);
+                               this->m_inputBokehProgram->read(bokeh, u, v, COM_PS_NEAREST);
                                madd_v4_v4v4(color_accum, bokeh, &buffer[bufferindex]);
                                add_v4_v4(multiplier_accum, bokeh);
                                bufferindex += offsetadd;
@@ -130,7 +130,7 @@ void BokehBlurOperation::executePixel(float *color, int x, int y, MemoryBuffer *
                color[3] = color_accum[3] * (1.0f / multiplier_accum[3]);
        }
        else {
-               this->m_inputProgram->read(color, x, y, COM_PS_NEAREST, inputBuffers);
+               this->m_inputProgram->read(color, x, y, COM_PS_NEAREST);
        }
 }
 
@@ -196,7 +196,7 @@ void BokehBlurOperation::executeOpenCL(OpenCLDevice* device,
 {
        cl_kernel kernel = device->COM_clCreateKernel("bokehBlurKernel", NULL);
        if (!this->m_sizeavailable) {
-               updateSize(inputMemoryBuffers);
+               updateSize();
        }
        cl_int radius = this->getWidth() * this->m_size / 100.0f;
        cl_int step = this->getStep();
@@ -213,11 +213,11 @@ void BokehBlurOperation::executeOpenCL(OpenCLDevice* device,
        device->COM_clEnqueueRange(kernel, outputMemoryBuffer, 9, this);
 }
 
-void BokehBlurOperation::updateSize(MemoryBuffer **memoryBuffers)
+void BokehBlurOperation::updateSize()
 {
        if (!this->m_sizeavailable) {
                float result[4];
-               this->getInputSocketReader(3)->read(result, 0, 0, COM_PS_NEAREST, memoryBuffers);
+               this->getInputSocketReader(3)->read(result, 0, 0, COM_PS_NEAREST);
                this->m_size = result[0];
                CLAMP(this->m_size, 0.0f, 10.0f);
                this->m_sizeavailable = true;
index 407118b17a5658d946f17df42b57eb52b757bf8b..eef5429c409960ebb7e8fd211c9318416313f5d8 100644 (file)
@@ -30,7 +30,7 @@ private:
        SocketReader *m_inputProgram;
        SocketReader *m_inputBokehProgram;
        SocketReader *m_inputBoundingBoxReader;
-       void updateSize(MemoryBuffer **memoryBuffers);
+       void updateSize();
        float m_size;
        bool m_sizeavailable;
        float m_bokehMidX;
@@ -39,11 +39,11 @@ private:
 public:
        BokehBlurOperation();
 
-       void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers);
+       void *initializeTileData(rcti *rect);
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, int x, int y, MemoryBuffer * inputBuffers[], void *data);
+       void executePixel(float *color, int x, int y, void *data);
        
        /**
         * Initialize the execution
index 90e272438d618c017f58e8e4efd5b8dec0c7931c..d7de201e9df5be6f3ca6979f0f08335e8de4c4b7 100644 (file)
@@ -87,7 +87,7 @@ float BokehImageOperation::isInsideBokeh(float distance, float x, float y)
        }
        return insideBokeh;
 }
-void BokehImageOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void BokehImageOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
        float shift = this->m_data->lensshift;
        float shift2 = shift / 2.0f;
index 085aaa471f008c74c35d89fd6da8a5443cd74a71..a797d0fca53a24df6714b8a7afd722b9df7d392c 100644 (file)
@@ -47,7 +47,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
        
        /**
         * Initialize the execution
index 96738a2920aaf491163b22bc3ec9e1dac913e38d..a0fb37f4310eaf940717705774cf7fec3be58df1 100644 (file)
@@ -44,7 +44,7 @@ void BoxMaskOperation::initExecution()
        this->m_aspectRatio = ((float)this->getWidth()) / this->getHeight();
 }
 
-void BoxMaskOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void BoxMaskOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
        float inputMask[4];
        float inputValue[4];
@@ -57,8 +57,8 @@ void BoxMaskOperation::executePixel(float *color, float x, float y, PixelSampler
        rx = this->m_data->x + (this->m_cosine * dx + this->m_sine * dy);
        ry = this->m_data->y + (-this->m_sine * dx + this->m_cosine * dy);
        
-       this->m_inputMask->read(inputMask, x, y, sampler, inputBuffers);
-       this->m_inputValue->read(inputValue, x, y, sampler, inputBuffers);
+       this->m_inputMask->read(inputMask, x, y, sampler);
+       this->m_inputValue->read(inputValue, x, y, sampler);
        
        float halfHeight = this->m_data->height / 2.0f;
        float halfWidth = this->m_data->width / 2.0f;
index cec680ef6c3202a325dbf59f78dab1fd04d78764..5a6745d9a9b8f0e818efe6e96e63c88a51593686 100644 (file)
@@ -45,7 +45,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
        
        /**
         * Initialize the execution
index 8c9fb6394a72e05a9a29ad69dc8d0bb0980cf6d7..9a6a930c7c9c4a820831b58054394f4daa2a91e8 100644 (file)
@@ -37,15 +37,15 @@ void BrightnessOperation::initExecution()
        this->m_inputContrastProgram = this->getInputSocketReader(2);
 }
 
-void BrightnessOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void BrightnessOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
        float inputValue[4];
        float a, b;
        float inputBrightness[4];
        float inputContrast[4];
-       this->m_inputProgram->read(inputValue, x, y, sampler, inputBuffers);
-       this->m_inputBrightnessProgram->read(inputBrightness, x, y, sampler, inputBuffers);
-       this->m_inputContrastProgram->read(inputContrast, x, y, sampler, inputBuffers);
+       this->m_inputProgram->read(inputValue, x, y, sampler);
+       this->m_inputBrightnessProgram->read(inputBrightness, x, y, sampler);
+       this->m_inputContrastProgram->read(inputContrast, x, y, sampler);
        float brightness = inputBrightness[0];
        float contrast = inputContrast[0];
        brightness /= 100.0f;
index 61f667aa1be174508fe0539df4d76654175f118e..2a6200ad9df8c40d5839716a006433d9fa4c0cac 100644 (file)
@@ -40,7 +40,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
        
        /**
         * Initialize the execution
index a1c679b3e154a2ef393495f972878795e80d6b9e..b0cfdb44736b85e09428ca19a8df1e18c4630110 100644 (file)
@@ -42,7 +42,7 @@ void CalculateMeanOperation::initExecution()
        NodeOperation::initMutex();
 }
 
-void CalculateMeanOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void CalculateMeanOperation::executePixel(float *color, int x, int y, void *data)
 {
        color[0] = this->m_result;
 }
@@ -70,11 +70,11 @@ bool CalculateMeanOperation::determineDependingAreaOfInterest(rcti *input, ReadB
        return false;
 }
 
-void *CalculateMeanOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
+void *CalculateMeanOperation::initializeTileData(rcti *rect)
 {
        lockMutex();
        if (!this->m_iscalculated) {
-               MemoryBuffer *tile = (MemoryBuffer *)this->m_imageReader->initializeTileData(rect, memoryBuffers);
+               MemoryBuffer *tile = (MemoryBuffer *)this->m_imageReader->initializeTileData(rect);
                calculateMean(tile);
                this->m_iscalculated = true;
        }
index 2bd723c40a350ecd1e8b73c7da918895506dd8eb..097275333060753446494a5a140de3ba5cf5ccb1 100644 (file)
@@ -46,14 +46,14 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, int x, int y, MemoryBuffer * inputBuffers[], void *data);
+       void executePixel(float *color, int x, int y, void *data);
        
        /**
         * Initialize the execution
         */
        void initExecution();
        
-       void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers);
+       void *initializeTileData(rcti *rect);
        
        /**
         * Deinitialize the execution
index 2d860df449c4071df32e2c11a5c352f64beb931f..de602ba1dd6d48d995b5d177c3c7be47e580171f 100644 (file)
@@ -31,16 +31,16 @@ CalculateStandardDeviationOperation::CalculateStandardDeviationOperation() : Cal
        /* pass */
 }
 
-void CalculateStandardDeviationOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void CalculateStandardDeviationOperation::executePixel(float *color, int x, int y, void *data)
 {
        color[0] = this->m_standardDeviation;
 }
 
-void *CalculateStandardDeviationOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
+void *CalculateStandardDeviationOperation::initializeTileData(rcti *rect)
 {
        lockMutex();
        if (!this->m_iscalculated) {
-               MemoryBuffer *tile = (MemoryBuffer *)this->m_imageReader->initializeTileData(rect, memoryBuffers);
+               MemoryBuffer *tile = (MemoryBuffer *)this->m_imageReader->initializeTileData(rect);
                CalculateMeanOperation::calculateMean(tile);
                this->m_standardDeviation = 0.0f;
                float *buffer = tile->getBuffer();
index 506c5d6fe3a77bc3faaa6586a1db562742579f44..311cedd7d32999dc74690a12110d1044bc21cca2 100644 (file)
@@ -39,9 +39,9 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, int x, int y, MemoryBuffer * inputBuffers[], void *data);
+       void executePixel(float *color, int x, int y, void *data);
 
-       void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers);
+       void *initializeTileData(rcti *rect);
 
 };
 #endif
index 0812dd45bf66202b63a873929f8ce297ca1afb80..7a6a22e5c051d21ac56627583fc5b5413b49f3fb 100644 (file)
@@ -39,11 +39,11 @@ void ChangeHSVOperation::deinitExecution()
        this->m_inputOperation = NULL;
 }
 
-void ChangeHSVOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ChangeHSVOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
        float inputColor1[4];
        
-       this->m_inputOperation->read(inputColor1, x, y, sampler, inputBuffers);
+       this->m_inputOperation->read(inputColor1, x, y, sampler);
        
        outputValue[0] = inputColor1[0] + (this->m_hue - 0.5f);
        if      (outputValue[0] > 1.0f) outputValue[0] -= 1.0f;
index ee35fbe01d4f8cb09f9b754237f96d074ba46ac7..e5660e44f7306db16a007d740e5b4a2199ca1c2f 100644 (file)
@@ -49,7 +49,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
 
        void setHue(float hue) { this->m_hue = hue; }
        void setSaturation(float saturation) { this->m_saturation = saturation; }
index b2de934e6d8f1815db89e0c76948829dcdcb069e..85f606fafdf1801b6e70c1b242ab9f6d67167cae 100644 (file)
@@ -83,7 +83,7 @@ void ChannelMatteOperation::deinitExecution()
        this->m_inputImageProgram = NULL;
 }
 
-void ChannelMatteOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ChannelMatteOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
        float inColor[4];
        float alpha;
@@ -92,7 +92,7 @@ void ChannelMatteOperation::executePixel(float *outputValue, float x, float y, P
        const float limit_min = this->m_limit_min;
        const float limit_range = this->m_limit_range;
 
-       this->m_inputImageProgram->read(inColor, x, y, sampler, inputBuffers);
+       this->m_inputImageProgram->read(inColor, x, y, sampler);
 
        /* matte operation */
        alpha = inColor[this->m_ids[0]] - max(inColor[this->m_ids[1]], inColor[this->m_ids[2]]);
index ee17036a78d5d0d07a640d13b5cbb379075732c6..a02d0618a4c7553146b17529b74e0d00573f77a9 100644 (file)
@@ -59,7 +59,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
 
        void initExecution();
        void deinitExecution();
index e88feb6db9c781d72af31a91a3844cc628f2fc9d..85a19d7c60fffc4dc8a451972e4fae8cf417dd7d 100644 (file)
@@ -44,7 +44,7 @@ void ChromaMatteOperation::deinitExecution()
        this->m_inputKeyProgram = NULL;
 }
 
-void ChromaMatteOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ChromaMatteOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
        float inKey[4];
        float inImage[4];
@@ -57,8 +57,8 @@ void ChromaMatteOperation::executePixel(float *outputValue, float x, float y, Pi
        float theta, beta;
        float kfg;
 
-       this->m_inputKeyProgram->read(inKey, x, y, sampler, inputBuffers);
-       this->m_inputImageProgram->read(inImage, x, y, sampler, inputBuffers);
+       this->m_inputKeyProgram->read(inKey, x, y, sampler);
+       this->m_inputImageProgram->read(inImage, x, y, sampler);
 
        /* store matte(alpha) value in [0] to go with
         * COM_SetAlphaOperation and the Value output
index eaca05e66ca99b1f889f9aa87b272298aeb49f46..37b58fa45ed380e840965f24351f0a91fd3f9b46 100644 (file)
@@ -42,7 +42,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
 
        void initExecution();
        void deinitExecution();
index 66ce86234b799d36068e3ff35880102a3507bcef..33e6db22ef4d86eb82a84f662e8da471eb50acba 100644 (file)
@@ -49,13 +49,13 @@ void ColorBalanceASCCDLOperation::initExecution()
        this->m_inputColorOperation = this->getInputSocketReader(1);
 }
 
-void ColorBalanceASCCDLOperation::executePixel(float *outputColor, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ColorBalanceASCCDLOperation::executePixel(float *outputColor, float x, float y, PixelSampler sampler)
 {
        float inputColor[4];
        float value[4];
        
-       this->m_inputValueOperation->read(value, x, y, sampler, inputBuffers);
-       this->m_inputColorOperation->read(inputColor, x, y, sampler, inputBuffers);
+       this->m_inputValueOperation->read(value, x, y, sampler);
+       this->m_inputColorOperation->read(inputColor, x, y, sampler);
        
        float fac = value[0];
        fac = min(1.0f, fac);
index a9c0dff9ad4e707b86b0c6a09b3de999363ad21a..d6361ea16ba24a56c1b773d5041aa9a9fbdb1d2a 100644 (file)
@@ -49,7 +49,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
        
        /**
         * Initialize the execution
index 13863a9ec5a083d991ccb40505e1ab05a857f659..b0691925361a8a94e844a101d9d454edb04fd0ac 100644 (file)
@@ -54,13 +54,13 @@ void ColorBalanceLGGOperation::initExecution()
        this->m_inputColorOperation = this->getInputSocketReader(1);
 }
 
-void ColorBalanceLGGOperation::executePixel(float *outputColor, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ColorBalanceLGGOperation::executePixel(float *outputColor, float x, float y, PixelSampler sampler)
 {
        float inputColor[4];
        float value[4];
        
-       this->m_inputValueOperation->read(value, x, y, sampler, inputBuffers);
-       this->m_inputColorOperation->read(inputColor, x, y, sampler, inputBuffers);
+       this->m_inputValueOperation->read(value, x, y, sampler);
+       this->m_inputColorOperation->read(inputColor, x, y, sampler);
        
        float fac = value[0];
        fac = min(1.0f, fac);
index ffc78fae6f155a8c59423aabf0e993879a2d8a5b..c3d44c53e5310a7a815cc17b4e186acff21d88ac 100644 (file)
@@ -50,7 +50,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
        
        /**
         * Initialize the execution
index 8008866752ff2bfacd89179f8bfbf4bc49050bc9..ebc818b0f7e48ca7ac9341f76124abdce53c8926 100644 (file)
@@ -40,12 +40,12 @@ void ColorCorrectionOperation::initExecution()
        this->m_inputMask = this->getInputSocketReader(1);
 }
 
-void ColorCorrectionOperation::executePixel(float *output, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ColorCorrectionOperation::executePixel(float *output, float x, float y, PixelSampler sampler)
 {
        float inputImageColor[4];
        float inputMask[4];
-       this->m_inputImage->read(inputImageColor, x, y, sampler, inputBuffers);
-       this->m_inputMask->read(inputMask, x, y, sampler, inputBuffers);
+       this->m_inputImage->read(inputImageColor, x, y, sampler);
+       this->m_inputMask->read(inputMask, x, y, sampler);
        
        float level = (inputImageColor[0] + inputImageColor[1] + inputImageColor[2]) / 3.0f;
        float contrast = this->m_data->master.contrast;
index 8db3870709e7e19bd91365bc474b10fc954327cf..685413741fa4abaa9f9d14068e9f0cb7f22f163a 100644 (file)
@@ -44,7 +44,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
        
        /**
         * Initialize the execution
index 9848d191c04c911782814582c490e21d3aff1537..88bd673a19fbf0f759168e062bfc986b95869687 100644 (file)
@@ -58,7 +58,7 @@ void ColorCurveOperation::initExecution()
 
 }
 
-void ColorCurveOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ColorCurveOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
        CurveMapping *cumap = this->m_curveMapping;
        CurveMapping *workingCopy = (CurveMapping *)MEM_dupallocN(cumap);
@@ -68,13 +68,13 @@ void ColorCurveOperation::executePixel(float *color, float x, float y, PixelSamp
        float fac[4];
        float image[4];
 
-       this->m_inputBlackProgram->read(black, x, y, sampler, inputBuffers);
-       this->m_inputWhiteProgram->read(white, x, y, sampler, inputBuffers);
+       this->m_inputBlackProgram->read(black, x, y, sampler);
+       this->m_inputWhiteProgram->read(white, x, y, sampler);
 
        curvemapping_set_black_white(workingCopy, black, white);
 
-       this->m_inputFacProgram->read(fac, x, y, sampler, inputBuffers);
-       this->m_inputImageProgram->read(image, x, y, sampler, inputBuffers);
+       this->m_inputFacProgram->read(fac, x, y, sampler);
+       this->m_inputImageProgram->read(image, x, y, sampler);
 
        if (*fac >= 1.0f)
                curvemapping_evaluate_premulRGBF(workingCopy, color, image);
@@ -126,14 +126,14 @@ void ConstantLevelColorCurveOperation::initExecution()
        curvemapping_set_black_white(this->m_curveMapping, this->m_black, this->m_white);
 }
 
-void ConstantLevelColorCurveOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ConstantLevelColorCurveOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
        float fac[4];
        float image[4];
 
 
-       this->m_inputFacProgram->read(fac, x, y, sampler, inputBuffers);
-       this->m_inputImageProgram->read(image, x, y, sampler, inputBuffers);
+       this->m_inputFacProgram->read(fac, x, y, sampler);
+       this->m_inputImageProgram->read(image, x, y, sampler);
 
        if (*fac >= 1.0f)
                curvemapping_evaluate_premulRGBF(this->m_curveMapping, color, image);
index 3bcbc31650cfe3fc184642b4c934bbe3b59aaa8f..beb2e16298a5e0667f9947eae32cbcb4127d98eb 100644 (file)
@@ -41,7 +41,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
        
        /**
         * Initialize the execution
@@ -70,7 +70,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
        
        /**
         * Initialize the execution
index 4a01499b0601c267416cec3cca21620bbacda71d..5326e397494aaa1df0a284a3cf99bce6c688a821 100644 (file)
@@ -44,7 +44,7 @@ void ColorMatteOperation::deinitExecution()
        this->m_inputKeyProgram = NULL;
 }
 
-void ColorMatteOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ColorMatteOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
        float inColor[4];
        float inKey[4];
@@ -55,8 +55,8 @@ void ColorMatteOperation::executePixel(float *outputValue, float x, float y, Pix
 
        float h_wrap;
 
-       this->m_inputImageProgram->read(inColor, x, y, sampler, inputBuffers);
-       this->m_inputKeyProgram->read(inKey, x, y, sampler, inputBuffers);
+       this->m_inputImageProgram->read(inColor, x, y, sampler);
+       this->m_inputKeyProgram->read(inKey, x, y, sampler);
 
 
        /* store matte(alpha) value in [0] to go with
index d996ce3466739ad3c5587d7c80618498344e8ad6..de7c4dd8ce2d8e26e19d4e3d8832ded8c8ab34fa 100644 (file)
@@ -42,7 +42,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
 
        void initExecution();
        void deinitExecution();
index 95dca0dc410200093dea171f28c9adb25ad14033..edd7df89c818e67f5e1a79f4331dd6249e04d8ab 100644 (file)
@@ -43,11 +43,11 @@ void ColorRampOperation::initExecution()
        this->m_inputProgram = this->getInputSocketReader(0);
 }
 
-void ColorRampOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ColorRampOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
        float values[4];
 
-       this->m_inputProgram->read(values, x, y, sampler, inputBuffers);
+       this->m_inputProgram->read(values, x, y, sampler);
        do_colorband(this->m_colorBand, values[0], color);
 }
 
index 42bc6b943b7f906e7fc8a5d4588f72056e1d8323..c5f3fe449debc691d1498cda13eeddeb915d68f5 100644 (file)
@@ -38,7 +38,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
        
        /**
         * Initialize the execution
index e2773f3a6b40bb1fae1446dc41d628424b35e617..2c0bfc10bb04229c2ec0f972d42d9c99b7f9abc3 100644 (file)
@@ -84,12 +84,12 @@ void ColorSpillOperation::deinitExecution()
        this->m_inputFacReader = NULL;
 }
 
-void ColorSpillOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ColorSpillOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
        float fac[4];
        float input[4];
-       this->m_inputFacReader->read(fac, x, y, sampler, inputBuffers);
-       this->m_inputImageReader->read(input, x, y, sampler, inputBuffers);
+       this->m_inputFacReader->read(fac, x, y, sampler);
+       this->m_inputImageReader->read(input, x, y, sampler);
        float rfac = min(1.0f, fac[0]);
        float map = calculateMapValue(rfac, input);
        if (map > 0.0f) {
index 7aac612cb8c4e9349a66663f8cbb3138446e99c4..ea443f2a5a1f796d265e8d068d176b057459f610 100644 (file)
@@ -46,7 +46,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
 
        void initExecution();
        void deinitExecution();
index 9f175a381a40b3f8727325dd2faf648b41ad0d8a..d05040c4c12747f5ee855c15928c706f0f986021 100644 (file)
@@ -78,24 +78,24 @@ void CombineChannelsOperation::deinitExecution()
 }
 
 
-void CombineChannelsOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void CombineChannelsOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
        float input[4];
        /// @todo: remove if statements
        if (this->m_inputChannel1Operation) {
-               this->m_inputChannel1Operation->read(input, x, y, sampler, inputBuffers);
+               this->m_inputChannel1Operation->read(input, x, y, sampler);
                color[0] = input[0];
        }
        if (this->m_inputChannel2Operation) {
-               this->m_inputChannel2Operation->read(input, x, y, sampler, inputBuffers);
+               this->m_inputChannel2Operation->read(input, x, y, sampler);
                color[1] = input[0];
        }
        if (this->m_inputChannel3Operation) {
-               this->m_inputChannel3Operation->read(input, x, y, sampler, inputBuffers);
+               this->m_inputChannel3Operation->read(input, x, y, sampler);
                color[2] = input[0];
        }
        if (this->m_inputChannel4Operation) {
-               this->m_inputChannel4Operation->read(input, x, y, sampler, inputBuffers);
+               this->m_inputChannel4Operation->read(input, x, y, sampler);
                color[3] = input[0];
        }
 }
index 8e4c2120614564a44cadf5b5e95dbdc601d7febf..ff1251a3949a7812c40600250cf78c6fd00b17cc 100644 (file)
@@ -33,7 +33,7 @@ private:
        SocketReader *m_inputChannel4Operation;
 public:
        CombineChannelsOperation();
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
        
        void initExecution();
        void deinitExecution();
index a58f77386ea2c79f8fd0fee7bbc91148a10bfb8b..445b0634ced485ae65f76c31d8cecd003df2d71b 100644 (file)
@@ -111,9 +111,9 @@ void CompositorOperation::executeRegion(rcti *rect, unsigned int tileNumber)
 
        for (y = y1; y < y2 && (!breaked); y++) {
                for (x = x1; x < x2 && (!breaked); x++) {
-                       this->m_imageInput->read(color, x, y, COM_PS_NEAREST, NULL);
+                       this->m_imageInput->read(color, x, y, COM_PS_NEAREST);
                        if (this->m_alphaInput != NULL) {
-                               this->m_alphaInput->read(&(color[3]), x, y, COM_PS_NEAREST, NULL);
+                               this->m_alphaInput->read(&(color[3]), x, y, COM_PS_NEAREST);
                        }
                        copy_v4_v4(buffer + offset, color);
                        offset += COM_NUMBER_OF_CHANNELS;
index 4d829eae7a0b5fdc931a1c0f7e565f2af84050cd..c7272d461d62c292bddc54377fddd560aaeadaf4 100644 (file)
@@ -38,10 +38,10 @@ void ConvertColorProfileOperation::initExecution()
        this->m_inputOperation = this->getInputSocketReader(0);
 }
 
-void ConvertColorProfileOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ConvertColorProfileOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
        float color[4];
-       this->m_inputOperation->read(color, x, y, sampler, inputBuffers);
+       this->m_inputOperation->read(color, x, y, sampler);
        IMB_buffer_float_from_float(outputValue, color, 4, this->m_toProfile, this->m_fromProfile, this->m_predivided, 1, 1, 0, 0);
 }
 
index b237448d16e0624786bb0b38162434e320bf55b1..09d96a92d95c279578e78b55ea0c3d9abd7a32fa 100644 (file)
@@ -59,7 +59,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
        
        /**
         * Initialize the execution
index a8c57449a2ea0d0007488f24b43c0a81a34fa16d..4da09a69a15bf9255e6e0f2f1cffb884b8929b18 100644 (file)
@@ -34,10 +34,10 @@ void ConvertColorToBWOperation::initExecution()
        this->m_inputOperation = this->getInputSocketReader(0);
 }
 
-void ConvertColorToBWOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ConvertColorToBWOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
        float inputColor[4];
-       this->m_inputOperation->read(&inputColor[0], x, y, sampler, inputBuffers);
+       this->m_inputOperation->read(&inputColor[0], x, y, sampler);
        outputValue[0] = rgb_to_bw(inputColor);
 }
 
index 9c62ad8dd39944da23406c1f7688a71691e854f6..a9951af2e3b207558f2c65da471ef11a3e088047 100644 (file)
@@ -44,7 +44,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
        
        /**
         * Initialize the execution
index c09842b1aa9a1251774e7847a8335f564f5cf2da..17bd34d51b019280db29db92f31ae444ac4712c2 100644 (file)
@@ -34,10 +34,10 @@ void ConvertColorToValueProg::initExecution()
        this->m_inputOperation = this->getInputSocketReader(0);
 }
 
-void ConvertColorToValueProg::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ConvertColorToValueProg::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
        float inputColor[4];
-       this->m_inputOperation->read(&inputColor[0], x, y, sampler, inputBuffers);
+       this->m_inputOperation->read(&inputColor[0], x, y, sampler);
        outputValue[0] = (inputColor[0] + inputColor[1] + inputColor[2]) / 3.0f;
 }
 
index c1ac7ca69ce745dc9382be1bb23f1d932c3c2fd5..6a20d4bf27afa740f3ca622f00d2798f210fc134 100644 (file)
@@ -44,7 +44,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
        
        /**
         * Initialize the execution
index 6c79c4ea6a3be30ac94e0d9aeb68457879da5f12..ec1f0fd37e4a423edc986da959d2a49a15619251 100644 (file)
@@ -34,9 +34,9 @@ void ConvertColorToVectorOperation::initExecution()
        this->m_inputOperation = this->getInputSocketReader(0);
 }
 
-void ConvertColorToVectorOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ConvertColorToVectorOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
-       this->m_inputOperation->read(outputValue, x, y, sampler, inputBuffers);
+       this->m_inputOperation->read(outputValue, x, y, sampler);
 }
 
 void ConvertColorToVectorOperation::deinitExecution()
index 51fa3a677cd09321e23ce55a66d4eb84ea4c34c0..861807db8dbc70592e20c297f317318354f5ec86 100644 (file)
@@ -44,7 +44,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
        
        /**
         * Initialize the execution
index b4319d25d1318b3ec7ce4c701f0f3696bfa6b7a2..80416bbccdf83574518ea597a6d3b7a5b4123f1b 100644 (file)
@@ -75,12 +75,12 @@ void ConvertDepthToRadiusOperation::initExecution()
        }
 }
 
-void ConvertDepthToRadiusOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ConvertDepthToRadiusOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
        float inputValue[4];
        float z;
        float radius;
-       this->m_inputOperation->read(inputValue, x, y, sampler, inputBuffers);
+       this->m_inputOperation->read(inputValue, x, y, sampler);
        z = inputValue[0];
        if (z != 0.f) {
                float iZ = (1.f / z);
index f0e905db9c2276cbc984d27f585736cff11e1733..4f80ef69f437c53c00918364c7c95a2aa937799f 100644 (file)
@@ -54,7 +54,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
        
        /**
         * Initialize the execution
index 5149e37020805fe34386b02cea2041c3180d8732..4b42de26f59b9104e0140456298ea83a31466e5b 100644 (file)
@@ -35,10 +35,10 @@ void ConvertHSVToRGBOperation::initExecution()
        this->m_inputOperation = this->getInputSocketReader(0);
 }
 
-void ConvertHSVToRGBOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ConvertHSVToRGBOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
        float inputColor[4];
-       this->m_inputOperation->read(inputColor, x, y, sampler, inputBuffers);
+       this->m_inputOperation->read(inputColor, x, y, sampler);
        hsv_to_rgb(inputColor[0], inputColor[1], inputColor[2], &outputValue[0], &outputValue[1], &outputValue[2]);
        outputValue[3] = inputColor[3];
 }
index 3babbfb7c1d676758ee7a3c7324896e56af5e1b9..28ce70170a0f8c69d8c3f539a3eee5bd74fc8284 100644 (file)
@@ -44,7 +44,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
        
        /**
         * Initialize the execution
index b7db0a6a2c71c0a74e6c48f12563195c75660650..787b1a4547cc8bf1b52fc5bcf234bc3702548731 100644 (file)
@@ -35,12 +35,12 @@ void ConvertKeyToPremulOperation::initExecution()
        this->m_inputColor = getInputSocketReader(0);
 }
 
-void ConvertKeyToPremulOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ConvertKeyToPremulOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
        float inputValue[4];
        float alpha;
 
-       this->m_inputColor->read(inputValue, x, y, sampler, inputBuffers);
+       this->m_inputColor->read(inputValue, x, y, sampler);
        alpha = inputValue[3];
 
        mul_v3_v3fl(outputValue, inputValue, alpha);
index 50b39928305fb865414039f0a8ffe1da20793d57..a1a8836a69099458e32e2c7cbe4774dfac5319e6 100644 (file)
@@ -40,7 +40,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
 
        void initExecution();
        void deinitExecution();
index 0ba23b2ec2ec8e694128919cba3aff244ef2a03e..22cfdd2f5724b0d67615ec0522f220e7711a4e06 100644 (file)
@@ -35,12 +35,12 @@ void ConvertPremulToKeyOperation::initExecution()
        this->m_inputColor = getInputSocketReader(0);
 }
 
-void ConvertPremulToKeyOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ConvertPremulToKeyOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
        float inputValue[4];
        float alpha;
 
-       this->m_inputColor->read(inputValue, x, y, sampler, inputBuffers);
+       this->m_inputColor->read(inputValue, x, y, sampler);
        alpha = inputValue[3];
 
        if (fabsf(alpha) < 1e-5f) {
index 173cbb4fc0a41bcc9990786b93fd59fca8226e69..fb83a06c25d53891bb8b0323dd84e9998890ee5f 100644 (file)
@@ -40,7 +40,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
 
        void initExecution();
        void deinitExecution();
index dd5e99076429b2c4f5a099218819c365ddbada62..8478eac75b0c6c49ed56d8c8a2567a2bacf4c415 100644 (file)
@@ -35,10 +35,10 @@ void ConvertRGBToHSVOperation::initExecution()
        this->m_inputOperation = this->getInputSocketReader(0);
 }
 
-void ConvertRGBToHSVOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ConvertRGBToHSVOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
        float inputColor[4];
-       this->m_inputOperation->read(inputColor, x, y, sampler, inputBuffers);
+       this->m_inputOperation->read(inputColor, x, y, sampler);
        rgb_to_hsv(inputColor[0], inputColor[1], inputColor[2], &outputValue[0], &outputValue[1], &outputValue[2]);
        outputValue[3] = inputColor[3];
 }
index 42bd439c8c2de16a69a0a67c439461e20471d3a9..09f6c7e48a65ecf75de529fcd2a875e773c5eb61 100644 (file)
@@ -44,7 +44,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
        
        /**
         * Initialize the execution
index 7f41a79b7f410bab49e63fbd5c3aeb188d7456a3..52aa1d7a12367f84117e338e550b827a7cfd4ce6 100644 (file)
@@ -50,12 +50,12 @@ void ConvertRGBToYCCOperation::setMode(int mode)
        }
 }
 
-void ConvertRGBToYCCOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ConvertRGBToYCCOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
        float inputColor[4];
        float color[3];
 
-       this->m_inputOperation->read(inputColor, x, y, sampler, inputBuffers);
+       this->m_inputOperation->read(inputColor, x, y, sampler);
        rgb_to_ycc(inputColor[0], inputColor[1], inputColor[2], &color[0], &color[1], &color[2], this->m_mode);
 
        /* divided by 255 to normalize for viewing in */
index 744e0657dc69969415db08514fe8e04c2be537f0..7f4eb6d73183be8c57b87b967674ebbe1d62ed1c 100644 (file)
@@ -48,7 +48,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
 
        /**
         * Initialize the execution
index e87a765f2eb844856e3eb8c392beef730fb66e3a..2206a066a3716e31ec55817fc2ca9248de535326 100644 (file)
@@ -34,10 +34,10 @@ void ConvertRGBToYUVOperation::initExecution()
        this->m_inputOperation = this->getInputSocketReader(0);
 }
 
-void ConvertRGBToYUVOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ConvertRGBToYUVOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
        float inputColor[4];
-       this->m_inputOperation->read(inputColor, x, y, sampler, inputBuffers);
+       this->m_inputOperation->read(inputColor, x, y, sampler);
        rgb_to_yuv(inputColor[0], inputColor[1], inputColor[2], &outputValue[0], &outputValue[1], &outputValue[2]);
        outputValue[3] = inputColor[3];
 }
index b470378704eb40159dcd336af6b54fe2b8d2b149..f7b3da800b3019260f36477e33cb503b35243180 100644 (file)
@@ -43,7 +43,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
        
        /**
         * Initialize the execution
index 100a4931d69a3458f19f33d5bb409f719e15cacc..330ffd00acbcc66f55bb5604cd71a7960c957f06 100644 (file)
@@ -33,10 +33,10 @@ void ConvertValueToColorProg::initExecution()
        this->m_inputProgram = this->getInputSocketReader(0);
 }
 
-void ConvertValueToColorProg::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ConvertValueToColorProg::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
        float inputValue[4];
-       this->m_inputProgram->read(inputValue, x, y, sampler, inputBuffers);
+       this->m_inputProgram->read(inputValue, x, y, sampler);
        color[0] = inputValue[0];
        color[1] = inputValue[0];
        color[2] = inputValue[0];
index d59964dd4005287a608e6028a9e6f5dc97ca73b3..2fa5edcf09b1d6bf7fe2f1647a9d26b0ad717aeb 100644 (file)
@@ -37,7 +37,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
        
        /**
         * Initialize the execution
index 37760fe26d7d9bf06fb3a1ded7ce2642283d0ba2..54a5b0dbd0e5fba818f85b44b361468122246082 100644 (file)
@@ -34,10 +34,10 @@ void ConvertValueToVectorOperation::initExecution()
        this->m_inputOperation = this->getInputSocketReader(0);
 }
 
-void ConvertValueToVectorOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ConvertValueToVectorOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
        float input[4];
-       this->m_inputOperation->read(input, x, y, sampler, inputBuffers);
+       this->m_inputOperation->read(input, x, y, sampler);
        outputValue[0] = input[0];
        outputValue[1] = input[0];
        outputValue[2] = input[0];
index 0e79c1ff3dfb02cd3c428b36b1d235ee9acd3ccf..c0936a32eb5c180260648cb005d19ea2a57a94df 100644 (file)
@@ -44,7 +44,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
        
        /**
         * Initialize the execution
index 395b96e8b253ac7c2d57bcb4a64ac190b8e71a52..9fb9a2e0705d567a7166241b0ed7145691a1757c 100644 (file)
@@ -34,9 +34,9 @@ void ConvertVectorToColorOperation::initExecution()
        this->m_inputOperation = this->getInputSocketReader(0);
 }
 
-void ConvertVectorToColorOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ConvertVectorToColorOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
-       this->m_inputOperation->read(outputValue, x, y, sampler, inputBuffers);
+       this->m_inputOperation->read(outputValue, x, y, sampler);
        outputValue[3] = 1.0f;
 }
 
index 8225d03d58e107c55e819014f5c9bb6c9bd2712d..a062c452a917eeec63c5b9752f4c6c7fdd077b9f 100644 (file)
@@ -44,7 +44,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
        
        /**
         * Initialize the execution
index 68842c5a055bfd585c2806daae8f6a35e42529ac..23b552f1dbe9882bb1d2d811bd107d3e3e4ddddb 100644 (file)
@@ -34,10 +34,10 @@ void ConvertVectorToValueOperation::initExecution()
        this->m_inputOperation = this->getInputSocketReader(0);
 }
 
-void ConvertVectorToValueOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ConvertVectorToValueOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
        float input[4];
-       this->m_inputOperation->read(input, x, y, sampler, inputBuffers);
+       this->m_inputOperation->read(input, x, y, sampler);
        outputValue[0] = (input[0] + input[1] + input[2]) / 3.0f;
 }
 
index a7981e8dc59dd4b5f14ba32ae1fbbb212abdd0c0..b662f3eed6c07270035d28258a3a47f4f340e3b3 100644 (file)
@@ -44,7 +44,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
        
        /**
         * Initialize the execution
index 78b7a7af60d3c0643af46b7373b6d15edafe2293..88a7e7dedd9215f445dd1cde11dad9fa186a265d 100644 (file)
@@ -50,10 +50,10 @@ void ConvertYCCToRGBOperation::setMode(int mode)
        }
 }
 
-void ConvertYCCToRGBOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ConvertYCCToRGBOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
        float inputColor[4];
-       this->m_inputOperation->read(inputColor, x, y, sampler, inputBuffers);
+       this->m_inputOperation->read(inputColor, x, y, sampler);
 
        /* need to un-normalize the data */
        /* R,G,B --> Y,Cb,Cr */
index e23dfd8a9857f6f6645f692880d7c4edb43bf1b5..a8e03bcb807810233d371842aa7711ffceaa772f 100644 (file)
@@ -48,7 +48,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
 
        /**
         * Initialize the execution
index b4393c53b920e92ddb6b447880274b88b6a84475..1a5e7cbf2a66dc1a36e1588dc48f92eaf9ebe4fb 100644 (file)
@@ -34,10 +34,10 @@ void ConvertYUVToRGBOperation::initExecution()
        this->m_inputOperation = this->getInputSocketReader(0);
 }
 
-void ConvertYUVToRGBOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ConvertYUVToRGBOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
        float inputColor[4];
-       this->m_inputOperation->read(inputColor, x, y, sampler, inputBuffers);
+       this->m_inputOperation->read(inputColor, x, y, sampler);
        yuv_to_rgb(inputColor[0], inputColor[1], inputColor[2], &outputValue[0], &outputValue[1], &outputValue[2]);
        outputValue[3] = inputColor[3];
 }
index 3368e0a24df6c7140507543ca0eacb10fe6184ae..80321ae37d26ff0a27b0c9ec636abf45b634db9c 100644 (file)
@@ -43,7 +43,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
        
        /**
         * Initialize the execution
index cf3ffe6d8f49bea017dcc4f825101af221b53db8..90bda5c8d2cdad84d977163fab3e6e5aa244cc12 100644 (file)
@@ -28,7 +28,7 @@ ConvolutionEdgeFilterOperation::ConvolutionEdgeFilterOperation() : ConvolutionFi
        /* pass */
 }
 
-void ConvolutionEdgeFilterOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void ConvolutionEdgeFilterOperation::executePixel(float *color, int x, int y, void *data)
 {
        float in1[4], in2[4], res1[4], res2[4];
 
@@ -46,7 +46,7 @@ void ConvolutionEdgeFilterOperation::executePixel(float *color, int x, int y, Me
        CLAMP(y3, 0, getHeight() - 1);
        
        float value[4];
-       this->m_inputValueOperation->read(value, x2, y2, inputBuffers, NULL);
+       this->m_inputValueOperation->read(value, x2, y2, NULL);
        float mval = 1.0f - value[0];
        
        res1[0] = 0.0f;
@@ -58,39 +58,39 @@ void ConvolutionEdgeFilterOperation::executePixel(float *color, int x, int y, Me
        res2[2] = 0.0f;
        res2[3] = 0.0f;
        
-       this->m_inputOperation->read(in1, x1, y1, inputBuffers, NULL);
+       this->m_inputOperation->read(in1, x1, y1, NULL);
        madd_v3_v3fl(res1, in1, this->m_filter[0]);
        madd_v3_v3fl(res2, in1, this->m_filter[0]);
        
-       this->m_inputOperation->read(in1, x2, y1, inputBuffers, NULL);
+       this->m_inputOperation->read(in1, x2, y1, NULL);
        madd_v3_v3fl(res1, in1, this->m_filter[1]);
        madd_v3_v3fl(res2, in1, this->m_filter[3]);
        
-       this->m_inputOperation->read(in1, x3, y1, inputBuffers, NULL);
+       this->m_inputOperation->read(in1, x3, y1, NULL);
        madd_v3_v3fl(res1, in1, this->m_filter[2]);
        madd_v3_v3fl(res2, in1, this->m_filter[6]);
        
-       this->m_inputOperation->read(in1, x1, y2, inputBuffers, NULL);
+       this->m_inputOperation->read(in1, x1, y2, NULL);
        madd_v3_v3fl(res1, in1, this->m_filter[3]);
        madd_v3_v3fl(res2, in1, this->m_filter[1]);
        
-       this->m_inputOperation->read(in2, x2, y2, inputBuffers, NULL);
+       this->m_inputOperation->read(in2, x2, y2, NULL);
        madd_v3_v3fl(res1, in2, this->m_filter[4]);
        madd_v3_v3fl(res2, in2, this->m_filter[4]);
        
-       this->m_inputOperation->read(in1, x3, y2, inputBuffers, NULL);
+       this->m_inputOperation->read(in1, x3, y2, NULL);
        madd_v3_v3fl(res1, in1, this->m_filter[5]);
        madd_v3_v3fl(res2, in1, this->m_filter[7]);
        
-       this->m_inputOperation->read(in1, x1, y3, inputBuffers, NULL);
+       this->m_inputOperation->read(in1, x1, y3, NULL);
        madd_v3_v3fl(res1, in1, this->m_filter[6]);
        madd_v3_v3fl(res2, in1, this->m_filter[2]);
        
-       this->m_inputOperation->read(in1, x2, y3, inputBuffers, NULL);
+       this->m_inputOperation->read(in1, x2, y3, NULL);
        madd_v3_v3fl(res1, in1, this->m_filter[7]);
        madd_v3_v3fl(res2, in1, this->m_filter[5]);
        
-       this->m_inputOperation->read(in1, x3, y3, inputBuffers, NULL);
+       this->m_inputOperation->read(in1, x3, y3, NULL);
        madd_v3_v3fl(res1, in1, this->m_filter[8]);
        madd_v3_v3fl(res2, in1, this->m_filter[8]);
        
index 92e45c7104f2d127513087c5e25b1264efe28755..b96b8785524c995bebe161bb0088e44647a4968f 100644 (file)
@@ -28,7 +28,7 @@
 class ConvolutionEdgeFilterOperation : public ConvolutionFilterOperation {
 public:
        ConvolutionEdgeFilterOperation();
-       void executePixel(float *color, int x, int y, MemoryBuffer * inputBuffers[], void *data);
+       void executePixel(float *color, int x, int y, void *data);
 };
 
 #endif
index 3840e775fe37812cdba1f38f33538ca8e580e0fb..6c1e434ab41368b602bb2c8c3d1adf9839daff11 100644 (file)
@@ -67,7 +67,7 @@ void ConvolutionFilterOperation::deinitExecution()
 }
 
 
-void ConvolutionFilterOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void ConvolutionFilterOperation::executePixel(float *color, int x, int y, void *data)
 {
        float in1[4];
        float in2[4];
@@ -84,27 +84,27 @@ void ConvolutionFilterOperation::executePixel(float *color, int x, int y, Memory
        CLAMP(y2, 0, getHeight() - 1);
        CLAMP(y3, 0, getHeight() - 1);
        float value[4];
-       this->m_inputValueOperation->read(value, x2, y2, inputBuffers, NULL);
+       this->m_inputValueOperation->read(value, x2, y2, NULL);
        const float mval = 1.0f - value[0];
 
        zero_v4(color);
-       this->m_inputOperation->read(in1, x1, y1, inputBuffers, NULL);
+       this->m_inputOperation->read(in1, x1, y1, NULL);
        madd_v4_v4fl(color, in1, this->m_filter[0]);
-       this->m_inputOperation->read(in1, x2, y1, inputBuffers, NULL);
+       this->m_inputOperation->read(in1, x2, y1, NULL);
        madd_v4_v4fl(color, in1, this->m_filter[1]);
-       this->m_inputOperation->read(in1, x3, y1, inputBuffers, NULL);
+       this->m_inputOperation->read(in1, x3, y1, NULL);
        madd_v4_v4fl(color, in1, this->m_filter[2]);
-       this->m_inputOperation->read(in1, x1, y2, inputBuffers, NULL);
+       this->m_inputOperation->read(in1, x1, y2, NULL);
        madd_v4_v4fl(color, in1, this->m_filter[3]);
-       this->m_inputOperation->read(in2, x2, y2, inputBuffers, NULL);
+       this->m_inputOperation->read(in2, x2, y2, NULL);
        madd_v4_v4fl(color, in2, this->m_filter[4]);
-       this->m_inputOperation->read(in1, x3, y2, inputBuffers, NULL);
+       this->m_inputOperation->read(in1, x3, y2, NULL);
        madd_v4_v4fl(color, in1, this->m_filter[5]);
-       this->m_inputOperation->read(in1, x1, y3, inputBuffers, NULL);
+       this->m_inputOperation->read(in1, x1, y3, NULL);
        madd_v4_v4fl(color, in1, this->m_filter[6]);
-       this->m_inputOperation->read(in1, x2, y3, inputBuffers, NULL);
+       this->m_inputOperation->read(in1, x2, y3, NULL);
        madd_v4_v4fl(color, in1, this->m_filter[7]);
-       this->m_inputOperation->read(in1, x3, y3, inputBuffers, NULL);
+       this->m_inputOperation->read(in1, x3, y3, NULL);
        madd_v4_v4fl(color, in1, this->m_filter[8]);
        
        color[0] = color[0] * value[0] + in2[0] * mval;
index 0b5dfb4d75a2bb1c999796c6b84340d2d93725ce..88455730c0ed321d79e344648a74c18009bc5847 100644 (file)
@@ -39,7 +39,7 @@ public:
        ConvolutionFilterOperation();
        void set3x3Filter(float f1, float f2, float f3, float f4, float f5, float f6, float f7, float f8, float f9);
        bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output);
-       void executePixel(float *color, int x, int y, MemoryBuffer * inputBuffers[], void *data);
+       void executePixel(float *color, int x, int y, void *data);
        
        void initExecution();
        void deinitExecution();
index 0a40f2370c8e9c6588b89e94f84df877863dd06c..efbc331e7d370d5941ab4bf5df62cf088744de7e 100644 (file)
@@ -73,10 +73,10 @@ CropOperation::CropOperation() : CropBaseOperation()
        /* pass */
 }
 
-void CropOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void CropOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
        if ((x < this->m_xmax && x >= this->m_xmin) && (y < this->m_ymax && y >= this->m_ymin)) {
-               this->m_inputOperation->read(color, x, y, sampler, inputBuffers);
+               this->m_inputOperation->read(color, x, y, sampler);
        }
        else {
                zero_v4(color);
@@ -108,7 +108,7 @@ void CropImageOperation::determineResolution(unsigned int resolution[], unsigned
        resolution[1] = this->m_ymax - this->m_ymin;
 }
 
-void CropImageOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void CropImageOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
-       this->m_inputOperation->read(color, (x + this->m_xmin), (y + this->m_ymin), sampler, inputBuffers);
+       this->m_inputOperation->read(color, (x + this->m_xmin), (y + this->m_ymin), sampler);
 }
index 39dbb8aa873335eef3adedd3f5db34f014b044ef..78644536143aaf77fec0a0803992b54643bfcc21 100644 (file)
@@ -48,7 +48,7 @@ class CropOperation : public CropBaseOperation {
 private:
 public:
        CropOperation();
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
 };
 
 class CropImageOperation : public CropBaseOperation {
@@ -57,7 +57,7 @@ public:
        CropImageOperation();
        bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output);
        void determineResolution(unsigned int resolution[], unsigned int preferedResolution[]);
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
 
 };
 #endif
index 3c4bdfe8e5b001cc3bfb5ca7fcc1eef8fb6c5321..ed3799fff5e0dea108530b65e33d7288a30989d5 100644 (file)
@@ -44,7 +44,7 @@ void DifferenceMatteOperation::deinitExecution()
        this->m_inputImage2Program = NULL;
 }
 
-void DifferenceMatteOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void DifferenceMatteOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
        float inColor1[4];
        float inColor2[4];
@@ -54,8 +54,8 @@ void DifferenceMatteOperation::executePixel(float *outputValue, float x, float y
        float difference;
        float alpha;
 
-       this->m_inputImage1Program->read(inColor1, x, y, sampler, inputBuffers);
-       this->m_inputImage2Program->read(inColor2, x, y, sampler, inputBuffers);
+       this->m_inputImage1Program->read(inColor1, x, y, sampler);
+       this->m_inputImage2Program->read(inColor2, x, y, sampler);
 
        difference = (fabsf(inColor2[0] - inColor1[0]) +
                      fabsf(inColor2[1] - inColor1[1]) +
index c35550560e152cdca5ddb64503d6c1b116bf75a9..acec6ebf193cff5077a70dd8cf7b1463b7c916d4 100644 (file)
@@ -43,7 +43,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
        
        void initExecution();
        void deinitExecution();
index a9b40f8a6ac03619a1517b41b2b7db57414bb186..71be94bf2a7f8af4435878a2753b05036c86f41e 100644 (file)
@@ -54,13 +54,13 @@ void DilateErodeThresholdOperation::initExecution()
        }
 }
 
-void *DilateErodeThresholdOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
+void *DilateErodeThresholdOperation::initializeTileData(rcti *rect)
 {
-       void *buffer = this->m_inputProgram->initializeTileData(NULL, memoryBuffers);
+       void *buffer = this->m_inputProgram->initializeTileData(NULL);
        return buffer;
 }
 
-void DilateErodeThresholdOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void DilateErodeThresholdOperation::executePixel(float *color, int x, int y, void *data)
 {
        float inputValue[4];
        const float sw = this->m__switch;
@@ -80,7 +80,7 @@ void DilateErodeThresholdOperation::executePixel(float *color, int x, int y, Mem
        const int bufferWidth = rect->xmax - rect->xmin;
        int offset;
 
-       this->m_inputProgram->read(inputValue, x, y, inputBuffers, NULL);
+       this->m_inputProgram->read(inputValue, x, y, NULL);
        if (inputValue[0] > sw) {
                for (int yi = miny; yi < maxy; yi++) {
                        const float dy = yi - y;
@@ -179,13 +179,13 @@ void DilateDistanceOperation::initExecution()
        }
 }
 
-void *DilateDistanceOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
+void *DilateDistanceOperation::initializeTileData(rcti *rect)
 {
-       void *buffer = this->m_inputProgram->initializeTileData(NULL, memoryBuffers);
+       void *buffer = this->m_inputProgram->initializeTileData(NULL);
        return buffer;
 }
 
-void DilateDistanceOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void DilateDistanceOperation::executePixel(float *color, int x, int y, void *data)
 {
        const float distance = this->m_distance;
        const float mindist = distance * distance;
@@ -259,7 +259,7 @@ ErodeDistanceOperation::ErodeDistanceOperation() : DilateDistanceOperation()
        /* pass */
 }
 
-void ErodeDistanceOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void ErodeDistanceOperation::executePixel(float *color, int x, int y, void *data)
 {
        const float distance = this->m_distance;
        const float mindist = distance * distance;
@@ -325,14 +325,14 @@ void DilateStepOperation::initExecution()
        this->initMutex();
 }
 
-void *DilateStepOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
+void *DilateStepOperation::initializeTileData(rcti *rect)
 {
        if (this->m_cached_buffer != NULL) {
                return this->m_cached_buffer;
        }
        lockMutex();
        if (this->m_cached_buffer == NULL) {
-               MemoryBuffer *buffer = (MemoryBuffer *)this->m_inputProgram->initializeTileData(NULL, memoryBuffers);
+               MemoryBuffer *buffer = (MemoryBuffer *)this->m_inputProgram->initializeTileData(NULL);
                float *rectf = buffer->convertToValueBuffer();
                int x, y, i;
                float *p;
@@ -374,7 +374,7 @@ void *DilateStepOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryB
 }
 
 
-void DilateStepOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void DilateStepOperation::executePixel(float *color, int x, int y, void *data)
 {
        color[0] = this->m_cached_buffer[y * this->getWidth() + x];
 }
@@ -412,14 +412,14 @@ ErodeStepOperation::ErodeStepOperation() : DilateStepOperation()
        /* pass */
 }
 
-void *ErodeStepOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
+void *ErodeStepOperation::initializeTileData(rcti *rect)
 {
        if (this->m_cached_buffer != NULL) {
                return this->m_cached_buffer;
        }
        lockMutex();
        if (this->m_cached_buffer == NULL) {
-               MemoryBuffer *buffer = (MemoryBuffer *)this->m_inputProgram->initializeTileData(NULL, memoryBuffers);
+               MemoryBuffer *buffer = (MemoryBuffer *)this->m_inputProgram->initializeTileData(NULL);
                float *rectf = buffer->convertToValueBuffer();
                int x, y, i;
                float *p;
index bc6049bf992b4bd8ce03e4edd0ffa1089a239af8..8c3eefb97e44c638419be228ca266c074d3a021a 100644 (file)
@@ -47,14 +47,14 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, int x, int y, MemoryBuffer * inputBuffers[], void *data);
+       void executePixel(float *color, int x, int y, void *data);
        
        /**
         * Initialize the execution
         */
        void initExecution();
        
-       void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers);
+       void *initializeTileData(rcti *rect);
        /**
         * Deinitialize the execution
         */
@@ -83,14 +83,14 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, int x, int y, MemoryBuffer * inputBuffers[], void *data);
+       void executePixel(float *color, int x, int y, void *data);
        
        /**
         * Initialize the execution
         */
        void initExecution();
        
-       void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers);
+       void *initializeTileData(rcti *rect);
        /**
         * Deinitialize the execution
         */
@@ -111,7 +111,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, int x, int y, MemoryBuffer * inputBuffers[], void *data);
+       void executePixel(float *color, int x, int y, void *data);
 
        void executeOpenCL(OpenCLDevice* device,
                           MemoryBuffer *outputMemoryBuffer, cl_mem clOutputBuffer, 
@@ -135,14 +135,14 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, int x, int y, MemoryBuffer * inputBuffers[], void *data);
+       void executePixel(float *color, int x, int y, void *data);
        
        /**
         * Initialize the execution
         */
        void initExecution();
        
-       void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers);
+       void *initializeTileData(rcti *rect);
        /**
         * Deinitialize the execution
         */
@@ -157,7 +157,7 @@ class ErodeStepOperation : public DilateStepOperation {
 public:
        ErodeStepOperation();
        
-       void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers);
+       void *initializeTileData(rcti *rect);
 };
 
 #endif
index 76ee5b2c2a1224297f72a912ce56ad4644e84398..5e6ff2c7da1d08d070794c626ad22e03d4139064 100644 (file)
@@ -66,12 +66,12 @@ void DirectionalBlurOperation::initExecution()
 
 }
 
-void DirectionalBlurOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void DirectionalBlurOperation::executePixel(float *color, int x, int y, void *data)
 {
        const int iterations = pow(2.0f, this->m_data->iter);
        float col[4] = {0, 0, 0, 0};
        float col2[4] = {0, 0, 0, 0};
-       this->m_inputProgram->read(col2, x, y, COM_PS_NEAREST, inputBuffers);
+       this->m_inputProgram->read(col2, x, y, COM_PS_NEAREST);
        float ltx = this->m_tx;
        float lty = this->m_ty;
        float lsc = this->m_sc;
@@ -87,7 +87,7 @@ void DirectionalBlurOperation::executePixel(float *color, int x, int y, MemoryBu
                this->m_inputProgram->read(col,
                                           cs * u + ss * v + this->m_center_x_pix,
                                           cs * v - ss * u + this->m_center_y_pix,
-                                          COM_PS_NEAREST, inputBuffers);
+                                          COM_PS_NEAREST);
 
                add_v4_v4(col2, col);
 
index 0ab5e9dff2de27fb04b19acfb292ba3a97f05446..cc49e947f9575181bb6c04f1f9946cd5672ce343 100644 (file)
@@ -40,7 +40,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, int x, int y, MemoryBuffer * inputBuffers[], void *data);
+       void executePixel(float *color, int x, int y, void *data);
        
        /**
         * Initialize the execution
index 3ef73feaf365ac666ad341d7fe313bc018033c58..018df78cb656b025c8ed0e0dac416cf83b209e32 100644 (file)
@@ -54,7 +54,7 @@ void DisplaceOperation::initExecution()
  * in order to take effect */
 #define DISPLACE_EPSILON    0.01f
 
-void DisplaceOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void DisplaceOperation::executePixel(float *color, int x, int y, void *data)
 {
        float inVector[4];
        float inScale[4];
@@ -64,9 +64,9 @@ void DisplaceOperation::executePixel(float *color, int x, int y, MemoryBuffer *i
        float dxt, dyt;
        float u, v;
 
-       this->m_inputScaleXProgram->read(inScale, x, y, COM_PS_NEAREST, inputBuffers);
+       this->m_inputScaleXProgram->read(inScale, x, y, COM_PS_NEAREST);
        float xs = inScale[0];
-       this->m_inputScaleYProgram->read(inScale, x, y, COM_PS_NEAREST, inputBuffers);
+       this->m_inputScaleYProgram->read(inScale, x, y, COM_PS_NEAREST);
        float ys = inScale[0];
 
        /* clamp x and y displacement to triple image resolution - 
@@ -74,7 +74,7 @@ void DisplaceOperation::executePixel(float *color, int x, int y, MemoryBuffer *i
        CLAMP(xs, -this->m_width_x4, this->m_width_x4);
        CLAMP(ys, -this->m_height_x4, this->m_height_x4);
 
-       this->m_inputVectorProgram->read(inVector, x, y, COM_PS_NEAREST, inputBuffers);
+       this->m_inputVectorProgram->read(inVector, x, y, COM_PS_NEAREST);
        p_dx = inVector[0] * xs;
        p_dy = inVector[1] * ys;
 
@@ -83,9 +83,9 @@ void DisplaceOperation::executePixel(float *color, int x, int y, MemoryBuffer *i
        v = y - p_dy + 0.5f;
 
        /* calc derivatives */
-       this->m_inputVectorProgram->read(inVector, x + 1, y, COM_PS_NEAREST, inputBuffers);
+       this->m_inputVectorProgram->read(inVector, x + 1, y, COM_PS_NEAREST);
        d_dx = inVector[0] * xs;
-       this->m_inputVectorProgram->read(inVector, x, y + 1, COM_PS_NEAREST, inputBuffers);
+       this->m_inputVectorProgram->read(inVector, x, y + 1, COM_PS_NEAREST);
        d_dy = inVector[1] * ys;
 
        /* clamp derivatives to minimum displacement distance in UV space */
@@ -96,7 +96,7 @@ void DisplaceOperation::executePixel(float *color, int x, int y, MemoryBuffer *i
        dyt = signf(dyt) * maxf(fabsf(dyt), DISPLACE_EPSILON) / this->getHeight();
 
        /* EWA filtering */
-       this->m_inputColorProgram->read(color, u, v, dxt, dyt, inputBuffers);
+       this->m_inputColorProgram->read(color, u, v, dxt, dyt);
 }
 
 void DisplaceOperation::deinitExecution()
index e01c919039642965936fb966b292e855d689cca5..0e5b042aea5cd85c1dc6dbc8e4d0374c1731767d 100644 (file)
@@ -48,7 +48,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, int x, int y, MemoryBuffer * inputBuffers[], void *data);
+       void executePixel(float *color, int x, int y, void *data);
        
        /**
         * Initialize the execution
index d21fc62abd7b5ef6bf2cde3d3f213445ee086b09..a93e39085c5069c9cd511631ea338e297a6f91a7 100644 (file)
@@ -53,7 +53,7 @@ void DisplaceSimpleOperation::initExecution()
  * in order to take effect */
 #define DISPLACE_EPSILON    0.01f
 
-void DisplaceSimpleOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void DisplaceSimpleOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
        float inVector[4];
        float inScale[4];
@@ -61,9 +61,9 @@ void DisplaceSimpleOperation::executePixel(float *color, float x, float y, Pixel
        float p_dx, p_dy;   /* main displacement in pixel space */
        float u, v;
 
-       this->m_inputScaleXProgram->read(inScale, x, y, sampler, inputBuffers);
+       this->m_inputScaleXProgram->read(inScale, x, y, sampler);
        float xs = inScale[0];
-       this->m_inputScaleYProgram->read(inScale, x, y, sampler, inputBuffers);
+       this->m_inputScaleYProgram->read(inScale, x, y, sampler);
        float ys = inScale[0];
 
        /* clamp x and y displacement to triple image resolution - 
@@ -71,7 +71,7 @@ void DisplaceSimpleOperation::executePixel(float *color, float x, float y, Pixel
        CLAMP(xs, -this->m_width_x4, this->m_width_x4);
        CLAMP(ys, -this->m_height_x4, this->m_height_x4);
 
-       this->m_inputVectorProgram->read(inVector, x, y, sampler, inputBuffers);
+       this->m_inputVectorProgram->read(inVector, x, y, sampler);
        p_dx = inVector[0] * xs;
        p_dy = inVector[1] * ys;
 
@@ -82,7 +82,7 @@ void DisplaceSimpleOperation::executePixel(float *color, float x, float y, Pixel
        CLAMP(u, 0.f, this->getWidth() - 1.f);
        CLAMP(v, 0.f, this->getHeight() - 1.f);
 
-       this->m_inputColorProgram->read(color, u, v, sampler, inputBuffers);
+       this->m_inputColorProgram->read(color, u, v, sampler);
 }
 
 void DisplaceSimpleOperation::deinitExecution()
index 25afbafe3358bbc0df23dd94c33dfbf9872ca56a..81adc7be3663b81cdc0e235295a51bfcdea7519d 100644 (file)
@@ -48,7 +48,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
        
        /**
         * Initialize the execution
index 5bdc616fed7d944b94aa3114d1aab12d58a7c72d..197e8b07918c0f589c4ebc65594a8c200e21067f 100644 (file)
@@ -44,7 +44,7 @@ void DistanceMatteOperation::deinitExecution()
        this->m_inputKeyProgram = NULL;
 }
 
-void DistanceMatteOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void DistanceMatteOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
        float inKey[4];
        float inImage[4];
@@ -55,8 +55,8 @@ void DistanceMatteOperation::executePixel(float *outputValue, float x, float y,
        float distance;
        float alpha;
 
-       this->m_inputKeyProgram->read(inKey, x, y, sampler, inputBuffers);
-       this->m_inputImageProgram->read(inImage, x, y, sampler, inputBuffers);
+       this->m_inputKeyProgram->read(inKey, x, y, sampler);
+       this->m_inputImageProgram->read(inImage, x, y, sampler);
        
        distance = sqrt(pow((inKey[0] - inImage[0]), 2) +
                        pow((inKey[1] - inImage[1]), 2) +
index 267aa1fca7aea5fe21df5b26cbaa3c8440c33806..6fe16c7fdff307fcef410a028557d91a00d63d25 100644 (file)
@@ -42,7 +42,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
        
        void initExecution();
        void deinitExecution();
index 53ab5f975187a88790c6d59e061f40f287e244ad..559d97d6056b8f4e6a793ff8662010adb9d5fb44 100644 (file)
@@ -45,11 +45,11 @@ void DotproductOperation::deinitExecution()
 
 /** @todo: current implementation is the inverse of a dotproduct. not 'logically' correct
  */
-void DotproductOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void DotproductOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
        float input1[4];
        float input2[4];
-       this->m_input1Operation->read(input1, x, y, sampler, inputBuffers);
-       this->m_input2Operation->read(input2, x, y, sampler, inputBuffers);
+       this->m_input1Operation->read(input1, x, y, sampler);
+       this->m_input2Operation->read(input2, x, y, sampler);
        color[0] = -(input1[0] * input2[0] + input1[1] * input2[1] + input1[2] * input2[2]);
 }
index 7ca540983d9cf07c129e320ca50f821e4755eca1..6ff6f622a50bc63073904c13749f933892ae9a6d 100644 (file)
@@ -31,7 +31,7 @@ private:
        SocketReader *m_input2Operation;
 public:
        DotproductOperation();
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
        
        void initExecution();
        void deinitExecution();
index e5a145bab2e8303514a74b6429b2e63cdb5609de..bcad974da70b5e3447a836b5b837989c87c2057d 100644 (file)
@@ -1260,15 +1260,15 @@ void DoubleEdgeMaskOperation::initExecution()
        this->m_cachedInstance = NULL;
 }
 
-void *DoubleEdgeMaskOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
+void *DoubleEdgeMaskOperation::initializeTileData(rcti *rect)
 {
        if (this->m_cachedInstance)
                return this->m_cachedInstance;
        
        lockMutex();
        if (this->m_cachedInstance == NULL) {
-               MemoryBuffer *innerMask = (MemoryBuffer *)this->m_inputInnerMask->initializeTileData(rect, memoryBuffers);
-               MemoryBuffer *outerMask = (MemoryBuffer *)this->m_inputOuterMask->initializeTileData(rect, memoryBuffers);
+               MemoryBuffer *innerMask = (MemoryBuffer *)this->m_inputInnerMask->initializeTileData(rect);
+               MemoryBuffer *outerMask = (MemoryBuffer *)this->m_inputOuterMask->initializeTileData(rect);
                float *data = new float[this->getWidth() * this->getHeight()];
                float *imask = innerMask->convertToValueBuffer();
                float *omask = outerMask->convertToValueBuffer();
@@ -1280,7 +1280,7 @@ void *DoubleEdgeMaskOperation::initializeTileData(rcti *rect, MemoryBuffer **mem
        unlockMutex();
        return this->m_cachedInstance;
 }
-void DoubleEdgeMaskOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void DoubleEdgeMaskOperation::executePixel(float *color, int x, int y, void *data)
 {
        float *buffer = (float *) data;
        int index = (y * this->getWidth() + x);
index 442680e320e66d2e1c50ceb53613ec5a48d41c6d..32e5a07cfdca007faf6c69366d25b0c919ccd1af 100644 (file)
@@ -42,7 +42,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, int x, int y, MemoryBuffer * inputBuffers[], void *data);
+       void executePixel(float *color, int x, int y, void *data);
        
        /**
         * Initialize the execution
@@ -54,7 +54,7 @@ public:
         */
        void deinitExecution();
 
-       void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers);
+       void *initializeTileData(rcti *rect);
 
        bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output);
        
index 1aa1b89ee766f250796ce51f5a5e2f2ce53e3b9a..c3cbaaaf2fc456374a9d0ac577289c1bf9e3fb6b 100644 (file)
@@ -44,7 +44,7 @@ void EllipseMaskOperation::initExecution()
        this->m_aspectRatio = ((float)this->getWidth()) / this->getHeight();
 }
 
-void EllipseMaskOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void EllipseMaskOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
        float inputMask[4];
        float inputValue[4];
@@ -57,8 +57,8 @@ void EllipseMaskOperation::executePixel(float *color, float x, float y, PixelSam
        rx = this->m_data->x + (this->m_cosine * dx + this->m_sine * dy);
        ry = this->m_data->y + (-this->m_sine * dx + this->m_cosine * dy);
        
-       this->m_inputMask->read(inputMask, x, y, sampler, inputBuffers);
-       this->m_inputValue->read(inputValue, x, y, sampler, inputBuffers);
+       this->m_inputMask->read(inputMask, x, y, sampler);
+       this->m_inputValue->read(inputValue, x, y, sampler);
        
        const float halfHeight = (this->m_data->height) / 2.0f;
        const float halfWidth = this->m_data->width / 2.0f;
index 0b0ffa023cb74bcb79d1dbd8b698efc75133eca0..fce3c93bba65faba18b32cde7932257f3459ed8f 100644 (file)
@@ -45,7 +45,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
        
        /**
         * Initialize the execution
index 6d9c980ea582be535a2a7417a2fe76e10a815ee8..7ef363f5c4a6b7142c68ea59176f44f1a08ea24b 100644 (file)
@@ -31,7 +31,7 @@ FastGaussianBlurOperation::FastGaussianBlurOperation() : BlurBaseOperation(COM_D
        this->m_iirgaus = NULL;
 }
 
-void FastGaussianBlurOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void FastGaussianBlurOperation::executePixel(float *color, int x, int y, void *data)
 {
        MemoryBuffer *newData = (MemoryBuffer *)data;
        newData->read(color, x, y);     
@@ -79,13 +79,13 @@ void FastGaussianBlurOperation::deinitExecution()
        BlurBaseOperation::deinitMutex();
 }
 
-void *FastGaussianBlurOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
+void *FastGaussianBlurOperation::initializeTileData(rcti *rect)
 {
        lockMutex();
        if (!this->m_iirgaus) {
-               MemoryBuffer *newBuf = (MemoryBuffer *)this->m_inputProgram->initializeTileData(rect, memoryBuffers);
+               MemoryBuffer *newBuf = (MemoryBuffer *)this->m_inputProgram->initializeTileData(rect);
                MemoryBuffer *copy = newBuf->duplicate();
-               updateSize(memoryBuffers);
+               updateSize();
 
                int c;
                this->m_sx = this->m_data->sizex * this->m_size / 2.0f;
@@ -233,7 +233,7 @@ FastGaussianBlurValueOperation::FastGaussianBlurValueOperation() : NodeOperation
        setComplex(true);
 }
 
-void FastGaussianBlurValueOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void FastGaussianBlurValueOperation::executePixel(float *color, int x, int y, void *data)
 {
        MemoryBuffer *newData = (MemoryBuffer *)data;
        newData->read(color, x, y);     
@@ -270,11 +270,11 @@ void FastGaussianBlurValueOperation::deinitExecution()
        deinitMutex();
 }
 
-void *FastGaussianBlurValueOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
+void *FastGaussianBlurValueOperation::initializeTileData(rcti *rect)
 {
        lockMutex();
        if (!this->m_iirgaus) {
-               MemoryBuffer *newBuf = (MemoryBuffer *)this->m_inputprogram->initializeTileData(rect, memoryBuffers);
+               MemoryBuffer *newBuf = (MemoryBuffer *)this->m_inputprogram->initializeTileData(rect);
                MemoryBuffer *copy = newBuf->duplicate();
                FastGaussianBlurOperation::IIR_gauss(copy, this->m_sigma, 0, 3);
                this->m_iirgaus = copy;
index 5f76490473fcadf624b72ea96f36698aec07ab59..4560e1b25e38eb019b1d1e6ca3a3c66349ee3bf2 100644 (file)
@@ -34,10 +34,10 @@ private:
 public:
        FastGaussianBlurOperation();
        bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output);
-       void executePixel(float *color, int x, int y, MemoryBuffer * inputBuffers[], void *data);
+       void executePixel(float *color, int x, int y, void *data);
        
        static void IIR_gauss(MemoryBuffer *src, float sigma, unsigned int channel, unsigned int xy);
-       void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers);
+       void *initializeTileData(rcti *rect);
        void deinitExecution();
        void initExecution();
 };
@@ -50,9 +50,9 @@ private:
 public:
        FastGaussianBlurValueOperation();
        bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output);
-       void executePixel(float *color, int x, int y, MemoryBuffer * inputBuffers[], void *data);
+       void executePixel(float *color, int x, int y, void *data);
        
-       void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers);
+       void *initializeTileData(rcti *rect);
        void deinitExecution();
        void initExecution();
        void setSigma(float sigma) { this->m_sigma = sigma; }
index 60dabb86bb5ac069d875bbffa56eff8c65140cab..939d05fffbf2caf18f18bc87c13faea4d8db9059 100644 (file)
@@ -42,12 +42,12 @@ void FlipOperation::deinitExecution()
 }
 
 
-void FlipOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void FlipOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
        float nx = this->m_flipX ? this->getWidth() - 1 - x : x;
        float ny = this->m_flipY ? this->getHeight() - 1 - y : y;
        
-       this->m_inputOperation->read(color, nx, ny, sampler, inputBuffers);
+       this->m_inputOperation->read(color, nx, ny, sampler);
 }
 
 bool FlipOperation::determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output)
index 5442774c94c1b52f55909d5994af064bf1ccbb8f..a13f7ecf752ccdb93305c85923c0df73538b7c4e 100644 (file)
@@ -33,7 +33,7 @@ private:
 public:
        FlipOperation();
        bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output);
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
        
        void initExecution();
        void deinitExecution();
index db8d54a2f3c254c0fea241339e5b670ade3b802f..a4cc03ac380bfc49ca38f5ccc02029758516071b 100644 (file)
@@ -34,10 +34,10 @@ void GammaCorrectOperation::initExecution()
        this->m_inputProgram = this->getInputSocketReader(0);
 }
 
-void GammaCorrectOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void GammaCorrectOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
        float inputColor[4];
-       this->m_inputProgram->read(inputColor, x, y, sampler, inputBuffers);
+       this->m_inputProgram->read(inputColor, x, y, sampler);
        if (inputColor[3] > 0.0f) {
                inputColor[0] /= inputColor[3];
                inputColor[1] /= inputColor[3];
@@ -75,10 +75,10 @@ void GammaUncorrectOperation::initExecution()
        this->m_inputProgram = this->getInputSocketReader(0);
 }
 
-void GammaUncorrectOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void GammaUncorrectOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
        float inputColor[4];
-       this->m_inputProgram->read(inputColor, x, y, sampler, inputBuffers);
+       this->m_inputProgram->read(inputColor, x, y, sampler);
 
        if (inputColor[3] > 0.0f) {
                inputColor[0] /= inputColor[3];
index 4db911bb9b5136a92942e9efac779717ecd265e8..2d4f2ea89d9aa0759136a0f0106f446d0181bb7d 100644 (file)
@@ -38,7 +38,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
        
        /**
         * Initialize the execution
@@ -64,7 +64,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
        
        /**
         * Initialize the execution
index 9ccc76f4392af85b5118c0e2d667d9ee6711c290..40c2ee0a1d486fc0e3dd87ed2d8bf8284989a895 100644 (file)
@@ -37,13 +37,13 @@ void GammaOperation::initExecution()
        this->m_inputGammaProgram = this->getInputSocketReader(1);
 }
 
-void GammaOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void GammaOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
        float inputValue[4];
        float inputGamma[4];
        
-       this->m_inputProgram->read(inputValue, x, y, sampler, inputBuffers);
-       this->m_inputGammaProgram->read(inputGamma, x, y, sampler, inputBuffers);
+       this->m_inputProgram->read(inputValue, x, y, sampler);
+       this->m_inputGammaProgram->read(inputGamma, x, y, sampler);
        const float gamma = inputGamma[0];
        /* check for negative to avoid nan's */
        color[0] = inputValue[0] > 0.0f ? powf(inputValue[0], gamma) : inputValue[0];
index 758f7bda04d8a236e44c68050cc981958544f293..8fc2599cba93ba8e5f7a75f34a34ca43bacf464f 100644 (file)
@@ -39,7 +39,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
        
        /**
         * Initialize the execution
index a138d4be1d9af3875c6066ac6d520f2f07281828..9865c87cb071245316fab10908d83bff80489c67 100644 (file)
@@ -34,13 +34,13 @@ GaussianAlphaXBlurOperation::GaussianAlphaXBlurOperation() : BlurBaseOperation(C
        this->m_rad = 0;
 }
 
-void *GaussianAlphaXBlurOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
+void *GaussianAlphaXBlurOperation::initializeTileData(rcti *rect)
 {
        lockMutex();
        if (!this->m_sizeavailable) {
-               updateGauss(memoryBuffers);
+               updateGauss();
        }
-       void *buffer = getInputOperation(0)->initializeTileData(NULL, memoryBuffers);
+       void *buffer = getInputOperation(0)->initializeTileData(NULL);
        unlockMutex();
        return buffer;
 }
@@ -62,10 +62,10 @@ void GaussianAlphaXBlurOperation::initExecution()
        }
 }
 
-void GaussianAlphaXBlurOperation::updateGauss(MemoryBuffer **memoryBuffers)
+void GaussianAlphaXBlurOperation::updateGauss()
 {
        if (this->m_gausstab == NULL) {
-               updateSize(memoryBuffers);
+               updateSize();
                float rad = this->m_size * this->m_data->sizex;
                if (rad < 1)
                        rad = 1;
@@ -75,7 +75,7 @@ void GaussianAlphaXBlurOperation::updateGauss(MemoryBuffer **memoryBuffers)
        }
 
        if (this->m_distbuf_inv == NULL) {
-               updateSize(memoryBuffers);
+               updateSize();
                float rad = this->m_size * this->m_data->sizex;
                if (rad < 1)
                        rad = 1;
@@ -90,7 +90,7 @@ BLI_INLINE float finv_test(const float f, const bool test)
        return (LIKELY(test == false)) ? f : 1.0f - f;
 }
 
-void GaussianAlphaXBlurOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void GaussianAlphaXBlurOperation::executePixel(float *color, int x, int y, void *data)
 {
        const bool do_invert = this->m_do_subtract;
        MemoryBuffer *inputBuffer = (MemoryBuffer *)data;
index 59797c279525cb58d724c8d2d8c27b981790aa19..6ea8b7e4371192cb3dc523548027e48a8767afa0 100644 (file)
@@ -33,14 +33,14 @@ private:
        int m_falloff;  /* falloff for distbuf_inv */
        bool m_do_subtract;
        int m_rad;
-       void updateGauss(MemoryBuffer **memoryBuffers);
+       void updateGauss();
 public:
        GaussianAlphaXBlurOperation();
 
        /**
         * @brief the inner loop of this program
         */
-       void executePixel(float *color, int x, int y, MemoryBuffer * inputBuffers[], void *data);
+       void executePixel(float *color, int x, int y, void *data);
        
        /**
         * @brief initialize the execution
@@ -52,7 +52,7 @@ public:
         */
        void deinitExecution();
        
-       void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers);
+       void *initializeTileData(rcti *rect);
        bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output);
 
        /**
index ab5f8d33850bf8afbaa50f250d626c8c6d151877..323a381c86972c85fdcf08d7b8c2eff57a1f3622 100644 (file)
@@ -34,13 +34,13 @@ GaussianAlphaYBlurOperation::GaussianAlphaYBlurOperation() : BlurBaseOperation(C
        this->m_rad = 0;
 }
 
-void *GaussianAlphaYBlurOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
+void *GaussianAlphaYBlurOperation::initializeTileData(rcti *rect)
 {
        lockMutex();
        if (!this->m_sizeavailable) {
-               updateGauss(memoryBuffers);
+               updateGauss();
        }
-       void *buffer = getInputOperation(0)->initializeTileData(NULL, memoryBuffers);
+       void *buffer = getInputOperation(0)->initializeTileData(NULL);
        unlockMutex();
        return buffer;
 }
@@ -62,10 +62,10 @@ void GaussianAlphaYBlurOperation::initExecution()
        }
 }
 
-void GaussianAlphaYBlurOperation::updateGauss(MemoryBuffer **memoryBuffers)
+void GaussianAlphaYBlurOperation::updateGauss()
 {
        if (this->m_gausstab == NULL) {
-               updateSize(memoryBuffers);
+               updateSize();
                float rad = this->m_size * this->m_data->sizey;
                if (rad < 1)
                        rad = 1;
@@ -75,7 +75,7 @@ void GaussianAlphaYBlurOperation::updateGauss(MemoryBuffer **memoryBuffers)
        }
 
        if (this->m_distbuf_inv == NULL) {
-               updateSize(memoryBuffers);
+               updateSize();
                float rad = this->m_size * this->m_data->sizex;
                if (rad < 1)
                        rad = 1;
@@ -90,7 +90,7 @@ BLI_INLINE float finv_test(const float f, const bool test)
        return (LIKELY(test == false)) ? f : 1.0f - f;
 }
 
-void GaussianAlphaYBlurOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void GaussianAlphaYBlurOperation::executePixel(float *color, int x, int y, void *data)
 {
        const bool do_invert = this->m_do_subtract;
        MemoryBuffer *inputBuffer = (MemoryBuffer *)data;
index e0789db7815f7d6efeee9b024fa002afd25af67d..050b0c384cb9d888230e62349dacbdcb6af86e13 100644 (file)
@@ -33,14 +33,14 @@ private:
        bool m_do_subtract;
        int m_falloff;
        int m_rad;
-       void updateGauss(MemoryBuffer **memoryBuffers);
+       void updateGauss();
 public:
        GaussianAlphaYBlurOperation();
        
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, int x, int y, MemoryBuffer * inputBuffers[], void *data);
+       void executePixel(float *color, int x, int y, void *data);
        
        /**
         * @brief initialize the execution
@@ -52,7 +52,7 @@ public:
         */
        void deinitExecution();
        
-       void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers);
+       void *initializeTileData(rcti *rect);
        bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output);
 
        /**
index a9e8de252978c7cd3e230f267dc62ddf491ebc81..d3c4ad96df05a20402ed46f13b211154174d6c38 100644 (file)
@@ -32,13 +32,13 @@ GaussianBokehBlurOperation::GaussianBokehBlurOperation() : BlurBaseOperation(COM
        this->m_gausstab = NULL;
 }
 
-void *GaussianBokehBlurOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
+void *GaussianBokehBlurOperation::initializeTileData(rcti *rect)
 {
        lockMutex();
        if (!this->m_sizeavailable) {
-               updateGauss(memoryBuffers);
+               updateGauss();
        }
-       void *buffer = getInputOperation(0)->initializeTileData(NULL, memoryBuffers);
+       void *buffer = getInputOperation(0)->initializeTileData(NULL);
        unlockMutex();
        return buffer;
 }
@@ -50,11 +50,11 @@ void GaussianBokehBlurOperation::initExecution()
        initMutex();
 
        if (this->m_sizeavailable) {
-               updateGauss(NULL);
+               updateGauss();
        }
 }
 
-void GaussianBokehBlurOperation::updateGauss(MemoryBuffer **memoryBuffers)
+void GaussianBokehBlurOperation::updateGauss()
 {
        if (this->m_gausstab == NULL) {
                float radxf;
@@ -67,7 +67,7 @@ void GaussianBokehBlurOperation::updateGauss(MemoryBuffer **memoryBuffers)
                const float width = this->getWidth();
                const float height = this->getHeight();
                if (!this->m_sizeavailable) {
-                       updateSize(memoryBuffers);
+                       updateSize();
                }
                radxf = this->m_size * (float)this->m_data->sizex;
                if (radxf > width / 2.0f)
@@ -112,7 +112,7 @@ void GaussianBokehBlurOperation::updateGauss(MemoryBuffer **memoryBuffers)
        }
 }
 
-void GaussianBokehBlurOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void GaussianBokehBlurOperation::executePixel(float *color, int x, int y, void *data)
 {
        float tempColor[4];
        tempColor[0] = 0;
@@ -207,9 +207,9 @@ GaussianBokehBlurReferenceOperation::GaussianBokehBlurReferenceOperation() : Nod
        this->m_inputSize = NULL;
 }
 
-void *GaussianBokehBlurReferenceOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
+void *GaussianBokehBlurReferenceOperation::initializeTileData(rcti *rect)
 {
-       void *buffer = getInputOperation(0)->initializeTileData(NULL, memoryBuffers);
+       void *buffer = getInputOperation(0)->initializeTileData(NULL);
        return buffer;
 }
 
@@ -263,7 +263,7 @@ void GaussianBokehBlurReferenceOperation::updateGauss()
        this->m_gausstab = ddgauss;
 }
 
-void GaussianBokehBlurReferenceOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void GaussianBokehBlurReferenceOperation::executePixel(float *color, int x, int y, void *data)
 {
        float tempColor[4];
        float tempSize[4];
@@ -277,14 +277,14 @@ void GaussianBokehBlurReferenceOperation::executePixel(float *color, int x, int
        int bufferwidth = inputBuffer->getWidth();
        int bufferstartx = inputBuffer->getRect()->xmin;
        int bufferstarty = inputBuffer->getRect()->ymin;
-       this->m_inputSize->read(tempSize, x, y, inputBuffers, data);
+       this->m_inputSize->read(tempSize, x, y, data);
        float size = tempSize[0];
        CLAMP(size, 0.0f, 1.0f);
        float sizeX = ceil(this->m_data->sizex * size);
        float sizeY = ceil(this->m_data->sizey * size);
 
        if (sizeX <= 0.5f && sizeY <= 0.5f) {
-               this->m_inputImage->read(color, x, y, inputBuffers, data);
+               this->m_inputImage->read(color, x, y, data);
                return;
        }
        
index ea3da65cbd9ae9a37119386620f6254c95eb5d1b..1a134c20e630385557621b43c7d1b6a85e8a43a7 100644 (file)
@@ -30,16 +30,16 @@ class GaussianBokehBlurOperation : public BlurBaseOperation {
 private:
        float *m_gausstab;
        int m_radx, m_rady;
-       void updateGauss(MemoryBuffer **memoryBuffers);
+       void updateGauss();
 
 public:
        GaussianBokehBlurOperation();
        void initExecution();
-       void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers);
+       void *initializeTileData(rcti *rect);
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, int x, int y, MemoryBuffer * inputBuffers[], void *data);
+       void executePixel(float *color, int x, int y, void *data);
        
        /**
         * Deinitialize the execution
@@ -66,11 +66,11 @@ private:
 public:
        GaussianBokehBlurReferenceOperation();
        void initExecution();
-       void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers);
+       void *initializeTileData(rcti *rect);
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, int x, int y, MemoryBuffer * inputBuffers[], void *data);
+       void executePixel(float *color, int x, int y, void *data);
        
        /**
         * Deinitialize the execution
index 70148da46db65a3a675a1e4301f66c910feef3e7..1acd9f21b1a2288dff79c4694b2055d3c26fb1c5 100644 (file)
@@ -33,13 +33,13 @@ GaussianXBlurOperation::GaussianXBlurOperation() : BlurBaseOperation(COM_DT_COLO
        this->m_rad = 0;
 }
 
-void *GaussianXBlurOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
+void *GaussianXBlurOperation::initializeTileData(rcti *rect)
 {
        lockMutex();
        if (!this->m_sizeavailable) {
-               updateGauss(memoryBuffers);
+               updateGauss();
        }
-       void *buffer = getInputOperation(0)->initializeTileData(NULL, memoryBuffers);
+       void *buffer = getInputOperation(0)->initializeTileData(NULL);
        unlockMutex();
        return buffer;
 }
@@ -60,10 +60,10 @@ void GaussianXBlurOperation::initExecution()
        }
 }
 
-void GaussianXBlurOperation::updateGauss(MemoryBuffer **memoryBuffers)
+void GaussianXBlurOperation::updateGauss()
 {
        if (this->m_gausstab == NULL) {
-               updateSize(memoryBuffers);
+               updateSize();
                float rad = this->m_size * this->m_data->sizex;
                if (rad < 1)
                        rad = 1;
@@ -73,7 +73,7 @@ void GaussianXBlurOperation::updateGauss(MemoryBuffer **memoryBuffers)
        }
 }
 
-void GaussianXBlurOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void GaussianXBlurOperation::executePixel(float *color, int x, int y, void *data)
 {
        float color_accum[4] = {0.0f, 0.0f, 0.0f, 0.0f};
        float multiplier_accum = 0.0f;
index 9b5c2131b74d70c84cf01bfef9e0f07bd869a2c1..a4a0dc655e261a9c3f70e22ddf890a668bddc266 100644 (file)
@@ -29,14 +29,14 @@ class GaussianXBlurOperation : public BlurBaseOperation {
 private:
        float *m_gausstab;
        int m_rad;
-       void updateGauss(MemoryBuffer **memoryBuffers);
+       void updateGauss();
 public:
        GaussianXBlurOperation();
 
        /**
         * @brief the inner loop of this program
         */
-       void executePixel(float *color, int x, int y, MemoryBuffer * inputBuffers[], void *data);
+       void executePixel(float *color, int x, int y, void *data);
        
        /**
         * @brief initialize the execution
@@ -48,7 +48,7 @@ public:
         */
        void deinitExecution();
        
-       void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers);
+       void *initializeTileData(rcti *rect);
        bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output);
 };
 #endif
index 478495ec3be1be02119110c093b0a9bd8c436949..7ed455a115627919481e5b923784624af2f8720c 100644 (file)
@@ -33,13 +33,13 @@ GaussianYBlurOperation::GaussianYBlurOperation() : BlurBaseOperation(COM_DT_COLO
        this->m_rad = 0;
 }
 
-void *GaussianYBlurOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
+void *GaussianYBlurOperation::initializeTileData(rcti *rect)
 {
        lockMutex();
        if (!this->m_sizeavailable) {
-               updateGauss(memoryBuffers);
+               updateGauss();
        }
-       void *buffer = getInputOperation(0)->initializeTileData(NULL, memoryBuffers);
+       void *buffer = getInputOperation(0)->initializeTileData(NULL);
        unlockMutex();
        return buffer;
 }
@@ -60,10 +60,10 @@ void GaussianYBlurOperation::initExecution()
        }
 }
 
-void GaussianYBlurOperation::updateGauss(MemoryBuffer **memoryBuffers)
+void GaussianYBlurOperation::updateGauss()
 {
        if (this->m_gausstab == NULL) {
-               updateSize(memoryBuffers);
+               updateSize();
                float rad = this->m_size * this->m_data->sizey;
                if (rad < 1)
                        rad = 1;
@@ -73,7 +73,7 @@ void GaussianYBlurOperation::updateGauss(MemoryBuffer **memoryBuffers)
        }
 }
 
-void GaussianYBlurOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void GaussianYBlurOperation::executePixel(float *color, int x, int y, void *data)
 {
        float color_accum[4] = {0.0f, 0.0f, 0.0f, 0.0f};
        float multiplier_accum = 0.0f;
index f4d40c231dcaa2d7728bbbc93111628cd738b381..e3e0d8891d31104e807a01475e0a6eb952b2e2d2 100644 (file)
@@ -29,14 +29,14 @@ class GaussianYBlurOperation : public BlurBaseOperation {
 private:
        float *m_gausstab;
        int m_rad;
-       void updateGauss(MemoryBuffer **memoryBuffers);
+       void updateGauss();
 public:
        GaussianYBlurOperation();
        
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, int x, int y, MemoryBuffer * inputBuffers[], void *data);
+       void executePixel(float *color, int x, int y, void *data);
        
        /**
         * @brief initialize the execution
@@ -48,7 +48,7 @@ public:
         */
        void deinitExecution();
        
-       void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers);
+       void *initializeTileData(rcti *rect);
        bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output);
 };
 #endif
index a6678fdecefe2f54f4c9cb5cdc882d0c366decf4..8bfc3e436dffb83c9ff32a901a85faf7b85d4b90 100644 (file)
@@ -41,9 +41,9 @@ void GlareBaseOperation::deinitExecution()
        SingleThreadedNodeOperation::deinitExecution();
 }
 
-MemoryBuffer *GlareBaseOperation::createMemoryBuffer(rcti *rect2, MemoryBuffer **memoryBuffers)
+MemoryBuffer *GlareBaseOperation::createMemoryBuffer(rcti *rect2)
 {
-       MemoryBuffer *tile = (MemoryBuffer *)this->m_inputProgram->initializeTileData(rect2, memoryBuffers);
+       MemoryBuffer *tile = (MemoryBuffer *)this->m_inputProgram->initializeTileData(rect2);
        rcti rect;
        rect.xmin = 0;
        rect.ymin = 0;
index 6104ec7a81e1c429b548ae11ffb2bfe336d67046..f6a8f6879da2461db1422dbda1cd6db6b138909e 100644 (file)
@@ -68,7 +68,7 @@ protected:
 
        virtual void generateGlare(float *data, MemoryBuffer *inputTile, NodeGlare *settings) = 0;
 
-       MemoryBuffer *createMemoryBuffer(rcti *rect, MemoryBuffer **memoryBuffers);
+       MemoryBuffer *createMemoryBuffer(rcti *rect);
 
 };
 #endif
index 6d8c567c1b5147763decc66e18b2843e0e887290..7f32618d2afe83c36f1fe1c2697f1d62b94ab4cf 100644 (file)
@@ -42,11 +42,11 @@ void GlareThresholdOperation::initExecution()
        this->m_inputProgram = this->getInputSocketReader(0);
 }
 
-void GlareThresholdOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void GlareThresholdOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
        const float threshold = this->m_settings->threshold;
        
-       this->m_inputProgram->read(color, x, y, sampler, inputBuffers);
+       this->m_inputProgram->read(color, x, y, sampler);
        if (rgb_to_luma_y(color) >= threshold) {
                color[0] -= threshold, color[1] -= threshold, color[2] -= threshold;
                color[0] = MAX2(color[0], 0.0f);
index d89f3a0f29db3515526a4ee3dde66dd51de28d55..faba6c6c47c86d3946d00feca2a415e7315ba1af 100644 (file)
@@ -42,7 +42,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
 
        /**
         * Initialize the execution
index 029144870722af5601df99aec229e573053b4352..df3d00278c301d9bc798803df23ebafa56a9a5ef 100644 (file)
@@ -45,11 +45,11 @@ void HueSaturationValueCorrectOperation::initExecution()
        this->m_inputProgram = this->getInputSocketReader(0);
 }
 
-void HueSaturationValueCorrectOperation::executePixel(float *output, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void HueSaturationValueCorrectOperation::executePixel(float *output, float x, float y, PixelSampler sampler)
 {
        float hsv[4], f;
 
-       this->m_inputProgram->read(hsv, x, y, sampler, inputBuffers);
+       this->m_inputProgram->read(hsv, x, y, sampler);
 
        /* adjust hue, scaling returned default 0.5 up to 1 */
        f = curvemapping_evaluateF(this->m_curveMapping, 0, hsv[0]);
index 7ae5f53e37066637b4c342e66eb9a63f4a0e11b1..ba565a9f7528411ade90fa1e09b14450fa0bf0ec 100644 (file)
@@ -37,7 +37,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *Vector, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *Vector, float x, float y, PixelSampler sampler);
        
        /**
         * Initialize the execution
index c84124368be4dadc14f3a95bc4271c9dd0e94bce..daa2ac9299e9caba38a2e75eb9daa2c382609a07 100644 (file)
@@ -33,11 +33,11 @@ void IDMaskOperation::initExecution()
        this->m_inputProgram = this->getInputSocketReader(0);
 }
 
-void IDMaskOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void IDMaskOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
        float inputValue[4];
        
-       this->m_inputProgram->read(inputValue, x, y, sampler, inputBuffers);
+       this->m_inputProgram->read(inputValue, x, y, sampler);
        const float a = (inputValue[0] == this->m_objectIndex) ? 1.0f : 0.0f;
        color[0] = a;
 }
index 23e8ec704e863300529f70c55bf0d2d744380ce8..9d356536499fcb74b3795bd53933f17760b12e9f 100644 (file)
@@ -39,7 +39,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
        
        /**
         * Initialize the execution
index eb2eaa8167a026db668e874fb7d16b69844a232e..729b3f8f18f97ceef2045f4df22e88019602b26b 100644 (file)
@@ -108,7 +108,7 @@ void BaseImageOperation::determineResolution(unsigned int resolution[], unsigned
        }
 }
 
-void ImageOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ImageOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
        if (this->m_imageBuffer == NULL || x < 0 || y < 0 || x >= this->getWidth() || y >= this->getHeight() ) {
                zero_v4(color);
@@ -128,7 +128,7 @@ void ImageOperation::executePixel(float *color, float x, float y, PixelSampler s
        }
 }
 
-void ImageAlphaOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ImageAlphaOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
        float tempcolor[4];
 
@@ -152,7 +152,7 @@ void ImageAlphaOperation::executePixel(float *color, float x, float y, PixelSamp
        }
 }
 
-void ImageDepthOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void ImageDepthOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
        if (this->m_depthBuffer == NULL || x < 0 || y < 0 || x >= this->getWidth() || y >= this->getHeight() ) {
                color[0] = 0.0f;
index c87b06b9c4d60f132c8ef9cbd4f25f58b8dd2ffb..847096c7d43c81189e6ef97c65a8df717b7af21f 100644 (file)
@@ -73,7 +73,7 @@ public:
         * Constructor
         */
        ImageOperation();
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
 };
 class ImageAlphaOperation : public BaseImageOperation {
 public:
@@ -81,7 +81,7 @@ public:
         * Constructor
         */
        ImageAlphaOperation();
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
 };
 class ImageDepthOperation : public BaseImageOperation {
 public:
@@ -89,6 +89,6 @@ public:
         * Constructor
         */
        ImageDepthOperation();
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
 };
 #endif
index 9e9c2522d66ab36128ca809d8f8c63fc4ebbcaad..0802d2d2523999db0ee7dd746d87dd6c9f929f3e 100644 (file)
@@ -39,12 +39,12 @@ void InvertOperation::initExecution()
        this->m_inputColorProgram = this->getInputSocketReader(1);
 }
 
-void InvertOperation::executePixel(float *out, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void InvertOperation::executePixel(float *out, float x, float y, PixelSampler sampler)
 {
        float inputValue[4];
        float inputColor[4];
-       this->m_inputValueProgram->read(inputValue, x, y, sampler, inputBuffers);
-       this->m_inputColorProgram->read(inputColor, x, y, sampler, inputBuffers);
+       this->m_inputValueProgram->read(inputValue, x, y, sampler);
+       this->m_inputColorProgram->read(inputColor, x, y, sampler);
        
        const float value = inputValue[0];
        const float invertedValue = 1.0f - value;
index f00a3fb739d8dee11332b053242872154f0f5faa..46a5d80b04a192db3080d5c67f43667840d906a5 100644 (file)
@@ -42,7 +42,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
        
        /**
         * Initialize the execution
index 3285bd32039e426ca6efdcfb4b58ac5207537d2e..00ea5877d630e6222bc327571ec7958a30ffb28b 100644 (file)
@@ -39,14 +39,14 @@ KeyingBlurOperation::KeyingBlurOperation() : NodeOperation()
        this->setComplex(true);
 }
 
-void *KeyingBlurOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
+void *KeyingBlurOperation::initializeTileData(rcti *rect)
 {
-       void *buffer = getInputOperation(0)->initializeTileData(rect, memoryBuffers);
+       void *buffer = getInputOperation(0)->initializeTileData(rect);
 
        return buffer;
 }
 
-void KeyingBlurOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void KeyingBlurOperation::executePixel(float *color, int x, int y, void *data)
 {
        MemoryBuffer *inputBuffer = (MemoryBuffer *)data;
        float *buffer = inputBuffer->getBuffer();
index 6e08712bf390746b0e3dbcad86db21180b7b7468..84406c33c2874b53d4e5182b5a211b31477557fb 100644 (file)
@@ -45,9 +45,9 @@ public:
        void setSize(int value) {this->m_size = value;}
        void setAxis(int value) {this->m_axis = value;}
 
-       void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers);
+       void *initializeTileData(rcti *rect);
 
-       void executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data);
+       void executePixel(float *color, int x, int y, void *data);
 
        bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output);
 };
index 8f7d7fbf6254935fa43b543056e9fcbdd848a39c..d8afaceb37bfde6638f791642bdefb3b9a1cee77 100644 (file)
@@ -44,14 +44,14 @@ KeyingClipOperation::KeyingClipOperation() : NodeOperation()
        this->setComplex(true);
 }
 
-void *KeyingClipOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
+void *KeyingClipOperation::initializeTileData(rcti *rect)
 {
-       void *buffer = getInputOperation(0)->initializeTileData(rect, memoryBuffers);
+       void *buffer = getInputOperation(0)->initializeTileData(rect);
 
        return buffer;
 }
 
-void KeyingClipOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void KeyingClipOperation::executePixel(float *color, int x, int y, void *data)
 {
        const int delta = this->m_kernelRadius;
        const float tolerance = this->m_kernelTolerance;
index 1a8e71a306b1ae040697183112e32b115788870c..eacbccc081890d6f47346d3aaac0abfe2773b268 100644 (file)
@@ -49,9 +49,9 @@ public:
 
        void setIsEdgeMatte(bool value) {this->m_isEdgeMatte = value;}
 
-       void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers);
+       void *initializeTileData(rcti *rect);
 
-       void executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data);
+       void executePixel(float *color, int x, int y, void *data);
 
        bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output);
 };
index 9798ddcee94dfc77f0f57e14e75df4169accfabe..2f3fa2bd72a86f2cf4f1de12c9ecd40ad2fb0f37 100644 (file)
@@ -65,13 +65,13 @@ void KeyingDespillOperation::deinitExecution()
        this->m_screenReader = NULL;
 }
 
-void KeyingDespillOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void KeyingDespillOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
        float pixelColor[4];
        float screenColor[4];
 
-       this->m_pixelReader->read(pixelColor, x, y, sampler, inputBuffers);
-       this->m_screenReader->read(screenColor, x, y, sampler, inputBuffers);
+       this->m_pixelReader->read(pixelColor, x, y, sampler);
+       this->m_screenReader->read(screenColor, x, y, sampler);
 
        int screen_primary_channel = get_pixel_primary_channel(screenColor);
        int other_1 = (screen_primary_channel + 1) % 3;
index 3485bf1952fc921cfd9e40d5b6ddeba604ba4e34..c6e489057c33ec53ad3cedb539eb21255eb2f815 100644 (file)
@@ -45,7 +45,7 @@ public:
        void setDespillFactor(float value) {this->m_despillFactor = value;}
        void setColorBalance(float value) {this->m_colorBalance = value;}
 
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
 };
 
 #endif
index 48d1967b5b3714d95081cb886f31be4a2a1c43ca..5912c206a84f04e5f4167d28775c453ec7b759e7 100644 (file)
@@ -85,17 +85,17 @@ void KeyingOperation::deinitExecution()
        this->m_coreReader = NULL;
 }
 
-void KeyingOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void KeyingOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
        float pixelColor[4];
        float screenColor[4];
        float garbageValue[4];
        float coreValue[4];
 
-       this->m_pixelReader->read(pixelColor, x, y, sampler, inputBuffers);
-       this->m_screenReader->read(screenColor, x, y, sampler, inputBuffers);
-       this->m_garbageReader->read(garbageValue, x, y, sampler, inputBuffers);
-       this->m_coreReader->read(coreValue, x, y, sampler, inputBuffers);
+       this->m_pixelReader->read(pixelColor, x, y, sampler);
+       this->m_screenReader->read(screenColor, x, y, sampler);
+       this->m_garbageReader->read(garbageValue, x, y, sampler);
+       this->m_coreReader->read(coreValue, x, y, sampler);
 
        int primary_channel = get_pixel_primary_channel(screenColor);
 
index 736db54850ab3cd0c1cfa7c4f706eca162dc3fab..413aaf6a81ecb7d543aca427568b9fb4d60dcbe5 100644 (file)
@@ -51,7 +51,7 @@ public:
 
        void setScreenBalance(float value) {this->m_screenBalance = value;}
 
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
 };
 
 #endif
index 134fd8bc7fe2b88ba8da2a81090f17e1df671eb1..fd3a8d64357f4a285fa1f9dfbae8d71a3d780ca2 100644 (file)
@@ -217,7 +217,7 @@ KeyingScreenOperation::TriangulationData *KeyingScreenOperation::buildVoronoiTri
        return triangulation;
 }
 
-void *KeyingScreenOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
+void *KeyingScreenOperation::initializeTileData(rcti *rect)
 {
        TileData *tile_data;
        TriangulationData *triangulation;
@@ -272,7 +272,7 @@ void *KeyingScreenOperation::initializeTileData(rcti *rect, MemoryBuffer **memor
        return tile_data;
 }
 
-void KeyingScreenOperation::deinitializeTileData(rcti *rect, MemoryBuffer **memoryBuffers, void *data)
+void KeyingScreenOperation::deinitializeTileData(rcti *rect, void *data)
 {
        TileData *tile_data = (TileData *) data;
 
@@ -301,7 +301,7 @@ void KeyingScreenOperation::determineResolution(unsigned int resolution[], unsig
        }
 }
 
-void KeyingScreenOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void KeyingScreenOperation::executePixel(float *color, int x, int y, void *data)
 {
        color[0] = 0.0f;
        color[1] = 0.0f;
index 95815cd39307b825af97b85a5ccfde5944e81faf..f6982ef09f39fb901de3f643fef1d92c281e4ffa 100644 (file)
@@ -73,14 +73,14 @@ public:
        void initExecution();
        void deinitExecution();
 
-       void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers);
-       void deinitializeTileData(rcti *rect, MemoryBuffer **memoryBuffers, void *data);
+       void *initializeTileData(rcti *rect);
+       void deinitializeTileData(rcti *rect, void *data);
 
        void setMovieClip(MovieClip *clip) {this->m_movieClip = clip;}
        void setTrackingObject(const char *object) {strncpy(this->m_trackingObject, object, sizeof(this->m_trackingObject));}
        void setFramenumber(int framenumber) {this->m_framenumber = framenumber;}
 
-       void executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data);
+       void executePixel(float *color, int x, int y, void *data);
 };
 
 #endif
index 233f903c3e3e22ab51c8c5802f32a3b6a6d07661..7f637c127c1ff92b200f4d2f693601dffa684bad 100644 (file)
@@ -40,7 +40,7 @@ void LuminanceMatteOperation::deinitExecution()
        this->m_inputImageProgram = NULL;
 }
 
-void LuminanceMatteOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void LuminanceMatteOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
        float inColor[4];
 
@@ -49,7 +49,7 @@ void LuminanceMatteOperation::executePixel(float *outputValue, float x, float y,
 
        float alpha;
 
-       this->m_inputImageProgram->read(inColor, x, y, sampler, inputBuffers);
+       this->m_inputImageProgram->read(inColor, x, y, sampler);
        
        /* one line thread-friend algorithm:
         * outputValue[0] = max(inputValue[3], min(high, max(low, ((inColor[0]-low)/(high-low))))
index 041fd0d7ee94b6b6323f76f57afafc70169eab52..c1ab628f78737c798baa7563533d13a90a75ddf2 100644 (file)
@@ -41,7 +41,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
        
        void initExecution();
        void deinitExecution();
index dec2d0849c9608d01677958b6db306c9ad937478..a5f503a669b828bfa3e735bcf80b544472c3cc0a 100644 (file)
@@ -40,7 +40,7 @@ void MapUVOperation::initExecution()
        this->m_inputUVProgram = this->getInputSocketReader(1);
 }
 
-void MapUVOperation::executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MapUVOperation::executePixel(float *color, float x, float y, PixelSampler sampler)
 {
        float inputUV[4];
        float uv_a[4], uv_b[4];
@@ -50,30 +50,30 @@ void MapUVOperation::executePixel(float *color, float x, float y, PixelSampler s
        float uv_l, uv_r;
        float uv_u, uv_d;
 
-       this->m_inputUVProgram->read(inputUV, x, y, sampler, inputBuffers);
+       this->m_inputUVProgram->read(inputUV, x, y, sampler);
        if (inputUV[2] == 0.f) {
                zero_v4(color);
                return;
        }
        /* adaptive sampling, red (U) channel */
-       this->m_inputUVProgram->read(uv_a, x - 1, y, COM_PS_NEAREST, inputBuffers);
-       this->m_inputUVProgram->read(uv_b, x + 1, y, COM_PS_NEAREST, inputBuffers);
+       this->m_inputUVProgram->read(uv_a, x - 1, y, COM_PS_NEAREST);
+       this->m_inputUVProgram->read(uv_b, x + 1, y, COM_PS_NEAREST);
        uv_l = uv_a[2] != 0.f ? fabsf(inputUV[0] - uv_a[0]) : 0.f;
        uv_r = uv_b[2] != 0.f ? fabsf(inputUV[0] - uv_b[0]) : 0.f;
 
        dx = 0.5f * (uv_l + uv_r);
 
        /* adaptive sampling, green (V) channel */
-       this->m_inputUVProgram->read(uv_a, x, y - 1, COM_PS_NEAREST, inputBuffers);
-       this->m_inputUVProgram->read(uv_b, x, y + 1, COM_PS_NEAREST, inputBuffers);
+       this->m_inputUVProgram->read(uv_a, x, y - 1, COM_PS_NEAREST);
+       this->m_inputUVProgram->read(uv_b, x, y + 1, COM_PS_NEAREST);
        uv_u = uv_a[2] != 0.f ? fabsf(inputUV[1] - uv_a[1]) : 0.f;
        uv_d = uv_b[2] != 0.f ? fabsf(inputUV[1] - uv_b[1]) : 0.f;
 
        dy = 0.5f * (uv_u + uv_d);
 
        /* more adaptive sampling, red and green (UV) channels */
-       this->m_inputUVProgram->read(uv_a, x - 1, y - 1, COM_PS_NEAREST, inputBuffers);
-       this->m_inputUVProgram->read(uv_b, x - 1, y + 1, COM_PS_NEAREST, inputBuffers);
+       this->m_inputUVProgram->read(uv_a, x - 1, y - 1, COM_PS_NEAREST);
+       this->m_inputUVProgram->read(uv_b, x - 1, y + 1, COM_PS_NEAREST);
        uv_l = uv_a[2] != 0.f ? fabsf(inputUV[0] - uv_a[0]) : 0.f;
        uv_r = uv_b[2] != 0.f ? fabsf(inputUV[0] - uv_b[0]) : 0.f;
        uv_u = uv_a[2] != 0.f ? fabsf(inputUV[1] - uv_a[1]) : 0.f;
@@ -82,8 +82,8 @@ void MapUVOperation::executePixel(float *color, float x, float y, PixelSampler s
        dx += 0.25f * (uv_l + uv_r);
        dy += 0.25f * (uv_u + uv_d);
 
-       this->m_inputUVProgram->read(uv_a, x + 1, y - 1, COM_PS_NEAREST, inputBuffers);
-       this->m_inputUVProgram->read(uv_b, x + 1, y + 1, COM_PS_NEAREST, inputBuffers);
+       this->m_inputUVProgram->read(uv_a, x + 1, y - 1, COM_PS_NEAREST);
+       this->m_inputUVProgram->read(uv_b, x + 1, y + 1, COM_PS_NEAREST);
        uv_l = uv_a[2] != 0.f ? fabsf(inputUV[0] - uv_a[0]) : 0.f;
        uv_r = uv_b[2] != 0.f ? fabsf(inputUV[0] - uv_b[0]) : 0.f;
        uv_u = uv_a[2] != 0.f ? fabsf(inputUV[1] - uv_a[1]) : 0.f;
@@ -107,7 +107,7 @@ void MapUVOperation::executePixel(float *color, float x, float y, PixelSampler s
        u = inputUV[0] * this->m_inputColorProgram->getWidth();
        v = inputUV[1] * this->m_inputColorProgram->getHeight();
 
-       this->m_inputColorProgram->read(color, u, v, dx, dy, inputBuffers);
+       this->m_inputColorProgram->read(color, u, v, dx, dy);
 
        /* "premul" */
        if (alpha < 1.0f) {
index c14640da61c8b5875422a6605fd733f8104ec4de..ae042f6078935e9afb04750ccaa8f3fea8ed3e73 100644 (file)
@@ -45,7 +45,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
        
        /**
         * Initialize the execution
index 17d82e85723ed25535426ebab351a3bdda7b919e..96e586ccef888b9b0a876886f59e121f22067da8 100644 (file)
@@ -34,10 +34,10 @@ void MapValueOperation::initExecution()
        this->m_inputOperation = this->getInputSocketReader(0);
 }
 
-void MapValueOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MapValueOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
        float src[4];
-       this->m_inputOperation->read(src, x, y, sampler, inputBuffers);
+       this->m_inputOperation->read(src, x, y, sampler);
        TexMapping *texmap = this->m_settings;
        float value = (src[0] + texmap->loc[0]) * texmap->size[0];
        if (texmap->flag & TEXMAP_CLIP_MIN)
index fb50d0fbe4df6a5664a8b7c68c99fb0f36ed8602..a2664c32a4e4067eb82ac0b96ebe552a98d8f2f4 100644 (file)
@@ -45,7 +45,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
        
        /**
         * Initialize the execution
index 682ccf712ad7582b724ecac065ae38a82ce760bd..5674582a21a2caffb8f02b5dc3bd2cb3c507abb7 100644 (file)
@@ -70,7 +70,7 @@ void MaskOperation::deinitExecution()
        }
 }
 
-void *MaskOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
+void *MaskOperation::initializeTileData(rcti *rect)
 {
        if (this->m_rasterizedMask)
                return this->m_rasterizedMask;
@@ -117,7 +117,7 @@ void MaskOperation::determineResolution(unsigned int resolution[], unsigned int
        }
 }
 
-void MaskOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void MaskOperation::executePixel(float *color, int x, int y, void *data)
 {
        if (!data) {
                color[0] = 0.0f;
@@ -167,7 +167,7 @@ void MaskOperation::deinitExecution()
        deinitMutex();
 }
 
-void *MaskOperation::initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers)
+void *MaskOperation::initializeTileData(rcti *rect)
 {
        /* pass */
        return NULL;
@@ -191,7 +191,7 @@ void MaskOperation::determineResolution(unsigned int resolution[], unsigned int
        }
 }
 
-void MaskOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
+void MaskOperation::executePixel(float *color, int x, int y, void *data)
 {
        const float xy[2] = {x / (float)this->m_maskWidth, y / (float)this->m_maskHeight};
        color[0] = BLI_maskrasterize_handle_sample(this->m_rasterMaskHandle, xy);
index 8fb98481ec774c75d55e8b0c67ac0ac7e44a7a36..d761ee58cb91bdadce8dea95e0470d652c3821cc 100644 (file)
@@ -72,7 +72,7 @@ public:
        void initExecution();
        void deinitExecution();
 
-       void *initializeTileData(rcti *rect, MemoryBuffer **memoryBuffers);
+       void *initializeTileData(rcti *rect);
 
        void setMask(Mask *mask) { this->m_mask = mask; }
        void setMaskWidth(int width) { this->m_maskWidth = width; }
@@ -81,7 +81,7 @@ public:
        void setSmooth(bool smooth) { this->m_do_smooth = smooth; }
        void setFeather(bool feather) { this->m_do_feather = feather; }
 
-       void executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data);
+       void executePixel(float *color, int x, int y, void *data);
 };
 
 #endif
index 596895a963a6fb28dd988534ffc0bd1a9cc64aaf..6c0c27c2522d7877b344bb5d7c1eafbf4b70b2e0 100644 (file)
@@ -71,52 +71,52 @@ void MathBaseOperation::clampIfNeeded(float *color)
        }
 }
 
-void MathAddOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MathAddOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
        float inputValue1[4];
        float inputValue2[4];
        
-       this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers);
-       this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers);
+       this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler);
+       this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler);
        
        outputValue[0] = inputValue1[0] + inputValue2[0];
 
        clampIfNeeded(outputValue);
 }
 
-void MathSubtractOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MathSubtractOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
        float inputValue1[4];
        float inputValue2[4];
        
-       this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers);
-       this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers);
+       this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler);
+       this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler);
        
        outputValue[0] = inputValue1[0] - inputValue2[0];
 
        clampIfNeeded(outputValue);
 }
 
-void MathMultiplyOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MathMultiplyOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
        float inputValue1[4];
        float inputValue2[4];
        
-       this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers);
-       this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers);
+       this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler);
+       this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler);
        
        outputValue[0] = inputValue1[0] * inputValue2[0];
 
        clampIfNeeded(outputValue);
 }
 
-void MathDivideOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MathDivideOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
        float inputValue1[4];
        float inputValue2[4];
        
-       this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers);
-       this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers);
+       this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler);
+       this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler);
        
        if (inputValue2[0] == 0) /* We don't want to divide by zero. */
                outputValue[0] = 0.0;
@@ -126,52 +126,52 @@ void MathDivideOperation::executePixel(float *outputValue, float x, float y, Pix
        clampIfNeeded(outputValue);
 }
 
-void MathSineOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MathSineOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
        float inputValue1[4];
        float inputValue2[4];
        
-       this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers);
-       this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers);
+       this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler);
+       this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler);
        
        outputValue[0] = sin(inputValue1[0]);
 
        clampIfNeeded(outputValue);
 }
 
-void MathCosineOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MathCosineOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
        float inputValue1[4];
        float inputValue2[4];
        
-       this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers);
-       this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers);
+       this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler);
+       this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler);
        
        outputValue[0] = cos(inputValue1[0]);
 
        clampIfNeeded(outputValue);
 }
 
-void MathTangentOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MathTangentOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
        float inputValue1[4];
        float inputValue2[4];
        
-       this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers);
-       this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers);
+       this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler);
+       this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler);
        
        outputValue[0] = tan(inputValue1[0]);
 
        clampIfNeeded(outputValue);
 }
 
-void MathArcSineOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MathArcSineOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
        float inputValue1[4];
        float inputValue2[4];
        
-       this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers);
-       this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers);
+       this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler);
+       this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler);
        
        if (inputValue1[0] <= 1 && inputValue1[0] >= -1)
                outputValue[0] = asin(inputValue1[0]);
@@ -181,13 +181,13 @@ void MathArcSineOperation::executePixel(float *outputValue, float x, float y, Pi
        clampIfNeeded(outputValue);
 }
 
-void MathArcCosineOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MathArcCosineOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
        float inputValue1[4];
        float inputValue2[4];
        
-       this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers);
-       this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers);
+       this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler);
+       this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler);
        
        if (inputValue1[0] <= 1 && inputValue1[0] >= -1)
                outputValue[0] = acos(inputValue1[0]);
@@ -197,26 +197,26 @@ void MathArcCosineOperation::executePixel(float *outputValue, float x, float y,
        clampIfNeeded(outputValue);
 }
 
-void MathArcTangentOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MathArcTangentOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
        float inputValue1[4];
        float inputValue2[4];
        
-       this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers);
-       this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers);
+       this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler);
+       this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler);
        
        outputValue[0] = atan(inputValue1[0]);
 
        clampIfNeeded(outputValue);
 }
 
-void MathPowerOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MathPowerOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
        float inputValue1[4];
        float inputValue2[4];
        
-       this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers);
-       this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers);
+       this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler);
+       this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler);
        
        if (inputValue1[0] >= 0) {
                outputValue[0] = pow(inputValue1[0], inputValue2[0]);
@@ -235,13 +235,13 @@ void MathPowerOperation::executePixel(float *outputValue, float x, float y, Pixe
        clampIfNeeded(outputValue);
 }
 
-void MathLogarithmOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MathLogarithmOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
        float inputValue1[4];
        float inputValue2[4];
        
-       this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers);
-       this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers);
+       this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler);
+       this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler);
        
        if (inputValue1[0] > 0  && inputValue2[0] > 0)
                outputValue[0] = log(inputValue1[0]) / log(inputValue2[0]);
@@ -251,65 +251,65 @@ void MathLogarithmOperation::executePixel(float *outputValue, float x, float y,
        clampIfNeeded(outputValue);
 }
 
-void MathMinimumOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MathMinimumOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
        float inputValue1[4];
        float inputValue2[4];
        
-       this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers);
-       this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers);
+       this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler);
+       this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler);
        
        outputValue[0] = min(inputValue1[0], inputValue2[0]);
 
        clampIfNeeded(outputValue);
 }
 
-void MathMaximumOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MathMaximumOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
        float inputValue1[4];
        float inputValue2[4];
        
-       this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers);
-       this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers);
+       this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler);
+       this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler);
        
        outputValue[0] = max(inputValue1[0], inputValue2[0]);
 
        clampIfNeeded(outputValue);
 }
 
-void MathRoundOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MathRoundOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
        float inputValue1[4];
        float inputValue2[4];
        
-       this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers);
-       this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers);
+       this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler);
+       this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler);
        
        outputValue[0] = round(inputValue1[0]);
 
        clampIfNeeded(outputValue);
 }
 
-void MathLessThanOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MathLessThanOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
        float inputValue1[4];
        float inputValue2[4];
        
-       this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers);
-       this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers);
+       this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler);
+       this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler);
        
        outputValue[0] = inputValue1[0] < inputValue2[0] ? 1.0f : 0.0f;
 
        clampIfNeeded(outputValue);
 }
 
-void MathGreaterThanOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MathGreaterThanOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
        float inputValue1[4];
        float inputValue2[4];
        
-       this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler, inputBuffers);
-       this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler, inputBuffers);
+       this->m_inputValue1Operation->read(&inputValue1[0], x, y, sampler);
+       this->m_inputValue2Operation->read(&inputValue2[0], x, y, sampler);
        
        outputValue[0] = inputValue1[0] > inputValue2[0] ? 1.0f : 0.0f;
 
index e53176aea4989a826b3a4f6553d78d6f4ee58d71..8fc6c762b16a8b75c21786f7bdeaa33eb53729bf 100644 (file)
@@ -50,7 +50,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]) = 0;
+       void executePixel(float *color, float x, float y, PixelSampler sampler) = 0;
        
        /**
         * Initialize the execution
@@ -73,88 +73,88 @@ public:
 class MathAddOperation : public MathBaseOperation {
 public:
        MathAddOperation() : MathBaseOperation() {}
-       void executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *outputValue, float x, float y, PixelSampler sampler);
 };
 class MathSubtractOperation : public MathBaseOperation {
 public:
        MathSubtractOperation() : MathBaseOperation() {}
-       void executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *outputValue, float x, float y, PixelSampler sampler);
 };
 class MathMultiplyOperation : public MathBaseOperation {
 public:
        MathMultiplyOperation() : MathBaseOperation() {}
-       void executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *outputValue, float x, float y, PixelSampler sampler);
 };
 class MathDivideOperation : public MathBaseOperation {
 public:
        MathDivideOperation() : MathBaseOperation() {}
-       void executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *outputValue, float x, float y, PixelSampler sampler);
 };
 class MathSineOperation : public MathBaseOperation {
 public:
        MathSineOperation() : MathBaseOperation() {}
-       void executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *outputValue, float x, float y, PixelSampler sampler);
 };
 class MathCosineOperation : public MathBaseOperation {
 public:
        MathCosineOperation() : MathBaseOperation() {}
-       void executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *outputValue, float x, float y, PixelSampler sampler);
 };
 class MathTangentOperation : public MathBaseOperation {
 public:
        MathTangentOperation() : MathBaseOperation() {}
-       void executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *outputValue, float x, float y, PixelSampler sampler);
 };
 
 class MathArcSineOperation : public MathBaseOperation {
 public:
        MathArcSineOperation() : MathBaseOperation() {}
-       void executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *outputValue, float x, float y, PixelSampler sampler);
 };
 class MathArcCosineOperation : public MathBaseOperation {
 public:
        MathArcCosineOperation() : MathBaseOperation() {}
-       void executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *outputValue, float x, float y, PixelSampler sampler);
 };
 class MathArcTangentOperation : public MathBaseOperation {
 public:
        MathArcTangentOperation() : MathBaseOperation() {}
-       void executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *outputValue, float x, float y, PixelSampler sampler);
 };
 class MathPowerOperation : public MathBaseOperation {
 public:
        MathPowerOperation() : MathBaseOperation() {}
-       void executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *outputValue, float x, float y, PixelSampler sampler);
 };
 class MathLogarithmOperation : public MathBaseOperation {
 public:
        MathLogarithmOperation() : MathBaseOperation() {}
-       void executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *outputValue, float x, float y, PixelSampler sampler);
 };
 class MathMinimumOperation : public MathBaseOperation {
 public:
        MathMinimumOperation() : MathBaseOperation() {}
-       void executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *outputValue, float x, float y, PixelSampler sampler);
 };
 class MathMaximumOperation : public MathBaseOperation {
 public:
        MathMaximumOperation() : MathBaseOperation() {}
-       void executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *outputValue, float x, float y, PixelSampler sampler);
 };
 class MathRoundOperation : public MathBaseOperation {
 public:
        MathRoundOperation() : MathBaseOperation() {}
-       void executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *outputValue, float x, float y, PixelSampler sampler);
 };
 class MathLessThanOperation : public MathBaseOperation {
 public:
        MathLessThanOperation() : MathBaseOperation() {}
-       void executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *outputValue, float x, float y, PixelSampler sampler);
 };
 class MathGreaterThanOperation : public MathBaseOperation {
 public:
        MathGreaterThanOperation() : MathBaseOperation() {}
-       void executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *outputValue, float x, float y, PixelSampler sampler);
 };
 
 #endif
index f8bd802928d1f88de8a10746e880825221c24bf9..b49c65cc010d15228b897091cca11462f84b622c 100644 (file)
@@ -27,15 +27,15 @@ MixAddOperation::MixAddOperation() : MixBaseOperation()
        /* pass */
 }
 
-void MixAddOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MixAddOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
        float inputColor1[4];
        float inputColor2[4];
        float inputValue[4];
        
-       this->m_inputValueOperation->read(inputValue, x, y, sampler, inputBuffers);
-       this->m_inputColor1Operation->read(inputColor1, x, y, sampler, inputBuffers);
-       this->m_inputColor2Operation->read(inputColor2, x, y, sampler, inputBuffers);
+       this->m_inputValueOperation->read(inputValue, x, y, sampler);
+       this->m_inputColor1Operation->read(inputColor1, x, y, sampler);
+       this->m_inputColor2Operation->read(inputColor2, x, y, sampler);
 
 
        float value = inputValue[0];
index c5eaf0a4d77f85c9ec2f941a6425865cfe3d78b9..8fc417060738340c53b7c130d8d8c5a53ca5e9a3 100644 (file)
@@ -39,7 +39,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
 
 };
 #endif
index df9297c568be009718149c87ebee3c1a04470b8c..e9dd7078f839c1efb2113627591e75c3f246afc0 100644 (file)
@@ -41,15 +41,15 @@ void MixBaseOperation::initExecution()
        this->m_inputColor2Operation = this->getInputSocketReader(2);
 }
 
-void MixBaseOperation::executePixel(float *outputColor, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MixBaseOperation::executePixel(float *outputColor, float x, float y, PixelSampler sampler)
 {
        float inputColor1[4];
        float inputColor2[4];
        float inputValue[4];
        
-       this->m_inputValueOperation->read(inputValue, x, y, sampler, inputBuffers);
-       this->m_inputColor1Operation->read(inputColor1, x, y, sampler, inputBuffers);
-       this->m_inputColor2Operation->read(inputColor2, x, y, sampler, inputBuffers);
+       this->m_inputValueOperation->read(inputValue, x, y, sampler);
+       this->m_inputColor1Operation->read(inputColor1, x, y, sampler);
+       this->m_inputColor2Operation->read(inputColor2, x, y, sampler);
        
        float value = inputValue[0];
        if (this->useValueAlphaMultiply()) {
index 1bba28180177eec8d40e15e55bd57012a932b873..0a8ed4fa0e1839e5069f85a5a426dec77c9e6ad6 100644 (file)
@@ -59,7 +59,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
        
        /**
         * Initialize the execution
index 0c6ede017975e7d415bc95c44cd920ebd8292af6..090343e8450e82248e30dfd1f67c92fde8ed63db 100644 (file)
@@ -27,16 +27,16 @@ MixBlendOperation::MixBlendOperation() : MixBaseOperation()
        /* pass */
 }
 
-void MixBlendOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MixBlendOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
        float inputColor1[4];
        float inputColor2[4];
        float inputValue[4];
        float value;
        
-       this->m_inputValueOperation->read(inputValue, x, y, sampler, inputBuffers);
-       this->m_inputColor1Operation->read(inputColor1, x, y, sampler, inputBuffers);
-       this->m_inputColor2Operation->read(inputColor2, x, y, sampler, inputBuffers);
+       this->m_inputValueOperation->read(inputValue, x, y, sampler);
+       this->m_inputColor1Operation->read(inputColor1, x, y, sampler);
+       this->m_inputColor2Operation->read(inputColor2, x, y, sampler);
        value = inputValue[0];
        
        if (this->useValueAlphaMultiply()) {
index 16ad635bebd8547bbb7f461e9d448f19077edb31..6073ca1fc52a49ab2f7c51c29f0bf82f8b3a6629 100644 (file)
@@ -39,7 +39,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
 
 };
 #endif
index 0d736583c58b3cebca6beb1d0c8ba8e9c82cb7be..fbb3cb7b27b0d9a9e895c903cc0607ce5a139ef6 100644 (file)
@@ -27,16 +27,16 @@ MixBurnOperation::MixBurnOperation() : MixBaseOperation()
        /* pass */
 }
 
-void MixBurnOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MixBurnOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
        float inputColor1[4];
        float inputColor2[4];
        float value;
        float tmp;
        
-       this->m_inputValueOperation->read(&value, x, y, sampler, inputBuffers);
-       this->m_inputColor1Operation->read(&inputColor1[0], x, y, sampler, inputBuffers);
-       this->m_inputColor2Operation->read(&inputColor2[0], x, y, sampler, inputBuffers);
+       this->m_inputValueOperation->read(&value, x, y, sampler);
+       this->m_inputColor1Operation->read(&inputColor1[0], x, y, sampler);
+       this->m_inputColor2Operation->read(&inputColor2[0], x, y, sampler);
        
        if (this->useValueAlphaMultiply()) {
                value *= inputColor2[3];
index 7412f651ab3023c2de25c3450203612441def208..88435f05503101ef7396d55715d3ee5f324b6421 100644 (file)
@@ -39,7 +39,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
 
 };
 #endif
index e7f7eb4d656d326d884a1e10b03008460f7d2830..378cfbd9b6cc4e97d5e1d47912b94959452daccc 100644 (file)
@@ -31,15 +31,15 @@ MixColorOperation::MixColorOperation() : MixBaseOperation()
        /* pass */
 }
 
-void MixColorOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MixColorOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
        float inputColor1[4];
        float inputColor2[4];
        float value;
 
-       this->m_inputValueOperation->read(&value, x, y, sampler, inputBuffers);
-       this->m_inputColor1Operation->read(&inputColor1[0], x, y, sampler, inputBuffers);
-       this->m_inputColor2Operation->read(&inputColor2[0], x, y, sampler, inputBuffers);
+       this->m_inputValueOperation->read(&value, x, y, sampler);
+       this->m_inputColor1Operation->read(&inputColor1[0], x, y, sampler);
+       this->m_inputColor2Operation->read(&inputColor2[0], x, y, sampler);
 
        if (this->useValueAlphaMultiply()) {
                value *= inputColor2[3];
index 028ff517132126d8d780f0e1226c604efb9d7931..fb91a426f40bcb49985383450d8cfd86eb26bb34 100644 (file)
@@ -39,7 +39,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
 
 };
 #endif
index f229a89fdabfee805c6e1db43d52e5aa46355d8d..68f9c02373328fd320b4cb9f88cc9e1c011c807b 100644 (file)
@@ -27,15 +27,15 @@ MixDarkenOperation::MixDarkenOperation() : MixBaseOperation()
        /* pass */
 }
 
-void MixDarkenOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MixDarkenOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
        float inputColor1[4];
        float inputColor2[4];
        float value;
        
-       this->m_inputValueOperation->read(&value, x, y, sampler, inputBuffers);
-       this->m_inputColor1Operation->read(&inputColor1[0], x, y, sampler, inputBuffers);
-       this->m_inputColor2Operation->read(&inputColor2[0], x, y, sampler, inputBuffers);
+       this->m_inputValueOperation->read(&value, x, y, sampler);
+       this->m_inputColor1Operation->read(&inputColor1[0], x, y, sampler);
+       this->m_inputColor2Operation->read(&inputColor2[0], x, y, sampler);
        
        if (this->useValueAlphaMultiply()) {
                value *= inputColor2[3];
index 337fa1a7024696e5b315b8452e5f75e2fb26a30e..8b5afaecbd5ad337c7b040440f5480bba5e6383f 100644 (file)
@@ -39,7 +39,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
 
 };
 #endif
index 70d621822787c3ac3caf253333bce58ca1f6ee67..48964e8b78bc550d3b2139ff2636f86a8d9d85ee 100644 (file)
@@ -28,15 +28,15 @@ MixDifferenceOperation::MixDifferenceOperation() : MixBaseOperation()
        /* pass */
 }
 
-void MixDifferenceOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MixDifferenceOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
        float inputColor1[4];
        float inputColor2[4];
        float value;
        
-       this->m_inputValueOperation->read(&value, x, y, sampler, inputBuffers);
-       this->m_inputColor1Operation->read(&inputColor1[0], x, y, sampler, inputBuffers);
-       this->m_inputColor2Operation->read(&inputColor2[0], x, y, sampler, inputBuffers);
+       this->m_inputValueOperation->read(&value, x, y, sampler);
+       this->m_inputColor1Operation->read(&inputColor1[0], x, y, sampler);
+       this->m_inputColor2Operation->read(&inputColor2[0], x, y, sampler);
        
        if (this->useValueAlphaMultiply()) {
                value *= inputColor2[3];
index 503fbb691d302072c4bcba0894fbb7263afa82ff..f4ad5d07586bbfe199b60ba3d6b5b2b36e64a66a 100644 (file)
@@ -39,7 +39,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
 
 };
 #endif
index 7ca47c4f50790e5dd4b0d284594cafd13656b65c..d9d2383001bb68add9b4769792d54424e0156435 100644 (file)
@@ -27,15 +27,15 @@ MixDivideOperation::MixDivideOperation() : MixBaseOperation()
        /* pass */
 }
 
-void MixDivideOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MixDivideOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
        float inputColor1[4];
        float inputColor2[4];
        float value;
        
-       this->m_inputValueOperation->read(&value, x, y, sampler, inputBuffers);
-       this->m_inputColor1Operation->read(&inputColor1[0], x, y, sampler, inputBuffers);
-       this->m_inputColor2Operation->read(&inputColor2[0], x, y, sampler, inputBuffers);
+       this->m_inputValueOperation->read(&value, x, y, sampler);
+       this->m_inputColor1Operation->read(&inputColor1[0], x, y, sampler);
+       this->m_inputColor2Operation->read(&inputColor2[0], x, y, sampler);
        
        if (this->useValueAlphaMultiply()) {
                value *= inputColor2[3];
index db60a39f93f6bdb589bad80b386aadd433ce0bd8..8f94fc2d510b1993b311a7cb3580d0c2db84a919 100644 (file)
@@ -39,7 +39,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float *color, float x, float y, PixelSampler sampler, MemoryBuffer * inputBuffers[]);
+       void executePixel(float *color, float x, float y, PixelSampler sampler);
 
 };
 #endif
index b8ed3e252a9975ff99958ea7767f2e14f0b9b9d7..34c6e4043f2b75f98a4b9d1223979658c16d7596 100644 (file)
@@ -27,16 +27,16 @@ MixDodgeOperation::MixDodgeOperation() : MixBaseOperation()
        /* pass */
 }
 
-void MixDodgeOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler, MemoryBuffer *inputBuffers[])
+void MixDodgeOperation::executePixel(float *outputValue, float x, float y, PixelSampler sampler)
 {
        float inputColor1[4];
        float inputColor2[4];
        float value;
        float tmp;
 
-       this->m_inputValueOperation->read(&value, x, y, sampler, inputBuffers);
-       this->m_inputColor1Operation->read(&inputColor1[0], x, y, sampler, inputBuffers);
-       this->m_inputColor2Operation->read(&inputColor2[0], x, y, sampler, inputBuffers);
+       this->m_inputValueOperation->read(&value, x, y, sampler);
+       this->m_inputColor1Operation->read(&inputColor1[0], x, y, sampler);
+       this->m_inputColor2Operation->read(&inputColor2[0], x, y,