# 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