Additional Bitmap Methods

**Location:** Denver, CO

Additonal Bitmap Methodsv0.9
By: Untra and Glitchfinder

Introduction

This is a set of additional methods that can be applied to desired bitmaps by scripters to make interesting things happen to them. Most of them are irreversible, but I intend to change this in the future so that the effects are not only reversible, but also so that they can be applied to the course of entire viewports, or the whole screen so as to make unique transitions or screen effects (as well as make battle animations more interesting). The script comes coupled with a .dll file that makes the affect instantaneous, minimizing stress on the game process.

Current Features
I swear to god I'll remake this mountain of spoiler tags. Argh!

Brighten

Darken

Invert

Grayscale

Pixelate (in v0.5 only)

Frost (in v0.5 only

Hyper Contrast

Monochrome

Emboss (still buggy)

Sepia

Sharpen

Soften

Crosseye (coming soon)

Script
There are two versions currently out; v0.9 and v0.5. Version 0.5 has the frost and pixelate methods, while version 0.85 works with a .dll that makes the methods work instantaneously, and comes with many more additional methods. The v1.0 release should have a functional Frost working.

v0.5

Line number On/Off | Expand/Contract | Select all

#==============================================================================
# ** Additional Bitmap Methods
#------------------------------------------------------------------------------
#   By Untra
#   5/5/10
#   v0.5
#==============================================================================
class Bitmap
  #--------------------------------------------------------------------------
  # * Brighten
  #--------------------------------------------------------------------------
   def brighten(amount)
      for w in 0..(width - 1)
         for h in 0..(height - 1)
            color = get_pixel(w, h)
            set_pixel(w, h, Color.new([color.red + amount, 255].min, [color.green + amount, 255].min, [color.blue + amount, 255].min, color.alpha)) if color.alpha > 0
         end
      end
      return self
   end
  #--------------------------------------------------------------------------
  # * Darken
  #--------------------------------------------------------------------------
   def darken(amount)
      for w in 0...width
         for h in 0...height
            color = get_pixel(w, h)
            set_pixel(w, h, Color.new([color.red - amount, 0].max, [color.green - amount, 0].max, [color.blue - amount, 0].max, color.alpha)) if color.alpha > 0
         end
      end
      return self
    end
  #--------------------------------------------------------------------------
  # * Invert
  #   WARNING: Inverting colors is especially process consuming, and with
  #     frequent use can lag a game indefinitely. Use sparringly.  
  #   NOTE: calling an invert color method a second time will bring its colors
  #     back to normal, assuming you didn't change its colors while in negative.
  #--------------------------------------------------------------------------
   def invert
      for w in 0..(width - 1)
         for h in 0..(height - 1)
            color = get_pixel(w, h)
            set_pixel(w, h, Color.new(255 - color.red, 255 - color.green, 255 - color.blue, color.alpha)) if color.alpha > 0
         end
      end
      return self
   end
  #--------------------------------------------------------------------------
  # * Grayscale
  #   WARNING: Putting a bitmap into grayscale is process consuming, and cannot
  #     be undone without recalling the bitmap. Use caution.
  #   NOTE: calling this method repeatedly has no effect on the bitmap, but will 
  #     still waste processing power. Do not call it repeatedly.
  #--------------------------------------------------------------------------
   def grayscale
      for w in 0...width
         for h in 0...height
            color = get_pixel(w, h)
            a = color.alpha
            if a > 0
               num = (color.red + color.green + color.blue) / 3
               set_pixel(w, h, Color.new(num, num, num, a))
            end
         end
      end
      return self
   end
  #--------------------------------------------------------------------------
  # * Pixelate  {buggy}
  #   WARNING: Pixelating a bitmap is process consuming, and cannot be undone.
  #   NOTE: Funky things happen if you pixelate a bitmap to single pixels (which
  #     is the original bitmap). Its incredibly process consuming, so the method
  #     will return nil if you so attempt it.
  #   NOTE: Pixelateing bitmaps to a larger pixel size is less process consuming.
  #     for best results, don't pixelate to numbers below four.
  #   NOTE: This works much better for solid images, due to bugs. 
  #--------------------------------------------------------------------------
   def pixelate(size)
     if size <= 1
       return nil
     else
       for w in 0..((width - 1) / size)
         w *= size
         for h in 0..((height - 1) / size)
            h *= size
            r, g, b, a = 0, 0, 0, 0
            size.times do |i|
               color = get_pixel(w, h)
               r += color.red ; g += color.green ; b += color.blue ; a += color.alpha
               color = get_pixel(w + i, h)
               r += color.red ; g += color.green ; b += color.blue ; a += color.alpha
               color = get_pixel(w, h + i)
               r += color.red ; g += color.green ; b += color.blue ; a += color.alpha
            end 
            fill_rect(w, h, size, size, Color.new( (r / size**2) * Math.sqrt(size), (g / size**2) * Math.sqrt(size), (b / size**2) * Math.sqrt(size), (a / size**2) * Math.sqrt(size)))
          end
        end
     end
   end
  #--------------------------------------------------------------------------
  # * Frost
  #   WARNING: Frosting a bitmap is process consuming, and cannot be undone.
  #   NOTE: Frosting a bitmap randomly scatters its pixels. As such, Consistant 
  #     results are impossible to get.
  #   NOTE: Frosting a bitmap beyond eight won't result in a more scattered image.
  #--------------------------------------------------------------------------
   def frost(passes)
      for pass in 1..passes
         for w in 0...width
            for h in 0...height
               set_pixel(w, h, get_pixel(w + rand(3) - 1, h + rand(3) - 1))
            end
         end
      end
      return self
   end
end

Expand to see the code.

v0.9

Version v0.9
http://www.box.net/shared/9m54d8hkzu

Line number On/Off | Expand/Contract | Select all

#==============================================================================
# ** Additional Bitmap Methods
#------------------------------------------------------------------------------
#   By Untra and Glitchfinder
#   6/3/10
#   v0.9
#==============================================================================
class Bitmap
#------------------------------------------------------------------------------
#Make sure you have uabm.dll in your project folder.
#You can get it from (assuming link is not dead):
#http://www.box.net/shared/9m54d8hkzu
#------------------------------------------------------------------------------
  Brighten = Win32API.new("uabm.dll", "Brighten", "li", "v")
  Darken = Win32API.new("uabm.dll", "Darken", "li", "v")
  Invert = Win32API.new("uabm.dll", "Invert", "l", "v")
  Grayscale = Win32API.new("uabm.dll", "Grayscale", "l", "v")
  Hcontrast = Win32API.new("uabm.dll", "Hcontrast", "l", "v")
  Monochrome = Win32API.new("uabm.dll", "Monochrome", "l", "v")
  Emboss = Win32API.new("uabm.dll", "Emboss", "l", "v")
  Sepia = Win32API.new("uabm.dll", "Sepia", "l", "v")
  Sharpen = Win32API.new("uabm.dll", "Sharpen", "l", "v")
  Soften = Win32API.new("uabm.dll", "Soften", "l", "v")
  #--------------------------------------------------------------------------
  # * Brighten (0...255)
  #--------------------------------------------------------------------------
  def brighten(amount)
    Brighten.call(self.__id__, amount)
  end
  #--------------------------------------------------------------------------
  # * Darken (0...255)
  #--------------------------------------------------------------------------
  def darken(amount)
    Darken.call(self.__id__, amount)
  end
  #--------------------------------------------------------------------------
  # * Invert
  #--------------------------------------------------------------------------
  def invert
    Invert.call(self.__id__)
  end
  #--------------------------------------------------------------------------
  # * Grayscale
  #--------------------------------------------------------------------------
  def grayscale
    Grayscale.call(self.__id__)
  end
  #--------------------------------------------------------------------------
  # * Hyper Contrast
  #--------------------------------------------------------------------------
  def hyper_contrast
    Hcontrast.call(self.__id__)
  end
  #--------------------------------------------------------------------------
  # * Monochrome
  #--------------------------------------------------------------------------
  def monochrome
    Monochrome.call(self.__id__)
  end
  #--------------------------------------------------------------------------
  # * Emboss {buggy}
  #--------------------------------------------------------------------------
  def emboss
    Emboss.call(self.__id__)
  end
  #--------------------------------------------------------------------------
  # * Sepia
  #--------------------------------------------------------------------------
  def sepia
    Sepia.call(self.__id__)
  end
  #--------------------------------------------------------------------------
  # * Sharpen {will update with numeric value options}
  #--------------------------------------------------------------------------
  def sharpen
    Sharpen.call(self.__id__)
  end
  #--------------------------------------------------------------------------
  # * Soften {will update with numeric value options}
  #--------------------------------------------------------------------------
  def soften
    Soften.call(self.__id__)
  end
end

Expand to see the code.

Instructions

Stick right above main, like you know you should.
This script is mostly for more advanced scripters that want to do more complex things with graphics. Its still a tad buggy, and more features will come (if sporadicly.)

FAQ

maybe later.

Compatibility

Not that I know of.

Credits and Thanks
To Glitchfinder, who deserves just as much credit for this as I do.
To the makers of the MACL; that script inspired me to write this
And to Paint.Net, which helped me figure out how to make the Frost and Pixelate methods.

Authors Note
Feel free to ask for some new features. If they're not too complex, I might (try to) add them in.

Terms and Conditions
Licensed under the WTFPL public licence. Click here for more information.

**Location:** Approximately 93 million miles from Sol.

My first impression of this script is favorable, since it is well formatted and properly commented. Regarding your comments about speed, you might find that, for the most part, it will be slow on any computer. This is because RMXP uses a very poorly designed series of methods to edit and display graphics, and it does not significantly improve on faster computers.

As to reversing the effects, it can't really be done. The closest you can do for some of these methods is cloning the bitmap and saving it to use later. On others, like the brighten, it is possible to undo, but to a point. For example, it won't be able to undo the changes made to a bitmap when the colors hit their maximum or minimum values before the process is finished. The grayscale is also impossible to undo without cloning the image first, since you are effectively removing the color information and modifying the remnants.

**Location:** Denver, CO

Glitchfinder wrote:

My first impression of this script is favorable, since it is well formatted and properly commented. Regarding your comments about speed, you might find that, for the most part, it will be slow on any computer. This is because RMXP uses a very poorly designed series of methods to edit and display graphics, and it does not significantly improve on faster computers.

Heh, I kinda imagined that might be the case. I'm banking on a future release of the ARGSS being able to tackle the issue, so more complex methods can be added on a broader scale. My goal: Touch fuzzy get dizzy effects.

Quote:

As to reversing the effects, it can't really be done. The closest you can do for some of these methods is cloning the bitmap and saving it to use later. On others, like the brighten, it is possible to undo, but to a point. For example, it won't be able to undo the changes made to a bitmap when the colors hit their maximum or minimum values before the process is finished. The grayscale is also impossible to undo without cloning the image first, since you are effectively removing the color information and modifying the remnants.

I'm thinking of possibly making a method to refresh any bitmap that was changed by certain effects by recalling it, or by adding additional properties to it by using alias to change the RPG::Cache module. I'm not sure what the next step to take is regarding this. (This is especially frustrating if you want to pixelate a bitmap from a higher value to single pixels, to create the look that the screen is transitioning, as it requires the original bitmap to be recalled and redrawn every iteration.)

egh...

**Location:** Germany

You almost entirely qualify for The Third Man's Golden Left-Sided Shoe Of Great Scripting, however, you sadly used the very weird indentation of 3 spaces. We're sorry to announce to you that you're a failure.
(seriously now, I can only second what Glitch said: Well coded, well documented - you just made me happy! :grin:

)

As far as the performance issues go, the bottleneck very rarely is the hardware. I don't know about you, but I'm running a 2.4GHz core2quad, 3GB RAM machine that was not too bad a year ago; nevertheless, I get performance issues with RPG Maker games (more precisely, RGSS Player games) on a regular basis, and everyone knowing me knows it's not because of my inefficient scripting :p The RGSS Player is known as a relatively slow interpreter, so while I'm not trying to discourage you, I think getting the effects you linked to work via an effect (as opposed to moving 1px-wide images up and down or something) would be pretty much close to impossible if you aim for a broad user spec (which, as a game designer, you do).

Oh, and in general, very nice effects you got there! :D

Keep up the good work (and maybe get your very own Golden Left-Sided Shoe Of Great Scripting next time!).

**Location:** Approximately 93 million miles from Sol.

To continue what BlueScope said, an alternative to scripting this via the slow RGSS-based Ruby interpreter might be programming a .dll file in a much faster language, such as C++. In point of fact, I could even provide you with the necessary code to get you started with bitmap methods in a .dll file, since I've dabbled with it myself. (Including creating several of the filters you have here) It is much faster, with no noticeable lag, and if you code it correctly, it will produce the exact same effect.

**Location:** Denver, CO

I know very little C++ to actually code in it, but If you provided me the code for what I've done so far I could teach myself by looking at your code and working from there.

In terms of software to work with, all I have is Microsoft Visual C++ 2008. Would this be enough?

I haven't made a ton of progress in terms of finding out how to "refresh" an altered bitmap, but I have been working on something else:

Crosseye

It makes two copies of the same bitmap at half transparency and moves them both x pixels away from the center. Still a bit buggy, and I'd like to figure out how to also make them move at a degree measure as opposed to just left and right.

**Location:** Approximately 93 million miles from Sol.

All right. Sorry for taking so long to get back to you with the code, but I have it right here. Right now, it's a mix of C and C++, but it works as long as you set it to compile as a .dll file. Some of the header files I included are for things that I had in my dll, such as the time classes used for random number generation for a splatter effect. You might want to note that RMXP and RMVX store bitmaps in the BGRA format, instead of the more common RGBA format, which is reflected in the example bitmap method below. Microsoft Visual C++ should be enough, though I would recommend getting the newest version, which was just released.

Line number On/Off | Expand/Contract | Select all

Expand to see the code.

**Location:** Denver, CO

Hey thanks! I'll take a better look into this and see where to begin coding these into C. Once I get a few methods working, I'll see how calling them through the .dll improves the latency. This will keep me busy once school lets out.
Thanks a million :thumb:

**Location:** Approximately 93 million miles from Sol.

Untra wrote:

Hey thanks! I'll take a better look into this and see where to begin coding these into C. Once I get a few methods working, I'll see how calling them through the .dll improves the latency. This will keep me busy once school lets out.
Thanks a million :thumb:

Trust me, it improves the latency by quite a bit. By the way, if RMXP crashes when you call the .dll file, it's probably because you are trying to read or set pixels that are outside the bitmap's range, or because of some other error caused by your input. Also, to send a bitmap to the .dll file, you have to use the .__id__ method. Basically, bitmap_variable.__id__

**Location:** Denver, CO

I'm getting a few errors trying to compile:

Line number On/Off | Expand/Contract | Select all

Expand to see the code.

That line (57) is:
RGSSBMINFO *bitmap = ((RGSSBITMAP*) (object<<1)) -> bm -> bminfo;

I'm not quite sure what to do. Help?

**Location:** Approximately 93 million miles from Sol.

you left the arguments out of the method name. Note that the method was named as method_name(long object). In this case, the method would be fed one bitmap, following the bitmap.__id__ advice I gave you earlier. Don't drop the long, or the object, or you'll get an error.

**Location:** Denver, CO

Thanks! I got it working!

http://www.box.net/shared/9m54d8hkzu

Alright, first working dll... Now what? :huh:

I'm not quite sure how to go about calling it though. Win32API.new of course, but just what arguments would I put in it?
I feel so very, very new at this... :blush:

Edit: for reference, heres the sole working method:

Line number On/Off | Expand/Contract | Select all

Expand to see the code.

**Location:** Approximately 93 million miles from Sol.

First you have to get a properly compiled .dll file. Then you'll do the following:

Line number On/Off | Expand/Contract | Select all

Expand to see the code.

Let me explain.

"dll name": the name of the dll file, with or without the extension. (case insensitive, crashes if not found)
"function name": The name of the function you wish to call. (case sensitive, crashes if not found)
"LlIiNnPp": The arguments. This is a string of characters, which are explained below.
"LlIiNnPpVv": The return value. A single character, follows the same rules as the arguments.

Arguments:
"L" or "l", "N" or "n": A long number. This can be used to pass booleans, where 0 is false and anything else is true.
"I" or "i": An int. This can be used to pass booleans. (see above)
"P" or "p": A pointer to a string. With more advanced programming, can be used to pass other variable types, such as structures.
"V" or "v": Void. May only be used as a return value.

One other thing I would like to note is that if the dll crashes, so will RMXP or RMVX, and that you will receive a non-specific error message regarding the event.

**Location:** Denver, CO

Ah, I see what I did with the dll. This should be it fixed then:
http://www.box.net/shared/9m54d8hkzu

It did however crash. :sad:

Line number On/Off | Expand/Contract | Select all

Expand to see the code.

I cannot thank you enough for all your help Glitchfinder! Ive learned a lot working with this code, and you've helped me just about every step of the way. You kick ass, sir.

**Location:** Approximately 93 million miles from Sol.

Instead of feeding it amount, you need to feed it bitmap.__id__, and, if you need the amount, you need to make a second argument for the function in the .dll file, so that it can take the amount as an int. This is because it takes object, which is essentially a pointer to the bitmap in system memory, and uses it to access the bitmap data. So, try this:

Line number On/Off | Expand/Contract | Select all

Expand to see the code.

Keep in mind that you'll also want to add a bit of checking to force the values for the new colors into the proper range, since they will give an error if they are less than 0 or greater than 255.

**Location:** Denver, CO

It works!

I tested a 640x480 image of a julia fractal brightened by 100, which would normally kill it outright. It took less than a second. :thumb:

I'll finish the rest of the methods before I release the full .dll.
You've helped a ton! Thanks!

**Location:** Denver, CO

Version v0.85
http://www.box.net/shared/9m54d8hkzu

Line number On/Off | Expand/Contract | Select all

Expand to see the code.

The first four methods work like a charm!

But Pixelate and Frost don't change the colors of each pixel; they either redraw the pixels over a set course or draw them somewhere else. I'm gonna do some more research on how to write them (as you've helped more than enough), but otherwise these first four work quickly and flawlessly.

Sun May 30, 2010 11:39 am

It's working great, :)

I may have found a bug: when I change an event's graphic with this, every other event with the same sprite/tile also change.
I'm doing something like:

Line number On/Off | Expand/Contract | Select all

Expand to see the code.

I could be doing it wrong, though.

**Location:** Denver, CO

Thats because they all share the same bitmap id. Hmm... I'll take a look into how you could force it onto just one event. Its not so much a bug than a simple oversight.

**Location:** Approximately 93 million miles from Sol.

Untra wrote:

Thats because they all share the same bitmap id. Hmm... I'll take a look into how you could force it onto just one event. Its not so much a bug than a simple oversight.

You'd have to make individual events clone the bitmap before using it. I've encountered this issue in the past.

Tue Jun 01, 2010 11:32 am

Line number On/Off | Expand/Contract | Select all

#==============================================================================
# ** Additional Bitmap Methods
#------------------------------------------------------------------------------
#   By Untra and Glitchfinder
#   5/29/10
#   v0.85
#==============================================================================
class Bitmap
#------------------------------------------------------------------------------
#Make sure you have uabm.dll in your project folder.
#You can get it from (assuming link is not dead):
#http://www.box.net/shared/9m54d8hkzu
#------------------------------------------------------------------------------
  Brighten = Win32API.new("uabm.dll", "Brighten", "li", "v")
  Darken = Win32API.new("uabm.dll", "Darken", "li", "v")
  Invert = Win32API.new("uabm.dll", "Invert", "l", "v")
  Grayscale = Win32API.new("uabm.dll", "Grayscale", "l", "v")
  #--------------------------------------------------------------------------
  # * Brighten
  #--------------------------------------------------------------------------
  def brighten(amount)
    Brighten.call(self.__id__, amount)
  end
  #--------------------------------------------------------------------------
  # * Darken
  #--------------------------------------------------------------------------
  def darken(amount)
    Darken.call(self.__id__, amount)
  end
  #--------------------------------------------------------------------------
  # * Invert
  #--------------------------------------------------------------------------
  def invert
    Invert.call(self.__id__)
  end
  #--------------------------------------------------------------------------
  # * Grayscale
  #--------------------------------------------------------------------------
   def grayscale
      Grayscale.call(self.__id__)
   end
end
 
#==============================================================================
# * Edit by Silver Wind
#==============================================================================
class Game_Event
  
  def name
    return @event.name
  end
  
end
#-------------------------------------------------------------------------#
class Game_Map
  def get_event(key)
     if key.is_a?(String)
      return get_event_by_name(key)
    else
      return get_event_by_id(key)
    end
  end
  
  def get_event_by_name(name)
    for i in @map.events.keys
      ev = @events[i]
      return ev if ev.name == name
    end
    # Error: No such event
    return nil
  end
  
  def get_event_by_id(i)
    for k in @map.events.keys
      ev = @events[k]
      return ev if ev.id== i
    end
    # Error: No such event
    return nil
  end
end
#-------------------------------------------------------------------------#
class Scene_Map
  
  def bitmap_effect(event, action, amount=nil)
    ev = $game_map.get_event(event)
    sprite = @spriteset.get_sprite(ev)
    return if ev.nil?
    case (action)
    when 'brighten'
      sprite.brighten_by(amount)
    when 'darken'
      sprite.darken_by(amount)
    when 'invert'
      sprite.invert
    when 'grayscale'
      sprite.grayscale
    end
  end
  
end
#-------------------------------------------------------------------------#
class Spriteset_Map
 
  def get_sprite(event)
    for sprite in @character_sprites
      ev = sprite.character
      # if it's the same Game_Event object.
      if ev.object_id == event.object_id  
        target_sprite = sprite
      end
    end
    return target_sprite
  end
  
end
#-------------------------------------------------------------------------#
class Sprite_Character < RPG::Sprite
  def brighten_by(x)
    self.bitmap.brighten(x)
  end
  
  def darken_by(x)
    self.bitmap.darken(x)
  end
  
  def invert
    self.bitmap.invert
  end
  
  def grayscale
    self.bitmap.grayscale
  end
  
  def update
    super
    # If tile ID, file name, or hue are different from current ones
    if @tile_id != @character.tile_id or
       @character_name != @character.character_name or
       @character_hue != @character.character_hue
      # Remember tile ID, file name, and hue
      @tile_id = @character.tile_id
      @character_name = @character.character_name
      @character_hue = @character.character_hue
      # If tile ID value is valid
      if @tile_id >= 384
        #----------------------------- edit -----------------------------#
        # clone the bitmap before using it for an event.
        bitmap = RPG::Cache.tile($game_map.tileset_name,
          @tile_id, @character.character_hue)
        self.bitmap = bitmap.clone
        #----------------------------------------------------------------#
        self.src_rect.set(0, 0, 32, 32)
        self.ox = 16
        self.oy = 32
      # If tile ID value is invalid
      else
        #----------------------------- edit -----------------------------#
        # clone the bitmap before using it for an event.
        bitmap = RPG::Cache.character(@character.character_name,
          @character.character_hue)
        self.bitmap = bitmap.clone
        #----------------------------------------------------------------#
        @cw = bitmap.width / 4
        @ch = bitmap.height / 4
        self.ox = @cw / 2
        self.oy = @ch
      end
    end
    # Set visible situation
    self.visible = (not @character.transparent)
    # If graphic is character
    if @tile_id == 0
      # Set rectangular transfer
      sx = @character.pattern * @cw
      sy = (@character.direction - 2) / 2 * @ch
      self.src_rect.set(sx, sy, @cw, @ch)
    end
    # Set sprite coordinates
    self.x = @character.screen_x
    self.y = @character.screen_y
    self.z = @character.screen_z(@ch)
    # Set opacity level, blend method, and bush depth
    self.opacity = @character.opacity
    self.blend_type = @character.blend_type
    self.bush_depth = @character.bush_depth
    # Animation
    if @character.animation_id != 0
      animation = $data_animations[@character.animation_id]
      animation(animation, true)
      @character.animation_id = 0
    end
  end
  
end
#-------------------------------------------------------------------------#
 
def brighten(event,amount)
  #return unless $scene.is_a?(Scene_Map)
  $scene.bitmap_effect(event,'brighten',amount)
end
 
def darken(event,amount)
  $scene.bitmap_effect(event,'darken',amount)
end
 
def invert(event)
  $scene.bitmap_effect(event,'invert')
end
 
def grayscale(event)
  $scene.bitmap_effect(event,'grayscale')
end

Expand to see the code.

Tiny edit. only 170 lines o.o;
The 4 last methods are meant to keep the call short in the script box.
Send the event name or number as parameter:
brighten("EV001",64)
invert(2)

**Location:** Approximately 93 million miles from Sol.

Silver Wind, were you aware that any methods or variables defined within the Interpreter class (Or Game_Interpreter for VX) will be accessible to the evented "call script..." command? That means that you would only have to define those methods inside the interpreter, instead of making them globally accessible. Another thing to note is that the Interpreter has a neat little method called get_character(parameter), that will return $game_player if the parameter is -1, or the event that called it, if it is 0, or, even better, will return the event whose ID you gave it as a parameter, if the parameter is above 0. This makes it extraordinarily easy to modify events on the fly. Another thing to note is that you never want to use the variable @index in the "call script..." command, because that is used to determine where in the event's command list you are operating from, and will result in an infinitely looping event, or, even worse, a crash. (You can define instance variables with @variable_name that will be accessible by future call scripts, if you want to.)

Tue Jun 01, 2010 9:14 pm

Thanks for the tip :)
I'll modified my script to use get_character.
I never touched @index, but yeah, better leave it alone :P

**Location:** Denver, CO

aanndd... I'm stuck.

Line number On/Off | Expand/Contract | Select all

 
//Pixelate
extern "C" _declspec (dllexport) BOOL Pixelate(long object, int size)
{
    RGSSBMINFO *bitmap = ((RGSSBITMAP*) (object<<1)) -> bm -> bminfo;
    DWORD rowsize;
    DWORD width, height;
    LPBYTE row;
    long x, y, z;
    int red, green, blue, alpha;
    if(!bitmap) return false;
    if(size <= 1) return false;
    width = bitmap -> infoheader -> biWidth;
    height = bitmap -> infoheader -> biHeight;
    rowsize = width * 4;
    row = (LPBYTE) (bitmap -> firstRow);
    for ( y = 0; y < (int) height - 1 / size; y++) {
        y *= size;
        for ( x = 0; x < (int) width - 1 / size; x++) {
            x *= size;
            red, green, blue, alpha = 0;
            LPBYTE thisrow = row;
            for ( z = 0; z == size; z++){
                //row
                thisrow = row;
                red += (thisrow[2]);
                green += (thisrow[1]);
                blue += (thisrow[0]);
                alpha += (thisrow[3]);
                //row
                x += z;
                thisrow = row;
                red += (thisrow[2]);
                green += (thisrow[1]);
                blue += (thisrow[0]);
                alpha += (thisrow[3]);
                x -= z;
                //row your boat
                y += z;
                thisrow = row;
                red += (thisrow[2]);
                green += (thisrow[1]);
                blue += (thisrow[0]);
                alpha += (thisrow[3]);
                y -= z;
            }
            double block = size;
            double r = red / pow(block,2);
            r *=  sqrt(block);
            double g = green / pow(block,2);
            g *=  sqrt(block);
            double b = blue / pow(block,2);
            b *=  sqrt(block);
            double a = alpha / pow(block,2);
            a *=  sqrt(block);
 
            if(r > 255) r = 255;
            if(g > 255) g = 255;
            if(b > 255) b = 255;
            if(a > 255) a = 255;
            if(r < 0) r = 0;
            if(g < 0) g = 0;
            if(b < 0) b = 0;
            if(a < 0) a = 0;
            thisrow[2] = (BYTE) r;
            thisrow[1] = (BYTE) g;
            thisrow[0] = (BYTE) b;
            thisrow[3] = (BYTE) a;
            thisrow += 4;
        }
        row -= rowsize;
    }
    return true;
}
 

Expand to see the code.

I think I'm completely off by line 25 there. This would be a lot easier with a set_pixel function :sad:

Edit: Sudden realization the original RGSS Method would be useful for comparison:

Line number On/Off | Expand/Contract | Select all

Expand to see the code.

**Location:** Approximately 93 million miles from Sol.

I think you're in need of some more source code. Here's the full source code of my .dll file, from the last time I updated it. At the time, I was working on adding in all the effects from theory's Character Shaders. Go ahead and add effects from that to your project, since all of them were open source or unsourced ruby code that has been floating around foreign-language RM* communities for years.

Line number On/Off | Expand/Contract | Select all

#include <cstdlib>
#include <ctime>
#include <ctype.h>
#include <math.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <windows.h>
 
BOOL APIENTRY DllMain( HMODULE hModule, DWORD  ul_reason_for_call, LPVOID lpReserved) {
    switch (ul_reason_for_call) {
        case DLL_PROCESS_ATTACH:
        case DLL_THREAD_ATTACH:
        case DLL_THREAD_DETACH:
        case DLL_PROCESS_DETACH:
        break;
    }
    return true;
}
 
typedef struct {
    DWORD flags;
    DWORD klass;
    void (*dmark) (void*);
    void (*dfree) (void*);
    double *data; //red is index 1, green is index 2, blue 3, alpha 0
} RGSSCOLOR;
 
typedef struct{
    DWORD unk1;
    DWORD unk2;
    BITMAPINFOHEADER *infoheader;
    RGSSCOLOR *firstRow;
    RGBQUAD *lastRow;
} RGSSBMINFO;
 
typedef struct{
    DWORD unk1;
    DWORD unk2;
    RGSSBMINFO *bminfo;
} BITMAPSTRUCT;
 
typedef struct{
    DWORD flags;
    DWORD klass;
    void (*dmark) (void*);
    void (*dfree) (void*);
    BITMAPSTRUCT *bm;
} RGSSBITMAP;
 
#define ASSERT(x) if(!x){DebugOut("Failed: %s: %d", #x, __LINE__);}
 
extern "C" _declspec (dllexport) BOOL AlienTwo(long object){
    RGSSBMINFO *bitmap = ((RGSSBITMAP*) (object<<1)) -> bm -> bminfo;
    DWORD rowsize;
    DWORD width, height;
    LPBYTE row, pixel1, pixel2, pixel3, pixel4;
    long x, y;
    double red, green, blue;
    if(!bitmap) return false;
    width = bitmap -> infoheader -> biWidth;
    height = bitmap -> infoheader -> biHeight;
    rowsize = width * 4;
    row = (LPBYTE) (bitmap -> firstRow);
    for ( y = 0; y < (int) height; y++) {
        pixel1 = row;
        pixel2 = row;
        pixel3 = row;
        pixel4 = row;
        if((y >= 0) && ((y + 1) < (int) height)) {
            pixel2 -= rowsize;
            pixel3 -= rowsize;
        }
        for ( x = 0; x < (int) width; x++) {
            if(((y + 1) < (int) height) && ((x + 1) < (int) width)) {
                pixel2 += 4;
                pixel4 += 4;
                red = sqrt(pow(((double) pixel1[2] - pixel2[2]), 2) + pow(((double) pixel3[2] - pixel4[2]), 2));
                green = sqrt(pow(((double) pixel1[1] - pixel2[1]), 2) + pow(((double) pixel3[1] - pixel4[1]), 2));
                blue = sqrt(pow(((double) pixel1[0] - pixel2[0]), 2) + pow(((double) pixel3[0] - pixel4[0]), 2));
            }
            else if(((y + 1) >= (int) height) && ((x + 1) < (int) width)) {
                pixel2 += 4;
                pixel4 += 4;
                red = sqrt(pow((double) pixel1[2], 2) + pow((double) pixel4[2], 2));
                green = sqrt(pow((double) pixel1[1], 2) + pow((double) pixel4[1], 2));
                blue = sqrt(pow((double) pixel1[0], 2) + pow((double) pixel4[0], 2));
            }
            else if(((y + 1) < (int) height) && ((x + 1) >= (int) width)) {
                red = sqrt(pow((double) pixel1[2], 2) + pow((double) pixel3[2], 2));
                green = sqrt(pow((double) pixel1[1], 2) + pow((double) pixel3[1], 2));
                blue = sqrt(pow((double) pixel1[0], 2) + pow((double) pixel3[0], 2));
            }
            else {
                red = pixel1[2];
                green = pixel1[1];
                blue = pixel1[0];
            }
            if((red + green + blue) > (double) 60) {
                if((red >= green) && (red >= blue)) {
                    red += 20;
                }
                else if((green >= red) && (green >= blue)) {
                    green += 20;
                }
                else {
                    blue += 20;
                }
                if(red > 255) red = 255;
                if(green > 255) green = 255;
                if(blue > 255) blue = 255;
                pixel1[2] = (BYTE) red;
                pixel1[1] = (BYTE) green;
                pixel1[0] = (BYTE) blue;
            }
            else {
                pixel1[2] = 0;
                pixel1[1] = 0;
                pixel1[0] = 0;
            }
            pixel1 += 4;
            pixel3 += 4;
        }
        row -= rowsize;
    }
    return true;
}
 
extern "C" _declspec (dllexport) BOOL BlackAndWhite(long object){
    RGSSBMINFO *bitmap = ((RGSSBITMAP*) (object<<1)) -> bm -> bminfo;
    DWORD rowsize;
    DWORD width, height;
    LPBYTE row;
    long x, y;
    int shade;
    if(!bitmap) return false;
    width = bitmap -> infoheader -> biWidth;
    height = bitmap -> infoheader -> biHeight;
    rowsize = width * 4;
    row = (LPBYTE) (bitmap -> firstRow);
    for ( y = 0; y < (int) height; y++) {
        LPBYTE thisrow = row;
        for ( x = 0; x < (int) width; x++) {
            shade = ((thisrow[2] + thisrow[1] + thisrow[0]) / 3);
            thisrow[2] = shade;
            thisrow[1] = shade;
            thisrow[0] = shade;
            thisrow += 4;
        }
        row -= rowsize;
    }
    return true;
}
 
extern "C" _declspec (dllexport) BOOL BlackAndWhite2(long object){
    RGSSBMINFO *bitmap = ((RGSSBITMAP*) (object<<1)) -> bm -> bminfo;
    DWORD rowsize;
    DWORD width, height;
    LPBYTE row;
    long x, y;
    int red, green, blue, shade;
    if(!bitmap) return false;
    width = bitmap -> infoheader -> biWidth;
    height = bitmap -> infoheader -> biHeight;
    rowsize = width * 4;
    row = (LPBYTE)(bitmap -> firstRow);
    for ( y = 0; y < (int) height; y++) {
        LPBYTE thisrow = row;
        for ( x = 0; x < (int) width; x++) {
            red = (thisrow[1] - thisrow[0] + thisrow[1] + thisrow[2]);
            red = (red * thisrow[2] / 256);
            if(red > 255) red = 255;
            green = (thisrow[0] - thisrow[1] + thisrow[0] + thisrow[2]);
            green = (green * thisrow[1] / 256);
            if(green > 255) green = 255;
            blue = (thisrow[0] - thisrow[1] + thisrow[0] + thisrow[2]);
            blue = (blue * thisrow[0] / 256);
            if(blue > 255) blue = 255;
            shade = ((red + green + blue) / 3);
            thisrow[2] = shade;
            thisrow[1] = shade;
            thisrow[0] = shade;
            thisrow += 4;
        }
        row -= rowsize;
    }
    return true;
}
 
extern "C" _declspec (dllexport) BOOL Emboss(long object){
    RGSSBMINFO *bitmap = ((RGSSBITMAP*) (object<<1)) -> bm -> bminfo;
    DWORD rowsize;
    DWORD width, height;
    LPBYTE row;
    long x, y;
    int red, green, blue;
    if(!bitmap) return false;
    width = bitmap -> infoheader -> biWidth;
    height = bitmap -> infoheader -> biHeight;
    rowsize = width * 4;
    row = (LPBYTE)(bitmap -> firstRow);
    for ( y = 0; y < (int) height; y++) {
        LPBYTE thisrow = row;
        LPBYTE nextrow = row;
        if((y > 0) && ((y + 1) < (int) height)) {
            nextrow -= (width * 4);
        }
        for ( x = 0; x < (int) width; x++) {
            if(((y + 1) < (int) height) && ((x + 1) < (int) width)) {
                nextrow += 4;
                red = (thisrow[2] - nextrow[2] + 128);
                green = (thisrow[1] - nextrow[1] + 128);
                blue = (thisrow[0] - nextrow[0] + 128);
            }
            else {
                red = (thisrow[2] + 128);
                green = (thisrow[1] + 128);
                blue = (thisrow[0] + 128);
            }
            red = abs(red);
            green = abs(green);
            blue = abs(blue);
            if(red > 255) red = 255;
            if(green > 255) green = 255;
            if(blue > 255) blue = 255;
            thisrow[2] = red;
            thisrow[1] = green;
            thisrow[0] = blue;
            thisrow += 4;
        }
        row -= rowsize;
    }
    return true;
}
 
extern "C" _declspec (dllexport) BOOL MinusTwo(long object){
    RGSSBMINFO *bitmap = ((RGSSBITMAP*) (object<<1)) -> bm -> bminfo;
    DWORD rowsize;
    DWORD width, height;
    LPBYTE row;
    long x, y;
    double color1, color2;
    if(!bitmap) return false;
    width = bitmap -> infoheader -> biWidth;
    height = bitmap -> infoheader -> biHeight;
    rowsize = width * 4;
    row = (LPBYTE)(bitmap -> firstRow);
    for ( y = 0; y < (int) height; y++) {
        LPBYTE thisrow = row;
        LPBYTE nextrow = row;
        if((y > 0) && ((y + 1) < (int) height)) {
            nextrow -= (width * 4);
        }
        for ( x = 0; x < (int) width; x++) {
            if(((y + 1) < (int) height) && ((x + 1) < (int) width)) {
                nextrow += 4;
                color2 = (((nextrow[2] * 0.3) + (nextrow[1] * 0.6) + (nextrow[0] * 0.1)) / 10);
            }
            else {
                color2 = 0;
            }
            color1 = (((thisrow[2] * 0.3) + (thisrow[1] * 0.6) + (thisrow[0] * 0.1)) / 10);
            if((color1 - color2) > 0.2) {
                thisrow[2] = 0;
                thisrow[1] = 0;
                thisrow[0] = 0;
            }
            else {
                thisrow[2] = 255;
                thisrow[1] = 255;
                thisrow[0] = 255;
            }
            thisrow += 4;
        }
        row -= rowsize;
    }
    return true;
}
 
extern "C" _declspec (dllexport) BOOL Sepia(long object){
    RGSSBMINFO *bitmap = ((RGSSBITMAP*) (object<<1)) -> bm -> bminfo;
    DWORD rowsize;
    DWORD width, height;
    LPBYTE row;
    long x, y;
    double red, green, blue;
    if(!bitmap) return false;
    width = bitmap -> infoheader -> biWidth;
    height = bitmap -> infoheader -> biHeight;
    rowsize = width * 4;
    row = (LPBYTE)(bitmap -> firstRow);
    for ( y = 0; y < (int) height; y++) {
        LPBYTE thisrow = row;
        for ( x = 0; x < (int) width; x++) {
            red = ((thisrow[2] * 0.393) + (thisrow[1] * 0.769) + (thisrow[0] * 0.189));
            green = ((thisrow[2] * 0.349) + (thisrow[1] * 0.686) + (thisrow[0] * 0.168));
            blue = ((thisrow[2] * 0.272) + (thisrow[1] * 0.534) + (thisrow[0] * 0.131));
            if(red > 255) red = 255;
            if(green > 255) green = 255;
            if(blue > 255) blue = 255;
            thisrow[2] = (BYTE) red;
            thisrow[1] = (BYTE) green;
            thisrow[0] = (BYTE) blue;
            thisrow += 4;
        }
        row -= rowsize;
    }
    return true;
}
 
extern "C" _declspec (dllexport) BOOL Sharpen(long object){
    RGSSBMINFO *bitmap = ((RGSSBITMAP*) (object<<1)) -> bm -> bminfo;
    DWORD rowsize;
    DWORD width, height;
    LPBYTE row;
    long x, y;
    double red, green, blue, ap;
    if(!bitmap) return false;
    width = bitmap -> infoheader -> biWidth;
    height = bitmap -> infoheader -> biHeight;
    rowsize = width * 4;
    row = (LPBYTE)(bitmap -> firstRow);
    red = 0;
    green = 0;
    blue = 0;
    ap = 0.8;
    for ( y = 0; y < (int) height; y++) {
        LPBYTE thisrow = row;
        LPBYTE nextrow = row;
        if((y > 0) && ((y + 1) < (int) height)) {
            nextrow -= (width * 4);
        }
        for ( x = 0; x < (int) width; x++) {
            if(((y + 1) < (int) height) && ((x + 1) < (int) width)) {
                nextrow += 4;
                red += nextrow[2];
                green += nextrow[1];
                blue += nextrow[0];
            }
            red = (((thisrow[2] - (red / 3)) * ap) + thisrow[2]);
            green = (((thisrow[1] - (green / 3)) * ap) + thisrow[1]);
            blue = (((thisrow[0] - (blue / 3)) * ap) + thisrow[0]);
            if(red > 255) red = 255;
            if(green > 255) green = 255;
            if(blue > 255) blue = 255;
            if(red < 0) red = 0;
            if(green < 0) green = 0;
            if(blue < 0) blue = 0;
            thisrow[2] = (BYTE) red;
            thisrow[1] = (BYTE) green;
            thisrow[0] = (BYTE) blue;
            thisrow += 4;
        }
        row -= rowsize;
    }
    return true;
}
 
extern "C" _declspec (dllexport) BOOL Soften(long object){
    RGSSBMINFO *bitmap = ((RGSSBITMAP*) (object<<1)) -> bm -> bminfo;
    DWORD rowsize;
    DWORD width, height;
    LPBYTE row;
    long x, y, xoffset, yoffset;
    int red, green, blue;
    if(!bitmap) return false;
    width = bitmap -> infoheader -> biWidth;
    height = bitmap -> infoheader -> biHeight;
    rowsize = width * 4;
    row = (LPBYTE) (bitmap -> firstRow);
    for ( y = 0; y < (int) height; y++) {
        LPBYTE thisrow = row;
        for ( x = 0; x < (int) width; x++) {
            red = 0;
            green = 0;
            blue = 0;
            for ( xoffset = -1; xoffset <= 1; xoffset++) {
                for ( yoffset = -1; yoffset <= 1; yoffset++) {
                    if ((y > 0) && ((y + yoffset) < (int) height) && ((y + yoffset) > 0) && ((x + xoffset) > 0) && ((x + xoffset) < (int) width)) {
                        LPBYTE newrow = thisrow;
                        newrow -= (yoffset * (width * 4));
                        newrow += (xoffset * 4);
                        red += newrow[2];
                        green += newrow[1];
                        blue += newrow[0];
                    }
                }
            }
            red /= 9;
            green /= 9;
            blue /= 9;
            thisrow[2] = red;
            thisrow[1] = green;
            thisrow[0] = blue;
            thisrow += 4;
        }
        row -= rowsize;
    }
    return true;
}
 
extern "C" _declspec (dllexport) BOOL Splatter(long object){
    RGSSBMINFO *bitmap = ((RGSSBITMAP*) (object<<1)) -> bm -> bminfo;
    DWORD rowsize;
    DWORD width, height;
    LPBYTE row;
    long x, y;
    int randomx, randomy;
    if(!bitmap) return false;
    width = bitmap -> infoheader -> biWidth;
    height = bitmap -> infoheader -> biHeight;
    rowsize = width * 4;
    row = (LPBYTE) (bitmap -> firstRow);
    srand((unsigned)time(0));
    for ( y = 0; y < (int) height; y++) {
        LPBYTE thisrow = row;
        for ( x = 0; x < (int) width; x++) {
            randomx = ((rand() % 3) + 1);
            randomy = ((rand() % 3) + 1);
            if((y > 0) && ((y + randomy) < (int) height) && ((x + randomx) < (int) width)) {
                LPBYTE newrow = thisrow;
                newrow -= (randomy * (width * 4));
                newrow += (randomx * 4);
                thisrow[2] = newrow[2];
                thisrow[1] = newrow[1];
                thisrow[0] = newrow[0];
                thisrow[3] = newrow[3];
            }
            else {
                thisrow[2] = 0;
                thisrow[1] = 0;
                thisrow[0] = 0;
                thisrow[3] = 0;
            }
            thisrow += 4;
        }
        row -= rowsize;
    }
    return true;
}
 
extern "C" _declspec (dllexport) BOOL Swap(long object1, long object2, int index){
    RGSSBMINFO *bitmap = ((RGSSBITMAP*) (object1<<1)) -> bm -> bminfo;
    RGSSBMINFO *palette = ((RGSSBITMAP*) (object2<<1)) -> bm -> bminfo;
    DWORD rowsize, pRowSize;
    DWORD width, height, pWidth;
    LPBYTE row, originalColor, newColor;
    long x, y;
    int red, green, blue, oldRed, oldGreen, oldBlue;
    if(!bitmap) return false;
    width = bitmap -> infoheader -> biWidth;
    height = bitmap -> infoheader -> biHeight;
    pWidth = palette -> infoheader -> biWidth;
    rowsize = width * 4;
    pRowSize = pWidth * 4;
    row = (LPBYTE) (bitmap -> firstRow);
    for ( y = 0; y < (int) height; y++) {
        LPBYTE thisrow = row;
        for ( x = 0; x < (int) width; x++) {
            red = thisrow[2];
            green = thisrow[1];
            blue = thisrow[0];
            originalColor = (LPBYTE) (palette -> firstRow);
            for ( int i = 0; i < (int) pWidth; i++) {
                oldRed = originalColor[2];
                oldGreen = originalColor[1];
                oldBlue = originalColor[0];
                if ( (red == oldRed) && (green == oldGreen) && (blue == oldBlue)) {
                    newColor = originalColor - (pRowSize * (index + 1));
                    thisrow[2] = newColor[2];
                    thisrow[1] = newColor[1];
                    thisrow[0] = newColor[0];
                }
                originalColor += 4;
                newColor += 4;
            }
            thisrow += 4;
        }
        row -= rowsize;
    }
    return true;
}
 
extern "C" _declspec (dllexport) BOOL Blank(long object){
    RGSSBMINFO *bitmap = ((RGSSBITMAP*) (object<<1)) -> bm -> bminfo;
    DWORD rowsize;
    DWORD width, height;
    LPBYTE row;
    long x, y;
    int red, green, blue;
    if(!bitmap) return false;
    width = bitmap -> infoheader -> biWidth;
    height = bitmap -> infoheader -> biHeight;
    rowsize = width * 4;
    row = (LPBYTE) (bitmap -> firstRow);
    for ( y = 0; y < (int) height; y++) {
        LPBYTE thisrow = row;
        for ( x = 0; x < (int) width; x++) {
            red = thisrow[2];
            green = thisrow[1];
            blue = thisrow[0];
            thisrow += 4;
        }
        row -= rowsize;
    }
    return true;
}

Expand to see the code.

**Location:** Denver, CO

I've been playing around with these methods, and I'm astounded! All of them work excellently. In particular, I like the splatter method; its code is actually the frost method, making things a ton easier. I'll incorporate all of these into the .dll and release them.

Oh, thank you so much! :biggrin:

Thu Jun 03, 2010 11:13 pm

Very cool, sorry I can't comment much on the technical side, however these are definately useful and functional, nice work.

**Location:** Denver, CO

Update: New version out now!

v0.9

Version v0.9
http://www.box.net/shared/9m54d8hkzu

Line number On/Off | Expand/Contract | Select all

#==============================================================================
# ** Additional Bitmap Methods
#------------------------------------------------------------------------------
#   By Untra and Glitchfinder
#   6/3/10
#   v0.9
#==============================================================================
class Bitmap
#------------------------------------------------------------------------------
#Make sure you have uabm.dll in your project folder.
#You can get it from (assuming link is not dead):
#http://www.box.net/shared/9m54d8hkzu
#------------------------------------------------------------------------------
  Brighten = Win32API.new("uabm.dll", "Brighten", "li", "v")
  Darken = Win32API.new("uabm.dll", "Darken", "li", "v")
  Invert = Win32API.new("uabm.dll", "Invert", "l", "v")
  Grayscale = Win32API.new("uabm.dll", "Grayscale", "l", "v")
  Hcontrast = Win32API.new("uabm.dll", "Hcontrast", "l", "v")
  Monochrome = Win32API.new("uabm.dll", "Monochrome", "l", "v")
  Emboss = Win32API.new("uabm.dll", "Emboss", "l", "v")
  Sepia = Win32API.new("uabm.dll", "Sepia", "l", "v")
  Sharpen = Win32API.new("uabm.dll", "Sharpen", "l", "v")
  Soften = Win32API.new("uabm.dll", "Soften", "l", "v")
  #--------------------------------------------------------------------------
  # * Brighten (0...255)
  #--------------------------------------------------------------------------
  def brighten(amount)
    Brighten.call(self.__id__, amount)
  end
  #--------------------------------------------------------------------------
  # * Darken (0...255)
  #--------------------------------------------------------------------------
  def darken(amount)
    Darken.call(self.__id__, amount)
  end
  #--------------------------------------------------------------------------
  # * Invert
  #--------------------------------------------------------------------------
  def invert
    Invert.call(self.__id__)
  end
  #--------------------------------------------------------------------------
  # * Grayscale
  #--------------------------------------------------------------------------
  def grayscale
    Grayscale.call(self.__id__)
  end
  #--------------------------------------------------------------------------
  # * Hyper Contrast
  #--------------------------------------------------------------------------
  def hyper_contrast
    Hcontrast.call(self.__id__)
  end
  #--------------------------------------------------------------------------
  # * Monochrome
  #--------------------------------------------------------------------------
  def monochrome
    Monochrome.call(self.__id__)
  end
  #--------------------------------------------------------------------------
  # * Emboss {buggy}
  #--------------------------------------------------------------------------
  def emboss
    Emboss.call(self.__id__)
  end
  #--------------------------------------------------------------------------
  # * Sepia
  #--------------------------------------------------------------------------
  def sepia
    Sepia.call(self.__id__)
  end
  #--------------------------------------------------------------------------
  # * Sharpen {will update with numeric value options}
  #--------------------------------------------------------------------------
  def sharpen
    Sharpen.call(self.__id__)
  end
  #--------------------------------------------------------------------------
  # * Soften {will update with numeric value options}
  #--------------------------------------------------------------------------
  def soften
    Soften.call(self.__id__)
  end
end

Expand to see the code.

As for the methods, most of them have been added in, but all of them could certainly use some tweaking. I'm hoping to apply arguments to the Sharpen and Soften methods, and the Sepia looks fairly off (it looks more like its been dipped in a bath of urine than sodium sulfide). I'm still working with the Frost to get it to work more accurately. For some reason, pixels that get pushed off the left side of the bitmap by the frosting wind up on the right, while pixels pushed to the right are simply lost.

Content Hidden

It only becomes really noticeable with smaller bitmaps at higher passes. The answer will come to me, but for now its a strange quirk thats been bothering me.

**Location:** Approximately 93 million miles from Sol.

I thought that, since I provided you with some of the methods, I might as well go a bit further. Here is a more permanent link for the current version of the .dll file. You might also want to try hosting it at [url]bb.ohsk.net[/url], which is hosted by shadow, owner of the Slacked IRC network.

Also, what in particular do you mean when you say that the emboss doesn't get every color. When I tested it, it seemed to work fine. I could be wrong, though. Also, below is the original set of Ruby methods that I was basing this stuff on:

Line number On/Off | Expand/Contract | Select all

def self.shader_alien2
    for y in 0..@bitmap.height
      for x in 0..@bitmap.width
          pixel1 = @bitmap.get_pixel(x, y)
          pixel2 = @bitmap.get_pixel(x + 1, y + 1)
          pixel3 = @bitmap.get_pixel(x, y + 1)
          pixel4 = @bitmap.get_pixel(x + 1, y)
          red = Math.hypot((pixel1.red - pixel2.red),
            (pixel3.red - pixel4.red))
          green = Math.hypot((pixel1.green - pixel2.green),
            (pixel3.green - pixel4.green))
          blue = Math.hypot((pixel1.blue - pixel2.blue),
            (pixel3.blue - pixel4.blue))
          if (red + green + blue) > 60
            if [red, green, blue].max == red
              @bitmap.set_pixel(x, y, Color.new(red + 20, green, blue,
                pixel1.alpha))
            elsif [red, green, blue].max == green
              @bitmap.set_pixel(x, y, Color.new(red, green + 20, blue,
                pixel1.alpha))
            elsif [red, green, blue].max == blue
              @bitmap.set_pixel(x, y, Color.new(red, green, blue + 20,
                pixel1.alpha))
            end
          else
            @bitmap.set_pixel(x, y, Color.new(0, 0, 0, pixel1.alpha))
          end
      end
      if x % 640 == 0 and x != 0
         self.contents.blt(0, 0, @bitmap, @bitmap.rect)
         Graphics.update
      end
    end
    return @bitmap
  end
 
  def self.shader_bnw
    for y in 0..@bitmap.height
      for x in 0..@bitmap.width
          a = @bitmap.get_pixel(x, y)
          shade = ((a.red + a.green + a.blue) / 3)
          @bitmap.set_pixel(x, y, Color.new(shade, shade, shade, a.alpha))
      end
      if x % 640 == 0 and x != 0
         self.contents.blt(0, 0, @bitmap, @bitmap.rect)
         Graphics.update
      end
    end
    return @bitmap
  end
 
  def self.shader_emboss
    for y in 0..@bitmap.height
      for x in 0..@bitmap.width
        a = @bitmap.get_pixel(x, y)
        b = @bitmap.get_pixel(x + 1, y + 1)
        red = (a.red - b.red + 128)
        red = red.abs
        green = (a.green - b.green + 128)
        green = green.abs
        blue = (a.blue - b.blue + 128)
        blue = blue.abs
        red = 255 if red > 255
        green = 255 if green > 255
        blue = 255 if blue > 255
        @bitmap.set_pixel(x, y, Color.new(red, green, blue, a.alpha))
      end
      if x % 640 == 0 and x != 0
         self.contents.blt(0, 0, @bitmap, @bitmap.rect)
         Graphics.update
      end
    end
    return @bitmap
  end
 
  def self.shader_minustwo
    for y in 0..@bitmap.height
      for x in 0..@bitmap.width
          a = @bitmap.get_pixel(x, y)
          b = @bitmap.get_pixel(x + 1, y + 1)
          color1 = (((a.red * 0.3) + (a.green * 0.6) + (a.blue * 0.1)) / 10)
          color2 = (((b.red * 0.3) + (b.green * 0.6) + (b.blue * 0.1)) / 10)
          if (color1 - color2) > 0.2
            @bitmap.set_pixel(x, y, Color.new(0, 0, 0, a.alpha))
          else
            @bitmap.set_pixel(x, y, Color.new(255, 255, 255, a.alpha))
          end
      end
      if x % 640 == 0 and x != 0
         self.contents.blt(0, 0, @bitmap, @bitmap.rect)
         Graphics.update
      end
    end
    return @bitmap
  end
 
  def self.shader_sepia
    for y in 0..@bitmap.height
      for x in 0..@bitmap.width
          a = @bitmap.get_pixel(x, y)
          red = ((a.red * 0.393) + (a.green * 0.769) + (a.blue * 0.189))
          green = ((a.red * 0.349) + (a.green * 0.686) + (a.blue * 0.168))
          blue = ((a.red * 0.272) + (a.green * 0.534) + (a.blue * 0.131))
          p blue if (y == 0 and x == 0)
          red = 255 if red > 255
          green = 255 if green > 255
          blue = 255 if blue > 255
          @bitmap.set_pixel(x, y, Color.new(red, green, blue, a.alpha))
      end
      if x % 640 == 0 and x != 0
         self.contents.blt(0, 0, @bitmap, @bitmap.rect)
         Graphics.update
      end
    end
    return @bitmap
  end
 
  def self.shader_sharpen
    red = 0
    green = 0
    blue = 0
    ap = 0.8
    for y in 0..@bitmap.height
      for x in 0..@bitmap.width
        a = @bitmap.get_pixel(x + 1, y + 1)
        b = @bitmap.get_pixel(x, y)
        red += a.red
        green += a.green
        blue += a.blue
        red = (b.red - (red / 3)) * ap + b.red
        green = (b.green - (green / 3)) * ap + b.green
        blue =(b.blue - (blue / 3)) * ap + b.blue
        red = 255 if red > 255
        green = 255 if green > 255
        blue = 255 if blue > 255
        red = 0 if red < 0
        green = 0 if green < 0
        blue = 0 if blue < 0
        @bitmap.set_pixel(x, y, Color.new(red, green, blue, b.alpha))
      end
      if x % 640 == 0 and x != 0
         self.contents.blt(0, 0, @bitmap, @bitmap.rect)
         Graphics.update
      end
    end
    return @bitmap
  end 
 
  def self.shader_soften
    for y in 0..@bitmap.height
      for x in 0..@bitmap.width
        red = 0
        green = 0
        blue = 0
        for x_offset in -1..1
          for y_offset in -1..1
            a = @bitmap.get_pixel(x + x_offset, y + y_offset)
            red += a.red
            green += a.green
            blue += a.blue
          end
        end
        red /= 9
        green /= 9
        blue /= 9
        b = @bitmap.get_pixel(x, y)
        @bitmap.set_pixel(x, y, Color.new(red, green, blue, b.alpha))
      end
      if x % 640 == 0 and x != 0
         self.contents.blt(0, 0, @bitmap, @bitmap.rect)
         Graphics.update
      end
    end
    return @bitmap
  end
 
  def self.shader_splatter
    for y in 0..@bitmap.height
      for x in 0..@bitmap.width
        x_offset = rand(3) + 1
        y_offset = rand(3) + 1
        b = @bitmap.get_pixel(x + x_offset, y + y_offset)
        @bitmap.set_pixel(x, y, Color.new(b.red, b.green, b.blue, b.alpha))
      end
      if x % 640 == 0 and x != 0
         self.contents.blt(0, 0, @bitmap, @bitmap.rect)
         Graphics.update
      end
    end
    return @bitmap
  end
 
  
  
  
  def self.shader_contrast
    conre = 1 ; ligre = 20
    congr = 2 ; liggr = 20
    conbl = 1 ; ligbl = 20
    ligre =(ligre-127*(conre-1))
    liggr =(liggr-127*(congr-1))
    ligbl =(ligbl-127*(conbl-1))
    for i in 0..@bitmap.height
      for j in 0..@bitmap.width
          a = @bitmap.get_pixel(j,i)
          re = a.red*conre + ligre
          gr = a.green*congr + liggr
          bl = a.blue*conbl + ligbl
          re = 255 if re > 255 ; re = 0 if re < 0
          gr = 255 if gr > 255 ; gr = 0 if gr < 0
          bl = 255 if bl > 255 ; bl = 0 if bl < 0
          @bitmap.set_pixel(j,i,Color.new(re, gr, bl, a.alpha))
      end
      if j % 640 == 0 and j != 0
         self.contents.blt(0,0,@bitmap,@bitmap.rect)
         Graphics.update
      end
    end
    return @bitmap
  end
 
  def self.shader_negative
    conre = -2 ; ligre = 0
    congr = -2 ; liggr = 0
    conbl = -2 ; ligbl = 0
    ligre =(ligre-127*(conre-1))
    liggr =(liggr-127*(congr-1))
    ligbl =(ligbl-127*(conbl-1))
    for i in 0..@bitmap.height
      for j in 0..@bitmap.width
          a = @bitmap.get_pixel(j,i)
          re = a.red*conre + ligre
          gr = a.green*congr + liggr
          bl = a.blue*conbl + ligbl
          re = 255 if re > 255 ; re = 0 if re < 0
          gr = 255 if gr > 255 ; gr = 0 if gr < 0
          bl = 255 if bl > 255 ; bl = 0 if bl < 0
          @bitmap.set_pixel(j,i,Color.new(re, gr, bl, a.alpha))
      end
      if j % 640 == 0 and j != 0
         self.contents.blt(0,0,@bitmap,@bitmap.rect)
         Graphics.update
      end
    end
    return @bitmap
  end
 
  def self.shader_cartoon
    for i in 0..@bitmap.height
      for j in 0..@bitmap.width
          a = @bitmap.get_pixel(j,i)
          b = @bitmap.get_pixel(j,i)
          re = a.red+b.red
          gr = a.green+b.green
          bl = a.blue+b.blue
          re = 255 if re > 255 ; re = 0 if re < 0
          gr = 255 if gr > 255 ; gr = 0 if gr < 0
          bl = 255 if bl > 255 ; bl = 0 if bl < 0
          @bitmap.set_pixel(j,i,Color.new(re, gr, bl, a.alpha))
      end
      if j % 640 == 0 and j != 0
         self.contents.blt(0,0,@bitmap,@bitmap.rect)
         Graphics.update
      end
    end
    return @bitmap
  end
 
  def self.shader_bright
    ra = 50
    for i in 0..@bitmap.height
      for j in 0..@bitmap.width
          a = @bitmap.get_pixel(j,i)
          b = @bitmap.get_pixel(j,i)
          re = (a.red>b.red ? a.red : b.red)
          gr = (a.green>b.green ? a.green : b.green)
          bl = (a.blue>b.blue ? a.blue : b.blue)
          al = (a.alpha>b.alpha ? a.alpha : b.alpha)
          @bitmap.set_pixel(j,i,Color.new(re+ra, gr+ra, bl+ra, al))
      end
      if j % 640 == 0 and j != 0
         self.contents.blt(0,0,@bitmap,@bitmap.rect)
         Graphics.update
      end
    end
    return @bitmap
  end
 
  def self.shader_bizarro
    ra = 100
    wh = 50
    for i in 0..@bitmap.height
      for j in 0..@bitmap.width
          a = @bitmap.get_pixel(j,i)
          no = rand(ra)-ra+1
          re = a.red+no+wh ; gr = a.green+no+wh ; bl = a.blue+no+wh
          re = 255 if re > 255 ; re = 0 if re < 0
          gr = 255 if gr > 255 ; gr = 0 if gr < 0
          bl = 255 if bl > 255 ; bl = 0 if bl < 0
          @bitmap.set_pixel(j,i,Color.new(re, gr, bl, a.alpha))
      end
      if j % 640 == 0 and j != 0
         self.contents.blt(0,0,@bitmap,@bitmap.rect)
         Graphics.update
      end
    end
    return @bitmap
  end
 
  def self.shader_bulletholes
    ra = 10
    for i in 0..@bitmap.height
      for j in 0..@bitmap.width
          a = @bitmap.get_pixel(j,i)
          if rand(101) < ra
             re = rand(256) ; gr = rand(256) ; bl = rand(256)
             @bitmap.set_pixel(j,i,Color.new(re, gr, bl, a.alpha))
          end
      end
      if j % 640 == 0 and j != 0
         self.contents.blt(0,0,@bitmap,@bitmap.rect)
         Graphics.update
      end
    end
    return @bitmap
  end
 
  def self.shader_sill
    ra = 500
    re = 0 ; gr = 0 ; bl = 0
    for i in 1..(@bitmap.height-1)
      for j in 1..(@bitmap.width-1)
        for m in -1..1
          for n in -1..1
            if m != 0 and n != 0
              a = @bitmap.get_pixel(j+m,i+n)
              re = re + a.red
              gr = gr + a.green
              bl = bl + a.blue
            end
          end
        end
        b = @bitmap.get_pixel(j,i)
        re = (b.red-re/8).abs
        gr = (b.green-gr/8).abs
        bl = (b.blue-bl/8).abs
        if (re+gr+bl) > ra
          @bitmap.set_pixel(j,i,Color.new(255, 255, 255, b.alpha))
        else
          @bitmap.set_pixel(j,i,Color.new(0, 0, 0, b.alpha))
        end
      end
      if j % 639 == 0 and j != 0
         self.contents.blt(0,0,@bitmap,@bitmap.rect)
         Graphics.update
      end
    end
    return @bitmap
  end
 
  def self.shader_bw2
    for i in 0..@bitmap.height
      for j in 0..@bitmap.width
          a = @bitmap.get_pixel(j,i)
          re = (a.green-a.blue+a.green+a.red).abs
          re = re*a.red/256
          re = 255 if re > 255
          gr = (a.blue-a.green+a.blue+a.red).abs
          gr = gr*a.red/256
          gr = 255 if gr > 255
          bl = (a.blue-a.green+a.blue+a.red).abs
          bl = bl*a.green/256
          bl = 255 if bl > 255
          ma = (re+gr+bl)/3
          @bitmap.set_pixel(j,i,Color.new(ma, ma, ma, a.alpha))
      end
      if j % 640 == 0 and j != 0
         self.contents.blt(0,0,@bitmap,@bitmap.rect)
         Graphics.update
      end
    end
    return @bitmap
  end
 
  def self.shader_alien
    for i in 0..@bitmap.height
      for j in 0..@bitmap.width
          a = @bitmap.get_pixel(j,i)
          re = (a.green-a.blue)**2/128
          re = 255 if re > 255
          gr = (a.red-a.blue)**2/128
          gr = 255 if gr > 255
          bl = (a.red-a.green)**2/128
          bl = 255 if bl > 255
          @bitmap.set_pixel(j,i,Color.new(re, gr, bl, a.alpha))
      end
      if j % 640 == 0 and j != 0
         self.contents.blt(0,0,@bitmap,@bitmap.rect)
         Graphics.update
      end
    end
    return @bitmap
  end
 
  def self.shader_monotone
    ccr = 255
    ccg = 255
    ccb = 50
    for i in 0..@bitmap.height
      for j in 0..@bitmap.width
          a = @bitmap.get_pixel(j,i)
          ma = (a.red+a.green+a.blue)/3
          re = ma*ccr/255
          gr = ma*ccg/255
          bl = ma*ccb/255
          @bitmap.set_pixel(j,i,Color.new(re, gr, bl, a.alpha))
      end
      if j % 640 == 0 and j != 0
         self.contents.blt(0,0,@bitmap,@bitmap.rect)
         Graphics.update
      end
    end
    return @bitmap
  end
 
  def self.shader_enhance
    for i in 0..@bitmap.height
      for j in 0..@bitmap.width
          a = @bitmap.get_pixel(j,i)
          re = a.red**2/255
          gr = a.green**2/255
          bl = a.blue**2/255
          @bitmap.set_pixel(j,i,Color.new(re, gr, bl, a.alpha))
      end
      if j % 640 == 0 and j != 0
         self.contents.blt(0,0,@bitmap,@bitmap.rect)
         Graphics.update
      end
    end
    return @bitmap
  end
  
  def self.shader_undead
    for i in 0..@bitmap.height
      for j in 0..@bitmap.width
          a = @bitmap.get_pixel(j,i)
          re = a.green*a.blue/255
          gr = a.red*a.blue/255
          bl = a.red*a.green/255
          @bitmap.set_pixel(j,i,Color.new(re, gr, bl, a.alpha))
      end
      if j % 640 == 0 and j != 0
         self.contents.blt(0,0,@bitmap,@bitmap.rect)
         Graphics.update
      end
    end
    return @bitmap
  end
  
  def self.shader_wtf
    for i in 0..@bitmap.height
      for j in 0..@bitmap.width
          a = @bitmap.get_pixel(j,i)
          re = Math.sin(Math.atan2(a.green, a.blue))*255
          gr = Math.sin(Math.atan2(a.blue, a.red))*255
          bl = Math.sin(Math.atan2(a.red, a.green))*255
          @bitmap.set_pixel(j,i,Color.new(re, gr, bl, a.alpha))
      end
      if j % 640 == 0 and j != 0
         self.contents.blt(0,0,@bitmap,@bitmap.rect)
         Graphics.update
      end
    end
    return @bitmap
  end
 
  def self.shader_plexiglass
    pow = 200
    lig_x = @bitmap.width/2
    lig_y = @bitmap.height/2
    rr = Math.hypot(lig_x,lig_y)
    rc = rr**2
    for i in 0..@bitmap.height
      for j in 0..@bitmap.width
          a = @bitmap.get_pixel(j,i)
          len = (j-lig_x)**2+(i-lig_y)**2
          if len < rc
             dis = Math.sqrt(len);
             bri = pow*(rr-dis)/rr
             re = a.red+bri
             gr = a.green+bri
             bl = a.blue+bri
             al = a.alpha+bri
             re = 255 if re > 255
             gr = 255 if gr > 255
             bl = 255 if bl > 255
             al = 255 if al > 255
             @bitmap.set_pixel(j,i,Color.new(re, gr, bl, al))
           end
      end
      if j % 640 == 0 and j != 0
         self.contents.blt(0,0,@bitmap,@bitmap.rect)
         Graphics.update
      end
    end
    return @bitmap
  end

Expand to see the code.

As a final note, your "Hyper Emboss" filter is looking very similar to Photoshop's "Glowing Edges" filter.

Fri Jun 04, 2010 4:16 pm

Those new effects are looking great, especially the sepia.

	Homepage Board Index About Us	Downloadable Games Free Browser Games Games in Development	RPG Maker Support Game Maker Support Construct 2 Support	HBGames the eZine Advanced RPG Maker Site Announcements
Powered by phpBB © phpBB Group Hosted by TheComputerGuyHosting.com

Additional Bitmap Methods

Who is online