void handleChildren(
SceneParser *parser,
SceneInputNode &input,
const ref_ptr<StateNode> &newNode)
{
// Process node children
const list< ref_ptr<SceneInputNode> > &childs = input.getChildren();
for(list< ref_ptr<SceneInputNode> >::const_iterator
it=childs.begin(); it!=childs.end(); ++it)
{
const ref_ptr<SceneInputNode> &x = *it;
// First try node processor
ref_ptr<NodeProcessor> nodeProcessor = parser->getNodeProcessor(x->getCategory());
if(nodeProcessor.get()!=NULL) {
nodeProcessor->processInput(parser, *x.get(), newNode);
continue;
}
// Second try state processor
ref_ptr<StateProcessor> stateProcessor = parser->getStateProcessor(x->getCategory());
if(stateProcessor.get()!=NULL) {
stateProcessor->processInput(parser, *x.get(), newNode->state());
continue;
}
REGEN_WARN("No processor registered for '" << x->getDescription() << "'.");
}
}
ref_ptr<Light> LightResource::createResource(
SceneParser *parser, SceneInputNode &input)
{
Light::Type lightType =
input.getValue<Light::Type>("type", Light::SPOT);
ref_ptr<Light> light = ref_ptr<Light>::alloc(lightType);
light->set_isAttenuated(
input.getValue<bool>("is-attenuated", lightType!=Light::DIRECTIONAL));
light->position()->setVertex(0,
input.getValue<Vec3f>("position", Vec3f(0.0f)));
light->direction()->setVertex(0,
input.getValue<Vec3f>("direction", Vec3f(0.0f,0.0f,1.0f)));
light->diffuse()->setVertex(0,
input.getValue<Vec3f>("diffuse", Vec3f(1.0f)));
light->specular()->setVertex(0,
input.getValue<Vec3f>("specular", Vec3f(1.0f)));
light->radius()->setVertex(0,
input.getValue<Vec2f>("radius", Vec2f(999999.9f)));
Vec2f angles = input.getValue<Vec2f>("cone-angles", Vec2f(50.0f,55.0f));
light->set_innerConeAngle(angles.x);
light->set_outerConeAngle(angles.y);
parser->putState(input.getName(),light);
return light;
}
// Override
void processInput(
SceneParser *parser,
SceneInputNode &input,
const ref_ptr<StateNode> &parent)
{
ref_ptr<State> state = ref_ptr<State>::alloc();
ref_ptr<StateNode> newNode = ref_ptr<StateNode>::alloc(state);
newNode->set_name(input.getName());
newNode->set_isHidden(GL_TRUE);
parent->addChild(newNode);
parser->putNode(input.getName(), newNode);
handleChildren(parser,input,newNode);
ViewNode viewNode;
viewNode.name = input.getName();
viewNode.node = newNode;
viewNodes_->push_back(viewNode);
REGEN_INFO("View: " << viewNode.name);
}
ref_ptr<AssetImporter> AssetResource::createResource(
SceneParser *parser,
SceneInputNode &input)
{
if(!input.hasAttribute("file")) {
REGEN_WARN("Ignoring Asset '" << input.getDescription() << "' without file.");
return ref_ptr<AssetImporter>();
}
const std::string assetPath = getResourcePath(input.getValue("file"));
const std::string texturePath = getResourcePath(input.getValue("texture-path"));
GLint assimpFlags = input.getValue<GLint>("import-flags",-1);
AssimpAnimationConfig animConfig;
animConfig.numInstances =
input.getValue<GLuint>("animation-instances",1u);
animConfig.useAnimation = (animConfig.numInstances>0) &&
input.getValue<bool>("use-animation",true);
animConfig.forceStates =
input.getValue<bool>("animation-force-states",true);
animConfig.ticksPerSecond =
input.getValue<GLfloat>("animation-tps",20.0);
animConfig.postState = input.getValue<NodeAnimation::Behavior>(
"animation-post-state",
NodeAnimation::BEHAVIOR_LINEAR);
animConfig.preState = input.getValue<NodeAnimation::Behavior>(
"animation-pre-state",
NodeAnimation::BEHAVIOR_LINEAR);
try {
return ref_ptr<AssetImporter>::alloc(
assetPath, texturePath, animConfig, assimpFlags);
}
catch(AssetImporter::Error &e) {
REGEN_WARN("Unable to open Asset file: " << e.what() << ".");
return ref_ptr<AssetImporter>();
}
}
ref_ptr<Camera> CameraResource::createResource(
SceneParser *parser,
SceneInputNode &input)
{
if(input.hasAttribute("reflector") ||
input.hasAttribute("reflector-normal") ||
input.hasAttribute("reflector-point"))
{
ref_ptr<Camera> userCamera =
parser->getResources()->getCamera(parser, input.getValue("camera"));
if(userCamera.get()==NULL) {
REGEN_WARN("Unable to find Camera for '" << input.getDescription() << "'.");
return ref_ptr<Camera>();
}
ref_ptr<ReflectionCamera> cam;
bool hasBackFace = input.getValue<bool>("has-back-face", false);
if(input.hasAttribute("reflector")) {
ref_ptr<MeshVector> mesh =
parser->getResources()->getMesh(parser, input.getValue("reflector"));
if(mesh.get()==NULL || mesh->empty()) {
REGEN_WARN("Unable to find Mesh for '" << input.getDescription() << "'.");
return ref_ptr<Camera>();
}
const vector< ref_ptr<Mesh> > &vec = *mesh.get();
cam = ref_ptr<ReflectionCamera>::alloc(
userCamera,vec[0],input.getValue<GLuint>("vertex-index",0u), hasBackFace);
}
else if(input.hasAttribute("reflector-normal")) {
Vec3f normal = input.getValue<Vec3f>("reflector-normal", Vec3f(0.0f,1.0f,0.0f));
Vec3f position = input.getValue<Vec3f>("reflector-point", Vec3f(0.0f,0.0f,0.0f));
cam = ref_ptr<ReflectionCamera>::alloc(userCamera,normal,position,hasBackFace);
}
if(cam.get()==NULL) {
REGEN_WARN("Unable to create Camera for '" << input.getDescription() << "'.");
return ref_ptr<Camera>();
}
parser->putState(input.getName(),cam);
return cam;
}
else if(input.hasAttribute("light")) {
ref_ptr<Camera> userCamera =
parser->getResources()->getCamera(parser, input.getValue("camera"));
if(userCamera.get()==NULL) {
REGEN_WARN("Unable to find Camera for '" << input.getDescription() << "'.");
return ref_ptr<Camera>();
}
ref_ptr<Light> light =
parser->getResources()->getLight(parser, input.getValue("light"));
if(light.get()==NULL) {
REGEN_WARN("Unable to find Light for '" << input.getDescription() << "'.");
return ref_ptr<Camera>();
}
GLuint numLayer = input.getValue<GLuint>("num-layer", 1u);
GLdouble splitWeight = input.getValue<GLdouble>("split-weight", 0.9);
GLdouble near = input.getValue<GLdouble>("near", 0.1);
GLdouble far = input.getValue<GLdouble>("far", 200.0);
ref_ptr<LightCamera> cam = ref_ptr<LightCamera>::alloc(
light,userCamera,Vec2f(near,far),numLayer,splitWeight);
parser->putState(input.getName(),cam);
// Hide cube shadow map faces.
if(input.hasAttribute("hide-faces")) {
const string val = input.getValue<string>("hide-faces","");
vector<string> faces;
boost::split(faces,val,boost::is_any_of(","));
for(vector<string>::iterator it=faces.begin();
it!=faces.end(); ++it) {
int faceIndex = atoi(it->c_str());
cam->set_isCubeFaceVisible(
GL_TEXTURE_CUBE_MAP_POSITIVE_X+faceIndex, GL_FALSE);
}
}
return cam;
}
else if(input.hasAttribute("cube-mesh")) {
ref_ptr<Camera> userCamera =
parser->getResources()->getCamera(parser, input.getValue("camera"));
if(userCamera.get()==NULL) {
REGEN_WARN("Unable to find Camera for '" << input.getDescription() << "'.");
return ref_ptr<Camera>();
}
ref_ptr<MeshVector> mesh =
parser->getResources()->getMesh(parser, input.getValue("cube-mesh"));
if(mesh.get()==NULL || mesh->empty()) {
REGEN_WARN("Unable to find Mesh for '" << input.getDescription() << "'.");
return ref_ptr<Camera>();
}
ref_ptr<CubeCamera> cam = ref_ptr<CubeCamera>::alloc((*mesh.get())[0],userCamera);
parser->putState(input.getName(),cam);
// Hide cube shadow map faces.
if(input.hasAttribute("hide-faces")) {
const string val = input.getValue<string>("hide-faces","");
vector<string> faces;
boost::split(faces,val,boost::is_any_of(","));
for(vector<string>::iterator it=faces.begin();
it!=faces.end(); ++it) {
int faceIndex = atoi(it->c_str());
cam->set_isCubeFaceVisible(
GL_TEXTURE_CUBE_MAP_POSITIVE_X+faceIndex, GL_FALSE);
}
}
return cam;
}
else if(input.hasAttribute("paraboloid-mesh")) {
ref_ptr<Camera> userCamera =
parser->getResources()->getCamera(parser, input.getValue("camera"));
if(userCamera.get()==NULL) {
REGEN_WARN("Unable to find Camera for '" << input.getDescription() << "'.");
return ref_ptr<Camera>();
}
ref_ptr<MeshVector> mesh =
parser->getResources()->getMesh(parser, input.getValue("paraboloid-mesh"));
if(mesh.get()==NULL || mesh->empty()) {
REGEN_WARN("Unable to find Mesh for '" << input.getDescription() << "'.");
return ref_ptr<Camera>();
}
bool hasBackFace = input.getValue<bool>("has-back-face",false);
ref_ptr<ParaboloidCamera> cam = ref_ptr<ParaboloidCamera>::alloc(
(*mesh.get())[0],userCamera,hasBackFace);
parser->putState(input.getName(),cam);
return cam;
}
else {
ref_ptr<Camera> cam = ref_ptr<Camera>::alloc();
cam->set_isAudioListener(
input.getValue<bool>("audio-listener", false));
cam->position()->setVertex(0,
input.getValue<Vec3f>("position", Vec3f(0.0f,2.0f,-2.0f)));
Vec3f dir = input.getValue<Vec3f>("direction", Vec3f(0.0f,0.0f,1.0f));
dir.normalize();
cam->direction()->setVertex(0, dir);
cam->updateFrustum(
(GLfloat)parser->getViewport()->getVertex(0).x/
(GLfloat)parser->getViewport()->getVertex(0).y,
input.getValue<GLfloat>("fov", 45.0f),
input.getValue<GLfloat>("near", 0.1f),
input.getValue<GLfloat>("far", 200.0f));
// Update frustum when window size changes
parser->addEventHandler(Application::RESIZE_EVENT,
ref_ptr<ProjectionUpdater>::alloc(cam, parser->getViewport()));
parser->putState(input.getName(),cam);
return cam;
}
}
