YSSIZE_T YsShellExt_DuplicateUtil::AddConstEdge(YsShellExt::ConstEdgeHandle ceHd,YSBOOL derived) { const YSSIZE_T newIdx=constEdgeArray.GetN(); auto &last=constEdgeArray.New(); last.srcCeHd=ceHd; YsArray <YsShellVertexHandle,4> vtHdArray; srcShl->GetConstEdge(vtHdArray,last.isLoop,ceHd); last.vertexArray.Set(vtHdArray.GetN(),NULL); for(YSSIZE_T vtIdx=0; vtIdx<vtHdArray.GetN(); ++vtIdx) { YsArray <YSSIZE_T> found; vtHdMap.FindMapping(found,*srcShl,vtHdArray[vtIdx]); if(0<found.GetN()) { last.vertexArray[vtIdx]=found[0]; } else { last.vertexArray[vtIdx]=AddVertex(vtHdArray[vtIdx],YSTRUE); } } last.attrib=srcShl->GetConstEdgeAttrib(ceHd); last.derived=derived; ceHdMap.AddMapping(*srcShl,ceHd,newIdx); return newIdx; }
YSSIZE_T YsShellExt_DuplicateUtil::AddPolygon(YsShellPolygonHandle plHd,YSBOOL derived) { const YSSIZE_T newIdx=polygonArray.GetN(); auto &last=polygonArray.New(); last.srcPlHd=plHd; YsArray <YsShellVertexHandle,4> plVtHd; srcShl->GetPolygon(plVtHd,plHd); last.vertexArray.Set(plVtHd.GetN(),NULL); for(YSSIZE_T vtIdx=0; vtIdx<plVtHd.GetN(); ++vtIdx) { YsArray <YSSIZE_T> found; vtHdMap.FindMapping(found,*srcShl,plVtHd[vtIdx]); if(0<found.GetN()) { last.vertexArray[vtIdx]=found[0]; } else { last.vertexArray[vtIdx]=AddVertex(plVtHd[vtIdx],YSTRUE); } } last.attrib=(*srcShl->GetPolygonAttrib(plHd)); srcShl->GetColor(last.col,plHd); srcShl->GetNormal(last.nom,plHd); last.derived=derived; plHdMap.AddMapping(*srcShl,plHd,newIdx); return newIdx; }
YSSIZE_T YsShellExt_DuplicateUtil::AddVolume(YsShellExt::VolumeHandle vlHd,YSBOOL derived) { const YSSIZE_T newIdx=volumeArray.GetN(); auto &last=volumeArray.New(); last.srcVlHd=vlHd; YsArray <YsShellExt::FaceGroupHandle,4> fgHdArray; srcShl->GetVolume(fgHdArray,vlHd); last.faceGroupArray.Set(fgHdArray.GetN(),NULL); for(YSSIZE_T plIdx=0; plIdx<fgHdArray.GetN(); ++plIdx) { YsArray <YSSIZE_T> found; fgHdMap.FindMapping(found,*srcShl,fgHdArray[plIdx]); if(0<found.GetN()) { last.faceGroupArray[plIdx]=found[0]; } else { last.faceGroupArray[plIdx]=AddFaceGroup(fgHdArray[plIdx],YSTRUE); } } last.attrib=srcShl->GetVolumeAttrib(vlHd); last.derived=derived; vlHdMap.AddMapping(*srcShl,vlHd,newIdx); return newIdx; }
YSRESULT YsShellExt_RoundUtil::SetUpRoundConstEdge(const YsShellExt &shl,YsShellExt::ConstEdgeHandle ceHd,const YsShellVertexStore *roundVtx) { YsArray <YsShellVertexHandle> ceVtHd; YSBOOL isLoop; shl.GetConstEdge(ceVtHd,isLoop,ceHd); if(YSTRUE==isLoop && 3>ceVtHd.GetN()) { return YSERR; } else if(YSTRUE!=isLoop && 2>ceVtHd.GetN()) { return YSERR; } if(YSTRUE==isLoop) { ceVtHd.Append(ceVtHd[0]); ceVtHd.Append(ceVtHd[1]); } for(YSSIZE_T idx=1; idx<ceVtHd.GetN()-1; ++idx) { if(NULL==roundVtx || YSTRUE==roundVtx->IsIncluded(ceVtHd[idx])) { const YsShellVertexHandle toVtHd[2]={ceVtHd[idx-1],ceVtHd[idx+1]}; AddRoundCorner((const YsShell &)shl,ceVtHd[idx],toVtHd); } } targetCeKeyArray.Append(shl.GetSearchKey(ceHd)); return YSOK; }
YSSIZE_T YsShellExt_DuplicateUtil::AddFaceGroup(YsShellExt::FaceGroupHandle fgHd,YSBOOL derived) { const YSSIZE_T newIdx=faceGroupArray.GetN(); auto &last=faceGroupArray.New(); last.srcFgHd=fgHd; YsArray <YsShellPolygonHandle,4> plHdArray; srcShl->GetFaceGroup(plHdArray,fgHd); last.polygonArray.Set(plHdArray.GetN(),NULL); for(YSSIZE_T plIdx=0; plIdx<plHdArray.GetN(); ++plIdx) { YsArray <YSSIZE_T> found; plHdMap.FindMapping(found,*srcShl,plHdArray[plIdx]); if(0<found.GetN()) { last.polygonArray[plIdx]=found[0]; } else { last.polygonArray[plIdx]=AddPolygon(plHdArray[plIdx],YSTRUE); } } last.attrib=srcShl->GetFaceGroupAttrib(fgHd); last.derived=derived; fgHdMap.AddMapping(*srcShl,fgHd,newIdx); return newIdx; }
YSRESULT YsShellExt_RoundUtil3d::CalculateRoundingAll(const YsShell &shl,const double radius) { YsArray <unsigned int> vtKeyArray; YsArray <HalfRoundCorner *> cornerPtrArray; for(auto &corner : cornerArray) { vtKeyArray.Append(shl.GetSearchKey(corner.fromVtHd)); cornerPtrArray.Append(&corner); } YsQuickSort <unsigned int,HalfRoundCorner *> (vtKeyArray.GetN(),vtKeyArray,cornerPtrArray); YsArray <HalfRoundCorner *> cornerPerVertex; for(YSSIZE_T idx=0; idx<cornerPtrArray.GetN(); ++idx) { cornerPerVertex.Append(cornerPtrArray[idx]); if(cornerPtrArray.GetN()-1==idx || vtKeyArray[idx]!=vtKeyArray[idx+1]) { if(YSOK!=CalculateRoundingPerVertex(shl,cornerPerVertex,radius)) { return YSERR; } cornerPerVertex.CleanUp(); } } return YSOK; }
void YsShellExt_SweepInfo::MakeInfo( const YsShellExt &shl, YSSIZE_T nPl,const YsShellPolygonHandle plHdArray[], YSSIZE_T nCe,const YsShellExt::ConstEdgeHandle ceHdArray[]) { CleanUp(); YsShellExt_BoundaryInfo::MakeInfo(*(const YsShell *)&shl,nPl,plHdArray); allSrcVtHd.SetShell((const YsShell &)shl); for(YSSIZE_T idx=0; idx<nPl; ++idx) { YsArray <YsShellVertexHandle,4> plVtHd; shl.GetPolygon(plVtHd,plHdArray[idx]); for(auto vtHd : plVtHd) { allSrcVtHd.AddVertex(vtHd); } } for(YSSIZE_T idx=0; idx<nCe; ++idx) { YsArray <YsShellVertexHandle,4> ceVtHd; YSBOOL isLoop; shl.GetConstEdge(ceVtHd,isLoop,ceHdArray[idx]); for(auto vtHd : ceVtHd) { allSrcVtHd.AddVertex(vtHd); } } for(YSSIZE_T ceIdx=0; ceIdx<nCe; ++ceIdx) { YSBOOL isLoop; YsArray <YsShellVertexHandle,16> ceVtHd; shl.GetConstEdge(ceVtHd,isLoop,ceHdArray[ceIdx]); if(2<=ceVtHd.GetN()) { if(YSTRUE==isLoop) { YsShellVertexHandle first=ceVtHd[0]; ceVtHd.Append(first); } for(int edIdx=0; edIdx<ceVtHd.GetN()-1; ++edIdx) { if(YSTRUE!=visited.IsIncluded(ceVtHd[edIdx],ceVtHd[edIdx+1])) { visited.AddEdge(ceVtHd[edIdx],ceVtHd[edIdx+1]); srcEdVtHd.Append(ceVtHd[edIdx]); srcEdVtHd.Append(ceVtHd[edIdx+1]); } } } } }
/* static */ void PolyCreFileName::MakeDirectoryForFile(const wchar_t wfn[]) { YsWString ful(wfn),pth,fil; ful.SeparatePathFile(pth,fil); ful=pth; YsArray <YsWString> backTrack; for(;;) { if(ful.LastChar()=='\\' || ful.LastChar()=='/') { ful.BackSpace(); } printf("%ls\n",ful.Txt()); backTrack.Append(ful); YsWString pth,fil; ful.SeparatePathFile(pth,fil); if(0<pth.Strlen() && 0<fil.Strlen()) { ful=pth; } else { break; } } for(YSSIZE_T idx=backTrack.GetN()-1; 0<=idx; --idx) { printf("MkDir %ls\n",backTrack[idx].Txt()); YsFileIO::MkDir(backTrack[idx]); } }
YSRESULT YsShell::LoadSrf( FILE *fp,YsArray <YsShellPolygonHandle> *noShadingPolygon,YsArray <YsShellVertexHandle> *roundVtx) { if(NULL!=fp) { YsArray <YsString,16> args; if(noShadingPolygon!=NULL) { noShadingPolygon->Set(0,NULL); } if(roundVtx!=NULL) { roundVtx->Set(0,NULL); } if(BeginReadSrf()==YSOK) { YsString str; while(str.Fgets(fp)!=NULL) { if(ReadSrfOneLine(str,noShadingPolygon,roundVtx)!=YSOK) { str.Arguments <16> (args); if(args.GetN()>0) { YSBOOL srmExtension; srmExtension=YSFALSE; args[0].Capitalize(); switch(args[0][0]) { case 'G': // GE, GL, GF case 'Z': // ZE, ZF, ZNBE,ZNBF, ZT, ZA, ZZ, ZH, ZU case 'Y': // YE, YF, YN, Y1 case 'M': // M case 'C': // CV case 'X': // X case 'L': // LF, LE, LL srmExtension=YSTRUE; break; } if(srmExtension!=YSTRUE) { return YSERR; } } } } EndReadSrf(); return YSOK; } } return YSERR; }
/* virtual */ void FsLazyWindowApplication::GetOpenWindowOption(FsOpenWindowOption &opt) const { opt.x0=96; opt.y0=0; opt.wid=1200; opt.hei=640; auto *cfg=PolyCreConfig::Create(); auto *fileAndDirName=PolyCreFileName::Create(); cfg->Load(fileAndDirName->GetOptionFileName()); if(YSTRUE==cfg->saveWindowPositionAndSize) { auto wposFn=fileAndDirName->GetLastWindowPositionFileName(); FILE *fp=YsFileIO::Fopen(wposFn,"r"); if(NULL!=fp) { YsString str; while(NULL!=str.Fgets(fp)) { YsArray <YsString> args; str.Arguments(args); if(0==strcmp(args[0],"POS") && 5<=args.GetN()) { opt.x0=atoi(args[1]); opt.y0=atoi(args[2]); opt.wid=atoi(args[3]); opt.hei=atoi(args[4]); if(0>opt.x0) { opt.x0=0; } if(0>opt.y0) { opt.y0=0; } if(120>opt.wid) { opt.wid=120; } if(120>opt.hei) { opt.hei=120; } } } fclose(fp); } } PolyCreConfig::Delete(cfg); PolyCreFileName::Delete(fileAndDirName); }
YsArray <const YsShellExt_RoundUtil3d::HalfRoundCorner *> YsShellExt_RoundUtil3d::MakeSortedHalfRoundCorner(const YsShell &shl) const { YsArray <unsigned int> vtKeyArray; YsArray <const HalfRoundCorner *> cornerPtrArray; for(auto &corner : cornerArray) { vtKeyArray.Append(shl.GetSearchKey(corner.fromVtHd)); cornerPtrArray.Append(&corner); } YsQuickSort <unsigned int,const HalfRoundCorner *> (vtKeyArray.GetN(),vtKeyArray,cornerPtrArray); return cornerPtrArray; }
YsArray <YSSIZE_T> YsShellExt_RoundUtil3d::FindHalfRoundCornerFromPolygon(const YsShell &shl,YsShellPolygonHandle plHd) const { YsArray <YsShellVertexHandle,4> plVtHd; shl.GetPolygon(plVtHd,plHd); YsArray <YSSIZE_T> idxArray; for(YSSIZE_T i=0; i<plVtHd.GetN(); ++i) { for(YSSIZE_T j=0; j<cornerArray.GetN(); ++j) { if(plVtHd[i]==cornerArray[j].fromVtHd && YSTRUE==plVtHd.IsIncluded(cornerArray[j].toVtHd)) { idxArray.Append(j); } } } return idxArray; }
YSRESULT YsShellExt_RoundUtil::SetUpRoundPolygon(const YsShell &shl,YsShellPolygonHandle plHd,const YsShellVertexStore *roundVtx) { YsArray <YsShellVertexHandle> plVtHd; shl.GetPolygon(plVtHd,plHd); for(YSSIZE_T idx=0; idx<plVtHd.GetN(); ++idx) { const YsShellVertexHandle fromVtHd=plVtHd[idx]; if(NULL==roundVtx || YSTRUE==roundVtx->IsIncluded(fromVtHd)) { const YsShellVertexHandle toVtHd[2]= { plVtHd.GetCyclic(idx-1), plVtHd.GetCyclic(idx+1) }; AddRoundCorner(shl,fromVtHd,toVtHd); } } targetPlKeyArray.Append(shl.GetSearchKey(plHd)); return YSOK; }
YSRESULT YsShellExt_RoundUtil3d::SetUpForAroundPolygonGroup( const YsShellExt &shl, YSSIZE_T nPl,const YsShellPolygonHandle plHdArray[]) { CleanUp(); if(YSTRUE!=shl.IsSearchEnabled()) { YsPrintf("%s\n",__FUNCTION__); YsPrintf(" This function requires a search table.\n"); return YSERR; } YsShellExt_BoundaryInfo boundary; boundary.MakeInfo((const YsShell &)shl,nPl,plHdArray); if(YSOK!=boundary.CacheContour((const YsShell &)shl)) { return YSERR; } YsShellPolygonStore sideAPolygon((const YsShell &)shl),sideBPolygon((const YsShell &)shl); sideAPolygon.AddPolygon(nPl,plHdArray); YsArray <YsShellPolygonHandle> sideAPolygonArray(nPl,plHdArray),sideBPolygonArray; YsShellEdgeStore boundaryEdge((const YsShell &)shl); for(YSSIZE_T contourIdx=0; contourIdx<boundary.GetNumContour(); ++contourIdx) { YsArray <YsShellVertexHandle> contourVtHd; boundary.GetContour(contourVtHd,contourIdx); if(3<=contourVtHd.GetN()) { if(contourVtHd[0]!=contourVtHd.Last()) { const YsShellVertexHandle vtHd0=contourVtHd[0]; contourVtHd.Append(vtHd0); } for(YSSIZE_T vtIdx=0; vtIdx<contourVtHd.GetN()-1; ++vtIdx) { boundaryEdge.AddEdge(contourVtHd[vtIdx],contourVtHd[vtIdx+1]); YSSIZE_T nVtPl; const YsShellPolygonHandle *vtPlHd; shl.FindPolygonFromVertex(nVtPl,vtPlHd,contourVtHd[vtIdx]); for(YSSIZE_T plIdx=0; plIdx<nVtPl; ++plIdx) { if(YSTRUE!=sideAPolygon.IsIncluded(vtPlHd[plIdx]) && YSTRUE!=sideBPolygon.IsIncluded(vtPlHd[plIdx])) { sideBPolygon.AddPolygon(vtPlHd[plIdx]); sideBPolygonArray.Append(vtPlHd[plIdx]); } } } } } return SetUpForVertexSequenceAndPolygonArray( shl, boundary.GetContourAll(), sideAPolygonArray, sideBPolygonArray); }
YsArray <YsShellExt_RoundUtil::VertexPositionPair> YsShellExt_RoundUtil::MakeRoundedVertexSequence(const YsShell &shl,YSSIZE_T nVt,const YsShellVertexHandle vtHdArrayIn[],YSBOOL isLoop) const { YsArray <YsShellVertexHandle> orgVtHdArray(nVt,vtHdArrayIn); YsArray <VertexPositionPair> newVtHdArray; for(YSSIZE_T orgVtIdx=0; orgVtIdx<orgVtHdArray.GetN(); ++orgVtIdx) { YSBOOL rounded=YSFALSE; for(const auto &roundCorner : cornerArray) { if(roundCorner.fromVtHd==orgVtHdArray[orgVtIdx]) { int forward=0,backward=1; if(roundCorner.toVtHd[0]==orgVtHdArray.GetCyclic(orgVtIdx-1)) { forward=1; backward=0; } else if(roundCorner.toVtHd[1]==orgVtHdArray.GetCyclic(orgVtIdx-1)) { forward=0; backward=1; } else { continue; } YSBOOL skipFirst=YSFALSE; if(0<newVtHdArray.GetN() && newVtHdArray.Last().pos==roundCorner.subDiv[backward].Last().pos) { skipFirst=YSTRUE; } newVtHdArray.Append(roundCorner.subDiv[backward]); newVtHdArray.Increment(); newVtHdArray.Last().vtHd=orgVtHdArray[orgVtIdx]; newVtHdArray.Last().pos=roundCorner.roundedCornerPos; for(YSSIZE_T i=roundCorner.subDiv[forward].GetN()-1; 0<=i; --i) { if(YSTRUE==skipFirst) { skipFirst=YSFALSE; continue; } newVtHdArray.Append(roundCorner.subDiv[forward][i]); } rounded=YSTRUE; } } if(YSTRUE!=rounded) { newVtHdArray.Increment(); newVtHdArray.Last().vtHd=orgVtHdArray[orgVtIdx]; newVtHdArray.Last().pos=shl.GetVertexPosition(newVtHdArray.Last().vtHd); } } if(2<=newVtHdArray.GetN() && YSTRUE==isLoop && newVtHdArray[0].pos==newVtHdArray.Last().pos) { newVtHdArray.DeleteLast(); } return newVtHdArray; }
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(); }
/*static*/ YsArray <double> YsShellExt_SweepInfoMultiStep::CalculateScalingForParallelSweepWithPathAndGuideLine( const YsVec3 &sweepDir,const YsArray <YsVec3> &pathArray,const YsArray <YsVec3> &guideArray) { if(1>=pathArray.GetN() || 1>=guideArray.GetN()) { YsArray <double> empty; return empty; } YsArray <double> scaling(pathArray.GetN(),NULL); for(auto &s : scaling) { s=1.0; } for(auto pathIndex : pathArray.AllIndex()) { auto &s=scaling[pathIndex]; auto &pathPnt=pathArray[pathIndex]; const YsPlane cutPln(pathPnt,sweepDir); YSBOOL done=YSFALSE; for(auto &guidePos : guideArray) { if(YSTRUE==cutPln.CheckOnPlane(guidePos)) { s=(guidePos-pathPnt).GetLength(); done=YSTRUE; break; } } if(YSTRUE!=done) { for(auto guideIndex : guideArray.AllIndex()) { if(guideIndex<guideArray.GetN()-1) { auto &pos0=guideArray[guideIndex]; auto &pos1=guideArray[guideIndex+1]; YsVec3 itsc; if(YSOK==cutPln.GetPenetrationHighPrecision(itsc,pos0,pos1)) { s=(itsc-pathPnt).GetLength(); done=YSTRUE; break; } else if(0==guideIndex) { if(YSOK==cutPln.GetIntersection(itsc,pos0,pos1-pos0) && (0.0<(itsc-pos0)*(pos0-pos1) || 2==guideArray.GetN())) // If guideArray consists of only two points, which side of line doesn't matter. { s=(itsc-pathPnt).GetLength(); done=YSTRUE; break; } } else if(guideArray.GetN()-2==guideIndex) { if(YSOK==cutPln.GetIntersection(itsc,pos0,pos1-pos0) && 0.0<(itsc-pos1)*(pos1-pos0)) { s=(itsc-pathPnt).GetLength(); done=YSTRUE; break; } } } } } } const double ref=scaling[0]; for(auto &s : scaling) { s/=ref; } scaling[0]=1.0; return scaling; }
void YsArguments2(YsArray <YsString,16> &args,const char vv[],YSSIZE_T l,const char *blank,const char *comma) { YsString empty; args.Set(0,NULL); YSSIZE_T i=0; while(YSTRUE==CharIsOneOf(vv[i],blank)) { i++; } YSSIZE_T head=i; while(i<l) { if(vv[head]=='\"') { head++; i++; while(i<l && vv[i]!='\"') { if(vv[i]&0x80) // 1st letter of Kanji character? { i++; } else if(isprint(vv[i])==0) { break; } i++; } args.Append(empty); args[args.GetN()-1].Set(i-head,vv+head); if(vv[i]=='\"') { i++; } } else { while(i<l && (CharIsOneOf(vv[i],blank)!=YSTRUE && CharIsOneOf(vv[i],comma)!=YSTRUE)) { if(vv[i]&0x80) // 1st letter of Kanji character? { i++; } else if(isprint(vv[i])==0) { break; } i++; } if(head<i) // <- This condition is added on 2005/03/03 { args.Append(empty); args[args.GetN()-1].Set(i-head,vv+head); } else if(head==i && YSTRUE==CharIsOneOf(vv[i],comma)) // < This condition is added (I thought there was, did I accidentally delet?) on 2012/01/26 { args.Increment(); args.GetEnd().Set(""); } } while(i<l && isprint(vv[i])==0) { i++; } while(i<l && CharIsOneOf(vv[i],blank)==YSTRUE) // Skip blank separator { i++; } if(CharIsOneOf(vv[i],comma)==YSTRUE) // Skip one comma separator { i++; while(i<l && CharIsOneOf(vv[i],blank)==YSTRUE) // Skip blank separator after a comma separator { i++; } if(i==l) { args.Append(empty); } } head=i; } }
void YsShellExt_SewingInfo::MakePolygonSplitInfo(const YsShellExt &shl) { // A concave polygon may be cut twice by one crawling. YsShellPolygonAttribTable <YsArray <YsArray <YsShellVertexHandle,2> > > plHdToDivider(shl.Conv()); for(auto &v : vtxSequence) { if(NULL==v.vtHd) { if(0<=v.vtxOnEdgeIdx) { v.vtHd=vtxOnEdge[v.vtxOnEdgeIdx].createdVtHd; } else if(0<=v.vtxOnPlgIdx) { v.vtHd=vtxOnPlg[v.vtxOnPlgIdx].vtHd; } } } { YsShellPolygonHandle currentPlHd=NULL; YsArray <YsShellVertexHandle,2> currentDivider; for(YSSIZE_T idx=0; idx<vtxSequence.GetN(); ++idx) { if(0==currentDivider.GetN()) { currentPlHd=vtxSequence[idx].plHd; currentDivider.Append(vtxSequence[idx].vtHd); } else { currentDivider.Append(vtxSequence[idx].vtHd); if(idx==vtxSequence.GetN()-1 || vtxSequence[idx].plHd!=currentPlHd) { if(2<=currentDivider.GetN()) { YsArray <YsArray <YsShellVertexHandle,2> > *pldv=plHdToDivider[currentPlHd]; if(NULL==pldv) { YsArray <YsArray <YsShellVertexHandle,2> > newDividerArray(1,NULL); newDividerArray[0].MoveFrom(currentDivider); plHdToDivider.SetAttrib(currentPlHd,newDividerArray); } else { pldv->Append(currentDivider); } } currentDivider.CleanUp(); currentDivider.Append(vtxSequence[idx].vtHd); } currentPlHd=vtxSequence[idx].plHd; } } } for(auto hashHd : plHdToDivider.AllHandle()) { auto plKey=plHdToDivider.GetKey(hashHd); auto plHd=shl.FindPolygon(plKey); auto ÷r=*plHdToDivider[plHd]; YsSegmentedArray <YsArray <YsShellVertexHandle,4>,4> plVtHd(1,NULL); plVtHd[0]=shl.GetPolygonVertex(plHd); for(auto d : divider) { YsArray <YsShellVertexHandle,4> fragment; for(auto &pl : plVtHd) { if(YSOK==YsShellExt_SplitLoopByHandleAndMidNode(pl,fragment,d)) { plVtHd.Append(fragment); break; } } } plgSplit.Increment(); plgSplit.Last().plHd=plHd; plgSplit.Last().plVtHdArray=plVtHd; } }
void GeblGuiEditorBase::DrawInGeometryEditMode(void) { if(YSTRUE==actuallyDrawPolygon && NULL!=slHd) { // auto &buf=slHd->GetDrawingBuffer(); auto &vboSet=slHd->GetVboSet(); auto &bufManager=YsGLBufferManager::GetSharedBufferManager(); glEnable(GL_CULL_FACE); if(NULL!=YsGLSLSharedVariColorShaded3DRenderer()) { auto unitPtr=bufManager.GetBufferUnit(vboSet.solidShadedPosNomColHd); if(nullptr!=unitPtr && YsGLBufferManager::Unit::EMPTY!=unitPtr->GetState()) { YsGLSLRenderer renderer(YsGLSLSharedVariColorShaded3DRenderer()); unitPtr->GetActualBuffer()->DrawPrimitiveVtxNomCol(renderer,GL_TRIANGLES); } } if(NULL!=YsGLSLSharedVariColor3DRenderer()) { YsGLSLRenderer renderer(YsGLSLSharedVariColor3DRenderer()); { auto unitPtr=bufManager.GetBufferUnit(vboSet.solidUnshadedPosColHd); if(nullptr!=unitPtr && YsGLBufferManager::Unit::EMPTY!=unitPtr->GetState()) { unitPtr->GetActualBuffer()->DrawPrimitiveVtxCol(renderer,GL_TRIANGLES); } } { auto unitPtr=bufManager.GetBufferUnit(vboSet.backFacePosColHd); if(nullptr!=unitPtr && YsGLBufferManager::Unit::EMPTY!=unitPtr->GetState()) { unitPtr->GetActualBuffer()->DrawPrimitiveVtxCol(renderer,GL_TRIANGLES); } } } if(NULL!=YsGLSLSharedVariColorShaded3DRenderer()) { auto unitPtr=bufManager.GetBufferUnit(vboSet.trspShadedPosNomColHd); if(nullptr!=unitPtr && YsGLBufferManager::Unit::EMPTY!=unitPtr->GetState()) { YsGLSLRenderer renderer(YsGLSLSharedVariColorShaded3DRenderer()); unitPtr->GetActualBuffer()->DrawPrimitiveVtxNomCol(renderer,GL_TRIANGLES); } } if(NULL!=YsGLSLSharedVariColor3DRenderer()) { auto unitPtr=bufManager.GetBufferUnit(vboSet.trspUnshadedPosColHd); if(nullptr!=unitPtr && YsGLBufferManager::Unit::EMPTY!=unitPtr->GetState()) { YsGLSLRenderer renderer(YsGLSLSharedVariColor3DRenderer()); unitPtr->GetActualBuffer()->DrawPrimitiveVtxNomCol(renderer,GL_TRIANGLES); } } if(NULL!=YsGLSLSharedFlashByPointSprite3DRenderer()) { auto unitPtr=bufManager.GetBufferUnit(vboSet.lightPosColPointSizeHd); if(nullptr!=unitPtr && YsGLBufferManager::Unit::EMPTY!=unitPtr->GetState()) { 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 YsGLSLRenderer renderer(YsGLSLSharedFlashByPointSprite3DRenderer()); YsGLSLSet3DRendererViewportDimensionf(renderer,(float)viewport[2],(float)viewport[3]); YsGLSLSet3DRendererPointSizeMode(renderer,YSGLSL_POINTSPRITE_SIZE_IN_3DSPACE); unitPtr->GetActualBuffer()->DrawPrimitiveVtxColPointSize(renderer,GL_POINTS); #ifdef GL_PROGRAM_POINT_SIZE glDisable(GL_PROGRAM_POINT_SIZE); glDisable(GL_POINT_SPRITE); #endif } } glDisable(GL_CULL_FACE); } if(YSTRUE==actuallyDrawOtherShell) { YsArray <const YsShellDnmContainer <YsShellExtEditGui>::Node *,16> allNode; shlGrp.GetNodePointerAll(allNode); for(YSSIZE_T nodeIdx=0; nodeIdx<allNode.GetN(); ++nodeIdx) { if(slHd!=allNode[nodeIdx]) { YsShellExtDrawingBuffer &buf=allNode[nodeIdx]->GetDrawingBuffer(); YsGLSLRenderer renderer(YsGLSLSharedFlat3DRenderer()); const GLfloat edgeCol[4]={0,0,0,0.2f}; YsGLSLSet3DRendererUniformColorfv(renderer,edgeCol); YsGLSLDrawPrimitiveVtxfv(renderer,GL_LINES,buf.normalEdgePosBuffer.GetNi(),buf.normalEdgePosBuffer); } } } }