Pixeltools Hueshift Dctl Pluginzip -

PixelTools HueShift DCTL is a compact, well-designed color-shifting tool for DaVinci Resolve that gives editors fast, controllable hue and saturation manipulation without needing large node trees or external plugins.

Result: Distinct color separation between skin and environment without the "dirty midtones" common in LUT-based looks.

Filename: PixelTools_HueShift.dctl

// PixelTools_HueShift.dctl
// A simple tool to shift hues globally or by range.
DEFINE_KERNEL :
(
    input_image,
    float global_shift,
    float red_range,
    float orange_range,
    float yellow_range,
    float green_range,
    float cyan_range,
    float blue_range,
    float magenta_range
)
// Helper: Convert RGB to Hue (0.0 to 1.0)
DEFINE_FUNC(float, get_hue, (float r, float g, float b))
(
    float max_c = max(max(r, g), b);
    float min_c = min(min(r, g), b);
    float delta = max_c - min_c;
float h = 0.0f;
if (delta > 0.00001f) 
        if (max_c == r) 
            h = (g - b) / delta;
            if (h < 0.0f) h += 6.0f;
         else if (max_c == g) 
            h = 2.0f + (b - r) / delta;
         else 
            h = 4.0f + (r - g) / delta;
h /= 6.0f;
return h;
)
// Helper: Convert Hue (0.0-1.0), Saturation, Value back to RGB
DEFINE_FUNC(float3, hsv_to_rgb, (float h, float s, float v))
(
    float r = 0.0f, g = 0.0f, b = 0.0f;
if (s <= 0.0f) 
        return (float3)(v, v, v);
h = h * 360.0f;
    int i = (int)floor(h / 60.0f);
    float f = (h / 60.0f) - i;
    float p = v * (1.0f - s);
    float q = v * (1.0f - f * s);
    float t = v * (1.0f - (1.0f - f) * s);
i = i % 6;
if (i == 0)  r = v; g = t; b = p; 
    else if (i == 1)  r = q; g = v; b = p; 
    else if (i == 2)  r = p; g = v; b = t; 
    else if (i == 3)  r = p; g = q; b = v; 
    else if (i == 4)  r = t; g = p; b = v; 
    else if (i == 5)  r = v; g = p; b = q;
return (float3)(r, g, b);
)
// Helper: Soft circular distance
DEFINE_FUNC(float, hue_dist, (float h1, float h2))
(
    float d = fabs(h1 - h2);
    if (d > 0.5f) d = 1.0f - d;
    return d;
)
(
    float4 in = READ_IMAGE(input_image);
    float r = in.x;
    float g = in.y;
    float b = in.z;
    float a = in.w;
// Calculate HSV
    float h = get_hue(r, g, b);
float max_c = max(max(r, g), b);
    float min_c = min(min(r, g), b);
    float delta = max_c - min_c;
float s = (max_c < 0.00001f) ? 0.0f : delta / max_c;
    float v = max_c;
// Apply Global Shift
    h += global_shift;
// Define center points for secondary shifts (Normalized 0.0 - 1.0)
    // R=0/1, O=1/12, Y=1/6, G=1/3, C=1/2, B=2/3, M=5/6
// Function to apply specific hue shifts if pixel is near target hue
    // Note: This is a cumulative simplified implementation. 
    // For precise secondary controls, a masking approach is better.
// We will apply the shifts based on distance to the primary hue centers.
    // We use a very simple mask: if distance < 0.1 (approx 36 degrees), apply shift.
    // Ideally, this should use smoothstep for smooth transitions.
float shift = 0.0f;
    float tolerance = 0.0833f; // Approx 30 degrees
// Red (Center 0.0 / 1.0)
    float d_r = hue_dist(h, 0.0f);
    if (d_r < tolerance) shift += red_range * (1.0f - d_r/tolerance);
// Orange (Center 1/12 = 0.0833)
    float d_o = hue_dist(h, 0.0833f);
    if (d_o < tolerance) shift += orange_range * (1.0f - d_o/tolerance);
// Yellow (Center 1/6 = 0.1666)
    float d_y = hue_dist(h, 0.1666f);
    if (d_y < tolerance) shift += yellow_range * (1.0f - d_y/tolerance);
// Green (Center 1/3 = 0.3333)
    float d_g = hue_dist(h, 0.3333f);
    if (d_g < tolerance) shift += green_range * (1.0f - d_g/tolerance);
// Cyan (Center 1/2 = 0.5)
    float d_c = hue_dist(h, 0.5f);
    if (d_c < tolerance) shift += cyan_range * (1.0f - d_c/tolerance);
// Blue (Center 2/3 = 0.6666)
    float d_b = hue_dist(h, 0.6666f);
    if (d_b < tolerance) shift += blue_range * (1.0f - d_b/tolerance);
// Magenta (Center 5/6 = 0.8333)
    float d_m = hue_dist(h, 0.8333f);
    if (d_m < tolerance) shift += magenta_range * (1.0f - d_m/tolerance);
// Apply calculated shift
    h += shift;
// Wrap hue
    h = fmod(h, 1.0f);
    if (h < 0.0f) h += 1.0f;
// Convert back to RGB
    float3 out_rgb = hsv_to_rgb(h, s, v);
WRITE_IMAGE((float4)(out_rgb.x, out_rgb.y, out_rgb.z, a));
)

Now that your pixeltools hueshift dctl pluginzip is live in your node tree, let’s grade. The interface is deceptively simple. It usually features sliders for Hue Rotation, Sat Scale, and Luminance Preserve. pixeltools hueshift dctl pluginzip

In the relentless pursuit of cinematic imagery, colorists often find themselves confined by the limitations of traditional lift/gamma/gain wheels or generic hue vs. hue curves. True artistic control demands precision—the ability to rotate or offset specific color ranges without introducing artifacts or clipping adjacent hues. Enter the PixelTools HueShift DCTL plugin.zip, a file that has quietly become a secret weapon among professional DaVinci Resolve colorists.

But what exactly is inside this zip file? Why is it generating such discussion on forums like LiftGammaGain and Reddit? More importantly, how can it transform your grade from "flat correction" to "painterly depth"?

This article unpacks everything: the technology behind DCTLs, the specific functionality of HueShift, installation steps, creative applications, and why this plugin is superior to Resolve’s native tools. Now that your pixeltools hueshift dctl pluginzip is

Navigate to your Resolve installation directory:

Windows:

C:\ProgramData\Blackmagic Design\DaVinci Resolve\Support\DCTL\

Note: ProgramData is hidden by default. Type it directly into Explorer. the specific functionality of HueShift

macOS:

/Library/Application Support/Blackmagic Design/DaVinci Resolve/DCTL/

Or in your user library:

~/Library/Application Support/Blackmagic Design/DaVinci Resolve/DCTL/

Linux:

/opt/resolve/Support/DCTL/

If a DCTL folder does not exist, create it manually.

Fully quit and relaunch DaVinci Resolve.