void myDisplay() {
glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt(0, 30, 40, 0, 30, 0, 0, 1, 0);
LightPosition();
glDisable(GL_LIGHTING);
glLineWidth(5);
drawAxes();
static float angle = 0.0;
glRotatef(angle, 0, 1, 0);
angle += 0.5;
glLineWidth(1);
myMesh.drawMesh();
clothMesh.drawMesh();
glEnable(GL_LIGHTING);
glutSwapBuffers();
}
void myDisplay() {
glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt(0.0, 0.5, 1.5, 0, 0, 0, 0, 1, 0);
LightPosition();
glDisable(GL_LIGHTING);
glLineWidth(5);
drawAxes();
glEnable(GL_LIGHTING);
//glDisable(GL_DEPTH_TEST);
static float angle = 0.0;
glRotatef(angle, 0.0, 1.0, 0.0);
angle += 0.5;
glPushMatrix();
glTranslatef(0, 0, -0.5);
glColor4f(1, 1, 1, 0.5);
glutSolidTeapot(0.5);
glPopMatrix();
glPushMatrix();
glColor4f(0, 0, 1, 0.5);
glutSolidTeapot(0.5);
glPopMatrix();
//glEnable(GL_DEPTH_TEST);
glutSwapBuffers();
}
void Mesh::setupVBOs() {
// delete all the old geometry
mesh_tri_verts.clear();
light_vert.clear();
cleanupVBOs();
// setup the new geometry
Vec3f light_position = LightPosition();
SetupLight(light_position);
SetupMesh();
SetupPlateVisualization();
bbox.setupVBOs();
}
void myDisplay() {
glClear(GL_DEPTH_BUFFER_BIT|GL_COLOR_BUFFER_BIT);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
myCam.setGLCamera(); //gluLookAt(0.0, 2.5, 5.0, 0,0,0, 0,1,0);
LightPosition();
glDisable(GL_LIGHTING);
glLineWidth(1);
drawPlane();
glLineWidth(5);
drawAxes();
glEnable(GL_LIGHTING);
glutSolidTeapot(0.5);
glutSwapBuffers();
}
void Mesh::drawVBOs() {
// scale it so it fits in the window
Vec3f center; bbox.getCenter(center);
float s = 1/bbox.maxDim();
glScalef(s,s,s);
glTranslatef(-center.x(),-center.y(),-center.z());
// setup the light
Vec3f light_position = LightPosition();
GLfloat position[4] = { float(light_position.x()),float(light_position.y()),float(light_position.z()),1 };
glLightfv(GL_LIGHT1, GL_POSITION, position);
if (args->glsl_enabled) {
glEnable(GL_DEPTH_TEST);
glClearColor(0,0,0,1.0f);
glEnable(GL_CULL_FACE);
//glHint(GL_PERSPECTIVE_CORRECTION_HINT,GL_NICEST);
//BEGIN SHADOW FUN/////////////===================================
//First step: Render from the light POV to a FBO, story depth values only
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,fboId); //Rendering offscreen
//Using the fixed pipeline to render to the depthbuffer
glUseProgramObjectARB(0);
// In the case we render the shadowmap to a higher resolution, the viewport must be modified accordingly.
glViewport(0,0,args->width * SHADOW_MAP_RATIO,args->height* SHADOW_MAP_RATIO);
// Clear previous frame values
glClear(GL_DEPTH_BUFFER_BIT);
//Disable color rendering, we only want to write to the Z-Buffer
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
//LIGHT POSITION==========================================================================================
setupMatrices(float(light_position.x()),float(light_position.y()),float(light_position.z()),
10,10,1);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(45,args->width/args->height,1.0f,1000.0f);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt((float)light_position.x(),(float)light_position.y(),(float)light_position.z(),0,0,0,0,1,0);
// Culling switching, rendering only backface, this is done to avoid self-shadowing
glCullFace(GL_FRONT);
//===========Draw the Things===================================================================================
InsertColor(floor_color);
DrawFloor();
//startTranslate(0,0,0);
//glutSolidCube(1);
InsertColor(mesh_color);
glUseProgramObjectARB(GLCanvas::program);
glColor3b(GLbyte(240-127), GLbyte(184-127), GLbyte(0-127));
DrawMesh(table, board_tri_verts_VBO);
DrawPieces(editBoard());
//endTranslate();
glUseProgramObjectARB(0);
//=============================================================================================================
//Save modelview/projection matrice into texture7, also add a biais
setTextureMatrix();
// Now rendering from the camera POV, using the FBO to generate shadows
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,0);
glViewport(0,0,args->width,args->height);
//Enabling color write (previously disabled for light POV z-buffer rendering)
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
// Clear previous frame values
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//Using the shadow shader
glUseProgramObjectARB(GLCanvas::program);
glUniform1iARB(shadowMapUniform,7);
glActiveTextureARB(GL_TEXTURE7);
glBindTexture(GL_TEXTURE_2D,depthTextureId);
Vec3f cam_position = camera->camera_position;
Vec3f interest = camera->point_of_interest;
//CAMERA MATRIX=======================================================================================================
//setupMatrices(cam_pos[0],cam_pos[1],cam_pos[2],interest[0],interest[1],interest[2]);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(45,args->width/args->height,1.0f,1000.0f);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt((float)cam_position.x(),(float)cam_position.y(),(float)cam_position.z(),(float)interest.x(),(float)interest.y(),(float)interest.z(),0,1,0);
glCullFace(GL_BACK);
//============================Draw the things
InsertColor(floor_color);
DrawFloor();
//startTranslate(0,0,0);
//glutSolidCube(1);
InsertColor(mesh_color);
glUseProgramObjectARB(GLCanvas::program);
glColor3b(GLbyte(240-127), GLbyte(184-127), GLbyte(0-127));
DrawMesh(table, board_tri_verts_VBO);
DrawPieces(editBoard());
//endTranslate();
glUseProgramObjectARB(0);
//============================All the things
// DEBUG only. this piece of code draw the depth buffer onscreen
//*
glUseProgramObjectARB(0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-args->width/2,args->width/2,-args->height/2,args->height/2,1,20);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glColor4f(1,1,1,1);
glActiveTextureARB(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D,depthTextureId);
glEnable(GL_TEXTURE_2D);
glTranslated(0,0,-1);
glBegin(GL_QUADS);
glTexCoord2d(0,0);glVertex3f(0,0,0);
glTexCoord2d(1,0);glVertex3f(args->width/2,0,0);
glTexCoord2d(1,1);glVertex3f(args->width/2,args->width/2,0);
glTexCoord2d(0,1);glVertex3f(0,args->height/2,0);
glEnd();
glDisable(GL_TEXTURE_2D);
//*/
//glutSwapBuffers();
glDisable(GL_STENCIL_TEST);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glDepthMask(1);
//END SHADOW FUN//////////////////////////////////////////////////
}
else
{
InsertColor(floor_color);
DrawFloor();
InsertColor(mesh_color);
glColor3b(GLbyte(240-127), GLbyte(184-127), GLbyte(0-127));
DrawMesh(table, board_tri_verts_VBO);
if(args->board_control)
{
DrawControlMap();
}
DrawPieces(editBoard());
}
// -------------------------
// ADDITIONAL VISUALIZATIONS (for debugging)
glColor3f(1,1,0);
//DrawLight();
if (args->bounding_box) {
glColor3f(0,0,0);
bbox.drawVBOs();
}
HandleGLError();
}
// Renders the map
void _Map::Render(_Camera *Camera, _Stats *Stats, _Object *ClientPlayer, double BlendFactor, int RenderFlags) {
// Set lights for editor
if(!ClientPlayer) {
glm::vec4 AmbientLightEditor(1.0f, 1.0f, 1.0f, 1.0f);
Assets.Programs["pos_uv"]->AmbientLight = AmbientLightEditor;
Assets.Programs["pos_uv"]->LightPosition = glm::vec3(0, 0, 0);
Assets.Programs["pos_uv_static"]->AmbientLight = AmbientLightEditor;
}
else {
// Setup day night cycle
SetAmbientLightByClock();
// Setup lights
glm::vec3 LightPosition(glm::vec3(ClientPlayer->Position, 1) + glm::vec3(0.5f, 0.5f, 0));
glm::vec3 LightAttenuation(0.0f, 1.0f, 0.0f);
Assets.Programs["pos_uv"]->LightAttenuation = LightAttenuation;
Assets.Programs["pos_uv"]->LightPosition = LightPosition;
Assets.Programs["pos_uv"]->AmbientLight = AmbientLight;
}
// Draw background map
if(BackgroundMap) {
BackgroundMap->Clock = Clock;
BackgroundMap->SetAmbientLightByClock();
if(!ClientPlayer)
BackgroundMap->AmbientLight = glm::vec4(1.0f);
Assets.Programs["pos_uv_static"]->AmbientLight = BackgroundMap->AmbientLight;
// Get camera position
glm::vec3 DrawPosition;
Camera->GetDrawPosition(BlendFactor, DrawPosition);
DrawPosition -= BackgroundOffset;
//BackgroundOffset.z = -10.0f;
float Width = DrawPosition.z * Graphics.AspectRatio;
float Height = DrawPosition.z;
// Get render bounds of background tiles
glm::vec4 BackgroundBounds;
BackgroundBounds[0] = glm::clamp(-Width + DrawPosition.x, 0.0f, (float)BackgroundMap->Size.x);
BackgroundBounds[1] = glm::clamp(-Height + DrawPosition.y, 0.0f, (float)BackgroundMap->Size.y);
BackgroundBounds[2] = glm::clamp(Width + DrawPosition.x, 0.0f, (float)BackgroundMap->Size.x);
BackgroundBounds[3] = glm::clamp(Height + DrawPosition.y, 0.0f, (float)BackgroundMap->Size.y);
BackgroundMap->RenderLayer("pos_uv_static", BackgroundBounds, BackgroundOffset, 0, true);
BackgroundMap->RenderLayer("pos_uv_static", BackgroundBounds, BackgroundOffset, 1, true);
}
// Get render bounds
glm::vec4 Bounds = Camera->GetAABB();
Bounds[0] = glm::clamp(Bounds[0], 0.0f, (float)Size.x);
Bounds[1] = glm::clamp(Bounds[1], 0.0f, (float)Size.y);
Bounds[2] = glm::clamp(Bounds[2], 0.0f, (float)Size.x);
Bounds[3] = glm::clamp(Bounds[3], 0.0f, (float)Size.y);
// Draw layers
RenderLayer("pos_uv", Bounds, glm::vec3(0.0f), 0);
RenderLayer("pos_uv", Bounds, glm::vec3(0.0f), 1);
// Render objects
for(const auto &Object : Objects) {
Object->Render(ClientPlayer);
}
// Check for flags
if(!RenderFlags)
return;
// Draw map boundaries
if(RenderFlags & FILTER_BOUNDARY) {
Graphics.SetProgram(Assets.Programs["pos"]);
Graphics.SetVBO(VBO_NONE);
Graphics.SetColor(COLOR_RED);
Graphics.DrawRectangle(glm::vec2(-0.51f, -0.51f), glm::vec2(Size.x - 0.49f, Size.y - 0.49f));
}
// Draw zone overlays
if((RenderFlags & FILTER_ZONE)) {
Graphics.SetProgram(Assets.Programs["pos"]);
Graphics.SetVBO(VBO_NONE);
for(int j = (int)Bounds[1]; j < Bounds[3]; j++) {
for(int i = (int)Bounds[0]; i < Bounds[2]; i++) {
_Tile *Tile = &Tiles[i][j];
// Draw zone color
if(!Tile->Wall && Tile->Zone > 0) {
Graphics.SetColor(ZoneColors[Tile->Zone % 6]);
Graphics.DrawRectangle(glm::vec2(i, j), glm::vec2(i, j), true);
}
}
}
}
// Draw text overlay
for(int j = (int)Bounds[1]; j < Bounds[3]; j++) {
for(int i = (int)Bounds[0]; i < Bounds[2]; i++) {
_Tile *Tile = &Tiles[i][j];
glm::vec3 DrawPosition = glm::vec3(i, j, 0) + glm::vec3(0.5f, 0.5f, 0);
// Draw wall
if(Tile->Wall) {
if(RenderFlags & FILTER_WALL)
Assets.Fonts["hud_medium"]->DrawText("W", glm::vec2(DrawPosition), COLOR_WHITE, CENTER_MIDDLE, 1.0f / 64.0f);
}
else {
// Draw zone number
if((RenderFlags & FILTER_ZONE) && Tile->Zone > 0)
Assets.Fonts["hud_medium"]->DrawText(std::to_string(Tile->Zone).c_str(), glm::vec2(DrawPosition), COLOR_WHITE, CENTER_MIDDLE, 1.0f / 64.0f);
// Draw PVP
if((RenderFlags & FILTER_PVP) && Tile->PVP)
Assets.Fonts["hud_medium"]->DrawText("PVP", glm::vec2(DrawPosition), COLOR_RED, CENTER_MIDDLE, 1.0f / 64.0f);
}
// Draw event info
if(Tile->Event.Type > 0) {
std::string EventText = Stats->EventNames[Tile->Event.Type].ShortName + std::string(" ") + std::to_string(Tile->Event.Data);
Assets.Fonts["hud_medium"]->DrawText(EventText, glm::vec2(DrawPosition), COLOR_CYAN, CENTER_MIDDLE, 1.0f / 64.0f);
}
}
}
}
void Mesh::drawVBOs() {
// scale it so it fits in the window
Vec3f center; bbox.getCenter(center);
float s = 1/bbox.maxDim();
glScalef(s,s,s);
glTranslatef(-center.x(),-center.y(),-center.z());
// setup the light
Vec3f light_position = LightPosition();
GLfloat position[4] = { float(light_position.x()),float(light_position.y()),float(light_position.z()),1 };
glLightfv(GL_LIGHT1, GL_POSITION, position);
// --------------------------
// Render Mesh
InsertColor(mesh_color);
glEnable(GL_TEXTURE_2D);
if (args->glsl_enabled) {
glUseProgramObjectARB(GLCanvas::program);
glActiveTexture(GL_TEXTURE0);
// Height Map
glActiveTexture(GL_TEXTURE0);
GLint mapLoc = glGetUniformLocationARB(GLCanvas::program, "terrainMap");
glBindTexture(GL_TEXTURE_2D, texture[0]);
glUniform1iARB(mapLoc, 0);
// Normal Map
glActiveTexture(GL_TEXTURE1);
GLint normLoc = glGetUniformLocationARB(GLCanvas::program, "normalMap");
glBindTexture(GL_TEXTURE_2D, texture[1]);
glUniform1iARB(normLoc, 1);
// Stone Texture
glActiveTexture(GL_TEXTURE2);
GLint stoneLoc = glGetUniformLocationARB(GLCanvas::program, "texStone");
glBindTexture(GL_TEXTURE_2D, texture[2]);
glUniform1iARB(stoneLoc, 2);
// Grass Texture
glActiveTexture(GL_TEXTURE3);
GLint grassLoc = glGetUniformLocationARB(GLCanvas::program, "texGrass");
glBindTexture(GL_TEXTURE_2D, texture[3]);
glUniform1iARB(grassLoc, 3);
// Snow Texture
glActiveTexture(GL_TEXTURE4);
GLint snowLoc = glGetUniformLocationARB(GLCanvas::program, "texSnow");
glBindTexture(GL_TEXTURE_2D, texture[4]);
glUniform1iARB(snowLoc, 4);
glActiveTexture(GL_TEXTURE0);
}
else {
glBindTexture(GL_TEXTURE_2D, texture[0]);
}
DrawMesh();
if (args->glsl_enabled) {
glUseProgramObjectARB(0);
}
glDisable(GL_TEXTURE_2D);
DrawPlateVisualization();
// -------------------------
// Render Light (for debugging)
glColor3f(1,1,0);
DrawLight();
HandleGLError();
}
void testApp::compute_raycast(const ofMatrix4x4 &tMatrix)
{
ofVec3f LightPosition(0,0,1000);
cv::Mat rayimage(KINECT_HEIGHT,KINECT_WIDTH,CV_8UC1);
float tStep = SIZE_TRIDE*0.8;
ofVec3f startPosition = ofVec3f(-2,-2,0.5);
int i=0,j=0;
int num=0;
int nnum =0;
for(j=0;j<480;j++)
{
uchar *ptr = rayimage.ptr<uchar>(j);
for(i=0;i<640;i++)
{
ptr[i] = 255;
num = j*KINECT_WIDTH+i;
pointsmap_final[num] = ofVec3f(0,0,0);
normalmap_final[num] = ofVec3f(0,0,0);
ofVec3f rayChange =nmmul(invKcam,ofVec3f(i,j,1));
rayChange = tMatrix * rayChange;
ofVec3f rayOne = 0.5*rayChange - startPosition;
ofVec3f rayTwo = 1.0*rayChange - startPosition;
ofVec3f rayFirst = getTheGlobalPostion(rayOne);
ofVec3f rayEnd = getTheGlobalPostion(rayTwo);
ofVec3f rayDirct = rayTwo - rayOne;//rayEnd - rayFirst;
rayDirct = rayDirct.normalize();
rayDirct.x = (rayDirct.x == 0.f) ? 1e-15 : rayDirct.x;
rayDirct.y = (rayDirct.y == 0.f) ? 1e-15 : rayDirct.y;
rayDirct.z = (rayDirct.z == 0.f) ? 1e-15 : rayDirct.z;
float pretsdf = getTsdfData((int)rayFirst.x,(int)rayFirst.y,(int)rayFirst.z);
float nowtsdf ;
float turr = 0;
float maxtime = getmaxtime(rayDirct,rayOne);
ofVec3f rayLast = rayOne + rayDirct*maxtime;
ofVec3f gLast = getTheGlobalPostion(rayLast);
ofVec3f rayPre = rayOne;
while(turr<maxtime)
{
ofVec3f rayNext = rayPre + rayDirct*tStep;
ofVec3f gnum = getTheGlobalPostion(rayNext);
if(!isvalid(gnum))
{
break;
}
nowtsdf = getTsdfData((int)gnum.x,(int)gnum.y,(int)gnum.z);
if(pretsdf>0&&nowtsdf<0)//&&!(pretsdf==1&&nowtsdf==-1))
{
float Ftdt = triLinary(rayNext);
if(isnan(Ftdt))
break;
float Ft = triLinary(rayPre);
if(isnan(Ft))
break;
float realt = turr - (tStep*Ft/(Ftdt-Ft));
ofVec3f rayzero = rayPre + rayDirct*(realt-turr);
pointsmap_final[num] = (rayzero + startPosition);//*100;// 显示用
//cout<<Ftdt<<" "<<Ft<<endl;
///计算法向////
ofVec3f pregnum = getTheGlobalPostion(rayzero);
if(pregnum.x>1&&pregnum.y>1&&pregnum.z>1&&pregnum.x<TSDF_SIZE-2&&pregnum.y<TSDF_SIZE-2&&pregnum.z<TSDF_SIZE-2)
{
ofVec3f t;
t = rayzero;
t.x -= SIZE_TRIDE;
float Fx1 = triLinary(t);
t = rayzero;
t.x += SIZE_TRIDE;
float Fx2 = triLinary(t);
float nx = (Fx2-Fx1);///(SIZE_TRIDE*2);
t = rayzero;
t.y -= SIZE_TRIDE;
float Fy1 = triLinary(t);
t = rayzero;
t.y += SIZE_TRIDE;
float Fy2 = triLinary(t);
float ny = (Fy2-Fy1);///(SIZE_TRIDE*2);
t = rayzero;
t.z -= SIZE_TRIDE;
float Fz1 = triLinary(t);
t = rayzero;
t.z += SIZE_TRIDE;
float Fz2 = triLinary(t);
float nz =(Fz2-Fz1);////(SIZE_TRIDE*2);
ofVec3f n(nx,ny,nz);
n = n.normalize();
normalmap_final[num] = n;
nnum++;
// 生成图像
ofVec3f pp = LightPosition - pointsmap_final[num];
pp = pp.normalize();
float r = fabs(pp.dot(n));
int br = (int)(r*205)+50;
br = max((int)0,min(br,255));
ptr[i] = br;
}
//num++;
break;
}
else if(pretsdf<0&&nowtsdf>0)
break;
else
{
pretsdf = nowtsdf;
rayPre = rayNext;
turr += tStep;
}
}// while()
//}// if(Last<0)
}// for(i)
}// for(j)
finalPointNum = num;
//std::cout<<num<<" "<<nnum<<endl;
cv::imshow("ray",rayimage);
}
