Help-Site Computer Manuals
Software
Hardware
Programming
Networking
  Algorithms & Data Structures   Programming Languages   Revision Control
  Protocols
  Cameras   Computers   Displays   Keyboards & Mice   Motherboards   Networking   Printers & Scanners   Storage
  Windows   Linux & Unix   Mac

Image.pod

OpenGL::Image - copyright 2007 Graphcomp - ALL RIGHTS RESERVED Author: Bob "grafman" Free - grafman@graphcomp.com Contributor: Geoff Broadwell


NAME


  OpenGL::Image - copyright 2007 Graphcomp - ALL RIGHTS RESERVED

  Author: Bob "grafman" Free - grafman@graphcomp.com

  Contributor: Geoff Broadwell

  This program is free software; you can redistribute it and/or

  modify it under the same terms as Perl itself.


DESCRIPTION


  This module is an extensible wrapper to abstract imaging interfaces

  By default, this module uses the OpenGL::Image::Targa module; support for

  other imaging libraries may be added by providing plug-in modules

  in the OpenGL/Image folder.

  An OpenGL::Image::Magick module is also provided for use with

  PerlMagick.  For best performance, ImageMagick 6.3.5 or newer should

  be installed.


SYNOPSIS


  ##########

  # Check for installed imaging engines

  use OpenGL::Image;

  # Get hashref of installed imaging engines

  # Keys are engine names; values are info hashes, including version,

  # priority (1 .. n, 1 is highest), module (Perl module name)

  # and description.

  # Priority can be set using Engines.lst (see INSTALL); otherwise

  # 'Targa' has top priority, and others are in unspecified order.

  my $engine_hashref = OpenGL::Image::GetEngines();

  # In list context, returns list of info hashes sorted by engine

  # priority; info hash does not include a priority value.

  my @sorted_engine_info = OpenGL::Image::GetEngines();

  # Check for a specific engine and optional version support

  # Returns an info hashref for the engine if available; otherwise undef.

  my $info_hashref = OpenGL::Image::HasEngine('Magick','6.3.5');

  ##########

  # Load texture - defaults to highest priority engine if none specified;

  # if Engines.lst is not specified, the highest priority is the Targa engine.

  my $tex = new OpenGL::Image(source=>'test.tga');

  # Get GL info

  my($ifmt,$fmt,$type) = $tex->Get('gl_internalformat','gl_format','gl_type');

  my($w,$h) = $tex->Get('width','height');

  # Test if power of 2

  if (!$tex->PowerOf2()) return;

  # Set texture  

  glTexImage2D_c(GL_TEXTURE_2D, 0, $ifmt, $w, $h, 0, $fmt, $type, $tex->Ptr());

  ##########

  # Modify GL frame using ImageMagick

  my $frame = new OpenGL::Image(engine=>'Magick',width=>$w,height=>$h);

  # Get default GL info

  my($def_fmt,$def_type) = $tex->Get('gl_format','gl_type');

  # Read frame pixels

  glReadPixels_c(0, 0, $width, $height, $def_fmt, $def_type, $frame->Ptr());

  # Sync cache

  $frame->Sync();

  # Modify frame pixels

  $frame->Native->Blur();

  # Draw back to frame

  glDrawPixels_c(0, 0, $width, $height, $def_fmt, $def_type, $frame->Ptr());

  ##########

  # Save GL frame

  my $image = new OpenGL::Image(width=>$width,height=>$height);

  # Read frame pixels

  glReadPixels_c(0, 0, $width, $height, $def_fmt, $def_type, $image->Ptr());

  # Save file - automatically does a Sync before write

  $image->Save('MyImage.tga');

  ##########

  # Get/Set normalized pixels

  my($r,$g,$b,$a) = $img->GetPixel($x,$y);

  $img->SetPixel($x,$y, 1.0, 0.5, 0.0, 1.0);

  # Sync cache after done modifying pixels

  $frame->Sync();

  ##########

  # Methods defined in OpenGL::Image::Common:

  # Get native engine object

  my $obj = $img->Native;

  $obj->Quantize() if ($obj);

  # Alternately (Assuming the native engine supports Blur):

  $img->Native->Blur();

  # Test if image width is a power of 2

  if ($img->IsPowerOf2());

  # Test if all listed values are a power of 2

  if ($img->IsPowerOf2(@list));

  # Get largest power of 2 size within dimensions of image

  my $size = $img->GetPowerOf2();

  # Get one or more parameter values

  my @values = $img->Get(@params);

  # Return the image's cache as an OpenGL::Array object.

  # Note: OGA may change after a cache update

  my $oga = $img->GetArray();

  # Return a C pointer to the image's cache.

  # For use with OpenGL's "_c" APIs.

  # Note: pointer may change after a cache update

  $img->Ptr();

  ##########

  # Supported parameters:

  # version - version of the engine

  # source - source image, if defined

  # width - width of image in pixels

  # height - height of image in pixels

  # pixels - number of pixels

  # components - number of pixel components

  # size - bytes per component

  # length - cache size in bytes

  # endian - 1 if big endian; otherwise 0

  # alpha - 1: normal alpha channel, -1: inverted alpha channel; 0: none

  # flipped - 1 bit set if cache ordered top to bottom; others reserved

  # gl_internalformat - internal GL pixel format. eg: GL_RGBA8, GL_RGBA16

  # gl_format - GL pixel format. eg: GL_RGBA, GL_BGRA

  # gl_type - GL data type.  eg: GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT

  ##########

  # APIs and Methods defined in engine modules:

  # Get engine version

  my $ver = OpenGL::Image::ENGINE_MODULE::EngineVersion();

  # Sync the image cache after a write.

  # Used by some engines for paged caches; otherwise a NOP.

  $img->Sync();

  # Save the image to a PNG file (assuming the engine supports PNGs)

  $img->Save('MyImage.png');

  # Get image blob.

  my $blob = $img->GetBlob();
Programminig
Wy
Wy
yW
Wy
Programming
Wy
Wy
Wy
Wy