/*

 * Copyright (c) 2007, 2016, Oracle and/or its affiliates. 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.  Oracle designates this

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

 * by Oracle 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

#ifndef D3DCONTEXT_H

#define D3DCONTEXT_H

#include "java_awt_Transparency.h"

#include "sun_java2d_pipe_BufferedContext.h"

#include "sun_java2d_d3d_D3DContext_D3DContextCaps.h"

#include "sun_java2d_d3d_D3DSurfaceData.h"

#include "ShaderList.h"

#include "D3DPipeline.h"

#include "D3DMaskCache.h"

#include "D3DVertexCacher.h"

#include "D3DResourceManager.h"

#include "j2d_md.h"

typedef enum {

    TILEFMT_UNKNOWN,

    TILEFMT_1BYTE_ALPHA,

    TILEFMT_3BYTE_RGB,

    TILEFMT_3BYTE_BGR,

    TILEFMT_4BYTE_ARGB_PRE,

} TileFormat;

typedef enum {

    CLIP_NONE,

    CLIP_RECT,

    CLIP_SHAPE,

} ClipType;

// - State switching optimizations -----------------------------------

/**

 * The goal is to reduce device state switching as much as possible.

 * This means: don't reset the texture if not needed, don't change

 * the texture stage states unless necessary.

 * For this we need to track the current device state. So each operation

 * supplies its own operation type to BeginScene, which updates the state

 * as necessary.

 *

 * Another optimization is to use a single vertex format for

 * all primitives.

 *

 * See D3DContext::UpdateState() and D3DContext::BeginScene() for

 * more information.

 */

#define STATE_CHANGE    (0 << 0)

#define STATE_RENDEROP  (1 << 0)

#define STATE_MASKOP    (1 << 1)

#define STATE_GLYPHOP   (1 << 2)

#define STATE_TEXTUREOP (1 << 3)

#define STATE_AAPGRAMOP (1 << 4)

#define STATE_OTHEROP   (1 << 5)

// The max. stage number we currently use (could not be

// larger than 7)

#define MAX_USED_TEXTURE_SAMPLER 1

// - Texture pixel format table  -------------------------------------

#define TR_OPAQUE      java_awt_Transparency_OPAQUE

#define TR_BITMASK     java_awt_Transparency_BITMASK

#define TR_TRANSLUCENT java_awt_Transparency_TRANSLUCENT

class D3DResource;

class D3DResourceManager;

class D3DMaskCache;

class D3DVertexCacher;

class D3DGlyphCache;

// - D3DContext class  -----------------------------------------------

/**

 * This class provides the following functionality:

 *  - holds the state of D3DContext java class (current pixel color,

 *    alpha compositing mode, extra alpha)

 *  - provides access to IDirect3DDevice9 interface (creation,

 *    disposal, exclusive access)

 *  - handles state changes of the direct3d device (transform,

 *    compositing mode, current texture)

 *  - provides means of creating textures, plain surfaces

 *  - holds a glyph cache texture for the associated device

 *  - implements primitives batching mechanism

 */

class D3DPIPELINE_API D3DContext {

public:

    /**

     * Releases the old device (if there was one) and all associated

     * resources, re-creates, initializes and tests the new device.

     *

     * If the device doesn't pass the test, it's released.

     *

     * Used when the context is first created, and then after a

     * display change event.

     *

     * Note that this method also does the necessary registry checks,

     * and if the registry shows that we've crashed when attempting

     * to initialize and test the device last time, it doesn't attempt

     * to create/init/test the device.

     */

    static

    HRESULT CreateInstance(IDirect3D9 *pd3d9, UINT adapter, D3DContext **ppCtx);

    // creates a new D3D windowed device with swap copy effect and default

    // present interval

    HRESULT InitContext();

    // creates or resets a D3D device given the parameters

    HRESULT ConfigureContext(D3DPRESENT_PARAMETERS *pNewParams);

    // resets existing D3D device with the current presentation parameters

    HRESULT ResetContext();

    HRESULT CheckAndResetDevice();

    // saves the state of the D3D device in a state block, resets

    // context's state to STATE_CHANGE

    HRESULT SaveState();

    // restores the state of the D3D device from existing state block,

    // resets context's state to STATE_CHANGE

    HRESULT RestoreState();

    void    ReleaseContextResources();

    void    ReleaseDefPoolResources();

    virtual ~D3DContext();

    // methods replicating java-level D3DContext objext

    HRESULT SetAlphaComposite(jint rule, jfloat extraAlpha, jint flags);

    HRESULT ResetComposite();

    /**

     * Glyph cache-related methods

     */

    HRESULT InitGrayscaleGlyphCache();

    HRESULT InitLCDGlyphCache();

    D3DGlyphCache* GetGrayscaleGlyphCache() { return pGrayscaleGlyphCache; }

    D3DGlyphCache* GetLCDGlyphCache() { return pLCDGlyphCache; }

    D3DResourceManager *GetResourceManager() { return pResourceMgr; }

    D3DMaskCache       *GetMaskCache() { return pMaskCache; }

    HRESULT UploadTileToTexture(D3DResource *pTextureRes, void *pixels,

                                jint dstx, jint dsty,

                                jint srcx, jint srcy,

                                jint srcWidth, jint srcHeight,

                                jint srcStride,

                                TileFormat srcFormat,

                                // out: num of pixels in first and last

                                // columns, only counted for LCD glyph uploads

                                jint *pPixelsTouchedL = NULL,

                                jint *pPixelsTouchedR = NULL);

    // returns capabilities of the Direct3D device

    D3DCAPS9 *GetDeviceCaps() { return &devCaps; }

    // returns caps in terms of the D3DContext

    int GetContextCaps() { return contextCaps; }

    D3DPRESENT_PARAMETERS *GetPresentationParams() { return &curParams; }

    IDirect3DDevice9 *Get3DDevice() { return pd3dDevice; }

    IDirect3D9 *Get3DObject() { return pd3dObject; }

    /**

     * This method only sets the texture if it's not already set.

     */

    HRESULT SetTexture(IDirect3DTexture9 *pTexture, DWORD dwSampler = 0);

    /**

     * This method only updates the texture color state if it hasn't changed.

     */

    HRESULT UpdateTextureColorState(DWORD dwState, DWORD dwSampler = 0);

    HRESULT SetRenderTarget(IDirect3DSurface9 *pSurface);

    HRESULT SetTransform(jdouble m00, jdouble m10,

                         jdouble m01, jdouble m11,

                         jdouble m02, jdouble m12);

    HRESULT ResetTransform();

    // clipping-related methods

    HRESULT SetRectClip(int x1, int y1, int x2, int y2);

    HRESULT BeginShapeClip();

    HRESULT EndShapeClip();

    HRESULT ResetClip();

    ClipType GetClipType();

    /**

     * Shader-related methods

     */

    HRESULT EnableBasicGradientProgram(jint flags);

    HRESULT EnableLinearGradientProgram(jint flags);

    HRESULT EnableRadialGradientProgram(jint flags);

    HRESULT EnableConvolveProgram(jint flags);

    HRESULT EnableRescaleProgram(jint flags);

    HRESULT EnableLookupProgram(jint flags);

    HRESULT EnableLCDTextProgram();

    HRESULT EnableAAParallelogramProgram();

    HRESULT DisableAAParallelogramProgram();

    BOOL IsTextureFilteringSupported(D3DTEXTUREFILTERTYPE fType);

    BOOL IsStretchRectFilteringSupported(D3DTEXTUREFILTERTYPE fType);

    BOOL IsPow2TexturesOnly()

        { return devCaps.TextureCaps & D3DPTEXTURECAPS_POW2; };

    BOOL IsSquareTexturesOnly()

        { return devCaps.TextureCaps & D3DPTEXTURECAPS_SQUAREONLY; }

    BOOL IsHWRasterizer() { return bIsHWRasterizer; }

    BOOL IsTextureFormatSupported(D3DFORMAT format, DWORD usage = 0);

    BOOL IsDynamicTextureSupported()

        { return devCaps.Caps2 & D3DCAPS2_DYNAMICTEXTURES; }

// REMIND: for now for performance testing

//        { return (getenv("J2D_D3D_USE_DYNAMIC_TEX") != NULL); }

    BOOL IsImmediateIntervalSupported()

        { return devCaps.PresentationIntervals & D3DPRESENT_INTERVAL_IMMEDIATE;}

    BOOL IsPixelShader20Supported()

        { return (devCaps.PixelShaderVersion >= D3DPS_VERSION(2,0)); }

    BOOL IsGradientInstructionExtensionSupported()

        { return devCaps.PS20Caps.Caps & D3DPS20CAPS_GRADIENTINSTRUCTIONS; }

    BOOL IsPixelShader30Supported()

        { return (devCaps.PixelShaderVersion >= D3DPS_VERSION(3,0)); }

    BOOL IsMultiTexturingSupported()

        { return (devCaps.MaxSimultaneousTextures > 1); }

    BOOL IsAlphaRTSurfaceSupported();

    BOOL IsAlphaRTTSupported();

    BOOL IsOpaqueRTTSupported();

    jint GetPaintState() { return paintState; }

    void SetPaintState(jint state) { this->paintState = state; }

    BOOL IsIdentityTx() { return bIsIdentityTx; }

    HRESULT FlushVertexQueue();

    D3DVertexCacher *pVCacher;

    HRESULT UpdateState(jbyte newState);

    HRESULT Sync();

    // primitives batching-related methods

    /**

     * Calls devices's BeginScene if there weren't one already pending,

     * sets the pending flag.

     */

    HRESULT BeginScene(jbyte newState);

    /**

     * Flushes the vertex queue and does end scene if

     * a BeginScene is pending

     */

    HRESULT EndScene();

    /**

     * Fields that track native-specific state.

     */

    jint       paintState;

    jboolean   useMask;

    jfloat     extraAlpha;

    /**

     * Current operation state.

     * See STATE_* macros above.

     */

    jbyte      opState;

private:

    /**

     * Glyph cache-related methods/fields...

     */

    D3DGlyphCache *pGrayscaleGlyphCache;

    D3DGlyphCache *pLCDGlyphCache;

    /**

     * The handle to the LCD text pixel shader program.

     */

    IDirect3DPixelShader9 *lcdTextProgram;

    /**

     * The handle to the AA pixel and vertex shader programs.

     */

    IDirect3DPixelShader9 *aaPgramProgram;

    IDirect3DPixelShader9 *CreateFragmentProgram(DWORD **shaders,

                                                 ShaderList *programs,

                                                 jint flags);

    HRESULT EnableFragmentProgram(DWORD **shaders,

                                  ShaderList *programList,

                                  jint flags);

    // finds appropriate to the target surface depth format,

    // creates the depth buffer and installs it onto the device

    HRESULT InitDepthStencilBuffer(D3DSURFACE_DESC *pTargetDesc);

    // returns true if the current depth buffer is compatible

    // with the new target, and the dimensions fit, false otherwise

    BOOL IsDepthStencilBufferOk(D3DSURFACE_DESC *pTargetDesc);

    D3DContext(IDirect3D9 *pd3dObject, UINT adapter);

    HRESULT InitDevice(IDirect3DDevice9 *d3dDevice);

    HRESULT InitContextCaps();

    // updates the texture transform(s) used for better texel to pixel mapping

    // for the passed in sampler;

    // if -1 is passed as the sampler, texture transforms for

    // samplers [0..MAX_USED_TEXTURE_SAMPLER] are updated

    // REMIND: see the comment in the method implementation before enabling.

#undef UPDATE_TX

#ifdef UPDATE_TX

    HRESULT UpdateTextureTransforms(DWORD dwSamplerToUpdate);

#endif // UPDATE_TX

    IDirect3DDevice9        *pd3dDevice;

    IDirect3D9              *pd3dObject;

    D3DResourceManager      *pResourceMgr;

    D3DMaskCache            *pMaskCache;

    ShaderList convolvePrograms;

    ShaderList rescalePrograms;

    ShaderList lookupPrograms;

    ShaderList basicGradPrograms;

    ShaderList linearGradPrograms;

    ShaderList radialGradPrograms;

    // array of the textures currently set to the device

    IDirect3DTexture9     *lastTexture[MAX_USED_TEXTURE_SAMPLER+1];

    DWORD lastTextureColorState[MAX_USED_TEXTURE_SAMPLER+1];

    UINT adapterOrdinal;

    D3DPRESENT_PARAMETERS   curParams;

    D3DCAPS9 devCaps;

    int contextCaps;

    BOOL bIsHWRasterizer;

    BOOL bIsIdentityTx;

    IDirect3DQuery9* pSyncQuery;

    D3DResource* pSyncRTRes;

    IDirect3DStateBlock9* pStateBlock;

    /**

     * Used to implement simple primitive batching.

     * See BeginScene/EndScene/ForceEndScene.

     */

    BOOL    bBeginScenePending;

};

// - Helper Macros ---------------------------------------------------

#define D3DC_INIT_SHADER_LIST(list, max) \

    do { \

        (list).head     = NULL; \

        (list).maxItems = (max); \

        (list).dispose  = D3DContext_DisposeShader; \

    } while (0)

/**

 * This constant determines the size of the shared tile texture used

 * by a number of image rendering methods.  For example, the blit tile texture

 * will have dimensions with width D3DC_BLIT_TILE_SIZE and height

 * D3DC_BLIT_TILE_SIZE (the tile will always be square).

 */

#define D3DC_BLIT_TILE_SIZE 256

/**

 * See BufferedContext.java for more on these flags...

 */

#define D3DC_NO_CONTEXT_FLAGS \

    sun_java2d_pipe_BufferedContext_NO_CONTEXT_FLAGS

#define D3DC_SRC_IS_OPAQUE    \

    sun_java2d_pipe_BufferedContext_SRC_IS_OPAQUE

#define D3DC_USE_MASK         \

    sun_java2d_pipe_BufferedContext_USE_MASK

#define CAPS_EMPTY          \

    sun_java2d_d3d_D3DContext_D3DContextCaps_CAPS_EMPTY

#define CAPS_RT_PLAIN_ALPHA \

    sun_java2d_d3d_D3DContext_D3DContextCaps_CAPS_RT_PLAIN_ALPHA

#define CAPS_RT_TEXTURE_ALPHA      \

    sun_java2d_d3d_D3DContext_D3DContextCaps_CAPS_RT_TEXTURE_ALPHA

#define CAPS_RT_TEXTURE_OPAQUE     \

    sun_java2d_d3d_D3DContext_D3DContextCaps_CAPS_RT_TEXTURE_OPAQUE

#define CAPS_MULTITEXTURE   \

    sun_java2d_d3d_D3DContext_D3DContextCaps_CAPS_MULTITEXTURE

#define CAPS_TEXNONPOW2     \

    sun_java2d_d3d_D3DContext_D3DContextCaps_CAPS_TEXNONPOW2

#define CAPS_TEXNONSQUARE   \

    sun_java2d_d3d_D3DContext_D3DContextCaps_CAPS_TEXNONSQUARE

#define CAPS_LCD_SHADER     \

    sun_java2d_d3d_D3DContext_D3DContextCaps_CAPS_LCD_SHADER

#define CAPS_BIOP_SHADER    \

    sun_java2d_d3d_D3DContext_D3DContextCaps_CAPS_BIOP_SHADER

#define CAPS_AA_SHADER    \

    sun_java2d_d3d_D3DContext_D3DContextCaps_CAPS_AA_SHADER

#define CAPS_DEVICE_OK      \

    sun_java2d_d3d_D3DContext_D3DContextCaps_CAPS_DEVICE_OK

#define CAPS_PS20           \

    sun_java2d_d3d_D3DContext_D3DContextCaps_CAPS_PS20

#define CAPS_PS30           \

    sun_java2d_d3d_D3DContext_D3DContextCaps_CAPS_PS30

#endif // D3DCONTEXT_H