Subject: GOOD0.60 - 3D OO Graphics System for LINUX
From: ekki (Ekkehard Beier) <[email-masked]>
Date: 18 Feb 1994 17:34:04 +0200
Newsgroups: comp.os.linux.announce

TU Ilmenau, Germany
Faculty of Computer Science
Department of Computer Graphics

We want to announce the 0.60 Release of the GOOD project. GOOD is
an object oriented framework for graphical applications running
under X Windows with special support to SGI GL, PHIGS, etc.

GOOD is free available with all sources. Everybody is invited to
use, modify and extend GOOD. Its our aim to provide a public
domain framework that should be helpful to other people.

GOOD consists of three essential parts

	* The Tcl/C++ Raytracer/Shader/Radiosity kernel YART
        YART is an extensible, object-oriented C++ kernel
        with consistent interpretative language binding (Tcl) 
	and supports raytracing, radiosity and shading. 
	The shader may be used as integrated previewer especially
        for animations or simulations before generating a lot
        of key frames on disk using the raytracer. 
	contact: [email-masked] 
	[YART will be described more detailed behind the GOOD text.]

	* The Interactive Object Manipulator IOM (for Yart)
	This is a Tk based Application Builder for YART with
	support to Spaceball, Mouse allowing real interactions	
	and dialog boxes, tree widget, class browser for non-direct
	interactions	 

	* The Module Application Framework MAF
	This is a C++ classlib for dataflow-driven applications including
	ipc, data transfer. Currently MAF is not available, 'cos
	we are reimplementing the prototype.

Additional there is a YART extension available, that implements a lot
of stuff for scientific visualization, especially field simulations,
streamlines, color mapping, etc.

* Changes from 0.50 to 0.60:
- support for AT&T from 2.1 to 3.2 (no more fuckin' warnings) 
- TARGA image class
- Radiosity interface now for GL port, too
- an OFF compatible quadmesh class
- reimplementation of attributes, input devices, primitive updating, etc.
  for more consistency
- several 3D textures adapted from GRIS Uni T"ubingen, that can be nested
  hierarchically, used with friendly permission

* DIRECTORY STRUCTURE and INSTALL

To avoid a set of defines, Shell-Variables etc. ya should create following directory structure:

	XXX - the root dir, give to it any name you want
		set an environment variable GOOD_ROOT_DIR to that dir

	XXX/YART - install YART in that dir (rename YART*.** to YART) or
		create a link

	XXX/IOM - the dir of the interactive object manipulator - the application
		builder for Yart; install the package inside or make a link

	XXX/MAF - install MAF in that dir or make a link

	XXX/packages - additional packages basing on the YART kernel

	XXX/packages/scient - install here the scientific package if ya
		need that

	XXX/classes - this dir contains a library of Tcl classes and is contained
		in the Tcl-include-path; subdirectorys are supported

	XXX/fonts - install all additional fonts here

	XXX/html - WWW documents  

	XXX/man  - man dir - include that dir in your man path:
		setenv MANPATH ...:${GOOD_ROOT_DIR}/man

	XXX/man/man3 - YART API

	XXX/man/man1 - binary man pages

	create a file XXX/man/mandesc:	
		1(1) User Commands (GOOD)
		3(3) Subroutines (YART)

	XXX/require - the parent directory of all external stuff that will
		be  needed for GOOD

	XXX/require/tcltk - link to the install directory of tcl and tk
	       inside this dir two subdirs should be placed:
	   
               include - tcl.h, tk.h
	       lib - libtcl.a, libtk.a, tkAppInit.o 		

	If you have installed Tcl/Tk correctly, this directory
	structure is automatically generated. However, you have to
	copy/move tkAppInit.o explicitely in the lib-subdir.

	XXX/require/tkTree - install here the Tk tree widget or make a link
             (make INSTALL)

* FILES *
Following files are contained in pub/PROJECTS/GOOD0.60
on metallica.prakinf.tu-ilmenau.de
( ftp anonymous, password: "Harley Fuckin' Davidson" )	

!NOTE! Not all of these files already exist inside the directory.

	YART?.??.tar.Z - YART Graphics Kernel

	IOM?.??.tar.Z - YART front end

	MAF?.??.tar.Z - the framework

	SCIENT?.??.tar.Z - scientific package

	tcl*.tar.Z - the Tcl release we used

	tk*.tar.Z - the Tk release we used

	tkTree*.tar.Z - the Tk Tree Widget

	fonts.tar.Z - font files for YART text primitive

	classes.tar.Z - Tcl composite classes

	        * YART - Yet Another Ray Tracer *

YART is an obj oriented system for interactive 3D graphics.
It's more than a raytracer; in the mean time Shading and 
Radiosity had been integrated.

YART is platform independend. Currently ports to SGI GL, PHIGS
PLUS and X11 do exist. An OpenGL port is in work. An MS Windows
port was done, too.
 
YART has two consistent language bindings: C++ and Tcl. Tcl allows
an interpretative access to the graphical classes and objects.

YART is strongly correlated to some essential metaphores and 
architecture of the PREMO concept, a coming ISO standard. So
you may consider YART as a conceptional prototype of PREMO.

YART is built around some essential abstract terms (representing
abstract classes, too) 

       	* CAMERA takes PRIMITIVEs from a SCENE and puts 'em to a PIXMAP	
		- the kind of projection, rendering, etc. 
		and special features like supersampling, stereoview are
		hidden into the specific camera class
		- any new camera can be implemented using transparent subclassing
		- YART currently has two camera classes:
			OneRayCamera - for raytracing test purposes
			LookatCamera - a cam with SGI GL like lookat
			features, allowing shading, raytracing, radiosity
			in one and the same pixmap
		- more than one camera can look at one scene

	* PRIMITIVE is a polymorph object derived from an
		 abstract class RT_Primitive, defining different
		 rendering protocols
		- Primitives can have any modelling aspects.
		- HiLevel primitives can be inherit using multiple
		inheritance:

                      Quadmesh        Quadirc  
			|               |      
	    		-----------------	
                               |
                             Sphere	
		(using raytr. props of quadric)
                (and shad. props of quadmesh)
		
		- composite objects will managed automatically
		- display lists will be used, if there are any available 	
		- a primitive can have a parent primitive	
		- children inherit geometrical and other attributes from their
		  parent object (hierarchical modeling)	
	
	* ATTRIBUTEs are properties of PRIMITIVES
		- attributes can be procedural implemented,
		 polymorph and will be inherited with priorities.
		- attributes can be additionally class related:
		 "Button.surface"
		- attributes are handled efficiently using
		  references for non-directly assigned attributes
		- every object can be assigned every attribute
		- every object can be asked for every attribute
		- examples for attr are: 

			Surface  	Fillstyle
			Solution	Mapping

		* SCENEs are unordered lists of PRIMITIVES
		- Scenes are the input for cameras.
		- Operations on scene objects can implemented using
		  subclassing.
		- An example for a special scene is our Radiosity scene

		* LIGHT sources are like PRIMITIVES objects those can
		 be inserted into a scene 
		- different lighting models can be implemnted in
		 light classes

		* a MAPPING is also an object like the others
		-  MAPPINGS can change surface parameters (emission,
                  diffusion, normals, ...) of primitives
		- the mapping can be done in a 2D area or in a 3D
		  solid wolrd
		- the parameters of mappings can be changed
		  interactively
		- mappings can use the local or global coordinate system or 
		the system of the father of the primitive ...

		* PIXMAPs are abstract units for displaying raste-
		rized images
		- pixmaps are very different: Online-Display, MPEG-based
		  storage pixmaps
		- pixmaps can be coupled with IMAGES

		* IMAGEs represent abstractly image files, the
		access to an image is independendly from the specific
		formate such as TIFF, GIF, RGB, ...

		* INPUT DEVICES are objects, too. They're event-
		controlled, callback-oriented, extensible,
		platform independend and can be coupled with objects

		- Input devices can be driven stand-alone or coupled
                to a camera (in this case, they can have a scene
		independent, camera specific visual feedback

*CURRENT STATE*
	* vector and matrix classes, complex numbers, dl list
	* Tcl support for math lib 
	* PRIMITIVES: 
	  Polymarker(s), Polyline, Polyvertex, Spline, Quadmesh,
	  Axes, Sphere, Torus, Cylinder, Cone, Polyhedron, Text,
	  Plane, Ellipsoid, Quadric

          the universal primitives are full editable(points,
	  surfaces, normal-  per vertex and/or global)

!NOTE! not all primitives are complete. Especially the universal primitives
(Poly*, Quadmesh) do not have a raytracing interface 'til now. Sorry about
that, but there wasn't enough time.

	* a class reading OFF files 
	* two lights classes: Ambient and Point (90 degress arc) 
	* complete surface props: diffuse[], specular[],
	emmission[], transparency, shininess, refraction  
	* a perspectivic "lookat" camera 
	* classes for surface mapping + some demo classes
	* a pixmap class for immediate display
	* persistence of objects, complete modelling functions
	 (scale, rotate, translate ),
	 Persistence has been realized by dumping Tcl code that
	represents the current objects
	* complete Tcl/C++ support 
	* a little shell allowing interactive programming (rtsh)
	* a further shell with Tk support (integration of YART pixmaps
	 into Tk 2D user interfaces)
	* editable hierarchy of objects with 
	  inheritance of modelling transformations and  attributes 
        * typeorthogonal assignment of attributes meaning that
	  Every primitive can be assinged every attribute 
	  the attribute context is easily extensible
	* automatic management of parts of high level objects 
	* Inputfunctionality. Input devices:
		Pick 			Locator
		FileDevice 		FileHandler 
		Spaceball 		Manipulator
	
       	Every input device manages both Tcl and C++ callbacks.
	  Other devices can be implemented easily ( Drag'and Drop,
	 ...). 

DESIGN AIMS:

	* YART is a framework that is easy extensible at any stage
	* minimization of the platform dependend stuff (currently less than
	3 per cents are platform dependend)
	* no device drivers, no platform defines!
	the YART lib is totally platform independend. just
	link the specific base lib and that's it
	* Network Transparent access to C++-objects is easily
	possible when using the Tcl interface

	* for Tcl to C++ conversion there are used parse tables
	for (half)automatic parameter conversion. These tables have
	additional informations (descriptions) and can be inquired
	interactively
	-> that informations are used for:
	- interactively programming: "sphere1 ?"
	returns descriptions of methods of OBJECT sphere1 
	- interactively programming: "Sphere ?"
	returns descriptions of methods of CLASS Sphere 
	- automatical generation of WYSIWYG user interfaces
	- automatical generated documentations (NROFF or
	HTML pages for all classes will be created automatically
	when calling "make DOC" 
	* a stereoview demo is also part of the distribution
	* an interpretative class system is also part of YART
	allowing fast implementation of Tcl classes (Composite
	primitives, etc.)

*CONTACT*
	* [email-masked]
	* there is a mailing list: [email-masked] 

*PLATFORMS*
	* OS:
		SGI Iris R3000, R4000
		SGI Indy 
		SUN Sparc
		Linux-PC 
		HP 9000	(HP-UX 9.01)

		[MS Windows - ported but not released]

	* Graphics:
		SGI GL (+ Tk)
		GTS GRALPHIGS (ISO-C binding) 
		IBM PC SVGA
		X11 (+ Tk)
		[OpenGL - in work]	
		[? SUNPHIGS ?]	
		[? PEX ?]

	* Compilers: 
		AT&T CC (cfront2.1, 3.0, 3.2)
		GNU 2.3.3, 2.4.5

		[GNU 2.5.7 seems to have problems with
		ordinary class forwards]			

YART has been heavily tested on LINUX, SGI and SUN Sparc before releasing.  	
*INSTALL*
	* get "YART0.60.tar.Z" in binary mode via ftp from
		 metallica.prakinf.tu-ilmenau.de 
	= 141.24.12.29 : pub/PROJECTS/GOOD0.60
	* login "ftp" password "HARLEY FUCKIN' DAVIDSON"	
	* the newest release should also be available from:
		ftp.luth.se:/pub/graphics/sources/oographics

	        wuarchive.wustl.edu: /graphics/graphics/mirrors/metallica.
 			prakinf.tu-ilmenau.de

		plaza.aarnet.edu.au: /graphics/graphics/metallica.
 			prakinf.tu-ilmenau.de

	* "zcat YART0.60.tar.Z | tar xvf -" ( a subdirectory will be
	  created automatically)

  !IMPORTANT!
!	* read README.GOO and set the links and the
!          GOOD_ROOT_DIR env variable!
!
!	* link src/system/<any>.mak to src/system/system.mak
!
!	* if you want to install Radiosity too please edit src/Makefile
!         (Radiosity works currently only with X11 port) 
!	
!	* call "make INSTALL" in <YART>/src
!	
!	* in "<YART>/FILES" all files of the distribution are shortly
!	  described	

*PRECONDITIONS*
	* Tcl 6.*/7.* (MS Windows)
	* Tcl7.0, Tk3.3, TkTree3.3 (UNIX with X11)
	  and { GL or X11 or PHIGS PLUS }

*REQUEST*
	* Looking for contributions, ideas, bug fixes, discussion,
	nice screen dumps, applications, demos, etc.
	* Everybody is welcome to use and extend YART 
	* The X11 shader is very slow and not suitable for
	realtime interactions on Linux, for instance.
	 Thus it would be cool
	if somebody could make a very fast wireframe shader
	* for people that want to make extensions: there is a long
	list of todoables in <YART>/TODO, but -please- read
	<YART>/GUIDELNS before hackin' any stuff and please
	contact us to avoid multiple works on the same subject
	
*DEMOS*
	on metallica there are located some traced images and a small
	animation in SGI movie formate (Dir:  pub/DEMOS) 

ENJOY with YART,
		Ekki, Ralf, Rainer, Roland, Heiko, J"urgen

****************************************************************
* Ekkehard 'Ekki' Beier                                        *
*   email: [email-masked]                          *
*   phone: ++49-3677-691243          fax:   ++49-3677-691201   *
*   talk : [email-masked] [141.24.12.29] *
* Technical University of Ilmenau                              *
* Faculty of Computer Science and Automation                   *
* Department of Computer Graphics                              *
* Am Ehrenberg, PSF 327, 98684 Ilmenau, GERMANY                *
*   private:                                                   * 
* Kopernikusstra3e 8, 98693 Ilmenau, GERMANY                   * 
****************************************************************

--
Mail submissions for comp.os.linux.announce to: [email-masked]
PLEASE remember Keywords: and a short description of the software.