void App::drawEnvironment(const float4x4 &mvp)
{
renderer->reset();
renderer->setShader(skyboxShaders[radialSelect][constMipSelect]);
renderer->setTexture("EnvCube", cubeEnv);
renderer->setTexture("Env2D", radialEnv);
renderer->setShaderConstant1f("mipBias", mipBias->getValue());
renderer->setDepthState(noDepthWrite);
renderer->apply();
float4x4 iMvp = !mvp;
float4 v0( 0, 2, 1, 1);
float4 v1( 3, -1, 1, 1);
float4 v2(-3, -1, 1, 1);
glBegin(GL_TRIANGLES);
glTexCoord4fv(iMvp * v0);
glVertex4fv(v0);
glTexCoord4fv(iMvp * v1);
glVertex4fv(v1);
glTexCoord4fv(iMvp * v2);
glVertex4fv(v2);
glEnd();
}
static void WINE_GLAPI wine_glMultiTexCoord4fvARB(GLenum target, const GLfloat *v) {
if(target != GL_TEXTURE0) {
ERR("Texture unit > 0 used, but GL_ARB_multitexture is not supported\n");
return;
}
glTexCoord4fv(v);
}
void GeomRenderer::sendTexCoord(GLuint texCoordIndex)
{
assert(texCoordData.size >= 1 && texCoordData.size <= 4);
switch(texCoordData.type)
{
case GL_SHORT:
if (texCoordData.size == 1) glTexCoord1sv((const GLshort*)((const char*)texCoordData.pointer + texCoordIndex*texCoordData.stride));
if (texCoordData.size == 2) glTexCoord2sv((const GLshort*)((const char*)texCoordData.pointer + texCoordIndex*texCoordData.stride));
if (texCoordData.size == 3) glTexCoord3sv((const GLshort*)((const char*)texCoordData.pointer + texCoordIndex*texCoordData.stride));
if (texCoordData.size == 4) glTexCoord4sv((const GLshort*)((const char*)texCoordData.pointer + texCoordIndex*texCoordData.stride));
break;
case GL_INT:
if (texCoordData.size == 1) glTexCoord1iv((const GLint*)((const char*)texCoordData.pointer + texCoordIndex*texCoordData.stride));
if (texCoordData.size == 2) glTexCoord2iv((const GLint*)((const char*)texCoordData.pointer + texCoordIndex*texCoordData.stride));
if (texCoordData.size == 3) glTexCoord3iv((const GLint*)((const char*)texCoordData.pointer + texCoordIndex*texCoordData.stride));
if (texCoordData.size == 4) glTexCoord4iv((const GLint*)((const char*)texCoordData.pointer + texCoordIndex*texCoordData.stride));
break;
case GL_FLOAT:
if (texCoordData.size == 1) glTexCoord1fv((const GLfloat*)((const char*)texCoordData.pointer + texCoordIndex*texCoordData.stride));
if (texCoordData.size == 2) glTexCoord2fv((const GLfloat*)((const char*)texCoordData.pointer + texCoordIndex*texCoordData.stride));
if (texCoordData.size == 3) glTexCoord3fv((const GLfloat*)((const char*)texCoordData.pointer + texCoordIndex*texCoordData.stride));
if (texCoordData.size == 4) glTexCoord4fv((const GLfloat*)((const char*)texCoordData.pointer + texCoordIndex*texCoordData.stride));
break;
case GL_DOUBLE:
if (texCoordData.size == 1) glTexCoord1dv((const GLdouble*)((const char*)texCoordData.pointer + texCoordIndex*texCoordData.stride));
if (texCoordData.size == 2) glTexCoord2dv((const GLdouble*)((const char*)texCoordData.pointer + texCoordIndex*texCoordData.stride));
if (texCoordData.size == 3) glTexCoord3dv((const GLdouble*)((const char*)texCoordData.pointer + texCoordIndex*texCoordData.stride));
if (texCoordData.size == 4) glTexCoord4dv((const GLdouble*)((const char*)texCoordData.pointer + texCoordIndex*texCoordData.stride));
break;
}
}
static void Display( void )
{
const struct interleave_info * const curr_info = info[ interleave_mode ];
/* 4 floats for 12 verticies for 4 data elements.
*/
char data[ (sizeof( GLfloat ) * 4) * 12 * 4 ];
unsigned i;
unsigned offset;
GLenum err;
GLenum format;
GLsizei stride;
glClearColor(0.2, 0.2, 0.8, 0);
glClear( GL_COLOR_BUFFER_BIT );
glPushMatrix();
glTranslatef(-1.5, 0, 0);
glColor3fv( c_f[0] );
if ( curr_info[0].data != NULL ) {
glEnable( GL_TEXTURE_2D );
}
else {
glDisable( GL_TEXTURE_2D );
}
offset = 0;
glBegin(GL_TRIANGLES);
for ( i = 0 ; i < 12 ; i++ ) {
const unsigned index = indicies[i];
/* Handle the vertex texture coordinate.
*/
if ( curr_info[0].data != NULL ) {
if ( curr_info[0].count == 2 ) {
glTexCoord2fv( DEREF(0, index) );
}
else {
glTexCoord4fv( DEREF(0, index) );
}
(void) memcpy( & data[ offset ], DEREF(0, index),
curr_info[0].size );
offset += curr_info[0].size;
}
/* Handle the vertex color.
*/
if ( curr_info[1].data != NULL ) {
if ( curr_info[1].type == GL_FLOAT ) {
if ( curr_info[1].count == 3 ) {
glColor3fv( DEREF(1, index) );
}
else {
glColor4fv( DEREF(1, index) );
}
}
else {
glColor4ubv( DEREF(1, index) );
}
(void) memcpy( & data[ offset ], DEREF(1, index),
curr_info[1].size );
offset += curr_info[1].size;
}
/* Handle the vertex normal.
*/
if ( curr_info[2].data != NULL ) {
glNormal3fv( DEREF(2, index) );
(void) memcpy( & data[ offset ], DEREF(2, index),
curr_info[2].size );
offset += curr_info[2].size;
}
switch( curr_info[3].count ) {
case 2:
glVertex2fv( DEREF(3, index) );
break;
case 3:
glVertex3fv( DEREF(3, index) );
break;
case 4:
glVertex4fv( DEREF(3, index) );
break;
}
(void) memcpy( & data[ offset ], DEREF(3, index),
curr_info[3].size );
offset += curr_info[3].size;
}
glEnd();
glTranslatef(3.0, 0, 0);
/* The masking with ~0x2A00 is a bit of a hack to make sure that format
* ends up with an invalid value no matter what rand() returns.
*/
format = (use_invalid_mode)
? (rand() & ~0x2A00) : GL_V2F + interleave_mode;
stride = (use_invalid_stride) ? -abs(rand()) : 0;
(void) glGetError();
glInterleavedArrays( format, stride, data );
err = glGetError();
if ( err ) {
printf("glInterleavedArrays(0x%04x, %d, %p) generated the error 0x%04x\n",
format, stride, data, err );
}
else {
glDrawArrays( GL_TRIANGLES, 0, 12 );
}
glPopMatrix();
glutSwapBuffers();
}
static void
RandomPrimitive(void)
{
int i;
int len = MinVertexCount + RandomInt(MaxVertexCount - MinVertexCount);
Vprim = RandomInt(10);
glBegin(Vprim);
Vbuffer[Vcount].type = BEGIN;
Vbuffer[Vcount].v[0] = Vprim;
Vcount++;
for (i = 0; i < len; i++) {
Vbuffer[Vcount].v[0] = RandomFloat(-3, 3);
Vbuffer[Vcount].v[1] = RandomFloat(-3, 3);
Vbuffer[Vcount].v[2] = RandomFloat(-3, 3);
Vbuffer[Vcount].v[3] = RandomFloat(-3, 3);
int k = RandomInt(9);
switch (k) {
case 0:
glVertex2fv(Vbuffer[Vcount].v);
Vbuffer[Vcount].type = VERTEX2;
break;
case 1:
glVertex3fv(Vbuffer[Vcount].v);
Vbuffer[Vcount].type = VERTEX3;
break;
case 2:
glVertex4fv(Vbuffer[Vcount].v);
Vbuffer[Vcount].type = VERTEX4;
break;
case 3:
glColor3fv(Vbuffer[Vcount].v);
Vbuffer[Vcount].type = COLOR3;
break;
case 4:
glColor4fv(Vbuffer[Vcount].v);
Vbuffer[Vcount].type = COLOR4;
break;
case 5:
glTexCoord2fv(Vbuffer[Vcount].v);
Vbuffer[Vcount].type = TEX2;
break;
case 6:
glTexCoord3fv(Vbuffer[Vcount].v);
Vbuffer[Vcount].type = TEX3;
break;
case 7:
glTexCoord4fv(Vbuffer[Vcount].v);
Vbuffer[Vcount].type = TEX4;
break;
case 8:
glSecondaryColor3fv(Vbuffer[Vcount].v);
Vbuffer[Vcount].type = SECCOLOR3;
break;
case 9:
glNormal3fv(Vbuffer[Vcount].v);
Vbuffer[Vcount].type = NORMAL3;
break;
default:
abort();
}
Vcount++;
if (Vcount >= BufferSize - 2) {
/* reset */
Vcount = 0;
}
}
Vbuffer[Vcount++].type = END;
glEnd();
}
bool
test_vertices(enum mode m)
{
bool pass = true;
int i;
/* Make three nice vertices */
float v[3][4];
for (i = 0; i < 3; i++) {
v[i][0] = 0.0;
v[i][1] = 0.0;
v[i][2] = 0.0;
v[i][3] = 1.0;
}
/* Set problematic values */
switch (m) {
case MODE_INFINITY:
make_pos_inf_float(&v[1][0]);
make_neg_inf_float(&v[2][1]);
break;
case MODE_NAN:
make_signaling_nan_float(&v[1][0]);
make_quiet_nan_float(&v[2][1]);
break;
case MODE_DIVZERO:
v[0][3] = 0.0;
v[1][3] = 0.0;
v[2][3] = 0.0;
break;
case MODE_DENORM:
make_denorm_float(&v[0][0], 0, 1);
make_denorm_float(&v[1][1], 1, 1);
break;
default:
; /* nothing */
}
/* Send the vertices to GL, using them in multiple ways */
/* As geometry */
glBegin(GL_POLYGON);
glVertex4fv(v[0]);
glVertex4fv(v[1]);
glVertex4fv(v[2]);
glEnd();
pass &= piglit_check_gl_error(GL_NO_ERROR);
/* As colors */
glBegin(GL_POLYGON);
glColor4fv(v[0]); glVertex2f(-1, -1);
glColor4fv(v[1]); glVertex2f( 1, -1);
glColor4fv(v[2]); glVertex2f( 0, 1);
glEnd();
pass &= piglit_check_gl_error(GL_NO_ERROR);
/* As lighting normals */
glEnable(GL_LIGHTING);
glBegin(GL_POLYGON);
glNormal3fv(v[0]); glVertex2f(-1, -1);
glNormal3fv(v[1]); glVertex2f( 1, -1);
glNormal3fv(v[2]); glVertex2f( 0, 1);
glEnd();
glDisable(GL_LIGHTING);
pass &= piglit_check_gl_error(GL_NO_ERROR);
/* As texture coordinates */
glEnable(GL_TEXTURE_2D);
glBegin(GL_POLYGON);
glTexCoord4fv(v[0]); glVertex2f(-1, -1);
glTexCoord4fv(v[1]); glVertex2f( 1, -1);
glTexCoord4fv(v[2]); glVertex2f( 0, 1);
glEnd();
glDisable(GL_TEXTURE_2D);
pass &= piglit_check_gl_error(GL_NO_ERROR);
return pass;
}
/////////////////////////////////////////////////////////
// Render
//
void GEMglTexCoord4fv :: render(GemState *state) {
glTexCoord4fv (v);
}
static void do_EvalCoord1f(GLcontext* ctx, GLfloat u)
{
/** Color Index **/
if (ctx->Eval.Map1Index)
{
GLfloat findex;
struct gl_1d_map *map = &ctx->EvalMap.Map1Index;
GLfloat uu = (u - map->u1) * map->du;
_math_horner_bezier_curve(map->Points, &findex, uu, 1, map->Order);
glIndexi( (GLint) findex );
}
/** Color **/
if (ctx->Eval.Map1Color4) {
GLfloat fcolor[4];
struct gl_1d_map *map = &ctx->EvalMap.Map1Color4;
GLfloat uu = (u - map->u1) * map->du;
_math_horner_bezier_curve(map->Points, fcolor, uu, 4, map->Order);
glColor4fv( fcolor );
}
/** Normal Vector **/
if (ctx->Eval.Map1Normal) {
GLfloat normal[3];
struct gl_1d_map *map = &ctx->EvalMap.Map1Normal;
GLfloat uu = (u - map->u1) * map->du;
_math_horner_bezier_curve(map->Points, normal, uu, 3, map->Order);
glNormal3fv( normal );
}
/** Texture Coordinates **/
if (ctx->Eval.Map1TextureCoord4) {
GLfloat texcoord[4];
struct gl_1d_map *map = &ctx->EvalMap.Map1Texture4;
GLfloat uu = (u - map->u1) * map->du;
_math_horner_bezier_curve(map->Points, texcoord, uu, 4, map->Order);
glTexCoord4fv( texcoord );
}
else if (ctx->Eval.Map1TextureCoord3) {
GLfloat texcoord[4];
struct gl_1d_map *map = &ctx->EvalMap.Map1Texture3;
GLfloat uu = (u - map->u1) * map->du;
_math_horner_bezier_curve(map->Points, texcoord, uu, 3, map->Order);
glTexCoord3fv( texcoord );
}
else if (ctx->Eval.Map1TextureCoord2) {
GLfloat texcoord[4];
struct gl_1d_map *map = &ctx->EvalMap.Map1Texture2;
GLfloat uu = (u - map->u1) * map->du;
_math_horner_bezier_curve(map->Points, texcoord, uu, 2, map->Order);
glTexCoord2fv( texcoord );
}
else if (ctx->Eval.Map1TextureCoord1) {
GLfloat texcoord[4];
struct gl_1d_map *map = &ctx->EvalMap.Map1Texture1;
GLfloat uu = (u - map->u1) * map->du;
_math_horner_bezier_curve(map->Points, texcoord, uu, 1, map->Order);
glTexCoord1fv( texcoord );
}
/** Vertex **/
if (ctx->Eval.Map1Vertex4)
{
GLfloat vertex[4];
struct gl_1d_map *map = &ctx->EvalMap.Map1Vertex4;
GLfloat uu = (u - map->u1) * map->du;
_math_horner_bezier_curve(map->Points, vertex, uu, 4, map->Order);
glVertex4fv( vertex );
}
else if (ctx->Eval.Map1Vertex3)
{
GLfloat vertex[4];
struct gl_1d_map *map = &ctx->EvalMap.Map1Vertex3;
GLfloat uu = (u - map->u1) * map->du;
_math_horner_bezier_curve(map->Points, vertex, uu, 3, map->Order);
glVertex3fv( vertex );
}
}
static void do_EvalCoord2f( GLcontext* ctx, GLfloat u, GLfloat v )
{
/** Color Index **/
if (ctx->Eval.Map2Index) {
GLfloat findex;
struct gl_2d_map *map = &ctx->EvalMap.Map2Index;
GLfloat uu = (u - map->u1) * map->du;
GLfloat vv = (v - map->v1) * map->dv;
_math_horner_bezier_surf(map->Points, &findex, uu, vv, 1,
map->Uorder, map->Vorder);
glIndexi( (GLuint) (GLint) findex );
}
/** Color **/
if (ctx->Eval.Map2Color4) {
GLfloat fcolor[4];
struct gl_2d_map *map = &ctx->EvalMap.Map2Color4;
GLfloat uu = (u - map->u1) * map->du;
GLfloat vv = (v - map->v1) * map->dv;
_math_horner_bezier_surf(map->Points, fcolor, uu, vv, 4,
map->Uorder, map->Vorder);
glColor4fv( fcolor );
}
/** Normal **/
if (ctx->Eval.Map2Normal &&
(!ctx->Eval.AutoNormal || (!ctx->Eval.Map2Vertex3 &&
!ctx->Eval.Map2Vertex4))) {
GLfloat normal[3];
struct gl_2d_map *map = &ctx->EvalMap.Map2Normal;
GLfloat uu = (u - map->u1) * map->du;
GLfloat vv = (v - map->v1) * map->dv;
_math_horner_bezier_surf(map->Points, normal, uu, vv, 3,
map->Uorder, map->Vorder);
glNormal3fv( normal );
}
/** Texture Coordinates **/
if (ctx->Eval.Map2TextureCoord4) {
GLfloat texcoord[4];
struct gl_2d_map *map = &ctx->EvalMap.Map2Texture4;
GLfloat uu = (u - map->u1) * map->du;
GLfloat vv = (v - map->v1) * map->dv;
_math_horner_bezier_surf(map->Points, texcoord, uu, vv, 4,
map->Uorder, map->Vorder);
glTexCoord4fv( texcoord );
}
else if (ctx->Eval.Map2TextureCoord3) {
GLfloat texcoord[4];
struct gl_2d_map *map = &ctx->EvalMap.Map2Texture3;
GLfloat uu = (u - map->u1) * map->du;
GLfloat vv = (v - map->v1) * map->dv;
_math_horner_bezier_surf(map->Points, texcoord, uu, vv, 3,
map->Uorder, map->Vorder);
glTexCoord3fv( texcoord );
}
else if (ctx->Eval.Map2TextureCoord2) {
GLfloat texcoord[4];
struct gl_2d_map *map = &ctx->EvalMap.Map2Texture2;
GLfloat uu = (u - map->u1) * map->du;
GLfloat vv = (v - map->v1) * map->dv;
_math_horner_bezier_surf(map->Points, texcoord, uu, vv, 2,
map->Uorder, map->Vorder);
glTexCoord2fv( texcoord );
}
else if (ctx->Eval.Map2TextureCoord1) {
GLfloat texcoord[4];
struct gl_2d_map *map = &ctx->EvalMap.Map2Texture1;
GLfloat uu = (u - map->u1) * map->du;
GLfloat vv = (v - map->v1) * map->dv;
_math_horner_bezier_surf(map->Points, texcoord, uu, vv, 1,
map->Uorder, map->Vorder);
glTexCoord1fv( texcoord );
}
/** Vertex **/
if(ctx->Eval.Map2Vertex4) {
GLfloat vertex[4];
GLfloat normal[3];
struct gl_2d_map *map = &ctx->EvalMap.Map2Vertex4;
GLfloat uu = (u - map->u1) * map->du;
GLfloat vv = (v - map->v1) * map->dv;
if (ctx->Eval.AutoNormal) {
GLfloat du[4], dv[4];
_math_de_casteljau_surf(map->Points, vertex, du, dv, uu, vv, 4,
map->Uorder, map->Vorder);
CROSS_PROD(normal, du, dv);
NORMALIZE_3FV(normal);
glNormal3fv( normal );
glVertex4fv( vertex );
}
else {
_math_horner_bezier_surf(map->Points, vertex, uu, vv, 4,
map->Uorder, map->Vorder);
glVertex4fv( vertex );
}
}
else if (ctx->Eval.Map2Vertex3) {
GLfloat vertex[4];
struct gl_2d_map *map = &ctx->EvalMap.Map2Vertex3;
GLfloat uu = (u - map->u1) * map->du;
GLfloat vv = (v - map->v1) * map->dv;
if (ctx->Eval.AutoNormal) {
GLfloat du[3], dv[3];
GLfloat normal[3];
_math_de_casteljau_surf(map->Points, vertex, du, dv, uu, vv, 3,
map->Uorder, map->Vorder);
CROSS_PROD(normal, du, dv);
NORMALIZE_3FV(normal);
glNormal3fv( normal );
glVertex3fv( vertex );
}
else {
_math_horner_bezier_surf(map->Points, vertex, uu, vv, 3,
map->Uorder, map->Vorder);
glVertex3fv( vertex );
}
}
}
inline void glTexCoord4v( const GLfloat * v ) { glTexCoord4fv( v ); }
M(void, glTexCoord4fv, jobject v) {
glTexCoord4fv(BUFF(GLfloat, v));
}
void __glXDisp_TexCoord4fv(GLbyte *pc)
{
glTexCoord4fv(
(GLfloat *)(pc + 0)
);
}
