ResourceId CResourceManager::loadMaterial(const std::string& file)
{
auto entry = m_materialFiles.find(file);
if (entry != m_materialFiles.end())
{
return entry->second;
}
LOG_DEBUG("Loading material from file %s.", file.c_str());
SMaterial material;
if (!load(file, *this, material))
{
LOG_ERROR("Failed to load material from file %s.", file.c_str());
return invalidResource;
}
ResourceId materialId =
createMaterial(material.m_base, material.m_normal, material.m_specular, material.m_glow, material.m_alpha);
if (materialId == invalidResource)
{
LOG_ERROR("Failed to create material resource id for material file %s.", file.c_str());
return invalidResource;
}
m_materialFiles[file] = materialId;
return materialId;
}
void initialise()
{
glClearColor(0.0f, 1.0f, 1.0f, 1.0f);
projection = glm::perspective(50.0f, 800.0f/600.0f, 0.1f, 10000.0f);
glEnable(GL_DEPTH_TEST);
glEnable(GL_VERTEX_ARRAY);
s = new shader("phong");
if (!s->shaders[0] || !s->shaders[1] || !s->program)
exit(EXIT_FAILURE);
light.ambient = glm::vec4(1.0f, 1.0f, 1.0f, 1.0f);
light.diffuse = glm::vec4(1.0f, 1.0f, 0.0f, 1.0f);
light.specular = glm::vec4(1.0f, 1.0f, 1.0f, 1.0f);
light.ambient = glm::vec4(1.0f, 1.0f, 1.0f, 1.0f);
light.diffuse = glm::vec4(1.0f, 1.0f, 1.0f, 1.0f);
light.specular = glm::vec4(1.0f, 1.0f, 1.0f, 1.0f);
light.lightDir = glm::vec4(1.0f, 0.0f, 0.0f, 1.0f);
// Create light buffer
glGenBuffers(1, &lightBuffer);
glBindBuffer(GL_UNIFORM_BUFFER, lightBuffer);
glBufferData(GL_UNIFORM_BUFFER, sizeof(lighting), &light, GL_STREAM_DRAW);
glBindBuffer(GL_UNIFORM_BUFFER, 0);
//object.geometry = createTorus(6, 500, 500);
//object.geometry = createSphere(20, 20);
//object.geometry = createPlane(10, 10);
object.geometry = createDisk(50);
glm::vec4 colour(0.5f, 0.25f, 0.15f, 1.0f);
object.material = createMaterial(colour, colour, colour, 5.0f);
object.materialBuffer = createMaterialBuffer(object.material);
object.transform.position = glm::vec3(0.0f, 0.5f, 0.0f);
}
Material::Material(optix::Context context, glm::vec3 ambient, glm::vec3 diffuse, glm::vec3 specular, glm::vec3 emissive, float shininess, float reflexive, float opacity, float refractiveIndex, GLuint tex) {
this->context = context;
createMaterial();
this->reflexive=reflexive;
this->opacity=opacity;
this->refractiveIndex=refractiveIndex;
prepareMaterial(ambient, diffuse, specular, emissive, shininess, tex);
}
Material* Scene::createMaterial(const MaterialDescription& description)
{
NxOgre::MaterialPrototype* prototype = NxOgre_New(MaterialPrototype)();
Functions::PrototypeFunctions::MaterialDescriptionToMaterialPrototype(description, prototype);
Material* material = createMaterial(prototype);
NxOgre_Delete(prototype);
return material;
}
void setUpExample()
{
Assets assets;
loadAssets(assets);
createMaterial(assets);
setUp3DScene(assets);
setUpInput();
}
Material::Material(optix::Context context, Ogre::MaterialPtr baseMaterial) {
setBaseMaterial(baseMaterial);
this->context = context;
createMaterial();
this->reflexive=0.0f;
this->opacity=1.0f;
this->refractiveIndex=1.0f;
update();
}
virtual void createLunch()
{
Material * material = createMaterial();
prepare(material);
make(material);
eat(material);
delete material;
}
std::shared_ptr< Mesh > MaterialFactory::createMesh( const char* meshXml ) {
std::shared_ptr< Mesh > mesh = std::shared_ptr< Mesh >( new Mesh() );
m_material = std::shared_ptr< GLSLMaterial >( new GLSLMaterial() );
m_doc = new tinyxml2::XMLDocument();
if( m_doc->LoadFile( meshXml ) ) {
printf("loading xml file error");
return NULL;
}
tinyxml2::XMLNode* child = m_doc->FirstChild();
const char* meshFile = child->ToElement()->Attribute( "file" );
int g_point_count = 0;
GLuint vao;
const aiScene* scene = aiImportFile (meshFile, aiProcess_Triangulate); // TRIANGLES!
if (!scene) {
fprintf (stderr, "ERROR: reading mesh %s\n", meshFile);
return false;
}
glGenVertexArrays( 1, &vao );
glBindVertexArray( vao );
mesh->setVAO( vao );
g_point_count = scene->mMeshes[0]->mNumVertices;
mesh->setSize( g_point_count );
for( tinyxml2::XMLElement* loopNode =child->FirstChildElement(); loopNode != NULL; loopNode=loopNode->NextSiblingElement() ) {
if( strcmp( loopNode->Name() , "Material" ) == 0 ) {
mesh->setMaterial( createMaterial( loopNode, scene ) );
}
}
aiReleaseImport( scene );
glBindVertexArray( 0 );
m_textureLocation = GL_TEXTURE0;
return mesh;
}
materialT* createDiffuseMaterial(vec3 ambient_color, vec3 diffuse_color) {
materialT* material = createMaterial();
material->color_fn = calcMaterialColor;
material->data = malloc(sizeof(diffuseMaterialT));
((diffuseMaterialT*)material->data)->ambient_color = ambient_color;
((diffuseMaterialT*)material->data)->diffuse_color = diffuse_color;
return (material);
}
/*! \todo move all except the default shader to config file
*/
void iMaterialResourceFactory::initDefaultMaterial()
{
_defaultID = createMaterial();
getMaterial(_defaultID)->setName("IgorDefault");
getMaterial(_defaultID)->addShaderSource("default.vert", iShaderObjectType::Vertex);
getMaterial(_defaultID)->addShaderSource("default_directional_light.frag", iShaderObjectType::Fragment);
getMaterial(_defaultID)->compileShader();
getMaterial(_defaultID)->getRenderStateSet().setRenderState(iRenderState::Texture2D0, iRenderStateValue::Off);
getMaterialGroup(_defaultID)->setOrder(iMaterial::RENDER_ORDER_DEFAULT);
// set material to start with
setMaterial(_defaultID);
}
DirectShowControl::DirectShowControl(Ogre::String name,Ogre::String filename, int width,int height,Ogre::Viewport *vp,bool overlay/*=true*/ ):isOverlay(overlay),
mName(name),mWidth(width),mHeight(height),mFilename(filename),mVp(vp)
{
mDirectshowTexture = new DirectShowMovieTexture(mWidth,mHeight,false);
mDirectshowTexture->loadMovie(mFilename);
createMaterial();
if(isOverlay)
createOverlay();
}
void EarthScene::initialise()
{
#if !defined(Q_OS_MAC)
// Create a material that performs multi-texturing
MaterialPtr material = createMaterial(
"../../../opengl/assets/textures/earth/color.png",
"../../../opengl/assets/textures/earth/specular.png",
"../../../opengl/assets/textures/earth/nightlights.png" );
#else
// Create a material that performs multi-texturing
MaterialPtr material = createMaterial(
"../../../../../../opengl/assets/textures/earth/color.png",
"../../../../../../opengl/assets/textures/earth/specular.png",
"../../../../../../opengl/assets/textures/earth/nightlights.png" );
#endif
// Create a cube and set the material on it
m_sphere = new Sphere( this );
m_sphere->setMaterial( material );
m_sphere->create();
// Enable depth testing
glEnable( GL_DEPTH_TEST );
}
bool ATOM_DOFEffect::init(ATOM_RenderDevice *device)
{
if( !ATOM_PostEffect::init(device) )
return false;
// create the material
if( !createMaterial(device) )
return false;
// create the rt
if( !createRT(device) )
return false;
return true;
}
void SpawnPoint::Initialize(const GameContext& gameContext)
{
auto physX = PhysxManager::GetInstance()->GetPhysics();
auto defaultMaterial = physX->createMaterial(0, 0, 1);
shared_ptr<PxGeometry> geom(new PxSphereGeometry(25.f));
auto col = new ColliderComponent(geom, *defaultMaterial);
col->EnableTrigger(true);
AddComponent(new RigidBodyComponent(true));
AddComponent(col);
this->SetOnTriggerCallBack([this](GameObject* trigger, GameObject* receiver, TriggerAction action)
{
if(receiver->GetName() == "Player")
{
m_PlayerInRange = !m_PlayerInRange;
}
});
}
NodeTransitPtr createBox(void)
{
// Make Object Nodes
NodeRecPtr ExampleBoxGeo = makeBox(100, 100, 100, 1, 1, 1);
MaterialRecPtr GreenMaterial = createMaterial(Color4f(0.0f,1.0f,0.0f,1.0f));
dynamic_cast<Geometry*>(ExampleBoxGeo->getCore())->setMaterial(GreenMaterial);
Matrix mat;
mat.setTranslate(250.0,250.0,0.0);
TransformRecPtr ExampleBoxTranCore = Transform::create();
ExampleBoxTranCore->setMatrix(mat);
NodeRecPtr ExampleBox = Node::create();
ExampleBox->setCore(ExampleBoxTranCore);
ExampleBox->addChild(ExampleBoxGeo);
ExampleBox->setTravMask(0);
return NodeTransitPtr(ExampleBox);
}
NodeTransitPtr createSphere(void)
{
// Make Object Nodes
NodeRecPtr ExampleSphereGeo = makeSphere(4, 100);
MaterialRecPtr RedMaterial = createMaterial(Color4f(1.0f,0.0f,0.0f,1.0f));
dynamic_cast<Geometry*>(ExampleSphereGeo->getCore())->setMaterial(RedMaterial);
Matrix mat;
mat.setTranslate(250.0,0.0,0.0);
TransformRecPtr SphereTranCore = Transform::create();
SphereTranCore->setMatrix(mat);
NodeRecPtr ExampleSphere = Node::create();
ExampleSphere->setCore(SphereTranCore);
ExampleSphere->addChild(ExampleSphereGeo);
ExampleSphere->setTravMask(0);
return NodeTransitPtr(ExampleSphere);
}
void EnemyIceBear::Initialize(const GameContext& gameContext)
{
UNREFERENCED_PARAMETER(gameContext);
m_CurrentHealth = 100.0f;
// ADD MODEL
auto physX = PhysxManager::GetInstance()->GetPhysics();
m_pIceBearModel = new GameObject();
auto iceBearModelComponent = new ModelComponent(L"./Resources/Meshes/IceBear.ovm");
iceBearModelComponent->SetMaterial(3);
m_pIceBearModel->AddComponent(iceBearModelComponent);
auto rigidbody = new RigidBodyComponent();
rigidbody->SetKinematic(true);
m_pIceBearModel->AddComponent(rigidbody);
auto defaultMaterial = physX->createMaterial(0.5f, 0.5f, 0.1f);
auto iceBearMesh = ContentManager::Load<PxConvexMesh>(L"./Resources/Meshes/IceBear.ovpc");
shared_ptr<PxGeometry> bearGeo(new PxConvexMeshGeometry(iceBearMesh));
auto IceBearCollider = new ColliderComponent(bearGeo, *defaultMaterial);
m_pIceBearModel->AddComponent(IceBearCollider);
AddChild(m_pIceBearModel);
m_pIceBearModel->GetTransform()->Translate(m_Position);
m_pHealthBarInside = new GameObject();
m_pHealthBarInside->AddComponent(new SpriteComponent(L"./Resources/Textures/IceBear_healthbar_green.png", XMFLOAT2(0.f, 0.5f), XMFLOAT4(1, 1, 1, 1.0f)));
AddChild(m_pHealthBarInside);
m_pHealthBarFrame = new GameObject();
m_pHealthBarFrame->AddComponent(new SpriteComponent(L"./Resources/Textures/IceBear_healthbar_empty.png", XMFLOAT2(0.5f, 0.5f), XMFLOAT4(1, 1, 1, 1.0f)));
AddChild(m_pHealthBarFrame);
}
NodeTransitPtr createCone(void)
{
// Make Object Nodes
NodeRecPtr ExampleConeGeo = makeCone(150, 50, 16, true, true);
MaterialRecPtr BlueMaterial = createMaterial(Color4f(0.0f,0.0f,1.0f,1.0f));
dynamic_cast<Geometry*>(ExampleConeGeo->getCore())->setMaterial(BlueMaterial);
// Preform transformations on them
Matrix mat;
// On Cone
mat.setTranslate(0.0,0.0,-250.0);
TransformRecPtr ConeTranCore = Transform::create();
ConeTranCore->setMatrix(mat);
NodeRecPtr ExampleCone = Node::create();
ExampleCone->setCore(ConeTranCore);
ExampleCone->addChild(ExampleConeGeo);
ExampleCone->setTravMask(0);
return NodeTransitPtr(ExampleCone);
}
Scene SDFLoader::loadScene(std::string const& filePath)
{
//std::cout << "loadScene: " << filePath << std::endl;
std::ifstream file;
std::string text;
Scene scene;
file.open(filePath, std::ios::in);
//std::cout << "loadScene (openFile): " << filePath << std::endl;
while(!file.eof())
{
std::getline(file, text);
std::istringstream textStream{text};
std::string word;
textStream >> word;
////std::cout << "Word:" << word << "\n";
//std::cout << "loadScene (start): " << filePath << "Word:" << word << std::endl;
if(word == "camera")
{
////std::cout << "Is Camera \n";
auto tmpCamera = createCamera(textStream);
_cameras.insert(std::make_pair(tmpCamera.name(),tmpCamera));
}
if(word == "render")
{
////std::cout << "Is Render \n";
setRenderData(textStream,scene);
}
//std::cout << "loadScene (preDefine): " << filePath << "Word:" << word << std::endl;
if(word == "define")
{
//std::cout << "loadScene (Define): " << filePath << std::endl;
////std::cout << "Is Define \n";
textStream >> word;
//std::cout << "loadScene (preLight): " << filePath << std::endl;
if(word == "light")
{
//std::cout << "loadScene (Light): " << filePath << std::endl;
////std::cout << "Is Light \n";
auto tmpLight = createLight(textStream);
scene._lights.insert(std::make_pair(tmpLight.name(),tmpLight));
}
//std::cout << "loadScene (preMaterial): " << filePath << std::endl;
if(word == "material")
{
//std::cout << "loadScene (Material): " << filePath << std::endl;
////std::cout << "Is Material \n";
auto tmpMaterial = createMaterial(textStream);
_materials.insert(std::make_pair(tmpMaterial.name(),tmpMaterial));
}
//std::cout << "loadScene (preShape): " << filePath << std::endl;
if (word == "shape")
{
//std::cout << "loadScene (Shape): " << filePath << std::endl;
////std::cout << "Is Shape \n";
textStream >> word;
if(word == "sphere")
{
////std::cout << "Is Sphere \n";
auto tmpSphere = createSphere(textStream);
scene._shapes.insert(std::make_pair(tmpSphere->name(),tmpSphere));
}
if(word == "box")
{
////std::cout << "Is Box \n";
auto tmpBox = createBox(textStream);
scene._shapes.insert(std::make_pair(tmpBox->name(),tmpBox));
}
if(word == "composite")
{
////std::cout << "Is Compsite \n";
auto tmpShapeComposite = createShapeComposite(textStream,scene._shapes);
scene._shapes.insert(std::make_pair(tmpShapeComposite->name(),tmpShapeComposite));
}
}
}
// -------------------------------------------------------------------
// Loads the material description
void ObjFileMtlImporter::load()
{
if ( m_DataIt == m_DataItEnd )
return;
while ( m_DataIt != m_DataItEnd )
{
switch (*m_DataIt)
{
case 'K':
{
++m_DataIt;
if (*m_DataIt == 'a') // Ambient color
{
++m_DataIt;
getColorRGBA( &m_pModel->m_pCurrentMaterial->ambient );
}
else if (*m_DataIt == 'd') // Diffuse color
{
++m_DataIt;
getColorRGBA( &m_pModel->m_pCurrentMaterial->diffuse );
}
else if (*m_DataIt == 's')
{
++m_DataIt;
getColorRGBA( &m_pModel->m_pCurrentMaterial->specular );
}
m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine );
}
break;
case 'd': // Alpha value
{
++m_DataIt;
getFloatValue( m_pModel->m_pCurrentMaterial->alpha );
m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine );
}
break;
case 'N': // Shineness
{
++m_DataIt;
switch(*m_DataIt)
{
case 's':
++m_DataIt;
getFloatValue(m_pModel->m_pCurrentMaterial->shineness);
break;
case 'i': //Index Of refraction
++m_DataIt;
getFloatValue(m_pModel->m_pCurrentMaterial->ior);
break;
}
m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine );
break;
}
break;
case 'm': // Texture
case 'b': // quick'n'dirty - for 'bump' sections
{
getTexture();
m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine );
}
break;
case 'n': // New material name
{
createMaterial();
m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine );
}
break;
case 'i': // Illumination model
{
m_DataIt = getNextToken<DataArrayIt>(m_DataIt, m_DataItEnd);
getIlluminationModel( m_pModel->m_pCurrentMaterial->illumination_model );
m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine );
}
break;
default:
{
m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine );
}
break;
}
}
}
ResourceId CResourceManager::loadMaterial(const std::string& file)
{
auto entry = m_materialFiles.find(file);
if (entry != m_materialFiles.end())
{
return entry->second;
}
LOG_DEBUG("Loading material from file %s.", file.c_str());
CIniFile ini;
if (!ini.load(file))
{
LOG_ERROR("Failed to load material file %s as ini file.", file.c_str());
return -1;
}
ResourceId diffuseId = -1;
if (ini.hasKey("diffuse", "file"))
{
// Diffuse texture is RGB format, ignore alpha
diffuseId = loadImage(ini.getValue("diffuse", "file", "error"), EColorFormat::RGB24);
if (diffuseId == -1)
{
LOG_ERROR("Failed to load diffuse texture specified in material file %s.",
file.c_str());
return -1;
}
}
ResourceId normalId = -1;
if (ini.hasKey("normal", "file"))
{
// Normal texture is RGB format
normalId = loadImage(ini.getValue("normal", "file", "error"), EColorFormat::RGB24);
if (normalId == -1)
{
LOG_ERROR("Failed to load normal texture specified in material file %s.", file.c_str());
return -1;
}
}
ResourceId specularId = -1;
if (ini.hasKey("specular", "file"))
{
// Specular texture is grey-scale format
specularId = loadImage(ini.getValue("specular", "file", "error"), EColorFormat::GreyScale8);
if (specularId == -1)
{
LOG_ERROR("Failed to load specular texture specified in material file %s.",
file.c_str());
return -1;
}
}
ResourceId glowId = -1;
if (ini.hasKey("glow", "file"))
{
// Glow texture is grey-scale format
glowId = loadImage(ini.getValue("glow", "file", "error"), EColorFormat::GreyScale8);
if (glowId == -1)
{
LOG_ERROR("Failed to load glow texture specified in material file %s.", file.c_str());
return -1;
}
}
ResourceId alphaId = -1;
if (ini.hasKey("alpha", "file"))
{
// Alpha texture is grey-scale format
alphaId = loadImage(ini.getValue("alpha", "file", "error"), EColorFormat::GreyScale8);
if (alphaId == -1)
{
LOG_ERROR("Failed to load alpha texture specified in material file %s.", file.c_str());
return -1;
}
}
ResourceId customShaderId = -1;
if (ini.hasKey("shader", "file"))
{
// Has custom shader file specified
customShaderId = loadShader(ini.getValue("shader", "file", "error"));
if (customShaderId == -1)
{
LOG_ERROR("Failed to load custom shader file specified in material file %s.",
file.c_str());
return -1;
}
}
ResourceId materialId =
createMaterial(diffuseId, normalId, specularId, glowId, alphaId, customShaderId);
if (materialId == -1)
{
LOG_ERROR("Failed to create material resource id for material file %s.", file.c_str());
return -1;
}
m_materialFiles[file] = materialId;
return materialId;
}
int main(int argc, char* argv[]){
// domain variables
int iter = 0;
int i;
int file_index;
int max_iter;
double max_time = 1.0;
double dt = .0000001;
double domain_box[4] = {0.0, 0.0, 1.0, 2.0};
double domain_m_box[4] = {.10, 0.2, 0.90, 2.00};
int domain_num_cells[2] = {10, 20};
int pp_cell[2] = {2,2};
double ipart_dim[2];
int domain_num_particles[2];
double test_px, test_py;
char p_filename[40];
char p_filename2[40];
char g_filename[40];
//timing variables
double start_time;
double end_time;
// patch variables
int rank = 0;
int size;
int num_proc[2];
double box[4];
double m_box[4];
int num_cells[2];
int halo_cells[4] = {1,1,1,1};
int num_particles[2];
int sfactor = 2;
GridData grid_data;
Node** grid;
InitialParticleData ipart_data;
Particle* particles;
Particle* post_particles;
Particle* particle_list;
Particle* rhalo_parts[8];
Particle* shalo_parts[8];
MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &size);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Request halo_req[8][2];
MPI_Status halo_stat[8][2];
max_iter = (int)(max_time/dt);
if(rank == 0){
if(argc == 3){
num_proc[0] = atoi(argv[1]);
num_proc[1] = atoi(argv[2]);
}else if(argc == 6){
num_proc[0] = atoi(argv[1]);
num_proc[1] = atoi(argv[2]);
domain_num_cells[0] = atoi(argv[3]);
domain_num_cells[1] = atoi(argv[4]);
max_iter = atoi(argv[5]);
}
}
MPI_Bcast(num_proc, 2, MPI_INT, 0, MPI_COMM_WORLD);
MPI_Bcast(domain_num_cells, 2, MPI_INT, 0, MPI_COMM_WORLD);
MPI_Bcast(&max_iter, 1, MPI_INT, 0, MPI_COMM_WORLD);
MPI_Barrier(MPI_COMM_WORLD);
grid_data.gravity[0] = 0;
grid_data.gravity[1] = -900.8;
grid_data.cell_dim[0] = (domain_box[2] - domain_box[0])/domain_num_cells[0];
grid_data.cell_dim[1] = (domain_box[3] - domain_box[1])/domain_num_cells[1];
test_px = grid_data.cell_dim[0]/pp_cell[0];
test_py = grid_data.cell_dim[1]/pp_cell[1];
domain_num_particles[0] = (int)((domain_m_box[2] - domain_m_box[0])/test_px);
domain_num_particles[1] = (int)((domain_m_box[3] - domain_m_box[1])/test_py);
ipart_dim[0] = (domain_m_box[2] - domain_m_box[0])/domain_num_particles[0];
ipart_dim[1] = (domain_m_box[3] - domain_m_box[1])/domain_num_particles[1];
decomposeGrid(rank, num_proc, domain_num_cells, num_cells, domain_box, box, halo_cells, &grid_data);
decomposeMaterial(box, domain_m_box, m_box, ipart_dim, num_particles);
ipart_data.density = 1000;
ipart_data.bulk = 3;
ipart_data.shear = 4;
ipart_data.E = 90000;
ipart_data.poisson = .30;
ipart_data.idim[0] = ipart_dim[0];
ipart_data.idim[1] = ipart_dim[1];
ipart_data.velocity[0] = 0;
ipart_data.velocity[1] = 0;
ipart_data.box[0] = m_box[0];
ipart_data.box[1] = m_box[1];
ipart_data.box[2] = m_box[2];
ipart_data.box[3] = m_box[3];
ipart_data.num_particles[0] = num_particles[0];
ipart_data.num_particles[1] = num_particles[1];
ipart_data.domain_num_particles[0] = domain_num_particles[0];
ipart_data.domain_num_particles[1] = domain_num_particles[1];
grid = createGrid(&grid_data, box, num_cells);
particles = createMaterial(&grid_data, &ipart_data);
post_particles = createMaterial(&grid_data, &ipart_data);
initializeGrid(&grid_data, grid);
initializeMaterial(&grid_data, &ipart_data, particles);
//allocate halo particles
allocateHaloParticles(&grid_data, sfactor, pp_cell, rhalo_parts, shalo_parts);
file_index = 0;
start_time = MPI_Wtime();
for(iter = 0; iter <= max_iter; iter++){
gatherHaloParticles(&grid_data, particles, rhalo_parts, shalo_parts);
sendRecvParticles(&grid_data, rhalo_parts, shalo_parts);
clearGridValues(&grid_data, grid);
mapToGrid(&grid_data, grid, particles);
for(i = 0; i < 8; i++){
if(grid_data.rank[i] >= 0 && rhalo_parts[i][0].particle_count > 0){
mapToGrid(&grid_data, grid, rhalo_parts[i]);
}
}
momentumToVelocityOnGrid(&grid_data, grid);
computeForces(&grid_data, grid, particles);
for(i = 0; i < 8; i++){
if(grid_data.rank[i] >= 0 && rhalo_parts[i][0].particle_count > 0){
computeForces(&grid_data, grid, rhalo_parts[i]);
}
}
computeAcceleration(&grid_data, grid);
/**
particle_list = gatherParticles(rank, size, domain_num_particles[0] * domain_num_particles[1],
particles, post_particles);
if(rank == 0){
//if(iter%100 == 0){
sprintf(p_filename, "ppart%06d.vtk", file_index);
//sprintf(p_filename2, "center%06d.vtk", file_index);
//sprintf(g_filename, "grid_output%06d.vtk", file_index);
//writeParticlesVtkFile(&grid_data, grid, rhalo_parts[0], p_filename);
writeParticlesVtkFile(&grid_data, grid, particle_list, p_filename);
//writeParticlesVtkFile(&grid_data, grid, particle_list, p_filename);
//writeParticlesVtkFile(&grid_data, grid, particles, p_filename);
//writeGridVtkFile(&grid_data, grid, g_filename);
//writeGridVtkFile(&grid_data, grid, g_filename);
//free(particle_list);
file_index++;
//}
}
**/
updateNodalValues(&grid_data, grid, dt);
updateStressAndStrain(&grid_data, grid, particles, dt);
pUpdateParticlePosition(&grid_data, grid, particles, post_particles, shalo_parts, dt);
sendRecvParticles(&grid_data, rhalo_parts, shalo_parts);
updateParticleList(&grid_data, particles, rhalo_parts);
/**
particle_list = gatherParticles(rank, size, domain_num_particles[0] * domain_num_particles[1],
particles, post_particles);
if(rank == 0){
sprintf(p_filename, "particle_output%06d.vtk", file_index);
file_index++;
//sprintf(g_filename, "grid_output%06d.vtk", file_index);
writeParticlesVtkFile(&grid_data, grid, particles, p_filename);
//writeParticlesVtkFile(&grid_data, grid, particle_list, p_filename);
//writeParticlesVtkFile(&grid_data, grid, particles, p_filename);
//writeGridVtkFile(&grid_data, grid, g_filename);
free(particle_list);
}
**/
MPI_Barrier(MPI_COMM_WORLD);
}
end_time = MPI_Wtime();
MPI_Barrier(MPI_COMM_WORLD);
//particle_list = gatherParticles(rank, size, domain_num_particles[0] * domain_num_particles[1],
// particles, post_particles);
if(rank == 0){
printf("Parallel, np: %d, iterations: %d, time: %f\n", size, max_iter, end_time-start_time);
//writeParticlesVtkFile(&grid_data, grid, particle_list, "pparts.vtk");
//free(particle_list);
}
freeGrid(grid, &grid_data);
freeMaterial(particles);
freeMaterial(post_particles);
freeHaloParticles(&grid_data, rhalo_parts, shalo_parts);
//MPI_Barrier(MPI_COMM_WORLD);
MPI_Finalize();
return 0;
}
void AssetLoader::readModel(Ogre::SceneManager* sceneMgr, Ogre::SceneNode* scnNode, const aiScene* scene, aiNode* nd)
{
for (size_t n = 0; n < nd->mNumChildren; n++)
{
aiNode* cnd = nd->mChildren[n];
Ogre::SceneNode* cnode = createChildSceneNodeWithTransform(scnNode, cnd);
for (size_t i = 0; i < cnd->mNumMeshes; i++) {
aiMesh* m = scene->mMeshes[cnd->mMeshes[i]];
aiMaterial* mat = scene->mMaterials[m->mMaterialIndex];
std::string nodeName = getFullPathName(cnd);
Ogre::MaterialPtr omat = createMaterial(Ogre::String(nodeName), m->mMaterialIndex, mat);
aiVector3D* vec = m->mVertices;
aiVector3D* norm = m->mNormals;
aiVector3D* uv = m->mTextureCoords[0];
aiColor4D* vcol = NULL;
if (m->HasVertexColors(0)) vcol = m->mColors[0];
// 頂点情報の読み込み
Ogre::AxisAlignedBox aab;
Ogre::ManualObject* mobj = new Ogre::ManualObject(nodeName+"_MObj");
mobj->begin(omat->getName());
//mobj->begin("Ogre/Skin");
for (size_t n = 0; n < m->mNumVertices; n ++) {
Ogre::Vector3 position(vec->x, vec->y, vec->z);
aab.merge(position);
mobj->position(vec->x, vec->y, vec->z);
vec++;
mobj->normal(norm->x, norm->y, norm->z);
norm++;
if (uv) {
mobj->textureCoord(uv->x, uv->y);
uv++;
}
if (vcol) {
mobj->colour(vcol->r, vcol->g, vcol->b, vcol->a);
vcol++;
}
}
// ポリゴンの構築
for (size_t n = 0; n < m->mNumFaces; n++) {
aiFace* face = &m->mFaces[n];
for (size_t k = 0; k < face->mNumIndices; k++) {
mobj->index(face->mIndices[k]);
}
}
mobj->end();
mobj->setBoundingBox(aab);
Ogre::String meshName(nodeName+"_Mesh");
mobj->convertToMesh(meshName);
delete mobj;
Ogre::String entityName(nodeName+"_Entity");
std::cout << "entity: " << entityName << std::endl;
Ogre::Entity* ent = sceneMgr->createEntity(entityName, meshName);
cnode->attachObject(ent);
}
readModel(sceneMgr, cnode, scene, cnd);
}
}
void iPhysics::createDefaultMaterial()
{
iPhysicsMaterial* material = createMaterial("default");
_defaultMaterialID = material->getID();
}
Scene createScene(char* filename){
Scene scene = {};
scene.max_depth = 10;
scene.num_samples = 100;
scene.image = createImage(500, 500);
Vector position = {278, 273, -800};
Vector look_at = {278, 273, 0};
Vector up = {0, 1, 0};
scene.camera = createCamera(position, look_at, up, 39, (float)(scene.image.width/scene.image.height));
scene.num_materials = 4;
scene.materials = malloc(scene.num_materials * sizeof(Material));
scene.materials[0] = createMaterial(createColor(.95, .25, .25), .6, .4, false);
scene.materials[1] = createMaterial(createColor(.25, .95, .25), .6, .4, false);
scene.materials[2] = createMaterial(createColor(.95, .95, .85), .6, .4, false);
scene.materials[3] = createMaterial(createColor(.9, .9, .9), .6, .4, true);
scene.num_triangles = 32;
scene.triangles = malloc(scene.num_triangles * sizeof(Triangle));
// Right Wall
scene.triangles[0] = createTriangle(&scene.materials[1], createVector(0.0, 0.0, 559.2), createVector(0.0, 0.0, 0.0), createVector(0.0, 548.8, 0.0));
scene.triangles[1] = createTriangle(&scene.materials[1], createVector(0.0, 0.0, 559.2), createVector(0.0, 548.8, 0.0), createVector(0.0, 548.8, 559.2));
// Floor
scene.triangles[2] = createTriangle(&scene.materials[2], createVector(556.0, 0.0, 0.0), createVector(0.0, 0.0, 0.0), createVector(0.0, 0.0, 559.2));
scene.triangles[3] = createTriangle(&scene.materials[2], createVector(556.0, 0.0, 0.0), createVector(0.0, 0.0, 559.2), createVector(556.0, 0.0, 559.2));
// Left Wall
scene.triangles[4] = createTriangle(&scene.materials[0], createVector(556.0, 0.0, 0.0), createVector(556.0, 0.0, 559.2), createVector(556.0, 548.8, 559.2));
scene.triangles[5] = createTriangle(&scene.materials[0], createVector(556.0, 0.0, 0.0), createVector(556.0, 548.8, 559.2), createVector(556.0, 548.8, 0.0));
// Ceiling
scene.triangles[6] = createTriangle(&scene.materials[2], createVector(556.0, 548.8, 0.0), createVector(0.0, 548.8, 559.2), createVector(0.0, 548.8, 0.0));
scene.triangles[7] = createTriangle(&scene.materials[2], createVector(556.0, 548.8, 0.0), createVector(556.0, 548.8, 559.2), createVector(0.0, 548.8, 559.2));
// Backwall
scene.triangles[8] = createTriangle(&scene.materials[2], createVector(556.0, 0.0, 559.2), createVector(0.0, 0.0, 559.2), createVector(0.0, 548.8, 559.2));
scene.triangles[9] = createTriangle(&scene.materials[2], createVector(556.0, 0.0, 559.2), createVector(0.0, 548.8, 559.2), createVector(556.0, 548.8, 559.2));
// Short Block
scene.triangles[10] = createTriangle(&scene.materials[2], createVector(130.0, 165.0, 65.0), createVector(82.0, 165.0, 225.0), createVector(240.0, 165.0, 272.0));
scene.triangles[11] = createTriangle(&scene.materials[2], createVector(130.0, 165.0, 65.0), createVector(240.0, 165.0, 272.0), createVector(290.0, 165.0, 114.0));
scene.triangles[12] = createTriangle(&scene.materials[2], createVector(290.0, 0.0, 114.0), createVector(290.0, 165.0, 114.0), createVector(240.0, 165.0, 272.0));
scene.triangles[13] = createTriangle(&scene.materials[2], createVector(290.0, 0.0, 114.0), createVector(240.0, 165.0, 272.0), createVector(240.0, 0.0, 272.0));
scene.triangles[14] = createTriangle(&scene.materials[2], createVector(130.0, 0.0, 65.0), createVector(130.0, 165.0, 65.0), createVector(290.0, 165.0, 114.0));
scene.triangles[15] = createTriangle(&scene.materials[2], createVector(130.0, 0.0, 65.0), createVector(290.0, 165.0, 114.0), createVector(290.0, 0.0, 114.0));
scene.triangles[16] = createTriangle(&scene.materials[2], createVector(82.0, 0.0, 225.0), createVector(82.0, 165.0, 225.0), createVector(130.0, 165.0, 65.0));
scene.triangles[17] = createTriangle(&scene.materials[2], createVector(82.0, 0.0, 225.0), createVector(130.0, 165.0, 65.0), createVector(130.0, 0.0, 65.0));
scene.triangles[18] = createTriangle(&scene.materials[2], createVector(240.0, 0.0, 272.0), createVector(240.0, 165.0, 272.0), createVector(82.0, 165.0, 225.0));
scene.triangles[19] = createTriangle(&scene.materials[2], createVector(240.0, 0.0, 272.0), createVector(82.0, 165.0, 225.0), createVector(82.0, 0.0, 225.0));
// Tall Block
scene.triangles[20] = createTriangle(&scene.materials[2], createVector(423.0, 330.0, 247.0), createVector(265.0, 330.0, 296.0), createVector(314.0, 330.0, 456.0));
scene.triangles[21] = createTriangle(&scene.materials[2], createVector(423.0, 330.0, 247.0), createVector(314.0, 330.0, 456.0), createVector(472.0, 330.0, 406.0));
scene.triangles[22] = createTriangle(&scene.materials[2], createVector(423.0, 0.0, 247.0), createVector(423.0, 330.0, 247.0), createVector(472.0, 330.0, 406.0));
scene.triangles[23] = createTriangle(&scene.materials[2], createVector(423.0, 0.0, 247.0), createVector(472.0, 330.0, 406.0), createVector(472.0, 0.0, 406.0));
scene.triangles[24] = createTriangle(&scene.materials[2], createVector(472.0, 0.0, 406.0), createVector(472.0, 330.0, 406.0), createVector(314.0, 330.0, 456.0));
scene.triangles[25] = createTriangle(&scene.materials[2], createVector(472.0, 0.0, 406.0), createVector(314.0, 330.0, 456.0), createVector(314.0, 0.0, 456.0));
scene.triangles[26] = createTriangle(&scene.materials[2], createVector(314.0, 0.0, 456.0), createVector(314.0, 330.0, 456.0), createVector(265.0, 330.0, 296.0));
scene.triangles[27] = createTriangle(&scene.materials[2], createVector(314.0, 0.0, 456.0), createVector(265.0, 330.0, 296.0), createVector(265.0, 0.0, 296.0));
scene.triangles[28] = createTriangle(&scene.materials[2], createVector(265.0, 0.0, 296.0), createVector(265.0, 330.0, 296.0), createVector(423.0, 330.0, 247.0));
scene.triangles[29] = createTriangle(&scene.materials[2], createVector(265.0, 0.0, 296.0), createVector(423.0, 330.0, 247.0), createVector(423.0, 0.0, 247.0));
// Area Light
scene.triangles[30] = createTriangle(&scene.materials[3], createVector(343.0, 548.7, 227.0), createVector(343.0, 548.7, 332.0), createVector(213.0, 548.7, 332.0));
scene.triangles[31] = createTriangle(&scene.materials[3], createVector(343.0, 548.7, 227.0), createVector(213.0, 548.7, 332.0), createVector(213.0, 548.7, 227.0));
scene.num_lights = 2;
scene.lights = malloc(scene.num_lights * sizeof(Triangle));
scene.lights[0] = createTriangle(&scene.materials[3], createVector(343.0, 548.7, 227.0), createVector(343.0, 548.7, 332.0), createVector(213.0, 548.7, 332.0));
scene.lights[1] = createTriangle(&scene.materials[3], createVector(343.0, 548.7, 227.0), createVector(213.0, 548.7, 332.0), createVector(213.0, 548.7, 227.0));
return scene;
}
bool PersonShape::changeMaterial(const PersonShape::Type type)
{
if (!entity_ )
{
ROS_ERROR_STREAM("entity is null in changeMaterial");
return false;
}
ROS_DEBUG_STREAM("Changing material ");
switch (type)
{
case FACE:
createMaterial("textures/face_neutral.png");
break;
case BODY:
createMaterial("default");
break;
case GENDER_MALE:
createMaterial("textures/person_gender_male.png");
break;
case GENDER_FEMALE:
createMaterial("textures/person_gender_female.png");
break;
case VALENCE_LOWEST:
createMaterial("textures/valence_lowest.png");
break;
case VALENCE_LOW:
createMaterial("textures/valence_low.png");
break;
case VALENCE_NEUTRAL:
createMaterial("textures/valence_neutral.png");
break;
case VALENCE_HIGH:
createMaterial("textures/valence_high.png");
break;
case VALENCE_HIGHEST:
createMaterial("textures/valence_highest.png");
break;
case ATTENTION_ABSENT:
createMaterial("textures/attention_absent.png");
break;
case ATTENTION_FOCUSED:
createMaterial("textures/attention_focused.png");
break;
case ATTENTION_INATENTIVE:
createMaterial("textures/attention_inatentive.png");
break;
}
entity_->setMaterial(material_);
}
void ModelTestScene::Initialize(const GameContext& gameContext)
{
UNREFERENCED_PARAMETER(gameContext);
//GROUND PLANE
//************
auto physX = PhysxManager::GetInstance()->GetPhysics();
auto bouncyMaterial = physX->createMaterial(0, 0, 1);
auto ground = new GameObject();
ground->AddComponent(new RigidBodyComponent(true));
std::shared_ptr<PxGeometry> geom(new PxPlaneGeometry());
ground->AddComponent(new ColliderComponent(geom, *bouncyMaterial, PxTransform(PxQuat(XM_PIDIV2, PxVec3(0, 0, 1)))));
AddChild(ground);
//CHAIR OBJECT
//************
m_pChair = new GameObject();
//1. Attach a modelcomponent (chair.ovm)
auto chairModelComponent = new ModelComponent(L"./Resources/Meshes/chair.ovm");
m_pChair->AddComponent(chairModelComponent);
//2. Create a ColorMaterial and add it to the material manager
auto chairColorMaterial = new ColorMaterial();
gameContext.pMaterialManager->AddMaterial(chairColorMaterial, 102);
//3. Assign the material to the previous created modelcomponent
m_pChair->GetComponent<ModelComponent>()->SetMaterial(102);
// Build and Run
//4. Create a DiffuseMaterial (using PosNormTex3D.fx)
// Make sure you are able to set a texture (DiffuseMaterial::SetDiffuseTexture(const wstring& assetFile))
// Load the correct shadervariable and set it during the material variable update
auto chairDiffuseMaterial = new DiffuseMaterial();
chairDiffuseMaterial->SetDiffuseTexture(L"./Resources/Textures/Chair_Dark.dds");
gameContext.pMaterialManager->AddMaterial(chairDiffuseMaterial, 104);
//5. Assign the material to the modelcomponent
m_pChair->GetComponent<ModelComponent>()->SetMaterial(104);
// Build and Run
//6. Attach a rigidbody component (pure-dynamic)
auto chairRigidbody = new RigidBodyComponent();
m_pChair->AddComponent(chairRigidbody);
//7. Attach a collider component (Use a PxConvexMeshGeometry [chair.ovpc])
auto defaultMaterial = physX->createMaterial(0.5f, 0.5f, 0.1f);
auto chairMesh = ContentManager::Load<PxConvexMesh>(L"./Resources/Meshes/chair.ovpc");
shared_ptr<PxGeometry> chairGeo(new PxConvexMeshGeometry(chairMesh));
auto chairCollider = new ColliderComponent(chairGeo, *defaultMaterial);
m_pChair->AddComponent(chairCollider);
AddChild(m_pChair);
chairRigidbody->SetDensity(300);
m_pChair->GetTransform()->Translate(0, 10, 0);
// Build and Run
}
