Just another WordPress.com site

OpenGL 4.2

OpenGL 4.2 was released, and it brings couple of features to it, actually 90% of them are features I had a hard time writing myself, and once I check how they performe, I will decide what to do about the new version. Perhaps implamenting, perhaps ignoring it, I don’t see any new features which are so exciting, so lets wait and see.

What is new?

So I had some huge problems with my computer, and I wasn’t able to develop the  insane things, all though I didn’t see many features missing with a computer of an AMD Duron 800MHZ, 384 MB RAM and nVIDIA TNT2 Riva Model 64 Pro.  So good news for people who kept their computer from 1999.

And now show off with the big guns:

JGL_FEATURE _LEVEL: JGL feature levels are slectable from 1.1 to 4.1.
With the AVD, you may render a gui pack on your app.
Supports OGRE3D mesh file format, as well as FBX, but wihtout animations( working on it! )
Like you saw, now works with OpenGL 4.1, as well as 3.3.
Better “connection” with Fragment Shaders.

And about the release:
The libraries will be available to use from 1.9.2011, and please feedback.
The Android libraries will be available from 3.9.2011, and again – please feedback!
And the AVD – released on 7.9.2011 ~ 15.9.2011, will send me feedback, so nothing from you here.
And of course, the GUI and Shader Lab – *I hope* will be available about 13 days after the release of AVD, again, will send me feedbacks by itself. Of course you may change this option.

 

After 2 weeks when I havent been home, I finally can continue working on JGL, and there is some progress – especially on the Android platform. JGL on Android may even be released sooner.

Right now, I am finishing rewriting the shell, and now using the OpenGL Vertex Buffers to make it more efficient.
What’s next? The IDE With QT.

HLSL OGL?

Right now, I am taking a little break from the JGL shell to work on something extra for JGL. As you know, JGL has an  IDE to help you write shaders, but that is not just it. I am planning to (try) implement a library which will allow you use HLSL( High Level Shading Language ) with OpenGL applications in general, and obviously with JGL application. I will post my progress, and the library when there will be any light down the tunnel 🙂 So far, I have finished the 8th grade 🙂 Finally no more Trigonometry with  my annoying teacher for the next 2 months!!

No. The whole point to see the code is to learn new things from it. The length of the code is about 1750 lines of code + 7 libraries that I had written over the years, and some of it not alone. Considering the code is only contains 10% of the whole version, the whole code will be much much more, and I don’t see an point of publishing it. Again, the code contains parts of libraries that I wrote that are too much complicated to publish and read.

All though, a part of code will be published. Like:

void DrawPlane(float size, float step)
{
jgl::shell::inner::getSingleton()->setVerteciesTrack(jgl::vertex::PLANE, size, step);
glBegin(GL_QUADS);
for (float z = 0.0; z < size; z += step)
{
for (float x = 0.0; x < size; x += step)
{
glVertex3f(x, 0.0, z);
glVertex3f(x + step, 0.0, z);
glVertex3f(x + step, 0.0, z + step);
glVertex3f(x, 0.0, z + step);
}
}
glEnd();
}

void DrawCube(float size, int resolution)
{
float step = size / resolution;

glPushMatrix();
glTranslatef(-size/2, -size/2, -size/2);

glNormal3f(0.0, -1.0, 0.0);

// top
glPushMatrix();
glTranslatef(0.0, size, 0.0);
glScalef(1.0, -1.0, 1.0);
DrawPlane(size, step);
glPopMatrix();

// bottom
DrawPlane(size, step);

// left
glPushMatrix();
glRotatef(90.0, 0.0, 0.0, 1.0);
glScalef(1.0, -1.0, 1.0);
DrawPlane(size, step);
glPopMatrix();

// right
glPushMatrix();
glTranslatef(size, 0.0, 0.0);
glRotatef(90.0, 0.0, 0.0, 1.0);
DrawPlane(size, step);
glPopMatrix();

// front
glPushMatrix();
glTranslatef(0.0, 0.0, size);
glRotatef(90.0, -1.0, 0.0, 0.0);
DrawPlane(size, step);
glPopMatrix();

// back
glPushMatrix();
glRotatef(90.0, -1.0, 0.0, 0.0);
glScalef(1.0, -1.0, 1.0);
DrawPlane(size, step);
glPopMatrix();

glPopMatrix();
}

Nice day to you all 🙂

Customizing

I don’t know if you heard, but JGL gives you the option to work with some function directly through code and IDE – toghether, synched.
That means, that a plugin must be existed to fit the IDE you are working in. The plugin will exist first for Visual Studio 2010,  and perhaps for Eclipse C++ a little later.

Open JGL 0.05 is no 8% to go!

My first goal, is easy work with vertices. How? Easy.
First of all, my first goal is to make shaders writing easily, by writing and compiling them through my IDE.  That means – a simple link to them through a vertex buffer which will follow every single vertex work you will be doing during the work with your code. And no, you won’t be working through my IDE, but Visual Studio 2010 / Eclipse C++( specially customized ). But that is far down the road.

Meanwhile, I am trying to implement some basic vertecies-work functions, such as planes and cubes, that are easily movable and rotatable via basic OpenGL function, such as :


glPushMatrix();
glTranslate( 0, 20, 0 );
DrawCube( size, resolution );
glPopMatrix();

.
 

For those of you who aren’t familiar with events, I will sumerise it: whenever something happans, a function excecutes.
Yes, there is a little bit more to it for what it sounds, a great example for it will be the C# Windows Forms Application.

I was thinking, perhaps I need to implement it inside JGL, because it would be very likely for triggred events such as
collision between objects, or even for loading.

Speaking of which, I am considering to rewrite the entire loading system in JGL, to become a XNA-content-like.

 

OJGL is now under development! Month to release, 4% is FINISHED.

The build 9, is canceled, and the build 10 will not inherite anything from the shell, which seems to cause the cancelation of 339×50.

Right now, I am writing the “cRenderWindow” class, under the “shell” namespace in OpenJGL.
Due to the ( soon to be ) implemented, the proccedure of the render window will be private, and the HDC as well.

Tag Cloud