diff -r f5050f1da672 -r 04becd199f91 javauis/m3g_qt/src/jni/graphics3d.inl
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/javauis/m3g_qt/src/jni/graphics3d.inl	Tue Apr 27 16:30:29 2010 +0300
@@ -0,0 +1,725 @@
+/*
+* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:
+*
+*/
+#include "javax_microedition_m3g_Graphics3D.h"
+
+/*
+ * Must be executed in UI thread
+ */
+JNIEXPORT jboolean JNICALL Java_javax_microedition_m3g_Graphics3D__1isProperRenderer
+(JNIEnv* aEnv, jclass)
+{
+    EGLContext ctx;
+    EGLConfig config;
+    EGLSurface surf;
+    EGLint attrib[5];
+    EGLint numConfigs;
+    bool isProperRenderer;
+
+    // initialize EGL and create a temporary surface & context for reading
+    // the renderer string
+    eglInitialize(eglGetDisplay(EGL_DEFAULT_DISPLAY), NULL, NULL);
+
+    attrib[0] = EGL_SURFACE_TYPE;
+    attrib[1] = EGL_PBUFFER_BIT;
+    attrib[2] = EGL_NONE;
+
+    eglChooseConfig(eglGetDisplay(0), attrib, &config, 1, &numConfigs);
+
+    ctx = eglCreateContext(eglGetDisplay(0), config, NULL, NULL);
+
+    attrib[0] = EGL_WIDTH;
+    attrib[1] = 2;
+    attrib[2] = EGL_HEIGHT;
+    attrib[3] = 2;
+    attrib[4] = EGL_NONE;
+
+    surf = eglCreatePbufferSurface(eglGetDisplay(0), config, attrib);
+    eglMakeCurrent(eglGetDisplay(0), surf, surf, ctx);
+
+    // We check if proper renderer is used and return value which is stored
+    // on java side and passed to fuctions where is decided if m3g renders
+    // into mutable off-screen image or into framebuffer (see
+    // Java_javax_microedition_m3g_Graphics3D__1bindGraphics and
+    // releaseGraphicsTarget).
+    const GLubyte *info;
+    info = glGetString(GL_RENDERER);   // get the renderer string
+
+    // check if "MBX" substring is found
+    if (strstr((const char *)info, "MBX"))
+    {
+        // HW renderer detected.
+        // If "MBX" HW is detected we must reset alpha for mutable off-screen
+        // images by hand (see releaseGraphicsTarget).
+        isProperRenderer = false;
+    }
+    else
+    {
+        // Other renderers can use m3g core API m3gSetAlphaWrite without
+        // performance drop.
+        isProperRenderer = true;
+    }
+
+    // destroy the temporary surface & context
+    eglMakeCurrent(eglGetDisplay(0), NULL, NULL, NULL);
+    eglDestroySurface(eglGetDisplay(0), surf);
+    eglDestroyContext(eglGetDisplay(0), ctx);
+
+    return isProperRenderer;
+}
+
+/*
+ * Must be executed in UI thread
+ */
+JNIEXPORT jboolean JNICALL Java_javax_microedition_m3g_Graphics3D__1bindGraphics
+(JNIEnv* aEnv, jclass, jint aCtx,
+ jint aSurfaceHandle, jint aClipX, jint aClipY, jint aClipW, jint aClipH,
+ jboolean aDepth, jint aHintBits, jboolean aIsProperRenderer)
+{
+    M3GRenderContext ctx = (M3GRenderContext)aCtx;
+
+    // Fetch the native peer of our target object
+    Java::GFX::WindowSurface* wsurf = reinterpret_cast<Java::GFX::WindowSurface*>(aSurfaceHandle);
+
+    int caps = Java::GFX::SwImage | Java::GFX::PBuffer;
+    QPaintDevice* surface = wsurf->bind(caps);
+
+    jboolean isImageTarget = false; /*cmidGraphics->IsImageTarget();*/
+
+    M3G_DO_LOCK
+
+    /*
+    * Get the physical screen size and pass it to m3gcore. This affects (improves) the performance
+    * as the canvas frambuffer (rendering target) is larger than the physical screen size in
+    * devices that have more than one screen orientation, causing extra copying operations.
+    *
+    * This will improve m3g performance and suppresses extra bitmap copying.
+    */
+
+    //TRect screenRect = CCoeEnv::Static()->ScreenDevice()->SizeInPixels();
+
+    eglWaitNative(EGL_CORE_NATIVE_ENGINE);
+
+    if (m3gSetRenderBuffers((M3GRenderContext)aCtx, aDepth ?
+                            M3G_COLOR_BUFFER_BIT|M3G_DEPTH_BUFFER_BIT :
+                            M3G_COLOR_BUFFER_BIT) && m3gSetRenderHints((M3GRenderContext)aCtx, aHintBits))
+    {
+
+        switch (wsurf->getType())
+        {
+        case Java::GFX::SwImage:
+        {
+            QImage* bitmap = static_cast<QImage*>(surface);
+            M3GPixelFormat format  = mapQtPixelformat(bitmap->format());
+            m3gBindMemoryTarget((M3GRenderContext)aCtx, bitmap->bits(), (M3Guint)bitmap->width(), (M3Guint)bitmap->height(), format, (M3Guint)(bitmap->width() * 4), NULL);
+            break;
+        }
+        default:
+            M3G_RAISE_EXCEPTION(aEnv, "java/lang/IllegalArgumentException");
+            break;
+        }
+
+        // Pass the physical screen size to m3gcore
+        //m3gSetDisplayArea(aCtx, screenRect.Width(), screenRect.Height());
+
+        m3gSetClipRect((M3GRenderContext)aCtx, aClipX, aClipY, aClipW, aClipH);
+        m3gSetViewport((M3GRenderContext)aCtx, aClipX, aClipY, aClipW, aClipH);
+    }
+
+    M3G_DO_UNLOCK(aEnv)
+
+    if (isImageTarget && aIsProperRenderer)
+    {
+        m3gSetAlphaWrite(ctx, M3G_FALSE);
+    }
+
+    return isImageTarget;
+}
+
+JNIEXPORT void JNICALL Java_javax_microedition_m3g_Graphics3D__1setViewport
+(JNIEnv* aEnv, jclass, jint aHContext, jint aX, jint aY,
+ jint aWidth, jint aHeight)
+{
+    M3G_DO_LOCK
+    m3gSetViewport((M3GRenderContext)aHContext, aX, aY, aWidth, aHeight);
+    M3G_DO_UNLOCK(aEnv)
+}
+
+
+static void releaseTarget(M3GRenderContext aCtx)
+{
+    eglWaitGL();
+    m3gReleaseTarget(aCtx);
+}
+
+
+/*
+static void releaseGraphicsTarget(M3GRenderContext aCtx, CMIDGraphics *aGraphics,
+    TBool aIsImageTarget, TBool aIsProperRenderer )
+    {
+    releaseTarget(aCtx);
+
+    // clear alpha for only mutable off-screen images (not for canvas/GameCanvas
+    // framebuffer) those images are indetified by aIsImageTarget argument
+    if (aIsImageTarget)
+        {
+        if ( aIsProperRenderer )
+            {
+            m3gSetAlphaWrite(aCtx, M3G_TRUE);
+            }
+        else
+            {
+            CFbsBitmap *bitmap = aGraphics->Bitmap();
+
+            const TInt width = bitmap->SizeInPixels().iWidth;
+            const TInt height = bitmap->SizeInPixels().iHeight;
+            TInt stride = bitmap->ScanLineLength(width, bitmap->DisplayMode());
+
+            bitmap->LockHeap();
+
+            for (TInt i = 0; i < height; i++)
+                {
+                const void *srcAddr =
+                    ((const char *) bitmap->DataAddress()) + i * stride;
+                unsigned char *src = (unsigned char *) srcAddr;
+                TInt count = width;
+                while (count--)
+                    {
+                    src += 3; //jump to last byte - alpha channel
+                    //setting FF to alpha channel for non-canvas image targets
+                    *src |= 0xff;
+                    src++;
+                    }
+                }
+
+            bitmap->UnlockHeap();
+            }
+        }
+    }
+*/
+JNIEXPORT void JNICALL Java_javax_microedition_m3g_Graphics3D__1releaseGraphics
+(JNIEnv* aEnv, jclass, jint aHandle,
+ jint aSurfaceHandle, jboolean aIsImageTarget, jboolean aIsProperRenderer)
+{
+    M3G_DO_LOCK
+
+    releaseTarget((M3GRenderContext)aHandle);
+
+    // Release used target surface
+    Java::GFX::WindowSurface* surf = reinterpret_cast<Java::GFX::WindowSurface*>(aSurfaceHandle);
+    surf->release();
+
+    /*
+    CMIDGraphics *cmidGraphics = MIDUnhandObject<CMIDGraphics>(aGraphicsHandle);
+
+    CJavaM3GEventSource* eventSource =
+        JavaUnhand<CJavaM3GEventSource>(aEventSourceHandle);
+    eventSource->ExecuteV(&releaseGraphicsTarget, ((M3GRenderContext) aHandle),
+        cmidGraphics, ((TBool) aIsImageTarget), ((TBool) aIsProperRenderer) );
+        */
+    M3G_DO_UNLOCK(aEnv)
+}
+
+JNIEXPORT void JNICALL Java_javax_microedition_m3g_Graphics3D__1setCamera
+(JNIEnv* aEnv, jclass, jint aHContext, jint aHCamera, jbyteArray aTransform)
+{
+    M3GMatrix *transform = NULL;
+    if (aTransform)
+    {
+        transform = (Matrix *)(aEnv->GetByteArrayElements(aTransform, NULL));
+        if (transform == NULL)
+        {
+            M3G_RAISE_EXCEPTION(aEnv, "java/lang/OutOfMemoryError");
+            return;
+        }
+    }
+
+    M3G_DO_LOCK
+    m3gSetCamera((M3GRenderContext) aHContext, (M3GCamera) aHCamera, transform);
+    M3G_DO_UNLOCK(aEnv)
+
+    if (transform)
+    {
+        aEnv->ReleaseByteArrayElements(aTransform, (jbyte*)transform, JNI_ABORT);
+    }
+}
+
+/*
+static void renderWorld(M3GRenderContext aHContext,
+                        M3GWorld aHWorld)
+{
+    m3gRenderWorld(aHContext, aHWorld);
+}
+*/
+
+JNIEXPORT void JNICALL Java_javax_microedition_m3g_Graphics3D__1renderWorld
+(JNIEnv* aEnv, jclass, jint aHContext, jint aHWorld)
+{
+    M3G_DO_LOCK
+
+    m3gRenderWorld((M3GRenderContext) aHContext, (M3GWorld) aHWorld);
+
+    /*
+    CJavaM3GEventSource* eventSource = JavaUnhand<CJavaM3GEventSource>(aEventSourceHandle);
+    eventSource->ExecuteV(&renderWorld,
+                       (M3GRenderContext) aHContext,
+                       (M3GWorld) aHWorld);
+    */
+    M3G_DO_UNLOCK(aEnv)
+}
+
+JNIEXPORT jint JNICALL Java_javax_microedition_m3g_Graphics3D__1ctor
+(JNIEnv* aEnv, jclass, jint aM3g)
+{
+    M3G_DO_LOCK
+    M3GRenderContext ctx = m3gCreateContext((M3GInterface)aM3g);
+    M3G_DO_UNLOCK(aEnv)
+
+    return (jint)ctx;
+}
+
+struct RenderStruct
+{
+    M3GVertexBuffer hVertices;
+    M3GIndexBuffer hIndices;
+    M3GAppearance hAppearance;
+    const M3GMatrix *transform;
+};
+
+/*
+static void renderImmediate(M3GRenderContext aHContext, RenderStruct *aR, jint aScope)
+{
+    m3gRender(aHContext,
+              aR->hVertices,
+              aR->hIndices,
+              aR->hAppearance,
+              aR->transform, 1.0f, aScope);
+}
+*/
+
+/*
+ * Must be executed in UI thread
+ */
+
+JNIEXPORT void JNICALL Java_javax_microedition_m3g_Graphics3D__1render
+(JNIEnv* aEnv, jclass, jint aHContext,
+ jint aHVertices, jint aHIndices, jint aHAppearance, jbyteArray aTransform, jint aScope)
+{
+    M3GMatrix *transform = NULL;
+    if (aTransform)
+    {
+        transform = (M3GMatrix *)aEnv->GetByteArrayElements(aTransform, NULL);
+        if (transform == NULL)
+        {
+            M3G_RAISE_EXCEPTION(aEnv, "java/lang/OutOfMemoryError");
+            return;
+        }
+    }
+
+    /*
+    RenderStruct r;
+    r.hVertices = (M3GVertexBuffer) aHVertices;
+    r.hIndices = (M3GIndexBuffer) aHIndices;
+    r.hAppearance = (M3GAppearance) aHAppearance;
+    r.transform = transform;
+    */
+
+
+    M3G_DO_LOCK
+
+    m3gRender((M3GRenderContext) aHContext, (M3GVertexBuffer) aHVertices, (M3GIndexBuffer) aHIndices, (M3GAppearance) aHAppearance,
+              transform, 1.0f, aScope);
+
+    /*
+      CJavaM3GEventSource* eventSource = JavaUnhand<CJavaM3GEventSource>(aEventSourceHandle);
+    eventSource->ExecuteV(&renderImmediate, ((M3GRenderContext) aHContext), &r, aScope);
+    */
+    M3G_DO_UNLOCK(aEnv)
+
+
+    if (transform)
+    {
+        aEnv->ReleaseByteArrayElements(aTransform, (jbyte*)transform, JNI_ABORT);
+    }
+}
+
+/*
+static void clear(M3GRenderContext aHContext, M3GBackground aHBackground)
+{
+    m3gClear(aHContext, aHBackground);
+}
+*/
+
+/*
+ * Must be executed in UI thread
+ */
+JNIEXPORT void JNICALL Java_javax_microedition_m3g_Graphics3D__1clear
+(JNIEnv* aEnv, jclass, jint aCtx, jint aBg)
+{
+    M3G_DO_LOCK
+    m3gClear((M3GRenderContext)aCtx, (M3GBackground)aBg);
+
+    /*
+    CJavaM3GEventSource* eventSource = JavaUnhand<CJavaM3GEventSource>(aEventSourceHandle);
+    eventSource->ExecuteV(&clear, (M3GRenderContext)aCtx, (M3GBackground)aBg);
+    */
+    M3G_DO_UNLOCK(aEnv)
+}
+
+JNIEXPORT void JNICALL Java_javax_microedition_m3g_Graphics3D__1releaseImage
+(JNIEnv* aEnv, jclass, jint aHCtx)
+{
+    M3G_DO_LOCK
+
+    releaseTarget((M3GRenderContext)aHCtx);
+
+    /*
+    CJavaM3GEventSource* eventSource = JavaUnhand<CJavaM3GEventSource>(aEventSourceHandle);
+    eventSource->ExecuteV(&releaseTarget, (M3GRenderContext)aHCtx);
+    */
+    M3G_DO_UNLOCK(aEnv)
+}
+
+JNIEXPORT void JNICALL Java_javax_microedition_m3g_Graphics3D__1addRef
+(JNIEnv* aEnv, jclass, jint aObject)
+{
+    M3G_DO_LOCK
+    m3gAddRef((M3GObject) aObject);
+    M3G_DO_UNLOCK(aEnv)
+}
+
+JNIEXPORT jint JNICALL Java_javax_microedition_m3g_Graphics3D__1addLight
+(JNIEnv* aEnv, jclass, jint aHContext, jint aHLight, jbyteArray aTransform)
+{
+    M3GMatrix *transform = NULL;
+    if (aTransform)
+    {
+        transform = (M3GMatrix *)(aEnv->GetByteArrayElements(aTransform, NULL));
+        if (transform == NULL)
+        {
+            M3G_RAISE_EXCEPTION(aEnv, "java/lang/OutOfMemoryError");
+            return 0;
+        }
+    }
+    M3G_DO_LOCK
+    int idx = m3gAddLight((M3GRenderContext) aHContext, (M3GLight) aHLight, transform);
+    M3G_DO_UNLOCK(aEnv)
+
+    if (transform)
+    {
+        aEnv->ReleaseByteArrayElements(aTransform, (jbyte*)transform, JNI_ABORT);
+    }
+
+    return idx;
+}
+
+/*
+static void bindImage(M3GRenderContext hCtx, M3GImage hImg, M3Gbool depth, M3Gbitmask hintBits)
+{
+    if (m3gSetRenderBuffers(hCtx, depth ? M3G_COLOR_BUFFER_BIT|M3G_DEPTH_BUFFER_BIT : M3G_COLOR_BUFFER_BIT) && m3gSetRenderHints(hCtx, hintBits)) {
+        m3gBindImageTarget(hCtx, hImg);
+    }
+}
+*/
+
+JNIEXPORT void JNICALL Java_javax_microedition_m3g_Graphics3D__1bindImage
+(JNIEnv* aEnv, jclass, jint aHCtx, jint aImageHandle, jboolean aDepth, jint aHintBits)
+{
+    M3G_DO_LOCK
+
+    if (m3gSetRenderBuffers((M3GRenderContext)aHCtx, (M3Gbool)aDepth ? M3G_COLOR_BUFFER_BIT|M3G_DEPTH_BUFFER_BIT : M3G_COLOR_BUFFER_BIT) && m3gSetRenderHints((M3GRenderContext)aHCtx, (M3Gbitmask)aHintBits))
+    {
+        m3gBindImageTarget((M3GRenderContext)aHCtx, (M3GImage)aImageHandle);
+    }
+
+    //CJavaM3GEventSource* eventSource = JavaUnhand<CJavaM3GEventSource>(aEventSourceHandle);
+    //eventSource->ExecuteV(&bindImage, (M3GRenderContext)aHCtx, (M3GImage)aImageHandle, (M3Gbool)aDepth, (M3Gbitmask)aHintBits);
+    M3G_DO_UNLOCK(aEnv)
+}
+
+JNIEXPORT void JNICALL Java_javax_microedition_m3g_Graphics3D__1resetLights
+(JNIEnv* aEnv, jclass, jint aHContext)
+{
+    M3G_DO_LOCK
+    m3gClearLights((M3GRenderContext) aHContext);
+    M3G_DO_UNLOCK(aEnv)
+}
+
+JNIEXPORT void JNICALL Java_javax_microedition_m3g_Graphics3D__1setDepthRange
+(JNIEnv* aEnv, jclass, jint aHContext, jfloat aDepthNear, jfloat aDepthFar)
+{
+    M3G_DO_LOCK
+    m3gSetDepthRange((M3GRenderContext) aHContext, aDepthNear, aDepthFar);
+    M3G_DO_UNLOCK(aEnv)
+}
+
+JNIEXPORT void JNICALL Java_javax_microedition_m3g_Graphics3D__1setLight
+(JNIEnv* aEnv, jclass, jint aHContext, jint aLightIndex, jint aHLight, jbyteArray aTransform)
+{
+    M3GMatrix *transform = NULL;
+    if (aTransform)
+    {
+        transform = (M3GMatrix *)(aEnv->GetByteArrayElements(aTransform, NULL));
+        if (transform == NULL)
+        {
+            M3G_RAISE_EXCEPTION(aEnv, "java/lang/OutOfMemoryError");
+            return;
+        }
+    }
+
+    M3G_DO_LOCK
+    m3gSetLight((M3GRenderContext) aHContext, aLightIndex, (M3GLight) aHLight, transform);
+    M3G_DO_UNLOCK(aEnv)
+
+    if (transform)
+    {
+        aEnv->ReleaseByteArrayElements(aTransform, (jbyte*)transform, JNI_ABORT);
+    }
+}
+
+/*
+static void renderNode(M3GRenderContext aHCtx,
+                       M3GNode aHNode,
+                       const M3GMatrix *aMtx)
+{
+    m3gRenderNode(aHCtx, aHNode, aMtx);
+}
+*/
+
+JNIEXPORT void JNICALL Java_javax_microedition_m3g_Graphics3D__1renderNode
+(JNIEnv* aEnv, jclass, jint aHCtx, jint aHNode, jbyteArray aTransform)
+{
+    M3GMatrix *transform = NULL;
+    if (aTransform)
+    {
+        transform = (M3GMatrix *)(aEnv->GetByteArrayElements(aTransform, NULL));
+        if (transform == NULL)
+        {
+            M3G_RAISE_EXCEPTION(aEnv, "java/lang/OutOfMemoryError");
+            return;
+        }
+    }
+
+    M3G_DO_LOCK
+
+    m3gRenderNode((M3GRenderContext)aHCtx, (M3GNode)aHNode, (const M3GMatrix *)transform);
+
+    //CJavaM3GEventSource* eventSource = JavaUnhand<CJavaM3GEventSource>(aEventSourceHandle);
+    //eventSource->ExecuteV(&renderNode, (M3GRenderContext)aHCtx, (M3GNode)aHNode, (const M3GMatrix *)transform);
+    M3G_DO_UNLOCK(aEnv)
+
+    if (aTransform)
+    {
+        aEnv->ReleaseByteArrayElements(aTransform, (jbyte*)transform, JNI_ABORT);
+    }
+}
+
+#if defined(M3G_ENABLE_PROFILING)
+
+JNIEXPORT jint JNICALL Java_javax_microedition_m3g_Graphics3D__1getStatistics
+(JNIEnv* aEnv, jclass, jintArray aStatArray)
+{
+    const M3Gint *statArray = (M3Gint *)(aStatArray != NULL ? aEnv->GetIntArrayElements(aStatArray, NULL) : NULL);
+    jint statArrayLength = aStatArray ? aEnv->GetArrayLength(aStatArray) : 0;
+
+    if (statArray != NULL && statArrayLength >= sizeof(m3gs_statistic))
+    {
+        m3gCopy((void*)statArray, m3gs_statistic, sizeof(m3gs_statistic));
+    }
+
+    M3G_DO_LOCK
+    m3gZero(m3gs_statistic, sizeof(m3gs_statistic));
+    M3G_DO_UNLOCK(aEnv)
+
+    if (statArray)
+    {
+        aEnv->ReleaseIntArrayElements(aStatArray, (jint*)statArray, 0);
+    }
+
+    return sizeof(m3gs_statistic);
+}
+
+#endif /* M3G_ENABLE_PROFILING */
+
+
+
+/* M3G 1.1 JNI Calls */
+
+JNIEXPORT void JNICALL Java_javax_microedition_m3g_Graphics3D__1getViewTransform
+(JNIEnv* aEnv, jclass, jint aHCtx, jbyteArray aTransform)
+{
+    M3GMatrix *transform = NULL;
+    if (aTransform)
+    {
+        transform = (M3GMatrix *)(aEnv->GetByteArrayElements(aTransform, NULL));
+        if (transform == NULL)
+        {
+            M3G_RAISE_EXCEPTION(aEnv, "java/lang/OutOfMemoryError");
+            return;
+        }
+    }
+
+    M3G_DO_LOCK
+    m3gGetViewTransform((M3GRenderContext) aHCtx, transform);
+    M3G_DO_UNLOCK(aEnv)
+
+    if (transform)
+    {
+        /* copy array to Java side and release arrays */
+        aEnv->ReleaseByteArrayElements(aTransform, (jbyte*)transform, 0);
+    }
+}
+
+JNIEXPORT jint JNICALL Java_javax_microedition_m3g_Graphics3D__1getCamera
+(JNIEnv* aEnv, jclass, jint aHCtx)
+{
+    M3G_DO_LOCK
+    jint camera = (jint)m3gGetCamera((M3GRenderContext)aHCtx);
+    M3G_DO_UNLOCK(aEnv)
+
+    return camera;
+}
+
+JNIEXPORT jint JNICALL Java_javax_microedition_m3g_Graphics3D__1getLightTransform
+(JNIEnv* aEnv, jclass, jint aHCtx, jint aLightIndex, jbyteArray aTransform)
+{
+    M3GMatrix *transform = NULL;
+    if (aTransform)
+    {
+        transform = (M3GMatrix *)(aEnv->GetByteArrayElements(aTransform, NULL));
+        if (transform == NULL)
+        {
+            M3G_RAISE_EXCEPTION(aEnv, "java/lang/OutOfMemoryError");
+            return 0;
+        }
+    }
+    M3G_DO_LOCK
+    int lightTransform = (M3Guint)m3gGetLightTransform((M3GRenderContext)aHCtx, aLightIndex, transform);
+    M3G_DO_UNLOCK(aEnv)
+
+    if (transform)
+    {
+        aEnv->ReleaseByteArrayElements(aTransform, (jbyte*)transform, 0);
+    }
+
+    return (jint)lightTransform;
+}
+
+JNIEXPORT jint JNICALL Java_javax_microedition_m3g_Graphics3D__1getLightCount
+(JNIEnv* aEnv, jclass, jint aHCtx)
+{
+    M3G_DO_LOCK
+    jint lightCount = (jint)m3gGetLightCount((M3GRenderContext)aHCtx);
+    M3G_DO_UNLOCK(aEnv)
+
+    return lightCount;
+}
+
+JNIEXPORT jfloat JNICALL Java_javax_microedition_m3g_Graphics3D__1getDepthRangeNear
+(JNIEnv* aEnv, jclass, jint aHCtx)
+{
+    float depthNear = 0;
+    float depthFar = 0;
+
+    M3G_DO_LOCK
+    m3gGetDepthRange((M3GRenderContext) aHCtx, &depthNear, &depthFar);
+    M3G_DO_UNLOCK(aEnv)
+
+    return (jfloat)depthNear;
+}
+
+JNIEXPORT jfloat JNICALL Java_javax_microedition_m3g_Graphics3D__1getDepthRangeFar
+(JNIEnv* aEnv, jclass, jint aHCtx)
+{
+    float depthNear = 0;
+    float depthFar = 0;
+
+    M3G_DO_LOCK
+    m3gGetDepthRange((M3GRenderContext) aHCtx, &depthNear, &depthFar);
+    M3G_DO_UNLOCK(aEnv)
+
+    return (jfloat)depthFar;
+}
+
+JNIEXPORT jint JNICALL Java_javax_microedition_m3g_Graphics3D__1getViewportX
+(JNIEnv* aEnv, jclass, jint aHCtx)
+{
+    int viewport[4];
+
+    M3G_DO_LOCK
+    m3gGetViewport((M3GRenderContext)aHCtx, &viewport[0],
+                   &viewport[1],
+                   &viewport[2],
+                   &viewport[3]);
+    M3G_DO_UNLOCK(aEnv)
+
+    return (jint)viewport[0];
+}
+
+JNIEXPORT jint JNICALL Java_javax_microedition_m3g_Graphics3D__1getViewportY
+(JNIEnv* aEnv, jclass, jint aHCtx)
+{
+    int viewport[4];
+
+    M3G_DO_LOCK
+    m3gGetViewport((M3GRenderContext)aHCtx, &viewport[0],
+                   &viewport[1],
+                   &viewport[2],
+                   &viewport[3]);
+    M3G_DO_UNLOCK(aEnv)
+
+    return (jint)viewport[1];
+}
+
+JNIEXPORT jint JNICALL Java_javax_microedition_m3g_Graphics3D__1getViewportWidth
+(JNIEnv* aEnv, jclass, jint aHCtx)
+{
+    int viewport[4];
+
+    M3G_DO_LOCK
+    m3gGetViewport((M3GRenderContext)aHCtx, &viewport[0],
+                   &viewport[1],
+                   &viewport[2],
+                   &viewport[3]);
+    M3G_DO_UNLOCK(aEnv)
+
+    return (jint)viewport[2];
+}
+
+JNIEXPORT jint JNICALL Java_javax_microedition_m3g_Graphics3D__1getViewportHeight
+(JNIEnv* aEnv, jclass, jint aHCtx)
+{
+    int viewport[4];
+
+    M3G_DO_LOCK
+    m3gGetViewport((M3GRenderContext)aHCtx, &viewport[0],
+                   &viewport[1],
+                   &viewport[2],
+                   &viewport[3]);
+    M3G_DO_UNLOCK(aEnv)
+
+    return (jint)viewport[3];
+}
+
+JNIEXPORT jboolean JNICALL Java_javax_microedition_m3g_Graphics3D__1isAASupported
+(JNIEnv* aEnv, jclass, jint aM3g)
+{
+    M3Gbool aaSupport = M3G_FALSE;
+
+    aaSupport = m3gIsAntialiasingSupported((M3GInterface)aM3g);
+
+    return (jboolean)aaSupport;
+}