typename T::return_type operator()(T& t, const char* d, typename T::size_type s)
{
_clear_flag = false;
data_type::size_type offset = 0;
if ( _data.empty() )
{
if (_data.capacity() > 0 )
data_type(_data).swap(_data);
offset = _parse_(t, d, s, 0, 0);
if (!_clear_flag)
{
if (offset == static_cast<data_type::size_type>(-1))
_assign(d, d + s);
else if ( static_cast<typename T::size_type>(offset) != s)
_assign(d + offset, d + s);
}
}
else
{
const size_t datasize = _data.size();
if (_data.capacity() < datasize + s) {
_data.reserve( datasize < 16384 ? datasize + s : datasize+(datasize>>1)+s);
}
std::copy(d, d + s, std::back_inserter(_data));
offset = _parse_(t, &(_data[0]), _data.size(), 0, datasize>size_sep ? datasize-size_sep : 0);
if (!_clear_flag)
{
if ( offset == static_cast<typename T::size_type>( _data.size() ) )
_data.clear();
else if ( offset!= static_cast<data_type::size_type>(-1) )
_data.erase( _data.begin(), _data.begin() + offset );
}
}
void Conf::load(kchar* cfgFile)
{
FILE* pf = _ttfopen(cfgFile, "rb");
if(pf) {
AutoCall<int (*)(FILE*), FILE*> _a(::fclose, pf);
char pred[128];
char val[128];
char line[256];
bool inComment = false;
try {
while(!feof(pf)) {
if(fgets(line,255,pf)) {
str_prepline(line);
if(*line==0)
continue;
if(inComment || *line=='#')
continue;
kchar* pnext = str_ccpy(pred, line,'=');
if(*pred=='[') {
str_lrtim(pred);
_section = pred;
continue;
} else if(*pred=='}') {
_assign("}", " ", 0);
}
if(pnext && *pnext) {
str_scpy(val, (char*)pnext+1, "#");
str_lrtim(val);
str_lrtim(pred);
_assign(pred, val, 0);
}
} else
break;
if(feof(pf)) {
break;
}
}
} catch(int& err) {
}
} else {
printf( "Cannot find configuration file in curent folder\r\n");
exit(0);
}
}
/**
* \brief Assignment operator.
* \param[in] other Another lexeme sequence to assign to the current object.
* \returns Reference to the original object after assignment.
*/
Lexeme &Lexeme::operator =(const Lexeme &other)
{
if (this != &other) {
_destroy();
_assign(other);
}
return *this;
}
const NEModule& NEModule::operator=(const ThisClass& rhs)
{
if(this == &rhs) return *this;
SuperClass::operator=(rhs);
return _assign(rhs);
}
// ---------------------------------------------------------------------------------
// 히스토리: 2011-07-07 이태훈 개발 완료
// ---------------------------------------------------------------------------------
const NESwitchableUnit NE_DLL &NESwitchableUnit::operator=(const NESwitchableUnit& source)
{
if(this == &source) return *this;
NEUnit::operator=(source);
return _assign(source);
}
GError*
meta0_assign_prefix_to_meta1(struct meta0_backend_s *m0, gchar *ns_name, gboolean nocheck)
{
// GET meta1 list from conscience
GList *working_m1list = NULL;
GSList *unref_m1list = NULL;
GError *error;
GPtrArray *new_meta1ref = NULL;
GRID_INFO("START Assign prefix");
error = _initContext(m0);
if (error) {
goto errorLabel;
}
// build working list , list sorted by score
error = _init_assign(ns_name,&working_m1list,&unref_m1list);
if ( error ) {
goto errorLabel;
}
if ( nocheck ) {
error =_check(working_m1list);
if ( error ) {
goto errorLabel;
}
}
error = _assign(working_m1list,unref_m1list);
if ( error ) {
goto errorLabel;
}
new_meta1ref = _updated_meta1ref();
error = meta0_backend_assign(m0, context->array_meta1_by_prefix, new_meta1ref,FALSE);
if ( error ) {
GRID_ERROR("failed to update BDD :(%d) %s", error->code, error->message);
goto errorLabel;
}
context->lastAssignTime=g_date_time_new_now_local();
errorLabel :
_resetContext();
if (new_meta1ref) {
meta0_utils_array_meta1ref_clean(new_meta1ref);
}
if (working_m1list) {
g_list_free(working_m1list);
working_m1list=NULL;
}
if (unref_m1list) {
g_slist_free(unref_m1list);
unref_m1list=NULL;
}
GRID_INFO("END ASSIGN");
return error;
}
RString::RString(XString x)
: owned(nullptr)
{
const RString *f = x.base();
const char *xb = &*x.begin();
const char *xe = &*x.end();
const char *fb = f ? &*f->begin() : nullptr;
const char *fe = f ? &*f->end() : nullptr;
if (f && xb == fb && xe == fe)
*this = *f;
else
_assign(x.begin(), x.end());
}
void TreeEqualizer::_assign( Node* node, const Viewport& vp,
const Range& range )
{
LBLOG( LOG_LB2 ) << "assign " << vp << ", " << range << " time "
<< node->time << " split " << node->split << std::endl;
LBASSERTINFO( vp.isValid(), vp );
LBASSERTINFO( range.isValid(), range );
LBASSERTINFO( node->resources > 0.f || !vp.hasArea() || !range.hasData(),
"Assigning work to unused compound: " << vp << ", " << range);
Compound* compound = node->compound;
if( compound )
{
LBASSERTINFO( vp == Viewport::FULL || range == Range::ALL,
"Mixed 2D/DB load-balancing not implemented" );
compound->setViewport( vp );
compound->setRange( range );
LBLOG( LOG_LB2 ) << compound->getChannel()->getName() << " set " << vp
<< ", " << range << std::endl;
return;
}
switch( node->mode )
{
case MODE_VERTICAL:
{
// Ensure minimum size
const Compound* root = getCompound();
const float pvpW = float( root->getInheritPixelViewport().w );
const float end = vp.getXEnd();
const float boundary = float( node->boundary2i.x( )) / pvpW;
float absoluteSplit = vp.x + vp.w * node->split;
if( node->left->resources == 0.f )
absoluteSplit = vp.x;
else if( node->right->resources == 0.f )
absoluteSplit = end;
else if( boundary > 0 )
{
const float right = vp.getXEnd() - absoluteSplit;
const float left = absoluteSplit - vp.x;
const float maxRight = float( node->right->maxSize.x( )) / pvpW;
const float maxLeft = float( node->left->maxSize.x( )) / pvpW;
if( right > maxRight )
absoluteSplit = end - maxRight;
else if( left > maxLeft )
absoluteSplit = vp.x + maxLeft;
if( (absoluteSplit - vp.x) < boundary )
absoluteSplit = vp.x + boundary;
if( (end - absoluteSplit) < boundary )
absoluteSplit = end - boundary;
const uint32_t ratio = uint32_t( absoluteSplit / boundary + .5f );
absoluteSplit = ratio * boundary;
}
absoluteSplit = LB_MAX( absoluteSplit, vp.x );
absoluteSplit = LB_MIN( absoluteSplit, end);
node->split = (absoluteSplit - vp.x ) / vp.w;
LBLOG( LOG_LB2 ) << "Constrained split " << vp << " at X "
<< node->split << std::endl;
// traverse children
Viewport childVP = vp;
childVP.w = (absoluteSplit - vp.x);
_assign( node->left, childVP, range );
childVP.x = childVP.getXEnd();
childVP.w = end - childVP.x;
// Fix 2994111: Rounding errors with 2D LB and 16 sources
// Floating point rounding may create a width for the 'right'
// child which is slightly below the parent width. Correct it.
while( childVP.getXEnd() < end )
childVP.w += std::numeric_limits< float >::epsilon();
_assign( node->right, childVP, range );
break;
}
case MODE_HORIZONTAL:
{
// Ensure minimum size
const Compound* root = getCompound();
const float pvpH = float( root->getInheritPixelViewport().h );
const float end = vp.getYEnd();
const float boundary = float( node->boundary2i.y( )) / pvpH;
float absoluteSplit = vp.y + vp.h * node->split;
if( node->left->resources == 0.f )
absoluteSplit = vp.y;
else if( node->right->resources == 0.f )
absoluteSplit = end;
else if( boundary > 0 )
{
const float right = vp.getYEnd() - absoluteSplit;
const float left = absoluteSplit - vp.y;
const float maxRight = float( node->right->maxSize.y( )) / pvpH;
const float maxLeft = float( node->left->maxSize.y( )) / pvpH;
if( right > maxRight )
absoluteSplit = end - maxRight;
else if( left > maxLeft )
absoluteSplit = vp.y + maxLeft;
if( (absoluteSplit - vp.y) < boundary )
absoluteSplit = vp.y + boundary;
if( (end - absoluteSplit) < boundary )
absoluteSplit = end - boundary;
const uint32_t ratio = uint32_t( absoluteSplit / boundary + .5f );
absoluteSplit = ratio * boundary;
}
absoluteSplit = LB_MAX( absoluteSplit, vp.y );
absoluteSplit = LB_MIN( absoluteSplit, end);
node->split = (absoluteSplit - vp.y ) / vp.h;
LBLOG( LOG_LB2 ) << "Constrained split " << vp << " at X "
<< node->split << std::endl;
// traverse children
Viewport childVP = vp;
childVP.h = (absoluteSplit - vp.y);
_assign( node->left, childVP, range );
childVP.y = childVP.getYEnd();
childVP.h = end - childVP.y;
// Fix 2994111: Rounding errors with 2D LB and 16 sources
// Floating point rounding may create a width for the 'right'
// child which is slightly below the parent width. Correct it.
while( childVP.getYEnd() < end )
childVP.h += std::numeric_limits< float >::epsilon();
_assign( node->right, childVP, range );
break;
}
case MODE_DB:
{
LBASSERT( vp == Viewport::FULL );
const float end = range.end;
float absoluteSplit = range.start + (range.end-range.start)*node->split;
const float boundary( node->boundaryf );
if( node->left->resources == 0.f )
absoluteSplit = range.start;
else if( node->right->resources == 0.f )
absoluteSplit = end;
const uint32_t ratio = uint32_t( absoluteSplit / boundary + .5f );
absoluteSplit = ratio * boundary;
if( (absoluteSplit - range.start) < boundary )
absoluteSplit = range.start;
if( (end - absoluteSplit) < boundary )
absoluteSplit = end;
node->split = (absoluteSplit-range.start) / (range.end-range.start);
LBLOG( LOG_LB2 ) << "Constrained split " << range << " at pos "
<< node->split << std::endl;
Range childRange = range;
childRange.end = absoluteSplit;
_assign( node->left, vp, childRange );
childRange.start = childRange.end;
childRange.end = range.end;
_assign( node->right, vp, childRange);
break;
}
default:
LBUNIMPLEMENTED;
}
}
///////////////
// Operators //
///////////////
image& image::operator=(const image& src)
{
_assign(src);
return *this;
}
///////////////
// Operators //
///////////////
triangleMesh& triangleMesh::operator=(const triangleMesh& tm)
{
_assign(tm);
return *this;
}
// ---------------------------------------------------------------------------------
// 히스토리: 2011-07-07 이태훈 개발 완료
// ---------------------------------------------------------------------------------
NE_DLL Kernal::Kernal(const Kernal& source)
: NEModule(source), _script_manager(NE_NULL), _node_manager(NE_NULL)
{
_assign(source);
}
NE_DLL NEComponent::NEComponent(const NEComponent& source)
: NEUnit(source)
{
_assign(source);
}
void LoadEqualizer::_computeSplit( Node* node, const float time,
LBDatas* datas, const Viewport& vp,
const Range& range )
{
LBLOG( LOG_LB2 ) << "_computeSplit " << vp << ", " << range << " time "
<< time << std::endl;
LBASSERTINFO( vp.isValid(), vp );
LBASSERTINFO( range.isValid(), range );
LBASSERTINFO( node->resources > 0.f || !vp.hasArea() || !range.hasData(),
"Assigning " << node->resources <<
" work to viewport " << vp << ", " << range );
Compound* compound = node->compound;
if( compound )
{
_assign( compound, vp, range );
return;
}
LBASSERT( node->left && node->right );
LBDatas workingSet = datas[ node->mode ];
const float leftTime = node->resources > 0 ?
time * node->left->resources / node->resources : 0.f;
float timeLeft = LB_MIN( leftTime, time ); // correct for fp rounding error
switch( node->mode )
{
case MODE_VERTICAL:
{
LBASSERT( range == Range::ALL );
float splitPos = vp.x;
const float end = vp.getXEnd();
while( timeLeft > std::numeric_limits< float >::epsilon() &&
splitPos < end )
{
LBLOG( LOG_LB2 ) << timeLeft << "ms left using "
<< workingSet.size() << " tiles" << std::endl;
// remove all irrelevant items from working set
for( LBDatas::iterator i = workingSet.begin();
i != workingSet.end(); )
{
const Data& data = *i;
if( data.vp.getXEnd() > splitPos )
++i;
else
i = workingSet.erase( i );
}
if( workingSet.empty( ))
break;
// find next 'discontinouity' in loads
float currentPos = 1.0f;
for( LBDatas::const_iterator i = workingSet.begin();
i != workingSet.end(); ++i )
{
const Data& data = *i;
if( data.vp.x > splitPos && data.vp.x < currentPos )
currentPos = data.vp.x;
const float xEnd = data.vp.getXEnd();
if( xEnd > splitPos && xEnd < currentPos )
currentPos = xEnd;
}
const float width = currentPos - splitPos;
LBASSERTINFO( width > 0.f, currentPos << "<=" << splitPos );
LBASSERT( currentPos <= 1.0f );
// accumulate normalized load in splitPos...currentPos
LBLOG( LOG_LB2 ) << "Computing load in X " << splitPos << "..."
<< currentPos << std::endl;
float currentTime = 0.f;
for( LBDatas::const_iterator i = workingSet.begin();
i != workingSet.end(); ++i )
{
const Data& data = *i;
if( data.vp.x >= currentPos ) // not yet needed data sets
break;
float yContrib = data.vp.h;
if( data.vp.y < vp.y )
yContrib -= (vp.y - data.vp.y);
const float dataEnd = data.vp.getYEnd();
const float vpEnd = vp.getYEnd();
if( dataEnd > vpEnd )
yContrib -= (dataEnd - vpEnd);
if( yContrib > 0.f )
{
const float percentage = ( width / data.vp.w ) *
( yContrib / data.vp.h );
currentTime += ( data.time * percentage );
LBLOG( LOG_LB2 ) << data.vp << " contributes "
<< yContrib << " in " << vp.h << " ("
<< percentage << ") with " << data.time
<< ": " << ( data.time * percentage )
<< " vp.y " << vp.y << " dataEnd "
<< dataEnd << " vpEnd " << vpEnd
<< std::endl;
LBASSERT( percentage < 1.01f )
}
}
LBLOG( LOG_LB2 ) << splitPos << "..." << currentPos << ": t="
<< currentTime << " of " << timeLeft
<< std::endl;
if( currentTime >= timeLeft ) // found last region
{
splitPos += ( width * timeLeft / currentTime );
timeLeft = 0.0f;
}
else
{
timeLeft -= currentTime;
splitPos = currentPos;
}
}
LBLOG( LOG_LB2 ) << "Should split at X " << splitPos << std::endl;
if( getDamping() < 1.f )
splitPos = (1.f - getDamping()) * splitPos +
getDamping() * node->split;
LBLOG( LOG_LB2 ) << "Dampened split at X " << splitPos << std::endl;
// There might be more time left due to MIN_PIXEL rounding by parent
// LBASSERTINFO( timeLeft <= .001f, timeLeft );
// Ensure minimum size
const Compound* root = getCompound();
const float pvpW = static_cast< float >(
root->getInheritPixelViewport().w );
const float boundary = static_cast< float >( node->boundary2i.x()) /
pvpW;
if( node->left->resources == 0.f )
splitPos = vp.x;
else if( node->right->resources == 0.f )
splitPos = end;
else if( boundary > 0 )
{
const float lengthRight = vp.getXEnd() - splitPos;
const float lengthLeft = splitPos - vp.x;
const float maxRight =
static_cast< float >( node->right->maxSize.x( )) / pvpW;
const float maxLeft =
static_cast< float >( node->left->maxSize.x( )) / pvpW;
if( lengthRight > maxRight )
splitPos = end - maxRight;
else if( lengthLeft > maxLeft )
splitPos = vp.x + maxLeft;
if( (splitPos - vp.x) < boundary )
splitPos = vp.x + boundary;
if( (end - splitPos) < boundary )
splitPos = end - boundary;
const uint32_t ratio =
static_cast< uint32_t >( splitPos / boundary + .5f );
splitPos = ratio * boundary;
}
splitPos = LB_MAX( splitPos, vp.x );
splitPos = LB_MIN( splitPos, end);
const float newPixelW = pvpW * splitPos;
const float oldPixelW = pvpW * node->split;
if( int( fabs(newPixelW - oldPixelW) ) < node->resistance2i.x( ))
splitPos = node->split;
else
node->split = splitPos;
LBLOG( LOG_LB2 ) << "Constrained split " << vp << " at X "
<< splitPos << std::endl;
// balance children
Viewport childVP = vp;
childVP.w = (splitPos - vp.x);
_computeSplit( node->left, leftTime, datas, childVP, range );
childVP.x = childVP.getXEnd();
childVP.w = end - childVP.x;
// Fix 2994111: Rounding errors with 2D LB and 16 sources
// Floating point rounding may create a width for the 'right'
// child which is slightly below the parent width. Correct it.
while( childVP.getXEnd() < end )
childVP.w += std::numeric_limits< float >::epsilon();
_computeSplit( node->right, time-leftTime, datas, childVP, range );
break;
}
case MODE_HORIZONTAL:
{
LBASSERT( range == Range::ALL );
float splitPos = vp.y;
const float end = vp.getYEnd();
while( timeLeft > std::numeric_limits< float >::epsilon() &&
splitPos < end )
{
LBLOG( LOG_LB2 ) << timeLeft << "ms left using "
<< workingSet.size() << " tiles" << std::endl;
// remove all unrelevant items from working set
for( LBDatas::iterator i = workingSet.begin();
i != workingSet.end(); )
{
const Data& data = *i;
if( data.vp.getYEnd() > splitPos )
++i;
else
i = workingSet.erase( i );
}
if( workingSet.empty( ))
break;
// find next 'discontinuouity' in loads
float currentPos = 1.0f;
for( LBDatas::const_iterator i = workingSet.begin();
i != workingSet.end(); ++i )
{
const Data& data = *i;
if( data.vp.y > splitPos && data.vp.y < currentPos )
currentPos = data.vp.y;
const float yEnd = data.vp.getYEnd();
if( yEnd > splitPos && yEnd < currentPos )
currentPos = yEnd;
}
const float height = currentPos - splitPos;
LBASSERTINFO( height > 0.f, currentPos << "<=" << splitPos );
LBASSERT( currentPos <= 1.0f );
// accumulate normalized load in splitPos...currentPos
LBLOG( LOG_LB2 ) << "Computing load in Y " << splitPos << "..."
<< currentPos << std::endl;
float currentTime = 0.f;
for( LBDatas::const_iterator i = workingSet.begin();
i != workingSet.end(); ++i )
{
const Data& data = *i;
if( data.vp.y >= currentPos ) // not yet needed data sets
break;
float xContrib = data.vp.w;
if( data.vp.x < vp.x )
xContrib -= (vp.x - data.vp.x);
const float dataEnd = data.vp.getXEnd();
const float vpEnd = vp.getXEnd();
if( dataEnd > vpEnd )
xContrib -= (dataEnd - vpEnd);
if( xContrib > 0.f )
{
const float percentage = ( height / data.vp.h ) *
( xContrib / data.vp.w );
currentTime += ( data.time * percentage );
LBLOG( LOG_LB2 ) << data.vp << " contributes "
<< xContrib << " in " << vp.w << " ("
<< percentage << ") with " << data.time
<< ": " << ( data.time * percentage )
<< " total " << currentTime << " vp.x "
<< vp.x << " dataEnd " << dataEnd
<< " vpEnd " << vpEnd << std::endl;
LBASSERT( percentage < 1.01f )
}
}
LBLOG( LOG_LB2 ) << splitPos << "..." << currentPos << ": t="
<< currentTime << " of " << timeLeft
<< std::endl;
if( currentTime >= timeLeft ) // found last region
{
splitPos += (height * timeLeft / currentTime );
timeLeft = 0.0f;
}
else
{
timeLeft -= currentTime;
splitPos = currentPos;
}
}
LBLOG( LOG_LB2 ) << "Should split at Y " << splitPos << std::endl;
if( getDamping() < 1.f )
splitPos = (1.f - getDamping( )) * splitPos +
getDamping() * node->split;
LBLOG( LOG_LB2 ) << "Dampened split at Y " << splitPos << std::endl;
const Compound* root = getCompound();
const float pvpH = static_cast< float >(
root->getInheritPixelViewport().h );
const float boundary = static_cast< float >(node->boundary2i.y( )) /
pvpH;
if( node->left->resources == 0.f )
splitPos = vp.y;
else if( node->right->resources == 0.f )
splitPos = end;
else if ( boundary > 0 )
{
const float lengthRight = vp.getYEnd() - splitPos;
const float lengthLeft = splitPos - vp.y;
const float maxRight =
static_cast< float >( node->right->maxSize.y( )) / pvpH;
const float maxLeft =
static_cast< float >( node->left->maxSize.y( )) / pvpH;
if( lengthRight > maxRight )
splitPos = end - maxRight;
else if( lengthLeft > maxLeft )
splitPos = vp.y + maxLeft;
if( (splitPos - vp.y) < boundary )
splitPos = vp.y + boundary;
if( (end - splitPos) < boundary )
splitPos = end - boundary;
const uint32_t ratio =
static_cast< uint32_t >( splitPos / boundary + .5f );
splitPos = ratio * boundary;
}
splitPos = LB_MAX( splitPos, vp.y );
splitPos = LB_MIN( splitPos, end );
const float newPixelH = pvpH * splitPos;
const float oldPixelH = pvpH * node->split;
if( int( fabs(newPixelH - oldPixelH) ) < node->resistance2i.y( ))
splitPos = node->split;
else
node->split = splitPos;
LBLOG( LOG_LB2 ) << "Constrained split " << vp << " at Y "
<< splitPos << std::endl;
Viewport childVP = vp;
childVP.h = (splitPos - vp.y);
_computeSplit( node->left, leftTime, datas, childVP, range );
childVP.y = childVP.getYEnd();
childVP.h = end - childVP.y;
while( childVP.getYEnd() < end )
childVP.h += std::numeric_limits< float >::epsilon();
_computeSplit( node->right, time - leftTime, datas, childVP, range);
break;
}
case MODE_DB:
{
LBASSERT( vp == Viewport::FULL );
float splitPos = range.start;
const float end = range.end;
while( timeLeft > std::numeric_limits< float >::epsilon() &&
splitPos < end )
{
LBLOG( LOG_LB2 ) << timeLeft << "ms left using "
<< workingSet.size() << " tiles" << std::endl;
// remove all irrelevant items from working set
for( LBDatas::iterator i = workingSet.begin();
i != workingSet.end(); )
{
const Data& data = *i;
if( data.range.end > splitPos )
++i;
else
i = workingSet.erase( i );
}
if( workingSet.empty( ))
break;
// find next 'discontinouity' in loads
float currentPos = 1.0f;
for( LBDatas::const_iterator i = workingSet.begin();
i != workingSet.end(); ++i )
{
const Data& data = *i;
currentPos = LB_MIN( currentPos, data.range.end );
}
const float size = currentPos - splitPos;
LBASSERTINFO( size > 0.f, currentPos << "<=" << splitPos );
LBASSERT( currentPos <= 1.0f );
// accumulate normalized load in splitPos...currentPos
LBLOG( LOG_LB2 ) << "Computing load in range " << splitPos
<< "..." << currentPos << std::endl;
float currentTime = 0.f;
for( LBDatas::const_iterator i = workingSet.begin();
i != workingSet.end(); ++i )
{
const Data& data = *i;
if( data.range.start >= currentPos ) // not yet needed data
break;
#if 0
// make sure we cover full area
LBASSERTINFO( data.range.start <= splitPos,
data.range.start << " > " << splitPos );
LBASSERTINFO( data.range.end >= currentPos,
data.range.end << " < " << currentPos);
#endif
currentTime += data.time * size / data.range.getSize();
}
LBLOG( LOG_LB2 ) << splitPos << "..." << currentPos << ": t="
<< currentTime << " of " << timeLeft
<< std::endl;
if( currentTime >= timeLeft ) // found last region
{
const float width = currentPos - splitPos;
splitPos += (width * timeLeft / currentTime );
timeLeft = 0.0f;
}
else
{
timeLeft -= currentTime;
splitPos = currentPos;
}
}
LBLOG( LOG_LB2 ) << "Should split at " << splitPos << std::endl;
if( getDamping() < 1.f )
splitPos = (1.f - getDamping( )) * splitPos +
getDamping() * node->split;
LBLOG( LOG_LB2 ) << "Dampened split at " << splitPos << std::endl;
const float boundary( node->boundaryf );
if( node->left->resources == 0.f )
splitPos = range.start;
else if( node->right->resources == 0.f )
splitPos = end;
const uint32_t ratio = static_cast< uint32_t >
( splitPos / boundary + .5f );
splitPos = ratio * boundary;
if( (splitPos - range.start) < boundary )
splitPos = range.start;
if( (end - splitPos) < boundary )
splitPos = end;
if( fabs( splitPos - node->split ) < node->resistancef )
splitPos = node->split;
else
node->split = splitPos;
LBLOG( LOG_LB2 ) << "Constrained split " << range << " at pos "
<< splitPos << std::endl;
Range childRange = range;
childRange.end = splitPos;
_computeSplit( node->left, leftTime, datas, vp, childRange );
childRange.start = childRange.end;
childRange.end = range.end;
_computeSplit( node->right, time - leftTime, datas, vp, childRange);
break;
}
default:
LBUNIMPLEMENTED;
}
}
void THPalette::_assign(THRenderTarget* pTarget) const
{
_assign(pTarget->getRawSurface());
}
RString::RString(const MString& s)
: owned(nullptr)
{
_assign(s.begin(), s.end());
}
RString::RString(XPair p)
: owned(nullptr)
{
_assign(p.begin(), p.end());
}
// --------------------------------------------------------------------------------
// 히스토리: 2011-07-07 이태훈 개발 완료
// --------------------------------------------------------------------------------
NE_DLL NEModule::NEModule(const NEModule& source)
: NENamedUnit(source), _is_argument_fetched(false), _owner(0x00), _index(NE_INDEX_ERROR)
{
_assign(source);
}
Matrix& Matrix::operator=(const Matrix& x) {
return _assign(*this,x);
}
Resource(const ThisClass& source)
: SuperClass(source)
{
_assign(source);
}
//////////////
// Mutators //
//////////////
ray& ray::operator=(const ray& r)
{
_assign(r);
return *this;
}
Affine2Vector& Affine2Vector::operator=(const IntervalVector& x) { return _assign(*this,x); }
//////////////
// Operator //
//////////////
bilinearTexturedAlbedo& bilinearTexturedAlbedo::operator=(const bilinearTexturedAlbedo& bta)
{
_assign(bta);
return *this;
}
IntervalMatrix& IntervalMatrix::operator=(const IntervalMatrix& x) {
resize(x.nb_rows(), x.nb_cols());
// need to be resized when called from operator*= (dimension can change)
return _assign(*this,x);
}
// ---------------------------------------------------------------------------------
// 히스토리: 2011-07-07 이태훈 개발 완료
// ---------------------------------------------------------------------------------
NE_DLL NEExportable::Identifier::Identifier(const Identifier& source)
:NEObject(source)
{
_assign(source);
}
const NEComponent NE_DLL &NEComponent::operator=(const NEComponent& source)
{
return _assign(source);
}
// ---------------------------------------------------------------------------------
// 히스토리: 2011-07-07 이태훈 개발 완료
// ---------------------------------------------------------------------------------
const NEExportable::Identifier NE_DLL &NEExportable::Identifier::operator=(const Identifier& source)
{
return _assign(source);
}
// ---------------------------------------------------------------------------------
// 히스토리: 2011-07-07 이태훈 개발 완료
// ---------------------------------------------------------------------------------
const Kernal NE_DLL &Kernal::operator=(const Kernal& source)
{
NEModule::operator=(source);
return _assign(source);
}
//-----------------------------------------------------------------------------
bool Conf::load(const char* cfgFile)
{
FILE* pf;
char locations[512];
::sprintf(locations,"/etc/%s",cfgFile);
pf = _ttfopen(locations, "rb"); if(pf) goto done;
::sprintf(locations,"/home/%s/.%s",getenv("USER"),cfgFile);
pf = _ttfopen(locations, "rb"); if(pf) goto done;
pf = _ttfopen(cfgFile, "rb");
done:
if(pf)
{
AutoCall<int (*)(FILE*), FILE*> _a(::fclose, pf);
char pred[128];
char val[128];
char line[512];
bool in_comment = false;
try
{
while(!::feof(pf))
{
if(::fgets(line,512,pf))
{
::str_prepline(line);
if(*line==0)
continue;
if(in_comment || *line=='#')
continue;
const char* pnext = ::str_ccpy(pred, line,'=');
if(*pred=='[')
{
str_lrtim(pred);
_section = pred;
continue;
}
else if(*pred=='}')
{
_assign("}", " ", 0);
}
if(pnext && *pnext)
{
::str_scpy(val, (char*)pnext+1, "#");
::str_lrtim(val);
::str_lrtim(pred);
//cheak the logs folder
if(pred[0]=='l')
_bind(pred, "logs_path", _logs_path, val);
_assign(pred, val, 0);
}
}
else
break;
if(feof(pf))
{
break;
}
}
}
catch(int& err)
{
;//noting
}
}
else
{
printf( "Cannot find configuration file in any of /etc/, ~/. and ./. \r\n");
//exit(0);
}
return finalize();
}
///////////////
// Operators //
///////////////
vec2d& vec2d::operator=(const vec2d& v)
{
_assign(v);
return *this;
}
///////////////
// Operators //
///////////////
sceneGraphNode& sceneGraphNode::operator=(const sceneGraphNode& node)
{
_assign(node);
return *this;
}
