C++ RAMEN_ASSERT函数代码示例

    void normalize()
    {
        T l = length();
        RAMEN_ASSERT( l > T(0));

        x /= l;
        y /= l;
        z /= l;
    }

    vector3_t<T>& operator/=( T s)
    {
        RAMEN_ASSERT( s != T(0));

        x /= s;
        y /= s;
        z /= s;
        return *this;
    }

void cu_ctx_destroy( CUcontext ctx)
{
	RAMEN_ASSERT( cuCtxDestroy_);

	// in this case, we don't check for errors, as
	// this is used in a destructor, and there's not much
	// we can do about it anyway.
	cuCtxDestroy_( ctx);
}

void graph_t::add_node( node_t *v)
{
	RAMEN_ASSERT( !has_node( v));

	vertex_desc_type vd = boost::add_vertex( graph_);
	graph_[vd].node = v;
	node_to_desc_[v] = vd;
	valid_order_ = false;
}

void clipboard_t::copy_keys( const std::string& name, const anim::any_curve_ptr_t& c)
{
	RAMEN_ASSERT( copying_);
	
	copy_curves_mode_ = false;
	contents_.push_back( named_curve_type( name, boost::shared_ptr<any_curve_t>()));
	copy_keys_visitor v( contents_.back().second);
	boost::apply_visitor( v, c);
}

void yaml_oarchive_t::write_composition_header()
{
	RAMEN_ASSERT( !header_written_);

	out_ << YAML::Key << "magic"	<< YAML::Value << "Ramen composition";
	out_ << YAML::Key << "version"	<< YAML::Value << version;
	check_errors();
	header_written_ = true;
}

	void add_level( const Sampler& sampler)
	{
		RAMEN_ASSERT( has_top_sampler_);

		samplers_.push_back( sampler);

		float scale = scales_.back() * 0.5f;
		scales_.push_back( scale);
		iscales_.push_back( 1.0f / scale);
	}

	void set_top_level( const TopLevelSampler& sampler)
	{
		RAMEN_ASSERT( !has_top_sampler_);

		top_sampler_ = sampler;
		has_top_sampler_ = true;

		scales_.push_back( 1.0f);
		iscales_.push_back( 1.0f);
	}

composition_t *param_t::composition()
{
    RAMEN_ASSERT( param_set());
    parameterised_t *p = parameterised();

    if( p)
        return p->composition();
    else
        return 0;
}

    void deallocate( unsigned char *p, std::size_t s)
	{
		if( p == 0)
			return;

		RAMEN_ASSERT( s != 0);

	    boost::lock_guard<boost::recursive_mutex> lock( mutex_);
	    pool_.deallocate( p, s);
	}

T *aligned_ptr( T *p, int alignment)
{
	RAMEN_ASSERT( (( alignment - 1) & alignment) == 0);

    uintptr_t ptr = reinterpret_cast<uintptr_t>( p);
    uintptr_t align = alignment - 1;
    uintptr_t aligned = ( ptr + align + 1) & ~align;

    return reinterpret_cast<unsigned char *>( aligned);
}

quad_manipulator_t::quad_manipulator_t( float2_param_t *topleft, float2_param_t *topright,
										float2_param_t *botleft, float2_param_t *botright) : manipulator_t()
{
	RAMEN_ASSERT( topleft && topright && botleft && botright);
	topleft_ = topleft;
	topright_ = topright;
	botleft_ = botleft;
	botright_ = botright;
	picked_corner_ = -1;
}

	virtual void do_mouse_release_event( const ui::mouse_release_event_t& event)
	{
		if( event.dragged)
		{
			RAMEN_ASSERT( drag_axes_ || drag_center_);
			param_->param_set()->end_edit( param_->track_mouse());
		}

		drag_center_ = drag_axes_ = false;
		dragx_ = dragy_ = true;
	}

void vertex_t::perspective_divide()
{
	RAMEN_ASSERT( screen.w != 0);

	inv_w = 1.0f / screen.w;
	screen.x *= inv_w;
	screen.y *= inv_w;

	uv.x *= inv_w;
	uv.y *= inv_w;
}

	pixel_t sample_level( int level, const vector2_t& p) const
	{
		RAMEN_ASSERT( level >= 0 && level < num_levels());

		if( level == 0)
			return top_sampler_( p);

		float s = scales_[level];
		vector2_t q( p.x * s, p.y * s);
		return samplers_[level - 1]( q);
	}