/*

* 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 "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:

*

*/

package javax.microedition.m3g;

import javax.microedition.lcdui.Graphics;

import java.util.Hashtable;

import java.util.Vector;

import org.eclipse.swt.widgets.*;

import org.eclipse.swt.graphics.*;

import com.nokia.mj.impl.rt.support.ShutdownListener;

import com.nokia.mj.impl.rt.support.ApplicationUtils;

import com.nokia.mj.impl.nokialcdui.LCDUIInvoker;

public class Graphics3D

{

    //------------------------------------------------------------------

    // Static data

    //------------------------------------------------------------------

    public static final int ANTIALIAS   = 2;

    public static final int DITHER      = 4;

    public static final int TRUE_COLOR  = 8;

    // M3G 1.1

    public static final int OVERWRITE   = 16;

    // Singleton instances

    static Graphics3D s_instance = null;

    //------------------------------------------------------------------

    // Instance data

    //------------------------------------------------------------------

    int handle;

    int iSurfaceHandle;

    private Camera camera = null;

    private Vector lights = new Vector();

    private java.lang.Object currentTarget = null;

    private int offsetX, offsetY, hints = 0;

    private boolean depthEnabled = true;

    private Destroyer destroyer;

    private Interface iInterface;

    // this flag is for identification of image target types

    // - True for mutable off-screen images

    // - False for canvas/GameCanvas framebuffer

    private boolean iIsImageTarget;

    // this flag is for identification if MBX HW accelerator is present

    // - True - MBX is NOT present

    // - False - MBX is present

    private boolean iIsProperRenderer;

    private boolean iNativeInitialized = false;

    // Shutdown listener

    private class Destroyer implements ShutdownListener

    {

        Graphics3D target;

        Destroyer(Graphics3D g3d)

        {

            target = g3d;

            ApplicationUtils appUtils = ApplicationUtils.getInstance();

            appUtils.addShutdownListener(this);

        }

        // This method gets called when application is shuttingdown

        public void shuttingDown()

        {

            // Finalize native peer

            Platform.finalizeObject(target.handle, target.iInterface);

            // signal shutdown (set shutdown flag)

            // and remove references

            target.iInterface.signalShutdown();

            target.iInterface = null;

            target.camera = null;

            //target.s_instance = null;

            // All done, Call gc() and finalization to collect

            // remaining objects, thus zeroying liveObjects count

            // in interface instance

        }

    }

    //------------------------------------------------------------------

    // Constructor(s)

    //------------------------------------------------------------------

    public static final Graphics3D getInstance()

    {

        if (s_instance == null)

        {

            s_instance = new Graphics3D();

        }

        return s_instance;

    }

    private Graphics3D()

    {

        iInterface = Interface.getInstance();

        initNativePeer();

        // setup listener for singleton teardown

        destroyer = new Destroyer(this);

    }

    //------------------------------------------------------------------

    // Public methods

    //------------------------------------------------------------------

    /**

     */

    public void bindTarget(java.lang.Object target)

    {

        bindTarget(target, true, 0);

    }

    /**

     *

     */

    public void bindTarget(java.lang.Object target, boolean depth, int flags)

    {

        integrityCheck();

        if (currentTarget != null)

        {

            throw new IllegalStateException();

        }

        if (target == null)

        {

            throw new NullPointerException();

        }

        final int finalFlags = flags;

        final boolean finalDepth = depth;

        if (target instanceof org.eclipse.swt.graphics.GC)

        {

            {

                throw new IllegalArgumentException();

            }

            Platform.executeInUIThread(

                new M3gRunnable()

            {

                public void doRun()

                {

                    iIsImageTarget = _bindGraphics(

                                         handle,

                                         iSurfaceHandle,

                                         finalDepth, finalFlags,

                                         iIsProperRenderer);

                }

            });

        }

        else if (target instanceof Image2D)

        {

            Image2D img = (Image2D) target;

            offsetX = offsetY = 0;

            final int imageHandle = img.handle;

            Platform.executeInUIThread(

                new M3gRunnable()

            {

                public void doRun()

                {

                    _bindImage(handle, imageHandle, finalDepth, finalFlags);

                }

            });

            currentTarget = img;

        }

        else

        {

            throw new IllegalArgumentException();

        }

        hints = flags;

        depthEnabled = depth;

    }

    /**

     *

     */

    public void releaseTarget()

    {

        integrityCheck();

        if (currentTarget == null)

        {

            return;

        }

        if (currentTarget instanceof org.eclipse.swt.graphics.GC)

        {

            Platform.executeInUIThread(

                new M3gRunnable()

            {

                public void doRun()

                {

                    _releaseGraphics(handle,

                                     iSurfaceHandle, iIsImageTarget, iIsProperRenderer);

                }

            });

        }

        else if (currentTarget instanceof Graphics)

        {

                final Graphics finalG = (Graphics)currentTarget;

                Platform.executeInUIThread(

                    new M3gRunnable()

                {

                    public void doRun()

                    {

                        _releaseGraphics(handle,

                    }

                });

        }

        else if (currentTarget instanceof Image2D)

        {

            Platform.executeInUIThread(

                new M3gRunnable()

            {

                public void doRun()

                {

                    _releaseImage(handle);

                }

            });

        }

        else

        {

            throw new Error();

        }

        currentTarget = null;

        iSurfaceHandle = 0;

    }

    /**

     *

     */

    public void setViewport(int x, int y, int width, int height)

    {

        integrityCheck();

        if (width <= 0 || height <= 0

                || width  > Defs.MAX_VIEWPORT_DIMENSION

                || height > Defs.MAX_VIEWPORT_DIMENSION)

        {

            throw new IllegalArgumentException();

        }

        _setViewport(handle, x + offsetX, y + offsetY, width, height);

    }

    /**

     *

     */

    public void clear(Background background)

    {

        integrityCheck();

        final Background finalBackground = background;

        Platform.executeInUIThread(

            new M3gRunnable()

        {

            public void doRun()

            {

                _clear(handle, finalBackground != null ? finalBackground.handle : 0);

            }

        });

    }

    /**

     *

     */

    public void render(World world)

    {

        integrityCheck();

        final World finalWorld = world;

        Platform.executeInUIThread(

            new M3gRunnable()

        {

            public void doRun()

            {

                _renderWorld(handle, finalWorld.handle);

            }

        });

    }

    /**

     *

     */

    public void render(VertexBuffer vertices,

                       IndexBuffer primitives,

                       Appearance appearance,

                       Transform transform)

    {

        // Call rendering method with default visibility

        integrityCheck();

        render(vertices, primitives, appearance, transform, -1);

    }

    /**

     *

     */

    public void render(VertexBuffer vertices,

                       IndexBuffer primitives,

                       Appearance appearance,

                       Transform transform,

                       int scope)

    {

        // null pointer exceptions thrown automatically below

        integrityCheck();

        final VertexBuffer finalVertices = vertices;

        final IndexBuffer finalPrimitives = primitives;

        final Appearance finalAppearance = appearance;

        final Transform finalTransform = transform;

        final int finalScope = scope;

        Platform.executeInUIThread(

            new M3gRunnable()

        {

            public void doRun()

            {

                _render(handle,

                        finalVertices.handle,

                        finalPrimitives.handle,

                        finalAppearance.handle,

                        finalTransform != null ? finalTransform.matrix : null,

                        finalScope);

            }

        });

    }

    /**

     *

     */

    public void render(Node node, Transform transform)

    {

        if (!(node instanceof Mesh

                || node instanceof Sprite3D

                || node instanceof Group)

                && node != null)

        {

            throw new IllegalArgumentException();

        }

        integrityCheck();

        final Node finalNode = node;

        final Transform finalTransform = transform;

        Platform.executeInUIThread(

            new M3gRunnable()

        {

            public void doRun()

            {

                _renderNode(handle,

                            finalNode.handle,

                            finalTransform != null ? finalTransform.matrix : null);

            }

        });

    }

    public void setCamera(Camera camera, Transform transform)

    {

        integrityCheck();

        _setCamera(handle,

                   camera != null ? camera.handle : 0,

                   transform != null ? transform.matrix : null);

        this.camera = camera;

    }

    /**

     */

    public int addLight(Light light, Transform transform)

    {

        integrityCheck();

        int index = _addLight(handle,

                              light.handle,

                              transform != null ? transform.matrix : null);

        if (lights.size() < index + 1)

        {

            lights.setSize(index + 1);

        }

        lights.setElementAt(light, index);

        return index;

    }

    /**

     *

     */

    public void setLight(int index, Light light, Transform transform)

    {

        integrityCheck();

        _setLight(handle,

                  index,

                  light != null ? light.handle : 0,

                  transform != null ? transform.matrix : null);

        lights.setElementAt(light, index);

    }

    /**

     */

    public void resetLights()

    {

        integrityCheck();

        _resetLights(handle);

        lights.removeAllElements();

    }

    /**

     *

     */

    public static final Hashtable getProperties()

    {

        Hashtable props = new Hashtable();

        props.put("supportAntialiasing",          new java.lang.Boolean(

                      _isAASupported(Interface.getHandle())));

        props.put("supportTrueColor",             new java.lang.Boolean(Defs.supportTrueColor));

        props.put("supportDithering",             new java.lang.Boolean(Defs.supportDithering));

        props.put("supportMipmapping",            new java.lang.Boolean(Defs.supportMipmapping));

        props.put("supportPerspectiveCorrection", new java.lang.Boolean(Defs.supportPerspectiveCorrection));

        props.put("supportLocalCameraLighting",   new java.lang.Boolean(Defs.supportLocalCameraLighting));

        props.put("maxLights",                    new java.lang.Integer(Defs.MAX_LIGHTS));

        props.put("maxViewportWidth",             new java.lang.Integer(Defs.MAX_VIEWPORT_WIDTH));

        props.put("maxViewportHeight",            new java.lang.Integer(Defs.MAX_VIEWPORT_HEIGHT));

        props.put("maxViewportDimension",         new java.lang.Integer(Defs.MAX_VIEWPORT_DIMENSION));

        props.put("maxTextureDimension",          new java.lang.Integer(Defs.MAX_TEXTURE_DIMENSION));

        props.put("maxSpriteCropDimension",       new java.lang.Integer(Defs.MAX_TEXTURE_DIMENSION));

        props.put("numTextureUnits",              new java.lang.Integer(Defs.NUM_TEXTURE_UNITS));

        props.put("maxTransformsPerVertex",       new java.lang.Integer(Defs.MAX_TRANSFORMS_PER_VERTEX));

        // Extra properties

        props.put("m3gRelease",                   new java.lang.String("04_wk49"));

        return props;

    }

    /**

     *

     */

    public void setDepthRange(float near, float far)

    {

        integrityCheck();

        _setDepthRange(handle, near, far);

    }

    // M3G 1.1

    public Camera getCamera(Transform transform)

    {

        integrityCheck();

        if (transform != null)

        {

            _getViewTransform(handle, transform.matrix);

        }

        return (Camera) Object3D.getInstance(_getCamera(handle));

    }

    public float getDepthRangeFar()

    {