dxruby64 1.4.7

data/sample/shader_sample/Shader/RgssSprite.rb

@@ -0,0 +1,143 @@
+class SpriteShader < Shader
+  hlsl = <<EOS
+  float4 g_blend;
+  float4 g_tone;
+
+  texture tex0;
+  sampler Samp = sampler_state
+  {
+   Texture =<tex0>;
+  };
+
+  struct PixelIn
+  {
+    float2 UV : TEXCOORD0;
+  };
+  struct PixelOut
+  {
+    float4 Color : COLOR0;
+  };
+
+  PixelOut PS(PixelIn input)
+  {
+    PixelOut output;
+    float3 temp;
+    float3 ntsc = {0.298912, 0.586611, 0.114478};
+    float ntscy;
+    output.Color = tex2D( Samp, input.UV );
+
+    ntsc = ntsc * output.Color.rgb;
+    ntscy = ntsc.r + ntsc.g + ntsc.b;
+    temp.r = output.Color.r + ((ntscy - output.Color.r) * g_tone.a);
+    temp.g = output.Color.g + ((ntscy - output.Color.g) * g_tone.a);
+    temp.b = output.Color.b + ((ntscy - output.Color.b) * g_tone.a);
+
+    output.Color.rgb = min(1.0, temp + g_tone.rgb) * (1.0 - g_blend.a) + g_blend.rgb * g_blend.a;
+
+    return output;
+  }
+
+  technique TShader
+  {
+   pass P0
+   {
+    PixelShader = compile ps_2_0 PS();
+   }
+  }
+EOS
+
+  @@core = Shader::Core.new(hlsl, 
+    {
+      :g_blend => :float,
+      :g_tone => :float,
+    }
+  )
+
+  def initialize
+    super(@@core, "TShader")
+    self.g_blend = [0.0,0.0,0.0,0.0]
+    self.g_tone = [0.0,0.0,0.0,0.0]
+    @tone = [0.0,0.0,0.0]
+    @gray = 0.0
+    class << self
+      protected :g_blend, :g_blend=, :g_tone, :g_tone=
+    end
+  end
+
+  def tone=(ary)
+    self.g_tone = [ary[0] / 255.0, ary[1] / 255.0, ary[2] / 255.0, @gray / 255.0]
+    @tone = ary
+  end
+
+  def gray=(gray)
+    self.g_tone = [@tone[0] / 255.0, @tone[1] / 255.0, @tone[2] / 255.0, gray / 255.0]
+    @gray = gray
+  end
+
+  def color=(ary)
+    self.g_blend = [ary[1] / 255.0, ary[2] / 255.0, ary[3] / 255.0, ary[0] / 255.0]
+  end
+end
+
+class RgssSprite < Sprite
+  def initialize(x=0, y=0, image=nil)
+    super
+    self.shader = SpriteShader.new
+    @rgss_sprite_color = nil
+    @rgss_sprite_flash_color = nil
+    @rgss_sprite_flash_duration = 1
+    @rgss_sprite_flash_count = 0
+  end
+
+  def tone=(ary)
+    if ary == nil
+      self.shader.tone = [0,0,0]
+    else
+      self.shader.tone = ary
+    end
+  end
+
+  def gray=(gray)
+    self.shader.gray = gray
+  end
+
+  def color=(ary)
+    @rgss_sprite_color = ary
+  end
+
+  def flash(color=[255,255,255,255], duration=30)
+    @rgss_sprite_flash_color = color
+    @rgss_sprite_flash_duration = duration
+    @rgss_sprite_flash_count = duration
+  end
+
+  def update
+    @rgss_sprite_flash_count -= 1 if @rgss_sprite_flash_count > 0
+  end
+
+  def draw
+    if @rgss_sprite_color != nil and @rgss_sprite_flash_count > 0
+      if @rgss_sprite_color[0] > @rgss_sprite_flash_color[0] * @rgss_sprite_flash_count / @rgss_sprite_flash_duration
+        self.shader.color = @rgss_sprite_color
+      else
+        self.shader.color = [@rgss_sprite_flash_color[0] * @rgss_sprite_flash_count / @rgss_sprite_flash_duration,
+                             @rgss_sprite_flash_color[1],
+                             @rgss_sprite_flash_color[2],
+                             @rgss_sprite_flash_color[3]
+                            ]
+      end
+    elsif @rgss_sprite_flash_count > 0
+      self.shader.color = [@rgss_sprite_flash_color[0] * @rgss_sprite_flash_count / @rgss_sprite_flash_duration,
+                           @rgss_sprite_flash_color[1],
+                           @rgss_sprite_flash_color[2],
+                           @rgss_sprite_flash_color[3]
+                          ]
+    elsif @rgss_sprite_color != nil
+      self.shader.color = @rgss_sprite_color
+    else
+      self.shader.color = [0,0,0,0]
+    end
+    super
+  end
+end
+

data/sample/shader_sample/Shader/Transition.rb

@@ -0,0 +1,108 @@
+# -*- coding: Windows-31J -*-
+
+class TransitionShader < DXRuby::Shader
+  hlsl = <<EOS
+  float g_min;
+  float g_max;
+  float2 scale;
+  texture tex0;
+  texture tex1;
+  sampler Samp0 = sampler_state
+  {
+   Texture =<tex0>;
+  };
+  sampler Samp1 = sampler_state
+  {
+   Texture =<tex1>;
+   AddressU = WRAP;
+   AddressV = WRAP;
+  };
+
+  struct PixelIn
+  {
+    float2 UV : TEXCOORD0;
+  };
+  struct PixelOut
+  {
+    float4 Color : COLOR0;
+  };
+
+  PixelOut PS(PixelIn input)
+  {
+    PixelOut output;
+    output.Color = tex2D( Samp0, input.UV );
+    output.Color.a *= smoothstep(g_min, g_max, tex2D( Samp1, input.UV * scale ).r );
+
+    return output;
+  }
+
+  technique Transition
+  {
+   pass P0
+   {
+    PixelShader = compile ps_2_0 PS();
+   }
+  }
+EOS
+
+  @@core = DXRuby::Shader::Core.new(
+    hlsl,
+    {
+      :g_min => :float,
+      :g_max => :float,
+      :scale => :float, # HLSL����float2�̏ꍇ��:float���w�肵��[Float, Flaot]�Ƃ����`�œn��
+      :tex1 => :texture,
+    }
+  )
+
+  # duration�͑J�ڂɂ�����t���[�����Aimage�̓��[���摜��Image�I�u�W�F�N�g(�ȗ��ŃN���X�t�F�[�h)�Avague�͞B����
+  def initialize(duration, image=nil, vague=nil)
+    super(@@core, "Transition")
+    if image
+      @image = image
+      @vague = vague == nil ? 40 : vague
+    else
+      @image = DXRuby::Image.new(1, 1, [0,0,0])
+      @vague = 256
+    end
+    @duration = duration
+    @count = 0
+    self.g_min = -@vague.fdiv(@duration)
+    self.g_max = 0.0
+    self.tex1   = @image
+    self.scale  = [DXRuby::Window.width.fdiv(@image.width), DXRuby::Window.height.fdiv(@image.height)]
+    # �V�F�[�_�p�����[�^�ݒ�̃��\�b�h�͊O������J�Ƃ���
+    class << self
+      protected :g_min, :g_min=, :g_max, :g_max=, :scale, :scale=, :tex1, :tex1=
+    end
+  end
+
+  def start(duration = nil)
+    @duration = duration if duration
+    @count = 0
+    self.g_min = -@vague.fdiv(@duration)
+    self.g_max = 0.0
+  end
+
+  def next
+    @count += 1
+    self.g_min = (((@vague+@duration).fdiv(@duration)) * @count - @vague).fdiv(@duration)
+    self.g_max = (((@vague+@duration).fdiv(@duration)) * @count).fdiv(@duration)
+  end
+
+  def frame_count=(c)
+    @count = c
+    self.g_min = (((@vague+@duration).fdiv(@duration)) * @count - @vague).fdiv(@duration)
+    self.g_max = (((@vague+@duration).fdiv(@duration)) * @count).fdiv(@duration)
+  end
+
+  def frame_count
+    @count
+  end
+
+  # �`��Ώۂ��w�肷��BRenderTarget�I�u�W�F�N�g���AWindow��n���B�f�t�H���g��Window�B
+  def target=(t)
+    self.scale = [t.width.fdiv(@image.width), t.height.fdiv(@image.height)]
+  end
+end
+

data/sample/shader_sample/fan.rb

@@ -0,0 +1,53 @@
+require 'dxruby'
+
+hlsl = <<EOS
+  texture tex0;
+  float4 color;
+  float start_angle, end_angle, flag, length;
+
+  sampler Samp0 = sampler_state
+  {
+   Texture =<tex0>;
+  };
+
+  float4 PS(float2 input : TEXCOORD0) : COLOR0
+  {
+    float temp;
+    temp = degrees(atan2(0.5 - input.y ,0.5 - input.x)) + 180.0;
+    clip(float2((temp - start_angle) * (end_angle - temp) * flag, length - distance(float2(0.5, 0.5), input)));
+
+    return color;
+  }
+
+  technique
+  {
+   pass
+   {
+    PixelShader = compile ps_2_0 PS();
+   }
+  }
+EOS
+
+core = Shader::Core.new(hlsl, :color => :float, :start_angle => :float, :end_angle => :float, :flag => :float, :length => :float)
+shader = Shader.new(core)
+
+image = Image.new(300,300)
+
+shader.color = [255, 255, 255, 255]
+shader.start_angle = 0
+shader.end_angle = 0
+shader.flag = 1
+shader.length = 0.4
+
+x = 1
+
+Window.loop do
+  x += 5
+  x = 0 if x > 360
+  shader.start_angle = x
+  Window.draw_ex(100, 100, image, shader:shader)
+end
+
+
+
+

data/sample/shader_sample/readme_sample.txt

@@ -0,0 +1,43 @@
+DXRuby �V�F�[�_�T���v���v���O����
+
+�܂��ŏ��ɁA�\�[�X�������Ă��߂�Ȃ����B
+�e�L�g�[�ɍ�������̂������Q�l�ɂȂ�΂��Ċ����ŋl�ߍ���ł���܂��B
+
+sample_blur.rb
+    �E�E�E�u���[(�ڂ���)�����ł��B
+
+sample_divide.rb
+    �E�E�E�}�E�X�Ő��������Ɖ摜���^����‚ɂȂ�܂��B
+
+sample_flash.rb
+    �E�E�EZ�L�[�ʼn摜���t���b�V�����܂��B
+
+sample_lens.rb
+    �E�E�E�}�E�X�J�[�\���̈ʒu�̊G�����ዾ�݂����Ɋg�傳��܂��B
+
+sample_mapping.rb
+    �E�E�E���S���瓯�S�~��ɏc���X�^�X�N���[�������āA���Ɖe���v�Z���Ă��܂��B
+          �o���v�}�b�s���O���h�L�ł��B
+
+sample_rasterscroll.rb
+    �E�E�E�V���v���ȃ��X�^�X�N���[���ł��B
+
+sample_rgsssprite.rb
+    �E�E�ERGSS2��Sprite�N���X�Ƌ߂��G�t�F�N�g(flash�Atone�Acolor)����������V�F�[�_�ł��B
+
+sample_spehari.rb
+    �E�E�ESEGA�̃X�y�[�X�n���A�[�̒n�ʂ̂悤�Ȃ��̂�`�悵�܂��B
+
+sample_sphere.rb
+    �E�E�E���̂̕\�ʂɉ摜���}�b�s���O����悤�ȃG�t�F�N�g�ł��B
+
+sample_transition.rb
+    �E�E�E���[���摜�Ɋ�Â����g�����W�V�������s���܂��BRGSS�ɋ߂��p�����[�^�ɂȂ��Ă��܂��B
+
+sample_wingman.rb
+    �E�E�E�E�B���O�}���ۂ��G�t�F�N�g�ł��B�Â��Ă��݂܂���B
+
+turn_transition.rb
+    �E�E�E����̓V�F�[�_�ł͂Ȃ��̂ł����A�Ȃ��������ɓ����Ă��܂��B
+          Window.draw_morph���g���āA���������摜��3D��]�̂悤�ɕ`�悵�܂��B
+

data/sample/shader_sample/sample_blur.rb

@@ -0,0 +1,112 @@
+require 'dxruby'
+
+hlsl = <<EOS
+  texture tex0;
+  float2 g_size;
+
+  sampler Samp0 = sampler_state
+  {
+    Texture =<tex0>;
+    AddressU=BORDER;
+    AddressV=BORDER;
+  };
+
+  float4 PS1(float2 In : TEXCOORD0) : COLOR0
+  {
+    float2 Texel0 = In + float2( -1.0/g_size.x, 0.0f );
+    float2 Texel1 = In + float2( -1.0/g_size.x*2, 0.0f );
+    float2 Texel2 = In + float2( -1.0/g_size.x*3, 0.0f );
+    float2 Texel3 = In + float2( -1.0/g_size.x*4, 0.0f );
+    float2 Texel4 = In + float2( -1.0/g_size.x*5, 0.0f );
+      
+    float2 Texel5 = In + float2( 1.0/g_size.x, 0.0f );
+    float2 Texel6 = In + float2( 1.0/g_size.x*2, 0.0f );
+    float2 Texel7 = In + float2( 1.0/g_size.x*3, 0.0f );
+    float2 Texel8 = In + float2( 1.0/g_size.x*4, 0.0f );
+    float2 Texel9 = In + float2( 1.0/g_size.x*5, 0.0f );
+
+    float4 p0  = tex2D( Samp0, In ) * 0.20f;
+      
+    float4 p1  = tex2D( Samp0, Texel0 ) * 0.12f;
+    float4 p2  = tex2D( Samp0, Texel1 ) * 0.10f;
+    float4 p3  = tex2D( Samp0, Texel2 ) * 0.08f;
+    float4 p4  = tex2D( Samp0, Texel3 ) * 0.06f;      
+    float4 p5  = tex2D( Samp0, Texel4 ) * 0.04f;
+   
+    float4 p6  = tex2D( Samp0, Texel5 ) * 0.12f;
+    float4 p7  = tex2D( Samp0, Texel6 ) * 0.10f;
+    float4 p8  = tex2D( Samp0, Texel7 ) * 0.08f;
+    float4 p9  = tex2D( Samp0, Texel8 ) * 0.06f;
+    float4 p10 = tex2D( Samp0, Texel9 ) * 0.04f;
+
+    return p0 + p1 + p2 + p3 + p4 + p5 + p6 + p7 + p8 + p9 + p10;
+  }
+
+  float4 PS2(float2 In : TEXCOORD0) : COLOR0
+  {
+    float2 Texel0 = In + float2( 0.0f, -1.0/g_size.y );
+    float2 Texel1 = In + float2( 0.0f, -1.0/g_size.y*2 );
+    float2 Texel2 = In + float2( 0.0f, -1.0/g_size.y*3 );
+    float2 Texel3 = In + float2( 0.0f, -1.0/g_size.y*4 );
+    float2 Texel4 = In + float2( 0.0f, -1.0/g_size.y*5 );
+        
+    float2 Texel5 = In + float2( 0.0f, 1.0/g_size.y );
+    float2 Texel6 = In + float2( 0.0f, 1.0/g_size.y*2 );
+    float2 Texel7 = In + float2( 0.0f, 1.0/g_size.y*3 );
+    float2 Texel8 = In + float2( 0.0f, 1.0/g_size.y*4 );
+    float2 Texel9 = In + float2( 0.0f, 1.0/g_size.y*5 );
+  
+    float4 p0  = tex2D( Samp0, In ) * 0.20f;
+        
+    float4 p1  = tex2D( Samp0, Texel0 ) * 0.12f;
+    float4 p2  = tex2D( Samp0, Texel1 ) * 0.10f;
+    float4 p3  = tex2D( Samp0, Texel2 ) * 0.08f;
+    float4 p4  = tex2D( Samp0, Texel3 ) * 0.06f;      
+    float4 p5  = tex2D( Samp0, Texel4 ) * 0.04f;
+     
+    float4 p6  = tex2D( Samp0, Texel5 ) * 0.12f;
+    float4 p7  = tex2D( Samp0, Texel6 ) * 0.10f;
+    float4 p8  = tex2D( Samp0, Texel7 ) * 0.08f;
+    float4 p9  = tex2D( Samp0, Texel8 ) * 0.06f;
+    float4 p10 = tex2D( Samp0, Texel9 ) * 0.04f;
+  
+    return p0 + p1 + p2 + p3 + p4 + p5 + p6 + p7 + p8 + p9 + p10;
+  }
+
+  technique Blur1
+  {
+    pass P0
+    {
+      PixelShader  = compile ps_2_0 PS1();
+    }
+  }
+  technique Blur2
+  {
+    pass P0
+    {
+      PixelShader  = compile ps_2_0 PS2();
+    }   
+  }
+EOS
+
+core = Shader::Core.new(hlsl,{:g_size => :float})
+shader1 = Shader.new(core, "Blur1")
+shader2 = Shader.new(core, "Blur2")
+
+image = Image.load("./image/maptile.png")
+
+shader1.g_size = [image.width,image.height]
+shader2.g_size = [image.width,image.height]
+
+rt1 = RenderTarget.new(image.width,image.height)
+rt2 = RenderTarget.new(image.width,image.height)
+
+Window.loop do
+  Window.draw(50, 50, image)
+  rt1.draw_ex(0, 0, image, :blend=>:nond, :shader=>shader1)
+  rt1.update
+  rt2.draw_ex(0, 0, rt1, :blend=>:nond, :shader=>shader2)
+  rt2.update
+  Window.draw(350, 50, rt2)
+  break if Input.key_push?(K_ESCAPE)
+end

data/sample/shader_sample/sample_divide.rb

@@ -0,0 +1,91 @@
+require 'dxruby'
+
+hlsl = <<EOS
+  float3 p1, p2;
+  texture tex0;
+
+  sampler Samp0 = sampler_state
+  {
+   Texture =<tex0>;
+  };
+
+  float4 PS1(float2 input : TEXCOORD0) : COLOR0
+  {
+    clip( cross( float3(p2.x - p1.x, p2.y - p1.y, 0), float3(input.x - p1.x, input.y - p1.y, 0) ).z );
+    return tex2D( Samp0, input );
+  }
+
+  float4 PS2(float2 input : TEXCOORD0) : COLOR0
+  {
+    clip( cross( float3(p1.x - p2.x, p1.y - p2.y, 0), float3(input.x - p1.x, input.y - p1.y, 0) ).z );
+    return tex2D( Samp0, input );
+  }
+
+  technique Zan1
+  {
+   pass P0
+   {
+    PixelShader = compile ps_2_0 PS1();
+   }
+  }
+  technique Zan2
+  {
+   pass P0
+   {
+    PixelShader = compile ps_2_0 PS2();
+   }
+  }
+EOS
+
+Window.width, Window.height = 800, 600
+
+core = Shader::Core.new(hlsl,{:p1=>:float, :p2=>:float})
+shader1 = Shader.new(core, "Zan1")
+shader2 = Shader.new(core, "Zan2")
+image = Image.load("bgimage/BG42a.jpg")
+image1 = image2 = nil
+
+rt = RenderTarget.new(image.width, image.height)
+
+point = nil
+transition_flg = false
+
+x1 = y1 = x2 = y2 = 0
+angle = 0
+alpha = 255
+
+Window.loop do
+  if !transition_flg
+    if Input.mouse_push?(M_LBUTTON)
+      point = [Input.mouse_pos_x, Input.mouse_pos_y]
+    end
+
+    if point
+      if Input.mouse_down?(M_LBUTTON)
+        Window.draw_line(point[0], point[1], Input.mouse_pos_x, Input.mouse_pos_y, C_WHITE, 1)
+      else
+        transition_flg = true
+        shader1.p1 = shader2.p1 = [point[0].quo(image.width), point[1].quo(image.height),0]
+        shader1.p2 = shader2.p2 = [Input.mouse_pos_x.quo(image.width), Input.mouse_pos_y.quo(image.height),0]
+        angle = Math.atan2( Input.mouse_pos_y - point[1], Input.mouse_pos_x - point[0] )
+        image1 = rt.draw_shader(0, 0, image, shader1).update.to_image
+        image2 = rt.draw_shader(0, 0, image, shader2).update.to_image
+        alpha = 255
+        point = nil
+        x1 = y1 = x2 = y2 = 0
+      end
+    end
+    Window.draw(0, 0, image)
+  else
+    x1 -= Math.cos(angle) * 5
+    y1 -= Math.sin(angle) * 5
+    x2 += Math.cos(angle) * 5
+    y2 += Math.sin(angle) * 5
+    alpha -= 3
+    Window.draw_alpha(x1, y1, image1, alpha)
+    Window.draw_alpha(x2, y2, image2, alpha)
+    transition_flg = false if alpha < 10
+  end
+  break if Input.key_push?(K_ESCAPE)
+end
+

data/sample/shader_sample/sample_flash.rb

@@ -0,0 +1,54 @@
+#!ruby -Ks
+require 'dxruby'
+require './shader/flash.rb'
+
+map = [[0, 0, 0, 0, 0, 0, 0, 0, 29, 11, 11, 30, 34, 66, 67, 67],
+       [0, 0, 0, 24, 25, 26, 0, 0, 29, 11, 11, 39, 40, 6, 34, 34],
+       [0, 0, 24, 17, 31, 35, 0, 0, 12, 20, 11, 11, 11, 39, 40, 40],
+       [0, 24, 17, 34, 7, 44, 0, 28, 28, 29, 11, 11, 11, 11, 11, 11],
+       [0, 33, 31, 34, 35, 0, 28, 3, 37, 38, 11, 11, 11, 18, 19, 19],
+       [0, 42, 43, 43, 44, 28, 3, 38, 11, 11, 11, 18, 19, 13, 28, 28],
+       [0, 0, 0, 0, 3, 37, 38, 11, 11, 18, 19, 13, 28, 28, 28, 0],
+       [0, 0, 0, 3, 38, 11, 11, 11, 18, 13, 28, 28, 51, 52, 52, 52],
+       [0, 0, 3, 38, 11, 11, 18, 19, 13, 51, 52, 52, 86, 58, 61, 76],
+       [28, 0, 29, 11, 11, 18, 13, 28, 51, 86, 58, 58, 61, 61, 58, 62],
+       [0, 28, 29, 11, 18, 13, 28, 0, 60, 58, 61, 61, 61, 61, 76, 71],
+       [0, 28, 29, 11, 27, 28, 28, 51, 86, 61, 61, 58, 76, 70, 71, 0],
+       [0, 0, 29, 11, 36, 4, 28, 60, 58, 61, 58, 76, 71, 0, 1, 2],
+       [0, 28, 29, 11, 11, 36, 4, 69, 70, 70, 70, 71, 0, 1, 2, 0],
+       [0, 0, 12, 20, 11, 11, 27, 0, 1, 0, 1, 1, 1, 2, 2, 0],
+       [0, 0, 28, 12, 20, 11, 27, 0, 0, 0, 2, 2, 0, 2, 2, 0],
+       [0, 0, 0, 2, 29, 11, 27, 1, 2, 2, 2, 0, 0, 2, 2, 2],
+       [0, 0, 0, 2, 29, 11, 27, 1, 0, 1, 1, 2, 2, 0, 0, 2],
+       [0, 0, 0, 0, 29, 11, 27, 1, 0, 2, 2, 2, 1, 1, 2, 2],
+       [0, 45, 47, 2, 29, 11, 36, 4, 1, 2, 2, 0, 0, 2, 2, 0],
+       [45, 82, 56, 0, 29, 11, 11, 36, 4, 1, 2, 2, 2, 2, 0, 0],
+       [54, 0, 56, 0, 12, 20, 11, 11, 36, 37, 4, 0, 2, 2, 2, 2],
+       [54, 55, 81, 46, 47, 12, 20, 11, 11, 11, 36, 4, 1, 1, 1, 2],
+       [54, 55, 0, 0, 56, 0, 12, 19, 20, 11, 11, 36, 37, 4, 1, 1],
+       [54, 0, 55, 55, 56, 0, 0, 0, 12, 20, 11, 11, 11, 36, 37, 37],
+       [63, 73, 55, 55, 56, 0, 0, 2, 2, 29, 11, 11, 11, 11, 11, 11],
+       [0, 54, 0, 55, 81, 47, 0, 2, 3, 38, 11, 11, 11, 11, 11, 11],
+       [0, 54, 0, 0, 55, 56, 2, 0, 29, 11, 11, 11, 21, 22, 22, 22],
+       [0, 63, 64, 64, 64, 65, 0, 0, 29, 11, 11, 21, 15, 48, 49, 49],
+       [0, 0, 0, 0, 0, 0, 0, 0, 29, 11, 11, 30, 34, 57, 34, 34],
+      ]
+
+shader = FlashShader.new(30, [255,255,255])
+
+rt = RenderTarget.new(640, 480)
+image = Image.loadToArray("image/maptile.png", 9, 10)
+
+Window.loop do
+  rt.draw_tile(0, 0, map, image, 0, 0, 12, 14)
+  rt.draw_tile(300, 200, map, image, 0, 0, 12, 14)
+  rt.update
+
+  shader.start if Input.keyPush?(K_Z)
+  shader.next
+
+  Window.draw_ex(0, 0, rt, :shader=>shader, :angle => 20)
+
+  break if Input.keyPush?(K_ESCAPE)
+end
+