/*

 * Copyright 2005-2007 Sun Microsystems, Inc.  All Rights Reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 */

package sun.java2d.d3d;

import java.awt.AlphaComposite;

import java.awt.GraphicsConfiguration;

import java.awt.Image;

import java.awt.Transparency;

import java.awt.image.ColorModel;

import java.awt.image.DirectColorModel;

import sun.awt.SunHints;

import sun.awt.Win32GraphicsConfig;

import sun.awt.Win32GraphicsDevice;

import sun.awt.image.SurfaceManager;

import sun.java2d.InvalidPipeException;

import sun.java2d.SunGraphics2D;

import sun.java2d.SurfaceData;

import sun.java2d.SurfaceDataProxy;

import sun.java2d.loops.GraphicsPrimitive;

import sun.java2d.loops.SurfaceType;

import sun.java2d.pipe.PixelToShapeConverter;

import sun.java2d.pipe.TextPipe;

import sun.java2d.windows.Win32OffScreenSurfaceData;

import sun.java2d.windows.Win32SurfaceData;

import sun.java2d.windows.WinVolatileSurfaceManager;

import sun.java2d.windows.WindowsFlags;

import static sun.java2d.windows.Win32SurfaceData.*;

public class D3DSurfaceData extends Win32OffScreenSurfaceData {

    // properties of a surface

    /**

     * This property is used for a back-buffer surface

     */

    public static final int D3D_ATTACHED_SURFACE = (1 << 15);

    /**

     * A surface with this property can be used as a Direct3D rendering

     * destination.

     */

    public static final int D3D_RENDER_TARGET    = (1 << 16);

    public static final int

        D3D_INVALID_SURFACE    = 0;

    /**

     * Surface is a Direct3D plain surface (not a texture).

     * Plain surface can be used as render target.

     * VolatileImages typically use plain surfaces as their hardware

     * accelerated surfaces.

     */

    public static final int

        D3D_PLAIN_SURFACE      = (1 << 0) | D3D_RENDER_TARGET;

    /**

     * Direct3D texture. Mostly used for cached accelerated surfaces.

     * Surfaces of this type can be copied from using hardware acceleration

     * by using texture mapping.

     */

    public static final int

        D3D_TEXTURE_SURFACE    = (1 << 1);

    /**

     * Direct3D Backbuffer surface - an attached surface. Used for

     * multibuffered BufferStrategies.

     */

    public static final int

        D3D_BACKBUFFER_SURFACE = D3D_PLAIN_SURFACE | D3D_ATTACHED_SURFACE;

    /**

     * Render-to-texture. A texture which can also be a render target.

     * Combines the benefits of textures (fast copies-from) and

     * backbuffers or plain surfaces (hw-accelerated rendering to the surface)

     */

    public static final int

        D3D_RTT_SURFACE        = D3D_TEXTURE_SURFACE | D3D_RENDER_TARGET;

    // supported texture pixel formats

    public static final int PF_INVALID         =  0;

    public static final int PF_INT_ARGB        =  1;

    public static final int PF_INT_RGB         =  2;

    public static final int PF_INT_RGBX        =  3;

    public static final int PF_INT_BGR         =  4;

    public static final int PF_USHORT_565_RGB  =  5;

    public static final int PF_USHORT_555_RGB  =  6;

    public static final int PF_USHORT_555_RGBX =  7;

    public static final int PF_INT_ARGB_PRE    =  8;

    public static final int PF_USHORT_4444_ARGB=  9;

    public static final String

        DESC_INT_ARGB_D3D         = "Integer ARGB D3D with translucency";

    public static final String

        DESC_USHORT_4444_ARGB_D3D = "UShort 4444 ARGB D3D with translucency";

    /**

     * Surface type for texture destination.  We cannot render textures to

     * the screen because Direct3D is not clipped by the window's clip list,

     * so we only enable the texture blit loops for copies to offscreen

     * accelerated surfaces.

     */

    public static final String

        DESC_DEST_D3D           = "D3D render target";

    public static final SurfaceType D3DSurface =

        SurfaceType.Any.deriveSubType("Direct3D Surface");

    public static final SurfaceType D3DTexture =

        D3DSurface.deriveSubType("Direct3D Texture");

    /**

     * D3D destination surface types (derive from offscreen dd surfaces).

     * Note that all of these surfaces have the same surface description;

     * we do not care about the depth of the surface since texture ops

     * support multiple depths.

     */

    public static final SurfaceType IntRgbD3D =

        IntRgbDD.deriveSubType(DESC_DEST_D3D);

    public static final SurfaceType IntRgbxD3D =

        IntRgbxDD.deriveSubType(DESC_DEST_D3D);

    public static final SurfaceType Ushort565RgbD3D =

        Ushort565RgbDD.deriveSubType(DESC_DEST_D3D);

    public static final SurfaceType Ushort555RgbxD3D =

        Ushort555RgbxDD.deriveSubType(DESC_DEST_D3D);

    public static final SurfaceType Ushort555RgbD3D =

        Ushort555RgbDD.deriveSubType(DESC_DEST_D3D);

    // REMIND: Is it possible to have d3d accelerated on this type of surface?

    public static final SurfaceType ThreeByteBgrD3D =

        ThreeByteBgrDD.deriveSubType(DESC_DEST_D3D);

    public static final SurfaceType IntArgbD3D =

        SurfaceType.IntArgb.deriveSubType(DESC_INT_ARGB_D3D);

    public static final SurfaceType Ushort4444ArgbD3D =

        SurfaceType.Ushort4444Argb.deriveSubType(DESC_USHORT_4444_ARGB_D3D);

    // Textures we can render to using d3d

    public static final SurfaceType IntRgbD3D_RTT =

        IntRgbD3D.deriveSubType(DESC_DEST_D3D);

    public static final SurfaceType IntRgbxD3D_RTT =

        IntRgbxD3D.deriveSubType(DESC_DEST_D3D);

    public static final SurfaceType Ushort565RgbD3D_RTT =

        Ushort565RgbD3D.deriveSubType(DESC_DEST_D3D);

    public static final SurfaceType Ushort555RgbxD3D_RTT =

        Ushort555RgbxD3D.deriveSubType(DESC_DEST_D3D);

    public static final SurfaceType Ushort555RgbD3D_RTT =

        Ushort555RgbD3D.deriveSubType(DESC_DEST_D3D);

    public static final SurfaceType Ushort4444ArgbD3D_RTT =

        Ushort4444ArgbD3D.deriveSubType(DESC_DEST_D3D);

    public static final SurfaceType IntArgbD3D_RTT =

        IntArgbD3D.deriveSubType(DESC_DEST_D3D);

    public static final SurfaceType ThreeByteBgrD3D_RTT =

        ThreeByteBgrD3D.deriveSubType(DESC_DEST_D3D);

    // the type of this surface - texture, plain, back-buffer

    protected int type;

    protected int pixelFormat;

    private D3DContext d3dContext;

    protected static D3DRenderer d3dPipe;

    protected static PixelToShapeConverter d3dTxPipe;

    protected static D3DTextRenderer d3dTextPipe;

    protected static D3DDrawImage d3dDrawImagePipe;

    private native void initOps(int depth, int transparency);

    static {

        if (WindowsFlags.isD3DEnabled()) {

            D3DBlitLoops.register();

            D3DMaskFill.register();

        }

        d3dPipe = new D3DRenderer();

        d3dTxPipe = new PixelToShapeConverter(d3dPipe);

        d3dTextPipe = new D3DTextRenderer();

        d3dDrawImagePipe = new D3DDrawImage();

        if (GraphicsPrimitive.tracingEnabled()) {

            d3dPipe = d3dPipe.traceWrapD3D();

            d3dTextPipe = d3dTextPipe.traceWrap();

        }

    }

    @Override

    public SurfaceDataProxy makeProxyFor(SurfaceData srcData) {

        //D3D may be eliminated soon so no Proxy was created for it...

        //return D3DSurfaceDataProxy.createProxy(srcData, graphicsConfig);

        return SurfaceDataProxy.UNCACHED;

    }

    /**

     * Non-public constructor.  Use createData() to create an object.

     *

     * This constructor is used to house the common construction

     * code shared between the creation of D3DSurfaceData objects

     * and subclasses of D3DSurfaceData (such as D3DBackBufferSD).

     *

     * It calls the common constructor in the parent, and then

     * initializes other shared D3D data.

     */

    protected D3DSurfaceData(int width, int height,

                             int d3dSurfaceType,

                             SurfaceType sType, ColorModel cm,

                             GraphicsConfiguration gc,

                             Image image, int transparency)

    {

        super(width, height, sType, cm, gc, image, transparency);

        this.type = d3dSurfaceType;

    }

    /**

     * Private constructor.  Use createData() to create an object.

     *

     * This constructor calls the common constructor above and then

     * performs the specific initialization of the D3DSurface.

     */

    private D3DSurfaceData(int width, int height,

                           int d3dSurfaceType,

                           SurfaceType sType, ColorModel cm,

                           GraphicsConfiguration gc,

                           Image image, int transparency,

                           int screen)

    {

        this(width, height, d3dSurfaceType, sType, cm, gc, image, transparency);

        pixelFormat = initSurface(width, height, screen,

                                  null /*parent SurfaceData*/);

    }

    public static D3DSurfaceData createData(int width, int height,

                                            int d3dSurfaceType,

                                            ColorModel cm,

                                            GraphicsConfiguration gc,

                                            Image image)

    {

        Win32GraphicsDevice gd = (Win32GraphicsDevice)gc.getDevice();

        // After a display change ddInstance may not be

        // recreated yet, and in this case isD3DEnabledOnDevice will

        // return false, until someone attempted to recreate the

        // primary.

        if (!gd.isD3DEnabledOnDevice()) {

            return null;

        }

        return new D3DSurfaceData(width, height,

                                  d3dSurfaceType,

                                  getSurfaceType(gc, cm, d3dSurfaceType),

                                  cm, gc, image,

                                  cm.getTransparency(), gd.getScreen());

    }

    int getPixelFormat() {

        return pixelFormat;

    }

    static SurfaceType getSurfaceType(GraphicsConfiguration gc,

                                      ColorModel cm,

                                      int d3dSurfaceType)

    {

        if (d3dSurfaceType == D3D_TEXTURE_SURFACE) {

            // for non-rtt textures we have only one surface type

            return D3DTexture;

        } else {

            int pixelSize = cm.getPixelSize();

            Win32GraphicsDevice gd = (Win32GraphicsDevice)gc.getDevice();

            int transparency = cm.getTransparency();

            // We'll attempt to use render-to-texture if render target is

            // requested, but it's not a back-buffer and we support RTT

            // for this configuration.

            boolean useRTT =

                ((d3dSurfaceType & D3D_RENDER_TARGET) != 0) &&

                ((d3dSurfaceType & D3D_BACKBUFFER_SURFACE) == 0) &&

                gd.getD3DContext().isRTTSupported();

            // if there's no RTT available, we can't accelerate non-opaque

            // surfaces, so we return null.

            if (transparency == Transparency.TRANSLUCENT ||

                transparency == Transparency.BITMASK)

            {

                if (pixelSize == 16) {

                    return useRTT ? Ushort4444ArgbD3D_RTT :

                        null/*Ushort4444ArgbD3D*/;

                } else {

                    return useRTT ? IntArgbD3D_RTT : null/*IntArgbD3D*/;

                }

            } else {

                // it's an opaque surface, either a VI or a back-buffer

                switch (pixelSize) {

                case 32:

                case 24:

                    if (cm instanceof DirectColorModel) {

                        if (((DirectColorModel)cm).getRedMask() == 0xff0000) {

                            return useRTT ? IntRgbD3D_RTT : IntRgbD3D;

                        } else {

                            return useRTT ? IntRgbxD3D_RTT : IntRgbxD3D;

                        }

                    } else {

                        return useRTT ? ThreeByteBgrD3D_RTT : ThreeByteBgrD3D;

                    }

                case 15:

                    return useRTT ? Ushort555RgbD3D_RTT : Ushort555RgbD3D;

                case 16:

                    if ((cm instanceof DirectColorModel) &&

                        (((DirectColorModel)cm).getBlueMask() == 0x3e))

                    {

                        return useRTT ? Ushort555RgbxD3D_RTT : Ushort555RgbxD3D;

                    } else {

                        return useRTT ? Ushort565RgbD3D_RTT : Ushort565RgbD3D;

                    }

                case 8: // not supported

                default:

                    throw new sun.java2d.InvalidPipeException("Unsupported bit " +

                                                              "depth: " +

                                                              cm.getPixelSize());

                }

            }

        }

    }

    private native int initOffScreenSurface(long pCtx,

                                            long pData, long parentPdata,

                                            int width, int height,

                                            int type, int screen);

    protected int initSurface(int width, int height, int screen,

                              Win32SurfaceData parentData)

    {

        int pFormat = PF_INVALID;

        synchronized (D3DContext.LOCK) {

            long pData = getNativeOps();

            long pDataParent = 0L;

            if (parentData != null) {

                pDataParent = parentData.getNativeOps();

            }

            D3DContext d3dContext = getContext();

            long pCtx = d3dContext.getNativeContext();

            // native context could be 0 if the context is currently invalid,

            // so attempt to revalidate

            if (pCtx == 0) {

                d3dContext.reinitNativeContext();

                pCtx = d3dContext.getNativeContext();

            }

            if (pData != 0 && pCtx != 0) {

                pFormat = initOffScreenSurface(pCtx,

                                               pData, pDataParent,

                                               width, height, type, screen);

            } else {

                // if the context can't be restored, give up for now.

                throw new InvalidPipeException("D3DSD.initSurface: pData " +

                                               "or pCtx is null");

            }

        }

        return pFormat;

    }

    @Override

    public void validatePipe(SunGraphics2D sg2d) {

        // we don't support COMP_XOR yet..

        if (sg2d.compositeState < sg2d.COMP_XOR) {

            TextPipe textpipe;

            boolean validated = false;

            if (((sg2d.compositeState <= sg2d.COMP_ISCOPY &&

                  sg2d.paintState <= sg2d.PAINT_ALPHACOLOR) ||

                 (sg2d.compositeState == sg2d.COMP_ALPHA &&

                  sg2d.paintState <= sg2d.PAINT_ALPHACOLOR &&

                  (((AlphaComposite)sg2d.composite).getRule() ==

                   AlphaComposite.SRC_OVER))) &&

                sg2d.textAntialiasHint <= SunHints.INTVAL_TEXT_ANTIALIAS_GASP)

            {

                // D3DTextRenderer handles both AA and non-AA text, but

                // only works if composite is SrcNoEa or SrcOver

                textpipe = d3dTextPipe;

            } else {

                // do this to initialize textpipe correctly; we will attempt

                // to override the non-text pipes below

                super.validatePipe(sg2d);

                textpipe = sg2d.textpipe;

                validated = true;

            }

            if (sg2d.antialiasHint != SunHints.INTVAL_ANTIALIAS_ON &&

                sg2d.paintState <= sg2d.PAINT_ALPHACOLOR)

            {

                sg2d.drawpipe =

                    sg2d.strokeState == sg2d.STROKE_THIN ? d3dPipe : d3dTxPipe;

                sg2d.fillpipe = d3dPipe;

                sg2d.shapepipe = d3dPipe;

            } else if (!validated) {

                super.validatePipe(sg2d);

            }

            // install the text pipe based on our earlier decision

            sg2d.textpipe = textpipe;

        } else {

            super.validatePipe(sg2d);

        }

        // always override the image pipe with the specialized D3D pipe

        sg2d.imagepipe = d3dDrawImagePipe;

    }

    /**

     * Disables D3D acceleration on the surface manager of this surfaceData

     * object. This can happen when we encounter a hard error in rendering a D3D

     * primitive (for example, if we were unable to set a surface as D3D target

     * surface).

     * Upon next validation the SurfaceManager will create a non-D3D surface.

     */

    public void disableD3D() {

        markSurfaceLost();

        SurfaceManager sMgr = SurfaceManager.getManager(image);

        if (sMgr instanceof WinVolatileSurfaceManager) {

            ((WinVolatileSurfaceManager)sMgr).setD3DAccelerationEnabled(false);

        }

    }

    @Override

    public boolean surfacePunted() {

        // Punting is disabled for D3D surfaces

        return false;

    }

    D3DContext getContext() {

        return ((Win32GraphicsDevice)graphicsConfig.getDevice()).getD3DContext();

    }

}