Knowing java structure

When WebGL becomes available it will make a radical change in network cooperation as it will allow a type of collaboration that has never been seen before. I can't even guess at what could be layered on top of it. It is probably one of the most important developments I have seen in a while. Strange ants are starting to get in my java OpenGL gears and so I will leave `java` alone for a while.

This is a way to set 'classpath' for Java as an environment variable. I simply wanted to make the process cleaner and refine the targets. Some of these jars do not exist in my environment and I was separating it out so I can test which are required for the tests. At the moment I assume java.library.path must be set at the command line in this case with the -D option as described in `man java`.

CLASSPATH=:res:jar/lwjgl.jar:jar/lwjgl_test.jar:jar/lwjgl_util.jar:\
jar/lwjgl_fmod3.jar:jar/lwjgl_devil.jar:jar/jinput.jar:
echo "This is CLASSPATH" $CLASSPATH
LD_LIBRARY_PATH=libs/linux
echo "This is LD_LIBRARY_PATH" $LD_LIBRARY_PATH
java -Djava.library.path=libs/linux org.lwjgl.test.opengl.Gears
unset CLASSPATH
unset LD_LIBRARY_PATH

The best way for me to understand anything is to do it and then redo it until I understand the nuances of the process. For java you need to know that `ant` is the XML builder and that a ".java" file compiles to ".class" using `javac` and is run by `java` using the Java Virtual Machine. It is great for things that have logic as it can be very predictable and safe, but the problem is the same one that every piece of software has: the interface with the real world and crossing the boundary to something strange.

I have an advantage as I can exclude, apply, or include many things that others would not comprehend for lack of contact with those things. For a list of some: the architecture of a digital machine, library structure, hardware interface, and systems utility and debug. In this case I want to "shotgun" a solution and then identify weaknesses and misunderstandings as the process proceeds. 'lwjgl' is a free opengl for java and others are proprietary and as such have no source, which makes it vastly more difficult to apply and understand and troubleshoot. This example will probably not serve well for others as I take some liberties just to get to the goal and your mileage may vary, in fact, the car may not even start.

# about 10 minutes
svn co https://java-game-lib.svn.sourceforge.net/svnroot/java-game-lib/trunk/LWJGL lwjgl


cd lwjgl

mkdir bin

ant generate-all
#BUILD SUCCESSFUL
#Total time: 23 seconds


ant compile
#BUILD SUCCESSFUL
#Total time: 13 seconds


ant compile_native
#BUILD SUCCESSFUL
#Total time: 20 seconds


cp -R bin/org org
cp -R bin/lwjgl lwjgl

man java


java -cp .:res:jar/lwjgl.jar:jar/lwjgl_test.jar:\
jar/lwjgl_util.jar:jar/lwjgl_fmod3.jar:jar/lwjgl_devil.jar:\
jar/jinput.jar: -Djava.library.\
path=libs/linux org.lwjgl.test.WindowCreationTest

And finally the console output of the test program on an X86_64 architecture using fglrx and X11.

#The following keys are available:
#ESCAPE:         Exit test
#ARROW Keys:     Move window when in non-fullscreen mode
#L:              List selectable display modes
#0-8:            Selection of display modes
#F:              Toggle fullscreen
#SHIFT-F:        Toggle fullscreen with Display.destroy()/create() cycle

The biggest problem with using an IDE is that you do not gain the knowledge of how to troubleshoot complex interactions like recursions, machine dependencies and many other things that can interfere. If the machine is exactly the same between users it would be much simpler, but technology constantly changes and there on the edge where I live the rocks are loose and it is easy to fall into the abyss of NULL bits and if you don't have a sonic screwdriver, you probably won't get out.

If you don't speak the language you won't get any information exchanged and even if you do, sometimes all they are saying is IDK.

NetBeans 6.0.1 is available from the debian archives along with other associated software. I installed that also on all architectures and tested. I lose interest with GUIs and eventually write my own interfaces, but for testing and examples it is a good learning tool.

I managed to learn some new things inadvertently about .eps, `inkscape`, XML image editing and origins. In order to solve the puzzle of the universe you need to have a lot of pieces and a convenient way to test their fitness to each other. I also know some new things about ancient Egypt during the time of the Pharaohs. Strange how some things interact. I may be Mae'r blaidd drwg go iawn or maybe Волк времени. There are so many things that become clear on the way to infinity and many have never been seen before and some have will never be seen without the eye that sees them.

Here there are ants and wolves and dragons.

When moving to another machine without the development files on the X86_64 machine I discovered that many dev headers are required for the `ant compile_native` which uses a C generated library. It isn't too difficult to figure out where those headers are located and again I just shotgunned it and installed kdevelop to start.

The lwjgl works well on the 32 bit machine and this is typical of open source. It seems that all the open source software is more usable and of course it is because there are many eyes to look at it and things created in the dark have a tendency to be more like fungus than flowers. It has a problem with full screen modes on the laptop and that it shares with about every other program as there is something odd going on with full screen on that machine. Beyond that it responded to keys and moved about, changed display sizes, and ran flawlessly. I am afraid that fglrx and X86_64 will be the last place it will work, but I have 32 bit partitions on that machine and they work fine. So open source wins again and everybody involved deserves some praise , it works and that is what it is all about.