Как исправить ошибку с2280 vc 2015?

Question

[Олег Викторович]

При компиляции кода возникает ошибка

на функцию "xray::math::rectangle::rectangle(const xray::math::rectangle &) [с vector_type=xray::math::int2]" (объявлено неявно) нельзя ссылаться, так как эта функция удалена render_dx9 xray\render\common\sources\terrain_texture_pool.cpp 124

Код в terrain_texture_pool.cpp

math::rectangle<int2>	terrain_texture_pool::get_tile_rect	(u32 ind)
{
	ASSERT(ind < m_tiles.x*m_tiles.y);
	int top		= ind/m_tiles.x;
	int left	= ind-top*m_tiles.x;
	return math::rectangle<int2>(int2(left*m_tile_size, top*m_tile_size), int2((left + 1)*m_tile_size, (top + 1)*m_tile_size));
}

строка
return math::rectangle(int2(left*m_tile_size, top*m_tile_size), int2((left + 1)*m_tile_size, (top + 1)*m_tile_size));
Определение math::rectangle

////////////////////////////////////////////////////////////////////////////
//	Created 	: 23.10.2008
//	Author		: Dmitriy Iassenev
//	Copyright (C) GSC Game World - 2009
////////////////////////////////////////////////////////////////////////////

#ifndef XRAY_MATH_RECTANGLE_H_INCLUDED
#define XRAY_MATH_RECTANGLE_H_INCLUDED

namespace xray {	
namespace math {
template < typename vector_type >
class rectangle {
public:
	typedef typename vector_type::type	type;
public:
#if defined(_MSC_VER)
#	pragma warning(push)
#	pragma warning(disable:4201)
#endif // #if defined(_MSC_VER)
	;
	union {
		struct {
			vector_type	min;
			vector_type	max;
		};
		struct {
			type		left;
			type		top;
			type		right;
			type		bottom;
		};
	};
#if defined(_MSC_VER)
#	pragma warning(pop)
#endif // #if defined(_MSC_VER)

public:
	inline rectangle();
	inline ~rectangle();
	inline				rectangle	( vector_type const& min, vector_type const& max );

	inline	rectangle&	zero		( );
	inline	rectangle&	identity	( );
	inline	rectangle&	invalidate	( );

	inline	rectangle&	operator +=	( type value );
	inline	rectangle&	operator +=	( vector_type const& value );
	inline	rectangle&	operator -=	( type value );
	inline	rectangle&	operator -=	( vector_type const& value );
	inline	rectangle&	operator *=	( type value );
	inline	rectangle&	operator *=	( vector_type const& value );
	inline	rectangle&	operator /=	( type value );
	inline	rectangle&	operator /=	( vector_type const& value );

	inline	rectangle&	move		( vector_type const& value );

	inline	rectangle&	modify		( vector_type const& position );
	inline	rectangle&	modify		( rectangle const& other );
			rectangle&	modify		( float4x4 const& transform );

	inline	vector_type	size		( ) const;
	inline	type		radius		( ) const;
	inline	type		volume		( ) const;

	inline	vector_type	center		( ) const;
	inline	vector_type	center		( vector_type& size ) const;

	inline	bool		intersect	( rectangle const& other ) const;

	inline	bool		contains	( vector_type const& position ) const;
	inline	bool		contains	( rectangle const& other ) const;

	inline	bool		similar		( rectangle const& other ) const;

	inline	vector_type	vertex		( u32 index ) const;
	inline	void		vertices	( vector_type ( &result )[ 4 ] ) const;

	inline	type		width		( ) const;
	inline	type		height		( ) const;

	inline	bool		valid		( ) const;
}; // class rectangle

template < typename vector_type >
inline 	math::rectangle<vector_type>	operator +	( math::rectangle<vector_type> const& rectangle, typename math::rectangle<vector_type>::type value );

template < typename vector_type >
inline 	math::rectangle<vector_type>	operator +	( typename math::rectangle<vector_type>::type value, math::rectangle<vector_type> const& rectangle );

template < typename vector_type >
inline 	math::rectangle<vector_type>	operator +	( math::rectangle<vector_type> const& rectangle, typename math::rectangle<vector_type>::vector_type const& value );

template < typename vector_type >
inline 	math::rectangle<vector_type>	operator +	( typename math::rectangle<vector_type>::vector_type const& value, math::rectangle<vector_type> const& rectangle );

template < typename vector_type >
inline 	math::rectangle<vector_type>	operator -	( math::rectangle<vector_type> const& rectangle, typename math::rectangle<vector_type>::type value );

template < typename vector_type >
inline 	math::rectangle<vector_type>	operator -	( typename math::rectangle<vector_type>::type value, math::rectangle<vector_type> const& rectangle );

template < typename vector_type >
inline 	math::rectangle<vector_type>	operator -	( math::rectangle<vector_type> const& rectangle, typename math::rectangle<vector_type>::vector_type const& value );

template < typename vector_type >
inline 	math::rectangle<vector_type>	operator -	( typename math::rectangle<vector_type>::vector_type const& value, math::rectangle<vector_type> const& rectangle );

template < typename vector_type >
inline 	math::rectangle<vector_type>	operator *	( math::rectangle<vector_type> const& rectangle, typename math::rectangle<vector_type>::type value );

template < typename vector_type >
inline 	math::rectangle<vector_type>	operator *	( typename math::rectangle<vector_type>::type value, math::rectangle<vector_type> const& rectangle );

template < typename vector_type >
inline 	math::rectangle<vector_type>	operator *	( math::rectangle<vector_type> const& rectangle, typename math::rectangle<vector_type>::vector_type const& value );

template < typename vector_type >
inline 	math::rectangle<vector_type>	operator *	( typename math::rectangle<vector_type>::vector_type const& value, math::rectangle<vector_type> const& rectangle );

template < typename vector_type >
inline 	math::rectangle<vector_type>	operator /	( math::rectangle<vector_type> const& rectangle, typename math::rectangle<vector_type>::type value );

template < typename vector_type >
inline 	math::rectangle<vector_type>	operator /	( typename math::rectangle<vector_type>::type value, math::rectangle<vector_type> const& rectangle );

template < typename vector_type >
inline 	math::rectangle<vector_type>	operator /	( math::rectangle<vector_type> const& rectangle, typename math::rectangle<vector_type>::vector_type const& value );

template < typename vector_type >
inline 	math::rectangle<vector_type>	operator /	( typename math::rectangle<vector_type>::vector_type const& value, math::rectangle<vector_type> const& rectangle );

typedef rectangle<float2_pod>	float_rectangle;

} // namespace math
} // namespace xray

#include <xray/math_rectangle_inline.h>

#endif // #ifndef XRAY_MATH_RECTANGLE_H_INCLUDED

Comments

[Олег Викторович]

Код

////////////////////////////////////////////////////////////////////////////
//	Created 	: 23.10.2008
//	Author		: Dmitriy Iassenev
//	Copyright (C) GSC Game World - 2009
////////////////////////////////////////////////////////////////////////////

#ifndef XRAY_MATH_RECTANGLE_INLINE_H_INCLUDED
#define XRAY_MATH_RECTANGLE_INLINE_H_INCLUDED

#define TEMPLATE_SIGNATURE	template < typename vector_type >
#define RECTANGLE			rectangle< vector_type >

namespace xray {
namespace math {

TEMPLATE_SIGNATURE
	inline RECTANGLE::rectangle()
{
}
TEMPLATE_SIGNATURE
inline RECTANGLE::~rectangle()
{
}
TEMPLATE_SIGNATURE
inline RECTANGLE::rectangle								( vector_type const& min, vector_type const& max ) :
	min			( min ),
	max			( max )
{
}

TEMPLATE_SIGNATURE
inline RECTANGLE& RECTANGLE::zero						( )
{
	min			= max = vector_type ( type(0), type(0), type(0) );
	return		( *this );
}

TEMPLATE_SIGNATURE
inline RECTANGLE& RECTANGLE::invalidate					( )
{
	min			= vector_type ( +infinity, +infinity, +infinity );
	max			= vector_type ( -infinity, -infinity, -infinity );

	return		( *this );
}

TEMPLATE_SIGNATURE
inline RECTANGLE& RECTANGLE::operator +=				( type value )
{
	min			-= value;
	max			+= value;

	return		( *this );
}

TEMPLATE_SIGNATURE
inline RECTANGLE& RECTANGLE::operator +=				( vector_type const& value )
{
	min			-= value;
	max			+= value;

	return		( *this );
}

TEMPLATE_SIGNATURE
inline RECTANGLE& RECTANGLE::operator -=				( type value )
{
	min			+= value;
	max			-= value;

	return		( *this );
}

TEMPLATE_SIGNATURE
inline RECTANGLE& RECTANGLE::operator -=				( vector_type const& value )
{
	min			+= value;
	max			-= value;

	return		( *this );
}

TEMPLATE_SIGNATURE
inline RECTANGLE& RECTANGLE::operator *=				( type value )
{
	RECTANGLE::vector_type		extents, center = this->center( extents );
	extents		*= value;
	min			= center - extents;
	max			= center + extents;

	return		( *this );
}

TEMPLATE_SIGNATURE
inline RECTANGLE& RECTANGLE::operator *=				( vector_type const& value )
{
	RECTANGLE::vector_type		extents, center = this->center( extents );
	extents		*= value;
	min			= center - extents;
	max			= center + extents;

	return		( *this );
}

TEMPLATE_SIGNATURE
inline RECTANGLE& RECTANGLE::operator /=				( type value )
{
	ASSERT		( !is_zero( value ) );

	RECTANGLE::vector_type		extents, center = this->center( extents );
	extents		/= value;
	min			= center - extents;
	max			= center + extents;

	return		( *this );
}

TEMPLATE_SIGNATURE
inline RECTANGLE& RECTANGLE::operator /=				( vector_type const& value )
{
	RECTANGLE::vector_type		extents, center = this->center( extents );
	extents		/= value;
	min			= center - extents;
	max			= center + extents;

	return		( *this );
}

TEMPLATE_SIGNATURE
inline RECTANGLE& RECTANGLE::move						( vector_type const& value )
{
	min			+= value;
	max			+= value;

	return		( *this );
}

TEMPLATE_SIGNATURE
inline RECTANGLE& RECTANGLE::modify						( vector_type const& position )
{
	min			= math::min( min, position );
	max			= math::max( max, position );

	return		( *this );
}

TEMPLATE_SIGNATURE
inline RECTANGLE& RECTANGLE::modify						( rectangle const& other )
{
	modify		( other.min );
	modify		( other.max );
}

TEMPLATE_SIGNATURE
inline vector_type RECTANGLE::size						( ) const
{
	return		( max - min );
}

TEMPLATE_SIGNATURE
inline typename RECTANGLE::type RECTANGLE::radius		( ) const
{
	return		( size( ).magnitude( )/type(2) );
}

TEMPLATE_SIGNATURE
inline typename RECTANGLE::type RECTANGLE::volume		( ) const
{
	RECTANGLE::vector_type const size = this->size( );
	return		( size.x*size.y*size.z );
}

TEMPLATE_SIGNATURE
inline vector_type RECTANGLE::center					( ) const
{
	return		( ( min + max )/type(2) );
}

TEMPLATE_SIGNATURE
inline vector_type RECTANGLE::center					( vector_type& size ) const
{
	size		= ( min - max )/type(2);
	return		( min + size );
}

TEMPLATE_SIGNATURE
inline bool	RECTANGLE::intersect						( rectangle const& other ) const
{
	return		( ( max >= other.min ) && ( min <= max ) );
}

TEMPLATE_SIGNATURE
inline bool	RECTANGLE::contains							( vector_type const& position ) const
{
	return		( ( min <= position ) && ( max >= position ) );
}

TEMPLATE_SIGNATURE
inline bool	RECTANGLE::contains							( rectangle const& other ) const
{
	return		( ( min <= other.min ) && ( max >= other.max  ) );
}

TEMPLATE_SIGNATURE
inline bool	RECTANGLE::similar							( rectangle const& other ) const
{
	return		( min.similar( other.min ) && max.similar( other.max ) );
}

TEMPLATE_SIGNATURE
inline vector_type RECTANGLE::vertex					( u32 index ) const
{
	ASSERT		( index < 4 );

	switch ( index ) {
		case 0 : return( vector_type ( min.x, min.y ) );
		case 1 : return( vector_type ( min.x, max.y ) );
		case 2 : return( vector_type ( max.x, min.y ) );
		case 3 : return( vector_type ( max.x, max.y ) );
		default: NODEFAULT(return vector_type( ));
	}
}

TEMPLATE_SIGNATURE
inline void	RECTANGLE::vertices							( vector_type ( &result )[ 4 ] ) const
{
	result[ 0 ]	= vector_type ( min.x, min.y );
	result[ 1 ]	= vector_type ( min.x, max.y );
	result[ 2 ]	= vector_type ( max.x, min.y );
	result[ 3 ]	= vector_type ( max.x, max.y );
}

TEMPLATE_SIGNATURE
inline bool	RECTANGLE::valid			( ) const
{
	return		( min.valid( ) && max.valid( ) );
}

TEMPLATE_SIGNATURE
inline typename RECTANGLE::type RECTANGLE::width		( ) const
{
	ASSERT		( max.x >= min.x );
	return		( max.x - min.x );
}

TEMPLATE_SIGNATURE
inline typename RECTANGLE::type RECTANGLE::height		( ) const
{
	ASSERT		( max.y >= min.y );
	return		( max.y - min.y );
}

#undef RECTANGLE
#undef TEMPLATE_SIGNATURE

#define TEMPLATE_SIGNATURE	template < typename vector_type >

TEMPLATE_SIGNATURE
inline math::rectangle<vector_type>	operator +						( math::rectangle<vector_type> const& rectangle, typename math::rectangle<vector_type>::type value )
{
	math::rectangle<vector_type>	result;
	result.min	= rectangle.min - value;
	result.max	= rectangle.max + value;
	return		( result );
}

TEMPLATE_SIGNATURE
inline math::rectangle<vector_type>	operator +						( typename math::rectangle<vector_type>::type value, math::rectangle<vector_type> const& rectangle )
{
	math::rectangle<vector_type>	result;
	result.min	= rectangle.min - value;
	result.max	= rectangle.max + value;
	return		( result );
}

TEMPLATE_SIGNATURE
inline math::rectangle<vector_type>	operator +						( math::rectangle<vector_type> const& rectangle, typename math::rectangle<vector_type>::vector_type const& value )
{
	math::rectangle<vector_type>	result;
	result.min	= rectangle.min - value;
	result.max	= rectangle.max + value;
	return		( result );
}

TEMPLATE_SIGNATURE
inline math::rectangle<vector_type>	operator +						( typename math::rectangle<vector_type>::vector_type const& value, math::rectangle<vector_type> const& rectangle )
{
	math::rectangle<vector_type>	result;
	result.min	= rectangle.min - value;
	result.max	= rectangle.max + value;
	return		( result );
}

TEMPLATE_SIGNATURE
inline math::rectangle<vector_type>	operator -						( math::rectangle<vector_type> const& rectangle, typename math::rectangle<vector_type>::type value )
{
	math::rectangle<vector_type>	result;
	result.min	= rectangle.min + value;
	result.max	= rectangle.max - value;
	return		( result );
}

TEMPLATE_SIGNATURE
inline math::rectangle<vector_type>	operator -						( typename math::rectangle<vector_type>::type value, math::rectangle<vector_type> const& rectangle )
{
	math::rectangle<vector_type>	result;
	result.min	= rectangle.min + value;
	result.max	= rectangle.max - value;
	return		( result );
}

TEMPLATE_SIGNATURE
inline math::rectangle<vector_type>	operator -						( math::rectangle<vector_type> const& rectangle, typename math::rectangle<vector_type>::vector_type const& value )
{
	math::rectangle<vector_type>	result;
	result.min	= rectangle.min + value;
	result.max	= rectangle.max - value;
	return		( result );
}

TEMPLATE_SIGNATURE
inline math::rectangle<vector_type>	operator -						( typename math::rectangle<vector_type>::vector_type const& value, math::rectangle<vector_type> const& rectangle )
{
	math::rectangle<vector_type>	result;
	result.min	= rectangle.min + value;
	result.max	= rectangle.max - value;
	return		( result );
}

TEMPLATE_SIGNATURE
inline math::rectangle<vector_type>	operator *						( math::rectangle<vector_type> const& rectangle, typename math::rectangle<vector_type>::type value )
{
	math::rectangle<vector_type>	result;
	result.min	= rectangle.min * value;
	result.max	= rectangle.max * value;
	return		( result );
}

TEMPLATE_SIGNATURE
inline math::rectangle<vector_type>	operator *						( typename math::rectangle<vector_type>::type value, math::rectangle<vector_type> const& rectangle )
{
	math::rectangle<vector_type>	result;
	result.min	= rectangle.min * value;
	result.max	= rectangle.max * value;
	return		( result );
}

TEMPLATE_SIGNATURE
inline math::rectangle<vector_type>	operator *						( math::rectangle<vector_type> const& rectangle, typename math::rectangle<vector_type>::vector_type const& value )
{
	math::rectangle<vector_type>	result;
	result.min	= rectangle.min * value;
	result.max	= rectangle.max * value;
	return		( result );
}

TEMPLATE_SIGNATURE
inline math::rectangle<vector_type>	operator *						( typename math::rectangle<vector_type>::vector_type const& value, math::rectangle<vector_type> const& rectangle )
{
	math::rectangle<vector_type>	result;
	result.min	= rectangle.min * value;
	result.max	= rectangle.max * value;
	return		( result );
}

TEMPLATE_SIGNATURE
inline math::rectangle<vector_type>	operator /						( math::rectangle<vector_type> const& rectangle, typename math::rectangle<vector_type>::type value )
{
	math::rectangle<vector_type>	result;
	result.min	= rectangle.min / value;
	result.max	= rectangle.max / value;
	return		( result );
}

TEMPLATE_SIGNATURE
inline math::rectangle<vector_type>	operator /						( typename math::rectangle<vector_type>::type value, math::rectangle<vector_type> const& rectangle )
{
	math::rectangle<vector_type>	result;
	result.min	= rectangle.min / value;
	result.max	= rectangle.max / value;
	return		( result );
}

TEMPLATE_SIGNATURE
inline math::rectangle<vector_type>	operator /						( math::rectangle<vector_type> const& rectangle, typename math::rectangle<vector_type>::vector_type const& value )
{
	math::rectangle<vector_type>	result;
	result.min	= rectangle.min / value;
	result.max	= rectangle.max / value;
	return		( result );
}

TEMPLATE_SIGNATURE
inline math::rectangle<vector_type>	operator /						( typename math::rectangle<vector_type>::vector_type const& value, math::rectangle<vector_type> const& rectangle )
{
	math::rectangle<vector_type>	result;
	result.min	= rectangle.min / value;
	result.max	= rectangle.max / value;
	return		( result );
}

} // namespace math
} // namespace xray

#undef TEMPLATE_SIGNATURE

#endif // #ifndef XRAY_MATH_RECTANGLE_INLINE_H_INCLUDED