Example #1
0
void TessMeshApp::Update(){
    App::Update();
    
    
    mesh->Update();
    
    meshShaderProgram->use();
    
    GLuint m = meshShaderProgram->uniform("model");
    glUniformMatrix4fv(m, 1, GL_FALSE, glm::value_ptr(mesh->modelMatrix));
    
    GLuint v = meshShaderProgram->uniform("view");
    glUniformMatrix4fv(v, 1, GL_FALSE, glm::value_ptr(camera.view));
    
    GLuint p = meshShaderProgram->uniform("projection");
    glUniformMatrix4fv(p, 1, GL_FALSE, glm::value_ptr(camera.projection));
    
    
    meshShaderProgram->disable();
    
    
    mouseShaderProgram->use();
    
    m = mouseShaderProgram->uniform("model");
    glUniformMatrix4fv(m, 1, GL_FALSE, glm::value_ptr(mesh->modelMatrix));
    
    v = mouseShaderProgram->uniform("view");
    glUniformMatrix4fv(v, 1, GL_FALSE, glm::value_ptr(camera.view));
    
    p = mouseShaderProgram->uniform("projection");
    glUniformMatrix4fv(p, 1, GL_FALSE, glm::value_ptr(camera.projection));
    


    // cursor
    {
        vec2 mouse = mouse_cursor;
        
        
        
        vec3 view = normalize( camera.camera_look_at - camera.camera_position );
        
        vec3 h = normalize(cross(view, camera.camera_up));
        
        vec3 v = normalize(cross(h, view));
        float rad = radians(camera.field_of_view);
        
        float vLength = tanf(rad /2.0f) * camera.near_clip;
        float hLength = vLength * camera.aspect;
        
        v *= vLength;
        h *= hLength;
        
        mouse.x -= window_width/2;
        mouse.y = window_height - mouse.y - window_height/2;
        
        mouse.x /= window_width/2;
        mouse.y /= window_height/2;
        
        vec3 pos = camera.camera_position + view * (float)camera.near_clip + h*mouse.x + v*mouse.y;
        
        
        GLuint mousePosition = mouseShaderProgram->uniform("mousePosition");

        glUniform3fv(mousePosition, 1, value_ptr(pos));
    
    }
    
    mouseShaderProgram->disable();
    
}
Example #2
0
Distance3f distance_trianglef(const float3 p, const float3* poly) {
  const float3 normal = normalize(cross(poly[1]-poly[0], poly[2]-poly[0]));

  // Degenerate triangle
  if (normal.x != normal.x) {
    // Hack to safely fail if triangle is degenerate
    float max_d = length2(poly[1]-poly[0]);
    float3 a = poly[1];
    float3 b = poly[0];
    if (length2(poly[2]-poly[1]) > max_d) {
      max_d = length2(poly[2]-poly[1]);
      a = poly[2];
      b = poly[1];
    }
    if (length2(poly[2]-poly[0]) > max_d) {
      // No need to reset max_d
      a = poly[2];
      b = poly[0];
    }
    return distance_line3(p, a, b);
  }

  const float proj_dist = dot((p - poly[0]), normal);

  const float3 proj_pnt = p - (normal * proj_dist);
  float dist = fabs(proj_dist);

  int drop_dim = 0;
  float drop_dim_val = fabs(normal.x);
  if (fabs(normal.y) > drop_dim_val) {
    drop_dim = 1;
    drop_dim_val = fabs(normal.y);
  }
  if (fabs(normal.z) > drop_dim_val) {
    drop_dim = 2;
    drop_dim_val = fabs(normal.z);
  }

  float2 poly_proj[3];
  float2 proj_proj_pnt;

#ifdef OPEN_CL
  for (int i = 0; i < 3; ++i) {
    if (drop_dim == 0) {
      poly_proj[i] = poly[i].yz;
    } else if (drop_dim == 1) {
      poly_proj[i] = poly[i].xz;
    } else {
      poly_proj[i] = poly[i].xy;
    }
  }
  if (drop_dim == 0) {
    proj_proj_pnt = proj_pnt.yz;
  } else if (drop_dim == 1) {
    proj_proj_pnt = proj_pnt.xz;
  } else {
    proj_proj_pnt = proj_pnt.xy;
  }
#else
  for (int i = 0; i < 3; ++i) {
    if (drop_dim == 0) {
      poly_proj[i] = make_float2(poly[i].y, poly[i].z);
    } else if (drop_dim == 1) {
      poly_proj[i] = make_float2(poly[i].x, poly[i].z);
    } else {
      poly_proj[i] = make_float2(poly[i].x, poly[i].y);
    }
  }
  if (drop_dim == 0) {
    proj_proj_pnt = make_float2(proj_pnt.y, proj_pnt.z);
  } else if (drop_dim == 1) {
    proj_proj_pnt = make_float2(proj_pnt.x, proj_pnt.z);
  } else {
    proj_proj_pnt = make_float2(proj_pnt.x, proj_pnt.y);
  }
#endif

  float2 poly_shift[3];
  for (int i = 0; i < 3; ++i) {
    poly_shift[i] = poly_proj[i] - proj_proj_pnt;
  }

  bool test_val;
  bool first_time = true;
  bool inside = true;
  for (int i = 0; i < 3; ++i) {
    float2 v = poly_shift[i];
    float2 vn = poly_shift[(i+1) % 3];
    float area = vn.x*v.y - v.x*vn.y;  // actually is twice area
    if (first_time) {
      test_val = area > 0;
      first_time = false;
    } else {
      if (test_val != area > 0) {
        inside = false;
        break;
      }
    }
  }

  if (inside) {
    // nan!
    /* assert(dist == dist); */

    // dist is set at start of function to be proj distance
    Distance3f d = { dist, proj_pnt };
    return d;
  } else {
    bool unset = true;
    Distance3f best;
    for (int i = 0; i < 3; ++i) {
      if (unset) {
        best = distance_line3(p, poly[i], poly[(i+1)%3]);
        unset = false;
      } else {
        Distance3f dist = distance_line3(p, poly[i], poly[(i+1)%3]);
        best = min_pair3f(best, dist);
      }
    }
    // nan!
    /* assert(best.d == best.d) { */
    return best;
  }
}
Example #3
0
double Vector2D::angleBetween(const Vector2D &a, const Vector2D &b)
{
    return atan2(cross(a, b), scalar(a, b));
}
Example #4
0
int HullLibrary::calchullgen(btVector3 *verts,int verts_count, int vlimit)
{
    if(verts_count <4) return 0;
    if(vlimit==0) vlimit=1000000000;
    int j;
    btVector3 bmin(*verts),bmax(*verts);
    btAlignedObjectArray<int> isextreme;
    isextreme.reserve(verts_count);
    btAlignedObjectArray<int> allow;
    allow.reserve(verts_count);

    for(j=0;j<verts_count;j++)
    {
        allow.push_back(1);
        isextreme.push_back(0);
        bmin.setMin (verts[j]);
        bmax.setMax (verts[j]);
    }
    btScalar epsilon = (bmax-bmin).length() * btScalar(0.001);
    btAssert (epsilon != 0.0);


    int4 p = FindSimplex(verts,verts_count,allow);
    if(p.x==-1) return 0; // simplex failed



    btVector3 center = (verts[p[0]]+verts[p[1]]+verts[p[2]]+verts[p[3]]) / btScalar(4.0);  // a valid interior point
    btHullTriangle *t0 = allocateTriangle(p[2],p[3],p[1]); t0->n=int3(2,3,1);
    btHullTriangle *t1 = allocateTriangle(p[3],p[2],p[0]); t1->n=int3(3,2,0);
    btHullTriangle *t2 = allocateTriangle(p[0],p[1],p[3]); t2->n=int3(0,1,3);
    btHullTriangle *t3 = allocateTriangle(p[1],p[0],p[2]); t3->n=int3(1,0,2);
    isextreme[p[0]]=isextreme[p[1]]=isextreme[p[2]]=isextreme[p[3]]=1;
    checkit(t0);checkit(t1);checkit(t2);checkit(t3);

    for(j=0;j<m_tris.size();j++)
    {
        btHullTriangle *t=m_tris[j];
        btAssert(t);
        btAssert(t->vmax<0);
        btVector3 n=TriNormal(verts[(*t)[0]],verts[(*t)[1]],verts[(*t)[2]]);
        t->vmax = maxdirsterid(verts,verts_count,n,allow);
        t->rise = dot(n,verts[t->vmax]-verts[(*t)[0]]);
    }
    btHullTriangle *te;
    vlimit-=4;
    while(vlimit >0 && ((te=extrudable(epsilon)) != 0))
    {
        int3 ti=*te;
        int v=te->vmax;
        btAssert(v != -1);
        btAssert(!isextreme[v]);  // wtf we've already done this vertex
        isextreme[v]=1;
        //if(v==p0 || v==p1 || v==p2 || v==p3) continue; // done these already
        j=m_tris.size();
        while(j--) {
            if(!m_tris[j]) continue;
            int3 t=*m_tris[j];
            if(above(verts,t,verts[v],btScalar(0.01)*epsilon))
            {
                extrude(m_tris[j],v);
            }
        }
        // now check for those degenerate cases where we have a flipped triangle or a really skinny triangle
        j=m_tris.size();
        while(j--)
        {
            if(!m_tris[j]) continue;
            if(!hasvert(*m_tris[j],v)) break;
            int3 nt=*m_tris[j];
            if(above(verts,nt,center,btScalar(0.01)*epsilon)  || cross(verts[nt[1]]-verts[nt[0]],verts[nt[2]]-verts[nt[1]]).length()< epsilon*epsilon*btScalar(0.1) )
            {
                btHullTriangle *nb = m_tris[m_tris[j]->n[0]];
                btAssert(nb);btAssert(!hasvert(*nb,v));btAssert(nb->id<j);
                extrude(nb,v);
                j=m_tris.size();
            }
        }
        j=m_tris.size();
        while(j--)
        {
            btHullTriangle *t=m_tris[j];
            if(!t) continue;
            if(t->vmax>=0) break;
            btVector3 n=TriNormal(verts[(*t)[0]],verts[(*t)[1]],verts[(*t)[2]]);
            t->vmax = maxdirsterid(verts,verts_count,n,allow);
            if(isextreme[t->vmax])
            {
                t->vmax=-1; // already done that vertex - algorithm needs to be able to terminate.
            }
            else
            {
                t->rise = dot(n,verts[t->vmax]-verts[(*t)[0]]);
            }
        }
        vlimit --;
    }
    return 1;
}
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
    #define facesInput prhs[0]
    #define verticesInput prhs[1]

    #define edgesOutput plhs[0]
    #define edgeLengthsOutput plhs[1]
    #define edgeUnitsOutput plhs[2]
    #define edgeCentersOutput plhs[3]
    #define edgeNormalsOutput plhs[4]
    #define faceNormalsOutput plhs[5]
    #define faceAreasOutput plhs[6]
    #define volumeOutput plhs[7]

    mxArray *faceCell, *edgesCell, *edgeCentersCell, *edgeLengthsCell, 
            *edgeUnitsCell, *faceNormalCell, *edgeNormalsCell;
    double *face, *vertices, *edges, *edgeCenters, *edgeLengths,
           *edgeUnits, *faceNormal, *edgeNormals, *faceAreas, *volume;
    double tmp;
    mwIndex f, e, i;
    mwIndex currentVertexIdx, nextVertexIdx, edgeIdx;
    mwSize faceNumber, edgeNumber, vertexNumber;
    mwSize edgesOutputSize[EDGES_OUTPUT_DIM];

    if (nrhs != 2)
        mexErrMsgTxt("There should be exactly two inputs, faces and vertices.");
    if (nlhs != 8)
        mexErrMsgTxt("There should be exactly 8 outputs. "
            "edges, edgeLengths, edgeCenters, edgeUnits, edgeCenters, "
            "edgeNormals, faceNormals.");
    if (!mxIsCell(facesInput))
        mexErrMsgTxt("Input faces should be a cell array!");
    if (!mxIsDouble(verticesInput))
        mexErrMsgTxt("Input vertices should be a double matrix!");
                
    faceNumber = mxGetNumberOfElements(facesInput);
    vertices = mxGetPr(verticesInput);
    vertexNumber = mxGetN(verticesInput);

    edgesOutputSize[0] = faceNumber;
    edgesOutputSize[1] = 1;

    edgesOutput = mxCreateCellArray(EDGES_OUTPUT_DIM, edgesOutputSize);
    edgeLengthsOutput = mxCreateCellArray(EDGES_OUTPUT_DIM, edgesOutputSize);
    edgeUnitsOutput = mxCreateCellArray(EDGES_OUTPUT_DIM, edgesOutputSize);
    edgeCentersOutput = mxCreateCellArray(EDGES_OUTPUT_DIM, edgesOutputSize);
    edgeNormalsOutput = mxCreateCellArray(EDGES_OUTPUT_DIM, edgesOutputSize);
    faceNormalsOutput = mxCreateCellArray(EDGES_OUTPUT_DIM, edgesOutputSize);
    faceAreasOutput = mxCreateDoubleMatrix(faceNumber, 1, mxREAL); 
    faceAreas = mxGetPr(faceAreasOutput);
    volumeOutput = mxCreateDoubleMatrix(1, 1, mxREAL); 
    volume = mxGetPr(volumeOutput);

    for (f = 0; f < faceNumber; f++)
    {
        faceCell = mxGetCell(facesInput, f);
        face = mxGetPr(faceCell);

        edgeNumber = (mwIndex)(mxGetN(faceCell)) - 1; 
            // face is 1 by e + 1 array, the last entry is duplication of
            // the first one

        edgesCell = mxCreateDoubleMatrix(dim, edgeNumber, mxREAL);
        edges = mxGetPr(edgesCell);

        edgeCentersCell = mxCreateDoubleMatrix(dim, edgeNumber, mxREAL);
        edgeCenters = mxGetPr(edgeCentersCell);

        edgeLengthsCell = mxCreateDoubleMatrix(1, edgeNumber, mxREAL);
        edgeLengths = mxGetPr(edgeLengthsCell);

        edgeUnitsCell = mxCreateDoubleMatrix(dim, edgeNumber, mxREAL);
        edgeUnits = mxGetPr(edgeUnitsCell);

        edgeNormalsCell = mxCreateDoubleMatrix(dim, edgeNumber, mxREAL);
        edgeNormals = mxGetPr(edgeNormalsCell);

        faceNormalCell = mxCreateDoubleMatrix(dim, 1, mxREAL);
        faceNormal = mxGetPr(faceNormalCell);

        for (e = 0; e < edgeNumber; e++)
        {
            for (i = 0; i < dim; i++)
            {
                nextVertexIdx = (mwIndex)face[e+1] * dim + i;
                currentVertexIdx = (mwIndex)face[e] * dim + i;

                edgeIdx = dim * e + i;

                edgeCenters[edgeIdx] = (vertices[nextVertexIdx] 
                    + vertices[currentVertexIdx]) / 2;
                edges[edgeIdx] = vertices[nextVertexIdx] 
                    - vertices[currentVertexIdx];
            }
            edgeLengths[e] = twoNorm(edges + e * dim, dim);

            for (i = 0; i < dim; i++)
            {
                edgeIdx = dim * e + i;
                edgeUnits[edgeIdx] = edges[edgeIdx] / edgeLengths[e];
            }
        }
        cross(edgeUnits, edgeUnits + dim, faceNormal); 
        mexPrint1dArray(faceNormal, dim);
        tmp = twoNorm(faceNormal, dim);
        divideScaler(faceNormal, dim, tmp);

        faceAreas[f] = calcFaceArea(vertices, vertexNumber, face,
            edgeNumber, faceNormal);

        for (e = 0; e < edgeNumber; e++){
            cross(edgeUnits + e * dim, faceNormal, edgeNormals + e * dim);
            for (i = 0; i < dim; i++){
                edgeNormals[e * dim + i] *= edgeLengths[e];
            }
        }
        mxSetCell(edgesOutput, f, edgesCell);
        mxSetCell(edgeCentersOutput, f, edgeCentersCell);
        mxSetCell(edgeLengthsOutput, f, edgeLengthsCell);
        mxSetCell(edgeUnitsOutput, f, edgeUnitsCell);
        mxSetCell(faceNormalsOutput, f, faceNormalCell);
        mxSetCell(edgeNormalsOutput, f, edgeNormalsCell);
    }
    *volume = calcPolyVolumeCellFaces(faceAreas, vertices, facesInput, 
        faceNormalsOutput);
}
Example #6
0
// Moller-Trumbore intersection
float Model::intersect(const Point &r, const Vector &ray, IntersectionInfo &out) const {

	Vector o = {r.x, r.y, r.z};
	Vector lb = bbtop;
	Vector rt = bbbottom;

	// based on https://gamedev.stackexchange.com/questions/18436/most-efficient-aabb-vs-ray-collision-algorithms/18459#18459
	// r.dir is unit direction vector of ray
	Vector dirfrac;
	dirfrac.x = 1.0f / ray.x;
	dirfrac.y = 1.0f / ray.y;
	dirfrac.z = 1.0f / ray.z;
	// lb is the corner of AABB with minimal coordinates - left bottom, rt is maximal corner
	// r.org is origin of ray
	float t1 = (lb.x - o.x)*dirfrac.x;
	float t2 = (rt.x - o.x)*dirfrac.x;
	float t3 = (lb.y - o.y)*dirfrac.y;
	float t4 = (rt.y - o.y)*dirfrac.y;
	float t5 = (lb.z - o.z)*dirfrac.z;
	float t6 = (rt.z - o.z)*dirfrac.z;

	float tmin = std::max(std::max(std::min(t1, t2), std::min(t3, t4)), std::min(t5, t6));
	float tmax = std::min(std::min(std::max(t1, t2), std::max(t3, t4)), std::max(t5, t6));

	// if tmax < 0, ray (line) is intersecting AABB, but whole AABB is behing us
	if (tmax < 0) {
		return -1;
	}

	// if tmin > tmax, ray doesn't intersect AABB
	if (tmin > tmax) {
		return -1;
	}

	float closest = -1;
	bool notfound = true;
	int size = _faces.size();
	for (int i = 0; i < size; ++i) {
		const Face &f = _faces[i];
		Vector v3 = _vertices[f.x];
		Vector v2 = _vertices[f.y];
		Vector v1 = _vertices[f.z];

		Vector e1 = v2-v1;
		Vector e2 = v3-v1;
		Vector p = cross(ray, e2);
		float det = dot(e1, p);

		if (fabs(det) < 0.000001f) {
			continue;
		}
		float inv_det = 1.f/det;

		Vector t = o - v1;

		float u = dot(t, p) * inv_det;

		if (u < 0.f || u > 1.f) {
			continue;
		}

		Vector q = cross(t, e1);
		float v = dot(ray, q) * inv_det;

		if (v < 0.f || v + u > 1.f) {
			continue;
		}
		float t2 = dot(e2, q) * inv_det;
		if (t2 > 0.0001f) {
			if (notfound || t2 < closest) {
				notfound = false;
				Vector sc = ray * t2;
				out.pos.x = o.x + sc.x;
				out.pos.y = o.y + sc.y;
				out.pos.z = o.z + sc.z;
				out.vertex = i;
				closest = t2;
			}
		}
	}
	return closest;
}
Example #7
0
void
MiroWindow::keyboard(unsigned char key, int x, int y)
{
    switch (key)
    {
        case 27:
            exit(0);
        break;

        case 'i':
        case 'I':
        {
            char str[1024];
            sprintf(str, "miro_%d.ppm", time(0));
            if (g_camera->isOpenGL())
            {
                unsigned char* buf = new unsigned char[g_image->width()*g_image->height()*3];
                glReadPixels(0, 0, g_image->width(), g_image->height(),
                             GL_RGB, GL_UNSIGNED_BYTE, buf);
                g_image->writePPM(str, buf, g_image->width(), g_image->height());
            }
            else
            {
                g_image->writePPM(str);
            }
            break;
        }

        case 'r':
        case 'R':
            g_camera->setRenderer(Camera::RENDER_RAYTRACE);
        break;

        case 'g':
        case 'G':
            g_camera->setRenderer(Camera::RENDER_OPENGL);
        break;

        case '+':
            m_scaleFact *= 1.5;
        break;

        case '-':
            m_scaleFact /= 1.5;
        break;

        case 'w':
        case 'W':
            g_camera->setEye(g_camera->eye() + m_scaleFact*g_camera->viewDir());
        break;

        case 's':
        case 'S':
            g_camera->setEye(g_camera->eye() - m_scaleFact*g_camera->viewDir());
        break;

        case 'q':
        case 'Q':
            g_camera->setEye(g_camera->eye() + m_scaleFact*g_camera->up());
        break;

        case 'z':
        case 'Z':
            g_camera->setEye(g_camera->eye() - m_scaleFact*g_camera->up());
        break;
		case 'v':
		case 'V':
			g_scene->togglePDraw();
		break;
		case 'b':
		case 'B':
			g_scene->toggleDraw();
		break;

        case 'a':
        case 'A':
        {
            Vector3 vRight = cross(g_camera->viewDir(), g_camera->up());
            g_camera->setEye(g_camera->eye() - m_scaleFact*vRight);
            break;
        }

        case 'd':
        case 'D':
        {
            Vector3 vRight = cross(g_camera->viewDir(), g_camera->up());
            g_camera->setEye(g_camera->eye() + m_scaleFact*vRight);
            break;
        }
        break;

        default:
        break;
    }
    glutPostRedisplay();
}
Example #8
0
void Boonas::doExtrude(QString num, QString filename) // extrudes and writes whilst extruding 
{
	float n = num.toFloat();
	float x, y, z, w;
	int numSides;
	Point* pa;
	Point* pb;
	Point* pc;
	Point pd;
	Point firstPoint;
	Vector va;
	Vector vb;
	Vector vn;
	bool again = true;
	filename.append(".poly");
	QFile* theDestination;
	theDestination = new QFile(filename);
	theDestination -> remove();
	theDestination -> open(QIODevice::ReadWrite | QIODevice::Text);
	QTextStream outStream( theDestination );
	
	do // do this loop while ther is more in orig
	{
		
		cursor = orig -> getCurrent(); // cursor is current
		cursor -> reset();
		
		//change color respectively for each object
		x = cursor -> getX(); 
		y = cursor -> getY();
		z = cursor -> getZ();
		
		if(colorValue != 0)
		{
			delete colorValue;
			colorValue = 0;
		}
		colorValue = new Point(x, y, z);
		
		cursor -> advance();
		
		if(!(orig -> isNotLast()))
		{
			again = false;
		}
		
		// get initial points in order to get unit vectior
		
		x = cursor -> getX(); 
		y = cursor -> getY();
		z = cursor -> getZ();
		
		pa = new Point(x, y, z);
		
		cursor -> advance();
		
		x = cursor -> getX(); 
		y = cursor -> getY();
		z = cursor -> getZ();
		
		pb = new Point(x, y, z);
		
		cursor -> advance();
		
		x = cursor -> getX(); 
		y = cursor -> getY();
		z = cursor -> getZ();
		
		pc = new Point(x, y, z);
		
		va = *pa - *pb;
		vb = *pb - *pc;
		
		vn = cross(va, vb);
		vn.normalize();
		
		//vn = vn * -1.0; // flip it
		
		vn = vn * n;
		// vn is vector!
		
		cursor -> reset(); // reset cursor so 2nd iteration starts from begining
		
		
		// skip color vector
		cursor -> advance();
		
		numSides = 0;
		
		outStream << "newObject" << endl;
		
		// put out color vector
		outStream << colorValue -> x() << " " << colorValue -> y() << " "<< colorValue -> z() << " 1" << endl;
		
		// first iteration, copy orig polygon, count number of sides
		do
		{
			numSides++;
			//qDebug() << "Test results";
			x = cursor -> getX(); // get point
			y = cursor -> getY();
			z = cursor -> getZ();
			w = cursor -> getW();
			
			outStream << x << " " << y << " " << z << " " << w << endl;
			
			cursor -> advance();
		}
		while(cursor -> hasNext()); // run through the points and mult!k
		
		numSides++;
		x = cursor -> getX(); // get point
		y = cursor -> getY();
		z = cursor -> getZ();
		w = cursor -> getW();
		
		outStream << x << " " << y << " " << z << " " << w << endl;
		//numsides is the number of points
		cursor -> reset();
		
		// skip color vector
		cursor -> advance();
		
		// second iteration, copy the top polygon
		outStream << "newObject" << endl;
		
		// put out color vector
		outStream << colorValue -> x() << " " << colorValue -> y() << " "<< colorValue -> z() << " 1" << endl;
		
		// second iteration, copy orig polygon to traversed points, count number of sides
		do
		{
			//qDebug() << "Test results";
			x = cursor -> getX(); // get point
			y = cursor -> getY();
			z = cursor -> getZ();
			w = cursor -> getW();
			
			delete pa;
			pa = new Point(x, y, z);
			pd = *pa + vn;
			outStream << pd.x() << " " << pd.y() << " " << pd.z() << " " << w << endl;
			
			cursor -> advance();
		}
		while(cursor -> hasNext()); // run through the points and mult!k
		
		x = cursor -> getX(); // get point
		y = cursor -> getY();
		z = cursor -> getZ();
		w = cursor -> getW();
		
		delete pa;
		pa = new Point(x, y, z);
		
		pd = *pa + vn;
		
		outStream << pd.x() << " " << pd.y() << " " << pd.z() << " " << w << endl;
		// start next run time for the sides yo
		cursor -> reset();
		
		// skip color vector
		cursor -> advance();
		
		
		for(int i = 0; i < (numSides - 1); i++) // run through this next bit for each side of the polygon except the last side
		{
			cursor -> reset();
			
			// skip color vector
			cursor -> advance();
			
			outStream << "newObject" << endl;
			
			// put out color vector
			outStream << colorValue -> x() << " " << colorValue -> y() << " "<< colorValue -> z() << " 1" << endl;
			
			for(int j = 0; j < i; j++) // advance cursor to get it to desired point
			{
				cursor -> advance();
			}
			
			x = cursor -> getX(); 
			y = cursor -> getY();
			z = cursor -> getZ();
			w = cursor -> getW();
			
			outStream << x << " " << y << " " << z << " " << w << endl; // out put orig point
			
			delete pa;
			pa = new Point(x, y, z);
			pd = *pa + vn;
			
			outStream << pd.x() << " " << pd.y() << " " << pd.z() << " " << w << endl; // out put mod point a
			
			cursor -> advance(); //advance to next point;
			
			x = cursor -> getX(); 
			y = cursor -> getY();
			z = cursor -> getZ();
			w = cursor -> getW();
			
			delete pa;
			pa = new Point(x, y, z);
			pd = *pa + vn;
			
			outStream << pd.x() << " " << pd.y() << " " << pd.z() << " " << w << endl; // out put mod point b

			outStream << x << " " << y << " " << z << " " << w << endl; // out put last point
		}
		// now we only have to deal with the last side
		
		outStream << "newObject" << endl;
		
		// put out color vector
		outStream << colorValue -> x() << " " << colorValue -> y() << " "<< colorValue -> z() << " 1" << endl;
		
		
		cursor -> reset();
		
		// skip color vector
		cursor -> advance();
		
		for(int i = 0; i < numSides; i++)
		{
			cursor -> advance(); // advance cursor to last point;
		}
		
		x = cursor -> getX(); 
		y = cursor -> getY();
		z = cursor -> getZ();
		w = cursor -> getW();
		
		outStream << x << " " << y << " " << z << " " << w << endl; // out put first point
		
		delete pa;
		pa = new Point(x, y, z);
		pd = *pa + vn;
		
		outStream << pd.x() << " " << pd.y() << " " << pd.z() << " " << w << endl; // out put mod point a
		
		cursor -> reset();
		
		// skip color vector
		cursor -> advance();
		
		x = cursor -> getX(); 
		y = cursor -> getY();
		z = cursor -> getZ();
		w = cursor -> getW();
		
		delete pa;
		pa = new Point(x, y, z);
		pd = *pa + vn;
		
		outStream << pd.x() << " " << pd.y() << " " << pd.z() << " " << w << endl; // out put mod point b
		
		outStream << x << " " << y << " " << z << " " << w << endl; // out put last point
		
		orig -> advance(); // advance what were working with
	}
	while(again);
	
	theDestination -> close();
	delete theDestination;
	delete pa;
	delete pb;
	delete pc;
}
Example #9
0
Model::Model(const std::string &filename, const Vector &off) : bbtop({0,0,0}), bbbottom({0,0,0}) {
	FILE *f = fopen(filename.c_str(), "r");

	int verts, faces;
	fscanf(f, "# %d %d\n", &verts, &faces);

	for (int i = 0; i < verts; ++i) {
		float x,y,z;
		fscanf(f, "v %f %f %f\n", &x, &y, &z);
		x += off.x;
		y += off.y;
		z += off.z;
		if (i == 0 || x > bbtop.x) {
			bbtop.x = x;
		}
		if (i == 0 || y > bbtop.y) {
			bbtop.y = y;
		}
		if (i == 0 || z > bbtop.z) {
			bbtop.z = z;
		}
		if (i == 0 || x < bbbottom.x) {
			bbbottom.x = x;
		}
		if (i == 0 || y < bbbottom.y) {
			bbbottom.y = y;
		}
		if (i == 0 || z < bbbottom.z) {
			bbbottom.z = z;
		}

		_vertices.push_back({x,y,z});
	}

	for (int i = 0; i < faces; ++i) {
		int x,y,z;
		fscanf(f, "f %d %d %d\n", &x, &y, &z);
		x--;
		y--;
		z--;
		//Based on https://www.opengl.org/wiki/Calculating_a_Surface_Normal
		Vector norm;
		Vector v1 = _vertices[x];
		Vector v2 = _vertices[y];
		Vector v3 = _vertices[z];
		Vector u = v2 - v3;
		Vector v = v1 - v3;
		norm = normalize(cross(v,u));

		_faces.push_back({x,y,z, norm});
	}
	fclose(f);

	mat_ambient[0] = 0.7;
	mat_ambient[1] = 0.7;
	mat_ambient[2] = 0.7;

	mat_diffuse[0] = 0;
	mat_diffuse[1] = 0;
	mat_diffuse[2] = 1;

	mat_specular[0] = 1;
	mat_specular[1] = 1;
	mat_specular[2] = 1;

	mat_shineness = 30;
	reflectance = 0.5;
	transparency = 0.5;
}
Example #10
0
// it works in the sense that it produces a perpendicular-to-everyting vector,
// but it has not been tested whether it points in the "right" direction.
float4 gcross(float4 p, float4 q, float4 r)
{
	return float4(dot(p.yzw, cross(q.yzw, r.yzw)), -dot(p.xzw, cross(q.xzw, r.xzw)), dot(p.xyw, cross(q.xyw, r.xyw)), -dot(p.xyz, cross(q.xyz, r.xyz)));
}
Example #11
0
float determinant(mat4 p)
{
	return dot(p.v[0],
			   float4(dot(p.v[1].yzw, cross(p.v[2].yzw, p.v[3].yzw)),
					  -dot(p.v[1].xzw, cross(p.v[2].xzw, p.v[3].xzw)), dot(p.v[1].xyw, cross(p.v[2].xyw, p.v[3].xyw)), -dot(p.v[1].xyz, cross(p.v[2].xyz, p.v[3].xyz))));
}
Example #12
0
float determinant(mat3 p)
{
	return dot(p.v[0], cross(p.v[1], p.v[2]));
}
Example #13
0
void DebugHooks::drawFaceLoopWireframe(const std::vector<const carve::geom3d::Vector *> &face_loop,
                                       const carve::geom3d::Vector &normal,
                                       float r, float g, float b, float a,
                                       bool inset) {
  glDisable(GL_DEPTH_TEST);

  const size_t S = face_loop.size();

  double INSET = 0.005;

  if (inset) {
    glColor4f(r, g, b, a / 2.0);
    glBegin(GL_LINE_LOOP);

    for (size_t i = 0; i < S; ++i) {
      size_t i_pre = (i + S - 1) % S;
      size_t i_post = (i + 1) % S;

      carve::geom3d::Vector v1 = (*face_loop[i] - *face_loop[i_pre]).normalized();
      carve::geom3d::Vector v2 = (*face_loop[i] - *face_loop[i_post]).normalized();

      carve::geom3d::Vector n1 = cross(normal, v1);
      carve::geom3d::Vector n2 = cross(v2, normal);

      carve::geom3d::Vector v = *face_loop[i];

      carve::geom3d::Vector p1 = v + INSET * n1;
      carve::geom3d::Vector p2 = v + INSET * n2;

      carve::geom3d::Vector i1 , i2;
      double mu1, mu2;

      carve::geom3d::Vector p;

      if (carve::geom3d::rayRayIntersection(carve::geom3d::Ray(v1, p1), carve::geom3d::Ray(v2, p2), i1, i2, mu1, mu2)) {
        p = (i1 + i2) / 2;
      } else {
        p = (p1 + p2) / 2;
      }

      glVertex(&p);
    }

    glEnd();
  }

  glColor4f(r, g, b, a);

  glBegin(GL_LINE_LOOP);

  for (unsigned i = 0; i < S; ++i) {
    glVertex(face_loop[i]);
  }

  glEnd();

  glColor4f(r, g, b, a);
  glPointSize(3.0);
  glBegin(GL_POINTS);

  for (unsigned i = 0; i < S; ++i) {
    carve::geom3d::Vector p = *face_loop[i];
    glVertex(face_loop[i]);
  }

  glEnd();

  glEnable(GL_DEPTH_TEST);
}
Example #14
0
MLIB_INLINE
mlib::Plane<PLANE,P,V,L>::Plane(const P &p,  const V&v1, const V&v2)
    : _d(0)
{
   *this = Plane<PLANE,P,V,L>(p, cross(v1, v2));
}