Cleanup: Renamed compositor executePixel functions and their 'read' wrappers in Socke...
authorLukas Tönne <lukas.toenne@gmail.com>
Tue, 19 Nov 2013 10:06:16 +0000 (11:06 +0100)
committerLukas Tönne <lukas.toenne@gmail.com>
Tue, 19 Nov 2013 10:06:16 +0000 (11:06 +0100)
Distinguish the 3 different methods for acquiring pixel color values (executePixel, executePixelSampled, executePixelFiltered).
This makes it easier to keep track of the different sampling methods (and works nicer with IDEs that do code parsing).

Differential Revision: http://developer.blender.org/D7

147 files changed:
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_BlurBaseOperation.cpp
source/blender/compositor/operations/COM_BokehBlurOperation.cpp
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_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_CompositorOperation.cpp
source/blender/compositor/operations/COM_ConvertColorProfileOperation.cpp
source/blender/compositor/operations/COM_ConvertColorProfileOperation.h
source/blender/compositor/operations/COM_ConvertDepthToRadiusOperation.cpp
source/blender/compositor/operations/COM_ConvertDepthToRadiusOperation.h
source/blender/compositor/operations/COM_ConvertOperation.cpp
source/blender/compositor/operations/COM_ConvertOperation.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_DirectionalBlurOperation.cpp
source/blender/compositor/operations/COM_DisplaceOperation.cpp
source/blender/compositor/operations/COM_DisplaceSimpleOperation.cpp
source/blender/compositor/operations/COM_DisplaceSimpleOperation.h
source/blender/compositor/operations/COM_DistanceRGBMatteOperation.cpp
source/blender/compositor/operations/COM_DistanceRGBMatteOperation.h
source/blender/compositor/operations/COM_DotproductOperation.cpp
source/blender/compositor/operations/COM_DotproductOperation.h
source/blender/compositor/operations/COM_EllipseMaskOperation.cpp
source/blender/compositor/operations/COM_EllipseMaskOperation.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_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_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_LuminanceMatteOperation.cpp
source/blender/compositor/operations/COM_LuminanceMatteOperation.h
source/blender/compositor/operations/COM_MapRangeOperation.cpp
source/blender/compositor/operations/COM_MapRangeOperation.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_MixOperation.cpp
source/blender/compositor/operations/COM_MixOperation.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_OutputFileOperation.cpp
source/blender/compositor/operations/COM_PixelateOperation.cpp
source/blender/compositor/operations/COM_PixelateOperation.h
source/blender/compositor/operations/COM_PlaneTrackMaskOperation.cpp
source/blender/compositor/operations/COM_PlaneTrackMaskOperation.h
source/blender/compositor/operations/COM_PlaneTrackWarpImageOperation.cpp
source/blender/compositor/operations/COM_PlaneTrackWarpImageOperation.h
source/blender/compositor/operations/COM_PreviewOperation.cpp
source/blender/compositor/operations/COM_ProjectorLensDistortionOperation.cpp
source/blender/compositor/operations/COM_ReadBufferOperation.cpp
source/blender/compositor/operations/COM_ReadBufferOperation.h
source/blender/compositor/operations/COM_RenderLayersProg.cpp
source/blender/compositor/operations/COM_RenderLayersProg.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_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_SplitOperation.cpp
source/blender/compositor/operations/COM_SplitOperation.h
source/blender/compositor/operations/COM_TextureOperation.cpp
source/blender/compositor/operations/COM_TextureOperation.h
source/blender/compositor/operations/COM_TrackPositionOperation.cpp
source/blender/compositor/operations/COM_TrackPositionOperation.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_VectorCurveOperation.cpp
source/blender/compositor/operations/COM_VectorCurveOperation.h
source/blender/compositor/operations/COM_ViewerOperation.cpp
source/blender/compositor/operations/COM_WrapOperation.cpp
source/blender/compositor/operations/COM_WrapOperation.h
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 b7aae8b92f0b8bace1d9e3a4befc13d1fbecb15f..2eaeb664c6739aa8ce63d47bf2c85ef43fbaf1ad 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 output[4], float x, float y, PixelSampler sampler) {}
+       virtual void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) {}
 
        /**
         * @brief calculate a single pixel
@@ -75,7 +75,7 @@ protected:
         * @param chunkData chunk specific data a during execution time.
         */
        virtual void executePixel(float output[4], int x, int y, void *chunkData) {
-               executePixel(output, x, y, COM_PS_NEAREST);
+               executePixelSampled(output, x, y, COM_PS_NEAREST);
        }
 
        /**
@@ -88,17 +88,17 @@ protected:
         * @param dy
         * @param inputBuffers chunks that can be read by their ReadBufferOperation.
         */
-       virtual void executePixel(float output[4], float x, float y, float dx, float dy, PixelSampler sampler) {}
+       virtual void executePixelFiltered(float output[4], float x, float y, float dx, float dy, PixelSampler sampler) {}
 
 public:
-       inline void read(float result[4], float x, float y, PixelSampler sampler) {
-               executePixel(result, x, y, sampler);
+       inline void readSampled(float result[4], float x, float y, PixelSampler sampler) {
+               executePixelSampled(result, x, y, sampler);
        }
        inline void read(float result[4], int x, int y, void *chunkData) {
                executePixel(result, x, y, chunkData);
        }
-       inline void read(float result[4], float x, float y, float dx, float dy, PixelSampler sampler) {
-               executePixel(result, x, y, dx, dy, sampler);
+       inline void readFiltered(float result[4], float x, float y, float dx, float dy, PixelSampler sampler) {
+               executePixelFiltered(result, x, y, dx, dy, sampler);
        }
 
        virtual void *initializeTileData(rcti *rect) { return 0; }
index 6cc9aae4553b89ea181a698c9d8d5247bc001df2..d4103a6168546bd252bddc6f88d8656c8ac804ff 100644 (file)
@@ -27,15 +27,15 @@ AlphaOverKeyOperation::AlphaOverKeyOperation() : MixBaseOperation()
        /* pass */
 }
 
-void AlphaOverKeyOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void AlphaOverKeyOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputColor1[4];
        float inputOverColor[4];
        float value[4];
        
-       this->m_inputValueOperation->read(value, x, y, sampler);
-       this->m_inputColor1Operation->read(inputColor1, x, y, sampler);
-       this->m_inputColor2Operation->read(inputOverColor, x, y, sampler);
+       this->m_inputValueOperation->readSampled(value, x, y, sampler);
+       this->m_inputColor1Operation->readSampled(inputColor1, x, y, sampler);
+       this->m_inputColor2Operation->readSampled(inputOverColor, x, y, sampler);
        
        if (inputOverColor[3] <= 0.0f) {
                copy_v4_v4(output, inputColor1);
index 31b0422918aff1e8b6e31bbcdc232d5d1494dbe4..eceee43e600dd9260254f4a82c930afcdc0cc319 100644 (file)
@@ -39,6 +39,6 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 #endif
index 111dc899e1d08659a22c499a4a6852f747046d91..1dba542e142c0be9a55f96ceeff225a9e52abae1 100644 (file)
@@ -27,15 +27,15 @@ AlphaOverMixedOperation::AlphaOverMixedOperation() : MixBaseOperation()
        this->m_x = 0.0f;
 }
 
-void AlphaOverMixedOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void AlphaOverMixedOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputColor1[4];
        float inputOverColor[4];
        float value[4];
        
-       this->m_inputValueOperation->read(value, x, y, sampler);
-       this->m_inputColor1Operation->read(inputColor1, x, y, sampler);
-       this->m_inputColor2Operation->read(inputOverColor, x, y, sampler);
+       this->m_inputValueOperation->readSampled(value, x, y, sampler);
+       this->m_inputColor1Operation->readSampled(inputColor1, x, y, sampler);
+       this->m_inputColor2Operation->readSampled(inputOverColor, x, y, sampler);
        
        if (inputOverColor[3] <= 0.0f) {
                copy_v4_v4(output, inputColor1);
index 14e7325ec1d4c5b5f17263c173a02ce430bbd0eb..ff6d1a978b89c689e814d55f47e1183179eafd87 100644 (file)
@@ -41,7 +41,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
        
        void setX(float x) { this->m_x = x; }
 };
index ac7906f2f9814e59a8177fae5c81d151835d3cc5..60a2fd6a44296c925237235ede57e0f8df06bc7d 100644 (file)
@@ -27,15 +27,15 @@ AlphaOverPremultiplyOperation::AlphaOverPremultiplyOperation() : MixBaseOperatio
        /* pass */
 }
 
-void AlphaOverPremultiplyOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void AlphaOverPremultiplyOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputColor1[4];
        float inputOverColor[4];
        float value[4];
        
-       this->m_inputValueOperation->read(value, x, y, sampler);
-       this->m_inputColor1Operation->read(inputColor1, x, y, sampler);
-       this->m_inputColor2Operation->read(inputOverColor, x, y, sampler);
+       this->m_inputValueOperation->readSampled(value, x, y, sampler);
+       this->m_inputColor1Operation->readSampled(inputColor1, x, y, sampler);
+       this->m_inputColor2Operation->readSampled(inputOverColor, x, y, sampler);
        
        /* Zero alpha values should still permit an add of RGB data */
        if (inputOverColor[3] < 0.0f) {
index 16bd2aeaeedd263e4b0f2d2c9be8642a38573026..db68583baa6f16aa1b31516f86a6ee0d4a823860 100644 (file)
@@ -39,7 +39,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 
 };
 #endif
index cc91210a3858af7ac249ed94ab34ef13e68d45be..dfff2bfeafbf0765b90319d4494bee468d70bebf 100644 (file)
@@ -152,7 +152,7 @@ void BlurBaseOperation::updateSize()
 {
        if (!this->m_sizeavailable) {
                float result[4];
-               this->getInputSocketReader(1)->read(result, 0, 0, COM_PS_NEAREST);
+               this->getInputSocketReader(1)->readSampled(result, 0, 0, COM_PS_NEAREST);
                this->m_size = result[0];
                this->m_sizeavailable = true;
        }
index 1c91af2a7a354737e5944e35bc3ffc549575c93e..7f17db1d31bca11a85fc1f661a43b51c77232ce5 100644 (file)
@@ -80,7 +80,7 @@ void BokehBlurOperation::executePixel(float output[4], int x, int y, void *data)
        float tempBoundingBox[4];
        float bokeh[4];
 
-       this->m_inputBoundingBoxReader->read(tempBoundingBox, x, y, COM_PS_NEAREST);
+       this->m_inputBoundingBoxReader->readSampled(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;
@@ -93,7 +93,7 @@ void BokehBlurOperation::executePixel(float output[4], int x, int y, void *data)
                zero_v4(color_accum);
 
                if (pixelSize < 2) {
-                       this->m_inputProgram->read(color_accum, x, y, COM_PS_NEAREST);
+                       this->m_inputProgram->readSampled(color_accum, x, y, COM_PS_NEAREST);
                        multiplier_accum[0] = 1.0f;
                        multiplier_accum[1] = 1.0f;
                        multiplier_accum[2] = 1.0f;
@@ -118,7 +118,7 @@ void BokehBlurOperation::executePixel(float output[4], int x, int y, void *data)
                        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);
+                               this->m_inputBokehProgram->readSampled(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 output[4], int x, int y, void *data)
                output[3] = color_accum[3] * (1.0f / multiplier_accum[3]);
        }
        else {
-               this->m_inputProgram->read(output, x, y, COM_PS_NEAREST);
+               this->m_inputProgram->readSampled(output, x, y, COM_PS_NEAREST);
        }
 }
 
@@ -220,7 +220,7 @@ void BokehBlurOperation::updateSize()
 {
        if (!this->m_sizeavailable) {
                float result[4];
-               this->getInputSocketReader(3)->read(result, 0, 0, COM_PS_NEAREST);
+               this->getInputSocketReader(3)->readSampled(result, 0, 0, COM_PS_NEAREST);
                this->m_size = result[0];
                CLAMP(this->m_size, 0.0f, 10.0f);
                this->m_sizeavailable = true;
index b87be33eca19929ea926f3a26161e7fb086303f0..82de750de72124770024f92249521c04ff6d6fe0 100644 (file)
@@ -85,7 +85,7 @@ float BokehImageOperation::isInsideBokeh(float distance, float x, float y)
        }
        return insideBokeh;
 }
-void BokehImageOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void BokehImageOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float shift = this->m_data->lensshift;
        float shift2 = shift / 2.0f;
index 44c4c0cfe2773b306a0fd2733e2815c57d590bcd..f1f0f1ed11cc315143a396c8aabd622f62b0cfba 100644 (file)
@@ -111,7 +111,7 @@ public:
        /**
         * @brief the inner loop of this program
         */
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
        
        /**
         * @brief Initialize the execution
index 52f844627618a294ec83da66375b4c2c52ed9e3e..4dd92aec4c80a02123df44a9eb5d68c52e7c9999 100644 (file)
@@ -44,7 +44,7 @@ void BoxMaskOperation::initExecution()
        this->m_aspectRatio = ((float)this->getWidth()) / this->getHeight();
 }
 
-void BoxMaskOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void BoxMaskOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputMask[4];
        float inputValue[4];
@@ -57,8 +57,8 @@ void BoxMaskOperation::executePixel(float output[4], float x, float y, PixelSamp
        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);
-       this->m_inputValue->read(inputValue, x, y, sampler);
+       this->m_inputMask->readSampled(inputMask, x, y, sampler);
+       this->m_inputValue->readSampled(inputValue, x, y, sampler);
        
        float halfHeight = this->m_data->height / 2.0f;
        float halfWidth = this->m_data->width / 2.0f;
index f39d74829d4e48d867f88becca11ca02c09850a3..04dc8a90fd700d687aa13e26f4f29bd69b5e1757 100644 (file)
@@ -45,7 +45,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
        
        /**
         * Initialize the execution
index 0613540250c222b8c8f5dbee3b6fff297457ed98..33e35c3fe3bbf5b9afbd746c41983aab46e9654c 100644 (file)
@@ -37,15 +37,15 @@ void BrightnessOperation::initExecution()
        this->m_inputContrastProgram = this->getInputSocketReader(2);
 }
 
-void BrightnessOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void BrightnessOperation::executePixelSampled(float output[4], 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);
-       this->m_inputBrightnessProgram->read(inputBrightness, x, y, sampler);
-       this->m_inputContrastProgram->read(inputContrast, x, y, sampler);
+       this->m_inputProgram->readSampled(inputValue, x, y, sampler);
+       this->m_inputBrightnessProgram->readSampled(inputBrightness, x, y, sampler);
+       this->m_inputContrastProgram->readSampled(inputContrast, x, y, sampler);
        float brightness = inputBrightness[0];
        float contrast = inputContrast[0];
        brightness /= 100.0f;
index 1c8eda63e940d4eb2630a82676696952aa45052b..22086ae11e83cc43f55a0ae1614acebb8c221df0 100644 (file)
@@ -40,7 +40,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
        
        /**
         * Initialize the execution
index e6e93774685091c8ea29e75964ace9ec51d8d113..964f1d6466797d14b5619c0ec234c1c198c13981 100644 (file)
@@ -39,11 +39,11 @@ void ChangeHSVOperation::deinitExecution()
        this->m_inputOperation = NULL;
 }
 
-void ChangeHSVOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void ChangeHSVOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputColor1[4];
        
-       this->m_inputOperation->read(inputColor1, x, y, sampler);
+       this->m_inputOperation->readSampled(inputColor1, x, y, sampler);
        
        output[0] = inputColor1[0] + (this->m_hue - 0.5f);
        if      (output[0] > 1.0f) output[0] -= 1.0f;
index 01852084e417b6bfcc93565df46055c4dc6f4a80..76025e86b7a013215cf63fe38f1a3fdec34605b9 100644 (file)
@@ -49,7 +49,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 
        void setHue(float hue) { this->m_hue = hue; }
        void setSaturation(float saturation) { this->m_saturation = saturation; }
index 84cc8aad9500fe791859e23804483192f08c6633..14494841c498eb13f4a5f18db51dd42cfce06c35 100644 (file)
@@ -88,7 +88,7 @@ void ChannelMatteOperation::deinitExecution()
        this->m_inputImageProgram = NULL;
 }
 
-void ChannelMatteOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void ChannelMatteOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inColor[4];
        float alpha;
@@ -97,7 +97,7 @@ void ChannelMatteOperation::executePixel(float output[4], float x, float y, Pixe
        const float limit_min = this->m_limit_min;
        const float limit_range = this->m_limit_range;
 
-       this->m_inputImageProgram->read(inColor, x, y, sampler);
+       this->m_inputImageProgram->readSampled(inColor, x, y, sampler);
 
        /* matte operation */
        alpha = inColor[this->m_ids[0]] - max(inColor[this->m_ids[1]], inColor[this->m_ids[2]]);
index efb4f7427ca699cc6f74c2294847a3c501643233..58b467e789288d7ef1576c8d1eb0f3c0ba2743b6 100644 (file)
@@ -59,7 +59,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 
        void initExecution();
        void deinitExecution();
index c2406abaa65dedb97e22a05008781cca75dad899..3329093882d73717174d4b33b1cb78ca43413abb 100644 (file)
@@ -44,7 +44,7 @@ void ChromaMatteOperation::deinitExecution()
        this->m_inputKeyProgram = NULL;
 }
 
-void ChromaMatteOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void ChromaMatteOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inKey[4];
        float inImage[4];
@@ -57,8 +57,8 @@ void ChromaMatteOperation::executePixel(float output[4], float x, float y, Pixel
        float theta, beta;
        float kfg;
 
-       this->m_inputKeyProgram->read(inKey, x, y, sampler);
-       this->m_inputImageProgram->read(inImage, x, y, sampler);
+       this->m_inputKeyProgram->readSampled(inKey, x, y, sampler);
+       this->m_inputImageProgram->readSampled(inImage, x, y, sampler);
 
        /* store matte(alpha) value in [0] to go with
         * COM_SetAlphaOperation and the Value output
index 9557faec8557e6c3dac6c40c1da6c1af6fcec05e..a68790838c032f556261c046c2e0f00bb1c4d334 100644 (file)
@@ -42,7 +42,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 
        void initExecution();
        void deinitExecution();
index 1456aaf6a552bdd0143bc28f51e13ca1c2a2e483..2846642570ca6c1563229a5e40bf4684db93f99f 100644 (file)
@@ -49,13 +49,13 @@ void ColorBalanceASCCDLOperation::initExecution()
        this->m_inputColorOperation = this->getInputSocketReader(1);
 }
 
-void ColorBalanceASCCDLOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void ColorBalanceASCCDLOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputColor[4];
        float value[4];
        
-       this->m_inputValueOperation->read(value, x, y, sampler);
-       this->m_inputColorOperation->read(inputColor, x, y, sampler);
+       this->m_inputValueOperation->readSampled(value, x, y, sampler);
+       this->m_inputColorOperation->readSampled(inputColor, x, y, sampler);
        
        float fac = value[0];
        fac = min(1.0f, fac);
index ee0b89f7f70588291ced9c656dc40f2466d879c8..bf3495869b0cfec591ecb3ad5ae13dfe87470d07 100644 (file)
@@ -49,7 +49,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
        
        /**
         * Initialize the execution
index 7e9c10df0a91c5d6cf494ef2e9ed4a80609b534a..9588687372edc5011352d0870f7c15584efbc4a8 100644 (file)
@@ -54,13 +54,13 @@ void ColorBalanceLGGOperation::initExecution()
        this->m_inputColorOperation = this->getInputSocketReader(1);
 }
 
-void ColorBalanceLGGOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void ColorBalanceLGGOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputColor[4];
        float value[4];
        
-       this->m_inputValueOperation->read(value, x, y, sampler);
-       this->m_inputColorOperation->read(inputColor, x, y, sampler);
+       this->m_inputValueOperation->readSampled(value, x, y, sampler);
+       this->m_inputColorOperation->readSampled(inputColor, x, y, sampler);
        
        float fac = value[0];
        fac = min(1.0f, fac);
index edc824475c28ca4cc21c2478aff117779b3157d9..da3a141e3c2ab8265368ac2b568fde9b56c8e277 100644 (file)
@@ -50,7 +50,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
        
        /**
         * Initialize the execution
index b7a3f43237a385f7c353e6ce3ae44c373ff10e0f..1920995100518610e2d5f7a50e7e6862478249b4 100644 (file)
@@ -40,12 +40,12 @@ void ColorCorrectionOperation::initExecution()
        this->m_inputMask = this->getInputSocketReader(1);
 }
 
-void ColorCorrectionOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void ColorCorrectionOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputImageColor[4];
        float inputMask[4];
-       this->m_inputImage->read(inputImageColor, x, y, sampler);
-       this->m_inputMask->read(inputMask, x, y, sampler);
+       this->m_inputImage->readSampled(inputImageColor, x, y, sampler);
+       this->m_inputMask->readSampled(inputMask, x, y, sampler);
        
        float level = (inputImageColor[0] + inputImageColor[1] + inputImageColor[2]) / 3.0f;
        float contrast = this->m_data->master.contrast;
index 018e67b7adabb7c4fbd4bbd34b972e8cd033e72d..2b47d6a8034a6b333d3d9b72b1b4360289cfdb40 100644 (file)
@@ -44,7 +44,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
        
        /**
         * Initialize the execution
index 2f13a90c07248c0fe2a53f1cba5c35d617cc0ba8..1115b2ab23949e790aed7471aa18ffa8131bcb89 100644 (file)
@@ -58,7 +58,7 @@ void ColorCurveOperation::initExecution()
 
 }
 
-void ColorCurveOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void ColorCurveOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        CurveMapping *cumap = this->m_curveMapping;
        
@@ -70,15 +70,15 @@ void ColorCurveOperation::executePixel(float output[4], float x, float y, PixelS
        float white[4];
        float bwmul[3];
 
-       this->m_inputBlackProgram->read(black, x, y, sampler);
-       this->m_inputWhiteProgram->read(white, x, y, sampler);
+       this->m_inputBlackProgram->readSampled(black, x, y, sampler);
+       this->m_inputWhiteProgram->readSampled(white, x, y, sampler);
 
        /* get our own local bwmul value,
         * since we can't be threadsafe and use cumap->bwmul & friends */
        curvemapping_set_black_white_ex(black, white, bwmul);
 
-       this->m_inputFacProgram->read(fac, x, y, sampler);
-       this->m_inputImageProgram->read(image, x, y, sampler);
+       this->m_inputFacProgram->readSampled(fac, x, y, sampler);
+       this->m_inputImageProgram->readSampled(image, x, y, sampler);
 
        if (*fac >= 1.0f) {
                curvemapping_evaluate_premulRGBF_ex(cumap, output, image,
@@ -130,13 +130,13 @@ void ConstantLevelColorCurveOperation::initExecution()
        curvemapping_set_black_white(this->m_curveMapping, this->m_black, this->m_white);
 }
 
-void ConstantLevelColorCurveOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void ConstantLevelColorCurveOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float fac[4];
        float image[4];
 
-       this->m_inputFacProgram->read(fac, x, y, sampler);
-       this->m_inputImageProgram->read(image, x, y, sampler);
+       this->m_inputFacProgram->readSampled(fac, x, y, sampler);
+       this->m_inputImageProgram->readSampled(image, x, y, sampler);
 
        if (*fac >= 1.0f) {
                curvemapping_evaluate_premulRGBF(this->m_curveMapping, output, image);
index 7dc1913b85af04887dca4be3cb852b745fba40e0..1eb7755395395ca8946bd4265fca8f5a8aebeeaf 100644 (file)
@@ -41,7 +41,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
        
        /**
         * Initialize the execution
@@ -70,7 +70,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
        
        /**
         * Initialize the execution
index d73196e42f564c762e41fd0306faad4fa4b41bab..b928141f41dccc01a9aa775a1a6ddb0f5e60d04c 100644 (file)
@@ -44,7 +44,7 @@ void ColorMatteOperation::deinitExecution()
        this->m_inputKeyProgram = NULL;
 }
 
-void ColorMatteOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void ColorMatteOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inColor[4];
        float inKey[4];
@@ -55,8 +55,8 @@ void ColorMatteOperation::executePixel(float output[4], float x, float y, PixelS
 
        float h_wrap;
 
-       this->m_inputImageProgram->read(inColor, x, y, sampler);
-       this->m_inputKeyProgram->read(inKey, x, y, sampler);
+       this->m_inputImageProgram->readSampled(inColor, x, y, sampler);
+       this->m_inputKeyProgram->readSampled(inKey, x, y, sampler);
 
 
        /* store matte(alpha) value in [0] to go with
index f065a5f7e895a2071b31fd3ede0d76ddbe3478dd..53bbe8f6466c07860a75bcf557d6a97eb3fbf0c2 100644 (file)
@@ -42,7 +42,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 
        void initExecution();
        void deinitExecution();
index 1618c83aecefdaa45bca9a4fa764e1da4becbfb4..fd3380d594e608c11726316ed638d50629837225 100644 (file)
@@ -43,11 +43,11 @@ void ColorRampOperation::initExecution()
        this->m_inputProgram = this->getInputSocketReader(0);
 }
 
-void ColorRampOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void ColorRampOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float values[4];
 
-       this->m_inputProgram->read(values, x, y, sampler);
+       this->m_inputProgram->readSampled(values, x, y, sampler);
        do_colorband(this->m_colorBand, values[0], output);
 }
 
index 96d9a525e1ef1d5b325801dd2c06ad1e7cf96283..333e6c36d971b327516460cdd6cfa69bf1130fd8 100644 (file)
@@ -38,7 +38,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
        
        /**
         * Initialize the execution
index a8e8cb98564f75fbe56b618102ad4080ea66bb48..873ec72d9e9178f4e3e0465877fcaf6aafa282f5 100644 (file)
@@ -84,12 +84,12 @@ void ColorSpillOperation::deinitExecution()
        this->m_inputFacReader = NULL;
 }
 
-void ColorSpillOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void ColorSpillOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float fac[4];
        float input[4];
-       this->m_inputFacReader->read(fac, x, y, sampler);
-       this->m_inputImageReader->read(input, x, y, sampler);
+       this->m_inputFacReader->readSampled(fac, x, y, sampler);
+       this->m_inputImageReader->readSampled(input, x, y, sampler);
        float rfac = min(1.0f, fac[0]);
        float map = calculateMapValue(rfac, input);
        if (map > 0.0f) {
index 94ff78c37b24ce6bb9924c531b39254dbaea9665..f9dc9ef7e25164203faa3126ebd29867ae0e2bcf 100644 (file)
@@ -46,7 +46,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 
        void initExecution();
        void deinitExecution();
index 383682b147410c3ae189a99a0f0ae367ea779ac0..3d4b771fecc172ca4c4d277bdec4b306606c265c 100644 (file)
@@ -188,20 +188,20 @@ void CompositorOperation::executeRegion(rcti *rect, unsigned int tileNumber)
                for (x = x1; x < x2 && (!breaked); x++) {
                        int input_x = x + dx, input_y = y + dy;
 
-                       this->m_imageInput->read(color, input_x, input_y, COM_PS_NEAREST);
+                       this->m_imageInput->readSampled(color, input_x, input_y, COM_PS_NEAREST);
                        if (this->m_ignoreAlpha) {
                                color[3] = 1.0f;
                        }
                        else {
                                if (this->m_alphaInput != NULL) {
-                                       this->m_alphaInput->read(&(color[3]), input_x, input_y, COM_PS_NEAREST);
+                                       this->m_alphaInput->readSampled(&(color[3]), input_x, input_y, COM_PS_NEAREST);
                                }
                        }
 
                        copy_v4_v4(buffer + offset4, color);
 
                        if (this->m_depthInput != NULL) {
-                               this->m_depthInput->read(color, input_x, input_y, COM_PS_NEAREST);
+                               this->m_depthInput->readSampled(color, input_x, input_y, COM_PS_NEAREST);
                                zbuffer[offset] = color[0];
                        }
                        offset4 += COM_NUMBER_OF_CHANNELS;
index 79ce149e79033c92f9c3856c9546a52ec1fedae8..cb269b16bf478ee36a3fd77b4c962a9dbccd37c6 100644 (file)
@@ -38,10 +38,10 @@ void ConvertColorProfileOperation::initExecution()
        this->m_inputOperation = this->getInputSocketReader(0);
 }
 
-void ConvertColorProfileOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void ConvertColorProfileOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float color[4];
-       this->m_inputOperation->read(color, x, y, sampler);
+       this->m_inputOperation->readSampled(color, x, y, sampler);
        IMB_buffer_float_from_float(output, color, 4, this->m_toProfile, this->m_fromProfile, this->m_predivided, 1, 1, 0, 0);
 }
 
index a8cbc613fb8d52f9bcf013e8f15a7c95fc32ed9d..e68a9bdf7c1c19ad58fb690c62d3acc7f58a2acd 100644 (file)
@@ -59,7 +59,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
        
        /**
         * Initialize the execution
index f39a28b87a80a19f2760482fbc6af24a6f1a7cd8..ea1443598a9a4e687ee0ed00732ce7f92b731bac 100644 (file)
@@ -72,12 +72,12 @@ void ConvertDepthToRadiusOperation::initExecution()
        }
 }
 
-void ConvertDepthToRadiusOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void ConvertDepthToRadiusOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputValue[4];
        float z;
        float radius;
-       this->m_inputOperation->read(inputValue, x, y, sampler);
+       this->m_inputOperation->readSampled(inputValue, x, y, sampler);
        z = inputValue[0];
        if (z != 0.f) {
                float iZ = (1.f / z);
index d5a1fd72cbfd691220386d06ed19a299b2a6cf17..b92eb65d01e4e0a2a62d542d84f346632e7162f2 100644 (file)
@@ -54,7 +54,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
        
        /**
         * Initialize the execution
index d72aabb078eef912de0344e315f8d4ee1d593284..6b3e4067b18dada1423eaf3af091cda624af33b6 100644 (file)
@@ -47,10 +47,10 @@ ConvertValueToColorOperation::ConvertValueToColorOperation() : ConvertBaseOperat
        this->addOutputSocket(COM_DT_COLOR);
 }
 
-void ConvertValueToColorOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void ConvertValueToColorOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputValue[4];
-       this->m_inputOperation->read(inputValue, x, y, sampler);
+       this->m_inputOperation->readSampled(inputValue, x, y, sampler);
        output[0] = output[1] = output[2] = inputValue[0];
        output[3] = 1.0f;
 }
@@ -64,10 +64,10 @@ ConvertColorToValueOperation::ConvertColorToValueOperation() : ConvertBaseOperat
        this->addOutputSocket(COM_DT_VALUE);
 }
 
-void ConvertColorToValueOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void ConvertColorToValueOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputColor[4];
-       this->m_inputOperation->read(inputColor, x, y, sampler);
+       this->m_inputOperation->readSampled(inputColor, x, y, sampler);
        output[0] = (inputColor[0] + inputColor[1] + inputColor[2]) / 3.0f;
 }
 
@@ -80,10 +80,10 @@ ConvertColorToBWOperation::ConvertColorToBWOperation() : ConvertBaseOperation()
        this->addOutputSocket(COM_DT_VALUE);
 }
 
-void ConvertColorToBWOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void ConvertColorToBWOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputColor[4];
-       this->m_inputOperation->read(inputColor, x, y, sampler);
+       this->m_inputOperation->readSampled(inputColor, x, y, sampler);
        output[0] = rgb_to_bw(inputColor);
 }
 
@@ -96,9 +96,9 @@ ConvertColorToVectorOperation::ConvertColorToVectorOperation() : ConvertBaseOper
        this->addOutputSocket(COM_DT_VECTOR);
 }
 
-void ConvertColorToVectorOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void ConvertColorToVectorOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
-       this->m_inputOperation->read(output, x, y, sampler);
+       this->m_inputOperation->readSampled(output, x, y, sampler);
 }
 
 
@@ -110,10 +110,10 @@ ConvertValueToVectorOperation::ConvertValueToVectorOperation() : ConvertBaseOper
        this->addOutputSocket(COM_DT_VECTOR);
 }
 
-void ConvertValueToVectorOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void ConvertValueToVectorOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float input[4];
-       this->m_inputOperation->read(input, x, y, sampler);
+       this->m_inputOperation->readSampled(input, x, y, sampler);
        output[0] = input[0];
        output[1] = input[0];
        output[2] = input[0];
@@ -129,9 +129,9 @@ ConvertVectorToColorOperation::ConvertVectorToColorOperation() : ConvertBaseOper
        this->addOutputSocket(COM_DT_COLOR);
 }
 
-void ConvertVectorToColorOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void ConvertVectorToColorOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
-       this->m_inputOperation->read(output, x, y, sampler);
+       this->m_inputOperation->readSampled(output, x, y, sampler);
        output[3] = 1.0f;
 }
 
@@ -144,10 +144,10 @@ ConvertVectorToValueOperation::ConvertVectorToValueOperation() : ConvertBaseOper
        this->addOutputSocket(COM_DT_VALUE);
 }
 
-void ConvertVectorToValueOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void ConvertVectorToValueOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float input[4];
-       this->m_inputOperation->read(input, x, y, sampler);
+       this->m_inputOperation->readSampled(input, x, y, sampler);
        output[0] = (input[0] + input[1] + input[2]) / 3.0f;
 }
 
@@ -176,12 +176,12 @@ void ConvertRGBToYCCOperation::setMode(int mode)
        }
 }
 
-void ConvertRGBToYCCOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void ConvertRGBToYCCOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputColor[4];
        float color[3];
 
-       this->m_inputOperation->read(inputColor, x, y, sampler);
+       this->m_inputOperation->readSampled(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 */
@@ -214,10 +214,10 @@ void ConvertYCCToRGBOperation::setMode(int mode)
        }
 }
 
-void ConvertYCCToRGBOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void ConvertYCCToRGBOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputColor[4];
-       this->m_inputOperation->read(inputColor, x, y, sampler);
+       this->m_inputOperation->readSampled(inputColor, x, y, sampler);
 
        /* need to un-normalize the data */
        /* R,G,B --> Y,Cb,Cr */
@@ -236,10 +236,10 @@ ConvertRGBToYUVOperation::ConvertRGBToYUVOperation() : ConvertBaseOperation()
        this->addOutputSocket(COM_DT_COLOR);
 }
 
-void ConvertRGBToYUVOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void ConvertRGBToYUVOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputColor[4];
-       this->m_inputOperation->read(inputColor, x, y, sampler);
+       this->m_inputOperation->readSampled(inputColor, x, y, sampler);
        rgb_to_yuv(inputColor[0], inputColor[1], inputColor[2], &output[0], &output[1], &output[2]);
        output[3] = inputColor[3];
 }
@@ -253,10 +253,10 @@ ConvertYUVToRGBOperation::ConvertYUVToRGBOperation() : ConvertBaseOperation()
        this->addOutputSocket(COM_DT_COLOR);
 }
 
-void ConvertYUVToRGBOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void ConvertYUVToRGBOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputColor[4];
-       this->m_inputOperation->read(inputColor, x, y, sampler);
+       this->m_inputOperation->readSampled(inputColor, x, y, sampler);
        yuv_to_rgb(inputColor[0], inputColor[1], inputColor[2], &output[0], &output[1], &output[2]);
        output[3] = inputColor[3];
 }
@@ -270,10 +270,10 @@ ConvertRGBToHSVOperation::ConvertRGBToHSVOperation() : ConvertBaseOperation()
        this->addOutputSocket(COM_DT_COLOR);
 }
 
-void ConvertRGBToHSVOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void ConvertRGBToHSVOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputColor[4];
-       this->m_inputOperation->read(inputColor, x, y, sampler);
+       this->m_inputOperation->readSampled(inputColor, x, y, sampler);
        rgb_to_hsv_v(inputColor, output);
        output[3] = inputColor[3];
 }
@@ -287,10 +287,10 @@ ConvertHSVToRGBOperation::ConvertHSVToRGBOperation() : ConvertBaseOperation()
        this->addOutputSocket(COM_DT_COLOR);
 }
 
-void ConvertHSVToRGBOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void ConvertHSVToRGBOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputColor[4];
-       this->m_inputOperation->read(inputColor, x, y, sampler);
+       this->m_inputOperation->readSampled(inputColor, x, y, sampler);
        hsv_to_rgb_v(inputColor, output);
        output[3] = inputColor[3];
 }
@@ -304,12 +304,12 @@ ConvertPremulToStraightOperation::ConvertPremulToStraightOperation() : ConvertBa
        this->addOutputSocket(COM_DT_COLOR);
 }
 
-void ConvertPremulToStraightOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void ConvertPremulToStraightOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputValue[4];
        float alpha;
 
-       this->m_inputOperation->read(inputValue, x, y, sampler);
+       this->m_inputOperation->readSampled(inputValue, x, y, sampler);
        alpha = inputValue[3];
 
        if (fabsf(alpha) < 1e-5f) {
@@ -332,12 +332,12 @@ ConvertStraightToPremulOperation::ConvertStraightToPremulOperation() : ConvertBa
        this->addOutputSocket(COM_DT_COLOR);
 }
 
-void ConvertStraightToPremulOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void ConvertStraightToPremulOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputValue[4];
        float alpha;
 
-       this->m_inputOperation->read(inputValue, x, y, sampler);
+       this->m_inputOperation->readSampled(inputValue, x, y, sampler);
        alpha = inputValue[3];
 
        mul_v3_v3fl(output, inputValue, alpha);
@@ -366,10 +366,10 @@ void SeparateChannelOperation::deinitExecution()
 }
 
 
-void SeparateChannelOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void SeparateChannelOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float input[4];
-       this->m_inputOperation->read(input, x, y, sampler);
+       this->m_inputOperation->readSampled(input, x, y, sampler);
        output[0] = input[this->m_channel];
 }
 
@@ -407,23 +407,23 @@ void CombineChannelsOperation::deinitExecution()
 }
 
 
-void CombineChannelsOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void CombineChannelsOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float input[4];
        if (this->m_inputChannel1Operation) {
-               this->m_inputChannel1Operation->read(input, x, y, sampler);
+               this->m_inputChannel1Operation->readSampled(input, x, y, sampler);
                output[0] = input[0];
        }
        if (this->m_inputChannel2Operation) {
-               this->m_inputChannel2Operation->read(input, x, y, sampler);
+               this->m_inputChannel2Operation->readSampled(input, x, y, sampler);
                output[1] = input[0];
        }
        if (this->m_inputChannel3Operation) {
-               this->m_inputChannel3Operation->read(input, x, y, sampler);
+               this->m_inputChannel3Operation->readSampled(input, x, y, sampler);
                output[2] = input[0];
        }
        if (this->m_inputChannel4Operation) {
-               this->m_inputChannel4Operation->read(input, x, y, sampler);
+               this->m_inputChannel4Operation->readSampled(input, x, y, sampler);
                output[3] = input[0];
        }
 }
index 06aeb2e52d7a0428fcc5c342fef9053e2b262a08..957df812a2e6dd7868cf0d345792cb0789b9012a 100644 (file)
@@ -42,7 +42,7 @@ class ConvertValueToColorOperation : public ConvertBaseOperation {
 public:
        ConvertValueToColorOperation();
        
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 
 
@@ -50,7 +50,7 @@ class ConvertColorToValueOperation : public ConvertBaseOperation {
 public:
        ConvertColorToValueOperation();
        
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 
 
@@ -58,7 +58,7 @@ class ConvertColorToBWOperation : public ConvertBaseOperation {
 public:
        ConvertColorToBWOperation();
        
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 
 
@@ -66,7 +66,7 @@ class ConvertColorToVectorOperation : public ConvertBaseOperation {
 public:
        ConvertColorToVectorOperation();
        
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 
 
@@ -74,7 +74,7 @@ class ConvertValueToVectorOperation : public ConvertBaseOperation {
 public:
        ConvertValueToVectorOperation();
        
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 
 
@@ -82,7 +82,7 @@ class ConvertVectorToColorOperation : public ConvertBaseOperation {
 public:
        ConvertVectorToColorOperation();
        
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 
 
@@ -90,7 +90,7 @@ class ConvertVectorToValueOperation : public ConvertBaseOperation {
 public:
        ConvertVectorToValueOperation();
        
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 
 
@@ -101,7 +101,7 @@ private:
 public:
        ConvertRGBToYCCOperation();
 
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 
        /** Set the YCC mode */
        void setMode(int mode);
@@ -115,7 +115,7 @@ private:
 public:
        ConvertYCCToRGBOperation();
        
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
        
        /** Set the YCC mode */
        void setMode(int mode);
@@ -126,7 +126,7 @@ class ConvertRGBToYUVOperation : public ConvertBaseOperation {
 public:
        ConvertRGBToYUVOperation();
        
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 
 
@@ -134,7 +134,7 @@ class ConvertYUVToRGBOperation : public ConvertBaseOperation {
 public:
        ConvertYUVToRGBOperation();
        
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 
 
@@ -142,7 +142,7 @@ class ConvertRGBToHSVOperation : public ConvertBaseOperation {
 public:
        ConvertRGBToHSVOperation();
        
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 
 
@@ -150,7 +150,7 @@ class ConvertHSVToRGBOperation : public ConvertBaseOperation {
 public:
        ConvertHSVToRGBOperation();
        
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 
 
@@ -158,7 +158,7 @@ class ConvertPremulToStraightOperation : public ConvertBaseOperation {
 public:
        ConvertPremulToStraightOperation();
 
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 
 
@@ -166,7 +166,7 @@ class ConvertStraightToPremulOperation : public ConvertBaseOperation {
 public:
        ConvertStraightToPremulOperation();
 
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 
 
@@ -176,7 +176,7 @@ private:
        int m_channel;
 public:
        SeparateChannelOperation();
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
        
        void initExecution();
        void deinitExecution();
@@ -193,7 +193,7 @@ private:
        SocketReader *m_inputChannel4Operation;
 public:
        CombineChannelsOperation();
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
        
        void initExecution();
        void deinitExecution();
index 844d23db2ac36c34a393289ca18ad0b0e6647d5d..c514b576dcf456a22a80b37a45b4f5bb2639ce0d 100644 (file)
@@ -82,10 +82,10 @@ CropOperation::CropOperation() : CropBaseOperation()
        /* pass */
 }
 
-void CropOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void CropOperation::executePixelSampled(float output[4], 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(output, x, y, sampler);
+               this->m_inputOperation->readSampled(output, x, y, sampler);
        }
        else {
                zero_v4(output);
@@ -117,10 +117,10 @@ void CropImageOperation::determineResolution(unsigned int resolution[2], unsigne
        resolution[1] = this->m_ymax - this->m_ymin;
 }
 
-void CropImageOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void CropImageOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        if (x >= 0 && x < getWidth() && y >= 0 && y < getHeight()) {
-               this->m_inputOperation->read(output, (x + this->m_xmin), (y + this->m_ymin), sampler);
+               this->m_inputOperation->readSampled(output, (x + this->m_xmin), (y + this->m_ymin), sampler);
        }
        else {
                zero_v4(output);
index d2f2b15aa36f430fea31604eba70389cfb475ed0..4890ede18a9fcc29826f2521a93afd72ce607f76 100644 (file)
@@ -48,7 +48,7 @@ class CropOperation : public CropBaseOperation {
 private:
 public:
        CropOperation();
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], 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[2], unsigned int preferedResolution[2]);
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 
 };
 #endif
index e23eb26f52708e21ceac823f9640f54e5555069a..325ef83a529a1cc4083b7c2e97f6524385b340b2 100644 (file)
@@ -44,7 +44,7 @@ void DifferenceMatteOperation::deinitExecution()
        this->m_inputImage2Program = NULL;
 }
 
-void DifferenceMatteOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void DifferenceMatteOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inColor1[4];
        float inColor2[4];
@@ -54,8 +54,8 @@ void DifferenceMatteOperation::executePixel(float output[4], float x, float y, P
        float difference;
        float alpha;
 
-       this->m_inputImage1Program->read(inColor1, x, y, sampler);
-       this->m_inputImage2Program->read(inColor2, x, y, sampler);
+       this->m_inputImage1Program->readSampled(inColor1, x, y, sampler);
+       this->m_inputImage2Program->readSampled(inColor2, x, y, sampler);
 
        difference = (fabsf(inColor2[0] - inColor1[0]) +
                      fabsf(inColor2[1] - inColor1[1]) +
index e0a38f703edf6283fc65a4018efdbfde60b4cc11..a3647e1e5dbfe55d6b985c44250bd01972500c68 100644 (file)
@@ -43,7 +43,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
        
        void initExecution();
        void deinitExecution();
index 23289429bfd0794d40faf7575707f9772da9242b..d6c25574d0151a58b4d7b38cc70390b521b646c1 100644 (file)
@@ -71,7 +71,7 @@ void DirectionalBlurOperation::executePixel(float output[4], int x, int y, void
        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);
+       this->m_inputProgram->readSampled(col2, x, y, COM_PS_NEAREST);
        float ltx = this->m_tx;
        float lty = this->m_ty;
        float lsc = this->m_sc;
@@ -84,7 +84,7 @@ void DirectionalBlurOperation::executePixel(float output[4], int x, int y, void
                const float v = isc * (y - this->m_center_y_pix) + lty;
                const float u = isc * (x - this->m_center_x_pix) + ltx;
 
-               this->m_inputProgram->read(col,
+               this->m_inputProgram->readSampled(col,
                                           cs * u + ss * v + this->m_center_x_pix,
                                           cs * v - ss * u + this->m_center_y_pix,
                                           COM_PS_NEAREST);
index 1723da11f2169b3a433dbcf004da3d80e0cd70c1..17692bd18ef3c88a4f3bf46dc3a39a3852322dd9 100644 (file)
@@ -64,9 +64,9 @@ void DisplaceOperation::executePixel(float output[4], int x, int y, void *data)
        float dxt, dyt;
        float u, v;
 
-       this->m_inputScaleXProgram->read(inScale, x, y, COM_PS_NEAREST);
+       this->m_inputScaleXProgram->readSampled(inScale, x, y, COM_PS_NEAREST);
        float xs = inScale[0];
-       this->m_inputScaleYProgram->read(inScale, x, y, COM_PS_NEAREST);
+       this->m_inputScaleYProgram->readSampled(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 output[4], int x, int y, void *data)
        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);
+       this->m_inputVectorProgram->readSampled(inVector, x, y, COM_PS_NEAREST);
        p_dx = inVector[0] * xs;
        p_dy = inVector[1] * ys;
 
@@ -83,9 +83,9 @@ void DisplaceOperation::executePixel(float output[4], int x, int y, void *data)
        v = y - p_dy + 0.5f;
 
        /* calc derivatives */
-       this->m_inputVectorProgram->read(inVector, x + 1, y, COM_PS_NEAREST);
+       this->m_inputVectorProgram->readSampled(inVector, x + 1, y, COM_PS_NEAREST);
        d_dx = inVector[0] * xs;
-       this->m_inputVectorProgram->read(inVector, x, y + 1, COM_PS_NEAREST);
+       this->m_inputVectorProgram->readSampled(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 output[4], int x, int y, void *data)
        dyt = signf(dyt) * max_ff(fabsf(dyt), DISPLACE_EPSILON) / this->getHeight();
 
        /* EWA filtering (without nearest it gets blurry with NO distortion) */
-       this->m_inputColorProgram->read(output, u, v, dxt, dyt, COM_PS_NEAREST);
+       this->m_inputColorProgram->readFiltered(output, u, v, dxt, dyt, COM_PS_NEAREST);
 }
 
 void DisplaceOperation::deinitExecution()
index c8ebb845bb670fa8578aec49d7fb3a6c881eaed9..48160d5db2cbccba806b8b93636f7758b1213562 100644 (file)
@@ -53,7 +53,7 @@ void DisplaceSimpleOperation::initExecution()
  * in order to take effect */
 // #define DISPLACE_EPSILON    0.01f
 
-void DisplaceSimpleOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void DisplaceSimpleOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inVector[4];
        float inScale[4];
@@ -61,9 +61,9 @@ void DisplaceSimpleOperation::executePixel(float output[4], float x, float y, Pi
        float p_dx, p_dy;   /* main displacement in pixel space */
        float u, v;
 
-       this->m_inputScaleXProgram->read(inScale, x, y, sampler);
+       this->m_inputScaleXProgram->readSampled(inScale, x, y, sampler);
        float xs = inScale[0];
-       this->m_inputScaleYProgram->read(inScale, x, y, sampler);
+       this->m_inputScaleYProgram->readSampled(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 output[4], float x, float y, Pi
        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);
+       this->m_inputVectorProgram->readSampled(inVector, x, y, sampler);
        p_dx = inVector[0] * xs;
        p_dy = inVector[1] * ys;
 
@@ -82,7 +82,7 @@ void DisplaceSimpleOperation::executePixel(float output[4], float x, float y, Pi
        CLAMP(u, 0.f, this->getWidth() - 1.f);
        CLAMP(v, 0.f, this->getHeight() - 1.f);
 
-       this->m_inputColorProgram->read(output, u, v, sampler);
+       this->m_inputColorProgram->readSampled(output, u, v, sampler);
 }
 
 void DisplaceSimpleOperation::deinitExecution()
index 989cf8a1f67076fec7bd19539b9a84db8837c7f9..6e52dfe86e9cd8967d280c4e919a50e7027407bc 100644 (file)
@@ -48,7 +48,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
        
        /**
         * Initialize the execution
index d3309e0c97807855d9b020138fff05e50724e64d..072ca1022e75e83b3c2359d3ba8b0a4081d1aea3 100644 (file)
@@ -49,7 +49,7 @@ float DistanceRGBMatteOperation::calculateDistance(float key[4], float image[4])
        return len_v3v3(key, image);
 }
 
-void DistanceRGBMatteOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void DistanceRGBMatteOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inKey[4];
        float inImage[4];
@@ -60,8 +60,8 @@ void DistanceRGBMatteOperation::executePixel(float output[4], float x, float y,
        float distance;
        float alpha;
 
-       this->m_inputKeyProgram->read(inKey, x, y, sampler);
-       this->m_inputImageProgram->read(inImage, x, y, sampler);
+       this->m_inputKeyProgram->readSampled(inKey, x, y, sampler);
+       this->m_inputImageProgram->readSampled(inImage, x, y, sampler);
        
        distance = this->calculateDistance(inKey, inImage);
 
index 43299486f6095fa1e6136fb182749bd33d5829f1..a815caa5ef5d3bbb827b78ff46cc7d4ef2aa80db 100644 (file)
@@ -45,7 +45,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
        
        void initExecution();
        void deinitExecution();
index 1439dfa404a360b7b3b8c3ddb91c0357ed17c9b6..368db185adce26565a66a662f10795fe7f2c2861 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 output[4], float x, float y, PixelSampler sampler)
+void DotproductOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float input1[4];
        float input2[4];
-       this->m_input1Operation->read(input1, x, y, sampler);
-       this->m_input2Operation->read(input2, x, y, sampler);
+       this->m_input1Operation->readSampled(input1, x, y, sampler);
+       this->m_input2Operation->readSampled(input2, x, y, sampler);
        output[0] = -(input1[0] * input2[0] + input1[1] * input2[1] + input1[2] * input2[2]);
 }
index 31588207504c55e1541677b35d50c17bb356a5e4..4378e280d1709415a028b4d8023c86a1b1582b6a 100644 (file)
@@ -31,7 +31,7 @@ private:
        SocketReader *m_input2Operation;
 public:
        DotproductOperation();
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
        
        void initExecution();
        void deinitExecution();
index 9ab21e2d5bdc5bd4a6af3a855f176ff0a73e4add..d7cc2ec92724f9ac4a4d0fd126dad73ee548c62d 100644 (file)
@@ -44,7 +44,7 @@ void EllipseMaskOperation::initExecution()
        this->m_aspectRatio = ((float)this->getWidth()) / this->getHeight();
 }
 
-void EllipseMaskOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void EllipseMaskOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputMask[4];
        float inputValue[4];
@@ -57,8 +57,8 @@ void EllipseMaskOperation::executePixel(float output[4], float x, float y, Pixel
        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);
-       this->m_inputValue->read(inputValue, x, y, sampler);
+       this->m_inputMask->readSampled(inputMask, x, y, sampler);
+       this->m_inputValue->readSampled(inputValue, x, y, sampler);
        
        const float halfHeight = (this->m_data->height) / 2.0f;
        const float halfWidth = this->m_data->width / 2.0f;
index ed74e6b43db8ca5937ac79d38f7498f06d02ee94..753615df370fe210e09f9731016677736a2c4564 100644 (file)
@@ -45,7 +45,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
        
        /**
         * Initialize the execution
index 526eba34d867cf7b33145efaba42c2d757ca7ec3..3de2ae9dabcc3115888c50be2630cbb0056c6bc4 100644 (file)
@@ -42,12 +42,12 @@ void FlipOperation::deinitExecution()
 }
 
 
-void FlipOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void FlipOperation::executePixelSampled(float output[4], 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(output, nx, ny, sampler);
+       this->m_inputOperation->readSampled(output, nx, ny, sampler);
 }
 
 bool FlipOperation::determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output)
index 018617cea8a28a9163d1a131964b32f3b6c7e1ff..a1fcde19876e6acb155d5b9731f6a4abd49ae272 100644 (file)
@@ -33,7 +33,7 @@ private:
 public:
        FlipOperation();
        bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output);
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
        
        void initExecution();
        void deinitExecution();
index 8f92dc02a57f6e78c9206410eb15fe1e8195225a..357677d683259bdbe750b81c5b10785f496dd98b 100644 (file)
@@ -34,10 +34,10 @@ void GammaCorrectOperation::initExecution()
        this->m_inputProgram = this->getInputSocketReader(0);
 }
 
-void GammaCorrectOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void GammaCorrectOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputColor[4];
-       this->m_inputProgram->read(inputColor, x, y, sampler);
+       this->m_inputProgram->readSampled(inputColor, x, y, sampler);
        if (inputColor[3] > 0.0f) {
                inputColor[0] /= inputColor[3];
                inputColor[1] /= inputColor[3];
@@ -73,10 +73,10 @@ void GammaUncorrectOperation::initExecution()
        this->m_inputProgram = this->getInputSocketReader(0);
 }
 
-void GammaUncorrectOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void GammaUncorrectOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputColor[4];
-       this->m_inputProgram->read(inputColor, x, y, sampler);
+       this->m_inputProgram->readSampled(inputColor, x, y, sampler);
 
        if (inputColor[3] > 0.0f) {
                inputColor[0] /= inputColor[3];
index 514855b4f569438bed5f9c74d43c8f7161a0537e..68eaab83c99870acab2686ab363cfdabf93aa521 100644 (file)
@@ -38,7 +38,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
        
        /**
         * Initialize the execution
@@ -64,7 +64,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
        
        /**
         * Initialize the execution
index 326031c598435035ceba6d1b836a576b2d1c7500..d98f2c4663fbd61cb7c2cc72e81486e4814f3b9f 100644 (file)
@@ -37,13 +37,13 @@ void GammaOperation::initExecution()
        this->m_inputGammaProgram = this->getInputSocketReader(1);
 }
 
-void GammaOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void GammaOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputValue[4];
        float inputGamma[4];
        
-       this->m_inputProgram->read(inputValue, x, y, sampler);
-       this->m_inputGammaProgram->read(inputGamma, x, y, sampler);
+       this->m_inputProgram->readSampled(inputValue, x, y, sampler);
+       this->m_inputGammaProgram->readSampled(inputGamma, x, y, sampler);
        const float gamma = inputGamma[0];
        /* check for negative to avoid nan's */
        output[0] = inputValue[0] > 0.0f ? powf(inputValue[0], gamma) : inputValue[0];
index 4482f7be34a54f105a7286cc9244970c41cbb587..d8e084578126b3cb33eb306ea58440a3148b76c0 100644 (file)
@@ -39,7 +39,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
        
        /**
         * Initialize the execution
index 1c7d2659c390a6e6cc1c9c6ed254a5d420ccf1df..78e1e80cafce5a62bb13bf219e9ac798967b2d14 100644 (file)
@@ -42,11 +42,11 @@ void GlareThresholdOperation::initExecution()
        this->m_inputProgram = this->getInputSocketReader(0);
 }
 
-void GlareThresholdOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void GlareThresholdOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        const float threshold = this->m_settings->threshold;
        
-       this->m_inputProgram->read(output, x, y, sampler);
+       this->m_inputProgram->readSampled(output, x, y, sampler);
        if (rgb_to_luma_y(output) >= threshold) {
                output[0] -= threshold, output[1] -= threshold, output[2] -= threshold;
                output[0] = max(output[0], 0.0f);
index 44f9db6a4830c6e3dde51e4da21b58271e9367e6..7760a19251b4e3dfb3c6695ddbb2f2c26fedeb86 100644 (file)
@@ -42,7 +42,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 
        /**
         * Initialize the execution
index 8f58942fbe2c0f3b3307ee307366fdb78b588d8a..6bbaac8e30399a8c100f0308fb8787b7049ba28e 100644 (file)
@@ -45,11 +45,11 @@ void HueSaturationValueCorrectOperation::initExecution()
        this->m_inputProgram = this->getInputSocketReader(0);
 }
 
-void HueSaturationValueCorrectOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void HueSaturationValueCorrectOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float hsv[4], f;
 
-       this->m_inputProgram->read(hsv, x, y, sampler);
+       this->m_inputProgram->readSampled(hsv, x, y, sampler);
 
        /* adjust hue, scaling returned default 0.5 up to 1 */
        f = curvemapping_evaluateF(this->m_curveMapping, 0, hsv[0]);
index 5e57d09a51e7abf13baa017f41088209890bca35..0a0e82bf168d6d92fda32531bc60e35be594b868 100644 (file)
@@ -37,7 +37,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
        
        /**
         * Initialize the execution
index 4b9bcb118e7a5560cfe02944108476fe1f8ae4bf..a021f07d2a7a408c6c790e30302e34822e680156 100644 (file)
@@ -33,11 +33,11 @@ void IDMaskOperation::initExecution()
        this->m_inputProgram = this->getInputSocketReader(0);
 }
 
-void IDMaskOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void IDMaskOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputValue[4];
        
-       this->m_inputProgram->read(inputValue, x, y, sampler);
+       this->m_inputProgram->readSampled(inputValue, x, y, sampler);
        const float a = (inputValue[0] == this->m_objectIndex) ? 1.0f : 0.0f;
        output[0] = a;
 }
index 68c5cf4c1dc52331607d796c7c29839ed7ebe904..dfddc489ca42bf41d7b0052fdae37703fb9377a8 100644 (file)
@@ -39,7 +39,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
        
        /**
         * Initialize the execution
index cface29fdcabd0dd47e1b79d9d2a62fd00872b71..adc325de37736a5a901b41961d7f72a88c08dd77 100644 (file)
@@ -146,7 +146,7 @@ static void sampleImageAtLocation(ImBuf *ibuf, float x, float y, PixelSampler sa
        }
 }
 
-void ImageOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void ImageOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        if ((this->m_imageFloatBuffer == NULL && this->m_imageByteBuffer == NULL) || x < 0 || y < 0 || x >= this->getWidth() || y >= this->getHeight() ) {
                zero_v4(output);
@@ -156,7 +156,7 @@ void ImageOperation::executePixel(float output[4], float x, float y, PixelSample
        }
 }
 
-void ImageAlphaOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void ImageAlphaOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float tempcolor[4];
 
@@ -170,7 +170,7 @@ void ImageAlphaOperation::executePixel(float output[4], float x, float y, PixelS
        }
 }
 
-void ImageDepthOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void ImageDepthOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        if (this->m_depthBuffer == NULL || x < 0 || y < 0 || x >= this->getWidth() || y >= this->getHeight() ) {
                output[0] = 0.0f;
index b51f11edd0406cf76f6d86eae9d002e2109f14a8..a9e2ed9ff64c0a4a5a19e7da1dd9037a73d74a90 100644 (file)
@@ -73,7 +73,7 @@ public:
         * Constructor
         */
        ImageOperation();
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 class ImageAlphaOperation : public BaseImageOperation {
 public:
@@ -81,7 +81,7 @@ public:
         * Constructor
         */
        ImageAlphaOperation();
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 class ImageDepthOperation : public BaseImageOperation {
 public:
@@ -89,6 +89,6 @@ public:
         * Constructor
         */
        ImageDepthOperation();
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 #endif
index 9c2dd82570973668a071fd1013cfc3c97f84a62c..dc5a2653129db5f5399c6e927d9cfdcff1ce6fb6 100644 (file)
@@ -39,12 +39,12 @@ void InvertOperation::initExecution()
        this->m_inputColorProgram = this->getInputSocketReader(1);
 }
 
-void InvertOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void InvertOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputValue[4];
        float inputColor[4];
-       this->m_inputValueProgram->read(inputValue, x, y, sampler);
-       this->m_inputColorProgram->read(inputColor, x, y, sampler);
+       this->m_inputValueProgram->readSampled(inputValue, x, y, sampler);
+       this->m_inputColorProgram->readSampled(inputColor, x, y, sampler);
        
        const float value = inputValue[0];
        const float invertedValue = 1.0f - value;
index 7fded7bb1e4200098d6fab15fa662c7460f04940..be1e933f1e96d00af7fbe8219319b9018690372d 100644 (file)
@@ -42,7 +42,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
        
        /**
         * Initialize the execution
index 01f5c032730ee1e5a12386e7acf8876e51480ce2..c4b821f998fc181a75c0c7fca075fc221eb07b6b 100644 (file)
@@ -53,13 +53,13 @@ void KeyingDespillOperation::deinitExecution()
        this->m_screenReader = NULL;
 }
 
-void KeyingDespillOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void KeyingDespillOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float pixelColor[4];
        float screenColor[4];
 
-       this->m_pixelReader->read(pixelColor, x, y, sampler);
-       this->m_screenReader->read(screenColor, x, y, sampler);
+       this->m_pixelReader->readSampled(pixelColor, x, y, sampler);
+       this->m_screenReader->readSampled(screenColor, x, y, sampler);
 
        const int screen_primary_channel = max_axis_v3(screenColor);
        const int other_1 = (screen_primary_channel + 1) % 3;
index 18e771b14f186140af726219d51ae1e55971f8f8..da9924d5b4b2451cc0abfb7c7ed86bf64f037fd2 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 output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 
 #endif
index baeacb56744da457f4cddcb98a45ee186fdac210..e2566d2f4f0360bce69077cf08d6dc4b260093bb 100644 (file)
@@ -65,13 +65,13 @@ void KeyingOperation::deinitExecution()
        this->m_screenReader = NULL;
 }
 
-void KeyingOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void KeyingOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float pixelColor[4];
        float screenColor[4];
 
-       this->m_pixelReader->read(pixelColor, x, y, sampler);
-       this->m_screenReader->read(screenColor, x, y, sampler);
+       this->m_pixelReader->readSampled(pixelColor, x, y, sampler);
+       this->m_screenReader->readSampled(screenColor, x, y, sampler);
 
        const int primary_channel = max_axis_v3(screenColor);
 
index fcff9243dfcc59e688be9503011e137f85c3db9b..e4542e2c6dd9ced20566efa1aae2c62a8f811200 100644 (file)
@@ -49,7 +49,7 @@ public:
 
        void setScreenBalance(float value) {this->m_screenBalance = value;}
 
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 
 #endif
index 4c65113ee709101dcd0dbe64ebee81fe92c4ba8c..0e48d5963c625b99e823ef87f8f011508885c6f4 100644 (file)
@@ -40,7 +40,7 @@ void LuminanceMatteOperation::deinitExecution()
        this->m_inputImageProgram = NULL;
 }
 
-void LuminanceMatteOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void LuminanceMatteOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inColor[4];
 
@@ -49,7 +49,7 @@ void LuminanceMatteOperation::executePixel(float output[4], float x, float y, Pi
 
        float alpha;
 
-       this->m_inputImageProgram->read(inColor, x, y, sampler);
+       this->m_inputImageProgram->readSampled(inColor, x, y, sampler);
        
        /* one line thread-friend algorithm:
         * output[0] = max(inputValue[3], min(high, max(low, ((inColor[0]-low)/(high-low))))
index cb8cc01efeaf9d1d5d561761dbf239f5cf95bdbc..93051f52228e78f74a06e33b3db020c2ca6d599e 100644 (file)
@@ -41,7 +41,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
        
        void initExecution();
        void deinitExecution();
index 1fe74ade0fc45c233b92c713fa562a6eb9b8d18c..2e80d4f1ba396087fc383240584287fb6709ae50 100644 (file)
@@ -46,18 +46,18 @@ void MapRangeOperation::initExecution()
 /* The code below assumes all data is inside range +- this, and that input buffer is single channel */
 #define BLENDER_ZMAX 10000.0f
 
-void MapRangeOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void MapRangeOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputs[8]; /* includes the 5 inputs + 3 pads */
        float value;
        float source_min, source_max;
        float dest_min, dest_max;
 
-       this->m_inputOperation->read(inputs, x, y, sampler);
-       this->m_sourceMinOperation->read(inputs + 1, x, y, sampler);
-       this->m_sourceMaxOperation->read(inputs + 2, x, y, sampler);
-       this->m_destMinOperation->read(inputs + 3, x, y, sampler);
-       this->m_destMaxOperation->read(inputs + 4, x, y, sampler);
+       this->m_inputOperation->readSampled(inputs, x, y, sampler);
+       this->m_sourceMinOperation->readSampled(inputs + 1, x, y, sampler);
+       this->m_sourceMaxOperation->readSampled(inputs + 2, x, y, sampler);
+       this->m_destMinOperation->readSampled(inputs + 3, x, y, sampler);
+       this->m_destMaxOperation->readSampled(inputs + 4, x, y, sampler);
        
        value = inputs[0];
        source_min = inputs[1];
index 00dfc68168cd3d1162f7eacf4c642179d55c462f..a232f89ea9de22ef4df47ceefa0ebbbfc269d5fa 100644 (file)
@@ -50,7 +50,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
        
        /**
         * Initialize the execution
index a9b6ad3edc1fa04235615ae01ea3d4fe6b3a8f99..289b447dec7387fd4517ae05b7cb14a226e8b59c 100644 (file)
@@ -40,7 +40,7 @@ void MapUVOperation::initExecution()
        this->m_inputUVProgram = this->getInputSocketReader(1);
 }
 
-void MapUVOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void MapUVOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputUV[4];
        float uv_a[4], uv_b[4];
@@ -50,22 +50,22 @@ void MapUVOperation::executePixel(float output[4], float x, float y, PixelSample
        float uv_l, uv_r;
        float uv_u, uv_d;
 
-       this->m_inputUVProgram->read(inputUV, x, y, sampler);
+       this->m_inputUVProgram->readSampled(inputUV, x, y, sampler);
        if (inputUV[2] == 0.f) {
                zero_v4(output);
                return;
        }
        /* adaptive sampling, red (U) channel */
-       this->m_inputUVProgram->read(uv_a, x - 1, y, COM_PS_NEAREST);
-       this->m_inputUVProgram->read(uv_b, x + 1, y, COM_PS_NEAREST);
+       this->m_inputUVProgram->readSampled(uv_a, x - 1, y, COM_PS_NEAREST);
+       this->m_inputUVProgram->readSampled(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);
-       this->m_inputUVProgram->read(uv_b, x, y + 1, COM_PS_NEAREST);
+       this->m_inputUVProgram->readSampled(uv_a, x, y - 1, COM_PS_NEAREST);
+       this->m_inputUVProgram->readSampled(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;
 
@@ -81,7 +81,7 @@ void MapUVOperation::executePixel(float output[4], float x, float y, PixelSample
        u = inputUV[0] * this->m_inputColorProgram->getWidth();
        v = inputUV[1] * this->m_inputColorProgram->getHeight();
 
-       this->m_inputColorProgram->read(output, u, v, dx, dy, COM_PS_NEAREST);
+       this->m_inputColorProgram->readFiltered(output, u, v, dx, dy, COM_PS_NEAREST);
 
        /* "premul" */
        if (alpha < 1.0f) {
index c8356c1a7ad7d30b77f62e18b3b4e41648053d63..fe8bfd2a9ac72679503d5f93020972b757e0f126 100644 (file)
@@ -45,7 +45,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
        
        /**
         * Initialize the execution
index 7acc431f7b5cdf6386d392d75b1ddc19c61f02f3..d6aaf560fcea7a9a46c0d588951aaf87fb379352 100644 (file)
@@ -34,10 +34,10 @@ void MapValueOperation::initExecution()
        this->m_inputOperation = this->getInputSocketReader(0);
 }
 
-void MapValueOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void MapValueOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float src[4];
-       this->m_inputOperation->read(src, x, y, sampler);
+       this->m_inputOperation->readSampled(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 418d6d9bf4d6e7aa0e91b059e0662e6fb891ca2b..a9a59d6633a04b501df2ff8b7692ba069cbe1079 100644 (file)
@@ -45,7 +45,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
        
        /**
         * Initialize the execution
index 85df691ee295c17dfd768e597b1a0a01d49c624d..a5b1987d4b371766fc02b8104aeadc94e073e3e9 100644 (file)
@@ -127,7 +127,7 @@ void MaskOperation::determineResolution(unsigned int resolution[2], unsigned int
        }
 }
 
-void MaskOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void MaskOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        const float xy[2] = {x * this->m_maskWidthInv,
                             y * this->m_maskHeightInv};
index 2de71afcfa7b1ae588839a92fe221b1e4d398794..18d7e594104db306c369e744c86f19e3f3078520 100644 (file)
@@ -83,7 +83,7 @@ public:
        void setMotionBlurSamples(int samples) { this->m_rasterMaskHandleTot = min(max(1, samples), CMP_NODE_MASK_MBLUR_SAMPLES_MAX); }
        void setMotionBlurShutter(float shutter) { this->m_frame_shutter = shutter; }
 
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 
 #endif
index fa0c480eb700723c5fa8412dd250da8416d27d32..cc7511bb9fc5b2d233205c67917683063c3cedbc 100644 (file)
@@ -72,52 +72,52 @@ void MathBaseOperation::clampIfNeeded(float *color)
        }
 }
 
-void MathAddOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void MathAddOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputValue1[4];
        float inputValue2[4];
        
-       this->m_inputValue1Operation->read(inputValue1, x, y, sampler);
-       this->m_inputValue2Operation->read(inputValue2, x, y, sampler);
+       this->m_inputValue1Operation->readSampled(inputValue1, x, y, sampler);
+       this->m_inputValue2Operation->readSampled(inputValue2, x, y, sampler);
        
        output[0] = inputValue1[0] + inputValue2[0];
 
        clampIfNeeded(output);
 }
 
-void MathSubtractOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void MathSubtractOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputValue1[4];
        float inputValue2[4];
        
-       this->m_inputValue1Operation->read(inputValue1, x, y, sampler);
-       this->m_inputValue2Operation->read(inputValue2, x, y, sampler);
+       this->m_inputValue1Operation->readSampled(inputValue1, x, y, sampler);
+       this->m_inputValue2Operation->readSampled(inputValue2, x, y, sampler);
        
        output[0] = inputValue1[0] - inputValue2[0];
 
        clampIfNeeded(output);
 }
 
-void MathMultiplyOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void MathMultiplyOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputValue1[4];
        float inputValue2[4];
        
-       this->m_inputValue1Operation->read(inputValue1, x, y, sampler);
-       this->m_inputValue2Operation->read(inputValue2, x, y, sampler);
+       this->m_inputValue1Operation->readSampled(inputValue1, x, y, sampler);
+       this->m_inputValue2Operation->readSampled(inputValue2, x, y, sampler);
        
        output[0] = inputValue1[0] * inputValue2[0];
 
        clampIfNeeded(output);
 }
 
-void MathDivideOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void MathDivideOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputValue1[4];
        float inputValue2[4];
        
-       this->m_inputValue1Operation->read(inputValue1, x, y, sampler);
-       this->m_inputValue2Operation->read(inputValue2, x, y, sampler);
+       this->m_inputValue1Operation->readSampled(inputValue1, x, y, sampler);
+       this->m_inputValue2Operation->readSampled(inputValue2, x, y, sampler);
        
        if (inputValue2[0] == 0) /* We don't want to divide by zero. */
                output[0] = 0.0;
@@ -127,52 +127,52 @@ void MathDivideOperation::executePixel(float output[4], float x, float y, PixelS
        clampIfNeeded(output);
 }
 
-void MathSineOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void MathSineOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputValue1[4];
        float inputValue2[4];
        
-       this->m_inputValue1Operation->read(inputValue1, x, y, sampler);
-       this->m_inputValue2Operation->read(inputValue2, x, y, sampler);
+       this->m_inputValue1Operation->readSampled(inputValue1, x, y, sampler);
+       this->m_inputValue2Operation->readSampled(inputValue2, x, y, sampler);
        
        output[0] = sin(inputValue1[0]);
 
        clampIfNeeded(output);
 }
 
-void MathCosineOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void MathCosineOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputValue1[4];
        float inputValue2[4];
        
-       this->m_inputValue1Operation->read(inputValue1, x, y, sampler);
-       this->m_inputValue2Operation->read(inputValue2, x, y, sampler);
+       this->m_inputValue1Operation->readSampled(inputValue1, x, y, sampler);
+       this->m_inputValue2Operation->readSampled(inputValue2, x, y, sampler);
        
        output[0] = cos(inputValue1[0]);
 
        clampIfNeeded(output);
 }
 
-void MathTangentOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void MathTangentOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputValue1[4];
        float inputValue2[4];
        
-       this->m_inputValue1Operation->read(inputValue1, x, y, sampler);
-       this->m_inputValue2Operation->read(inputValue2, x, y, sampler);
+       this->m_inputValue1Operation->readSampled(inputValue1, x, y, sampler);
+       this->m_inputValue2Operation->readSampled(inputValue2, x, y, sampler);
        
        output[0] = tan(inputValue1[0]);
 
        clampIfNeeded(output);
 }
 
-void MathArcSineOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void MathArcSineOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputValue1[4];
        float inputValue2[4];
        
-       this->m_inputValue1Operation->read(inputValue1, x, y, sampler);
-       this->m_inputValue2Operation->read(inputValue2, x, y, sampler);
+       this->m_inputValue1Operation->readSampled(inputValue1, x, y, sampler);
+       this->m_inputValue2Operation->readSampled(inputValue2, x, y, sampler);
        
        if (inputValue1[0] <= 1 && inputValue1[0] >= -1)
                output[0] = asin(inputValue1[0]);
@@ -182,13 +182,13 @@ void MathArcSineOperation::executePixel(float output[4], float x, float y, Pixel
        clampIfNeeded(output);
 }
 
-void MathArcCosineOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void MathArcCosineOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputValue1[4];
        float inputValue2[4];
        
-       this->m_inputValue1Operation->read(inputValue1, x, y, sampler);
-       this->m_inputValue2Operation->read(inputValue2, x, y, sampler);
+       this->m_inputValue1Operation->readSampled(inputValue1, x, y, sampler);
+       this->m_inputValue2Operation->readSampled(inputValue2, x, y, sampler);
        
        if (inputValue1[0] <= 1 && inputValue1[0] >= -1)
                output[0] = acos(inputValue1[0]);
@@ -198,26 +198,26 @@ void MathArcCosineOperation::executePixel(float output[4], float x, float y, Pix
        clampIfNeeded(output);
 }
 
-void MathArcTangentOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void MathArcTangentOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputValue1[4];
        float inputValue2[4];
        
-       this->m_inputValue1Operation->read(inputValue1, x, y, sampler);
-       this->m_inputValue2Operation->read(inputValue2, x, y, sampler);
+       this->m_inputValue1Operation->readSampled(inputValue1, x, y, sampler);
+       this->m_inputValue2Operation->readSampled(inputValue2, x, y, sampler);
        
        output[0] = atan(inputValue1[0]);
 
        clampIfNeeded(output);
 }
 
-void MathPowerOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void MathPowerOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputValue1[4];
        float inputValue2[4];
        
-       this->m_inputValue1Operation->read(inputValue1, x, y, sampler);
-       this->m_inputValue2Operation->read(inputValue2, x, y, sampler);
+       this->m_inputValue1Operation->readSampled(inputValue1, x, y, sampler);
+       this->m_inputValue2Operation->readSampled(inputValue2, x, y, sampler);
        
        if (inputValue1[0] >= 0) {
                output[0] = pow(inputValue1[0], inputValue2[0]);
@@ -236,13 +236,13 @@ void MathPowerOperation::executePixel(float output[4], float x, float y, PixelSa
        clampIfNeeded(output);
 }
 
-void MathLogarithmOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void MathLogarithmOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputValue1[4];
        float inputValue2[4];
        
-       this->m_inputValue1Operation->read(inputValue1, x, y, sampler);
-       this->m_inputValue2Operation->read(inputValue2, x, y, sampler);
+       this->m_inputValue1Operation->readSampled(inputValue1, x, y, sampler);
+       this->m_inputValue2Operation->readSampled(inputValue2, x, y, sampler);
        
        if (inputValue1[0] > 0  && inputValue2[0] > 0)
                output[0] = log(inputValue1[0]) / log(inputValue2[0]);
@@ -252,78 +252,78 @@ void MathLogarithmOperation::executePixel(float output[4], float x, float y, Pix
        clampIfNeeded(output);
 }
 
-void MathMinimumOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void MathMinimumOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputValue1[4];
        float inputValue2[4];
        
-       this->m_inputValue1Operation->read(inputValue1, x, y, sampler);
-       this->m_inputValue2Operation->read(inputValue2, x, y, sampler);
+       this->m_inputValue1Operation->readSampled(inputValue1, x, y, sampler);
+       this->m_inputValue2Operation->readSampled(inputValue2, x, y, sampler);
        
        output[0] = min(inputValue1[0], inputValue2[0]);
 
        clampIfNeeded(output);
 }
 
-void MathMaximumOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void MathMaximumOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputValue1[4];
        float inputValue2[4];
        
-       this->m_inputValue1Operation->read(inputValue1, x, y, sampler);
-       this->m_inputValue2Operation->read(inputValue2, x, y, sampler);
+       this->m_inputValue1Operation->readSampled(inputValue1, x, y, sampler);
+       this->m_inputValue2Operation->readSampled(inputValue2, x, y, sampler);
        
        output[0] = max(inputValue1[0], inputValue2[0]);
 
        clampIfNeeded(output);
 }
 
-void MathRoundOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void MathRoundOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputValue1[4];
        float inputValue2[4];
        
-       this->m_inputValue1Operation->read(inputValue1, x, y, sampler);
-       this->m_inputValue2Operation->read(inputValue2, x, y, sampler);
+       this->m_inputValue1Operation->readSampled(inputValue1, x, y, sampler);
+       this->m_inputValue2Operation->readSampled(inputValue2, x, y, sampler);
        
        output[0] = round(inputValue1[0]);
 
        clampIfNeeded(output);
 }
 
-void MathLessThanOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void MathLessThanOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputValue1[4];
        float inputValue2[4];
        
-       this->m_inputValue1Operation->read(inputValue1, x, y, sampler);
-       this->m_inputValue2Operation->read(inputValue2, x, y, sampler);
+       this->m_inputValue1Operation->readSampled(inputValue1, x, y, sampler);
+       this->m_inputValue2Operation->readSampled(inputValue2, x, y, sampler);
        
        output[0] = inputValue1[0] < inputValue2[0] ? 1.0f : 0.0f;
 
        clampIfNeeded(output);
 }
 
-void MathGreaterThanOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void MathGreaterThanOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputValue1[4];
        float inputValue2[4];
        
-       this->m_inputValue1Operation->read(inputValue1, x, y, sampler);
-       this->m_inputValue2Operation->read(inputValue2, x, y, sampler);
+       this->m_inputValue1Operation->readSampled(inputValue1, x, y, sampler);
+       this->m_inputValue2Operation->readSampled(inputValue2, x, y, sampler);
        
        output[0] = inputValue1[0] > inputValue2[0] ? 1.0f : 0.0f;
 
        clampIfNeeded(output);
 }
 
-void MathModuloOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void MathModuloOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputValue1[4];
        float inputValue2[4];
        
-       this->m_inputValue1Operation->read(inputValue1, x, y, sampler);
-       this->m_inputValue2Operation->read(inputValue2, x, y, sampler);
+       this->m_inputValue1Operation->readSampled(inputValue1, x, y, sampler);
+       this->m_inputValue2Operation->readSampled(inputValue2, x, y, sampler);
        
        if (inputValue2[0] == 0)
                output[0] = 0.0;
index 649a9688037fa2326a05cb2f830ac5c936518682..4ea7c43a67d2145f73535043667e8d2ad3c12a58 100644 (file)
@@ -50,7 +50,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float output[4], float x, float y, PixelSampler sampler) = 0;
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler) = 0;
        
        /**
         * Initialize the execution
@@ -73,94 +73,94 @@ public:
 class MathAddOperation : public MathBaseOperation {
 public:
        MathAddOperation() : MathBaseOperation() {}
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 class MathSubtractOperation : public MathBaseOperation {
 public:
        MathSubtractOperation() : MathBaseOperation() {}
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 class MathMultiplyOperation : public MathBaseOperation {
 public:
        MathMultiplyOperation() : MathBaseOperation() {}
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 class MathDivideOperation : public MathBaseOperation {
 public:
        MathDivideOperation() : MathBaseOperation() {}
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 class MathSineOperation : public MathBaseOperation {
 public:
        MathSineOperation() : MathBaseOperation() {}
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 class MathCosineOperation : public MathBaseOperation {
 public:
        MathCosineOperation() : MathBaseOperation() {}
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 class MathTangentOperation : public MathBaseOperation {
 public:
        MathTangentOperation() : MathBaseOperation() {}
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 
 class MathArcSineOperation : public MathBaseOperation {
 public:
        MathArcSineOperation() : MathBaseOperation() {}
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 class MathArcCosineOperation : public MathBaseOperation {
 public:
        MathArcCosineOperation() : MathBaseOperation() {}
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 class MathArcTangentOperation : public MathBaseOperation {
 public:
        MathArcTangentOperation() : MathBaseOperation() {}
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 class MathPowerOperation : public MathBaseOperation {
 public:
        MathPowerOperation() : MathBaseOperation() {}
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 class MathLogarithmOperation : public MathBaseOperation {
 public:
        MathLogarithmOperation() : MathBaseOperation() {}
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 class MathMinimumOperation : public MathBaseOperation {
 public:
        MathMinimumOperation() : MathBaseOperation() {}
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 class MathMaximumOperation : public MathBaseOperation {
 public:
        MathMaximumOperation() : MathBaseOperation() {}
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 class MathRoundOperation : public MathBaseOperation {
 public:
        MathRoundOperation() : MathBaseOperation() {}
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 class MathLessThanOperation : public MathBaseOperation {
 public:
        MathLessThanOperation() : MathBaseOperation() {}
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 class MathGreaterThanOperation : public MathBaseOperation {
 public:
        MathGreaterThanOperation() : MathBaseOperation() {}
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 
 class MathModuloOperation : public MathBaseOperation {
 public:
        MathModuloOperation() : MathBaseOperation() {}
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 
 #endif
index f094e93f147d7621c797c0d54afda25e2e3dc486..9781cb4e162f1b0a271f107defbaa80843eed7e3 100644 (file)
@@ -48,15 +48,15 @@ void MixBaseOperation::initExecution()
        this->m_inputColor2Operation = this->getInputSocketReader(2);
 }
 
-void MixBaseOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void MixBaseOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputColor1[4];
        float inputColor2[4];
        float inputValue[4];
        
-       this->m_inputValueOperation->read(inputValue, x, y, sampler);
-       this->m_inputColor1Operation->read(inputColor1, x, y, sampler);
-       this->m_inputColor2Operation->read(inputColor2, x, y, sampler);
+       this->m_inputValueOperation->readSampled(inputValue, x, y, sampler);
+       this->m_inputColor1Operation->readSampled(inputColor1, x, y, sampler);
+       this->m_inputColor2Operation->readSampled(inputColor2, x, y, sampler);
        
        float value = inputValue[0];
        if (this->useValueAlphaMultiply()) {
@@ -107,15 +107,15 @@ MixAddOperation::MixAddOperation() : MixBaseOperation()
        /* pass */
 }
 
-void MixAddOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void MixAddOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputColor1[4];
        float inputColor2[4];
        float inputValue[4];
 
-       this->m_inputValueOperation->read(inputValue, x, y, sampler);
-       this->m_inputColor1Operation->read(inputColor1, x, y, sampler);
-       this->m_inputColor2Operation->read(inputColor2, x, y, sampler);
+       this->m_inputValueOperation->readSampled(inputValue, x, y, sampler);
+       this->m_inputColor1Operation->readSampled(inputColor1, x, y, sampler);
+       this->m_inputColor2Operation->readSampled(inputColor2, x, y, sampler);
 
        float value = inputValue[0];
        if (this->useValueAlphaMultiply()) {
@@ -136,16 +136,16 @@ MixBlendOperation::MixBlendOperation() : MixBaseOperation()
        /* pass */
 }
 
-void MixBlendOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void MixBlendOperation::executePixelSampled(float output[4], 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);
-       this->m_inputColor1Operation->read(inputColor1, x, y, sampler);
-       this->m_inputColor2Operation->read(inputColor2, x, y, sampler);
+       this->m_inputValueOperation->readSampled(inputValue, x, y, sampler);
+       this->m_inputColor1Operation->readSampled(inputColor1, x, y, sampler);
+       this->m_inputColor2Operation->readSampled(inputColor2, x, y, sampler);
        value = inputValue[0];
        
        if (this->useValueAlphaMultiply()) {
@@ -167,16 +167,16 @@ MixBurnOperation::MixBurnOperation() : MixBaseOperation()
        /* pass */
 }
 
-void MixBurnOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void MixBurnOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputColor1[4];
        float inputColor2[4];
        float inputValue[4];
        float tmp;
 
-       this->m_inputValueOperation->read(inputValue, x, y, sampler);
-       this->m_inputColor1Operation->read(inputColor1, x, y, sampler);
-       this->m_inputColor2Operation->read(inputColor2, x, y, sampler);
+       this->m_inputValueOperation->readSampled(inputValue, x, y, sampler);
+       this->m_inputColor1Operation->readSampled(inputColor1, x, y, sampler);
+       this->m_inputColor2Operation->readSampled(inputColor2, x, y, sampler);
 
        float value = inputValue[0];
        if (this->useValueAlphaMultiply()) {
@@ -235,15 +235,15 @@ MixColorOperation::MixColorOperation() : MixBaseOperation()
        /* pass */
 }
 
-void MixColorOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void MixColorOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputColor1[4];
        float inputColor2[4];
        float inputValue[4];
 
-       this->m_inputValueOperation->read(inputValue, x, y, sampler);
-       this->m_inputColor1Operation->read(inputColor1, x, y, sampler);
-       this->m_inputColor2Operation->read(inputColor2, x, y, sampler);
+       this->m_inputValueOperation->readSampled(inputValue, x, y, sampler);
+       this->m_inputColor1Operation->readSampled(inputColor1, x, y, sampler);
+       this->m_inputColor2Operation->readSampled(inputColor2, x, y, sampler);
 
        float value = inputValue[0];
        if (this->useValueAlphaMultiply()) {
@@ -277,15 +277,15 @@ MixDarkenOperation::MixDarkenOperation() : MixBaseOperation()
        /* pass */
 }
 
-void MixDarkenOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void MixDarkenOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputColor1[4];
        float inputColor2[4];
        float inputValue[4];
 
-       this->m_inputValueOperation->read(inputValue, x, y, sampler);
-       this->m_inputColor1Operation->read(inputColor1, x, y, sampler);
-       this->m_inputColor2Operation->read(inputColor2, x, y, sampler);
+       this->m_inputValueOperation->readSampled(inputValue, x, y, sampler);
+       this->m_inputColor1Operation->readSampled(inputColor1, x, y, sampler);
+       this->m_inputColor2Operation->readSampled(inputColor2, x, y, sampler);
 
        float value = inputValue[0];
        if (this->useValueAlphaMultiply()) {
@@ -315,15 +315,15 @@ MixDifferenceOperation::MixDifferenceOperation() : MixBaseOperation()
        /* pass */
 }
 
-void MixDifferenceOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void MixDifferenceOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputColor1[4];
        float inputColor2[4];
        float inputValue[4];
 
-       this->m_inputValueOperation->read(inputValue, x, y, sampler);
-       this->m_inputColor1Operation->read(inputColor1, x, y, sampler);
-       this->m_inputColor2Operation->read(inputColor2, x, y, sampler);
+       this->m_inputValueOperation->readSampled(inputValue, x, y, sampler);
+       this->m_inputColor1Operation->readSampled(inputColor1, x, y, sampler);
+       this->m_inputColor2Operation->readSampled(inputColor2, x, y, sampler);
 
        float value = inputValue[0];
        if (this->useValueAlphaMultiply()) {
@@ -345,15 +345,15 @@ MixDivideOperation::MixDivideOperation() : MixBaseOperation()
        /* pass */
 }
 
-void MixDivideOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void MixDivideOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputColor1[4];
        float inputColor2[4];
        float inputValue[4];
 
-       this->m_inputValueOperation->read(inputValue, x, y, sampler);
-       this->m_inputColor1Operation->read(inputColor1, x, y, sampler);
-       this->m_inputColor2Operation->read(inputColor2, x, y, sampler);
+       this->m_inputValueOperation->readSampled(inputValue, x, y, sampler);
+       this->m_inputColor1Operation->readSampled(inputColor1, x, y, sampler);
+       this->m_inputColor2Operation->readSampled(inputColor2, x, y, sampler);
 
        float value = inputValue[0];
        if (this->useValueAlphaMultiply()) {
@@ -386,16 +386,16 @@ MixDodgeOperation::MixDodgeOperation() : MixBaseOperation()
        /* pass */
 }
 
-void MixDodgeOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void MixDodgeOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputColor1[4];
        float inputColor2[4];
        float inputValue[4];
        float tmp;
 
-       this->m_inputValueOperation->read(inputValue, x, y, sampler);
-       this->m_inputColor1Operation->read(inputColor1, x, y, sampler);
-       this->m_inputColor2Operation->read(inputColor2, x, y, sampler);
+       this->m_inputValueOperation->readSampled(inputValue, x, y, sampler);
+       this->m_inputColor1Operation->readSampled(inputColor1, x, y, sampler);
+       this->m_inputColor2Operation->readSampled(inputColor2, x, y, sampler);
 
        float value = inputValue[0];
        if (this->useValueAlphaMultiply()) {
@@ -459,16 +459,16 @@ MixGlareOperation::MixGlareOperation() : MixBaseOperation()
        /* pass */
 }
 
-void MixGlareOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void MixGlareOperation::executePixelSampled(float output[4], 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);
-       this->m_inputColor1Operation->read(inputColor1, x, y, sampler);
-       this->m_inputColor2Operation->read(inputColor2, x, y, sampler);
+       this->m_inputValueOperation->readSampled(inputValue, x, y, sampler);
+       this->m_inputColor1Operation->readSampled(inputColor1, x, y, sampler);
+       this->m_inputColor2Operation->readSampled(inputColor2, x, y, sampler);
        value = inputValue[0];
        float mf = 2.f - 2.f * fabsf(value - 0.5f);
 
@@ -491,15 +491,15 @@ MixHueOperation::MixHueOperation() : MixBaseOperation()
        /* pass */
 }
 
-void MixHueOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void MixHueOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputColor1[4];
        float inputColor2[4];
        float inputValue[4];
 
-       this->m_inputValueOperation->read(inputValue, x, y, sampler);
-       this->m_inputColor1Operation->read(inputColor1, x, y, sampler);
-       this->m_inputColor2Operation->read(inputColor2, x, y, sampler);
+       this->m_inputValueOperation->readSampled(inputValue, x, y, sampler);
+       this->m_inputColor1Operation->readSampled(inputColor1, x, y, sampler);
+       this->m_inputColor2Operation->readSampled(inputColor2, x, y, sampler);
 
        float value = inputValue[0];
        if (this->useValueAlphaMultiply()) {
@@ -533,15 +533,15 @@ MixLightenOperation::MixLightenOperation() : MixBaseOperation()
        /* pass */
 }
 
-void MixLightenOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void MixLightenOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputColor1[4];
        float inputColor2[4];
        float inputValue[4];
 
-       this->m_inputValueOperation->read(inputValue, x, y, sampler);
-       this->m_inputColor1Operation->read(inputColor1, x, y, sampler);
-       this->m_inputColor2Operation->read(inputColor2, x, y, sampler);
+       this->m_inputValueOperation->readSampled(inputValue, x, y, sampler);
+       this->m_inputColor1Operation->readSampled(inputColor1, x, y, sampler);
+       this->m_inputColor2Operation->readSampled(inputColor2, x, y, sampler);
 
        float value = inputValue[0];
        if (this->useValueAlphaMultiply()) {
@@ -569,15 +569,15 @@ MixLinearLightOperation::MixLinearLightOperation() : MixBaseOperation()
        /* pass */
 }
 
-void MixLinearLightOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void MixLinearLightOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputColor1[4];
        float inputColor2[4];
        float inputValue[4];
 
-       this->m_inputValueOperation->read(inputValue, x, y, sampler);
-       this->m_inputColor1Operation->read(inputColor1, x, y, sampler);
-       this->m_inputColor2Operation->read(inputColor2, x, y, sampler);
+       this->m_inputValueOperation->readSampled(inputValue, x, y, sampler);
+       this->m_inputColor1Operation->readSampled(inputColor1, x, y, sampler);
+       this->m_inputColor2Operation->readSampled(inputColor2, x, y, sampler);
 
        float value = inputValue[0];
        if (this->useValueAlphaMultiply()) {
@@ -608,15 +608,15 @@ MixMultiplyOperation::MixMultiplyOperation() : MixBaseOperation()
        /* pass */
 }
 
-void MixMultiplyOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void MixMultiplyOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputColor1[4];
        float inputColor2[4];
        float inputValue[4];
 
-       this->m_inputValueOperation->read(inputValue, x, y, sampler);
-       this->m_inputColor1Operation->read(inputColor1, x, y, sampler);
-       this->m_inputColor2Operation->read(inputColor2, x, y, sampler);
+       this->m_inputValueOperation->readSampled(inputValue, x, y, sampler);
+       this->m_inputColor1Operation->readSampled(inputColor1, x, y, sampler);
+       this->m_inputColor2Operation->readSampled(inputColor2, x, y, sampler);
 
        float value = inputValue[0];
        if (this->useValueAlphaMultiply()) {
@@ -638,15 +638,15 @@ MixOverlayOperation::MixOverlayOperation() : MixBaseOperation()
        /* pass */
 }
 
-void MixOverlayOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void MixOverlayOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputColor1[4];
        float inputColor2[4];
        float inputValue[4];
 
-       this->m_inputValueOperation->read(inputValue, x, y, sampler);
-       this->m_inputColor1Operation->read(inputColor1, x, y, sampler);
-       this->m_inputColor2Operation->read(inputColor2, x, y, sampler);
+       this->m_inputValueOperation->readSampled(inputValue, x, y, sampler);
+       this->m_inputColor1Operation->readSampled(inputColor1, x, y, sampler);
+       this->m_inputColor2Operation->readSampled(inputColor2, x, y, sampler);
 
        float value = inputValue[0];
        if (this->useValueAlphaMultiply()) {
@@ -685,15 +685,15 @@ MixSaturationOperation::MixSaturationOperation() : MixBaseOperation()
        /* pass */
 }
 
-void MixSaturationOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void MixSaturationOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputColor1[4];
        float inputColor2[4];
        float inputValue[4];
 
-       this->m_inputValueOperation->read(inputValue, x, y, sampler);
-       this->m_inputColor1Operation->read(inputColor1, x, y, sampler);
-       this->m_inputColor2Operation->read(inputColor2, x, y, sampler);
+       this->m_inputValueOperation->readSampled(inputValue, x, y, sampler);
+       this->m_inputColor1Operation->readSampled(inputColor1, x, y, sampler);
+       this->m_inputColor2Operation->readSampled(inputColor2, x, y, sampler);
 
        float value = inputValue[0];
        if (this->useValueAlphaMultiply()) {
@@ -724,15 +724,15 @@ MixScreenOperation::MixScreenOperation() : MixBaseOperation()
        /* pass */
 }
 
-void MixScreenOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void MixScreenOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputColor1[4];
        float inputColor2[4];
        float inputValue[4];
 
-       this->m_inputValueOperation->read(inputValue, x, y, sampler);
-       this->m_inputColor1Operation->read(inputColor1, x, y, sampler);
-       this->m_inputColor2Operation->read(inputColor2, x, y, sampler);
+       this->m_inputValueOperation->readSampled(inputValue, x, y, sampler);
+       this->m_inputColor1Operation->readSampled(inputColor1, x, y, sampler);
+       this->m_inputColor2Operation->readSampled(inputColor2, x, y, sampler);
 
        float value = inputValue[0];
        if (this->useValueAlphaMultiply()) {
@@ -755,15 +755,15 @@ MixSoftLightOperation::MixSoftLightOperation() : MixBaseOperation()
        /* pass */
 }
 
-void MixSoftLightOperation::executePixel(float output[4], float x, float y, PixelSampler sampler) \
+void MixSoftLightOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler) \
 {
        float inputColor1[4];
        float inputColor2[4];
        float inputValue[4];
 
-       this->m_inputValueOperation->read(inputValue, x, y, sampler);
-       this->m_inputColor1Operation->read(inputColor1, x, y, sampler);
-       this->m_inputColor2Operation->read(inputColor2, x, y, sampler);
+       this->m_inputValueOperation->readSampled(inputValue, x, y, sampler);
+       this->m_inputColor1Operation->readSampled(inputColor1, x, y, sampler);
+       this->m_inputColor2Operation->readSampled(inputColor2, x, y, sampler);
 
        float value = inputValue[0];
        if (this->useValueAlphaMultiply()) {
@@ -792,15 +792,15 @@ MixSubtractOperation::MixSubtractOperation() : MixBaseOperation()
        /* pass */
 }
 
-void MixSubtractOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void MixSubtractOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputColor1[4];
        float inputColor2[4];
        float inputValue[4];
 
-       this->m_inputValueOperation->read(inputValue,   x, y, sampler);
-       this->m_inputColor1Operation->read(inputColor1,   x, y, sampler);
-       this->m_inputColor2Operation->read(inputColor2,   x, y, sampler);
+       this->m_inputValueOperation->readSampled(inputValue,   x, y, sampler);
+       this->m_inputColor1Operation->readSampled(inputColor1,   x, y, sampler);
+       this->m_inputColor2Operation->readSampled(inputColor2,   x, y, sampler);
 
        float value = inputValue[0];
        if (this->useValueAlphaMultiply()) {
@@ -821,15 +821,15 @@ MixValueOperation::MixValueOperation() : MixBaseOperation()
        /* pass */
 }
 
-void MixValueOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void MixValueOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float inputColor1[4];
        float inputColor2[4];
        float inputValue[4];
 
-       this->m_inputValueOperation->read(inputValue, x, y, sampler);
-       this->m_inputColor1Operation->read(inputColor1, x, y, sampler);
-       this->m_inputColor2Operation->read(inputColor2, x, y, sampler);
+       this->m_inputValueOperation->readSampled(inputValue, x, y, sampler);
+       this->m_inputColor1Operation->readSampled(inputColor1, x, y, sampler);
+       this->m_inputColor2Operation->readSampled(inputColor2, x, y, sampler);
 
        float value = inputValue[0];
        if (this->useValueAlphaMultiply()) {
index 93dbe6f36a6cc1fa9d130fcc22f82a8a0db34f75..479ce161eea6b944e6dc45dae5dc7d3602fb08d6 100644 (file)
@@ -60,7 +60,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
        
        /**
         * Initialize the execution
@@ -83,115 +83,115 @@ public:
 class MixAddOperation : public MixBaseOperation {
 public:
        MixAddOperation();
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 
 class MixBlendOperation : public MixBaseOperation {
 public:
        MixBlendOperation();
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 
 class MixBurnOperation : public MixBaseOperation {
 public:
        MixBurnOperation();
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 
 class MixColorOperation : public MixBaseOperation {
 public:
        MixColorOperation();
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 
 class MixDarkenOperation : public MixBaseOperation {
 public:
        MixDarkenOperation();
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 
 class MixDifferenceOperation : public MixBaseOperation {
 public:
        MixDifferenceOperation();
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 
 class MixDivideOperation : public MixBaseOperation {
 public:
        MixDivideOperation();
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 
 class MixDodgeOperation : public MixBaseOperation {
 public:
        MixDodgeOperation();
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 
 class MixGlareOperation : public MixBaseOperation {
 public:
        MixGlareOperation();
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 
 class MixHueOperation : public MixBaseOperation {
 public:
        MixHueOperation();
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 
 class MixLightenOperation : public MixBaseOperation {
 public:
        MixLightenOperation();
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 
 class MixLinearLightOperation : public MixBaseOperation {
 public:
        MixLinearLightOperation();
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 
 class MixMultiplyOperation : public MixBaseOperation {
 public:
        MixMultiplyOperation();
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 
 class MixOverlayOperation : public MixBaseOperation {
 public:
        MixOverlayOperation();
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 
 class MixSaturationOperation : public MixBaseOperation {
 public:
        MixSaturationOperation();
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 
 class MixScreenOperation : public MixBaseOperation {
 public:
        MixScreenOperation();
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 
 class MixSoftLightOperation : public MixBaseOperation {
 public:
        MixSoftLightOperation();
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 
 class MixSubtractOperation : public MixBaseOperation {
 public:
        MixSubtractOperation();
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 
 class MixValueOperation : public MixBaseOperation {
 public:
        MixValueOperation();
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 
 #endif
index 0d2de47bc4f16457b1beed76c7d429dbc543df76..fbbfa8fd65ea4b8eb888fbb0bfbc2d65c150d2ae 100644 (file)
@@ -33,7 +33,7 @@ MovieClipAttributeOperation::MovieClipAttributeOperation() : NodeOperation()
        this->m_attribute = MCA_X;
 }
 
-void MovieClipAttributeOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void MovieClipAttributeOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        if (!this->m_valueSet) {
                float loc[2], scale, angle;
index f894626d534545193b87020532f3f17acd46610e..49c86c7fafc4f0e0dfc869bd89a19c22ef5387f7 100644 (file)
@@ -51,7 +51,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
        void determineResolution(unsigned int resolution[2], unsigned int preferredResolution[2]);
 
        void setMovieClip(MovieClip *clip) { this->m_clip = clip; }
index 76dc093035c21f0261aa43d5a4d4080f68bbb6ba..5b75113e7f35d3d5a5198771eaf846d541bdeb18 100644 (file)
@@ -86,7 +86,7 @@ void MovieClipBaseOperation::determineResolution(unsigned int resolution[2], uns
        }
 }
 
-void MovieClipBaseOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void MovieClipBaseOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        ImBuf *ibuf = this->m_movieClipBuffer;
 
@@ -122,9 +122,9 @@ MovieClipAlphaOperation::MovieClipAlphaOperation() : MovieClipBaseOperation()
        this->addOutputSocket(COM_DT_VALUE);
 }
 
-void MovieClipAlphaOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void MovieClipAlphaOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
-       MovieClipBaseOperation::executePixel(output, x, y, sampler);
+       MovieClipBaseOperation::executePixelSampled(output, x, y, sampler);
        output[0] = output[3];
        output[1] = 0.0f;
        output[2] = 0.0f;
index a368dca423cb74f2cea63acb5f332f94e199aa94..c16262cbd0246425d7f7ad8bad7c031560f01e26 100644 (file)
@@ -57,7 +57,7 @@ public:
        void setCacheFrame(bool value) { this->m_cacheFrame = value; }
 
        void setFramenumber(int framenumber) { this->m_framenumber = framenumber; }
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 
 class MovieClipOperation : public MovieClipBaseOperation {
@@ -68,7 +68,7 @@ public:
 class MovieClipAlphaOperation : public MovieClipBaseOperation {
 public:
        MovieClipAlphaOperation();
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 
 #endif
index 863a404ba676621e25881fece887371d850d4bef..a8c7728160dda7f8e1293cddedea1f39cefcd4ed 100644 (file)
@@ -122,16 +122,16 @@ void MovieDistortionOperation::deinitExecution()
 }
 
 
-void MovieDistortionOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void MovieDistortionOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        
        if (this->m_cache != NULL) {
                float u, v;
                this->m_cache->getUV(&this->m_movieClip->tracking, x, y, &u, &v);
-               this->m_inputOperation->read(output, u, v, COM_PS_BILINEAR);
+               this->m_inputOperation->readSampled(output, u, v, COM_PS_BILINEAR);
        }
        else {
-               this->m_inputOperation->read(output, x, y, COM_PS_BILINEAR);
+               this->m_inputOperation->readSampled(output, x, y, COM_PS_BILINEAR);
        }
 }
 
index c96294519929682d8d86eb9d26fd541af00730eb..42c4a84f9b25b2e9b1f7ffadeaec76d47bf830c7 100644 (file)
@@ -156,7 +156,7 @@ protected:
 
 public:
        MovieDistortionOperation(bool distortion);
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 
        void initExecution();
        void deinitExecution();
index e2a95b2e33b3b0ee93b8bfaa1ce77ceb4e72524b..84c1fdfb6f5c67c0324b6f0802943ac4a975d2e5 100644 (file)
@@ -42,7 +42,7 @@ ImBuf *MultilayerBaseOperation::getImBuf()
        return NULL;
 }
 
-void MultilayerColorOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void MultilayerColorOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        int yi = y;
        int xi = x;
@@ -70,7 +70,7 @@ void MultilayerColorOperation::executePixel(float output[4], float x, float y, P
        }
 }
 
-void MultilayerValueOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void MultilayerValueOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        int yi = y;
        int xi = x;
@@ -83,7 +83,7 @@ void MultilayerValueOperation::executePixel(float output[4], float x, float y, P
        }
 }
 
-void MultilayerVectorOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void MultilayerVectorOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        int yi = y;
        int xi = x;
index 065bcc7da1e882e5f3665332448685f220e81798..37bee1b6a8c33ae564164dba020bf892986614d9 100644 (file)
@@ -46,7 +46,7 @@ public:
        MultilayerColorOperation(int passindex) : MultilayerBaseOperation(passindex) {
                this->addOutputSocket(COM_DT_COLOR);
        }
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 
 class MultilayerValueOperation : public MultilayerBaseOperation {
@@ -54,7 +54,7 @@ public:
        MultilayerValueOperation(int passindex) : MultilayerBaseOperation(passindex) {
                this->addOutputSocket(COM_DT_VALUE);
        }
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 
 class MultilayerVectorOperation : public MultilayerBaseOperation {
@@ -62,7 +62,7 @@ public:
        MultilayerVectorOperation(int passindex) : MultilayerBaseOperation(passindex) {
                this->addOutputSocket(COM_DT_VECTOR);
        }
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 
 #endif
index a5be993f24130a3523fc9ebc4445712d75b2bd40..c94387337c3dcc2774b21ba034515b1cd83eb257 100644 (file)
@@ -79,7 +79,7 @@ static void write_buffer_rect(rcti *rect, const bNodeTree *tree,
 
        for (y = y1; y < y2 && (!breaked); y++) {
                for (x = x1; x < x2 && (!breaked); x++) {
-                       reader->read(color, x, y, COM_PS_NEAREST);
+                       reader->readSampled(color, x, y, COM_PS_NEAREST);
                        
                        for (i = 0; i < size; ++i)
                                buffer[offset + i] = color[i];
index 89e7f0093a1aa2a28d6c75f955d22c36c5c0626e..eed6d1d01b91642b926825629b1ccd4ed90847cc 100644 (file)
@@ -40,10 +40,10 @@ void PixelateOperation::deinitExecution()
        this->m_inputOperation = NULL;
 }
 
-void PixelateOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void PixelateOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float nx = round(x);
        float ny = round(y);
-       this->m_inputOperation->read(output, nx, ny, sampler);
+       this->m_inputOperation->readSampled(output, nx, ny, sampler);
 }
 
index 83603a593315ccac8d936e037095beac895c3003..8e60baf7f0520420151a4cecde35a9ffd9b24216 100644 (file)
@@ -62,7 +62,7 @@ public:
         * @param y y-coordinate
         * @param sampler sampler
         */
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 
 #endif
index 8aa1324d8e2803dae5ddbef126f21b4ac9302ddc..58fa4bd08dcd68340d9728b5b147e66758d2a99f 100644 (file)
@@ -50,7 +50,7 @@ void PlaneTrackMaskOperation::initExecution()
        BLI_jitter_init(this->m_jitter[0], this->m_osa);
 }
 
-void PlaneTrackMaskOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void PlaneTrackMaskOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float point[2];
 
index db32f9830e0ff520be7dc6c2dcd686bc075be83c..7f76395407963426a17fd29874a1954d69870d49 100644 (file)
@@ -43,7 +43,7 @@ public:
 
        void initExecution();
 
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 
 #endif
index df487a766f3a89ef4333b700e1f50b47573e98a0..e3788f89b2df0ef89631eac2cb87f7157caac4c8 100644 (file)
@@ -125,7 +125,7 @@ void PlaneTrackWarpImageOperation::deinitExecution()
        this->m_pixelReader = NULL;
 }
 
-void PlaneTrackWarpImageOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void PlaneTrackWarpImageOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float color_accum[4];
 
@@ -142,7 +142,7 @@ void PlaneTrackWarpImageOperation::executePixel(float output[4], float x, float
                        u *= this->m_pixelReader->getWidth();
                        v *= this->m_pixelReader->getHeight();
 
-                       this->m_pixelReader->read(current_color, u, v, dx, dy, COM_PS_NEAREST);
+                       this->m_pixelReader->readFiltered(current_color, u, v, dx, dy, COM_PS_NEAREST);
                        add_v4_v4(color_accum, current_color);
                }
        }
index a92ff3f9ddf3f733715fe2afd81c40c99c21069d..4d73a01cad0e22db083929970fde1b27bf710bcb 100644 (file)
@@ -45,7 +45,7 @@ public:
        void initExecution();
        void deinitExecution();
 
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 
        bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output);
 };
index ba158fb250960926c74d67bf158a2da13e840f55..add9e8b959e3f1250dbe430df212e3b9c0dd1449 100644 (file)
@@ -104,7 +104,7 @@ void PreviewOperation::executeRegion(rcti *rect, unsigned int tileNumber)
                        color[1] = 0.0f;
                        color[2] = 0.0f;
                        color[3] = 1.0f;
-                       this->m_input->read(color, rx, ry, COM_PS_NEAREST);
+                       this->m_input->readSampled(color, rx, ry, COM_PS_NEAREST);
                        IMB_colormanagement_processor_apply_v4(cm_processor, color);
                        F4TOCHAR4(color, this->m_outputBuffer + offset);
                        offset += 4;
index e8b900b9a850be0e80db9b75289d40a8eb20e812..7f6079c55aa5ed16af1f774f1e7ed4a61fd88993 100644 (file)
@@ -102,7 +102,7 @@ void ProjectorLensDistortionOperation::updateDispersion()
        this->lockMutex();
        if (!this->m_dispersionAvailable) {
                float result[4];
-               this->getInputSocketReader(1)->read(result, 1, 1, COM_PS_NEAREST);
+               this->getInputSocketReader(1)->readSampled(result, 1, 1, COM_PS_NEAREST);
                this->m_dispersion = result[0];
                this->m_kr = 0.25f * max_ff(min_ff(this->m_dispersion, 1.0f), 0.0f);
                this->m_kr2 = this->m_kr * 20;
index 3aeef6bf409b1392e71c2cf29b855011c0b95f27..b93e338ad6c4c362ce8a6b987ae35c24790646fc 100644 (file)
@@ -52,7 +52,7 @@ void ReadBufferOperation::determineResolution(unsigned int resolution[2], unsign
                m_single_value = operation->isSingleValue();
        }
 }
-void ReadBufferOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void ReadBufferOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        if (m_single_value) {
                /* write buffer has a single value stored at (0,0) */
@@ -81,7 +81,7 @@ void ReadBufferOperation::executePixelExtend(float output[4], float x, float y,
        }
 }
 
-void ReadBufferOperation::executePixel(float output[4], float x, float y, float dx, float dy, PixelSampler sampler)
+void ReadBufferOperation::executePixelFiltered(float output[4], float x, float y, float dx, float dy, PixelSampler sampler)
 {
        if (m_single_value) {
                /* write buffer has a single value stored at (0,0) */
index 7a67056eda65d60e7e99e5c67fe65c5fd09128c7..cdc6e50f6d4ca0274c6c0417c14e93c1bbd761c8 100644 (file)
@@ -40,10 +40,10 @@ public:
        void determineResolution(unsigned int resolution[2], unsigned int preferredResolution[2]);
        
        void *initializeTileData(rcti *rect);
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
        void executePixelExtend(float output[4], float x, float y, PixelSampler sampler,
                                MemoryBufferExtend extend_x, MemoryBufferExtend extend_y);
-       void executePixel(float output[4], float x, float y, float dx, float dy, PixelSampler sampler);
+       void executePixelFiltered(float output[4], float x, float y, float dx, float dy, PixelSampler sampler);
        const bool isReadBufferOperation() const { return true; }
        void setOffset(unsigned int offset) { this->m_offset = offset; }
        unsigned int getOffset() const { return this->m_offset; }
index a8382dd1746418744e508dfc0ffea98e9894e8f4..2c2a4c6f1805897b4039e2ba7ec8442813a64a20 100644 (file)
@@ -112,7 +112,7 @@ void RenderLayersBaseProg::doInterpolation(float output[4], float x, float y, Pi
        }
 }
 
-void RenderLayersBaseProg::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void RenderLayersBaseProg::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
 #if 0
        const RenderData *rd = this->m_rd;
@@ -192,7 +192,7 @@ RenderLayersAlphaProg::RenderLayersAlphaProg() : RenderLayersBaseProg(SCE_PASS_C
        this->addOutputSocket(COM_DT_VALUE);
 }
 
-void RenderLayersAlphaProg::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void RenderLayersAlphaProg::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        int ix = x;
        int iy = y;
@@ -234,7 +234,7 @@ RenderLayersDepthProg::RenderLayersDepthProg() : RenderLayersBaseProg(SCE_PASS_Z
        this->addOutputSocket(COM_DT_VALUE);
 }
 
-void RenderLayersDepthProg::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void RenderLayersDepthProg::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        int ix = x;
        int iy = y;
index 04861174387e38131b1c933c0c03872f65d7cfd8..b76a8621b19eab83c94423f6f2a0b5e307783d85 100644 (file)
@@ -99,7 +99,7 @@ public:
        short getLayerId() { return this->m_layerId; }
        void initExecution();
        void deinitExecution();
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 
 class RenderLayersAOOperation : public RenderLayersBaseProg {
@@ -110,7 +110,7 @@ public:
 class RenderLayersAlphaProg : public RenderLayersBaseProg {
 public:
        RenderLayersAlphaProg();
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 
 class RenderLayersColorOperation : public RenderLayersBaseProg {
@@ -126,7 +126,7 @@ public:
 class RenderLayersDepthProg : public RenderLayersBaseProg {
 public:
        RenderLayersDepthProg();
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 
 class RenderLayersDiffuseOperation : public RenderLayersBaseProg {
index 422c5b93484d7572b57941027e42d86edb95d014..c6ad87bbf9707297d2d946fd95eb4ea09321075f 100644 (file)
@@ -52,7 +52,7 @@ inline void RotateOperation::ensureDegree()
 {
        if (!this->m_isDegreeSet) {
                float degree[4];
-               this->m_degreeSocket->read(degree, 0, 0, COM_PS_NEAREST);
+               this->m_degreeSocket->readSampled(degree, 0, 0, COM_PS_NEAREST);
                double rad;
                if (this->m_doDegree2RadConversion) {
                        rad = DEG2RAD((double)degree[0]);
@@ -68,14 +68,14 @@ inline void RotateOperation::ensureDegree()
 }
 
 
-void RotateOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void RotateOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        ensureDegree();
        const float dy = y - this->m_centerY;
        const float dx = x - this->m_centerX;
        const float nx = this->m_centerX + (this->m_cosine * dx + this->m_sine * dy);
        const float ny = this->m_centerY + (-this->m_sine * dx + this->m_cosine * dy);
-       this->m_imageSocket->read(output, nx, ny, sampler);
+       this->m_imageSocket->readSampled(output, nx, ny, sampler);
 }
 
 bool RotateOperation::determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output)
index 292f0743a445d3447bf2f0bcc75a665b61a84261..40acad1abe63c661750f92500d26b05f050cfe2b 100644 (file)
@@ -38,7 +38,7 @@ private:
 public:
        RotateOperation();
        bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output);
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
        void initExecution();
        void deinitExecution();
        void setDoDegree2RadConversion(bool abool) { this->m_doDegree2RadConversion = abool; }
index 9e8f5af0ef066e6c80772634cc178c32cd5c70b6..452765a5ab7d6edec4d295b756fa48e9bc919000 100644 (file)
@@ -66,22 +66,22 @@ void ScaleOperation::deinitExecution()
 }
 
 
-void ScaleOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void ScaleOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        PixelSampler effective_sampler = getEffectiveSampler(sampler);
 
        float scaleX[4];
        float scaleY[4];
 
-       this->m_inputXOperation->read(scaleX, x, y, effective_sampler);
-       this->m_inputYOperation->read(scaleY, x, y, effective_sampler);
+       this->m_inputXOperation->readSampled(scaleX, x, y, effective_sampler);
+       this->m_inputYOperation->readSampled(scaleY, x, y, effective_sampler);
 
        const float scx = scaleX[0];
        const float scy = scaleY[0];
 
        float nx = this->m_centerX + (x - this->m_centerX) / scx;
        float ny = this->m_centerY + (y - this->m_centerY) / scy;
-       this->m_inputOperation->read(output, nx, ny, effective_sampler);
+       this->m_inputOperation->readSampled(output, nx, ny, effective_sampler);
 }
 
 bool ScaleOperation::determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output)
@@ -90,8 +90,8 @@ bool ScaleOperation::determineDependingAreaOfInterest(rcti *input, ReadBufferOpe
        float scaleX[4];
        float scaleY[4];
 
-       this->m_inputXOperation->read(scaleX, 0, 0, COM_PS_NEAREST);
-       this->m_inputYOperation->read(scaleY, 0, 0, COM_PS_NEAREST);
+       this->m_inputXOperation->readSampled(scaleX, 0, 0, COM_PS_NEAREST);
+       this->m_inputYOperation->readSampled(scaleY, 0, 0, COM_PS_NEAREST);
 
        const float scx = scaleX[0];
        const float scy = scaleY[0];
@@ -134,15 +134,15 @@ void ScaleAbsoluteOperation::deinitExecution()
 }
 
 
-void ScaleAbsoluteOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void ScaleAbsoluteOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        PixelSampler effective_sampler = getEffectiveSampler(sampler);
 
        float scaleX[4];
        float scaleY[4];
 
-       this->m_inputXOperation->read(scaleX, x, y, effective_sampler);
-       this->m_inputYOperation->read(scaleY, x, y, effective_sampler);
+       this->m_inputXOperation->readSampled(scaleX, x, y, effective_sampler);
+       this->m_inputYOperation->readSampled(scaleY, x, y, effective_sampler);
 
        const float scx = scaleX[0]; // target absolute scale
        const float scy = scaleY[0]; // target absolute scale
@@ -156,7 +156,7 @@ void ScaleAbsoluteOperation::executePixel(float output[4], float x, float y, Pix
        float nx = this->m_centerX + (x - this->m_centerX) / relativeXScale;
        float ny = this->m_centerY + (y - this->m_centerY) / relativeYScale;
 
-       this->m_inputOperation->read(output, nx, ny, effective_sampler);
+       this->m_inputOperation->readSampled(output, nx, ny, effective_sampler);
 }
 
 bool ScaleAbsoluteOperation::determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output)
@@ -165,8 +165,8 @@ bool ScaleAbsoluteOperation::determineDependingAreaOfInterest(rcti *input, ReadB
        float scaleX[4];
        float scaleY[4];
 
-       this->m_inputXOperation->read(scaleX, 0, 0, COM_PS_NEAREST);
-       this->m_inputYOperation->read(scaleY, 0, 0, COM_PS_NEAREST);
+       this->m_inputXOperation->readSampled(scaleX, 0, 0, COM_PS_NEAREST);
+       this->m_inputYOperation->readSampled(scaleY, 0, 0, COM_PS_NEAREST);
 
        const float scx = scaleX[0];
        const float scy = scaleY[0];
@@ -253,17 +253,17 @@ void ScaleFixedSizeOperation::deinitExecution()
 }
 
 
-void ScaleFixedSizeOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void ScaleFixedSizeOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        PixelSampler effective_sampler = getEffectiveSampler(sampler);
 
        if (this->m_is_offset) {
                float nx = ((x - this->m_offsetX) * this->m_relX);
                float ny = ((y - this->m_offsetY) * this->m_relY);
-               this->m_inputOperation->read(output, nx, ny, effective_sampler);
+               this->m_inputOperation->readSampled(output, nx, ny, effective_sampler);
        }
        else {
-               this->m_inputOperation->read(output, x * this->m_relX, y * this->m_relY, effective_sampler);
+               this->m_inputOperation->readSampled(output, x * this->m_relX, y * this->m_relY, effective_sampler);
        }
 }
 
index f42cdbd78ed6b28b08bae71a35e9f1473c5cabc7..706a5898027eefe6d62d03f67c809a442d5ac663 100644 (file)
@@ -47,7 +47,7 @@ private:
 public:
        ScaleOperation();
        bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output);
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 
        void initExecution();
        void deinitExecution();
@@ -63,7 +63,7 @@ class ScaleAbsoluteOperation : public BaseScaleOperation {
 public:
        ScaleAbsoluteOperation();
        bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output);
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 
        void initExecution();
        void deinitExecution();
@@ -88,7 +88,7 @@ public:
        ScaleFixedSizeOperation();
        bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output);
        void determineResolution(unsigned int resolution[2], unsigned int preferredResolution[2]);
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 
        void initExecution();
        void deinitExecution();
index d1060224444e094bfbc3607f3ebe8378604ad98b..5d2977d361b3e573784612f868d735a375cc499b 100644 (file)
@@ -291,9 +291,9 @@ void ScreenLensDistortionOperation::updateDispersionAndDistortion()
        this->lockMutex();
        if (!this->m_valuesAvailable) {
                float result[4];
-               this->getInputSocketReader(1)->read(result, 0, 0, COM_PS_NEAREST);
+               this->getInputSocketReader(1)->readSampled(result, 0, 0, COM_PS_NEAREST);
                this->m_distortion = result[0];
-               this->getInputSocketReader(2)->read(result, 0, 0, COM_PS_NEAREST);
+               this->getInputSocketReader(2)->readSampled(result, 0, 0, COM_PS_NEAREST);
                this->m_dispersion = result[0];
                updateVariables(this->m_distortion, this->m_dispersion);
                this->m_valuesAvailable = true;
index fc6cfa455f3209410b8c139e5d80546d688bfaf0..efdc844704a6ffdc73ee64e52d3e4c14d935ab9f 100644 (file)
@@ -38,12 +38,12 @@ void SetAlphaOperation::initExecution()
        this->m_inputAlpha = getInputSocketReader(1);
 }
 
-void SetAlphaOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void SetAlphaOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float alphaInput[4];
        
-       this->m_inputColor->read(output, x, y, sampler);
-       this->m_inputAlpha->read(alphaInput, x, y, sampler);
+       this->m_inputColor->readSampled(output, x, y, sampler);
+       this->m_inputAlpha->readSampled(alphaInput, x, y, sampler);
        
        output[3] = alphaInput[0];
 }
index 1ec4a7aeacf9b188ece1f64d4194160523fa4317..a0869ec90b2096859e51acbb3fb3931594696b54 100644 (file)
@@ -43,7 +43,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
        
        void initExecution();
        void deinitExecution();
index 44c29b3befda6b3e748a27c414f48cf6f2079ba8..94a863e628b2b4226ebaefbbc54663d2d2dd11d0 100644 (file)
@@ -27,7 +27,7 @@ SetColorOperation::SetColorOperation() : NodeOperation()
        this->addOutputSocket(COM_DT_COLOR);
 }
 
-void SetColorOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void SetColorOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        copy_v4_v4(output, this->m_color);
 }
index 8377decdd7bcd621d1adbd1dcbd408aba1e09884..7dfed6b570bbf9b32aba80e500d765f5260e3e89 100644 (file)
@@ -55,7 +55,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 
        void determineResolution(unsigned int resolution[2], unsigned int preferredResolution[2]);
        bool isSetOperation() const { return true; }
index 343b5973f7e77ca66e07260f30785f5f712bdbb0..be72ffd0336f19ebdf203dd6e06b1e000f2d6d6f 100644 (file)
@@ -37,7 +37,7 @@ void SetSamplerOperation::deinitExecution()
        this->m_reader = NULL;
 }
 
-void SetSamplerOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void SetSamplerOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
-       this->m_reader->read(output, x, y, this->m_sampler);
+       this->m_reader->readSampled(output, x, y, this->m_sampler);
 }
index c94e174fc813e33bfb15d4f62d2629bd975ebbef..145d82bd407a673ab084dc99b357cd66607de686 100644 (file)
@@ -44,7 +44,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
        void initExecution();
        void deinitExecution();
 };
index c5ce3e4c09ce2e118e7186d3c2d58f376c0e637b..51e09a63051f1d49ccddece8af410fbeb2071c4c 100644 (file)
@@ -27,7 +27,7 @@ SetValueOperation::SetValueOperation() : NodeOperation()
        this->addOutputSocket(COM_DT_VALUE);
 }
 
-void SetValueOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void SetValueOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        output[0] = this->m_value;
 }
index b88b85d66f2e1d40c93ec2ac67775a1ebcf4d2b5..7cb914ffa488fea925707ada2a34ff8265662a18 100644 (file)
@@ -46,7 +46,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
        void determineResolution(unsigned int resolution[2], unsigned int preferredResolution[2]);
        
        bool isSetOperation() const { return true; }
index d5c665e81f5b6c45d8b419832af7f7d59872a755..17212d78e15a8a0f566ca6c3b69851d1ad63484d 100644 (file)
@@ -28,7 +28,7 @@ SetVectorOperation::SetVectorOperation() : NodeOperation()
        this->addOutputSocket(COM_DT_VECTOR);
 }
 
-void SetVectorOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void SetVectorOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        output[0] = this->m_x;
        output[1] = this->m_y;
index d15da58e58e9de07d8e245776a957fe24eaa2c5d..6fd1b9768fc08546734b737f3775cdc2243dd010 100644 (file)
@@ -54,7 +54,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 
        void determineResolution(unsigned int resolution[2], unsigned int preferredResolution[2]);
        bool isSetOperation() const { return true; }
index ac2cee8eb4447889e33f7da74d84eda1c8e61d59..d047198ac9327550072b1044a4201b986cc1a39a 100644 (file)
@@ -39,9 +39,9 @@ void SocketProxyOperation::deinitExecution()
        this->m_inputOperation = NULL;
 }
 
-void SocketProxyOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void SocketProxyOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        if (this->m_inputOperation) {
-               this->m_inputOperation->read(output, x, y, sampler);
+               this->m_inputOperation->readSampled(output, x, y, sampler);
        }
 }
index a37384455ca459dc39530032a40ee7b5209e929c..6a6a0b351b0f847781f42b721ee0c1157d2c3a67 100644 (file)
@@ -30,7 +30,7 @@ private:
        SocketReader *m_inputOperation;
 public:
        SocketProxyOperation(DataType type);
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
        
        void initExecution();
        void deinitExecution();
index a7dbccfc2f7d4d16c6d1a4a11a08227c3b3d7cfb..210095f3bf1da513e85f071b3edd359e7ee75275 100644 (file)
@@ -57,15 +57,15 @@ void SplitOperation::deinitExecution()
        this->m_image2Input = NULL;
 }
 
-void SplitOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void SplitOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        int perc = this->m_xSplit ? this->m_splitPercentage * this->getWidth() / 100.0f : this->m_splitPercentage * this->getHeight() / 100.0f;
        bool image1 = this->m_xSplit ? x > perc : y > perc;
        if (image1) {
-               this->m_image1Input->read(output, x, y, COM_PS_NEAREST);
+               this->m_image1Input->readSampled(output, x, y, COM_PS_NEAREST);
        }
        else {
-               this->m_image2Input->read(output, x, y, COM_PS_NEAREST);
+               this->m_image2Input->readSampled(output, x, y, COM_PS_NEAREST);
        }
 }
 
index 5a042b789d8cb51757d7a7dd958b42152d557b16..2853c845d030a3a89fa9c34b4dc09ea091db4ed7 100644 (file)
@@ -35,7 +35,7 @@ public:
        SplitOperation();
        void initExecution();
        void deinitExecution();
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
        void determineResolution(unsigned int resolution[2], unsigned int preferredResolution[2]);
        void setSplitPercentage(float splitPercentage) { this->m_splitPercentage = splitPercentage; }
        void setXSplit(bool xsplit) { this->m_xSplit = xsplit; }
index bbb7c8b52891489a3225d8ec0e65f42e97ceb876..96aea56050f0389867f64fa01697127ae1b20958 100644 (file)
@@ -75,16 +75,16 @@ void TextureBaseOperation::determineResolution(unsigned int resolution[2], unsig
        }
 }
 
-void TextureAlphaOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void TextureAlphaOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
-       TextureBaseOperation::executePixel(output, x, y, sampler);
+       TextureBaseOperation::executePixelSampled(output, x, y, sampler);
        output[0] = output[3];
        output[1] = 0.0f;
        output[2] = 0.0f;
        output[3] = 0.0f;
 }
 
-void TextureBaseOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void TextureBaseOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        TexResult texres = {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0, NULL};
        float textureSize[4];
@@ -96,8 +96,8 @@ void TextureBaseOperation::executePixel(float output[4], float x, float y, Pixel
        const float u = (x - cx) / this->getWidth() * 2;
        const float v = (y - cy) / this->getHeight() * 2;
 
-       this->m_inputSize->read(textureSize, x, y, sampler);
-       this->m_inputOffset->read(textureOffset, x, y, sampler);
+       this->m_inputSize->readSampled(textureSize, x, y, sampler);
+       this->m_inputOffset->readSampled(textureOffset, x, y, sampler);
 
        vec[0] = textureSize[0] * (u + textureOffset[0]);
        vec[1] = textureSize[1] * (v + textureOffset[1]);
@@ -136,7 +136,7 @@ MemoryBuffer *TextureBaseOperation::createMemoryBuffer(rcti *rect2)
 
        for (int y = 0; y < height; y++) {
                for (int x = 0; x < width; x++, data += 4) {
-                       this->executePixel(data, x, y, COM_PS_NEAREST);
+                       this->executePixelSampled(data, x, y, COM_PS_NEAREST);
                }
        }
 
index b776f6f2493ee1d8d6824c98c227bcd9252d09ae..064e63c025aaf2c806e5cea2e725f7029bf6fa8e 100644 (file)
@@ -62,7 +62,7 @@ protected:
 
        MemoryBuffer *createMemoryBuffer(rcti *rect2);
 public:
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 
        void setTexture(Tex *texture) { this->m_texture = texture; }
        void initExecution();
@@ -79,7 +79,7 @@ public:
 class TextureAlphaOperation : public TextureBaseOperation {
 public:
        TextureAlphaOperation();
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 
 };
 
index 4f00358633abe827d478e207cea09c463e785745..721b17bcff0107e61fe933b642fb9b58731397eb 100644 (file)
@@ -102,7 +102,7 @@ void TrackPositionOperation::initExecution()
        }
 }
 
-void TrackPositionOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void TrackPositionOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        output[0] = this->m_markerPos[this->m_axis] - this->m_relativePos[this->m_axis];
 
index 7a4ce9f92130f84400bed23c3cff9f91b45bbdca..10dbaf96646869ac279a4f23c7cdc7870ab73e0b 100644 (file)
@@ -70,7 +70,7 @@ public:
 
        void initExecution();
 
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 
        bool isSetOperation() const { return true; }
 };
index e2582c3b67b78b9e3e389a4de5ca49f16f600a7f..64da954a2e10159b0b92f1af721952a2cb9adffc 100644 (file)
@@ -52,14 +52,14 @@ void TranslateOperation::deinitExecution()
 }
 
 
-void TranslateOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void TranslateOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        ensureDelta();
 
        float originalXPos = x - this->getDeltaX();
        float originalYPos = y - this->getDeltaY();
 
-       this->m_inputOperation->read(output, originalXPos, originalYPos, sampler);
+       this->m_inputOperation->readSampled(output, originalXPos, originalYPos, sampler);
 }
 
 bool TranslateOperation::determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output)
index a638ae7ce69ccf3dc1e6ee9962c63fe0cddb7367..f2ae976e2efb48bee9ee576117b7903546986dbc 100644 (file)
@@ -38,7 +38,7 @@ private:
 public:
        TranslateOperation();
        bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output);
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 
        void initExecution();
        void deinitExecution();
@@ -49,9 +49,9 @@ public:
        inline void ensureDelta() {
                if (!this->m_isDeltaSet) {
                        float tempDelta[4];
-                       this->m_inputXOperation->read(tempDelta, 0, 0, COM_PS_NEAREST);
+                       this->m_inputXOperation->readSampled(tempDelta, 0, 0, COM_PS_NEAREST);
                        this->m_deltaX = tempDelta[0];
-                       this->m_inputYOperation->read(tempDelta, 0, 0, COM_PS_NEAREST);
+                       this->m_inputYOperation->readSampled(tempDelta, 0, 0, COM_PS_NEAREST);
                        this->m_deltaY = tempDelta[0];
                        this->m_isDeltaSet = true;
                }
index 03031e0f76409cf8b69582afda153217fdb534b5..8bdaa0f486ee4227dcb28aff11ec3288c9228173 100644 (file)
@@ -338,7 +338,7 @@ voi *InverseSearchRadiusOperation::initializeTileData(rcti *rect)
        return data;
 }
 
-void InverseSearchRadiusOperation::executePixel(float output[4], int x, int y, void *data)
+void InverseSearchRadiusOperation::executePixelChunk(float output[4], int x, int y, void *data)
 {
        MemoryBuffer *buffer = (MemoryBuffer *)data;
        buffer->readNoCheck(color, x, y);
index 7ba8df16795db2bbde61f16f765dd73a947e9113..cab38698296db89fd8525552e5f4c44ee0f4ba1d 100644 (file)
@@ -85,7 +85,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float output[4], int x, int y, MemoryBuffer *inputBuffers[], void *data);
+       void executePixelChunk(float output[4], int x, int y, void *data);
        
        /**
         * Initialize the execution
index 6450b0716a38f0e12248824132b1bef66a4f5431..204b0f2011b9516ba9c2bf6ea52d97e041435141 100644 (file)
@@ -43,12 +43,12 @@ void VectorCurveOperation::initExecution()
        this->m_inputProgram = this->getInputSocketReader(0);
 }
 
-void VectorCurveOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void VectorCurveOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float input[4];
 
 
-       this->m_inputProgram->read(input, x, y, sampler);
+       this->m_inputProgram->readSampled(input, x, y, sampler);
 
        curvemapping_evaluate_premulRGBF(this->m_curveMapping, output, input);
        output[3] = input[3];
index 6a1f916c60ba23d0b27452e00b54a4d56ae360ae..677af77b05e3238dd97d2653f4ec228f09e3b1ab 100644 (file)
@@ -37,7 +37,7 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
        
        /**
         * Initialize the execution
index 97be44e2be03e73c716aa0fc075c05a813f51f6f..13b50910b50642d858ef91e15ab6e991fa99a06b 100644 (file)
@@ -101,18 +101,18 @@ void ViewerOperation::executeRegion(rcti *rect, unsigned int tileNumber)
 
        for (y = y1; y < y2 && (!breaked); y++) {
                for (x = x1; x < x2; x++) {
-                       this->m_imageInput->read(&(buffer[offset4]), x, y, COM_PS_NEAREST);
+                       this->m_imageInput->readSampled(&(buffer[offset4]), x, y, COM_PS_NEAREST);
                        if (this->m_ignoreAlpha) {
                                buffer[offset4 + 3] = 1.0f;
                        }
                        else {
                                if (this->m_alphaInput != NULL) {
-                                       this->m_alphaInput->read(alpha, x, y, COM_PS_NEAREST);
+                                       this->m_alphaInput->readSampled(alpha, x, y, COM_PS_NEAREST);
                                        buffer[offset4 + 3] = alpha[0];
                                }
                        }
                        if (m_depthInput) {
-                               this->m_depthInput->read(depth, x, y, COM_PS_NEAREST);
+                               this->m_depthInput->readSampled(depth, x, y, COM_PS_NEAREST);
                                depthbuffer[offset] = depth[0];
                        }
 
index ea19952f60c6e1fd0226edaf1fe1ed4d95e96f66..e6cde05eae2b21441436c8c8a5f07fa3c0dd7ff0 100644 (file)
@@ -42,7 +42,7 @@ inline float WrapOperation::getWrappedOriginalYPos(float y)
        return fmodf(y, this->getHeight());
 }
 
-void WrapOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void WrapOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float nx, ny;
        nx = x;
index ddd5fa8032de6084a9b321b4fbd5b83b6ac221dd..33ea128056461b6ff23be7313198a8b9784e1211 100644 (file)
@@ -31,7 +31,7 @@ private:
 public:
        WrapOperation();
        bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output);
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 
        void setWrapping(int wrapping_type);
        float getWrappedOriginalXPos(float x);
index c73cb3ae325d37f8c4bd6133f624e1b3d654b1f1..832864b399d4b8100897c768356de100eef128d7 100644 (file)
@@ -40,9 +40,9 @@ WriteBufferOperation::~WriteBufferOperation()
        }
 }
 
-void WriteBufferOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void WriteBufferOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
-       this->m_input->read(output, x, y, sampler);
+       this->m_input->readSampled(output, x, y, sampler);
 }
 
 void WriteBufferOperation::initExecution()
@@ -98,7 +98,7 @@ void WriteBufferOperation::executeRegion(rcti *rect, unsigned int tileNumber)
                for (y = y1; y < y2 && (!breaked); y++) {
                        int offset4 = (y * memoryBuffer->getWidth() + x1) * COM_NUMBER_OF_CHANNELS;
                        for (x = x1; x < x2; x++) {
-                               this->m_input->read(&(buffer[offset4]), x, y, COM_PS_NEAREST);
+                               this->m_input->readSampled(&(buffer[offset4]), x, y, COM_PS_NEAREST);
                                offset4 += COM_NUMBER_OF_CHANNELS;
                        }
                        if (isBreaked()) {
index 157543fcb722530c9bfe4a14c26a3f17968b2bc4..1f1f58b18f1df71e18b9e7dcb65f37d04211df94 100644 (file)
@@ -39,7 +39,7 @@ public:
        ~WriteBufferOperation();
        int isBufferOperation() { return true; }
        MemoryProxy *getMemoryProxy() { return this->m_memoryProxy; }
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
        const bool isWriteBufferOperation() const { return true; }
        bool isSingleValue() const { return m_single_value; }
        
index 7db91a40fb757cdf707155afe8f2a3780cbe2db4..6cb88919b1bedf099f847950e95411dd98fc06bb 100644 (file)
@@ -46,36 +46,36 @@ void ZCombineOperation::initExecution()
        this->m_depth2Reader = this->getInputSocketReader(3);
 }
 
-void ZCombineOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void ZCombineOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float depth1[4];
        float depth2[4];
 
-       this->m_depth1Reader->read(depth1, x, y, sampler);
-       this->m_depth2Reader->read(depth2, x, y, sampler);
+       this->m_depth1Reader->readSampled(depth1, x, y, sampler);
+       this->m_depth2Reader->readSampled(depth2, x, y, sampler);
        if (depth1[0] < depth2[0]) {
-               this->m_image1Reader->read(output, x, y, sampler);
+               this->m_image1Reader->readSampled(output, x, y, sampler);
        }
        else {
-               this->m_image2Reader->read(output, x, y, sampler);
+               this->m_image2Reader->readSampled(output, x, y, sampler);
        }
 }
-void ZCombineAlphaOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void ZCombineAlphaOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float depth1[4];
        float depth2[4];
        float color1[4];
        float color2[4];
 
-       this->m_depth1Reader->read(depth1, x, y, sampler);
-       this->m_depth2Reader->read(depth2, x, y, sampler);
+       this->m_depth1Reader->readSampled(depth1, x, y, sampler);
+       this->m_depth2Reader->readSampled(depth2, x, y, sampler);
        if (depth1[0] <= depth2[0]) {
-               this->m_image1Reader->read(color1, x, y, sampler);
-               this->m_image2Reader->read(color2, x, y, sampler);
+               this->m_image1Reader->readSampled(color1, x, y, sampler);
+               this->m_image2Reader->readSampled(color2, x, y, sampler);
        }
        else {
-               this->m_image1Reader->read(color2, x, y, sampler);
-               this->m_image2Reader->read(color1, x, y, sampler);
+               this->m_image1Reader->readSampled(color2, x, y, sampler);
+               this->m_image2Reader->readSampled(color1, x, y, sampler);
        }
        float fac = color1[3];
        float ifac = 1.0f - fac;
@@ -113,28 +113,28 @@ void ZCombineMaskOperation::initExecution()
        this->m_image2Reader = this->getInputSocketReader(2);
 }
 
-void ZCombineMaskOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void ZCombineMaskOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float mask[4];
        float color1[4];
        float color2[4];
 
-       this->m_maskReader->read(mask, x, y, sampler);
-       this->m_image1Reader->read(color1, x, y, sampler);
-       this->m_image2Reader->read(color2, x, y, sampler);
+       this->m_maskReader->readSampled(mask, x, y, sampler);
+       this->m_image1Reader->readSampled(color1, x, y, sampler);
+       this->m_image2Reader->readSampled(color2, x, y, sampler);
 
        interp_v4_v4v4(output, color1, color2, 1.0f - mask[0]);
 }
 
-void ZCombineMaskAlphaOperation::executePixel(float output[4], float x, float y, PixelSampler sampler)
+void ZCombineMaskAlphaOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
        float mask[4];
        float color1[4];
        float color2[4];
 
-       this->m_maskReader->read(mask, x, y, sampler);
-       this->m_image1Reader->read(color1, x, y, sampler);
-       this->m_image2Reader->read(color2, x, y, sampler);
+       this->m_maskReader->readSampled(mask, x, y, sampler);
+       this->m_image1Reader->readSampled(color1, x, y, sampler);
+       this->m_image2Reader->readSampled(color2, x, y, sampler);
 
        float fac = (1.0f - mask[0]) * (1.0f - color1[3]) + mask[0] * color2[3];
        float mfac = 1.0f - fac;
index eeeb29d330f15feddfd12bec5216261318d74fa9..199120fa3bedffc9161e95f32570fac2c6a501d3 100644 (file)
@@ -47,11 +47,11 @@ public:
        /**
         * the inner loop of this program
         */
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 
 class ZCombineAlphaOperation : public ZCombineOperation {
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 
 class ZCombineMaskOperation : public NodeOperation {
@@ -64,10 +64,10 @@ public:
 
        void initExecution();
        void deinitExecution();
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 class ZCombineMaskAlphaOperation : public ZCombineMaskOperation {
-       void executePixel(float output[4], float x, float y, PixelSampler sampler);
+       void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 };
 
 #endif