1 /*

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

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of the License "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: Rendering context function implementations

    15 *

    16 */

    17 

    18 

    19 /*!

    20  * \internal

    21  * \file

    22  * \brief Rendering context function implementations

    23  */

    24 

    25 #ifndef M3G_CORE_INCLUDE

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

    27 #endif

    28 

    29 #include "m3g_rendercontext.h"

    30 #include "m3g_object.h"

    31 

    32 #include "m3g_gl.h"

    33 #include "m3g_memory.h"

    34 #include "m3g_appearance.h"

    35 #include "m3g_indexbuffer.h"

    36 #include "m3g_lightmanager.h"

    37 #include "m3g_vertexbuffer.h"

    38 #include "m3g_world.h"

    39 

    40 /*----------------------------------------------------------------------

    41  * Private data types

    42  *--------------------------------------------------------------------*/

    43 

    44 #if defined(M3G_NGL_CONTEXT_API)

    45 /*!

    46  * \internal

    47  * \brief Depth buffer data

    48  */

    49 typedef struct

    50 {

    51     M3GMemObject handle;

    52     M3Gsizei size;

    53 } DepthBuffer;

    54 #endif /*M3G_NGL_CONTEXT_API*/

    55 

    56 #if !defined(M3G_NGL_CONTEXT_API)

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

    58 typedef struct {

    59     EGLContext handle;

    60     M3GPixelFormat format;

    61     M3Gbitmask bufferBits;

    62     M3Gbitmask surfaceTypeBits;

    63     M3Gbitmask modeBits;

    64     M3Guint lastUseTime;

    65 } GLContextRecord;

    66 

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

    68 typedef struct {

    69     EGLSurface handle;

    70     M3Gbitmask bufferBits;

    71     M3Gbitmask type;

    72     M3Guint targetHandle;

    73     M3Guint lastUseTime;

    74 } GLSurfaceRecord;

    75 #endif /*!M3G_NGL_CONTEXT_API*/

    76 

    77 /*!

    78  * \internal \brief Rendering target data

    79  */

    80 typedef struct 

    81 {

    82     M3Gbitmask type;

    83     M3GPixelFormat format;

    84     M3Gint width, height;

    85 #   if defined(M3G_NGL_CONTEXT_API)

    86     M3Guint stride;

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

    88 #   else

    89     EGLSurface surface;

    90 #   endif

    91     M3Guint handle;

    92     M3Guint userData;

    93     

    94     /*!

    95      * \internal

    96      * \brief Flag set to indicate back buffer rendering

    97      *

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

    99      * conversion, when releasing the target.

   100      */

   101     M3Gbool buffered;

   102 } RenderTarget;

   103 

   104 /*!

   105  * \internal

   106  * \brief Back color buffer data

   107  */

   108 typedef struct {

   109 #   if defined(M3G_NGL_CONTEXT_API)

   110     M3GMemObject handle;

   111     M3Gsizei size;

   112 #   else

   113     M3Gint width, height;

   114     EGLSurface glSurface;

   115 #   endif /* M3G_NGL_CONTEXT_API */

   116     M3Gbool contentsValid;

   117 } BackBuffer;

   118 

   119 /*!

   120  * \internal

   121  * \brief Rendering context data structure

   122  *

   123  * This includes data related to a specific rendering context,

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

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

   126  */

   127 struct M3GRenderContextImpl

   128 {

   129     Object object;

   130     

   131     RenderTarget target;

   132     BackBuffer backBuffer;

   133 #   if defined(M3G_NGL_CONTEXT_API)

   134     DepthBuffer depthBuffer;

   135 #   endif

   136 

   137 #   if !defined(M3G_NGL_CONTEXT_API)

   138     

   139     /* OpenGL context and surface caches */

   140     

   141     GLContextRecord glContext[M3G_MAX_GL_CONTEXTS];

   142     GLSurfaceRecord glSurface[M3G_MAX_GL_SURFACES];

   143     M3Guint cacheTimeStamp;

   144     

   145 #   endif /* M3G_NGL_CONTEXT_API */

   146 

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

   148     M3Genum renderMode;

   149     

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

   151     GLfloat viewTransform[16];

   152 

   153     /*! \internal \brief Current camera */

   154     const Camera *camera;

   155 

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

   157     LightManager lightManager;

   158 

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

   160     M3Gint lastScope;

   161 

   162 	M3Gfloat depthNear;

   163 	M3Gfloat depthFar;

   164     

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

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

   167 

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

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

   170 

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

   172     struct { M3Gint width, height; } display;

   173     

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

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

   176 

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

   178     M3Gbool glInitialized;

   179 

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

   181     M3Gbool accelerated;

   182     

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

   184 	RenderQueue *renderQueue;

   185 

   186     M3Gbool currentColorWrite;

   187     M3Gbool currentAlphaWrite;

   188     M3Gbool inSplitDraw;

   189     M3Gbool alphaWrite;

   190 };

   191 

   192 /*

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

   194  * respective EGL bit values

   195  */

   196 enum SurfaceType {

   197     SURFACE_NONE = 0,

   198     SURFACE_IMAGE = 0x01,       /* EGL_PBUFFER_BIT */

   199     SURFACE_BITMAP = 0x02,      /* EGL_PIXMAP_BIT */

   200     SURFACE_WINDOW = 0x04,      /* EGL_WINDOW_BIT */

   201     SURFACE_MEMORY = SURFACE_IMAGE | SURFACE_BITMAP | SURFACE_WINDOW,

   202     SURFACE_EGL = 0x80

   203 };

   204 

   205 enum RenderMode {

   206     RENDER_IMMEDIATE,

   207     RENDER_NODES,

   208     RENDER_WORLD

   209 };

   210 

   211 /*----------------------------------------------------------------------

   212  * Platform specific code

   213  *--------------------------------------------------------------------*/

   214 

   215 static M3Gbool m3gBindRenderTarget(RenderContext *ctx,

   216                                    M3Genum targetType,

   217                                    M3Gint width, M3Gint height,

   218                                    M3GPixelFormat format,

   219                                    M3Guint handle);

   220 static void m3gResetRectangles(RenderContext *ctx);

   221 static void m3gSetGLDefaults(void);

   222 static void m3gUpdateScissor(RenderContext *ctx);

   223 static void m3gValidateBuffers(RenderContext *ctx);

   224 static M3Gbool m3gValidTargetFormat(M3GPixelFormat format);

   225 

   226 #include "m3g_rendercontext.inl"

   227 

   228 /*----------------------------------------------------------------------

   229  * Internal functions

   230  *--------------------------------------------------------------------*/

   231 

   232 /*!

   233  * \internal

   234  * \brief Rendering context destructor

   235  *

   236  */

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

   238 {

   239     RenderContext *ctx = (RenderContext *) obj;

   240     M3G_VALIDATE_OBJECT(ctx);

   241 

   242     M3G_ASSIGN_REF(ctx->camera, NULL);

   243     

   244 #   if defined(M3G_NGL_CONTEXT_API)

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

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

   247     }

   248 

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

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

   251     

   252 #   else /* !M3G_NGL_CONTEXT_API */

   253     

   254     {

   255         int i;

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

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

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

   259             }

   260         }

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

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

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

   264             }

   265         }

   266     }

   267 

   268 #   endif /* M3G_NGL_CONTEXT_API */

   269     

   270     if (ctx->glInitialized) {

   271         m3gShutdownGL(M3G_INTERFACE(ctx));

   272     }

   273 

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

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

   276     m3gDestroyObject(obj);

   277 }

   278 

   279 /*!

   280  * \internal

   281  * \brief Resets the clipping and viewport rectangles to defaults

   282  *

   283  * This is called after binding a new target.

   284  */

   285 static void m3gResetRectangles(RenderContext *ctx)

   286 {

   287     int w = ctx->display.width;

   288     int h = ctx->display.height;

   289     

   290     ctx->clip.x0 = 0;

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

   292     ctx->clip.x1 = w;

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

   294 

   295     ctx->viewport.x = 0;

   296     ctx->viewport.y = 0;

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

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

   299 }

   300 

   301 /*!

   302  * \internal

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

   304  */

   305 static void m3gValidateClipRect(RenderContext *ctx)

   306 {

   307     int xMin = 0;

   308     int xMax = ctx->display.width;

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

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

   311     

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

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

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

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

   316 }

   317 

   318 /*!

   319  * \internal

   320  * \brief Computes the GL scissor rectangle

   321  *

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

   323  * clipping rectangle.

   324  */

   325 static void m3gUpdateScissor(RenderContext *ctx)

   326 {

   327     int sx0 = ctx->viewport.x;

   328     int sy0 = ctx->viewport.y;

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

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

   331 

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

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

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

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

   336 

   337     ctx->scissor.x = sx0;

   338     ctx->scissor.y = sy0;

   339     

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

   341         ctx->scissor.width = sx1 - sx0;

   342         ctx->scissor.height = sy1 - sy0;

   343     }

   344     else {

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

   346     }

   347 }

   348 

   349 /*!

   350  * \internal

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

   352  */

   353 static M3Gbool m3gValidTargetFormat(M3GPixelFormat format)

   354 {

   355     return m3gInRange(format, M3G_RGB8, M3G_RGBA4);

   356 }

   357 

   358 /*!

   359  * \internal

   360  * \brief Checks whether a given format has alpha

   361  */

   362 static M3Gbool m3gFormatHasAlpha(M3GPixelFormat format)

   363 {

   364     switch (format) {

   365     case M3G_A8:

   366     case M3G_LA8:

   367     case M3G_LA4:

   368     case M3G_RGBA8:

   369     case M3G_BGRA8:

   370     case M3G_RGBA4:

   371     case M3G_RGB5A1:

   372     case M3G_PALETTE8_RGBA8:

   373         return M3G_TRUE;

   374     default:

   375         return M3G_FALSE;

   376     }

   377 }

   378 

   379 /*!

   380  * \internal

   381  * \brief Sets the global alpha write enable flag. 

   382  *

   383  *	Used for disabling the alpha channel writes when the rendering 

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

   385  *

   386  * \param ctx        the rendering context

   387  * \param enable     alpha write enable flag

   388  */

   389 M3G_API void m3gSetAlphaWrite(M3GRenderContext ctx, M3Gbool enable)

   390 {

   391 	ctx->alphaWrite = enable;

   392 }

   393 

   394 /*!

   395  * \internal

   396  * \brief Reads the global alpha write enable flag. 

   397  *

   398  * \param ctx        the rendering context

   399  */

   400 M3G_API M3Gbool m3gGetAlphaWrite(M3GRenderContext ctx)

   401 {

   402 	return ctx->alphaWrite;

   403 }

   404 

   405 

   406 /*!

   407  * \internal

   408  * \brief Sets up a new rendering target

   409  *

   410  * \param ctx        the rendering context

   411  * \param targetType rendering target type

   412  * \param width      width of the target

   413  * \param height     height of the target

   414  * \param format     target pixel format

   415  * \param handle     user object handle

   416  */

   417 static M3Gbool m3gBindRenderTarget(RenderContext *ctx,

   418                                    M3Genum targetType,

   419                                    M3Gint width, M3Gint height,

   420                                    M3GPixelFormat format,

   421                                    M3Guint handle)

   422 {

   423     /* Check for generic errors */

   424     

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

   426         m3gRaiseError(M3G_INTERFACE(ctx), M3G_INVALID_OPERATION);

   427         return M3G_FALSE;

   428     }

   429     if (!m3gValidTargetFormat(format)) {

   430         m3gRaiseError(M3G_INTERFACE(ctx), M3G_INVALID_ENUM);

   431         return M3G_FALSE;

   432     }

   433 

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

   435        an exception is thrown. */

   436     

   437     if (width > M3G_MAX_VIEWPORT_WIDTH ||

   438         height > M3G_MAX_VIEWPORT_HEIGHT) {

   439         m3gRaiseError(M3G_INTERFACE(ctx), M3G_INVALID_ENUM);

   440         return M3G_FALSE;

   441     }

   442 

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

   444     

   445     ctx->target.type = targetType;

   446     ctx->target.width = width;

   447     ctx->target.height = height;

   448     ctx->display.width = width;

   449     ctx->display.height = height;

   450     ctx->target.format = format;

   451     ctx->target.handle = handle;

   452     m3gResetRectangles(ctx);

   453     m3gUpdateScissor(ctx);

   454     m3gValidateBuffers(ctx);

   455     

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

   457      * rendering context this time around */

   458     

   459     ctx->lastScope = 0;

   460     

   461     return M3G_TRUE;

   462 }

   463 

   464 /*!

   465  * \internal

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

   467  */

   468 static void m3gSetGLDefaults(void)

   469 {

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

   471     glEnable(GL_NORMALIZE);

   472     glEnable(GL_SCISSOR_TEST);

   473 	glLightModelfv(GL_LIGHT_MODEL_AMBIENT, black);

   474     glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

   475 }

   476 

   477 /*!

   478  * \internal

   479  * \brief Validates the buffers required for a rendering context

   480  *

   481  * Allocates or reallocates buffers as necessary, according to the

   482  * currently set flags of the context.

   483  */

   484 static void m3gValidateBuffers(RenderContext *ctx)

   485 {

   486     M3G_VALIDATE_OBJECT(ctx);

   487 

   488     /* Initialize OpenGL if not already done */

   489     

   490     if (!ctx->glInitialized) {

   491         m3gInitializeGL(M3G_INTERFACE(ctx));

   492         ctx->glInitialized = M3G_TRUE;

   493     }

   494 

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

   496      * use a back buffer */

   497     

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

   499 #   if defined(M3G_FORCE_BUFFERED_RENDERING)

   500     ctx->target.buffered = M3G_TRUE;

   501 #   endif

   502     

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

   504      * for buffered rendering exists. */

   505     

   506     if (ctx->target.buffered) {

   507         if (!m3gValidateBackBuffer(ctx)) {

   508             return; /* out of memory */

   509         }

   510     }

   511 

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

   513     

   514 #   if defined(M3G_NGL_CONTEXT_API)

   515     if (!m3gValidateDepthBuffer(ctx)) {

   516         return; /* out of memory */

   517     }

   518 #   endif

   519 

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

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

   522     

   523     if (ctx->target.buffered) {

   524         if (ctx->modeBits & M3G_OVERWRITE_BIT) {

   525             ctx->backBuffer.contentsValid = M3G_TRUE;

   526         }

   527         else {

   528             ctx->backBuffer.contentsValid = M3G_FALSE;

   529         }

   530     }

   531 }

   532 

   533 /*!

   534  * \internal

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

   536  * set rendering target buffer

   537  */

   538 static void m3gMakeCurrent(RenderContext *ctx)

   539 {

   540     m3gMakeGLCurrent(ctx);

   541 

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

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

   544      * in case */

   545     

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

   547         glDisable(GL_DEPTH_TEST);

   548     }

   549     else {

   550         glEnable(GL_DEPTH_TEST);

   551     }

   552 

   553     /* Enable multisampling if required */

   554 

   555     if (ctx->modeBits & M3G_ANTIALIAS_BIT) {

   556         glEnable(GL_MULTISAMPLE);

   557     }

   558     else {

   559         glDisable(GL_MULTISAMPLE);

   560     }

   561     

   562     M3G_ASSERT_GL;

   563 }

   564 

   565 /*!

   566  * \internal

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

   568  */

   569 static M3Gbool m3gIsAccelerated(const RenderContext *ctx)

   570 {

   571     return ctx->accelerated;

   572 }

   573 

   574 /*!

   575  * \internal

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

   577  *

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

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

   580  */

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

   582 {

   583     if (ctx->lastScope != scope) {

   584 

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

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

   587          * the viewing matrix to the lights only */

   588         

   589         if (ctx->renderMode == RENDER_NODES) {

   590             glPushMatrix();

   591             glLoadMatrixf(ctx->viewTransform);

   592         }

   593         

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

   595         ctx->lastScope = scope;

   596         

   597         if (ctx->renderMode == RENDER_NODES) {

   598             glPopMatrix();

   599         }

   600     }

   601 	M3G_ASSERT_GL;

   602 }

   603 

   604 /*!

   605  * \internal

   606  * \brief Gets the current camera

   607  */

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

   609 	return ctx->camera;	

   610 }

   611 

   612 /*!

   613  * \internal

   614  * \brief Sets up some rendering parameters that

   615  * do not change during scene renders.

   616  */

   617 static void m3gInitRender(M3GRenderContext context, M3Genum renderMode)

   618 {

   619     RenderContext *ctx = (RenderContext *) context;

   620     M3G_VALIDATE_OBJECT(ctx);

   621 

   622     m3gIncrementRenderTimeStamp(ctx);

   623     m3gMakeCurrent(ctx);

   624     m3gCollectGLObjects(M3G_INTERFACE(ctx));

   625     

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

   627      * this point */

   628     

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

   630         m3gUpdateBackBuffer(ctx);

   631     }

   632     

   633     /* Set up viewport and scissoring */

   634     

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

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

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

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

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

   640     M3G_ASSERT_GL;

   641     

   642     /* Set up the projection and viewing transformations (static

   643      * during rendering) */

   644 

   645 	m3gApplyProjection(ctx->camera);

   646     if (renderMode == RENDER_NODES) {

   647         glLoadIdentity();

   648     }

   649     else {

   650         glLoadMatrixf(ctx->viewTransform);

   651     }

   652     M3G_ASSERT_GL;

   653 

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

   655     

   656     if (renderMode != ctx->renderMode) {

   657         ctx->lastScope = 0;

   658     }

   659     ctx->renderMode = renderMode;

   660 }

   661 

   662 /*!

   663  * \internal

   664  * \brief A workaround for a broken implementation of glColorMask

   665  *

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

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

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

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

   670  * buffer.

   671  *

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

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

   674  */

   675 static void m3gUpdateColorMaskStatus(RenderContext *ctx,

   676                                      M3Gbool newColorWrite,

   677                                      M3Gbool newAlphaWrite)

   678 {

   679     GLint pow2Width, pow2Height;

   680 

   681 	/* Get the global alpha write value */

   682 	newAlphaWrite &= m3gGetAlphaWrite(ctx);

   683 

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

   685     

   686     if (ctx->currentColorWrite == newColorWrite

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

   688         return; /* no change, quick exit */

   689     }

   690     

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

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

   693     

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

   695 

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

   697         

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

   699 

   700         glDisable(GL_CULL_FACE);

   701         glDisable(GL_ALPHA_TEST);

   702         glDisableClientState(GL_NORMAL_ARRAY);

   703         glDisableClientState(GL_COLOR_ARRAY);

   704         glDisable(GL_LIGHTING);

   705         glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);

   706         glDepthMask(GL_FALSE);

   707         glDepthFunc(GL_ALWAYS);

   708         m3gDisableTextures();

   709         M3G_ASSERT_GL;

   710     

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

   712         

   713         glActiveTexture(GL_TEXTURE0);

   714         glBindTexture(GL_TEXTURE_2D, 0);

   715         glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

   716         glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

   717         M3G_ASSERT_GL;

   718 

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

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

   721         m3gPushScreenSpace(ctx, M3G_FALSE);

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

   723         glMatrixMode(GL_PROJECTION);

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

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

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

   727         glMatrixMode(GL_MODELVIEW);

   728             

   729         /* Set up texture and vertex coordinate arrays */

   730 

   731         glClientActiveTexture(GL_TEXTURE0);

   732         glEnableClientState(GL_TEXTURE_COORD_ARRAY);

   733         glEnableClientState(GL_VERTEX_ARRAY);

   734         glMatrixMode(GL_TEXTURE);

   735         glLoadIdentity();

   736         glMatrixMode(GL_MODELVIEW);

   737         M3G_ASSERT_GL;

   738 

   739         /* Blend the texture with the frame buffer */

   740         {

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

   742             GLshort pos[8];

   743             

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

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

   746 

   747             glVertexPointer(2, GL_SHORT, 0, pos);

   748             glTexCoordPointer(2, GL_BYTE, 0, tc);

   749                 

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

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

   752             pos[2] = pos[0];

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

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

   755             pos[5] = pos[1];

   756             pos[6] = pos[4];

   757             pos[7] = pos[3];

   758             

   759             glEnable(GL_BLEND);

   760             glColor4x(cm, cm, cm, am);

   761 

   762             /* Zero the masked channels */

   763             

   764             glBlendFunc(GL_ZERO, GL_ONE_MINUS_SRC_COLOR);

   765             glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);

   766 

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

   768             

   769             glEnable(GL_TEXTURE_2D);

   770             glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);

   771             glBlendFunc(GL_ONE, GL_ONE);

   772             glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);

   773         }

   774             

   775         /* Restore the mandatory state */

   776             

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

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

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

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

   781         m3gPopSpace(ctx);

   782     }

   783     

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

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

   786     

   787     if (newColorWrite != newAlphaWrite) {

   788         GLenum err;

   789             

   790         glBindTexture(GL_TEXTURE_2D, 0);

   791         M3G_ASSERT_GL;

   792             

   793         glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA,

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

   795                          pow2Width, pow2Height,

   796                          0);

   797         err = glGetError();

   798         if (err == GL_INVALID_OPERATION) {

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

   800             glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB,

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

   802                              pow2Width, pow2Height,

   803                              0);

   804             err = glGetError();

   805         }

   806         if (err == GL_OUT_OF_MEMORY) {

   807             m3gRaiseError(M3G_INTERFACE(ctx), M3G_OUT_OF_MEMORY);

   808         }

   809         M3G_ASSERT(!err);

   810     }

   811     else {

   812         

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

   814          * resources */

   815         

   816         glTexImage2D(GL_TEXTURE_2D, 0,

   817                      GL_RGBA,

   818                      1, 1,

   819                      0,

   820                      GL_RGBA, GL_UNSIGNED_BYTE, NULL);

   821     }

   822     

   823     ctx->currentColorWrite = newColorWrite;

   824     ctx->currentAlphaWrite = newAlphaWrite;

   825 }

   826 

   827 /*!

   828  * \internal

   829  * \brief Sets the GL to input screen space coordinates

   830  *

   831  * This pushes the current modelview and projection matrices into the

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

   833  * modelview matrix.

   834  * 

   835  * \param ctx the rendering context

   836  * \param realPixels M3G_TRUE to use actual pixel coordinates,

   837  * M3G_FALSE to use normalized device coordinates

   838  */

   839 static void m3gPushScreenSpace(RenderContext *ctx, M3Gbool realPixels)

   840 {

   841     M3G_VALIDATE_OBJECT(ctx);

   842     

   843     glMatrixMode(GL_PROJECTION);

   844     glPushMatrix();

   845     glLoadIdentity();

   846     if (realPixels) {

   847         int w = ctx->viewport.width;

   848         int h = ctx->viewport.height;

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

   850     }

   851     glMatrixMode(GL_MODELVIEW);

   852     glPushMatrix();

   853     glLoadIdentity();

   854 }

   855 

   856 /*!

   857  * \internal

   858  * \brief Restores the projection and modelview matrix modified by

   859  * m3gPushScreenSpace

   860  */

   861 static void m3gPopSpace(RenderContext *ctx)

   862 {

   863     M3G_VALIDATE_OBJECT(ctx);

   864     

   865     M3G_UNREF(ctx);

   866     glMatrixMode(GL_PROJECTION);

   867     glPopMatrix();

   868     glMatrixMode(GL_MODELVIEW);

   869     glPopMatrix();

   870 }

   871 

   872 /*!

   873  * \internal

   874  * \brief Clears the current buffer(s)

   875  */

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

   877 {

   878     m3gMakeCurrent(ctx);

   879     

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

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

   882     

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

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

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

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

   887             m3gUpdateBackBuffer(ctx);

   888         }

   889     }

   890 

   891     if (m3gGetColorMaskWorkaround(M3G_INTERFACE(ctx))) {

   892         m3gUpdateColorMaskStatus(ctx, M3G_TRUE, M3G_TRUE);

   893     }

   894 

   895     glDepthMask(GL_TRUE);

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

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

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

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

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

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

   902 

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

   904      * locking memory for rendering */

   905     

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

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

   908             return; /* out of memory */

   909         }

   910     }

   911 

   912     /* All clear for clearing... */

   913     

   914     m3gLockFrameBuffer(ctx);

   915     

   916     if (bg != NULL) {

   917         m3gApplyBackground(ctx, bg);

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

   919             ctx->backBuffer.contentsValid = M3G_TRUE;

   920         }

   921     }

   922     else {

   923         glClearColorx(0, 0, 0, 0);

   924         glClearDepthx(1 << 16);

   925         glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);

   926         if (ctx->target.buffered) {

   927             ctx->backBuffer.contentsValid = M3G_TRUE;

   928         }

   929     }

   930         

   931     m3gReleaseFrameBuffer(ctx);

   932 }

   933 

   934 /*!

   935  * \internal

   936  * \brief Draws a batch of primitives

   937  *

   938  * This is the place most rendering commands are eventually routed to;

   939  * sprites and backgrounds are the only exception to this. We assume

   940  * that all eror checking has been performed at this point.

   941  */

   942 static void m3gDrawMesh(RenderContext *ctx,

   943                         const VertexBuffer *vb,

   944                         const IndexBuffer *ib,

   945                         const Appearance *app,

   946                         const M3GMatrix *modelTransform,

   947                         M3Gint alphaFactor,

   948                         M3Gint scope)

   949 {

   950     M3G_VALIDATE_OBJECT(ctx);

   951     M3G_VALIDATE_OBJECT(vb);

   952     M3G_VALIDATE_OBJECT(ib);

   953     M3G_VALIDATE_OBJECT(app);

   954 

   955     /* Check whether we need to use alternate rendering to get

   956      * two-sided lighting */

   957     if (m3gGetTwoSidedLightingWorkaround(M3G_INTERFACE(ctx))) {

   958         if (m3gSplitDrawMesh(ctx, vb, ib, app, modelTransform, alphaFactor, scope)) {

   959             return;

   960         }

   961     }

   962 

   963     M3G_ASSERT(m3gInRange(alphaFactor, 0, 0x10000));

   964     

   965     if (m3gGetColorMaskWorkaround(M3G_INTERFACE(ctx))) {

   966 		m3gUpdateColorMaskStatus(ctx, m3gColorMask(app), m3gAlphaMask(app));

   967     }

   968     

   969     /* Load lights */

   970     

   971     m3gApplyLights(ctx, scope);

   972     

   973     /* Apply the extra modeling transformation if present */

   974     

   975     if (modelTransform != NULL) {

   976 		float transform[16];

   977 		m3gGetMatrixColumns(modelTransform, transform);

   978         

   979         glPushMatrix();

   980         glMultMatrixf(transform);

   981     }

   982 

   983     /* Check whether we need to create an alpha-factored color cache

   984      * for the vertex buffer; this requires unlocking the frame buffer

   985      * for a while, and we may even run out of memory in the process,

   986      * but we still need to exit with the frame buffer lock and the

   987      * matrix stack in the expected state */

   988 

   989     if (alphaFactor < 0x10000 && !m3gValidateAlphaCache(vb)) {

   990         M3Gbool ok;

   991         m3gReleaseFrameBuffer(ctx);

   992         ok = m3gCreateAlphaColorCache(vb->colors);

   993         m3gLockFrameBuffer(ctx);

   994         if (!ok) {

   995             goto RestoreModelview; /* let's just skip the drawing part */

   996         }

   997     }

   998 

   999 #   if defined(M3G_NGL_TEXTURE_API)

  1000     /* Similarly to the alpha cache above, also check whether any

  1001      * textures may need to allocate mipmaps at this point */

  1002     {

  1003         M3Gint i;

  1004         for (i = 0; i < M3G_NUM_TEXTURE_UNITS; ++i) {

  1005             Texture *tex = app->texture[i];

  1006             if (tex && !m3gValidateTextureMipmapping(tex)) {

  1007                 M3Gbool ok;

  1008                 m3gReleaseFrameBuffer(ctx);

  1009                 ok = m3gValidateMipmapMemory(m3gGetTextureImage(tex));

  1010                 m3gLockFrameBuffer(ctx);

  1011                 if (!ok) {

  1012                     goto RestoreModelview;

  1013                 }

  1014             }

  1015         }

  1016     }

  1017 #   endif

  1018     

  1019     /* Load up the rest of the stuff we need for rendering; note that

  1020      * the vertex buffer scale and bias apply to the texture matrix

  1021      * from the appearance object, so they need to be applied last */

  1022     

  1023     m3gApplyAppearance(app, ctx, alphaFactor);

  1024     m3gLockVertexBuffer(vb, alphaFactor);

  1025     m3gApplyScaleAndBias(vb);

  1026     

  1027     /* All ready, render and then release the stuff we bound above */

  1028     

  1029     m3gSendIndexBuffer(ib);

  1030     m3gReleaseVertexBuffer(vb);

  1031     m3gReleaseTextures(app);

  1032 

  1033     /* Restore viewing-only modelview if changed */

  1034 

  1035 RestoreModelview:

  1036     if (modelTransform != NULL) {

  1037         glPopMatrix();

  1038     }

  1039 }

  1040 

  1041 /*!

  1042  * \internal

  1043  * \brief Validates background format against current target

  1044  *

  1045  * \retval M3G_TRUE valid format

  1046  * \retval M3G_FALSE invalid format

  1047  */

  1048 static M3Gbool m3gValidateBackground(RenderContext *ctx, Background *bg)

  1049 {

  1050     /* Check that source image and target formats match */

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

  1052         M3GPixelFormat boundFormat =

  1053             (ctx->target.type == SURFACE_IMAGE)

  1054             ? m3gPixelFormat(((const Image *)ctx->target.handle)->format)

  1055             : ctx->target.format;

  1056         if (ctx->target.type == SURFACE_IMAGE && boundFormat == M3G_RGBA8) {

  1057             return (m3gGetFormat(bg->image) == M3G_RGBA);

  1058         }

  1059         else {

  1060             return (m3gGetFormat(bg->image) == M3G_RGB);

  1061         }

  1062     }

  1063 

  1064     return M3G_TRUE;

  1065 }

  1066 

  1067 /*----------------------------------------------------------------------

  1068  * Virtual function table

  1069  *--------------------------------------------------------------------*/

  1070 

  1071 static const ObjectVFTable m3gvf_RenderContext = {

  1072     NULL, /* ApplyAnimation */

  1073     NULL, /* IsCompatible */

  1074     NULL, /* UpdateProperty */

  1075     NULL, /* GetReference */

  1076     NULL, /* find */

  1077     NULL, /* CreateClone */

  1078     m3gDestroyContext

  1079 };

  1080 

  1081 

  1082 /*----------------------------------------------------------------------

  1083  * Public API

  1084  *--------------------------------------------------------------------*/

  1085 

  1086 /*!

  1087  * \brief Creates and initializes a new rendering context

  1088  *

  1089  * \param bufferBits buffer bitmask

  1090  * \param width maximum width of context

  1091  * \param height maximum height of context

  1092  * \param modeBits hint bitmask

  1093  * \param mem pointer to memory block to allocate from

  1094  */

  1095 /*@access M3GInterface@*/

  1096 /*@access M3GRenderContext@*/

  1097 /*@only@*/

  1098 M3G_API M3GRenderContext m3gCreateContext(M3GInterface interface)/*@*/

  1099 {

  1100     Interface *m3g = (Interface*) interface;

  1101     M3G_VALIDATE_INTERFACE(m3g);

  1102         

  1103     {

  1104         RenderContext *ctx =

  1105             (RenderContext*) m3gAllocZ(m3g, (int) sizeof(RenderContext));

  1106         if (ctx == NULL) {

  1107             return NULL; /* m3gAlloc automatically raises out-of-mem */

  1108         }

  1109 

  1110 		ctx->renderQueue = m3gCreateRenderQueue(m3g);

  1111         if (ctx->renderQueue == NULL) {

  1112             m3gFree(m3g, ctx);

  1113             return NULL;

  1114         }

  1115         ctx->bufferBits = M3G_COLOR_BUFFER_BIT|M3G_DEPTH_BUFFER_BIT;

  1116         ctx->depthNear = 0.0f;

  1117         ctx->depthFar = 1.0f;

  1118 

  1119         m3gInitObject(&ctx->object, m3g, M3G_CLASS_RENDER_CONTEXT);

  1120 

  1121 		m3gSetAlphaWrite(ctx, M3G_TRUE);

  1122 

  1123         if (m3gGetColorMaskWorkaround(M3G_INTERFACE(ctx))) {

  1124             ctx->currentColorWrite = M3G_TRUE;

  1125             ctx->currentAlphaWrite = m3gGetAlphaWrite(ctx);

  1126         }

  1127         

  1128 		return (M3GRenderContext)ctx;

  1129     }

  1130 }

  1131 

  1132 /*!

  1133  * \brief Sets the buffers to use for subsequent rendering

  1134  */