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

void RC2UI::writeBool( const QString& name, bool value ){    wi(); *out << "<property>" << endl; indent();    wi(); *out << "<name>" << name << "</name>" << endl;    wi(); *out << "<bool>" << (value ? "true" : "false") << "</bool>" << endl; undent();    wi(); *out << "</property>" << endl;}

void AudioData::wl(FILE* fp, uint32_t l){	unsigned int i1, i0;	i0 = l % 65536L;	i1 = (l - i0) / 65536L;	wi(fp, i0);	wi(fp, i1);}

float Lambert (Vec3f source, Vec3f position, Vec3f normal){    Vec3f wi(source - position);    wi /= wi.length();    return dot(normal, wi);}

int main(int argc, char* argv[])      {      QApplication app(argc, argv);      QWidget wi(0);      PDPI = wi.logicalDpiX();    // physical resolution      DPI  = PDPI;                // logical drawing resolution      DPMM = DPI / INCH;          // dots/mm      runtime = new Runtime;      MScore::init();      seq = new Seq;      if (!seq->init()) {            printf("cannot initialize sequencer/n");            exit(-1);            }      qmlRegisterType<ScoreView>("MuseScore", 1, 0, "ScoreView");      QDeclarativeView view;      view.setResizeMode(QDeclarativeView::SizeRootObjectToView);      QDeclarativeContext* ctxt = view.rootContext();      ctxt->setContextProperty(QLatin1String("runtime"), runtime);      // registering only for exposing the Runtime::Orientation enum      qmlRegisterUncreatableType<Runtime>("Qt", 4, 7, "Orientation", QString());      qmlRegisterUncreatableType<Runtime>("QtQuick", 1, 0, "Orientation", QString());      view.setSource(QUrl("qrc:/mplayer.qml"));      view.show();      return app.exec();      }

	inline Float sample(PhaseFunctionSamplingRecord &pRec, Sampler *sampler) const {		Float Sxx, Sxy, Sxz, Syy, Syz, Szz;	/*	vec3 omega3(pRec.mRec.orientation.x, pRec.mRec.orientation.y, pRec.mRec.orientation.z);		omega3 = normalize(omega3);		Sxx = sigma3*sigma3*omega3.x*omega3.x + omega3.y*omega3.y + omega3.z*omega3.z;		Sxy = sigma3*sigma3*omega3.x*omega3.y - omega3.x*omega3.y;		Sxz = sigma3*sigma3*omega3.x*omega3.z - omega3.x*omega3.z;		Syy = sigma3*sigma3*omega3.y*omega3.y + omega3.x*omega3.x + omega3.z*omega3.z;		Syz = sigma3*sigma3*omega3.y*omega3.z - omega3.y*omega3.z;		Szz = sigma3*sigma3*omega3.z*omega3.z + omega3.x*omega3.x + omega3.y*omega3.y;*/		Sxx = pRec.mRec.S[0]; Syy = pRec.mRec.S[1]; Szz = pRec.mRec.S[2];		Sxy = pRec.mRec.S[3]; Sxz = pRec.mRec.S[4];	Syz = pRec.mRec.S[5];		if (Sxx*Sxx + Syy*Syy + Szz*Szz + Sxy*Sxy + Sxz*Sxz + Syz*Syz < 1e-3)			return 0.0;		vec3 wi(pRec.wi.x, pRec.wi.y, pRec.wi.z);				#if defined(SGGX_STATISTICS)			avgSampleIterations.incrementBase();		#endif		wi=normalize(wi);		Point2 point = sampler->next2D();		vec3 wo=sample_specular(wi, Sxx, Syy, Szz, Sxy, Sxz, Syz, point.x, point.y);		wo = normalize(wo);		pRec.wo = Vector(wo.x,wo.y,wo.z);#if defined(SGGXDEBUGSAMPLE)		float length = sqrtf(dot(wo, wo));		if (fabs(length - 1.0) > 0.0001)		{			FILE *f = fopen("log_phase_sample.txt", "a+");			fprintf(f, "wo %f %f %f/n", wo.x, wo.y, wo.z);			fprintf(f, "%f/n",length );			fclose(f);		}#endif		/*int iterations = 0, maxIterations = 1000;		while (true) {			Vector H = m_fiberDistr.sample(sampler->next2D());			#if defined(SGGX_STATISTICS)				++avgSampleIterations;			#endif			++iterations;			if (sampler->next1D() < absDot(wi, H)) {				Vector wo = H*(2*dot(wi, H)) - wi;				pRec.wo = frame.toWorld(wo);				break;			}			if (iterations >= maxIterations) {				Log(EWarn, "Sample generation unsuccessful after %i iterations"					" (dp=%f, fiberOrientation=%s, wi=%s)", iterations,					absDot(pRec.wi, pRec.mRec.orientation),					pRec.mRec.orientation.toString().c_str(),					pRec.wi.toString().c_str());				return 0.0f;			}		}*/		return 1.0f;	}

bool schur(const mat &A, mat &U, mat &T){  it_assert_debug(A.rows() == A.cols(), "schur(): Matrix is not square");  char jobvs = 'V';  char sort = 'N';  int info;  int n = A.rows();  int lda = n;  int ldvs = n;  int lwork = 3 * n; // This may be choosen better!  int sdim = 0;  vec wr(n);  vec wi(n);  vec work(lwork);  T.set_size(lda, n, false);  U.set_size(ldvs, n, false);  T = A; // The routine overwrites input matrix with eigenvectors  dgees_(&jobvs, &sort, 0, &n, T._data(), &lda, &sdim, wr._data(), wi._data(),         U._data(), &ldvs, work._data(), &lwork, 0, &info);  return (info == 0);}

void WeatherMgr::LoadFromDB(){	//sLog.outString("  Loading Weather..."); // weather type 0= sunny / 1= fog / 2 = light_rain / 4 = rain / 8 = snow / ?? = sandstorm	QueryResult *result = WorldDatabase.Query( "SELECT zoneId,high_chance,high_type,med_chance,med_type,low_chance,low_type FROM weather" );	if( !result )		return;	do	{		Field *fields = result->Fetch();		WeatherInfo* wi(new WeatherInfo);		wi->m_zoneId = fields[0].GetUInt32();		wi->m_effectValues[0] = fields[1].GetUInt32();  // high_chance		wi->m_effectValues[1] = fields[2].GetUInt32();  // high_type		wi->m_effectValues[2] = fields[3].GetUInt32();  // med_chance		wi->m_effectValues[3] = fields[4].GetUInt32();  // med_type		wi->m_effectValues[4] = fields[5].GetUInt32();  // low_chance		wi->m_effectValues[5] = fields[6].GetUInt32();  // low_type		m_zoneWeathers[wi->m_zoneId] = wi;		wi->_GenerateWeather();	} while( result->NextRow() );	Log.Notice("WeatherMgr", "Loaded weather information for %u zones.", result->GetRowCount());	delete result;}

void* RenderThread::run(){    while (1)    {        std::auto_ptr<WorkItem> wi(img->wq.waitForItem());        RowWorkItem* rwi = NULL;        QuitWorkItem* qwi = NULL;        if ((rwi = dynamic_cast<RowWorkItem*>(wi.get())))        {            doRow(rwi->row);        }        else if ((qwi = dynamic_cast<QuitWorkItem*>(wi.get())))        {            break;        }        else        {            gf_a(0);        }    }    return NULL;}

glm::vec3 BlinnMicrofacetBxDF::EvaluateHemisphereScatteredEnergy(const glm::vec3 &wo, int num_samples, const glm::vec2 *samples) const{    //TODO    glm::vec3 color( 0.f );    for( int i = 0; i < num_samples; ++i ){        float cos_theta( powf( samples[ i ].x, 1.f / ( exponent + 1.f ) ) );        float sin_theta( sqrtf( fmaxf( 0.f, 1.f - cos_theta * cos_theta ) ) );        float phi( samples[ i ].y * TWO_PI );        float cos_phi( cosf( phi ) );        float sin_phi( sinf( phi ) );        glm::vec3 wh( sin_theta * cos_phi, sin_theta * sin_phi, cos_theta );        float woDwh( glm::dot( wo, wh ) );        if( woDwh < 0.f ) wh = -wh;        glm::vec3 wi( -wo + 2.f * woDwh * wh );        color += EvaluateScatteredEnergy( wo, wi );    }    return color / ( float )num_samples;}

	Float computeTransmittance(const char *name, Float eta, Float alpha, Float cosTheta) {		Properties bsdfProps("roughdielectric");		if (cosTheta < 0) {			cosTheta = -cosTheta;			eta = 1.0f / eta;		}		if (eta < 1) {			bsdfProps.setFloat("intIOR", 1.0f);			bsdfProps.setFloat("extIOR", 1.0f / eta);		} else {			bsdfProps.setFloat("extIOR", 1.0f);			bsdfProps.setFloat("intIOR", eta);		}		bsdfProps.setFloat("alpha", alpha);		bsdfProps.setString("distribution", name);		ref<BSDF> bsdf = static_cast<BSDF *>(				PluginManager::getInstance()->createObject(bsdfProps));		NDIntegrator intTransmittance(1, 2, 50000, 0, 1e-6f);		Vector wi(math::safe_sqrt(1-cosTheta*cosTheta), 0, cosTheta);		Float transmittance, error;		Float min[2] = {0, 0}, max[2] = {1, 1};		intTransmittance.integrateVectorized(			boost::bind(&transmittanceIntegrand, bsdf, wi, _1, _2, _3),			min, max, &transmittance, &error, NULL);		return transmittance;	}

Ray Ray::getInConeRay(Vec3f intersection, Vec3f * triangle, int depth, pair <int, int> exceptionTriangle){    Vec3f n = getNormalwithRayComes(triangle, this->direction);    //find a unit vector in the plane    Vec3f ex(triangle[0] - intersection);    ex /= ex.length();    //another unit vector in the plane to forme a local coordiante    Vec3f ey = cross(n, ex);    Vec3f wi(this->position - intersection);    wi /= wi.length();    float cosTheta_i = dot(wi, n);    if(cosTheta_i < -EPS)        cout << "ERROR in getInConeRaysOut: l'angle theta_i est plus grande que 90, something wrong with the direction" << endl;    //find a eOnPlane vector unit (which lies on plane)    float xComponent     = getRandomFloat(-1.0, 1.0);    float yComponent     = getRandomFloat(-1.0, 1.0);    Vec3f eOnPlane(xComponent * ex + yComponent * ey);    eOnPlane /= eOnPlane.length();    //to ensure the direction Out lies inside the cone    //dirOut = costheta_i * normal + sintheta_i * eOnPlane    Vec3f dirOut(cosTheta_i * n + sqrt(1 - cosTheta_i*cosTheta_i) * eOnPlane);    dirOut /= dirOut.length();    return Ray(intersection, dirOut, bshRoot, depth, exceptionTriangle);}

 //! Returns a negative duration_type duration_type get_neg_offset(const date_type& d) const  {   ymd_type ymd(d.year_month_day());   if (origDayOfMonth_ == 0) {     origDayOfMonth_ = ymd.day;     day_type endOfMonthDay(cal_type::end_of_month_day(ymd.year,ymd.month));     if (endOfMonthDay == ymd.day) {       origDayOfMonth_ = -1; //force the value to the end of month     }   }   typedef date_time::wrapping_int2<short,1,12> wrap_int2;   typedef typename wrap_int2::int_type int_type;   wrap_int2 wi(ymd.month);   //calc the year wrap around, add() returns 0 or 1 if wrapped   int_type year = wi.subtract(static_cast<int_type>(f_));    year = static_cast<int_type>(year + ymd.year); //calculate resulting year   //find the last day for the new month   day_type resultingEndOfMonthDay(cal_type::end_of_month_day(year, wi.as_int()));   //original was the end of month -- force to last day of month   if (origDayOfMonth_ == -1) {     return date_type(year, wi.as_int(), resultingEndOfMonthDay) - d;   }   day_type dayOfMonth = origDayOfMonth_;   if (dayOfMonth > resultingEndOfMonthDay) {     dayOfMonth = resultingEndOfMonthDay;   }   return date_type(year, wi.as_int(), dayOfMonth) - d; }

int main(int argc, char** argv) {    QApplication app(argc, argv);    srand(time(0));    GameParams gp;    WindowInterface wi(gp);    //WindowInterface wi2(wi);    return app.exec();}

int InsetFormulaMacro::plaintext(odocstream & os, OutputParams const & runparams) const{	odocstringstream oss;	WriteStream wi(oss, false, true, WriteStream::wsDefault, runparams.encoding);	tmpl()->write(wi);	docstring const str = oss.str();	os << str;	return str.size();}

    inline sample sample_direction(std::uint64_t u0, std::uint64_t, const vector& wo) const    {      // try both bsdfs      auto reflected = reflection_.reflect(wo);      auto transmitted = transmission_.transmit(wo);      // compute the importance of either sample      float reflected_importance = luminance(reflected.throughput());      float transmitted_importance = luminance(transmitted.throughput());      // the probability of selecting the reflected direction is proportional to its importance      float reflected_probability = reflected_importance / (reflected_importance + transmitted_importance);      if(dist2d::u01f(u0) < reflected_probability)      {        return sample(reflected.wi(), reflected.throughput(), reflected_probability);      }      return sample(transmitted.wi(), transmitted.throughput(), 1.f - reflected_probability);    }

/* *  Constructor */CButCamCast::CButCamCast(const std::string & name,rviz::VisualizationManager * manager): Display( name, manager ), m_bPublish(true){  // Create and connect pane  rviz::WindowManagerInterface * wi( manager->getWindowManager() );  if( wi != 0 )  {    // Arm manipulation controls    m_pane = new CControllPane( wi->getParentWindow(), wxT("Screencasts manager"), wi);    if( m_pane != 0 )    {      wi->addPane( "Screencasts manager", m_pane );      wi->showPane( m_pane );      // Connect signal      m_pane->getSigChckBox().connect( boost::bind( &CButCamCast::onPublishStateChanged, this, _1) );      m_pane->getSigSave().connect( boost::bind( &CButCamCast::onSave, this, _1 ) );    }  }else{    std::cerr << "No window manager, no panes :( " << std::endl;  }  // Get node handle  ros::NodeHandle private_nh("/");  // Set parameters  // Get camera screencasting topic name  private_nh.param("rviz_screencast_topic_name", m_camCastPublisherName, CAMERA_SCREENCAST_TOPIC_NAME);  // Get timer period  private_nh.param("publishig_period", m_timerPeriod, DEFAULT_PUBLISHING_PERIOD );  // Get scene node  m_sceneNode = scene_manager_->getRootSceneNode()->createChildSceneNode();  // Create publisher  this->m_camCastPublisher = private_nh.advertise< sensor_msgs::Image >(m_camCastPublisherName, 100, false);  // Create geometry  createGeometry(private_nh);  // Create publishing timer  m_timer = private_nh.createTimer( ros::Duration(m_timerPeriod), boost::bind( &CButCamCast::onTimerPublish, this, _1) );  // Set publishing parameters  m_textureWithRtt->setFrame("/map");}

	Spectrum eval(const BSDFSamplingRecord &bRec, EMeasure measure) const {		if (!(bRec.typeMask & EDiffuseReflection) || measure != ESolidAngle			|| Frame::cosTheta(bRec.wi) <= 0			|| Frame::cosTheta(bRec.wo) <= 0)			return Spectrum(0.0f);		djb::dir wi(djb::vec3(bRec.wi.x, bRec.wi.y, bRec.wi.z));		djb::dir wo(djb::vec3(bRec.wo.x, bRec.wo.y, bRec.wo.z));		djb::vec3 value = m_sgd->evalp(wo, wi);		return Color3(value.x, value.y, value.z);	}

float blinnPhong(Vec3f camPos, Vec3f source, Vec3f vertex, Vec3f * triangle, float s){    Vec3f wi(source - vertex);    Vec3f wo(camPos - vertex);    Vec3f n = getNormalwithRayComes(triangle, -wo);    wi.normalize();    wo.normalize();    n.normalize();    Vec3f wh(wi + wo);    wh.normalize();    return pow(dot(n, wh),s);}

void AudioData::SaveToWavFile(std::string filename){	FILE *fp;	int bytes_per_sample = (use_stereo ? 4 : 2);	// Write 8/16-bit mono/stereo .wav file	fp = fopen(filename.c_str(), "wb");	fprintf(fp, "RIFF");	wl(fp, sample_count * bytes_per_sample + 36L);	fprintf(fp, "WAVEfmt ");	wl(fp, 16L);	wi(fp, 1);	wi(fp, use_stereo ? 2 : 1);	wl(fp, 0L + sample_freq_Hz);	wl(fp, 0L + sample_freq_Hz * bytes_per_sample);	wi(fp, bytes_per_sample);	wi(fp, 16);	fprintf(fp, "data");	wl(fp, sample_count * bytes_per_sample);	fwrite(samplebuffer.data(), bytes_per_sample, sample_count, fp);	fclose(fp);}

	Spectrum sample(BSDFSamplingRecord &bRec, const Point2 &sample) const {		if (!(bRec.typeMask & EDiffuseReflection) || Frame::cosTheta(bRec.wi) <= 0)			return Spectrum(0.0f);		bRec.wo = warp::squareToCosineHemisphere(sample);		bRec.eta = 1.0f;		bRec.sampledComponent = 0;		bRec.sampledType = EDiffuseReflection;		djb::vec3 wi(bRec.wi.x, bRec.wi.y, bRec.wi.z);		djb::vec3 wo(bRec.wo.x, bRec.wo.y, bRec.wo.z);		djb::vec3 brdf = m_tabular_anisotropic->eval(djb::dir(wi),djb::dir(wo));		return M_PI * Color3(brdf.x, brdf.y, brdf.z);	}

void WeaponChain::fromXml(XML& xml){	mTimeBetweenShots = xml.getFloat("time_between_shots");	XMLIterator it(&xml);	it.setElemName("weaponchain>weapon");	it.gotoZero();	while(it.gotoNext()==true){		WeaponInfo wi(&it.getElem());		/*wd.DLL = it.getElem().getString("dll");		wd.XML = it.getElem().getString("xml");		wd.mount = it.getElem().getString("mount");		mWeapon.push_back(wd);*/		mWeapon.push_back(wi);	}}

DirectionalLight loadDirectionalLight(        const Scene& scene,        const tinyxml2::XMLElement& elt) {    auto pExitantPower = elt.FirstChildElement("ExitantPower");    if(pExitantPower) {        Vec3f wi(0, 1, 0);        getChildAttribute(elt, "IncidentDirection", wi);        Vec3f exitantPower = zero<Vec3f>();        getChildAttribute(elt, "ExitantPower", exitantPower);        return DirectionalLight(wi, exitantPower, scene);    }    return { normalize(loadVector(elt)), loadColor(elt) };}

Spectrum<constant::spectrumSamples> PathBRDF::randomBRDFSampling(bool& randomBRDFsampled,                                                                 Spectrum<constant::spectrumSamples>& L,                                                                 const Vector3D& wo,                                                                 const MaterialBRDF& material,                                                                 const Intersection& intersection,                                                                 const TracerSpectrum& pathTracer,                                                                 const int bounce,                                                                 const BRDFType type) const {        Vector3D wi(INFINITY, INFINITY, INFINITY);        //Sample brdf of the give type.    Spectrum<constant::spectrumSamples> f = material.samplef(&wi, wo, intersection, type);        if(wi.x != INFINITY && wi.y != INFINITY && wi.z != INFINITY) {                //BRDF has been sampled.        randomBRDFsampled = true;                //Normalize wi.        wi.normalize();                //Get pdf of wi sampled from brdf.        float pdf = material.pdf(wi, wo, intersection, type);                Spectrum<constant::spectrumSamples> weight(0.0f);                //Check pdf to avoid 0/0 division (and NaN generation).        //A spectrum composed of NaN values could bend all samples        //during sum in Tracer classes.        if(pdf > 0.0f) {                        weight = (f * fabsf(wi.dot(intersection.normal))) / pdf;        } else {                        //Weight is 0, so all bounces will be useless.            return L;        }                //Setup new ray to be traced.        Ray newRay(MathUtils::addEpsilon(intersection.point, intersection.normal), wi);                //Rendering equation with recursive path tracing calculation.        L = L + weight * pathTracer.trace(newRay, bounce - 1);    }        return L;}

	Float *computeTransmittance(const char *name, Float ior, Float alpha, 			size_t resolution, Float &diffTrans, int inverted) {		Properties bsdfProps(alpha == 0 ? "dielectric" : "roughdielectric");		if (inverted) {			bsdfProps.setFloat("intIOR", 1.00);			bsdfProps.setFloat("extIOR", ior);		} else {			bsdfProps.setFloat("extIOR", 1.00);			bsdfProps.setFloat("intIOR", ior);		}		bsdfProps.setFloat("alpha", alpha);		bsdfProps.setString("distribution", name);		ref<BSDF> bsdf = static_cast<BSDF *>(				PluginManager::getInstance()->createObject(bsdfProps));		Float stepSize = 1.0f / (resolution-1);		Float error;		NDIntegrator intTransmittance(1, 2, 50000, 0, 1e-6f);		NDIntegrator intDiffTransmittance(1, 1, 50000, 0, 1e-6f);		Float *transmittances = new Float[resolution];		for (size_t i=0; i<resolution; ++i) {			Float t = i * stepSize;			if (i == 0) /* Don't go all the way to zero */				t = stepSize/10;				Float cosTheta = std::pow(t, (Float) 4.0f);			Vector wi(std::sqrt(std::max((Float) 0, 					1-cosTheta*cosTheta)), 0, cosTheta);			Float min[2] = {0, 0}, max[2] = {1, 1};			intTransmittance.integrateVectorized(				boost::bind(&transmittanceIntegrand, bsdf, wi, _1, _2, _3),				min, max, &transmittances[i], &error, NULL);		}		Float min[1] = { 0 }, max[1] = { 1 };		intDiffTransmittance.integrateVectorized(			boost::bind(&diffTransmittanceIntegrand, transmittances, resolution, _1, _2, _3),			min, max, &diffTrans, &error, NULL);		if (alpha == 0.0f)			cout << diffTrans << " vs " << 1-fresnelDiffuseReflectance(inverted ? (1.0f / ior) : ior) << endl;		return transmittances;	}

 inline  void gees (char const jobvs, char const sort, logical_t* select, int const n,            double* a, int const lda, int& sdim, traits::complex_d* w,            double* vs, int const ldvs, double* work, int const lwork,            bool* bwork, int& info)  {   traits::detail::array<double> wr(n);   traits::detail::array<double> wi(n);   LAPACK_DGEES (&jobvs, &sort, select, &n, a, &lda, &sdim,                 traits::vector_storage(wr), traits::vector_storage(wi),                 vs, &ldvs, work, &lwork, bwork, &info);   traits::detail::interlace(traits::vector_storage(wr),                             traits::vector_storage(wr)+n,                             traits::vector_storage(wi),                             w); }