void Channel::_drawModel( const Model* scene )
{
Window* window = static_cast< Window* >( getWindow( ));
VertexBufferState& state = window->getState();
const FrameData& frameData = _getFrameData();
if( frameData.getColorMode() == COLOR_MODEL && scene->hasColors( ))
state.setColors( true );
else
state.setColors( false );
state.setChannel( this );
// Compute cull matrix
const eq::Matrix4f& rotation = frameData.getCameraRotation();
const eq::Matrix4f& modelRotation = frameData.getModelRotation();
eq::Matrix4f position = eq::Matrix4f::IDENTITY;
position.set_translation( frameData.getCameraPosition());
const eq::Frustumf& frustum = getFrustum();
const eq::Matrix4f projection = useOrtho() ? frustum.compute_ortho_matrix():
frustum.compute_matrix();
const eq::Matrix4f& view = getHeadTransform();
const eq::Matrix4f model = rotation * position * modelRotation;
state.setProjectionModelViewMatrix( projection * view * model );
state.setRange( &getRange().start);
const eq::Pipe* pipe = getPipe();
const GLuint program = state.getProgram( pipe );
if( program != VertexBufferState::INVALID )
glUseProgram( program );
scene->cullDraw( state );
state.setChannel( 0 );
if( program != VertexBufferState::INVALID )
glUseProgram( 0 );
const InitData& initData =
static_cast<Config*>( getConfig( ))->getInitData();
if( !initData.useROI( ))
{
declareRegion( getPixelViewport( ));
return;
}
#ifndef NDEBUG // region border
const eq::PixelViewport& pvp = getPixelViewport();
const eq::PixelViewport& region = getRegion();
glMatrixMode( GL_PROJECTION );
glLoadIdentity();
glOrtho( 0.f, pvp.w, 0.f, pvp.h, -1.f, 1.f );
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
const eq::View* currentView = getView();
if( currentView && frameData.getCurrentViewID() == currentView->getID( ))
glColor3f( 0.f, 0.f, 0.f );
else
glColor3f( 1.f, 1.f, 1.f );
glNormal3f( 0.f, 0.f, 1.f );
const eq::Vector4f rect( float( region.x ) + .5f, float( region.y ) + .5f,
float( region.getXEnd( )) - .5f,
float( region.getYEnd( )) - .5f );
glBegin( GL_LINE_LOOP ); {
glVertex3f( rect[0], rect[1], -.99f );
glVertex3f( rect[2], rect[1], -.99f );
glVertex3f( rect[2], rect[3], -.99f );
glVertex3f( rect[0], rect[3], -.99f );
} glEnd();
#endif
}
/** Create output workspace
* @brief ConvertCWSDExpToMomentum::createExperimentMDWorkspace
* @return
*/
API::IMDEventWorkspace_sptr ConvertCWSDMDtoHKL::createHKLMDWorkspace(
const std::vector<Kernel::V3D> &vec_hkl,
const std::vector<signal_t> &vec_signal,
const std::vector<detid_t> &vec_detid) {
// Check
if (vec_hkl.size() != vec_signal.size() ||
vec_signal.size() != vec_detid.size())
throw std::invalid_argument("Input vectors for HKL, signal and detector "
"IDs are of different size!");
// Create workspace in Q_sample with dimenion as 3
size_t nDimension = 3;
IMDEventWorkspace_sptr mdws =
MDEventFactory::CreateMDWorkspace(nDimension, "MDEvent");
// Extract Dimensions and add to the output workspace.
std::vector<std::string> vec_ID(3);
vec_ID[0] = "H";
vec_ID[1] = "K";
vec_ID[2] = "L";
std::vector<std::string> dimensionNames(3);
dimensionNames[0] = "H";
dimensionNames[1] = "K";
dimensionNames[2] = "L";
Mantid::Kernel::SpecialCoordinateSystem coordinateSystem =
Mantid::Kernel::HKL;
// Add dimensions
std::vector<double> m_extentMins(3);
std::vector<double> m_extentMaxs(3);
std::vector<size_t> m_numBins(3, 100);
getRange(vec_hkl, m_extentMins, m_extentMaxs);
// Get MDFrame of HKL type with RLU
auto unitFactory = makeMDUnitFactoryChain();
auto unit = unitFactory->create(Units::Symbol::RLU.ascii());
Mantid::Geometry::HKL frame(unit);
for (size_t i = 0; i < nDimension; ++i) {
std::string id = vec_ID[i];
std::string name = dimensionNames[i];
// std::string units = "A^-1";
mdws->addDimension(
Geometry::MDHistoDimension_sptr(new Geometry::MDHistoDimension(
id, name, frame, static_cast<coord_t>(m_extentMins[i]),
static_cast<coord_t>(m_extentMaxs[i]), m_numBins[i])));
}
// Set coordinate system
mdws->setCoordinateSystem(coordinateSystem);
// Creates a new instance of the MDEventInserter to output workspace
MDEventWorkspace<MDEvent<3>, 3>::sptr mdws_mdevt_3 =
boost::dynamic_pointer_cast<MDEventWorkspace<MDEvent<3>, 3>>(mdws);
MDEventInserter<MDEventWorkspace<MDEvent<3>, 3>::sptr> inserter(mdws_mdevt_3);
// Go though each spectrum to conver to MDEvent
for (size_t iq = 0; iq < vec_hkl.size(); ++iq) {
Kernel::V3D hkl = vec_hkl[iq];
std::vector<Mantid::coord_t> millerindex(3);
millerindex[0] = static_cast<float>(hkl.X());
millerindex[1] = static_cast<float>(hkl.Y());
millerindex[2] = static_cast<float>(hkl.Z());
signal_t signal = vec_signal[iq];
signal_t error = std::sqrt(signal);
uint16_t runnumber = 1;
detid_t detid = vec_detid[iq];
// Insert
inserter.insertMDEvent(
static_cast<float>(signal), static_cast<float>(error * error),
static_cast<uint16_t>(runnumber), detid, millerindex.data());
}
return mdws;
}
Array<T> getAll (void) const { return getRange(0, getSize()); }
static long scaleVolumeValueToHardware(float value, long min, long max) {
return (long)(value * getRange(min, max) + min);
}
// =============================================================================
int Epetra_NumPyMultiVector::getRangeLen(PyObject * range,
const Epetra_MultiVector & source)
{
if (!tmp_range) getRange(range, source);
return PyArray_Size((PyObject*)tmp_range);
}
uint16_t SRF02::getFakeRangeIn(void) {
return(getRange(0x57));
}
uint16_t SRF02::getRealRangeIn(void) {
return(getRange(0x50));
}
void AnalysisBase::getTDCBins(TProfile* h, float& lo, float& hi){
getRange(h,lo,hi,0.97,1);
lo = lo - 1.0 + 0.5;
hi = hi + 0.5;
return;
}
void AnalysisBase::findBeamRegionAndAlign(int iPass){
cout << "==================================================================" << endl;
cout << "findBeamRegionAndAlign(): Determining Fiducial Region, Pass = "******"==================================================================" << endl;
double dxWindow = dxWin;
if(iPass == 1) dxWindow = 1000.0;
if(iPass == 2) dxWindow = 1.0;
TH1F* hthx = new TH1F("hthx","#theta_{X}",1000,-5.0,5.0);
TH1F* hthy = new TH1F("hthy","#theta_{Y}",1000,-5.0,5.0);
TH1F* hx = new TH1F("hx","Y position of matched cluster",800,-40.0,40.0);
TH1F* hxdut = new TH1F("hxdut","Y position of matched cluster",800,-40.0,40.0);
TH1F* hs = new TH1F("hs","Strip number of matched cluster",512,0,512.0);
TH1F* hy = new TH1F("hy","Y position of matched cluster",800,-10.0,10.0);
TH1F* hw = new TH1F("hw","#DeltaX",20000,-100.0,100.0);
TH1F* hn = new TH1F("hn","#DeltaX",4000,-2.0,2.0);
TH1F* hnn = new TH1F("hnn","#DeltaX",400,-0.2,0.2);
TH2F* hxy = new TH2F("hxy","Y_{trk} vs X_{trk}, with cluster",640,-8,8.0,640,-8,8);
TProfile *ht = new TProfile("ht","Cluster Charge vs TDC time",12,0,12,100,1000);
TProfile *hzrot = new TProfile("hzrot","#DeltaX vs Y_{trk} at DUT",1600,-8,8,-1.0,1.0);
TH2F* hca = new TH2F("hca","Y_{trk} vs X_{trk}, with found cluster",160,-8,8.0,320,-8,8);
TH2F* hcf = new TH2F("hcf","Y_{trk} vs X_{trk}, with found cluster",160,-8,8.0,320,-8,8);
hca->Sumw2();
hcf->Sumw2();
int istrip;
double nomStrip=0, detStrip = 0;
Long64_t nbytes = 0, nb = 0;
Int_t nentries = fChain->GetEntriesFast();
for (Long64_t jentry=0; jentry<max(nentries,200000);jentry++) {
Long64_t ientry = LoadTree(jentry);
//if(jentry%1000==0) cout << "At entry = " << jentry << endl;
if (ientry < 0) break;
nb = fChain->GetEntry(jentry); nbytes += nb;
if(n_tp3_tracks > 1) continue;
for(int k=0; k<n_tp3_tracks; k++){
bool goodTime = (clustersTDC >= tdcLo && clustersTDC < tdcHi);
goodTime = clustersTDC>1.0;
if(!goodTime) continue;
double x_trk = vec_trk_tx->at(k)*z_DUT+vec_trk_x->at(k);
double y_trk = vec_trk_ty->at(k)*z_DUT+vec_trk_y->at(k);
transformTrackToDUTFrame(k, x_trk, y_trk, nomStrip, detStrip);
double tx = 1000*vec_trk_tx->at(k);
double ty = 1000*vec_trk_ty->at(k);
double x_trk0 = x_trk;
for(int j=0; j<min(clusterNumberPerEvent,10); j++){
if(clustersPosition[j] < 0.1) continue;
if(polarity*clustersCharge[j] < kClusterChargeMin) continue;
bool goodHit = (clustersPosition[j]>iLo && clustersPosition[j]<iHi);
istrip = clustersSeedPosition[j];
if(badStrips[istrip]==0) continue; // exclude bad strips
double x_dut = getDUTHitPosition(j);
x_trk = x_trk0;
double dx = x_dut - x_trk;
hn->Fill(dx);
hnn->Fill(dx);
hca->Fill(x_trk,y_trk);
if(fabs(dx)<dxWindow || iPass==1) {
if(goodHit) {
hx->Fill(x_trk);
hxdut->Fill(x_dut);
hs->Fill(clustersPosition[j]);
hy->Fill(y_trk);
hthx->Fill(tx);
hthy->Fill(ty);
hw->Fill(dx);
hxy->Fill(x_trk,y_trk);
ht->Fill(clustersTDC+0.1,polarity*clustersCharge[j]);
hzrot->Fill(y_trk,dx);
hcf->Fill(x_trk,y_trk);
}
}
}
}
}
//hnn->Draw();
if(iPass==4) {
findCutoutRegion(hcf);
}else {
float xmin=0,xmax=0,ymin=0,ymax=0,txmin=0,txmax=0,tymin=0,tymax=0;
getRange(hthx,txmin,txmax,0.05,2);
getRange(hthy,tymin,tymax,0.05,2);
//getRange(hx,xmin,xmax,0.05,2);
getRange(hy,ymin,ymax,0.2,2);
// Use strip numbers to get xMin and xMax, since dead strips make holes in xpos plot
xmin = getEdgePosition(iHi);
xmax = getEdgePosition(iLo);
xMin = xmin;
xMax = xmax;
yMin = ymin;
yMax = ymax;
txMin = txmin;
txMax = txmax;
tyMin = tymin;
tyMax = tymax;
//
float xlo = 0, xhi=0;
if(iPass==1) getRange(hw,xlo,xhi,0.1,1);
if(iPass==2) getRange(hn,xlo,xhi,0.1,1);
if(iPass==3) getRange(hn,xlo,xhi,0.1,1);
if(iPass>3) getRange(hnn,xlo,xhi,0.2,1);
double XOFF = (xhi + xlo)/2.0;
xOff = xOff - XOFF;
double x_ave = (xMax + xMin)/2.0;
double y_ave = (yMax + yMin)/2.0;
xGloOff = xGloOff - x_ave;
if(iPass<=4) yGloOff = yGloOff - y_ave;
// Check/correct for z rotation
if(iPass==3 && correctForZRotation){
cout << "Checking for z-rotation" << endl;
TF1* p1 = new TF1("p1","[0]+[1]*x",yMin,yMax);
p1->SetParameters(0.0,0.0001);
hzrot->Fit(p1,"0R");
double rz = p1->GetParameter(1);
cout << "=======================================================================" << endl;
cout << "==> Updating z rotation angle from " << Rz << " to " << Rz-rz << " mrad" << endl;
Rz = Rz - rz;
delete p1;
}
float lo = 0, hi = 0;
getTDCBins(ht,lo,hi);
tdcLo = lo;
tdcHi = hi;
cout << "=================================================================" << endl;
cout << "====> TDC Range updated to be from " << tdcLo << " -- " << tdcHi << std::endl;
cout << "=================================================================" << endl;
cout << "====> Fiducial regions, xLo, xHi (Strip numbers) = " << iLo << " " << iHi << endl;
cout << "====> Fiducial regions, xLo, xHi (pos in mm) = " << xMin << " " << xMax << " mm " << endl;
cout << "====> Fiducial regions, yLo, yHi (pos in mm) = " << yMin << " " << yMax << " mm " << endl;
cout << "====> Fiducial regions, thxLo, thxHi (pos in mrad) = " << txMin << " " << txMax << " mrad" << endl;
cout << "====> Fiducial regions, thyLo, thxHi (pos in mrad) = " << tyMin << " " << tyMax << " mrad" << endl;
cout << "=================================================================" << endl;
cout << "====> Shifting sensor by dX = " << XOFF << " mm " << ", new xOff = " << xOff << endl;
cout << "====> Global X, Y shifts: " << x_ave << " " << y_ave << endl;
cout << "====> New global x,y = " << xGloOff << " " << yGloOff << endl;
}
//if(iPass==1) hw->Draw(); // for debugging
//if(iPass==2) hy->Draw();
//return;
delete hxdut;
delete hthx;
delete hthy;
delete hx;
delete hy;
delete hxy;
delete hw;
delete hn;
delete hnn;
delete hs;
delete ht;
delete hzrot;
delete hcf;
delete hca;
return;
}
void
CGnuPlotStyleRadar::
draw2D(CGnuPlotPlot *plot, CGnuPlotRenderer *renderer)
{
CGnuPlotRadarStyleValue *value =
CGnuPlotStyleValueMgrInst->getValue<CGnuPlotRadarStyleValue>(plot);
if (! value) {
value = plot->app()->device()->createRadarStyleValue(plot);
CGnuPlotStyleValueMgrInst->setValue<CGnuPlotRadarStyleValue>(plot, value);
}
//---
const CBBox2D &bbox = plot->bbox2D();
CPoint2D pc = bbox.getCenter();
double r = bbox.getWidth()/2;
int np = -1;
for (const auto &point : plot->getPoints2D()) {
np = std::min(np < 0 ? INT_MAX : np, point.getNumValues());
}
if (np < 3)
return;
//double pw = renderer->pixelWidthToWindowWidth (1);
//double ph = renderer->pixelHeightToWindowHeight(1);
CGnuPlotGroup *group = plot->group();
const CGnuPlotKeyData &keyData = plot->keyData();
const CGnuPlotAxisData &xaxis = group->xaxis(1);
const CGnuPlotKey::Columns &columns = keyData.columns();
double da = 360/np;
std::vector<CPoint2D> points = radarPoints(value->angleStart(), pc, r, np);
double v = getRange(plot);
//---
// draw border
renderer->drawPolygon(points, value->borderColor(), value->borderWidth(), value->borderDash());
//---
// draw column labels (how determine indices)
{
double a = value->angleStart();
for (int i = 1; i <= np && i < int(columns.size()); ++i) {
CPoint2D p = radarPoint(pc, r, a);
CHAlignType halign = CHALIGN_TYPE_CENTER;
CVAlignType valign = CVALIGN_TYPE_CENTER;
double dx = 0;
double dy = 0;
if (p.x < pc.x - v/2) {
halign = CHALIGN_TYPE_RIGHT;
dx = -8;
}
else if (p.x > pc.x + v/2) {
halign = CHALIGN_TYPE_LEFT;
dx = 8;
}
if (p.y < pc.y - v/2) {
valign = CVALIGN_TYPE_TOP;
dy = 8;
}
else if (p.y > pc.y + v/2) {
valign = CVALIGN_TYPE_BOTTOM;
dy = -8;
}
CRGBA tc = CRGBA(0,0,0);
renderer->drawHAlignedText(p, HAlignPos(halign, dx), VAlignPos(valign, dy), columns[i], tc),
a -= da;
}
}
//---
// draw axis if needed
if (xaxis.isDisplayed()) {
CRGBA ac = value->axisColor();
ac.setAlpha(value->axisAlpha());
double dr = 0.1;
double ra = 0.1;
while (ra < v) {
std::vector<CPoint2D> points1 = radarPoints(value->angleStart(), pc, ra, np);
renderer->drawPolygon(points1, ac, value->axisWidth(), value->axisDash());
ra += dr;
}
for (const auto &p : points)
renderer->drawLine(p, pc, ac, value->axisWidth(), value->axisDash());
}
//---
bool cache = false;
if (! renderer->isPseudo() && plot->isCacheActive()) {
plot->updatePolygonCacheSize(plot->numPoints2D());
cache = true;
}
int pi = 0;
for (const auto &point : plot->getPoints2D()) {
std::vector<CPoint2D> points1;
double a = value->angleStart();
for (int i = 0; i < np; ++i) {
double v1;
if (! point.getValue(i + 1, v1))
continue;
CPoint2D p = radarPoint(pc, v1, a);
points1.push_back(p);
a -= da;
}
CRGBA lc, fc;
getPointsColor(value, pi + 1, lc, fc);
if (cache) {
//std::string label = (pi < int(columns.size()) ? columns[pi] : "");
std::string label = xaxis.iticLabel(pi);
auto polygon = plot->polygonObjects()[pi];
polygon->setPoints(points1);
polygon->setTipText(label);
if (! polygon->testAndSetUsed()) {
CGnuPlotFillP fill (polygon->fill ()->dup());
CGnuPlotStrokeP stroke(polygon->stroke()->dup());
fill->setColor(fc);
fill->setType (CGnuPlotTypes::FillType::SOLID);
stroke->setColor (lc);
stroke->setWidth (value->strokeWidth());
stroke->setLineDash(value->strokeDash());
polygon->setFill (fill );
polygon->setStroke(stroke);
}
}
else {
renderer->fillPolygon(points1, fc);
renderer->drawPolygon(points1, lc, value->strokeWidth(), value->strokeDash());
}
++pi;
}
if (cache) {
for (const auto &polygon : plot->polygonObjects())
polygon->draw(renderer);
}
}
void Channel::frameAssemble( const eq::uint128_t& frameID )
{
const bool composeOnly = (_drawRange == eq::Range::ALL);
eq::FrameData* data = _frame.getData();
_startAssemble();
const eq::Frames& frames = getInputFrames();
eq::PixelViewport coveredPVP;
eq::Frames dbFrames;
eq::Zoom zoom( eq::Zoom::NONE );
// Make sure all frames are ready and gather some information on them
for( eq::Frames::const_iterator i = frames.begin();
i != frames.end(); ++i )
{
eq::Frame* frame = *i;
{
eq::ChannelStatistics stat( eq::Statistic::CHANNEL_FRAME_WAIT_READY,
this );
frame->waitReady( );
}
const eq::Range& range = frame->getRange();
if( range == eq::Range::ALL ) // 2D frame, assemble directly
eq::Compositor::assembleFrame( frame, this );
else
{
dbFrames.push_back( frame );
zoom = frame->getZoom();
_expandPVP( coveredPVP, frame->getImages(), frame->getOffset() );
}
}
coveredPVP.intersect( getPixelViewport( ));
if( dbFrames.empty( ))
{
resetAssemblyState();
return;
}
// calculate correct frames sequence
if( !composeOnly && coveredPVP.hasArea( ))
{
_frame.clear();
data->setRange( _drawRange );
dbFrames.push_back( &_frame );
}
_orderFrames( dbFrames );
// check if current frame is in proper position, read back if not
if( !composeOnly )
{
if( _bgColor == eq::Vector3f::ZERO && dbFrames.front() == &_frame )
dbFrames.erase( dbFrames.begin( ));
else if( coveredPVP.hasArea())
{
eq::Window::ObjectManager* glObjects = getObjectManager();
_frame.setOffset( eq::Vector2i( 0, 0 ));
_frame.setZoom( zoom );
data->setPixelViewport( coveredPVP );
_frame.readback( glObjects, getDrawableConfig( ));
clearViewport( coveredPVP );
// offset for assembly
_frame.setOffset( eq::Vector2i( coveredPVP.x, coveredPVP.y ));
}
}
// blend DB frames in order
try
{
eq::Compositor::assembleFramesSorted( dbFrames, this, 0,
true /*blendAlpha*/ );
}
catch( eq::Exception e )
{
EQWARN << e << std::endl;
}
resetAssemblyState();
// Update range
_drawRange = getRange();
}
void MeshCommand::setLightUniforms()
{
Director *director = Director::getInstance();
auto scene = director->getRunningScene();
const auto& conf = Configuration::getInstance();
int maxDirLight = conf->getMaxSupportDirLightInShader();
int maxPointLight = conf->getMaxSupportPointLightInShader();
int maxSpotLight = conf->getMaxSupportSpotLightInShader();
auto &lights = scene->getLights();
auto glProgram = _glProgramState->getGLProgram();
if (_glProgramState->getVertexAttribsFlags() & (1 << GLProgram::VERTEX_ATTRIB_NORMAL))
{
resetLightUniformValues();
GLint enabledDirLightNum = 0;
GLint enabledPointLightNum = 0;
GLint enabledSpotLightNum = 0;
Vec3 ambientColor;
for (const auto& light : lights)
{
bool useLight = light->isEnabled() && ((unsigned int)light->getLightFlag() & _lightMask);
if (useLight)
{
float intensity = light->getIntensity();
switch (light->getLightType())
{
case LightType::DIRECTIONAL:
{
if(enabledDirLightNum < maxDirLight)
{
auto dirLight = static_cast<DirectionLight *>(light);
Vec3 dir = dirLight->getDirectionInWorld();
dir.normalize();
const Color3B &col = dirLight->getDisplayedColor();
s_dirLightUniformColorValues[enabledDirLightNum] = Vec3(col.r / 255.0f * intensity, col.g / 255.0f * intensity, col.b / 255.0f * intensity);
s_dirLightUniformDirValues[enabledDirLightNum] = dir;
++enabledDirLightNum;
}
}
break;
case LightType::POINT:
{
if(enabledPointLightNum < maxPointLight)
{
auto pointLight = static_cast<PointLight *>(light);
Mat4 mat= pointLight->getNodeToWorldTransform();
const Color3B &col = pointLight->getDisplayedColor();
s_pointLightUniformColorValues[enabledPointLightNum] = Vec3(col.r / 255.0f * intensity, col.g / 255.0f * intensity, col.b / 255.0f * intensity);
s_pointLightUniformPositionValues[enabledPointLightNum] = Vec3(mat.m[12], mat.m[13], mat.m[14]);
s_pointLightUniformRangeInverseValues[enabledPointLightNum] = 1.0f / pointLight->getRange();
++enabledPointLightNum;
}
}
break;
case LightType::SPOT:
{
if(enabledSpotLightNum < maxSpotLight)
{
auto spotLight = static_cast<SpotLight *>(light);
Vec3 dir = spotLight->getDirectionInWorld();
dir.normalize();
Mat4 mat= light->getNodeToWorldTransform();
const Color3B &col = spotLight->getDisplayedColor();
s_spotLightUniformColorValues[enabledSpotLightNum] = Vec3(col.r / 255.0f * intensity, col.g / 255.0f * intensity, col.b / 255.0f * intensity);
s_spotLightUniformPositionValues[enabledSpotLightNum] = Vec3(mat.m[12], mat.m[13], mat.m[14]);
s_spotLightUniformDirValues[enabledSpotLightNum] = dir;
s_spotLightUniformInnerAngleCosValues[enabledSpotLightNum] = spotLight->getCosInnerAngle();
s_spotLightUniformOuterAngleCosValues[enabledSpotLightNum] = spotLight->getCosOuterAngle();
s_spotLightUniformRangeInverseValues[enabledSpotLightNum] = 1.0f / spotLight->getRange();
++enabledSpotLightNum;
}
}
break;
case LightType::AMBIENT:
{
auto ambLight = static_cast<AmbientLight *>(light);
const Color3B &col = ambLight->getDisplayedColor();
ambientColor += Vec3(col.r / 255.0f * intensity, col.g / 255.0f * intensity, col.b / 255.0f * intensity);
}
break;
default:
break;
}
}
}
if (0 < maxDirLight)
{
glProgram->setUniformLocationWith3fv((GLint)glProgram->getUniformLocationForName(s_dirLightUniformColorName), (GLfloat*)(&s_dirLightUniformColorValues[0]), (unsigned int)s_dirLightUniformColorValues.size());
glProgram->setUniformLocationWith3fv((GLint)glProgram->getUniformLocationForName(s_dirLightUniformDirName), (GLfloat*)(&s_dirLightUniformDirValues[0]), (unsigned int)s_dirLightUniformDirValues.size());
}
if (0 < maxPointLight)
{
glProgram->setUniformLocationWith3fv((GLint)glProgram->getUniformLocationForName(s_pointLightUniformColorName), (GLfloat*)(&s_pointLightUniformColorValues[0]), (unsigned int)s_pointLightUniformColorValues.size());
glProgram->setUniformLocationWith3fv((GLint)glProgram->getUniformLocationForName(s_pointLightUniformPositionName), (GLfloat*)(&s_pointLightUniformPositionValues[0]), (unsigned int)s_pointLightUniformPositionValues.size());
glProgram->setUniformLocationWith1fv((GLint)glProgram->getUniformLocationForName(s_pointLightUniformRangeInverseName), (GLfloat*)(&s_pointLightUniformRangeInverseValues[0]), (unsigned int)s_pointLightUniformRangeInverseValues.size());
}
if (0 < maxSpotLight)
{
glProgram->setUniformLocationWith3fv((GLint)glProgram->getUniformLocationForName(s_spotLightUniformColorName), (GLfloat*)(&s_spotLightUniformColorValues[0]), (unsigned int)s_spotLightUniformColorValues.size());
glProgram->setUniformLocationWith3fv((GLint)glProgram->getUniformLocationForName(s_spotLightUniformPositionName), (GLfloat*)(&s_spotLightUniformPositionValues[0]), (unsigned int)s_spotLightUniformPositionValues.size());
glProgram->setUniformLocationWith3fv((GLint)glProgram->getUniformLocationForName(s_spotLightUniformDirName), (GLfloat*)(&s_spotLightUniformDirValues[0]), (unsigned int)s_spotLightUniformDirValues.size());
glProgram->setUniformLocationWith1fv((GLint)glProgram->getUniformLocationForName(s_spotLightUniformInnerAngleCosName), (GLfloat*)(&s_spotLightUniformInnerAngleCosValues[0]), (unsigned int)s_spotLightUniformInnerAngleCosValues.size());
glProgram->setUniformLocationWith1fv((GLint)glProgram->getUniformLocationForName(s_spotLightUniformOuterAngleCosName), (GLfloat*)(&s_spotLightUniformOuterAngleCosValues[0]), (unsigned int)s_spotLightUniformOuterAngleCosValues.size());
glProgram->setUniformLocationWith1fv((GLint)glProgram->getUniformLocationForName(s_spotLightUniformRangeInverseName), (GLfloat*)(&s_spotLightUniformRangeInverseValues[0]), (unsigned int)s_spotLightUniformRangeInverseValues.size());
}
glProgram->setUniformLocationWith3f(glProgram->getUniformLocationForName(s_ambientLightUniformColorName), ambientColor.x, ambientColor.y, ambientColor.z);
}
else // normal does not exist
{
Vec3 ambient(0.0f, 0.0f, 0.0f);
bool hasAmbient = false;
for (const auto& light : lights)
{
if (light->getLightType() == LightType::AMBIENT)
{
bool useLight = light->isEnabled() && ((unsigned int)light->getLightFlag() & _lightMask);
if (useLight)
{
hasAmbient = true;
const Color3B &col = light->getDisplayedColor();
ambient.x += col.r * light->getIntensity();
ambient.y += col.g * light->getIntensity();
ambient.z += col.b * light->getIntensity();
}
}
}
if (hasAmbient)
{
ambient.x /= 255.f; ambient.y /= 255.f; ambient.z /= 255.f;
}
glProgram->setUniformLocationWith4f(glProgram->getUniformLocationForName("u_color"), _displayColor.x * ambient.x, _displayColor.y * ambient.y, _displayColor.z * ambient.z, _displayColor.w);
}
}
/**
* Copies the contents of fromMsg to the contents of toMsg. Both must be
* instances of LinkMessage. The toLink object must be an instance of Link.
* It's filled in if the contents of fromMsg are a Link. Returns KNI_TRUE if
* successful, otherwise KNI_FALSE.
*/
static jboolean
copy(jobject fromMsg, jobject toMsg, jobject toLink) {
jboolean retval;
KNI_StartHandles(6);
KNI_DeclareHandle(byteArrayClass);
KNI_DeclareHandle(stringClass);
KNI_DeclareHandle(linkClass);
KNI_DeclareHandle(fromContents);
KNI_DeclareHandle(newString);
KNI_DeclareHandle(newByteArray);
KNI_FindClass("[B", byteArrayClass);
KNI_FindClass("java/lang/String", stringClass);
KNI_FindClass("com/sun/midp/links/Link", linkClass);
getContents(fromMsg, fromContents);
if (KNI_IsInstanceOf(fromContents, byteArrayClass)) {
/* do a byte array copy */
jint fromOffset;
jint fromLength;
getRange(fromMsg, &fromOffset, &fromLength);
SNI_NewArray(SNI_BYTE_ARRAY, fromLength, newByteArray);
if (KNI_IsNullHandle(newByteArray)) {
retval = KNI_FALSE;
} else {
KNI_GetRawArrayRegion(fromContents, fromOffset, fromLength,
SNI_GetRawArrayPointer(newByteArray));
setContents(toMsg, newByteArray);
setRange(toMsg, 0, fromLength);
retval = KNI_TRUE;
}
} else if (KNI_IsInstanceOf(fromContents, stringClass)) {
/* do a string copy */
jchar *buf;
jsize slen = KNI_GetStringLength(fromContents);
SNI_NewArray(SNI_BYTE_ARRAY, slen*sizeof(jchar), newByteArray);
if (KNI_IsNullHandle(newByteArray)) {
retval = KNI_FALSE;
} else {
buf = SNI_GetRawArrayPointer(newByteArray);
KNI_GetStringRegion(fromContents, 0, slen, buf);
KNI_NewString(buf, slen, newString);
setContents(toMsg, newString);
retval = KNI_TRUE;
}
} else if (KNI_IsInstanceOf(fromContents, linkClass)) {
/* copy the link */
rendezvous *rp = getNativePointer(fromContents);
setNativePointer(toLink, rp);
rp_incref(rp);
setContents(toMsg, toLink);
retval = KNI_TRUE;
} else {
retval = KNI_FALSE;
}
KNI_EndHandles();
return retval;
}
void
Quilt::getRange( REAL *from, REAL *to, Flist& slist )
{
getRange( from, to, 0, slist );
}
uint16_t SRF02::getRealRangeUs(void) {
return(getRange(0x52));
}
void ScrollBar::beforeDraw( GfxEngine& painter )
{
if( !isVisible() )
return;
bool needRecalculateSliderParams = (_sliderPos != _lastSliderPos);
if( !(_d->needRecalculateParams || needRecalculateSliderParams) )
return;
if( _d->needRecalculateParams )
{
_d->backgroundRect = getAbsoluteRect();
if( _horizontal )
{
if( _d->upButton && _d->upButton->isVisible() )
_d->backgroundRect.UpperLeftCorner += Point( _d->upButton->getWidth(), 0 );
if( _d->downButton && _d->downButton->isVisible() )
_d->backgroundRect.LowerRightCorner -= Point( _d->downButton->getWidth(), 0 );
}
else
{
if( _d->upButton && _d->upButton->isVisible() )
_d->backgroundRect.UpperLeftCorner += Point( 0, _d->upButton->getHeight() );
if( _d->downButton && _d->downButton->isVisible() )
_d->backgroundRect.LowerRightCorner -= Point( 0, _d->downButton->getHeight() );
}
}
_isSliderHovered = _d->sliderRect.isPointInside( _d->cursorPos );
ElementState st = _dragging && _draggedBySlider
? stPressed
: (_lastSliderHovered ? stHovered : stNormal);
_d->sliderTexture = (st == stPressed) ? _d->sliderPictureDown : _d->sliderPictureUp;
if( needRecalculateSliderParams )
{
_lastSliderPos = _sliderPos;
_d->sliderRect = getAbsoluteRect();
if( !math::isEqual( getRange(), 0.f ) )
{
// recalculate slider rectangle
if( _horizontal )
{
_d->sliderRect.UpperLeftCorner.setX( getScreenLeft() + _lastSliderPos - _drawLenght/2 );
if( _d->upButton && _d->upButton->isVisible() )
_d->sliderRect.UpperLeftCorner += Point( _d->upButton->getWidth(), 0 );
_d->sliderRect.LowerRightCorner.setX( _d->sliderRect.UpperLeftCorner.getX() + _drawLenght );
}
else
{
_d->sliderRect.UpperLeftCorner.setY( getScreenTop() + _lastSliderPos - _drawLenght/2 );
if( _d->upButton && _d->upButton->isVisible() )
_d->sliderRect.UpperLeftCorner += Point( 0, _d->upButton->getHeight() );
_d->sliderRect.LowerRightCorner.setY( _d->sliderRect.UpperLeftCorner.getY() + _drawLenght );
}
}
}
Widget::beforeDraw( painter );
}
uint16_t SRF02::getFakeRangeCm(void) {
return(getRange(0x56));
}
task main()
{
// pose ===========================================================
float pose[3];
float* pose_ptr = &pose;
float x=0,y=0,phi=0;
pose[0]=x;pose[1]=y;pose[2]=phi;
// speeds =========================================================
float v=CRUISE, w=0;
float w_look = 0.0;
float w_head = 0.0;
// logObstacle behavior ===========================================
// obstacle log
float obstacles_xy[N_ANGLES][2];
for(int i=0; i<N_ANGLES; i++){
obstacles_xy[i][0]=10.0;//x
obstacles_xy[i][1]=10.0;//y
}
float* obstacle_ptr;
float temp_o_x,temp_o_y;
//ranging
float range;
// head tracking
float halfViewingAngle = headCalibrate();
float headAngle = 0;
float angleDelta = 2.0*halfViewingAngle/(float)N_ANGLES;
float headAngleWorld = 0.0;
float prevHeadAngleWorld = headAngleWorld-2.0*angleDelta;
resetAngleCounter(N_ANGLES-1,-1);
// collision =====================================================
bool collision_flag = false;
//more state variables for pose ===================================
float ticks[2];
float* ticks_ptr;
float prevTicks[2];
prevTicks[0]=0;prevTicks[1]=0;
resetWheelEncoders();
while(1){
// update state ================================================================================================
ticks_ptr = readWheelEncoders();
ticks[0]=ticks_ptr[0];ticks[1]=ticks_ptr[1];
pose_ptr = update_odometry(pose,ticks,prevTicks);
pose[0]=pose_ptr[0];pose[1]=pose_ptr[1];pose[2]=pose_ptr[2];
x=pose_ptr[0];y=pose_ptr[1];phi=pose_ptr[2];
//store for next pass
prevTicks[0] = ticks[0];
prevTicks[1] = ticks[1];
// end update state ============================================================================================
// logObstacle behavior ========================================================================================
headAngle = getHeadAngle();
range = getRange();
headAngleWorld = headAngle-halfViewingAngle+phi;
if(abs(headAngleWorld - prevHeadAngleWorld) >= angleDelta){
prevHeadAngleWorld = headAngleWorld;
obstacle_ptr = getObstaclePosition(headAngleWorld,range,pose);
temp_o_x = obstacle_ptr[0];temp_o_y = obstacle_ptr[1];
obstacles_xy[AngleCounter][0] = temp_o_x;
obstacles_xy[AngleCounter][1] = temp_o_y;
incrementAngleCounter();
}
// end logObstacle behavior ====================================================================================
// collide behavior ============================================================================================
collision_flag = checkForCollisions(obstacles_xy,pose);
// end collide behavior ========================================================================================
// send actuator commands ======================================================================================
v = CRUISE;
if(collision_flag && v>0.0){
v = 0.0;
}
set_motor_speeds(v,0.0);
//worked before the angle was limited
//if(collision_flag)v
// //halt();
// //set_motor_speeds(0.0,0.0);
// set_motor_speeds(0.0,5.0);
//}else{
// set_motor_speeds(v,0.0);
//}
w_look = lookBackAndForth(w_look);
w_head = w_look;
headRotate(w_head);
// end send actuator commands ==================================================================================
}
}
uint16_t SRF02::getFakeRangeUs(void) {
return(getRange(0x58));
}
void CTestSliderWithTransformationDlg::setSliderType(IntervalScale type) {
m_slider.setTransformation(getRange(), 1000, type);
showSliderValue();
}
static float scaleVolumeValueToNormalized(long value, long min, long max) {
return (float) (value - min) / getRange(min, max);
}
//------------------------------------------------------------------------
CMouseEventResult CSlider::onMouseMoved (CPoint& where, const CButtonState& _buttons)
{
if (isEditing ())
{
CButtonState buttons (_buttons);
if (kAlwaysUseZoomFactor)
buttons |= kZoomModifier;
if (buttons & kLButton)
{
if (kAlwaysUseZoomFactor)
{
CCoord distance = fabs ((style & kHorizontal) ? where.y - mouseStartPoint.y : where.x - mouseStartPoint.x);
float newZoomFactor = 1.f;
if (distance > ((style & kHorizontal) ? getHeight () : getWidth ()))
{
newZoomFactor = (float)(distance / ((style & kHorizontal) ? getHeight () : getWidth ()));
newZoomFactor = static_cast<int32_t>(newZoomFactor * 10.f) / 10.f;
}
if (zoomFactor != newZoomFactor)
{
zoomFactor = newZoomFactor;
oldVal = (value - getMin ()) / getRange ();
delta = calculateDelta (where);
}
}
if (oldVal == getMin () - 1)
oldVal = (value - getMin ()) / getRange ();
if ((oldButton != buttons) && (buttons & kZoomModifier))
{
oldVal = (value - getMin ()) / getRange ();
oldButton = buttons;
}
else if (!(buttons & kZoomModifier))
oldVal = (value - getMin ()) / getRange ();
float normValue;
if (style & kHorizontal)
normValue = (float)(where.x - delta) / (float)rangeHandle;
else
normValue = (float)(where.y - delta) / (float)rangeHandle;
if (style & kRight || style & kBottom)
normValue = 1.f - normValue;
if (buttons & kZoomModifier)
normValue = oldVal + ((normValue - oldVal) / zoomFactor);
setValueNormalized (normValue);
if (isDirty ())
{
valueChanged ();
invalid ();
}
}
return kMouseEventHandled;
}
return kMouseEventNotHandled;
}
Action::ResultE LODSetupGraphOp::traverseEnter(Node * const node)
{
if(node->getCore()->getType().isDerivedFrom(DistanceLOD::getClassType()))
{
return Action::Skip;
}
// clear out the old sets
_mSets.clear();
UInt32 numChildren = node->getNChildren();
// check node's children for LOD name tags.
UInt32 i = 0;
UInt32 j = 0;
for(i = 0; i < numChildren; ++i)
{
const Char8 *namePtr = OSG::getName(node->getChild(i));
if(namePtr != NULL)
{
std::string curNodeName(namePtr );
size_t nameSize (curNodeName.size());
for(j = 0; j < _mLODs.size(); ++j)
{
// we only check for the tags at the end of the strings
size_t searchLoc =
(nameSize > _mLODs[j].mTag.size()) ?
(nameSize - _mLODs[j].mTag.size()) : 0;
size_t loc = curNodeName.find(_mLODs[j].mTag, searchLoc);
if(loc != std::string::npos)
{
std::string baseName(curNodeName);
baseName.erase(loc, _mLODs[j].mTag.size());
bool createNewSet = true;
for(UInt32 k = 0; k < _mSets.size(); ++k)
{
if(baseName.compare(_mSets[k].mBaseName) == 0)
{
_mSets[k].addLODPair(_mLODs[j].mLOD,
node->getChild(i));
createNewSet = false;
break;
}
}
if(createNewSet == true)
{
LODSet newSet;
newSet.mBaseName = baseName;
newSet.addLODPair(_mLODs[j].mLOD, node->getChild(i));
_mSets.push_back(newSet);
break;
}
}
}// end for(_mLODs.size())
} //end if(namePtr != NULL)
} // end for(numChildren)
// now we add as many LODs as we can
int madeNow = 0;
if(_mSets.size() > 0)
{
for(i = 0; i < _mSets.size(); ++i)
{
if(_mSets[i].mLODPairs.size() > 1)
{
DistanceLODRecPtr TheLODCore = DistanceLOD::create();
MFReal32 *ranges = TheLODCore->editMFRange();
NodeRecPtr newLODNode = Node::create();
newLODNode->setCore(TheLODCore);
// also set the name of the node now
OSG::setName(newLODNode, _mSets[i].mBaseName + "_LODNode");
node->addChild(newLODNode);
bool centerIsSet = false;
for(j = 0; j < _mSets[i].mLODPairs.size(); ++j)
{
LODPair cur = _mSets[i].mLODPairs[j];
if((cur.first != -1 ) &&
(cur.second != NULL) &&
(getRange(cur.first) > 0.0f) )
{
ranges ->push_back(getRange(cur.first));
newLODNode->addChild (cur.second );
if(!centerIsSet)
{
Pnt3f volCenter;
cur.second->getVolume().getCenter(volCenter);
TheLODCore->setCenter(volCenter);
centerIsSet = true;
}
madeNow++;
}
}
}
}
if(madeNow > 0)
{
_totalNumMade += madeNow;
return Action::Skip;
}
}
return Action::Continue;
}
void ARMarcato::PrintName(std::ostream &os) const
{
os << "\\marcato";
if (getRange()) os << "(";
}
bool Info::isAnInt() const
{
return constant.getGVNValue() != nullptr || getRange().isValid();
}
/**
* Zeichen-Callback.
* Loescht die Buffer, ruft das Zeichnen der Szene auf und tauscht den Front-
* und Backbuffer.
*/
static void
cbDisplay (void)
{
int toX = G_fullScreen ? G_Width : G_Width/2,
toZ = G_fullScreen ? G_Height : G_Height/2;
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glClearColor(0.0, 1.0, 1.0, 0.0);
glClearDepth(1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
if (!getHelpStatus()) {
/*==================================================================*/
/* Textur mit Kamera-Perspektive */
/*==================================================================*/
drawSceneToTexture(G_fboCam, getCameraPosition(0), getCameraPosition(1), getCameraPosition(2), 0.0, 0.0, 0.0);
/*==================================================================*/
/* Terrain mit Ambient Occlusion. */
/*==================================================================*/
glUseProgram(G_ShaderID);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glViewport (0, 0, toX, toZ);
setProjection (1);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt (getCameraPosition(0), getCameraPosition(1), getCameraPosition(2),
0.0, 0.0, 0.0,
0.0, 1.0, 0.0);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, G_TexCamera);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, G_TexCameraDepth);
GLfloat mp[16], mv[16];
glGetFloatv(GL_PROJECTION_MATRIX, mp);
glGetFloatv(GL_MODELVIEW_MATRIX, mv);
glUniformMatrix4fv(glGetUniformLocation(G_ShaderID, "projMatrix"), 1, GL_FALSE, &mp[0]);
glUniformMatrix4fv(glGetUniformLocation(G_ShaderID, "viewMatrix"), 1, GL_FALSE, &mv[0]);
glUniform1i(G_sampler2dLoc, 1);
glUniform1i(G_samplerDepth2dLoc, 0);
GLuint showTexture[] = {G_showTexture};
glUniform1iv(glGetUniformLocation(G_ShaderID, "showTexture"), 1, showTexture);
GLuint screenWidth[] = {G_Width};
glUniform1iv(glGetUniformLocation(G_ShaderID, "screenWidth"), 1, screenWidth);
GLuint screenHeight[] = {G_Height};
glUniform1iv(glGetUniformLocation(G_ShaderID, "screenHeight"), 1, screenHeight);
GLfloat nearPlane[] = {G_NearPlane};
glUniform1fv(glGetUniformLocation(G_ShaderID, "nearPlane"), 1, nearPlane);
GLfloat farPlane[] = {G_FarPlane};
glUniform1fv(glGetUniformLocation(G_ShaderID, "farPlane"), 1, farPlane);
GLuint range[] = {getRange()};
glUniform1iv(glGetUniformLocation(G_ShaderID, "range"), 1, range);
GLuint pixelDistance[] = {getPixelDistance()};
glUniform1iv(glGetUniformLocation(G_ShaderID, "pixelDistance"), 1, pixelDistance);
GLfloat multiplier[] = {getMultiplier()};
glUniform1fv(glGetUniformLocation(G_ShaderID, "multiplier"), 1, multiplier);
glBindBuffer (GL_ARRAY_BUFFER, G_WaterBuffer);
glBufferData (GL_ARRAY_BUFFER, sizeof(*getWaterList())*WORLD_SIZE*WORLD_SIZE, getWaterList(), GL_STATIC_DRAW);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8*sizeof(GLfloat)+1*sizeof(GLint), 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, G_WaterBufferIndex);
/* Wasser. */
glDrawElements(GL_TRIANGLES, WORLD_SIZE*WORLD_SIZE*2*3, GL_UNSIGNED_INT, 0);
glDisableVertexAttribArray(0);
glDisableVertexAttribArray(1);
glUseProgram(0);
drawFPS();
drawAttributes();
} else {
printHelp();
}
/* Alles fertig. */
glutSwapBuffers ();
}
void getAll (Array<T>& res) const { getRange(res, 0, getSize()); }
int android_ioctl_siwpriv(struct net_device *dev,
struct iw_request_info *__info,
struct iw_point *data, char *__extra)
{
char cmd[384]; /* assume that android command will not excess 384 */
char buf[512];
int len = sizeof(cmd)-1;
AR_SOFTC_DEV_T *arPriv = (AR_SOFTC_DEV_T *)ar6k_priv(dev);
AR_SOFTC_STA_T *arSta = &arPriv->arSta;
if (!data->pointer) {
return -EOPNOTSUPP;
}
if (data->length < len) {
len = data->length;
}
if (copy_from_user(cmd, data->pointer, len)) {
return -EIO;
}
cmd[len] = 0;
if (strcasecmp(cmd, "RSSI")==0 || strcasecmp(cmd, "RSSI-APPROX") == 0) {
int rssi = -200;
struct iw_statistics *iwStats;
struct iw_statistics* (*get_iwstats)(struct net_device *);
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19)
get_iwstats = dev->get_wireless_stats;
#else
get_iwstats = dev->wireless_handlers->get_wireless_stats;
#endif
if (get_iwstats && arPriv->arConnected) {
iwStats = get_iwstats(dev);
if (iwStats) {
rssi = iwStats->qual.qual;
if (rssi == 255)
rssi = -200;
else
rssi += (161 - 256);
}
}
len = snprintf(buf, data->length, "SSID rssi %d\n", rssi) + 1;
return (copy_to_user(data->pointer, buf, len)==0) ? len : -1;
} else if (strcasecmp(cmd, "LINKSPEED")==0) {
/* We skip to use SIOCGIWRATE since Android always asked LINKSPEED just after RSSI*/
unsigned int speed_mbps;
if (arPriv->arConnected) {
speed_mbps = arPriv->arTargetStats.tx_unicast_rate / 1000;
} else {
speed_mbps = 1;
}
len = snprintf(buf, data->length, "LinkSpeed %u\n", speed_mbps) + 1;
return (copy_to_user(data->pointer, buf, len)==0) ? len : -1;
} else if (memcmp(cmd, "CSCAN S\x01\x00\x00S\x00", 12)==0) {
int iocmd = SIOCSIWSCAN - SIOCSIWCOMMIT;
const iw_handler setScan = dev->wireless_handlers->standard[iocmd];
A_INT32 home_dwell=0, pas_dwell=0;
A_UCHAR ssid[IW_ESSID_MAX_SIZE+1] = { 0 };
A_INT32 ssid_len = 0;
A_UINT8 index = 1; /* reserve 1st index for wext */
char *scanBuf = cmd + 12;
char *scanEnd = cmd + len;
while ( scanBuf < scanEnd ) {
char *sp = scanBuf;
switch (*scanBuf) {
case 'S': /* SSID section */
if ((scanBuf + 1) < scanEnd && (scanBuf+1+(int)*(scanBuf+1)) < scanEnd ) {
if (ssid_len > 0) {
/* setup the last parsed ssid, reserve 1st index for wext */
if (wmi_probedSsid_cmd(arPriv->arWmi, index+1,
SPECIFIC_SSID_FLAG, ssid_len, ssid) == A_OK) {
++index;
if (arSta->scanSpecificSsid<index) {
arSta->scanSpecificSsid = index;
}
}
}
ssid_len = *(scanBuf+1);
A_MEMCPY(ssid, scanBuf+2, ssid_len);
ssid[ssid_len] = '\0';
scanBuf += 2 + ssid_len;
}
break;
case 'C': /* Channel section */
if (scanBuf+1 < scanEnd) {
int chList = *(scanBuf+1);
scanBuf += 2;
(void)chList;
}
break;
case 'P': /* Passive dwell section */
if (scanBuf+2 < scanEnd) {
pas_dwell = *(scanBuf+1) + (*(scanBuf+2) << 8);
scanBuf += 3;
}
break;
case 'H': /* Home dwell section */
if (scanBuf+2 < scanEnd) {
home_dwell = *(scanBuf+1) + (*(scanBuf+2) << 8);
scanBuf += 3;
}
break;
case 'N': /* Number of probe section */
break;
case 'A': /* Active dwell section */
break;
case 'T': /* Scan active type section */
break;
default:
break;
}
if (sp == scanBuf) {
return -1; /* parsing error */
}
}
if (ssid_len>0 && index < arSta->scanSpecificSsid) {
A_UINT8 idx; /* Clean up the last specific scan items */
for (idx=index; idx<arSta->scanSpecificSsid; ++idx) {
wmi_probedSsid_cmd(arPriv->arWmi, 1+idx, DISABLE_SSID_FLAG, 0, NULL);
}
arSta->scanSpecificSsid = index;
}
if (pas_dwell>0) {
/* TODO: Should we change our passive dwell? There may be some impact for bt-coex */
}
if (home_dwell>0) {
/* TODO: Should we adjust home_dwell? How to pass it to wext handler? */
}
if (setScan) {
union iwreq_data miwr;
struct iw_request_info minfo;
struct iw_scan_req scanreq, *pScanReq = NULL;
A_MEMZERO(&minfo, sizeof(minfo));
A_MEMZERO(&miwr, sizeof(miwr));
if (ssid_len > 0) {
A_MEMZERO(&scanreq, sizeof(scanreq));
pScanReq = &scanreq;
memcpy(scanreq.essid, ssid, ssid_len);
scanreq.essid_len = ssid_len;
miwr.data.flags |= IW_SCAN_THIS_ESSID;
miwr.data.pointer = (__force void __user *)&scanreq;
miwr.data.length = sizeof(scanreq);
}
minfo.cmd = SIOCSIWSCAN;
return setScan(dev, &minfo, &miwr, (char*)pScanReq);
}
return -1;
} else if (strcasecmp(cmd, "MACADDR")==0) {
/* reply comes back in the form "Macaddr = XX:XX:XX:XX:XX:XX" where XX */
A_UCHAR *mac = dev->dev_addr;
len = snprintf(buf, data->length, "Macaddr = %02X:%02X:%02X:%02X:%02X:%02X\n",
mac[0], mac[1], mac[2],
mac[3], mac[4], mac[5]) + 1;
return (copy_to_user(data->pointer, buf, len)==0) ? len : -1;
} else if (strcasecmp(cmd, "SCAN-ACTIVE")==0) {
return 0; /* unsupport function. Suppress the error */
} else if (strcasecmp(cmd, "SCAN-PASSIVE")==0) {
return 0; /* unsupport function. Suppress the error */
} else if (strcasecmp(cmd, "START")==0 || strcasecmp(cmd, "STOP")==0) {
struct ifreq ifr;
char userBuf[16];
int ex_arg = (strcasecmp(cmd, "START")==0) ? WLAN_ENABLED : WLAN_DISABLED;
int ret;
A_MEMZERO(userBuf, sizeof(userBuf));
((int *)userBuf)[0] = AR6000_XIOCTRL_WMI_SET_WLAN_STATE;
((int *)userBuf)[1] = ex_arg;
ret = android_do_ioctl_direct(dev, AR6000_IOCTL_EXTENDED, &ifr, userBuf);
if (ret==0) {
/* Send wireless event which need by android supplicant */
union iwreq_data wrqu;
A_MEMZERO(&wrqu, sizeof(wrqu));
wrqu.data.length = strlen(cmd);
wireless_send_event(dev, IWEVCUSTOM, &wrqu, cmd);
}
return ret;
} else if (strncasecmp(cmd, "POWERMODE ", 10)==0) {
int mode;
if (sscanf(cmd, "%*s %d", &mode) == 1) {
int iocmd = SIOCSIWPOWER - SIOCSIWCOMMIT;
iw_handler setPower = dev->wireless_handlers->standard[iocmd];
if (setPower) {
union iwreq_data miwr;
struct iw_request_info minfo;
A_MEMZERO(&minfo, sizeof(minfo));
A_MEMZERO(&miwr, sizeof(miwr));
minfo.cmd = SIOCSIWPOWER;
if (mode == 0 /* auto */)
miwr.power.disabled = 0;
else if (mode == 1 /* active */)
miwr.power.disabled = 1;
else
return -1;
return setPower(dev, &minfo, &miwr, NULL);
}
}
return -1;
} else if (strcasecmp(cmd, "GETPOWER")==0) {
struct ifreq ifr;
int userBuf[2];
A_MEMZERO(userBuf, sizeof(userBuf));
((int *)userBuf)[0] = AR6000_XIOCTRL_WMI_GET_POWER_MODE;
if (android_do_ioctl_direct(dev, AR6000_IOCTL_EXTENDED, &ifr, userBuf)>=0) {
WMI_POWER_MODE_CMD *getPowerMode = (WMI_POWER_MODE_CMD *)userBuf;
len = snprintf(buf, data->length, "powermode = %u\n",
(getPowerMode->powerMode==MAX_PERF_POWER) ? 1/*active*/ : 0/*auto*/) + 1;
return (copy_to_user(data->pointer, buf, len)==0) ? len : -1;
}
return -1;
} else if (strncasecmp(cmd, "SETSUSPENDOPT ", 14)==0) {
int enable;
if (sscanf(cmd, "%*s %d", &enable)==1) {
/*
* We set our suspend mode by wlan_config.h now.
* Should we follow Android command?? TODO
*/
return 0;
}
return -1;
} else if (strcasecmp(cmd, "SCAN-CHANNELS")==0) {
// reply comes back in the form "Scan-Channels = X" where X is the number of channels
int iocmd = SIOCGIWRANGE - SIOCSIWCOMMIT;
iw_handler getRange = dev->wireless_handlers->standard[iocmd];
if (getRange) {
union iwreq_data miwr;
struct iw_request_info minfo;
struct iw_range range;
A_MEMZERO(&minfo, sizeof(minfo));
A_MEMZERO(&miwr, sizeof(miwr));
A_MEMZERO(&range, sizeof(range));
minfo.cmd = SIOCGIWRANGE;
miwr.data.pointer = (__force void __user *) ⦥
miwr.data.length = sizeof(range);
getRange(dev, &minfo, &miwr, (char*)&range);
}
if (arSta->arNumChannels!=-1) {
len = snprintf(buf, data->length, "Scan-Channels = %d\n", arSta->arNumChannels) + 1;
return (copy_to_user(data->pointer, buf, len)==0) ? len : -1;
}
return -1;
} else if (strncasecmp(cmd, "SCAN-CHANNELS ", 14)==0 ||
strncasecmp(cmd, "COUNTRY ", 8)==0) {
/*
* Set the available channels with WMI_SET_CHANNELPARAMS cmd
* However, the channels will be limited by the eeprom regulator domain
* Try to use a regulator domain which will not limited the channels range.
*/
int i;
int chan = 0;
A_UINT16 *clist;
struct ifreq ifr;
char ioBuf[256];
WMI_CHANNEL_PARAMS_CMD *chParamCmd = (WMI_CHANNEL_PARAMS_CMD *)ioBuf;
if (strncasecmp(cmd, "COUNTRY ", 8)==0) {
char *country = cmd + 8;
if (strcasecmp(country, "US")==0) {
chan = 11;
} else if (strcasecmp(country, "JP")==0) {
chan = 14;
} else if (strcasecmp(country, "EU")==0) {
chan = 13;
}
} else if (sscanf(cmd, "%*s %d", &chan) != 1) {
return -1;
}
if ( (chan != 11) && (chan != 13) && (chan != 14)) {
return -1;
}
if (arPriv->arNextMode == AP_NETWORK) {
return -1;
}
A_MEMZERO(&ifr, sizeof(ifr));
A_MEMZERO(ioBuf, sizeof(ioBuf));
chParamCmd->phyMode = WMI_11G_MODE;
clist = chParamCmd->channelList;
chParamCmd->numChannels = chan;
chParamCmd->scanParam = 1;
for (i = 0; i < chan; i++) {
clist[i] = wlan_ieee2freq(i + 1);
}
return android_do_ioctl_direct(dev, AR6000_IOCTL_WMI_SET_CHANNELPARAMS, &ifr, ioBuf);
} else if (strncasecmp(cmd, "BTCOEXMODE ", 11)==0) {
int mode;
if (sscanf(cmd, "%*s %d", &mode)==1) {
/*
* Android disable BT-COEX when obtaining dhcp packet except there is headset is connected
* It enable the BT-COEX after dhcp process is finished
* We ignore since we have our way to do bt-coex during dhcp obtaining.
*/
switch (mode) {
case 1: /* Disable*/
break;
case 0: /* Enable */
/* fall through */
case 2: /* Sense*/
/* fall through */
default:
break;
}
return 0; /* ignore it */
}
return -1;
} else if (strcasecmp(cmd, "BTCOEXSCAN-START")==0) {
/* Android enable or disable Bluetooth coexistence scan mode. When this mode is on,
* some of the low-level scan parameters used by the driver are changed to
* reduce interference with A2DP streaming.
*/
return 0; /* ignore it since we have btfilter */
} else if (strcasecmp(cmd, "BTCOEXSCAN-STOP")==0) {
return 0; /* ignore it since we have btfilter */
} else if (strncasecmp(cmd, "RXFILTER-ADD ", 13)==0) {
return 0; /* ignore it */
} else if (strncasecmp(cmd, "RXFILTER-REMOVE ", 16)==0) {
return 0; /* ignoret it */
} else if (strcasecmp(cmd, "RXFILTER-START")==0 || strcasecmp(cmd, "RXFILTER-STOP")==0) {
unsigned int flags = dev->flags;
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 34)
int mc_count = dev->mc_count;
#else
int mc_count = netdev_mc_count(dev);
#endif
if (!(flags & IFF_UP)) {
return -1;
}
if (strcasecmp(cmd, "RXFILTER-START")==0) {
if (mc_count > 0 || (flags & IFF_MULTICAST) ) {
flags &= ~IFF_MULTICAST;
}
} else {
flags |= IFF_MULTICAST;
}
if (flags != dev->flags) {
dev_change_flags(dev, flags);
}
return 0;
}
return -EOPNOTSUPP;
}
void ARShareStem::PrintName(std::ostream & os) const
{
os << "\\shareStem";
if (!getRange())
os << "Begin";
}
// ----------------------------------------------------------------------------
// buttonEvent() - called when a button is pressed
// ----------------------------------------------------------------------------
void MapDisplay::buttonEvent(const int b)
{
// cmdRange up, down
const auto page = static_cast<MapPage*>(subpage());
// cmdAirspeed, cmdAltitude, cmdHeading up, down
oe::models::Player* pA = getOwnship();
oe::models::Autopilot* ap = nullptr;
if (pA != nullptr) {
ap = static_cast<oe::models::Autopilot*>(pA->getPilot());
}
if (page != nullptr && ap != nullptr) {
if (b == oe::base::as_integer(Btn::DEC_RANGE)) {
if (page->getRange() > 5) {
page->setRange(page->getRange() - 5);
}
}
else if (b == oe::base::as_integer(Btn::INC_RANGE)) {
if (page->getRange() < 320) {
page->setRange(page->getRange() + 5);
}
}
else if (b == oe::base::as_integer(Btn::DEC_CMD_AS)) {
double cmdAirspeed = ap->getCommandedVelocityKts();
if (cmdAirspeed > 100) {
cmdAirspeed -= 10;
ap->setCommandedVelocityKts(cmdAirspeed);
}
}
else if (b == oe::base::as_integer(Btn::INC_CMD_AS)) {
double cmdAirspeed = ap->getCommandedVelocityKts();
if (cmdAirspeed < 400) {
cmdAirspeed += 10;
ap->setCommandedVelocityKts(cmdAirspeed);
}
}
else if (b == oe::base::as_integer(Btn::DEC_CMD_ALT)) {
double cmdAltitude = ap->getCommandedAltitudeFt();
if (cmdAltitude > 1000) {
cmdAltitude -= 500;
ap->setCommandedAltitudeFt(cmdAltitude);
}
}
else if (b == oe::base::as_integer(Btn::INC_CMD_ALT)) {
double cmdAltitude = ap->getCommandedAltitudeFt();
if (cmdAltitude < 40000) {
cmdAltitude += 500;
ap->setCommandedAltitudeFt(cmdAltitude);
}
}
else if (b == oe::base::as_integer(Btn::DEC_CMD_HDG)) {
double cmdHeading = ap->getCommandedHeadingD();
cmdHeading -= 10;
if (cmdHeading < -180.0) cmdHeading += 360;
ap->setCommandedHeadingD(cmdHeading);
}
else if (b == oe::base::as_integer(Btn::INC_CMD_HDG)) {
double cmdHeading = ap->getCommandedHeadingD();
cmdHeading += 10;
if (cmdHeading > 180.0) cmdHeading -= 360;
ap->setCommandedHeadingD(cmdHeading);
}
else if (b == oe::base::as_integer(Btn::INC_CMD_AS_NPS)) {
double maxAccel = ap->getMaxVelAcc();
if (maxAccel < 20) maxAccel++;
ap->setMaxVelAccNps(maxAccel);
}
else if (b == oe::base::as_integer(Btn::DEC_CMD_AS_NPS)) {
double maxAccel = ap->getMaxVelAcc();
if (maxAccel > 1) maxAccel--;
ap->setMaxVelAccNps(maxAccel);
}
// Climb rate in meters per second
else if (b == oe::base::as_integer(Btn::INC_CMD_ALT_MPS)) {
double maxClimb = ap->getMaxClimbRate();
if (maxClimb < 100) maxClimb += 5;
ap->setMaxClimbRateMps(maxClimb);
}
else if (b == oe::base::as_integer(Btn::DEC_CMD_ALT_MPS)) {
double maxClimb = ap->getMaxClimbRate();
if (maxClimb > 5) maxClimb -= 5;
ap->setMaxClimbRateMps(maxClimb);
}
// Turn rate in degrees per second
else if (b == oe::base::as_integer(Btn::INC_CMD_HDG_ROT)) {
double maxTR = ap->getMaxTurnRate();
if (maxTR < 25) maxTR++;
ap->setMaxTurnRateDps(maxTR);
}
else if (b == oe::base::as_integer(Btn::DEC_CMD_HDG_ROT)) {
double maxTR = ap->getMaxTurnRate();
if (maxTR > 0) maxTR--;
ap->setMaxTurnRateDps(maxTR);
}
// Max bank (degrees)
else if (b == oe::base::as_integer(Btn::INC_CMD_HDG_BNK)) {
double maxBank = ap->getMaxBankAngle();
if (maxBank < 90) maxBank++;
ap->setMaxBankAngleDeg(maxBank);
}
else if (b == oe::base::as_integer(Btn::DEC_CMD_HDG_BNK)) {
double maxBank = ap->getMaxBankAngle();
if (maxBank > 0) maxBank--;
ap->setMaxBankAngleDeg(maxBank);
}
else if (b == oe::base::as_integer(Btn::PASSIVE_ENABLE)) {
passiveEnable = true;
}
else if (b == oe::base::as_integer(Btn::PASSIVE_DISABLE)) {
passiveEnable = false;
}
// get our autopilot mode and change it
else if (b == oe::base::as_integer(Btn::CHANGE_AP_MODE)) {
// if off, go to nav
const bool navMode = ap->isNavModeOn();
const bool loiterMode = ap->isLoiterModeOn();
const bool flMode = ap->isFollowTheLeadModeOn();
// if in nav mode, go to loiter mode
if (navMode) {
ap->setNavMode(false);
ap->setLoiterMode(true);
}
// if in loiter mode, go to follow the lead mode
else if (loiterMode) {
ap->setLoiterMode(false);
ap->setFollowTheLeadMode(true);
}
// if in follow the lead mode, turn off all modes
else if (flMode) {
ap->setFollowTheLeadMode(false);
}
// all modes off, go back to nav
else ap->setNavMode(true);
}
}
}
