reMesh* reFBXAsset::importMesh(FbxNode* fbxNode)
{
	qDebug() << "import mesh for" << fbxNode->GetName();
	reMesh* mesh = new reMesh;

	FbxMesh* fmesh = (FbxMesh*) fbxNode->GetNodeAttribute();
	FbxVector4* controlPoints = fmesh->GetControlPoints(); 

	for (int i=0; i<fmesh->GetPolygonCount(); i++) 
	{
		reFace* face = new reFace;
		for (int j=0; j<fmesh->GetPolygonSize(i); j++)
		{
			int vi = fmesh->GetPolygonVertex(i, j);
			reVertex vertex;
			vertex.pos = reVec3(controlPoints[vi][0], controlPoints[vi][1], controlPoints[vi][2]);
			FbxVector4 fNormal;
			fmesh->GetPolygonVertexNormal(i, j, fNormal);
			vertex.uv = getUV(fmesh, vi, i, j);
			vertex.normal = reVec3(fNormal[0], fNormal[1], fNormal[2]);
			face->vertices.push_back(vertex);	
		}
		reMaterial* mat =  getMaterial(fmesh, i, mesh->materialSet);
		mesh->addFace(face,mat ? mat->id: -1);
	}
	
	reMeshAsset* meshAsset = new reMeshAsset(meshes);
	meshAsset->mesh = mesh;
	meshes->children.push_back(meshAsset);
	meshAsset->setPath((dataDir().toStdString() + "/" + fbxNode->GetName() + ".mesh").c_str());
	mesh->save(dataDir().toStdString() + "/" + fbxNode->GetName() + ".mesh");
	return mesh;
}
Exemple #2
0
vec4 sampleLayer(sampler2D layer, LayerSettings layerSettings) {
      /*
      if (layerSettings.useConstantColor && false) {
        return layerSettings.constantColor;
      }
      */
      return texture2D(layer, getUV(layerSettings));
}
Exemple #3
0
bool sphere::hit(const ray& r, float t_min, float t_max, hit_record& rec) const
{
    vec3 oc = r.origin() - center;
    
    float v2 = dot(r.direction(), r.direction());
    float voc = dot(oc, r.direction());

    // 判別式.
    float discriminant = voc * voc - v2 * (dot(oc, oc) - radius*radius);

    if (discriminant > 0) {
        // 手前.
        float temp = (-voc - sqrt(discriminant)) / v2;

        if (temp < t_max && temp > t_min) {
            rec.t = temp;
            rec.p = r.org + rec.t * r.dir;
            
            rec.normal = (rec.p - center);
            rec.normal.noramlize();

            getUV(rec.u, rec.v, rec.normal);

            rec.mat_ptr = mat_ptr;
            return true;
        }

        // 奥.
        temp = (-voc + sqrt(discriminant)) / v2;

        if (temp < t_max && temp > t_min) {
            rec.t = temp;
            rec.p = r.org + rec.t * r.dir;
            
            rec.normal = (rec.p - center) / radius;
            rec.normal.noramlize();

            getUV(rec.u, rec.v, rec.normal);

            rec.mat_ptr = mat_ptr;
            return true;
        }
    }

    return false;
}
Colour Checkerboard::getTexture(const IntersectData& intersect,
                                const Eigen::Matrix4d& view)const{
  Colour outcolour;
  
  double* uv = getUV(intersect,view);
  outcolour = getTexture(uv);
  delete[] uv;
  return outcolour;
}
void Application::compute_cylinders(Vertex vertices[]) {
	for( size_t i = 0; i <= N; ++i ) {
		for( size_t j = 0; j <= M; ++j ) {
			float theta = i / static_cast<float>( N ), z = height*j / static_cast<float>( M );
			vertices[i + j*( N + 1 )].position = getUV(theta, z);
			vertices[i + j*( N + 1 )].colour = glm::normalize(vertices[i + j*( N + 1 )].position);
		}
	}
	/*vertices[( N + 1 )*( M + 1 )].position = glm::vec3(height,0.0f,0.0f);
	vertices[( N + 1 )*( M + 1 )].colour = vertices[( N + 1 )*( M + 1 )].position;
	vertices[( N + 1 )*( M + 1 ) + 1].position = glm::vec3(height,0.0f,0.0f);
	vertices[( N + 1 )*( M + 1 ) + 1].colour = glm::normalize(vertices[( N + 1 )*( M + 1 ) + 1].position);*/
}
Exemple #6
0
static VertexData::Vertexes loadVertexes(const aiMesh* mesh) {
    VertexData::Vertexes vertexes;

    for (auto i = 0u; i < mesh->mNumVertices; i++) {
        vertexes.add(createVertex(
            mesh->mVertices[i],
            mesh->mNormals[i],
            getUV(mesh, i, 0)
        ));
    }

    return vertexes;
}
Exemple #7
0
/*
 * This method evaluates if the intersection is inside the polygon or not, in order to to this, it does a parallel projection of the polygon
 * Then it translate the polygon to the origin, and finally using the x axe, if the number of edges that the x axe touch is odd the intersection is inside the polygon
 * if is is pair, the intersection is not in the polygon
 */
int isThePointInsideThePolygon(OBJECT *object, VECTOR *intersection) {
    LIST_NODE_PTR pointList = ((LIST_NODE_PTR) object->polygon.listOfPointsSplashPtr);
    LIST_NODE_PTR startNode = pointList;
    int numberOfWalls = 0;
    long double u, v;
    int isTheFirstOne = 1, checkLastOne = 0;
    POINT currentPoint, nextPoint, previousPoint, lastPoint;

    //First I have to get u, v values which were used to splash the polygon (Made on the load fase)
    getUV(&u, &v, &object->normal, intersection);

    //Second I have to translate the polygon to the origin in order to "Count the walls"
    while (pointList != NULL) {//I walk the list until the penultimate element, this is because I evaluate the edges and not the points
        currentPoint.x = u - pointList->data.point.x;
        currentPoint.y = v - pointList->data.point.y;

        if (pointList->nextPtr != NULL) { //Case it is not the last point
            nextPoint.x = u - pointList->nextPtr->data.point.x;
            nextPoint.y = v - pointList->nextPtr->data.point.y;
        } else { //Case it is the last point
            nextPoint.x = u - startNode->data.point.x;
            nextPoint.y = v - startNode->data.point.y;

            if (checkLastOne == 1) {
                long double nextX, nextY, previousX, previousY;
                previousX = currentPoint.x;
                previousY = currentPoint.y;
                nextX = startNode->nextPtr->data.point.x;
                nextY = startNode->nextPtr->data.point.y;

                if ((previousY > 0.0 && nextY > 0.0) || (previousY < 0.0 && nextY < 0.0)) {
                    numberOfWalls += 2;
                } else {
                    numberOfWalls++;
                }
            }

        }

        //Logic of the corners, If a corner is a minum or a maximun we have to count two if it is a nee we count it only as one
        if (currentPoint.y == 0.0 && currentPoint.x > 0.0) {
            long double nextX, nextY, previousX, previousY;
            if (isTheFirstOne != 1) {//The previous X and Y is in the last node of the list
                previousX = previousPoint.x;
                previousY = previousPoint.y;

                nextX = nextPoint.x;
                nextY = nextPoint.y;

                if ((previousY > 0.0 && nextY > 0.0) || (previousY < 0.0 && nextY < 0.0)) {
                    numberOfWalls += 2;
                } else {
                    numberOfWalls++;
                }
            } else {
                checkLastOne = 1; //Case where I have to check the first corner
            }
        }

        //trivial acceptance. Both U are positive and one v is negative and the another is positive
        if ((currentPoint.x >= 0.0 && nextPoint.x >= 0.0) &&
                ((currentPoint.y > 0.0 && nextPoint.y < 0.0) ||
                (currentPoint.y < 0.0 && nextPoint.y > 0.0))) {
            numberOfWalls++;
        } else if (((currentPoint.x >= 0.0 && nextPoint.x <= 0.0) ||
                (currentPoint.x <= 0.0 && nextPoint.x >= 0.0)) &&
                ((currentPoint.y > 0.0 && nextPoint.y < 0.0) ||
                (currentPoint.y < 0.0 && nextPoint.y > 0.0))) {//Hard Case, One v positive and the another one negative, one u positive and the another one negative
            long double m = (nextPoint.y - currentPoint.y) / (nextPoint.x - currentPoint.x);
            long double b = currentPoint.y - (m * currentPoint.x);
            long double xIntersection = (0 - b) / m;

            if (xIntersection > 0.0) {
                numberOfWalls++;
            }
        }

        previousPoint = currentPoint;

        pointList = pointList->nextPtr;
        isTheFirstOne = 0;
    }

    return (numberOfWalls % 2);
}
Exemple #8
0
void UVMapper::apply(Object &obj, Material *materialRef, unsigned short layerRef)
{
	float u,v,s,t;
	Vector normal;

	map<unsigned short, set<cvrIndex>, ltushort>::iterator h;
	/* i -- used to iterate through the set of faces which belong to the given material */
	set<cvrIndex>::iterator i;
	/* j -- used to step through the points of the face which is referenced by i */
	vector<cvrIndex>::iterator j;
	unsigned int seg;
	
	obj.buildRefList();
	if (obj.mat_reflist[materialRef].empty()) return;

	/* calculate the uv for the points referenced by this face's pointref vector */
	switch (projection_mode)
	{
	case UV_PROJECTION_CUBIC: /* cubic projection needs to know the surface normal */

		for (seg = 0; seg < obj.mat_reflist[materialRef].size(); seg++)
		{
			for (h = obj.mat_reflist[materialRef][seg].begin(); h != obj.mat_reflist[materialRef][seg].end(); h++)
			{	
				for (i = (*h).second.begin(); i != (*h).second.end(); i++)
				{
					/* check and see if the uv's are allocated, if not, allocate them */
					if ((unsigned short)obj.faces[(*i)]->uv.size() < layerRef+1) obj.faces[(*i)]->uv.resize(layerRef+1);
					if (obj.faces[(*i)]->uv[layerRef].size() != obj.faces[(*i)]->pointref.size())	obj.faces[(*i)]->uv[layerRef].resize(obj.faces[(*i)]->pointref.size());

					cvrIndex pt_count = 0;	/* used to keep track of which UV we're calculating (since pointrefs aren't necessicarily in order) */
					for (j = obj.faces[(*i)]->pointref.begin(); j != obj.faces[(*i)]->pointref.end(); j++)
					{
						XYZ uvpoint = *obj.points[*j];

						uvpoint -= center;	/* shift the point by the centerpoint */
						
						/* if we have a rotation, rotate the point to match it */
						if (rotation.x || rotation.y || rotation.z)	
						{
							XYZ npoint = uvpoint;
							rotatexyz(rotation,uvpoint,npoint);
							uvpoint = npoint;
						}

						/* first we need to check what the most 'dominant' direction of this face is (axis) */
						
						float nx, ny, nz;
						
						nx = fabs(obj.faces[(*i)]->face_normal.x);
						ny = fabs(obj.faces[(*i)]->face_normal.y);
						nz = fabs(obj.faces[(*i)]->face_normal.z);
						
						/* x portion of vector is dominant, we're mapping in the Y/Z plane */
						if (nx >= ny && nx >= nz)
						{
							/* we use a .5 offset because texture coordinates range from 0->1, so to center it we need to offset by .5 */
							s = uvpoint.z / scale.z + 0.5f;	/* account for scale here */
							t = uvpoint.y / scale.y + 0.5f;
							u = fract(s);
							v = fract(t);
						}

						/* y portion of vector is dominant, we're mapping in the X/Z plane */
						if (ny >= nx && ny >= nz)
						{
							
							s = -uvpoint.x / scale.x + 0.5f;
							t = uvpoint.z / scale.z + 0.5f;
							u = fract(s);
							v = fract(t);
						}

						/* z portion of vector is dominant, we're mapping in the X/Y plane */
						if (nz >= nx && nz >= ny)
						{
							s = -uvpoint.x / scale.x + 0.5f;
							t = uvpoint.y / scale.y + 0.5f;
							u = fract(s);
							v = fract(t);
						}

						if (obj.faces[(*i)]->face_normal.x > 0) { u = -u;  }
						if (obj.faces[(*i)]->face_normal.y < 0) { u = -u;  }
						if (obj.faces[(*i)]->face_normal.z > 0) { u = -u;  }
						
						obj.faces[(*i)]->uv[layerRef][pt_count].u = u;
						obj.faces[(*i)]->uv[layerRef][pt_count].v = v;
						pt_count++; /* next point UV please */
					}
				}
			}
		}
		break;

	default:	/* simple XYZ to UV calc will suffice for non-cubic mapping */

		for (seg = 0; seg < obj.mat_reflist[materialRef].size(); seg++)
		{
			for (h = obj.mat_reflist[materialRef][seg].begin(); h != obj.mat_reflist[materialRef][seg].end(); h++)
			{	
				for (i = (*h).second.begin(); i != (*h).second.end(); i++)
				{
					if ((unsigned short)obj.faces[(*i)]->uv.size() < layerRef+1) obj.faces[(*i)]->uv.resize(layerRef+1);
					if (obj.faces[(*i)]->uv[layerRef].size() != obj.faces[(*i)]->pointref.size())	obj.faces[(*i)]->uv[layerRef].resize(obj.faces[(*i)]->pointref.size());
			
					cvrIndex pt_count = 0;	
					for (j = obj.faces[(*i)]->pointref.begin(); j != obj.faces[(*i)]->pointref.end(); j++)
					{
						getUV(*obj.points[*j], obj.faces[*i]->uv[layerRef][pt_count++]);	/* map it, see getUV */
					}
				}
			}
		}
		break;
	}
};