void LuxRenderer::defineFilm() { int width = this->mtlu_renderGlobals->imgWidth; int height = this->mtlu_renderGlobals->imgHeight; MString outputPath = this->mtlu_renderGlobals->basePath + "/" + this->mtlu_renderGlobals->imageName + "." + (int)this->mtlu_renderGlobals->currentFrame + ".lxs"; // file path without extension, will be added automatically by the renderer MString fileName = this->mtlu_renderGlobals->imagePath + "/" + this->mtlu_renderGlobals->imageName + "." + (int)this->mtlu_renderGlobals->currentFrame; const char *filename = fileName.asChar(); const int xres = width; const int yres = height; const bool write_png = true; const int halttime = this->mtlu_renderGlobals->halttime; const int haltspp = this->mtlu_renderGlobals->haltspp; int displayinterval = 3; ParamSet fp = CreateParamSet(); fp->AddInt("xresolution",&xres); fp->AddInt("yresolution",&yres); fp->AddBool("write_png",&write_png); fp->AddString("filename",&filename); if( halttime > 0) fp->AddInt("halttime", &halttime); if( haltspp > 0) fp->AddInt("haltspp", &haltspp); if( displayinterval > 0) fp->AddInt("displayinterval", &displayinterval); lux->film("fleximage", boost::get_pointer(fp)); }
void LuxRenderer::createAreaLightMesh(mtlu_MayaObject *obj) { MString meshName(""); MFnDependencyNode depFn(obj->mobject); MObject otherSideObj = getOtherSideNode(MString("mtlu_areaLight_geo"), obj->mobject); if( otherSideObj != MObject::kNullObj) { }else{ int indices[6] = {0,1,2,2,3,0}; float floatPointArray[12] = {-1, -1, 0, -1, 1, 0, 1, 1, 0, 1, -1, 0}; float floatNormalArray[12] = {0,0,-1, 0,0,-1, 0,0,-1, 0,0,-1}; ParamSet triParams = CreateParamSet(); triParams->AddInt("indices", indices, 6); triParams->AddPoint("P", floatPointArray, 4); triParams->AddNormal("N", floatNormalArray, 4); lux->transformBegin(); float fm[16]; MMatrix tm = obj->transformMatrices[0]; setZUp(tm, fm); this->lux->transform(fm); this->lux->shape("trianglemesh", boost::get_pointer(triParams)); lux->transformEnd(); } }
void Heightfield::Refine(vector<Reference<Shape> > &refined) const { int ntris = 2*(nx-1)*(ny-1); refined.reserve(ntris); int *verts = new int[3*ntris]; Point *P = new Point[nx*ny]; float *uvs = new float[2*nx*ny]; int nverts = nx*ny; int x, y; // Compute heightfield vertex positions int pos = 0; for (y = 0; y < ny; ++y) { for (x = 0; x < nx; ++x) { P[pos].x = uvs[2*pos] = (float)x / (float)(nx-1); P[pos].y = uvs[2*pos+1] = (float)y / (float)(ny-1); P[pos].z = z[pos]; ++pos; } } // Fill in heightfield vertex offset array int *vp = verts; for (y = 0; y < ny-1; ++y) { for (x = 0; x < nx-1; ++x) { #define VERT(x,y) ((x)+(y)*nx) *vp++ = VERT(x, y); *vp++ = VERT(x+1, y); *vp++ = VERT(x+1, y+1); *vp++ = VERT(x, y); *vp++ = VERT(x+1, y+1); *vp++ = VERT(x, y+1); } #undef VERT } ParamSet paramSet; paramSet.AddInt("indices", verts, 3*ntris); paramSet.AddFloat("uv", uvs, 2 * nverts); paramSet.AddPoint("P", P, nverts); refined.push_back(CreateTriangleMeshShape(ObjectToWorld, WorldToObject, ReverseOrientation, paramSet)); delete[] P; delete[] uvs; delete[] verts; }
void LuxRenderer::defineTriangleMesh(mtlu_MayaObject *obj, bool noObjectDef = false) { MObject meshObject = obj->mobject; MStatus stat = MStatus::kSuccess; MFnMesh meshFn(meshObject, &stat); CHECK_MSTATUS(stat); MItMeshPolygon faceIt(meshObject, &stat); CHECK_MSTATUS(stat); MPointArray points; meshFn.getPoints(points); MFloatVectorArray normals; meshFn.getNormals( normals, MSpace::kWorld ); MFloatArray uArray, vArray; meshFn.getUVs(uArray, vArray); logger.debug(MString("Translating mesh object ") + meshFn.name().asChar()); MString meshFullName = obj->fullNiceName; MIntArray trianglesPerFace, triVertices; meshFn.getTriangles(trianglesPerFace, triVertices); int numTriangles = 0; for( size_t i = 0; i < trianglesPerFace.length(); i++) numTriangles += trianglesPerFace[i]; // lux render does not have a per vertex per face normal definition, here we can use one normal and uv per vertex only // So I create the triangles with unique vertices, normals and uvs. Of course this way vertices etc. cannot be shared. int numPTFloats = numTriangles * 3 * 3; logger.debug(MString("Num Triangles: ") + numTriangles + " num tri floats " + numPTFloats); float *floatPointArray = new float[numPTFloats]; float *floatNormalArray = new float[numPTFloats]; float *floatUvArray = new float[numTriangles * 3 * 2]; logger.debug(MString("Allocated ") + numPTFloats + " floats for point and normals"); MIntArray triangelVtxIdListA; MFloatArray floatPointArrayA; MPointArray triPoints; MIntArray triVtxIds; MIntArray faceVtxIds; MIntArray faceNormalIds; int *triangelVtxIdList = new int[numTriangles * 3]; for( uint sgId = 0; sgId < obj->shadingGroups.length(); sgId++) { MString slotName = MString("slot_") + sgId; } int triCount = 0; int vtxCount = 0; for(faceIt.reset(); !faceIt.isDone(); faceIt.next()) { int faceId = faceIt.index(); int numTris; faceIt.numTriangles(numTris); faceIt.getVertices(faceVtxIds); MIntArray faceUVIndices; faceNormalIds.clear(); for( uint vtxId = 0; vtxId < faceVtxIds.length(); vtxId++) { faceNormalIds.append(faceIt.normalIndex(vtxId)); int uvIndex; faceIt.getUVIndex(vtxId, uvIndex); faceUVIndices.append(uvIndex); } int perFaceShadingGroup = 0; if( obj->perFaceAssignments.length() > 0) perFaceShadingGroup = obj->perFaceAssignments[faceId]; //logger.info(MString("Face ") + faceId + " will receive SG " + perFaceShadingGroup); for( int triId = 0; triId < numTris; triId++) { int faceRelIds[3]; faceIt.getTriangle(triId, triPoints, triVtxIds); for( uint triVtxId = 0; triVtxId < 3; triVtxId++) { for(uint faceVtxId = 0; faceVtxId < faceVtxIds.length(); faceVtxId++) { if( faceVtxIds[faceVtxId] == triVtxIds[triVtxId]) { faceRelIds[triVtxId] = faceVtxId; } } } uint vtxId0 = faceVtxIds[faceRelIds[0]]; uint vtxId1 = faceVtxIds[faceRelIds[1]]; uint vtxId2 = faceVtxIds[faceRelIds[2]]; uint normalId0 = faceNormalIds[faceRelIds[0]]; uint normalId1 = faceNormalIds[faceRelIds[1]]; uint normalId2 = faceNormalIds[faceRelIds[2]]; uint uvId0 = faceUVIndices[faceRelIds[0]]; uint uvId1 = faceUVIndices[faceRelIds[1]]; uint uvId2 = faceUVIndices[faceRelIds[2]]; floatPointArray[vtxCount * 3] = points[vtxId0].x; floatPointArray[vtxCount * 3 + 1] = points[vtxId0].y; floatPointArray[vtxCount * 3 + 2] = points[vtxId0].z; floatNormalArray[vtxCount * 3] = normals[normalId0].x; floatNormalArray[vtxCount * 3 + 1] = normals[normalId0].y; floatNormalArray[vtxCount * 3 + 2] = normals[normalId0].z; floatUvArray[vtxCount * 2] = uArray[uvId0]; floatUvArray[vtxCount * 2 + 1] = vArray[uvId0]; vtxCount++; floatPointArray[vtxCount * 3] = points[vtxId1].x; floatPointArray[vtxCount * 3 + 1] = points[vtxId1].y; floatPointArray[vtxCount * 3 + 2] = points[vtxId1].z; floatNormalArray[vtxCount * 3] = normals[normalId1].x; floatNormalArray[vtxCount * 3 + 1] = normals[normalId1].y; floatNormalArray[vtxCount * 3 + 2] = normals[normalId1].z; floatUvArray[vtxCount * 2] = uArray[uvId1]; floatUvArray[vtxCount * 2 + 1] = vArray[uvId1]; vtxCount++; floatPointArray[vtxCount * 3] = points[vtxId2].x; floatPointArray[vtxCount * 3 + 1] = points[vtxId2].y; floatPointArray[vtxCount * 3 + 2] = points[vtxId2].z; floatNormalArray[vtxCount * 3] = normals[normalId2].x; floatNormalArray[vtxCount * 3 + 1] = normals[normalId2].y; floatNormalArray[vtxCount * 3 + 2] = normals[normalId2].z; floatUvArray[vtxCount * 2] = uArray[uvId2]; floatUvArray[vtxCount * 2 + 1] = vArray[uvId2]; vtxCount++; //logger.debug(MString("Vertex count: ") + vtxCount + " maxId " + ((vtxCount - 1) * 3 + 2) + " ptArrayLen " + (numTriangles * 3 * 3)); triangelVtxIdList[triCount * 3] = triCount * 3; triangelVtxIdList[triCount * 3 + 1] = triCount * 3 + 1; triangelVtxIdList[triCount * 3 + 2] = triCount * 3 + 2; triCount++; } } //generatetangents bool Generate tangent space using miktspace, useful if mesh has a normal map that was also baked using miktspace (such as blender or xnormal) false //subdivscheme string Subdivision algorithm, options are "loop" and "microdisplacement" "loop" //displacementmap string Name of the texture used for the displacement. Subdivscheme parameter must always be provided, as load-time displacement is handled by the loop-subdivision code. none - optional. (loop subdiv can be used without displacement, microdisplacement will not affect the mesh without a displacement map specified) //dmscale float Scale of the displacement (for an LDR map, this is the maximum height of the displacement in meter) 0.1 //dmoffset float Offset of the displacement. 0 //dmnormalsmooth bool Smoothing of the normals of the subdivided faces. Only valid for loop subdivision. true //dmnormalsplit bool Force the mesh to split along breaks in the normal. If a mesh has no normals (flat-shaded) it will rip open on all edges. Only valid for loop subdivision. false //dmsharpboundary bool Try to preserve mesh boundaries during subdivision. Only valid for loop subdivision. false //nsubdivlevels integer Number of subdivision levels. This is only recursive for loop subdivision, microdisplacement will need much larger values (such as 50). 0 bool generatetangents = false; getBool(MString("mtlu_mesh_generatetangents"), meshFn, generatetangents); int subdivscheme = 0; const char *subdAlgos[] = {"loop", "microdisplacement"}; getInt(MString("mtlu_mesh_subAlgo"), meshFn, subdivscheme); const char *subdalgo = subdAlgos[subdivscheme]; float dmscale; getFloat(MString("mtlu_mesh_dmscale"), meshFn, dmscale); float dmoffset; getFloat(MString("mtlu_mesh_dmoffset"), meshFn, dmoffset); MString displacementmap; getString(MString("mtlu_mesh_displacementMap"), meshFn, displacementmap); const char *displacemap = displacementmap.asChar(); bool dmnormalsmooth = true; getBool(MString("mtlu_mesh_dmnormalsmooth"), meshFn, dmnormalsmooth); bool dmnormalsplit = false; getBool(MString("mtlu_mesh_dmnormalsplit"), meshFn, dmnormalsplit); bool dmsharpboundary = false; getBool(MString("mtlu_mesh_dmsharpboundary"), meshFn, dmsharpboundary); int nsubdivlevels = 0; getInt(MString("mtlu_mesh_subdivlevel"), meshFn, nsubdivlevels); // a displacment map needs its own texture defintion MString displacementTextureName = ""; if(displacementmap.length() > 0) { ParamSet dmParams = CreateParamSet(); dmParams->AddString("filename", &displacemap); displacementTextureName = meshFn.name() + "_displacementMap"; this->lux->texture(displacementTextureName.asChar(), "float", "imagemap", boost::get_pointer(dmParams)); } ParamSet triParams = CreateParamSet(); int numPointValues = numTriangles * 3; int numUvValues = numTriangles * 3 * 2; clock_t startTime = clock(); logger.info(MString("Adding mesh values to params.")); triParams->AddInt("indices", triangelVtxIdList, numTriangles * 3); triParams->AddPoint("P", floatPointArray, numPointValues); triParams->AddNormal("N", floatNormalArray, numPointValues); triParams->AddFloat("uv", floatUvArray, numUvValues); if( nsubdivlevels > 0) triParams->AddInt("nsubdivlevels", &nsubdivlevels, 1); triParams->AddBool("generatetangents", &generatetangents, 1); triParams->AddString("subdivscheme", &subdalgo , 1); if(displacementmap.length() > 0) { triParams->AddFloat("dmoffset", &dmoffset, 1); triParams->AddFloat("dmscale", &dmscale, 1); const char *dmft = displacementTextureName.asChar(); triParams->AddString("displacementmap", &dmft); } triParams->AddBool("dmnormalsmooth", &dmnormalsmooth, 1); triParams->AddBool("dmnormalsplit", &dmnormalsplit, 1); triParams->AddBool("dmsharpboundary", &dmsharpboundary, 1); clock_t pTime = clock(); if(!noObjectDef) this->lux->objectBegin(meshFullName.asChar()); this->lux->shape("trianglemesh", boost::get_pointer(triParams)); if(!noObjectDef) this->lux->objectEnd(); clock_t eTime = clock(); logger.info(MString("Timing: Parameters: ") + ((pTime - startTime)/CLOCKS_PER_SEC) + " objTime " + ((eTime - pTime)/CLOCKS_PER_SEC) + " all " + ((eTime - startTime)/CLOCKS_PER_SEC)); return; }
void LoopSubdiv::Refine(vector<Reference<Shape> > &refined) const { vector<SDFace *> f = faces; vector<SDVertex *> v = vertices; MemoryArena arena; for (int i = 0; i < nLevels; ++i) { // Update _f_ and _v_ for next level of subdivision vector<SDFace *> newFaces; vector<SDVertex *> newVertices; // Allocate next level of children in mesh tree for (uint32_t j = 0; j < v.size(); ++j) { v[j]->child = arena.Alloc<SDVertex>(); v[j]->child->regular = v[j]->regular; v[j]->child->boundary = v[j]->boundary; newVertices.push_back(v[j]->child); } for (uint32_t j = 0; j < f.size(); ++j) for (int k = 0; k < 4; ++k) { f[j]->children[k] = arena.Alloc<SDFace>(); newFaces.push_back(f[j]->children[k]); } // Update vertex positions and create new edge vertices // Update vertex positions for even vertices for (uint32_t j = 0; j < v.size(); ++j) { if (!v[j]->boundary) { // Apply one-ring rule for even vertex if (v[j]->regular) v[j]->child->P = weightOneRing(v[j], 1.f/16.f); else v[j]->child->P = weightOneRing(v[j], beta(v[j]->valence())); } else { // Apply boundary rule for even vertex v[j]->child->P = weightBoundary(v[j], 1.f/8.f); } } // Compute new odd edge vertices map<SDEdge, SDVertex *> edgeVerts; for (uint32_t j = 0; j < f.size(); ++j) { SDFace *face = f[j]; for (int k = 0; k < 3; ++k) { // Compute odd vertex on _k_th edge SDEdge edge(face->v[k], face->v[NEXT(k)]); SDVertex *vert = edgeVerts[edge]; if (!vert) { // Create and initialize new odd vertex vert = arena.Alloc<SDVertex>(); newVertices.push_back(vert); vert->regular = true; vert->boundary = (face->f[k] == NULL); vert->startFace = face->children[3]; // Apply edge rules to compute new vertex position if (vert->boundary) { vert->P = 0.5f * edge.v[0]->P; vert->P += 0.5f * edge.v[1]->P; } else { vert->P = 3.f/8.f * edge.v[0]->P; vert->P += 3.f/8.f * edge.v[1]->P; vert->P += 1.f/8.f * face->otherVert(edge.v[0], edge.v[1])->P; vert->P += 1.f/8.f * face->f[k]->otherVert(edge.v[0], edge.v[1])->P; } edgeVerts[edge] = vert; } } } // Update new mesh topology // Update even vertex face pointers for (uint32_t j = 0; j < v.size(); ++j) { SDVertex *vert = v[j]; int vertNum = vert->startFace->vnum(vert); vert->child->startFace = vert->startFace->children[vertNum]; } // Update face neighbor pointers for (uint32_t j = 0; j < f.size(); ++j) { SDFace *face = f[j]; for (int k = 0; k < 3; ++k) { // Update children _f_ pointers for siblings face->children[3]->f[k] = face->children[NEXT(k)]; face->children[k]->f[NEXT(k)] = face->children[3]; // Update children _f_ pointers for neighbor children SDFace *f2 = face->f[k]; face->children[k]->f[k] = f2 ? f2->children[f2->vnum(face->v[k])] : NULL; f2 = face->f[PREV(k)]; face->children[k]->f[PREV(k)] = f2 ? f2->children[f2->vnum(face->v[k])] : NULL; } } // Update face vertex pointers for (uint32_t j = 0; j < f.size(); ++j) { SDFace *face = f[j]; for (int k = 0; k < 3; ++k) { // Update child vertex pointer to new even vertex face->children[k]->v[k] = face->v[k]->child; // Update child vertex pointer to new odd vertex SDVertex *vert = edgeVerts[SDEdge(face->v[k], face->v[NEXT(k)])]; face->children[k]->v[NEXT(k)] = vert; face->children[NEXT(k)]->v[k] = vert; face->children[3]->v[k] = vert; } } // Prepare for next level of subdivision f = newFaces; v = newVertices; } // Push vertices to limit surface PbrtPoint *Plimit = new PbrtPoint[v.size()]; for (uint32_t i = 0; i < v.size(); ++i) { if (v[i]->boundary) Plimit[i] = weightBoundary(v[i], 1.f/5.f); else Plimit[i] = weightOneRing(v[i], gamma(v[i]->valence())); } for (uint32_t i = 0; i < v.size(); ++i) v[i]->P = Plimit[i]; // Compute vertex tangents on limit surface vector<Normal> Ns; Ns.reserve(v.size()); vector<PbrtPoint> Pring(16, PbrtPoint()); for (uint32_t i = 0; i < v.size(); ++i) { SDVertex *vert = v[i]; Vector S(0,0,0), T(0,0,0); int valence = vert->valence(); if (valence > (int)Pring.size()) Pring.resize(valence); vert->oneRing(&Pring[0]); if (!vert->boundary) { // Compute tangents of interior face for (int k = 0; k < valence; ++k) { S += cosf(2.f*M_PI*k/valence) * Vector(Pring[k]); T += sinf(2.f*M_PI*k/valence) * Vector(Pring[k]); } } else { // Compute tangents of boundary face S = Pring[valence-1] - Pring[0]; if (valence == 2) T = Vector(Pring[0] + Pring[1] - 2 * vert->P); else if (valence == 3) T = Pring[1] - vert->P; else if (valence == 4) // regular T = Vector(-1*Pring[0] + 2*Pring[1] + 2*Pring[2] + -1*Pring[3] + -2*vert->P); else { float theta = M_PI / float(valence-1); T = Vector(sinf(theta) * (Pring[0] + Pring[valence-1])); for (int k = 1; k < valence-1; ++k) { float wt = (2*cosf(theta) - 2) * sinf((k) * theta); T += Vector(wt * Pring[k]); } T = -T; } } Ns.push_back(Normal(Cross(S, T))); } // Create _TriangleMesh_ from subdivision mesh uint32_t ntris = uint32_t(f.size()); int *verts = new int[3*ntris]; int *vp = verts; uint32_t totVerts = uint32_t(v.size()); map<SDVertex *, int> usedVerts; for (uint32_t i = 0; i < totVerts; ++i) usedVerts[v[i]] = i; for (uint32_t i = 0; i < ntris; ++i) { for (int j = 0; j < 3; ++j) { *vp = usedVerts[f[i]->v[j]]; ++vp; } } ParamSet paramSet; paramSet.AddInt("indices", verts, 3*ntris); paramSet.AddPoint("P", Plimit, totVerts); paramSet.AddNormal("N", &Ns[0], int(Ns.size())); refined.push_back(CreateTriangleMeshShape(ObjectToWorld, WorldToObject, ReverseOrientation, paramSet)); delete[] verts; delete[] Plimit; }
void LuxRenderer::defineCamera() { std::shared_ptr<MayaScene> mayaScene = MayaTo::getWorldPtr()->worldScenePtr; std::shared_ptr<RenderGlobals> renderGlobals = MayaTo::getWorldPtr()->worldRenderGlobalsPtr; std::shared_ptr<MayaObject> mo = mayaScene->camList[0]; MMatrix cm = mo->dagPath.inclusiveMatrix(); MFnCamera camFn(mo->mobject); this->transformCamera(mo.get(), renderGlobals->doMb && (mo->transformMatrices.size() > 1)); // lux uses the fov of the smallest image edge double hFov = RadToDeg(camFn.horizontalFieldOfView()); double vFov = RadToDeg(camFn.verticalFieldOfView()); float fov = hFov; int width, height; renderGlobals->getWidthHeight(width, height); if( height < width) fov = vFov; // focaldist float focusDist = (float)camFn.focusDistance() * renderGlobals->sceneScale; float focalLen = (float)camFn.focalLength(); float fStop = (float)camFn.fStop(); bool useDOF = false; getBool(MString("depthOfField"), camFn, useDOF); useDOF = useDOF && renderGlobals->doDof; // hither, yon float hither = (float)camFn.nearClippingPlane(); float yon = (float)camFn.farClippingPlane(); // render region int left, bottom, right, top; renderGlobals->getRenderRegion(left, bottom, right, top); int ybot = (height - bottom); int ytop = (height - top); int ymin = ybot < ytop ? ybot : ytop; int ymax = ybot > ytop ? ybot : ytop; float lensradius = (focalLen / 1000.0) / ( 2.0 * fStop ); int blades = 0; getInt(MString("mtlu_diaphragm_blades"), camFn, blades); bool autofocus = false; getBool(MString("mtlu_autofocus"), camFn, autofocus); int dist = 0; getInt(MString("mtlu_distribution"), camFn, dist); logger.debug(MString("Lens distribution: ") + dist + " " + LensDistributions[dist]); float power = 1.0f; getFloat(MString("mtlu_power"), camFn, power); const char *lensdistribution = LensDistributions[dist]; float shutterOpen = 0.0f; float shutterClose = renderGlobals->mbLength; ParamSet cp = CreateParamSet(); cp->AddFloat("fov", &fov); cp->AddFloat("focaldistance", &focusDist); cp->AddFloat("hither", &hither); cp->AddFloat("yon", &yon); cp->AddFloat("shutteropen", &shutterOpen); cp->AddFloat("shutterclose", &shutterClose); if( blades > 0) cp->AddInt("blades", &blades); if( useDOF ) { cp->AddFloat("lensradius", &lensradius); cp->AddBool("autofocus", &autofocus); cp->AddString("distribution", &lensdistribution); cp->AddFloat("power", &power); } lux->camera("perspective", boost::get_pointer(cp)); if( renderGlobals->exportSceneFile) this->luxFile << "Camera \"perspective\" "<< "\"float fov\" [" << fov << "]" <<"\n"; }
int testSimpleScene() { ParamSet params; int xres = 500; int yres = 500; params.AddInt("xresolution", &xres, 1); params.AddInt("yresolution", &yres, 1); Transform t = LookAt(Point(0,0,0), Point(0,0,-100), Vector(0,1,0)); AnimatedTransform cam2world(&t, 0, &t, 0); params.AddString("filename", new string("render.png"), 1); //BoxFilter *filter = CreateBoxFilter(params); GaussianFilter *filter = new GaussianFilter(3, 3, 0.001f); ImageFilm *film = CreateImageFilm(params, filter); PerspectiveCamera *camera = CreatePerspectiveCamera(params, cam2world, film); //AdaptiveSampler *sampler = CreateAdaptiveSampler(params, film, camera); //Sampler *sampler = CreateRandomSampler(params, film, camera); //Sampler *sampler = CreateBestCandidateSampler(params, film, camera); //Sampler *sampler = CreateHaltonSampler(params, film, camera); //StratifiedSampler *sampler = CreateStratifiedSampler(params, film, camera); bool jitter = false; int xstart, xend, ystart, yend; film->GetSampleExtent(&xstart, &xend, &ystart, ¥d); int xsamp = 1; int ysamp = 1; StratifiedSampler *sampler = new StratifiedSampler( xstart, xend, ystart, yend, xsamp, ysamp, jitter, camera->shutterOpen, camera->shutterClose); //PathIntegrator *surfaceIg = CreatePathSurfaceIntegrator(params); //DirectLightingIntegrator *surfaceIg = CreateDirectLightingIntegrator(params); WhittedIntegrator *surfaceIg = CreateWhittedSurfaceIntegrator(params); SingleScatteringIntegrator *volumeIg = CreateSingleScatteringIntegrator(params); SamplerRenderer renderer(sampler, camera, surfaceIg, volumeIg, false); VolumeRegion *volumeRegion = NULL; vector<Light*> lights; float il1[] = {1.f,1.f,1.f}; float il2[] = {2.f,0.5f,0.3f}; float il3[] = {0.f,0.2f,1.3f}; lights.push_back(new PointLight(Translate(Vector(2,2,0)), RGBSpectrum::FromRGB(il1))); lights.push_back(new PointLight(Translate(Vector(-2,-2,-2)), RGBSpectrum::FromRGB(il2))); lights.push_back(new PointLight(Translate(Vector(-2, 2,-2)), RGBSpectrum::FromRGB(il3))); //(MCreatePointLight(Translate(Vector(2,2,0)), params)); //lights.push_back(CreatePointLight(Translate(Vector(0,4,0)), params)); Transform obj2world = Translate(Vector(0,0,-2)); Transform world2obj = Inverse(obj2world); Sphere *sphere1 = CreateSphereShape(&obj2world, &world2obj, false, params); Transform obj2world2 = Translate(Vector(0.7,0.7,2.6)); Transform world2obj2 = Inverse(obj2world2); Sphere *sphere2 = CreateSphereShape(&obj2world2, &world2obj2, false, params); TextureParams tparams(params, params, map<string, Reference<Texture<float> > >(), map<string, Reference<Texture<Spectrum> > >()); MirrorMaterial *mirror = new MirrorMaterial(new ConstantTexture<Spectrum>(Spectrum(0.9f)), NULL); ShinyMetalMaterial *metal = new ShinyMetalMaterial( new ConstantTexture<Spectrum>(Spectrum(1.f)), new ConstantTexture<float>(0.1f), new ConstantTexture<Spectrum>(Spectrum(1.f)), NULL); //CreateShinyMetalMaterial(Transform(), tparams); GlassMaterial *glass = CreateGlassMaterial(Transform(), tparams); //float c1[] = {0.f,10.99f,0.f}; float c1[] = {5.f,5.f,5.f}; Spectrum spec1 = RGBSpectrum::FromRGB(c1, SpectrumType::SPECTRUM_REFLECTANCE); MatteMaterial *matte = new MatteMaterial( new ConstantTexture<Spectrum>(spec1), new ConstantTexture<float>(0.0f), NULL); // Reference<Texture<Spectrum> > Kd = mp.GetSpectrumTexture("Kd", Spectrum(0.5f)); // Reference<Texture<float> > sigma = mp.GetFloatTexture("sigma", 0.f); // Reference<Texture<float> > bumpMap = mp.GetFloatTextureOrNull("bumpmap"); // return ; //CreateMatteMaterial(Transform(), tparams); Reference<Primitive> prim1 = new GeometricPrimitive(sphere1, matte, NULL); //Reference<Primitive> prim2 = new GeometricPrimitive(sphere2, metal, NULL); vector<Reference<Primitive> > prims; prims.push_back(prim1); //prims.push_back(prim2); Primitive *accel = CreateBVHAccelerator(prims, params); Scene *scene = new Scene(accel, lights, volumeRegion); // Scene(Primitive *accel, const vector<Light *> <s, VolumeRegion *vr); //TODO: // create scene // step through to see that something happens // start building minimal viable js version // - unit test js functionality against similar c++ unit results renderer.Render(scene); film->WriteImage(1); return 0; }
void NURBS::Refine(vector<Reference<Shape> > &refined) const { // Compute NURBS dicing rates int diceu = 30, dicev = 30; float *ueval = new float[diceu]; float *veval = new float[dicev]; Point *evalPs = new Point[diceu*dicev]; Normal *evalNs = new Normal[diceu*dicev]; int i; for (i = 0; i < diceu; ++i) ueval[i] = Lerp((float)i / (float)(diceu-1), umin, umax); for (i = 0; i < dicev; ++i) veval[i] = Lerp((float)i / (float)(dicev-1), vmin, vmax); // Evaluate NURBS over grid of points memset(evalPs, 0, diceu*dicev*sizeof(Point)); memset(evalNs, 0, diceu*dicev*sizeof(Point)); float *uvs = new float[2*diceu*dicev]; // Turn NURBS into triangles Homogeneous3 *Pw = (Homogeneous3 *)P; if (!isHomogeneous) { Pw = (Homogeneous3 *)alloca(nu*nv*sizeof(Homogeneous3)); for (int i = 0; i < nu*nv; ++i) { Pw[i].x = P[3*i]; Pw[i].y = P[3*i+1]; Pw[i].z = P[3*i+2]; Pw[i].w = 1.; } } for (int v = 0; v < dicev; ++v) { for (int u = 0; u < diceu; ++u) { uvs[2*(v*diceu+u)] = ueval[u]; uvs[2*(v*diceu+u)+1] = veval[v]; Vector dPdu, dPdv; Point pt = NURBSEvaluateSurface(uorder, uknot, nu, ueval[u], vorder, vknot, nv, veval[v], Pw, &dPdu, &dPdv); evalPs[v*diceu + u].x = pt.x; evalPs[v*diceu + u].y = pt.y; evalPs[v*diceu + u].z = pt.z; evalNs[v*diceu + u] = Normal(Normalize(Cross(dPdu, dPdv))); } } // Generate points-polygons mesh int nTris = 2*(diceu-1)*(dicev-1); int *vertices = new int[3 * nTris]; int *vertp = vertices; // Compute the vertex offset numbers for the triangles for (int v = 0; v < dicev-1; ++v) { for (int u = 0; u < diceu-1; ++u) { #define VN(u,v) ((v)*diceu+(u)) *vertp++ = VN(u, v); *vertp++ = VN(u+1, v); *vertp++ = VN(u+1, v+1); *vertp++ = VN(u, v); *vertp++ = VN(u+1, v+1); *vertp++ = VN(u, v+1); #undef VN } } int nVerts = diceu*dicev; ParamSet paramSet; paramSet.AddInt("indices", vertices, 3*nTris); paramSet.AddPoint("P", evalPs, nVerts); paramSet.AddFloat("uv", uvs, 2 * nVerts); paramSet.AddNormal("N", evalNs, nVerts); refined.push_back(MakeShape("trianglemesh", ObjectToWorld, reverseOrientation, paramSet)); // Cleanup from NURBS refinement delete[] uvs; delete[] ueval; delete[] veval; delete[] evalPs; delete[] evalNs; delete[] vertices; }