/* This calls the appropriate vertex pointer based on the given capability. */
static void _setVertexPointer(GLint size,
GLenum type,
GLsizei stride,
const GLvoid *pointer,
GLenum capability)
{
switch(capability) {
case GL_VERTEX_ARRAY:
glVertexPointer(size, type, stride, pointer);
break;
case GL_NORMAL_ARRAY:
glNormalPointer(type, stride, pointer);
break;
case GL_COLOR_ARRAY:
glColorPointer(size, type, stride, pointer);
break;
case GL_INDEX_ARRAY:
glIndexPointer(type, stride, pointer);
break;
case GL_TEXTURE_COORD_ARRAY:
glTexCoordPointer(size, type, stride, pointer);
break;
case GL_EDGE_FLAG_ARRAY:
glEdgeFlagPointer(stride, pointer);
break;
default:
fatalUnreportableError("Unexpected capabilitity passed to _setVertexPointer");
break;
}
}
enum piglit_result
piglit_display(void)
{
bool pass = true;
float green[] = {0, 1, 0, 0};
float clear[] = {0.5, 0.5, 0.5, 0.5};
struct {
GLfloat x, y;
GLfloat r, g, b, a;
GLboolean edgeflag;
} verts[] = {
{ 1.5, 1.5, 0.0, 1.0, 0.0, 0.0, GL_TRUE },
{ 5.5, 1.5, 0.0, 1.0, 0.0, 0.0, GL_FALSE },
{ 5.5, 5.5, 0.0, 1.0, 0.0, 0.0, GL_TRUE },
{ 1.5, 5.5, 0.0, 1.0, 0.0, 0.0, GL_FALSE },
};
piglit_ortho_projection(piglit_width, piglit_height, false);
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
glClearColor(0.5, 0.5, 0.5, 0.5);
glClear(GL_COLOR_BUFFER_BIT);
glColor4f(0, 1, 0, 0);
glVertexPointer(2, GL_FLOAT, sizeof(verts[0]), &verts[0].x);
glVertexAttribPointer(color_index, 4, GL_FLOAT, GL_FALSE,
sizeof(verts[0]), &verts[0].r);
glEdgeFlagPointer(sizeof(verts[0]), &verts[0].edgeflag);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableVertexAttribArray(color_index);
glEnableClientState(GL_EDGE_FLAG_ARRAY);
glDrawArrays(GL_POLYGON, 0, 4);
pass = piglit_probe_pixel_rgba(3, 1, green) && pass;
pass = piglit_probe_pixel_rgba(3, 5, green) && pass;
pass = piglit_probe_pixel_rgba(1, 3, clear) && pass;
pass = piglit_probe_pixel_rgba(5, 3, clear) && pass;
piglit_present_results();
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
void
piglit_init(int argc, char **argv)
{
bool pass = true;
GLubyte dummy[100];
glVertexPointer(2, GL_FLOAT, 12, dummy);
glNormalPointer(GL_FLOAT, 0, dummy);
glColorPointer(4, GL_UNSIGNED_BYTE, 16, dummy);
glSecondaryColorPointer(3, GL_SHORT, 32, dummy);
glTexCoordPointer(3, GL_SHORT, 18, dummy);
glEdgeFlagPointer(4, dummy);
glIndexPointer(GL_SHORT, 10, dummy);
glFogCoordPointer(GL_FLOAT, 8, dummy);
pass = test_get(GL_VERTEX_ARRAY_SIZE, 2) && pass;
pass = test_get(GL_VERTEX_ARRAY_TYPE, GL_FLOAT) && pass;
pass = test_get(GL_VERTEX_ARRAY_STRIDE, 12) && pass;
pass = test_get(GL_NORMAL_ARRAY_TYPE, GL_FLOAT) && pass;
pass = test_get(GL_NORMAL_ARRAY_STRIDE, 0) && pass;
pass = test_get(GL_COLOR_ARRAY_SIZE, 4) && pass;
pass = test_get(GL_COLOR_ARRAY_TYPE, GL_UNSIGNED_BYTE) && pass;
pass = test_get(GL_COLOR_ARRAY_STRIDE, 16) && pass;
pass = test_get(GL_SECONDARY_COLOR_ARRAY_SIZE, 3) && pass;
pass = test_get(GL_SECONDARY_COLOR_ARRAY_TYPE, GL_SHORT) && pass;
pass = test_get(GL_SECONDARY_COLOR_ARRAY_STRIDE, 32) && pass;
pass = test_get(GL_TEXTURE_COORD_ARRAY_SIZE, 3) && pass;
pass = test_get(GL_TEXTURE_COORD_ARRAY_TYPE, GL_SHORT) && pass;
pass = test_get(GL_TEXTURE_COORD_ARRAY_STRIDE, 18) && pass;
pass = test_get(GL_EDGE_FLAG_ARRAY_STRIDE, 4) && pass;
pass = test_get(GL_INDEX_ARRAY_TYPE, GL_SHORT) && pass;
pass = test_get(GL_INDEX_ARRAY_STRIDE, 10) && pass;
pass = test_get(GL_FOG_COORD_ARRAY_TYPE, GL_FLOAT) && pass;
pass = test_get(GL_FOG_COORD_ARRAY_STRIDE, 8) && pass;
piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL);
}
void glEdgeFlagPointerEXT( GLsizei stride, GLsizei count, const GLboolean *ptr )
{
(void) count;
glEdgeFlagPointer( stride, ptr );
}
// ----------------------------------------------------------------------------
void
vertex_attribute_edge_flag_enable( vertex_attribute_t *attr )
{
glEnableClientState( attr->target );
glEdgeFlagPointer( attr->stride, attr->pointer );
}
void nuiGLDrawContext::DrawArray(const nuiRenderArray& rArray)
{
if (mCurrentState.mAntialiasing)
{
/*
glEnable(GL_POLYGON_SMOOTH);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
*/
// glHint(GL_MULTISAMPLE_FILTER_HINT_NV, GL_NICEST);
glEnable(GL_MULTISAMPLE_ARB);
}
if (rArray.IsArrayEnabled(nuiRenderArray::eVertex))
{
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(rArray.GetVertexElements(), GL_FLOAT, 0, &rArray.GetVertices()[0]);
}
else
glDisableClientState(GL_VERTEX_ARRAY);
if (rArray.IsArrayEnabled(nuiRenderArray::eColor))
{
glEnableClientState(GL_COLOR_ARRAY);
glColorPointer(rArray.GetColorElements(), GL_FLOAT, 0, &rArray.GetColors()[0]);
}
else
{
nuiColor c;
switch (rArray.GetMode())
{
case GL_POINTS:
case GL_LINES:
case GL_LINE_LOOP:
case GL_LINE_STRIP:
c = mCurrentState.mStrokeColor;
break;
case GL_TRIANGLES:
case GL_TRIANGLE_STRIP:
case GL_TRIANGLE_FAN:
case GL_QUADS:
case GL_QUAD_STRIP:
case GL_POLYGON:
c = mCurrentState.mFillColor;
break;
}
glColor4f(
c.Red(),
c.Green(),
c.Blue(),
c.Alpha()
);
glDisableClientState(GL_COLOR_ARRAY);
}
if (rArray.IsArrayEnabled(nuiRenderArray::eTexCoord))
{
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(rArray.GetTexCoordElements(), GL_FLOAT, 0, &rArray.GetTexCoords()[0]);
}
else
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
if (rArray.IsArrayEnabled(nuiRenderArray::eNormal))
{
glEnableClientState(GL_NORMAL_ARRAY);
glNormalPointer(GL_FLOAT, 0, &rArray.GetNormals()[0]);
}
else
glDisableClientState(GL_NORMAL_ARRAY);
if (rArray.IsArrayEnabled(nuiRenderArray::eEdgeFlag))
{
glEnableClientState(GL_EDGE_FLAG_ARRAY);
glEdgeFlagPointer(1, &rArray.GetEdgeFlags()[0]);
}
else
glDisableClientState(GL_EDGE_FLAG_ARRAY);
glDrawArrays(rArray.GetMode(), 0, rArray.GetSize());
if (mCurrentState.mAntialiasing)
{
glDisable(GL_MULTISAMPLE_ARB);
}
glColor3f(1.0f, 1.0f, 1.0f);
}
void
__glXDispSwap_DrawArrays(GLbyte * pc)
{
__GLXdispatchDrawArraysHeader *hdr = (__GLXdispatchDrawArraysHeader *) pc;
__GLXdispatchDrawArraysComponentHeader *compHeader;
GLint numVertexes = hdr->numVertexes;
GLint numComponents = hdr->numComponents;
GLenum primType = hdr->primType;
GLint stride = 0;
int i;
__GLX_DECLARE_SWAP_VARIABLES;
__GLX_SWAP_INT(&numVertexes);
__GLX_SWAP_INT(&numComponents);
__GLX_SWAP_INT(&primType);
pc += sizeof(__GLXdispatchDrawArraysHeader);
compHeader = (__GLXdispatchDrawArraysComponentHeader *) pc;
/* compute stride (same for all component arrays) */
for (i = 0; i < numComponents; i++) {
GLenum datatype = compHeader[i].datatype;
GLint numVals = compHeader[i].numVals;
GLenum component = compHeader[i].component;
__GLX_SWAP_INT(&datatype);
__GLX_SWAP_INT(&numVals);
__GLX_SWAP_INT(&component);
stride += __GLX_PAD(numVals * __glXTypeSize(datatype));
}
pc += numComponents * sizeof(__GLXdispatchDrawArraysComponentHeader);
/* set up component arrays */
for (i = 0; i < numComponents; i++) {
GLenum datatype = compHeader[i].datatype;
GLint numVals = compHeader[i].numVals;
GLenum component = compHeader[i].component;
__GLX_SWAP_INT(&datatype);
__GLX_SWAP_INT(&numVals);
__GLX_SWAP_INT(&component);
swapArray(numVals, datatype, stride, numVertexes, pc);
switch (component) {
case GL_VERTEX_ARRAY:
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(numVals, datatype, stride, pc);
break;
case GL_NORMAL_ARRAY:
glEnableClientState(GL_NORMAL_ARRAY);
glNormalPointer(datatype, stride, pc);
break;
case GL_COLOR_ARRAY:
glEnableClientState(GL_COLOR_ARRAY);
glColorPointer(numVals, datatype, stride, pc);
break;
case GL_INDEX_ARRAY:
glEnableClientState(GL_INDEX_ARRAY);
glIndexPointer(datatype, stride, pc);
break;
case GL_TEXTURE_COORD_ARRAY:
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(numVals, datatype, stride, pc);
break;
case GL_EDGE_FLAG_ARRAY:
glEnableClientState(GL_EDGE_FLAG_ARRAY);
glEdgeFlagPointer(stride, (const GLboolean *) pc);
break;
case GL_SECONDARY_COLOR_ARRAY:
{
PFNGLSECONDARYCOLORPOINTERPROC SecondaryColorPointerEXT =
__glGetProcAddress("glSecondaryColorPointerEXT");
glEnableClientState(GL_SECONDARY_COLOR_ARRAY);
SecondaryColorPointerEXT(numVals, datatype, stride, pc);
break;
}
case GL_FOG_COORD_ARRAY:
{
PFNGLFOGCOORDPOINTERPROC FogCoordPointerEXT =
__glGetProcAddress("glFogCoordPointerEXT");
glEnableClientState(GL_FOG_COORD_ARRAY);
FogCoordPointerEXT(datatype, stride, pc);
break;
}
default:
break;
}
pc += __GLX_PAD(numVals * __glXTypeSize(datatype));
}
glDrawArrays(primType, 0, numVertexes);
/* turn off anything we might have turned on */
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);
glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_INDEX_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisableClientState(GL_EDGE_FLAG_ARRAY);
glDisableClientState(GL_SECONDARY_COLOR_ARRAY);
glDisableClientState(GL_FOG_COORD_ARRAY);
}
void
CVisComplexObj::draw()
{
logToFile((f, "VisComplexObj Draw\n"));
if(!Show) return;
double *vertices = exact ? scrVertices : getVertices();
if (arrays[aiIndices] != 0 && GetLength(arrays[aiIndices], 1) == 0 ||
vertices == 0 || GetLength(vertices, 1) == 0)
return;
glPushMatrix();
if(exact){
glMatrixMode (GL_MODELVIEW);
glLoadIdentity();
glTranslated(0.0, 0.0, Z);
}
else {
// Only get exact calibration location of center
// and approximate the rest of the points
float x = XPosToScreen((float)X,(float)Y);
float y = YPosToScreen((float)X,(float)Y);
Clipped = VISWIN_IS_CLIPPED(x,y);
DPosToDScreen(JAC,x,y);
// Rot 4x4, allocated by column, as in matlab
// Jac, though, is only the 2x2 Jacobian
ROT[0]=(float)scale*JAC[0][0]; ROT[1]=(float)scale*JAC[1][0];
ROT[4]=(float)scale*JAC[0][1]; ROT[5]=(float)scale*JAC[1][1];
ROT[12]=x; ROT[13]=y; ROT[14]=Z;
glMatrixMode (GL_MODELVIEW);
// glLoadIdentity();
// glTranslatef((float)x,(float)y,Z); // 3: Translate
// glScalef((float)scx,(float)scy,1); // 2: Scale
glLoadMatrixf(ROT); // 2: Translate and Scale
glRotatef((float)angle,0,0,1); // 1: Rotate About Z axis
}
#if INDEX_MODE
glIndexi(ColorIndex);
#else
glColor4d(color[0],color[1],color[2],alpha);
#endif
if (drawMode >= odmLines && drawMode <= odmLineLoop)
{
if (lineStipple != 0)
{
glLineStipple(lineStippleFactor, lineStipple);
glEnable(GL_LINE_STIPPLE);
}
if (lineWidth != 1.0) glLineWidth((float)lineWidth);
}
if (drawMode == odmPoints && pointSize != 1.0) glPointSize((float)pointSize);
if (drawMode >= odmTriangles && drawMode <= odmPolygon)
{
if (arrays[aiPolygonStipple] != 0)
{
glEnable(GL_POLYGON_STIPPLE);
glPolygonStipple((unsigned char *)arrays[aiPolygonStipple]);
}
}
if (vertices != 0) glEnableClientState(GL_VERTEX_ARRAY);
if (arrays[aiNormals ] != 0) glEnableClientState(GL_NORMAL_ARRAY);
if (arrays[aiColors ] != 0) glEnableClientState(GL_COLOR_ARRAY);
if (arrays[aiEdgeFlags] != 0) glEnableClientState(GL_EDGE_FLAG_ARRAY);
if (vertices != 0)
glVertexPointer(GetLength(vertices, 0), GL_DOUBLE, 0, vertices);
if (arrays[aiNormals] != 0)
glNormalPointer(GL_DOUBLE, 0, arrays[aiNormals]);
if (arrays[aiColors] != 0)
glColorPointer (GetLength(arrays[aiColors], 0), GL_DOUBLE, 0, arrays[aiColors]);
if (arrays[aiEdgeFlags] != 0)
glEdgeFlagPointer(0, arrays[aiEdgeFlags]);
if (arrays[aiIndices] != 0)
glDrawElements(glDrawModeMap[drawMode], GetLength(arrays[aiIndices]), GL_UNSIGNED_INT, arrays[aiIndices]);
else
glDrawArrays(glDrawModeMap[drawMode], 0, GetLength(vertices, 1));
if (vertices != 0) glDisableClientState(GL_VERTEX_ARRAY);
if (arrays[aiNormals ] != 0) glDisableClientState(GL_NORMAL_ARRAY);
if (arrays[aiColors ] != 0) glDisableClientState(GL_COLOR_ARRAY);
if (arrays[aiEdgeFlags] != 0) glDisableClientState(GL_EDGE_FLAG_ARRAY);
if (drawMode >= odmTriangles && drawMode <= odmPolygon)
{
if (arrays[aiPolygonStipple] != 0) glDisable(GL_POLYGON_STIPPLE);
}
if (drawMode >= odmLines && drawMode <= odmLineLoop)
{
if (lineStipple != 0) glDisable(GL_LINE_STIPPLE);
if (lineWidth != 1.0) glLineWidth(1.0);
}
if (drawMode == odmPoints && pointSize != 1.0) glPointSize(1.0);
glPopMatrix();
}
M(void, glEdgeFlagPointer, jint stride, jobject ptr) {
glEdgeFlagPointer(stride, BUFF(GLvoid, ptr));
}
