void OGRLineString::setPoints( int nPointsIn, OGRRawPoint * paoPointsIn,
double * padfZ )
{
setNumPoints( nPointsIn );
memcpy( paoPoints, paoPointsIn, sizeof(OGRRawPoint) * nPointsIn);
/* -------------------------------------------------------------------- */
/* Check 2D/3D. */
/* -------------------------------------------------------------------- */
if( padfZ != NULL )
{
int i, bIs3D = FALSE;
for( i = 0; i < nPointsIn && !bIs3D; i++ )
{
if( padfZ[i] != 0.0 )
bIs3D = TRUE;
}
if( !bIs3D )
padfZ = NULL;
}
if( padfZ == NULL )
{
if( this->padfZ != NULL )
Make2D();
}
else
{
Make3D();
memcpy( this->padfZ, padfZ, sizeof(double) * nPointsIn );
}
}
void EntityEmitter::UpdateSound(Sound& sound) {
AL::Source& source = sound.GetSource();
if (entityNum == listenerEntity) {
MakeLocal(source);
} else {
Make3D(source, entities[entityNum].position, entities[entityNum].velocity);
}
}
void OGRLineString::setPoints( int nPointsIn, double * padfX, double * padfY,
double * padfZ )
{
int i;
/* -------------------------------------------------------------------- */
/* Check 2D/3D. */
/* -------------------------------------------------------------------- */
if( padfZ != NULL )
{
int bIs3D = FALSE;
for( i = 0; i < nPointsIn && !bIs3D; i++ )
{
if( padfZ[i] != 0.0 )
bIs3D = TRUE;
}
if( !bIs3D )
padfZ = NULL;
}
#ifdef __WXOSX__
if( padfZ == NULL ) {
Make2D();
return;
}
#else
if( padfZ == NULL )
Make2D();
#endif
else
Make3D();
/* -------------------------------------------------------------------- */
/* Assign values. */
/* -------------------------------------------------------------------- */
setNumPoints( nPointsIn );
for( i = 0; i < nPointsIn; i++ )
{
paoPoints[i].x = padfX[i];
paoPoints[i].y = padfY[i];
}
if( this->padfZ != NULL )
memcpy( this->padfZ, padfZ, sizeof(double) * nPointsIn );
}
void OGRLineString::setPoint( int iPoint, double xIn, double yIn, double zIn )
{
if( iPoint >= nPointCount )
setNumPoints( iPoint+1 );
paoPoints[iPoint].x = xIn;
paoPoints[iPoint].y = yIn;
if( zIn != 0.0 )
{
Make3D();
padfZ[iPoint] = zIn;
}
else if( getCoordinateDimension() == 3 )
{
padfZ[iPoint] = 0.0;
}
}
OGRLinearRing::OGRLinearRing( OGRLinearRing * poSrcRing )
{
if( poSrcRing == NULL )
{
CPLDebug( "OGR", "OGRLinearRing::OGRLinearRing(OGRLinearRing*poSrcRing) - passed in ring is NULL!" );
return;
}
setNumPoints( poSrcRing->getNumPoints() );
memcpy( paoPoints, poSrcRing->paoPoints,
sizeof(OGRRawPoint) * getNumPoints() );
if( poSrcRing->padfZ )
{
Make3D();
memcpy( padfZ, poSrcRing->padfZ, sizeof(double) * getNumPoints() );
}
}
OGRErr OGRLinearRing::_importFromWkb( OGRwkbByteOrder eByteOrder, int b3D,
unsigned char * pabyData,
int nBytesAvailable )
{
if( nBytesAvailable < 4 && nBytesAvailable != -1 )
return OGRERR_NOT_ENOUGH_DATA;
/* -------------------------------------------------------------------- */
/* Get the vertex count. */
/* -------------------------------------------------------------------- */
int nNewNumPoints;
memcpy( &nNewNumPoints, pabyData, 4 );
if( OGR_SWAP( eByteOrder ) )
nNewNumPoints = CPL_SWAP32(nNewNumPoints);
/* Check if the wkb stream buffer is big enough to store
* fetched number of points.
* 16 or 24 - size of point structure
*/
int nPointSize = (b3D ? 24 : 16);
if (nNewNumPoints < 0 || nNewNumPoints > INT_MAX / nPointSize)
return OGRERR_CORRUPT_DATA;
int nBufferMinSize = nPointSize * nNewNumPoints;
if( nBytesAvailable != -1 && nBufferMinSize > nBytesAvailable - 4 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Length of input WKB is too small" );
return OGRERR_NOT_ENOUGH_DATA;
}
/* (Re)Allocation of paoPoints buffer. */
setNumPoints( nNewNumPoints );
if( b3D )
Make3D();
else
Make2D();
/* -------------------------------------------------------------------- */
/* Get the vertices */
/* -------------------------------------------------------------------- */
int i = 0;
if( !b3D )
{
memcpy( paoPoints, pabyData + 4, 16 * nPointCount );
}
else
{
for( int i = 0; i < nPointCount; i++ )
{
memcpy( &(paoPoints[i].x), pabyData + 4 + 24 * i, 8 );
memcpy( &(paoPoints[i].y), pabyData + 4 + 24 * i + 8, 8 );
memcpy( padfZ + i, pabyData + 4 + 24 * i + 16, 8 );
}
}
/* -------------------------------------------------------------------- */
/* Byte swap if needed. */
/* -------------------------------------------------------------------- */
if( OGR_SWAP( eByteOrder ) )
{
for( i = 0; i < nPointCount; i++ )
{
CPL_SWAPDOUBLE( &(paoPoints[i].x) );
CPL_SWAPDOUBLE( &(paoPoints[i].y) );
if( b3D )
{
CPL_SWAPDOUBLE( padfZ + i );
}
}
}
return OGRERR_NONE;
}
//! @cond Doxygen_Suppress
OGRErr OGRLinearRing::_importFromWkb( OGRwkbByteOrder eByteOrder, int _flags,
const unsigned char * pabyData,
int nBytesAvailable,
int& nBytesConsumedOut )
{
nBytesConsumedOut = -1;
if( nBytesAvailable < 4 && nBytesAvailable != -1 )
return OGRERR_NOT_ENOUGH_DATA;
/* -------------------------------------------------------------------- */
/* Get the vertex count. */
/* -------------------------------------------------------------------- */
int nNewNumPoints = 0;
memcpy( &nNewNumPoints, pabyData, 4 );
if( OGR_SWAP( eByteOrder ) )
nNewNumPoints = CPL_SWAP32(nNewNumPoints);
// Check if the wkb stream buffer is big enough to store
// fetched number of points.
// 16, 24, or 32 - size of point structure.
int nPointSize = 0;
if( (_flags & OGR_G_3D) && (_flags & OGR_G_MEASURED) )
nPointSize = 32;
else if( (_flags & OGR_G_3D) || (_flags & OGR_G_MEASURED) )
nPointSize = 24;
else
nPointSize = 16;
if( nNewNumPoints < 0 || nNewNumPoints > INT_MAX / nPointSize )
return OGRERR_CORRUPT_DATA;
int nBufferMinSize = nPointSize * nNewNumPoints;
if( nBytesAvailable != -1 && nBufferMinSize > nBytesAvailable - 4 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Length of input WKB is too small" );
return OGRERR_NOT_ENOUGH_DATA;
}
// (Re)Allocation of paoPoints buffer.
setNumPoints( nNewNumPoints, FALSE );
if( _flags & OGR_G_3D )
Make3D();
else
Make2D();
if( _flags & OGR_G_MEASURED )
AddM();
else
RemoveM();
nBytesConsumedOut = 4 + nPointCount * nPointSize;
/* -------------------------------------------------------------------- */
/* Get the vertices */
/* -------------------------------------------------------------------- */
if( (flags & OGR_G_3D) && (flags & OGR_G_MEASURED) )
{
for( int i = 0; i < nPointCount; i++ )
{
memcpy( &(paoPoints[i].x), pabyData + 4 + 32 * i, 8 );
memcpy( &(paoPoints[i].y), pabyData + 4 + 32 * i + 8, 8 );
memcpy( padfZ + i, pabyData + 4 + 32 * i + 16, 8 );
memcpy( padfM + i, pabyData + 4 + 32 * i + 24, 8 );
}
}
else if( flags & OGR_G_MEASURED )
{
for( int i = 0; i < nPointCount; i++ )
{
memcpy( &(paoPoints[i].x), pabyData + 4 + 24 * i, 8 );
memcpy( &(paoPoints[i].y), pabyData + 4 + 24 * i + 8, 8 );
memcpy( padfM + i, pabyData + 4 + 24 * i + 16, 8 );
}
}
else if( flags & OGR_G_3D )
{
for( int i = 0; i < nPointCount; i++ )
{
memcpy( &(paoPoints[i].x), pabyData + 4 + 24 * i, 8 );
memcpy( &(paoPoints[i].y), pabyData + 4 + 24 * i + 8, 8 );
memcpy( padfZ + i, pabyData + 4 + 24 * i + 16, 8 );
}
}
else
{
memcpy( paoPoints, pabyData + 4, 16 * nPointCount );
}
/* -------------------------------------------------------------------- */
/* Byte swap if needed. */
/* -------------------------------------------------------------------- */
if( OGR_SWAP( eByteOrder ) )
{
for( int i = 0; i < nPointCount; i++ )
{
CPL_SWAPDOUBLE( &(paoPoints[i].x) );
CPL_SWAPDOUBLE( &(paoPoints[i].y) );
if( flags & OGR_G_3D )
{
CPL_SWAPDOUBLE( padfZ + i );
}
if( flags & OGR_G_MEASURED )
{
CPL_SWAPDOUBLE( padfM + i );
}
}
}
return OGRERR_NONE;
}
OGRErr OGRLinearRing::_importFromWkb( OGRwkbByteOrder eByteOrder, int b3D,
unsigned char * pabyData,
int nBytesAvailable )
{
if( nBytesAvailable < 4 && nBytesAvailable != -1 )
return OGRERR_NOT_ENOUGH_DATA;
/* -------------------------------------------------------------------- */
/* Get the vertex count. */
/* -------------------------------------------------------------------- */
int nNewNumPoints;
memcpy( &nNewNumPoints, pabyData, 4 );
if( OGR_SWAP( eByteOrder ) )
nNewNumPoints = CPL_SWAP32(nNewNumPoints);
setNumPoints( nNewNumPoints );
if( b3D )
Make3D();
else
Make2D();
/* -------------------------------------------------------------------- */
/* Get the vertices */
/* -------------------------------------------------------------------- */
int i;
if( !b3D )
memcpy( paoPoints, pabyData + 4, 16 * nPointCount );
else
{
for( int i = 0; i < nPointCount; i++ )
{
memcpy( &(paoPoints[i].x), pabyData + 4 + 24 * i, 8 );
memcpy( &(paoPoints[i].y), pabyData + 4 + 24 * i + 8, 8 );
memcpy( padfZ + i, pabyData + 4 + 24 * i + 16, 8 );
}
}
/* -------------------------------------------------------------------- */
/* Byte swap if needed. */
/* -------------------------------------------------------------------- */
if( OGR_SWAP( eByteOrder ) )
{
for( i = 0; i < nPointCount; i++ )
{
CPL_SWAPDOUBLE( &(paoPoints[i].x) );
CPL_SWAPDOUBLE( &(paoPoints[i].y) );
if( b3D )
{
CPL_SWAPDOUBLE( padfZ + i );
}
}
}
return OGRERR_NONE;
}
OGRErr OGRLineString::importFromWkb( unsigned char * pabyData,
int nBytesAvailable )
{
OGRwkbByteOrder eByteOrder;
if( nBytesAvailable < 21 && nBytesAvailable != -1 )
return OGRERR_NOT_ENOUGH_DATA;
/* -------------------------------------------------------------------- */
/* Get the byte order byte. */
/* -------------------------------------------------------------------- */
eByteOrder = (OGRwkbByteOrder) *pabyData;
assert( eByteOrder == wkbXDR || eByteOrder == wkbNDR );
/* -------------------------------------------------------------------- */
/* Get the geometry feature type. For now we assume that */
/* geometry type is between 0 and 255 so we only have to fetch */
/* one byte. */
/* -------------------------------------------------------------------- */
OGRwkbGeometryType eGeometryType;
int bIs3D;
if( eByteOrder == wkbNDR )
{
eGeometryType = (OGRwkbGeometryType) pabyData[1];
bIs3D = (pabyData[2] & 0x80);
}
else
{
eGeometryType = (OGRwkbGeometryType) pabyData[4];
bIs3D = (pabyData[3] & 0x80);
}
assert( eGeometryType == wkbLineString );
/* -------------------------------------------------------------------- */
/* Get the vertex count. */
/* -------------------------------------------------------------------- */
int nNewNumPoints;
memcpy( &nNewNumPoints, pabyData + 5, 4 );
if( OGR_SWAP( eByteOrder ) )
nNewNumPoints = CPL_SWAP32(nNewNumPoints);
setNumPoints( nNewNumPoints );
if( bIs3D )
Make3D();
else
Make2D();
/* -------------------------------------------------------------------- */
/* Get the vertex. */
/* -------------------------------------------------------------------- */
int i;
if( bIs3D )
{
for( i = 0; i < nPointCount; i++ )
{
memcpy( paoPoints + i, pabyData + 9 + i*24, 16 );
memcpy( padfZ + i, pabyData + 9 + 16 + i*24, 8 );
}
}
else
{
memcpy( paoPoints, pabyData + 9, 16 * nPointCount );
}
/* -------------------------------------------------------------------- */
/* Byte swap if needed. */
/* -------------------------------------------------------------------- */
if( OGR_SWAP( eByteOrder ) )
{
for( i = 0; i < nPointCount; i++ )
{
CPL_SWAPDOUBLE( &(paoPoints[i].x) );
CPL_SWAPDOUBLE( &(paoPoints[i].y) );
}
if( bIs3D )
{
for( i = 0; i < nPointCount; i++ )
{
CPL_SWAPDOUBLE( padfZ + i );
}
}
}
return OGRERR_NONE;
}
void PositionEmitter::InternalSetupSound(Sound& sound) {
AL::Source& source = sound.GetSource();
Make3D(source, position, origin);
}
void PositionEmitter::UpdateSound(Sound& sound) {
AL::Source& source = sound.GetSource();
Make3D(source, position, origin);
}
void EntityEmitter::InternalSetupSound(Sound& sound) {
AL::Source& source = sound.GetSource();
Make3D(source, entities[entityNum].position, entities[entityNum].velocity);
}
