664 lines
19 KiB
Ruby
664 lines
19 KiB
Ruby
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
|
||
#-------------------------------------------------------------------------------
|