Rendering issue with light against transparency #136
Assignees
Triager-bot
Clear assignees
Triager-bot
No Assignees
Notifications
Due Date
No due date set.
Dependencies
No dependencies set.
Reference: Triager-bot/test#136
Reference in New Issue
Block a user
Delete Branch "%!s()"
Deleting a branch is permanent. Although the deleted branch may continue to exist for a short time before it actually gets removed, it CANNOT be undone in most cases. Continue?
Original bug report: https://projects.blender.org/blender/blender/issues/157228
System Information
Operating system: Windows 11
Graphics card: NVIDIA GeForce RTX 4070
Blender Version
Broken: 5.1
Short description of error
lights on transparent objects have incorrect alpha and color in rendered file, shows otherwise in-editor.
Exact steps for others to reproduce the error
light-transparency-bug.blend
to view issue from given blend file: render, see it looks fine, hold mouse over image to see color info is incorrect.
the exported image is what it really looks like.
to recreate on your own:
put a light against an object with a low alpha (~0.2) and render, issue should be present
footage of recreation:
Report is clear
LLM Reasoning
Got it, let's see. The bug report has a clear title, a short description of the error, and steps to reproduce (both with a blend file and instructions). Even though there are system info, we ignore that. The steps are present: using the blend file or recreating by putting light against low alpha object. So the clarity is good. So the answer should be Yes.
JSON Data
{
"llm_judgement": true,
"processing_time": 5.700346
}
Report is specific
LLM Reasoning
Got it, let's figure out if this bug report is specific or generic. The question says specific is about a particular issue, like crashing with a specific feature while rendering. Generic is vague, like just "crashing while rendering."
Looking at the bug report: the title is "Rendering issue with light against transparency." The body describes lights on transparent objects having incorrect alpha and color in rendered files vs editor. Then there are exact steps to reproduce, including a blend file attachment and specific instructions (put a light against an object with low alpha ~0.2). So it's about a specific scenario: light interacting with transparent objects during rendering. That's a specific issue because it's not just "rendering issues" in general, but a particular case of lights on transparent objects. Wait, but let me check the examples. The example for specific is "Crashing while using a specific feature while rendering." Here, the specific feature would be light against transparency. So yes, this is a specific issue because it's about a particular interaction (light and transparent objects) with exact reproduction steps. So the answer should be 'Specific'.
JSON Data
{
"llm_judgement": true,
"processing_time": 12.706646000000001
}
Report flagged as NOT a duplicate by LLM
Bug concerning emission glow, alpha value and transparent background
https://projects.blender.org/blender/blender/issues/150668
The bug that I want to point out happens in this scenario.
When:
The result:
I am using Blender 5.0
Please fix this bug as soon as possible.
LLM Reasoning
Got it, let's analyze these two bug reports. First, look at the descriptions and steps to reproduce.
Bug report 1: Talks about lights on transparent objects having incorrect alpha and color in rendered files (shows fine in-editor). Steps involve putting a light against an object with low alpha (~0.2) and rendering. The issue is that the exported image looks wrong compared to the editor view.
Bug report 2: Mentions emission glow, alpha value, and transparent background. When transparency is enabled, an object with low alpha and emission glow looks pale/miscolored in render (normal in render window but off in photo). Uses Blender 5.0.
Now, check if they're the same issue. Both involve transparent objects (low alpha) where the rendered output has color issues that aren't visible in the editor. Report 1 mentions lights against transparency, report 2 mentions emission glow with transparency. Wait, but maybe the core is about transparent objects rendering incorrectly (color/alpha issues). Let's see: both have "transparent" option enabled, low alpha, and render vs editor discrepancy. But report 1 has a light against the object, report 2 has emission glow. Are these different scenarios or same underlying issue?
Wait, the key parts: Report 1 is about lights on transparent objects (maybe the light's interaction with transparency), Report 2 is about emission glow on transparent objects. But maybe they're related to how Blender handles transparency in rendering. However, the steps and descriptions are slightly different. Let's check if the core issue is the same. The first report's error is "lights on transparent objects have incorrect alpha and color", second is "emission glow... looks very pale and miscolored". Are these two different manifestations of the same bug? Or different bugs?
Wait, the user says to focus on Description and Steps. Let's list:
Report 1:
Report 2:
Are these the same issue? The first involves a light against the transparent object, the second involves emission glow. But maybe both are about how Blender renders transparent objects with certain properties (light or emission) leading to color issues. However, the specific elements (light vs emission glow) might make them different. Wait, but maybe the underlying problem is the same: transparency rendering bug where certain effects (light interaction or emission) cause incorrect colors in the final render. But are they duplicates?
Wait, let's think again. The first report's issue is about lights on transparent objects—maybe the light's contribution through transparency is wrong. The second is about emission glow on transparent objects—emission's contribution through transparency is wrong. Are these two different bugs or same? Since the steps involve different elements (light vs emission), maybe they are not the same. But wait, maybe the core is that any effect (light or emission) on a transparent object with low alpha causes rendering issues. But the descriptions are about different effects. So perhaps they are not duplicates.
Wait, but let's check the titles: "Rendering issue with light against transparency" vs "Bug concerning emission glow, alpha value and transparent background". Different focuses. Steps: Report 1 has a light against the object, Report 2 has emission glow. So maybe they are different issues. Therefore, the answer is No.
JSON Data
{
"llm_judgement": false,
"processing_time": 37.900769,
"duplicate_report_number": "150668"
}
Report flagged as duplicate by LLM
Bug Fix: Emission glow looking pale when the background is transparent and Alpha is lower than 1
https://projects.blender.org/blender/blender/issues/150731
System Information: AMD Ryzen 9 8945HS w/ Radeon 780M Graphics (4.00 GHz)
RAM: 32 GB
Storage: 954 GB
Product ID: 00355-61794-32113-AAOEM
64-bit
Operating system: Windows 11 Pro
Version: 24H2
Graphics card: AMD Radeon Graphics
Blender Version: Blender 5.0.0
The bug that I want to point out happens in this scenario.
When:
In this scenario, the material of the object looks very miscolored and much paler than it is supposed to be. It looks normal in the render preview and render window but when you open up the photo in your device, you see that it looks very off.
To reproduce the error:
Please fix this bug as soon as possible.
LLM Reasoning
Got it, let's analyze the two bug reports. First, look at the descriptions and steps.
Bug report 1: Talks about lights on transparent objects having incorrect alpha/color in rendered file vs editor. Steps involve putting a light against an object with low alpha (~0.2) and rendering.
Bug report 2: Focuses on emission glow looking pale when background is transparent and alpha <1. Steps include enabling transparent, setting alpha ~0.3, adding emission strength, then rendering—glow looks off in the exported image.
Wait, but are they the same? Let's check the core issue. Report 1 mentions lights against transparency (maybe light interacting with transparent objects), report 2 is about emission glow on transparent objects. But maybe the underlying problem is similar: incorrect color/alpha when rendering transparent objects, especially with emissive or light interactions.
Wait, but let's see the steps. Report 1 has a light against a low alpha object. Report 2 has an object with emission (glow) and low alpha, transparent background. Are these related? Maybe both are about incorrect rendering of transparent materials when there's light/emission involved. But do they describe the same issue?
Wait, report 1 says "lights on transparent objects have incorrect alpha and color"—so maybe the light is behind or interacting with the transparent object. Report 2 is about emission glow (the object itself emitting) being pale. Are these two different scenarios? Or are they the same underlying bug where transparent materials render incorrectly in certain cases?
Wait, let's check the key elements: both involve transparent objects (alpha <1), rendering issues where the result looks wrong in exported images vs editor. But report 1 is about lights on transparent objects, report 2 is about emission glow on transparent objects. Are these two different manifestations of the same bug? Or are they distinct?
Wait, maybe the core issue is that when a transparent object (alpha <1) is rendered, there's a problem with color/alpha in the final output. But report 1 mentions lights against transparency, report 2 mentions emission glow. Let's see if the steps align.
Report 1: put light against low alpha object → render → issue. Report 2: set transparent, low alpha, emission → render → issue. Are these two different issues? Or same?
Wait, maybe they are duplicates because both involve transparent objects (alpha <1) leading to incorrect rendering in the exported image vs editor. But let's think again. Report 1 is about lights interacting with transparent objects, report 2 is about emissive materials on transparent objects. Are these two different bugs or the same?
Alternatively, maybe they are the same because both involve transparency and color issues in rendered output. But I need to decide if they are duplicates.
Wait, let's check the titles: Report 1 is "Rendering issue with light against transparency", report 2 is "Bug Fix: Emission glow looking pale when background is transparent and Alpha is lower than 1". The first is about lights on transparent objects, the second about emission glow. Are these two different scenarios? Or are they part of the same bug?
Hmm. Let's see the steps again. Report 1: light against low alpha object. Report 2: object with emission (glow) and low alpha, transparent background. Maybe the underlying problem is that when a transparent object has any kind of light interaction (either external light or self-emission), the rendering is incorrect. So maybe they are duplicates.
But wait, maybe not. Let's think: if report 1 is about lights (external) on transparent objects, and report 2 is about emission (internal) on transparent objects, are those two different issues? Or same?
Alternatively, maybe the user in report 2 is describing a specific case of the same bug as report 1. For example, emission glow is a type of light, so maybe both are about light interaction with transparent objects leading to incorrect rendering.
But I need to decide if they are duplicates. Let's see: both have steps involving low alpha (transparent) objects, rendering issues where the result looks wrong in exported images vs editor. So maybe yes, they are duplicates.
Wait, but let's check the system info. Report 1 has NVIDIA RTX 4070, report 2 has AMD Radeon. But that doesn't matter for duplication—different hardware can have same bug.
Alternatively, maybe not. Let's see: report 1 is about lights (external) on transparent objects, report 2 is about emission (internal) on transparent objects. Are these two different bugs? Or same?
I think they are duplicates because both involve transparent objects (alpha <1) leading to incorrect color/alpha in rendered output, regardless of whether the light is external or internal (emission). So the core issue is the same: rendering of transparent materials with light interactions has a bug.
So the answer would be Yes? Wait, but let me check again. Report 1 says "lights on transparent objects have incorrect alpha and color"—so maybe the light is behind the object, and the transparency is causing issues. Report 2 is about emission glow (the object itself emitting) being pale. Are these two different?
Wait, maybe not. Let's think of an example: if you have a transparent object with low alpha, and a light behind it, the light might pass through but the color is wrong. If the object has emission, the emitted light might be pale. Both could be due to the same bug in how transparency is handled during rendering.
Alternatively, maybe they are different. But given that both involve transparent objects (alpha <1) and rendering issues where the result looks wrong in exported images vs editor, I think they are duplicates. So the answer is Yes? Wait, but let me confirm.
Wait, report 1's steps: put light against low alpha object → render. Report 2's steps: set transparent, low alpha, emission → render. Are these two different scenarios or same?
Maybe the user in report 2 is describing a specific case of the same bug as report 1. So yes, duplicates.
But I'm not 100% sure. Alternatively, maybe they are different. But according to the question, if unsure, respond No. Wait, but let's think again.
Wait, report 1 is about lights (external) on transparent objects. Report 2 is about emission (internal) on transparent objects. Are these two different issues? For example, one is about light passing through transparency, the other about emissive materials with transparency. Maybe they are distinct. So maybe No.
But I need to decide. Let's see: the key elements in both reports:
Are these two different bugs? Or same?
I think they are duplicates because the core problem is the same: incorrect rendering of transparent materials when there's light interaction. So Yes.
But wait, maybe not. Let me check again. Report 1 says "lights on transparent objects have incorrect alpha and color"—so the light is interacting with the transparent object. Report 2 says "emission glow looking pale"—the object itself is emitting. Are these two different?
Alternatively, maybe they are the same because emission is a type of light. So yes, duplicates.
So I'll go with Yes.
JSON Data
{
"llm_judgement": true,
"processing_time": 79.843251,
"duplicate_report_number": "150731"
}
Report flagged as duplicate by LLM
Alpha looks different
https://projects.blender.org/blender/blender/issues/104320
System Information
Operating system: Windows-10-10.0.22000-SP0 64 Bits
Graphics card: NVIDIA GeForce RTX 3070 Ti/PCIe/SSE2 NVIDIA Corporation 4.5.0 NVIDIA 517.40
Blender Version
Broken: version: 3.4.0, branch: blender-v3.4-release, commit date: 2022-12-06 18:46, hash:
a95bf1ac01Worked: (newest version of Blender that worked as expected)
Short description of error
An image with transparency does not look the same as when rendering. It is dimmer and some glare disappears
Exact steps for others to reproduce the error
Here simple scene for demonstate issue. Just sphere with lights and transparent material.
Alpha(Issue).blend
LLM Reasoning
Got it, let's analyze the two bug reports. First, look at the descriptions and steps to reproduce.
Bug report 1 is about lights on transparent objects having incorrect alpha and color in rendered files (vs in-editor). The steps involve putting a light against an object with low alpha (~0.2) and rendering.
Bug report 2 mentions an image with transparency not looking the same when rendering—dimmer, glare disappears. Steps include a sphere with lights and transparent material.
Both are about issues with transparency and lighting in rendered output vs expected (maybe in-editor or previous versions). The core problem seems related to how transparency interacts with lights during rendering. Let's check if they're the same issue.
Bug 1: Light against transparent object, alpha/color wrong in render. Bug 2: Transparency looks different (dimmer, glare gone) when rendering. Both involve rendering issues with transparent materials and lighting. The steps both use scenes with transparent objects and lights. So maybe duplicates? Wait, but let's check details.
Bug 1's short description is "lights on transparent objects have incorrect alpha and color in rendered file". Bug 2's is "An image with transparency does not look the same as when rendering. It is dimmer and some glare disappears". Both are about rendering differences for transparent materials with lights. The steps both involve creating a scene with transparent objects and lights, then rendering. So likely the same issue. But wait, maybe not? Wait, the first one mentions alpha/color incorrect, the second dimmer/glare gone. Are those the same underlying problem? Maybe. Let's see if they're duplicates.
The question is to answer Yes or No. Since both are about transparency and lighting in rendering (different appearance than expected), and steps involve similar setups (transparent objects with lights), I think they are duplicates. So answer Yes? Wait, but maybe not. Wait, let's recheck. Bug 1: light against transparent object, alpha/color wrong. Bug 2: transparency looks different (dimmer, glare). Are these the same issue? Maybe. Let's see. The key is whether the core problem is the same. Both are about rendering issues with transparent materials and lighting. So I think Yes. Wait, but maybe not. Wait, the user says to focus on Description and Steps.
Bug 1 steps: put light against object with low alpha (~0.2), render. Bug 2 steps: sphere with lights and transparent material. Both involve rendering a scene with transparent objects and lights, resulting in unexpected appearance. So yes, same issue. So answer Yes? Wait, but maybe I'm wrong. Let me think again. The first bug is about alpha/color of lights on transparent objects being incorrect. The second is about transparency (the image) looking dimmer, glare disappears. Are these the same? Maybe the underlying problem is the same—how Blender handles transparency and lighting in rendering. So yes, duplicates. So answer Yes.
JSON Data
{
"llm_judgement": true,
"processing_time": 32.894338000000005,
"duplicate_report_number": "104320"
}
Report flagged as NOT a duplicate by LLM
Animations with transparency working in viewport and render tab but not as exported files
https://projects.blender.org/blender/blender/issues/154544
System Information
Operating system: Microsoft Windows 11 Pro
Graphics card: NVIDA GeForce RTX 4080 SUPER
Blender Version
Broken: 5.0
Worked: never
Short description of error
My animation with transparency looks fine in the viewport, and even in the render tab when rendering, but doesn't look correct in my file explorer as image sequences, and looks completely different depending on what video program opens up these images (sometimes disappeared entirely, sometimes the wrong color).
Exact steps for others to reproduce the error
In blender, the render result looks good in the render tab, and while I'm exporting I'm watching each frame look correct, but when I bring the image sequence back into a new VSE, the glowing effects have different outlines on non glowing parts, and when I render this image sequence in the render, I can't see the outlines but the color has disappeared completely. And when I send this animation to a coworker to use as an overlay in a different video software like adobe premiere, the glowing portions of the animation are gone entirely.
Context:
Things I have researched to troubleshoot: I have read about needing to render out a pass of the bloom effects on a black background, and the text without bloom on a transparent background and then combining each sequence of those passes with the bloom being add alpha and the black text being alpha over- this produced a similar result to the original render but with less color and still would not show up in other programs. I have also researched needing to premultiply the alpha which I have tried to render out versions of this animation with various set ups I've found which sometimes used math nodes to multiply the original image with another alpha pass set to premultiply which didn't work either.
In the extensive research I've done trying to troubleshoot this problem including scouring all types of codec settings and different compositing set ups that would make the alphas behave properly as an exported render, I am still not able to produce in my final file what I see in the render tab as the animation is rendering. If this is not an official bug in the program there must to be some kind of accessible way to make sure the alphas are being replicated properly in blender- when I can see them behaving how I need in the viewport and the render tab.
LLM Reasoning
Got it, let's analyze these two bug reports. First, look at the descriptions and steps.
Bug report 1 is about lights on transparent objects having incorrect alpha/color in rendered files (exported) but looking fine in-editor. The steps involve putting a light against a low-alpha object and rendering.
Bug report 2 is about animations with transparency that look good in viewport/render tab but not in exported files (image sequences), with issues like disappearing or wrong colors in other programs. Steps mention exporting image sequences, using VSE, Premiere, etc., and troubleshooting premultiplied alpha.
The core issue: both involve transparency rendering correctly in Blender's interface but incorrectly in exported files. But wait, report 1 is about lights on transparent objects (specific to lighting), report 2 is about animations with transparency (general animation). Wait, no—report 1's issue is that the rendered file (exported) has incorrect alpha/color for lights on transparent objects, while in-editor it's fine. Report 2's issue is that exported image sequences of animations with transparency don't look right in other programs, even though render tab shows them correctly.
Are they the same? Let's check the key points: both have "rendered/exported file has incorrect transparency" vs "in-editor/render tab looks fine". But report 1 is about lights on transparent objects (specific scenario), report 2 is about animations with transparency (general). However, the underlying problem might be similar—alpha handling in exported files. But are they duplicates? Let's see: report 1's steps involve a specific setup (light against low-alpha object), report 2 involves animation exports. The descriptions are different: one is about lights on transparent objects, the other about animations with transparency. So maybe not the same issue. Wait, but both have the problem that exported files don't match render tab. But the context is different—lights vs animations. So probably not duplicates. Therefore, answer is No.
JSON Data
{
"llm_judgement": false,
"processing_time": 24.176244999999998,
"duplicate_report_number": "154544"
}
Report flagged as NOT a duplicate by LLM
Light cannot pass through transparent meshes
https://projects.blender.org/blender/blender/issues/103876
System Information
Operating system: Windows-10-10.0.19041-SP0 64 Bits
Graphics card: NVIDIA GeForce GTX 980 Ti/PCIe/SSE2 NVIDIA Corporation 4.5.0 NVIDIA 522.25
Blender Version
Broken: version: 3.5.0 Alpha, branch: master, commit date: 2023-01-13 23:22, hash:
3a3d9488a1Worked: (newest version of Blender that worked as expected)
Short description of error
Light can't pass through the transparent mesh, visually, this is obviously a bug, but I don't know where the bug is.
Exact steps for others to reproduce the error
Lighting shadow.blend
LLM Reasoning
Got it, let's analyze the two bug reports. First, look at the descriptions and steps to reproduce.
Bug report 1: The issue is about lights on transparent objects having incorrect alpha/color in rendered files (shows fine in editor). Steps involve putting a light against a low-alpha object and rendering.
Bug report 2: The issue is that light can't pass through transparent meshes. Steps include using a blend file to show the problem where light doesn't go through transparency.
Wait, are these the same? Let's check the core problem. Bug 1 is about incorrect alpha/color when light is against transparency (maybe rendering artifacts). Bug 2 is about light not passing through transparent meshes at all. So the problems seem different: one is about visual artifacts in rendered output vs editor, the other is about light transmission through transparency. The steps and descriptions don't match exactly. So they are not duplicates.
JSON Data
{
"llm_judgement": false,
"processing_time": 12.763254,
"duplicate_report_number": "103876"
}