int
__glXDisp_FeedbackBuffer(__GLXclientState * cl, GLbyte * pc)
{
GLsizei size;
GLenum type;
__GLXcontext *cx;
int error;
cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
if (!cx) {
return error;
}
pc += __GLX_SINGLE_HDR_SIZE;
size = *(GLsizei *) (pc + 0);
type = *(GLenum *) (pc + 4);
if (cx->feedbackBufSize < size) {
cx->feedbackBuf = (GLfloat *) realloc(cx->feedbackBuf,
(size_t) size
* __GLX_SIZE_FLOAT32);
if (!cx->feedbackBuf) {
cl->client->errorValue = size;
return BadAlloc;
}
cx->feedbackBufSize = size;
}
glFeedbackBuffer(size, type, cx->feedbackBuf);
cx->hasUnflushedCommands = GL_TRUE;
return Success;
}
int __glXDispSwap_FeedbackBuffer(__GLXclientState *cl, GLbyte *pc)
{
ClientPtr client = cl->client;
GLsizei size;
GLenum type;
__GLX_DECLARE_SWAP_VARIABLES;
__GLXcontext *cx;
int error;
REQUEST_FIXED_SIZE(xGLXSingleReq, 8);
__GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
if (!cx) {
return error;
}
pc += __GLX_SINGLE_HDR_SIZE;
__GLX_SWAP_INT(pc+0);
__GLX_SWAP_INT(pc+4);
size = *(GLsizei *)(pc+0);
type = *(GLenum *)(pc+4);
if (cx->feedbackBufSize < size) {
cx->feedbackBuf = (GLfloat *) __glXRealloc(cx->feedbackBuf,
(size_t) size
* __GLX_SIZE_FLOAT32);
if (!cx->feedbackBuf) {
cl->client->errorValue = size;
return BadAlloc;
}
cx->feedbackBufSize = size;
}
glFeedbackBuffer(size, type, cx->feedbackBuf);
__GLX_NOTE_UNFLUSHED_CMDS(cx);
return Success;
}
enum piglit_result
piglit_display(void)
{
bool pass = true;
float buffer[2 +
ARRAY_SIZE(vertex_array) +
ARRAY_SIZE(color_array) +
ARRAY_SIZE(texcoord_array)];
int i, j;
piglit_ortho_projection(piglit_width, piglit_height, false);
glClearColor(0.0, 1.0, 0.0, 0.0);
glClear(GL_COLOR_BUFFER_BIT);
glVertexPointer(4, GL_FLOAT, 0, vertex_array);
glColorPointer(4, GL_FLOAT, 0, color_array);
glTexCoordPointer(4, GL_FLOAT, 0, texcoord_array);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
for (i = 0; i < ARRAY_SIZE(types); i++) {
bool case_pass = true;
int returned_count;
printf("Testing %s\n", types[i].name);
for (j = 0; j < ARRAY_SIZE(buffer); j++)
buffer[j] = -1.0;
glFeedbackBuffer(ARRAY_SIZE(buffer), types[i].type, buffer);
glRenderMode(GL_FEEDBACK);
glDrawArrays(GL_TRIANGLES, 0, 4);
returned_count = glRenderMode(GL_RENDER);
if (returned_count != types[i].count) {
case_pass = false;
} else {
for (j = 0; j < types[i].count; j++) {
if (fabs(buffer[j] - types[i].values[j]) > .01)
case_pass = false;
}
}
if (!case_pass) {
pass = false;
report_failure(&types[i], buffer, returned_count);
piglit_report_subtest_result(PIGLIT_FAIL,
types[i].name);
} else {
piglit_report_subtest_result(PIGLIT_PASS,
types[i].name);
}
}
piglit_present_results();
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
/*----------------------------------------------------------------------
ComputeFilledBox :
Modify Bounding Box according to opengl feedback mechanism
(after transformation, coordinates may have changed)
----------------------------------------------------------------------*/
void ComputeFilledBox (PtrBox box, int frame, int xmin, int xmax,
int ymin, int ymax, ThotBool show_bgimage)
{
GLfloat feedBuffer[4096];
GLint mode;
int size;
if (NotFeedBackMode)
{
glGetIntegerv (GL_RENDER_MODE, &mode);
box->BxBoundinBoxComputed = TRUE;
glFeedbackBuffer (4096, GL_2D, feedBuffer);
glRenderMode (GL_FEEDBACK);
NotFeedBackMode = FALSE;
DrawFilledBox (box, box->BxAbstractBox, frame, NULL,
xmin, xmax, ymin, ymax, FALSE, TRUE, TRUE, show_bgimage);
size = glRenderMode (mode);
NotFeedBackMode = TRUE;
if (size > 0)
{
box->BxClipX = -1;
box->BxClipY = -1;
getboundingbox (size, feedBuffer, frame,
&box->BxClipX,
&box->BxClipY,
&box->BxClipW,
&box->BxClipH);
box->BxBoundinBoxComputed = TRUE;
/* printBuffer (size, feedBuffer); */
}
}
}
void mglLine::scale( int rel_x, int rel_y, float x_dir, float y_dir )
{
GLfloat* buff = new GLfloat[5];
glFeedbackBuffer( 5, GL_2D, buff );
dprintf("before scaling: x1=%d, y1=%d, x2=%d, y2=%d\n", x1, y1, x2, y2 );
glRenderMode( GL_FEEDBACK );
glPushMatrix();
glScalef( x_dir, y_dir, 1 );
draw();
glPopMatrix();
//int xdiff = (int)buff[1] - x1;
//int ydiff = (int)buff[2] - y1;
x1 = ((int)buff[1] );
y1 = ((int)buff[2] );
x2 = ((int)buff[3] );
y2 = ((int)buff[4] );
delete[] buff;
dprintf("after scaling: x1=%d, y1=%d, x2=%d, y2=%d\n", x1, y1, x2, y2 );
char mstr[20];
itoa( x1, mstr, 10 );
PrintText( 50,50, mstr );
}
int
area(void)
{
GLfloat* buffer;
int i, n, size;
GLfloat a = 0;
/* allocate memory - 8 values in feedback buffer per triangle */
buffer = (GLfloat*)malloc(sizeof(GLfloat)*1*8);
glFeedbackBuffer(1*8, GL_2D, buffer);
glRenderMode(GL_FEEDBACK);
draw();
size = glRenderMode(GL_RENDER);
i = 0;
while (i < size) {
if (buffer[i] == GL_POLYGON_TOKEN) {
i++; n = buffer[i]; i++;
/* z component of cross product = twice triangle area, if
area is negative, the triangle is backfacing */
a = ((buffer[i+2]-buffer[i+0])*(buffer[i+5]-buffer[i+1]) -
(buffer[i+4]-buffer[i+0])*(buffer[i+3]-buffer[i+1])) / 2;
i += n*2;
} else {
printf("unknown token 0x%x parsed at %d\n", (short)buffer[i], i);
i++;
}
}
free(buffer);
return (int)a;
}
static void
DoFeedback(void)
{
GLint x;
glFeedbackBuffer(MAXFEED, GL_3D_COLOR, feedBuf);
(void) glRenderMode(GL_FEEDBACK);
glPushMatrix();
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(-175, 175, -175, 175);
glMatrixMode(GL_MODELVIEW);
glClearColor(0.0, 0.0, 0.0, 0.0);
glClear(GL_COLOR_BUFFER_BIT);
glScalef(zoom, zoom, zoom);
glRotatef(zRotation, 0, 0, 1);
Render(GL_FEEDBACK);
glPopMatrix();
x = glRenderMode(GL_RENDER);
if (x == -1) {
x = MAXFEED;
}
DrawFeedback((GLint) x);
}
void CPhysEnv::GetNearestPoint(int x, int y)
{
/// Local Variables ///////////////////////////////////////////////////////////
float *feedBuffer;
int hitCount;
tParticle *tempParticle;
int loop;
///////////////////////////////////////////////////////////////////////////////
// INITIALIZE A PLACE TO PUT ALL THE FEEDBACK INFO (3 DATA, 1 TAG, 2 TOKENS)
feedBuffer = (float *)malloc(sizeof(GLfloat) * m_ParticleCnt * 6);
// TELL OPENGL ABOUT THE BUFFER
glFeedbackBuffer(m_ParticleCnt * 6,GL_3D,feedBuffer);
(void)glRenderMode(GL_FEEDBACK); // SET IT IN FEEDBACK MODE
tempParticle = m_CurrentSys;
for (loop = 0; loop < m_ParticleCnt; loop++)
{
// PASS THROUGH A MARKET LETTING ME KNOW WHAT VERTEX IT WAS
glPassThrough((float)loop);
// SEND THE VERTEX
glBegin(GL_POINTS);
glVertex3fv((float *)&tempParticle->pos);
glEnd();
tempParticle++;
}
hitCount = glRenderMode(GL_RENDER); // HOW MANY HITS DID I GET
//fout<<"hit count "<<hitCount<,endl;
CompareBuffer(hitCount,feedBuffer,(float)x,(float)y); // CHECK THE HIT
free(feedBuffer); // GET RID OF THE MEMORY
}
void gl_feedbackbuffer( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] ) {
// Retrieve memory ptr from double argument:
GLfloat* ptr = (GLfloat*) PsychDoubleToPtr((GLdouble) mxGetScalar(prhs[2]));
if (NULL == glFeedbackBuffer) mogl_glunsupported("glFeedbackBuffer");
glFeedbackBuffer((GLsizei)mxGetScalar(prhs[0]),
(GLenum)mxGetScalar(prhs[1]),
ptr);
}
/*----------------------------------------------------------------------
ComputeBoundingBox :
Modify Bounding Box according to opengl feedback mechanism
(after transformation, coordinates may have changed)
----------------------------------------------------------------------*/
void ComputeBoundingBox (PtrBox box, int frame, int xmin, int xmax,
int ymin, int ymax)
{
#ifdef _GL
GLfloat feedBuffer[FEEDBUFFERSIZE];
GLint mode;
int size;
ViewFrame *pFrame;
if (NotFeedBackMode)
{
glGetIntegerv (GL_RENDER_MODE, &mode);
/* display into a temporary buffer */
glFeedbackBuffer (FEEDBUFFERSIZE, GL_2D, feedBuffer);
glRenderMode (GL_FEEDBACK);
NotFeedBackMode = FALSE;
/* display the box with transformation and clipping */
DisplayBox (box, frame, xmin, xmax, ymin, ymax, NULL, FALSE);
size = glRenderMode (mode);
NotFeedBackMode = TRUE;
if (size > 0)
{
/* the box is displayed */
if (size > FEEDBUFFERSIZE)
size = FEEDBUFFERSIZE;
box->BxClipX = -1;
box->BxClipY = -1;
getboundingbox (size, feedBuffer, frame,
&box->BxClipX,
&box->BxClipY,
&box->BxClipW,
&box->BxClipH);
box->BxBoundinBoxComputed = TRUE;
}
else
{
/* the box is not displayed */
pFrame = &ViewFrameTable[frame - 1];
/* */
box->BxClipX = box->BxXOrg - (pFrame->FrXOrg?pFrame->FrXOrg:pFrame->OldFrXOrg);
box->BxClipY = box->BxYOrg - (pFrame->FrYOrg?pFrame->FrYOrg:pFrame->OldFrYOrg);
box->BxClipW = box->BxW;
box->BxClipH = box->BxH;
box->BxBoundinBoxComputed = FALSE;
}
}
#endif /* _GL */
}
void mglLine::move( int x_distance, int y_distance )
{
GLfloat* buff = new GLfloat[5];
glFeedbackBuffer( 5, GL_2D, buff );
glRenderMode( GL_FEEDBACK );
glPushMatrix();
glTranslatef( (float)x_distance, (float)y_distance, 0 );
draw();
glPopMatrix();
x1 = (int)buff[1];
y1 = (int)buff[2];
x2 = (int)buff[3];
y2 = (int)buff[4];
delete[] buff;
}
int
determineBoundary(void (*renderFunc) (void), int probableSize)
{
static GLfloat *feedbackBuffer = NULL;
static int bufferSize = 0;
GLint returned;
if (bufferSize > probableSize) {
probableSize = bufferSize;
}
doFeedback:
/* XXX Careful, some systems still don't understand realloc of NULL. */
if (bufferSize < probableSize) {
bufferSize = probableSize;
feedbackBuffer = realloc(feedbackBuffer, bufferSize * sizeof(GLfloat));
}
glFeedbackBuffer(bufferSize, GL_2D, feedbackBuffer);
(void) glRenderMode(GL_FEEDBACK);
(*renderFunc) ();
returned = glRenderMode(GL_RENDER);
#if 0
if (returned == -1) {
#else
/* XXX RealityEngine workaround. */
if (returned == -1 || returned == probableSize) {
#endif
probableSize = probableSize + (probableSize >> 1);
goto doFeedback; /* Try again with larger feedback buffer. */
}
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0, width, 0, height);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
processFeedback(returned, feedbackBuffer);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
return returned;
}
void displayFeedback(void) {
GLfloat feedBuffer[1024];
GLint size;
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0.0, 100.0, 0.0, 100.0, 0.0, 1.0);
glClearColor(0.0, 0.0, 0.0, 0.0);
glClear(GL_COLOR_BUFFER_BIT);
drawGeometryFeedback(GL_RENDER);
glFeedbackBuffer(1024, GL_3D_COLOR, feedBuffer);
(void) glRenderMode(GL_FEEDBACK);
drawGeometryFeedback(GL_FEEDBACK);
size = glRenderMode(GL_RENDER);
printBufferFeedback(size, feedBuffer);
}
void mglLine::rotate( float theta, float x_rel, float y_rel )
{
GLfloat* buff = new GLfloat[5];
glFeedbackBuffer( 5, GL_2D, buff );
glRenderMode( GL_FEEDBACK );
glPushMatrix();
glTranslatef( x_rel, y_rel, 0 );
glRotatef( theta, 0, 0, 1 );
glTranslatef( -x_rel, -y_rel, 0 );
draw();
glPopMatrix();
x1 = (int)buff[1];
y1 = (int)buff[2];
x2 = (int)buff[3];
y2 = (int)buff[4];
delete[] buff;
}
int Occluded(struct L3PartS *PartPtr, int Color, float m1[4][4])
{
GLfloat feedbackBuffer[1024];
GLint returned = 0;
int size = 1024;
// Nutz!! Depth test is performed AFTER feedback is generated
// so this does NOT work. Need HP_OCCLUSION_TEST extension...
glFeedbackBuffer(size, GL_3D_COLOR, feedbackBuffer);
(void) glRenderMode(GL_FEEDBACK);
DrawPartBox(PartPtr, Color, m1, 0);
glFlush();
returned = glRenderMode(GL_RENDER);
if (returned > 0)
return 0;
else
return 1;
}
/* Tesselates a high order rectangular patch into single triangles using gl evaluators
*
* The problem is that OpenGL does not offer a direct way to return the tesselated primitives,
* and they can't be sent off for rendering directly either. Tesselating is slow, so we want
* to cache the patches in a vertex buffer. But more importantly, gl can't bind generated
* attributes to numbered shader attributes, so we have to store them and rebind them as needed
* in drawprim.
*
* To read back, the opengl feedback mode is used. This creates a problem because we want
* untransformed, unlit vertices, but feedback runs everything through transform and lighting.
* Thus disable lighting and set identity matrices to get unmodified colors and positions.
* To overcome clipping find the biggest x, y and z values of the vertices in the patch and scale
* them to [-1.0;+1.0] and set the viewport up to scale them back.
*
* Normals are more tricky: Draw white vertices with 3 directional lights, and calculate the
* resulting colors back to the normals.
*
* NOTE: This function activates a context for blitting, modifies matrices & viewport, but
* does not restore it because normally a draw follows immediately afterwards. The caller is
* responsible of taking care that either the gl states are restored, or the context activated
* for drawing to reset the lastWasBlit flag.
*/
HRESULT tesselate_rectpatch(IWineD3DDeviceImpl *This,
struct WineD3DRectPatch *patch) {
unsigned int i, j, num_quads, out_vertex_size, buffer_size, d3d_out_vertex_size;
float max_x = 0.0f, max_y = 0.0f, max_z = 0.0f, neg_z = 0.0f;
struct wined3d_stream_info stream_info;
struct wined3d_stream_info_element *e;
struct wined3d_context *context;
const BYTE *data;
const WINED3DRECTPATCH_INFO *info = &patch->RectPatchInfo;
DWORD vtxStride;
GLenum feedback_type;
GLfloat *feedbuffer;
/* Simply activate the context for blitting. This disables all the things we don't want and
* takes care of dirtifying. Dirtifying is preferred over pushing / popping, since drawing the
* patch (as opposed to normal draws) will most likely need different changes anyway. */
context = context_acquire(This, NULL, CTXUSAGE_BLIT);
/* First, locate the position data. This is provided in a vertex buffer in the stateblock.
* Beware of vbos
*/
device_stream_info_from_declaration(This, FALSE, &stream_info, NULL);
e = &stream_info.elements[WINED3D_FFP_POSITION];
if (e->buffer_object)
{
struct wined3d_buffer *vb;
vb = (struct wined3d_buffer *)This->stateBlock->streamSource[e->stream_idx];
e->data = (BYTE *)((unsigned long)e->data + (unsigned long)buffer_get_sysmem(vb));
}
vtxStride = e->stride;
data = e->data +
vtxStride * info->Stride * info->StartVertexOffsetHeight +
vtxStride * info->StartVertexOffsetWidth;
/* Not entirely sure about what happens with transformed vertices */
if (stream_info.position_transformed) FIXME("Transformed position in rectpatch generation\n");
if(vtxStride % sizeof(GLfloat)) {
/* glMap2f reads vertex sizes in GLfloats, the d3d stride is in bytes.
* I don't see how the stride could not be a multiple of 4, but make sure
* to check it
*/
ERR("Vertex stride is not a multiple of sizeof(GLfloat)\n");
}
if(info->Basis != WINED3DBASIS_BEZIER) {
FIXME("Basis is %s, how to handle this?\n", debug_d3dbasis(info->Basis));
}
if(info->Degree != WINED3DDEGREE_CUBIC) {
FIXME("Degree is %s, how to handle this?\n", debug_d3ddegree(info->Degree));
}
/* First, get the boundary cube of the input data */
for(j = 0; j < info->Height; j++) {
for(i = 0; i < info->Width; i++) {
const float *v = (const float *)(data + vtxStride * i + vtxStride * info->Stride * j);
if(fabs(v[0]) > max_x) max_x = fabs(v[0]);
if(fabs(v[1]) > max_y) max_y = fabs(v[1]);
if(fabs(v[2]) > max_z) max_z = fabs(v[2]);
if(v[2] < neg_z) neg_z = v[2];
}
}
/* This needs some improvements in the vertex decl code */
FIXME("Cannot find data to generate. Only generating position and normals\n");
patch->has_normals = TRUE;
patch->has_texcoords = FALSE;
ENTER_GL();
glMatrixMode(GL_PROJECTION);
checkGLcall("glMatrixMode(GL_PROJECTION)");
glLoadIdentity();
checkGLcall("glLoadIndentity()");
glScalef(1.0f / (max_x), 1.0f / (max_y), max_z == 0.0f ? 1.0f : 1.0f / (2.0f * max_z));
glTranslatef(0.0f, 0.0f, 0.5f);
checkGLcall("glScalef");
glViewport(-max_x, -max_y, 2 * (max_x), 2 * (max_y));
checkGLcall("glViewport");
/* Some states to take care of. If we're in wireframe opengl will produce lines, and confuse
* our feedback buffer parser
*/
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
checkGLcall("glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)");
IWineD3DDeviceImpl_MarkStateDirty(This, STATE_RENDER(WINED3DRS_FILLMODE));
if(patch->has_normals) {
static const GLfloat black[] = {0.0f, 0.0f, 0.0f, 0.0f};
static const GLfloat red[] = {1.0f, 0.0f, 0.0f, 0.0f};
static const GLfloat green[] = {0.0f, 1.0f, 0.0f, 0.0f};
static const GLfloat blue[] = {0.0f, 0.0f, 1.0f, 0.0f};
static const GLfloat white[] = {1.0f, 1.0f, 1.0f, 1.0f};
glEnable(GL_LIGHTING);
checkGLcall("glEnable(GL_LIGHTING)");
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, black);
checkGLcall("glLightModel for MODEL_AMBIENT");
IWineD3DDeviceImpl_MarkStateDirty(This, STATE_RENDER(WINED3DRS_AMBIENT));
for (i = 3; i < context->gl_info->limits.lights; ++i)
{
glDisable(GL_LIGHT0 + i);
checkGLcall("glDisable(GL_LIGHT0 + i)");
IWineD3DDeviceImpl_MarkStateDirty(This, STATE_ACTIVELIGHT(i));
}
IWineD3DDeviceImpl_MarkStateDirty(This, STATE_ACTIVELIGHT(0));
glLightfv(GL_LIGHT0, GL_DIFFUSE, red);
glLightfv(GL_LIGHT0, GL_SPECULAR, black);
glLightfv(GL_LIGHT0, GL_AMBIENT, black);
glLightfv(GL_LIGHT0, GL_POSITION, red);
glEnable(GL_LIGHT0);
checkGLcall("Setting up light 1");
IWineD3DDeviceImpl_MarkStateDirty(This, STATE_ACTIVELIGHT(1));
glLightfv(GL_LIGHT1, GL_DIFFUSE, green);
glLightfv(GL_LIGHT1, GL_SPECULAR, black);
glLightfv(GL_LIGHT1, GL_AMBIENT, black);
glLightfv(GL_LIGHT1, GL_POSITION, green);
glEnable(GL_LIGHT1);
checkGLcall("Setting up light 2");
IWineD3DDeviceImpl_MarkStateDirty(This, STATE_ACTIVELIGHT(2));
glLightfv(GL_LIGHT2, GL_DIFFUSE, blue);
glLightfv(GL_LIGHT2, GL_SPECULAR, black);
glLightfv(GL_LIGHT2, GL_AMBIENT, black);
glLightfv(GL_LIGHT2, GL_POSITION, blue);
glEnable(GL_LIGHT2);
checkGLcall("Setting up light 3");
IWineD3DDeviceImpl_MarkStateDirty(This, STATE_MATERIAL);
IWineD3DDeviceImpl_MarkStateDirty(This, STATE_RENDER(WINED3DRS_COLORVERTEX));
glDisable(GL_COLOR_MATERIAL);
glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, black);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, black);
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, white);
checkGLcall("Setting up materials");
}
/* Enable the needed maps.
* GL_MAP2_VERTEX_3 is needed for positional data.
* GL_AUTO_NORMAL to generate normals from the position. Do not use GL_MAP2_NORMAL.
* GL_MAP2_TEXTURE_COORD_4 for texture coords
*/
num_quads = ceilf(patch->numSegs[0]) * ceilf(patch->numSegs[1]);
out_vertex_size = 3 /* position */;
d3d_out_vertex_size = 3;
glEnable(GL_MAP2_VERTEX_3);
if(patch->has_normals && patch->has_texcoords) {
FIXME("Texcoords not handled yet\n");
feedback_type = GL_3D_COLOR_TEXTURE;
out_vertex_size += 8;
d3d_out_vertex_size += 7;
glEnable(GL_AUTO_NORMAL);
glEnable(GL_MAP2_TEXTURE_COORD_4);
} else if(patch->has_texcoords) {
FIXME("Texcoords not handled yet\n");
feedback_type = GL_3D_COLOR_TEXTURE;
out_vertex_size += 7;
d3d_out_vertex_size += 4;
glEnable(GL_MAP2_TEXTURE_COORD_4);
} else if(patch->has_normals) {
feedback_type = GL_3D_COLOR;
out_vertex_size += 4;
d3d_out_vertex_size += 3;
glEnable(GL_AUTO_NORMAL);
} else {
feedback_type = GL_3D;
}
checkGLcall("glEnable vertex attrib generation");
buffer_size = num_quads * out_vertex_size * 2 /* triangle list */ * 3 /* verts per tri */
+ 4 * num_quads /* 2 triangle markers per quad + num verts in tri */;
feedbuffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, buffer_size * sizeof(float) * 8);
glMap2f(GL_MAP2_VERTEX_3,
0.0f, 1.0f, vtxStride / sizeof(float), info->Width,
0.0f, 1.0f, info->Stride * vtxStride / sizeof(float), info->Height,
(const GLfloat *)data);
checkGLcall("glMap2f");
if(patch->has_texcoords) {
glMap2f(GL_MAP2_TEXTURE_COORD_4,
0.0f, 1.0f, vtxStride / sizeof(float), info->Width,
0.0f, 1.0f, info->Stride * vtxStride / sizeof(float), info->Height,
(const GLfloat *)data);
checkGLcall("glMap2f");
}
glMapGrid2f(ceilf(patch->numSegs[0]), 0.0f, 1.0f, ceilf(patch->numSegs[1]), 0.0f, 1.0f);
checkGLcall("glMapGrid2f");
glFeedbackBuffer(buffer_size * 2, feedback_type, feedbuffer);
checkGLcall("glFeedbackBuffer");
glRenderMode(GL_FEEDBACK);
glEvalMesh2(GL_FILL, 0, ceilf(patch->numSegs[0]), 0, ceilf(patch->numSegs[1]));
checkGLcall("glEvalMesh2");
i = glRenderMode(GL_RENDER);
if(i == -1) {
LEAVE_GL();
ERR("Feedback failed. Expected %d elements back\n", buffer_size);
HeapFree(GetProcessHeap(), 0, feedbuffer);
context_release(context);
return WINED3DERR_DRIVERINTERNALERROR;
} else if(i != buffer_size) {
LEAVE_GL();
ERR("Unexpected amount of elements returned. Expected %d, got %d\n", buffer_size, i);
HeapFree(GetProcessHeap(), 0, feedbuffer);
context_release(context);
return WINED3DERR_DRIVERINTERNALERROR;
} else {
TRACE("Got %d elements as expected\n", i);
}
HeapFree(GetProcessHeap(), 0, patch->mem);
patch->mem = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, num_quads * 6 * d3d_out_vertex_size * sizeof(float) * 8);
i = 0;
for(j = 0; j < buffer_size; j += (3 /* num verts */ * out_vertex_size + 2 /* tri marker */)) {
if(feedbuffer[j] != GL_POLYGON_TOKEN) {
ERR("Unexpected token: %f\n", feedbuffer[j]);
continue;
}
if(feedbuffer[j + 1] != 3) {
ERR("Unexpected polygon: %f corners\n", feedbuffer[j + 1]);
continue;
}
/* Somehow there are different ideas about back / front facing, so fix up the
* vertex order
*/
patch->mem[i + 0] = feedbuffer[j + out_vertex_size * 2 + 2]; /* x, triangle 2 */
patch->mem[i + 1] = feedbuffer[j + out_vertex_size * 2 + 3]; /* y, triangle 2 */
patch->mem[i + 2] = (feedbuffer[j + out_vertex_size * 2 + 4] - 0.5f) * 4.0f * max_z; /* z, triangle 3 */
if(patch->has_normals) {
patch->mem[i + 3] = feedbuffer[j + out_vertex_size * 2 + 5];
patch->mem[i + 4] = feedbuffer[j + out_vertex_size * 2 + 6];
patch->mem[i + 5] = feedbuffer[j + out_vertex_size * 2 + 7];
}
i += d3d_out_vertex_size;
patch->mem[i + 0] = feedbuffer[j + out_vertex_size * 1 + 2]; /* x, triangle 2 */
patch->mem[i + 1] = feedbuffer[j + out_vertex_size * 1 + 3]; /* y, triangle 2 */
patch->mem[i + 2] = (feedbuffer[j + out_vertex_size * 1 + 4] - 0.5f) * 4.0f * max_z; /* z, triangle 2 */
if(patch->has_normals) {
patch->mem[i + 3] = feedbuffer[j + out_vertex_size * 1 + 5];
patch->mem[i + 4] = feedbuffer[j + out_vertex_size * 1 + 6];
patch->mem[i + 5] = feedbuffer[j + out_vertex_size * 1 + 7];
}
i += d3d_out_vertex_size;
patch->mem[i + 0] = feedbuffer[j + out_vertex_size * 0 + 2]; /* x, triangle 1 */
patch->mem[i + 1] = feedbuffer[j + out_vertex_size * 0 + 3]; /* y, triangle 1 */
patch->mem[i + 2] = (feedbuffer[j + out_vertex_size * 0 + 4] - 0.5f) * 4.0f * max_z; /* z, triangle 1 */
if(patch->has_normals) {
patch->mem[i + 3] = feedbuffer[j + out_vertex_size * 0 + 5];
patch->mem[i + 4] = feedbuffer[j + out_vertex_size * 0 + 6];
patch->mem[i + 5] = feedbuffer[j + out_vertex_size * 0 + 7];
}
i += d3d_out_vertex_size;
}
if(patch->has_normals) {
/* Now do the same with reverse light directions */
static const GLfloat x[] = {-1.0f, 0.0f, 0.0f, 0.0f};
static const GLfloat y[] = { 0.0f, -1.0f, 0.0f, 0.0f};
static const GLfloat z[] = { 0.0f, 0.0f, -1.0f, 0.0f};
glLightfv(GL_LIGHT0, GL_POSITION, x);
glLightfv(GL_LIGHT1, GL_POSITION, y);
glLightfv(GL_LIGHT2, GL_POSITION, z);
checkGLcall("Setting up reverse light directions");
glRenderMode(GL_FEEDBACK);
checkGLcall("glRenderMode(GL_FEEDBACK)");
glEvalMesh2(GL_FILL, 0, ceilf(patch->numSegs[0]), 0, ceilf(patch->numSegs[1]));
checkGLcall("glEvalMesh2");
i = glRenderMode(GL_RENDER);
checkGLcall("glRenderMode(GL_RENDER)");
i = 0;
for(j = 0; j < buffer_size; j += (3 /* num verts */ * out_vertex_size + 2 /* tri marker */)) {
if(feedbuffer[j] != GL_POLYGON_TOKEN) {
ERR("Unexpected token: %f\n", feedbuffer[j]);
continue;
}
if(feedbuffer[j + 1] != 3) {
ERR("Unexpected polygon: %f corners\n", feedbuffer[j + 1]);
continue;
}
if(patch->mem[i + 3] == 0.0f)
patch->mem[i + 3] = -feedbuffer[j + out_vertex_size * 2 + 5];
if(patch->mem[i + 4] == 0.0f)
patch->mem[i + 4] = -feedbuffer[j + out_vertex_size * 2 + 6];
if(patch->mem[i + 5] == 0.0f)
patch->mem[i + 5] = -feedbuffer[j + out_vertex_size * 2 + 7];
normalize_normal(patch->mem + i + 3);
i += d3d_out_vertex_size;
if(patch->mem[i + 3] == 0.0f)
patch->mem[i + 3] = -feedbuffer[j + out_vertex_size * 1 + 5];
if(patch->mem[i + 4] == 0.0f)
patch->mem[i + 4] = -feedbuffer[j + out_vertex_size * 1 + 6];
if(patch->mem[i + 5] == 0.0f)
patch->mem[i + 5] = -feedbuffer[j + out_vertex_size * 1 + 7];
normalize_normal(patch->mem + i + 3);
i += d3d_out_vertex_size;
if(patch->mem[i + 3] == 0.0f)
patch->mem[i + 3] = -feedbuffer[j + out_vertex_size * 0 + 5];
if(patch->mem[i + 4] == 0.0f)
patch->mem[i + 4] = -feedbuffer[j + out_vertex_size * 0 + 6];
if(patch->mem[i + 5] == 0.0f)
patch->mem[i + 5] = -feedbuffer[j + out_vertex_size * 0 + 7];
normalize_normal(patch->mem + i + 3);
i += d3d_out_vertex_size;
}
}
glDisable(GL_MAP2_VERTEX_3);
glDisable(GL_AUTO_NORMAL);
glDisable(GL_MAP2_NORMAL);
glDisable(GL_MAP2_TEXTURE_COORD_4);
checkGLcall("glDisable vertex attrib generation");
LEAVE_GL();
context_release(context);
HeapFree(GetProcessHeap(), 0, feedbuffer);
vtxStride = 3 * sizeof(float);
if(patch->has_normals) {
vtxStride += 3 * sizeof(float);
}
if(patch->has_texcoords) {
vtxStride += 4 * sizeof(float);
}
memset(&patch->strided, 0, sizeof(patch->strided));
patch->strided.position.format = WINED3DFMT_R32G32B32_FLOAT;
patch->strided.position.lpData = (BYTE *) patch->mem;
patch->strided.position.dwStride = vtxStride;
if(patch->has_normals) {
patch->strided.normal.format = WINED3DFMT_R32G32B32_FLOAT;
patch->strided.normal.lpData = (BYTE *) patch->mem + 3 * sizeof(float) /* pos */;
patch->strided.normal.dwStride = vtxStride;
}
if(patch->has_texcoords) {
patch->strided.texCoords[0].format = WINED3DFMT_R32G32B32A32_FLOAT;
patch->strided.texCoords[0].lpData = (BYTE *) patch->mem + 3 * sizeof(float) /* pos */;
if(patch->has_normals) {
patch->strided.texCoords[0].lpData += 3 * sizeof(float);
}
patch->strided.texCoords[0].dwStride = vtxStride;
}
return WINED3D_OK;
}
/////////////////////////////////////////////////////////
// Render
//
void GEMglFeedbackBuffer :: render(GemState *state) {
glFeedbackBuffer (size, type, buffer);
error("i got data @ %X, but i don't know what to do with it!", buffer);
}
M(void, glFeedbackBuffer, jint size, jint type, jobject buffer) {
glFeedbackBuffer(size, type, BUFF(GLfloat, buffer));
}
void MakeSelection(int nChoice)
{
// Space for the feedback buffer
GLfloat feedBackBuff[FEED_BUFF_SIZE];
// Storeage for counters, etc.
int size,i,j,count;
// Initial minimum and maximum values
bRect.right = bRect.bottom = -999999.0f;
bRect.left = bRect.top = 999999.0f;
// Set the feedback buffer
glFeedbackBuffer(FEED_BUFF_SIZE,GL_2D, feedBackBuff);
// Enter feedback mode
glRenderMode(GL_FEEDBACK);
// Redraw the scene
DrawObjects();
// Leave feedback mode
size = glRenderMode(GL_RENDER);
// Parse the feedback buffer and get the
// min and max X and Y window coordinates
i = 0;
while(i < size)
{
// Search for appropriate token
if(feedBackBuff[i] == GL_PASS_THROUGH_TOKEN)
if(feedBackBuff[i+1] == (GLfloat)nChoice)
{
i+= 2;
// Loop until next token is reached
while(i < size && feedBackBuff[i] != GL_PASS_THROUGH_TOKEN)
{
// Just get the polygons
if(feedBackBuff[i] == GL_POLYGON_TOKEN)
{
// Get all the values for this polygon
count = (int)feedBackBuff[++i]; // How many vertices
i++;
for(j = 0; j < count; j++) // Loop for each vertex
{
// Min and Max X
if(feedBackBuff[i] > bRect.right)
bRect.right = feedBackBuff[i];
if(feedBackBuff[i] < bRect.left)
bRect.left = feedBackBuff[i];
i++;
// Min and Max Y
if(feedBackBuff[i] > bRect.bottom)
bRect.bottom = feedBackBuff[i];
if(feedBackBuff[i] < bRect.top)
bRect.top = feedBackBuff[i];
i++;
}
}
else
i++; // Get next index and keep looking
}
break;
}
i++;
}
}
int sftcpy(pScene sc,pMesh mesh) {
FILE *file;
GLfloat *fbbuffer;
GLint nvalues;
GLsizei size;
char *ptr,data[128];
static int nfree=0;
/* default */
if ( ddebug ) printf("soft copy\n");
//#ifdef IGL
//#define SFT_EXT "ps"
//#define GL2PS_EXT GL2PS_EPS
//#else
#define SFT_EXT "ps"
//#endif
/* get file name */
strcpy(data,mesh->name);
ptr = (char*)strstr(data,".mesh");
if ( ptr ) *ptr = '\0';
nfree = filnum(data,nfree,SFT_EXT);
if ( nfree == -1 ) return(0);
/* open PS file */
sprintf(data,"%s.%.3d." SFT_EXT,data,nfree);
file = fopen(data,"w");
if ( !file ) {
fprintf(stdout," Unable to open %s\n",data);
return(0);
}
//#ifdef IGL
// // http://www.geuz.org/gl2ps/#tth_sEc3
// GLint buffsize = 0, state = GL2PS_OVERFLOW;
// GLint viewport[4];
//
// glGetIntegerv(GL_VIEWPORT, viewport);
//
// while( state == GL2PS_OVERFLOW ){
// buffsize += 1024*1024;
// gl2psBeginPage (mesh->name, "medit", viewport,
// GL2PS_EXT, GL2PS_BSP_SORT, GL2PS_SILENT |
// GL2PS_OCCLUSION_CULL | GL2PS_BEST_ROOT,
// GL_RGBA, 0, NULL, 0, 0, 0, buffsize,
// file, data );
// drawModel(sc);
// if ( sc->type & S_DECO ) redrawStatusBar(sc);
// state = gl2psEndPage();
// }
//
// fclose(file);
//
//#else
/* size for feedback buffer */
size = 0;
nvalues = -1;
do {
size += 1024*1024;
fbbuffer = (GLfloat *)calloc(1+size,sizeof(GLfloat));
if ( !fbbuffer ) {
return(0);
}
if ( ddebug ) printf("feedback pointer = %p\n",fbbuffer);
/* draw scene in back buffer */
glFeedbackBuffer(size,GL_3D_COLOR,fbbuffer);
(void)glRenderMode(GL_FEEDBACK);
/*
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt(0.,0.,-sc->persp->depth, 0.,0.,0., 0.0,1.0,0.0);
setupView(sc);
glMultMatrixf(sc->view->matrix);
glTranslatef(sc->cx,sc->cy,sc->cz);
*/
drawModel(sc);
if ( sc->type & S_DECO ) redrawStatusBar(sc);
/*drawModel(sc);*/
nvalues = (GLint)glRenderMode(GL_RENDER);
if ( nvalues < 0 )
free(fbbuffer);
}
while ( nvalues < 0 );
if ( nvalues < 1 ) {
return(0);
}
else if ( ddebug ) printf("nvalues = %d size = %d\n",nvalues,size);
/* write EPS file */
glutSetCursor(GLUT_CURSOR_WAIT);
headps(file);
coreps(file,size,fbbuffer);
tailps(file);
if ( ddebug ) fprintf(stdout,"%s written\n",data);
glutSetCursor(GLUT_CURSOR_INHERIT);
//#endif
return(1);
}
void MakeSelection(int nChoice)
{
static GLfloat feedBackBuff[FEED_BUFF_SIZE];
int size,i,j,count;
boundingRect.right = boundingRect.bottom = -999999;
boundingRect.left = boundingRect.top = 999999;
glFeedbackBuffer(FEED_BUFF_SIZE,GL_2D, feedBackBuff);
glRenderMode(GL_FEEDBACK);
DrawObjects();
size = glRenderMode(GL_RENDER);
i = 0;
while(i < size)
{
if(feedBackBuff[i] == GL_PASS_THROUGH_TOKEN)
if(feedBackBuff[i+1] == (GLfloat)nChoice)
{
i+= 2;
while(i < size && feedBackBuff[i] != GL_PASS_THROUGH_TOKEN)
{
if(feedBackBuff[i] == GL_POLYGON_TOKEN)
{
count = (int)feedBackBuff[++i];
i++;
for(j = 0; j < count; j++)
{
if(feedBackBuff[i] > boundingRect.right)
boundingRect.right = int(feedBackBuff[i]);
if(feedBackBuff[i] < int(boundingRect.left))
boundingRect.left = int(feedBackBuff[i]);
i++;
if(feedBackBuff[i] > boundingRect.bottom)
boundingRect.bottom = int(feedBackBuff[i]);
if(feedBackBuff[i] < boundingRect.top)
boundingRect.top = int(feedBackBuff[i]);
i++;
}
}
else
i++;
}
break;
}
i++;
}
}
/* draw a model in feedback mode and return the list of visible vertices */
void
DrawModelFeedbackMode( Model *model, int width, int height,
Viewer3dParam *par, vector<int> &vertexIndices )
{
glEnable(GL_DEPTH_TEST);
glDisable(GL_LIGHTING);
glRenderMode (GL_RENDER);
GlClearWindow(1);
Setup3d( par );
DrawModel( model, 0);
GLfloat *pixels = (GLfloat*)malloc(3*width*height*sizeof(GLfloat));
glReadPixels(0,0,width, height, GL_DEPTH_COMPONENT,GL_FLOAT,(void*)pixels);
// no texture
int ii;
// init feedback mode
int BUFSIZE_FEEDBACK = 6 * ( model->NVertices() + 1 );
GLfloat *feedbackBuffer = (GLfloat *)malloc(BUFSIZE_FEEDBACK*sizeof(GLfloat));
if ( feedbackBuffer == NULL ) {
dbg(DBG_INFO, "Failed to init feedback data!\n");
}
glFeedbackBuffer(BUFSIZE_FEEDBACK,GL_3D,feedbackBuffer);
// set mode to feedback
glRenderMode(GL_FEEDBACK);
Setup3d( par );
for (ii=0;ii<model->NVertices();ii++) {
Vec3f vx = model->GetVertex(ii).v();
// pass index in feedback mode
glPassThrough(ii);
glBegin(GL_POINTS);
glVertex3f( vx[0], vx[1], vx[2] );
glEnd();
}
// retrieve feedback
GLuint hits = glRenderMode( GL_RENDER );
// parse hits
if ( (int)hits != -1 ) {
GLfloat *ptr = (GLfloat*)feedbackBuffer;
GLfloat x,y,z;
GLint code,id;
int counter =0;
for (ii=0;ii<(int)hits;ii++) {
code = (int)*ptr;
if ( code == GL_PASS_THROUGH_TOKEN ) {
id = (int)*(ptr+1);
ptr+=2;
ii+=1;
continue;
}
if ( code == GL_POINT_TOKEN ) {
x = *(ptr+1);
y = *(ptr+2);
z = *(ptr+3);
int xx = x - floor(x) > 0.5 ? int(floor(x))+1 : int(floor(x));
int yy = y - floor(y) > 0.5 ? int(floor(y))+1 : int(floor(y));
if ( xx < width - 1 && xx > 1 && \
yy < height - 1 && yy > 1 ) {
float thresh = MAX( MAX( MAX( pixels[yy*width+xx],
pixels[(yy-1)*width+xx]),
pixels[yy*width+xx-1] ),
pixels[(yy-1)*width+xx-1] );
if ( z <= thresh + 1E-5 ) {
vertexIndices.push_back( id );
counter++;
}
}
ptr += 4;
ii += 3;
continue;
}
}
dbg(DBG_INFO,"%d visible points (%d model points)\n", counter, model->NVertices());
}
// free memory
delete ( feedbackBuffer );
delete ( pixels );
}
void MakeSelection(int nChoice)
{
//选择缓冲区
static GLfloat feedBackBuff[FEED_BUFF_SIZE];
int size,i,j,count;
//初始化边界的最大和最小值
boundingRect.right = boundingRect.bottom = -999999.0f;
boundingRect.left = boundingRect.top = 999999.0f;
//设置反馈缓冲区
glFeedbackBuffer(FEED_BUFF_SIZE,GL_2D, feedBackBuff);
//进入反馈模式
glRenderMode(GL_FEEDBACK);
//绘制物体
DrawObjects();
//离开反馈模式
size = glRenderMode(GL_RENDER);
//解析反馈的数据，获得被选择物体的最大的和最小的窗口坐标
i = 0;
while(i < size)
{
// 搜索用户自定义的标记
if(feedBackBuff[i] == GL_PASS_THROUGH_TOKEN)
//判断标记是否与我们选择的物体名称相同
if(feedBackBuff[i+1] == (GLfloat)nChoice)
{
i+= 2;
while(i < size && feedBackBuff[i] != GL_PASS_THROUGH_TOKEN)
{
//多边形的标记
if(feedBackBuff[i] == GL_POLYGON_TOKEN)
{
//获得所有多边形的反馈信息
count = (int)feedBackBuff[++i];//有多少个顶点
i++;
for(j = 0; j < count; j++) //遍历每一个顶点
{
//取得x的最大最小值
if(feedBackBuff[i] > boundingRect.right)
boundingRect.right = feedBackBuff[i];
if(feedBackBuff[i] < boundingRect.left)
boundingRect.left = feedBackBuff[i];
i++;
//取得y的最大最小值
if(feedBackBuff[i] > boundingRect.bottom)
boundingRect.bottom = feedBackBuff[i];
if(feedBackBuff[i] < boundingRect.top)
boundingRect.top = feedBackBuff[i];
i++;
}
}
else
i++;
}
break;
}
i++;
}
}
JNIEXPORT void JNICALL Java_OpenGL_GLFeedbackBuffer_feedbackBuffer
(JNIEnv *env, jobject feedbackBuffer, jint size, jint type, jint bufferPointer)
{
glFeedbackBuffer(size, type, (GLfloat*) bufferPointer);
}
