Blender V5.3
blender::compositor Namespace Reference

Classes

class  BokehKernel
class  BokehKernelContainer
class  BokehKernelKey
class  BundleItem
class  CachedImage
class  CachedImageContainer
class  CachedImageKey
class  CachedMask
class  CachedMaskContainer
class  CachedMaskKey
class  CachedResource
class  CachedResourceContainer
class  CachedShader
class  CachedShaderContainer
class  CachedShaderKey
class  Closure
class  ClosureZoneOperation
class  Context
class  ConversionOperation
class  DenoisedAuxiliaryPassContainer
class  DericheGaussianCoefficients
class  DericheGaussianCoefficientsContainer
class  DericheGaussianCoefficientsKey
class  DerivedResources
class  DistortionGrid
class  DistortionGridContainer
class  DistortionGridKey
class  Domain
struct  EWASamplingData
class  FileOutput
class  FogGlowKernel
class  FogGlowKernelContainer
class  FogGlowKernelKey
class  GPUData
class  GPUShaderCreator
class  GroupNodeOperation
class  ImageCoordinates
class  ImageCoordinatesContainer
class  ImageCoordinatesKey
class  ImplicitInputOperation
class  InputDescriptor
class  KeyingScreen
class  KeyingScreenContainer
class  KeyingScreenKey
class  MorphologicalDistanceFeatherWeights
class  MorphologicalDistanceFeatherWeightsContainer
class  MorphologicalDistanceFeatherWeightsKey
class  MultiFunctionProcedureOperation
class  NodeGroupOperation
class  NodeOperation
class  NodeTreeEvaluator
class  NodeTreeInputNodeOperation
class  NodeTreeOutputNodeOperation
class  OCIOColorSpaceConversionShader
class  OCIOColorSpaceConversionShaderContainer
class  OCIOColorSpaceConversionShaderKey
class  OCIOToDisplayShader
class  OCIOToDisplayShaderContainer
class  OCIOToDisplayShaderKey
class  Operation
class  PixelOperation
struct  RealizationOptions
class  RealizeOnDomainOperation
class  RenderContext
class  RepeatZoneOperation
class  Result
class  SceneCompositorEffectsOperation
struct  Schedule
class  ScopedNodeGroupTimer
class  ScopedNodeTimer
class  ShaderNode
class  ShaderOperation
class  SimpleOperation
class  SingleValueNodeInputOperation
class  SMAAPrecomputedTextures
class  SMAAPrecomputedTexturesContainer
class  StaticCacheManager
class  StringImage
class  StringImageContainer
class  StringImageKey
class  SymmetricBlurWeights
class  SymmetricBlurWeightsContainer
class  SymmetricBlurWeightsKey
class  SymmetricSeparableBlurWeights
class  SymmetricSeparableBlurWeightsContainer
class  SymmetricSeparableBlurWeightsKey
class  UndefinedNodeOperation
class  VanVlietGaussianCoefficients
class  VanVlietGaussianCoefficientsContainer
class  VanVlietGaussianCoefficientsKey
class  ZoneOperation
class  ZoneTreeOperation

Typedefs

using BundleItemPtr = ImplicitSharingPtr<BundleItem>
using ClosurePtr = ImplicitSharingPtr<Closure>
using ProcessorsVector = Vector<std::unique_ptr<SimpleOperation>>
using PixelCompileUnit = VectorSet<const bNode *>
using Color = ColorSceneLinear4f<eAlpha::Premultiplied>
using SocketResultFn = FunctionRef<Result *(const bNodeSocket &)>
using NeededBuffers = Map<const bNode *, int>

Enumerations

enum class  MorphologicalBlurOperation : uint8_t { Dilate , Erode }
enum class  PaddingMethod : uint8_t { Zero , Extend }
enum class  SummedAreaTableOperation : uint8_t { Identity , Square }
enum class  DistortionType : uint8_t { Undistort = 0 , Distort = 1 }
enum class  CoordinatesType : uint8_t { Uniform , Normalized , Pixel }
enum class  HorizontalAlignment : uint8_t { Left = 0 , Center = 1 , Right = 2 }
enum class  VerticalAlignment : uint8_t {
  Top = 0 , TopBaseline = 1 , Middle = 2 , BottomBaseline = 3 ,
  Bottom = 4
}
enum class  SideEffectOutputTypes : uint8_t { None = 0 , ViewerNode = 1 << 0 , FileOutputNode = 1 << 1 , NodePreviews = 1 << 2 }
enum class  Interpolation : uint8_t { Nearest , Bilinear , Bicubic , Anisotropic }
enum class  Extension : uint8_t { Extend , Repeat , Clip }
enum class  InputRealizationMode : uint8_t { None , Transforms , OperationDomain }
enum class  ImplicitInputType : uint8_t { UniformImageCoordinates , SceneFrame }
enum class  ResultType : uint8_t {
  Float , Float2 , Float3 , Float4 ,
  Color , Int , Int2 , Int3 ,
  Int4 , Bool , Float4x4 , Menu ,
  Quaternion , String , Object , Image ,
  Font , Scene , Text , Mask ,
  Bundle , Closure
}
enum class  ResultPrecision : uint8_t { Full , Half }
enum class  ResultStorageType : uint8_t { SingleValue , GPUImage , CPUImage }

Functions

ImBuf * compute_preview (Context &context, const Result &input)
void convolve (Context &context, const Result &input, const Result &kernel, Result &output, const bool normalize_kernel)
void deriche_gaussian_blur (Context &context, const Result &input, Result &output, const float2 &sigma, const bool extend_bounds)
void extract_alpha (Context &context, const Result &input, Result &output)
void jump_flooding (Context &context, Result &input, Result &output)
int2 encode_jump_flooding_value (const int2 &closest_seed_texel, const bool is_flooded)
int2 initialize_jump_flooding_value (const int2 &texel, const bool is_seed)
void morphological_blur (Context &context, const Result &input, Result &output, const float2 &radius, const MorphologicalBlurOperation operation=MorphologicalBlurOperation::Erode, const math::FilterKernel filter_type=math::FilterKernel::Gauss)
void morphological_distance (Context &context, const Result &input, Result &output, const int distance)
void morphological_distance_feather (Context &context, const Result &input, Result &output, const int distance, const int falloff_type=PROP_SMOOTH)
void pad (Context &context, const Result &input, Result &output, const int2 size, const PaddingMethod padding_method)
float4 sum_color (Context &context, const Result &input)
float sum_log_luminance (Context &context, const Result &input, const float3 &luminance_coefficients)
float4 sum_squared_difference_color (Context &context, const Result &input, const float4 subtrahend)
float minimum_float (Context &context, const Result &input)
Color minimum_color (Context &context, const Result &input)
float minimum_luminance (Context &context, const Result &input, const float3 &luminance_coefficients)
float minimum_float_in_range (Context &context, const Result &input, const float lower_bound, const float upper_bound)
float maximum_float (Context &context, const Result &input)
float2 maximum_float2 (Context &context, const Result &input)
Color maximum_color (Context &context, const Result &input)
float maximum_luminance (Context &context, const Result &input, const float3 &luminance_coefficients)
float maximum_float_in_range (Context &context, const Result &input, const float lower_bound, const float upper_bound)
void recursive_gaussian_blur (Context &context, const Result &input, Result &output, const float2 &radius, const bool extend_bounds=false)
Color sample_pixel (Context &context, const Result &input, const Interpolation &interpolation, const Extension &extension_mode_x, const Extension &extension_mode_y, const float2 coordinates)
void smaa (Context &context, const Result &input, Result &output, const float threshold=0.1f, const float local_contrast_adaptation_factor=2.0f, const int corner_rounding=25)
void summed_area_table (Context &context, Result &input, Result &output, SummedAreaTableOperation operation=SummedAreaTableOperation::Identity)
float4 summed_area_table_sum (const Result &table, const int2 &lower_bound, const int2 &upper_bound)
void symmetric_separable_blur (Context &context, const Result &input, Result &output, const float2 &radius, const math::FilterKernel filter_type=math::FilterKernel::Gauss, const bool extend_bounds=false)
void symmetric_separable_blur_variable_size (Context &context, const Result &input, const Result &radius, Result &output, const int weights_resolution=128, const math::FilterKernel filter_type=math::FilterKernel::Gauss)
void van_vliet_gaussian_blur (Context &context, const Result &input, Result &output, const float2 &sigma, const bool extend_bounds)
static void compute_preview_cpu (Context &context, const Result &input, ImBuf *output)
static void compute_preview_gpu (Context &context, const Result &input_result, ImBuf *output)
static int2 compute_preview_size (int2 size)
static void sum_causal_and_non_causal_results_gpu (Context &context, const Result &causal_input, const Result &non_causal_input, Result &output)
static void sum_causal_and_non_causal_results_cpu (const Result &causal_input, const Result &non_causal_input, Result &output)
static void sum_causal_and_non_causal_results (Context &context, const Result &causal_input, const Result &non_causal_input, Result &output)
static void blur_pass_gpu (Context &context, const Result &input, Result &causal_result, Result &non_causal_result, const float sigma)
static void blur_pass_cpu (Context &context, const Result &input, Result &causal_output, Result &non_causal_output, const float sigma)
static void blur_pass (Context &context, const Result &input, Result &output, const float sigma)
static float2 compute_radius_from_sigma (const float2 sigma)
static void extract_alpha_gpu (Context &context, const Result &input, Result &output)
static void extract_alpha_cpu (const Result &input, Result &output)
static void jump_flooding_pass_gpu (Context &context, Result &input, Result &output, int step_size)
static void jump_flooding_pass_cpu (Result &input, Result &output, int step_size)
static void jump_flooding_pass (Context &context, Result &input, Result &output, int step_size)
static const char * get_shader (MorphologicalBlurOperation operation)
static void apply_morphological_operator_gpu (Context &context, const Result &input, Result &blurred_input, const MorphologicalBlurOperation operation)
static void apply_morphological_operator_cpu (const Result &input, Result &blurred_input, const MorphologicalBlurOperation operation)
static void apply_morphological_operator (Context &context, const Result &input, Result &blurred_input, const MorphologicalBlurOperation operation)
static const char * get_shader_name (const int distance)
static void morphological_distance_gpu (Context &context, const Result &input, Result &output, const int distance)
template<bool IsDilate>
static void morphological_distance_cpu (const Result &input, Result &output, const int structuring_element_radius)
template<bool IsErode>
static void morphological_distance_feather_pass (const Result &input, const MorphologicalDistanceFeatherWeights &weights, Result &output)
static const char * get_shader_name (const int distance)
static Result horizontal_pass_gpu (Context &context, const Result &input, const int distance, const int falloff_type)
static Result horizontal_pass_cpu (Context &context, const Result &input, const int distance, const int falloff_type)
static Result horizontal_pass (Context &context, const Result &input, const int distance, const int falloff_type)
static void vertical_pass_gpu (Context &context, const Result &original_input, const Result &horizontal_pass_result, Result &output, const int distance, const int falloff_type)
static void vertical_pass_cpu (Context &context, const Result &original_input, const Result &horizontal_pass_result, Result &output, const int distance, const int falloff_type)
static void vertical_pass (Context &context, const Result &original_input, const Result &horizontal_pass_result, Result &output, const int distance, const int falloff_type)
static const char * get_shader_name (const ResultType type, const PaddingMethod padding_method)
static void zero_pad_gpu (Context &context, const Result &input, Result &output, const int2 size, const PaddingMethod padding_method)
static void zero_pad_cpu (const Result &input, Result &output, const int2 size, const PaddingMethod padding_method)
static float * parallel_reduction_dispatch (gpu::Texture *texture, gpu::Shader *shader, gpu::TextureFormat format)
template<typename Value, typename Function, typename Reduction>
static Value parallel_reduce (const int2 range, const Value &identity, const Function &function, const Reduction &reduction)
static float4 sum_color_gpu (Context &context, const Result &input)
static float4 sum_color_cpu (const Result &input)
static float sum_log_luminance_gpu (Context &context, const Result &input, const float3 &luminance_coefficients)
static float sum_log_luminance_cpu (const Result &input, const float3 &luminance_coefficients)
static float4 sum_squared_difference_color_gpu (Context &context, const Result &input, const float4 subtrahend)
static float4 sum_squared_difference_color_cpu (const Result &input, const float4 subtrahend)
static float minimum_float_gpu (Context &context, const Result &input)
static float minimum_float_cpu (const Result &input)
static Color minimum_color_cpu (const Result &input)
static Color minimum_color_gpu (Context &context, const Result &input)
static float minimum_luminance_gpu (Context &context, const Result &input, const float3 &luminance_coefficients)
static float minimum_luminance_cpu (const Result &input, const float3 &luminance_coefficients)
static float minimum_float_in_range_gpu (Context &context, const Result &input, const float lower_bound, const float upper_bound)
static float minimum_float_in_range_cpu (const Result &input, const float lower_bound, const float upper_bound)
static float maximum_float_gpu (Context &context, const Result &input)
static float maximum_float_cpu (const Result &input)
static float2 maximum_float2_gpu (Context &context, const Result &input)
static float2 maximum_float2_cpu (const Result &input)
static Color maximum_color_gpu (Context &context, const Result &input)
static Color maximum_color_cpu (const Result &input)
static float maximum_luminance_gpu (Context &context, const Result &input, const float3 &luminance_coefficients)
static float maximum_luminance_cpu (const Result &input, const float3 &luminance_coefficients)
static float maximum_float_in_range_gpu (Context &context, const Result &input, const float lower_bound, const float upper_bound)
static float maximum_float_in_range_cpu (const Result &input, const float lower_bound, const float upper_bound)
static float2 compute_sigma_from_radius (float2 radius)
static char const * get_pixel_sampler_shader_name (const Interpolation &interpolation)
static Color sample_pixel_gpu (Context &context, const Result &input, const Interpolation &interpolation, const Extension &extension_mode_x, const Extension &extension_mode_y, const float2 coordinates)
static Color sample_pixel_cpu (const Result &input, const Interpolation &interpolation, const Extension &extension_mode_x, const Extension &extension_mode_y, const float2 coordinates)
static void SMAAMovc (float2 cond, float2 &variable, float2 value)
static void SMAAMovc (float4 cond, float4 &variable, float4 value)
static void SMAAEdgeDetectionVS (float2 texcoord, int2 size, float4 offset[3])
static void SMAABlendingWeightCalculationVS (float2 texcoord, int2 size, float2 &pixcoord, float4 offset[3])
static void SMAANeighborhoodBlendingVS (float2 texcoord, int2 size, float4 &offset)
template<typename T>
static float2 SMAALumaEdgeDetectionPS (float2 texcoord, float4 offset[3], SMAATexture2D(colorTex), float edge_threshold, float3 luminance_coefficients, float local_contrast_adaptation_factor)
static float2 SMAADecodeDiagBilinearAccess (float2 e)
static float4 SMAADecodeDiagBilinearAccess (float4 e)
static float2 SMAASearchDiag1 (SMAATexture2D(edgesTex), float2 texcoord, float2 dir, int2 size, float2 &e)
static float2 SMAASearchDiag2 (SMAATexture2D(edgesTex), float2 texcoord, float2 dir, int2 size, float2 &e)
static float2 SMAAAreaDiag (SMAATexture2D(areaTex), float2 dist, float2 e, float offset)
static float2 SMAACalculateDiagWeights (SMAATexture2D(edgesTex), SMAATexture2D(areaTex), float2 texcoord, float2 e, float4 subsampleIndices, int2 size)
static float SMAASearchLength (SMAATexture2D(searchTex), float2 e, float offset)
static float SMAASearchXLeft (SMAATexture2D(edgesTex), SMAATexture2D(searchTex), float2 texcoord, float end, int2 size)
static float SMAASearchXRight (SMAATexture2D(edgesTex), SMAATexture2D(searchTex), float2 texcoord, float end, int2 size)
static float SMAASearchYUp (SMAATexture2D(edgesTex), SMAATexture2D(searchTex), float2 texcoord, float end, int2 size)
static float SMAASearchYDown (SMAATexture2D(edgesTex), SMAATexture2D(searchTex), float2 texcoord, float end, int2 size)
static float2 SMAAArea (SMAATexture2D(areaTex), float2 dist, float e1, float e2, float offset)
static void SMAADetectHorizontalCornerPattern (SMAATexture2D(edgesTex), float2 &weights, float4 texcoord, float2 d, int2 size, int corner_rounding)
static void SMAADetectVerticalCornerPattern (SMAATexture2D(edgesTex), float2 &weights, float4 texcoord, float2 d, int2 size, int corner_rounding)
static float4 SMAABlendingWeightCalculationPS (float2 texcoord, float2 pixcoord, float4 offset[3], SMAATexture2D(edgesTex), SMAATexture2D(areaTex), SMAATexture2D(searchTex), float4 subsampleIndices, int2 size, int corner_rounding)
template<typename T>
static float4 SMAANeighborhoodBlendingPS (float2 texcoord, float4 offset, SMAATexture2D(colorTex), SMAATexture2D(blendTex), int2 size)
static float3 get_luminance_coefficients (ResultType type)
static Result detect_edges_gpu (Context &context, const Result &input, const float threshold, const float local_contrast_adaptation_factor)
static Result detect_edges_cpu (Context &context, const Result &input, const float threshold, const float local_contrast_adaptation_factor)
static Result detect_edges (Context &context, const Result &input, const float threshold, const float local_contrast_adaptation_factor)
static Result calculate_blending_weights_gpu (Context &context, const Result &edges, const int corner_rounding)
static Result calculate_blending_weights_cpu (Context &context, const Result &edges, const int corner_rounding)
static Result calculate_blending_weights (Context &context, const Result &edges, const int corner_rounding)
static const char * get_blend_shader_name (ResultType type)
static void blend_neighborhood_gpu (Context &context, const Result &input, const Result &weights, Result &output)
static void blend_neighborhood_cpu (const Result &input, const Result &weights, Result &output)
static void blend_neighborhood (Context &context, const Result &input, const Result &weights, Result &output)
static const char * get_compute_incomplete_prologues_shader (SummedAreaTableOperation operation)
static void compute_incomplete_prologues (Context &context, Result &input, SummedAreaTableOperation operation, Result &incomplete_x_prologues, Result &incomplete_y_prologues)
static void compute_complete_x_prologues (Context &context, Result &input, Result &incomplete_x_prologues, Result &complete_x_prologues, Result &complete_x_prologues_sum)
static void compute_complete_y_prologues (Context &context, Result &input, Result &incomplete_y_prologues, Result &complete_x_prologues_sum, Result &complete_y_prologues)
static const char * get_compute_complete_blocks_shader (SummedAreaTableOperation operation)
static void compute_complete_blocks (Context &context, Result &input, Result &complete_x_prologues, Result &complete_y_prologues, SummedAreaTableOperation operation, Result &output)
static void summed_area_table_gpu (Context &context, Result &input, Result &output, SummedAreaTableOperation operation)
static void summed_area_table_cpu (Result &input, Result &output, SummedAreaTableOperation operation)
template<typename T>
static void blur_pass (const Result &input, const Result &weights, Result &output)
static const char * get_blur_shader (const ResultType type)
static void blur_pass_gpu (Context &context, const Result &input, Result &output, const float radius, const math::FilterKernel filter_type)
static void blur_pass_cpu (Context &context, const Result &input, Result &output, const float radius, const math::FilterKernel filter_type)
static void blur_pass (Context &context, const Result &input, Result &output, const float radius, const math::FilterKernel filter_type)
static void blur_pass (const Result &input, const Result &radius_input, const Result &weights, Result &output, const bool is_vertical_pass)
static Result horizontal_pass_gpu (Context &context, const Result &input, const Result &radius, const int weights_resolution, const math::FilterKernel filter_type)
static Result horizontal_pass_cpu (Context &context, const Result &input, const Result &radius, const int weights_resolution, const math::FilterKernel filter_type)
static Result horizontal_pass (Context &context, const Result &input, const Result &radius, const int weights_resolution, const math::FilterKernel filter_type)
static void vertical_pass_gpu (Context &context, const Result &original_input, const Result &horizontal_pass_result, const Result &radius, Result &output, const int weights_resolution, const math::FilterKernel filter_type)
static void vertical_pass_cpu (Context &context, const Result &original_input, const Result &horizontal_pass_result, const Result &radius, Result &output, const int weights_resolution, const math::FilterKernel filter_type)
static void vertical_pass (Context &context, const Result &original_input, const Result &horizontal_pass_result, const Result &radius, Result &output, const int weights_resolution, const math::FilterKernel filter_type)
static void sum_causal_and_non_causal_results_gpu (Context &context, const Result &first_causal_input, const Result &first_non_causal_input, const Result &second_causal_input, const Result &second_non_causal_input, Result &output)
static void sum_causal_and_non_causal_results_cpu (const Result &first_causal_input, const Result &first_non_causal_input, const Result &second_causal_input, const Result &second_non_causal_input, Result &output)
static void sum_causal_and_non_causal_results (Context &context, const Result &first_causal_input, const Result &first_non_causal_input, const Result &second_causal_input, const Result &second_non_causal_input, Result &output)
static void blur_pass_gpu (Context &context, const Result &input, Result &first_causal_result, Result &first_non_causal_result, Result &second_causal_result, Result &second_non_causal_result, const float sigma)
static void blur_pass_cpu (Context &context, const Result &input, Result &first_causal_output, Result &first_non_causal_output, Result &second_causal_output, Result &second_non_causal_output, const float sigma)
static void blur_pass (Context &context, const Result &input, Result &output, const float sigma)
static float2 compute_radius_from_sigma (const float2 sigma)
bool operator== (const BokehKernelKey &a, const BokehKernelKey &b)
bool operator== (const CachedImageKey &a, const CachedImageKey &b)
bool operator== (const CachedShaderKey &a, const CachedShaderKey &b)
bool operator== (const DericheGaussianCoefficientsKey &a, const DericheGaussianCoefficientsKey &b)
bool operator== (const DistortionGridKey &a, const DistortionGridKey &b)
bool operator== (const FogGlowKernelKey &a, const FogGlowKernelKey &b)
bool operator== (const ImageCoordinatesKey &a, const ImageCoordinatesKey &b)
bool operator== (const KeyingScreenKey &a, const KeyingScreenKey &b)
bool operator== (const MorphologicalDistanceFeatherWeightsKey &a, const MorphologicalDistanceFeatherWeightsKey &b)
bool operator== (const OCIOColorSpaceConversionShaderKey &a, const OCIOColorSpaceConversionShaderKey &b)
bool operator== (const OCIOToDisplayShaderKey &a, const OCIOToDisplayShaderKey &b)
bool operator== (const SymmetricBlurWeightsKey &a, const SymmetricBlurWeightsKey &b)
bool operator== (const VanVlietGaussianCoefficientsKey &a, const VanVlietGaussianCoefficientsKey &b)
static float compute_exterior_angle (int sides)
static float compute_rotation (float angle, int sides)
static float2 get_regular_polygon_vertex_position (const int vertex_index, const float exterior_angle, const float rotation)
static float2 closest_point_on_line (const float2 point, const float2 line_start, const float2 line_end)
static float bokeh (const float2 point, const float circumradius, const float exterior_angle, const float rotation, const float roundness, const float catadioptric)
static float4 spectral_bokeh (const int2 texel, const int2 size, const float exterior_angle, const float rotation, const float roundness, const float catadioptric, const float lens_shift)
static RenderLayer * get_render_layer (const RenderResult *render_result, const ImageUser &image_user)
static int get_pass_index (const RenderResult *render_result, const ImageUser &image_user, const char *name)
static RenderPass * get_render_pass (const RenderLayer *render_layer, const ImageUser &image_user)
static RenderPass * get_render_pass (const RenderResult *render_result, const ImageUser &image_user)
static int get_view_index (const Context &context, const RenderResult *render_result, const ImageUser &image_user)
static ImageUser compute_image_user_for_pass (const Context &context, const Image &image, const RenderResult *render_result, const ImageUser &image_user, const char *pass_name)
static ImBuf * compute_linear_buffer (ImBuf *image_buffer)
static ResultType float_type (const int channels_count)
static ResultType get_pass_type (const RenderPass *render_pass)
static Vector< MaskRasterHandle * > get_mask_raster_handles (Mask *mask, int2 size, int frame, bool frame_is_current, bool use_feather, int motion_blur_samples, float motion_blur_shutter)
static double compute_numerator_0 ()
static double compute_numerator_1 (float sigma)
static double compute_numerator_2 (float sigma)
static double compute_numerator_3 (float sigma)
static double4 compute_numerator (float sigma)
static double compute_denominator_1 (float sigma)
static double compute_denominator_2 (float sigma)
static double compute_denominator_3 (float sigma)
static double compute_denominator_4 (float sigma)
static double4 compute_denominator (float sigma)
static float compute_normalization_scale (const double4 &causal_feedforward_coefficients, const double4 &feedback_coefficients)
static double4 compute_non_causal_feedforward_coefficients (const double4 &causal_feedforward_coefficients, const double4 &feedback_coefficients)
static double compute_boundary_coefficient (const double4 &feedforward_coefficients, const double4 &feedback_coefficients)
template<typename Value, typename Function, typename Reduction>
static Value parallel_reduce (const int range, const Value &identity, const Function &function, const Reduction &reduction)
static Domain compute_output_domain (MovieDistortion *distortion, const int2 &calibration_size, const DistortionType &type, const Domain &domain)
static int2 get_movie_clip_size (MovieClip *movie_clip, int frame_number)
static float compute_fog_glow_kernel_value (int2 texel, math::AngleRadian field_of_view_per_pixel)
static const char * get_shader_name (const CoordinatesType type)
static void compute_marker_points (MovieClip *movie_clip, MovieClipUser &movie_clip_user, MovieTrackingObject *movie_tracking_object, Vector< float2 > &marker_positions, Vector< float4 > &marker_colors)
static MovieClipUser get_movie_clip_user (Context &context, MovieClip *movie_clip)
static float compute_distance_falloff (int type, float x)
static int load_font (const VFont *font)
static float compute_draw_horizontal_position (const int start_offset, const int line_width, const int total_width, const HorizontalAlignment alignment)
static float compute_draw_vertical_position (const int lines_count, const int line_index, const int line_height, const int descender)
static float compute_horizontal_offset (const int start_offset, const int total_width, const HorizontalAlignment alignment)
static float compute_vertical_offset (const int total_height, const int line_height, const int descender, const VerticalAlignment alignment)
static double compute_scaled_poles_variance (const std::array< std::complex< double >, 4 > &poles, double scale_factor)
static double compute_scaled_poles_variance_derivative (const std::array< std::complex< double >, 4 > &poles, double scale_factor)
static double find_scale_factor (const std::array< std::complex< double >, 4 > &poles, double reference_sigma)
static std::array< std::complex< double >, 4 > computed_scaled_poles (const std::array< std::complex< double >, 4 > &poles, float sigma)
static std::array< std::complex< double >, 4 > compute_causal_poles (const std::array< std::complex< double >, 4 > &non_causal_poles)
static double4 compute_feedback_coefficients (const std::array< std::complex< double >, 4 > &poles)
static double compute_feedforward_coefficient (const double4 &feedback_coefficients)
static std::complex< double > compute_partial_fraction_residue (const std::array< std::complex< double >, 4 > &poles, const std::complex< double > &target_pole, double gain)
static std::complex< double > compute_causal_transfer_function_at_non_causal_pole (const std::array< std::complex< double >, 4 > &poles, const std::complex< double > &target_pole, double gain)
static void compute_second_order_section (const std::complex< double > &pole, const std::complex< double > &residue, const std::complex< double > &transfer_value, double2 &r_feedback_coefficients, double2 &r_causal_feedforward_coefficients, double2 &r_non_causal_feedforward_coefficients)
static double compute_boundary_coefficient (const double2 &feedback_coefficients, const double2 &feedforward_coefficients)
bool operator== (const Domain &a, const Domain &b)
bool operator!= (const Domain &a, const Domain &b)
StringRefNull to_string (const Interpolation &interpolation)
StringRefNull to_string (const Extension &extension)
GPUSamplerExtendMode map_extension_mode_to_extend_mode (const Extension &mode)
NodeOperation * get_group_node_operation (Context &context, const bNode &node)
void init ()
NodeOperation * get_node_tree_input_node_operation (Context &context, const bNode &node, Operation &operation)
NodeOperation * get_node_tree_output_node_operation (Context &context, const bNode &node, Operation &operation)
StringRefNull to_string (const ResultPrecision &precision)
BLI_INLINE math::InterpWrapMode map_extension_mode_to_wrap_mode (const Extension &mode)
static void sample_ewa_read_callback (void *userdata, int x, int y, float result[4])
Schedule compute_schedule (const Context &context, const bNodeTree &node_group, const ComputeContext &compute_context, SocketResultFn socket_result_fn, const bke::bNodeTreeZone *zone=nullptr)
int compute_output_reference_count (const bNodeSocket &output, const Schedule &schedule, const VectorSet< const bNode * > *ignored_nodes=nullptr)
NodeOperation * get_undefined_node_operation (Context &context, const bNode &node)
bool is_socket_available (const bNodeSocket *socket)
const bNodeSocket * get_output_linked_to_input (const bNodeSocket &input)
ResultType socket_data_type_to_result_type (const eNodeSocketDatatype data_type, const std::optional< int > dimensions=std::nullopt)
ResultType get_node_socket_result_type (const bNodeSocket *socket)
ResultType get_node_interface_socket_result_type (const bNodeTreeInterfaceSocket &socket)
bool is_output_linked_to_input_conditioned (const bNodeSocket &output, FunctionRef< bool(const bNodeSocket &)> condition)
bool is_pixel_node (const bNode &node)
InputDescriptor input_descriptor_from_input_socket (const bNodeSocket *socket)
InputDescriptor input_descriptor_from_interface_input (const bNodeTree &node_group, const bNodeTreeInterfaceSocket &socket)
void compute_dispatch_threads_at_least (gpu::Shader *shader, int2 threads_range, int2 local_size=int2(16))
bool is_node_preview_needed (const bNode &node)
const bNodeSocket * find_preview_output_socket (const bNode &node)
template<typename Function>
void parallel_for (const int2 range, const Function &function)
static ResultType get_implicit_input_result_type (const ImplicitInputType implicit_input)
static void register_cpp_types ()
static Result * get_node_group_result_for_socket (NodeGroupOperation &operation, const bNodeSocket &socket)
static bool is_node_tree_input_node (const bNode &node)
static destruct_ptr< nodes::eval_log::ImageInfoLog > get_image_info_log (LinearAllocator<> *allocator, const Domain &domain, const ResultPrecision &precision)
template<typename T>
static void realize_on_domain (const Result &input, Result &output, const float3x3 &transformation, const std::optional< float2x2 > &jacobian)
static Domain sanitize_domain_data_size (const Domain domain, const Context &context, const std::optional< ResultStorageType > storage_type)
static void bind_texture (gpu::Shader *shader, gpu::Texture *texture, const StringRef texture_name)
static bool is_compatible_texture (const gpu::Texture *texture, const Result &result)
static bke::compositor::ExecutionMode get_execution_mode (const Context &context)
static Result * get_effect_input (Context &context, PointerRNA &effect_inputs_ptr, const bNodeTreeInterfaceSocket &input_socket)
static bool has_viewer_node (const bNodeTree &node_group, const ComputeContext &compute_context, const ComputeContext &viewer_compute_context, bke::ComputeContextCache &compute_context_cache)
static bool has_file_output_recursive (const bNodeTree &node_group)
template<typename T, typename SocketT>
static std::optional< T > get_input_socket_value (const Context &context, const bNodeSocket &input, SocketResultFn socket_result_fn)
static bool is_switch_node_input_needed (const Context &context, const bNode &node, const bNodeSocket &input, SocketResultFn socket_result_fn)
static bool is_menu_switch_node_input_needed (const Context &context, const bNode &node, const bNodeSocket &input, SocketResultFn socket_result_fn)
static bool is_index_switch_node_input_needed (const Context &context, const bNode &node, const bNodeSocket &input, SocketResultFn socket_result_fn)
static bool is_input_needed (const Context &context, const bNode &node, const bNodeSocket &input, SocketResultFn socket_result_fn)
static Stack< const bNode * > get_output_nodes (const Context &context, const bNodeTree &node_group, const ComputeContext &compute_context, const bke::bNodeTreeZone *zone, SocketResultFn socket_result_fn)
static NeededBuffers compute_number_of_needed_buffers (const Context &context, Stack< const bNode * > &output_nodes, SocketResultFn socket_result_fn)
static Vector< const bNode * > find_node_dependency_nodes (const Context &context, Schedule &schedule, const bNode &node, const bke::bNodeTreeZone *zone, SocketResultFn socket_result_fn)
static Vector< const bNode * > find_zone_dependency_nodes (const Context &context, Schedule &schedule, const bke::bNodeTreeZone &zone, SocketResultFn socket_result_fn)
static Vector< const bNode * > find_dependency_nodes (const Context &context, Schedule &schedule, const bNode &node, const bke::bNodeTreeZone *zone, SocketResultFn socket_result_fn)
static GPUType gpu_type_from_socket (const bNodeSocket &socket)
static void populate_gpu_node_stack (const bNodeSocket &socket, GPUNodeStack &stack)
static const char * get_set_function_name (const ResultType type)
static GPUNodeLink * get_input_value_link (const bNodeSocket &input, GPUNodeStack &stack)
static GPUNodeLink * get_result_single_value_link (const Result &result)
static const char * get_store_function_name (ResultType type)
static GPUNodeLink * get_default_input_value_link (const ResultType type)
static const char * glsl_store_expression_from_result_type (ResultType type)
static ImageType gpu_image_type_from_result_type (const ResultType type)
static const char * glsl_type_from_result_type (ResultType type)
static const char * glsl_swizzle_from_result_type (ResultType type)
static std::optional< ImplicitInputType > get_implicit_input (const NodeDefaultInputType node_default_input_type)
static int get_domain_priority (const bNodeSocket *input, const nodes::SocketDeclaration *socket_declaration)
static Result * get_zone_result_for_socket (ZoneTreeOperation &operation, const bke::bNodeTreeZone &zone, const bNodeSocket &socket)
int compute_number_of_diagonals (const int2 &size)
int compute_diagonal_length (const int2 &size, const int diagonal_index)
int2 compute_diagonal_start (const int2 &size, const int index)
int2 get_diagonal_direction ()
int compute_anti_diagonal_length (const int2 &size, const int diagonal_index)
int2 compute_anti_diagonal_start (const int2 &size, const int index)
int2 get_anti_diagonal_direction ()
void log_result (Context &context, nodes::eval_log::NodeTreeLogger &logger, const bNodeSocket &socket, const Result &result)
static destruct_ptr< nodes::eval_log::ImageInfoLog > get_image_info_log (LinearAllocator<> *allocator, const Result &result)
static destruct_ptr< nodes::eval_log::BundleValueLog > get_bundle_info_log (Context &context, LinearAllocator<> *allocator, const Result &result)
static destruct_ptr< nodes::eval_log::ClosureValueLog > get_closure_info_log (LinearAllocator<> *allocator, const Result &result)
Symmetric Separable Blur Weights Key
bool operator== (const SymmetricSeparableBlurWeightsKey &a, const SymmetricSeparableBlurWeightsKey &b)

Variables

static constexpr double a0 = 1.6797292232361107
static constexpr double a1 = 3.7348298269103580
static constexpr double b0 = 1.7831906544515104
static constexpr double b1 = 1.7228297663338028
static constexpr double c0 = -0.6802783501806897
static constexpr double c1 = -0.2598300478959625
static constexpr double w0 = 0.6318113174569493
static constexpr double w1 = 1.9969276832487770
static CLG_LogRef LOG = {"compositor.gpu"}

Typedef Documentation

◆ BundleItemPtr

◆ ClosurePtr

◆ Color

◆ NeededBuffers

Definition at line 426 of file scheduler.cc.

◆ PixelCompileUnit

Definition at line 27 of file COM_pixel_operation.hh.

◆ ProcessorsVector

Definition at line 25 of file COM_operation.hh.

◆ SocketResultFn

Definition at line 45 of file COM_scheduler.hh.

Enumeration Type Documentation

◆ CoordinatesType

Enumerator
Uniform 
Normalized 
Pixel 

Definition at line 20 of file COM_image_coordinates.hh.

◆ DistortionType

Enumerator
Undistort 
Distort 

Definition at line 22 of file COM_distortion_grid.hh.

◆ Extension

Enumerator
Extend 
Repeat 
Clip 

Definition at line 27 of file COM_domain.hh.

◆ HorizontalAlignment

Enumerator
Left 
Center 
Right 

Definition at line 24 of file COM_string_image.hh.

◆ ImplicitInputType

Enumerator
UniformImageCoordinates 
SceneFrame 

Definition at line 34 of file COM_input_descriptor.hh.

◆ InputRealizationMode

Enumerator
None 
Transforms 
OperationDomain 

Definition at line 19 of file COM_input_descriptor.hh.

◆ Interpolation

Enumerator
Nearest 
Bilinear 
Bicubic 
Anisotropic 

Definition at line 19 of file COM_domain.hh.

◆ MorphologicalBlurOperation

Enumerator
Dilate 
Erode 

Definition at line 18 of file COM_algorithm_morphological_blur.hh.

◆ PaddingMethod

Enumerator
Zero 
Extend 

Definition at line 15 of file COM_algorithm_pad.hh.

◆ ResultPrecision

Enumerator
Full 
Half 

Definition at line 81 of file COM_result.hh.

◆ ResultStorageType

Enumerator
SingleValue 
GPUImage 
CPUImage 

Definition at line 87 of file COM_result.hh.

◆ ResultType

Enumerator
Float 
Float2 
Float3 
Float4 
Color 
Int 
Int2 
Int3 
Int4 
Bool 
Float4x4 
Menu 
Quaternion 
String 
Object 
Image 
Font 
Scene 
Text 
Mask 
Bundle 
Closure 

Definition at line 53 of file COM_result.hh.

◆ SideEffectOutputTypes

Enumerator
None 
ViewerNode 
FileOutputNode 
NodePreviews 

Definition at line 37 of file COM_context.hh.

◆ SummedAreaTableOperation

Enumerator
Identity 
Square 

Definition at line 17 of file COM_algorithm_summed_area_table.hh.

◆ VerticalAlignment

Enumerator
Top 
TopBaseline 
Middle 
BottomBaseline 
Bottom 

Definition at line 30 of file COM_string_image.hh.

Function Documentation

◆ apply_morphological_operator()

void blender::compositor::apply_morphological_operator ( Context & context,
const Result & input,
Result & blurred_input,
const MorphologicalBlurOperation operation )
static

◆ apply_morphological_operator_cpu()

void blender::compositor::apply_morphological_operator_cpu ( const Result & input,
Result & blurred_input,
const MorphologicalBlurOperation operation )
static

◆ apply_morphological_operator_gpu()

◆ bind_texture()

◆ blend_neighborhood()

void blender::compositor::blend_neighborhood ( Context & context,
const Result & input,
const Result & weights,
Result & output )
static

Definition at line 1680 of file smaa.cc.

References blend_neighborhood(), blend_neighborhood_cpu(), blend_neighborhood_gpu(), and output.

Referenced by blend_neighborhood(), and smaa().

◆ blend_neighborhood_cpu()

◆ blend_neighborhood_gpu()

◆ blur_pass() [1/5]

◆ blur_pass() [2/5]

◆ blur_pass() [3/5]

void blender::compositor::blur_pass ( Context & context,
const Result & input,
Result & output,
const float radius,
const math::FilterKernel filter_type )
static

Definition at line 139 of file symmetric_separable_blur.cc.

References blur_pass(), blur_pass_cpu(), blur_pass_gpu(), and output.

◆ blur_pass() [4/5]

◆ blur_pass() [5/5]

void blender::compositor::blur_pass ( Context & context,
const Result & input,
Result & output,
const float sigma )
static

◆ blur_pass_cpu() [1/3]

◆ blur_pass_cpu() [2/3]

void blender::compositor::blur_pass_cpu ( Context & context,
const Result & input,
Result & first_causal_output,
Result & first_non_causal_output,
Result & second_causal_output,
Result & second_non_causal_output,
const float sigma )
static

◆ blur_pass_cpu() [3/3]

void blender::compositor::blur_pass_cpu ( Context & context,
const Result & input,
Result & output,
const float radius,
const math::FilterKernel filter_type )
static

◆ blur_pass_gpu() [1/3]

◆ blur_pass_gpu() [2/3]

void blender::compositor::blur_pass_gpu ( Context & context,
const Result & input,
Result & first_causal_result,
Result & first_non_causal_result,
Result & second_causal_result,
Result & second_non_causal_result,
const float sigma )
static

Definition at line 112 of file van_vliet_gaussian_blur.cc.

References blender::compositor::Result::allocate_texture(), blender::compositor::Result::bind_as_image(), blender::compositor::Result::bind_as_texture(), blur_pass_gpu(), compute_dispatch_threads_at_least(), blender::compositor::Domain::data_size, blender::compositor::Result::domain(), blender::compositor::VanVlietGaussianCoefficients::first_causal_boundary_coefficient(), blender::compositor::VanVlietGaussianCoefficients::first_causal_feedforward_coefficients(), blender::compositor::VanVlietGaussianCoefficients::first_feedback_coefficients(), blender::compositor::VanVlietGaussianCoefficients::first_non_causal_boundary_coefficient(), blender::compositor::VanVlietGaussianCoefficients::first_non_causal_feedforward_coefficients(), blender::gpu::shader::metadata::float2, blender::GPU_shader_bind(), blender::GPU_shader_unbind(), blender::GPU_shader_uniform_1f(), blender::GPU_shader_uniform_2fv(), blender::gpu::shader::metadata::int2, blender::compositor::VanVlietGaussianCoefficients::second_causal_boundary_coefficient(), blender::compositor::VanVlietGaussianCoefficients::second_causal_feedforward_coefficients(), blender::compositor::VanVlietGaussianCoefficients::second_feedback_coefficients(), blender::compositor::VanVlietGaussianCoefficients::second_non_causal_boundary_coefficient(), blender::compositor::VanVlietGaussianCoefficients::second_non_causal_feedforward_coefficients(), blender::compositor::Result::unbind_as_image(), and blender::compositor::Result::unbind_as_texture().

◆ blur_pass_gpu() [3/3]

◆ bokeh()

◆ calculate_blending_weights()

Result blender::compositor::calculate_blending_weights ( Context & context,
const Result & edges,
const int corner_rounding )
static

◆ calculate_blending_weights_cpu()

◆ calculate_blending_weights_gpu()

◆ closest_point_on_line()

float2 blender::compositor::closest_point_on_line ( const float2 point,
const float2 line_start,
const float2 line_end )
static

◆ compute_anti_diagonal_length()

int blender::compositor::compute_anti_diagonal_length ( const int2 & size,
const int diagonal_index )
inline

◆ compute_anti_diagonal_start()

◆ compute_boundary_coefficient() [1/2]

double blender::compositor::compute_boundary_coefficient ( const double2 & feedback_coefficients,
const double2 & feedforward_coefficients )
static

The IIR filter difference equation relies on previous outputs to compute new outputs, those previous outputs are not really defined at the start of the filter. To do Neumann boundary condition, we initialize the previous output with a special value that is a function of the boundary value. This special value is computed by multiply the boundary value with a coefficient to simulate an infinite stream of the boundary value.

The function for the coefficient can be derived by substituting the boundary value for previous inputs, equating all current and previous outputs to the same value, and finally rearranging to compute that same output value.

Start by the difference equation where b_i are the feedforward coefficients and a_i are the feedback coefficients:

y[n] = \sum_{i = 0}^3 b_i x[n - i] - \sum_{i = 0}^3 a_i y[n - i]

Assume all outputs are y and all inputs are x, which is the boundary value:

y = \sum_{i = 0}^3 b_i x - \sum_{i = 0}^3 a_i y

Now rearrange to compute y:

y = x \sum_{i = 0}^3 b_i - y \sum_{i = 0}^3 a_i
y + y \sum_{i = 0}^3 a_i = x \sum_{i = 0}^3 b_i
y (1 + \sum_{i = 0}^3 a_i) = x \sum_{i = 0}^3 b_i
y = x \cdot \frac{\sum_{i = 0}^3 b_i}{1 + \sum_{i = 0}^3 a_i}

So our coefficient is the value that is multiplied by the boundary value x. Had x been zero, that is, we are doing Dirichlet boundary condition, the equations still hold.

Definition at line 394 of file van_vliet_gaussian_coefficients.cc.

References compute_boundary_coefficient(), and blender::math::reduce_add().

Referenced by blender::compositor::VanVlietGaussianCoefficients::VanVlietGaussianCoefficients().

◆ compute_boundary_coefficient() [2/2]

double blender::compositor::compute_boundary_coefficient ( const double4 & feedforward_coefficients,
const double4 & feedback_coefficients )
static

The IIR filter difference equation relies on previous outputs to compute new outputs, those previous outputs are not really defined at the start of the filter. To do Neumann boundary condition, we initialize the previous output with a special value that is a function of the boundary value. This special value is computed by multiply the boundary value with a coefficient to simulate an infinite stream of the boundary value.

The function for the coefficient can be derived by substituting the boundary value for previous inputs, equating all current and previous outputs to the same value, and finally rearranging to compute that same output value.

Start by the difference equation where b_i are the feedforward coefficients and a_i are the feedback coefficients:

y[n] = \sum_{i = 0}^3 b_i x[n - i] - \sum_{i = 0}^3 a_i y[n - i]

Assume all outputs are y and all inputs are x, which is the boundary value:

y = \sum_{i = 0}^3 b_i x - \sum_{i = 0}^3 a_i y

Now rearrange to compute y:

y = x \sum_{i = 0}^3 b_i - y \sum_{i = 0}^3 a_i
y + y \sum_{i = 0}^3 a_i = x \sum_{i = 0}^3 b_i
y (1 + \sum_{i = 0}^3 a_i) = x \sum_{i = 0}^3 b_i
y = x \cdot \frac{\sum_{i = 0}^3 b_i}{1 + \sum_{i = 0}^3 a_i}

So our coefficient is the value that is multiplied by the boundary value x. Had x been zero, that is, we are doing Dirichlet boundary condition, the equations still hold.

Definition at line 240 of file deriche_gaussian_coefficients.cc.

References compute_boundary_coefficient(), and blender::math::reduce_add().

Referenced by compute_boundary_coefficient(), compute_boundary_coefficient(), and blender::compositor::DericheGaussianCoefficients::DericheGaussianCoefficients().

◆ compute_causal_poles()

std::array< std::complex< double >, 4 > blender::compositor::compute_causal_poles ( const std::array< std::complex< double >, 4 > & non_causal_poles)
static

◆ compute_causal_transfer_function_at_non_causal_pole()

std::complex< double > blender::compositor::compute_causal_transfer_function_at_non_causal_pole ( const std::array< std::complex< double >, 4 > & poles,
const std::complex< double > & target_pole,
double gain )
static

◆ compute_complete_blocks()

◆ compute_complete_x_prologues()

◆ compute_complete_y_prologues()

◆ compute_denominator()

◆ compute_denominator_1()

double blender::compositor::compute_denominator_1 ( float sigma)
static

◆ compute_denominator_2()

double blender::compositor::compute_denominator_2 ( float sigma)
static

◆ compute_denominator_3()

double blender::compositor::compute_denominator_3 ( float sigma)
static

◆ compute_denominator_4()

double blender::compositor::compute_denominator_4 ( float sigma)
static

◆ compute_diagonal_length()

◆ compute_diagonal_start()

int2 blender::compositor::compute_diagonal_start ( const int2 & size,
const int index )
inline

◆ compute_dispatch_threads_at_least()

void blender::compositor::compute_dispatch_threads_at_least ( gpu::Shader * shader,
int2 threads_range,
int2 local_size = int2(16) )

Definition at line 235 of file utilities.cc.

References compute_dispatch_threads_at_least(), blender::math::divide_ceil(), blender::GPU_compute_dispatch(), blender::gpu::shader::metadata::int2, and local_size.

Referenced by blender::nodes::node_composite_glare_cc::GlareOperation::accumulate_ghosts_gpu(), blender::nodes::node_composite_glare_cc::GlareOperation::accumulate_streak_gpu(), apply_morphological_operator_gpu(), blender::nodes::node_composite_glare_cc::GlareOperation::apply_streak_filter_gpu(), blend_neighborhood_gpu(), blur_pass_gpu(), blur_pass_gpu(), blur_pass_gpu(), calculate_blending_weights_gpu(), blender::nodes::node_composite_glare_cc::GlareOperation::compute_base_ghost_gpu(), blender::nodes::node_composite_glare_cc::GlareOperation::compute_bloom_downsample_gpu(), blender::nodes::node_composite_glare_cc::GlareOperation::compute_bloom_upsample_gpu(), blender::nodes::node_composite_double_edge_mask_cc::DoubleEdgeMaskOperation::compute_boundary_gpu(), blender::nodes::node_composite_mask_to_sdf_cc::MaskToSDFOperation::compute_boundary_gpu(), blender::nodes::node_composite_defocus_cc::DefocusOperation::compute_defocus_radius_from_depth_gpu(), blender::nodes::node_composite_defocus_cc::DefocusOperation::compute_defocus_radius_from_scale_gpu(), compute_dispatch_threads_at_least(), blender::nodes::node_composite_dilate_erode_cc::DilateErodeOperation::compute_distance_threshold_gpu(), blender::nodes::node_composite_dilate_erode_cc::DilateErodeOperation::compute_distance_threshold_seeds_gpu(), blender::nodes::node_composite_double_edge_mask_cc::DoubleEdgeMaskOperation::compute_gradient_gpu(), blender::nodes::node_composite_base_cryptomatte_cc::BaseCryptoMatteOperation::compute_image_gpu(), blender::nodes::node_composite_keying_cc::KeyingOperation::compute_image_gpu(), blender::nodes::node_composite_inpaint_cc::InpaintOperation::compute_inpainting_boundary_gpu(), blender::nodes::node_composite_inpaint_cc::InpaintOperation::compute_inpainting_region_gpu(), blender::nodes::node_composite_depth_combin_cc::ZCombineOperation::compute_mask_gpu(), blender::nodes::node_composite_base_cryptomatte_cc::BaseCryptoMatteOperation::compute_matte_gpu(), blender::nodes::node_composite_keying_cc::KeyingOperation::compute_matte_gpu(), blender::nodes::node_composite_vector_blur_cc::VectorBlurOperation::compute_motion_blur(), blender::nodes::node_composite_base_cryptomatte_cc::BaseCryptoMatteOperation::compute_pick_gpu(), blender::nodes::node_composite_corner_pin_cc::CornerPinOperation::compute_plane_gpu(), blender::nodes::node_composite_plane_track_deform_cc::PlaneTrackDeformOperation::compute_plane_gpu(), blender::nodes::node_composite_corner_pin_cc::CornerPinOperation::compute_plane_mask_gpu(), blender::nodes::node_composite_plane_track_deform_cc::PlaneTrackDeformOperation::compute_plane_mask_gpu(), compute_preview_gpu(), blender::nodes::node_composite_mask_to_sdf_cc::MaskToSDFOperation::compute_signed_distance_gpu(), blender::nodes::node_composite_kuwahara_cc::ConvertKuwaharaOperation::compute_structure_tensor_gpu(), blender::nodes::node_composite_keying_cc::KeyingOperation::compute_tweaked_matte_gpu(), blender::seq::CompositorContext::create_result_from_input(), blender::draw::compositor_engine::Context::crop_pass(), detect_edges_gpu(), blender::nodes::node_composite_vector_blur_cc::VectorBlurOperation::dilate_max_velocity_gpu(), blender::nodes::node_composite_glare_cc::GlareOperation::downsample_kernel_gpu(), blender::compositor::ConversionOperation::execute(), blender::compositor::ShaderOperation::execute(), blender::nodes::node_composite_crop_cc::CropOperation::execute_alpha_crop_gpu(), blender::nodes::node_composite_kuwahara_cc::ConvertKuwaharaOperation::execute_anisotropic_gpu(), blender::nodes::node_composite_depth_combin_cc::ZCombineOperation::execute_anti_aliased_depth_gpu(), blender::nodes::node_composite_depth_combin_cc::ZCombineOperation::execute_anti_aliased_image_gpu(), blender::nodes::node_composite_kuwahara_cc::ConvertKuwaharaOperation::execute_classic_convolution_gpu(), blender::nodes::node_composite_kuwahara_cc::ConvertKuwaharaOperation::execute_classic_summed_area_table_gpu(), blender::nodes::node_composite_blur_cc::BlurOperation::execute_constant_size_gpu(), blender::nodes::node_composite_bokeh_blur_cc::BokehBlurOperation::execute_constant_size_gpu(), blender::nodes::node_composite_relative_to_pixel_cc::RelativeToPixelOperation::execute_float_gpu(), blender::nodes::node_composite_relative_to_pixel_cc::RelativeToPixelOperation::execute_float_per_dimension_gpu(), blender::nodes::node_composite_bilateral_blur_cc::BilateralBlurOperation::execute_gpu(), blender::nodes::node_composite_box_mask_cc::BoxMaskOperation::execute_gpu(), blender::nodes::node_composite_convert_color_space_cc::ConvertColorSpaceOperation::execute_gpu(), blender::nodes::node_composite_convert_to_display_cc::ConvertToDisplayOperation::execute_gpu(), blender::nodes::node_composite_defocus_cc::DefocusOperation::execute_gpu(), blender::nodes::node_composite_despeckle_cc::DespeckleOperation::execute_gpu(), blender::nodes::node_composite_directional_blur_cc::DirectionalBlurOperation::execute_gpu(), blender::nodes::node_composite_displace_cc::DisplaceOperation::execute_gpu(), blender::nodes::node_composite_ellipse_mask_cc::EllipseMaskOperation::execute_gpu(), blender::nodes::node_composite_filter_cc::FilterOperation::execute_gpu(), blender::nodes::node_composite_flip_cc::FlipOperation::execute_gpu(), blender::nodes::node_composite_id_mask_cc::IDMaskOperation::execute_gpu(), blender::nodes::node_composite_map_uv_cc::MapUVOperation::execute_gpu(), blender::nodes::node_composite_movie_distortion_cc::MovieDistortionOperation::execute_gpu(), blender::nodes::node_composite_normalize_cc::NormalizeOperation::execute_gpu(), blender::nodes::node_composite_pixelate_cc::PixelateOperation::execute_gpu(), blender::nodes::node_composite_split_cc::SplitOperation::execute_gpu(), blender::nodes::node_composite_glare_cc::GlareOperation::execute_highlights_gpu(), blender::nodes::node_composite_lens_distortion_cc::LensDistortionOperation::execute_horizontal_distortion_gpu(), blender::nodes::node_composite_crop_cc::CropOperation::execute_image_crop_gpu(), blender::nodes::node_composite_glare_cc::GlareOperation::execute_mix_gpu(), blender::nodes::node_composite_tone_map_cc::ToneMapOperation::execute_photoreceptor_gpu(), blender::nodes::node_composite_lens_distortion_cc::LensDistortionOperation::execute_radial_distortion_gpu(), blender::nodes::node_composite_depth_combin_cc::ZCombineOperation::execute_simple_depth_gpu(), blender::nodes::node_composite_tone_map_cc::ToneMapOperation::execute_simple_gpu(), blender::nodes::node_composite_depth_combin_cc::ZCombineOperation::execute_simple_image_gpu(), blender::nodes::node_composite_glare_cc::GlareOperation::execute_simple_star_anti_diagonal_pass_gpu(), blender::nodes::node_composite_glare_cc::GlareOperation::execute_simple_star_diagonal_pass_gpu(), blender::nodes::node_composite_glare_cc::GlareOperation::execute_simple_star_horizontal_pass_gpu(), blender::nodes::node_composite_glare_cc::GlareOperation::execute_simple_star_vertical_pass_gpu(), blender::nodes::node_composite_dilate_erode_cc::DilateErodeOperation::execute_step_horizontal_pass_gpu(), blender::nodes::node_composite_dilate_erode_cc::DilateErodeOperation::execute_step_vertical_pass_gpu(), blender::nodes::node_composite_glare_cc::GlareOperation::execute_sun_beams_gpu(), blender::nodes::node_composite_blur_cc::BlurOperation::execute_variable_size_gpu(), blender::nodes::node_composite_bokeh_blur_cc::BokehBlurOperation::execute_variable_size_gpu(), blender::nodes::node_composite_scale_cc::ScaleOperation::execute_variable_size_gpu(), blender::nodes::node_composite_relative_to_pixel_cc::RelativeToPixelOperation::execute_vector_gpu(), extract_alpha_gpu(), blender::nodes::node_composite_keying_cc::KeyingOperation::extract_input_chroma_gpu(), blender::nodes::node_composite_inpaint_cc::InpaintOperation::fill_inpainting_region_gpu(), horizontal_pass_gpu(), horizontal_pass_gpu(), jump_flooding_pass_gpu(), morphological_distance_gpu(), blender::nodes::node_composite_keying_cc::KeyingOperation::replace_input_chroma_gpu(), sum_causal_and_non_causal_results_gpu(), sum_causal_and_non_causal_results_gpu(), vertical_pass_gpu(), vertical_pass_gpu(), blender::nodes::node_composite_glare_cc::GlareOperation::write_glare_output_gpu(), blender::nodes::node_composite_glare_cc::GlareOperation::write_highlights_output_gpu(), blender::draw::compositor_engine::Context::write_output(), and zero_pad_gpu().

◆ compute_distance_falloff()

◆ compute_draw_horizontal_position()

float blender::compositor::compute_draw_horizontal_position ( const int start_offset,
const int line_width,
const int total_width,
const HorizontalAlignment alignment )
static

◆ compute_draw_vertical_position()

float blender::compositor::compute_draw_vertical_position ( const int lines_count,
const int line_index,
const int line_height,
const int descender )
static

◆ compute_exterior_angle()

float blender::compositor::compute_exterior_angle ( int sides)
static

Definition at line 80 of file bokeh_kernel.cc.

References compute_exterior_angle().

Referenced by compute_exterior_angle(), and compute_rotation().

◆ compute_feedback_coefficients()

double4 blender::compositor::compute_feedback_coefficients ( const std::array< std::complex< double >, 4 > & poles)
static

◆ compute_feedforward_coefficient()

double blender::compositor::compute_feedforward_coefficient ( const double4 & feedback_coefficients)
static

◆ compute_fog_glow_kernel_value()

◆ compute_horizontal_offset()

float blender::compositor::compute_horizontal_offset ( const int start_offset,
const int total_width,
const HorizontalAlignment alignment )
static

◆ compute_image_user_for_pass()

ImageUser blender::compositor::compute_image_user_for_pass ( const Context & context,
const Image & image,
const RenderResult * render_result,
const ImageUser & image_user,
const char * pass_name )
static

◆ compute_incomplete_prologues()

◆ compute_linear_buffer()

◆ compute_marker_points()

◆ compute_non_causal_feedforward_coefficients()

double4 blender::compositor::compute_non_causal_feedforward_coefficients ( const double4 & causal_feedforward_coefficients,
const double4 & feedback_coefficients )
static

◆ compute_normalization_scale()

float blender::compositor::compute_normalization_scale ( const double4 & causal_feedforward_coefficients,
const double4 & feedback_coefficients )
static

◆ compute_number_of_diagonals()

◆ compute_number_of_needed_buffers()

◆ compute_numerator()

◆ compute_numerator_0()

double blender::compositor::compute_numerator_0 ( )
static

Definition at line 69 of file deriche_gaussian_coefficients.cc.

References a0, c0, and compute_numerator_0().

Referenced by compute_numerator(), and compute_numerator_0().

◆ compute_numerator_1()

double blender::compositor::compute_numerator_1 ( float sigma)
static

◆ compute_numerator_2()

double blender::compositor::compute_numerator_2 ( float sigma)
static

◆ compute_numerator_3()

double blender::compositor::compute_numerator_3 ( float sigma)
static

◆ compute_output_domain()

◆ compute_output_reference_count()

◆ compute_partial_fraction_residue()

std::complex< double > blender::compositor::compute_partial_fraction_residue ( const std::array< std::complex< double >, 4 > & poles,
const std::complex< double > & target_pole,
double gain )
static

Computes the residue of the partial fraction of the transfer function of the given causal poles and gain for the given target pole. This essentially evaluates Equation (3.41) in Oppenheim's book, where d_k is the target pole and assuming the transfer function is in the form given in Equation (3.39), where d_k are the poles. See the following derivation for the gain value.

For the particular case of the Van Vliet's system, there are no zeros, so the numerator in Equation (3.39) is one. Further note that Van Vliet's formulation is different from the expected form, so we need to rearrange Equation (3) in to match the form in Equation (3.39), which is shown below.

Start from the causal term of Equation (3):

H_+(z) = \prod_{i=1}^N \frac{d_i - 1}{d_i - z^{-1}}

Divide by d_i:

H_+(z) = \prod_{i=1}^N \frac{1 - d_i^{-1}}{1 - d_i^{-1}z^{-1}}

Move the numerator to its own product:

H_+(z) = \prod_{i=1}^N 1 - d_i^{-1} \prod_{i=1}^N \frac{1}{1 - d_i^{-1}z^{-1}}

And we reach the same form as Equation (3.39). Where the first product term is b0 / a0 and is also the given gain value, which is also the same as the feedforward coefficient denoted by the alpha in Equation (12). Further d_i^{-1} in our derivation is the same as d_k in Equation (3.39), the discrepancy in the inverse operator is the fact that Van Vliet's derivation assume non causal poles, while Oppenheim's assume causal poles, which are inverse of each other as can be seen in the compute_causal_poles function.

Definition at line 290 of file van_vliet_gaussian_coefficients.cc.

References compute_partial_fraction_residue().

Referenced by compute_partial_fraction_residue(), and blender::compositor::VanVlietGaussianCoefficients::VanVlietGaussianCoefficients().

◆ compute_preview()

◆ compute_preview_cpu()

◆ compute_preview_gpu()

◆ compute_preview_size()

int2 blender::compositor::compute_preview_size ( int2 size)
static

◆ compute_radius_from_sigma() [1/2]

float2 blender::compositor::compute_radius_from_sigma ( const float2 sigma)
static

◆ compute_radius_from_sigma() [2/2]

float2 blender::compositor::compute_radius_from_sigma ( const float2 sigma)
static

◆ compute_rotation()

float blender::compositor::compute_rotation ( float angle,
int sides )
static

Definition at line 85 of file bokeh_kernel.cc.

References angle(), compute_exterior_angle(), and compute_rotation().

Referenced by compute_rotation().

◆ compute_scaled_poles_variance()

double blender::compositor::compute_scaled_poles_variance ( const std::array< std::complex< double >, 4 > & poles,
double scale_factor )
static

◆ compute_scaled_poles_variance_derivative()

double blender::compositor::compute_scaled_poles_variance_derivative ( const std::array< std::complex< double >, 4 > & poles,
double scale_factor )
static

Computes the partial derivative with respect to the scale factor at the given scale factor of the variance of the Gaussian filter represented by the given poles scaled by the given scale factor. This is based on the partial derivative with respect to the scale factor of Equation (20) in Van Vliet's paper.

The derivative is not listed in the paper, but was computed manually as the sum of the following for each of the poles:

\frac{
2a^\frac{1}{x}e^\frac{ib}{x} (e^\frac{ib}{x}+a^\frac{1}{x}) (\ln(a)-ib)
}{
x^2 (a^\frac{1}{x}-e^\frac{ib}{x})^3
}

Where "x" is the scale factor, "a" is the magnitude of the pole, and "b" is its phase.

Definition at line 101 of file van_vliet_gaussian_coefficients.cc.

References compute_scaled_poles_variance_derivative(), and blender::math::square().

Referenced by compute_scaled_poles_variance_derivative(), and find_scale_factor().

◆ compute_schedule()

◆ compute_second_order_section()

void blender::compositor::compute_second_order_section ( const std::complex< double > & pole,
const std::complex< double > & residue,
const std::complex< double > & transfer_value,
double2 & r_feedback_coefficients,
double2 & r_causal_feedforward_coefficients,
double2 & r_non_causal_feedforward_coefficients )
static

◆ compute_sigma_from_radius()

float2 blender::compositor::compute_sigma_from_radius ( float2 radius)
static

◆ compute_vertical_offset()

float blender::compositor::compute_vertical_offset ( const int total_height,
const int line_height,
const int descender,
const VerticalAlignment alignment )
static

◆ computed_scaled_poles()

std::array< std::complex< double >, 4 > blender::compositor::computed_scaled_poles ( const std::array< std::complex< double >, 4 > & poles,
float sigma )
static

◆ convolve()

◆ deriche_gaussian_blur()

◆ detect_edges()

Result blender::compositor::detect_edges ( Context & context,
const Result & input,
const float threshold,
const float local_contrast_adaptation_factor )
static

Definition at line 1526 of file smaa.cc.

References detect_edges(), detect_edges_cpu(), and detect_edges_gpu().

Referenced by detect_edges(), and smaa().

◆ detect_edges_cpu()

◆ detect_edges_gpu()

◆ encode_jump_flooding_value()

int2 blender::compositor::encode_jump_flooding_value ( const int2 & closest_seed_texel,
const bool is_flooded )
inline

◆ extract_alpha()

◆ extract_alpha_cpu()

void blender::compositor::extract_alpha_cpu ( const Result & input,
Result & output )
static

◆ extract_alpha_gpu()

◆ find_dependency_nodes()

Vector< const bNode * > blender::compositor::find_dependency_nodes ( const Context & context,
Schedule & schedule,
const bNode & node,
const bke::bNodeTreeZone * zone,
SocketResultFn socket_result_fn )
static

◆ find_node_dependency_nodes()

◆ find_preview_output_socket()

const bNodeSocket * blender::compositor::find_preview_output_socket ( const bNode & node)

◆ find_scale_factor()

double blender::compositor::find_scale_factor ( const std::array< std::complex< double >, 4 > & poles,
double reference_sigma )
static

◆ find_zone_dependency_nodes()

◆ float_type()

ResultType blender::compositor::float_type ( const int channels_count)
static

◆ get_anti_diagonal_direction()

◆ get_blend_shader_name()

const char * blender::compositor::get_blend_shader_name ( ResultType type)
static

Definition at line 1615 of file smaa.cc.

References BLI_assert_unreachable, Color, Float, and get_blend_shader_name().

Referenced by blend_neighborhood_gpu(), and get_blend_shader_name().

◆ get_blur_shader()

const char * blender::compositor::get_blur_shader ( const ResultType type)
static

Definition at line 55 of file symmetric_separable_blur.cc.

References BLI_assert_unreachable, Color, Float, Float4, and get_blur_shader().

Referenced by blur_pass_gpu(), and get_blur_shader().

◆ get_bundle_info_log()

◆ get_closure_info_log()

◆ get_compute_complete_blocks_shader()

const char * blender::compositor::get_compute_complete_blocks_shader ( SummedAreaTableOperation operation)
static

◆ get_compute_incomplete_prologues_shader()

const char * blender::compositor::get_compute_incomplete_prologues_shader ( SummedAreaTableOperation operation)
static

◆ get_default_input_value_link()

◆ get_diagonal_direction()

◆ get_domain_priority()

int blender::compositor::get_domain_priority ( const bNodeSocket * input,
const nodes::SocketDeclaration * socket_declaration )
static

◆ get_effect_input()

Result * blender::compositor::get_effect_input ( Context & context,
PointerRNA & effect_inputs_ptr,
const bNodeTreeInterfaceSocket & input_socket )
static

Definition at line 43 of file scene_compositor_effects_operation.cc.

References BLI_assert_unreachable, blender::PointerRNA::data_as(), blender::bNodeSocketValueIntVector::dimensions, blender::bNodeSocketValueVector::dimensions, blender::gpu::shader::metadata::float2, blender::gpu::shader::metadata::float3, blender::gpu::shader::metadata::float4, get_effect_input(), get_node_interface_socket_result_type(), blender::bNodeTreeInterfaceSocket::identifier, blender::gpu::shader::metadata::int2, blender::gpu::shader::metadata::int3, blender::result, blender::RNA_boolean_get(), blender::RNA_enum_get(), blender::RNA_float_get(), blender::RNA_float_get_array(), blender::RNA_int_get(), blender::RNA_int_get_array(), blender::RNA_pointer_get(), blender::RNA_string_get(), blender::SOCK_BOOLEAN, blender::SOCK_BUNDLE, blender::SOCK_CLOSURE, blender::SOCK_COLLECTION, blender::SOCK_CUSTOM, blender::SOCK_FLOAT, blender::SOCK_FONT, blender::SOCK_GEOMETRY, blender::SOCK_IMAGE, blender::SOCK_INT, blender::SOCK_INT_VECTOR, blender::SOCK_MASK, blender::SOCK_MATERIAL, blender::SOCK_MATRIX, blender::SOCK_MENU, blender::SOCK_OBJECT, blender::SOCK_RGBA, blender::SOCK_ROTATION, blender::SOCK_SCENE, blender::SOCK_SHADER, blender::SOCK_SOUND, blender::SOCK_STRING, blender::SOCK_TEXT_ID, blender::SOCK_TEXTURE, blender::SOCK_VECTOR, blender::bNodeTreeInterfaceSocket::socket_data, and blender::math::to_quaternion().

Referenced by blender::compositor::SceneCompositorEffectsOperation::execute(), and get_effect_input().

◆ get_execution_mode()

◆ get_group_node_operation()

NodeOperation * blender::compositor::get_group_node_operation ( Context & context,
const bNode & node )

Definition at line 133 of file group_node_operation.cc.

References get_group_node_operation(), and node.

Referenced by get_group_node_operation().

◆ get_image_info_log() [1/2]

◆ get_image_info_log() [2/2]

◆ get_implicit_input()

◆ get_implicit_input_result_type()

◆ get_input_socket_value()

◆ get_input_value_link()

◆ get_luminance_coefficients()

◆ get_mask_raster_handles()

◆ get_movie_clip_size()

int2 blender::compositor::get_movie_clip_size ( MovieClip * movie_clip,
int frame_number )
static

◆ get_movie_clip_user()

MovieClipUser blender::compositor::get_movie_clip_user ( Context & context,
MovieClip * movie_clip )
static

◆ get_node_group_result_for_socket()

◆ get_node_interface_socket_result_type()

◆ get_node_socket_result_type()

◆ get_node_tree_input_node_operation()

NodeOperation * blender::compositor::get_node_tree_input_node_operation ( Context & context,
const bNode & node,
Operation & operation )

◆ get_node_tree_output_node_operation()

NodeOperation * blender::compositor::get_node_tree_output_node_operation ( Context & context,
const bNode & node,
Operation & operation )

◆ get_output_linked_to_input()

const bNodeSocket * blender::compositor::get_output_linked_to_input ( const bNodeSocket & input)

◆ get_output_nodes()

◆ get_pass_index()

int blender::compositor::get_pass_index ( const RenderResult * render_result,
const ImageUser & image_user,
const char * name )
static

◆ get_pass_type()

ResultType blender::compositor::get_pass_type ( const RenderPass * render_pass)
static

◆ get_pixel_sampler_shader_name()

char const * blender::compositor::get_pixel_sampler_shader_name ( const Interpolation & interpolation)
static

◆ get_regular_polygon_vertex_position()

float2 blender::compositor::get_regular_polygon_vertex_position ( const int vertex_index,
const float exterior_angle,
const float rotation )
static

◆ get_render_layer()

RenderLayer * blender::compositor::get_render_layer ( const RenderResult * render_result,
const ImageUser & image_user )
static

◆ get_render_pass() [1/2]

RenderPass * blender::compositor::get_render_pass ( const RenderLayer * render_layer,
const ImageUser & image_user )
static

◆ get_render_pass() [2/2]

RenderPass * blender::compositor::get_render_pass ( const RenderResult * render_result,
const ImageUser & image_user )
static

Definition at line 95 of file cached_image.cc.

References get_render_layer(), and get_render_pass().

◆ get_result_single_value_link()

◆ get_set_function_name()

◆ get_shader()

const char * blender::compositor::get_shader ( MorphologicalBlurOperation operation)
static

Definition at line 20 of file morphological_blur.cc.

References BLI_assert_unreachable, Dilate, Erode, and get_shader().

Referenced by apply_morphological_operator_gpu(), and get_shader().

◆ get_shader_name() [1/4]

const char * blender::compositor::get_shader_name ( const CoordinatesType type)
static

Definition at line 73 of file image_coordinates.cc.

References BLI_assert_unreachable, get_shader_name(), Normalized, Pixel, and Uniform.

◆ get_shader_name() [2/4]

const char * blender::compositor::get_shader_name ( const int distance)
static

◆ get_shader_name() [3/4]

const char * blender::compositor::get_shader_name ( const int distance)
static

Definition at line 132 of file morphological_distance_feather.cc.

References distance(), and get_shader_name().

◆ get_shader_name() [4/4]

const char * blender::compositor::get_shader_name ( const ResultType type,
const PaddingMethod padding_method )
static

Definition at line 15 of file pad.cc.

References BLI_assert_unreachable, Color, Extend, Float, Float2, Float4, get_shader_name(), and Zero.

◆ get_store_function_name()

◆ get_undefined_node_operation()

NodeOperation * blender::compositor::get_undefined_node_operation ( Context & context,
const bNode & node )

Definition at line 28 of file undefined_node_operation.cc.

References get_undefined_node_operation(), and node.

Referenced by get_undefined_node_operation().

◆ get_view_index()

int blender::compositor::get_view_index ( const Context & context,
const RenderResult * render_result,
const ImageUser & image_user )
static

◆ get_zone_result_for_socket()

◆ glsl_store_expression_from_result_type()

◆ glsl_swizzle_from_result_type()

◆ glsl_type_from_result_type()

◆ gpu_image_type_from_result_type()

◆ gpu_type_from_socket()

◆ has_file_output_recursive()

bool blender::compositor::has_file_output_recursive ( const bNodeTree & node_group)
static

Definition at line 89 of file scheduler.cc.

References has_file_output_recursive(), and node.

Referenced by get_output_nodes(), and has_file_output_recursive().

◆ has_viewer_node()

bool blender::compositor::has_viewer_node ( const bNodeTree & node_group,
const ComputeContext & compute_context,
const ComputeContext & viewer_compute_context,
bke::ComputeContextCache & compute_context_cache )
static

◆ horizontal_pass() [1/2]

Result blender::compositor::horizontal_pass ( Context & context,
const Result & input,
const int distance,
const int falloff_type )
static

◆ horizontal_pass() [2/2]

Result blender::compositor::horizontal_pass ( Context & context,
const Result & input,
const Result & radius,
const int weights_resolution,
const math::FilterKernel filter_type )
static

◆ horizontal_pass_cpu() [1/2]

◆ horizontal_pass_cpu() [2/2]

Result blender::compositor::horizontal_pass_cpu ( Context & context,
const Result & input,
const Result & radius,
const int weights_resolution,
const math::FilterKernel filter_type )
static

◆ horizontal_pass_gpu() [1/2]

◆ horizontal_pass_gpu() [2/2]

◆ init()

void blender::compositor::init ( )

Definition at line 17 of file init.cc.

References init(), and register_cpp_types().

Referenced by init(), and main().

◆ initialize_jump_flooding_value()

◆ input_descriptor_from_input_socket()

◆ input_descriptor_from_interface_input()

◆ is_compatible_texture()

bool blender::compositor::is_compatible_texture ( const gpu::Texture * texture,
const Result & result )
static

◆ is_index_switch_node_input_needed()

bool blender::compositor::is_index_switch_node_input_needed ( const Context & context,
const bNode & node,
const bNodeSocket & input,
SocketResultFn socket_result_fn )
static

◆ is_input_needed()

◆ is_menu_switch_node_input_needed()

bool blender::compositor::is_menu_switch_node_input_needed ( const Context & context,
const bNode & node,
const bNodeSocket & input,
SocketResultFn socket_result_fn )
static

◆ is_node_preview_needed()

bool blender::compositor::is_node_preview_needed ( const bNode & node)

◆ is_node_tree_input_node()

bool blender::compositor::is_node_tree_input_node ( const bNode & node)
static

◆ is_output_linked_to_input_conditioned()

bool blender::compositor::is_output_linked_to_input_conditioned ( const bNodeSocket & output,
FunctionRef< bool(const bNodeSocket &)> condition )

◆ is_pixel_node()

bool blender::compositor::is_pixel_node ( const bNode & node)

◆ is_socket_available()

bool blender::compositor::is_socket_available ( const bNodeSocket * socket)

Definition at line 26 of file utilities.cc.

References blender::bNodeSocket::idname, is_socket_available(), and blender::StringRef::StringRef().

Referenced by blender::nodes::node_geo_evaluate_closure_cc::EvaluateClosureOperation::add_missing_inputs_outputs_warnings(), compute_number_of_needed_buffers(), blender::compositor::NodeOperation::compute_results_reference_counts(), blender::compositor::ZoneOperation::compute_results_reference_counts(), blender::compositor::NodeTreeInputNodeOperation::execute(), blender::compositor::NodeTreeOutputNodeOperation::execute(), blender::compositor::RepeatZoneOperation::execute(), blender::nodes::node_composite_image_cc::ImageOperation::execute(), blender::nodes::node_composite_render_layer_cc::RenderLayerOperation::execute(), find_node_dependency_nodes(), find_preview_output_socket(), get_closure_info_log(), blender::nodes::node_composite_legacy_cryptomatte_cc::LegacyCryptoMatteOperation::get_layers(), get_output_nodes(), is_socket_available(), blender::compositor::NodeOperation::log_data(), blender::compositor::PixelOperation::log_data(), blender::compositor::ZoneOperation::log_data(), blender::nodes::node_geo_evaluate_closure_cc::EvaluateClosureOperation::map_inputs(), blender::compositor::NodeOperation::NodeOperation(), blender::nodes::node_geo_evaluate_closure_cc::EvaluateClosureOperation::set_reference_counts(), blender::nodes::node_geo_evaluate_closure_cc::EvaluateClosureOperation::write_default_outputs(), blender::nodes::node_geo_evaluate_closure_cc::EvaluateClosureOperation::write_outputs(), and blender::compositor::ZoneOperation::ZoneOperation().

◆ is_switch_node_input_needed()

bool blender::compositor::is_switch_node_input_needed ( const Context & context,
const bNode & node,
const bNodeSocket & input,
SocketResultFn socket_result_fn )
static

◆ jump_flooding()

◆ jump_flooding_pass()

void blender::compositor::jump_flooding_pass ( Context & context,
Result & input,
Result & output,
int step_size )
static

◆ jump_flooding_pass_cpu()

void blender::compositor::jump_flooding_pass_cpu ( Result & input,
Result & output,
int step_size )
static

◆ jump_flooding_pass_gpu()

◆ load_font()

◆ log_result()

◆ map_extension_mode_to_extend_mode()

◆ map_extension_mode_to_wrap_mode()

◆ maximum_color()

Color blender::compositor::maximum_color ( Context & context,
const Result & input )

◆ maximum_color_cpu()

◆ maximum_color_gpu()

Color blender::compositor::maximum_color_gpu ( Context & context,
const Result & input )
static

◆ maximum_float()

float blender::compositor::maximum_float ( Context & context,
const Result & input )

◆ maximum_float2()

◆ maximum_float2_cpu()

◆ maximum_float2_gpu()

◆ maximum_float_cpu()

◆ maximum_float_gpu()

float blender::compositor::maximum_float_gpu ( Context & context,
const Result & input )
static

◆ maximum_float_in_range()

float blender::compositor::maximum_float_in_range ( Context & context,
const Result & input,
const float lower_bound,
const float upper_bound )

◆ maximum_float_in_range_cpu()

float blender::compositor::maximum_float_in_range_cpu ( const Result & input,
const float lower_bound,
const float upper_bound )
static

◆ maximum_float_in_range_gpu()

float blender::compositor::maximum_float_in_range_gpu ( Context & context,
const Result & input,
const float lower_bound,
const float upper_bound )
static

◆ maximum_luminance()

float blender::compositor::maximum_luminance ( Context & context,
const Result & input,
const float3 & luminance_coefficients )

◆ maximum_luminance_cpu()

float blender::compositor::maximum_luminance_cpu ( const Result & input,
const float3 & luminance_coefficients )
static

◆ maximum_luminance_gpu()

◆ minimum_color()

◆ minimum_color_cpu()

◆ minimum_color_gpu()

Color blender::compositor::minimum_color_gpu ( Context & context,
const Result & input )
static

◆ minimum_float()

float blender::compositor::minimum_float ( Context & context,
const Result & input )

Definition at line 269 of file parallel_reduction.cc.

References minimum_float(), minimum_float_cpu(), and minimum_float_gpu().

Referenced by minimum_float().

◆ minimum_float_cpu()

◆ minimum_float_gpu()

float blender::compositor::minimum_float_gpu ( Context & context,
const Result & input )
static

◆ minimum_float_in_range()

float blender::compositor::minimum_float_in_range ( Context & context,
const Result & input,
const float lower_bound,
const float upper_bound )

◆ minimum_float_in_range_cpu()

float blender::compositor::minimum_float_in_range_cpu ( const Result & input,
const float lower_bound,
const float upper_bound )
static

◆ minimum_float_in_range_gpu()

float blender::compositor::minimum_float_in_range_gpu ( Context & context,
const Result & input,
const float lower_bound,
const float upper_bound )
static

◆ minimum_luminance()

float blender::compositor::minimum_luminance ( Context & context,
const Result & input,
const float3 & luminance_coefficients )

◆ minimum_luminance_cpu()

float blender::compositor::minimum_luminance_cpu ( const Result & input,
const float3 & luminance_coefficients )
static

◆ minimum_luminance_gpu()

◆ morphological_blur()

◆ morphological_distance()

◆ morphological_distance_cpu()

template<bool IsDilate>
void blender::compositor::morphological_distance_cpu ( const Result & input,
Result & output,
const int structuring_element_radius )
static

◆ morphological_distance_feather()

◆ morphological_distance_feather_pass()

◆ morphological_distance_gpu()

◆ operator!=()

bool blender::compositor::operator!= ( const Domain & a,
const Domain & b )

Definition at line 107 of file domain.cc.

References b, and operator!=().

Referenced by operator!=().

◆ operator==() [1/15]

◆ operator==() [2/15]

◆ operator==() [3/15]

bool blender::compositor::operator== ( const CachedShaderKey & a,
const CachedShaderKey & b )

◆ operator==() [4/15]

bool blender::compositor::operator== ( const DericheGaussianCoefficientsKey & a,
const DericheGaussianCoefficientsKey & b )

◆ operator==() [5/15]

◆ operator==() [6/15]

◆ operator==() [7/15]

◆ operator==() [8/15]

◆ operator==() [9/15]

bool blender::compositor::operator== ( const KeyingScreenKey & a,
const KeyingScreenKey & b )

◆ operator==() [10/15]

◆ operator==() [11/15]

◆ operator==() [12/15]

◆ operator==() [13/15]

◆ operator==() [14/15]

◆ operator==() [15/15]

bool blender::compositor::operator== ( const VanVlietGaussianCoefficientsKey & a,
const VanVlietGaussianCoefficientsKey & b )

◆ pad()

◆ parallel_for()

template<typename Function>
void blender::compositor::parallel_for ( const int2 range,
const Function & function )
inline

Definition at line 77 of file COM_utilities.hh.

References blender::IndexRange::IndexRange(), blender::gpu::shader::metadata::int2, parallel_for(), and blender::threading::parallel_for().

Referenced by blender::nodes::node_composite_glare_cc::GlareOperation::accumulate_ghosts_cpu(), blender::nodes::node_composite_glare_cc::GlareOperation::accumulate_streak_cpu(), apply_morphological_operator_cpu(), blender::nodes::node_composite_glare_cc::GlareOperation::apply_streak_filter_cpu(), blend_neighborhood_cpu(), blur_pass(), blur_pass(), blur_pass_cpu(), blur_pass_cpu(), blender::nodes::node_composite_box_mask_cc::box_mask(), blender::compositor::CachedImage::CachedImage(), blender::compositor::CachedMask::CachedMask(), calculate_blending_weights_cpu(), blender::nodes::node_composite_movie_clip_cc::MovieClipOperation::compute_alpha(), blender::nodes::node_composite_displace_cc::DisplaceOperation::compute_anisotropic(), blender::nodes::node_composite_glare_cc::GlareOperation::compute_base_ghost_cpu(), blender::nodes::node_composite_glare_cc::GlareOperation::compute_bloom_downsample_chain(), blender::nodes::node_composite_glare_cc::GlareOperation::compute_bloom_downsample_cpu(), blender::nodes::node_composite_glare_cc::GlareOperation::compute_bloom_upsample_cpu(), blender::nodes::node_composite_bokeh_blur_cc::BokehBlurOperation::compute_blur_kernel(), blender::nodes::node_composite_double_edge_mask_cc::DoubleEdgeMaskOperation::compute_boundary_cpu(), blender::nodes::node_composite_mask_to_sdf_cc::MaskToSDFOperation::compute_boundary_cpu(), blender::nodes::node_composite_kuwahara_cc::ConvertKuwaharaOperation::compute_classic(), blender::nodes::node_composite_defocus_cc::DefocusOperation::compute_defocus_radius_from_depth_cpu(), blender::nodes::node_composite_defocus_cc::DefocusOperation::compute_defocus_radius_from_scale_cpu(), blender::nodes::node_composite_dilate_erode_cc::DilateErodeOperation::compute_distance_threshold_cpu(), blender::nodes::node_composite_dilate_erode_cc::DilateErodeOperation::compute_distance_threshold_seeds_cpu(), blender::nodes::node_composite_double_edge_mask_cc::DoubleEdgeMaskOperation::compute_gradient_cpu(), blender::nodes::node_composite_movie_clip_cc::MovieClipOperation::compute_image(), blender::nodes::node_composite_base_cryptomatte_cc::BaseCryptoMatteOperation::compute_image_cpu(), blender::nodes::node_composite_keying_cc::KeyingOperation::compute_image_cpu(), blender::nodes::node_composite_inpaint_cc::InpaintOperation::compute_inpainting_boundary_cpu(), blender::nodes::node_composite_inpaint_cc::InpaintOperation::compute_inpainting_region_cpu(), blender::nodes::node_composite_displace_cc::DisplaceOperation::compute_interpolation(), blender::nodes::node_composite_depth_combin_cc::ZCombineOperation::compute_mask_cpu(), blender::nodes::node_composite_base_cryptomatte_cc::BaseCryptoMatteOperation::compute_matte_cpu(), blender::nodes::node_composite_keying_cc::KeyingOperation::compute_matte_cpu(), blender::nodes::node_composite_vector_blur_cc::compute_max_tile_velocity_cpu(), blender::nodes::node_composite_base_cryptomatte_cc::BaseCryptoMatteOperation::compute_pick_cpu(), blender::nodes::node_composite_corner_pin_cc::CornerPinOperation::compute_plane_cpu(), blender::nodes::node_composite_plane_track_deform_cc::PlaneTrackDeformOperation::compute_plane_cpu(), blender::nodes::node_composite_corner_pin_cc::CornerPinOperation::compute_plane_mask_cpu(), blender::nodes::node_composite_plane_track_deform_cc::PlaneTrackDeformOperation::compute_plane_mask_cpu(), blender::nodes::node_composite_mask_to_sdf_cc::MaskToSDFOperation::compute_signed_distance_cpu(), blender::nodes::node_composite_kuwahara_cc::ConvertKuwaharaOperation::compute_structure_tensor_cpu(), blender::nodes::node_composite_keying_cc::KeyingOperation::compute_tweaked_matte_cpu(), convolve(), detect_edges_cpu(), blender::nodes::node_composite_vector_blur_cc::dilate_max_velocity_cpu(), blender::compositor::DistortionGrid::DistortionGrid(), blender::compositor::Result::download_to_cpu(), blender::nodes::node_composite_glare_cc::GlareOperation::downsample_kernel_cpu(), blender::nodes::node_composite_ellipse_mask_cc::ellipse_mask(), blender::nodes::node_composite_blank_image_cc::BlankImageOperation::execute(), blender::nodes::node_composite_denoise_cc::DenoiseOperation::execute(), blender::nodes::node_composite_crop_cc::CropOperation::execute_alpha_crop_cpu(), blender::nodes::node_composite_kuwahara_cc::ConvertKuwaharaOperation::execute_anisotropic_cpu(), blender::nodes::node_composite_depth_combin_cc::ZCombineOperation::execute_anti_aliased_cpu(), blender::nodes::node_composite_glare_cc::GlareOperation::execute_bloom(), blender::nodes::node_composite_blur_cc::BlurOperation::execute_constant_size_cpu(), blender::nodes::node_composite_bokeh_blur_cc::BokehBlurOperation::execute_constant_size_cpu(), blender::nodes::node_composite_bilateral_blur_cc::BilateralBlurOperation::execute_cpu(), blender::nodes::node_composite_convert_color_space_cc::ConvertColorSpaceOperation::execute_cpu(), blender::nodes::node_composite_convert_to_display_cc::ConvertToDisplayOperation::execute_cpu(), blender::nodes::node_composite_defocus_cc::DefocusOperation::execute_cpu(), blender::nodes::node_composite_despeckle_cc::DespeckleOperation::execute_cpu(), blender::nodes::node_composite_directional_blur_cc::DirectionalBlurOperation::execute_cpu(), blender::nodes::node_composite_filter_cc::FilterOperation::execute_cpu(), blender::nodes::node_composite_flip_cc::FlipOperation::execute_cpu(), blender::nodes::node_composite_id_mask_cc::IDMaskOperation::execute_cpu(), blender::nodes::node_composite_movie_distortion_cc::MovieDistortionOperation::execute_cpu(), blender::nodes::node_composite_normalize_cc::NormalizeOperation::execute_cpu(), blender::nodes::node_composite_pixelate_cc::PixelateOperation::execute_cpu(), blender::nodes::node_composite_split_cc::SplitOperation::execute_cpu(), blender::nodes::node_composite_map_uv_cc::MapUVOperation::execute_cpu_anisotropic(), blender::nodes::node_composite_map_uv_cc::MapUVOperation::execute_cpu_interpolation(), blender::nodes::node_composite_relative_to_pixel_cc::RelativeToPixelOperation::execute_float_cpu(), blender::nodes::node_composite_relative_to_pixel_cc::RelativeToPixelOperation::execute_float_per_dimension_cpu(), blender::nodes::node_composite_glare_cc::GlareOperation::execute_highlights_cpu(), blender::nodes::node_composite_lens_distortion_cc::LensDistortionOperation::execute_horizontal_distortion_cpu(), blender::nodes::node_composite_crop_cc::CropOperation::execute_image_crop_cpu(), blender::nodes::node_composite_glare_cc::GlareOperation::execute_kernel(), blender::nodes::node_composite_glare_cc::GlareOperation::execute_mix_cpu(), blender::nodes::node_composite_tone_map_cc::ToneMapOperation::execute_photoreceptor_cpu(), blender::nodes::node_composite_lens_distortion_cc::LensDistortionOperation::execute_radial_distortion_cpu(), blender::nodes::node_composite_depth_combin_cc::ZCombineOperation::execute_simple_cpu(), blender::nodes::node_composite_tone_map_cc::ToneMapOperation::execute_simple_cpu(), blender::nodes::node_composite_glare_cc::GlareOperation::execute_simple_star_anti_diagonal_pass_cpu(), blender::nodes::node_composite_glare_cc::GlareOperation::execute_simple_star_diagonal_pass_cpu(), blender::nodes::node_composite_glare_cc::GlareOperation::execute_simple_star_horizontal_pass_cpu(), blender::nodes::node_composite_glare_cc::GlareOperation::execute_simple_star_vertical_pass_cpu(), blender::nodes::node_composite_glare_cc::GlareOperation::execute_streaks(), blender::nodes::node_composite_glare_cc::GlareOperation::execute_sun_beams(), blender::nodes::node_composite_glare_cc::GlareOperation::execute_sun_beams_cpu(), blender::nodes::node_composite_blur_cc::BlurOperation::execute_variable_size_cpu(), blender::nodes::node_composite_bokeh_blur_cc::BokehBlurOperation::execute_variable_size_cpu(), blender::nodes::node_composite_scale_cc::ScaleOperation::execute_variable_size_cpu(), blender::nodes::node_composite_relative_to_pixel_cc::RelativeToPixelOperation::execute_vector_cpu(), extract_alpha_cpu(), blender::nodes::node_composite_keying_cc::KeyingOperation::extract_input_chroma_cpu(), blender::nodes::node_composite_inpaint_cc::InpaintOperation::fill_inpainting_region_cpu(), jump_flooding_pass_cpu(), morphological_distance_cpu(), morphological_distance_feather_pass(), parallel_for(), realize_on_domain(), blender::nodes::node_composite_keying_cc::KeyingOperation::replace_input_chroma_cpu(), blender::compositor::StringImage::StringImage(), sum_causal_and_non_causal_results_cpu(), sum_causal_and_non_causal_results_cpu(), blender::compositor::Result::upload_to_gpu(), blender::nodes::node_composite_glare_cc::GlareOperation::write_glare_output_cpu(), blender::nodes::node_composite_glare_cc::GlareOperation::write_highlights_output_cpu(), and zero_pad_cpu().

◆ parallel_reduce() [1/2]

template<typename Value, typename Function, typename Reduction>
Value blender::compositor::parallel_reduce ( const int range,
const Value & identity,
const Function & function,
const Reduction & reduction )
static

◆ parallel_reduce() [2/2]

◆ parallel_reduction_dispatch()

◆ populate_gpu_node_stack()

◆ realize_on_domain()

template<typename T>
void blender::compositor::realize_on_domain ( const Result & input,
Result & output,
const float3x3 & transformation,
const std::optional< float2x2 > & jacobian )
static

◆ recursive_gaussian_blur()

◆ register_cpp_types()

void blender::compositor::register_cpp_types ( )
static

Definition at line 12 of file init.cc.

References BLI_CPP_TYPE_REGISTER, blender::None, and register_cpp_types().

Referenced by init(), and register_cpp_types().

◆ sample_ewa_read_callback()

◆ sample_pixel()

◆ sample_pixel_cpu()

Color blender::compositor::sample_pixel_cpu ( const Result & input,
const Interpolation & interpolation,
const Extension & extension_mode_x,
const Extension & extension_mode_y,
const float2 coordinates )
static

◆ sample_pixel_gpu()

◆ sanitize_domain_data_size()

Domain blender::compositor::sanitize_domain_data_size ( const Domain domain,
const Context & context,
const std::optional< ResultStorageType > storage_type )
static

◆ smaa()

◆ SMAAArea()

float2 blender::compositor::SMAAArea ( SMAATexture2D(areaTex) ,
float2 dist,
float e1,
float e2,
float offset )
static

Ok, we have the distance and both crossing edges. So, what are the areas at each side of current edge?

Definition at line 1131 of file smaa.cc.

References blender::gpu::shader::metadata::float2, mad, blender::math::round(), SMAA_AREATEX_MAX_DISTANCE, SMAA_AREATEX_PIXEL_SIZE, SMAA_AREATEX_SELECT, SMAA_AREATEX_SUBTEX_SIZE, SMAAArea(), SMAASampleLevelZero, and SMAATexture2D.

Referenced by SMAAArea(), and SMAABlendingWeightCalculationPS().

◆ SMAAAreaDiag()

float2 blender::compositor::SMAAAreaDiag ( SMAATexture2D(areaTex) ,
float2 dist,
float2 e,
float offset )
static

Similar to SMAAArea, this calculates the area corresponding to a certain diagonal distance and crossing edges 'e'.

Definition at line 880 of file smaa.cc.

References blender::e, blender::gpu::shader::metadata::float2, mad, SMAA_AREATEX_MAX_DISTANCE_DIAG, SMAA_AREATEX_PIXEL_SIZE, SMAA_AREATEX_SELECT, SMAA_AREATEX_SUBTEX_SIZE, SMAAAreaDiag(), SMAASampleLevelZero, and SMAATexture2D.

Referenced by SMAAAreaDiag(), and SMAACalculateDiagWeights().

◆ SMAABlendingWeightCalculationPS()

◆ SMAABlendingWeightCalculationVS()

void blender::compositor::SMAABlendingWeightCalculationVS ( float2 texcoord,
int2 size,
float2 & pixcoord,
float4 offset[3] )
static

◆ SMAACalculateDiagWeights()

◆ SMAADecodeDiagBilinearAccess() [1/2]

float2 blender::compositor::SMAADecodeDiagBilinearAccess ( float2 e)
static

◆ SMAADecodeDiagBilinearAccess() [2/2]

float4 blender::compositor::SMAADecodeDiagBilinearAccess ( float4 e)
static

◆ SMAADetectHorizontalCornerPattern()

void blender::compositor::SMAADetectHorizontalCornerPattern ( SMAATexture2D(edgesTex) ,
float2 & weights,
float4 texcoord,
float2 d,
int2 size,
int corner_rounding )
static

◆ SMAADetectVerticalCornerPattern()

void blender::compositor::SMAADetectVerticalCornerPattern ( SMAATexture2D(edgesTex) ,
float2 & weights,
float4 texcoord,
float2 d,
int2 size,
int corner_rounding )
static

◆ SMAAEdgeDetectionVS()

void blender::compositor::SMAAEdgeDetectionVS ( float2 texcoord,
int2 size,
float4 offset[3] )
static

◆ SMAALumaEdgeDetectionPS()

template<typename T>
float2 blender::compositor::SMAALumaEdgeDetectionPS ( float2 texcoord,
float4 offset[3],
SMAATexture2D(colorTex) ,
float edge_threshold,
float3 luminance_coefficients,
float local_contrast_adaptation_factor )
static

Luma Edge Detection

IMPORTANT NOTICE: luma edge detection requires gamma-corrected colors, and thus 'colorTex' should be a non-sRGB texture.

Definition at line 731 of file smaa.cc.

References blender::math::abs(), blender::math::dot(), blender::gpu::shader::metadata::float2, blender::gpu::shader::metadata::float3, blender::gpu::shader::metadata::float4, L, blender::math::max(), SMAA_PREDICATION, SMAALumaEdgeDetectionPS(), SMAASamplePoint, SMAATexture2D, SMAATexturePass2D, blender::math::step(), and T.

Referenced by detect_edges_cpu(), and SMAALumaEdgeDetectionPS().

◆ SMAAMovc() [1/2]

void blender::compositor::SMAAMovc ( float2 cond,
float2 & variable,
float2 value )
static

◆ SMAAMovc() [2/2]

void blender::compositor::SMAAMovc ( float4 cond,
float4 & variable,
float4 value )
static

◆ SMAANeighborhoodBlendingPS()

◆ SMAANeighborhoodBlendingVS()

void blender::compositor::SMAANeighborhoodBlendingVS ( float2 texcoord,
int2 size,
float4 & offset )
static

◆ SMAASearchDiag1()

float2 blender::compositor::SMAASearchDiag1 ( SMAATexture2D(edgesTex) ,
float2 texcoord,
float2 dir,
int2 size,
float2 & e )
static

◆ SMAASearchDiag2()

◆ SMAASearchLength()

float blender::compositor::SMAASearchLength ( SMAATexture2D(searchTex) ,
float2 e,
float offset )
static

This allows to determine how much length should we add in the last step of the searches. It takes the bilinearly interpolated edge (see @PSEUDO_GATHER4), and adds 0, 1 or 2, depending on which edges and crossing edges are active.

Definition at line 1019 of file smaa.cc.

References blender::e, blender::gpu::shader::metadata::float2, mad, scale(), SMAA_SEARCHTEX_PACKED_SIZE, SMAA_SEARCHTEX_SELECT, SMAA_SEARCHTEX_SIZE, SMAASampleLevelZero, SMAASearchLength(), and SMAATexture2D.

Referenced by SMAASearchLength(), SMAASearchXLeft(), SMAASearchXRight(), SMAASearchYDown(), and SMAASearchYUp().

◆ SMAASearchXLeft()

float blender::compositor::SMAASearchXLeft ( SMAATexture2D(edgesTex) ,
SMAATexture2D(searchTex) ,
float2 texcoord,
float end,
int2 size )
static

Horizontal/vertical search functions for the 2nd pass.

@PSEUDO_GATHER4 This texcoord has been offset by (-0.25, -0.125) in the vertex shader to sample between edge, thus fetching four edges in a row. Sampling with different offsets in each direction allows to disambiguate which edges are active from the four fetched ones.

Definition at line 1042 of file smaa.cc.

References blender::e, blender::gpu::shader::metadata::float2, blender::gpu::shader::metadata::int2, mad, SMAASampleLevelZero, SMAASearchLength(), SMAASearchXLeft(), SMAATexture2D, and SMAATexturePass2D.

Referenced by SMAABlendingWeightCalculationPS(), and SMAASearchXLeft().

◆ SMAASearchXRight()

float blender::compositor::SMAASearchXRight ( SMAATexture2D(edgesTex) ,
SMAATexture2D(searchTex) ,
float2 texcoord,
float end,
int2 size )
static

◆ SMAASearchYDown()

float blender::compositor::SMAASearchYDown ( SMAATexture2D(edgesTex) ,
SMAATexture2D(searchTex) ,
float2 texcoord,
float end,
int2 size )
static

◆ SMAASearchYUp()

float blender::compositor::SMAASearchYUp ( SMAATexture2D(edgesTex) ,
SMAATexture2D(searchTex) ,
float2 texcoord,
float end,
int2 size )
static

◆ socket_data_type_to_result_type()

◆ spectral_bokeh()

float4 blender::compositor::spectral_bokeh ( const int2 texel,
const int2 size,
const float exterior_angle,
const float rotation,
const float roundness,
const float catadioptric,
const float lens_shift )
static

◆ sum_causal_and_non_causal_results() [1/2]

void blender::compositor::sum_causal_and_non_causal_results ( Context & context,
const Result & causal_input,
const Result & non_causal_input,
Result & output )
static

◆ sum_causal_and_non_causal_results() [2/2]

void blender::compositor::sum_causal_and_non_causal_results ( Context & context,
const Result & first_causal_input,
const Result & first_non_causal_input,
const Result & second_causal_input,
const Result & second_non_causal_input,
Result & output )
static

◆ sum_causal_and_non_causal_results_cpu() [1/2]

◆ sum_causal_and_non_causal_results_cpu() [2/2]

void blender::compositor::sum_causal_and_non_causal_results_cpu ( const Result & first_causal_input,
const Result & first_non_causal_input,
const Result & second_causal_input,
const Result & second_non_causal_input,
Result & output )
static

◆ sum_causal_and_non_causal_results_gpu() [1/2]

◆ sum_causal_and_non_causal_results_gpu() [2/2]

void blender::compositor::sum_causal_and_non_causal_results_gpu ( Context & context,
const Result & first_causal_input,
const Result & first_non_causal_input,
const Result & second_causal_input,
const Result & second_non_causal_input,
Result & output )
static

◆ sum_color()

◆ sum_color_cpu()

◆ sum_color_gpu()

◆ sum_log_luminance()

float blender::compositor::sum_log_luminance ( Context & context,
const Result & input,
const float3 & luminance_coefficients )

◆ sum_log_luminance_cpu()

float blender::compositor::sum_log_luminance_cpu ( const Result & input,
const float3 & luminance_coefficients )
static

◆ sum_log_luminance_gpu()

◆ sum_squared_difference_color()

◆ sum_squared_difference_color_cpu()

◆ sum_squared_difference_color_gpu()

◆ summed_area_table()

◆ summed_area_table_cpu()

◆ summed_area_table_gpu()

◆ summed_area_table_sum()

◆ symmetric_separable_blur()

◆ symmetric_separable_blur_variable_size()

void blender::compositor::symmetric_separable_blur_variable_size ( Context & context,
const Result & input,
const Result & radius,
Result & output,
const int weights_resolution = 128,
const math::FilterKernel filter_type = math::FilterKernel::Gauss )

◆ to_string() [1/3]

StringRefNull blender::compositor::to_string ( const Extension & extension)

Definition at line 129 of file domain.cc.

References BLI_assert_unreachable, Clip, Extend, N_, Repeat, and to_string().

◆ to_string() [2/3]

StringRefNull blender::compositor::to_string ( const Interpolation & interpolation)

◆ to_string() [3/3]

StringRefNull blender::compositor::to_string ( const ResultPrecision & precision)

Definition at line 1248 of file result.cc.

References BLI_assert_unreachable, Full, Half, N_, and to_string().

◆ van_vliet_gaussian_blur()

◆ vertical_pass() [1/2]

void blender::compositor::vertical_pass ( Context & context,
const Result & original_input,
const Result & horizontal_pass_result,
const Result & radius,
Result & output,
const int weights_resolution,
const math::FilterKernel filter_type )
static

◆ vertical_pass() [2/2]

void blender::compositor::vertical_pass ( Context & context,
const Result & original_input,
const Result & horizontal_pass_result,
Result & output,
const int distance,
const int falloff_type )
static

◆ vertical_pass_cpu() [1/2]

void blender::compositor::vertical_pass_cpu ( Context & context,
const Result & original_input,
const Result & horizontal_pass_result,
const Result & radius,
Result & output,
const int weights_resolution,
const math::FilterKernel filter_type )
static

◆ vertical_pass_cpu() [2/2]

void blender::compositor::vertical_pass_cpu ( Context & context,
const Result & original_input,
const Result & horizontal_pass_result,
Result & output,
const int distance,
const int falloff_type )
static

◆ vertical_pass_gpu() [1/2]

◆ vertical_pass_gpu() [2/2]

◆ zero_pad_cpu()

◆ zero_pad_gpu()

Variable Documentation

◆ a0

double blender::compositor::a0 = 1.6797292232361107
inlinestaticconstexpr

◆ a1

double blender::compositor::a1 = 3.7348298269103580
inlinestaticconstexpr

◆ b0

double blender::compositor::b0 = 1.7831906544515104
inlinestaticconstexpr

◆ b1

◆ c0

double blender::compositor::c0 = -0.6802783501806897
inlinestaticconstexpr

◆ c1

double blender::compositor::c1 = -0.2598300478959625
inlinestaticconstexpr

◆ LOG

◆ w0

double blender::compositor::w0 = 0.6318113174569493
inlinestaticconstexpr

◆ w1

double blender::compositor::w1 = 1.9969276832487770
inlinestaticconstexpr