2D Dynamic Lighting in Java

Question

I am making a game that has campfire objects. What I want to do is to brighten all pixels in a circle around each campfire. However, looping through every pixel and changing those within the radius is not all that efficient and makes the game run at ~7 fps. Ideas on how to either make this process efficient or simulate light differently?

I haven't written the code for the fires but this is the basic loop to check each pixel/change its brightness based on a number:

public static BufferedImage updateLightLevels(BufferedImage img, float light)
{
    BufferedImage brightnessBuffer = new BufferedImage(img.getWidth(), img.getHeight(), BufferedImage.TYPE_4BYTE_ABGR);

    brightnessBuffer.getGraphics().drawImage(img, 0, 0, null);

    for(int i = 0; i < brightnessBuffer.getWidth(); i++)
    {
        for(int a = 0; a < brightnessBuffer.getHeight(); a++)
        {
            //get the color at the pixel
            int rgb = brightnessBuffer.getRGB(i, a);

            //check to see if it is transparent
            int alpha = (rgb >> 24) & 0x000000FF;

            if(alpha != 0)
            {
                //make a new color
                Color rgbColor = new Color(rgb);

                //turn it into an hsb color
                float[] hsbCol = Color.RGBtoHSB(rgbColor.getRed(), rgbColor.getGreen(), rgbColor.getBlue(), null);

                //lower it by the certain amount
                //if the pixel is already darker then push it all the way to black
                if(hsbCol[2] <= light)
                    hsbCol[2] -= (hsbCol[2]) - .01f;
                else
                    hsbCol[2] -= light;

                //turn the hsb color into a rgb color
                int rgbNew = Color.HSBtoRGB(hsbCol[0], hsbCol[1], hsbCol[2]);

                //set the pixel to the new color
                brightnessBuffer.setRGB(i, a, rgbNew);
            }


        }
    }

    return brightnessBuffer;
}

I apologize if my code is not clean, I'm self taught.

Answer 1

I can give you lots of approaches.

You're currently rendering on the CPU, and you're checking every single pixel. That's hardcore brute force, and brute force isn't what the CPU is best at. It works, but as you've seen, the performance is abysmal.

I'd point you in two directions that would massively improve your performance:

Method 1 - Culling. Does every single pixel really need to have its lighting calculated? If you could instead calculate a general "ambient light", then you could paint most of the pixels in that ambient light, and then only calculate the really proper lighting for pixels closest to lights; so lights throw a "spot" effect which fades into the ambient. That way you're only ever performing checks on a few of the pixels of the screen at a time (the circle area around each light). The code you posted just looks like it paints every pixel, I'm not seeing where the "circle" dropoff is even applied.

Edit:

Instead, sweep through the lights, and just loop through local offsets of the light position.

for(Light l : Lights){

for(int x = l.getX() -LIGHT_DISTANCE, x< l.getX() + LIGHT_DISTANCE, y++){

for(int y = l.getY() - LIGHT_DISTANCE, y < l.getY() + LIGHT_DISTANCE, y++){

//calculate light
int rgb = brightnessBuffer.getRGB(x, y);
//do stuff
}

}

You may want to add a check with that method so overlapping lights don't cause a bunch of rechecks, unless you DO want that behavior (ideally those pixels would be twice as bright)

Method 2 - Offhand calculation to the GPU. There's a reason we have graphics cards; they're specifically built to be able to number crunch those situations where you really need brute force. If you can offload this process to the GPU as a shader, then it'll run licketysplit, even if you run it on every pixel several times over. This will require you to learn graphics APIs however, but if you're working in java, LibGDX makes it very painless to render using the GPU and pass off a couple shaders to the GPU.