int prev_process_info__compute_load(cdtime_t tm, pid_t pid, unsigned long stime, unsigned long utime, unsigned long *spercent, unsigned long *upercent) { /* {{{ */
/* Notes :
* stime and utime are provided in machine unit (time or ticks) and will be converted in seconds here
* tm is provided in cdtime_t (and will be converted into seconds here)
* result values spercent and upercent are percent values
* this function returns 0 if spercent and upercernt are meaningful.
*/
prev_process_info_t *info;
if(NULL == (info = g_tree_lookup(prev_process_info, GINT_TO_POINTER(pid)))) {
info = g_slice_alloc(sizeof(*info));
info->tm = tm;
info->stime = stime;
info->utime = utime;
g_tree_insert(prev_process_info, GINT_TO_POINTER(pid), info);
*spercent = 0;
*upercent = 0;
return(-1);
}
*spercent = TICKS_TO_SECONDS((100 * (stime - info->stime)) / CDTIME_T_TO_TIME_T(tm - info->tm));
*upercent = TICKS_TO_SECONDS((100 * (utime - info->utime)) / CDTIME_T_TO_TIME_T(tm - info->tm));
info->stime = stime;
info->utime = utime;
info->tm = tm;
return(0);
} /* }}} */
// --[ Method ]---------------------------------------------------------------
//
// - Class : CStravaganzaMaxTools
//
// - prototype : bool BuildShaders()
//
// - Purpose : Builds the shader list from MAX's materials.
// Preview mode requires texture files to be stored with full
// path in order to load them. When we export, we only store the
// filename. Another thing is that in the export mode, we copy
// all textures into the path specified by the user if that
// option is checked.
//
// -----------------------------------------------------------------------------
bool CStravaganzaMaxTools::BuildShaders()
{
std::vector<Mtl*>::iterator it;
assert(m_vecShaders.empty());
if(!m_bPreview && m_bCopyTextures && m_strTexturePath == "")
{
CLogger::NotifyWindow("Textures won't be copied\nSpecify a valid output texture path first");
}
LOG.Write("\n\n-Building shaders: ");
for(it = m_vecMaterials.begin(); it != m_vecMaterials.end(); ++it)
{
Mtl* pMaxMaterial = *it;
assert(pMaxMaterial);
LOG.Write("\n %s", pMaxMaterial->GetName().data());
CShaderStandard* pShaderStd = new CShaderStandard;
pShaderStd->SetName(pMaxMaterial->GetName().data());
// Properties
StdMat2 *pMaxStandardMtl = NULL;
StdMat2 *pMaxBakedMtl = NULL;
float fAlpha;
if(pMaxMaterial->ClassID() == Class_ID(DMTL_CLASS_ID, 0))
{
pMaxStandardMtl = (StdMat2 *)pMaxMaterial;
}
else if(pMaxMaterial->ClassID() == Class_ID(BAKE_SHELL_CLASS_ID, 0))
{
pMaxStandardMtl = (StdMat2 *)pMaxMaterial->GetSubMtl(0);
pMaxBakedMtl = (StdMat2 *)pMaxMaterial->GetSubMtl(1);
}
if(pMaxStandardMtl)
{
// Standard material
fAlpha = pMaxStandardMtl->GetOpacity(0);
Shader* pMaxShader = pMaxStandardMtl->GetShader();
CVector4 v4Specular = ColorToVector4(pMaxStandardMtl->GetSpecular(0), 0.0f) * pMaxShader->GetSpecularLevel(0, 0);
pShaderStd->SetAmbient (ColorToVector4(pMaxStandardMtl->GetAmbient(0), 0.0f));
pShaderStd->SetDiffuse (ColorToVector4(pMaxStandardMtl->GetDiffuse(0), fAlpha));
pShaderStd->SetSpecular (v4Specular);
pShaderStd->SetShininess(pMaxShader->GetGlossiness(0, 0) * 128.0f);
if(pMaxStandardMtl->GetTwoSided() == TRUE)
{
pShaderStd->SetTwoSided(true);
}
// Need to cast to StdMat2 in order to get access to IsFaceted().
// ¿Is StdMat2 always the interface for standard materials?
if(((StdMat2*)pMaxStandardMtl)->IsFaceted())
{
pShaderStd->SetFaceted(true);
}
if(pMaxStandardMtl->GetWire() == TRUE)
{
pShaderStd->SetPostWire(true);
pShaderStd->SetWireLineThickness(pMaxStandardMtl->GetWireSize(0));
}
}
else
{
// Material != Standard
fAlpha = 1.0f; // pMaxMaterial->GetXParency();
pShaderStd->SetAmbient (ColorToVector4(pMaxMaterial->GetAmbient(), 0.0f));
pShaderStd->SetDiffuse (ColorToVector4(pMaxMaterial->GetDiffuse(), fAlpha));
pShaderStd->SetSpecular (CVector4(0.0f, 0.0f, 0.0f, 0.0f));
pShaderStd->SetShininess(0.0f);
}
// Layers
if(!pMaxStandardMtl)
{
m_vecShaders.push_back(pShaderStd);
continue;
}
bool bDiffuseMap32Bits = false;
StdMat2 *pStandardMtl;
for(int i = 0; i < 3; i++)
{
int nMap;
pStandardMtl = pMaxStandardMtl;
// 0 = diffuse, 1 == bump, 2 = lightmap (self illumination slot) or envmap (reflection slot)
if(i == 0)
{
nMap = ID_DI;
}
else if(i == 1)
{
nMap = ID_BU;
// If its a baked material, get the bump map from there
if(pMaxBakedMtl)
{
pStandardMtl = pMaxBakedMtl;
}
}
else if(i == 2)
{
bool bBaked = false;
// If its a baked material, get the map2 (lightmap) from there
if(pMaxBakedMtl)
{
if(pMaxBakedMtl->GetMapState(ID_SI) == MAXMAPSTATE_ENABLED)
{
bBaked = true;
nMap = ID_SI;
pStandardMtl = pMaxBakedMtl;
}
}
if(!bBaked)
{
if(pStandardMtl->GetMapState(ID_SI) == MAXMAPSTATE_ENABLED)
{
nMap = ID_SI;
}
else
{
nMap = ID_RL;
}
}
}
// Check validity
if(pStandardMtl->GetMapState(nMap) != MAXMAPSTATE_ENABLED)
{
if(i == 0)
{
LOG.Write("\n No diffuse. Skipping.");
break;
}
continue;
}
Texmap* pMaxTexmap = pStandardMtl->GetSubTexmap(nMap);
if(!pMaxTexmap)
{
if(i == 0)
{
LOG.Write("\n No diffuse. Skipping.");
break;
}
continue;
}
// Get texmaps
std::vector<std::string> vecTextures, vecPaths;
CShaderStandard::SLayerInfo layerInfo;
CShaderStandard::SBitmapInfo bitmapInfo;
if(pMaxTexmap->ClassID() == Class_ID(BMTEX_CLASS_ID, 0))
{
BitmapTex* pMaxBitmapTex = (BitmapTex*)pMaxTexmap;
Bitmap* pMaxBitmap = pMaxBitmapTex->GetBitmap(SECONDS_TO_TICKS(m_fStartTime));
StdUVGen* pMaxUVGen = pMaxBitmapTex->GetUVGen();
if(!pMaxBitmap)
{
if(i == 0)
{
LOG.Write("\n Invalid diffuse. Skipping.");
break;
}
continue;
}
assert(pMaxUVGen);
BitmapInfo bi = pMaxBitmap->Storage()->bi;
// bi.Name() returns the full path
// bi.Filename() returns just the filename
vecTextures.push_back(bi.Filename());
vecPaths. push_back(bi.Name());
LOG.Write("\n Bitmap %s", vecTextures[0].data());
// Check if diffuse texture has alpha channel
if(i == 0)
{
CBitmap bitmap;
CInputFile bitmapFile;
if(!bitmapFile.Open(bi.Name(), false))
{
CLogger::NotifyWindow("WARNING - CStravaganzaMaxTools::BuildShaders():\nUnable to load file %s", bi.Name());
}
else
{
if(!bitmap.Load(&bitmapFile, GetFileExt(bi.Name())))
{
CLogger::NotifyWindow("WARNING - CStravaganzaMaxTools::BuildShaders():\nUnable to load bitmap %s", bi.Name());
}
else
{
if(bitmap.GetBpp() == 32)
{
bDiffuseMap32Bits = true;
LOG.Write(" (with alpha channel)");
}
bitmap.Free();
}
bitmapFile.Close();
}
}
// Ok, copy properties
layerInfo.texInfo.bLoop = false;
layerInfo.texInfo.eTextureType = UtilGL::Texturing::CTexture::TEXTURE2D;
bitmapInfo.strFile = m_bPreview ? bi.Name() : bi.Filename();
bitmapInfo.bTile = ((pMaxUVGen->GetTextureTiling() & (U_WRAP | V_WRAP)) == (U_WRAP | V_WRAP)) ? true : false;
bitmapInfo.fSeconds = 0.0f;
bitmapInfo.bForceFiltering = false;
bitmapInfo.eFilter = UtilGL::Texturing::FILTER_TRILINEAR; // won't be used (forcefiltering = false)
layerInfo.texInfo.m_vecBitmaps.push_back(bitmapInfo);
layerInfo.eTexEnv = nMap == ID_RL ? CShaderStandard::TEXENV_ADD : CShaderStandard::TEXENV_MODULATE;
layerInfo.eUVGen = pMaxUVGen->GetCoordMapping(0) == UVMAP_SPHERE_ENV ? CShaderStandard::UVGEN_ENVMAPPING : CShaderStandard::UVGEN_EXPLICITMAPPING;
layerInfo.uMapChannel = pMaxUVGen->GetMapChannel();
layerInfo.v3ScrollSpeed = CVector3(0.0f, 0.0f, 0.0f);
layerInfo.v3RotationSpeed = CVector3(0.0f, 0.0f, 0.0f);
layerInfo.v3ScrollOffset = CVector3(pMaxUVGen->GetUOffs(0), pMaxUVGen->GetVOffs(0), 0.0f);
layerInfo.v3RotationOffset = CVector3(pMaxUVGen->GetUAng(0), pMaxUVGen->GetVAng(0), pMaxUVGen->GetWAng(0));
}
else if(pMaxTexmap->ClassID() == Class_ID(ACUBIC_CLASS_ID, 0))
{
ACubic* pMaxCubic = (ACubic*)pMaxTexmap;
IParamBlock2* pBlock = pMaxCubic->pblock;
Interval validRange = m_pMaxInterface->GetAnimRange();
for(int nFace = 0; nFace < 6; nFace++)
{
int nMaxFace;
switch(nFace)
{
case 0: nMaxFace = 3; break;
case 1: nMaxFace = 2; break;
case 2: nMaxFace = 1; break;
case 3: nMaxFace = 0; break;
case 4: nMaxFace = 5; break;
case 5: nMaxFace = 4; break;
}
TCHAR *name;
pBlock->GetValue(acubic_bitmap_names, TICKS_TO_SECONDS(m_fStartTime), name, validRange, nMaxFace);
vecPaths.push_back(name);
CStr path, file, ext;
SplitFilename(CStr(name), &path, &file, &ext);
std::string strFile = std::string(file.data()) + ext.data();
vecTextures.push_back(strFile);
bitmapInfo.strFile = m_bPreview ? name : strFile;
bitmapInfo.bTile = false;
bitmapInfo.fSeconds = 0.0f;
bitmapInfo.bForceFiltering = false;
bitmapInfo.eFilter = UtilGL::Texturing::FILTER_TRILINEAR;
layerInfo.texInfo.m_vecBitmaps.push_back(bitmapInfo);
}
layerInfo.texInfo.bLoop = false;
layerInfo.texInfo.eTextureType = UtilGL::Texturing::CTexture::TEXTURECUBEMAP;
layerInfo.eTexEnv = nMap == ID_RL ? CShaderStandard::TEXENV_ADD : CShaderStandard::TEXENV_MODULATE;
layerInfo.eUVGen = CShaderStandard::UVGEN_ENVMAPPING;
layerInfo.uMapChannel = 0;
layerInfo.v3ScrollSpeed = CVector3(0.0f, 0.0f, 0.0f);
layerInfo.v3RotationSpeed = CVector3(0.0f, 0.0f, 0.0f);
layerInfo.v3ScrollOffset = CVector3(0.0f, 0.0f, 0.0f);
layerInfo.v3RotationOffset = CVector3(0.0f, 0.0f, 0.0f);
}
else
{
if(i == 0)
{
LOG.Write("\n No diffuse. Skipping.");
break;
}
continue;
}
if(!m_bPreview && m_bCopyTextures && m_strTexturePath != "")
{
for(int nTex = 0; nTex != vecTextures.size(); nTex++)
{
// Copy textures into the specified folder
std::string strDestPath = m_strTexturePath;
if(strDestPath[strDestPath.length() - 1] != '\\')
{
strDestPath.append("\\", 1);
}
strDestPath.append(vecTextures[nTex]);
if(!CopyFile(vecPaths[nTex].data(), strDestPath.data(), FALSE))
{
CLogger::NotifyWindow("Unable to copy %s to\n%s", vecPaths[i], strDestPath.data());
}
}
}
if(layerInfo.eUVGen == CShaderStandard::UVGEN_ENVMAPPING && i == 1)
{
CLogger::NotifyWindow("%s : Bump with spheremapping not supported", pShaderStd->GetName().data());
}
else
{
// Add layer
switch(i)
{
case 0: pShaderStd->SetLayer(CShaderStandard::LAYER_DIFF, layerInfo); break;
case 1: pShaderStd->SetLayer(CShaderStandard::LAYER_BUMP, layerInfo); break;
case 2: pShaderStd->SetLayer(CShaderStandard::LAYER_MAP2, layerInfo); break;
}
}
}
// ¿Do we need blending?
if(ARE_EQUAL(fAlpha, 1.0f) && !bDiffuseMap32Bits)
{
pShaderStd->SetBlendSrcFactor(UtilGL::States::BLEND_ONE);
pShaderStd->SetBlendDstFactor(UtilGL::States::BLEND_ZERO);
}
else
{
pShaderStd->SetBlendSrcFactor(UtilGL::States::BLEND_SRCALPHA);
pShaderStd->SetBlendDstFactor(UtilGL::States::BLEND_INVSRCALPHA);
}
// Add shader
m_vecShaders.push_back(pShaderStd);
}
return true;
}
// --[ Method ]---------------------------------------------------------------
//
// - Class : CStravaganzaMaxTools
//
// - prototype : void ReadConfig(bool bLoadDefaults = false)
//
// - Purpose : Initializes the tool parameters, reading the previous
// configuration from a cfg file or creating default values.
// If bLoadDefaults is true, the config file won't be read and
// default values will be assigned.
//
// -----------------------------------------------------------------------------
void CStravaganzaMaxTools::ReadConfig(bool bLoadDefaults)
{
if(!m_hPanel) return;
ISpinnerControl* pMaxSpin;
ICustEdit* pMaxEdit;
CInputFile cfgFile;
m_bPreprocessMesh = true;
m_bUseLights = true;
m_eAnimType = ANIMATION_SAMPLING;
m_nAnimCheckStep = 20;
m_nNumPosSamplesPerSec = 30;
m_nNumSclSamplesPerSec = 30;
m_nNumRotSamplesPerSec = 30;
m_nNumCamSettingsPerSec = 15;
m_nNumLightSettingsPerSec = 15;
m_strFile = "";
m_bCopyTextures = true;
m_strTexturePath = "";
m_ePreviewType = CRenderVisitor::MODE_SOLID;
m_bFullscreen = false;
m_bLoop = true;
m_nPreviewResX = 800;
m_nPreviewResY = 600;
m_fViewportHeight = 1.0f;
m_bShowStats = true;
m_bRenderToAvi = false;
m_strAviFile = "";
m_strPreviewCamera = "";
if(cfgFile.Open(m_strCfgFile, false) && !bLoadDefaults)
{
int nValue;
// Common options
cfgFile.ReadInt(&nValue);
m_bPreprocessMesh = nValue ? true : false;
cfgFile.ReadInt(&nValue);
m_bUseLights = nValue ? true : false;
m_fStartTime = TICKS_TO_SECONDS(m_pMaxInterface->GetAnimRange().Start());
m_fEndTime = TICKS_TO_SECONDS(m_pMaxInterface->GetAnimRange().End());
cfgFile.ReadInt(&m_nAnimCheckStep);
cfgFile.ReadInt(&m_nNumPosSamplesPerSec);
cfgFile.ReadInt(&m_nNumSclSamplesPerSec);
cfgFile.ReadInt(&m_nNumRotSamplesPerSec);
cfgFile.ReadInt(&m_nNumCamSettingsPerSec);
cfgFile.ReadInt(&m_nNumLightSettingsPerSec);
cfgFile.ReadInt(&nValue);
switch(nValue)
{
case ANIMATION_SAMPLING: m_eAnimType = ANIMATION_SAMPLING; break;
case ANIMATION_MAXKEYS: m_eAnimType = ANIMATION_MAXKEYS; break;
}
// Export options
cfgFile.ReadStringZero(&m_strFile);
cfgFile.ReadInt(&nValue);
m_bCopyTextures = nValue ? true : false;
cfgFile.ReadStringZero(&m_strTexturePath);
// Preview options
cfgFile.ReadStringZero(&m_strPreviewCamera);
FillCameraCombobox(GetDlgItem(m_hPanel, IDC_COMBO_CAMERA), m_pMaxInterface->GetRootNode());
cfgFile.ReadInt(&nValue);
switch(nValue)
{
case CRenderVisitor::MODE_WIREFRAME: m_ePreviewType = CRenderVisitor::MODE_WIREFRAME; break;
case CRenderVisitor::MODE_SOLID: m_ePreviewType = CRenderVisitor::MODE_SOLID; break;
case CRenderVisitor::MODE_FULLDETAIL: m_ePreviewType = CRenderVisitor::MODE_FULLDETAIL; break;
}
cfgFile.ReadInt(&nValue);
m_bFullscreen = nValue ? true : false;
cfgFile.ReadInt(&nValue);
m_bLoop = nValue ? true : false;
cfgFile.ReadInt (&m_nPreviewResX);
cfgFile.ReadInt (&m_nPreviewResY);
cfgFile.ReadFloat(&m_fViewportHeight);
cfgFile.ReadInt (&nValue);
m_bShowStats = nValue ? true : false;
cfgFile.ReadInt (&nValue);
m_bRenderToAvi = nValue ? true : false;
cfgFile.ReadStringZero(&m_strAviFile);
}
cfgFile.Close();
// Common
CheckDlgButton(m_hPanel, IDC_CHECK_PREPROCESSMESHES, m_bPreprocessMesh ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(m_hPanel, IDC_CHECK_USELIGHTS, m_bUseLights ? BST_CHECKED : BST_UNCHECKED);
EnableWindow(GetDlgItem(m_hPanel, IDC_RADIO_USEMAXKEYS), FALSE);
switch(m_eAnimType)
{
case ANIMATION_SAMPLING:
CheckRadioButton(m_hPanel, IDC_RADIO_USESAMPLING, IDC_RADIO_USEMAXKEYS, IDC_RADIO_USESAMPLING);
break;
case ANIMATION_MAXKEYS:
CheckRadioButton(m_hPanel, IDC_RADIO_USESAMPLING, IDC_RADIO_USEMAXKEYS, IDC_RADIO_USEMAXKEYS);
break;
}
pMaxSpin = GetISpinner(GetDlgItem(m_hPanel, IDC_SPIN_STARTTIME));
pMaxSpin->LinkToEdit(GetDlgItem(m_hPanel, IDC_EDIT_STARTTIME), EDITTYPE_FLOAT);
pMaxSpin->SetLimits(m_fStartTime, m_fEndTime, TRUE);
pMaxSpin->SetScale(0.01f);
pMaxSpin->SetValue(m_fStartTime, FALSE);
ReleaseISpinner(pMaxSpin);
pMaxSpin = GetISpinner(GetDlgItem(m_hPanel, IDC_SPIN_ENDTIME));
pMaxSpin->LinkToEdit(GetDlgItem(m_hPanel, IDC_EDIT_ENDTIME), EDITTYPE_FLOAT);
pMaxSpin->SetLimits(m_fStartTime, m_fEndTime, TRUE);
pMaxSpin->SetScale(0.01f);
pMaxSpin->SetValue(m_fEndTime, FALSE);
ReleaseISpinner(pMaxSpin);
pMaxSpin = GetISpinner(GetDlgItem(m_hPanel, IDC_SPIN_ANIMCHECKSTEP));
pMaxSpin->LinkToEdit(GetDlgItem(m_hPanel, IDC_EDIT_ANIMCHECKSTEP), EDITTYPE_INT);
pMaxSpin->SetLimits(0, 100, TRUE);
pMaxSpin->SetScale(1);
pMaxSpin->SetValue(m_nAnimCheckStep, FALSE);
ReleaseISpinner(pMaxSpin);
pMaxSpin = GetISpinner(GetDlgItem(m_hPanel, IDC_SPIN_POSSAMPLINGFREQ));
pMaxSpin->LinkToEdit(GetDlgItem(m_hPanel, IDC_EDIT_POSSAMPLINGFREQ), EDITTYPE_INT);
pMaxSpin->SetLimits(0, 100, TRUE);
pMaxSpin->SetScale(1);
pMaxSpin->SetValue(m_nNumPosSamplesPerSec, FALSE);
ReleaseISpinner(pMaxSpin);
pMaxSpin = GetISpinner(GetDlgItem(m_hPanel, IDC_SPIN_SCLSAMPLINGFREQ));
pMaxSpin->LinkToEdit(GetDlgItem(m_hPanel, IDC_EDIT_SCLSAMPLINGFREQ), EDITTYPE_INT);
pMaxSpin->SetLimits(0, 100, TRUE);
pMaxSpin->SetScale(1);
pMaxSpin->SetValue(m_nNumSclSamplesPerSec, FALSE);
ReleaseISpinner(pMaxSpin);
pMaxSpin = GetISpinner(GetDlgItem(m_hPanel, IDC_SPIN_ROTSAMPLINGFREQ));
pMaxSpin->LinkToEdit(GetDlgItem(m_hPanel, IDC_EDIT_ROTSAMPLINGFREQ), EDITTYPE_INT);
pMaxSpin->SetLimits(0, 100, TRUE);
pMaxSpin->SetScale(1);
pMaxSpin->SetValue(m_nNumRotSamplesPerSec, FALSE);
ReleaseISpinner(pMaxSpin);
// Export
pMaxEdit = GetICustEdit(GetDlgItem(m_hPanel, IDC_EDIT_DESTINATIONFILE));
pMaxEdit->SetText((char*)m_strFile.data());
pMaxEdit->SetLeading(2);
ReleaseICustEdit(pMaxEdit);
CheckDlgButton(m_hPanel, IDC_CHECK_COPYTEXTURES, m_bCopyTextures ? BST_CHECKED : BST_UNCHECKED);
pMaxEdit = GetICustEdit(GetDlgItem(m_hPanel, IDC_EDIT_TEXTUREFOLDER));
pMaxEdit->SetText((char*)m_strTexturePath.data());
pMaxEdit->SetLeading(2);
ReleaseICustEdit(pMaxEdit);
EnableWindow(GetDlgItem(m_hPanel, IDC_EDIT_TEXTUREFOLDER), m_bCopyTextures ? TRUE : FALSE);
EnableWindow(GetDlgItem(m_hPanel, IDC_BUTTON_TEXTUREFOLDER), m_bCopyTextures ? TRUE : FALSE);
// Preview
switch(m_ePreviewType)
{
case CRenderVisitor::MODE_WIREFRAME:
CheckRadioButton(m_hPanel, IDC_RADIO_WIREFRAME, IDC_RADIO_FULLDETAIL, IDC_RADIO_WIREFRAME);
break;
case CRenderVisitor::MODE_SOLID:
CheckRadioButton(m_hPanel, IDC_RADIO_WIREFRAME, IDC_RADIO_FULLDETAIL, IDC_RADIO_SOLID);
break;
case CRenderVisitor::MODE_FULLDETAIL:
CheckRadioButton(m_hPanel, IDC_RADIO_WIREFRAME, IDC_RADIO_FULLDETAIL, IDC_RADIO_FULLDETAIL);
break;
}
CheckDlgButton(m_hPanel, IDC_CHECK_FULLSCREEN, m_bFullscreen ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(m_hPanel, IDC_CHECK_LOOP, m_bLoop ? BST_CHECKED : BST_UNCHECKED);
pMaxEdit = GetICustEdit(GetDlgItem(m_hPanel, IDC_EDIT_RESW));
pMaxEdit->SetText(m_nPreviewResX);
ReleaseICustEdit(pMaxEdit);
pMaxEdit = GetICustEdit(GetDlgItem(m_hPanel, IDC_EDIT_RESH));
pMaxEdit->SetText(m_nPreviewResY);
ReleaseICustEdit(pMaxEdit);
pMaxSpin = GetISpinner(GetDlgItem(m_hPanel, IDC_SPIN_VIEWPORTHEIGHT));
pMaxSpin->LinkToEdit(GetDlgItem(m_hPanel, IDC_EDIT_VIEWPORTHEIGHT), EDITTYPE_FLOAT);
pMaxSpin->SetLimits(0.0f, 1.0f, TRUE);
pMaxSpin->SetScale(0.01f);
pMaxSpin->SetValue(m_fViewportHeight, FALSE);
ReleaseISpinner(pMaxSpin);
CheckDlgButton(m_hPanel, IDC_CHECK_SHOWSTATS, m_bShowStats ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(m_hPanel, IDC_CHECK_RENDERTOAVI, m_bRenderToAvi ? BST_CHECKED : BST_UNCHECKED);
pMaxEdit = GetICustEdit(GetDlgItem(m_hPanel, IDC_EDIT_AVIFILE));
pMaxEdit->SetText((char*)m_strAviFile.data());
pMaxEdit->SetLeading(2);
ReleaseICustEdit(pMaxEdit);
EnableWindow(GetDlgItem(m_hPanel, IDC_EDIT_AVIFILE), m_bRenderToAvi ? TRUE : FALSE);
EnableWindow(GetDlgItem(m_hPanel, IDC_BUTTON_AVIFILE), m_bRenderToAvi ? TRUE : FALSE);
}
