janwas
5bf9bca9ef
there are too many W4 and "potentially uninitialized", so those are disabled by 0ad_warning_disable.h. the silly "int x = strlen" and very dangerous "int x = (void*)p" (and vice versa) problems are fixed. This was SVN commit r5526.
251 lines
6.7 KiB
C++
251 lines
6.7 KiB
C++
#include "precompiled.h"
|
|
#include "0ad_warning_disable.h"
|
|
# include "sr_grid.h"
|
|
|
|
//============================ SrGridBase =================================
|
|
|
|
SrGridBase::SrGridBase ( int dim, int ns )
|
|
{
|
|
_cells = 0;
|
|
if ( dim*ns>0 ) init ( dim, ns );
|
|
}
|
|
|
|
void SrGridBase::init ( int dim, int ns )
|
|
{
|
|
int i;
|
|
_axis.size ( dim );
|
|
|
|
for ( i=0; i<dim; i++ )
|
|
{ _axis[i].min = 0.0f;
|
|
_axis[i].max = 1.0f;
|
|
_axis[i].segs = ns;
|
|
}
|
|
|
|
init ( _axis );
|
|
}
|
|
|
|
void SrGridBase::init ( const SrArray<SrGridAxis>& axis_desc )
|
|
{
|
|
if ( &axis_desc != &_axis ) _axis=axis_desc;
|
|
|
|
if ( _axis.size()==0 ) { _cells=0; _size.size(0); _seglen.size(0); return; }
|
|
|
|
int i, j;
|
|
|
|
_cells = _axis[0].segs;
|
|
int dim = _axis.size();
|
|
|
|
for ( i=1; i<dim; i++ )
|
|
{ _cells *= _axis[i].segs;
|
|
}
|
|
|
|
_size.size ( dim );
|
|
for ( i=0; i<dim; i++ )
|
|
{ _size[i] = 1;
|
|
for ( j=0; j<i; j++ ) _size[i]*=_axis[j].segs;
|
|
}
|
|
|
|
_seglen.size ( dim );
|
|
for ( i=0; i<dim; i++ )
|
|
_seglen[i] = (_axis[i].max-_axis[i].min)/float(_axis[i].segs);
|
|
}
|
|
|
|
int SrGridBase::cell_index ( int i, int j ) const
|
|
{
|
|
if ( dimensions()!=2 ) return 0;
|
|
|
|
return _size[1]*j + i;
|
|
}
|
|
|
|
int SrGridBase::cell_index ( int i, int j, int k ) const
|
|
{
|
|
if ( dimensions()!=3 ) return 0;
|
|
|
|
return _size[2]*k + _size[1]*j + i;
|
|
}
|
|
|
|
int SrGridBase::cell_index ( const SrArray<int>& coords ) const
|
|
{
|
|
int dim = _axis.size();
|
|
|
|
if ( dim!=coords.size() || dim<=0 ) return 0;
|
|
|
|
int i, cell = coords[0];
|
|
for ( i=1; i<dim; i++ ) cell += coords[i]*_size[i];
|
|
|
|
return cell;
|
|
}
|
|
|
|
void SrGridBase::cell_coords ( int index, int& i, int& j ) const
|
|
{
|
|
if ( dimensions()!=2 ) { i=j=0; return; }
|
|
|
|
j = index/_size[1]; index=index%_size[1];
|
|
i = index;
|
|
}
|
|
|
|
void SrGridBase::cell_coords ( int index, int& i, int& j, int& k ) const
|
|
{
|
|
if ( dimensions()!=3 ) { i=j=k=0; return; }
|
|
|
|
k = index/_size[2]; index=index%_size[2];
|
|
j = index/_size[1]; index=index%_size[1];
|
|
i = index;
|
|
}
|
|
|
|
void SrGridBase::cell_coords ( int index, SrArray<int>& coords ) const
|
|
{
|
|
int d = dimensions();
|
|
|
|
if ( coords.size()!=d ) coords.size(d);
|
|
|
|
d--;
|
|
while ( d>0 )
|
|
{ coords[d] = index/_size[d];
|
|
index = index%_size[d];
|
|
d--;
|
|
}
|
|
coords[0] = index;
|
|
}
|
|
|
|
void SrGridBase::cell_boundary ( int i, int j, SrPnt2& a, SrPnt2& b ) const
|
|
{
|
|
if ( dimensions()!=2 ) return;
|
|
|
|
a.x = _axis[0].min + float(i)*_seglen[0];
|
|
a.y = _axis[1].min + float(j)*_seglen[1];
|
|
|
|
b.x = a.x + _seglen[0];
|
|
b.y = a.y + _seglen[1];
|
|
}
|
|
|
|
void SrGridBase::cell_boundary ( int i, int j, int k, SrPnt& a, SrPnt& b ) const
|
|
{
|
|
if ( dimensions()!=3 ) return;
|
|
|
|
a.x = _axis[0].min + float(i)*_seglen[0];
|
|
a.y = _axis[1].min + float(j)*_seglen[1];
|
|
a.z = _axis[2].min + float(k)*_seglen[2];
|
|
|
|
b.x = a.x + _seglen[0];
|
|
b.y = a.y + _seglen[1];
|
|
b.z = a.z + _seglen[2];
|
|
}
|
|
|
|
void SrGridBase::get_intersection ( SrPnt2 a, SrPnt2 b, SrArray<int>& cells ) const
|
|
{
|
|
if ( dimensions()!=2 ) return;
|
|
|
|
if ( a.x>b.x || a.y>b.y ) return;
|
|
|
|
if ( a.x>=_axis[0].max || a.y>=_axis[1].max ) return;
|
|
if ( b.x<=_axis[0].min || b.y<=_axis[1].min ) return;
|
|
|
|
float f = _seglen[0]/2;
|
|
a.x = SR_BOUND ( a.x, _axis[0].min, _axis[0].max-f );
|
|
b.x = SR_BOUND ( b.x, _axis[0].min, _axis[0].max-f );
|
|
f = _seglen[1]/2;
|
|
a.y = SR_BOUND ( a.y, _axis[1].min, _axis[1].max-f );
|
|
b.y = SR_BOUND ( b.y, _axis[1].min, _axis[1].max-f );
|
|
|
|
int i1 = (int) ((a.x-_axis[0].min) / _seglen[0]);
|
|
int j1 = (int) ((a.y-_axis[1].min) / _seglen[1]);
|
|
|
|
f = (b.x-_axis[0].min) / _seglen[0];
|
|
int i2 = int(f); if ( float(i2)==f ) i2--;
|
|
|
|
f = (b.y-_axis[1].min) / _seglen[1];
|
|
int j2 = int(f); if ( float(j2)==f ) j2--;
|
|
|
|
int i, j, index;
|
|
|
|
for ( j=j1; j<=j2; j++ )
|
|
{ index = _size[1]*j + i1; // == cell_index(i1,j);
|
|
for ( i=i1; i<=i2; i++ )
|
|
{ cells.push() = index;
|
|
index++;
|
|
}
|
|
}
|
|
}
|
|
|
|
void SrGridBase::get_intersection ( SrPnt a, SrPnt b, SrArray<int>& cells ) const
|
|
{
|
|
if ( dimensions()!=3 ) return;
|
|
|
|
if ( a.x>b.x || a.y>b.y || a.z>b.z ) return;
|
|
|
|
if ( a.x>=_axis[0].max || a.y>=_axis[1].max || a.z>=_axis[2].max ) return;
|
|
if ( b.x<=_axis[0].min || b.y<=_axis[1].min || b.z<=_axis[2].min ) return;
|
|
|
|
float f = _seglen[0]/2;
|
|
a.x = SR_BOUND ( a.x, _axis[0].min, _axis[0].max-f );
|
|
b.x = SR_BOUND ( b.x, _axis[0].min, _axis[0].max-f );
|
|
f = _seglen[1]/2;
|
|
a.y = SR_BOUND ( a.y, _axis[1].min, _axis[1].max-f );
|
|
b.y = SR_BOUND ( b.y, _axis[1].min, _axis[1].max-f );
|
|
f = _seglen[2]/2;
|
|
a.z = SR_BOUND ( a.z, _axis[2].min, _axis[2].max-f );
|
|
b.z = SR_BOUND ( b.z, _axis[2].min, _axis[2].max-f );
|
|
|
|
int i1 = (int) ((a.x-_axis[0].min) / _seglen[0]);
|
|
int j1 = (int) ((a.y-_axis[1].min) / _seglen[1]);
|
|
int k1 = (int) ((a.z-_axis[2].min) / _seglen[2]);
|
|
|
|
f = (b.x-_axis[0].min) / _seglen[0];
|
|
int i2 = int(f); if ( float(i2)==f ) i2--;
|
|
|
|
f = (b.y-_axis[1].min) / _seglen[1];
|
|
int j2 = int(f); if ( float(j2)==f ) j2--;
|
|
|
|
f = (b.z-_axis[2].min) / _seglen[2];
|
|
int k2 = int(f); if ( float(k2)==f ) k2--;
|
|
|
|
int i, j, k, index;
|
|
|
|
for ( k=k1; k<=k2; k++ )
|
|
for ( j=j1; j<=j2; j++ )
|
|
{ index = _size[2]*k + _size[1]*j + i1; // == cell_index(i1,j,k);
|
|
for ( i=i1; i<=i2; i++ )
|
|
{ cells.push() = index;
|
|
index++;
|
|
}
|
|
}
|
|
}
|
|
|
|
int SrGridBase::get_point_location ( SrPnt2 a ) const
|
|
{
|
|
if ( dimensions()!=2 ) return -1;
|
|
|
|
if ( a.x>=_axis[0].max || a.y>=_axis[1].max ) return -1;
|
|
if ( a.x<=_axis[0].min || a.y<=_axis[1].min ) return -1;
|
|
|
|
a.x = SR_BOUND ( a.x, _axis[0].min, _axis[0].max-(_seglen[0]/2) );
|
|
a.y = SR_BOUND ( a.y, _axis[1].min, _axis[1].max-(_seglen[1]/2) );
|
|
|
|
int i = (int) ((a.x-_axis[0].min) / _seglen[0]);
|
|
int j = (int) ((a.y-_axis[1].min) / _seglen[1]);
|
|
|
|
return _size[1]*j + i;
|
|
}
|
|
|
|
int SrGridBase::get_point_location ( SrPnt a ) const
|
|
{
|
|
if ( dimensions()!=3 ) return -1;
|
|
|
|
if ( a.x>=_axis[0].max || a.y>=_axis[1].max || a.z>=_axis[2].max ) return -1;
|
|
if ( a.x<=_axis[0].min || a.y<=_axis[1].min || a.z<=_axis[2].min ) return -1;
|
|
|
|
a.x = SR_BOUND ( a.x, _axis[0].min, _axis[0].max-(_seglen[0]/2) );
|
|
a.y = SR_BOUND ( a.y, _axis[1].min, _axis[1].max-(_seglen[1]/2) );
|
|
a.z = SR_BOUND ( a.z, _axis[2].min, _axis[2].max-(_seglen[2]/2) );
|
|
|
|
int i = (int) ((a.x-_axis[0].min) / _seglen[0]);
|
|
int j = (int) ((a.y-_axis[1].min) / _seglen[1]);
|
|
int k = (int) ((a.z-_axis[2].min) / _seglen[2]);
|
|
|
|
return _size[2]*k + _size[1]*j + i;
|
|
}
|
|
|
|
//============================== end of file ===============================
|
|
|