void
solver_type::
ensure_buffer_size
( solve_1d_functor_type
const & calc_1d_functor
, size_type x_size
, size_type y_size
)
// The 1d functors know how big a buffer they need.
{
// Make sure the buffers are big enough to handle the solve.
// And shrink them or release them if they are too big.
if ( not_early_exit( ) ) {
size_type const now_buf_size = buf_a_.size( );
size_type const min_buf_size = calc_1d_functor.get_min_buf_count( x_size, y_size);
if ( (min_buf_size > now_buf_size) ||
(min_buf_size < (now_buf_size / 2)) )
{
if ( min_buf_size == 0 ) {
clear_buffers( );
} else {
buf_a_.resize( min_buf_size); buf_iter_a_ = buf_a_.begin( );
buf_b_.resize( min_buf_size); buf_iter_b_ = buf_b_.begin( );
}
}
d_assert( buf_a_.size( ) >= min_buf_size);
d_assert( buf_b_.size( ) >= min_buf_size);
}
}
const char * DBConnector::GetString(int i)
{
d_assert (mysql_row != NULL);
d_assert (i < (int)mysql_num_fields(mysql_result));
return mysql_row[i];
}
void
double_slide_holder::
set_values
( value_type val
, value_type min
, value_type max
, value_type ss // -1 means use existing value
, value_type ps // -1 means use existing value
)
{
d_assert( ! is_setting( ));
// We generate our own signals instead of relying on the inner object.
while_setting_value_wrapper_type wrapper( this, false);
d_assert( is_setting( ));
// Remember the old values.
value_type const old_val = get_value( );
value_type const old_min = get_min_value( );
value_type const old_max = get_max_value( );
value_type const old_ss = get_single_step( );
value_type const old_ps = get_page_step( );
// Must do this before the conversions that follow.
setup_conversions( min, max);
// Send the values to the inner holder.
p_inner_holder_->
set_values
( convert_outer_to_inner( val)
, convert_outer_to_inner( min)
, convert_outer_to_inner( max)
, convert_outer_to_inner_distance( ss)
, convert_outer_to_inner_distance( ps)
);
// Find the new values. These may be slightly different due to rounding etc.
value_type const new_val = get_value( );
value_type const new_min = get_min_value( );
value_type const new_max = get_max_value( );
value_type const new_ss = get_single_step( );
value_type const new_ps = get_page_step( );
// Emit the value signals.
if ( (new_ss != old_ss) || (new_ps != old_ps) ) {
emit has_changed__steps( new_ss, new_ps);
wrapper.request_signal( );
}
if ( (new_min != old_min) || (new_max != old_max) ) {
emit has_changed__range( new_min, new_max);
wrapper.request_signal( );
}
if ( new_val != old_val ) {
emit has_changed( new_val);
wrapper.request_signal( );
}
// The wrapper dtor will signal has_changed( ) if appropriate.
wrapper.done_with_no_throws( );
}
void TerrainLayerDlg::_notifyEditLayer(Event * _sender)
{
if (mLayerInfoDlg->GetLayer() == NULL) // is add
return ;
Terrain * tn = Environment::Instance()->GetTerrain();
int layerId = GetCurLayer();
d_assert (layerId != -1);
Terrain::Layer layer;
layer.detail = mLayerInfoDlg->GetDiffuseMap();
layer.normal = mLayerInfoDlg->GetNormalMap();
layer.specular = mLayerInfoDlg->GetSpecularMap();
layer.scale = mLayerInfoDlg->GetUVScale();
layer.material = -1;
tn->SetLayer(layerId, layer);
size_t isel = mLayerList->getIndexSelected();
d_assert (isel != MyGUI::ITEM_NONE);
mLayerList->setItemNameAt(isel, layer.detail.c_wstr());
}
void memory_session::begin()
{
scoped_lock l(mutex);
d_assert(unfrozen_threads_count != UNINITIALIZED, "Memory session begin() while uninitialized");
const bool currently_frozen = (unfrozen_threads_count == 0);
// is zero only on first begin() of current thread with this session
if (!frozen.get())
{
frozen.reset(new bool(currently_frozen));
if (unfrozen_threads_count > 0)
++unfrozen_threads_count;
// session right after init() is unfrozen
else if (unfrozen_threads_count == NOTSTARTED)
unfrozen_threads_count = 1;
}
else
{
d_assert(unfrozen_threads_count >= 0, "unfrozen_threads_count == " << unfrozen_threads_count);
*frozen.get() = currently_frozen;
if (!currently_frozen)
++unfrozen_threads_count;
}
default_sub_session->begin();
}
void
int_range_steps_holder::
attach( QSpinBox * p_spinb)
{
d_assert( p_spinb);
// Move the values.
d_assert( is_valid( ));
//if ( init_value_from_holder ) {
move_values_to( p_spinb);
//} else {
// set_values_from( p_spinb);
//}
d_assert( is_valid( ));
// Put the widget on the list.
d_assert( ! attached_widgets_.contains( p_spinb));
attached_widgets_.push_front( p_spinb);
d_verify( connect(
p_spinb, SIGNAL( destroyed( QObject *)),
this, SLOT( before_dtor( QObject *))
));
// Watch for a signal from the UI.
d_verify( connect( p_spinb, SIGNAL( valueChanged( int)), this, SLOT( set_value( int))));
// We also need to relay changes here back to the UI objects. We could do it by intercepting
// these signals from this object:
// has_changed( int)
// has_changed__range( int, int)
// has_changed__steps( int, int)
// But since the ctrl classes don't have the slots to support this, so instead we loop thru
// our list of attached widgets and set these values explicitly. See move_values_to(..) and
// set_values(..).
}
/* static */
int
pack_range_steps_holder::
convert_log_pack_to_ui( double d_log_pack)
//
// Used when you want to map a double value to a log-scale integer.
// Double must be > 0. Doubles map to integers as follows:
//
// log_pack ui == 1000 * std::log( log_pack)
// ======= ================
// 0.0001 -> -9210
// 0.001 -> -6908
// 0.01 -> -4605
// 0.1 -> -2303
// 1.0 -> 0
// 10.0 -> +2303
// 100.0 -> +4605
// 1000.0 -> +6908
// 10000.0 -> +9210
{
// ln( 10000) is slightly more than +9.21
// ln( .0001) is slightly less than -9.21
d_assert( (0.0001 <= d_log_pack) && (d_log_pack <= 10000.0)); // is_valid_log_pack
// std::log(..) is natural log. std::log10(..) is log-base-10.
double const d_linear_pack = std::log( d_log_pack);
int const i_ui = convert_linear_pack_to_ui( d_linear_pack);
d_assert( (-10000 <= i_ui) && (i_ui <= 10000)); // is_valid_ui_for_log_pack
return i_ui;
}
void
int_range_steps_holder::
attach( QAbstractSlider * p_slider)
{
d_assert( p_slider);
// Move the values.
d_assert( is_valid( ));
//if ( init_value_from_holder ) {
move_values_to( p_slider);
//} else {
// set_values_from( p_slider);
//}
d_assert( is_valid( ));
// Put the widget on the list.
d_assert( ! attached_widgets_.contains( p_slider));
attached_widgets_.push_front( p_slider);
d_verify( connect(
p_slider, SIGNAL( destroyed( QObject *)),
this, SLOT( before_dtor( QObject *))
));
// Watch for a signal from the UI.
d_verify( connect( p_slider, SIGNAL( valueChanged( int)), this, SLOT( set_value( int))));
// We don't connect back the other way (from this object to the UI) because the UI classes
// don't have the right slots. Instead we keep these objects updated in set_values(..).
}
GizmoBar::GizmoBar()
{
mLayout = MGUI::Layout::Load("GizmoBar.layout", NULL);
mLayout->SetVisible(false);
mWidget_Move = mLayout->GetChild("Move"); d_assert (mWidget_Move);
mWidget_Rotate = mLayout->GetChild("Rotate"); d_assert (mWidget_Rotate);
mWidget_Scale = mLayout->GetChild("Scale"); d_assert (mWidget_Scale);
mWidget_Move->SetAlpha(1.0f);
mWidget_Rotate->SetAlpha(0.5f);
mWidget_Scale->SetAlpha(0.5f);
mWidget_Move->E_MouseClick += new cListener1<GizmoBar, const MGUI::MouseEvent *>(this, &GizmoBar::OnMove);
mWidget_Rotate->E_MouseClick += new cListener1<GizmoBar, const MGUI::MouseEvent *>(this, &GizmoBar::OnRotate);
mWidget_Scale->E_MouseClick += new cListener1<GizmoBar, const MGUI::MouseEvent *>(this, &GizmoBar::OnScale);
mEditBox_X = (MGUI::EditBox *)mLayout->GetChild("x");
mEditBox_Y = (MGUI::EditBox *)mLayout->GetChild("y");
mEditBox_Z = (MGUI::EditBox *)mLayout->GetChild("z");
mEditBox_X->E_KeyLostFocus += new cListener1<GizmoBar, const MGUI::FocusEvent *>(this, &GizmoBar::OnTextChanged);
mEditBox_Y->E_KeyLostFocus += new cListener1<GizmoBar, const MGUI::FocusEvent *>(this, &GizmoBar::OnTextChanged);
mEditBox_Z->E_KeyLostFocus += new cListener1<GizmoBar, const MGUI::FocusEvent *>(this, &GizmoBar::OnTextChanged);
Editor::Instance()->E_NodeSelect += new cListener0<GizmoBar>(this, &GizmoBar::OnNodeSelect);
Editor::Instance()->E_NodePositionChanged += new cListener0<GizmoBar>(this, &GizmoBar::OnPositionChanged);
Editor::Instance()->E_NodeRotationChanged += new cListener0<GizmoBar>(this, &GizmoBar::OnRotationChanged);
Editor::Instance()->E_NodeScaleChanged += new cListener0<GizmoBar>(this, &GizmoBar::OnScaleChanged);
}
void MGUI_RenderSystem::initialise()
{
d_assert (!mIsInitialise);
MYGUI_PLATFORM_LOG(Info, "* Initialise: " << getClassTypeName());
mVertexFormat = MyGUI::VertexColourType::ColourARGB;
memset(&mInfo, 0, sizeof(mInfo));
setViewSize(Engine::Instance()->GetDeviceProperty()->Width,
Engine::Instance()->GetDeviceProperty()->Height);
mUpdate = false;
mShaderLib = ShaderLibManager::Instance()->LoadShaderLib("Shaders\\MGUI.ShaderLib", "Shaders\\MGUI.ShaderLib");
d_assert (mShaderLib);
mDefaultTech = mShaderLib->GetTechnique("MGUI_Default");
d_assert (mDefaultTech);
mVertexDecl = VideoBufferManager::Instance()->CreateVertexDeclaration();
mVertexDecl->AddElement(0, 0, DT_FLOAT3, DU_POSITION, 0);
mVertexDecl->AddElement(0, 12, DT_COLOR, DU_COLOR, 0);
mVertexDecl->AddElement(0, 16, DT_FLOAT2, DU_TEXCOORD, 0);
mVertexDecl->Init();
MYGUI_PLATFORM_LOG(Info, getClassTypeName() << " successfully initialized");
mIsInitialise = true;
}
void
worker_thread_type::
start_run__from_master_thread
( input_params_type const & input_params
, sheet_type const & src_sheet
, sheet_type & trg_sheet
, sheet_type & extra_sheet
)
// Start running the worker thread.
// The worker thread will signal when it is done.
{
// This is called from the master thread.
d_assert( currentThread( ) != this);
// This is only called if we are not running.
d_assert( 0 == p_src_sheet_ );
d_assert( 0 == p_trg_sheet_ );
d_assert( 0 == p_extra_sheet_);
// Setup the params for the solver.
input_params_ = input_params ;
p_src_sheet_ = & src_sheet ;
p_trg_sheet_ = & trg_sheet ;
p_extra_sheet_ = & extra_sheet ;
// This signal should be picked up by the worker thread.
emit start__master_to_worker( );
}
void Water::Load(const char * source)
{
DataStreamPtr stream = ResourceManager::Instance()->OpenResource(source);
if (stream == NULL)
return ;
int Magic, Version;
stream->Read(&Magic, sizeof(int));
stream->Read(&Version, sizeof(int));
d_assert (Magic == K_Magic);
d_assert (Version == 0);
if (Version == 0)
{
int sizeX, sizeZ;
stream->Read(&sizeX, sizeof(int));
stream->Read(&sizeZ, sizeof(int));
d_assert (sizeX == mSizeX && sizeZ == mSizeZ);
stream->Read(&mHeight, sizeof(float));
stream->Read(mData, sizeX * sizeZ);
}
_initBlock();
}
std::pair<byte*, size_t> memory_sub_session::add_merge_remove_free_small_chunk(byte* p, size_t bytes)
{
std::pair<byte*, std::pair<size_t, int> > chunk_alloc = free_small_chunk_alloc(p);
size_t remainder_size = bytes;
byte* remainder_pointer = p;
if (!free_small_chunks.empty())
{
// adding and merging free space
std::map<byte*, size_t>::iterator next = free_small_chunks.upper_bound(remainder_pointer);
if (next != free_small_chunks.begin())
{
std::map<byte*, size_t>::iterator previous = next;
--previous;
if (previous->first >= chunk_alloc.first)
{
d_assert(remainder_pointer > previous->first);
const size_t diff = remainder_pointer - previous->first;
d_assert(diff >= previous->second);
if (diff == previous->second)
{
remainder_pointer = previous->first;
remainder_size += previous->second;
free_small_chunks_inv.erase(std::make_pair(previous->second, previous->first));
free_small_chunks.erase(previous);
parent->ram_allocated_bytes -= free_small_chunk_size;
parent->total_allocated_bytes -= free_small_chunk_size;
next = free_small_chunks.upper_bound(remainder_pointer);
}
}
}
if (next != free_small_chunks.end() && remainder_size != chunk_alloc.second.first)
{
d_assert(next->first > remainder_pointer);
const size_t diff = next->first - remainder_pointer;
if (diff == remainder_size)
{
remainder_size += next->second;
free_small_chunks_inv.erase(std::make_pair(next->second, next->first));
free_small_chunks.erase(next);
parent->ram_allocated_bytes -= free_small_chunk_size;
parent->total_allocated_bytes -= free_small_chunk_size;
}
}
}
return std::make_pair(remainder_pointer, remainder_size);
}
/* static */
int
pack_range_steps_holder::
convert_linear_pack_to_ui( int i_linear_pack)
{
d_assert( is_valid_linear_pack( i_linear_pack));
int const i_ui = i_linear_pack * i_linear_to_ui_expand_factor;
d_assert( is_valid_ui( i_ui));
return i_ui;
}
void memory_sub_session::remove_small_alloc(byte* p)
{
std::set<std::pair<byte*, size_t> >::const_iterator i = small_allocs.upper_bound(std::make_pair(p, 0));
d_assert(i != small_allocs.end());
d_assert(i->first == p);
small_allocs.erase(i);
parent->ram_allocated_bytes -= small_alloc_size;
parent->total_allocated_bytes -= small_alloc_size;
}
void SetupTextBox(MGUI::Layout * layout, const uchar_t * caption, const String & parentName)
{
d_assert (layout != NULL);
MGUI::Widget * parentWidget = layout->GetChild(parentName.c_str());
d_assert (parentWidget != NULL);
MGUI::TextBox * textBox = new MGUI::TextBox(NULL, parentWidget);
textBox->SetAlign(MGUI::eAlign::LEFT | MGUI::eAlign::V_CENTER);
textBox->SetCaption(caption);
}
/* static */
double
pack_range_steps_holder::
convert_ui_to_log_pack( int i_ui)
{
d_assert( (-10000 <= i_ui) && (i_ui <= 10000)); // is_valid_ui_for_log_pack
// std::exp(..) calcs the "natural" exponential.
double const d_linear_pack = convert_ui_to_linear_pack( i_ui);
double const d_log_pack = std::exp( d_linear_pack);
d_assert( (0.0001 <= d_log_pack) && (d_log_pack <= 10000.0)); // is_valid_log_pack
return d_log_pack;
}
/* destructor */
worker_thread_type::
~worker_thread_type( )
{
// Which thread runs the destructor?
// d_assert( currentThread( ) != this) ?
// We should not be in the middle of a run.
d_assert( 0 == p_src_sheet_ );
d_assert( 0 == p_trg_sheet_ );
d_assert( 0 == p_extra_sheet_);
}
/* slot (protected) */
void
double_slide_holder::
intercept__has_changed__steps( inner_value_type /* inner_ss */, inner_value_type /* inner_ps */)
{
// We should be the only ones setting these inner values.
d_assert( is_setting( ));
// Confirm that everything looks right.
d_assert( is_valid( ));
// Our setter will emit this signal later.
}
/* static */
double
pack_range_steps_holder::
convert_ui_to_linear_pack( int i_ui)
//
// Changes an integer to a double 1000 times smaller.
// Used when you need a big integer for a UI widget, but you store a small double.
{
d_assert( is_valid_ui( i_ui));
double const d_linear_pack = static_cast< double >( i_ui) * d_ui_to_linear_squeeze_factor;
d_assert( is_valid_linear_pack( d_linear_pack));
return d_linear_pack;
}
d_define_method(illuminable_bitmap, set_light_mask)(struct s_object *self, struct s_object *drawable_mask, enum e_illuminable_bitmap_sides side) {
d_using(illuminable_bitmap);
double mask_width, mask_height, image_width, image_height;
if (illuminable_bitmap_attributes->drawable_mask[side])
d_delete(illuminable_bitmap_attributes->drawable_mask[side]);
illuminable_bitmap_attributes->drawable_mask[side] = d_retain(drawable_mask);
d_call(illuminable_bitmap_attributes->drawable_mask[side], m_drawable_set_blend, e_drawable_blend_add);
d_call(illuminable_bitmap_attributes->drawable_mask[side], m_drawable_get_dimension, &mask_width, &mask_height);
d_call(self, m_drawable_get_dimension, &image_width, &image_height);
d_assert((image_width == mask_width));
d_assert((image_height == mask_height));
return self;
}
void
int_range_steps_holder::
detach( QAbstractSlider * p_slider)
{
d_assert( p_slider);
d_assert( is_valid( ));
d_assert( attached_widgets_.contains( p_slider));
d_verify( disconnect( p_slider, SIGNAL( valueChanged( int)), this, SLOT( set_value( int))));
d_verify( disconnect( p_slider, SIGNAL( destroyed( QObject *)), this, SLOT( before_dtor( QObject *))));
d_verify( 1 == attached_widgets_.removeAll( p_slider));
d_assert( ! attached_widgets_.contains( p_slider));
d_assert( is_valid( ));
}
/* ctor */
double_slide_holder::
double_slide_holder
( QObject * p_parent
, value_type outer_init // = 0.0
, value_type outer_lo // = -1.0
, value_type outer_hi // = +1.0
)
: holder_base_type( p_parent)
, p_inner_holder_ ( 0)
, outer_lo_ ( 0)
, inner_to_outer_ ( 0)
, outer_to_inner_ ( 0)
{
setup_conversions( outer_lo, outer_hi);
// Now that conversions are set up, create the inner holder.
// Should we use the global lo/hi limits, or the calculated limits? We'll use the
// calculated limits for now.
p_inner_holder_ =
new inner_holder_type
( this
, convert_outer_to_inner( outer_init)
, convert_outer_to_inner( outer_lo)
, convert_outer_to_inner( outer_hi)
);
d_assert( p_inner_holder_);
// Relay all the signals from the inner holder.
d_verify( connect(
p_inner_holder_, SIGNAL( has_changed( )),
this, SLOT( intercept__has_changed( ))
));
d_verify( connect(
p_inner_holder_, SIGNAL( has_changed( int)),
this, SLOT( intercept__has_changed( int))
));
d_verify( connect(
p_inner_holder_, SIGNAL( has_changed__range( int, int)),
this, SLOT( intercept__has_changed__range( int, int))
));
d_verify( connect(
p_inner_holder_, SIGNAL( has_changed__steps( int, int)),
this, SLOT( intercept__has_changed__steps( int, int))
));
// Should always be true when outside class methods.
d_assert( is_valid( ));
}
void NullTexture::_load(DataStreamPtr stream)
{
if (mLoadState != Resource::LOADING)
return ;
if (stream == NULL)
{
d_log("!: Load texture '%s' failed.", mSourceName.c_str());
return ;
}
d_assert (mPixelData == NULL && mLockFlag == 0);
Image image;
if (IMG_Load(image, stream))
{
mPixelData = image.pixels;
mWidth = image.width;
mHeight = image.height;
mFormat = image.format;
mMipmaps = 1;
}
else
{
d_log ("?: image '%s' load failed.", mSourceName.c_str());
}
}
TypeEd_ImageBox::TypeEd_ImageBox(MGUI::Widget * widget, MGUI::Widget * panel)
{
d_assert (TYPE_OF(MGUI::ImageBox, widget));
mImageBox = (MGUI::ImageBox *)widget;
float top = 0;
const float K_Space = 8;
mLabel_Image = new MGUI::Label(NULL, panel);
mLabel_Image->SetCaption(L"Image:");
mLabel_Image->SetRect(0, top, 64, 24);
mEditBox_Image = new MGUI::EditBox(AllLookFeel::Instance()->GetEditBox(), panel);
mEditBox_Image->SetRect(80, top, 162, 24);
top += 24 + K_Space;
mLabel_UVRect = new MGUI::Label(NULL, panel);
mLabel_UVRect->SetCaption(L"UVRect");
mLabel_UVRect->SetRect(0, top, 162, 24);
mEditBox_UVRect = new MGUI::EditBox(AllLookFeel::Instance()->GetEditBox(), panel);
mEditBox_UVRect->SetRect(80, top, 162, 24);
top += 24 + K_Space;
// Init
mEditBox_Image->SetCaption(mImageBox->GetSkin() != NULL ? mImageBox->GetSkin()->GetName().c_wstr() : L"");
mEditBox_UVRect->SetCaption(mImageBox->GetUVRect().ToString().c_wstr());
mEditBox_Image->E_KeyLostFocus += new cListener1<TypeEd_ImageBox, const MGUI::FocusEvent *>(this, &TypeEd_ImageBox::OnImageChanged);
mEditBox_UVRect->E_KeyLostFocus += new cListener1<TypeEd_ImageBox, const MGUI::FocusEvent *>(this, &TypeEd_ImageBox::OnUVRectChanged);
}
FileStream::FileStream(const TString128 & file)
{
mData = NULL;
mFile.Open(file.c_str(), OM_READ_BINARY);
d_assert (mFile.IsOpen());
}
/* overridden virtual */
void
int_animator_type::
wrap_to_max( )
{
d_assert( p_holder_);
p_holder_->wrap_to_max( );
}
/* overridden virtual */
bool
int_animator_type::
is_bumping_max( )
{
d_assert( p_holder_);
return p_holder_->is_bumping_max( );
}
/* overridden virtual */
holder_base_type *
int_animator_type::
get_animated( ) const
{
d_assert( p_holder_);
return p_holder_;
}
void memory_session::init(bool autobegin)
{
memory_manager::instance->reserve_total_bytes(total_limit_bytes, &unfreeze_condition, 0, 0);
try
{
memory_manager::instance->reserve_ram_bytes(ram_limit_bytes, &unfreeze_condition, 0, total_limit_bytes);
}
catch (...)
{
memory_manager::instance->free_total_bytes(total_limit_bytes);
throw;
}
d_assert(unfrozen_threads_count == UNINITIALIZED, "Double initialization of memory session");
unfrozen_threads_count = NOTSTARTED;
if (autobegin)
{
try
{
begin();
}
catch (...)
{
memory_manager::instance->free_total_bytes(total_limit_bytes);
memory_manager::instance->free_ram_bytes(ram_limit_bytes);
unfrozen_threads_count = UNINITIALIZED;
throw;
}
}
}
