Neo Mode 7 +

[MGC]

RMXP : Add-on for the Neo Mode 7 Engine : Neo Mode 7 +
Version: 1.0

Introduction
This add-on for the Neo Mode 7 script was designed to increase a little the performances. Results may vary depending on the machine.


Features

• global performances slightly increased when rendering mode 7.
  
• mode 7 drawing only when moving -> lag is strongly reduced at stop.
  
• resolutions [R2]&[R3] applied only when moving -> not so ugly at stop (you can disable this feature by replacing "false" by "true" line 34.
  

Installation

Paste this script below the Neo Mode 7 script (compatible with the latest version on this board - 29/03/2010, or here), and copy the DLL at the root of your project.

Script :

Code:

#============================================================================
# Add-on : Neo Mode 7 +
# V.1.0 - 15/09/10
# Author : MGC
#
# This script increases (a little) the performances of the Neo Mode 7 engine.
# It is compliant with the 29/03/10 version that can be found on rmvxp.com.
# It requires the file "MGCmode7+.dll".
#
# Paste this script below the last part of the Neo Mode 7 script.
#============================================================================

#============================================================================
# ** Game_System
#============================================================================
class Game_System
  #--------------------------------------------------------------------------
  # * Aliased methods (F12 compatibility)
  #--------------------------------------------------------------------------
  unless @already_aliased_neoM7Plus
    alias initialize_neoM7Plus_game_system initialize
    @already_aliased_neoM7Plus = true
  end
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #     fple_always_same_res (boolean): true = same quality when moving or not
  #--------------------------------------------------------------------------
  attr_accessor :neoM7Plus_always_same_res
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize
    initialize_neoM7Plus_game_system
    self.neoM7Plus_always_same_res = false
  end
end

#============================================================================
# ** Sprite
#============================================================================
class Sprite
  #--------------------------------------------------------------------------
  # calculate x and y coordinates in mode 7 for a vertical sprite
  #--------------------------------------------------------------------------
  def neoM7(x_map, y_map)
    x_map = 32 * x_map
    y_map = 32 * y_map
    y_init = $game_temp.zoom_sprites * (y_map - $game_temp.pivot - $game_map.display_y.to_i / 4)
    x_init = $game_temp.zoom_sprites * (x_map - 320 - $game_map.display_x.to_i / 4)
    y_intermediate = (y_init * $game_temp.cos_theta -
    x_init * $game_temp.sin_theta).to_i >> 11
    x_intermediate = (x_init * $game_temp.cos_theta +
    y_init * $game_temp.sin_theta).to_i >> 11
    self.y = $game_temp.pivot + ($game_temp.distance_h * y_intermediate *
    $game_temp.cos_alpha) / (($game_temp.distance_h << 11) - y_intermediate *
    $game_temp.sin_alpha)
    self.x = 320 + ($game_temp.slope_value * y +
    $game_temp.corrective_value) * x_intermediate
  end
  #--------------------------------------------------------------------------
  # calculate x and y coordinates in mode 7 for a character sprite
  #--------------------------------------------------------------------------
  def neoM7_character(x_screen, y_screen)
    y_init = $game_temp.zoom_sprites * (y_screen - $game_temp.pivot)
    x_init = $game_temp.zoom_sprites * (x_screen - 320)
    y_intermediate = (y_init * $game_temp.cos_theta -
    x_init * $game_temp.sin_theta).to_i >> 11
    x_intermediate = (x_init * $game_temp.cos_theta +
    y_init * $game_temp.sin_theta).to_i >> 11
    self.y = $game_temp.pivot + ($game_temp.distance_h * y_intermediate *
    $game_temp.cos_alpha) / (($game_temp.distance_h << 11) - y_intermediate *
    $game_temp.sin_alpha)
    self.x = (320 + ($game_temp.slope_value * y +
    $game_temp.corrective_value) * x_intermediate)
  end
end

#============================================================================
# ** Bitmap
#============================================================================
class Bitmap
  NeoMode7Plus = Win32API.new("MGCmode7+.dll", "NeoMode7Plus", "lllllll", "l")
  CHLP = Win32API.new("MGCmode7+.dll", "CleanHeightLimitPlus", "lll", "l")
  #--------------------------------------------------------------------------
  # mode 7 transformation
  #--------------------------------------------------------------------------
  def neoM7(tileset, data, map_width, map_height, off_x, off_y, options)
    raise RGSSError.new("Disposed bitmap") if disposed?
    NeoMode7Plus.call(self.__id__, tileset.__id__, data.__id__, off_x, off_y,
    [$game_temp.cos_alpha, $game_temp.sin_alpha, $game_temp.distance_h,
    $game_temp.pivot_map.to_i, $game_temp.slope_value_map,
    $game_temp.corrective_value_map, $game_temp.neoM7_height_limit,
    $game_temp.cos_theta, $game_temp.sin_theta, $game_temp.distance_p.to_i,
    $game_temp.zoom_map].__id__, options.__id__)
  end
  #--------------------------------------------------------------------------
  def neoM7_screen(tileset, data, map_width, map_height, off_x, off_y, options)
    raise RGSSError.new("Disposed bitmap") if disposed?
    NeoMode7Plus.call(self.__id__, tileset.__id__, data.__id__, off_x, off_y,
    [$game_temp.cos_alpha, $game_temp.sin_alpha, $game_temp.distance_h,
    $game_temp.pivot.to_i, $game_temp.slope_value_map,
    (131072 * $game_temp.corrective_value).to_i, $game_temp.height_limit_sprites.to_i,
    $game_temp.cos_theta, $game_temp.sin_theta, 0,
    $game_temp.zoom_map].__id__, options.__id__)
  end
  #--------------------------------------------------------------------------
  # delete pixels beyond the horizon
  #--------------------------------------------------------------------------
  def clean_limit(old_limit, new_limit)
    raise RGSSError.new("Disposed bitmap") if disposed?
    CHLP.call(self.__id__, old_limit, new_limit)
  end
end

#============================================================================
# ** Tilemap_neoM7
#============================================================================
class Tilemap_neoM7
  #--------------------------------------------------------------------------
  # * Alias : F12 compatibility
  #--------------------------------------------------------------------------
  unless @already_aliased_neoM7Plus
    alias increase_zoom_neoM7Plus_tilemap increase_zoom
    alias set_zoom_neoM7Plus_tilemap set_zoom
    alias update_animated_neoM7Plus_tilemap update_animated
    @already_aliased_neoM7Plus = true
  end
  #--------------------------------------------------------------------------
  # * Attributes
  #--------------------------------------------------------------------------
  attr_accessor  :sprite_screen # sprite used to contain the map's drawing when not moving
  #--------------------------------------------------------------------------
  # * Object Initialization
  #     viewport  : viewport
  #--------------------------------------------------------------------------
  def initialize(viewport, spriteset)
    @even = true
    @viewport = viewport
    @spriteset = spriteset
    @id = $game_map.map_id # map's ID : used to load or save the map in Cache
    self.tilesets_list = [] # contains tilesets (Bitmap)
    @height = $game_map.height << 5 # @height : map's height (in pixel)
    @width = $game_map.width << 5 # @width : map's width (in pixel)
    @options = [0, 0, 0]
    @options[0] = $game_system.neoM7_loop ? 1 : 0
    @zoom = $game_system.neoM7_zoom # zoom level of the map
    $game_temp.zoom_sprites = @zoom.to_f / 100
    $game_temp.zoom_map = (4096 * (1.0 / $game_temp.zoom_sprites)).to_i

    # tilesets graphics and data map are loaded if already in Cache
    if RPG::Cache_Datamap.in_cache(@id)
      @bitmap_data = RPG::Cache_Datamap.load(@id)
      @map_tileset = RPG::Cache_Tileset.load(@id)
      tilesets_list.push(@map_tileset)
      if $game_system.neoM7_animated
        @map_tileset_2 = RPG::Cache_Tileset.load(@id, 1)
        @map_tileset_3 = RPG::Cache_Tileset.load(@id, 2)
        @map_tileset_4 = RPG::Cache_Tileset.load(@id, 3)
        tilesets_list.push(@map_tileset_2)
        tilesets_list.push(@map_tileset_3)
        tilesets_list.push(@map_tileset_4)
      end
    else # draw the data map and the tileset and save them in the Cache
      draw_map
    end

    # create vertical elements from tiles
    data_V = Data_Vertical_Sprites.new(viewport)
    # @vertical_sprites : list of vertical sprites (Sprite_V)
    @vertical_sprites = data_V.list_sprites_V
    # @vertical_sprites_animated : list of animated vertical sprites (Sprite_V)
    @vertical_sprites_animated = data_V.list_sprites_V_animated
    
    # angle of rotation (theta)
    self.theta = $game_system.neoM7_theta
    theta_rad = (Math::PI * theta) / 180
    # easier to work with integer value than floats ('>>' and '<<' operations)
    $game_temp.cos_theta = (2048 * Math.cos(theta_rad)).to_i
    $game_temp.sin_theta = (2048 * Math.sin(theta_rad)).to_i
    
    # offsets : equivalent to display_x and display_y
    @offset_x = 0
    @offset_y = 0

    $game_temp.distance_h = 480 # distance between the center of the map (halfwidth, pivot) and the point of view
    # screenline's number of the slant's pivot = y-coordinate of the rotation center
    $game_temp.pivot = $game_system.neoM7_pivot # character sprites
    $game_temp.pivot_map = $game_temp.pivot /
    ($game_system.neoM7_resolution == 1 ? 1 :
    ($game_system.neoM7_resolution == 2 ? 1.33 : 2)) # map sprite
     # distance between the center of the map (halfwidth, pivot) and the projection plane surface
    $game_temp.distance_p = $game_temp.distance_h - $game_temp.distance_h /
    ($game_system.neoM7_resolution == 1 ? 1 :
    ($game_system.neoM7_resolution == 2 ? 1.334 :  2))
    # zoom value of the map sprite
    @coeff_resolution = ($game_system.neoM7_resolution == 1 ? 1 :
    ($game_system.neoM7_resolution == 2 ? 1.334 : 2))
    # x-offset for the 3 resolutions
    @offset_x_res = ($game_system.neoM7_resolution == 1 ? 0 :
    ($game_system.neoM7_resolution == 2 ? 80 : 160))
    # y-offset for the 3 resolutions
    @offset_y_res = $game_temp.pivot - $game_temp.pivot_map
    @index_animated = 0 # 0..3 : index of animated tiles pattern
    
    # map sprite
    self.sprite = Sprite.new(@viewport)
    sprite.x = 0
    sprite.y = 0
    sprite.z = - 99999 # map must not mask vertical elements
    self.sprite_screen = Sprite.new(viewport)
    sprite_screen.x = 0
    sprite_screen.y = 0
    sprite_screen.z = - 99999
    if $game_system.neoM7_resolution != 1
      sprite.bitmap = ($game_system.neoM7_resolution == 2 ?
      Bitmap.new(480, 360) : Bitmap.new(320, 240))
    else
      sprite.bitmap = Bitmap.new(640, 480) # screen dimensions
    end
    sprite.zoom_x = @coeff_resolution
    sprite.zoom_y = @coeff_resolution
    if $game_system.neoM7Plus_always_same_res
      sprite_screen.bitmap = sprite.bitmap
      sprite_screen.zoom_x = @coeff_resolution
      sprite_screen.zoom_y = @coeff_resolution
    else
      sprite_screen.bitmap = Bitmap.new(640, 480)
    end

    # angle of slant (alpha)
    self.alpha = $game_system.neoM7_alpha
    refresh_alpha

  end
  #--------------------------------------------------------------------------
  # * Refresh all the parameters dependent on the angle of slant
  #--------------------------------------------------------------------------
  def refresh_alpha
    # angle of slant
    alpha_rad = (Math::PI * alpha) / 180
    $game_temp.cos_alpha = (2048 * Math.cos(alpha_rad)).to_i
    $game_temp.sin_alpha = (2048 * Math.sin(alpha_rad)).to_i
    $game_system.neoM7_alpha = alpha
    $game_system.neoM7_pivot = $game_temp.pivot
    # h0,  z0 : intermediate values used to calculate the slope
    h0 = (- ($game_temp.distance_h) * $game_temp.pivot *
    $game_temp.cos_alpha) / (($game_temp.distance_h << 11) +
    $game_temp.pivot * $game_temp.sin_alpha) + $game_temp.pivot
    z0 = ($game_temp.distance_h << 11).to_f /
    (($game_temp.distance_h << 11) + $game_temp.pivot * $game_temp.sin_alpha)
    # slope
    $game_temp.slope_value = (1.0 - z0) / ($game_temp.pivot - h0)
    $game_temp.slope_value_map = (131072 * $game_temp.slope_value).to_i
    $game_temp.corrective_value = 1.0 - $game_temp.pivot * $game_temp.slope_value
    $game_temp.corrective_value_map = (131072 * $game_temp.corrective_value / @coeff_resolution).to_i
    last_line = - $game_temp.pivot_map - $game_system.neoM7_horizon
    old_limit = $game_temp.neoM7_height_limit
    $game_temp.neoM7_height_limit = (($game_temp.distance_h - $game_temp.distance_p) *
    last_line * $game_temp.cos_alpha) / (($game_temp.distance_h << 11) -
    last_line * $game_temp.sin_alpha) + $game_temp.pivot_map
    if $game_system.neoM7_white_horizon
      @options[1] = $game_temp.neoM7_height_limit > 0 ? 1 : 0
    end
    $game_temp.neoM7_height_limit = [$game_temp.neoM7_height_limit.to_i, 0].max
    $game_temp.height_limit_sprites = $game_temp.neoM7_height_limit * @coeff_resolution
    @even = ((old_limit - $game_temp.neoM7_height_limit) & 1 == 0 ? @even : !@even)
    # delete lines beyond the new horizon
    sprite.bitmap.clean_limit(old_limit,
    $game_temp.neoM7_height_limit) if old_limit < $game_temp.neoM7_height_limit
    @need_update = true
  end
  #--------------------------------------------------------------------------
  # * Increase (or decrease) the angle of rotation
  #--------------------------------------------------------------------------
  def increase_theta(value)
    self.theta += value
    self.theta %= 360
    theta_rad = (Math::PI * theta) / 180
    $game_temp.cos_theta = (2048 * Math.cos(theta_rad)).to_i
    $game_temp.sin_theta = (2048 * Math.sin(theta_rad)).to_i
    $game_system.neoM7_theta = theta
    @need_update = true
  end
  #--------------------------------------------------------------------------
  # * Set the angle of rotation
  #--------------------------------------------------------------------------
  def set_theta(value)
    self.theta = value % 360
    theta_rad = (Math::PI * theta) / 180
    $game_temp.cos_theta = (2048 * Math.cos(theta_rad)).to_i
    $game_temp.sin_theta = (2048 * Math.sin(theta_rad)).to_i
    $game_system.neoM7_theta = theta
    @need_update = true
  end
  #--------------------------------------------------------------------------
  # * Increase (or decrease) the zoom level
  #--------------------------------------------------------------------------
  def increase_zoom(value)
    increase_zoom_neoM7Plus_tilemap(value)
    @need_update = true
  end
  #--------------------------------------------------------------------------
  # * Set the zoom level
  #--------------------------------------------------------------------------
  def set_zoom(value)
    set_zoom_neoM7Plus_tilemap(value)
    @need_update = true
  end
  #--------------------------------------------------------------------------
  # * Update the map sprite and the vertical sprites
  #--------------------------------------------------------------------------
  def update
    @offset_x = $game_map.display_x / 4 + @offset_x_res
    @offset_y = $game_map.display_y / 4 + @offset_y_res
    if !@need_update && (@offset_x != @offset_x_old || @offset_y != @offset_y_old)
      @offset_x_old = @offset_x
      @offset_y_old = @offset_y
      @need_update = true
    end
    if @need_update
      @need_update_anim = false
      sprite_screen.visible = false
      sprite.visible = true
      # update map sprite
      if $game_system.neoM7_filter
        @even = !@even
        @need_update = @even
        @options[2] = @even ? 1 : 2
      else
        @need_update = false
      end
      sprite.bitmap.neoM7(@map_tileset, @bitmap_data, @width, @height, @offset_x, @offset_y, @options)
      
      # update vertical sprites
      for vertical_sprite in @vertical_sprites
        vertical_sprite.update
      end
      @need_update_screen = true
    elsif @need_update_screen || @need_update_anim
      sprite_screen.visible = true
      sprite.visible = false
      @options[2] = 0
      sprite_screen.bitmap.clear
      if $game_system.neoM7Plus_always_same_res
        sprite_screen.bitmap.neoM7(@map_tileset, @bitmap_data, @width, @height, @offset_x, @offset_y, @options)
      else
        sprite_screen.bitmap.neoM7_screen(@map_tileset, @bitmap_data, @width, @height,
        $game_map.display_x / 4, $game_map.display_y / 4, @options)
      end
      @need_update_screen = false
      @need_update_anim = false
    end
  end
  #--------------------------------------------------------------------------
  # * Update animation for animated tiles
  #--------------------------------------------------------------------------
  def update_animated
    update_animated_neoM7Plus_tilemap
    @need_update_anim = true
  end
end

DLL : MGCmode7+.dll