Files
LonaRPG-Online-Games/Data/Scripts/Frames/RVscript/450_KHAS_LightGraphicLib.rb
T

663 lines
19 KiB
Ruby
Raw Normal View History

2026-10-29 21:59:06 +04:00
unless defined?(Ruby310Compat)
begin
compat_candidates = []
begin
compat_candidates << File.expand_path('000_Ruby310_Compat.rb', File.dirname(__FILE__))
rescue StandardError
end
begin
cwd = Dir.pwd.to_s
compat_candidates << File.expand_path('Data/Scripts/000_Ruby310_Compat.rb', cwd) unless cwd.empty?
compat_candidates << File.expand_path('000_Ruby310_Compat.rb', cwd) unless cwd.empty?
rescue StandardError
end
compat_candidates.compact.uniq.each do |compat_path|
next unless File.file?(compat_path)
load compat_path
break if defined?(Ruby310Compat)
end
rescue StandardError
end
end
#-------------------------------------------------------------------------------
# * [ACE] Khas Graphics Library
#-------------------------------------------------------------------------------
# * By Nilo K. (Khas)
# * Version: 2.0
# * Released on: 01/22/2017
#
# Blog: arcthunder.blogspot.com
# Facebook: facebook.com/khasarc
# Twitter: twitter.com/arcthunder
# Youtube: youtube.com/c/khasarc
#
#-------------------------------------------------------------------------------
# * Terms of Use
#-------------------------------------------------------------------------------
# When using KHAS GRAPHICS LIBRARY (the script), including its library, you
# agree with the following terms:
# 1. If you purchased a license to one of my scripts, credit is not required.
# Otherwise, you must give credit to Khas (if you want, a link to my blog is
# always appreciated);
# 2. You can use the script for free in both non-commercial and commercial
# projects;
# 4. You can edit the script for using in your own project. However, you are
# not allowed to share/distribute any modified version;
# 5. If you want to share a Khas script, don’t post the direct download link,
# redirect the user to my blog instead;
# 6. The script can not be ported to any RPG Maker version than VX Ace.
#
#-------------------------------------------------------------------------------
# * Updates
#-------------------------------------------------------------------------------
# Please check my blog for KGL updates!
#
#-------------------------------------------------------------------------------
# * Requirements
#-------------------------------------------------------------------------------
# 1. Khas Core Library
# Place the "Khas Core Library" script before KGL.
#
# 2. Khas Graphics Library file
# Place the "KGL2.klib" file in your game's System folder.
# You can customize the library location if you need.
#
#-------------------------------------------------------------------------------
# * Graphics Core (configuration)
#-------------------------------------------------------------------------------
module Graphics_Core
# LIBRARY FOLDER
# If you want to place the "KGL2.klib" file in another folder,
# please change the string below.
KGL_Folder = "System/"
# SCREEN RESOLUTION
# Change this if you are using a custom resolution script.
Screen_Width = Graphics.width
Screen_Height = Graphics.height
end
#-------------------------------------------------------------------------------
# * Requirements
#-------------------------------------------------------------------------------
unless $khas && $khas[:core]
warning = Sprite.new
warning.bitmap = Bitmap.new(Graphics.width,Graphics.height)
warning.bitmap.fill_rect(0,0,Graphics.width,Graphics.height,Color.new(255,255,255))
warning.bitmap.font = Font.new(System_Settings::MESSAGE_WINDOW_FONT_NAME, 32)
warning.bitmap.font.bold = true
warning.bitmap.font.outline = false
warning.bitmap.font.color.set(255,144,9)
warning.bitmap.draw_text(0,Graphics.height/2-32,Graphics.width,32,"PLEASE INSTALL",1)
warning.bitmap.draw_text(0,Graphics.height/2,Graphics.width,32,"KHAS CORE LIBRARY 1.03",1)
while !Input.trigger?(:C)
Input.update
Graphics.update
end
warning.bitmap.dispose
warning.dispose
exit
end
#-------------------------------------------------------------------------------
# * KGL
#-------------------------------------------------------------------------------
# mkxp-z port note:
# - prefers the embedded KGL2 library from the custom mkxp-z executable
# - falls back to the legacy System/KGL2.klib path on older builds
# - on mkxp-z, still falls back to a software/no-KGL path so the project can boot
module KGL
@@mkxp_z = defined?(System) && System.const_defined?(:VERSION)
@@software = false
@@software_reason = nil
@@framebuffer = nil
@@shadowbuffer = nil
@@light_blending = true
@@soft_shadows = false
@@native_bitmap_mode = false
@@native = {}
@@native_bitmap_handles = {}
@@native_dirty = {}
@@native_tmp = {}
@@downloadBufferRect = nil
@@clearBufferRectRGBA = nil
@@lightShaderBufferClip = nil
@@library_name = nil
def self.library_candidates
legacy_path = "#{Graphics_Core::KGL_Folder}KGL2.klib"
seen = {}
["KGL2", legacy_path].compact.map { |entry| entry.to_s }.reject { |entry| entry == "" }.select { |entry| seen[entry] ? false : (seen[entry] = true) }
rescue
["KGL2", "#{Graphics_Core::KGL_Folder}KGL2.klib"]
end
def self.bind_function(library_name, name, p="")
Ruby310Compat.native_api(library_name, name, p, "i")
end
def self.function(name, p="")
if @@library_name
return bind_function(@@library_name, name, p)
end
last_error = nil
library_candidates.each do |library_name|
begin
api = bind_function(library_name, name, p)
@@library_name = library_name
return api
rescue Exception => e
last_error = e
end
end
raise(last_error || LoadError.new("KGL2 library is unavailable"))
end
begin
@@version = KGL.function("kglVersion")
@@load = KGL.function("kglLoad")
@@blank = KGL.function("kglBlank", "i")
@@clear = KGL.function("kglClear", "ii")
@@invert = KGL.function("kglInvert", "i")
@@clone = KGL.function("kglClone", "ii")
@@bindFramebuffer = KGL.function("kglBindFramebuffer", "i")
@@bindShadowbuffer = KGL.function("kglBindShadowbuffer", "i")
@@unbindFramebuffer = KGL.function("kglUnbindFramebuffer")
@@unbindShadowbuffer = KGL.function("kglUnbindShadowbuffer")
@@clearFramebuffer = KGL.function("kglClearFramebuffer")
@@compressAlpha = KGL.function("kglCompressAlpha", "i")
@@lightBlending = KGL.function("kglLightBlending", "i")
@@lightShader = KGL.function("kglLightShader", "iiii")
@@softShadows = KGL.function("kglSoftShadows", "i")
@@shadowShaderH = KGL.function("kglShadowShaderH", "iii")
@@shadowShaderV = KGL.function("kglShadowShaderV", "iii")
@@shadowShaderW = KGL.function("kglShadowShaderW", "iii")
if @@mkxp_z
@@createBuffer = KGL.function("kglCreateBuffer", "ii")
@@destroyBuffer = KGL.function("kglDestroyBuffer", "i")
@@uploadBuffer = KGL.function("kglUploadBuffer", "ipi")
@@downloadBuffer = KGL.function("kglDownloadBuffer", "ipi")
@@downloadBufferRect = KGL.function("kglDownloadBufferRect", "ipiiiii")
@@blankBuffer = KGL.function("kglBlankBuffer", "i")
@@clearBufferRGBA = KGL.function("kglClearBufferRGBA", "ii")
@@clearBufferRectRGBA = KGL.function("kglClearBufferRectRGBA", "iiiiii")
@@cloneBuffer = KGL.function("kglCloneBuffer", "ii")
@@compressAlphaBuffer = KGL.function("kglCompressAlphaBuffer", "i")
@@bindFramebufferBuffer = KGL.function("kglBindFramebufferBuffer", "i")
@@bindShadowbufferBuffer = KGL.function("kglBindShadowbufferBuffer", "i")
@@lightShaderBuffer = KGL.function("kglLightShaderBuffer", "iiii")
@@lightShaderBufferClip = KGL.function("kglLightShaderBufferClip", "iiiiiiii")
@@native_bitmap_mode = true
end
rescue Exception => e
if @@mkxp_z
@@software = true
@@software_reason = "native mkxp-z raw_data backend unavailable: #{e.class}: #{e.message}"
puts "[KHAS] software fallback enabled: #{@@software_reason}"
else
raise
end
end
def self.software?
@@software
end
def self.native_bitmap_mode?
@@native_bitmap_mode && !@@software
end
def self.native_smoke_test
return true unless native_bitmap_mode?
begin
h = @@createBuffer.call(1, 1)
if h.nil? || h <= 0
@@software = true
@@software_reason = "native mkxp-z raw_data backend self-test failed (kglCreateBuffer returned #{h.inspect})"
return false
end
@@destroyBuffer.call(h)
true
rescue Exception => e
@@software = true
@@software_reason = "native mkxp-z raw_data backend self-test failed: #{e.class}: #{e.message}"
false
end
end
def self.run
if @@software
puts "[KHAS] software backend active#{@@software_reason ? ' (' + @@software_reason + ')' : ''}"
elsif native_bitmap_mode?
KGL.load
if native_smoke_test
puts "Khas Graphics Library #{KGL.version} (mkxp-z raw_data native backend)"
else
puts "[KHAS] software backend active (#{@@software_reason})"
end
else
KGL.load
puts "Khas Graphics Library #{KGL.version}"
end
end
def self.compressRGBA(color)
r = color.red.to_i
g = color.green.to_i
b = color.blue.to_i
a = color.alpha.to_i
r | (g << 8) | (b << 16) | (a << 24)
end
def self.compressBGRA(color)
r = color.red.to_i
g = color.green.to_i
b = color.blue.to_i
a = color.alpha.to_i
b | (g << 8) | (r << 16) | (a << 24)
end
def self.version
@@version.call().to_f / 100
end
def self.load
@@load.call()
end
def self.bitmap_key(bitmap)
bitmap.__id__
end
def self.allocate_buffer(bitmap)
key = bitmap_key(bitmap)
handle = @@native_bitmap_handles[key]
if handle && @@native[key] && @@native[key][0] == bitmap.width && @@native[key][1] == bitmap.height
return handle
end
release_bitmap(bitmap)
handle = @@createBuffer.call(bitmap.width, bitmap.height)
raise "KGL native buffer alloc failed for #{bitmap.width}x#{bitmap.height}" if handle.nil? || handle <= 0
@@native_bitmap_handles[key] = handle
@@native[key] = [bitmap.width, bitmap.height]
@@native_dirty[key] = true
handle
end
def self.ensure_buffer(bitmap)
return nil if bitmap.nil?
allocate_buffer(bitmap) unless @@native_bitmap_handles[bitmap_key(bitmap)]
key = bitmap_key(bitmap)
if !@@native[key] || @@native[key][0] != bitmap.width || @@native[key][1] != bitmap.height
allocate_buffer(bitmap)
end
if @@native_dirty[key]
data = bitmap.raw_data
@@uploadBuffer.call(@@native_bitmap_handles[key], data, data.bytesize)
@@native_dirty[key] = false
end
@@native_bitmap_handles[key]
end
def self.mark_native_dirty(bitmap)
return unless bitmap && native_bitmap_mode?
@@native_dirty[bitmap_key(bitmap)] = true if @@native_bitmap_handles[bitmap_key(bitmap)]
end
def self.release_bitmap(bitmap)
return unless bitmap && native_bitmap_mode?
key = bitmap_key(bitmap)
handle = @@native_bitmap_handles.delete(key)
@@destroyBuffer.call(handle) if handle && handle > 0
@@native.delete(key)
@@native_dirty.delete(key)
@@native_tmp.delete(key)
@@framebuffer = nil if @@framebuffer.equal?(bitmap)
@@shadowbuffer = nil if @@shadowbuffer.equal?(bitmap)
end
def self.normalize_rect(rect, max_w, max_h)
return nil if rect.nil?
x, y, w, h = rect
x = x.to_i
y = y.to_i
w = w.to_i
h = h.to_i
return nil if w <= 0 || h <= 0
x2 = x + w
y2 = y + h
x = 0 if x < 0
y = 0 if y < 0
x2 = max_w if x2 > max_w
y2 = max_h if y2 > max_h
w = x2 - x
h = y2 - y
return nil if w <= 0 || h <= 0
[x, y, w, h]
end
def self.commit(bitmap, rect = nil)
return unless bitmap && native_bitmap_mode?
key = bitmap_key(bitmap)
handle = @@native_bitmap_handles[key]
return unless handle && handle > 0
bytes = bitmap.width * bitmap.height * 4
data = @@native_tmp[key]
full_download = false
if data.nil? || data.bytesize != bytes
data = "\0" * bytes
@@native_tmp[key] = data
full_download = true
end
rect = normalize_rect(rect, bitmap.width, bitmap.height) unless rect.nil?
if !full_download && rect && @@downloadBufferRect
x, y, w, h = rect
@@downloadBufferRect.call(handle, data, bytes, x, y, w, h)
else
@@downloadBuffer.call(handle, data, bytes)
end
bitmap.raw_data = data
@@native_dirty[key] = false
end
def self.commit_if_bound(bitmap)
commit(bitmap) if native_bitmap_mode?
end
def self.bindFramebuffer(bitmap)
if @@software
@@framebuffer = bitmap
elsif native_bitmap_mode?
@@framebuffer = bitmap
@@bindFramebufferBuffer.call(ensure_buffer(bitmap))
else
@@bindFramebuffer.call(bitmap.__id__)
end
end
def self.bindShadowbuffer(bitmap)
if @@software
@@shadowbuffer = bitmap
elsif native_bitmap_mode?
@@shadowbuffer = bitmap
@@bindShadowbufferBuffer.call(ensure_buffer(bitmap))
else
@@bindShadowbuffer.call(bitmap.__id__)
end
end
def self.unbindFramebuffer()
if @@software
@@framebuffer = nil
else
@@unbindFramebuffer.call()
end
end
def self.unbindShadowbuffer()
if @@software
@@shadowbuffer = nil
else
@@unbindShadowbuffer.call()
end
end
def self.clearFramebuffer()
if @@software
blank(@@framebuffer) if @@framebuffer
else
@@clearFramebuffer.call()
end
end
def self.loadFramebuffer(bitmap, x, y)
# not used by this project
end
def self.blank(bitmap)
return unless bitmap
if @@software
bitmap.clear
elsif native_bitmap_mode?
@@blankBuffer.call(ensure_buffer(bitmap))
else
@@blank.call(bitmap.__id__)
end
end
def self.clear(bitmap, color)
return unless bitmap
if @@software
bitmap.clear
bitmap.fill_rect(0, 0, bitmap.width, bitmap.height, color)
elsif native_bitmap_mode?
@@clearBufferRGBA.call(ensure_buffer(bitmap), KGL.compressRGBA(color))
else
@@clear.call(bitmap.__id__, KGL.compressBGRA(color))
end
end
def self.clear_rect(bitmap, color, rect)
return clear(bitmap, color) if rect.nil?
if @@software || !native_bitmap_mode? || @@clearBufferRectRGBA.nil?
clear(bitmap, color)
else
rect = normalize_rect(rect, bitmap.width, bitmap.height)
return if rect.nil?
x, y, w, h = rect
@@clearBufferRectRGBA.call(ensure_buffer(bitmap), KGL.compressRGBA(color), x, y, w, h)
end
end
def self.invert(bitmap)
return unless bitmap
if @@software
# unused in this project
elsif native_bitmap_mode?
commit(bitmap)
bitmap.invert
mark_native_dirty(bitmap)
ensure_buffer(bitmap)
else
@@invert.call(bitmap.__id__)
end
end
def self.clone(target, source)
return unless target && source
if @@software
target.clear
target.blt(0, 0, source, source.rect, 255)
elsif native_bitmap_mode?
@@cloneBuffer.call(ensure_buffer(target), ensure_buffer(source))
else
@@clone.call(target.__id__, source.__id__)
end
end
def self.compressAlpha(bitmap)
return if bitmap.nil?
if @@software
y = 0
while y < bitmap.height
x = 0
while x < bitmap.width
c = bitmap.get_pixel(x, y)
a = c.alpha.to_i
if a <= 0
bitmap.set_pixel(x, y, Color.new(0, 0, 0, 255))
elsif a < 255
r = (c.red.to_i * a) >> 8
g = (c.green.to_i * a) >> 8
b = (c.blue.to_i * a) >> 8
bitmap.set_pixel(x, y, Color.new(r, g, b, 255))
else
bitmap.set_pixel(x, y, Color.new(c.red.to_i, c.green.to_i, c.blue.to_i, 255))
end
x += 1
end
y += 1
end
elsif native_bitmap_mode?
@@compressAlphaBuffer.call(ensure_buffer(bitmap))
else
@@compressAlpha.call(bitmap.__id__)
end
end
def self.lightBlending(b)
if @@software
@@light_blending = b
else
@@lightBlending.call(b ? 1 : 0)
end
end
def self.lightShader(light, tx, ty, opacity)
return if opacity <= 0 || light.nil?
if @@software
return unless @@framebuffer
amount = opacity.to_i
amount = 0 if amount < 0
amount = 255 if amount > 255
ox = tx.to_i
oy = ty.to_i
sx0 = ox < 0 ? -ox : 0
sy0 = oy < 0 ? -oy : 0
sx1 = light.width
sy1 = light.height
max_sx1 = @@framebuffer.width - ox
max_sy1 = @@framebuffer.height - oy
sx1 = max_sx1 if sx1 > max_sx1
sy1 = max_sy1 if sy1 > max_sy1
return if sx1 <= sx0 || sy1 <= sy0
y = sy0
while y < sy1
dy = oy + y
x = sx0
while x < sx1
dx = ox + x
sp = light.get_pixel(x, y)
sr = sp.red.to_i
sg = sp.green.to_i
sb = sp.blue.to_i
if sr != 0 || sg != 0 || sb != 0
if amount != 255
sr = (sr * amount) >> 8
sg = (sg * amount) >> 8
sb = (sb * amount) >> 8
end
dp = @@framebuffer.get_pixel(dx, dy)
dr = dp.red.to_i - sr
dg = dp.green.to_i - sg
db = dp.blue.to_i - sb
dr = 0 if dr < 0
dg = 0 if dg < 0
db = 0 if db < 0
@@framebuffer.set_pixel(dx, dy, Color.new(dr, dg, db, 255))
end
x += 1
end
y += 1
end
elsif native_bitmap_mode?
@@lightShaderBuffer.call(ensure_buffer(light), tx.to_i, ty.to_i, opacity.to_i)
else
@@lightShader.call(light.__id__, tx, ty, opacity)
end
end
def self.lightShaderClipped(light, tx, ty, opacity, rect)
return if opacity <= 0 || light.nil?
if native_bitmap_mode? && @@lightShaderBufferClip && rect
rect = normalize_rect(rect, @@framebuffer.width, @@framebuffer.height) if @@framebuffer
return if rect.nil?
x, y, w, h = rect
@@lightShaderBufferClip.call(ensure_buffer(light), tx.to_i, ty.to_i, opacity.to_i, x, y, w, h)
else
lightShader(light, tx, ty, opacity)
end
end
def self.softShadows(s)
if @@software
@@soft_shadows = s
else
@@softShadows.call(s ? 1 : 0)
end
end
def self.shadowShaderH(x1, x2, y)
@@shadowShaderH.call(x1, x2, y) unless @@software
end
def self.shadowShaderV(y1, y2, x)
@@shadowShaderV.call(y1, y2, x) unless @@software
end
def self.shadowShaderW(y1, y2, x)
@@shadowShaderW.call(y1, y2, x) unless @@software
end
end
class Bitmap
alias khas_kgl_native_dispose dispose
def dispose
KGL.release_bitmap(self) if defined?(KGL)
khas_kgl_native_dispose
end
end
KGL.run
#-------------------------------------------------------------------------------
# * Version
#-------------------------------------------------------------------------------
$khas_graphics[:core] = 2.0
$khas_graphics[:kgl] = KGL.version
#-------------------------------------------------------------------------------
# * Framebuffer
#-------------------------------------------------------------------------------
class Framebuffer < Sprite
include Graphics_Core
def initialize(viewport = nil, width = Screen_Width, height = Screen_Height)
super(viewport)
self.bitmap = Bitmap.new(width, height)
end
def bind
KGL.bindFramebuffer(self.bitmap)
end
def unbind
KGL.unbindFramebuffer()
end
def clear
KGL.clearFramebuffer()
end
def dispose
self.bitmap.dispose
super
end
end
#-------------------------------------------------------------------------------
# * End
#-------------------------------------------------------------------------------