Initial commit

Data/Scripts/008_Objects and windows/002_BitmapCache.rb

@@ -0,0 +1,497 @@
+class Hangup < Exception; end
+
+
+
+def strsplit(str,re)
+  ret=[]
+  tstr=str
+  while re=~tstr
+    ret[ret.length]=$~.pre_match
+    tstr=$~.post_match
+  end
+  ret[ret.length]=tstr if ret.length
+  return ret
+end
+
+def canonicalize(c)
+  csplit = strsplit(c,/[\/\\]/)
+  pos = -1
+  ret = []
+  retstr = ""
+  for x in csplit
+    if x=="."
+    elsif x==".."
+      if pos>=0
+        ret.delete_at(pos) 
+        pos -= 1
+      end
+    else
+      ret.push(x)
+      pos += 1
+    end
+  end
+  for i in 0...ret.length
+    retstr += "/" if i>0
+    retstr += ret[i]
+  end
+  return retstr
+end
+
+
+
+#####################################################################
+class WeakRef
+  @@id_map =  {}
+  @@id_rev_map =  {}
+  @@final = lambda { |id|
+    __old_status = Thread.critical
+    Thread.critical = true
+    begin
+      rids = @@id_map[id]
+      if rids
+	      for rid in rids
+	        @@id_rev_map.delete(rid)
+        end
+        @@id_map.delete(id)
+      end
+      rid = @@id_rev_map[id]
+      if rid
+	      @@id_rev_map.delete(id)
+	      @@id_map[rid].delete(id)
+	      @@id_map.delete(rid) if @@id_map[rid].empty?
+      end
+    ensure
+      Thread.critical = __old_status
+    end
+  }
+
+  # Create a new WeakRef from +orig+.
+  def initialize(orig)
+    __setobj__(orig)
+  end
+
+  def __getobj__
+    unless @@id_rev_map[self.__id__] == @__id
+      return nil
+    end
+    begin
+      ObjectSpace._id2ref(@__id)
+    rescue RangeError
+      return nil
+    end
+  end
+
+  def __setobj__(obj)
+    @__id = obj.__id__
+    __old_status = Thread.critical
+    begin
+      Thread.critical = true
+      unless @@id_rev_map.key?(self)
+        ObjectSpace.define_finalizer obj, @@final
+        ObjectSpace.define_finalizer self, @@final
+      end
+      @@id_map[@__id] = [] unless @@id_map[@__id]
+    ensure
+      Thread.critical = __old_status
+    end
+    @@id_map[@__id].push self.__id__
+    @@id_rev_map[self.__id__] = @__id
+  end
+
+  # Returns true if the referenced object still exists, and false if it has
+  # been garbage collected.
+  def weakref_alive?
+    @@id_rev_map[self.__id__] == @__id
+  end
+end
+
+
+
+class WeakHashtable
+  include Enumerable
+
+  def initialize
+    @hash={}
+  end
+
+  def clear
+    @hash.clear
+  end
+
+  def delete(value)
+    @hash.delete(value)
+  end
+
+  def include?(value)
+    @hash.include?(value)
+  end
+
+  def each
+    @hash.each { |i| yield i }
+  end
+
+  def keys
+    @hash.keys
+  end
+
+  def values
+    @hash.values
+  end
+
+  def [](key)
+    o=@hash[key]
+    return o if !o
+    if o.weakref_alive? 
+      o=o.__getobj__
+    else
+      @hash.delete(key)
+      o=nil
+    end
+    return o
+  end
+
+  def []=(key,o)
+    if o!=nil
+      o=WeakRef.new(o)
+    end
+    @hash[key]=o
+  end
+end
+
+
+
+# Cache from RPG Maker VX library
+module Cache
+  def self.system(x,hue=0)
+    BitmapCache.load_bitmap("Graphics/System/"+x,hue, true)
+  end
+
+  def self.character(x,hue=0)
+    BitmapCache.load_bitmap("Graphics/Characters/"+x,hue, true)
+  end
+
+  def self.picture(x,hue=0)
+    BitmapCache.load_bitmap("Graphics/Pictures/"+x,hue, true)
+  end
+
+  def self.animation(x,hue=0)
+    BitmapCache.load_bitmap("Graphics/Animations/"+x,hue, true)
+  end
+
+  def self.battler(x,hue=0)
+    BitmapCache.load_bitmap("Graphics/Battlers/"+x,hue, true)
+  end
+
+  def self.face(x,hue=0)
+    BitmapCache.load_bitmap("Graphics/Faces/"+x,hue, true)
+  end
+
+  def self.parallax(x,hue=0)
+    BitmapCache.load_bitmap("Graphics/Parallaxes/"+x,hue, true)
+  end
+
+  def self.clear
+    BitmapCache.clear()
+  end
+
+  def self.load_bitmap(dir,name,hue=0)
+    BitmapCache.load_bitmap(dir+name,hue, true)
+  end
+end
+
+
+
+# RPG::Cache from RPG Maker XP library
+module RPG
+  module Cache
+    def self.load_bitmap(folder_name, filename, hue = 0)
+	    BitmapCache.load_bitmap(folder_name+filename.to_s,hue, true)
+    end
+
+    def self.animation(filename, hue)
+      self.load_bitmap("Graphics/Animations/", filename, hue)
+    end
+
+    def self.autotile(filename)
+      self.load_bitmap("Graphics/Autotiles/", filename)
+    end
+
+    def self.battleback(filename)
+      self.load_bitmap("Graphics/Battlebacks/", filename)
+    end
+
+    def self.battler(filename, hue)
+      self.load_bitmap("Graphics/Battlers/", filename, hue)
+    end
+
+    def self.character(filename, hue)
+      self.load_bitmap("Graphics/Characters/", filename, hue)
+    end
+
+    def self.fog(filename, hue)
+      self.load_bitmap("Graphics/Fogs/", filename, hue)
+    end
+
+    def self.gameover(filename)
+      self.load_bitmap("Graphics/Gameovers/", filename)
+    end
+
+    def self.icon(filename)
+      self.load_bitmap("Graphics/Icons/", filename)
+    end
+
+    def self.panorama(filename, hue)
+      self.load_bitmap("Graphics/Panoramas/", filename, hue)
+    end
+
+    def self.picture(filename)
+      self.load_bitmap("Graphics/Pictures/", filename)
+    end
+
+    def self.tileset(filename)
+      self.load_bitmap("Graphics/Tilesets/", filename)
+    end
+
+    def self.title(filename)
+      self.load_bitmap("Graphics/Titles/", filename)
+    end
+
+    def self.windowskin(filename)
+      self.load_bitmap("Graphics/Windowskins/", filename)
+    end
+
+    def self.tile(filename, tile_id, hue)
+      BitmapCache.tile(filename,tile_id,hue)
+    end
+
+    def self.clear
+      BitmapCache.clear()
+    end
+  end
+end
+
+
+
+# A safer version of RPG::Cache, this module loads bitmaps that keep an internal
+# reference count.  Each call to dispose decrements the reference count and the
+# bitmap is freed when the reference count reaches 0.
+class Thread
+  def Thread.exclusive
+    _old = Thread.critical
+    begin
+      Thread.critical = true
+      return yield
+    ensure
+      Thread.critical = _old
+    end
+  end
+end
+
+
+
+class BitmapWrapper < Bitmap
+  @@disposedBitmaps={}
+  @@keys={}
+=begin
+  @@final = lambda { |id|
+    Thread.exclusive {
+      if @@disposedBitmaps[id]!=true
+        File.open("debug.txt","ab") { |f|
+          f.write("Bitmap finalized without being disposed: #{@@keys[id]}\r\n")
+        }
+      end
+      @@disposedBitmaps[id]=nil
+    }
+  }
+=end
+  attr_reader :refcount
+
+  def dispose
+    return if self.disposed?
+    @refcount-=1
+    if @refcount==0
+      super
+      #Thread.exclusive { @@disposedBitmaps[__id__]=true }
+    end
+  end
+
+  def initialize(*arg)
+    super
+    @refcount=1
+    #Thread.exclusive { @@keys[__id__]=arg.inspect+caller(1).inspect }
+    #ObjectSpace.define_finalizer(self,@@final)
+  end
+
+  def resetRef # internal
+    @refcount=1
+  end
+
+  def copy
+    bm=self.clone
+    bm.resetRef
+    return bm
+  end
+
+  def addRef
+    @refcount+=1
+  end
+end
+
+
+
+module BitmapCache
+  @cache = WeakHashtable.new
+
+  def self.fromCache(i)
+    return nil if !@cache.include?(i)
+    obj=@cache[i]
+    return nil if obj && obj.disposed?
+    return obj
+  end
+
+  def self.setKey(key,obj)
+    @cache[key]=obj
+  end
+
+  def self.debug
+    File.open("bitmapcache2.txt","wb") { |f|
+      for i in @cache.keys
+        k = fromCache(i)
+        if !k
+          f.write("#{i} (nil)\r\n")
+        elsif k.disposed?
+          f.write("#{i} (disposed)\r\n")
+        else
+          f.write("#{i} (#{k.refcount}, #{k.width}x#{k.height})\r\n")
+        end
+      end
+    }
+  end
+
+  def self.load_bitmap(path, hue = 0, failsafe = false)
+    cached = true
+    path = canonicalize(path)
+    objPath = fromCache(path)
+    if !objPath
+      @cleancounter = ((@cleancounter || 0) + 1)%10
+      if @cleancounter == 0
+        for i in @cache.keys
+          @cache.delete(i) if !fromCache(i)
+        end
+      end
+      begin
+        bm = BitmapWrapper.new(path)
+      rescue Hangup
+        begin
+          bm = BitmapWrapper.new(path)
+        rescue
+          raise _INTL("Failed to load the bitmap located at: {1}",path) if !failsafe
+          bm = BitmapWrapper.new(32,32)
+        end
+      rescue
+        raise _INTL("Failed to load the bitmap located at: {1}",path) if !failsafe
+        bm = BitmapWrapper.new(32,32)
+      end
+      objPath = bm
+      @cache[path] = objPath
+      cached=false
+    end
+    if hue == 0
+      objPath.addRef if cached
+      return objPath
+    else
+      key = [path, hue]
+      objKey = fromCache(key)
+      if !objKey
+        bitmap = objPath.copy
+        bitmap.hue_change(hue) if hue!=0
+        objKey = bitmap
+        @cache[key] = objKey
+      else
+        objKey.addRef
+      end
+      return objKey
+    end
+  end
+
+  def self.animation(filename, hue)
+    self.load_bitmap("Graphics/Animations/"+filename, hue)
+  end
+
+  def self.autotile(filename)
+    self.load_bitmap("Graphics/Autotiles/"+ filename)
+  end
+
+  def self.battleback(filename)
+    self.load_bitmap("Graphics/Battlebacks/"+ filename)
+  end
+
+  def self.battler(filename, hue)
+    self.load_bitmap("Graphics/Battlers/"+ filename, hue)
+  end
+
+  def self.character(filename, hue)
+    self.load_bitmap("Graphics/Characters/"+ filename, hue)
+  end
+
+  def self.fog(filename, hue)
+    self.load_bitmap("Graphics/Fogs/"+ filename, hue)
+  end
+
+  def self.gameover(filename)
+    self.load_bitmap("Graphics/Gameovers/"+ filename)
+  end
+
+  def self.icon(filename)
+    self.load_bitmap("Graphics/Icons/"+ filename)
+  end
+
+  def self.panorama(filename, hue)
+    self.load_bitmap("Graphics/Panoramas/"+ filename, hue)
+  end
+
+  def self.picture(filename)
+    self.load_bitmap("Graphics/Pictures/"+ filename)
+  end
+
+  def self.tileset(filename)
+    self.load_bitmap("Graphics/Tilesets/"+ filename)
+  end
+
+  def self.title(filename)
+    self.load_bitmap("Graphics/Titles/"+ filename)
+  end
+
+  def self.windowskin(filename)
+    self.load_bitmap("Graphics/Windowskins/"+ filename)
+  end
+
+  def self.tileEx(filename, tile_id, hue)
+    key = [filename, tile_id, hue]
+    objKey=fromCache(key)
+    if !objKey
+      bitmap=BitmapWrapper.new(32, 32)
+      x = (tile_id - 384) % 8 * 32
+      y = (tile_id - 384) / 8 * 32
+      rect = Rect.new(x, y, 32, 32)
+      tileset = yield(filename)
+      bitmap.blt(0, 0, tileset, rect)
+      tileset.dispose
+      bitmap.hue_change(hue) if hue!=0
+      objKey=bitmap
+      @cache[key]=objKey
+    else
+      objKey.addRef
+    end
+    objKey
+  end
+
+  def self.tile(filename, tile_id, hue)
+    return self.tileEx(filename, tile_id,hue) { |f| self.tileset(f) }
+  end
+
+  def self.clear
+    @cache = {}
+    GC.start
+  end
+end