void GLContext::SaveMaterial( int face, int flag )
{
assert( !m_restoreVector.empty() );
Message &msg = *m_restoreVector.rbegin();
switch( flag )
{
case AMBIENT:
case DIFFUSE:
case SPECULAR:
case AMBIENT_AND_DIFFUSE:
case EMISSION:
{
GAL::P4f value;
glGetMaterialfv( ToGLFlag( face ), ToGLMaterial( flag ), value );
msg += MaterialMsg( face, flag, value );
}
break;
case SHININESS:
{
GLfloat value;
glGetMaterialfv( ToGLFlag( face ), GL_SHININESS, &value );
msg += MaterialMsg( face, SHININESS, value );
}
break;
default:
break;
};
}
void MeshDrawer::DrawMesh() const
{
if(p_vtx == NULL) return;
// Get previous material diffuse components
float ambient[4], diffuse[4], specular[4], emission[4], shininess;
glGetMaterialfv(GL_FRONT, GL_AMBIENT, ambient);
glGetMaterialfv(GL_FRONT, GL_DIFFUSE, diffuse);
glGetMaterialfv(GL_FRONT, GL_SPECULAR, specular);
glGetMaterialfv(GL_FRONT, GL_EMISSION, emission);
glGetMaterialfv(GL_FRONT, GL_SHININESS, &shininess);
//glDisable(GL_LIGHTING);
glShadeModel(GL_SMOOTH);
glEnable(GL_POLYGON_SMOOTH);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
glEnable(GL_POLYGON_OFFSET_FILL);
glPolygonOffset(2.0, 2.0);
glEnable(GL_COLOR_MATERIAL);
glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
if(m_mode & Global::DRAWMAXMINPOINTS) DrawMaxMinPoints();
if(m_mode & Global::DRAWSADDLEPOINTS) DrawSaddlePoints();
glDisable(GL_COLOR_MATERIAL);
glDisable(GL_POLYGON_OFFSET_FILL);
glDisable(GL_POLYGON_SMOOTH);
glEnable(GL_LIGHTING);
// Reset previous material diffuse components
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, ambient);
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, diffuse);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, specular);
glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, emission);
glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, shininess);
glDisable(GL_LIGHTING);
glDepthFunc(GL_LEQUAL);
glEnable(GL_LINE_SMOOTH);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
glLineWidth(2.0f);
if(m_mode & Global::DRAWCONNECTLINES) DrawConnectLines();
if(m_mode & Global::DRAWBADCONNLINES) DrawBadConnLines();
if(m_mode & Global::DRAWSTRAIGHTENLINES) DrawStraighten();
glHint(GL_LINE_SMOOTH_HINT, GL_DONT_CARE);
glDisable(GL_BLEND);
glDisable(GL_LINE_SMOOTH);
glEnable(GL_LIGHTING);
glDepthFunc(GL_LESS);
glEnable(GL_LIGHTING);
}
void ofMaterial::begin() {
// save previous values, opengl es cannot use push/pop attrib
glGetMaterialfv(GL_FRONT_AND_BACK,GL_DIFFUSE,&prev_diffuse.r);
glGetMaterialfv(GL_FRONT_AND_BACK,GL_SPECULAR,&prev_specular.r);
glGetMaterialfv(GL_FRONT_AND_BACK,GL_AMBIENT,&prev_ambient.r);
glGetMaterialfv(GL_FRONT_AND_BACK,GL_EMISSION,&prev_emissive.r);
glGetMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, &prev_shininess);
// Material colors and properties
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, &diffuse.r);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, &specular.r);
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, &ambient.r);
glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, &emissive.r);
glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, &shininess);
}
static void hugsprim_glGetMaterialfv_1(HugsStackPtr hugs_root)
{
HsWord32 arg1;
HsWord32 arg2;
HsPtr arg3;
arg1 = hugs->getWord32();
arg2 = hugs->getWord32();
arg3 = hugs->getPtr();
glGetMaterialfv(arg1, arg2, arg3);
hugs->returnIO(hugs_root,0);
}
void ParticleShaderVoronoi::drawSecondPass(int i)
{
// push the shader name down
glPushName(0xffffffff);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
gmVector3 p = position->getPosition(i);
glTranslatef(p[0],p[1],p[2]);
gmMatrix4 rotMat = orientation->getMatrix(i);
GLdouble mat[16];
rotMat.copyTo(mat);
glMultMatrixd(mat);
//setColor(i);
// Pull the diffuse color
GLfloat diff[4];
glGetMaterialfv(GL_FRONT, GL_DIFFUSE, diff);
// Set the disk center
GLfloat dC[3] = {0.0, 0.0, 0.0};
// Get the radius
if (radius_data)
radius = (*radius_data)[i];
else
radius = 1.0;
// Set the per-particle Cg parameters
cgGLSetParameter3fv(diskCenterWC, dC);
cgGLSetParameter4fv(diffuseColor, diff);
cgGLSetParameter1f(diskRadius, GLfloat(radius * scale));
cgGLSetStateMatrixParameter(modelViewProj, CG_GL_MODELVIEW_PROJECTION_MATRIX, CG_GL_MATRIX_IDENTITY);
cgGLSetStateMatrixParameter(modelView, CG_GL_MODELVIEW_MATRIX, CG_GL_MATRIX_IDENTITY);
cgGLSetStateMatrixParameter(modelViewIT, CG_GL_MODELVIEW_MATRIX, CG_GL_MATRIX_INVERSE_TRANSPOSE);
// Now, actually draw the shape
drawShape(i);
glPopMatrix();
glPopName();
}
void glGetMaterialiv(GLenum face, GLenum pname, GLint *param) {
GLfloat f[4];
glGetMaterialfv(face, pname, f);
switch (pname) {
case GL_AMBIENT_AND_DIFFUSE:
case GL_AMBIENT:
case GL_DIFFUSE:
case GL_SPECULAR:
case GL_EMISSION:
param[3] = f[3];
case GL_COLOR_INDEXES:
param[2] = f[2];
param[1] = f[1];
case GL_SHININESS:
param[0] = f[0];
break;
}
}
int __glXDisp_GetMaterialfv(__GLXclientState *cl, GLbyte *pc)
{
GLenum pname;
GLint compsize;
__GLXcontext *cx;
ClientPtr client = cl->client;
int error;
GLfloat answerBuffer[200];
char *answer;
cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
if (!cx) {
return error;
}
pc += __GLX_SINGLE_HDR_SIZE;
pname = *(GLenum *)(pc + 4);
compsize = __glGetMaterialfv_size(pname);
if (compsize < 0) compsize = 0;
__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
__glXClearErrorOccured();
glGetMaterialfv(
*(GLenum *)(pc + 0),
*(GLenum *)(pc + 4),
(GLfloat *) answer
);
if (__glXErrorOccured()) {
__GLX_BEGIN_REPLY(0);
__GLX_PUT_SIZE(0);
__GLX_SEND_HEADER();
} else if (compsize == 1) {
__GLX_BEGIN_REPLY(0);
__GLX_PUT_SIZE(1);
__GLX_PUT_FLOAT();
__GLX_SEND_HEADER();
} else {
__GLX_BEGIN_REPLY(compsize*4);
__GLX_PUT_SIZE(compsize);
__GLX_SEND_HEADER();
__GLX_SEND_FLOAT_ARRAY(compsize);
}
return Success;
}
void ParticleShaderDiskDevelop::drawParticle(int i)
{
cgGLEnableProfile(vProfile);
cgGLEnableProfile(fProfile);
cgGLBindProgram(vProgram);
bindCGParametersVertex();
bindCGParametersFragment();
cgGLBindProgram(fProgram);
GLfloat lightpos[4];
glGetLightfv(GL_LIGHT0, GL_POSITION, lightpos);
cgGLSetParameter4fv(lightPositionEC, lightpos);
// Pull the diffuse color
GLfloat diff[4];
glGetMaterialfv(GL_FRONT, GL_DIFFUSE, diff);
// Set the disk center
GLfloat dC[3] = {0.0, 0.0, 0.0};
// Get the radius
if (radius_data)
radius = (*radius_data)[i];
else
radius = 1.0;
// Set the per-particle Cg parameters
cgGLSetParameter3fv(diskCenterWC, dC);
cgGLSetParameter4fv(diffuseColor, diff);
cgGLSetParameter1f(diskRadius, GLfloat(radius * scale));
cgGLSetStateMatrixParameter(modelViewProj, CG_GL_MODELVIEW_PROJECTION_MATRIX, CG_GL_MATRIX_IDENTITY);
cgGLSetStateMatrixParameter(modelView, CG_GL_MODELVIEW_MATRIX, CG_GL_MATRIX_IDENTITY);
cgGLSetStateMatrixParameter(modelViewIT, CG_GL_MODELVIEW_MATRIX, CG_GL_MATRIX_INVERSE_TRANSPOSE);
gluDisk(quad,0,radius*scale*1.51,4,4);
cgGLDisableProfile(vProfile);
cgGLDisableProfile(fProfile);
}
void CSkelMeshViewer::Draw3D(float TimeDelta)
{
guard(CSkelMeshViewer::Draw3D);
assert(Inst);
CSkelMeshInstance *MeshInst = static_cast<CSkelMeshInstance*>(Inst);
// tick animations
MeshInst->UpdateAnimation(TimeDelta);
#if HIGHLIGHT_CURRENT
if (TimeSinceCreate < 0)
TimeSinceCreate += 1.0f; // ignore this frame for highlighting
else
TimeSinceCreate += TimeDelta;
float lightAmbient[4];
float boost = 0;
float highlightTime = max(TimeSinceCreate, 0);
if (TaggedMeshes.Num() && highlightTime < HIGHLIGHT_DURATION)
{
if (highlightTime > HIGHLIGHT_DURATION / 2)
highlightTime = HIGHLIGHT_DURATION - highlightTime; // fade
boost = HIGHLIGHT_STRENGTH * highlightTime / (HIGHLIGHT_DURATION / 2);
glGetMaterialfv(GL_FRONT, GL_AMBIENT, lightAmbient);
lightAmbient[0] += boost;
lightAmbient[1] += boost;
lightAmbient[2] += boost;
glLightfv(GL_LIGHT0, GL_AMBIENT, lightAmbient);
glMaterialfv(GL_FRONT, GL_AMBIENT, lightAmbient);
}
#endif // HIGHLIGHT_CURRENT
// draw main mesh
CMeshViewer::Draw3D(TimeDelta);
#if HIGHLIGHT_CURRENT
if (boost > 0)
{
lightAmbient[0] -= boost;
lightAmbient[1] -= boost;
lightAmbient[2] -= boost;
glLightfv(GL_LIGHT0, GL_AMBIENT, lightAmbient);
glMaterialfv(GL_FRONT, GL_AMBIENT, lightAmbient);
}
#endif // HIGHLIGHT_CURRENT
int i;
#if SHOW_BOUNDS
//?? separate function for drawing wireframe Box (pass CCoords, Mins and Maxs to function)
BindDefaultMaterial(true);
glBegin(GL_LINES);
CVec3 verts[8];
static const int inds[] =
{
0,1, 2,3, 0,2, 1,3,
4,5, 6,7, 4,6, 5,7,
0,4, 1,5, 2,6, 3,7
};
const FBox &B = MeshInst->pMesh->BoundingBox;
for (i = 0; i < 8; i++)
{
CVec3 &v = verts[i];
v[0] = (i & 1) ? B.Min.X : B.Max.X;
v[1] = (i & 2) ? B.Min.Y : B.Max.Y;
v[2] = (i & 4) ? B.Min.Z : B.Max.Z;
MeshInst->BaseTransformScaled.TransformPointSlow(v, v);
}
// can use glDrawElements(), but this will require more GL setup
glColor3f(0.5,0.5,1);
for (i = 0; i < ARRAY_COUNT(inds) / 2; i++)
{
glVertex3fv(verts[inds[i*2 ]].v);
glVertex3fv(verts[inds[i*2+1]].v);
}
glEnd();
glColor3f(1, 1, 1);
#endif // SHOW_BOUNDS
for (i = 0; i < TaggedMeshes.Num(); i++)
{
CSkelMeshInstance *mesh = TaggedMeshes[i];
if (mesh->pMesh == MeshInst->pMesh) continue; // avoid duplicates
mesh->UpdateAnimation(TimeDelta);
DrawMesh(mesh);
}
//?? make this common - place into DrawMesh() ?
//?? problem: overdraw of skeleton when displaying multiple meshes
//?? (especially when ShowInfluences is on, and meshes has different bone counts - the same bone
//?? will be painted multiple times with different colors)
if (ShowSkel)
MeshInst->DrawSkeleton(ShowLabels, (DrawFlags & DF_SHOW_INFLUENCES) != 0);
if (ShowAttach)
MeshInst->DrawAttachments();
if (IsFollowingMesh)
FocusCameraOnPoint(MeshInst->GetMeshOrigin());
unguard;
}
void ofMaterial::begin() {
#ifndef TARGET_PROGRAMMABLE_GL
if(!ofIsGLProgrammableRenderer()){
#ifndef TARGET_OPENGLES
// save previous values, opengl es cannot use push/pop attrib
glGetMaterialfv(GL_FRONT,GL_DIFFUSE,&prev_data.diffuse.r);
glGetMaterialfv(GL_FRONT,GL_SPECULAR,&prev_data.specular.r);
glGetMaterialfv(GL_FRONT,GL_AMBIENT,&prev_data.ambient.r);
glGetMaterialfv(GL_FRONT,GL_EMISSION,&prev_data.emissive.r);
glGetMaterialfv(GL_FRONT, GL_SHININESS, &prev_data.shininess);
glGetMaterialfv(GL_BACK,GL_DIFFUSE,&prev_data_back.diffuse.r);
glGetMaterialfv(GL_BACK,GL_SPECULAR,&prev_data_back.specular.r);
glGetMaterialfv(GL_BACK,GL_AMBIENT,&prev_data_back.ambient.r);
glGetMaterialfv(GL_BACK,GL_EMISSION,&prev_data_back.emissive.r);
glGetMaterialfv(GL_BACK, GL_SHININESS, &prev_data_back.shininess);
// Material colors and properties
glMaterialfv(GL_FRONT, GL_DIFFUSE, &data.diffuse.r);
glMaterialfv(GL_FRONT, GL_SPECULAR, &data.specular.r);
glMaterialfv(GL_FRONT, GL_AMBIENT, &data.ambient.r);
glMaterialfv(GL_FRONT, GL_EMISSION, &data.emissive.r);
glMaterialfv(GL_FRONT, GL_SHININESS, &data.shininess);
glMaterialfv(GL_BACK, GL_DIFFUSE, &data.diffuse.r);
glMaterialfv(GL_BACK, GL_SPECULAR, &data.specular.r);
glMaterialfv(GL_BACK, GL_AMBIENT, &data.ambient.r);
glMaterialfv(GL_BACK, GL_EMISSION, &data.emissive.r);
glMaterialfv(GL_BACK, GL_SHININESS, &data.shininess);
#elif !defined(TARGET_PROGRAMMABLE_GL)
// opengl es 1.1 implementation must use GL_FRONT_AND_BACK.
glGetMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, &prev_data.diffuse.r);
glGetMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, &prev_data.specular.r);
glGetMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, &prev_data.ambient.r);
glGetMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, &prev_data.emissive.r);
glGetMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, &prev_data.shininess);
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, &data.diffuse.r);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, &data.specular.r);
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, &data.ambient.r);
glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, &data.emissive.r);
glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, &data.shininess);
#endif
}
#endif
if(ofIsGLProgrammableRenderer()){
ofGetGLProgrammableRenderer()->setCurrentMaterial(this);
}
}
/* 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;
}
void DrawLightExam()
{
// compute camera
g_pos.y = distance * sin(yAngle);
g_pos.x = distance * cos(yAngle) * sin(-xAngle);
g_pos.z = distance * cos(yAngle) * cos(-xAngle);
g_lightPos.y = LightDistantce * sin(yLightAngle);
g_lightPos.x = LightDistantce * cos(yLightAngle) * sin(-xLightAngle);
g_lightPos.z = LightDistantce * cos(yLightAngle) * cos(-xLightAngle);
light.vcPosition = g_lightPos;
light.vcDirection = -g_lightPos;
light.vcDirection.w = 0;
light.fPhi = g_cutoff;
light.fExponent = g_exponent;
g_pDevice->UseWindow(0);
ZFXVector vU(0, 1, 0);
g_pDevice->SetViewLookAt(g_pos, ZFXVector(0, 0, 0), vU);
IShaderManager *sm = g_pDevice->GetShaderManager();
sm->SetNamedConstant("camera_position", DAT_FVEC4, 1, g_pos.v);
GLfloat f[16] = { 0.0 };
glGetFloatv(GL_MODELVIEW_MATRIX, f);
glGetFloatv(GL_PROJECTION_MATRIX, f);
ZFXMatrix mWorld;
mWorld.Identity();
g_pDevice->SetWorldTransform(&mWorld);
//sm->EnableShader(false);
g_pDevice->SetAmbientLight(0.1, 0.1, 0.1);
g_pDevice->SetLight(&light, 0);
float v[4];
glGetMaterialfv(GL_FRONT, GL_AMBIENT, v);
glGetMaterialfv(GL_FRONT, GL_DIFFUSE, v);
glGetMaterialfv(GL_FRONT, GL_SPECULAR, v);
glGetMaterialfv(GL_FRONT, GL_EMISSION, v);
DrawOBJModel();
GLenum error = glGetError();
if (error != GL_NO_ERROR)
{
int i = 0;
}
glGetMaterialfv(GL_FRONT, GL_AMBIENT, v);
glGetMaterialfv(GL_FRONT, GL_DIFFUSE, v);
glGetMaterialfv(GL_FRONT, GL_SPECULAR, v);
glGetMaterialfv(GL_FRONT, GL_EMISSION, v);
glGetLightfv(GL_LIGHT0, GL_AMBIENT, v);
glGetLightfv(GL_LIGHT0, GL_DIFFUSE, v);
glGetLightfv(GL_LIGHT0, GL_SPECULAR, v);
error = glGetError();
if (error != GL_NO_ERROR)
{
int i = 0;
}
}
void glGetMaterialfvLogged(GLenum face, GLenum pname, GLfloat *params) {
printf("glGetMaterialfv(%s, %s, %p)\n", GLEnumName(face), GLEnumName(pname), params);
glGetMaterialfv(face, pname, params);
}
void MeshModelRender::DrawModelFaceColor()
{
CoordArray& vCoord = kernel->GetVertexInfo().GetCoord();
NormalArray& vNormal = kernel->GetVertexInfo().GetNormal();
ColorArray& fColor = kernel->GetFaceInfo().GetColor();
PolyIndexArray& fIndex = kernel->GetFaceInfo().GetIndex();
if(fColor.size() != fIndex.size())
return;
// Get previous material diffuse components
float ambient[4], diffuse[4], specular[4], emission[4], shininess;
glGetMaterialfv(GL_FRONT, GL_AMBIENT, ambient);
glGetMaterialfv(GL_FRONT, GL_DIFFUSE, diffuse);
glGetMaterialfv(GL_FRONT, GL_SPECULAR, specular);
glGetMaterialfv(GL_FRONT, GL_EMISSION, emission);
glGetMaterialfv(GL_FRONT, GL_SHININESS, &shininess);
glDisable(GL_LIGHTING);
glShadeModel(GL_SMOOTH);
// glEnable(GL_POLYGON_SMOOTH);
// glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
// glEnable(GL_POLYGON_OFFSET_FILL);
// glPolygonOffset(2.0, 2.0);
glEnable(GL_COLOR_MATERIAL);
glColorMaterial(GL_FRONT, GL_DIFFUSE);
size_t nFace = fIndex.size();
size_t i, j, n;
if(!kernel->GetModelInfo().IsGeneralMesh())
{
if(kernel->GetModelInfo().IsTriMesh()) // Triangle mesh
glBegin(GL_TRIANGLES);
else if(kernel->GetModelInfo().IsQuadMesh()) // Quadangle mesh
glBegin(GL_QUADS);
else
return;
for(i = 0; i < nFace; ++ i)
{
IndexArray& face = fIndex[i];
n = face.size();
Color& c = fColor[i];
glColor3d(c[0], c[1], c[2]);
for(j = 0; j < n; ++ j)
{
VertexID& vID = face[j];
Coord& v = vCoord[vID];
Normal& n = vNormal[vID];
glNormal3d(n[0], n[1], n[2]);
glVertex3d(v[0], v[1], v[2]);
}
}
glEnd();
}
else // General polygonal mesh
{
for(i = 0; i < nFace; ++ i)
{
IndexArray& face = fIndex[i];
n = face.size();
Color& c = fColor[i];
glColor3d(c[0], c[1], c[2]);
glBegin(GL_POLYGON);
for(j = 0; j < n; ++ j)
{
VertexID vID = face[j];
Coord& v = vCoord[vID];
Normal& n = vNormal[vID];
glNormal3d(n[0], n[1], n[2]);
glVertex3d(v[0], v[1], v[2]);
}
glEnd();
}
}
glDisable(GL_COLOR_MATERIAL);
glDisable(GL_POLYGON_OFFSET_FILL);
glDisable(GL_POLYGON_SMOOTH);
glEnable(GL_LIGHTING);
// Reset previous material diffuse components
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, ambient);
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, diffuse);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, specular);
glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, emission);
glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, shininess);
}
void ui_draw_but_NORMAL(uiBut *but, uiWidgetColors *wcol, rcti *rect)
{
static GLuint displist = 0;
int a, old[8];
GLfloat diff[4], diffn[4] = {1.0f, 1.0f, 1.0f, 1.0f};
float vec0[4] = {0.0f, 0.0f, 0.0f, 0.0f};
float dir[4], size;
/* store stuff */
glGetMaterialfv(GL_FRONT, GL_DIFFUSE, diff);
/* backdrop */
glColor3ubv((unsigned char *)wcol->inner);
uiSetRoundBox(UI_CNR_ALL);
uiDrawBox(GL_POLYGON, rect->xmin, rect->ymin, rect->xmax, rect->ymax, 5.0f);
/* sphere color */
glMaterialfv(GL_FRONT, GL_DIFFUSE, diffn);
glCullFace(GL_BACK);
glEnable(GL_CULL_FACE);
/* disable blender light */
for (a = 0; a < 8; a++) {
old[a] = glIsEnabled(GL_LIGHT0 + a);
glDisable(GL_LIGHT0 + a);
}
/* own light */
glEnable(GL_LIGHT7);
glEnable(GL_LIGHTING);
ui_get_but_vectorf(but, dir);
dir[3] = 0.0f; /* glLightfv needs 4 args, 0.0 is sun */
glLightfv(GL_LIGHT7, GL_POSITION, dir);
glLightfv(GL_LIGHT7, GL_DIFFUSE, diffn);
glLightfv(GL_LIGHT7, GL_SPECULAR, vec0);
glLightf(GL_LIGHT7, GL_CONSTANT_ATTENUATION, 1.0f);
glLightf(GL_LIGHT7, GL_LINEAR_ATTENUATION, 0.0f);
/* transform to button */
glPushMatrix();
glTranslatef(rect->xmin + 0.5f * BLI_rcti_size_x(rect), rect->ymin + 0.5f * BLI_rcti_size_y(rect), 0.0f);
if (BLI_rcti_size_x(rect) < BLI_rcti_size_y(rect))
size = BLI_rcti_size_x(rect) / 200.f;
else
size = BLI_rcti_size_y(rect) / 200.f;
glScalef(size, size, size);
if (displist == 0) {
GLUquadricObj *qobj;
displist = glGenLists(1);
glNewList(displist, GL_COMPILE);
qobj = gluNewQuadric();
gluQuadricDrawStyle(qobj, GLU_FILL);
glShadeModel(GL_SMOOTH);
gluSphere(qobj, 100.0, 32, 24);
glShadeModel(GL_FLAT);
gluDeleteQuadric(qobj);
glEndList();
}
glCallList(displist);
/* restore */
glDisable(GL_LIGHTING);
glDisable(GL_CULL_FACE);
glMaterialfv(GL_FRONT, GL_DIFFUSE, diff);
glDisable(GL_LIGHT7);
/* AA circle */
glEnable(GL_BLEND);
glEnable(GL_LINE_SMOOTH);
glColor3ubv((unsigned char *)wcol->inner);
glutil_draw_lined_arc(0.0f, M_PI * 2.0, 100.0f, 32);
glDisable(GL_BLEND);
glDisable(GL_LINE_SMOOTH);
/* matrix after circle */
glPopMatrix();
/* enable blender light */
for (a = 0; a < 8; a++) {
if (old[a])
glEnable(GL_LIGHT0 + a);
}
}
void
GlfSimpleLightingContext::SetStateFromOpenGL()
{
// import classic GL light's parameters into shaded lights
SetUseLighting(glIsEnabled(GL_LIGHTING));
GfMatrix4d worldToViewMatrix;
glGetDoublev(GL_MODELVIEW_MATRIX, worldToViewMatrix.GetArray());
GfMatrix4d viewToWorldMatrix = worldToViewMatrix.GetInverse();
GLint nLights = 0;
glGetIntegerv(GL_MAX_LIGHTS, &nLights);
GlfSimpleLightVector lights;
lights.reserve(nLights);
GlfSimpleLight light;
for(int i = 0; i < nLights; ++i)
{
int lightName = GL_LIGHT0 + i;
if (glIsEnabled(lightName)) {
GLfloat position[4], color[4];
glGetLightfv(lightName, GL_POSITION, position);
light.SetPosition(GfVec4f(position)*viewToWorldMatrix);
glGetLightfv(lightName, GL_AMBIENT, color);
light.SetAmbient(GfVec4f(color));
glGetLightfv(lightName, GL_DIFFUSE, color);
light.SetDiffuse(GfVec4f(color));
glGetLightfv(lightName, GL_SPECULAR, color);
light.SetSpecular(GfVec4f(color));
lights.push_back(light);
}
}
SetLights(lights);
GlfSimpleMaterial material;
GLfloat color[4], shininess;
glGetMaterialfv(GL_FRONT, GL_AMBIENT, color);
material.SetAmbient(GfVec4f(color));
glGetMaterialfv(GL_FRONT, GL_DIFFUSE, color);
material.SetDiffuse(GfVec4f(color));
glGetMaterialfv(GL_FRONT, GL_SPECULAR, color);
material.SetSpecular(GfVec4f(color));
glGetMaterialfv(GL_FRONT, GL_EMISSION, color);
material.SetEmission(GfVec4f(color));
glGetMaterialfv(GL_FRONT, GL_SHININESS, &shininess);
// clamp to 0.0001, since pow(0,0) is undefined in GLSL.
shininess = std::max(0.0001f, shininess);
material.SetShininess(shininess);
SetMaterial(material);
GfVec4f sceneAmbient;
glGetFloatv(GL_LIGHT_MODEL_AMBIENT, &sceneAmbient[0]);
SetSceneAmbient(sceneAmbient);
}
//------------------------------------------------------------------------
// llgl_dump()
//------------------------------------------------------------------------
void llgl_dump()
{
int i;
F32 fv[16];
GLboolean b;
LL_INFOS() << "==========================" << LL_ENDL;
LL_INFOS() << "OpenGL State" << LL_ENDL;
LL_INFOS() << "==========================" << LL_ENDL;
LL_INFOS() << "-----------------------------------" << LL_ENDL;
LL_INFOS() << "Current Values" << LL_ENDL;
LL_INFOS() << "-----------------------------------" << LL_ENDL;
glGetFloatv(GL_CURRENT_COLOR, fv);
LL_INFOS() << "GL_CURRENT_COLOR : " << fv4(fv) << LL_ENDL;
glGetFloatv(GL_CURRENT_NORMAL, fv);
LL_INFOS() << "GL_CURRENT_NORMAL : " << fv3(fv) << LL_ENDL;
LL_INFOS() << "-----------------------------------" << LL_ENDL;
LL_INFOS() << "Lighting" << LL_ENDL;
LL_INFOS() << "-----------------------------------" << LL_ENDL;
LL_INFOS() << "GL_LIGHTING : " << boolstr(glIsEnabled(GL_LIGHTING)) << LL_ENDL;
LL_INFOS() << "GL_COLOR_MATERIAL : " << boolstr(glIsEnabled(GL_COLOR_MATERIAL)) << LL_ENDL;
glGetIntegerv(GL_COLOR_MATERIAL_PARAMETER, (GLint*)&i);
LL_INFOS() << "GL_COLOR_MATERIAL_PARAMETER: " << cmstr(i) << LL_ENDL;
glGetIntegerv(GL_COLOR_MATERIAL_FACE, (GLint*)&i);
LL_INFOS() << "GL_COLOR_MATERIAL_FACE : " << facestr(i) << LL_ENDL;
fv[0] = fv[1] = fv[2] = fv[3] = 12345.6789f;
glGetMaterialfv(GL_FRONT, GL_AMBIENT, fv);
LL_INFOS() << "GL_AMBIENT material : " << fv4(fv) << LL_ENDL;
fv[0] = fv[1] = fv[2] = fv[3] = 12345.6789f;
glGetMaterialfv(GL_FRONT, GL_DIFFUSE, fv);
LL_INFOS() << "GL_DIFFUSE material : " << fv4(fv) << LL_ENDL;
fv[0] = fv[1] = fv[2] = fv[3] = 12345.6789f;
glGetMaterialfv(GL_FRONT, GL_SPECULAR, fv);
LL_INFOS() << "GL_SPECULAR material : " << fv4(fv) << LL_ENDL;
fv[0] = fv[1] = fv[2] = fv[3] = 12345.6789f;
glGetMaterialfv(GL_FRONT, GL_EMISSION, fv);
LL_INFOS() << "GL_EMISSION material : " << fv4(fv) << LL_ENDL;
fv[0] = fv[1] = fv[2] = fv[3] = 12345.6789f;
glGetMaterialfv(GL_FRONT, GL_SHININESS, fv);
LL_INFOS() << "GL_SHININESS material : " << fv1(fv) << LL_ENDL;
fv[0] = fv[1] = fv[2] = fv[3] = 12345.6789f;
glGetFloatv(GL_LIGHT_MODEL_AMBIENT, fv);
LL_INFOS() << "GL_LIGHT_MODEL_AMBIENT : " << fv4(fv) << LL_ENDL;
glGetBooleanv(GL_LIGHT_MODEL_LOCAL_VIEWER, &b);
LL_INFOS() << "GL_LIGHT_MODEL_LOCAL_VIEWER: " << boolstr(b) << LL_ENDL;
glGetBooleanv(GL_LIGHT_MODEL_TWO_SIDE, &b);
LL_INFOS() << "GL_LIGHT_MODEL_TWO_SIDE : " << boolstr(b) << LL_ENDL;
for (int l=0; l<8; l++)
{
b = glIsEnabled(GL_LIGHT0+l);
LL_INFOS() << "GL_LIGHT" << l << " : " << boolstr(b) << LL_ENDL;
if (!b)
continue;
glGetLightfv(GL_LIGHT0+l, GL_AMBIENT, fv);
LL_INFOS() << " GL_AMBIENT light : " << fv4(fv) << LL_ENDL;
glGetLightfv(GL_LIGHT0+l, GL_DIFFUSE, fv);
LL_INFOS() << " GL_DIFFUSE light : " << fv4(fv) << LL_ENDL;
glGetLightfv(GL_LIGHT0+l, GL_SPECULAR, fv);
LL_INFOS() << " GL_SPECULAR light : " << fv4(fv) << LL_ENDL;
glGetLightfv(GL_LIGHT0+l, GL_POSITION, fv);
LL_INFOS() << " GL_POSITION light : " << fv4(fv) << LL_ENDL;
glGetLightfv(GL_LIGHT0+l, GL_CONSTANT_ATTENUATION, fv);
LL_INFOS() << " GL_CONSTANT_ATTENUATION : " << fv1(fv) << LL_ENDL;
glGetLightfv(GL_LIGHT0+l, GL_QUADRATIC_ATTENUATION, fv);
LL_INFOS() << " GL_QUADRATIC_ATTENUATION : " << fv1(fv) << LL_ENDL;
glGetLightfv(GL_LIGHT0+l, GL_SPOT_DIRECTION, fv);
LL_INFOS() << " GL_SPOT_DIRECTION : " << fv4(fv) << LL_ENDL;
glGetLightfv(GL_LIGHT0+l, GL_SPOT_EXPONENT, fv);
LL_INFOS() << " GL_SPOT_EXPONENT : " << fv1(fv) << LL_ENDL;
glGetLightfv(GL_LIGHT0+l, GL_SPOT_CUTOFF, fv);
LL_INFOS() << " GL_SPOT_CUTOFF : " << fv1(fv) << LL_ENDL;
}
LL_INFOS() << "-----------------------------------" << LL_ENDL;
LL_INFOS() << "Pixel Operations" << LL_ENDL;
LL_INFOS() << "-----------------------------------" << LL_ENDL;
LL_INFOS() << "GL_ALPHA_TEST : " << boolstr(glIsEnabled(GL_ALPHA_TEST)) << LL_ENDL;
LL_INFOS() << "GL_DEPTH_TEST : " << boolstr(glIsEnabled(GL_DEPTH_TEST)) << LL_ENDL;
glGetBooleanv(GL_DEPTH_WRITEMASK, &b);
LL_INFOS() << "GL_DEPTH_WRITEMASK : " << boolstr(b) << LL_ENDL;
LL_INFOS() << "GL_BLEND : " << boolstr(glIsEnabled(GL_BLEND)) << LL_ENDL;
LL_INFOS() << "GL_DITHER : " << boolstr(glIsEnabled(GL_DITHER)) << LL_ENDL;
}
void _glGetMaterialfv( int target,int pname,Array<Float> params,int offset ) {
glGetMaterialfv( target,pname,¶ms[offset] );
}
void ofMaterial::begin() {
#ifndef TARGET_OPENGLES
// save previous values, opengl es cannot use push/pop attrib
glGetMaterialfv(GL_FRONT,GL_DIFFUSE,&prev_diffuse.r);
glGetMaterialfv(GL_FRONT,GL_SPECULAR,&prev_specular.r);
glGetMaterialfv(GL_FRONT,GL_AMBIENT,&prev_ambient.r);
glGetMaterialfv(GL_FRONT,GL_EMISSION,&prev_emissive.r);
glGetMaterialfv(GL_FRONT, GL_SHININESS, &prev_shininess);
glGetMaterialfv(GL_BACK,GL_DIFFUSE,&prev_diffuse_back.r);
glGetMaterialfv(GL_BACK,GL_SPECULAR,&prev_specular_back.r);
glGetMaterialfv(GL_BACK,GL_AMBIENT,&prev_ambient_back.r);
glGetMaterialfv(GL_BACK,GL_EMISSION,&prev_emissive_back.r);
glGetMaterialfv(GL_BACK, GL_SHININESS, &prev_shininess_back);
// Material colors and properties
glMaterialfv(GL_FRONT, GL_DIFFUSE, &diffuse.r);
glMaterialfv(GL_FRONT, GL_SPECULAR, &specular.r);
glMaterialfv(GL_FRONT, GL_AMBIENT, &ambient.r);
glMaterialfv(GL_FRONT, GL_EMISSION, &emissive.r);
glMaterialfv(GL_FRONT, GL_SHININESS, &shininess);
glMaterialfv(GL_BACK, GL_DIFFUSE, &diffuse.r);
glMaterialfv(GL_BACK, GL_SPECULAR, &specular.r);
glMaterialfv(GL_BACK, GL_AMBIENT, &ambient.r);
glMaterialfv(GL_BACK, GL_EMISSION, &emissive.r);
glMaterialfv(GL_BACK, GL_SHININESS, &shininess);
#else
// opengl es 1.1 implementation must use GL_FRONT_AND_BACK.
glGetMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, &prev_diffuse.r);
glGetMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, &prev_specular.r);
glGetMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, &prev_ambient.r);
glGetMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, &prev_emissive.r);
glGetMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, &prev_shininess);
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, &diffuse.r);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, &specular.r);
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, &ambient.r);
glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, &emissive.r);
glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, &shininess);
#endif
}
DGLE_RESULT DGLE_API CFixedFunctionPipeline::GetMaterialDiffuseColor(TColor4 &stColor)
{
glGetMaterialfv(GL_FRONT, GL_DIFFUSE, stColor);
return S_OK;
}
DGLE_RESULT DGLE_API CFixedFunctionPipeline::GetMaterialSpecularColor(TColor4 &stColor)
{
glGetMaterialfv(GL_FRONT, GL_SPECULAR, stColor);
return S_OK;
}
DGLE_RESULT DGLE_API CFixedFunctionPipeline::GetMaterialShininess(float &fShininess)
{
glGetMaterialfv(GL_FRONT, GL_SHININESS, &fShininess);
return S_OK;
}
