/*

* 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 com.nokia.mj.impl.rt.legacy.ToolkitInvoker;

import com.nokia.mj.impl.rt.legacy.ToolkitObserver;

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;

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

    // Instance data

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

    int handle;

    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;

    // this flag is for identification of image target types

    // - True for mutable off-screen images

    // - False for canvas/GameCanvas framebuffer

    private boolean isImageTarget;

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

    // - True - MBX is NOT present

    // - False - MBX is present

    private boolean isProperRenderer;

    // NGA specific change.

    // Identifies if 2D content drawn prior M3G content to canvas

    // needs to be uploaded to canvas EGL surface before

    // M3G binds to EGL surface.

    private boolean eglContentValid = false;

    // NGA specific change.

    // Class for storing and comparing

    // clip and viewport rectangles

    private class Rect

    {

        public int x;

        public int y;

        public int width;

        public int height;

        public Rect()

        {

            x = 0;

            y = 0;

            width = 0;

            height = 0;

        }

        public Rect(int x, int y, int width, int height)

        {

            this.x = x;

            this.y = y;

            this.width = width;

            this.height = height;

        }

        public boolean contains(Rect r)

        {

            return x <= r.x && y <= r.y &&

                   (x + width)  >= (r.x + r.width) &&

                   (y + height) >= (r.y + r.height);

        }

    };

    // NGA specific change.

    // Viewport and clip are saved to Java side

    // for checking if Background is used for clearing

    // entire canvas area.

    private Rect viewport;

    private Rect clip;

    private boolean ngaEnabled = false;

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

    // Constructor(s)

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

    /**

     *

     */

    public static final Graphics3D getInstance()

    {

        Interface instance = Interface.getInstance();

        synchronized (instance)

        {

            if (instance.isShutdownOngoing())

            {

                throw new RuntimeException("Graphics3D closed");

            }

            if (instance.graphics3D == null)

            {

                instance.graphics3D = new Graphics3D();

            }

            return instance.graphics3D;

        }

    }

    /**

     *

     */

    private Graphics3D()

    {

        ToolkitInvoker invoker = ToolkitInvoker.getToolkitInvoker();

        this.handle = _ctor(Interface.getHandle());

        _addRef(handle);

        try

        {

            isProperRenderer = _isProperRenderer(Interface.bindEventSource());

        }

        finally

        {

            Interface.releaseEventSource();

        }

        // NGA specific change.

        // Initializes the viewport and clipping rectangles

        this.viewport = new Rect();

        this.clip = new Rect();

        // Initializes NGA status - enabled or disabled

    /**

     *

     */

    void doDestroyNotify()

    {

        this.camera = null;

        this.lights = null;

    }

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

    // Public methods

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

    /**

     */

    public void bindTarget(java.lang.Object target)

    {

        bindTarget(target, true, 0);

    }

    /**

     *

     */

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

    {

        {

            {

                {

                    throw new IllegalArgumentException();

                }

            }

            {

            }

        }

    }

    /**

     *

     */

    public void releaseTarget()

    {

        {

            {

                {

                }

            }

            {

            }

        }

    }

    /**

     *

     */

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

        }

        // NGA specific change.

        if (ngaEnabled)

        {

            // Update the viewport info.

            viewport.x = x + offsetX;

            viewport.y = y + offsetY;

            viewport.width = width;

            viewport.height = height;

            _setViewport(handle, viewport.x, viewport.y, viewport.width, viewport.height);

        }

        else

        {

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

        }

    }

    /**

     *

     */

    public void clear(Background background)

    {

        integrityCheck();

        if (getTarget() == null)

        {

            throw new java.lang.IllegalStateException(

                "Graphics3D does not have a rendering target");

        }

        // NGA specific change.

        if (ngaEnabled)

        {

            checkBackgroundCleared(background);

        }

        try

        {

            _clear(Interface.bindEventSource(),

                   handle, background != null ? background.handle : 0);

        }

        finally

        {

            Interface.releaseEventSource();

        }

    }

    /**

     *

     */

    public void render(World world)

    {

        integrityCheck();

        // NGA specific change.

        if (ngaEnabled)

        {

            checkBackgroundCleared(world.getBackground());

        }

        try

        {

            _renderWorld(Interface.bindEventSource(), handle, world.handle);

        }

        finally

        {

            Interface.releaseEventSource();

        }

    }

    /**

     *

     */

    public void render(VertexBuffer vertices,

                       IndexBuffer primitives,

                       Appearance appearance,

                       Transform transform)

    {

        // Call rendering method with default visibility

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

        // NGA specific change.

        if (ngaEnabled)

        {

            updateEglContent();

        }

        try

        {

            _render(Interface.bindEventSource(),

                    handle,

                    vertices.handle,

                    primitives.handle,

                    appearance.handle,

                    transform != null ? transform.matrix : null,

                    scope);

        }

        finally

        {

            Interface.releaseEventSource();

        }

    }

    /**

     *

     */

    public void render(Node node, Transform transform)

    {

        if (!(node instanceof Mesh

                || node instanceof Sprite3D

                || node instanceof Group)

                && node != null)

        {

            throw new IllegalArgumentException();

        }

        integrityCheck();

        // NGA specific change.

        if (ngaEnabled)

        {

            updateEglContent();

        }

        try

        {

            _renderNode(Interface.bindEventSource(),

                        handle,

                        node.handle,

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

        }

        finally

        {

            Interface.releaseEventSource();

        }

    }

    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)

        {