/*

* 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"

struct BindStruct

{

    int x, y, w, h;

    M3Gbool depth;

    M3Gbitmask hintBits;

};

static void IsProperRenderer(TBool* aIsProperRenderer)

{

    EGLContext ctx;

    EGLConfig config;

    EGLSurface surf;

    EGLint attrib[5];

    EGLint numConfigs;

    // 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).

        *aIsProperRenderer = EFalse;

    }

    else

    {

        // Other renderers can use m3g core API m3gSetAlphaWrite without

        // performance drop.

        *aIsProperRenderer = ETrue;

    }

    // destroy the temporary surface & context

    eglMakeCurrent(eglGetDisplay(0), NULL, NULL, NULL);

    eglDestroySurface(eglGetDisplay(0), surf);

    eglDestroyContext(eglGetDisplay(0), ctx);

}

JNIEXPORT

jboolean JNICALL Java_javax_microedition_m3g_Graphics3D__1isProperRenderer

(JNIEnv* aEnv, jclass, jint aHandle)

{

    TBool isProperRenderer;

    M3G_DO_LOCK

    CJavaM3GEventSource* eventSource =

        JavaUnhand<CJavaM3GEventSource>(aHandle);

    eventSource->ExecuteV(&IsProperRenderer, &isProperRenderer);

    M3G_DO_UNLOCK(aEnv)

    jboolean ret = static_cast<jboolean>(isProperRenderer);

    return ret;

}

#ifdef RD_JAVA_NGA_ENABLED

static void bindGraphicsBuffer(M3GRenderContext aCtx,

                               CMIDGraphics *aGraphics,

                               const BindStruct *aR)

{   

    if (m3gSetRenderBuffers(aCtx, aR->depth ? 

        M3G_COLOR_BUFFER_BIT|M3G_DEPTH_BUFFER_BIT : 

        M3G_COLOR_BUFFER_BIT) && m3gSetRenderHints(aCtx, aR->hintBits)) 

    {

        // Try to bind to EGLSurface if possible

        if (aGraphics->IsEglAvailable()) 

        {

            m3gBindEGLSurfaceTarget(aCtx, (M3GEGLSurface)aGraphics->BindEglSurface());

        }

        else

        {

            eglWaitNative(EGL_CORE_NATIVE_ENGINE);  

            m3gBindBitmapTarget(aCtx, (M3GNativeBitmap) aGraphics->Bitmap());

            // 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();

            m3gSetDisplayArea(aCtx, screenRect.Width(), screenRect.Height());

        }            

        m3gSetClipRect(aCtx, aR->x, aR->y, aR->w, aR->h);

        m3gSetViewport(aCtx, aR->x, aR->y, aR->w, aR->h);

    }

}

#else // !RD_JAVA_NGA_ENABLED    

static void bindGraphicsBuffer(M3GRenderContext aCtx,

                               CMIDGraphics *aGraphics,

                               const BindStruct *aR)

{

    CFbsBitmap *bitmap = aGraphics->Bitmap();

    /*

    * 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(aCtx, aR->depth ?

                            M3G_COLOR_BUFFER_BIT|M3G_DEPTH_BUFFER_BIT :

                            M3G_COLOR_BUFFER_BIT) && m3gSetRenderHints(aCtx, aR->hintBits))

    {

        m3gBindBitmapTarget(aCtx, (M3GNativeBitmap) bitmap);

        // Pass the physical screen size to m3gcore

        m3gSetDisplayArea(aCtx, screenRect.Width(), screenRect.Height());

        m3gSetClipRect(aCtx, aR->x, aR->y, aR->w, aR->h);

        m3gSetViewport(aCtx, aR->x, aR->y, aR->w, aR->h);

    }

}

#endif // RD_JAVA_NGA_ENABLED    

JNIEXPORT jboolean JNICALL Java_javax_microedition_m3g_Graphics3D__1bindGraphics

(JNIEnv* aEnv, jclass, jint aEventSourceHandle, jint aCtx,

 jint aGraphicsHandle, 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 Graphics object

    CMIDGraphics *cmidGraphics = MIDUnhandObject<CMIDGraphics>(aGraphicsHandle);

    BindStruct r;

    r.x = aClipX;

    r.y = aClipY;

    r.w = aClipW;

    r.h = aClipH;

    r.hintBits = aHintBits;

    r.depth = aDepth;

    jboolean isImageTarget = cmidGraphics->IsImageTarget();

    M3G_DO_LOCK

    // Call to the server side

    CJavaM3GEventSource* eventSource =

        JavaUnhand<CJavaM3GEventSource>(aEventSourceHandle);

    eventSource->ExecuteV(&bindGraphicsBuffer,

                          ctx, cmidGraphics, (const BindStruct *)&r);

    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)

}

#ifdef RD_JAVA_NGA_ENABLED

static void releaseTarget(M3GRenderContext aCtx, CMIDGraphics *aGraphics)

{

    // No need to wait GL when EGL surface is used

    if (!aGraphics || !aGraphics->IsEglAvailable())

    {

        eglWaitGL();

    }

    m3gReleaseTarget(aCtx);

}

#else

static void releaseTarget(M3GRenderContext aCtx)

{

    eglWaitGL();

    m3gReleaseTarget(aCtx);

}

#endif

static void releaseGraphicsTarget(M3GRenderContext aCtx, CMIDGraphics *aGraphics,

                                  TBool aIsImageTarget, TBool aIsProperRenderer)

{

#ifdef RD_JAVA_NGA_ENABLED

    releaseTarget(aCtx, aGraphics);

#else

    releaseTarget(aCtx);

#endif    

#ifdef RD_JAVA_NGA_ENABLED

    aGraphics->ReleaseEglSurface();

#endif // RD_JAVA_NGA_ENABLED     

    // 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 aEventSourceHandle, jint aHandle,

 jint aGraphicsHandle, jboolean aIsImageTarget, jboolean aIsProperRenderer)

{

    M3G_DO_LOCK

    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 aEventSourceHandle, jint aHContext, jint aHWorld)

{

    M3G_DO_LOCK

    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);

}

JNIEXPORT void JNICALL Java_javax_microedition_m3g_Graphics3D__1render

(JNIEnv* aEnv, jclass, jint aEventSourceHandle, 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

    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);

}

JNIEXPORT void JNICALL Java_javax_microedition_m3g_Graphics3D__1clear

(JNIEnv* aEnv, jclass, jint aEventSourceHandle, jint aCtx, jint aBg)

{

    M3G_DO_LOCK

    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 aEventSourceHandle, jint aHCtx)

{

    M3G_DO_LOCK

    CJavaM3GEventSource* eventSource = JavaUnhand<CJavaM3GEventSource>(aEventSourceHandle);

#ifdef RD_JAVA_NGA_ENABLED

    eventSource->ExecuteV(&releaseTarget, (M3GRenderContext)aHCtx, (CMIDGraphics*)NULL);

#else    

    eventSource->ExecuteV(&releaseTarget, (M3GRenderContext)aHCtx);

#endif    

    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 aEventSourceHandle, jint aHCtx, jint aImageHandle, jboolean aDepth, jint aHintBits)

{

    M3G_DO_LOCK

    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 aEventSourceHandle, jint aHCtx, jint aHNode, jbyteArray aTransform)

{

    M3GMatrix *transform = NULL;

    if (aTransform)

    {

        transform = (M3GMatrix *)(aEnv->GetByteArrayElements(aTransform, NULL));