Been fiddling around with multiplying and al_set_blender and getting lights to work finally got 1 central light to follow the player around on screen with a black semitransparent tint following the camera.. this is almost the desired output, but woth this code each time a new light point is pushed back into a vector containing light positions it interferes with other points within proximity and overlaps its back night mask with the region thats supposed to be illuminatied.

Was wondering a good architecture for lighting, was thinking of having a black mask follow the camera and whenever a light position is within camera range it affects that bitmap, is this a good method for a sidescrolling game is there a better method?

Also how do you get the lights to not overlap in a negative way appreciate everything

Probably you only need one "black mask", and a light spot per sprite. So why not keep the sprite and it's light spot together?
Could you post some code or put it up on something like github so we can see what you have programmed?

I actually read the last thread a while back but missed replying, sorry about that.

A lot of people make the mistake of thinking of this as a "light mask" when in actuality it's better to think of it as a shadow mask. AllegroFlare has a very easy to understand and use ShadowMask class. Here are the files:

shadow_mask.h.
shadow_mask.cpp.

Also if you're interested:

• Here's the PR in AllegroFlare where `ShadowMask` was added.

• Here's the allegro.cc thread with the question that sparked the creation of the class.

• And here's an example program.

Note that for the example program, you'll need to compile AllegroFlare, but the ShadowMask class is stand-alone.

Oates, could you explain some of this? I don't understand allegro's blenders very well. I've read the manual and I still don't get it.

I don't understand what your line with the blender here does :

al_set_blender(ALLEGRO_ADD, ALLEGRO_DST_COLOR, ALLEGRO_ZERO);

How does that let you draw the shadow mask?

And how do you combine lights with this?

al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_ONE);

EDIT

I tried to do my own lights and I'm having problems :

My code [ https://pastebin.com/c2srVteB ] and the results [ https://imgur.com/a/NRPQ1 ]

EDIT2

{"name":"611131","src":"\/\/djungxnpq2nug.cloudfront.net\/image\/cache\/0\/0\/00e9941907378dcb44cbd19d86049cf7.png","w":802,"h":633,"tn":"\/\/djungxnpq2nug.cloudfront.net\/image\/cache\/0\/0\/00e9941907378dcb44cbd19d86049cf7"}

That doesn't look like add... that looks like replace... maybe it's the alpha and not the luminescence of the light messing with it?

[edit] Wait, and the circle doesn't make sense. If it's a square bitmap/texture, how is it drawing a circle / drawing stuff under it? Check the alpha for sure...

The light effects and merging of lights works 100% visually now thanks to all your help only problem is it cuts fps by 1000%
Anyone have ideas to remedy this

How many draws are we talking about per frame? (Lightmap) lighting effects are almost free on any GPU made after the 90's and maybe even before. So there's most likely something else going on.

Do you know how to use a profiler?

Dont know how to use profilers in the context you describe and theres only 1 draw of the lightmap per frame, surface its drawn to is 1280x720 and theres 3 light points currently. Perhaps its somehow running on cpu rather than gpu?

Also noticed it runs near 100% speed when laptop is plugged in and 10% speed when not plugged in

Okay, I discussed this on IRC with Mr-Hide and we have working lighting now.

https://imgur.com/a/AAXVT

Here's the code :

https://pastebin.com/PB1qWz56

I finally understand the blending better. I was wasting my time with a pure black bitmap with varying alpha and an alpha blender when it is as simple as drawing in plain color and using a multiply blender. The color value becomes the light value.

In regards to your slowdown, don't profile yet, sit down and think about what you're doing. Look at your code and examine what it is doing. Post code so we can help.

//light.cpp
include "light.h"

light::light()
{
torch = al_load_bitmap("images/torchlight.png");
draw = false;
}

void light::UpdateXYLight()
{
x1 = positionX;
x2 = positionX + 450;
y1 = positionY;
y2 = positionY + 450;
}

//////blend.cpp
#include "blend.h"

void blend::update_surface(std::vector<light*> &lightVector, std::vector<light*>::const_iterator &iter44, std::vector<player*> &playerVector, float cameraPosition[2])
{
ALLEGRO_STATE previous_state;
al_store_state(&previous_state, ALLEGRO_STATE_TARGET_BITMAP | ALLEGRO_STATE_BLENDER);
al_set_target_bitmap(surface);
al_clear_to_color(al_map_rgb(0, 0, 0));
al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_ONE);

int counter_ = 0;
for (iter44 = lightVector.begin(); iter44 != lightVector.end(); iter44++)
{
int tempposx = lightVector[counter_]->positionX - cameraPosition[0];
int tempposy = lightVector[counter_]->positionY - cameraPosition[1];
if (lightVector[counter_]->draw)
al_draw_bitmap(lightVector[counter_]->torch, tempposx, tempposy, NULL);
counter_++;
}

al_draw_bitmap(playerVector[0]->torch, playerVector[0]->positionX - cameraPosition[0] - 180, playerVector[0]->positionY - cameraPosition[1] - 200, NULL);

al_restore_state(&previous_state);
}

void blend::draw(std::vector<light*> &lightVector, std::vector<light*>::const_iterator &iter44, std::vector<player*> &playerVector, float cameraPosition[2])
{
update_surface(lightVector, iter44, playerVector, cameraPosition);

ALLEGRO_STATE previous_state;
al_store_state(&previous_state, ALLEGRO_STATE_BLENDER);
al_set_blender(ALLEGRO_ADD, ALLEGRO_DST_COLOR, ALLEGRO_ZERO);///

al_draw_bitmap(surface, cameraPosition[0], cameraPosition[1], 0);

al_restore_state(&previous_state);
}

void blend::UpdateLight(std::vector<player*> &playerVector, float cameraPosition[2])
{
//points[0].x = playerVector[0]->positionX - 300;
//points[0].y = playerVector[0]->positionY - 850;
//points[#include "blend.h"

void blend::update_surface(std::vector<light*> &lightVector, std::vector<light*>::const_iterator &iter44, std::vector<player*> &playerVector, float cameraPosition[2])
{
ALLEGRO_STATE previous_state;
al_store_state(&previous_state, ALLEGRO_STATE_TARGET_BITMAP | ALLEGRO_STATE_BLENDER);
al_set_target_bitmap(surface);
al_clear_to_color(al_map_rgb(0, 0, 0));
al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_ONE);

int counter_ = 0;
for (iter44 = lightVector.begin(); iter44 != lightVector.end(); iter44++)
{
int tempposx = lightVector[counter_]->positionX - cameraPosition[0];
int tempposy = lightVector[counter_]->positionY - cameraPosition[1];
if (lightVector[counter_]->draw)
al_draw_bitmap(lightVector[counter_]->torch, tempposx, tempposy, NULL);
counter_++;
}

al_draw_bitmap(playerVector[0]->torch, playerVector[0]->positionX - cameraPosition[0] - 180, playerVector[0]->positionY - cameraPosition[1] - 200, NULL);

al_restore_state(&previous_state);
}

void blend::draw(std::vector<light*> &lightVector, std::vector<light*>::const_iterator &iter44, std::vector<player*> &playerVector, float cameraPosition[2])
{
update_surface(lightVector, iter44, playerVector, cameraPosition);

ALLEGRO_STATE previous_state;
al_store_state(&previous_state, ALLEGRO_STATE_BLENDER);
al_set_blender(ALLEGRO_ADD, ALLEGRO_DST_COLOR, ALLEGRO_ZERO);///

al_draw_bitmap(surface, cameraPosition[0], cameraPosition[1], 0);

al_restore_state(&previous_state);
}

void blend::UpdateLight(std::vector<player*> &playerVector, float cameraPosition[2])
{
//
}

void blend::UpdateXYScreen()
{
x1 = positionX;
x2 = positionX + 1280;
y1 = positionY;
y2 = positionY + 720;
}

void blend::UpdateXYScreen()
{
x1 = positionX;
x2 = positionX + 1280;
y1 = positionY;
y2 = positionY + 720;
}

added code tag

That sounds like your power settings are set to keep the GPU usage to a minimum. What are your hardware specs? Are other 3D programs affected?

Run a profile. See what's taking all of the time. It could be a clue, like you have a memory bitmap by accident.

That code wouldn't even compile. You have nested function definitions. Post code that compiles with <code>code goes here...</code> tags.