Example #1
0
	iVertexBuffer* cVertexBufferOGL::CreateCopy(eVertexBufferUsageType aUsageType)
	{
		cVertexBufferOGL *pVtxBuff = hplNew( cVertexBufferOGL,(mpLowLevelGraphics,
			mVertexFlags,mDrawType,aUsageType,
			GetVertexNum(),GetIndexNum()) );

		//Copy the vertices to the new buffer.
		for(int i=0; i < klNumOfVertexFlags; i++)
		{
			if(kvVertexFlags[i] & mVertexFlags)
			{
				int lElements = kvVertexElements[i];
				if(mbTangents && kvVertexFlags[i] == eVertexFlag_Texture1)
					lElements=4;

				pVtxBuff->ResizeArray(kvVertexFlags[i], (int)mvVertexArray[i].size());

				memcpy(pVtxBuff->GetArray(kvVertexFlags[i]),
					&mvVertexArray[i][0], mvVertexArray[i].size() * sizeof(float));
			}
		}

		//Copy indices to the new buffer
		pVtxBuff->ResizeIndices(GetIndexNum());
		memcpy(pVtxBuff->GetIndices(), GetIndices(), GetIndexNum() * sizeof(unsigned int) );

		pVtxBuff->mbTangents = mbTangents;
		pVtxBuff->mbHasShadowDouble = mbHasShadowDouble;

		pVtxBuff->Compile(0);

		return pVtxBuff;
	}
Example #2
0
//******************************************************************************
//Name:  SetTensor                                                             *
//                                                                             *
//Purpose:  Set the tensor portion of the field                                *
//                                                                             *
//Takes: takes a pointer to a position array and the address of the tensor     *
//******************************************************************************
void field::SetTensor(double *position, const tensor &rval)
{

	int *index;
	int *r_index;
	int i, j, temp;
	double value;

//Error check
	if( rval.p->num_indices != (p->num_indices - 3) )
		error("SetTensor error:","cannot assign a tensor to a field point");

	for(i = 3; i < p->num_indices; i++)
	{
	  if( rval.p->range[i-3] != p->range[i] )
		  error("SetTensor error:","cannot assign a tensor to a field point");
	}
//set up the index array that indexes into the field and set the specified position
	index = new int[p->num_indices];
	GetIndices(position, index);

//set up the index array that indexes into the rval tensor
	r_index = new int[rval.p->num_indices];

//create a tempory tensor for stupid Microsoft (comment out if not using MS)
	tensor temp_t;
	temp_t = rval;

//set the field
	for(i = 0; i < rval.p->product; i++)
	{
		//pack the r_index array (see tensor::Contract)
		temp = 0;
		for(j = 0; j < rval.p->num_indices - 1; j++)
		{
		  r_index[j] = (i - i%rval.p->scales[j] - temp)/rval.p->scales[j];
		  temp += r_index[j] * rval.p->scales[j];
		}

		r_index[j] = (i - temp)/rval.p->scales[j];

		//complete the index array with the tensor indices
		for(j = 3; j < p->num_indices; j++) index[j] = r_index[j - 3];

        //comment out following line when using Microsoft (in the head)
        //value = rval.Val(r_index);

      //comment out following line when not using Microsoft (in the head)
		value = temp_t.Val(r_index);

		//put the rval tensors value into the field at specified position
      Set(value,index);
	}

  //Clean up
  delete [] index;
  delete [] r_index;
}
Example #3
0
// find the indices of the lattice element that contanis (x,y,z) 
int Lattice::GetIndices(float x, float y, float z, int &iidx, int &jidx, int &kidx) {

  int rank = GetRank(x,y,z); 
  if (rank!=-1) {
    GetIndices(rank, iidx, jidx, kidx); 
    return(rank); 
  }
  else return(-1); 

}
Example #4
0
int Lattice::CheckNeighbor(int myrank, float x, float y, float z)
{
  int i,j,k; 
  GetIndices(myrank, i, j, k); 
  if (isIn(x,y,z,i-1,j,k)==true) return(0);  //-X
  if (isIn(x,y,z,i+1,j,k)==true) return(1);  //+X
  if (isIn(x,y,z,i,j-1,k)==true) return(2);  //-Y
  if (isIn(x,y,z,i,j+1,k)==true) return(3);  //+Y
  if (isIn(x,y,z,i,j,k-1)==true) return(4);  //-Z
  if (isIn(x,y,z,i,j,k+1)==true) return(5);  //+Z
  return(-1); 
}
Example #5
0
File: primvar.cpp Project: JT-a/USD
bool 
UsdGeomPrimvar::ComputeFlattened(VtValue *value, UsdTimeCode time) const
{
    VtValue attrVal;
    if (!Get(&attrVal, time)) {
        return false;
    }

    // If the primvar attr value is not an array or if the primvar isn't 
    // indexed, simply return the attribute value.
    if (!attrVal.IsArrayValued() || !IsIndexed()) {
        *value = VtValue::Take(attrVal);
        return true;
    }

    VtIntArray indices;
    if (!GetIndices(&indices, time)) {
        TF_CODING_ERROR("No indices authored for indexed primvar <%s>.", 
                        _attr.GetPath().GetText());
        return false;
    }

    // Handle all known supported array value types.
    bool foundSupportedType =
        _ComputeFlattenedArray<VtVec2fArray>(attrVal, indices, value)       || 
        _ComputeFlattenedArray<VtVec2dArray>(attrVal, indices, value)       || 
        _ComputeFlattenedArray<VtVec2iArray>(attrVal, indices, value)       || 
        _ComputeFlattenedArray<VtVec2hArray>(attrVal, indices, value)       || 
        _ComputeFlattenedArray<VtVec3fArray>(attrVal, indices, value)       || 
        _ComputeFlattenedArray<VtVec3dArray>(attrVal, indices, value)       || 
        _ComputeFlattenedArray<VtVec3iArray>(attrVal, indices, value)       || 
        _ComputeFlattenedArray<VtVec3hArray>(attrVal, indices, value)       || 
        _ComputeFlattenedArray<VtVec4fArray>(attrVal, indices, value)       || 
        _ComputeFlattenedArray<VtVec4dArray>(attrVal, indices, value)       || 
        _ComputeFlattenedArray<VtVec4iArray>(attrVal, indices, value)       || 
        _ComputeFlattenedArray<VtVec4hArray>(attrVal, indices, value)       ||
        _ComputeFlattenedArray<VtMatrix3dArray>(attrVal, indices, value)    || 
        _ComputeFlattenedArray<VtMatrix4dArray>(attrVal, indices, value)    ||
        _ComputeFlattenedArray<VtStringArray>(attrVal, indices, value)      ||
        _ComputeFlattenedArray<VtDoubleArray>(attrVal, indices, value)      ||
        _ComputeFlattenedArray<VtIntArray>(attrVal, indices, value)         ||
        _ComputeFlattenedArray<VtFloatArray>(attrVal, indices, value)       ||
        _ComputeFlattenedArray<VtHalfArray>(attrVal, indices, value);

    if (!foundSupportedType) {
        TF_WARN("Unsupported indexed primvar value type %s.", 
                attrVal.GetTypeName().c_str());
    }

    return !value->IsEmpty();
}
Example #6
0
//------------------------------------------------------------------------------
/// \brief Gets the size necessary to read into a 1-dimensional array
//------------------------------------------------------------------------------
int ArrayReaderParser::GetArraySize () const
{
  int size = 1;
  if (ValidInputString())
  {
    VEC_INT_PAIR indices = GetIndices();
    for (size_t i = 0; i < indices.size(); ++i)
    {
      size *= indices[i].second;
    }
  }
  
  return size;
} // ArrayReaderParser::GetArraySize
Example #7
0
//******************************************************************************
//Name:  SetInterpTensor                                                       *
//                                                                             *
//Purpose:  set the grid tensors based on interpolation from a tensor at an    *
//          arbitrary position                                                 *
//                                                                             *
//Takes: pointer to the position array and address of the rval tensor          *
//******************************************************************************
void field::SetInterpTensor(double *position, const tensor &rval)
{
 int step;
 int i, j, k;
 int scaled_pos[3];
 int grid_pos[3];
 double pos[3];
 tensor dummy, temp;


 step = 1;
 out_of_range = FALSE;

//Set the reference position
  for(i = 0; i < 3; i++) reference_pos[i] = position[i];

//Get the double indices for the scaled position
  GetIndices(reference_pos, scaled_pos);

//step through the floor steping
 while( !out_of_range )
 {
	 for( i = 0; i < 2; i++)
	 {
		 for( j = 0; j < 2; j++)
		 {
			 for( k = 0; k < 2; k++)
			 {
			   grid_pos[0] = (int)floor( scaled_pos[0] + i * step );
			   grid_pos[1] = (int)floor( scaled_pos[1] + j * step );
            grid_pos[2] = (int)floor( scaled_pos[2] + k * step );
            GetPosition(grid_pos, pos);
            dummy <= GetTensor(pos);
            temp <= rval;
			   temp.ScalarMult(Smoother(PARTICLE_SMOOTHING));
			   dummy <= dummy + temp;
			   if( out_of_range ) break;
			 }
		 }
	 }
//temp hack to keep the interpolation to within one cell
 out_of_range = TRUE;
 }

}
Example #8
0
	void Init() {
		PROFILE_SCOPED()
		frac = 1.0 / double(edgeLen-1);

		// also want vtx indices for tris not touching edge of patch 
		indices.reset(new unsigned short[IDX_VBO_COUNT_ALL_IDX()]);
		unsigned short *idx = indices.get();
		for (int x=0; x<edgeLen-1; x++) {
			for (int y=0; y<edgeLen-1; y++) {
				idx[0] = x + edgeLen*y;
				idx[1] = x+1 + edgeLen*y;
				idx[2] = x + edgeLen*(y+1);
				idx+=3;

				idx[0] = x+1 + edgeLen*y;
				idx[1] = x+1 + edgeLen*(y+1);
				idx[2] = x + edgeLen*(y+1);
				idx+=3;
			}
		}

		// these will hold the optimised indices
		std::vector<unsigned short> pl_short;

		// populate the N indices lists from the arrays built during InitTerrainIndices()
		// iterate over each index list and optimize it
		unsigned int tri_count = GetIndices(pl_short);
		VertexCacheOptimizerUShort vco;
		VertexCacheOptimizerUShort::Result res = vco.Optimize(&pl_short[0], tri_count);
		assert(0 == res);

		//create buffer & copy
		indexBuffer.Reset(Pi::renderer->CreateIndexBuffer(pl_short.size(), Graphics::BUFFER_USAGE_STATIC));
		Uint16* idxPtr = indexBuffer->Map(Graphics::BUFFER_MAP_WRITE);
		for (Uint32 j = 0; j < pl_short.size(); j++) {
			idxPtr[j] = pl_short[j];
		}
		indexBuffer->Unmap();

		if (indices) {
			indices.reset();
		}
	}
void CConvexHull::GetVertices(CArrayBlock* pasPositions, SFloat3* psPoints, int iStride)
{
	CArrayInt	aiIndices;
	int			i;
	int			iIndex;
	SFloat3*	psPosition;

	aiIndices.Init(mcPolygons.NumElements()+1);
	GetIndices(&aiIndices, psPoints, iStride);

	for (i = 0; i < aiIndices.NumElements(); i++)
	{
		iIndex = aiIndices.GetValue(i);
		psPosition = GetPosition(psPoints, iStride, iIndex);
		pasPositions->Add(psPosition);
	}

	aiIndices.Kill();
}
Example #10
0
    VOID InsertWeight( DWORD dwIndex, DWORD dwBoneIndex, FLOAT fBoneWeight )
    {
        assert( dwBoneIndex < 256 );

        BYTE* pIndices = GetIndices( dwIndex );
        FLOAT* pWeights = GetWeights( dwIndex );

        for( DWORD i = 0; i < dwVertexStride; ++i )
        {
            if( fBoneWeight > pWeights[i] )
            {
                for( DWORD j = (dwVertexStride - 1); j > i; --j )
                {
                    pIndices[j] = pIndices[j - 1];
                    pWeights[j] = pWeights[j - 1];
                }
                pIndices[i] = (BYTE)dwBoneIndex;
                pWeights[i] = fBoneWeight;
                break;
            }
        }
    }
Example #11
0
_Use_decl_annotations_
Geometry AssetLoader::LoadGeometryFromFile(const char* filename) const
{
    char source[MAX_PATH];
    sprintf_s(source, "%s%s", GetConfig().ContentRoot, filename);

    GeometryFileData data;
    LoadGeometryFileData(source, &data);

    auto pool = GetGraphics().GetPoolWithSpace(VertexFormat::StaticGeometry, data.NumVertices, data.NumIndices);
    uint32_t verticesIndex = 0;
    uint32_t indicesIndex = 0;
    pool->ReserveRange(data.NumVertices, data.NumIndices, &verticesIndex, &indicesIndex);

    ComPtr<ID3D11Device> device;
    pool->GetVertices()->GetDevice(&device);

    ComPtr<ID3D11DeviceContext> context;
    device->GetImmediateContext(&context);

    D3D11_BOX box = {};
    box.left = sizeof(StaticGeometryVertex) * verticesIndex;
    box.right = box.left + data.NumVertices * sizeof(StaticGeometryVertex);
    box.bottom = 1;
    box.back = 1;
    context->UpdateSubresource(pool->GetVertices(), 0, &box, data.Vertices, data.NumVertices * sizeof(StaticGeometryVertex), 0);

    box.left = sizeof(uint32_t) * indicesIndex;
    box.right = box.left + (data.NumIndices * sizeof(uint32_t));
    context->UpdateSubresource(pool->GetIndices(), 0, &box, data.Indices, data.NumIndices * sizeof(uint32_t), 0);

    Geometry geometry(pool, verticesIndex, indicesIndex, data.NumIndices);

    FreeGeometryFileData(&data);

    return geometry;
}
Example #12
0
MyMeshText::MyMeshText(int maxletters, FontDefinition* pFont)
{
    m_pFont = pFont;

#if _DEBUG
    m_MostLettersAttemptedToDrawThisFrame = 0;
    m_MostLettersAttemptedToDrawEver = 0;
#endif

    // Create buffers and base set of indices.
    CreateBuffers( VertexFormat_XYZUV_RGBA, (unsigned short)maxletters*4, maxletters*6, true );

    unsigned short* pIndices = GetIndices( true );
    for( unsigned short i=0; i<maxletters; i++ )
    {
        pIndices[i*6+0] = i*4+0;  // 0--1
        pIndices[i*6+1] = i*4+2;  // |\ |
        pIndices[i*6+2] = i*4+1;  // | \|
        pIndices[i*6+3] = i*4+2;  // 3--2
        pIndices[i*6+4] = i*4+0;
        pIndices[i*6+5] = i*4+3;
    }
    RebuildIndices();
}
Example #13
0
//******************************************************************************
//Name:  GetInterpTensor                                                       *
//                                                                             *
//Purpose:  get the interpolated tensor at an arbitrary position               *
//                                                                             *
//Takes: pointer to the position array                                         *
//******************************************************************************
tensor field::GetInterpTensor(double *position)
{
 int i, j, k, m, n;
 double scaled_pos[3];
 int grid_pos[3];
 double W;

 if( is_series_set == FALSE )
  error("GetInterpTensor error:","series not set");

 //initialize member data tensors
 sum_Wm   <= 0.0*sum_Wm;
 sum_a2   <= 0.0*sum_a2;
 sum_da1  <= 0.0*sum_da1;
 d_sum_a2 <= 0.0*d_sum_a2;

 out_of_range = FALSE;

//Set the reference position
  for(i = 0; i < 3; i++) reference_pos[i] = position[i];

//Get the real indices for the scaled position
  GetIndices(reference_pos, scaled_pos);

//Create the return tensor and set it to zero
 ret_dummy <= 0.0*GetTensor(reference_pos);

//Reset the normalization
  normalization = 0.0;

//step through the floor steping
  for( i = grid_lower_bound; i < grid_upper_bound; i++)
   {
	 for( j = grid_lower_bound; j < grid_upper_bound; j++)
	  {
	   for( k = grid_lower_bound; k < grid_upper_bound; k++)
		 {
         //Get the indices of the lowest corner of the cell
			grid_pos[0] = (int)floor( scaled_pos[0] + i );
			grid_pos[1] = (int)floor( scaled_pos[1] + j );
         grid_pos[2] = (int)floor( scaled_pos[2] + k );

         //find the position this grid point
         GetPosition(grid_pos,current_pos);

         //form the difference array and its magnitude (for use by smoother)
         //and the difference position
         y = 0;
         for( m = 0; m < 3; m++ )
			 {
           pos_diff[m] = reference_pos[m] - current_pos[m];
           y += pos_diff[m]*pos_diff[m];
           d.Set(pos_diff[m], m);
			 }
         y = sqrt(y)/smoothing_length;
         if( y > 1.0 + SMOOTHING_TOL ) continue;

         //get all of the tensors requested by the order
         for( m = 0; m <= series.order; m++)
           tmp[m] <= series.list[m]->GetTensor(grid_pos);

         //get the (psuedo) scalar smoothing value
         W = Smoother(CWM_SMOOTHER);

			//if the field is basic (i.e. not a derivative of
			//another field)
			if( is_deriv_field == FALSE )
			 {
           if( series.order == 2 )
            {
              m = tmp[2].NumIndices() - 1;
              tmp[2] <= 0.5 *( tmp[2].Contract(d,m,0) ).Contract(d,m-1,0);
            }
           if( series.order == 1 || series.order == 2 )
            {
              m = tmp[1].NumIndices() - 1;
              tmp[1] <= tmp[1].Contract(d,m,0);
            }
           for( m = 0; m <= series.order; m++)
			      ret_dummy <= ret_dummy + W*tmp[m];
			 }


			//if the field is not basic (i.e. is a derivative of
			//another field
         if( is_deriv_field == TRUE )
			 {
			   //if the field is independent (i.e. its smoothing is not
			   //a derivative of the smoohting of its basic field
			   if( is_dep_field == FALSE )
			    {
				  temp0 <= 0.0*tmp[0];
				  if( series.order == 1 )
				   {
				    m = tmp[1].NumIndices() - 1;
				    temp0 <= tmp[1].Contract(d,m,0);
				   }
				  ret_dummy <= ret_dummy + W*(tmp[0] + temp0);
			    }
			   //if the field is dependent (i.e. it smoothing is
			   //based on the derivative of the smoothing of its basic field
			   else
			    {
				  temp0 <= 0.0*tmp[0];
              if( series.order == 2 )
				   {
                 m = tmp[2].NumIndices() - 1;
                 //form the 1/2 * t,ij*(z-x)_i*(z-x)_j term if neccessary
                 temp0 <= 0.5*( tmp[2].Contract(d,m,0) ).Contract(d,m-1,0);
				   }

				  temp1 <= 0.0*tmp[0];
				  if( series.order ==1 || series.order == 2 )
				   {
                 n = tmp[1].NumIndices() - 1;
				     //form the t,i*(z-x)_i term if neccessary
					  temp1 <= tmp[1].Contract(d,n,0);

					  //form the t,i + t,ij*(z-x)_j
                 temp2 <= 0.0*tmp[1];
                 if( series.order == 2 ) temp2 <=  tmp[2].Contract(d,m,0);
                 sum_da1 <= sum_da1 + W*(tmp[1] + temp2);
 				   }
				  //form the t + t,i*(z-x)_i + 1/2 * t,ij*(z-x)_i*(z-x)_j
              a2 <= tmp[0] + temp1 + temp0;

              sum_a2 <=  sum_a2 + W*a2;

              //get the derivative of the smoothing
              Wm <= Smoother_Deriv(CWM_SMOOTHER);

              //keep running sum
              sum_Wm <= sum_Wm + Wm;

              //form the term labeled dN_D_2 in the MathCAD
              d_sum_a2 <= d_sum_a2 + a2 * Wm;
			    }
          }
	    }
	  }
   }

//Normalize the interpolated tensor
  if( is_dep_field == FALSE ) ret_dummy <= (1.0/normalization)*ret_dummy;
  if( is_dep_field == TRUE  )
  {
    ret_dummy <= normalization * ( sum_da1 + d_sum_a2 ) - sum_a2 * sum_Wm;
    ret_dummy <= 1.0/(normalization*normalization) * ret_dummy;
  }

 return ret_dummy;

}
Example #14
0
//******************************************************************************
//Name:  GetTensor                                                             *
//                                                                             *
//Purpose:  get the tensor portion of the field given the position             *
//                                                                             *
//Takes: point to a position array                                             *
//******************************************************************************
tensor field::GetTensor(double *position)
{

	int *index;
	int num_indices, f_num_indices;
	int *range;
	int *d_index;
	int i, j, temp;

//set up the index array that indexes into the field and pack the position indices
	index = new int[p->num_indices];
	GetIndices(position, index);

//get the parameters necessary to define the dummy return tensor
	num_indices = p->num_indices - 3;
	range = new int[num_indices];

	for(i = 0; i < num_indices; i++)
		range[i] = p->range[i+3];

//set up the d_index array that indexes into the dummy return tensor
	d_index = new int[num_indices];

//Create the dummy tensor which will hold the return values and resize it
	tensor dummy;

	dummy.Resize(num_indices, range);

//Loop over the number of components
	for(i = 0; i < dummy.p->product; i++)
	{
      //test for range = 1 cases here
      f_num_indices = p->num_indices;
      for(j = 0; j < p->num_indices; j++)
       {
         if(p->range[j] == 1) f_num_indices--;
       }
		//pack the index array (see tensor::Contract)
		temp = 0;
		for(j = 3; j < f_num_indices - 1; j++)
		 {
		  index[j] = (i - i%p->scales[j] - temp)/p->scales[j];
		  temp += index[j] * p->scales[j];
		 }
      //handle range = 1 cases here
      if(f_num_indices < p->num_indices)
       {
        index[f_num_indices - 1] = (i - temp)/p->scales[f_num_indices - 1];
        for(j = f_num_indices; j < p->num_indices; j++) index[j] = 0;
       }
      else
       {
        index[j] = (i - temp)/p->scales[j];
       }

		//strip off only the 'field' indices leaving the indices that specify position
		for(j = 0; j < num_indices; j++)
			d_index[j] = index[j+3];

		//set the value of dummy with the value of the field
        dummy.Set(Val(index),d_index);
	}

//clean up
	delete [] range;
	delete [] index;
	delete [] d_index;

//return
   return dummy;

}
Example #15
0
BoundingBox::BoundingBox(btDiscreteDynamicsWorld* worldN)
{
	world = worldN;
	layer = 0;
	parent = NULL;

	Vertex fill = { { -0.5f*METER, -0.5f*METER, -0.5f*METER }, { 1.0f, 0.0f, 0.0f } };
	GetVertices().push_back(fill);
	Vertex fill1 = { { 0.5f*METER, -0.5f*METER, 0.5f*METER }, { 1.0f, 0.0f, 0.0f } };
	GetVertices().push_back(fill1);
	Vertex fill2 = { { -0.5f*METER, -0.5f*METER, 0.5f*METER }, { 1.0f, 0.0f, 0.0f } };
	GetVertices().push_back(fill2);
	Vertex fill3 = { { 0.5f*METER, -0.5f*METER, -0.5f*METER }, { 1.0f, 0.0f, 0.0f } };
	GetVertices().push_back(fill3);

	Vertex fill4 = { { -0.5f*METER, 0.5f*METER, -0.5f*METER }, { 1.0f, 0.0f, 0.0f } };
	GetVertices().push_back(fill4);
	Vertex fill5 = { { 0.5f*METER, 0.5f*METER, 0.5f*METER }, { 1.0f, 0.0f, 0.0f } };
	GetVertices().push_back(fill5);
	Vertex fill6 = { { -0.5f*METER, 0.5f*METER, 0.5f*METER }, { 1.0f, 0.0f, 0.0f } };
	GetVertices().push_back(fill6);
	Vertex fill7 = { { 0.5f*METER, 0.5f*METER, -0.5f*METER }, { 1.0f, 0.0f, 0.0f } };
	GetVertices().push_back(fill7);

	Index iFill1 = { glm::uvec3(0, 1, 2) };
	GetIndices().push_back(iFill1);
	Index iFill2 = { glm::uvec3(0, 3, 1) };
	GetIndices().push_back(iFill2);
	Index iFill3 = { glm::uvec3(4, 6, 5) };
	GetIndices().push_back(iFill3);
	Index iFill4 = { glm::uvec3(4, 5, 7) };
	GetIndices().push_back(iFill4);
	Index iFill5 = { glm::uvec3(0, 2, 6) };
	GetIndices().push_back(iFill5);
	Index iFill6 = { glm::uvec3(0, 6, 4) };
	GetIndices().push_back(iFill6);
	Index iFill7 = { glm::uvec3(1, 3, 7) };
	GetIndices().push_back(iFill7);
	Index iFill8 = { glm::uvec3(1, 7, 5) };
	GetIndices().push_back(iFill8);
	Index iFill9 = { glm::uvec3(0, 4, 7) };
	GetIndices().push_back(iFill9);
	Index iFill10 = { glm::uvec3(0, 7, 3) };
	GetIndices().push_back(iFill10);
	Index iFill11 = { glm::uvec3(1, 5, 6) };
	GetIndices().push_back(iFill11);
	Index iFill12 = { glm::uvec3(1, 6, 2) };
	GetIndices().push_back(iFill12);


	shape = new btBoxShape(btVector3(0.5f * METER, 0.5f * METER, 0.5f * METER));

	btDefaultMotionState* fallMotionState =
		new btDefaultMotionState(btTransform(btQuaternion(0, 0, 0, 1), btVector3(0, 50*METER, 0)));
	btScalar mass = 1;
	btVector3 fallInertia(0, 0, 0);
	shape->calculateLocalInertia(mass, fallInertia);
	btRigidBody::btRigidBodyConstructionInfo fallRigidBodyCI(mass, fallMotionState, shape, fallInertia);
	rigidBody = new btRigidBody(fallRigidBodyCI);
	world->addRigidBody(rigidBody);

	

	Load();
}
Example #16
0
//******************************************************************************
//Name:  GetInterpTensor                                                       *
//                                                                             *
//Purpose:  get the interpolated tensor at an arbitrary position               *
//                                                                             *
//Takes: pointer to the position array                                         *
//******************************************************************************
tensor Particle::GetInterpTensor(double *position)
{
 int i, j, k, m, n;
 double scaled_pos[3];
 int grid_pos[3];
 double W;

 //initialize member data tensors
 sum_Wm   <= 0.0*sum_Wm;

//Set the reference position
  for(i = 0; i < 3; i++) reference_pos[i] = position[i];

//Get the real indices for the scaled position
  GetIndices(reference_pos, scaled_pos);

//Create the return tensor and set it to zero
// ret_dummy <= 0.0*GetTensor(reference_pos);

//Reset the normalization
  normalization = 0.0;

//step through the floor steping
  for( i = grid_lower_bound; i < grid_upper_bound; i++)
   {
	 for( j = grid_lower_bound; j < grid_upper_bound; j++)
	  {
	   for( k = grid_lower_bound; k < grid_upper_bound; k++)
		 {
         //Get the indices of the lowest corner of the cell
			grid_pos[0] = (int)floor( scaled_pos[0] + i );
			grid_pos[1] = (int)floor( scaled_pos[1] + j );
         grid_pos[2] = (int)floor( scaled_pos[2] + k );

         //find the position this grid point
         GetPosition(grid_pos,current_pos);

         //form the difference array and its magnitude (for use by smoother)
         //and the difference position
         y = 0;
         for( m = 0; m < 3; m++ )
			 {
           pos_diff[m] = reference_pos[m] - current_pos[m];
           y += pos_diff[m]*pos_diff[m];
           d.Set(pos_diff[m], m);
			 }
         y = sqrt(y)/smoothing_length;
         if( y > 1.0 + SMOOTHING_TOL ) continue;

         //get the (psuedo) scalar smoothing value
         W = Smoother(CWM_SMOOTHER);

         //get the derivative of the smoothing
         Smoother_Deriv(CWM_SMOOTHER);

         //keep running sum
         sum_Wm <= sum_Wm + Wm;
	    }
	  }
   }

//Normalize the interpolated tensor

 return ret_dummy;
Example #17
0
//******************************************************************************
//Name:  update_inv_g                                                          *
//                                                                             *
//Purpose:  scans over the relevant regions of the grid and gets a smoothed    *
//          version of the inverse metric at the particle                      *
//                                                                             *
//Takes:                                                                       *
//******************************************************************************
void Particle::update_inv_g(int stage)
{
 int i, j, k, m, n;
 double scaled_pos[3];
 int grid_pos[3];
 double position[3];
 double W;

//loop over the particles and determine the smoothed inverse metric
//for each one
 for( c1 = 0; c1 < numParticles; c1++)
 {
  //Set the reference position using the particle's position
  reference_pos[0] = pos[stage][c1].Val(0);
  reference_pos[1] = pos[stage][c1].Val(1);
  reference_pos[2] = pos[stage][c1].Val(2);

  //Get the real indices for the scaled position
  GetIndices(reference_pos, scaled_pos);

  //Reset the normalization
  normalization = 0.0;

  //initialize member data tensors
  sum_Wm      <= 0.0*sum_Wm;
  T_temp4x4   <= 0.0*T_temp4x4;
  T_temp4x4x3 <= 0.0*T_temp4x4x3;

  //step through the floor steping
  for( i = grid_lower_bound; i < grid_upper_bound; i++)
   {
	 for( j = grid_lower_bound; j < grid_upper_bound; j++)
	  {
	   for( k = grid_lower_bound; k < grid_upper_bound; k++)
		 {
         //Get the indices of the lowest corner of the cell
			grid_pos[0] = (int)floor( scaled_pos[0] + i );
			grid_pos[1] = (int)floor( scaled_pos[1] + j );
         grid_pos[2] = (int)floor( scaled_pos[2] + k );

         //find the metric at the particular grid point
         inv_g_temp <= my_field_partner->GetInvG(stage,
                                                 grid_pos[0],
                                                 grid_pos[1],
                                                 grid_pos[2]);

         //find the position this grid point
         GetPosition(grid_pos,current_pos);

         //form the difference array and its magnitude (for use by smoother)
         //and the difference position
         y = 0;
         for( m = 0; m < 3; m++ )
			 {
           pos_diff[m] = reference_pos[m] - current_pos[m];
           y += pos_diff[m]*pos_diff[m];
			 }
         y = sqrt(y)/smoothing_length;
         if( y > 1.0 + SMOOTHING_TOL ) continue;

         //get the (psuedo) scalar smoothing value
         W = Smoother(CWM_SMOOTHER);

         //get the derivative of the smoothing
         Smoother_Deriv(CWM_SMOOTHER);

         //keep running sum
         sum_Wm      <= sum_Wm + Wm;
 	      T_temp4x4   <= T_temp4x4 + W*inv_g_temp;
         T_temp4x4x3 <= T_temp4x4x3 + inv_g_temp*Wm;

	    }
	  }
   }

  //Normalize the interpolated tensor and pack arrays
  inv_g[stage][c1]   <= T_temp4x4;
  d_inv_g[stage][c1] <= T_temp4x4x3;
  norm[stage][c1]     = normalization;
  d_norm[stage][c1]  <= sum_Wm;

 }


Example #18
0
void AasRenderer::Render(gfx::AnimatedModel *model,
	const gfx::AnimatedModelParams& params,
	gsl::span<Light3d> lights,
	const MdfRenderOverrides *materialOverrides) {

	// Find or create render caching data for the model
	auto &renderData = mRenderDataCache[model->GetHandle()];
	if (!renderData) {
		renderData = std::make_unique<AasRenderData>();
	}
	
	auto materialIds(model->GetSubmeshes());
	for (size_t i = 0; i < materialIds.size(); ++i) {
		auto materialId = materialIds[i];
		auto submesh(model->GetSubmesh(params, i));
		
		// Remove special material marker in the upper byte and only 
		// use the actual shader registration id
		materialId &= 0x00FFFFFF;

		// Usually this should not happen, since it means there's  
		// an unbound replacement material
		if (materialId == 0) {
			continue;
		}

		// if material was not found
		if (materialId == 0x00FFFFFF) {
			continue;
		}

		auto material = mMdfFactory.GetById(materialId);
		
		if (!material) {
			logger->error("Legacy shader with id {} wasn't found.", materialId);
			continue;
		}

		material->Bind(mDevice, lights, materialOverrides);

		// Do we have to recalculate the normals?
		if (material->GetSpec()->recalculateNormals) {
			RecalcNormals(
				submesh->GetVertexCount(),
				submesh->GetPositions().data(),
				submesh->GetNormals().data(),
				submesh->GetPrimitiveCount(),
				submesh->GetIndices().data()
			);
		}

		auto &submeshData = GetSubmeshData(*renderData, i, *submesh);
		submeshData.binding.Bind();

		auto d3d = mDevice.GetDevice();
		d3d->SetIndices(submeshData.idxBuffer->GetBuffer());
		D3DLOG(d3d->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, submesh->GetVertexCount(), 0, submesh->GetPrimitiveCount()));

	}

}
Example #19
0
    void ModelDefinition::Serialize(Serializer &serializer) const
    {
        BasicSerializer intermediarySerializer;


        /////////////////////////////////////
        // Bones

        intermediarySerializer.Write(static_cast<uint32_t>(m_bones.count));
        
        // Local information.
        for (size_t iBone = 0; iBone < m_bones.count; ++iBone)
        {
            auto bone = m_bones[iBone];
            assert(bone != nullptr);
            {
                // Name.
                intermediarySerializer.WriteString(bone->GetName());

                // Relative transformation.
                intermediarySerializer.Write(bone->GetPosition());
                intermediarySerializer.Write(bone->GetRotation());
                intermediarySerializer.Write(bone->GetScale());

                // 4x4 offset matrix.
                intermediarySerializer.Write(bone->GetOffsetMatrix());
            }
        }

        // Parents. -1 for bones without parents.
        for (size_t iBone = 0; iBone < m_bones.count; ++iBone)
        {
            auto bone = m_bones[iBone];
            assert(bone != nullptr);
            {
                auto parentBone = bone->GetParent();
                if (parentBone != nullptr)
                {
                    size_t parentBoneIndex;
                    if (!this->FindBoneIndex(parentBone, parentBoneIndex))
                    {
                        assert(false);
                    }
                    
                    intermediarySerializer.Write(static_cast<uint32_t>(parentBoneIndex));
                }
                else
                {
                    intermediarySerializer.Write(static_cast<uint32_t>(-1));
                }
            }
        }

        Serialization::ChunkHeader header;
        header.id          = Serialization::ChunkID_Model_Bones;
        header.version     = 1;
        header.sizeInBytes = intermediarySerializer.GetBufferSizeInBytes();
        serializer.Write(header);
        serializer.Write(intermediarySerializer.GetBuffer(), header.sizeInBytes);



        /////////////////////////////////////
        // Meshes
        //
        // Vertex data is always saved in P3T2N3T3B3 format. Bones are referenced using an integer to index into the list of bones defined above.

        intermediarySerializer.Clear();
        intermediarySerializer.Write(static_cast<uint32_t>(this->meshes.count));

        for (size_t iMesh = 0; iMesh < this->meshes.count; ++iMesh)
        {
            // Name.
            intermediarySerializer.WriteString(this->meshes[iMesh].name);


            // Material.
            intermediarySerializer.WriteString(this->meshes[iMesh].material->GetDefinition().relativePath);


            // Vertices.
            auto vertexArray = this->meshes[iMesh].geometry;
            assert(vertexArray != nullptr);
            {
                // Vertex Format.
                vertexArray->GetFormat().Serialize(intermediarySerializer);


                // Vertices.
                intermediarySerializer.Write(static_cast<uint32_t>(vertexArray->GetVertexCount()));

                if (vertexArray->GetVertexCount() > 0)
                {
                    intermediarySerializer.Write(vertexArray->GetVertexDataPtr(), vertexArray->GetFormat().GetSizeInBytes() * vertexArray->GetVertexCount());
                }


                // Indices.
                intermediarySerializer.Write(static_cast<uint32_t>(vertexArray->GetIndexCount()));

                if (vertexArray->GetIndexCount() > 0)
                {
                    intermediarySerializer.Write(vertexArray->GetIndexDataPtr(), sizeof(uint32_t) * vertexArray->GetIndexCount());
                }


                // Skinning Vertex Attributes.
                if (this->meshes[iMesh].skinningVertexAttributes != nullptr)
                {
                    intermediarySerializer.Write(static_cast<uint32_t>(vertexArray->GetVertexCount()));

                    if (vertexArray->GetVertexCount() > 0)
                    {
                        uint32_t totalBoneWeights = 0;


                        // Bone Counts.
                        for (size_t iVertex = 0; iVertex < vertexArray->GetVertexCount(); ++iVertex)
                        {
                            uint16_t count = static_cast<uint16_t>(this->meshes[iMesh].skinningVertexAttributes[iVertex].bones.count);
                            intermediarySerializer.Write(count);

                            totalBoneWeights += count;
                        }

                            
                        // Bone/Weight Pairs.
                        intermediarySerializer.Write(totalBoneWeights);

                        for (size_t iVertex = 0; iVertex < vertexArray->GetVertexCount(); ++iVertex)
                        {
                            auto &bones = this->meshes[iMesh].skinningVertexAttributes[iVertex].bones;
                            {
                                for (size_t iBone = 0; iBone < bones.count; ++iBone)
                                {
                                    auto &bone = bones[iBone];

                                    intermediarySerializer.Write(static_cast<uint32_t>(bone.boneIndex));
                                    intermediarySerializer.Write(static_cast<float   >(bone.weight));
                                }
                            }
                        }
                    }
                }
                else
                {
                    intermediarySerializer.Write(static_cast<uint32_t>(0));
                }


                // Default uniforms.
                this->meshes[iMesh].defaultUniforms.Serialize(intermediarySerializer);
            }
        }

        header.id          = Serialization::ChunkID_Model_Meshes;
        header.version     = 1;
        header.sizeInBytes = intermediarySerializer.GetBufferSizeInBytes();
        serializer.Write(header);
        serializer.Write(intermediarySerializer.GetBuffer(), header.sizeInBytes);



        /////////////////////////////////////
        // Animation

        intermediarySerializer.Clear();
        intermediarySerializer.Write(static_cast<uint32_t>(m_animation.GetKeyFrameCount()));

        for (uint32_t iKeyFrame = 0; iKeyFrame < m_animation.GetKeyFrameCount(); ++iKeyFrame)
        {
            // Time.
            intermediarySerializer.Write(static_cast<float>(m_animation.GetKeyFrameTimeByIndex(iKeyFrame)));
            
            
            // Channels.
            intermediarySerializer.Write(static_cast<uint32_t>(this->animationChannelBones.count));

            for (size_t iChannel = 0; iChannel < this->animationChannelBones.count; ++iChannel)
            {
                auto channel = this->animationChannelBones.buffer[iChannel]->value;
                auto bone    = this->animationChannelBones.buffer[iChannel]->key;

                assert(channel != nullptr);
                assert(bone    != nullptr);
                {
                    // Bone Index.
                    size_t boneIndex;
                    this->FindBoneIndex(bone, boneIndex);

                    intermediarySerializer.Write(static_cast<uint32_t>(boneIndex));


                    // Bone Transformation.
                    glm::vec3 position;
                    glm::quat rotation;
                    glm::vec3 scale;

                    auto key = static_cast<TransformAnimationKey*>(channel->GetKey(iKeyFrame));
                    if (key != nullptr)
                    {
                        position = key->position;
                        rotation = key->rotation;
                        scale    = key->scale;
                    }
                    else
                    {
                        // We should never actually get here, but for completeness we'll just write identities.
                        position = bone->GetPosition();
                        rotation = bone->GetRotation();
                        scale    = bone->GetScale();
                    }

                    intermediarySerializer.Write(position);
                    intermediarySerializer.Write(rotation);
                    intermediarySerializer.Write(scale);
                }
            }
        }

        intermediarySerializer.Write(this->animationAABBPadding);


        header.id          = Serialization::ChunkID_Model_Animation;
        header.version     = 1;
        header.sizeInBytes = intermediarySerializer.GetBufferSizeInBytes();
        serializer.Write(header);
        serializer.Write(intermediarySerializer.GetBuffer(), header.sizeInBytes);



        /////////////////////////////////////
        // Animation Segments

        intermediarySerializer.Clear();
        intermediarySerializer.Write(static_cast<uint32_t>(m_animation.GetNamedSegmentCount()));

        for (size_t iSegment = 0; iSegment < m_animation.GetNamedSegmentCount(); ++iSegment)
        {
            auto segment = m_animation.GetNamedSegmentByIndex(iSegment);
            assert(segment != nullptr);
            {
                intermediarySerializer.WriteString(segment->name);
                intermediarySerializer.Write(static_cast<uint32_t>(segment->startKeyFrame));
                intermediarySerializer.Write(static_cast<uint32_t>(segment->endKeyFrame));
            }
        }

        header.id          = Serialization::ChunkID_Model_AnimationSegments;
        header.version     = 1;
        header.sizeInBytes = intermediarySerializer.GetBufferSizeInBytes();
        serializer.Write(header);
        serializer.Write(intermediarySerializer.GetBuffer(), header.sizeInBytes);



        /////////////////////////////////////
        // Animation Sequences

        /*
        intermediarySerializer.Clear();
        intermediarySerializer.Write(static_cast<uint32_t>(this->animationSequences.count));

        for (size_t iSequence = 0; iSequence < this->animationSequences.count; ++iSequence)
        {
        }

        header.id          = Serialization::ChunkID_Model_AnimationSequences;
        header.version     = 1;
        header.sizeInBytes = intermediarySerializer.GetBufferSizeInBytes();
        serializer.Write(header);
        serializer.Write(intermediarySerializer.GetBuffer(), header.sizeInBytes);
        */


        /////////////////////////////////////
        // Convex Hulls

        intermediarySerializer.Clear();
        intermediarySerializer.Write(static_cast<uint32_t>(m_convexHulls.count));

        Vector<uint32_t> vertexCounts(m_convexHulls.count);
        Vector<uint32_t> indexCounts( m_convexHulls.count);
        Vector<float>    vertices;
        Vector<uint32_t> indices;

        for (size_t iConvexHull = 0; iConvexHull < m_convexHulls.count; ++iConvexHull)
        {
            auto convexHull = m_convexHulls[iConvexHull];
            assert(convexHull != nullptr);
            {
                uint32_t vertexCount = static_cast<uint32_t>(convexHull->GetVertexCount());
                uint32_t indexCount  = static_cast<uint32_t>(convexHull->GetIndexCount());

                vertexCounts.PushBack(vertexCount);
                indexCounts.PushBack( indexCount);

                for (uint32_t iVertex = 0; iVertex < vertexCount; ++iVertex)
                {
                    vertices.PushBack(convexHull->GetVertices()[iVertex * 3 + 0]);
                    vertices.PushBack(convexHull->GetVertices()[iVertex * 3 + 1]);
                    vertices.PushBack(convexHull->GetVertices()[iVertex * 3 + 2]);
                }

                for (uint32_t iIndex = 0; iIndex < indexCount; ++iIndex)
                {
                    indices.PushBack(convexHull->GetIndices()[iIndex]);
                }
            }
        }

        intermediarySerializer.Write(vertexCounts.buffer, vertexCounts.count * 4);
        intermediarySerializer.Write(indexCounts.buffer,  indexCounts.count  * 4);

        intermediarySerializer.Write(static_cast<uint32_t>(vertices.count));
        intermediarySerializer.Write(static_cast<uint32_t>(indices.count));

        intermediarySerializer.Write(vertices.buffer, vertices.count * 4);
        intermediarySerializer.Write(indices.buffer,  indices.count  * 4);

        intermediarySerializer.Write(this->convexHullBuildSettings);


        header.id          = Serialization::ChunkID_Model_ConvexHulls;
        header.version     = 1;
        header.sizeInBytes = intermediarySerializer.GetBufferSizeInBytes();
        serializer.Write(header);
        serializer.Write(intermediarySerializer.GetBuffer(), header.sizeInBytes);



        /////////////////////////////////////
        // Null Chunk

        header.id          = Serialization::ChunkID_Null;
        header.version     = 1;
        header.sizeInBytes = 0;
        serializer.Write(header);
    }