R = min( width, height )/2
for each pixel x,y
    dx = R-x
    dy = R-y
    r = sqrt( dx*dx + dy*dy )/R
    color(x,y) = some munging of r

Where I wrote ’some munging of r’ we want to do the code specific to each
flare. This is what I used for the images above:

	// (1-r)^2 c = 1-r; c = c*c; if (r>1) c=0;		// r c = r; if (r>1) c=0;
	// r^6 c = r*r; c = c*c; c = c*c*c; if (r>1) c=0;		// ring of width .2 and radius R c = 1-fabs(r-.9f)/.1f; if (c < 0) c = 0; c = c*c; c = c*c;

For all of these, the color value (c) we produce is between 0 and 1.
Assuming you're making a 32-bit texture, the value to put in the
color buffer is:

byte b = c*255
dword clr = b | (b<<8) | (b<<16)

Handling Rough Edges

If you code that straight out, you're going to get very rough edges around the flare. This comes from the if (r>1) c=0; statement. What we want instead is a function that smoothly blends the color out. We'll make a function like Renderman's smoothstep to do this. The equation it uses is: 3x^2 - 2x^3, giving a nice transition between 0 and 1. Here it is in code: function smoothstep(a, b, x) if x < a then return 0 if x >= b then return 1 x = (x-a) / (b-a) return (x*x) * (3-2*x) To use it, just replace the if-statement with c *= 1-smoothstep(1-.01, 1+.01, r);

Well, that does it for the easy textures now onto the interesting part.

A Bit More Challenging

For the last texture, what we want is a bunch of light rays emanating
from the center of the image. To do this, you could take an atan2 at
every pixel and use the result as an index into a 1-d array of color values, then mess
with the resulting image until it stopped looking like crap, or you could
save yourself some time and just shoot additive particles from the center
pixel. I've chosen the latter approach and here's how it's done:

create temporary buffer to accumulate pixel values
initialize buffer values to 0

for each particle
    (pick a random direction)
    angle = (rand() / RAND_MAX) * 2*pi
    dx = cos(angle)
    dy = sin(angle)

    (push particle along this path)
    fx = width / 2
    fy = height / 2
    for each step
        DrawParticle(buffer, fx, fy)
        fx += dx
        fy += dy

normalize values of buffer and move to texture

For the DrawParticle function you can do a variety of things to
achieve different looks. For example you can have the particle's
brightness die off as it gets farther from the center, you can
have the borders of the particle decrease instead of increase values
in the temporary buffer, or you can use different shapes for the
particle and rotate them as it extends from the center. Here's
the simplest version:

function DrawParticle(buffer, fx, fy)
    for y = -partRadius to partRadius
        for x = -partRadius to partRadius
            r2 = x*x + y*y
            c = 1 - r2/(partRadius*partRadius)
            c = c*c
            c = c*c
            buffer(x+fx,y+fy) += c

Putting It All Together

Now that you have good lens flare textures, the real fun
begins: finding the right order, colors, and sizes for arranging them.
I'll leave that to you, but for the interested here's my preferred layout

refer to:www.blackpawn.com/texts/lensflare/default.html

随机日志

• 2010年05月17日 -- Hun Gotspot v1.6.0 jvm Gc
• 2010年10月26日 -- 皇室米兰拍婚纱
• 2009年10月15日 -- How to SEO Your Wordpress Blog
• 2010年01月26日 -- 纪念sun被收购的日子
• 2011年01月12日 -- WP-Polls插件有Bug
• 2010年05月12日 -- jQuery Alert Dlalogs(Alert,Confirm,&prompt Replacements)
• 2010年02月27日 -- 兽兽门完整版下载地址
• 2010年01月1日 -- 卡巴斯基(kav)7.0最新KEY授权文件[2010/01/01更新]
• 2010年04月28日 -- Java新手入门很重要的几个基本概念
• 2009年10月26日 -- 北京电视台重点报道的英语学习网站