accel.cc:	bbox = primitives[0]->BoundWorldSpace();
accel.cc:		bbox = Union(bbox, primitives[i]->BoundWorldSpace());
accel.cc:		int lastPrim = primitivesToProcess.size() - 1;
accel.cc:		if (prim->CanIntersect())
accel.cc:			prim->Refine(&refined);
accel.cc:	Float dx = 1.00001 * (bbox.pMax.x - bbox.pMin.x);
accel.cc:	Float dy = 1.00001 * (bbox.pMax.y - bbox.pMin.y);
accel.cc:	Float dz = 1.00001 * (bbox.pMax.z - bbox.pMin.z);
accel.cc:		BBox primBounds = primitives[i]->BoundWorldSpace();
accel.cc:		int x1 = min(x2v(primBounds.pMax.x), XVoxels - 1);
accel.cc:		int y1 = min(y2v(primBounds.pMax.y), YVoxels - 1);
accel.cc:		int z1 = min(z2v(primBounds.pMax.z), ZVoxels - 1);
accel.cc:		x--;
accel.cc:		OutX = -1;
accel.cc:		NextXCrossing = rayT + (v2x(x + 1) - gridIntersect.x) / ray.D.x;
accel.cc:		NextXCrossing = rayT + (v2x(x) - gridIntersect.x) / ray.D.x;
accel.cc:		DeltaX = -XWidth / ray.D.x;
accel.cc:		StepX = -1;
accel.cc:		OutX = -1;
accel.cc:		y--;
accel.cc:		NextYCrossing = rayT + (v2y(y) - gridIntersect.y) / ray.D.y;
accel.cc:		DeltaY = -YWidth / ray.D.y;
accel.cc:		StepY = OutY = -1;
accel.cc:		NextYCrossing = rayT + (v2y(y + 1) - gridIntersect.y) / ray.D.y;
accel.cc:		z--;
accel.cc:		NextZCrossing = rayT + (v2z(z) - gridIntersect.z) / ray.D.z;
accel.cc:		DeltaZ = -ZWidth / ray.D.z;
accel.cc:		StepZ = OutZ = -1;
accel.cc:		NextZCrossing = rayT + (v2z(z + 1) - gridIntersect.z) / ray.D.z;
accel.cc:		if (primitiveList->size() > 0) {
accel.cc:			list < Primitive * >::iterator iter = primitiveList->begin();
accel.cc:			while (iter != primitiveList->end()) {
accel.cc:					&(prim->attributes->WorldToObject);
accel.cc:				if (prim->IntersectClosest(rayObj, mint, maxt, hitInfo)) {
accel.cc::	bounds(Union(child1->bounds, child2->bounds))
accel.cc:		bboxes[i] = primitives[i]->BoundWorldSpace();
accel.cc:	Float dx = bounds.pMax.x - bounds.pMin.x;
accel.cc:	Float dy = bounds.pMax.y - bounds.pMin.y;
accel.cc:	Float dz = bounds.pMax.z - bounds.pMin.z;
accel.cc:		Point Pcenter = 0.5 * primitives[i].second->pMin +
accel.cc:			0.5 * primitives[i].second->pMax;
accel.cc:			if (primitives[i].second->pMax.x < pmid) {
accel.cc:			} else if (primitives[i].second->pMin.x > pmid) {
accel.cc:			if (primitives[i].second->pMax.y < pmid) {
accel.cc:			} else if (primitives[i].second->pMin.y > pmid) {
accel.cc:			if (primitives[i].second->pMax.z < pmid) {
accel.cc:			} else if (primitives[i].second->pMin.z > pmid) {
accel.cc://  int ranitem = random() % (end-start);
accel.cc:	if (!node->bounds.Inside(ray(mint)) &&
accel.cc:		(!node->bounds.IntersectP(ray, &hitt) || hitt < mint))
accel.cc:	if (node->isLeaf) {
accel.cc:		Ray rayo = (node->primitive->attributes->WorldToObject) (ray);
accel.cc:		if (node->primitive->CanIntersect())
accel.cc:			return node->primitive->IntersectClosest(rayo, mint, maxt,
accel.cc:			node->primitive->Refine(&refined);
accel.cc:		Assert(node->children[0] && node->children[1]);
accel.cc:			RecursiveIntersect(node->children[0], ray, mint, maxt, hit);
accel.cc:		if (RecursiveIntersect(node->children[1], ray, mint, maxt, hit))
api.cc:#define TOKEN_TYPE_ERROR       -1
api.cc:		if (strcmp(iter->first, name) == 0)
api.cc:			return iter->first;
api.cc:		const char *end = &name[strlen(name) - 1];
api.cc:			--end;
api.cc:		char *buf = (char *) alloca(end - name + 1);
api.cc:		strncpy(buf, name, end - name);
api.cc:		buf[end - name] = '\0';
api.cc:		if (iter->first == name) {
api.cc:			*token = iter->first;
api.cc:			*type = iter->second;
api.cc:		if (strcmp(iter->first, name) == 0) {
api.cc:			*token = iter->first;
api.cc:			*type = iter->second;
api.cc:		Severe("Token %s declared to be non-uniform float type %s",
api.cc:					surffunc->AddUniformFloat(token, (Float *) params[i]);
api.cc:					surffunc->AddUniformPoint(token, (Float *) params[i]);
api.cc:					surffunc->AddUniformHPoint(token, (Float *) params[i]);
api.cc:					surffunc->AddUniformVector(token, (Float *) params[i]);
api.cc:					surffunc->AddUniformNormal(token, (Float *) params[i]);
api.cc:					surffunc->AddUniformColor(token, (Float *) params[i]);
api.cc:					surffunc->AddUniformString(token,
api.cc:					surffunc->AddVertexFloat(token, (Float *) params[i]);
api.cc:					surffunc->AddVertexPoint(token, (Float *) params[i]);
api.cc:					surffunc->AddVertexHPoint(token, (Float *) params[i]);
api.cc:					surffunc->AddVertexVector(token, (Float *) params[i]);
api.cc:					surffunc->AddVertexNormal(token, (Float *) params[i]);
api.cc:					surffunc->AddVertexColor(token, (Float *) params[i]);
api.cc:	if (curPrimitiveAttributes->LightShader)
api.cc:		curPrimitiveAttributes->LightShader->SetGeometry(prim);
api.cc:	scene->AddPrimitives(primitives);
api.cc:	scene->Render();
api.cc:	curPrimitiveAttributes->Dereference();
api.cc:	curMaterialAttributes->Dereference();
api.cc:		if (strcmp(iter->first, name) == 0) {
api.cc:			if (iter->second != tokenType) {
api.cc:				typeToString(iter->second, str1);
api.cc:			return iter->first;
api.cc:	curLightAttributes->Dereference();
api.cc:		scene->camera->WorldToCamera[i] = curTransform[i];
api.cc:	curPrimitiveAttributes->Surface =
api.cc:	scene->sampler->PixelSamples[0] = max((Float) 1., x);
api.cc:	scene->sampler->PixelSamples[1] = max((Float) 1., y);
api.cc:	scene->image->XResolution = x;
api.cc:	scene->image->YResolution = y;
api.cc:	scene->image->PixelAspectRatio = pixelAspect;
api.cc:	scene->image->FrameAspectRatio = x * pixelAspect / y;
api.cc:	if (scene->image->FrameAspectRatio >= 1) {
api.cc:		scene->camera->ScreenLeft = -scene->image->FrameAspectRatio;
api.cc:		scene->camera->ScreenRight = scene->image->FrameAspectRatio;
api.cc:		scene->camera->ScreenBottom = -1;
api.cc:		scene->camera->ScreenTop = 1;
api.cc:		scene->camera->ScreenLeft = -1;
api.cc:		scene->camera->ScreenRight = 1;
api.cc:		scene->camera->ScreenBottom = -1. / scene->image->FrameAspectRatio;
api.cc:		scene->camera->ScreenTop = 1. / scene->image->FrameAspectRatio;
api.cc:	scene->image->FrameAspectRatio = aspect;
api.cc:	scene->camera->ScreenLeft = left;
api.cc:	scene->camera->ScreenRight = right;
api.cc:	scene->camera->ScreenBottom = bottom;
api.cc:	scene->camera->ScreenTop = top;
api.cc:	scene->image->CropLeft = left;
api.cc:	scene->image->CropRight = right;
api.cc:	scene->image->CropBottom = bottom;
api.cc:	scene->image->CropTop = top;
api.cc:	scene->camera->ClipHither = hither;
api.cc:	scene->camera->ClipYon = yon;
api.cc:	scene->camera->ShutterStart = time0;
api.cc:	scene->camera->ShutterEnd = time1;
api.cc:	scene->camera->FStop = fstop;
api.cc:	scene->camera->FocalLength = focallen;
api.cc:	scene->camera->FocalDistance = focaldist;
api.cc:		scene->camera->CameraToScreen = curTransform[0] *
api.cc:			Orthographic(scene->camera->ClipHither,
api.cc:						 scene->camera->ClipYon);
api.cc:		scene->camera->ProjectionType = Camera::Orthographic;
api.cc:		scene->camera->CameraToScreen = curTransform[0] *
api.cc:			Perspective(fov, 1. / scene->image->PixelAspectRatio,
api.cc:						scene->camera->ClipHither,
api.cc:						scene->camera->ClipYon) * Scale(-1, -1, 1);
api.cc:		scene->camera->ProjectionType = Camera::Perspective;
api.cc:		scene->camera->CameraToScreen = curTransform[0];
api.cc:		scene->camera->ProjectionType = Camera::Perspective;	// guess
api.cc:	scene->image->Gain = gain;
api.cc:	scene->image->Gamma = gamma;
api.cc:	scene->sampler->Filter = filter;
api.cc:	scene->sampler->FilterXWidth = xwidth;
api.cc:	scene->sampler->FilterYWidth = ywidth;
api.cc:	scene->image->Imager = name;
api.cc:		scene->image->ColorQuantOne = one;
api.cc:		scene->image->ColorQuantMin = minimum;
api.cc:		scene->image->ColorQuantMax = maximum;
api.cc:		scene->image->ColorQuantDither = ditheramp;
api.cc:		scene->image->DepthQuantOne = one;
api.cc:		scene->image->DepthQuantMin = minimum;
api.cc:		scene->image->DepthQuantMax = maximum;
api.cc:		scene->image->DepthQuantDither = ditheramp;
api.cc:	scene->image->DisplayType = type;
api.cc:	scene->image->DisplayName = Strdup(name);
api.cc:	scene->image->DisplayMode = displayMode;
api.cc:				scene->sampler->JitterSamples = on;
api.cc:				scene->image->ImageViewer = Strdup(arr[0]);
api.cc:					scene->IlluminationIntegrator = LRT_COLOR;
api.cc:					scene->IlluminationIntegrator = LRT_RAYCAST;
api.cc:					scene->IlluminationIntegrator = LRT_WHITTED;
api.cc:					scene->IlluminationIntegrator = LRT_MONTECARLO;
api.cc:					scene->IlluminationIntegrator = LRT_RMAN;
api.cc:					delete scene->camera;
api.cc:					scene->camera = new PinholeCamera;
api.cc:					delete scene->camera;
api.cc:					scene->camera = new MbDOFCamera;
api.cc:					scene->camera->ShutterType = LRT_IRIS;
api.cc:					scene->camera->ShutterType = LRT_STRIPE;
api.cc:				scene->camera->IrisRate = param;
api.cc:				scene->camera->StripeWidth = param;
api.cc:					scene->camera->StripeDirection = LRT_DOWN;
api.cc:					scene->camera->StripeDirection = LRT_UP;
api.cc:					scene->camera->StripeDirection = LRT_LEFT;
api.cc:					scene->camera->StripeDirection = LRT_RIGHT;
api.cc:	curPrimitiveAttributes->Dereference();
api.cc:	curLightAttributes->Dereference();
api.cc:	curMaterialAttributes->Dereference();
api.cc:	if (curPrimitiveAttributes->GetReferences() > 1) {
api.cc:		curPrimitiveAttributes->Dereference();
api.cc:	curPrimitiveAttributes->Color = Spectrum(Cs[0], Cs[1], Cs[2]);
api.cc:	if (curPrimitiveAttributes->GetReferences() > 1) {
api.cc:		curPrimitiveAttributes->Dereference();
api.cc:	curPrimitiveAttributes->Opacity = Spectrum(Cs[0], Cs[1], Cs[2]);
api.cc:					if (curLightAttributes->GetReferences() > 1) {
api.cc:						curLightAttributes->Dereference();
api.cc:					curLightAttributes->CastsShadows = true;
api.cc:					if (curLightAttributes->GetReferences() > 1) {
api.cc:						curLightAttributes->Dereference();
api.cc:					curLightAttributes->CastsShadows = false;
api.cc:					if (curLightAttributes->GetReferences() > 1) {
api.cc:						curLightAttributes->Dereference();
api.cc:					curLightAttributes->NSamples = int (count);
api.cc:				if (curPrimitiveAttributes->GetReferences() > 1) {
api.cc:					curPrimitiveAttributes->Dereference();
api.cc:					curPrimitiveAttributes->Sampling =
api.cc:					curPrimitiveAttributes->Sampling =
api.cc:					curPrimitiveAttributes->Sampling =
api.cc:	if (curTransform[0] != curMaterialAttributes->WorldToSurface &&
api.cc:		curMaterialAttributes->GetReferences() > 1) {
api.cc:		curMaterialAttributes->Dereference();
api.cc:	curMaterialAttributes->SurfaceToWorld = curTransform[0];
api.cc:	curMaterialAttributes->WorldToSurface =
api.cc:	curMaterialAttributes->Reference();
api.cc:	if (curPrimitiveAttributes->GetReferences() > 1) {
api.cc:		curPrimitiveAttributes->Dereference();
api.cc:	curPrimitiveAttributes->Surface = MaterialCreate(name, surfData);
api.cc:															scene->camera->
api.cc:															scene->camera->
api.cc:	if ((curTransform[0] != curPrimitiveAttributes->WorldToObject ||
api.cc:		 lights != curPrimitiveAttributes->Lights) &&
api.cc:		curPrimitiveAttributes->GetReferences() > 1) {
api.cc:		curPrimitiveAttributes->Dereference();
api.cc:	curPrimitiveAttributes->ObjectToWorld = curTransform[0];
api.cc:	curPrimitiveAttributes->WorldToObject =
api.cc:	curPrimitiveAttributes->Lights = lights;
api.cc:	curPrimitiveAttributes->Reference();
api.cc:	RtInt *indices = new RtInt[3 * (nverts - 2)];
api.cc:	for (int i = 0; i < nverts - 2; i++) {
api.cc:	AddPrimitive(new TriangleMesh(nverts - 2, nverts, indices, P,
api.cc:	if ((curTransform[0] != curPrimitiveAttributes->WorldToObject ||
api.cc:		 lights != curPrimitiveAttributes->Lights) &&
api.cc:		curPrimitiveAttributes->GetReferences() > 1) {
api.cc:		curPrimitiveAttributes->Dereference();
api.cc:	curPrimitiveAttributes->ObjectToWorld = curTransform[0];
api.cc:	curPrimitiveAttributes->WorldToObject =
api.cc:	curPrimitiveAttributes->Lights = lights;
api.cc:	curPrimitiveAttributes->Reference();
api.cc:		nIndices += 3 * (nvertices[i] - 2);
api.cc:		for (int j = 0; j < nvertices[i] - 2; j++) {
api.cc:	if ((curTransform[0] != curPrimitiveAttributes->WorldToObject ||
api.cc:		 lights != curPrimitiveAttributes->Lights) &&
api.cc:		curPrimitiveAttributes->GetReferences() > 1) {
api.cc:		curPrimitiveAttributes->Dereference();
api.cc:	curPrimitiveAttributes->ObjectToWorld = curTransform[0];
api.cc:	curPrimitiveAttributes->WorldToObject =
api.cc:	curPrimitiveAttributes->Lights = lights;
api.cc:	curPrimitiveAttributes->Reference();
api.cc:	if ((curTransform[0] != curPrimitiveAttributes->WorldToObject ||
api.cc:		 lights != curPrimitiveAttributes->Lights) &&
api.cc:		curPrimitiveAttributes->GetReferences() > 1) {
api.cc:		curPrimitiveAttributes->Dereference();
api.cc:	curPrimitiveAttributes->ObjectToWorld = curTransform[0];
api.cc:	curPrimitiveAttributes->WorldToObject =
api.cc:	curPrimitiveAttributes->Lights = lights;
api.cc:	curPrimitiveAttributes->Reference();
api.cc:	if (curPrimitiveAttributes->LightShader)
api.cc:		if ((curTransform[0] != curPrimitiveAttributes->WorldToObject ||
api.cc:			 lights != curPrimitiveAttributes->Lights) &&
api.cc:			curPrimitiveAttributes->GetReferences() > 1) {
api.cc:			curPrimitiveAttributes->Dereference();
api.cc:		curPrimitiveAttributes->ObjectToWorld = curTransform[0];
api.cc:		curPrimitiveAttributes->WorldToObject =
api.cc:		curPrimitiveAttributes->Lights = lights;
api.cc:		curPrimitiveAttributes->Reference();
api.cc:	if ((curTransform[0] != curPrimitiveAttributes->WorldToObject ||
api.cc:		 lights != curPrimitiveAttributes->Lights) &&
api.cc:		curPrimitiveAttributes->GetReferences() > 1) {
api.cc:		curPrimitiveAttributes->Dereference();
api.cc:	curPrimitiveAttributes->ObjectToWorld = curTransform[0];
api.cc:	curPrimitiveAttributes->WorldToObject =
api.cc:	curPrimitiveAttributes->Lights = lights;
api.cc:	curPrimitiveAttributes->Reference();
api.cc:	if ((curTransform[0] != curPrimitiveAttributes->WorldToObject ||
api.cc:		 lights != curPrimitiveAttributes->Lights) &&
api.cc:		curPrimitiveAttributes->GetReferences() > 1) {
api.cc:		curPrimitiveAttributes->Dereference();
api.cc:	curPrimitiveAttributes->ObjectToWorld = curTransform[0];
api.cc:	curPrimitiveAttributes->WorldToObject =
api.cc:	curPrimitiveAttributes->Lights = lights;
api.cc:	curPrimitiveAttributes->Reference();
api.cc:	if ((curTransform[0] != curPrimitiveAttributes->WorldToObject ||
api.cc:		 lights != curPrimitiveAttributes->Lights) &&
api.cc:		curPrimitiveAttributes->GetReferences() > 1) {
api.cc:		curPrimitiveAttributes->Dereference();
api.cc:	curPrimitiveAttributes->ObjectToWorld = curTransform[0];
api.cc:	curPrimitiveAttributes->WorldToObject =
api.cc:	curPrimitiveAttributes->Lights = lights;
api.cc:	curPrimitiveAttributes->Reference();
api.cc:	if ((curTransform[0] != curPrimitiveAttributes->WorldToObject ||
api.cc:		 lights != curPrimitiveAttributes->Lights) &&
api.cc:		curPrimitiveAttributes->GetReferences() > 1) {
api.cc:		curPrimitiveAttributes->Dereference();
api.cc:	curPrimitiveAttributes->ObjectToWorld = curTransform[0];
api.cc:	curPrimitiveAttributes->WorldToObject =
api.cc:	curPrimitiveAttributes->Lights = lights;
api.cc:	curPrimitiveAttributes->Reference();
api.cc:	if (curTransform[0] != curLightAttributes->WorldToLight &&
api.cc:		curLightAttributes->GetReferences() > 1) {
api.cc:		curLightAttributes->Dereference();
api.cc:	curLightAttributes->LightToWorld = curTransform[0];
api.cc:	curLightAttributes->WorldToLight =
api.cc:	curLightAttributes->Reference();
api.cc:		curLightAttributes->Dereference();
api.cc:	if (curTransform[0] != curLightAttributes->WorldToLight &&
api.cc:		curLightAttributes->GetReferences() > 1) {
api.cc:		curLightAttributes->Dereference();
api.cc:	curLightAttributes->LightToWorld = curTransform[0];
api.cc:	curLightAttributes->WorldToLight =
api.cc:	curLightAttributes->Reference();
api.cc:	if (curPrimitiveAttributes->GetReferences() > 1) {
api.cc:		curPrimitiveAttributes->Dereference();
api.cc:	curPrimitiveAttributes->LightShader = lt;
api.cc:		curLightAttributes->Dereference();
api.cc:		Error("Trying to de-Illuminate an unknown light!");
camera.cc:	ScreenLeft = -4. / 3.;
camera.cc:	ScreenBottom = -1;
camera.cc:	ClipHither = 1e-2;
camera.cc:		Scale(scene->image->XResolution, scene->image->YResolution, 1.) *
camera.cc:		Scale(1, -1, 1) *
camera.cc:		Scale(1. / (ScreenRight - ScreenLeft),
camera.cc:			  1. / (ScreenTop - ScreenBottom), 1.) *
camera.cc:		Translate(Vector(-ScreenLeft, -ScreenTop, 0.));
camera.cc:	if (sample[0] < scene->image->SampleCropLeft ||
camera.cc:		sample[0] > scene->image->SampleCropRight ||
camera.cc:		sample[1] < scene->image->SampleCropBottom ||
camera.cc:		sample[1] > scene->image->SampleCropTop) return false;
geometry.cc:	Float tNear = (pMin.x - ray.O.x) * invRayDir;
geometry.cc:	Float tFar = (pMax.x - ray.O.x) * invRayDir;
geometry.cc:	tNear = (pMin.y - ray.O.y) * invRayDir;
geometry.cc:	tFar = (pMax.y - ray.O.y) * invRayDir;
geometry.cc:	tNear = (pMin.z - ray.O.z) * invRayDir;
geometry.cc:	tFar = (pMax.z - ray.O.z) * invRayDir;
heightfield.cc:	int ntris = 2 * (nx - 1) * (ny - 1);
heightfield.cc:			P[pos].x = (float) x / (float) (nx - 1);
heightfield.cc:			P[pos].y = (float) y / (float) (ny - 1);
heightfield.cc:	for (y = 0; y < ny - 1; ++y) {
heightfield.cc:		for (x = 0; x < nx - 1; ++x) {
heightfield.cc:	refined->push_back(new TriangleMesh(ntris, nx * ny, verts, P,
image.cc:		Clamp(RasterCropLeft - scene->sampler->FilterXWidth, 0.,
image.cc:		Clamp(RasterCropRight + scene->sampler->FilterXWidth, 0.,
image.cc:		Clamp(RasterCropBottom - scene->sampler->FilterYWidth, 0.,
image.cc:		Clamp(RasterCropTop + scene->sampler->FilterYWidth, 0.,
image.cc:		(int) Clamp(ceil(XResolution * CropRight), 0, XResolution) - XBase;
image.cc:		(int) Clamp(ceil(YResolution * CropTop), 0, YResolution) - YBase;
image.cc:	int offset = (y - YBase) * XWidth + (x - XBase);
image.cc:		if (execlp(ImageViewer, ImageViewer, DisplayName, NULL) == -1) {
image.cc:			Round(pixels[i] * one + RandomFloat(-ditheramp, ditheramp));
image.cc:	Float HalfXWidth = scene->sampler->FilterXWidth / 2.;
image.cc:	Float HalfYWidth = scene->sampler->FilterYWidth / 2.;
image.cc:	int x0 = max((int) ceil(Praster.x - HalfXWidth), XBase);
image.cc:	int y0 = max((int) ceil(Praster.y - HalfYWidth), YBase);
image.cc:			Float fx = x - Praster.x;
image.cc:			Float fy = y - Praster.y;
image.cc:				scene->sampler->Filter(fx, fy, XWidth, YWidth);
image.cc:			int offset = (y - YBase) * XWidth + (x - XBase);
light.cc:	attributes->Dereference();
light.cc:	lightPos = surfaceFunction->InitializePoint(RI_FROM, Point(0, 0, 0));
light.cc:	lightPos = attr->LightToWorld(lightPos);
light.cc:	Spectrum lightColor = surfaceFunction->InitializeColor(RI_LIGHTCOLOR,
light.cc:	Float intensity = surfaceFunction->InitializeFloat(RI_INTENSITY, 1.0);
light.cc:	pFrom = surfaceFunction->InitializePoint(RI_FROM, Point(0, 0, 0));
light.cc:	pTo = surfaceFunction->InitializePoint(RI_TO, Point(0, 0, 1));
light.cc:	pFrom = attr->LightToWorld(pFrom);
light.cc:	pTo = attr->LightToWorld(pTo);
light.cc:	lightDir = (pFrom - pTo).Hat();
light.cc:	Spectrum lightColor = surfaceFunction->InitializeColor(RI_LIGHTCOLOR,
light.cc:	Float intensity = surfaceFunction->InitializeFloat(RI_INTENSITY, 1.0);
light.cc:	Spectrum lightColor = surfaceFunction->InitializeColor(RI_LIGHTCOLOR,
light.cc:	Float intensity = surfaceFunction->InitializeFloat(RI_INTENSITY, 1.0);
light.cc:	attributes->Dereference();
light.cc:	pFrom = surfaceFunction->InitializePoint(RI_FROM, Point(0, 0, 0));
light.cc:	pTo = surfaceFunction->InitializePoint(RI_TO, Point(0, 0, 1));
light.cc:	pFrom = attr->LightToWorld(pFrom);
light.cc:	pTo = attr->LightToWorld(pTo);
light.cc:	lightDir = (pFrom - pTo).Hat();
light.cc:		Radians(surfaceFunction->InitializeFloat(RI_CONEANGLE, 30.));
light.cc:		Radians(surfaceFunction->InitializeFloat(RI_CONEDELTAANGLE, 5.));
light.cc:		surfaceFunction->InitializeFloat(RI_BEAMDISTRIBUTION, 2.0);
light.cc:	Spectrum lightColor = surfaceFunction->InitializeColor(RI_LIGHTCOLOR,
light.cc:	Float intensity = surfaceFunction->InitializeFloat(RI_INTENSITY, 1.0);
light.cc:	Float cosangle = max(Dot((pFrom - Ps).Hat(), lightDir), (Float) 0.);
light.cc:						cos(coneAngle - coneDeltaAngle), cosangle);
light.cc:	Spectrum lightColor = surfaceFunction->InitializeColor(RI_LIGHTCOLOR,
light.cc:	Float intensity = surfaceFunction->InitializeFloat(RI_INTENSITY, 1.0);
light.cc:	Float pdf = primitive->Sample(u, &hitInfo);
light.cc:		*Plight = primitive->attributes->ObjectToWorld(hitInfo.Pobj);
light.cc:		Normal N = primitive->attributes->ObjectToWorld(hitInfo.NgObj);
light.cc:		Float costhetao = fabs(Dot(N.Hat(), (Pshade - *Plight).Hat()));
lrt.cc:		ParseRIB("-");
nurbs.cc:	int firstKnot = order - 1;
nurbs.cc:	int cpOffset = knotOffset - order + 1;
nurbs.cc:	for (int i = 0; i < order - 2; ++i)
nurbs.cc:		for (int j = 0; j < order - 1 - i; ++j) {
nurbs.cc:			alpha = (knot[1 + j] - t) /
nurbs.cc:				(knot[1 + j] - knot[j + 2 - order + i]);
nurbs.cc:				cpWork[j].x * alpha + cpWork[j + 1].x * (1. - alpha);
nurbs.cc:				cpWork[j].y * alpha + cpWork[j + 1].y * (1. - alpha);
nurbs.cc:				cpWork[j].z * alpha + cpWork[j + 1].z * (1. - alpha);
nurbs.cc:				cpWork[j].w * alpha + cpWork[j + 1].w * (1. - alpha);
nurbs.cc:	alpha = (knot[1] - t) / (knot[1] - knot[0]);
nurbs.cc:	Homogeneous3 val(cpWork[0].x * alpha + cpWork[1].x * (1. - alpha),
nurbs.cc:					 cpWork[0].y * alpha + cpWork[1].y * (1. - alpha),
nurbs.cc:					 cpWork[0].z * alpha + cpWork[1].z * (1. - alpha),
nurbs.cc:					 cpWork[0].w * alpha + cpWork[1].w * (1. - alpha));
nurbs.cc:		float factor = (order - 1) / (knot[1] - knot[0]);
nurbs.cc:		Homogeneous3 delta((cpWork[1].x - cpWork[0].x) * factor,
nurbs.cc:						   (cpWork[1].y - cpWork[0].y) * factor,
nurbs.cc:						   (cpWork[1].z - cpWork[0].z) * factor,
nurbs.cc:						   (cpWork[1].w - cpWork[0].w) * factor);
nurbs.cc:		deriv->x = delta.x / val.w - (val.x * delta.w / (val.w * val.w));
nurbs.cc:		deriv->y = delta.y / val.w - (val.y * delta.w / (val.w * val.w));
nurbs.cc:		deriv->z = delta.z / val.w - (val.z * delta.w / (val.w * val.w));
nurbs.cc:	int uFirstCp = uOffset - uOrder + 1;
nurbs.cc:	assert(uFirstCp >= 0 && uFirstCp + uOrder - 1 < ucp);
nurbs.cc:	int vFirstCp = vOffset - vOrder + 1;
nurbs.cc:	assert(vFirstCp >= 0 && vFirstCp + vOrder - 1 < vcp);
nurbs.cc:	Homogeneous3 P = NURBSEvaluate(uOrder, uKnot, iso - uFirstCp, ucp,
nurbs.cc:		(void) NURBSEvaluate(vOrder, vKnot, iso - vFirstCp, vcp, 1, v,
nurbs.cc:		Point pt = attributes->ObjectToWorld(Point(pp[0], pp[1], pp[2]));
nurbs.cc:			pt = attributes->ObjectToWorld(Point(pp[0], pp[1], pp[2]));
nurbs.cc:		Point pt = attributes->ObjectToWorld(Point(pp[0] / pp[3],
nurbs.cc:			pt = attributes->ObjectToWorld(Point(pp[0] / pp[3],
nurbs.cc:		ueval[i] = Lerp((Float) i / (Float) (diceu - 1), umin, umax);
nurbs.cc:		veval[i] = Lerp((Float) i / (Float) (dicev - 1), vmin, vmax);
nurbs.cc:	int nTris = 2 * (diceu - 1) * (dicev - 1);
nurbs.cc:	for (int v = 0; v < dicev - 1; ++v) {
nurbs.cc:		for (int u = 0; u < diceu - 1; ++u) {
nurbs.cc:	refined->push_back(new TriangleMesh(nTris, diceu * dicev, vertices,
primitives.cc:	attributes->Dereference();
primitives.cc:	return attributes->ObjectToWorld(BoundObjectSpace());
primitives.cc:	// hitInfo->RecordHit(P, N, uu,
primitives.cc:	// hitInfo->RecordHit(P, N, uu,
primitives.cc:	// hitInfo->RecordHit(P, N, uu,
primitives.cc:	return interpolatedData->GetPoint(token);
primitives.cc:	const Float *ret = hitPrim->surfaceFunction->GetUniformFloat(token);
primitives.cc:	return interpolatedData->GetFloat(token);
primitives.cc:	const Vector *ret = hitPrim->surfaceFunction->GetUniformVector(token);
primitives.cc:	return interpolatedData->GetVector(token);
primitives.cc:	const Normal *ret = hitPrim->surfaceFunction->GetUniformNormal(token);
primitives.cc:	return interpolatedData->GetNormal(token);
primitives.cc:	const Spectrum *ret = hitPrim->surfaceFunction->GetUniformColor(token);
primitives.cc:	return interpolatedData->GetColor(token);
primitives.cc:	return hitPrim->surfaceFunction->GetUniformString(token);
quadrics.cc:	zmin = Clamp(min(z0, z1), -radius, radius);
quadrics.cc:	zmax = Clamp(max(z0, z1), -radius, radius);
quadrics.cc:	return BBox(Point(-radius, -radius, zmin),
quadrics.cc:		ray.O.z * ray.O.z - radius * radius;
quadrics.cc:	Float discrim = B * B - 4. * A * C;
quadrics.cc:	Float t0 = (-B - rootDiscrim) * inv2A;
quadrics.cc:	Float t1 = (-B + rootDiscrim) * inv2A;
quadrics.cc:	phi = acos(-Phit.z / radius);
quadrics.cc:		Float val = Clamp(Phit.x / (radius * sin(phi)), -1, 1);
quadrics.cc:			u = 1 - theta;
quadrics.cc:		phi = acos(-Phit.z / radius);
quadrics.cc:			Float val = Clamp(Phit.x / (radius * sin(phi)), -1, 1);
quadrics.cc:				u = 1 - theta;
quadrics.cc:		Float vmin = acos(-zmin / radius);
quadrics.cc:		Float vmax = acos(-zmax / radius);
quadrics.cc:		v = (v * M_PI - vmin) / (vmax - vmin);
quadrics.cc:		Normal surfNorm = Normal(Phit - Point(0, 0, 0));
quadrics.cc:		hit->RecordHit(Phit, surfNorm, u, v, this);
quadrics.cc:			{ u * v, (1. - u) * v, u * (1. - v), (1. - u) * (1. - v) };
quadrics.cc:		interpolatedData = surfaceFunction->Interpolate(4,
quadrics.cc:		hit->SetInterpolatedData(interpolatedData);
quadrics.cc:	Point p1 = Point(-radius, -radius, zmin);
quadrics.cc:	Float C = ray.O.x * ray.O.x + ray.O.y * ray.O.y - radius * radius;
quadrics.cc:	Float discrim = B * B - 4. * A * C;
quadrics.cc:	Float t0 = (-B - rootDiscrim) * inv2A;
quadrics.cc:	Float t1 = (-B + rootDiscrim) * inv2A;
quadrics.cc:	u = 1. - (atan2(Phit.y, -Phit.x) + M_PI) / thetaMax;
quadrics.cc:	v = (Phit.z - zmin) / (zmax - zmin);
quadrics.cc:		u = 1. - (atan2(Phit.y, -Phit.x) + M_PI) / thetaMax;
quadrics.cc:		v = (Phit.z - zmin) / (zmax - zmin);
quadrics.cc:		Normal surfNorm = Normal(Phit - Point(0, 0, Phit.z));
quadrics.cc:		hit->RecordHit(Phit, surfNorm, u, v, this);
quadrics.cc:	Point p1 = Point(-radius, -radius, 0);
quadrics.cc:		ray.D.y * ray.D.y - k * ray.D.z * ray.D.z;
quadrics.cc:				   ray.D.y * ray.O.y - k * ray.D.z * (ray.O.z - height));
quadrics.cc:		ray.O.y * ray.O.y - k * (ray.O.z - height) * (ray.O.z - height);
quadrics.cc:	Float discrim = B * B - 4. * A * C;
quadrics.cc:	Float t0 = (-B - rootDiscrim) * inv2A;
quadrics.cc:	Float t1 = (-B + rootDiscrim) * inv2A;
quadrics.cc:	u = 1. - (atan2(Phit.y, -Phit.x) + M_PI) / thetaMax;
quadrics.cc:		u = 1. - (atan2(Phit.y, -Phit.x) + M_PI) / thetaMax;
quadrics.cc:		hit->RecordHit(Phit, surfNormal, u, v, this);
quadrics.cc:	Point p1 = Point(-radius, -radius, zmin);
quadrics.cc:	Float B = 2 * k * (ray.D.x * ray.O.x + ray.D.y * ray.O.y) - ray.D.z;
quadrics.cc:	Float C = k * (ray.O.x * ray.O.x + ray.O.y * ray.O.y) - ray.O.z;
quadrics.cc:	Float discrim = B * B - 4. * A * C;
quadrics.cc:	Float t0 = (-B - rootDiscrim) * inv2A;
quadrics.cc:	Float t1 = (-B + rootDiscrim) * inv2A;
quadrics.cc:	u = 1. - (atan2(Phit.y, -Phit.x) + M_PI) / (2. * M_PI);
quadrics.cc:	v = (Phit.z - zmin) / (zmax - zmin);
quadrics.cc:		u = 1. - (atan2(Phit.y, -Phit.x) + M_PI) / (2. * M_PI);
quadrics.cc:		v = (Phit.z - zmin) / (zmax - zmin);
quadrics.cc:		Float crossu = atan2(Phit.y, -Phit.x) + M_PI;
quadrics.cc:		Vector dPdu((-radius * sqrt(crossv) * sin(crossu)) / sqrt(zmax),
quadrics.cc:		hit->RecordHit(Phit, surfNorm, u, v, this);
quadrics.cc:	Point p1 = Point(-rmax, -rmax, zmin);
quadrics.cc:	t = -p2.z / (p1.z - p2.z);
quadrics.cc:	pr = Point(t * p1.x + (1 - t) * p2.x,
quadrics.cc:			   t * p1.y + (1 - t) * p2.y, t * p1.z + (1 - t) * p2.z);
quadrics.cc:	c2 = (a2 * p1.z * p1.z) / (p1.x * p1.x + p1.y * p1.y - a2);
quadrics.cc:		ray.D.y * ray.D.y / a2 - ray.D.z * ray.D.z / c2;
quadrics.cc:				   ray.D.y * ray.O.y / a2 - ray.D.z * ray.O.z / c2);
quadrics.cc:		ray.O.y * ray.O.y / a2 - ray.O.z * ray.O.z / c2 - 1;
quadrics.cc:	Float discrim = B * B - 4. * A * C;
quadrics.cc:	Float t0 = (-B - rootDiscrim) * inv2A;
quadrics.cc:	Float t1 = (-B + rootDiscrim) * inv2A;
quadrics.cc:	v = (Phit.z - p1.z) / (p2.z - p1.z);
quadrics.cc:	pr = Point((1 - v) * p1.x + v * p2.x,
quadrics.cc:			   (1 - v) * p1.y + v * p2.y, (1 - v) * p1.z + v * p2.z);
quadrics.cc:	u = atan2(Phit.y, Phit.x) - atan2(pr.y, pr.x);
quadrics.cc:		v = (Phit.z - p1.z) / (p2.z - p1.z);
quadrics.cc:		pr = Point((1 - v) * p1.x + v * p2.x,
quadrics.cc:				   (1 - v) * p1.y + v * p2.y, (1 - v) * p1.z + v * p2.z);
quadrics.cc:		u = atan2(Phit.y, Phit.x) - atan2(pr.y, pr.x);
quadrics.cc:		Vector dPdu(-a * cosh(crossv) * sin(crossu),
quadrics.cc:		hit->RecordHit(Phit, surfNorm, u, v, this);
quadrics.cc:	return BBox(Point(-Radius, -Radius, Height),
quadrics.cc:	Float hitt = (Height - ray.O.z) / ray.D.z;
quadrics.cc:	Float u = 1. - (atan2(Phit.y, -Phit.x) + M_PI) / (2. * M_PI);
quadrics.cc:	Float v = 1. - (sqrt(Phit.x * Phit.x + Phit.y * Phit.y) / Radius);
quadrics.cc:		hit->RecordHit(Phit, Normal(0, 0, 1), u, v, this);
quadrics.cc:			{ u * v, (1. - u) * v, u * (1. - v), (1. - u) * (1. - v) };
quadrics.cc:		interpolatedData = surfaceFunction->Interpolate(4,
quadrics.cc:		hit->SetInterpolatedData(interpolatedData);
reflection.cc:	reflectedDirection = -wo - 2. * Dot(N, -wo) * Vector(N);
reflection.cc:	Float c2 = 1 - (eta * eta * (1. - c1));
reflection.cc:		DirT = -eta * wo + (eta * c1 - c2) * Vector(N);
reflection.cc:		ret += (*weightIter) * (*funcIter)->fr(wi);
reflection.cc:		if (component >= (*funcIter)->SpecularComponents())
reflection.cc:			component -= (*funcIter)->SpecularComponents();
reflection.cc:				(*funcIter)->SampleSpecular(component, wi);
reflection.cc:	Float u0 = 2 * u[0] - 1.;
reflection.cc:	Float u1 = 2 * u[1] - 1.;
reflection.cc:	*wi = u0 * Du + u1 * Dv + sqrt(1. - (u0 * u0 + u1 * u1)) * Vector(N);
reflection.cc:	funcs[fnum]->Sample(u, wi, pdf);
reflection.cc:		pdfSum += funcs[i]->Pdf(wi);
rib.cc:	if (strcmp(filename, "-") == 0)
sampling.cc:	if (x >= -xwidth * 0.5 && x <= xwidth * 0.5 &&
sampling.cc:		y >= -ywidth * 0.5 && y <= ywidth * 0.5)
sampling.cc:	if (x >= -xwidth * 0.5 && x <= xwidth * 0.5 &&
sampling.cc:		y >= -ywidth * 0.5 && y <= ywidth * 0.5)
sampling.cc:		return (xwidth * 0.5 - fabs(x)) * (ywidth * 0.5 - fabs(y));
sampling.cc:		return exp(-d2) - exp(-w2);
sampling.cc:		return ((-B - 6. * C) * r * r * r + (6. * B + 30. * C) * r * r +
sampling.cc:				(-12. * B - 48. * C) * r + (8. * B + 24. * C)) * ONE_SIXTH;
sampling.cc:		return ((12. - 9. * B - 6. * C) * r * r * r +
sampling.cc:				(-18. + 12. * B + 6. * C) * r * r + (6. -
sampling.cc:	XPos = -1;
sampling.cc:	XMax = (int) ceil(scene->image->XResolution * PixelSamples[0]);
sampling.cc:	YMax = (int) ceil(scene->image->YResolution * PixelSamples[1]);
sampling.cc:	tablePos = -1;
sampling.cc:		if (x0 >= scene->image->XResolution) {
sampling.cc:			if (y0 >= scene->image->YResolution)
scene.cc:	camera->FinalizeOptions();
scene.cc:	sampler->FinalizeValues();
scene.cc:	image->FinalizeValues();
scene.cc:	while (sampler->GetNextImageSample(sample)) {
scene.cc:		if (!camera->GenerateRay(sample, ray))
scene.cc:			integrator->Integrate(ray, &hitInfo, &hitDist, &alpha);
scene.cc:		Float screenz = camera->WorldToScreen(ray(hitDist)).z;
scene.cc:		image->AddSample(Praster, L, alpha);
scene.cc:	image->Write();
scene.cc:	return accelerator->IntersectClosest(ray, mint, maxt, hit);
scene.cc:	Float tmin = 1e-6;
scene.cc:	Float tmax = 1. - tmin;
scene.cc:	if (accelerator->IntersectClosest(Ray(p1, p2 - p1), tmin, &tmax, NULL)) {
scene.cc:	Float tmin = 1e-6;
scene.cc:	if (accelerator->IntersectClosest(ray, tmin, &tmax, NULL)) {
shading.cc:	Ng = hitInfo->hitPrim->attributes->ObjectToWorld(hitInfo->NgObj);
shading.cc:		Ng = -Ng;
shading.cc:	const Normal *Ni = hitInfo->GetNormal(RI_N);
shading.cc:		Ns = hitInfo->hitPrim->attributes->ObjectToWorld(*Ni).Hat();
shading.cc:			Ns = -Ns;
shading.cc:	const Float *ret = hitInfo->GetFloat(token);
shading.cc:		return hitInfo->u;
shading.cc:		return hitInfo->v;
shading.cc:	const Spectrum *ret = hitInfo->GetColor(token);
shading.cc:		return hitInfo->hitPrim->attributes->Color;
shading.cc:		return hitInfo->hitPrim->attributes->Opacity;
shading.cc:	const Point *ret = hitInfo->GetPoint(token);
shading.cc:	const char *ret = hitInfo->GetString(token);
shading.cc:	const Vector *ret = hitInfo->GetVector(token);
shading.cc:	const Normal *ret = hitInfo->GetNormal(token);
shading.cc:	mix->AddFunction(CreateLambertian(surfKd * Cs, sc.Ns));
shading.cc:	mix->AddFunction(CreateBlinnGlossy(surfKs * surfSpecColor,
shading.cc:	texName = surfaceFunction->InitializeString(RI_TEXTURENAME,
shading.cc:		surfColor *= tmap->Lookup(s, t);
shading.cc:		mix->AddFunction(CreateSpecularReflection(shadeKr * Cs,
shading.cc:			mix->AddFunction(CreateSpecularTransmission(Kt * Cs,
shading.cc:			mix->AddFunction(CreateSpecularTransmission(Kt * Cs,
shading.cc:		mix->AddFunction(CreateBlinnGlossy(shadeKs * Cs,
shading.cc:		mix->AddFunction(CreateSpecularReflection(shadeKr * Cs,
shading.cc:	if (primitiveData->vertexPoints.size() > 0) {
shading.cc:		int nvp = primitiveData->vertexPoints.size();
shading.cc:	if (primitiveData->vertexFloats.size() > 0) {
shading.cc:		interpVertexFloats = new Float[primitiveData->vertexFloats.size()];
shading.cc:	if (primitiveData->vertexVectors.size() > 0) {
shading.cc:		int nv = primitiveData->vertexVectors.size();
shading.cc:	if (primitiveData->vertexNormals.size() > 0) {
shading.cc:		int vn = primitiveData->vertexNormals.size();
shading.cc:	if (primitiveData->vertexColors.size() > 0) {
shading.cc:		int nc = primitiveData->vertexColors.size();
shading.cc:		ret->interpVertexPoints[i] = value;
shading.cc:		ret->interpVertexFloats[i] = value;
shading.cc:		ret->interpVertexVectors[i] = value;
shading.cc:		ret->interpVertexNormals[i] = value;
shading.cc:		ret->interpVertexColors[i] = value;
shading.cc:	const Point *ret = primitiveData->GetUniformPoint(token);
shading.cc:	primitiveData->vertexPoints;
shading.cc:	const vector<pair<RtToken, Float *> > &vfp = primitiveData->vertexFloats;
shading.cc:	const vector<pair<RtToken, Vector *> > &vvp = primitiveData->vertexVectors;
shading.cc:	const vector<pair<RtToken, Normal *> > &vnp = primitiveData->vertexNormals;
shading.cc:	const vector<pair<RtToken, Spectrum *> > &vcp = primitiveData->vertexColors;
sl.cc:		params.hitInfo->hitPrim->attributes->Lights;
sl.cc:		if (lt->IsAmbient()) {
sl.cc:			amb += lt->Sample(params.sampleGenerator, dummy, &dummy);
sl.cc:		return SLTriple(-a, -b, -c);
texture.cc:	Float xReal = u * (width - 1);
texture.cc:	Float yReal = v * (height - 1);
texture.cc:	Float dx = xReal - x;
texture.cc:	Float dy = yReal - y;
texture.cc:	weights[0] = (1. - dx) * (1. - dy);
texture.cc:	weights[1] = (1. - dx) * dy;
texture.cc:	weights[2] = dx * (1. - dy);
texture.cc:	if (y < height - 1 && x < width - 1) {
texture.cc:	} else if (y < height - 1) {
texture.cc:	} else if (x < width - 1) {
tiffio.cc:			Error("TIFFRead: colormap not found in one-sample image");
tiffio.cc:			if (TIFFReadScanline(tiff, fbuf, y, 1) == -1) {
tiffio.cc:			if (TIFFReadScanline(tiff, ubuf, y, 1) == -1) {
transform.cc:	memcpy(this->m, matrix, sizeof(this->m));
transform.cc:	memcpy(this->m, matrix, sizeof(this->m));
transform.cc:				  0, cos_t, -sin_t, 0, 0, sin_t, cos_t, 0, 0, 0, 0, 1);
transform.cc:	Transform ret(cos_t, 0, -sin_t, 0,
transform.cc:	Transform ret(cos_t, -sin_t, 0, 0,
transform.cc:	m[0][0] = axis.x * axis.x + (1. - axis.x * axis.x) * c;
transform.cc:	m[0][1] = axis.x * axis.y * (1 - c) - axis.z * s;
transform.cc:	m[0][2] = axis.x * axis.z * (1 - c) + axis.y * s;
transform.cc:	m[1][0] = axis.x * axis.y * (1 - c) + axis.z * s;
transform.cc:	m[1][1] = axis.y * axis.y + (1 - axis.y * axis.y) * c;
transform.cc:	m[1][2] = axis.y * axis.z * (1 - c) - axis.x * s;
transform.cc:	m[2][0] = axis.x * axis.z * (1 - c) - axis.y * s;
transform.cc:	m[2][1] = axis.y * axis.z * (1 - c) + axis.x * s;
transform.cc:	m[2][2] = axis.z * axis.z + (1 - axis.z * axis.z) * c;
transform.cc:	Transform scale = Scale(1., 1., 1. / (f - n));
transform.cc:	m[0][0] = 2. * near / (right - left);
transform.cc:	m[0][2] = (right + left) / (right - left);
transform.cc:	m[1][1] = 2. * near / (top - bottom);
transform.cc:	m[1][2] = (top + bottom) / (top - bottom);
transform.cc:	m[2][2] = -(far + near) / (far - near);
transform.cc:	m[2][3] = 2. * far * near / (far - near);
transform.cc:	m[3][2] = -1.;
transform.cc:	Float ymin = -ymax;
transport.cc:	if (scene->Intersect(ray, 0., hitDist, hitInfo)) {
transport.cc:		const Spectrum *Csp = hitInfo->GetColor(RI_CS);
transport.cc:			return hitInfo->hitPrim->attributes->Color;
transport.cc:	if (scene->Intersect(ray, 0., hitDist, hitInfo)) {
transport.cc:		ShadeContext shadeContext(hitInfo, -ray.D);
transport.cc:		if (hitInfo->hitPrim->attributes->LightShader != NULL) {
transport.cc:				hitInfo->hitPrim->attributes->LightShader->
transport.cc:		if (!hitInfo->hitPrim->attributes->Surface)
transport.cc:			hitInfo->hitPrim->attributes->Surface->Shade(shadeContext);
transport.cc:			hitInfo->hitPrim->attributes->ObjectToWorld(hitInfo->Pobj);
transport.cc:			hitInfo->hitPrim->attributes->Lights;
transport.cc:			Spectrum dE = lt->dE(Pw, &Plight);
transport.cc:			if (!lt->CastsShadows() || scene->Unoccluded(Pw, Plight)) {
transport.cc:				Vector wi = (Plight - Pw).Hat();
transport.cc:				L += dE * brdf->fr(wi) * Dot(wi, Nw);
transport.cc:	if (scene->Intersect(ray, 1e-4, hitDist, hitInfo)) {
transport.cc:		ShadeContext shadeContext(hitInfo, -ray.D);
transport.cc:		if (hitInfo->hitPrim->attributes->LightShader != NULL) {
transport.cc:				hitInfo->hitPrim->attributes->LightShader->
transport.cc:		if (!hitInfo->hitPrim->attributes->Surface)
transport.cc:			hitInfo->hitPrim->attributes->Surface->Shade(shadeContext);
transport.cc:			hitInfo->hitPrim->attributes->ObjectToWorld(hitInfo->Pobj);
transport.cc:			hitInfo->hitPrim->attributes->Lights;
transport.cc:			Spectrum dE = lt->dE(Pw, &Plight);
transport.cc:			if (!lt->CastsShadows() || scene->Unoccluded(Pw, Plight)) {
transport.cc:				Vector wi = (Plight - Pw).Hat();
transport.cc:				L += dE * brdf->fr(wi) * Dot(wi, Nw);
transport.cc:			for (int i = 0; i < brdf->SpecularComponents(); ++i) {
transport.cc:				Spectrum kernel = brdf->SampleSpecular(i, &newRay.D);
transport.cc:		--RayDepth;
transport.cc:	if (scene->Intersect(ray, 1e-4, hitDist, hitInfo)) {
transport.cc:		ShadeContext shadeContext(hitInfo, -ray.D);
transport.cc:		if (hitInfo->hitPrim->attributes->LightShader != NULL) {
transport.cc:				hitInfo->hitPrim->attributes->LightShader->
transport.cc:		if (!hitInfo->hitPrim->attributes->Surface)
transport.cc:			hitInfo->hitPrim->attributes->Surface->Shade(shadeContext);
transport.cc:		if (hitInfo->hitPrim->attributes->Sampling ==
transport.cc:			else if (hitInfo->hitPrim->attributes->Sampling ==
transport.cc:			//    for i = 0 to light->NumSamples()
transport.cc:			else if (hitInfo->hitPrim->attributes->Sampling ==
transport.cc:	this->name = strdup(name);
transport.cc:	void *var = dso->GetSym( sym ); \
transport.cc:			SLTriple(params.hitInfo->hitPrim->attributes->
transport.cc:					 ObjectToWorld(params.hitInfo->Pobj));
transport.cc:	if (scene->Intersect(ray, 0., hitDist, hitInfo) &&
transport.cc:		hitInfo->hitPrim->attributes->Surface != NULL) {
transport.cc:		ShadeContext shadeContext(hitInfo, -ray.D);
transport.cc:		RmanShaderParams params(hitInfo->hitPrim->attributes->Surface->
transport.cc:								*scene->sampler, hitInfo);
transport.cc:			(RendermanShader *) shaders.Search(hitInfo->attributes->
transport.cc:											   Surface->Name());
transport.cc:				new RendermanShader(hitInfo->attributes->Surface->Name());
transport.cc:			shaders.Add(hitInfo->attributes->Surface->Name(), shader);
transport.cc:		shader->Run(params);
trimesh.cc:	BBox worldBounds(attributes->ObjectToWorld(p[0]),
trimesh.cc:					 attributes->ObjectToWorld(p[1]));
trimesh.cc:		worldBounds = Union(worldBounds, attributes->ObjectToWorld(p[i]));
trimesh.cc:	refined->reserve(ntris);
trimesh.cc:		refined->push_back(new Triangle(this, i));
trimesh.cc:	BBox objectBounds(mesh->p[mesh->vertexIndex[triNum * 3]],
trimesh.cc:					  mesh->p[mesh->vertexIndex[triNum * 3 + 1]]);
trimesh.cc:	return Union(objectBounds, mesh->p[mesh->vertexIndex[triNum * 3 + 2]]);
trimesh.cc:	Transform o2w = mesh->attributes->ObjectToWorld;
trimesh.cc:	BBox objectBounds(o2w(mesh->p[mesh->vertexIndex[triNum * 3]]),
trimesh.cc:					  o2w(mesh->p[mesh->vertexIndex[triNum * 3 + 1]]));
trimesh.cc:				 o2w(mesh->p[mesh->vertexIndex[triNum * 3 + 2]]));
trimesh.cc:	int *vptr = &(mesh->vertexIndex[3 * triNum]);
trimesh.cc:	const Point *p = mesh->p;
trimesh.cc:	Vector E1 = p[vertexIndex1] - p[vertexIndex0];
trimesh.cc:	Vector E2 = p[vertexIndex2] - p[vertexIndex0];
trimesh.cc:	Vector T = ray.O - mesh->p[vertexIndex0];
trimesh.cc:		hit->RecordHit(ray(t), N, u, v, mesh);
trimesh.cc:		Float interpWeights[3] = { 1. - u - v, u, v };
trimesh.cc:			mesh->surfaceFunction->Interpolate(3,
trimesh.cc:		hit->SetInterpolatedData(interpolatedData);
util.cc:					minv[j][k] -= minv[icol][k] * save;
util.cc:	for (int j = 3; j >= 0; j--) {
util.cc:		if (strcmp(newTracker->category, trackers[i]->category) == 0 &&
util.cc:			strcmp(newTracker->name, trackers[i]->name) == 0) {
util.cc:				  newTracker->category, newTracker->name);
util.cc:		if (trackers[i]->level <= level) {
util.cc:			fprintf(dest, "%s/%s", trackers[i]->category,
util.cc:					trackers[i]->name);
util.cc:				strlen(trackers[i]->category) + 1 +
util.cc:				strlen(trackers[i]->name);
util.cc:			int paddingSpaces = resultsColumn - textLength;
util.cc:			while (paddingSpaces--)
util.cc:			if (trackers[i]->ptrb == NULL)
util.cc:				fprintf(dest, "%d\n", *trackers[i]->ptra);
util.cc:				if (*trackers[i]->ptrb > 0) {
util.cc:						(Float) * trackers[i]->ptra / (Float) *
util.cc:						trackers[i]->ptrb;
util.cc:					fprintf(dest, "%d:%d (%f%%)\n", *trackers[i]->ptra,
util.cc:							*trackers[i]->ptrb, 100. * ratio);
util.cc:					fprintf(dest, "%d:%d\n", *trackers[i]->ptra,
util.cc:							*trackers[i]->ptrb);
util.cc:		trackers[i]->ptra = 0;
util.cc:		if (trackers[i]->ptrb)
util.cc:			trackers[i]->ptrb = 0;
util.cc:#define UPPER_MASK 0x80000000	/* most significant w-r bits */
util.cc:		mt[mti] = (69069 * mt[mti - 1]) & 0xffffffff;
util.cc:		for (kk = 0; kk < N - M; kk++) {
util.cc:		for (; kk < N - 1; kk++) {
util.cc:			mt[kk] = mt[kk + (M - N)] ^ (y >> 1) ^ mag01[y & 0x1];
util.cc:		y = (mt[N - 1] & UPPER_MASK) | (mt[0] & LOWER_MASK);
util.cc:		mt[N - 1] = mt[M - 1] ^ (y >> 1) ^ mag01[y & 0x1];
util.cc:		if (strcmp(key, iter->first) == 0)
util.cc:			return iter->second;
util.cc:		if (strcmp(key, iter->first) == 0)
