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__
}
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__
}
DeferredRendering::~DeferredRendering()
{
DeleteMem(m_DREffect);
DeleteMem(m_DiffuseRT);
DeleteMem(m_NormalRT);
DeleteMem(m_DepthRT);
}
AEResult GameObjectScriptGOC::RemoveGameObjectScriptInstance()
{
/////////////////////////////////////////
//Pre-checks
if (!m_IsReady)
{
return AEResult::NotReady;
}
AEAssert(m_GameObjectScriptInstance != nullptr);
if (m_GameObjectScriptInstance == nullptr)
{
return AEResult::NullObj;
}
/////////////////////////////////////////
//Remove Instance
m_GameObjectScriptManager->Remove(m_GameObjectScriptInstance->m_Name);
DeleteMem(m_GameObjectScriptProperties);
DeleteMem(m_GameObjectScriptInstance);
/////////////////////////////////////////
//Finish
return AEResult::Ok;
}
DebugStats::~DebugStats()
{
DeleteMem(m_SpriteFontAE);
DeleteMem(m_SpriteBatchAE);
DeleteMem(m_GridVertexBuffer);
DeleteMem(m_AxisVertexBuffer);
DeleteMem(m_BasicColorMaterial);
}
KDNode::~KDNode()
{
if(m_interior){
DeleteMem(m_lChild);
DeleteMem(m_rChild);
}
else{
DeleteMem(m_points);
}
}
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;
}
AEResult SkinningMaterial::CreateVertexShaderConstantBuffer()
{
AEResult ret = AEResult::Ok;
/////////////////////////////////////////////////////
//Create Constant Buffer
// - _AE_CB_World_View_Proj
// - _AE_CB_Bones
//
/****************************************************************************
*Constant Buffer #1: _AE_CB_World_View_Proj
****************************************************************************/
ConstantBuffer* cbWVP = nullptr;
ret = AEBuiltInMaterialsHelpers::BuildCBWVP(m_GraphicDevice, &cbWVP);
if(ret != AEResult::Ok)
{
return AEResult::ConstantBufferInitFailed;
}
ret = m_VSProps->AddConstantBuffer(cbWVP);
if(ret != AEResult::Ok)
{
DeleteMem(cbWVP);
return AEResult::ConstantBufferInitFailed;
}
/****************************************************************************
*Constant Buffer #2: _AE_CB_Bones
****************************************************************************/
ConstantBuffer* cbBones = nullptr;
ret = AEBuiltInMaterialsHelpers::BuildCBBones(m_GraphicDevice, &cbBones);
ret = m_VSProps->AddConstantBuffer(cbBones);
if(ret != AEResult::Ok)
{
DeleteMem(cbBones);
return AEResult::ConstantBufferInitFailed;
}
/****************************************************************************
*Finish
****************************************************************************/
return AEResult::Ok;
}
GameLightsUpdate::~GameLightsUpdate()
{
DeleteMem(m_SpotLightShadowViewport);
DeleteMem(m_VarianceShadowMaterial);
DeleteMem(m_VarianceSkinningShadowMaterial);
AERelease(m_SpotLightShadowTexturesDS);
AERelease(m_DirLightShadowTexturesDS);
for (size_t i = 0; i < m_DirLightShadowViewports.size(); i++)
{
DeleteMem(m_DirLightShadowViewports[i]);
}
}
void WaitForCurrProcess(void)
{
unl objs = 1;
unl res = 0;
HANDLE proc[2];
proc[0] = CurrProc;
proc[1] = 0;
while (!StopCommand) {
res = MsgWaitForMultipleObjects(objs, proc, FALSE,
INFINITE, QS_ALLINPUT);
if (res == WAIT_OBJECT_0)
break;
if (res == WAIT_FAILED) {
ExitType = 1;
LocalExitCode = GetLastError();
break;
}
if (res == (WAIT_OBJECT_0 + objs)) {
MSG msg;
while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
// if it's a quit message we're out of here
if (msg.message == WM_QUIT)
return;
// otherwise dispatch it
TranslateMessage(&msg);
DispatchMessage(&msg);
if (((msg.message == WM_KEYDOWN)
&& (msg.wParam == VK_CANCEL))
|| ((msg.message == WM_CHAR)
&& (msg.wParam == 0x03))) {
ExitType = 6;
LocalExitCode = 1;
StopCommand = true;
break;
}
} // end of PeekMessage while loop
}
}
if (!StopCommand
&& !GetExitCodeProcess(procInfo->hProcess, &LocalExitCode)) {
ExitType = 2;
LocalExitCode = GetLastError();
}
CloseHandle(procInfo->hProcess);
CloseHandle(procInfo->hThread);
DeleteMem(startInfo);
DeleteMem(procInfo);
}
AEResult QuadTextureMaterial::CreateVertexShaderConstantBuffer()
{
AEResult ret = AEResult::Ok;
/////////////////////////////////////////////////////
//Create Constant Buffer
// - _AE_CB_HalfPixel
//
/****************************************************************************
*Constant Buffer #1: _AE_CB_HalfPixel
****************************************************************************/
ConstantBuffer* cb = nullptr;
ret = AEBuiltInMaterialsHelpers::BuildCBHalfPixel(m_GraphicDevice, &cb);
if(ret != AEResult::Ok)
{
return AEResult::ConstantBufferInitFailed;
}
ret = m_VSProps->AddConstantBuffer(cb);
if(ret != AEResult::Ok)
{
DeleteMem(cb);
return AEResult::ConstantBufferInitFailed;
}
/****************************************************************************
*Finish
****************************************************************************/
return AEResult::Ok;
}
XBoxGamepadManager::~XBoxGamepadManager()
{
for (uint32_t i = 0; i < XUSER_MAX_COUNT; i++)
{
DeleteMem(m_Gamepads[i]);
}
}
//----------------------------------------------------------------------------------------
// 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;
}
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;
}
PaintUndoTile::~PaintUndoTile()
{
if (m_pData)
{
DeleteMem(m_pData);
}
}
void GameObjectMaterialComponentsWidget::on_m_AddMaterialButton_clicked()
{
if(!m_IsReady)
{
return;
}
////////////////////////////////
//Create New Mesh Material GOC
AETODO("Add literal from Localization");
MeshMaterialGOC* meshMaterialGOC = new MeshMaterialGOC(m_GameObject, L"Empty Mesh Material");
////////////////////////////////
//Add it to Game Object
AEResult ret = m_GameObject->AddMeshMaterialGOC(meshMaterialGOC);
if(ret != AEResult::Ok)
{
AETODO("Add log and window message");
DeleteMem(meshMaterialGOC);
return;
}
////////////////////////////////
//New Index will be the Top Level Count
uint32_t selectedIndex = m_GameObjectMaterialComponentsWidgetQtUI.m_MaterialsTree->topLevelItemCount();
////////////////////////////////
//Repopulate tree with new data
PopulateMaterialsTree(selectedIndex);
}
AEResult ConvertToMeshContent(const MeshPartHolder& meshPartHolder, MeshPartContent** meshPartContent, bool generateTangentBinormal)
{
if(meshPartContent == nullptr)
{
return AEResult::NullParameter;
}
MeshPartContent* meshContentTemp = new MeshPartContent();
meshContentTemp->m_MatID = meshPartHolder.m_MaterialID;
meshContentTemp->m_VertexType = meshPartHolder.m_VertexType;
AEResult ret = BuildVertexBufferContent(meshContentTemp->m_VertexType, meshPartHolder.m_VtxHolderVec, &meshContentTemp->m_VtxBuff, generateTangentBinormal, meshPartHolder.m_IndexHolder);
if(ret != AEResult::Ok)
{
DeleteMem(meshContentTemp);
return ret;
}
uint32_t idxSize = (uint32_t)meshPartHolder.m_IndexHolder.size();
meshContentTemp->m_IdxSize = idxSize;
meshContentTemp->m_IdxBuf16 = new uint16_t[idxSize];
ZeroMemory(meshContentTemp->m_IdxBuf16, idxSize * sizeof(uint16_t));
for (uint32_t i = 0; i < idxSize; ++i)
{
meshContentTemp->m_IdxBuf16[i] = meshPartHolder.m_IndexHolder[i];
}
(*meshPartContent) = meshContentTemp;
return AEResult::Ok;
}
/*********************************************************************\
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);
}
Bool PickObjectTool::MouseInput(BaseDocument* doc, BaseContainer& data, BaseDraw* bd, EditorWindow* win, const BaseContainer& msg)
{
Int32 mode = data.GetInt32(MDATA_PICKOBJECT_MODE);
Int32 x, y, l, xr = 0, yr = 0, wr = 0, hr = 0;
Matrix4d m;
ViewportPixel** pix = nullptr;
String str;
char ch[200];
Bool ret = false;
AutoAlloc<C4DObjectList> list;
if (!list)
return false;
VIEWPORT_PICK_FLAGS flags = VIEWPORT_PICK_FLAGS_ALLOW_OGL | VIEWPORT_PICK_FLAGS_USE_SEL_FILTER;
if (data.GetBool(MDATA_PICKOBJECT_ONLY_VISIBLE))
flags |= VIEWPORT_PICK_FLAGS_OGL_ONLY_VISIBLE;
x = msg.GetInt32(BFM_INPUT_X);
y = msg.GetInt32(BFM_INPUT_Y);
Float64 timer = 0.0;
if (mode == MDATA_PICKOBJECT_MODE_CIRCLE)
{
Int32 rad = data.GetInt32(MDATA_PICKOBJECT_CIRCLE_RAD);
timer = GeGetMilliSeconds();
ret = ViewportSelect::PickObject(bd, doc, x, y, rad, xr, yr, wr, hr, pix, flags, nullptr, list, &m);
timer = GeGetMilliSeconds() - timer;
}
else if (mode == MDATA_PICKOBJECT_MODE_RECTANGLE)
{
Int32 width = data.GetInt32(MDATA_PICKOBJECT_RECT_W);
Int32 height = data.GetInt32(MDATA_PICKOBJECT_RECT_H);
x -= width / 2;
y -= height / 2;
timer = GeGetMilliSeconds();
ret = ViewportSelect::PickObject(bd, doc, x, y, x + width, y + height, xr, yr, wr, hr, pix, flags, nullptr, list, &m);
timer = GeGetMilliSeconds() - timer;
}
if (ret)
{
sprintf(ch, "Picking region from (%d, %d), size (%d, %d)|", xr, yr, wr, hr);
str += ch;
for (l = 0; l < list->GetCount(); l++)
{
sprintf(ch, ", z = %.4f|", list->GetZ(l));
str += "Found Object " + list->GetObject(l)->GetName() + ch;
}
}
else
{
str = "PickObject failed";
}
sprintf(ch, "|Time: %.2f us", float(timer) * 1000.0f);
str += ch;
DeleteMem(pix);
GeOutString(str, GEMB_OK);
return true;
}
void Mesh::CleanUp()
{
uint32_t size = (uint32_t)m_MeshPartVector.size();
for (uint32_t i = 0; i < size; ++i)
{
DeleteMem(m_MeshPartVector[i]);
}
m_MeshPartVector.clear();
}
Bool ApplinkDialog::Command(Int32 id, const BaseContainer& msg)
{
dirty = true;
saveSettings();
switch(id)
{
case IDC_BTN_EXPORT:
{
BaseDocument* doc = GetActiveDocument();
ApplinkExporter* exporter = NewObjClear(ApplinkExporter);
exporter->Execute(doc, &gPreferences);
String exeCoat = gPreferences.GetString(IDC_COAT_EXE_PATH);
if(gPreferences.GetBool(IDC_CHK_COAT_START) && exeCoat != "")
{
if(!Find3DCoat())
{
Int32 length = exeCoat.GetCStringLen(STRINGENCODING_8BIT) + 1;
char* buffer = NewMemClear(char,length);
exeCoat.GetCString(buffer, length, STRINGENCODING_8BIT);
#if defined _WIN32 || defined _WIN64
SHELLEXECUTEINFO ExecuteInfo;
memset(&ExecuteInfo, 0, sizeof(ExecuteInfo));
ExecuteInfo.cbSize = sizeof(ExecuteInfo);
ExecuteInfo.fMask = 0;
ExecuteInfo.hwnd = 0;
ExecuteInfo.lpVerb = TEXT("open"); // Operation to perform
wchar_t *pBuffer = (wchar_t *)malloc(MAX_PATH);
mbstowcs(pBuffer, buffer, MAX_PATH);
ExecuteInfo.lpFile = pBuffer; // Application name
ExecuteInfo.lpDirectory = 0; // Default directory
ExecuteInfo.nShow = SW_SHOWNORMAL;
ExecuteInfo.hInstApp = 0;
if(ShellExecuteEx(&ExecuteInfo) == false)
{
GePrint("3D-Coat.exe not found!");
}
#elif __APPLE__
string str = "open " + string(buffer);
system(str.c_str());
GePrint("Start 3D-Coat: " + String(buffer));
#endif
DeleteMem(buffer);
}
else
{
GePrint("3D-Coat.exe is run!");
}
}
}
void MemStatDialog::CheckMaxMemory(Int32 mbblocks)
{
maxon::BaseArray<void*> blocks;
Int32 i;
for (i = 0; true; i++)
{
void* block = nullptr;
if (mbblocks > 0)
block = NewMem(UChar, mbblocks * 1024 * 1024);
if (!block)
break;
InitValues();
if (!blocks.Append(block))
{
DeleteMem(block);
break;
}
InitValues();
}
BaseContainer stat;
GeGetMemoryStat(stat);
for (i = 0; i < blocks.GetCount(); i++)
{
void* block = blocks[i];
if (block)
DeleteMem(block);
}
InitValues();
String memstr = String::MemoryToString(stat.GetInt64(C4D_MEMORY_STAT_MEMORY_INUSE));
switch (mbblocks)
{
case 1: SetString(IDC_MEMORY_TEST_1MB_RES, memstr); break;
case 10: SetString(IDC_MEMORY_TEST_10MB_RES, memstr); break;
case 100: SetString(IDC_MEMORY_TEST_100MB_RES, memstr); break;
}
GeOutString("Max memory allocation: " + memstr, GEMB_OK);
}
void UpdateCRC(Crc32 &crc, const String &str)
{
Int32 lLen = str.GetCStringLen();
Char* pchString = NewMem(Char,lLen + 2);
if (!pchString)
return;
str.GetCString(pchString, lLen + 1);
crc.Update(pchString, lLen);
DeleteMem(pchString);
}
void Skeleton::CleanUp()
{
uint32_t size = (uint32_t)m_BoneHierarchy.size();
for(uint32_t i = 0; i < size; ++i)
{
DeleteMem(m_BoneHierarchy[i]);
}
m_BoneHierarchy.clear();
}
void PhysicsActor::CleanUp()
{
for each (auto collider in m_PhysicColliderMap)
{
PhysicCollider* physicCollider = collider.second;
m_PxRigidActor->detachShape(*physicCollider->GetPxShape());
DeleteMem(physicCollider);
}
ModelContent::~ModelContent()
{
//Clean Skeleton
DeleteMem(m_SkeletonContent);
//Clean Animations
for(auto itAnim : m_Animations)
{
DeleteMem(itAnim.second);
}
m_Animations.clear();
//Clean Meshes
for(auto itMesh : m_Meshes)
{
DeleteMem(itMesh.second);
}
m_Meshes.clear();
}
GameObjectScriptGOC::~GameObjectScriptGOC()
{
RemoveGameObjectScriptAsset();
if (m_ASContext != nullptr)
{
m_ASContext->Unprepare();
ReleaseAngel(m_ASContext);
}
DeleteMem(m_TempGameObjectScriptProperties);
}
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;
}
AEResult GameObjectScriptGOC::ClearGameObjectScriptAsset(bool informGameAsset)
{
if (m_GameObjectScript.m_ResourceAsset != nullptr)
{
if (m_GameObjectScript.m_OnListenerObjDeletionEvent != nullptr && informGameAsset)
{
m_GameObjectScript.m_OnListenerObjDeletionEvent(m_GameObjectScript.m_CallerID);
}
m_GameObjectScript.m_AssetID = 0;
m_GameObjectScript.m_GameAsset = nullptr;
m_GameObjectScript.m_CallerID = 0;
m_GameObjectScript.m_OnListenerObjDeletionEvent = nullptr;
AERelease(m_GameObjectScript.m_ResourceAsset);
DeleteMem(m_GameObjectScriptProperties);
DeleteMem(m_GameObjectScriptInstance);
}
return AEResult::Ok;
}
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;
}
