//-------------------------------------------------------------------------
// function: SetPixelThreshold
//
// Set threshold of intensity
// to be considered as part
// of the peak
//-------------------------------------------------------------------------
void CPeak::SetPixelThreshold(Float dIntensity)
{
if(dMaxIntensity < 0) // intensity should really be positive
{
FindRange();
}
// sort in assending order
if ( !PixelsSorted )
{
sort(vPixelList.begin(), vPixelList.end());
}
//
// Find first element that meets the threshold
// criteria
//
UInt i;
for(i = 0; i < vPixelList.size(); i ++ )
{
if(vPixelList[i].fIntensity > dIntensity)
break;
}
if( i > 0 )
{
vPixelList.erase(vPixelList.begin(), vPixelList.begin() + i - 1);
}
}
bool Insert(const ClosingPair &p) {
auto found = FindRange(p);
if (found.first == 0 && found.second == 0) {
const auto result = closing_pairs.insert(p);
if (!result.second)
result.first->second = p.second;
RemoveRange(std::next(result.first), p.second);
return true;
} else {
return false;
}
}
////////////////////////////////////////////////////////////////////////////////
// SetChannelProperty()
//
// Called by the engine when a channel property is set
// An interface to the property, the new value and as a link to the channel are passed
// to the method
////////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CetfarduinoAin::SetChannelProperty(long UserVal, tagNESTABLEPROP* pChan, VARIANT* NewValue)
{
int Index = pChan->Index-1; // we use 0 based index
variant_t& vtNewValue = reinterpret_cast<variant_t&>(*NewValue);
// Input Range property
if(UserVal == USER_INPUTRANGE) {
TSafeArrayAccess<double> NewRange(NewValue);
Range* range = 0;
RETURN_HRESULT(FindRange(NewRange[0], NewRange[1], range));
NewRange[0] = range->minVal;
NewRange[1] = range->maxVal;
_updateChildren = true;
}
_updateChildren = true;
return S_OK;
}
STDMETHODIMP CbDevice::ChildChange(ULONG typeofchange, tagNESTABLEPROP * pChan)
{
HRESULT retval=S_OK;
//int progress=typeofchange & ~CHILDCHANGE_REASON_MASK;
int type=typeofchange & CHILDCHANGE_REASON_MASK;
if (pChan) // if we have a channel
{
switch (type)
{
case ADD_CHILD :
++_nChannels;
retval=UpdateChans(false); // must exist in base class // resizes channel arrrays
_updateChildren=true;
// now set the new range
RANGE_INFO *NewInfo;
if (!retval)
{
retval=FindRange(static_cast<float>(reinterpret_cast<AICHANNEL*>(pChan)->VoltRange[0]),
static_cast<float>(reinterpret_cast<AICHANNEL*>(pChan)->VoltRange[1]),NewInfo);
if (!retval) _chanRange[_nChannels-1]=NewInfo->rangeInt;
}
if (retval)
--_nChannels;
return retval;
case DELETE_CHILD :
--_nChannels;
break;
case REINDEX_CHILD :
break;
}
}
if (typeofchange & END_CHANGE)
{
retval=UpdateChans(false); // must exist in base class
_updateChildren=true;
}
return retval;
}
HRESULT CbDevice::UpdateChans(bool ForStart)
{
_chanList.resize(_nChannels);
_chanRange.resize(_nChannels);
AICHANNEL *aichan=NULL;
if (_updateChildren && ForStart)
{
#ifdef _DEBUG
long chancheck=0;
_EngineChannelList->GetNumberOfChannels(&chancheck);
_ASSERTE(chancheck==_nChannels);
#endif
for (int i=0; i<_nChannels; i++)
{
_EngineChannelList->GetChannelStructLocal(i, (NESTABLEPROP**)&aichan);
_ASSERTE(aichan);
_chanList[i]=static_cast<short>(aichan->Nestable.HwChan);
RANGE_INFO *NewInfo;
RETURN_HRESULT(FindRange(static_cast<float>(aichan->VoltRange[0]),
static_cast<float>(aichan->VoltRange[1]),NewInfo));
_chanRange[i]=NewInfo->rangeInt;
if (aichan->Nestable.Type==NPAOCHANNEL)
{
RETURN_HRESULT(UpdateDefaultChannelValue(i,((AOCHANNEL*)aichan)->DefaultValue));
}
}
_updateChildren=false;
}
else
{
// we still need working chanlist and rangelist if no gainlist
}
return S_OK;
}
void CLegacyMeshDrawer::DoDrawGroundRow(const CCamera* cam, int bty)
{
if (!BigTexSquareRowVisible(cam, bty)) {
//! skip this entire row of squares if we can't see it
return;
}
CVertexArray* ma = GetVertexArray();
bool inStrip = false;
float x0, x1;
int x,y;
int sx = 0;
int ex = smfReadMap->numBigTexX;
//! only process the necessary big squares in the x direction
const int bigSquareSizeY = bty * smfReadMap->bigSquareSize;
const std::vector<CCamera::FrustumLine> negSides = cam->GetNegFrustumSides();
const std::vector<CCamera::FrustumLine> posSides = cam->GetPosFrustumSides();
std::vector<CCamera::FrustumLine>::const_iterator fli;
for (fli = negSides.begin(); fli != negSides.end(); ++fli) {
x0 = fli->base + fli->dir * bigSquareSizeY;
x1 = x0 + fli->dir * smfReadMap->bigSquareSize;
if (x0 > x1)
x0 = x1;
x0 /= smfReadMap->bigSquareSize;
if (x0 > sx)
sx = (int) x0;
}
for (fli = posSides.begin(); fli != posSides.end(); ++fli) {
x0 = fli->base + fli->dir * bigSquareSizeY + smfReadMap->bigSquareSize;
x1 = x0 + fli->dir * smfReadMap->bigSquareSize;
if (x0 < x1)
x0 = x1;
x0 /= smfReadMap->bigSquareSize;
if (x0 < ex)
ex = (int) x0;
}
if (sx > ex)
return;
const float cx2 = cam2->GetPos().x / SQUARE_SIZE;
const float cy2 = cam2->GetPos().z / SQUARE_SIZE;
for (int btx = sx; btx < ex; ++btx) {
ma->Initialize();
for (int lod = 1; lod < neededLod; lod <<= 1) {
float oldcamxpart = 0.0f;
float oldcamypart = 0.0f;
const int hlod = lod >> 1;
const int dlod = lod << 1;
int cx = cx2;
int cy = cy2;
if (lod > 1) {
int cxo = (cx / hlod) * hlod;
int cyo = (cy / hlod) * hlod;
float cx2o = (cxo / lod) * lod;
float cy2o = (cyo / lod) * lod;
oldcamxpart = (cx2 - cx2o) / lod;
oldcamypart = (cy2 - cy2o) / lod;
}
cx = (cx / lod) * lod;
cy = (cy / lod) * lod;
const int ysquaremod = (cy % dlod) / lod;
const int xsquaremod = (cx % dlod) / lod;
const float camxpart = (cx2 - ((cx / dlod) * dlod)) / dlod;
const float camypart = (cy2 - ((cy / dlod) * dlod)) / dlod;
const float mcxp = 1.0f - camxpart, mcyp = 1.0f - camypart;
const float hcxp = 0.5f * camxpart, hcyp = 0.5f * camypart;
const float hmcxp = 0.5f * mcxp, hmcyp = 0.5f * mcyp;
const float mocxp = 1.0f - oldcamxpart, mocyp = 1.0f - oldcamypart;
const float hocxp = 0.5f * oldcamxpart, hocyp = 0.5f * oldcamypart;
const float hmocxp = 0.5f * mocxp, hmocyp = 0.5f * mocyp;
const int minty = bty * smfReadMap->bigSquareSize, maxty = minty + smfReadMap->bigSquareSize;
const int mintx = btx * smfReadMap->bigSquareSize, maxtx = mintx + smfReadMap->bigSquareSize;
const int minly = cy + (-viewRadius + 3 - ysquaremod) * lod;
const int maxly = cy + ( viewRadius - 1 - ysquaremod) * lod;
const int minlx = cx + (-viewRadius + 3 - xsquaremod) * lod;
const int maxlx = cx + ( viewRadius - 1 - xsquaremod) * lod;
const int xstart = std::max(minlx, mintx), xend = std::min(maxlx, maxtx);
const int ystart = std::max(minly, minty), yend = std::min(maxly, maxty);
const int vrhlod = viewRadius * hlod;
for (y = ystart; y < yend; y += lod) {
int xs = xstart;
int xe = xend;
FindRange(cam2, /*inout*/ xs, /*inout*/ xe, y, lod);
// If FindRange modifies (xs, xe) to a (less then) empty range,
// continue to the next row.
// If we'd continue, nloop (below) would become negative and we'd
// allocate a vertex array with negative size. (mantis #1415)
if (xe < xs) continue;
int ylod = y + lod;
int yhlod = y + hlod;
int nloop = (xe - xs) / lod + 1;
ma->EnlargeArrays(52 * nloop);
int yhdx = y * smfReadMap->heightMapSizeX;
int ylhdx = yhdx + lod * smfReadMap->heightMapSizeX;
int yhhdx = yhdx + hlod * smfReadMap->heightMapSizeX;
for (x = xs; x < xe; x += lod) {
int xlod = x + lod;
int xhlod = x + hlod;
//! info: all triangle quads start in the top left corner
if ((lod == 1) ||
(x > cx + vrhlod) || (x < cx - vrhlod) ||
(y > cy + vrhlod) || (y < cy - vrhlod)) {
//! normal terrain (all vertices in one LOD)
if (!inStrip) {
DrawVertexAQ(ma, x, y);
DrawVertexAQ(ma, x, ylod);
inStrip = true;
}
DrawVertexAQ(ma, xlod, y);
DrawVertexAQ(ma, xlod, ylod);
} else {
//! border between 2 different LODs
if ((x >= cx + vrhlod)) {
//! lower LOD to the right
int idx1 = CLAMP(yhdx + x), idx1LOD = CLAMP(idx1 + lod), idx1HLOD = CLAMP(idx1 + hlod);
int idx2 = CLAMP(ylhdx + x), idx2LOD = CLAMP(idx2 + lod), idx2HLOD = CLAMP(idx2 + hlod);
int idx3 = CLAMP(yhhdx + x), idx3HLOD = CLAMP(idx3 + hlod);
float h1 = (GetVisibleVertexHeight(idx1) + GetVisibleVertexHeight(idx2)) * hmocxp + GetVisibleVertexHeight(idx3) * oldcamxpart;
float h2 = (GetVisibleVertexHeight(idx1) + GetVisibleVertexHeight(idx1LOD)) * hmocxp + GetVisibleVertexHeight(idx1HLOD) * oldcamxpart;
float h3 = (GetVisibleVertexHeight(idx2) + GetVisibleVertexHeight(idx1LOD)) * hmocxp + GetVisibleVertexHeight(idx3HLOD) * oldcamxpart;
float h4 = (GetVisibleVertexHeight(idx2) + GetVisibleVertexHeight(idx2LOD)) * hmocxp + GetVisibleVertexHeight(idx2HLOD) * oldcamxpart;
if (inStrip) {
ma->EndStrip();
inStrip = false;
}
DrawVertexAQ(ma, x, y);
DrawVertexAQ(ma, x, yhlod, h1);
DrawVertexAQ(ma, xhlod, y, h2);
DrawVertexAQ(ma, xhlod, yhlod, h3);
ma->EndStrip();
DrawVertexAQ(ma, x, yhlod, h1);
DrawVertexAQ(ma, x, ylod);
DrawVertexAQ(ma, xhlod, yhlod, h3);
DrawVertexAQ(ma, xhlod, ylod, h4);
ma->EndStrip();
DrawVertexAQ(ma, xhlod, ylod, h4);
DrawVertexAQ(ma, xlod, ylod);
DrawVertexAQ(ma, xhlod, yhlod, h3);
DrawVertexAQ(ma, xlod, y);
DrawVertexAQ(ma, xhlod, y, h2);
ma->EndStrip();
}
else if ((x <= cx - vrhlod)) {
//! lower LOD to the left
int idx1 = CLAMP(yhdx + x), idx1LOD = CLAMP(idx1 + lod), idx1HLOD = CLAMP(idx1 + hlod);
int idx2 = CLAMP(ylhdx + x), idx2LOD = CLAMP(idx2 + lod), idx2HLOD = CLAMP(idx2 + hlod);
int idx3 = CLAMP(yhhdx + x), idx3LOD = CLAMP(idx3 + lod), idx3HLOD = CLAMP(idx3 + hlod);
float h1 = (GetVisibleVertexHeight(idx1LOD) + GetVisibleVertexHeight(idx2LOD)) * hocxp + GetVisibleVertexHeight(idx3LOD ) * mocxp;
float h2 = (GetVisibleVertexHeight(idx1 ) + GetVisibleVertexHeight(idx1LOD)) * hocxp + GetVisibleVertexHeight(idx1HLOD) * mocxp;
float h3 = (GetVisibleVertexHeight(idx2 ) + GetVisibleVertexHeight(idx1LOD)) * hocxp + GetVisibleVertexHeight(idx3HLOD) * mocxp;
float h4 = (GetVisibleVertexHeight(idx2 ) + GetVisibleVertexHeight(idx2LOD)) * hocxp + GetVisibleVertexHeight(idx2HLOD) * mocxp;
if (inStrip) {
ma->EndStrip();
inStrip = false;
}
DrawVertexAQ(ma, xlod, yhlod, h1);
DrawVertexAQ(ma, xlod, y);
DrawVertexAQ(ma, xhlod, yhlod, h3);
DrawVertexAQ(ma, xhlod, y, h2);
ma->EndStrip();
DrawVertexAQ(ma, xlod, ylod);
DrawVertexAQ(ma, xlod, yhlod, h1);
DrawVertexAQ(ma, xhlod, ylod, h4);
DrawVertexAQ(ma, xhlod, yhlod, h3);
ma->EndStrip();
DrawVertexAQ(ma, xhlod, y, h2);
DrawVertexAQ(ma, x, y);
DrawVertexAQ(ma, xhlod, yhlod, h3);
DrawVertexAQ(ma, x, ylod);
DrawVertexAQ(ma, xhlod, ylod, h4);
ma->EndStrip();
}
if ((y >= cy + vrhlod)) {
//! lower LOD above
int idx1 = yhdx + x, idx1LOD = CLAMP(idx1 + lod), idx1HLOD = CLAMP(idx1 + hlod);
int idx2 = ylhdx + x, idx2LOD = CLAMP(idx2 + lod);
int idx3 = yhhdx + x, idx3LOD = CLAMP(idx3 + lod), idx3HLOD = CLAMP(idx3 + hlod);
float h1 = (GetVisibleVertexHeight(idx1 ) + GetVisibleVertexHeight(idx1LOD)) * hmocyp + GetVisibleVertexHeight(idx1HLOD) * oldcamypart;
float h2 = (GetVisibleVertexHeight(idx1 ) + GetVisibleVertexHeight(idx2 )) * hmocyp + GetVisibleVertexHeight(idx3 ) * oldcamypart;
float h3 = (GetVisibleVertexHeight(idx2 ) + GetVisibleVertexHeight(idx1LOD)) * hmocyp + GetVisibleVertexHeight(idx3HLOD) * oldcamypart;
float h4 = (GetVisibleVertexHeight(idx2LOD) + GetVisibleVertexHeight(idx1LOD)) * hmocyp + GetVisibleVertexHeight(idx3LOD ) * oldcamypart;
if (inStrip) {
ma->EndStrip();
inStrip = false;
}
DrawVertexAQ(ma, x, y);
DrawVertexAQ(ma, x, yhlod, h2);
DrawVertexAQ(ma, xhlod, y, h1);
DrawVertexAQ(ma, xhlod, yhlod, h3);
DrawVertexAQ(ma, xlod, y);
DrawVertexAQ(ma, xlod, yhlod, h4);
ma->EndStrip();
DrawVertexAQ(ma, x, yhlod, h2);
DrawVertexAQ(ma, x, ylod);
DrawVertexAQ(ma, xhlod, yhlod, h3);
DrawVertexAQ(ma, xlod, ylod);
DrawVertexAQ(ma, xlod, yhlod, h4);
ma->EndStrip();
}
else if ((y <= cy - vrhlod)) {
//! lower LOD beneath
int idx1 = CLAMP(yhdx + x), idx1LOD = CLAMP(idx1 + lod);
int idx2 = CLAMP(ylhdx + x), idx2LOD = CLAMP(idx2 + lod), idx2HLOD = CLAMP(idx2 + hlod);
int idx3 = CLAMP(yhhdx + x), idx3LOD = CLAMP(idx3 + lod), idx3HLOD = CLAMP(idx3 + hlod);
float h1 = (GetVisibleVertexHeight(idx2 ) + GetVisibleVertexHeight(idx2LOD)) * hocyp + GetVisibleVertexHeight(idx2HLOD) * mocyp;
float h2 = (GetVisibleVertexHeight(idx1 ) + GetVisibleVertexHeight(idx2 )) * hocyp + GetVisibleVertexHeight(idx3 ) * mocyp;
float h3 = (GetVisibleVertexHeight(idx2 ) + GetVisibleVertexHeight(idx1LOD)) * hocyp + GetVisibleVertexHeight(idx3HLOD) * mocyp;
float h4 = (GetVisibleVertexHeight(idx2LOD) + GetVisibleVertexHeight(idx1LOD)) * hocyp + GetVisibleVertexHeight(idx3LOD ) * mocyp;
if (inStrip) {
ma->EndStrip();
inStrip = false;
}
DrawVertexAQ(ma, x, yhlod, h2);
DrawVertexAQ(ma, x, ylod);
DrawVertexAQ(ma, xhlod, yhlod, h3);
DrawVertexAQ(ma, xhlod, ylod, h1);
DrawVertexAQ(ma, xlod, yhlod, h4);
DrawVertexAQ(ma, xlod, ylod);
ma->EndStrip();
DrawVertexAQ(ma, xlod, yhlod, h4);
DrawVertexAQ(ma, xlod, y);
DrawVertexAQ(ma, xhlod, yhlod, h3);
DrawVertexAQ(ma, x, y);
DrawVertexAQ(ma, x, yhlod, h2);
ma->EndStrip();
}
}
}
if (inStrip) {
ma->EndStrip();
inStrip = false;
}
} //for (y = ystart; y < yend; y += lod)
const int yst = std::max(ystart - lod, minty);
const int yed = std::min(yend + lod, maxty);
int nloop = (yed - yst) / lod + 1;
if (nloop > 0)
ma->EnlargeArrays(8 * nloop);
//! rita yttre begr?snings yta mot n?ta lod
if (maxlx < maxtx && maxlx >= mintx) {
x = maxlx;
int xlod = x + lod;
for (y = yst; y < yed; y += lod) {
DrawVertexAQ(ma, x, y);
DrawVertexAQ(ma, x, y + lod);
if (y % dlod) {
const int idx1 = CLAMP((y ) * smfReadMap->heightMapSizeX + x), idx1LOD = CLAMP(idx1 + lod);
const int idx2 = CLAMP((y + lod) * smfReadMap->heightMapSizeX + x), idx2LOD = CLAMP(idx2 + lod);
const int idx3 = CLAMP((y - lod) * smfReadMap->heightMapSizeX + x), idx3LOD = CLAMP(idx3 + lod);
const float h = (GetVisibleVertexHeight(idx3LOD) + GetVisibleVertexHeight(idx2LOD)) * hmcxp + GetVisibleVertexHeight(idx1LOD) * camxpart;
DrawVertexAQ(ma, xlod, y, h);
DrawVertexAQ(ma, xlod, y + lod);
} else {
const int idx1 = CLAMP((y ) * smfReadMap->heightMapSizeX + x), idx1LOD = CLAMP(idx1 + lod);
const int idx2 = CLAMP((y + lod) * smfReadMap->heightMapSizeX + x), idx2LOD = CLAMP(idx2 + lod);
const int idx3 = CLAMP((y + dlod) * smfReadMap->heightMapSizeX + x), idx3LOD = CLAMP(idx3 + lod);
const float h = (GetVisibleVertexHeight(idx1LOD) + GetVisibleVertexHeight(idx3LOD)) * hmcxp + GetVisibleVertexHeight(idx2LOD) * camxpart;
DrawVertexAQ(ma, xlod, y);
DrawVertexAQ(ma, xlod, y + lod, h);
}
ma->EndStrip();
}
}
if (minlx > mintx && minlx < maxtx) {
x = minlx - lod;
int xlod = x + lod;
for (y = yst; y < yed; y += lod) {
if (y % dlod) {
int idx1 = CLAMP((y ) * smfReadMap->heightMapSizeX + x);
int idx2 = CLAMP((y + lod) * smfReadMap->heightMapSizeX + x);
int idx3 = CLAMP((y - lod) * smfReadMap->heightMapSizeX + x);
float h = (GetVisibleVertexHeight(idx3) + GetVisibleVertexHeight(idx2)) * hcxp + GetVisibleVertexHeight(idx1) * mcxp;
DrawVertexAQ(ma, x, y, h);
DrawVertexAQ(ma, x, y + lod);
} else {
int idx1 = CLAMP((y ) * smfReadMap->heightMapSizeX + x);
int idx2 = CLAMP((y + lod) * smfReadMap->heightMapSizeX + x);
int idx3 = CLAMP((y + dlod) * smfReadMap->heightMapSizeX + x);
float h = (GetVisibleVertexHeight(idx1) + GetVisibleVertexHeight(idx3)) * hcxp + GetVisibleVertexHeight(idx2) * mcxp;
DrawVertexAQ(ma, x, y);
DrawVertexAQ(ma, x, y + lod, h);
}
DrawVertexAQ(ma, xlod, y);
DrawVertexAQ(ma, xlod, y + lod);
ma->EndStrip();
}
}
if (maxly < maxty && maxly > minty) {
y = maxly;
int xs = std::max(xstart - lod, mintx);
int xe = std::min(xend + lod, maxtx);
FindRange(cam2, xs, xe, y, lod);
if (xs < xe) {
x = xs;
int ylod = y + lod;
int nloop = (xe - xs) / lod + 2; //! one extra for if statment
int ylhdx = (y + lod) * smfReadMap->heightMapSizeX;
ma->EnlargeArrays(2 * nloop);
if (x % dlod) {
int idx2 = CLAMP(ylhdx + x), idx2PLOD = CLAMP(idx2 + lod), idx2MLOD = CLAMP(idx2 - lod);
float h = (GetVisibleVertexHeight(idx2MLOD) + GetVisibleVertexHeight(idx2PLOD)) * hmcyp + GetVisibleVertexHeight(idx2) * camypart;
DrawVertexAQ(ma, x, y);
DrawVertexAQ(ma, x, ylod, h);
} else {
DrawVertexAQ(ma, x, y);
DrawVertexAQ(ma, x, ylod);
}
for (x = xs; x < xe; x += lod) {
if (x % dlod) {
DrawVertexAQ(ma, x + lod, y);
DrawVertexAQ(ma, x + lod, ylod);
} else {
int idx2 = CLAMP(ylhdx + x), idx2PLOD = CLAMP(idx2 + lod), idx2PLOD2 = CLAMP(idx2 + dlod);
float h = (GetVisibleVertexHeight(idx2PLOD2) + GetVisibleVertexHeight(idx2)) * hmcyp + GetVisibleVertexHeight(idx2PLOD) * camypart;
DrawVertexAQ(ma, x + lod, y);
DrawVertexAQ(ma, x + lod, ylod, h);
}
}
ma->EndStrip();
}
}
if (minly > minty && minly < maxty) {
y = minly - lod;
int xs = std::max(xstart - lod, mintx);
int xe = std::min(xend + lod, maxtx);
FindRange(cam2, xs, xe, y, lod);
if (xs < xe) {
x = xs;
int ylod = y + lod;
int yhdx = y * smfReadMap->heightMapSizeX;
int nloop = (xe - xs) / lod + 2; //! one extra for if statment
ma->EnlargeArrays(2 * nloop);
if (x % dlod) {
int idx1 = CLAMP(yhdx + x), idx1PLOD = CLAMP(idx1 + lod), idx1MLOD = CLAMP(idx1 - lod);
float h = (GetVisibleVertexHeight(idx1MLOD) + GetVisibleVertexHeight(idx1PLOD)) * hcyp + GetVisibleVertexHeight(idx1) * mcyp;
DrawVertexAQ(ma, x, y, h);
DrawVertexAQ(ma, x, ylod);
} else {
DrawVertexAQ(ma, x, y);
DrawVertexAQ(ma, x, ylod);
}
for (x = xs; x < xe; x+= lod) {
if (x % dlod) {
DrawVertexAQ(ma, x + lod, y);
DrawVertexAQ(ma, x + lod, ylod);
} else {
int idx1 = CLAMP(yhdx + x), idx1PLOD = CLAMP(idx1 + lod), idx1PLOD2 = CLAMP(idx1 + dlod);
float h = (GetVisibleVertexHeight(idx1PLOD2) + GetVisibleVertexHeight(idx1)) * hcyp + GetVisibleVertexHeight(idx1PLOD) * mcyp;
DrawVertexAQ(ma, x + lod, y, h);
DrawVertexAQ(ma, x + lod, ylod);
}
}
ma->EndStrip();
}
}
} //for (int lod = 1; lod < neededLod; lod <<= 1)
smfGroundDrawer->SetupBigSquare(btx, bty);
DrawGroundVertexArrayQ(ma);
}
}
float findC3RangeWithNetwork(MECH * mech, MECH * mechTarget,
float realRange, dbref * myNetwork,
int networkSize, dbref * c3Ref)
{
float c3Range = 0.0;
float bestRange = 0.0;
int i;
int inLOS = 0;
int mapX, mapY;
float hexX, hexY, hexZ;
MECH *otherMech;
MAP *map;
bestRange = realRange;
*c3Ref = 0;
if(networkSize == 0)
return realRange;
for(i = 0; i < networkSize; i++) {
otherMech = getMechInTempNetwork(i, myNetwork, networkSize);
if(!otherMech)
continue;
if(!Good_obj(otherMech->mynum))
continue;
if(mechTarget) {
if(otherMech == mechTarget)
continue;
debugC3(tprintf
("C3RANGE-NETWORK (mech): Finding range from %d to %d.",
mech->mynum, mechTarget->mynum));
c3Range = FaMechRange(otherMech, mechTarget);
inLOS =
InLineOfSight(otherMech, mechTarget, MechX(mechTarget),
MechY(mechTarget), c3Range);
} else if((MechTargX(mech) > 0) && (MechTargY(mech) > 0)) {
mapX = MechTargX(mech);
mapY = MechTargY(mech);
map = getMap(mech->mapindex);
debugC3(tprintf
("C3RANGE-NETWORK (hex): Finding range from %d to %d %d.",
mech->mynum, mapX, mapY));
MechTargZ(mech) = Elevation(map, mapX, mapY);
hexZ = ZSCALE * MechTargZ(mech);
MapCoordToRealCoord(mapX, mapY, &hexX, &hexY);
c3Range =
FindRange(MechFX(otherMech), MechFY(otherMech),
MechFZ(otherMech), hexX, hexY, hexZ);
inLOS = LOS_NB(otherMech, NULL, mapX, mapY, c3Range);
} else {
continue;
}
if(inLOS && (c3Range < bestRange)) {
bestRange = c3Range;
*c3Ref = otherMech->mynum;
}
}
return bestRange;
}
