/*

* 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 targetHandle;

    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;

}

/*!

 * \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;

    return M3G_TRUE;

}

/*!

 * \internal

 * \brief Initializes the current GL context to default settings.

 */

static void m3gSetGLDefaults(void)

{

	static const GLfloat black[] = {0.f, 0.f, 0.f, 0.f};

    glEnable(GL_NORMALIZE);

    glEnable(GL_SCISSOR_TEST);

	glLightModelfv(GL_LIGHT_MODEL_AMBIENT, black);

    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

}

/*!

 * \internal

 * \brief Validates the buffers required for a rendering context

 *

 * Allocates or reallocates buffers as necessary, according to the

 * currently set flags of the context.

 */

static void m3gValidateBuffers(RenderContext *ctx)

{

    M3G_VALIDATE_OBJECT(ctx);

    /* Initialize OpenGL if not already done */

    if (!ctx->glInitialized) {

        m3gInitializeGL(M3G_INTERFACE(ctx));

        ctx->glInitialized = M3G_TRUE;

    }

    /* Check whether we can render directly to the target or need to

     * use a back buffer */

    ctx->target.buffered = !m3gCanDirectRender(ctx);

#   if defined(M3G_FORCE_BUFFERED_RENDERING)

    ctx->target.buffered = M3G_TRUE;

#   endif

    /* If direct rendering wasn't possible, check that the back buffer

     * for buffered rendering exists. */

    if (ctx->target.buffered) {

        if (!m3gValidateBackBuffer(ctx)) {

            return; /* out of memory */

        }

    }

    /* With the legacy NGL API, we also manage the depth buffer */

#   if defined(M3G_NGL_CONTEXT_API)

    if (!m3gValidateDepthBuffer(ctx)) {

        return; /* out of memory */

    }

#   endif

    /* Delay blitting from the front buffer until we know it's

     * necessary; let's raise a flag to check that later on */

    if (ctx->target.buffered) {

        if (ctx->modeBits & M3G_OVERWRITE_BIT) {

            ctx->backBuffer.contentsValid = M3G_TRUE;

        }