/*

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

    eglBindAPI(EGL_OPENGL_ES_API);

    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;

    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;

        }

        else {

            ctx->backBuffer.contentsValid = M3G_FALSE;

        }

    }

}

/*!

 * \internal

 * \brief Makes a GL context current to this thread and the currently

 * set rendering target buffer

 */

static void m3gMakeCurrent(RenderContext *ctx)

{

    m3gMakeGLCurrent(ctx);

    /* Note that the depth buffer may in some cases exist even if not

     * explicitly requested, so we need to disable the depth test just

     * in case */

    if ((ctx->bufferBits & M3G_DEPTH_BUFFER_BIT) == 0) {

        glDisable(GL_DEPTH_TEST);

    }

    else {

        glEnable(GL_DEPTH_TEST);

    }

    /* Enable multisampling if required */

    if (ctx->modeBits & M3G_ANTIALIAS_BIT) {

        glEnable(GL_MULTISAMPLE);

    }

    else {

        glDisable(GL_MULTISAMPLE);

    }

    M3G_ASSERT_GL;

}

/*!

 * \internal

 * \brief Returns the HW acceleration status of the current context

 */

static M3Gbool m3gIsAccelerated(const RenderContext *ctx)

{

    return ctx->accelerated;

}

/*!

 * \internal

 * \brief Sets the currently enabled lights to the GL state

 *

 * \note the correct viewing matrix *must* be set prior to calling

 * this for the lights to be transformed into eye space correctly

 */

static M3G_INLINE void m3gApplyLights(RenderContext *ctx, M3Gint scope)

{

    if (ctx->lastScope != scope) {

        /* If coming from RenderNode, we have the geometry in camera

         * space but the lights in world space, so we need to apply

         * the viewing matrix to the lights only */

        if (ctx->renderMode == RENDER_NODES) {

            glPushMatrix();

            glLoadMatrixf(ctx->viewTransform);

        }

        m3gSelectGLLights(&ctx->lightManager, 8, scope, 0, 0, 0);

        ctx->lastScope = scope;

        if (ctx->renderMode == RENDER_NODES) {

            glPopMatrix();

        }

    }

	M3G_ASSERT_GL;

}

/*!

 * \internal

 * \brief Gets the current camera

 */

static const Camera *m3gGetCurrentCamera(const RenderContext *ctx) {

	return ctx->camera;	

}

/*!

 * \internal

 * \brief Sets up some rendering parameters that

 * do not change during scene renders.

 */

static void m3gInitRender(M3GRenderContext context, M3Genum renderMode)

{

    RenderContext *ctx = (RenderContext *) context;

    M3G_VALIDATE_OBJECT(ctx);

    m3gIncrementRenderTimeStamp(ctx);

    m3gMakeCurrent(ctx);

    m3gCollectGLObjects(M3G_INTERFACE(ctx));

    /* If buffered rendering, blit the image to the back buffer at

     * this point */

    if (ctx->target.buffered && !ctx->backBuffer.contentsValid) {

        m3gUpdateBackBuffer(ctx);

    }

    /* Set up viewport and scissoring */

    glViewport(ctx->viewport.x, ctx->viewport.y,

               ctx->viewport.width, ctx->viewport.height);

	glDepthRangef(ctx->depthNear, ctx->depthFar);

    glScissor(ctx->scissor.x, ctx->scissor.y,

              ctx->scissor.width, ctx->scissor.height);

    M3G_ASSERT_GL;

    /* Set up the projection and viewing transformations (static

     * during rendering) */

	m3gApplyProjection(ctx->camera);

    if (renderMode == RENDER_NODES) {

        glLoadIdentity();

    }

    else {

        glLoadMatrixf(ctx->viewTransform);

    }

    M3G_ASSERT_GL;

    /* Invalidate any already set GL lights if rendering mode changed */

    if (renderMode != ctx->renderMode) {

        ctx->lastScope = 0;

    }

    ctx->renderMode = renderMode;

}

/*!

 * \internal

 * \brief A workaround for a broken implementation of glColorMask

 *

 * Saves the framebuffer in the OpenGL default texture each time the

 * color mask changes, for restoring later.  Not very pretty, but

 * works as long as the default texture is not touched in between --

 * currently, we only touch that when copying to and from the back

 * buffer.

 *

 * \param newColorWrite the color mask state we're about to change to

 * \param newAlphaWrite the alpha write state we're about to change to

 */

static void m3gUpdateColorMaskStatus(RenderContext *ctx,

                                     M3Gbool newColorWrite,

                                     M3Gbool newAlphaWrite)

{

    GLint pow2Width, pow2Height;

	/* Get the global alpha write value */

	newAlphaWrite &= m3gGetAlphaWrite(ctx);

    /* Check that the ColorMask state is actually about to change */

    if (ctx->currentColorWrite == newColorWrite

        && (ctx->currentAlphaWrite == newAlphaWrite || !m3gFormatHasAlpha(ctx->target.format))) {

        return; /* no change, quick exit */

    }

    pow2Width = m3gNextPowerOfTwo(ctx->clip.x1 - ctx->clip.x0);

    pow2Height = m3gNextPowerOfTwo(ctx->clip.y1 - ctx->clip.y0);

    /* If we previously had stored something, restore it now */

    if (ctx->currentColorWrite != ctx->currentAlphaWrite) {

        /* Disable any stray state we don't want */

        glDisable(GL_CULL_FACE);

        glDisable(GL_ALPHA_TEST);

        glDisableClientState(GL_NORMAL_ARRAY);

        glDisableClientState(GL_COLOR_ARRAY);

        glDisable(GL_LIGHTING);

        glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);

        glDepthMask(GL_FALSE);

        glDepthFunc(GL_ALWAYS);

        m3gDisableTextures();

        M3G_ASSERT_GL;

        /* Bind the default texture and set up screen space rendering */

        glActiveTexture(GL_TEXTURE0);

        glBindTexture(GL_TEXTURE_2D, 0);

        glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

        glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

        M3G_ASSERT_GL;

        glScissor(ctx->clip.x0, ctx->clip.y0,

                  ctx->clip.x1 - ctx->clip.x0, ctx->clip.y1 - ctx->clip.y0);

        m3gPushScreenSpace(ctx, M3G_FALSE);

        glViewport(0, 0, ctx->target.width, ctx->target.height);

        glMatrixMode(GL_PROJECTION);

        glOrthox(0, ctx->target.width << 16,

                 0, ctx->target.height << 16,

                 -1 << 16, 1 << 16);

        glMatrixMode(GL_MODELVIEW);

        /* Set up texture and vertex coordinate arrays */

        glClientActiveTexture(GL_TEXTURE0);

        glEnableClientState(GL_TEXTURE_COORD_ARRAY);

        glEnableClientState(GL_VERTEX_ARRAY);

        glMatrixMode(GL_TEXTURE);

        glLoadIdentity();

        glMatrixMode(GL_MODELVIEW);

        M3G_ASSERT_GL;

        /* Blend the texture with the frame buffer */

        {

            static const M3Gbyte tc[8] = { 0, 0, 0, 1, 1, 0, 1, 1 };

            GLshort pos[8];

            GLfixed cm = (GLfixed)(ctx->currentColorWrite ? 0 : 1 << 16);

            GLfixed am = (GLfixed)(ctx->currentAlphaWrite ? 0 : 1 << 16);

            glVertexPointer(2, GL_SHORT, 0, pos);

            glTexCoordPointer(2, GL_BYTE, 0, tc);

            pos[0] = (GLshort) ctx->clip.x0;

            pos[1] = (GLshort) ctx->clip.y0;

            pos[2] = pos[0];

            pos[3] = (GLshort) (pos[1] + pow2Height);

            pos[4] = (GLshort) (pos[0] + pow2Width);

            pos[5] = pos[1];

            pos[6] = pos[4];

            pos[7] = pos[3];

            glEnable(GL_BLEND);

            glColor4x(cm, cm, cm, am);

            /* Zero the masked channels */

            glBlendFunc(GL_ZERO, GL_ONE_MINUS_SRC_COLOR);

            glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);

            /* Add the masked channels from the stored texture */

            glEnable(GL_TEXTURE_2D);

            glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);

            glBlendFunc(GL_ONE, GL_ONE);

            glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);

        }

        /* Restore the mandatory state */

        glScissor(ctx->scissor.x, ctx->scissor.y,

                  ctx->scissor.width, ctx->scissor.height);

        glViewport(ctx->viewport.x, ctx->viewport.y,

                   ctx->viewport.width, ctx->viewport.height);

        m3gPopSpace(ctx);

    }

    /* Copy the current clip rectangle into the default texture if

     * we're going to be rendering with unsupported masks in effect */

    if (newColorWrite != newAlphaWrite) {

        GLenum err;

        glBindTexture(GL_TEXTURE_2D, 0);

        M3G_ASSERT_GL;

        glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA,

                         ctx->clip.x0, ctx->clip.y0,

                         pow2Width, pow2Height,

                         0);

        err = glGetError();

        if (err == GL_INVALID_OPERATION) {

            /* Incompatible FB format -- must be GL_RGB then */

            glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB,

                             ctx->clip.x0, ctx->clip.y0,

                             pow2Width, pow2Height,

                             0);

            err = glGetError();

        }

        if (err == GL_OUT_OF_MEMORY) {

            m3gRaiseError(M3G_INTERFACE(ctx), M3G_OUT_OF_MEMORY);

        }

        M3G_ASSERT(!err);

    }

    else {

        /* Texture not needed for now, so allow GL to free some

         * resources */

        glTexImage2D(GL_TEXTURE_2D, 0,

                     GL_RGBA,

                     1, 1,

                     0,

                     GL_RGBA, GL_UNSIGNED_BYTE, NULL);

    }

    ctx->currentColorWrite = newColorWrite;

    ctx->currentAlphaWrite = newAlphaWrite;

}

/*!

 * \internal

 * \brief Sets the GL to input screen space coordinates

 *

 * This pushes the current modelview and projection matrices into the

 * matrix stack, then sets up an orthogonal projection and an identity

 * modelview matrix.

 * 

 * \param ctx the rendering context

 * \param realPixels M3G_TRUE to use actual pixel coordinates,

 * M3G_FALSE to use normalized device coordinates

 */

static void m3gPushScreenSpace(RenderContext *ctx, M3Gbool realPixels)

{

    M3G_VALIDATE_OBJECT(ctx);

    glMatrixMode(GL_PROJECTION);

    glPushMatrix();

    glLoadIdentity();

    if (realPixels) {

        int w = ctx->viewport.width;

        int h = ctx->viewport.height;

        glOrthox(0, w << 16, 0, h << 16, -1 << 16, 1 << 16);

    }

    glMatrixMode(GL_MODELVIEW);

    glPushMatrix();

    glLoadIdentity();

}

/*!

 * \internal

 * \brief Restores the projection and modelview matrix modified by

 * m3gPushScreenSpace

 */

static void m3gPopSpace(RenderContext *ctx)

{

    M3G_VALIDATE_OBJECT(ctx);

    M3G_UNREF(ctx);

    glMatrixMode(GL_PROJECTION);

    glPopMatrix();

    glMatrixMode(GL_MODELVIEW);

    glPopMatrix();

}

/*!

 * \internal

 * \brief Clears the current buffer(s)

 */

static void m3gClearInternal(RenderContext *ctx, Background *bg)

{

    m3gMakeCurrent(ctx);

    /* If buffered rendering, copy data to the back buffer at this

     * point if we're not clearing the whole clip rectangle */

    if (ctx->target.buffered && !ctx->backBuffer.contentsValid) {

        if (ctx->scissor.x > ctx->clip.x0 || ctx->scissor.y > ctx->clip.y0 ||

            ctx->scissor.x + ctx->scissor.width < ctx->clip.x1 ||

            ctx->scissor.y + ctx->scissor.height < ctx->clip.y1) {

            m3gUpdateBackBuffer(ctx);

        }

    }

    if (m3gGetColorMaskWorkaround(M3G_INTERFACE(ctx))) {

        m3gUpdateColorMaskStatus(ctx, M3G_TRUE, M3G_TRUE);

    }

    glDepthMask(GL_TRUE);

    glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, m3gGetAlphaWrite(ctx));

    glDepthRangef(ctx->depthNear, ctx->depthFar);

    glViewport(ctx->viewport.x, ctx->viewport.y,

               ctx->viewport.width, ctx->viewport.height);

    glScissor(ctx->scissor.x, ctx->scissor.y,

              ctx->scissor.width, ctx->scissor.height);

    /* Touch the background image to make sure it's created prior to

     * locking memory for rendering */

    if (bg != NULL && bg->image != NULL) {

        if (!m3gGetPowerOfTwoImage(bg->image)) {

            return; /* out of memory */

        }

    }

    /* All clear for clearing... */

    m3gLockFrameBuffer(ctx);

    if (bg != NULL) {

        m3gApplyBackground(ctx, bg);

        if (ctx->target.buffered && bg->colorClearEnable) {

            ctx->backBuffer.contentsValid = M3G_TRUE;

        }

    }

    else {

        glClearColorx(0, 0, 0, 0);

        glClearDepthx(1 << 16);

        glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);

        if (ctx->target.buffered) {

            ctx->backBuffer.contentsValid = M3G_TRUE;

        }

    }