GIF Player

GIF Sprite [ Selecionar ] [ - ]
=begin

  &#33050;&#26412;&#65306;&#12304;&#24616;&#24565;&#20135;&#29289; - GIF&#22270;&#29255;&#25773;&#25918;&#12305;
  
  &#21151;&#33021;&#65306;&#22312;&#28216;&#25103;&#20013;&#25773;&#25918;GIF&#22270;&#29255; &#8251; &#34920;&#24773;&#20248;&#20808;&#12290;
  
  &#35828;&#26126;: &#20351;&#29992;&#27493;&#39588;&#65306;
  
        1&#12289;&#20351;&#29992; @gs = GIFSprite.new([viewport,[x,[,y,[loop_counts]]]])
           &#21019;&#24314;GIF&#22270;&#29255;&#23545;&#35937;&#65307;
           
        2&#12289;&#28982;&#21518;&#20351;&#29992; @gs.bitmap = "gif_filename" &#8251; &#21253;&#21547;&#25991;&#20214;&#22841;&#36335;&#24452;&#65307;
        
        3&#12289;&#21487;&#20197; @gs.loop_counts = n   
           
           &#35774;&#32622;&#24490;&#29615;&#27425;&#25968;&#65292;-1&#34920;&#31034;&#26080;&#38480;&#24490;&#29615;(&#40664;&#35748;&#30340;)&#65292;0&#23601;&#37322;&#25918;&#22270;&#29255;&#12290;
           
        4&#12289;@gs.x = x,@gs.y = y,@gs.z = z &#31561;&#35774;&#32622;&#21508;&#31181;&#22352;&#26631;&#20540;&#12290;
  
  &#34917;&#20805;&#65306;1&#12289;&#30001;&#20110;&#32771;&#34385;&#30340;&#25928;&#29575;&#38382;&#39064;&#65292;&#25552;&#20379;&#20102;&#29983;&#25104;&#20020;&#26102;&#25991;&#20214;&#25216;&#26415;&#65292;&#21363;&#31532;&#19968;&#36816;&#34892;&#20043;&#21518;&#20197;&#21518;&#27599;&#27425;&#36816;
  
        &#34892;&#20250;&#30452;&#25509;&#35835;&#21462;&#20020;&#26102;&#25991;&#20214;&#29983;&#25104;&#23545;&#35937;&#65292;&#21487;&#20197;&#20351;&#29992; GIFSprite.TmpFileclear &#28165;&#31354;&#20020;&#26102;
        
        &#25991;&#20214;&#12290;
        
        2&#12289;&#21487;&#20197;&#20351;&#29992; GIFSprite.pre_load(filename_arr) &#25968;&#32452;&#39044;&#21152;&#36733;&#19968;&#32452;&#22270;&#29255;&#12290;        
        
  &#29256;&#26412;&#65306;v1.0
        
  &#20316;&#32773;&#65306;&#28796;&#30524;&#30340;&#22799;&#23068;
  
=end


#==============================================================================
# &#9632; System
#------------------------------------------------------------------------------
# &#12288;&#22788;&#29702;&#31995;&#32479;&#30456;&#20851;&#30340;&#27169;&#22359; &#12290;
#==============================================================================
module System
  
  #--------------------------------------------------------------------------
  # &#9679; &#27169;&#22359;&#20989;&#25968;
  #--------------------------------------------------------------------------
  module_function
  
  #--------------------------------------------------------------------------
  # &#9679; API&#20989;&#25968;&#22768;&#26126;
  #--------------------------------------------------------------------------
  WinExec = Win32API.new("kernel32","WinExec",'pi','i')

  #--------------------------------------------------------------------------
  # &#9679; &#26597;&#30475;&#25110;&#20462;&#25913;&#25991;&#20214;&#21450;&#25991;&#20214;&#22841;&#23646;&#24615;
  #  filename &#65306;&#25991;&#20214;&#25110;&#25991;&#20214;&#22841;&#21517;&#23383;
  #
  #  +a -a    &#65306;&#28155;&#21152;&#12289;&#21024;&#38500; &#23384;&#26723; &#23646;&#24615;
  #  +r -r    &#65306;&#28155;&#21152;&#12289;&#21024;&#38500; &#21482;&#35835; &#23646;&#24615;
  #  +s -s    &#65306;&#28155;&#21152;&#12289;&#21024;&#38500; &#31995;&#32479; &#23646;&#24615;
  #  +h -h    &#65306;&#28155;&#21152;&#12289;&#21024;&#38500; &#38544;&#34255; &#23646;&#24615;
  #--------------------------------------------------------------------------
  def attrib(filename,*args)
    if args.empty?
      astr = `attrib #{filename}`
      attri_arr = Array.new
      astr = astr.split(/:/)[0]
      astr = astr[0,astr.size - 1]
      astr.gsub!(/ /,"")
      return astr.split(//)
    else
      cmdline = ""
      for cmdchar in args
        cmdchar.downcase!
        next if cmdline.include? cmdchar
        if ["+a","-a","+r","-r","+s","-s","+h","-h"].include? cmdchar
          cmdline += " " + cmdchar
        end
      end
      cmdline += " "
      result = WinExec.call("attrib #{cmdline}#{filename}",0)
      if result < 31
        return
      end
    end
  end
  
end

#==============================================================================
# &#9632; GIF
#------------------------------------------------------------------------------
# &#12288;&#20998;&#26512;&#22788;&#29702;GIF&#22270;&#29255;&#30340;&#26680;&#24515;&#27169;&#22359; &#12290;
#==============================================================================
module GIF
  
  # &#23450;&#20041;&#24120;&#37327;
  SIZE_GIFH = 6
  
  SIZE_GIFS = 7
  
  SIZE_GIFI = 9
  
  SIZE_GIFC = 6
  
  SIZE_GIFP = 13
  
  SIZE_GIFA = 12
  
  CODE_MASK = [0x0000,
               0x0001,0x0003,0x0007,0x000f,
               0x001f,0x003f,0x007f,0x00ff,
               0x01ff,0x03ff,0x07ff,0x0fff]
  
  INC_TABLE = [8,8,4,2,0]
  
  BGN_TABLE = [0,4,2,1,0]
  
  # &#24314;&#31435;&#25991;&#20214;&#22841;
  Dir.mkdir("GIF") unless Dir["*"].include?("GIF")
  
  # &#20989;&#25968;&#23450;&#20041;
  module_function
  
  #--------------------------------------------------------------------------
  # &#9679; &#20998;&#35299;gif&#22270;&#29255;
  #--------------------------------------------------------------------------
  def analyze_gif
    @old_dir = Dir.pwd
    Dir.chdir("GIF")
    @total_gif = []
    for g in Dir["*"]
      suf = g.split(/\\./)
      if suf[1].is_a?(String) and suf[1].downcase == "gif"
        @total_gif.push(g)
        Dir.mkdir(suf[0]) unless Dir["*"].include? suf[0]
      end
    end
    @total_gif.each{|file| self.readdata(file)}
    Dir.chdir(@old_dir)
    p '&#20840;&#37096;&#20998;&#35299;&#23436;&#27605;&#65292;&#28857;&#20987;&#30830;&#23450;&#36864;&#20986;'
    exit
  end
  
  #--------------------------------------------------------------------------
  # &#9679; &#35835;&#21462;&#25991;&#20214;&#25968;&#25454;&#65306;&#25104;&#21151;&#36820;&#22238;@gif_infos&#65292;&#22833;&#36133;&#36820;&#22238;nil
  #--------------------------------------------------------------------------
  def readdata(filename)
    # &#26816;&#26597;&#26159;&#21542;&#26377;&#20020;&#26102;&#35760;&#24518;&#25991;&#20214;
    tmp_filename = File.basename(filename,".*")
    unless Dir["~TEMP/#{tmp_filename}_infos.fmd"].empty?
      begin
        giffr = open("~TEMP/#{tmp_filename}_infos.fmd","rb")
        tmp_infos = Marshal.load(giffr)
        giffr.close
        if Dir["~TEMP/#{tmp_filename}_*.png"].size == tmp_infos.total_frames
          return tmp_infos
        end
      rescue
      end
    end
    # &#21021;&#22987;&#21270;&#25968;&#25454;
    self.initial_var(filename)
    # &#25171;&#24320;&#25991;&#20214;
    begin
      @f = open(filename,"rb")
      # &#35835;&#21462;&#25991;&#20214;&#22836;
      self.read_gifh
      # &#35835;&#21462;&#36923;&#36753;&#23631;&#24149;&#25551;&#36848;&#22359;
      self.read_gifs
      # &#35835;&#21462;&#19979;&#19968;&#20010;&#23383;&#33410;
      @temp = @f.read(1)[0]
      # &#24490;&#29615;&#35835;&#21462;&#27599;&#20010;&#22270;&#35937;&#25551;&#36848;&#22359;
      while true
        if @temp == 0x2c
          # &#35835;&#21462;&#22270;&#35937;&#25551;&#36848;&#22359;
          self.read_gifi
        end
        if @temp == 0x21
          # &#35835;&#21462;&#22270;&#35937;&#25193;&#23637;&#22359;
          self.read_gife
        end
        if @temp == 0x3b
          break
        end
        # &#35835;&#21462;&#19979;&#19968;&#20010;&#23383;&#33410;
        @temp = @f.read(1)[0]
      end
      # &#8251; &#35774;&#32622;&#22270;&#35937;&#24103;&#25968;
      @gif_infos.total_frames = @frame_count
      # &#8251; &#20889;&#20837;&#22270;&#35937;&#20998;&#35299;&#25968;&#25454;
      giffw = open("~TEMP/#{@filename}_infos.fmd","wb")
      Marshal.dump(@gif_infos,giffw)
      giffw.close
    rescue
      return nil
    ensure
      @f.close
    end
    return @gif_infos
  end
  
  #--------------------------------------------------------------------------
  # &#9679; &#21021;&#22987;&#21270;&#21464;&#37327;
  #--------------------------------------------------------------------------
  def initial_var(filename)
    # &#8251; &#29983;&#25104;&#22270;&#35937;&#25968;&#25454;&#23545;&#35937;
    @gif_infos = GIFSprite::Infos.new
    # &#24103;&#25968;&#35745;&#25968;
    @frame_count = 0
    @f = nil
    @temp = nil
    # &#33719;&#21462;&#25991;&#20214;&#21517;
    @filename = File.basename(filename,".*")
  end
  
  #--------------------------------------------------------------------------
  # &#9679; &#35835;&#21462;&#25991;&#20214;&#22836;
  #--------------------------------------------------------------------------
  def read_gifh
    @gifh = @f.read(SIZE_GIFH)
    if @gifh[0,3] != "GIF"
      raise "&#19981;&#26159;GIF&#25991;&#20214;!"
    end
    if @gifh[3,3] != "87a" and @gifh[3,3] != "89a"
      raise "&#19981;&#25903;&#25345;&#30340;&#29256;&#26412;!"
    end
  end
  
  #--------------------------------------------------------------------------
  # &#9679; &#35835;&#21462;&#36923;&#36753;&#23631;&#24149;&#25551;&#36848;&#22359;
  #--------------------------------------------------------------------------
  def read_gifs
    @gifs = @f.read(SIZE_GIFS).unpack("S2C3")
    # &#33719;&#21462;&#35843;&#33394;&#26495;&#20301;&#25968;
    @_pal_bits = (@gifs[2] & 7) + 1
    # &#8251; &#33719;&#21462;&#22270;&#35937;&#23485;&#24230;
    @gif_infos.width = @gifs[0]
    # &#8251; &#33719;&#21462;&#22270;&#35937;&#39640;&#24230;
    @gif_infos.height = @gifs[1]
    # &#26159;&#21542;&#26377;&#20840;&#23616;&#35843;&#33394;&#26495;
    if @gifs[2] >> 7 == 1
      # &#20840;&#23616;&#35843;&#33394;&#26495;&#22823;&#23567;
      @g_pal_size = 3 * (1 << @_pal_bits)
      # &#35835;&#21462;&#20840;&#23616;&#35843;&#33394;&#26495;&#25968;&#25454;
      @g_pal = @f.read(@g_pal_size).unpack("C*")
    end
  end
  
  #--------------------------------------------------------------------------
  # &#9679; &#35835;&#21462;&#22270;&#35937;&#25551;&#36848;&#22359;
  #--------------------------------------------------------------------------
  def read_gifi
    # &#35835;&#21462;&#22270;&#35937;&#25551;&#36848;&#22359;
    @gifi = @f.read(SIZE_GIFI).unpack("S4C")
    # &#8251; &#29983;&#25104;&#20020;&#26102;&#24103;&#25968;&#25454;&#23545;&#35937;
    @gif_fd = GIFSprite::Infos::FrameData.new if @gif_fd.nil?
    # &#8251; &#33719;&#21462;&#24103;&#20559;&#31227;
    @gif_fd.offset_x = @gifi[0]
    @gif_fd.offset_y = @gifi[1]
    # &#33719;&#21462;&#23485;&#24230;&#21644;&#39640;&#24230;
    @_width = @gifi[2]
    @_height = @gifi[3]
    # &#28165;&#31354;&#23616;&#37096;&#35843;&#33394;&#26495;
    @l_pal = nil
    # &#26159;&#21542;&#26377;&#23616;&#37096;&#35843;&#33394;&#26495;
    if @gifi[4] >> 7 == 1
      # &#33719;&#21462;&#35843;&#33394;&#26495;&#20301;&#25968;
      @_pal_bits = (@gifi[4] & 7) + 1
      # &#23616;&#37096;&#35843;&#33394;&#26495;&#22823;&#23567;
      @l_pal_size = 3 * (1 << @_pal_bits)
      # &#35835;&#21462;&#23616;&#37096;&#35843;&#33394;&#26495;&#25968;&#25454;
      @l_pal = @f.read(@l_pal_size).unpack("C*")
    end
    # &#33719;&#21462;&#20132;&#38169;&#26631;&#35760;
    @_lace = (@gifi[4] >> 6) & 1
    # &#20462;&#27491;&#35843;&#33394;&#26495;&#20301;&#25968;
    @_pal_bits = @_pal_bits == 1 ? 1 : (@_pal_bits <= 4 ? 4 : 8)
    # &#33719;&#21462;&#34892;&#23383;&#33410;&#25968;
    @_width_bytes = (((@_width * @_pal_bits) + 31) >> 5) << 2
    # &#35835;&#21462;&#22270;&#35937;&#21387;&#32553;&#25968;&#25454;
    self.read_lzw_data
    # &#8251; &#35774;&#32622;GIF&#24103;&#25968;&#25454;
    @gif_infos.frame_data[@frame_count - 1] = @gif_fd
    # &#8251; &#28165;&#38500;&#24103;&#25968;&#25454;
    @gif_fd = nil
  end
  
  #--------------------------------------------------------------------------
  # &#9679; &#35835;&#21462;&#22270;&#35937;&#21387;&#32553;&#25968;&#25454;
  #--------------------------------------------------------------------------
  def read_lzw_data
    # &#35299;&#30721;&#29992;
    lzw_mincodelen = @f.read(1)[0]
    # &#24103;&#25968;&#21152; 1
    @frame_count += 1
    # &#22270;&#35937;&#22359;&#25968;&#25454;
    image_data = ""
    # &#22359;&#22823;&#23567;
    blocksize = @f.read(1)[0]
    while blocksize > 0
      image_data += @f.read(blocksize)
      blocksize = @f.read(1)[0]
    end
    # &#23548;&#20986;&#22270;&#35937;
    self.dump_imgs(image_data,lzw_mincodelen)
  end
 
  #--------------------------------------------------------------------------
  # &#9679; &#35835;&#21462;&#25193;&#20805;&#22359;
  #--------------------------------------------------------------------------
  def read_gife
    label = @f.read(1)[0]
    case label
    when 0xf9 # &#22270;&#24418;&#25511;&#21046;&#25193;&#23637;&#22359;
      @gifc = @f.read(SIZE_GIFC).unpack("C2SC2")
      # &#8251; &#29983;&#25104;&#24103;&#25968;&#25454;&#23545;&#35937;
      @gif_fd = GIFSprite::Infos::FrameData.new   
      # &#8251; &#33719;&#21462;&#24103;&#25968;&#25454; &#24310;&#36831;&#26102;&#38388;
      @gif_fd.delay_time = @gifc[2]
      # &#8251; &#33719;&#21462;&#19979;&#19968;&#24103;&#30340;&#22788;&#29702;&#26041;&#27861;
      @gif_fd.disposal_method = (@gifc[1] & 28) >> 2
      # &#33719;&#21462;&#36879;&#26126;&#39068;&#33394;
      @_trans_index = nil
      if @gifc[1] & 1 > 0
        @_trans_index = @gifc[3]
      end
    when 0x01 # &#22270;&#24418;&#35828;&#26126;&#25193;&#23637;&#22359;
      @gifp = @f.read(SIZE_GIFP).unpack("CS4C4")
      blocksize = @f.read(1)[0]
      while blocksize > 0
        @f.read(blocksize)
        blocksize = @f.read(1)[0]
      end 
    when 0xfe # &#27880;&#35299;&#35828;&#26126;&#25193;&#23637;&#22359;
      blocksize = @f.read(1)[0]
      while blocksize > 0
        @f.read(blocksize)
        blocksize = @f.read(1)[0]
      end
    when 0xff # &#24212;&#29992;&#31243;&#24207;&#25193;&#23637;&#22359;
      @gifa = @f.read(SIZE_GIFA).unpack("C*")
      blocksize = @f.read(1)[0]
      while blocksize > 0
        @f.read(blocksize)
        blocksize = @f.read(1)[0]
      end
    end
  end
  
  #--------------------------------------------------------------------------
  # &#9679; &#35774;&#32622;&#35843;&#33394;&#26495;
  #--------------------------------------------------------------------------
  def set_pal
    @_pal = []
    if @l_pal != nil
      @_pal = @l_pal
    elsif @g_pal != nil
      @_pal = @g_pal
    else
      for i in 0...1 << @_pal_bits
        @_pal.push i,i,i
      end
    end 
  end
  
  #--------------------------------------------------------------------------
  # &#9679; &#35299;&#30721;&#22270;&#24418;&#25968;&#25454;
  #--------------------------------------------------------------------------
  def dump_imgs(image_data,lze_len)
    @image_data = image_data.unpack("C*")
    
    self.set_pal
    
    @png_data = []

    @stack = []
    @images = []
    
    @prefix = []
    @suffix = []
    
    @bitcount = @_pal_bits
    @widthcount = 0
    
    @left_bits = 0x00
    @current_bits = lze_len + 0x01
    
    @lzw_clear = 1 << lze_len
    @lzw_eoi = @lzw_clear + 1
    @nowtablendx = @lzw_clear + 2
    @toptablendx = 1 << @current_bits
    
    @wdata = 0
    @wcode = 0
    @oldcode = 0xffff
    @row_num = 0
    @tempchar = 0x00
    @pass = 0x00
    @firstchar = 0
    @tempndx = 0
    # &#35835;&#21462;&#32534;&#30721;&#23383;&#31526;
    self.read_byte
    # &#19981;&#26159;@lzw_eoi&#21017;&#24490;&#29615;
    while @wcode != @lzw_eoi
      # @lzw_clear&#30721;
      if @wcode == @lzw_clear
        for i in 0...@lzw_clear
          @prefix[i] = 0xffff
          @suffix[i] = i
        end
        for i in @nowtablendx...4096
          @prefix[i] = 0xffff
          @suffix[i] = 0x00
        end
        @current_bits = lze_len + 0x01
        @nowtablendx = @lzw_clear + 2
        @toptablendx = 1 << @current_bits
        @oldcode = 0xffff
        # &#35835;&#21462;&#32534;&#30721;&#23383;&#31526;
        self.read_byte
        if @wcode != @lzw_eoi
          while @prefix[@wcode] != 0xffff
            @stack.push(@suffix[@wcode])
            @wcode = @prefix[@wcode]
          end
          @stack.push(@suffix[@wcode])
          @firstchar = @stack[-1]
          # &#36755;&#20986;&#35299;&#30721;&#25968;&#25454;
          self.output_data
        end
      else
        if @wcode < @nowtablendx
          @tempndx = @wcode
        else
          @tempndx = @oldcode
          @stack.push(@firstchar)
        end
        while @prefix[@tempndx] != 0xffff
          @stack.push(@suffix[@tempndx])
          @tempndx = @prefix[@tempndx]
        end
        @stack.push(@suffix[@tempndx])
        @firstchar = @stack[-1]
        @prefix[@nowtablendx] = @oldcode
        @suffix[@nowtablendx] = @firstchar
        @nowtablendx += 1
        if @nowtablendx == @toptablendx and @current_bits < 12
          @current_bits += 1
          @toptablendx = 1 << @current_bits
        end
        # &#36755;&#20986;&#35299;&#30721;&#25968;&#25454;
        self.output_data
      end
      @oldcode = @wcode
      # &#35835;&#21462;&#32534;&#30721;&#23383;&#31526;
      self.read_byte
    end
    Graphics.update
    # &#29983;&#25104;png&#22270;
    self.make_png
  end

  #--------------------------------------------------------------------------
  # &#9679; &#35835;&#21462;&#19979;&#19968;&#20010;&#23383;&#33410;
  #--------------------------------------------------------------------------
  def read_byte
    while @left_bits < @current_bits
      @next_char = @image_data.shift
      @wdata |= (@next_char << @left_bits)
      @left_bits += 0x08
    end
    @wcode = @wdata & CODE_MASK[@current_bits]
    @wdata >>= @current_bits
    @left_bits -= @current_bits
  end
  
  #--------------------------------------------------------------------------
  # &#9679; &#36755;&#20986;&#35299;&#30721;&#25968;&#25454;
  #--------------------------------------------------------------------------
  def output_data
    while !@stack.empty?
      @tempchar |= (@stack.pop << (8 - @bitcount))
      if @bitcount == 8
        @images.push(@tempchar)
        @tempchar = 0x00
        @bitcount = @_pal_bits
      else
        @bitcount += @_pal_bits
      end
      @widthcount += 1
      if @widthcount == @_width
        if @bitcount != @_pal_bits
          @images.push(@tempchar)
          @tempchar = 0x00
          @bitcount = @_pal_bits
        end
        @png_data[@row_num] = @images.clone
        @images.clear
        if @_lace > 0
          @row_num += INC_TABLE[@pass]
          if @row_num >= @_height
            @pass += 1
            @row_num = BGN_TABLE[@pass]
          end
        else
          @row_num += 1
        end
        @widthcount = 0
      end
    end
  end
  
  #--------------------------------------------------------------------------
  # &#9679; &#29983;&#25104;png&#22270;&#29255;
  #--------------------------------------------------------------------------
  def make_png
    fp = open("~TEMP/#@filename" + sprintf("_%02d",@frame_count)+".png","wb")
    fp.write(self.make_png_header)
    fp.write(self.make_png_ihdr)
    fp.write(self.make_png_plte) if @_trans_index.nil?
    fp.write(self.make_png_idat)
    fp.write(self.make_png_iend)
    fp.close
  end
    
  #--------------------------------------------------------------------------
  # &#9679; png&#22836;&#25991;&#20214;
  #--------------------------------------------------------------------------
  def make_png_header
    return [0x89,0x50,0x4e,0x47,0x0d,0x0a,0x1a,0x0a].pack("C*")
  end
  
  #--------------------------------------------------------------------------
  # &#9679; png&#20449;&#24687;&#22836;&#22359;
  #--------------------------------------------------------------------------
  def make_png_ihdr
    ih_size = [13].pack("N")
    ih_sign = "IHDR"
    ih_width = [@_width].pack("N")
    ih_height = [@_height].pack("N")
    if @_trans_index != nil
      ih_bit_depth = [@_pal_bits > 8 ? 16 : 8].pack("C")
      ih_color_type = [6].pack("C")
    else
      ih_bit_depth = [@_pal_bits].pack("C")
      ih_color_type = [3].pack("C")
    end
    ih_compression_method = [0].pack("C")
    ih_filter_method = [0].pack("C")
    ih_interlace_method = [0].pack("C")
    string = ih_sign + ih_width + ih_height + ih_bit_depth + ih_color_type +
             ih_compression_method + ih_filter_method + ih_interlace_method
    ih_crc = [Zlib.crc32(string)].pack("N")
    return ih_size + string + ih_crc
  end
  
  #--------------------------------------------------------------------------
  # &#9679; png&#35843;&#33394;&#26495;&#22359;
  #--------------------------------------------------------------------------
  def make_png_plte
    pl_size = [@_pal.size].pack("N")
    pl_sign = "PLTE"
    pl_data = @_pal.pack("C*")
    pl_crc = [Zlib.crc32(pl_sign + pl_data)].pack("N")
    return pl_size + pl_sign + pl_data + pl_crc
  end
  
  #--------------------------------------------------------------------------
  # &#9679; png&#25968;&#25454;&#22359;
  #--------------------------------------------------------------------------
  def make_png_idat
    lz_data = []
    if @_trans_index != nil
      for i in 0...@png_data.size
        lz_data.push 0
        for j in @png_data[i]
          if j == @_trans_index
            lz_data.push @_pal[j*3],@_pal[j*3+1],@_pal[j*3+2],0
          else
            lz_data.push @_pal[j*3],@_pal[j*3+1],@_pal[j*3+2],255
          end
        end
      end
    else
      for i in 0...@png_data.size
        lz_data.push 0
        lz_data += @png_data[i]
      end
    end
    id_data = Zlib::Deflate.deflate(lz_data.pack("C*"),9)
    id_size = [id_data.size].pack("N")
    id_sign = "IDAT"
    id_crc = [Zlib.crc32(id_sign + id_data)].pack("N")
    return id_size + id_sign + id_data + id_crc
  end
  
  #--------------------------------------------------------------------------
  # &#9679; png &#32467;&#23614;&#22359;
  #--------------------------------------------------------------------------
  def make_png_iend
    ie_size = [0].pack("N")
    ie_sign = "IEND"
    ie_crc = [Zlib.crc32(ie_sign)].pack("N")
    return ie_size + ie_sign + ie_crc
  end
  
end

#==============================================================================
# &#9632; Graphics
#------------------------------------------------------------------------------
# &#12288;&#22788;&#29702;&#30011;&#38754;&#30340;&#27169;&#22359; &#12290;
#==============================================================================
class << Graphics

  #--------------------------------------------------------------------------
  # &#9679; &#28155;&#21152;&#21035;&#21517;&#12289;&#32447;&#31243;&#12289;&#20020;&#30028;&#21306;
  #--------------------------------------------------------------------------
  unless method_defined? :origin_update
    alias origin_update update
    def update_critical
      Thread.critical = true
      origin_update
      Thread.critical = false
    end
    Thread.new{loop{Graphics.update_critical;sleep(9)}}
  end
  
  #--------------------------------------------------------------------------
  # &#9679; &#23450;&#20041;&#31867;&#21464;&#37327;
  #--------------------------------------------------------------------------
  @@gif_sprites = Array.new
  
  #--------------------------------------------------------------------------
  # &#9679; &#28155;&#21152;GIF&#22270;&#29255;&#31934;&#28789;
  #--------------------------------------------------------------------------
  def add(gs)
    @@gif_sprites << gs
  end
  
  #--------------------------------------------------------------------------
  # &#9679; &#21024;&#38500;GIF&#22270;&#29255;&#31934;&#28789;
  #--------------------------------------------------------------------------
  def del(gs)
    @@gif_sprites.delete gs
  end

  #--------------------------------------------------------------------------
  # &#9679; &#26356;&#26032;&#30011;&#38754;
  #--------------------------------------------------------------------------
  def update
    update_critical
    @@gif_sprites.each{|gs| gs.update}
  end
  
end

#==============================================================================
# &#9632; GIFSprite
#------------------------------------------------------------------------------
# &#12288;GIF&#31934;&#28789;&#30340;&#26680;&#24515;&#31867; &#12290;
#==============================================================================
class GIFSprite
  
  #============================================================================
  # &#9679; GIFSprite::Infos
  #----------------------------------------------------------------------------
  # &#12288;GIF&#22270;&#29255;&#20449;&#24687;&#31867; &#12290;
  #============================================================================
  class Infos
    
    #------------------------------------------------------------------------
    # &#9679; &#23450;&#20041;&#23454;&#20363;&#21464;&#37327;
    #------------------------------------------------------------------------
    attr_accessor :total_frames
    attr_accessor :width
    attr_accessor :height
    attr_accessor :frame_data
    
    #------------------------------------------------------------------------
    # &#9679; &#21021;&#22987;&#21270;
    #------------------------------------------------------------------------
    def initialize
      @total_frames = 0
      @width = 0
      @height = 0
      @frame_data = Array.new
    end
    
    #==========================================================================
    # &#9679; GIFSprite::Infos::FrameData
    #--------------------------------------------------------------------------
    # &#12288;GIF&#22270;&#29255;&#27599;&#24103;&#20449;&#24687;&#31867; &#12290;
    #==========================================================================
    class FrameData
      
      #----------------------------------------------------------------------
      # &#9679; &#23450;&#20041;&#23454;&#20363;&#21464;&#37327;
      #----------------------------------------------------------------------
      attr_accessor :offset_x
      attr_accessor :offset_y
      attr_accessor :delay_time
      attr_accessor :disposal_method
      
      #----------------------------------------------------------------------
      # &#9679; &#21021;&#22987;&#21270;
      #----------------------------------------------------------------------
      def initialize
        @offset_x = 0
        @offset_y = 0
        @delay_time = 0
        @disposal_method = 0
      end
      
    end
    
  end
  
  #--------------------------------------------------------------------------
  # &#9679; &#39044;&#22788;&#29702;&#65306;&#24314;&#31435;&#20020;&#26102;&#25991;&#20214;&#22841;
  #--------------------------------------------------------------------------
  unless Dir["*"].include?("~TEMP")
    Dir.mkdir("~TEMP")
    System.attrib("~TEMP","+h","+s")
  end
  
  #--------------------------------------------------------------------------
  # &#9679; &#28165;&#31354;&#30828;&#32531;&#23384;
  #--------------------------------------------------------------------------
  def self.TmpFileclear
    begin
      Dir["~TEMP/*"].each{|filename| File.delete filename}
    rescue
    end
  end
  
  #--------------------------------------------------------------------------
  # &#9679; &#39044;&#21152;&#36733;&#22270;&#29255;
  #--------------------------------------------------------------------------
  def self.pre_load(filename_arr)
    filename_arr.each{|fn| GIF.readdata(fn)}
  end
  
  #--------------------------------------------------------------------------
  # &#9679; &#23450;&#20041;&#23454;&#20363;&#21464;&#37327;
  #--------------------------------------------------------------------------
  attr_accessor :x
  attr_accessor :y
  attr_reader   :z
  attr_accessor :loop_counts
  attr_accessor :viewport
  
  #--------------------------------------------------------------------------
  # &#9679; &#21019;&#24314;&#23545;&#35937;
  #--------------------------------------------------------------------------
  def self.new(viewport = nil,x = 0,y = 0,loop_counts = -1)
    obj = super()
    obj.viewport = viewport
    obj.x = x
    obj.y = y
    obj.loop_counts = loop_counts
    Graphics.add(obj)
    obj
  end
  
  #--------------------------------------------------------------------------
  # &#9679; &#33719;&#21462;&#22270;&#29255;&#20449;&#24687;
  #--------------------------------------------------------------------------
  def bitmap
    @gif_infos
  end
  
  #--------------------------------------------------------------------------
  # &#9679; &#35774;&#32622;&#22270;&#29255;&#25991;&#20214;&#21517;
  #--------------------------------------------------------------------------
  def bitmap=(filename)
    @gif_infos = GIF.readdata(filename)
    if @gif_infos != nil
      @sp_arr = Array.new
      basename = File.basename(filename,".*")
      for i in 0...@gif_infos.total_frames
        sp   = Sprite.new(@viewport)
        sp.bitmap = Bitmap.new(sprintf("~TEMP/#{basename}_%02d.png",i + 1))
        sp.visible = i == 0
        sp.x = @gif_infos.frame_data[i].offset_x
        sp.y = @gif_infos.frame_data[i].offset_y
        @sp_arr << sp
      end
      @update_frame_count = 0
      @current_show_frame = 0
      @next_frame_counts = 
      (@gif_infos.frame_data[0].delay_time * Graphics.frame_rate / 100) 
    end
  end
  
  #--------------------------------------------------------------------------
  # &#9679; &#23450;&#20041;x=
  #--------------------------------------------------------------------------
  def x=(x)
    if @gif_infos.nil?
      @x = 0
      return
    end
    @x = x
    for i in 0...@gif_infos.total_frames
      @sp_arr[i].x = @gif_infos.frame_data[i].offset_x + @x
    end
  end
  
  #--------------------------------------------------------------------------
  # &#9679; &#23450;&#20041;y=
  #--------------------------------------------------------------------------
  def y=(y)
    if @gif_infos.nil?
      @y = 0
      return
    end
    @y = y
    for i in 0...@gif_infos.total_frames
      @sp_arr[i].y = @gif_infos.frame_data[i].offset_y + @y
    end
  end
  
  #--------------------------------------------------------------------------
  # &#9679; &#23450;&#20041;z=
  #--------------------------------------------------------------------------
  def z=(z)
    if @gif_infos.nil?
      @z = 0
      return
    end
    @z = z
    for i in 0...@gif_infos.total_frames
      @sp_arr[i].z = @z
    end
  end
  
  #--------------------------------------------------------------------------
  # &#9679; &#33719;&#21462;&#23485;&#24230;
  #--------------------------------------------------------------------------
  def width
    return @gif_infos.nil? ? 0 : @gif_infos.width
  end
  
  #--------------------------------------------------------------------------
  # &#9679; &#33719;&#21462;&#39640;&#24230;
  #--------------------------------------------------------------------------
  def height
    return @gif_infos.nil? ? 0 : @gif_infos.height
  end
  
  #--------------------------------------------------------------------------
  # &#9679; &#37322;&#25918;&#31934;&#28789;
  #--------------------------------------------------------------------------
  def dispose
    Graphics.del(self)
    @sp_arr.each{|sp|
      sp.bitmap.dispose
      sp.dispose
    }
    @sp_arr.clear
    @gif_infos = nil
  end
  
  #--------------------------------------------------------------------------
  # &#9679; &#26356;&#26032;&#31934;&#28789;
  #--------------------------------------------------------------------------
  def update
    if @gif_infos.nil?
      return
    end
    @update_frame_count += 1
    if @update_frame_count >= @next_frame_counts
      @current_show_frame = (@current_show_frame + 1) % @gif_infos.total_frames
      case @gif_infos.frame_data[@current_show_frame - 1].disposal_method
      when 0 # &#19981;&#22788;&#29702;
        
      when 1 # &#22270;&#35937;&#20445;&#30041;&#22312;&#21407;&#22788;
        
      when 2 # &#24403;&#21069;&#22270;&#35937;&#28040;&#22833;
        @sp_arr[@current_show_frame - 1].visible = false
      when 3 # &#23578;&#19981;&#26126; = =
        
      end
      @sp_arr[@current_show_frame].visible = true
      if @current_show_frame == 0
        @loop_counts -= 1 if @loop_counts > 0
        if @loop_counts == 0
          self.dispose
          return
        end
        for i in 0...@sp_arr.size
          @sp_arr[i].visible = i == @current_show_frame
        end
      end
      @update_frame_count = 0
      @next_frame_counts = (@gif_infos.frame_data[@current_show_frame].\\
      delay_time * Graphics.frame_rate / 100)
    end
  end
  
end
Download

Visualizações: 162 Downloads: 13
Informações

Desenvolvimento: N�o sei
Categoria: Advanced Scripts/System Enhanc
Classe: RGSS
Versão: 1.0.2
Tamanho: 764,25 kB
Ultima atualização: 02/06/09
Discuta

Você precisa estar logado para criar um tópico de discução em nosso Forum. Faça Login ou Registre-se por favor.
Envie para um amigo

Envie um e-mail indicando este script para um amigo seu!
E-mail enviado com sucesso!!
Falha no envio do e-mail!!!
Talvez algum campo ficou sem preenchimento!
GIF Player

Download

Informações

Discuta

Envie para um amigo

Favoritos
