2
|
1 |
/*
|
|
2 |
* Copyright 2003-2007 Sun Microsystems, Inc. All Rights Reserved.
|
|
3 |
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
4 |
*
|
|
5 |
* This code is free software; you can redistribute it and/or modify it
|
|
6 |
* under the terms of the GNU General Public License version 2 only, as
|
|
7 |
* published by the Free Software Foundation. Sun designates this
|
|
8 |
* particular file as subject to the "Classpath" exception as provided
|
|
9 |
* by Sun in the LICENSE file that accompanied this code.
|
|
10 |
*
|
|
11 |
* This code is distributed in the hope that it will be useful, but WITHOUT
|
|
12 |
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
13 |
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
14 |
* version 2 for more details (a copy is included in the LICENSE file that
|
|
15 |
* accompanied this code).
|
|
16 |
*
|
|
17 |
* You should have received a copy of the GNU General Public License version
|
|
18 |
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
19 |
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
20 |
*
|
|
21 |
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
|
|
22 |
* CA 95054 USA or visit www.sun.com if you need additional information or
|
|
23 |
* have any questions.
|
|
24 |
*/
|
|
25 |
|
|
26 |
#ifndef OGLSurfaceData_h_Included
|
|
27 |
#define OGLSurfaceData_h_Included
|
|
28 |
|
|
29 |
#include "java_awt_image_AffineTransformOp.h"
|
|
30 |
#include "sun_java2d_opengl_OGLSurfaceData.h"
|
|
31 |
|
|
32 |
#include "J2D_GL/gl.h"
|
|
33 |
#include "SurfaceData.h"
|
|
34 |
#include "Trace.h"
|
|
35 |
#include "OGLFuncs.h"
|
|
36 |
|
|
37 |
typedef struct _OGLSDOps OGLSDOps;
|
|
38 |
|
|
39 |
/**
|
|
40 |
* The OGLPixelFormat structure contains all the information OpenGL needs to
|
|
41 |
* know when copying from or into a particular system memory image buffer (via
|
|
42 |
* glDrawPixels(), glReadPixels, glTexSubImage2D(), etc).
|
|
43 |
*
|
|
44 |
* GLenum format;
|
|
45 |
* The pixel format parameter used in glDrawPixels() and other similar calls.
|
|
46 |
* Indicates the component ordering for each pixel (e.g. GL_BGRA).
|
|
47 |
*
|
|
48 |
* GLenum type;
|
|
49 |
* The pixel data type parameter used in glDrawPixels() and other similar
|
|
50 |
* calls. Indicates the data type for an entire pixel or for each component
|
|
51 |
* in a pixel (e.g. GL_UNSIGNED_BYTE with GL_BGR means a pixel consists of
|
|
52 |
* 3 unsigned byte components, blue first, then green, then red;
|
|
53 |
* GL_UNSIGNED_INT_8_8_8_8_REV with GL_BGRA means a pixel consists of 1
|
|
54 |
* unsigned integer comprised of four byte components, alpha first, then red,
|
|
55 |
* then green, then blue).
|
|
56 |
*
|
|
57 |
* jint alignment;
|
|
58 |
* The byte alignment parameter used in glPixelStorei(GL_UNPACK_ALIGNMENT). A
|
|
59 |
* value of 4 indicates that each pixel starts on a 4-byte aligned region in
|
|
60 |
* memory, and so on. This alignment parameter helps OpenGL speed up pixel
|
|
61 |
* transfer operations by transferring memory in aligned blocks.
|
|
62 |
*
|
|
63 |
* jboolean hasAlpha;
|
|
64 |
* If true, indicates that this pixel format contains an alpha component.
|
|
65 |
*
|
|
66 |
* jboolean isPremult;
|
|
67 |
* If true, indicates that this pixel format contains color components that
|
|
68 |
* have been pre-multiplied by their corresponding alpha component.
|
|
69 |
*/
|
|
70 |
typedef struct {
|
|
71 |
GLenum format;
|
|
72 |
GLenum type;
|
|
73 |
jint alignment;
|
|
74 |
jboolean hasAlpha;
|
|
75 |
jboolean isPremult;
|
|
76 |
} OGLPixelFormat;
|
|
77 |
|
|
78 |
/**
|
|
79 |
* The OGLSDOps structure describes a native OpenGL surface and contains all
|
|
80 |
* information pertaining to the native surface. Some information about
|
|
81 |
* the more important/different fields:
|
|
82 |
*
|
|
83 |
* void *privOps;
|
|
84 |
* Pointer to native-specific (GLX, WGL, etc.) SurfaceData info, such as the
|
|
85 |
* native Drawable handle and GraphicsConfig data.
|
|
86 |
*
|
|
87 |
* jint drawableType;
|
|
88 |
* The surface type; can be any one of the surface type constants defined
|
|
89 |
* below (OGLSD_WINDOW, OGLSD_TEXTURE, etc).
|
|
90 |
*
|
|
91 |
* GLenum activeBuffer;
|
|
92 |
* Can be either GL_FRONT if this is the front buffer surface of an onscreen
|
|
93 |
* window or a pbuffer surface, or GL_BACK if this is the backbuffer surface
|
|
94 |
* of an onscreen window.
|
|
95 |
*
|
|
96 |
* jboolean isOpaque;
|
|
97 |
* If true, the surface should be treated as being fully opaque. If
|
|
98 |
* the underlying surface (e.g. pbuffer) has an alpha channel and isOpaque
|
|
99 |
* is true, then we should take appropriate action (i.e. call glColorMask()
|
|
100 |
* to disable writes into the alpha channel) to ensure that the surface
|
|
101 |
* remains fully opaque.
|
|
102 |
*
|
|
103 |
* jboolean needsInit;
|
|
104 |
* If true, the surface requires some one-time initialization, which should
|
|
105 |
* be performed after a context has been made current to the surface for
|
|
106 |
* the first time.
|
|
107 |
*
|
|
108 |
* jint x/yOffset
|
|
109 |
* The offset in pixels of the OpenGL viewport origin from the lower-left
|
|
110 |
* corner of the heavyweight drawable. For example, a top-level frame on
|
|
111 |
* Windows XP has lower-left insets of (4,4). The OpenGL viewport origin
|
|
112 |
* would typically begin at the lower-left corner of the client region (inside
|
|
113 |
* the frame decorations), but AWT/Swing will take the insets into account
|
|
114 |
* when rendering into that window. So in order to account for this, we
|
|
115 |
* need to adjust the OpenGL viewport origin by an x/yOffset of (-4,-4). On
|
|
116 |
* X11, top-level frames typically don't have this insets issue, so their
|
|
117 |
* x/yOffset would be (0,0) (the same applies to pbuffers).
|
|
118 |
*
|
|
119 |
* jint width/height;
|
|
120 |
* The cached surface bounds. For offscreen surface types (OGLSD_PBUFFER,
|
|
121 |
* OGLSD_TEXTURE, etc.) these values must remain constant. Onscreen window
|
|
122 |
* surfaces (OGLSD_WINDOW, OGLSD_FLIP_BACKBUFFER, etc.) may have their
|
|
123 |
* bounds changed in response to a programmatic or user-initiated event, so
|
|
124 |
* these values represent the last known dimensions. To determine the true
|
|
125 |
* current bounds of this surface, query the native Drawable through the
|
|
126 |
* privOps field.
|
|
127 |
*
|
|
128 |
* GLuint textureID;
|
|
129 |
* The texture object handle, as generated by glGenTextures(). If this value
|
|
130 |
* is zero, the texture has not yet been initialized.
|
|
131 |
*
|
|
132 |
* jint textureWidth/Height;
|
|
133 |
* The actual bounds of the texture object for this surface. If the
|
|
134 |
* GL_ARB_texture_non_power_of_two extension is not present, the dimensions
|
|
135 |
* of an OpenGL texture object must be a power-of-two (e.g. 64x32 or 128x512).
|
|
136 |
* The texture image that we care about has dimensions specified by the width
|
|
137 |
* and height fields in this OGLSDOps structure. For example, if the image
|
|
138 |
* to be stored in the texture has dimensions 115x47, the actual OpenGL
|
|
139 |
* texture we allocate will have dimensions 128x64 to meet the pow2
|
|
140 |
* restriction. The image bounds within the texture can be accessed using
|
|
141 |
* floating point texture coordinates in the range [0.0,1.0].
|
|
142 |
*
|
|
143 |
* GLenum textureTarget;
|
|
144 |
* The texture target of the texture object for this surface. If this
|
|
145 |
* surface is not backed by a texture, this value is set to zero. Otherwise,
|
|
146 |
* this value is GL_TEXTURE_RECTANGLE_ARB when the GL_ARB_texture_rectangle
|
|
147 |
* extension is in use; if not, it is set to GL_TEXTURE_2D.
|
|
148 |
*
|
|
149 |
* GLint textureFilter;
|
|
150 |
* The current filter state for this texture object (can be either GL_NEAREST
|
|
151 |
* or GL_LINEAR). We cache this value here and check it before updating
|
|
152 |
* the filter state to avoid redundant calls to glTexParameteri() when the
|
|
153 |
* filter state remains constant (see the OGLSD_UPDATE_TEXTURE_FILTER()
|
|
154 |
* macro below).
|
|
155 |
*
|
|
156 |
* GLuint fbobjectID, depthID;
|
|
157 |
* The object handles for the framebuffer object and depth renderbuffer
|
|
158 |
* associated with this surface. These fields are only used when
|
|
159 |
* drawableType is OGLSD_FBOBJECT, otherwise they are zero.
|
|
160 |
*/
|
|
161 |
struct _OGLSDOps {
|
|
162 |
SurfaceDataOps sdOps;
|
|
163 |
void *privOps;
|
|
164 |
jint drawableType;
|
|
165 |
GLenum activeBuffer;
|
|
166 |
jboolean isOpaque;
|
|
167 |
jboolean needsInit;
|
|
168 |
jint xOffset;
|
|
169 |
jint yOffset;
|
|
170 |
jint width;
|
|
171 |
jint height;
|
|
172 |
GLuint textureID;
|
|
173 |
jint textureWidth;
|
|
174 |
jint textureHeight;
|
|
175 |
GLenum textureTarget;
|
|
176 |
GLint textureFilter;
|
|
177 |
GLuint fbobjectID;
|
|
178 |
GLuint depthID;
|
|
179 |
};
|
|
180 |
|
|
181 |
/**
|
|
182 |
* The following convenience macros are used when rendering rectangles (either
|
|
183 |
* a single rectangle, or a whole series of them). To render a single
|
|
184 |
* rectangle, simply invoke the GLRECT() macro. To render a whole series of
|
|
185 |
* rectangles, such as spans in a complex shape, first invoke GLRECT_BEGIN(),
|
|
186 |
* then invoke the appropriate inner loop macro (either XYXY or XYWH) for
|
|
187 |
* each rectangle, and finally invoke GLRECT_END() to notify OpenGL that the
|
|
188 |
* vertex list is complete. Care should be taken to avoid calling OpenGL
|
|
189 |
* commands (besides GLRECT_BODY_*()) inside the BEGIN/END pair.
|
|
190 |
*/
|
|
191 |
|
|
192 |
#define GLRECT_BEGIN j2d_glBegin(GL_QUADS)
|
|
193 |
|
|
194 |
#define GLRECT_BODY_XYXY(x1, y1, x2, y2) \
|
|
195 |
do { \
|
|
196 |
j2d_glVertex2i(x1, y1); \
|
|
197 |
j2d_glVertex2i(x2, y1); \
|
|
198 |
j2d_glVertex2i(x2, y2); \
|
|
199 |
j2d_glVertex2i(x1, y2); \
|
|
200 |
} while (0)
|
|
201 |
|
|
202 |
#define GLRECT_BODY_XYWH(x, y, w, h) \
|
|
203 |
GLRECT_BODY_XYXY(x, y, (x) + (w), (y) + (h))
|
|
204 |
|
|
205 |
#define GLRECT_END j2d_glEnd()
|
|
206 |
|
|
207 |
#define GLRECT(x, y, w, h) \
|
|
208 |
do { \
|
|
209 |
GLRECT_BEGIN; \
|
|
210 |
GLRECT_BODY_XYWH(x, y, w, h); \
|
|
211 |
GLRECT_END; \
|
|
212 |
} while (0)
|
|
213 |
|
|
214 |
/**
|
|
215 |
* These are shorthand names for the surface type constants defined in
|
|
216 |
* OGLSurfaceData.java.
|
|
217 |
*/
|
|
218 |
#define OGLSD_UNDEFINED sun_java2d_opengl_OGLSurfaceData_UNDEFINED
|
|
219 |
#define OGLSD_WINDOW sun_java2d_opengl_OGLSurfaceData_WINDOW
|
|
220 |
#define OGLSD_PBUFFER sun_java2d_opengl_OGLSurfaceData_PBUFFER
|
|
221 |
#define OGLSD_TEXTURE sun_java2d_opengl_OGLSurfaceData_TEXTURE
|
|
222 |
#define OGLSD_FLIP_BACKBUFFER sun_java2d_opengl_OGLSurfaceData_FLIP_BACKBUFFER
|
|
223 |
#define OGLSD_FBOBJECT sun_java2d_opengl_OGLSurfaceData_FBOBJECT
|
|
224 |
|
|
225 |
/**
|
|
226 |
* These are shorthand names for the filtering method constants used by
|
|
227 |
* image transform methods.
|
|
228 |
*/
|
|
229 |
#define OGLSD_XFORM_DEFAULT 0
|
|
230 |
#define OGLSD_XFORM_NEAREST_NEIGHBOR \
|
|
231 |
java_awt_image_AffineTransformOp_TYPE_NEAREST_NEIGHBOR
|
|
232 |
#define OGLSD_XFORM_BILINEAR \
|
|
233 |
java_awt_image_AffineTransformOp_TYPE_BILINEAR
|
|
234 |
|
|
235 |
/**
|
|
236 |
* Helper macros that update the current texture filter state only when
|
|
237 |
* it needs to be changed, which helps reduce overhead for small texturing
|
|
238 |
* operations. The filter state is set on a per-texture (not per-context)
|
|
239 |
* basis; for example, it is possible for one texture to be using GL_NEAREST
|
|
240 |
* while another texture uses GL_LINEAR under the same context.
|
|
241 |
*/
|
|
242 |
#define OGLSD_INIT_TEXTURE_FILTER(oglSDOps, filter) \
|
|
243 |
do { \
|
|
244 |
j2d_glTexParameteri((oglSDOps)->textureTarget, \
|
|
245 |
GL_TEXTURE_MAG_FILTER, (filter)); \
|
|
246 |
j2d_glTexParameteri((oglSDOps)->textureTarget, \
|
|
247 |
GL_TEXTURE_MIN_FILTER, (filter)); \
|
|
248 |
(oglSDOps)->textureFilter = (filter); \
|
|
249 |
} while (0)
|
|
250 |
|
|
251 |
#define OGLSD_UPDATE_TEXTURE_FILTER(oglSDOps, filter) \
|
|
252 |
do { \
|
|
253 |
if ((oglSDOps)->textureFilter != (filter)) { \
|
|
254 |
OGLSD_INIT_TEXTURE_FILTER(oglSDOps, filter); \
|
|
255 |
} \
|
|
256 |
} while (0)
|
|
257 |
|
|
258 |
/**
|
|
259 |
* Convenience macros for setting the texture wrap mode for a given target.
|
|
260 |
* The texture wrap mode should be reset to our default value of
|
|
261 |
* GL_CLAMP_TO_EDGE by calling OGLSD_RESET_TEXTURE_WRAP() when a texture
|
|
262 |
* is first created. If another mode is needed (e.g. GL_REPEAT in the case
|
|
263 |
* of TexturePaint acceleration), one can call the OGLSD_UPDATE_TEXTURE_WRAP()
|
|
264 |
* macro to easily set up the new wrap mode. However, it is important to
|
|
265 |
* restore the wrap mode back to its default value (by calling the
|
|
266 |
* OGLSD_RESET_TEXTURE_WRAP() macro) when the operation is finished.
|
|
267 |
*/
|
|
268 |
#define OGLSD_UPDATE_TEXTURE_WRAP(target, wrap) \
|
|
269 |
do { \
|
|
270 |
j2d_glTexParameteri((target), GL_TEXTURE_WRAP_S, (wrap)); \
|
|
271 |
j2d_glTexParameteri((target), GL_TEXTURE_WRAP_T, (wrap)); \
|
|
272 |
} while (0)
|
|
273 |
|
|
274 |
#define OGLSD_RESET_TEXTURE_WRAP(target) \
|
|
275 |
OGLSD_UPDATE_TEXTURE_WRAP(target, GL_CLAMP_TO_EDGE)
|
|
276 |
|
|
277 |
/**
|
|
278 |
* Exported methods.
|
|
279 |
*/
|
|
280 |
jint OGLSD_Lock(JNIEnv *env,
|
|
281 |
SurfaceDataOps *ops, SurfaceDataRasInfo *pRasInfo,
|
|
282 |
jint lockflags);
|
|
283 |
void OGLSD_GetRasInfo(JNIEnv *env,
|
|
284 |
SurfaceDataOps *ops, SurfaceDataRasInfo *pRasInfo);
|
|
285 |
void OGLSD_Unlock(JNIEnv *env,
|
|
286 |
SurfaceDataOps *ops, SurfaceDataRasInfo *pRasInfo);
|
|
287 |
void OGLSD_Dispose(JNIEnv *env, SurfaceDataOps *ops);
|
|
288 |
void OGLSD_Flush(JNIEnv *env, OGLSDOps *oglsdo);
|
|
289 |
jint OGLSD_NextPowerOfTwo(jint val, jint max);
|
|
290 |
jboolean OGLSD_InitFBObject(GLuint *fbobjectID, GLuint *depthID,
|
|
291 |
GLuint textureID, GLenum textureTarget,
|
|
292 |
jint textureWidth, jint textureHeight);
|
|
293 |
|
|
294 |
#endif /* OGLSurfaceData_h_Included */
|