示例#1
0
void Loop(){
	mat4 ModelMatrix(1.0f);
	float bgColor[] = { 0.2f, 0.4f, 0.5f };
	
	do{
		glClearColor(bgColor[0], bgColor[1], bgColor[2], 1);
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

		g_mutex.lock();
		drawHands();
		g_mutex.unlock();
		
		g_text.printText2D(info, 30, 30, 15, 0);
		g_text.printText2D(counter, 370, 500, 100, 0);

		if (g_leapListener.saved){
			int i = next_gesture_id - 1;
			printf("next = %d\ni = %d\n", next_gesture_id, i);
			
			char visible[] = "true";

			std::string varname;
			varname.append(std::to_string(i + 1));
			varname.append(" - Name:");
			TwSetParam(bar2, varname.c_str(), "visible", TW_PARAM_CSTRING, 1, visible);

			varname.clear();
			varname.append(std::to_string(i + 1));
			varname.append(" - ID:");
			TwSetParam(bar2, varname.c_str(), "visible", TW_PARAM_CSTRING, 1, visible);

			varname.clear();
			varname.append(std::to_string(i + 1));
			varname.append(" - Hands:");
			TwSetParam(bar2, varname.c_str(), "visible", TW_PARAM_CSTRING, 1, visible);

			varname.clear();
			varname.append(std::to_string(i + 1));
			varname.append(" - Fingers:");
			TwSetParam(bar2, varname.c_str(), "visible", TW_PARAM_CSTRING, 1, visible);

			varname.clear();
			varname.append(std::to_string(i + 1));
			varname.append(" - sep:");
			TwSetParam(bar2, varname.c_str(), "visible", TW_PARAM_CSTRING, 1, visible);
			
			g_leapListener.saved = false;

		}

		TwDraw();

		glfwSwapBuffers();
	} while (glfwGetKey(GLFW_KEY_ESC) != GLFW_PRESS &&
		glfwGetWindowParam(GLFW_OPENED));
}
示例#2
0
glm::mat4 TransformSystem::ModelMatrix(EntityID entityID, World* world)
{
    return ModelMatrix(EntityWrapper(world, entityID));
}
示例#3
0
void eGrid::Render( eCamera* cam, int viewer, REAL& zNear ){
    if (!sr_glOut)
        return;
#ifndef DEDICATED
    ProjMatrix();

    z=cam->CameraZ();
    if ( zNear > z )
    {
        zNear = z;
    }

	if (sr_floorMirror){
		ModelMatrix();
		glScalef(1,1,-1);

		if (z>10) z=10;
		glFrontFace((cam->MirrorView())?GL_CCW:GL_CW);

		bool us=false;
		bool ls=false;

		if (sr_floorMirror>=rMIRROR_ALL){
			us=sr_upperSky;
			ls=sr_lowerSky;
		}
		else if (sr_floorMirror>=rMIRROR_WALLS){
			if (sr_lowerSky)
				ls=true;
			else if (sr_upperSky)
				us=true;
		}

		cam->SetRenderingMain(false && cam->CameraMain());
		display_simple(cam, viewer,false,
					   us,ls,
					   0,
					   sr_floorMirror>=rMIRROR_WALLS,
					   sr_floorMirror>=rMIRROR_OBJECTS,
					   zNear);
		z=cam->CameraZ();
		glFrontFace((cam->MirrorView())?GL_CW:GL_CCW);
		ModelMatrix();
		glScalef(1,1,-1);


		cam->SetRenderingMain(true && cam->CameraMain());
		display_simple(cam, viewer,true,
					   sr_upperSky,sr_lowerSky,
					   1-sr_floorMirror_strength,
					   true,true,zNear);

	}
	else
	{
		glFrontFace((cam->MirrorView())?GL_CW:GL_CCW);
		cam->SetRenderingMain(true && cam->CameraMain());
		display_simple(cam, viewer,true,
					   sr_upperSky,sr_lowerSky,
					   1,
					   true,true,zNear);
	}
	
#ifdef EVENT_DEB
    //  for(int i=eEdge_crossing.Len()-1;i>=0;i--){
    //    eEdge_crossing(i)->Render();
    //  }
#endif
#endif
}
示例#4
0
void eGrid::display_simple( eCamera* cam, int viewer,bool floor,
                            bool sr_upperSky,bool sr_lowerSky,
                            REAL flooralpha,
                            bool eWalls,bool gameObjects,
                            REAL& zNear){
    sr_CheckGLError();

    /*
    static GLfloat S[]={1,0,0,0};
    static GLfloat T[]={0,1,0,0};
    static GLfloat R[]={0,0,1,0};
    static GLfloat Q[]={0,0,0,1};

    glTexGeni(GL_S,GL_TEXTURE_GEN_MODE,GL_OBJECT_LINEAR);
    glTexGenfv(GL_S,GL_OBJECT_PLANE,S);

    glTexGeni(GL_T,GL_TEXTURE_GEN_MODE,GL_OBJECT_LINEAR);
    glTexGenfv(GL_T,GL_OBJECT_PLANE,T);

    glTexGeni(GL_R,GL_TEXTURE_GEN_MODE,GL_OBJECT_LINEAR);
    glTexGenfv(GL_R,GL_OBJECT_PLANE,R);

    glTexGeni(GL_Q,GL_TEXTURE_GEN_MODE,GL_OBJECT_LINEAR);
    glTexGenfv(GL_Q,GL_OBJECT_PLANE,Q);

    glDisable(GL_TEXTURE_GEN_T);
    glDisable(GL_TEXTURE_GEN_S);
    glDisable(GL_TEXTURE_GEN_R);
    glDisable(GL_TEXTURE_GEN_Q);
    */


    glDisable(GL_DEPTH_TEST);
    glDepthMask(GL_FALSE);

    glDisable(GL_CULL_FACE);

    eCoord camPos = cam->CameraGlancePos(); 
    // eWallRim::Bound( camPos, 10 );

    if (sr_upperSky || se_BlackSky()){
        if (se_BlackSky()){
            //glDisable(GL_TEXTURE);
            glDisable(GL_TEXTURE_2D);

            glColor3f(0,0,0);

            if ( z < lower_height )
                infinity_xy_plane(cam->CameraPos(), cam->CameraDir(), lower_height);

            glEnable(GL_TEXTURE_2D);
        }
        else {
            TexMatrix();
            glLoadIdentity();
            //      glScalef(.25,.25,.25);

            se_glFloorTexture();

            glColor3f(.5,.5,1);

            if ( z < upper_height )
                infinity_xy_plane(cam->CameraPos(), cam->CameraDir(), upper_height);
        }
    }

    if (sr_lowerSky && !sr_highRim){
        paint_sr_lowerSky(this, viewer,sr_upperSky, cam);
    }

    if (floor){
        sr_DepthOffset(false);

        su_FetchAndStoreSDLInput();
        int floorDetail = sr_floorDetail;

        // no multitexturing without alpha blending
        if ( !sr_alphaBlend && floorDetail > rFLOOR_TEXTURE )
            floorDetail = rFLOOR_TEXTURE;

        switch(floorDetail){
        case rFLOOR_OFF:
            break;
        case rFLOOR_GRID:
            {
	#define SIDELEN   (se_GridSize())
	#define EXTENSION 10

                eCoord center = cam->CameraPos() + cam->CameraDir() * (SIDELEN * EXTENSION * .8);

                REAL x=center.x;
                REAL y=center.y;
                int xn=static_cast<int>(x/SIDELEN);
                int yn=static_cast<int>(y/SIDELEN);


                //glDisable(GL_TEXTURE);
                glDisable(GL_TEXTURE_2D);

	#define INTENSITY(x,xx) (1-(((x)-(xx))*((x)-(xx))/(EXTENSION*SIDELEN*EXTENSION*SIDELEN)))


                BeginLines();
                for(int i=xn-EXTENSION;i<=xn+EXTENSION;i++){
                    REAL intens=INTENSITY(i*SIDELEN,x);
                    if (intens<0) intens=0;
                    se_glFloorColor(intens,intens);
                    glVertex2f(i*SIDELEN,y-SIDELEN*(EXTENSION+1));
                    glVertex2f(i*SIDELEN,y+SIDELEN*(EXTENSION+1));
                }
                for(int j=yn-EXTENSION;j<=yn+EXTENSION;j++){
                    REAL intens=INTENSITY(j*SIDELEN,y);
                    if (intens<0) intens=0;
                    se_glFloorColor(intens,intens);
                    glVertex2f(x-(EXTENSION+1)*SIDELEN,j*SIDELEN);
                    glVertex2f(x+(EXTENSION+1)*SIDELEN,j*SIDELEN);
                }
                RenderEnd();
            }
            break;

        case rFLOOR_TEXTURE:
            TexMatrix();
            glLoadIdentity();
            glScalef(1/se_GridSize(),1/se_GridSize(),1.);

            se_glFloorTexture();
            se_glFloorColor(flooralpha);

            infinity_xy_plane( cam->CameraPos(), cam->CameraDir()); 

            /* old way: draw every triangle
            for(int i=eFace::faces.Len()-1;i>=0;i--){
            eFace *f=eFace::faces(i);

            if (f->visHeight[viewer]<z){
            glBegin(GL_TRIANGLES);
            for(int j=0;j<=2;j++){
            glVertex3f(f->p[j]->x,f->p[j]->y,0);
            }
            glEnd();
            }
            }
            */

            break;

        case rFLOOR_TWOTEXTURE:
            se_glFloorColor(flooralpha);

            TexMatrix();
            glLoadIdentity();
            REAL gs = 1/se_GridSize();
            glScalef(0.01*gs,gs,1.);

            se_glFloorTexture_a();
            infinity_xy_plane( cam->CameraPos(), cam->CameraDir()); 

            se_glFloorColor(flooralpha);

            TexMatrix();
            glLoadIdentity();
            glScalef(gs,.01*gs,1.);

            se_glFloorTexture_b();

            glDepthFunc(GL_LEQUAL);
            glBlendFunc(GL_SRC_ALPHA,GL_ONE);
            infinity_xy_plane( cam->CameraPos(), cam->CameraDir() );
            glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);

            break;
        }
    }

    glEnable(GL_DEPTH_TEST);
    glDepthMask(GL_TRUE);
	
    TexMatrix();
    glLoadIdentity();
    ModelMatrix();

    //  glDisable(GL_TEXTURE_GEN_S);
    //  glDisable(GL_TEXTURE_GEN_T);
    //  glDisable(GL_TEXTURE_GEN_Q);
    //  glDisable(GL_TEXTURE_GEN_R);

    if(eWalls){
        {
            su_FetchAndStoreSDLInput();
    
            eWallRim::RenderAll( cam );
        }

        if (sr_lowerSky && sr_highRim){
            //      glEnable(GL_TEXTURE_GEN_S);
            //      glEnable(GL_TEXTURE_GEN_T);
            //      glEnable(GL_TEXTURE_GEN_Q);
            //      glEnable(GL_TEXTURE_GEN_R);

            paint_sr_lowerSky(this, viewer,sr_upperSky, cam);

            //      glDisable(GL_TEXTURE_GEN_S);
            //      glDisable(GL_TEXTURE_GEN_T);
            //      glDisable(GL_TEXTURE_GEN_Q);
            //      glDisable(GL_TEXTURE_GEN_R);

            TexMatrix();
            glLoadIdentity();
            ModelMatrix();
        }
    }

    sr_CheckGLError();

    if (eWalls){
        // glDisable(GL_CULL_FACE);
        // draw_eWall(this,viewer,0,zNear,cam);

        /*
        #ifdef DEBUG
        for(int i=sg_netPlayerWalls.Len()-1;i>=0;i--){
          glMatrixMode(GL_MODELVIEW);
          glPushMatrix();
          if (sg_netPlayerWalls(i)->Preliminary())
        glTranslatef(0,0,4);
          else
        glTranslatef(0,0,8);
          if (sg_netPlayerWalls(i)->Wall())
        sg_netPlayerWalls(i)->Wall()->RenderList(false);
          glPopMatrix();
          }
        #endif
        */

        /*
        static int oldlen=0;
        int newlen=sg_netPlayerWalls.Len();
        if (newlen!=oldlen){
          con << "Number of player eWalls now " << newlen << '\n';
          oldlen=newlen;
        }
        */

    }

    sr_CheckGLError();

    if (gameObjects)
        eGameObject::RenderAll(this, cam);

    eDebugLine::Render();
#ifdef DEBUG

    ePath::RenderLast();

    if (debug_grid){
        //glDisable(GL_TEXTURE);
        glDisable(GL_TEXTURE_2D);
        glDisable(GL_LIGHTING);
        BeginLines();

        int i;
        for(i=edges.Len()-1;i>=0;i--){
            eHalfEdge *e=edges[i];
            if (e->Face())
                glColor4f(1,1,1,1);
            else
                glColor4f(0,0,1,1);

            glVertex3f(e->Point()->x,e->Point()->y,10);
            glVertex3f(e->Point()->x,e->Point()->y,15);
            glVertex3f(e->Point()->x,e->Point()->y,.1);
            glVertex3f(e->other->Point()->x,e->other->Point()->y,.1);
            glVertex3f(e->other->Point()->x,e->other->Point()->y,10);
            glVertex3f(e->other->Point()->x,e->other->Point()->y,15);

        }

        for(i=points.Len()-1;i>=0;i--){
            ePoint *p=points[i];
            glColor4f(1,0,0,1);
            glVertex3f(p->x,p->y,0);
            glVertex3f(p->x,p->y,(p->GetRefcount()+1)*5);
        }
        /*
        for(int i=sg_netPlayerWalls.Len()-1;i>=0;i--){
          eEdge *e=sg_netPlayerWalls[i]->Edge();
        glColor4f(0,1,0,1);

          glVertex3f(e->Point()->x,e->Point()->y,5);
          glVertex3f(e->Point()->x,e->Point()->y,10);
          glVertex3f(e->Point()->x,e->Point()->y,10);
          glVertex3f(e->other->Point()->x,e->other->Point()->y,10);
          glVertex3f(e->other->Point()->x,e->other->Point()->y,10);
          glVertex3f(e->other->Point()->x,e->other->Point()->y,5);
        }
        */
        RenderEnd();
    }
#endif

}
示例#5
0
void World::Bind(unsigned int TransformationBinding)
{
	World::ModelMatrix().push(DefaultModel);
	if (World::TransformationBuffer == 0)
	{
		glGenBuffers(1, &World::TransformationBuffer);
		glBindBuffer(GL_UNIFORM_BUFFER, World::TransformationBuffer);
		glBufferData(GL_UNIFORM_BUFFER, TransformationSize, nullptr, GL_DYNAMIC_DRAW);
		glBufferSubData(GL_UNIFORM_BUFFER, ModelMatrixOffset, ModelMatrixSize, glm::value_ptr(ModelMatrix().top()));
		glBufferSubData(GL_UNIFORM_BUFFER, ViewMatrixOffset, ViewMatrixSize, &ViewMatrix);
		glBufferSubData(GL_UNIFORM_BUFFER, ProjectionMatrixOffset, ProjectionMatrixSize, &ProjectionMatrix);
		glBindBufferBase(GL_UNIFORM_BUFFER, TransformationBinding, World::TransformationBuffer);
	};
}
示例#6
0
void World::UpdateModel()
{
	if (TransformationBuffer > 0)
	{
		glBindBuffer(GL_UNIFORM_BUFFER, TransformationBuffer);
		glBufferSubData(GL_UNIFORM_BUFFER, ModelMatrixOffset, ModelMatrixSize, glm::value_ptr(ModelMatrix().top()));
	};
}
示例#7
0
void GlobalMatrices::UpdateShader()
{
	ModelMatrix()->UpdateShader("modelMat");
	ViewMatrix()->UpdateShader("viewMat");
	ProjectionMatrix()->UpdateShader("projMat");
}