void shadowDisplay(void (*drawScene)(const BoardData *, const BoardData3d *, const renderdata *), const BoardData* bd, const BoardData3d *bd3d, const renderdata *prd)
{
/* Pass 1: Draw model, ambient light only (some diffuse to vary shadow darkness) */
float zero[4] = {0,0,0,0};
float d1[4];
float specular[4];
float diffuse[4];
drawScene(bd, bd3d, prd);
/* Create shadow volume in stencil buffer */
glEnable(GL_STENCIL_TEST);
draw_shadow_volume_to_stencil(bd3d);
/* Pass 2: Redraw model, full light in non-shadowed areas */
glStencilFunc(GL_NOTEQUAL, midStencilVal, (GLuint)~0);
glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
glGetLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse);
d1[0] = d1[1] = d1[2] = d1[3] = prd->dimness;
glLightfv(GL_LIGHT0, GL_DIFFUSE, d1);
/* No specular light */
glGetLightfv(GL_LIGHT0, GL_SPECULAR, specular);
glLightfv(GL_LIGHT0, GL_SPECULAR, zero);
if (renderingBase)
drawScene(bd, bd3d, prd);
else
drawBoard(bd, bd3d, prd);
glLightfv(GL_LIGHT0, GL_SPECULAR, specular);
glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse);
glDisable(GL_STENCIL_TEST);
}
void DcGp::DcGpTools::MakeLightsNeutral()
{
GLint maxLightCount;
glGetIntegerv(GL_MAX_LIGHTS, &maxLightCount);
for (int i = 0; i < maxLightCount; ++i)
{
if (glIsEnabled(GL_LIGHT0+i))
{
float diffuse[4];
float ambiant[4];
float specular[4];
glGetLightfv(GL_LIGHT0 + i, GL_DIFFUSE, diffuse);
glGetLightfv(GL_LIGHT0 + i, GL_AMBIENT, ambiant);
glGetLightfv(GL_LIGHT0 + i, GL_SPECULAR, specular);
diffuse[0] = diffuse[1] = diffuse[2] = (diffuse[0] + diffuse[1] + diffuse[2]) / 3.0f; //gray 'mean' value
ambiant[0] = ambiant[1] = ambiant[2] = (ambiant[0] + ambiant[1] + ambiant[2]) / 3.0f; //gray 'mean' value
specular[0] = specular[1] = specular[2] = (specular[0] + specular[1] + specular[2]) / 3.0f; //gray 'mean' value
glLightfv(GL_LIGHT0 + i, GL_DIFFUSE, diffuse);
glLightfv(GL_LIGHT0 + i, GL_AMBIENT, ambiant);
glLightfv(GL_LIGHT0 + i, GL_SPECULAR, specular);
}
}
}
DGLE_RESULT DGLE_API CFixedFunctionPipeline::GetLightType(uint uiIdx, E_LIGHT_TYPE &eType)
{
if (uiIdx >= (uint)_iMaxLights)
return E_INVALIDARG;
if (_bStateFilterEnabled)
eType = _pLights[uiIdx].type;
else
{
GLfloat pos[4];
glGetLightfv(GL_LIGHT0 + uiIdx, GL_POSITION, pos);
if (pos[3] == 0.f)
eType = LT_DIRECTIONAL;
else
{
GLfloat cutoff;
glGetLightfv(GL_LIGHT0 + uiIdx, GL_SPOT_CUTOFF, &cutoff);
if (cutoff == 180.f)
eType = LT_POINT;
else
eType = LT_SPOT;
}
}
return S_OK;
}
DGLE_RESULT DGLE_API CFixedFunctionPipeline::GetSpotLightConfiguration(uint uiIdx, TPoint3 &stPosition, TVector3 &stDirection, float &fRange, float &fSpotAngle)
{
E_LIGHT_TYPE type;
GetLightType(uiIdx, type);
if (uiIdx >= (uint)_iMaxLights || type != LT_SPOT)
return E_INVALIDARG;
GLfloat pos[4];
glGetLightfv(GL_LIGHT0 + uiIdx, GL_POSITION, pos);
glGetLightfv(GL_LIGHT0 + uiIdx, GL_SPOT_DIRECTION, stDirection);
// May work wrong when light position was set or changed directly via OpenGL outside this class.
const TMatrix4x4 inv_mview = MatrixInverse(_pLights[uiIdx].mview);
stPosition = inv_mview.ApplyToPoint(TPoint3(pos[0], pos[1], pos[2]));
stDirection = inv_mview.ApplyToVector(stDirection);
glGetLightfv(GL_LIGHT0 + uiIdx, GL_SPOT_CUTOFF, &fSpotAngle);
fSpotAngle *= 2.f;
glGetLightfv(GL_LIGHT0 + uiIdx, GL_LINEAR_ATTENUATION, &fRange);
fRange = _c_fAttenuationFactor / fRange;
return S_OK;
}
Single
SpotLight::getSpotExponent () const
{
Single exponent;
glGetLightfv (GL_LIGHT0 + m_lightNumber, GL_SPOT_EXPONENT, &exponent);
return (exponent);
}
Vector3f
SpotLight::getSpotDirection () const
{
Vector3f spotDirection;
glGetLightfv (GL_LIGHT0 + m_lightNumber, GL_SPOT_DIRECTION,
&spotDirection[0]);
return (spotDirection);
}
Single
SpotLight::getConstantAttenuation () const
{
Single constantAtten;
glGetLightfv (GL_LIGHT0 + m_lightNumber, GL_CONSTANT_ATTENUATION,
&constantAtten);
return (constantAtten);
}
Single
SpotLight::getLinearAttenuation () const
{
Single linearAtten;
glGetLightfv (GL_LIGHT0 + m_lightNumber, GL_LINEAR_ATTENUATION,
&linearAtten);
return (linearAtten);
}
Single
SpotLight::getQuadraticAttenuation () const
{
Single quadraticAtten;
glGetLightfv (GL_LIGHT0 + m_lightNumber, GL_QUADRATIC_ATTENUATION,
&quadraticAtten);
return (quadraticAtten);
}
void PerPixelRenderer::setupMatrices(int L) const
{
GLfloat pos[4],dir[3];
glGetLightfv(GL_LIGHT0+L,GL_POSITION,pos);
glGetLightfv(GL_LIGHT0+L,GL_SPOT_DIRECTION,dir);
dir[0]+=pos[0];
dir[1]+=pos[1];
dir[2]+=pos[2];
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(100.0f,(GLdouble)_w/(GLdouble)_h,0.1f,1000.0f);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt(pos[0],pos[1],pos[2],
dir[0],dir[1],dir[2],
0,1,0);
}
DGLE_RESULT DGLE_API CFixedFunctionPipeline::GetLightColor(uint uiIdx, TColor4 &stColor)
{
if (uiIdx >= (uint)_iMaxLights)
return E_INVALIDARG;
glGetLightfv(GL_LIGHT0 + uiIdx, GL_DIFFUSE, stColor.rgba);
return S_OK;
}
DGLE_RESULT DGLE_API CFixedFunctionPipeline::GetLightIntensity(uint uiIdx, float &fIntensity)
{
if (uiIdx >= (uint)_iMaxLights)
return E_INVALIDARG;
glGetLightfv(GL_LIGHT0 + uiIdx, GL_CONSTANT_ATTENUATION, &fIntensity);
fIntensity = 1.f / fIntensity;
return S_OK;
}
DGLE_RESULT DGLE_API CFixedFunctionPipeline::GetPointLightConfiguration(uint uiIdx, TPoint3 &stPosition, float &fRange)
{
E_LIGHT_TYPE type;
GetLightType(uiIdx, type);
if (uiIdx >= (uint)_iMaxLights || type != LT_POINT)
return E_INVALIDARG;
GLfloat pos[4];
glGetLightfv(GL_LIGHT0 + uiIdx, GL_POSITION, pos);
// May work wrong when light position was set or changed directly via OpenGL outside this class.
stPosition = MatrixInverse(_pLights[uiIdx].mview).ApplyToPoint(TPoint3(pos[0], pos[1], pos[2]));
glGetLightfv(GL_LIGHT0 + uiIdx, GL_LINEAR_ATTENUATION, &fRange);
fRange = _c_fAttenuationFactor / fRange;
return S_OK;
}
void GLContext::SaveLight( int light, int flag )
{
assert( !m_restoreVector.empty() );
Message &msg = *m_restoreVector.rbegin();
switch( flag )
{
case AMBIENT:
case DIFFUSE:
case SPECULAR:
case AMBIENT_AND_DIFFUSE:
case POSITION:
{
GAL::P4f value;
glGetLightfv( ToGLFlag( light ), ToGLLight( flag ), value );
msg += LightMsg( light, flag, value );
}
break;
case SPOT_DIRECTION:
{
GAL::P3f value;
glGetLightfv( ToGLFlag( light ), GL_SPOT_DIRECTION, value );
msg += LightMsg( light, SPOT_DIRECTION, value );
}
break;
case SPOT_EXPONENT:
case SPOT_CUTOFF:
case CONSTANT_ATTENUATION:
case LINEAR_ATTENUATION:
case QUADRATIC_ATTENUATION:
{
GLint value;
glGetLightiv( ToGLFlag( light ), ToGLLight( flag ), &value );
msg += LightMsg( light, flag, value );
}
break;
default:
break;
};
}
static void hugsprim_glGetLightfv_14(HugsStackPtr hugs_root)
{
HsWord32 arg1;
HsWord32 arg2;
HsPtr arg3;
arg1 = hugs->getWord32();
arg2 = hugs->getWord32();
arg3 = hugs->getPtr();
glGetLightfv(arg1, arg2, arg3);
hugs->returnIO(hugs_root,0);
}
void DrawGLScene() // Main Drawing Routine
{
GLmatrix16f Minv, Inv;
GLvector4f lp;
// Clear Color Buffer, Depth Buffer, Stencil Buffer
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
glColor4f(0.7f, 0.4f, 0.0f, 1.0f);
glLoadIdentity();
glPushMatrix(); {
glTranslatef(0.0f, 0.0f, -20.0f); // Zoom Into Screen 20 Units
glLightfv(GL_LIGHT1, GL_POSITION, LightPos); // Position Light1
glTranslatef(SpherePos[0], SpherePos[1], SpherePos[2]); // Position The Sphere
gluSphere(q, 1.5f, 32, 16); // Draw A Sphere
} glPopMatrix();
glPushMatrix(); {
glTranslatef(0.0f, 0.0f, -20.0f); // Zoom Into The Screen 20 Units
DrawGLRoom(); // Draw The Room
glTranslatef(ObjPos[0], ObjPos[1], ObjPos[2]); // Position The Object
glRotatef(xrot, 1.0f, 0.0f, 0.0f); // Spin It On The X Axis By xrot
glRotatef(yrot, 0.0f, 1.0f, 0.0f); // Spin It On The Y Axis By yrot
DrawGLObject(obj); // Procedure For Drawing The Loaded Object
// 获得光源的位置(返回值是在视觉坐标系下的)
glGetLightfv(GL_LIGHT1, GL_POSITION, lp);
glGetFloatv(GL_MODELVIEW_MATRIX, Minv);
m3dInvertMatrix44(Inv, Minv);
// 把光源位置从视觉坐标系下变换到当前的场景坐标系(obj)下.
VMatMult(Inv, lp);
// 开始渲染阴影
CastShadow(&obj, lp);
// 用一个小黄球标记出光源的位置
glPushMatrix(); {
glColor4f(0.7f, 0.4f, 0.0f, 1.0f); // Set Color To Purplish Blue
glDisable(GL_LIGHTING); // Disable Lighting
glDepthMask(GL_FALSE); // Disable Depth Mask
glTranslatef(lp[0], lp[1], lp[2]);
gluSphere(q, 0.2f, 16, 8);
glEnable(GL_LIGHTING); // Enable Lighting
glDepthMask(GL_TRUE); // Enable Depth Mask
} glPopMatrix();
} glPopMatrix();
xrot += xspeed;
yrot += yspeed;
glFlush();
glutSwapBuffers();
}
LightPosition::LightPosition(Particles *ps, const std::string& name):ParticleAttribute(ps,name)
{
glGetLightfv(GL_LIGHT0, GL_POSITION, _lightPositionf);
for(size_t i = 0; i < 4; i++) _lightPositionInput[i] = _lightPositionf[i];
new PSParamgmVector4(this,&_lightPositionInput,_lightPositionInput,
"light","light position","Light position in eye coordinate space.");
new PSParamButton(this,new LightPositionSet(this),"set","Set Light Position", "Set Light Position");
new PSParamBool(this,&_lightIsInWorldCoords,false,"worldCoord","isWorldCoords","The light will be placed in world coordinates, realize"
"that the opengl light will remain at a relative position!"
"To update its position one needs to click on set light again");
}
void DefaultRenderer::drawLights()
{
GLfloat pos[4];
glPushMatrix();
for(int i=0; i<MAX_LIGHTS; i++) {
glColor3f(0.0f,0.0f,0.0f);
if(glIsEnabled(GL_LIGHT0+i)) {
glDisable(GL_LIGHTING);
glGetLightfv(GL_LIGHT0+i,GL_POSITION,pos);
glTranslatef(pos[0],pos[1],pos[2]);
glutSolidSphere(_rad,16,16);
glEnable(GL_LIGHTING);
}
}
glPopMatrix();
}
DGLE_RESULT DGLE_API CFixedFunctionPipeline::GetDirectionalLightConfiguration(uint uiIdx, TVector3 &stDirection)
{
E_LIGHT_TYPE type;
GetLightType(uiIdx, type);
if (uiIdx >= (uint)_iMaxLights || type != LT_DIRECTIONAL)
return E_INVALIDARG;
GLfloat dir[4];
glGetLightfv(GL_LIGHT0 + uiIdx, GL_POSITION, dir);
// May work wrong when light position was set or changed directly via OpenGL outside this class.
stDirection = MatrixInverse(_pLights[uiIdx].mview).ApplyToVector(TVector3(dir[0], dir[1], dir[2]));
return S_OK;
}
void dim_lights(const double f)
{
int max_lights = 0;
glGetIntegerv(GL_MAX_LIGHTS,&max_lights);
float ld[4];
for(int l = 0; l<max_lights; l++)
{
// Dim if hovered over
glGetLightfv(GL_LIGHT0+l,GL_DIFFUSE,ld);
ld[0] *= f;
ld[1] *= f;
ld[2] *= f;
ld[3] *= f;
glLightfv(GL_LIGHT0+l,GL_DIFFUSE,ld);
}
}
int __glXDisp_GetLightfv(__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 = __glGetLightfv_size(pname);
if (compsize < 0) compsize = 0;
__GLX_GET_ANSWER_BUFFER(answer,cl,compsize*4,4);
__glXClearErrorOccured();
glGetLightfv(
*(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 ShadowMapping::renderingFromLightSetup(MeshDocument& md, GLArea* gla){
Box3m bb = md.bbox();
Point3m center = bb.Center();
Scalarm diag = bb.Diag();
GLfloat lP[4];
glGetLightfv(GL_LIGHT0, GL_POSITION, lP);
vcg::Point3f light = -vcg::Point3f(lP[0],lP[1],lP[2]);
vcg::Matrix44f tm = gla->trackball.Matrix();
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
glOrtho(-(diag/2),
diag/2,
-(diag/2),
diag/2,
-(diag/2),
diag/2);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
vcg::Point3f u, v;
//mi seleziona automaticamente un upvector che mi eviti casi degeneri...nel caso vada bene 010 sceglie quello
vcg::GetUV(light, u, v, vcg::Point3f(0,-1,0));
glLoadIdentity();
gluLookAt(0, 0, 0, light[0], light[1], light[2], v[0], v[1], v[2]);
//get the rotation matrix from the trackball
vcg::Matrix44f rotation;
vcg::Similarityf track = gla->trackball.track;
track.rot.ToMatrix(rotation);
glMultMatrixf(rotation.transpose().V());
//traslate the model in the center
glTranslatef(-center[0],-center[1],-center[2]);
}
void LightPosition::prepare()
{
if (!_lightIsInWorldCoords)
{
glGetLightfv(GL_LIGHT0, GL_POSITION, _lightPositionf);
gmVector4 eyeLP;
for(size_t i = 0; i < 4; i++)
eyeLP[i] = _lightPositionf[i];
GLdouble modelview[16];
glGetDoublev(GL_MODELVIEW_MATRIX,modelview);
gmMatrix4 _m(modelview[0], modelview[4], modelview[8], modelview[12],
modelview[1], modelview[5], modelview[9], modelview[13],
modelview[2], modelview[6], modelview[10], modelview[14],
modelview[3], modelview[7], modelview[11], modelview[15]);
gmMatrix4 _m_inv = _m.inverse();
_lightPosition = _m_inv * eyeLP;
}
else
{
_lightPosition = _lightPositionInput;
}
}
void Camera::DrawSpike(double rad, const vector3d &viewCoords, const matrix4x4d &viewTransform)
{
glPushMatrix();
float znear, zfar;
Render::GetNearFarClipPlane(znear, zfar);
double newdist = znear + 0.5f * (zfar - znear);
double scale = newdist / viewCoords.Length();
glTranslatef(float(scale*viewCoords.x), float(scale*viewCoords.y), float(scale*viewCoords.z));
Render::State::UseProgram(0);
// face the camera dammit
vector3d zaxis = viewCoords.Normalized();
vector3d xaxis = vector3d(0,1,0).Cross(zaxis).Normalized();
vector3d yaxis = zaxis.Cross(xaxis);
matrix4x4d rot = matrix4x4d::MakeInvRotMatrix(xaxis, yaxis, zaxis);
glMultMatrixd(&rot[0]);
glDisable(GL_LIGHTING);
glDisable(GL_DEPTH_TEST);
glEnable(GL_BLEND);
// XXX WRONG. need to pick light from appropriate turd.
GLfloat col[4];
glGetLightfv(GL_LIGHT0, GL_DIFFUSE, col);
glColor4f(col[0], col[1], col[2], 1);
glBegin(GL_TRIANGLE_FAN);
glVertex3f(0,0,0);
glColor4f(col[0], col[1], col[2], 0);
const float spikerad = float(scale*rad);
// bezier with (0,0,0) control points
{
vector3f p0(0,spikerad,0), p1(spikerad,0,0);
float t=0.1f; for (int i=1; i<10; i++, t+= 0.1f) {
vector3f p = (1-t)*(1-t)*p0 + t*t*p1;
glVertex3fv(&p[0]);
}
}
{
vector3f p0(spikerad,0,0), p1(0,-spikerad,0);
float t=0.1f; for (int i=1; i<10; i++, t+= 0.1f) {
vector3f p = (1-t)*(1-t)*p0 + t*t*p1;
glVertex3fv(&p[0]);
}
}
{
vector3f p0(0,-spikerad,0), p1(-spikerad,0,0);
float t=0.1f; for (int i=1; i<10; i++, t+= 0.1f) {
vector3f p = (1-t)*(1-t)*p0 + t*t*p1;
glVertex3fv(&p[0]);
}
}
{
vector3f p0(-spikerad,0,0), p1(0,spikerad,0);
float t=0.1f; for (int i=1; i<10; i++, t+= 0.1f) {
vector3f p = (1-t)*(1-t)*p0 + t*t*p1;
glVertex3fv(&p[0]);
}
}
glEnd();
glDisable(GL_BLEND);
glEnable(GL_LIGHTING);
glEnable(GL_DEPTH_TEST);
glPopMatrix();
}
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 Planet::DrawAtmosphere(const vector3d &camPos)
{
Color col;
double density;
GetSBody()->GetAtmosphereFlavor(&col, &density);
const double rad1 = 0.999;
const double rad2 = 1.05;
glPushMatrix();
// face the camera dammit
vector3d zaxis = (-camPos).Normalized();
vector3d xaxis = vector3d(0,1,0).Cross(zaxis).Normalized();
vector3d yaxis = zaxis.Cross(xaxis);
matrix4x4d rot = matrix4x4d::MakeInvRotMatrix(xaxis, yaxis, zaxis);
glMultMatrixd(&rot[0]);
matrix4x4f invViewRot;
glGetFloatv(GL_MODELVIEW_MATRIX, &invViewRot[0]);
invViewRot.ClearToRotOnly();
invViewRot = invViewRot.InverseOf();
const int numLights = Pi::worldView->GetNumLights();
assert(numLights < 4);
vector3f lightDir[4];
float lightCol[4][4];
// only
for (int i=0; i<numLights; i++) {
float temp[4];
glGetLightfv(GL_LIGHT0 + i, GL_DIFFUSE, lightCol[i]);
glGetLightfv(GL_LIGHT0 + i, GL_POSITION, temp);
lightDir[i] = (invViewRot * vector3f(temp[0], temp[1], temp[2])).Normalized();
}
const double angStep = M_PI/32;
// find angle player -> centre -> tangent point
// tangent is from player to surface of sphere
float tanAng = float(acos(rad1 / camPos.Length()));
// then we can put the f*****g atmosphere on the horizon
vector3d r1(0.0, 0.0, rad1);
vector3d r2(0.0, 0.0, rad2);
rot = matrix4x4d::RotateYMatrix(tanAng);
r1 = rot * r1;
r2 = rot * r2;
rot = matrix4x4d::RotateZMatrix(angStep);
glDisable(GL_LIGHTING);
glBlendFunc(GL_SRC_ALPHA, GL_ONE);
glEnable(GL_BLEND);
glDisable(GL_CULL_FACE);
glBegin(GL_TRIANGLE_STRIP);
for (float ang=0; ang<2*M_PI; ang+=float(angStep)) {
vector3d norm = r1.Normalized();
glNormal3dv(&norm.x);
float _col[4] = { 0,0,0,0 };
for (int lnum=0; lnum<numLights; lnum++) {
const float dot = norm.x*lightDir[lnum].x + norm.y*lightDir[lnum].y + norm.z*lightDir[lnum].z;
_col[0] += dot*lightCol[lnum][0];
_col[1] += dot*lightCol[lnum][1];
_col[2] += dot*lightCol[lnum][2];
}
for (int i=0; i<3; i++) _col[i] = _col[i] * col[i];
_col[3] = col[3];
glColor4fv(_col);
glVertex3dv(&r1.x);
glColor4f(0,0,0,0);
glVertex3dv(&r2.x);
r1 = rot * r1;
r2 = rot * r2;
}
glEnd();
glEnable(GL_CULL_FACE);
glDisable(GL_BLEND);
glEnable(GL_LIGHTING);
glPopMatrix();
}
void pie_Draw3DShape(iIMDShape *shape, int frame, int team, PIELIGHT colour, int pieFlag, int pieFlagData)
{
PIELIGHT teamcolour;
ASSERT_OR_RETURN(, shape, "Attempting to draw null sprite");
teamcolour = pal_GetTeamColour(team);
pieCount++;
ASSERT(frame >= 0, "Negative frame %d", frame);
ASSERT(team >= 0, "Negative team %d", team);
if (drawing_interface || !shadows)
{
pie_Draw3DShape2(shape, frame, colour, teamcolour, pieFlag, pieFlagData);
}
else
{
if (pieFlag & (pie_ADDITIVE | pie_TRANSLUCENT | pie_PREMULTIPLIED) && !(pieFlag & pie_FORCE_IMMEDIATE))
{
TranslucentShape tshape;
glGetFloatv(GL_MODELVIEW_MATRIX, tshape.matrix);
tshape.shape = shape;
tshape.frame = frame;
tshape.colour = colour;
tshape.flag = pieFlag;
tshape.flag_data = pieFlagData;
tshapes.push_back(tshape);
}
else
{
if(pieFlag & pie_SHADOW || pieFlag & pie_STATIC_SHADOW)
{
float distance;
// draw a shadow
ShadowcastingShape scshape;
glGetFloatv(GL_MODELVIEW_MATRIX, scshape.matrix);
distance = scshape.matrix[12] * scshape.matrix[12];
distance += scshape.matrix[13] * scshape.matrix[13];
distance += scshape.matrix[14] * scshape.matrix[14];
// if object is too far in the fog don't generate a shadow.
if (distance < SHADOW_END_DISTANCE)
{
float invmat[9], pos_light0[4];
inverse_matrix( scshape.matrix, invmat );
// Calculate the light position relative to the object
glGetLightfv(GL_LIGHT0, GL_POSITION, pos_light0);
scshape.light.x = invmat[0] * pos_light0[0] + invmat[3] * pos_light0[1] + invmat[6] * pos_light0[2];
scshape.light.y = invmat[1] * pos_light0[0] + invmat[4] * pos_light0[1] + invmat[7] * pos_light0[2];
scshape.light.z = invmat[2] * pos_light0[0] + invmat[5] * pos_light0[1] + invmat[8] * pos_light0[2];
scshape.shape = shape;
scshape.flag = pieFlag;
scshape.flag_data = pieFlagData;
scshapes.push_back(scshape);
}
}
pie_Draw3DShape2(shape, frame, colour, teamcolour, pieFlag, pieFlagData);
}
}
}
static std::string getLightingState(bool showDisabled) {
std::string result;
int L;
if (glIsEnabled(GL_LIGHTING)) {
result += "glEnable(GL_LIGHTING);\n";
} else {
result += "glDisable(GL_LIGHTING);\n";
if (! showDisabled) {
return result;
}
}
result += "\n";
result += format("glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, %d);\n\n", glGetInteger(GL_LIGHT_MODEL_TWO_SIDE));
for (L = 0; L < 8; L++) {
result += format("// Light %d\n", L);
if (glIsEnabled(GL_LIGHT0 + L)) {
result += format("glEnable(GL_LIGHT0 + %d);\n", L);
} else {
result += format("glDisable(GL_LIGHT0 + %d);\n", L);
}
if (showDisabled || glIsEnabled(GL_LIGHT0 + L)) {
float x[4];
glGetLightfv(GL_LIGHT0 + L, GL_POSITION, x);
result += format("{float pos[]={%4.4ff, %4.4ff, %4.4ff, %4.4ff};\nglLightfv(GL_LIGHT0 + %d, GL_POSITION, pos);}\n",
x[0], x[1], x[2], x[3], L);
glGetLightfv(GL_LIGHT0 + L, GL_AMBIENT, x);
result += format("{float col[]={%4.4ff, %4.4ff, %4.4ff, %4.4ff};\nglLightfv(GL_LIGHT0 + %d, GL_AMBIENT, col);}\n",
x[0], x[1], x[2], x[3], L);
glGetLightfv(GL_LIGHT0 + L, GL_DIFFUSE, x);
result += format("{float col[]={%4.4ff, %4.4ff, %4.4ff, %4.4ff};\nglLightfv(GL_LIGHT0 + %d, GL_DIFFUSE, col);}\n",
x[0], x[1], x[2], x[3], L);
glGetLightfv(GL_LIGHT0 + L, GL_SPECULAR, x);
result += format("{float col[]={%4.4ff, %4.4ff, %4.4ff, %4.4ff};\nglLightfv(GL_LIGHT0 + %d, GL_SPECULAR, col);}\n",
x[0], x[1], x[2], x[3], L);
glGetLightfv(GL_LIGHT0 + L, GL_CONSTANT_ATTENUATION, x);
result += format("glLightf (GL_LIGHT0 + %d, GL_CONSTANT_ATTENUATION, %ff);\n",
L, x[0]);
glGetLightfv(GL_LIGHT0 + L, GL_LINEAR_ATTENUATION, x);
result += format("glLightf (GL_LIGHT0 + %d, GL_LINEAR_ATTENUATION, %ff);\n",
L, x[0]);
glGetLightfv(GL_LIGHT0 + L, GL_QUADRATIC_ATTENUATION, x);
result += format("glLightf (GL_LIGHT0 + %d, GL_QUADRATIC_ATTENUATION, %ff);\n",
L, x[0]);
}
result += "\n";
}
// Ambient
result += "// Ambient\n";
float x[4];
glGetFloatv(GL_LIGHT_MODEL_AMBIENT, x);
result += format("{float col[] = {%ff, %ff, %ff, %ff};\n glLightModelfv(GL_LIGHT_MODEL_AMBIENT, col);}\n",
x[0], x[1], x[2], x[3]);
result += "\n";
return result;
}
void pie_Draw3DShape(iIMDShape *shape, int frame, int team, PIELIGHT colour, int pieFlag, int pieFlagData)
{
pieCount++;
ASSERT(frame >= 0, "Negative frame %d", frame);
ASSERT(team >= 0, "Negative team %d", team);
const PIELIGHT teamcolour = pal_GetTeamColour(team);
if (pieFlag & pie_BUTTON)
{
pie_Draw3DButton(shape, teamcolour);
}
else
{
SHAPE tshape;
tshape.shape = shape;
tshape.frame = frame;
tshape.colour = colour;
tshape.teamcolour = teamcolour;
tshape.flag = pieFlag;
tshape.flag_data = pieFlagData;
pie_GetMatrix(&tshape.matrix[0][0]);
if (pieFlag & pie_HEIGHT_SCALED) // construct
{
tshape.matrix = glm::scale(tshape.matrix, glm::vec3(1.0f, (float)pieFlagData / (float)pie_RAISE_SCALE, 1.0f));
}
if (pieFlag & pie_RAISE) // collapse
{
tshape.matrix = glm::translate(tshape.matrix, glm::vec3(1.0f, (-shape->max.y * (pie_RAISE_SCALE - pieFlagData)) * (1.0f / pie_RAISE_SCALE), 1.0f));
}
if (pieFlag & (pie_ADDITIVE | pie_TRANSLUCENT | pie_PREMULTIPLIED))
{
tshapes.push_back(tshape);
}
else
{
if (shadows && (pieFlag & pie_SHADOW || pieFlag & pie_STATIC_SHADOW))
{
float distance;
// draw a shadow
ShadowcastingShape scshape;
pie_GetMatrix(&scshape.matrix[0][0]);
distance = scshape.matrix[3][0] * scshape.matrix[3][0];
distance += scshape.matrix[3][1] * scshape.matrix[3][1];
distance += scshape.matrix[3][2] * scshape.matrix[3][2];
// if object is too far in the fog don't generate a shadow.
if (distance < SHADOW_END_DISTANCE)
{
glm::vec4 pos_light0;
glm::mat4 invmat = glm::inverse(scshape.matrix);
// Calculate the light position relative to the object
glGetLightfv(GL_LIGHT0, GL_POSITION, &pos_light0[0]);
scshape.light = invmat * pos_light0;
scshape.shape = shape;
scshape.flag = pieFlag;
scshape.flag_data = pieFlagData;
scshapes.push_back(scshape);
}
}
shapes.push_back(tshape);
}
}
}
