| /* |
| * 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. |
| */ |
| |
| #include <jlong.h> |
| #include <string.h> |
| |
| #include "sun_java2d_d3d_D3DPaints_MultiGradient.h" |
| |
| #include "D3DPaints.h" |
| #include "D3DContext.h" |
| #include "D3DRenderQueue.h" |
| #include "D3DSurfaceData.h" |
| |
| HRESULT |
| D3DPaints_ResetPaint(D3DContext *d3dc) |
| { |
| jint pixel, paintState; |
| jubyte ea; |
| HRESULT res; |
| |
| J2dTraceLn(J2D_TRACE_INFO, "D3DPaints_ResetPaint"); |
| |
| RETURN_STATUS_IF_NULL(d3dc, E_FAIL); |
| |
| paintState = d3dc->GetPaintState(); |
| J2dTraceLn1(J2D_TRACE_VERBOSE, " state=%d", paintState); |
| |
| res = d3dc->UpdateState(STATE_OTHEROP); |
| |
| // disable current complex paint state, if necessary |
| if (paintState > PAINT_ALPHACOLOR) { |
| IDirect3DDevice9 *pd3dDevice = d3dc->Get3DDevice(); |
| DWORD sampler = d3dc->useMask ? 1 : 0; |
| |
| d3dc->SetTexture(NULL, sampler); |
| pd3dDevice->SetSamplerState(sampler, |
| D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP); |
| pd3dDevice->SetSamplerState(sampler, |
| D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP); |
| pd3dDevice->SetTextureStageState(sampler, |
| D3DTSS_TEXCOORDINDEX, sampler); |
| res = pd3dDevice->SetTextureStageState(sampler, |
| D3DTSS_TEXTURETRANSFORMFLAGS, |
| D3DTTFF_DISABLE); |
| |
| if (paintState == PAINT_GRADIENT || |
| paintState == PAINT_LIN_GRADIENT || |
| paintState == PAINT_RAD_GRADIENT) |
| { |
| res = pd3dDevice->SetPixelShader(NULL); |
| } |
| } |
| |
| // set each component of the current color state to the extra alpha |
| // value, which will effectively apply the extra alpha to each fragment |
| // in paint/texturing operations |
| ea = (jubyte)(d3dc->extraAlpha * 0xff + 0.5f); |
| pixel = (ea << 24) | (ea << 16) | (ea << 8) | (ea << 0); |
| d3dc->pVCacher->SetColor(pixel); |
| d3dc->useMask = JNI_FALSE; |
| d3dc->SetPaintState(-1); |
| return res; |
| } |
| |
| HRESULT |
| D3DPaints_SetColor(D3DContext *d3dc, jint pixel) |
| { |
| HRESULT res = S_OK; |
| |
| J2dTraceLn1(J2D_TRACE_INFO, "D3DPaints_SetColor: pixel=%08x", pixel); |
| |
| RETURN_STATUS_IF_NULL(d3dc, E_FAIL); |
| |
| // no need to reset the current op state here unless the paint |
| // state really needs to be changed |
| if (d3dc->GetPaintState() > PAINT_ALPHACOLOR) { |
| res = D3DPaints_ResetPaint(d3dc); |
| } |
| |
| d3dc->pVCacher->SetColor(pixel); |
| d3dc->useMask = JNI_FALSE; |
| d3dc->SetPaintState(PAINT_ALPHACOLOR); |
| return res; |
| } |
| |
| /************************* GradientPaint support ****************************/ |
| |
| HRESULT |
| D3DPaints_SetGradientPaint(D3DContext *d3dc, |
| jboolean useMask, jboolean cyclic, |
| jdouble p0, jdouble p1, jdouble p3, |
| jint pixel1, jint pixel2) |
| { |
| IDirect3DDevice9 *pd3dDevice; |
| HRESULT res; |
| |
| J2dTraceLn(J2D_TRACE_INFO, "D3DPaints_SetGradientPaint"); |
| |
| RETURN_STATUS_IF_NULL(d3dc, E_FAIL); |
| D3DPaints_ResetPaint(d3dc); |
| |
| #if 0 |
| /* |
| * REMIND: The following code represents the original fast gradient |
| * implementation. The problem is that it relies on LINEAR |
| * texture filtering, which does not provide sufficient |
| * precision on certain hardware (from ATI, notably), which |
| * will cause visible banding (e.g. 64 shades of gray between |
| * black and white, instead of the expected 256 shades. For |
| * correctness on such hardware, it is necessary to use a |
| * shader-based approach that does not suffer from these |
| * precision issues (see below). This original implementation |
| * is about 16x faster than software, whereas the shader-based |
| * implementation is only about 4x faster than software (still |
| * impressive). For simplicity, we will always use the |
| * shader-based version for now, but in the future we could |
| * consider using the fast path for certain hardware (that does |
| * not exhibit the problem) or provide a flag to allow developers |
| * to control which path we take (for those that are less |
| * concerned about quality). Therefore, I'll leave this code |
| * here (currently disabled) for future use. |
| */ |
| D3DResource *pGradientTexRes; |
| IDirect3DTexture9 *pGradientTex; |
| |
| // this will initialize the gradient texture, if necessary |
| res = d3dc->GetResourceManager()->GetGradientTexture(&pGradientTexRes); |
| RETURN_STATUS_IF_FAILED(res); |
| |
| pGradientTex = pGradientTexRes->GetTexture(); |
| |
| // update the texture containing the gradient colors |
| { |
| D3DLOCKED_RECT lockedRect; |
| res = pGradientTex->LockRect(0, &lockedRect, NULL, D3DLOCK_NOSYSLOCK); |
| RETURN_STATUS_IF_FAILED(res); |
| jint *pPix = (jint*)lockedRect.pBits; |
| pPix[0] = pixel1; |
| pPix[1] = pixel2; |
| pGradientTex->UnlockRect(0); |
| } |
| |
| DWORD sampler = useMask ? 1 : 0; |
| DWORD wrapMode = cyclic ? D3DTADDRESS_WRAP : D3DTADDRESS_CLAMP; |
| d3dc->SetTexture(pGradientTex, sampler); |
| d3dc->UpdateTextureColorState(D3DTA_TEXTURE, sampler); |
| |
| pd3dDevice = d3dc->Get3DDevice(); |
| pd3dDevice->SetSamplerState(sampler, D3DSAMP_ADDRESSU, wrapMode); |
| pd3dDevice->SetSamplerState(sampler, D3DSAMP_ADDRESSV, wrapMode); |
| pd3dDevice->SetSamplerState(sampler, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR); |
| pd3dDevice->SetSamplerState(sampler, D3DSAMP_MINFILTER, D3DTEXF_LINEAR); |
| |
| D3DMATRIX mt; |
| ZeroMemory(&mt, sizeof(mt)); |
| mt._11 = (float)p0; |
| mt._21 = (float)p1; |
| mt._31 = (float)0.0; |
| mt._41 = (float)p3; |
| mt._12 = 0.0f; |
| mt._22 = 1.0f; |
| mt._32 = 0.0f; |
| mt._42 = 0.0f; |
| pd3dDevice->SetTransform(useMask ? D3DTS_TEXTURE1 : D3DTS_TEXTURE0, &mt); |
| pd3dDevice->SetTextureStageState(sampler, D3DTSS_TEXCOORDINDEX, |
| D3DTSS_TCI_CAMERASPACEPOSITION); |
| res = pd3dDevice->SetTextureStageState(sampler, |
| D3DTSS_TEXTURETRANSFORMFLAGS, |
| D3DTTFF_COUNT2); |
| #else |
| jfloat params[4]; |
| jfloat color[4]; |
| jint flags = 0; |
| |
| if (cyclic) flags |= BASIC_GRAD_IS_CYCLIC; |
| if (useMask) flags |= BASIC_GRAD_USE_MASK; |
| |
| // locate/enable the shader program for the given flags |
| res = d3dc->EnableBasicGradientProgram(flags); |
| RETURN_STATUS_IF_FAILED(res); |
| |
| // update the "uniform" values |
| params[0] = (jfloat)p0; |
| params[1] = (jfloat)p1; |
| params[2] = (jfloat)p3; |
| params[3] = 0.0f; // unused |
| pd3dDevice = d3dc->Get3DDevice(); |
| res = pd3dDevice->SetPixelShaderConstantF(0, params, 1); |
| |
| color[0] = ((pixel1 >> 16) & 0xff) / 255.0f; // r |
| color[1] = ((pixel1 >> 8) & 0xff) / 255.0f; // g |
| color[2] = ((pixel1 >> 0) & 0xff) / 255.0f; // b |
| color[3] = ((pixel1 >> 24) & 0xff) / 255.0f; // a |
| res = pd3dDevice->SetPixelShaderConstantF(1, color, 1); |
| |
| color[0] = ((pixel2 >> 16) & 0xff) / 255.0f; // r |
| color[1] = ((pixel2 >> 8) & 0xff) / 255.0f; // g |
| color[2] = ((pixel2 >> 0) & 0xff) / 255.0f; // b |
| color[3] = ((pixel2 >> 24) & 0xff) / 255.0f; // a |
| res = pd3dDevice->SetPixelShaderConstantF(2, color, 1); |
| |
| // set up texture coordinate transform with identity matrix, which |
| // will have the effect of passing the current window-space coordinates |
| // through to the TEXCOORD0/1 register used by the basic gradient |
| // pixel shader |
| DWORD sampler = useMask ? 1 : 0; |
| D3DMATRIX mt; |
| ZeroMemory(&mt, sizeof(mt)); |
| mt._11 = 1.0f; |
| mt._21 = 0.0f; |
| mt._31 = 0.0f; |
| mt._41 = 0.0f; |
| mt._12 = 0.0f; |
| mt._22 = 1.0f; |
| mt._32 = 0.0f; |
| mt._42 = 0.0f; |
| pd3dDevice->SetTransform(useMask ? D3DTS_TEXTURE1 : D3DTS_TEXTURE0, &mt); |
| pd3dDevice->SetTextureStageState(sampler, D3DTSS_TEXCOORDINDEX, |
| D3DTSS_TCI_CAMERASPACEPOSITION); |
| pd3dDevice->SetTextureStageState(sampler, D3DTSS_TEXTURETRANSFORMFLAGS, |
| D3DTTFF_COUNT2); |
| #endif |
| |
| // pixel state has been set appropriately in D3DPaints_ResetPaint() |
| d3dc->useMask = useMask; |
| d3dc->SetPaintState(PAINT_GRADIENT); |
| return res; |
| } |
| |
| /************************** TexturePaint support ****************************/ |
| |
| HRESULT |
| D3DPaints_SetTexturePaint(D3DContext *d3dc, |
| jboolean useMask, |
| jlong pSrcOps, jboolean filter, |
| jdouble xp0, jdouble xp1, jdouble xp3, |
| jdouble yp0, jdouble yp1, jdouble yp3) |
| { |
| D3DSDOps *srcOps = (D3DSDOps *)jlong_to_ptr(pSrcOps); |
| IDirect3DDevice9 *pd3dDevice; |
| HRESULT res; |
| |
| J2dTraceLn(J2D_TRACE_INFO, "D3DPaints_SetTexturePaint"); |
| |
| RETURN_STATUS_IF_NULL(d3dc, E_FAIL); |
| RETURN_STATUS_IF_NULL(srcOps, E_FAIL); |
| RETURN_STATUS_IF_NULL(srcOps->pResource, E_FAIL); |
| D3DPaints_ResetPaint(d3dc); |
| |
| DWORD sampler = useMask ? 1 : 0; |
| DWORD dwFilter = filter ? D3DTEXF_LINEAR : D3DTEXF_POINT; |
| res = d3dc->SetTexture(srcOps->pResource->GetTexture(), sampler); |
| d3dc->UpdateTextureColorState(D3DTA_TEXTURE, sampler); |
| pd3dDevice = d3dc->Get3DDevice(); |
| pd3dDevice->SetSamplerState(sampler, D3DSAMP_ADDRESSU, D3DTADDRESS_WRAP); |
| pd3dDevice->SetSamplerState(sampler, D3DSAMP_ADDRESSV, D3DTADDRESS_WRAP); |
| pd3dDevice->SetSamplerState(sampler, D3DSAMP_MAGFILTER, dwFilter); |
| pd3dDevice->SetSamplerState(sampler, D3DSAMP_MINFILTER, dwFilter); |
| |
| D3DMATRIX mt; |
| ZeroMemory(&mt, sizeof(mt)); |
| |
| // offset by a half texel to correctly map texels to pixels |
| // m02 = tx * m00 + ty * m01 + m02; |
| // m12 = tx * m10 + ty * m11 + m12; |
| jdouble tx = (1 / (2.0f * srcOps->pResource->GetDesc()->Width)); |
| jdouble ty = (1 / (2.0f * srcOps->pResource->GetDesc()->Height)); |
| xp3 = tx * xp0 + ty * xp1 + xp3; |
| yp3 = tx * yp0 + ty * yp1 + yp3; |
| |
| mt._11 = (float)xp0; |
| mt._21 = (float)xp1; |
| mt._31 = (float)0.0; |
| mt._41 = (float)xp3; |
| mt._12 = (float)yp0; |
| mt._22 = (float)yp1; |
| mt._32 = (float)0.0; |
| mt._42 = (float)yp3; |
| pd3dDevice->SetTransform(useMask ? D3DTS_TEXTURE1 : D3DTS_TEXTURE0, &mt); |
| pd3dDevice->SetTextureStageState(sampler, D3DTSS_TEXCOORDINDEX, |
| D3DTSS_TCI_CAMERASPACEPOSITION); |
| pd3dDevice->SetTextureStageState(sampler, D3DTSS_TEXTURETRANSFORMFLAGS, |
| D3DTTFF_COUNT2); |
| |
| // pixel state has been set appropriately in D3DPaints_ResetPaint() |
| d3dc->useMask = useMask; |
| d3dc->SetPaintState(PAINT_TEXTURE); |
| return res; |
| } |
| |
| /****************** Shared MultipleGradientPaint support ********************/ |
| |
| /** Composes the given parameters as flags into the given flags variable.*/ |
| #define COMPOSE_FLAGS(flags, cycleMethod, large, useMask, linear) \ |
| do { \ |
| flags |= ((cycleMethod) & MULTI_GRAD_CYCLE_METHOD); \ |
| if (large) flags |= MULTI_GRAD_LARGE; \ |
| if (useMask) flags |= MULTI_GRAD_USE_MASK; \ |
| if (linear) flags |= MULTI_GRAD_LINEAR_RGB; \ |
| } while (0) |
| |
| /** |
| * The maximum number of gradient "stops" supported by the fragment shader |
| * and related code. When the MULTI_GRAD_LARGE flag is set, we will use |
| * MAX_FRACTIONS_LARGE; otherwise, we use MAX_FRACTIONS_SMALL. By having |
| * two separate values, we can have one highly optimized shader (SMALL) that |
| * supports only a few fractions/colors, and then another, less optimal |
| * shader that supports more stops. |
| */ |
| #define MAX_FRACTIONS \ |
| sun_java2d_d3d_D3DPaints_MultiGradient_MULTI_MAX_FRACTIONS_D3D |
| #define MAX_FRACTIONS_LARGE MAX_FRACTIONS |
| #define MAX_FRACTIONS_SMALL 4 |
| |
| /** |
| * Called from the D3DPaints_SetLinear/RadialGradientPaint() methods |
| * in order to setup the fraction/color values that are common to both. |
| */ |
| static HRESULT |
| D3DPaints_SetMultiGradientPaint(D3DContext *d3dc, |
| jboolean useMask, jint numStops, |
| void *pFractions, void *pPixels) |
| { |
| HRESULT res; |
| IDirect3DDevice9 *pd3dDevice; |
| IDirect3DTexture9 *pMultiGradientTex; |
| D3DResource *pMultiGradientTexRes; |
| jint maxFractions = (numStops > MAX_FRACTIONS_SMALL) ? |
| MAX_FRACTIONS_LARGE : MAX_FRACTIONS_SMALL; |
| jfloat stopVals[MAX_FRACTIONS * 4]; |
| jfloat *fractions = (jfloat *)pFractions; |
| juint *pixels = (juint *)pPixels; |
| int i; |
| int fIndex = 0; |
| |
| pd3dDevice = d3dc->Get3DDevice(); |
| |
| // update the "uniform" fractions and scale factors |
| for (i = 0; i < maxFractions; i++) { |
| stopVals[fIndex+0] = (i < numStops) ? |
| fractions[i] : 0.0f; |
| stopVals[fIndex+1] = (i < numStops-1) ? |
| 1.0f / (fractions[i+1] - fractions[i]) : 0.0f; |
| stopVals[fIndex+2] = 0.0f; // unused |
| stopVals[fIndex+3] = 0.0f; // unused |
| fIndex += 4; |
| } |
| pd3dDevice->SetPixelShaderConstantF(0, stopVals, maxFractions); |
| |
| // this will initialize the multi-gradient texture, if necessary |
| res = d3dc->GetResourceManager()-> |
| GetMultiGradientTexture(&pMultiGradientTexRes); |
| RETURN_STATUS_IF_FAILED(res); |
| |
| pMultiGradientTex = pMultiGradientTexRes->GetTexture(); |
| |
| // update the texture containing the gradient colors |
| D3DLOCKED_RECT lockedRect; |
| res = pMultiGradientTex->LockRect(0, &lockedRect, NULL, D3DLOCK_NOSYSLOCK); |
| RETURN_STATUS_IF_FAILED(res); |
| |
| juint *pPix = (juint*)lockedRect.pBits; |
| memcpy(pPix, pixels, numStops*sizeof(juint)); |
| if (numStops < MAX_MULTI_GRADIENT_COLORS) { |
| // when we don't have enough colors to fill the entire |
| // color gradient, we have to replicate the last color |
| // in the right-most texel for the NO_CYCLE case where the |
| // texcoord is sometimes forced to 1.0 |
| pPix[MAX_MULTI_GRADIENT_COLORS-1] = pixels[numStops-1]; |
| } |
| pMultiGradientTex->UnlockRect(0); |
| |
| // set the gradient texture and update relevant state |
| DWORD sampler = useMask ? 1 : 0; |
| res = d3dc->SetTexture(pMultiGradientTex, sampler); |
| d3dc->UpdateTextureColorState(D3DTA_TEXTURE, sampler); |
| pd3dDevice->SetSamplerState(sampler, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP); |
| pd3dDevice->SetSamplerState(sampler, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP); |
| pd3dDevice->SetSamplerState(sampler, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR); |
| pd3dDevice->SetSamplerState(sampler, D3DSAMP_MINFILTER, D3DTEXF_LINEAR); |
| |
| // set up texture coordinate transform with identity matrix, which |
| // will have the effect of passing the current window-space coordinates |
| // through to the TEXCOORD0/1 register used by the multi-stop |
| // gradient pixel shader |
| D3DMATRIX mt; |
| ZeroMemory(&mt, sizeof(mt)); |
| mt._11 = 1.0f; |
| mt._21 = 0.0f; |
| mt._31 = 0.0f; |
| mt._41 = 0.0f; |
| mt._12 = 0.0f; |
| mt._22 = 1.0f; |
| mt._32 = 0.0f; |
| mt._42 = 0.0f; |
| pd3dDevice->SetTransform(useMask ? D3DTS_TEXTURE1 : D3DTS_TEXTURE0, &mt); |
| pd3dDevice->SetTextureStageState(sampler, D3DTSS_TEXCOORDINDEX, |
| D3DTSS_TCI_CAMERASPACEPOSITION); |
| pd3dDevice->SetTextureStageState(sampler, D3DTSS_TEXTURETRANSFORMFLAGS, |
| D3DTTFF_COUNT2); |
| return res; |
| } |
| |
| /********************** LinearGradientPaint support *************************/ |
| |
| HRESULT |
| D3DPaints_SetLinearGradientPaint(D3DContext *d3dc, D3DSDOps *dstOps, |
| jboolean useMask, jboolean linear, |
| jint cycleMethod, jint numStops, |
| jfloat p0, jfloat p1, jfloat p3, |
| void *fractions, void *pixels) |
| { |
| HRESULT res; |
| IDirect3DDevice9 *pd3dDevice; |
| jfloat params[4]; |
| jboolean large = (numStops > MAX_FRACTIONS_SMALL); |
| jint flags = 0; |
| |
| J2dTraceLn(J2D_TRACE_INFO, "D3DPaints_SetLinearGradientPaint"); |
| |
| RETURN_STATUS_IF_NULL(d3dc, E_FAIL); |
| RETURN_STATUS_IF_NULL(dstOps, E_FAIL); |
| D3DPaints_ResetPaint(d3dc); |
| |
| COMPOSE_FLAGS(flags, cycleMethod, large, useMask, linear); |
| |
| // locate/enable the shader program for the given flags |
| res = d3dc->EnableLinearGradientProgram(flags); |
| RETURN_STATUS_IF_FAILED(res); |
| |
| // update the common "uniform" values (fractions and colors) |
| D3DPaints_SetMultiGradientPaint(d3dc, useMask, |
| numStops, fractions, pixels); |
| |
| // update the other "uniform" values |
| params[0] = p0; |
| params[1] = p1; |
| params[2] = p3; |
| params[3] = 0.0f; // unused |
| pd3dDevice = d3dc->Get3DDevice(); |
| res = pd3dDevice->SetPixelShaderConstantF(16, params, 1); |
| |
| // pixel state has been set appropriately in D3DPaints_ResetPaint() |
| d3dc->useMask = useMask; |
| d3dc->SetPaintState(PAINT_LIN_GRADIENT); |
| return res; |
| } |
| |
| /********************** RadialGradientPaint support *************************/ |
| |
| HRESULT |
| D3DPaints_SetRadialGradientPaint(D3DContext *d3dc, D3DSDOps *dstOps, |
| jboolean useMask, jboolean linear, |
| jint cycleMethod, jint numStops, |
| jfloat m00, jfloat m01, jfloat m02, |
| jfloat m10, jfloat m11, jfloat m12, |
| jfloat focusX, |
| void *fractions, void *pixels) |
| { |
| HRESULT res; |
| IDirect3DDevice9 *pd3dDevice; |
| jfloat denom, inv_denom; |
| jfloat params[4]; |
| jboolean large = (numStops > MAX_FRACTIONS_SMALL); |
| jint flags = 0; |
| |
| J2dTraceLn(J2D_TRACE_INFO, "D3DPaints_SetRadialGradientPaint"); |
| |
| RETURN_STATUS_IF_NULL(d3dc, E_FAIL); |
| RETURN_STATUS_IF_NULL(dstOps, E_FAIL); |
| D3DPaints_ResetPaint(d3dc); |
| |
| COMPOSE_FLAGS(flags, cycleMethod, large, useMask, linear); |
| |
| // locate/enable the shader program for the given flags |
| res = d3dc->EnableRadialGradientProgram(flags); |
| RETURN_STATUS_IF_FAILED(res); |
| |
| // update the common "uniform" values (fractions and colors) |
| D3DPaints_SetMultiGradientPaint(d3dc, useMask, |
| numStops, fractions, pixels); |
| |
| // update the other "uniform" values |
| params[0] = m00; |
| params[1] = m01; |
| params[2] = m02; |
| params[3] = 0.0f; // unused |
| pd3dDevice = d3dc->Get3DDevice(); |
| pd3dDevice->SetPixelShaderConstantF(16, params, 1); |
| |
| params[0] = m10; |
| params[1] = m11; |
| params[2] = m12; |
| params[3] = 0.0f; // unused |
| pd3dDevice->SetPixelShaderConstantF(17, params, 1); |
| |
| // pack a few unrelated, precalculated values into a single float4 |
| denom = 1.0f - (focusX * focusX); |
| inv_denom = 1.0f / denom; |
| params[0] = focusX; |
| params[1] = denom; |
| params[2] = inv_denom; |
| params[3] = 0.0f; // unused |
| res = pd3dDevice->SetPixelShaderConstantF(18, params, 1); |
| |
| // pixel state has been set appropriately in D3DPaints_ResetPaint() |
| d3dc->useMask = useMask; |
| d3dc->SetPaintState(PAINT_RAD_GRADIENT); |
| return res; |
| } |
