dxruby64 1.4.7

data/sample/shader_sample/sample_lens.rb

@@ -0,0 +1,65 @@
+require 'dxruby'
+
+hlsl = <<EOS
+texture tex0;
+texture tex1;
+float2 scale;
+float2 pos;
+float r, distance;
+
+sampler Samp0 = sampler_state
+{
+ Texture =<tex0>;
+};
+sampler Samp1 = sampler_state
+{
+ Texture =<tex1>;
+ AddressU = BORDER;
+ AddressV = BORDER;
+};
+
+float4 PS(float2 input : TEXCOORD0) : COLOR0
+{
+  float4 output;
+  float d;
+
+  clip(tex2D( Samp0, input ).r - 1.0);
+
+  d = sqrt((input.x-0.5)*(input.x-0.5) + (input.y-0.5)*(input.y-0.5))+1;
+  output = tex2D( Samp1, float2( pos.x + (input.x-0.5) / scale.x * distance / r * d, pos.y + (input.y-0.5) / scale.y * distance / r * d));
+  return output;
+}
+
+technique Lens
+{
+ pass P0
+ {
+  PixelShader = compile ps_2_0 PS();
+ }
+}
+EOS
+
+Window.width, Window.height = 800, 600
+bgimage = Image.load("bgimage/BG42a.jpg")
+image = Image.new(200,200).circle_fill(100,100,100,C_WHITE)
+loupeimage = Image.new(200,200).circle(100,100,100,C_WHITE)
+
+core = DXRuby::Shader::Core.new(hlsl, {:scale=>:float, :r=>:float, :distance=>:float, :tex1=>:texture, :pos=>:float})
+shader = Shader.new(core, "Lens")
+shader.scale = [bgimage.width.quo(image.width), bgimage.height.quo(image.height)]
+shader.r = 1000
+shader.distance = 500
+shader.tex1 = bgimage
+
+Window.loop do
+  shader.pos = [Input.mouse_pos_x.quo(bgimage.width), Input.mouse_pos_y.quo(bgimage.height)]
+  shader.distance += Input.y*10
+  shader.distance = 0 if shader.distance < 0
+  shader.distance = shader.r if shader.distance > shader.r
+
+  Window.draw(0,0,bgimage)
+  Window.draw_shader(Input.mouse_pos_x-image.width/2, Input.mouse_pos_y-image.width/2, image, shader)
+  Window.draw(Input.mouse_pos_x-image.width/2, Input.mouse_pos_y-image.width/2, loupeimage)
+  break if Input.key_push?(K_ESCAPE)
+end
+

data/sample/shader_sample/sample_mapping.rb

@@ -0,0 +1,50 @@
+require 'dxruby'
+
+hlsl = <<EOS
+float g_start;
+float g_level;
+texture tex0;
+sampler Samp = sampler_state
+{
+ Texture =<tex0>;
+ AddressU = BORDER;
+ AddressV = BORDER;
+};
+
+float4 PS(float2 input : TEXCOORD0) : COLOR0
+{
+  float4 output;
+  float dist = radians(distance(input, float2(0.5, 0.5)) * 360 * 4 - g_start);
+  float height = sin(dist);
+  float slope = cos(dist);
+  float d = clamp(-1,1,dot(normalize(float3(input.y - 0.5, input.x - 0.5,0 )), float3(0.5,-0.5,0.5)))*slope+1;
+  input.y = input.y + height * g_level;
+
+  output = tex2D( Samp, input ) * d;
+
+  return output;
+}
+
+technique Raster
+{
+ pass P0
+ {
+  PixelShader = compile ps_2_0 PS();
+ }
+}
+EOS
+
+Window.width, Window.height = 800, 600
+core = DXRuby::Shader::Core.new(hlsl, {:g_start=>:float, :g_level=>:float})
+shader = Shader.new(core, "Raster")
+shader.g_start = 0
+shader.g_level = 0
+image = Image.load("bgimage/BG42a.jpg")
+
+Window.loop do
+  shader.g_start += 3
+  shader.g_level = 0.15
+  Window.draw_shader(0, 0, image, shader)
+  break if Input.key_push?(K_ESCAPE)
+end
+

data/sample/shader_sample/sample_rasterscroll.rb

@@ -0,0 +1,48 @@
+#!ruby -Ks
+require 'dxruby'
+require './shader/rasterscroll.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 = RasterScrollShader.new(5, 0.1)
+rt = RenderTarget.new(640, 480)
+image = Image.load_to_array("image/maptile.png", 9, 10)
+
+Window.loop do
+  rt.draw_tile(150, 16, map, image, 0, 0, 12, 14)
+  rt.update
+  shader.update
+  Window.draw_shader(0, 0, rt, shader)
+  break if Input.key_push?(K_ESCAPE)
+end
+

data/sample/shader_sample/sample_rgsssprite.rb

@@ -0,0 +1,41 @@
+#!ruby -Ks
+require 'dxruby'
+require './shader/rgsssprite'
+
+Window.width = 800
+Window.height = 600
+
+s = RgssSprite.new
+s.image = Image.load('./bgimage/BG10a_80.jpg')
+
+Window.loop do
+
+  # Z�Ńt���b�V��������
+  s.flash if Input.key_push?(K_Z)
+
+  # X�������Ă���ԃO���C�X�P�[���ɂȂ�
+  if Input.key_down?(K_X)
+    s.gray = 255
+  else
+    s.gray = 0
+  end
+
+  # C�������Ă���ԁA�ԐF�������Ȃ�
+  if Input.key_down?(K_C)
+    s.tone = [-255,0,0]
+  else
+    s.tone = nil
+  end
+
+  # V�������Ă���ԁA�‚��u�����h����
+  if Input.key_down?(K_V)
+    s.color = [60,0,0,255]
+  else
+    s.color = nil
+  end
+
+  s.update
+  s.draw
+  break if Input.key_push?(K_ESCAPE)
+end
+

data/sample/shader_sample/sample_spehari.rb

@@ -0,0 +1,50 @@
+require 'dxruby'
+
+hlsl = <<EOS
+  texture tex0;
+
+  sampler Samp0 = sampler_state
+  {
+   Texture =<tex0>;
+   AddressU = WRAP;
+   AddressV = WRAP;
+  };
+
+  float4 PS(float2 input : TEXCOORD0) : COLOR0
+  {
+    return tex2D( Samp0, float2((input.x-0.5) / (input.y+0.20), (input.y-1) / (input.y+0.20)) );
+  }
+
+  technique SH
+  {
+   pass P0
+   {
+    PixelShader = compile ps_2_0 PS();
+   }
+  }
+EOS
+
+core = Shader::Core.new(hlsl,{})
+shader = Shader.new(core, "SH")
+
+image = Image.new(80, 80,[0, 255, 0])
+image.box_fill(0, 0, 39, 39, [150,250,150])
+image.box_fill(40, 0, 79, 39, [100,250,100])
+image.box_fill(0, 40, 39, 79, [200,250,200])
+image.box_fill(40, 40, 79, 79, [0,220,0])
+
+rt = RenderTarget.new(640,240)
+z = 0
+x = 0
+y = 0
+Window.loop do
+  z -= 10
+  x += Input.x * 5
+  y -= Input.y * 2
+  y = 0 if y < 0
+  y = 100 if y > 100
+
+  rt.draw_tile(0, 0, [[0]], [image], x, z, 8, 3).update
+  Window.draw_ex(0, 240, rt, :shader=>shader, :scaley=>y/200.0+0.5, :centery=>240.0)
+  break if Input.key_push?(K_ESCAPE)
+end

data/sample/shader_sample/sample_sphere.rb

@@ -0,0 +1,66 @@
+require 'dxruby'
+
+hlsl = <<EOS
+texture tex0;
+float2 raito;
+
+sampler Samp0 = sampler_state
+{
+ Texture =<tex0>;
+ AddressU = BORDER;
+ AddressV = BORDER;
+};
+
+float4 PS1(float2 input : TEXCOORD0) : COLOR0
+{
+  float pi = acos(-1);
+  return tex2D( Samp0, 
+                    float2( ((1 - (acos((input.x*2 - 1.0) ) / pi)) - 0.5) + 0.5
+                          , ((1 - (acos((input.y*2 - 1.0) ) / pi)) - 0.5) + 0.5) );
+//                          , input.y ));
+}
+
+float4 PS2(float2 input : TEXCOORD0) : COLOR0
+{
+  return tex2D( Samp0, 
+                  float2((input.x - 0.5) / cos(asin((input.y*2 - 1.0))) / raito.x + 0.5
+                       , (input.y - 0.5) / raito.y + 0.5) );
+}
+
+technique Sphere1
+{
+ pass P0
+ {
+  PixelShader = compile ps_2_0 PS1();
+ }
+}
+technique Sphere2
+{
+ pass P0
+ {
+  PixelShader = compile ps_2_0 PS2();
+ }
+}
+EOS
+
+Window.width, Window.height = 800, 600
+image = Image.load("bgimage/world_map2.png")
+image = image.slice(4, 5, image.width - 10, image.height - 9)
+
+core = DXRuby::Shader::Core.new(hlsl, {:raito=>:float})
+shader1 = Shader.new(core, "Sphere1")
+shader2 = Shader.new(core, "Sphere2")
+shader1.raito = shader2.raito = [600.quo(Window.width), 600.quo(Window.height)]
+
+rt1 = RenderTarget.new(image.width/2, image.height)
+rt2 = RenderTarget.new(Window.width, Window.height)
+x = 0
+
+Window.loop do
+  x -= 3
+  rt1.draw_tile(0, 0, [[0]], [image], x, 0, 2, 1).update
+  rt2.draw_ex(0, 0, rt1, :shader=>shader1, :centerx=>0, :centery=>0, :scalex=>Window.width.quo(rt1.width), :scaley=>Window.height.quo(rt1.height) ).update
+  Window.draw_ex(0, 0, rt2, :shader=>shader2,:angle=>23.4)
+  break if Input.key_push?(K_ESCAPE)
+end
+

data/sample/shader_sample/sample_transition.rb

@@ -0,0 +1,62 @@
+#!ruby -Ks
+require 'dxruby'
+require './shader/transition'
+
+Window.width = 800
+Window.height = 600
+
+shader = []
+# ���[���摜��640*480�A�w�i�摜��800*600�Ȃ̂Ń��[���摜���g�債�ăV�F�[�_�ɐݒ肷��
+# ����ȃ��\�b�h�`�F�C�����ł��Ă��܂��Ƃ����\
+# ���\�b�h�̖߂�l�͌��\���������Ȃ̂ŁA�ł��Ă����͂��Ȃ̂ɂł��Ȃ����\�b�h����������A����������
+shader << TransitionShader.new(100,
+                               RenderTarget.new(800,600).
+                                            draw_scale(0, 0, Image.load("./rule/�E�Q����.png"), 800/640.0, 600/480.0, 0, 0).
+                                            update.
+                                            to_image,
+                               20)
+
+# �������摜�����̂܂ܐH�킹��Ɖ�ʑS�̂ɌJ��Ԃ��Ďg��
+shader << TransitionShader.new(100,
+                               Image.load("./rule/�`�F�b�J�[.png"),
+                               20)
+shader << TransitionShader.new(100,
+                               Image.load("./rule/���u���C���h.png"),
+                               20)
+
+
+# �w�i�摜
+bg = [Image.load('./bgimage/BG10a_80.jpg'),
+      Image.load('./bgimage/BG13a_80.jpg'),
+      Image.load('./bgimage/BG00a1_80.jpg')
+     ]
+
+count = 100
+mode = 0
+image_new = bg[0]
+image_old = nil
+
+# �X�^�[�g����new�̂ݕ\��
+# Z����������new��old�ɂȂ��āAold����O�ɕ`�悳��A�g�����W�V�������������B
+# new��3���̉摜�����ԂɁB
+Window.loop do
+  if count < 100
+    count += 1
+    shader[mode].frame_count = count
+  end
+
+  if Input.key_down?(K_Z) && count == 100
+    count = 0
+    image_old = image_new
+    mode = mode == 2 ? 0 : mode + 1
+    image_new = bg[mode]
+    shader[mode].start
+  end
+
+  Window.draw(0,0,image_new)
+  Window.draw_shader(0,0,image_old, shader[mode]) if count < 100
+
+  break if Input.key_push?(K_ESCAPE)
+end
+
+

data/sample/shader_sample/sample_vertexshader.rb

@@ -0,0 +1,223 @@
+require 'dxruby'
+
+class Vector
+  def initialize(*v)
+    @vec = v
+  end
+
+  def rotate(angle)
+    x = @vec[0] * Math.cos(Math::PI / 180 * angle) - @vec[1] * Math.sin(Math::PI / 180 * angle)
+    y = @vec[0] * Math.sin(Math::PI / 180 * angle) + @vec[1] * Math.cos(Math::PI / 180 * angle)
+    temp = @vec.dup
+    temp[0] = x
+    temp[1] = y
+    Vector.new(*temp)
+  end
+
+  def +(v)
+    case v
+    when Vector
+      Vector.new(*@vec.map.with_index{|s,i|s+v[i]})
+    when Array
+      Vector.new(*@vec.map.with_index{|s,i|s+v[i]})
+    when Numeric
+      Vector.new(*@vec.map{|s|s+v})
+    else
+      nil
+    end
+  end
+
+  def *(matrix)
+    result = []
+    for i in 0..(matrix.size-1)
+      data = 0
+      for j in 0..(@vec.size-1)
+        data += @vec[j] * matrix[j][i]
+      end
+      result.push(data)
+    end
+    return Vector.new(*result)
+  end
+
+  def [](i)
+    @vec[i]
+  end
+
+  def size
+    @vec.size
+  end
+
+  def to_a
+    @vec
+  end
+
+  def x
+    @vec[0]
+  end
+  def y
+    @vec[1]
+  end
+  def z
+    @vec[2]
+  end
+  def w
+    @vec[3]
+  end
+end
+
+class Matrix
+  def initialize(*arr)
+    @arr = Array.new(4) {|i| Vector.new(*arr[i])}
+  end
+
+  def *(a)
+    result = []
+    for i in 0..(a.size-1)
+      result.push(@arr[i] * a)
+    end
+    return Matrix.new(*result)
+  end
+
+  def [](i)
+    @arr[i]
+  end
+
+  def size
+    @arr.size
+  end
+
+  def self.create_rotation_z(angle)
+    cos = Math.cos(Math::PI/180 * angle)
+    sin = Math.sin(Math::PI/180 * angle)
+    return Matrix.new(
+     [ cos, sin, 0, 0],
+     [-sin, cos, 0, 0],
+     [   0,   0, 1, 0],
+     [   0,   0, 0, 1]
+    )
+  end
+
+  def self.create_rotation_x(angle)
+    cos = Math.cos(Math::PI/180 * angle)
+    sin = Math.sin(Math::PI/180 * angle)
+    return Matrix.new(
+     [   1,   0,   0, 0],
+     [   0, cos, sin, 0],
+     [   0,-sin, cos, 0],
+     [   0,   0,   0, 1]
+    )
+  end
+
+  def self.create_rotation_y(angle)
+    cos = Math.cos(Math::PI/180 * angle)
+    sin = Math.sin(Math::PI/180 * angle)
+    return Matrix.new(
+     [ cos,   0,-sin, 0],
+     [   0,   1,   0, 0],
+     [ sin,   0, cos, 0],
+     [   0,   0,   0, 1]
+    )
+  end
+
+  def self.create_transration(x, y, z)
+    return Matrix.new(
+     [   1,   0,   0,   0],
+     [   0,   1,   0,   0],
+     [   0,   0,   1,   0],
+     [   x,   y,   z,   1]
+    )
+  end
+
+  def to_a
+    @arr.map {|v|v.to_a}.flatten
+  end
+end
+
+
+hlsl = <<EOS
+float4x4 g_world, g_view, g_proj;
+texture tex0;
+
+sampler Samp = sampler_state
+{
+ Texture =<tex0>;
+};
+
+struct VS_OUTPUT
+{
+  float4 pos : POSITION;
+  float2 tex : TEXCOORD0;
+};
+
+VS_OUTPUT VS(float4 pos: POSITION, float2 tex: TEXCOORD0)
+{
+  VS_OUTPUT output;
+
+  output.pos = mul(mul(mul(pos, g_world), g_view), g_proj);
+  output.tex = tex;
+
+  return output;
+}
+
+float4 PS(float2 input : TEXCOORD0) : COLOR0
+{
+  return tex2D( Samp, input );
+}
+
+technique
+{
+ pass
+ {
+  VertexShader = compile vs_2_0 VS();
+  PixelShader = compile ps_2_0 PS();
+ }
+}
+EOS
+
+core = Shader::Core.new(hlsl, {:g_world=>:float, :g_view=>:float, :g_proj=>:float})
+shader = Shader.new(core)
+
+shader.g_view = Matrix.new([1, 0, 0, 0],
+                           [0, -1, 0, 0],
+                           [0, 0, 1, 0],
+                           [-Window.width/2, Window.height/2, 0, 1]
+                          ).to_a
+
+zn = 700.0
+zf = 5000.0
+sw = 640.0
+sh = 480.0
+shader.g_proj = Matrix.new([2.0 * zn / sw,              0,                    0, 0],
+                           [             0, 2.0 * zn / sh,                    0, 0],
+                           [             0,             0,       zf / (zf - zn), 1],
+                           [             0,             0, -zn * zf / (zf - zn), 0]
+                          ).to_a
+
+
+image = [Image.load("bgimage/BG42a.jpg"), Image.load("bgimage/BG00a1_80.jpg"),
+         Image.load("bgimage/BG10a_80.jpg"), Image.load("bgimage/BG13a_80.jpg"),
+         Image.load("bgimage/BG32a.jpg")]
+
+a=0
+Window.loop do
+  a += 1
+  idx = 0
+  image.map{|img|
+  idx += 1
+    [img,
+    Matrix.create_transration(0,0,-1000) *
+    Matrix.create_rotation_y(a+idx*72) * 
+    Matrix.create_transration(0,0,1000) * 
+    Matrix.create_rotation_x(20) * 
+    Matrix.create_transration(300,300,1500)
+    ]
+  }.sort_by{|ary|
+    -(Vector.new(0,0,0,1) * ary[1]).z
+  }.each do |ary|
+    shader.g_world = ary[1].to_a
+    Window.draw_shader(-ary[0].width/2, -ary[0].height/2, ary[0], shader)
+  end
+  break if Input.key_push?(K_ESCAPE)
+end
+
+

data/sample/shader_sample/sample_wingman.rb

@@ -0,0 +1,47 @@
+require 'dxruby'
+require './shader/rgsssprite'
+
+Window.width = 800
+Window.height = 600
+
+class Wingman
+  @@image = Image.load('./bgimage/BG42a.jpg')
+  @@shader = SpriteShader.new
+  def initialize
+    @count = 0
+    @flag = false
+    @@shader.gray = 255
+  end
+  def start
+    @flag = true
+  end
+  def update
+    @count += 2 if @flag
+  end
+  def draw
+    if @count < 180
+      Window.draw_ex(0, 0, @@image, :alpha => 128, :blend => :add, :angle => @count)
+      Window.draw_ex(0, 0, @@image, :alpha => 128, :blend => :add, :angle => -@count)
+    elsif @count < 300
+      @@shader.gray = (@count - 180) * 255 / 120
+      Window.draw_ex(0, 0, @@image, :angle => 180, :shader => @@shader)
+    else
+      Window.draw_ex(0, 0, @@image, :angle => 180, :shader => @@shader)
+    end
+  end
+end
+
+w = Wingman.new
+
+Window.loop do
+  w.update
+  w.draw
+  w.start if Input.key_push?(K_SPACE)
+  break if Input.key_push?(K_ESCAPE)
+end
+
+
+
+
+
+