Files
LonaRPG-Online-Games/ModScripts/_Mods/LonaPaletteStudio/Scripts/0_LonaPaletteStudio.rb
T
2026-10-29 21:59:06 +04:00

4833 lines
173 KiB
Ruby
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
# 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