Object-Oriented Graphics (Tcl/C++): GOOD 0.95 
Author Message
 Object-Oriented Graphics (Tcl/C++): GOOD 0.95

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

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

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 YART
        YART is an extensible, object-oriented C++ kernel
        with consistent interpretative language binding (Tcl)
        and supports ray-tracing, radiosity and shading.

        [YART will be described more detailed behind the GOOD text.]

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

        * 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.

Additionally there are YART extensions available, see below.


To avoid a set of defines, Shell-Variables etc. you 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/require - the parent directory of all external stuff that will
                be  needed for GOOD

        XXX/require/tcltk - link to the install directory of Tcl/Tk

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

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

        XXX/MAF - install MAF in that dir or make a link
                -> see README.MAF

        XXX/packages - additional packages basing on the YART kernel

        XXX/packages/scient - install here the scientific package if ya
                need that -> see INSTALL.SCN, README.SCN

        XXX/packages/... - install other packages here

        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/off - data files in OFF format

        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 (GOOD)

!LINUX GUYS: please remove older Tcl and Tk stuff before! In (older) SLS
installations is contained tcl6.4, tk3.2 and preinstalled it /usr/local/
lib, include, bin.

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

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

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

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

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

        [ MAF?.??.tar.Z - distributed framework, currently only
        internally available ]

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

        [ MM?.??.tar.Z - multi media package - in preparation ]

        [ DB?.??.tar.Z - DeltaBlue constraint solver - in preparation ]

        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 ]

        off.tar.Z - OFF data files

YART is an obj oriented system for interactive 3D graphics.
It is independend from any platform or kind of rendering.

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

        * a PRIMITIVE is a geometrical object that has one or more
         interfaces to camera classes, these are:
                - a interface for usage of a low-level shading lib
                  such as GL or PHIGS PLUS with usage of display lists
                - a ray-tracing interface
                - a radiosity interface

                - composite mechanisms allow the implementation of
                higher level primitives without reimplementing these
                interfaces and the inheritance of attributes and modeling

        * 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

                following cameras are implemented:
                - the LookatCamera, implementing following kinds of rendering:
                  * standard recursive ray-tracing (basing on the ray-tracing
                    interface of the primitives)
                  * non-ideal diffuse progressive refinement radiosity with
                    adaptive meshing (basing on the radiosity interface of
                    the primitives)
                  * shading (based on the shading interface)  

                - OneRayCamera - for raytracing test purposes (basing on the
                  ray-tracing interface)

                - SuperSamplingCamera - supersampled raytracing

                - StereoCamera

                - at run time there can be an arbitrary number of cameras,
                more than one camera can look at one scene, extended primitives
                (i.e. a robot) may have their own camera

                -new camera classes may implement new algorithms like path tracing,
                distributed ray-tracing, hybrid rendering, shading formulas, etc.

        * ATTRIBUTEs are properties of PRIMITIVES
                - YART implements an object-oriented, flexible
                and extensible attribute mechanism
                - 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 attrs are:

                        Surface         Fillstyle
                        Resolution      Mapping

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

        * LIGHT sources are like PRIMITIVES objects those can
                 be inserted into a scene
                - light sources also have specific interfaces for communication
                with cameras

        * 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 world
                - the parameters of mappings can be changed
                - 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.
                YART implements a flexible, extensible, object-oriented
                interaction model basing on abstract events, high-level
                events, callbacks and hierarchical input 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

* Further features are:
        - two consistent language bindings: C++ and Tcl. Tcl allows
        an interpretative access to the graphical classes and objects.
        - built-in documentation for interactive inquiries, automatic
        man page and user-interface generation
        - integration of Tk widget set
        - high level primitives (analytical, OFF, text) basing on the
        basic primitives (Poly*, Quadmesh)
        - an object model distinguishing between objects and non-objects
        - an interpretative class system
        - Tcl and C++ demos showing usage and extensibility

*MAILING LIST (english speaking!)*

        * OS:
                SGI Iris R3000, R4000
                SGI Indy (IRIX 4.0, 5.1)
                SUN Sparc
                HP 9000 (HP-UX 9.01)
                NetBSD (0.9a)

                [MS Windows - ported but not released]

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

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

        * get "YART0.95.ar.Z" in binary mode via ftp from
        = : pub/PROJECTS/GOOD0.95
        * login "ftp" password "HARLEY {*filter*}IN' DAVIDSON"    
        * the newest release should also be available from:

                wuarchive.wustl.edu: /graphics/graphics/mirrors/metallica.

                plaza.aarnet.edu.au: /graphics/graphics/metallica.

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

!       * read README.GOO and set the links and the
!          GOOD_ROOT_DIR env variable!
!       * "cd src; configure; make install"
!       NOTE: The predefined configuration can be changed,
!       for instance: configure OPEN_GL
!       * in "<YART>/FILES" all files of the distribution are shortly
!         described    

        * Tcl7.3, Tk3.6, TkTree3.3 (tkTree.tar.Z), { GL or X11 or PHIGS PLUS or AIX GL
        or OpenGL }

        * 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

        on metallica there are located some traced images and a small
        animation in SGI movie formate (Dir:  pub/DEMOS)


* Ekkehard 'Ekki' Beier                                        *

*  phone: ++49-3677-691243          fax:   ++49-3677-691201    *

* 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                   *

Mon, 09 Dec 1996 00:53:27 GMT  
 [ 1 post ] 

 Relevant Pages 

1. Object-Oriented Graphics (Tcl/C++): GOOD 0.70

2. Object-Oriented Graphics (Tcl/C++): GOOD 0.50

3. Object-Oriented Graphics: GOOD 1.2

4. Object-Oriented Graphics: GOOD 1.00

5. object oriented tcl (using tcl with c++)

6. A good tutorial(book) about Object-Oriented Tcl

7. ANNOUNCEMENT: Object-Oriented Systems - new object-oriented journal

8. ANNOUNCEMENT: Object-Oriented Systems - new object-oriented journal

9. Workshop on Object Oriented Graphics (CFP)

10. CFP - ECOOP/OOPSLA Workshop on Graphics for Object-Oriented Software Engineering

11. Workshop on Object Oriented Graphics (CFP)

12. Dallas, Tx. - Object Oriented Mentors - C++ or Smalltalk


Powered by phpBB® Forum Software