Changelog:
General:
-Fixed problems with child node positioning.
-The window “getAspect()” function now works correctly.
-Meshes no longer support useless vertex colors.
-Made many functions virtual, for extending. (Can’t believe I forgot this one)
-Added the ability to change the title of the window.
Pipeline:
-Lights fixed.
-Fixed edge smoothing so it works properly.
-Fixed the problem in which nodes without meshes wouldn’t have their render function called.
Download:
GelNet is an ultra-light networking library. Right now it can only perform UDP networking, but in version 1.0 it will support TCP/IP connections as well. Its syntax is extremely simple and easy to interpret. Everything needed for the library is shown in the 21 line sample project and the library is only 24 kilobytes in size.
Download is here (A tutorial should not be needed):
I updated the minor version number as I have decided that the GelFX engine is somewhat usable in a project.
Changelog from GelFX v0.0.2a to v0.1.0a
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.
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.
I made another prototype, which demonstrates refractive water that integrates seamlessly with the terrain. You know how in some games, the water will form a little edge where the water meets the terrain or whatever solid object is intersecting it? This program doesn’t have that problem, the water blends right into the terrain, making the water look great.
Unfortunately, I don’t have the ability to make truly refractive water, but what I have looks refractive, and in graphics, looking fine is really what it’s all about. Anyways, here is a video and the download is available at the bottom of the post. If someone asks, I can explain the technique that I used in another post (Though be wary, as it would be quite technical.).
Download in RAR format.
Download in ZIP format.
The controls are the usual WASD control system, and Q and E move the camera up and down. Use the mouse to rotate the view. Click to make the window capture the mouse, right click to release it.
If, when you run it, you see no refraction and just a terrain, your graphics card is too old to run this prototype. My apologies to you, but there is nothing I can do.
This is a new version of the Nebula prototype, and it has point textures. This means that although I’m giving OpenGl ~32,000 points, the texture makes it render ~200,000.
Unfortunately, it is also slightly slower.
This version does not have the ability to generate a new Nebula, but it retains both blue and red colorings of the nebula.
This prototype creates a procedurally generated nebula. It is quite laggy, and so if you don’t have a modern graphics card/processor, you probably shouldn’t even try it.
Screenie:
You can use WASD Controls for x/z movement, and move up and down with e and q respectively.
Press F to regenerate a new nebula.
Press R to switch between emissive nebula and reflective nebula. (It is by default reflective)
Press 1-3 to switch color schemes for the nebula (1 is blue, 2 is red, 3 is green)
Right click to rotate the camera with the mouse
Downloads:
I have created a new website using the incredibly versatile WordPress. If any of you are planning on making a blog anytime soon, I would certainly recommend using it.
-Eavan