Files
LonaRPG-Online-Games/ModScripts/_Mods/LonaPaletteStudio/Scripts/0_LonaPaletteStudio.rb
T

4832 lines
173 KiB
Ruby
Raw Normal View History

2026-10-29 21:59:06 +04:00
# encoding: UTF-8
# Lona Palette Studio RU
# Target runtime: Ruby 3.1.0 (Ruby310Compat) / MKXP-Z.
# MKXP-Z exposes Bitmap#get_data and Bitmap#set_data as RGBA, top-down bytes.
Ruby310Compat.json_ready? if defined?(Ruby310Compat) && Ruby310Compat.respond_to?(:json_ready?)
module LonaPaletteStudio
def self.ui_font_name
begin
if defined?(MPSafeFont) && MPSafeFont.respond_to?(:rus2_active?) && MPSafeFont.rus2_active?
name = MPSafeFont.rus2_font(:MENU_L, :TITLE_MENU, :CHOICE)
return name if name && Font.exist?(name)
end
rescue
end
value = Font.default_name rescue "VL Gothic"
value = value[0] if value.is_a?(Array)
value.to_s.empty? ? "VL Gothic" : value.to_s
rescue
"VL Gothic"
end
def self.apply_ui_font(bitmap)
return if bitmap.nil? || !bitmap.respond_to?(:font) || bitmap.font.nil?
bitmap.font.name = ui_font_name
bitmap.font.bold = true
bitmap.font.shadow = false
bitmap.font.outline = false
end
MOD_ID = "LonaPaletteStudio"
VERSION = "1.2.1-ru-mkxpz-net-perf"
MENU_LABEL = "Палитра"
STORAGE_KEY = "LonaPaletteStudio"
SETTINGS_KEY = "LonaPaletteStudioSettings"
RGBA_BYTES_PER_PIXEL = 4
# The cache is shared by portraits and CHS. Palette signatures are part of
# every key, so changing one player must not flush bitmaps used by everyone.
# A bounded LRU prevents long editor sessions from retaining every transient
# slider colour forever.
BITMAP_CACHE_MAX_ENTRIES = 512
PAGE_ORDER = ["hair_primary", "assc", "skin", "eyes", "nipples", "gear"]
PAGE_NAMES = {
"hair_primary" => "Волосы",
"assc" => "Пирсинг",
"skin" => "Кожа 1",
"eyes" => "Глаза",
"nipples" => "Кожа 2",
"gear" => "Одежда"
}
HAIR_TARGET_ORDER = ["hair_primary", "hair_highlight"]
HAIR_TARGET_NAMES = {
"hair_primary" => "Основа",
"hair_highlight" => "Блики"
}
ASSC_TARGET_ORDER = ["piercing_face", "piercing_nipple", "piercing_arm", "piercing_belly", "piercing_vag"]
ASSC_TARGET_NAMES = {
"piercing_face" => "Лицо",
"piercing_nipple" => "Грудь",
"piercing_arm" => "Руки",
"piercing_belly" => "Живот",
"piercing_vag" => "Пах"
}
SOFT_TARGET_ORDER = ["lips", "nipples", "vag", "anus"]
SOFT_TARGET_NAMES = {
"lips" => "Язык",
"nipples" => "Соски",
"vag" => "Ваг.",
"anus" => "Анус"
}
GEAR_SLOT_ORDER = ["gear_head", "gear_face", "gear_neck", "gear_outer", "gear_top", "gear_top_extra", "gear_mid", "gear_mid_extra", "gear_bottom", "gear_vag", "gear_anal", "gear_mainhand", "gear_offhand"]
GEAR_SLOT_NAMES = {
"gear_head" => "Гл",
"gear_face" => "Лц",
"gear_neck" => "Шя",
"gear_outer" => "Вр",
"gear_top" => "Вх",
"gear_top_extra" => "В+",
"gear_mid" => "Ср",
"gear_mid_extra" => "С+",
"gear_bottom" => "Нз",
"gear_vag" => "Вг",
"gear_anal" => "Ан",
"gear_mainhand" => "ПР",
"gear_offhand" => "ЛР"
}
GEAR_LAYER_ORDER = ["base", "trim", "metal"]
GEAR_LAYER_NAMES = {
"base" => "Цвет 1",
"trim" => "Цвет 2",
"metal" => "Цвет 3"
}
GEAR_PROFILE_KEYS = GEAR_SLOT_ORDER.flat_map { |slot_key| GEAR_LAYER_ORDER.map { |layer_key| "#{slot_key}_#{layer_key}" } }
PROFILE_KEYS = HAIR_TARGET_ORDER + ["skin", "eyes"] + ASSC_TARGET_ORDER + SOFT_TARGET_ORDER + GEAR_PROFILE_KEYS
WHEEL_STYLE_OPTIONS = ["real", "soft", "fantasy", "full"]
WHEEL_STYLE_LABELS = {
"real" => "Натур.",
"soft" => "Мягк.",
"fantasy" => "Фэнт.",
"full" => "Все"
}
WHEEL_STYLE_PAGE_KEYS = ["skin", "nipples"]
WHEEL_STYLE_DEFAULTS = {
"skin" => "real",
"nipples" => "real"
}
SKIN_COLOR_MODES = ["gradient", "solid"]
SKIN_COLOR_MODE_LABELS = {
"gradient" => "Градиент",
"solid" => "Сплошной"
}
EYE_SKIN_RGBS = [
[222, 143, 93], [185, 90, 66], [239, 181, 169], [240, 181, 169],
[253, 165, 106]
]
EYE_NEUTRAL_RGBS = [
[255, 255, 255], [254, 255, 255], [0, 0, 0],
[20, 28, 22], [20, 28, 21], [43, 49, 40], [43, 49, 41]
]
PALETTE_CATEGORY_SCAN_GLOBS = [
"ModScripts/PaletteChanger/10_DEFAULT_Transformations.json",
"ModScripts/PaletteChanger/20_DEFAULT_Hair_dyes.json",
"ModScripts/PaletteChanger/9999_DEFAULT_Races.json",
"ModScripts/PaletteChanger/unactive_jsons/1000_*.json",
"ModScripts/PaletteChanger/unactive_jsons/*_Hair_*.json",
"ModScripts/PaletteChanger/unactive_jsons/*_Eyes_*.json",
"ModScripts/PaletteChanger/unactive_jsons/*_Skin_*.json",
"ModScripts/PaletteChanger/unactive_jsons/*DedGirl*.json",
"ModScripts/_Mods/Lona_Booba_Graphics/PaletteChanger/10_DEFAULT_Transformations_BOOBA.json",
"ModScripts/_Mods/Lona_Booba_Graphics/PaletteChanger/1000_*.json",
"ModScripts/_Mods/Lona_Booba_Graphics/PaletteChanger/*_Skin_*.json",
"ModScripts/_Mods/Lona_Booba_Graphics/PaletteChanger/9999_DEFAULT_Races_BOOBA.json",
"ModScripts/_Mods/Lona_Booba_Graphics/PaletteChanger/unactive_jsons/1000_*.json",
"ModScripts/_Mods/Lona_Booba_Graphics/PaletteChanger/unactive_jsons/*_Hair_*.json",
"ModScripts/_Mods/Lona_Booba_Graphics/PaletteChanger/unactive_jsons/*_Eyes_*.json",
"ModScripts/_Mods/Lona_Booba_Graphics/PaletteChanger/unactive_jsons/*_Skin_*.json",
"ModScripts/_Mods/Lona_Booba_Graphics/PaletteChanger/unactive_jsons/DESU/*.json",
"ModScripts/_Mods/DESU_MODE/100_DESU_Body.json",
"ModScripts/_Mods/DESU_MODE/100_DESU_Clothes.json",
"ModScripts/_Mods/DESU_MODE/100_DESU_Eyes.json",
"ModScripts/_Mods/DESU_MODE/100_DESU_Hair.json",
"ModScripts/_Mods/DESU_MODE/100_DESU_Deepone.json",
"ModScripts/_Mods/RolePlayS/Graphics/PaletteChanger/*.json",
"ModScripts/_Mods/RolePlayS/PaletteChanger/*.json",
"ModScripts/_Mods/RolePlayS/Solyanka/PaletteChanger/*.json"
]
PALETTE_CATEGORY_FROM_SOURCE = {
"source_mc/hair.act" => "hair_primary",
"source_mc/eyes.act" => "eyes",
"source_mc/eyes_h.act" => "eyes",
"source_mc/tongue.act" => "lips",
"source_mc/skin.act" => "skin",
"source_mc/skin_h.act" => "skin",
"source_mc/piercing_basic.act" => "piercing_face",
"source_mc/apparel/glasses_basic.act" => "gear_head",
"source_mc/apparel/adv_ext.act" => "gear_outer",
"source_mc/apparel/adv_ext_metal.act" => "gear_outer",
"source_mc/apparel/rag_ext.act" => "gear_outer",
"source_mc/apparel/sur_ext.act" => "gear_outer",
"source_mc/apparel/sur_ext_metal.act" => "gear_outer",
"source_mc/apparel/dancer/4.act" => "gear_outer",
"source_mc/apparel/dancer/4_metal.act" => "gear_outer",
"source_mc/apparel/adv_top.act" => "gear_top",
"source_mc/apparel/adv_top_rope.act" => "gear_top",
"source_mc/apparel/rag_top.act" => "gear_top",
"source_mc/apparel/sur_top.act" => "gear_top",
"source_mc/apparel/sur_top_fang.act" => "gear_top",
"source_mc/apparel/sur_top_ribs.act" => "gear_top",
"source_mc/apparel/dancer/1.act" => "gear_top",
"source_mc/apparel/dancer/1_metal.act" => "gear_top",
"source_mc/apparel/adv_mid.act" => "gear_mid",
"source_mc/apparel/rag_mid.act" => "gear_mid",
"source_mc/apparel/rag_mid_sub.act" => "gear_mid",
"source_mc/apparel/sur_mid.act" => "gear_mid",
"source_mc/apparel/sur_mid_ribs.act" => "gear_mid",
"source_mc/apparel/sur_mid_sub.act" => "gear_mid",
"source_mc/apparel/dancer/2.act" => "gear_mid",
"source_mc/apparel/dancer/2_metal.act" => "gear_mid",
"source_mc/apparel/adv_bot.act" => "gear_bottom",
"source_mc/apparel/adv_bot_boots.act" => "gear_bottom",
"source_mc/apparel/rag_bot.act" => "gear_bottom",
"source_mc/apparel/sur_bot.act" => "gear_bottom",
"source_mc/apparel/sur_bot_fur.act" => "gear_bottom",
"source_mc/apparel/sur_bot_panties.act" => "gear_bottom",
"source_mc/apparel/dancer/3.act" => "gear_bottom",
"source_mc/apparel/dancer/3_metal.act" => "gear_bottom"
}
PALETTE_SOURCE_FILES = {
"hair_primary" => ["source_mc/hair.act"],
"eyes" => ["source_mc/eyes.act", "source_mc/eyes_h.act"],
"skin" => ["source_mc/skin.act", "source_mc/skin_h.act"],
"piercing_basic" => ["source_mc/piercing_basic.act"],
"gear_base" => ["source_mc/apparel/adv_ext.act", "source_mc/apparel/rag_ext.act", "source_mc/apparel/adv_top.act", "source_mc/apparel/rag_top.act", "source_mc/apparel/sur_top.act", "source_mc/apparel/adv_mid.act", "source_mc/apparel/rag_mid.act", "source_mc/apparel/sur_mid.act", "source_mc/apparel/adv_bot.act", "source_mc/apparel/rag_bot.act", "source_mc/apparel/sur_bot.act", "source_mc/apparel/dancer/1.act", "source_mc/apparel/dancer/2.act", "source_mc/apparel/dancer/3.act", "source_mc/apparel/dancer/4.act"],
"gear_trim" => ["source_mc/apparel/adv_top_rope.act", "source_mc/apparel/adv_bot_boots.act", "source_mc/apparel/rag_mid_sub.act", "source_mc/apparel/sur_top_fang.act", "source_mc/apparel/sur_top_ribs.act", "source_mc/apparel/sur_mid_ribs.act", "source_mc/apparel/sur_mid_sub.act", "source_mc/apparel/sur_bot_fur.act", "source_mc/apparel/sur_bot_panties.act"],
"gear_metal" => ["source_mc/apparel/glasses_basic.act", "source_mc/apparel/adv_ext_metal.act", "source_mc/apparel/sur_ext_metal.act", "source_mc/apparel/dancer/1_metal.act", "source_mc/apparel/dancer/2_metal.act", "source_mc/apparel/dancer/3_metal.act", "source_mc/apparel/dancer/4_metal.act"],
"gear_head" => ["source_mc/apparel/glasses_basic.act"],
"gear_outer" => ["source_mc/apparel/adv_ext.act", "source_mc/apparel/adv_ext_metal.act", "source_mc/apparel/rag_ext.act", "source_mc/apparel/sur_ext.act", "source_mc/apparel/sur_ext_metal.act", "source_mc/apparel/dancer/4.act", "source_mc/apparel/dancer/4_metal.act"],
"gear_top" => ["source_mc/apparel/adv_top.act", "source_mc/apparel/adv_top_rope.act", "source_mc/apparel/rag_top.act", "source_mc/apparel/sur_top.act", "source_mc/apparel/sur_top_fang.act", "source_mc/apparel/sur_top_ribs.act", "source_mc/apparel/dancer/1.act", "source_mc/apparel/dancer/1_metal.act"],
"gear_mid" => ["source_mc/apparel/adv_mid.act", "source_mc/apparel/rag_mid.act", "source_mc/apparel/rag_mid_sub.act", "source_mc/apparel/sur_mid.act", "source_mc/apparel/sur_mid_ribs.act", "source_mc/apparel/sur_mid_sub.act", "source_mc/apparel/dancer/2.act", "source_mc/apparel/dancer/2_metal.act"],
"gear_bottom" => ["source_mc/apparel/adv_bot.act", "source_mc/apparel/adv_bot_boots.act", "source_mc/apparel/rag_bot.act", "source_mc/apparel/sur_bot.act", "source_mc/apparel/sur_bot_fur.act", "source_mc/apparel/sur_bot_panties.act", "source_mc/apparel/dancer/3.act", "source_mc/apparel/dancer/3_metal.act"]
}
CATEGORY_PRIORITY = ["piercing_face", "piercing_nipple", "piercing_arm", "piercing_belly", "piercing_vag", "eyes", "lips", "nipples", "vag", "hair_primary", "gear_head", "gear_face", "gear_neck", "gear_outer", "gear_top", "gear_top_extra", "gear_mid", "gear_mid_extra", "gear_bottom", "gear_vag", "gear_anal", "gear_mainhand", "gear_offhand", "skin"]
SOFT_MASK_ALPHA_THRESHOLDS = {
"chcg1_analopen_melaninanal.png" => 160,
"chcg1_melaninanal.png" => 160,
"chcg1_melaninvag.png" => 160,
"chcg1_vagopen_melaninvag.png" => 160,
"chcg2_analopen_melaninanal.png" => 160,
"chcg2_melaninanal.png" => 160,
"chcg2_melaninvag.png" => 160,
"chcg2_preg8m_melaninvag.png" => 160,
"chcg2_vagopen_melaninvag.png" => 160,
"chcg2_vagopen_preg8m_melaninvag.png" => 160,
"chcg3_analopen_melaninanal.png" => 144,
"chcg3_melaninanal.png" => 144,
"chcg4_analopen_melaninanal.png" => 160,
"chcg4_melaninanal.png" => 160,
"chcg4_melaninvag.png" => 160,
"chcg4_vagopen_melaninvag.png" => 160,
"pose1_subpose1_melaninvag.png" => 144,
"pose4_analopen_melaninanal.png" => 144,
"pose4_melaninanal.png" => 144,
"pose4_melaninvag.png" => 144,
"pose4_vagopen_melaninvag.png" => 144,
"pose5_subpose1_melaninvag.png" => 144
}
HUE_STEP = 2.0
SV_STEP = 4.0
def self.log(message)
rps_audit_log_palette_studio(message) rescue nil
end
def self.audit_error(message)
formatted = "[LonaPaletteStudio] #{message}"
begin
rps_audit_log(formatted)
rescue
rps_audit_log_palette_studio(message) rescue nil
end
nil
end
def self.log_exception(context, exception)
return if exception.nil?
backtrace = begin
(exception.backtrace || []).first(6).join(" | ")
rescue
""
end
audit_error("#{context} #{exception.class}: #{exception.message}#{backtrace.empty? ? '' : " | #{backtrace}"}")
end
def self.clamp(value, min_value, max_value)
return min_value if value < min_value
return max_value if value > max_value
value
end
def self.wrap_hue(value)
(value.to_f % 360.0 + 360.0) % 360.0
end
def self.color_luma(red, green, blue)
red.to_f * 0.299 + green.to_f * 0.587 + blue.to_f * 0.114
end
def self.quantize(value, step, min_value, max_value)
return clamp(value, min_value, max_value) if step.to_f <= 0.0
clamp((value.to_f / step.to_f).round * step.to_f, min_value, max_value)
end
# Return a validated MKXP-Z RGBA/top-down byte buffer. A nil result lets
# callers use the slower but portable get_pixel/set_pixel fallback.
def self.bitmap_rgba_data(bitmap, mutable = false)
return nil if bitmap.nil?
return nil unless bitmap.respond_to?(:get_data)
raw = bitmap.get_data
return nil unless raw.is_a?(String) && raw.respond_to?(:getbyte)
return nil if mutable && !raw.respond_to?(:setbyte)
expected_size = bitmap.width.to_i * bitmap.height.to_i * RGBA_BYTES_PER_PIXEL
return nil unless expected_size >= 0 && raw.bytesize == expected_size
mutable ? raw.dup : raw
rescue => e
log_exception("bitmap RGBA read failed", e)
nil
end
def self.default_profile(category)
case category.to_s
when "hair_highlight"
{
"enabled" => 0,
"h" => 28.0,
"s" => 124.0,
"v" => 236.0
}
when "piercing_face", "piercing_nipple", "piercing_arm", "piercing_belly", "piercing_vag"
{
"enabled" => 0,
"h" => 40.0,
"s" => 96.0,
"v" => 220.0
}
when "skin"
{
"enabled" => 0,
"h" => 22.0,
"s" => 78.0,
"v" => 240.0,
"mode" => "gradient"
}
when "lips"
{
"enabled" => 0,
"h" => 4.0,
"s" => 112.0,
"v" => 220.0
}
when "eyes"
{
"enabled" => 0,
"h" => 190.0,
"s" => 180.0,
"v" => 220.0
}
when "nipples"
{
"enabled" => 0,
"h" => 10.0,
"s" => 94.0,
"v" => 212.0
}
when "vag"
{
"enabled" => 0,
"h" => 8.0,
"s" => 108.0,
"v" => 206.0
}
when "anus"
{
"enabled" => 0,
"h" => 6.0,
"s" => 90.0,
"v" => 180.0
}
when /\Agear_.+_base\z/
{
"enabled" => 0,
"h" => 26.0,
"s" => 132.0,
"v" => 214.0,
"sample_r" => -1,
"sample_g" => -1,
"sample_b" => -1
}
when /\Agear_.+_trim\z/
{
"enabled" => 0,
"h" => 18.0,
"s" => 116.0,
"v" => 228.0,
"sample_r" => -1,
"sample_g" => -1,
"sample_b" => -1
}
when /\Agear_.+_metal\z/
{
"enabled" => 0,
"h" => 42.0,
"s" => 82.0,
"v" => 236.0,
"sample_r" => -1,
"sample_g" => -1,
"sample_b" => -1
}
else
{
"enabled" => 0,
"h" => 28.0,
"s" => 168.0,
"v" => 220.0
}
end
end
def self.default_state
state = {}
PROFILE_KEYS.each do |page_key|
state[page_key] = default_profile(page_key)
end
state
end
def self.deep_copy(obj)
Marshal.load(Marshal.dump(obj))
rescue
obj
end
def self.story_storage
return nil unless defined?($story_stats) && $story_stats
$story_stats.data ||= {} if $story_stats.respond_to?(:data)
$story_stats.data
rescue
nil
end
def self.default_settings
{
"wheel_styles" => deep_copy(WHEEL_STYLE_DEFAULTS)
}
end
def self.settings_storage
storage = story_storage
return default_settings if storage.nil?
storage[SETTINGS_KEY] ||= default_settings
settings = storage[SETTINGS_KEY]
settings["wheel_styles"] ||= deep_copy(WHEEL_STYLE_DEFAULTS)
WHEEL_STYLE_PAGE_KEYS.each do |page_key|
style_key = settings["wheel_styles"][page_key].to_s
settings["wheel_styles"][page_key] = WHEEL_STYLE_OPTIONS.include?(style_key) ? style_key : WHEEL_STYLE_DEFAULTS[page_key]
end
settings
end
def self.wheel_style_supported?(page_key)
WHEEL_STYLE_PAGE_KEYS.include?(page_key.to_s)
end
def self.wheel_style_for_page(page_key)
return "full" unless wheel_style_supported?(page_key)
settings = settings_storage
style_key = settings["wheel_styles"][page_key.to_s].to_s rescue nil
WHEEL_STYLE_OPTIONS.include?(style_key) ? style_key : WHEEL_STYLE_DEFAULTS[page_key.to_s]
end
def self.set_wheel_style_for_page(page_key, style_key)
return unless wheel_style_supported?(page_key)
value = style_key.to_s
return unless WHEEL_STYLE_OPTIONS.include?(value)
settings = settings_storage
settings["wheel_styles"][page_key.to_s] = value
end
def self.wheel_style_label(style_key)
WHEEL_STYLE_LABELS[style_key.to_s] || style_key.to_s.capitalize
end
def self.skin_color_mode_supported?(mode_key)
SKIN_COLOR_MODES.include?(mode_key.to_s)
end
def self.normalize_skin_color_mode(mode_key)
value = mode_key.to_s
skin_color_mode_supported?(value) ? value : "gradient"
end
def self.skin_color_mode(state_hash = nil)
normalize_skin_color_mode(profile_for("skin", state_hash)["mode"])
end
def self.skin_color_mode_label(mode_key)
SKIN_COLOR_MODE_LABELS[normalize_skin_color_mode(mode_key)]
end
def self.ensure_state
storage = story_storage
return default_state if storage.nil?
storage[STORAGE_KEY] ||= default_state
state = storage[STORAGE_KEY]
PROFILE_KEYS.each do |page_key|
state[page_key] ||= default_profile(page_key)
profile = state[page_key]
profile["enabled"] = profile["enabled"].to_i
profile["h"] = profile["h"].to_f
profile["s"] = profile["s"].to_f
profile["v"] = profile["v"].to_f
profile["mode"] = normalize_skin_color_mode(profile["mode"]) if page_key.to_s == "skin"
end
state
end
def self.state
ensure_state
end
def self.profile_for(page_key, state_hash = nil)
current_state = state_hash || state
current_state[page_key.to_s] || default_profile(page_key)
end
def self.profile_debug_summary(profile_key, state_hash = nil)
profile = profile_for(profile_key, state_hash)
sample = profile_sample_rgb(profile)
mode = profile.key?("mode") ? normalize_skin_color_mode(profile["mode"]) : "-"
"profile=#{profile_key.inspect} enabled=#{profile["enabled"].to_i} hsv=#{profile["h"].to_f.round(2)},#{profile["s"].to_f.round(2)},#{profile["v"].to_f.round(2)} mode=#{mode} sample=#{sample ? sample.join(',') : '-'}"
rescue => e
"profile=#{profile_key.inspect} summary_error=#{e.class}: #{e.message}"
end
def self.profile_signature(profile)
[
profile["enabled"].to_i,
profile["h"].to_f.round(2),
profile["s"].to_f.round(2),
profile["v"].to_f.round(2),
profile.key?("mode") ? normalize_skin_color_mode(profile["mode"]) : "-",
profile_sample_rgb(profile) ? profile_sample_rgb(profile).join(",") : "-"
].join(":")
end
def self.clear_recolor_cache!
@bitmap_cache = {}
@bitmap_cache_usage = {}
end
def self.bitmap_cache
@bitmap_cache ||= {}
end
def self.bitmap_cache_usage
@bitmap_cache_usage ||= {}
end
def self.fetch_cached_bitmap(cache_key)
cached = bitmap_cache[cache_key]
return nil if cached.nil?
if cached.respond_to?(:disposed?) && cached.disposed?
bitmap_cache.delete(cache_key)
bitmap_cache_usage.delete(cache_key)
return nil
end
@bitmap_cache_tick = (@bitmap_cache_tick || 0) + 1
bitmap_cache_usage[cache_key] = @bitmap_cache_tick
cached
end
def self.store_cached_bitmap(cache_key, bitmap)
bitmap_cache[cache_key] = bitmap
@bitmap_cache_tick = (@bitmap_cache_tick || 0) + 1
bitmap_cache_usage[cache_key] = @bitmap_cache_tick
trim_bitmap_cache!
bitmap
end
def self.trim_bitmap_cache!
overflow = bitmap_cache.length - BITMAP_CACHE_MAX_ENTRIES
return if overflow <= 0
# Dropping references is safer than disposing immediately: an engine sprite
# may still be finishing a frame with the returned bitmap. MKXP-Z releases
# the native image when Ruby collects the now-unreferenced object.
victims = bitmap_cache_usage.sort_by { |_key, tick| tick }.first([overflow + 32, bitmap_cache.length].min)
victims.each do |entry|
key = entry[0]
bitmap_cache.delete(key)
bitmap_cache_usage.delete(key)
end
end
def self.state_for_part(part)
override = part.instance_variable_get(:@palette_studio_preview_state) rescue nil
override || render_state_override || state
end
# CHS parts are shared engine objects. Network rendering temporarily puts the
# palette of one remote character on this stack so it cannot leak to others.
def self.render_state_override
stack = @render_state_stack
stack && !stack.empty? ? stack[-1] : nil
end
def self.with_render_state(state_hash)
@render_state_stack ||= []
@render_state_stack << state_hash
begin
yield
ensure
@render_state_stack.pop
end
end
# A remote character may have no Palette Studio state at all. In that case
# its CHS render must stay completely untouched; otherwise the global part
# hooks fall back to the local player's palette and recolor the remote player.
def self.render_palette_bypassed?
stack = @render_palette_bypass_stack
stack && !stack.empty? && stack[-1]
end
def self.without_palette_rendering
@render_palette_bypass_stack ||= []
@render_palette_bypass_stack << true
begin
yield
ensure
@render_palette_bypass_stack.pop
end
end
def self.overlay_profile_key_for_dirt_key(dirt_key)
case dirt_key.to_s
when "MelaninNipple"
"nipples"
when "MelaninVag", "MelaninAnal"
"vag"
else
nil
end
end
def self.legacy_skin2_overlay_name?(normalized_name)
value = normalized_name.to_s.downcase
return true if value.include?("effectbleedvag") || value.include?("effectbleedanal")
return true if value.include?("melaninmnipple") || value.include?("melaninsnipple")
return true if value.include?("melaninvag") || value.include?("melaninanal")
false
end
def self.legacy_skin2_overlay_part?(part)
return false if part.nil?
entries = []
entries << (part.respond_to?(:part_name) ? part.part_name : nil)
entries << (part.respond_to?(:root_folder) ? part.root_folder : nil)
bitmaps = part.bitmaps rescue nil
if bitmaps.respond_to?(:values)
bitmaps.values.each do |value|
entries << value
end
end
legacy_skin2_overlay_name?(entries.compact.join("|"))
end
def self.overlay_visibility_opacity_for_part(part, state_hash = nil)
return nil if render_palette_bypassed?
return nil if part.nil?
return 0 if legacy_skin2_overlay_part?(part)
return nil unless part.respond_to?(:isDirt) && part.isDirt
profile_key = overlay_profile_key_for_dirt_key(part.dirtKey)
return nil if profile_key.nil?
current_state = state_hash || state_for_part(part)
profile = profile_for(profile_key, current_state)
profile["enabled"].to_i == 0 ? 0 : 255
end
def self.apply_overlay_visibility_to_part!(part, state_hash = nil)
forced_opacity = overlay_visibility_opacity_for_part(part, state_hash)
return false if forced_opacity.nil?
part.opacity = forced_opacity.to_i
true
end
def self.profile_sample_rgb(profile)
return nil unless profile.is_a?(Hash)
return nil unless profile.key?("sample_r") && profile.key?("sample_g") && profile.key?("sample_b")
red = profile["sample_r"].to_i
green = profile["sample_g"].to_i
blue = profile["sample_b"].to_i
return nil if red < 0 || green < 0 || blue < 0
[red, green, blue]
end
def self.set_profile_sample_rgb!(profile, red, green, blue)
return unless profile.is_a?(Hash)
profile["sample_r"] = clamp(red.to_i, -1, 255)
profile["sample_g"] = clamp(green.to_i, -1, 255)
profile["sample_b"] = clamp(blue.to_i, -1, 255)
end
def self.gear_profile?(profile_key)
profile_key.to_s =~ /\Agear_.+_(base|trim|metal)\z/
end
def self.soft_lips_name?(normalized_name)
value = normalized_name.to_s
value.include?("mouth") || value.include?("lip")
end
def self.mouth_skin_layer_name?(normalized_name)
value = normalized_name.to_s
return false unless value.include?("mouth")
value.include?("head_mouth") || value.include?("face_mouth") || value.include?("head") || value.include?("face")
end
def self.soft_nipples_name?(normalized_name)
normalized_name.to_s.include?("nipple")
end
def self.soft_vag_name?(normalized_name)
value = normalized_name.to_s
return false if value.include?("pubichair")
return false if value.include?("melaninvag") || value.include?("melaninanal")
return false if value.include?("effectbleed")
value.include?("vagopen") || value.include?("analopen") ||
value.include?("vagruined") || value.include?("vag")
end
def self.body_overlay_search_stem(filename)
name = filename.to_s.sub(/\.png\z/i, "")
name = name.sub(/_backup\z/i, "")
name = name.gsub(/_body_dirt(?:_(?:low|high|mid|top|bot))?\z/i, "")
name = name.gsub(/_dirt(?:_(?:low|high|mid|top|bot))?\z/i, "")
name = name.gsub(/_shockbody\z/i, "")
name = name.gsub(/_botbody/i, "")
name = name.gsub(/_body_(?:low|high|mid|top|bot)\z/i, "")
name = name.gsub(/_body\z/i, "")
name = name.gsub(/__+/, "_")
name.sub(/_\z/, "")
end
def self.eye_composite_name?(normalized_name)
value = normalized_name.to_s
return false if value.include?("subeyes")
value.include?("head_eyes") || value.include?("face_eyes") || value.include?("headground")
end
def self.skin_primary_name?(normalized_name)
value = normalized_name.to_s
return true if mouth_skin_layer_name?(value)
return false if soft_lips_name?(value) || soft_nipples_name?(value) || soft_vag_name?(value)
value.include?("skin") || value.include?("body") || value.include?("head") || value.include?("face") ||
value.include?("arm") || value.include?("leg") || value.include?("breast") || value.include?("torso")
end
def self.head_hair_skin_overlay_name?(normalized_name)
value = normalized_name.to_s
value.include?("hair") && value.include?("_skin") && (value.include?("head") || value.include?("face"))
end
def self.page_wheel_config(page_key)
case page_key.to_s
when "skin"
case wheel_style_for_page(page_key)
when "real"
{ "hue_start" => 8.0, "hue_span" => 42.0, "sat_min" => 8.0, "sat_max" => 166.0 }
when "soft"
{ "hue_start" => 352.0, "hue_span" => 84.0, "sat_min" => 4.0, "sat_max" => 124.0 }
when "fantasy"
{ "hue_start" => 0.0, "hue_span" => 360.0, "sat_min" => 18.0, "sat_max" => 220.0 }
else
{ "hue_start" => 0.0, "hue_span" => 360.0, "sat_min" => 0.0, "sat_max" => 255.0 }
end
when "nipples"
case wheel_style_for_page(page_key)
when "real"
{ "hue_start" => 336.0, "hue_span" => 74.0, "sat_min" => 16.0, "sat_max" => 194.0 }
when "soft"
{ "hue_start" => 326.0, "hue_span" => 96.0, "sat_min" => 8.0, "sat_max" => 164.0 }
when "fantasy"
{ "hue_start" => 0.0, "hue_span" => 360.0, "sat_min" => 20.0, "sat_max" => 224.0 }
else
{ "hue_start" => 0.0, "hue_span" => 360.0, "sat_min" => 0.0, "sat_max" => 255.0 }
end
else
{ "hue_start" => 0.0, "hue_span" => 360.0, "sat_min" => 0.0, "sat_max" => 255.0 }
end
end
def self.page_hint_text(page_key)
case page_key.to_s
when "hair_primary"
"Волосы: основной цвет и блики."
when "assc"
"Цвета отдельных групп пирсинга."
when "skin"
"Кожа 1: основной оттенок тела."
when "eyes"
"Глаза: меняется только радужка."
when "nipples"
"Кожа 2: язык, соски и пах."
when "gear"
"Одежда: слот и канал цвета."
else
"Настройте цвет и примените изменения."
end
end
def self.wheel_hue_for_page(page_key, wheel_hue)
config = page_wheel_config(page_key)
return wrap_hue(wheel_hue) if config["hue_span"] >= 359.9
wrap_hue(config["hue_start"] + (wrap_hue(wheel_hue) / 360.0) * config["hue_span"])
end
def self.wheel_saturation_for_page(page_key, wheel_fraction)
config = page_wheel_config(page_key)
clamp(config["sat_min"] + clamp(wheel_fraction.to_f, 0.0, 1.0) * (config["sat_max"] - config["sat_min"]), 0.0, 255.0)
end
def self.profile_hue_to_wheel_angle(page_key, hue)
config = page_wheel_config(page_key)
return wrap_hue(hue) if config["hue_span"] >= 359.9
start_hue = wrap_hue(config["hue_start"])
relative = (wrap_hue(hue) - start_hue) % 360.0
if relative > config["hue_span"]
end_hue = wrap_hue(start_hue + config["hue_span"])
return hue_distance(wrap_hue(hue), start_hue) <= hue_distance(wrap_hue(hue), end_hue) ? 0.0 : 359.99
end
(relative / config["hue_span"]) * 360.0
end
def self.profile_saturation_to_wheel_fraction(page_key, saturation)
config = page_wheel_config(page_key)
range = config["sat_max"] - config["sat_min"]
return clamp(saturation.to_f / 255.0, 0.0, 1.0) if range <= 0.0
clamp((saturation.to_f - config["sat_min"]) / range, 0.0, 1.0)
end
def self.hue_distance(a, b)
diff = (wrap_hue(a) - wrap_hue(b)).abs
diff > 180.0 ? 360.0 - diff : diff
end
def self.normalize_lookup_path(path)
return nil if path.nil?
value = path.to_s.gsub("\\", "/")
value = value.split("@", 2)[0].to_s
return nil if value.empty?
begin
if defined?(BitmapChanger) && BitmapChanger.respond_to?(:normalize_path)
value = BitmapChanger.normalize_path(value).to_s
else
root = Dir.pwd.gsub("\\", "/")
absolute = File.expand_path(value, root).gsub("\\", "/")
value = absolute.start_with?(root + "/") ? absolute[(root.length + 1)..-1] : value
end
rescue
end
value.downcase
end
def self.part_lookup_candidates(part, filename)
candidates = []
candidates << normalize_lookup_path(filename)
root_folder = (part.respond_to?(:root_folder) ? part.root_folder : nil).to_s
if !root_folder.empty? && !filename.to_s.empty?
candidates << normalize_lookup_path("#{root_folder}#{filename}")
end
candidates.compact.uniq
end
def self.palette_entry_source_paths(entry)
paths = Array(entry["palette_old"])
Array(entry["palettes"]).each do |palette_entry|
next unless palette_entry.is_a?(Hash)
paths.concat(Array(palette_entry["palette_old"]))
end
paths.compact.map { |path| path.to_s.gsub("\\", "/").downcase }.uniq
end
def self.palette_category_catalog
return @palette_category_catalog if @palette_category_catalog
catalog = {}
CATEGORY_PRIORITY.each { |category| catalog[category] = {} }
seen_files = {}
PALETTE_CATEGORY_SCAN_GLOBS.each do |pattern|
Dir.glob(pattern).sort.each do |json_path|
normalized_json_path = json_path.to_s.gsub("\\", "/")
file_key = normalized_json_path.downcase
next if seen_files[file_key]
seen_files[file_key] = true
payload = begin
if defined?(Ruby310Compat) && Ruby310Compat.respond_to?(:parse_json_file)
Ruby310Compat.parse_json_file(normalized_json_path)
else
JSON.decode(File.binread(normalized_json_path))
end
rescue StandardError => e
log_exception("palette JSON read failed path=#{normalized_json_path.inspect}", e)
nil
end
next if payload.nil?
entries = payload.is_a?(Array) ? payload : [payload]
entries.each do |entry|
next unless entry.is_a?(Hash)
names = Array(entry["names"]).compact
next if names.empty?
categories = palette_entry_source_paths(entry).map { |path| PALETTE_CATEGORY_FROM_SOURCE[path] }.compact.uniq
normalized_names = names.map { |name| normalize_lookup_path(name) }.compact.uniq
next if normalized_names.empty?
normalized_names.each do |normalized_name|
prefer_skin_mouth = categories.include?("skin") && mouth_skin_layer_name?(normalized_name)
categories.each { |category| catalog[category][normalized_name] = true }
catalog["lips"][normalized_name] = true if soft_lips_name?(normalized_name) && !prefer_skin_mouth
catalog["nipples"][normalized_name] = true if soft_nipples_name?(normalized_name)
catalog["vag"][normalized_name] = true if soft_vag_name?(normalized_name)
catalog["skin"][normalized_name] = true if categories.empty? && skin_primary_name?(normalized_name)
end
end
end
end
@palette_category_catalog = catalog
end
def self.read_palette_source_color_keys(relative_path)
full_path = "ModScripts/PaletteChanger/#{relative_path}".gsub("\\", "/")
return {} unless File.exist?(full_path)
data = File.binread(full_path) rescue nil
return {} if data.nil? || data.empty?
keys = {}
bytes = data.unpack("C*")[0, [768, data.bytesize].min]
index = 0
while index + 2 < bytes.length
keys["#{bytes[index]},#{bytes[index + 1]},#{bytes[index + 2]}"] = true
index += 3
end
keys
end
def self.read_palette_source_colors(relative_path)
full_path = "ModScripts/PaletteChanger/#{relative_path}".gsub("\\", "/")
return [] unless File.exist?(full_path)
data = File.binread(full_path) rescue nil
return [] if data.nil? || data.empty?
colors = []
bytes = data.unpack("C*")[0, [768, data.bytesize].min]
index = 0
while index + 2 < bytes.length
colors << [bytes[index], bytes[index + 1], bytes[index + 2]]
index += 3
end
colors
end
def self.palette_source_color_sets
return @palette_source_color_sets if @palette_source_color_sets
sets = Hash.new { |hash, key| hash[key] = {} }
PALETTE_SOURCE_FILES.each do |category, relative_paths|
Array(relative_paths).each do |relative_path|
read_palette_source_color_keys(relative_path).each_key { |key| sets[category][key] = true }
end
end
eye_colors = []
Array(PALETTE_SOURCE_FILES["eyes"]).each { |relative_path| eye_colors.concat(read_palette_source_colors(relative_path)) }
eye_colors.uniq.each do |rgb|
next if eye_skin_pixel?(rgb[0], rgb[1], rgb[2])
next if eye_neutral_pixel?(rgb[0], rgb[1], rgb[2])
next if [rgb[0], rgb[1], rgb[2]].max < 45
sets["eyes_iris"]["#{rgb[0]},#{rgb[1]},#{rgb[2]}"] = true
end
hair_colors = read_palette_source_colors("source_mc/hair.act").uniq.reject do |rgb|
([rgb[0], rgb[1], rgb[2]].max < 20) || (([rgb[0], rgb[1], rgb[2]].max - [rgb[0], rgb[1], rgb[2]].min) < 8)
end
sorted_hair = hair_colors.sort_by { |rgb| color_luma(rgb[0], rgb[1], rgb[2]) }
highlight_start = [[(sorted_hair.length * 0.68).floor, 0].max, sorted_hair.length].min
(sorted_hair[highlight_start..-1] || []).each do |rgb|
sets["hair_highlight"]["#{rgb[0]},#{rgb[1]},#{rgb[2]}"] = true
end
soft_tissue_palette_samples.each do |rgb|
sets["skin_secondary_soft"]["#{rgb[0]},#{rgb[1]},#{rgb[2]}"] = true
end
@palette_source_color_sets = sets
end
def self.soft_tissue_palette_samples
return @soft_tissue_palette_samples if @soft_tissue_palette_samples
@soft_tissue_palette_samples = read_palette_source_colors("source_mc/tongue.act").uniq.reject do |rgb|
rgb[0] <= 8 && rgb[1] >= 248 && rgb[2] >= 248
end
end
def self.eye_iris_palette_samples
return @eye_iris_palette_samples if @eye_iris_palette_samples
eye_colors = []
Array(PALETTE_SOURCE_FILES["eyes"]).each { |relative_path| eye_colors.concat(read_palette_source_colors(relative_path)) }
@eye_iris_palette_samples = eye_colors.uniq.reject do |rgb|
eye_skin_pixel?(rgb[0], rgb[1], rgb[2]) || eye_neutral_pixel?(rgb[0], rgb[1], rgb[2]) || [rgb[0], rgb[1], rgb[2]].max < 45
end
end
def self.eye_iris_source_pixel?(red, green, blue)
matches_palette_color?(red, green, blue, eye_iris_palette_samples, 10)
end
def self.palette_source_pixel?(category, red, green, blue)
set = palette_source_color_sets[category.to_s]
return false if set.nil? || set.empty?
set["#{red},#{green},#{blue}"] ? true : false
end
def self.gear_profile_key(slot_key, layer_key)
"#{slot_key}_#{layer_key}"
end
def self.gear_profile_keys_for_category(category)
GEAR_LAYER_ORDER.map { |layer_key| gear_profile_key(category.to_s, layer_key) }
end
def self.piercing_category_for_blob(blob)
value = blob.to_s
return nil unless value.include?("piercing")
return "piercing_nipple" if value.include?("piercingchest")
return "piercing_arm" if value.include?("piercingarm") || value.include?("piercingback")
return "piercing_belly" if value.include?("piercingbelly")
return "piercing_vag" if value.include?("piercingvag") || value.include?("piercinganal")
"piercing_face"
end
def self.gear_slot_for_blob(blob)
value = blob.to_s
return nil if value.empty?
return nil unless value.include?("equip") || value.include?("glass") || value.include?("helmet") || value.include?("cloak") || value.include?("robe") || value.include?("weapon") || value.include?("shield") || value.include?("panty") || value.include?("tail") || value.include?("amulet") || value.include?("choker")
return nil if value.include?("bodypaint") || value.include?("tattoo")
return "gear_mainhand" if value.include?("weapon") || value.include?("sword") || value.include?("axe") || value.include?("bow") || value.include?("staff")
return "gear_offhand" if value.include?("shield") || value.include?("buckler")
return "gear_vag" if value.include?("panty") || value.include?("equip_vag")
return "gear_anal" if value.include?("tail") || value.include?("equip_anal")
return "gear_face" if value.include?("equip_face") || value.include?("painthead") || value.include?("faceequip")
return "gear_neck" if value.include?("neck") || value.include?("choker") || value.include?("amulet") || value.include?("collar")
return "gear_top_extra" if value.include?("topext") || value.include?("top_extra") || value.include?("topext")
return "gear_mid_extra" if value.include?("midext") || value.include?("mid_extra") || value.include?("midextra")
return "gear_outer" if value.include?("cloak") || value.include?("robe") || value.include?("cape") || value.include?("ext")
return "gear_mid" if value.include?("mid")
return "gear_top" if value.include?("top") || value.include?("bra")
return "gear_bottom" if value.include?("boot") || value.include?("shoe") || value.include?("bot") || value.include?("leg")
return "gear_head" if value.include?("glass") || value.include?("helmet") || value.include?("hood") || value.include?("veil") || value.include?("mask") || value.include?("dochead") || value.include?("scholarhead") || value.include?("headequip") || value.include?("equip_head")
nil
end
def self.secondary_skin_context_for_part(part, filename)
part_name = (part.respond_to?(:part_name) ? part.part_name : "").to_s.downcase
root_folder = (part.respond_to?(:root_folder) ? part.root_folder : "").to_s.downcase
file_name = filename.to_s.downcase
blob = [part_name, root_folder, file_name].join("|")
{
:eye_composite_layer => eye_composite_name?(blob),
:secondary_soft_tissue => blob.include?("mouth") || blob.include?("tongue"),
:mouth_layer => blob.include?("mouth"),
:body_layer => blob.include?("body") || blob.include?("subpose") || blob.include?("preg") || blob.include?("shockbody") || blob.include?("dirt")
}
end
def self.skin_primary_pixel?(red, green, blue)
return true if palette_source_pixel?("skin", red, green, blue)
return false if eye_neutral_pixel?(red, green, blue)
return false if palette_source_pixel?("eyes", red, green, blue)
return false if palette_source_pixel?("hair_primary", red, green, blue)
return false if secondary_tissue_pixel?(red, green, blue)
likely_skin_pixel?(red, green, blue)
end
def self.secondary_tissue_pixel?(red, green, blue)
return false if eye_neutral_pixel?(red, green, blue)
return false if palette_source_pixel?("skin", red, green, blue)
return true if matches_palette_color?(red, green, blue, soft_tissue_palette_samples, 28)
max_value = [red, green, blue].max
min_value = [red, green, blue].min
chroma = max_value - min_value
luma = color_luma(red, green, blue)
return false if luma < 16.0 || luma > 244.0
return false if chroma < 9
red >= green + 4 && red >= blue - 10
end
def self.secondary_body_tissue_pixel?(red, green, blue)
return true if secondary_tissue_pixel?(red, green, blue)
return false if eye_neutral_pixel?(red, green, blue)
return false if palette_source_pixel?("skin", red, green, blue)
max_value = [red, green, blue].max
min_value = [red, green, blue].min
chroma = max_value - min_value
luma = color_luma(red, green, blue)
return false if luma < 18.0 || luma > 242.0
return false if chroma < 6
red >= green - 6 && red >= blue - 8
end
def self.overlay_zone_cache
@overlay_zone_cache ||= {}
end
def self.portrait_source_part_catalog
@portrait_source_part_catalog ||= begin
catalog = {}
source_data = ($data_lona_portrait && $data_lona_portrait[1]).is_a?(Hash) ? $data_lona_portrait[1] : {}
source_data.each_value do |parts|
next unless parts.is_a?(Array)
parts.each do |prt|
next if prt.nil?
name = (prt.respond_to?(:part_name) ? prt.part_name : nil).to_s
next if name.empty?
catalog[name] ||= []
catalog[name] << prt
end
end
catalog
end
end
def self.body_overlay_part_names_for_part(part, kind)
part_name = body_overlay_search_stem((part.respond_to?(:part_name) ? part.part_name : "").to_s)
return [] if part_name.empty?
case kind.to_sym
when :nipples
["#{part_name}_MelaninMNipple", "#{part_name}_MelaninSNipple"]
when :vag
["#{part_name}_EffectBleedVag", "#{part_name}_EffectBleedAnal", "#{part_name}_MelaninVag", "#{part_name}_MelaninAnal"]
else
[]
end
end
def self.body_overlay_parts_for_body_part(part, kind)
candidates = body_overlay_part_names_for_part(part, kind).flat_map do |name|
portrait_source_part_catalog[name] || []
end
root_folder = (part.respond_to?(:root_folder) ? part.root_folder : "").to_s.downcase
exact = candidates.select do |candidate|
(candidate.respond_to?(:root_folder) ? candidate.root_folder : "").to_s.downcase == root_folder
end
exact.empty? ? candidates : exact
end
def self.first_bitmap_filename_for_part(part)
bitmaps = part.bitmaps rescue nil
return nil if bitmaps.nil? || !bitmaps.respond_to?(:values)
bitmaps.values.find { |value| value && !value.to_s.empty? }
end
def self.body_overlay_base_name(filename)
body_overlay_search_stem(filename)
end
def self.body_overlay_candidates(filename, kind)
base = body_overlay_base_name(filename)
return [] if base.empty?
case kind.to_sym
when :nipples
["#{base}_MelaninMNipple.png", "#{base}_MelaninSNipple.png"]
when :vag
["#{base}_EffectBleedVag.png", "#{base}_EffectBleedAnal.png", "#{base}_MelaninVag.png", "#{base}_MelaninAnal.png"]
else
[]
end
end
def self.root_folder_png_catalog(root_folder)
@root_folder_png_catalog ||= {}
key = root_folder.to_s.downcase
@root_folder_png_catalog[key] ||= begin
Dir.entries(root_folder.to_s).select { |entry| entry.to_s.downcase.end_with?(".png") }
rescue
[]
end
end
def self.overlay_candidate_score(source_stem, candidate_stem)
source_tokens = source_stem.to_s.downcase.split("_").reject { |token| token.empty? }
candidate_tokens = candidate_stem.to_s.downcase.split("_").reject { |token| token.empty? }
return nil if source_tokens.empty? || candidate_tokens.empty?
return nil unless candidate_tokens[0] == source_tokens[0]
shared = candidate_tokens.inject(0) { |sum, token| source_tokens.include?(token) ? sum + 1 : sum }
extra = candidate_tokens.inject(0) { |sum, token| source_tokens.include?(token) ? sum : sum + 1 }
missing = source_tokens.inject(0) { |sum, token| candidate_tokens.include?(token) ? sum : sum + 1 }
shared * 12 - extra * 4 - missing
end
def self.body_overlay_file_candidates(root_folder, filename, suffixes)
return [] if root_folder.to_s.empty?
source_stem = body_overlay_search_stem(filename)
return [] if source_stem.empty?
root_folder_png_catalog(root_folder).map do |entry|
matched_suffix = suffixes.find { |suffix| entry.to_s.downcase.end_with?(suffix.to_s.downcase) }
next nil if matched_suffix.nil?
candidate_stem = entry[0, entry.length - matched_suffix.length]
score = overlay_candidate_score(source_stem, candidate_stem)
next nil if score.nil?
[score, entry.to_s]
end.compact.sort_by { |entry| [-entry[0], entry[1]] }.map { |entry| entry[1] }.uniq
end
def self.body_effect_bleed_candidates(root_folder, filename)
stem = body_overlay_search_stem(filename)
return [] if stem.empty?
suffixes = ["_EffectBleedVag.png"]
downcased = stem.downcase
if downcased.include?("analopen") || downcased.include?("sphincter") || downcased.include?("_anal")
suffixes << "_EffectBleedAnal.png"
end
body_overlay_file_candidates(root_folder, filename, suffixes)
end
def self.alpha_bounds_for_bitmap(bitmap, min_alpha = 1)
return nil if bitmap.nil?
threshold = [min_alpha.to_i, 1].max
x1 = nil
y1 = nil
x2 = nil
y2 = nil
x = 0
while x < bitmap.width
y = 0
while y < bitmap.height
pixel = bitmap.get_pixel(x, y)
if pixel && pixel.alpha.to_i >= threshold
x1 = x if x1.nil? || x < x1
y1 = y if y1.nil? || y < y1
x2 = x if x2.nil? || x > x2
y2 = y if y2.nil? || y > y2
end
y += 1
end
x += 1
end
return nil if x1.nil?
{ :x1 => x1, :y1 => y1, :x2 => x2, :y2 => y2, :width => bitmap.width, :height => bitmap.height }
rescue => e
audit_error("alpha_bounds_for_bitmap failed #{e.class}: #{e.message}")
nil
end
def self.normalized_zone_from_bounds(bounds, padding = 0)
return nil if bounds.nil?
width = [bounds[:width].to_i - 1, 1].max.to_f
height = [bounds[:height].to_i - 1, 1].max.to_f
{
:x1 => clamp((bounds[:x1].to_f - padding.to_f) / width, 0.0, 1.0),
:y1 => clamp((bounds[:y1].to_f - padding.to_f) / height, 0.0, 1.0),
:x2 => clamp((bounds[:x2].to_f + padding.to_f) / width, 0.0, 1.0),
:y2 => clamp((bounds[:y2].to_f + padding.to_f) / height, 0.0, 1.0)
}
end
def self.merge_normalized_zones(zones)
valid = zones.compact
return nil if valid.empty?
{
:x1 => valid.map { |zone| zone[:x1].to_f }.min,
:y1 => valid.map { |zone| zone[:y1].to_f }.min,
:x2 => valid.map { |zone| zone[:x2].to_f }.max,
:y2 => valid.map { |zone| zone[:y2].to_f }.max
}
end
def self.normalize_zone_collection(zones)
valid = zones.compact
return nil if valid.empty?
return valid[0] if valid.length == 1
valid
end
def self.soft_zone_padding(kind)
case kind.to_sym
when :nipples
4
when :vag
0
else
0
end
end
def self.soft_zone_alpha_threshold(kind, overlay_name = nil)
override = SOFT_MASK_ALPHA_THRESHOLDS[overlay_name.to_s.downcase]
return override if override
case kind.to_sym
when :nipples
24
when :vag
name = overlay_name.to_s.downcase
return(name.include?("effectbleedanal") ? 36 : 20) if name.include?("effectbleed")
name.include?("anal") ? 80 : 96
else
1
end
end
# ── Painted mask system ──────────────────────────────────────────────
# Masks are hand-painted body PNG copies in Masks/ folder.
# Marker colors: White=nipple, Green=vagina, Dark Blue=anus.
PAINTED_MASK_FOLDER = "ModScripts/_Mods/LonaPaletteStudio/Masks"
# 0=none, 1=nipple, 2=vag, 3=anus
PMASK_NONE = 0
PMASK_NIPPLE = 1
PMASK_VAG = 2
PMASK_ANUS = 3
def self.painted_mask_cache
@painted_mask_cache ||= {}
end
def self.clear_painted_mask_cache!
@painted_mask_cache = {}
@painted_mask_marker_presence_cache = {}
@painted_mask_directory_entries = nil
end
def self.painted_mask_marker_presence_cache
@painted_mask_marker_presence_cache ||= {}
end
def self.painted_mask_directory_entries
@painted_mask_directory_entries ||= begin
Dir.entries(PAINTED_MASK_FOLDER).select { |entry| entry.to_s.downcase.end_with?(".png") }
rescue
[]
end
end
def self.painted_mask_marker_id(kind)
case kind.to_sym
when :nipples then PMASK_NIPPLE
when :vag then PMASK_VAG
when :anus then PMASK_ANUS
else PMASK_NONE
end
end
def self.painted_mask_file_has_marker?(mask_name, kind)
marker_id = painted_mask_marker_id(kind)
return false if marker_id == PMASK_NONE
file_key = mask_name.to_s.downcase
cache_key = [file_key, marker_id]
return painted_mask_marker_presence_cache[cache_key] if painted_mask_marker_presence_cache.key?(cache_key)
mask_path = "#{PAINTED_MASK_FOLDER}/#{mask_name}"
unless File.exist?(mask_path)
painted_mask_marker_presence_cache[cache_key] = false
return false
end
mask_bmp = nil
begin
mask_bmp = Bitmap.new(mask_path)
found = false
raw = bitmap_rgba_data(mask_bmp)
if raw
offset = 0
raw_length = raw.bytesize
while offset + 3 < raw_length
alpha = raw.getbyte(offset + 3)
if alpha && alpha > 0
red = raw.getbyte(offset)
green = raw.getbyte(offset + 1)
blue = raw.getbyte(offset + 2)
if painted_mask_marker(red, green, blue) == marker_id
found = true
break
end
end
offset += RGBA_BYTES_PER_PIXEL
end
else
y = 0
while y < mask_bmp.height && !found
x = 0
while x < mask_bmp.width
color = mask_bmp.get_pixel(x, y)
if color && color.alpha.to_i > 0 && painted_mask_marker(color.red, color.green, color.blue) == marker_id
found = true
break
end
x += 1
end
y += 1
end
end
painted_mask_marker_presence_cache[cache_key] = found
found
rescue => e
audit_error("painted mask marker scan failed #{mask_path}: #{e.class}: #{e.message}")
painted_mask_marker_presence_cache[cache_key] = false
false
ensure
if mask_bmp && mask_bmp.respond_to?(:dispose)
mask_bmp.dispose unless mask_bmp.respond_to?(:disposed?) && mask_bmp.disposed?
end
end
end
def self.painted_body_mask_exists_for_overlay?(filename, kind)
base = File.basename(filename.to_s).sub(/\.png\z/i, "")
stem = base.sub(/_(?:EffectBleedVag|EffectBleedAnal|MelaninVag|MelaninAnal|MelaninMNipple|MelaninSNipple)\z/i, "")
families = [stem]
closed = stem.sub(/_(?:vagopen|analopen)\z/i, "")
families << closed unless closed == stem
candidates = []
families.each do |family|
next if family.to_s.empty?
candidates.concat([
"#{family}_body_low.png",
"#{family}_body.png",
"#{family}_body_high.png",
"#{family}_body_mid.png",
"#{family}_body_top.png",
"#{family}_body_bot.png"
])
prefix = "#{family}_".downcase
painted_mask_directory_entries.each do |entry|
entry_name = entry.to_s
entry_downcase = entry_name.downcase
next unless entry_downcase.start_with?(prefix)
next unless entry_downcase =~ /_body(?:_(?:low|high|mid|top|bot))?\.png\z/i
candidates << entry_name
end
end
candidates.uniq.any? { |mask_name| painted_mask_file_has_marker?(mask_name, kind) }
end
def self.painted_mask_marker(red, green, blue)
return PMASK_NIPPLE if red >= 248 && green >= 248 && blue >= 248
return PMASK_VAG if green >= 192 && red <= 64 && blue <= 64
return PMASK_ANUS if blue >= 96 && red <= 48 && green <= 48
PMASK_NONE
end
def self.painted_mask_key_for(marker)
case marker
when PMASK_NIPPLE then :nipples
when PMASK_VAG then :vag
when PMASK_ANUS then :anus
else nil
end
end
def self.load_painted_mask(filename, expected_width, expected_height)
fname = filename.to_s.downcase
cache_key = [fname, expected_width.to_i, expected_height.to_i]
return painted_mask_cache[cache_key] if painted_mask_cache.key?(cache_key)
base = File.basename(filename.to_s)
mask_path = "#{PAINTED_MASK_FOLDER}/#{base}"
unless File.exist?(mask_path)
mask_path = "#{PAINTED_MASK_FOLDER}/#{base}.png" unless base =~ /\.png\z/i
unless File.exist?(mask_path)
painted_mask_cache[cache_key] = nil
return nil
end
end
mask_bmp = nil
begin
mask_bmp = Bitmap.new(mask_path)
if mask_bmp.width != expected_width.to_i || mask_bmp.height != expected_height.to_i
audit_error("painted mask size mismatch #{mask_path} expected #{expected_width}x#{expected_height} got #{mask_bmp.width}x#{mask_bmp.height}")
painted_mask_cache[cache_key] = nil
return nil
end
pixel_count = expected_width.to_i * expected_height.to_i
mask_data = Array.new(pixel_count, PMASK_NONE)
marked_count = 0
raw = bitmap_rgba_data(mask_bmp)
if raw
offset = 0
idx = 0
raw_length = raw.bytesize
while offset + 3 < raw_length
alpha = raw.getbyte(offset + 3)
if alpha && alpha > 0
red = raw.getbyte(offset)
green = raw.getbyte(offset + 1)
blue = raw.getbyte(offset + 2)
marker = painted_mask_marker(red, green, blue)
if marker != PMASK_NONE
mask_data[idx] = marker
marked_count += 1
end
end
offset += RGBA_BYTES_PER_PIXEL
idx += 1
end
else
y = 0
while y < expected_height.to_i
x = 0
while x < expected_width.to_i
color = mask_bmp.get_pixel(x, y)
if color && color.alpha > 0
marker = painted_mask_marker(color.red, color.green, color.blue)
if marker != PMASK_NONE
mask_data[y * expected_width.to_i + x] = marker
marked_count += 1
end
end
x += 1
end
y += 1
end
end
result = {
:data => mask_data,
:width => expected_width.to_i,
:height => expected_height.to_i,
:marked_count => marked_count
}
log("painted mask loaded #{mask_path} #{expected_width}x#{expected_height} marked=#{marked_count}") if $rps_audit_log_palette_studio
painted_mask_cache[cache_key] = result
result
rescue => e
audit_error("painted mask load failed #{mask_path}: #{e.class}: #{e.message}")
painted_mask_cache[cache_key] = nil
nil
ensure
if mask_bmp && mask_bmp.respond_to?(:dispose)
mask_bmp.dispose unless mask_bmp.respond_to?(:disposed?) && mask_bmp.disposed?
end
end
end
def self.painted_mask_target_at(mask, pixel_x, pixel_y)
return nil if mask.nil?
data = mask[:data]
return nil if data.nil?
idx = pixel_y.to_i * mask[:width].to_i + pixel_x.to_i
return nil if idx < 0 || idx >= data.size
marker = data[idx]
painted_mask_key_for(marker)
end
# ── End painted mask system ──────────────────────────────────────────
def self.merge_span_ranges(ranges)
valid = ranges.compact.map { |range| [range[0].to_i, range[1].to_i] }
return [] if valid.empty?
sorted = valid.sort_by { |range| [range[0], range[1]] }
merged = [sorted.shift]
sorted.each do |range|
last = merged[-1]
if range[0] <= last[1] + 1
last[1] = [last[1], range[1]].max
else
merged << range
end
end
merged
end
def self.alpha_row_spans_for_bitmap(bitmap, alpha_threshold)
return nil if bitmap.nil?
threshold = [alpha_threshold.to_i, 1].max
rows = {}
y = 0
while y < bitmap.height
row_ranges = []
x = 0
range_start = nil
while x < bitmap.width
pixel = bitmap.get_pixel(x, y)
visible = pixel && pixel.alpha.to_i >= threshold
if visible
range_start = x if range_start.nil?
elsif !range_start.nil?
row_ranges << [range_start, x - 1]
range_start = nil
end
x += 1
end
row_ranges << [range_start, bitmap.width - 1] if !range_start.nil?
rows[y] = merge_span_ranges(row_ranges) unless row_ranges.empty?
y += 1
end
rows
rescue => e
audit_error("alpha_row_spans_for_bitmap failed #{e.class}: #{e.message}")
nil
end
def self.mask_bounds_from_rows(rows)
return nil if rows.nil? || rows.empty?
x1 = nil
y1 = nil
x2 = nil
y2 = nil
rows.each do |row_y, spans|
next if spans.nil? || spans.empty?
y1 = row_y if y1.nil? || row_y < y1
y2 = row_y if y2.nil? || row_y > y2
spans.each do |span|
x1 = span[0] if x1.nil? || span[0] < x1
x2 = span[1] if x2.nil? || span[1] > x2
end
end
return nil if x1.nil? || y1.nil?
{ :x1 => x1, :y1 => y1, :x2 => x2, :y2 => y2 }
end
def self.mask_shape_from_bitmap(bitmap, overlay_name, local_offset_x, local_offset_y, body_bitmap_width, body_bitmap_height, alpha_threshold, padding = 0)
rows = alpha_row_spans_for_bitmap(bitmap, alpha_threshold)
return nil if rows.nil? || rows.empty?
bounds = mask_bounds_from_rows(rows)
return nil if bounds.nil?
width = [body_bitmap_width.to_i - 1, 1].max.to_f
height = [body_bitmap_height.to_i - 1, 1].max.to_f
span_count = rows.values.inject(0) { |sum, spans| sum + spans.length }
{
:type => :mask,
:name => overlay_name.to_s.downcase,
:offset_x => local_offset_x.to_i,
:offset_y => local_offset_y.to_i,
:source_width => bitmap.width,
:source_height => bitmap.height,
:rows => rows,
:row_count => rows.length,
:span_count => span_count,
:x1 => clamp((local_offset_x.to_f + bounds[:x1].to_f - padding.to_f) / width, 0.0, 1.0),
:y1 => clamp((local_offset_y.to_f + bounds[:y1].to_f - padding.to_f) / height, 0.0, 1.0),
:x2 => clamp((local_offset_x.to_f + bounds[:x2].to_f + padding.to_f) / width, 0.0, 1.0),
:y2 => clamp((local_offset_y.to_f + bounds[:y2].to_f + padding.to_f) / height, 0.0, 1.0)
}
rescue => e
audit_error("mask_shape_from_bitmap failed overlay=#{overlay_name.inspect} #{e.class}: #{e.message}")
nil
end
def self.body_vag_seed_pixel?(red, green, blue)
return false if eye_neutral_pixel?(red, green, blue)
return false if palette_source_pixel?("skin", red, green, blue)
return true if matches_palette_color?(red, green, blue, soft_tissue_palette_samples, 24)
max_value = [red, green, blue].max
min_value = [red, green, blue].min
chroma = max_value - min_value
luma = color_luma(red, green, blue)
return false if luma < 16.0 || luma > 232.0
return false if chroma < 8
red >= green - 10 && red >= blue - 12
end
def self.body_vag_fill_pixel?(red, green, blue, seed_samples)
return false if eye_neutral_pixel?(red, green, blue)
return false if palette_source_pixel?("skin", red, green, blue)
return true if secondary_tissue_pixel?(red, green, blue)
return false unless secondary_body_tissue_pixel?(red, green, blue)
return false if seed_samples.nil? || seed_samples.empty?
seed_samples.any? do |sample|
color_distance_sq(red, green, blue, sample[0], sample[1], sample[2]) <= (44 * 44)
end
end
def self.mask_shape_from_body_rows(rows, overlay_name, body_bitmap_width, body_bitmap_height, padding = 0)
return nil if rows.nil? || rows.empty?
bounds = mask_bounds_from_rows(rows)
return nil if bounds.nil?
width = [body_bitmap_width.to_i - 1, 1].max.to_f
height = [body_bitmap_height.to_i - 1, 1].max.to_f
span_count = rows.values.inject(0) { |sum, spans| sum + spans.length }
{
:type => :mask,
:name => overlay_name.to_s.downcase,
:offset_x => 0,
:offset_y => 0,
:source_width => body_bitmap_width.to_i,
:source_height => body_bitmap_height.to_i,
:rows => rows,
:row_count => rows.length,
:span_count => span_count,
:x1 => clamp((bounds[:x1].to_f - padding.to_f) / width, 0.0, 1.0),
:y1 => clamp((bounds[:y1].to_f - padding.to_f) / height, 0.0, 1.0),
:x2 => clamp((bounds[:x2].to_f + padding.to_f) / width, 0.0, 1.0),
:y2 => clamp((bounds[:y2].to_f + padding.to_f) / height, 0.0, 1.0)
}
end
def self.seeded_body_mask_from_overlay(body_bitmap, overlay_bitmap, overlay_name, local_offset_x, local_offset_y, alpha_threshold, padding = 0)
return nil if body_bitmap.nil? || overlay_bitmap.nil?
overlay_rows = alpha_row_spans_for_bitmap(overlay_bitmap, alpha_threshold)
return nil if overlay_rows.nil? || overlay_rows.empty?
overlay_bounds = mask_bounds_from_rows(overlay_rows)
return nil if overlay_bounds.nil?
seed_samples = []
seed_points = []
overlay_rows.each do |overlay_y, spans|
spans.each do |span|
x = span[0].to_i
while x <= span[1].to_i
body_x = local_offset_x.to_i + x
body_y = local_offset_y.to_i + overlay_y.to_i
if body_x >= 0 && body_y >= 0 && body_x < body_bitmap.width && body_y < body_bitmap.height
pixel = body_bitmap.get_pixel(body_x, body_y)
if pixel && pixel.alpha.to_i > 0 && body_vag_seed_pixel?(pixel.red, pixel.green, pixel.blue)
seed_points << [body_x, body_y]
seed_samples << [pixel.red, pixel.green, pixel.blue]
end
end
x += 1
end
end
end
search_x1 = [local_offset_x.to_i + overlay_bounds[:x1].to_i - 14, 0].max
search_y1 = [local_offset_y.to_i + overlay_bounds[:y1].to_i - 14, 0].max
search_x2 = [local_offset_x.to_i + overlay_bounds[:x2].to_i + 14, body_bitmap.width - 1].min
search_y2 = [local_offset_y.to_i + overlay_bounds[:y2].to_i + 14, body_bitmap.height - 1].min
if seed_points.empty?
center_x = (search_x1 + search_x2) / 2.0
center_y = (search_y1 + search_y2) / 2.0
fallback = []
y = search_y1
while y <= search_y2
x = search_x1
while x <= search_x2
pixel = body_bitmap.get_pixel(x, y)
if pixel && pixel.alpha.to_i > 0 && body_vag_seed_pixel?(pixel.red, pixel.green, pixel.blue)
distance = ((x - center_x) * (x - center_x)) + ((y - center_y) * (y - center_y))
fallback << [distance, x, y, [pixel.red, pixel.green, pixel.blue]]
end
x += 1
end
y += 1
end
fallback.sort_by! { |entry| entry[0] }
(fallback[0, 24] || []).each do |entry|
seed_points << [entry[1], entry[2]]
seed_samples << entry[3]
end
end
return nil if seed_points.empty?
seed_samples = seed_samples.uniq[0, 24]
rows = {}
visited = {}
queue = seed_points.uniq
queue_index = 0
while queue_index < queue.length
current = queue[queue_index]
queue_index += 1
x = current[0].to_i
y = current[1].to_i
next if x < search_x1 || y < search_y1 || x > search_x2 || y > search_y2
key = "#{x},#{y}"
next if visited[key]
visited[key] = true
pixel = body_bitmap.get_pixel(x, y)
next if pixel.nil? || pixel.alpha.to_i <= 0
next unless body_vag_fill_pixel?(pixel.red, pixel.green, pixel.blue, seed_samples)
rows[y] ||= []
rows[y] << [x, x]
queue << [x - 1, y]
queue << [x + 1, y]
queue << [x, y - 1]
queue << [x, y + 1]
queue << [x - 1, y - 1]
queue << [x + 1, y - 1]
queue << [x - 1, y + 1]
queue << [x + 1, y + 1]
end
return nil if rows.empty?
rows.keys.each do |row_y|
rows[row_y] = merge_span_ranges(rows[row_y])
end
mask_shape_from_body_rows(rows, overlay_name, body_bitmap.width, body_bitmap.height, padding)
rescue => e
audit_error("seeded_body_mask_from_overlay failed overlay=#{overlay_name.inspect} #{e.class}: #{e.message}")
nil
end
def self.body_vag_mask_from_overlay_part(body_part, body_filename, overlay_part, padding, alpha_threshold = 1)
return nil if body_part.nil? || overlay_part.nil?
body_root = (body_part.respond_to?(:root_folder) ? body_part.root_folder : "").to_s
body_file = body_filename.to_s
overlay_root = (overlay_part.respond_to?(:root_folder) ? overlay_part.root_folder : "").to_s
overlay_file = first_bitmap_filename_for_part(overlay_part)
return nil if body_root.empty? || body_file.empty? || overlay_root.empty? || overlay_file.nil?
body_bitmap = Cache.load_part(body_root, "/" + body_file)
overlay_bitmap = Cache.load_part(overlay_root, "/" + overlay_file)
body_x = body_part.respond_to?(:posX) ? body_part.posX.to_i : 0
body_y = body_part.respond_to?(:posY) ? body_part.posY.to_i : 0
overlay_x = overlay_part.respond_to?(:posX) ? overlay_part.posX.to_i : 0
overlay_y = overlay_part.respond_to?(:posY) ? overlay_part.posY.to_i : 0
overlay_name = (overlay_part.respond_to?(:part_name) ? overlay_part.part_name : overlay_file).to_s
seeded_body_mask_from_overlay(body_bitmap, overlay_bitmap, overlay_name, overlay_x - body_x, overlay_y - body_y, alpha_threshold, padding)
rescue => e
audit_error("body_vag_mask_from_overlay_part failed #{e.class}: #{e.message}")
nil
end
def self.mask_from_overlay_part(body_part, overlay_part, bitmap_width, bitmap_height, padding, alpha_threshold = 1)
return nil if body_part.nil? || overlay_part.nil?
root_folder = (overlay_part.respond_to?(:root_folder) ? overlay_part.root_folder : "").to_s
filename = first_bitmap_filename_for_part(overlay_part)
return nil if root_folder.empty? || filename.nil?
bitmap = Cache.load_part(root_folder, "/" + filename)
body_x = body_part.respond_to?(:posX) ? body_part.posX.to_i : 0
body_y = body_part.respond_to?(:posY) ? body_part.posY.to_i : 0
overlay_x = overlay_part.respond_to?(:posX) ? overlay_part.posX.to_i : 0
overlay_y = overlay_part.respond_to?(:posY) ? overlay_part.posY.to_i : 0
overlay_name = (overlay_part.respond_to?(:part_name) ? overlay_part.part_name : filename).to_s
mask_shape_from_bitmap(bitmap, overlay_name, overlay_x - body_x, overlay_y - body_y, bitmap_width, bitmap_height, alpha_threshold, padding)
rescue => e
audit_error("mask_from_overlay_part failed #{e.class}: #{e.message}")
nil
end
def self.zone_from_overlay_part(body_part, overlay_part, bitmap_width, bitmap_height, padding, alpha_threshold = 1)
return nil if body_part.nil? || overlay_part.nil?
root_folder = (overlay_part.respond_to?(:root_folder) ? overlay_part.root_folder : "").to_s
filename = first_bitmap_filename_for_part(overlay_part)
return nil if root_folder.empty? || filename.nil?
bitmap = Cache.load_part(root_folder, "/" + filename)
bounds = alpha_bounds_for_bitmap(bitmap, alpha_threshold)
return nil if bounds.nil?
body_x = body_part.respond_to?(:posX) ? body_part.posX.to_i : 0
body_y = body_part.respond_to?(:posY) ? body_part.posY.to_i : 0
overlay_x = overlay_part.respond_to?(:posX) ? overlay_part.posX.to_i : 0
overlay_y = overlay_part.respond_to?(:posY) ? overlay_part.posY.to_i : 0
width = [bitmap_width.to_i - 1, 1].max.to_f
height = [bitmap_height.to_i - 1, 1].max.to_f
local_x1 = (overlay_x - body_x) + bounds[:x1].to_i
local_y1 = (overlay_y - body_y) + bounds[:y1].to_i
local_x2 = (overlay_x - body_x) + bounds[:x2].to_i
local_y2 = (overlay_y - body_y) + bounds[:y2].to_i
{
:x1 => clamp((local_x1.to_f - padding.to_f) / width, 0.0, 1.0),
:y1 => clamp((local_y1.to_f - padding.to_f) / height, 0.0, 1.0),
:x2 => clamp((local_x2.to_f + padding.to_f) / width, 0.0, 1.0),
:y2 => clamp((local_y2.to_f + padding.to_f) / height, 0.0, 1.0)
}
rescue => e
audit_error("zone_from_overlay_part failed #{e.class}: #{e.message}")
nil
end
def self.body_soft_zone_for_part(part, filename, bitmap_width, bitmap_height, kind)
root_folder = (part.respond_to?(:root_folder) ? part.root_folder : "").to_s
file_name = filename.to_s
cache_key = [root_folder.downcase, file_name.downcase, bitmap_width.to_i, bitmap_height.to_i, kind.to_s]
return overlay_zone_cache[cache_key] if overlay_zone_cache.key?(cache_key)
padding = soft_zone_padding(kind)
use_mask = kind.to_sym == :vag
zones = body_overlay_parts_for_body_part(part, kind).map do |overlay_part|
overlay_name = (overlay_part.respond_to?(:part_name) ? overlay_part.part_name : first_bitmap_filename_for_part(overlay_part)).to_s
alpha_threshold = soft_zone_alpha_threshold(kind, overlay_name)
if use_mask
if kind.to_sym == :vag
body_vag_mask_from_overlay_part(part, file_name, overlay_part, padding, alpha_threshold) ||
mask_from_overlay_part(part, overlay_part, bitmap_width, bitmap_height, padding, alpha_threshold)
else
mask_from_overlay_part(part, overlay_part, bitmap_width, bitmap_height, padding, alpha_threshold)
end
else
zone_from_overlay_part(part, overlay_part, bitmap_width, bitmap_height, padding, alpha_threshold)
end
end
if zones.compact.empty?
zones = body_overlay_candidates(file_name, kind).map do |candidate|
begin
next nil unless File.exist?("#{root_folder}/#{candidate}")
bitmap = Cache.load_part(root_folder, "/" + candidate)
alpha_threshold = soft_zone_alpha_threshold(kind, candidate)
if use_mask
next nil unless bitmap.width.to_i == bitmap_width.to_i && bitmap.height.to_i == bitmap_height.to_i
mask_shape_from_bitmap(bitmap, candidate, 0, 0, bitmap_width, bitmap_height, alpha_threshold, padding)
else
normalized_zone_from_bounds(alpha_bounds_for_bitmap(bitmap, alpha_threshold), padding)
end
rescue
nil
end
end
end
overlay_zone_cache[cache_key] = normalize_zone_collection(zones)
end
def self.zone_signature(zone)
return "-" if zone.nil?
if zone.is_a?(Array)
return zone.map { |entry| zone_signature(entry) }.join(";")
end
if zone.is_a?(Hash) && zone[:type] == :mask
return [
"mask",
zone[:name].to_s,
zone[:offset_x].to_i,
zone[:offset_y].to_i,
zone[:source_width].to_i,
zone[:source_height].to_i,
zone[:row_count].to_i,
zone[:span_count].to_i,
(zone[:x1].to_f * 1000.0).round,
(zone[:y1].to_f * 1000.0).round,
(zone[:x2].to_f * 1000.0).round,
(zone[:y2].to_f * 1000.0).round
].join(",")
end
[
(zone[:x1].to_f * 1000.0).round,
(zone[:y1].to_f * 1000.0).round,
(zone[:x2].to_f * 1000.0).round,
(zone[:y2].to_f * 1000.0).round
].join(",")
end
def self.pixel_within_zone?(pixel_x, pixel_y, bitmap_width, bitmap_height, zone)
return false if zone.nil?
if zone.is_a?(Array)
return zone.any? { |entry| pixel_within_zone?(pixel_x, pixel_y, bitmap_width, bitmap_height, entry) }
end
return false if pixel_x.nil? || pixel_y.nil?
if zone.is_a?(Hash) && zone[:type] == :mask
local_x = pixel_x.to_i - zone[:offset_x].to_i
local_y = pixel_y.to_i - zone[:offset_y].to_i
return false if local_x < 0 || local_y < 0
return false if local_x >= zone[:source_width].to_i || local_y >= zone[:source_height].to_i
spans = zone[:rows][local_y] rescue nil
return false if spans.nil? || spans.empty?
return spans.any? { |span| local_x >= span[0].to_i && local_x <= span[1].to_i }
end
width = [bitmap_width.to_i - 1, 1].max.to_f
height = [bitmap_height.to_i - 1, 1].max.to_f
x_ratio = pixel_x.to_f / width
y_ratio = pixel_y.to_f / height
x_ratio >= zone[:x1].to_f && x_ratio <= zone[:x2].to_f &&
y_ratio >= zone[:y1].to_f && y_ratio <= zone[:y2].to_f
end
def self.body_soft_target_key_for_pixel(context, pixel_x, pixel_y, bitmap_width, bitmap_height)
return nil if context.nil?
return nil unless context[:painted_mask]
painted_mask_target_at(context[:painted_mask], pixel_x, pixel_y)
end
def self.overlay_alpha_for_target(alpha, target_category, context)
return alpha.to_i if alpha.nil?
return alpha.to_i unless context && context[:secondary_overlay]
return alpha.to_i unless ["nipples", "vag", "anus"].include?(target_category.to_s)
boosted = alpha.to_i + ((216.0 - alpha.to_i) * 0.85)
clamp(boosted.round, alpha.to_i, 240)
end
def self.gear_material_pixel?(red, green, blue)
return false if eye_neutral_pixel?(red, green, blue)
return false if palette_source_pixel?("skin", red, green, blue)
return false if palette_source_pixel?("eyes", red, green, blue)
return false if palette_source_pixel?("hair_primary", red, green, blue)
return false if palette_source_pixel?("skin_secondary_soft", red, green, blue)
max_value = [red, green, blue].max
min_value = [red, green, blue].min
chroma = max_value - min_value
luma = color_luma(red, green, blue)
return false if luma < 14.0
return false if max_value >= 236 && chroma < 10
return false if chroma < 8 && luma < 52.0
chroma >= 12 || luma >= 96.0
end
def self.gear_trim_pixel?(red, green, blue)
return true if palette_source_pixel?("gear_trim", red, green, blue)
max_value = [red, green, blue].max
min_value = [red, green, blue].min
chroma = max_value - min_value
luma = color_luma(red, green, blue)
return false if luma < 26.0
chroma >= 26 && luma >= 78.0
end
def self.gear_metal_pixel?(red, green, blue)
return true if palette_source_pixel?("gear_metal", red, green, blue)
max_value = [red, green, blue].max
min_value = [red, green, blue].min
chroma = max_value - min_value
luma = color_luma(red, green, blue)
return false if luma < 42.0
chroma <= 42 && luma >= 112.0
end
def self.gear_layer_for_pixel(category, red, green, blue)
return "metal" if gear_metal_pixel?(red, green, blue)
return "trim" if gear_trim_pixel?(red, green, blue)
return "base" if palette_source_pixel?(category, red, green, blue) || palette_source_pixel?("gear_base", red, green, blue) || gear_material_pixel?(red, green, blue)
nil
end
def self.page_keywords
@page_keywords ||= {
"hair" => [
"hair", "bang", "pony", "braid", "twin", "tail", "messy", "dancer", "pubichair",
"hairpony", "hairtwi", "hairdanc", "hairmess", "hairshort"
],
"eyes" => [
"subeyes", "_eyes", "head_eyes", "eyes01", "eyes02", "eyes03",
"eyes04", "eyes05", "eyes06", "eyes07", "eyes08"
],
"skin" => [
"skin", "melanin", "body", "head", "face", "arm", "leg",
"breast", "vag", "anal", "torso"
]
}
end
def self.exclusion_keywords
@exclusion_keywords ||= [
"armour", "armor", "cloth", "weapon", "shield", "mask", "helmet",
"hat", "cape", "stocking", "shoe", "boot", "bra", "panty",
"underwear", "bodysuit", "accessory", "blush", "freckle",
"cums", "wound", "shockhead", "slavebrand", "painthead", "headpaint"
]
end
def self.category_for_part(part, filename)
part_name = (part.respond_to?(:part_name) ? part.part_name : "").to_s.downcase
root_folder = (part.respond_to?(:root_folder) ? part.root_folder : "").to_s.downcase
file_name = filename.to_s.downcase
blob = [part_name, root_folder, file_name].join("|")
return nil if blob.empty?
return nil if legacy_skin2_overlay_name?(blob)
piercing_category = piercing_category_for_blob(blob)
return piercing_category if piercing_category
candidates = part_lookup_candidates(part, filename)
candidates.each do |candidate|
return "skin" if head_hair_skin_overlay_name?(candidate)
return "skin" if mouth_skin_layer_name?(candidate) && palette_category_catalog["skin"][candidate]
end
candidates.each do |candidate|
CATEGORY_PRIORITY.each do |category|
return category if palette_category_catalog[category][candidate]
end
end
if page_keywords["eyes"].any? { |value| blob.include?(value) } && !blob.include?("tear")
return "eyes"
end
return "skin" if mouth_skin_layer_name?(blob)
return "skin" if head_hair_skin_overlay_name?(blob)
return "lips" if soft_lips_name?(blob)
return "nipples" if soft_nipples_name?(blob)
return "vag" if soft_vag_name?(blob)
if page_keywords["hair"].any? { |value| blob.include?(value) }
return "hair_primary"
end
gear_slot = gear_slot_for_blob(blob)
return gear_slot if gear_slot
return nil if exclusion_keywords.any? { |value| blob.include?(value) }
if skin_primary_name?(blob)
return "skin"
end
if root_folder.include?("graphics/portrait/lona") || root_folder.include?("graphics/charactercharsets/lonamcc")
if page_keywords["skin"].any? { |value| blob.include?(value) }
return "skin"
end
end
nil
end
def self.hair_highlight_allowed_for_part?(part, filename)
candidates = part_lookup_candidates(part, filename)
candidates.each do |candidate|
value = candidate.to_s
return false if head_hair_skin_overlay_name?(value)
end
part_name = (part.respond_to?(:part_name) ? part.part_name : "").to_s.downcase
root_folder = (part.respond_to?(:root_folder) ? part.root_folder : "").to_s.downcase
file_name = filename.to_s.downcase
blob = [part_name, root_folder, file_name].join("|")
return false if head_hair_skin_overlay_name?(blob)
true
end
def self.filename_for_part_map(part, target)
return nil unless part.respond_to?(:bitmaps)
bitmaps = part.bitmaps rescue nil
return nil if bitmaps.nil? || !bitmaps.respond_to?(:[])
bitmaps[target] rescue nil
end
def self.hsv_to_rgb(hue, saturation, value)
h = hue.to_f % 360.0
s = clamp(saturation.to_f, 0.0, 255.0) / 255.0
v = clamp(value.to_f, 0.0, 255.0) / 255.0
chroma = v * s
x = chroma * (1.0 - (((h / 60.0) % 2.0) - 1.0).abs)
m = v - chroma
r1 = 0.0
g1 = 0.0
b1 = 0.0
case (h / 60.0).floor
when 0
r1, g1, b1 = chroma, x, 0.0
when 1
r1, g1, b1 = x, chroma, 0.0
when 2
r1, g1, b1 = 0.0, chroma, x
when 3
r1, g1, b1 = 0.0, x, chroma
when 4
r1, g1, b1 = x, 0.0, chroma
else
r1, g1, b1 = chroma, 0.0, x
end
[
((r1 + m) * 255.0).round,
((g1 + m) * 255.0).round,
((b1 + m) * 255.0).round
]
end
def self.matches_palette_color?(red, green, blue, palette, tolerance = 6)
palette.any? do |sample|
(red - sample[0]).abs <= tolerance &&
(green - sample[1]).abs <= tolerance &&
(blue - sample[2]).abs <= tolerance
end
end
def self.category_needs_recolor?(category, state_hash)
case category.to_s
when "eyes"
profile_for("skin", state_hash)["enabled"].to_i == 1 || profile_for("eyes", state_hash)["enabled"].to_i == 1
when "skin"
profile_for("skin", state_hash)["enabled"].to_i == 1 ||
profile_for("nipples", state_hash)["enabled"].to_i == 1 ||
profile_for("vag", state_hash)["enabled"].to_i == 1 ||
profile_for("anus", state_hash)["enabled"].to_i == 1
when "lips"
profile_for("skin", state_hash)["enabled"].to_i == 1 || profile_for("lips", state_hash)["enabled"].to_i == 1
when "nipples", "vag", "anus"
profile_for(category, state_hash)["enabled"].to_i == 1
when "hair_primary"
profile_for("hair_primary", state_hash)["enabled"].to_i == 1 || profile_for("hair_highlight", state_hash)["enabled"].to_i == 1
when /\Agear_/
gear_profile_keys_for_category(category).any? { |profile_key| profile_for(profile_key, state_hash)["enabled"].to_i == 1 }
else
profile_for(category, state_hash)["enabled"].to_i == 1
end
end
def self.cache_signature_for_category(category, state_hash)
case category.to_s
when "eyes"
[profile_signature(profile_for("skin", state_hash)), profile_signature(profile_for("eyes", state_hash))].join("|")
when "skin"
[
profile_signature(profile_for("skin", state_hash)),
profile_signature(profile_for("nipples", state_hash)),
profile_signature(profile_for("vag", state_hash)),
profile_signature(profile_for("anus", state_hash))
].join("|")
when "lips"
[profile_signature(profile_for("skin", state_hash)), profile_signature(profile_for("lips", state_hash))].join("|")
when "nipples", "vag", "anus"
[profile_signature(profile_for(category, state_hash)), skin_color_mode(state_hash)].join("|")
when "hair_primary"
[profile_signature(profile_for("hair_primary", state_hash)), profile_signature(profile_for("hair_highlight", state_hash))].join("|")
when /\Agear_/
gear_profile_keys_for_category(category).map { |profile_key| profile_signature(profile_for(profile_key, state_hash)) }.join("|")
else
profile_signature(profile_for(category, state_hash))
end
end
def self.enabled_profile_entry(page_key, state_hash)
profile = profile_for(page_key, state_hash)
return nil if profile["enabled"].to_i == 0
[page_key, profile]
end
def self.eye_skin_pixel?(red, green, blue)
matches_palette_color?(red, green, blue, EYE_SKIN_RGBS, 10)
end
def self.eye_neutral_pixel?(red, green, blue)
max_value = [red, green, blue].max
min_value = [red, green, blue].min
chroma = max_value - min_value
luma = red * 0.299 + green * 0.587 + blue * 0.114
return true if matches_palette_color?(red, green, blue, EYE_NEUTRAL_RGBS, 12)
return true if chroma < 12
return true if max_value >= 170 && chroma <= 52
return true if luma >= 150 && chroma <= 36
return true if max_value <= 48 && chroma <= 18
false
end
def self.eye_iris_pixel?(red, green, blue)
return false if eye_skin_pixel?(red, green, blue)
return false if eye_neutral_pixel?(red, green, blue)
return false if [red, green, blue].max < 45
true
end
def self.dark_red_pixel?(red, green, blue)
red >= 70 && red > green + 20 && red > blue + 12 && green < 128 && blue < 128
end
def self.likely_skin_pixel?(red, green, blue)
return false if [red, green, blue].max < 30
return false if [red, green, blue].max - [red, green, blue].min < 6
red >= green - 15 && red >= blue
end
def self.rgb_to_hsv(red, green, blue)
r = clamp(red.to_f, 0.0, 255.0) / 255.0
g = clamp(green.to_f, 0.0, 255.0) / 255.0
b = clamp(blue.to_f, 0.0, 255.0) / 255.0
max_value = [r, g, b].max
min_value = [r, g, b].min
delta = max_value - min_value
hue = 0.0
if delta > 0.0
if max_value == r
hue = 60.0 * (((g - b) / delta) % 6.0)
elsif max_value == g
hue = 60.0 * (((b - r) / delta) + 2.0)
else
hue = 60.0 * (((r - g) / delta) + 4.0)
end
end
saturation = max_value <= 0.0 ? 0.0 : (delta / max_value) * 255.0
value = max_value * 255.0
[wrap_hue(hue), saturation, value]
end
def self.color_distance_sq(red_a, green_a, blue_a, red_b, green_b, blue_b)
((red_a.to_i - red_b.to_i) ** 2) + ((green_a.to_i - green_b.to_i) ** 2) + ((blue_a.to_i - blue_b.to_i) ** 2)
end
def self.profile_sample_tolerance(profile)
sample = profile_sample_rgb(profile)
return 0 if sample.nil?
max_value = [sample[0], sample[1], sample[2]].max
chroma = max_value - [sample[0], sample[1], sample[2]].min
if max_value <= 48
30
elsif max_value <= 72 || chroma <= 16
28
else
36
end
end
def self.profile_sample_match_distance(profile, red, green, blue)
sample = profile_sample_rgb(profile)
return nil if sample.nil?
distance = color_distance_sq(red, green, blue, sample[0], sample[1], sample[2])
tolerance = profile_sample_tolerance(profile)
return nil if tolerance <= 0 || distance > (tolerance * tolerance)
distance
end
def self.profile_sample_matches_pixel?(profile, red, green, blue)
!profile_sample_match_distance(profile, red, green, blue).nil?
end
def self.closest_gear_sample_target(category, state_hash, red, green, blue)
candidates = []
[
["metal", profile_for(gear_profile_key(category, "metal"), state_hash), enabled_profile_entry(gear_profile_key(category, "metal"), state_hash)],
["trim", profile_for(gear_profile_key(category, "trim"), state_hash), enabled_profile_entry(gear_profile_key(category, "trim"), state_hash)],
["base", profile_for(gear_profile_key(category, "base"), state_hash), enabled_profile_entry(gear_profile_key(category, "base"), state_hash)]
].each do |layer_key, profile, target|
next if target.nil?
distance = profile_sample_match_distance(profile, red, green, blue)
next if distance.nil?
candidates << [distance, layer_key, target]
end
return nil if candidates.empty?
layer_priority = { "metal" => 0, "trim" => 1, "base" => 2 }
candidates.sort_by { |entry| [entry[0], layer_priority[entry[1]] || 9] }.first[2]
end
def self.pixel_target_for(red, green, blue, alpha, category, state_hash, context = nil, pixel_x = nil, pixel_y = nil, bitmap_width = nil, bitmap_height = nil)
return nil if alpha.to_i <= 0
case category.to_s
when "eyes"
skin_target = enabled_profile_entry("skin", state_hash)
eyes_target = enabled_profile_entry("eyes", state_hash)
return skin_target if palette_source_pixel?("skin", red, green, blue) && skin_target
return eyes_target if eye_iris_source_pixel?(red, green, blue) && eyes_target
return skin_target if eye_skin_pixel?(red, green, blue) && skin_target
return nil if palette_source_pixel?("eyes", red, green, blue)
return nil if eye_neutral_pixel?(red, green, blue)
return nil if context && context[:eye_composite_layer]
return eyes_target if eye_iris_pixel?(red, green, blue) && eyes_target
nil
when "skin"
skin_target = enabled_profile_entry("skin", state_hash)
lip_target = enabled_profile_entry("lips", state_hash)
nipple_target = enabled_profile_entry("nipples", state_hash)
vag_target = enabled_profile_entry("vag", state_hash)
anus_target = enabled_profile_entry("anus", state_hash)
if context && context[:mouth_layer]
return lip_target if lip_target && (palette_source_pixel?("skin_secondary_soft", red, green, blue) || secondary_tissue_pixel?(red, green, blue))
return nil if secondary_tissue_pixel?(red, green, blue)
return skin_target if skin_target && skin_primary_pixel?(red, green, blue)
return nil
end
if context && context[:body_layer]
body_soft_key = body_soft_target_key_for_pixel(context, pixel_x, pixel_y, bitmap_width, bitmap_height)
return nipple_target if nipple_target && body_soft_key == :nipples
return vag_target if vag_target && body_soft_key == :vag
return anus_target if anus_target && body_soft_key == :anus
return nil if body_soft_key
return nil if secondary_tissue_pixel?(red, green, blue)
end
return skin_target if skin_target && skin_primary_pixel?(red, green, blue)
nil
when "lips"
skin_target = enabled_profile_entry("skin", state_hash)
lip_target = enabled_profile_entry("lips", state_hash)
if context && context[:mouth_layer]
return lip_target if lip_target && (palette_source_pixel?("skin_secondary_soft", red, green, blue) || secondary_tissue_pixel?(red, green, blue))
return skin_target if skin_target && skin_primary_pixel?(red, green, blue)
end
return nil if lip_target.nil?
return lip_target if palette_source_pixel?("skin_secondary_soft", red, green, blue)
return lip_target if context && context[:secondary_soft_tissue] && secondary_tissue_pixel?(red, green, blue)
nil
when "nipples"
nipple_target = enabled_profile_entry("nipples", state_hash)
return nil if nipple_target.nil?
return nipple_target if context && context[:body_layer] && body_soft_target_key_for_pixel(context, pixel_x, pixel_y, bitmap_width, bitmap_height) == :nipples
nil
when "vag"
vag_target = enabled_profile_entry("vag", state_hash)
return nil if vag_target.nil?
return vag_target if context && context[:body_layer] && body_soft_target_key_for_pixel(context, pixel_x, pixel_y, bitmap_width, bitmap_height) == :vag
nil
when "anus"
anus_target = enabled_profile_entry("anus", state_hash)
return nil if anus_target.nil?
return anus_target if context && context[:body_layer] && body_soft_target_key_for_pixel(context, pixel_x, pixel_y, bitmap_width, bitmap_height) == :anus
nil
when "hair_primary"
highlight_target = (context && context[:allow_hair_secondary] == false) ? nil : enabled_profile_entry("hair_highlight", state_hash)
primary_target = enabled_profile_entry("hair_primary", state_hash)
return highlight_target || primary_target if palette_source_pixel?("hair_highlight", red, green, blue)
return primary_target if palette_source_pixel?("hair_primary", red, green, blue)
nil
when "piercing_face", "piercing_nipple", "piercing_arm", "piercing_belly", "piercing_vag"
piercing_target = enabled_profile_entry(category, state_hash)
return nil if piercing_target.nil?
return piercing_target if palette_source_pixel?("piercing_basic", red, green, blue)
return piercing_target
when /\Agear_/
base_target = enabled_profile_entry(gear_profile_key(category, "base"), state_hash)
trim_target = enabled_profile_entry(gear_profile_key(category, "trim"), state_hash)
metal_target = enabled_profile_entry(gear_profile_key(category, "metal"), state_hash)
sampled_target = closest_gear_sample_target(category, state_hash, red, green, blue)
return sampled_target if sampled_target
layer_key = gear_layer_for_pixel(category, red, green, blue)
return nil if layer_key.nil?
case layer_key
when "metal"
return metal_target || trim_target || base_target
when "trim"
return trim_target || base_target || metal_target
else
return base_target || trim_target || metal_target
end
nil
when "hair_highlight"
nil
else
enabled_profile_entry(category, state_hash)
end
end
def self.skin_family_category?(category)
["skin", "nipples", "vag", "anus"].include?(category.to_s)
end
def self.skin_family_recolor_components(red, green, blue, profile, category, context = nil)
luma = red * 0.299 + green * 0.587 + blue * 0.114
max_value = [red, green, blue].max.to_f
min_value = [red, green, blue].min.to_f
chroma = max_value - min_value
detail = chroma / 255.0
shadow = luma / 255.0
target_h = profile["h"].to_f
target_s = profile["s"].to_f
target_v = profile["v"].to_f
cat = category.to_s
if (context && context[:skin_color_mode].to_s == "solid")
sat = target_s
val = target_v
edge_keep_scale = 0.10
highlight_keep_scale = 0.04
else
case cat
when "nipples"
if context && context[:secondary_overlay]
sat = target_s * (0.92 + detail * 0.18 + shadow * 0.04)
val = target_v * (0.68 + shadow * 0.34)
elsif max_value < 92.0
sat = target_s * (0.58 + detail * 0.42 + shadow * 0.08)
val = target_v * (0.34 + shadow * 0.66)
else
sat = target_s * (0.42 + detail * 0.74 + shadow * 0.08)
val = target_v * (0.24 + shadow * 0.78)
end
when "vag"
if context && context[:secondary_overlay]
sat = target_s * (0.98 + detail * 0.20 + shadow * 0.06)
val = target_v * (0.82 + shadow * 0.24)
elsif max_value < 92.0
sat = target_s * (0.78 + detail * 0.48 + shadow * 0.10)
val = target_v * (0.48 + shadow * 0.66)
else
sat = target_s * (0.66 + detail * 0.78 + shadow * 0.10)
val = target_v * (0.40 + shadow * 0.82)
end
when "anus"
if context && context[:secondary_overlay]
sat = target_s * (0.94 + detail * 0.18 + shadow * 0.06)
val = target_v * (0.72 + shadow * 0.28)
elsif max_value < 92.0
sat = target_s * (0.70 + detail * 0.44 + shadow * 0.10)
val = target_v * (0.42 + shadow * 0.62)
else
sat = target_s * (0.58 + detail * 0.72 + shadow * 0.10)
val = target_v * (0.36 + shadow * 0.78)
end
else
sat = target_s * (0.12 + detail * 0.42 + shadow * 0.18)
val = target_v * (0.32 + shadow * 0.74)
end
edge_keep_scale = 0.82
highlight_keep_scale = 0.18
end
sat = clamp(sat, 0.0, 255.0)
val = clamp(val, 0.0, 255.0)
new_rgb = hsv_to_rgb(target_h, sat, val)
edge_keep = clamp((28.0 - luma) / 28.0, 0.0, 1.0) * edge_keep_scale
highlight_keep = clamp((luma - 232.0) / 23.0, 0.0, 1.0) * highlight_keep_scale
keep = edge_keep + highlight_keep
[
(new_rgb[0] * (1.0 - keep) + red * keep).round,
(new_rgb[1] * (1.0 - keep) + green * keep).round,
(new_rgb[2] * (1.0 - keep) + blue * keep).round
]
end
def self.recolor_components(red, green, blue, profile, category, context = nil)
return skin_family_recolor_components(red, green, blue, profile, category, context) if skin_family_category?(category)
luma = red * 0.299 + green * 0.587 + blue * 0.114
max_value = [red, green, blue].max.to_f
min_value = [red, green, blue].min.to_f
chroma = max_value - min_value
detail = chroma / 255.0
shadow = luma / 255.0
target_h = profile["h"].to_f
target_s = profile["s"].to_f
target_v = profile["v"].to_f
case category.to_s
when "skin"
sat = target_s * (0.12 + detail * 0.42 + shadow * 0.18)
val = target_v * (0.32 + shadow * 0.74)
when "lips"
sat = target_s * (0.44 + detail * 0.72 + shadow * 0.10)
val = target_v * (0.26 + shadow * 0.78)
when "nipples"
if context && context[:secondary_overlay]
sat = target_s * (0.92 + detail * 0.18 + shadow * 0.04)
val = target_v * (0.68 + shadow * 0.34)
elsif max_value < 92.0
sat = target_s * (0.58 + detail * 0.42 + shadow * 0.08)
val = target_v * (0.34 + shadow * 0.66)
else
sat = target_s * (0.42 + detail * 0.74 + shadow * 0.08)
val = target_v * (0.24 + shadow * 0.78)
end
when "vag"
if context && context[:secondary_overlay]
sat = target_s * (0.98 + detail * 0.20 + shadow * 0.06)
val = target_v * (0.82 + shadow * 0.24)
elsif max_value < 92.0
sat = target_s * (0.78 + detail * 0.48 + shadow * 0.10)
val = target_v * (0.48 + shadow * 0.66)
else
sat = target_s * (0.66 + detail * 0.78 + shadow * 0.10)
val = target_v * (0.40 + shadow * 0.82)
end
when "anus"
if context && context[:secondary_overlay]
sat = target_s * (0.94 + detail * 0.18 + shadow * 0.06)
val = target_v * (0.72 + shadow * 0.28)
elsif max_value < 92.0
sat = target_s * (0.70 + detail * 0.44 + shadow * 0.10)
val = target_v * (0.42 + shadow * 0.62)
else
sat = target_s * (0.58 + detail * 0.72 + shadow * 0.10)
val = target_v * (0.36 + shadow * 0.78)
end
when "hair_primary"
sat = target_s * (0.40 + detail * 0.84 + shadow * 0.18)
val = target_v * (0.26 + shadow * 0.92)
when "hair_highlight"
sat = target_s * (0.30 + detail * 0.54 + shadow * 0.12)
val = target_v * (0.44 + shadow * 0.66)
when "eyes"
sat = target_s * (0.54 + detail * 0.62)
val = target_v * (0.34 + shadow * 0.74)
when "piercing_face", "piercing_nipple", "piercing_arm", "piercing_belly", "piercing_vag"
sat = target_s * (0.20 + detail * 0.64)
val = target_v * (0.28 + shadow * 0.74)
when /\Agear_/
sat = target_s * (0.28 + detail * 0.78 + shadow * 0.14)
val = target_v * (0.22 + shadow * 0.88)
else
sat = target_s * (0.32 + detail * 0.92)
val = target_v * (0.18 + shadow * 0.92)
end
sat = clamp(sat, 0.0, 255.0)
val = clamp(val, 0.0, 255.0)
new_rgb = hsv_to_rgb(target_h, sat, val)
edge_keep_scale = case category.to_s
when "hair_primary"
0.22
when "hair_highlight"
0.12
when "piercing_face", "piercing_nipple", "piercing_arm", "piercing_belly", "piercing_vag", /\Agear_/
0.28
when "lips", "nipples"
0.18
when "vag"
0.08
when "anus"
0.10
else
0.82
end
highlight_keep_scale = case category.to_s
when "hair_primary"
0.10
when "hair_highlight"
0.06
when "piercing_face", "piercing_nipple", "piercing_arm", "piercing_belly", "piercing_vag"
0.02
when /\Agear_/
0.12
when "lips", "nipples"
0.10
when "vag"
0.04
when "anus"
0.06
else
0.18
end
edge_keep = clamp((28.0 - luma) / 28.0, 0.0, 1.0) * edge_keep_scale
highlight_keep = clamp((luma - 232.0) / 23.0, 0.0, 1.0) * highlight_keep_scale
keep = edge_keep + highlight_keep
[
(new_rgb[0] * (1.0 - keep) + red * keep).round,
(new_rgb[1] * (1.0 - keep) + green * keep).round,
(new_rgb[2] * (1.0 - keep) + blue * keep).round
]
end
def self.recolor_bitmap_for_part(part, bitmap, filename)
return bitmap if render_palette_bypassed?
return bitmap if bitmap.nil?
return bitmap if bitmap.respond_to?(:disposed?) && bitmap.disposed?
category = category_for_part(part, filename)
return bitmap if category.nil?
current_state = state_for_part(part)
return bitmap unless category_needs_recolor?(category, current_state)
log("recolor begin category=#{category.inspect} filename=#{filename.inspect} part=#{(part.respond_to?(:part_name) ? part.part_name : part.class).inspect} size=#{bitmap.width}x#{bitmap.height}") if $rps_audit_log_palette_studio
target_context = {
:allow_hair_secondary => hair_highlight_allowed_for_part?(part, filename),
:skin_color_mode => skin_color_mode(current_state)
}
target_context.merge!(secondary_skin_context_for_part(part, filename))
if target_context[:body_layer]
painted = load_painted_mask(filename, bitmap.width, bitmap.height)
target_context[:painted_mask] = painted if painted
end
cache_key = [
bitmap.object_id,
category,
cache_signature_for_category(category, current_state),
(part.respond_to?(:root_folder) ? part.root_folder.to_s : ""),
filename.to_s,
target_context[:allow_hair_secondary] ? 1 : 0,
target_context[:secondary_soft_tissue] ? 1 : 0,
target_context[:painted_mask] ? target_context[:painted_mask][:marked_count].to_i : 0
]
cached = fetch_cached_bitmap(cache_key)
return cached if cached
transformed = Bitmap.new(bitmap.width, bitmap.height)
used_bulk_path = false
target_hits = 0
# Only painted body masks depend on pixel coordinates. Other layers use a
# small set of repeated palette colours, so memoizing their result avoids
# repeating HSV/category calculations tens of thousands of times per image.
coordinate_dependent = !!target_context[:body_layer]
pixel_result_cache = coordinate_dependent ? nil : {}
if bitmap.respond_to?(:get_data) && transformed.respond_to?(:set_data)
begin
raw = bitmap_rgba_data(bitmap, true)
raise TypeError, "MKXP-Z did not return a valid RGBA bitmap buffer" if raw.nil?
offset = 0
raw_length = raw.bytesize
while offset + 3 < raw_length
alpha = raw.getbyte(offset + 3)
if alpha && alpha > 0
red = raw.getbyte(offset)
green = raw.getbyte(offset + 1)
blue = raw.getbyte(offset + 2)
if coordinate_dependent
pixel_index = offset / RGBA_BYTES_PER_PIXEL
pixel_x = pixel_index % bitmap.width
pixel_y = pixel_index / bitmap.width
target = pixel_target_for(red, green, blue, alpha, category, current_state, target_context, pixel_x, pixel_y, bitmap.width, bitmap.height)
if target
new_rgb = recolor_components(red, green, blue, target[1], target[0], target_context)
raw.setbyte(offset, new_rgb[0].to_i)
raw.setbyte(offset + 1, new_rgb[1].to_i)
raw.setbyte(offset + 2, new_rgb[2].to_i)
raw.setbyte(offset + 3, overlay_alpha_for_target(alpha, target[0], target_context).to_i)
target_hits += 1
end
else
color_key = (red << 24) | (green << 16) | (blue << 8) | alpha
unless pixel_result_cache.key?(color_key)
target = pixel_target_for(red, green, blue, alpha, category, current_state, target_context)
if target
new_rgb = recolor_components(red, green, blue, target[1], target[0], target_context)
pixel_result_cache[color_key] = [new_rgb[0].to_i, new_rgb[1].to_i, new_rgb[2].to_i, overlay_alpha_for_target(alpha, target[0], target_context).to_i]
else
pixel_result_cache[color_key] = false
end
end
result = pixel_result_cache[color_key]
if result
raw.setbyte(offset, result[0])
raw.setbyte(offset + 1, result[1])
raw.setbyte(offset + 2, result[2])
raw.setbyte(offset + 3, result[3])
target_hits += 1
end
end
end
offset += RGBA_BYTES_PER_PIXEL
end
transformed.set_data(raw)
used_bulk_path = true
rescue => e
log_exception("bulk recolor fallback category=#{category.inspect} filename=#{filename.inspect} bitmap=#{bitmap.class} size=#{bitmap.width}x#{bitmap.height}", e)
end
end
unless used_bulk_path
# Native blit copies unchanged pixels in one operation. The portable path
# then touches only colours that actually require replacement instead of
# calling set_pixel for the whole image.
transformed.blt(0, 0, bitmap, bitmap.rect)
x = 0
while x < bitmap.width
y = 0
while y < bitmap.height
color = bitmap.get_pixel(x, y)
if color && color.alpha > 0
if coordinate_dependent
target = pixel_target_for(color.red, color.green, color.blue, color.alpha, category, current_state, target_context, x, y, bitmap.width, bitmap.height)
if target
new_rgb = recolor_components(color.red, color.green, color.blue, target[1], target[0], target_context)
new_alpha = overlay_alpha_for_target(color.alpha, target[0], target_context)
transformed.set_pixel(x, y, Color.new(new_rgb[0], new_rgb[1], new_rgb[2], new_alpha))
target_hits += 1
end
else
color_key = (color.red << 24) | (color.green << 16) | (color.blue << 8) | color.alpha
unless pixel_result_cache.key?(color_key)
target = pixel_target_for(color.red, color.green, color.blue, color.alpha, category, current_state, target_context)
if target
new_rgb = recolor_components(color.red, color.green, color.blue, target[1], target[0], target_context)
pixel_result_cache[color_key] = [new_rgb[0], new_rgb[1], new_rgb[2], overlay_alpha_for_target(color.alpha, target[0], target_context)]
else
pixel_result_cache[color_key] = false
end
end
result = pixel_result_cache[color_key]
if result
transformed.set_pixel(x, y, Color.new(result[0], result[1], result[2], result[3]))
target_hits += 1
end
end
end
y += 1
end
x += 1
end
end
store_cached_bitmap(cache_key, transformed)
log("recolor end category=#{category.inspect} filename=#{filename.inspect} part=#{(part.respond_to?(:part_name) ? part.part_name : part.class).inspect} hits=#{target_hits} path=#{used_bulk_path ? 'bulk' : 'pixel'}") if $rps_audit_log_palette_studio
transformed
rescue => e
log_exception("recolor_bitmap_for_part failed category=#{category.inspect} filename=#{filename.inspect} part=#{(part.respond_to?(:part_name) ? part.part_name : part.class).inspect}", e)
bitmap
end
def self.current_revision
@revision ||= 0
end
def self.bump_revision!
@revision = current_revision + 1
end
def self.normalize_pending_state!(pending_state)
PROFILE_KEYS.each do |page_key|
pending_state[page_key] ||= default_profile(page_key)
profile = pending_state[page_key]
profile["enabled"] = profile["enabled"].to_i
profile["h"] = clamp(profile["h"].to_f, 0.0, 359.99)
profile["s"] = clamp(profile["s"].to_f, 0.0, 255.0)
profile["v"] = clamp(profile["v"].to_f, 0.0, 255.0)
profile["mode"] = normalize_skin_color_mode(profile["mode"]) if page_key.to_s == "skin"
if gear_profile?(page_key)
profile["sample_r"] = clamp(profile["sample_r"].to_i, -1, 255)
profile["sample_g"] = clamp(profile["sample_g"].to_i, -1, 255)
profile["sample_b"] = clamp(profile["sample_b"].to_i, -1, 255)
end
end
pending_state
end
def self.apply_pending_state!(pending_state)
storage = story_storage
return if storage.nil?
storage[STORAGE_KEY] = normalize_pending_state!(deep_copy(pending_state))
bump_revision!
refresh_live_appearance!
end
def self.refresh_live_appearance!
begin
if defined?($game_player) && $game_player && $game_player.respond_to?(:refresh_chs)
$game_player.refresh_chs
end
rescue => e
audit_error("refresh_chs failed #{e.class}: #{e.message}")
end
begin
if defined?($game_portraits) && $game_portraits
portraits = $game_portraits.instance_variable_get(:@portraits) rescue nil
if portraits.is_a?(Hash)
portraits.each_value do |portrait|
next unless portrait.is_a?(Lona_Portrait) rescue false
portrait.refresh if portrait.respond_to?(:refresh)
portrait.force_update if portrait.respond_to?(:force_update)
end
end
end
rescue => e
audit_error("portrait refresh failed #{e.class}: #{e.message}")
end
end
def self.assign_preview_state!(renderer, state_hash)
return if renderer.nil?
parts_map = renderer.instance_variable_get(:@allParts) rescue nil
return unless parts_map.is_a?(Hash)
parts_map.each_value do |parts|
next unless parts.is_a?(Array)
parts.each do |part|
next if part.nil?
part.instance_variable_set(:@palette_studio_preview_state, state_hash)
end
end
end
def self.wheel_bitmap(size, page_key = nil)
@wheel_bitmaps ||= {}
cache_key = [size, page_key.to_s, wheel_style_for_page(page_key)]
cached = @wheel_bitmaps[cache_key]
return cached if cached && (!cached.respond_to?(:disposed?) || !cached.disposed?)
radius = size / 2.0
bitmap = Bitmap.new(size, size)
x = 0
while x < size
y = 0
while y < size
dx = x - radius + 0.5
dy = y - radius + 0.5
distance = Math.sqrt(dx * dx + dy * dy)
if distance <= radius
wheel_hue = ((Math.atan2(dy, dx) * 180.0 / Math::PI) + 360.0) % 360.0
hue = wheel_hue_for_page(page_key, wheel_hue)
sat = wheel_saturation_for_page(page_key, distance / radius)
rgb = hsv_to_rgb(hue, sat, 255.0)
bitmap.set_pixel(x, y, Color.new(rgb[0], rgb[1], rgb[2], 255))
end
y += 1
end
x += 1
end
outline = Color.new(12, 12, 16, 255)
bitmap.fill_rect(0, 0, size, 1, outline)
bitmap.fill_rect(0, size - 1, size, 1, outline)
bitmap.fill_rect(0, 0, 1, size, outline)
bitmap.fill_rect(size - 1, 0, 1, size, outline)
@wheel_bitmaps[cache_key] = bitmap
bitmap
end
def self.sidebar_width
(Graphics.width * 0.24375).to_i
end
def self.command_display_name
MENU_LABEL
end
def self.entry_class(entry)
return entry if entry.is_a?(Class)
entry.class
end
def self.menu_insert_index_from_names(command_names)
system_name = ($game_text["menu:core/system"] rescue nil).to_s
display_name = ($game_text["menu:core/display_pp"] rescue "Display").to_s
display_index = command_names.index(display_name)
return display_index + 1 unless display_index.nil?
system_index = command_names.index(system_name)
return system_index unless system_index.nil?
command_names.length
end
def self.menu_insert_index_from_entries(entries)
fullscreen_index = nil
system_index = nil
entries.each_with_index do |entry, index|
klass = entry_class(entry)
fullscreen_index = index if defined?(Menu_FullscreenPP) && klass == Menu_FullscreenPP
system_index = index if klass == Menu_System
end
return fullscreen_index + 1 unless fullscreen_index.nil?
return system_index unless system_index.nil?
entries.length
end
def self.inject_menu_commands(command_names)
return command_names if command_names.nil?
return command_names if command_names.include?(command_display_name)
result = command_names.dup
result.insert(menu_insert_index_from_names(result), command_display_name)
result
end
def self.inject_menu_contents(contents)
return contents if contents.nil?
return contents if contents.any? { |entry| entry_class(entry) == Menu_LonaPaletteStudio }
result = contents.dup
insert_index = menu_insert_index_from_entries(result)
insert_value = result.any? { |entry| entry.is_a?(Class) } ? Menu_LonaPaletteStudio : Menu_LonaPaletteStudio.new
result.insert(insert_index, insert_value)
result
end
end
class Lona_Part
alias_method :lps_set_value_without_overlay_visibility, :set_value unless method_defined?(:lps_set_value_without_overlay_visibility)
def set_value(key, value, forcedOpacity = false)
result = lps_set_value_without_overlay_visibility(key, value, forcedOpacity)
LonaPaletteStudio.apply_overlay_visibility_to_part!(self) if defined?(LonaPaletteStudio)
result
end
alias_method :lps_update_dirt_without_overlay_visibility, :updateDirt unless method_defined?(:lps_update_dirt_without_overlay_visibility)
def updateDirt(ref)
result = lps_update_dirt_without_overlay_visibility(ref)
LonaPaletteStudio.apply_overlay_visibility_to_part!(self) if defined?(LonaPaletteStudio)
result
end
end
module LonaPaletteStudioPreview
DEFAULT_POSE_NAME = "pose1"
POSE_NAME_BY_PAGE = {}
SUBPOSE_VALUE = 1
POSE_OPTIONS = [
["pose1", 1, "Поза 1"],
["pose1", 2, "Поза 2"],
["pose1", 3, "Поза 3"],
["pose4", 1, "Поза 4"],
["pose5", 1, "Поза 5"],
["chcg1", 1, "Поза 6"],
["chcg1", 2, "Поза 7"],
["chcg2", 1, "Поза 8"],
["chcg3", 1, "Поза 9"],
["chcg4", 1, "Поза 10"],
["chcg4", 2, "Поза 11"],
["chcg5", 1, "Поза 12"]
]
NUDE_PREVIEW_PAGES = ["skin", "nipples"]
PREVIEW_KEEP_KEYWORDS = ["hair", "bang", "braid", "pony", "twin", "tail", "eyes", "subeyes"]
PREVIEW_HIDE_KEYWORDS = ["equip", "armour", "armor", "cloth", "bra", "panty", "underwear", "bodysuit", "shoe", "boot", "stocking", "cape", "mask", "helmet", "hood", "nun", "scholar", "doc"]
@pose_index = 0
@expression_index = 0
def self.clone_part(part)
part.clone
rescue
part
end
def self.part_blob(part)
entries = []
entries << (part.respond_to?(:part_name) ? part.part_name : nil)
entries << (part.respond_to?(:root_folder) ? part.root_folder : nil)
bitmaps = part.bitmaps rescue nil
if bitmaps.respond_to?(:values)
bitmaps.values.each do |value|
entries << value
end
end
entries.compact.map { |value| value.to_s.downcase }.join("|")
end
def self.hide_part_for_nude_preview?(part)
blob = part_blob(part)
return false if PREVIEW_KEEP_KEYWORDS.any? { |keyword| blob.include?(keyword) }
PREVIEW_HIDE_KEYWORDS.any? { |keyword| blob.include?(keyword) }
end
def self.pose_name_for_page(page_key)
current_pose_triplet(actor_for_preview)[0]
end
def self.pose_canvas(actor, pose_name)
canvas_map = actor.statMap["canvas"] rescue nil
return canvas_map[pose_name] if canvas_map && canvas_map[pose_name]
[300, 400, 0, 0]
end
def self.pose_source_data
return nil if $data_lona_portrait.nil?
$data_lona_portrait[1]
rescue => e
LonaPaletteStudio.log("pose_source_data failed #{e.class}: #{e.message}")
nil
end
def self.pose_source_parts(pose_name)
source_data = pose_source_data
return nil if source_data.nil?
source_data[pose_name]
rescue => e
LonaPaletteStudio.log("pose_source_parts failed #{e.class}: #{e.message}")
nil
end
def self.live_pose_parts(actor, pose_name)
return nil if actor.nil? || !actor.respond_to?(:portrait)
portrait = actor.portrait rescue nil
return nil if portrait.nil?
all_parts = portrait.instance_variable_get(:@allParts) rescue nil
return nil if all_parts.nil?
parts = all_parts[pose_name]
return nil if parts.nil? || parts.empty?
parts
rescue => e
LonaPaletteStudio.log("live_pose_parts failed #{e.class}: #{e.message}")
nil
end
def self.safe_actor_eye_value(actor, stat_key)
value = actor.stat[stat_key] rescue nil
return value if value.is_a?(Integer) && value > 0
1
rescue => e
LonaPaletteStudio.log("safe_actor_eye_value failed #{e.class}: #{e.message}")
1
end
def self.renderer_name_order(actor)
if actor && actor.respond_to?(:portrait)
portrait = actor.portrait rescue nil
name_order = portrait.instance_variable_get(:@name_order) rescue nil
return name_order if name_order
end
$data_lona_portrait[0] rescue nil
end
def self.pose_parts(actor, pose_name)
# Prefer the live portrait definition first. This keeps the studio preview
# aligned with runtime-injected parts/name_order changes instead of the
# older raw $data_lona_portrait snapshot.
live_parts = live_pose_parts(actor, pose_name)
source_parts = pose_source_parts(pose_name)
return live_parts if source_parts.nil? || source_parts.empty?
return source_parts if live_parts.nil? || live_parts.empty?
merged_parts = []
seen = {}
[live_parts, source_parts].each do |part_list|
part_list.each do |part|
signature = part_blob(part)
next if signature.empty?
next if seen[signature]
seen[signature] = true
merged_parts << part
end
end
merged_parts
end
def self.actor_for_preview
return nil unless defined?($game_player) && $game_player && $game_player.respond_to?(:actor)
$game_player.actor rescue nil
end
def self.available_poses(actor = nil)
source_data = pose_source_data
poses = POSE_OPTIONS.select do |triplet|
parts = source_data[triplet[0]] rescue nil
parts && !parts.empty?
end
poses = [[DEFAULT_POSE_NAME, SUBPOSE_VALUE, "Поза 1"]] if poses.empty?
poses
rescue => e
LonaPaletteStudio.log("available_poses failed #{e.class}: #{e.message}")
[[DEFAULT_POSE_NAME, SUBPOSE_VALUE, "Поза 1"]]
end
def self.clamp_pose_index(actor = nil)
poses = available_poses(actor)
@pose_index = 0 if @pose_index.nil?
@pose_index = 0 if @pose_index < 0
@pose_index = poses.length - 1 if @pose_index >= poses.length
@pose_index
end
def self.current_pose_triplet(actor = nil)
poses = available_poses(actor)
poses[clamp_pose_index(actor)] || poses[0] || [DEFAULT_POSE_NAME, SUBPOSE_VALUE, "Поза 1"]
end
def self.expression_keys_for_pose(actor, pose_name)
parts = pose_parts(actor, pose_name)
keys = []
(parts || []).each do |part|
name_order = part.nameOrder rescue nil
next if name_order.nil? || !name_order.include?("mouth")
value_index = name_order.index("mouth")
bitmaps = part.bitmaps rescue nil
next if bitmaps.nil? || bitmaps.empty?
bitmaps.keys.each do |key_arr|
key_value = key_arr.is_a?(Array) ? key_arr[value_index] : key_arr
next if key_value.nil? || key_value.to_s.empty?
keys << key_value
end
end
keys = keys.uniq.sort_by do |value|
if value.is_a?(Numeric)
[value.to_i, value.to_s]
else
match = value.to_s.match(/(\d+)/)
[match ? match[1].to_i : 0, value.to_s]
end
end
keys = [1] if keys.empty?
keys
rescue => e
LonaPaletteStudio.log("expression_keys_for_pose failed #{e.class}: #{e.message}")
[1]
end
def self.preview_values_match?(left, right)
return false if left.nil? || right.nil?
left.to_s == right.to_s || left.to_i == right.to_i
end
def self.pose_name_variants(pose_name)
name = pose_name.to_s
variants = [name]
trimmed = name.sub(/_subpose\d+\z/i, "")
variants << trimmed unless trimmed == name
variants.uniq
end
def self.eye_support_from_filenames(parts, pose_name)
support = { :pairs => [], :eyes => [], :subeyes => [] }
variants = pose_name_variants(pose_name).map { |value| value.to_s.downcase }
return support if variants.empty?
root_folders = (parts || []).map { |part| (part.respond_to?(:root_folder) ? part.root_folder : "").to_s }.reject { |value| value.empty? }.uniq
root_folders.each do |root_folder|
LonaPaletteStudio.root_folder_png_catalog(root_folder).each do |entry|
entry_name = entry.to_s
next if entry_name =~ /_EXT\.png\z/i
entry_downcase = entry_name.downcase
next unless variants.any? { |variant| entry_downcase.start_with?("#{variant}_head_eyes") }
match = entry_name.match(/_head_eyes(\d+)_subeyes(\d+)/i)
next if match.nil?
eye_value = match[1].to_i
subeye_value = match[2].to_i
support[:eyes] << eye_value
support[:subeyes] << subeye_value
support[:pairs] << [eye_value, subeye_value]
end
end
support[:pairs].uniq!
support[:eyes].uniq!
support[:subeyes].uniq!
support
rescue => e
LonaPaletteStudio.log("eye_support_from_filenames failed #{e.class}: #{e.message}")
{ :pairs => [], :eyes => [], :subeyes => [] }
end
def self.eye_support_for_pose(actor, pose_name)
parts = pose_parts(actor, pose_name)
support = { :pairs => [], :eyes => [], :subeyes => [] }
(parts || []).each do |part|
name_order = part.nameOrder rescue nil
next if name_order.nil?
eye_index = name_order.index("eyes")
subeye_index = name_order.index("subeyes")
next if eye_index.nil? && subeye_index.nil?
bitmaps = part.bitmaps rescue nil
next if bitmaps.nil? || bitmaps.empty?
bitmaps.keys.each do |key_arr|
next unless key_arr.is_a?(Array)
eye_value = eye_index.nil? ? nil : key_arr[eye_index]
subeye_value = subeye_index.nil? ? nil : key_arr[subeye_index]
support[:eyes] << eye_value unless eye_value.nil?
support[:subeyes] << subeye_value unless subeye_value.nil?
if !eye_value.nil? && !subeye_value.nil?
support[:pairs] << [eye_value, subeye_value]
end
end
end
file_support = eye_support_from_filenames(parts, pose_name)
support[:pairs].concat(file_support[:pairs])
support[:eyes].concat(file_support[:eyes])
support[:subeyes].concat(file_support[:subeyes])
support[:pairs].uniq!
support[:eyes].uniq!
support[:subeyes].uniq!
support
rescue => e
LonaPaletteStudio.log("eye_support_for_pose failed #{e.class}: #{e.message}")
{ :pairs => [], :eyes => [], :subeyes => [] }
end
def self.resolve_preview_eye_pair(actor, pose_name)
actor_eye = safe_actor_eye_value(actor, "eyes")
actor_subeye = safe_actor_eye_value(actor, "subeyes")
support = eye_support_for_pose(actor, pose_name)
pairs = support[:pairs]
if !pairs.empty?
# Some poses do not ship every eyes/subeyes combo. Clamp the preview to
# a combination that actually exists so the face layer does not vanish.
exact_pair = pairs.find { |eye_value, subeye_value| preview_values_match?(eye_value, actor_eye) && preview_values_match?(subeye_value, actor_subeye) }
return exact_pair if exact_pair
same_eye_pair = pairs.find { |eye_value, _subeye_value| preview_values_match?(eye_value, actor_eye) }
return same_eye_pair if same_eye_pair
return pairs[0]
end
resolved_eye = support[:eyes].find { |value| preview_values_match?(value, actor_eye) } || support[:eyes][0] || actor_eye
resolved_subeye = support[:subeyes].find { |value| preview_values_match?(value, actor_subeye) } || support[:subeyes][0] || actor_subeye
[resolved_eye, resolved_subeye]
rescue => e
LonaPaletteStudio.log("resolve_preview_eye_pair failed #{e.class}: #{e.message}")
[actor_eye, actor_subeye]
end
def self.clamp_expression_index(actor = nil)
actor ||= actor_for_preview
pose_name = current_pose_triplet(actor)[0]
expressions = expression_keys_for_pose(actor, pose_name)
@expression_index = 0 if @expression_index.nil?
@expression_index = 0 if @expression_index < 0
@expression_index = expressions.length - 1 if @expression_index >= expressions.length
@expression_index
end
def self.current_expression_key(actor = nil)
actor ||= actor_for_preview
pose_name = current_pose_triplet(actor)[0]
expressions = expression_keys_for_pose(actor, pose_name)
expressions[clamp_expression_index(actor)] || expressions[0] || 1
end
def self.current_pose_label(actor = nil)
"Поза #{clamp_pose_index(actor) + 1}"
end
def self.current_expression_label(actor = nil)
actor ||= actor_for_preview
pose_name = current_pose_triplet(actor)[0]
expressions = expression_keys_for_pose(actor, pose_name)
index = clamp_expression_index(actor)
return "Выражение 1" if expressions.length <= 0
"Выражение #{index + 1}"
end
def self.cycle_pose(delta, actor = nil)
poses = available_poses(actor)
return false if poses.length <= 1
@pose_index = clamp_pose_index(actor) + delta.to_i
@pose_index = 0 if @pose_index >= poses.length
@pose_index = poses.length - 1 if @pose_index < 0
@expression_index = 0
true
end
def self.cycle_expression(delta, actor = nil)
actor ||= actor_for_preview
pose_name = current_pose_triplet(actor)[0]
expressions = expression_keys_for_pose(actor, pose_name)
return false if expressions.length <= 1
@expression_index = clamp_expression_index(actor) + delta.to_i
@expression_index = 0 if @expression_index >= expressions.length
@expression_index = expressions.length - 1 if @expression_index < 0
true
end
def self.force_baseline(renderer)
return if renderer.nil?
actor = actor_for_preview
pose_triplet = current_pose_triplet(actor)
preview_eye, preview_subeye = resolve_preview_eye_pair(actor, pose_triplet[0])
renderer.portrait.visible = true if renderer.respond_to?(:portrait) && renderer.portrait
renderer.set_stat("subpose", pose_triplet[1].to_i) if renderer.respond_to?(:set_stat)
renderer.set_stat("dirt", 0) if renderer.respond_to?(:set_stat)
renderer.set_stat("eyes", preview_eye) if renderer.respond_to?(:set_stat)
renderer.set_stat("subeyes", preview_subeye) if renderer.respond_to?(:set_stat)
renderer.set_stat("mouth", current_expression_key(actor)) if renderer.respond_to?(:set_stat)
rescue => e
LonaPaletteStudio.audit_error("force_baseline failed #{e.class}: #{e.message}")
end
def self.build_renderer(page_key)
return nil unless defined?(Lona_Portrait)
return nil unless defined?($game_player) && $game_player && $game_player.respond_to?(:actor)
actor = $game_player.actor rescue nil
return nil if actor.nil?
pose_name = pose_name_for_page(page_key)
parts = pose_parts(actor, pose_name)
return nil if parts.nil? || parts.empty?
name_order = renderer_name_order(actor)
return nil if name_order.nil?
cloned_parts = parts.map { |part| clone_part(part) }
if NUDE_PREVIEW_PAGES.include?(page_key.to_s)
cloned_parts.reject! { |part| hide_part_for_nude_preview?(part) }
end
pose_hash = { pose_name => cloned_parts }
renderer = Lona_Portrait.new(actor, pose_hash, pose_name, name_order, pose_canvas(actor, pose_name))
renderer.instance_variable_set(:@palette_studio_pose_name, pose_name)
renderer.portrait.visible = true if renderer.respond_to?(:portrait) && renderer.portrait
renderer.refresh
force_baseline(renderer)
renderer.force_update
renderer
rescue => e
LonaPaletteStudio.audit_error("build_renderer failed #{e.class}: #{e.message}")
nil
end
def self.dispose_renderer(renderer)
return if renderer.nil?
begin
portrait = renderer.portrait rescue nil
bitmap = portrait.bitmap rescue nil
bitmap.dispose if bitmap && bitmap.respond_to?(:disposed?) && !bitmap.disposed?
rescue => e
LonaPaletteStudio.log("dispose_renderer bitmap failed #{e.class}: #{e.message}")
end
begin
renderer.portrait.dispose if renderer.respond_to?(:portrait) && renderer.portrait
rescue => e
LonaPaletteStudio.log("dispose_renderer portrait failed #{e.class}: #{e.message}")
end
begin
if renderer.respond_to?(:prt_vp) && renderer.prt_vp
renderer.prt_vp.dispose
renderer.prt_vp = nil
end
rescue => e
LonaPaletteStudio.log("dispose_renderer viewport failed #{e.class}: #{e.message}")
end
end
end
class Scene_Menu
alias lona_palette_studio_create_menu create_menu unless method_defined?(:lona_palette_studio_create_menu)
def create_menu(command_names)
lona_palette_studio_create_menu(LonaPaletteStudio.inject_menu_commands(command_names))
end
alias lona_palette_studio_create_contents create_contents unless method_defined?(:lona_palette_studio_create_contents)
def create_contents(contents, *args)
lona_palette_studio_create_contents(LonaPaletteStudio.inject_menu_contents(contents), *args)
end
end
class Menu_LonaPaletteStudio < Menu_ContentBase
# Live portrait composition is expensive. Four frames keeps dragging smooth
# while limiting full portrait rebuilds to roughly 15 per second at 60 FPS.
PREVIEW_UPDATE_INTERVAL_FRAMES = 4
PANEL_X = 154
PANEL_Y = 16
PANEL_W = 476
PANEL_H = 344
TAB_W = 70
TAB_H = 22
TAB_START_X = 170
TAB_Y = 48
TAB_GAP = 5
PREVIEW_X = 170
PREVIEW_Y = 92
PREVIEW_W = 192
PREVIEW_H = 248
WHEEL_SIZE = 104
WHEEL_X = 388
WHEEL_Y = 92
SLIDER_X = 498
SLIDER_Y = 92
SLIDER_W = 18
SLIDER_H = 104
BUTTON_Y = 264
APPLY_X = 434
RESET_X = 514
BUTTON_W = 64
BUTTON_H = 20
PRESET_Y = 200
SWATCH_Y = 240
SWATCH_W = 32
PRESET_W = 44
PRESET_H = 16
PRESET_GAP = 4
SWATCH_H = 16
CONTROL_PANEL_W = 236
CONTROL_PANEL_H = 286
TOGGLE_W = 52
ASSC_SLOT_X = 548
ASSC_SLOT_Y = 84
ASSC_SLOT_W = 48
ASSC_SLOT_H = 16
ASSC_SLOT_GAP = 2
SOFT_SLOT_X = 548
SOFT_SLOT_Y = 84
SOFT_SLOT_W = 48
SOFT_SLOT_H = 16
SOFT_SLOT_GAP = 2
GEAR_SLOT_X = 548
GEAR_SLOT_Y = 84
GEAR_SLOT_W = 28
GEAR_SLOT_H = 18
GEAR_SLOT_GAP = 4
GEAR_SLOT_COL_GAP = 4
GEAR_SLOT_COLUMNS = 2
GEAR_LAYER_X = 388
GEAR_LAYER_Y = 200
GEAR_LAYER_W = 68
GEAR_LAYER_H = 18
GEAR_LAYER_GAP = 6
PREVIEW_CONTROL_ROW_H = 16
PREVIEW_CONTROL_GAP = 2
FONT_TITLE = 20
FONT_BODY = 14
FONT_SMALL = 12
def initialize
super
@active = false
@page_index = 0
@hair_target_index = 0
@assc_target_index = 0
@soft_target_index = 0
@gear_slot_index = 0
@gear_layer_index = 0
@pending_state = nil
@preview_renderer = nil
@preview_renderer_page_key = nil
@preview_dirty = false
@last_preview_sync_frame = nil
@surface = Sprite.new(@viewport)
@surface.z = System_Settings::SCENE_Menu_Contents_Z + 1
@surface.bitmap = Bitmap.new(Graphics.width, Graphics.height)
LonaPaletteStudio.apply_ui_font(@surface.bitmap)
@mouse_rects = {}
# The original implementation built a complete portrait for every ordinary
# menu open. Build it only after the player actually enters this page.
hide
end
def dispose
set_palette_mouse_enabled(false) if @active
LonaPaletteStudioPreview.dispose_renderer(@preview_renderer)
@preview_renderer = nil
if @surface
@surface.bitmap.dispose if @surface.bitmap && !@surface.bitmap.disposed?
@surface.dispose
end
super
end
def show
super
refresh
end
def hide
set_palette_mouse_enabled(false) if @active
@active = false
super
end
def enter_page
@menu.deactivate if @menu
@active = true
set_palette_mouse_enabled(true)
@pending_state = LonaPaletteStudio.deep_copy(LonaPaletteStudio.state)
rebuilt = ensure_preview_renderer_pose!
sync_preview unless rebuilt
refresh
Input.update
SndLib.sys_ok if defined?(SndLib)
end
def mouse_force_main_menu_pause
@active
end
def mouse_press_cancel
back_to_mainmenu if @active
end
def update
return unless @viewport.visible
if !@active
if Mouse.enable? && Input.trigger?(:MZ_LINK) && !Mouse.within_XYWH?(0, 0, LonaPaletteStudio.sidebar_width, Graphics.height)
enter_page
end
return
end
mouse_update_input if Mouse.enable?
keyboard_update_input
flush_queued_preview_update
end
def keyboard_update_input
return back_to_mainmenu if Input.trigger?(:B) || WolfPad.trigger?(:X_LINK)
if Input.trigger?(:C) || WolfPad.trigger?(:Z_LINK)
apply_pending_changes
return
end
if Input.trigger?(:L)
switch_page(-1)
return
end
if Input.trigger?(:R)
switch_page(1)
return
end
if Input.trigger?(:UI_DeleteItem)
reset_current_page
return
end
if Input.press?(:SHIFT)
step = 3.0
adjust_value(step) if Input.repeat?(:UP)
adjust_value(-step) if Input.repeat?(:DOWN)
else
move_wheel_cursor(-2.0, 0.0) if Input.repeat?(:LEFT)
move_wheel_cursor(2.0, 0.0) if Input.repeat?(:RIGHT)
move_wheel_cursor(0.0, -2.0) if Input.repeat?(:UP)
move_wheel_cursor(0.0, 2.0) if Input.repeat?(:DOWN)
end
end
def mouse_update_input
return Mouse.ForceIdle if Input.respond_to?(:MouseWheelForceIdle?) && Input.MouseWheelForceIdle?
return back_to_mainmenu if Input.trigger?(:MX_LINK)
clicked = Input.trigger?(:MZ_LINK)
pressed = Input.respond_to?(:press?) ? Input.press?(:MZ_LINK) : clicked
return unless clicked || pressed
LonaPaletteStudio::PAGE_ORDER.each_with_index do |page_key, index|
if rect_hit?(("tab_" + page_key).to_sym) && clicked
set_page_index(index)
return
end
end
if rect_hit?(:preview_pose_prev) && clicked
cycle_preview_pose(-1)
return
elsif rect_hit?(:preview_pose_next) && clicked
cycle_preview_pose(1)
return
elsif rect_hit?(:preview_expression_prev) && clicked
cycle_preview_expression(-1)
return
elsif rect_hit?(:preview_expression_next) && clicked
cycle_preview_expression(1)
return
end
if point_in_preview? && clicked
return if handle_preview_click
if current_page_key == "gear"
sample_current_gear_color_from_preview
return
end
end
if wheel_style_buttons_visible?
LonaPaletteStudio::WHEEL_STYLE_OPTIONS.each_with_index do |_style_key, index|
if rect_hit?(("wheel_style_" + index.to_s).to_sym) && clicked
apply_wheel_style(index)
return
end
end
end
if current_page_key == "assc"
LonaPaletteStudio::ASSC_TARGET_ORDER.each_with_index do |_slot_key, index|
if rect_hit?(("assc_slot_" + index.to_s).to_sym) && clicked
set_assc_target_index(index)
return
end
end
end
if current_page_key == "hair_primary"
LonaPaletteStudio::HAIR_TARGET_ORDER.each_with_index do |_slot_key, index|
if rect_hit?(("hair_slot_" + index.to_s).to_sym) && clicked
set_hair_target_index(index)
return
end
end
end
if current_page_key == "nipples"
LonaPaletteStudio::SOFT_TARGET_ORDER.each_with_index do |_slot_key, index|
if rect_hit?(("soft_slot_" + index.to_s).to_sym) && clicked
set_soft_target_index(index)
return
end
end
end
if current_page_key == "skin"
if rect_hit?(:skin_mode_gradient) && clicked
set_skin_color_mode("gradient")
return
elsif rect_hit?(:skin_mode_solid) && clicked
set_skin_color_mode("solid")
return
end
end
if current_page_key == "gear"
LonaPaletteStudio::GEAR_SLOT_ORDER.each_with_index do |_slot_key, index|
if rect_hit?(("gear_slot_" + index.to_s).to_sym) && clicked
set_gear_slot_index(index)
return
end
end
LonaPaletteStudio::GEAR_LAYER_ORDER.each_with_index do |_layer_key, index|
if rect_hit?(("gear_layer_" + index.to_s).to_sym) && clicked
set_gear_layer_index(index)
return
end
end
end
if rect_hit?(:apply) && clicked
apply_pending_changes
return
elsif rect_hit?(:reset) && clicked
reset_current_page
return
elsif rect_hit?(:current_toggle) && clicked
toggle_current_page
return
elsif point_in_wheel?
set_profile_from_mouse
return
elsif rect_hit?(:value_slider)
set_value_from_mouse
return
end
end
def back_to_mainmenu
@active = false
set_palette_mouse_enabled(false)
@pending_state = nil
@preview_dirty = false
LonaPaletteStudioPreview.dispose_renderer(@preview_renderer)
@preview_renderer = nil
@preview_renderer_page_key = nil
@preview_pose_name = nil
refresh
@menu.activate if @menu
SndLib.sys_cancel if defined?(SndLib)
end
def set_palette_mouse_enabled(enabled)
return unless defined?(Mouse)
enabled ? Mouse.enable : Mouse.disable
rescue => e
LonaPaletteStudio.log_exception("palette mouse toggle failed enabled=#{enabled}", e)
end
def current_state_for_view
@active && @pending_state ? @pending_state : LonaPaletteStudio.state
end
def current_page_key
LonaPaletteStudio::PAGE_ORDER[@page_index] || "hair_primary"
end
def current_profile_key
return current_hair_target_key if current_page_key == "hair_primary"
return current_assc_target_key if current_page_key == "assc"
return current_soft_target_key if current_page_key == "nipples"
return LonaPaletteStudio.gear_profile_key(current_gear_slot_key, current_gear_layer_key) if current_page_key == "gear"
current_page_key
end
def current_hair_target_key
LonaPaletteStudio::HAIR_TARGET_ORDER[@hair_target_index] || "hair_primary"
end
def current_assc_target_key
LonaPaletteStudio::ASSC_TARGET_ORDER[@assc_target_index] || "piercing_face"
end
def current_gear_slot_key
LonaPaletteStudio::GEAR_SLOT_ORDER[@gear_slot_index] || "gear_top"
end
def current_soft_target_key
LonaPaletteStudio::SOFT_TARGET_ORDER[@soft_target_index] || "lips"
end
def current_skin_color_mode
LonaPaletteStudio.skin_color_mode(current_state_for_view)
end
def current_gear_layer_key
LonaPaletteStudio::GEAR_LAYER_ORDER[@gear_layer_index] || "base"
end
def current_control_name
if current_page_key == "hair_primary"
LonaPaletteStudio::HAIR_TARGET_NAMES[current_hair_target_key] || "Волосы"
elsif current_page_key == "assc"
LonaPaletteStudio::ASSC_TARGET_NAMES[current_assc_target_key] || "Пирсинг"
elsif current_page_key == "nipples"
LonaPaletteStudio::SOFT_TARGET_NAMES[current_soft_target_key] || "Кожа 2"
elsif current_page_key == "gear"
"#{LonaPaletteStudio::GEAR_SLOT_NAMES[current_gear_slot_key] || 'Одежда'} #{LonaPaletteStudio::GEAR_LAYER_NAMES[current_gear_layer_key] || ''}".strip
else
LonaPaletteStudio::PAGE_NAMES[current_page_key] || "Цвет"
end
end
def current_profile
LonaPaletteStudio.profile_for(current_profile_key, current_state_for_view)
end
def current_profile_mutable
return nil unless @pending_state
LonaPaletteStudio.normalize_pending_state!(@pending_state)
@pending_state[current_profile_key]
end
def current_color_rgb(profile)
LonaPaletteStudio.hsv_to_rgb(profile["h"], profile["s"], profile["v"])
end
def switch_page(direction)
new_index = (@page_index + direction) % LonaPaletteStudio::PAGE_ORDER.length
set_page_index(new_index)
SndLib.play_cursor if defined?(SndLib)
end
def set_page_index(index)
@index = [[index.to_i, 0].max, LonaPaletteStudio::PAGE_ORDER.length - 1].min
@page_index = @index
rebuilt = ensure_preview_renderer_pose!
sync_preview unless rebuilt
refresh
end
def set_hair_target_index(index)
@hair_target_index = [[index.to_i, 0].max, LonaPaletteStudio::HAIR_TARGET_ORDER.length - 1].min
refresh
SndLib.play_cursor if defined?(SndLib)
end
def set_assc_target_index(index)
@assc_target_index = [[index.to_i, 0].max, LonaPaletteStudio::ASSC_TARGET_ORDER.length - 1].min
refresh
SndLib.play_cursor if defined?(SndLib)
end
def set_soft_target_index(index)
@soft_target_index = [[index.to_i, 0].max, LonaPaletteStudio::SOFT_TARGET_ORDER.length - 1].min
refresh
SndLib.play_cursor if defined?(SndLib)
end
def set_skin_color_mode(mode_key)
profile = current_profile_mutable
return if profile.nil?
normalized = LonaPaletteStudio.normalize_skin_color_mode(mode_key)
return if profile["mode"].to_s == normalized
profile["mode"] = normalized
note_preview_change
SndLib.play_cursor if defined?(SndLib)
end
def set_gear_slot_index(index)
@gear_slot_index = [[index.to_i, 0].max, LonaPaletteStudio::GEAR_SLOT_ORDER.length - 1].min
refresh
SndLib.play_cursor if defined?(SndLib)
end
def set_gear_layer_index(index)
@gear_layer_index = [[index.to_i, 0].max, LonaPaletteStudio::GEAR_LAYER_ORDER.length - 1].min
refresh
SndLib.play_cursor if defined?(SndLib)
end
def toggle_current_page
profile = current_profile_mutable
return if profile.nil?
profile["enabled"] = profile["enabled"].to_i == 0 ? 1 : 0
note_preview_change
SndLib.play_cursor if defined?(SndLib)
end
def reset_current_page
return if @pending_state.nil?
target_keys = if current_page_key == "nipples"
LonaPaletteStudio::SOFT_TARGET_ORDER
else
[current_profile_key]
end
target_keys.each do |profile_key|
profile = @pending_state[profile_key]
next if profile.nil?
defaults = LonaPaletteStudio.default_profile(profile_key)
profile.clear
defaults.each { |key, value| profile[key] = value }
end
note_preview_change
SndLib.sys_cancel if defined?(SndLib)
end
def wheel_style_buttons_visible?
LonaPaletteStudio.wheel_style_supported?(current_page_key)
end
def apply_wheel_style(index)
return unless wheel_style_buttons_visible?
style_key = LonaPaletteStudio::WHEEL_STYLE_OPTIONS[index]
return if style_key.nil?
LonaPaletteStudio.set_wheel_style_for_page(current_page_key, style_key)
refresh
SndLib.play_cursor if defined?(SndLib)
end
def apply_pending_changes
return if @pending_state.nil?
LonaPaletteStudio.log("apply_pending_changes begin page=#{current_page_key.inspect} profile=#{current_profile_key.inspect}") if $rps_audit_log_palette_studio
LonaPaletteStudio.apply_pending_state!(@pending_state)
@pending_state = LonaPaletteStudio.deep_copy(LonaPaletteStudio.state)
sync_preview
refresh
SndLib.sys_ok if defined?(SndLib)
LonaPaletteStudio.log("apply_pending_changes end page=#{current_page_key.inspect} profile=#{current_profile_key.inspect}") if $rps_audit_log_palette_studio
rescue => e
LonaPaletteStudio.log_exception("apply_pending_changes page=#{current_page_key.inspect} profile=#{current_profile_key.inspect} #{LonaPaletteStudio.profile_debug_summary(current_profile_key, @pending_state)}", e)
end
def note_preview_change
LonaPaletteStudio.log("note_preview_change page=#{current_page_key.inspect} profile=#{current_profile_key.inspect} enabled=#{(current_profile_mutable['enabled'] rescue nil).inspect}") if $rps_audit_log_palette_studio
@preview_dirty = true
flush_queued_preview_update
rescue => e
LonaPaletteStudio.log_exception("note_preview_change page=#{current_page_key.inspect} profile=#{current_profile_key.inspect} #{LonaPaletteStudio.profile_debug_summary(current_profile_key, @pending_state)}", e)
end
def preview_frame_id
return Graphics.frame_count.to_i if Graphics.respond_to?(:frame_count)
@preview_fallback_frame = (@preview_fallback_frame || 0) + 1
end
def flush_queued_preview_update(force = false)
return unless @preview_dirty
frame_id = preview_frame_id
if !force && !@last_preview_sync_frame.nil?
return if frame_id - @last_preview_sync_frame < PREVIEW_UPDATE_INTERVAL_FRAMES
end
@preview_dirty = false
@last_preview_sync_frame = frame_id
sync_preview
refresh
end
def move_wheel_cursor(delta_x, delta_y)
profile = current_profile_mutable
return if profile.nil?
point = wheel_point_for_profile(profile)
dx = point[0] + delta_x
dy = point[1] + delta_y
radius = WHEEL_SIZE / 2.0
distance = Math.sqrt(dx * dx + dy * dy)
if distance > radius && distance > 0.0
scale = radius / distance
dx *= scale
dy *= scale
end
apply_wheel_point(dx, dy)
end
def adjust_value(delta)
profile = current_profile_mutable
return if profile.nil?
profile["enabled"] = 1
profile["v"] = LonaPaletteStudio.quantize(profile["v"].to_f + delta.to_f, LonaPaletteStudio::SV_STEP, 0.0, 255.0)
note_preview_change
end
def wheel_point_for_profile(profile)
radius = WHEEL_SIZE / 2.0
angle = LonaPaletteStudio.profile_hue_to_wheel_angle(current_page_key, profile["h"].to_f) * Math::PI / 180.0
distance = radius * LonaPaletteStudio.profile_saturation_to_wheel_fraction(current_page_key, profile["s"].to_f)
[
Math.cos(angle) * distance,
Math.sin(angle) * distance
]
end
def apply_wheel_point(dx, dy)
profile = current_profile_mutable
return if profile.nil?
radius = WHEEL_SIZE / 2.0
distance = Math.sqrt(dx * dx + dy * dy)
wheel_hue = (((Math.atan2(dy, dx) * 180.0 / Math::PI) + 360.0) % 360.0)
new_h = LonaPaletteStudio.quantize(LonaPaletteStudio.wheel_hue_for_page(current_page_key, wheel_hue), LonaPaletteStudio::HUE_STEP, 0.0, 358.0)
new_s = LonaPaletteStudio.quantize(LonaPaletteStudio.wheel_saturation_for_page(current_page_key, distance / radius), LonaPaletteStudio::SV_STEP, 0.0, 255.0)
return if profile["enabled"].to_i == 1 && profile["h"] == new_h && profile["s"] == new_s
profile["enabled"] = 1
profile["h"] = new_h
profile["s"] = new_s
note_preview_change
end
def set_profile_from_mouse
center_x = WHEEL_X + WHEEL_SIZE / 2.0
center_y = WHEEL_Y + WHEEL_SIZE / 2.0
mouse_x, mouse_y = Mouse.GetMouseXY
apply_wheel_point(mouse_x - center_x, mouse_y - center_y)
end
def set_value_from_mouse
profile = current_profile_mutable
return if profile.nil?
_, mouse_y = Mouse.GetMouseXY
rel_y = LonaPaletteStudio.clamp(mouse_y - SLIDER_Y, 0.0, SLIDER_H.to_f)
new_v = LonaPaletteStudio.quantize(((SLIDER_H - rel_y) / SLIDER_H.to_f) * 255.0, LonaPaletteStudio::SV_STEP, 0.0, 255.0)
return if profile["enabled"].to_i == 1 && profile["v"] == new_v
profile["enabled"] = 1
profile["v"] = new_v
note_preview_change
end
def current_preview_bitmap
return nil if @preview_renderer.nil?
@preview_renderer.portrait.bitmap if @preview_renderer.respond_to?(:portrait)
rescue
nil
end
def preview_image_rect_bounds
control_height = PREVIEW_CONTROL_ROW_H * 2 + PREVIEW_CONTROL_GAP + 20
[PREVIEW_X, PREVIEW_Y + control_height, PREVIEW_W, PREVIEW_H - control_height]
end
def build_gear_sampling_bitmap
return [current_preview_bitmap, nil] if current_page_key != "gear"
renderer = LonaPaletteStudioPreview.build_renderer(current_page_key)
return [current_preview_bitmap, nil] if renderer.nil?
sample_state = LonaPaletteStudio.deep_copy(current_state_for_view)
LonaPaletteStudio::GEAR_PROFILE_KEYS.each do |profile_key|
profile = LonaPaletteStudio.profile_for(profile_key, sample_state)
profile["enabled"] = 0 if profile
end
LonaPaletteStudio.assign_preview_state!(renderer, sample_state)
renderer.refresh if renderer.respond_to?(:refresh)
LonaPaletteStudioPreview.force_baseline(renderer)
renderer.force_update if renderer.respond_to?(:force_update)
[renderer.portrait.bitmap, renderer]
rescue => e
LonaPaletteStudio.log_exception("build_gear_sampling_bitmap slot=#{current_gear_slot_key.inspect} layer=#{current_gear_layer_key.inspect}", e)
[current_preview_bitmap, nil]
end
def resolve_sample_color(bitmap, sample_x, sample_y)
return nil if bitmap.nil?
search_radius = 4
0.upto(search_radius) do |radius|
x_min = [sample_x - radius, 0].max
x_max = [sample_x + radius, bitmap.width - 1].min
y_min = [sample_y - radius, 0].max
y_max = [sample_y + radius, bitmap.height - 1].min
x_min.upto(x_max) do |x|
y_min.upto(y_max) do |y|
color = bitmap.get_pixel(x, y) rescue nil
next if color.nil? || color.alpha.to_i <= 0
return [color, x, y]
end
end
end
nil
end
def preview_draw_rect
bitmap = current_preview_bitmap
return nil if bitmap.nil?
return nil if bitmap.respond_to?(:disposed?) && bitmap.disposed?
target_rect = preview_image_rect_bounds
src_w = [bitmap.width, 1].max
src_h = [bitmap.height, 1].max
scale = [target_rect[2].to_f / src_w, target_rect[3].to_f / src_h].min
scale = 1.0 if scale > 1.0
draw_w = [(src_w * scale).to_i, 1].max
draw_h = [(src_h * scale).to_i, 1].max
draw_x = target_rect[0] + (target_rect[2] - draw_w) / 2
draw_y = target_rect[1] + (target_rect[3] - draw_h) / 2
[draw_x, draw_y, draw_w, draw_h]
end
def point_in_preview?
rect = preview_draw_rect
return false if rect.nil?
Mouse.within_XYWH?(rect[0], rect[1], rect[2], rect[3])
end
def preview_sample_coords_from_mouse(bitmap = nil)
bitmap ||= current_preview_bitmap
rect = preview_draw_rect
return nil if rect.nil? || bitmap.nil?
mouse_x, mouse_y = Mouse.GetMouseXY
return nil unless Mouse.within_XYWH?(rect[0], rect[1], rect[2], rect[3])
sample_x = LonaPaletteStudio.clamp(((mouse_x - rect[0]).to_f / [rect[2], 1].max) * bitmap.width, 0.0, bitmap.width - 1.0).to_i
sample_y = LonaPaletteStudio.clamp(((mouse_y - rect[1]).to_f / [rect[3], 1].max) * bitmap.height, 0.0, bitmap.height - 1.0).to_i
[sample_x, sample_y]
end
def preview_active_parts
return [] if @preview_renderer.nil?
parts = @preview_renderer.instance_variable_get(:@prts) rescue nil
if parts.nil? || parts.empty?
parts_map = @preview_renderer.instance_variable_get(:@allParts) rescue nil
pose_name = @preview_pose_name
if pose_name.nil? || pose_name.to_s.empty?
pose_name = @preview_renderer.instance_variable_get(:@palette_studio_pose_name) rescue nil
end
parts = parts_map[pose_name] if parts_map.is_a?(Hash) && pose_name && parts_map[pose_name]
end
Array(parts)
rescue => e
LonaPaletteStudio.audit_error("preview_active_parts failed #{e.class}: #{e.message}")
[]
end
def preview_part_bitmap(part)
bitmap = part.bitmap rescue nil
bitmap = part.instance_variable_get(:@bitmap) rescue nil if bitmap.nil?
return nil if bitmap.nil?
return nil if bitmap.respond_to?(:disposed?) && bitmap.disposed?
bitmap
rescue
nil
end
def preview_part_target(part)
target = part.prtArrKey rescue nil
target = part.instance_variable_get(:@prtArrKey) rescue nil if target.nil?
target
end
def preview_part_offset(part)
x = part.respond_to?(:posX) ? part.posX.to_i : 0
y = part.respond_to?(:posY) ? part.posY.to_i : 0
[x, y]
rescue
[0, 0]
end
def preview_part_source_bitmap(part, target)
bitmap = nil
if !target.nil? && part.respond_to?(:lona_palette_studio_orig_get_bitmap)
bitmap = part.lona_palette_studio_orig_get_bitmap(target)
elsif !target.nil? && part.respond_to?(:lona_palette_studio_chs_orig_get_bitmap)
bitmap = part.lona_palette_studio_chs_orig_get_bitmap(target)
end
if bitmap.nil? || (bitmap.respond_to?(:disposed?) && bitmap.disposed?)
bitmap = preview_part_bitmap(part)
end
bitmap
rescue
preview_part_bitmap(part)
end
def preview_probe_state
state = {}
LonaPaletteStudio::PROFILE_KEYS.each do |profile_key|
profile = LonaPaletteStudio.default_profile(profile_key)
profile["enabled"] = 1 if profile.is_a?(Hash)
state[profile_key] = profile
end
state
end
def preview_fallback_target_key(hit)
return nil if hit.nil?
category = hit[:category].to_s
pixel = hit[:pixel]
return nil if category.empty?
return category if pixel.nil?
case category
when "hair_primary"
return "hair_highlight" if LonaPaletteStudio.palette_source_pixel?("hair_highlight", pixel.red, pixel.green, pixel.blue)
"hair_primary"
when /\Agear_/
layer_key = LonaPaletteStudio.gear_layer_for_pixel(category, pixel.red, pixel.green, pixel.blue) || "base"
LonaPaletteStudio.gear_profile_key(category, layer_key)
else
category
end
end
def resolve_preview_part_hit(sample_x, sample_y)
preview_active_parts.reverse_each do |part|
bitmap = preview_part_bitmap(part)
next if bitmap.nil?
offset_x, offset_y = preview_part_offset(part)
local_x = sample_x - offset_x
local_y = sample_y - offset_y
next if local_x < 0 || local_y < 0 || local_x >= bitmap.width || local_y >= bitmap.height
pixel = bitmap.get_pixel(local_x, local_y) rescue nil
next if pixel.nil? || pixel.alpha.to_i <= 0
target = preview_part_target(part)
filename = LonaPaletteStudio.filename_for_part_map(part, target)
category = LonaPaletteStudio.category_for_part(part, filename)
next if category.nil?
source_bitmap = preview_part_source_bitmap(part, target)
source_pixel = pixel
if source_bitmap && local_x >= 0 && local_y >= 0 && local_x < source_bitmap.width && local_y < source_bitmap.height
source_pixel = source_bitmap.get_pixel(local_x, local_y) rescue pixel
end
context = LonaPaletteStudio.secondary_skin_context_for_part(part, filename)
if context[:body_layer] && source_bitmap
painted = LonaPaletteStudio.load_painted_mask(filename, source_bitmap.width, source_bitmap.height)
context[:painted_mask] = painted if painted
end
return {
:part => part,
:bitmap => source_bitmap || bitmap,
:pixel => source_pixel || pixel,
:local_x => local_x,
:local_y => local_y,
:filename => filename,
:category => category,
:context => context
}
end
nil
rescue => e
LonaPaletteStudio.audit_error("resolve_preview_part_hit failed #{e.class}: #{e.message}")
nil
end
def resolve_preview_target_key(hit)
return nil if hit.nil?
bitmap = hit[:bitmap]
pixel = hit[:pixel]
return preview_fallback_target_key(hit) if bitmap.nil? || pixel.nil?
target = LonaPaletteStudio.pixel_target_for(
pixel.red,
pixel.green,
pixel.blue,
pixel.alpha,
hit[:category],
preview_probe_state,
hit[:context],
hit[:local_x],
hit[:local_y],
bitmap.width,
bitmap.height
)
return target[0] if target
preview_fallback_target_key(hit)
rescue => e
LonaPaletteStudio.audit_error("resolve_preview_target_key failed #{e.class}: #{e.message}")
preview_fallback_target_key(hit)
end
def apply_preview_target_selection(target_key)
target = target_key.to_s
return false if target.empty?
new_page_index = @page_index
new_hair_target_index = @hair_target_index
new_assc_target_index = @assc_target_index
new_soft_target_index = @soft_target_index
new_gear_slot_index = @gear_slot_index
new_gear_layer_index = @gear_layer_index
case target
when "hair_primary", "hair_highlight"
new_page_index = LonaPaletteStudio::PAGE_ORDER.index("hair_primary") || new_page_index
new_hair_target_index = LonaPaletteStudio::HAIR_TARGET_ORDER.index(target) || new_hair_target_index
when "skin"
new_page_index = LonaPaletteStudio::PAGE_ORDER.index("skin") || new_page_index
when "eyes"
new_page_index = LonaPaletteStudio::PAGE_ORDER.index("eyes") || new_page_index
when "lips", "nipples", "vag"
new_page_index = LonaPaletteStudio::PAGE_ORDER.index("nipples") || new_page_index
new_soft_target_index = LonaPaletteStudio::SOFT_TARGET_ORDER.index(target) || new_soft_target_index
when "piercing_face", "piercing_nipple", "piercing_arm", "piercing_belly", "piercing_vag"
new_page_index = LonaPaletteStudio::PAGE_ORDER.index("assc") || new_page_index
new_assc_target_index = LonaPaletteStudio::ASSC_TARGET_ORDER.index(target) || new_assc_target_index
when /\Agear_.+_(base|trim|metal)\z/
layer_key = LonaPaletteStudio::GEAR_LAYER_ORDER.find { |candidate| target.end_with?("_" + candidate) }
return false if layer_key.nil?
slot_key = target.sub(/_#{layer_key}\z/, "")
slot_index = LonaPaletteStudio::GEAR_SLOT_ORDER.index(slot_key)
layer_index = LonaPaletteStudio::GEAR_LAYER_ORDER.index(layer_key)
return false if slot_index.nil? || layer_index.nil?
new_page_index = LonaPaletteStudio::PAGE_ORDER.index("gear") || new_page_index
new_gear_slot_index = slot_index
new_gear_layer_index = layer_index
else
return false
end
page_changed = @page_index != new_page_index
target_changed =
@hair_target_index != new_hair_target_index ||
@assc_target_index != new_assc_target_index ||
@soft_target_index != new_soft_target_index ||
@gear_slot_index != new_gear_slot_index ||
@gear_layer_index != new_gear_layer_index
return false unless page_changed || target_changed
@page_index = new_page_index
@hair_target_index = new_hair_target_index
@assc_target_index = new_assc_target_index
@soft_target_index = new_soft_target_index
@gear_slot_index = new_gear_slot_index
@gear_layer_index = new_gear_layer_index
if page_changed
rebuilt = ensure_preview_renderer_pose!
sync_preview unless rebuilt
end
refresh
true
end
def handle_preview_click
sample = preview_sample_coords_from_mouse
return false if sample.nil?
hit = resolve_preview_part_hit(sample[0], sample[1])
return false if hit.nil?
target_key = resolve_preview_target_key(hit)
return false if target_key.nil?
changed = apply_preview_target_selection(target_key)
if LonaPaletteStudio.gear_profile?(target_key)
sample_current_gear_color_from_preview
return true
end
SndLib.play_cursor if changed && defined?(SndLib)
true
rescue => e
LonaPaletteStudio.audit_error("handle_preview_click failed #{e.class}: #{e.message}")
false
end
def sample_current_gear_color_from_preview
profile = current_profile_mutable
rect = preview_draw_rect
return if profile.nil? || rect.nil?
mouse_x, mouse_y = Mouse.GetMouseXY
return unless Mouse.within_XYWH?(rect[0], rect[1], rect[2], rect[3])
sampling_bitmap = nil
sampling_renderer = nil
sampling_bitmap, sampling_renderer = build_gear_sampling_bitmap
return if sampling_bitmap.nil?
sample_x = LonaPaletteStudio.clamp(((mouse_x - rect[0]).to_f / [rect[2], 1].max) * sampling_bitmap.width, 0.0, sampling_bitmap.width - 1.0).to_i
sample_y = LonaPaletteStudio.clamp(((mouse_y - rect[1]).to_f / [rect[3], 1].max) * sampling_bitmap.height, 0.0, sampling_bitmap.height - 1.0).to_i
resolved = resolve_sample_color(sampling_bitmap, sample_x, sample_y)
if resolved.nil?
LonaPaletteStudio.log("gear sample miss slot=#{current_gear_slot_key.inspect} layer=#{current_gear_layer_key.inspect} sample_xy=#{sample_x},#{sample_y}") if $rps_audit_log_palette_studio
return
end
color = resolved[0]
sample_x = resolved[1]
sample_y = resolved[2]
LonaPaletteStudio.set_profile_sample_rgb!(profile, color.red, color.green, color.blue)
hsv = LonaPaletteStudio.rgb_to_hsv(color.red, color.green, color.blue)
profile["enabled"] = 1
profile["h"] = LonaPaletteStudio.quantize(hsv[0], LonaPaletteStudio::HUE_STEP, 0.0, 358.0)
profile["s"] = LonaPaletteStudio.quantize(hsv[1], LonaPaletteStudio::SV_STEP, 0.0, 255.0)
profile["v"] = LonaPaletteStudio.quantize(hsv[2], LonaPaletteStudio::SV_STEP, 0.0, 255.0)
LonaPaletteStudio.log("gear sample slot=#{current_gear_slot_key.inspect} layer=#{current_gear_layer_key.inspect} rgb=#{color.red},#{color.green},#{color.blue} sample_xy=#{sample_x},#{sample_y}") if $rps_audit_log_palette_studio
note_preview_change
SndLib.play_cursor if defined?(SndLib)
rescue => e
LonaPaletteStudio.audit_error("sample_current_gear_color_from_preview failed #{e.class}: #{e.message}")
ensure
LonaPaletteStudioPreview.dispose_renderer(sampling_renderer) if defined?(sampling_renderer) && sampling_renderer
end
def point_in_wheel?
mouse_x, mouse_y = Mouse.GetMouseXY
center_x = WHEEL_X + WHEEL_SIZE / 2.0
center_y = WHEEL_Y + WHEEL_SIZE / 2.0
dx = mouse_x - center_x
dy = mouse_y - center_y
(dx * dx + dy * dy) <= (WHEEL_SIZE / 2.0) * (WHEEL_SIZE / 2.0)
end
def rect_hit?(key)
rect = @mouse_rects[key]
return false if rect.nil?
Mouse.within_XYWH?(rect[0], rect[1], rect[2], rect[3])
end
def rebuild_preview_renderer
recreate_preview_renderer
sync_preview
end
def recreate_preview_renderer
LonaPaletteStudioPreview.dispose_renderer(@preview_renderer)
@preview_pose_name = LonaPaletteStudioPreview.pose_name_for_page(current_page_key)
@preview_renderer_page_key = current_page_key
@preview_renderer = LonaPaletteStudioPreview.build_renderer(current_page_key)
end
def apply_state_to_preview_renderer(renderer, preview_state)
return if renderer.nil?
LonaPaletteStudio.assign_preview_state!(renderer, preview_state)
renderer.refresh if renderer.respond_to?(:refresh)
LonaPaletteStudioPreview.force_baseline(renderer)
renderer.force_update if renderer.respond_to?(:force_update)
end
def ensure_preview_renderer_pose!
desired_pose_name = LonaPaletteStudioPreview.pose_name_for_page(current_page_key)
return false if @preview_renderer && @preview_pose_name == desired_pose_name && @preview_renderer_page_key == current_page_key
rebuild_preview_renderer
true
end
def cycle_preview_pose(delta)
return unless LonaPaletteStudioPreview.cycle_pose(delta)
rebuild_preview_renderer
refresh
SndLib.play_cursor if defined?(SndLib)
end
def cycle_preview_expression(delta)
return unless LonaPaletteStudioPreview.cycle_expression(delta)
rebuild_preview_renderer
refresh
SndLib.play_cursor if defined?(SndLib)
end
def sync_preview(retry_attempted = false)
return if @preview_renderer.nil?
preview_state = @active && @pending_state ? @pending_state : LonaPaletteStudio.state
LonaPaletteStudio.log("sync_preview begin page=#{current_page_key.inspect} profile=#{current_profile_key.inspect} active=#{@active.inspect}") if $rps_audit_log_palette_studio
apply_state_to_preview_renderer(@preview_renderer, preview_state)
@preview_dirty = false
@last_preview_sync_frame = preview_frame_id
LonaPaletteStudio.log("sync_preview end page=#{current_page_key.inspect} profile=#{current_profile_key.inspect}") if $rps_audit_log_palette_studio
rescue => e
snapshot = LonaPaletteStudio.profile_debug_summary(current_profile_key, preview_state)
LonaPaletteStudio.log_exception("sync_preview page=#{current_page_key.inspect} profile=#{current_profile_key.inspect} active=#{@active.inspect} #{snapshot}", e)
return if retry_attempted
begin
recreate_preview_renderer
return if @preview_renderer.nil?
preview_state = @active && @pending_state ? @pending_state : LonaPaletteStudio.state
apply_state_to_preview_renderer(@preview_renderer, preview_state)
LonaPaletteStudio.audit_error("sync_preview recovered page=#{current_page_key.inspect} profile=#{current_profile_key.inspect} active=#{@active.inspect} #{snapshot}")
rescue => recovery_error
LonaPaletteStudio.log_exception("sync_preview recovery page=#{current_page_key.inspect} profile=#{current_profile_key.inspect} active=#{@active.inspect} #{snapshot}", recovery_error)
end
end
def refresh
return if @surface.nil? || @surface.bitmap.nil? || @surface.bitmap.disposed?
bmp = @surface.bitmap
bmp.clear
@mouse_rects.clear
draw_frame(bmp)
draw_preview_panel(bmp)
draw_wheel_and_slider(bmp)
draw_page_details(bmp)
draw_buttons(bmp)
draw_tabs(bmp)
draw_hints(bmp)
end
def draw_frame(bmp)
bmp.fill_rect(PANEL_X, PANEL_Y, PANEL_W, PANEL_H, Color.new(8, 10, 14, 196))
outline_rect(bmp, PANEL_X, PANEL_Y, PANEL_W, PANEL_H, Color.new(132, 154, 126, 255))
bmp.font.size = FONT_TITLE
bmp.font.bold = true
bmp.font.outline = false
bmp.font.color = Color.new(230, 240, 220, 255)
bmp.draw_text(PANEL_X + 16, PANEL_Y + 6, 220, 24, "Редактор палитры")
bmp.font.bold = true
bmp.font.size = FONT_SMALL
bmp.font.color = Color.new(160, 180, 150, 255)
status_text = if @active
current_profile["enabled"].to_i == 0 ? "Статус: выкл." : "Статус: вкл."
else
"Статус: готов"
end
bmp.draw_text(PANEL_X + PANEL_W - 148, PANEL_Y + 10, 134, 18, status_text, 2)
end
def draw_tabs(bmp)
LonaPaletteStudio::PAGE_ORDER.each_with_index do |page_key, index|
x = TAB_START_X + index * (TAB_W + TAB_GAP)
y = TAB_Y
active = index == @page_index
fill = active ? Color.new(88, 132, 92, 220) : Color.new(26, 34, 28, 220)
outline = active ? Color.new(200, 236, 192, 255) : Color.new(100, 120, 96, 255)
bmp.fill_rect(x, y, TAB_W, TAB_H, fill)
outline_rect(bmp, x, y, TAB_W, TAB_H, outline)
bmp.font.size = FONT_SMALL
bmp.font.color = active ? Color.new(248, 255, 244, 255) : Color.new(180, 194, 178, 255)
bmp.draw_text(x, y + 1, TAB_W, TAB_H, LonaPaletteStudio::PAGE_NAMES[page_key], 1)
@mouse_rects[("tab_" + page_key).to_sym] = [x, y, TAB_W, TAB_H]
end
end
def draw_preview_panel(bmp)
panel_x = PREVIEW_X - 6
panel_y = PREVIEW_Y - 22
panel_w = PREVIEW_W + 12
panel_h = PREVIEW_H + 28
draw_section_panel(bmp, panel_x, panel_y, panel_w, panel_h, "")
draw_preview_control_row(bmp, panel_x + 8, panel_y + 4, panel_w - 16, PREVIEW_CONTROL_ROW_H, "< #{LonaPaletteStudioPreview.current_pose_label} >", :preview_pose_prev, :preview_pose_next)
draw_preview_control_row(bmp, panel_x + 8, panel_y + 4 + PREVIEW_CONTROL_ROW_H + PREVIEW_CONTROL_GAP, panel_w - 16, PREVIEW_CONTROL_ROW_H, "< #{LonaPaletteStudioPreview.current_expression_label} >", :preview_expression_prev, :preview_expression_next)
draw_preview_metrics(bmp, panel_x + 8, panel_y + 4 + PREVIEW_CONTROL_ROW_H * 2 + PREVIEW_CONTROL_GAP + 2, panel_w - 16)
preview_bitmap = nil
begin
preview_bitmap = @preview_renderer.portrait.bitmap if @preview_renderer && @preview_renderer.respond_to?(:portrait)
rescue
preview_bitmap = nil
end
image_rect = preview_image_rect_bounds
if preview_bitmap && (!preview_bitmap.respond_to?(:disposed?) || !preview_bitmap.disposed?)
draw_bitmap_fit(bmp, preview_bitmap, image_rect[0], image_rect[1], image_rect[2], image_rect[3])
else
bmp.font.size = FONT_BODY
bmp.font.color = Color.new(190, 190, 190, 255)
bmp.draw_text(image_rect[0], image_rect[1] + 88, image_rect[2], 20, "Нет предпросмотра", 1)
end
end
def draw_preview_metrics(bmp, x, y, width)
profile = current_profile
bmp.font.size = FONT_SMALL
bmp.font.color = Color.new(168, 184, 162, 255)
text = sprintf("Т:%03d Н:%03d Я:%03d", profile["h"].to_i, profile["s"].to_i, profile["v"].to_i)
bmp.draw_text(x, y, width, 14, text, 1)
end
def draw_preview_control_row(bmp, x, y, width, height, text, left_key, right_key)
bmp.fill_rect(x, y, width, height, Color.new(30, 38, 40, 220))
outline_rect(bmp, x, y, width, height, Color.new(118, 136, 124, 255))
bmp.font.size = FONT_SMALL
bmp.font.color = Color.new(234, 242, 228, 255)
bmp.draw_text(x, y, width, height, text, 1)
half_w = [width / 2, 36].max
@mouse_rects[left_key] = [x, y, half_w, height]
@mouse_rects[right_key] = [x + width - half_w, y, half_w, height]
end
def draw_wheel_and_slider(bmp)
draw_section_panel(bmp, WHEEL_X - 12, WHEEL_Y - 22, CONTROL_PANEL_W, CONTROL_PANEL_H, "#{current_control_name}: цвет")
bmp.blt(WHEEL_X, WHEEL_Y, LonaPaletteStudio.wheel_bitmap(WHEEL_SIZE, current_page_key), Rect.new(0, 0, WHEEL_SIZE, WHEEL_SIZE))
outline_rect(bmp, WHEEL_X, WHEEL_Y, WHEEL_SIZE, WHEEL_SIZE, Color.new(14, 14, 18, 255))
profile = current_profile
marker = wheel_point_for_profile(profile)
marker_x = (WHEEL_X + WHEEL_SIZE / 2.0 + marker[0]).round
marker_y = (WHEEL_Y + WHEEL_SIZE / 2.0 + marker[1]).round
draw_marker(bmp, marker_x, marker_y)
draw_value_slider(bmp, profile)
@mouse_rects[:value_slider] = [SLIDER_X, SLIDER_Y, SLIDER_W, SLIDER_H]
draw_hair_target_buttons(bmp) if current_page_key == "hair_primary"
draw_assc_target_buttons(bmp) if current_page_key == "assc"
draw_soft_target_buttons(bmp) if current_page_key == "nipples"
draw_gear_slot_buttons(bmp) if current_page_key == "gear"
end
def palette_detail_layout
layout = {
:detail_y => PRESET_Y,
:swatch_y => SWATCH_Y,
:button_y => BUTTON_Y,
:applied_x => APPLY_X,
:preview_x => APPLY_X + SWATCH_W + 14,
:toggle_x => APPLY_X + (SWATCH_W + 14) * 2,
:apply_x => APPLY_X,
:reset_x => RESET_X,
:mode_gradient_x => nil,
:mode_solid_x => nil,
:mode_y => nil,
:mode_w => BUTTON_W,
:gear_text_y => BUTTON_Y + BUTTON_H + 8,
:hint_y => 308,
:gear_layer_x => GEAR_LAYER_X,
:gear_layer_y => GEAR_LAYER_Y,
:gear_layer_w => GEAR_LAYER_W,
:gear_layer_gap => GEAR_LAYER_GAP
}
if current_page_key == "nipples"
layout[:detail_y] -= 4
layout[:swatch_y] -= 4
layout[:button_y] -= 4
layout[:gear_text_y] -= 4
layout[:hint_y] = 304
elsif current_page_key == "skin"
layout[:mode_gradient_x] = 422
layout[:mode_solid_x] = 504
layout[:mode_y] = 289
layout[:mode_w] = 78
layout[:hint_y] = 318
elsif current_page_key == "gear"
layout[:detail_y] = 200
layout[:swatch_y] = 223
layout[:button_y] = 219
layout[:applied_x] = 428
layout[:preview_x] = 428
layout[:applied_label_x] = 458
layout[:applied_label_y] = 204
layout[:applied_swatch_x] = 465
layout[:applied_swatch_y] = 222
layout[:preview_label_x] = 460
layout[:preview_label_y] = 238
layout[:preview_swatch_x] = 468
layout[:preview_swatch_y] = 253
layout[:toggle_x] = 458
layout[:toggle_y] = 271
layout[:apply_x] = 513
layout[:apply_y] = 219
layout[:reset_x] = 513
layout[:reset_y] = 246
layout[:gear_text_y] = 291
layout[:hint_y] = 318
layout[:gear_layer_x] = 385
layout[:gear_layer_y] = 198
layout[:gear_layer_w] = 64
layout[:gear_layer_gap] = 9
layout[:gear_layer_vertical] = true
end
layout
end
def draw_page_details(bmp)
profile = current_profile
applied_profile = LonaPaletteStudio.profile_for(current_profile_key, LonaPaletteStudio.state)
pending_rgb = current_color_rgb(profile)
applied_rgb = current_color_rgb(applied_profile)
layout = palette_detail_layout
text_x = WHEEL_X
detail_y = layout[:detail_y]
swatch_y = layout[:swatch_y]
button_y = layout[:button_y]
applied_x = layout[:applied_x]
preview_x = layout[:preview_x]
toggle_x = layout[:toggle_x]
applied_swatch_x = layout[:applied_swatch_x] || applied_x
applied_swatch_y = layout[:applied_swatch_y] || swatch_y
preview_swatch_x = layout[:preview_swatch_x] || preview_x
preview_swatch_y = layout[:preview_swatch_y] || swatch_y
applied_label_x = layout[:applied_label_x] || (applied_swatch_x - 6)
applied_label_y = layout[:applied_label_y] || (applied_swatch_y - 14)
preview_label_x = layout[:preview_label_x] || (preview_swatch_x - 6)
preview_label_y = layout[:preview_label_y] || (preview_swatch_y - 14)
toggle_y = layout[:toggle_y] || swatch_y
apply_y = layout[:apply_y] || button_y
reset_y = layout[:reset_y] || button_y
bmp.font.size = FONT_SMALL
bmp.font.color = Color.new(164, 184, 160, 255)
draw_wheel_style_buttons(bmp, text_x, detail_y) if wheel_style_buttons_visible?
if current_page_key == "gear"
draw_gear_layer_buttons(bmp, layout)
sample = LonaPaletteStudio.profile_sample_rgb(profile)
source_text = sample ? "Источник: #{sample[0]},#{sample[1]},#{sample[2]}" : "Щёлкните по одежде для образца"
bmp.draw_text(text_x, layout[:gear_text_y], 224, 14, source_text)
bmp.draw_text(text_x, layout[:gear_text_y] + 14, 224, 14, "Цвет 1/2/3 → образец → круг")
end
bmp.draw_text(applied_label_x, applied_label_y, SWATCH_W + 12, 14, "Было", 1)
bmp.fill_rect(applied_swatch_x, applied_swatch_y, SWATCH_W, SWATCH_H, Color.new(applied_rgb[0], applied_rgb[1], applied_rgb[2], applied_profile["enabled"].to_i == 0 ? 72 : 255))
outline_rect(bmp, applied_swatch_x, applied_swatch_y, SWATCH_W, SWATCH_H, Color.new(220, 226, 216, 255))
bmp.draw_text(preview_label_x, preview_label_y, SWATCH_W + 12, 14, "Будет", 1)
bmp.fill_rect(preview_swatch_x, preview_swatch_y, SWATCH_W, SWATCH_H, Color.new(pending_rgb[0], pending_rgb[1], pending_rgb[2], profile["enabled"].to_i == 0 ? 72 : 255))
outline_rect(bmp, preview_swatch_x, preview_swatch_y, SWATCH_W, SWATCH_H, Color.new(220, 226, 216, 255))
draw_skin_mode_buttons(bmp, layout) if current_page_key == "skin"
toggle_w = TOGGLE_W
bmp.fill_rect(toggle_x, toggle_y - 1, toggle_w, SWATCH_H + 2, Color.new(28, 36, 30, 220))
outline_rect(bmp, toggle_x, toggle_y - 1, toggle_w, SWATCH_H + 2, Color.new(126, 148, 120, 255))
bmp.font.size = FONT_SMALL
bmp.font.color = profile["enabled"].to_i == 0 ? Color.new(214, 180, 180, 255) : Color.new(202, 236, 194, 255)
bmp.draw_text(toggle_x, toggle_y, toggle_w, SWATCH_H, profile["enabled"].to_i == 0 ? "Вкл." : "Выкл.", 1)
@mouse_rects[:current_toggle] = [toggle_x, toggle_y - 1, toggle_w, SWATCH_H + 2]
draw_button(bmp, layout[:apply_x], apply_y, BUTTON_W, BUTTON_H, "Примен.", Color.new(86, 132, 92, 220), Color.new(224, 248, 220, 255))
draw_button(bmp, layout[:reset_x], reset_y, BUTTON_W, BUTTON_H, "Сброс", Color.new(112, 70, 70, 220), Color.new(252, 226, 220, 255))
@mouse_rects[:apply] = [layout[:apply_x], apply_y, BUTTON_W, BUTTON_H]
@mouse_rects[:reset] = [layout[:reset_x], reset_y, BUTTON_W, BUTTON_H]
end
def draw_wheel_style_buttons(bmp, x, y)
bmp.font.size = FONT_SMALL
bmp.font.color = Color.new(164, 184, 160, 255)
LonaPaletteStudio::WHEEL_STYLE_OPTIONS.each_with_index do |style_key, index|
preset_x = x + index * (PRESET_W + PRESET_GAP)
active = LonaPaletteStudio.wheel_style_for_page(current_page_key) == style_key
fill = active ? Color.new(90, 128, 96, 220) : Color.new(64, 78, 62, 220)
outline = active ? Color.new(212, 238, 204, 255) : Color.new(138, 160, 132, 255)
bmp.fill_rect(preset_x, y, PRESET_W, PRESET_H, fill)
outline_rect(bmp, preset_x, y, PRESET_W, PRESET_H, outline)
bmp.font.color = active ? Color.new(248, 255, 244, 255) : Color.new(232, 240, 226, 255)
bmp.draw_text(preset_x, y, PRESET_W, PRESET_H, LonaPaletteStudio.wheel_style_label(style_key), 1)
@mouse_rects[("wheel_style_" + index.to_s).to_sym] = [preset_x, y, PRESET_W, PRESET_H]
end
end
def draw_skin_mode_buttons(bmp, layout)
mode_y = layout[:mode_y]
return if mode_y.nil?
button_w = layout[:mode_w].to_i
[["gradient", layout[:mode_gradient_x]], ["solid", layout[:mode_solid_x]]].each do |mode_key, button_x|
next if button_x.nil?
active = current_skin_color_mode == mode_key
fill = active ? Color.new(90, 128, 96, 220) : Color.new(64, 78, 62, 220)
text_color = active ? Color.new(248, 255, 244, 255) : Color.new(232, 240, 226, 255)
draw_button(bmp, button_x.to_i, mode_y.to_i, button_w, BUTTON_H, LonaPaletteStudio.skin_color_mode_label(mode_key), fill, text_color)
@mouse_rects[("skin_mode_" + mode_key).to_sym] = [button_x.to_i, mode_y.to_i, button_w, BUTTON_H]
end
end
def draw_assc_target_buttons(bmp)
LonaPaletteStudio::ASSC_TARGET_ORDER.each_with_index do |slot_key, index|
y = ASSC_SLOT_Y + index * (ASSC_SLOT_H + ASSC_SLOT_GAP)
active = slot_key == current_assc_target_key
fill = active ? Color.new(88, 132, 92, 220) : Color.new(42, 50, 46, 220)
outline = active ? Color.new(220, 244, 212, 255) : Color.new(112, 128, 118, 255)
bmp.fill_rect(ASSC_SLOT_X, y, ASSC_SLOT_W, ASSC_SLOT_H, fill)
outline_rect(bmp, ASSC_SLOT_X, y, ASSC_SLOT_W, ASSC_SLOT_H, outline)
bmp.font.size = 10
bmp.font.color = active ? Color.new(248, 255, 244, 255) : Color.new(218, 228, 212, 255)
bmp.draw_text(ASSC_SLOT_X, y, ASSC_SLOT_W, ASSC_SLOT_H, LonaPaletteStudio::ASSC_TARGET_NAMES[slot_key], 1)
@mouse_rects[("assc_slot_" + index.to_s).to_sym] = [ASSC_SLOT_X, y, ASSC_SLOT_W, ASSC_SLOT_H]
end
end
def draw_hair_target_buttons(bmp)
LonaPaletteStudio::HAIR_TARGET_ORDER.each_with_index do |slot_key, index|
y = ASSC_SLOT_Y + index * (ASSC_SLOT_H + ASSC_SLOT_GAP)
active = slot_key == current_hair_target_key
fill = active ? Color.new(88, 132, 92, 220) : Color.new(42, 50, 46, 220)
outline = active ? Color.new(220, 244, 212, 255) : Color.new(112, 128, 118, 255)
bmp.fill_rect(ASSC_SLOT_X, y, ASSC_SLOT_W, ASSC_SLOT_H, fill)
outline_rect(bmp, ASSC_SLOT_X, y, ASSC_SLOT_W, ASSC_SLOT_H, outline)
bmp.font.size = 10
bmp.font.color = active ? Color.new(248, 255, 244, 255) : Color.new(218, 228, 212, 255)
bmp.draw_text(ASSC_SLOT_X, y, ASSC_SLOT_W, ASSC_SLOT_H, LonaPaletteStudio::HAIR_TARGET_NAMES[slot_key], 1)
@mouse_rects[("hair_slot_" + index.to_s).to_sym] = [ASSC_SLOT_X, y, ASSC_SLOT_W, ASSC_SLOT_H]
end
end
def draw_soft_target_buttons(bmp)
LonaPaletteStudio::SOFT_TARGET_ORDER.each_with_index do |slot_key, index|
y = SOFT_SLOT_Y + index * (SOFT_SLOT_H + SOFT_SLOT_GAP)
active = slot_key == current_soft_target_key
fill = active ? Color.new(88, 132, 92, 220) : Color.new(42, 50, 46, 220)
outline = active ? Color.new(220, 244, 212, 255) : Color.new(112, 128, 118, 255)
bmp.fill_rect(SOFT_SLOT_X, y, SOFT_SLOT_W, SOFT_SLOT_H, fill)
outline_rect(bmp, SOFT_SLOT_X, y, SOFT_SLOT_W, SOFT_SLOT_H, outline)
bmp.font.size = 10
bmp.font.color = active ? Color.new(248, 255, 244, 255) : Color.new(218, 228, 212, 255)
bmp.draw_text(SOFT_SLOT_X, y, SOFT_SLOT_W, SOFT_SLOT_H, LonaPaletteStudio::SOFT_TARGET_NAMES[slot_key], 1)
@mouse_rects[("soft_slot_" + index.to_s).to_sym] = [SOFT_SLOT_X, y, SOFT_SLOT_W, SOFT_SLOT_H]
end
end
def gear_slot_draw_position(slot_key, index)
column = index % GEAR_SLOT_COLUMNS
row = index / GEAR_SLOT_COLUMNS
x = GEAR_SLOT_X + column * (GEAR_SLOT_W + GEAR_SLOT_COL_GAP)
y = GEAR_SLOT_Y + row * (GEAR_SLOT_H + GEAR_SLOT_GAP)
if slot_key == "gear_anal"
x = GEAR_SLOT_X + (GEAR_SLOT_W + GEAR_SLOT_COL_GAP)
y = GEAR_SLOT_Y + 6 * (GEAR_SLOT_H + GEAR_SLOT_GAP)
elsif slot_key == "gear_offhand"
x = GEAR_SLOT_X + (GEAR_SLOT_W + GEAR_SLOT_COL_GAP)
y = GEAR_SLOT_Y + 7 * (GEAR_SLOT_H + GEAR_SLOT_GAP)
end
[x, y]
end
def draw_gear_slot_buttons(bmp)
LonaPaletteStudio::GEAR_SLOT_ORDER.each_with_index do |slot_key, index|
x, y = gear_slot_draw_position(slot_key, index)
active = slot_key == current_gear_slot_key
fill = active ? Color.new(88, 132, 92, 220) : Color.new(42, 50, 46, 220)
outline = active ? Color.new(220, 244, 212, 255) : Color.new(112, 128, 118, 255)
bmp.fill_rect(x, y, GEAR_SLOT_W, GEAR_SLOT_H, fill)
outline_rect(bmp, x, y, GEAR_SLOT_W, GEAR_SLOT_H, outline)
bmp.font.size = 10
bmp.font.color = active ? Color.new(248, 255, 244, 255) : Color.new(218, 228, 212, 255)
bmp.draw_text(x, y, GEAR_SLOT_W, GEAR_SLOT_H, LonaPaletteStudio::GEAR_SLOT_NAMES[slot_key], 1)
@mouse_rects[("gear_slot_" + index.to_s).to_sym] = [x, y, GEAR_SLOT_W, GEAR_SLOT_H]
end
end
def draw_gear_layer_buttons(bmp, layout = nil)
x_base = layout ? layout[:gear_layer_x].to_i : GEAR_LAYER_X
y_base = layout ? layout[:gear_layer_y].to_i : GEAR_LAYER_Y
width = layout ? layout[:gear_layer_w].to_i : GEAR_LAYER_W
gap = layout ? layout[:gear_layer_gap].to_i : GEAR_LAYER_GAP
vertical = layout ? layout[:gear_layer_vertical] : false
LonaPaletteStudio::GEAR_LAYER_ORDER.each_with_index do |layer_key, index|
x = vertical ? x_base : (x_base + index * (width + gap))
y = vertical ? (y_base + index * (GEAR_LAYER_H + gap)) : y_base
active = layer_key == current_gear_layer_key
fill = active ? Color.new(90, 128, 96, 220) : Color.new(64, 78, 62, 220)
outline = active ? Color.new(212, 238, 204, 255) : Color.new(138, 160, 132, 255)
bmp.fill_rect(x, y, width, GEAR_LAYER_H, fill)
outline_rect(bmp, x, y, width, GEAR_LAYER_H, outline)
bmp.font.size = FONT_SMALL
bmp.font.color = active ? Color.new(248, 255, 244, 255) : Color.new(232, 240, 226, 255)
bmp.draw_text(x, y, width, GEAR_LAYER_H, LonaPaletteStudio::GEAR_LAYER_NAMES[layer_key], 1)
@mouse_rects[("gear_layer_" + index.to_s).to_sym] = [x, y, width, GEAR_LAYER_H]
end
end
def draw_buttons(bmp)
end
def smart_input_label(symbol, fallback = nil)
if defined?(InputUtils)
if InputUtils.respond_to?(:getKeyAndTranslate)
label = InputUtils.getKeyAndTranslate(symbol).to_s
return label unless label.empty?
end
if InputUtils.respond_to?(:getKeyAndTranslateLong)
label = InputUtils.getKeyAndTranslateLong(symbol).to_s
return label unless label.empty?
end
end
fallback.nil? ? symbol.to_s : fallback.to_s
rescue
fallback.nil? ? symbol.to_s : fallback.to_s
end
def gamepad_ui_mode?
mode = ($data_GamePadUImode rescue nil).to_s
mode == "PS" || mode == "XB" || mode == "ND"
end
def direction_input_hint
return "КРЕСТОВИНА / СТИК" if gamepad_ui_mode?
"СТРЕЛКИ / WASD"
end
def action_hint_text
[
"#{smart_input_label(:C, 'Z')} ок",
"#{smart_input_label(:B, 'X')} назад",
"#{smart_input_label(:L, 'Q')}/#{smart_input_label(:R, 'E')} вкладки",
"#{smart_input_label(:UI_DeleteItem, 'Del')} сб."
].join(" ")
end
def detail_hint_text
case current_page_key
when "assc"
"Клик: пирсинг или поза."
when "skin"
"Режим действует на Кожу 1 и 2."
when "nipples"
"Клик: зона; управление: цвет."
when "gear"
"Клик: слот, слой и образец."
when "hair_primary"
"Клик: волосы; управление: цвет."
when "eyes"
"Клик: глаза; круг: цвет радужки."
else
"Клик: цель; управление: цвет."
end
end
def draw_hints(bmp)
bmp.font.size = FONT_SMALL
bmp.font.color = Color.new(156, 172, 150, 255)
hint_x = WHEEL_X - 6
hint_w = CONTROL_PANEL_W - 12
hint_y = palette_detail_layout[:hint_y]
bmp.draw_text(hint_x, hint_y, hint_w, 14, LonaPaletteStudio.page_hint_text(current_page_key), 1)
bmp.draw_text(hint_x, hint_y + 14, hint_w, 14, action_hint_text, 1)
bmp.draw_text(hint_x, hint_y + 28, hint_w, 14, detail_hint_text, 1)
end
def draw_value_slider(bmp, profile)
row = 0
while row < SLIDER_H
value = ((SLIDER_H - row) / SLIDER_H.to_f) * 255.0
rgb = LonaPaletteStudio.hsv_to_rgb(profile["h"], profile["s"], value)
bmp.fill_rect(SLIDER_X, SLIDER_Y + row, SLIDER_W, 1, Color.new(rgb[0], rgb[1], rgb[2], 255))
row += 1
end
outline_rect(bmp, SLIDER_X, SLIDER_Y, SLIDER_W, SLIDER_H, Color.new(18, 18, 18, 255))
handle_y = (SLIDER_Y + (SLIDER_H - 1) - (profile["v"].to_f / 255.0 * (SLIDER_H - 1))).round
bmp.fill_rect(SLIDER_X - 3, handle_y - 1, SLIDER_W + 6, 3, Color.new(250, 250, 250, 255))
end
def draw_button(bmp, x, y, width, height, text, fill, text_color)
bmp.fill_rect(x, y, width, height, fill)
outline_rect(bmp, x, y, width, height, Color.new(18, 18, 18, 255))
bmp.font.size = FONT_BODY
bmp.font.color = text_color
bmp.draw_text(x, y + 1, width, height, text, 1)
end
def draw_section_panel(bmp, x, y, width, height, title)
bmp.fill_rect(x, y, width, height, Color.new(18, 22, 28, 188))
outline_rect(bmp, x, y, width, height, Color.new(110, 128, 118, 255))
bmp.font.size = FONT_SMALL
bmp.font.color = Color.new(210, 224, 204, 255)
bmp.draw_text(x + 6, y + 2, width - 12, 14, title)
end
def outline_rect(bmp, x, y, width, height, color)
bmp.fill_rect(x, y, width, 1, color)
bmp.fill_rect(x, y + height - 1, width, 1, color)
bmp.fill_rect(x, y, 1, height, color)
bmp.fill_rect(x + width - 1, y, 1, height, color)
end
def draw_marker(bmp, x, y)
bmp.fill_rect(x - 4, y, 9, 1, Color.new(0, 0, 0, 255))
bmp.fill_rect(x, y - 4, 1, 9, Color.new(0, 0, 0, 255))
bmp.fill_rect(x - 3, y, 7, 1, Color.new(255, 255, 255, 255))
bmp.fill_rect(x, y - 3, 1, 7, Color.new(255, 255, 255, 255))
outline_rect(bmp, x - 3, y - 3, 7, 7, Color.new(18, 18, 18, 255))
end
def draw_bitmap_fit(bmp, source_bitmap, x, y, width, height)
src_w = [source_bitmap.width, 1].max
src_h = [source_bitmap.height, 1].max
scale = [width.to_f / src_w, height.to_f / src_h].min
scale = 1.0 if scale > 1.0
draw_w = [(src_w * scale).to_i, 1].max
draw_h = [(src_h * scale).to_i, 1].max
draw_x = x + (width - draw_w) / 2
draw_y = y + (height - draw_h) / 2
bmp.stretch_blt(Rect.new(draw_x, draw_y, draw_w, draw_h), source_bitmap, source_bitmap.rect)
end
end
class Lona_Part
alias lona_palette_studio_orig_get_bitmap get_bitmap unless method_defined?(:lona_palette_studio_orig_get_bitmap)
def get_bitmap(target)
bitmap = lona_palette_studio_orig_get_bitmap(target)
filename = LonaPaletteStudio.filename_for_part_map(self, target)
LonaPaletteStudio.recolor_bitmap_for_part(self, bitmap, filename)
end
end
class Lona_CHS_Part
unless method_defined?(:lona_palette_studio_chs_orig_get_bitmap)
alias lona_palette_studio_chs_orig_get_bitmap get_bitmap
end
def get_bitmap(target, h_mode = -1, position = -1)
filename = nil
if h_mode >= 0
filename = @h_bitmaps[h_mode][target] rescue nil
else
filename = @bitmaps[target] rescue nil
end
bitmap = lona_palette_studio_chs_orig_get_bitmap(target, h_mode, position)
LonaPaletteStudio.recolor_bitmap_for_part(self, bitmap, filename)
end
end