code

Guest

Sep 30th, 2026

Never

Not a member of GistPad yet? Sign Up, it unlocks many cool features!

None 176.50 KB | None | 0 0

copy raw download clone embed print report

--------------------------------------------------------------------------------
-- RE2 LIGHTPROBES CONTROL TEST
-- TEST INTENSITY
--
-- 8 LIGHTPROBES
-- CHECKBOX INDIVIDUELLE
-- OPTION TOUT
--
-- READ + WRITE RUNTIME
-- Aucun JSON
-- Aucun changement permanent
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
-- LOG
--------------------------------------------------------------------------------
local function test_log(message)
log.info(
"[LIGHTPROBES-CONTROL-TEST] " ..
tostring(message)
)
end
--------------------------------------------------------------------------------
-- LOAD LIGHTPROBES DATABASE
--------------------------------------------------------------------------------
local function load_lightprobes_database()
local path =
"Light/LightProbs/LightProbes.lua"
test_log(
"LOADING DATABASE: " ..
path
)
local source =
fs.read(
path
)
if not source
then
test_log(
"DATABASE FILE NOT FOUND"
)
return false
end
test_log(
"DATABASE FILE READ OK"
)
local chunk,
error_message =
load(
source,
"@LightProbs/LightProbes.lua"
)
if not chunk
then
test_log(
"DATABASE LUA COMPILE FAILED"
)
test_log(
tostring(
error_message
)
)
return false
end
local ok,
result =
pcall(
chunk
)
if not ok
then
test_log(
"DATABASE LUA EXECUTION FAILED"
)
test_log(
tostring(
result
)
)
return false
end
if type(result) ~= "table"
then
test_log(
"DATABASE RETURN IS NOT A TABLE"
)
test_log(
"TYPE = " ..
tostring(
type(result)
)
)
return false
end
LIGHTPROBES_DATABASE =
result
test_log(
"DATABASE LOADED SUCCESSFULLY"
)
test_log(
"DATABASE ENTRIES = " ..
tostring(
#LIGHTPROBES_DATABASE
)
)
return true
end
--------------------------------------------------------------------------------
-- ACTIVE LIGHTPROBES ZONE
--------------------------------------------------------------------------------
local LIGHTPROBES_LIST =
{
}
local LIGHTPROBES_ZONES =
{
}
local selected_lightprobes_zone =
nil
local function build_lightprobes_zones()
LIGHTPROBES_ZONES =
{
}
if type(LIGHTPROBES_DATABASE) ~= "table"
then
return false
end
for zone_name,
zone_data
in pairs(
LIGHTPROBES_DATABASE
)
do
if type(zone_data) == "table"
then
LIGHTPROBES_ZONES[
#LIGHTPROBES_ZONES + 1
] =
zone_name
end
end
table.sort(
LIGHTPROBES_ZONES
)
if #LIGHTPROBES_ZONES > 0
then
selected_lightprobes_zone =
LIGHTPROBES_ZONES[1]
end
return true
end
local function build_lightprobes_list_for_zone(
zone_name
)
LIGHTPROBES_LIST =
{
}
if type(LIGHTPROBES_DATABASE) ~= "table"
then
return false
end
local zone_data =
LIGHTPROBES_DATABASE[
zone_name
]
if type(zone_data) ~= "table"
then
return false
end
for i = 1,
#zone_data
do
local source =
zone_data[i]
if source
and source.id
and source.guid
then
LIGHTPROBES_LIST[
#LIGHTPROBES_LIST + 1
] =
{
zone = zone_name,
name = source.id,
guid = source.guid,
selected = true
}
end
end
return true
end
--------------------------------------------------------------------------------
-- RUNTIME CACHE
--------------------------------------------------------------------------------
local resolved_lightprobes =
{
}
local original_intensity =
{
}
--------------------------------------------------------------------------------
-- CONTROL VALUES
--------------------------------------------------------------------------------
local control_intensity = 0.005
local control_red = 1.0
local control_green = 1.0
local control_blue = 1.0
local control_saturate = 0.0
local control_ambient_color_intensity = 1.0
--------------------------------------------------------------------------------
-- GET CURRENT SCENE
--------------------------------------------------------------------------------
local function get_current_scene()
local scene_manager =
sdk.get_native_singleton(
"via.SceneManager"
)
if not scene_manager
then
test_log(
"SCENE MANAGER NOT FOUND"
)
return nil
end
local scene =
nil
local ok_scene,
scene_result =
pcall(
function()
return sdk.call_native_func(
scene_manager,
sdk.find_type_definition(
"via.SceneManager"
),
"get_CurrentScene"
)
end
)
if ok_scene
and scene_result
then
scene =
scene_result
end
if not scene
then
local ok_call,
result_call =
pcall(
function()
return scene_manager:call(
"get_CurrentScene"
)
end
)
if ok_call
and result_call
then
scene =
result_call
end
end
if not scene
then
test_log(
"CURRENT SCENE NOT FOUND"
)
return nil
end
return scene
end
--------------------------------------------------------------------------------
-- RESOLVE ALL LIGHTPROBES
--------------------------------------------------------------------------------
local function resolve_all_lightprobes()
resolved_lightprobes =
{
}
local scene =
get_current_scene()
if not scene
then
test_log(
"CURRENT SCENE NOT FOUND"
)
return false
end
test_log(
"CURRENT SCENE FOUND"
)
local ok_components,
transforms =
pcall(
function()
return scene:call(
"findComponents(System.Type)",
sdk.typeof(
"via.Transform"
)
)
end
)
if not ok_components
or not transforms
then
test_log(
"TRANSFORM ENUMERATION FAILED"
)
return false
end
local ok_count,
count =
pcall(
function()
return transforms:get_Count()
end
)
if not ok_count
or not count
then
test_log(
"TRANSFORM COUNT FAILED"
)
return false
end
test_log(
"TRANSFORMS = " ..
tostring(
count
)
)
local guid_to_index =
{
}
for i = 1,
#LIGHTPROBES_LIST
do
local entry =
LIGHTPROBES_LIST[i]
if entry
and entry.guid
then
guid_to_index[
tostring(
entry.guid
)
] =
i
end
end
local guid_count =
0
for _,
_ in pairs(
guid_to_index
)
do
guid_count =
guid_count + 1
end
test_log(
"ACTIVE ZONE GUIDS = " ..
tostring(
guid_count
)
)
for i = 0,
count - 1
do
local ok_transform,
transform =
pcall(
function()
return transforms:get_Item(
i
)
end
)
if ok_transform
and transform
then
local ok_game_object,
game_object =
pcall(
function()
return transform:call(
"get_GameObject"
)
end
)
if ok_game_object
and game_object
then
local ok_name,
object_name =
pcall(
function()
return game_object:call(
"get_Name"
)
end
)
if ok_name
and object_name
then
object_name =
tostring(
object_name
)
end
local ok_guid,
object_guid =
pcall(
function()
return game_object:call(
"get_GUID"
)
end
)
if ok_guid
and object_guid
then
object_guid =
tostring(
object_guid
)
local database_index =
guid_to_index[
object_guid
]
if database_index
then
test_log(
"GUID MATCH = " ..
object_guid ..
" | NAME = " ..
tostring(
object_name
)
)
local ok_components_go,
components =
pcall(
function()
return game_object:call(
"get_Components"
)
end
)
if ok_components_go
and components
then
local ok_component_count,
component_count =
pcall(
function()
return components:get_Count()
end
)
if ok_component_count
and component_count
then
for c = 0,
component_count - 1
do
local ok_component,
component =
pcall(
function()
return components:get_Item(
c
)
end
)
if ok_component
and component
then
local ok_type,
type_definition =
pcall(
function()
return component:get_type_definition()
end
)
if ok_type
and type_definition
then
local ok_full_name,
full_name =
pcall(
function()
return type_definition:get_full_name()
end
)
if ok_full_name
and full_name
and tostring(
full_name
) ==
"via.render.LightProbes"
then
resolved_lightprobes[
database_index
] =
component
test_log(
"LIGHTPROBE RESOLVED = " ..
tostring(
object_name
) ..
" | GUID = " ..
object_guid
)
break
end
end
end
end
end
end
end
end
end
end
end
local resolved_count =
0
for i = 1,
#LIGHTPROBES_LIST
do
if resolved_lightprobes[i]
then
resolved_count =
resolved_count + 1
end
end
test_log(
"RESOLVED = " ..
tostring(
resolved_count
) ..
" / " ..
tostring(
#LIGHTPROBES_LIST
)
)
return true
end
--------------------------------------------------------------------------------
-- GET TARGET
--------------------------------------------------------------------------------
local function get_target(index)
if resolved_lightprobes[index]
then
return resolved_lightprobes[index]
end
resolve_all_lightprobes()
return resolved_lightprobes[index]
end
--------------------------------------------------------------------------------
-- COLOR CACHE
--------------------------------------------------------------------------------
local original_color =
{
}
--------------------------------------------------------------------------------
-- READ COLOR
--------------------------------------------------------------------------------
local function read_selected_color()
test_log(
"================================================"
)
test_log(
"READ COLOR"
)
for i = 1,
#LIGHTPROBES_LIST
do
local entry =
LIGHTPROBES_LIST[i]
if entry.selected
then
local lightprobes =
get_target(
i
)
if lightprobes
then
local ok,
color =
pcall(
function()
return lightprobes:get_AmbientColor()
end
)
if ok
and color
then
local ok_x,
r =
pcall(
function()
return color.x
end
)
local ok_y,
g =
pcall(
function()
return color.y
end
)
local ok_z,
b =
pcall(
function()
return color.z
end
)
if ok_x
and ok_y
and ok_z
then
original_color[i] =
{
x = r,
y = g,
z = b
}
test_log(
entry.name ..
" | COLOR = " ..
tostring(r) ..
" / " ..
tostring(g) ..
" / " ..
tostring(b)
)
else
test_log(
entry.name ..
" | COLOR COMPONENT READ FAILED"
)
end
else
test_log(
entry.name ..
" | get_AmbientColor FAILED"
)
end
else
test_log(
entry.name ..
" | TARGET NOT FOUND"
)
end
end
end
test_log(
"================================================"
)
end
--------------------------------------------------------------------------------
-- RESTORE COLOR
--------------------------------------------------------------------------------
local function restore_selected_color()
test_log(
"================================================"
)
test_log(
"RESTORE COLOR"
)
for i = 1,
#LIGHTPROBES_LIST
do
local entry =
LIGHTPROBES_LIST[i]
if entry.selected
then
local lightprobes =
get_target(
i
)
local original =
original_color[i]
if lightprobes
and original
then
local ok_color,
color =
pcall(
function()
return lightprobes:get_AmbientColor()
end
)
if ok_color
and color
then
color.x =
original.x
color.y =
original.y
color.z =
original.z
local ok_set =
pcall(
function()
lightprobes:set_AmbientColor(
color
)
end
)
if ok_set
then
test_log(
entry.name ..
" | COLOR RESTORED = " ..
tostring(original.x) ..
" / " ..
tostring(original.y) ..
" / " ..
tostring(original.z)
)
else
test_log(
entry.name ..
" | COLOR RESTORE FAILED"
)
end
else
test_log(
entry.name ..
" | get_AmbientColor FAILED"
)
end
else
test_log(
entry.name ..
" | NOTHING TO RESTORE"
)
end
end
end
test_log(
"================================================"
)
end
--------------------------------------------------------------------------------
-- APPLY x2
--------------------------------------------------------------------------------
local function apply_selected_intensity_x2()
test_log(
"================================================"
)
test_log(
"INTENSITY x2 SELECTED"
)
for i = 1,
#LIGHTPROBES_LIST
do
local entry =
LIGHTPROBES_LIST[i]
if entry.selected
then
local lightprobes =
get_target(
i
)
if lightprobes
then
local ok_read,
current =
pcall(
function()
return lightprobes:get_Intensity()
end
)
if ok_read
then
if original_intensity[i] == nil
then
original_intensity[i] =
current
end
local new_value =
current * 2.0
local ok_set =
pcall(
function()
lightprobes:set_Intensity(
new_value
)
end
)
if ok_set
then
test_log(
entry.name ..
" | OLD = " ..
tostring(
current
) ..
" | NEW = " ..
tostring(
new_value
)
)
else
test_log(
entry.name ..
" | SET INTENSITY FAILED"
)
end
else
test_log(
entry.name ..
" | get_Intensity FAILED"
)
end
else
test_log(
entry.name ..
" | TARGET NOT FOUND"
)
end
end
end
test_log(
"================================================"
)
end
--------------------------------------------------------------------------------
-- RESTORE
--------------------------------------------------------------------------------
local function restore_selected_intensity()
test_log(
"================================================"
)
test_log(
"RESTORE SELECTED"
)
for i = 1,
#LIGHTPROBES_LIST
do
local entry =
LIGHTPROBES_LIST[i]
if entry.selected
then
local lightprobes =
get_target(
i
)
local original =
original_intensity[i]
if lightprobes
and original ~= nil
then
local ok_set =
pcall(
function()
lightprobes:set_Intensity(
original
)
end
)
if ok_set
then
test_log(
entry.name ..
" | RESTORED = " ..
tostring(
original
)
)
else
test_log(
entry.name ..
" | RESTORE FAILED"
)
end
else
test_log(
entry.name ..
" | NOTHING TO RESTORE"
)
end
end
end
test_log(
"================================================"
)
end
--------------------------------------------------------------------------------
-- READ CURRENT CONTROLS
--------------------------------------------------------------------------------
local function read_current_controls()
for i = 1,
#LIGHTPROBES_LIST
do
if LIGHTPROBES_LIST[i].selected
then
local lightprobes =
get_target(
i
)
if lightprobes
then
----------------------------------------------------------------
-- INTENSITY
----------------------------------------------------------------
local ok_intensity,
intensity =
pcall(
function()
return lightprobes:get_Intensity()
end
)
if ok_intensity
and intensity ~= nil
then
control_intensity =
intensity
end
----------------------------------------------------------------
-- COLOR
----------------------------------------------------------------
local ok_color,
color =
pcall(
function()
return lightprobes:get_AmbientColor()
end
)
if ok_color
and color
then
local ok_r,
r =
pcall(
function()
return color.x
end
)
local ok_g,
g =
pcall(
function()
return color.y
end
)
local ok_b,
b =
pcall(
function()
return color.z
end
)
if ok_r
and ok_g
and ok_b
then
control_red =
r
control_green =
g
control_blue =
b
end
end
break
end
end
end
test_log(
"CONTROL VALUES READ"
)
test_log(
"INTENSITY = " ..
tostring(
control_intensity
)
)
test_log(
"COLOR = " ..
tostring(
control_red
) ..
" / " ..
tostring(
control_green
) ..
" / " ..
tostring(
control_blue
)
)
end
--------------------------------------------------------------------------------
-- SELECT ALL
--------------------------------------------------------------------------------
local function select_all()
for i = 1,
#LIGHTPROBES_LIST
do
LIGHTPROBES_LIST[i].selected =
true
end
end
--------------------------------------------------------------------------------
-- DESELECT ALL
--------------------------------------------------------------------------------
local function deselect_all()
for i = 1,
#LIGHTPROBES_LIST
do
LIGHTPROBES_LIST[i].selected =
false
end
end
--------------------------------------------------------------------------------
-- COUNT SELECTED
--------------------------------------------------------------------------------
local function count_selected()
local count =
0
for i = 1,
#LIGHTPROBES_LIST
do
if LIGHTPROBES_LIST[i].selected
then
count =
count + 1
end
end
return count
end
----------------------------------------------------------------------------
-- SELECTION
----------------------------------------------------------------------------
local function draw_selection_buttons()
if imgui.button(
"TOUT"
)
then
select_all()
end
imgui.same_line()
if imgui.button(
"RIEN"
)
then
deselect_all()
end
end
----------------------------------------------------------------------------
-- RESOLVE
----------------------------------------------------------------------------
local function draw_resolve_button()
if imgui.button(
"RESOLVE 16 LIGHTPROBES"
)
then
resolve_all_lightprobes()
end
end
----------------------------------------------------------------------------
-- INTENSITY
----------------------------------------------------------------------------
local function draw_intensity_control()
local intensity_changed,
new_intensity =
imgui.slider_float(
"Intensity",
control_intensity,
0.0,
1.0
)
if intensity_changed
then
control_intensity =
new_intensity
for i = 1,
#LIGHTPROBES_LIST
do
local entry =
LIGHTPROBES_LIST[i]
if entry
and entry.selected
then
local lightprobes =
get_target(i)
if lightprobes
then
pcall(
function()
lightprobes:set_Intensity(
control_intensity
)
end
)
end
end
end
end
end
----------------------------------------------------------------------------
-- RED
----------------------------------------------------------------------------
local function draw_red_control()
local red_changed,
new_red =
imgui.slider_float(
"Red",
control_red,
0.0,
1.0
)
if red_changed
then
control_red =
new_red
for i = 1,
#LIGHTPROBES_LIST
do
local entry =
LIGHTPROBES_LIST[i]
if entry
and entry.selected
then
local lightprobes =
get_target(i)
if lightprobes
then
local ok,
color =
pcall(
function()
return lightprobes:get_AmbientColor()
end
)
if ok
and color
then
color.x =
control_red
pcall(
function()
lightprobes:set_AmbientColor(
color
)
end
)
end
end
end
end
end
end
----------------------------------------------------------------------------
-- GREEN
----------------------------------------------------------------------------
local function draw_green_control()
local green_changed,
new_green =
imgui.slider_float(
"Green",
control_green,
0.0,
1.0
)
if green_changed
then
control_green =
new_green
for i = 1,
#LIGHTPROBES_LIST
do
local entry =
LIGHTPROBES_LIST[i]
if entry
and entry.selected
then
local lightprobes =
get_target(i)
if lightprobes
then
local ok,
color =
pcall(
function()
return lightprobes:get_AmbientColor()
end
)
if ok
and color
then
color.y =
control_green
pcall(
function()
lightprobes:set_AmbientColor(
color
)
end
)
end
end
end
end
end
end
----------------------------------------------------------------------------
-- BLUE
----------------------------------------------------------------------------
local function draw_blue_control()
local blue_changed,
new_blue =
imgui.slider_float(
"Blue",
control_blue,
0.0,
1.0
)
if blue_changed
then
control_blue =
new_blue
for i = 1,
#LIGHTPROBES_LIST
do
local entry =
LIGHTPROBES_LIST[i]
if entry
and entry.selected
then
local lightprobes =
get_target(i)
if lightprobes
then
local ok,
color =
pcall(
function()
return lightprobes:get_AmbientColor()
end
)
if ok
and color
then
color.z =
control_blue
pcall(
function()
lightprobes:set_AmbientColor(
color
)
end
)
end
end
end
end
end
end
----------------------------------------------------------------------------
-- VALUES
----------------------------------------------------------------------------
local function draw_values()
imgui.text(
"Intensity = " ..
string.format(
"%.6f",
control_intensity
)
)
imgui.text(
"RGB = " ..
string.format(
"%.3f",
control_red
) ..
" / " ..
string.format(
"%.3f",
control_green
) ..
" / " ..
string.format(
"%.3f",
control_blue
)
)
imgui.text(
"Saturate = " ..
string.format(
"%.3f",
control_saturate
)
)
imgui.text(
"Ambient Color Intensity = " ..
string.format(
"%.3f",
control_ambient_color_intensity
)
)
end
----------------------------------------------------------------------------
-- RESTORE
----------------------------------------------------------------------------
local function draw_restore_button()
if imgui.button(
"RESTORE ORIGINAL"
)
then
restore_selected_intensity()
restore_selected_color()
end
end
----------------------------------------------------------------------------
-- RESTORE COLOR
----------------------------------------------------------------------------
local function draw_restore_color_button()
if imgui.button(
"RESTORE COLOR"
)
then
restore_selected_color()
end
end
----------------------------------------------------------------------------
-- LIGHTPROBES LIST
----------------------------------------------------------------------------
local function draw_lightprobes_list()
for i = 1,
#LIGHTPROBES_LIST
do
local entry =
LIGHTPROBES_LIST[i]
local changed,
selected =
imgui.checkbox(
entry.name,
entry.selected
)
if changed
then
entry.selected =
selected
end
imgui.same_line()
imgui.text(
entry.guid
)
end
end
----------------------------------------------------------------------------
-- SATURATE CONTROL
----------------------------------------------------------------------------
local function draw_saturate_control()
local saturate_changed,
new_saturate =
imgui.slider_float(
"Saturate",
control_saturate,
0.0,
1.0
)
if saturate_changed
then
control_saturate =
new_saturate
for i = 1,
#LIGHTPROBES_LIST
do
local entry =
LIGHTPROBES_LIST[i]
if entry
and entry.selected
then
local lightprobes =
get_target(i)
if lightprobes
then
pcall(
function()
lightprobes:set_Saturate(
control_saturate
)
end
)
end
end
end
end
end
----------------------------------------------------------------------------
-- AMBIENT COLOR INTENSITY CONTROL
----------------------------------------------------------------------------
local function draw_ambient_color_intensity_control()
local changed,
new_value =
imgui.slider_float(
"Ambient Color Intensity",
control_ambient_color_intensity,
0.0,
2.0
)
if changed
then
control_ambient_color_intensity =
new_value
for i = 1,
#LIGHTPROBES_LIST
do
local entry =
LIGHTPROBES_LIST[i]
if entry
and entry.selected
then
local lightprobes =
get_target(i)
if lightprobes
then
pcall(
function()
lightprobes:set_AmbientColorIntensity(
control_ambient_color_intensity
)
end
)
end
end
end
end
end
--------------------------------------------------------------------------------
-- AMBIENT COLOR PICKER
--------------------------------------------------------------------------------
local control_alpha = 1.0
local function draw_ambient_color_picker()
local color =
Vector4f.new(
control_red,
control_green,
control_blue,
control_alpha
)
local changed,
new_color =
imgui.color_edit4(
"Ambient Color",
color
)
if changed
and new_color
then
control_red =
new_color.x
control_green =
new_color.y
control_blue =
new_color.z
control_alpha =
new_color.w
for i = 1,
#LIGHTPROBES_LIST
do
local entry =
LIGHTPROBES_LIST[i]
if entry
and entry.selected
then
local lightprobes =
get_target(i)
if lightprobes
then
pcall(
function()
local ambient_color =
lightprobes:get_AmbientColor()
ambient_color.x =
control_red
ambient_color.y =
control_green
ambient_color.z =
control_blue
lightprobes:set_AmbientColor(
ambient_color
)
end
)
end
end
end
end
end
--------------------------------------------------------------------------------
-- COLOR TEMPERATURE CONTROL
--------------------------------------------------------------------------------
local control_black_body_radiation =
0.0
local control_temperature =
6500.0
local function draw_color_temperature_controls()
----------------------------------------------------------------
-- BLACK BODY RADIATION
----------------------------------------------------------------
local changed_blackbody,
new_blackbody =
imgui.slider_float(
"Black Body Radiation",
control_black_body_radiation,
0.0,
1.0,
"%.2f"
)
if changed_blackbody
then
control_black_body_radiation =
new_blackbody
test_log(
"BlackBodyRadiation CHANGE = " ..
tostring(
control_black_body_radiation
)
)
for i = 1,
#LIGHTPROBES_LIST
do
local entry =
LIGHTPROBES_LIST[i]
if entry
and entry.selected
then
local lightprobes =
get_target(i)
if lightprobes
then
local ok,
result =
pcall(
function()
return lightprobes:call(
"set_BlackBodyRadiation",
control_black_body_radiation
)
end
)
test_log(
entry.name ..
" | set_BlackBodyRadiation | OK = " ..
tostring(ok) ..
" | RESULT = " ..
tostring(result)
)
end
end
end
end
----------------------------------------------------------------
-- TEMPERATURE
----------------------------------------------------------------
local changed_temperature,
new_temperature =
imgui.slider_float(
"Temperature",
control_temperature,
1000.0,
20000.0,
"%.0f K"
)
if changed_temperature
then
control_temperature =
new_temperature
test_log(
"Temperature CHANGE = " ..
tostring(
control_temperature
)
)
for i = 1,
#LIGHTPROBES_LIST
do
local entry =
LIGHTPROBES_LIST[i]
if entry
and entry.selected
then
local lightprobes =
get_target(i)
if lightprobes
then
local ok,
result =
pcall(
function()
return lightprobes:call(
"set_Temperature",
control_temperature
)
end
)
test_log(
entry.name ..
" | set_Temperature | OK = " ..
tostring(ok) ..
" | RESULT = " ..
tostring(result)
)
end
end
end
end
end
--------------------------------------------------------------------------------
-- UI
--------------------------------------------------------------------------------
re.on_draw_ui(
function()
if imgui.tree_node(
"LightProbes Control Test"
)
then
--------------------------------------------------------------------------------
-- LIGHTPROBES ZONE SELECTOR
--------------------------------------------------------------------------------
if #LIGHTPROBES_ZONES > 0
then
local current_zone_index =
1
for i = 1,
#LIGHTPROBES_ZONES
do
if LIGHTPROBES_ZONES[i]
== selected_lightprobes_zone
then
current_zone_index =
i
break
end
end
local changed_zone,
new_zone_index =
imgui.combo(
"Zone",
current_zone_index - 1,
LIGHTPROBES_ZONES
)
if changed_zone
then
local new_zone =
LIGHTPROBES_ZONES[
new_zone_index + 1
]
if new_zone
and new_zone ~= selected_lightprobes_zone
then
selected_lightprobes_zone =
new_zone
test_log(
"ZONE CHANGED = " ..
tostring(
selected_lightprobes_zone
)
)
resolved_lightprobes =
{
}
original_intensity =
{
}
original_color =
{
}
build_lightprobes_list_for_zone(
selected_lightprobes_zone
)
test_log(
"PROBES IN NEW ZONE = " ..
tostring(
#LIGHTPROBES_LIST
)
)
end
end
end
imgui.text(
"LightProbes : " ..
tostring(
#LIGHTPROBES_LIST
)
)
imgui.text(
"Selected : " ..
tostring(
count_selected()
) ..
" / " ..
tostring(
#LIGHTPROBES_LIST
)
)
imgui.separator()
draw_selection_buttons()
draw_resolve_button()
imgui.separator()
imgui.text(
"LIGHTPROBES CONTROL"
)
draw_intensity_control()
draw_red_control()
draw_green_control()
draw_blue_control()
draw_ambient_color_picker()
draw_saturate_control()
draw_ambient_color_intensity_control()
draw_color_temperature_controls()
draw_values()
imgui.separator()
draw_restore_button()
imgui.same_line()
draw_restore_color_button()
imgui.separator()
draw_lightprobes_list()
imgui.tree_pop()
end
end
)
--------------------------------------------------------------------------------
-- STARTUP
--------------------------------------------------------------------------------
test_log(
"SCRIPT LOADED"
)
if load_lightprobes_database()
then
test_log(
"LIGHTPROBES DATABASE LOADED"
)
if build_lightprobes_zones()
then
test_log(
"LIGHTPROBES ZONES = " ..
tostring(
#LIGHTPROBES_ZONES
)
)
for i = 1,
#LIGHTPROBES_ZONES
do
test_log(
"ZONE [" ..
tostring(i) ..
"] = " ..
tostring(
LIGHTPROBES_ZONES[i]
)
)
end
if selected_lightprobes_zone
then
test_log(
"SELECTED ZONE = " ..
tostring(
selected_lightprobes_zone
)
)
if build_lightprobes_list_for_zone(
selected_lightprobes_zone
)
then
test_log(
"PROBES IN ZONE = " ..
tostring(
#LIGHTPROBES_LIST
)
)
for i = 1,
#LIGHTPROBES_LIST
do
local entry =
LIGHTPROBES_LIST[i]
if entry
then
test_log(
tostring(i) ..
" | " ..
tostring(
entry.zone
) ..
" | " ..
tostring(
entry.name
) ..
" | " ..
tostring(
entry.guid
)
)
end
end
else
test_log(
"LIGHTPROBES ZONE LIST BUILD FAILED"
)
end
else
test_log(
"NO LIGHTPROBES ZONE SELECTED"
)
end
else
test_log(
"LIGHTPROBES ZONES BUILD FAILED"
)
end
else
test_log(
"LIGHTPROBES DATABASE LOAD FAILED"
)
end

RAW Paste Data Copied

--------------------------------------------------------------------------------
-- RE2 LIGHTPROBES CONTROL TEST
-- TEST INTENSITY
--
-- 8 LIGHTPROBES
-- CHECKBOX INDIVIDUELLE
-- OPTION TOUT
--
-- READ + WRITE RUNTIME
-- Aucun JSON
-- Aucun changement permanent
--------------------------------------------------------------------------------

--------------------------------------------------------------------------------
-- LOG
--------------------------------------------------------------------------------

local function test_log(message)

log.info(
        "[LIGHTPROBES-CONTROL-TEST] " ..
        tostring(message)
    )

end

--------------------------------------------------------------------------------
-- LOAD LIGHTPROBES DATABASE
--------------------------------------------------------------------------------

local function load_lightprobes_database()

local path =
        "Light/LightProbs/LightProbes.lua"

test_log(
        "LOADING DATABASE: " ..
        path
    )

local source =
        fs.read(
            path
        )

if not source
    then

test_log(
            "DATABASE FILE NOT FOUND"
        )

return false

end

test_log(
        "DATABASE FILE READ OK"
    )

local chunk,
          error_message =
        load(
            source,
            "@LightProbs/LightProbes.lua"
        )

if not chunk
    then

test_log(
            "DATABASE LUA COMPILE FAILED"
        )

test_log(
            tostring(
                error_message
            )
        )

return false

end

local ok,
          result =
        pcall(
            chunk
        )

if not ok
    then

test_log(
            "DATABASE LUA EXECUTION FAILED"
        )

test_log(
            tostring(
                result
            )
        )

return false

end

if type(result) ~= "table"
    then

test_log(
            "DATABASE RETURN IS NOT A TABLE"
        )

test_log(
            "TYPE = " ..
            tostring(
                type(result)
            )
        )

return false

end

LIGHTPROBES_DATABASE =
        result

test_log(
        "DATABASE LOADED SUCCESSFULLY"
    )

test_log(
        "DATABASE ENTRIES = " ..
        tostring(
            #LIGHTPROBES_DATABASE
        )
    )

return true

end

--------------------------------------------------------------------------------
-- ACTIVE LIGHTPROBES ZONE
--------------------------------------------------------------------------------

local LIGHTPROBES_LIST =
{
}

local LIGHTPROBES_ZONES =
{
}

local selected_lightprobes_zone =
    nil

local function build_lightprobes_zones()

LIGHTPROBES_ZONES =
    {
    }

if type(LIGHTPROBES_DATABASE) ~= "table"
    then

return false

end

for zone_name,
        zone_data
    in pairs(
        LIGHTPROBES_DATABASE
    )
    do

if type(zone_data) == "table"
        then

LIGHTPROBES_ZONES[
                #LIGHTPROBES_ZONES + 1
            ] =
                zone_name

end

table.sort(
        LIGHTPROBES_ZONES
    )

if #LIGHTPROBES_ZONES > 0
    then

selected_lightprobes_zone =
            LIGHTPROBES_ZONES[1]

end

return true

end

local function build_lightprobes_list_for_zone(
    zone_name
)

LIGHTPROBES_LIST =
    {
    }

if type(LIGHTPROBES_DATABASE) ~= "table"
    then

return false

end

local zone_data =
        LIGHTPROBES_DATABASE[
            zone_name
        ]

if type(zone_data) ~= "table"
    then

return false

end

for i = 1,
        #zone_data
    do

local source =
            zone_data[i]

if source
        and source.id
        and source.guid
        then

LIGHTPROBES_LIST[
                #LIGHTPROBES_LIST + 1
            ] =
            {
                zone = zone_name,
                name = source.id,
                guid = source.guid,
                selected = true
            }

end

return true

end

--------------------------------------------------------------------------------
-- RUNTIME CACHE
--------------------------------------------------------------------------------

local resolved_lightprobes =
{
}

local original_intensity =
{
}

--------------------------------------------------------------------------------
-- CONTROL VALUES
--------------------------------------------------------------------------------

local control_intensity = 0.005

local control_red = 1.0

local control_green =  1.0

local control_blue = 1.0

local control_saturate = 0.0

local control_ambient_color_intensity = 1.0

--------------------------------------------------------------------------------
-- GET CURRENT SCENE
--------------------------------------------------------------------------------

local function get_current_scene()

local scene_manager =
        sdk.get_native_singleton(
            "via.SceneManager"
        )

if not scene_manager
    then

test_log(
            "SCENE MANAGER NOT FOUND"
        )

return nil

end

local scene =
        nil

local ok_scene,
          scene_result =
        pcall(
            function()

return sdk.call_native_func(
                    scene_manager,
                    sdk.find_type_definition(
                        "via.SceneManager"
                    ),
                    "get_CurrentScene"
                )

end
        )

if ok_scene
    and scene_result
    then

scene =
            scene_result

end

if not scene
    then

local ok_call,
              result_call =
            pcall(
                function()

return scene_manager:call(
                        "get_CurrentScene"
                    )

end
            )

if ok_call
        and result_call
        then

scene =
                result_call

end

if not scene
    then

test_log(
            "CURRENT SCENE NOT FOUND"
        )

return nil

end

return scene

end

--------------------------------------------------------------------------------
-- RESOLVE ALL LIGHTPROBES
--------------------------------------------------------------------------------

local function resolve_all_lightprobes()

resolved_lightprobes =
    {
    }

local scene =
        get_current_scene()

if not scene
    then

test_log(
            "CURRENT SCENE NOT FOUND"
        )

return false

end

test_log(
        "CURRENT SCENE FOUND"
    )

local ok_components,
          transforms =
        pcall(
            function()

return scene:call(
                    "findComponents(System.Type)",
                    sdk.typeof(
                        "via.Transform"
                    )
                )

end
        )

if not ok_components
    or not transforms
    then

test_log(
            "TRANSFORM ENUMERATION FAILED"
        )

return false

end

local ok_count,
          count =
        pcall(
            function()

return transforms:get_Count()

end
        )

if not ok_count
    or not count
    then

test_log(
            "TRANSFORM COUNT FAILED"
        )

return false

end

test_log(
        "TRANSFORMS = " ..
        tostring(
            count
        )
    )

local guid_to_index =
    {
    }

for i = 1,
        #LIGHTPROBES_LIST
    do

local entry =
            LIGHTPROBES_LIST[i]

if entry
        and entry.guid
        then

guid_to_index[
                tostring(
                    entry.guid
                )
            ] =
                i

end

local guid_count =
        0

for _,
        _ in pairs(
            guid_to_index
        )
    do

guid_count =
            guid_count + 1

end

test_log(
        "ACTIVE ZONE GUIDS = " ..
        tostring(
            guid_count
        )
    )

for i = 0,
        count - 1
    do

local ok_transform,
              transform =
            pcall(
                function()

return transforms:get_Item(
                        i
                    )

end
            )

if ok_transform
        and transform
        then

local ok_game_object,
                  game_object =
                pcall(
                    function()

return transform:call(
                            "get_GameObject"
                        )

end
                )

if ok_game_object
            and game_object
            then

local ok_name,
                      object_name =
                    pcall(
                        function()

return game_object:call(
                                "get_Name"
                            )

end
                    )

if ok_name
                and object_name
                then

object_name =
                        tostring(
                            object_name
                        )

end

local ok_guid,
                      object_guid =
                    pcall(
                        function()

return game_object:call(
                                "get_GUID"
                            )

end
                    )

if ok_guid
                and object_guid
                then

object_guid =
                        tostring(
                            object_guid
                        )

local database_index =
                        guid_to_index[
                            object_guid
                        ]

if database_index
                    then

test_log(
                            "GUID MATCH = " ..
                            object_guid ..
                            " | NAME = " ..
                            tostring(
                                object_name
                            )
                        )

local ok_components_go,
                              components =
                            pcall(
                                function()

return game_object:call(
                                        "get_Components"
                                    )

end
                            )

if ok_components_go
                        and components
                        then

local ok_component_count,
                                  component_count =
                                pcall(
                                    function()

return components:get_Count()

end
                                )

if ok_component_count
                            and component_count
                            then

for c = 0,
                                    component_count - 1
                                do

local ok_component,
                                          component =
                                        pcall(
                                            function()

return components:get_Item(
                                                    c
                                                )

end
                                        )

if ok_component
                                    and component
                                    then

local ok_type,
                                              type_definition =
                                            pcall(
                                                function()

return component:get_type_definition()

end
                                            )

if ok_type
                                        and type_definition
                                        then

local ok_full_name,
                                                  full_name =
                                                pcall(
                                                    function()

return type_definition:get_full_name()

end
                                                )

if ok_full_name
                                            and full_name
                                            and tostring(
                                                full_name
                                            ) ==
                                                "via.render.LightProbes"
                                            then

resolved_lightprobes[
                                                    database_index
                                                ] =
                                                    component

test_log(
                                                    "LIGHTPROBE RESOLVED = " ..
                                                    tostring(
                                                        object_name
                                                    ) ..
                                                    " | GUID = " ..
                                                    object_guid
                                                )

break

end

local resolved_count =
        0

for i = 1,
        #LIGHTPROBES_LIST
    do

if resolved_lightprobes[i]
        then

resolved_count =
                resolved_count + 1

end

test_log(
        "RESOLVED = " ..
        tostring(
            resolved_count
        ) ..
        " / " ..
        tostring(
            #LIGHTPROBES_LIST
        )
    )

return true

end

--------------------------------------------------------------------------------
-- GET TARGET
--------------------------------------------------------------------------------

local function get_target(index)

if resolved_lightprobes[index]
    then

return resolved_lightprobes[index]

end

resolve_all_lightprobes()

return resolved_lightprobes[index]

end

--------------------------------------------------------------------------------
-- COLOR CACHE
--------------------------------------------------------------------------------

local original_color =
{
}

--------------------------------------------------------------------------------
-- READ COLOR
--------------------------------------------------------------------------------

local function read_selected_color()

test_log(
        "================================================"
    )

test_log(
        "READ COLOR"
    )

for i = 1,
        #LIGHTPROBES_LIST
    do

local entry =
            LIGHTPROBES_LIST[i]

if entry.selected
        then

local lightprobes =
                get_target(
                    i
                )

if lightprobes
            then

local ok,
                      color =
                    pcall(
                        function()

return lightprobes:get_AmbientColor()

end
                    )

if ok
                and color
                then

local ok_x,
                          r =
                        pcall(
                            function()

return color.x

end
                        )

local ok_y,
                          g =
                        pcall(
                            function()

return color.y

end
                        )

local ok_z,
                          b =
                        pcall(
                            function()

return color.z

end
                        )

if ok_x
                    and ok_y
                    and ok_z
                    then

original_color[i] =
                        {
                            x = r,
                            y = g,
                            z = b
                        }

test_log(
                            entry.name ..
                            " | COLOR = " ..
                            tostring(r) ..
                            " / " ..
                            tostring(g) ..
                            " / " ..
                            tostring(b)
                        )

else

test_log(
                            entry.name ..
                            " | COLOR COMPONENT READ FAILED"
                        )

end

else

test_log(
                        entry.name ..
                        " | get_AmbientColor FAILED"
                    )

end

else

test_log(
                    entry.name ..
                    " | TARGET NOT FOUND"
                )

end

test_log(
        "================================================"
    )

end

--------------------------------------------------------------------------------
-- RESTORE COLOR
--------------------------------------------------------------------------------

local function restore_selected_color()

test_log(
        "================================================"
    )

test_log(
        "RESTORE COLOR"
    )

for i = 1,
        #LIGHTPROBES_LIST
    do

local entry =
            LIGHTPROBES_LIST[i]

if entry.selected
        then

local lightprobes =
                get_target(
                    i
                )

local original =
                original_color[i]

if lightprobes
            and original
            then

local ok_color,
                      color =
                    pcall(
                        function()

return lightprobes:get_AmbientColor()

end
                    )

if ok_color
                and color
                then

color.x =
                        original.x

color.y =
                        original.y

color.z =
                        original.z

local ok_set =
                        pcall(
                            function()

lightprobes:set_AmbientColor(
                                    color
                                )

end
                        )

if ok_set
                    then

test_log(
                            entry.name ..
                            " | COLOR RESTORED = " ..
                            tostring(original.x) ..
                            " / " ..
                            tostring(original.y) ..
                            " / " ..
                            tostring(original.z)
                        )

else

test_log(
                            entry.name ..
                            " | COLOR RESTORE FAILED"
                        )

end

else

test_log(
                        entry.name ..
                        " | get_AmbientColor FAILED"
                    )

end

else

test_log(
                    entry.name ..
                    " | NOTHING TO RESTORE"
                )

end

test_log(
        "================================================"
    )

end

--------------------------------------------------------------------------------
-- APPLY x2
--------------------------------------------------------------------------------

local function apply_selected_intensity_x2()

test_log(
        "================================================"
    )

test_log(
        "INTENSITY x2 SELECTED"
    )

for i = 1,
        #LIGHTPROBES_LIST
    do

local entry =
            LIGHTPROBES_LIST[i]

if entry.selected
        then

local lightprobes =
                get_target(
                    i
                )

if lightprobes
            then

local ok_read,
                      current =
                    pcall(
                        function()

return lightprobes:get_Intensity()

end
                    )

if ok_read
                then

if original_intensity[i] == nil
                    then

original_intensity[i] =
                            current

end

local new_value =
                        current * 2.0

local ok_set =
                        pcall(
                            function()

lightprobes:set_Intensity(
                                    new_value
                                )

end
                        )

if ok_set
                    then

test_log(
                            entry.name ..
                            " | OLD = " ..
                            tostring(
                                current
                            ) ..
                            " | NEW = " ..
                            tostring(
                                new_value
                            )
                        )

else

test_log(
                            entry.name ..
                            " | SET INTENSITY FAILED"
                        )

end

else

test_log(
                        entry.name ..
                        " | get_Intensity FAILED"
                    )

end

else

test_log(
                    entry.name ..
                    " | TARGET NOT FOUND"
                )

end

test_log(
        "================================================"
    )

end

--------------------------------------------------------------------------------
-- RESTORE
--------------------------------------------------------------------------------

local function restore_selected_intensity()

test_log(
        "================================================"
    )

test_log(
        "RESTORE SELECTED"
    )

for i = 1,
        #LIGHTPROBES_LIST
    do

local entry =
            LIGHTPROBES_LIST[i]

if entry.selected
        then

local lightprobes =
                get_target(
                    i
                )

local original =
                original_intensity[i]

if lightprobes
            and original ~= nil
            then

local ok_set =
                    pcall(
                        function()

lightprobes:set_Intensity(
                                original
                            )

end
                    )

if ok_set
                then

test_log(
                        entry.name ..
                        " | RESTORED = " ..
                        tostring(
                            original
                        )
                    )

else

test_log(
                        entry.name ..
                        " | RESTORE FAILED"
                    )

end

else

test_log(
                    entry.name ..
                    " | NOTHING TO RESTORE"
                )

end

test_log(
        "================================================"
    )

end

--------------------------------------------------------------------------------
-- READ CURRENT CONTROLS
--------------------------------------------------------------------------------

local function read_current_controls()

for i = 1,
        #LIGHTPROBES_LIST
    do

if LIGHTPROBES_LIST[i].selected
        then

local lightprobes =
                get_target(
                    i
                )

if lightprobes
            then

----------------------------------------------------------------
                -- INTENSITY
                ----------------------------------------------------------------

local ok_intensity,
                      intensity =
                    pcall(
                        function()

return lightprobes:get_Intensity()

end
                    )

if ok_intensity
                and intensity ~= nil
                then

control_intensity =
                        intensity

end

----------------------------------------------------------------
                -- COLOR
                ----------------------------------------------------------------

local ok_color,
                      color =
                    pcall(
                        function()

return lightprobes:get_AmbientColor()

end
                    )

if ok_color
                and color
                then

local ok_r,
                          r =
                        pcall(
                            function()

return color.x

end
                        )

local ok_g,
                          g =
                        pcall(
                            function()

return color.y

end
                        )

local ok_b,
                          b =
                        pcall(
                            function()

return color.z

end
                        )

if ok_r
                    and ok_g
                    and ok_b
                    then

control_red =
                            r

control_green =
                            g

control_blue =
                            b

end

break

end

test_log(
        "CONTROL VALUES READ"
    )

test_log(
        "INTENSITY = " ..
        tostring(
            control_intensity
        )
    )

test_log(
        "COLOR = " ..
        tostring(
            control_red
        ) ..
        " / " ..
        tostring(
            control_green
        ) ..
        " / " ..
        tostring(
            control_blue
        )
    )

end

--------------------------------------------------------------------------------
-- SELECT ALL
--------------------------------------------------------------------------------

local function select_all()

for i = 1,
        #LIGHTPROBES_LIST
    do

LIGHTPROBES_LIST[i].selected =
            true

end

--------------------------------------------------------------------------------
-- DESELECT ALL
--------------------------------------------------------------------------------

local function deselect_all()

for i = 1,
        #LIGHTPROBES_LIST
    do

LIGHTPROBES_LIST[i].selected =
            false

end

--------------------------------------------------------------------------------
-- COUNT SELECTED
--------------------------------------------------------------------------------

local function count_selected()

local count =
        0

for i = 1,
        #LIGHTPROBES_LIST
    do

if LIGHTPROBES_LIST[i].selected
        then

count =
                count + 1

end

return count

end

----------------------------------------------------------------------------
-- SELECTION
----------------------------------------------------------------------------

local function draw_selection_buttons()

if imgui.button(
        "TOUT"
    )
    then

select_all()

end

imgui.same_line()

if imgui.button(
        "RIEN"
    )
    then

deselect_all()

end

end
----------------------------------------------------------------------------
-- RESOLVE
----------------------------------------------------------------------------

local function draw_resolve_button()

if imgui.button(
        "RESOLVE 16 LIGHTPROBES"
    )
    then

resolve_all_lightprobes()

end

end
----------------------------------------------------------------------------
-- INTENSITY
----------------------------------------------------------------------------

local function draw_intensity_control()

local intensity_changed,
          new_intensity =
        imgui.slider_float(
            "Intensity",
            control_intensity,
            0.0,
            1.0
        )

if intensity_changed
    then

control_intensity =
            new_intensity

for i = 1,
            #LIGHTPROBES_LIST
        do

local entry =
                LIGHTPROBES_LIST[i]

if entry
            and entry.selected
            then

local lightprobes =
                    get_target(i)

if lightprobes
                then

pcall(
                        function()

lightprobes:set_Intensity(
                                control_intensity
                            )

end
                    )

end

----------------------------------------------------------------------------
-- RED
----------------------------------------------------------------------------

local function draw_red_control()

local red_changed,
          new_red =
        imgui.slider_float(
            "Red",
            control_red,
            0.0,
            1.0
        )

if red_changed
    then

control_red =
            new_red

for i = 1,
            #LIGHTPROBES_LIST
        do

local entry =
                LIGHTPROBES_LIST[i]

if entry
            and entry.selected
            then

local lightprobes =
                    get_target(i)

if lightprobes
                then

local ok,
                          color =
                        pcall(
                            function()

return lightprobes:get_AmbientColor()

end
                        )

if ok
                    and color
                    then

color.x =
                            control_red

pcall(
                            function()

lightprobes:set_AmbientColor(
                                    color
                                )

end
                        )

end

end
----------------------------------------------------------------------------
-- GREEN
----------------------------------------------------------------------------

local function draw_green_control()

local green_changed,
          new_green =
        imgui.slider_float(
            "Green",
            control_green,
            0.0,
            1.0
        )

if green_changed
    then

control_green =
            new_green

for i = 1,
            #LIGHTPROBES_LIST
        do

local entry =
                LIGHTPROBES_LIST[i]

if entry
            and entry.selected
            then

local lightprobes =
                    get_target(i)

if lightprobes
                then

local ok,
                          color =
                        pcall(
                            function()

return lightprobes:get_AmbientColor()

end
                        )

if ok
                    and color
                    then

color.y =
                            control_green

pcall(
                            function()

lightprobes:set_AmbientColor(
                                    color
                                )

end
                        )

end

end
----------------------------------------------------------------------------
-- BLUE
----------------------------------------------------------------------------

local function draw_blue_control()

local blue_changed,
          new_blue =
        imgui.slider_float(
            "Blue",
            control_blue,
            0.0,
            1.0
        )

if blue_changed
    then

control_blue =
            new_blue

for i = 1,
            #LIGHTPROBES_LIST
        do

local entry =
                LIGHTPROBES_LIST[i]

if entry
            and entry.selected
            then

local lightprobes =
                    get_target(i)

if lightprobes
                then

local ok,
                          color =
                        pcall(
                            function()

return lightprobes:get_AmbientColor()

end
                        )

if ok
                    and color
                    then

color.z =
                            control_blue

pcall(
                            function()

lightprobes:set_AmbientColor(
                                    color
                                )

end
                        )

end

end
----------------------------------------------------------------------------
-- VALUES
----------------------------------------------------------------------------

local function draw_values()

imgui.text(
        "Intensity = " ..
        string.format(
            "%.6f",
            control_intensity
        )
    )

imgui.text(
        "RGB = " ..
        string.format(
            "%.3f",
            control_red
        ) ..
        " / " ..
        string.format(
            "%.3f",
            control_green
        ) ..
        " / " ..
        string.format(
            "%.3f",
            control_blue
        )
    )

imgui.text(
        "Saturate = " ..
        string.format(
            "%.3f",
            control_saturate
        )
    )

imgui.text(
        "Ambient Color Intensity = " ..
        string.format(
            "%.3f",
            control_ambient_color_intensity
        )
    )

end

----------------------------------------------------------------------------
-- RESTORE
----------------------------------------------------------------------------

local function draw_restore_button()

if imgui.button(
        "RESTORE ORIGINAL"
    )
    then

restore_selected_intensity()

restore_selected_color()

end

----------------------------------------------------------------------------
-- RESTORE COLOR
----------------------------------------------------------------------------

local function draw_restore_color_button()

if imgui.button(
        "RESTORE COLOR"
    )
    then

restore_selected_color()

end

end
----------------------------------------------------------------------------
-- LIGHTPROBES LIST
----------------------------------------------------------------------------

local function draw_lightprobes_list()

for i = 1,
        #LIGHTPROBES_LIST
    do

local entry =
            LIGHTPROBES_LIST[i]

local changed,
              selected =
            imgui.checkbox(
                entry.name,
                entry.selected
            )

if changed
        then

entry.selected =
                selected

end

imgui.same_line()

imgui.text(
            entry.guid
        )

end

----------------------------------------------------------------------------
-- SATURATE CONTROL
----------------------------------------------------------------------------

local function draw_saturate_control()

local saturate_changed,
          new_saturate =
        imgui.slider_float(
            "Saturate",
            control_saturate,
            0.0,
            1.0
        )

if saturate_changed
    then

control_saturate =
            new_saturate

for i = 1,
            #LIGHTPROBES_LIST
        do

local entry =
                LIGHTPROBES_LIST[i]

if entry
            and entry.selected
            then

local lightprobes =
                    get_target(i)

if lightprobes
                then

pcall(
                        function()

lightprobes:set_Saturate(
                                control_saturate
                            )

end
                    )

end

----------------------------------------------------------------------------
-- AMBIENT COLOR INTENSITY CONTROL
----------------------------------------------------------------------------

local function draw_ambient_color_intensity_control()

local changed,
          new_value =
        imgui.slider_float(
            "Ambient Color Intensity",
            control_ambient_color_intensity,
            0.0,
            2.0
        )

if changed
    then

control_ambient_color_intensity =
            new_value

for i = 1,
            #LIGHTPROBES_LIST
        do

local entry =
                LIGHTPROBES_LIST[i]

if entry
            and entry.selected
            then

local lightprobes =
                    get_target(i)

if lightprobes
                then

pcall(
                        function()

lightprobes:set_AmbientColorIntensity(
                                control_ambient_color_intensity
                            )

end
                    )

end

--------------------------------------------------------------------------------
-- AMBIENT COLOR PICKER
--------------------------------------------------------------------------------

local control_alpha = 1.0

local function draw_ambient_color_picker()

local color =
        Vector4f.new(
            control_red,
            control_green,
            control_blue,
            control_alpha
        )

local changed,
          new_color =
        imgui.color_edit4(
            "Ambient Color",
            color
        )

if changed
    and new_color
    then

control_red =
            new_color.x

control_green =
            new_color.y

control_blue =
            new_color.z

control_alpha =
            new_color.w

for i = 1,
            #LIGHTPROBES_LIST
        do

local entry =
                LIGHTPROBES_LIST[i]

if entry
            and entry.selected
            then

local lightprobes =
                    get_target(i)

if lightprobes
                then

pcall(
                        function()

local ambient_color =
                                lightprobes:get_AmbientColor()

ambient_color.x =
                                control_red

ambient_color.y =
                                control_green

ambient_color.z =
                                control_blue

lightprobes:set_AmbientColor(
                                ambient_color
                            )

end
                    )

end

--------------------------------------------------------------------------------
-- COLOR TEMPERATURE CONTROL
--------------------------------------------------------------------------------

local control_black_body_radiation =
    0.0

local control_temperature =
    6500.0

local function draw_color_temperature_controls()

----------------------------------------------------------------
    -- BLACK BODY RADIATION
    ----------------------------------------------------------------

local changed_blackbody,
          new_blackbody =
        imgui.slider_float(
            "Black Body Radiation",
            control_black_body_radiation,
            0.0,
            1.0,
            "%.2f"
        )

if changed_blackbody
    then

control_black_body_radiation =
            new_blackbody

test_log(
            "BlackBodyRadiation CHANGE = " ..
            tostring(
                control_black_body_radiation
            )
        )

for i = 1,
            #LIGHTPROBES_LIST
        do

local entry =
                LIGHTPROBES_LIST[i]

if entry
            and entry.selected
            then

local lightprobes =
                    get_target(i)

if lightprobes
                then

local ok,
                          result =
                        pcall(
                            function()

return lightprobes:call(
                                    "set_BlackBodyRadiation",
                                    control_black_body_radiation
                                )

end
                        )

test_log(
                        entry.name ..
                        " | set_BlackBodyRadiation | OK = " ..
                        tostring(ok) ..
                        " | RESULT = " ..
                        tostring(result)
                    )

end

----------------------------------------------------------------
    -- TEMPERATURE
    ----------------------------------------------------------------

local changed_temperature,
          new_temperature =
        imgui.slider_float(
            "Temperature",
            control_temperature,
            1000.0,
            20000.0,
            "%.0f K"
        )

if changed_temperature
    then

control_temperature =
            new_temperature

test_log(
            "Temperature CHANGE = " ..
            tostring(
                control_temperature
            )
        )

for i = 1,
            #LIGHTPROBES_LIST
        do

local entry =
                LIGHTPROBES_LIST[i]

if entry
            and entry.selected
            then

local lightprobes =
                    get_target(i)

if lightprobes
                then

local ok,
                          result =
                        pcall(
                            function()

return lightprobes:call(
                                    "set_Temperature",
                                    control_temperature
                                )

end
                        )

test_log(
                        entry.name ..
                        " | set_Temperature | OK = " ..
                        tostring(ok) ..
                        " | RESULT = " ..
                        tostring(result)
                    )

end

--------------------------------------------------------------------------------
-- UI
--------------------------------------------------------------------------------

re.on_draw_ui(
    function()

if imgui.tree_node(
            "LightProbes Control Test"
        )
        then

--------------------------------------------------------------------------------
            -- LIGHTPROBES ZONE SELECTOR
            --------------------------------------------------------------------------------

if #LIGHTPROBES_ZONES > 0
            then

local current_zone_index =
                    1

for i = 1,
                    #LIGHTPROBES_ZONES
                do

if LIGHTPROBES_ZONES[i]
                    == selected_lightprobes_zone
                    then

current_zone_index =
                            i

break

end

local changed_zone,
                      new_zone_index =
                    imgui.combo(
                        "Zone",
                        current_zone_index - 1,
                        LIGHTPROBES_ZONES
                    )

if changed_zone
                then

local new_zone =
                        LIGHTPROBES_ZONES[
                            new_zone_index + 1
                        ]

if new_zone
                    and new_zone ~= selected_lightprobes_zone
                    then

selected_lightprobes_zone =
                            new_zone

test_log(
                            "ZONE CHANGED = " ..
                            tostring(
                                selected_lightprobes_zone
                            )
                        )

resolved_lightprobes =
                        {
                        }

original_intensity =
                        {
                        }

original_color =
                        {
                        }

build_lightprobes_list_for_zone(
                            selected_lightprobes_zone
                        )

test_log(
                            "PROBES IN NEW ZONE = " ..
                            tostring(
                                #LIGHTPROBES_LIST
                            )
                        )

end

imgui.text(
                "LightProbes : " ..
                tostring(
                    #LIGHTPROBES_LIST
                )
            )

imgui.text(
                "Selected : " ..
                tostring(
                    count_selected()
                ) ..
                " / " ..
                tostring(
                    #LIGHTPROBES_LIST
                )
            )

imgui.separator()

draw_selection_buttons()

draw_resolve_button()

imgui.separator()

imgui.text(
                "LIGHTPROBES CONTROL"
            )

draw_intensity_control()

draw_red_control()

draw_green_control()

draw_blue_control()

draw_ambient_color_picker()

draw_saturate_control()

draw_ambient_color_intensity_control()

draw_color_temperature_controls()

draw_values()

imgui.separator()

draw_restore_button()

imgui.same_line()

draw_restore_color_button()

imgui.separator()

draw_lightprobes_list()

imgui.tree_pop()

end

end
)

--------------------------------------------------------------------------------
-- STARTUP
--------------------------------------------------------------------------------

test_log(
    "SCRIPT LOADED"
)

if load_lightprobes_database()
then

test_log(
        "LIGHTPROBES DATABASE LOADED"
    )

if build_lightprobes_zones()
    then

test_log(
            "LIGHTPROBES ZONES = " ..
            tostring(
                #LIGHTPROBES_ZONES
            )
        )

for i = 1,
            #LIGHTPROBES_ZONES
        do

test_log(
                "ZONE [" ..
                tostring(i) ..
                "] = " ..
                tostring(
                    LIGHTPROBES_ZONES[i]
                )
            )

end

if selected_lightprobes_zone
        then

test_log(
                "SELECTED ZONE = " ..
                tostring(
                    selected_lightprobes_zone
                )
            )

if build_lightprobes_list_for_zone(
                selected_lightprobes_zone
            )
            then

test_log(
                    "PROBES IN ZONE = " ..
                    tostring(
                        #LIGHTPROBES_LIST
                    )
                )

for i = 1,
                    #LIGHTPROBES_LIST
                do

local entry =
                        LIGHTPROBES_LIST[i]

if entry
                    then

test_log(
                            tostring(i) ..
                            " | " ..
                            tostring(
                                entry.zone
                            ) ..
                            " | " ..
                            tostring(
                                entry.name
                            ) ..
                            " | " ..
                            tostring(
                                entry.guid
                            )
                        )

end

else

test_log(
                    "LIGHTPROBES ZONE LIST BUILD FAILED"
                )

end

else

test_log(
                "NO LIGHTPROBES ZONE SELECTED"
            )

end

else

test_log(
            "LIGHTPROBES ZONES BUILD FAILED"
        )

end

else

test_log(
        "LIGHTPROBES DATABASE LOAD FAILED"
    )

end