Click here to Skip to main content
Click here to Skip to main content
Add your own
alternative version

OAG Library (OpenGL) Part 1 - Setting Up the Library for an MFC Application

, 7 Aug 2011
OAG is a library written in C++. With this library, you can create OpenGL based applications.
freetype-2311.zip
freetype-2.3.11
vms_make.com
ChangeLog.20
version.sed
Jamrules
Jamfile
configure
docs
reference
README
INSTALL.CROSS
INSTALL.MAC
TRUETYPE
MAKEPP
INSTALL
INSTALL.ANY
release
UPGRADE.UNIX
INSTALL.UNIX
VERSION.DLL
INSTALL.VMS
DEBUG
PROBLEMS
CUSTOMIZE
TODO
PATENTS
CHANGES
INSTALL.GNU
objs
README
builds
modules.mk
exports.mk
freetype.mk
link_std.mk
toplevel.mk
os2
os2-gcc.mk
os2-def.mk
os2-dev.mk
detect.mk
ansi
ansi-def.mk
ansi.mk
symbian
freetype.mmp
bld.inf
win32
w32-dev.mk
vc2005
w32-lcc.mk
vc2008
w32-intl.mk
w32-bccd.mk
w32-wat.mk
w32-icc.mk
w32-mingw32.mk
w32-bcc.mk
w32-gcc.mk
detect.mk
win32-def.mk
visualce
freetype.dsp
freetype.dsw
visualc
freetype.dsp
freetype.dsw
w32-vcc.mk
atari
gen-purec-patch.sh
FREETYPE.PRJ
FNames.SIC
deflinejoiner.awk
unix
ltmain.sh
config.sub
ftconfig.in
configure
mkinstalldirs
freetype2.m4
unixddef.mk
freetype2.in
install-sh
configure.ac
ft-munmap.m4
unix-cc.in
freetype-config.in
unix.mk
unix-def.in
unix-dev.mk
detect.mk
aclocal.m4
unix-lcc.mk
config.guess
configure.raw
install.mk
beos
beos.mk
beos-def.mk
detect.mk
newline
amiga
makefile.os4
makefile
smakefile
include
freetype
config
README
src
base
detect.mk
vms
compiler
watcom.mk
intelc.mk
visualc.mk
visualage.mk
ansi-cc.mk
win-lcc.mk
bcc-dev.mk
gcc.mk
gcc-dev.mk
emx.mk
unix-lcc.mk
bcc.mk
dos
dos-gcc.mk
dos-def.mk
dos-wat.mk
detect.mk
dos-emx.mk
link_dos.mk
mac
README
wince
vc2008-ce
vc2005-ce
ChangeLog.22
include
freetype
config
internal
services
ChangeLog.21
autogen.sh
README
README.git
devel
src
type1
Jamfile
module.mk
rules.mk
sfnt
Jamfile
module.mk
rules.mk
Jamfile
psnames
Jamfile
module.mk
rules.mk
truetype
Jamfile
module.mk
rules.mk
tools
Jamfile
ftrandom
README
Makefile
docmaker
otvalid
Jamfile
module.mk
rules.mk
pcf
Jamfile
module.mk
README
rules.mk
raster
Jamfile
module.mk
rules.mk
base
Jamfile
rules.mk
lzw
Jamfile
rules.mk
gxvalid
Jamfile
module.mk
README
rules.mk
cache
Jamfile
rules.mk
psaux
Jamfile
module.mk
rules.mk
winfonts
Jamfile
module.mk
rules.mk
type42
Jamfile
module.mk
rules.mk
cff
Jamfile
module.mk
rules.mk
pfr
Jamfile
module.mk
rules.mk
gzip
Jamfile
rules.mk
pshinter
Jamfile
module.mk
rules.mk
bdf
Jamfile
module.mk
README
rules.mk
autofit
Jamfile
module.mk
rules.mk
smooth
Jamfile
module.mk
rules.mk
cid
Jamfile
module.mk
rules.mk
modules.cfg
Makefile
ChangeLog
OAGLibrary.zip
OAGLibrary
Common
include
src
IOSystem
include
Compiler
src
ObjectMappingTable
include
src
OpenGL
include
BMP
FontMapping
Font
JPG
OAGXML
PCX
TGA
TextureMapping
Texture
WindowsViewer
oag
src
BMP
FontMapping
Font
JPG
OAGXML
PCX
TGA
TextureMapping
Texture
WindowsViewer
oag
Workspaces
VC9
Common
oagCommon
Debug
OAGCommon.vcproj.NTHOME.Tucci.user
OAGCommon.vcproj.etucci-PC.etucci.user
Release
IOSystem
Debug
IOSystem.suo
IOSystem.vcproj.NTHOME.Tucci.user
IOSystem.vcproj.etucci-PC.etucci.user
Release
ObjectMappingTable
Debug
ObjectMappingTable.vcproj.NTHOME.Tucci.user
ObjectMappingTable.vcproj.etucci-PC.etucci.user
Release
OpenGL.suo
OpenGL
BMP
BMP.vcproj.NTHOME.Tucci.user
BMP.vcproj.etucci-PC.etucci.user
Debug
Release
FontMapping
Debug
FontMapping.vcproj.NTHOME.Tucci.user
Release
Font
Debug
Font.vcproj.NTHOME.Tucci.user
Font.vcproj.etucci-PC.etucci.user
Release
JPG
Debug
JPG.vcproj.NTHOME.Tucci.user
JPG.vcproj.etucci-PC.etucci.user
Release
OAGXML
Debug
OAGXML.vcproj.NTHOME.Tucci.user
OAGXML.vcproj.etucci-PC.etucci.user
Release
PCX
Debug
PCX.vcproj.NTHOME.Tucci.user
PCX.vcproj.etucci-PC.etucci.user
Release
TGA
Debug
Release
TGA.vcproj.NTHOME.Tucci.user
TGA.vcproj.etucci-PC.etucci.user
TextureMapping
Debug
Release
TextureMapping.suo
TextureMapping.vcproj.NTHOME.Tucci.user
TextureMapping.vcproj.etucci-PC.etucci.user
Texture
Debug
Release
Texture.vcproj.NTHOME.Tucci.user
Texture.vcproj.etucci-PC.etucci.user
WindowsViewer
Debug
Release
WindowsViewer.vcproj.NTHOME.Tucci.user
WindowsViewer.vcproj.etucci-PC.etucci.user
oag
Debug
Release
oag.vcproj.NTHOME.Tucci.user
oag.vcproj.etucci-PC.etucci.user
bin
VC9
OAGXML_DOCUMENTATION.zip
OAG_2D_demo.zip
OAG_2D_SRC.zip
OAGMFC
Debug
UserImages.bmp
OAGMFC.suo
OAGMFC
CadTools
Debug
OAGMFC.APS
OAGMFC.vcproj.NTHOME.Tucci.user
Release
RenderGraphicMFC.aps
UserImages.bmp
res
OAGMFC.ico
OAGMFCDoc.ico
Toolbar.bmp
Toolbar256.bmp
Release
UserImages.bmp
OAG_Demo.zip
OAG_Demo
RenderGraphicMFC.exe
readme.zip
RenderGraphicMFC.zip
RenderGraphicMFC
RenderGraphicMFC
UserImages.bmp
res
RenderGraphicMFC.ico
RenderGraphicMFCDoc.ico
Toolbar.bmp
Toolbar256.bmp
WinAPIs.zip
WinAPIs
FTGL-2.1.3rc5
bin
Debug
Release
include
FTGL
FTGlyph
FTLayout
src
FTGL
FTGlyph
FTLayout
LibJPEG
Debug
Release
files
libjpeg.map
LibXML
COPYING
Copyright
LibXML.vcproj.8.00.old
bin
Debug Win32
LibXML
Intermediate
Release Win32
LibXML
Intermediate
include
libxml
XmlParserInterface
Debug
Release
xmlsamples.zip
xmlsample
2DTree.bmp
Building2D.oagxml
Polyline.oagxml
Rect.oagxml
TextureAndText.oagxml
Triangle.oagxml
arial.ttf
fontMapping.oagxml
honda-pcx.jpg
line.oagxml
line2.oagxml
shrub.jpg
/*
 * jctrans.c
 *
 * Copyright (C) 1995-1998, Thomas G. Lane.
 * Modified 2000-2009 by Guido Vollbeding.
 * This file is part of the Independent JPEG Group's software.
 * For conditions of distribution and use, see the accompanying README file.
 *
 * This file contains library routines for transcoding compression,
 * that is, writing raw DCT coefficient arrays to an output JPEG file.
 * The routines in jcapimin.c will also be needed by a transcoder.
 */

#define JPEG_INTERNALS
#include "jinclude.h"
#include "jpeglib.h"


/* Forward declarations */
LOCAL(void) transencode_master_selection
	JPP((j_compress_ptr cinfo, jvirt_barray_ptr * coef_arrays));
LOCAL(void) transencode_coef_controller
	JPP((j_compress_ptr cinfo, jvirt_barray_ptr * coef_arrays));


/*
 * Compression initialization for writing raw-coefficient data.
 * Before calling this, all parameters and a data destination must be set up.
 * Call jpeg_finish_compress() to actually write the data.
 *
 * The number of passed virtual arrays must match cinfo->num_components.
 * Note that the virtual arrays need not be filled or even realized at
 * the time write_coefficients is called; indeed, if the virtual arrays
 * were requested from this compression object's memory manager, they
 * typically will be realized during this routine and filled afterwards.
 */

GLOBAL(void)
jpeg_write_coefficients (j_compress_ptr cinfo, jvirt_barray_ptr * coef_arrays)
{
  if (cinfo->global_state != CSTATE_START)
    ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state);
  /* Mark all tables to be written */
  jpeg_suppress_tables(cinfo, FALSE);
  /* (Re)initialize error mgr and destination modules */
  (*cinfo->err->reset_error_mgr) ((j_common_ptr) cinfo);
  (*cinfo->dest->init_destination) (cinfo);
  /* Perform master selection of active modules */
  transencode_master_selection(cinfo, coef_arrays);
  /* Wait for jpeg_finish_compress() call */
  cinfo->next_scanline = 0;	/* so jpeg_write_marker works */
  cinfo->global_state = CSTATE_WRCOEFS;
}


/*
 * Initialize the compression object with default parameters,
 * then copy from the source object all parameters needed for lossless
 * transcoding.  Parameters that can be varied without loss (such as
 * scan script and Huffman optimization) are left in their default states.
 */

GLOBAL(void)
jpeg_copy_critical_parameters (j_decompress_ptr srcinfo,
			       j_compress_ptr dstinfo)
{
  JQUANT_TBL ** qtblptr;
  jpeg_component_info *incomp, *outcomp;
  JQUANT_TBL *c_quant, *slot_quant;
  int tblno, ci, coefi;

  /* Safety check to ensure start_compress not called yet. */
  if (dstinfo->global_state != CSTATE_START)
    ERREXIT1(dstinfo, JERR_BAD_STATE, dstinfo->global_state);
  /* Copy fundamental image dimensions */
  dstinfo->image_width = srcinfo->image_width;
  dstinfo->image_height = srcinfo->image_height;
  dstinfo->input_components = srcinfo->num_components;
  dstinfo->in_color_space = srcinfo->jpeg_color_space;
  dstinfo->jpeg_width = srcinfo->output_width;
  dstinfo->jpeg_height = srcinfo->output_height;
  dstinfo->min_DCT_h_scaled_size = srcinfo->min_DCT_h_scaled_size;
  dstinfo->min_DCT_v_scaled_size = srcinfo->min_DCT_v_scaled_size;
  /* Initialize all parameters to default values */
  jpeg_set_defaults(dstinfo);
  /* jpeg_set_defaults may choose wrong colorspace, eg YCbCr if input is RGB.
   * Fix it to get the right header markers for the image colorspace.
   */
  jpeg_set_colorspace(dstinfo, srcinfo->jpeg_color_space);
  dstinfo->data_precision = srcinfo->data_precision;
  dstinfo->CCIR601_sampling = srcinfo->CCIR601_sampling;
  /* Copy the source's quantization tables. */
  for (tblno = 0; tblno < NUM_QUANT_TBLS; tblno++) {
    if (srcinfo->quant_tbl_ptrs[tblno] != NULL) {
      qtblptr = & dstinfo->quant_tbl_ptrs[tblno];
      if (*qtblptr == NULL)
	*qtblptr = jpeg_alloc_quant_table((j_common_ptr) dstinfo);
      MEMCOPY((*qtblptr)->quantval,
	      srcinfo->quant_tbl_ptrs[tblno]->quantval,
	      SIZEOF((*qtblptr)->quantval));
      (*qtblptr)->sent_table = FALSE;
    }
  }
  /* Copy the source's per-component info.
   * Note we assume jpeg_set_defaults has allocated the dest comp_info array.
   */
  dstinfo->num_components = srcinfo->num_components;
  if (dstinfo->num_components < 1 || dstinfo->num_components > MAX_COMPONENTS)
    ERREXIT2(dstinfo, JERR_COMPONENT_COUNT, dstinfo->num_components,
	     MAX_COMPONENTS);
  for (ci = 0, incomp = srcinfo->comp_info, outcomp = dstinfo->comp_info;
       ci < dstinfo->num_components; ci++, incomp++, outcomp++) {
    outcomp->component_id = incomp->component_id;
    outcomp->h_samp_factor = incomp->h_samp_factor;
    outcomp->v_samp_factor = incomp->v_samp_factor;
    outcomp->quant_tbl_no = incomp->quant_tbl_no;
    /* Make sure saved quantization table for component matches the qtable
     * slot.  If not, the input file re-used this qtable slot.
     * IJG encoder currently cannot duplicate this.
     */
    tblno = outcomp->quant_tbl_no;
    if (tblno < 0 || tblno >= NUM_QUANT_TBLS ||
	srcinfo->quant_tbl_ptrs[tblno] == NULL)
      ERREXIT1(dstinfo, JERR_NO_QUANT_TABLE, tblno);
    slot_quant = srcinfo->quant_tbl_ptrs[tblno];
    c_quant = incomp->quant_table;
    if (c_quant != NULL) {
      for (coefi = 0; coefi < DCTSIZE2; coefi++) {
	if (c_quant->quantval[coefi] != slot_quant->quantval[coefi])
	  ERREXIT1(dstinfo, JERR_MISMATCHED_QUANT_TABLE, tblno);
      }
    }
    /* Note: we do not copy the source's Huffman table assignments;
     * instead we rely on jpeg_set_colorspace to have made a suitable choice.
     */
  }
  /* Also copy JFIF version and resolution information, if available.
   * Strictly speaking this isn't "critical" info, but it's nearly
   * always appropriate to copy it if available.  In particular,
   * if the application chooses to copy JFIF 1.02 extension markers from
   * the source file, we need to copy the version to make sure we don't
   * emit a file that has 1.02 extensions but a claimed version of 1.01.
   * We will *not*, however, copy version info from mislabeled "2.01" files.
   */
  if (srcinfo->saw_JFIF_marker) {
    if (srcinfo->JFIF_major_version == 1) {
      dstinfo->JFIF_major_version = srcinfo->JFIF_major_version;
      dstinfo->JFIF_minor_version = srcinfo->JFIF_minor_version;
    }
    dstinfo->density_unit = srcinfo->density_unit;
    dstinfo->X_density = srcinfo->X_density;
    dstinfo->Y_density = srcinfo->Y_density;
  }
}


/*
 * Master selection of compression modules for transcoding.
 * This substitutes for jcinit.c's initialization of the full compressor.
 */

LOCAL(void)
transencode_master_selection (j_compress_ptr cinfo,
			      jvirt_barray_ptr * coef_arrays)
{
  /* Initialize master control (includes parameter checking/processing) */
  jinit_c_master_control(cinfo, TRUE /* transcode only */);

  /* Entropy encoding: either Huffman or arithmetic coding. */
  if (cinfo->arith_code)
    jinit_arith_encoder(cinfo);
  else {
    jinit_huff_encoder(cinfo);
  }

  /* We need a special coefficient buffer controller. */
  transencode_coef_controller(cinfo, coef_arrays);

  jinit_marker_writer(cinfo);

  /* We can now tell the memory manager to allocate virtual arrays. */
  (*cinfo->mem->realize_virt_arrays) ((j_common_ptr) cinfo);

  /* Write the datastream header (SOI, JFIF) immediately.
   * Frame and scan headers are postponed till later.
   * This lets application insert special markers after the SOI.
   */
  (*cinfo->marker->write_file_header) (cinfo);
}


/*
 * The rest of this file is a special implementation of the coefficient
 * buffer controller.  This is similar to jccoefct.c, but it handles only
 * output from presupplied virtual arrays.  Furthermore, we generate any
 * dummy padding blocks on-the-fly rather than expecting them to be present
 * in the arrays.
 */

/* Private buffer controller object */

typedef struct {
  struct jpeg_c_coef_controller pub; /* public fields */

  JDIMENSION iMCU_row_num;	/* iMCU row # within image */
  JDIMENSION mcu_ctr;		/* counts MCUs processed in current row */
  int MCU_vert_offset;		/* counts MCU rows within iMCU row */
  int MCU_rows_per_iMCU_row;	/* number of such rows needed */

  /* Virtual block array for each component. */
  jvirt_barray_ptr * whole_image;

  /* Workspace for constructing dummy blocks at right/bottom edges. */
  JBLOCKROW dummy_buffer[C_MAX_BLOCKS_IN_MCU];
} my_coef_controller;

typedef my_coef_controller * my_coef_ptr;


LOCAL(void)
start_iMCU_row (j_compress_ptr cinfo)
/* Reset within-iMCU-row counters for a new row */
{
  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;

  /* In an interleaved scan, an MCU row is the same as an iMCU row.
   * In a noninterleaved scan, an iMCU row has v_samp_factor MCU rows.
   * But at the bottom of the image, process only what's left.
   */
  if (cinfo->comps_in_scan > 1) {
    coef->MCU_rows_per_iMCU_row = 1;
  } else {
    if (coef->iMCU_row_num < (cinfo->total_iMCU_rows-1))
      coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->v_samp_factor;
    else
      coef->MCU_rows_per_iMCU_row = cinfo->cur_comp_info[0]->last_row_height;
  }

  coef->mcu_ctr = 0;
  coef->MCU_vert_offset = 0;
}


/*
 * Initialize for a processing pass.
 */

METHODDEF(void)
start_pass_coef (j_compress_ptr cinfo, J_BUF_MODE pass_mode)
{
  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;

  if (pass_mode != JBUF_CRANK_DEST)
    ERREXIT(cinfo, JERR_BAD_BUFFER_MODE);

  coef->iMCU_row_num = 0;
  start_iMCU_row(cinfo);
}


/*
 * Process some data.
 * We process the equivalent of one fully interleaved MCU row ("iMCU" row)
 * per call, ie, v_samp_factor block rows for each component in the scan.
 * The data is obtained from the virtual arrays and fed to the entropy coder.
 * Returns TRUE if the iMCU row is completed, FALSE if suspended.
 *
 * NB: input_buf is ignored; it is likely to be a NULL pointer.
 */

METHODDEF(boolean)
compress_output (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
{
  my_coef_ptr coef = (my_coef_ptr) cinfo->coef;
  JDIMENSION MCU_col_num;	/* index of current MCU within row */
  JDIMENSION last_MCU_col = cinfo->MCUs_per_row - 1;
  JDIMENSION last_iMCU_row = cinfo->total_iMCU_rows - 1;
  int blkn, ci, xindex, yindex, yoffset, blockcnt;
  JDIMENSION start_col;
  JBLOCKARRAY buffer[MAX_COMPS_IN_SCAN];
  JBLOCKROW MCU_buffer[C_MAX_BLOCKS_IN_MCU];
  JBLOCKROW buffer_ptr;
  jpeg_component_info *compptr;

  /* Align the virtual buffers for the components used in this scan. */
  for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
    compptr = cinfo->cur_comp_info[ci];
    buffer[ci] = (*cinfo->mem->access_virt_barray)
      ((j_common_ptr) cinfo, coef->whole_image[compptr->component_index],
       coef->iMCU_row_num * compptr->v_samp_factor,
       (JDIMENSION) compptr->v_samp_factor, FALSE);
  }

  /* Loop to process one whole iMCU row */
  for (yoffset = coef->MCU_vert_offset; yoffset < coef->MCU_rows_per_iMCU_row;
       yoffset++) {
    for (MCU_col_num = coef->mcu_ctr; MCU_col_num < cinfo->MCUs_per_row;
	 MCU_col_num++) {
      /* Construct list of pointers to DCT blocks belonging to this MCU */
      blkn = 0;			/* index of current DCT block within MCU */
      for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
	compptr = cinfo->cur_comp_info[ci];
	start_col = MCU_col_num * compptr->MCU_width;
	blockcnt = (MCU_col_num < last_MCU_col) ? compptr->MCU_width
						: compptr->last_col_width;
	for (yindex = 0; yindex < compptr->MCU_height; yindex++) {
	  if (coef->iMCU_row_num < last_iMCU_row ||
	      yindex+yoffset < compptr->last_row_height) {
	    /* Fill in pointers to real blocks in this row */
	    buffer_ptr = buffer[ci][yindex+yoffset] + start_col;
	    for (xindex = 0; xindex < blockcnt; xindex++)
	      MCU_buffer[blkn++] = buffer_ptr++;
	  } else {
	    /* At bottom of image, need a whole row of dummy blocks */
	    xindex = 0;
	  }
	  /* Fill in any dummy blocks needed in this row.
	   * Dummy blocks are filled in the same way as in jccoefct.c:
	   * all zeroes in the AC entries, DC entries equal to previous
	   * block's DC value.  The init routine has already zeroed the
	   * AC entries, so we need only set the DC entries correctly.
	   */
	  for (; xindex < compptr->MCU_width; xindex++) {
	    MCU_buffer[blkn] = coef->dummy_buffer[blkn];
	    MCU_buffer[blkn][0][0] = MCU_buffer[blkn-1][0][0];
	    blkn++;
	  }
	}
      }
      /* Try to write the MCU. */
      if (! (*cinfo->entropy->encode_mcu) (cinfo, MCU_buffer)) {
	/* Suspension forced; update state counters and exit */
	coef->MCU_vert_offset = yoffset;
	coef->mcu_ctr = MCU_col_num;
	return FALSE;
      }
    }
    /* Completed an MCU row, but perhaps not an iMCU row */
    coef->mcu_ctr = 0;
  }
  /* Completed the iMCU row, advance counters for next one */
  coef->iMCU_row_num++;
  start_iMCU_row(cinfo);
  return TRUE;
}


/*
 * Initialize coefficient buffer controller.
 *
 * Each passed coefficient array must be the right size for that
 * coefficient: width_in_blocks wide and height_in_blocks high,
 * with unitheight at least v_samp_factor.
 */

LOCAL(void)
transencode_coef_controller (j_compress_ptr cinfo,
			     jvirt_barray_ptr * coef_arrays)
{
  my_coef_ptr coef;
  JBLOCKROW buffer;
  int i;

  coef = (my_coef_ptr)
    (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
				SIZEOF(my_coef_controller));
  cinfo->coef = (struct jpeg_c_coef_controller *) coef;
  coef->pub.start_pass = start_pass_coef;
  coef->pub.compress_data = compress_output;

  /* Save pointer to virtual arrays */
  coef->whole_image = coef_arrays;

  /* Allocate and pre-zero space for dummy DCT blocks. */
  buffer = (JBLOCKROW)
    (*cinfo->mem->alloc_large) ((j_common_ptr) cinfo, JPOOL_IMAGE,
				C_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK));
  jzero_far((void FAR *) buffer, C_MAX_BLOCKS_IN_MCU * SIZEOF(JBLOCK));
  for (i = 0; i < C_MAX_BLOCKS_IN_MCU; i++) {
    coef->dummy_buffer[i] = buffer + i;
  }
}

By viewing downloads associated with this article you agree to the Terms of Service and the article's licence.

If a file you wish to view isn't highlighted, and is a text file (not binary), please let us know and we'll add colourisation support for it.

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Share

About the Author

Eduardo Tucci
Software Developer
Brazil Brazil
I live in Matão, a small city in Brazil. I studied as Programmer in a College for Software Development in Database.
After finishing the College I have been working with java, c# and Computer Graphics with searches for OpenGL.

| Advertise | Privacy | Mobile
Web04 | 2.8.140827.1 | Last Updated 7 Aug 2011
Article Copyright 2010 by Eduardo Tucci
Everything else Copyright © CodeProject, 1999-2014
Terms of Service
Layout: fixed | fluid