/*

* 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: M3G core API public interface

*

*/

#ifndef __M3G_CORE_H__

#define __M3G_CORE_H__

#if defined(__cplusplus)

extern "C" {

#endif

/*!

 * \file

 * \brief Public interface to the M3G core library

 *

 * This can be overlaid by an additional layer providing the actual

 * API for different languages; for the JSR184 API, this is the Java

 * binding layer.

 */

#endif

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

 * Enumerated constants

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

/*javax.microedition.m3g.AnimationTrack*/

#define M3G_ANIM_ALPHA          256

#define M3G_ANIM_AMBIENT_COLOR  257

#define M3G_ANIM_COLOR          258

#define M3G_ANIM_CROP           259

#define M3G_ANIM_DENSITY        260

#define M3G_ANIM_DIFFUSE_COLOR  261

#define M3G_ANIM_EMISSIVE_COLOR 262

#define M3G_ANIM_FAR_DISTANCE   263

#define M3G_ANIM_FIELD_OF_VIEW  264

#define M3G_ANIM_INTENSITY      265

#define M3G_ANIM_MORPH_WEIGHTS  266

#define M3G_ANIM_NEAR_DISTANCE  267

#define M3G_ANIM_ORIENTATION    268

#define M3G_ANIM_PICKABILITY    269

#define M3G_ANIM_SCALE          270

#define M3G_ANIM_SHININESS      271

#define M3G_ANIM_SPECULAR_COLOR 272

#define M3G_ANIM_SPOT_ANGLE     273

#define M3G_ANIM_SPOT_EXPONENT  274

#define M3G_ANIM_TRANSLATION    275

#define M3G_ANIM_VISIBILITY     276

/*javax.microedition.m3g.Background*/

#define M3G_BORDER              32

#define M3G_REPEAT              33

/*javax.microedition.m3g.Camera*/

#define M3G_GENERIC             48

#define M3G_PARALLEL            49

#define M3G_PERSPECTIVE         50

/*javax.microedition.m3g.CompositingMode*/

#define M3G_ALPHA_BLEND         64

#define M3G_ALPHA_ADD           65

#define M3G_MODULATE            66

#define M3G_MODULATE_X2         67

#define M3G_REPLACE             68

/*javax.microedition.m3g.Fog*/

#define M3G_EXPONENTIAL_FOG     80

#define M3G_LINEAR_FOG          81

/*javax.microedition.m3g.Graphics3D*/

#define M3G_ANTIALIAS_BIT       2

#define M3G_DITHER_BIT          4

#define M3G_TRUECOLOR_BIT       8

#define M3G_OVERWRITE_BIT       16

/*javax.microedition.m3g.Image2D*/

typedef enum 

{

    M3G_ALPHA           = 96,

    M3G_LUMINANCE       = 97,

    M3G_LUMINANCE_ALPHA = 98,

    M3G_RGB             = 99,

    M3G_RGBA            = 100

} M3GImageFormat;

/*javax.microedition.m3g.KeyframeSequence*/

#define M3G_LINEAR              176

#define M3G_SLERP               177

#define M3G_SPLINE              178

#define M3G_SQUAD               179

#define M3G_STEP                180

#define M3G_CONSTANT            192

#define M3G_LOOP                193

/*javax.microedition.m3g.Light*/

#define M3G_AMBIENT             128

#define M3G_DIRECTIONAL         129

#define M3G_OMNI                130

#define M3G_SPOT                131

/*javax.microedition.m3g.Material*/

#define M3G_AMBIENT_BIT         1024

#define M3G_DIFFUSE_BIT         2048

#define M3G_EMISSIVE_BIT        4096

#define M3G_SPECULAR_BIT        8192

/*javax.microedition.m3g.Node*/

#define M3G_NONE                144

#define M3G_ORIGIN              145

#define M3G_X_AXIS              146

#define M3G_Y_AXIS              147

#define M3G_Z_AXIS              148

/*javax.microedition.m3g.Object3D*/

typedef enum {    

    M3G_CLASS_ANIMATION_CONTROLLER = 1,

    M3G_CLASS_ANIMATION_TRACK      = 2,

    M3G_CLASS_APPEARANCE           = 3,

    M3G_CLASS_BACKGROUND           = 4,

    M3G_CLASS_CAMERA               = 5,

    M3G_CLASS_COMPOSITING_MODE     = 6,

    M3G_CLASS_FOG                  = 7,

    M3G_CLASS_GROUP                = 8,

    M3G_CLASS_IMAGE                = 9,

    M3G_CLASS_INDEX_BUFFER         = 10,

    M3G_CLASS_KEYFRAME_SEQUENCE    = 11,

    M3G_CLASS_LIGHT                = 12,

    M3G_CLASS_LOADER               = 13,

    M3G_CLASS_MATERIAL             = 14,

    M3G_CLASS_MESH                 = 15,

    M3G_CLASS_MORPHING_MESH        = 16,

    M3G_CLASS_POLYGON_MODE         = 17,

    M3G_CLASS_RENDER_CONTEXT       = 18,

    M3G_CLASS_SKINNED_MESH         = 19,

    M3G_CLASS_SPRITE               = 20,

    M3G_CLASS_TEXTURE              = 21,

    M3G_CLASS_VERTEX_ARRAY         = 22,

    M3G_CLASS_VERTEX_BUFFER        = 23,

    M3G_CLASS_WORLD                = 24,

    /* extra enumeration used for abstract classes */

    M3G_ABSTRACT_CLASS             = 0

} M3GClass;

/*javax.microedition.m3g.PolygonMode*/

#define M3G_CULL_BACK           160

#define M3G_CULL_FRONT          161

#define M3G_CULL_NONE           162

#define M3G_SHADE_FLAT          164

#define M3G_SHADE_SMOOTH        165

#define M3G_WINDING_CCW         168

#define M3G_WINDING_CW          169

/*javax.microedition.m3g.Texture2D*/

#define M3G_FILTER_BASE_LEVEL   208

#define M3G_FILTER_LINEAR       209

#define M3G_FILTER_NEAREST      210

#define M3G_FUNC_ADD            224

#define M3G_FUNC_BLEND          225

#define M3G_FUNC_DECAL          226

#define M3G_FUNC_MODULATE       227

#define M3G_FUNC_REPLACE        228

#define M3G_WRAP_CLAMP          240

#define M3G_WRAP_REPEAT         241

/*javax.microedition.m3g.Defs*/

#define M3G_GET_POSITIONS       0

#define M3G_GET_NORMALS         1

#define M3G_GET_COLORS          2

#define M3G_GET_TEXCOORDS0      3

#define M3G_GET_CROPX           0

#define M3G_GET_CROPY           1

#define M3G_GET_CROPWIDTH       2

#define M3G_GET_CROPHEIGHT      3

#define M3G_GET_MODEX           0

#define M3G_GET_MODEY           1

#define M3G_SETGET_COLORCLEAR   0

#define M3G_SETGET_DEPTHCLEAR   1

#define M3G_GET_NEAR            0

#define M3G_GET_FAR             1

#define M3G_SETGET_RENDERING    0

#define M3G_SETGET_PICKING      1

#define M3G_GET_CONSTANT        0

#define M3G_GET_LINEAR          1

#define M3G_GET_QUADRATIC       2

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

/* Object usage flag bits

 *

 * Currently only used for Image

 */

/*! \brief Specifies that an object can be written to at any time */

#define M3G_DYNAMIC             0x0001

/*! \brief Specifies that an object can only be written to prior to

 *  its first use (default) */

#define M3G_STATIC              0x0002

/*! \brief Specifies that an Image can be rendered to (implies

 *  M3G_DYNAMIC) */

#define M3G_RENDERING_TARGET    0x0004

/*!

 * \brief Specifies that an Image is paletted

 */

#define M3G_PALETTED            0x0008

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

/* Buffer bit constants */

#define M3G_COLOR_BUFFER_BIT        0x0001

#define M3G_DEPTH_BUFFER_BIT        0x0002

#define M3G_STENCIL_BUFFER_BIT      0x0004

#define M3G_MULTISAMPLE_BUFFER_BIT  0x0008

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

/* Pixel (output/texture) formats

 */

typedef enum {

    M3G_L8,

    M3G_A8,

    M3G_LA8,

    M3G_LA4,

    M3G_RGB8,

    M3G_RGB8_32,

    M3G_BGR8_32,

    M3G_RGB4,

    M3G_RGB565,

    M3G_RGBA8,

    M3G_BGRA8,

    M3G_ARGB8,

    M3G_RGBA4,

    M3G_RGB5A1,

    M3G_PALETTE8_RGB8,

    M3G_PALETTE8_RGB8_32,

    M3G_PALETTE8_RGBA8,

    M3G_NO_FORMAT

} M3GPixelFormat;

/* Errors */

typedef enum {

    M3G_NO_ERROR = 0x00,

    M3G_INVALID_VALUE,

    M3G_INVALID_ENUM,

    M3G_INVALID_OPERATION,

    M3G_INVALID_OBJECT,

    M3G_INVALID_INDEX,

    M3G_OUT_OF_MEMORY,

    M3G_NULL_POINTER,

    M3G_ARITHMETIC_ERROR,

    M3G_IO_ERROR

} M3GError;

/* Supported types of rendering primitives

 *

 * These match GL enums directly.

 */

typedef enum {

    M3G_TRIANGLE_STRIPS = 0x05

    /*M3G_TRIANGLES,

      M3G_TRIANGLE_FANS*/

} M3Gprimitive;

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

/*! \brief Supported input data types

 *

 * These can be converted to/from OpengGL type enums by adding 0x1400.

 */

typedef enum {

    M3G_BYTE    = 0x00,

    M3G_UBYTE,

    M3G_SHORT,

    M3G_USHORT,

    M3G_INT,

    M3G_UINT,

    M3G_FLOAT

} M3Gdatatype;

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

/*! \brief Profiling statistics */

typedef enum {

    M3G_STAT_CULLING_TESTS,

    M3G_STAT_FLOPS,

    M3G_STAT_MEMORY_ALLOCS,

    M3G_STAT_MEMORY_LOCKS,

    M3G_STAT_RENDER_NODES,

    M3G_STAT_RENDER_NODES_CULLED,

    M3G_STAT_RENDER_NODES_DRAWN,

    M3G_STAT_TCACHE_COMPOSITE_COLLISIONS,

    M3G_STAT_TCACHE_COMPOSITE_HITS,

    M3G_STAT_TCACHE_COMPOSITE_INSERTS,

    M3G_STAT_TCACHE_COMPOSITE_MISSES,

    M3G_STAT_TCACHE_PATH_COLLISIONS,

    M3G_STAT_TCACHE_PATH_FLUSHES,

    M3G_STAT_TCACHE_PATH_HITS,

    M3G_STAT_TCACHE_PATH_INSERTS,

    M3G_STAT_TCACHE_PATH_MISSES,

    M3G_PROFILE_ALIGN,

    M3G_PROFILE_ANIM,

    M3G_PROFILE_BINDTORELEASE,

    M3G_PROFILE_COMMIT,

    M3G_PROFILE_LOADER_DECODE,

    M3G_PROFILE_MORPH,

    M3G_PROFILE_NGL_DRAW,

    M3G_PROFILE_PICK,

    M3G_PROFILE_RELEASETOBIND,

    M3G_PROFILE_SETUP,

    M3G_PROFILE_SETUP_SORT,

    M3G_PROFILE_SETUP_TRANSFORMS,

    M3G_PROFILE_SKIN,

    M3G_PROFILE_TCACHE,

    M3G_PROFILE_TRANSFORM_INVERT,

    M3G_PROFILE_TRANSFORM_TO,

    M3G_PROFILE_VALIDATE,

    M3G_PROFILE_VFC_TEST,

    M3G_PROFILE_VFC_UPDATE,

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

    M3G_STAT_CUMULATIVE, /* the rest are not cleared automatically */

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

    M3G_STAT_BOUNDING_BOXES,

    M3G_STAT_MEMORY_ALLOCATED,

    M3G_STAT_MEMORY_MALLOC_BYTES,

    M3G_STAT_MEMORY_MALLOC_PEAK,

    M3G_STAT_MEMORY_OBJECT_BYTES,

    M3G_STAT_MEMORY_OBJECT_PEAK,

    M3G_STAT_MEMORY_PEAK,

    M3G_STAT_OBJECTS,

    M3G_STAT_RENDERABLES,

    M3G_STAT_RENDERQUEUE_SIZE,

    M3G_STAT_TCACHE_COMPOSITE_LOAD,

    M3G_STAT_TCACHE_PATH_LOAD,

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

    M3G_STAT_MAX

} M3Gstatistic;

#define MIN_PROFILE_STAT    M3G_PROFILE_ALIGN

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

 * Portable numeric types

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

typedef int             M3Gint;     /*!< \brief 32-bit signed integer   */

typedef short           M3Gshort;   /*!< \brief 16-bit signed integer   */

typedef signed char     M3Gbyte;    /*!< \brief  8-bit signed integer   */

typedef unsigned        M3Guint;    /*!< \brief 32-bit unsigned integer */

typedef unsigned short  M3Gushort;  /*!< \brief 16-bit unsigned integer */

typedef unsigned char   M3Gubyte;   /*!< \brief  8-bit unsigned integer */

typedef float           M3Gfloat;   /*!< \brief 32-bit IEEE float */

typedef M3Gint   M3Genum;

typedef M3Guint  M3Gbitmask;

typedef M3Guint  M3Gbool;

typedef M3Gint  M3Gsizei;

/* Boolean values */

#define M3G_TRUE        ((M3Gbool)1)

#define M3G_FALSE       ((M3Gbool)0)

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

 * Object handle types

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

typedef struct M3GInterfaceImpl *M3GInterface;

typedef struct M3GLoaderImpl *M3GLoader;

typedef struct M3GObjectImpl *M3GObject;

    typedef struct M3GAnimationControllerImpl *M3GAnimationController;

    typedef struct M3GAnimationTrackImpl *M3GAnimationTrack;

    typedef struct M3GAppearanceImpl *M3GAppearance;

    typedef struct M3GBackgroundImpl *M3GBackground;

    typedef struct M3GCompositingModeImpl *M3GCompositingMode;

    typedef struct M3GFogImpl *M3GFog;

    typedef struct M3GImageImpl *M3GImage;

    typedef struct M3GIndexBufferImpl *M3GIndexBuffer;

    typedef struct M3GKeyframeSequenceImpl *M3GKeyframeSequence;

    typedef struct M3GMaterialImpl *M3GMaterial;

    typedef struct M3GTransformableImpl *M3GTransformable;

        typedef struct M3GNodeImpl *M3GNode;

            typedef struct M3GCameraImpl *M3GCamera;

            typedef struct M3GGroupImpl *M3GGroup;

                typedef struct M3GWorldImpl *M3GWorld;

            typedef struct M3GLightImpl *M3GLight;

            typedef struct M3GMeshImpl *M3GMesh;

                typedef struct M3GMorphingMeshImpl *M3GMorphingMesh;

                typedef struct M3GSkinnedMeshImpl *M3GSkinnedMesh;

            typedef struct M3GSpriteImpl *M3GSprite;

        typedef struct M3GTextureImpl *M3GTexture;

    typedef struct M3GPolygonModeImpl *M3GPolygonMode;

    typedef struct M3GRenderContextImpl *M3GRenderContext;

    typedef struct M3GVertexArrayImpl *M3GVertexArray;

    typedef struct M3GVertexBufferImpl *M3GVertexBuffer;

typedef /*@abstract@*/ M3Gint M3GMemObject;

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

 * Abstracted OpenGL rendering target types

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

typedef /*@abstract@*/ M3Guint M3GNativeBitmap;

typedef /*@abstract@*/ M3Guint M3GNativeWindow;

typedef /*@abstract@*/ M3Guint M3GEGLSurface;

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

 * Math API

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

/* -------- Data types -------- */

/*!

 * \brief An optimized 4x4 matrix class.

 *

 * \note This is an abstract type, and only declared here so that it

 * can be instantiated on the stack.  The internal format may change

 * in the future.

 */

typedef struct

{

    /* If you change this struct be sure to check the

     * structure size against the array size in Transform.java!! */

    M3Gfloat elem[16];

    M3Guint mask;

    M3Guint classified  : 1;

    M3Guint complete    : 1;

} M3GMatrix;

/*!

 * \brief A 3-vector class

 */

typedef struct {

    M3Gfloat x, y, z;

} M3GVec3;

/*!

 * \brief A 4-vector class

 */

typedef struct {

    M3Gfloat x, y, z, w;

} M3GVec4;

/*!

 * \brief A quaternion class

 */

typedef struct {

    M3Gfloat x, y, z, w;

} M3GQuat;

/*!

 * \brief A rectangle

 */

typedef struct {

	M3Gint x;

	M3Gint y;

	M3Gint width;

	M3Gint height;

} M3GRectangle;

/* -------- Interpolation -------- */

M3G_API void m3gLerp    (M3Gint size,

                         M3Gfloat *vec,

                         M3Gfloat s,

                         const M3Gfloat *start, const M3Gfloat *end);

M3G_API void m3gHermite (M3Gint size,

                         M3Gfloat *vec,

                         M3Gfloat s,

                         const M3Gfloat *start, const M3Gfloat *end,

                         const M3Gfloat *tStart, const M3Gfloat *tEnd);

M3G_API void m3gSlerpQuat(M3GQuat *quat,

                          M3Gfloat s,

                          const M3GQuat *q0, const M3GQuat *q1);

M3G_API void m3gSquadQuat(M3GQuat *quat,

                          M3Gfloat s,

                          const M3GQuat *q0, const M3GQuat *a,

                          const M3GQuat *b, const M3GQuat *q1);

/* -------- Matrix, vector & quaternion operations -------- */

/* Matrix */

/* shorthand names for the OpenGL style functions */

#define m3gRotateMatrix         m3gPostRotateMatrix

#define m3gRotateMatrixQuat     m3gPostRotateMatrixQuat

#define m3gTranslateMatrix      m3gPostTranslateMatrix

#define m3gScaleMatrix          m3gPostScaleMatrix

#define m3gMulMatrix            m3gPostMultiplyMatrix

/* ...and second names for the matrix-matrix multipliers */

#define m3gLeftMulMatrix        m3gPreMultiplyMatrix

#define m3gRightMulMatrix       m3gPostMultiplyMatrix

M3G_API void    m3gCopyMatrix           (M3GMatrix *dst, const M3GMatrix *src);

M3G_API void    m3gGetMatrixColumn      (const M3GMatrix *mtx, M3Gint col, M3GVec4 *dst);

M3G_API void    m3gGetMatrixColumns     (const M3GMatrix *mtx, M3Gfloat *dst);

M3G_API void    m3gGetMatrixRow         (const M3GMatrix *mtx, M3Gint row, M3GVec4 *dst);

M3G_API void    m3gGetMatrixRows        (const M3GMatrix *mtx, M3Gfloat *dst);

M3G_API void    m3gIdentityMatrix       (M3GMatrix *mtx);

M3G_API M3Gbool m3gInvertMatrix         (M3GMatrix *mtx);

M3G_API M3Gbool m3gMatrixInverse        (M3GMatrix *mtx, const M3GMatrix *other);

M3G_API void    m3gMatrixTranspose      (M3GMatrix *mtx, const M3GMatrix *other);

M3G_API M3Gbool m3gInverseTranspose     (M3GMatrix *mtx, const M3GMatrix *other);

M3G_API void    m3gMatrixProduct        (M3GMatrix *dst, const M3GMatrix *left, const M3GMatrix *right);

M3G_API void    m3gPostMultiplyMatrix   (M3GMatrix *mtx, const M3GMatrix *other);

M3G_API void    m3gPostRotateMatrix     (M3GMatrix *mtx, M3Gfloat angle, M3Gfloat ax, M3Gfloat ay, M3Gfloat az);

M3G_API void    m3gPostRotateMatrixQuat (M3GMatrix *mtx, const M3GQuat *quat);

M3G_API void    m3gPostScaleMatrix      (M3GMatrix *mtx, M3Gfloat sx, M3Gfloat sy, M3Gfloat sz);