void
init(void)
{
GLfloat matDiff[4] = { 0.65F, 0.05F, 0.20F, 0.60F };
GLfloat matSpec[4] = { 0.50F, 0.50F, 0.50F, 1.00F };
GLfloat matShine = 20.00F;
GLint indexes[3];
GLfloat light0Pos[4] = { 0.70F, 0.70F, 1.25F, 0.00F };
glClearColor(colors[2].diff[0], colors[2].diff[1], colors[2].diff[2], 1.0F);
glClearIndex((GLfloat) colors[2].indexes[1]);
setProjection();
glTranslatef(0.0F, 0.0F, -2.0F);
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, matDiff);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, matSpec);
glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, matShine);
indexes[0] = 0;
indexes[1] = colors[0].indexes[1] - colors[0].indexes[0];
indexes[2] = colors[0].indexes[2] - colors[0].indexes[0];
glMaterialiv(GL_FRONT_AND_BACK, GL_COLOR_INDEXES, indexes);
glLightfv(GL_LIGHT0, GL_POSITION, light0Pos);
glEnable(GL_LIGHT0);
glEnable(GL_LIGHTING);
glEnable(GL_DEPTH_TEST);
setCheckTexture();
glEnable(GL_TEXTURE_2D);
glEnable(GL_CULL_FACE);
}
void __glXDisp_Materialiv(GLbyte *pc)
{
glMaterialiv(
*(GLenum *)(pc + 0),
*(GLenum *)(pc + 4),
(GLint *)(pc + 8)
);
}
static void hugsprim_glMaterialiv_6(HugsStackPtr hugs_root)
{
HsWord32 arg1;
HsWord32 arg2;
HsPtr arg3;
arg1 = hugs->getWord32();
arg2 = hugs->getWord32();
arg3 = hugs->getPtr();
glMaterialiv(arg1, arg2, arg3);
hugs->returnIO(hugs_root,0);
}
ENTRYPOINT void draw_bang (ModeInfo *mi)
{
Display *dpy = MI_DISPLAY(mi);
Window window = MI_WINDOW(mi);
GLfloat camx, camz;
float r = 10.0;
int LightPos[4] = {-10,0,0,1};
int MatSpec [4] = {1,1,1,1};
glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), *(bang->glx_context));
glMaterialiv(GL_FRONT_AND_BACK,GL_SPECULAR,MatSpec);
glMateriali(GL_FRONT_AND_BACK,GL_SHININESS,100);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
/* set camera position */
camx = r*sin(bang->alpha) + 0.5;
camz = r*cos(bang->alpha) + 0.5;
bang->alpha += 0.01;
if (bang->alpha == 360)
{
bang->alpha = 0;
}
gluLookAt(camx, 0.0, camz, 0.0, 0.0, 0.0, 0, 1, 0);
glLightiv(GL_LIGHT0, GL_POSITION, LightPos);
/* gluLookAt(10, 0.0, 10, 0, 0, 0, 0, 1, 0);*/
glPushMatrix ();
drawsphere(0.1, 0.0, 0.0, 0.0);
drawsphere(0.5, 3.0, 0.0, 0.0);
drawsphere(1.0, 6.0, 0.0, 0.0);
glPopMatrix ();
if (MI_IS_FPS(mi)) do_fps (mi);
glXSwapBuffers(dpy, window);
}
/* will need to test every variant cases */
CAMLprim value c_set_get_material( value _face_mode, value v /* material_mode */ ) {
GLenum face_mode;
GLfloat * material_state;
#include "enums/face_mode.inc.c"
material_state = malloc(4 * sizeof(GLfloat));
switch (Tag_val(v))
{
#define set_get_glMaterial_with_4_floats(pname) \
{ GLfloat params[4]; \
params[0] = Double_val(Field(v,0)); \
params[1] = Double_val(Field(v,1)); \
params[2] = Double_val(Field(v,2)); \
params[3] = Double_val(Field(v,3)); \
glGetMaterialfv( \
face_mode, \
(pname == GL_AMBIENT_AND_DIFFUSE ? GL_AMBIENT : pname), \
material_state ); \
glMaterialfv( \
face_mode, \
pname, \
params ); \
}
case 0:
set_get_glMaterial_with_4_floats(GL_AMBIENT); break;
case 1:
set_get_glMaterial_with_4_floats(GL_DIFFUSE); break;
case 2:
set_get_glMaterial_with_4_floats(GL_SPECULAR); break;
case 3:
set_get_glMaterial_with_4_floats(GL_EMISSION); break;
case 5:
set_get_glMaterial_with_4_floats(GL_AMBIENT_AND_DIFFUSE); break;
#undef set_get_glMaterial_with_4_floats
case 4:
glGetMaterialfv(
face_mode,
GL_SHININESS,
material_state );
glMaterialf(
face_mode,
GL_SHININESS,
Double_val(Field(v,0)) );
break;
case 6:
{ GLint params[3];
params[0] = Int_val(Field(v,0));
params[1] = Int_val(Field(v,1));
params[2] = Int_val(Field(v,2));
glGetMaterialfv(
face_mode,
GL_COLOR_INDEXES,
material_state );
glMaterialiv(
face_mode,
GL_COLOR_INDEXES,
params );
}
break;
default: caml_failwith("variant handling bug");
}
return (value) material_state;
}
template< > inline void glMaterialv< Vector3i > ( GLenum face, GLenum pname, const Vector3i params ) { glMaterialiv(face,pname,(int*)¶ms); };
void CInvaderMystery::Draw(void) const
{
// Position the model in 3-space
glTranslatef(m_fPositionX, m_fPositionY, m_fPositionZ);
// set spin of mystery invader
glRotatef(10.0f, 1.0f, 0.0f, 0.0f);
glRotatef(m_fAngle, m_fAngleX, m_fAngleY, m_fAngleZ);
// set scale
if (m_fScale != 1.0f)
{
glScalef(m_fScale, m_fScale, m_fScale);
glEnable(GL_NORMALIZE);
}
GLfloat pfSpecular[4] = {1.0f, 1.0f, 1.0f, 1.0f};
GLfloat pfShininess[1] = {32.0f};
GLint piDiffuse[4] = {m_uchBodyColor[0] << 23, m_uchBodyColor[1] << 23, m_uchBodyColor[2] << 23, 0x7fffffff};
GLint piAmbient[4] = {m_uchBodyColor[0] << 20, m_uchBodyColor[1] << 20, m_uchBodyColor[2] << 20, 0x7fffffff};
if (m_bFlash)
{
piDiffuse[0] = piDiffuse[1] = piDiffuse[2] = piDiffuse[3] = 0x7fffffff;
piAmbient[0] = piAmbient[1] = piAmbient[2] = piAmbient[3] = 0x7fffffff;
}
glMaterialfv(GL_FRONT, GL_SPECULAR, pfSpecular);
glMaterialfv(GL_FRONT, GL_SHININESS, pfShininess);
glMaterialiv(GL_FRONT, GL_DIFFUSE, piDiffuse);
glMaterialiv(GL_FRONT, GL_AMBIENT, piAmbient);
// draw the body
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_NORMAL_ARRAY);
glVertexPointer(3, GL_FLOAT, 0, m_pfVertex);
glNormalPointer(GL_FLOAT, 0, m_pfNormal);
glDrawArrays(GL_TRIANGLE_FAN, 0, m_ciRadialPieces + 2);
glDrawArrays(GL_TRIANGLE_FAN, m_ciRadialPieces + 2, m_ciRadialPieces + 2);
int iIndex = 2 * (m_ciRadialPieces + 2);
for (int iStrip = 0; iStrip < m_ciBodySlices - 1; iStrip++)
{
glDrawArrays(GL_QUAD_STRIP, iIndex, (m_ciRadialPieces + 1) * 2);
iIndex += (m_ciRadialPieces + 1) * 2;
}
glDrawArrays(GL_QUADS, iIndex, (m_ciRadialPieces - m_ciWindows) * 4);
iIndex += (m_ciRadialPieces - m_ciWindows) * 4;
// draw windows
piDiffuse[0] = m_uchWindowColor[0] << 23;
piDiffuse[1] = m_uchWindowColor[1] << 23;
piDiffuse[2] = m_uchWindowColor[2] << 23;
piAmbient[0] = m_uchWindowColor[0] << 20;
piAmbient[1] = m_uchWindowColor[1] << 20;
piAmbient[2] = m_uchWindowColor[2] << 20;
glMaterialiv(GL_FRONT, GL_DIFFUSE, piDiffuse);
glMaterialiv(GL_FRONT, GL_AMBIENT, piAmbient);
glDrawArrays(GL_QUADS, iIndex, m_ciWindows * 4);
iIndex += m_ciWindows * 4;
// draw landing gear
piDiffuse[0] = m_uchGearColor[0] << 23;
piDiffuse[1] = m_uchGearColor[1] << 23;
piDiffuse[2] = m_uchGearColor[2] << 23;
piAmbient[0] = m_uchGearColor[0] << 20;
piAmbient[1] = m_uchGearColor[1] << 20;
piAmbient[2] = m_uchGearColor[2] << 20;
glMaterialiv(GL_FRONT, GL_DIFFUSE, piDiffuse);
glMaterialiv(GL_FRONT, GL_AMBIENT, piAmbient);
for (int iGear = 0; iGear < m_ciLandingGears; iGear++)
{
glDrawArrays(GL_TRIANGLE_FAN, iIndex, m_ciGearPieces + 2);
iIndex += m_ciGearPieces + 2;
}
// draw center bottom piece
piDiffuse[0] = m_uchCenterColor[0] << 23;
piDiffuse[1] = m_uchCenterColor[1] << 23;
piDiffuse[2] = m_uchCenterColor[2] << 23;
piAmbient[0] = m_uchCenterColor[0] << 20;
piAmbient[1] = m_uchCenterColor[1] << 20;
piAmbient[2] = m_uchCenterColor[2] << 20;
glMaterialiv(GL_FRONT, GL_DIFFUSE, piDiffuse);
glMaterialiv(GL_FRONT, GL_AMBIENT, piAmbient);
glDrawArrays(GL_QUADS, iIndex, 20);
iIndex += 20;
// all done
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);
if (m_fScale != 1.0f)
{
glDisable(GL_NORMALIZE);
}
return;
}
static void Init(void)
{
static float ambient[] = {0.1, 0.1, 0.1, 1.0};
static float diffuse[] = {0.5, 1.0, 1.0, 1.0};
static float position[] = {90.0, 90.0, 150.0, 0.0};
static float front_mat_shininess[] = {30.0};
static float front_mat_specular[] = {0.2, 0.2, 0.2, 1.0};
static float front_mat_diffuse[] = {0.5, 0.28, 0.38, 1.0};
static float back_mat_shininess[] = {50.0};
static float back_mat_specular[] = {0.5, 0.5, 0.2, 1.0};
static float back_mat_diffuse[] = {1.0, 1.0, 0.2, 1.0};
static float lmodel_ambient[] = {1.0, 1.0, 1.0, 1.0};
static float lmodel_twoside[] = {GL_TRUE};
glClearColor(0.0, 0.0, 0.0, 0.0);
glFrontFace(GL_CW);
glEnable(GL_DEPTH_TEST);
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
glLightModelfv(GL_LIGHT_MODEL_TWO_SIDE, lmodel_twoside);
glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse);
glLightfv(GL_LIGHT0, GL_POSITION, position);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glMaterialfv(GL_FRONT, GL_SHININESS, front_mat_shininess);
glMaterialfv(GL_FRONT, GL_SPECULAR, front_mat_specular);
glMaterialfv(GL_FRONT, GL_DIFFUSE, front_mat_diffuse);
glMaterialfv(GL_BACK, GL_SHININESS, back_mat_shininess);
glMaterialfv(GL_BACK, GL_SPECULAR, back_mat_specular);
glMaterialfv(GL_BACK, GL_DIFFUSE, back_mat_diffuse);
glEnable(GL_CLIP_PLANE0);
if (rgb) {
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, decal);
glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, repeat);
glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, repeat);
glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, nearest);
glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, nearest);
glTexImage2D(GL_TEXTURE_2D, 0, 3, CHECKIMAGEWIDTH, CHECKIMAGEHEIGHT, 0,
GL_RGB, GL_UNSIGNED_BYTE, (GLvoid *)checkImage);
glEnable(GL_TEXTURE_2D);
glCullFace(GL_BACK);
glEnable(GL_CULL_FACE);
} else {
SetGreyRamp();
/* commented out by BrianP because it's the wrong way to handle a 4-bit visual!
if (doubleBuffer) {
colorIndexes[1] = 10;
colorIndexes[2] = 15;
}
*/
glMaterialiv(GL_FRONT_AND_BACK, GL_COLOR_INDEXES, colorIndexes);
}
BuildLists();
dithering = GL_TRUE;
shade = GL_TRUE;
doStipple = GL_FALSE;
polyMode = GL_BACK;
}
inline void glMaterialv( const GLenum & face, const GLenum & pname, const GLint * param ) { glMaterialiv( face, pname, param ); }
M(void, glGetMaterialfv, jint face, jint pname, jobject params) {
glMaterialiv(face, pname, BUFF(GLint, params));
}
