#include "toonz/sceneproperties.h"

// TnzLib includes

#include "toonz/cleanupparameters.h"

#include "toonz/tcenterlinevectorizer.h"

#include "toonz/captureparameters.h"

#include "toonz/tcamera.h"

#include "toonz/tstageobjecttree.h"

#include "toonz/txshleveltypes.h"

#include "cleanuppalette.h"

// TnzBase includes

#include "toutputproperties.h"

#include "trasterfx.h"

#include "tscanner.h"

// TnzCore includes

#include "tstream.h"

#include "tpalette.h"

#include "tproperty.h"

//=============================================================================

TSceneProperties::TSceneProperties()

	: m_cleanupParameters(new CleanupParameters()), m_scanParameters(new TScannerParameters()), m_vectorizerParameters(new VectorizerParameters()), m_captureParameters(new CaptureParameters()), m_outputProp(new TOutputProperties()), m_previewProp(new TOutputProperties()), m_bgColor(255, 255, 255, 0), m_markerDistance(6), m_markerOffset(0), m_fullcolorSubsampling(1), m_tlvSubsampling(1), m_fieldGuideSize(12), m_fieldGuideAspectRatio(1.38)

{

	//Default color

	m_notesColor.push_back(TPixel32(255, 235, 140));

	m_notesColor.push_back(TPixel32(255, 160, 120));

	m_notesColor.push_back(TPixel32(255, 180, 190));

	m_notesColor.push_back(TPixel32(135, 205, 250));

	m_notesColor.push_back(TPixel32(145, 240, 145));

	m_notesColor.push_back(TPixel32(130, 255, 210));

	m_notesColor.push_back(TPixel32(150, 245, 255));

}

//-----------------------------------------------------------------------------

TSceneProperties::~TSceneProperties()

{

	delete m_cleanupParameters;

	delete m_scanParameters;

	delete m_vectorizerParameters;

	delete m_captureParameters;

	clearPointerContainer(m_cameras);

	delete m_outputProp;

	delete m_previewProp;

}

//-----------------------------------------------------------------------------

void TSceneProperties::assign(const TSceneProperties *sprop)

{

	assert(sprop);

	m_hGuides = sprop->m_hGuides;

	m_vGuides = sprop->m_vGuides;

	*m_outputProp = *sprop->m_outputProp;

	*m_previewProp = *sprop->m_previewProp;

	m_cleanupParameters->assign(sprop->m_cleanupParameters);

	m_scanParameters->assign(sprop->m_scanParameters);

	assert(sprop->m_vectorizerParameters);

	*m_vectorizerParameters = *sprop->m_vectorizerParameters;

	if (sprop != this) {

		m_cameras = sprop->m_cameras;

		for (int i = 0; i < (int)m_cameras.size(); i++)

			m_cameras[i] = new TCamera(*m_cameras[i]);

	}

	*m_outputProp = *sprop->m_outputProp;

	*m_previewProp = *sprop->m_previewProp;

	m_bgColor = sprop->m_bgColor;

	m_markerDistance = sprop->m_markerDistance;

	m_markerOffset = sprop->m_markerOffset;

	m_fullcolorSubsampling = sprop->m_fullcolorSubsampling;

	m_tlvSubsampling = sprop->m_tlvSubsampling;

	m_fieldGuideSize = sprop->m_fieldGuideSize;

	m_fieldGuideAspectRatio = sprop->m_fieldGuideAspectRatio;

	int i;

	for (i = 0; i < m_notesColor.size(); i++)

		m_notesColor.replace(i, sprop->getNoteColor(i));

}

//-----------------------------------------------------------------------------

void TSceneProperties::onInitialize()

{

	//  m_scanParameters->adaptToCurrentScanner();

}

//-----------------------------------------------------------------------------

void TSceneProperties::setBgColor(const TPixel32 &color)

{

	m_bgColor = color;

}

//-----------------------------------------------------------------------------

void TSceneProperties::setMarkers(int distance, int offset)

{

	m_markerDistance = distance;

	m_markerOffset = offset;

}

//-----------------------------------------------------------------------------

void TSceneProperties::setFullcolorSubsampling(int s)

{

	assert(1 <= s && s <= 100);

	m_fullcolorSubsampling = tcrop(s, 1, 100);

}

//-----------------------------------------------------------------------------

void TSceneProperties::setTlvSubsampling(int s)

{

	assert(1 <= s && s <= 100);

	m_tlvSubsampling = tcrop(s, 1, 100);

}

//-----------------------------------------------------------------------------

void TSceneProperties::setFieldGuideSize(int size)

{

	assert(1 <= size && size <= 100);

	m_fieldGuideSize = tcrop(size, 1, 100);

}

//-----------------------------------------------------------------------------

void TSceneProperties::setFieldGuideAspectRatio(double ar)

{

	assert(ar >= 0);

	if (ar <= 0)

		ar = 1;

	m_fieldGuideAspectRatio = ar;

}

//-----------------------------------------------------------------------------

void TSceneProperties::saveData(TOStream &os) const

{

	if (!m_hGuides.empty()) {

		os.openChild("hGuides");

		for (int i = 0; i < (int)m_hGuides.size(); i++)

			os << m_hGuides[i];

		os.closeChild();

	}

	if (!m_vGuides.empty()) {

		os.openChild("vGuides");

		for (int i = 0; i < (int)m_vGuides.size(); i++)

			os << m_vGuides[i];

		os.closeChild();

	}

	int i;

	if (!m_cameras.empty()) {

		os.openChild("cameras");

		for (i = 0; i < (int)m_cameras.size(); i++) {

			os.openChild("camera");

			m_cameras[i]->saveData(os);

			os.closeChild();

		}

		os.closeChild();

	}

	os.openChild("outputs");

	std::vector<toutputproperties *=""> outputs;</toutputproperties>

	outputs.push_back(getOutputProperties());

	outputs.push_back(getPreviewProperties());

	for (i = 0; i < (int)outputs.size(); i++) {

		TOutputProperties &out = *outputs[i];

		const TRenderSettings &rs = out.getRenderSettings();

		std::map<std::string, std::string=""> attr;</std::string,>

		attr["name"] = i == 0 ? "main" : "preview";

		os.openChild("output", attr);

		TFilePath outPath = out.getPath();

		int from, to, step;

		out.getRange(from, to, step);

		os.child("range") << from << to;

		os.child("step") << step;

		os.child("shrink") << rs.m_shrinkX;

		os.child("applyShrinkToViewer") << (rs.m_applyShrinkToViewer ? 1 : 0);

		os.child("fps") << out.getFrameRate();

		os.child("path") << outPath;

		os.child("bpp") << rs.m_bpp;

		os.child("multimedia") << out.getMultimediaRendering();

		os.child("threadsIndex") << out.getThreadIndex();

		os.child("maxTileSizeIndex") << out.getMaxTileSizeIndex();

		os.child("subcameraPrev") << (out.isSubcameraPreview() ? 1 : 0);

		os.child("stereoscopic") << (rs.m_stereoscopic ? 1 : 0) << rs.m_stereoscopicShift;

		switch (rs.m_quality) {

		case TRenderSettings::StandardResampleQuality:

			os.child("resquality") << (int)0;

			break;

		case TRenderSettings::ImprovedResampleQuality:

			os.child("resquality") << (int)1;

			break;

		case TRenderSettings::HighResampleQuality:

			os.child("resquality") << (int)2;

		case TRenderSettings::Triangle_FilterResampleQuality:

			os.child("resquality") << (int)100;

			break;

		case TRenderSettings::Mitchell_FilterResampleQuality:

			os.child("resquality") << (int)101;

			break;

		case TRenderSettings::Cubic5_FilterResampleQuality:

			os.child("resquality") << (int)102;

			break;

		case TRenderSettings::Cubic75_FilterResampleQuality:

			os.child("resquality") << (int)103;

			break;

		case TRenderSettings::Cubic1_FilterResampleQuality:

			os.child("resquality") << (int)104;

			break;

		case TRenderSettings::Hann2_FilterResampleQuality:

			os.child("resquality") << (int)105;

			break;

		case TRenderSettings::Hann3_FilterResampleQuality:

			os.child("resquality") << (int)106;

			break;

		case TRenderSettings::Hamming2_FilterResampleQuality:

			os.child("resquality") << (int)107;

			break;

		case TRenderSettings::Hamming3_FilterResampleQuality:

			os.child("resquality") << (int)108;

			break;

		case TRenderSettings::Lanczos2_FilterResampleQuality:

			os.child("resquality") << (int)109;

			break;

		case TRenderSettings::Lanczos3_FilterResampleQuality:

			os.child("resquality") << (int)110;

			break;

		case TRenderSettings::Gauss_FilterResampleQuality:

			os.child("resquality") << (int)111;

			break;

		case TRenderSettings::ClosestPixel_FilterResampleQuality:

			os.child("resquality") << (int)112;

			break;

		case TRenderSettings::Bilinear_FilterResampleQuality:

			os.child("resquality") << (int)113;

			break;

			break;

		DEFAULT:

			assert(false);

		}

		switch (rs.m_fieldPrevalence) {

		case TRenderSettings::NoField:

			os.child("fieldprevalence") << (int)0;

			break;

		case TRenderSettings::EvenField:

			os.child("fieldprevalence") << (int)1;

			break;

		case TRenderSettings::OddField:

			os.child("fieldprevalence") << (int)2;

			break;

		DEFAULT:

			assert(false);

		}

		os.child("gamma") << rs.m_gamma;

		os.child("timestretch") << rs.m_timeStretchFrom << rs.m_timeStretchTo;

		if (out.getOffset() != 0)

			os.child("offset") << out.getOffset();

		os.openChild("formatsProperties");

		std::vector<std::string> fileExtensions;</std::string>

		out.getFileFormatPropertiesExtensions(fileExtensions);

		for (int i = 0; i < (int)fileExtensions.size(); i++) {

			std::string ext = fileExtensions[i];

			TPropertyGroup *pg = out.getFileFormatProperties(ext);

			assert(pg);

			std::map<std::string, std::string=""> attr;</std::string,>

			attr["ext"] = ext;

			os.openChild("formatProperties", attr);

			pg->saveData(os);

			os.closeChild();

		}

		os.closeChild();

		os.closeChild(); // 

	}

	os.closeChild();

	os.openChild("cleanupParameters");

	m_cleanupParameters->saveData(os);

	os.closeChild();

	os.openChild("scanParameters");

	m_scanParameters->saveData(os);

	os.closeChild();

	os.openChild("vectorizerParameters");

	m_vectorizerParameters->saveData(os);

	os.closeChild();

	os.child("bgColor") << m_bgColor;

	os.child("markers") << m_markerDistance << m_markerOffset;

	os.child("subsampling") << m_fullcolorSubsampling << m_tlvSubsampling;

	os.child("fieldguide") << m_fieldGuideSize << m_fieldGuideAspectRatio;

	os.openChild("noteColors");

	for (i = 0; i < m_notesColor.size(); i++)

		os << m_notesColor.at(i);

	os.closeChild();

}

//-----------------------------------------------------------------------------

/*! Set all scene properties elements, to information contained in \b TIStream \b is.

		\sa saveData()

*/

void TSceneProperties::loadData(TIStream &is, bool isLoadingProject)

{

	TSceneProperties defaultProperties;

	assign(&defaultProperties);

	int globFrom = -1, globTo = 0, globStep = 1;

	double globFrameRate = -1;

	std::string tagName;

	*m_outputProp = *m_previewProp = TOutputProperties();

	while (is.matchTag(tagName)) {

		if (tagName == "projectPath") {

			TFilePath projectPath;

			is >> projectPath;

		} else if (tagName == "range") {

			is >> globFrom >> globTo;

		} //backCompatibility: prima range e fps non erano in Output

		else if (tagName == "step") {

			is >> globStep;

		} else if (tagName == "fps") {

			is >> globFrameRate;

		} else if (tagName == "bgColor") {

			is >> m_bgColor;

		} else if (tagName == "viewerBgColor" || tagName == "previewBgColor" || tagName == "chessboardColor1" || tagName == "chessboardColor2") //back compatibility

		{

			TPixel32 dummy;

			is >> dummy;

		} else if (tagName == "markers") {

			is >> m_markerDistance >> m_markerOffset;

		} else if (tagName == "subsampling") {

			is >> m_fullcolorSubsampling >> m_tlvSubsampling;

		} else if (tagName == "fieldguide") {

			is >> m_fieldGuideSize >> m_fieldGuideAspectRatio;

		} else if (tagName == "safearea") {

			double dummy1, dummy2;

			is >> dummy1 >> dummy2;

		} //back compatibility

		else if (tagName == "columnIconLoadingPolicy") {

			int dummy;

			is >> dummy;

		}								 //back compatibility

		else if (tagName == "playrange") //back compatibility

		{

			std::string dummy;

			is >> globFrom >> globTo >> dummy;

		} else if (tagName == "camera") //back compatibility with tab 2.2

		{

			clearPointerContainer(m_cameras);

			m_cameras.clear();

			TCamera *camera = new TCamera();

			m_cameras.push_back(camera);

			TDimension res(0, 0);

			is >> res.lx >> res.ly;

			camera->setRes(res);

			double cameraDpi = 36.0;

			camera->setSize(TDimensionD(res.lx / cameraDpi, res.ly / cameraDpi));

		} else if (tagName == "playRange") {

			int playR0, playR1;

			is >> playR0 >> playR1;

		} else if (tagName == "hGuides" || tagName == "vGuides") {

			Guides &guides = tagName == "hGuides" ? m_hGuides : m_vGuides;

			while (!is.matchEndTag()) {

				double g;

				is >> g;

				guides.push_back(g);

			}

			continue;

		} else if (tagName == "cameras") {

			clearPointerContainer(m_cameras);

			m_cameras.clear();

			while (is.matchTag(tagName)) {

				if (tagName == "camera") {

					TCamera *camera = new TCamera();

					m_cameras.push_back(camera);

					camera->loadData(is);

				} // if "camera"

				else

					throw TException("unexpected property tag: " + tagName);

				is.closeChild();

			}

		} else if (tagName == "outputs" || tagName == "outputStreams") {

			while (is.matchTag(tagName)) {

				if (tagName == "output" || tagName == "outputStream") {

					TOutputProperties dummyOut;

					TOutputProperties *outPtr = &dummyOut;

					std::string name = is.getTagAttribute("name");

					if (name == "preview")

						outPtr = m_previewProp;

					else if (name == "main")

						outPtr = m_outputProp;

					TOutputProperties &out = *outPtr;

					TRenderSettings renderSettings;

					if (globFrom != -1)

						out.setRange(globFrom, globTo, globStep);

					else if (globStep != 1) {

						int from, to, dummy;

						out.getRange(from, to, dummy);

						out.setRange(from, to, globStep);

					}

					if (globFrameRate != -1)

						out.setFrameRate(globFrameRate);

					while (is.matchTag(tagName)) {

						if (tagName == "camera") {

							int dummy;

							is >> dummy;

						}									// per compatibilita'

						else if (tagName == "cameraData") { // per compatibilita'

							while (is.matchTag(tagName)) {

								if (tagName == "size") {

									TDimensionD size(0, 0);

									is >> size.lx >> size.ly;

								} else if (tagName == "res") {

									TDimension res(0, 0);

									is >> res.lx >> res.ly;

								}

								is.closeChild();

							}

						} else if (tagName == "path") {

							TFilePath fp;

							is >> fp;

							std::string ext = fp.getUndottedType();

							TPropertyGroup *pg = out.getFileFormatProperties(ext);

							if (ext == "avi" && pg->getPropertyCount() != 1)

								fp = fp.withType("tif");

							out.setPath(fp);

						} else if (tagName == "offset") {

							int j;

							is >> j;

							out.setOffset(j);

						} else if (tagName == "range") {

							int from, to, step, dummy;

							is >> from >> to;

							out.getRange(dummy, dummy, step);

							out.setRange(from, to, step);

						} else if (tagName == "step") {

							int dummy, from, to, step;

							is >> step;

							out.getRange(from, to, dummy);

							out.setRange(from, to, step);

						} else if (tagName == "shrink") {

							int shrink;

							is >> shrink;

							renderSettings.m_shrinkX = renderSettings.m_shrinkY = shrink;

						} else if (tagName == "applyShrinkToViewer") {

							int applyShrinkToViewer;

							is >> applyShrinkToViewer;

							renderSettings.m_applyShrinkToViewer = (applyShrinkToViewer != 0);

						} else if (tagName == "fps") {

							double j;

							is >> j;

							out.setFrameRate(j);

						} else if (tagName == "bpp") {

							int j;

							is >> j;

							if (j == 32 || j == 64)

								renderSettings.m_bpp = j;

						} else if (tagName == "multimedia") {

							int j;

							is >> j;

							out.setMultimediaRendering(j);

						} else if (tagName == "threadsIndex") {

							int j;

							is >> j;

							out.setThreadIndex(j);

						} else if (tagName == "maxTileSizeIndex") {

							int j;

							is >> j;

							out.setMaxTileSizeIndex(j);

						} else if (tagName == "subcameraPrev") {

							int j;

							is >> j;

							out.setSubcameraPreview(j != 0);

						} else if (tagName == "resquality") {

							int j;

							is >> j;

							switch (j) {

							case 0:

								renderSettings.m_quality = TRenderSettings::StandardResampleQuality;

								CASE 1 : renderSettings.m_quality = TRenderSettings::ImprovedResampleQuality;

								CASE 2 : renderSettings.m_quality = TRenderSettings::HighResampleQuality;

								CASE 100 : renderSettings.m_quality = TRenderSettings::Triangle_FilterResampleQuality;

								CASE 101 : renderSettings.m_quality = TRenderSettings::Mitchell_FilterResampleQuality;

								CASE 102 : renderSettings.m_quality = TRenderSettings::Cubic5_FilterResampleQuality;

								CASE 103 : renderSettings.m_quality = TRenderSettings::Cubic75_FilterResampleQuality;

								CASE 104 : renderSettings.m_quality = TRenderSettings::Cubic1_FilterResampleQuality;

								CASE 105 : renderSettings.m_quality = TRenderSettings::Hann2_FilterResampleQuality;

								CASE 106 : renderSettings.m_quality = TRenderSettings::Hann3_FilterResampleQuality;

								CASE 107 : renderSettings.m_quality = TRenderSettings::Hamming2_FilterResampleQuality;

								CASE 108 : renderSettings.m_quality = TRenderSettings::Hamming3_FilterResampleQuality;

								CASE 109 : renderSettings.m_quality = TRenderSettings::Lanczos2_FilterResampleQuality;

								CASE 110 : renderSettings.m_quality = TRenderSettings::Lanczos3_FilterResampleQuality;

								CASE 111 : renderSettings.m_quality = TRenderSettings::Gauss_FilterResampleQuality;

								CASE 112 : renderSettings.m_quality = TRenderSettings::ClosestPixel_FilterResampleQuality;

								CASE 113 : renderSettings.m_quality = TRenderSettings::Bilinear_FilterResampleQuality;

							DEFAULT:

								renderSettings.m_quality = TRenderSettings::StandardResampleQuality;

							}

						} else if (tagName == "fieldprevalence") {

							int j;

							is >> j;

							switch (j) {

							case 0:

								renderSettings.m_fieldPrevalence = TRenderSettings::NoField;

								CASE 1 : renderSettings.m_fieldPrevalence = TRenderSettings::EvenField;

								CASE 2 : renderSettings.m_fieldPrevalence = TRenderSettings::OddField;

							DEFAULT:

								renderSettings.m_fieldPrevalence = TRenderSettings::NoField;

							}

						} else if (tagName == "gamma") {

							double g;

							is >> g;

							renderSettings.m_gamma = g;

						} else if (tagName == "timestretch") {

							double from, to;

							is >> from >> to;

							renderSettings.m_timeStretchFrom = from;

							renderSettings.m_timeStretchTo = to;

						} else if (tagName == "stereoscopic") {

							int doit;

							double val;

							is >> doit >> val;

							renderSettings.m_stereoscopic = (doit == 1);

							renderSettings.m_stereoscopicShift = val;

						}

						// TODO: aggiungere la lettura della quality

						else if (tagName == "res") { // obsoleto

							TDimension d(0, 0);

							is >> d.lx >> d.ly;

							if (!is.eos()) {

								std::string s;

								is >> s;

							}

						} else if (tagName == "formatsProperties") {

							while (is.matchTag(tagName)) {

								if (tagName == "formatProperties") {

									std::string ext = is.getTagAttribute("ext");

									TPropertyGroup *pg =

										out.getFileFormatProperties(ext);

									if (ext == "avi") {

										TPropertyGroup appProperties;

										appProperties.loadData(is);

										if (pg->getPropertyCount() != 1 || appProperties.getPropertyCount() != 1) {

											is.closeChild();

											continue;

										}

										TEnumProperty *enumProp = dynamic_cast<tenumproperty *="">(pg->getProperty(0));</tenumproperty>

										TEnumProperty *enumAppProp = dynamic_cast<tenumproperty *="">(appProperties.getProperty(0));</tenumproperty>

										assert(enumAppProp && enumProp);

										if (enumAppProp && enumProp) {

											try {

												enumProp->setValue(enumAppProp->getValue());

											} catch (TProperty::RangeError &) {

											}

										} else

											throw TException();

									} else

										pg->loadData(is);

									is.closeChild();

								} else

									throw TException("unexpected tag: " + tagName);

							} // end while

						} else {

							throw TException("unexpected property tag: " + tagName);

						}

						is.closeChild();

					}

					if (renderSettings.m_timeStretchFrom == renderSettings.m_timeStretchTo &&

						renderSettings.m_timeStretchTo == 1)

						renderSettings.m_timeStretchFrom = renderSettings.m_timeStretchTo = out.getFrameRate();

					out.setRenderSettings(renderSettings);

				} else

					throw TException("unexpected property tag: " + tagName);

				is.closeChild();

			} // while (outputs/outputStreams)

		} else if (tagName == "cleanupPalette") {

			m_cleanupParameters->m_cleanupPalette->loadData(is);

		} else if (tagName == "cleanupParameters") {

			m_cleanupParameters->loadData(is, !isLoadingProject);

		} else if (tagName == "scanParameters") {

			//m_scanParameters->adaptToCurrentScanner(); Rallenta tutto!!!

			m_scanParameters->loadData(is);

		} else if (tagName == "vectorizerParameters") {

			m_vectorizerParameters->loadData(is);

		} else if (tagName == "captureParameters") {

			m_captureParameters->loadData(is);

		} else if (tagName == "defaultLevelParameters") {

			// this

			int type;

			double width, height, dpi;

			is >> type >> width >> height >> dpi;

		} else if (tagName == "noteColors") {

			int i = 0;

			while (!is.eos()) {

				TPixel32 color;

				is >> color;

				m_notesColor.replace(i, color);

				i++;

			}

			assert(i == 7);

		} else {

			throw TException("unexpected property tag: " + tagName);

		}

		is.closeChild();

	}

}

//-----------------------------------------------------------------------------

void TSceneProperties::cloneCamerasFrom(TStageObjectTree *stageObjects)

{

	clearPointerContainer(m_cameras);

	int cameraCount = stageObjects->getCameraCount();

	int tmpCameraId = 0;

	for (int i = 0; i < cameraCount;) {

		/*-- カメラが見つからなかった場合、tmpCameraIdのみ進める --*/

		if (!stageObjects->getStageObject(TStageObjectId::CameraId(tmpCameraId), false)) {

			tmpCameraId++;

			continue;

		}

		TStageObject *cameraObject = stageObjects->getStageObject(TStageObjectId::CameraId(tmpCameraId));

		TCamera *camera = new TCamera(*cameraObject->getCamera());

		m_cameras.push_back(camera);

		/*-- カメラが見つかったので、i も tmpCameraId も進める --*/

		i++;

		tmpCameraId++;

	}

}

//-----------------------------------------------------------------------------

void TSceneProperties::cloneCamerasTo(TStageObjectTree *stageObjects) const

{

	TDimension maxCameraRes(0, 0);

	for (int i = 0; i < (int)m_cameras.size(); i++) {

		TStageObject *cameraPegbar = stageObjects->getStageObject(TStageObjectId::CameraId(i));

		TCamera *camera = m_cameras[i];

		TDimension cameraRes = camera->getRes();

		bool modified = false;

		if (maxCameraRes.lx > 0 && cameraRes.lx > maxCameraRes.lx) {

			cameraRes.lx = maxCameraRes.lx;

			modified = true;

		}

		if (maxCameraRes.ly > 0 && cameraRes.ly > maxCameraRes.ly) {

			cameraRes.ly = maxCameraRes.ly;

			modified = true;

		}

		if (modified)

			camera->setRes(cameraRes);

		*cameraPegbar->getCamera() = *m_cameras[i];

	}

}

//-----------------------------------------------------------------------------

QList<tpixel32> TSceneProperties::getNoteColors() const</tpixel32>

{

	return m_notesColor;

}

//-----------------------------------------------------------------------------

TPixel32 TSceneProperties::getNoteColor(int colorIndex) const

{

	return m_notesColor[colorIndex];

}

//-----------------------------------------------------------------------------

void TSceneProperties::setNoteColor(TPixel32 color, int colorIndex)

{

	m_notesColor[colorIndex] = color;

}