/*

 * 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 OGLSurfaceData_h_Included

#define OGLSurfaceData_h_Included

#include "java_awt_image_AffineTransformOp.h"

#include "sun_java2d_opengl_OGLSurfaceData.h"

#include "sun_java2d_pipe_hw_AccelSurface.h"

#include "J2D_GL/gl.h"

#include "SurfaceData.h"

#include "Trace.h"

#include "OGLFuncs.h"

typedef struct _OGLSDOps OGLSDOps;

/**

 * The OGLPixelFormat structure contains all the information OpenGL needs to

 * know when copying from or into a particular system memory image buffer (via

 * glDrawPixels(), glReadPixels, glTexSubImage2D(), etc).

 *

 *     GLenum format;

 * The pixel format parameter used in glDrawPixels() and other similar calls.

 * Indicates the component ordering for each pixel (e.g. GL_BGRA).

 *

 *     GLenum type;

 * The pixel data type parameter used in glDrawPixels() and other similar

 * calls.  Indicates the data type for an entire pixel or for each component

 * in a pixel (e.g. GL_UNSIGNED_BYTE with GL_BGR means a pixel consists of

 * 3 unsigned byte components, blue first, then green, then red;

 * GL_UNSIGNED_INT_8_8_8_8_REV with GL_BGRA means a pixel consists of 1

 * unsigned integer comprised of four byte components, alpha first, then red,

 * then green, then blue).

 *

 *     jint alignment;

 * The byte alignment parameter used in glPixelStorei(GL_UNPACK_ALIGNMENT).  A

 * value of 4 indicates that each pixel starts on a 4-byte aligned region in

 * memory, and so on.  This alignment parameter helps OpenGL speed up pixel

 * transfer operations by transferring memory in aligned blocks.

 *

 *     jboolean hasAlpha;

 * If true, indicates that this pixel format contains an alpha component.

 *

 *     jboolean isPremult;

 * If true, indicates that this pixel format contains color components that

 * have been pre-multiplied by their corresponding alpha component.

 */

typedef struct {

    GLenum   format;

    GLenum   type;

    jint     alignment;

    jboolean hasAlpha;

    jboolean isPremult;

} OGLPixelFormat;

/**

 * The OGLSDOps structure describes a native OpenGL surface and contains all

 * information pertaining to the native surface.  Some information about

 * the more important/different fields:

 *

 *     void *privOps;

 * Pointer to native-specific (GLX, WGL, etc.) SurfaceData info, such as the

 * native Drawable handle and GraphicsConfig data.

 *

 *     jint drawableType;

 * The surface type; can be any one of the surface type constants defined

 * below (OGLSD_WINDOW, OGLSD_TEXTURE, etc).

 *

 *     GLenum activeBuffer;

 * Can be either GL_FRONT if this is the front buffer surface of an onscreen

 * window or a pbuffer surface, or GL_BACK if this is the backbuffer surface

 * of an onscreen window.

 *

 *     jboolean isOpaque;

 * If true, the surface should be treated as being fully opaque.  If

 * the underlying surface (e.g. pbuffer) has an alpha channel and isOpaque

 * is true, then we should take appropriate action (i.e. call glColorMask()

 * to disable writes into the alpha channel) to ensure that the surface

 * remains fully opaque.

 *

 *     jboolean needsInit;

 * If true, the surface requires some one-time initialization, which should

 * be performed after a context has been made current to the surface for

 * the first time.

 *

 *     jint x/yOffset

 * The offset in pixels of the OpenGL viewport origin from the lower-left

 * corner of the heavyweight drawable.  For example, a top-level frame on

 * Windows XP has lower-left insets of (4,4).  The OpenGL viewport origin

 * would typically begin at the lower-left corner of the client region (inside

 * the frame decorations), but AWT/Swing will take the insets into account

 * when rendering into that window.  So in order to account for this, we

 * need to adjust the OpenGL viewport origin by an x/yOffset of (-4,-4).  On

 * X11, top-level frames typically don't have this insets issue, so their

 * x/yOffset would be (0,0) (the same applies to pbuffers).

 *

 *     jint width/height;

 * The cached surface bounds.  For offscreen surface types (OGLSD_FBOBJECT,

 * OGLSD_TEXTURE, etc.) these values must remain constant.  Onscreen window

 * surfaces (OGLSD_WINDOW, OGLSD_FLIP_BACKBUFFER, etc.) may have their

 * bounds changed in response to a programmatic or user-initiated event, so

 * these values represent the last known dimensions.  To determine the true

 * current bounds of this surface, query the native Drawable through the

 * privOps field.

 *

 *     GLuint textureID;

 * The texture object handle, as generated by glGenTextures().  If this value

 * is zero, the texture has not yet been initialized.

 *

 *     jint textureWidth/Height;

 * The actual bounds of the texture object for this surface.  If the

 * GL_ARB_texture_non_power_of_two extension is not present, the dimensions

 * of an OpenGL texture object must be a power-of-two (e.g. 64x32 or 128x512).

 * The texture image that we care about has dimensions specified by the width

 * and height fields in this OGLSDOps structure.  For example, if the image

 * to be stored in the texture has dimensions 115x47, the actual OpenGL

 * texture we allocate will have dimensions 128x64 to meet the pow2

 * restriction.  The image bounds within the texture can be accessed using

 * floating point texture coordinates in the range [0.0,1.0].

 *

 *     GLenum textureTarget;

 * The texture target of the texture object for this surface.  If this

 * surface is not backed by a texture, this value is set to zero.  Otherwise,

 * this value is GL_TEXTURE_RECTANGLE_ARB when the GL_ARB_texture_rectangle

 * extension is in use; if not, it is set to GL_TEXTURE_2D.

 *

 *     GLint textureFilter;

 * The current filter state for this texture object (can be either GL_NEAREST

 * or GL_LINEAR).  We cache this value here and check it before updating

 * the filter state to avoid redundant calls to glTexParameteri() when the

 * filter state remains constant (see the OGLSD_UPDATE_TEXTURE_FILTER()

 * macro below).

 *

 *     GLuint fbobjectID, depthID;

 * The object handles for the framebuffer object and depth renderbuffer

 * associated with this surface.  These fields are only used when

 * drawableType is OGLSD_FBOBJECT, otherwise they are zero.

 */

struct _OGLSDOps {

    SurfaceDataOps               sdOps;

    void                         *privOps;

    jint                         drawableType;

    GLenum                       activeBuffer;

    jboolean                     isOpaque;

    jboolean                     needsInit;

    jint                         xOffset;

    jint                         yOffset;

    jint                         width;

    jint                         height;

    GLuint                       textureID;

    jint                         textureWidth;

    jint                         textureHeight;

    GLenum                       textureTarget;

    GLint                        textureFilter;

    GLuint                       fbobjectID;

    GLuint                       depthID;

};

/**

 * The following convenience macros are used when rendering rectangles (either

 * a single rectangle, or a whole series of them).  To render a single

 * rectangle, simply invoke the GLRECT() macro.  To render a whole series of

 * rectangles, such as spans in a complex shape, first invoke GLRECT_BEGIN(),

 * then invoke the appropriate inner loop macro (either XYXY or XYWH) for

 * each rectangle, and finally invoke GLRECT_END() to notify OpenGL that the

 * vertex list is complete.  Care should be taken to avoid calling OpenGL

 * commands (besides GLRECT_BODY_*()) inside the BEGIN/END pair.

 */

#define GLRECT_BEGIN j2d_glBegin(GL_QUADS)

#define GLRECT_BODY_XYXY(x1, y1, x2, y2) \

    do { \

        j2d_glVertex2i(x1, y1); \

        j2d_glVertex2i(x2, y1); \

        j2d_glVertex2i(x2, y2); \

        j2d_glVertex2i(x1, y2); \

    } while (0)

#define GLRECT_BODY_XYWH(x, y, w, h) \

    GLRECT_BODY_XYXY(x, y, (x) + (w), (y) + (h))

#define GLRECT_END j2d_glEnd()

#define GLRECT(x, y, w, h) \

    do { \

        GLRECT_BEGIN; \

        GLRECT_BODY_XYWH(x, y, w, h); \

        GLRECT_END; \

    } while (0)

/**

 * These are shorthand names for the surface type constants defined in

 * OGLSurfaceData.java.

 */

#define OGLSD_UNDEFINED       sun_java2d_pipe_hw_AccelSurface_UNDEFINED

#define OGLSD_WINDOW          sun_java2d_pipe_hw_AccelSurface_WINDOW

#define OGLSD_TEXTURE         sun_java2d_pipe_hw_AccelSurface_TEXTURE

#define OGLSD_FLIP_BACKBUFFER sun_java2d_pipe_hw_AccelSurface_FLIP_BACKBUFFER

#define OGLSD_FBOBJECT        sun_java2d_pipe_hw_AccelSurface_RT_TEXTURE

/**

 * These are shorthand names for the filtering method constants used by

 * image transform methods.

 */

#define OGLSD_XFORM_DEFAULT 0

#define OGLSD_XFORM_NEAREST_NEIGHBOR \

    java_awt_image_AffineTransformOp_TYPE_NEAREST_NEIGHBOR

#define OGLSD_XFORM_BILINEAR \

    java_awt_image_AffineTransformOp_TYPE_BILINEAR

/**

 * Helper macros that update the current texture filter state only when

 * it needs to be changed, which helps reduce overhead for small texturing

 * operations.  The filter state is set on a per-texture (not per-context)

 * basis; for example, it is possible for one texture to be using GL_NEAREST

 * while another texture uses GL_LINEAR under the same context.

 */

#define OGLSD_INIT_TEXTURE_FILTER(oglSDOps, filter)                          \

    do {                                                                     \

        j2d_glTexParameteri((oglSDOps)->textureTarget,                       \

                            GL_TEXTURE_MAG_FILTER, (filter));                \

        j2d_glTexParameteri((oglSDOps)->textureTarget,                       \

                            GL_TEXTURE_MIN_FILTER, (filter));                \

        (oglSDOps)->textureFilter = (filter);                                \

    } while (0)

#define OGLSD_UPDATE_TEXTURE_FILTER(oglSDOps, filter)    \

    do {                                                 \

        if ((oglSDOps)->textureFilter != (filter)) {     \

            OGLSD_INIT_TEXTURE_FILTER(oglSDOps, filter); \

        }                                                \

    } while (0)

/**

 * Convenience macros for setting the texture wrap mode for a given target.

 * The texture wrap mode should be reset to our default value of

 * GL_CLAMP_TO_EDGE by calling OGLSD_RESET_TEXTURE_WRAP() when a texture

 * is first created.  If another mode is needed (e.g. GL_REPEAT in the case

 * of TexturePaint acceleration), one can call the OGLSD_UPDATE_TEXTURE_WRAP()

 * macro to easily set up the new wrap mode.  However, it is important to

 * restore the wrap mode back to its default value (by calling the

 * OGLSD_RESET_TEXTURE_WRAP() macro) when the operation is finished.

 */

#define OGLSD_UPDATE_TEXTURE_WRAP(target, wrap)                   \

    do {                                                          \

        j2d_glTexParameteri((target), GL_TEXTURE_WRAP_S, (wrap)); \

        j2d_glTexParameteri((target), GL_TEXTURE_WRAP_T, (wrap)); \

    } while (0)

#define OGLSD_RESET_TEXTURE_WRAP(target) \

    OGLSD_UPDATE_TEXTURE_WRAP(target, GL_CLAMP_TO_EDGE)

/**

 * Exported methods.

 */

jint OGLSD_Lock(JNIEnv *env,

                SurfaceDataOps *ops, SurfaceDataRasInfo *pRasInfo,

                jint lockflags);

void OGLSD_GetRasInfo(JNIEnv *env,

                      SurfaceDataOps *ops, SurfaceDataRasInfo *pRasInfo);

void OGLSD_Unlock(JNIEnv *env,

                  SurfaceDataOps *ops, SurfaceDataRasInfo *pRasInfo);

void OGLSD_Dispose(JNIEnv *env, SurfaceDataOps *ops);

void OGLSD_Delete(JNIEnv *env, OGLSDOps *oglsdo);

jint OGLSD_NextPowerOfTwo(jint val, jint max);

jboolean OGLSD_InitFBObject(GLuint *fbobjectID, GLuint *depthID,

                            GLuint textureID, GLenum textureTarget,

                            jint textureWidth, jint textureHeight);

#endif /* OGLSurfaceData_h_Included */