C++ ControlPoint::getPosition方法代码示例

	void FFTSplineControl::stretchControlPoints(float factor)
	{
		for(unsigned int i = 0; i < controlPoints.size(); i++)
		{
			ControlPoint *cp = controlPoints[i];
			assert(cp != NULL);

			float x = cp->getPosition().getX();
			x *= factor;
			cp->getPosition().setX(x);
		}
	}

	float SplineControl::getValueFromControlPoint(ControlPoint &cp)
	{
		float legendHeight = height * LEGEND_DIM;
		float legendlessHeight = height - (legendHeight * 2.0f);
		float cpy = 1.0f - ((cp.getPosition().getY() - legendHeight) / legendlessHeight);
		cpy = constrainYVal(cpy);

		return cpy;
	}

	void SplineControl::snapControlPoint(ControlPoint &cp)
	{
		float cpx = cp.getPosition().getX();
		float cpy = cp.getPosition().getY();

		// clamp x
		if(cpx < 0.0f) cpx = 0.0f;
		else if(cpx > width) cpx = width;

		// clamp y
		float legendDim = (height * LEGEND_DIM);
		if(cpy < legendDim) cpy = legendDim;
		else if(cpy > height - legendDim) cpy = (height - legendDim);

		// snap
		float snapIncrement = InterfaceManager::getBeatLength() / (float)BEAT_SNAP;
		float divs = floorf((cpx + (snapIncrement * 0.5f)) / snapIncrement);
		cpx = snapIncrement * divs;

		cp.getPosition().setX(cpx);
		cp.getPosition().setY(cpy);
	}

	/*
	void SplineControl::renderSplineControl(float SplineControlWidth)
	{
		glPushAttrib(GL_LINE_BIT | GL_CURRENT_BIT);
		
		glColor4f(1.0f, 1.0f, 1.0, 1.0f);
		glLineWidth(getLineWidth(2.0f));
		
		glEnable(GL_LINE_SMOOTH);
		glBegin(GL_LINE_STRIP);
			float increment = InterfaceManager::getBeatLength() / (float)InterfaceManager::VALUES_PER_BEAT;
			for(float f = 0.0; f <= SplineControlWidth; f+= (increment / (float)UPSAMPLE_FACTOR))
			{		
				float legendlessHeight = height - ((height * LEGEND_DIM) * 2.0f);
				float value = getValue(f);
				float vx = f;
				float vy = (value * legendlessHeight) + (height * LEGEND_DIM);
				glVertex3f(vx, height - vy, 0.0f);
			}
		glEnd();
		glDisable(GL_LINE_SMOOTH);

		glPopAttrib();
	}
	*/
	void SplineControl::savePreset(unsigned int presetType)
	{
		WavesGlobalState *wavesGlobalState = WavesGlobalState::getInstance();
		assert(wavesGlobalState != NULL);

		std::map<unsigned int, SplinePreset *> &splinePresets = wavesGlobalState->getSplinePresets();

		unsigned int numControlPoints = controlPoints.size();
		if(numControlPoints > 0)
		{
			std::vector<const Point2f> points;
			for(unsigned int i = 0; i < numControlPoints; i++)
			{
				ControlPoint *cp = controlPoints[i];
				assert(cp != NULL);

				const Point2f &cPos = cp->getPosition();
				
				float sx = cPos.getX() / width;
				float sy = cPos.getY() / height;
				Point2f sp(sx, sy);
				points.push_back(sp);
			}	
			
			// HACK : assume that if saved and Id in particular range, it must be a default and so save an altered copy
			if((!presetSaved && numControlPoints > 0) || (presetSaved && presetId >= 0 && presetId <= 5))
			{
				unsigned int pId = SplinePreset::generateId();
				
				SplinePreset *preset = new SplinePreset(pId, points, width, (SplinePreset::PresetType)presetType);	
				assert(preset != NULL);

				splinePresets[pId] = preset;
				
				preset->save();
				presetId = pId;
				presetSaved = true;
			}
			else
			{				
				SplinePreset *preset = splinePresets[presetId];
				assert(preset != NULL);

				preset->setPoints(points);
				preset->save();
			}
		}
	}

	float FFTSplineControl::getValue(float beat)
	{
		float position = beat;
		int size = controlPoints.size();

		if(size <= 0) return 0.5f;
		else if(size <= 1) 
		{
			return getValueFromControlPoint(*controlPoints[0]);
		}
		else
		{
			for(int i = 0; i < size; i++)
			{
				ControlPoint *cp = controlPoints[i];
				assert(cp != NULL);

				if(cp->getPosition().getX() >= position)
				{
					int index0 = i - 2;
					int index1 = i - 1;
					int index3 = i + 1;
					
					if(index0 < 0) index0 = i;
					if(index1 < 0) index1 = i;
					if(index3 >= size) index3 = i;

					float y0 = getValueFromControlPoint(*controlPoints[index0]);
					float y1 = getValueFromControlPoint(*controlPoints[index1]);
					float y2 = getValueFromControlPoint(*controlPoints[i]);
					float y3 = getValueFromControlPoint(*controlPoints[index3]);

					ControlPoint *cpi = controlPoints[index1];
					assert(cpi != NULL);

					float x0 = constrainXVal(index1 == i ? 0.0f : cpi->getPosition().getX());
					float x1 = constrainXVal(cp->getPosition().getX());

					// in case of a wrap around		
					float mu = 1.0f; 
					
					// guard against / 0
					if(x0 != x1) 
					{
						mu = (position - x0) / (x1 - x0);
					}

					if(x0 > x1)
					{
						float interval = x1 + (width - x0);
						mu = (position + (width - x0)) / interval;
					}	

					float returnVal = Interpolator::hermiteInterpolate(y0, y1, y2, y3, mu, Interpolator::DEFAULT_TENSION, 0.0f);
					return constrainYVal(returnVal);
				}
			}
			
			unsigned int index0 = size - 2;
			unsigned int index1 = size - 1;
			if(index0 < 0) index0 = size - 1;

			// for last segment
			float y0 = getValueFromControlPoint(*controlPoints[index0]);
			float y1 = getValueFromControlPoint(*controlPoints[index1]);
			float y2 = getValueFromControlPoint(*controlPoints[index1]);
			float y3 = getValueFromControlPoint(*controlPoints[index1]);

			ControlPoint *cpi = controlPoints[index1];
			assert(cpi != NULL);

			float x0 = constrainXVal(cpi->getPosition().getX());
			float x1 = constrainXVal(width);

			float interval = x1 + (width - x0);
			float mu = (position - x0) / interval;
		
			float returnVal = Interpolator::hermiteInterpolate(y0, y1, y2, y3, mu, Interpolator::DEFAULT_TENSION, 0.0f);
			return constrainYVal(returnVal);
		}
	}