Material Material::cloneMe()
{
String name = mMaterial->getName();
unsigned int i = 0;
Ogre::MaterialPtr ptr = Ogre::MaterialManager::getSingletonPtr()->getByName(name+StringUtils::toString(i));
while(ptr.getPointer())
{
++i;// keep going until we get a unique name
ptr = Ogre::MaterialManager::getSingletonPtr()->getByName(name+StringUtils::toString(i));
}
Ogre::MaterialPtr newptr = mMaterial->clone(name+StringUtils::toString(i));
return Material(newptr.getPointer());
}
SoftBody::Material * SoftBody::PushMaterial()
{
PhysicsFn->SelectMemory( TEXT("SoftBodies") );
Material * pMaterial = New Material();
PhysicsFn->UnSelectMemory();
pMaterial->fLinearStiffness = 0.0f;
pMaterial->fAngularStiffness = 0.0f;
pMaterial->fAreaStiffness = 0.0f;
pMaterial->fVolumeStiffness = 0.0f;
pMaterial->dwFlags = 0;
m_arrMaterials.Push( pMaterial );
return pMaterial;
}
Material AasRenderer::CreateGeometryShadowMaterial(gfx::RenderingDevice &device)
{
BlendState blendState;
blendState.blendEnable = true;
blendState.srcBlend = D3DBLEND_SRCALPHA;
blendState.destBlend = D3DBLEND_INVSRCALPHA;
RasterizerState rasterizerState;
rasterizerState.cullMode = D3DCULL_NONE;
DepthStencilState depthStencilState;
depthStencilState.depthWrite = false;
auto vs{ device.GetShaders().LoadVertexShader("shadow_geom_vs") };
auto ps{ device.GetShaders().LoadPixelShader("diffuse_only_ps") };
return Material(blendState, depthStencilState, rasterizerState, {}, vs, ps);
}
ParserResult MaterialSymbol::ParseLine(const std::vector<std::string>& aParameters, Scene& aOutput){
if(aParameters.size() != 6){
return kParseMalformedLine;
}
double se, diffuse, specular, shininess, reflectivity;
REQUIRE_PARSE_SUCCESS(Misc::GetDouble(aParameters[1], &se));
REQUIRE_PARSE_SUCCESS(Misc::GetDouble(aParameters[2], &diffuse));
REQUIRE_PARSE_SUCCESS(Misc::GetDouble(aParameters[3], &specular));
REQUIRE_PARSE_SUCCESS(Misc::GetDouble(aParameters[4], &shininess));
REQUIRE_PARSE_SUCCESS(Misc::GetDouble(aParameters[5], &reflectivity));
aOutput.mMaterials.push_back(Material(se, diffuse, specular, shininess, reflectivity));
return kParseSuccess;
}
Material SceneSettingReader::readMaterial()
{
settings_.beginGroup("material");
settings_.beginGroup("diffuse");
const Color diffuse = readColor();
settings_.endGroup();
settings_.beginGroup("specular");
const Color specular = readColor();
settings_.endGroup();
settings_.beginGroup("ambient");
const Color ambient = readColor();
settings_.endGroup();
const double shininess = settings_.value("shininess").toDouble();
settings_.endGroup();
return Material(specular, diffuse, ambient, shininess);
}
void MainMenu::init(Game* game)
{
// Important to set the game for changeState() to work!
setGame(game);
// Create the menu.
mMenu = new Menu("MainMenu", NavigationType::MOUSE, HOR);
mMenu->setSize(880, 700, 256, 512);
mMenu->addMenuItem(new MenuItem("SelectLevel", "data/imgs/buttons/play_standard.png", "data/imgs/buttons/play_glow.png"));
mMenu->addMenuItem(new MenuItem("About", "data/imgs/buttons/about_standard.png", "data/imgs/buttons/about_glow.png"));
mMenu->addMenuItem(new MenuItem("Quit", "data/imgs/buttons/quit_standard.png", "data/imgs/buttons/quit_glow.png"));
mMenu->buildMenu(116*1.5, 50*1.5);
mMenu->connect(&MainMenu::menuMessage, this);
// Side menu.
mAboutMenu = new Menu("SideMenu", NavigationType::MOUSE, HOR);
mAboutMenu->setSize(1000, 700, 256, 512);
MenuItem* item = new MenuItem("Back", "data/imgs/buttons/back_standard.png", "data/imgs/buttons/back_glow.png");
mAboutMenu->addMenuItem(item);
mAboutMenu->buildMenu(116*1.5, 50*1.5);
mAboutMenu->connect(&MainMenu::menuMessage, this);
// Create the world.
mWorld = new World();
mLight = new Light(D3DXVECTOR3(0, 25, 0), D3DXVECTOR3(0, -1, 0), Material(WHITE, 0), 32, 1600.0f);
mWorld->addLight(mLight);
mWorld->addAmbientLight(D3DCOLOR_ARGB(200, 100, 100, 100));
mLogo = gGraphics->loadTexture("data/imgs/logo.png");
mAboutTexture = gGraphics->loadTexture("data/imgs/about.png");
// Set the graphics light list.
gGraphics->setLightList(mWorld->getLights());
// Setup the camera.
gCamera->setPosition(D3DXVECTOR3(0, 5000, 0));
gCamera->setDirection(D3DXVECTOR3(0, -0.6, 0.4));
ShowCursor(true);
gSound->muteMusic(false);
gSound->playMusic("data/sound/menu_loop.wav", true, 0);
gSound->setVolume(0.15f);
mShowingAbout = false;
}
bool GraphicsInit()
{
graphicsEngine = new Renderer();
customScene = new CustomScene("MeshScene", graphicsEngine);
// Set the lights
globalLight = new Light(Material(MaterialWhite), glm::vec4(0.00001, 2.0, 25.0, 1.0));
customScene->addLight(globalLight);
// Camera's are added in the CustomScene's constructor
customModel = new CustomModel( customScene, NULL, None );
customScene->addModel(customModel);
graphicsEngine->initializeScenes();
graphicsEngine->initializeScenes();
return true;
}
//===================================================================
Mesh::Mesh(const Mesh &mesh)
{
// copy ctor
mShaderProgram = new QOpenGLShaderProgram(this);
mDebugView = mesh.mDebugView;
mIndexBuffer = QOpenGLBuffer(mesh.mIndexBuffer);
mMode = mesh.mMode;
mTextureImage = mesh.mTextureImage;
setTextureImage(mTextureImage);
for (int index = 0; index < mesh.mVertices.count(); index++)
mVertices.append(mesh.vertices().at(index)) ;
addMaterial(Material());
mOpacity = mesh.mOpacity;
}
//----------------------------------------------------------------------------------------------
DebugMultiPoly::DebugMultiPoly()
{
m_origin = Vector3f();
m_firstColor = Color4f();
m_timeToLiveSeconds = 0.f;
m_killNextFrame = false;
m_shouldBeRemoved = false;
m_hasTexture = false;
m_material = Material();
m_material.m_useVBO = true;
//m_VBOOffset = 0;
genVBO();
//Texture* currTex = new Texture(".\\Data\\cobblestonesDiffuse.png");
//m_material.m_useVBO = true;
//m_material.m_useDiffuse = true;
//m_material.m_useShaderProgram=true;
////currMat-._useShaderProgram = true;
//m_material.m_diffuseID = currTex->m_openGLTextureID;
}
void TPZBndCond::Clone(std::map<int, TPZAutoPointer<TPZMaterial> > &matvec) {
int matid = Id();
TPZAutoPointer<TPZMaterial> refmaterial = Material();
TPZAutoPointer<TPZMaterial> newrefmaterial;
int refmatid = 0;
if(refmaterial) {
refmaterial->Clone(matvec);
refmatid = refmaterial->Id();
newrefmaterial = matvec[refmatid];
}
std::map<int, TPZAutoPointer<TPZMaterial> >::iterator matit;
matit = matvec.find(matid);
if(matit == matvec.end())
{
TPZAutoPointer<TPZMaterial> newmat = TPZAutoPointer<TPZMaterial>(new TPZBndCond(*this, newrefmaterial));
matvec[matid] = newmat;
}
}
void Graphics::drawTest(ID3DXMesh* mesh, IDirect3DTexture9* texture, D3DXVECTOR3 position, D3DXVECTOR3 rotation)
{
HR(mFX->SetTechnique(mhTexTech));
D3DXMATRIX M;
float rotY = atan2f(rotation.x, rotation.z);
D3DXMatrixRotationY(&M, rotY);
setEffectData(texture, position, Dimensions(500), Material(), 0, M, true);
HR(mFX->Begin(0, 0));
HR(mFX->BeginPass(0));
mesh->DrawSubset(0);
HR(mFX->EndPass());
HR(mFX->End());
}
global func FindPosInMat(string sMat, int iXStart, int iYStart, int iWidth, int iHeight, int iSize)
{
var iX, iY;
var iMaterial = Material(sMat);
for(var i = 0; i < 500; i++)
{
iX = AbsX(iXStart+Random(iWidth));
iY = AbsY(iYStart+Random(iHeight));
if(GetMaterial(iX,iY)==iMaterial &&
GetMaterial(iX+iSize,iY+iSize)==iMaterial &&
GetMaterial(iX+iSize,iY-iSize)==iMaterial &&
GetMaterial(iX-iSize,iY-iSize)==iMaterial &&
GetMaterial(iX-iSize,iY+iSize)==iMaterial
) {
return [iX, iY]; // Location found.
}
}
return 0; // No location found.
}
bool GraphicsInit()
{
graphicsEngine = new Renderer();
scene1 = new Scene("MeshScene", graphicsEngine);
scene1->addLight(new Light(Material(MaterialWhite),glm::vec4(0.0, 0.0, 10.0, 1.0)));
// Base
Base = new ObjLoader ( scene1, NULL, CUBE, None );
Base->SetMaterial(Material(MaterialSilver));
Base->SetName(std::string("Base"));
Base->ScaleLocal(1.5, 0.25, 1.5);
// Stand
Stand = new ObjLoader ( scene1, Base, SEMI_HOLLOW_CYLINDER, None );
Stand->SetMaterial(Material(MaterialSilver));
Stand->SetName(std::string("Stand"));
Stand->Translate(0.0, 4.0, 0.0);
Stand->ScaleLocal(0.5, 4.0, 0.5);
// Motor Shaft
MotorShaft = new ObjLoader ( scene1, Stand, CUBE, None );
MotorShaft->SetMaterial(Material(MaterialSilver));
MotorShaft->SetName(std::string("MotorShaft"));
MotorShaft->Translate(0.0, 4.0, 1.0);
MotorShaft->ScaleLocal(0.5, 0.5, 2.0);
// Motor Engine
Sphere = new ObjLoader ( scene1, MotorShaft, SPHERE, None );
Sphere->SetMaterial(Material(MaterialGold));
Sphere->Translate(0.0, 0.0, 2.0);
Sphere->SetName(std::string("Sphere"));
// Fan Blades
for(int i=0; i<360; i+=360/18){
CubePlane = new ObjLoader ( scene1, Sphere, CUBE, None );
CubePlane->SetMaterial(Material(MaterialCopper));
CubePlane->SetName(std::string("FanBlade"));
CubePlane->Translate(0.0, 2.0, 0.0);
CubePlane->SetCenter(glm::vec3(0.0, -2.0, 0.0));
CubePlane->ScaleLocal(0.20, 2.0, 0.20);
CubePlane->Rotate(i, 0.0, 0.0, 1.0);
}
scene1->addModel( Base);
graphicsEngine->initializeScenes();
// Sphere->SetVisible(!true, true);
// Sphere->SetVisible(true, !true);
Base->Rotate(45.0, 0.0, 1.0, 0.0);
// Sphere->SetVisible(true, true);
return true;
}
UMaterial* UGTCaptureComponent::GetMaterial(FString InModeName = TEXT(""))
{
// Load material for visualization
static TMap<FString, FString>* MaterialPathMap = nullptr;
if (MaterialPathMap == nullptr)
{
MaterialPathMap = new TMap<FString, FString>();
MaterialPathMap->Add(TEXT("depth"), TEXT("Material'/UnrealCV/SceneDepthWorldUnits.SceneDepthWorldUnits'"));
MaterialPathMap->Add(TEXT("plane_depth"), TEXT("Material'/UnrealCV/ScenePlaneDepthWorldUnits.ScenePlaneDepthWorldUnits'"));
MaterialPathMap->Add(TEXT("vis_depth"), TEXT("Material'/UnrealCV/SceneDepth.SceneDepth'"));
MaterialPathMap->Add(TEXT("debug"), TEXT("Material'/UnrealCV/debug.debug'"));
// MaterialPathMap->Add(TEXT("object_mask"), TEXT("Material'/UnrealCV/VertexColorMaterial.VertexColorMaterial'"));
MaterialPathMap->Add(TEXT("normal"), TEXT("Material'/UnrealCV/WorldNormal.WorldNormal'"));
FString OpaqueMaterialName = "Material'/UnrealCV/OpaqueMaterial.OpaqueMaterial'";
MaterialPathMap->Add(TEXT("opaque"), OpaqueMaterialName);
}
static TMap<FString, UMaterial*>* StaticMaterialMap = nullptr;
if (StaticMaterialMap == nullptr)
{
StaticMaterialMap = new TMap<FString, UMaterial*>();
for (auto& Elem : *MaterialPathMap)
{
FString ModeName = Elem.Key;
FString MaterialPath = Elem.Value;
ConstructorHelpers::FObjectFinder<UMaterial> Material(*MaterialPath); // ConsturctorHelpers is only available for UObject.
if (Material.Object != NULL)
{
StaticMaterialMap->Add(ModeName, (UMaterial*)Material.Object);
}
}
}
UMaterial* Material = StaticMaterialMap->FindRef(InModeName);
if (Material == nullptr)
{
UE_LOG(LogUnrealCV, Warning, TEXT("Can not recognize visualization mode %s"), *InModeName);
}
return Material;
}
LeafSystem::LeafSystem(const Mesh& mesh, TextureType texture_type, const glm::vec3& origin, int numParticles) :
draw_template_({
ShaderType::DEFERRED,
mesh,
Material(),
Texture(texture_type, DIFFUSE_TEXTURE),
boost::none,
EffectSet({EffectType::CASTS_SHADOW, EffectType::CASTS_REFLECTION})
}),
origin_(origin),
scale_(0.7f),
velocity_(glm::vec3(0.0f, -0.00001f, 0.0f)),
acceleration_(glm::vec3(0.0f, -0.000001f, 0.0f)) {
for (int i = 0; i < numParticles; i++) {
glm::vec3 randVec = getRandomVec();
float randAngle = static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / ROT_MAX));
particles_.push_back(Particle(glm::vec3(origin_.x + randVec.x, origin_.y + randVec.y, origin_.z + randVec.z),
scale_, randAngle, velocity_, acceleration_));
}
}
TestScene::TestScene()
{
auto tex = -1;// ImageHandler::GetInstance().LoadFromFile("input_data/chino.jpg", true);
//AddObject(new Sphere(1e5, Vector3(1e5 + 1, 40.8, 81.6), Material(Material::REFLECTION_TYPE_LAMBERT, Color(), Color(0.75, 0.25, 0.25), 0.0, tex)), true, false); // 左
AddFloorYZ_xUp(200, 200, Vector3(1, 40.8, 81.6), Material(Material::REFLECTION_TYPE_LAMBERT, Color(), Color(0.75, 0.25, 0.25), 0.0)); // 左
//AddObject(new Sphere(1e5, Vector3(-1e5 + 99, 40.8, 81.6), Material(Material::REFLECTION_TYPE_LAMBERT, Color(), Color(0.25, 0.25, 0.75), tex)), true, false); // 右
AddFloorYZ_xDown(200, 200, Vector3(99, 40.8, 81.6), Material(Material::REFLECTION_TYPE_LAMBERT, Color(), Color(0.25, 0.25, 0.75), 0.0)); // 右
//AddObject(new Sphere(1e5, Vector3(50, 40.8, 1e5), Material(Material::REFLECTION_TYPE_LAMBERT, Color(), Color(0.75, 0.75, 0.75))), true, false); // 奥
AddFloorXY_zUp(150, 150/1.77777777777, Vector3(50, 40.8, 0), Material(Material::REFLECTION_TYPE_LAMBERT, Color(), Color(1, 1, 1), 0.0, tex)); // 奥
//AddObject(new Sphere(1e5, Vector3(50, 40.8, -1e5 + 250), Material(Material::REFLECTION_TYPE_LAMBERT, Color(), Color())), true, false); // 手前
AddFloorXY_zDown(150, 150 / 1.77777777777, Vector3(50, 40.8, 250), Material(Material::REFLECTION_TYPE_LAMBERT, Color(), Color(0.75, 0.75, 0.75), 0.0, tex)); // 手前
//AddObject(new Sphere(1e5, Vector3(50, 1e5, 81.6), Material(Material::REFLECTION_TYPE_LAMBERT, Color(), Color(0.75, 0.75, 0.75))), true, false); // 下
AddFloorXZ_yUp(200, 200, Vector3(50, 0, 81.6), Material(Material::REFLECTION_TYPE_LAMBERT, Color(), Color(0.75, 0.75, 0.75)));
//AddObject(new Sphere(1e5, Vector3(50, -1e5 + 81.6, 81.6), Material(Material::REFLECTION_TYPE_LAMBERT, Color(), Color(0.75, 0.75, 0.75))), true, false); // 上
AddFloorXZ_yDown(200, 200, Vector3(50, 81.6, 81.6), Material(Material::REFLECTION_TYPE_LAMBERT, Color(), Color(0.75, 0.75, 0.75)));
m_ibl.reset(new IBL("input_data/Barce_Rooftop_C_Env.hdr"));
Model *cube = new Model;
//if (!cube->ReadFromObj("input_data/Cargo_ship/OBJ/msmunchen_visualstudio.obj", true)) {
if (!cube->ReadFromObj("input_data/shrine.obj", true)) {
std::cerr << "failed to load cube.obj!!!" << std::endl;
getchar();
exit(-1);
}
//cube->Transform(Vector3(50, 30, 50), Vector3(10, 10, 10), Matrix::RotateAroundVector(Vector3(0, 1, 0), 45.0 / 180 * PI));
//cube->Transform(Vector3(50, 10, 50), Vector3(6, 6, 6), Matrix::RotateAroundVector(Vector3(0, 1, 0), 30.0 / 180 * PI));
//cube->Transform(Vector3(50, 5, 70), Vector3(0.05, 0.05, 0.05), Matrix::RotateAroundVector(Vector3(0, 1, 0), 15.0 / 180 * PI));
cube->Transform(Vector3(27, 16.5, 47), Vector3(2, 2, 2), Matrix::RotateAroundVector(Vector3(0, 1, 0), 0 / 180 * PI));
AddModel(cube, true, true);
//AddObject(new Sphere(10,Vector3(), Material(Material::REFLECTION_TYPE_LAMBERT, Color(), Color(0.25, 0.75, 0.25)))); // 緑球
//AddObject(new Sphere(16.5,Vector3(27, 16.5, 47), Material(Material::REFLECTION_TYPE_SPECULAR, Color(), Color(0.99, 0.99, 0.99)))); // 鏡
//AddObject(new Sphere(16.5,Vector3(77, 16.5, 78), Material(Material::REFLECTION_TYPE_REFRACTION, Color(), Color(0.99, 0.99, 0.99), REFRACTIVE_INDEX_OBJECT))); // ガラス
//SphereLight *sphereLight = new SphereLight(7.5, Vector3(50.0, 72.5, 61.6), Material(Material::REFLECTION_TYPE_LAMBERT, Color(26, 26, 26), Color()));
SphereLight *sphereLight = new SphereLight(15, Vector3(50.0, 90, 81.6), Material(Material::REFLECTION_TYPE_LAMBERT, Color(36, 36, 36), Color()));
AddObject(sphereLight, true, false); // 照明
//ConstructBVH();
ConstructQBVH();
}
int XFileLoader::CreateMaterial(const string& materialName, vec4 diffuse, vec4 specular, const string& textureFilename)
{
if (m_materialLookup.find(materialName) != m_materialLookup.end())
return m_materialLookup[materialName];
int materialIdx = m_materials.size();
m_materials.emplace_back(std::move(Material()));
Material::MaterialData data = { diffuse, specular };
m_materials[materialIdx].setMaterialData(data);
m_materialLookup.insert(make_pair(move(materialName), materialIdx));
if (!textureFilename.empty())
{
string fname(textureFilename.begin(), textureFilename.end());
m_materials[materialIdx].setDiffuseTexture(move(VBGL::Texture2D::loadTexture(fname)));
auto ext = fname.rfind(L'.');
if (ext == fname.npos)
THROW_EXCEPTION_T("Parsing error", ParsingException);
string specName = fname.substr(0, ext) + "_Specular" + fname.substr(ext);
m_materials[materialIdx].setSpecularTexture(move(VBGL::Texture2D::loadTexture(specName)));
}
return materialIdx;
}
int WriterNodeVisitor::processStateSet(osg::StateSet* ss)
{
MaterialMap::const_iterator itr = _materialMap.find(ss);
if (itr != _materialMap.end())
{
assert(itr->second.index>=0);
return itr->second.index;
}
osg::Material* mat = dynamic_cast<osg::Material*>(ss->getAttribute(osg::StateAttribute::MATERIAL));
osg::Texture* tex = dynamic_cast<osg::Texture*>(ss->getTextureAttribute(0, osg::StateAttribute::TEXTURE));
if (mat || tex)
{
int matNum = _lastMaterialIndex;
_materialMap.insert(std::make_pair(osg::ref_ptr<osg::StateSet>(ss), Material(*this, ss, mat, tex, _preserveMaterialNames, matNum) ));
++_lastMaterialIndex;
return matNum;
}
return -1;
}
int main() {
// Initiatisation
glm::ivec2 screenSize = glm::ivec2(400, 300);
// -- Camera
Camera cam = Camera(70.f, screenSize, 1);
cam.LookAt(glm::vec3(50,52,295.6), glm::vec3(50,52,295.6) + glm::vec3(0,0.0,-1));
// -- Scene
Scene sc;
// Sphere(1e5, Vec( 1e5+1,40.8,81.6), Vec(),Vec(.75,.25,.25),DIFF),//Left
// Sphere(1e5, Vec(-1e5+99,40.8,81.6),Vec(),Vec(.25,.25,.75),DIFF),//Rght
// Sphere(1e5, Vec(50,40.8, 1e5), Vec(),Vec(.75,.75,.75),DIFF),//Back
// Sphere(1e5, Vec(50,40.8,-1e5+170), Vec(),Vec(), DIFF),//Frnt
// Sphere(1e5, Vec(50, 1e5, 81.6), Vec(),Vec(.75,.75,.75),DIFF),//Botm
// Sphere(1e5, Vec(50,-1e5+81.6,81.6),Vec(),Vec(.75,.75,.75),DIFF),//Top
sc.AddPrimitive(
new Sphere(glm::vec3(1e5 + 1, 40.8, 81.6), 1e5,
Material(glm::vec3(.75, .25, .25))));
sc.AddPrimitive(
new Sphere(glm::vec3(-1e5 + 99, 40.8, 81.6), 1e5,
Material(glm::vec3(.25, .25, .75))));
sc.AddPrimitive(
new Sphere(glm::vec3(50,40.8, 1e5), 1e5,
Material(glm::vec3(.75, .75, .75))));
sc.AddPrimitive(
new Sphere(glm::vec3(50, 40.8, -1e5 + 250), 1e5,
Material(glm::vec3(.75, .75, .75))));
sc.AddPrimitive(
new Sphere(glm::vec3(50, 1e5, 81.6), 1e5,
Material(glm::vec3(.75, .75, .75))));
sc.AddPrimitive(
new Sphere(glm::vec3(50,-1e5+81.6,81.6), 1e5,
Material(glm::vec3(.75, .75, .75))));
sc.AddLight(new PointLight(glm::vec3(50,52,240)));
// -- Screne
Screen screen(screenSize);
// Ray generation
for (int x = 0; x < screenSize.x; x++)
for (int y = 0; y < screenSize.y; y++) {
glm::vec3 colorFinal = sc.ComputeColor(cam.GetRay(x,y));
screen.Store(x, y, colorFinal*100.f);
}
screen.SaveToPGM("out.pgm");
return 0;
}
const Geometry::Material& MaterialManager::materialAt(const DDSurfaces::Vector3D& pos ){
if( pos != _pos ) {
TGeoNode *node=_tgeoMgr->FindNode( pos[0], pos[1], pos[2] ) ;
if( ! node ) {
std::stringstream err ;
err << " MaterialManager::material: No geometry node found at location: " << pos ;
throw std::runtime_error( err.str() );
}
// std::cout << " @@@ MaterialManager::material @ " << pos << " found volume : " << node->GetName() << std::endl ;
_m = Material( node->GetMedium() ) ;
_pos = pos ;
}
return _m ; ;
}
void ObjObject::buildShaderProgram()
{
if ( shaderProgram==0 ) {
// Create array of ShaderInfo structs that specifies the vertex and
// fragment shaders to be compiled and linked into a program.
ShaderInfo shaders[] = {
{ GL_VERTEX_SHADER, "pVS-phong-per-frag.vert" },
{ GL_FRAGMENT_SHADER, "pfixed-function-phong-toon-per-frag.frag"},
//{ GL_VERTEX_SHADER, "pVSpSolidColor.vert" },
//{ GL_FRAGMENT_SHADER, "pFSc.frag"},
{ GL_NONE, NULL } // signals that there are no more shaders
};
shaderProgram = LoadShaders(shaders);
}
glUseProgram(shaderProgram);
modelLocation = glGetUniformLocation(shaderProgram, "modelMatrix");
assert(modelLocation != 0xFFFFFFFF);
solidColorLocation = glGetUniformLocation(shaderProgram, "objectColor");
//assert(solidColorLocation != 0xFFFFFFFF);
material = Material( getUniformLocation( shaderProgram, "object.ambientMat"),
getUniformLocation( shaderProgram, "object.diffuseMat"),
getUniformLocation( shaderProgram, "object.specularMat"),
getUniformLocation( shaderProgram, "object.specularExp"),
getUniformLocation( shaderProgram, "object.emissiveMat" ),
getUniformLocation( shaderProgram, "object.textureMapped"),
getUniformLocation( shaderProgram, "object.toon") );
//material.setAmbientAndDiffuseMat( objectColor );
material.setAmbientAndDiffuseMat( vec4(0.8f,0.6f,0.2f,1.0f) * 0.5f );
material.setSpecularMat( vec4(1.0f, 1.0f, 1.0f, 1.0f) );
material.setSpecularExponentMat( 64.0f );
material.setTextureMapped(true);
material.setToon(true);
} // end buildShaderProgram
/**
* Callback d'affichage d'OpenGL
*/
void DisplayCallback()
{
// On ne repasse pas dans le loop si il y a une demande de fermeture
if(_exitRequest || glutGet(GLUT_WINDOW_FORMAT_ID) == 0 ){
_displayExited = true;
return;
}
// Vidage de la frame
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// On dirige la caméra
_camera->Look();
// Par défaut, on applique un matérial blanc
Material mat = Material();
mat.ToWhiteReflect();
mat.Enable();
// Affichage de la montre
glPushMatrix();
glRotatef(-45.0, 1.0, 0.0, 0.0);
glScalef(0.2, 0.2, 0.2);
_montre->FastDisplay();
glPopMatrix();
// On réapplique le matériel
// Et on affiche la pièce
mat.Enable();
glPushMatrix();
glTranslatef(0, -1.8, 0);
glRotatef(-90, 1.0, 0.0, 0.0);
_room->BuildAndDisplayHorloge();
_room->FastDisplay();
glPopMatrix();
// Netoyage
glutSwapBuffers();
glFlush();
}
//----------------------------------------------------------------------------
bool MtlLoader::GetNewMaterial (const vector<string>& tokens)
{
// Syntax
//
// newmtl name
if (tokens[0] == "newmtl")
{
mCurrent = (int)mMaterials.size();
mMaterials.push_back(Material());
if (tokens.size() > 1)
{
mMaterials[mCurrent].Name = tokens[1];
return true;
}
assert(false);
mCode = EC_TOO_FEW_TOKENS;
}
return false;
}
void Graphics::setEffectParameters(D3DXMATRIX world)
{
Light lights1[4];
for(int i = 0; i < mLightList->size(); i++)
lights1[i] = *mLightList->operator[](i);
// Calculate the inverse transpose matrix.
D3DXMATRIX worldInverseTranspose;
D3DXMatrixInverse(&worldInverseTranspose, 0, &world);
D3DXMatrixTranspose(&worldInverseTranspose, &worldInverseTranspose);
// Set the parameters.
HR(mFX->SetMatrix(mhWVP, &(world*gCamera->getViewMatrix()*gCamera->getProjectionMatrix())));
HR(mFX->SetMatrix(mhWorld, &world));
HR(mFX->SetVector(mhEyePos, &D3DXVECTOR4(gCamera->getPosition(), 0)));
HR(mFX->SetMatrix(mhWorldInverseTranspose, &worldInverseTranspose));
HR(mFX->SetInt(mhNumLights, mLightList->size()));
HR(mFX->SetRawValue(mhLights, (void*)&lights1, 0, sizeof(Light)*mLightList->size()));
// Set the DEFUALT = WHITE object material and the light array (max 4 lights right now).
HR(mFX->SetRawValue(mhObjectMaterial, (void*)&Material(), 0, sizeof(Material)));
}
bool IVCONV::swv_read_materials( )
/*****************************************************************************/
/*
Purpose:
Creates materials with textures from Bullfrog's game Syndicate Wars
*/
{
//Setup textures
int base_txtr=texture_num;
for (unsigned int i=0;i<6;i++)
{
texture[texture_num]=Texture();
sprintf(texture[texture_num].name,"TEX%02uC.PNG",i);
texture[texture_num].intense=1.0f;
if ( debug )
printf ( " SW_READ_MATERIALS creating texture entry for %s\n",texture[texture_num].name);
texture_num++;
texture[texture_num]=Texture();
sprintf(texture[texture_num].name,"TEX%02uM.PNG",i);
texture[texture_num].intense=1.0f;
texture_num++;
}
//Now materials
for (unsigned int i=0;i<6;i++)
{
material[material_num]=Material();
material[material_num].rgb=vec3(.5,.5,.5);
material[material_num].ambient=vec3(.4,.4,.4);
material[material_num].specular=vec3(.8,.8,.8);
sprintf(material[material_num].name,"%s%02u",DEFAULT_MATERIAL_NAME,i);
material[material_num].texture=base_txtr+2*i;
material[material_num].mask_texture=base_txtr+2*i+1;
material[material_num].alpha=0.0f;
if ( debug )
printf ( " SW_READ_MATERIALS creating material entry %u\n",i);
material_num++;
}
}
void Montre::BuildStructureIntermediaire()
{
// Plaque
glPushMatrix();
glTranslatef(-0.35, 0, 0);
glRotatef(180, 0, 1, 0);
_plaqueSeparation->FastDisplay();
glPopMatrix();
// Pilier de soutien
for(int i=0; i<4; i++)
{
Material mat = Material();
mat.ToBlackReflect();
mat.Enable();
glPushMatrix();
glTranslatef((i%2?1:-1)*1.15, 0.02, (i%3?1:-1)*1.15);
glRotatef(90, 1, 0, 0);
_rotorInferieur->FastDisplay();
glPopMatrix();
}
}
void Box::setBoxWithRandomColor(float width, float height, float depth)
{
float w2 = width / 2;
float h2 = height / 2;
float d2 = depth / 2;
std::vector<FigureVertex> vertices;
std::vector<UINT> indices;
GeometryGenerator::createBox(width, height, depth, vertices, indices);
setBuffer(vertices, indices);
auto material = Material();
material.m_Ambient = XMFLOAT4(0.01f * (rand() % 100), 0.01f * (rand() % 100), 0.01f * (rand() % 100), 1.0f);
material.m_Diffuse = XMFLOAT4(0.01f * (rand() % 100), 0.01f * (rand() % 100), 0.01f * (rand() % 100), 0.5f);
material.m_Specular = XMFLOAT4(0.01f * (rand() % 100), 0.01f * (rand() % 100), 0.01f * (rand() % 100), 16.0f);
setMaterial(material);
}
ClicECAL::ClicECAL(double innerRadius,
double innerZ,
double depth,
double clusterSizePhoton,
double clusterSize,
double etaAcceptance,
const std::vector<double>
emin,
const std::vector<double>
eresBarrel,
int nX0,
int nLambdaI,
double eResponse)
: Calorimeter(Layer::kEcal,
VolumeCylinder(Layer::kEcal, innerRadius + depth, innerZ + depth, innerRadius, innerZ),
Material("Clic_ECAL", depth / nX0, depth / nLambdaI)),
m_clusterSize(clusterSize),
m_clusterSizePhoton(clusterSizePhoton),
m_emin(emin),
m_eresBarrel(eresBarrel),
m_eResponse(eResponse),
m_etaAcceptance(etaAcceptance) {}
/// \brief Do an update: mix the materials of all children and choose
/// type randomly
void PostTraversal(const ei::IVec4& _position, Model::ModelData::SVON* _node,
const Model::ModelData::SVON* _left, const Model::ModelData::SVON* _right, const Model::ModelData::SVON* _bottom,
const Model::ModelData::SVON* _top, const Model::ModelData::SVON* _front, const Model::ModelData::SVON* _back)
{
if( !_node->Data().IsDirty() ) return;
int selfInner = _position.w == 0 ? _node->Data().inner : 0;
_node->Data().surface =
((_left == nullptr) || !(_left->Data().inner || selfInner))
| (((_right == nullptr) || !(_right->Data().inner || selfInner)) << 1)
| (((_bottom == nullptr) || !(_bottom->Data().inner || selfInner)) << 2)
| (((_top == nullptr) || !(_top->Data().inner || selfInner)) << 3)
| (((_front == nullptr) || !(_front->Data().inner || selfInner)) << 4)
| (((_back == nullptr) || !(_back->Data().inner || selfInner)) << 5);
// Recompute the material from surface voxels only
if( _node->Children() && _node->Data().surface )
{
Material materials[8]; int num = 0;
for( int i = 0; i < 8; ++i )
{
if( _node->Children()[i].Data().surface
&& _node->Children()[i].Data().material != Material::UNDEFINED ) {
//Assert( _node->Children()[i].Data().material != Material::UNDEFINED, "Undefined child material in use." );
materials[num++] = _node->Children()[i].Data().material;
}
}
if( num > 0 )
_node->Data().material = Material(materials, num);
else
// If all children are non-surface this one is non-surface too.
// The estimation from solidity was wrong.
_node->Data().surface = 0;
Assert(_node->Data().material != Material::UNDEFINED, "The voxel has an undefined material and will appear green.");
}
_node->Data().dirty = 0;
}
void Wall::buildShaderProgram()
{
if ( shaderProgram==0 ) {
ShaderInfo shaders[] = {
{ GL_VERTEX_SHADER, "pVSpSolidColor.vert" },
{ GL_FRAGMENT_SHADER, "pFSc.frag"},
{ GL_NONE, NULL } // signals that there are no more shaders
};
// Read the files and create the OpenGL shader program.
shaderProgram = LoadShaders(shaders);
}
// This program will stay in effect for all draw calls until it is
// replaced with another or explicitly disabled (and the
// fixed function pipeline is enabld) by calling glUseProgram with NULL
glUseProgram(shaderProgram);
modelLocation = glGetUniformLocation(shaderProgram, "modelMatrix");
assert(modelLocation != 0xFFFFFFFF);
material = Material( getUniformLocation( shaderProgram, "object.ambientMat"),
getUniformLocation( shaderProgram, "object.diffuseMat"),
getUniformLocation( shaderProgram, "object.specularMat"),
getUniformLocation( shaderProgram, "object.specularExp"),
getUniformLocation( shaderProgram, "object.emissiveMat" ),
getUniformLocation( shaderProgram, "object.textureMapped") );
material.setAmbientAndDiffuseMat( vec4( 0.5f, 0.5f, 0.5f, 1.0f ));
material.setSpecularMat( vec4(1.0f, 1.0f, 1.0f, 1.0f) );
material.setSpecularExponentMat( 64.0f );
material.setTextureMapped( true );
// For Texture mapping
//baseImageLoc = glGetUniformLocation(shaderProgram, "baseImage");
}
