void StatusUpdatePrintPage(int iPageNum)
{
WCHAR tch[32] = { L'\0' };
FormatString(tch,COUNTOF(tch),IDS_PRINTFILE,iPageNum);
StatusSetText(g_hwndStatus,255,tch);
StatusSetSimple(g_hwndStatus,TRUE);
InvalidateRect(g_hwndStatus,nullptr,TRUE);
UpdateWindow(g_hwndStatus);
}
void StatusUpdatePrintPage(int iPageNum)
{
WCHAR tch[32];
FormatString(tch,COUNTOF(tch),IDS_PRINTFILE,iPageNum);
StatusSetText(hwndStatus,255,tch);
StatusSetSimple(hwndStatus,TRUE);
InvalidateRect(hwndStatus,NULL,TRUE);
UpdateWindow(hwndStatus);
}
Bool PickObjectTool::GetCursorInfo(BaseDocument* doc, BaseContainer& data, BaseDraw* bd, Float x, Float y, BaseContainer& bc)
{
if (bc.GetId() == BFM_CURSORINFO_REMOVE)
{
_lastBaseDraw = nullptr;
}
else
{
_lastBaseDraw = bd;
_mouseX = (Int32)x;
_mouseY = (Int32)y;
AutoAlloc<C4DObjectList> list;
if (list)
{
// get the z position of the topmost object. The z range for objects is from -1 to 1.
Float z = 1.0;
String str;
Matrix4d m;
ViewportSelect::PickObject(bd, doc, _mouseX, _mouseY, 1, VIEWPORT_PICK_FLAGS_ALLOW_OGL | VIEWPORT_PICK_FLAGS_USE_SEL_FILTER | VIEWPORT_PICK_FLAGS_OGL_ONLY_TOPMOST, nullptr, list, &m);
if (list->GetCount() > 0)
z = list->GetZ(0);
if (z < 1.0)
{
Vector v = GetWorldCoordinates(bd, m, x, y, z);
char ch[200];
sprintf(ch, "Mouse coordinates: (%d, %d), world coordinates: (%.4f, %.4f, %.4f)", _mouseX, _mouseY, v.x, v.y, v.z);
str = ch;
}
else
{
str = "Mouse cursor is not over an object";
}
StatusSetText(str);
}
}
SpecialEventAdd(EVMSG_UPDATEHIGHLIGHT);
return true;
}
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;
}
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;
}
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;
}
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;
}
inline void _SetStatusText(const WCHAR *szStatus)
{
StatusSetText(hStatus, 0, szStatus);
}
