LensFlareKernel

The LensFlareKernel generates a lens flare whose properties - including size, spread, position, orientation and brightness - can be controlled by the user. It does not require any inputs.

This kernel demonstrates that user-defined functions can be called from within a kernel’s standard functions, such as init() and process(), just as they could in C++.

// Copyright (c) 2012 The Foundry Visionmongers Ltd.  All Rights Reserved.
// Example RIP Kernel

#define kRandMax 32767

/// Platform-consistent PRNG based on SGI rand().
inline int RandI(unsigned int seed) {
  unsigned int next = seed;
  int result;

  next *= 1103515245;
  next += 12345;
  result = (unsigned int) (next / 65536) % 256;

  next *= 1103515245;
  next += 12345;
  result <<= 7;
  result ^= (unsigned int) (next / 65536) % 256;
  return result;
}

inline float RandF(unsigned int seed)
{
  return float(RandI(seed))/float(kRandMax);
}

/// LensFlareKernel: Generates a lens flare on top of the input image.
/// NOTE that this process does not currently vectorize.
kernel LensFlareKernel : ImageComputationKernel<ePixelWise>
{
  Image<eWrite, eAccessPoint> dst;

param:
  float2 flareHandle;
  float2 centre;
  float  size;
  float  spread;
  float  brightness;
  int    nDots;
  int    seed;

local:
  static const int kMaxDots = 10;
  float4 colours[kMaxDots];
  float2 dotCentres[kMaxDots];
  float  invSizeSqr[kMaxDots];
  int actualDots;

  void define() {
    defineParam(centre,      "Centre", float2(400.0f, 400.0f));
    defineParam(flareHandle, "FlareHandle",  float2(800.0f, 800.0f));
    defineParam(size,        "Size",         150.0f);
    defineParam(brightness,  "Brightness",   1.0f);
    defineParam(spread,      "Spread",   0.3f);
    defineParam(nDots,       "NDots",   5);
    defineParam(seed,        "Seed",   0);
  }

  void init() {
    actualDots = nDots > kMaxDots ? kMaxDots : nDots;
    actualDots = actualDots < 0 ? 0 : actualDots;
    float2 dist = centre - flareHandle;
    for(int i = 0; i < actualDots; ++i) {
      float t = float(i) / float(kMaxDots-1);
      dotCentres[i] = flareHandle + dist * spread * RandF(seed + i);
      float thisSize =  RandF(seed + i + 1000) * size;
      invSizeSqr[i] = 1.0f/(thisSize * thisSize);
      colours[i] = float4(RandF(seed + i + 2000),
                          RandF(seed + i + 3000),
                          RandF(seed + i + 4000),
                          RandF(seed + i + 5000));
    }
  }

  float4 flareValue(float2 posf,
                   int index)
  {
    float2 delta = posf - dotCentres[index];
    float dotDelta = dot(delta, delta) * invSizeSqr[index];
    float value = clamp(1.0f - dotDelta, 0.0f, 1.0f);
    value *= value;
    return colours[index] * value;
  }

  void process(int2 pos) {
    float2 posf(pos.x, pos.y);

    SampleType(dst) sample(0.0f);

    float4 value = 0;
    for(int i = 0; i < actualDots; ++i) {
      value += flareValue(posf, i);
    }

    sample.x += value.x * brightness;
    sample.y += value.y * brightness;
    sample.z += value.z * brightness;

    dst() = sample;
  }

};

Footnotes

[1]	Note that kernels which call user-defined functions from within kernel() currently cannot be vectorized on the CPU.