bool MaterialSlot::setItem(Item* item)
{
if (!Slot::setItem(item))
{
return false;
}
if (item)
{
try
{
CeGuiString mat = item->getProperty("material").toString();
CeGuiString mesh = item->getSubmeshName();
///@todo: what to do if actor is null?, think about changing the inventory of an gameobject not in scene
if (mOwner->getActor())
{
MeshObject* mo = dynamic_cast<MeshObject*>(
mOwner->getActor()->getControlledObject());
MergeableMeshObject* mmo = dynamic_cast<MergeableMeshObject*>(
mo);
if (mmo && !mesh.empty())
{
mmo->replaceSubmesh(mSubmesh, mesh.c_str());
}
if (mo)
{
mo->setMaterial(mat.c_str(), mSubmesh);
}
}
}
catch (const IllegalArgumentException&)
{
LOG_ERROR(Logger::RULES, "Item " + item->getName() + " has no property material.");
}
catch (const WrongFormatException&)
{
LOG_ERROR(Logger::RULES, "Item " + item->getName() + " has a property material, but it is no string property.");
}
}
else
{
///@todo reset material?
}
return true;
}
int main(int argc, const char * argv[]) {
// Initialize glfw
if (!glfwInit()){
std::cerr << "Failed to initialize glfw" << std::endl;
exit(EXIT_FAILURE);
}
// Set the error callback for glfw
glfwSetErrorCallback(error_callback);
// Set window settings
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);
GLFWwindow *window = glfwCreateWindow(800,600, "OpenGL Renderer", NULL, NULL);
if (!window) {
std::cerr << "Could not create glfw window!" << std::endl;
glfwTerminate();
exit(EXIT_FAILURE);
}
glfwMakeContextCurrent(window);
glfwSwapInterval(1);
glfwSetKeyCallback(window, key_callback);
glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
int width, height;
glfwGetFramebufferSize(window, &width, &height);
glViewport(0, 0, width, height);
float ratio = width / (float) height;
Camera cam(glm::vec3(0,0,-2));
cam.setProjMatrix(ratio);
DefaultMaterial m(glm::vec3(.2f,.2f,.9f));
MeshObject cube;
cube.setMaterial(&m);
SceneNode cubeNode(&cube);
cubeNode.setTransform(glm::scale(glm::mat4(), glm::vec3(2)));
double lastFrameTime = glfwGetTime();
double xpos, ypos;
while (!glfwWindowShouldClose(window)) {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
double currentFrameTime = glfwGetTime();
double delta = currentFrameTime - lastFrameTime;
lastFrameTime = currentFrameTime;
cam.translate(glm::vec3(delta * camXSpeed, delta * camYSpeed, delta * camZSpeed));
glfwGetCursorPos(window, &xpos, &ypos);
// Cursor rotation is currently broken.
//cam.rotateFromCursor(2*xpos/width - 1, 2*ypos/height - 1);
cubeNode.render(window, cam.getViewMatrix(), cam.getProjMatrix());
glfwSwapBuffers(window);
glfwPollEvents();
}
glfwDestroyWindow(window);
glfwTerminate();
return 0;
}
void XmlParser::readMeshs(Renderer * renderer ,Scene * scene, XmlNode * meshNode) {
// Read mesh
while(meshNode) {
// Create cube
glm::mat4 id;
MeshObject * mesh = new MeshObject(id);
// Read shaders and init it
int basicShader = renderer->getDefaultBasicShader();
int lightShader = renderer->getDefaultLightShader();
XmlNode * basicShaderNode = meshNode->first_node("basic-shader");
XmlNode * lightShaderNode = meshNode->first_node("light-shader");
// If there is a basic shader node
if (basicShaderNode) {
XmlAttr * vert, * frag;
xmlAttribute(vert, basicShaderNode);
xmlAttribute(frag, basicShaderNode);
// Create new shader
basicShader = renderer->createShaderProg(vert->value(), frag->value());
}
// If there is a light shader node
if (lightShaderNode) {
XmlAttr * vert, * frag;
xmlAttribute(vert, lightShaderNode);
xmlAttribute(frag, lightShaderNode);
// Create new shader
lightShader = renderer->createShaderProg(vert->value(), frag->value());
}
// Init mesh
mesh->init(basicShader, lightShader);
// Load file (it must exist)
XmlAttr * file;
xmlAttribute(file, meshNode);
mesh->loadFromFile(file->value());
// Try to read model
readModel(mesh, meshNode->first_node("model"));
// Add c to scene
scene->addGameObject(mesh);
// Set texture
XmlNode * textureNode = meshNode->first_node("texture");
if (textureNode) {
// Get file name
XmlAttr * file;
xmlAttribute(file, textureNode);
// Create texture
Texture texture(GL_TEXTURE0, std::string(file->value()));
// Set texture
mesh->setTexture(texture);
}
// Set normal map
XmlNode * normalMapNode = meshNode->first_node("normal-map");
if (normalMapNode) {
// Get file name
XmlAttr * file;
xmlAttribute(file, normalMapNode);
// Create texture
Texture normalMap(GL_TEXTURE2, std::string(file->value()));
// Set texture
mesh->setNormalMap(normalMap);
}
// Set material
XmlNode * material = meshNode->first_node("material");
if (material) {
// Create material
Material * m = new Material();
// Set emissive
XmlNode * emissive = material->first_node("emissive");
if (emissive) {
XmlAttr * r, *g, *b;
xmlAttribute(r, emissive);
xmlAttribute(g, emissive);
xmlAttribute(b, emissive);
// Set diffuse
m->setEmissive(atof(r->value()), atof(g->value()),
atof(b->value()));
}
// Read ambient
XmlNode * ambient = material->first_node("ambient");
if (ambient) {
XmlAttr * r, *g, *b;
xmlAttribute(r, ambient);
xmlAttribute(g, ambient);
xmlAttribute(b, ambient);
// Set diffuse
m->setAmbient(atof(r->value()), atof(g->value()),
atof(b->value()));
}
// Read diffuse
XmlNode * diffuse = material->first_node("diffuse");
if (diffuse) {
XmlAttr * r, *g, *b;
xmlAttribute(r, diffuse);
xmlAttribute(g, diffuse);
xmlAttribute(b, diffuse);
// Set diffuse
m->setDiffuse(atof(r->value()), atof(g->value()),
atof(b->value()));
}
// Read specular
XmlNode * specular = material->first_node("specular");
if (specular) {
XmlAttr * r, *g, *b;
xmlAttribute(r, specular);
xmlAttribute(g, specular);
xmlAttribute(b, specular);
// Set diffuse
m->setSpecular(atof(r->value()), atof(g->value()),
atof(b->value()));
}
// Read specular
XmlNode * shininess = material->first_node("shininess");
if (shininess) {
XmlAttr * value;
xmlAttribute(value, shininess);
// Set diffuse
m->setShininess(atof(value->value()));
}
// Set material
mesh->setMaterial(m);
}
// Read Scripts
XmlNode * scripts = meshNode->first_node("scripts");
readScripts(scene, mesh, scripts);
// Get next cube
meshNode = meshNode->next_sibling("mesh");
}
}
