void ApplinkExporter::WriteUVWTag(BaseFile* objfile, ExportObject& mObject, LONG pcnt, const CPolygon* padr)
{
//GePrint("Length UV: " + RealToString(pUV->GetLength()));
/* for(t = 0; t < pcnt*4; t++)
{
GePrint(LongToString(t) + ": " + RealToString(pUV[t].x) + ", " + RealToString(pUV[t].y) );
}*/
String str = "# begin " + LongToString(mObject.Vt.GetCount()) + " texture vertices\n";
this->WriteString(str, objfile);
for(LONG t = 0, y=0; t < pcnt; t++)
{
str = "vt " + RealToString(mObject.Vt[y].x, NULL, 6) + " " + RealToString( 1 - mObject.Vt[y].y, NULL, 6) + " " + RealToString(mObject.Vt[y].z, NULL, 6) + "\n";
this->WriteString(str, objfile);
str = "vt " + RealToString(mObject.Vt[y+1].x, NULL, 6) + " " + RealToString(1 - mObject.Vt[y+1].y, NULL, 6) + " " + RealToString(mObject.Vt[y+1].z, NULL, 6) + "\n";
this->WriteString(str, objfile);
str = "vt " + RealToString(mObject.Vt[y+2].x, NULL, 6) + " " + RealToString(1 - mObject.Vt[y+2].y, NULL, 6) + " " + RealToString(mObject.Vt[y+2].z, NULL, 6) + "\n";
this->WriteString(str, objfile);
if(mObject.Fpvnb[t] == 4)
{
str = "vt " + RealToString(mObject.Vt[y+3].x, NULL, 6) + " " + RealToString(1 - mObject.Vt[y+3].y, NULL, 6) + " " + RealToString(mObject.Vt[y+3].z, NULL, 6) + "\n";
this->WriteString(str, objfile);
}
y += mObject.Fpvnb[t];
}
str = "# end " + LongToString(mObject.Vt.GetCount()) + " texture vertices\n";
this->WriteString(str, objfile);
this->WriteEndLine(objfile);
}
std::string PatchCsFullForEnd1::_code(const std::string &table_name) const
{
FUNCTION_TRACE;
bool coverage_count=option().coverage_count!=0;
if (coverage_count)
return " )?"+table_name+".IncrementTrue("+LongToString(offset())+"):"+table_name+".IncrementFalse("+LongToString(offset()+1)+"))";
else
return " )?"+table_name+".SetTrue("+LongToString(offset())+"):"+table_name+".SetFalse("+LongToString(offset()+1)+"))";
}
std::string PatchCppFullIfThenStart1::code(const std::string &table_name) const
{
FUNCTION_TRACE;
bool coverage_count=option().coverage_count!=0;
if (coverage_count)
return " { "+std::string(table_name)+"["+LongToString(offset())+"]++; ";
else
return " { "+std::string(table_name)+"["+LongToString(offset())+"]=1; ";
}
std::string PatchCppSemiWhileEnd2::code(const std::string &table_name) const
{
FUNCTION_TRACE;
bool coverage_count=option().coverage_count!=0;
if (coverage_count)
return " } else { "+std::string(table_name)+"["+LongToString(offset())+"]++; break ; } ";
else
return " } else { "+std::string(table_name)+"["+LongToString(offset())+"]=1; break ; } ";
}
std::string PatchCsFullWhileStart2::_code(const std::string &table_name) const
{
FUNCTION_TRACE;
bool coverage_count=option().coverage_count!=0;
if (coverage_count)
return " { "+table_name+".val["+LongToString(offset())+"]++; ";
else
return " { "+table_name+".val["+LongToString(offset())+"]=1; ";
}
std::string PatchCppFalseOnlyConditionEnd::code(const std::string &table_name) const
{
FUNCTION_TRACE;
bool coverage_count=option().coverage_count!=0;
if (coverage_count)
return " )?(1):(("+std::string(table_name)+"["+LongToString(offset())+"]++),0))";
else
return " )?(1):(("+std::string(table_name)+"["+LongToString(offset())+"]=1),0))";
}
std::string PatchCppLabelEnd::code(const std::string &table_name) const
{
FUNCTION_TRACE;
bool coverage_count=option().coverage_count!=0;
if (coverage_count)
return " "+table_name+"["+LongToString(offset())+"]++; "+table_name+"_label:;";
else
return " "+table_name+"["+LongToString(offset())+"]=1; "+table_name+"_label:;";
}
void CLargeFileDlg::OnBnSelectFile_Clicked()
{
TCHAR szSortFilePath[_MAX_PATH];
OPENFILENAME ofn = { OPENFILENAME_SIZE_VERSION_400 };
ofn.hwndOwner = this->m_hWnd;
ofn.lpstrFilter = TEXT("*.*\0");
lstrcpy(szSortFilePath, TEXT("*.*"));
ofn.lpstrFile = szSortFilePath;
ofn.nMaxFile = _countof(szSortFilePath);
ofn.lpstrTitle = TEXT("Select file");
ofn.lpstrDefExt = L"dat";
ofn.lpstrFilter = L"*.* File (*.*)\0*.*\0";
ofn.Flags = OFN_EXPLORER | OFN_FILEMUSTEXIST;
BOOL bOk = GetOpenFileName(&ofn);
if (bOk)
{
m_FilePath.SetWindowTextW(szSortFilePath);
LARGE_INTEGER *liFileSize = new LARGE_INTEGER();
HANDLE hFile = CreateFile(
(LPCWSTR)szSortFilePath, // file to open
GENERIC_READ, // open for reading
FILE_SHARE_READ, // share for reading
NULL, // default security
OPEN_EXISTING, // existing file only
FILE_ATTRIBUTE_NORMAL, // overlapped operation //| FILE_FLAG_NO_BUFFERING
NULL); // no attr. template
if (INVALID_HANDLE_VALUE==hFile)
{
ShowMB(L"Cannot create Handle file %s", szSortFilePath);
return;
}
if (!GetFileSizeEx(hFile, liFileSize))
{
ShowMB(L"Cannot get size of file %s", szSortFilePath);
return;
}
m_FileSize.SetWindowTextW(LongToString(liFileSize->QuadPart, L"%d"));
DWORD totalPage = chROUNDUP(liFileSize->QuadPart, 4096) / 4096;
m_TotalPage.SetWindowTextW(LongToString(totalPage, L"%d"));
CloseHandle(hFile);
}
m_btExecute.EnableWindow(bOk);
m_btTupleCount.EnableWindow(bOk);
}
/// ***************************************************************************
/// ***************************************************************************
Bool RegisterContainerObject(Bool menu)
{
if (menu) {
BaseContainer* menu = nullptr;
FindMenuResource("M_EDITOR", "IDS_MENU_OBJECT", &menu);
if (menu) {
menu->InsData(MENURESOURCE_SEPERATOR, true);
menu->InsData(MENURESOURCE_COMMAND, "PLUGIN_CMD_" + LongToString(Ocontainer));
}
return true;
}
_orig_GetInfo = C4DOS.Bo->GetInfo;
C4DOS.Bo->GetInfo = _hook_GetInfo;
AutoAlloc<BaseBitmap> bmp;
bmp->Init(GeGetPluginPath() + "res" + "img" + "ocontainer.png");
return RegisterObjectPlugin(
Ocontainer,
GeLoadString(IDS_OCONTAINER),
OBJECT_GENERATOR,
ContainerObject::Alloc,
"Ocontainer",
bmp,
CONTAINEROBJECT_DISKLEVEL);
}
void ApplinkExporter::WriteVertexPositions(BaseFile* objfile, ExportObject& mObject, LONG vcnt)
{
String str = "# begin " + LongToString(vcnt) + " vertices\n";
this->WriteString(str, objfile);
//GePrint("Fv count: " + LongToString(Fv.GetCount()));
//for (p = 0; p < Fv.GetCount(); p++)
//{
// GePrint(LongToString(Fv[p]));
//}
for (LONG p = 0; p < mObject.Vp.GetCount(); p++)
{
str = "v " + RealToString(mObject.Vp[p].x, NULL, 6) + " " + RealToString(mObject.Vp[p].y, NULL, 6) + " " + RealToString(mObject.Vp[p].z, NULL, 6) + "\n";
this->WriteString(str, objfile);
}
str = "# end " + LongToString(vcnt) + " vertices\n";
this->WriteString(str, objfile);
this->WriteEndLine(objfile);
}
void XmlNewPrepareXML(XmlNew xmlNew)
{
char* CurrentIdNew;
xmlNew->XmlStructure = Replace(xmlNew->XmlStructure, "$newsgroup", xmlNew->CurrentNew.NewsGroup);
CurrentIdNew = LongToString(xmlNew->CurrentNew.IdNew);
xmlNew->XmlStructure = Replace(xmlNew->XmlStructure, "$idNoticia", CurrentIdNew);
xmlNew->XmlStructure = Replace(xmlNew->XmlStructure, "$HEAD", xmlNew->CurrentNew.Head);
xmlNew->XmlStructure = Replace(xmlNew->XmlStructure, "$BODY", xmlNew->CurrentNew.Body);
LogFileLogEntry(MAINPROCESSNAME, NOTHREADID, LOGTYPEINFO, "Se preparó el siguente xml: ", xmlNew->XmlStructure);
MemFree(CurrentIdNew);
}
String CSVNodeData::GetTableColumnPortName(LONG column) const {
if (!m_table.Loaded() || column < 0) {
return GeLoadString(IDC_CSVNODE_INVALIDPORT);
}
String prefix = GeLoadString(IDC_CSVNODE_TABLECOLUMN_PREFIX);
const CSVRow& header = m_table.GetHeader();
if (column < header.GetCount()) {
return prefix + header[column];
}
else {
return prefix + LongToString(column + 1);
}
}
bool wxIntegerFormValidator::OnDisplayValue( wxProperty *property, wxPropertyFormView *WXUNUSED(view),
wxWindow *WXUNUSED(parentWindow))
{
// The item used for viewing the real number: should be a text item or a slider
wxWindow *m_propertyWindow = property->GetWindow();
if (!m_propertyWindow)
return false;
if (m_propertyWindow->IsKindOf(CLASSINFO(wxTextCtrl)))
{
wxTextCtrl *textItem = (wxTextCtrl *)m_propertyWindow;
textItem->SetValue(LongToString(property->GetValue().IntegerValue()));
}
else if (m_propertyWindow->IsKindOf(CLASSINFO(wxSlider)))
{
((wxSlider *)m_propertyWindow)->SetValue((int)property->GetValue().IntegerValue());
}
else
return false;
return true;
}
SplineObject* Voxelify::ComputeSpline(BaseThread* bt, vector<VGrid> grids, LONG longestPercent, GeDynamicArray<GeDynamicArray<Vector> > &splinesAtPoint){
SplineObject* parentSpline = SplineObject::Alloc(0, SPLINETYPE_BSPLINE);
std::vector<SplinePair >splinePairs;
Real avSplineSize = 0.0, avSplineLength = 0.0;
GeDynamicArray<GeDynamicArray<LONG> > validPoints(grids.size());
for (LONG k=0; k < grids.size(); k++){
validPoints[k] = GeDynamicArray<LONG>(grids[0].points.size());
validPoints[k].Fill(0,grids[0].points.size(),1);
}
GeDynamicArray<LONG> indxs;
for (LONG i = 0; i < grids[0].points.size(); i++) {
if (grids[0].indices[i] == -1) continue;
GeDynamicArray<Vector> rawSpline;
Vector point(grids[0].points[i][0], grids[0].points[i][1], grids[0].points[i][2]);
indxs.Push(i);
rawSpline.Push(point);
splinesAtPoint.Push(rawSpline);
}
Real distMin = std::numeric_limits<float>::max();
Real distMax = 0.;
AutoAlloc<SplineHelp> splineHelp;
LONG i, o;
for (i = 0; i < splinesAtPoint.GetCount(); i++){//iterate points
bool lastPointCaptured = true;
LONG indx = indxs[i];
for (o=0; o < grids.size()-1; o++){ // for each point iterate objects and collect nearest points
LONG closestIndx = grids[o+1].indices[indx];
if ( closestIndx == -1){
GePrint("error finding neighbor "+LongToString(o)+"/"+LongToString(i));
if (o == grids.size()-1){
lastPointCaptured = false;
}
continue;
}
vector<float> point = grids[o].points[indx];
vector<float> point1 = grids[o+1].points[indx];
Real dist = hypot(point[0] - point1[0], hypot(point[1] - point1[1], point[2] - point1[2]));
distMin = distMin < dist ? distMin : dist;
distMax = distMax > dist ? distMax : dist;
if (o != grids.size()-1) {
//if (dist > maxSeg || dist < minSeg) {
// continue;
//}
}
validPoints[o][i] = 0;
Vector clsst(point1[0],point1[1],point1[2]);
if (splinesAtPoint[i].Find(clsst) == NOTOK){
splinesAtPoint[i].Push(clsst);
}
}
if (!lastPointCaptured) continue;
SplineObject* spline=SplineObject::Alloc(splinesAtPoint[i].GetCount(),SPLINETYPE_BSPLINE);
if (!spline) continue;
spline->GetDataInstance()->SetBool(SPLINEOBJECT_CLOSED, FALSE);
Vector *padr = spline->GetPointW();
for (LONG l = 0; l < splinesAtPoint[i].GetCount(); l++){
padr[l] = splinesAtPoint[i][l];
}
splineHelp->InitSpline(spline);
Real splnLength = splineHelp->GetSplineLength();
if (splnLength > 0.0){
splinePairs.push_back(SplinePair(spline, splnLength));
avSplineLength += splnLength;
avSplineSize += splinesAtPoint[i].GetCount();
} else {
SplineObject::Free(spline);
}
if (i % 5 == 0){
LONG progress = 10 + (90*i)/splinesAtPoint.GetCount();
StatusSetBar(progress);
StatusSetText(LongToString(progress)+"%");
if (bt && bt->TestBreak()){
//break; //this break seems to be kicking in randomly killing the loop
}
}
}
LONG splnSize = splinePairs.size();
GePrint(LongToString(i)+" points "+LongToString(splnSize)+" splines");
if (splnSize > 0) {
LONG limit = splnSize * longestPercent / 100;
limit = limit == 0 ? 1 : limit;
std::sort(splinePairs.begin(), splinePairs.end(),comparator);
for (int s = 0; s < limit; s++){
avSplineLength += splinePairs[s].second;
splinePairs[s].first->InsertUnder(parentSpline);
}
String sizeAvg = splinesAtPoint.GetCount() == 0? "Nan":RealToString(avSplineSize/splinesAtPoint.GetCount());
GePrint("d="+RealToString(distMin)+" : "+RealToString(distMax)+" avSpln="+RealToString(avSplineLength/avSplineSize));
}
StatusSetText(LongToString(i)+" points "+LongToString(splnSize)+" splines");
if (splnSize == 0) return NULL;
return parentSpline;
}
void CRTF_HTMLConverter::R2H_InterpretTag(const CString& strRTFTag)
{
CString strTestTag;
CHTMLElement* pElement = NULL;
//Char attributes
if (strRTFTag == _T("b"))
{
pElement = new CHTMLElement(CHTMLElement::c_nodHTMLBegin, _T("b"));
}
else if (strRTFTag == _T("b0"))
{
pElement = new CHTMLElement(CHTMLElement::c_nodHTMLEnd, _T("b"));
}
else if (strRTFTag == _T("i"))
{
pElement = new CHTMLElement(CHTMLElement::c_nodHTMLBegin, _T("i"));
}
else if (strRTFTag == _T("i0"))
{
pElement = new CHTMLElement(CHTMLElement::c_nodHTMLEnd, _T("i"));
}
else if (strRTFTag == _T("ul"))
{
pElement = new CHTMLElement(CHTMLElement::c_nodHTMLBegin, _T("u"));
}
else if (strRTFTag == _T("ulnone"))
{
pElement = new CHTMLElement(CHTMLElement::c_nodHTMLEnd, _T("u"));
}
else
{
pElement = new CHTMLElement();
}
//Special character (umlaut)
strTestTag = _T("\'");
if ((pElement->m_enNodeType == CHTMLElement::c_nodInvalid) && (strRTFTag.GetLength() >= strTestTag.GetLength()) &&
(strRTFTag.Left(strTestTag.GetLength()) == strTestTag))
{
CString strSpecialChar = strRTFTag;
strSpecialChar.Delete(0, strTestTag.GetLength());
ASSERT(strSpecialChar.GetLength() == 2); //Invalid RTF (must be 2-digit hex code)
strSpecialChar = strSpecialChar.Left(2);
pElement->m_enNodeType = CHTMLElement::c_nodText;
pElement->m_strNodeText = _T("&#x") + strSpecialChar + _T(";");
}
//Paragraph Tag
if ((pElement->m_enNodeType == CHTMLElement::c_nodInvalid) && (strRTFTag == _T("par")))
{
long lLastUnclosedPStart = -1;
//Look if we first must close paragraph
for (int iLastElements = m_arrHTMLElements.GetSize() - 1; iLastElements >= 0; iLastElements--)
{
/*
CHTMLElement* pElementTest = m_arrHTMLElements[iLastElements];
if ((pElementTest->m_enNodeType==CHTMLElement::c_nodHTMLEnd)&&(pElementTest->m_strNodeText=="p")) break; //everything is OK
if ((pElementTest->m_enNodeType==CHTMLElement::c_nodHTMLBegin)&&(pElementTest->m_strNodeText=="p"))
{
lLastUnclosedPStart=iLastElements;
break; //everything is OK
}
*/
}
if (lLastUnclosedPStart >= 0)
{
//Look if there is no text between last <p> and this <p-end> (e.g. <p></p>)
//HTML does then not display a linefeed, therefore make it to <p> </p>
BOOL bLastParaEmpty = TRUE;
for (int iLastPara = lLastUnclosedPStart; iLastPara < m_arrHTMLElements.GetSize(); iLastPara++)
{
CHTMLElement* pElementTest = m_arrHTMLElements[iLastPara];
if (pElementTest->m_enNodeType == CHTMLElement::c_nodText)
{
if ((pElementTest->m_strNodeText != _T("")) &&
(pElementTest->m_strNodeText != _T("\r")) &&
(pElementTest->m_strNodeText != _T("\n")) &&
(pElementTest->m_strNodeText != _T("\r\n")) &&
(pElementTest->m_strNodeText != _T("b")))
{
bLastParaEmpty = FALSE;
}
}
}
}
//Add paragraph tag (<p>
pElement->m_enNodeType = CHTMLElement::c_nodHTMLBegin;
pElement->m_strNodeText = _T("br");
// pElement->m_strNodeText = "p";
}
// else Unknown RTF tag, just ignore
//Paragraph Alignment
strTestTag = _T("q");
if ((pElement->m_enNodeType == CHTMLElement::c_nodInvalid) && (strRTFTag.GetLength() >= strTestTag.GetLength()) &&
(strRTFTag.Left(strTestTag.GetLength()) == strTestTag))
{
//Get RTF alignment
CString strAlignRTF, strAlignHTML;
pElement->m_enNodeType = CHTMLElement::c_nodHTMLBegin;
pElement->m_strNodeText = _T("font");
strAlignRTF = strRTFTag;
strAlignRTF.Delete(0, strTestTag.GetLength());
ASSERT(strAlignRTF.GetLength() == 1); //Invalid RTF
//Convert RTF options to HTML options
if (strAlignRTF == _T("l"))
{
strAlignHTML = _T("left");
}
else if (strAlignRTF == _T("r"))
{
strAlignHTML = _T("right");
}
else if (strAlignRTF == _T("c"))
{
strAlignHTML = _T("center");
}
else
{
; //unsupported
}
//Find last paragraph
long lLastParaStart = -1;
for (int iLastElements = m_arrHTMLElements.GetSize() - 1; iLastElements >= 0; iLastElements--)
{
CHTMLElement* pElementTest = m_arrHTMLElements[iLastElements];
if ((pElementTest->m_enNodeType == CHTMLElement::c_nodHTMLBegin) && (pElementTest->m_strNodeText == _T("p")))
{
lLastParaStart = iLastElements;
break; //everything is OK
}
}
if ((lLastParaStart >= 0) && (strAlignHTML != _T("")))
{
CHTMLElement* pElementPara = m_arrHTMLElements[lLastParaStart];
pElementPara->m_mapParams.SetAt(_T("align"), _T("\"") + strAlignHTML + _T("\""));
}
}
//font color
strTestTag = _T("cf");
if ((pElement->m_enNodeType == CHTMLElement::c_nodInvalid) && (strRTFTag.GetLength() >= strTestTag.GetLength()) &&
(strRTFTag.Left(strTestTag.GetLength()) == strTestTag))
{
CString strActColor;
pElement->m_enNodeType = CHTMLElement::c_nodHTMLBegin;
pElement->m_strNodeText = _T("font");
strActColor = strRTFTag;
strActColor.Delete(0, strTestTag.GetLength());
ASSERT(strActColor.GetLength() > 0); //Invalid RTF
long lActColor = StringToLong(strActColor);
ASSERT(lActColor < m_arrColors.GetSize()); //Color not in Colortable !
if (lActColor < m_arrColors.GetSize())
{
DWORD r = 0, g = 0, b = 0;
COLORREF ref = m_arrColors[lActColor];
r = GetRValue(ref);
g = GetGValue(ref);
b = GetBValue(ref);
CString strHTMLColor;
strHTMLColor.Format(_T("#%02x%02x%02x"), r, g, b);
m_strActFontColor = strHTMLColor;
}
}
//font size
strTestTag = _T("fs");
if ((pElement->m_enNodeType == CHTMLElement::c_nodInvalid) && (strRTFTag.GetLength() >= strTestTag.GetLength()) &&
(strRTFTag.Left(strTestTag.GetLength()) == strTestTag))
{
pElement->m_enNodeType = CHTMLElement::c_nodHTMLBegin;
pElement->m_strNodeText = _T("font");
m_strActFontSize = strRTFTag;
m_strActFontSize.Delete(0, strTestTag.GetLength());
ASSERT(m_strActFontSize.GetLength() > 0); //Invalid RTF
m_strActFontSize = LongToString(StringToLong(m_strActFontSize) / 2); //RTF stores the doubled font size
}
//font name
strTestTag = _T("f"); //f+number
if ((pElement->m_enNodeType == CHTMLElement::c_nodInvalid) && (strRTFTag.GetLength() >= strTestTag.GetLength()) &&
(strRTFTag.Left(strTestTag.GetLength()) == strTestTag) &&
(strRTFTag.Mid(1).SpanIncluding(_T("01234567890")) == strRTFTag.Mid(1)))
{
CString strActFontDsgn = strRTFTag;
pElement->m_enNodeType = CHTMLElement::c_nodHTMLBegin;
pElement->m_strNodeText = _T("font");
ASSERT(strActFontDsgn.GetLength() > 0); //Invalid RTF
CString strActFontName;
BOOL bFound = m_mapFontNames.Lookup(strActFontDsgn, strActFontName);
ASSERT(bFound); //Font not found in font table, don't change font
if (bFound)
{
m_strActFontName = strActFontName;
}
}
//New font tag ?
if ((pElement->m_enNodeType == CHTMLElement::c_nodHTMLBegin) && (pElement->m_strNodeText == _T("font")))
{
BOOL bMustClose = FALSE;
//Look if we first must close paragraph
for (int iLastElements = m_arrHTMLElements.GetSize() - 1; iLastElements >= 0; iLastElements--)
{
CHTMLElement* pElementTest = m_arrHTMLElements[iLastElements];
if ((pElementTest->m_enNodeType == CHTMLElement::c_nodHTMLEnd) && (pElementTest->m_strNodeText == _T("font")))
{
break; //everything is OK
}
if ((pElementTest->m_enNodeType == CHTMLElement::c_nodHTMLBegin) &&
(pElementTest->m_strNodeText == _T("font")))
{
bMustClose = TRUE;
break; //everything is OK
}
}
if (bMustClose)
{
//Insert Closing </p>
CHTMLElement* pElementClose = new CHTMLElement();
pElementClose->m_enNodeType = CHTMLElement::c_nodHTMLEnd;
pElementClose->m_strNodeText = _T("font");
m_arrHTMLElements.Add(pElementClose);
}
//Set font tag options
pElement->m_mapParams.SetAt(_T("color"), _T("\"") + m_strActFontColor + _T("\""));
pElement->m_mapParams.SetAt(_T("style"), _T("\"font-size: ") + m_strActFontSize + _T("pt; font-family:") +
m_strActFontName + _T(";\""));
}
if (pElement->m_enNodeType != CHTMLElement::c_nodInvalid)
{
m_arrHTMLElements.Add(pElement);
}
else
{
delete pElement;
}
}
// go through every (child) object
static Bool Recurse(HierarchyHelp *hh, BaseThread *bt, BaseObject *main, BaseObject *op, const Matrix &ml, Real srad, Real crad, LONG sub, Bool single)
{
// test if input object if polygonal
if (op->GetType()==Opolygon)
{
BaseObject *tp = NULL;
PolyInfo *pli = NULL;
const Vector *padr = ToPoly(op)->GetPointR();
Vector pa,pb;
LONG pcnt = ToPoly(op)->GetPointCount(),i,side,a=0,b=0;
const CPolygon *vadr = ToPoly(op)->GetPolygonR();
LONG vcnt = ToPoly(op)->GetPolygonCount();
Matrix m;
Neighbor n;
// load names from resource
String pstr = GeLoadString(IDS_ATOM_POINT);
String estr = GeLoadString(IDS_ATOM_EDGE);
// initialize neighbor class
if (!n.Init(pcnt,vadr,vcnt,NULL)) return FALSE;
// create separate objects
// if this option is enabled no polygonal geometry is build - more parametric objects
// are returned instead
if (single)
{
for (i=0; i<pcnt; i++)
{
// alloc sphere primitive
tp=BaseObject::Alloc(Osphere);
if (!tp) return FALSE;
// add phong tag
if (!tp->MakeTag(Tphong)) return FALSE;
tp->SetName(pstr+" "+LongToString(i));
// set object parameters
BaseContainer *bc = tp->GetDataInstance();
bc->SetReal(PRIM_SPHERE_RAD,srad);
bc->SetReal(PRIM_SPHERE_SUB,sub);
// insert as last object under main
tp->InsertUnderLast(main);
// set position in local coordinates
tp->SetRelPos(padr[i]*ml);
}
for (i=0; i<vcnt; i++)
{
// get polygon info for i-th polygon
pli = n.GetPolyInfo(i);
for (side=0; side<4; side++)
{
// only proceed if edge has not already been processed
// and edge really exists (for triangles side 2 from c..d does not exist as c==d)
if (pli->mark[side] || side==2 && vadr[i].c==vadr[i].d) continue;
// alloc cylinder primitive
tp=BaseObject::Alloc(Ocylinder);
if (!tp) return FALSE;
// add phong tag
if (!tp->MakeTag(Tphong)) return FALSE;
switch (side)
{
case 0: a=vadr[i].a; b=vadr[i].b; break;
case 1: a=vadr[i].b; b=vadr[i].c; break;
case 2: a=vadr[i].c; b=vadr[i].d; break;
case 3: a=vadr[i].d; b=vadr[i].a; break;
}
tp->SetName(estr+" "+LongToString(pli->edge[side]));
pa = padr[a]*ml;
pb = padr[b]*ml;
// set object parameters
BaseContainer *bc = tp->GetDataInstance();
bc->SetReal(PRIM_CYLINDER_RADIUS,crad);
bc->SetReal(PRIM_CYLINDER_HEIGHT,Len(pb-pa));
bc->SetReal(PRIM_AXIS,4);
bc->SetLong(PRIM_CYLINDER_CAPS,FALSE);
bc->SetLong(PRIM_CYLINDER_HSUB,1);
bc->SetLong(PRIM_CYLINDER_SEG,sub);
// place cylinder at edge center
tp->SetRelPos((pa+pb)*0.5);
// build edge matrix
m.v3=!(pb-pa);
RectangularSystem(m.v3,&m.v1,&m.v2);
tp->SetRelRot(MatrixToHPB(m, tp->GetRotationOrder()));
// insert as last object under main
tp->InsertUnderLast(main);
}
}
}
else
{
// check if polygonal geometry has to be built
tp = BuildPolyHull(ToPoly(op),ml,srad,crad,sub,hh->GetLOD(),&n,bt);
if (tp)
{
tp->SetName(op->GetName());
tp->InsertUnderLast(main);
// check if isoparm geometry has to be built
if (hh->GetBuildFlags()&BUILDFLAGS_ISOPARM)
{
LineObject *ip = BuildIsoHull(ToPoly(op),ml,srad,crad,sub,hh->GetLOD(),&n,bt);
// isoparm always needs to be set into a polygon object
if (ip) tp->SetIsoparm(ip);
}
}
}
}
for (op=op->GetDown(); op; op=op->GetNext())
if (!Recurse(hh,bt,main,op,ml*op->GetMl(),srad,crad,sub,single)) return FALSE;
// check for user break
return !bt || !bt->TestBreak();
}
Bool ListViewDialog::Command(LONG id,const BaseContainer &msg)
{
switch (id)
{
case GADGET_LISTVIEW1:
case GADGET_LISTVIEW2:
{
switch (msg.GetLong(BFM_ACTION_VALUE))
{
case LV_SIMPLE_SELECTIONCHANGED:
GePrintF("Selection changed, id: %d, val: %p ",msg.GetLong(LV_SIMPLE_ITEM_ID),msg.GetVoid(LV_SIMPLE_DATA));
break;
case LV_SIMPLE_CHECKBOXCHANGED:
GePrintF("CheckBox changed, id: %d, col: %d, val: %p",msg.GetLong(LV_SIMPLE_ITEM_ID),msg.GetLong(LV_SIMPLE_COL_ID),msg.GetVoid(LV_SIMPLE_DATA));
break;
case LV_SIMPLE_FOCUSITEM:
GePrintF("Focus set id: %d, col: %d",msg.GetLong(LV_SIMPLE_ITEM_ID),msg.GetLong(LV_SIMPLE_COL_ID));
break;
case LV_SIMPLE_BUTTONCLICK:
GePrintF("Button clicked id: %d, col: %d",msg.GetLong(LV_SIMPLE_ITEM_ID),msg.GetLong(LV_SIMPLE_COL_ID));
break;
}
}
UpdateButtons();
break;
// case GADGET_LISTVIEW2:
// break;
case GADGET_INSERT:
{
AutoAlloc<BaseSelect> s2;
if (selection && s2)
{
// TEST
LONG i,id,count = listview1.GetItemCount();
BaseContainer test;
for (i=0;i<count;i++)
{
listview1.GetItemLine(i,&id,&test);
}
// TEST
if (!listview1.GetSelection(selection))
{
GePrint("No Selection");
}
else
{
LONG i,a,b;
String str;
for (i=0;selection->GetRange(i,MAXLONGl,&a,&b);i++)
{
if (a==b) str += LongToString(a)+" ";
else str += LongToString(a)+"-"+LongToString(b)+" ";
}
// str.Delete(str.GetLength()-1,1);
GePrint("Selection: "+str);
BaseContainer data;
for (i=0;testdata[i].id;i++)
{
if (selection->IsSelected(testdata[i].id))
{
data.SetLong('chck',TRUE);
data.SetString('name',testdata[i].name);
data.SetString('bttn',"...");
selection->Select(counter2);
listview2.SetItem(counter2++,data);
}
}
listview2.SetSelection(selection);
listview2.DataChanged();
}
}
}
UpdateButtons();
break;
case GADGET_REMOVE:
{
if (selection && listview2.GetSelection(selection))
{
LONG i,a,b;
for (i=0;selection->GetRange(i,MAXLONGl,&a,&b);i++)
{
for (;a<=b;a++)
{
listview2.RemoveItem(a);
}
}
listview2.DataChanged();
}
}
UpdateButtons();
break;
}
return TRUE;
}
//*****************************************************************************
//
// Main Program
//
//*****************************************************************************
int main(int argc, const char **argv)
{
int iDrive = 0;
unsigned int iNumDrives;
PSTR pchTemp = NULL;
#ifdef _DOS
setvbuf(stdout, NULL, _IONBF, 0);
#endif
usFirstDisk = fSwitches = 0;
DisplayMessage(IDS_EGOLINE, VERSION);
ParseEnvironmentOptions("QF_OPT");
if (!(parms(&argc, (const PPSTR) argv + 1) - 1))
usage(TRUE);
else
argv++;
#ifndef _WINDOWS
signal(SIGINT, c_break); // set ctrl-break handler
#endif
#if !defined(_WINDOWS) && !defined(__OS2__) && !defined(WIN32)
_harderr(handler); // set hardware error handler
#endif
// get original drive and directory ...
_dos_getdrive(&usFirstDisk);
getcwd(szOriginalPath, sizeof(szOriginalPath));
_dos_setdrive(usFirstDisk, (unsigned int *) &iNumDrives);
splitfilespec((char *) strupr((char *) *argv), szFileName, (unsigned int *) &iDrive);
if (!isvalid(iDrive) || bError) // invalid drive specified.
{
BELL();
DisplayMessage(IDS_INVALIDDRIVE);
exit(1);
}
if ((fSwitches & DELETEFILE) && (fSwitches & NOPROMPT))
if (!ShowNoPromptMessage(iDrive, szFileName))
c_break(0);
if (fSwitches & ALLDRIVES) {
for (iDrive = 1; iDrive <= floppies(); iDrive++) {
if (isvalid(iDrive) && !bError) {
_dos_setdrive(iDrive, &iNumDrives);
walkdirs("\\", 0, filefind);
}
if (bError)
bError = FALSE;
}
for (floppies() + 1; iDrive <= iNumDrives; iDrive++) {
if (isvalid(iDrive) && !bError) {
_dos_setdrive(iDrive, &iNumDrives);
getcwd(curdir, sizeof(curdir)); // save current directory on
walkdirs("\\", 0, filefind); // alternate drives
chdir(curdir);
}
if (bError)
bError = FALSE;
}
} else {
_dos_setdrive(iDrive, &iNumDrives);
getcwd(curdir, sizeof(curdir)); // save current directory on alternate drives
if (fSwitches & FROM_CURDIR) // Only search current directory and subdirs
walkdirs(szOriginalPath, 1, filefind);
else
walkdirs("\\", 0, filefind);
chdir(curdir);
}
_dos_setdrive(usFirstDisk, &iNumDrives);
chdir(szOriginalPath);
// print totals
if (!(fSwitches & NOFILEINFO)) {
if (fSwitches & SUBDIRTOT) {
if (ulDirs || ulTotal) {
PSTR pchNumFiles = NULL;
printf("\n ================ ===========\n");
pchTemp = LongToString(ulTotalFileSize, pchTemp, 11, LTS_PADLEFT);
pchNumFiles = LongToString(ulTotal + ulDirs, NULL, 16, LTS_PADLEFT);
printf
(" %s %s total files/bytes in all directories\n",
pchNumFiles, pchTemp);
if (pchNumFiles)
free(pchNumFiles);
usLineCount += 3;
}
}
if (ulDirs || ulTotal) {
printf("\n");
if (ulDirs) {
pchTemp = LongToString(ulDirs, pchTemp, 11, LTS_PADLEFT);
printf(" %s directory(s) found.\n", pchTemp);
}
pchTemp = LongToString(ulTotal, pchTemp, 11, LTS_PADLEFT);
printf(" %s file(s) found.\n", pchTemp);
} else
printf("\nNo files found.\n");
if ((fSwitches & DELETEFILE) && ulTotal) {
pchTemp = LongToString((LONG) nDeleted, pchTemp, 11, LTS_PADLEFT);
printf(" %s file(s) deleted.\n", pchTemp);
}
if (fSwitches & LOG) {
unassign();
printf(" done.");
}
}
// free the memory that MIGHT have been allocated by LongToString.
if (pchTemp)
free(pchTemp);
return (0);
}
/******************************************************************************
*
* Name: filefind
* Synopsis: int filefind(filespec);
* PSTR filespec; name of file to search for
*
* Description: Searches directory for filespec
*
*
* Returns: Number of files found.
*
*****************************************************************************/
int PASCAL filefind(PSTR szFileName)
{
FILESTUFF fs;
int bDone, iFound = 0, temp = 0, bPrinted = 0;
char dir[MAXPATH], tempstr[MAXPATH];
PSTR pchNumFound = NULL;
PSTR pch = NULL;
struct _find_t ffblk;
memset(&fs, 0, sizeof(fs));
ulSubTotal = 0;
if (!(fSwitches & (COMPRESSED | COMPRESSED_ONLY)))
bDone = _dos_findfirst(szFileName, S_ATTR, &ffblk);
else
bDone = _dos_findfirst("*.*", S_ATTR, &ffblk);
while (!bDone) {
fs.byType = 0;
if (*ffblk.name == '.' && (ffblk.attrib & _A_SUBDIR)) {
bDone = _dos_findnext(&ffblk);
continue;
}
strcpy(fs.szName, ffblk.name); // fill in fs structure
*fs.szArchiveName = 0;
fs.ulSize = ffblk.size;
#ifndef WIN32
fs.usDate = ffblk.wr_date;
fs.usTime = ffblk.wr_time;
#else
{
DOSDATETIME filetime;
struct tm *tm;
tm = localtime(&ffblk.time_write);
filetime.date.iMonth = tm->tm_mon + 1;
filetime.date.iDay = tm->tm_mday;
filetime.date.iYear = tm->tm_year - 80;
fs.usDate = filetime.iValue;
filetime.time.iTwoSecs = tm->tm_sec;
filetime.time.iMinutes = tm->tm_min;
filetime.time.iHours = tm->tm_hour;
fs.usTime = filetime.iValue;
}
#endif
if (ffblk.attrib & _A_SUBDIR)
fs.byType |= FS_DIRECTORY;
if (!(fSwitches & COMPRESSED_ONLY)) {
if (Match(szFileName, ffblk.name)) {
if (++iFound == 1) {
if (!bPrinted) {
DisplayMessage(IDS_DIRECTORYLINE, getcwd(dir, MAXPATH));
bPrinted++;
usLineCount += 2;
}
}
if (!(fs.byType & FS_MAINARCHIVE))
ShowFileInfo(&fs);
if ((fSwitches & DELETEFILE)
&& !(ffblk.attrib & _A_SUBDIR)) {
sprintf(tempstr,
(dir[strlen(dir) - 1] !=
'\\' ? "%s\\%s" : "%s%s"), dir, ffblk.name);
if (MaybeDelete(tempstr, !(fSwitches & NOPROMPT)))
nDeleted++;
}
if (ffblk.attrib & _A_SUBDIR) {
if (iFound > 0)
iFound--;
ulDirs++;
}
}
}
// search compressed files if specified ...
if (fSwitches & COMPRESSED || fSwitches & COMPRESSED_ONLY) {
LPFNARCHIVESEARCH lpfn = GetArchiveSearchFunction(ffblk.name);
if (lpfn) {
fs.byType |= FS_MAINARCHIVE;
strcpy(fs.szArchiveName, ffblk.name);
iFound += (*lpfn) (&fs, szFileName, &bPrinted);
}
}
bDone = _dos_findnext(&ffblk);
}
if ((fSwitches & SUBDIRTOT) && !(fSwitches & NOFILEINFO)) {
if (iFound > 0) {
printf(" ---------------- -----------\n");
pch = LongToString(ulSubTotal, NULL, 11, LTS_PADLEFT);
pchNumFound = LongToString((ULONG) iFound, NULL, 16, LTS_PADLEFT);
printf(" %s %s total bytes\n", pchNumFound, pch);
if (pch)
free(pch);
if (pchNumFound)
free(pchNumFound);
usLineCount += 2;
ulTotalFileSize += ulSubTotal;
}
}
return (iFound);
}
Bool ApplinkExporter::Execute(BaseDocument* document, BaseContainer* bc)
{
matDefault = BaseMaterial::Alloc(Mmaterial);
if(!matDefault) return false;
Filename fileObjPath;
fileObjPath.SetDirectory(bc->GetString(IDC_TMP_FOLDER));
fileObjPath.SetFile(document->GetDocumentName());
fileObjPath.SetSuffix("obj");
Filename fileObjOutPath;
fileObjOutPath.SetDirectory(bc->GetString(IDC_TMP_FOLDER));
fileObjOutPath.SetFile("output.obj");
Filename fileImport;
fileImport.SetDirectory(bc->GetString(IDC_EXCH_FOLDER));
fileImport.SetFile("import.txt");
GePrint(fileObjPath.GetString());
GePrint(fileObjOutPath.GetString());
GePrint(fileImport.GetString());
const Matrix tM(LVector(0.0f, 0.0f, 0.0f), LVector(1.0f, 0.0f, 0.0f), LVector(0.0f, 1.0f, 0.0f), LVector(0.0f, 0.0f, -1.0f));
//BaseDocument* doc = document->Polygonize();
AutoAlloc<AtomArray> oSel;
document->GetActiveObjects(oSel, GETACTIVEOBJECTFLAGS_0);
if(oSel->GetCount() > 0)
{
//Write import.txt//
AutoAlloc<BaseFile> basefileImport;
if (!basefileImport->Open(fileImport, FILEOPEN_WRITE, FILEDIALOG_NONE, GeGetByteOrder())) return FALSE;
this->WriteString(fileObjPath.GetString() + "\n", basefileImport);
this->WriteString(fileObjOutPath.GetString() + "\n", basefileImport);
this->WriteString(mapType(bc->GetLong(IDC_COMBO_MAP_TYPE)) + "\n", basefileImport);
Bool bSkipImp = bc->GetBool(IDC_CHK_SKIP_IMP_DIALOG);
if(bSkipImp)
{
this->WriteString("[SkipImport]\n", basefileImport);
}
Bool bSkipExp = bc->GetBool(IDC_CHK_SKIP_EXP_DIALOG);
if(bSkipExp)
{
this->WriteString("[SkipExport]\n", basefileImport);
}
GePrint(mapType(bc->GetLong(IDC_COMBO_MAP_TYPE)));
basefileImport->Close();
GePrint("File " + fileImport.GetString() + " write success!");
//Write file.obj//
AutoAlloc<BaseFile> objfile;
//if (!objfile) return FALSE;
if (!objfile->Open(fileObjPath, FILEOPEN_WRITE, FILEDIALOG_NONE, GeGetByteOrder())) return FALSE;
String str;
str = "#Wavefront OBJ Export for 3D-Coat\n";
this->WriteString(str, objfile);
DateTime t;
GetDateTimeNow(t);
str = "#File created: " + FormatTime("%d.%m.%Y %H:%M:%S", t) + "\n";
this->WriteString(str, objfile);
str = "#Cinema4D Version: " + LongToString(GetC4DVersion()) + "\n";
this->WriteString(str, objfile);
this->WriteEndLine(objfile);
Bool expMat = bc->GetBool(IDC_CHK_EXP_MAT);
vpcnt = vtcnt = 0;
for(int i = 0; i < oSel->GetCount(); i++)
{
StatusSetSpin();
PolygonObject* ob = (PolygonObject*) oSel->GetIndex(i);
if (ob->GetType() == Opolygon)
{
StatusSetText("Export object " + ob->GetName());
ExportObject mObject;
GePrint("Name " + ob->GetName());
//GePrint("Type " + LongToString(ob->GetType()));
if(expMat)
{
mObject.pmatidxArray.ReSize(ob->GetPolygonCount());
mObject.tempMats.ReSize(1);
mObject.pmatidxArray.Fill(0);
Bool haveMats = false;
//////////////////////////////////////////
for(BaseTag* tag = ob->GetFirstTag(); tag != NULL; tag = tag->GetNext())
{
LONG typ = tag->GetType();
if(typ == Ttexture)
{
if (!getParameterLink(*tag, TEXTURETAG_MATERIAL, Mbase)) continue;
haveMats = true;
TextureTag* txttag = (TextureTag*)tag;
BaseMaterial* material = txttag->GetMaterial();
if(material == NULL)
{
GePrint("Material not found on " + ob->GetName() + "object.");
return false;
}
//GePrint("Mat Name: " + material->GetName());
String restrict = getParameterString(*tag, TEXTURETAG_RESTRICTION);
if (restrict.Content())
{
mObject.tempMats.Push(material);
//GePrint("Selection: " + restrict);
for(BaseTag* seltag = ob->GetFirstTag(); seltag != NULL; seltag = seltag->GetNext())
{
LONG seltyp = seltag->GetType();
if(seltyp == Tpolygonselection && seltag->GetName() == restrict)
{
SelectionTag* selecttag = (SelectionTag*)seltag;
BaseSelect* sel = selecttag->GetBaseSelect();
//GePrint("sel data count: " + LongToString(sel->GetCount()));
LONG seg = 0, a, b, p;
while (sel->GetRange(seg++, &a, &b))
{
for (p = a; p <= b; ++p)
{
//GePrint("seltpolygon: " + LongToString(p));
mObject.pmatidxArray[p] = mObject.tempMats.GetCount()-1;
}
}
}
}
}
else
{
mObject.tempMats[0] = material;
mObject.pmatidxArray.Fill(0);
}
}
}
if(!mObject.tempMats[0])
{
matDefault->SetName("Default");
BaseChannel* color = matDefault->GetChannel(CHANNEL_COLOR);
if (!color) return false; // return some error
BaseContainer cdata = color->GetData();
cdata.SetVector(BASECHANNEL_COLOR_EX, Vector(1.0f, 1.0f, 1.0f));
//document->InsertMaterial(matDefault, NULL, FALSE);
//matDefault->Update(TRUE, TRUE);
//matDefault->Message(MSG_UPDATE);
mObject.tempMats[0] = matDefault;
//GePrint("Global material not found on object " + ob->GetName() + ".");
//return false;
}
if(haveMats)
{
//GePrint("mObject.tempMats.GetCount(): " + LongToString(mObject.tempMats.GetCount()));
for(LONG m = 0; m < mObject.tempMats.GetCount(); m++)
{
Bool inMats = false;
//GePrint("materialArray.GetCount(): " + LongToString(materialArray.GetCount()));
for(LONG n = 0; n < materialArray.GetCount(); n++)
{
if(mObject.tempMats[m]->GetName() == materialArray[n]->GetName())
{
inMats = true;
break;
}
}
if(!inMats)
{
materialArray.Push(mObject.tempMats[m]);
}
}
}
//String str1;
//for (LONG p = 0; p < ob->GetPolygonCount(); p++)
//{
// str1 += LongToString(mObject.pmatidxArray[p]) + ",";
//}
//GePrint(str1);
}
/////////////////////////////////////////////////
const Vector* vadr = ob->GetPointR();
const CPolygon* padr = ob->GetPolygonR();
LONG vcnt = ob->GetPointCount();
LONG pcnt = ob->GetPolygonCount();
mObject.Fpvnb.ReSize(pcnt);// poly counts
for(LONG p = 0; p < pcnt; p++)
{
if(padr[p].c != padr[p].d)
{
mObject.Fpvnb[p] = 4;
}
else
{
mObject.Fpvnb[p] = 3;
}
}
mObject.pVertexCount = PVertexLength(mObject);
//Vertex positions
mObject.Vp.ReSize(vcnt);
Matrix mg = tM * ob->GetMgn();
for (LONG v = 0; v < vcnt; v++)
{
mObject.Vp[v] = vadr[v] * mg;
//GePrint("Point[" + LongToString(i) + "] " + LongToString(padr[i].x) + ", " + LongToString(padr[i].y) + ", " + LongToString(padr[i].z));
//str = "v " + LongToString(vadr[p].x) + " " + LongToString(vadr[p].y) + " " + LongToString(vadr[p].z) + "\n";
//this->WriteString(str, objfile);
}
mObject.Fv.ReSize(mObject.pVertexCount);
LONG y=0;
for (LONG p = 0; p < pcnt; p++)
{
if(mObject.Fpvnb[p] == 4)
{
mObject.Fv[y] = padr[p].d;
mObject.Fv[y+1] = padr[p].c;
mObject.Fv[y+2] = padr[p].b;
mObject.Fv[y+3] = padr[p].a;
}
else
{
mObject.Fv[y] = padr[p].c;
mObject.Fv[y+1] = padr[p].b;
mObject.Fv[y+2] = padr[p].a;
}
y += mObject.Fpvnb[p];
}
//String str1;
//for (LONG p = 0; p < mObject.Fv.GetCount(); p++)
//{
// str1 += LongToString(mObject.Fv[p]) + " ";
//}
//GePrint(str1);
///////////////////////////////
///////////vertex UV
//////////////////////////////
if(bc->GetBool(IDC_CHK_EXP_UV))
{
// Get first UV tag (if at least one)
UVWTag* uvw_tag = (UVWTag*)ob->GetTag(Tuvw, 0);
if(!uvw_tag)
{
GePrint("Object \"" + ob->GetName() + "\" has no UVW tag.\nUV coordinates can't be exported.");
return FALSE;
}
else
{
mObject.Vt.ReSize(mObject.pVertexCount);
mObject.Fvt.ReSize(mObject.pVertexCount);
const UVWHandle dataptr = uvw_tag->GetDataAddressR();
UVWStruct res;
for(LONG t=0, y=0; t < pcnt; t++)
{
//GePrint("y: " + LongToString(y));
UVWTag::Get(dataptr, t, res);
if(mObject.Fpvnb[t] == 4)
{
mObject.Vt[y] = res.d;
mObject.Vt[y + 1] = res.c;
mObject.Vt[y + 2] = res.b;
mObject.Vt[y + 3] = res.a;
mObject.Fvt[y] = y;
mObject.Fvt[y + 1] = y + 1;
mObject.Fvt[y + 2] = y + 2;
mObject.Fvt[y + 3] = y + 3;
}
else
{
mObject.Vt[y] = res.c;
mObject.Vt[y + 1] = res.b;
mObject.Vt[y + 2] = res.a;
mObject.Fvt[y] = y;
mObject.Fvt[y + 1] = y + 1;
mObject.Fvt[y + 2] = y + 2;
}
y += mObject.Fpvnb[t];
}
}
//String str1;
//for (LONG p = 0; p < mObject.Fvt.GetCount(); p++)
//{
// str1 += LongToString(mObject.Fvt[p]) + " ";
//}
//GePrint(str1);
}
WriteExportFile(bc, ob, objfile, mObject, vcnt, pcnt);
//GePrint("Fvt: " + LongToString(Fvt.GetCount()));
vpcnt += mObject.Vp.GetCount();
if(bc->GetBool(IDC_CHK_EXP_UV))
vtcnt += mObject.Vt.GetCount();
}
}
objfile->Close();
if(expMat && materialArray.GetCount() > 0)
WriteMatsFile(document, bc);
}
else
{
GePrint("No selected objects!");
}
BaseMaterial::Free(matDefault);
return TRUE;
}
void CLargeFileDlg::OnBnClickedDebugTupleCount()
{
LPWSTR filePathRead = new TCHAR[MAX_PATH];
m_FilePath.GetWindowTextW(filePathRead, MAX_PATH);
HANDLE hFile = CreateFile(
(LPCWSTR)filePathRead, // file to open
GENERIC_READ, // open for reading
FILE_SHARE_READ, // share for reading
NULL, // default security
OPEN_EXISTING, // existing file only
FILE_ATTRIBUTE_NORMAL, // overlapped operation //| FILE_FLAG_NO_BUFFERING
NULL); // no attr. template
if (INVALID_HANDLE_VALUE==hFile)
{
ShowMB(L"Cannot create Handle file %s", filePathRead);
return;
}
BufferPool bufferPool;
bufferPool.size = SSD_PAGE_SIZE * 256 * 64; // 64MB
bufferPool.currentSize = 0;
bufferPool.data = new CHAR[bufferPool.size];
PageHelpers2 *utl = new PageHelpers2();
Buffer pageBuffer;
utl->InitBuffer(pageBuffer, SSD_PAGE_SIZE, &bufferPool);
PagePtr *pagePtr;
utl->InitRunPage(pagePtr, pageBuffer);
Buffer readBuffer;
utl->InitBuffer(readBuffer, bufferPool.size-bufferPool.currentSize, &bufferPool);
DWORD pageCount = 0;
DWORD tupleCount = 0;
while (TRUE)
{
DWORD dwBytesRead = 0;
ReadFile(hFile, readBuffer.data, readBuffer.size, &dwBytesRead, NULL);
if(dwBytesRead==0) { break; }
if(dwBytesRead%SSD_PAGE_SIZE==0)
pageCount = dwBytesRead / SSD_PAGE_SIZE;
else
pageCount = dwBytesRead / SSD_PAGE_SIZE + 1;
for(UINT i=0; i<pageCount; i++)
{
utl->GetPageInfo(readBuffer.data, pagePtr, pageBuffer, i, SSD_PAGE_SIZE);
PageHeader *pageHeader = (PageHeader *)(pagePtr->page);
tupleCount+=pageHeader->totalTuple;
}
}
m_TupleCount.SetWindowTextW(LongToString(tupleCount, L"%d"));
CloseHandle(hFile);
delete filePathRead;
delete bufferPool.data;
}
LONG CSVNodeData::FillPortsMenu(GvNode* node, BaseContainer& names, BaseContainer& ids,
GvValueID value_type, GvPortIO flag, LONG firstId) {
// Validate the passed flag.
switch (flag) {
case GV_PORT_INPUT:
case GV_PORT_OUTPUT:
break;
case GV_PORT_INVALID:
case GV_PORT_INPUT_OR_GEDATA:
default:
// DEBUG:
GePrint(__FUNCTION__ ": Invalid flag passed. (" + LongToString(flag) + ")");
return 0;
} // end switch
// Retrieve a list of already available ports.
AutoAlloc<GvPortList> availPorts;
if (!availPorts) return 0; // memory error
node->GetPortList(flag, availPorts);
// Iterate over all ports available ports and yield them.
LONG countAdded = 0;
for (LONG i=0; g_csvports[i].id != 0; i++) {
const CSVPort& port = g_csvports[i];
// Skip this port if it is not requested (eg. an INPORT, but only
// OUTPORTs are requested).
if (port.inport && flag != GV_PORT_INPUT) continue;
if (!port.inport && flag != GV_PORT_OUTPUT) continue;
// Check if the port already exists.
Bool exists = NodeHasPort(node, port.id, flag);
// Fill in the menu containers.
String name = GeLoadString(port.id) + String(exists ? "&d&" : "");
names.SetString(firstId + i, name);
ids.SetLong(firstId + i, port.id);
countAdded++;
}
// Add the CSV Table's output ports.
if (flag == GV_PORT_OUTPUT && m_table.Loaded()) {
LONG colCount = m_table.GetColumnCount();
GeData forceCols, forceColsCount;
node->GetParameter(CSVNODE_FORCEOUTPORTS, forceCols, DESCFLAGS_GET_0);
node->GetParameter(CSVNODE_FORCEOUTPORTS_COUNT, forceColsCount, DESCFLAGS_GET_0);
if (forceCols.GetBool() && forceColsCount.GetLong() > colCount) {
colCount = forceColsCount.GetLong();
}
for (LONG i=0; i < colCount; i++) {
// Compute the port id and check if the port already exists.
LONG portId = CSVNODE_DYNPORT_START + i;
Bool exists = NodeHasPort(node, portId, flag);
// Compute the name of the port.
String name = GetTableColumnPortName(i);
names.SetString(firstId + portId, name + String(exists ? "&d&" : ""));
ids.SetLong(firstId + portId, portId);
countAdded++;
}
}
return countAdded;
}
SplineObject* Voxelify::GetContour(BaseObject *op, BaseDocument *doc, Real lod, BaseThread *bt){
BaseContainer *data = op->GetDataInstance();
BaseObject* parent=(BaseObject*)data->GetLink(CTT_OBJECT_LINK,doc,Obase);
if (!parent) return NULL;
LONG startObject = data->GetLong(START_FRAME);
LONG endObject = data->GetLong(END_FRAME);
if (startObject >=endObject) return NULL;
maxSeg = data->GetReal(CTTSPOBJECT_MAXSEG,30.);
minSeg = data->GetReal(CTTSPOBJECT_MINSEG);
LONG delta = data->GetLong(OBJECT_SKIP,1);
delta = delta < 1 ? 1 : delta;
GeDynamicArray<BaseObject*> children;
GeDynamicArray<GeDynamicArray<Vector> > splineAtPoint;
BaseObject* chld = NULL;
LONG trck = 0;
for (chld=parent->GetDownLast(); chld; chld=chld->GetPred()) {
if (trck >= startObject && trck<= endObject && trck % delta == 0){
children.Push((BaseObject*)chld->GetClone(COPYFLAGS_NO_HIERARCHY|COPYFLAGS_NO_ANIMATION|COPYFLAGS_NO_BITS,NULL));
}
trck++;
}
if (children.GetCount() < 2) {
return NULL;
}
LONG splineInterpolation = data->GetLong(SPLINEOBJECT_INTERPOLATION);
LONG longestPercent = data->GetLong(TAKE_LONGEST, 1);
longestPercent = longestPercent > 100 ? 100: longestPercent;
parentMatrix = parent->GetMl();
GeDynamicArray<GeDynamicArray<Vector> > objectPoints(children.GetCount());
StatusSetBar(0);
StatusSetText("Collecting Points");
vector<vector<float> > points;
std::vector<VGrid> grids;
LONG gridSize = data->GetLong(GRID_SIZE, 1);
if (!(gridSize > 0)) return NULL;
for (int k= 0; k < children.GetCount(); k++){
Matrix ml;
DoRecursion(op,children[k],objectPoints[k], ml);
points = objectPointsToPoints(objectPoints[k]);
GePrint(children[k]->GetName());
grids.push_back(vox.voxelify(points,gridSize, 12, 1.0));
if (k % 5 == 0){
LONG progress = 10 + (50*k)/children.GetCount();
StatusSetBar(progress);
StatusSetText(LongToString(progress)+"%");
if (bt && bt->TestBreak()){
//break; //this break seems to be kicking in randomly killing the loop
}
}
}
StatusSetText("Building Splines");
SplineObject* parentSpline = ComputeSpline(bt, grids, longestPercent, splineAtPoint);
ModelingCommandData mcd;
mcd.doc = doc;
mcd.op = parentSpline;
if(!SendModelingCommand(MCOMMAND_JOIN, mcd)){
return NULL;
}
SplineObject* ret = ToSpline(mcd.result->GetIndex(0L));
ret->GetDataInstance()->SetLong(SPLINEOBJECT_INTERPOLATION, splineInterpolation);
for (int k=0; k<children.GetCount(); k++){
if (children[k]){
BaseObject::Free(children[k]);
}
}
return ret;
Error:
for (int i = 0; i < children.GetCount(); i++){
BaseObject::Free(children[i]);
}
return NULL;
}
BaseObject *Objectify::GetVirtualObjects(BaseObject *op, HierarchyHelp *hh)
{
BaseDocument *doc = op->GetDocument();
BaseContainer *data = op->GetDataInstance();
BaseObject* obj = (BaseObject*)data->GetLink(CTT_OBJECT_LINK,doc,Obase);
LONG crntFrame = doc->GetTime().GetFrame(doc->GetFps());
if (!obj) return NULL;
if (obj->GetType() != Ospline){
return NULL;
}
// start new list
op->NewDependenceList();
// check cache for validity and check master object for changes
Bool dirty = op->CheckCache(hh) || op->IsDirty(DIRTYFLAGS_DATA);
// if child list has been modified
if (!dirty) dirty = !op->CompareDependenceList();
// mark child objects as processed
op->TouchDependenceList();
dirty = dirty || (prevFrame != crntFrame);
prevFrame = crntFrame;
// if no change has been detected, return original cache
if (!dirty) return op->GetCache(hh);
SplineObject* spline = (SplineObject*) obj;
AutoAlloc<SplineHelp> splineHelp;
StatusSetText("Collecting points");
float positioAlongSpline = data->GetReal(POSITION_ALONG_SPLINE,0.5);
positioAlongSpline /= 10000.0f;
positioAlongSpline = positioAlongSpline > 1.0 ? 1.0: positioAlongSpline;
positioAlongSpline = positioAlongSpline < 0.0 ? 0.0: positioAlongSpline;
cout<<positioAlongSpline<<endl;
vector<vector<float> > points;
for (LONG i = 0; i < spline->GetSegmentCount(); i++){
Vector p = spline->GetSplinePoint(positioAlongSpline, i);
vector<float> point;
point.push_back(p.x);
point.push_back(p.y);
point.push_back(p.z);
points.push_back(point);
}
StatusSetText("Collected "+LongToString(points.size())+" points");
ksearchNeighbors= data->GetLong(TRIANGULATION_MAX_NEIGHBORS, 100);
gp3SearchRadius = data->GetReal(TRIANGULATION_MAX_SEARCH_RADIUS,30.);
gp3MaxNeighbors = data->GetLong(KSEARCH_NEIGHBORS, 20);
gp3Mu = data->GetReal(KSEARCH_MU, 0.5);
vector<vector<float> > surfacePoints;
vector<vector<int> > triIndxs;
StatusSetBar(0);
StatusSetText("Triangulating");
bool useMls = data->GetBool(USE_MLS, false);
tri.computeSurface(points, surfacePoints, triIndxs, ksearchNeighbors, gp3SearchRadius, gp3MaxNeighbors, gp3Mu, useMls);
StatusSetBar(100);
StatusSetText("Got "+LongToString(triIndxs.size())+" triangles");
if (triIndxs.size() == 0){
return NULL;
}
PolygonObject* myPoly = PolygonObject::Alloc(surfacePoints.size(),triIndxs.size());
Vector* ppoints = myPoly->GetPointW();
vector<float> sp;
for (int t = 0; t < surfacePoints.size()-2; t += 3) {
sp = surfacePoints[t];
ppoints[t+0] = Vector(sp[0],sp[1],sp[2]);
sp = surfacePoints[t+1];
ppoints[t+1] = Vector(sp[0],sp[1],sp[2]);
sp = surfacePoints[t+2];
ppoints[t+2] = Vector(sp[0],sp[1],sp[2]);
}
for (int t = 0; t < triIndxs.size(); t ++) {
myPoly->GetPolygonW()[t] = CPolygon(triIndxs[t][0], triIndxs[t][1], triIndxs[t][2], triIndxs[t][2]);
}
StatusClear();
myPoly->Message(MSG_UPDATE);
return ToPoly(myPoly);
BaseThread* bt=hh->GetThread();
BaseObject* main = BaseObject::Alloc(Onull);
SplineObject* emptySpline = SplineObject::Alloc(0, SPLINETYPE_LINEAR);
ModelingCommandData mcd;
mcd.doc = doc;
mcd.op = emptySpline;
if(!SendModelingCommand(MCOMMAND_JOIN, mcd)){
return NULL;
}
Error:
return NULL;
}
void ApplinkExporter::WriteExportFile(BaseContainer* bc, PolygonObject* ob, BaseFile* objfile, ExportObject& mObject, LONG vcnt, LONG pcnt)
{
const CPolygon* padr = ob->GetPolygonR();
Bool expUV = bc->GetBool(IDC_CHK_EXP_UV);
Bool expMat = bc->GetBool(IDC_CHK_EXP_MAT);
String str;
if(expMat && materialArray.GetCount() > 0)
{
Filename fileMatObj;
fileMatObj.SetFile(GetActiveDocument()->GetDocumentName());
fileMatObj.SetSuffix("mtl");
str = "mtllib " + fileMatObj.GetFile().GetString() + "\n";
this->WriteString(str, objfile);
this->WriteEndLine(objfile);
}
str = "g " + ob->GetName() + "\n";
this->WriteString(str, objfile);
this->WriteEndLine(objfile);
// vertex positions
ApplinkExporter::WriteVertexPositions(objfile, mObject, vcnt);
//UV
if(expUV)
ApplinkExporter::WriteUVWTag(objfile, mObject, pcnt, padr);
//Polygon faces v/vt/vn (v//vn)
str = "# begin " + LongToString(pcnt) + " faces\n";
this->WriteString(str, objfile);
LONG y=0;
String prevMat = "", currMat = "";
for (LONG i = 0; i < pcnt; i++)
{
if(expMat && materialArray.GetCount() > 0)
{
currMat = mObject.tempMats[mObject.pmatidxArray[i]]->GetName();
if(currMat != prevMat)
{
str = "usemtl " + currMat + "\n";
this->WriteString(str, objfile);
prevMat = currMat;
}
}
//GePrint("Polygon[" + LongToString(i) + "] " + LongToString(vadr[i].a) + ", " + LongToString(vadr[i].b) + ", " + LongToString(vadr[i].c) + ", " + LongToString(vadr[i].d));
str = "f";
//GePrint("poly vertices: " + LongToString(mObject.Fpvnb[i]));
for(LONG j = 0; j < mObject.Fpvnb[i]; j++)
{
str += " ";
str += LongToString(mObject.Fv[y+j] + 1 + vpcnt);
if(expUV && mObject.Fvt.GetCount() > 0)
{
str += "/";
str += LongToString(mObject.Fvt[y+j] + 1 + vtcnt);
}
}
str += "\n";
//GePrint("str = " + str);
this->WriteString(str, objfile);
y += mObject.Fpvnb[i];
}
str = "# end " + LongToString(pcnt) + " faces\n";
this->WriteString(str, objfile);
this->WriteEndLine(objfile);
}
