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
}
}
}
