The larges additions in this release are VBO’s for meshes, framebuffers being much more likely to work on a graphics card, and lighting in the Standard pipe.

Changelog:

GelFX 0.0.1a to 0.0.2a

General:
-Index files now specify tags. (Old index files broken)
-Meshes can change what they output in color for g-buffers.
-Meshes use VBO’s, and the user can specify what usage flag is used on OpenGL.
-GFX_NODE_STAN changed to GFX_NODE.
-Framebuffers are MUCH more robust.
-Custom Framebuffer creation. (Includes multiple color targets in a single Framebuffer)

Pipeline:
-Standard shading pipe added. (Single no-attenuation white point light)
-Deferred shading pipe added.
-Edge softening possible in both pipes. (Fake AA)
-Framebuffers support HDRI.
-Shaders can be sent messages.
-Got rid of useless “init()” function in Pipes.

The changelog can also be found in the download.

GelFX 0.0.2a – Rar

GelFX 0.0.2a – Zip

Keep in mind that this product is licensed under the Creative Commons Attribution-NoDerivs 3.0 Unported License.

The GelFX Graphics Engine by http://pixelgel.com/ is licensed under a Creative Commons Attribution-NoDerivs 3.0 Unported License.

This will be a short tutorial on making custom Pipes.

The Pipe class has two functions that you might be altering. The render function, and the init function. Each function is called when the Pipeline is processed, the init function before rendering. The init function should be used for all setup that doesn’t require rendering, and the render function should be used for its namesake.

In the render function, the Pipe is going to have to traverse the Pipeline SceneGraph. The way I do this is a “traverseNode(Node* n, Vec3f global)” function. The render function calls this with the root node of the function and 0,0,0. The function crawls through the SceneGraph, performing whatever duties it must on the nodes that qualify for treatment. For most Pipes, this would mean that the Node has “hidden” set to false, and has either its primary or secondary shader set to that Pipe’s shader.

I hope this tutorial will someday be useful. Now it’s time to get back to work on the GelFX library, rather than typing these tutorials.

This will be a short tutorial on how to make a new node.

Usually if you are making a Node, all that you want to change is the render function. Within a custom render function, you can make basically any OpenGL calls you would like, though there are some OpenGL states that are assumed to be one way or another before some Core rendering functions begin. glColor is supposed to be 1,1,1,1, faces should be culled, depth testing enabled with the depthFunc being GL_LESS, and GL_TEXTURE_2D should be enabled. Make sure that at the end of the function this is all true.

If all you change is the render function, the SceneGraph will interface with the new node class fine without any other changes. If you are making a new Pipe to use that Node in a special case, you need to make a new Node type. To do this, you must define a new node type in “Node.h”. You can see where the other defines are, right after it includes vector. The standard for Node type defines is to put GFX_NODE_ and then whatever type of Node it is. In your custom constructor you must set the variable “type” of the Node to whatever define you created.

I hope this might be useful someday when the GelFX library actually has some usable features, and full tutorials on handling the Core.

I have been making a new graphics engine for a little while, trying to keep the interface as simple as possible, as wells as keep the library somewhat low-level. This isn’t Ogre3D, Panda3D, or any of those graphics engines that do everything for you. GelFX simply provides a dynamic pipeline and scenegraph system that remain simple enough to be modified without first examining the library in depth. Within the next couple of days I will write up a tutorial for creating homebrew Nodes and Pipes, so if you want to do that you should wait a short while.

The library is only around 2000 lines of code, and provides support for shaders, framebuffers (If your GPU supports the extension) and can have anything OpenGL added to it due to its simplicity. The core library doesn’t contain anything impressive as of this posting, but I will create new pipes and nodes to the core as I progress.

The library also contains a very basic window abstraction for Win32, though any window library can be used (Just so long as it supports OpenGL rendering).

The downloads follow:

RAR Format (~4.8mB)
ZIP Format  (~5.8mB)

If you are having trouble figuring out what  to do with each class, the headers are commented.

Keep in mind that this product is licensed under the Creative Commons Attribution-NoDerivs 3.0 Unported License.

The GelFX Graphics Engine by http://pixelgel.com/ is licensed under a Creative Commons Attribution-NoDerivs 3.0 Unported License.