HRESULT
D3DTR_DrawGlyphList(D3DContext *d3dc, D3DSDOps *dstOps,
jint totalGlyphs, jboolean usePositions,
jboolean subPixPos, jboolean rgbOrder, jint lcdContrast,
jfloat glyphListOrigX, jfloat glyphListOrigY,
unsigned char *images, unsigned char *positions)
{
int glyphCounter;
HRESULT res = S_OK;
J2dTraceLn(J2D_TRACE_INFO, "D3DTR_DrawGlyphList");
RETURN_STATUS_IF_NULL(d3dc, E_FAIL);
RETURN_STATUS_IF_NULL(d3dc->Get3DDevice(), E_FAIL);
RETURN_STATUS_IF_NULL(dstOps, E_FAIL);
RETURN_STATUS_IF_NULL(images, E_FAIL);
if (usePositions) {
RETURN_STATUS_IF_NULL(positions, E_FAIL);
}
glyphMode = MODE_NOT_INITED;
isCachedDestValid = JNI_FALSE;
for (glyphCounter = 0; glyphCounter < totalGlyphs; glyphCounter++) {
jint x, y;
jfloat glyphx, glyphy;
jboolean grayscale;
GlyphInfo *ginfo = (GlyphInfo *)jlong_to_ptr(NEXT_LONG(images));
if (ginfo == NULL) {
// this shouldn't happen, but if it does we'll just break out...
J2dRlsTraceLn(J2D_TRACE_ERROR,
"D3DTR_DrawGlyphList: glyph info is null");
break;
}
grayscale = (ginfo->rowBytes == ginfo->width);
if (usePositions) {
jfloat posx = NEXT_FLOAT(positions);
jfloat posy = NEXT_FLOAT(positions);
glyphx = glyphListOrigX + posx + ginfo->topLeftX;
glyphy = glyphListOrigY + posy + ginfo->topLeftY;
FLOOR_ASSIGN(x, glyphx);
FLOOR_ASSIGN(y, glyphy);
} else {
glyphx = glyphListOrigX + ginfo->topLeftX;
glyphy = glyphListOrigY + ginfo->topLeftY;
FLOOR_ASSIGN(x, glyphx);
FLOOR_ASSIGN(y, glyphy);
glyphListOrigX += ginfo->advanceX;
glyphListOrigY += ginfo->advanceY;
}
if (ginfo->image == NULL) {
continue;
}
if (grayscale) {
// grayscale or monochrome glyph data
if (ginfo->width <= D3DTR_CACHE_CELL_WIDTH &&
ginfo->height <= D3DTR_CACHE_CELL_HEIGHT &&
SUCCEEDED(d3dc->InitGrayscaleGlyphCache()))
{
res = D3DTR_DrawGrayscaleGlyphViaCache(d3dc, ginfo, x, y);
} else {
res = D3DTR_DrawGrayscaleGlyphNoCache(d3dc, ginfo, x, y);
}
} else {
// LCD-optimized glyph data
jint rowBytesOffset = 0;
if (subPixPos) {
jint frac = (jint)((glyphx - x) * 3);
if (frac != 0) {
rowBytesOffset = 3 - frac;
x += 1;
}
}
if (rowBytesOffset == 0 &&
ginfo->width <= D3DTR_CACHE_CELL_WIDTH &&
ginfo->height <= D3DTR_CACHE_CELL_HEIGHT &&
SUCCEEDED(d3dc->InitLCDGlyphCache()))
{
res = D3DTR_DrawLCDGlyphViaCache(d3dc, dstOps,
ginfo, x, y,
glyphCounter, totalGlyphs,
rgbOrder, lcdContrast);
} else {
res = D3DTR_DrawLCDGlyphNoCache(d3dc, dstOps,
ginfo, x, y,
rowBytesOffset,
rgbOrder, lcdContrast);
}
}
if (FAILED(res)) {
break;
}
}
D3DTR_DisableGlyphModeState(d3dc);
return res;
}
HRESULT
D3DBufImgOps_EnableConvolveOp(D3DContext *d3dc, jlong pSrcOps,
jboolean edgeZeroFill,
jint kernelWidth, jint kernelHeight,
unsigned char *kernel)
{
HRESULT res;
IDirect3DDevice9 *pd3dDevice;
D3DSDOps *srcOps = (D3DSDOps *)jlong_to_ptr(pSrcOps);
jint kernelSize = kernelWidth * kernelHeight;
jint texW, texH;
jfloat xoff, yoff;
jfloat edgeX, edgeY;
jfloat imgEdge[4];
jfloat kernelVals[MAX_KERNEL_SIZE*4];
jint i, j, kIndex;
jint flags = 0;
J2dTraceLn2(J2D_TRACE_INFO,
"D3DBufImgOps_EnableConvolveOp: kernelW=%d kernelH=%d",
kernelWidth, kernelHeight);
RETURN_STATUS_IF_NULL(d3dc, E_FAIL);
RETURN_STATUS_IF_NULL(srcOps, E_FAIL);
d3dc->UpdateState(STATE_CHANGE);
// texcoords are specified in the range [0,1], so to achieve an
// x/y offset of approximately one pixel we have to normalize
// to that range here
texW = srcOps->pResource->GetDesc()->Width;
texH = srcOps->pResource->GetDesc()->Height;
xoff = 1.0f / texW;
yoff = 1.0f / texH;
if (edgeZeroFill) {
flags |= CONVOLVE_EDGE_ZERO_FILL;
}
if (kernelWidth == 5 && kernelHeight == 5) {
flags |= CONVOLVE_5X5;
}
// locate/enable the shader program for the given flags
res = d3dc->EnableConvolveProgram(flags);
RETURN_STATUS_IF_FAILED(res);
// update the "uniform" image min/max values
// (texcoords are in the range [0,1])
// imgEdge[0] = imgMin.x
// imgEdge[1] = imgMin.y
// imgEdge[2] = imgMax.x
// imgEdge[3] = imgMax.y
edgeX = (kernelWidth/2) * xoff;
edgeY = (kernelHeight/2) * yoff;
imgEdge[0] = edgeX;
imgEdge[1] = edgeY;
imgEdge[2] = (((jfloat)srcOps->width) / texW) - edgeX;
imgEdge[3] = (((jfloat)srcOps->height) / texH) - edgeY;
pd3dDevice = d3dc->Get3DDevice();
pd3dDevice->SetPixelShaderConstantF(0, imgEdge, 1);
// update the "uniform" kernel offsets and values
kIndex = 0;
for (i = -kernelHeight/2; i < kernelHeight/2+1; i++) {
for (j = -kernelWidth/2; j < kernelWidth/2+1; j++) {
kernelVals[kIndex+0] = j*xoff;
kernelVals[kIndex+1] = i*yoff;
kernelVals[kIndex+2] = NEXT_FLOAT(kernel);
kernelVals[kIndex+3] = 0.0f; // unused
kIndex += 4;
}
}
return pd3dDevice->SetPixelShaderConstantF(1, kernelVals, kernelSize);
}
void
OGLTR_DrawGlyphList(JNIEnv *env, OGLContext *oglc, OGLSDOps *dstOps,
jint totalGlyphs, jboolean usePositions,
jboolean subPixPos, jboolean rgbOrder, jint lcdContrast,
jfloat glyphListOrigX, jfloat glyphListOrigY,
unsigned char *images, unsigned char *positions)
{
int glyphCounter;
J2dTraceLn(J2D_TRACE_INFO, "OGLTR_DrawGlyphList");
RETURN_IF_NULL(oglc);
RETURN_IF_NULL(dstOps);
RETURN_IF_NULL(images);
if (usePositions) {
RETURN_IF_NULL(positions);
}
glyphMode = MODE_NOT_INITED;
isCachedDestValid = JNI_FALSE;
for (glyphCounter = 0; glyphCounter < totalGlyphs; glyphCounter++) {
jint x, y;
jfloat glyphx, glyphy;
jboolean grayscale, ok;
GlyphInfo *ginfo = (GlyphInfo *)jlong_to_ptr(NEXT_LONG(images));
if (ginfo == NULL) {
// this shouldn't happen, but if it does we'll just break out...
J2dRlsTraceLn(J2D_TRACE_ERROR,
"OGLTR_DrawGlyphList: glyph info is null");
break;
}
grayscale = (ginfo->rowBytes == ginfo->width);
if (usePositions) {
jfloat posx = NEXT_FLOAT(positions);
jfloat posy = NEXT_FLOAT(positions);
glyphx = glyphListOrigX + posx + ginfo->topLeftX;
glyphy = glyphListOrigY + posy + ginfo->topLeftY;
FLOOR_ASSIGN(x, glyphx);
FLOOR_ASSIGN(y, glyphy);
} else {
glyphx = glyphListOrigX + ginfo->topLeftX;
glyphy = glyphListOrigY + ginfo->topLeftY;
FLOOR_ASSIGN(x, glyphx);
FLOOR_ASSIGN(y, glyphy);
glyphListOrigX += ginfo->advanceX;
glyphListOrigY += ginfo->advanceY;
}
if (ginfo->image == NULL) {
continue;
}
if (grayscale) {
// grayscale or monochrome glyph data
if (cacheStatus != CACHE_LCD &&
ginfo->width <= OGLTR_CACHE_CELL_WIDTH &&
ginfo->height <= OGLTR_CACHE_CELL_HEIGHT)
{
ok = OGLTR_DrawGrayscaleGlyphViaCache(oglc, ginfo, x, y);
} else {
ok = OGLTR_DrawGrayscaleGlyphNoCache(oglc, ginfo, x, y);
}
} else {
// LCD-optimized glyph data
jint rowBytesOffset = 0;
if (subPixPos) {
jint frac = (jint)((glyphx - x) * 3);
if (frac != 0) {
rowBytesOffset = 3 - frac;
x += 1;
}
}
if (rowBytesOffset == 0 &&
cacheStatus != CACHE_GRAY &&
ginfo->width <= OGLTR_CACHE_CELL_WIDTH &&
ginfo->height <= OGLTR_CACHE_CELL_HEIGHT)
{
ok = OGLTR_DrawLCDGlyphViaCache(oglc, dstOps,
ginfo, x, y,
glyphCounter, totalGlyphs,
rgbOrder, lcdContrast);
} else {
ok = OGLTR_DrawLCDGlyphNoCache(oglc, dstOps,
ginfo, x, y,
rowBytesOffset,
rgbOrder, lcdContrast);
}
}
if (!ok) {
break;
}
}
OGLTR_DisableGlyphModeState();
}
JNIEXPORT void JNICALL
Java_sun_java2d_opengl_OGLRenderQueue_flushBuffer
(JNIEnv *env, jobject oglrq,
jlong buf, jint limit)
{
jboolean sync = JNI_FALSE;
unsigned char *b, *end;
J2dTraceLn1(J2D_TRACE_INFO,
"OGLRenderQueue_flushBuffer: limit=%d", limit);
b = (unsigned char *)jlong_to_ptr(buf);
if (b == NULL) {
J2dRlsTraceLn(J2D_TRACE_ERROR,
"OGLRenderQueue_flushBuffer: cannot get direct buffer address");
return;
}
INIT_PREVIOUS_OP();
end = b + limit;
while (b < end) {
jint opcode = NEXT_INT(b);
J2dTraceLn2(J2D_TRACE_VERBOSE,
"OGLRenderQueue_flushBuffer: opcode=%d, rem=%d",
opcode, (end-b));
switch (opcode) {
// draw ops
case sun_java2d_pipe_BufferedOpCodes_DRAW_LINE:
{
jint x1 = NEXT_INT(b);
jint y1 = NEXT_INT(b);
jint x2 = NEXT_INT(b);
jint y2 = NEXT_INT(b);
OGLRenderer_DrawLine(oglc, x1, y1, x2, y2);
}
break;
case sun_java2d_pipe_BufferedOpCodes_DRAW_RECT:
{
jint x = NEXT_INT(b);
jint y = NEXT_INT(b);
jint w = NEXT_INT(b);
jint h = NEXT_INT(b);
OGLRenderer_DrawRect(oglc, x, y, w, h);
}
break;
case sun_java2d_pipe_BufferedOpCodes_DRAW_POLY:
{
jint nPoints = NEXT_INT(b);
jboolean isClosed = NEXT_BOOLEAN(b);
jint transX = NEXT_INT(b);
jint transY = NEXT_INT(b);
jint *xPoints = (jint *)b;
jint *yPoints = ((jint *)b) + nPoints;
OGLRenderer_DrawPoly(oglc, nPoints, isClosed,
transX, transY,
xPoints, yPoints);
SKIP_BYTES(b, nPoints * BYTES_PER_POLY_POINT);
}
break;
case sun_java2d_pipe_BufferedOpCodes_DRAW_PIXEL:
{
jint x = NEXT_INT(b);
jint y = NEXT_INT(b);
// Note that we could use GL_POINTS here, but the common
// use case for DRAW_PIXEL is when rendering a Path2D,
// which will consist of a mix of DRAW_PIXEL and DRAW_LINE
// calls. So to improve batching we use GL_LINES here,
// even though it requires an extra vertex per pixel.
CONTINUE_IF_NULL(oglc);
CHECK_PREVIOUS_OP(GL_LINES);
j2d_glVertex2i(x, y);
j2d_glVertex2i(x+1, y+1);
}
break;
case sun_java2d_pipe_BufferedOpCodes_DRAW_SCANLINES:
{
jint count = NEXT_INT(b);
OGLRenderer_DrawScanlines(oglc, count, (jint *)b);
SKIP_BYTES(b, count * BYTES_PER_SCANLINE);
}
break;
case sun_java2d_pipe_BufferedOpCodes_DRAW_PARALLELOGRAM:
{
jfloat x11 = NEXT_FLOAT(b);
jfloat y11 = NEXT_FLOAT(b);
jfloat dx21 = NEXT_FLOAT(b);
jfloat dy21 = NEXT_FLOAT(b);
jfloat dx12 = NEXT_FLOAT(b);
jfloat dy12 = NEXT_FLOAT(b);
jfloat lwr21 = NEXT_FLOAT(b);
jfloat lwr12 = NEXT_FLOAT(b);
OGLRenderer_DrawParallelogram(oglc,
x11, y11,
dx21, dy21,
dx12, dy12,
lwr21, lwr12);
}
break;
case sun_java2d_pipe_BufferedOpCodes_DRAW_AAPARALLELOGRAM:
{
jfloat x11 = NEXT_FLOAT(b);
jfloat y11 = NEXT_FLOAT(b);
jfloat dx21 = NEXT_FLOAT(b);
jfloat dy21 = NEXT_FLOAT(b);
jfloat dx12 = NEXT_FLOAT(b);
jfloat dy12 = NEXT_FLOAT(b);
jfloat lwr21 = NEXT_FLOAT(b);
jfloat lwr12 = NEXT_FLOAT(b);
OGLRenderer_DrawAAParallelogram(oglc, dstOps,
x11, y11,
dx21, dy21,
dx12, dy12,
lwr21, lwr12);
}
break;
// fill ops
case sun_java2d_pipe_BufferedOpCodes_FILL_RECT:
{
jint x = NEXT_INT(b);
jint y = NEXT_INT(b);
jint w = NEXT_INT(b);
jint h = NEXT_INT(b);
OGLRenderer_FillRect(oglc, x, y, w, h);
}
break;
case sun_java2d_pipe_BufferedOpCodes_FILL_SPANS:
{
jint count = NEXT_INT(b);
OGLRenderer_FillSpans(oglc, count, (jint *)b);
SKIP_BYTES(b, count * BYTES_PER_SPAN);
}
break;
case sun_java2d_pipe_BufferedOpCodes_FILL_PARALLELOGRAM:
{
jfloat x11 = NEXT_FLOAT(b);
jfloat y11 = NEXT_FLOAT(b);
jfloat dx21 = NEXT_FLOAT(b);
jfloat dy21 = NEXT_FLOAT(b);
jfloat dx12 = NEXT_FLOAT(b);
jfloat dy12 = NEXT_FLOAT(b);
OGLRenderer_FillParallelogram(oglc,
x11, y11,
dx21, dy21,
dx12, dy12);
}
break;
case sun_java2d_pipe_BufferedOpCodes_FILL_AAPARALLELOGRAM:
{
jfloat x11 = NEXT_FLOAT(b);
jfloat y11 = NEXT_FLOAT(b);
jfloat dx21 = NEXT_FLOAT(b);
jfloat dy21 = NEXT_FLOAT(b);
jfloat dx12 = NEXT_FLOAT(b);
jfloat dy12 = NEXT_FLOAT(b);
OGLRenderer_FillAAParallelogram(oglc, dstOps,
x11, y11,
dx21, dy21,
dx12, dy12);
}
break;
// text-related ops
case sun_java2d_pipe_BufferedOpCodes_DRAW_GLYPH_LIST:
{
jint numGlyphs = NEXT_INT(b);
jint packedParams = NEXT_INT(b);
jfloat glyphListOrigX = NEXT_FLOAT(b);
jfloat glyphListOrigY = NEXT_FLOAT(b);
jboolean usePositions = EXTRACT_BOOLEAN(packedParams,
OFFSET_POSITIONS);
jboolean subPixPos = EXTRACT_BOOLEAN(packedParams,
OFFSET_SUBPIXPOS);
jboolean rgbOrder = EXTRACT_BOOLEAN(packedParams,
OFFSET_RGBORDER);
jint lcdContrast = EXTRACT_BYTE(packedParams,
OFFSET_CONTRAST);
unsigned char *images = b;
unsigned char *positions;
jint bytesPerGlyph;
if (usePositions) {
positions = (b + numGlyphs * BYTES_PER_GLYPH_IMAGE);
bytesPerGlyph = BYTES_PER_POSITIONED_GLYPH;
} else {
positions = NULL;
bytesPerGlyph = BYTES_PER_GLYPH_IMAGE;
}
OGLTR_DrawGlyphList(env, oglc, dstOps,
numGlyphs, usePositions,
subPixPos, rgbOrder, lcdContrast,
glyphListOrigX, glyphListOrigY,
images, positions);
SKIP_BYTES(b, numGlyphs * bytesPerGlyph);
}
break;
// copy-related ops
case sun_java2d_pipe_BufferedOpCodes_COPY_AREA:
{
jint x = NEXT_INT(b);
jint y = NEXT_INT(b);
jint w = NEXT_INT(b);
jint h = NEXT_INT(b);
jint dx = NEXT_INT(b);
jint dy = NEXT_INT(b);
OGLBlitLoops_CopyArea(env, oglc, dstOps,
x, y, w, h, dx, dy);
}
break;
case sun_java2d_pipe_BufferedOpCodes_BLIT:
{
jint packedParams = NEXT_INT(b);
jint sx1 = NEXT_INT(b);
jint sy1 = NEXT_INT(b);
jint sx2 = NEXT_INT(b);
jint sy2 = NEXT_INT(b);
jdouble dx1 = NEXT_DOUBLE(b);
jdouble dy1 = NEXT_DOUBLE(b);
jdouble dx2 = NEXT_DOUBLE(b);
jdouble dy2 = NEXT_DOUBLE(b);
jlong pSrc = NEXT_LONG(b);
jlong pDst = NEXT_LONG(b);
jint hint = EXTRACT_BYTE(packedParams, OFFSET_HINT);
jboolean texture = EXTRACT_BOOLEAN(packedParams,
OFFSET_TEXTURE);
jboolean rtt = EXTRACT_BOOLEAN(packedParams,
OFFSET_RTT);
jboolean xform = EXTRACT_BOOLEAN(packedParams,
OFFSET_XFORM);
jboolean isoblit = EXTRACT_BOOLEAN(packedParams,
OFFSET_ISOBLIT);
if (isoblit) {
OGLBlitLoops_IsoBlit(env, oglc, pSrc, pDst,
xform, hint, texture, rtt,
sx1, sy1, sx2, sy2,
dx1, dy1, dx2, dy2);
} else {
jint srctype = EXTRACT_BYTE(packedParams, OFFSET_SRCTYPE);
OGLBlitLoops_Blit(env, oglc, pSrc, pDst,
xform, hint, srctype, texture,
sx1, sy1, sx2, sy2,
dx1, dy1, dx2, dy2);
}
}
break;
case sun_java2d_pipe_BufferedOpCodes_SURFACE_TO_SW_BLIT:
{
jint sx = NEXT_INT(b);
jint sy = NEXT_INT(b);
jint dx = NEXT_INT(b);
jint dy = NEXT_INT(b);
jint w = NEXT_INT(b);
jint h = NEXT_INT(b);
jint dsttype = NEXT_INT(b);
jlong pSrc = NEXT_LONG(b);
jlong pDst = NEXT_LONG(b);
OGLBlitLoops_SurfaceToSwBlit(env, oglc,
pSrc, pDst, dsttype,
sx, sy, dx, dy, w, h);
}
break;
case sun_java2d_pipe_BufferedOpCodes_MASK_FILL:
{
jint x = NEXT_INT(b);
jint y = NEXT_INT(b);
jint w = NEXT_INT(b);
jint h = NEXT_INT(b);
jint maskoff = NEXT_INT(b);
jint maskscan = NEXT_INT(b);
jint masklen = NEXT_INT(b);
unsigned char *pMask = (masklen > 0) ? b : NULL;
OGLMaskFill_MaskFill(oglc, x, y, w, h,
maskoff, maskscan, masklen, pMask);
SKIP_BYTES(b, masklen);
}
break;
case sun_java2d_pipe_BufferedOpCodes_MASK_BLIT:
{
jint dstx = NEXT_INT(b);
jint dsty = NEXT_INT(b);
jint width = NEXT_INT(b);
jint height = NEXT_INT(b);
jint masklen = width * height * sizeof(jint);
OGLMaskBlit_MaskBlit(env, oglc,
dstx, dsty, width, height, b);
SKIP_BYTES(b, masklen);
}
break;
// state-related ops
case sun_java2d_pipe_BufferedOpCodes_SET_RECT_CLIP:
{
jint x1 = NEXT_INT(b);
jint y1 = NEXT_INT(b);
jint x2 = NEXT_INT(b);
jint y2 = NEXT_INT(b);
OGLContext_SetRectClip(oglc, dstOps, x1, y1, x2, y2);
}
break;
case sun_java2d_pipe_BufferedOpCodes_BEGIN_SHAPE_CLIP:
{
OGLContext_BeginShapeClip(oglc);
}
break;
case sun_java2d_pipe_BufferedOpCodes_SET_SHAPE_CLIP_SPANS:
{
jint count = NEXT_INT(b);
OGLRenderer_FillSpans(oglc, count, (jint *)b);
SKIP_BYTES(b, count * BYTES_PER_SPAN);
}
break;
case sun_java2d_pipe_BufferedOpCodes_END_SHAPE_CLIP:
{
OGLContext_EndShapeClip(oglc, dstOps);
}
break;
case sun_java2d_pipe_BufferedOpCodes_RESET_CLIP:
{
OGLContext_ResetClip(oglc);
}
break;
case sun_java2d_pipe_BufferedOpCodes_SET_ALPHA_COMPOSITE:
{
jint rule = NEXT_INT(b);
jfloat extraAlpha = NEXT_FLOAT(b);
jint flags = NEXT_INT(b);
OGLContext_SetAlphaComposite(oglc, rule, extraAlpha, flags);
}
break;
case sun_java2d_pipe_BufferedOpCodes_SET_XOR_COMPOSITE:
{
jint xorPixel = NEXT_INT(b);
OGLContext_SetXorComposite(oglc, xorPixel);
}
break;
case sun_java2d_pipe_BufferedOpCodes_RESET_COMPOSITE:
{
OGLContext_ResetComposite(oglc);
}
break;
case sun_java2d_pipe_BufferedOpCodes_SET_TRANSFORM:
{
jdouble m00 = NEXT_DOUBLE(b);
jdouble m10 = NEXT_DOUBLE(b);
jdouble m01 = NEXT_DOUBLE(b);
jdouble m11 = NEXT_DOUBLE(b);
jdouble m02 = NEXT_DOUBLE(b);
jdouble m12 = NEXT_DOUBLE(b);
OGLContext_SetTransform(oglc, m00, m10, m01, m11, m02, m12);
}
break;
case sun_java2d_pipe_BufferedOpCodes_RESET_TRANSFORM:
{
OGLContext_ResetTransform(oglc);
}
break;
// context-related ops
case sun_java2d_pipe_BufferedOpCodes_SET_SURFACES:
{
jlong pSrc = NEXT_LONG(b);
jlong pDst = NEXT_LONG(b);
if (oglc != NULL) {
RESET_PREVIOUS_OP();
}
oglc = OGLContext_SetSurfaces(env, pSrc, pDst);
dstOps = (OGLSDOps *)jlong_to_ptr(pDst);
}
break;
case sun_java2d_pipe_BufferedOpCodes_SET_SCRATCH_SURFACE:
{
jlong pConfigInfo = NEXT_LONG(b);
if (oglc != NULL) {
RESET_PREVIOUS_OP();
}
oglc = OGLSD_SetScratchSurface(env, pConfigInfo);
dstOps = NULL;
}
break;
case sun_java2d_pipe_BufferedOpCodes_FLUSH_SURFACE:
{
jlong pData = NEXT_LONG(b);
OGLSDOps *oglsdo = (OGLSDOps *)jlong_to_ptr(pData);
if (oglsdo != NULL) {
CONTINUE_IF_NULL(oglc);
RESET_PREVIOUS_OP();
OGLSD_Delete(env, oglsdo);
}
}
break;
case sun_java2d_pipe_BufferedOpCodes_DISPOSE_SURFACE:
{
jlong pData = NEXT_LONG(b);
OGLSDOps *oglsdo = (OGLSDOps *)jlong_to_ptr(pData);
if (oglsdo != NULL) {
CONTINUE_IF_NULL(oglc);
RESET_PREVIOUS_OP();
OGLSD_Delete(env, oglsdo);
if (oglsdo->privOps != NULL) {
free(oglsdo->privOps);
}
}
}
break;
case sun_java2d_pipe_BufferedOpCodes_DISPOSE_CONFIG:
{
jlong pConfigInfo = NEXT_LONG(b);
CONTINUE_IF_NULL(oglc);
RESET_PREVIOUS_OP();
OGLGC_DestroyOGLGraphicsConfig(pConfigInfo);
// the previous method will call glX/wglMakeCurrent(None),
// so we should nullify the current oglc and dstOps to avoid
// calling glFlush() (or similar) while no context is current
oglc = NULL;
dstOps = NULL;
}
break;
case sun_java2d_pipe_BufferedOpCodes_INVALIDATE_CONTEXT:
{
// flush just in case there are any pending operations in
// the hardware pipe
if (oglc != NULL) {
RESET_PREVIOUS_OP();
j2d_glFlush();
}
// invalidate the references to the current context and
// destination surface that are maintained at the native level
oglc = NULL;
dstOps = NULL;
}
break;
case sun_java2d_pipe_BufferedOpCodes_SAVE_STATE:
{
j2d_glPushAttrib(GL_ALL_ATTRIB_BITS);
j2d_glPushClientAttrib(GL_CLIENT_ALL_ATTRIB_BITS);
j2d_glMatrixMode(GL_MODELVIEW);
j2d_glPushMatrix();
j2d_glMatrixMode(GL_PROJECTION);
j2d_glPushMatrix();
j2d_glMatrixMode(GL_TEXTURE);
j2d_glPushMatrix();
}
break;
case sun_java2d_pipe_BufferedOpCodes_RESTORE_STATE:
{
j2d_glPopAttrib();
j2d_glPopClientAttrib();
j2d_glMatrixMode(GL_MODELVIEW);
j2d_glPopMatrix();
j2d_glMatrixMode(GL_PROJECTION);
j2d_glPopMatrix();
j2d_glMatrixMode(GL_TEXTURE);
j2d_glPopMatrix();
}
break;
case sun_java2d_pipe_BufferedOpCodes_SYNC:
{
sync = JNI_TRUE;
}
break;
// multibuffering ops
case sun_java2d_pipe_BufferedOpCodes_SWAP_BUFFERS:
{
jlong window = NEXT_LONG(b);
if (oglc != NULL) {
RESET_PREVIOUS_OP();
}
OGLSD_SwapBuffers(env, window);
}
break;
// special no-op (mainly used for achieving 8-byte alignment)
case sun_java2d_pipe_BufferedOpCodes_NOOP:
break;
// paint-related ops
case sun_java2d_pipe_BufferedOpCodes_RESET_PAINT:
{
OGLPaints_ResetPaint(oglc);
}
break;
case sun_java2d_pipe_BufferedOpCodes_SET_COLOR:
{
jint pixel = NEXT_INT(b);
OGLPaints_SetColor(oglc, pixel);
}
break;
case sun_java2d_pipe_BufferedOpCodes_SET_GRADIENT_PAINT:
{
jboolean useMask= NEXT_BOOLEAN(b);
jboolean cyclic = NEXT_BOOLEAN(b);
jdouble p0 = NEXT_DOUBLE(b);
jdouble p1 = NEXT_DOUBLE(b);
jdouble p3 = NEXT_DOUBLE(b);
jint pixel1 = NEXT_INT(b);
jint pixel2 = NEXT_INT(b);
OGLPaints_SetGradientPaint(oglc, useMask, cyclic,
p0, p1, p3,
pixel1, pixel2);
}
break;
case sun_java2d_pipe_BufferedOpCodes_SET_LINEAR_GRADIENT_PAINT:
{
jboolean useMask = NEXT_BOOLEAN(b);
jboolean linear = NEXT_BOOLEAN(b);
jint cycleMethod = NEXT_INT(b);
jint numStops = NEXT_INT(b);
jfloat p0 = NEXT_FLOAT(b);
jfloat p1 = NEXT_FLOAT(b);
jfloat p3 = NEXT_FLOAT(b);
void *fractions, *pixels;
fractions = b; SKIP_BYTES(b, numStops * sizeof(jfloat));
pixels = b; SKIP_BYTES(b, numStops * sizeof(jint));
OGLPaints_SetLinearGradientPaint(oglc, dstOps,
useMask, linear,
cycleMethod, numStops,
p0, p1, p3,
fractions, pixels);
}
break;
case sun_java2d_pipe_BufferedOpCodes_SET_RADIAL_GRADIENT_PAINT:
{
jboolean useMask = NEXT_BOOLEAN(b);
jboolean linear = NEXT_BOOLEAN(b);
jint numStops = NEXT_INT(b);
jint cycleMethod = NEXT_INT(b);
jfloat m00 = NEXT_FLOAT(b);
jfloat m01 = NEXT_FLOAT(b);
jfloat m02 = NEXT_FLOAT(b);
jfloat m10 = NEXT_FLOAT(b);
jfloat m11 = NEXT_FLOAT(b);
jfloat m12 = NEXT_FLOAT(b);
jfloat focusX = NEXT_FLOAT(b);
void *fractions, *pixels;
fractions = b; SKIP_BYTES(b, numStops * sizeof(jfloat));
pixels = b; SKIP_BYTES(b, numStops * sizeof(jint));
OGLPaints_SetRadialGradientPaint(oglc, dstOps,
useMask, linear,
cycleMethod, numStops,
m00, m01, m02,
m10, m11, m12,
focusX,
fractions, pixels);
}
break;
case sun_java2d_pipe_BufferedOpCodes_SET_TEXTURE_PAINT:
{
jboolean useMask= NEXT_BOOLEAN(b);
jboolean filter = NEXT_BOOLEAN(b);
jlong pSrc = NEXT_LONG(b);
jdouble xp0 = NEXT_DOUBLE(b);
jdouble xp1 = NEXT_DOUBLE(b);
jdouble xp3 = NEXT_DOUBLE(b);
jdouble yp0 = NEXT_DOUBLE(b);
jdouble yp1 = NEXT_DOUBLE(b);
jdouble yp3 = NEXT_DOUBLE(b);
OGLPaints_SetTexturePaint(oglc, useMask, pSrc, filter,
xp0, xp1, xp3,
yp0, yp1, yp3);
}
break;
// BufferedImageOp-related ops
case sun_java2d_pipe_BufferedOpCodes_ENABLE_CONVOLVE_OP:
{
jlong pSrc = NEXT_LONG(b);
jboolean edgeZero = NEXT_BOOLEAN(b);
jint kernelWidth = NEXT_INT(b);
jint kernelHeight = NEXT_INT(b);
OGLBufImgOps_EnableConvolveOp(oglc, pSrc, edgeZero,
kernelWidth, kernelHeight, b);
SKIP_BYTES(b, kernelWidth * kernelHeight * sizeof(jfloat));
}
break;
case sun_java2d_pipe_BufferedOpCodes_DISABLE_CONVOLVE_OP:
{
OGLBufImgOps_DisableConvolveOp(oglc);
}
break;
case sun_java2d_pipe_BufferedOpCodes_ENABLE_RESCALE_OP:
{
jlong pSrc = NEXT_LONG(b);
jboolean nonPremult = NEXT_BOOLEAN(b);
jint numFactors = 4;
unsigned char *scaleFactors = b;
unsigned char *offsets = (b + numFactors * sizeof(jfloat));
OGLBufImgOps_EnableRescaleOp(oglc, pSrc, nonPremult,
scaleFactors, offsets);
SKIP_BYTES(b, numFactors * sizeof(jfloat) * 2);
}
break;
case sun_java2d_pipe_BufferedOpCodes_DISABLE_RESCALE_OP:
{
OGLBufImgOps_DisableRescaleOp(oglc);
}
break;
case sun_java2d_pipe_BufferedOpCodes_ENABLE_LOOKUP_OP:
{
jlong pSrc = NEXT_LONG(b);
jboolean nonPremult = NEXT_BOOLEAN(b);
jboolean shortData = NEXT_BOOLEAN(b);
jint numBands = NEXT_INT(b);
jint bandLength = NEXT_INT(b);
jint offset = NEXT_INT(b);
jint bytesPerElem = shortData ? sizeof(jshort):sizeof(jbyte);
void *tableValues = b;
OGLBufImgOps_EnableLookupOp(oglc, pSrc, nonPremult, shortData,
numBands, bandLength, offset,
tableValues);
SKIP_BYTES(b, numBands * bandLength * bytesPerElem);
}
break;
case sun_java2d_pipe_BufferedOpCodes_DISABLE_LOOKUP_OP:
{
OGLBufImgOps_DisableLookupOp(oglc);
}
break;
default:
J2dRlsTraceLn1(J2D_TRACE_ERROR,
"OGLRenderQueue_flushBuffer: invalid opcode=%d", opcode);
if (oglc != NULL) {
RESET_PREVIOUS_OP();
}
return;
}
}
if (oglc != NULL) {
RESET_PREVIOUS_OP();
if (sync) {
j2d_glFinish();
} else {
j2d_glFlush();
}
OGLSD_Flush(env);
}
}