Пример #1
0
bool Cube::isHit(	Ray &ray,
					vect3d &pNormal, float *t, vect3d *pTexColor)
{
	if(!_bbox.isHit(ray))
	{
		return false;
	}

	float fCurrT = 0xFFFFFFFF;
	float t0 = 0xFFFFFFFF;
	vect3d vCurrNormal;
	for(int i = 0; i < 6; i ++)
	{
		t0 = 0xFFFFFFFF;
		vect3d tmpv;
		bool bHit = _vs[i]->isHit(ray, tmpv, &t0, pTexColor);
		if( bHit && (t0 < fCurrT) )
		{
			fCurrT = t0;			
			vecCopy(vCurrNormal, tmpv);
		}	
	}

	if(fCurrT == 0xFFFFFFFF)
	{
		return false;
	}

	*t = fCurrT;
	vecCopy(pNormal, vCurrNormal);
	return true;
}
Пример #2
0
void Object::setMaterial(vect3d &specColor, vect3d &diffColor, vect3d &ambiColor, float fShininess)
{
	vecCopy(_mat.specColor, specColor);
	vecCopy(_mat.diffColor, diffColor);
	vecCopy(_mat.ambiColor, ambiColor);
	_mat.fShininess = fShininess;
}
Пример #3
0
Square::Square(	vect3d &pCenter, 
			    vect3d &pNormal,
				vect3d &pHeadVec, 
				float nWidth, 
				float nHeight,
				float fReflR, float fRefrR, float fRefrK, float fEmitR)
	:PrimaryObject(fReflR, fRefrR, fRefrK, fEmitR)
{
		
	vecCopy(_vCenter, pCenter);
	vecCopy(_vNormal, pNormal);	
	vecCopy(_vWidthVec, pHeadVec);	

	_nWidth = nWidth;
	_nHeight = nHeight;

	vecScale(_vWidthVec, nHeight/2, _v2WidthVec);

	vect3d v2HeightVec;
	cross_product(_vWidthVec, _vNormal, v2HeightVec);
	normalize(v2HeightVec);
	vecScale(v2HeightVec, nWidth/2, _v2HeightVec);

	a = _vNormal[0]; b = _vNormal[1]; c = _vNormal[2];
	d = (-1) * (a * _vCenter[0] + b * _vCenter[1] + c * _vCenter[2]);

	updateBBox();
}
Пример #4
0
void extended_kalman_init( uFloat **P, uFloat *x )
{
#ifdef PRINT_DEBUG
  printf( "ekf: Initializing filter\n" );
#endif

  alloc_globals( STATE_SIZE, MEAS_SIZE );

  sys_transfer = matrix( 1, STATE_SIZE, 1, STATE_SIZE );
  mea_transfer = matrix( 1, MEAS_SIZE, 1, STATE_SIZE );

  /*  Init the global variables using the arguments.  */

  vecCopy( x, state_post, STATE_SIZE );
  vecCopy( x, state_pre, STATE_SIZE );
  matCopy( P, cov_post, STATE_SIZE, STATE_SIZE );
  matCopy( P, cov_pre, STATE_SIZE, STATE_SIZE );

  covarianceSet( sys_noise_cov, mea_noise_cov );	

#ifdef PRINT_DEBUG
  printf( "ekf: Completed Initialization\n" );
#endif

}
Пример #5
0
Platform::Platform(GameObject * source)
{
    body.type = RECTANGLE;
    id = PLATFORM;

    tex_id = source->tex_id;
    vecCopy(source->body.center, body.center);
    vecCopy(source->prevPosition, prevPosition);
    vecCopy(source->velocity, velocity);

    body.width = source->body.width;
    body.height = source->body.height;
    textureWidth = source->textureWidth;
    textureHeight = source->textureHeight;
    horizontalTiles = source->horizontalTiles;
    verticalTiles = source->verticalTiles;
    for (int i = 0; i < 3; i++) {
        rgb[i] = source->rgb[i];
    }
}
Пример #6
0
void getAvgNormal(float *retNorm, float *depthBuf, int x, int y, int width, int height, int nSampleRad)
{
	float tmp[3] = {0};
	unsigned nAvailableCount = 0;

	for(int j = -nSampleRad; j <= nSampleRad; j ++)
	for(int i = -nSampleRad; i <= nSampleRad; i ++)
	{
		int currX = x + i;
		int currY = y + j;
		if( currX >=0 && currX < width &&
			currY >=0 && currY < height )
		{
			float fd = *(depthBuf + (currX + currY * width));
			if(fd > 0)
			{
				float currNorm[3];

				//	The sampled normal should get an average value ...
				float dz_x = dz2x(currX, currY, width, height, depthBuf);
				float dz_y = dz2y(currX, currY, width, height, depthBuf);

				float Cx = i == 0 ? 0 : 2.f / (width * currX);	
				float Cy = j == 0 ? 0 : 2.f / (height * currY);	

				float D = Cy * Cy * dz_x * dz_x + Cx * Cx * dz_y * dz_y + Cx * Cx * Cy * Cy * (1 - fd) * (1 - fd);
				if(D == 0)
				{
					continue;
				}
				float rv_sqrtD = 1.f / sqrt(D);

				currNorm[0] = - Cy * dz_x * rv_sqrtD;
				currNorm[1] = - Cx * dz_y * rv_sqrtD;
				currNorm[2] = Cx * Cy * (1 - fd) * rv_sqrtD;

				vecAdd(tmp, currNorm, tmp);
				nAvailableCount ++;
			}
		}
	}

	if(nAvailableCount > 0)
	{
		vecScale(tmp, 1.f/nAvailableCount, tmp);
		normalize(tmp);
		vecCopy(retNorm, tmp);
	}
}
Пример #7
0
// Does the same as R function table
std::map<int, int> tabulateVector(std::vector<int>& vec) {
    std::vector<int> vecCopy(vec); 
    std::sort(vecCopy.begin(), vecCopy.end());
    std::vector<int>::iterator it = std::unique(vecCopy.begin(), vecCopy.end());
    vecCopy.resize(std::distance(vecCopy.begin(), it));
    
    std::map<int, int>  table;
    //int pos = 0;
    for (std::vector<int>::size_type i = 0; i != vecCopy.size(); i++) {
        int mycount = std::count(vec.begin(), vec.end(), vecCopy[i]);
        table[vecCopy[i]] = mycount;
        //pos = pos + mycount;
    }
    return table;
}    
Пример #8
0
/* --------------- Platform Class --------------- */
Platform::Platform(int width, int height, int x, int y, int tex)
{
    body.type = RECTANGLE;
    id = PLATFORM;
    tex_id = tex;

    vecMake(x,y,body.center);
    vecCopy(body.center, prevPosition);
    vecZero(velocity);

    body.width = width;
    body.height = height;
    textureWidth = 15;     // !!!!! need to merge with game's texture data !!!!!
    textureHeight = 15;
    horizontalTiles = width / textureWidth;
    verticalTiles = height / textureHeight;
    rgb[0] = 90;
    rgb[1] = 140;
    rgb[2] = 90;
}
Пример #9
0
bool Triangle::isHit(Ray &ray, vect3d &pNormal, float *pt, vect3d *pTexColor)
{
	//	This will slow down the performance 
	//
	//if(!_bbox.isHit(ray))
	//{
	//	return false;
	//}

	float u = 0, v = 0;
	if(isTriangleHit(_vertices, ray, pt, &u, &v))
	{
		if(_bSmooth && _bHasVNorm)
		{
			vect3d vSmoothNorm;
			point2point(_vnormal[1], vSmoothNorm, vSmoothNorm);
			vecScale(vSmoothNorm, u, vSmoothNorm);

			vect3d vnorm2;
			point2point(_vnormal[2], vnorm2, vnorm2);
			vecScale(vnorm2, v, vnorm2);

			vect3d vnorm3;
			point2point(_vnormal[0], vnorm3, vnorm3);
			vecScale(vnorm3, (1 - u - v), vnorm3);

			point2point(vSmoothNorm, vnorm2, vSmoothNorm);
			point2point(vSmoothNorm, vnorm3, pNormal);

			normalize(pNormal);
		}
		else
		{
			vecCopy(pNormal, _normal);
		}
		return true;
	}
	return false;
}
Пример #10
0
static void rungeKutta( uFloat *old_state, uFloat *new_state )
{

#ifdef PRINT_DEBUG
  printf( "ekf: rungeKutta\n" );
#endif

  /* k1 = period * F( old_state ) */	
  systemF( tempState, old_state );
  vecScalarMult( tempState, PERIOD, k1, STATE_SIZE );

  /* k2 = period * F( old_state + k1 * 0.5) */
  vecScalarMult( k1, 0.5, tempState, STATE_SIZE ); /* tempState = k1 * 0.5 */
  vecAdd( old_state, tempState, tempState, STATE_SIZE );  /* tempState = old_state + k1 * 0.5 */
  systemF( tempState, old_state );
  vecScalarMult( tempState, PERIOD, k2, STATE_SIZE );

  /* k3 = period * F( old_state + k2 * 0.5) */
  vecScalarMult( k2, 0.5, tempState, STATE_SIZE ); /* tempState = k2 * 0.5 */
  vecAdd( old_state, tempState, tempState, STATE_SIZE );  /* tempState = old_state + k2 * 0.5 */
  systemF( tempState, old_state );
  vecScalarMult( tempState, PERIOD, k3, STATE_SIZE );
  
  /* k4 = period * F( old_state + k3) */
  vecAdd( old_state, tempState, tempState, STATE_SIZE );  /* tempState = old_state + k3 */
  systemF( tempState, old_state );
  vecScalarMult( tempState, PERIOD, k4, STATE_SIZE );

  /*  new_state = old_state + 0.16667 * ( k1 + 2*k2 + 2*k3 + k4 ) */
  vecCopy( k1, new_state, STATE_SIZE );
  vecScalarMult( k2, 2.0, tempState, STATE_SIZE );
  vecAdd( new_state, tempState, new_state, STATE_SIZE);
  vecScalarMult( k3, 2.0, tempState, STATE_SIZE );
  vecAdd( new_state, tempState, new_state, STATE_SIZE);
  vecAdd( new_state, k4, new_state, STATE_SIZE);
  vecScalarMult( new_state, 0.16667, new_state, STATE_SIZE );
  vecAdd( new_state, old_state, new_state, STATE_SIZE);

}
Пример #11
0
Cube::Cube(		float fLen, float fWidth, float fHeight,	 
				vect3d &pCenterPos,
				vect3d &pVerticalVec,
				vect3d &pHorizonVec,				
				float fReflR, float fRefrR, float fRefrK, float fEmitR)
	:PrimaryObject(fReflR, fRefrR, fRefrK, fEmitR)
{
	assert( (fLen > 0) && (fWidth > 0) && (fHeight > 0) );
	
	///
	///	Since there's no ObjObject in GPU, and I want to make primaryObj id the same as the 
	///	GPU primaryObj array index, I do this. This should not impact the current functional 
	///	code.
	///
	nCurrObj --;

	_fLength = fLen;	
	_fWidth = fWidth;	
	_fHeight = fHeight;	

	vecCopy(_vCenterPos, pCenterPos);
	vecCopy(_verticalVec, pVerticalVec);
	vecCopy(_horizonVec, pHorizonVec);

	vect3d tmpVec, tmpPoint;

	//	Top square
	vecScale(_verticalVec, _fHeight / 2.0, tmpVec);
	point2point(_vCenterPos, tmpVec, tmpPoint);
	_vs[0] = new Square(tmpPoint, _verticalVec, _horizonVec, _fLength, _fWidth);
	//_vs[0]->setColor(c1,c1,c1, c1, 0.5);

	vecScale(_verticalVec, (-1)*_fHeight / 2.0, tmpVec);
	point2point(_vCenterPos, tmpVec, tmpPoint);
	vecScale(_verticalVec, -1, tmpVec);
	_vs[1] = new Square(tmpPoint, tmpVec, _horizonVec, _fLength, _fWidth);
	//_vs[1]->setColor(c1,c1,c1, c1,0.5);

	//	Left square
	vect3d vLeftNormalVec;
	cross_product(_horizonVec, _verticalVec, vLeftNormalVec);
	normalize(vLeftNormalVec);

	vecScale(vLeftNormalVec, _fLength / 2.0, tmpVec);
	point2point(_vCenterPos, tmpVec, tmpPoint);
	_vs[2] = new Square(tmpPoint, vLeftNormalVec, _horizonVec, _fHeight, _fWidth);
	//_vs[2]->setColor(c2,c2,c2, c2,0.5);

	vecScale(vLeftNormalVec, (-1)*_fLength / 2.0, tmpVec);
	point2point(_vCenterPos, tmpVec, tmpPoint);
	vecScale(vLeftNormalVec, -1, tmpVec);
	_vs[3] = new Square(tmpPoint, tmpVec, _horizonVec, _fHeight, _fWidth);
	//_vs[3]->setColor(c2,c2,c2, c2,0.5);

	//	Right square
	vecScale(_horizonVec, _fWidth / 2.0, tmpVec);
	point2point(_vCenterPos, tmpVec, tmpPoint);
	_vs[4] = new Square(tmpPoint, _horizonVec, _verticalVec, _fLength, _fHeight);
	//_vs[4]->setColor(c3,c3,c3, c3,0.5);

	vecScale(_horizonVec, (-1)*_fWidth / 2.0, tmpVec);
	point2point(_vCenterPos, tmpVec, tmpPoint);
	vecScale(_horizonVec, -1, tmpVec);
	_vs[5] = new Square(tmpPoint, tmpVec, _verticalVec, _fLength, _fHeight);
	//_vs[5]->setColor(c3,c3,c3, c3,0.5);

	updateBBox();
}
Пример #12
0
bool Square::isHit(Ray &ray, vect3d &pNormal, float *pt, vect3d *pTexColor)
{
	if(!_bbox.isHit(ray))
	{
		return false;
	}

	//	The hit point on the plane
	vect3d op;
	points2vec(_vCenter, ray.start_point, op);

	float dn = dot_product(ray.direction_vec, _vNormal);
	if(dn == 0.f)
	{
		return false;
	}

	float t = - dot_product(op, _vNormal) / dn;
	//	NOTE: since it is a 0-thickness plane, we need this.
	if(t <= epsi)
	{
		return false;
	}

	//	Get the hit point
	vect3d vHitPoint;
	vect3d pView; vecScale(ray.direction_vec, t, pView);
	point2point(ray.start_point, pView, vHitPoint);

	vect3d vHitVec;
	points2vec(vHitPoint, _vCenter, vHitVec);

	float dx = dot_product(vHitVec, _v2HeightVec) / pow( _nWidth /2 , 2);
	float dy = dot_product(vHitVec, _v2WidthVec) / pow( _nHeight /2 , 2);
	
	if( fabs(dy) <= 1.f && fabs(dx) <= 1.0f )
	{
		*pt = t;
		vecCopy(pNormal, _vNormal);

		if(_tex != NULL && pTexColor != NULL)
		{
			float fWidInx = (-dx + 1.f) / 2.f * _nWidth;
			float fHeiInx = (dy + 1.f) / 2.f * _nHeight;

			switch(_eTexMapType)
			{
			case STRETCH:
				_tex->getTexAt( fWidInx / _nWidth * _tex->nWidth, 
								fHeiInx / _nHeight * _tex->nHeight, *pTexColor);
				break;

			case REPEAT:
				_tex->getTexAt( (unsigned)fWidInx % _tex->nWidth, 
								(unsigned)fHeiInx % _tex->nHeight, *pTexColor);
				break;

			case STRAIGHT:
				
				if(fWidInx < _tex->nWidth && fHeiInx < _tex->nHeight)
				{
					_tex->getTexAt( (unsigned)fWidInx, (unsigned)fHeiInx, *pTexColor);
				}
				break;

			};
		}
		return true;
	}
	
	return false;
}
Пример #13
0
void cameraSetView(Camera * camera, float4 pos, float4 target, float4 up) {
	vecCopy(camera->position, pos);
	vecCopy(camera->target, target);
	vecCopy(camera->up, up);
}