LibreMediaServer/lms-video
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

- Reestructuración de ficheros y directorios general

Browse source 
- merge v0.01 --> Añadido fileselector
- Añadidas fuentes de Gem y Pure Data
- pix2jpg incluído en Gem. Archivos de construcción de Gem modificados.
- Añadido fichero ompiling.txt con instrucciones de compilación
This commit is contained in:
Santi Noreña 2013-02-04 18:00:17 +01:00
parent c9adfd020b
commit e85d191b46
3100 changed files with 775434 additions and 3073 deletions
Download patch file Download diff file Expand all files Collapse all files

145
Gem/doc/CodingStyle.txt Normal file
View file

@ -0,0 +1,145 @@
Coding Guidelines for Gem
=========================
2011, IOhannes m zmölnig
in no special order...
directory structure
-------------------
src/Gem
Gem core architecture classes
src/Utils
Utilitiy code that can be re-used in several different contexts
src/RTE
Pd-specific code (RTE=Real Time Environment)
(in the far future i would like to have all Pd-specific code wrapped in
here)
src/plugins
plugin infrastructure and (pure virtual) baseclasses for the various
plugins
src/Base
Base classes for objectclasses
src/deprecated
deprecated headers for backward compatibility
src/Controls/
objectclasses: CONTROL
src/Manips/
objectclasses: MANIPulatorS
src/Geos/
objectclasses: GEometric ObjectS
src/Nongeos/
objectclasses: positionable Objects that are not Geos
src/openGL/
objectclasses: OPENGL wrapper objects
src/Particles/
objectclasses: PARTICLE engine
src/Pixes/
objectclasses: PIXEl proceSsing
src/Output/
objectclasses: window handling
plugins/*/
plugin implementations for various backends
extra/*/
additional objectclasses
directories containing objectclasses, should not hold auxiliary files!
these should go into src/Utils/ (if they are of general interest) or the code
should be embedded into the objectclass code.
a noteable exception is the extra/*/ folder
file structure
--------------
C++ files are suffixed ".cpp".
they are accompanied by a header file ".h" containing the public interface.
there is a file for each objectclass named like the objectclass. e.g.
> src/Manips/ortho.cpp
contains the code for the [ortho] objectclass.
private/protected/public
------------------------
ctor/dtor should be public
methods should be protected/public
members should be protected
private members should be hidden using a PIMPL idiom
callbacks
---------
message callbacks from the RTE should be implemented using the CPPEXTERN_MSG*
macros defined in src/RTE/MessageCallbacks.h
this removes the need for static callbacks in the header-files
C-style vs C++-style
--------------------
while Pd is written in C, Gem is written in C++;
please try to use C++ idioms whenever possible.
use STL instead of inventing your own data containers!
esp. use "std::string" instead of "char*" whenever possible
the Gem code base is full of C-idioms and types; this is mainly because i
started as a C-programmer and only gradually learned using C++; don't repeat my
follies :-)
variable naming
---------------
member variables are usually prefixed with "m_"
static variables are usually prefixed with "s_"
initialization
--------------
initialize all member variables in the constructor(s).
use "member initialization lists" when possible.
e.g. use
> foo::foo(void) : m_x(0), m_y(0) {}
rather than
> foo::foo(void) { m_x=0; m_y=0; }
import/export
-------------
all functions/classes that should be visible from outside must be exported using
the GEM_EXTERN macro.
all objectclasses are exported.
all utility classes are exported.
dependencies
------------
the dependencies of Gem should be kept at a minimum (ideally only openGL)
objectclasses that use special libraries should go into extra/
if you want to add functionality to Gem that is (or can be) implemented by a
number of different backends (libraries), this should be done via an abstract
interface and plugins, thus moving the binary dependency outside of Gem.
Indentation
-----------
TODO
git commits
-----------
try to avoid committing pd-patches and C++ code within the same
commit. conflicts in C++-code can usually easily be resolved, whereas
conflicts in Pd-patches are usually impossible to resolve (but for the
most trivial cases)
git branching
-------------
try to avoid forking from branches other than master.
esp. avoid branches on top of branches.
before committing a pull rqeuest, make sure that your branch applies clean to
current master.

BIN
Gem/doc/GemPrimer.pdf Normal file
View file

Binary file not shown.

47
Gem/doc/Makefile.am Normal file
View file

@ -0,0 +1,47 @@
AUTOMAKE_OPTIONS = foreign
gemdocdir=$(pkglibdir)
nobase_dist_gemdoc_DATA = \
cMatrix.html \
gem.known_bugs.txt \
GemPrimer.pdf \
gem.release_notes.txt \
gem.todo.txt \
manual/add.jpg \
manual/addResult.jpg \
manual/Advanced.html \
manual/basicCube.jpg \
manual/BasicObj.html \
manual/counter.jpg \
manual/GemFaq.html \
manual/gemwin.jpg \
manual/GemWPd.html \
manual/Gloss.html \
manual/Images.html \
manual/index.html \
manual/Input.html \
manual/Intro.html \
manual/invertFrac.jpg \
manual/invert.jpg \
manual/Lighting.html \
manual/light.jpg \
manual/ListObjects.html \
manual/mask.jpg \
manual/maskResult.jpg \
manual/normalFrac.jpg \
manual/Particles.html \
manual/Pixes.html \
manual/pixImage.jpg \
manual/redSquare.jpg \
manual/sphere15.jpg \
manual/sphere5.jpg \
manual/Texture.html \
manual/texture.jpg \
manual/transXYZ.jpg \
manual/tribar.gif \
manual/tripleLine.jpg \
manual/tripleRand.jpg \
manual/Utility.html \
manual/world_light.jpg \
manual/WriteCode.html

270
Gem/doc/cMatrix.html Normal file
View file

@ -0,0 +1,270 @@
<html>
<head>
<title>Matrix Operations for Image Processing</title>
</head>
<body bgcolor="#ffffff" text="#000000">
<!--no_print--><br><center><table width=564><tr><td>
<h2>Matrix Operations for Image Processing</h2>
<!--no_print--><h3>Paul Haeberli</h3>
<h3>Nov 1993</h3>
<img src=../tribar.gif alt="Horiz Bar" width=561 height=3>
<h3>Introduction</h3>
<p>
Four by four matrices are commonly used to transform geometry for 3D
rendering. These matrices may also be used to transform RGB colors, to scale
RGB colors, and to control hue, saturation and contrast. The most important
advantage of using matrices is that any number of color transformations
can be composed using standard matrix multiplication.
<p>
Please note that for these operations to be correct, we really must operate
on linear brightness values. If the input image is in a non-linear brightness
space RGB colors must be transformed into a linear space before these
matrix operations are used.
<h3>Color Transformation</h3>
RGB colors are transformed by a four by four matrix as shown here:
<pre>
xformrgb(mat,r,g,b,tr,tg,tb)
float mat[4][4];
float r,g,b;
float *tr,*tg,*tb;
{
*tr = r*mat[0][0] + g*mat[1][0] +
b*mat[2][0] + mat[3][0];
*tg = r*mat[0][1] + g*mat[1][1] +
b*mat[2][1] + mat[3][1];
*tb = r*mat[0][2] + g*mat[1][2] +
b*mat[2][2] + mat[3][2];
}
</pre>
<h3>The Identity</h3>
This is the identity matrix:
<pre>
float mat[4][4] = {
1.0, 0.0, 0.0, 0.0,
0.0, 1.0, 0.0, 0.0,
0.0, 0.0, 1.0, 0.0,
0.0, 0.0, 0.0, 1.0,
};
</pre>
Transforming colors by the identity matrix will leave them unchanged.
<h3>Changing Brightness</h3>
To scale RGB colors a matrix like this is used:
<pre>
float mat[4][4] = {
rscale, 0.0, 0.0, 0.0,
0.0, gscale, 0.0, 0.0,
0.0, 0.0, bscale, 0.0,
0.0, 0.0, 0.0, 1.0,
};
</pre>
Where rscale, gscale, and bscale specify how much to scale the r, g, and b
components of colors. This can be used to alter the color balance of an image.
<p>
In effect, this calculates:
<pre>
tr = r*rscale;
tg = g*gscale;
tb = b*bscale;
</pre>
<h3>Modifying Saturation</h3>
<h3>Converting to Luminance</h3>
To convert a color image into a black and white image, this matrix is used:
<pre>
float mat[4][4] = {
rwgt, rwgt, rwgt, 0.0,
gwgt, gwgt, gwgt, 0.0,
bwgt, bwgt, bwgt, 0.0,
0.0, 0.0, 0.0, 1.0,
};
</pre>
Where rwgt is 0.3086, gwgt is 0.6094, and bwgt is 0.0820. This is the
luminance vector. Notice here that we do not use the standard NTSC weights
of 0.299, 0.587, and 0.114. The NTSC weights are only applicable to RGB
colors in a gamma 2.2 color space. For linear RGB colors the values above
are better.
<p>
In effect, this calculates:
<pre>
tr = r*rwgt + g*gwgt + b*bwgt;
tg = r*rwgt + g*gwgt + b*bwgt;
tb = r*rwgt + g*gwgt + b*bwgt;
</pre>
<h3>Modifying Saturation</h3>
To saturate RGB colors, this matrix is used:
<pre>
float mat[4][4] = {
a, b, c, 0.0,
d, e, f, 0.0,
g, h, i, 0.0,
0.0, 0.0, 0.0, 1.0,
};
</pre>
Where the constants are derived from the saturation value s
as shown below:
<pre>
a = (1.0-s)*rwgt + s;
b = (1.0-s)*rwgt;
c = (1.0-s)*rwgt;
d = (1.0-s)*gwgt;
e = (1.0-s)*gwgt + s;
f = (1.0-s)*gwgt;
g = (1.0-s)*bwgt;
h = (1.0-s)*bwgt;
i = (1.0-s)*bwgt + s;
</pre>
One nice property of this saturation matrix is that the luminance
of input RGB colors is maintained. This matrix can also be used
to complement the colors in an image by specifying a saturation
value of -1.0.
<p>
Notice that when <code>s</code> is set to 0.0, the matrix is exactly
the "convert to luminance" matrix described above. When <code>s</code>
is set to 1.0 the matrix becomes the identity. All saturation matrices
can be derived by interpolating between or extrapolating beyond these
two matrices.
<p>
This is discussed in more detail in the note on
<a href="../interp/index.html">Image Processing By Interpolation and Extrapolation</a>.
<h3>Applying Offsets to Color Components</h3>
To offset the r, g, and b components of colors in an image this matrix is used:
<pre>
float mat[4][4] = {
1.0, 0.0, 0.0, 0.0,
0.0, 1.0, 0.0, 0.0,
0.0, 0.0, 1.0, 0.0,
roffset,goffset,boffset,1.0,
};
</pre>
This can be used along with color scaling to alter the contrast of RGB
images.
<h3>Simple Hue Rotation</h3>
To rotate the hue, we perform a 3D rotation of RGB colors about the diagonal
vector [1.0 1.0 1.0]. The transformation matrix is derived as shown here:
<p>
If we have functions:<br><br>
<dl>
<dt><code>identmat(mat)</code>
<dd>that creates an identity matrix.
</dl>
<dl>
<dt><code>xrotatemat(mat,rsin,rcos)</code>
<dd>that multiplies a matrix that rotates about the x (red) axis.
</dl>
<dl>
<dt><code>yrotatemat(mat,rsin,rcos)</code>
<dd>that multiplies a matrix that rotates about the y (green) axis.
</dl>
<dl>
<dt><code>zrotatemat(mat,rsin,rcos)</code>
<dd>that multiplies a matrix that rotates about the z (blue) axis.
</dl>
Then a matrix that rotates about the 1.0,1.0,1.0 diagonal can be
constructed like this:
<br>
First we make an identity matrix
<pre>
identmat(mat);
</pre>
Rotate the grey vector into positive Z
<pre>
mag = sqrt(2.0);
xrs = 1.0/mag;
xrc = 1.0/mag;
xrotatemat(mat,xrs,xrc);
mag = sqrt(3.0);
yrs = -1.0/mag;
yrc = sqrt(2.0)/mag;
yrotatemat(mat,yrs,yrc);
</pre>
Rotate the hue
<pre>
zrs = sin(rot*PI/180.0);
zrc = cos(rot*PI/180.0);
zrotatemat(mat,zrs,zrc);
</pre>
Rotate the grey vector back into place
<pre>
yrotatemat(mat,-yrs,yrc);
xrotatemat(mat,-xrs,xrc);
</pre>
The resulting matrix will rotate the hue of the input RGB colors. A rotation
of 120.0 degrees will exactly map Red into Green, Green into Blue and
Blue into Red. This transformation has one problem, however, the luminance
of the input colors is not preserved. This can be fixed with the following
refinement:
<h3>Hue Rotation While Preserving Luminance</h3>
We make an identity matrix
<pre>
identmat(mmat);
</pre>
Rotate the grey vector into positive Z
<pre>
mag = sqrt(2.0);
xrs = 1.0/mag;
xrc = 1.0/mag;
xrotatemat(mmat,xrs,xrc);
mag = sqrt(3.0);
yrs = -1.0/mag;
yrc = sqrt(2.0)/mag;
yrotatemat(mmat,yrs,yrc);
matrixmult(mmat,mat,mat);
</pre>
Shear the space to make the luminance plane horizontal
<pre>
xformrgb(mmat,rwgt,gwgt,bwgt,&lx,&ly,&lz);
zsx = lx/lz;
zsy = ly/lz;
zshearmat(mat,zsx,zsy);
</pre>
Rotate the hue
<pre>
zrs = sin(rot*PI/180.0);
zrc = cos(rot*PI/180.0);
zrotatemat(mat,zrs,zrc);
</pre>
Unshear the space to put the luminance plane back
<pre>
zshearmat(mat,-zsx,-zsy);
</pre>
Rotate the grey vector back into place
<pre>
yrotatemat(mat,-yrs,yrc);
xrotatemat(mat,-xrs,xrc);
</pre>
<h3>Conclusion</h3>
I've presented several matrix transformations that may be applied
to RGB colors. Each color transformation is represented by
a 4 by 4 matrix, similar to matrices commonly used to transform 3D geometry.
<p>
<a href="matrix.c">Example C code</a>
that demonstrates these concepts is provided for your enjoyment.
<p>
These transformations allow us to adjust image contrast, brightness, hue and
saturation individually. In addition, color matrix transformations concatenate
in a way similar to geometric transformations. Any sequence of
operations can be combined into a single matrix using
matrix multiplication.
<!--no_print--><p>
<!--no_print--><center>
<!--no_print--><a href=../index.html#matrix><img src=../gobot.gif width=564 height=25 border=0></a>
<!--no_print--><br>
<!--no_print--></center>
<!--no_print--></td></tr></table></center>
</body>
</html>

298
Gem/doc/gem.known_bugs.txt Normal file
View file

@ -0,0 +1,298 @@
GEM ONLINE DOCUMENTATION CHAPTER 4: Known bugs
----------------------------------------------
---------------------------- KNOWN BUGS -----------------------------
[pix_lumaoffset] crashes
--------------
POSTED 15/05/04
--------------
BUG: pix_lumaoffset crashes when the offset-factor is very high and fill+smooth is turned on
ANS: yes; but we haven't found where the bug is hidden yet
loading movies leaks memory under Win32
--------------
POSTED 4/16/02
--------------
BUG: each time an AVI is loaded, the used memory increases for about 400k.
after some time (and opening MANY files) this will be too much...
ANS: i fear, this is really a mikro$oft bug! (probably not;-))
loading MPEG-movies crashes under Win32
--------------
POSTED 4/05/04
--------------
BUG: loading MPEG-movies (*.MPG) crashes pd
ANS: MPEG is not really supported under the Win32-version of Gem
however Gem tries to decode MPEGs via QuickTime which might crash (see below)
loading AVI-movies does not work under Win32
--------------
POSTED 4/05/04
--------------
BUG: loading some AVI-movies with certain codecs does not work under Win2k and bigger.
ANS: Gem is (still) using a rather old API for decoding videos.
it might well be, that not all installed codecs are supported (e.g. Indeo-5)
have to destroy / create window to change lighting state in buffer == 1
--------------
POSTED 11/07/98
--------------
BUG: If you want to change the lighting when GEM is running in single
buffer mode, you have to destroy and then create the window.
ANS: hopefully we will drop single-buffer mode soon (enabling double-buffer feedback instead) (2004)
WinNT pix_video object
--------------
POSTED 6/25/98
-------------
BUG: The WinNT pix_video object has a lot of problems. It is not
very stable, tends to lock up the machine, etc.
ANS: don't have much problems with it.
daniel's directshow-support enables support for most newer (ieee1394,usb) cameras under win,
although the interface is somewhat different than on other OS's
(eg: set dimensions via pop-up menu,...)
splines are incorrect
--------------
POSTED 6/25/98
--------------
BUG: In preventing the crasher in the spline object, I have introduced
another bug. Mainly, the end points don't get computed correctly.
Polygon doesn't tesselate (ie, polygons sometimes look strange)
--------------
POSTED 5/19/97
--------------
BUG: Because the polygon object doesn't tesselate itself,
if it is concave, the behavior is undefined under OpenGL.
glxContext memory leak
--------------
POSTED 5/18/97
--------------
BUG: The dummy glxContext doesn't ever get destroyed. Use a static object
to create and destroy it when the DSO is loaded/unloaded.
Indycam broken
--------------
POSTED 5/1/97
--------------
BUG: The Indycam object doesn't seem to work. While getting the O2cam
up, I seem to have broken the Indycam object. One known
bug is that the Indycam doesn't accept the dimen message.
ANS: i don't have a running SGI with an indycam at hand, so i
don't know how to fix it
---------------------------- FIXED BUGS -----------------------------
some geos don't render data from pix_movie correctly
--------------
POSTED 19/03/2004
FIXED 20/03/2004
--------------
BUG: Some objects don't render images correctly
ANS: Gem tries to use rectangle-textures when available
GLU-objects cannot handle such textures
FIX: send a "mode 0" message to the [pix_texture]
FIX2:put the specific GLU-code into Gem and fixed the problem
some geos don't render data from pix_movie correctly
--------------
POSTED 4/24/99
FIXED 20/03/2004
--------------
BUG: Sphere and cone don't texture map movie data correctly because
they ignore the texture coordinates that pix_movie sets.
ANS: as long as we use the libGLU for these objects there is not much chance
to fix the core of this problem
FIX: put the specific GLU-code into Gem and fixed the problem
Cone and sphere ignore textCoords
--------------
POSTED 4/12/99
FIXED 20/03/2004
--------------
BUG: The glu library is used to create the cone and sphere, so gem
doesn't control the texture coordinates used.
FIX: put the specific GLU-code into Gem and fixed the problem
text2d is messed up
--------------
FIXED 01/01/04
POSTED 2/22/98
--------------
BUG: text2d doesn't really work at all. There seems to be a bug
in the GLTT library which is messing up the rasterpos.
FIX: use FTGL rather than GLTT
curve is broken under Linux
--------------
FIXED 01/01/04
POSTED 0/24/99
--------------
BUG: if curve is used under Linux, it core dumps when rendering.
It dumps on glMap1f(GL_MAP1_VERTEX_3, 0.0, 1.0, 3, m_numInputs, &(m_vert[0][0]));
ANS: seems to work now
model crashes when nothing is loaded
---------------
FIXED 01/01/04
POSTED 10/25/02
---------------
BUG: if rendering is started without a model being loaded before, pd crashes
ANS: seems to be fixed sime time ago...
pix_imageInPlace crashes when nothing is loaded
---------------
FIXED 01/01/04
POSTED 10/25/02
---------------
BUG: when trying to download non-existant images (by specifying the wrong
preload-name), pd-crashes
ANS: seems to be fixed now...
Can't process pix_movie data with pix objects
--------------
FIXED 4/15/02
POSTED 4/24/99
--------------
BUG: pix_movie sends the data immediately to OpenGL,
so there is no chance to process the data.
ANS: it does what it does; [pix_film] does not send the image-data immediately, so use it instead
pix_2grey doesn't process the correct number of pixels
--------------
FIXED 2/19/00
POSTED 2/18/00
--------------
BUG: The pixel count is calculated with addition instead of multiplying.
ANS: Just changed how the calculation occurs.
tablet not reset on exit
--------------
FIXED 1/24/99
POSTED 8/29/98
--------------
BUG: If the user has a tablet, it is not reset to the default settings
on exit, making it unusable as a mouse.
ANS: Just needed to do some more cleanup on exit. Should be okay now.
text object can't be found
--------------
FIXED 2/21/98
POSTED 5/1/97
--------------
BUG: Because the text is a special keyword and object inside of
pd, the text object cannot be found as a GEM object. The solution
is to rename it to something else.
ANS: I am using a cool library called gltt which will render true type
fonts in OpenGL.
Memory exception on WinNT
--------------
FIXED 12/15/97
POSTED 11/30/97
--------------
BUG: If you use pix_image, then there is a memory exception (ie, crash) when
you exit Pd. It doesn't happen while actually running Pd/GEM.
ANS: Mysterious...it went away.
Polygon and curve under NT
--------------
FIXED 10/21/97
POSTED 10/21/97
--------------
BUG: The vertex calls are receiving 0, 0, 0 for x, y, z
ANS: Extra type * parameter in the vert_* calls
Single buffering under NT
--------------
FIXED 10/21/97
POSTED 10/19/97
--------------
BUG: Single buffering doesn't work under NT.
ANS: Need an explicit glFlush(). gemHead calls glFlush after a bang message.
Geos texture coordinates
--------------
FIXED 10/17/97
POSTED 6/16/97
--------------
BUG: The vertex and texture coordinates should start so that the first
S,T is 0,0
ANS: Just did it.
pix_composite is backwards
--------------
FIXED 7/12/97
POSTED 6/16/97
--------------
BUG: The pix_composite object should have its inlets swapped. Conceptually
it doesn't make sense the way it works currently.
FIX: Just did it.
pix_convolve is broken
--------------
FIXED 7/13/97
POSTED 6/16/97
--------------
BUG: Sometimes pix_convolve doesn't work - seems to do with the scale factor
ANS: I'm not sure why it wasn't working. I have hammered it with a variey
of kernels and scales and never had a problem...
ANS2: I found a bug where pix_image didn't automatically refresh its image
at the start of rendering
pix_alpha is backwards
--------------
FIXED 7/12/92
POSTED 6/16/97
--------------
BUG: Sometimes it works, sometimes it doesn't
ANS: Swapped around the inlet creations
polygon's first inlet doesn't work
--------------
FIXED 5/18/97
POSTED 5/17/97
--------------
BUG: The first vertex of polygon doesn't work. It is always set to the
origin. Also, polygon defaults to line drawing. Check Curve for
the same problems (it is derived from polygon).
ANS: The first inlet no longer takes the first vertex. I added another
inlet.
fonts do not load
--------------
FIXED 4/02/02
POSTED 4/01/02
--------------
BUG: the example fonts for text2d/text3d do not load
FIX: accidentally i did a dos2unix to the *.ttf files. this damaged them.
Get new ones from ftp://iem.at/pd/Externals/GEM/misc

1018
Gem/doc/gem.release_notes.txt Normal file
View file

File diff suppressed because it is too large Load diff

65
Gem/doc/gem.todo.txt Normal file
View file

@ -0,0 +1,65 @@
GEM ONLINE DOCUMENTATION CHAPTER 7: TODO
----------------------------------------
This is a list of future improvements and changes.
No importance should be given to the order...it is just
when I thought of things.
- Mark D.
- IOhannes m z
---------------------------- TODO -----------------------------
GENERAL
-------
only connect to tablet if gem_tablet exists
make a separate Gem-thread (to do parallel audio/video-processing)
enable output to other "devices": like files, video-editing-cards,...
PARTICLE
--------
OBJECTS
-------
triangle_fan
stereoscopic display with hardware glasses
NURBS/bezier patches
3DstudioMax file loader
CAL3d (character animation library): (not sure anymore. maybe quake2-files would be better ?)
Alias|Wavefront file data
- articulation hierarchies in Wavefront's Kinemation
- read Preview's .mov files (an ascii list of x, y, and/or z values)
morphing between alias|wavefront models
- assume same number of points in each model
PIXES
-----
pix_dv (under linux this still needs a lot of testing)
motion and image analysis
some way to fragment an image so that it can be used as multiple
texture maps (hopefully arbitrary shapes, but possibly only rectangular)
pix_erosion
pix_dilation
pix_median/min/max filter
pix_lowpass
pix_highpass
video external keyer
- three inputs - the matte and two image inputs
increased control of the Threshold object.
- upper and lower levels adjustable
stereoscopic texture loader
pix_circle
pix_triangle
test pix_video - espec offset message
OPENGL
------
be able to switch between single and double buffering on the fly
have multiple graphics windows
increased control of view port, etc.
be able to use multiple pipes (MCO)
try out glMatrixMode(GL_TEXTURE) to deal with nonstandard texture mapping
render to a pixblock (use pbuffers or offscreen renderer)
on systems that run in console mode only (like linux with(out) XFree86), render to the console with beautiful ASCII-art
multipass rendering
multitexturing

27
Gem/doc/manual/Advanced.html Normal file
View file

@ -0,0 +1,27 @@
<!doctype html public "-//w3c//dtd html 4.0 transitional//en">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<meta name="Author" content="Mark Danks">
<meta name="GENERATOR" content="Mozilla/4.5 [en] (WinNT; I) [Netscape]">
<title>Advanced</title>
</head>
<body>
<center>
<h2>
<u>Advanced objects</u></h2></center>
<p><br>Todo:
<p>more than 8 lights
<br>pix_imageInPlace
<br>accumrotate
<br>camera
<br>polygon and curve
<br>text3d
<br>pix_data
<br>linear_path
<br>spline_path
<p><a href="index.html">[return]</a>
</body>
</html>

115
Gem/doc/manual/BasicObj.html Normal file
View file

@ -0,0 +1,115 @@
<!doctype html public "-//w3c//dtd html 4.0 transitional//en">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<meta name="Author" content="Mark Danks">
<meta name="Author" content="IOhannes m zmölnig">
<title>Basic Objects</title>
</head>
<body>
<center>
<h2>
<u>Basic Objects</u></h2></center>
<p><br>There are a number of objects which are the foundation for GEM.
These objects are used in every patch and control the graphics and rendering.
<p><a href="#gemwin">[gemwin]</a> - The window manager
<br><a href="#gemhead">[gemhead]</a> - The start of a rendering chain
<br><a href="#manips">manips</a> - Move an object in the window
<br><a href="#geos">geos</a> - Render a shape
<p><img SRC="tribar.gif" height=13 width=561>
<h3>
<a NAME="gemwin"></a>[gemwin]</h3>
The graphics window is created and destroyed with the <i>[gemwin]</i> object.
With the <i>[gemwin]</i> object, you can set the default size of the graphics
window, create and destroy the graphics window, turn on and off rendering,
etc. All basic GEM patches will have the following <i>[gemwin]</i>
object with these messages:
<center>
<p><img SRC="gemwin.jpg" BORDER=1 height=128 width=78></center>
The create and destroy messages will display and remove the graphics window.
The 1 and 0 messages start and stop rendering.
<p><img SRC="tribar.gif" height=13 width=561>
<h3>
<a NAME="gemhead"></a>[gemhead]</h3>
The <i>[gemhead]</i> object is the start of every rendering chain.
A simple patch, which is located in examples/gem_basic/gem1.redSquare.pd
looks like:
<center>
<p><img SRC="redSquare.jpg" BORDER=1 height=138 width=91></center>
<p>This patch will render a red square. The <i>[gemhead]</i> object
signifies the start of rendering. The <i>[color]</i> object sets the color
for all objects after it in the chain. The <i>[square]</i> object renders
a square into the graphics window based on the current color, texturing,
and transformations. In this case, there is no texturing and no transformation.
<p>Every rendering chain <b>MUST</b> start with a [gemhead]. If you
do not put a <i>[gemhead]</i> at the beginning of the chain, then nothing
will be rendered for that part of the patch.
<p><img SRC="tribar.gif" height=13 width=561>
<h3>
<a NAME="manips"></a>manips</h3>
In the patch 01.basic/02.cube.pd, the <i>[translateXYZ]</i> object is
introduced.
<center>
<p><img SRC="basicCube.jpg" BORDER=1 height=133 width=93></center>
<p>The graphics are transformed and moved by the <i>manipulator</i> objects,
or the manips. GEM has the following manips:
<p><i>[color]</i> - set the color with a vector
<br><i>[colorRGB]</i> - set the color with 3 discrete values
<br><i>[rotate]</i> - rotate with an angle and vector
<br><i>[rotateXYZ]</i> - rotate with 3 discrete values
<br><i>[scale]</i> - scale with a vector
<br><i>[scaleXYZ]</i> - scale with 3 discrete values
<br><i>[translate]</i> - translate with a vector
<br><i>[translateXYZ]</i> - translate with 3 discrete values
<p>To understand the difference between the vector and discrete values
version, realize that everything in is defined in 3 dimensions. These
dimensions can be XYZ values, or RGB colors.
<center>
<p><img SRC="transXYZ.jpg" BORDER=1 height=92 width=201></center>
<p>The two translate objects above will do exactly the same thing in a
patch, but they provide two different ways to do it. <i>[translate]</i> accepts
a scalar and vector. <i>[translateXYZ]</i> accepts three floats which
specify a point in space. The manips will transform any object which
appears after it in the rendering chain.
<p><img SRC="tribar.gif" height=13 width=561>
<h3>
<a NAME="geos"></a>geos</h3>
Up above, we saw the <i>[square]</i> and <i>[cube]</i> objects. The other
primary geos are:
<p><i>[square]</i> - render a square
<br><i>[circle]</i> - render a circle
<br><i>[triangle]</i> - render a triangle
<br><i>[cube]</i> - render a cube
<br><i>[sphere]</i> - render a sphere
<br><i>[cone]</i> - render a cone
<p>The <i>[square]</i>, <i>[circle]</i>, <i>[cube]</i>, and <i>[triangle]</i> objects
have a right-hand inlet to set the size of the shape. The default
size is 1.
<p>The <i>[cone]</i> and <i>[sphere]</i> objects are not perfectly smooth.
They are actually composed of a number of polygons. In order to control
the rendering better, the middle inlet is the size of the object, while
the right-hand inlet is the number of slices to define the shape.
Take a look at the patch gem_basic/gem3.sphere.pd to see how the number
of slices can change the look of a sphere. Don't worry about the
<i><a href="Lighting.html#world_light">[world_light]</a></i>
object, it is just there to make it easier to see the difference in the
number of slices. Make sure to click the 'lighting 0' message before
closing the patch (if you don't, then other patches will probably be completely
black until you quit and restart pd/GEM).
<p>Your graphics window should look like this for 5 and 15 slices:
<center>
<p><img SRC="sphere5.jpg" BORDER=0 height=150 width=150><img SRC="sphere15.jpg" height=150 width=150></center>
Obviously, the more slices that you use, the better the sphere looks.
However, each slice adds more polygons, which can slow down your frame
rate. In computer graphics, there is always a trade off between resolution
and speed.
<p><img SRC="tribar.gif" height=13 width=561>
<p><a href="index.html">[return]</a>
<br>
</body>
</html>

667
Gem/doc/manual/GemFaq.html Normal file
View file

@ -0,0 +1,667 @@
<!doctype html public "-//w3c//dtd html 4.0 transitional//en">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<meta name="Author" content="Mark Danks">
<meta name="GENERATOR" content="Mozilla/4.5 [en] (WinNT; I) [Netscape]">
<title>Gem FAQ</title>
</head>
<body>
<center>
<h2>
<u>GEM FAQ</u></h2></center>
<p><br>* : new question
<br>+ : changed question
<p><img SRC="tribar.gif" height=13 width=561>
<h2>
<u>QUESTIONS</u></h2>
<i><a href="#General">GENERAL</a></i>
<br><a href="#1.1">1.1) What is GEM?</a>
<br><a href="#1.2">1.2) What is Pd?</a>
<br><a href="#1.3">1.3) What platforms do GEM and Pd run on?</a>
<br><a href="#1.4.0">1.4.0) How do I install GEM and Pd on IRIX?</a>
<br><a href="#1.4.1">1.4.1) How do I install GEM and Pd on linux?</a>
<br><a href="#1.4.2">1.4.2) How do I install GEM and Pd on WinNT?</a>
<br><a href="#1.7">1.7) What is a good intro to OpenGL?</a>
<br><a href="#1.8">1.8) Are there any web sites for Pd or GEM?</a>
<br><a href="#1.9">1.9) What libraries does GEM use? (aka: Who does Mark
want to thank?)</a>
<br><a href="#1.10">1.10) Are there any restrictions on GEM?</a>
<br><a href="#1.11">1.11) How do I use GEM in a performance?</a>
<p><i><a href="#UsingGem">USING GEM</a></i>
<br><a href="#2.1">2.1) How do I (???)</a>
<br><a href="#2.2">2.2) How do I make GEM run?</a>
<br><a href="#2.3">2.3) Why doesn't GEM run?</a>
<br><a href="#2.4">2.4) I've got it running. Now what?</a>
<br><a href="#2.5">2.5) On IRIX 5.3, why does GEM dump with an rld error?</a>
<br><a href="#2.6">2.6) Why can't I compile GEM on IRIX 5.3?</a>
<br><a href="#2.7">2.7) Why is GEM slow in general?</a>
<br><a href="#2.8">2.8) Why is GEM slow on IRIX?</a>
<br><a href="#2.9">2.9) Why is GEM slow on WinNT/Win95?</a>
<br><a href="#2.10">2.10) Why is GEM slow on Linux?</a>
<br><a href="#2.11">2.11) If I resize the window, everything looks strange.</a>
<br><a href="#2.12">2.12) Can GEM run on a 3Dfx Voodoo card?</a>
<br><a href="#2.13">2.13) Will GEM support hardware transform and lighting
(T&amp;L) ?</a>
<br><a href="#2.14">2.14) I get an error "GEM needs Truecolor visual support".</a>
<p><i><a href="#ViewingObjects">VIEWING OBJECTS</a></i>
<br><a href="#3.1">3.1) Why does everything seem dim?</a>
<br><a href="#3.2">3.2) Why does everything seem dark?</a>
<p><i><a href="#TextureMapping">TEXTURE MAPPING</a></i>
<br><a href="#4.1">4.1) My image doesn't appear. What is going on?</a>
<br><a href="#4.2">4.2) My image looks strange. What is going on?</a>
<br><a href="#4.3">4.3) Why does GEM say that it can't handle a gray image?</a>
<br><a href="#4.4">4.4) What image formats can GEM handle?</a>
<br><a href="#4.5">4.5) What movie formats can GEM handle?</a>
<br><a href="#4.6">4.6) Why is pix_draw so slow?</a>
<p><i><a href="#WorkingWithPd">WORKING WITH PD</a></i>
<br><a href="#5.1">5.1) Why do I get clicks in the audio?</a>
<br><a href="#5.2">5.2) How do I get audio data to GEM?</a>
<br><a href="#5.3">5.3) Why can't GEM find an image/model file?</a>
<br><a href="#5.4">5.4) How can I optimize my patches?</a>
<p><i><a href="#NewGemObjects">WRITING NEW GEM OBJECTS</a></i>
<br><a href="#6.1">6.1) How do I write a new GEM object?</a>
<br><a href="#6.2">6.2) What are the default OpenGL states?</a>
<p><i><a href="#ObjectSpecific">OBJECT SPECIFIC</a></i>
<br><a href="#7.1">7.1) Why doesn't &lt;object> exist on &lt;platform>?</a>
<br><a href="#7.2">7.2) Why doesn't gemtablet work?</a>
<br><a href="#7.3">7.3) I don't want GEM to take over my tablet.
How do I stop it?</a>
<br><a href="#7.4">7.4) Why doesn't gemmouse work in IRIX/Linux?</a>
<br><a href="#7.5">7.5) Why doesn't gemorb work?</a>
<br><a href="#7.6">7.6) What is wrong with pix_video in WinNT?</a>
<p><img SRC="tribar.gif" height=13 width=561>
<h2>
<u>ANSWERS</u></h2>
<a NAME="General"></a><h3>GENERAL</h3>
<br><a NAME="1.1"></a>1.1) What is GEM?
<p>GEM is the Graphics Environment for Multimedia.
It was originally written by <a href="mailto:mark@danks.org">Mark Danks</a> to generate real-time computer
graphics, especially for audio-visual compositions. It originally ran under
FTS/Max (which is why you might see some papers reference it), but all
new development is under Pd.
<p>You can get GEM at <a href="http://www.iem.at/GEM">http://gem.iem.at/</a>
<p>GEM was sponsored by a grant from Intel (<a href="http://www.intel.com">http://www.intel.com</a>)
<p>GEM was ported to <a href="http://www.linux.org">linux</a> by <a href="mailto:geiger@xdv.org">G&uuml;nter Geiger</a>
<p>GEM is now maintained by <a href="mailto:zmoelnig@iem.at">IOhannes m zm&ouml;lnig</a>.
<p>the core-development team consists of<ul>
<li>chris clepper</li>
<li>günter geiger</li>
<li>daniel heckenberg</li>
<li>james tittle</li>
<li>IOhannes m zmölnig</li></ul>
lots of contributions are made by various people (thanks to all of them)
<p>----
<br><a NAME="1.2"></a>1.2) What is Pd?
<p>Pd is a real-time environment for audio and MIDI.
It was written by <a href="mailto:msp@ucsd.edu">Miller Puckette</a>, who created FTS/Max when
he was at IRCAM. Basically, Pd can be seen as the next generation
of real-time visual programming languages. GEM runs inside of the
Pd environment.
<p>You can get Pd at <a href="http://www.crca.ucsd.edu/~msp/software.html">http://www.crca.ucsd.edu/~msp/software.html</a>
<p>Pd is sponsored by a grant from Intel (<a href="http://www.intel.com">http://www.intel.com</a>)
<p>----
<br><a NAME="1.3"></a>1.3) What platforms do GEM and Pd run on?
<p>GEM and Pd run on Windows (95, 98, ME, NT 4.0, 2000, XP), linux and macOS-X (&gt;10.2).
SGI-Irix (&gt; 6.2) used to be supported but i don't have any prove that it still works).
<a href="mailto:geiger@xdv.org">G&uuml;nter Geiger</a>
has done an initial port of GEM and Pd to Linux <a href="http://gige.epy.co.at/">http://gige.epy.co.at</a>).
<p>GEM is now maintained by <a href="mailto:zmoelnig@iem.at">me</a> and
developed by a team of several independent programmers (see <a href="1.1">section 1.1</a>)
<p>----
<br><a NAME="1.4"></a>1.4) How do I install GEM ?
<p>----
<br><a NAME="1.4.0"></a>1.4.0) How do I install GEM and Pd on IRIX?
<p>See the readme for installing Pd.
<p>GEM should be at
<p>pd/gem
<p>If you run GEM.INSTALL.sh, then all of the example files and documention
should be put in the correct locations.
<p>----
<br><a NAME="1.4.1"></a>1.4.1) How do I install GEM and Pd on linux?
<p>See the readme for installing Pd.
<p>GEM should be at
<p>chdir to &lt;gem&gt;/src/Gnu and build Gem following the instructions in the README.build
(<tt>./configure; make</tt>)
<p>If you then <tt>make install</tt>, then all of the example files and documention
should be put in the correct locations.
<p>if you are using debian, Gem should be available via apt</p>
<p>if you are using an rpm-based distribution, check out the builds at planetCCRMA</p>
<p>----
<br><a NAME="1.4.2"></a>1.4.2) How do I install GEM and Pd on WinNT?
<p>See the readme for installing Pd.
<p>unzip GEM so that it is at
<p>pd\gem
<p>If you run GEM.INSTALL.bat, then all of the example files and documentation
should be put in the correct locations.
<p>there is also an installer for windows.
<p>----
<br><a NAME="1.4.3"></a>1.4.3) How do I install GEM and Pd on macOS?
<p>See the readme for installing Pd.
<p>there is also an installer for macOS.
<p>----
<br><a NAME="1.7"></a>1.7) What is a good intro to OpenGL?
<p>The best book is the <u>OpenGL Programming Manual</u>
by Mason and Woo. This is also called the "Red Book". If you search
the web, there are many sites on OpenGL. A good starting point is
<a href="http://www.opengl.org">http://www.opengl.org</a>.
Also, Mark Kilgard (who used to work for SGI) has a wonderful site with
lots of links (<a href="http://reality.sgi.com/mjk">http://reality.sgi.com/mjk</a>)
Also, Normal Lin has written another great book on <u>3D-graphics under linux</u>
<p>----
<br><a NAME="1.8"></a>1.8) Are there any web sites for Pd or GEM?
<p>Except for the ones noted above, there is the Japanese
installation page at
<br><a href="http://www.rinc.or.jp/~kotobuki/gem/index.htm">http://www.rinc.or.jp/~kotobuki/gem/index.htm</a>
<p>There is a Pd mailing list. Subscription info
is on IEM's site <a href="http://www.iem.at/mailinglists/pd-list">http://www.iem.at/mailinglists/pd-list</a>
<p>One of pd's unofficial home-pages is at <a href="http://pd.iem.at">http://pd.iem.at</a> hosted by the
<a href="http://iem.at">Institute of Electronic Music and Acoustics, Graz, Austria</a>
<p>Also hosted by the <a href="http://iem.at">iem</a> is the site of the pd-community
<a href="http://www.puredata.info">http://www.puredata.info</a>
<p>An interesting place might also be G&uuml;nter Geiger's size <a href="http://gige.epy.co.at/">http://gige.epy.co.at/</a>
<p>there are lot's of other cool pages (search the net...)
<p>----
<br><a NAME="1.9"></a>1.9) What libraries does GEM use?
(aka: Who does Mark want to thank?)
<p>All copyrights and license info can be found in
<br> GEM.LICENSE.TERMS
<br> Thanks to Sam Leffner for libTiff, the TIFF image
loader.
<br>
sam@engr.sgi.com
<br> <a href="ftp://ftp.sgi.com/graphics/tiff/">ftp://ftp.sgi.com/graphics/tiff/</a>
<br> Thanks to Masayuki Matsumoto for fstimage for OpenGL,
the SGI
<br> image loader.
<br>
matumot@dst.nk-exa.co.jp
<br> Thanks to the Independent JPEG Group for libjpeg,
the JPEG image loader.
<br>
jpeg-info@uunet.uu.net
<br> <a href="ftp://ftp.simtel.net/pub/simtelnet/msdos/graphics/">ftp://ftp.simtel.net/pub/simtelnet/msdos/graphics/</a>
<br> Thanks to Mark Kilgard at al. (and SGI) for glut, the openGL Utility Toolkit
<br> <a href="http://www.pobox.com/~ndr">http://www.pobox.com/~ndr</a>
<br> Thanks to Stephane Rehel for GLTT, the OpenGL TrueType
render.
<br>
rehel@worldnet.fr
<br> <a href="http://home.worldnet.fr/~rehel/gltt/gltt.html">http://home.worldnet.fr/~rehel/gltt/gltt.html</a>
<br> Thanks to David Turner, Robert Wilhelm, and Werner
Lemberg for
<br> Freetype, a TrueType font
rendering engine.
<br>
turner@enst.fr
<br>
robert@physiol.med.tu-muenchen.de
<br>
a7971428@unet.univie.ac.at
<br> <a href="http://www.physiol.med.tu-muenchen.de/~robert/freetype.html">http://www.physiol.med.tu-muenchen.de/~robert/freetype.html</a>
<br> Thanks to the MPEG Software Simulation Group, for
libmpeg, the
<br>MPEG-2 Encoder/Decoder
<br>
mssg@mpeg.org
<br> <a href="http://www.mpeg.org/MSSG/">http://www.mpeg.org/MSSG/</a>
<br> Thanks to Heroine for quicktime4linux
a quickime Decoder
and libmpeg3, another MPEG-2 Encoder/Decoder
<br>MPEG-2 Encoder/Decoder
<br>
mssg@mpeg.org
<br> <a href="http://heroinewarrior.com/">http://heroinewarrior.com/</a>
<br> Thanks to LCS/Telegraphics for Wintab, the Windows
tablet library.
<br>
wintab@pointing.com
<br> Thanks to David McAllister for the Particle System
library.
<br>
davemc@cs.unc.edu
<br> <a href="http://www.cs.unc.edu/~davemc/Particle/">http://www.cs.unc.edu/~davemc/Particle/</a>
<br> Thanks to John Stone for the Space Orb library,
libOrb
<br>
j.stone@acm.org
<br> <a href="http://www.umr.edu/~johns/projects/liborb/">http://www.umr.edu/~johns/projects/liborb/</a>
<p>----
<br><a NAME="1.10"></a>1.10) Are there any restrictions on GEM?
<p>GEM is under the Gnu Public License. This basically
means that it will always be free software.Check out <a href="http://www.gnu.org">http://www.gnu.org</a>
for more information and read the full license in GnuGPL.LICENSE in the GEM release.
<p>----
<br><a NAME="1.11"></a>1.11) How do I use GEM in a performance?
<p>This is a constant problem, because there is no consistent
way to display video on any platform. Also, you usually do not want
to send the entire screen, but only the GEM window. It is also useful
to be able to edit/control the Pd patch window while the patch is actually
running.
<p>On SGIs, the best way is to get a video out option.
On the SGI O2, Impact, and Onyx (Mark has used all of these), there is a
simple connector or breakout box to do video.
If you run the video out program, then you will get a rectangle on your screen
which shows what is being sent out the video connector.
Make your GEM window a little larger than 640x480 and center it in the rectangle.
You can now project this with a standard video projector.
<p>On PCs it is a bit harder.
Several modern video-cards have the possibility to output several screens
(either 2 (or more) VGA-screens or 1 VGA-screen and 1 TV (Composite or S-HVS)
or a combination with DFTs)
If you have a Canopus Voodoo2 card it has a video and s-video output on it. As described
in <a href="#2.12">question 2.12</a>, you can get a Voodoo to work with
GEM. If any one else has a better solution, please let me know.
The nVidia Riva TNTs require that you output the full screen, so this is
not a very good option. You can use a video scan convertor.
Some of them only display a part of the scene, which is exactly what you
want.
<p>With modern multi-headed cards it is more simple:
Configure your card to display the desktop spread over your multiple screens
(e.g.: from left-to-right).
On windows and macOS you can do this via the display-properties dialog.
On linux you will have to edit your /etc/X11/XF86Config-4 file either by hand or
(if your system supports it) via an appropriate editor (yes, nowadays there are some).
Now create your gem-window on the second screen:
it should have the same dimensions as the 2nd screen (e.g: "[dimen 800 600(").
to place it at the second screen use the offset (e.g: if your primary sreen
(the one you want for patch-editing) has the dimension 1024x768 use "[offset 1024 0(",
which will create the gem-window 1024 pixels right of the upper-left corner
of the total screen (and 0 pixels below it),
which is exactly the upper-left corner of the 2nd screen.
You most probably want to turn off the borders with "[border 0(".<br>
<em>Note:</em> some grafix-card have openGL-hardware-acceleration only on the 1st screen
(so you should create the gem-window on the 1st screen and move
your patches to the 2nd screen)
<p>If you are using an XServer for displaying (under linux) you can also use another
computer for rendering.
You can specify the place where the gem-window should be created with something like
"create &lt;<em>render.host</em>&gt;:0.0"
<p>If you are doing audio with graphics, the only solution
to prevent clicking (<a href="#5.1">question 5.1</a>) is to run 2 computers
and have them communicate with netsend/netreceive. We are working
on making Pd/GEM multi-processor friendly, so if you have a multi-processor
system, you can run everything on one machine eventually.
<p>
<hr WIDTH="100%"><a NAME="UsingGem"></a><h3><i>USING GEM</i></h3>
<br><a NAME="2.1"></a>2.1)How do I (???)
<p>Many of the general usage questions are probably
answered in the manual or release notes. The pd mailing list is also
a good place to find answers as well.
<p><a NAME="2.2"></a>2.2) How do I make GEM run?
<p>GEM is not an executable. It requires Pd to
work and is loaded in at run time. For example, I have an alias on
the SGI which does
<p>/usr/people/mdanks/pd/bin/pd -lib /usr/people/mdanks/pd/gem/Gem
<p>and on WinNT
<p>\pdDir\pd\bin\pd -lib /pdDir/pd/gem/Gem
<p>on UNIX-systems you will probably want to use a <tt>.pdrc</tt> file,
where you can put the command-line arguments for pd that you "always" need.
<p>If you don't see a startup message from GEM, then something went wrong.
<p>Most people use use the command shell to start Pd.
It is not very difficult to configure Pd to run from double-clicking on the icon.
<p>----
<br><a NAME="2.3"></a>2.3) Why doesn't GEM run?
<p><b>Notice that the -lib flag always requires Unix
styles slashes</b>. This is the case even on Windows.
<p>You may also want to use the -nosound flag.
For instance, my PC has problems using audio (it leaks memory), so I just
turn off the audio part of Pd. However, other people can't get GEM
to work if the -nosound is used (on Win95). You can also try the
-dac or -adc flags (for digital-analog-conversion only and analog-digital-conversion
only).
<p>----
<br><a NAME="2.4"></a>2.4) I've got it running. Now what?
<p>Try out the manual. It will step you through
the basics.
<br> You will also want to look at the example files.
Assuming that everything is installed correctly, you can get to the examples
by going to the Help menu in Pd and selecting examples. A bunch of
the patches should start with gem&lt;something>. The best one is
<i>gem/01.basic/01.redSquare.pd</i>
It puts a red square up on the screen and allows you to rotate it. <i>gemImage.pd</i>
shows how to load in a TIFF file. <i>gem/03.lighting/04.moveSpheres.pd</i>
moves two spheres around the screen. Try the other ones.
<br> Most of the GEM objects have test patches which
give some information about the various controls for the object.
<p>----
<br><a NAME="2.5"></a>2.5) On IRIX 5.3, why does GEM dump with an rld error?
<p>GEM only works under IRIX 6.2+. The rld error
is probably something about not having glBindTextureEXT (or something).
OpenGL 1.0 has some extensions to speed up texture mapping (which are an
integral part of OpenGL 1.1). However, these don't exist on IRIX
5.3. If you recompile GEM (see the next question), things should
work fine.
<br> I don't have access to an IRIX machine, so don't
expect any builds from me. Upgrading to IRIX 6.2+ is worth it.
<p>----
<br><a NAME="2.6"></a>2.6) Why can't I compile GEM on IRIX 5.3?
<p>There was probably an error saying that the compiler
couldn't find the file "dmedia/vl_vino.h" in pix_videoSGI.cpp. IRIX
6.2+ adds new functionality to the media libraries which makes life much
easier. You cannot compile pix_video or pix_indycam as is under 5.3.
You can remove them from the Pix/Makefile and from the linker part of the
global Makefile. You will also need to recompile the Td and Tiff
libraries.
<p>There shouldn't be any problems doing this. I haven't tried any
of this, so if it works for someone, please let me know.
<p>----
<br><a NAME="2.7"></a>2.7) Why is GEM slow in general?
<p>Examine what you are doing. If you are constantly
changing textures, then this is probably your problem. If you have
models with a million triangles, then this is probably the problem.
Compare what you are doing with realistic specs on your system. Some
systems slow down when they have to draw very large polygons (slow fill
rate).
<br> You can also turn on profiling to see how long it
takes to render a frame. Send a profile message to the gemwin object.
The number that is printed is the number of milliseconds one frame takes
to render. 50 milliseconds is 20 frames per second. 'profile 2' is
good if you want to see how long the image processing is taking.
<br> profile 0 - turn off profiling
<br> profile 1 - turn on profiling
<br> profile 2 - turn on profiling
and don't cache pixes
<p>----
<br><a NAME="2.8"></a>2.8) Why is GEM slow on IRIX?
<p>If you are having major slowdowns, then please let
me know. I have gotten very good performance on most machines (Indy,
O2, Impact, Onyx2).
<p>----
<br><a NAME="2.9"></a>2.9) Why is GEM slow on WinNT/Win95?
<p>You probably don't have hardware acceleration.
You can use software rendering, but it basically useless except for extremely
basic patches. You can get a good graphics accelerator for really
cheap these days. I recommend a card based on nVidia's chipsets,
such as the TNT2 or GeForce, but there are other companies such as 3dfx
and Matrox. Make sure that you are running the latest drivers for
your card. The basic drivers that come with the cards are usually
very bad.
<br> Also, PCs don't deal with lots of texture maps very
well (they are bus limited, at least until AGP), so if you are trying to
use lots of constantly changing texture maps
(especially with [pix_multiimage], [pix_video] or [pix_film]), that will cause problems.
<p>----
<br><a NAME="2.10"></a>2.10) Why is GEM slow on Linux?
<p>It is because you have to use Mesa, which might be
running iin software. Mesa (<a href="http://www.mesa.org">http://www.mesa.org</a>)
is an awesome package by Brian Paul (brianp@avid.com) which "emulates"
OpenGL. Basically, it is a fully compliant OpenGL package, but it
isn't officially sanctioned by the OpenGL ARB, such, it is doesn't have
the OpenGL name. There is an acceleration package for the many graphics
card, but I don't know anything about it.
<br>nVidia is being very supportive of Linux:
their TNT2 and GeForce cards work under Linux with hardware-acceleration of openGL.
(but the drivers are proprietary)
<br>radeon cards should also be supported very well under linux (even with open-source drivers)
<p>----
<br><a NAME="2.11"></a>2.11) If I resize the window, everything looks strange.
<p>GEM doesn't trap resize events in IRIX or Linux (this
is not a problem in WinNT). This means that OpenGL doesn't have the
correct information to render properly. If you want to resize the
window, send a 'dimen x y' message to gemwin before you create the window.
<p>----
<br><a NAME="2.12"></a>2.12) Can GEM run on a 3Dfx Voodoo card?
<p>I (this is: Mark Danks) have a Voodoo2 card, which runs fine under WinNT.
I use the OpenGL beta driver from 3Dfx at work all the time without any
problems and, except that the Voodoo takes over the full screen, it seems
to work fine. You will need to download the OpenGL Beta driver from
3Dfx's web site at http://www.3dfx.com and put the OpenGL32.dll into the
same directory as pd.exe (NOT gem.dll). Debugging patches is much
easier if you have two monitors, one for the 3-D card and one for the 2-D
card.
<p>IMPORTANT: You MUST set the environment variable
<p>GEM_SINGLE_CONTEXT = 1
<p>to make the Voodoo card work. It will make a window 640x480 (which
is the correct size for TV video out on my Canopus V2 card). On WinNT,
right click "My Computer" and go to "Properties". On the "Environment"
tab, you need to add the variable "GEM_SINGLE_CONTEXT" with a value of
1.
<br>Resizing the GEM window with a Voodoo card is not
a great idea. The Voodoo card can only display certain window sizes and
will clip the graphics.
<p>For the tech heads in the audience...I create an
OpenGL context at startup and never actually display its associated window.
This means that GEM objects can create display lists, call OpenGL commands,
etc. in their constructors, even if no window is actually being displayed.
However, with the Voodoo card, there can only be one OpenGL context.
So, instead of creating one context and just holding onto it in the background,
I create the normal GEM window and associate the OpenGL context with it...and
the user can never destroy or close that window.
<p>----
<br><a NAME="2.13"></a>2.13) Will GEM support hardware transform and lighting
(T &amp; L)?
<p>Absolutely! Unlike some other APIs, OpenGL
will automatically use hardware accelerated transform and lighting if the
card has it. GEM gets great performance from cards like nVidia's
GeForce.
<p><a NAME="2.14"></a>2.14) I get an error "GEM needs Truecolor visual
support".
<p>This error means that your X display is running with
paletted colors, which is the result of limited color depth. If you
start the X display with
<p>startx -- -bpp 16
<p>or some higher number, then it should work fine. 32-bit color
is the best.
<p>
<hr WIDTH="100%"><a NAME="ViewingObjects"></a><h3><i>VIEWING OBJECTS</i></h3>
<br><a NAME="3.1"></a>3.1)Why does everything seem dim?<
<p>You probably turned on lighting but don't have any
lights in the world. Either add a light with <i>world_light</i> or
<i>light</i>
or turn lighting off by sending a message 'lighting 0' to the <i>gemwin</i>.
You can also send a reset message to <i>gemwin</i> to set it back to the
startup state (which doesn't have any lighting).
<p>----
<br><a NAME="3.2"></a>3.2) Why does everything seem dark?
<p>See question 3.1.
<br> If you are using <tt>view</tt> in your patch to change the viewpoint,
you may not be pointing in the correct direction. You also might have translated
everything outside of the current viewport.
<br> Also, if you have been using single buffering ('buffer
1' message to <i>gemwin</i>), then you might still be in that mode.
Either send a 'buffer 2' message or a 'reset' message to <i>gemwin</i>.
Then, destroy and create your window.
<p>
<hr WIDTH="100%"><a NAME="TextureMapping"></a><h3><i>TEXTURE MAPPING</i></h3>
<br><a NAME="4.1"></a>4.1) My image doesn't appear. What is going
on?
<p>Normally images have to be texture-mapped onto Geos.
You have to use [pix_texture] to map the current image onto a Geo.
"Current" means that any pix-manipulation that is done after texturing will not be displayed.
<p>Any Geo has a color (which is initially set to white).
If you have set the color to black, your Geo (including the image) might be very dark.
If you are using alpha-blending, make sure that the Geo is not invisible.
<p>Normally images that want to be texture mapped with openGL should have dimensions that are a power of 2 in both height and width.
Now [pix_texture] will make this totally transparent to you (so normally you don't have to care about the size of the image).
However with non-power-of-2 images <i>pix_coordinate</i> might not behave as expected,
because these images need absolute texture-coordinates rather than normalized ones
(as are used with power-of-2 images): so if the texture-coordinates are set to "(0,0) (1,0) (1,1) (0,1)" you might see only the first pixel of the image (which might be black).
<p>Also, make sure that GEM can find your image (ie,
that the path name is correct).
<p>----
<br><a NAME="4.2"></a>4.2) My image looks strange. What is going
on?
<p>GEM supports gray8, YUV, and RGBA images. If
it sees that the number of bits per channel and the number of channels
is something that it should be able to handle, it tries to load the raw
data. If you have compressed or stored the pixel data in some "strange"
format, then GEM will probably not read the information correctly.
<br> Also, if it is an RGBA image, then make sure that
the alpha channel is something useful (this only matters if you are using
the alpha channel, like in the alpha object or pix_mask).
<p>----
<br><a NAME="4.3"></a>4.3) Why does GEM say that it can't handle a gray
image?
<p>This error message occurs whenever a pix object receives
a gray8 image and the implementor hasn't provided a way to deal with that
format of image. (Implementors often only provide functions for GEM's <i>native</i>
color-format RGBA. Any other color-format (like BGR) will try to call the function
for gray8 images, which might not be supported.)
If you do not want to change the image format with some extern image-programm
(like Photoshop or the Gimp) you might want to try <i>pix_rgba</a>
or harass whoever made the object to add the functionality.
<p>----
<br><a NAME="4.4"></a>4.4) What image formats can GEM handle?
<p>GEM can read in TIFF, JPEG, and SGI images.
These can be in any color format. Gray scale images are loaded in
as gray scale (ie, one byte per pixel). Everything else is loaded
in or converted to an RGBA image (ie, four bytes per pixel). If there
is an alpha channel, then it will be respected. Otherwise, the alpha
channel will be set to fully opaque (alpha == 255).
<p>GEM can write TIFF and JPEG images.
TIFF-images will be full RGBA-images, wheras JPEG-files only support (compressed) RGB.
<p>----
<br><a NAME="4.5"></a>4.5) What movie formats can GEM handle?
<p>The movie formats GEM can handle (still) depend on the platform
you are using.
<p>On Windoze you can read all AVI-files you have codecs for
<p>On linux the readable formats depend on the libraries you had installed when you compiled GEM.
Currently there is (optional) support for AVI, quicktime (*.MOV) and MPEG (*.MPG) files.
Not all quicktime-formats are supported. This is unfortunate but is due to linux restrictions.
I highly recommend that you install the mpeg3-library from Heroine because it is much more stable than mpeg1 (which comes with many linux-distributions).
If you have compiled in support for libavifile, you will be able to open Micro$oft-AVI-files.
If you have installed the proper codecs
(libavifile supports a mechanism for loading codecs from windows-DLLs) you should be able to
open almost any format.
If you have serious problems, mail them <a href="mailto:zmoelnig@iem.at">to me</a>.
(Be ready to upload the movie-file that won't work)
<p>----
<br><a NAME="4.6"></a>4.6) Why is <i>pix_draw</i> so slow?
<p><i>pix_draw</i> is almost never hardware accelerated
on PCs graphics accelerator. This means that it runs <i>extremely</i>
slowly. Always use <i>pix_texture</i>, even if you are just displaying
an image.
<p>
<hr WIDTH="100%"><a NAME="WorkingWithPd"></a><h3><i>WORKING WITH PD</i></h3>
<br><a NAME="5.1"></a>5.1) Why do I get clicks in the audio?
<p>If you are getting a constant stream of clicks in
your audio, then it is probably because you are trying to do graphics and
audio in the same process. Rendering a graphics frame usually takes
longer than the size of the audio buffer, which is why you get clicks (the
clicks are usually at 20Hz...the typical frame rate).
<br> One way around this is to use two computers, one
for graphics and one for audio. If you have enough processing power
(or dual processors), then you can run two versions of Pd, one for graphics
and one for audio. Just use <i>netsend</i> and <i>netreceive</i>
to have the two versions of Pd talk to each other.
<p>----
<br><a NAME="5.2"></a>5.2) How do I get audio data to GEM?
<p>One simple way to get raw audio values right now is
to use <i>snapshot~</i>. Just set up a <i>metro</i> which bangs <i>snapshot~</i>
and use the floating point value. If you want "musical" information,
then use objects such as <i>env~</i>.
You might also have a look at the <i>pix_sig2pix~</i> which interprets audio-data as pixels
and its counterpart <i>pix_pix2sig~</i>
<p>----
<br><a NAME="5.3"></a>5.3) Why can't GEM find an image/model file?
<p>This means that GEM can't locate the file.
If you use an absolute path (with / for instance), then GEM will look there.
Otherwise, GEM will look in the directory of where the patch is.
Then pd/GEM will search the paths you specified at startup with the <i>-path</i> flag.
<p>Check the following:
<p>1) Does the file exist?
<br> 2) Did you make a typo in the filename?
<br> 3) Is the file in the search-path ?
<p>----
<br><a NAME="5.4"></a>5.4) How can I optimize my patches?
<p>One of the biggest performance hits is having UI
elements in your patch which have to be updated. The biggest performance
hog is the number box. While the number box is great for debugging,
make sure that they are all gone from your "release" patch. If you
run a performance meter, you will see that whenever Tcl/Tk has to update
the user interface, it sucks the entire processor. Another examples
of this is when you move a lot of objects at once, everything jerks and
slides across the screen. There are probably ways to improve this...
<br> Another problem is doing unneccessary calculations.
When you are throwing lots of numbers around, especially packing/unpacking,
doing vector math, etc., they add up. If the calculations are going
unused (for instance, that part of the patch is turned off), then do not
trigger the math objects. Use <i>spigot</i> or <i>gate</i> and block
the events early. This is especially important with objects that
send a lot of numbers, like ~ objects or <i>line</i>/<i>tripleLine</i>.
<p>
<hr WIDTH="100%"><a NAME="NewGemObjects"></a><h3><i>WRITING NEW GEM OBJECTS</i></h3>
<br><a NAME="6.1"></a>6.1) How do I write a new GEM object?
<p>For the time being, you have to look at the code.
It is fairly well documented and straight forward (if you know C++ and
OOP). Start with an object which is similar to what you want and
derive a new class. The biggest issue right now is how to load in
GEM as a DSO/DLL. For SGIs, you will need to setenv LD_LIBRARY_PATH.
On NT, you will need to have your path include the directory with GEM.
<p>----
<br><a NAME="6.2"></a>6.2) What are the default OpenGL states?
<p>GemMan (and by association, gemwin) disables alpha
testing, alpha blending, culling, and lighting. Lighting defaults
to two sided, with GL_COLOR_MATERIAL enabled. The viewport is set
to
<p>float xDivy = (float)m_width / (float)m_height;
<br> glMatrixMode(GL_PROJECTION);
<br> glLoadIdentity();
<br> glFrustum(-xDivy, xDivy, -1.0, 1.0, 1.0, 20.0);
<br> gluLookAt(0.0, 0.0, 4.0, 0.0, 0.0, 0.0, 0.0, 1.0,
0.0);
<br> glMatrixMode(GL_MODELVIEW);
<br> glViewport(0, 0, m_width, m_height);
<p>which gives a range of about -4 to 4 in X and Y at the origin.
This is a small range, but changing it now would break a lot of patches.
<p>The specific functions to look at are:
<p>GemMan::windowInit()
<br>GemMan::resetValues()
<br>gemhead::renderGL()
<p>
<hr WIDTH="100%"><a NAME="ObjectSpecific"></a><h3><i>OBJECT SPECIFIC</i></h3>
<br><a NAME="7.1"></a>7.1) Why doesn't &lt;object> exist on &lt;platform>?
<p>Usually, this is because I don't have the resources
to get the object running on that platform. If an object that you
want doesn't exist on your platform, then ask for it! However, if
it is tied to hardware, then it is much less likely that I will be able
to do anything about it (unless someone donates the hardware to me...)
<p>----
<br><a NAME="7.2"></a>7.2) Why doesn't <i>gemtablet</i> work?
<p><i>gemtablet</i> only works on WinNT. I don't
have drivers for IRIX or Linux (also, see question 7.4)
<br> If GEM can find the tablet, then it will print a
message at window creation time. If you don't see a message, then
GEM doesn't think that you have a tablet.
<br> The tablet is mapped to the size of the GEM graphics
window.
<p>---
<br><a NAME="7.3"></a>7.3) I don't want GEM to take over my tablet.
How do I stop it?
<p>Set the environment variable
<p>GEM_NO_TABLET = 1
<p>----
<br><a NAME="7.4"></a>7.4) Why doesn't <i>gemmouse</i> work in IRIX?
<p>Basically, I don't have physical access to an SGI machine.
This makes it hard to do some of the OS specific work.
It should be straightforward to do the event handling, so if someone gets
it working, I would love to include it (and give you credit). All
you have to do is call the correct event functions from GemEvent.h and
everything should just start to work (ie, gemmouse doesn't have any OS
specific code in it).
<p>----
<br><a NAME="7.5"></a>7.5) Why doesn't gemorb work?
<p>You need to make sure that your SpaceOrb is hooked
up correctly. I am using a library which isn't supported by SpaceTec so
there can be problems, although I have not had any.
<br> &lt;RANT> When will companies wake up and actually
provide drivers and support for their products under WinNT? &lt;/RANT>
<p>----
<br><a NAME="7.6"></a>7.6) What is wrong with <i>pix_video</i> in WinNT?
<p>I haven't completely figured out how to get access
to the video stream in WinNT. I'm using Video for Windows with a
Connectix QuickCam, as well as an Intel Video Capture Card, and it seems
to assume that you are only writing to a file or previewing into a window.
Windows tries to take over the system and doesn't really provide any stable
hooks (unlike IRIX). If anyone knows how to deal with this, please
let me know.
<p><a href="index.html">[return]</a>
<br>
<br>
</body>
</html>

140
Gem/doc/manual/GemWPd.html Normal file
View file

@ -0,0 +1,140 @@
<!doctype html public "-//w3c//dtd html 4.0 transitional//en">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<meta name="Author" content="Mark Danks">
<meta name="GENERATOR" content="Mozilla/4.5 [en] (WinNT; I) [Netscape]">
<title>Using GEM with Pd</title>
</head>
<body>
<center>
<h2>
<u>Using GEM with Pd</u></h2></center>
&nbsp;&nbsp;&nbsp; An important fact is that GEM is NOT an application.
It is a library that the application Pd loads in at run-time.&nbsp; Most
of this information is taken directly from the GEM FAQ.
<p><a href="#GEMIrix">How do I install GEM on IRIX?</a>
<br><a href="#GEMWinNT">How do I install GEM on Win95/NT/2k?</a>
<br><a href="#GEMlinux">How do I install GEM on linux?</a>
<br><a href="#GEMmacos">How do I install GEM on macOS-X?</a>
<br><a href="#runIRIX">How do I run GEM on IRIX?</a>
<br><a href="#runWinNT">How do I run GEM on Win95/NT/2k?</a>
<br><a href="#runlinux">How do I run GEM on linux?</a>
<br><a href="#runmacos">How do I run GEM on linux?</a>
<br><a href="#noRun">Why doesn't GEM run?</a>
<p><img SRC="tribar.gif" height=13 width=561>
<h4>
<a NAME="GEMIrix"></a><u>How do I install GEM and Pd on IRIX?</u></h4>
See the readme for installing Pd.
<p>Uncompress and untar the GEM file that you downloaded.&nbsp; GEM should
be located at
<p>pd/gem
<p>depending on where you have installed Pd.
<p>If you run the shell script, GEM.INSTALL.sh, then all of the example
files and documention
<br>should be put in the correct locations.
<p><img SRC="tribar.gif" height=13 width=561>
<h4>
<a NAME="GEMWinNT"></a><u>How do I install GEM and Pd on WinNT?</u></h4>
See the readme for installing Pd.
<p>TODO: there should be a install package somewhere
<p>Unzip the GEM file that you downloaded so that it is at
<p>pd\gem
<p>depending on where you have installed Pd.
<p>If you run GEM.INSTALL.bat, then all of the example files and documentation
should be put in the correct locations.
<p><img SRC="tribar.gif" height=13 width=561>
<h4>
<a NAME="GEMlinux"></a><u>How do I install GEM and Pd on linux?</u></h4>
See the readme for installing Pd.
<p>Uncompress and untar the GEM file that you downloaded so that it is at
<p>pd/gem
<p>depending on where you have installed Pd.
<p>chdir into &lt;pd/gem&gt;/src/Gnu
<p>read the README.build
<p>run <tt>./configure</tt> and afterwards <tt>make</tt>
<p>If you run <tt>make install</tt>, then all of the example files and documentation
should be put in the correct locations.
<p><img SRC="tribar.gif" height=13 width=561>
<h4>
<a NAME="GEMmacos"></a><u>How do I install GEM and Pd on macOS-X?</u></h4>
See the readme for installing Pd.
<p>TODO: there should be a install package somewhere
<p><img SRC="tribar.gif" height=13 width=561>
<h4>
<a NAME="runIRIX"></a><u>How do I run GEM on IRIX?</u></h4>
&nbsp;&nbsp; To use GEM type something like:
<p>/usr/people/mdanks/pd/bin/pd -lib /usr/people/mdanks/pd/gem/Gem
<p>(where /usr/people/mdanks is the path to the pd directory). Check out
the README for Pd to see examples of the -lib flag. If you just try to
"run" GEM, you will get an error! Notice that last word is a capital Gem.
If you get a "can't find gem_setup" error, then that is the problem. Look
in the GEM FAQ
<br>for trouble shooting suggestions.
<p>If you don't see startup messages from GEM, then something went wrong.
<br>Also, you might need to add pd/bin to your PATH environment variable.
<p><img SRC="tribar.gif" height=13 width=561>
<h4>
<a NAME="runWinNT"></a><u>How do I run GEM on Win95/NT?</u></h4>
&nbsp;&nbsp;&nbsp; It is best to start Pd from a DOS command line.&nbsp;
If you go to the Start menu, you should find an application called "Command
Prompt" under the Program menu.&nbsp; You need to change to the drive where
you installed Pd.&nbsp; For instance, if it is on your D: drive, just type
d: at the prompt.
<p>&nbsp;&nbsp; To use GEM type something like:
<p>\pd\bin\pd -lib /pd/gem/Gem
<p>depending on where you installed Pd.
<p>&nbsp;&nbsp;&nbsp; Check out the README for Pd to see examples of the
-lib flag. If you just try to double click GEM, you will get an error!
Notice that last word is a capital Gem. If you get a "can't find gem_setup"
error, then that is the problem. Look in the GEM FAQ for trouble shooting
suggestions.
<p>If you don't see a startup message from GEM, then something went wrong.
<p>&nbsp;&nbsp;&nbsp; Most people use the command shell to start Pd.&nbsp;
It is difficult to configure Pd to run from double-clicking on the icon.
<p>&nbsp;&nbsp;&nbsp; Also, you might need to add pd/bin to your PATH environment
variable.
<p><img SRC="tribar.gif" height=13 width=561>
<h4>
<a NAME="runIRIX"></a><u>How do I run GEM on linux?</u></h4>
&nbsp;&nbsp; To use GEM type something like:
<p>/usr/people/mdanks/pd/bin/pd -lib /usr/people/mdanks/pd/gem/Gem
<p>(where /usr/people/mdanks is the path to the pd directory). Check out
the README for Pd to see examples of the -lib flag. If you just try to
"run" GEM, you will get an error! Notice that last word is a capital Gem.
If you get a "can't find gem_setup" error, then that is the problem. Look
in the GEM FAQ
<br>for trouble shooting suggestions.
<p>If you don't see startup messages from GEM, then something went wrong.
<br>Also, you might need to add pd/bin to your PATH environment variable.
<p><img SRC="tribar.gif" height=13 width=561>
<h4>
<a NAME="runIRIX"></a><u>How do I run GEM on macOS-X?</u></h4>
&nbsp;&nbsp; To use GEM type something like:
<code>/usr/local/bin/pd -lib /Users/zmoelnig/pd/Gem</code>
<p>(where /usr/local/bin/pd is the path to the pd directory and
/Users/zmoelnig/pd is the path where the <i>Gem.pd_darwin</i> resides).
Check out the README for Pd to see examples of the -lib flag. If you just try to
"run" GEM, you will get an error! Notice that last word is a capital Gem.
If you get a "can't find gem_setup" error, then that is the problem. Look
in the GEM FAQ
<br>for trouble shooting suggestions.
<p>If you don't see startup messages from GEM, then something went wrong.
<br>Also, you might need to add pd/bin to your PATH environment variable.
<p><img SRC="tribar.gif" height=13 width=561>
<h4>
<a NAME="noRun"></a><u>Why doesn't GEM run?</u></h4>
&nbsp;&nbsp;&nbsp; Notice that the -lib flag always requires Unix styles
slashes, even if you are on Windows.&nbsp; This means that you need to
do <i>-lib /gem/Gem</i>, not <i>-lib \gem\Gem</i>
<p>&nbsp;&nbsp;&nbsp; You may also want to use the -nosound flag.&nbsp;
For instance, my PC has problems using audio (it leaks memory), so I just
turn off the audio part of Pd.&nbsp; However, other people can't get GEM
to work if the -nosound is used (on Win95).&nbsp; You can also try the
-dac or -adc flags (for digital-analog-conversion only and analog-digital-conversion
only).
<p><a href="index.html">[return]</a>
<br>&nbsp;
</body>
</html>

41
Gem/doc/manual/Gloss.html Normal file
View file

@ -0,0 +1,41 @@
<!doctype html public "-//w3c//dtd html 4.0 transitional//en">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<meta name="Author" content="Mark Danks">
<meta name="GENERATOR" content="Mozilla/4.5 [en] (WinNT; I) [Netscape]">
<title>Glossary/Index</title>
</head>
<body>
<center>
<h2>
<u>Glossary</u></h2></center>
<a NAME="Alpha"></a>Alpha - The amount of opacity.&nbsp; An alpha equal
to 1.0 means completely opaque.&nbsp; An alpha equal to 0.0 means completely
transparent.
<p><a NAME="Controls"></a>Controls - GEM objects which access the low levels
of GEM, such as window managers.
<p><a NAME="Geos"></a>Geos - GEM objects which have a shape of some kind,
such as a cube.
<p><a NAME="Manips"></a>Manips - GEM objects which manipulate the geos.
<p><a NAME="MarkEx"></a>MarkEx - A collection of objects which help with
data manipulation, especially for usage in GEM.
<p><a NAME="Nongeos"></a>Nongeos - GEM objects which do not have an explicit
shape, yet affect the rendering in some way.
<p><a NAME="OpenGL"></a><a href="http://www.opengl.org">OpenGL</a> - A
graphics API which exists on many different platforms.<br>
Gem can <i>also</i> be used as a wrapper for openGL, allowing to program openGL without having to
compile
<p><a NAME="Particles"></a>Particles - GEM objects which involve the particle
system.
<p><a NAME="Pd"></a><a href="http://pd.iem.at">Pd</a>
- A visual programming language for audio processing.&nbsp; This is the
host application for GEM.
<p><a NAME="Pixes"></a>Pixes - Image processing objects in GEM
<p><a NAME="Texture"></a>Texture mapping - Applying an image to a geometric
object.
<p><a href="index.html">[return]</a>
<br>&nbsp;
</body>
</html>

112
Gem/doc/manual/Images.html Normal file
View file

@ -0,0 +1,112 @@
<!doctype html public "-//w3c//dtd html 4.0 transitional//en">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<meta name="Author" content="Mark Danks">
<meta name="Author" content="IOhannes m zmölnig">
<title>Images</title>
</head>
<body>
<center>
<h2>
<u>Dealing with Images</u></h2></center>
Images are files which are loaded into GEM. The images can be manipulated,
applied to objects, and used in any number of different ways. In
this section, you will load in an image and display it on the screen.
This section will not apply the images to a <i>geo</i>; that occurs in
the next part of the manual.
<p>The pix objects are GEM objects which deal with <i>pix</i>els.
They do everything from loading in images to applying filters to the data.
The objects in this section of the manual only load in pix data from outside
sources. How you actually display the image is up to you. The
most common usages are with <i>[pix_draw]</i> and <i>[pix_texture]</i>.
<p><b>Warning</b>: <i>[pix_draw]</i> is almost always slower than <i>[pix_texture]</i>.
Because <i>[pix_draw]</i> is easier to use than <i>[pix_texture]</i>, it is
used in these examples. However, in any real usage or piece, <i>[pix_texture]</i>
should always be used instead. <i>[pix_draw]</i> is slow because PC
graphics accelerators do not provide hardware acceleration for that functionality.
<i>[pix_texture]</i> does have hardware acceleration and will be much faster.
<p><a href="#pix_image">[pix_image]</a> - load in an image
<br><a href="#pix_multiimage">[pix_multiimage]</a> - load in multiple images
<br><a href="#pix_movie">[pix_movie]</a> - load in a movie file
<br><a href="#pix_video">[pix_video]</a> - use a real time video source
<p><img SRC="tribar.gif" height=13 width=561>
<h3>
<a NAME="pix_image"></a>[pix_image]</h3>
<i>[pix_image]</i> is used to load in images. Images can be in a variety
of different formats, including TIFF, JPEG, and SGI formats. The
patch gem_pix/gemImage.pd is the simplest use of the <i>[pix_image]</i> object.
In this patch, the <i>[pix_image]</i> object loads in the file dancer.JPG.
<center>
<p><img SRC="pixImage.jpg" BORDER=1 height=180 width=151></center>
<p>As is the case with every GEM chain, this patch starts with the <i>[gemhead]</i>
object. The next object is <i>[pix_image]</i>, which actually loads
the image. <i>[pix_image]</i> makes the file dancer.JPG the current
pixel data, which will be used in all subsequent operations in the chain.
The <i>[translateXYZ]</i> object is used to move the image around.
Finally, the <i>[pix_draw]</i> object renders the pixel data to the screen.
<p>The patch mentions that changing the Z in <i>[translateXYZ]</i> does not
change the size of the image, as would occur with a <i>geo</i> object like
<i>[square]</i>.
This is because <i>[pix_draw]</i> simply draws the pixel at the current raster
position, without any transformation. If you want to change the size
on the fly and rotate the image, you need to texture map the pix, which
is described in the next section.
<p><img SRC="tribar.gif" height=13 width=561>
<h3>
<a NAME="pix_multiimage"></a>[pix_multiimage]</h3>
The <i>[pix_image]</i> object only loads in one image at time. If you
try to change the image rapidly while the patch is running, you will notice
a lag every time it has to load in a new file. To avoid this lag,
there is another object called <i>[pix_multiimage]</i>. If you look
at patch gem_pix/gemMultiImage.pd, you will see this object in action.
<p>Basically, the * in the file name is replaced by the number that you
pass in. This allows you to play sequences of images with random
access. The one downside is that every image is loaded into memory
when the object is created, so you need to have a lot of RAM to use it.
<p><img SRC="tribar.gif" height=13 width=561>
<h3><a NAME="pix_movie"></a>[pix_movie]/[pix_film]</h3>
These objects are used to read movie-files from disk (or if supported from the internet).
The movie is streamed off of disk,
using whatever decompression libraries are installed on your computer.
On Windows AVI movies seem to work fine,
but there is also a prelaminary support for quicktimes (and mpeg).
On macOS-X all formats supported by the system (basically: quicktime) should work ok.
On linux the support is highly depending on what libraries are installed during compile time.
There is support for MPEG (with libmpeg1 or (preferred:) libmpeg3),
quicktime (either libquicktime or quicktime4linux;
most likely you will not be able to decode quicktimes with proprietary codecs)
and AVI (with libavifile which is able to utilize windows-dlls for (proprietary) codecs).
There is also some rudimentary support for FFMPEG.
The right inlet of <i>[pix_movie]</i>
accepts a number to specify the frame to display. Look at 04.pix/04.movie.pd
for an image.
<p>A key fact of <i>[pix_movie]</i> is that it immediately sends the movie
data to OpenGL as a texture map. This means that you do not need
the <i>[pix_texture]</i> object in your chain. This also means that
you cannot process the movie data with pix objects. The main reason
for this is that it removes the need for a copy of all of the movie data.
If you want to apply some image-processing, you will have to use <i>[pix_film]</i>
(and <i>[pix_texture]</i> for texture-mapping).
<p>Some of the geos will not texture map the <i>[pix_movie]</i> data correctly.
Cone and sphere do not use texture coordinates when they are provided,
so when you display a movie on one of these objects, you will have a black
region (unless your movie size is a power of two...however, most movies
are 320x160 pixels or something). This will be fixed in a future
release.
<p><img SRC="tribar.gif" height=13 width=561>
<h3>
<a NAME="pix_video"></a>pix_video</h3>
The "image" can come from the <i>[pix_video]</i> object.
This means that you can use a real-time video source and display it on the screen.
<p>You can play with <i>[pix_video]</i> with the patches in 04.video/.
The patches are explained in more depth in the advanced section of the GEM manual.
<p><img SRC="tribar.gif" height=13 width=561>
<p><a href="index.html">[return]</a>
<br>
</body>
</html>

19
Gem/doc/manual/Input.html Normal file
View file

@ -0,0 +1,19 @@
<!doctype html public "-//w3c//dtd html 4.0 transitional//en">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<meta name="Author" content="Mark Danks">
<meta name="GENERATOR" content="Mozilla/4.5 [en] (WinNT; I) [Netscape]">
<title>Input devices</title>
</head>
<body>
<center>
<h2>
<u>Input devices</u></h2></center>
<p><br>Nothing here yet
<p><a href="index.html">[return]</a>
<br>&nbsp;
</body>
</html>

62
Gem/doc/manual/Intro.html Normal file
View file

@ -0,0 +1,62 @@
<!doctype html public "-//w3c//dtd html 4.0 transitional//en">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<meta name="Author" content="Mark Danks">
<meta name="GENERATOR" content="Mozilla/4.5 [en] (WinNT; I) [Netscape]">
<title>GEM - Introduction</title>
</head>
<body>
<center>
<h2>
<u>Introduction</u></h2></center>
GEM is the Graphics Environment for Multimedia. It was originally written by
<a href="http://www.danks.org/mark">Mark Danks</a> to generate real-time computer graphics,
especially for audio-visual compositions.
Because GEM is a visual programming environment, users do not need any experience
in traditional computer languages.
<p>GEM is a collection of externals which allow the user to create
<a href="http://www.opengl.org">OpenGL</a>
graphics within <a href="http://www.crca.ucsd.edu/~msp/software.html">Pd</a>,
a program for real-time audio processing by <a href="http://www.crca.ucsd.edu/~msp">Miller
Puckette</a> (of <a href="http://www.ircam.fr">Max</a> fame).
<p>There are many different shapes and objects, including polygonal graphics,
lighting, texture mapping, image processing, and camera motion. All of
this is possible in real-time without any previous programming experience.
Because GEM is an add-on library for <a href="http://www.crca.ucsd.edu/~msp/software.html">Pd</a>,
users can combine audio and graphics, controlling one medium from another.
<p>GEM is supported in part by a grant from the <a href="http://www.intel.com">Intel
Research Council</a> for the <a href="http://www.gvm.com">The Global Visual
Music</a> project of <a href="http://felix.usc.edu/vibeke.html">Vibeke
Sorensen</a>, <a href="http://www.crca.ucsd.edu/~msp">Miller Puckette</a>
and <a href="http://www.earunit.org/rand.htm">Rand Steiger</a>.
<p>An important thing to remember is that GEM is NOT an application.&nbsp;
It is a library that Pd loads at run-time.&nbsp; Make sure that you see
the section on <a href="GemWPd.html">using GEM with Pd</a>.&nbsp; This
manual assumes that you have Pd working correctly and can load up patches
already.&nbsp; If you do not have that working yet, look at the Pd manual
and the GEM FAQ.&nbsp; Also, it is assumed that you have a basic understanding
of how to use Pd and the idea behind the data flow model.&nbsp; In other
words, if I ask you to pass a message with 3 floats into an object, you
would know what I mean.
<p>The system requirements vary depending on your system and what you are
trying to do.&nbsp; In general, you should have the most powerful computer
available and the best graphics accelerator on the market.&nbsp; In reality,
people have been doing some amazing work with a Pentium II and an <a href="http://www.nvidia.com">nVidia
Riva TNT</a> or <a href="http://www.3dfx.com">3Dfx Voodoo2</a> card.&nbsp;
If you are on an SGI, then everything from an O2 up seems to be okay.&nbsp;
The biggest requirement is that you have some kind of OpenGL graphics accelerator.&nbsp;
This means that a Matrox Millennium II will not run very quickly.
<p>The other factor is what you are trying to do.&nbsp; Pushing real-time
video around requires a fast bus, which really only exists on SGIs.&nbsp;
Doing thousands of texture mapped polygons is great on a PC...if it is
a constant texture.&nbsp; There are many issues which mean that there is
no one answer to "Is this system good enough?".&nbsp; In general, you will
have to try and see.
<p>GEM is now maintained by <a href="http://www.iem.at/info/personal/jz.htm">IOhannes m zm&ouml;lnig</a>.
So any bug-reports and donations should go to him instead of Mark...
<p><a href="index.html">[return]</a>
<br>&nbsp;
</body>
</html>

107
Gem/doc/manual/Lighting.html Normal file
View file

@ -0,0 +1,107 @@
<!doctype html public "-//w3c//dtd html 4.0 transitional//en">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<meta name="Author" content="Mark Danks">
<meta name="Author" content="IOhannes m zmölnig">
<title>Lighting</title>
</head>
<body>
<center>
<h2>
<u>Lighting</u></h2></center>
Lighting is an important factor is how we perceive the quality of an image.
For example, without lighting and shading, a sphere would just look like
a circle. GEM provides two types of lights, a local light and world
light.
<p>OpenGL uses a vertex lighting model. This means that for every
vertex in the scene, the influence of the light is calculated. The
color for the polygon is then modified by the light value of all of the
vertices. This generally produces a very smooth effect, but you will
occasionally run into rendering artifacts, especially if you use local
lights. For example, imagine you have a local light close a large
square. The corners of the square are far away from the light, so
none of them will be lit very brightly, even though the light itself is
very close to the surface of the square.
<p>It is important to realize that lighting is an expensive operation to
use. The number of polygons that you will be able to render will
be much lower if lighting is turned on. As usual, the complexity
of the scene and the speed of your computer and graphics card will greatly
affect your frame rate.
<p>GEM has only a maximum of 8 lights at one time. If you try to
create more lights than that, you will get an error message.
<p><a href="#Activate">Activate lighting</a>
<br><a href="#world_light">[world_light]</a> - A directional light
<br><a href="#light">[light]</a> - A point light in the world
<br><a href="#Moving">Moving lights</a>
<p><img SRC="tribar.gif" height=13 width=561>
<h3>
<a NAME="Activate"></a>Activate lighting</h3>
Lighting is activated by sending a message to <i>[gemwin]</i>. If you
send "lighting 1", then lighting will be turned on. If you send "lighting
0", then lighting will be turned off. The lighting state is kept
even if you destroy the gemwin. This means that if you close a patch
and open another one, the lighting will still be the same.
<p>Individual lights can be turned on and off by sending a 1 or 0 to the
left inlet of the light object itself.
<p><img SRC="tribar.gif" height=13 width=561>
<h3>
<a NAME="world_light"></a>[world_light]</h3>
A <i>[world_light]</i> is a light which exists infintely far away.
This reduces the computation needed, so your patch can run faster, but
it means that all of the light rays are parallel. The <i>[world_light]</i>
is good for objects like the sun and other lighting affects. This
means that translating a <i>[world_light]</i> has no effect, although rotation
does.
<p>The following patch is 03.lighting/01.world_light.pd.
<center>
<p><img SRC="world_light.jpg" BORDER=1 height=152 width=370></center>
<p>The <i>[world_light]</i> has one extra inlet. The right inlet accepts
three floats to set the color of the light. A <i>[color]</i> object
would do nothing. In this case, the light is being set to purple.
The <i>[world_light]</i> also accepts a debug message. The debug message
turns on and off a graphical representation of the light in the scene.
The <i>[world_light]</i> looks like a cone. The cone shows the direction
that the light is coming from. Remember that the actual position
of the light does not matter, so geos behind the cone will still be lit.
It is the direction of the light that matters. This is why you can
rotate the light.
<p><img SRC="tribar.gif" height=13 width=561>
<h3>
<a NAME="light"></a>[light]</h3>
A <i>[light]</i> object generates a point light in the world. Because
the light is local to the scene, there is more math to generate the effect
of the light on the vertices. However, unlike a <i>[world_light]</i>,
you can translate the <i>[light]</i> object.
<p>Below is the patch 03.lighting/02.light.pd.
<center>
<p><img SRC="light.jpg" BORDER=1 height=215 width=212></center>
<p>The <i>[light]</i> object has a right inlet for the color, just light
the <i>[world_light]</i> object. As this patch shows, the light can
be moved around the scene with both <i>[rotate]</i> and <i>[translate]</i>
objects. If you were to set the translate X value equal to 1.0, then
the sphere would not be lit at all. This is because the light would
be inside of the sphere. When you turn on the debug representation,
it is a sphere with its origin where the light it. The <i>[light]</i>
object does not have any size. It exists as a point source.
<p><img SRC="tribar.gif" height=13 width=561>
<h3>
<a NAME="Moving"></a>Moving lights</h3>
The patch 03.lighting/03.controlLights.pd allows you to move a <i>[light]</i>
and <i>[world_light]</i> object in the same scene to see the difference between
the two objects.
<p>The patch 03.lighting/04.moveSpheres.pd is an example which moves
two spheres around the world. Turn on and off the individual lights
for a demonstration of a local versus infinite light.
<p>The patch 03.lighting/05.materials.pd uses the material objects to
selectively control the color of the object. Notice that the diffuse object
sets the "overall" color, while the specular objects sets the bright reflective
area where the light directly shines.
<p><img SRC="tribar.gif" height=13 width=561>
<p><a href="index.html">[return]</a>
<br>
</body>
</html>

231
Gem/doc/manual/ListObjects.html Normal file
View file

@ -0,0 +1,231 @@
<!doctype html public "-//w3c//dtd html 4.0 transitional//en">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<meta name="Author" content="Mark Danks">
<meta name="GENERATOR" content="Mozilla/4.5 [en] (WinNT; I) [Netscape]">
<title>List of GEM objects</title>
</head>
<body>
<center>
<h2>
<u>List of GEM objects</u></h2></center>
<a href="#Controls">Controls</a>
<br><a href="#Manips">Manipulators</a>
<br><a href="#Geos">Geos</a>
<br><a href="#Particles">Particles</a>
<br><a href="#Nongeos">Nongeos</a>
<br><a href="#Pixes">Pixes</a>
<br><a href="#TV">TV</a>
<br><a href="#MarkEx">MarkEx</a>
<p>
<hr WIDTH="100%"><a NAME="Controls"></a><i><u>Controls</u></i>
<br>gemhead - the start of rendering chain
<br>gemwin - the window manager
<br>gemmouse - outputs the mouse position and buttons in the GEM window
<br>gemkeyboard - outputs the keycode of a key pressed when you are in the GEM window (there might be different keycodes in Windows/Linux)
<br>gemkeyname - outputs a symbolic description of a key pressed when you are in the GEM window (there might be different symbols in Windows/Linux)
<br>gemorb - outputs the position, rotation, and buttons for a Space Orb
<br>gemtablet - outputs the pen position, pressure, and buttons in the
GEM window
<p>
<hr WIDTH="100%">
<br><a NAME="Manips"></a><i><u>Manipulators</u></i>
<br>accumrotate - accumulate a rotation
<br>alpha - enable/disable alpha blending
<br>ambient - set the ambient color with a vector
<br>ambientRGB - set the ambient color with 3 discrete values
<br>camera -
<br>color - set the color with a vector
<br>colorRGB - set the color with 3 discrete values
<br>depth - enable/disable depth testing
<br>diffuse - set the diffuse color with a vector
<br>diffuseRGB - set the diffuse color with 3 discrete values
<br>emission - set the emissive color with a vector
<br>emissionRGB - set the emissive color with 3 discrete values
<br>linear_path - generate a path from an array of points
<br>ortho - change the view to orthogonal, with the viewport the size of
the window
<br>polygon_smooth - turn on anti-aliasing for the objects below
<br>rotate - rotate with an angle and vector
<br>rotateXYZ - rotate with 3 discrete values
<br>scale - scale with a vector
<br>scaleXYZ - scale with 3 discrete values
<br>separator - push the OpenGL state for the rest of the chain and pop
when done
<br>shininess - set the shininess of an object
<br>specular - set the specular color with a vector
<br>specularRGB - set the specular color with 3 discrete values
<br>spline_path - generate a spline from an array of knots
<br>translate - translate with a vector
<br>translateXYZ - translate with 3 discrete values
<p><a NAME="Geos"></a><i><u>Geos</u></i>
<br>circle - render a circle
<br>colorSquare - render a colored square (evtl. with color gradients)
<br>cone - render a cone
<br>cube - render a cube
<br>cuboid - render a box
<br>curve - render a Bezier curve
<br>curve3d - render a surface
<br>cylinder - render a cylinder
<br>disk - render a disk
<br>imageVert - make pixel colors to a height field map
<br>model - render an Alias|Wavefront model
<br>multimodel - render a series of Alias|Wavefront models, render by number
<br>newWave - render a wave (that is evolving over time)
<br>polygon - render a polygon
<br>primTri - a triangle primitive
<br>rectangle - render a rectangle
<br>ripple - a rectangle with distorted (over time) texture-coordinates
<br>rubber - a grid where you can move one of the grid-points
<br>slideSquare - render a number of sliding squares
<br>sphere - render a sphere
<br>square - render a square
<br>teapot - render a teapot
<br>text2d - render 2-D text (a bitmap)
<br>text3d - render 3-D text (polygonal)
<br>textextruded - render an extruded 3D-text
<br>textoutline - render outlined text (polygonal)
<br>triangle - render a triangle
<p><a NAME="Particles"></a><i><u>Particles</u></i>
<br>part_head - The start of a particle group
<br>part_color - Set the range of colors for the new particles
<br>part_damp - set the damping for particles
<br>part_draw - Apply the actions and render the particles.&nbsp; Accepts
a message "draw line" or "draw point" to change the drawing style.
<br>part_follow - Particles will follow each other like a snake
<br>part_gravity - Have the particles accelerate in a direction
<br>part_info - get the information (position, color, size,...) of each particle
<br>part_killold - Remove particles past a certain age
<br>part_killslow - Remove particles below a certain speed
<br>part_orbitpoint - Orbit the particles around a specified point
<br>part_render - render the remaining gem-tree as particles.
<br>part_size - Set the size of new particles
<br>part_source - Generate particles
<br>part_targetcolor - Change color of the particles toward the specified
color
<br>part_targetsize - Change size of the particles toward the specified
size
<br>part_velocity - Set the velocity domain
(distribution like CONE and the appropriate arguments)
<br>part_vertex - emit a single particle
<p><a NAME="Nongeos"></a><i><u>Nongeos</u></i>
<br>light - make a point light
<br>world_light - make a light at infinity
<p><a NAME="Pixes"></a><i><u>Pixes</u></i>
<br>pix_2grey - convert rgb pixels to grey (still an RGBA image)
<br>pix_a_2grey - convert rgb pixels to grey based on alpha channel
<br>pix_add - add two pixes together
<br>pix_aging - super8-like aging effect
<br>pix_alpha - set the alpha value of a pix
<br>pix_background - let through only pixels that differ from a static "background" image
<br>pix_backlight - a backlight photo effect
<br>pix_biquad - 2p2z-filter for subsequent images
<br>pix_bitmask - apply a bitmask to a pix
<br>pix_blob - get center of gravity
<br>pix_buf - buffer a pix
<br>pix_buffer - storage room for pixes (like [table] for floats)
<br>pix_buffer_read/pix_buffer_write - put/get pixes into/from a pix_buffer
<br>pix_chroma_key - color keying (like "blue-box")
<br>pix_coloralpha - set the alpha-channel of a pix as a mean-value of the color-components
<br>pix_colormatrix - recombine the RGBA-channels with matrix-operation
<br>pix_color - set the color of a pix (leaving alpha alone)
<br>pix_colorreduce - reduce the number of colors (statistically)
<br>pix_composite - composite two pixes together
<br>pix_convolve - convolve a pix with a kernal
<br>pix_coordinate - set the texture coordinates
<br>pix_crop - get a sub-image of a pix
<br>pix_curve - apply color-curves onto a pix
<br>pix_data - get pixel data information
<br>pix_delay - frame-wise delay
<br>pix_diff - get absolute difference of two pixes
<br>pix_dot - rasterize a pix with big dots
<br>pix_draw - draw a pix
<br>pix_dump - dump the pixel-data as a long list of floats
<br>pix_duotone - reduce the number of colors by thresholding
<br>pix_film - use a movie file as a pix source for image-processing
<br>pix_flip - flip the pixels of a pix
<br>pix_gain - apply a gain to a pix
<br>pix_grey - convert any pix into greyscale colorspace
<br>pix_halftone - rasterize a pix like it was printed in a newspaper
<br>pix_histo - get the histogram of a pix
<br>pix_hsv2rgb - transform a pix from HSV-colorspace into RGB-colorspace
<br>pix_image - load in an image file
<br>pix_imageInPlace - load a series of image files directly into texture-buffer, display by number
<br>pix_info - get information about the pix (like dimension, colorspace,...)
<br>pix_invert - invert a pix
<br>pix_kaleidoscope - as if you were looking at the pix through a kaleidoscope
<br>pix_levels - level adjustment
<br>pix_lumaoffset - y-offset pixels depending on their luminance
<br>pix_mask - mask a pix based on another pix
<br>pix_metaimage - recompose an image out of smaller versions of itself
<br>pix_mix - mix to pixes together
<br>pix_motionblur - motionblur an image
<br>pix_movie - use a movie file as a pix source and load it immediately into the texture-buffer
<br>pix_movement - set the alpha-channel with respect to the change between two frames
<br>pix_multiply - multiply two pixes
<br>pix_multiimage - load in a series of image files, display by number
<br>pix_normalize - normalize a pix
<br>pix_offset - add an offset to a pix (wrapping instead of clipping)
<br>pix_pix2sig~ - interpret a pix as 4 (RGBA) audio-signals
<br>pix_posterize - posterization photo effect
<br>pix_puzzle - shuffle an image
<br>pix_rds - generate a Random Dot Stereogram out of the image (aka: Magic Eye (tm))
<br>pix_rectangle - generate a rectangle in a pix buffer
<br>pix_refraction - break up an image into coloured "glass-bricks"
<br>pix_resize - resize a pix to next power of 2
<br>pix_rgb2hsv - transform a pix from RGB-colorspace into HSV-colorspace
<br>pix_rgba - transform a pix of any format into RGBA
<br>pix_roll - (sc)roll through an image (wrapping)
<br>pix_rtx - swap time-axis and x-axis
<br>pix_scanline - take every nth line of the original image
<br>pix_set - set the pixel-data with a long list of floats
<br>pix_sig2pix~ - interpret 4 audio-signals as (RGBA) image-data
<br>pix_snap - capture the render window into a pix
<br>pix_snap2tex - capture the render window directly as a texture
<br>pix_subtract - subtract two pixes
<br>pix_tIIR - time-base Infinite-Impulse-Response filter (for motion-bluring,...) with settable number of poles/zeros
<br>pix_takealpha - take the alpha channel of one pix and put it into another pix
<br>pix_texture - use a pix as a texture map
<br>pix_threshold - apply a threshold to a pix
<br>pix_video - use a video camera as a pix source
<br>pix_write - capture the render window to disk
<br>pix_zoom - zoom into a pix (using OpenGL)
<p><a NAME="openGL"></a><i><u>openGL</u></i>
there are more than 250 objects that
form a complete wrapper around the openGL set of functions
(as defined in the openGL-1.2 standard).<br>
each openGL-function is prefixed with "GEM", eg:
<i>[GEMglVertex3f]</i> is wrapped around <i>glVertex3f</i>.
<p><a NAME="MarkEx"></a><i><u>MarkEx</u></i>
<br>alternate - alternate between two outlets
<br>average - average a sequence of numbers
<br>change - only output on change
<br>counter - count bangs
<br>invert - non-zero numbers to zero, zero to 1
<br>multiselect/multisel - a select object which accepts a list in the
right inlet
<br>oneshot - send a bang, then block until reset
<br>randomF / randF - floating point random numbers
<br>strcat - string concatentation
<br>tripleLine - do a line with three numbers
<br>tripleRand - random with three numbers
<br>vector+ / v+ - add a scalar to a vector
<br>vector- / v- - subtract a scalar from a vector
<br>vector* / v* - multiply a vector by a scalar
<br>vector/ / v/ - divide a vector by a scalar
<br>vectorpack / vpack - attach a scalar to the end of a vector
<br>rgb2hsv - convert a list of three floats from RGB to an HSV value
<br>hsv2rgb - convert a list of three floats from HSV to an RGB value
<br>abs~ - absolute value of a signal
<br>reson~ - resonant filter
<p><a href="index.html">[return]</a>
<br>&nbsp;
<br>&nbsp;
</body>
</html>

19
Gem/doc/manual/Particles.html Normal file
View file

@ -0,0 +1,19 @@
<!doctype html public "-//w3c//dtd html 4.0 transitional//en">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<meta name="Author" content="Mark Danks">
<meta name="GENERATOR" content="Mozilla/4.5 [en] (WinNT; I) [Netscape]">
<title>Particles</title>
</head>
<body>
<center>
<h2>
<u>Particles</u></h2></center>
<p><br>Nothing here yet
<p><a href="index.html">[return]</a>
<br>&nbsp;
</body>
</html>

105
Gem/doc/manual/Pixes.html Normal file
View file

@ -0,0 +1,105 @@
<!doctype html public "-//w3c//dtd html 4.0 transitional//en">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<meta name="Author" content="Mark Danks">
<meta name="Author" content="IOhannes m zmölnig">
<title>Pixes (image processing)</title>
</head>
<body>
<center>
<h2>
<u>Image processing</u></h2></center>
The pix objects are used to do image processing to pixel data. If
you load in an image with <i>[pix_image]</i>, then you can change what the
image looks like before rendering it out
<p>In general, processing images is <i>extremely</i> expensive, so you
probably cannot have that many active pix objects. GEM only reprocesses
images when the source image changes or one of the parameters for a pix
object changes. This means that GEM will only process an image when
something is different, instead of every frame. If you want to do
a lot of processing at start up, but then not change anything once the
patch is running, GEM will only do the computation once.<br>
Modern CPUs use SIMD (Single Instruction - Multiple Data) (like MMX, SSE2, altivec)
to make pixel-processing more effective (by processing data parallely).
Until now, only the macOS version of Gem has support for SIMD for some pix-objects.
MMX/SSE2 boosts will hopefully come in future Gem-releases.
<p>The pix objects are divided into two general groups, those which take
one input, and those which require two input images. For example,
<i>[pix_invert]</i>
will "invert" all of the pixels (if a pixel is white, it will change to
black), while <i>[pix_add]</i> will add two images together.
<p>Only some of the pix objects are described here. Look in the reference
patches for explanations for the other pix objects.
<p><a href="#invert">[pix_invert]</a> - invert the pixel data
<br><a href="#add">[pix_add]</a> - add two pixes together
<br><a href="#mask">[pix_mask]</a> - create an alpha mask
<br><a href="#convolve">[pix_convolve]</a> - convolve a pix with a kernel
<p><img SRC="tribar.gif" height=13 width=561>
<h3>
<a NAME="invert"></a>[pix_invert]</h3>
<i>[pix_invert]</i> inverts the pixels in an image. To use <i>[pix_invert]</i>,
simply make sure that you have already loaded an image into the chain.
In the following patch, the fractal image will be inverted.
<center>
<p><img SRC="invert.jpg" BORDER=1 height=120 width=179></center>
<p>Here is the difference between the fractal image and the inverted version.
<center>
<p><img SRC="normalFrac.jpg" height=256 width=256><img SRC="invertFrac.jpg" height=256 width=256></center>
<p><img SRC="tribar.gif" height=13 width=561>
<h3>
<a NAME="add"></a>pix_add</h3>
<i>[pix_add]</i> does what you would expect. It adds two images together.
<center>
<p><img SRC="add.jpg" BORDER=1 height=152 width=305></center>
<p>This patch adds the fractal image with a car image. The processed
image will often contain a lot of white pixels, because the data is just
added together. This occurs in the resulting image, shown below.
<center>
<p><img SRC="addResult.jpg" height=257 width=255></center>
<p><br>
<p><img SRC="tribar.gif" height=13 width=561>
<h3>
<a NAME="mask"></a>pix_mask</h3>
<i>[pix_mask]</i> is used to create an alpha mask from another image.
In the following example (gem_pix/gemMaskDancer.pd), the fractal image's
alpha channel is replaced by the dancer image. If the <i>[alpha]</i>
object was removed, then you would just see the solid fractal image (because
the alpha channel wouldn't be used).
<p>In other words, images are composed of a red, a green, a blue, and an
alpha channel. The alpha channel is the transparency of the pixel.
<i>[pix_mask]</i> only modifies the alpha channel and does not touch the
red, green, or blue data.
<center>
<p><img SRC="mask.jpg" BORDER=1 height=262 width=191></center>
<p>The result is this image.
<center>
<p><img SRC="maskResult.jpg" height=218 width=187></center>
<p><img SRC="tribar.gif" height=13 width=561>
<h3>
<a NAME="convolve"></a>pix_convolve</h3>
<i>[pix_convolve]</i> convolves pix data with a convolution kernel.
Basically, you can get really nice effects if you choose the correct kernel...and
garbage if you choose the wrong one.
<p>Edge detection is done with a convolution kernel, as is smoothing.
The biggest problem is that convolving an image is about the most expensive
operation that you can do in GEM.
<p>Look at gem_pix/gemPixConvolve.pd to get an idea of some of the kernels
that you can send to <i>[pix_convolve]</i> and the effects that you can get.
<p>If you want to learn the math behind convolution, then find any standard
image processing (or audio processing book, this is just 2D convolution).
<br>
<p><img SRC="tribar.gif" height=13 width=561>
<p><a href="index.html">[return]</a>
<br>
</body>
</html>

126
Gem/doc/manual/Texture.html Normal file
View file

@ -0,0 +1,126 @@
<!doctype html public "-//w3c//dtd html 4.0 transitional//en">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<meta name="Author" content="Mark Danks">
<meta name="Author" content="IOhannes m zmölnig">
<title>Texture mapping</title>
</head>
<body>
<center>
<h2>
<u>Texture Mapping</u></h2></center>
<a href="Gloss.html#Texture">Texture mapping</a> is the act of applying
pixel data to a geometric object. In GEM, this is achieved with the
<i>[pix_texture]</i>
object. It is important to understand that the
<i>[pix_texture]</i>
object merely sets the pix as the current texture. It does not do
any rendering! You need to use a geo object which does texture mapping.
All of the basic geo objects can texture map, such as <i>[square]</i> or
<i>[sphere]</i>.
<p><img SRC="tribar.gif" height=13 width=561>
<p>A simple example of texture mapping is the following patch:
<center>
<p><img SRC="texture.jpg" BORDER=1 height=182 width=160></center>
<p>This patch can be found at 07.texture/01.texture.pd. Change
the number box connected to the rotate object to see what a texture map
on a cube looks like.
<p>The <i>[pix_image]</i> object loads in the fractal image file. The
<i>[pix_texture]</i>
object says that the pix data should be used as a texture map. Notice
that this is different than the previous manual section when we used the
<i>[pix_draw]</i> object. The final object in the chain is the <i>[cube]</i>
object. Because we have enabled texture mapping with the <i>[pix_texture]</i>
object, the cube takes the pix data and applies it to the geometry.
<p><img SRC="tribar.gif" height=13 width=561>
<p>Texture mapping can be used with any GEM object. In the previous
manual section, you saw how to load in pix data with a variety of objects,
including <i>[pix_multiimage]</i> and <i>[pix_video]</i>. All of these
objects can be used with the <i>[pix_texture]</i> object.
<p>Because the pix data is applied to geometry, you can move, rotate, and
scale the image. This is extremely useful on the <i>[square]</i> object.
Instead of doing a one-to-one pixel mapping as occurs with the <i>[pix_draw]</i>
object, you can resize and reshape the image.
<p>OpenGL originally required that images must have dimensions that are power-of-2, such as 64, 128, or 256. This restriction has been released with recent gfx-cards
(like some radeon/nvidia products).
However, if the width or height of an image is not a power of two,
then the <i>[pix_texture]</i> object will take care of this,
and still render it (depending on you hardware with some tricks).
You can thus texture images of any size, but since this is based on tricking
the texture-coordinates, <i>[pix_coordinate]</i> might not give the wanted result any more.
<p><img SRC="tribar.gif" height=13 width=561>
<p>The example patch 07.texture/02.moveImages.pd is a much more complex
patch which uses alpha blending to create a transparent object, in this
case, the dancer. Make sure to turn on the rotation with the <i>[metro]</i>
object.
<p><img SRC="tribar.gif" height=13 width=561><a href="index.html"></a>
<p>People have been asking how textures are handled in GEM. Here
is a long explanation from an email which I wrote.
<p><tt> Here is how textures are dealt with under OpenGL and hardware
accelerators. This can obviously change in the future, but right
now, I am fairly certain that the info is correct (I make games in my day
job, so I have vested interest in this :-)</tt><tt></tt>
<p><tt> The amount of memory (VRAM) on the card (12mb for Voodoo2,
16mb for TNT, 64mb for GeForce2, etc) is used for both textures (TRAM)
and frame buffer space. If you have a large rendering window, like
1600x1200, it will take up 1600x1200x4x3 in 32-bit mode with double buffering
and a Z buffer (or 23mb). Most people run at TV resolution, like
NTSC, so it takes 640x480x4x3 = 3.7mb All of the space left
is for textures onboard the card (FYI, if you have heard that people are
having problems with the PlayStation2, notice that it only has 4mb of VRAM...not
much onboard texture space, huh? :-) Thankfully it has an <i>extremely</i>
fast DMA bus)</tt><tt></tt>
<p><tt> Sooo, when GEM "creates" a texture, it immediately tries
to send the texture to the card, which uses some of the left over space
in the VRAM. If you had a 640x480 window on a Voodoo2, you have ~8mb
of texture space left over. On a GeForce2, ~60mb. The problem
is what happens if you want more textures than can fit into TRAM.
OpenGL requires that the video drivers deal with the problem, so GEM doesn't
care too much (more about this later).</tt><tt></tt>
<p><tt> In most cases, the drivers cache the textures in main memory
and if a texture is requested for rendering and it isn't resident on the
card, it will download it. If you have AGP, then this is pretty quick,
although none of 3dfx cards really take advantage of this (ie, those cards
are about the same speed as the PCI bus). So depending on the number
of textures, and how complex the scene is, you might be able to display
more textures than you have TRAM.</tt><tt></tt>
<p><tt> One slowdown that can happen with GEM is that it makes a
copy of the image before sending it down the chain of objects. If
you are constantly changing images with a pix_multiimage, this can be a
performance hit, but you can modify the actual pixel data with the pix
objects. The pixels aren't sent to the graphics card until the pix_texture
object is reached.</tt><tt></tt>
<p><tt> GEM tries to help with this with a few objects. pix_imageInPlace
acts much the same as pix_multiimage, but it downloads _every_ image in
the sequence to the card when a download message is recieved. It
also immediately turns on texturing, instead of making a copy (ie, you
don't need a pix_texture object). Much faster, but not as flexible.
pix_movie does much the same thing. It sends the pixel data without
copying it if there is a new frame to display.</tt><tt></tt>
<p><tt> The entire pix system uses a caching system so that the copying
and processing only occurs if something actually changes. For example,
if you had a pix_threshold object, it would only process when rendering
started...and every time that the values actually changed. You can
use pix_buf to isolate parts which don't change from those that do, but
it involves another copy.</tt><tt></tt>
<p><tt> On the Voodoo2, the hardware itself limits textures to 256x256...this
will never change. The newest Voodoo5 boards have a higher texture
size.</tt><tt></tt>
<p><tt> If you load the _exact_ same image (this means the exact
same file/path name), then the pix_image has a cache system which means
that it is only loaded into the</tt>
<br><tt>computers memory once. However, each pix_image still sends
its own copy down to the gfx card.</tt><tt></tt>
<p><tt> You could use a single [pix_image]/[pix_texture] with [separator]
to do this...I have done it a lot in the past.</tt><tt></tt>
<p><tt> The reason that [pix_image] doesn't share the actual texture
data is that you can modify the pixel data with other pix objects...[pix_image]
doesn't actually send the texture data to the gfx card, [pix_texture] does.</tt>
<p><img SRC="tribar.gif" height=13 width=561><a href="index.html"></a>
<p><a href="index.html">[return]</a>
<br>
</body>
</html>

149
Gem/doc/manual/Utility.html Normal file
View file

@ -0,0 +1,149 @@
<!doctype html public "-//w3c//dtd html 4.0 transitional//en">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<meta name="Author" content="Mark Danks">
<meta name="GENERATOR" content="Mozilla/4.5 [en] (WinNT; I) [Netscape]">
<title>Utility objects</title>
</head>
<body>
<center>
<h2>
<u>Utility objects</u></h2></center>
There are a number of objects which were written to make it easier to use
both GEM and pd.&nbsp; For instance, you often pass around 3 floats at
a time in GEM, either for position or colors.&nbsp; To help with this,
there are a collection of vector objects.&nbsp; Use the list below to find
out about the objects.
<p>These objects used to be in a separate library called MarkEx, but they
have now been folded into GEM.
<p><a href="#counter">counter</a> - count the number of bangs
<br><a href="#average">average</a> - average a series of numbers together
<br><a href="#change">change</a> - only output when there is a change in
the number
<br><a href="#invert">invert</a> - invert a number
<br><a href="#randF">randomF/randF</a> - floating point random number
<br><a href="#tripleLine">tripleLine</a> - line object for 3 values
<br><a href="#tripleRand">tripleRand</a> - three random numbers
<br><a href="#vector">vector objects</a> - process a series of numbers
<br><a href="#hsv2rgb">hsv2rgb and rgb2hsv</a> - convert between RGB and
HSV color space
<p><img SRC="tribar.gif" height=13 width=561>
<h3>
<a NAME="counter"></a>counter</h3>
<center><img SRC="counter.jpg" BORDER=1 height=85 width=87></center>
<p>The inlets are:
<br>bang (increment or decrement the counter)
<br>set direction (1 = count up, 2 = count down, 3 = count up and down)
<br>set low value
<br>set hight value
<br>The outlet is the current count.
<p>So in this case, the top <i>counter</i> will count up from 1 to 10.&nbsp;
The bottom <i>counter</i> will count up from 2 to 5.
<p>The <i>counter</i> also accepts the messages reset and clear.&nbsp;
Reset immediately sets the counter to its low value and outputs the value.&nbsp;
The clear message means that the next bang will set the <i>counter</i>
to its low value.
<p><img SRC="tribar.gif" height=13 width=561>
<h3>
<a NAME="average"></a>average</h3>
The <i>average</i> object just averages a series of numbers as they come
in.&nbsp; The left inlet accepts a single float.&nbsp; It then outputs
the current average.&nbsp; The default number of floats to average together
is 10, but that can be changed by sending a new value to the right inlet.
<p>The <i>average</i> object also accepts the messages clear and reset.&nbsp;
Clear will immediately set all of the values that the object has been storing
for averaging to 0.&nbsp; With the reset message, you must pass in a number
to set all of the values.
<p><img SRC="tribar.gif" height=13 width=561>
<h3>
<a NAME="change"></a>change</h3>
<i>Change</i> only accepts a number into its left inlet.&nbsp; If the number
is the same as the last number sent to the <i>change</i> object, then it
does nothing.&nbsp; If the number is different, then the <i>change</i>
object will output the new number and store it for the next comparision.
<p>This object is very useful for the == object and others like it, since
they send a 0 or a 1 every time they do a comparision, and you usually
only care when the state actually changes.
<p><img SRC="tribar.gif" height=13 width=561>
<h3>
<a NAME="invert"></a>invert</h3>
The <i>invert</i> object is very simple.&nbsp; If the number sent to its
left inlet is equal to 0., then <i>invert</i> outputs a 1.&nbsp; If the
number is not equal to 0., the <i>invert</i> outputs a 0.
<p><img SRC="tribar.gif" height=13 width=561>
<h3>
<a NAME="randF"></a>randomF/randF</h3>
One problem with the <i>random</i> object in pd is that it only sends out
integers.&nbsp; This a real problem in GEM, where you often want a value
between 0 and 1.&nbsp; <i>randomF</i> is exactly like the <i>random</i>
object.
<p>When the left inlet gets a bang, <i>randomF</i> outputs a random number
between 0 and the given range.&nbsp; The range can be set with a number
to the right inlet.
<p><i>randF</i> is just an alternate name for <i>randomF</i>.
<p><img SRC="tribar.gif" height=13 width=561>
<h3>
<a NAME="tripleLine"></a>tripleLine</h3>
<center><img SRC="tripleLine.jpg" BORDER=1 height=92 width=111></center>
<p>The <i>line</i> object is really great for dealing with a single number.&nbsp;
To do a line with 3 values, like an RGB color value, means that you have
to unpack, do a <i>line</i>, then repack the number.&nbsp; Not only is
it a pain, but it expensive computationally.
<p><i>tripleLine</i> behaves just like the <i>line</i> object, only it
accepts three numbers to interpolate between.&nbsp; In the example, <i>tripleLine</i>
will interpolate from the current values to 1., .2, .4 over 1000 milliseconds.&nbsp;
The default output resolution is 50 milliseconds, which is the same default
rendering time.&nbsp; Going faster with GEM objects will not produce any
benefit, unless you increase the frames per second.
<p><img SRC="tribar.gif" height=13 width=561>
<h3>
<a NAME="tripleRand"></a>tripleRand</h3>
<center><img SRC="tripleRand.jpg" BORDER=1 height=89 width=149></center>
<p>Just as using <i>tripleLine</i> makes it easier to interpolate between
3 values at once, <i>tripleRand</i> makes it easy to generate three random
values.&nbsp; In the above example, when the bang is sent, <i>tripleRand</i>
will create three values and output them, with the first between 0 - 1,
the second between 0 - .5, and the third from 0 - .8.
<p><img SRC="tribar.gif" height=13 width=561>
<h3>
<a NAME="vector"></a>Vector objects</h3>
The vector math objects are
<br><i>vector+ </i>or<i> v+</i>
<br><i>vector- </i>or<i> v-</i>
<br><i>vector* </i>or<i> v*</i>
<br><i>vector/ </i>or<i> v/</i>
<br>All of the above objects perform math on a list of numbers.&nbsp; The
left inlet accepts a list of numbers of any length.&nbsp; The right inlet
accepts a single value, which is the operand for the computation.&nbsp;
In other words, they work just like the normal *, +, -, and / objects,
except they can handle more than one number in the left inlet.
<p>There are two other objects which are also useful.
<p>The first is <i>vectorabs </i>or<i> vabs</i>. It computes the absolute
value on a list of numbers.
<p>The second object is <i>vectorpack </i>or<i> vpack</i>. <i>vpack</i>
accepts a list of numbers in the left inlet and a single number into the
right inlet.&nbsp; The output is a single list of numbers that is the vector
with the single number appended to the end.&nbsp; This is very useful when
you want to change the time for a <i>tripleLine</i> without unpacking and
repacking all of the data.<i></i>
<p><img SRC="tribar.gif" height=13 width=561>
<h3>
<a NAME="hsv2rgb"></a>hsv2rgb and rgb2hsv</h3>
These two objects convert three numbers between HSV and RGB color space.&nbsp;
HSV stands for hue, saturation, and value.&nbsp; The simple way to think
of HSV space is that hue is the "color", such as red, blue, etc, the saturation
is how intense the color is, and the value is how bright the color is.
<p>You can get some really nice effects by varying the hue of a color,
because the brightness will not change while you do it.
<p><img SRC="tribar.gif" height=13 width=561>
<p><a href="index.html">[return]</a>
</body>
</html>

41
Gem/doc/manual/WriteCode.html Normal file
View file

@ -0,0 +1,41 @@
<!doctype html public "-//w3c//dtd html 4.0 transitional//en">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<meta name="Author" content="Mark Danks">
<meta name="Author" content="IOhannes m zmölnig">
<title>Writing new objects</title>
</head>
<body>
<center>
<h2>
<u>Creating new GEM objects</u></h2></center>
Look at the source code :-)&nbsp; GEM is written in C++, which means that
you have to jump through some hopes to interact properly with Pd, which
is written in C.&nbsp; If you look in Base/CPPExtern.h, you will see a
collection of macros which you can use to help you create new objects.&nbsp;
Use one of the GEM objects which is closest to what you want to do as a
template.
<p>One problem on SGI...you will need to
<p>setenv LD_LIBRARY_PATH "/where/ever/pd/gem"
<p>so that rld (the run-time linker) can find the GEM dso.&nbsp; Because
you are linking with GEM, Pd isn't involved with the run time linking process;
it is all done when Pd calls dlopen.
<p>On NT, there is much the same problem...
<p>set your PATH environment variable to \where\ever\pd\gem
<p>or
<p>make sure that your new .dll is located in the same directory where
GEM is.
<p>On NT, all of the classes and functions are exported through declexport/declimport.&nbsp;
You shouldn't have to do anything to call the functions.&nbsp; I have not
had any problems making other dll's which are loaded into Pd at runtime.&nbsp;
You need to make certain that you are exporting the correct functions.&nbsp;
If your dll cannot find the gem.dll, then it will silently fail.
<p>And of course, e-mail IOhannes m zmölnig (<a href="mailto:zmoelnig@iem.at">zmoelnig@iem.at</a>) if you have any problems,
questions, or solutions
<p><img SRC="tribar.gif" height=13 width=561>
<p><a href="index.html">[return]</a>
<br>&nbsp;
</body>
</html>

BIN
Gem/doc/manual/add.jpg Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 12 KiB

BIN
Gem/doc/manual/addResult.jpg Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 60 KiB

BIN
Gem/doc/manual/basicCube.jpg Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 8.3 KiB

BIN
Gem/doc/manual/counter.jpg Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 7.8 KiB

BIN
Gem/doc/manual/gemwin.jpg Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 8.8 KiB

67
Gem/doc/manual/index.html Normal file
View file

@ -0,0 +1,67 @@
<!doctype html public "-//w3c//dtd html 4.0 transitional//en">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<meta name="Author" content="Mark Danks; IOhannes m zm&ouml;nig">
<title>Gem Manual</title>
</head>
<body>
<center>
<h2>
<u>GEM Manual</u></h2></center>
<center><img SRC="redSquare.jpg" ALT="a simple patch" BORDER=2 height=138 width=91></center>
<p>This is the first attempt at a manual for GEM, so bear with me.
Any comments are appreciated. Send them to <a href="mailto:mark@danks.org">Mark Danks</a>
<hr>
In fact, this ought to be the second attempt at such a manual. There will not be much now.
But send any comments to <a href="mailto:zmoelnig@iem.kug.ac.at">IOhannes m zm&ouml;lnig</a> instead.
<p><img SRC="tribar.gif" height=13 width=561>
<p><a href="Intro.html">Introduction</a>
<br>&nbsp;&nbsp;&nbsp; An introduction to GEM and what you can do with
it.&nbsp; The general system requirements are also described here.
<p><a href="GemWPd.html">Using GEM with Pd</a>
<br>&nbsp;&nbsp;&nbsp; How to use GEM with Pd.&nbsp; This includes how
to start Pd so that the GEM library is loaded and working properly.
<p><a href="BasicObj.html">Basic objects</a>
<br>&nbsp;&nbsp;&nbsp; The basic objects that GEM has.&nbsp; This section
shows you how to create a simple patch.
<p><a href="Images.html">Images</a>
<br>&nbsp;&nbsp;&nbsp; Using images is an important part of GEM. Here you
will load in images and learn the basics of dealing with images.
<p><a href="Texture.html">Texture mapping</a>
<br>&nbsp;&nbsp;&nbsp; Loading in images is only one part.&nbsp; Applying
those images to 3-D shapes is called texture mapping.
<p><a href="Pixes.html">Pixes (image processing)</a>
<br>&nbsp;&nbsp;&nbsp; Once you have texture mapped the images, you will
probably want to process and change them in response to user interaction.&nbsp;
The <i>pix</i> objects provide this functionality.
<p><a href="Lighting.html">Lighting</a>
<br>&nbsp;&nbsp;&nbsp; Shading and lighting are easy with the lighting
objects.
<p>Particles
<br>&nbsp;&nbsp;&nbsp; Particle systems can create effects such as smoke,
fire, and water.
<p><a href="Utility.html">Utility objects</a>
<br>&nbsp;&nbsp;&nbsp; To help you deal with the data which GEM uses, there
are a number of utility objects.
<p>Input devices
<br>&nbsp;&nbsp;&nbsp; GEM provides interaction with the mouse and other
input devices.
<p>Advanced
<br>&nbsp;&nbsp;&nbsp; Now that you know all about the other objects, here
are a few of the more advanced ones.
<p><a href="WriteCode.html">Writing new objects</a>
<br>&nbsp;&nbsp;&nbsp; How to write new objects for GEM.
<p><a href="GemFaq.html">FAQ</a>
<br>&nbsp;&nbsp;&nbsp; Frequently asked questions about GEM.
<p><a href="ListObjects.html">List of Objects</a>
<br>&nbsp;&nbsp;&nbsp; All of the objects in GEM with a very brief description..
<p><a href="Gloss.html">Glossary/Index</a>
<br>&nbsp;&nbsp;&nbsp; A collection of definitions and links to explanations.
<p><img SRC="tribar.gif" height=13 width=561>
<br>&nbsp;
</body>
</html>

BIN
Gem/doc/manual/invert.jpg Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 10 KiB

BIN
Gem/doc/manual/invertFrac.jpg Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 68 KiB

BIN
Gem/doc/manual/light.jpg Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 17 KiB

BIN
Gem/doc/manual/mask.jpg Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 18 KiB

BIN
Gem/doc/manual/maskResult.jpg Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 13 KiB

BIN
Gem/doc/manual/normalFrac.jpg Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 67 KiB

BIN
Gem/doc/manual/pixImage.jpg Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 12 KiB

BIN
Gem/doc/manual/redSquare.jpg Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 3.5 KiB

BIN
Gem/doc/manual/sphere15.jpg Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 4.2 KiB

BIN
Gem/doc/manual/sphere5.jpg Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 4.1 KiB

BIN
Gem/doc/manual/texture.jpg Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 11 KiB

BIN
Gem/doc/manual/transXYZ.jpg Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 8.6 KiB

BIN
Gem/doc/manual/tribar.gif Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 882 B

BIN
Gem/doc/manual/tripleLine.jpg Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 9.6 KiB

BIN
Gem/doc/manual/tripleRand.jpg Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 8.2 KiB

BIN
Gem/doc/manual/world_light.jpg Normal file
View file

Binary file not shown.
Side by side

After

Width:  |  Height:  |  Size: 13 KiB