/*

* 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: Sprite implementation

*

*/

/*!

 * \internal

 * \file

 * \brief Sprite implementation

 */

#ifndef M3G_CORE_INCLUDE

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

#endif

/*#include <stdio.h>*/

#include "m3g_sprite.h"

#include "m3g_appearance.h"

#include "m3g_camera.h"

#include "m3g_rendercontext.h"

#include "m3g_renderqueue.h"

#define FLIPX   1

#define FLIPY   2

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

 * Internal functions

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

/*!

 * \internal

 * \brief Destroys this Sprite object.

 *

 * \param obj Sprite object

 */

static void m3gDestroySprite(Object *obj)

{

    Sprite *sprite = (Sprite *) obj;

    M3G_VALIDATE_OBJECT(sprite);

    M3G_ASSIGN_REF(sprite->image, NULL);

    M3G_ASSIGN_REF(sprite->appearance, NULL);

    m3gIncStat(M3G_INTERFACE(obj), M3G_STAT_RENDERABLES, -1);

    m3gDestroyNode(obj);

}

/*!

 * \internal

 * \brief Overloaded Object3D method.

 *

 * \param property      animation property

 * \retval M3G_TRUE     property supported

 * \retval M3G_FALSE    property not supported

 */

static M3Gbool m3gSpriteIsCompatible(M3Gint property)

{

    switch (property) {

    case M3G_ANIM_CROP:

        return M3G_TRUE;

    default:

        return m3gNodeIsCompatible(property);

    }

}

/*!

 * \internal

 * \brief Overloaded Node method

 */

static M3Gint m3gSpriteGetBBox(Node *self, AABB *bbox)

{

    Sprite *sprite = (Sprite*) self;

    /* Only scaled sprites can have a bounding box; non-scaled ones

     * are marked as non-cullable in the "SetParent" function in

     * m3g_node.c */

    if (sprite->scaled) {

        const AABB spriteBBox = { { -.5f, -.5f,  0.f },

                                  {  .5f,  .5f,  0.f } };

        *bbox = spriteBBox;

        return (4 * VFC_VERTEX_COST +

                2 * VFC_TRIANGLE_COST +

                VFC_NODE_OVERHEAD);

    }

    else {

        return 0; /* no bounding box for non-scaled sprites */

    }

}

/*!

 * \internal

 * \brief Overloaded Object3D method.

 *

 * \param self          Sprite object

 * \param property      animation property

 * \param valueSize     size of value array

 * \param value         value array

 */

static void m3gSpriteUpdateProperty(Object *self,

                                    M3Gint property,

                                    M3Gint valueSize,

                                    const M3Gfloat *value)

{

    Sprite *sprite = (Sprite *) self;

    M3G_VALIDATE_OBJECT(sprite);

    M3G_ASSERT_PTR(value);

    switch (property) {

    case M3G_ANIM_CROP:

        /* Assert that the value vector is large enough */

        if (valueSize > 2) {

            M3G_ASSERT(valueSize >= 4);

            m3gSetCrop(sprite,  m3gRoundToInt(value[0]),

                       m3gRoundToInt(value[1]),

                       m3gClampInt(m3gRoundToInt(value[2]),

                                   -M3G_MAX_TEXTURE_DIMENSION,

                                   M3G_MAX_TEXTURE_DIMENSION),

                       m3gClampInt(m3gRoundToInt(value[3]),

                                   -M3G_MAX_TEXTURE_DIMENSION,

                                   M3G_MAX_TEXTURE_DIMENSION) );

        }

        else {

            M3G_ASSERT(valueSize >= 2);

            m3gSetCrop(sprite,  m3gRoundToInt(value[0]),

                       m3gRoundToInt(value[1]),

                       sprite->crop.width,

                       sprite->crop.height );

        }

        break;

    default:

        m3gNodeUpdateProperty(self, property, valueSize, value);

    }

}

/*!

 * \internal

 * \brief Overloaded Node method.

 *

 * \param self Sprite object

 * \param toCamera transform to camera

 * \param alphaFactor total alpha factor

 * \param caller caller node

 * \param renderQueue RenderQueue

 *

 * \retval M3G_TRUE continue render setup

 * \retval M3G_FALSE abort render setup

 */

static M3Gbool m3gSpriteSetupRender(Node *self,

                                    const Node *caller,

                                    SetupRenderState *s,

                                    RenderQueue *renderQueue)

{

    Sprite *sprite = (Sprite *)self;

    Interface *m3g = M3G_INTERFACE(sprite);

    M3G_UNREF(caller);

    m3gIncStat(M3G_INTERFACE(self), M3G_STAT_RENDER_NODES, 1);

    if ((self->enableBits & NODE_RENDER_BIT) != 0 &&

        (self->scope & renderQueue->scope) != 0) {

        if (sprite->appearance != NULL && sprite->image != NULL &&

            sprite->crop.width != 0 && sprite->crop.height != 0) {

            /* Fetch the cumulative alpha factor for this node */

            sprite->totalAlphaFactor =

                (M3Gushort) m3gGetTotalAlphaFactor((Node*) sprite, renderQueue->root);

            /* Touch the POT image to make sure it's allocated prior

             * to rendering */

            if (!m3gGetPowerOfTwoImage(sprite->image) ||

                !m3gInsertDrawable(m3g,

                                   renderQueue,

                                   self,

                                   &s->toCamera,

                                   0,

                                   m3gGetAppearanceSortKey(sprite->appearance)))

                return M3G_FALSE;

        }

    }

    return M3G_TRUE;

}

/*!

 * \internal

 * \brief Calculates sprite vertex positions and texture coordinates.

 *

 * \param sprite        Sprite object

 * \param ctx           RenderContext object (Graphics3D)

 * \param cam           Camera object

 * \param vert          vertex position to fill in

 * \param texvert       texture coordinates to fill in

 * \param eyeSpace      coordinates after modelview

 * \param adjust        adjust for texture coorinates, render and

 *                      pick need different adjustment

 * \retval M3G_TRUE     crop and image intersect

 * \retval M3G_FALSE    crop and image do not intersect

 */

static M3Gbool m3gGetSpriteCoordinates(Sprite *sprite,

                                       RenderContext *ctx,

                                       const Camera *cam,

                                       const Matrix *toCamera,

                                       M3Gint *vert,

                                       M3Gshort *texvert,

                                       Vec4 *eyeSpace,

                                       M3Gshort adjust)

{

    Vec4 o = {0, 0, 0, 1};      /* Origin */

    Vec4 x = {0.5f, 0, 0, 1};   /* Half of x unit */

    Vec4 y = {0, 0.5f, 0, 1};   /* Half of y unit */

    Vec4 ot;

    Rect rIsect, rImage;

    rImage.x = 0;

    rImage.y = 0;

    rImage.width = sprite->width;

    rImage.height = sprite->height;

    /* Intersection of image and crop*/

    if (!m3gIntersectRectangle(&rIsect, &rImage, &sprite->crop)) {

        /* No intersection -> nothing to render / pick */

        return M3G_FALSE;

    }

    /* Calculate origin and vectors after modelview */

    m3gTransformVec4(toCamera, &o);

    m3gTransformVec4(toCamera, &x);

    m3gTransformVec4(toCamera, &y);

    ot = o;

    m3gScaleVec4(&o, m3gRcp(o.w));

    m3gScaleVec4(&x, m3gRcp(x.w));

    m3gScaleVec4(&y, m3gRcp(y.w));

    /* Store eyespace coordinates */

    if (eyeSpace != NULL) {

        eyeSpace->x = o.x;

        eyeSpace->y = o.y;

        eyeSpace->z = o.z;

    }

    m3gSubVec4(&x, &o);

    m3gSubVec4(&y, &o);

    x.x = m3gAdd(ot.x, m3gLengthVec3((const Vec3*) &x));

    x.y = ot.y;

    x.z = ot.z;

    x.w = ot.w;

    y.y = m3gAdd(ot.y, m3gLengthVec3((const Vec3*) &y));

    y.x = ot.x;

    y.z = ot.z;

    y.w = ot.w;

    /* Calculate origin and vectors after projection */

    {

        const Matrix *projMatrix = m3gProjectionMatrix(cam);

        m3gTransformVec4(projMatrix, &ot);

        m3gTransformVec4(projMatrix, &x);

        m3gTransformVec4(projMatrix, &y);

    }

#ifndef M3G_USE_NGL_API

    /* Store w after projection */

    if (eyeSpace != NULL) {

        eyeSpace->w = ot.w;

    }

#endif

    m3gScaleVec4(&ot, m3gRcp(ot.w));

    m3gScaleVec4(&x, m3gRcp(x.w));

    m3gScaleVec4(&y, m3gRcp(y.w));

    m3gSubVec4(&x, &ot);

    m3gSubVec4(&y, &ot);

    x.x = m3gLengthVec3((const Vec3*) &x);

    y.y = m3gLengthVec3((const Vec3*) &y);

    /* Non-scaled sprites take width from crop rectangle*/

    if (!sprite->scaled) {

        M3Gint viewport[4];

        if (ctx != NULL) {

            m3gGetViewport(ctx, viewport, viewport + 1, viewport + 2, viewport + 3);

        }

        else {

            /* Use a dummy viewport, this is only when picking and

               not rendering to anything. Values must represent a valid viewport */

            viewport[0] = 0;

            viewport[1] = 0;

            viewport[2] = 256;

            viewport[3] = 256;

        }

        x.x = m3gDivif (rIsect.width, viewport[2]);

        y.y = m3gDivif (rIsect.height, viewport[3]);

        ot.x = m3gSub(ot.x,

                      m3gDivif (2 * sprite->crop.x + sprite->crop.width - 2 * rIsect.x - rIsect.width,

                                viewport[2]));

        ot.y = m3gAdd(ot.y,

                      m3gDivif (2 * sprite->crop.y + sprite->crop.height - 2 * rIsect.y - rIsect.height,

                                viewport[3]));

    }

    else {

        /* Adjust width and height according to cropping rectangle */

        x.x = m3gDiv(x.x, (M3Gfloat) sprite->crop.width);

        y.y = m3gDiv(y.y, (M3Gfloat) sprite->crop.height);

        ot.x = m3gSub(ot.x,

                      m3gMul((M3Gfloat)(2 * sprite->crop.x + sprite->crop.width - 2 * rIsect.x - rIsect.width),

                             x.x));

        ot.y = m3gAdd(ot.y,

                      m3gMul((M3Gfloat)(2 * sprite->crop.y + sprite->crop.height - 2 * rIsect.y - rIsect.height),

                             y.y));

        x.x = m3gMul(x.x, (M3Gfloat) rIsect.width);

        y.y = m3gMul(y.y, (M3Gfloat) rIsect.height);

    }

#ifdef M3G_USE_NGL_API

    /* Store final Z */

    if (eyeSpace != NULL) {

        eyeSpace->w = ot.z;

    }

#endif

    /* Set up positions */

    vert[0 * 3 + 0] = (M3Gint) m3gMul(65536, m3gSub(ot.x, x.x));

    vert[0 * 3 + 1] = m3gRoundToInt(m3gAdd(m3gMul(65536, m3gAdd(ot.y, y.y)), 0.5f));

    vert[0 * 3 + 2] = m3gRoundToInt(m3gMul(65536, ot.z));

    vert[1 * 3 + 0] = vert[0 * 3 + 0];

    vert[1 * 3 + 1] = (M3Gint) m3gMul(65536, m3gSub(ot.y, y.y));

    vert[1 * 3 + 2] = vert[0 * 3 + 2];

    vert[2 * 3 + 0] = m3gRoundToInt(m3gAdd(m3gMul(65536, m3gAdd(ot.x, x.x)), 0.5f));

    vert[2 * 3 + 1] = vert[0 * 3 + 1];

    vert[2 * 3 + 2] = vert[0 * 3 + 2];

    vert[3 * 3 + 0] = vert[2 * 3 + 0];

    vert[3 * 3 + 1] = vert[1 * 3 + 1];

    vert[3 * 3 + 2] = vert[0 * 3 + 2];

    /* Set up texture coordinates */

    if (!(sprite->flip & FLIPX)) {

        texvert[0 * 2 + 0] = (M3Gshort) rIsect.x;

        texvert[1 * 2 + 0] = (M3Gshort) rIsect.x;

        texvert[2 * 2 + 0] = (M3Gshort) (rIsect.x + rIsect.width - adjust);

        texvert[3 * 2 + 0] = (M3Gshort) (rIsect.x + rIsect.width - adjust);

    }

    else {

        texvert[0 * 2 + 0] = (M3Gshort) (rIsect.x + rIsect.width - adjust);

        texvert[1 * 2 + 0] = (M3Gshort) (rIsect.x + rIsect.width - adjust);

        texvert[2 * 2 + 0] = (M3Gshort) rIsect.x;

        texvert[3 * 2 + 0] = (M3Gshort) rIsect.x;

    }

    if (!(sprite->flip & FLIPY)) {

        texvert[0 * 2 + 1] = (M3Gshort) rIsect.y;

        texvert[1 * 2 + 1] = (M3Gshort) (rIsect.y + rIsect.height - adjust);

        texvert[2 * 2 + 1] = (M3Gshort) rIsect.y;

        texvert[3 * 2 + 1] = (M3Gshort) (rIsect.y + rIsect.height - adjust);

    }

    else {

        texvert[0 * 2 + 1] = (M3Gshort) (rIsect.y + rIsect.height - adjust);

        texvert[1 * 2 + 1] = (M3Gshort) rIsect.y;

        texvert[2 * 2 + 1] = (M3Gshort) (rIsect.y + rIsect.height - adjust);

        texvert[3 * 2 + 1] = (M3Gshort) rIsect.y;

    }

    return M3G_TRUE;

}

/*!

 * \internal

 * \brief Overloaded Node method.

 *

 * Renders the sprite as a textured quad.

 *

 * \param self Mesh object

 * \param ctx current render context

 * \param patchIndex submesh index

 */

static void m3gSpriteDoRender(Node *self,

                              RenderContext *ctx,

                              const Matrix *toCamera,

                              M3Gint patchIndex)

{

    Sprite *sprite = (Sprite *)self;

    M3Gshort texvert[4 * 2];

    M3Gint vert[4 * 3];

    Vec4 eyeSpace;

    Image *imagePow2;

    M3G_UNREF(patchIndex);

    M3G_BEGIN_PROFILE(M3G_INTERFACE(self), M3G_PROFILE_SETUP_TRANSFORMS);

    if (!m3gGetSpriteCoordinates(sprite,

                                 ctx,

                                 m3gGetCurrentCamera(ctx),

                                 toCamera,

                                 vert,

                                 texvert,

                                 &eyeSpace,

                                 0)) {

        return;

    }

    M3G_END_PROFILE(M3G_INTERFACE(self), M3G_PROFILE_SETUP_TRANSFORMS);

    /* Get power of two image */

    imagePow2 = m3gGetPowerOfTwoImage(sprite->image);

    /* If NULL -> out of memory */

    if (imagePow2 == NULL) {

        return;

    }

    if (m3gGetColorMaskWorkaround(M3G_INTERFACE(ctx))) {

        m3gUpdateColorMaskStatus(ctx,

                                 m3gColorMask(sprite->appearance),

                                 m3gAlphaMask(sprite->appearance));

    }

    /* Disable unwanted state. Note that we do this BEFORE setting the

     * sprite color to avoid any problems with glColorMaterial  */

    m3gApplyDefaultMaterial();

    m3gApplyDefaultPolygonMode();

    /* Disable color array, normals and textures*/

    glDisableClientState(GL_COLOR_ARRAY);

    glDisableClientState(GL_NORMAL_ARRAY);

    m3gDisableTextures();

    /* Sprite image to texture unit 0 */

    glClientActiveTexture(GL_TEXTURE0);

    glActiveTexture(GL_TEXTURE0);

    glEnableClientState(GL_TEXTURE_COORD_ARRAY);

    glTexCoordPointer(2, GL_SHORT, 0, texvert);

    glEnable(GL_TEXTURE_2D);

    glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, (GLfixed) GL_MODULATE);

    m3gBindTextureImage(imagePow2,

                        M3G_FILTER_BASE_LEVEL,

                        m3gIsAccelerated(ctx) ? M3G_FILTER_LINEAR : M3G_FILTER_NEAREST);

    glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);

    glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

    glMatrixMode(GL_TEXTURE);

    glLoadIdentity();

    glScalef(m3gRcp((M3Gfloat) m3gGetWidth(sprite->image)),

             m3gRcp((M3Gfloat) m3gGetHeight(sprite->image)),

             1.f);

    glMatrixMode(GL_MODELVIEW);

    /* Apply fog and compositing mode */

#ifdef M3G_USE_NGL_API

    m3gApplySpriteFog(sprite->appearance->fog, eyeSpace.z, eyeSpace.w);

#else

    m3gApplyFog(sprite->appearance->fog);

#endif

    m3gApplyCompositingMode(sprite->appearance->compositingMode, ctx);

    {

        GLfixed a = (GLfixed) (0xff * sprite->totalAlphaFactor);

        a = (a >> (NODE_ALPHA_FACTOR_BITS - 8))

            + (a >> NODE_ALPHA_FACTOR_BITS)

            + (a >> (NODE_ALPHA_FACTOR_BITS + 7));

        glColor4x((GLfixed) 1 << 16, (GLfixed) 1 << 16, (GLfixed) 1 << 16, a);

    }

    /* Load vertices */

    glEnableClientState(GL_VERTEX_ARRAY);

    glVertexPointer(3, GL_FIXED, 0, vert);

    /* Store current matrices, then set up an identity modelview and

     * projection */

    m3gPushScreenSpace(ctx, M3G_FALSE);

#ifndef M3G_USE_NGL_API

    /* Transform the sprite vertices (in NDC) back to eye coordinates, so that 

       the fog distance will be calculated correctly in the OpenGL pipeline. */

    {

        GLfloat transform[16];

        GLfloat scaleW[16] = { 0.f, 0.f, 0.f, 0.f,

                               0.f, 0.f, 0.f, 0.f,

                               0.f, 0.f, 0.f, 0.f,

                               0.f, 0.f, 0.f, 0.f };

        Matrix invProjMatrix;

        const Matrix *projMatrix = m3gProjectionMatrix(m3gGetCurrentCamera(ctx));

        m3gMatrixInverse(&invProjMatrix, projMatrix);

		m3gGetMatrixColumns(&invProjMatrix, transform);

        glMatrixMode(GL_MODELVIEW);

        glMultMatrixf(transform);

        scaleW[0] = scaleW[5] = scaleW[10] = scaleW[15] = eyeSpace.w;

        glMultMatrixf(scaleW);

        glMatrixMode(GL_PROJECTION);

        m3gGetMatrixColumns(projMatrix, transform);

        glLoadMatrixf(transform);

    }

#endif

    /* Load indices -> draws the sprite */

    M3G_BEGIN_PROFILE(M3G_INTERFACE(ctx), M3G_PROFILE_NGL_DRAW);

    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);

    M3G_END_PROFILE(M3G_INTERFACE(ctx), M3G_PROFILE_NGL_DRAW);

    m3gReleaseTextureImage(imagePow2);

    /* Restore the previous modelview and projection */

    m3gPopSpace(ctx);

}

/*!

 * \internal

 * \brief Overloaded Node method.

 *

 * Picks a scaled sprite as 2D from viewport.

 *

 * \param self      Mesh object

 * \param mask      pick scope mask

 * \param ray       pick ray

 * \param ri        RayIntersection object

 * \param toGroup   transform to originating group

 * \retval          M3G_TRUE    continue pick

 * \retval          M3G_FALSE   abort pick

 */

static M3Gbool m3gSpriteRayIntersect(Node *self,

                                     M3Gint mask,

                                     M3Gfloat *ray,

                                     RayIntersection *ri,

                                     Matrix *toGroup)

{

    Sprite *sprite = (Sprite *)self;

    M3Gshort texvert[4 * 2];

    M3Gint vert[4 * 3];

    M3Gint x, y;

    Vec4 eyeSpace;

    M3Gfloat distance;

    M3G_UNREF(toGroup);

    /* Check that picking is possible */

    if (sprite->image == NULL ||

        sprite->appearance == NULL ||

        ri->camera == NULL ||

        !sprite->scaled ||

        sprite->crop.width == 0 ||

        sprite->crop.height == 0 ||

        (self->scope & mask) == 0) {

        return M3G_TRUE;

    }

    /* Calculate modelview transform, picking is possible without rendering */

    {

        Matrix toCamera;

        if (!m3gGetTransformTo(self, (Node *)ri->camera,

                               &toCamera)) {

            return M3G_FALSE;

        }

        if (!m3gGetSpriteCoordinates(sprite, NULL,

                                     (const Camera *)ri->camera, &toCamera,

                                     vert, texvert, &eyeSpace, 1)) {

            return M3G_TRUE;

        }

    }

    /* Do the pick in 2D, formula is from the spec and values are

       set to 16.16 fixed point format */

    x = m3gRoundToInt(m3gMul(2 * 65536, ri->x)) - 65536;

    y = 65536 - m3gRoundToInt(m3gMul(2 * 65536, ri->y));

    if (x >= vert[0 * 3 + 0] && x <= vert[2 * 3 + 0] &&

        y <= vert[0 * 3 + 1] && y >= vert[1 * 3 + 1] ) {

        distance = m3gDiv(m3gSub(eyeSpace.z, ray[6]), m3gSub(ray[7], ray[6]));

        if (distance <= 0 ||

            distance >= ri->tMin) return M3G_TRUE;

        ri->tMin = distance;

        ri->distance = ri->tMin;

        ri->submeshIndex = 0;

        x -= vert[0 * 3 + 0];

        y  = vert[0 * 3 + 1] - y;

        if (!(sprite->flip & FLIPX)) {

            ri->textureS[0] = m3gAdd(texvert[0 * 2 + 0],

                                     m3gDivif ((texvert[2 * 2 + 0] - texvert[0 * 2 + 0] + 1) * x,

                                               vert[2 * 3 + 0] - vert[0 * 3 + 0]));

        }

        else {

            ri->textureS[0] = m3gSub((M3Gfloat)(texvert[0 * 2 + 0] + 1),

                                     m3gDivif ((texvert[0 * 2 + 0] - texvert[2 * 2 + 0] + 1) * x,

                                               vert[2 * 3 + 0] - vert[0 * 3 + 0]));

        }

        if (!(sprite->flip & FLIPY)) {

            ri->textureT[0] = m3gAdd(texvert[0 * 2 + 1],

                                     m3gDivif ((texvert[1 * 2 + 1] - texvert[0 * 2 + 1] + 1) * y,

                                               vert[0 * 3 + 1] - vert[1 * 3 + 1]));

        }

        else {

            ri->textureT[0] = m3gSub((M3Gfloat)(texvert[0 * 2 + 1] + 1),

                                     m3gDivif ((texvert[0 * 2 + 1] - texvert[1 * 2 + 1] + 1) * y,

                                               vert[0 * 3 + 1] - vert[1 * 3 + 1]));

        }

        {

            /* Finally check against alpha */

            M3Gint threshold = 0, alpha;

            if (sprite->appearance->compositingMode) {

                threshold = (M3Gint)m3gMul(m3gGetAlphaThreshold(sprite->appearance->compositingMode), 256);

            }

            alpha = m3gGetAlpha(sprite->image, (M3Gint)ri->textureS[0], (M3Gint)ri->textureT[0]);

            if (alpha >= threshold) {

                /* Normalize texture coordinates */

                ri->textureS[0] = m3gDiv(ri->textureS[0], (M3Gfloat) sprite->width);

                ri->textureT[0] = m3gDiv(ri->textureT[0], (M3Gfloat) sprite->height);

                ri->textureS[1] = 0.f;

                ri->textureT[1] = 0.f;

                ri->normal[0] = 0.f;

                ri->normal[1] = 0.f;

                ri->normal[2] = 1.f;

                ri->intersected = self;

            }

        }

    }

    return M3G_TRUE;

}

/*!

 * \internal

 * \brief Overloaded Object3D method.

 *

 * \param self Sprite object

 * \param references array of reference objects

 * \return number of references

 */

static M3Gint m3gSpriteDoGetReferences(Object *self, Object **references)

{

    Sprite *sprite = (Sprite *)self;

    int num = m3gObjectDoGetReferences(self, references);

    if (sprite->image != NULL) {

        if (references != NULL)

            references[num] = (Object *)sprite->image;

        num++;

    }

    if (sprite->appearance != NULL) {

        if (references != NULL)

            references[num] = (Object *)sprite->appearance;

        num++;

    }

    return num;

}

/*!

 * \internal

 * \brief Overloaded Object3D method.

 */

static Object *m3gSpriteFindID(Object *self, M3Gint userID)

{

    Sprite *sprite = (Sprite *)self;

    Object *found = m3gObjectFindID(self, userID);

    if (!found && sprite->image != NULL) {

        found = m3gFindID((Object*) sprite->image, userID);

    }

    if (!found && sprite->appearance != NULL) {

        found = m3gFindID((Object*) sprite->appearance, userID);

    }

    return found;

}

/*!

 * \internal

 * \brief Overloaded Object3D method.

 *

 * \param originalObj original Sprite object

 * \param cloneObj pointer to cloned Sprite object

 * \param pairs array for all object-duplicate pairs

 * \param numPairs number of pairs

 */

static M3Gbool m3gSpriteDuplicate(const Object *originalObj,

                                  Object **cloneObj,

                                  Object **pairs,

                                  M3Gint *numPairs)

{

    Sprite *original = (Sprite *)originalObj;

    Sprite *clone;

    M3G_ASSERT(*cloneObj == NULL); /* no derived classes */

    /* Create the clone object */

    clone = (Sprite *)m3gCreateSprite(originalObj->interface,

                                      original->scaled,

                                      original->image,

                                      original->appearance);

    if (!clone) {

        return M3G_FALSE;

    }

    *cloneObj = (Object *)clone;

    /* Duplicate our own fields */

    clone->crop = original->crop;

    clone->flip = original->flip;

    /* Duplicate base class data */

    return m3gNodeDuplicate(originalObj, cloneObj, pairs, numPairs);

}

/*!

 * \internal

 * \brief Overloaded Object3D method.

 *

 * \param self Sprite object

 * \param time current world time

 * \return minimum validity

 */

static M3Gint m3gSpriteApplyAnimation(Object *self, M3Gint time)

{

    M3Gint validity, minValidity;

    Sprite *sprite = (Sprite *)self;

    Object *app;

    M3G_VALIDATE_OBJECT(sprite);

    minValidity = m3gObjectApplyAnimation(self, time);

    if (minValidity > 0) {

        app = (Object *) sprite->appearance;

        if (app != NULL) {

            validity = M3G_VFUNC(Object, app, applyAnimation)(app, time);

            minValidity = M3G_MIN(validity, minValidity);

        }

    }

    return minValidity;

}

/*!

 * \internal

 * \brief Initializes a Sprite object. See specification

 * for default values.

 *

 * \param m3g           M3G interface

 * \param sprite        Sprite object

 * \param scaled        scaled flag

 * \param appearance    Appearance object

 * \param image         Image2D object

 * \retval M3G_TRUE     Sprite initialized

 * \retval M3G_FALSE    initialization failed

 */

static M3Gbool m3gInitSprite(Interface *m3g,

                             Sprite *sprite,

                             M3Gbool scaled,

                             Appearance *appearance,

                             Image *image)

{

    /* Sprite is derived from node */

    m3gInitNode(m3g, &sprite->node, M3G_CLASS_SPRITE);

    sprite->node.hasRenderables = M3G_TRUE;

    m3gIncStat(m3g, M3G_STAT_RENDERABLES, 1);

    sprite->scaled = scaled;

    M3G_ASSIGN_REF(sprite->appearance, appearance);

    return m3gSetSpriteImage(sprite, image);

}

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

 * Virtual function table

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

static const NodeVFTable m3gvf_Sprite = {

    {

        {

            m3gSpriteApplyAnimation,

            m3gSpriteIsCompatible,

            m3gSpriteUpdateProperty,

            m3gSpriteDoGetReferences,

            m3gSpriteFindID,

            m3gSpriteDuplicate,

            m3gDestroySprite

        }

    },

    m3gNodeAlign,

    m3gSpriteDoRender,

    m3gSpriteGetBBox,

    m3gSpriteRayIntersect,

    m3gSpriteSetupRender,

    m3gNodeUpdateDuplicateReferences,

    m3gNodeValidate

};

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

 * Public API functions

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

/*!

 * \brief Creates a Sprite object.

 *

 * \param hInterface    M3G interface

 * \param scaled        scaled flag

 * \param hImage        Image2D object

 * \param hAppearance   Appearance object

 * \retval Sprite new Sprite object

 * \retval NULL Sprite creating failed

 */

M3G_API M3GSprite m3gCreateSprite(M3GInterface hInterface,

                                  M3Gbool scaled,

                                  M3GImage hImage,

                                  M3GAppearance hAppearance)

{

    Interface *m3g = (Interface *) hInterface;

    M3G_VALIDATE_INTERFACE(m3g);

    if (hImage == 0) {

        m3gRaiseError(m3g, M3G_NULL_POINTER);

        return NULL;

    }

    {

        Sprite *sprite =  m3gAllocZ(m3g, sizeof(Sprite));

        if (sprite != NULL) {

            if (!m3gInitSprite(m3g,

                               sprite,

                               scaled,

                               (Appearance *)hAppearance,

                               (Image *)hImage)) {

                M3G_ASSIGN_REF(sprite->image, NULL);

                M3G_ASSIGN_REF(sprite->appearance, NULL);

                m3gFree(m3g, sprite);

                return NULL;

            }

        }

        return (M3GSprite) sprite;

    }

}

/*!

 * \brief Get sprite scaled flag.

 *

 * \param handle        Sprite object

 * \retval M3G_TRUE     sprite is scaled

 * \retval M3G_FALSE    sprite is not scaled

 */

M3G_API M3Gbool m3gIsScaledSprite(M3GSprite handle)

{

    Sprite *sprite = (Sprite *) handle;

    M3G_VALIDATE_OBJECT(sprite);

    return sprite->scaled;

}

/*!

 * \brief Set sprite appearance.

 *

 * \param handle        Sprite object

 * \param hAppearance   Appearance object

 */

M3G_API void m3gSetSpriteAppearance(M3GSprite handle,

                                    M3GAppearance hAppearance)

{

    Sprite *sprite = (Sprite *) handle;

    M3G_VALIDATE_OBJECT(sprite);

    M3G_ASSIGN_REF(sprite->appearance, hAppearance);

}

/*!

 * \brief Set sprite image

 *

 * \param handle        Sprite object

 * \param hImage        Image2D object

 * \retval              M3G_TRUE image was set

 * \retval              M3G_FALSE failed to set image

 */

M3G_API M3Gbool m3gSetSpriteImage(M3GSprite handle, M3GImage hImage)

{

    Sprite *sprite = (Sprite *) handle;

    Image *image = (Image *)hImage;

    M3G_VALIDATE_OBJECT(sprite);

    if (image == NULL) {

        m3gRaiseError(M3G_INTERFACE(sprite), M3G_NULL_POINTER);

        return M3G_FALSE;

    }

    M3G_ASSIGN_REF(sprite->image, image);

    sprite->width = m3gGetWidth(image);

    sprite->height = m3gGetHeight(image);

    sprite->crop.x = 0;

    sprite->crop.y = 0;

    sprite->crop.width  = m3gClampInt(sprite->width,  0, M3G_MAX_TEXTURE_DIMENSION);

    sprite->crop.height = m3gClampInt(sprite->height, 0, M3G_MAX_TEXTURE_DIMENSION);

    sprite->flip = 0;

    return M3G_TRUE;

}

/*!

 * \brief Set sprite image crop rectangle.

 *

 * \param handle        Sprite object

 * \param cropX         crop upper left x

 * \param cropY         crop upper left y

 * \param width         crop width

 * \param height        crop height

 */

M3G_API void m3gSetCrop(M3GSprite handle,

                        M3Gint cropX, M3Gint cropY,

                        M3Gint width, M3Gint height)

{

    Sprite *sprite = (Sprite *) handle;

    M3G_VALIDATE_OBJECT(sprite);

    /* Check for illegal crop size */

    if (!m3gInRange(width,  -M3G_MAX_TEXTURE_DIMENSION, M3G_MAX_TEXTURE_DIMENSION) ||

        !m3gInRange(height, -M3G_MAX_TEXTURE_DIMENSION, M3G_MAX_TEXTURE_DIMENSION) ) {

        m3gRaiseError(M3G_INTERFACE(sprite), M3G_INVALID_VALUE);

        return;

    }

    sprite->crop.x = cropX;

    sprite->crop.y = cropY;

    if (width < 0) {

        sprite->crop.width = -width;

        sprite->flip |= FLIPX;

    }

    else {

        sprite->crop.width = width;

        sprite->flip &= ~FLIPX;

    }

    if (height < 0) {

        sprite->crop.height = -height;

        sprite->flip |= FLIPY;

    }

    else {

        sprite->crop.height = height;

        sprite->flip &= ~FLIPY;

    }

}

/*!

 * \brief Get sprite image crop parameter.

 *

 * \param handle        Sprite object

 * \param which         which crop parameter to return

 *                      \arg M3G_GET_CROPX

 *                      \arg M3G_GET_CROPY

 *                      \arg M3G_GET_CROPWIDTH

 *                      \arg M3G_GET_CROPHEIGHT

 * \return              image crop parameter