예제 #1
0
파일: disc.cpp 프로젝트: codemodo/renderer
Intersection Disc::GetIntersection(Ray r)
{
    //Transform the ray
    Ray r_loc = r.GetTransformedCopy(transform.invT());
    Intersection result;

    //Ray-plane intersection
    float t = glm::dot(glm::vec3(0,0,1), (glm::vec3(0.5f, 0.5f, 0) - r_loc.origin)) / glm::dot(glm::vec3(0,0,1), r_loc.direction);
    glm::vec4 P = glm::vec4(t * r_loc.direction + r_loc.origin, 1);
    //Check that P is within the bounds of the disc (not bothering to take the sqrt of the dist b/c we know the radius)
    float dist2 = (P.x * P.x + P.y * P.y);
    if(t > 0 && dist2 <= 0.25f)
    {
        result.point = glm::vec3(transform.T() * P);
        result.normal = glm::normalize(glm::vec3(transform.invTransT() * glm::vec4(ComputeNormal(glm::vec3(P)), 0)));
        result.object_hit = this;
        result.t = glm::distance(result.point, r.origin);
        //was interp
        result.texture_color = Material::GetImageColor(GetUVCoordinates(glm::vec3(P)), material->texture);

        //Compute tangent and bitangent
        glm::vec3 T = glm::normalize(glm::cross(glm::vec3(0,1,0), ComputeNormal(glm::vec3(P))));
        glm::vec3 B = glm::cross(ComputeNormal(glm::vec3(P)), T);
        result.tangent = glm::normalize(glm::vec3(transform.T() * glm::vec4(T, 0)));
        result.bitangent = glm::normalize(glm::vec3(transform.T() * glm::vec4(B, 0)));
    }
    return result;
}
예제 #2
0
Intersection SquarePlane::GetIntersection(Ray r)
{
    //Transform the ray
    Ray r_loc = r.GetTransformedCopy(transform.invT());
    Intersection result;

    //Ray-plane intersection
    float t = glm::dot(glm::vec3(0,0,1), (glm::vec3(0.5f, 0.5f, 0) - r_loc.origin)) / glm::dot(glm::vec3(0,0,1), r_loc.direction);
    glm::vec4 P = glm::vec4(t * r_loc.direction + r_loc.origin, 1);
    //Check that P is within the bounds of the square
    if(t > 0 && P.x >= -0.5f && P.x <= 0.5f && P.y >= -0.5f && P.y <= 0.5f)
    {
        result.point = glm::vec3(transform.T() * P);
        result.normal = glm::normalize(glm::vec3(transform.invTransT() * glm::vec4(ComputeNormal(glm::vec3(P)), 0)));
        result.object_hit = this;
        result.t = glm::distance(result.point, r.origin);
        result.texture_color = Material::GetImageColorInterp(GetUVCoordinates(glm::vec3(P)), material->texture);
        // Store the tangent and bitangent
        glm::vec3 tangent;
        glm::vec3 bitangent;
        ComputeTangents(ComputeNormal(glm::vec3(P)), tangent, bitangent);
        result.tangent = glm::normalize(glm::vec3(transform.T() * glm::vec4(tangent, 0)));
        result.bitangent = glm::normalize(glm::vec3(transform.T() * glm::vec4(bitangent, 0)));

        return result;
    }
    return result;
}
예제 #3
0
Intersection SquarePlane::GetIntersection(Ray r)
{
    //Transform the ray
    Ray rLocal = r.GetTransformedCopy(transform.invT());
    Intersection result;

    //Ray-plane intersection
    float t = glm::dot(glm::vec3(0,0,1), (glm::vec3(0.5f, 0.5f, 0) - rLocal.origin)) / glm::dot(glm::vec3(0,0,1), rLocal.direction);
    glm::vec4 P = glm::vec4(t * rLocal.direction + rLocal.origin, 1);
    //Check that P is within the bounds of the square
    if(t > 0 && P.x >= -0.5f && P.x <= 0.5f && P.y >= -0.5f && P.y <= 0.5f)
    {
        result.point = glm::vec3(transform.T() * P);
        result.normal = glm::normalize(glm::vec3(transform.invTransT() * glm::vec4(ComputeNormal(glm::vec3(P)), 0)));
        result.object_hit = this;
        result.t = glm::distance(result.point, r.origin);
        //was interp
        result.texture_color = Material::GetImageColor(GetUVCoordinates(glm::vec3(P)), material->texture);

        glm::vec3 T = glm::normalize(glm::cross(glm::vec3(0,1,0), ComputeNormal(glm::vec3(P))));
        glm::vec3 B = glm::cross(ComputeNormal(glm::vec3(P)), T);
        result.tangent = glm::normalize(glm::vec3(transform.T() * glm::vec4(T, 0)));
        result.bitangent = glm::normalize(glm::vec3(transform.T() * glm::vec4(B, 0)));

        return result;
    }
    return result;
}
예제 #4
0
glm::vec3 Face::computeNormal() const {
  // note: this face might be non-planar, so average the two triangle normals
  glm::vec3 a = (*this)[0]->get();
  glm::vec3 b = (*this)[1]->get();
  glm::vec3 c = (*this)[2]->get();
  glm::vec3 d = (*this)[3]->get();
  return 0.5f * (ComputeNormal(a,b,c) + ComputeNormal(a,c,d));
}
Vec3f Face::computeNormal() const {
  // note: this face might be non-planar, so average the two triangle normals
  Vec3f a = (*this)[0]->get();
  Vec3f b = (*this)[1]->get();
  Vec3f c = (*this)[2]->get();
  Vec3f d = (*this)[3]->get();
  return 0.5 * (ComputeNormal(a,b,c) + ComputeNormal(a,c,d));
}
예제 #6
0
void Triangle::ReplaceVertex(Vertex *vold,Vertex *vnew) 
{
	assert(vold && vnew);
	assert(vold==vertex[0] || vold==vertex[1] || vold==vertex[2]);
	assert(vnew!=vertex[0] && vnew!=vertex[1] && vnew!=vertex[2]);
	if(vold==vertex[0]){
		vertex[0]=vnew;
	}
	else if(vold==vertex[1]){
		vertex[1]=vnew;
	}
	else {
		assert(vold==vertex[2]);
		vertex[2]=vnew;
	}
	Remove(vold->face,this);
	assert(!Contains(vnew->face,this));
	vnew->face.push_back(this);
	for (int i = 0; i<3; i++) {
		vold->RemoveIfNonNeighbor(vertex[i]);
		vertex[i]->RemoveIfNonNeighbor(vold);
	}
	for (int i = 0; i<3; i++) {
		assert(Contains(vertex[i]->face,this)==1);
		for(int j=0;j<3;j++) if(i!=j) {
			AddUnique(vertex[i]->neighbor,vertex[j]);
		}
	}
	ComputeNormal();
}
예제 #7
0
	bool OpenglProject::GetNormalFromIDs(int idx1, int idz1, int idx2, int idz2, int idx3, int idz3,
		int xResolution, int zResolution, Vector3& normal, float* vertex_array)
	{
		if( idx1 >= 0 && idx1 < xResolution
			&& idx2 >= 0 && idx2 < xResolution
			&& idx3 >= 0 && idx3 < xResolution
			&& idz1 >= 0 && idz1 < zResolution
			&& idz2 >= 0 && idz2 < zResolution
			&& idz3 >= 0 && idz3 < zResolution )
		{


			float fx1 = vertex_array[ ( idx1 * zResolution + idz1) * 3];
			float fy1 = vertex_array[ ( idx1 * zResolution + idz1) * 3 + 1];
			float fz1 = vertex_array[ ( idx1 * zResolution + idz1) * 3 + 2];

			float fx2 = vertex_array[ ( idx2 * zResolution + idz2) * 3];
			float fy2 = vertex_array[ ( idx2 * zResolution + idz2) * 3 + 1];
			float fz2 = vertex_array[ ( idx2 * zResolution + idz2) * 3 + 2];

			float fx3 = vertex_array[ ( idx3 * zResolution + idz3) * 3];
			float fy3 = vertex_array[ ( idx3 * zResolution + idz3) * 3 + 1];
			float fz3 = vertex_array[ ( idx3 * zResolution + idz3) * 3 + 2];

			normal = ComputeNormal(Vector3(fx1, fy1, fz1), 
				Vector3(fx2, fy2, fz2),
				Vector3(fx3, fy3, fz3));
			normal = normalize(normal);
			return true;
		}

		return false;
	}
void ObjMesh::Init()
{
	ReadFromFile(filePath.c_str(), scale_factor);
	ComputeNormal();
	ApplyTransformation();
	ComputeAABB();
}
예제 #9
0
RadianceShape::RadianceShape(std::vector<Vector3f> vertexList, std::vector<int> indiceList)
  : Element()
{
  _vertices = new Vertex[vertexList.size()];
  _normal = new Vector3f[vertexList.size()];
  _indices = new int[indiceList.size()];
 
   _nbVertices = vertexList.size();
   _nbIndices = indiceList.size();
  
  for (int i = 0 ; i < (int) _nbVertices ; ++i)
  {
    _vertices[i].position = glm::vec3(vertexList[i]._x, vertexList[i]._y, vertexList[i]._z);
	}

 for (int i = 0; i < (int) _nbIndices; ++i)
	{
		_indices[i] = indiceList[i];
	}

 ComputeNormal();



}
예제 #10
0
void Triangle::ReplaceVertex(Vertex *vold,Vertex *vnew) 
{
	ASSERT(vold && vnew);
	ASSERT(vold==vertex[0] || vold==vertex[1] || vold==vertex[2]);
	ASSERT(vnew!=vertex[0] && vnew!=vertex[1] && vnew!=vertex[2]);

	if( vold==vertex[0] )
		vertex[0]=vnew;
	else if( vold==vertex[1] )
		vertex[1]=vnew;
	else 
		vertex[2]=vnew;

	vold->face.removeSearch(this);

	ASSERT(vnew->face.search(this) < 0);
	vnew->face.push(this);

	int i =0;
	for(;i<3;i++) 
	{
		vold->RemoveIfNonNeighbor(vertex[i]);
		vertex[i]->RemoveIfNonNeighbor(vold);
	}
	for(i=0;i<3;i++) 
	{
		ASSERT( vertex[i]->face.search(this) >= 0 );
		for(int j=0;j<3;j++) 
			if(i!=j) 
				vertex[i]->neighbor.pushUnique( vertex[j] );
	}

	ComputeNormal();
}
예제 #11
0
/* Determine the polygon normal and project vertices onto the plane
 * of the polygon.
 */
void __gl_projectPolygon( GLUtesselator *tess )
{
  GLUvertex *v, *vHead = &tess->mesh->vHead;
  GLdouble norm[3];
  GLdouble *sUnit, *tUnit;
  int i, computedNormal = FALSE;

  norm[0] = tess->normal[0];
  norm[1] = tess->normal[1];
  norm[2] = tess->normal[2];
  if( norm[0] == 0 && norm[1] == 0 && norm[2] == 0 ) {
    ComputeNormal( tess, norm );
    computedNormal = TRUE;
  }
  sUnit = tess->sUnit;
  tUnit = tess->tUnit;
  i = LongAxis( norm );

#if defined(FOR_TRITE_TEST_PROGRAM) || defined(TRUE_PROJECT)
  /* Choose the initial sUnit vector to be approximately perpendicular
   * to the normal.
   */
  Normalize( norm );

  sUnit[i] = 0;
  sUnit[(i+1)%3] = S_UNIT_X;
  sUnit[(i+2)%3] = S_UNIT_Y;

  /* Now make it exactly perpendicular */
  w = Dot( sUnit, norm );
  sUnit[0] -= w * norm[0];
  sUnit[1] -= w * norm[1];
  sUnit[2] -= w * norm[2];
  Normalize( sUnit );

  /* Choose tUnit so that (sUnit,tUnit,norm) form a right-handed frame */
  tUnit[0] = norm[1]*sUnit[2] - norm[2]*sUnit[1];
  tUnit[1] = norm[2]*sUnit[0] - norm[0]*sUnit[2];
  tUnit[2] = norm[0]*sUnit[1] - norm[1]*sUnit[0];
  Normalize( tUnit );
#else
  /* Project perpendicular to a coordinate axis -- better numerically */
  sUnit[i] = 0;
  sUnit[(i+1)%3] = S_UNIT_X;
  sUnit[(i+2)%3] = S_UNIT_Y;

  tUnit[i] = 0;
  tUnit[(i+1)%3] = (norm[i] > 0) ? -S_UNIT_Y : S_UNIT_Y;
  tUnit[(i+2)%3] = (norm[i] > 0) ? S_UNIT_X : -S_UNIT_X;
#endif

  /* Project the vertices onto the sweep plane */
  for( v = vHead->next; v != vHead; v = v->next ) {
    v->s = Dot( v->coords, sUnit );
    v->t = Dot( v->coords, tUnit );
  }
  if( computedNormal ) {
    CheckOrientation( tess );
  }
}
예제 #12
0
Intersection SquarePlane::GetSampledIntersection(float randX, float randY, const glm::vec3 &isx_normal)
{
    glm::vec4 point = glm::vec4(-0.5 + randX, -0.5 + randY, 0.f, 1.f);
    Intersection result;
    result.point = glm::vec3(transform.T() * point);
    result.normal = glm::normalize(glm::vec3(transform.invTransT() * glm::vec4(ComputeNormal(glm::vec3(point)), 0)));
    result.object_hit = this;
    result.texture_color = Material::GetImageColor(GetUVCoordinates(glm::vec3(point)), material->texture);
    return result;
}
예제 #13
0
void Face::computeCachedNormal()
{
	// note: this face might be non-planar, so average the two triangle normals
	Vec3f a = (*this)[0]->get();
	Vec3f b = (*this)[1]->get();
	Vec3f c = (*this)[2]->get();
	Vec3f d = (*this)[3]->get();

	//Checks to make sure we don't have three points that we are using here to check the normal be linear -- that could cause errors!! 
	if(isLinear(a,b,c)){
		cached_normal = new Vec3f(ComputeNormal(a,c,d));
		return;
	}
	if(isLinear(a,c,d)){
		cached_normal = new Vec3f(ComputeNormal(a,b,c));
		return;
	}
	cached_normal = new Vec3f(0.5 * (ComputeNormal(a,b,c) + ComputeNormal(a,c,d)));
	return;
}
예제 #14
0
Triangle::Triangle(Vertex *v0,Vertex *v1,Vertex *v2){
	assert(v0!=v1 && v1!=v2 && v2!=v0);
	vertex[0]=v0;
	vertex[1]=v1;
	vertex[2]=v2;
	ComputeNormal();
	triangles.push_back(this);
	for(int i=0;i<3;i++) {
		vertex[i]->face.push_back(this);
		for(int j=0;j<3;j++) if(i!=j) {
			AddUnique(vertex[i]->neighbor, vertex[j]);
		}
	}
}
예제 #15
0
파일: Shape.cpp 프로젝트: MegatronX/KHMPOld
void Shape::UpdateOutline()
{
    unsigned int count = myVertices.GetVertexCount() - 2;
    myOutlineVertices.Resize((count + 1) * 2);

    for (unsigned int i = 0; i < count; ++i)
    {
        unsigned int index = i + 1;

        // Get the two segments shared by the current point
        Vector2f p0 = (i == 0) ? myVertices[count].Position : myVertices[index - 1].Position;
        Vector2f p1 = myVertices[index].Position;
        Vector2f p2 = myVertices[index + 1].Position;

        // Compute their normal
        Vector2f n1 = ComputeNormal(p0, p1);
        Vector2f n2 = ComputeNormal(p1, p2);

        // Combine them to get the extrusion direction
        float factor = 1.f + (n1.x * n2.x + n1.y * n2.y);
        Vector2f normal = -(n1 + n2) / factor;

        // Update the outline points
        myOutlineVertices[i * 2 + 0].Position = p1;
        myOutlineVertices[i * 2 + 1].Position = p1 + normal * myOutlineThickness;
    }

    // Duplicate the first point at the end, to close the outline
    myOutlineVertices[count * 2 + 0].Position = myOutlineVertices[0].Position;
    myOutlineVertices[count * 2 + 1].Position = myOutlineVertices[1].Position;

    // Update outline colors
    UpdateOutlineColors();

    // Update the shape's bounds
    myBounds = myOutlineVertices.GetBounds();
}
예제 #16
0
파일: render.cpp 프로젝트: benstreb/Gorilla
void Mesh::SetupFloor() {
  Vec3f diff = bbox.getMax()-bbox.getMin();
  // create vertices just a bit bigger than the bounding box
  Vec3f a = bbox.getMin() + Vec3f(-0.75*diff.x(),0,-0.75*diff.z());
  Vec3f b = bbox.getMin() + Vec3f( 1.75*diff.x(),0,-0.75*diff.z());
  Vec3f c = bbox.getMin() + Vec3f(-0.75*diff.x(),0, 1.75*diff.z());
  Vec3f d = bbox.getMin() + Vec3f( 1.75*diff.x(),0, 1.75*diff.z());
  Vec3f normal = ComputeNormal(a,c,d);
  floor_quad_verts.push_back(VBOPosNormal(a,normal));
  floor_quad_verts.push_back(VBOPosNormal(c,normal));
  floor_quad_verts.push_back(VBOPosNormal(d,normal));
  floor_quad_verts.push_back(VBOPosNormal(b,normal));
  glBindBuffer(GL_ARRAY_BUFFER,floor_quad_verts_VBO); 
  glBufferData(GL_ARRAY_BUFFER,sizeof(VBOPosNormal)*4,&floor_quad_verts[0],GL_STATIC_DRAW); 
}
예제 #17
0
  SliceOrdering::SliceOrdering(ServerIndex& index,
                               const std::string& seriesId) :
    index_(index),
    seriesId_(seriesId),
    isVolume_(false)
  {
    ComputeNormal();
    CreateInstances();

    if (!SortUsingPositions() &&
        !SortUsingIndexInSeries())
    {
      LOG(ERROR) << "Unable to order the slices of the series " << seriesId;
      throw OrthancException(ErrorCode_CannotOrderSlices);
    }
  }
예제 #18
0
파일: disc.cpp 프로젝트: codemodo/renderer
Intersection Disc::GetSampledIntersection(float randX, float randY, const glm::vec3 &isx_normal)
{
    float r = sqrtf(randX);
    float theta = 2.f * M_PI * randY;
    glm::vec4 point = glm::vec4(
                        r*cosf(theta),
                        r*sinf(theta),
                        0.f,
                        1.f
                       );
    Intersection result;
    result.point = glm::vec3(transform.T() * point);
    result.normal = glm::normalize(glm::vec3(transform.invTransT() * glm::vec4(ComputeNormal(glm::vec3(point)), 0)));
    result.object_hit = this;
    result.texture_color = Material::GetImageColor(GetUVCoordinates(glm::vec3(point)), material->texture);
    return result;
}
예제 #19
0
Triangle::Triangle(Vertex *v0,Vertex *v1,Vertex *v2)
{
	ASSERT(v0!=v1 && v1!=v2 && v2!=v0);

	vertex[0]=v0;
	vertex[1]=v1;
	vertex[2]=v2;

	ComputeNormal();
	s_Triangles.push(this);

	for(int i=0;i<3;i++) 
	{
		vertex[i]->face.push(this);
		for(int j=0;j<3;j++) 
			if(i != j) 
				vertex[i]->neighbor.pushUnique( vertex[j] );
	}
}
예제 #20
0
파일: polygon.cpp 프로젝트: PNZA/ICT290
CPolygon::CPolygon(vector<CVector>& verts, vector<tex_coord_t>& tex_coords)
{
	assert(verts.size() == tex_coords.size());

	//Looks a little messy, but it's so we only use one iterator instead of two.
	vector<CVector>::iterator vert_itr;
	unsigned int i = 0;

	for(vert_itr = verts.begin(); vert_itr!= verts.end(); vert_itr++)
	{
		m_verts.push_back(*vert_itr);
		m_tex_coords.push_back((tex_coords)[i]);
		i++;
	}

	//make sure it was all copied over correctly
	assert(m_verts.size() == m_tex_coords.size());

	ComputeNormal();
	m_cached_midpoint = GetMidpoint();
}
예제 #21
0
void Terrain::Initialize(const char* sTexture, const char* sHeightMap, const char* sNormalMap, float fHeight)
{
	SetHeight(fHeight);

	ImageBMP* image = new ImageBMP(m_OpenGL);
	image->Load(sHeightMap);

	m_Texture = new Texture(m_OpenGL);
	TextureID = m_Texture->GetTexture2D(sTexture);

	iWidth = image->GetWidth();
	iHeight = image->GetHeight();

	hs = new float*[image->GetHeight()];
	Normal = new Vector3f*[image->GetHeight()];
	NormalTemp = new Vector3f*[image->GetHeight()];

	for (unsigned int i = 0; i < image->GetHeight(); ++i)
	{
		hs[i] = new float[image->GetWidth()];
		Normal[i] = new Vector3f[image->GetWidth()];
		NormalTemp[i] = new Vector3f[image->GetWidth()];
	}

	for (unsigned int y = 0; y < image->GetHeight(); y++)
	{
		for (unsigned int x = 0; x < image->GetWidth(); x++)
		{
			unsigned char color = (unsigned char)image->GetData()[3 * (y * image->GetWidth() + x)];
			float h = ((color / 255.0f) - 0.5f);
			SetHeight(x, y, h);
		}
	}

	ComputeNormal();
	GenerateTerrain();
	Bind();

	vPosition = Vector3f(0, -20, 0);
}
예제 #22
0
파일: render.cpp 프로젝트: benstreb/Gorilla
void Mesh::SetupMesh(triangleshashtype &triSet, GLuint VBO, std::vector<VBOPosNormal> &VBO_verts_vector) {
  for (auto iter = triSet.begin(); iter != triSet.end(); iter++) {
    Triangle *t = iter->second;
    Vec3f a = (*t)[0]->getPos();
    Vec3f b = (*t)[1]->getPos();
    Vec3f c = (*t)[2]->getPos();
    Vec3f na = ComputeNormal(a,b,c);
    Vec3f nb = na;
    Vec3f nc = na;
    if (args->gouraud_normals) {
      na = (*t)[0]->getGouraudNormal();
      nb = (*t)[1]->getGouraudNormal();
      nc = (*t)[2]->getGouraudNormal();
    }
    VBO_verts_vector.push_back(VBOPosNormal(a,na));
    VBO_verts_vector.push_back(VBOPosNormal(b,nb));
    VBO_verts_vector.push_back(VBOPosNormal(c,nc));
  }
  glBindBuffer(GL_ARRAY_BUFFER, VBO);
  glBufferData(GL_ARRAY_BUFFER,
         sizeof(VBOPosNormal) * numTriangles(triSet) * 3,
         &VBO_verts_vector[0],
         GL_STATIC_DRAW);
}
예제 #23
0
/* __gl_renderCache( tess ) takes a single contour and tries to render it
 * as a triangle fan.  This handles convex polygons, as well as some
 * non-convex polygons if we get lucky.
 *
 * Returns TRUE if the polygon was successfully rendered.  The rendering
 * output is provided as callbacks (see the api).
 */
GLboolean __gl_renderCache( GLUtesselator *tess )
{
  CachedVertex *v0 = tess->cache;
  CachedVertex *vn = v0 + tess->cacheCount;
  CachedVertex *vc;
  GLdouble norm[3];
  int sign;

  if( tess->cacheCount < 3 ) {
    /* Degenerate contour -- no output */
    return TRUE;
  }

  norm[0] = tess->normal[0];
  norm[1] = tess->normal[1];
  norm[2] = tess->normal[2];
  if( norm[0] == 0 && norm[1] == 0 && norm[2] == 0 ) {
    ComputeNormal( tess, norm, FALSE );
  }

  sign = ComputeNormal( tess, norm, TRUE );
  if( sign == SIGN_INCONSISTENT ) {
    /* Fan triangles did not have a consistent orientation */
    return FALSE;
  }
  if( sign == 0 ) {
    /* All triangles were degenerate */
    return TRUE;
  }

  /* Make sure we do the right thing for each winding rule */
  switch( tess->windingRule ) {
  case GLU_TESS_WINDING_ODD:
  case GLU_TESS_WINDING_NONZERO:
    break;
  case GLU_TESS_WINDING_POSITIVE:
    if( sign < 0 ) return TRUE;
    break;
  case GLU_TESS_WINDING_NEGATIVE:
    if( sign > 0 ) return TRUE;
    break;
  case GLU_TESS_WINDING_ABS_GEQ_TWO:
    return TRUE;
  }

  CALL_BEGIN_OR_BEGIN_DATA( tess->boundaryOnly ? GL_LINE_LOOP
			  : (tess->cacheCount > 3) ? GL_TRIANGLE_FAN
			  : GL_TRIANGLES );

  CALL_VERTEX_OR_VERTEX_DATA( v0->data );
  if( sign > 0 ) {
    for( vc = v0+1; vc < vn; ++vc ) {
      CALL_VERTEX_OR_VERTEX_DATA( vc->data );
    }
  } else {
    for( vc = vn-1; vc > v0; --vc ) {
      CALL_VERTEX_OR_VERTEX_DATA( vc->data );
    }
  }
  CALL_END_OR_END_DATA();
  return TRUE;
}
예제 #24
0
//==================================================================================
void HullLibrary::AddConvexTriangle(ConvexHullTriangleInterface *callback,const float *p1,const float *p2,const float *p3)
{
	ConvexHullVertex v1,v2,v3;

	#define TSCALE1 (1.0f/4.0f)

	v1.mPos[0] = p1[0];
	v1.mPos[1] = p1[1];
	v1.mPos[2] = p1[2];

	v2.mPos[0] = p2[0];
	v2.mPos[1] = p2[1];
	v2.mPos[2] = p2[2];

	v3.mPos[0] = p3[0];
	v3.mPos[1] = p3[1];
	v3.mPos[2] = p3[2];

	float n[3];
	ComputeNormal(n,p1,p2,p3);

	v1.mNormal[0] = n[0];
	v1.mNormal[1] = n[1];
	v1.mNormal[2] = n[2];

	v2.mNormal[0] = n[0];
	v2.mNormal[1] = n[1];
	v2.mNormal[2] = n[2];

	v3.mNormal[0] = n[0];
	v3.mNormal[1] = n[1];
	v3.mNormal[2] = n[2];

	const float *tp1 = p1;
	const float *tp2 = p2;
	const float *tp3 = p3;

	int32_t i1 = 0;
	int32_t i2 = 0;

	float nx = fabsf(n[0]);
	float ny = fabsf(n[1]);
	float nz = fabsf(n[2]);

	if ( nx <= ny && nx <= nz )
		i1 = 0;
	if ( ny <= nx && ny <= nz )
		i1 = 1;
	if ( nz <= nx && nz <= ny )
		i1 = 2;

	switch ( i1 )
	{
		case 0:
			if ( ny < nz )
				i2 = 1;
			else
				i2 = 2;
			break;
		case 1:
			if ( nx < nz )
				i2 = 0;
			else
				i2 = 2;
			break;
		case 2:
			if ( nx < ny )
				i2 = 0;
			else
				i2 = 1;
			break;
	}

	v1.mTexel[0] = tp1[i1]*TSCALE1;
	v1.mTexel[1] = tp1[i2]*TSCALE1;

	v2.mTexel[0] = tp2[i1]*TSCALE1;
	v2.mTexel[1] = tp2[i2]*TSCALE1;

	v3.mTexel[0] = tp3[i1]*TSCALE1;
	v3.mTexel[1] = tp3[i2]*TSCALE1;

	callback->ConvexHullTriangle(v3,v2,v1);
}
예제 #25
0
파일: polygon.cpp 프로젝트: PNZA/ICT290
const CVector& CPolygon::GetNormal()
{
	ComputeNormal();
	return m_normal;
}