void CamerasExporter::operator()(Object *ob, Scene *sce)
{
// TODO: shiftx, shifty, YF_dofdist
Camera *cam = (Camera*)ob->data;
std::string cam_id(get_camera_id(ob));
std::string cam_name(id_name(cam));
switch (cam->type) {
case CAM_PANO:
case CAM_PERSP: {
COLLADASW::PerspectiveOptic persp(mSW);
persp.setXFov(RAD2DEGF(focallength_to_fov(cam->lens, cam->sensor_x)), "xfov");
persp.setAspectRatio((float)(sce->r.xsch)/(float)(sce->r.ysch), false, "aspect_ratio");
persp.setZFar(cam->clipend, false, "zfar");
persp.setZNear(cam->clipsta, false, "znear");
COLLADASW::Camera ccam(mSW, &persp, cam_id, cam_name);
addCamera(ccam);
break;
}
case CAM_ORTHO:
default:
{
COLLADASW::OrthographicOptic ortho(mSW);
ortho.setXMag(cam->ortho_scale, "xmag");
ortho.setAspectRatio((float)(sce->r.xsch)/(float)(sce->r.ysch), false, "aspect_ratio");
ortho.setZFar(cam->clipend, false, "zfar");
ortho.setZNear(cam->clipsta, false, "znear");
COLLADASW::Camera ccam(mSW, &ortho, cam_id, cam_name);
addCamera(ccam);
break;
}
}
}
CameraViewDialog::CameraViewDialog(View* view, QWidget* parent) : QDialog(parent),
view(view),
autoText(false)
{
this->setupUi(this);
connect(add_Button,SIGNAL(clicked()), this, SLOT(addCamera()));
connect(remove_Button, SIGNAL(clicked()), this, SLOT(removeCamera()));
connect(settings_Button, SIGNAL(clicked()), this, SLOT(settingsCamera()));
if(view){
QList<Camera*> cameraList= view->cameras();
foreach(Camera* c, cameraList){
QVariant var;
var.setValue(c);
QListWidgetItem* item= new QListWidgetItem(listWidget);
item->setData(Qt::UserRole, var);
autoText=true;
item->setText(c->getName());
autoText=false;
item->setFlags (item->flags () | Qt::ItemIsEditable);
if(view->currentCamera()==c){
listWidget->setCurrentItem(item);
}
}
connect(listWidget, SIGNAL(currentItemChanged(QListWidgetItem*, QListWidgetItem*)),
this, SLOT(changeCurrentCamera(QListWidgetItem*, QListWidgetItem*)));
connect(listWidget, SIGNAL(itemChanged ( QListWidgetItem *)),
this, SLOT(cameraNameChange(QListWidgetItem *)));
}
int PovrayMaker::render()
{
addCamera();
addLightSource(scale, scale, scale);
double axLen=1.5*scale;
double axThick=0.005*scale;
addCylinder(0, 0,0,axLen, 0,0, axThick,1);
addCylinder(0, 0,0,0, axLen,0, axThick,2);
addCylinder(0, 0,0,0, 0,axLen, axThick,3);
file->close();
QFile iniFile(fileName+QString("%1.ini").arg(dnum));
QString processor("D:\\Program\" \"Files\\POVRAY\\bin\\pvengine /EXIT ");
// QString processor("notepad ");
if(iniFile.exists())
Povray.start(processor+fileName+QString("%1.ini").arg(dnum));
else
Povray.start(processor+fileName+QString("%1.pov").arg(dnum));
if (!Povray.waitForStarted())
return 1;
if (!Povray.waitForFinished(-1))
return 2;
if(!file->open(QIODevice::Append | QIODevice::Text))
return 3;
textOut.setDevice(file);
return 0;
}
// Constructor
BattleGround::BattleGround(void)
: end(false)
{
// Default settings
//setShadowTechnique(Ogre::SHADOWTYPE_STENCIL_ADDITIVE);
setAmbientLight(Ogre::ColourValue(1,1,1));
// Create camera
look_node = getManager().getRootSceneNode()->createChildSceneNode();
cam_node = getManager().getRootSceneNode()->createChildSceneNode();
useCamera(addCamera("BattleGround Camera", *cam_node, *look_node));
// Ground
addObject("cube", Ogre::Vector3(0,-5,0), Ogre::Vector3(10,1,1));
addObject("cube", Ogre::Vector3(-23,7,0), Ogre::Vector3(3,0.5,1));
addObject("cube", Ogre::Vector3(23,7,0), Ogre::Vector3(3,0.5,1));
for (int i=0; i<5; i++)
addObject("cube", Ogre::Vector3(0,5*i,0), Ogre::Vector3(0.6,0.6,0.6), 100);
setStartingPosition(-10,10);
setStartingPosition(10,10);
#if DEBUG_PHYSIC_SHAPES
createDebugDrawer(getManager());
#endif
bool hydrax = false, skyx = false;
FtsEvaluator ev(ScriptManager::get().getL());
ev.evalBool("Config.Hydrax", hydrax);
ev.evalBool("Config.SkyX", skyx);
if(hydrax)
createWaterPlane();
if(skyx)
createSky();
}
void Scene::link( Object* child )
{
switch( child->m_feature )
{
case Object::Feature:
break;
case Entity::Feature:
addEntity( (Entity*)child );
break;
case Camera::Feature:
addCamera( (Camera*)child );
addEntity( (Entity*)child );
break;
/*case Element::Light:
break;*/
default:
MAGICAL_ASSERT( false, "Invalid!" );
break;
}
for( auto itr : child->m_children )
{
link( itr );
}
}
ObjectEditor::ObjectEditor(QString *patchProject,ELanguage *lan, QWidget *parent):
SpaceEngine()
{
SpaceEngineEvents->setParent(parent);
addCamera();
pack=new EResursePack();
camera=getCamersList()->front();
// camera->setLineWidth(5);
connect(camera,SIGNAL(MouseClikedEvent(EMouseEvent*)),SLOT(cameraClick(EMouseEvent*)));
connect(camera,SIGNAL(scrollEnd(EKord&)),this,SLOT(cameraSizeChanged(EKord&)));
setCameraVirtual(camera,EKord(0.70,0.88),EKord(0,0.1));
Projectpatch=patchProject;
lang=lan;
log=new ELoadScreen();
addMap();
ObjectRender=NULL;
setMap(getMapsList()->front(),camera);
createVerticalMenu();
createHorizontalMenu();
addQtWidget(log,EKord(0),EKord(1,0.1));
log->setHidden(true);
ugol=lastX=0;
connect(getMain(),SIGNAL(EmouseMoveEvent(QMouseEvent*)),SLOT(MouseMove(QMouseEvent*)));
connect(getMain(),SIGNAL(EkeyPressEvent(QKeyEvent*)),SLOT(press(QKeyEvent*)));
connect(getMain(),SIGNAL(EkeyReleaseEvent(QKeyEvent*)),SLOT(release(QKeyEvent*)));
alt=ShiftPressd=ctrlPresed=false;
}
BEGIN_JLIB_GRAPHICS_RENDER_NAMESPACE
scene::scene( math::colour4 col, unsigned int w, unsigned int h ) : _target( 0 ),
_defaultScene( 0 ), _defaultCamera( this, math::triple( 10, 10, 10 ), 0 )
{
_bgCol = col;
_width = w;
_height = h;
glViewport( 0, 0, _width, _height );
addScene( &_defaultScene );
addCamera( _defaultCamera );
}
void PlanetariumEngine::reset(void)
{
mSceneManager->clear();
foreach (Planet* p, mObjects)
delete p;
mHighLightedBody = 0;
mObjects.clear();
addCamera();
addStarBackground();
}
PovrayMaker::~PovrayMaker()
{
addCamera();
addLightSource(scale, scale, scale);
double axLen=1.5*scale;
double axThick=0.005*scale;
addCylinder(0, 0,0,axLen, 0,0, axThick,1);
addCylinder(0, 0,0,0, axLen,0, axThick,2);
addCylinder(0, 0,0,0, 0,axLen, axThick,3);
}
CameraMetaData::CameraMetaData(const char *docname) {
xml_document doc;
xml_parse_result result = doc.load_file(docname);
if (!result) {
ThrowCME("CameraMetaData: XML Document could not be parsed successfully. Error was: %s in %s",
result.description(), doc.child("node").attribute("attr").value());
}
xml_node cameras = doc.child("Cameras");
for (xml_node camera = cameras.child("Camera"); camera; camera = camera.next_sibling("Camera")) {
Camera *cam = new Camera(camera);
if(!addCamera(cam)) continue;
// Create cameras for aliases.
for (uint32 i = 0; i < cam->aliases.size(); i++) {
addCamera(new Camera(cam, i));
}
}
}
PlanetariumEngine::PlanetariumEngine(irr::IrrlichtDevice* device,
const Configuration::GraphicsConfig& config)
: mSceneManager(device->getSceneManager())
, mDriver(device->getVideoDriver())
, mConfiguration(config)
, mScale(10.0)
, mHighLightedBody(0)
{
addCamera();
addStarBackground();
device->getCursorControl()->setVisible(true);
}
bool SingleViewer::update( const App& app, ConfigFile& config )
{
if( ! Viewer::update( app, config ) ) return false;
if( getNumCameras() == 0 )
{
addCamera().setPose( 0, 0 ); // Camera at Display origin
}
assert( getNumCameras() == 1 );
setViewportToFullWindow( getCamera(0) );
return true;
}
PhotoTexturingWidget::PhotoTexturingWidget(MeshEditInterface* plugin, PhotoTexturer* texturer,MeshModel &m,GLArea *gla): MeshlabEditDockWidget(gla) {
lastDirectory = "";
connect(this,SIGNAL(updateGLAreaTextures()),gla,SLOT(updateTexture()));
connect(this,SIGNAL(setGLAreaTextureMode(vcg::GLW::TextureMode)),gla,SLOT(setTextureMode(vcg::GLW::TextureMode)));
connect(this,SIGNAL(updateMainWindowMenus()),gla,SIGNAL(updateMainWindowMenus()));
ptPlugin = plugin;
photoTexturer = texturer;
PhotoTexturingWidget::ui.setupUi(this);
this->setWidget(ui.main_frame);
//this->setFeatures(QDockWidget::AllDockWidgetFeatures);
this->setFeatures(QDockWidget::DockWidgetMovable|QDockWidget::DockWidgetClosable);
this->setAllowedAreas(Qt::NoDockWidgetArea);
this->setFloating(true);
mesh = &m;
glarea = gla;
//setting up the headers for the tblewidget
//QStringList headers;
//headers << "Camera" << "Image";
//ui.cameraTableWidget->setHorizontalHeaderLabels(headers);
connect(ui.configurationLoadPushButton, SIGNAL(clicked()),this,SLOT(loadConfigurationFile()));
connect(ui.configurationSavePushButton, SIGNAL(clicked()),this,SLOT(saveConfigurationFile()));
connect(ui.exportToMaxScriptPushButton, SIGNAL(clicked()),this,SLOT(exportCamerasToMaxScript()));
connect(ui.convertToTsaiCameraPushButton, SIGNAL(clicked()),this,SLOT(convertToTsaiCamera()));
connect(ui.addCameraPushButton, SIGNAL(clicked()),this,SLOT(addCamera()));
connect(ui.removeCameraPushButton, SIGNAL(clicked()),this,SLOT(removeCamera()));
connect(ui.assignImagePushButton, SIGNAL(clicked()),this,SLOT(assignImage()));
connect(ui.calculateTexturesPushButton, SIGNAL(clicked()),this,SLOT(calculateTextures()));
connect(ui.combineTexturesPushButton, SIGNAL(clicked()),this,SLOT(combineTextures()));
connect(ui.unprojectTexturePushButton, SIGNAL(clicked()),this,SLOT(unprojectTextures()));
connect(ui.bakeTexturePushButton, SIGNAL(clicked()),this,SLOT(bakeTextures()));
connect(ui.textureListWidget, SIGNAL(itemClicked(QListWidgetItem* )),this,SLOT(selectCurrentTexture()));
connect(ui.resetPushButton, SIGNAL(clicked()),this,SLOT(reset()));
connect(ui.closePushButton, SIGNAL(clicked()),this,SLOT(close()));
//connect(ui.cancelPushButton, SIGNAL(clicked()),this,SLOT(cancel()));
photoTexturer->storeOriginalTextureCoordinates(mesh);
loadDefaultSettings();
update();
}
bool Demo::initialize() {
Marvin * player = new Marvin();
player->setPosition(glm::vec3(0, 0, 0));
if (player->initialize() == false)
return false;
_objects.push_back(player);
Camera * camera = new Camera(player);
camera->setOffset(glm::vec3(0, 20, 20));
addCamera("primary", camera);
return true;
}
Camera* World::addSpotLightSource(SpotLight light, float fov){
Camera* cam = new Camera(this, new ShadowMapping(light.shadowMap, SHADOWMAPPINGSHADER), false);
cam->fov_ = fov;
cam->position = light.position;
cam->useDirection = true;
cam->direction = light.direction;
cam->resize(Config::graphics.shadowmapResolution, Config::graphics.shadowmapResolution);
light.depthBiasVP = glm::mat4(
0.5f, 0.0f, 0.0f, 0.0f,
0.0f, 0.5f, 0.0f, 0.0f,
0.0f, 0.0f, 0.5f, 0.0f,
0.5f, 0.5f, 0.5f, 1.0f
) * cam->getProjectionMatrix() * cam->getViewMatrix();
addCamera(cam);
spotlights.push_back(light);
}
void Facade::uploadCameraFromFile(StreamInfo streamInfo)
{
try
{
processStream(&streamInfo);
AddCamera addCamera(this->action, &streamInfo);
addCamera.execute();
DrawScene drawScene(this->action);
drawScene.execute();
}
catch(BaseException& exc)
{
this->alertWindowService->showErrorMessage(exc.what());
}
}
// This method is templated on the implementation of hctMayaSceneExporter::createHkxNodes()
void FbxToHkxConverter::addNodesRecursive(hkxScene *scene, FbxNode* fbxNode, hkxNode* node, int animStackIndex)
{
for (int childIndex = 0; childIndex < fbxNode->GetChildCount(); childIndex++)
{
FbxNode* fbxChildNode = fbxNode->GetChild(childIndex);
FbxNodeAttribute* fbxNodeAtttrib = fbxChildNode->GetNodeAttribute();
bool selected = fbxChildNode->GetSelected();
// Ignore nodes(and their descendants) if they're invisible and we ignore invisible objects
if ( !(!m_options.m_visibleOnly || fbxNode->GetVisibility()) )
continue;
// Ignore nodes(and their descendants) if they're not selected and we ignore deselected objects
if ( !(!m_options.m_selectedOnly || selected) )
continue;
hkxNode* newChildNode = new hkxNode();
{
newChildNode->m_name = fbxChildNode->GetName();
node->m_children.pushBack(newChildNode);
}
newChildNode->m_selected = selected;
// Extract the following types of data from this node (taken from hkxScene.h):
if (fbxNodeAtttrib != NULL)
{
switch (fbxNodeAtttrib->GetAttributeType())
{
case FbxNodeAttribute::eMesh:
{
// Generate hkxMesh and all its dependent data (ie: hkxSkinBinding, hkxMeshSection, hkxMaterial)
if (m_options.m_exportMeshes)
{
addMesh(scene, fbxChildNode, newChildNode);
}
break;
}
case FbxNodeAttribute::eNurbsCurve:
{
if (m_options.m_exportSplines)
{
addSpline(scene, fbxChildNode, newChildNode);
}
break;
}
case FbxNodeAttribute::eCamera:
{
// Generate hkxCamera
if (m_options.m_exportCameras)
{
addCamera(scene, fbxChildNode, newChildNode);
}
break;
}
case FbxNodeAttribute::eLight:
{
// Generate hkxLight
if (m_options.m_exportLights)
{
addLight(scene, fbxChildNode, newChildNode);
}
break;
}
case FbxNodeAttribute::eSkeleton:
{
// Flag this node as a bone if it's associated with a skeleton attribute
newChildNode->m_bone = true;
break;
}
default:
break;
}
}
// Extract this node's animation data and bind transform
extractKeyFramesAndAnnotations(scene, fbxChildNode, newChildNode, animStackIndex);
if (m_options.m_exportAttributes)
{
addSampledNodeAttributeGroups(scene, animStackIndex, fbxChildNode, newChildNode);
}
GetCustomVisionData(fbxChildNode, newChildNode->m_userProperties);
addNodesRecursive(scene, fbxChildNode, newChildNode, animStackIndex);
newChildNode->removeReference();
}
}
//parse a scene description file and generate a Scene
Scene* SceneParser::parse(const char* filename){
std::cout << "SceneParser::parse parses scene... " << filename <<" \n";
struct basicxmlnode * rootNode = NULL;
//open file
FILE * fp = fopen(filename, "rt");
if (!fp) {
std::cerr << "SceneParser - Error: Failed opening file " << filename << "\n";
return NULL;
}
std::string filenameString = std::string(filename);
size_t index = filenameString.find_last_of("/");
if (index == std::string::npos) {
index = filenameString.find_last_of("\\");
}
if (index == std::string::npos) {
directory = "";
}
else {
directory = filenameString.substr(0,index+1);
}
//read xml tree
rootNode = readbasicxmlnode(fp);
fclose(fp);
if (!rootNode) {
std::cerr << "SceneParser - Error: Failed reading file " << filename << ". Maybe an XML syntax error?\n";
return NULL;
}
//construct scene
Scene* scene = new Scene();
//read scene properties
if (!addSceneProperties(rootNode, scene)) {
std::cerr << "SceneParser - Error: Failed to read Scene Properties in " << filename << "\n";
deletebasicxmlnode(rootNode);
delete(scene);
return NULL;
}
//read camera
struct basicxmlnode * cameraNode = getchildnodebyname(rootNode, "Camera");
if (!addCamera(cameraNode, scene)) {
std::cerr << "SceneParser - Error: Failed reading camera description in " << filename << "\n";
deletebasicxmlnode(rootNode);
delete(scene);
return NULL;
}
//read lights
struct basicxmlnode * lightsNode = getchildnodebyname(rootNode, "Lights");
if (!lightsNode) {
std::cout << "SceneParser - Warning: No Lights specified in " << filename << "\n";
}
else if (!lightsNode->children[0]) {
std::cout << "SceneParser - Warning: No Lights specified in " << filename << "\n";
}
else {
for(int lightsIndex = 0; lightsNode->children[lightsIndex]; lightsIndex++) {
if(!addLight(lightsNode->children[lightsIndex], scene)) {
std::cerr << "SceneParser - Error: Failed reading light description in " << filename << "\n";
deletebasicxmlnode(rootNode);
delete(scene);
return NULL;
}
}
}
//read materials
struct basicxmlnode * materialsNode = getchildnodebyname(rootNode, "Materials");
if (!materialsNode) {
std::cout << "SceneParser - No global Materials specified in " << filename << "\n";
}
else if (!materialsNode->children[0]) {
std::cout << "SceneParser - Empty Materials node in " << filename << "\n";
} else {
for(int materialsIndex = 0; materialsNode->children[materialsIndex]; materialsIndex++) {
if(!addGlobalMaterial(materialsNode->children[materialsIndex], scene)) {
std::cerr << "SceneParser - Error: Failed reading global material description in " << filename << "\n";
deletebasicxmlnode(rootNode);
delete(scene);
return NULL;
}
}
}
//read textures
struct basicxmlnode* texturesNode = getchildnodebyname(rootNode, "Textures");
if (!texturesNode) {
std::cout << "SceneParser - No global Textures specified in " << filename << "\n";
}
else if (!texturesNode->children[0]) {
std::cout << "SceneParser - Empty Textures node in " << filename << "\n";
}
else {
for(int texturesIndex = 0; texturesNode->children[texturesIndex]; texturesIndex++) {
if(!addGlobalTexture(texturesNode->children[texturesIndex], scene)) {
std::cerr << "SceneParser - Error: Failed reading global texture description in " << filename << "\n";
deletebasicxmlnode(rootNode);
delete(scene);
return NULL;
}
}
}
//read elements
struct basicxmlnode * elementsNode = getchildnodebyname(rootNode, "Elements");
if (!elementsNode) {
std::cout << "SceneParser - Warning: No Elements specified in " << filename << "\n";
}
else if (!elementsNode->children[0]) {
std::cout << "SceneParser - Warning: No Elements specified in " << filename << "\n";
}
for(int elementsIndex = 0; elementsNode->children[elementsIndex]; elementsIndex++) {
if(!addElement(elementsNode->children[elementsIndex], scene)) {
std::cerr << "SceneParser - Error: Failed reading element description in " << filename << "\n";
deletebasicxmlnode(rootNode);
delete(scene);
return NULL;
}
}
//free xml memory
deletebasicxmlnode(rootNode);
std::cout << "[done]\n\n";
return scene;
}
QWidget *WalkmeshManager::buildCameraPage()
{
QWidget *ret = new QWidget(this);
ListWidget *listWidget = new ListWidget(ret);
listWidget->addAction(ListWidget::Add, tr("Ajouter caméra"), this, SLOT(addCamera()));
listWidget->addAction(ListWidget::Rem, tr("Supprimer caméra"), this, SLOT(removeCamera()));
caToolbar = listWidget->toolBar();
camList = listWidget->listWidget();
caVectorXEdit = new VertexWidget(ret);
caVectorYEdit = new VertexWidget(ret);
caVectorZEdit = new VertexWidget(ret);
caSpaceXEdit = new QDoubleSpinBox(ret);
qreal maxInt = qPow(2,31);
caSpaceXEdit->setRange(-maxInt, maxInt);
caSpaceXEdit->setDecimals(0);
caSpaceYEdit = new QDoubleSpinBox(ret);
caSpaceYEdit->setRange(-maxInt, maxInt);
caSpaceYEdit->setDecimals(0);
caSpaceZEdit = new QDoubleSpinBox(ret);
caSpaceZEdit->setRange(-maxInt, maxInt);
caSpaceZEdit->setDecimals(0);
caZoomEdit = new QSpinBox(ret);
caZoomEdit->setRange(-32768, 32767);
QGridLayout *caLayout = new QGridLayout(ret);
caLayout->addWidget(listWidget, 0, 0, 8, 1);
caLayout->addWidget(new QLabel(tr("Distance (zoom) :")), 0, 1, 1, 3);
caLayout->addWidget(caZoomEdit, 0, 4, 1, 2);
caLayout->addWidget(new QLabel(tr("Axes de la caméra :")), 1, 1, 1, 6);
caLayout->addWidget(caVectorXEdit, 2, 1, 1, 6);
caLayout->addWidget(caVectorYEdit, 3, 1, 1, 6);
caLayout->addWidget(caVectorZEdit, 4, 1, 1, 6);
caLayout->addWidget(new QLabel(tr("Position de la caméra :")), 5, 1, 1, 6);
caLayout->addWidget(new QLabel(tr("X")), 6, 1);
caLayout->addWidget(caSpaceXEdit, 6, 2);
caLayout->addWidget(new QLabel(tr("Y")), 6, 3);
caLayout->addWidget(caSpaceYEdit, 6, 4);
caLayout->addWidget(new QLabel(tr("Z")), 6, 5);
caLayout->addWidget(caSpaceZEdit, 6, 6);
caLayout->setRowStretch(7, 1);
caLayout->setColumnStretch(2, 1);
caLayout->setColumnStretch(4, 1);
caLayout->setColumnStretch(6, 1);
connect(camList, SIGNAL(currentRowChanged(int)), SLOT(setCurrentCamera(int)));
connect(caVectorXEdit, SIGNAL(valuesChanged(Vertex_s)), SLOT(editCaVector(Vertex_s)));
connect(caVectorYEdit, SIGNAL(valuesChanged(Vertex_s)), SLOT(editCaVector(Vertex_s)));
connect(caVectorZEdit, SIGNAL(valuesChanged(Vertex_s)), SLOT(editCaVector(Vertex_s)));
connect(caSpaceXEdit, SIGNAL(valueChanged(double)), SLOT(editCaPos(double)));
connect(caSpaceYEdit, SIGNAL(valueChanged(double)), SLOT(editCaPos(double)));
connect(caSpaceZEdit, SIGNAL(valueChanged(double)), SLOT(editCaPos(double)));
connect(caZoomEdit, SIGNAL(valueChanged(int)), SLOT(editCaZoom(int)));
return ret;
}
void TutorialLevel::setup(){
INFO("Generating Tutorial Level...");
readFile();
initalizeGrid();
createRenders();
createLevel();
waterSurfaceManager = WaterSurfaceManagerPtr(new WaterSurfaceManager());
addGameObject(waterSurfaceManager);
INFO("Removal String so less of make");
INFO("Setting up the cameras for the Test Level...");
CameraPtr cam3(new Camera(glm::vec3(25, 30, 0), glm::vec3(10, 20, 6),
glm::vec3(0, 1, 0)));
cam3->setProjectionMatrix(
glm::perspective(glm::radians(90.0f),
(float) Global::ScreenWidth/Global::ScreenHeight,
0.1f, 100.f));
addCamera("CinematicCamera", cam3);
setMainCamera("CinematicCamera");
setCullingCamera("CinematicCamera");
CameraPtr cam1(new Camera(glm::vec3(4, 10, -5), glm::vec3(4, 4, -10),
glm::vec3(0, 1, 0)));
cam1->setProjectionMatrix(
glm::perspective(glm::radians(90.0f),
(float) Global::ScreenWidth/Global::ScreenHeight,
0.1f, 100.f));
addCamera("Camera1", cam1);
CameraPtr cam2(new Camera(glm::vec3(0, 1, 0), glm::vec3(-6, -3, 6),
glm::vec3(0, 1, 0)));
cam2->setProjectionMatrix(
glm::perspective(glm::radians(90.0f),
(float) Global::ScreenWidth/Global::ScreenHeight,
0.1f, 100.f));
l1 = LightPtr(new Light(glm::vec3(1), 30.0f, glm::vec3(0, 30, 0)));
l1->setPosition(l1->getDirection());
Uniform3DGridPtr<int> typeGrid = getTypeGrid();
gridCenter = glm::vec3((typeGrid->getMaxX() - typeGrid->getMinX())/2.0f,
(typeGrid->getMaxY() - typeGrid->getMinY())/2.0f,
(typeGrid->getMinZ() - typeGrid->getMaxZ())/2.0f);
l1->setViewMatrix(glm::lookAt(
l1->getPosition(),
gridCenter, glm::vec3(0, 1, 0)));
l1->setProjectionMatrix(glm::ortho<float>(-30,30,-30,30,-70,70));
addLight("Sun", l1);
INFO("Setting up the player for the Test Level...");
cinematicPlayer = CinematicPlayerPtr(new CinematicPlayer(cam3));
cinematicPlayer->setup();
addGameObject("cinematicPlayer", cinematicPlayer);
player = PlayerPtr(new Player(cam1, 2));
player->setup();
addGameObject("player" , player);
CollisionManager::addCollisionObjectToList(player);
debugPlayer = DebugPlayerPtr(new DebugPlayer(cam2));
debugPlayer->setup();
addGameObject("debugPlayer" , debugPlayer);
//Text
addCamera("DebugCamera", cam2);
sky = ObjectPtr(new Object(
LoadManager::getMesh("sphere.obj"),
MaterialManager::getMaterial("None")));
sky->applyTexture(LoadManager::getTexture("Sky"));
sky->enableTexture();
sky->scale(glm::vec3(-90.0f,-90.0f,-90.0f));
sky->translate(Director::getScene()->getCamera()->getEye());
RenderEngine::getRenderElement("textured")->addObject(sky);
ExclamationPtr exclamation = ExclamationPtr(new Exclamation(glm::vec3(30, 26, -48)));
exclamation->setup();
addGameObject("exclamation", exclamation);
}
void TunnelLevel::setup(){
INFO("Generating Test Level...");
readFile();
initalizeGrid();
createRenders();
createLevel();
INFO("Removal String so less of make");
waterSurfaceManager = WaterSurfaceManagerPtr(new WaterSurfaceManager());
addGameObject(waterSurfaceManager);
CameraPtr cam3(new Camera(glm::vec3(30, 45, 0), glm::vec3(30, 15, 6),
glm::vec3(0, 1, 0)));
cam3->setProjectionMatrix(
glm::perspective(glm::radians(90.0f),
(float) Global::ScreenWidth/Global::ScreenHeight,
0.1f, 100.f));
addCamera("CinematicCamera", cam3);
setMainCamera("CinematicCamera");
setCullingCamera("CinematicCamera");
INFO("Setting up the cameras for the Test Level...");
CameraPtr cam1(new Camera(glm::vec3(32.0f, 12.0f, -24.0f), glm::vec3(4, 4, -10),
glm::vec3(0, 1, 0)));
cam1->setProjectionMatrix(
glm::perspective(glm::radians(90.0f),
(float) Global::ScreenWidth/Global::ScreenHeight,
0.1f, 100.f));
addCamera("Camera1", cam1);
setMainCamera("Camera1");
setCullingCamera("Camera1");
CameraPtr cam2(new Camera(glm::vec3(0, 1, 0), glm::vec3(-6, -3, 6),
glm::vec3(0, 1, 0)));
cam2->setProjectionMatrix(
glm::perspective(glm::radians(90.0f),
(float) Global::ScreenWidth/Global::ScreenHeight,
0.1f, 100.f));
l1 = LightPtr(new Light(glm::vec3(1), 30.0f, glm::vec3(32, 30, -20)));
l1->setPosition(l1->getDirection());
Uniform3DGridPtr<int> typeGrid = getTypeGrid();
gridCenter = glm::vec3((typeGrid->getMaxX() - typeGrid->getMinX())/2.0f,
(typeGrid->getMaxY() - typeGrid->getMinY())/2.0f,
(typeGrid->getMinZ() - typeGrid->getMaxZ())/2.0f);
l1->setViewMatrix(glm::lookAt(
l1->getPosition(),
gridCenter, glm::vec3(0, 1, 0)));
l1->setProjectionMatrix(glm::ortho<float>(-30,30,-30,30,-70,70));
addLight("Sun", l1);
cinematicPlayer = CinematicPlayerPtr(new CinematicPlayer(cam3));
cinematicPlayer->setup();
addGameObject("cinematicPlayer", cinematicPlayer);
INFO("Setting up the player for the Test Level...");
player = PlayerPtr(new Player(cam1, 2));
player->setup();
addGameObject("player" , player);
CollisionManager::addCollisionObjectToList(player);
debugPlayer = DebugPlayerPtr(new DebugPlayer(cam2));
debugPlayer->setup();
addGameObject("debugPlayer" , debugPlayer);
addCamera("DebugCamera", cam2);
INFO("Creating Switch for the Test Level...");
SwitchPtr s1(new Switch(glm::vec3(0.9f, 0.1f, 0.1f), glm::vec3(33.7f, 11.0f, -27.0f),
glm::vec3(0,0,1), -20.0f, 1));
s1->setup();
addGameObject("s1", s1);
CollisionManager::addCollisionObjectToGrid(s1);
std::list<SolidCubePtr> solidCubes;
// INFO("Creating Active Terrain for the Test Level...");
for(int i = 11; i < 36; i+=2) {
for(int j = -27; j < -20; j+=2) {
SolidCubePtr at1(new SolidCube(glm::vec3(29, i, j)));
at1->setup();
RenderEngine::getRenderGrid()->removeObject(at1->getObject());
solidCubes.push_back(at1);
}
}
ActiveTerrainPtr a1(new ActiveTerrain(s1, glm::vec3(), glm::vec3(), 50.0f));
a1->setup();
a1->setCubes(solidCubes);
addGameObject("a1", a1);
sky = ObjectPtr(new Object(
LoadManager::getMesh("sphere.obj"),
MaterialManager::getMaterial("None")));
sky->applyTexture(LoadManager::getTexture("Sky"));
sky->enableTexture();
sky->scale(glm::vec3(-50.0f,-50.0f,-50.0f));
sky->translate(Director::getScene()->getCamera()->getEye());
RenderEngine::getRenderElement("textured")->addObject(sky);
ExclamationPtr exclamation = ExclamationPtr(new Exclamation(glm::vec3(60, 5, -23)));
exclamation->setup();
addGameObject("exclamation", exclamation);
PTR_CAST(SolidCube, (*grid)(7, 20, 11))->getObject()->applyTextureIndex(LoadManager::getTexture("DrainTexture"), 0);
PTR_CAST(SolidCube, (*grid)(7, 20, 12))->getObject()->applyTextureIndex(LoadManager::getTexture("DrainTexture"), 0);
PTR_CAST(SolidCube, (*grid)(7, 20, 11))->getObject()->applyNormalMapIndex(LoadManager::getTexture("RegularNormalMap"), 0);
PTR_CAST(SolidCube, (*grid)(7, 20, 12))->getObject()->applyNormalMapIndex(LoadManager::getTexture("RegularNormalMap"), 0);
shearRegion(8, 10, 21, 21, 11, 12, 1, 0, 0.0f);
shearRegion(11, 13, 20, 20, 11, 12, 1, 0, 0.5f);
PTR_CAST(SolidCube, (*grid)(16, 12, 0))->getObject()->applyTextureIndex(LoadManager::getTexture("DrainTexture"), 0);
PTR_CAST(SolidCube, (*grid)(17, 12, 0))->getObject()->applyTextureIndex(LoadManager::getTexture("DrainTexture"), 0);
PTR_CAST(SolidCube, (*grid)(16, 12, 0))->getObject()->applyNormalMapIndex(LoadManager::getTexture("RegularNormalMap"), 0);
PTR_CAST(SolidCube, (*grid)(17, 12, 0))->getObject()->applyNormalMapIndex(LoadManager::getTexture("RegularNormalMap"), 0);
shearRegion(16, 17, 13, 13, 1, 4, 0, 1, 0.0f);
shearRegion(16, 17, 12, 12, 5, 8, 0, 1, 0.5f);
PTR_CAST(SolidCube, (*grid)(16, 12, 23))->getObject()->applyTextureIndex(LoadManager::getTexture("DrainTexture"), 0);
PTR_CAST(SolidCube, (*grid)(17, 12, 23))->getObject()->applyTextureIndex(LoadManager::getTexture("DrainTexture"), 0);
PTR_CAST(SolidCube, (*grid)(16, 12, 23))->getObject()->applyNormalMapIndex(LoadManager::getTexture("RegularNormalMap"), 0);
PTR_CAST(SolidCube, (*grid)(17, 12, 23))->getObject()->applyNormalMapIndex(LoadManager::getTexture("RegularNormalMap"), 0);
shearRegion(16, 17, 13, 13, 19, 22, 0, -1, 0.0f);
shearRegion(16, 17, 12, 12, 15, 18, 0, -1, 0.5f);
PTR_CAST(SolidCube, (*grid)(26, 12, 15))->getObject()->applyTextureIndex(LoadManager::getTexture("DrainTexture"), 0);
PTR_CAST(SolidCube, (*grid)(26, 12, 8))->getObject()->applyTextureIndex(LoadManager::getTexture("DrainTexture"), 0);
PTR_CAST(SolidCube, (*grid)(26, 12, 15))->getObject()->applyNormalMapIndex(LoadManager::getTexture("RegularNormalMap"), 0);
PTR_CAST(SolidCube, (*grid)(26, 12, 8))->getObject()->applyNormalMapIndex(LoadManager::getTexture("RegularNormalMap"), 0);
}
//---------------------------------------------------------------
void CameraExporter::exportCamera( ExportNode* exportNode )
{
if ( !exportNode->getIsInVisualScene() )
return;
String cameraId = getCameraId(*exportNode);
INode* iNode = exportNode->getINode();
CameraObject* camera = (CameraObject*)iNode->GetObjectRef();
INode* targetNode = ( camera->ClassID().PartA() == LOOKAT_CAM_CLASS_ID) ? iNode->GetTarget() : 0;
if ( camera )
{
if ( mDocumentExporter->isExportedObject(ObjectIdentifier(camera)) )
return;
mDocumentExporter->insertExportedObject(ObjectIdentifier(camera), exportNode);
// Retrieve the camera parameters block
IParamBlock* parameters = (IParamBlock*) camera->GetReference(MaxCamera::PBLOCK_REF);
COLLADASW::BaseOptic * optics = 0;
if ( camera->IsOrtho() )
{
optics = new COLLADASW::OrthographicOptic(COLLADASW::LibraryCameras::mSW);
// Calculate the target distance for FOV calculations
float targetDistance;
if ( targetNode )
{
Point3 targetTrans = targetNode->GetNodeTM(mDocumentExporter->getOptions().getAnimationStart()).GetTrans();
Point3 cameraTrans = iNode->GetNodeTM(mDocumentExporter->getOptions().getAnimationStart()).GetTrans();
targetDistance = (targetTrans - cameraTrans).Length();
}
else
{
targetDistance = camera->GetTDist(mDocumentExporter->getOptions().getAnimationStart());
}
ConversionInverseOrthoFOVFunctor conversionInverseOrthoFOVFunctor(targetDistance);
if ( AnimationExporter::isAnimated(parameters, MaxCamera::FOV) )
{
optics->setXMag(conversionInverseOrthoFOVFunctor(parameters->GetFloat(MaxCamera::FOV)), XMAG_SID);
mAnimationExporter->addAnimatedParameter(parameters, MaxCamera::FOV, cameraId, XMAG_SID, 0, true, &conversionInverseOrthoFOVFunctor);
}
else
{
optics->setXMag(conversionInverseOrthoFOVFunctor(parameters->GetFloat(MaxCamera::FOV)));
}
}
else
{
optics = new COLLADASW::PerspectiveOptic(COLLADASW::LibraryCameras::mSW);
if ( AnimationExporter::isAnimated(parameters, MaxCamera::FOV) )
{
optics->setXFov(COLLADASW::MathUtils::radToDegF(parameters->GetFloat(MaxCamera::FOV)), XFOV_SID);
mAnimationExporter->addAnimatedParameter(parameters, MaxCamera::FOV, cameraId, XFOV_SID, 0, true, &ConversionFunctors::radToDeg);
}
else
{
optics->setXFov(COLLADASW::MathUtils::radToDegF(parameters->GetFloat(MaxCamera::FOV)));
}
}
bool hasAnimatedZNear = mAnimationExporter->addAnimatedParameter(parameters, MaxCamera::NEAR_CLIP, cameraId, optics->getZNearDefaultSid(), 0);
optics->setZNear(parameters->GetFloat(MaxCamera::NEAR_CLIP), hasAnimatedZNear);
bool hasAnimatedZFar = mAnimationExporter->addAnimatedParameter(parameters, MaxCamera::FAR_CLIP, cameraId, optics->getZFarDefaultSid(), 0);
optics->setZFar(parameters->GetFloat(MaxCamera::FAR_CLIP), hasAnimatedZFar);
#ifdef UNICODE
String exportNodeName = COLLADABU::StringUtils::wideString2utf8String(exportNode->getINode()->GetName());
COLLADASW::Camera colladaCamera(COLLADASW::LibraryCameras::mSW, optics, cameraId, COLLADASW::Utils::checkNCName(exportNodeName));
#else
COLLADASW::Camera colladaCamera(COLLADASW::LibraryCameras::mSW, optics, cameraId, COLLADASW::Utils::checkNCName(exportNode->getINode()->GetName()));
#endif
setExtraTechnique(&colladaCamera);
// Retrieve the camera target
if ( targetNode )
{
ExportNode* targetExportNode = mExportSceneGraph->getExportNode(targetNode);
addExtraParameter(EXTRA_PARAMETER_TARGET, "#" + targetExportNode->getId());
}
if (camera->GetMultiPassEffectEnabled(0, FOREVER))
{
IMultiPassCameraEffect *multiPassCameraEffect = camera->GetIMultiPassCameraEffect();
if (multiPassCameraEffect)
{
Class_ID id = multiPassCameraEffect->ClassID();
// the camera could have both effects, but not in Max
if (id == FMULTI_PASS_MOTION_BLUR_CLASS_ID)
{
IParamBlock2 *parameters = multiPassCameraEffect->GetParamBlock(0);
if (parameters )
{
addParamBlockAnimatedExtraParameters(MOTION_BLUR_ELEMENT, MOTION_BLUR_PARAMETERS, MOTION_BLUR_PARAMETER_COUNT, parameters, cameraId);
}
}
else if (id == FMULTI_PASS_DOF_CLASS_ID)
{
IParamBlock2 *parameters = multiPassCameraEffect->GetParamBlock(0);
if (parameters )
{
addParamBlockAnimatedExtraParameters(DEPTH_OF_FIELD_ELEMENT, DEPTH_OF_FIELD_PARAMETERS, DEPTH_OF_FIELD_PARAMETER_COUNT, parameters, cameraId);
addExtraParameter(TARGETDISTANCE_PARAMETER, camera->GetTDist(0));
}
}
}
}
addCamera(colladaCamera);
delete optics;
}
}
