//--------------------------------------------------------------
void ofApp::setup()
{
ofSetLogLevel(OF_LOG_NOTICE);
ofBackground(ofColor::black);
// Add all Scenes to the Playlist.
auto playlist = entropy::GetPlaylist();
playlist->addScene(make_shared<entropy::scene::Bubbles>());
playlist->addScene(make_shared<entropy::scene::Calibrate>());
playlist->addScene(make_shared<entropy::scene::Inflation>());
playlist->addScene(make_shared<entropy::scene::Interlude>());
playlist->addScene(make_shared<entropy::scene::Particles>());
playlist->addScene(make_shared<entropy::scene::Surveys>());
}
void CCAppEngine::startGame()
{
#ifdef IOS
extern NSString *gAdMobPublisherID;
gAdMobPublisherID = @"a14e76818589686";
CCWindowController::instance->toggleAdverts( true );
CCWindowController::instance->toggleAdverts( false );
#endif
addScene( new SceneSocialBackground() );
addScene( new SceneSocialLogin() );
//AddFlag( gEngine->renderFlags, collision_box );
//AddFlag( gEngine->renderFlags, render_collisionTrees );
}
void Main::onInitialize() {
dt::Scene::SceneSP scene = addScene(new dt::Scene("testscene"));
scene->getPhysicsWorld()->setShowDebug(true);
dt::ResourceManager::get()->addResourceLocation("sinbad.zip","Zip", true);
Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
dt::Node::NodeSP camnode = scene->addChildNode(new dt::Node("camnode"));
camnode->setPosition(Ogre::Vector3(0, 0, 50));
camnode->addComponent(new dt::CameraComponent("cam"))->lookAt(Ogre::Vector3(0, 0, 0));;
dt::Node::NodeSP meshnode1 = _addMeshNode(scene.get(), "meshNode1", Ogre::Vector3(-15.0f, 20.0f, 0.0f));
meshnode1->setPosition(-15, 0, 0);
meshnode1->addComponent(new dt::PhysicsBodyComponent("meshNode1", "meshBody", dt::PhysicsBodyComponent::BOX, 0.0));
dt::Node::NodeSP par = scene->addChildNode(new dt::Node("parent_node"));
dt::Node::NodeSP triggerAreaNode = par->addChildNode(new dt::Node("triggerArea"));
std::shared_ptr<dt::TriggerAreaComponent> triggerAreaComponent = triggerAreaNode->addComponent(new dt::TriggerAreaComponent(new btBoxShape(btVector3(5.0f, 5.0f, 5.0f)), "triggerArea"));
//triggerAreaNode->setPosition(Ogre::Vector3(0.0f, 0.0f, 0.0f));
par->setPosition(-15, 0, 0);
QObject::connect(triggerAreaComponent.get(),
SIGNAL(triggered(dt::TriggerAreaComponent*, dt::Component*)),
this,
SLOT(areaTriggered(dt::TriggerAreaComponent*,
dt::Component*)));
}
ViewportsSplitter::ViewportsSplitter(QWidget * parent)
: QSplitter(Qt::Vertical, parent)
{
connect( &_timer, SIGNAL(timeout()), this, SLOT(update()) );
_timer.start( 10 );
first = new ViewportPanel(this);
second = new ViewportPanel(this);
third = new ViewportPanel(this);
fourth = new ViewportPanel(this);
dummy = new ViewportPanel(this);
connect(this, SIGNAL(indexLayoutChanged(const int&)), first, SLOT(updateIndexLayout(const int&)));
connect(this, SIGNAL(indexLayoutChanged(const int&)), second, SLOT(updateIndexLayout(const int&)));
connect(this, SIGNAL(indexLayoutChanged(const int&)), third, SLOT(updateIndexLayout(const int&)));
connect(this, SIGNAL(indexLayoutChanged(const int&)), fourth, SLOT(updateIndexLayout(const int&)));
splitQuad();
// add a dummy scene to the scene stack in order to
// avoid empty viewports if the scene-view panel is selected
// before any scene is added to the node pipeline
addScene(new osg::Group, "dummy");
this->installEventFilter(this);
}
void Game::Init(bool enable_http)
{
// Init base game
CIwGame::Init(enable_http);
// Create a scene then add it to the game
CIwGameScene* scene = new CIwGameScene();
scene->Init();
scene->setName("MyScene");
scene->setVirtualTransform(320, 480, 0, false, false);
addScene(scene);
// Create and load resource group that contains our font
CIwGameResourceGroup* group = new CIwGameResourceGroup();
group->setGroupFilename("Common.group");
group->Load();
scene->getResourceManager()->addResource(group); // Add to scenes resource manager so that it is auto cleaned up
// Create font
CIwGameFont* font = new CIwGameFont();
font->setName("trebuchet_12");
font->Init("trebuchet_12", group->getResourceGroup());
scene->getResourceManager()->addResource(font); // Add to scenes resource manager so that it is auto cleaned up
// Create a text actor and add it to the scene
CIwGameActorText* text = new CIwGameActorText();
scene->addActor(text);
CIwRect rect = CIwRect(-100, -20, 200, 40);
CIwGameString string = "Hello World";
text->Init(font, rect, string, 0);
text->setColour(0xff, 0xff, 0xff, 0xff);
}
void SelectLevelState::onInitialize()
{
auto scene = addScene(new Scene("SelectLevel"));
auto camnode = scene->addChildNode(new dt::Node("camnode"));
camnode->setPosition(Ogre::Vector3(0, 0, 10));
camnode->addComponent(new dt::CameraComponent("cam"))->lookAt(Ogre::Vector3(0, 0, 0));
//************************************************************
//The following lines are for test purpose only.
//Todo: Replace them with the actual content.
Ogre::FontManager::getSingleton().load("DejaVuSans", "General");
auto node1 = scene->addChildNode(new dt::Node("node1"));
auto text1 = node1->addComponent(new dt::TextComponent("Select Level", "text1"));
text1->setBackgroundMaterial("TextOverlayBackground");
text1->setColor(Ogre::ColourValue::White);
text1->setFont("DejaVuSans");
text1->setFontSize(72);
text1->setPadding(Ogre::Vector2(20, 20));
GuiRootWindow& rootWindow = GuiManager::get()->getRootWindow();
mReturnButton = rootWindow.addChildWidget<GuiButton>(new GuiButton("return"));
mReturnButton->setPosition(100, 100);
mReturnButton->setSize(250, 100);
mReturnButton->setCaption("Return");
dynamic_cast<MyGUI::Button*>(mReturnButton->getMyGUIWidget())->eventMouseButtonClick
+= MyGUI::newDelegate(this, &SelectLevelState::onReturnClick);
//************************************************************
}
void CCAppEngine::start()
{
addScene( new SceneSample1() );
CCAddFlag( gEngine->renderFlags, render_collisionBoxes );
//CCAddFlag( gEngine->renderFlags, render_collisionTrees );
}
//--------------------------------------------------------------
void ofApp::setup()
{
// Add Scene to the Playlist.
auto playlist = entropy::GetPlaylist();
playlist->addScene(make_shared<entropy::scene::Surveys>());
playlist->previewScene();
}
//--------------------------------------------------------------
bool mtlSceneManager::addAndSwitchToScene(const string& _name, mtlScene* _scene, mtlSceneTransition _transition, bool _destroyLast) {
if (!tween.isCompleted()) {
ofLog(OF_LOG_WARNING, "mtlSceneManager::addAndSwitchToScene() ignored as there is already a switch in progress");
return false;
}
addScene(_name, _scene);
return switchToScene(_name, _transition, _destroyLast);
}
//--------------------------------------------------------------
void ofApp::setup()
{
ofBackground(ofColor::black);
// ofEnableGLDebugLog();
// Add Scene to the Playlist.
auto playlist = entropy::GetPlaylist();
playlist->addScene(make_shared<entropy::scene::Particles>());
playlist->previewScene();
}
//--------------------------------------------------------------
void ofApp::setup()
{
ofBackground(ofColor::black);
// Add Scenes to the Manager.
auto manager = entropy::GetSceneManager();
auto scene = make_shared<entropy::scene::Lighting>();
manager->addScene(scene);
manager->setCurrentScene(scene->getName());
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief file control module
void QSWindow::openFile(){ ////
openFileName = QFileDialog::getOpenFileName ////
(this, "Open File: ", QDir::homePath(), "*.wav *.mp3 *.txt *.mid"); ////
if(openFileName.isEmpty()) ////
ui->statusBar->showMessage("open file unchosen!", 5000); ////
else{ ////
ui->statusBar->showMessage(QString("open: %1").arg(openFileName)); ////
addScene();
}
}
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 );
}
GameMain::GameMain()
{
gGameInst = this;
///// ゲームの初期化
// TODO: ゲーム内で共通して利用する変数などがあれば、ここで準備してください。
//
// ★ GameMain クラスのインスタンスには、GameMain.h をインクルードして gGameInst 変数で参照します。
//
///// シーンの追加
// ★ 追加されたシーンは、ゲーム終了時に自動的に delete されます。自分で解放しようとしないでください。
addScene("title", new TitleScene());
addScene("fire", new FireScene());
addScene("noise", new NoiseScene());
addScene("cube3d", new Cube3DScene());
addScene("dual", new DualScreenScene());
///// 最初のシーンの選択
GMGame::ChangeScene("title");
}
// TODO: This needs some rewriting.
void VondelBook::populateTree(QTreeWidget *tree)
{
QDomElement root = vondelDOM->documentElement();
if (root.tagName() != VondelBook::XML_BOOK)
return;
treeWidget = tree;
treeWidget->clear();
QTreeWidgetItem* book = new QTreeWidgetItem(treeWidget);
book->setText(0, root.attribute(VondelBook::XML_TITLE));
// List of chapters so we can add scenes later to.
QHash<int, QTreeWidgetItem*> treeChapters;
// Get the list of chapter nodes.
QDomNodeList chapters = vondelDOM->elementsByTagName(VondelBook::XML_CHAPTER);
for (int i = 0; i < chapters.count(); i++) {
QDomElement elem = chapters.item(i).toElement();
QString title = elem.attribute(VondelBook::XML_TITLE);
QString cid = elem.attribute(VondelBook::XML_ID);
int type = QTreeWidgetItem::UserType + cid.toInt();
QTreeWidgetItem *chapter = new QTreeWidgetItem(book, type + 999);
chapter->setText(0, title);
chapter->setText(1, cid);
treeChapters[cid.toInt()] = chapter;
addBook("0", cid, title);
}
// Get the list of scene nodes.
// Add them to the chapter.
QDomNodeList scenes = vondelDOM->elementsByTagName(VondelBook::XML_SCENE);
for (int i = 0; i < scenes.count(); i++) {
QDomElement elem = scenes.item(i).toElement();
QString title = elem.attribute(VondelBook::XML_TITLE);
QString id = elem.attribute(VondelBook::XML_ID);
QString cid = elem.attribute(VondelBook::XML_CHAPTERID);
// Add the scene to the chapter.
QTreeWidgetItem *chapter = treeChapters[cid.toInt()];
int type = QTreeWidgetItem::UserType + id.toInt();
QTreeWidgetItem *sceneItem = new QTreeWidgetItem(chapter, type + 1999);
sceneItem->setText(0, title);
sceneItem->setText(1, id);
VondelScene *scene = addScene(id.toInt(), title);
int words = scene->wordCount();
addBook(cid, id, title, words);
}
}
void Main::onInitialize() {
auto scene = addScene(new dt::Scene("testscene"));
dt::ResourceManager::get()->addResourceLocation("sinbad.zip","Zip", true);
dt::ResourceManager::get()->addResourceLocation("particle/","FileSystem", true);
Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
// make a scene
auto camnode = scene->addChildNode(new dt::Node("camnode"));
camnode->setPosition(Ogre::Vector3(0, 2, 10));
camnode->addComponent(new dt::CameraComponent("cam"))->lookAt(Ogre::Vector3(0, 2, 0));;
auto p = scene->addChildNode(new dt::Node("p"));
p->setScale(0.2);
auto mesh = p->addComponent(new dt::MeshComponent("Sinbad.mesh"));
mesh->setAnimation("RunBase");
mesh->setLoopAnimation(true);
mesh->playAnimation();
auto path =
p->addComponent(new dt::FollowPathComponent(dt::FollowPathComponent::LOOP));
path->addPoint(Ogre::Vector3(-10, 0, 0));
path->addPoint(Ogre::Vector3(10, 0, 0));
path->setDuration(2.f);
path->setFollowRotation(true);
// create the particle system
auto p_sys = p->addComponent(new dt::ParticleSystemComponent("p_sys"));
p_sys->setMaterialName("Test/Particle");
p_sys->setParticleCountLimit(1000);
p_sys->getOgreParticleSystem()->setDefaultDimensions(0.03, 0.03);
Ogre::ParticleEmitter* e = p_sys->addEmitter("emit1", "Point");
e->setAngle(Ogre::Degree(10));
e->setColour(Ogre::ColourValue(1.f, 0.6f, 0.f), Ogre::ColourValue(0.2f, 0.8f, 0.2f));
e->setEmissionRate(100);
e->setParticleVelocity(3.f, 4.f);
e->setTimeToLive(1.f, 2.f);
p_sys->addScalerAffector("scaler", 1.05);
p_sys->addLinearForceAffector("force", Ogre::Vector3(0, 5, 0));
Ogre::ParticleAffector* a = p_sys->addAffector("colour_interpolator", "ColourInterpolator");
a->setParameter("time0", "0");
a->setParameter("colour0", "1 1 0 1");
a->setParameter("time1", "0.5");
a->setParameter("colour1", "1 0.3 0 1");
a->setParameter("time2", "1");
a->setParameter("colour2", "1 0 0 0");
}
void QSWindow::addScene(){
if(openFileName.endsWith("wav", Qt::CaseInsensitive)){ ////
addScene(wavView, openFileName); ////
//mediaPlayer->setMedia(QUrl::fromLocalFile(openFileName));
playButton->setEnabled(true);
//mediaPlayer->moveToThread(musicThread);
}
else if(openFileName.endsWith("txt", Qt::CaseInsensitive))
{
addScene(scoreView, openFileName);
}
else if(openFileName.endsWith("mid", Qt::CaseInsensitive)){
addScene(staffView, openFileName);
MidiParser::test(openFileName.toStdString());
}else if(openFileName.endsWith("mp3", Qt::CaseInsensitive)){
std::thread th(WavFile::from_lame0, this, openFileName , openFileName+QString("QS.wav"));
th.detach();
}else{
ui->statusBar->showMessage("can't process such file format!");
openFileName = "";
}
}
/**
Add a new scene to a chapter.
*/
QDomElement VondelBook::addNewScene(QDomElement chapter, QString title)
{
QString chapterId;
int id = getNextId(scenesList);
if (title == "") title = QObject::tr("Untitled Scene ") + QString::number(id);
VondelScene *scene = addScene(id, title);
scenesList.appendChild(scene->xmlNode);
chapterId = chapter.attribute(VondelBook::XML_ID);
scene->xmlNode.setAttribute(XML_ID, id);
scene->xmlNode.setAttribute(XML_CHAPTERID, chapterId);
addCreationDate(scene->xmlNode);
return scene->xmlNode;
}
void SceneManager::Update(){
if (Game->MANAGER.load){
if (Game->MANAGER.scene){
addScene(Game->MANAGER.loadName, Game->MANAGER.scene);
}
Game->MANAGER.load = false;
}
if (Game->MANAGER.unload){
removeScene(Game->MANAGER.unloadName);
Game->MANAGER.unload = false;
}
if (Game->MANAGER.change){
changeScene(Game->MANAGER.changeName);
Game->MANAGER.change = false;
}
}
void LoadingScene::updateLoadingMain()
{
bool done = true;
switch (mLoadingStep)
{
case 0:
break;
case 100:
// switch to main game
auto sceneManager = SceneManager::getInstance();
sceneManager->addScene(SceneManager::SCENE_NAME::MAIN_GAME);
break;
}
if (done)
mLoadingStep += LOADING_STEP_MAIN;
}
void Main::onInitialize() {
auto scene = addScene(new dt::Scene("testscene"));
dt::ResourceManager::get()->addResourceLocation("","FileSystem");
dt::ResourceManager::get()->addResourceLocation("crate","FileSystem");
Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
OgreProcedural::Root::getInstance()->sceneManager = scene->getSceneManager();
OgreProcedural::SphereGenerator().setRadius(1.f).setUTile(.5f).realizeMesh("Sphere");
OgreProcedural::PlaneGenerator().setSizeX(100.f).setSizeY(100.f).setVTile(10.f).setUTile(10.f).realizeMesh("Plane");
Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
auto camnode = scene->addChildNode(new dt::Node("camnode"));
camnode->setPosition(Ogre::Vector3(30, 25, 30));
camnode->addComponent(new dt::CameraComponent("cam"))->lookAt(Ogre::Vector3(0, 10, 0));;
auto planenode = scene->addChildNode(new dt::Node("planenode"));
planenode->setPosition(Ogre::Vector3(0, 0, 0));
planenode->addComponent(new dt::MeshComponent("Plane", "PrimitivesTest/Pebbles", "plane-mesh"));
planenode->addComponent(new dt::PhysicsBodyComponent("plane-mesh", "plane-body",
dt::PhysicsBodyComponent::CONVEX, 0.0f));
auto lightnode1 = scene->addChildNode(new dt::Node("lightnode1"));
lightnode1->addComponent(new dt::LightComponent("light1"));
lightnode1->setPosition(Ogre::Vector3(15, 5, 15));
int n = 2; // (n*2+1) ^ 3 blocks
for(int x = -n; x <= n; ++x) {
for(int y = -n; y <= n; ++y) {
for(int i = 0; i < n*2 + 1; ++i) {
auto node = scene->addChildNode(new dt::Node("node"
"x-" + dt::Utils::toString(x) + "-" +
"y-" + dt::Utils::toString(y) + "-" +
"z-" + dt::Utils::toString(i) ));
node->setPosition(Ogre::Vector3(x * 2.5, i * 2.5 + 5, y * 2.5));
node->addComponent(new dt::MeshComponent("Crate01.mesh", "", "mesh"));
node->addComponent(new dt::PhysicsBodyComponent("mesh", "body"));
}
}
}
}
void QSWindow::scoreToWav(){
ui->tabWidget->setCurrentWidget(ui->scoreTab);
QSScene* sc = (QSScene*)scoreView->scene();
if(sc==0 || ! QFileInfo(sc->Name()).isFile()){
ui->statusBar->showMessage(QString("No current score file!"));
return;
}
saveFile();
if(saveFileName.isEmpty()){
return;
}else{
WavFile wavOut;
if(wavOut.fromScore(60.0/80, sc->Name().toStdString().c_str()));
wavOut.save(saveFileName.toStdString().c_str());
statusBar()->showMessage(QString("Score to Wave file successful!"));
openFileName = saveFileName;
QTimer::singleShot(3000, this, SLOT(addScene()));
playButton->setEnabled(true);
}
}
////////////////////////////////////////////////
/// @brief constructor of QS mainwindow
///
///
///
/// @author wyj
///////////////////////////////////////////////
QSWindow::QSWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::QSWindow),
openFileName(""),
saveFileName(""),
tempFileName(""),
mediaPlayer(0),
musicthread(0),
recorder(new QSRecorder(this)),
preset(QSPreset::getInstance(this))
{
//qDebug()<<QSettings(QSAbout::domainName, QSAbout::appName).scope();
//QSettings(QSAbout::domainName, QSAbout::appName).clear();//remove this line in release version
ui->setupUi(this);
preset->readSettings();//ALSO construct ALL Views!!
//set icon
QIcon iconQS(":/image/QScore.jpg");
setWindowIcon(iconQS);
//initialize
ui->statusBar->showMessage(QString("Welcome to QtScoreur! ")+QDir::currentPath());
//setAutoFillBackground(false);
QPalette winPalette;
winPalette.setBrush(QPalette::Window, QBrush(QPixmap(QString(":/image/glry.jpg"), "JPG").scaled(900,600)));
//setPalette(winPalette);
//music play
musicInit();
musicthread = new QSPlayer(openFileName); ////
mediaPlayer = musicthread->player;
musicthread->start();
preload();//holding all connections needed
// load sample score from qrc
QString sampleScore = QDir::homePath()+QString("/QS_tmp/thu_anthem_short");
QDir::home().mkdir(QString("QS_tmp"));
QFile fw(sampleScore+QString(".txt")), fd(":/sample/thu_anthem_short.txt");
fw.open(QFile::WriteOnly);
fd.open(QFile::ReadOnly);
QByteArray ba = fd.readAll();
fw.write(ba.constData(),ba.size());
fd.close();
fw.close();
addScene(staffView);
addScene(scoreView, sampleScore+QString(".txt"));
if(! QFileInfo(sampleScore+QString(".wav")).isFile()){
WavFile wavOut;
qDebug()<<"THERE";
if(wavOut.fromScore(60.0/80, (sampleScore+QString(".txt")).toStdString().c_str())){
qDebug()<<"HERE";
wavOut.save(sampleScore.toStdString().append(".wav").c_str());
addScene(wavView, wavOut, sampleScore+QString(".wav"));
playButton->setEnabled(true);
}
}else{
addScene(wavView, sampleScore+QString(".wav"));
playButton->setEnabled(true);
}
keyScene = new KeyScene(keyView, this);
//add webView
webView = new Html5ApplicationViewer(ui->webTab);
webView->setOrientation(Html5ApplicationViewer::ScreenOrientationAuto);
webView->resize(900, 400);
webView->showExpanded();
webView->loadUrl(QUrl(QLatin1String("http://www.scoreur.net")));
}
void SceneController::initScene(){
// AlteGLobals
Gallery * gallerie;
Net * n = new Net();
Bee * bee = new Bee();
Light * l1 = new Light(.2,.1,.1,0) ;
Light * l2 = new Light(0,0.2,0,0) ;
Light * l3 = new Light(0,0,0.2,0) ;
Light * gallerieLight = new Light(0.6,0.6,0.6,0.1);
BezierCurve * bc = new BezierCurve();
Gravity grav;
CollisionEngine * ce;
// TestScene
Scene * s_test = new Scene();
//s_test->add(new SegRing());
//addScene(s_test);
DemoScene1 * ds1 = new DemoScene1();
addScene(ds1);
// Scene 0
Scene * s0 = new Scene();
Rect * title = new Rect();
title->setTexture("./Resources/Pix/omtest.jpg");
//title->setColor3f(1,1,1);
title->dim[0]= 100;
title->dim[1]= 100;
title->setPos3f(0,0,10);
s0->add(title);
s0->add(l1);
//addScene(s0);
//Scene 1 (Water)
Scene * s1 = new Scene();
NewNet * nn = new NewNet();
s1->add(nn);
nn->pos[0] = 0;
nn->pos[1] = 0;
nn->pos[2] = 0;
nn->rot[0] = 90;
l3->pos[0] =0;
l3->pos[1] =50;
l3->pos[2] =0;
s1->add(bee);
s1->add(l1);
s1->add(l2);
s1->add(l3);
addScene(s1);
// Scene 2 (Gravity)
Scene * s2 = new Scene();
grav.scene = s2;
s2->add(new Ball());
Rect * rect = new Rect();
rect->dim[0] =500;
rect->dim[1] = 500;
//rect->setTexture("./Resources/Pix/test.jpg");
rect->rot[0] = 90;
Rect * transR1 = new Rect();
transR1->color[0] = 1;
transR1->color[1] = 0;
transR1->color[2] = 0;
transR1->color[3] = 0.5;
transR1->dim[0]= 100;
transR1->dim[1]= 50;
Rect * transR2 = new Rect();
transR2->color[0] = 0;
transR2->color[1] = 0;
transR2->color[2] = 1;
transR2->color[3] = 0.5;
transR2->dim[0]= 50;
transR2->dim[1]= 50;
transR2->pos[2] = 20;
s2->add(transR2);
s2->add(transR1);
s2->add(rect);
s2->add(l1);
s2->add(l2);
s2->add(l3);
// addScene(s2);
// Scene 3 (Partile System)
Scene * s3 = new Scene();
//scene[3].add(new Particle());
ParticleEmitter * emitter =new ParticleEmitter();
s3->add(emitter);
addScene(s3);
// Scene 4 (Bilder)
Scene * s4 = new Scene();
Directory *d= new Directory();
d->openDirectory("./Resources/Pix");
// d->openDirectory("/home/johannes/BIlder/090526 Kletter Tag2 Grillen Wohnheim");
// d->openDirectory("/home/johannes/BIlder/Hochzeit Anna und Mike 1.8.09");
gallerie =new Gallery(d);
s4->add(gallerie);
gallerieLight->pos[0] = -200;
gallerieLight->pos[1] = 200;
s4->add(gallerieLight);
addScene(s4);
// Szene 5 (Bezier Curve)
Scene * s5 = new Scene();
GLfloat point[3] = {0,0,0};
//bc->addPoint2f(point);
bc->addPoint2f(10,-10);
bc->addPoint3f(-20,25,25);
bc->addPoint3f(20,25,25);
bc->addPoint2f(-10,-10);
// The long bc
BezierCurveLong * bcl = new BezierCurveLong();
bcl->add(10,0,2);
bcl->add(100,19,0);
bcl->add(10,10,4);
bcl->add(10,30,0);
bcl->add(10,-10,0);
bcl->add(100,19,6);
bcl->add(10,10,0);
bcl->add(10,30,0);
bcl->add(10,-10,3);
// bcl->add(-10,-10,0);
bcl->closeToLoop();
//bcl->add(0,10,0);
s5->add(bcl);
// s5->add(bc);
addScene(s5);
// Scene 6 (Collision & Physics)
Scene * s6 = new Scene();
GLint Rad = 10;
for (GLfloat alpha = -M_PI ; alpha <= M_PI; alpha += M_PI/50.0)
{
GLfloat size = 1+ (rand()%Rad/2)/10.0 ;
Ball * pb1 =new Ball(size,
rand()%100/100.0,
rand()%100/100.0,
rand()%100/100.0);
//pb1->drawBoundings = true;
//pb1->drawForces = true;
pb1->mass = size;
pb1->setPos3f(Rad *(rand()%(Rad-1)) *cos(alpha),
Rad *(rand()%(Rad-1)) *sin(alpha),
Rad *(rand()%(Rad-1)) *cos(alpha));
for (int k = 0 ; k < 3 ; k ++)
pb1->force[k] = -pb1->pos[(k ) % 3]/10;
s6->add(pb1);
}
/*
Ball * b1 = new Ball(5,1,0,0);
b1->setPos3f(-10,5,1.5);
b1->mass = 5;
b1->force[0] = - b1->pos[0];
b1->force[1] = - b1->pos[1];
b1->force[2] = - b1->pos[2];
b1->drawForces = 1;
scene[6].add(b1);
b1 = new Ball(5,0,1,0);
b1->mass = 5;
b1->setPos3f(10,10,0);
b1->force[0] = - b1->pos[0];
b1->force[1] = - b1->pos[1];
b1->force[2] = - b1->pos[2];
b1->drawForces = 1;
scene[6].add(b1);
*/
ce = new CollisionEngine(s6);
addScene(s6);
// Scene 7 FileBrowser
Scene * s7 = new Scene();
s7->add(new FileBrowser());
addScene(s7);
}
void Main::onInitialize() {
mScore1 = 0;
mScore2 = 0;
auto scene = addScene(new dt::Scene("testscene"));
OgreProcedural::Root::getInstance()->sceneManager = scene->getSceneManager();
dt::ResourceManager::get()->addResourceLocation("","FileSystem", true);
Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
Ogre::FontManager::getSingleton().load("DejaVuSans", "General");
auto camnode = scene->addChildNode(new dt::Node("camnode"));
camnode->setPosition(Ogre::Vector3(0, 0, 30));
camnode->addComponent(new dt::CameraComponent("cam"))->lookAt(Ogre::Vector3(0, 0, 0));
auto lightnode = scene->addChildNode(new dt::Node("lightnode"));
lightnode->setPosition(Ogre::Vector3(-20, 20, 10));
lightnode->addComponent(new dt::LightComponent("light"));
// generate meshes
OgreProcedural::BoxGenerator().setSizeX(FIELD_WIDTH + 1).setSizeY(FIELD_HEIGHT).setSizeZ(1.f).realizeMesh("Field");
OgreProcedural::BoxGenerator().setSizeX(1.0).setSizeY(1.f).setSizeZ(1.f).realizeMesh("Ball");
OgreProcedural::BoxGenerator().setSizeX(1.0).setSizeY(3.f).setSizeZ(1.f).realizeMesh("Paddle");
mGameNode = scene->addChildNode(new dt::Node("game"));
mFieldNode = mGameNode->addChildNode(new dt::Node("field"));
mFieldNode->setPosition(Ogre::Vector3(0, 0, -1));
mFieldNode->addComponent(new dt::MeshComponent("Field", "SimplePongField", "mesh"));
mBallNode = mGameNode->addChildNode(new dt::Node("ball"));
mBallNode->setPosition(Ogre::Vector3(0, 0, 0));
mBallNode->addComponent(new dt::MeshComponent("Ball", "SimplePongBall", "mesh"));
mPaddle1Node = mGameNode->addChildNode(new dt::Node("paddle1"));
mPaddle1Node->setPosition(Ogre::Vector3(- FIELD_WIDTH / 2 - 0.5, 0, 0));
mPaddle1Node->addComponent(new dt::MeshComponent("Paddle", "SimplePongPaddle", "mesh"));
mPaddle2Node = mGameNode->addChildNode(new dt::Node("paddle2"));
mPaddle2Node->setPosition(Ogre::Vector3(FIELD_WIDTH / 2 + 0.5, 0, 0));
mPaddle2Node->addComponent(new dt::MeshComponent("Paddle", "SimplePongPaddle", "mesh"));
auto score1_node = mGameNode->addChildNode(new dt::Node("score1"));
score1_node->setPosition(Ogre::Vector3(-10, FIELD_HEIGHT / 2 + 2, 0));
mScore1Text = score1_node->addComponent(new dt::TextComponent("0", "text"));
mScore1Text->setFont("DejaVuSans");
mScore1Text->setFontSize(64);
auto score2_node = mGameNode->addChildNode(new dt::Node("score2"));
score2_node->setPosition(Ogre::Vector3(10, FIELD_HEIGHT / 2 + 2, 0));
mScore2Text = score2_node->addComponent(new dt::TextComponent("0", "text"));
mScore2Text->setFont("DejaVuSans");
mScore2Text->setFontSize(64);
auto info_node = scene->addChildNode(new dt::Node("info"));
info_node->setPosition(Ogre::Vector3(0, - FIELD_HEIGHT / 2 - 3, 0));
auto info_text = info_node->addComponent(new dt::TextComponent("Left player: W/S -- Right player: Up/Down", "text"));
info_text->setFont("DejaVuSans");
info_text->setFontSize(20);
resetBall();
}
int main( void )
{
//init bullet
initBullet();
// Initialise GLFW
if( !glfwInit() )
{
fprintf( stderr, "Failed to initialize GLFW\n" );
return -1;
}
glfwWindowHint(GLFW_SAMPLES, 4);
// glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
// glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
// glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
//screen resolution GLFW
const GLFWvidmode * mode = glfwGetVideoMode(glfwGetPrimaryMonitor());
int w = mode->width;
int h = mode->height;
if(MessageBox(NULL, L"Would you like to run in fullscreen?", L"Fullscreen", MB_ICONQUESTION | MB_YESNO) == IDYES)
{
window = glfwCreateWindow( w, h, "Ray Tracing - Alfonso Oricchio", glfwGetPrimaryMonitor(), NULL);
printf("fullscreen\n");
}
else
{
window = glfwCreateWindow( WINDOW_WIDTH, WINDOW_HEIGHT, "Ray Tracing - Alfonso Oricchio", NULL, NULL);
printf("window\n");
}
// Open a window and create its OpenGL context
if( window == NULL ){
fprintf( stderr, "Failed to open GLFW window. If you have an Intel GPU, they are not 3.3 compatible. Try the 2.1 version of the tutorials.\n" );
glfwTerminate();
return -1;
}
glfwMakeContextCurrent(window);
// Initialize GLEW
glewExperimental = true; // Needed for core profile
if (glewInit() != GLEW_OK) {
fprintf(stderr, "Failed to initialize GLEW\n");
return -1;
}
// Ensure we can capture the escape key being pressed below
glfwSetInputMode(window, GLFW_STICKY_KEYS, GL_TRUE);
glfwSetCursorPos(window, WINDOW_WIDTH/2, WINDOW_HEIGHT/2);
// Dark blue background
glClearColor(0.0f, 0.0f, 0.4f, 0.0f);
// Enable depth test
glEnable(GL_DEPTH_TEST);
// Accept fragment if it closer to the camera than the former one
glDepthFunc(GL_LESS);
// Cull triangles which normal is not towards the camera
//glEnable(GL_CULL_FACE);
GLuint VertexArrayID;
glGenVertexArrays(1, &VertexArrayID);
glBindVertexArray(VertexArrayID);
// Create and compile our GLSL program from the shaders
GLuint depthProgramID = LoadShaders( "DepthRTT.vertexshader", "DepthRTT.fragmentshader" );
// Get a handle for our "MVP" uniform
GLuint depthMatrixID = glGetUniformLocation(depthProgramID, "depthMVP");
// The framebuffer, which regroups 0, 1, or more textures, and 0 or 1 depth buffer.
GLuint FramebufferName = 0;
glGenFramebuffers(1, &FramebufferName);
glBindFramebuffer(GL_FRAMEBUFFER, FramebufferName);
// Depth texture. Slower than a depth buffer, but you can sample it later in your shader
GLuint depthTexture;
glGenTextures(1, &depthTexture);
glBindTexture(GL_TEXTURE_2D, depthTexture);
glTexImage2D(GL_TEXTURE_2D, 0,GL_DEPTH_COMPONENT16, 1024, 1024, 0,GL_DEPTH_COMPONENT, GL_FLOAT, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_R_TO_TEXTURE);
glFramebufferTexture(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, depthTexture, 0);
// No color output in the bound framebuffer, only depth.
glDrawBuffer(GL_NONE);
// Always check that our framebuffer is ok
if(glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
return false;
/***********************************************************/
// The quad's FBO. Used only for visualizing the shadowmap.
static const GLfloat g_quad_vertex_buffer_data[] = {
-1.0f, -1.0f, 0.0f,
1.0f, -1.0f, 0.0f,
-1.0f, 1.0f, 0.0f,
-1.0f, 1.0f, 0.0f,
1.0f, -1.0f, 0.0f,
1.0f, 1.0f, 0.0f,
};
GLuint quad_vertexbuffer;
glGenBuffers(1, &quad_vertexbuffer);
glBindBuffer(GL_ARRAY_BUFFER, quad_vertexbuffer);
glBufferData(GL_ARRAY_BUFFER, sizeof(g_quad_vertex_buffer_data), g_quad_vertex_buffer_data, GL_STATIC_DRAW);
// Create and compile our GLSL program from the shaders
GLuint quad_programID = LoadShaders( "Passthrough.vertexshader", "SimpleTexture.fragmentshader" );
GLuint texID = glGetUniformLocation(quad_programID, "texture");
/**********************************************************/
// Create and compile our GLSL program from the shaders
GLuint programID = LoadShaders( "TransformVertexShader.vertexshader", "ColorFragmentShader.fragmentshader" );
// Get a handle for our "MVP" uniform
GLuint MatrixID = glGetUniformLocation(programID, "MVP");
GLuint ViewMatrixID = glGetUniformLocation(programID, "V");
GLuint ModelMatrixID = glGetUniformLocation(programID, "M");
GLuint DepthBiasID = glGetUniformLocation(programID, "DepthBiasMVP");
GLuint ShadowMapID = glGetUniformLocation(programID, "shadowMap");
// Get a handle for our "LightPosition" uniform
GLuint lightInvDirID = glGetUniformLocation(programID, "LightInvDirection_worldspace");
//CUBO1
addBox(2,2,2,0,0,0,1.0);
//CUBO2
addBox2(2,2,2,0,6,0,1.0);
//FLOOR
initFloor();
//WALL
initWall();
//BALL
addScene();
do{
world->stepSimulation(1/60.f);
if (glfwGetKey( window, GLFW_KEY_SPACE ) == GLFW_PRESS){
btRigidBody* ball = addBall(1.0,CamGetPosition().x,CamGetPosition().y,CamGetPosition().z,2.0);
ball->setLinearVelocity(btVector3((CamGetDirection().x*50),(CamGetDirection().y*50),(CamGetDirection().z*50)));
}
// Render to our framebuffer
glBindFramebuffer(GL_FRAMEBUFFER, FramebufferName);
glViewport(0,0,1024,1024); // Render on the whole framebuffer, complete from the lower left corner to the upper right
// Clear the screen
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//////////////////////////////
// Use our shader
//SHADOW RENDER
glUseProgram(depthProgramID);
glm::vec3 lightInvDir = glm::vec3(0.5f,2,2);
// Compute the MVP matrix from the light's point of view
glm::mat4 depthProjectionMatrix = glm::ortho<float>(-10,10,-10,10,-10,20);
glm::mat4 depthViewMatrix = glm::lookAt(lightInvDir, glm::vec3(0,0,0), glm::vec3(0,1,0));
// or, for spot light :
//glm::vec3 lightPos(5, 20, 20);
//glm::mat4 depthProjectionMatrix = glm::perspective<float>(45.0f, 1.0f, 2.0f, 50.0f);
//glm::mat4 depthViewMatrix = glm::lookAt(lightPos, lightPos-lightInvDir, glm::vec3(0,1,0));
glm::mat4 depthModelMatrix = glm::mat4(1.0);
glm::mat4 depthMVP = depthProjectionMatrix * depthViewMatrix * depthModelMatrix;
// Send our transformation to the currently bound shader,
// in the "MVP" uniform
glUniformMatrix4fv(depthMatrixID, 1, GL_FALSE, &depthMVP[0][0]);
// CUBE1 -------------------------------------------------------------------------
renderBox(bodies[0],true); //just a cube not really needed
//CUBE2 --------------------------------------------------------------------------
renderBox2(bodies[1],true); //just a cube not really needed
//FLOOR --------------------------------------------------------------------------
renderPlane(bodies[2],true); //floor
//WALL ---------------------------------------------------------------------------
renderWall(bodies[3],true); //back wall
//CASTLE -------------------------------------------------------------------------
renderScene(true); //castle, main scene
//BALL ---------------------------------------------------------------------------
int iv;
for(iv = 4; iv < bodies.size();iv++)
{
renderBall(bodies[iv],(iv - 4),true); //"cannon balls" shooted from the camera
}
//////////////////////////////
//STANDARD RENDER
// Compute the MVP matrix from keyboard and mouse input
// Clear the screen
// Render to the screen
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glViewport(0,0,1024,768); // Render on the whole framebuffer, complete from the lower left corner to the upper right
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Use our shader
glUseProgram(programID);
computeMatricesFromInputs();
glm::mat4 ProjectionMatrix = getProjectionMatrix();
glm::mat4 ViewMatrix = getViewMatrix();
glm::mat4 ModelMatrix = glm::mat4(1.0);
glm::mat4 MVP = ProjectionMatrix * ViewMatrix * ModelMatrix;
glm::mat4 biasMatrix(
0.5, 0.0, 0.0, 0.0,
0.0, 0.5, 0.0, 0.0,
0.0, 0.0, 0.5, 0.0,
0.5, 0.5, 0.5, 1.0
);
glm::mat4 depthBiasMVP = biasMatrix*depthMVP;
// Send our transformation to the currently bound shader,
// in the "MVP" uniform
glUniformMatrix4fv(MatrixID, 1, GL_FALSE, &MVP[0][0]);
glUniformMatrix4fv(ModelMatrixID, 1, GL_FALSE, &ModelMatrix[0][0]);
glUniformMatrix4fv(ViewMatrixID, 1, GL_FALSE, &ViewMatrix[0][0]);
glUniformMatrix4fv(DepthBiasID, 1, GL_FALSE, &depthBiasMVP[0][0]);
glUniform3f(lightInvDirID, lightInvDir.x, lightInvDir.y, lightInvDir.z);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, depthTexture);
glUniform1i(ShadowMapID, 0);
// CUBE1 -------------------------------------------------------------------------
renderBox(bodies[0],false); //just a cube not really needed
//CUBE2 --------------------------------------------------------------------------
renderBox2(bodies[1],false); //just a cube not really needed
//FLOOR --------------------------------------------------------------------------
renderPlane(bodies[2],false); //floor
//WALL ---------------------------------------------------------------------------
renderWall(bodies[3],false); //back wall
//CASTLE -------------------------------------------------------------------------
renderScene(false); //castle, main scene
//BALL ---------------------------------------------------------------------------
// int iv;
for(iv = 4; iv < bodies.size();iv++)
{
renderBall(bodies[iv],(iv - 4),false); //"cannon balls" shooted from the camera
}
/*--------------------------------------------------*/
// Optionally render the shadowmap (for debug only)
// Render only on a corner of the window (or we we won't see the real rendering...)
glViewport(0,0,512,512);
// Use our shader
glUseProgram(quad_programID);
// Bind our texture in Texture Unit 0
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, depthTexture);
// Set our "renderedTexture" sampler to user Texture Unit 0
glUniform1i(texID, 0);
// 1rst attribute buffer : vertices
glEnableVertexAttribArray(0);
glBindBuffer(GL_ARRAY_BUFFER, quad_vertexbuffer);
glVertexAttribPointer(
0, // attribute 0. No particular reason for 0, but must match the layout in the shader.
3, // size
GL_FLOAT, // type
GL_FALSE, // normalized?
0, // stride
(void*)0 // array buffer offset
);
// Draw the triangle !
// You have to disable GL_COMPARE_R_TO_TEXTURE above in order to see anything !
//glDrawArrays(GL_TRIANGLES, 0, 6); // 2*3 indices starting at 0 -> 2 triangles
glDisableVertexAttribArray(0);
/*--------------------------------------------------*/
// Swap buffers
glfwSwapBuffers(window);
glfwPollEvents();
} // Check if the ESC key was pressed or the window was closed
while( glfwGetKey(window, GLFW_KEY_ESCAPE ) != GLFW_PRESS &&
glfwWindowShouldClose(window) == 0 );
deleteALL();
glDeleteProgram(programID);
glDeleteVertexArrays(1, &VertexArrayID);
// Close OpenGL window and terminate GLFW
glfwTerminate();
return 0;
}
void DiaScene::clientMessage(QJsonObject msg, int id)
{
if(msg.contains("resetScene")){
if(current != -1){
scenes.value(order.at(current)).data()->stop();
scenes.value(order.at(current)).data()->start();
}
if(fadingTo != -1){
scenes.value(order.at(fadingTo)).data()->stop();
scenes.value(order.at(fadingTo)).data()->start();
}
sendMsgButNotTo(msg,id,false);
}
if(msg.contains("nextScene")){
next();
sendMsg(getState(false),false);
}
if(msg.contains("currentScene")){
int newId = msg.value("currentScene").toInt(-1);
if(newId != -1 && newId < scenes.count() && newId != current){
newId = order.indexOf(newId);
fadeTimer.restart();
if(fadingTo != -1)
scenes.value(order.at(fadingTo)).data()->stop();
scenes.value(order.at(newId)).data()->start();
fadingTo = newId;
}
sendMsgButNotTo(getState(false),id,false);
}
if(msg.contains("prevScene")){
if(scenes.count() != 0 && current > 0){
fadeTimer.restart();
if(fadingTo != -1)
scenes.value(order.at(fadingTo)).data()->stop();
scenes.value(order.at(current-1)).data()->start();
fadingTo = current - 1;
}
sendMsg(getState(false),false);
}
if(msg.contains("addScene")){
QJsonObject addCmd = msg.value("addScene").toObject();
QSharedPointer<Scene> newScene = builder->build(addCmd.value("type").toString(),addCmd.value("name").toString());
if(newScene.isNull()){
qDebug("duscoScene: ERROR: unknown scene type");
return;
}
addScene(newScene,addCmd.value("name").toString(),"",1.0);
}
if(msg.contains("deleteScene")){
int id = msg.value("deleteScene").toInt(-1);
if(current != -1 && order.at(current) == id){
scenes.value(id).data()->stop();
current = fadingTo == -1 ? -1 : fadingTo;
}
if(fadingTo != -1 && order.at(fadingTo) == id){
scenes.value(id).data()->stop();
fadingTo = -1;
}
if(scenes.contains(id)){
scenes.remove(id);
order.removeAll(id);
}
sendMsg(getState(true),false);
}
if(msg.contains("cloneScene")){
int sceneId = msg.value("cloneScene").toInt(-1);
addScene(QSharedPointer<Dia>(new Dia(scenes.value(sceneId).data()->serialize(builder)
,builder,wss,jack,monitorIo)));
}
if(msg.contains("musicNotification")){
setNextOnMusic(msg.value("musicNotification").toBool(false));
sendMsgButNotTo(msg,id,false);
}
if(msg.contains("orderChanged")){
QJsonArray readOrder = msg.value("orderChanged").toArray();
if(readOrder.size() != order.size()){
qDebug() << "ERROR: incomplete order!";
return;
}
QList<int> newOrder;
int newCurrent = current;
int newFadingTo = fadingTo;
int ctr = 0;
foreach (QJsonValue val, readOrder) {
int i = val.toInt(-1);
qDebug() << "old current:" << current << " --> index:" << order.value(current);
if(i == -1 || i >= order.size()){
qDebug() << "ERROR: invalid item!";
return;
}
if(current != -1 && order.value(current) == i)
newCurrent = ctr;
if(fadingTo != -1 && order.value(fadingTo) == i)
newFadingTo = ctr;
newOrder.append(i);
ctr++;
}
void SceneManager::addSceneJson(std::string fileName, std::string sceneName)
{
addScene(Scene::loadJson(fileName), sceneName);
}
void QSWindow::dropEvent(QDropEvent *event){
qDebug()<<event->mimeData()->data(QString("text/plain"));
addScene();
}
bool World::loadWorld(Common::MacResManager *resMan) {
Common::MacResIDArray resArray;
Common::SeekableReadStream *res;
Common::MacResIDArray::const_iterator iter;
// Dumping interpreter code
#if 1
res = resMan->getResource(MKTAG('C','O','D','E'), 1);
warning("code size: %d", res->size());
byte *buf = (byte *)malloc(res->size());
res->read(buf, res->size());
Common::DumpFile out;
out.open("code.bin");
out.write(buf, res->size());
out.close();
free(buf);
delete res;
#endif
if ((resArray = resMan->getResIDArray(MKTAG('G','C','O','D'))).size() == 0)
return false;
// Load global script
res = resMan->getResource(MKTAG('G','C','O','D'), resArray[0]);
_globalScript = new Script(res);
// TODO: read creator
// Load main configuration
if ((resArray = resMan->getResIDArray(MKTAG('V','E','R','S'))).size() == 0)
return false;
_name = resMan->getBaseFileName();
if (resArray.size() > 1)
warning("Too many VERS resources");
if (!resArray.empty()) {
debug(3, "Loading version info");
res = resMan->getResource(MKTAG('V','E','R','S'), resArray[0]);
res->skip(10);
byte b = res->readByte();
_weaponMenuDisabled = (b != 0);
if (b != 0 && b != 1)
error("Unexpected value for weapons menu");
res->skip(3);
_aboutMessage = readPascalString(res);
if (!scumm_stricmp(resMan->getBaseFileName().c_str(), "Scepters"))
res->skip(1); // ????
_soundLibrary1 = readPascalString(res);
_soundLibrary2 = readPascalString(res);
delete res;
}
Common::String *message;
if ((message = loadStringFromDITL(resMan, 2910, 1)) != NULL) {
message->trim();
debug(2, "_gameOverMessage: %s", message->c_str());
_gameOverMessage = message;
}
if ((message = loadStringFromDITL(resMan, 2480, 3)) != NULL) {
message->trim();
debug(2, "_saveBeforeQuitMessage: %s", message->c_str());
_saveBeforeQuitMessage = message;
}
if ((message = loadStringFromDITL(resMan, 2490, 3)) != NULL) {
message->trim();
debug(2, "_saveBeforeCloseMessage: %s", message->c_str());
_saveBeforeCloseMessage = message;
}
if ((message = loadStringFromDITL(resMan, 2940, 2)) != NULL) {
message->trim();
debug(2, "_revertMessage: %s", message->c_str());
_revertMessage = message;
}
// Load scenes
resArray = resMan->getResIDArray(MKTAG('A','S','C','N'));
debug(3, "Loading %d scenes", resArray.size());
for (iter = resArray.begin(); iter != resArray.end(); ++iter) {
res = resMan->getResource(MKTAG('A','S','C','N'), *iter);
Scene *scene = new Scene(resMan->getResName(MKTAG('A','S','C','N'), *iter), res);
res = resMan->getResource(MKTAG('A','C','O','D'), *iter);
if (res != NULL)
scene->_script = new Script(res);
res = resMan->getResource(MKTAG('A','T','X','T'), *iter);
if (res != NULL) {
scene->_textBounds = readRect(res);
scene->_fontType = res->readUint16BE();
scene->_fontSize = res->readUint16BE();
Common::String text;
while (res->pos() < res->size()) {
char c = res->readByte();
if (c == 0x0d)
c = '\n';
text += c;
}
scene->_text = text;
delete res;
}
addScene(scene);
}
// Load Objects
resArray = resMan->getResIDArray(MKTAG('A','O','B','J'));
debug(3, "Loading %d objects", resArray.size());
for (iter = resArray.begin(); iter != resArray.end(); ++iter) {
res = resMan->getResource(MKTAG('A','O','B','J'), *iter);
addObj(new Obj(resMan->getResName(MKTAG('A','O','B','J'), *iter), res));
}
// Load Characters
resArray = resMan->getResIDArray(MKTAG('A','C','H','R'));
debug(3, "Loading %d characters", resArray.size());
for (iter = resArray.begin(); iter != resArray.end(); ++iter) {
res = resMan->getResource(MKTAG('A','C','H','R'), *iter);
Chr *chr = new Chr(resMan->getResName(MKTAG('A','C','H','R'), *iter), res);
addChr(chr);
// TODO: What if there's more than one player character?
if (chr->_playerCharacter)
_player = chr;
}
// Load Sounds
resArray = resMan->getResIDArray(MKTAG('A','S','N','D'));
debug(3, "Loading %d sounds", resArray.size());
for (iter = resArray.begin(); iter != resArray.end(); ++iter) {
res = resMan->getResource(MKTAG('A','S','N','D'), *iter);
addSound(new Sound(resMan->getResName(MKTAG('A','S','N','D'), *iter), res));
}
if (!_soundLibrary1.empty()) {
loadExternalSounds(_soundLibrary1);
}
if (!_soundLibrary2.empty()) {
loadExternalSounds(_soundLibrary2);
}
// Load Patterns
res = resMan->getResource(MKTAG('P','A','T','#'), 900);
if (res != NULL) {
int count = res->readUint16BE();
debug(3, "Loading %d patterns", count);
for (int i = 0; i < count; i++) {
byte *pattern = (byte *)malloc(8);
res->read(pattern, 8);
_patterns->push_back(pattern);
}
delete res;
} else {
/* Enchanted Scepters did not use the PAT# resource for the textures. */
res = resMan->getResource(MKTAG('C','O','D','E'), 1);
if (res != NULL) {
res->skip(0x55ac);
for (int i = 0; i < 29; i++) {
byte *pattern = (byte *)malloc(8);
res->read(pattern, 8);
_patterns->push_back(pattern);
}
}
delete res;
}
res = resMan->getResource(MKTAG('M','E','N','U'), 2001);
if (res != NULL) {
Common::StringArray *menu = readMenu(res);
_aboutMenuItemName.clear();
Common::String string = menu->operator[](1);
for (uint i = 0; i < string.size() && string[i] != ';'; i++) // Read token
_aboutMenuItemName += string[i];
delete menu;
delete res;
}
res = resMan->getResource(MKTAG('M','E','N','U'), 2004);
if (res != NULL) {
Common::StringArray *menu = readMenu(res);
_commandsMenuName = menu->operator[](0);
_commandsMenu = menu->operator[](1);
delete menu;
delete res;
}
res = resMan->getResource(MKTAG('M','E','N','U'), 2005);
if (res != NULL) {
Common::StringArray *menu = readMenu(res);
_weaponsMenuName = menu->operator[](0);
delete menu;
delete res;
}
// TODO: Read Apple menu and get the name of that menu item..
// store global info in state object for use with save/load actions
//world.setCurrentState(initialState); // pass off the state object to the world
return true;
}
