/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* 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.
*/
/**
* This file contains a standalone program that is used to generate the
* D3DShaders.h file. The program invokes the fxc (D3D Shader Compiler)
* utility, which is part of the DirectX 9/10 SDK. Since most JDK
* developers (other than some Java 2D engineers) do not have the full DXSDK
* installed, and since we do not want to make the JDK build process
* dependent on the full DXSDK installation, we have chosen not to make
* this shader compilation step part of the build process. Instead, it is
* only necessary to compile and run this program when changes need to be
* made to the shader code contained within. Typically, this only happens
* on an as-needed basis by someone familiar with the D3D pipeline. Running
* this program is fairly straightforward:
*
* % rm D3DShaders.h
* % cl D3DShaderGen.c
* % D3DShaderGen.exe
*
* (And don't forget to putback the updated D3DShaders.h file!)
*/
#include <stdio.h>
#include <process.h>
#include <Windows.h>
/** Evaluates to true if the given bit is set on the local flags variable. */
// REMIND
//#define J2dTraceLn(a, b) fprintf(stderr, "%s\n", b);
//#define J2dTraceLn1(a, b, c) fprintf(stderr, b, c);
#define J2dTraceLn(a, b)
#define J2dTraceLn1(a, b, c)
/************************* General shader support ***************************/
static void
{
int val;
// write source to tmp.hlsl
{
"c:\\progra~1\\mi5889~1\\utilit~1\\bin\\x86\\fxc.exe "
// uncomment the following line to generate debug
// info in the shader header file (may be useful
// for testing/debuggging purposes, but it nearly
// doubles the size of the header file and compiled
// shader programs - off for production builds)
//si.hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
//fprintf(stderr, "%s\n", pargs);
{
do {
//fprintf(stderr, "waiting...");
Sleep(100);
} while (code == STILL_ACTIVE);
if (code != 0) {
}
}
}
// append tmp.h to D3DShaders.h
{
int ch;
}
}
}
static void
{
}
/** Extracts the CycleMethod enum value from the given flags variable. */
((flags) & MULTI_GRAD_CYCLE_METHOD)
static void
{
int i;
for (i = 0; i < num; i++) {
// REMIND: what a hack!
} else {
}
}
// append to D3DShaders.h
}
/**************************** ConvolveOp support ****************************/
static const char *convolveShaderSource =
// image to be convolved
"sampler2D baseImage : register(s0);"
// image edge limits:
// imgEdge.xy = imgMin.xy (anything < will be treated as edge case)
// imgEdge.zw = imgMax.xy (anything > will be treated as edge case)
"float4 imgEdge : register(c0);"
// value for each location in the convolution kernel:
// kernelVals[i].x = offsetX[i]
// kernelVals[i].y = offsetY[i]
// kernelVals[i].z = kernel[i]
"float3 kernelVals[%d] : register(c1);"
""
"void main(in float2 tc : TEXCOORD0,"
" inout float4 color : COLOR0)"
"{"
" float4 sum = imgEdge - tc.xyxy;"
""
" if (sum.x > 0 || sum.y > 0 || sum.z < 0 || sum.w < 0) {"
// (placeholder for edge condition code)
" color = %s;"
" } else {"
" int i;"
" sum = float4(0, 0, 0, 0);"
" for (i = 0; i < %d; i++) {"
" sum +="
" kernelVals[i].z *"
" tex2D(baseImage, tc + kernelVals[i].xy);"
" }"
// modulate with current color in order to apply extra alpha
" color *= sum;"
" }"
""
"}";
/**
* Flags that can be bitwise-or'ed together to control how the shader
* source code is generated.
*/
static void
{
char *edge;
"D3DShaderGen_GenerateConvolveShader: flags=%d",
flags);
if (IS_SET(CONVOLVE_EDGE_ZERO_FILL)) {
// EDGE_ZERO_FILL: fill in zero at the edges
edge = "float4(0, 0, 0, 0)";
} else {
// EDGE_NO_OP: use the source pixel color at the edges
edge = "tex2D(baseImage, tc)";
}
// compose the final source code string from the various pieces
}
/**************************** RescaleOp support *****************************/
static const char *rescaleShaderSource =
// image to be rescaled
"sampler2D baseImage : register(s0);"
// vector containing scale factors
"float4 scaleFactors : register(c0);"
// vector containing offsets
"float4 offsets : register(c1);"
""
"void main(in float2 tc : TEXCOORD0,"
" inout float4 color : COLOR0)"
"{"
" float4 srcColor = tex2D(baseImage, tc);"
""
// (placeholder for un-premult code)
" %s"
""
// rescale source value
" float4 result = (srcColor * scaleFactors) + offsets;"
""
// (placeholder for re-premult code)
" %s"
""
// modulate with current color in order to apply extra alpha
" color *= result;"
"}";
/**
* Flags that can be bitwise-or'ed together to control how the shader
* source code is generated.
*/
static void
{
"D3DShaderGen_GenerateRescaleShader: flags=%d",
flags);
if (IS_SET(RESCALE_NON_PREMULT)) {
preRescale = "srcColor.rgb /= srcColor.a;";
postRescale = "result.rgb *= result.a;";
}
// compose the final source code string from the various pieces
}
/**************************** LookupOp support ******************************/
static const char *lookupShaderSource =
// source image (bound to texture unit 0)
"sampler2D baseImage : register(s0);"
// lookup table (bound to texture unit 1)
"sampler2D lookupTable : register(s1);"
// offset subtracted from source index prior to lookup step
"float4 offset : register(c0);"
""
"void main(in float2 tc : TEXCOORD0,"
" inout float4 color : COLOR0)"
"{"
" float4 srcColor = tex2D(baseImage, tc);"
// (placeholder for un-premult code)
" %s"
// subtract offset from original index
" float4 srcIndex = srcColor - offset;"
// use source value as input to lookup table (note that
// "v" texcoords are hardcoded to hit texel centers of
" float4 result;"
" result.r = tex2D(lookupTable, float2(srcIndex.r, 0.125)).r;"
" result.g = tex2D(lookupTable, float2(srcIndex.g, 0.375)).r;"
" result.b = tex2D(lookupTable, float2(srcIndex.b, 0.625)).r;"
// (placeholder for alpha store code)
" %s"
// (placeholder for re-premult code)
" %s"
// modulate with current color in order to apply extra alpha
" color *= result;"
"}";
/**
* Flags that can be bitwise-or'ed together to control how the shader
* source code is generated.
*/
static void
{
char *alpha;
"D3DShaderGen_GenerateLookupShader: flags=%d",
flags);
if (IS_SET(LOOKUP_USE_SRC_ALPHA)) {
// when numComps is 1 or 3, the alpha is not looked up in the table;
// just keep the alpha from the source fragment
alpha = "result.a = srcColor.a;";
} else {
// when numComps is 4, the alpha is looked up in the table, just
// like the other color components from the source fragment
alpha = "result.a = tex2D(lookupTable, float2(srcIndex.a, 0.875)).r;";
}
if (IS_SET(LOOKUP_NON_PREMULT)) {
preLookup = "srcColor.rgb /= srcColor.a;";
postLookup = "result.rgb *= result.a;";
}
// compose the final source code string from the various pieces
}
/************************* GradientPaint support ****************************/
/*
* To simplify the code and to make it easier to upload a number of
* uniform values at once, we pack a bunch of scalar (float) values
* into a single float3 below. Here's how the values are related:
*
* params.x = p0
* params.y = p1
* params.z = p3
*/
static const char *basicGradientShaderSource =
"float3 params : register (c0);"
"float4 color1 : register (c1);"
"float4 color2 : register (c2);"
// (placeholder for mask variable)
"%s"
""
// (placeholder for mask texcoord input)
"void main(%s"
" in float4 winCoord : TEXCOORD%d,"
" inout float4 color : COLOR0)"
"{"
" float3 fragCoord = float3(winCoord.x, winCoord.y, 1.0);"
" float dist = dot(params.xyz, fragCoord);"
""
// the setup code for p0/p1/p3 translates/scales to hit texel
// centers (at 0.25 and 0.75) because it is needed for the
// desirable for this shader-based implementation, so we
// re-transform the value here...
" dist = (dist - 0.25) * 2.0;"
""
" float fraction;"
// (placeholder for cycle code)
" %s"
""
" float4 result = lerp(color1, color2, fraction);"
""
// (placeholder for mask modulation code)
" %s"
""
// modulate with current color in order to apply extra alpha
" color *= result;"
"}";
/**
* Flags that can be bitwise-or'ed together to control how the shader
* source code is generated.
*/
static void
{
char *cycleCode;
"D3DShaderGen_GenerateBasicGradShader",
flags);
if (IS_SET(BASIC_GRAD_IS_CYCLIC)) {
"fraction = 1.0 - (abs(frac(dist * 0.5) - 0.5) * 2.0);";
} else {
"fraction = clamp(dist, 0.0, 1.0);";
}
if (IS_SET(BASIC_GRAD_USE_MASK)) {
/*
* This code modulates the calculated result color with the
* corresponding alpha value from the alpha mask texture active
* on texture unit 0. Only needed when useMask is true (i.e., only
* for MaskFill operations).
*/
maskVars = "sampler2D mask : register(s0);";
maskInput = "in float4 maskCoord : TEXCOORD0,";
maskCode = "result *= tex2D(mask, maskCoord.xy).a;";
}
// compose the final source code string from the various pieces
}
/****************** Shared MultipleGradientPaint support ********************/
/**
* These constants are identical to those defined in the
* MultipleGradientPaint.CycleMethod enum; they are copied here for
* convenience (ideally we would pull them directly from the Java level,
* but that entails more hassle than it is worth).
*/
#define CYCLE_NONE 0
/**
* The following constants are flags that can be bitwise-or'ed together
* to control how the MultipleGradientPaint shader source code is generated:
*
* MULTI_GRAD_CYCLE_METHOD
* Placeholder for the CycleMethod enum constant.
*
* MULTI_GRAD_LARGE
* If set, use the (slower) shader that supports a larger number of
* gradient colors; otherwise, use the optimized codepath. See
* the MAX_FRACTIONS_SMALL/LARGE constants below for more details.
*
* MULTI_GRAD_USE_MASK
* If set, apply the alpha mask value from texture unit 1 to the
* final color result (only used in the MaskFill case).
*
* MULTI_GRAD_LINEAR_RGB
* If set, convert the linear RGB result back into the sRGB color space.
*/
//#define MULTI_GRAD_CYCLE_METHOD (3 << 0)
// REMIND
/** Extracts the CycleMethod enum value from the given flags variable. */
//#define EXTRACT_CYCLE_METHOD(flags) \
// ((flags) & MULTI_GRAD_CYCLE_METHOD)
/**
* 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
* shader that supports more stops.
*/
/**
* The maximum number of gradient colors supported by all of the gradient
* fragment shaders. Note that this value must be a power of two, as it
* determines the size of the 1D texture created below. It also must be
* greater than or equal to MAX_FRACTIONS (there is no strict requirement
* that the two values be equal).
*/
static const char *multiGradientShaderSource =
// gradient texture size (in texels)
"#define TEXTURE_SIZE %d\n"
"#define MAX_FRACTIONS %d\n"
// size of a single texel
"#define FULL_TEXEL (1.0 / float(TEXTURE_SIZE))\n"
// size of half of a single texel
"#define HALF_TEXEL (FULL_TEXEL / 2.0)\n"
// texture containing the gradient colors
"sampler2D colors : register (s%d);"
// fractions[i].x = gradientStop[i]
// fractions[i].y = scaleFactor[i]
"float2 fractions[MAX_FRACTIONS] : register (c0);"
// (placeholder for mask variable)
"%s"
// (placeholder for Linear/RadialGP-specific variables)
"%s"
""
// (placeholder for mask texcoord input)
"void main(%s"
" in float4 winCoord : TEXCOORD%d,"
" inout float4 color : COLOR0)"
"{"
" float dist;"
// (placeholder for Linear/RadialGradientPaint-specific code)
" %s"
""
" float4 result;"
// (placeholder for CycleMethod-specific code)
" %s"
""
// (placeholder for ColorSpace conversion code)
" %s"
""
// (placeholder for mask modulation code)
" %s"
""
// modulate with current color in order to apply extra alpha
" color *= result;"
"}";
/*
* Note: An earlier version of this code would simply calculate a single
* texcoord:
* "tc = HALF_TEXEL + (FULL_TEXEL * relFraction);"
* and then use that value to do a single texture lookup, taking advantage
* of the LINEAR texture filtering mode which in theory will do the
* appropriate linear interpolation between adjacent texels, like this:
* "float4 result = tex2D(colors, float2(tc, 0.5));"
*
* The problem with that approach is that on certain hardware (from ATI,
* notably) the LINEAR texture fetch unit has low precision, and would
* for instance only produce 64 distinct grayscales between white and black,
* instead of the expected 256. The visual banding caused by this issue
* is severe enough to likely cause complaints from developers, so we have
* devised a new approach below that instead manually fetches the two
* relevant neighboring texels and then performs the linear interpolation
* using the lerp() instruction (which does not suffer from the precision
* issues of the fixed-function texture filtering unit). This new approach
* requires a few more instructions and is therefore slightly slower than
* the old approach (not more than 10% or so).
*/
static const char *texCoordCalcCode =
"int i;"
"float relFraction = 0.0;"
"for (i = 0; i < MAX_FRACTIONS-1; i++) {"
" relFraction +="
" clamp((dist - fractions[i].x) * fractions[i].y, 0.0, 1.0);"
"}"
// we offset by half a texel so that we find the linearly interpolated
// color between the two texel centers of interest
"float intPart = floor(relFraction);"
"float tc1 = HALF_TEXEL + (FULL_TEXEL * intPart);"
"float tc2 = HALF_TEXEL + (FULL_TEXEL * (intPart + 1.0));"
"float4 clr1 = tex2D(colors, float2(tc1, 0.5));"
"float4 clr2 = tex2D(colors, float2(tc2, 0.5));"
"result = lerp(clr1, clr2, frac(relFraction));";
/** Code for NO_CYCLE that gets plugged into the CycleMethod placeholder. */
static const char *noCycleCode =
"if (dist <= 0.0) {"
" result = tex2D(colors, float2(0.0, 0.5));"
"} else if (dist >= 1.0) {"
" result = tex2D(colors, float2(1.0, 0.5));"
"} else {"
// (placeholder for texcoord calculation)
" %s"
"}";
/** Code for REFLECT that gets plugged into the CycleMethod placeholder. */
static const char *reflectCode =
"dist = 1.0 - (abs(frac(dist * 0.5) - 0.5) * 2.0);"
// (placeholder for texcoord calculation)
"%s";
/** Code for REPEAT that gets plugged into the CycleMethod placeholder. */
static const char *repeatCode =
"dist = frac(dist);"
// (placeholder for texcoord calculation)
"%s";
static void
{
if (IS_SET(MULTI_GRAD_USE_MASK)) {
/*
* This code modulates the calculated result color with the
* corresponding alpha value from the alpha mask texture active
* on texture unit 0. Only needed when useMask is true (i.e., only
* for MaskFill operations).
*/
maskVars = "sampler2D mask : register(s0);";
maskInput = "in float4 maskCoord : TEXCOORD0,";
maskCode = "result *= tex2D(mask, maskCoord.xy).a;";
}
if (IS_SET(MULTI_GRAD_LINEAR_RGB)) {
/*
* This code converts a single pixel in linear RGB space back
* into sRGB (note: this code was adapted from the
* MultipleGradientPaintContext.convertLinearRGBtoSRGB() method).
*/
"result.rgb = 1.055 * pow(result.rgb, 0.416667) - 0.055;";
}
if (cycleMethod == CYCLE_NONE) {
} else if (cycleMethod == CYCLE_REFLECT) {
} else { // (cycleMethod == CYCLE_REPEAT)
}
// compose the final source code string from the various pieces
}
/********************** LinearGradientPaint support *************************/
static void
{
char *paintVars;
char *distCode;
"D3DShaderGen_GenerateLinearGradShader",
flags);
/*
* To simplify the code and to make it easier to upload a number of
* uniform values at once, we pack a bunch of scalar (float) values
* into a single float3 below. Here's how the values are related:
*
* params.x = p0
* params.y = p1
* params.z = p3
*/
"float3 params : register(c16);";
distCode =
"float3 fragCoord = float3(winCoord.x, winCoord.y, 1.0);"
"dist = dot(params.xyz, fragCoord);";
}
/********************** RadialGradientPaint support *************************/
static void
{
char *paintVars;
char *distCode;
"D3DShaderGen_GenerateRadialGradShader",
flags);
/*
* To simplify the code and to make it easier to upload a number of
* uniform values at once, we pack a bunch of scalar (float) values
* into float3 values below. Here's how the values are related:
*
* m0.x = m00
* m0.y = m01
* m0.z = m02
*
* m1.x = m10
* m1.y = m11
* m1.z = m12
*
* precalc.x = focusX
* precalc.y = 1.0 - (focusX * focusX)
* precalc.z = 1.0 / precalc.z
*/
"float3 m0 : register(c16);"
"float3 m1 : register(c17);"
"float3 precalc : register(c18);";
/*
* The following code is derived from Daniel Rice's whitepaper on
* radial gradient performance (attached to the bug report for 6521533).
* Refer to that document as well as the setup code in the Java-level
* BufferedPaints.setRadialGradientPaint() method for more details.
*/
distCode =
"float3 fragCoord = float3(winCoord.x, winCoord.y, 1.0);"
"float x = dot(fragCoord, m0);"
"float y = dot(fragCoord, m1);"
"float xfx = x - precalc.x;"
"dist = (precalc.x*xfx + sqrt(xfx*xfx + y*y*precalc.y))*precalc.z;";
}
/*************************** LCD text support *******************************/
// REMIND: Shader uses texture addressing operations in a dependency chain
// that is too complex for the target shader model (ps_2_0) to handle
// (ugh, I guess we can either require ps_3_0 or just use
// the slower pow intrinsic)
#define POW_LUT 0
static const char *lcdTextShaderSource =
"float3 srcAdj : register(c0);"
"sampler2D glyphTex : register(s0);"
"sampler2D dstTex : register(s1);"
#if POW_LUT
"sampler3D invgammaTex : register(s2);"
"sampler3D gammaTex : register(s3);"
#else
"float3 invgamma : register(c1);"
"float3 gamma : register(c2);"
#endif
""
"void main(in float2 tc0 : TEXCOORD0,"
" in float2 tc1 : TEXCOORD1,"
" inout float4 color : COLOR0)"
"{"
// load the RGB value from the glyph image at the current texcoord
" float3 glyphClr = tex2D(glyphTex, tc0).rgb;"
" if (!any(glyphClr)) {"
// zero coverage, so skip this fragment
" discard;"
" }"
// load the RGB value from the corresponding destination pixel
" float3 dstClr = tex2D(dstTex, tc1).rgb;"
// gamma adjust the dest color using the invgamma LUT
#if POW_LUT
" float3 dstAdj = tex3D(invgammaTex, dstClr).rgb;"
#else
" float3 dstAdj = pow(dstClr, invgamma);"
#endif
// linearly interpolate the three color values
" float3 result = lerp(dstAdj, srcAdj, glyphClr);"
// gamma re-adjust the resulting color (alpha is always set to 1.0)
#if POW_LUT
" color = float4(tex3D(gammaTex, result).rgb, 1.0);"
#else
" color = float4(pow(result, gamma), 1.0);"
#endif
"}";
static void
{
}
/*************************** AA support *******************************/
/*
* This shader fills the space between an outer and inner parallelogram.
* It can be used to draw an outline by specifying both inner and outer
* values. It fills pixels by estimating what portion falls inside the
* outer shape, and subtracting an estimate of what portion falls inside
* the inner shape. Specifying both inner and outer values produces a
* standard "wide outline". Specifying an inner shape that falls far
* outside the outer shape allows the same shader to fill the outer
* shape entirely since pixels that fall within the outer shape are never
* inside the inner shape and so they are filled based solely on their
* coverage of the outer shape.
*
* The setup code renders this shader over the bounds of the outer
* shape (or the only shape in the case of a fill operation) and
* sets the texture 0 coordinates so that 0,0=>0,1=>1,1=>1,0 in those
* texture coordinates map to the four corners of the parallelogram.
* Similarly the texture 1 coordinates map the inner shape to the
* unit square as well, but in a different coordinate system.
*
* When viewed in the texture coordinate systems the parallelograms
* we are filling are unit squares, but the pixels have then become
* tiny parallelograms themselves. Both of the texture coordinate
* systems are affine transforms so the rate of change in X and Y
* of the texture coordinates are essentially constants and happen
* to correspond to the size and direction of the slanted sides of
* the distorted pixels relative to the "square mapped" boundary
* of the parallelograms.
*
* The shader uses the ddx() and ddy() functions to measure the "rate
* of change" of these texture coordinates and thus gets an accurate
* measure of the size and shape of a pixel relative to the two
* parallelograms. It then uses the bounds of the size and shape
* of a pixel to intersect with the unit square to estimate the
* coverage of the pixel. Unfortunately, without a lot more work
* to calculate the exact area of intersection between a unit
* square (the original parallelogram) and a parallelogram (the
* distorted pixel), this shader only approximates the pixel
* coverage, but emperically the estimate is very useful and
* produces visually pleasing results, if not theoretically accurate.
*/
static const char *aaShaderSource =
"void main(in float2 tco : TEXCOORD0,"
" in float2 tci : TEXCOORD1,"
" inout float4 color : COLOR0)"
"{"
// Calculate the vectors for the "legs" of the pixel parallelogram
// for the outer parallelogram.
" float2 oleg1 = ddx(tco);"
" float2 oleg2 = ddy(tco);"
// Calculate the bounds of the distorted pixel parallelogram.
" float2 omin = min(tco, tco+oleg1);"
" omin = min(omin, tco+oleg2);"
" omin = min(omin, tco+oleg1+oleg2);"
" float2 omax = max(tco, tco+oleg1);"
" omax = max(omax, tco+oleg2);"
" omax = max(omax, tco+oleg1+oleg2);"
// Calculate the vectors for the "legs" of the pixel parallelogram
// for the inner parallelogram.
" float2 ileg1 = ddx(tci);"
" float2 ileg2 = ddy(tci);"
// Calculate the bounds of the distorted pixel parallelogram.
" float2 imin = min(tci, tci+ileg1);"
" imin = min(imin, tci+ileg2);"
" imin = min(imin, tci+ileg1+ileg2);"
" float2 imax = max(tci, tci+ileg1);"
" imax = max(imax, tci+ileg2);"
" imax = max(imax, tci+ileg1+ileg2);"
// Clamp the bounds of the parallelograms to the unit square to
// estimate the intersection of the pixel parallelogram with
// the unit square. The ratio of the 2 rectangle areas is a
// reasonable estimate of the proportion of coverage.
" float2 o1 = clamp(omin, 0.0, 1.0);"
" float2 o2 = clamp(omax, 0.0, 1.0);"
" float oint = (o2.y-o1.y)*(o2.x-o1.x);"
" float oarea = (omax.y-omin.y)*(omax.x-omin.x);"
" float2 i1 = clamp(imin, 0.0, 1.0);"
" float2 i2 = clamp(imax, 0.0, 1.0);"
" float iint = (i2.y-i1.y)*(i2.x-i1.x);"
" float iarea = (imax.y-imin.y)*(imax.x-imin.x);"
// Proportion of pixel in outer shape minus the proportion
// of pixel in the inner shape == the coverage of the pixel
// in the area between the two.
" color *= coverage;"
"}";
static void
{
}
/**************************** Main entrypoint *******************************/
static void
{
int i;
#if 1
// Generate BufferedImageOp shaders
for (i = 0; i < MAX_RESCALE; i++) {
}
for (i = 0; i < MAX_CONVOLVE; i++) {
}
for (i = 0; i < MAX_LOOKUP; i++) {
}
// Generate Paint shaders
for (i = 0; i < MAX_BASIC_GRAD; i++) {
}
for (i = 0; i < MAX_MULTI_GRAD; i++) {
}
for (i = 0; i < MAX_MULTI_GRAD; i++) {
}
// Generate LCD text shader
// Genereate Shader to fill Antialiased parallelograms
#else
/*
for (i = 0; i < MAX_RESCALE; i++) {
D3DShaderGen_GenerateRescaleShader(i);
}
D3DShaderGen_WriteShaderArray("rescale", MAX_RESCALE);
*/
//D3DShaderGen_GenerateConvolveShader(2);
//D3DShaderGen_GenerateLCDTextShader();
//D3DShaderGen_GenerateLinearGradShader(16);
#endif
}
int
{
return 0;
}