/*

* Copyright (c) 2003 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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: Rendering context function implementations

*

*/

/*!

 * \internal

 * \file

 * \brief Rendering context function implementations

 */

#ifndef M3G_CORE_INCLUDE

#   error included by m3g_core.c; do not compile separately.

#endif

#include "m3g_rendercontext.h"

#include "m3g_object.h"

#include "m3g_gl.h"

#include "m3g_memory.h"

#include "m3g_appearance.h"

#include "m3g_indexbuffer.h"

#include "m3g_lightmanager.h"

#include "m3g_vertexbuffer.h"

#include "m3g_world.h"

/*----------------------------------------------------------------------

 * Private data types

 *--------------------------------------------------------------------*/

#if defined(M3G_NGL_CONTEXT_API)

/*!

 * \internal

 * \brief Depth buffer data

 */

typedef struct

{

    M3GMemObject handle;

    M3Gsizei size;

} DepthBuffer;

#endif /*M3G_NGL_CONTEXT_API*/

#if !defined(M3G_NGL_CONTEXT_API)

/*! \internal \brief OpenGL rendering context record */

typedef struct {

    EGLContext handle;

    M3GPixelFormat format;

    M3Gbitmask bufferBits;

    M3Gbitmask surfaceTypeBits;

    M3Gbitmask modeBits;

    M3Guint lastUseTime;

} GLContextRecord;

/*! \internal \brief OpenGL surface record */

typedef struct {

    EGLSurface handle;

    M3Gbitmask bufferBits;

    M3Gbitmask type;

    M3Guint width;

    M3Guint height;

    M3Guint format;

    M3Guint targetHandle;

    void* pixels;

    M3Guint lastUseTime;

} GLSurfaceRecord;

#endif /*!M3G_NGL_CONTEXT_API*/

/*!

 * \internal \brief Rendering target data

 */

typedef struct 

{

    M3Gbitmask type;

    M3GPixelFormat format;

    M3Gint width, height;

    M3Guint stride;

    /*@shared@*/ void *pixels, *lockedPixels;

    EGLSurface surface;

    M3Guint handle;

    M3Guint userData;

    /*!

     * \internal

     * \brief Flag set to indicate back buffer rendering

     *

     * The final target is only written to, via a format

     * conversion, when releasing the target.

     */

    M3Gbool buffered;

} RenderTarget;

/*!

 * \internal

 * \brief Back color buffer data

 */

typedef struct {

#   if defined(M3G_NGL_CONTEXT_API)

    M3GMemObject handle;

    M3Gsizei size;

#   else

    M3Gint width, height;

    EGLSurface glSurface;

#   endif /* M3G_NGL_CONTEXT_API */

    M3Gbool contentsValid;

} BackBuffer;

/*!

 * \internal

 * \brief Rendering context data structure

 *

 * This includes data related to a specific rendering context,

 * including e.g.  viewport settings, and active lights and

 * camera. This is equivalent to the Graphics3D class in the Java API.

 */

struct M3GRenderContextImpl

{

    Object object;

    RenderTarget target;

    BackBuffer backBuffer;

#   if defined(M3G_NGL_CONTEXT_API)

    DepthBuffer depthBuffer;

#   endif

#   if !defined(M3G_NGL_CONTEXT_API)

    /* OpenGL context and surface caches */

    GLContextRecord glContext[M3G_MAX_GL_CONTEXTS];

    GLSurfaceRecord glSurface[M3G_MAX_GL_SURFACES];

    M3Guint cacheTimeStamp;

#   endif /* M3G_NGL_CONTEXT_API */

    /*! \internal \brief Current/last rendering mode */

    M3Genum renderMode;

    /*! \internal \brief OpenGL viewing transformation */

    GLfloat viewTransform[16];

    /*! \internal \brief Current camera */

    const Camera *camera;

    /*! \internal \brief Light manager component */

    LightManager lightManager;

    /*! \internal \brief Last used scope, to speed up light selection */

    M3Gint lastScope;

	M3Gfloat depthNear;

	M3Gfloat depthFar;

    /*! \internal \brief Clipping rectangle parameters */

    struct { M3Gint x0, y0, x1, y1; } clip;

    /*! \internal \brief Scissor and viewport rectangles */

    struct { GLint x, y, width, height; } scissor, viewport;

    /*! \internal \brief Physical display size */

    struct { M3Gint width, height; } display;

    M3Gbitmask bufferBits;      /*!< \brief Rendering buffer bits */

    M3Gbitmask modeBits;        /*!< \brief Rendering mode bits */

    /*! \internal \brief OpenGL subsystem initialization flag */

    M3Gbool glInitialized;

    /*! \internal \brief HW acceleration status flag */

    M3Gbool accelerated;

    /*! \internal \brief Render queue for this context */

	RenderQueue *renderQueue;

    M3Gbool currentColorWrite;

    M3Gbool currentAlphaWrite;

    M3Gbool inSplitDraw;

    M3Gbool alphaWrite;

};

/*

 * Rendering target types; note that the values here MUST match the

 * respective EGL bit values

 */

enum SurfaceType {

    SURFACE_NONE = 0,

    SURFACE_IMAGE = 0x01,       /* EGL_PBUFFER_BIT */

    SURFACE_BITMAP = 0x02,      /* EGL_PIXMAP_BIT */

    SURFACE_WINDOW = 0x04,      /* EGL_WINDOW_BIT */

    SURFACE_MEMORY = SURFACE_IMAGE | SURFACE_BITMAP | SURFACE_WINDOW,

    SURFACE_EGL = 0x80

};

enum RenderMode {

    RENDER_IMMEDIATE,

    RENDER_NODES,

    RENDER_WORLD

};

/*----------------------------------------------------------------------

 * Platform specific code

 *--------------------------------------------------------------------*/

static M3Gbool m3gBindRenderTarget(RenderContext *ctx,

                                   M3Genum targetType,

                                   M3Gint width, M3Gint height,

                                   M3GPixelFormat format,

                                   M3Guint handle);

static void m3gResetRectangles(RenderContext *ctx);

static void m3gSetGLDefaults(void);

static void m3gUpdateScissor(RenderContext *ctx);

static void m3gValidateBuffers(RenderContext *ctx);

static M3Gbool m3gValidTargetFormat(M3GPixelFormat format);

#include "m3g_rendercontext.inl"

/*----------------------------------------------------------------------

 * Internal functions

 *--------------------------------------------------------------------*/

/*!

 * \internal

 * \brief Rendering context destructor

 *

 */

static void m3gDestroyContext(/*@only@*/ Object *obj)

{

    RenderContext *ctx = (RenderContext *) obj;

    M3G_VALIDATE_OBJECT(ctx);

    M3G_ASSIGN_REF(ctx->camera, NULL);

#   if defined(M3G_NGL_CONTEXT_API)

    if (ctx->target.type == SURFACE_MEMORY && ctx->target.pixels == NULL) {

        m3gSignalTargetRelease(M3G_INTERFACE(ctx), ctx->target.handle);

    }

    m3gFreeObject(M3G_INTERFACE(ctx), ctx->depthBuffer.handle);

    m3gFreeObject(M3G_INTERFACE(ctx), ctx->backBuffer.handle);

#   else /* !M3G_NGL_CONTEXT_API */

    {

        int i;

        for (i = 0; i < M3G_MAX_GL_CONTEXTS; ++i) {

            if (ctx->glContext[i].handle != 0) {

                m3gDeleteGLContext(ctx->glContext[i].handle);

            }

        }

        for (i = 0; i < M3G_MAX_GL_SURFACES; ++i) {

            if (ctx->glSurface[i].handle != 0) {

                m3gDeleteGLSurface(ctx->glSurface[i].handle);

            }

        }

    }

#   endif /* M3G_NGL_CONTEXT_API */

    if (ctx->glInitialized) {

        m3gShutdownGL(M3G_INTERFACE(ctx));

    }

    m3gDestroyLightManager(&ctx->lightManager, M3G_INTERFACE(ctx));

    m3gDestroyRenderQueue(M3G_INTERFACE(ctx), ctx->renderQueue);

    m3gDestroyObject(obj);

}

/*!

 * \internal

 * \brief Resets the clipping and viewport rectangles to defaults

 *

 * This is called after binding a new target.

 */

static void m3gResetRectangles(RenderContext *ctx)

{

    int w = ctx->display.width;

    int h = ctx->display.height;

    ctx->clip.x0 = 0;

    ctx->clip.y0 = ctx->target.height - ctx->display.height;

    ctx->clip.x1 = w;

    ctx->clip.y1 = ctx->clip.y0 + h;

    ctx->viewport.x = 0;

    ctx->viewport.y = 0;

    ctx->viewport.width = M3G_MIN(w, M3G_MAX_VIEWPORT_DIMENSION);

    ctx->viewport.height = M3G_MIN(h, M3G_MAX_VIEWPORT_DIMENSION);

}

/*!

 * \internal

 * \brief Constrains the clip rectangle to the rendering target.

 */

static void m3gValidateClipRect(RenderContext *ctx)

{

    int xMin = 0;

    int xMax = ctx->display.width;

    int yMin = ctx->target.height - ctx->display.height;

    int yMax = yMin + ctx->display.height;

    ctx->clip.x0 = m3gClampInt(ctx->clip.x0, xMin, xMax);

    ctx->clip.y0 = m3gClampInt(ctx->clip.y0, yMin, yMax);

    ctx->clip.x1 = m3gClampInt(ctx->clip.x1, xMin, xMax);

    ctx->clip.y1 = m3gClampInt(ctx->clip.y1, yMin, yMax);

}

/*!

 * \internal

 * \brief Computes the GL scissor rectangle

 *

 * The scissor rectangle is the intersection of the viewport and the

 * clipping rectangle.

 */

static void m3gUpdateScissor(RenderContext *ctx)

{

    int sx0 = ctx->viewport.x;

    int sy0 = ctx->viewport.y;

    int sx1 = sx0 + ctx->viewport.width;

    int sy1 = sy0 + ctx->viewport.height;

    sx0 = M3G_MAX(sx0, ctx->clip.x0);

    sy0 = M3G_MAX(sy0, ctx->clip.y0);

    sx1 = M3G_MIN(sx1, ctx->clip.x1);

    sy1 = M3G_MIN(sy1, ctx->clip.y1);

    ctx->scissor.x = sx0;

    ctx->scissor.y = sy0;

    if (sx0 < sx1 && sy0 < sy1) {

        ctx->scissor.width = sx1 - sx0;

        ctx->scissor.height = sy1 - sy0;

    }

    else {

        ctx->scissor.width = ctx->scissor.height = 0;

    }

}

/*!

 * \internal

 * \brief Checks whether we can render in a given format

 */

static M3Gbool m3gValidTargetFormat(M3GPixelFormat format)

{

    return m3gInRange(format, M3G_RGB8, M3G_RGBA4);

}

/*!

 * \internal

 * \brief Checks whether a given format has alpha

 */

static M3Gbool m3gFormatHasAlpha(M3GPixelFormat format)

{

    switch (format) {

    case M3G_A8:

    case M3G_LA8:

    case M3G_LA4:

    case M3G_RGBA8:

    case M3G_BGRA8:

    case M3G_RGBA4:

    case M3G_RGB5A1:

    case M3G_PALETTE8_RGBA8:

        return M3G_TRUE;

    default:

        return M3G_FALSE;

    }

}

/*!

 * \internal

 * \brief Sets the global alpha write enable flag. 

 *

 *	Used for disabling the alpha channel writes when the rendering 

 *  target is a Java MIDP Image that has an alpha channel.

 *

 * \param ctx        the rendering context

 * \param enable     alpha write enable flag

 */

M3G_API void m3gSetAlphaWrite(M3GRenderContext ctx, M3Gbool enable)

{

	ctx->alphaWrite = enable;

}

/*!

 * \internal

 * \brief Reads the global alpha write enable flag. 

 *

 * \param ctx        the rendering context

 */

M3G_API M3Gbool m3gGetAlphaWrite(M3GRenderContext ctx)

{

	return ctx->alphaWrite;

}

/*!

 * \brief Frees all GLES resources allocated by the M3G API 

 *        (EGL surfaces, contexts and texture objects). 

 *

 * \note M3G must not be bound to any target when calling this.

 *

 */

M3G_API void m3gFreeGLESResources(M3GRenderContext ctx)

{

#ifdef M3G_ENABLE_GLES_RESOURCE_HANDLING

    PointerArray image2DObjects;

    M3Gint i;

    /* M3G must not be bound to a rendering target at this point. */

    if (ctx->target.type != SURFACE_NONE) {

        m3gRaiseError(M3G_INTERFACE(ctx), M3G_INVALID_OPERATION);

    }

    /* EGL might not be initialized yet, so do it here just in case. */ 

    eglInitialize(eglGetDisplay(EGL_DEFAULT_DISPLAY), NULL, NULL);

    eglMakeCurrent(eglGetDisplay(EGL_DEFAULT_DISPLAY), NULL, NULL, NULL);

    /* Delete EGL surfaces */

    for (i = 0; i < M3G_MAX_GL_SURFACES; ++i) {

        GLSurfaceRecord *surf = &ctx->glSurface[i];

        if (surf->handle) {

            m3gDeleteGLSurface(surf->handle);

        }

        m3gZero(surf, sizeof(GLSurfaceRecord));

    }

    if (ctx->backBuffer.glSurface != NULL) {

        m3gDeleteGLSurface(ctx->backBuffer.glSurface);

        m3gZero(&ctx->backBuffer, sizeof(BackBuffer));

    }

    /* Delete EGL contexts */

    for (i = 0; i < M3G_MAX_GL_CONTEXTS; ++i) {

        GLContextRecord *context = &ctx->glContext[i];

        if (context->handle) {

            m3gDeleteGLContext(context->handle);

        }

        m3gZero(context, sizeof(GLContextRecord));

    }

    /* Delete references to GLES texture objects from all live Image2D objects. 

       Texture objects themselves have already been destroyed with the last GL context. */

    m3gInitArray(&image2DObjects);

    m3gGetObjectsWithClassID(M3G_INTERFACE(ctx), M3G_CLASS_IMAGE, &image2DObjects);

    i = m3gArraySize(&image2DObjects);

    while (i > 0) {

        Image *image = (Image*)m3gGetArrayElement(&image2DObjects, --i);

        m3gInvalidateImage(image);

        image->texObject = 0;

    }

    m3gDestroyArray(&image2DObjects, M3G_INTERFACE(ctx));

#endif

}

/*!

 * \internal

 * \brief Sets up a new rendering target

 *

 * \param ctx        the rendering context

 * \param targetType rendering target type

 * \param width      width of the target

 * \param height     height of the target

 * \param format     target pixel format

 * \param handle     user object handle

 */

static M3Gbool m3gBindRenderTarget(RenderContext *ctx,

                                   M3Genum targetType,

                                   M3Gint width, M3Gint height,

                                   M3GPixelFormat format,

                                   M3Guint handle)

{

    /* Check for generic errors */

    if (ctx->target.type != SURFACE_NONE) {

        m3gRaiseError(M3G_INTERFACE(ctx), M3G_INVALID_OPERATION);

        return M3G_FALSE;

    }

    if (!m3gValidTargetFormat(format)) {

        m3gRaiseError(M3G_INTERFACE(ctx), M3G_INVALID_ENUM);

        return M3G_FALSE;

    }

    /* If target width or height exceeds maximum viewport width or height

       an exception is thrown. */

    if (width > M3G_MAX_VIEWPORT_WIDTH ||

        height > M3G_MAX_VIEWPORT_HEIGHT) {

        m3gRaiseError(M3G_INTERFACE(ctx), M3G_INVALID_ENUM);

        return M3G_FALSE;

    }

    /* Everything checks out; set up the target parameters */

    ctx->target.type = targetType;

    ctx->target.width = width;

    ctx->target.height = height;

    ctx->display.width = width;

    ctx->display.height = height;

    ctx->target.format = format;

    ctx->target.handle = handle;

    m3gResetRectangles(ctx);

    m3gUpdateScissor(ctx);

    m3gValidateBuffers(ctx);

    /* Invalidate lights in case we're using a different OpenGL

     * rendering context this time around */

    ctx->lastScope = 0;