Ejemplo n.º 1
0
int RemoveHighestPriority(Heap *interval_heap) {
    int value_removed;
    if(IntervalHeapIsEmpty(*interval_heap)) {
        printf("Fila vazia!\n");
        return -1;
    } else if ((*interval_heap).node[0].min == -1) {
        value_removed = RemoveMaximum(&(*interval_heap), 0);
    } else if ((*interval_heap).node[0].max == -1) {
        value_removed = RemoveMinimum(&(*interval_heap), 0);
    } else {
        int final_node_position = (*interval_heap).size - 1;

        // Remove o valor mínimo da raiz.
        value_removed = RemoveMaximum(&(*interval_heap), 0);

        // Reinsere o valor do último nó na raiz.
        if((*interval_heap).node[final_node_position].max == -1) {
            SwapValues(&(*interval_heap).node[final_node_position].min,
                        &(*interval_heap).node[0].max);
        } else {
            SwapValues(&(*interval_heap).node[final_node_position].max,
                        &(*interval_heap).node[0].max);
        }
        DownwardsMax(&(*interval_heap), 0);
    }

    (*interval_heap).number_of_elements -= 1;
    if((*interval_heap).number_of_elements % 2 == 0) {
        (*interval_heap).size -= 1;
    }

    return value_removed;
}
Ejemplo n.º 2
0
/*
========================
idJointBuffer::Swap
========================
*/
void idJointBuffer::Swap( idJointBuffer & other ) {
	// Make sure the ownership of the buffer is not transferred to an unintended place.
	assert( other.OwnsBuffer() == OwnsBuffer() );

	SwapValues( other.numJoints, numJoints );
	SwapValues( other.offsetInOtherBuffer, offsetInOtherBuffer );
	SwapValues( other.apiObject, apiObject );
}
Ejemplo n.º 3
0
char BoundingBox::intersect(const Ray &ray, float *hitt0, float *hitt1) const 
{
    float t0 = ray.m_tmin, t1 = ray.m_tmax;
    for (int i = 0; i < 3; ++i) {
		const float diri = ray.m_dir.comp(i);
		const Vector3F o = ray.m_origin;
		if(IsValueNearZero(diri)) {
			if(i == 0) {
				if(o.x < m_data[0] || o.x > m_data[3]) return 0;
			}
			else if(i == 1) {
				if(o.y < m_data[1] || o.y > m_data[4]) return 0;
			}
			else {
				if(o.z < m_data[2] || o.z > m_data[5]) return 0;
			}
			continue;
		}
        // Update interval for _i_th bounding box slab
        float invRayDir = 1.f / ray.m_dir.comp(i);
        float tNear = (getMin(i) - ray.m_origin.comp(i)) * invRayDir;
        float tFar  = (getMax(i) - ray.m_origin.comp(i)) * invRayDir;

        // Update parametric interval from slab intersection $t$s
        if (tNear > tFar) SwapValues(tNear, tFar);
        t0 = tNear > t0 ? tNear : t0;
        t1 = tFar  < t1 ? tFar  : t1;
        if (t0 > t1) return 0;
    }
    if (hitt0) *hitt0 = t0;
    if (hitt1) *hitt1 = t1;
    return 1;
}
Ejemplo n.º 4
0
// Tendo o pai como referência, o mesmo é comparado com seus filhos e trocado
// caso a sua prioridade seja maior que a de um deles.
void DownwardsMin(Heap *intervals, int position) {

    //Assume que o filho de menor valor é o da esquerda.
    int lowest_son_position = 2*position+1;
    bool stop = false;

    // Enquanto o vetor ainda estiver sendo percorrido e o pai
    // não ser menor que ambos seus filhos...
    while((!stop) && (lowest_son_position < (*intervals).size)) {
        // Caso os filhos da direita e esquerda existirem e o valor atual do
        // filho de menor valor for maior que o do irmão, significa que a
        // posição do filho de menor valor é a posição do irmão.
        int father_value = (*intervals).node[position].min;
        if(BrotherHasLowerValue((*intervals), lowest_son_position)){
            lowest_son_position += 1;
            // Garante que o valor a ser utilizado é o correto.
            AssignValues(&(*intervals).node[lowest_son_position]);
        }

        // Caso o pai possua prioridade maior que a do filho de menor prioridade,
        // troca os valores de ambos entre si. A verificação é feita para ambos
        // os extremos do intervalo.
        if((father_value > (*intervals).node[lowest_son_position].min)
            && IsNotEmpty((*intervals).node[lowest_son_position].min)) {

            SwapValues(&(*intervals).node[position].min,
                        &(*intervals).node[lowest_son_position].min);

        } else if ((father_value > (*intervals).node[lowest_son_position].max)
            && IsNotEmpty((*intervals).node[lowest_son_position].max)) {

            SwapValues(&(*intervals).node[position].min,
                        &(*intervals).node[lowest_son_position].max);

        //Caso o pai esteja na posição correta, interrompe o loop.
        } else  {
            stop = true;
        }
        position = lowest_son_position;
        lowest_son_position = (2 * lowest_son_position) + 1;
        //Ajusta os valores máximo e mínimo, caso necessário.
        AssignValues(&(*intervals).node[position]);
    }
    AssignValues(&(*intervals).node[position]);
}
Ejemplo n.º 5
0
// Troca os valores máximo e mínimo caso não estejam no campo correto.
bool AssignValues(Interval *node) {
    if((((*node).max > -1) && ((*node).max < (*node).min))
        || (((*node).min > -1) && ((*node).min > (*node).max))) {
        SwapValues(&(*node).max, &(*node).min);
        return true;
    }

    return false;
}
Ejemplo n.º 6
0
void  main()
{
int  a,b;
int  *a_ptr, *b_ptr;
scanf("%d,%d",&a,&b);
a_ptr = &a;
b_ptr = &b;
SwapValues(&a, &b);//等同於SwapValues(a_ptr, b_ptr);
printf("a=%d,b=%d\n" , a,b);// 等同於printf("a=%d,b=%d",*a_ptr, *b_ptr);
}
Ejemplo n.º 7
0
int InsertionSort(int the_array[], unsigned int size)//Apply the insertion sort algorithm to sort an array of integers.
{
    int passes = 0;
    for (int i = 0; i <= (size - 1); i++) 
    {
        passes++;
        int j = i;
        while (j > 0 && the_array[j] < the_array[j - 1]) 
        {
            SwapValues(the_array[j], the_array[j - 1]);
            j = j - 1;
        }
    }
    return passes;
}
Ejemplo n.º 8
0
int BubbleSort(int the_array[], unsigned int size)//Apply the bubble sort algorithm to sort an array of integers.
{
    int passes = 0;
    for (int i = size - 1; i > 0; i--) 
    {
        passes++;
        for (int j = 0; j < i; j++) 
        {
            if (the_array[j] > the_array[j + 1]) 
            {
                SwapValues(the_array[j], the_array[j + 1]);
            }
        }
    }
    return passes;
}
Ejemplo n.º 9
0
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
//		¥ EvaluateInt
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
TTBInteger CRandomFunction::EvaluateInt(
	CProgram				&ioState)
{
	SInt32			t;
	TTBInteger		lower=mLower(ioState),higher=mHigher(ioState),temp;
	
	if (lower>higher)
		SwapValues(lower,higher,temp);

	// this implementation is assuming a 32 bit random number generator
	// if it's a 16 bit one, then passing a min max with a span > 16 bits will not yield a full spread
	COMPILE_TIME_ASSERT(RAND_MAX==0x7fffffff);
		
	UInt32		diff=higher-lower+1;
	TTBInteger	rand;
	
	rand=std::rand()%diff+lower;

	return rand;
}
Ejemplo n.º 10
0
int main()
{
//~ Function 1 
	int a = 1;
	int b = 2;
	printf("int a equals %d\n",  a);
	printf("int b equals %d\n",  b);
	SwapValues(&a, &b);
	printf("Values swapped\n");
	printf("int a now equals %d\n",  a);
	printf("int b now equals %d\n",  b);
	
	int arr[5] = {1, 2, 3, 4, 5};
	int len = 5;
//~	Function 2
	printf("New temp variable the sum is: %d\n", GetSumReturn(arr, len));
	
//~ Function 3
	int sum = 0;
	printf("The sum value is now: %d\n", sum);
	GetSumParameter(arr, len, &sum);
	printf("Sum value changed\n");
	printf("The sum value is now: %d\n", sum);

//~	Function 4
	int arr2[5] = {1, 2, 3, 4, 5};
	int result[5];
	int i = 0;
	for(; i != len; i++)
	{
		printf("%d\n", result[i]);
	}
	ArrayAdd(arr, arr2, len, result);
	i = 0;
	for(; i != len; i++)
	{
		printf("%d\n", result[i]);
	}
	
	return 0;
}
Ejemplo n.º 11
0
int SelectionSort(int the_array[], unsigned int size)//Apply the selection sort algorithm to sort an array of integers.
{
    int smallest = 0;
    int passes = 0;
    for (int i = 0; i < size; i++) 
    {
        passes++;
        smallest = i;
        for (int j = (i + 1); j < size; j++) 
        {
            if (the_array[j] < the_array[smallest])
            {
                smallest = j;
            }
        }
        if (smallest != i) 
        {
            SwapValues(the_array[i], the_array[smallest]);
        }
    }
    return passes;
}
Ejemplo n.º 12
0
int OptimizedBubbleSort(int the_array[], unsigned int size)//Apply the optimized bubble sort algorithm to sort an array of integers.
{
    int passes = 0;
    for (int i = size - 1; i > 0; i--)
    {
        bool swapped = false;
        passes++;
        for (int j = 0; j < i; j++)
        {
            if (the_array[j] > the_array[j + 1])
            {
                SwapValues(the_array[j], the_array[j + 1]);
                swapped = true;
            }
        }
        if (swapped == false)
        {
            break;
        }
    }
    return passes;
}
Ejemplo n.º 13
0
// Tendo o pai como referência, o mesmo é comparado com seus filhos e trocado
// caso a sua prioridade seja menor que a de um deles.
void DownwardsMax(Heap *intervals, int position) {

    //Assume que o filho de maior valor é o da esquerda.
    int highest_son_position = 2*position+1;
    bool stop = false;

    // Enquanto o vetor ainda estiver sendo percorrido e o pai
    // não ser maior que ambos seus filhos...
    while((!stop) && (highest_son_position < (*intervals).size)) {
        // Caso os filhos da direita e esquerda existirem e o valor do filho de
        // maior valor for menor que o do irmão, significa que a posição do filho de
        // maior valor é a posição do irmão.
        int father_value = (*intervals).node[position].max;
        if(BrotherHasHigherValue((*intervals), highest_son_position)) {
            highest_son_position += 1;
            // Garante que o valor a ser utilizado é o correto.
            AssignValues(&(*intervals).node[highest_son_position]);
        }

        // Caso o pai possua prioridade menor que a do filho de maior prioridade,
        // troca os valores de ambos entre si.
        if(father_value < (*intervals).node[highest_son_position].max) {

            SwapValues(&(*intervals).node[position].max,
                        &(*intervals).node[highest_son_position].max);

            position = highest_son_position;
            highest_son_position = (2 * highest_son_position) + 1;
            //Ajusta os valores máximo e mínimo, caso necessário.
            AssignValues(&(*intervals).node[position]);
        //Caso o pai esteja na posição correta, interrompe o loop.
        } else {
            stop = true;
        }
    }
    AssignValues(&(*intervals).node[position]);
}
Ejemplo n.º 14
0
/*
====================
idMD5Mesh::ParseMesh
====================
*/
void idMD5Mesh::ParseMesh( idLexer& parser, int numJoints, const idJointMat* joints )
{
	idToken		token;
	idToken		name;
	
	parser.ExpectTokenString( "{" );
	
	//
	// parse name
	//
	if( parser.CheckTokenString( "name" ) )
	{
		parser.ReadToken( &name );
	}
	
	//
	// parse shader
	//
	parser.ExpectTokenString( "shader" );
	
	parser.ReadToken( &token );
	idStr shaderName = token;
	
	shader = declManager->FindMaterial( shaderName );
	
	//
	// parse texture coordinates
	//
	parser.ExpectTokenString( "numverts" );
	int count = parser.ParseInt();
	if( count < 0 )
	{
		parser.Error( "Invalid size: %s", token.c_str() );
	}
	
	this->numVerts = count;
	
	idList<idVec2> texCoords;
	idList<int> firstWeightForVertex;
	idList<int> numWeightsForVertex;
	
	texCoords.SetNum( count );
	firstWeightForVertex.SetNum( count );
	numWeightsForVertex.SetNum( count );
	
	int numWeights = 0;
	int maxweight = 0;
	for( int i = 0; i < texCoords.Num(); i++ )
	{
		parser.ExpectTokenString( "vert" );
		parser.ParseInt();
		
		parser.Parse1DMatrix( 2, texCoords[ i ].ToFloatPtr() );
		
		firstWeightForVertex[ i ]	= parser.ParseInt();
		numWeightsForVertex[ i ]	= parser.ParseInt();
		
		if( !numWeightsForVertex[ i ] )
		{
			parser.Error( "Vertex without any joint weights." );
		}
		
		numWeights += numWeightsForVertex[ i ];
		if( numWeightsForVertex[ i ] + firstWeightForVertex[ i ] > maxweight )
		{
			maxweight = numWeightsForVertex[ i ] + firstWeightForVertex[ i ];
		}
	}
	
	//
	// parse tris
	//
	parser.ExpectTokenString( "numtris" );
	count = parser.ParseInt();
	if( count < 0 )
	{
		parser.Error( "Invalid size: %d", count );
	}
	
	idList<int> tris;
	tris.SetNum( count * 3 );
	numTris = count;
	for( int i = 0; i < count; i++ )
	{
		parser.ExpectTokenString( "tri" );
		parser.ParseInt();
		
		tris[ i * 3 + 0 ] = parser.ParseInt();
		tris[ i * 3 + 1 ] = parser.ParseInt();
		tris[ i * 3 + 2 ] = parser.ParseInt();
	}
	
	//
	// parse weights
	//
	parser.ExpectTokenString( "numweights" );
	count = parser.ParseInt();
	if( count < 0 )
	{
		parser.Error( "Invalid size: %d", count );
	}
	
	if( maxweight > count )
	{
		parser.Warning( "Vertices reference out of range weights in model (%d of %d weights).", maxweight, count );
	}
	
	idList<vertexWeight_t> tempWeights;
	tempWeights.SetNum( count );
	assert( numJoints < 256 );		// so we can pack into bytes
	
	for( int i = 0; i < count; i++ )
	{
		parser.ExpectTokenString( "weight" );
		parser.ParseInt();
		
		int jointnum = parser.ParseInt();
		if( ( jointnum < 0 ) || ( jointnum >= numJoints ) )
		{
			parser.Error( "Joint Index out of range(%d): %d", numJoints, jointnum );
		}
		
		tempWeights[ i ].joint			= jointnum;
		tempWeights[ i ].jointWeight	= parser.ParseFloat();
		
		parser.Parse1DMatrix( 3, tempWeights[ i ].offset.ToFloatPtr() );
	}
	
	// create pre-scaled weights and an index for the vertex/joint lookup
	idVec4* scaledWeights = ( idVec4* ) Mem_Alloc16( numWeights * sizeof( scaledWeights[0] ), TAG_MD5_WEIGHT );
	int* weightIndex = ( int* ) Mem_Alloc16( numWeights * 2 * sizeof( weightIndex[0] ), TAG_MD5_INDEX );
	memset( weightIndex, 0, numWeights * 2 * sizeof( weightIndex[0] ) );
	
	count = 0;
	for( int i = 0; i < texCoords.Num(); i++ )
	{
		int num = firstWeightForVertex[i];
		for( int j = 0; j < numWeightsForVertex[i]; j++, num++, count++ )
		{
			scaledWeights[count].ToVec3() = tempWeights[num].offset * tempWeights[num].jointWeight;
			scaledWeights[count].w = tempWeights[num].jointWeight;
			weightIndex[count * 2 + 0] = tempWeights[num].joint * sizeof( idJointMat );
		}
		weightIndex[count * 2 - 1] = 1;
	}
	
	parser.ExpectTokenString( "}" );
	
	// update counters
	c_numVerts += texCoords.Num();
	c_numWeights += numWeights;
	c_numWeightJoints++;
	for( int i = 0; i < numWeights; i++ )
	{
		c_numWeightJoints += weightIndex[i * 2 + 1];
	}
	
	//
	// build a base pose that can be used for skinning
	//
	idDrawVert* basePose = ( idDrawVert* )Mem_ClearedAlloc( texCoords.Num() * sizeof( *basePose ), TAG_MD5_BASE );
	for( int j = 0, i = 0; i < texCoords.Num(); i++ )
	{
		idVec3 v = ( *( idJointMat* )( ( byte* )joints + weightIndex[j * 2 + 0] ) ) * scaledWeights[j];
		while( weightIndex[j * 2 + 1] == 0 )
		{
			j++;
			v += ( *( idJointMat* )( ( byte* )joints + weightIndex[j * 2 + 0] ) ) * scaledWeights[j];
		}
		j++;
		
		basePose[i].Clear();
		basePose[i].xyz = v;
		basePose[i].SetTexCoord( texCoords[i] );
	}
	
	// build the weights and bone indexes into the verts, so they will be duplicated
	// as necessary at mirror seems
	
	static int maxWeightsPerVert;
	static float maxResidualWeight;
	
	const int MAX_VERTEX_WEIGHTS = 4;
	
	idList< bool > jointIsUsed;
	jointIsUsed.SetNum( numJoints );
	for( int i = 0; i < jointIsUsed.Num(); i++ )
	{
		jointIsUsed[i] = false;
	}
	
	numMeshJoints = 0;
	maxJointVertDist = 0.0f;
	
	//-----------------------------------------
	// new-style setup for fixed four weights and normal / tangent deformation
	//
	// Several important models have >25% residual weight in joints after the
	// first four, which is worrisome for using a fixed four joint deformation.
	//-----------------------------------------
	for( int i = 0; i < texCoords.Num(); i++ )
	{
		idDrawVert& dv = basePose[i];
		
		// some models do have >4 joint weights, so it is necessary to sort and renormalize
		
		// sort the weights and take the four largest
		int	weights[256];
		const int numWeights = numWeightsForVertex[ i ];
		for( int j = 0; j < numWeights; j++ )
		{
			weights[j] = firstWeightForVertex[i] + j;
		}
		// bubble sort
		for( int j = 0; j < numWeights; j++ )
		{
			for( int k = 0; k < numWeights - 1 - j; k++ )
			{
				if( tempWeights[weights[k]].jointWeight < tempWeights[weights[k + 1]].jointWeight )
				{
					SwapValues( weights[k], weights[k + 1] );
				}
			}
		}
		
		if( numWeights > maxWeightsPerVert )
		{
			maxWeightsPerVert = numWeights;
		}
		
		const int usedWeights = Min( MAX_VERTEX_WEIGHTS, numWeights );
		
		float totalWeight = 0;
		for( int j = 0; j < numWeights; j++ )
		{
			totalWeight += tempWeights[weights[j]].jointWeight;
		}
		assert( totalWeight > 0.999f && totalWeight < 1.001f );
		
		float usedWeight = 0;
		for( int j = 0; j < usedWeights; j++ )
		{
			usedWeight += tempWeights[weights[j]].jointWeight;
		}
		
		const float residualWeight = totalWeight - usedWeight;
		if( residualWeight > maxResidualWeight )
		{
			maxResidualWeight = residualWeight;
		}
		
		byte finalWeights[MAX_VERTEX_WEIGHTS] = { 0 };
		byte finalJointIndecies[MAX_VERTEX_WEIGHTS] = { 0 };
		for( int j = 0; j < usedWeights; j++ )
		{
			const vertexWeight_t& weight = tempWeights[weights[j]];
			const int jointIndex = weight.joint;
			const float fw = weight.jointWeight;
			assert( fw >= 0.0f && fw <= 1.0f );
			const float normalizedWeight = fw / usedWeight;
			finalWeights[j] = idMath::Ftob( normalizedWeight * 255.0f );
			finalJointIndecies[j] = jointIndex;
		}
		
		// Sort the weights and indices for hardware skinning
		for( int k = 0; k < 3; ++k )
		{
			for( int l = k + 1; l < 4; ++l )
			{
				if( finalWeights[l] > finalWeights[k] )
				{
					SwapValues( finalWeights[k], finalWeights[l] );
					SwapValues( finalJointIndecies[k], finalJointIndecies[l] );
				}
			}
		}
		
		// Give any left over to the biggest weight
		finalWeights[0] += Max( 255 - finalWeights[0] - finalWeights[1] - finalWeights[2] - finalWeights[3], 0 );
		
		dv.color[0] = finalJointIndecies[0];
		dv.color[1] = finalJointIndecies[1];
		dv.color[2] = finalJointIndecies[2];
		dv.color[3] = finalJointIndecies[3];
		
		dv.color2[0] = finalWeights[0];
		dv.color2[1] = finalWeights[1];
		dv.color2[2] = finalWeights[2];
		dv.color2[3] = finalWeights[3];
		
		for( int j = usedWeights; j < 4; j++ )
		{
			assert( dv.color2[j] == 0 );
		}
		
		for( int j = 0; j < usedWeights; j++ )
		{
			if( !jointIsUsed[finalJointIndecies[j]] )
			{
				jointIsUsed[finalJointIndecies[j]] = true;
				numMeshJoints++;
			}
			const idJointMat& joint = joints[finalJointIndecies[j]];
			float dist = ( dv.xyz - joint.GetTranslation() ).Length();
			if( dist > maxJointVertDist )
			{
				maxJointVertDist = dist;
			}
		}
	}
	
	meshJoints = ( byte* ) Mem_Alloc( numMeshJoints * sizeof( meshJoints[0] ), TAG_MODEL );
	numMeshJoints = 0;
	for( int i = 0; i < numJoints; i++ )
	{
		if( jointIsUsed[i] )
		{
			meshJoints[numMeshJoints++] = i;
		}
	}
	
	// build the deformInfo and collect a final base pose with the mirror
	// seam verts properly including the bone weights
	deformInfo = R_BuildDeformInfo( texCoords.Num(), basePose, tris.Num(), tris.Ptr(),
									shader->UseUnsmoothedTangents() );
									
	for( int i = 0; i < deformInfo->numOutputVerts; i++ )
	{
		for( int j = 0; j < 4; j++ )
		{
			if( deformInfo->verts[i].color[j] >= numJoints )
			{
				idLib::FatalError( "Bad joint index" );
			}
		}
	}
	
	Mem_Free( basePose );
}
Ejemplo n.º 15
0
/*
====================
idSurface_Polytope::SplitPolytope
====================
*/
int idSurface_Polytope::SplitPolytope( const idPlane &plane, const float epsilon, idSurface_Polytope **front, idSurface_Polytope **back ) const {
	int side, i, j, s, v0, v1, v2, edgeNum;
	idSurface *surface[2];
	idSurface_Polytope *polytopeSurfaces[2], *surf;
	int *onPlaneEdges[2];

	onPlaneEdges[0] = (int *) _alloca( indexes.Num() / 3 * sizeof( int ) );
	onPlaneEdges[1] = (int *) _alloca( indexes.Num() / 3 * sizeof( int ) );

	side = Split( plane, epsilon, &surface[0], &surface[1], onPlaneEdges[0], onPlaneEdges[1] );

	*front = polytopeSurfaces[0] = new (TAG_IDLIB_SURFACE) idSurface_Polytope;
	*back = polytopeSurfaces[1] = new (TAG_IDLIB_SURFACE) idSurface_Polytope;

	for ( s = 0; s < 2; s++ ) {
		if ( surface[s] ) {
			polytopeSurfaces[s] = new idSurface_Polytope( *surface[s] );
			delete surface[s];
			surface[s] = NULL;
		}
	}

	*front = polytopeSurfaces[0];
	*back = polytopeSurfaces[1];

	if ( side != SIDE_CROSS ) {
		return side;
	}

	// add triangles to close off the front and back polytope
	for ( s = 0; s < 2; s++ ) {

		surf = polytopeSurfaces[s];

		edgeNum = surf->edgeIndexes[onPlaneEdges[s][0]];
		v0 = surf->edges[abs(edgeNum)].verts[INT32_SIGNBITSET(edgeNum)];
		v1 = surf->edges[abs(edgeNum)].verts[INT32_SIGNBITNOTSET(edgeNum)];

		for ( i = 1; onPlaneEdges[s][i] >= 0; i++ ) {
			for ( j = i+1; onPlaneEdges[s][j] >= 0; j++ ) {
				edgeNum = surf->edgeIndexes[onPlaneEdges[s][j]];
				if ( v1 == surf->edges[abs(edgeNum)].verts[INT32_SIGNBITSET(edgeNum)] ) {
					v1 = surf->edges[abs(edgeNum)].verts[INT32_SIGNBITNOTSET(edgeNum)];
					SwapValues( onPlaneEdges[s][i], onPlaneEdges[s][j] );
					break;
				}
			}
		}

		for ( i = 2; onPlaneEdges[s][i] >= 0; i++ ) {
			edgeNum = surf->edgeIndexes[onPlaneEdges[s][i]];
			v1 = surf->edges[abs(edgeNum)].verts[INT32_SIGNBITNOTSET(edgeNum)];
			v2 = surf->edges[abs(edgeNum)].verts[INT32_SIGNBITSET(edgeNum)];
			surf->indexes.Append( v0 );
			surf->indexes.Append( v1 );
			surf->indexes.Append( v2 );
		}

		surf->GenerateEdgeIndexes();
	}

	return side;
}
Ejemplo n.º 16
0
/*
====================
idRenderModelLiquid::Update
====================
*/
void idRenderModelLiquid::Update()
{
	int		x, y;
	float*	p2;
	float*	p1;
	float	value;
	
	time += update_tics;
	
	SwapValues( page1, page2 );
	
	if( time > nextDropTime )
	{
		WaterDrop( -1, -1, page2 );
		nextDropTime = time + drop_delay;
	}
	else if( time < nextDropTime - drop_delay )
	{
		nextDropTime = time + drop_delay;
	}
	
	p1 = page1;
	p2 = page2;
	
	switch( liquid_type )
	{
		case 0 :
			for( y = 1; y < verts_y - 1; y++ )
			{
				p2 += verts_x;
				p1 += verts_x;
				for( x = 1; x < verts_x - 1; x++ )
				{
					value =
						( p2[ x + verts_x ] +
						  p2[ x - verts_x ] +
						  p2[ x + 1 ] +
						  p2[ x - 1 ] +
						  p2[ x - verts_x - 1 ] +
						  p2[ x - verts_x + 1 ] +
						  p2[ x + verts_x - 1 ] +
						  p2[ x + verts_x + 1 ] +
						  p2[ x ] ) * ( 2.0f / 9.0f ) -
						p1[ x ];
						
					p1[ x ] = value * density;
				}
			}
			break;
			
		case 1 :
			for( y = 1; y < verts_y - 1; y++ )
			{
				p2 += verts_x;
				p1 += verts_x;
				for( x = 1; x < verts_x - 1; x++ )
				{
					value =
						( p2[ x + verts_x ] +
						  p2[ x - verts_x ] +
						  p2[ x + 1 ] +
						  p2[ x - 1 ] +
						  p2[ x - verts_x - 1 ] +
						  p2[ x - verts_x + 1 ] +
						  p2[ x + verts_x - 1 ] +
						  p2[ x + verts_x + 1 ] ) * 0.25f -
						p1[ x ];
						
					p1[ x ] = value * density;
				}
			}
			break;
			
		case 2 :
			for( y = 1; y < verts_y - 1; y++ )
			{
				p2 += verts_x;
				p1 += verts_x;
				for( x = 1; x < verts_x - 1; x++ )
				{
					value =
						( p2[ x + verts_x ] +
						  p2[ x - verts_x ] +
						  p2[ x + 1 ] +
						  p2[ x - 1 ] +
						  p2[ x - verts_x - 1 ] +
						  p2[ x - verts_x + 1 ] +
						  p2[ x + verts_x - 1 ] +
						  p2[ x + verts_x + 1 ] +
						  p2[ x ] ) * ( 1.0f / 9.0f );
						  
					p1[ x ] = value * density;
				}
			}
			break;
	}
}
Ejemplo n.º 17
0
/*!
  For 3D and 2D.

  @par Revision history:
  - 08.06.2006, c
  - 02.08.2006
*/
int32 orient_elements( int32 *flag, int32 flag_n_row,
		      int32 *conn, int32 conn_n_row, int32 conn_n_col,
		      float64 *coors, int32 coors_n_row, int32 coors_n_col,
		      int32 *v_roots, int32 v_roots_n_row,
		      int32 *v_vecs, int32 v_vecs_n_row, int32 v_vecs_n_col,
		      int32 *swap_from, int32 swap_from_n_row, int32 swap_from_n_col,
		      int32 *swap_to, int32 swap_to_n_row, int32 swap_to_n_col )
{
#define IR( iel, ir ) (conn[conn_n_col*(iel)+v_roots[ir]])
#define IV( iel, ir, iv ) (conn[conn_n_col*(iel)+v_vecs[v_vecs_n_col*ir+iv]])
#define CONN( iel, ip ) (conn[conn_n_col*(iel)+ip])
#define SWF( ir, is ) (swap_from[swap_from_n_col*ir+is])
#define SWT( ir, is ) (swap_to[swap_to_n_col*ir+is])

  int32 ir, iel, ii, ip0, ip1, ip2, ip3, tmp, nc;
  float64 v0[3], v1[3], v2[3], v3[3], cross[3], dot[1];

  nc = coors_n_col;
  if (nc == 4) { // 3D.
    for (iel = 0; iel < conn_n_row; iel++) {
      flag[iel] = 0;

      for (ir = 0; ir < v_roots_n_row; ir++) {
	ip0 = IR( iel, ir );
	ip1 = IV( iel, ir, 0 );
	ip2 = IV( iel, ir, 1 );
	ip3 = IV( iel, ir, 2 );
	for (ii = 0; ii < 3; ii++) {
	  v0[ii] = coors[nc*ip0+ii];
	  v1[ii] = coors[nc*ip1+ii] - v0[ii];
	  v2[ii] = coors[nc*ip2+ii] - v0[ii];
	  v3[ii] = coors[nc*ip3+ii] - v0[ii];
	}
	gtr_cross_product( cross, v1, v2 );
	gtr_dot_v3( dot, v3, cross );
/*       output( "%d %d -> %d %d %d %d %e\n", iel, ir, ip0, ip1, ip2, ip3, */
/* 	      dot[0] ); */
	if (dot[0] < CONST_MachEps) {
	  flag[iel]++;
	  for (ii = 0; ii < swap_from_n_col; ii++) {
	    SwapValues( CONN( iel, SWF( ir, ii ) ),
			CONN( iel, SWT( ir, ii ) ), tmp );
/* 	  output( "%d %d\n", SWF( ir, ii ), SWT( ir, ii ) ); */
	  }
	}
      }
/*     sys_pause(); */
    }
  } else if (nc == 3) { // 2D.
    for (iel = 0; iel < conn_n_row; iel++) {
      flag[iel] = 0;

      for (ir = 0; ir < v_roots_n_row; ir++) {
	ip0 = IR( iel, ir );
	ip1 = IV( iel, ir, 0 );
	ip2 = IV( iel, ir, 1 );
	for (ii = 0; ii < 2; ii++) {
	  v0[ii] = coors[nc*ip0+ii];
	  v1[ii] = coors[nc*ip1+ii] - v0[ii];
	  v2[ii] = coors[nc*ip2+ii] - v0[ii];
	}
	v1[2] = v2[2] = 0.0;
	gtr_cross_product( cross, v1, v2 );
	if (cross[2] < CONST_MachEps) {
	  flag[iel]++;
	  for (ii = 0; ii < swap_from_n_col; ii++) {
	    SwapValues( CONN( iel, SWF( ir, ii ) ),
			CONN( iel, SWT( ir, ii ) ), tmp );
	  }
	}
      }
    }
  }
  
  return( RET_OK );

#undef IR
#undef IV
#undef CONN
#undef SWF
#undef SWT
}
Ejemplo n.º 18
0
/*
============
idWinding2D::RayIntersection
============
*/
bool idWinding2D::RayIntersection( const idVec2 &start, const idVec2 &dir, float &scale1, float &scale2, int *edgeNums ) const {
	int i, numEdges, localEdgeNums[2];
	int sides[MAX_POINTS_ON_WINDING_2D+1], counts[3];
	float d1, d2, epsilon = 0.1f;
	idVec3 plane, edges[2];

	scale1 = scale2 = 0.0f;
	counts[SIDE_FRONT] = counts[SIDE_BACK] = counts[SIDE_ON] = 0;

	plane = Plane2DFromVecs( start, dir );
	for ( i = 0; i < numPoints; i++ ) {
		d1 = plane.x * p[i].x + plane.y * p[i].y + plane.z;
		if ( d1 > epsilon ) {
			sides[i] = SIDE_FRONT;
		}
		else if ( d1 < -epsilon ) {
			sides[i] = SIDE_BACK;
		}
		else {
			sides[i] = SIDE_ON;
		}
		counts[sides[i]]++;
	}
	sides[i] = sides[0];

	if ( !counts[SIDE_FRONT] ) {
		return false;
	}
	if ( !counts[SIDE_BACK] ) {
		return false;
	}

	numEdges = 0;
	for ( i = 0; i < numPoints; i++ ) {
		if ( sides[i] != sides[i+1] && sides[i+1] != SIDE_ON ) {
			localEdgeNums[numEdges] = i;
			edges[numEdges++] = Plane2DFromPoints( p[i], p[(i+1)%numPoints] );
			if ( numEdges >= 2 ) {
				break;
			}
		}
	}
	if ( numEdges < 2 ) {
		return false;
	}

	d1 = edges[0].x * start.x + edges[0].y * start.y + edges[0].z;
	d2 = - ( edges[0].x * dir.x + edges[0].y * dir.y );
	if ( d2 == 0.0f ) {
		return false;
	}
	scale1 = d1 / d2;
	d1 = edges[1].x * start.x + edges[1].y * start.y + edges[1].z;
	d2 = - ( edges[1].x * dir.x + edges[1].y * dir.y );
	if ( d2 == 0.0f ) {
		return false;
	}
	scale2 = d1 / d2;

	if ( idMath::Fabs( scale1 ) > idMath::Fabs( scale2 ) ) {
		SwapValues( scale1, scale2 );
		SwapValues( localEdgeNums[0], localEdgeNums[1] );
	}

	if ( edgeNums ) {
		edgeNums[0] = localEdgeNums[0];
		edgeNums[1] = localEdgeNums[1];
	}
	return true;
}