//----------------------------------------------------------------------------------------
// Create default filter settings
// Function result: filter settings oder 0 (not enough memory)
//----------------------------------------------------------------------------------------
static FILTER_PARAM filter_new_settings(FI_REF fi, const BaseContainer* t_bc)
{
PRIVATE_SETTINGS* settings;
settings = NewMemClear(PRIVATE_SETTINGS, 1);
if (settings)
{
settings->magic = PRIVATE_SETTINGS_MAGIC;
settings->matrix_opacity = 1.0;
settings->angle = DFLT_ANGLE;
settings->scale_matrix = true;
settings->type = 0;
settings->tile_flags = TILE_REPEAT_BORDER;
settings->emr = 0; // no effect matrix so far
settings->emr_lock = Semaphore::Alloc(); // create a semaphore for the matrix object
if (settings->emr_lock == 0) // failed to allocate the semaphore?
{
DeleteMem(settings);
settings = 0;
}
}
return (FILTER_PARAM)settings;
}
Bool CDynamicStringSet::ReadElement(BaseFile* pFile, String* pElement, Int32 lLevel)
{
#ifdef __API_INTERN__
Int32 len=0;
Char *c = nullptr;
if (!pFile->ReadInt32(&len)) return false;
if (!len) { *pElement=String(); return true; }
c = NewMemClear(Char, len);
if (!c)
{
return false;
}
if (!pFile->ReadBytes(c,len))
{
DeleteMem(c);
return false;
}
pElement->SetCString(c,len-1);
DeleteMem(c);
return true;
#else
return pFile->ReadString(pElement) != 0;
#endif // __API_INTERN__
}
static
Float
getMedian(const GeDynamicArray<Vector> &points, const Int32 *pnts, Int32 numPoints, Random &rng, INT axis, Sorter &sorter)
{
Int32 maxSamples = 20;
Int32 numSamples = numPoints < maxSamples ? numPoints : maxSamples;
Float* samples = NewMemClear(Float,numSamples);
for(Int32 i=0;i<numSamples;i++){
Float val = rng.Get01();
Int32 a = val * (numPoints-1);
switch(axis){
case 0:
samples[i] = points[pnts[a]].x;
break;
case 1:
samples[i] = points[pnts[a]].y;
break;
case 2:
samples[i] = points[pnts[a]].z;
break;
}
}
sorter.Sort(samples,numSamples,sizeof(Float));
Float ret = samples[numSamples/2];
DeleteMem(samples);
return ret;
}
Bool CDynamicFilenameArray::ReadElement(BaseFile* pFile, Filename* pElement, Int32 lLevel)
{
#ifdef __API_INTERN__
Int32 len=0;
Char *c = nullptr;
if (!pFile->ReadInt32(&len)) return false;
if (!len) { *pElement = Filename(); return true; }
c = NewMemClear(Char, len);
if (!c)
{
return false;
}
if (!pFile->ReadBytes(c,len))
{
DeleteMem(c);
return false;
}
String str;
str.SetCString(c, len-1);
*pElement = Filename(str);
DeleteMem(c);
return true;
#else
return pFile->ReadFilename(pElement) != 0;
#endif // __API_INTERN__
}
/*********************************************************************\
Function name : CLanguageList::Init
Description :
Created at : 26.09.01, @ 16:11:23
Created by : Thomas Kunert
Modified by :
\*********************************************************************/
void CLanguageList::Init()
{
Filename resourcepath = GeGetStartupPath() + Filename("resource");
if (GetC4DVersion() >= 16000) {
// R16 has a new resource directory structure. The c4d_language.str
// files we are searching for are in resource/modules/c4dplugin/strings_xx.
// Fix for https://github.com/nr-plugins/resedit/issues/4
resourcepath = resourcepath + "modules" + "c4dplugin";
}
AutoAlloc <BrowseFiles> pBrowse;
pBrowse->Init(resourcepath, false);
while (pBrowse->GetNext())
{
if (pBrowse->IsDir())
{
Filename fn = pBrowse->GetFilename();
if (fn.GetString().SubStr(0, 8).ToLower() == "strings_")
{
String idx = fn.GetString();
idx.Delete(0, 8);
Filename stringname = resourcepath + fn+Filename("c4d_language.str");
AutoAlloc <BaseFile> pFile;
if (!pFile)
return;
if (!GeFExist(stringname))
{
GeOutString("Missing c4d_language.str to identify the string directory!!!", GEMB_ICONEXCLAMATION);
}
else if (pFile->Open(stringname))
{
Int32 len = pFile->GetLength();
Char *buffer = NewMemClear(Char,len + 2);
if (buffer)
{
pFile->ReadBytes(buffer,len);
buffer[len]=0;
Int32 i;
for (i = 0; i < len && buffer[i] >= ' '; i++) { }
buffer[i] = 0;
for (i--; i > 0 && buffer[i]== ' '; i--) { }
buffer[i + 1] = 0;
AddLanguage(buffer, idx);
DeleteMem(buffer);
}
}
}
}
}
CriticalAssert(GetNumLanguages() > 0);
}
String EncryptPassword(const String& str)
{
Int32 lLen = str.GetCStringLen(STRINGENCODING_8BIT);
if (lLen <= 0)
return str;
Int32 lCryptLen = (lLen + 256) / 256;
lCryptLen *= 256;
Int32 i;
Random rnd;
rnd.Init(97355832);
Int32 plKey[30];
char ch[3];
String strCrypt;
GeCipher256 c;
char* pchPassword = NewMemClear(Char,lCryptLen);
if (!pchPassword)
return str;
str.GetCString(pchPassword, lLen + 1, STRINGENCODING_8BIT);
pchPassword[lLen] = 0;
for (i = 0; i < lCryptLen; i++)
{
rnd.Get01();
pchPassword[i] ^= (rnd.GetSeed() & 0xff);
}
rnd.Init(956612571);
for (i = 0; i < 30; i++)
{
rnd.Get01();
plKey[i] = rnd.GetSeed();
lIntel(&(plKey[i]));
}
if (!c.Open((UChar*)plKey, sizeof(plKey), true))
{
DeleteMem(pchPassword);
return str;
}
for (i = 0; i < lCryptLen; i += 256)
c.Encrypt((UChar*)&pchPassword[i], 256);
for (i = 0; i < lCryptLen; i++)
{
sprintf_safe(ch, sizeof(ch), "%02x", ((int)pchPassword[i]) & 0xff);
DebugAssert(ch[2] == 0);
strCrypt += ch;
}
DeleteMem(pchPassword);
return strCrypt;
}
void
buildKDTree(const GeDynamicArray<Vector> &points, KDNode **nodes, Random &rng)
{
Sorter sorter;
Int32 *pnts = NewMemClear(Int32,points.GetCount());
Int32 numPoints = points.GetCount();
for(Int32 i=0;i<numPoints;i++){
pnts[i] = i;
}
*nodes = recursiveBuild(points,pnts,numPoints,rng,0,sorter);
}
/*********************************************************************\
Function name : CLanguageList::Init
Description :
Created at : 26.09.01, @ 16:11:23
Created by : Thomas Kunert
Modified by :
\*********************************************************************/
void CLanguageList::Init()
{
Filename resourcepath = GeGetStartupPath() + Filename("resource");
AutoAlloc <BrowseFiles> pBrowse;
pBrowse->Init(resourcepath, false);
while (pBrowse->GetNext())
{
if (pBrowse->IsDir())
{
Filename fn = pBrowse->GetFilename();
if (fn.GetString().SubStr(0, 8).ToLower() == "strings_")
{
String idx = fn.GetString();
idx.Delete(0, 8);
Filename stringname = resourcepath + fn+Filename("c4d_language.str");
AutoAlloc <BaseFile> pFile;
if (!pFile)
return;
if (!GeFExist(stringname))
{
GeOutString("Missing c4d_language.str to identify the string directory!!!", GEMB_ICONEXCLAMATION);
}
else if (pFile->Open(stringname))
{
Int32 len = pFile->GetLength();
Char *buffer = NewMemClear(Char,len + 2);
if (buffer)
{
pFile->ReadBytes(buffer,len);
buffer[len]=0;
Int32 i;
for (i = 0; i < len && buffer[i] >= ' '; i++) { }
buffer[i] = 0;
for (i--; i > 0 && buffer[i]== ' '; i--) { }
buffer[i + 1] = 0;
AddLanguage(buffer, idx);
DeleteMem(buffer);
}
}
}
}
}
}
Bool CDynamicStringArray::WriteElement(BaseFile* pFile, const String* pElement) const
{
#ifdef __API_INTERN__
Bool ok;
Int32 len = pElement->GetCStringLen()+1;
Char *mem = NewMemClear(Char, len);
if (!mem)
{
return false;
}
pElement->GetCString(mem, len);
ok = pFile->WriteInt32(len) && pFile->WriteBytes(mem,len);
DeleteMem(mem);
return ok;
#else
return pFile->WriteString(*pElement) != 0;
#endif // __API_INTERN__
}
IMAGERESULT BFFSaverData::Save(const Filename& name, BaseBitmap* bm, BaseContainer* data, SAVEBIT savebits)
{
Int32 y, bw, bh;
Bool ok = true;
UChar* line = nullptr;
AutoAlloc<BaseFile> file;
if (!file)
return IMAGERESULT_OUTOFMEMORY;
if (!file->Open(name, FILEOPEN_WRITE, FILEDIALOG_NONE, BYTEORDER_MOTOROLA))
return IMAGERESULT_FILEERROR;
bw = bm->GetBw();
bh = bm->GetBh();
file->WriteInt32(0x42464600);
file->WriteInt32(bw);
file->WriteInt32(bh);
if (bw > 0)
line = NewMemClear(UChar, 3 * bw);
if (!line)
{
DeleteMem(line);
return IMAGERESULT_OUTOFMEMORY;
}
for (y = 0; y < bh; y++)
{
bm->GetPixelCnt(0, y, bw, line, COLORBYTES_RGB, COLORMODE_RGB, PIXELCNT_0);
file->WriteBytes(line, bw * 3);
}
ok = file->GetError() == FILEERROR_NONE;
DeleteMem(line);
return ok ? IMAGERESULT_OK : IMAGERESULT_FILEERROR;
}
IMAGERESULT BFFLoaderData::Load(const Filename& name, BaseBitmap* bm, Int32 frame)
{
Int32 y, bw, bh, header;
Bool ok = true;
UChar* line = nullptr;
AutoAlloc<BaseFile> file;
if (!file)
return IMAGERESULT_OUTOFMEMORY;
if (!file->Open(name, FILEOPEN_READ, FILEDIALOG_NONE, BYTEORDER_MOTOROLA))
return IMAGERESULT_FILEERROR;
file->ReadInt32(&header);
file->ReadInt32(&bw);
file->ReadInt32(&bh);
if (bw > 0)
line = NewMemClear(UChar, 3 * bw);
if (bm->Init(bw, bh, 24) != IMAGERESULT_OK || !line)
{
DeleteMem(line);
return IMAGERESULT_OUTOFMEMORY;
}
for (y = 0; y < bh && ok; y++)
{
// check if current thread is canceled and return IMAGERESULT_THREADCANCELED
file->ReadBytes(line, bw * 3);
ok = bm->SetPixelCnt(0, y, bw, line, COLORBYTES_RGB, COLORMODE_RGB, PIXELCNT_0);
}
ok = ok && file->GetError() == FILEERROR_NONE;
DeleteMem(line);
return ok ? IMAGERESULT_OK : IMAGERESULT_FILEERROR;
}
Bool DiffDistriDialog::Command(Int32 id, const BaseContainer &msg)
{
switch (id)
{
case IDC_DIFF_DISTRI_NEW_BTN:
{
Filename fn;
if (fn.FileSelect(FILESELECTTYPE_ANYTHING, FILESELECT_LOAD, GeLoadString(IDS_DIFF_DISTRI_CHOOSE)))
{
if (!fn.CheckSuffix("zip"))
{
GeOutString(GeLoadString(IDS_DIFF_DISTRI_INVALID_SUFFIX), GEMB_OK | GEMB_ICONSTOP);
}
else
{
g_pResEditPrefs->arOldFiles.AddFilename(fn);
m_pTreeView->Refresh();
}
}
}
break;
case IDC_DIFF_DISTRI_REMOVE_BTN:
if (m_fnSelection.Content())
{
g_pResEditPrefs->arOldFiles.RemoveFilename(m_fnSelection);
m_fnSelection = Filename();
m_pTreeView->Refresh();
}
break;
case IDC_DIFF_DISTRI_NEWZIP_EDIT:
g_pResEditPrefs->fnNewZip = m_pNewZipEdit->GetData().GetValue().GetFilename();
break;
case IDC_DIFF_DISTRI_DESTPATH_EDIT:
{
Filename fnDestZip = m_pDestPathEdit->GetData().GetValue().GetFilename();
g_pResEditPrefs->fnDestZip = fnDestZip;
g_pResEditPrefs->fnDestZip.SetSuffix("zip");
if (fnDestZip.Content() && g_pResEditPrefs->fnDestZip != fnDestZip)
m_pDestPathEdit->SetData(TriState<GeData>(g_pResEditPrefs->fnDestZip));
}
break;
case IDC_OK:
{
GeData d;
String strPassword;
Int32 lLen = 0;
char* pchPassword = nullptr;
Filename fnDestZip = m_pDestPathEdit->GetData().GetValue().GetFilename();
g_pResEditPrefs->fnNewZip = m_pNewZipEdit->GetData().GetValue().GetFilename();
g_pResEditPrefs->fnDestZip = fnDestZip;
g_pResEditPrefs->fnDestZip.SetSuffix("zip");
if (fnDestZip.Content() && g_pResEditPrefs->fnDestZip != fnDestZip)
m_pDestPathEdit->SetData(TriState<GeData>(g_pResEditPrefs->fnDestZip));
GetString(IDC_DIFF_DISTRI_PASSWORD_EDIT, strPassword);
lLen = strPassword.GetCStringLen(STRINGENCODING_8BIT);
if (lLen)
{
pchPassword = NewMemClear(Char,lLen + 2);
if (pchPassword)
strPassword.GetCString(pchPassword, lLen + 1, STRINGENCODING_8BIT);
}
if (!g_pResEditPrefs->arOldFiles.GetElementCount())
{
GeOutString(GeLoadString(IDS_DIFF_DISTRI_NO_OLD), GEMB_ICONSTOP);
DeleteMem(pchPassword);
break;
}
if (!g_pResEditPrefs->fnNewZip.Content())
{
GeOutString(GeLoadString(IDS_DIFF_DISTRI_NO_NEW), GEMB_ICONSTOP);
DeleteMem(pchPassword);
break;
}
if (!g_pResEditPrefs->fnDestZip.Content())
{
GeOutString(GeLoadString(IDS_DIFF_DISTRI_NO_DEST), GEMB_ICONSTOP);
DeleteMem(pchPassword);
break;
}
if (!DiffZipFiles(g_pResEditPrefs->arOldFiles, g_pResEditPrefs->fnNewZip, g_pResEditPrefs->fnDestZip, pchPassword))
GeOutString(GeLoadString(IDS_DIFF_DISTRI_FAILED, g_pResEditPrefs->fnNewZip.GetString(), g_pResEditPrefs->fnDestZip.GetString()), GEMB_OK | GEMB_ICONEXCLAMATION);
DeleteMem(pchPassword);
}
break;
case IDC_CANCEL:
Close();
break;
default:
break;
}
return true;
}
static
KDNode *
recursiveBuild(const GeDynamicArray<Vector> &points, const Int32 *pnts, Int32 numPoints, Random &rng, INT depth, Sorter &sorter)
{
KDNode *node =NewMemClear(KDNode,1);
Int32 minNodeEntries = 4;
Int32 maxDepth = 10;
if(numPoints > minNodeEntries && depth < maxDepth){
INT axis = depth%3;
Float splitPos = getMedian(points,pnts,numPoints,rng,axis,sorter);
Int32 numLeft = 0;
for(Int32 i=0;i<numPoints;i++){
switch(axis){
case 0:
if(points[pnts[i]].x < splitPos){
numLeft++;
}
break;
case 1:
if(points[pnts[i]].y < splitPos){
numLeft++;
}
break;
case 2:
if(points[pnts[i]].z < splitPos){
numLeft++;
}
break;
}
}
Int32 *lPoints = NewMemClear(Int32,numLeft);
Int32 *rPoints = NewMemClear(Int32,numPoints - numLeft);
Int32 lPos=0;
Int32 rPos=0;
for(Int32 i=0;i<numPoints;i++){
Float val = 0;
switch(axis){
case 0:
val = points[pnts[i]].x;
break;
case 1:
val = points[pnts[i]].y;
break;
case 2:
val = points[pnts[i]].z;
break;
}
if(val < splitPos){
lPoints[lPos] = pnts[i];
lPos++;
}
else{
rPoints[rPos] = pnts[i];
rPos++;
}
}
node->initInterior(splitPos);
node->m_lChild = recursiveBuild(points,lPoints,numLeft,rng,depth+1,sorter);
node->m_rChild = recursiveBuild(points,rPoints,numPoints-numLeft,rng,depth+1,sorter);
DeleteMem(pnts);
}
else{
node->initLeaf(pnts,numPoints);
}
return node;
}
String DecryptPassword(const String &str)
{
Int32 lLen = str.GetCStringLen(STRINGENCODING_8BIT);
if (lLen <= 0)
return str;
if (lLen % 512)
{
DebugAssert(false);
return "";
}
GeCipher256 c;
Random rnd;
Int32 plKey[30];
char *pchCryptPassword = nullptr, *pchPassword = nullptr;
pchCryptPassword = NewMemClear(Char,lLen + 2);
pchPassword = (lLen > 1) ? NewMemClear(Char,lLen / 2) : nullptr;
if (!pchCryptPassword || !pchPassword)
{
DeleteMem(pchCryptPassword);
DeleteMem(pchPassword);
return "";
}
Int32 i;
int n;
str.GetCString(pchCryptPassword, lLen + 1, STRINGENCODING_8BIT);
lLen /= 2;
for (i = 0; i < lLen; i++)
{
sscanf(&pchCryptPassword[2 * i], "%02x", &n);
DebugAssert(n >= 0 && n < 256);
pchPassword[i] = (char)n;
}
rnd.Init(956612571);
for (i = 0; i < 30; i++)
{
rnd.Get01();
plKey[i] = rnd.GetSeed();
lIntel(&(plKey[i]));
}
if (!c.Open((UChar*)plKey, sizeof(plKey), true))
{
DeleteMem(pchCryptPassword);
DeleteMem(pchPassword);
return "";
}
for (i = 0; i < lLen; i += 256)
c.Decrypt((UChar*)&pchPassword[i], 256);
rnd.Init(97355832);
for (i = 0; i < lLen; i++)
{
rnd.Get01();
pchPassword[i] ^= (rnd.GetSeed() & 0xff);
}
String strDecrypt = pchPassword;
DeleteMem(pchCryptPassword);
DeleteMem(pchPassword);
return strDecrypt;
}
