| /* |
| * Copyright (c) 2007, 2008, 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.h" |
| #include "sun_java2d_d3d_D3DContext_D3DContextCaps.h" |
| #include "sun_java2d_d3d_D3DSurfaceData.h" |
| #include "sun_java2d_pipe_hw_AccelDeviceEventNotifier.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 |
| |
| #define DEVICE_RESET \ |
| sun_java2d_pipe_hw_AccelDeviceEventNotifier_DEVICE_RESET |
| #define DEVICE_DISPOSED \ |
| sun_java2d_pipe_hw_AccelDeviceEventNotifier_DEVICE_DISPOSED |
| |
| #endif // D3DCONTEXT_H |
