Example #1
0
static void drawPrismColor(GLdouble radius,V3d Base1Pos,V3d Base2Pos, V4d Specular,V4d Diffuse,V4d Ambiant)
{
	glMaterialdv(GL_FRONT_AND_BACK,GL_SPECULAR,Specular);
	glMaterialdv(GL_FRONT_AND_BACK,GL_DIFFUSE,Diffuse);
	glMaterialdv(GL_FRONT_AND_BACK,GL_AMBIENT,Ambiant);
	glMateriali(GL_FRONT_AND_BACK,GL_SHININESS,50);
	drawPrism(radius,Base1Pos,Base2Pos);
}
Example #2
0
/*
 =======================================================================================================================
    draws a chair with one of two textures
 =======================================================================================================================
 */
void chair()
{
	/*~~~~~~~~~~~~~~~~~~~~~~*/
	static int	texChoose = 0;
	/*~~~~~~~~~~~~~~~~~~~~~~*/

	setMaterial(finDefault);
	if(texChoose % 2)
		glBindTexture(GL_TEXTURE_2D, texture[0]);
	else
		glBindTexture(GL_TEXTURE_2D, texture[2]);
	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
	glEnable(GL_TEXTURE_2D);
	glBegin(GL_QUADS);

	/*~~~~~~~~~~~~~~~~~~~~~*/
	float	legheight = 0.75;
	float	dist = 0.5;
	float	legfat = 0.1;
	float	seat = 0.1;
	float	seatback = 0.9;
	/*~~~~~~~~~~~~~~~~~~~~~*/

	drawPrism(0.0, 0.0, 0.0, legheight, legfat, legfat);
	drawPrism(dist, 0.0, 0.0, legheight, legfat, legfat);
	drawPrism(0.0, dist, 0.0, legheight, legfat, legfat);
	drawPrism(dist, dist, 0.0, legheight, legfat, legfat);
	drawPrism(0, 0, legheight, seat, dist + legfat, dist + legfat);
	drawPrism(0, 0, legheight + seat, seatback, dist + legfat, legfat);
	glEnd();
	glDisable(GL_TEXTURE_2D);
	texChoose++;
}
Example #3
0
void drawLoad(TString infile="../build/hits.root"){
  gStyle->SetOptStat(0);
  fSavePath = "load";
  
  PrtInit(infile,0); //digi
  
  TH2F* hHits = new TH2F("hHits",";x, [mm];y, [mm]",500,-40,350,500,-100,100);
  Int_t angle(0), step(0);
  Double_t test(0);
  PrtHit fHit;
  for (Int_t ievent=0; ievent<fCh->GetEntries(); ievent++){
    PrtNextEvent(ievent,1000);
    if(ievent==0){
      angle = fEvent->GetAngle() + 0.01;
      test = fEvent->GetTest1();
      fInfo +=  fEvent->PrintInfo();
    }
    for(Int_t h=0; h<fEvent->GetHitSize(); h++){
      fHit = fEvent->GetHit(h);
      Int_t mcpid = fHit.GetMcpId();
      Int_t pixid = fHit.GetPixelId()-1;
      TVector3 pos = fHit.GetGlobalPos();
      
      Double_t time = fHit.GetLeadTime();
      hHits->Fill(pos.X(),pos.Y());
    }
  }
  
  canvasAdd(Form("load_%d",angle),800,500);
  hHits->SetStats(0);
  hHits->GetXaxis()->SetTitleOffset(0.85);
  hHits->GetYaxis()->SetTitleOffset(0.85);
  hHits->GetXaxis()->SetTitleSize(0.05);
  hHits->GetYaxis()->SetTitleSize(0.05);
  //hHits->SetTitle(Form("#theta_{track} = %d#circ",angle));
  hHits->Draw("colz");
  drawPrism(prismShift,0);
  canvasSave(1,0);
}
Example #4
0
void pgDrawFoot() {
    drawPrism(1.25, 0.2);
}
Example #5
0
void LevelEditor::draw(GLboolean simplifyForPicking)
{
    // Calcolo nuovo Frame

    if (!simplifyForPicking)
    {
       QList<int> actions = currentActions->getAllActions();

        while (!actions.isEmpty())
        {
            GLint step = actions.takeFirst();
            switch (step)
            {
            // Primary Actions

            case INITIAL_MOVEMENT:
                if (cameraOffset->y < 0.0f)
                {
                    cameraOffset->y += 2.0f;
                }
                else
                {
                    currentActions->setPrimaryAction(DO_NOTHING);
                    isMoving = false;
                }

                break;

            case GO_TO_SET_NAME_VIEW:
                if(currentView == SET_PARAM_VIEW)
                {
                    cameraOffset->x -= 0.5f;
                    cameraAngle -= 6.0f;
                    if(cameraOffset->x == -30.0f)
                    {
                        currentView = SET_NAME_VIEW;
                        currentActions->setPrimaryAction(DO_NOTHING);
                        isMoving = false;
                        cameraAngle = 0.0f;
                    }
                }

                break;

            case GO_TO_SET_PARAM_VIEW:
                if (currentView == SET_NAME_VIEW)
                {
                    cameraOffset->x += 0.5f;
                    cameraAngle += 6.0f;

                    if (cameraOffset->x == 0.0f)
                    {
                        currentView = SET_PARAM_VIEW;
                        currentActions->setPrimaryAction(DO_NOTHING);
                        isMoving = false;
                        cameraAngle = 0.0f;
                    }
                }
                else if (currentView == SET_GRAVITY_VIEW)
                {
                    cameraOffset->x -= 0.5f;
                    cameraAngle -= 6.0f;

                    if (cameraOffset->x == 0.0f)
                    {
                        currentView = SET_PARAM_VIEW;
                        currentActions->setPrimaryAction(DO_NOTHING);
                        isMoving = false;
                        cameraAngle = 0.0f;
                    }
                }

                break;

            case GO_TO_SET_GRAVITY_VIEW:
                cameraOffset->x += 0.5f;
                cameraAngle += 6.0f;

                if (cameraOffset->x == 30.0f)
                {
                    currentView = SET_GRAVITY_VIEW;
                    currentActions->setPrimaryAction(DO_NOTHING);
                    isMoving = false;
                    cameraAngle = 0.0f;
                }

                break;

             case GO_TO_EDITING_LEVEL_VIEW:
                cameraOffset->x += 2.0f;

                if (cameraOffset->x == 60.0f)
                {
                    currentView = EDITING_LEVEL_VIEW;
                    emit setMouseMovementTracking(MOUSE_MOVED_DOWN);
                }
                else if (cameraOffset->x == 90.0f)
                {
                    currentActions->setPrimaryAction(DO_NOTHING);
                    isMoving = false;
                }

                break;

            case EXIT_TO_MENU:
                cameraOffset->x += (currentView == EDITING_LEVEL_VIEW) ? 2.0f : 5.0f;

                if (cameraOffset->x == 150.0f)
                {
                    currentActions->setPrimaryAction(DO_NOTHING);
                    isMoving = false;
                    emit levelEditorClosed();
                    return;
                }

                break;

            // Secondary Actions

            case ROTATE_VOLUMECUBE:
                angleRotVolumeCube += 5.0f;

                if ((GLint(angleRotVolumeCube) % 360) == 0)
                    angleRotVolumeCube = 0.0f;

                if ((GLint(angleRotVolumeCube) % 90) == 0)
                    currentActions->removeSecondaryAction(ROTATE_VOLUMECUBE);

                break;
            }
        }
    }

    // Disegno l' editor

    if (!(isMoving && simplifyForPicking))
    {
        dynamic_cast<QGLWidget*>(parent)->renderText(-currentError.length()*0.1225f, -6.0f, 0.0, currentError);

        glPushName(BUTTON_VOLUME);
        glPushMatrix();
            glTranslatef(9.5f, 6.0f, 3.0f);
            glRotatef(angleRotVolumeCube, -1.0f, 0.0f, 0.0f);
            drawPrism(0.8f, 0.8f, 0.8f, volumeSkin, true);
        glPopMatrix();
        glPopName();

        glTranslatef(-cameraOffset->x, -cameraOffset->y, -cameraOffset->z);
        glRotatef(cameraAngle, 0.0f, 0.0f, 1.0f);

        glPushMatrix();

        if(currentView == EDITING_LEVEL_VIEW)
        {
            glPushMatrix();

                glTranslatef(90.0f, 0.0f, 0.0f);

                glPushMatrix();
                    glTranslatef(7.0f, 4.0f, 3.0f);
                    save->draw(simplifyForPicking);
                    glTranslatef(0.0f, -1.5f, 0.0f);
                    cancel->draw(simplifyForPicking);
                    glTranslatef(0.0f, -1.5f, 0.0f);
                    clear->draw(simplifyForPicking);
                    glTranslatef(0.0f, -1.5f, 0.0f);
                    exit->draw(simplifyForPicking);
                glPopMatrix();

                glPushMatrix();

                    glTranslatef(levelOffset->x, levelOffset->y, levelOffset->z);
                    glScalef(0.4f, 0.4f, 0.4f);
                    level->draw(simplifyForPicking);

                glPopMatrix();

                glScalef(0.4f, 0.4f, 0.4f);
                glTranslatef(-25.0f, 15.0f, 0.0f);

                glPushMatrix();
                if (movingObject == 0)
                {
                    glTranslatef(currentDelta.x, currentDelta.y, currentDelta.z);
                    setMaterialColor(positionValid ? COLOR_GREEN : COLOR_RED);
                }
                else
                {
                    setMaterialColor(COLOR_DISABLED);
                }

                glPushName(OBSTACLE_0);
                drawObstacle(0);
                glPopName();
                glPopMatrix();

                glTranslatef(0.0f, -7.0f, 0.0f);

                glPushMatrix();
                if (movingObject == 1)
                {
                    glTranslatef(currentDelta.x, currentDelta.y, currentDelta.z);
                    setMaterialColor(positionValid ? COLOR_GREEN : COLOR_RED);
                }
                else
                {
                    setMaterialColor(COLOR_DISABLED);
                }

                glPushName(OBSTACLE_1);
                drawObstacle(1);
                glPopName();
                glPopMatrix();

                if (currentWidth >= 6)
                {
                    glTranslatef(0.0f, -7.0f, 0.0f);

                    glPushMatrix();
                    if (movingObject == 2)
                    {
                        glTranslatef(currentDelta.x, currentDelta.y, currentDelta.z);
                        setMaterialColor(positionValid ? COLOR_GREEN : COLOR_RED);
                    }
                    else
                    {
                        setMaterialColor(COLOR_DISABLED);
                    }

                    glPushName(OBSTACLE_2);
                    drawObstacle(2);
                    glPopName();
                    glPopMatrix();

                    glTranslatef(0.0f, -7.0f, 0.0f);

                    glPushMatrix();
                    if (movingObject == 3)
                    {
                        glTranslatef(currentDelta.x, currentDelta.y, currentDelta.z);
                        setMaterialColor(positionValid ? COLOR_GREEN : COLOR_RED);
                    }
                    else
                    {
                        setMaterialColor(COLOR_DISABLED);
                    }

                    glPushName(OBSTACLE_3);
                    drawObstacle(3);
                    glPopName();
                    glPopMatrix();
                }

            glPopMatrix();
            setMaterialColor(COLOR_DISABLED);
        }
        else
        {
            // Set Name View
            glPushMatrix();

                glTranslatef(-30.0f, 6.0f, 0.0f);
                labelSetLevelName->draw(simplifyForPicking);

                glTranslatef(8.5f, -13.0f, 0.0f);
                next->draw(simplifyForPicking);

                glTranslatef(-17.0f, 0.0f, 0.0f);
                menu->draw(simplifyForPicking);

                glTranslatef(8.5f, 6.5f, 0.0f);

                if (!simplifyForPicking)
                {
                    if (formSetLevelName->getLabel(0) == "" && visible)
                    {
                        visibleTime++;
                        drawPrism(2.0f, 2.0f, 2.0f);
                        if(visibleTime == 20)
                            visible = false;
                    }
                    else if (formSetLevelName->getLabel(0) == "" && !visible)
                    {
                        visibleTime++;
                        if(visibleTime == 33)
                        {
                            visibleTime = 0;
                            visible = true;
                        }
                    }
                    else
                    {
                        formSetLevelName->draw(simplifyForPicking);
                    }
                }

            glPopMatrix();

            // Set Parameters View

            glPushMatrix();

                glTranslatef(9.0f, -7.0f, 0.0f);
                next->draw(simplifyForPicking);

                glTranslatef(-18.5f, 0.0f, 0.0f);
                back->draw(simplifyForPicking);

                glTranslatef(3.5f, 11.5f, 0.0f);
                lengthString->draw(simplifyForPicking);

                glTranslatef(12.0f, 0.0f, 0.0f);
                widthString->draw(simplifyForPicking);

                glTranslatef(-12.0f, -2.5f, 1.5f);
                glPushName(BUTTON_LENGTHEN);
                glBegin(GL_TRIANGLES);
                    glVertex3f( 0.0f,  1.0f,  0.0f);
                    glVertex3f( 1.0f, -1.0f,  0.0f);
                    glVertex3f(-1.0f, -1.0f,  0.0f);
                glEnd();
                glPopName();

                glTranslatef(0.0f, -3.5f, -1.5f);
                lengthLabel->draw(simplifyForPicking);

                glTranslatef(7.0f, 0.0f, 1.5f);
                glPushName(BUTTON_REDUCE);
                glBegin(GL_TRIANGLES);
                    glVertex3f(-1.0f,  0.0f,  0.0f);
                    glVertex3f( 1.0f,  1.0f,  0.0f);
                    glVertex3f( 1.0f, -1.0f,  0.0f);
                glEnd();
                glPopName();

                glTranslatef(4.5f, 0.0f, -1.5f);
                widthLabel->draw(simplifyForPicking);

                glTranslatef(4.5f, 0.0f, 1.5f);
                glPushName(BUTTON_ENLARGE);
                glBegin(GL_TRIANGLES);
                    glVertex3f( 1.0f,  0.0f,  0.0f);
                    glVertex3f(-1.0f,  1.0f,  0.0f);
                    glVertex3f(-1.0f, -1.0f,  0.0f);
                glEnd();
                glPopName();

                glTranslatef(-16.0f, -3.5f, 0.0f);
                glPushName(BUTTON_SHORTEN);
                glBegin(GL_TRIANGLES);
                    glVertex3f(-1.0f,  1.0f,  0.0f);
                    glVertex3f( 1.0f,  1.0f,  0.0f);
                    glVertex3f( 0.0f, -1.0f,  0.0f);
                glEnd();
                glPopName();

            glPopMatrix();

            // Set Gravity

            glPushMatrix();

                glTranslatef(30.0f, 4.0f, 0.0f);
                gravityString->draw(simplifyForPicking);

                glTranslatef(0.0f, -4.0f, 0.0f);
                gravityLabel->draw(simplifyForPicking);

                glTranslatef(+6.0f, 0.0f, 0.0f);
                glPushName(BUTTON_GRAVITY_PLUS);
                glBegin(GL_TRIANGLES);
                    glVertex3f( 1.0f,  0.0f,  0.0f);
                    glVertex3f(-1.0f,  1.0f,  0.0f);
                    glVertex3f(-1.0f, -1.0f,  0.0f);
                glEnd();
                glPopName();

                glTranslatef(-12.0f, 0.0f, 0.0f);
                glPushName(BUTTON_GRAVITY_MINUS);
                glBegin(GL_TRIANGLES);
                    glVertex3f(-1.0f,  0.0f,  0.0f);
                    glVertex3f( 1.0f,  1.0f,  0.0f);
                    glVertex3f( 1.0f, -1.0f,  0.0f);
                glEnd();
                glPopName();

                glTranslatef(-2.0f, -7.0f, 0.0f);

                if (level == NULL)
                    back->draw(simplifyForPicking);

                glTranslatef(15.0f, -0.0f, 0.0f);
                create->draw(simplifyForPicking);

            glPopMatrix();

        }
        glPopMatrix();
    }
}