|
Magician Frequently Asked Questions
Basic Information About Magician
- What is Magician?
Magician is a set of classes written in the Java(TM) programming
language that allows you to write high-performance 3D applications using
the OpenGL(TM) API designed by the OpenGL Architecture Review Board.
- What is OpenGL?
OpenGL is a platform-independent 3D graphics API designed through
an open specification process by many industry leaders including
Silicon Graphics Incorporated, Microsoft and Sun Microsystems.
For more information, please read the OpenGL
Frequently Asked Questions.
- So, why do I want this?
If you are a developer currently writing OpenGL applications in C, or C++,
you might well be interested in Magician. Magician abstracts
all the underlying window toolkit code away from the programmer, and,
since it is written in Java, will run immediately on any Java platform,
including Windows95/NT, Solaris, Linux, Apple, Irix and HP-UX to name but a
few!
You can also take advantage of our unique ``composable pipeline''
architecture that enables you to runtime enable per-statement profiling,
tracing and error-checking. These powerful features allow you to track
down and remove problems in your applications extremely rapidly.
Magician also leverages functionality from Java itself including
the ability to load model data and texture maps via the Web. We
ship several other extremely useful utility classes such as virtual
trackball support, Encapsulated PostScript writers and model data loaders
with Magician.
- What's the licensing?
Magician 2.0.0 implements an ``evaluation'' download version which
runs identically to the fully-licensed version of Magician with
the differences that:
- The word ``Evaluation'' is displayed in the bottom-left corner of
each OpenGL window intermittently.
Apart from those two differences, the evaluation and licensed versions
of Magician are identical and support 100% of OpenGL and GLU.
We offer a range of licenses ranging from the hobby programmer or
home enthusiast to source code licenses for corporations wishing to
closely integrate Magician into their own technologies. Full
information on these licenses and draft copies of each license type can
be downloaded via our Licensing page.
- What's going to happen to Magician when the ``official'' SGI bindings become available?
The bindings being developed by SGI have not yet been ratified by the
OpenGL Architecture Review Board and appear to have stalled for the
time being. Arcane Technologies have indicated their interest in
defining the standard for OpenGL Java bindings and distributed a
short hand-out at the March 9-10 OpenGL ARB Meeting overviewing
Magician.
Arcane Technologies attended the June 1998 OpenGL ARB meeting and
ensured that the Java OpenGL bindings process was kicked back into gear.
A working group to discuss and design the ``core language'' specification
has now been set up. Arcane Technologies are a member of this working
group and Magician has been put forward as a proposed architecture.
Our presentation to the OpenGL ARB is available via the Web for
download and reading from our Documentation Pages.
The presentation is available as a self-running Powerpoint presentation
which means you don't need Powerpoint installed to view it or it can be
viewed on-line as a series of images.
We have just released ( 16th November 1998 ) a response to a set
of questions the OpenGL ARB issued regarding the submitted JavaGL proposals.
Magician successfully covers all of the questions. Read
the document on-line or see the
Documentation Pages for PostScript and PDF
downloads.
Archives of the working group mailing
list can be found on our WWW site and may be perused by all interested
parties.
Whatever the outcome of the ratification process for official Java OpenGL
bindings, we will implement this specification rapidly and retro-fit it
into Magician allowing usage of both Magician's powerful
composable pipeline architecture and the ratified standard if they differ.
- What's the relationship between Java3D and Magician?
There is no relationship between Java3D and Magician other than the
fact that both offer 3D rendering capabilities for the Java programming
language.
Magician offers a lower-level solution to rendering than Java3D
in that Java3D is potentially layered on top of OpenGL whereas Magician
is OpenGL.
Our sister product, Sorceress is closer
in functionality to Java3D than Magician.
- Do Java3D and Magician interoperate?
No. Magician and Java3D use different approaches to rendering.
Magician also supports far more virtual machines and operating
systems than Java3D and runs considerably faster than Java3D.
Problems Running Magician Software
- When I try to run the demos, I get ``Unable to locate class com.hermetica.magician.demos.bootFrame''?
There are several reasons that you may encounter this error. The most
common being:
- You have not downloaded the Magician core classes and compiled
demo programs.
- Your CLASSPATH setting is completely wrong. To resolve this problem,
you must add the location of the Magician core classes to
your CLASSPATH environment variable.
- You are following old instructions or have an old release of Magician.
The correct class name to run the demo harness is:
java com.hermetica.magician.demos.bootFrame
- You are not using the correct Virtual Machine. Using the java
program is restricted to the Sun Virtual Machine via either the
Sun JDK or JRE. If you are using a Microsoft-based Virtual Machine,
you will need to run
jview com.hermetica.magician.demos.bootFrame
- When the demos program runs, it pops up a window saying there's a
Magician error??
This happens when there is a problem with the underlying native library.
Follow the instructions in the box.
- What's this ``Xlib: unexpected async reply (sequence 0x68fe)!'' error?!
This error occurs due to the fact that the Java Virtual Machine is a
multi-threaded program but the underlying X Windows library that AWT
depends on are not. This message is generated when two threads are attempting
to use X Windows simultaneously causing the X protocol to get its knickers
in a twist. Essentially, this error can be classed as being a race condition
and until the Virtual Machine developers correctly initialize X Windows
multi-threading, this error will not go away.
The error is mostly prone to occurring under the following conditions:
- The machine upon which you are running a Magician application
is under extreme load and the actual X-Windows protocol which is
transferring the frame buffer from the X server to the client
simply cannot cope with the amount of traffic being transmitted.
- The error can similarly occur, and, in fact, is more prone to occur, if
you are running a Magician application on a remote X server, since
the network latency will be a bigger issue increasing the window
for a race condition to occur.
If you encounter this error in your application, there are usually ways
in which it can be worked around. Please contact Arcane Technologies if
you wish assistance in this area.
Note: This problem was generally rectified in the Beta 3
release of Magician but still occasionally appears especially
under certain configurations of Irix.
- ``Your applets are broken!''
The most usual causes of problems pertaining to running the Magician
demonstrations applets on the Arcane Technologies WWW site are as
follows:
When will.....?
- ...there be a port to....?
The current porting schedule for Magician is as follows
Operating System / Browser |
Date |
AIX 4.x |
Preliminary port completed -- Available to licencees |
SuperCede |
Discontinued as SuperCede have been acquired |
IBM Visual Age for Java Version 2.x(1) |
No ETA |
BeOS (2) |
No ETA |
(1) IBM have confirmed problems with Visual Age for Java versions
1.x and 2.x. We have no ETA from IBM as to when these problems
will be resolved and as such cannot supply a date for when
Magician will run under Visual Age for Java. Applications
of the latest FixPaks does not appear to resolve the problems.
(2) BeOS support will not be implemented until the
BeOS supports a Java Virtual Machine! There are no
plans for this to happen, as yet, for either
Intel or PPC releases of the BeOS. If you know
otherwise, please let us know!
We rely on your input to determine which platforms it is worthwhile to
port Magician onto. Therefore, if you have a favourite platform
that Magician does not run on, please contact us
and let us know about it!
- ...Magician support Swing?
Magician 2.0.0 can be used with Swing in certain ways that do not
trigger problems within Swing's design such as the occlusion of lightweight
components with heavyweight components and the inability to use heavyweight
components within lightweight layout managers such as JInternalFrame.
The major problem is that Swing fundamentally does not interoperate with
``heavyweight'' AWT components such as Magician uses. We have
experimented with various software-based solutions to the problem, but
performance is so appalling, we have decided not to release our Swing
components for Magician.
- ...Magician support Java-2?
Magician supports Java-2, including HotSpot.
- ...Magician support Microsoft OpenGL instead of / as well as SGI OpenGL?
We have decided to ship Magician 2.0.0 with Microsoft
OpenGL linked versions of our native code. However, we have found in
testing that this version of OpenGL is slightly less stable than SGI
OpenGL so SGI OpenGL remains the ``preferred renderer''.
It is also possible to force the usage of Microsoft OpenGL with the
standard SGI OpenGL linked version of Magician. SGI OpenGL supports
hardware-acceleration by ``passing-through'' to Microsoft OpenGL if a
hardware-accelerator has been detected on your machine. By use of a
registry setting, it is possible to force the use of Microsoft OpenGL
whether or not a hardware-accelerator is present. This allows you to
then use Microsoft OpenGL with Magician. The registry setting is
called
\\HKEY_LOCAL_MACHINE\Software\Silicon Graphics\OpenGL\OverrideDispatch
and it should be created as a DWORD value. The following values
have the following effects
DWORD Value |
Effect |
0 |
Use SGI OpenGL unless hardware is detected. ( Default ) |
1 |
Always use SGI OpenGL. |
2 |
Always use Microsoft OpenGL. |
To test this out, create the new registry setting and set it to 1.
If you then run the Magician demo program
java com.hermetica.magician.demos.bootFrame
jview com.hermetica.magician.demos.bootFrame
and select ``Help | OpenGL Information'' from the menu bar, it should
report something like ``SGI Generic 1.1''. This shows that the
renderer being used is the Silicon Graphics one.
If you then set the registry value to 2 and re-run the demo
program, it should report that ``Microsoft GDI Generic'' is being
used. That shows that either the Microsoft OpenGL software renderer or a
hardware-acceleration driver is being used.
We have also added a property test to Magician 2.0.0 called
magician.renderer which allows you to specify which renderer is
the preferred renderer on the command line. For example, with the Sun JVM,
you could run:
java -Dmagician.renderer=Microsoft com.hermetica.magician.demos.bootFrame
to use the Microsoft renderer before the SGI renderer. Valid values for this
setting are
SGI
Microsoft
Mesa
Sun
IBM
Note that not all of these renderers will be available for your platform. If
the preferred renderer cannot be used, Magician will attempt to load
other implementations for use.
Hardware Acceleration
- What hardware does Magician support?
Magician itself does not support hardware-acceleration. The
presence of hardware-acceleration is dictated by the underlying OpenGL
libraries that a particular build of Magician uses.
Card manufacturers wishing us to test their cards in conjunction with
Magician should contact us
for more information.
Support for Magician
- What support do I get for Magician?
Please see our Licensing & Support page for
more information on this.
Java is a registered trademark of Sun Microsystems, Inc.
OpenGL is a registered trademark of Silicon Graphics, Inc.
|