//define a function that will add a new
// node to an existing binary search tree
NodePointer addNode(NodePointer np, int n){
NodePointer rp = np;
if( np == NULL) {
rp = createRoot(n);
}//if
else if( n < np->value){
if(np->lp == NULL){
np->lp = createRoot(n);
}// if
else {
np->lp = addNode (np->lp,n);
}//else
}//else if
else if (n > np->value){
if( np->rp == NULL){
np->rp = createRoot( n );
}//if
else{
np->rp = addNode(np->rp, n);
}//else
}//else if
else {
///if values to be added is already in tree, do nothing
//do not add duplicate values to tree
}//else
return rp;
}//addNode
TrieNode & buildTrieFromDict(ifstream & dictFile) {
/*
* while not end of file
* file get line to string
* prepend the word with '*', append the word with '\0'
* insert word to trie
* if faile to insert
* output error message break and return
*
* current node = root
* charIndex = string head
*/
int indexStr = 0;
string word;
TrieNode & root = createRoot();
while (!dictFile.eof()) {
getline(dictFile, word);
word.push_back(END_OF_WORD);
if (insertWord(root, word) == false) {
cout << "memory runs out" << endl;
break;
}
}
return root;
}
void CineSeq01::create()
{
createRoot("cineSeq01", SEQUENCE, NULL, NULL);
addChild("cineSeq01", "cineCam1", ACTION, NULL, (btaction)&CineSeq01::cineCam1);
addChild("cineSeq01", "playerBirth", ACTION, NULL, (btaction)&CineSeq01::playerBirth);
addChild("cineSeq01", "die", ACTION, NULL, (btaction)&CineSeq01::die);
}
void chanFileSystemDockWidget::init() {
createWidgets();
createContextMenu();
createFileSystemTree();
createRoot();
}
void MusicXMLConfigManager::writeMusicSongsConfig(const MusicSongsList &musics)
{
if( musics.isEmpty() )
{
return;
}
//Open wirte file
if( !writeConfig(MUSICPATH_AL) )
{
return;
}
///////////////////////////////////////////////////////
createProcessingInstruction();
QDomElement musicPlayer = createRoot("TTKMusicPlayer");
//Class A
QDomElement fileNormalPath = writeDomElement(musicPlayer, "fileNormalPath", "count", musics[0].count());
QDomElement fileLovestPath = writeDomElement(musicPlayer, "fileLovestPath", "count", musics[1].count());
QDomElement netFilePath = writeDomElement(musicPlayer, "netFilePath", "count", musics[2].count());
//extend playlist init here
// for(int i=3; i<fileNamesList.count(); ++i)
// {
// QDomElement extend = m_ddom->createElement("extend" + QString::number(i - 2));
// extend.setAttribute("count",fileNamesList[i].count());
// TTKMusicPlayer.appendChild(extend);
// }
//Class B
foreach(MusicSong song, musics[0])
{
writeDomElementMutilText(fileNormalPath, "value", QStringList() << "name" << "playCount" << "time",
QList<QVariant>() << song.getMusicName() << song.getMusicPlayCount()
<< song.getMusicTime(), song.getMusicPath());
}
void createRestoreOptions(Volume* volume, const char *optionsPlist, int SystemPartitionSize, int UpdateBaseband) {
AbstractFile* plistFile;
Dictionary* info;
char* plist;
HFSPlusCatalogRecord* record;
info = NULL;
record = getRecordFromPath(optionsPlist, volume, NULL, NULL);
if(record != NULL && record->recordType == kHFSPlusFileRecord) {
HFSPlusCatalogFile* file = (HFSPlusCatalogFile*)record;
size_t bufferSize = 512;
plist = malloc(bufferSize);
plistFile = createAbstractFileFromMemory((void**)&plist, bufferSize);
if (plistFile) {
char zero = 0;
writeToFile(file, plistFile, volume);
plistFile->write(plistFile, &zero, sizeof(zero));
plistFile->close(plistFile);
info = createRoot(plist);
removeKey(info, "CreateFilesystemPartitions");
removeKey(info, "SystemPartitionSize");
removeKey(info, "UpdateBaseband");
removeKey(info, "MinimumSystemPartition");
addIntegerToDictionary(info, "MinimumSystemPartition", SystemPartitionSize);
XLOG(0, "got %s from ramdisk\n", optionsPlist);
}
free(plist);
}
XLOG(0, "start create restore options\n");
if (!info) info = createRoot("<dict></dict>");
addBoolToDictionary(info, "CreateFilesystemPartitions", TRUE);
addIntegerToDictionary(info, "SystemPartitionSize", SystemPartitionSize);
addBoolToDictionary(info, "UpdateBaseband", UpdateBaseband);
plist = getXmlFromRoot(info);
releaseDictionary(info);
XLOG(0, "%s", plist);
plistFile = createAbstractFileFromMemory((void**)&plist, sizeof(char) * strlen(plist));
add_hfs(volume, plistFile, optionsPlist);
free(plist);
}
StorageTreeModel::StorageTreeModel(const QString &data, QObject *parent) :
QAbstractItemModel(parent)
{
_dataIsChanged = false;
_editable = false;
_mol = 7;
createRoot();
}
//Application initialisation
void Application::initialise()
{
createRoot();
defineResources();
setupRenderSystem();
createRenderWindow();
initialiseResourceGroups();
setupScene();
setupInputSystem();
}
int main()
{
createRoot (0);
root->left = create(1);
root->right = create(2);
root->left->left = create(3);
root->left->right = create(5);
root->right->right = create(4);
//print_inorder(root);
}
void BPlusIndexP::splitAddLeaf(IndexPage* page, Index* index) {
Logger* log = getLogger(NULL);
//temporal arrays
Index** tmpelements = (Index**)malloc(sizeof(Index*) * (BUCKET_MAX_ELEMENTS + 1));
//IndexPage** tmppointers = (IndexPage**)malloc(sizeof(IndexPage*) * (BUCKET_MAX_ELEMENTS + 2));
initializeArray((void**)tmpelements, BUCKET_MAX_ELEMENTS);
copyArray((void**)page->elements, (void**)tmpelements, 0, BUCKET_MAX_ELEMENTS - 1, 0);
int posToInsert = findInsertPositionArray(tmpelements, index, page->size, BUCKET_MAX_ELEMENTS);
insertArray((void**)tmpelements, index, posToInsert, BUCKET_MAX_ELEMENTS + 1);
// clean the previous "left"
initializeArray((void**)page->elements, BUCKET_MAX_ELEMENTS);
IndexPage* rightPage = new IndexPage();
int midPoint = (BUCKET_MAX_ELEMENTS / 2);
copyArray((void**)tmpelements, (void**)page->elements, 0, midPoint, 0);
page->size = (BUCKET_MAX_ELEMENTS / 2) + 1;
// Clean up the elements moved to the rightPage
for (int x = page->size; x < BUCKET_MAX_ELEMENTS; x++) {
page->elements[x] = NULL;
page->pointers[x + 1] = NULL;
}
// cleans the last one
page->pointers[BUCKET_MAX_ELEMENTS] = NULL;
refreshParentRelationship(page);
//copyArray((void**)tmppointers, (void**)page->pointers, 0, midPoint + 1, 0);
copyArray((void**)tmpelements, (void**)rightPage->elements, midPoint + 1, BUCKET_MAX_ELEMENTS, 0);
rightPage->size = (BUCKET_MAX_ELEMENTS / 2) + 1;
refreshParentRelationship(rightPage);
//copyArray((void**)tmppointers, (void**)rightPage->pointers, midPoint + 2, BUCKET_MAX_ELEMENTS + 2, 0);
// Promotion
IndexPage* parentElement = page->parentElement;
Index* copyElement = new Index(*rightPage->elements[0]);
if (parentElement == NULL) {
createRoot(copyElement, page, rightPage);
} else {
addElement(parentElement, copyElement, rightPage);
}
parentElement = rightPage->parentElement;
free(tmpelements);
refreshParentRelationship(parentElement);
persistPage(page);
persistPage(rightPage);
persistPage(page->parentElement);
}
void BPlusIndex::splitAddInner(IndexPage* page, Index* index, IndexPage* rightPage) {
Logger* log = getLogger(NULL);
//temporal arrays
Index** tmpelements = (Index**)malloc(sizeof(Index*) * (BUCKET_MAX_ELEMENTS + 1));
IndexPage** tmppointers = (IndexPage**)malloc(sizeof(IndexPage*) * (BUCKET_MAX_ELEMENTS + 2));
initializeArray((void**)tmpelements, BUCKET_MAX_ELEMENTS);
initializeArray((void**)tmppointers, BUCKET_MAX_ELEMENTS + 1);
copyArray((void**)page->elements, (void**)tmpelements, 0, BUCKET_MAX_ELEMENTS - 1, 0);
copyArray((void**)page->pointers, (void**)tmppointers, 0, BUCKET_MAX_ELEMENTS, 0);
int posToInsert = findInsertPositionArray(tmpelements, index, page->size, BUCKET_MAX_ELEMENTS);
insertArray((void**)tmpelements, index, posToInsert, BUCKET_MAX_ELEMENTS + 1);
insertArray((void**)tmppointers, rightPage, posToInsert + 1, BUCKET_MAX_ELEMENTS + 2);
// clean the previous "left"
initializeArray((void**)page->elements, BUCKET_MAX_ELEMENTS);
initializeArray((void**)page->pointers, BUCKET_MAX_ELEMENTS + 1);
IndexPage* newRightPage = new IndexPage();
int midPoint = (BUCKET_MAX_ELEMENTS / 2);
copyArray((void**)tmpelements, (void**)page->elements, 0, midPoint, 0);
copyArray((void**)tmppointers, (void**)page->pointers, 0, midPoint + 1, 0);
page->size = (BUCKET_MAX_ELEMENTS / 2) + 1;
copyArray((void**)tmpelements, (void**)newRightPage->elements, midPoint + 1, BUCKET_MAX_ELEMENTS, 0);
copyArray((void**)tmppointers, (void**)newRightPage->pointers, midPoint + 2, BUCKET_MAX_ELEMENTS + 1, 1);
newRightPage->size = (BUCKET_MAX_ELEMENTS / 2) + 1;
refreshParentRelationship(newRightPage);
// Promotion
IndexPage* parentElement = page->parentElement;
Index* element = newRightPage->elements[0];
if (parentElement == NULL) {
createRoot(element, page, newRightPage);
parentElement = _head;
} else {
addElement(parentElement, element, newRightPage);
}
shiftLeftArray((void**)newRightPage->elements, 0, 1, BUCKET_MAX_ELEMENTS - 1);
shiftLeftArray((void**)newRightPage->pointers, 0, 1, BUCKET_MAX_ELEMENTS);
newRightPage->size--;
refreshParentRelationship(parentElement);
free(tmpelements);
free(tmppointers);
}
Interaction::CommandResult* CCreateClass::create(Visualization::Item* /*source*/, Visualization::Item* target,
const QString& name, const QStringList& attributes)
{
auto pr = dynamic_cast<OOModel::Project*> (target->node());
OOModel::Class* cl = nullptr;
bool newModel = false;
if (pr)
{
cl = new OOModel::Class();
if (!name.isEmpty()) cl->setName(name);
// Set visibility
if (attributes.first() == "private" ) cl->setVisibility(OOModel::Visibility::PRIVATE);
else if (attributes.first() == "protected" ) cl->setVisibility(OOModel::Visibility::PROTECTED);
else if (attributes.first() == "public" ) cl->setVisibility(OOModel::Visibility::PUBLIC);
else cl->setVisibility(OOModel::Visibility::DEFAULT);
pr->beginModification("create class");
pr->classes()->append(cl);
pr->endModification();
}
else
{
newModel = true;
auto model = new Model::Model();
cl = dynamic_cast<OOModel::Class*> (model->createRoot("Class"));
cl->beginModification("set project name");
if (!name.isEmpty()) cl->setName(name);
// Set visibility
if (attributes.first() == "private" ) cl->setVisibility(OOModel::Visibility::PRIVATE);
else if (attributes.first() == "protected" ) cl->setVisibility(OOModel::Visibility::PROTECTED);
else if (attributes.first() == "public" ) cl->setVisibility(OOModel::Visibility::PUBLIC);
else cl->setVisibility(OOModel::Visibility::DEFAULT);
cl->endModification();
target->scene()->addTopLevelItem( new Visualization::RootItem(cl) );
target->scene()->listenToModel(model);
}
target->setUpdateNeeded(Visualization::Item::StandardUpdate);
if (newModel) target->scene()->addPostEventAction(new Interaction::SetCursorEvent(target->scene(), cl,
Interaction::SetCursorEvent::CursorDefault, true));
else target->scene()->addPostEventAction(new Interaction::SetCursorEvent(target, cl,
Interaction::SetCursorEvent::CursorDefault, true));
return new Interaction::CommandResult();
}
// define a function that will add a new
// node to an existing binary search tree
NodePointer addNode( NodePointer np, int n ) {
NodePointer rp = np;
if( np == NULL ) rp = createRoot( n );
else if( n < (*np).value ) {
if( (*np).lp == NULL ) (*np).lp = createRoot( n );
else (*np).lp = addNode( (*np).lp, n );
} // elseif
else if( n > (*np).value ) {
if( (*np).rp == NULL ) (*np).rp = createRoot( n );
else (*np).rp = addNode( (*np).rp, n );
}
else {
// if value to be added is already in tree, do nothing
// (do not add duplicate values to tree)
}
return rp;
} // addNode
int main(int argc, char **argv) {
int nodeCount;
int cleaning=0;
if (argc < 4) {
usage(argv);
}
if(strcmp("clean",argv[3])==0){
cleaning=1;
}
zoo_set_debug_level(ZOO_LOG_LEVEL_INFO);
zoo_deterministic_conn_order(1); // enable deterministic order
zh = zookeeper_init(argv[1], listener, 10000, 0, 0, 0);
if (!zh)
return errno;
LOG_INFO(LOGSTREAM, "Checking server connection...");
ensureConnected();
if(cleaning==1){
int rc = 0;
deletedCounter=0;
rc=recursiveDelete(argv[2]);
if(rc==ZOK){
LOG_INFO(LOGSTREAM, "Successfully deleted a subtree starting at %s (%d nodes)",
argv[2],deletedCounter);
exit(0);
}
exit(1);
}
nodeCount=atoi(argv[3]);
createRoot(argv[2]);
while(1) {
ensureConnected();
LOG_INFO(LOGSTREAM, "Creating children for path %s",argv[2]);
doCreateNodes(argv[2],nodeCount);
waitCounter();
LOG_INFO(LOGSTREAM, "Starting the write cycle for path %s",argv[2]);
doWrites(argv[2],nodeCount);
waitCounter();
LOG_INFO(LOGSTREAM, "Starting the read cycle for path %s",argv[2]);
doReads(argv[2],nodeCount);
waitCounter();
LOG_INFO(LOGSTREAM, "Starting the delete cycle for path %s",argv[2]);
doDeletes(argv[2],nodeCount);
waitCounter();
}
zookeeper_close(zh);
return 0;
}
ddModelBrowser::ddModelBrowser(wxWindow *parent, wxWindowID id, const wxPoint &pos, const wxSize &size, long style, ddDatabaseDesign *design)
: wxTreeCtrl(parent, id, pos, size, style)
{
ownerDesign = design;
rootNode = (wxTreeItemId *)NULL;
createRoot(_("Database Design"));
// Create normal images list of browser
// Remember to update enum gqbImages in ddModelBrowser.h if changing the images!!
imageList = new wxImageList(16, 16);
imageList->Add(*database_sm_png_ico);
imageList->Add(*table_sm_png_ico);
this->AssignImageList(imageList);
}
void fixupBootNeuterArgs(Volume* volume, char unlockBaseband, char selfDestruct, char use39, char use46) {
const char bootNeuterPlist[] = "/System/Library/LaunchDaemons/com.devteam.bootneuter.auto.plist";
AbstractFile* plistFile;
char* plist;
Dictionary* info;
size_t bufferSize;
ArrayValue* arguments;
XLOG(0, "fixing up BootNeuter arguments...\n");
plist = malloc(1);
bufferSize = 0;
plistFile = createAbstractFileFromMemoryFile((void**)&plist, &bufferSize);
get_hfs(volume, bootNeuterPlist, plistFile);
plistFile->close(plistFile);
info = createRoot(plist);
free(plist);
arguments = (ArrayValue*) getValueByKey(info, "ProgramArguments");
addStringToArray(arguments, "-autoMode");
addStringToArray(arguments, "YES");
addStringToArray(arguments, "-RegisterForSystemEvents");
addStringToArray(arguments, "YES");
if(unlockBaseband) {
addStringToArray(arguments, "-unlockBaseband");
addStringToArray(arguments, "YES");
}
if(selfDestruct) {
addStringToArray(arguments, "-selfDestruct");
addStringToArray(arguments, "YES");
}
if(use39) {
addStringToArray(arguments, "-bootLoader");
addStringToArray(arguments, "3.9");
} else if(use46) {
addStringToArray(arguments, "-bootLoader");
addStringToArray(arguments, "4.6");
}
plist = getXmlFromRoot(info);
releaseDictionary(info);
plistFile = createAbstractFileFromMemory((void**)&plist, sizeof(char) * strlen(plist));
add_hfs(volume, plistFile, bootNeuterPlist);
free(plist);
}
int main(int argc, char** argv){
//build a BST that contains integers found on the command line
//then print the integers in ascending order
if(argc > 1){
NodePointer rp = createRoot( atoi (argv[1]));
int i;
for( i = 2; i < argc; i++){
rp = addNode( rp , atoi(argv[i]));
}//for
printNodes(rp);
} //if
exit(0);
} //main(int, char**)
//-------------------------------------------------------------------------------------
//Main function for the setup runs all different setup sequences
bool OGREBase::setup(void)
{
createRoot();
loadConfig();
addOverlay();
if (!generateRenderWindow()) return false;
createSceneBase();
createScene();
createCamera();
createViewports();
startOIS();
initSDKTray();
finalTouch();
return true;
}
Dictionary *createDictionaryFromAbstractFile(AbstractFile * file)
{
char *plist = (char *)malloc(file->getLength(file));
Dictionary *dict;
if (plist == NULL) {
fprintf(stderr, "Unable to allocate sufficent memory\n");
return NULL;
}
file->read(file, plist, file->getLength(file));
file->close(file);
dict = createRoot(plist);
free(plist);
return dict;
}
void MusicDownloadRecordConfigManager::writeDownloadConfig(const MusicDownloadRecords &records)
{
if(!writeConfig(mappingFilePathFromEnum()))
{
return;
}
///////////////////////////////////////////////////////
createProcessingInstruction();
QDomElement musicPlayer = createRoot(APPNAME);
QDomElement download = writeDom(musicPlayer, "download");
foreach(const MusicDownloadRecord &record, records)
{
writeDomElementMutilText(download, "value", MusicXmlAttributes() << MusicXmlAttribute("name", record.m_name)
<< MusicXmlAttribute("size", record.m_size)
<< MusicXmlAttribute("time", record.m_time), record.m_path);
}
void DownloadBreakPointConfigManager::writeBreakPointConfig(const DownloadBreakPointItems &records)
{
///////////////////////////////////////////////////////
createProcessingInstruction();
QDomElement player = createRoot(APPNAME);
QDomElement download = writeDom(player, "breakPoint");
if(!records.isEmpty())
{
writeDomText(download, "url", records.first().m_url);
}
foreach(const DownloadBreakPointItem &record, records)
{
writeDomElementMutil(download, "value", DownloadXmlAttributes() <<
DownloadXmlAttribute("start", record.m_start) <<
DownloadXmlAttribute("end", record.m_end) <<
DownloadXmlAttribute("ready", record.m_ready) );
}
struct node *primaryLabels(struct node *root, int value){
struct node *current = root;
struct node *newNode = NULL;
newNode = createRoot(newNode, value);
if (current->label > value) {
newNode->next = current;
root = newNode;
}
else{
while (current->next != NULL && current->next->label < value) {
current = current->next;
}
newNode->next = current->next;
current->next = newNode;
}
return root;
}
void MusicMyDownloadRecordConfigManager::writeDownloadConfig(const MusicDownloadRecord &record)
{
if( !writeConfig( DOWNLOADINFO_FULL ) )
{
return;
}
///////////////////////////////////////////////////////
createProcessingInstruction();
QDomElement musicPlayer = createRoot("TTKMusicPlayer");
QDomElement download = writeDom(musicPlayer, "download");
for(int i=0; i<record.m_names.count(); ++i)
{
writeDomElementMutilText(download, "value", QStringList()<<"name"<<"size",
QList<QVariant>()<<record.m_names[i]<<record.m_sizes[i],
record.m_paths[i]);
}
//Write to file
QTextStream out(m_file);
m_ddom->save(out, 4);
}
void MusicUserConfigManager::writeUserXMLConfig(const MusicUserRecord &record)
{
if( !writeConfig( USERPATH_AL ) )
{
return;
}
///////////////////////////////////////////////////////
createProcessingInstruction();
QDomElement musicPlayer = createRoot("QMusicPlayer");
for(int i=0; i<record.m_names.count(); ++i)
{
writeDomElementMutilText(musicPlayer, "username", QStringList()<<"name"<<"userRp"<<"userAl",
QList<QVariant>()<<record.m_names[i]<<record.m_rps[i]<<record.m_als[i],
record.m_pwds[i]);
}
//Write to file
QTextStream out(m_file);
m_ddom->save(out, 4);
}
OgreInitializer::OgreInitializer(
const Ogre::String &base_path,
bool create_,
const Ogre::String &plugins,
const Ogre::String &config,
const Ogre::String &log_)
{
mRoot = nullptr;
mWindow = nullptr;
mCreated = false;
#if OGRE_PLATFORM == OGRE_PLATFORM_APPLE
mResourcesPath = Ogre::macBundlePath() + "/Contents/Resources/" + base_path;
#else
mResourcesPath = base_path;
#endif
if (create_)
createRoot(plugins, config, log_);
oldCOUTStreamBuf = std::cout.rdbuf();
oldCERRStreamBuf = std::cerr.rdbuf();
mConsole = new OgreConsole(false);
}
void MusicLocalSongSearchRecordObject::writeSearchConfig(const MusicSearchRecord &record)
{
if( !writeConfig( MUSICSEARCH_AL ) )
{
return;
}
///////////////////////////////////////////////////////
createProcessingInstruction();
QDomElement musicPlayer = createRoot("QMusicPlayer");
QDomElement download = writeDom(musicPlayer, "searchRecord");
for(int i=0; i<record.m_names.count(); ++i)
{
writeDomElementText(download, "value", "name",
record.m_names[i], record.m_times[i]);
}
//Write to file
QTextStream out(m_file);
m_ddom->save(out, 4);
}
void ddModelBrowser::refreshFromModel()
{
this->DeleteAllItems();
createRoot(_("Database Design"));
hdIteratorBase *iterator = ownerDesign->getEditor()->modelFiguresEnumerator();
hdIFigure *tmpFigure;
ddTableFigure *table;
while(iterator->HasNext())
{
tmpFigure = (hdIFigure *)iterator->Next();
if(tmpFigure->getKindId() == DDTABLEFIGURE)
{
table = (ddTableFigure *)tmpFigure;
this->AppendItem(rootNode, table->getTableName(), DD_IMG_FIG_TABLE, DD_IMG_FIG_TABLE, new ddBrowserDataContainer(table));
}
}
delete iterator;
this->Expand(rootNode);
this->SortChildren(rootNode);
}
/**
* init begginning scene
*/
static void initSceneBeginning(){
GLfloat up[3];
// create root node
beginning[E_B_ROOT] = createRoot();
GLfloat LightAmbient[] = {0.0f, 0.0f, 0.0f, 1.0f};
GLfloat LightDiffuse[] = {1.0f, 1.0f, 1.0f, 1.0f};
GLfloat LightSpecular[] = {1.0f, 1.0f, 1.0f, 1.0f};
GLfloat LightPosition[] = {15.0f, 15.0f, 15.0f, 1.0f};
GLfloat LightTargetPoint[] = {0.0, 0.0, 0.0};
GLfloat lightCutOff = 30.0;
setLight(beginning[E_B_ROOT], LightAmbient, LightDiffuse, LightSpecular, LightPosition, LightTargetPoint, lightCutOff);
// setup camera
beginning[E_B_CAM_1_CURVE] = createCurve(beginning[E_B_ROOT], NULL, NULL, 0, 0);
up[0] = 0; up[1] = 0; up[2] = 1;
beginning[E_B_CAM_1] = createCamera(beginning[E_B_CAM_1_CURVE], 50, 1, 10000, up, NULL, 0, 0);
// add models
// body - dependent on root
beginning[E_B_PIANO_BODY] = createMesh(beginning[E_B_ROOT], E_MESH_PIANO_BODY, E_MAT_PIANO_BODY);
// bench - dependent on root
beginning[E_B_PIANO_BENCH] = createMesh(beginning[E_B_ROOT], E_MESH_PIANO_BENCH, E_MAT_PIANO_BODY);
// strings - dependent on body
beginning[E_B_PIANO_STRINGS] = createMesh(beginning[E_B_PIANO_BODY], E_MESH_PIANO_STRINGS, E_MAT_PIANO_STRINGS);
// keys - dependent on body
for (int i = 0; i < 9; ++i){
beginning[E_B_PIANO_C0 + 0 + i * 11] = createMesh(beginning[E_B_PIANO_BODY], E_MESH_PIANO_WHITE_KEY, E_MAT_PIANO_WHITE_KEY); // C sharp
translateNode(beginning[E_B_PIANO_C0 + 0 + i * 11], -0.1875 * 0 + (-0.1875 * 7 * i), 0, 0);
beginning[E_B_PIANO_C0 + 1 + i * 11] = createMesh(beginning[E_B_PIANO_BODY], E_MESH_PIANO_BLACK_KEY, E_MAT_PIANO_BLACK_KEY); // C flat
translateNode(beginning[E_B_PIANO_C0 + 1 + i * 11], -0.1875 * 0 + (-0.1875 * 7 * i), 0, 0);
beginning[E_B_PIANO_C0 + 2 + i * 11] = createMesh(beginning[E_B_PIANO_BODY], E_MESH_PIANO_WHITE_KEY, E_MAT_PIANO_WHITE_KEY); // D sharp
translateNode(beginning[E_B_PIANO_C0 + 2 + i * 11], -0.1875 * 1 + (-0.1875 * 7 * i), 0, 0);
beginning[E_B_PIANO_C0 + 3 + i * 11] = createMesh(beginning[E_B_PIANO_BODY], E_MESH_PIANO_BLACK_KEY, E_MAT_PIANO_BLACK_KEY); // D flat
translateNode(beginning[E_B_PIANO_C0 + 3 + i * 11], -0.1875 * 1 + (-0.1875 * 7 * i), 0, 0);
beginning[E_B_PIANO_C0 + 4 + i * 11] = createMesh(beginning[E_B_PIANO_BODY], E_MESH_PIANO_WHITE_KEY, E_MAT_PIANO_WHITE_KEY); // E sharp
translateNode(beginning[E_B_PIANO_C0 + 4 + i * 11], -0.1875 * 2 + (-0.1875 * 7 * i), 0, 0);
beginning[E_B_PIANO_C0 + 5 + i * 11] = createMesh(beginning[E_B_PIANO_BODY], E_MESH_PIANO_WHITE_KEY, E_MAT_PIANO_WHITE_KEY); // F sharp
translateNode(beginning[E_B_PIANO_C0 + 5 + i * 11], -0.1875 * 3 + (-0.1875 * 7 * i), 0, 0);
beginning[E_B_PIANO_C0 + 6 + i * 11] = createMesh(beginning[E_B_PIANO_BODY], E_MESH_PIANO_BLACK_KEY, E_MAT_PIANO_BLACK_KEY); // F flat
translateNode(beginning[E_B_PIANO_C0 + 6 + i * 11], -0.1875 * 3 + (-0.1875 * 7 * i), 0, 0);
beginning[E_B_PIANO_C0 + 7 + i * 11] = createMesh(beginning[E_B_PIANO_BODY], E_MESH_PIANO_WHITE_KEY, E_MAT_PIANO_WHITE_KEY); // G sharp
translateNode(beginning[E_B_PIANO_C0 + 7 + i * 11], -0.1875 * 4 + (-0.1875 * 7 * i), 0, 0);
beginning[E_B_PIANO_C0 + 8 + i * 11] = createMesh(beginning[E_B_PIANO_BODY], E_MESH_PIANO_BLACK_KEY, E_MAT_PIANO_BLACK_KEY); // G flat
translateNode(beginning[E_B_PIANO_C0 + 8 + i * 11], -0.1875 * 4 + (-0.1875 * 7 * i), 0, 0);
beginning[E_B_PIANO_C0 + 9 + i * 11] = createMesh(beginning[E_B_PIANO_BODY], E_MESH_PIANO_WHITE_KEY, E_MAT_PIANO_WHITE_KEY); // A sharp
translateNode(beginning[E_B_PIANO_C0 + 9 + i * 11], -0.1875 * 5 + (-0.1875 * 7 * i), 0, 0);
beginning[E_B_PIANO_C0 + 10 + i * 11] = createMesh(beginning[E_B_PIANO_BODY], E_MESH_PIANO_BLACK_KEY, E_MAT_PIANO_BLACK_KEY); // A flat
translateNode(beginning[E_B_PIANO_C0 + 10 + i * 11], -0.1875 * 5 + (-0.1875 * 7 * i), 0, 0);
beginning[E_B_PIANO_C0 + 11 + i * 11] = createMesh(beginning[E_B_PIANO_BODY], E_MESH_PIANO_WHITE_KEY, E_MAT_PIANO_WHITE_KEY); // B sharp
translateNode(beginning[E_B_PIANO_C0 + 11 + i * 11], -0.1875 * 6 + (-0.1875 * 7 * i), 0, 0);
}
// ground - dependent on root
beginning[E_B_GROUND] = createMesh(beginning[E_B_ROOT], E_MESH_GROUND, E_MAT_GROUND);
// texts
// author's name
beginning[E_B_NAME] = createDummy(beginning[E_B_ROOT]);
translateNode(beginning[E_B_NAME], -6, -600, 600);
rotateNodeDeg(beginning[E_B_NAME], -45, 0, 0);
beginning[E_B_NAME0] = createMesh(beginning[E_B_NAME], E_MESH_ALPHABET_T, E_MAT_TEXT); // T
translateNode(beginning[E_B_NAME0], 1, 0, 0);
beginning[E_B_NAME1] = createMesh(beginning[E_B_NAME0], E_MESH_ALPHABET_O, E_MAT_TEXT); // O
translateNode(beginning[E_B_NAME1], 1, 0, 0);
beginning[E_B_NAME2] = createMesh(beginning[E_B_NAME1], E_MESH_ALPHABET_M, E_MAT_TEXT); // M
translateNode(beginning[E_B_NAME2], 1, 0, 0);
beginning[E_B_NAME3] = createMesh(beginning[E_B_NAME2], E_MESH_ALPHABET_A, E_MAT_TEXT); // A
beginning[E_B_NAME4] = createMesh(beginning[E_B_NAME3], E_MESH_ALPHABET_CARKA, E_MAT_TEXT); // '
translateNode(beginning[E_B_NAME3], 1, 0, 0);
beginning[E_B_NAME5] = createMesh(beginning[E_B_NAME4], E_MESH_ALPHABET_S, E_MAT_TEXT); // S
beginning[E_B_NAME6] = createMesh(beginning[E_B_NAME5], E_MESH_ALPHABET_HACEK, E_MAT_TEXT); // ˇ
translateNode(beginning[E_B_NAME5], 1, 0, 0);
beginning[E_B_NAME7] = createMesh(beginning[E_B_NAME4], E_MESH_ALPHABET_M, E_MAT_TEXT); // M
translateNode(beginning[E_B_NAME7], 3, 0, 0);
beginning[E_B_NAME8] = createMesh(beginning[E_B_NAME7], E_MESH_ALPHABET_A, E_MAT_TEXT); // A
translateNode(beginning[E_B_NAME8], 1, 0, 0);
beginning[E_B_NAME9] = createMesh(beginning[E_B_NAME8], E_MESH_ALPHABET_R, E_MAT_TEXT); // R
translateNode(beginning[E_B_NAME9], 1, 0, 0);
beginning[E_B_NAME10] = createMesh(beginning[E_B_NAME9], E_MESH_ALPHABET_E, E_MAT_TEXT); // E
translateNode(beginning[E_B_NAME10], 1, 0, 0);
beginning[E_B_NAME11] = createMesh(beginning[E_B_NAME10], E_MESH_ALPHABET_K, E_MAT_TEXT); // K
translateNode(beginning[E_B_NAME11], 1, 0, 0);
// school
beginning[E_B_SCHOOL] = createDummy(beginning[E_B_ROOT]);
translateNode(beginning[E_B_SCHOOL], -14.9, -500, 500);
rotateNodeDeg(beginning[E_B_SCHOOL], -45, 0, 0);
beginning[E_B_SCHOOL0] = createMesh(beginning[E_B_SCHOOL], E_MESH_ALPHABET_B, E_MAT_TEXT); // B
translateNode(beginning[E_B_SCHOOL0], 1, 0, 0);
beginning[E_B_SCHOOL1] = createMesh(beginning[E_B_SCHOOL0], E_MESH_ALPHABET_R, E_MAT_TEXT); // R
translateNode(beginning[E_B_SCHOOL1], 1, 0, 0);
beginning[E_B_SCHOOL2] = createMesh(beginning[E_B_SCHOOL1], E_MESH_ALPHABET_N, E_MAT_TEXT); // N
translateNode(beginning[E_B_SCHOOL2], 1, 0, 0);
beginning[E_B_SCHOOL3] = createMesh(beginning[E_B_SCHOOL2], E_MESH_ALPHABET_O, E_MAT_TEXT); // O
translateNode(beginning[E_B_SCHOOL3], 1, 0, 0);
beginning[E_B_SCHOOL4] = createMesh(beginning[E_B_SCHOOL3], E_MESH_ALPHABET_U, E_MAT_TEXT); // U
translateNode(beginning[E_B_SCHOOL4], 2, 0, 0);
beginning[E_B_SCHOOL5] = createMesh(beginning[E_B_SCHOOL4], E_MESH_ALPHABET_N, E_MAT_TEXT); // N
translateNode(beginning[E_B_SCHOOL5], 1, 0, 0);
beginning[E_B_SCHOOL6] = createMesh(beginning[E_B_SCHOOL5], E_MESH_ALPHABET_I, E_MAT_TEXT); // I
translateNode(beginning[E_B_SCHOOL6], 0.8, 0, 0);
beginning[E_B_SCHOOL7] = createMesh(beginning[E_B_SCHOOL6], E_MESH_ALPHABET_V, E_MAT_TEXT); // V
translateNode(beginning[E_B_SCHOOL7], 0.8, 0, 0);
beginning[E_B_SCHOOL8] = createMesh(beginning[E_B_SCHOOL7], E_MESH_ALPHABET_E, E_MAT_TEXT); // E
translateNode(beginning[E_B_SCHOOL8], 1, 0, 0);
beginning[E_B_SCHOOL9] = createMesh(beginning[E_B_SCHOOL8], E_MESH_ALPHABET_R, E_MAT_TEXT); // R
translateNode(beginning[E_B_SCHOOL9], 1, 0, 0);
beginning[E_B_SCHOOL10] = createMesh(beginning[E_B_SCHOOL9], E_MESH_ALPHABET_S, E_MAT_TEXT); // S
translateNode(beginning[E_B_SCHOOL10], 1, 0, 0);
beginning[E_B_SCHOOL11] = createMesh(beginning[E_B_SCHOOL10], E_MESH_ALPHABET_I, E_MAT_TEXT); // I
translateNode(beginning[E_B_SCHOOL11], 0.8, 0, 0);
beginning[E_B_SCHOOL12] = createMesh(beginning[E_B_SCHOOL11], E_MESH_ALPHABET_T, E_MAT_TEXT); // T
translateNode(beginning[E_B_SCHOOL12], 0.8, 0, 0);
beginning[E_B_SCHOOL13] = createMesh(beginning[E_B_SCHOOL12], E_MESH_ALPHABET_Y, E_MAT_TEXT); // Y --
translateNode(beginning[E_B_SCHOOL13], 1, 0, 0);
beginning[E_B_SCHOOL14] = createMesh(beginning[E_B_SCHOOL13], E_MESH_ALPHABET_O, E_MAT_TEXT); // O
translateNode(beginning[E_B_SCHOOL14], 2, 0, 0);
beginning[E_B_SCHOOL15] = createMesh(beginning[E_B_SCHOOL14], E_MESH_ALPHABET_F, E_MAT_TEXT); // F
translateNode(beginning[E_B_SCHOOL15], 1, 0, 0);
beginning[E_B_SCHOOL16] = createMesh(beginning[E_B_SCHOOL15], E_MESH_ALPHABET_T, E_MAT_TEXT); // T
translateNode(beginning[E_B_SCHOOL16], 2, 0, 0);
beginning[E_B_SCHOOL17] = createMesh(beginning[E_B_SCHOOL16], E_MESH_ALPHABET_E, E_MAT_TEXT); // E
translateNode(beginning[E_B_SCHOOL17], 1, 0, 0);
beginning[E_B_SCHOOL18] = createMesh(beginning[E_B_SCHOOL17], E_MESH_ALPHABET_C, E_MAT_TEXT); // C
translateNode(beginning[E_B_SCHOOL18], 1, 0, 0);
beginning[E_B_SCHOOL19] = createMesh(beginning[E_B_SCHOOL18], E_MESH_ALPHABET_H, E_MAT_TEXT); // H
translateNode(beginning[E_B_SCHOOL19], 1, 0, 0);
beginning[E_B_SCHOOL20] = createMesh(beginning[E_B_SCHOOL19], E_MESH_ALPHABET_N, E_MAT_TEXT); // N
translateNode(beginning[E_B_SCHOOL20], 1, 0, 0);
beginning[E_B_SCHOOL21] = createMesh(beginning[E_B_SCHOOL20], E_MESH_ALPHABET_O, E_MAT_TEXT); // O
translateNode(beginning[E_B_SCHOOL21], 1, 0, 0);
beginning[E_B_SCHOOL22] = createMesh(beginning[E_B_SCHOOL21], E_MESH_ALPHABET_L, E_MAT_TEXT); // L
translateNode(beginning[E_B_SCHOOL22], 1, 0, 0);
beginning[E_B_SCHOOL23] = createMesh(beginning[E_B_SCHOOL22], E_MESH_ALPHABET_O, E_MAT_TEXT); // O
translateNode(beginning[E_B_SCHOOL23], 1, 0, 0);
beginning[E_B_SCHOOL24] = createMesh(beginning[E_B_SCHOOL23], E_MESH_ALPHABET_G, E_MAT_TEXT); // G
translateNode(beginning[E_B_SCHOOL24], 1, 0, 0);
beginning[E_B_SCHOOL25] = createMesh(beginning[E_B_SCHOOL24], E_MESH_ALPHABET_Y, E_MAT_TEXT); // Y
translateNode(beginning[E_B_SCHOOL25], 1, 0, 0);
// presents
beginning[E_B_PRESENTS] = createDummy(beginning[E_B_ROOT]);
translateNode(beginning[E_B_PRESENTS], -4.5, -400, 400);
rotateNodeDeg(beginning[E_B_PRESENTS], -45, 0, 0);
beginning[E_B_PRESENTS0] = createMesh(beginning[E_B_PRESENTS], E_MESH_ALPHABET_P, E_MAT_TEXT); // P
translateNode(beginning[E_B_PRESENTS0], 1, 0, 0);
beginning[E_B_PRESENTS1] = createMesh(beginning[E_B_PRESENTS0], E_MESH_ALPHABET_R, E_MAT_TEXT); // R
translateNode(beginning[E_B_PRESENTS1], 1, 0, 0);
beginning[E_B_PRESENTS2] = createMesh(beginning[E_B_PRESENTS1], E_MESH_ALPHABET_E, E_MAT_TEXT); // E
translateNode(beginning[E_B_PRESENTS2], 1, 0, 0);
beginning[E_B_PRESENTS3] = createMesh(beginning[E_B_PRESENTS2], E_MESH_ALPHABET_S, E_MAT_TEXT); // S
translateNode(beginning[E_B_PRESENTS3], 1, 0, 0);
beginning[E_B_PRESENTS4] = createMesh(beginning[E_B_PRESENTS3], E_MESH_ALPHABET_E, E_MAT_TEXT); // E
translateNode(beginning[E_B_PRESENTS4], 1, 0, 0);
beginning[E_B_PRESENTS5] = createMesh(beginning[E_B_PRESENTS4], E_MESH_ALPHABET_N, E_MAT_TEXT); // N
translateNode(beginning[E_B_PRESENTS5], 1, 0, 0);
beginning[E_B_PRESENTS6] = createMesh(beginning[E_B_PRESENTS5], E_MESH_ALPHABET_T, E_MAT_TEXT); // T
translateNode(beginning[E_B_PRESENTS6], 1, 0, 0);
beginning[E_B_PRESENTS7] = createMesh(beginning[E_B_PRESENTS6], E_MESH_ALPHABET_S, E_MAT_TEXT); // S
translateNode(beginning[E_B_PRESENTS7], 1, 0, 0);
// everything is possible
beginning[E_B_TITLE_1] = createDummy(beginning[E_B_ROOT]);
translateNode(beginning[E_B_TITLE_1], 2, 5, 13.5);
rotateNodeDeg(beginning[E_B_TITLE_1], 0, 0, 140);
beginning[E_B_TITLE_1_0] = createMesh(beginning[E_B_TITLE_1], E_MESH_ALPHABET_E, E_MAT_TEXT); // E
translateNode(beginning[E_B_TITLE_1_0], 1, 0, 0);
beginning[E_B_TITLE_1_1] = createMesh(beginning[E_B_TITLE_1_0], E_MESH_ALPHABET_V, E_MAT_TEXT); // V
translateNode(beginning[E_B_TITLE_1_1], 1, 0, 0);
beginning[E_B_TITLE_1_2] = createMesh(beginning[E_B_TITLE_1_1], E_MESH_ALPHABET_E, E_MAT_TEXT); // E
translateNode(beginning[E_B_TITLE_1_2], 1, 0, 0);
beginning[E_B_TITLE_1_3] = createMesh(beginning[E_B_TITLE_1_2], E_MESH_ALPHABET_R, E_MAT_TEXT); // R
translateNode(beginning[E_B_TITLE_1_3], 1, 0, 0);
beginning[E_B_TITLE_1_4] = createMesh(beginning[E_B_TITLE_1_3], E_MESH_ALPHABET_Y, E_MAT_TEXT); // Y
translateNode(beginning[E_B_TITLE_1_4], 1, 0, 0);
beginning[E_B_TITLE_1_5] = createMesh(beginning[E_B_TITLE_1_4], E_MESH_ALPHABET_T, E_MAT_TEXT); // T
translateNode(beginning[E_B_TITLE_1_5], 1, 0, 0);
beginning[E_B_TITLE_1_6] = createMesh(beginning[E_B_TITLE_1_5], E_MESH_ALPHABET_H, E_MAT_TEXT); // H
translateNode(beginning[E_B_TITLE_1_6], 1, 0, 0);
beginning[E_B_TITLE_1_7] = createMesh(beginning[E_B_TITLE_1_6], E_MESH_ALPHABET_I, E_MAT_TEXT); // I
translateNode(beginning[E_B_TITLE_1_7], 1, 0, 0);
beginning[E_B_TITLE_1_8] = createMesh(beginning[E_B_TITLE_1_7], E_MESH_ALPHABET_N, E_MAT_TEXT); // N
translateNode(beginning[E_B_TITLE_1_8], 1, 0, 0);
beginning[E_B_TITLE_1_9] = createMesh(beginning[E_B_TITLE_1_8], E_MESH_ALPHABET_G, E_MAT_TEXT); // G
translateNode(beginning[E_B_TITLE_1_9], 1, 0, 0);
beginning[E_B_TITLE_1_10] = createMesh(beginning[E_B_TITLE_1], E_MESH_ALPHABET_I, E_MAT_TEXT); // I
translateNode(beginning[E_B_TITLE_1_10], 5, 0, -1.5);
beginning[E_B_TITLE_1_11] = createMesh(beginning[E_B_TITLE_1_10], E_MESH_ALPHABET_S, E_MAT_TEXT); // S
translateNode(beginning[E_B_TITLE_1_11], 1, 0, 0);
beginning[E_B_TITLE_1_12] = createMesh(beginning[E_B_TITLE_1], E_MESH_ALPHABET_P, E_MAT_TEXT); // P
translateNode(beginning[E_B_TITLE_1_12], 2, 0, -3);
beginning[E_B_TITLE_1_13] = createMesh(beginning[E_B_TITLE_1_12], E_MESH_ALPHABET_O, E_MAT_TEXT); // O
translateNode(beginning[E_B_TITLE_1_13], 1, 0, 0);
beginning[E_B_TITLE_1_14] = createMesh(beginning[E_B_TITLE_1_13], E_MESH_ALPHABET_S, E_MAT_TEXT); // S
translateNode(beginning[E_B_TITLE_1_14], 1, 0, 0);
beginning[E_B_TITLE_1_15] = createMesh(beginning[E_B_TITLE_1_14], E_MESH_ALPHABET_S, E_MAT_TEXT); // S
translateNode(beginning[E_B_TITLE_1_15], 1, 0, 0);
beginning[E_B_TITLE_1_16] = createMesh(beginning[E_B_TITLE_1_15], E_MESH_ALPHABET_I, E_MAT_TEXT); // I
translateNode(beginning[E_B_TITLE_1_16], 1, 0, 0);
beginning[E_B_TITLE_1_17] = createMesh(beginning[E_B_TITLE_1_16], E_MESH_ALPHABET_B, E_MAT_TEXT); // B
translateNode(beginning[E_B_TITLE_1_17], 1, 0, 0);
beginning[E_B_TITLE_1_18] = createMesh(beginning[E_B_TITLE_1_17], E_MESH_ALPHABET_L, E_MAT_TEXT); // L
translateNode(beginning[E_B_TITLE_1_18], 1, 0, 0);
beginning[E_B_TITLE_1_19] = createMesh(beginning[E_B_TITLE_1_18], E_MESH_ALPHABET_E, E_MAT_TEXT); // L
translateNode(beginning[E_B_TITLE_1_19], 1, 0, 0);
beginning[E_B_TITLE_2_CURVE] = createCurve(beginning[E_B_ROOT], NULL, NULL, 0, 0);
beginning[E_B_TITLE_2] = createDummy(beginning[E_B_TITLE_2_CURVE]);
scaleNode(beginning[E_B_TITLE_2], 0.5, 0.5, 0.5);
rotateNodeDeg(beginning[E_B_TITLE_2], 30, 30, 120);
beginning[E_B_TITLE_2_0] = createMesh(beginning[E_B_TITLE_2], E_MESH_ALPHABET_I, E_MAT_TEXT); // I
translateNode(beginning[E_B_TITLE_2_0], 1, 0, 0);
beginning[E_B_TITLE_2_1] = createMesh(beginning[E_B_TITLE_2_0], E_MESH_ALPHABET_N, E_MAT_TEXT); // N
translateNode(beginning[E_B_TITLE_2_1], 1, 0, 0);
beginning[E_B_TITLE_2_2] = createMesh(beginning[E_B_TITLE_2_1], E_MESH_ALPHABET_Y, E_MAT_TEXT); // Y
translateNode(beginning[E_B_TITLE_2_2], 2, 0, 0);
beginning[E_B_TITLE_2_3] = createMesh(beginning[E_B_TITLE_2_2], E_MESH_ALPHABET_O, E_MAT_TEXT); // O
translateNode(beginning[E_B_TITLE_2_3], 1, 0, 0);
beginning[E_B_TITLE_2_4] = createMesh(beginning[E_B_TITLE_2_3], E_MESH_ALPHABET_U, E_MAT_TEXT); // U
translateNode(beginning[E_B_TITLE_2_4], 1, 0, 0);
beginning[E_B_TITLE_2_5] = createMesh(beginning[E_B_TITLE_2_4], E_MESH_ALPHABET_R, E_MAT_TEXT); // R
translateNode(beginning[E_B_TITLE_2_5], 1, 0, 0);
beginning[E_B_TITLE_2_6] = createMesh(beginning[E_B_TITLE_2], E_MESH_ALPHABET_D, E_MAT_TEXT); // D
translateNode(beginning[E_B_TITLE_2_6], 2, 0, -1.5);
beginning[E_B_TITLE_2_7] = createMesh(beginning[E_B_TITLE_2_6], E_MESH_ALPHABET_R, E_MAT_TEXT); // R
translateNode(beginning[E_B_TITLE_2_7], 1, 0, 0);
beginning[E_B_TITLE_2_8] = createMesh(beginning[E_B_TITLE_2_7], E_MESH_ALPHABET_E, E_MAT_TEXT); // E
translateNode(beginning[E_B_TITLE_2_8], 1, 0, 0);
beginning[E_B_TITLE_2_9] = createMesh(beginning[E_B_TITLE_2_8], E_MESH_ALPHABET_A, E_MAT_TEXT); // A
translateNode(beginning[E_B_TITLE_2_9], 1, 0, 0);
beginning[E_B_TITLE_2_10] = createMesh(beginning[E_B_TITLE_2_9], E_MESH_ALPHABET_M, E_MAT_TEXT); // M
translateNode(beginning[E_B_TITLE_2_10], 1, 0, 0);
beginning[E_B_TITLE_2_11] = createMesh(beginning[E_B_TITLE_2_10], E_MESH_ALPHABET_S, E_MAT_TEXT); // S
translateNode(beginning[E_B_TITLE_2_11], 1, 0, 0);
}
/**
* init first scene
*/
static void initScene1(){
GLfloat up[3];
// create root node
scene1[E_S1_ROOT] = createRoot();
GLfloat LightAmbient[] = {0.0f, 0.0f, 0.0f, 1.0f};
GLfloat LightDiffuse[] = {1.0f, 1.0f, 1.0f, 1.0f};
GLfloat LightSpecular[] = {1.0f, 1.0f, 1.0f, 1.0f};
GLfloat LightPosition[] = {15.0f, 15.0f, 15.0f, 1.0f};
GLfloat LightTargetPoint[] = {0.0, 0.0, 0.0};
GLfloat lightCutOff = 30.0;
setLight(scene1[E_S1_ROOT], LightAmbient, LightDiffuse, LightSpecular, LightPosition, LightTargetPoint, lightCutOff);
// setup camera
scene1[E_S1_CAM_1_CURVE] = createCurve(scene1[E_S1_ROOT], NULL, NULL, 0, 0);
up[0] = 0; up[1] = 0; up[2] = 1;
scene1[E_S1_CAM_1] = createCamera(scene1[E_S1_CAM_1_CURVE], 50, 1, 10000, up, NULL, 0, 0);
// add models
// body - dependent on root
scene1[E_S1_PIANO_BODY] = createMesh(scene1[E_S1_ROOT], E_MESH_PIANO_BODY, E_MAT_PIANO_BODY);
// bench - dependent on root
scene1[E_S1_PIANO_BENCH] = createMesh(scene1[E_S1_ROOT], E_MESH_PIANO_BENCH, E_MAT_PIANO_BODY);
// strings - dependent on body
scene1[E_S1_PIANO_STRINGS] = createMesh(scene1[E_S1_PIANO_BODY], E_MESH_PIANO_STRINGS, E_MAT_PIANO_STRINGS);
// keys - dependent on body
for (int i = 0; i < 9; ++i){
scene1[E_S1_PIANO_C0 + 0 + i * 11] = createMesh(scene1[E_S1_PIANO_BODY], E_MESH_PIANO_WHITE_KEY, E_MAT_PIANO_WHITE_KEY); // C sharp
translateNode(scene1[E_S1_PIANO_C0 + 0 + i * 11], -0.1875 * 0 + (-0.1875 * 7 * i), 0, 0);
scene1[E_S1_PIANO_C0 + 1 + i * 11] = createMesh(scene1[E_S1_PIANO_BODY], E_MESH_PIANO_BLACK_KEY, E_MAT_PIANO_BLACK_KEY); // C flat
translateNode(scene1[E_S1_PIANO_C0 + 1 + i * 11], -0.1875 * 0 + (-0.1875 * 7 * i), 0, 0);
scene1[E_S1_PIANO_C0 + 2 + i * 11] = createMesh(scene1[E_S1_PIANO_BODY], E_MESH_PIANO_WHITE_KEY, E_MAT_PIANO_WHITE_KEY); // D sharp
translateNode(scene1[E_S1_PIANO_C0 + 2 + i * 11], -0.1875 * 1 + (-0.1875 * 7 * i), 0, 0);
scene1[E_S1_PIANO_C0 + 3 + i * 11] = createMesh(scene1[E_S1_PIANO_BODY], E_MESH_PIANO_BLACK_KEY, E_MAT_PIANO_BLACK_KEY); // D flat
translateNode(scene1[E_S1_PIANO_C0 + 3 + i * 11], -0.1875 * 1 + (-0.1875 * 7 * i), 0, 0);
scene1[E_S1_PIANO_C0 + 4 + i * 11] = createMesh(scene1[E_S1_PIANO_BODY], E_MESH_PIANO_WHITE_KEY, E_MAT_PIANO_WHITE_KEY); // E sharp
translateNode(scene1[E_S1_PIANO_C0 + 4 + i * 11], -0.1875 * 2 + (-0.1875 * 7 * i), 0, 0);
scene1[E_S1_PIANO_C0 + 5 + i * 11] = createMesh(scene1[E_S1_PIANO_BODY], E_MESH_PIANO_WHITE_KEY, E_MAT_PIANO_WHITE_KEY); // F sharp
translateNode(scene1[E_S1_PIANO_C0 + 5 + i * 11], -0.1875 * 3 + (-0.1875 * 7 * i), 0, 0);
scene1[E_S1_PIANO_C0 + 6 + i * 11] = createMesh(scene1[E_S1_PIANO_BODY], E_MESH_PIANO_BLACK_KEY, E_MAT_PIANO_BLACK_KEY); // F flat
translateNode(scene1[E_S1_PIANO_C0 + 6 + i * 11], -0.1875 * 3 + (-0.1875 * 7 * i), 0, 0);
scene1[E_S1_PIANO_C0 + 7 + i * 11] = createMesh(scene1[E_S1_PIANO_BODY], E_MESH_PIANO_WHITE_KEY, E_MAT_PIANO_WHITE_KEY); // G sharp
translateNode(scene1[E_S1_PIANO_C0 + 7 + i * 11], -0.1875 * 4 + (-0.1875 * 7 * i), 0, 0);
scene1[E_S1_PIANO_C0 + 8 + i * 11] = createMesh(scene1[E_S1_PIANO_BODY], E_MESH_PIANO_BLACK_KEY, E_MAT_PIANO_BLACK_KEY); // G flat
translateNode(scene1[E_S1_PIANO_C0 + 8 + i * 11], -0.1875 * 4 + (-0.1875 * 7 * i), 0, 0);
scene1[E_S1_PIANO_C0 + 9 + i * 11] = createMesh(scene1[E_S1_PIANO_BODY], E_MESH_PIANO_WHITE_KEY, E_MAT_PIANO_WHITE_KEY); // A sharp
translateNode(scene1[E_S1_PIANO_C0 + 9 + i * 11], -0.1875 * 5 + (-0.1875 * 7 * i), 0, 0);
scene1[E_S1_PIANO_C0 + 10 + i * 11] = createMesh(scene1[E_S1_PIANO_BODY], E_MESH_PIANO_BLACK_KEY, E_MAT_PIANO_BLACK_KEY); // A flat
translateNode(scene1[E_S1_PIANO_C0 + 10 + i * 11], -0.1875 * 5 + (-0.1875 * 7 * i), 0, 0);
scene1[E_S1_PIANO_C0 + 11 + i * 11] = createMesh(scene1[E_S1_PIANO_BODY], E_MESH_PIANO_WHITE_KEY, E_MAT_PIANO_WHITE_KEY); // B sharp
translateNode(scene1[E_S1_PIANO_C0 + 11 + i * 11], -0.1875 * 6 + (-0.1875 * 7 * i), 0, 0);
}
// puppet
scene1[E_S1_PUPPET_LOWER_BODY] = createMesh(scene1[E_S1_ROOT], E_MESH_PUPPET_LOWER_BODY, E_MAT_PUPPET_WOOD);
translateNode(scene1[E_S1_PUPPET_LOWER_BODY], -0.6, 10.3, 3.5);
storeNoRotMatrix(scene1[E_S1_PUPPET_LOWER_BODY]);
scene1[E_S1_PUPPET_UPPER_BODY] = createMesh(scene1[E_S1_PUPPET_LOWER_BODY], E_MESH_PUPPET_UPPER_BODY, E_MAT_PUPPET_WOOD);
translateNode(scene1[E_S1_PUPPET_UPPER_BODY], 0, 0, 1.3);
storeNoRotMatrix(scene1[E_S1_PUPPET_UPPER_BODY]);
scene1[E_S1_PUPPET_TIE] = createMesh(scene1[E_S1_PUPPET_UPPER_BODY], E_MESH_PUPPET_TIE, E_MAT_PIANO_WHITE_KEY);
translateNode(scene1[E_S1_PUPPET_TIE], 0, -0.3, 2.0);
scaleNode(scene1[E_S1_PUPPET_TIE], 0.6, 0.6, 0.6);
storeNoRotMatrix(scene1[E_S1_PUPPET_TIE]);
scene1[E_S1_PUPPET_HEAD] = createMesh(scene1[E_S1_PUPPET_UPPER_BODY], E_MESH_PUPPET_HEAD, E_MAT_PUPPET_WOOD);
translateNode(scene1[E_S1_PUPPET_HEAD], 0, 0, 2.2);
storeNoRotMatrix(scene1[E_S1_PUPPET_HEAD]);
scene1[E_S1_PUPPET_HAIR] = createMesh(scene1[E_S1_PUPPET_HEAD], E_MESH_PUPPET_HAIR, E_MAT_PUPPET_HAIR);
translateNode(scene1[E_S1_PUPPET_HAIR], 0, -0.1, 0.2);
scaleNode(scene1[E_S1_PUPPET_HAIR], 0.9, 0.9, 0.9);
scene1[E_S1_PUPPET_LEFT_ARM] = createMesh(scene1[E_S1_PUPPET_UPPER_BODY], E_MESH_PUPPET_ARM, E_MAT_PUPPET_WOOD);
translateNode(scene1[E_S1_PUPPET_LEFT_ARM], 1.1, -0.2, 1.1);
storeNoRotMatrix(scene1[E_S1_PUPPET_LEFT_ARM]);
scene1[E_S1_PUPPET_RIGHT_ARM] = createMesh(scene1[E_S1_PUPPET_UPPER_BODY], E_MESH_PUPPET_ARM, E_MAT_PUPPET_WOOD);
translateNode(scene1[E_S1_PUPPET_RIGHT_ARM], -1.1, -0.2, 1.1);
storeNoRotMatrix(scene1[E_S1_PUPPET_RIGHT_ARM]);
scene1[E_S1_PUPPET_LEFT_LEG] = createMesh(scene1[E_S1_ROOT], E_MESH_PUPPET_LEG, E_MAT_PUPPET_WOOD);
scene1[E_S1_PUPPET_RIGHT_LEG] = createMesh(scene1[E_S1_PUPPET_LEFT_LEG], E_MESH_PUPPET_LEG, E_MAT_PUPPET_WOOD);
translateNode(scene1[E_S1_PUPPET_RIGHT_LEG], -1, 0, 0);
scene1[E_S1_PUPPET_LEFT_EYE] = createMesh(scene1[E_S1_PUPPET_HEAD], E_MESH_PUPPET_EYE, E_MAT_PUPPET_EYE);
translateNode(scene1[E_S1_PUPPET_LEFT_EYE], 0.3, -0.65, 1.1);
storeNoRotMatrix(scene1[E_S1_PUPPET_LEFT_EYE]);
scene1[E_S1_PUPPET_LEFT_PUPIL] = createMesh(scene1[E_S1_PUPPET_LEFT_EYE], E_MESH_PUPPET_EYE, E_MAT_PUPPET_HAIR);
translateNode(scene1[E_S1_PUPPET_LEFT_PUPIL], 0, -0.1, -0.05);
scaleNode(scene1[E_S1_PUPPET_LEFT_PUPIL], 0.4, 0.4, 0.4);
scene1[E_S1_PUPPET_RIGHT_EYE] = createMesh(scene1[E_S1_PUPPET_HEAD], E_MESH_PUPPET_EYE, E_MAT_PUPPET_EYE);
translateNode(scene1[E_S1_PUPPET_RIGHT_EYE], -0.3, -0.65, 1.1);
storeNoRotMatrix(scene1[E_S1_PUPPET_RIGHT_EYE]);
scene1[E_S1_PUPPET_RIGHT_PUPIL] = createMesh(scene1[E_S1_PUPPET_RIGHT_EYE], E_MESH_PUPPET_EYE, E_MAT_PUPPET_HAIR);
translateNode(scene1[E_S1_PUPPET_RIGHT_PUPIL], 0, -0.1, -0.05);
scaleNode(scene1[E_S1_PUPPET_RIGHT_PUPIL], 0.4, 0.4, 0.4);
scene1[E_S1_PUPPET_MOUTH_PATH] = createCurve(scene1[E_S1_PUPPET_HEAD], NULL, NULL, 0, 0);
scene1[E_S1_PUPPET_MOUTH] = createMesh(scene1[E_S1_PUPPET_MOUTH_PATH], E_MESH_PUPPET_MOUTH, E_MAT_PUPPET_EYE);
storeNoRotMatrix(scene1[E_S1_PUPPET_MOUTH]);
scene1[E_S1_PUPPET_LEFT_EYEBROW] = createMesh(scene1[E_S1_PUPPET_HEAD], E_MESH_PUPPET_EYEBROW, E_MAT_PUPPET_HAIR);
translateNode(scene1[E_S1_PUPPET_LEFT_EYEBROW], 0.3, -0.7, 1.33);
storeNoRotMatrix(scene1[E_S1_PUPPET_LEFT_EYEBROW]);
scene1[E_S1_PUPPET_RIGHT_EYEBROW] = createMesh(scene1[E_S1_PUPPET_HEAD], E_MESH_PUPPET_EYEBROW, E_MAT_PUPPET_HAIR);
translateNode(scene1[E_S1_PUPPET_RIGHT_EYEBROW], -0.3, -0.7, 1.33);
storeNoRotMatrix(scene1[E_S1_PUPPET_RIGHT_EYEBROW]);
// ground - dependent on root
scene1[E_S1_GROUND] = createMesh(scene1[E_S1_ROOT], E_MESH_GROUND, E_MAT_GROUND);
}
VXmlDocInstance()
{
QString fileName = defaultFileName();
QString rootTagName = QFileInfo(fileName).completeBaseName();
createRoot(rootTagName);
}
