[Effect] : 2D Dynamic Lighting

Share your Construct 2 effect files

Post » Fri May 10, 2013 10:37 am

Thank you for this nice effect. Will it work with also animation sprites. If so how ? Do I also need to add mapping for each frames ? Did you ever try this
B
7
S
1
G
1
Posts: 76
Reputation: 904

Post » Fri May 10, 2013 10:45 am

@Spider_hip : yes, you need to add a mapping per frame.
B
33
S
9
G
6
Posts: 709
Reputation: 6,704

Post » Fri Sep 27, 2013 3:16 am

I need some help with this - I understand everything except how to cast shadows on the ground. Is there a certain color map value I need to use on the floor in order to cast shadows?
B
5
S
1
Posts: 11
Reputation: 397

Post » Wed Oct 23, 2013 6:58 pm

This is some great awesome effect. Even an excellent job with the shadow casting. I wonder though if this will be upgraded someday, like with several light sources?
Sebastian Dieguez
http://about.me/sebasoft
B
4
G
1
Posts: 9
Reputation: 503

Post » Mon Nov 11, 2013 5:55 pm

How do you make a map like that?
Thanks
B
3
Posts: 4
Reputation: 183

Post » Thu Nov 14, 2013 11:59 am

After this topic was created: http://www.scirra.com/forum/dynamic-lighting-program-for-2d_topic79467.html

I decided to research about old dynamic light systems, and remembering of RPG Maker and how smart the community was back then.

How hard will be to try and implement this script, made in Ruby? This specific one was one of the best scripts for dynamic light and shadows.

At least, we have Pode's plugin.

[code]=begin
==============================================================================
** Dynamic Light & Shadows
------------------------------------------------------------------------------
Trebor777
Version 1.5
16/11/2007
Version 1.5 is based on Rataime's shadows script,Rewrote the code structure
and Added extra features

==============================================================================
Instructions
==============================================================================
To create a source light:
Write a comment on 2 lines
Light
arg1|arg2|arg3|arg4|arg5

arg1, is the minimum angle.
arg2, is the maximum angle
arg3, the distance in pixel covered by the light
arg4, the height, in tiles where the light is.
arg5, the direction of the light, use the same numbers as RMXP is using:
up: 8, right: 6, down: 2, left: 4
It will turn the event automatically to this direction and
draw the light according to it, using its min and max angle.

The 0 is always on the left of the direction.
example,
the light "look at" the right, so its direction is 6.
the min angle is 0, so it'll start from the tile above to whatever
the max angle is, in a clockwise way.

So if you need to create a light, who covers only a cone of 60?, facing to the
right, at a height of 1 tile, covering a radius of 150pixels:
    Light
    60|120|150|1|6


I might do in the future, a simpler version for that.
_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-
To have an event with a shadow:
Write a comment on 2 lines
Shadow
arg1

arg1, is the maximum height of the object, so if you have a pillar on your map
covering several tiles in height, just create a shadow event at its base,
and give the height of that pillar as arg1.

For characters, just use a height of 0.

To turn off/on a light:
Use a script call:
a simple "self.off=true" (to turn off) or "self.off=false" to turn on is needed.
What is important is where you use this script call:

If the event switching the light is not the same as the source, you need use the
"call script" command inside the "set move route" command
(of course, don't forget to say on which event it applies)
instead of the default "call script" command found on page3.

==============================================================================
Configuration
==============================================================================
==============================================================================
You probably won't need to touch this : it's the 'map' of how to display the
shadow depending on the event's direction and his relative position to the
source. a minus means the shadow is mirrored. It seems complex, and it is.
Complain to Enterbrain (why didn't they use something clockwise or counter-
clockwise ? I suspect it's because of the rm2k legacy. More explanations
below.
=============================================================================
=end
SDK.log('DL&S', "trebor777", 1, "16.11.07")
if SDK.state('DL&S')

SHADOWS_DIRECTION_ARRAY = Array.new
SHADOWS_DIRECTION_ARRAY[2] = [ -3, 4, -2, 1 ]
SHADOWS_DIRECTION_ARRAY[4] = [ 4, -2, 1, -3 ]
SHADOWS_DIRECTION_ARRAY[6] = [ 1, -3, 4, -2 ]
SHADOWS_DIRECTION_ARRAY[8] = [ -2, 1, -3, 4 ]

#==============================================================================
# An important option : if you set it to true, the shadows will get longer if
# you are far from the source. Nice, but induces lag : it will eat your CPU,
# and quite possibly your first born if you try that on a big map.
#==============================================================================
SHADOW_GETS_LONGER = true

#==============================================================================
# Misc options
# If an event has its opacity below SHADOWS_OPACITY_THRESHOLD, no shadow will
# be displayed.
# Set SHADOWS_CATERPILLAR_COMPATIBLE to true if you uses the caterpillar script
#==============================================================================
SHADOWS_OPACITY_THRESHOLD = 254
SHADOWS_CATERPILLAR_COMPATIBLE = true

#==============================================================================
# Class Light
#==============================================================================
class Light
@@lights=[]
attr_reader :character, :parameters
#--------------------------------------------------------------------------
def initialize(viewport,character, param)
    @character = character
    @viewport = viewport
    unless param.nil?
      @parameters = param[0].split('|')
      @anglemin = @parameters.first.to_i
      @anglemax = @parameters[1].to_i
      @distancemax = @parameters[2].to_i
      @light_height = @parameters[3].to_i
      @base_face_at = @parameters.last.to_i
      @character.direction=@base_face_at
      test = @@lights.find_all{|l| l.character==@character and l.parameters==@parameters}
      if test.size==0
        draw_lights
        update
        @@lights.push(self)
      end
    end
end
#--------------------------------------------------------------------------
def Light.set
    return @@lights
end
#--------------------------------------------------------------------------
def Light.off_size
    result=0
    @@lights.each do |light|
      result+=1 if light.character.off
    end
    return result
end
#--------------------------------------------------------------------------
def dispose
    @s_light.dispose
    @@lights.delete(self)
end
#--------------------------------------------------------------------------
def update
    unless @s_light.nil?
      @s_light.visible=!@character.off
      @s_light.angle=0 if @character.direction==2
      @s_light.angle=-90 if @character.direction==4
      @s_light.angle=180 if @character.direction==8
      @s_light.angle=90 if @character.direction==6
      @s_light.x=@character.screen_x
      @s_light.y=@character.screen_y+32*@light_height
      @s_light.z=@character.screen_z
    end
end
#--------------------------------------------------------------------------
def draw_lights

    return if @@lights.include?(self) or (@@lights.find_all{|l| l.character==@character and l.parameters==@parameters}).size>0

    radius = @distancemax
    @s_light=Sprite.new(@viewport)
    @s_light.x=@character.screen_x
    @s_light.y=@character.screen_y+32*@light_height
    @s_light.z=@character.screen_z
    @s_light.bitmap=Bitmap.new(radius*2,radius*2)
    @s_light.opacity=90
    @s_light.ox+=radius
    @s_light.oy+=radius
    @s_light.angle=0 if @base_face_at==2
    @s_light.angle=270 if @base_face_at==4
    @s_light.angle=180 if @base_face_at==8
    @s_light.angle=90 if @base_face_at==6
    @s_light.bitmap.draw_pie(radius,radius,radius,Color.new(255,255,100,90),@anglemi
n, @anglemax)
end
end
#==============================================================================
# Class shadow
#==============================================================================
class Shadow
attr_accessor :character
attr_reader :distance, :distancemax, :overlayed
@@shadows=[]
#--------------------------------------------------------------------------
def initialize(viewport,character, param,light)
    @character = character
    @viewport = viewport
    unless param.nil?
      @parameters = param[0].split('|')
      @shadow_max_height = @parameters[1].to_i
      @anglemin=light.parameters[0].to_f
      @anglemax=light.parameters[1].to_f
      @distancemax=light.parameters[2].to_f
      @light_height= light.parameters[3].to_i
      @source = light
      @s_shadow = RPG::Sprite.new(@viewport)
      @s_shadow.color = Color.new(0, 0, 0)
      update
    end
    @@shadows.push(self)
end
#--------------------------------------------------------------------------
def Shadow.set
    return @@shadows
end
#--------------------------------------------------------------------------
def sprite
    return @s_shadow
end
#--------------------------------------------------------------------------
def dispose
    @s_shadow.dispose
    @@shadows.delete(self)
end
#--------------------------------------------------------------------------
def in_light_range?
    return (@distance<=@distancemax)
end
#--------------------------------------------------------------------------
def overlayed?
    @overlayed = false
    @@shadows.each do |i|
      s = i.sprite
      next if s.nil? or i == self or @character.tile_id!=0 or s.disposed?
      if (@s_shadow.z)>s.z and @s_shadow.angle.between?(s.angle-1.5,s.angle+1.5)\
       and ((@character.x-i.character.**2 + (@character.y-i.character.y)**2)**0.5<=s.zoom_y \
       and s.z>=0
        @s_shadow.visible=false
        @overlayed = true
      end
      return if !@s_shadow.visible
    end

    return @overlayed
end
#--------------------------------------------------------------------------
def update
    # set shadow visibility according to the light state
    @s_shadow.visible = !@source.character.off
    if @character.transparent or @character.opacity <= SHADOWS_OPACITY_THRESHOLD
      @s_shadow.visible = false
      return
    end
    if @old_amin.nil? and @old_amax.nil? and @old_dir.nil?
      @old_amin= @anglemin
      @old_amax= @anglemax
      @old_dir = @source.character.direction
    end
    # adapt the angle according to the source direction
    case @source.character.direction
      when 2
        @anglemin= @old_amin+180
        @anglemax= @old_amax+180
      when 4
        @anglemin= @old_amin+90
        @anglemax= @old_amax+90
      when 8
        @anglemin= @old_amin
        @anglemax= @old_amax
      when 6
        @anglemin= @old_amin+270
        @anglemax= @old_amax+270
      end
    if @old_dir!=@source.character.direction
      @old_dir = @source.character.direction
    end
    # simplify the angles if more than 360 or less than 0
    @anglemin%=360;@anglemax%=360

    tile_height= @shadow_max_height
    @deltax=(@source.character.real_x-@character.real_X)/4
    @deltay= ((@source.character.real_y+@light_height*128)-(@character.real_y+tile_height*128))/4
    @distance = (((@deltax ** 2) + (@deltay ** 2))** 0.5)
    if @distancemax !=0 and @distance>@distancemax
      @s_shadow.visible = false
      return
    end

    @s_shadow.angle = 57.3*Math.atan2(@deltax, @deltay )
    @angle_trigo= (@s_shadow.angle+90) % 360

    #test if there is a shadow above it, from something close,and then
    # don't display its shadow
    return if overlayed?

    if @anglemin !=0 or @anglemax !=0
      if (@angle_trigo<@anglemin or @angle_trigo>@anglemax) and \
          @anglemin<@anglemax
        @s_shadow.visible = false
        return
      elsif (@angle_trigo<@anglemin and @angle_trigo>@anglemax) and \
             @anglemin>@anglemax
        @s_shadow.visible = false
        return
      end    
    end
    @s_shadow.update
    if @tile_id != @character.tile_id or
       @character_name != @character.character_name or
       @character_hue != @character.character_hue
       @tile_id = @character.tile_id
      @character_name = @character.character_name
      @character_hue = @character.character_hue
      if @tile_id >= 384
        @s_shadow.bitmap = RPG::Cache.tile($game_map.tileset_name,
        @tile_id, @character.character_hue)
        @s_shadow.src_rect.set(0, 0, 32, 32)
        @s_shadow.ox = 16
        @s_shadow.oy = 32
      else
        @s_shadow.bitmap = RPG::Cache.character(@character.character_name,
          @character.character_hue)
        @cw = @s_shadow.bitmap.width / 4
        @ch = @s_shadow.bitmap.height / 4
        @s_shadow.ox = @cw / 2
        @s_shadow.oy = @ch
      end
    end
    @s_shadow.x = @character.screen_x
    @s_shadow.y = @character.screen_y-8
    @s_shadow.z = @character.screen_z(@ch)-1

    if @tile_id!=0 # if the sprite graphic is from the tileset
      # set the Z-Index using the tileset priority settings
      @s_shadow.z = ($game_map.priorities[@tile_id])*32
      # convert the shadow angle, into 8-directions (0-7)
      direction_shadow=((@s_shadow.angle/45+45/2.0+90).round)%8
      # for the middle-Top and top layers,
      for i in [1, 2]
        # get the tile from the converted angle
        tile_around=[$game_map.data[@character.x,@character.y-1,i],
        $game_map.data[@character.x-1,@character.y-1,i],
        $game_map.data[@character.x-1,@character.y,i],
        $game_map.data[@character.x-1,@character.y+1,i],
        $game_map.data[@character.x,@character.y+1,i],
        $game_map.data[@character.x+1,@character.y+1,i],
        $game_map.data[@character.x+1,@character.y,i],
        $game_map.data[@character.x+1,@character.y-1,i]]
        # if the tile is the empty one go to the next layer
        next if tile_around[direction_shadow]==0
        # else, lower the Z-index if the tile around is "above" or at the same
        # priority of our tile
        @s_shadow.z-=32 if $game_map.priorities[tile_around[direction_shadow]]>=$game_map.priorities[@tile_id]
      end
    end
    if @tile_id == 0
      sx = @character.pattern * @cw
      quarter = ((@angle_trigo/90+0.5).floor)%4

      # The quarter is the position of the event relative to the source.
      # Imagine the source is the o point (0,0). Trace the 2 lines
      # y=x and y=-x : you get something like a big X
      # On the right, quarter=0. Up, quarter = 1, and so on
      # Take the @character.direction row (2,4,6,8), and the quarter
      # column (0,1,2,3) (remember, it starts at 0), and you'll get
      # a number between 1 and 4. It correspond to the row of the charset
      # the shadow will be, and mirrored if negative.
      # Yes, it isn't obvious, but I didn't find any simple operation to
      # get those.
      magic = SHADOWS_DIRECTION_ARRAY[@character.direction][quarter]
      magic = -magic
      if magic < 0
        @s_shadow.mirror = true
        magic = -magic
      else
        @s_shadow.mirror = false
      end
      sy = (magic-1)*@ch
      @s_shadow.src_rect.set(sx, sy, @cw, @ch)
    end
    # This is the formula of the opacity in function of the distance
    # ** 2 means square
    @s_shadow.opacity = 1200/((@distance ** 2)/ 1000 + 6)
    # This is the formula of the size in function of the distance
    # The 0.75 is here so you have a size of 1:1 when next to the source.
    @s_shadow.zoom_y=0.75*(@shadow_max_height+1) + (@distance) / 256 if SHADOW_GETS_LONGER
end
end
#==============================================================================
# ** Zlib    
#==============================================================================

module Zlib
#============================================================================
# ** Png_File    
#============================================================================

class Png_File < GzipWriter
    #--------------------------------------------------------------------------
    # * Make PNG
    #--------------------------------------------------------------------------
    def make_png(bitmap, mode = 0)
      # Save Bitmap & Mode
      @bitmap, @mode = bitmap, mode
      # Create & Save PNG
      self.write(make_header)
      self.write(make_ihdr)
      self.write(make_idat)
      self.write(make_iend)
    end
    #--------------------------------------------------------------------------
    # * Make Header
    #--------------------------------------------------------------------------
    def make_header
      return [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a].pack('C*')
    end
    #--------------------------------------------------------------------------
    # * Make IHDR
    #--------------------------------------------------------------------------
    def make_ihdr
      ih_size               = [13].pack("N")
      ih_sign               = 'IHDR'
      ih_width              = [@bitmap.width].pack('N')
      ih_height             = [@bitmap.height].pack('N')
      ih_bit_depth          = [8].pack('C')
      ih_color_type        = [6].pack('C')
      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
    #--------------------------------------------------------------------------
    # * Make IDAT
    #--------------------------------------------------------------------------
    def make_idat
      header = "\\x49\\x44\\x41\\x54"
      data    = @mode == 0 ? make_bitmap_data0 : make_bitmap_data1
      data    = Zlib::Deflate.deflate(data, 8)
      crc     = [Zlib.crc32(header + data)].pack('N')
      size    = [data.length].pack('N')
      return size + header + data + crc
    end
    #--------------------------------------------------------------------------
    # * Make Bitmap Data 0
    #--------------------------------------------------------------------------
    def make_bitmap_data0
      gz = Zlib::GzipWriter.open('hoge.gz')
      t_Fx = 0
      w = @bitmap.width
      h = @bitmap.height
      data = []
      for y in 0...h
        data.push(0)
        for x in 0...w
          t_Fx += 1
          if t_Fx % 10000 == 0
            Graphics.update
          end
          if t_Fx % 100000 == 0
            s = data.pack("C*")
            gz.write(s)
            data.clear
          end
          color = @bitmap.get_pixel(x, y)
          red = color.red
          green = color.green
          blue = color.blue
          alpha = color.alpha
          data.push(red)
          data.push(green)
          data.push(blue)
          data.push(alpha)
        end
      end
      s = data.pack("C*")
      gz.write(s)
      gz.close
      data.clear
      gz = Zlib::GzipReader.open('hoge.gz')
      data = gz.read
      gz.close
      File.delete('hoge.gz')
      return data
    end
    #--------------------------------------------------------------------------
    # * Make Bitmap Data Mode 1
    #--------------------------------------------------------------------------
    def make_bitmap_data1
      w = @bitmap.width
      h = @bitmap.height
      data = []
      for y in 0...h
        data.push(0)
        for x in 0...w
          color = @bitmap.get_pixel(x, y)
          red = color.red
          green = color.green
          blue = color.blue
          alpha = color.alpha
          data.push(red)
          data.push(green)
          data.push(blue)
          data.push(alpha)
        end
      end
      return data.pack("C*")
    end
    #--------------------------------------------------------------------------
    # * Make IEND
    #--------------------------------------------------------------------------
    def make_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
end
#==============================================================================
# Class Game Event
#==============================================================================
class Game_Event
alias treb_mobile_source_game_event_initialize initialize
attr_accessor :off, :direction
def initialize(*args)
    # create the off attribute, only used for the lights
    @off = false
    treb_mobile_source_game_event_initialize(*args)
end
end
#==============================================================================
# class Spriteset Map
#==============================================================================
class Spriteset_Map
alias trebor777_DLS_spriteset_map_init_characters init_characters
alias trebor777_DLS_spriteset_map_update_character_sprites update_character_sprites
alias trebor777_DLS_spriteset_map_dispose dispose
#--------------------------------------------------------------------------
def init_characters
    trebor777_DLS_spriteset_map_init_characters
    # create the lights and shadows arrays
    @lights = []
    @shadows = []
    @viewport1.visible=false
    @viewport2.visible=false
    @viewport3.visible=false
    for i in $game_map.events.keys.sort
      # Search for light trigger
      light_param = SDK.event_comment_input($game_map.events, 1, "Light")
      # if not found go to the next iteration
      next if light_param.nil?
      # else add it to the Lights Hash, and create a new light
      @lights.push( Light.new(@viewport1,$game_map.events,light_param) )
      # create the shadow for the player.
      @shadows.push( Shadow.new(@viewport1,$game_player, ['0'], @lights.last) )
    end
    for i in $game_map.events.keys.sort
      for light in @lights
        # Search for shadow trigger
        shadow_param = SDK.event_comment_input($game_map.events, 1, "Shadow")
        next if shadow_param.nil?
        @shadows.push( Shadow.new(@viewport1,$game_map.events, shadow_param, light) )
      end
    end
    @viewport1.visible=true
    @viewport2.visible=true
    @viewport3.visible=true
end
#--------------------------------------------------------------------------
def update_character_sprites
    trebor777_DLS_spriteset_map_update_character_sprites
    lights_off = 0
    # Update the lights
    for light in @lights
      light.update
      # count the number of lights off
      lights_off+=1 if light.character.off
    end
    # Update the Shadows
    for shade in @shadows
      shade.update
    end
    if @lights.size>0
      # updating screen tinting according to the number of lights on
      value=((lights_off.to_f/@lights.size)*(-180)).round
      $game_screen.start_tone_change(Tone.new(value,value,value,value), 1)
    else
      $game_screen.start_tone_change(Tone.new(0,0,0,0), 1)
    end
end
#--------------------------------------------------------------------------
def dispose
    for light in @lights
      light.dispose
    end
    # Update the Shadows
    for shade in @shadows
      shade.dispose
    end
    @lights = []
    @shadows = []
end
end
#==============================================================================
# Class Bitmap
#==============================================================================
class Bitmap
#--------------------------------------------------------------------------
def draw_line(x1, y1, x2, y2, width = 1, color = Color.new(255, 255, 255))
    # Return if width is less than or 0
    return if width <= 0
    # Reverse all parameters sent if 2 x is less than the first x
    x1, x2, y1, y2 = x2, x1, y2, y1 if x2 < x1    
    # Get S (1/2 width)
    s = width / 2.0
    # If X Coordinates are equal
    if x1 == x2
      # Draw Vertical line
      fill_rect(x1 - s, [y1, y2].min, width, (y2 - y1).abs, color)
    # If Y Coordinates are equal
    elsif y1 == y2
      # Draw Horizontal line
      fill_rect(x1, y1 - s, x2 - x1, width, color)
    end
    # Get Length
    length = x2 - x1 < (y2 - y1).abs ? (y2 - y1).abs : x2 - x1
    # Get Increments
    x_increment, y_increment = (x2 - x1) / length.to_f, (y2 - y1) / length.to_f
    # Get Current X and Y
    x, y = x1, y1
    # While Current X is less than end X
    while x < x2
      # Draw Box of width width and width height
      fill_rect(x-s, y-s, width, width, color)
      # Increment X and Y
      x += x_increment
      y += y_increment
    end
end
#--------------------------------------------------------------------------
# Draw pie, take quite a long time as it draws each line.
#--------------------------------------------------------------------------
def draw_pie(x,y,radius,color = Color.new(255, 255, 255, 255),start_angle=0,end_angle=360)
    end_angle+=360 if end_angle
    name_string="#{radius}_#{start_angle}_#{end_angle}"
    #filename="Graphics/Pictures/#{name_string}.png"
    if FileTest.exist?("Graphics/Pictures/#{name_string}.png")
      temp = RPG::Cache.picture(name_string)
      blt(0,0,temp,temp.rect)
    else
      Graphics.transition
      t = Progress_Bar.new(160,240,320,20,end_angle-start_angle+2 )
      for i in start_angle...end_angle
        t.current_step+=1
        t.update
        Graphics.update
        for j in 0..2
          x_=(Math::cos((i+j/2.0)*Math::PI/180)*radius).round+x
          y_=(Math::sin((i+j/2.0)*Math::PI/180)*radius).round+y
          draw_line(x, y, x_, y_, 2,color)
        end
      end
      t.current_step+=1
      t.update
      Graphics.update
      make_png(name_string, 'Graphics/Pictures/')
      t.current_step+=1
      t.update
      Graphics.update
      t.dispose
    end
end
def make_png(name = 'like', path = '', mode = 0)
    Dir.make_dir(path) if path != '' and !FileTest.directory?(path)
    Zlib::Png_File.open('temp.gz')   { |gz| gz.make_png(self, mode) }
    Zlib::GzipReader.open('temp.gz') { |gz| $read = gz.read }
    f = File.open(path + name + '.png', 'wb')
    f.write($read)
    f.close
    File.delete('temp.gz')
end
end

class Progress_Bar < Sprite
#--------------------------------------------------------------------------
# * Public Instance Variables
#--------------------------------------------------------------------------
attr_accessor :current_step   # The Current Step
attr_accessor :steps          # The max amount of steps
#----------------------------------------------------------------------------
# * Initialize Object
#----------------------------------------------------------------------------
def initialize(x,y,width,height=16,steps=100,start=0)
    super()
    @steps = steps
    self.x = x
    self.y = y
    @current_step= start
    @width = width
    @height = height
    @w = 9
    @nb_bars = @width/@w
    @c1 = Color.new(46,211,49,255)
    @c2 = Color.new(46,211,49,227)
    @c3 = Color.new(46,211,49,202)
    @c4 = Color.new(46,211,49,177)
    @c5 = Color.new(46,211,49,152)
    @c6 = Color.new(46,211,49,127)
    @stretch_c = (@height-4)/16.0
    self.bitmap = Bitmap.new(@width, @height)
    self.bitmap.clear
    self.bitmap.fill_rect(0, 0, @width, @height, Color.new(59,59,59,167))
    draw
end
#----------------------------------------------------------------------------
# * Draw Bar
#----------------------------------------------------------------------------
def draw
    self.bitmap.fill_rect(1, 1, @width-2, @height-2, Color.new(59,59,59,0))
    for i in 0...((@current_step/@steps.to_f)*@nb_bars).round
      self.bitmap.fill_rect(i*@w+1,2,@w-2,@height-4,@c6)
      self.bitmap.fill_rect(i*@w+1,3*@stretch_c,@w-2,@height-6*@stretch_c,@c5)
      self.bitmap.fill_rect(i*@w+1,4*@stretch_c,@w-2,@height-8*@stretch_c,@c4)
      self.bitmap.fill_rect(i*@w+1,5*@stretch_c,@w-2,@height-10*@stretch_c,@c3)
      self.bitmap.fill_rect(i*@w+1,6*@stretch_c,@w-2,@height-12*@stretch_c,@c2)
      self.bitmap.fill_rect(i*@w+1,7*@stretch_c,@w-2,@height-14*@stretch_c,@c1)
    end
    @old = @current_step
end
#----------------------------------------------------------------------------
# * Update
#----------------------------------------------------------------------------
def update
    draw if @current_step != @old
end
end
#SDK test
end[/code]TELLES08082013-11-14 11:59:42
ImageImageImageImageImageImage
B
93
S
20
G
13
Posts: 1,217
Reputation: 18,996

Post » Thu Nov 14, 2013 5:45 pm

I've been working with another shader script I came across. As a noob, I know pretty much nothing about shaders but I wanted to make it work in Construct so I made this.

In the rar is the capx and the effect files, I can't upload to dropbox cause I'm at work and someone was really stupid blocking dropbox... Click on the blue square and drag it around so the blue light can move. I was about to put one more light in there but first I wanted to ask you guys about some ideas I've got.



Hope someone can help me with some ideas I've got. I can hardcode more lights, or even pass the number of lights I want to, that's easy.

After working with this I have many doubts
1.- How can I apply the same light to a different texture, let's say I've got a character Sprite in the center of the rock image in the CAPX. Do I have to put the same effect on it? Is there a way that different textures with their own normal maps share the same light?
2.- Is it possible to create some kind of light objetc plugin from this?

Excuse me if I'm being stupid here, as I said, I don't know much about how all this work. Create a "light casting" object, look for how many normal maps are in the same layer or a map with a "is_normal" value and then process them with the same light?

After all, I believe this is the same thing I asked first, is it possible to use the same light or light effect for two different textures/normal maps?

Fixed the link to my project. You can see the demo here. Used @R0J0hound images now just to see the difference between his and mine.
Here's the demo: Demo
Grab the blue square and drag it around to see the effect.
Here's the capx and my effect files, hope someone can give them a look.
CAPX and Effect files

Ambient and light colors are hardcoded for now in the fx file. donelwero2013-11-14 23:35:09
B
20
S
5
G
3
Posts: 53
Reputation: 3,310

Post » Thu Nov 14, 2013 7:48 pm

Sprite Lamp

Maybe someone has seen that before? If not, enjoy and drool.

EDIT:

Just read the dev's update from yesterday since he passed the funding in like a day:
[QUOTE]Engine Integration: I've received lots of requests about this. Given that 'engine integration' in this context really just means 'getting a particular shader working' in most cases, this is very achievable - however, not all engines work the same way, and in some cases it might not be possible. So far, requests have been mostly along the lines of Starling, Construct 2, and Game Maker, and as far as I can tell, all these are possible.[/QUOTE]Pancholo2013-11-14 19:55:21
B
13
S
5
G
1
Posts: 34
Reputation: 2,022

Post » Thu Nov 14, 2013 11:27 pm

[QUOTE=Pancholo] Sprite Lamp

Maybe someone has seen that before? If not, enjoy and drool.

EDIT:

Just read the dev's update from yesterday since he passed the funding in like a day:
[QUOTE]Engine Integration: I've received lots of requests about this. Given that 'engine integration' in this context really just means 'getting a particular shader working' in most cases, this is very achievable - however, not all engines work the same way, and in some cases it might not be possible. So far, requests have been mostly along the lines of Starling, Construct 2, and Game Maker, and as far as I can tell, all these are possible.[/QUOTE][/QUOTE]

Sprite Lamp does look awesome.

Fixed the link to my project. You can see the demo here. Used @R0J0hound images now just to see the difference between his and mine.
Here's the demo: Demo
Grab the blue square and drag it around to see the effect.
Here's the capx and my effect files, hope someone can give them a look.
CAPX and Effect files

Ambient and light colors are hardcoded for now in the fx file.
donelwero2013-11-14 23:34:55
B
20
S
5
G
3
Posts: 53
Reputation: 3,310

Post » Thu Nov 14, 2013 11:48 pm

Good god, so much drool ;o
B
38
S
8
G
3
Posts: 438
Reputation: 6,869

PreviousNext

Return to Effects

Who is online

Users browsing this forum: No registered users and 1 guest