void YsClassSample::RotatePolygon(YsVec3 p[],double pitch,double yaw) { int i; YsMatrix4x4 m; m.Initialize(); m.RotateXZ(yaw); m.RotateZY(pitch); for(i=0; i<4; i++) { p[i]=m*p[i]; } }
void Display(void) { double matBuf[4*4]; YsVec3 eyePos; YsMatrix4x4 eyeTfm; glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); eyePos.Set(0.0,0.0,eyeDistance); eyePos=eyeAtt.GetMatrix()*eyePos; eyeTfm.Initialize(); eyeTfm.Translate(eyePos); eyeTfm.Rotate(eyeAtt); eyeTfm.Invert(); eyeTfm.Translate(-eyeLookAt); eyeTfm.GetArray(matBuf); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glMultMatrixd(matBuf); DrawSeparatablePair(nVtx,vtx); glFlush(); glutSwapBuffers(); }
void Display(void) { double matBuf[4*4]; YsVec3 eyePos; YsMatrix4x4 eyeTfm; glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); eyePos.Set(0.0,0.0,eyeDistance); eyePos=eyeAtt.GetMatrix()*eyePos; eyeTfm.Initialize(); eyeTfm.Translate(eyePos); eyeTfm.Rotate(eyeAtt); eyeTfm.Invert(); eyeTfm.Translate(-eyeLookAt); eyeTfm.GetArray(matBuf); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glMultMatrixd(matBuf); DrawShell(sh1,blu,drawInPolygon); DrawShell(sh2,grn,drawInPolygon); DrawAxis(5.0); glFlush(); glutSwapBuffers(); }
void YsTransform3DCoordToScreenCoord(YsVec3 &scrn,const YsVec3 &from,const int viewport[4],const YsMatrix4x4 &projViewModelTfm) { double pos4d[4]={from.x(),from.y(),from.z(),1.0}; projViewModelTfm.Mul(pos4d,pos4d); pos4d[0]/=pos4d[3]; pos4d[1]/=pos4d[3]; pos4d[2]/=pos4d[3]; pos4d[0]=(double)viewport[0]+(double)viewport[2]*(pos4d[0]+1.0)/2.0; pos4d[1]=(double)viewport[1]+(double)viewport[3]*(pos4d[1]+1.0)/2.0; scrn.Set(pos4d[0],pos4d[1],pos4d[2]); }
void YsTransformScreenCoordTo3DCoord(YsVec3 &threeD,const YsVec3 &scrn,const int viewport[4],const YsMatrix4x4 &projViewModelTfm) { double pos4d[4]= { (scrn.x()-(double)viewport[0])*2.0/(double)viewport[2]-1.0, (scrn.y()-(double)viewport[1])*2.0/(double)viewport[3]-1.0, scrn.z(), 1.0 }; projViewModelTfm.MulInverse(pos4d,pos4d); pos4d[0]/=pos4d[3]; pos4d[1]/=pos4d[3]; pos4d[2]/=pos4d[3]; threeD.Set(pos4d[0],pos4d[1],pos4d[2]); }
void Display(void) { double matBuf[4*4]; YsVec3 eyePos; YsMatrix4x4 eyeTfm; YsVec3 p; glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); eyePos.Set(0.0,0.0,eyeDistance); eyePos=eyeAtt.GetMatrix()*eyePos; eyeTfm.Initialize(); eyeTfm.Translate(eyePos); eyeTfm.Rotate(eyeAtt); eyeTfm.Invert(); eyeTfm.Translate(-eyeLookAt); eyeTfm.GetArray(matBuf); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glMultMatrixd(matBuf); DrawAxis(5.0); glDisable(GL_LIGHTING); glColor3d(1.0,1.0,1.0); glBegin(GL_LINES); glVertex3d(0.0,0.0,0.0); glVertex3d(axisOfOrbit.x()*5.0,axisOfOrbit.y()*5.0,axisOfOrbit.z()*5.0); glEnd(); rot.RotatePositive(p,orbiter); glPushMatrix(); glTranslatef(p.x()*5.0,p.y()*5.0,p.z()*5.0); DrawCursor(); glPopMatrix(); glFlush(); glutSwapBuffers(); }
YSRESULT YsShellExt_SweepInfoMultiStep::SetUpNonParallelSweepWithPath(const YsShellExt &shl,YSSIZE_T nPathVt,const YsShellVertexHandle pathVtHdArrayIn[],YSBOOL isLoop,const YsVec3 nom[],const double scaling[]) { const auto &allVtHd=GetVertexAll(); // Need the original normal. CleanUpLayer(); if(2<=nPathVt) { YsConstArrayMask <YsShellVertexHandle> pathVtHd(nPathVt,pathVtHdArrayIn); YsArray <YsVec3> pathPnt(nPathVt,NULL); for(YSSIZE_T idx=0; idx<pathVtHd.GetN(); ++idx) { pathPnt[idx]=shl.GetVertexPosition(pathVtHd[idx]); } const YSSIZE_T nLayer=(YSTRUE==isLoop ? nPathVt : nPathVt-1); SetUpNLayer(shl,nLayer+1); // First set of vertices are not counted as a layer. Number of layers will be nPathVt-1. // Rotation must be progressive. Why? Assume nom[0] and nom[5] are 180 degrees opposite. // If the rotation is calculated for each layer by YsRotation::MakeAtoB(nom[0],nom[layerIndex]), // rotational axis for nom[5] may become different from other layers, and thus the continuity is lost. // The solution is calculating the rotation for each step progressively. YsArray <YsMatrix3x3> rot(nPathVt-1,NULL); YsMatrix3x3 prevRot; for(int layerIdx=0; layerIdx<nPathVt-1; ++layerIdx) { YsRotation thisRot; thisRot.MakeAtoB(nom[layerIdx],nom[layerIdx+1]); prevRot*=thisRot; rot[layerIdx]=prevRot; } for(auto layerIdx=0; layerIdx<nPathVt-1; ++layerIdx) { YsMatrix4x4 tfm; tfm.Translate(pathPnt[layerIdx+1]); tfm*=rot[layerIdx]; tfm.Scale(scaling[layerIdx+1],scaling[layerIdx+1],scaling[layerIdx+1]); tfm.Translate(-pathPnt[0]); for(auto vtHd : allVtHd) { YSSIZE_T indexInLayer; if(YSOK==srcVtKeyToMidPointIndex.FindElement(indexInLayer,shl.GetSearchKey(vtHd))) { auto &point=layerArray[layerIdx].pointArray[indexInLayer]; if(vtHd==pathVtHd[0]) { point.vtHd=pathVtHd[layerIdx+1]; point.pos=shl.GetVertexPosition(pathVtHd[layerIdx+1]); } else { point.vtHd=NULL; point.pos=tfm*shl.GetVertexPosition(vtHd); } } } } if(YSTRUE==isLoop) { for(auto vtHd : allVtHd) { YSSIZE_T indexInLayer; if(YSOK==srcVtKeyToMidPointIndex.FindElement(indexInLayer,shl.GetSearchKey(vtHd))) { auto &point=layerArray[nLayer-1].pointArray[indexInLayer]; point.vtHd=vtHd; point.pos=shl.GetVertexPosition(vtHd); } } } return YSOK; } return YSERR; }
/* virtual */ void FsLazyWindowApplication::Draw(void) { int wid,hei; FsGetWindowSize(wid,hei); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA); glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); glEnable(GL_DEPTH_TEST); drawEnv.SetProjectionMode(YsProjectionTransformation::PERSPECTIVE); drawEnv.SetAspectRatio((double)wid/(double)hei); drawEnv.SetFOVY(YsPi/4.0); drawEnv.SetNearFar(0.1,100.0); drawEnv.SetViewTarget((min+max)/2.0); drawEnv.SetViewDistance((max-min).GetLength()); GLfloat projMat[16]; drawEnv.GetProjectionMatrix().GetOpenGlCompatibleMatrix(projMat); auto &view=drawEnv.GetViewMatrix(); YsMatrix4x4 modeling; YsMatrix4x4 fullMatrix=view*modeling; GLfloat viewMat[16]; fullMatrix.GetOpenGlCompatibleMatrix(viewMat); { YsGLSLPlain3DRenderer renderer; // Again, do not nest the renderer! renderer.SetProjection(projMat); renderer.SetModelView(viewMat); GLfloat color[8]={0,0,1,1, 1,0,0,1}; const GLfloat vtx[6]= { lastClick[0].xf(),lastClick[0].yf(),lastClick[0].zf(), lastClick[1].xf(),lastClick[1].yf(),lastClick[1].zf() }; renderer.DrawVtxCol(GL_LINES,2,vtx,color); glEnable(GL_PROGRAM_POINT_SIZE); renderer.SetUniformPointSize(3.0); renderer.DrawVtx(GL_POINTS,cellVtx.size()/3,cellVtx.data()); } { GLfloat lightDir[]={0,0,1}; YsGLSLShaded3DRenderer renderer; // Again, do not nest the renderer! renderer.SetProjection(projMat); renderer.SetModelView(viewMat); renderer.SetLightDirectionInCameraCoordinate(0,lightDir); renderer.DrawVtxNomCol(GL_TRIANGLES,vtx.size()/3,vtx.data(),nom.data(),col.data()); } YsMatrix4x4 shadowMat; shadowMat.Translate(0.0,-12.0,0.0); shadowMat.Scale(1.0,0.0,1.0); fullMatrix=view*shadowMat*modeling; fullMatrix.GetOpenGlCompatibleMatrix(viewMat); { GLfloat color[]={0,0,0,1}; YsGLSLPlain3DRenderer renderer; // Again, do not nest the renderer! renderer.SetProjection(projMat); renderer.SetModelView(viewMat); renderer.SetUniformColor(color); renderer.DrawVtx(GL_TRIANGLES,vtx.size()/3,vtx.data()); } FsSwapBuffers(); needRedraw=false; }
void GeblGuiEditorBase::Draw(void) { if(YSTRUE!=drawingMasterSwitch) { DrawGuiOnly(); return; } // Do this at the beginning of Draw funtion. This will allow one of the elements set SetNeedRedraw(YSTRUE) // within drawing function so that Draw function will be called again in the next iteragion. >> SetNeedRedraw(YSFALSE); drawEnv.SetNeedRedraw(YSFALSE); threeDInterface.SetNeedRedraw(YSFALSE); // << glEnable(GL_POLYGON_OFFSET_FILL); glPolygonOffset(1,1); if(NULL==slHd) { if(NULL!=GetTopStatusBar()) { GetTopStatusBar()->ClearStringAll(); } if(NULL!=GetBottomStatusBar()) { GetBottomStatusBar()->ClearStringAll(); } } if(NULL!=slHd && NULL!=GetTopStatusBar()) { YsWString ful,pth,fil; slHd->GetFileName(ful); ful.SeparatePathFile(pth,fil); if(YSTRUE==slHd->IsModified()) { fil.Append(L"(*)"); } YsWString curMsg; if(0!=YsWString::Strcmp(fil,GetTopStatusBar()->GetString(curMsg,0))) { GetTopStatusBar()->SetString(0,fil); } } if(NULL!=slHd && NULL!=GetBottomStatusBar()) { YsString str("Selection"); YsString append; { YsArray <YsShellVertexHandle> selVtHd; slHd->GetSelectedVertex(selVtHd); if(0<selVtHd.GetN()) { append.Printf(" Vertex:%d",(int)selVtHd.GetN()); str.Append(append); } } { YsArray <YsShellPolygonHandle> selPlHd; slHd->GetSelectedPolygon(selPlHd); if(0<selPlHd.GetN()) { append.Printf(" Polygon:%d",(int)selPlHd.GetN()); str.Append(append); } } { YsArray <YsShellExt::ConstEdgeHandle> selCeHd; slHd->GetSelectedConstEdge(selCeHd); if(0<selCeHd.GetN()) { append.Printf(" ConstEdge:%d",(int)selCeHd.GetN()); str.Append(append); } } { YsArray <YsShellExt::FaceGroupHandle> selFgHd; slHd->GetSelectedFaceGroup(selFgHd); if(0<selFgHd.GetN()) { append.Printf(" FaceGroup:%d",(int)selFgHd.GetN()); str.Append(append); } } GetBottomStatusBar()->SetString(0,str); } int viewport[4]; drawEnv.GetOpenGlCompatibleViewport(viewport); drawEnv.SetVerticalOrientation(YSTRUE); drawEnv.UpdateNearFar(); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA); glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LEQUAL); if(YsCoordSysModel==YSOPENGL) { glFrontFace(GL_CCW); } else { glFrontFace(GL_CW); } const YsMatrix4x4 &projMat=drawEnv.GetProjectionMatrix(); const YsMatrix4x4 &viewMat=drawEnv.GetViewMatrix(); const YsMatrix4x4 projViewMat=(projMat*viewMat); threeDInterface.SetViewport(viewport); threeDInterface.SetProjViewModelMatrix(projViewMat); glViewport(viewport[0],viewport[1],viewport[2],viewport[3]); GLfloat glProjMat[16]; projMat.GetOpenGlCompatibleMatrix(glProjMat); GLfloat glModelviewMat[16]; viewMat.GetOpenGlCompatibleMatrix(glModelviewMat); // glMatrixMode(GL_PROJECTION); // glLoadIdentity(); // glMultMatrixf(glProjMat); // glMatrixMode(GL_MODELVIEW); // glLoadIdentity(); // glMultMatrixf(glModelviewMat); YsGLSLSetShared3DRendererProjection(glProjMat); YsGLSLSetShared3DRendererModelView(glModelviewMat); YsVec3 lightDir=YsUnitVector(YsVec3(0.1,1.0,3.0)); const GLfloat lightDirf[]={lightDir.xf(),lightDir.yf(),lightDir.zf()}; YsGLSLSetShared3DRendererDirectionalLightInCameraCoordinatefv(0,lightDirf); YsGLSLSetShared3DRendererSpecularColor(config->GetSpecularColor()); YsGLSLSetShared3DRendererAmbientColor(config->GetAmbientColor()); YsGLSLSetShared3DRendererLightColor(0,config->GetLightColor()); actuallyDrawVertex=drawVertex; actuallyDrawConstEdge=drawConstEdge; actuallyDrawPolygonEdge=drawPolygonEdge; actuallyDrawPolygon=drawPolygon; actuallyDrawShrunkPolygon=drawShrunkPolygon; actuallyDrawNonManifoldEdge=drawNonManifoldEdge; if(NULL!=UIBeforeDrawCallBack) { (*UIBeforeDrawCallBack)(*this); } glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); if(YSTRUE==viewDrawBackgroundGradation->GetCheck() && (NULL==guiExtension || YSTRUE!=guiExtension->DrawBackground())) { // Linear interpolation looks to be too fast. Probably need three colors. YsGLSLUsePlain2DRenderer(YsGLSLSharedPlain2DRenderer()); YsGLSLUseWindowCoordinateInPlain2DDrawing(YsGLSLSharedPlain2DRenderer(),YSTRUE); glDepthMask(0); const GLfloat rect[12]= { 0 ,0, (GLfloat)viewport[2],0, 0 ,(GLfloat)viewport[3]/2.0f, (GLfloat)viewport[2],(GLfloat)viewport[3]/2.0f, 0 ,(GLfloat)viewport[3], (GLfloat)viewport[2],(GLfloat)viewport[3] }; const GLfloat color[24]= { config->bgColor[0].Rf(),config->bgColor[0].Gf(),config->bgColor[0].Bf(),1, config->bgColor[0].Rf(),config->bgColor[0].Gf(),config->bgColor[0].Bf(),1, config->bgColor[1].Rf(),config->bgColor[1].Gf(),config->bgColor[1].Bf(),1, config->bgColor[1].Rf(),config->bgColor[1].Gf(),config->bgColor[1].Bf(),1, config->bgColor[2].Rf(),config->bgColor[2].Gf(),config->bgColor[2].Bf(),1, config->bgColor[2].Rf(),config->bgColor[2].Gf(),config->bgColor[2].Bf(),1 }; YsGLSLDrawPlain2DPrimitivefv(YsGLSLSharedPlain2DRenderer(),GL_TRIANGLE_STRIP,6,rect,color); glDepthMask(1); YsGLSLEndUsePlain2DRenderer(YsGLSLSharedPlain2DRenderer()); } threeDInterface.Draw(); if(NULL!=slHd && YSTRUE==slHd->NeedRemakeHighlightVertexBuffer()) { slHd->GetHighlight().RemakeVertexBuffer(*slHd); slHd->SetNeedRemakeHighlightVertexBuffer(YSFALSE); } if(NEED_REMAKE_DRAWING_NONE!=needRemakeDrawingBuffer || (nullptr!=slHd && YSTRUE==slHd->GetTemporaryModification().Changed())) { RemakeDrawingBuffer(slHd,needRemakeDrawingBuffer); needRemakeDrawingBuffer=NEED_REMAKE_DRAWING_NONE; slHd->GetTemporaryModification().ClearChangeFlag(); } if(NEED_REMAKE_DRAWING_NONE!=needRemakeDrawingBuffer_for_OtherShell && YSTRUE==actuallyDrawOtherShell) { YsArray <YsShellDnmContainer <YsShellExtEditGui>::Node *> allNode; shlGrp.GetNodePointerAll(allNode); for(YSSIZE_T nodeIdx=0; nodeIdx<allNode.GetN(); ++nodeIdx) { if(slHd!=allNode[nodeIdx]) { RemakeDrawingBuffer(allNode[nodeIdx],needRemakeDrawingBuffer_for_OtherShell); } } needRemakeDrawingBuffer_for_OtherShell=NEED_REMAKE_DRAWING_NONE; } { GLfloat prevTfm[16]; GLfloat curNodeTfm[16]; if(YSTRUE==dnmEditMode) { YsMatrix4x4 curMat; { YsGLSLShaded3DRenderer renderer; renderer.GetModelView(prevTfm); curMat.CreateFromOpenGlCompatibleMatrix(prevTfm); } YsMatrix4x4 tfm=curMat*dnmState.GetNodeToRootTransformation(slHd); tfm.GetOpenGlCompatibleMatrix(curNodeTfm); YsGLSLSetShared3DRendererModelView(curNodeTfm); } YsShellExtDrawingBuffer &drawBuf=slHd->GetDrawingBuffer(); if(YSTRUE==actuallyDrawVertex && NULL!=slHd) { GeblGuiFoundation::DrawVertex(*slHd,viewport); } if(0<drawBuf.selectedVertexPosBuffer.GetNumVertex() && NULL!=slHd) { GeblGuiFoundation::DrawSelectedVertex(*slHd,viewport); } if(0<drawBuf.selectedVertexLineBuffer.GetNumVertex() && NULL!=slHd) { GeblGuiFoundation::DrawSelectedVertexLine(*slHd); } if(YSTRUE==actuallyDrawPolygonEdge && NULL!=slHd) { GeblGuiFoundation::DrawPolygonEdge(*slHd); } if(YSTRUE==actuallyDrawShrunkPolygon && NULL!=slHd) { GeblGuiFoundation::DrawShrunkPolygon(*slHd); } if(0<drawBuf.selectedPolygonPosBuffer.GetNumVertex() && NULL!=slHd) { GeblGuiFoundation::DrawSelectedPolygon(*slHd); } if(YSTRUE==actuallyDrawConstEdge && 0<drawBuf.constEdgeVtxBuffer.GetNumVertex() && NULL!=slHd) { GeblGuiFoundation::DrawConstEdge(*slHd); } if(0<drawBuf.selectedConstEdgeVtxBuffer.GetNumVertex() && NULL!=slHd) { GeblGuiFoundation::DrawSelectedConstEdge(*slHd); } if(YSTRUE==dnmEditMode) { YsGLSLSetShared3DRendererModelView(prevTfm); } if(YSTRUE!=dnmEditMode) { DrawInGeometryEditMode(); } else { DrawInDnmEditMode(); } if(YSTRUE==dnmEditMode) { YsGLSLSetShared3DRendererModelView(curNodeTfm); } if(0<=drawBuf.selectedFaceGroupVtxBuffer.GetNumVertex() && NULL!=slHd) { GeblGuiFoundation::DrawSelectedFaceGroup(*slHd); } if(YSTRUE==dnmEditMode) { YsGLSLSetShared3DRendererModelView(prevTfm); } } if(NULL!=slHd && YSTRUE==actuallyDrawNonManifoldEdge) { if(YSTRUE==nonManifoldEdgeCache.IsModified(slHd)) { nonManifoldEdgeCache.CacheNonManifoldEdge(slHd); } struct YsGLSL3DRenderer *renderer=YsGLSLSharedVariColor3DRenderer(); YsGLSLUse3DRenderer(renderer); glLineWidth(3); YsGLSLDrawPrimitiveVtxColfv(renderer,GL_LINES,nonManifoldEdgeCache.lineVtxBuf.GetNi(),nonManifoldEdgeCache.lineVtxBuf,nonManifoldEdgeCache.lineColBuf); glLineWidth(1); YsGLSLEndUse3DRenderer(renderer); // The following could have easily be done by glPointSize. However, stupid OpenGL ES 2.0 got rid of glPointSize. // OpenGL ES should be gone. The hardware on the tablets and smart phones are good enough to support full-blown // OpenGL. OpenGL ES will be remembered as a dark history of OpenGL. That is bad. Not as bad as Direct 3D though. renderer=YsGLSLSharedVariColorMarkerByPointSprite3DRenderer(); YsGLSLUse3DRenderer(renderer); #ifdef GL_PROGRAM_POINT_SIZE glEnable(GL_POINT_SPRITE); glEnable(GL_PROGRAM_POINT_SIZE); #endif YsGLSLSet3DRendererUniformMarkerType(renderer,YSGLSL_MARKER_TYPE_RECT); YsGLSLSet3DRendererUniformMarkerDimension(renderer,3.0f); YsGLSLDrawPrimitiveVtxColfv( renderer,GL_POINTS, nonManifoldEdgeCache.pointVtxBuf.GetNi(), nonManifoldEdgeCache.pointVtxBuf, nonManifoldEdgeCache.pointColBuf); #ifdef GL_PROGRAM_POINT_SIZE glDisable(GL_POINT_SPRITE); glDisable(GL_PROGRAM_POINT_SIZE); #endif YsGLSLEndUse3DRenderer(renderer); } if(YSTRUE==drawHighlight) { auto &bufManager=YsGLBufferManager::GetSharedBufferManager(); auto &highlight=slHd->GetHighlight(); YsGLSLRenderer renderer(YsGLSLSharedFlat3DRenderer()); const GLfloat blue[]={0.0f,0.0f,1.0f,1.0f}; YsGLSLSet3DRendererUniformColorfv(renderer,blue); { auto unitPtr=bufManager.GetBufferUnit(highlight.highlightedEdgeVboHandle); if(nullptr!=unitPtr && YsGLBufferManager::Unit::EMPTY!=unitPtr->GetState()) { unitPtr->GetActualBuffer()->DrawPrimitiveVtx(renderer,GL_LINES); } } glLineWidth(2); { auto unitPtr=bufManager.GetBufferUnit(highlight.highlightedThickEdgeVboHandle); if(nullptr!=unitPtr && YsGLBufferManager::Unit::EMPTY!=unitPtr->GetState()) { unitPtr->GetActualBuffer()->DrawPrimitiveVtx(renderer,GL_LINES); } } glLineWidth(1); const GLfloat darkBlue[]={0.0f,0.0f,0.7f,1.0f}; YsGLSLSet3DRendererUniformColorfv(renderer,darkBlue); { auto unitPtr=bufManager.GetBufferUnit(highlight.highlightedPolygonVboHandle); if(nullptr!=unitPtr && YsGLBufferManager::Unit::EMPTY!=unitPtr->GetState()) { unitPtr->GetActualBuffer()->DrawPrimitiveVtx(renderer,GL_TRIANGLES); } } } if(NULL!=UIDrawCallBack3D) { UIDrawCallBack3D(*this); } if(draw3dCallBack) { draw3dCallBack(); } refBmpStore->Draw(); if(YSTRUE==drawAxis) { const GLfloat axisLength=5.0; GeblGuiFoundation::DrawAxis(axisLength,viewport,projMat,viewMat); } // 2D Drawing // glMatrixMode(GL_PROJECTION); // glLoadIdentity(); // glOrtho(0.0,(double)viewport[2],(double)viewport[3],0.0,-1.0,1.0); // glMatrixMode(GL_MODELVIEW); // glLoadIdentity(); YsGLSLUsePlain2DRenderer(YsGLSLSharedPlain2DRenderer()); YsGLSLUseWindowCoordinateInPlain2DDrawing(YsGLSLSharedPlain2DRenderer(),YSTRUE); { if(YSTRUE==lBtnDown) { const GLfloat rect[8]= { (GLfloat)lBtnDownMx,(GLfloat)lBtnDownMy, (GLfloat)moveMx, (GLfloat)lBtnDownMy, (GLfloat)moveMx, (GLfloat)moveMy, (GLfloat)lBtnDownMx,(GLfloat)moveMy }; const GLfloat color[16]= { 0,0,0,0.8f, 0,0,0,0.8f, 0,0,0,0.8f, 0,0,0,0.8f }; YsGLSLDrawPlain2DPrimitivefv(YsGLSLSharedPlain2DRenderer(),GL_LINE_LOOP,4,rect,color); } } YsGLSLEndUsePlain2DRenderer(YsGLSLSharedPlain2DRenderer()); glDisable(GL_DEPTH_TEST); FsGuiCanvas::Show(); if(NULL!=UIDrawCallBack2D) { (*UIDrawCallBack2D)(*this); } FsSwapBuffers(); }
void GeblGuiEditorBase::DrawInDnmEditModeRecursive(YsShellDnmContainer <YsShellExtEditGui>::Node *node,const YsShellDnmContainer <YsShellExtEditGui>::DnmState &state,const YsMatrix4x4 &curTfm) { const YsMatrix4x4 tfm=curTfm*state.GetTransformation(node); GLfloat glTfm[16]; tfm.GetOpenGlCompatibleMatrix(glTfm); for(auto childNode : node->children) { DrawInDnmEditModeRecursive(childNode,state,tfm); } if(YSTRUE==state.GetShow(node)) { auto &buf=node->GetDrawingBuffer(); if(NULL!=YsGLSLSharedVariColorShaded3DRenderer()) { auto renderer=YsGLSLSharedVariColorShaded3DRenderer(); YsGLSLUse3DRenderer(renderer); YsGLSLSet3DRendererModelViewfv(renderer,glTfm); YsGLSLDrawPrimitiveVtxNomColfv( renderer, GL_TRIANGLES, buf.solidShadedVtxBuffer.GetNi(), buf.solidShadedVtxBuffer, buf.solidShadedNomBuffer, buf.solidShadedColBuffer); YsGLSLEndUse3DRenderer(renderer); } if(NULL!=YsGLSLSharedVariColor3DRenderer()) { auto renderer=YsGLSLSharedVariColor3DRenderer(); YsGLSLUse3DRenderer(renderer); YsGLSLSet3DRendererModelViewfv(renderer,glTfm); YsGLSLDrawPrimitiveVtxColfv( renderer, GL_TRIANGLES, buf.solidUnshadedVtxBuffer.GetNi(), buf.solidUnshadedVtxBuffer, buf.solidUnshadedColBuffer); YsGLSLEndUse3DRenderer(renderer); } if(NULL!=YsGLSLSharedVariColorShaded3DRenderer()) { auto renderer=YsGLSLSharedVariColorShaded3DRenderer(); YsGLSLUse3DRenderer(renderer); YsGLSLSet3DRendererModelViewfv(renderer,glTfm); YsGLSLDrawPrimitiveVtxNomColfv( renderer, GL_TRIANGLES, buf.trspShadedVtxBuffer.GetNi(), buf.trspShadedVtxBuffer, buf.trspShadedNomBuffer, buf.trspShadedColBuffer); YsGLSLEndUse3DRenderer(renderer); } if(NULL!=YsGLSLSharedVariColor3DRenderer()) { auto renderer=YsGLSLSharedVariColor3DRenderer(); YsGLSLUse3DRenderer(renderer); YsGLSLSet3DRendererModelViewfv(renderer,glTfm); YsGLSLDrawPrimitiveVtxColfv( renderer, GL_TRIANGLES, buf.trspUnshadedVtxBuffer.GetNi(), buf.trspUnshadedVtxBuffer, buf.trspUnshadedColBuffer); YsGLSLEndUse3DRenderer(renderer); } if(NULL!=YsGLSLSharedFlashByPointSprite3DRenderer()) { int viewport[4]; glGetIntegerv(GL_VIEWPORT,viewport); #ifdef GL_PROGRAM_POINT_SIZE glEnable(GL_PROGRAM_POINT_SIZE); // Needed for enabling gl_PointSize in the vertex shader. glEnable(GL_POINT_SPRITE); // Needed for enabling gl_PointCoord in the fragment shader. #endif auto renderer=YsGLSLSharedFlashByPointSprite3DRenderer(); YsGLSLUse3DRenderer(renderer); YsGLSLSet3DRendererViewportDimensionf(renderer,(float)viewport[2],(float)viewport[3]); YsGLSLSet3DRendererPointSizeMode(renderer,YSGLSL_POINTSPRITE_SIZE_IN_3DSPACE); YsGLSLDrawPrimitiveVtxColPointSizefv( renderer, GL_POINTS, buf.lightVtxBuffer.GetNi(), buf.lightVtxBuffer, buf.lightColBuffer, buf.lightSizeBuffer); YsGLSLEndUse3DRenderer(renderer); #ifdef GL_PROGRAM_POINT_SIZE glDisable(GL_PROGRAM_POINT_SIZE); glDisable(GL_POINT_SPRITE); #endif } } }