Why don't you just try it and see what happens. :/

I gave you sample code in your other thread.

The choice of color is important, but you also probably want to apply a gradient or radial gradient, not just a blanket tint.

Thank you relpatseht and André Silva,
https://www.allegro.cc/forums/thread/606569 I got a thread on gradients- I will try that for sure.
How are you applying it to every object?
Well as you guessed, all object's are drawn using the same tint. Someone said that even though we use different versions of al_draw-... all are basically calling the same function al_draw_tinted_scaled_rotated_bitmap - hence I won't be having any additional overheads. So my RenderingEngine class have overloaded functions that use the cameraTint if no other tint is explicitly specified. Interpolation is, however, a new word for me Let me dig deep into the mechanisms you briefed - I will try to implement it as well as I can.
Thank you for your expert opinions.
All of my work till today is here at- https://github.com/ThinkalVB/NearEarth
Feel free to make suggestions or changes.

Thank you Edgar Reynaldo,
Lighting.zip was superb.
So when to use additive and multiplicative blending?

If I am understanding it right - What I got as the basic logic is - Make a bitmap, color it full black. Then draw the lights in it (call it a lightMap). Then draw the lightmap above the background.
And while drawing the lightMap you can use additive or multiplicative blending - so the mixing of colors works fine.
I am right - or am I getting it wrong?

In my project

step 1) clear display backBuffer with black
step 2) clear the lightMap with daylight or cameraTint
step 3) draw the background texture

step 4) draw lights to lightmap
step 4) draw objects to the display back buffer

step 5) When rendering of objects complete
step 6) Draw the lightmap in the display buffer
[This means I no more need to apply the camera tint to every object drawn on the display buffer]
Some results attached - when I used additive and multiplicative blending while drawing the lightMap to the back buffer for RenderingEngine::setCameraTint(al_map_rgba(50,50,50,250)); - It's night

Edit How to fade the light - controlling the luminosity ?

Thank you Edgar Reynaldo,
I think i should stick to additive blending in the lightMap (for all the lights in the scene).
One more question - how to decrease the intensity with the distance - (at the origin - intensity 100% and as we move away it should decrease to 0). One way I figured out is to use a for loop while drawing filled circles. However, it's not working as I intended.

al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_ONE);
al_set_target_bitmap(lightMap);
      
for (int radii = 100; radii != 0; radii--)
{
al_draw_filled_circle(600, 500, radii, al_map_rgba(255, 0, 0, 1));
}
switchToDisplayBuffer();

But I think drawing 255 primitives for every light 60 frames per second is very unethical or compute intensive for some reason. Is there a better way to get it done? (faster and clean)??????
Also, I came to know that allegro primitives don't follow the usual transformation. So how to make them follow it?.

Ah thank you Edgar Reynaldo,

I forgot that one. I corrected the code the result is pretty promising. But don't have any idea why a special region is more illuminated than it's center. Any thoughts?

But I have one simple honest doubt - If it uses pre-multiplied alpha - why we even have to pass the alpha value to the function. Because both seem to produce the same result?

It would be great if you could comment on the transformations in the allegro primitives and any easy or clean way to draw the lights - more efficiently?

One more thing if I have RGB values as 255,144,245 then how can I convert it to float values - to do the pre-multiplied alpha thing?

Thank you Edgar Reynaldo,

My player character is at 1500,1500 but I am drawing the light at 500,600 and both use the same transformation. So essentially the light shouldn't show up on the screen. But you see the result - the light is showing up at the display co-ordinate 500,600. That's the problem.

Thank you Edgar Reynaldo,
This is more controllable and better I think.

float alpha = 1.0f;
float gradient = 30.0f;
float radius = 100.0f;

float dGradient = radius / gradient;
float dAlpha = alpha / gradient;

for (auto radii = 1.0f; radii <= radius; radii += dGradient)
{
al_draw_circle(500, 600, radii, al_map_rgb_f(1.0f*alpha, 0.0f*alpha, 0.0f*alpha), dGradient);
alpha -= dAlpha;
}

Full source code is in Git and is up-todate till this minute. [issue: lightMap is not using the transformation]
https://github.com/ThinkalVB/NearEarth

Thank you Edgar Reynaldo,
I didn't quite get it.
There are two transforms per bitmap target. If you change the target bitmap, the transforms are reset to the stored version.
stored version?

Did you mean there are two transformations related to a bitmap? [like an active and default tranforms] Once you switch to another target bitmap the default transformation's come into effect and once you switch back, the old transformation will be restored????

Isn't there a way to use the same transformation for both the lightMap bitmap and the display's back buffer?:P:-/

Thank you Edgar Reynaldo,
I was very much confused and worried - I thought transforms won't work with primitives.
One more thing
I have a bright sun in the scene -

  RenderingEngine::setCameraTint(al_map_rgb(250, 250, 250));

Then I tried to draw a light in the scene - same as the one above. However when using additive blending - it's the same color everywhere (no change - as it is supposed to be). Then I tried multiplicative blending but it was an absolute horror.
So possibly which blending mode should I use in such a bright background light scenario????:)

Thank you Edgar Reynaldo,
I am sorry - I totally forgot to sync it to Git. It's done now.
I was doing quite the opposite - For lightmap using additive blending and when drawing the light map over the back buffer I was using multiplicative blending.
If I use the blending vice verse - the background seems to be fully white.::)