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