bw / opentoonz

Clone
Source Code
GIT

Files

  1.   70f81d091c03435b9b53ca38b1696f256886ddf5
  2.   toonz
  3.   sources
  4.   toonzlib
  5.   sceneproperties.cpp
Blob Blame Raw 


#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;
	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;
		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;
		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;
			attr["ext"] = ext;
			os.openChild("formatProperties", attr);
			pg->saveData(os);
			os.closeChild();
		}
		os.closeChild();

		os.closeChild(); // </output>
	}
	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 *enumAppProp = dynamic_cast<TEnumProperty *>(appProperties.getProperty(0));
										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
{
	return m_notesColor;
}

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

TPixel32 TSceneProperties::getNoteColor(int colorIndex) const
{
	return m_notesColor[colorIndex];
}

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

void TSceneProperties::setNoteColor(TPixel32 color, int colorIndex)
{
	m_notesColor[colorIndex] = color;
}

Powered by Pagure 5.7.4

SSH Hostkey/Fingerprint | Documentation | About

© 2014-2019 Red Hat, Inc. and others.

Logo by Pavel Lashutin