...
> (3) Some info:
> - Does VRML (and VRML worlds) support any kind of Interaction?
> - Can I change other person's "worlds"? Can others change the world I made
> available? (in real-time, meaning when they are accessing it?) How?
> - How can I visualize a scene using NCSA's browser or Netscape? (or I can't?)
> - Can I atach behavior to the "objects" represented on the scene? How? (or
> they are just plain simple and static? with no action atached (like, .e.g.
> a search mechanism?)
> - Am I still making sense? Are these stupid questions?
>
> Well..at this stage..even flames are welcome:-))
I have been lurking on this list for about a week now, but I felt I had
to respond to this. My name is Pete McCann and I'm involved in some
work here at Washington University that might lend a unique perspective
to this area.
ObPhilosophy:
No, I don't think these are stupid questions. Many years before William
Gibson started writing his novels, Vernor Vinge was writing stories that
were collected into a book called _True_Names--_and_other_dangers_ (New
York, Baen, distributed by Simon & Schuster 1987). The title story of
this work was one where the heroes (the underground hackers) won out
over the villains (the government dweebs) not because they had access to
better information, but because they had better metaphors for presenting
and visualizing this information. I'd recommend this book to anyone
interested in the roots of the "cyberspace" mentality.
ObVRML:
First, let me explain a little bit about what we do here. What follows
is slightly long, but I'll try to explain just the bare minimum that is
necessary for you to understand my point.
We do program visualization work here. Our main product is a software
system called Pavane, which is a tool for making 3D visualizations of
some executing concurrent program. Our approach is unique in that we do
not require the author of a concurrent program to add calls to graphics
subroutines in his code; rather, we merely ask that he export his state.
A visualization of that state can then be generated. A typical setup
for the system might look like the following:
Program -
\__STATE_____Visualization______Display
/ SPACE Mapping ^ Module
Program - |
Open Inventor
File Format
The above diagram shows two programs executing concurrently, making
updates to some dataspace. The visualization mapping generates 3D
graphical objects from this space. It does this by applying a set of
pattern matching rules to the dataspace. We have our own language for
writing such rules and a compiler that generates C++ code to do the
matching. The Mapping module then builds an OpenInventor scene graph
(the parts of which are specified in the production section of each
rule) and sends it to the Display program, which right now is a highly
customized Inventor SoXtViewer. Animation can be used to show smooth
transitions in the state of the underlying computation. We also allow
the user to interact with the scene and this information can be fed back
to the underlying computation.
When I first saw the announcements about VRML, I was quite happy,
because it was clear that our visualization system would mesh nicely
with the standard. This started me thinking about how our system might
be integrated into the Web in general, which leads me to my main point:
VRML presents a unique opportunity to decouple the (user-defined) view
(rendering) of an object from its underlying logical (author-defined)
structure. If my browser encounters an object of type 'foo', I should
have a choice over how 'foo' is rendered, even though there might be
some default or widely accepted standard. I have heard Web-gurus
complain endlessly about the folks at N*tsc*pe, about how the extensions
to HTML satisfy many Web authors but destroy part of the essential
usefulness of the Web as an information resource. Specification of a
specific font size, for instance, dictates what a browser is allowed to
do with the document. I have no indication of what this font size has
to do with the logical structure of the document, and I am limited in my
ability to present the information the way I want to and to do things
like searches or indexing.
VRML represents 3D scenes as trees or DAGs that have structure. This is
a big win over a markup language that simply annotates some existing
structure. Personally, I wouldn't mind seeing other types of documents
written in a VRML-like syntax, such as:
#VRML V2.0 ASCII
TextDocument {
Title {
title "My Logical Document"
}
Preface {
body "Welcome to my logical document...
...
"
}
Introduction {
}
Chapter {
chapnum 1
body "Hello there..."
}
Chapter {
chapnum 2
body "Hi there again..."
}
}
This would greatly facilitate searches and indexing, and would also allow
me to "render" the document the way I want to see it, at any of several levels
of abstraction.
User-defined views of a dataset could be implemented in many forms. If the
dataset is already close to some 3D representation (already describes 3D
objects, let's say) this could be accomplished simply by swapping out the
rendering code for a given type of object. I think this could be accomplished
pretty easily with existing Inventor mechanisms for dynamic linking.
A more interesting form of user interaction would be to build pattern
matching rules, like we do with Pavane. This would allow a user to
customize his or her view of any dataset to an arbitrary extent. I can
envision some kind of distributed implementation of the Rete matching
algorithm, which would look a lot like an "intelligent agents" scenario
where I subscribe to a database with a partial pattern, and the database
is obliged to run any changes to itself through this pattern, and send
me the changes I'm interested in.
We've already demonstrated with Pavane how composite views of multiple
datasets can be constructed with a rule-based approach. To me, this
idea, coupled with a distributed pattern matching system, would bring
the Web closer to a "spider-web" metaphor, where a user can sit in the
center of his custom 3D virtual reality and feel for the vibrations he's
interested in throughout the entire net, along the virtual tendrils
created by his pattern matching agents.
If anyone wants more information about Pavane, they can look at
http://swarm.cs.wustl.edu/pavane.html
Sorry if this whole post was a bit off the VRML standards topic, but I
feel very strongly that the sort of system I've described is where the
true future of the net lies.
-- Pete McCann [email protected] Department of Computer Science http://swarm.wustl.edu/~mccap/ Washington University in St. Louis