--------------------------------------------------------------------------------
-- 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