void SceneWidget::selectLightingMode (const std::string& mode)
{
if (mode=="day")
setLighting (&mLightingDay);
else if (mode=="night")
setLighting (&mLightingNight);
else if (mode=="bright")
setLighting (&mLightingBright);
}
void setShaders()
{
MapObject Tiles = getTileBuffer();
ImportObj Tee = getTeeBuffer();
ImportObj Cup = getCupBuffer();
ImportObj Walls = getWallsBuffer();
ImportObj Pointer = getPointer();
GLuint program = LoadShaders("vshader5.glsl", "fshader5.glsl");
shadertemp = program;
glUseProgram(program);
GLuint vPosition, vNormal;
//Set lighting
setLighting(program);
// Retrieve transformation uniform variable locations
ModelView = glGetUniformLocation(program, "ModelView");
Projection = glGetUniformLocation(program, "Projection");
glGenVertexArrays(6, vao);
BindShader(vao[0], program, Tiles.Vertices, Tiles.Normals, Tiles.Indices);
BindShader(vao[1], program, Tee.Vertices, Tee.Normals, Tee.Indices);
BindShader(vao[2], program, Cup.Vertices, Cup.Normals, Cup.Indices);
BindShader(vao[3], program, GolfBall.Model.Vertices, GolfBall.Model.Normals, GolfBall.Model.Indices);
BindShader(vao[4], program, Walls.Vertices, Walls.Normals, Walls.Indices);
BindShader(vao[5], program, Pointer.Vertices, Pointer.Normals, Pointer.Indices);
}
void GLWidget::paintGL()
{
// ---- Drawing all opaques objects (here, mainly lines) ----
glDepthMask(GL_TRUE);
// Clear the window and buffers
glClearColor(settings_->backgroundColor_r(),
settings_->backgroundColor_g(),
settings_->backgroundColor_b(),
1);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Initialize the view and lighting
setCameraPositionAndOrientation();
setLighting();
// Set material (this is required for the 3D vew)
// XXX this shouldn't be done here
setMaterial(material_);
glEnable(GL_COLOR_MATERIAL);
// Draw scene
currentGLWidget_ = this;
drawScene();
currentGLWidget_ = 0;
}
SceneWidget::SceneWidget(QWidget *parent)
: QWidget(parent)
, mWindow(NULL)
, mCamera(NULL)
, mSceneMgr(NULL), mNavigation (0), mLighting (0), mUpdate (false)
, mKeyForward (false), mKeyBackward (false), mKeyLeft (false), mKeyRight (false)
, mKeyRollLeft (false), mKeyRollRight (false)
, mFast (false), mDragging (false), mMod1 (false)
, mFastFactor (4) /// \todo make this configurable
, mDefaultAmbient (0, 0, 0, 0), mHasDefaultAmbient (false)
{
setAttribute(Qt::WA_PaintOnScreen);
setAttribute(Qt::WA_NoSystemBackground);
setFocusPolicy (Qt::StrongFocus);
mSceneMgr = Ogre::Root::getSingleton().createSceneManager(Ogre::ST_GENERIC);
mSceneMgr->setAmbientLight (Ogre::ColourValue (0,0,0,1));
mCamera = mSceneMgr->createCamera("foo");
mCamera->setPosition (300, 0, 0);
mCamera->lookAt (0, 0, 0);
mCamera->setNearClipDistance (0.1);
mCamera->setFarClipDistance (30000);
mCamera->roll (Ogre::Degree (90));
setLighting (&mLightingDay);
QTimer *timer = new QTimer (this);
connect (timer, SIGNAL (timeout()), this, SLOT (update()));
timer->start (20); /// \todo make this configurable
}
void display(void) {
++FrameCount;
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
eye=Vec3( dist * cos( theta ) * (cos( phi )), dist * sin( theta ) * (cos( phi )), dist * sin( phi ) );
setLighting();
setCamera();
float EYE[]={eye.x,eye.y,eye.z};
glUseProgram(ProgramID);
glUniformMatrix4fv(projMatrixLoc, 1, false, projMatrix);
glUniformMatrix4fv(viewMatrixLoc, 1, false, viewMatrix);
glUniform4fv(LightPosLoc, 1, LightPosition);
glUniform4fv(LightDifLoc, 1, DiffuseLight);
glUniform4fv(LightAmbLoc, 1, AmbientLight);
glUniform4fv(LightSpecLoc, 1, SpecularLight);
glUniform3fv(eyeLoc, 1, EYE);
glBindVertexArray(VAO);
if(MODE==0){
glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
glDrawElements(GL_TRIANGLES,3*model->nf,GL_UNSIGNED_INT,(GLvoid*)0);
}
else if(MODE==1){
glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
glDrawElements(GL_TRIANGLES,3*model->nf,GL_UNSIGNED_INT,(GLvoid*)0);
}
else if(MODE==2){
glUniform3f(cLoc,0,0,0);
glDrawElements(GL_POINTS,3*model->nf,GL_UNSIGNED_INT,(GLvoid*)0);
}
glutSwapBuffers();
}
void GodRaysSampler::prepare(SoftwareRenderer *renderer) {
setCameraLocation(renderer->getCameraLocation());
setLighting(renderer->getLightingManager());
setAltitudes(renderer->getScenery()->getTerrain()->getHeightInfo().min_height,
renderer->getCloudsRenderer()->getHighestAltitude());
renderer->getScenery()->getAtmosphere()->childGodRays()->copy(definition);
reset();
}
void lightShader::beginRender()
{
shader.setShaderActive(true);
setLighting();
setMaterial();
shader.setUniformVariable3f("cLightPosition", LightPosition[0], LightPosition[1], LightPosition[2]);
glActiveTexture(GL_TEXTURE0);
}
SceneWidget::SceneWidget(Resource::SceneManager* sceneManager, QWidget *parent, Qt::WindowFlags f)
: RenderWidget(parent, f)
, mSceneManager(sceneManager)
, mLighting(NULL)
, mHasDefaultAmbient(false)
{
// we handle lighting manually
mView->setLightingMode(osgViewer::View::NO_LIGHT);
setLighting(&mLightingDay);
}
void displayObject()
{
setMaterial();
setLighting();
setViewport();
setCamera();
//startDrawing
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
sate();//memanggil fungsi menggambar objek sate
glFlush();//mengirim semua objek untuk dirender
}
SceneWidget::SceneWidget(boost::shared_ptr<Resource::ResourceSystem> resourceSystem, QWidget *parent, Qt::WindowFlags f)
: RenderWidget(parent, f)
, mResourceSystem(resourceSystem)
, mLighting(NULL)
, mHasDefaultAmbient(false)
{
// we handle lighting manually
mView->setLightingMode(osgViewer::View::NO_LIGHT);
setLighting(&mLightingDay);
}
CGameCamera::CGameCamera()
{
m_targetObject = NULL;
m_objectType = CGameObject::CameraObject;
#ifdef GSEDITOR
m_cameraMesh = NULL;
#endif
ISceneManager *smgr = getIView()->getSceneMgr();
// save old camera
ICameraSceneNode *oldCam = smgr->getActiveCamera();
// create new camera
m_camera = smgr->addCameraSceneNode();
m_camera->setFOV( core::degToRad(60.0f) );
m_camera->setFarValue( 8000.0f );
m_camera->grab();
core::vector3df pos(0,0,0);
setPosition( pos );
core::vector3df target(1,0,0);
setTarget( target );
#ifdef GSEDITOR
CColladaMeshComponent *comp = new CColladaMeshComponent( this );
comp->loadFromFile( getIView()->getPath("data/editor/camera.dae") );
addComponent( comp );
setLighting( false );
m_cameraMesh = m_node;
m_cameraMesh->setVisible( true );
ITriangleSelector *selector = smgr->createTriangleSelectorFromBoundingBox( m_cameraMesh );
m_cameraMesh->setTriangleSelector(selector);
selector->drop();
#endif
// set camera node
m_node = m_camera;
// restore camera
smgr->setActiveCamera( oldCam );
m_animator = NULL;
#ifndef GSGAMEPLAY
setEditorCamera();
#else
setFreeCamera();
#endif
}
void Mesh::EnableSpecialFX(){
draw_sequence=MESH_SPECIAL_FX_ONLY;
setEnvMap(GFXFALSE);
setLighting (GFXTRUE);
if (orig) {
orig->draw_sequence=MESH_SPECIAL_FX_ONLY;
orig->blendSrc = orig->blendDst= ONE;
orig->setEnvMap( GFXFALSE);
orig->setLighting (GFXTRUE);
}
blendSrc=ONE;
blendDst=ONE;
}
// ***************************************************************************
void CMaterial::initUnlit()
{
setShader(Normal);
setLighting(false);
setColor(CRGBA(255,255,255,255));
for(uint32 i=0;i<IDRV_MAT_MAXTEXTURES;i++)
setTexture((uint8)i ,NULL);
setZBias(0);
setZFunc(lessequal);
setZWrite(true);
setBlend(false);
setAlphaTestThreshold(0.5f);
}
/*
Afficher les deux lumieres
*/
void drawLights()
{
/*
** AJOUTER CODE ICI
**
** Dessine chaque lumiere en utilisant sa composante diffuse
** comme couleur. Utilisez la commande "glutSolideSphere" pour afficher
** les lumieres.
**
** Vous devez desactiver l'eclairage et le remettre dans son
** etat inital ensuite
*/
if(glIsEnabled(GL_LIGHTING) == GL_TRUE)
{
glDisable(GL_LIGHTING);
for (int i = 0; i < 2; i++) {
glPushMatrix();
glDisable(gLights[i].lightID);
if(gLights[i].on)
{
setLighting(gLights[i]);
glEnable(gLights[i].lightID);
}
glTranslated(gLights[i].position[0], gLights[i].position[1], gLights[i].position[2]);
glColor4fv(gLights[i].diffuse);
glutSolidSphere(8,20,20);
glPopMatrix();
}
glEnable(GL_LIGHTING);
}
else
{
for (int i = 0; i < 2; i++) {
glPushMatrix();
glTranslated(gLights[i].position[0], gLights[i].position[1], gLights[i].position[2]);
glColor4fv(gLights[i].diffuse);
glutSolidSphere(8,20,20);
glPopMatrix();
}
}
}
void displayObject()
{
setMaterial();
setLighting();
setViewport();
setCamera();
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
kubus();
prisma();
teko();
bola();
cone();
donat();
glFlush();
}
void display()
{
glClearColor(0.0,0.0,0.0,1.0);
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
//gluLookAt(0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
setLighting();
shader.bind();
cube();
shader.unbind();
//glutSwapBuffers();
SDL_GL_SwapBuffers();
angle += 0.1f;
}
void MapgenSinglenode::makeChunk(BlockMakeData *data)
{
// Pre-conditions
assert(data->vmanip);
assert(data->nodedef);
assert(data->blockpos_requested.X >= data->blockpos_min.X &&
data->blockpos_requested.Y >= data->blockpos_min.Y &&
data->blockpos_requested.Z >= data->blockpos_min.Z);
assert(data->blockpos_requested.X <= data->blockpos_max.X &&
data->blockpos_requested.Y <= data->blockpos_max.Y &&
data->blockpos_requested.Z <= data->blockpos_max.Z);
this->generating = true;
this->vm = data->vmanip;
this->ndef = data->nodedef;
v3s16 blockpos_min = data->blockpos_min;
v3s16 blockpos_max = data->blockpos_max;
// Area of central chunk
v3s16 node_min = blockpos_min * MAP_BLOCKSIZE;
v3s16 node_max = (blockpos_max + v3s16(1, 1, 1)) * MAP_BLOCKSIZE - v3s16(1, 1, 1);
blockseed = getBlockSeed2(node_min, data->seed);
MapNode n_node(c_node);
for (s16 z = node_min.Z; z <= node_max.Z; z++)
for (s16 y = node_min.Y; y <= node_max.Y; y++) {
u32 i = vm->m_area.index(node_min.X, y, z);
for (s16 x = node_min.X; x <= node_max.X; x++) {
if (vm->m_data[i].getContent() == CONTENT_IGNORE)
vm->m_data[i] = n_node;
i++;
}
}
// Add top and bottom side of water to transforming_liquid queue
updateLiquid(&data->transforming_liquid, node_min, node_max);
// Set lighting
if ((flags & MG_LIGHT) && set_light == LIGHT_SUN)
setLighting(LIGHT_SUN, node_min, node_max);
this->generating = false;
}
SceneWidget::SceneWidget(boost::shared_ptr<Resource::ResourceSystem> resourceSystem, QWidget *parent, Qt::WindowFlags f)
: RenderWidget(parent, f)
, mResourceSystem(resourceSystem)
, mLighting(NULL)
, mHasDefaultAmbient(false)
{
// we handle lighting manually
mView->setLightingMode(osgViewer::View::NO_LIGHT);
setLighting(&mLightingDay);
mResourceSystem->getSceneManager()->setParticleSystemMask(Mask_ParticleSystem);
/// \todo make shortcut configurable
QShortcut *focusToolbar = new QShortcut (Qt::Key_T, this, 0, 0, Qt::WidgetWithChildrenShortcut);
connect (focusToolbar, SIGNAL (activated()), this, SIGNAL (focusToolbarRequest()));
}
void display(void) {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
setLighting();
setMaterial();
glTranslatef(0.0, 0.0, transZ);
//glRotatef(rotY, 0.0, 1.0, 0.0);
glutSolidTeapot(1);
glutSwapBuffers();
}
//-----------------------------------------------------------------------------
//* Initialize
//! Initializes OpenGL.
//
//! @param fullscreen will render scene in fullscreen if true
//! @param width width of window or width of screen resolution
//! @param height height of window or height of screen resolution
//! @param bitDepth bitDepth to use
//! @param refreshRate refresh frequency to use
//! @param vSync limits frame rate to the monitor's refresh frequency
//! @param hideCursor hides mouse coursor if true
//-----------------------------------------------------------------------------
bool OpenGLManager::initialize(bool fullscreen, int width, int height, int bitDepth, int refreshRate, bool vSync, bool hideCursor)
{
m_width = width;
m_height = height;
m_bitDepth = bitDepth;
m_refreshRate = refreshRate;
m_fullscreen = fullscreen;
m_renderingCallback = NULL;
//Set OpenGL Settings
setClearColor(0.0f, 0.0f, 0.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
//Set render states
setCullMode(false, true);
setTextureing2D(false);
setLighting(false);
return true;
}
int main(int argc, char** argv)
{
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowPosition(200,50);
glutInitWindowSize(winWidth,winHeight);
main_window = glutCreateWindow("Nick Barnes - Homework 6");
glutDisplayFunc(drawScene);
glutMouseFunc(mouseFunc);
glutMotionFunc(motionFunc);
glutKeyboardFunc(keyFunc);
glutIdleFunc(idleFunc);
glutReshapeFunc(resizeScene);
setLighting();
//gluiCode();
glEnable(GL_TEXTURE_2D);
LoadGLTextures();
glShadeModel(GL_SMOOTH);
glEnable(GL_DEPTH_TEST);
glutMainLoop();
}
void GLWidget::initializeGL(){
//glewInit();
glEnable( GL_DEPTH_TEST);
glFrontFace( GL_CCW);
glShadeModel( GL_SMOOTH);
glEnable( GL_NORMALIZE);
setLighting( true);
init3dEng();
setQuaternion( 1);
//m_trackBalls = TrackBall(0.0f, QVector3D(0, 1, 0), TrackBall::Plane);
m_trackBalls = TrackBall(0.0f, QVector3D(0, 1, 0), TrackBall::Sphere);
//-- sun Light
sun1.isOn = true;
sun1.mat.ambi.set( .3, .3, .3, 1.);
sun1.mat.diff.set( .7, .7, .7, 1.);
sun1.pos.set( -.5, 1, .5, 0.);
sun2.isOn = true;
sun2.mat.ambi.set( .3, .3, .3, 1.);
sun2.mat.diff.set( .7, .7, .7, 1.);
sun2.pos.set( .5, -1, -.5, 0.);
//-- bulb Light
bulb.isOn = false;
bulb.mat.ambi.set( .3, .3, .3, 1.);
bulb.mat.diff.set( .7, .7, .7, 1.);
bulb.mat.spec.set( 1., 1., 1., 1.);
bulb.att.set( 1.0, .01, .0003);
Texture2d *tex;
GLubyte *textureImage; //added by sai
tex = loadBMP( "lap.bmp");
//bool success = loadPngImage("lap.png",256,256,true,&textureImage);
//tex = loadBMP( "tex3.bmp");
//stoma.Load3ds( "stomach.3ds");
stoma.LoadBIN("mesh.bin");
stoma.smooth = 1;
stoma.bindTexture( tex);
//stoma.bindTexture(&textureImage);
//stoma.rotate( -90, 0, 0);
//stoma.scale( Vector3f( .3, .3, .3));
//stoma.scale( Vector3f( .003, .003, .003));
stoma.col.set( .6, .6, .2);
stoma.calcBoundingCube();
stoma.calcGraph();
//glTranslatef(0,-160.0,0.0);
stoma.drawGraph();
skele.Load3ds( "skeleton.3ds");
skele.smooth = 1;
skele.col.set( .7, .7, .7);
skele.calcBoundingCube();
//stoma += -((skele.cubeBoundMin+skele.cubeBoundMax)/2.0);
stoma += -((stoma.cubeBoundMin+stoma.cubeBoundMax)/2.0);
skele += -((skele.cubeBoundMin+skele.cubeBoundMax)/2.0);
skele.updateDisplayList();
stoma.lap();
stoma.saveBIN( "mappedmesh.bin");
//tex = loadBMP( "lapatlas.bmp");
//stoma.bindTexture( tex);
stoma.updateDisplayList();
skele.isHidden = true;
model.LoadBIN( "mesh.bin");
model.col.set( .8, .4, .4);
model.scale( Vector3f(.1));
model.calcBoundingCube();
model += -((model.cubeBoundMin+model.cubeBoundMax)/2.0);
model.updateDisplayList();
model.isHidden = true;
m_mouseClick = 0;
camS = 0.1;
camM = 1.0; // camera zoom
camT = 0.0; camP = 0.0; // camera theta and phi
aspectRatio = 1.0;
freeCam.pos.set( 45., 0., 0.);
//freeCam.pos.set( 0., 0., -50.);
freeCam.cnear = 0.01;
freeCam.cfar = 2000.0;
freeCam.ang = 45.0/camM;
freeCam.eye.set( 0., 0., 0.);
//freeCam.eye = freeCam.pos + Vector3f( sin(camP)*cos(camT), sin(camT), cos(camP)*cos(camT));
printf("Done\n");
}
//--------------------------------------------------------------
// draw the view
void mgDX9Display::drawView()
{
mg_d3dDevice->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER,
D3DCOLOR_XRGB(0, 0, 0), 1.0f, 0);
// if too early, do nothing
if (m_theApp == NULL)
return;
mg_d3dDevice->BeginScene();
D3DXMatrixIdentity(&m_state->m_worldMatrix);
// render sky (before light and fog, or we can't see sky)
D3DXMATRIX eyeMatrix;
toD3DMatrix(m_eyeMatrix, eyeMatrix);
m_state->m_viewMatrix = eyeMatrix;
mg_d3dDevice->SetTransform(D3DTS_PROJECTION, &m_state->m_projMatrix);
mg_d3dDevice->SetTransform(D3DTS_WORLD, &m_state->m_worldMatrix);
mg_d3dDevice->SetTransform(D3DTS_VIEW, &m_state->m_viewMatrix);
// set defaults
setMatColor(0.5, 0.5, 0.5);
setLighting(false);
m_theApp->drawSky();
// set up for world object rendering
D3DXMatrixIdentity(&m_state->m_worldMatrix);
mg_d3dDevice->SetTransform(D3DTS_PROJECTION, &m_state->m_projMatrix);
mg_d3dDevice->SetTransform(D3DTS_WORLD, &m_state->m_worldMatrix);
// set up view transform
D3DXMATRIX translate;
D3DXMatrixTranslation(&translate, (FLOAT) -m_eyePt.x, (FLOAT) -m_eyePt.y, (FLOAT) -m_eyePt.z);
D3DXMatrixMultiply(&m_state->m_viewMatrix, &translate, &eyeMatrix);
mg_d3dDevice->SetTransform(D3DTS_VIEW, &m_state->m_viewMatrix);
frustumBuildPlanes();
setLightAndFog();
// set defaults
setMatColor(0.5, 0.5, 0.5);
setLighting(true);
setZEnable(true);
setTransparent(false);
// tell the app the draw the view
m_theApp->drawView();
// set up for front plane rendering. screen coordinates.
D3DXMATRIX identity;
D3DXMatrixIdentity(&identity);
mg_d3dDevice->SetTransform(D3DTS_PROJECTION, &identity);
mg_d3dDevice->SetTransform(D3DTS_WORLD, &identity);
D3DXMATRIX scaling;
D3DXMatrixScaling(&scaling, 2.0f/(FLOAT) m_graphicsWidth, -2.0f/(FLOAT) m_graphicsHeight, 1.0f);
D3DXMatrixTranslation(&translate, -0.5f * (FLOAT) m_graphicsWidth, -0.5f * (FLOAT) m_graphicsHeight, 0.0f);
D3DXMatrixMultiply(&m_state->m_viewMatrix, &translate, &scaling);
mg_d3dDevice->SetTransform(D3DTS_VIEW, &m_state->m_viewMatrix);
// turn off quality texture filtering. for overlay, we want the actual pixels
mg_d3dDevice->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_NONE);
mg_d3dDevice->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_POINT);
mg_d3dDevice->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_POINT);
// set defaults for overlay
setMatColor(1.0, 1.0, 1.0);
setLighting(false);
setZEnable(false);
// tell the app to draw its overlay
m_theApp->drawOverlay();
// draw the cursor, if enabled
if (m_cursorEnabled)
drawCursor();
// turn texture filtering back on
mg_d3dDevice->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
mg_d3dDevice->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_ANISOTROPIC);
mg_d3dDevice->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_ANISOTROPIC);
mg_d3dDevice->SetSamplerState(0, D3DSAMP_MAXANISOTROPY, 2); // m_state->m_deviceCaps.MaxAnisotropy);
mg_d3dDevice->EndScene();
}
void drawObjects(void)
{
int x, y;
float float_x, float_y, float_xb, float_yb;
glTranslatef(transZ, 0.0, -transX);
glRotatef(xrot, 0.0, 1.0, 0.0);
//glRotatef(-yrot, 0.0, 1.0, 0.0);
// Ground
//glColor4f(0.3f,0.3f,0.3f,1);
//glEnable( GL_TEXTURE_2D );
//glBindTexture( GL_TEXTURE_2D, tex );
glBegin(GL_QUADS);
//glTexCoord2f(0, 0);
glColor4f(0.54f,0.27f,0.07f,1);
glVertex3f(-35,-5,-35);
//glTexCoord2f(1, 0);
glColor4f(0.54f,0.27f,0.07f,1);
glVertex3f(-35,-5, 15);
//glTexCoord2f(1, 1);
glColor4f(0.54f,0.27f,0.07f,1);
glVertex3f( 15,-5, 15);
//glTexCoord2f(0, 1);
glColor4f(0.54f,0.27f,0.07f,1);
glVertex3f( 15,-5,-35);
//glTexCoord2f(0, 0);
glColor4f(0.5f,0.5f,0.0f,1);
glVertex3f(-35,12,-35);
//glTexCoord2f(1, 0);
glColor4f(0.5f,0.5f,0.0f,1);
glVertex3f(-35,12, 15);
glColor4f(0.5f,0.5f,0.0f,1);
//glTexCoord2f(1, 1);
glColor4f(0.5f,0.5f,0.0f,1);
glVertex3f( -35,-5, 15);
//glTexCoord2f(0, 1);
glColor4f(0.5f,0.5f,0.0f,1);
glVertex3f( -35,-5,-35);
glEnd();
glPushMatrix();
glTranslatef(0,-2.5,-16);
glColor4f(0.9f,0.9f,0.9f,1);
glMatrixMode(GL_TEXTURE);
glActiveTextureARB(GL_TEXTURE7);
glPushMatrix();
glTranslatef(0,-2.5,-16);
glutSolidCube(4);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
glPushMatrix();
glUseProgram(shaderProgram);
setLighting();
setMaterial();
glTranslatef(-20,-2.5,-20);
glRotatef(-90, 1.0, 0.0, 0.0);
glRotatef(90, 0.0, 0.0, 1.0);
glMatrixMode(GL_TEXTURE);
glActiveTextureARB(GL_TEXTURE7);
glPushMatrix();
glTranslatef(-20,-2.5,-20);
glutSolidCube(4);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
//endTranslate();
glUseProgram(0);
glPushMatrix();
glUseProgram(shaderProgram);
setLighting();
setMaterial();
glTranslatef(0,0,-5);
glRotatef(-90, 1.0, 0.0, 0.0);
glRotatef(90, 0.0, 0.0, 1.0);
glMatrixMode(GL_TEXTURE);
glActiveTextureARB(GL_TEXTURE7);
glPushMatrix();
glTranslatef(0,0,-5);
glutSolidSphere(2,25,25);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
//endTranslate();
glUseProgram(0);
glPushMatrix();
glUseProgram(shaderProgram);
setLighting();
setMaterial();
glTranslatef(-20,7,-10);
glMatrixMode(GL_TEXTURE);
glActiveTextureARB(GL_TEXTURE7);
glPushMatrix();
glTranslatef(-20,7,-10);
glBegin(GL_QUADS);
for( x = 0; x < 44; x++ )
{
for( y = 0; y < 44; y++ )
{
float_x = float(x)/44.0f;
float_y = float(y)/44.0f;
float_xb = float(x+1)/44.0f;
float_yb = float(y+1)/44.0f;
//glTexCoord2f( float_x, float_y);
//glColor4f(1.0, 0.0, 0.0, 1.0);
glVertex3f( points[x][y][0], points[x][y][1], points[x][y][2] );
// glTexCoord2f( float_x, float_yb );
//glColor4f(0.0, 1.0, 0.0, 1.0);
glVertex3f( points[x][y+1][0], points[x][y+1][1], points[x][y+1][2] );
// glTexCoord2f( float_xb, float_yb );
//glColor4f(0.0, 0.0, 1.0, 1.0);
glVertex3f( points[x+1][y+1][0], points[x+1][y+1][1], points[x+1][y+1][2] );
// glTexCoord2f( float_xb, float_y );
//glColor4f(1.0, 1.0, 0.0, 1.0);
glVertex3f( points[x+1][y][0], points[x+1][y][1], points[x+1][y][2] );
}
}
glEnd();
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
if( wiggle_count == 2 )
{
for( y = 0; y < 45; y++ )
{
hold=points[0][y][2];
for( x = 0; x < 44; x++)
{
points[x][y][2] = points[x+1][y][2];
}
points[44][y][2]=hold;
}
wiggle_count = 0;
}
wiggle_count++;
// Instead of calling glTranslatef, we need a custom function that also maintain the light matrix
//startTranslate(0,10,-16);
glUseProgram(0);
glPushMatrix();
glUseProgram(shaderProgram);
setMaterial2();
setLighting2();
glTranslatef(-15.5,-5,-10);
glRotatef(-90, 1.0, 0.0, 0.0);
glRotatef(90, 0.0, 0.0, 1.0);
glMatrixMode(GL_TEXTURE);
glActiveTextureARB(GL_TEXTURE7);
glPushMatrix();
glTranslatef(-15.5,-5,-10);
GLUquadric *quadratic = gluNewQuadric();
gluCylinder(quadratic, 0.75f, 0.75f, 17.0f, 10.0f, 10.0f);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
glUseProgram(0);
glPushMatrix();
glUseProgram(shaderProgram);
setMaterial3();
setLighting3();
glTranslatef(-15.5,12,-10);
glRotatef(-90, 1.0, 0.0, 0.0);
glRotatef(90, 0.0, 0.0, 1.0);
glMatrixMode(GL_TEXTURE);
glActiveTextureARB(GL_TEXTURE7);
glPushMatrix();
glTranslatef(-15.5,12,-10);
glutSolidSphere(1,25,25);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
glUseProgram(0);
glPushMatrix();
glUseProgram(toonProgram);
setMaterial3();
setLighting3();
glTranslatef(-10,-2.5,-30);
//glRotatef(-90, 1.0, 0.0, 0.0);
//glRotatef(90, 0.0, 0.0, 1.0);
glMatrixMode(GL_TEXTURE);
glActiveTextureARB(GL_TEXTURE7);
glPushMatrix();
glTranslatef(-10,-5,-30);
glutSolidTorus(1.5, 2.0, 10.0, 50.0);
//glutSolidTeapot(4);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
glUseProgram(0);
}
void Renderer::render(const shared_ptr<Scene>& _scene, bool _withNames, bool _fastDraw){
if(!initDone || _scene->glDirty || (_scene->gl && _scene->gl->dirty)){
init(_scene);
_scene->glDirty=false;
if(_scene->gl) _scene->gl->dirty=false;
}
assert(initDone);
switch(fast){
case FAST_ALWAYS: fastDraw=true; break;
case FAST_UNFOCUSED: fastDraw=_fastDraw; break;
case FAST_NEVER: fastDraw=false; break;
}
// make a copy to see if it were true the whole time
bool wasSetRefNow(setRefNow);
withNames=_withNames; // used in many methods
if(withNames) glNamedObjects.clear();
// acquire shared_ptr to scene
{ scene=_scene; }
// smuggle scene and ourselves into GLViewInfo for use with GlRep and field functors
viewInfo.scene=scene.get();
viewInfo.renderer=this;
setClippingPlanes();
setLighting();
drawPeriodicCell();
fieldDispatcher.scene=scene.get(); fieldDispatcher.updateScenePtr();
for(auto& f: scene->fields){
fieldDispatcher(f,&viewInfo);
}
if(engines){
for(const auto& e: scene->engines){
if(!e || e->dead) continue; // !e should not happen, but make sure
glScopedName name(viewInfo,e,shared_ptr<Node>());
e->render(viewInfo);
}
}
for(const shared_ptr<GlExtraDrawer>& d: extraDrawers){
if(!d || d->dead) continue;
glPushMatrix();
d->scene=scene.get();
d->render();
glPopMatrix();
}
// if ref positions were set the whole time, unset here, it is done for all nodes
if(setRefNow && wasSetRefNow){ setRefNow=false; }
if(withNames) cerr<<"render(withNames==true) done, "<<glNamedObjects.size()<<" objects inserted"<<endl;
// release the shared_ptr; must be GIL-protected since descruction of Python-constructed object without GIL causes crash
{ GilLock lock; scene.reset(); }
}
void CMaterial::initLighted()
{
initUnlit();
setLighting(true);
}
