OOP 3D app development environment?

Ooka 101 Aug 24, 2006 at 20:44

Represent objects as cubes and spheres, their methods and properties as textures (colors, etc.), and then build your programs by dropping objects into a 3D space, linking them with different color lines for individual methods, etc.

Anyway, it seems to me that such a tool would be phenomenally useful, especially if it came with a VS type toolbox, etc. The design view could be a transparent plane on one side of your program’s enclosing box. Just click and change perspective to view the application design, use perspective to drop new objects and links between objects into the program. It could even potentially represent an object logically by basing the number of faces of an object on the number of methods and other properties.

Objects could even be made into textures, and then applied to other objects, and so on. Wouldn’t OOP logic be easier to envision with a simulation of the actual objects right in front of you?

Is there anything like this out there?

6 Replies

Please log in or register to post a reply.

monjardin 102 Aug 25, 2006 at 15:30

There are tools that allow you to build class hierarchies in UML digrams and generate the code framework. Google for CASE tools.

dega512 101 Aug 25, 2006 at 16:05

There are tools that allow you to build class hierarchies in UML digrams and generate the code framework. Google for CASE tools.

You can also look into VS.NET 2005, it does this too.

Ooka 101 Aug 25, 2006 at 17:22

Not quite what I’m envisioning. Perhaps an entirely new language would have to be developed…

Imagine your program as a 3 dimensional object consisting of boxes, pipes, spheres, and wires. Imagine writing your program by creating the code for a particular object, then assigning it unique visual properties. So you’d click on your toolbox, drag a Red Cube and place it near the other objects you want it to interact with, and connect it to those objects using wires. If you need to extend the object a bit, physically, attach a pipe that will link out to the appropriate object.

So basically, you could create a shell for an object by creating a cube. Whatever language you’re using has a base class template. Then, you can use a properties tab and select a number of methods, etc, which would automatically place wire-connectors on the object, each with a unique color.

I know UML flowcharts and other tools can help you visually design code, but I would like to actually see an integrated 3D coding environment, where it merges all the advantages of modelling and 3D logic with OOP frameworks.

You’d still have to sit down and write code for everything at the end of the day… theres no avoiding that, as far as I can tell. But you can visually appraise and innovate with your own set of code objects.

Bleh. My vocabulary lacks the words to properly express this idea, but the best I can approximate it as is this: 3D Script Modeling

The objects and heirarchy are transparent to the designer, except for the code view pane.

The more I think about it, the more I’m sure that it hasn’t been done, and that it’s probably not been done for a good reason. I’ll try to clarify, and maybe offer an example of the logic behind it.

Ed_Mack 101 Aug 26, 2006 at 01:57

The problem is that code simply has no spacial mapping. Code is so unbounded, and has so many underlying semantic relationships that it just wouldn’t work. And once the program was large enough to be useful, the environment would be cluttered.

Although, you could probably play with better ways to navigate source code than a file listing and a few hyperlinks.

SmokingRope 101 Aug 27, 2006 at 07:28

How do you intend to represent conditionals and function bodys? Generating a texture from some source code might be one thing. If the texture defines the source code content it’s a whole different ballpark. I like the idea but it’s more of a visualization tool from where i see it. Maybe based on a zoom feature you can convert a texture into spheres and cubes. You could optimize the program by preprocessing the different classes on startup or during compilation; this still won’t get you anywhere near C++.

Ooka 101 Aug 28, 2006 at 02:22

Hmm… ok, so there isn’t anything out there like this. I think a design doc is in order. Real Tron, lol.

Just off the top of my head, I’d say that conditionals would be represented by semi-transparent connectors with the texture of the originating object. I was thinking that the individual faces of polyhedrons could be a generic “container” for functions, methods, definitions, etc.

The usefullness would be the ability to visually design an application by dragging, dropping, linking, and texturing code objects without a greater understanding of the code beneath. Some sort of AI would have to make assumptions on what specific linkages are supposed to mean in the source code itself.

For instance, let’s say you grab a textbox cube, place it in the application space, then switch to form view, place it correctly on the form, where you want it to be, and then back to 3D design. Add a text display object, then use an Output shaded line to link from the textbox to the display object. The program would assume that on an event, the contents of the text-box would be presented in the display object.

To modify the event, right click on the linker object, which would present you with the properties of the methods available to the textbox object. Set your Event as the Enter key, or some such.

An AI would have to be designed to make assumptions based on the visual logic of the designer. All those assumptions could be run through an interface of some sort that lets you choose the “settings” of an object being placed or modified. Each “object” in oop by definition contains it’s own context, so designing a tool to read that context meaningfully and determine possible interactions with another specific object should be possible.

An arbitrary set of spatial relationships could be defined on the fly, so as to keep the program manageable and uncluttered. Zoom tools and auto-occlusion would be all thats needed to focus on individual areas of code… imagine flying over a city, only the city is on the surface of a sphere. Or a Cube, or however. I imagine that once this program goes through the first few stages of testing and real thought/effort, the creators would come up with the solution to the problem of viewpoints and gestalt mapping.

Oh, and it would prevent any sort of dead zones in your code. I know I’ve had that problem before… code that appears to be functional and integrated with the project you’re working on, but through some sort of error, the code is isolated from any real interaction with the rest of the program. Faulty interfaces and flow control would be presented in a visual manner, while the actual code remains a black box to the user. Unless you want to view it, of course, but thats the idea.

Anyway, lots of good thoughts. I’d love a tool like this, especially with an import function to bring in and automatically parse existing code into 3D objects.