Pixeltools Hueshift Dctl Pluginzip -

A simplified version of what the DCTL does internally:

__DEVICE__ float3 transform(int p_Width, int p_Height, int p_X, int p_Y, float p_R, float p_G, float p_B)
float3 rgb = make_float3(p_R, p_G, p_B);
    float3 hsv = rgb_to_hsv(rgb);
    hsv.x = fmod(hsv.x + hue_shift_angle / 360.0f, 1.0f); // Shift hue
    return hsv_to_rgb(hsv);

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));
)

Due to the rise of "DCTL scam sites," only trust these sources:

| Source | Price | Trust Level | |--------|-------|-------------| | PixelTools Official Gumroad | $15-25 (as of 2026) | ⭐⭐⭐⭐⭐ | | LiftGammaGain Store | Often bundled | ⭐⭐⭐⭐ | | John’s DCTL Bundle (via Patreon) | Subscription | ⭐⭐⭐ (check recent reviews) | pixeltools hueshift dctl pluginzip

Avoid:

If budget is a concern, PixelTools frequently offers a "name your price" option for students and indie colorists.

When you download the legitimate PixelTools HueShift DCTL, the zip archive typically contains: A simplified version of what the DCTL does

pixeltools_hueshift_dctl_plugin.zip
├── PixelTools_HueShift.dctl
├── PixelTools_HueShift_Advanced.dctl
├── License.txt
├── User_Guide.pdf
└── Example_Still.dpx

Security note: Always verify that the pixeltools hueshift dctl plugin.zip you download comes from the official PixelTools Gumroad page or their authorized distribution channels. Malicious actors sometimes package malware inside fake DCTL zips.

Unzip the pixeltools_hueshift_plugin.zip (or similar name). Inside, you should find:

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. Filename: PixelTools_HueShift

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.