自学教程：C++ volume函数代码示例

double bin_search(double inf, double sup){  //printf("inf = %lf sup = %lf/n", inf, sup );  double base = b + (B-b)/H*(inf+sup)/2;  //printf(">> %lf/n", base );  //printf("h = %lf volume = %lf/n", (inf+sup)/2,volume(b, base, (inf+sup)/2)  );  //printf("/n");  if(volume(b, base, (inf+sup)/2) > l/n - 0.0000001 && volume(b, base, (inf+sup)/2) < l/n + 0.0000001 )  {    return (inf + sup)/2;  }  else if(volume(b, base, (inf+sup)/2) > l/n)  {    return bin_search(inf, (inf+sup)/2);  }  else if(volume(b, base, (inf+sup)/2) < l/n)  {    return bin_search((inf+sup)/2, sup);  }}

void ACubiquityVolume::PostActorCreated(){	loadVolume();	const auto eyePosition = eyePositionInVolumeSpace();	//while (!volume()->update({ eyePosition.X, eyePosition.Y, eyePosition.Z }, 0.0)) { /*Keep calling update until it returns true*/ }	volume()->update({ eyePosition.X, eyePosition.Y, eyePosition.Z }, lodThreshold);	createOctree();	Super::PostActorCreated();}

CLHEP::Hep3Vector tubeDimensions(uint64_t aVolumeId) {  DD4hep::Geometry::VolumeManager volMgr = DD4hep::Geometry::LCDD::getInstance().volumeManager();  auto pvol = volMgr.lookupPlacement(aVolumeId);  auto solid = pvol.volume().solid();  // get the envelope of the shape  TGeoConeSeg* tube = (dynamic_cast<TGeoConeSeg*>(solid.ptr()));  if (tube == nullptr) {    return CLHEP::Hep3Vector(0, 0, 0);  }  // get half-widths  return CLHEP::Hep3Vector(tube->GetRmin1(), tube->GetRmax1(), tube->GetDZ());}

/** * @brief receiving data main method * * Initialize and open a port, wait for input from input bottle, and print positive message if successful */int main(int argc, char *argv[]) {    yarp::os::Network yarp;    taylortrack::utils::ConfigParser config("../conf/real_config.conf");    taylortrack::utils::CommunicationSettings out;    out = config.get_audio_communication_out();    taylortrack::sim::DataReceiver<yarp::os::Bottle> rec;    bool data_receiver_initialized = rec.init(config.get_audio_communication_in());    if(data_receiver_initialized) {        taylortrack::utils::AudioSettings audio = config.get_audio_configuration();        taylortrack::localization::SrpPhat algorithm;// = taylortrack::localization::SrpPhat(audio.sample_rate, audio.mic_x, audio.mic_y, audio.grid_x, audio.grid_y, audio.interval, (int) audio.frame_size, audio.beta);        algorithm.set_config(config);        int microphones = static_cast<int>(audio.mic_x.size());        yarp::os::BufferedPort<yarp::os::Bottle> outport;        outport.open(out.port);        //yarp.connect(outport.getName(),yarp::os::ConstString(config.get_visualizer_communication_in().port));        yarp.connect(outport.getName(),yarp::os::ConstString(config.get_audio_communication_destination().port));        while (true) {            std::vector<taylortrack::utils::RArray> signals;            yarp::os::Bottle *new_data = rec.read_data(true);            for (int i = 0; i < microphones; ++i) {                taylortrack::utils::RArray volume(static_cast<size_t>(new_data->size()) / microphones);                int c = 0;                for (int j = i; j < new_data->size(); j += microphones) {                    volume[c] = new_data->get(j).asDouble();                    ++c;                }                signals.push_back(volume);            }            taylortrack::utils::VadSimple test_vad = taylortrack::utils::VadSimple(0.0000007);            if(test_vad.detect(signals[0])) {              algorithm.calculate_position_and_distribution(signals);              taylortrack::utils::RArray result = algorithm.get_last_distribution();              yarp::os::Bottle& bottle = outport.prepare();              bottle.clear();              for (int k = 0; k < static_cast<int>(result.size()); ++k) {                bottle.addDouble(result[k]);              }              outport.write(true);            } else {              std::cout << "No voice activity detected." << std::endl;            }        }    } else {        std::cout << "Error initializing incoming communication..." << std::endl;        return EXIT_FAILURE;    }}

int main() {    float raio, resultado;    printf("Digite o raio: /n");    scanf("%f", &raio);    printf("resultado: %.2f/n/n", volume(raio));    return 0;}

bool DeskbarView::_EntryInTrash(const entry_ref* ref){	BEntry entry(ref);	BVolume volume(ref->device);	BPath path;	if (volume.InitCheck() != B_OK		|| find_directory(B_TRASH_DIRECTORY, &path, false, &volume) != B_OK)		return false;	BDirectory trash(path.Path());	return trash.Contains(&entry);}

const Kernel::FT volume( const Geometry& g ){    if ( g.isEmpty() ) {        return 0;    }    SFCGAL_ASSERT_GEOMETRY_VALIDITY( g );    switch ( g.geometryTypeId() ) {    case TYPE_POINT:    case TYPE_LINESTRING:    case TYPE_POLYGON:    case TYPE_TRIANGLE:    case TYPE_MULTIPOINT:    case TYPE_MULTILINESTRING:    case TYPE_MULTIPOLYGON:    case TYPE_TRIANGULATEDSURFACE:    case TYPE_POLYHEDRALSURFACE:        return 0;    case TYPE_SOLID:        return volume( g.as<Solid>(), NoValidityCheck() );    case TYPE_MULTISOLID:    case TYPE_GEOMETRYCOLLECTION:        Kernel::FT v=0;        const GeometryCollection& c = g.as<GeometryCollection>();        for ( size_t i=0; i<c.numGeometries(); i++ ) {            if ( c.geometryN( i ).is<Solid>() ) {                v = v + volume( c.geometryN( i ).as<Solid>(), NoValidityCheck() );            }        }        return v;    }    BOOST_THROW_EXCEPTION( Exception(                               ( boost::format( "volume( %s ) is not defined" ) % g.geometryType() ).str()                           ) );    return 0; // to avoid warning}

void AdvectionManager::init(const Domain &domain, const Mesh &mesh,                            const ConfigManager &configManager,                            const TimeManager &timeManager) {    this->domain = &domain;    this->mesh = &mesh;    io.init(timeManager);    string output_prefix;    if (configManager.hasKey("tspas", "output_prefix")) {        configManager.getValue("tspas", "output_prefix", output_prefix);    } else {        output_prefix = "tspas."+            boost::lexical_cast<string>(mesh.getNumGrid(0, FULL))+"x"+            boost::lexical_cast<string>(mesh.getNumGrid(1, FULL));    }    outputFileIdx = io.registerOutputFile(mesh, output_prefix,                                          IOFrequencyUnit::STEPS, 10);    Qstar.create("qstar", "N/A", "intermediate tracer density", mesh, CENTER);    FX.create("fx", "N/A", "flux along x direction", mesh, X_FACE);    FY.create("fy", "N/A", "flux along y direction", mesh, Y_FACE);    A.create("a", "N/A", "shape-preserving judger", mesh, CENTER);    B.create("b", "N/A", "beta", mesh, CENTER);    volume.create("volume", "m2 or m3", "the volume of grid cells", mesh, CENTER);        io.file(outputFileIdx).registerOutputField<double, 1, FULL_DIMENSION>(1, &volume);    int js = 0, jn = mesh.getNumGrid(1, FULL)-1;    for (int i = 0; i < mesh.getTotalNumGrid(CENTER); ++i) {        volume(i) = mesh.getCellVolume(i);    }    dlon.resize(mesh.getNumGrid(0, HALF));    for (int i = 0; i < mesh.getNumGrid(0, HALF); ++i) {        dlon[i] = mesh.getGridInterval(0, FULL, i); // this is correct    }    dlat.resize(mesh.getNumGrid(1, HALF));    for (int j = 0; j < mesh.getNumGrid(1, HALF); ++j) {        dlat[j] = mesh.getGridInterval(1, FULL, j); // this is correct    }    cosLatFull.set_size(mesh.getNumGrid(1, FULL));    for (int j = 0; j < mesh.getNumGrid(1, FULL); ++j) {        cosLatFull[j] = mesh.getCosLat(FULL, j);    }    cosLatFull[js] = 0;    cosLatFull[jn] = 0;    cosLatHalf.set_size(mesh.getNumGrid(1, HALF));    for (int j = 0; j < mesh.getNumGrid(1, HALF); ++j) {        cosLatHalf[j] = mesh.getCosLat(HALF, j);    }}

// ----------------------------------------------------------------------------// test the volume setting page creation api.// ----------------------------------------------------------------------------//void CTestVolumeSettingPage::TestL()    {    TInt volume(KBCTestVolumeDefaultVolumeLevel);    CAknVolumeSettingPage* volumeSettingPage = new( ELeave ) CAknVolumeSettingPage(             R_BCTESTVOLUME_SETTING_PAGE_VOLUME_INDICATOR,             volume );    AssertNotNullL(volumeSettingPage, _L("create volume setting page."));    AssertTrueL(        volumeSettingPage->ExecuteLD( CAknSettingPage::EUpdateWhenChanged ),        _L("setting page executed."));    }

/*****************************************************************	setAscentRate:*	This function takes the previous two points and calculates *	the ascent rate****************************************************************/void Predictor::setAscentRatePre( ){	double airDen = air ( _balloon->getLatestPoint().getAlt() );	double vol = volume ( _balloon->getLatestPoint().getAlt() );	double totMass = ( _balloon->getMassPayload() + _balloon->getMassBalloon() );	double areaBalloon = area( _balloon->getLatestPoint().getAlt() );	totMass *= GRAVITY;	double top = 2.0 * .85 * airDen * vol * GRAVITY;	top = top - 2.0 * totMass;	double bottom = _balloon->getDragBalloon() *  areaBalloon * airDen;	top = top / bottom;	_ascentRate = sqrt ( top );}

void CGameListCtrl::OnExportSave(wxCommandEvent& WXUNUSED (event)){	const GameListItem* iso = GetSelectedISO();	if (!iso)		return;	u64 title_id;	std::unique_ptr<DiscIO::IVolume> volume(DiscIO::CreateVolumeFromFilename(iso->GetFileName()));	if (volume && volume->GetTitleID(&title_id))	{		CWiiSaveCrypted::ExportWiiSave(title_id);	}}

int Find() {    for (int i = 2; i < n; i++) {        Point ndir = (info[0] - info[i]).cross(info[1] - info[i]);        if (ndir == Point()) continue;        swap(info[i], info[2]);        for (int j = i + 1; j < n; j++)            if (Sign(volume(0, 1, 2, j)) != 0) {                swap(info[j], info[3]);                insert(0, 1, 2);  insert(0, 2, 1);                return 1;            }    }    return 0;}

void KNMusicStandardBackend::smartVolumeOn(){    //If the origial volume is not -1, means smart volume has been turned on.    if(m_originalVolume!=-1)    {        return;    }    //Backup the original volume.    m_originalVolume=m_main->volume()==0?volume():m_main->volume();    //Set the preview as the full volume.    m_preview->setVolume(m_originalVolume);    //Set the main volume as the 1/8 of the full volume.    m_main->setVolume(m_originalVolume>8?m_originalVolume/8:0);}

	// Make a random box inside the World Box with the given percentage Volume	void Box::randomBox(const Box& world, const float percentageVolume,Box& random)	{	bigSpaceUnit newVolume = volume(world)*percentageVolume/100;	spaceUnit dimensionInc = pow(newVolume,1.0/3.0) /2;	for (size_t i = 0; i < DIMENSION; i++)		{		boost::uniform_real<> uni_dist (world.low.Vector[i],world.high.Vector[i]);		boost::variate_generator<boost::mt11213b &,boost::uniform_real<> > uni(generator, uni_dist);		float center = uni();		random.low.Vector[i]  = center-dimensionInc;		random.high.Vector[i] = center+dimensionInc;		}	}

void MusicPlayer::setMusicEnhanced(Enhanced type){    m_musicEnhanced = type;    if(m_musicEnhanced == Music3D)    {        m_volumeMusic3D = volume();    }    else    {        m_music->setVolume(m_volumeMusic3D, m_volumeMusic3D);        setMusicEnhancedCase();    }}

StorageChunk StorageChunk::new_from_buffer(const Vec3i &location,	const Vector<uint8_t> &contents, Error *err){	if (contents.length() < 4 || slice_cast<const char>(contents.sub(0, 4)) != "NGSC") {		err->set("Bad magic, NGSC expected");		return StorageChunk(location);	}	ByteReader br(contents.sub(4));	Vec3i chunk_size, storage_chunk_size;	chunk_size.x = br.read_int32(err);	chunk_size.y = br.read_int32(err);	chunk_size.z = br.read_int32(err);	if (*err)		return StorageChunk(location);	if (chunk_size != CHUNK_SIZE) {		err->set("Mismatching chunk sizes, file: (%d %d %d), expected: (%d %d %d)",			VEC3(chunk_size), VEC3(CHUNK_SIZE));		return StorageChunk(location);	}	storage_chunk_size.x = br.read_int32(err);	storage_chunk_size.y = br.read_int32(err);	storage_chunk_size.z = br.read_int32(err);	if (*err)		return StorageChunk(location);	if (storage_chunk_size != STORAGE_CHUNK_SIZE) {		err->set("Mismatching storage chunk sizes, file: (%d %d %d), expected: (%d %d %d)",			VEC3(storage_chunk_size), VEC3(STORAGE_CHUNK_SIZE));		return StorageChunk(location);	}	auto tmp = br.read_compressed(err);	if (*err)		return StorageChunk(location);	StorageChunk msc(location);	br = ByteReader(tmp);	for (int i = 0, n = volume(storage_chunk_size); i < n; i++) {		Chunk &c = msc.chunks[i];		c.lods[0].deserialize(&br, CHUNK_SIZE + Vec3i(1), err);		if (*err)			return StorageChunk(location);	}	return msc;}

/* main loop */intmain(void){	input_line = (char *)malloc(6 * sizeof(char));	led_setperm();	set_time = 200000;	while (strncmp(input_line, "quit", 4) != 0)	{		input_line = readline("Led Control> ");		/* I know instruction parsing is really lame :/ */		if (!strncmp(input_line, "help", 4))			help();		if (!strncmp(input_line, "ledon", 5))			ledon();		if (!strncmp(input_line, "ledoff", 6))			ledoff();		if (!strncmp(input_line, "settime", 7))			settime();		if (!strncmp(input_line, "volume", 6))			volume();		if (!strncmp(input_line, "bin", 3))			bin();		if (!strncmp(input_line, "slide", 5))			slide();		if (!strncmp(input_line, "blink", 5))			blink();		if (!strncmp(input_line, "bislide", 7))			bislide();		if (!strncmp(input_line, "biblink", 7))			biblink();		if (!strncmp(input_line, "grow", 4))			grow();		if (!strncmp(input_line, "center", 6))			center();		if (!strncmp(input_line, "side", 4))			side();		if (!strncmp(input_line, "biside", 6))			biside();		if (!strncmp(input_line, "demo", 4))			demo();	}	led_off_all();	exit(0);}

int _tmain(int argc, _TCHAR* argv[]){	std::vector<unsigned int> vinput;	get_input(vinput);	size_t volume(0);		if(vinput.empty() || vinput.size() == 1)	{		// volume = 0		return 0;	}	size_t vis = vinput.size();	size_t idxfwd(0), idxbwd(vis - 1);	std::vector<unsigned int> output;	output.resize(vis, UINT_MAX); // initial value for array	unsigned int mvalfwd = vinput[idxfwd];	unsigned int mvalbwd = vinput[idxbwd];	unsigned s;	while(idxbwd)	{		// check forward iterators		s = check_val(output[idxfwd], vinput[idxfwd], mvalfwd);		if(UINT_MAX != output[idxfwd]) // check with initial value!		{			volume += std::min(s, output[idxfwd]);		}		output[idxfwd] = s;		idxfwd++;		// check backward iterator		s = check_val(output[idxbwd], vinput[idxbwd], mvalbwd);		if(UINT_MAX != output[idxbwd]) // check with initial value!		{			volume += std::min(s, output[idxbwd]);		}		output[idxbwd] = s;		idxbwd--;	}	// volume = sum of all elements in output	// volume contain value already!	return 0;}

void ViStreamInput::mute(bool value){	if(value)	{		mMuteVolume = volume();		setVolume(0);		mIsMute = true;	}	else	{		mIsMute = false;		setVolume(mMuteVolume);	}}

voidFiniteStrainMaterial::computeStrain(){  //Method from Rashid, 1993  std::vector<RankTwoTensor> Fhat;  Fhat.resize(_qrule->n_points());  RankTwoTensor ave_Fhat;  Real volume(0);  Real ave_dfgrd_det;  ave_dfgrd_det=0.0;  for (_qp = 0; _qp < _qrule->n_points(); ++_qp)  {    //Deformation gradient    RankTwoTensor A(_grad_disp_x[_qp], _grad_disp_y[_qp], _grad_disp_z[_qp]); //Deformation gradient    RankTwoTensor Fbar(_grad_disp_x_old[_qp], _grad_disp_y_old[_qp], _grad_disp_z_old[_qp]); //Old Deformation gradient    _dfgrd[_qp] = A;    _dfgrd[_qp].addIa(1.0);//Gauss point deformation gradient    A -= Fbar; //A = gradU - gradUold    Fbar.addIa(1.0); //Fbar = ( I + gradUold)    //Incremental deformation gradient Fhat = I + A Fbar^-1    Fhat[_qp] = A * Fbar.inverse();    Fhat[_qp].addIa(1.0);    //Calculate average Fhat for volumetric locking correction    ave_Fhat += Fhat[_qp] * _JxW[_qp];    volume += _JxW[_qp];    ave_dfgrd_det += _dfgrd[_qp].det() * _JxW[_qp]; //Average deformation gradient  }  ave_Fhat /= volume; //This is needed for volumetric locking correction  ave_dfgrd_det /=volume; //Average deformation gradient  for (_qp = 0; _qp < _qrule->n_points(); ++_qp)  {    Real factor( std::pow( ave_Fhat.det() / Fhat[_qp].det(), 1.0/3.0));    Fhat[_qp] *= factor; //Finalize volumetric locking correction    computeQpStrain(Fhat[_qp]);    factor = std::pow(ave_dfgrd_det / _dfgrd[_qp].det(), 1.0/3.0);//Volumetric locking correction    _dfgrd[_qp] *= factor;//Volumetric locking correction  }}

bool remove(int p, int b, int a) {	int f = bf[b][a];	face_t ff;	if (fc[f].vis) {		if (dblcmp(volume(pt[p], pt[fc[f].a], pt[fc[f].b], pt[fc[f].c])) >= 0) {			return true;		} else {			ff.a = a, ff.b = b, ff.c = p;			bf[ff.a][ff.b] = bf[ff.b][ff.c] = bf[ff.c][ff.a] = ++fcnt;			ff.vis = true;			fc[fcnt] = ff;		}	}	return false;}

void vol_meter(){  int vol = volume();  int length = 16 * (float)num_panels * ((float)vol / (float)600);  clear_scr();  for (int x = 0; x < length; x ++)   {  for (int y = 0; y < 8;y++)  {    picture[x][y] = red;    } } }

GameFile::GameFile(const std::string& path)    : m_file_path(path), m_region(DiscIO::Region::Unknown), m_country(DiscIO::Country::Unknown){  {    std::string name, extension;    SplitPath(m_file_path, nullptr, &name, &extension);    m_file_name = name + extension;    std::unique_ptr<DiscIO::Volume> volume(DiscIO::CreateVolumeFromFilename(m_file_path));    if (volume != nullptr)    {      m_platform = volume->GetVolumeType();      m_short_names = volume->GetShortNames();      m_long_names = volume->GetLongNames();      m_short_makers = volume->GetShortMakers();      m_long_makers = volume->GetLongMakers();      m_descriptions = volume->GetDescriptions();      m_region = volume->GetRegion();      m_country = volume->GetCountry();      m_blob_type = volume->GetBlobType();      m_file_size = volume->GetRawSize();      m_volume_size = volume->GetSize();      m_internal_name = volume->GetInternalName();      m_game_id = volume->GetGameID();      m_gametdb_id = volume->GetGameTDBID();      m_title_id = volume->GetTitleID().value_or(0);      m_maker_id = volume->GetMakerID();      m_revision = volume->GetRevision().value_or(0);      m_disc_number = volume->GetDiscNumber().value_or(0);      m_apploader_date = volume->GetApploaderDate();      m_volume_banner.buffer = volume->GetBanner(&m_volume_banner.width, &m_volume_banner.height);      m_valid = true;    }  }  if (!IsValid() && IsElfOrDol())  {    m_valid = true;    m_file_size = m_volume_size = File::GetSize(m_file_path);    m_platform = DiscIO::Platform::ELFOrDOL;    m_blob_type = DiscIO::BlobType::DIRECTORY;  }}

QDomElement SMActionVideoNative::createDomElement(QDomDocument& document){    QDomElement element = SMAction::createDomElement(document);    //repeat    QDomElement repeatElement = document.createElement("repeat");    repeatElement.appendChild(document.createTextNode(QString::number(repeat())));    element.appendChild(repeatElement);    //volume    QDomElement volumeElement = document.createElement("volume");    volumeElement.appendChild(document.createTextNode(QString::number(volume())));    element.appendChild(volumeElement);    return element;}

    typename viennagrid::result_of::coord< MeshSegmentHandleType >::type    volume_mesh(MeshSegmentHandleType const & mesh_obj)    {      typedef typename viennagrid::result_of::const_element_range<MeshSegmentHandleType, ElementTOrTag>::type  CellContainer;      typedef typename viennagrid::result_of::iterator<CellContainer>::type                                       CellIterator;      typename viennagrid::result_of::coord< MeshSegmentHandleType >::type new_volume = 0;      CellContainer new_cells = viennagrid::elements<ElementTOrTag>(mesh_obj);      for (CellIterator new_cit = new_cells.begin();                        new_cit != new_cells.end();                      ++new_cit)      {        new_volume += volume( default_point_accessor(mesh_obj), *new_cit);      }      return new_volume;    }

/* greebo: This gets called by the SelectObserver if the user drags a box and holds down * any of the selection modifiers. Possible selection candidates are determined and selected/deselected */void RadiantSelectionSystem::SelectArea(const View& view,                                        const Vector2& device_point,                                        const Vector2& device_delta,                                        SelectionSystem::EModifier modifier, bool face){    // If we are in replace mode, deselect all the components or previous selections    if (modifier == SelectionSystem::eReplace) {        if (face) {            setSelectedAllComponents(false);        }        else {            deselectAll();        }    }    {        // Construct the selection test according to the area the user covered with his drag        View scissored(view);        ConstructSelectionTest(scissored, Rectangle::ConstructFromArea(device_point, device_delta));        SelectionVolume volume(scissored);        // The posssible candidates go here        SelectionPool pool;        SelectablesList candidates;        if (face)        {            ComponentSelector selectionTester(pool, volume, eFace);            GlobalSceneGraph().foreachVisibleNodeInVolume(scissored, selectionTester);            // Load them all into the vector            for (SelectionPool::iterator i = pool.begin(); i != pool.end(); ++i)            {                candidates.push_back(i->second);            }        }        else {            testSelectScene(candidates, volume, scissored, Mode(), ComponentMode());        }        // Cycle through the selection pool and toggle the candidates, but only if we are in toggle mode        for (SelectablesList::iterator i = candidates.begin(); i != candidates.end(); i++) {            (*i)->setSelected(!(modifier == SelectionSystem::eToggle && (*i)->isSelected()));        }    }}

	void ConsoleCommands::registerCommands(Console& console, AppService& appService, Menu& menu, GameSettings& gameSettings)	{		SDL_version sdlVersion;		std::string verStr = D6_L("version");		// Print application info		console.printLine(D6_L("/n===Application information==="));		console.printLine(Format("{0} {1}: {2}") << APP_NAME << verStr << APP_VERSION);		SDL_GetVersion(&sdlVersion);		console.printLine(Format("SDL {0}: {1}.{2}.{3}") << verStr << sdlVersion.major << sdlVersion.minor << sdlVersion.patch);		const SDL_version* mixVersion = Mix_Linked_Version();		console.printLine(Format("SDL_mixer {0}: {1}.{2}.{3}") << verStr << mixVersion->major << mixVersion->minor << mixVersion->patch);		console.printLine(D6_L("Language: english"));		// Set some console functions		console.setLast(15);		console.registerCommand("switch_render_mode", [&gameSettings](Console& con, const Console::Arguments& args) {			toggleRenderMode(con, args, gameSettings);		});		console.registerCommand("show_fps", [&gameSettings](Console& con, const Console::Arguments& args) {			toggleShowFps(con, args, gameSettings);		});		console.registerCommand("gl_info", openGLInfo);		console.registerCommand("lang", language);		console.registerCommand("volume", [&appService](Console& con, const Console::Arguments& args) {			volume(con, args, appService.getSound());		});		console.registerCommand("rounds", [&gameSettings](Console& con, const Console::Arguments& args) {			maxRounds(con, args, gameSettings);		});		console.registerCommand("ghosts", [&gameSettings](Console& con, const Console::Arguments& args) {			ghostMode(con, args, gameSettings);		});		console.registerCommand("music", [&menu](Console& con, const Console::Arguments& args) {			musicOnOff(con, args, menu);		});		console.registerCommand("joy_scan", [&menu](Console& con, const Console::Arguments& args) {			joyScan(con, args, menu);		});		console.registerCommand("skin", [&menu](Console& con, const Console::Arguments& args) {			loadSkin(con, args, menu);		});		console.registerCommand("gun", enableWeapon);		console.registerCommand("start_ammo_range", [&gameSettings](Console& con, const Console::Arguments& args) {			ammoRange(con, args, gameSettings);		});	}

int RawConverter::RawToRawPlusDerivativesConverter( const string& src,                                                    const string& dst ){    unsigned w, h, d;//read header    {        string configFileName = src;        hFile info( fopen( configFileName.append( ".vhf" ).c_str(), "rb" ) );        FILE* file = info.f;        if( file==NULL ) return lFailed( "Can't open header file" );        readDimensionsFromSav( file, w, h, d );    }    std::cout << "Creating derivatives for raw model: "           << src << " " << w << " x " << h << " x " << d << endl;//read model    vector<unsigned char> volume( w*h*d, 0 );    std::cout << "Reading model" << endl;    {        ifstream file( src.c_str(),                       ifstream::in | ifstream::binary | ifstream::ate );        if( !file.is_open() )            return lFailed( "Can't open volume file" );        ifstream::pos_type size;        size = min( (int)file.tellg(), (int)volume.size() );        file.seekg( 0, ios::beg );        file.read( (char*)( &volume[0] ), size );        file.close();    }//calculate and save derivatives    {        int result = calculateAndSaveDerivatives( dst, &volume[0], w,  h, d );        if( result ) return result;    }    std::cout << "done" << endl;    return 0;}

void snake(){   if (beat())   {      int vol = volume();      move_back(0);      int amount = (float)vol/600 * 8;      int length = (float)vol/600 * (float)num_panels* 16;         for (int i = 0; i < length  ;i++)       {            picture[i][amount] =red;       }     }  }