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