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); } } }