void planet::draw(vector<vector<double> > positions) {
// Hollow circle to represent planets
ofNoFill();
// Draw the tail
drawTail(positions);
// Draw the planet at this point in time
ofEllipse(SCALE_FACTOR*position[0] + ofGetWindowWidth()/2.0, SCALE_FACTOR*position[1] + ofGetWindowHeight()/2.0, DIAMETER,DIAMETER);
}
/* void drawHelicopter()
This function holds all the creation of
the parts of the helicopter
*/
void Model::drawHelicopter() {
glPushMatrix();
setPosition();
drawEngine();
drawTailConnect();
drawTail();
drawBody();
glPopMatrix(); // Last pop containing the helicopter
glPopMatrix();
}
int main() {
Surface* surface = new Surface(70, 60, ' ');
drawBody(surface);
drawCockpit(surface);
drawWing(surface, true);
drawWing(surface, false);
drawSeats(surface);
drawTail(surface);
std::cout << surface->str() << std::endl;
}
void Trogdor::drawTrogdor()
{
glPushMatrix();
glTranslated(this->position.getX(), this->position.getY(), this->position.getZ());
glScalef(8, 8, 8);
glRotatef(facing, 0, 1, 0);
glPushMatrix();
drawBody();
drawTail();
drawNeckHead();
drawLegs();
drawWings();
glPopMatrix();
glPopMatrix();
}
void drawBee() {
mvstack.push(model_view);
//rotate bee
model_view *= RotateY(-10*TIME);
model_view *= Translate(0, 5, 0);
model_view *= Translate(5, .5*sin(100+TIME), 0);
model_view *= RotateY(90);
//draw bee parts
drawBody();
drawHead();
drawTail();
drawWings();
drawLegz();
model_view = mvstack.pop();
}
// Draw the Comet and all the related infos : name, circle etc... GZ: Taken from Planet.cpp 2013-11-05 and extended
void Comet::draw(StelCore* core, float maxMagLabels, const QFont& planetNameFont)
{
if (hidden)
return;
if (getEnglishName() == core->getCurrentLocation().planetName)
{ // GZ moved this up. Maybe even don't do that? E.g., draw tail while riding the comet? Decide later.
return;
}
// The CometOrbit is in fact available in userDataPtr!
CometOrbit* orbit=(CometOrbit*)userDataPtr;
Q_ASSERT(orbit);
if (!orbit->objectDateValid(core->getJDay())) return; // out of useful date range. This allows having hundreds of comet elements.
if (orbit->getUpdateTails()){
// Compute lengths and orientations from orbit object, but only if required.
// TODO: This part should possibly be moved to another thread to keep draw() free from too much computation.
Vec2f tailFactors=getComaDiameterAndTailLengthAU();
float gasTailEndRadius=qMax(tailFactors[0], 0.025f*tailFactors[1]) ; // This avoids too slim gas tails for bright comets like Hale-Bopp.
float gasparameter=gasTailEndRadius*gasTailEndRadius/(2.0f*tailFactors[1]); // parabola formula: z=r²/2p, so p=r²/2z
// The dust tail is thicker and usually shorter. The factors can be configured in the elements.
float dustparameter=gasTailEndRadius*gasTailEndRadius*dustTailWidthFactor*dustTailWidthFactor/(2.0f*dustTailLengthFactor*tailFactors[1]);
// Find valid parameters to create paraboloid vertex arrays: dustTail, gasTail.
computeParabola(gasparameter, gasTailEndRadius, -0.5f*gasparameter, gastailVertexArr, gastailTexCoordArr, gastailIndices);
// This was for a rotated straight parabola:
//computeParabola(dustparameter, 2.0f*tailFactors[0], -0.5f*dustparameter, dusttailVertexArr, dusttailTexCoordArr, dusttailIndices);
// Now we make a skewed parabola. Skew factor 15 (last arg) ad-hoc/empirical. TBD later: Find physically correct solution.
computeParabola(dustparameter, dustTailWidthFactor*gasTailEndRadius, -0.5f*dustparameter, dusttailVertexArr, gastailTexCoordArr, gastailIndices, 25.0f*orbit->getVelocity().length());
// Note that we use a diameter larger than what the formula returns. A scale factor of 1.2 is ad-hoc/empirical (GZ), but may look better.
computeComa(1.0f*tailFactors[0]);
orbit->setUpdateTails(false); // don't update until position has been recalculated elsewhere
}
Mat4d mat = Mat4d::translation(eclipticPos) * rotLocalToParent;
/* // We can remove that - a Comet has no parent except for the sun...
PlanetP p = parent;
while (p && p->parent)
{
mat = Mat4d::translation(p->eclipticPos) * mat * p->rotLocalToParent;
p = p->parent;
}
*/
// This removed totally the Planet shaking bug!!!
StelProjector::ModelViewTranformP transfo = core->getHeliocentricEclipticModelViewTransform();
transfo->combine(mat);
// Compute the 2D position and check if in the screen
const StelProjectorP prj = core->getProjection(transfo);
float screenSz = getAngularSize(core)*M_PI/180.*prj->getPixelPerRadAtCenter();
float viewport_left = prj->getViewportPosX();
float viewport_bottom = prj->getViewportPosY();
if (prj->project(Vec3d(0), screenPos)
&& screenPos[1]>viewport_bottom - screenSz && screenPos[1] < viewport_bottom + prj->getViewportHeight()+screenSz
&& screenPos[0]>viewport_left - screenSz && screenPos[0] < viewport_left + prj->getViewportWidth() + screenSz)
{
// Draw the name, and the circle if it's not too close from the body it's turning around
// this prevents name overlapping (ie for jupiter satellites)
float ang_dist = 300.f*atan(getEclipticPos().length()/getEquinoxEquatorialPos(core).length())/core->getMovementMgr()->getCurrentFov();
// if (ang_dist==0.f) ang_dist = 1.f; // if ang_dist == 0, the Planet is sun.. --> GZ: we can remove it.
// by putting here, only draw orbit if Comet is visible for clarity
drawOrbit(core); // TODO - fade in here also...
if (flagLabels && ang_dist>0.25 && maxMagLabels>getVMagnitude(core))
{
labelsFader=true;
}
else
{
labelsFader=false;
}
drawHints(core, planetNameFont);
draw3dModel(core,transfo,screenSz);
}
// tails should also be drawn if core is off-screen...
drawTail(core,transfo,true); // gas tail
drawTail(core,transfo,false); // dust tail
//Coma: this is just a fan disk tilted towards the observer;-)
drawComa(core, transfo);
return;
}
// We are going to override (is that the right word?) the draw()
// method of ModelerView to draw out SampleModel
void SampleModel::draw()
{
// This call takes care of a lot of the nasty projection
// matrix stuff. Unless you want to fudge directly with the
// projection matrix, don't bother with this ...
ModelerView::draw();
/*************************************************
**
** NOW SAVE THE CURRENT MODELVIEW MATRIX
**
** At this point in execution, the MODELVIEW matrix contains
** ONLY the camera transformation. We need to save this camera
** transformation so that we can use it later (for reasons
** explained below).
**
*****************************************************/
cameraMatrix = getModelViewMatrix();
// draw the sample model
setAmbientColor(.1f, .1f, .1f);
//glPushMatrix();
//glPopMatrix();
glPushMatrix(); // push identity
glTranslated(VAL(XPOS), VAL(YPOS), VAL(ZPOS)); // values set by the sliders
if (VAL(NINJATURTLE))
setDiffuseColor(COLOR_GREEN);
else
setDiffuseColor(.940f, .816f, .811f);
if (animate)
glRotated(animHeadAngle, 0.0, 1.0, 0.0);
if (VAL(EYEBANDANA))
drawEyeBandana();
if (!VAL(NINJATURTLE))
setDiffuseColor(.940f, .816f, .811f);
drawHead();
if (!VAL(NINJATURTLE)) {
setDiffuseColor(0, 0, 0);
drawFace();
setDiffuseColor(.940f, .816f, .811f);
drawNeck();
}
drawUpperTorso();
drawLowerTorso();
if (!VAL(NINJATURTLE))
setDiffuseColor(.940f, .816f, .811f);
drawRightHandJoint();
glPushMatrix();
if (animate)
glRotated(animUpperArmAngle, 1.0, 0, 0);
drawUpperRightHand();
drawLowerRightHand();
drawRightHand();
glPopMatrix();
drawLeftHandJoint();
glPushMatrix();
if (animate)
glRotated(-animUpperArmAngle, 1.0, 0, 0);
drawUpperLeftHand();
drawLowerLeftHand();
drawLeftHand();
glPopMatrix();
drawRightLegJoint();
drawLeftLegJoint();
drawUpperRightLeg();
drawLowerRightLeg();
drawRightFoot();
drawUpperLeftLeg();
drawLowerLeftLeg();
drawLeftFoot();
if (VAL(NINJATURTLE))
drawShell();
else
drawTail(); // handle the positioning and hierachical modeling of the tail
if (VAL(METABALLSKIN)) {
MetaBalls mb;
mb.setUpGrid();
mb.setUpMetaballs();
mb.evalScalarField();
mb.draw();
}
glPopMatrix();
/***********************************************
**
** NOW WE WILL ACTUALLY BEGIN DRAWING THE MODEL
**
** Draw your model up to the node where you would like
** particles to spawn from.
**
** FYI: As you call glRotate, glScale, or glTranslate,
** OpenGL is multiplying new transformations into the
** MODELVIEW matrix.
**
********************************************/
// If particle system exists, draw it
ParticleSystem *ps = ModelerApplication::Instance()->GetParticleSystem();
if (ps != NULL) {
ps->computeForcesAndUpdateParticles(t);
ps->drawParticles(t, m_camera);
}
/*************************************************
**
** NOW DO ANY CLOSING CODE
**
** Don't forget that animator requires you to call
** endDraw().
**
**************************************************/
endDraw();
}
void glutDisplay() {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
loadGlobalCoord();
glShadeModel(GL_SMOOTH);
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
glEnable(GL_DEPTH_TEST);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glLightfv(GL_LIGHT0, GL_AMBIENT, AMBIENT_LIGHT);
glLightfv(GL_LIGHT0, GL_DIFFUSE, DIFFUSE_LIGHT);
glLightfv(GL_LIGHT0, GL_SPECULAR, SPECULAR_LIGHT);
glLightfv(GL_LIGHT0, GL_POSITION, LIGHT_POSITION);
glEnable(GL_LIGHT1);
glLightfv(GL_LIGHT1, GL_AMBIENT, AMBIENT_SUB_LIGHT);
glLightfv(GL_LIGHT1, GL_DIFFUSE, DIFFUSE_SUB_LIGHT);
glLightfv(GL_LIGHT1, GL_SPECULAR, SPECULAR_LIGHT);
glLightfv(GL_LIGHT1, GL_POSITION, SUB_LIGHT_POSITION);
glEnable(GL_COLOR_MATERIAL);
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, MATERIAL_AMBIENT);
glMaterialfv(GL_FRONT, GL_SPECULAR, MATERIAL_SPECULAR);
glMateriali(GL_FRONT, GL_SHININESS, 48);
glTranslatef(0, 0, baseTrans);
glRotatef(bodyRot, 0, 0, 1);
glRotatef(90.0f, 1, 0, 0);
glColor3f(1.0, 1.0, 0); // Yellow color
GLUquadricObj* body = gluNewQuadric();
gluCylinder(body, 5.5, 7.0, 17, 100, 10);
gluDeleteQuadric(body);
glPushMatrix();
drawLeftArm();
glPopMatrix();
glPushMatrix();
drawRightArm();
glPopMatrix();
glPushMatrix();
drawLeftLeg();
glPopMatrix();
glPushMatrix();
drawRightLeg();
glPopMatrix();
glPushMatrix();
drawTail();
glPushMatrix();
drawBall();
glPopMatrix();
glPopMatrix();
glPushMatrix();
drawHead();
glPushMatrix();
drawLeftEye();
glPopMatrix();
glPushMatrix();
drawRightEye();
glPopMatrix();
glPushMatrix();
drawLeftCheek();
glPopMatrix();
glPushMatrix();
drawRightCheek();
glPopMatrix();
glPushMatrix();
drawMouse();
glPopMatrix();
glPushMatrix();
drawLeftEar();
glPopMatrix();
glPushMatrix();
drawRightEar();
glPopMatrix();
glPopMatrix();
glutSwapBuffers();
}
