C++ BoundingBox::getMin方法代码示例

char BoundingBox::inside(const BoundingBox & b) const
{
	return (getMin(0) >= b.getMin(0) &&
			getMin(1) >= b.getMin(1) &&
			getMin(2) >= b.getMin(2) &&
			getMax(0) <= b.getMax(0) &&
			getMax(1) <= b.getMax(1) &&
			getMax(2) <= b.getMax(2));
}

char BoundingBox::isBoxAround(const BoundingBox & b, float threshold) const
{
    if(b.getMin(0) > getMax(0) + threshold) return 0;
    if(b.getMax(0) < getMin(0) - threshold) return 0;
    if(b.getMin(1) > getMax(1) + threshold) return 0;
    if(b.getMax(1) < getMin(1) - threshold) return 0;
    if(b.getMin(2) > getMax(2) + threshold) return 0;
    if(b.getMax(2) < getMin(2) - threshold) return 0;
    return 1;
}

Transform::Transform(Matrix &m, Object3D *o)
	:mMat(m), mObj(o)
{
	mMat.Inverse(mReverseMat);

    //Compute the transformed BBox
    BoundingBox *pBB = mObj->getBoundingBox();

    if (pBB == NULL)
        return;

    Vec3f minP = pBB->getMin();
    Vec3f maxP = pBB->getMax();

    mMat.Transform(minP);
    mMat.Transform(maxP);

    BoundingBox box;
    box = Union(box, minP);
    box = Union(box, Vec3f(maxP.x(), minP.y(), minP.z()));
    box = Union(box, Vec3f(minP.x(), maxP.y(), minP.z()));
    box = Union(box, Vec3f(maxP.x(), maxP.y(), minP.z()));
    box = Union(box, Vec3f(minP.x(), minP.y(), maxP.z()));
    box = Union(box, Vec3f(maxP.x(), minP.y(), maxP.z()));
    box = Union(box, Vec3f(minP.x(), maxP.y(), maxP.z()));
    box = Union(box, maxP);

    mpBox = new BoundingBox();
    mpBox->Set(&box);
}

bool BoundingBox::intersects( std::list<Vector> vectors, BoundingBox &other){
    
    GLfloat rot[3];
    other.getRotation( rot);
    
    Matrix4f transformationMatrix;
    Matrix4f rotationMatrix;
    
    rotationMatrix.rotate( -rotation[0], -rotation[1], -rotation[2]);
    
    rotationMatrix.rotate( rot[0], rot[1], rot[2]);
    
    Matrix4f axis;
    
    GLfloat mins[3], maxes[3];
                        
    for (int i=0; i<NUM_DIMENSIONS; i++) {
        
        Vector v( axis[ i * (NUM_DIMENSIONS +1) ], axis[ i * (NUM_DIMENSIONS +1) +1], axis[i* (NUM_DIMENSIONS +1) +2] );
        
        Matrix matrixVector = rotationMatrix * v;
        Vector newV(matrixVector);
        
        findExtremePoint(vectors, newV, mins + i, maxes + i);
    }
    
    Vector newMin( mins[0], mins[1], mins[2]);
    Vector newMax( maxes[0], maxes[1], maxes[2]);
    
    Vector translate(other.getTranslation());
    transformationMatrix.rotate( rotation[0], rotation[1], rotation[2]);
    transformationMatrix.translate( translation.getX(), translation.getY(), translation.getZ());
    transformationMatrix.rotate( -rot[0], -rot[1], -rot[2]);
    transformationMatrix.translate( -translate.getX(), -translate.getY(), -translate.getZ());

    newMin = transformationMatrix * newMin;
    newMax = transformationMatrix * newMax;
    
    if ( newMax.getX() + EPSILON < other.getMin().getX() || other.getMax().getX() + EPSILON< newMin.getX() )
        return false;
    if ( newMax.getY() + EPSILON < other.getMin().getY() || other.getMax().getY() + EPSILON< newMin.getY() )
        return false;
    if ( newMax.getZ() + EPSILON < other.getMin().getZ() || other.getMax().getZ() + EPSILON< newMin.getZ() )
        return false;
    
    return true;
}

char BoundingBox::intersect(const BoundingBox & another) const
{
    for(int i=0; i < 3; i++) {
        if(getMin(i) > another.getMax(i)) return 0;
        if(getMax(i) < another.getMin(i)) return 0;    
    }
    return 1;
}

		void resetProjection() {
			if(screenHeight == 0) {
				projection = mat4(); // don't want to divide by zero...
				return;
			}
			BoundingBox* box = currentMesh->getBoundingBox();
			projection = mat4()
				* Perspective(90, (float)screenWidth/screenHeight, 0.0000001, 100000)
				* LookAt(box->getMax() + box->getSize()/2, box->getMin(), vec4(0, 1, 0, 0));
		}

BoundingBox BoundingBox::operator=( const BoundingBox& rhs){

    min = rhs.getMin();
    max = rhs.getMax();
    translation = rhs.getTranslation();
    
    rhs.getRotation( rotation );
    
    return *this;
    
}

bool Ray::intersect (const BoundingBox & bbox, Vec3Df & intersectionPoint) const {
    const Vec3Df & minBb = bbox.getMin ();
    const Vec3Df & maxBb = bbox.getMax ();
    bool inside = true;
    unsigned int  quadrant[NUMDIM];
    register unsigned int i;
    unsigned int whichPlane;
    Vec3Df maxT;
    Vec3Df candidatePlane;
    
    for (i=0; i<NUMDIM; i++)
        if (origin[i] < minBb[i]) {
            quadrant[i] = LEFT;
            candidatePlane[i] = minBb[i];
            inside = false;
        } else if (origin[i] > maxBb[i]) {
            quadrant[i] = RIGHT;
            candidatePlane[i] = maxBb[i];
            inside = false;
        } else	{
            quadrant[i] = MIDDLE;
        }

    if (inside)	{
        intersectionPoint = origin;
        return (true);
    }

    for (i = 0; i < NUMDIM; i++)
        if (quadrant[i] != MIDDLE && direction[i] !=0.)
            maxT[i] = (candidatePlane[i]-origin[i]) / direction[i];
        else
            maxT[i] = -1.;

    whichPlane = 0;
    for (i = 1; i < NUMDIM; i++)
        if (maxT[whichPlane] < maxT[i])
            whichPlane = i;

    if (maxT[whichPlane] < 0.) return (false);
    for (i = 0; i < NUMDIM; i++)
        if (whichPlane != i) {
            intersectionPoint[i] = origin[i] + maxT[whichPlane] *direction[i];
            if (intersectionPoint[i] < minBb[i] || intersectionPoint[i] > maxBb[i])
                return (false);
        } else {
            intersectionPoint[i] = candidatePlane[i];
        }
    return (true);			
}

BoundingBox transformBoundingBox(BoundingBox b, mat4 transform) {
	/* Bounding box
	 * ca-------cb
	 * |        |
	 * |        |
	 * |        |
	 * cd-------cc
	 */
	//mat4 transform = getCurrentModelviewMatrix();
	vec2 min2, max2,ca,cb,cc,cd;
	
	// get the min and max vec2's of the boundingBox
	b.getMin(min2);
	b.getMax(max2);
	
	// create the corner points of the bounding box
	ca[0] = min2[0]; ca[1] = max2[1];
	cb[0] = max2[0]; cb[1] = max2[1];
	cc[0] = max2[0]; cc[1] = min2[1];
	cd[0] = min2[0]; cd[1] = min2[1];
	
	// convert the four corner points into vec4
	vec4 ca4(ca[0],ca[1],0,1),
		cb4(cb[0],cb[1],0,1),
		cc4(cc[0],cc[1],0,1),
		cd4(cd[0],cd[1],0,1);
		
	// transform the corner points
	ca4 = transform*ca4;
	cb4 = transform*cb4;
	cc4 = transform*cc4;
	cd4 = transform*cd4;
	
	// find the new bounding box after the transformation
	min2[0] = min(min(min(ca4[0],cb4[0]),cc4[0]),cd4[0]);
	min2[1] = min(min(min(ca4[1],cb4[1]),cc4[1]),cd4[1]);
	max2[0] = max(max(max(ca4[0],cb4[0]),cc4[0]),cd4[0]);
	max2[1] = max(max(max(ca4[1],cb4[1]),cc4[1]),cd4[1]);
	
	// make the bounding box and return it
	return BoundingBox(min2,max2);
}

void PhotonMapping::TracePhotons() {
  std::cout << "trace photons" << std::endl;

  // first, throw away any existing photons
  delete kdtree;

  // consruct a kdtree to store the photons
  BoundingBox *bb = mesh->getBoundingBox();
  Vec3f min = bb->getMin();
  Vec3f max = bb->getMax();
  Vec3f diff = max-min;
  min -= 0.001*diff;
  max += 0.001*diff;
  kdtree = new KDTree(BoundingBox(min,max));

  // photons emanate from the light sources
  const std::vector<Face*>& lights = mesh->getLights();

  // compute the total area of the lights
  double total_lights_area = 0;
  for (unsigned int i = 0; i < lights.size(); i++) {
    total_lights_area += lights[i]->getArea();
  }

  // shoot a constant number of photons per unit area of light source
  // (alternatively, this could be based on the total energy of each light)
  for (unsigned int i = 0; i < lights.size(); i++) {  
    double my_area = lights[i]->getArea();
    int num = args->num_photons_to_shoot * my_area / total_lights_area;
    // the initial energy for this photon
    Vec3f energy = my_area/double(num) * lights[i]->getMaterial()->getEmittedColor();
    Vec3f normal = lights[i]->computeNormal();
    for (int j = 0; j < num; j++) {
      Vec3f start = lights[i]->RandomPoint();
      // the initial direction for this photon (for diffuse light sources)
      Vec3f direction = RandomDiffuseDirection(normal);
      TracePhoton(start,direction,energy,0);
    }
  }
}

// this only test intersection with axis alligned bounding box
bool Ray::intersectSimpleBbox(const BoundingBox& box, double & t) const
{
	vec3 v = direction;
	point3 p = startPoint;
	point3 boxMin = box.getMin();
	point3 boxMax = box.getMax();

	double tnear{ -1.0 }, tfar{ INFINITY };

	// test X,Y,Z
	for(int i = 0; i<3;i++)
	{
		if (v[i] == 0)
		{
			if (p[i] < boxMin[i] || p[i] > boxMax[i])
			{
				return false;
			}
		}

		// if survive parallel test
		double t1 = (boxMin[i] - p[i]) / v[i];
		double t2 = (boxMax[i] - p[i]) / v[i];

		if(t1 > t2)
		{
			swap(t1, t2);
		}

		if(t1 > tnear)
		{
			tnear = t1;
		}

		if(t2 < tfar)
		{
			tfar = t2;
		}
		if(tnear > tfar)
		{
			return false;
		}

		if(tfar < 0)
		{
			return false;
		}
	}


	// check if eye is in the box
	if(tnear)
	{
		t = tnear;
	}else
	{
		t = tfar;
	}
	
	return true;

}

bool OpenGLRenderer::renderBoundingBox(const BoundingBox &box, const glm::mat4 &modelMatrix, const glm::vec3 &color, Camera &camera,
                                       RenderTarget &renderTarget)
{
    /* Generate the box lines */
    GLfloat boxFaces[] = {
        /* First face */
        box.getMin().x, box.getMin().y, box.getMin().z, box.getMax().x, box.getMin().y, box.getMin().z, box.getMin().x, box.getMin().y,
        box.getMin().z, box.getMin().x, box.getMax().y, box.getMin().z, box.getMin().x, box.getMin().y, box.getMin().z, box.getMin().x,
        box.getMin().y, box.getMax().z,
        /*--*/
        box.getMax().x, box.getMax().y, box.getMax().z, box.getMin().x, box.getMax().y, box.getMax().z, box.getMax().x, box.getMax().y,
        box.getMax().z, box.getMax().x, box.getMin().y, box.getMax().z, box.getMax().x, box.getMax().y, box.getMax().z, box.getMax().x,
        box.getMax().y, box.getMin().z,
        /*--*/
        box.getMin().x, box.getMax().y, box.getMax().z, box.getMin().x, box.getMax().y, box.getMin().z, box.getMin().x, box.getMax().y,
        box.getMax().z, box.getMin().x, box.getMin().y, box.getMax().z,
        /*--*/
        box.getMax().x, box.getMin().y, box.getMax().z, box.getMax().x, box.getMin().y, box.getMin().z, box.getMax().x, box.getMin().y,
        box.getMax().z, box.getMin().x, box.getMin().y, box.getMax().z,
        /*--*/
        box.getMax().x, box.getMax().y, box.getMin().z, box.getMin().x, box.getMax().y, box.getMin().z, box.getMax().x, box.getMax().y,
        box.getMin().z, box.getMax().x, box.getMin().y, box.getMin().z,
    };

    /* Calculate MVP matrix, bounding box coordinates are already in world coordinates */
    glm::mat4 MVP = camera.getPerspectiveMatrix() * camera.getViewMatrix() * modelMatrix;

    __(glEnable(GL_DEPTH_TEST));

    /* Bind the render target */
    renderTarget.bind();
    {
        GLuint boxPosVAO, boxPosVBO;

        /* Bind program to upload the uniform */
        _renderBoundingBox.attach();

        /* Send our transformation to the currently bound _renderBoundingBox, in the "MVP" uniform */
        _renderBoundingBox.setUniformMat4("u_MVPMatrix", &MVP);
        _renderBoundingBox.setUniformVec3("u_boxColor", const_cast<glm::vec3 &>(color));

        __(glGenVertexArrays(1, &boxPosVAO));
        __(glBindVertexArray(boxPosVAO));

        __(glGenBuffers(1, &boxPosVBO));

        __(glBindBuffer(GL_ARRAY_BUFFER, boxPosVBO));

        __(glBufferData(GL_ARRAY_BUFFER, sizeof boxFaces, boxFaces, GL_STATIC_DRAW));

        __(glEnableVertexAttribArray(0));
        __(glVertexAttribPointer(0,         // attribute. No particular reason for 0, but must match the layout in the shader.
                                 3,         // size
                                 GL_FLOAT,  // type
                                 GL_FALSE,  // normalized?
                                 0,         // stride
                                 (void *)0  // array buffer offset
                                 ));

        __(glDrawArrays(GL_LINES, 0, sizeof boxFaces / (2 * sizeof *boxFaces)));

        __(glBindVertexArray(0));

        __(glDeleteBuffers(1, &boxPosVBO));
        __(glDeleteVertexArrays(1, &boxPosVAO));

        /* Unbind */
        _renderBoundingBox.detach();
    }
    renderTarget.unbind();

    return true;
}