Tuesday, November 30, 2010

Qt3d not ready

Wow. It took a couple of months of work to figure out that I can't use Qt3D, at least, not yet. As it stands, it's just too slow when used in conjunction with my system. When they've cleared up a few problems, especially the way they apply objects, I'll engage the code and try again.That was a very difficult decision to make. Upgrading to OpenGL ES2 is even more difficult using my old approach but I have no choice as of today.

I cleared up a few problems with some Qt upgrades. No objects could be created from menu and key presses are ignored, don't know why, somewhere along the line, Qt changed the way they do things and it's up to me to keep up with those changes. 3d development is gruesome but it's the holy grail.

Anyway, no matter how long it takes, I plan on having a system that deals with this book the way it deserves to be dealt with. Period.....

If I had unlimited funds, those funds would go into the creation of 3d views of the Urantia Book's concepts. Using the system, I plan on licensing it and using that to fund hiring people to create objects like the Jerusem circles. These objects can then be used, painted and manipulated by the system.

Onward and upward

Thursday, November 25, 2010

Fixed 3ds object imports on Linux-like operating systems

Wow. Thought my object import system was dead. I forgot Linux cares about upper/lowercase. Works again. God I love Linux, its just so powerful. Apple, though, is really an awesome platform to test the underlying BSD platform that the Apple runs on.

Sunday, November 21, 2010

Upgrade Failure on N900

Got impatient and tried getting an update on the embedded platform.

Using Qt3d and the Nokia SDK, I am unable to get a working copy of the Virtual Urantia book on the N900 cell phone. I'll be waiting till the Nokia SDK releases with version 4.7 or 4.8. For now, it's still working with version 4.6 which unfortunately doesn't support the new Qt3D SDK.I could try to compile the 4.7 Qt source with the Maemo (the operating system for the N900) toolkit but I have better things to do than to get impatient and waste time when I'll be able to do it with the next version of Nokia's SDK for devices.

It would be nice as I can show off my progress to Marlene and also prove to myself that what I'm doing will work with the OpenGL ES2 hardware.

Oh well. I have other things to do. Back to Object Picking on Qt3d.

Wednesday, November 17, 2010

Large Scene Efficiency fix

Finally, I have the embedded platform's large scene efficiency working. The whole system won't come down to a crawl on a cell phone. It's time to work on the picking part of the platform. That is, selecting an object in a scene. This way, I bring up pertinent information about the object, say Jerusem, for instance. I'm still waiting for Qt's upgrade to Pepper2 on Native Client. I think I'm over the hump of getting this to work on OpenGL ES2.

Next comes getting the effects system I just completed last month to take the jump into OpenGL ES2.

Monday, November 15, 2010

Native Client

Both Saturday and Sunday I spent trying to compile Native Client and Qt. No luck, not really a lost weekend as I'm relearning the ins and outs of Linux again. I'm done with Windows, just too many security risks, that is, for development. I will, though, recompile (recreate) the program on it at intermittent intervals. Anyway, without Qt, I have no Native Client and with no Native Client, no Internet.

Received an email back from Morten Sorvig at Nokia. He's explained that he stopped working on Qt compiling in Native Client until they release Pepper 2. This is more of the real thing as Pepper 1 was the release that didn't support all the sandboxed protection on the Net. They're a month late, so any day now.  

A lot of people think that this computer business is changing too quickly. From my vantage point, it's like Molasses. It's worth the wait, though.

Back to working with QT3D and the conversion to OpenGL ES2. I'll put together the scenarios and functions to show that I can't, as yet, get it working with large scenes or they haven't handled it yet. Both Power Plant and Virtual Urantia need large scene efficiency and I haven't found the secret that will allow Qt3D to be efficient with large scenes yet.

I'm doing double duty here. I'm working on my own version of converting to OpenGL ES2 without QT3D for now. I can't be sure that their system will be ready or capable as yet to go full speed. The worst thing that can happen to a programmer is to up against a wall without a way out.

Friday, November 12, 2010

Qt3D and the Net Continued

Here is where Qt3D comes in. Qt3D is a research arm of Nokia's Qt software development kit (SDK). Jumping to a platform such as OpenGL ES2 when you're stuff is written in OpenGL is not a trivial change. The mathematics of 3d is very complex.

(Skip this paragraph if math is not your friend)
Take a simple cube for example, every corner of a cube has to be entered into an a variable array with 3 floating point numbers. Since there are 8 corners, this adds up to 8 * 3 or 24 floating point entries. Then in a separate array, a normal entry has to be made for each corner which tells the corner where to reflect light from. Then every face corner has to entered into an index that describes each face. That's 4 entries for each face. Since there are 6 faces, that's 6 * 4 = 24 entries. That's a grand total of 24 corners (vertices) + 24 face descriptions + 8 normals or 56 entries in 3 separate variable entries.

Now that I've described a cube, imagine the resurrection halls of Mansonia. Thank God I have standardized programs that can create these objects for me. For that I use  programs that create the 3d entity. I still have to deal with manipulating the arrays and delivering them to the graphics engine. I use Blender for that. It's open sourced, so it's free and is capable of creating all the 3d content I need to get the Urantia Book in 3d.

Ok. This is where Qt3d comes in. It makes it easy for me to take these arrays and properly present the objects with the right mathematics to position, rotate and resize them in the scenes that are created to present the information to the user.

Using Qt3d and Qt, I am now capable of presenting 3d content to the graphics card in an organized fashion using OpenGL ES2.

The next step is getting it to function on the Internet. Nokia's Qt SDK has an arm that has just released a project called Lighthouse which, hopefully, simplifies getting the system to work on differing types of computers. It has a branch that
takes my code and resets (recompiles) it to work on Native Client. Native Client, as I alluded to earlier, allows C++ programs like mine to work on then Internet.

A little bit on Native Client. Using the Qt's Lighthouse project, I can place my system through Native Client on a normal browser. The code is sandboxed, that is, protected from damaging the local computer and then it is presented to the user as if it had been installed. Google has a front end using Native Client's way of compiling the code (making my code usable by a computer), that first, makes sure that some methods of using the local computer aren't entered into the program and then they insure this when the user accesses the code by visiting the page on the Internet.

At that point the program downloads and is tested for compliance so that no program is capable of damaging the local computer. I think that Google has breached the new way of using the Internet. A real stroke of genius for Google and the power that will be placed on the Internet. The first time you download the code, it takes a bit of time and from then on it only downloads the changes. This way, when I upgrade, I won't beset the users with long waits. I've asked the programmers to add a wait progress icon to help with long waits. I'll be entering it in their bug and suggestion system today.

My hope is that Google succeeds with this platform. It represents the largest change to the Internet since it was born and will bring power between disparate systems. I create my own hardware, that is, build my own circuit boards and one thing that doesn't escape me is that the entire breath of hardware makers and controllers use C and C++ for control of their hardware. It is by far the best way to manipulate a CPU or GPU directly (Central Processing Unit and Graphics Processing Unit). So it goes to follow that most of these people will be able to control their stuff over the Internet if they are given the chance and that is where Native Client comes in. That is not the end of the story. All the major software is generally written in native code like C++ and now with Java. JavaScript is different, it is what is used on the Net. They will also give Cobol and Fortran the capability to present their programs also.

So, programs like Adobe Photoshop (if they take advantage of it), will be able to run from any computer on the net. That includes the new TV you're going to buy.

So a new age is born and I've waited long enough to get on the Net. Two days ago, I started playing with getting up and running on Native Client. Since the system is not completely ready for OpenGL ES2, 3d will have to wait till that's complete using Qt3D. In the meantime, I have the searching and indexing system running on the Urantia Book and it is capable of looking up things pretty quickly and in many different ways. Working directly with the Urantia book, I am capable of doing a lot of really interesting things with the book.  So that's what I'm putting up on the Internet first.

I've read some of the dissenting voices coming from the industry as far as Native Client is concerned. For instance, both Firefox and Opera say it's dangerous and they seem to be resisting the change. First comes rejection, then apathy, then acceptance. I guess it's the story of humanity. I've looked at their concerns with security and there is no doubt in my mind that ActiveX on Internet Explorer, Firefox's NSAPI, and the like are far more dangerous and have been creating the enormous virus and trojan problem we're having. I don't know anyone who hasn't been affected by these. Native Client will pretty much eliminate all of that. I use Kubuntu Linux now so I'm not plagued with any of these problems but everyone I know using Windows has been attacked. For now, Google's Chrome and Firefox are the only two working as yet. Chrome mainly. It's a good browser and will probably gain a strong following until Firefox and Opera have decided to use the Native Client code instead of Google forcing Native Client through NSAPI and the like.

Anyway, I am fully dedicated to bringing the Virtual Urantia platform and it's evolution to the Web, that is, as long as I'm mentally capable.

From now on, I'll be posting my efforts here, probably on a daily basis.

You can type in "Pierre Chicoine" Qt3D with the quotes around my name or "Pierre Chicoine" "Native Client" or PierreChicoine Qt3d or Pierre Chicoine Virtual Urantia to see some of my 3d exploits.

Qt3D and the Net.

This my first blog entry, so it's detailed.

There are two main steps in getting the Virtual Urantia book online. The first is getting the 3d engine side of the system into a format that will be recognized by graphics cards on differing computer architectures on the Net.  This is where I use OpenGL ES2.  In 2001, I switched from Microsoft MFC to Qt from Trolltech. I began writing this system with Microsoft MFC in 1996.  Qt being cross platformed and Microsoft being locked to Windows only. The problem right now is that I am using OpenGL and not it's successors OpenGL ES2 and OpenGL 4. OpenGL ES2 works across all desktops and embedded platforms. Examples of embedded embedded platforms are your cell phone, your higher end TV, your new notebook, even your newer remotes. I'm writing this entry from my cell phone as I am still in bed.

The second is getting it working in a browser. I've learned that very few people are willing to download and install a program into their computer. It has to be easy and painless. Give them a web address and that's the depth of the involvement. That's not an easy thing to accomplish. I write in C++. I can't imagine using anything else at this stage. When I first started tackling this problem, I looked at ways of delivering 3d content on the Web. X3d was one of my attempts. After a month of work, I decided it would'nt work. I waited several months while creating the effects system in OpenGL ES2 and the answer came with Google's Native Client. Here I see a a way to get my system on the web without a complete rewrite of 10 million typed characters of code. That's more characters than the Urantia Book itself. Using Native Client, I'm capable of writing the whole thing in C++. Whew!

So much for now.