ruby-gr 0.0.3 → 0.0.4

data/lib/gr/ffi.rb

@@ -3,6 +3,7 @@
 require 'ffi'
 
 module GR
+  # FFI Wrapper module for GR
   module FFI
     extend ::FFI::Library
 
@@ -191,5 +192,7 @@ module GR
     attach_function :gr_shadelines, %i[int pointer pointer int int int], :void
     attach_function :gr_panzoom, %i[double double double double pointer pointer pointer pointer], :void
     # attach_function :gr_findboundary
+    attach_function :gr_setresamplemethod, %i[uint], :void
+    attach_function :gr_inqresamplemethod, %i[pointer], :void
   end
 end

data/lib/gr3.rb

@@ -71,6 +71,11 @@ module GR3
     end
 
     # This function allows the user to find out how his commands are rendered.
+    # If gr3 is initialized, a string in the format:
+    # `"gr3 - " + window toolkit + " - " + framebuffer extension + " - " + OpenGL version + " - " + OpenGL renderer string`.
+    # For example `"gr3 - GLX - GL_ARB_framebuffer_object - 2.1 Mesa 7.10.2 - Software Rasterizer"`
+    # might be returned on a Linux system (using GLX) with an available GL_ARB_framebuffer_object implementation.
+    # If gr3 is not initialized `"Not initialized"` is returned.
     def getrenderpathstring(*)
       super
     end
@@ -85,14 +90,20 @@ module GR3
       super
     end
 
+    # Use the currently bound framebuffer as the framebuffer used for drawing to OpenGL (using gr3.drawimage).
+    # This function is only needed when you do not want to render to 0, the default framebuffer.
     def usecurrentframebuffer(*)
       super
     end
 
+    # Set the framebuffer used for drawing to OpenGL (using gr3.drawimage).
+    # This function is only needed when you do not want to render to 0, the default framebuffer.
     def useframebuffer(*)
       super
     end
 
+    # Set rendering quality
+    # @param quality [] The quality to set
     def setquality(*)
       super
     end
@@ -121,9 +132,15 @@ module GR3
     end
 
     # This function creates a int from vertex position, normal and color data.
-    def createmesh(_n, vertices, normals, colors)
+    # Returns a mesh.
+    # @param n [Integer] the number of vertices in the mesh
+    # @param vertices [Array, NArray] the vertex positions
+    # @param normals [Array, NArray] the vertex normals
+    # @param colors [Array, NArray] the vertex colors,
+    #  they should be white (1,1,1) if you want to change the color for each drawn mesh
+    def createmesh(n, vertices, normals, colors)
       inquiry_int do |mesh|
-        super(mesh, vertices, normals, colors)
+        super(mesh, n, vertices, normals, colors)
       end
     end
 
@@ -134,31 +151,63 @@ module GR3
       end
     end
 
-    # This function creates a int from vertex position, normal and color data.
+    # This function creates an indexed mesh from vertex information (position,
+    # normal and color) and triangle information (indices).
+    # Returns a mesh.
+    # @param num_vertices [Integer] the number of vertices in the mesh
+    # @param vertices [Array, NArray] the vertex positions
+    # @param normals [Array, NArray] the vertex normals
+    # @param colors [Array, NArray] the vertex colors,
+    #  they should be white (1,1,1) if you want to change the color for each drawn mesh
+    # @param num_indices [Integer] the number of indices in the mesh (three times the number of triangles)
+    # @param indices [Array, NArray] the index array (vertex indices for each triangle)
     def createindexedmesh(num_vertices, vertices, normals, colors, num_indices, indices)
       inquiry_int do |mesh|
         super(mesh, num_vertices, vertices, normals, colors, num_indices, indices)
       end
     end
 
-    # This function adds a mesh to the draw list, so it will be drawn when the user calls gr3_getpixmap.
+    # This function adds a mesh to the draw list, so it will be drawn when the user calls getpixmap.
+    # The given data stays owned by the user, a copy will be saved in the draw list and the mesh reference counter will be increased.
+    # @param mesh [Integer] The mesh to be drawn
+    # @param n [Integer] The number of meshes to be drawn
+    # @param positions [Array, NArray] The positions where the meshes should be drawn
+    # @param directions [Array, NArray] The forward directions the meshes should be facing at
+    # @param ups [Array, NArray] The up directions
+    # @param colors [Array, NArray] The colors the meshes should be drawn in, it will be multiplied with each vertex color
+    # @param scales [Array, NArray] The scaling factors
     def drawmesh(*)
       super
     end
 
     # This function marks a mesh for deletion and removes the user’s reference from the mesh’s referenc counter,
     # so a user must not use the mesh after calling this function.
+    # @param mesh [Integer] The mesh that should be marked for deletion
     def deletemesh(*)
       super
     end
 
     # This function sets the view matrix by getting the position of the camera,
     # the position of the center of focus and the direction which should point up.
+    # @param  camera_x [Array, NArray] The x-coordinate of the camera
+    # @param  camera_y [Array, NArray] The y-coordinate of the camera
+    # @param  camera_z [Array, NArray] The z-coordinate of the camera
+    # @param  center_x [Array, NArray] The x-coordinate of the center of focus
+    # @param  center_y [Array, NArray] The y-coordinate of the center of focus
+    # @param  center_z [Array, NArray] The z-coordinate of the center of focus
+    # @param  up_x [Array, NArray] The x-component of the up direction
+    # @param  up_y [Array, NArray] The y-component of the up direction
+    # @param  up_z [Array, NArray] The z-component of the up direction
     def cameralookat(*)
       super
     end
 
     # This function sets the projection parameters.
+    # This function takes effect when the next image is created.
+    # @param vertical_field_of_view [Numeric] This parameter is the vertical field of view in degrees.
+    #  It must be greater than 0 and less than 180.
+    # @param zNear [Numeric] The distance to the near clipping plane.
+    # @param zFar [Numeric] The distance to the far clipping plane.
     def setcameraprojectionparameters(*)
       super
     end
@@ -169,6 +218,10 @@ module GR3
     end
 
     # This function sets the direction of light.
+    # If it is called with (0, 0, 0), the light is always pointing into the same direction as the camera.
+    # @param x [Numeric] The x-component of the light's direction
+    # @param y [Numeric] The y-component of the light's direction
+    # @param z [Numeric] The z-component of the light's direction
     def setlightdirection(*)
       super
     end
@@ -186,14 +239,17 @@ module GR3
       super
     end
 
+    # This function allows drawing a cylinder without requiring a mesh.
     def drawconemesh(*)
       super
     end
 
+    # This function allows drawing a cylinder without requiring a mesh.
     def drawcylindermesh(*)
       super
     end
 
+    # This function allows drawing a sphere without requiring a mesh.
     def drawspheremesh(*)
       super
     end
@@ -218,10 +274,12 @@ module GR3
       super
     end
 
+    # the current projection type: GR3_PROJECTION_PERSPECTIVE or GR3_PROJECTION_PARALLEL
     def getprojectiontype(*)
       super
     end
 
+    # @param type [Integer] the new projection type: GR3_PROJECTION_PERSPECTIVE or GR3_PROJECTION_PARALLEL
     def setprojectiontype(*)
       super
     end
@@ -229,40 +287,74 @@ module GR3
     # This function creates an isosurface from voxel data using the
     # marching cubes algorithm.
     # Returns a mesh.
+    # @param grid [NArray] 3D narray array containing the voxel data
+    # @param step [Array] voxel sizes in each direction
+    # @param offset [Array] coordinate origin in each direction
+    # @param isolevel [Integer] isovalue at which the surface will be created
     def createisosurfacemesh(grid, step, offset, isolevel)
-      dim_x, dim_y, dim_z = grid.shape
-      step_x, step_y, step_z = step
-      offset_x, offset_y, offset_z = offset
-      # NArray does not have the strides method
-      bytesize = grid.class.byte_size
-      stride_x =  1
-      stride_y =  dim_y
-      stride_z =  dim_y * dim_z
-      # stride_x, stride_y, stride_z = stride
+      args = _preprocess_createslicemesh(grid, step, offset)
+      grid = args.shift
       inquiry_int do |mesh|
-        super(mesh, uint16(grid), isolevel, dim_x, dim_y, dim_z,
-        stride_x, stride_y, stride_z, step_x, step_y, step_z, offset_x, offset_y, offset_z)
+        super(mesh, uint16(grid), isolevel, *args)
       end
     end
 
     # Create a mesh of a surface plot similar to gr_surface.
+    # Uses the current colormap. To apply changes of the colormap
+    # a new mesh has to be created.
+    # @param nx [Integer] number of points in x-direction
+    # @param ny [Integer] number of points in y-direction
+    # @param px [Array, NArray] an array containing the x-coordinates
+    # @param py [Array, NArray] an array containing the y-coordinates
+    # @param pz [Array, NArray] an array of length nx * ny containing the z-coordinates
+    # @param option [Integer] option for the surface mesh; the GR3_SURFACE constants can be combined with bitwise or. See the table below.
+    #  * 0  : GR3_SURFACE_DEFAULT
+    #    *    default behavior
+    #  * 1  : GR3_SURFACE_NORMALS
+    #    *    interpolate the vertex normals from the gradient
+    #  * 2  : GR3_SURFACE_FLAT
+    #    *    set all z-coordinates to zero
+    #  * 4  : GR3_SURFACE_GRTRANSFORM
+    #    *    use gr_inqwindow, gr_inqspace and gr_inqscale to transform the data to NDC coordinates
+    #  * 8  : GR3_SURFACE_GRCOLOR
+    #    *    color the surface according to the current gr colormap
+    #  * 16 : GR3_SURFACE_GRZSHADED
+    #    *    like GR3_SURFACE_GRCOLOR, but use the z-value directly as color index
     def createsurfacemesh(nx, ny, px, py, pz, option = 0)
       inquiry_int do |mesh|
         super(mesh, nx, ny, px, py, pz, option)
       end
     end
 
-    # Draw a mesh with the projection of gr.
+    # Draw a mesh with the projection of gr. It uses the current
+    # projection parameters (rotation, tilt) of gr.
+    # This function alters the projection type, the projection parameters,
+    # the viewmatrix and the light direction. If necessary, the user has to
+    # save them before the call to this function and restore them after
+    # the call to gr3_drawimage.
+    # @param mesh [Integer] the mesh to be drawn
+    # @param n [Integer] the number of meshes to be drawn
+    # @param positions [Array, NArray] the positions where the meshes should be drawn
+    # @param directions [Array, NArray] the forward directions the meshes should be facing at
+    # @param ups [Array, NArray] the up directions
+    # @param colors [Array, NArray] the colors the meshes should be drawn in, it will be multiplied with each vertex color
+    # @param scales [Array, NArray] the scaling factors
     def drawmesh_grlike(*)
       super
     end
 
     # Convenience function for drawing a surfacemesh.
+    # @param mesh [Integer] the mesh to be drawn
     def drawsurface(*)
       super
     end
 
     # Create a surface plot with gr3 and draw it with gks as cellarray.
+    # @param px [Array, NArray] an array containing the x-coordinates
+    # @param py [Array, NArray] an array containing the y-coordinates
+    # @param pz [Array, NArray] an array of length nx * ny containing the z-coordinates
+    # @param option [Integer] see the option parameter of gr_surface.
+    #  OPTION_COLORED_MESH and OPTION_Z_SHADED_MESH are supported.
     def surface(px, py, pz, _option)
       nx = px.length
       ny = py.length
@@ -271,11 +363,28 @@ module GR3
     end
 
     # drawtubemesh
+    # Draw a tube following a path given by a list of points. The colors and
+    # radii arrays specify the color and radius at each point.
+    # @param n [Integer] the number of points given
+    # @param points [Array, NArray] the points the tube should go through
+    # @param colors [Array, NArray] the color at each point
+    # @param radii [Array, NArray]  the desired tube radius at each point
+    # @param num_steps [Integer] the number of steps between each point, allowing for a more smooth tube
+    # @param num_segments [Integer] the number of segments each ring of the tube consists of,
+    #  e.g. 3 would yield a triangular tube
     def drawtubemesh(n, points, colors, radii, num_steps = 10, num_segments = 20)
       super(n, points, colors, radii, num_steps, num_segments)
     end
 
-    # createtubemesh
+    # Create a mesh object in the shape of a tube following a path given by a
+    # list of points. The colors and radii arrays specify the color and radius at
+    # each point.
+    # @param n [Integer] the number of points given
+    # @param points [Array, NArray] the points the tube should go through
+    # @param colors [Array, NArray] the color at each point
+    # @param radii [Array, NArray] the desired tube radius at each point
+    # @param num_steps [Integer] the number of steps between each point, allowing for a more smooth tube
+    # @param num_segments [Integer] the number of segments each ring of the tube consists of, e.g. 3 would yield a triangular tube
     def createtubemesh(n, points, colors, radii, num_steps = 10, num_segments = 20)
       inquiry_uint do |mesh| # mesh should be Int?
         super(mesh, n, points, colors, radii, num_steps, num_segments)
@@ -349,69 +458,38 @@ module GR3
     # drawn and at which positions they should go through the data. If neither
     # x nor y nor z are set, 0.5 will be used for all three.
     # Returns meshes for the yz-slice, the xz-slice and the xy-slice.
+    # @param grid [NArray] 3D narray array containing the voxel data
+    # @param x [Numeric] the position of the slice through the xz-plane (0 to 1)
+    # @param y [Numeric] the position of the slice through the xz-plane (0 to 1)
+    # @param z [Numeric] the position of the slice through the xz-plane (0 to 1)
+    # @param step [Array] voxel sizes in each direction
+    # @param offset [Array] coordinate origin in each direction
     def createslicemeshes(grid, x = nil, y = nil, z = nil, step = nil, offset = nil)
       if [x, y, z].all?(&:nil?)
         x = 0.5
         y = 0.5
         z = 0.5
       end
-      _mesh_x = (createxslicemesh(grid, x, step, offset) if x)
-      _mesh_y = (createyslicemesh(grid, y, step, offset) if y)
-      _mesh_z = (createzslicemesh(grid, z, step, offset) if z)
-      [_mesh_x, _mesh_y, _mesh_z]
-    end
-
-    def preprocess_createslicemesh(grid, step, offset)
-      # TODO: raise error when grid is not narray
-      # grid
-      case grid.class::MAX
-      when Integer
-        input_max = grid.class::MAX
-      when Float
-        # floating point values are expected to be in range [0, 1]
-        # Complex narrays are not taken into account
-        input_max = 1
-        grid[grid > 1] = 1
-      else
-        raise ArgumentError, 'grid must be three dimensional array of Real numbers'
-      end
-      scaling_factor = Numo::UInt16::MAX / input_max.to_f
-      grid = (grid.cast_to(Numo::UInt64) * scaling_factor).cast_to(Numo::UInt16) # room for improvement
-
-      # step & offset
-      nx, ny, nz = grid.shape
-      if step.nil? && offset.nil?
-        step = [2.0 / (nx - 1), 2.0 / (ny - 1), 2.0 / (nz - 1)]
-        offset = [-1.0, -1.0, -1.0]
-      elsif offset.nil?
-        offset = [-step[0] * (nx - 1) / 2.0,
-                  -step[1] * (ny - 1) / 2.0,
-                  -step[2] * (nz - 1) / 2.0]
-      elsif step.nil?
-        step = [-offset[0] * 2.0 / (nx - 1),
-                -offset[1] * 2.0 / (ny - 1),
-                -offset[2] * 2.0 / (nz - 1)]
-      end
-
-      step_x, step_y, step_z = step
-      offset_x, offset_y, offset_z = offset
-
-      [grid, nx, ny, nz, step_x, step_y, step_z, offset_x, offset_y, offset_z]
+      mesh_x = (createxslicemesh(grid, x, step, offset) if x)
+      mesh_y = (createyslicemesh(grid, y, step, offset) if y)
+      mesh_z = (createzslicemesh(grid, z, step, offset) if z)
+      [mesh_x, mesh_y, mesh_z]
     end
 
     # Creates a meshes for a slices through the yz-plane of the given data,
     # using the current GR colormap. Use the x parameter to set the position of
     # the yz-slice.
     # Returns a mesh for the yz-slice.
+    # @param grid [NArray] 3D narray array containing the voxel data
+    # @param x [Numeric] the position of the slice through the xz-plane (0 to 1)
+    # @param step [Array] voxel sizes in each direction
+    # @param offset [Array] coordinate origin in each direction
     def createxslicemesh(grid, x = 0.5, step = nil, offset = nil)
-      grid, nx, ny, nz, step_x, step_y, step_z, offset_x, offset_y, offset_z = preprocess_createslicemesh(grid, step, offset)
-      x = (x.clamp(0, 1) * nx).floor
-      stride_x = 1
-      stride_y = ny
-      stride_z = ny * nz
+      args = _preprocess_createslicemesh(grid, step, offset)
+      grid = args.shift
+      x = (x.clamp(0, 1) * args[0]).floor
       inquiry_int do |mesh|
-        super(mesh, grid, x, nx, ny, nz, stride_x, stride_y, stride_z,
-              step_x, step_y, step_z, offset_x, offset_y, offset_z)
+        super(mesh, uint16(grid), x, *args)
       end
     end
 
@@ -419,15 +497,16 @@ module GR3
     # using the current GR colormap. Use the y parameter to set the position of
     # the xz-slice.
     # Returns a mesh for the xz-slice.
+    # @param grid [NArray] 3D narray array containing the voxel data
+    # @param y [Numeric] the position of the slice through the xz-plane (0 to 1)
+    # @param step [Array] voxel sizes in each direction
+    # @param offset [Array] coordinate origin in each direction
     def createyslicemesh(grid, y = 0.5, step = nil, offset = nil)
-      grid, nx, ny, nz, step_x, step_y, step_z, offset_x, offset_y, offset_z = preprocess_createslicemesh(grid, step, offset)
-      y = (y.clamp(0, 1) * ny).floor
-      stride_x = nx
-      stride_y = 1
-      stride_z = nx * nz
+      args = _preprocess_createslicemesh(grid, step, offset)
+      grid = args.shift
+      y = (y.clamp(0, 1) * args[1]).floor
       inquiry_int do |mesh|
-        super(mesh, grid, y, nx, ny, nz, stride_x, stride_y, stride_z,
-              step_x, step_y, step_z, offset_x, offset_y, offset_z)
+        super(mesh, uint16(grid), y, *args)
       end
     end
 
@@ -435,19 +514,29 @@ module GR3
     # using the current GR colormap. Use the z parameter to set the position of
     # the xy-slice.
     # Returns a mesh for the xy-slice.
+    # @param grid [NArray] 3D narray array containing the voxel data
+    # @param z [Numeric] the position of the slice through the xz-plane (0 to 1)
+    # @param step [Array] voxel sizes in each direction
+    # @param offset [Array] coordinate origin in each direction
     def createzslicemesh(grid, z = 0.5, step = nil, offset = nil)
-      grid, nx, ny, nz, step_x, step_y, step_z, offset_x, offset_y, offset_z = preprocess_createslicemesh(grid, step, offset)
-      z = (z.clamp(0, 1) * nz).floor
-      stride_x = ny * nz
-      stride_y = ny
-      stride_z = 1
+      args = _preprocess_createslicemesh(grid, step, offset)
+      grid = args.shift
+      z = (z.clamp(0, 1) * args[2]).floor
       inquiry_int do |mesh|
-        super(mesh, grid, z, nx, ny, nz, stride_x, stride_y, stride_z,
-              step_x, step_y, step_z, offset_x, offset_y, offset_z)
+        super(mesh, uint16(grid), z, *args)
       end
     end
 
     # Draw a yz-slice through the given data, using the current GR colormap.
+    # @param grid [NArray] 3D narray array containing the voxel data
+    # @param x [Numeric] the position of the slice through the yz-plane (0 to 1)
+    # @param step [Array] voxel sizes in each direction
+    # @param offset [Array] coordinate origin in each direction
+    # @param position [Array] the positions where the meshes should be drawn
+    # @param direction [Array] the forward directions the meshes should be facing at
+    # @param up [Array] the up directions
+    # @param color [Array] the colors the meshes should be drawn in, it will be multiplied with each vertex color
+    # @param scale [Array] the scaling factors
     def drawxslicemesh(grid, x = 0.5, step = nil, offset = nil,
                        position = [0, 0, 0], direction = [0, 0, 1], up = [0, 1, 0],
                        color = [1, 1, 1], scale = [1, 1, 1])
@@ -457,6 +546,15 @@ module GR3
     end
 
     # Draw a xz-slice through the given data, using the current GR colormap.
+    # @param grid [NArray] 3D narray array containing the voxel data
+    # @param y [Numeric] the position of the slice through the xz-plane (0 to 1)
+    # @param step [Array] voxel sizes in each direction
+    # @param offset [Array] coordinate origin in each direction
+    # @param position [Array] the positions where the meshes should be drawn
+    # @param direction [Array] the forward directions the meshes should be facing at
+    # @param up [Array] the up directions
+    # @param color [Array] the colors the meshes should be drawn in, it will be multiplied with each vertex color
+    # @param scale [Array] the scaling factors
     def drawyslicemesh(grid, y = 0.5, step = nil, offset = nil,
                        position = [0, 0, 0], direction = [0, 0, 1], up = [0, 1, 0],
                        color = [1, 1, 1], scale = [1, 1, 1])
@@ -466,6 +564,15 @@ module GR3
     end
 
     # Draw a xy-slice through the given data, using the current GR colormap.
+    # @param grid [NArray] 3D narray array containing the voxel data
+    # @param z [Numeric] the position of the slice through the xy-plane (0 to 1)
+    # @param step [Array] voxel sizes in each direction
+    # @param offset [Array] coordinate origin in each direction
+    # @param position [Array] the positions where the meshes should be drawn
+    # @param direction [Array] the forward directions the meshes should be facing at
+    # @param up [Array] the up directions
+    # @param color [Array] the colors the meshes should be drawn in, it will be multiplied with each vertex color
+    # @param scale [Array] the scaling factors
     def drawzslicemesh(grid, z = 0.5, step = nil, offset = nil,
                        position = [0, 0, 0], direction = [0, 0, 1], up = [0, 1, 0],
                        color = [1, 1, 1], scale = [1, 1, 1])
@@ -478,6 +585,17 @@ module GR3
     # Use the parameters x, y or z to specify what slices should be drawn and at
     # which positions they should go through the data. If neither x nor y nor
     # z are set, 0.5 will be used for all three.
+    # @param grid [NArray] 3D narray array containing the voxel data
+    # @param x [Numeric] the position of the slice through the yz-plane (0 to 1)
+    # @param y [Numeric] the position of the slice through the xz-plane (0 to 1)
+    # @param z [Numeric] the position of the slice through the xy-plane (0 to 1)
+    # @param step [Array] voxel sizes in each direction
+    # @param offset [Array] coordinate origin in each direction
+    # @param position [Array] the positions where the meshes should be drawn
+    # @param direction [Array] the forward directions the meshes should be facing at
+    # @param up [Array] the up directions
+    # @param color [Array] the colors the meshes should be drawn in, it will be multiplied with each vertex color
+    # @param scale [Array] the scaling factors
     def drawslicemeshes(grid, x = nil, y = nil, z = nil, step = nil,
                         offset = nil, position = [0, 0, 0], direction = [0, 0, 1], up = [0, 1, 0],
                         color = [1, 1, 1], scale = [1, 1, 1])
@@ -500,14 +618,59 @@ module GR3
         super(nx, ny, nz, data, algorithm, dmin, dmax)
       end
     end
-  end
 
-  # Constants - imported from GR.jl
+    private
+
+    def _preprocess_createslicemesh(grid, step, offset)
+      # TODO: raise error when grid is not narray
+      # grid
+      case grid.class::MAX
+      when Integer
+        input_max = grid.class::MAX
+      when Float
+        # floating point values are expected to be in range [0, 1]
+        # Complex narrays are not taken into account
+        input_max = 1
+        grid[grid > 1] = 1
+      else
+        raise ArgumentError, 'grid must be three dimensional array of Real numbers'
+      end
+      scaling_factor = Numo::UInt16::MAX / input_max.to_f
+      grid = (grid.cast_to(Numo::UInt64) * scaling_factor).cast_to(Numo::UInt16) # room for improvement
+
+      # step & offset
+      nx, ny, nz = grid.shape
+      if step.nil? && offset.nil?
+        step = [2.0 / (nx - 1), 2.0 / (ny - 1), 2.0 / (nz - 1)]
+        offset = [-1.0, -1.0, -1.0]
+      elsif offset.nil?
+        offset = [-step[0] * (nx - 1) / 2.0,
+                  -step[1] * (ny - 1) / 2.0,
+                  -step[2] * (nz - 1) / 2.0]
+      elsif step.nil?
+        step = [-offset[0] * 2.0 / (nx - 1),
+                -offset[1] * 2.0 / (ny - 1),
+                -offset[2] * 2.0 / (nz - 1)]
+      end
+
+      step_x, step_y, step_z = step
+      offset_x, offset_y, offset_z = offset
+
+      # strides
+      stride_x = ny * nz
+      stride_y = nz
+      stride_z = 1
+
+      [grid, nx, ny, nz, stride_x, stride_y, stride_z, step_x, step_y, step_z, offset_x, offset_y, offset_z]
+    end
+  end
 
+  # InitAttribute
   IA_END_OF_LIST = 0
   IA_FRAMEBUFFER_WIDTH = 1
   IA_FRAMEBUFFER_HEIGHT = 2
 
+  # Error
   ERROR_NONE = 0
   ERROR_INVALID_VALUE = 1
   ERROR_INVALID_ATTRIBUTE = 2
@@ -520,6 +683,7 @@ module GR3
   ERROR_CANNOT_OPEN_FILE = 9
   ERROR_EXPORT = 10
 
+  # Quality
   QUALITY_OPENGL_NO_SSAA  = 0
   QUALITY_OPENGL_2X_SSAA  = 2
   QUALITY_OPENGL_4X_SSAA  = 4
@@ -531,9 +695,11 @@ module GR3
   QUALITY_POVRAY_8X_SSAA  = 8 + 1
   QUALITY_POVRAY_16X_SSAA = 16 + 1
 
+  # Drawable
   DRAWABLE_OPENGL = 1
   DRAWABLE_GKS = 2
 
+  # SurfaceOption
   SURFACE_DEFAULT     =  0
   SURFACE_NORMALS     =  1
   SURFACE_FLAT        =  2