Jinx Engine

Business and Project Management Discussions Community & Volunteer Projects
#1

I’ve gone through the normal channels but 2 months later an no luck, so I’ll post here instead.

Jinx Engine

Typically, scenegraph rendering APIs provide an
abstraction above the rendering library to hide away
the details of a particular API or support multiple
technologies through a single interface. While this
solves these issues, it can also lead to a new API
which becomes just a complex to learn. Developers with
an understanding of graphics libraries such as OpenGL
can often feel like their hands are tied using a
scenegraph due to the nature of this abstraction.

Jinx is 3D hybrid scenegraph rendering engine for
LWJGL. Rather than abstracting the underlying
rendering technology, Jinx embraces it, allowing a
mixed mode of programming through pre-defined and
custom nodes in the scenegraph.

The scenegraph allows callbacks for states which are
attached to the nodes in the graph, for example,
attaching a color state to a geometry node to specify
a color for the geometry. A callback within the
render process allows the developer to insert code at
any point in the state rendering process to define
custom states which are not directly supported at the
API.

The developer is given the choice of fully utilising
the existing scenegraph structure and at any point
adding nodes with custom LWJGL endering code. The Jinx
API uses the LWJGL classes extensively to further
support the familiarisation of existing LWJGL
developers.

The goal of Jinx is to find a balance between a high
level scenegraph which allows rapid development of the
rendering process and flexibility to allow interaction
with the engine at any point by providing custom
rendering code. At this stage, the basic scenegraph
framework is being developed, with emphasis on the
scenegraph API rather than the custom interaction
parts, although support for these do already exist.

See jinx.dev.java.net for an example of a NeHe port
for Jinx under the examples. Further examples and
documentation will be added to the site shortly.

#2

I thought that’s what the others were trying to move towards already, where not already in place?

#3

Easier to see than explain…


public class RenderIntegrationTest {
	/**
	 * Constructor
	 */
	public RenderIntegrationTest() {

        /*
         * Create a rendering display window using defaults.
         */
        RenderWindow rWin = JinxEngine.getInstance()
                .createRenderWindow();

	/*
	 * Apply an intial state to clear the color buffer
	 */
	JinxEngine.getInstance().getEngineStateContainer()
		.applyState(new ColorBufferState());
		
        /*
         * Add the exit and full screen switch commands
         */
        InputManager.getInstance().addAction(
                        new KeyActionExit(),
                        new KeyActionSwitchFullScreen());
        
	/*
	 * Apply the rendering node
	 */
	SceneManager.getInstance().attachRootNode(
			new CameraNode("Camera1")
				.addChild(new MyRender("CustomRender")));
		
        /*
         * Render
         */
        rWin.traverseGraph();
        }
	
        class MyRender extends RenderIntegrationNode {
		/**
		 * Constructor
		 * @param nodeName
		 */
		public MyRender(final String nodeName) {
			super(nodeName);
		}

		/* (non-Javadoc)
		 * @see org.jinx.render.RenderIntegrationNode#render(org.jinx.device.VideoDriver)
		 */
		public void render(final VideoDriver driver) {
			GL11.glTranslatef(0.0f, 0.0f, -5.0f);
			GL11.glBegin(GL11.GL_TRIANGLES);
			GL11.glVertex3f(0.0f, 1.0f, 0.0f);
			GL11.glVertex3f(1.0f, -1.0f, 0.0f);
			GL11.glVertex3f(-1.0f, -1.0f, 0.0f);
			GL11.glEnd();
		}

		/* (non-Javadoc)
		 * @see org.jinx.render.RenderObject#update()
		 */
		public void update() {
		}
	}
}