scenix: headers diff between 5.5.8.0.0 and 5.5.8.0.8 versions

	CgFx.h	CgFx.h

	skipping to change at line 2253	skipping to change at line 2253
	*/	*/
	NVSG_API bool isLightParameter(CgFxParameter param) const;	NVSG_API bool isLightParameter(CgFxParameter param) const;

	/*! \brief Returns wheteher the specified parameter represents a light po sition.	/*! \brief Returns wheteher the specified parameter represents a light po sition.
	* \param param Parameter to query.	* \param param Parameter to query.
	* \return	* \return
	* The function returns \c true if the specified parameter represents a l ight position.	* The function returns \c true if the specified parameter represents a l ight position.
	* \remarks	* \remarks
	* \ref lightpositionparameters fall into the category of \ref autoconnec tedeffectparameters.	* \ref lightpositionparameters fall into the category of \ref autoconnec tedeffectparameters.
	*/	*/

	NVSG_API unsigned int isLightPositionParameter(CgFxParameter param) const ;	NVSG_API bool isLightPositionParameter(CgFxParameter param) const;

	/*! \brief Returns wheteher the specified parameter represents a light di rection.	/*! \brief Returns wheteher the specified parameter represents a light di rection.
	* \param param Parameter to query.	* \param param Parameter to query.
	* \return	* \return
	* The function returns \c true if the specified parameter represents a l ight direction.	* The function returns \c true if the specified parameter represents a l ight direction.
	* \remarks	* \remarks
	* \ref lightdirectionparameters fall into the category of \ref autoconne ctedeffectparameters.	* \ref lightdirectionparameters fall into the category of \ref autoconne ctedeffectparameters.
	*/	*/

	NVSG_API unsigned int isLightDirectionParameter(CgFxParameter param) cons t;	NVSG_API bool isLightDirectionParameter(CgFxParameter param) const;

	/*! \brief Returns wheteher the specified parameter represents a light ty pe.	/*! \brief Returns wheteher the specified parameter represents a light ty pe.
	* \param param Parameter to query.	* \param param Parameter to query.
	* \return	* \return
	* The function returns \c true if the specified parameter represents a l ight type.	* The function returns \c true if the specified parameter represents a l ight type.
	* \remarks	* \remarks
	* \ref lighttypeparameters fall into the category of \ref autoconnectede ffectparameters.	* \ref lighttypeparameters fall into the category of \ref autoconnectede ffectparameters.
	*/	*/

	NVSG_API unsigned int isLightTypeParameter(CgFxParameter param) const;	NVSG_API bool isLightTypeParameter(CgFxParameter param) const;

	/*! \brief Returns whether the specified parameter specifies an array of light parameters.	/*! \brief Returns whether the specified parameter specifies an array of light parameters.
	* \param param Parameter to query.	* \param param Parameter to query.
	* \return	* \return
	* The function returns \c true if the specified parameter specifies an array of	* The function returns \c true if the specified parameter specifies an array of
	* \ref lightparameters. Otherwise, the function returns \c false.	* \ref lightparameters. Otherwise, the function returns \c false.
	* \remarks	* \remarks
	* \ref lightparameters fall into the category of \ref autoconnectedeffe ctparameters.	* \ref lightparameters fall into the category of \ref autoconnectedeffe ctparameters.
	*/	*/
	NVSG_API bool isLightArrayParameter(CgFxParameter param) const;	NVSG_API bool isLightArrayParameter(CgFxParameter param) const;


		/*! \brief Returns whether the specified parameter specifies a dynamic ar
		ray of light parameters.
		* \param param Parameter to query.
		* \return
		* The function returns \c true if the specified parameter specifies a d
		ynamic array of
		* \ref lightparameters. Otherwise, the function returns \c false.
		* \remarks
		* \ref lightparameters fall into the category of \ref autoconnectedeffe
		ctparameters.
		*/
		NVSG_API bool isDynamicLightArrayParameter(CgFxParameter param) const;

	/*! \brief Returns whether the specified parameter represents a \ref mate rialparameter.	/*! \brief Returns whether the specified parameter represents a \ref mate rialparameter.
	* \param	* \param
	* param Parameter to query.	* param Parameter to query.
	* \return	* \return
	* The function returns \c true if \a param is a material parameter.	* The function returns \c true if \a param is a material parameter.
	* Otherwise, the function returns \c false.	* Otherwise, the function returns \c false.
	* \remarks	* \remarks
	* A \ref materialparameter falls into the category of \ref autoconnecte deffectparameters.	* A \ref materialparameter falls into the category of \ref autoconnecte deffectparameters.
	*/	*/
	NVSG_API bool isMaterialParameter(CgFxParameter param) const;	NVSG_API bool isMaterialParameter(CgFxParameter param) const;

	skipping to change at line 2512	skipping to change at line 2522
	/*! \brief Returns a light parameter by name.	/*! \brief Returns a light parameter by name.
	* \param	* \param
	* name Name string used to look up the light parameter.	* name Name string used to look up the light parameter.
	* \return	* \return
	* The function returns a valid handle to the \ref lightparameters "light parameter" with the	* The function returns a valid handle to the \ref lightparameters "light parameter" with the
	* specified name, if found. Otherwise, the function returns NULL, to ind icate that a light	* specified name, if found. Otherwise, the function returns NULL, to ind icate that a light
	* parameter with that name does not exist.	* parameter with that name does not exist.
	*/	*/
	NVSG_API CgFxParameter getLightByName(const std::string& name) const;	NVSG_API CgFxParameter getLightByName(const std::string& name) const;


		/*! \brief Returns whether this effect contains a dynamically sized light
		array
		* \return \c true, if the effect contains a dynamically sized light arra
		y, \c false otherwise.
		* \remarks An effect can either contain a dynamically sized light array
		or a number of normal lights and light arrays.
		*/
		NVSG_API bool hasDynamicNumberOfLights() const;

		/*! \brief Set the desired number of lights of a dynamically sized light
		array
		* \param num The number of lights the effect should have
		* \remarks An effect can either contain a dynamically sized light array
		or a number of normal lights and light arrays.
		* If the \c num is equal to the current number of lights, the function h
		as no effect.
		*/
		NVSG_API void setDynamicNumberOfLights(unsigned int num);

		/*! \brief Get the current number of lights
		* \return The current number of lights, if the effect contains a dynamic
		array of lights.
		*/
		NVSG_API unsigned int getDynamicNumberOfLights() const;

	/*! \brief Returns the effects \ref materialparameter if available.	/*! \brief Returns the effects \ref materialparameter if available.
	* \return	* \return
	* The function returns a valid handle to the material parameter, if ava ilable.	* The function returns a valid handle to the material parameter, if ava ilable.
	* Otherwise, the function returns NULL, to indicate that a material par ameter is not available	* Otherwise, the function returns NULL, to indicate that a material par ameter is not available
	* for this effect.	* for this effect.
	* \remarks	* \remarks
	* A \ref materialparameter falls into the category of \ref autoconnecte deffectparameters	* A \ref materialparameter falls into the category of \ref autoconnecte deffectparameters
	* \sa nvsg::Material, CgFxEffect::isMaterialParameter	* \sa nvsg::Material, CgFxEffect::isMaterialParameter
	*/	*/
	NVSG_API CgFxParameter getMaterial() const;	NVSG_API CgFxParameter getMaterial() const;

	/*! \brief Returns the effect's \ref sceneparameter	/*! \brief Returns the effect's \ref sceneparameter
	* \return	* \return
	* The function returns a valid handle to the NVSGScene parameter, if av ailable.	* The function returns a valid handle to the NVSGScene parameter, if av ailable.
	* Otherwise, the function returns NULL, to indicate that a scene parame ter is not available	* Otherwise, the function returns NULL, to indicate that a scene parame ter is not available
	* for this effect. Note that this is NOT the nvsg::Scene, but the	* for this effect. Note that this is NOT the nvsg::Scene, but the
	* NVSGScene data structure that may be defined in the effect!	* NVSGScene data structure that may be defined in the effect!

	* \remarks
	* A \ref materialparameter falls into the category of \ref autoconnecte
	deffectparameters
	* \sa nvsg::Scene, CgFxEffect::isSceneParameter	* \sa nvsg::Scene, CgFxEffect::isSceneParameter
	*/	*/
	NVSG_API CgFxParameter getScene() const;	NVSG_API CgFxParameter getScene() const;

	/*! \brief Returns a numeric-type parameter value as 32-bit float values.	/*! \brief Returns a numeric-type parameter value as 32-bit float values.
	* \param	* \param
	* param Handle to the parameter to retrieve the value from.	* param Handle to the parameter to retrieve the value from.
	* \param	* \param
	* value Pointer to the buffer that receives the float values.	* value Pointer to the buffer that receives the float values.
	* \return	* \return

	skipping to change at line 4987	skipping to change at line 5013
	{	{
	SharedParams();	SharedParams();
	~SharedParams();	~SharedParams();

	CgFxParameter m_scene; // NVSGScene	CgFxParameter m_scene; // NVSGScene

	// NVSG transforms known by semantic	// NVSG transforms known by semantic
	std::vector<CgFxParameter> m_transforms;	std::vector<CgFxParameter> m_transforms;

	std::vector<CgFxParameter> m_lights; // NVSGLights	std::vector<CgFxParameter> m_lights; // NVSGLights

		CgFxParameter m_dynamicLightArray; // dynamic array of NVSGLights in CgFxEffect
	CgFxParameter m_material; // NVSGMaterial	CgFxParameter m_material; // NVSGMaterial

	// MetaSL light params	// MetaSL light params
	std::vector<CgFxParameter> m_lightPositions;	std::vector<CgFxParameter> m_lightPositions;
	std::vector<CgFxParameter> m_lightDirections;	std::vector<CgFxParameter> m_lightDirections;
	std::vector<CgFxParameter> m_lightTypes;	std::vector<CgFxParameter> m_lightTypes;

	struct StateLabel {	struct StateLabel {
	StateLabel() : m_first(~0), m_second(~0) {}	StateLabel() : m_first(~0), m_second(~0) {}
	size_t m_first;	size_t m_first;

End of changes. 7 change blocks.
	6 lines changed or deleted	42 lines changed or added

	CombineTraverser.h	CombineTraverser.h

	skipping to change at line 52	skipping to change at line 52
	NVSG_API CombineTraverser( void );	NVSG_API CombineTraverser( void );

	/*! \brief Get the bitmask describing the targets to combine.	/*! \brief Get the bitmask describing the targets to combine.
	* \return A bitmask describing the targets to combine. */	* \return A bitmask describing the targets to combine. */
	NVSG_API unsigned int getCombineTargets() const;	NVSG_API unsigned int getCombineTargets() const;

	/*! \brief Set the bitmask describing the targets to combine.	/*! \brief Set the bitmask describing the targets to combine.
	* \param mask The bitmask describing the targets to combine. */	* \param mask The bitmask describing the targets to combine. */
	NVSG_API void setCombineTargets( unsigned int mask );	NVSG_API void setCombineTargets( unsigned int mask );


		//! Get the 'ignore acceleration builder' hint.
		/** If the 'ignore acceleration builder' hint is set, combinable obje
		cts with different hints are
		* still considered for combining.
		* \return true if the names will be ignored, otherwise false */
		NVSG_API bool getIgnoreAccelerationBuilderHints() const;

		//! Set the 'ignore acceleration builder' hint.
		/** If the 'ignore acceleration builder' hint is set, combinable obje
		cts with different hints are
		* still considered for combining. */
		NVSG_API void setIgnoreAccelerationBuilderHints( bool ignore );

	protected:	protected:
	//! Protected destructor to prevent instantiation of a CombineTravers er on stack.	//! Protected destructor to prevent instantiation of a CombineTravers er on stack.
	NVSG_API virtual ~CombineTraverser( void );	NVSG_API virtual ~CombineTraverser( void );

	//! Combine all GeoNodes and LODs directly underneath this AnimatedTr ansform.	//! Combine all GeoNodes and LODs directly underneath this AnimatedTr ansform.
	NVSG_API virtual void handleAnimatedTransform( nvsg::AnimatedTransfor m *p );	NVSG_API virtual void handleAnimatedTransform( nvsg::AnimatedTransfor m *p );

	//! Combine all GeoNodes and LODs directly underneath this Billboard.	//! Combine all GeoNodes and LODs directly underneath this Billboard.
	NVSG_API virtual void handleBillboard( nvsg::Billboard * p );	NVSG_API virtual void handleBillboard( nvsg::Billboard * p );


	skipping to change at line 105	skipping to change at line 116
	//! Gather TriFans to combine PrimitiveSets.	//! Gather TriFans to combine PrimitiveSets.
	NVSG_API virtual void handleTriFans( nvsg::TriFans * p );	NVSG_API virtual void handleTriFans( nvsg::TriFans * p );

	//! Gather TriStrips to combine PrimitiveSets.	//! Gather TriStrips to combine PrimitiveSets.
	NVSG_API virtual void handleTriStrips( nvsg::TriStrips * p );	NVSG_API virtual void handleTriStrips( nvsg::TriStrips * p );

	//! Keep track of the current StateSet.	//! Keep track of the current StateSet.
	NVSG_API virtual bool preTraverseDrawables(const nvsg::GeoNode* gnode , unsigned int geomIndex);	NVSG_API virtual bool preTraverseDrawables(const nvsg::GeoNode* gnode , unsigned int geomIndex);

	private:	private:

		bool areCompatible( const nvsg::GeoNode p0, const nvsg::GeoNode p1
		);
		bool areCompatible( const nvsg::Group p0, const nvsg::Group p1 );
		bool areCompatible( const nvsg::LOD p0, const nvsg::LOD p1 );
		bool areCompatible( const nvsg::Object p0, const nvsg::Object p1 );
		bool areCompatible( const nvsg::Transform *p0, const nvsg::Transform
		*p1 );

	void combineGeoNodes( nvsg::Group *p );	void combineGeoNodes( nvsg::Group *p );
	void combineLODs( nvsg::Group *p );	void combineLODs( nvsg::Group *p );
	void combineLODRanges( nvsg::LOD *p );	void combineLODRanges( nvsg::LOD *p );
	void combineTransforms( nvsg::Group *p );	void combineTransforms( nvsg::Group *p );

	// for PrimitiveSet combining:	// for PrimitiveSet combining:
	void combine( nvsg::PrimitiveSet p0, const nvsg::PrimitiveSet p1 );	void combine( nvsg::PrimitiveSet p0, const nvsg::PrimitiveSet p1 );
	void combine( nvsg::IndependentPrimitiveSetHandle p0, nvsg::Independ entPrimitiveSetHandle p1 );	void combine( nvsg::IndependentPrimitiveSetHandle p0, nvsg::Independ entPrimitiveSetHandle p1 );
	void combine( nvsg::MeshedPrimitiveSetHandle p0, nvsg::MeshedPrimiti veSetHandle p1 );	void combine( nvsg::MeshedPrimitiveSetHandle p0, nvsg::MeshedPrimiti veSetHandle p1 );
	void combine( nvsg::StrippedPrimitiveSetHandle p0, nvsg::StrippedPri mitiveSetHandle p1 );	void combine( nvsg::StrippedPrimitiveSetHandle p0, nvsg::StrippedPri mitiveSetHandle p1 );

	skipping to change at line 137	skipping to change at line 154
	void storeDrawable( TH p, std::map<nvsg::StateSetHandle , std::vect or<std::vector<TH*> > > &mvvT );	void storeDrawable( TH p, std::map<nvsg::StateSetHandle , std::vect or<std::vector<TH*> > > &mvvT );
	nvsg::IndependentPrimitiveSetHandle * simpleCombine( nvsg::Independen tPrimitiveSetHandle * p0	nvsg::IndependentPrimitiveSetHandle * simpleCombine( nvsg::Independen tPrimitiveSetHandle * p0
	, nvsg::Independen tPrimitiveSetHandle * p1 );	, nvsg::Independen tPrimitiveSetHandle * p1 );
	nvsg::MeshedPrimitiveSetHandle * simpleCombine( nvsg::MeshedPrimitive SetHandle * p0	nvsg::MeshedPrimitiveSetHandle * simpleCombine( nvsg::MeshedPrimitive SetHandle * p0
	, nvsg::MeshedPrimitive SetHandle * p1 );	, nvsg::MeshedPrimitive SetHandle * p1 );
	nvsg::StrippedPrimitiveSetHandle * simpleCombine( nvsg::StrippedPrimi tiveSetHandle * p0	nvsg::StrippedPrimitiveSetHandle * simpleCombine( nvsg::StrippedPrimi tiveSetHandle * p0
	, nvsg::StrippedPrimi tiveSetHandle * p1 );	, nvsg::StrippedPrimi tiveSetHandle * p1 );

	private:	private:
	unsigned int m_combineTargets;	unsigned int m_combineTargets;

		bool m_ignoreAccelerationBuilderHints;

	// for PrimitiveSet combining	// for PrimitiveSet combining
	nvsg::StateSetHandle * m_currentStateSet;	nvsg::StateSetHandle * m_currentStateSet;
	// For each primitive type, hold a map from the current StateSet to a vector of vector of primitives.	// For each primitive type, hold a map from the current StateSet to a vector of vector of primitives.
	// The Primitives in the second level vector are compatible to each of them.	// The Primitives in the second level vector are compatible to each of them.
	std::map<nvsg::StateSetHandle , std::vector<std::vector<nvsg::LinesH andle > > > m_lines;	std::map<nvsg::StateSetHandle , std::vector<std::vector<nvsg::LinesH andle > > > m_lines;
	std::map<nvsg::StateSetHandle , std::vector<std::vector<nvsg::LineSt ripsHandle > > > m_lineStrips;	std::map<nvsg::StateSetHandle , std::vector<std::vector<nvsg::LineSt ripsHandle > > > m_lineStrips;
	std::map<nvsg::StateSetHandle , std::vector<std::vector<nvsg::Points Handle > > > m_points;	std::map<nvsg::StateSetHandle , std::vector<std::vector<nvsg::Points Handle > > > m_points;
	std::map<nvsg::StateSetHandle , std::vector<std::vector<nvsg::QuadMe shesHandle > > > m_quadMeshes;	std::map<nvsg::StateSetHandle , std::vector<std::vector<nvsg::QuadMe shesHandle > > > m_quadMeshes;
	std::map<nvsg::StateSetHandle , std::vector<std::vector<nvsg::QuadsH andle > > > m_quads;	std::map<nvsg::StateSetHandle , std::vector<std::vector<nvsg::QuadsH andle > > > m_quads;

	skipping to change at line 162	skipping to change at line 180

	inline unsigned int CombineTraverser::getCombineTargets() const	inline unsigned int CombineTraverser::getCombineTargets() const
	{	{
	return( m_combineTargets );	return( m_combineTargets );
	}	}

	inline void CombineTraverser::setCombineTargets( unsigned int mask )	inline void CombineTraverser::setCombineTargets( unsigned int mask )
	{	{
	m_combineTargets = mask;	m_combineTargets = mask;
	}	}


		inline bool CombineTraverser::getIgnoreAccelerationBuilderHints() const
		{
		return( m_ignoreAccelerationBuilderHints );
		}

		inline void CombineTraverser::setIgnoreAccelerationBuilderHints( bool ign
		ore )
		{
		m_ignoreAccelerationBuilderHints = ignore;
		}
	}	}

End of changes. 4 change blocks.
	0 lines changed or deleted	33 lines changed or added

	Compositor.h	Compositor.h

	skipping to change at line 104	skipping to change at line 104
	In most cases the destination Node cannot do meaningful composition work un til at least	In most cases the destination Node cannot do meaningful composition work un til at least
	one source Node has completed its portion of the drawing task. In this cas e, one	one source Node has completed its portion of the drawing task. In this cas e, one
	image transfer can often be avoided by rendering one fraction of the overal l	image transfer can often be avoided by rendering one fraction of the overal l
	drawing task directly into the context associated with the destination Node .	drawing task directly into the context associated with the destination Node .
	The Compositor will then be able to combine the images obtained from the so urce Nodes	The Compositor will then be able to combine the images obtained from the so urce Nodes
	with this already-waiting image. For this reason, the destination Node mus t be	with this already-waiting image. For this reason, the destination Node mus t be
	included when calling setSortOrder() (unless specifying "arbitrary order").	included when calling setSortOrder() (unless specifying "arbitrary order").

	*/	*/


	#ifndef NVS_COMPOSITOR_H	#ifndef CPX_COMPOSITOR_H
	#define NVS_COMPOSITOR_H	#define CPX_COMPOSITOR_H


	#include "nvscale.h"	#include "complex.h"


	namespace nvs	namespace cpx
	{	{
	/*!	/*!
	* \brief Node is the interface to the compositor network for a	* \brief Node is the interface to the compositor network for a
	* GL-context/thread.	* GL-context/thread.

	* \par Namespace: nvs	* \par Namespace: cpx
	* \remarks	* \remarks
	* The Node acts either as an image producer (source Node) or an image	* The Node acts either as an image producer (source Node) or an image
	* consumer (destination Node). The role of a Node is defined by the C ompositor	* consumer (destination Node). The role of a Node is defined by the C ompositor
	* at creation time and cannot be changed during the lifetime of the ob ject	* at creation time and cannot be changed during the lifetime of the ob ject
	* (see Compositor::getNode).	* (see Compositor::getNode).
	* A Node is tightly associated with the GL context which is current wh en	* A Node is tightly associated with the GL context which is current wh en
	* its initialize() method is called. After initialize(), the associat ed GL	* its initialize() method is called. After initialize(), the associat ed GL
	* context for a particular Node must ALWAYS be current whenever calls are	* context for a particular Node must ALWAYS be current whenever calls are
	* made to that Node's methods.	* made to that Node's methods.
	*/	*/
	class Node	class Node
	{	{
	private:	private:
	Node(const Node &rhs);	Node(const Node &rhs);
	Node &operator=(const Node &rhs);	Node &operator=(const Node &rhs);

	protected:	protected:
	Node() {}	Node() {}

	virtual NVS_API ~Node() {}	virtual CPX_API ~Node() {}

	public:	public:
	/*!	/*!
	* \brief Initialize the GL-part of a Node on a given current conte xt.	* \brief Initialize the GL-part of a Node on a given current conte xt.
	* \return	* \return

	* 'NVS_SUCCESS' on success;\n	* 'CPX_R_SUCCESS' on success;\n
	* 'NVS_SYNCHRONIZATION_ERROR' if the node is locked by the Composi	* 'CPX_R_SYNCHRONIZATION_ERROR' if the node is locked by the Compo
	tor	sitor
	* due to a configuration call from another thread;\n	* due to a configuration call from another thread;\n

	* 'NVS_INVALID_PIXELFORMAT' if the pixelformat of the current draw able	* 'CPX_R_INVALID_PIXELFORMAT' if the pixelformat of the current dr awable
	* is not suitable for compositing;\n	* is not suitable for compositing;\n

	* 'NVS_MISSING_EXTENSION' if the Compositor cannot load required G L	* 'CPX_R_MISSING_EXTENSION' if the Compositor cannot load required GL
	* extensions;\n	* extensions;\n

	* 'NVS_PIXELFORMAT_MISMATCH' if the nodes use drawables of differe nt	* 'CPX_R_PIXELFORMAT_MISMATCH' if the nodes use drawables of diffe rent
	* formats;\n	* formats;\n

	* 'NVS_INVALID_FBO' if the FBO is of an incorrect format;\n	* 'CPX_R_INVALID_FBO' if the FBO is of an incorrect format;\n
	* 'NVS_GL_ERROR' in case of GL errors.\n	* 'CPX_R_GL_ERROR' in case of GL errors.\n
	* \remarks	* \remarks
	* Depending on Compositor and system configuration, this may (or m ay	* Depending on Compositor and system configuration, this may (or m ay
	* not) be a blocking method. In the blocking case, this method wi ll	* not) be a blocking method. In the blocking case, this method wi ll
	* not return until all other Nodes have also entered initialize(). For	* not return until all other Nodes have also entered initialize(). For
	* this reason, to avoid deadlock, serial Node initialization must be	* this reason, to avoid deadlock, serial Node initialization must be
	* avoided since it causes one Node's entry to initialize() to depe nd	* avoided since it causes one Node's entry to initialize() to depe nd
	* circularly on another's exit. Only call Node::initialize() from a	* circularly on another's exit. Only call Node::initialize() from a
	* different asynchronous thread for each GPU.	* different asynchronous thread for each GPU.
	*/	*/

	virtual NVS_API Result initialize(void) = 0;	virtual CPX_API Result initialize(void) = 0;

	/*!	/*!
	* \brief Delete GL resources associated with the Node.	* \brief Delete GL resources associated with the Node.
	* \return	* \return

	* 'NVS_SUCCESS' on success;\n	* 'CPX_R_SUCCESS' on success;\n
	* 'NVS_SYNCHRONIZATION_ERROR' if the Node is locked by the Composi	* 'CPX_R_CONTEXT_MISMATCH' if the context bound by initialize() is
	tor	not current;\n
		* 'CPX_R_SYNCHRONIZATION_ERROR' if the Node is locked by the Compo
		sitor
	* due to a configuration call from another thread;\n	* due to a configuration call from another thread;\n

	* 'NVS_GL_ERROR' in case of GL errors.\n	* 'CPX_R_GL_ERROR' in case of GL errors.\n
	*/	*/

	virtual NVS_API Result terminate(void) = 0;	virtual CPX_API Result terminate(void) = 0;

	/*!	/*!
	* \brief Perform the actual compositing step.	* \brief Perform the actual compositing step.
	* \return	* \return

	* 'NVS_SUCCESS' on success;\n	* 'CPX_R_SUCCESS' on success;\n
	* 'NVS_SYNCHRONIZATION_ERROR' if the Node is locked by the Composi	* 'CPX_R_CONTEXT_MISMATCH' if the context bound by initialize() is
	tor	not current;\n
		* 'CPX_R_SYNCHRONIZATION_ERROR' if the Node is locked by the Compo
		sitor
	* due to a configuration call from another thread;\n	* due to a configuration call from another thread;\n

	* 'NVS_RESIZE_FAILED' if the Compositor failed to resize the inter nal	* 'CPX_R_RESIZE_FAILED' if the Compositor failed to resize the int ernal
	* buffers involved in compositing;\n	* buffers involved in compositing;\n

	* 'NVS_GL_ERROR' in case of GL errors.\n	* 'CPX_R_GL_ERROR' in case of GL errors.\n
	*	*
	* \remarks	* \remarks
	* To execute a complete compositing step this method needs to be c alled	* To execute a complete compositing step this method needs to be c alled
	* on all Node instances belonging to the governing Compositor inst ance.	* on all Node instances belonging to the governing Compositor inst ance.
	* \remarks	* \remarks
	* If the Node is in the role of an image producer, it will make th e	* If the Node is in the role of an image producer, it will make th e
	* image data in its buffer available to the consumer Node, and may	* image data in its buffer available to the consumer Node, and may
	* block until the consumer signals completion before returning.	* block until the consumer signals completion before returning.
	* \remarks	* \remarks
	* If the Node is in the consumer role, it will wait for the produc ers	* If the Node is in the consumer role, it will wait for the produc ers

	skipping to change at line 212	skipping to change at line 214
	* - No Node may depend on the return of another Node from composit e()	* - No Node may depend on the return of another Node from composit e()
	* in order to initiate its own composite() call.	* in order to initiate its own composite() call.
	*	*
	* \b Guarantees\b : (NOT barrier-like)	* \b Guarantees\b : (NOT barrier-like)
	* - As soon as composite() returns on any Node, that Node is free (and	* - As soon as composite() returns on any Node, that Node is free (and
	* encouraged) to begin other work or start on the next frame.	* encouraged) to begin other work or start on the next frame.
	* - When composite() returns on the consumer Node (only), all othe r	* - When composite() returns on the consumer Node (only), all othe r
	* Nodes have at least begun their own composite() calls, and som e may	* Nodes have at least begun their own composite() calls, and som e may
	* have completed them and moved on.	* have completed them and moved on.
	*/	*/

	virtual NVS_API Result composite(void)=0;	virtual CPX_API Result composite(void)=0;
	};	};

	/*!	/*!
	* \brief Helper class to specify a rectangle.	* \brief Helper class to specify a rectangle.

	* \par Namespace: nvs	* \par Namespace: cpx
	*/	*/
	class Rect	class Rect
	{	{
	public:	public:
	/*!	/*!
	* \brief Construct an invalid, but legal Rect	* \brief Construct an invalid, but legal Rect
	* \remarks	* \remarks
	* A valid Rect must have non-negative extent, but this particular	* A valid Rect must have non-negative extent, but this particular
	* invalid Rect is legal for use in some cases. This is the ONLY	* invalid Rect is legal for use in some cases. This is the ONLY
	* legal but invalid Rect.	* legal but invalid Rect.
	*/	*/

	NVS_API Rect(void)	CPX_API Rect(void)
	: x(-1), y(-1), w(-1), h(-1)	: x(-1), y(-1), w(-1), h(-1)
	{}	{}

	/*!	/*!
	* \brief Construct a Rect with the given extent, centered at the o rigin.	* \brief Construct a Rect with the given extent, centered at the o rigin.
	*/	*/

	NVS_API Rect(int _w, int _h)	CPX_API Rect(int _w, int _h)
	: x(0), y(0), w(_w), h(_h)	: x(0), y(0), w(_w), h(_h)
	{}	{}

	/*!	/*!
	* \brief Construct a Rect with explicit control over position and extent.	* \brief Construct a Rect with explicit control over position and extent.
	*/	*/

	NVS_API Rect(int _x, int _y, int _w, int _h)	CPX_API Rect(int _x, int _y, int _w, int _h)
	: x(_x), y(_y), w(_w), h(_h)	: x(_x), y(_y), w(_w), h(_h)
	{}	{}

	/*!	/*!
	* \brief Test if the receiver is legal to use.	* \brief Test if the receiver is legal to use.
	* \return	* \return
	* 'true' if the receiver is valid or the special invalid Rect,	* 'true' if the receiver is valid or the special invalid Rect,
	* 'false' otherwise.	* 'false' otherwise.
	*/	*/

	NVS_API bool isLegal(void) const;	CPX_API bool isLegal(void) const;

	/*!	/*!
	* \brief Test if the receiver is valid.	* \brief Test if the receiver is valid.
	* \return	* \return
	* 'true' if the receiver has positive extent, 'false' otherwise.	* 'true' if the receiver has positive extent, 'false' otherwise.
	*/	*/
	// In debug builds, this asserts at least isLegal(), whether valid or not.	// In debug builds, this asserts at least isLegal(), whether valid or not.

	NVS_API bool isValid(void) const;	CPX_API bool isValid(void) const;

	public:	public:
	int x; //!< left coordinate of the lower-left poin t	int x; //!< left coordinate of the lower-left poin t
	int y; //!< bottom coordinate of the lower-left po int	int y; //!< bottom coordinate of the lower-left po int
	int w; //!< extent to the right	int w; //!< extent to the right
	int h; //!< extent upwards	int h; //!< extent upwards
	};	};

	/*!	/*!
	* \brief The class used to configure and manage Nodes.	* \brief The class used to configure and manage Nodes.

	* \par Namespace: nvs	* \par Namespace: cpx
	* \remarks	* \remarks
	* The actual composition event is triggered through the Nodes received from	* The actual composition event is triggered through the Nodes received from
	* this class, but it is configured via setLayout and setSortOrder here .	* this class, but it is configured via setLayout and setSortOrder here .
	* The details of the composition operation are determined by the	* The details of the composition operation are determined by the
	* CompositionTechnique for which the Compositor was created by the Fac tory	* CompositionTechnique for which the Compositor was created by the Fac tory

	* (ex: NVS_CT_DEPTH). A Compositor instance is not bound to any parti cular	* (ex: CPX_CT_DEPTH). A Compositor instance is not bound to any parti cular
	* thread or GL context. However, the client must assure that it is ne ver	* thread or GL context. However, the client must assure that it is ne ver
	* accessed concurrently by multiple threads, or while any thread is ca lling	* accessed concurrently by multiple threads, or while any thread is ca lling
	* a method on any of its constituent Nodes. In many cases, concurrent	* a method on any of its constituent Nodes. In many cases, concurrent
	* access can be detected, but the result is function failure with the	* access can be detected, but the result is function failure with the

	* NVS_SYNCHRONIZATION_ERROR Result code. As each such return represen ts a	* CPX_R_SYNCHRONIZATION_ERROR Result code. As each such return repres ents a
	* non-deterministic failure, care should be taken to ensure that	* non-deterministic failure, care should be taken to ensure that

	* NVS_SYNCHRONIZATION_ERROR results NEVER crop up.	* CPX_R_SYNCHRONIZATION_ERROR results NEVER crop up.
	*/	*/
	class Compositor	class Compositor
	{	{
	private:	private:
	Compositor(const Compositor &rhs);	Compositor(const Compositor &rhs);
	Compositor &operator=(const Compositor &rhs);	Compositor &operator=(const Compositor &rhs);

	protected:	protected:
	friend class FactoryImpl;	friend class FactoryImpl;
	Compositor() {}	Compositor() {}

	skipping to change at line 311	skipping to change at line 313
	* \param idx	* \param idx
	* Index of the Node to get. The Node with idx==0 is the destinatio n	* Index of the Node to get. The Node with idx==0 is the destinatio n
	* Node; other Nodes are source Nodes (see Node for more descriptio n).	* Node; other Nodes are source Nodes (see Node for more descriptio n).
	* \return	* \return
	* Pointer to the Node instance, or NULL if idx is invalid.	* Pointer to the Node instance, or NULL if idx is invalid.
	* \remarks	* \remarks
	* The lifetime of Nodes is bound to the lifetime of the	* The lifetime of Nodes is bound to the lifetime of the
	* Compositor, i.e. Nodes are created and destroyed with the	* Compositor, i.e. Nodes are created and destroyed with the
	* Compositor, invalidating all pointers obtained through this meth od.	* Compositor, invalidating all pointers obtained through this meth od.
	*/	*/

	virtual NVS_API Node* getNode(int idx)=0;	virtual CPX_API Node* getNode(int idx)=0;

	/*!	/*!
	* \brief Get the number of Nodes in the Compositor network.	* \brief Get the number of Nodes in the Compositor network.
	* \return	* \return
	* Number of Nodes in the Compositor network.	* Number of Nodes in the Compositor network.
	*/	*/

	virtual NVS_API int getNumNodes(void)=0;	virtual CPX_API int getNumNodes(void)=0;

	/*!	/*!
	* \brief Specifiy how source tiles are mapped to destination tiles .	* \brief Specifiy how source tiles are mapped to destination tiles .
	* \param srcNodeIndex	* \param srcNodeIndex
	* The source Node index from which the rectangle of source image d ata	* The source Node index from which the rectangle of source image d ata

	* is read. If srcNodeIndex is set to NVS_ALL_NODES the layout is applied to	* is read. If srcNodeIndex is set to CPX_ALL_NODES the layout is applied to
	* all source nodes; otherwise note that the Node with index 0 is n ot a source	* all source nodes; otherwise note that the Node with index 0 is n ot a source
	* Node, and setLayout may not be called on it directly.	* Node, and setLayout may not be called on it directly.
	* \param srcRect	* \param srcRect
	* The rectangle from which source image data is read. Relative to the	* The rectangle from which source image data is read. Relative to the
	* current viewport on the source Node.	* current viewport on the source Node.
	* \param dstRect	* \param dstRect
	* The rectangle into which source image data is composited in the	* The rectangle into which source image data is composited in the
	* destination buffer. Relative to the viewport on the destination	* destination buffer. Relative to the viewport on the destination
	* Node. By default, dstRect is assumed to be the same as srcRect, but	* Node. By default, dstRect is assumed to be the same as srcRect, but
	* note that this can produce unexpected results if the correspondi ng	* note that this can produce unexpected results if the correspondi ng
	* viewports are NOT the same.	* viewports are NOT the same.
	* \return	* \return

	* 'NVS_SUCCESS' on success,	* 'CPX_R_SUCCESS' on success,
	* 'NVS_SYNCHRONIZATION_ERROR' if one of the Nodes is active,	* 'CPX_R_SYNCHRONIZATION_ERROR' if one of the Nodes is active,
	* 'NVS_INVALID_OBJECT' if srcNodeIndex does not name a Node (or AL	* 'CPX_R_INVALID_OBJECT' if srcNodeIndex does not name a Node (or
	L_NODES),	ALL_NODES),
	* 'NVS_INVALID_VALUE' if the srcRect or dstRect is invalid.	* 'CPX_R_INVALID_VALUE' if the srcRect or dstRect is invalid.
	* \remarks	* \remarks
	* The method will only succeed if all Compositor Nodes are outside the	* The method will only succeed if all Compositor Nodes are outside the
	* composite call. This functions creates/resizes all Compositor	* composite call. This functions creates/resizes all Compositor
	* internal buffers. Therefore this function must be called before	* internal buffers. Therefore this function must be called before
	* the composite is triggered.	* the composite is triggered.
	*/	*/

	virtual NVS_API Result setLayout(int srcNodeIndex, const Rect& srcR ect,	virtual CPX_API Result setLayout(int srcNodeIndex, const Rect& srcR ect,
	const Rect& dstRect=Rect())=0;	const Rect& dstRect=Rect())=0;

	/*!	/*!
	* \brief Set the compositing order.	* \brief Set the compositing order.
	* \param len	* \param len
	* Specifies the number of elements pointed to by list; must equal	* Specifies the number of elements pointed to by list; must equal
	* getNumNodes(), OR 0 to indicate "arbitrary order".	* getNumNodes(), OR 0 to indicate "arbitrary order".
	* \param list	* \param list
	* Specifies nNde indices in the order in which their buffers shoul d be	* Specifies nNde indices in the order in which their buffers shoul d be
	* composited. Each node index should appear exactly once, but the	* composited. Each node index should appear exactly once, but the

	skipping to change at line 369	skipping to change at line 371
	* if len is 0, to indicate "arbitrary order".	* if len is 0, to indicate "arbitrary order".
	* \remarks	* \remarks
	* Composition sort order can only be changed if none of the Nodes is	* Composition sort order can only be changed if none of the Nodes is
	* inside a composite() call. Most compositing techniques are	* inside a composite() call. Most compositing techniques are
	* order-independent, and should not override the default (which is	* order-independent, and should not override the default (which is
	* arbitrary-order). Default arbitrary order can be restored by pa ssing	* arbitrary-order). Default arbitrary order can be restored by pa ssing
	* 0 for len and NULL for list. Alpha compositing, however, must	* 0 for len and NULL for list. Alpha compositing, however, must
	* composite Nodes back-to-front according to the depth (in eye spa ce)	* composite Nodes back-to-front according to the depth (in eye spa ce)
	* of their respective portions of the dataset.	* of their respective portions of the dataset.
	* \return	* \return

	* 'NVS_SUCCESS' if successful;	* 'CPX_R_SUCCESS' if successful;
	* 'NVS_SYNCHRONIZATION_ERROR' if one of the Nodes is active;	* 'CPX_R_SYNCHRONIZATION_ERROR' if one of the Nodes is active;
	* 'NVS_INVALID_PARAM' if len is not 0 or getNumNodes();	* 'CPX_R_INVALID_PARAM' if len is not 0 or getNumNodes();
	* 'NVS_INVALID_PARAM' if list is NULL and len is not 0 or vice-ver	* 'CPX_R_INVALID_PARAM' if list is NULL and len is not 0 or vice-v
	sa;	ersa;
	* 'NVS_INVALID_OBJECT' if not all (and only) Node indices appear i	* 'CPX_R_INVALID_OBJECT' if not all (and only) Node indices appear
	n list.	in list.
	* 'NVS_INVALID_VALUE' if the CompositionTechnique in use requires	* 'CPX_R_INVALID_VALUE' if the CompositionTechnique in use require
	an	s an
	* explicit sort order, but "arbitrary order" is requested.	* explicit sort order, but "arbitrary order" is requested.
	*/	*/

	virtual NVS_API Result setSortOrder(int len, int* list)=0;	virtual CPX_API Result setSortOrder(int len, int* list)=0;
	};	};
	};	};
	#endif	#endif

End of changes. 35 change blocks.
	55 lines changed or deleted	59 lines changed or added

	Factory.h	Factory.h

	skipping to change at line 21	skipping to change at line 21
	// POSSIBILITY OF SUCH DAMAGES	// POSSIBILITY OF SUCH DAMAGES

	/*!	/*!
	* \file	* \file
	* \brief	* \brief
	*/	*/

	#ifndef _FACTORY_H	#ifndef _FACTORY_H
	#define _FACTORY_H	#define _FACTORY_H


	#include "nvscale.h"	#include "complex.h"


	namespace nvs	namespace cpx
	{	{
	class Compositor;	class Compositor;
	class RenderArea;	class RenderArea;
	class Distributor;	class Distributor;

	/*!	/*!
	* \brief The Factory is a singleton which creates instances of the	* \brief The Factory is a singleton which creates instances of the

	* various component types included in the NVScale library.	* various component types included in the CompleX library.
	* \par Namespace: nvs	* \par Namespace: cpx
	*/	*/
	class Factory	class Factory
	{	{
	private:	private:
	friend class FactoryImpl;	friend class FactoryImpl;
	friend class FactoryInternal;	friend class FactoryInternal;
	Factory(void);	Factory(void);
	Factory(const Factory &rhs);	Factory(const Factory &rhs);
	Factory &operator=(const Factory &rhs);	Factory &operator=(const Factory &rhs);

	protected:	protected:
	virtual ~Factory() {}	virtual ~Factory() {}

	public:	public:
	/*!	/*!
	* \brief Get a pointer to the global Factory instance.	* \brief Get a pointer to the global Factory instance.
	*/	*/

	static NVS_API Factory* getInstance(void);	static CPX_API Factory* getInstance(void);

	/*!	/*!
	* \brief Create a Compositor employing the requested technique.	* \brief Create a Compositor employing the requested technique.
	* \param out	* \param out
	* The output parameter that will receive the Compositor instance.	* The output parameter that will receive the Compositor instance.
	* On successful return, instance will control a network of numNode s	* On successful return, instance will control a network of numNode s
	* Nodes, using CompositionTechnique tech.	* Nodes, using CompositionTechnique tech.
	* \param tech	* \param tech
	* The technique to be employed by the created Compositor.	* The technique to be employed by the created Compositor.
	* Must be one of the techniques enumerated in CompositionTechnique :\n	* Must be one of the techniques enumerated in CompositionTechnique :\n

	* 'NVS_CT_DEPTH' for composition based on depth buffer values;\n	* 'CPX_CT_DEPTH' for composition based on depth buffer values;\n
	* 'NVS_CT_ALPHA' for composition based on alpha channel values;\n	* 'CPX_CT_ALPHA' for composition based on alpha channel values;\n
	* 'NVS_CT_SCREEN' for composition based solely on order and layout	* 'CPX_CT_SCREEN' for composition based solely on order and layout
	settings;\n	settings;\n
	* 'NVS_CT_SKIP' to go through the motions of composition, but not	* 'CPX_CT_SKIP' to go through the motions of composition, but not
	move any data.\n	move any data.\n
	* \param numNodes	* \param numNodes
	* Number of Nodes in the compositor network including all source N odes	* Number of Nodes in the compositor network including all source N odes
	* and the destination Node. Must be at least 2.	* and the destination Node. Must be at least 2.
	* \return	* \return

	* 'NVS_INVALID_ENUM' if tech is NVS_CT_INVALID or not an accepted	* 'CPX_R_INVALID_ENUM' if tech is CPX_CT_INVALID or not an accepte
	value;\n	d value;\n
	* 'NVS_INVALID_PARAM' if out is NULL;\n	* 'CPX_R_INVALID_PARAM' if out is NULL;\n
	* 'NVS_INVALID_PARAM' if numNodes is not at least 2;\n	* 'CPX_R_INVALID_PARAM' if numNodes is not at least 2;\n
	* 'NVS_GENERIC_FAILURE' if the Compositor could not be created;\n	* 'CPX_R_GENERIC_FAILURE' if the Compositor could not be created;\
	* 'NVS_SUCCESS' otherwise.\n	n
		* 'CPX_R_SUCCESS' otherwise.\n
	*/	*/

	virtual NVS_API Result createCompositor(Compositor **out,	virtual CPX_API Result createCompositor(Compositor **out,
	CompositionTechnique tech,	CompositionTechnique tech,
	int numNodes) = 0;	int numNodes) = 0;

	/*!	/*!
	* \brief Destroy a compositor previously created by the factory.	* \brief Destroy a compositor previously created by the factory.
	* \param compositor The Compositor object to destroy.	* \param compositor The Compositor object to destroy.
	* \return	* \return

	* 'NVS_INVALID_OBJECT' if compositor is NULL;\n	* 'CPX_R_INVALID_OBJECT' if compositor is NULL;\n
	* 'NVS_SUCCESS' otherwise.\n	* 'CPX_R_SUCCESS' otherwise.\n
	*/	*/

	virtual NVS_API Result destroyCompositor(Compositor *compositor) = 0;	virtual CPX_API Result destroyCompositor(Compositor *compositor) = 0;

	/*!	/*!
	* \brief Create a Distributor employing the specified technique.	* \brief Create a Distributor employing the specified technique.
	* \param out	* \param out
	* The output parameter that will receive the Distributor instance.	* The output parameter that will receive the Distributor instance.
	* \param tech	* \param tech
	* The technique to be employed by the created Distributor.	* The technique to be employed by the created Distributor.
	* Must be one of the techniques enumerated in DistributionTechniqu e:\n	* Must be one of the techniques enumerated in DistributionTechniqu e:\n

	* 'NVS_DT_GREEDY' for simple weight-minimization (suitable for dep	* 'CPX_DT_GREEDY' for simple weight-minimization (suitable for dep
	th composition);\n	th composition);\n
	* 'NVS_DT_SPATIAL' for spatially partitioned distribution (for alp	* 'CPX_DT_SPATIAL' for spatially partitioned distribution (for alp
	ha composition).\n	ha composition).\n
	* \param numNodes	* \param numNodes
	* The number of Nodes that will render a portion of the scene. Th is is	* The number of Nodes that will render a portion of the scene. Th is is
	* usually the number of Nodes in the compositor network.	* usually the number of Nodes in the compositor network.
	* \return	* \return

	* 'NVS_INVALID_ENUM' if tech is NVS_DT_INVALID or not an accepted	* 'CPX_R_INVALID_ENUM' if tech is CPX_DT_INVALID or not an accepte
	value;\n	d value;\n
	* 'NVS_INVALID_PARAM' if out is NULL;\n	* 'CPX_R_INVALID_PARAM' if out is NULL;\n
	* 'NVS_INVALID_PARAM' if numNodes is not at least 2;\n	* 'CPX_R_INVALID_PARAM' if numNodes is not at least 2;\n
	* 'NVS_GENERIC_FAILURE' if the Distributor could not be created;\n	* 'CPX_R_GENERIC_FAILURE' if the Distributor could not be created;
	* 'NVS_SUCCESS' otherwise.\n	\n
		* 'CPX_R_SUCCESS' otherwise.\n
	* \remarks	* \remarks
	* A Distributor handles the task of deciding which scene objects a re	* A Distributor handles the task of deciding which scene objects a re
	* rendered on which Nodes in a distributed rendering environment. Using	* rendered on which Nodes in a distributed rendering environment. Using
	* a Distributor is not required for composition to work, but any	* a Distributor is not required for composition to work, but any
	* alternative manual distribution technique must produce results w hich	* alternative manual distribution technique must produce results w hich
	* are compatible with the desired CompositionTechnique. Alpha	* are compatible with the desired CompositionTechnique. Alpha

	* composition (NVS_CT_ALPHA) requires strict depth-sortability of	* composition (CPX_CT_ALPHA) requires strict depth-sortability of
	the portions	the portions
	* rendered on each Node. Depth composition (NVS_CT_DEPTH) require	* rendered on each Node. Depth composition (CPX_CT_DEPTH) require
	s that translucent	s that translucent
	* objects be rendered after image composition on the Node that hos ts	* objects be rendered after image composition on the Node that hos ts
	* the composited image.	* the composited image.
	* \remarks	* \remarks
	* When using depth or alpha composition, the recommended Distribut or	* When using depth or alpha composition, the recommended Distribut or
	* can be created by passing the result of	* can be created by passing the result of
	* getRecommendedDistributionTechnique() to this method.	* getRecommendedDistributionTechnique() to this method.
	* \sa getRecommendedDistributionTechnique()	* \sa getRecommendedDistributionTechnique()
	*/	*/

	virtual NVS_API Result createDistributor(Distributor **out,	virtual CPX_API Result createDistributor(Distributor **out,
	DistributionTechnique tech ,	DistributionTechnique tech ,
	int numNodes) = 0;	int numNodes) = 0;

	/*!	/*!
	* \brief Destroy a distributor previously created by the factory.	* \brief Destroy a distributor previously created by the factory.
	* \param distributor The Distributor object to destroy.	* \param distributor The Distributor object to destroy.
	* \return	* \return

	* 'NVS_INVALID_OBJECT' if distributor is NULL;\n	* 'CPX_R_INVALID_OBJECT' if distributor is NULL;\n
	* 'NVS_SUCCESS' otherwise.\n	* 'CPX_R_SUCCESS' otherwise.\n
	*/	*/

	virtual NVS_API Result destroyDistributor(Distributor *distributor) = 0;	virtual CPX_API Result destroyDistributor(Distributor *distributor) = 0;

	/*!	/*!
	* \brief	* \brief
	* Get the recommended distribution technique for the specified	* Get the recommended distribution technique for the specified
	* CompositionTechnique.	* CompositionTechnique.
	* \param tech	* \param tech
	* One of the techniques enumerated in CompositionTechnique.	* One of the techniques enumerated in CompositionTechnique.
	* \return	* \return

	* NVS_DT_INVALID if tech does not name a CompositionTechnique	* CPX_DT_INVALID if tech does not name a CompositionTechnique
	* for which recommendations are available, otherwise the recommend ed	* for which recommendations are available, otherwise the recommend ed
	* DistributionTechnique.	* DistributionTechnique.
	* \remarks	* \remarks
	* A Distributor handles the task of deciding which scene objects a re	* A Distributor handles the task of deciding which scene objects a re
	* rendered on which Nodes in a distributed rendering environment. Using	* rendered on which Nodes in a distributed rendering environment. Using
	* a Distributor is not required for composition to work, but any	* a Distributor is not required for composition to work, but any
	* alternative manual distribution technique must produce results w ith	* alternative manual distribution technique must produce results w ith
	* similarly compatible characteristics. Alpha composition require s	* similarly compatible characteristics. Alpha composition require s
	* strict depth-sortability of portions rendered on each Node. Dep th	* strict depth-sortability of portions rendered on each Node. Dep th
	* composition requires that translucent objects be rendered after image	* composition requires that translucent objects be rendered after image
	* composition on the Node that hosts the composited image.	* composition on the Node that hosts the composited image.
	* \remarks	* \remarks
	* The returned DistributorType can be used to instantiate a Distri butor	* The returned DistributorType can be used to instantiate a Distri butor
	* object by calling createDistributor(). It is an error to create a	* object by calling createDistributor(). It is an error to create a

	* Distributor of type NVS_DT_INVALID.	* Distributor of type CPX_DT_INVALID.
	* \sa createDistributor	* \sa createDistributor
	*/	*/

	virtual NVS_API DistributionTechnique	virtual CPX_API DistributionTechnique
	getRecommendedDistributionTechnique(CompositionTechnique tech) = 0;	getRecommendedDistributionTechnique(CompositionTechnique tech) = 0;

	/*!	/*!
	* \brief Create a RenderArea, as-yet unaffiliated with a specific GPU.	* \brief Create a RenderArea, as-yet unaffiliated with a specific GPU.
	* \param out	* \param out
	* The output parameter that will receive the RenderArea instance.	* The output parameter that will receive the RenderArea instance.
	* \remarks	* \remarks
	* The RenderArea must be initialized and then resized before it ca n be	* The RenderArea must be initialized and then resized before it ca n be
	* used.	* used.
	* \return	* \return

	* 'NVS_INVALID_PARAM' if out is NULL;\n	* 'CPX_R_INVALID_PARAM' if out is NULL;\n
	* 'NVS_SUCCESS' otherwise.\n	* 'CPX_R_SUCCESS' otherwise.\n
	* \sa RenderArea::initialize	* \sa RenderArea::initialize
	* \sa RenderArea::resize	* \sa RenderArea::resize
	*/	*/

	virtual NVS_API Result createRenderArea(RenderArea **out) = 0;	virtual CPX_API Result createRenderArea(RenderArea **out) = 0;

	/*!	/*!
	* \brief Destroy a RenderArea obtained with createRenderArea()	* \brief Destroy a RenderArea obtained with createRenderArea()
	* \param ra The RenderArea to destroy.	* \param ra The RenderArea to destroy.
	* \return	* \return

	* 'NVS_INVALID_OBJECT' if ra is NULL;\n	* 'CPX_R_INVALID_OBJECT' if ra is NULL;\n
	* 'NVS_SUCCESS' otherwise.\n	* 'CPX_R_SUCCESS' otherwise.\n
	*/	*/

	virtual NVS_API Result destroyRenderArea(RenderArea *ra) = 0;	virtual CPX_API Result destroyRenderArea(RenderArea *ra) = 0;
	};	};
	};	};
	#endif	#endif

End of changes. 22 change blocks.
	48 lines changed or deleted	50 lines changed or added

	LightSource.h	LightSource.h

	skipping to change at line 48	skipping to change at line 48
	* \note A LightSource has no method to turn light sources on or off. Th is functionality is	* \note A LightSource has no method to turn light sources on or off. Th is functionality is
	* located in the Group holding the LightSource objects.	* located in the Group holding the LightSource objects.
	* \note LightSource objects only influence objects beneath the Group th e LightSource is part	* \note LightSource objects only influence objects beneath the Group th e LightSource is part
	* of.	* of.
	* \sa DirectedLight, PointLight, SpotLight, Switch */	* \sa DirectedLight, PointLight, SpotLight, Switch */
	class LightSource : public OwnedObject<GroupHandle>	class LightSource : public OwnedObject<GroupHandle>
	{	{
	friend class Group;	friend class Group;

	public:	public:

	static MetaSLLightParameterNames m_metaSLLightParameterNames[8];

	public:
	/*! \brief Destructs a LightSource.	/*! \brief Destructs a LightSource.
	* If the LightSource holds an Animation, its reference count is dec remented.	* If the LightSource holds an Animation, its reference count is dec remented.
	* \sa addRef, removeRef */	* \sa addRef, removeRef */
	NVSG_API virtual ~LightSource();	NVSG_API virtual ~LightSource();

	NVSG_API virtual void syncEffectLight(CgFxEffect * fx, CgFxParameter fxLight, const nvmath::Mat44f& modelToWorld) const {}	NVSG_API virtual void syncEffectLight(CgFxEffect * fx, CgFxParameter fxLight, const nvmath::Mat44f& modelToWorld) const {}
	NVSG_API virtual void syncMetaSLLightParameters(CgFxEffect * fx, unsi gned int light, const nvmath::Mat44f& world, const nvmath::Mat44f& view) co nst {}	NVSG_API virtual void syncMetaSLLightParameters(CgFxEffect * fx, unsi gned int light, const nvmath::Mat44f& world, const nvmath::Mat44f& view) co nst {}

	/*! \brief Get the ambient color of this LightSource.	/*! \brief Get the ambient color of this LightSource.
	* \return A reference to the constant ambient color.	* \return A reference to the constant ambient color.

End of changes. 1 change blocks.
	3 lines changed or deleted	0 lines changed or added

	NVSGVersion.h	NVSGVersion.h

	skipping to change at line 30	skipping to change at line 30
	// - There must be no unnecessary leading zeros in the numbers.	// - There must be no unnecessary leading zeros in the numbers.
	// (e.g.: don't use '02' - use '2' instead)	// (e.g.: don't use '02' - use '2' instead)
	//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -	//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
	#define NVSG_VER_MAIN 5 // marketing main version	#define NVSG_VER_MAIN 5 // marketing main version
	#define NVSG_VER_AUX 5 // marketing auxiliary version	#define NVSG_VER_AUX 5 // marketing auxiliary version

	#define NVSG_VER_MAJOR 8	#define NVSG_VER_MAJOR 8
	#define NVSG_VER_MINOR 0	#define NVSG_VER_MINOR 0

	#if !defined(NVSG_VER_BUILD)	#if !defined(NVSG_VER_BUILD)

	#define NVSG_VER_BUILD 0	#define NVSG_VER_BUILD 8
	#endif	#endif

	//#define NVSG_ALPHA	//#define NVSG_ALPHA

	#define NVSG_BETA	//#define NVSG_BETA

	#ifdef LINUX	#ifdef LINUX
	#define NVSG_BETA	#define NVSG_BETA
	#elif defined _WIN64	#elif defined _WIN64
	#define NVSG_BETA	#define NVSG_BETA
	#endif	#endif

	// MaKe STRing helper macro	// MaKe STRing helper macro
	#define MKSTR(s) MKSTR_i(s)	#define MKSTR(s) MKSTR_i(s)
	#define MKSTR_i(s) MKSTR_ii(s)	#define MKSTR_i(s) MKSTR_ii(s)

End of changes. 2 change blocks.
	2 lines changed or deleted	2 lines changed or added

	RTFx.h	RTFx.h

	skipping to change at line 58	skipping to change at line 58
	/*! \brief Assigns contents from a source RTFx object.	/*! \brief Assigns contents from a source RTFx object.
	* \param	* \param
	* rhs Source RTFx object	* rhs Source RTFx object
	* \return	* \return
	* The assignment operator returns a reference to this RTFx object.	* The assignment operator returns a reference to this RTFx object.
	* \remarks	* \remarks
	* The assignment operator releases old contents before re-assigning t he new contents.	* The assignment operator releases old contents before re-assigning t he new contents.
	*/	*/
	NVSG_API RTFxBase& operator=(const RTFxBase& rhs);	NVSG_API RTFxBase& operator=(const RTFxBase& rhs);


	/*! \brief Returns whether this object shares its embedded data with ot
	her RTFx objects.
	* \return
	* The function returns \c true if the object shares its embedded data
	with another RTFx object.
	* Otherwise, the function returns \c false.
	* \remarks
	* This function is useful only if you need to deal with shared data.
	* \n\n
	* A certain RTFx object shares its data with another RTFx object if i
	t was either instantiated
	* as a copy of the other object (RTFxHandle::clone), or if it was ass
	igned to by the other object
	* using the RTFx::operator= assignment operator.
	* \n\n
	* If you need to write code that, for instance, saves a RTFx object t
	o a file, you
	* can use this function if you want your code to handle shared data.
	In this context,
	* RTFx::getDataID would be also very helpful to identify the shared d
	ata.
	*/
	NVSG_API virtual bool isDataShared() const;

	/*! \brief Returns the unique data identifier for this object.
	* \return
	* The function returns a 64-bit value which uniquely identifies the e
	mbedded data.
	* \remarks
	* This function helps to identify shared RTFx objects. Two RTFx objec
	ts that share their data
	* do have the same data ID. Use RTFx::isDataShared to determine wheth
	er a certain RTFx object
	* shares its data with other RTFx objects.
	* \sa RTFxHandle::clone, RTFx::operator=()
	*/
	NVSG_API virtual DataID getDataID() const;

	/*! \brief Overrides Object::isEquivalent.	/*! \brief Overrides Object::isEquivalent.
	* \param	* \param
	* object Pointer to the const Object to test for equivalence with thi s RTFx object.	* object Pointer to the const Object to test for equivalence with thi s RTFx object.
	* \param	* \param
	* ignoreNames Object names will be ignored while testing if this is \ c true.	* ignoreNames Object names will be ignored while testing if this is \ c true.
	* \param	* \param
	* deepCompare The function performs a deep-compare instead of a shall ow compare if this is \c true.	* deepCompare The function performs a deep-compare instead of a shall ow compare if this is \c true.
	* \return	* \return
	* The function returns \c true if the Object pointed to by \a object is detected to be equivalent	* The function returns \c true if the Object pointed to by \a object is detected to be equivalent
	* to this RTFx object.	* to this RTFx object.
	* \remarks	* \remarks
	* The test will consider the optional control parameters ignoreNames and deepCompare.	* The test will consider the optional control parameters ignoreNames and deepCompare.
	* If you omit these two, the function ignores the object names and pe rforms a shallow	* If you omit these two, the function ignores the object names and pe rforms a shallow
	* compare only.	* compare only.
	* \sa Object::isEquivalent	* \sa Object::isEquivalent
	*/	*/
	NVSG_API virtual bool isSameAs(const RTFxBase *object, bool ignoreNames , bool deepCompare) const;	NVSG_API virtual bool isSameAs(const RTFxBase *object, bool ignoreNames , bool deepCompare) const;


	/*! \brief Get a count of textures in this RTFx.	/*! \brief Interface to get the RTFxProgram of this object.
	* \return Integer count of textures declared in this RTFx.	* \return A pointer to the RTFxProgram of this object.
	* \remarks Returns a count of textures that have been defined in this	* \remarks All classes deriving from RTFxBase have to provide this fu
	RTFx.	nction. As ownership handling
	* \sa RTFx::getTexture */	* of an RTFxProgram needs an Object, the RTFxProgram can't be a part
	NVSG_API unsigned int getNumberOfTextures() const;	of the RTFxBase. That is, all
		* concrete classes deriving from RTFxBase should also derive from Obj
	/*! \brief Get a handle to the texture by index.	ect (or a class derived from
	* \return RTFxTexture handle, or NULL if index was invalid.	* Object). */
	* \param index The index of the texture to query.	NVSG_API virtual nvsg::RTFxProgramHandle * getProgram() const = 0;
	* \remarks Returns the texture at the given index.
	* \note The behavior is undefined, if \a index is larger or equal to
	the number of textures in
	* this RTFx.
	* \sa getNumberOfTextures */
	NVSG_API TextureAttributeItemHandle * getTexture( unsigned int index )
	const;

	/*! \brief Get a count of parameters in this RTFx.	/*! \brief Get a count of parameters in this RTFx.
	* \return	* \return
	* Integer parameter count.	* Integer parameter count.
	* \remarks	* \remarks
	* Returns the number of parameters in this RTFx. Parameters may have been defined programmatically or	* Returns the number of parameters in this RTFx. Parameters may have been defined programmatically or
	* in the RTFx file itself.	* in the RTFx file itself.
	*/	*/
	NVSG_API virtual unsigned int getNumberOfParameters() const;	NVSG_API virtual unsigned int getNumberOfParameters() const;


	skipping to change at line 153	skipping to change at line 118
	* \param name The name of the parameter to get the index of.	* \param name The name of the parameter to get the index of.
	* \return The index of the parameter named by \a name in this set of parameters, or ~0, if the	* \return The index of the parameter named by \a name in this set of parameters, or ~0, if the
	* parameter is not part of this set of parameters.	* parameter is not part of this set of parameters.
	* \sa getNumberOfParameters, containsParameter */	* \sa getNumberOfParameters, containsParameter */
	NVSG_API unsigned int getParameterIndex( const std::string & name ) con st;	NVSG_API unsigned int getParameterIndex( const std::string & name ) con st;

	/*! \brief Add a parameter to the RTFxBase.	/*! \brief Add a parameter to the RTFxBase.
	* \param name Name of the parameter to add.	* \param name Name of the parameter to add.
	* \param type Type of the parameter to add.	* \param type Type of the parameter to add.
	* \param count Number of elements of type \a type in the parameter to add	* \param count Number of elements of type \a type in the parameter to add

		* \param size Memory footprint size in bytes (sizeof(structure)*count ) if the type is PT_USER_DATA. Otherwise, ignored.
	* \param semantic The semantic to assign to the variable (see note).	* \param semantic The semantic to assign to the variable (see note).
	* \param annotations The annotations to add to this variable (see not e).	* \param annotations The annotations to add to this variable (see not e).
	* \return The index of the newly added parameter.	* \return The index of the newly added parameter.
	* \remarks An RTFxBase manages the values of parameters used in an as sociated RTFxProgram.	* \remarks An RTFxBase manages the values of parameters used in an as sociated RTFxProgram.
	* \note The behavior is undefined if there is a variable in the assoc iated RTFxProgram with	* \note The behavior is undefined if there is a variable in the assoc iated RTFxProgram with
	* the same name, but of a different type or count.	* the same name, but of a different type or count.
	* \note Semantics and Annotations assigned this way are NOT stored to any NVSG output files. Only the	* \note Semantics and Annotations assigned this way are NOT stored to any NVSG output files. Only the
	* semantics and annotations that appear in the RTFx file itself will be stored to disk.	* semantics and annotations that appear in the RTFx file itself will be stored to disk.
	* \sa getNumberOfParameters, removeParameter, setParameterValue */	* \sa getNumberOfParameters, removeParameter, setParameterValue */
	NVSG_API unsigned int addParameter( const std::string & name, unsigned char type, unsigned int count,	NVSG_API unsigned int addParameter( const std::string & name, unsigned char type, unsigned int count,

		unsigned int size = 0,
	const std::string & semantic = std: :string(),	const std::string & semantic = std: :string(),
	const std::vector< RTFxParameter::A nnotation > & annotations = std::vector< RTFxParameter::Annotation >() );	const std::vector< RTFxParameter::A nnotation > & annotations = std::vector< RTFxParameter::Annotation >() );

	/*! \brief Remove a parameter from the RTFxBase.	/*! \brief Remove a parameter from the RTFxBase.
	* \param index The index of the parameter to remove.	* \param index The index of the parameter to remove.
	* \note The behavior is undefined if \a index is larger or equal to t he number of parameters	* \note The behavior is undefined if \a index is larger or equal to t he number of parameters
	* in this RTFxBase.	* in this RTFxBase.
	* \sa getNumberOfParameters, addParameter, getParameter */	* \sa getNumberOfParameters, addParameter, getParameter */
	NVSG_API void removeParameter( unsigned int index );	NVSG_API void removeParameter( unsigned int index );

	/*! \brief Sets a parameter's value using floats.	/*! \brief Sets a parameter's value using floats.
	* \param index The index of the parameter to set.	* \param index The index of the parameter to set.
	* \param f A pointer to a constant array of floating-point data, that is at least the size of	* \param f A pointer to a constant array of floating-point data, that is at least the size of
	* the parameter specified by \a index.	* the parameter specified by \a index.
	* \remarks Sets a parameter's value using floating point values. Note that no conversions are	* \remarks Sets a parameter's value using floating point values. Note that no conversions are
	* performed.	* performed.
	* \note The behavior is undefined if index is larger than or equal to the number of parameters	* \note The behavior is undefined if index is larger than or equal to the number of parameters
	* in this RTFx, or if the specified parameter is not a floating-point parameter.	* in this RTFx, or if the specified parameter is not a floating-point parameter.
	* \sa getNumberOfParameters, RTFxProgram::getVariableType */	* \sa getNumberOfParameters, RTFxProgram::getVariableType */

	NVSG_API virtual void setParameterValue( unsigned int index, const floa t* f);	NVSG_API void setParameterValue( unsigned int index, const float* f);

	/*! \brief Sets a parameter's value using signed integers.	/*! \brief Sets a parameter's value using signed integers.
	* \param index The index of the parameter to set.	* \param index The index of the parameter to set.
	* \param i A pointer to a constant array of signed integer data, that is at least the size of	* \param i A pointer to a constant array of signed integer data, that is at least the size of
	* the parameter specified by \a index.	* the parameter specified by \a index.
	* \remarks Sets a parameter's value using signed integer values. Note that no conversions are	* \remarks Sets a parameter's value using signed integer values. Note that no conversions are
	* performed.	* performed.
	* \note The behavior is undefined if index is larger than or equal to the number of parameters	* \note The behavior is undefined if index is larger than or equal to the number of parameters
	* in this RTFx, or if the specified parameter is not a signed integer parameter.	* in this RTFx, or if the specified parameter is not a signed integer parameter.
	* \sa getNumberOfParameters, RTFxProgram::getVariableType */	* \sa getNumberOfParameters, RTFxProgram::getVariableType */

	NVSG_API virtual void setParameterValue( unsigned int index, const int * i );	NVSG_API void setParameterValue( unsigned int index, const int * i );

	/*! \brief Sets a parameter's value using unsigned integers.	/*! \brief Sets a parameter's value using unsigned integers.
	* \param index The index of the parameter to set.	* \param index The index of the parameter to set.
	* \param ui A pointer to a constant array of unsigned integer data, t hat is at least the size of	* \param ui A pointer to a constant array of unsigned integer data, t hat is at least the size of
	* the parameter specified by \a index.	* the parameter specified by \a index.
	* \remarks Sets a parameter's value using unsigned integer values. No te that no conversions are	* \remarks Sets a parameter's value using unsigned integer values. No te that no conversions are
	* performed.	* performed.
	* \note The behavior is undefined if index is larger than or equal to the number of parameters	* \note The behavior is undefined if index is larger than or equal to the number of parameters
	* in this RTFx, or if the specified parameter is not an unsigned inte ger parameter.	* in this RTFx, or if the specified parameter is not an unsigned inte ger parameter.
	* \sa getNumberOfParameters, RTFxProgram::getVariableType */	* \sa getNumberOfParameters, RTFxProgram::getVariableType */

	NVSG_API virtual void setParameterValue( unsigned int index, const unsi	NVSG_API void setParameterValue( unsigned int index, const unsigned int
	gned int * ui );	* ui );

		/*! \brief Sets a parameter's value using untyped pointer.
		* \param index The index of the parameter to set.
		* \param v A pointer to untyped memory, that is at least the size of
		the parameter specified by \a index.
		* \note The behavior is undefined if index is larger than or equal to
		the number of parameters
		* in this RTFx.
		* \sa getNumberOfParameters, RTFxProgram::getVariableType */
		NVSG_API void setParameterValue( unsigned int index, const void * v );

	/! \brief set buffer value /	/! \brief set buffer value /

	NVSG_API virtual void setParameterValue( unsigned int index, nvsg::RTBu fferAttributeHandle * buffer );	NVSG_API void setParameterValue( unsigned int index, nvsg::RTBufferAttr ibuteHandle * buffer );

	/! \brief set texture value /	/! \brief set texture value /

	NVSG_API virtual void setParameterValue( unsigned int index, nvsg::Text	NVSG_API void setParameterValue( unsigned int index, nvsg::TextureAttri
	ureAttributeItemHandle * tex );	buteItemHandle * tex );

	protected:
	friend class nvtraverser::RTTraverser;

	protected:	protected:

	virtual void resetToDefaults();	NVSG_API virtual void onParameterValueChanged() = 0;
		NVSG_API virtual void resetToDefaults();
	NVSG_API virtual void setProgram( nvsg::RTFxProgramHandle * program ) = 0;	NVSG_API virtual void setProgram( nvsg::RTFxProgramHandle * program ) = 0;

	NVSG_API virtual nvsg::RTFxProgramHandle * getProgram() const = 0;
	NVSG_API void initFromProgram( RTFxProgramHandle * prgHdl );	NVSG_API void initFromProgram( RTFxProgramHandle * prgHdl );

	private:	private:
	nvsg::TextureAttributeItemHandle * loadTexture( const std::string & fil eName, const std::vector<std::string> & searchPaths );	nvsg::TextureAttributeItemHandle * loadTexture( const std::string & fil eName, const std::vector<std::string> & searchPaths );

	private:	private:

	std::vector<RTFxParameter> m_parameters;	std::vector<RTFxParameter> m_parameters;
	std::vector<TextureAttributeItemHandle *> m_textures;
	};	};

	class RTFx : public StateAttribute, public RTFxBase	class RTFx : public StateAttribute, public RTFxBase
	{	{
	public:	public:
	NVSG_API RTFx();	NVSG_API RTFx();
	NVSG_API RTFx(const RTFx & rhs);	NVSG_API RTFx(const RTFx & rhs);
	NVSG_API RTFx(const StateAttribute & rhs);	NVSG_API RTFx(const StateAttribute & rhs);
	NVSG_API virtual ~RTFx();	NVSG_API virtual ~RTFx();
	NVSG_API RTFx& operator=(const RTFx& rhs);	NVSG_API RTFx& operator=(const RTFx& rhs);
	NVSG_API virtual bool isEquivalent(const Object *object, bool ignoreN ames, bool deepCompare) const;	NVSG_API virtual bool isEquivalent(const Object *object, bool ignoreN ames, bool deepCompare) const;
	NVSG_API virtual bool isDataShared() const;	NVSG_API virtual bool isDataShared() const;
	NVSG_API virtual DataID getDataID() const;	NVSG_API virtual DataID getDataID() const;

	NVSG_API virtual void resetToDefaults();	NVSG_API virtual void resetToDefaults();
	NVSG_API virtual void setProgram( nvsg::RTFxProgramHandle * program ) ;	NVSG_API virtual void setProgram( nvsg::RTFxProgramHandle * program ) ;
	NVSG_API virtual nvsg::RTFxProgramHandle * getProgram() const;	NVSG_API virtual nvsg::RTFxProgramHandle * getProgram() const;

	NVSG_API virtual void setParameterValue( unsigned int index, const fl	NVSG_API virtual void onParameterValueChanged();
	oat * f );
	NVSG_API virtual void setParameterValue( unsigned int index, const in
	t * i );
	NVSG_API virtual void setParameterValue( unsigned int index, const un
	signed int * i );
	NVSG_API virtual void setParameterValue( unsigned int index, nvsg::RT
	BufferAttributeHandle * buffer );
	NVSG_API virtual void setParameterValue( unsigned int index, nvsg::Te
	xtureAttributeItemHandle * tex );

	private:	private:

		// Can't have m_program in RTFxBase due to ownership handling, that n eeds to be done in from inside an Object
	nvsg::RTFxProgramHandle * m_program;	nvsg::RTFxProgramHandle * m_program;
	};	};

	class RTFxSceneAttribute : public SceneAttribute, public RTFxBase	class RTFxSceneAttribute : public SceneAttribute, public RTFxBase
	{	{
	public:	public:
	NVSG_API RTFxSceneAttribute();	NVSG_API RTFxSceneAttribute();
	NVSG_API RTFxSceneAttribute(const RTFxSceneAttribute & rhs);	NVSG_API RTFxSceneAttribute(const RTFxSceneAttribute & rhs);
	NVSG_API RTFxSceneAttribute(const SceneAttribute & rhs);	NVSG_API RTFxSceneAttribute(const SceneAttribute & rhs);
	NVSG_API virtual ~RTFxSceneAttribute();	NVSG_API virtual ~RTFxSceneAttribute();
	NVSG_API RTFxSceneAttribute& operator=(const RTFxSceneAttribute& rhs) ;	NVSG_API RTFxSceneAttribute& operator=(const RTFxSceneAttribute& rhs) ;
	NVSG_API virtual bool isEquivalent(const Object *object, bool ignoreN ames, bool deepCompare) const;	NVSG_API virtual bool isEquivalent(const Object *object, bool ignoreN ames, bool deepCompare) const;
	NVSG_API virtual bool isDataShared() const;	NVSG_API virtual bool isDataShared() const;
	NVSG_API virtual DataID getDataID() const;	NVSG_API virtual DataID getDataID() const;

	NVSG_API virtual void resetToDefaults();	NVSG_API virtual void resetToDefaults();
	NVSG_API virtual void setProgram( nvsg::RTFxProgramHandle * program ) ;	NVSG_API virtual void setProgram( nvsg::RTFxProgramHandle * program ) ;
	NVSG_API virtual nvsg::RTFxProgramHandle * getProgram() const;	NVSG_API virtual nvsg::RTFxProgramHandle * getProgram() const;

	NVSG_API virtual void setParameterValue( unsigned int index, const fl	NVSG_API virtual void onParameterValueChanged();
	oat * f );
	NVSG_API virtual void setParameterValue( unsigned int index, const in
	t * i );
	NVSG_API virtual void setParameterValue( unsigned int index, const un
	signed int * i );
	NVSG_API virtual void setParameterValue( unsigned int index, nvsg::RT
	BufferAttributeHandle * buffer );
	NVSG_API virtual void setParameterValue( unsigned int index, nvsg::Te
	xtureAttributeItemHandle * tex );

	private:	private:

		// Can't have m_program in RTFxBase due to ownership handling, that n eeds to be done in from inside an Object
	nvsg::RTFxProgramHandle * m_program;	nvsg::RTFxProgramHandle * m_program;
	};	};
	} // namespace nvsg	} // namespace nvsg

End of changes. 16 change blocks.
	90 lines changed or deleted	36 lines changed or added

	RTFxProgram.h	RTFxProgram.h

	skipping to change at line 38	skipping to change at line 38
	friend class RTFxProgram;	friend class RTFxProgram;
	friend class RTFxBase;	friend class RTFxBase;

	public:	public:
	// enum value for parameter types besides the standard scalar values	// enum value for parameter types besides the standard scalar values
	// note - must be named, or can't be used in checked_cast<>	// note - must be named, or can't be used in checked_cast<>
	enum AdditionalTypes	enum AdditionalTypes
	{	{
	PT_BUFFER = 0x80,	PT_BUFFER = 0x80,
	PT_OBJECT,	PT_OBJECT,

	PT_TEXTURE_SAMPLER	PT_TEXTURE_SAMPLER,
		PT_USER_DATA
	};	};

	struct Annotation	struct Annotation
	{	{
	std::string type;	std::string type;
	std::string name;	std::string name;
	std::string value;	std::string value;
	NVSG_API bool operator==( const Annotation & rhs ) const;	NVSG_API bool operator==( const Annotation & rhs ) const;
	};	};

	public:	public:
	NVSG_API RTFxParameter();	NVSG_API RTFxParameter();

	NVSG_API RTFxParameter( const std::string & name, unsigned char type,	/*! \brief Constructs a new parameter.
	unsigned char count );	* \param name The parameter's name.
		* \param type The parameter's type. For a 'float3' type this would
		be NVSG_FLOAT.
		* \param count The number of elements in the parameter or array. F
		or float3 this would be 3.
		* \param size The parameter's size in bytes. For a PT_USER_DATA pa
		rameter, this would be
		* sizeof( structure ) * count. For other parameter types, it is ig
		nored since the size can be
		* determined from the data type and count.
		*/
		NVSG_API RTFxParameter( const std::string & name, unsigned char type,
		unsigned char count, unsigned int size );
	NVSG_API RTFxParameter( const RTFxParameter & rhs );	NVSG_API RTFxParameter( const RTFxParameter & rhs );
	NVSG_API ~RTFxParameter();	NVSG_API ~RTFxParameter();


		NVSG_API RTFxParameter & operator=( const RTFxParameter & rhs );
	NVSG_API bool operator==( const RTFxParameter & rhs ) const;	NVSG_API bool operator==( const RTFxParameter & rhs ) const;

	NVSG_API const std::string & getName() const;	NVSG_API const std::string & getName() const;

		/! \brief Returns the data type /
	NVSG_API unsigned char getType() const;	NVSG_API unsigned char getType() const;

	NVSG_API unsigned char getCount() const;	/*! \brief Returns the number of elements in the array.
		* \note Since the RTFx parser only has access to the PTX declaring
		the parameter's total size in bytes, is not
		* possible to independently determine the count and size of the dat
		a structure for PT_USER_DATA types.
		* Therefore, all PT_USER_DATA typed parameters will have a count of
		1. */
		NVSG_API unsigned char getCount() const;
		/*! \brief Returns the total size of the data structure (sizeof(type)
		*count).
		* \note Since the RTFx parser only has access to the PTX declaring
		the parameter's total size in bytes, is not
		* possible to independently determine the count and size of the dat
		a structure for PT_USER_DATA types.
		* Therefore, all PT_USER_DATA typed parameters will have a size equ
		al to the entire data structure array. */
		NVSG_API unsigned int getSize() const;

		/! \brief Gets a parameter's value using a void .
		* \param v A pointer to untyped memory, that is at least the size o
		f the parameter.
		* \remarks Gets a parameter's value.
		* \note This method is typically used for parameters of type PT_USE
		R_DATA.
		* \sa getType, getSize, getName, setValue */
		NVSG_API void getValue( void * v ) const;

		/! \brief Sets a parameter's value using a void .
		* parameter.
		* \param v A pointer to untyped memory, that is at least the size o
		f the parameter.
		* \remarks Sets a parameter's value.
		* \note This method is typically used for parameters of type PT_USE
		R_DATA.
		* \sa getType, getSize, getName, getValue */
		NVSG_API void setValue( const void * v );

	/*! \brief Gets a parameter's value using floats.	/*! \brief Gets a parameter's value using floats.
	* \param f A pointer to an array of floating-point data, that is at least the size of the	* \param f A pointer to an array of floating-point data, that is at least the size of the
	* parameter.	* parameter.
	* \remarks Gets a floating-point parameter's value. Note that no co nversions are performed.	* \remarks Gets a floating-point parameter's value. Note that no co nversions are performed.
	* \note The behavior is undefined the specified parameter is not a floating-point parameter.	* \note The behavior is undefined the specified parameter is not a floating-point parameter.
	* \sa getType, getName, setValue */	* \sa getType, getName, setValue */
	NVSG_API void getValue( float * f ) const;	NVSG_API void getValue( float * f ) const;

	/*! \brief Sets a parameter's value using floats.	/*! \brief Sets a parameter's value using floats.

	skipping to change at line 178	skipping to change at line 213
	NVSG_API const std::vector<Annotation> & getAnnotations() const;	NVSG_API const std::vector<Annotation> & getAnnotations() const;

	/*! \brief Get variable's semantic.	/*! \brief Get variable's semantic.
	* \param result The returned semantic.	* \param result The returned semantic.
	* \return bool True if the variable has a semantic, false otherwise .	* \return bool True if the variable has a semantic, false otherwise .
	* \note semantics are currently immutable	* \note semantics are currently immutable
	* \sa getAnnotation */	* \sa getAnnotation */
	NVSG_API bool getSemantic( std::string & result ) const;	NVSG_API bool getSemantic( std::string & result ) const;
	NVSG_API const std::string & getSemantic() const;	NVSG_API const std::string & getSemantic() const;


		/*! \brief Get variable's type and count from a string description.
		* \note Unrecognized type names will return type=PT_USER_DATA assum
		ing the type was a data structure.
		* In addition, for parameters determined to be of type PT_USER_DATA
		, count will always be 1.
		* */
		NVSG_API static bool stringToParameterDescription( const std::string
		& str, unsigned char & type, unsigned char & count );

		/*! \brief Returns the named type of this parameter
		* \remarks If the parameter is a type PT_USER_DATA, and this parame
		ter was parsed from an RTFx file,
		* then this will be the data type parsed from the RTFx (ie: the str
		uct identifier).
		*/
		NVSG_API const std::string & getParameterTypeName();

	private:	private:
	NVSG_API void addAnnotation( const Annotation & anno );	NVSG_API void addAnnotation( const Annotation & anno );

	// Note: the type is specified by the variable of the same name in th e associated RTFxProgram !!	// Note: the type is specified by the variable of the same name in th e associated RTFxProgram !!
	std::string m_name; // name of paramete r	std::string m_name; // name of paramete r
	unsigned char m_type; // type of the para meter in m_data	unsigned char m_type; // type of the para meter in m_data
	unsigned char m_count; // number of elemen ts in m_data	unsigned char m_count; // number of elemen ts in m_data
	std::vector<unsigned char> m_data; // the data buffer for a single parameter	std::vector<unsigned char> m_data; // the data buffer for a single parameter
	nvsg::RTBufferAttributeHandle * m_buffer; // buffer parameter	nvsg::RTBufferAttributeHandle * m_buffer; // buffer parameter
	nvsg::TextureAttributeItemHandle * m_texture; // texture paramete r	nvsg::TextureAttributeItemHandle * m_texture; // texture paramete r
	std::vector<Annotation> m_annotations; // variable's annot ations	std::vector<Annotation> m_annotations; // variable's annot ations

	std::string m_semantic; // variable's annotati	std::string m_semantic; // variable's annot
	ons	ations
		std::string m_typeName; // variable's type
		string
	};	};

	inline const std::vector< RTFxParameter::Annotation > & RTFxParameter::ge tAnnotations() const	inline const std::vector< RTFxParameter::Annotation > & RTFxParameter::ge tAnnotations() const
	{	{
	return m_annotations;	return m_annotations;
	}	}

	inline unsigned int RTFxParameter::getNumberOfAnnotations() const	inline unsigned int RTFxParameter::getNumberOfAnnotations() const
	{	{
	return checked_cast< unsigned int >( m_annotations.size() );	return checked_cast< unsigned int >( m_annotations.size() );

	skipping to change at line 508	skipping to change at line 556
	* \return If this RTFxProgram was created from a source string, tha t string is returned.	* \return If this RTFxProgram was created from a source string, tha t string is returned.
	* Otherwise an empty string is returned.	* Otherwise an empty string is returned.
	* \sa RTFx::isFromLump, RTFx::createFromLump */	* \sa RTFx::isFromLump, RTFx::createFromLump */
	NVSG_API const std::string & getSourceCode() const;	NVSG_API const std::string & getSourceCode() const;

	/*! \brief Create an RTFxProgram from a file, caching the resulting R TFxProgram	/*! \brief Create an RTFxProgram from a file, caching the resulting R TFxProgram
	* \param file The filename containing the RTFx code.	* \param file The filename containing the RTFx code.
	* \param searchPaths A vector containing search paths to use for sh ader and include paths.	* \param searchPaths A vector containing search paths to use for sh ader and include paths.
	* \param errorReturn If the method returns NULL, then errorReturn w ill contain an error	* \param errorReturn If the method returns NULL, then errorReturn w ill contain an error
	* message indicating what the possible errors were.	* message indicating what the possible errors were.

		* \param compargs A vector containing arguments to the NVCC compile
		r used to compile CUDA to PTX. An example
		* would be "-Iinclude" or "-DMYAPP", etc. These arguments are igno
		red if the source is already in compiled PTX
		* format.
	* \remarks Loads RTFx code from a file, parses it, and prepares it for the RTTraverser which	* \remarks Loads RTFx code from a file, parses it, and prepares it for the RTTraverser which
	* will compile it at runtime.\n	* will compile it at runtime.\n
	* The search paths will be used for all shader and include paths.\n	* The search paths will be used for all shader and include paths.\n
	* If an RTFxProgram of the same file name is found in the cache, a pointer to it will be returned instead.	* If an RTFxProgram of the same file name is found in the cache, a pointer to it will be returned instead.
	* \returns RTFxProgramHandle possibly cached.	* \returns RTFxProgramHandle possibly cached.
	* \sa CgFxEffect::createFromFile */	* \sa CgFxEffect::createFromFile */
	static NVSG_API RTFxProgramHandle * createFromFile( const std::string & file,	static NVSG_API RTFxProgramHandle * createFromFile( const std::string & file,

	std::vector< std:	const std::vector
	:string > & searchPaths,	< std::string > & searchPaths,
		const std::vector
		< std::string > & compargs,
	std::string & err orReturn );	std::string & err orReturn );

	/*! \brief Create an RTFxProgram from a string, caching the resulting RTFxProgram	/*! \brief Create an RTFxProgram from a string, caching the resulting RTFxProgram
	* \param string A string containing RTFx code.	* \param string A string containing RTFx code.
	* \param searchPaths A vector containing search paths to use for sh ader and include paths.	* \param searchPaths A vector containing search paths to use for sh ader and include paths.
	* \param errorReturn If the method returns NULL, then errorReturn w ill contain an error	* \param errorReturn If the method returns NULL, then errorReturn w ill contain an error
	* message indicating what the possible errors were.	* message indicating what the possible errors were.
	* \param filetype Defaults to RTFxProgram::FT_RTFX indicating that this is an RTFx formatted	* \param filetype Defaults to RTFxProgram::FT_RTFX indicating that this is an RTFx formatted
	* file. In the future, RTFxProgram::FT_METASL support may be added using this same entry	* file. In the future, RTFxProgram::FT_METASL support may be added using this same entry
	* point.	* point.

		* \param compargs A vector containing arguments to the NVCC compile
		r used to compile CUDA to PTX. An example
		* would be "-Iinclude" or "-DMYAPP", etc. These arguments are igno
		red if the source is already in compiled PTX
		* format.
	* \remarks Loads RTFx code from the given string, parses it, and pr epares it for the	* \remarks Loads RTFx code from the given string, parses it, and pr epares it for the
	* RTTraverser which will compile it at runtime.\n	* RTTraverser which will compile it at runtime.\n
	* The search paths will be used for all shader and include paths.	* The search paths will be used for all shader and include paths.
	* \returns boolean indicating success or failure.	* \returns boolean indicating success or failure.
	* \sa CgFxEffect::createFromLump */	* \sa CgFxEffect::createFromLump */
	static NVSG_API RTFxProgramHandle * createFromLump( const std::string & lump,	static NVSG_API RTFxProgramHandle * createFromLump( const std::string & lump,

	std::vector< std:	const std::vector
	:string > & searchPaths,	< std::string > & searchPaths,
		const std::vector
		< std::string > & compargs,
	std::string & err orReturn,	std::string & err orReturn,
	FileType filetype = FT_RTFX );	FileType filetype = FT_RTFX );

	private:	private:
	NVSG_API void constructProgram( RTFxParser * parser );	NVSG_API void constructProgram( RTFxParser * parser );

	NVSG_API bool createFromFile( const std::string & file, std::string &	NVSG_API bool createFromFile( const std::string & file, const std::ve
	errorReturn );	ctor<std::string> & args, std::string & errorReturn );
	NVSG_API bool createFromLump( const std::string & lump, std::string &	NVSG_API bool createFromLump( const std::string & lump, const std::ve
	errorReturn, FileType filetype = FT_RTFX );	ctor<std::string> & args, std::string & errorReturn, FileType filetype = FT
		_RTFX );
	NVSG_API void setSearchPaths( const std::vector<std::string> & paths );	NVSG_API void setSearchPaths( const std::vector<std::string> & paths );
	NVSG_API void decomposeAnnotations( RTFxParameter & param, const std: :string & annos );	NVSG_API void decomposeAnnotations( RTFxParameter & param, const std: :string & annos );

	private:	private:
	struct TextureEntry	struct TextureEntry
	{	{
	std::string file; // file containing texture	std::string file; // file containing texture
	TextureFormat format; // format of the buffer for t exture conversion; currently ignored !	TextureFormat format; // format of the buffer for t exture conversion; currently ignored !
	std::string samplerName; // name of sampler in code to assign bits to	std::string samplerName; // name of sampler in code to assign bits to
	FilterModes filterModes;	FilterModes filterModes;

End of changes. 12 change blocks.
	14 lines changed or deleted	98 lines changed or added

	RTTraverser.h	RTTraverser.h

	skipping to change at line 112	skipping to change at line 112
	float opacity;	float opacity;
	};	};

	public:	public:
	//! Default constructor	//! Default constructor
	RTTraverser( nvui::RTRenderArea * ra );	RTTraverser( nvui::RTRenderArea * ra );

	virtual void setScene( nvsg::SceneHandle * scene );	virtual void setScene( nvsg::SceneHandle * scene );
	void setSceneFileName( std::string & fileName );	void setSceneFileName( std::string & fileName );


	NVRT_API void setAccelerationTypeGeometry( nvrt::RTAcceleration::RTBui
	lderType builder, nvrt::RTAcceleration::RTTraverserType traverser );
	NVRT_API void setAccelerationTypeHierarchy( nvrt::RTAcceleration::RTBu
	ilderType builder, nvrt::RTAcceleration::RTTraverserType traverser );
	NVRT_API void setAccelerationCache( nvrt::RTAccelerationCacheHandle * ach );	NVRT_API void setAccelerationCache( nvrt::RTAccelerationCacheHandle * ach );
	NVRT_API nvrt::RTAccelerationCacheHandle * getAccelerationCache() cons t;	NVRT_API nvrt::RTAccelerationCacheHandle * getAccelerationCache() cons t;

	NVRT_API void setSceneEpsilonFactor( float factor );	NVRT_API void setSceneEpsilonFactor( float factor );
	NVRT_API float getSceneEpsilonFactor() const;	NVRT_API float getSceneEpsilonFactor() const;
	NVRT_API void setMaxReflectionDepth( unsigned int depth );	NVRT_API void setMaxReflectionDepth( unsigned int depth );
	NVRT_API unsigned int getMaxReflectionDepth() const;	NVRT_API unsigned int getMaxReflectionDepth() const;
	NVRT_API void setMaxRefractionDepth( unsigned int depth );	NVRT_API void setMaxRefractionDepth( unsigned int depth );
	NVRT_API unsigned int getMaxRefractionDepth() const;	NVRT_API unsigned int getMaxRefractionDepth() const;
	NVRT_API void setMaxShadowDepth( unsigned int depth );	NVRT_API void setMaxShadowDepth( unsigned int depth );

	skipping to change at line 183	skipping to change at line 181
	private:	private:
	typedef std::map< size_t, size_t > AttributeMap;	typedef std::map< size_t, size_t > AttributeMap;

	private:	private:
	nvsg::TextureAttributeItemHandle * getTextureOnTextureUnit( unsigned in t which );	nvsg::TextureAttributeItemHandle * getTextureOnTextureUnit( unsigned in t which );
	void setVariable( nvrt::RTVariable *, const nvsg:: RTFxParameter & param );	void setVariable( nvrt::RTVariable *, const nvsg:: RTFxParameter & param );
	unsigned int getAttributeMask( const AttributeMap & attrib utes );	unsigned int getAttributeMask( const AttributeMap & attrib utes );
	void createDefaultTexture( void );	void createDefaultTexture( void );
	void addLightSources( void );	void addLightSources( void );
	void addSamplePoints( void );	void addSamplePoints( void );

	nvrt::RTGroupHandle * createGroup();	nvrt::RTGroupHandle * createGroup( const nvsg::Group * p );
	nvrt::RTBufferHandle * createIndexBuffer( const nvsg::QuadMeshes * p );	nvrt::RTBufferHandle * createIndexBuffer( const nvsg::QuadMeshes * p );
	nvrt::RTBufferHandle * createIndexBuffer( const nvsg::Quads * p );	nvrt::RTBufferHandle * createIndexBuffer( const nvsg::Quads * p );
	nvrt::RTBufferHandle * createIndexBuffer( const nvsg::QuadStrips * p );	nvrt::RTBufferHandle * createIndexBuffer( const nvsg::QuadStrips * p );
	nvrt::RTBufferHandle * createIndexBuffer( const nvsg::Triangles * p );	nvrt::RTBufferHandle * createIndexBuffer( const nvsg::Triangles * p );
	nvrt::RTBufferHandle * createIndexBuffer( const nvsg::TriFans * p );	nvrt::RTBufferHandle * createIndexBuffer( const nvsg::TriFans * p );
	nvrt::RTBufferHandle * createIndexBuffer( const nvsg::TriStrips * p );	nvrt::RTBufferHandle * createIndexBuffer( const nvsg::TriStrips * p );
	void createIntersectionPrograms( const AttributeMa p & attributes, nvrt::RTGeometry * geom );	void createIntersectionPrograms( const AttributeMa p & attributes, nvrt::RTGeometry * geom );
	nvrt::RTMaterialHandle * createRTMaterial( nvrt::RTMaterialHandle * sr c = 0 );	nvrt::RTMaterialHandle * createRTMaterial( nvrt::RTMaterialHandle * sr c = 0 );
	void createHitandAnyHitPrograms( nvsg::RTFxHandle * rtfxHandle, nvrt::RTMaterialHandle * matHandle );	void createHitandAnyHitPrograms( nvsg::RTFxHandle * rtfxHandle, nvrt::RTMaterialHandle * matHandle );

		void determineAccelerationTypes( const nvsg::GeoNo
		de * p
		, nvrt::RTAccelerat
		ion::RTBuilderType & rtbt
		, nvrt::RTAccelerat
		ion::RTTraverserType & rttt );
		void determineAccelerationTypes( const nvsg::Group
		* p
		, nvrt::RTAccelerat
		ion::RTBuilderType & rtbt
		, nvrt::RTAccelerat
		ion::RTTraverserType & rttt );
	void getShaderMaterial( const nvsg::Material * p, ShaderMaterial & sm );	void getShaderMaterial( const nvsg::Material * p, ShaderMaterial & sm );
	void setMaterialComponents( const nvsg::Material * p, nvrt::RTMaterialHandle * rtm );	void setMaterialComponents( const nvsg::Material * p, nvrt::RTMaterialHandle * rtm );

	void initAccelerationGeometry( nvrt::RTAcceleratio	void initAccelerationGeometry( nvrt::RTAcceleratio
	nHandle * accelerationHdl );	nHandle * accelerationHdl
	void initAccelerationHierarchy( nvrt::RTAccelerati	, nvrt::RTAcceleratio
	onHandle * accelerationHdl );	n::RTBuilderType rtbt
		, nvrt::RTAcceleratio
		n::RTTraverserType rttt );
		void initAccelerationHierarchy( nvrt::RTAccelerati
		onHandle * accelerationHdl
		, nvrt::RTAccelerati
		on::RTBuilderType rtbt
		, nvrt::RTAccelerati
		on::RTTraverserType rttt );
	nvrt::RTGroupCache * processGroup( const nvsg::Group * p );	nvrt::RTGroupCache * processGroup( const nvsg::Group * p );
	template<typename T>	template<typename T>
	void processPrimitiveSet( T * p );	void processPrimitiveSet( T * p );
	void processTextures( const nvsg::RTFxBase * rtfx, nvrt::RTVariablesManager * vholder );	void processTextures( const nvsg::RTFxBase * rtfx, nvrt::RTVariablesManager * vholder );
	void processBuffers( const nvsg::RTFxBase * rtfx, nvrt::RTVariablesManager * vholder );	void processBuffers( const nvsg::RTFxBase * rtfx, nvrt::RTVariablesManager * vholder );
	void pushLightType( nvsg::LightSourceHandle * lsh, const nvmath::Mat44f&, const nvmath::Mat44f& );	void pushLightType( nvsg::LightSourceHandle * lsh, const nvmath::Mat44f&, const nvmath::Mat44f& );
	void setGlobalVariables( const nvsg::RTFxBase * p, nvrt::RTContextHandle * ch );	void setGlobalVariables( const nvsg::RTFxBase * p, nvrt::RTContextHandle * ch );
	void setLocalVariables( const nvsg::RTFxBase * p, nvrt::RTMaterialHandle * mh );	void setLocalVariables( const nvsg::RTFxBase * p, nvrt::RTMaterialHandle * mh );
	void setLocalVariables( const nvsg::RTFxBase * p, nvrt::RTGeometryHandle * gh );	void setLocalVariables( const nvsg::RTFxBase * p, nvrt::RTGeometryHandle * gh );
	void setLocalVariables( const nvsg::RTFxBase * p, std::vector<nvrt::RTProgramHandle *> & phv );	void setLocalVariables( const nvsg::RTFxBase * p, std::vector<nvrt::RTProgramHandle *> & phv );

	skipping to change at line 266	skipping to change at line 274
	nvrt::RTTextureSamplerCache getTextureSamplerCache(const nvsg::DALHost host) const;	nvrt::RTTextureSamplerCache getTextureSamplerCache(const nvsg::DALHost host) const;
	nvrt::RTTextureSamplerCache getOrGenTextureSamplerCache(nvsg::TextureA ttributeItemHandle taih);	nvrt::RTTextureSamplerCache getOrGenTextureSamplerCache(nvsg::TextureA ttributeItemHandle taih);
	void updateTextureSampler( nvrt::RTTextureSamplerCache c, nvsg::Textur eAttributeItemHandle p );	void updateTextureSampler( nvrt::RTTextureSamplerCache c, nvsg::Textur eAttributeItemHandle p );

	nvrt::RTVASBufferCache genVASBufferCache(nvsg::DALHost host, nvsg::Ob ject *p);	nvrt::RTVASBufferCache genVASBufferCache(nvsg::DALHost host, nvsg::Ob ject *p);
	nvrt::RTVASBufferCache getVASBufferCache(const nvsg::DALHost host) co nst;	nvrt::RTVASBufferCache getVASBufferCache(const nvsg::DALHost host) co nst;

	nvrt::RTFxSceneAttributeCache genRTFxSceneAttributeCache(nvsg::DALHost host, nvsg::Object *p);	nvrt::RTFxSceneAttributeCache genRTFxSceneAttributeCache(nvsg::DALHost host, nvsg::Object *p);
	nvrt::RTFxSceneAttributeCache getRTFxSceneAttributeCache(const nvsg::D ALHost host) const;	nvrt::RTFxSceneAttributeCache getRTFxSceneAttributeCache(const nvsg::D ALHost host) const;


	nvrt::RTGroupCache genGroupCache(nvsg::DALHost host, const nvsg::Obje ct *p);	nvrt::RTGroupCache genGroupCache(nvsg::DALHost host, const nvsg::Grou p *p);
	nvrt::RTGroupCache getGroupCache(const nvsg::DALHost host) const;	nvrt::RTGroupCache getGroupCache(const nvsg::DALHost host) const;

	nvrt::RTGeometryCache genGeometryCache(nvsg::DALHost host, nvsg::Obje ct *p);	nvrt::RTGeometryCache genGeometryCache(nvsg::DALHost host, nvsg::Obje ct *p);
	nvrt::RTGeometryCache getGeometryCache(const nvsg::DALHost host) cons t;	nvrt::RTGeometryCache getGeometryCache(const nvsg::DALHost host) cons t;

	private:	private:
	// set this here for now	// set this here for now
	enum { NVRT_MAX_TEXTURE_UNITS = 8 };	enum { NVRT_MAX_TEXTURE_UNITS = 8 };

	nvsg::RTFxSceneAttributeHandle * m_defaultRTFxSceneAttribute;	nvsg::RTFxSceneAttributeHandle * m_defaultRTFxSceneAttribute;

	nvrt::RTAcceleration::RTBuilderType m_accelerationBuilderTypeGeometry
	;
	nvrt::RTAcceleration::RTTraverserType m_accelerationTraverserTypeGeomet
	ry;
	nvrt::RTAcceleration::RTBuilderType m_accelerationBuilderTypeHierarch
	y;
	nvrt::RTAcceleration::RTTraverserType m_accelerationTraverserTypeHierar
	chy;
	nvrt::RTAccelerationCacheHandle * m_rtCache;	nvrt::RTAccelerationCacheHandle * m_rtCache;
	nvrt::RTDALDataCreator * m_DALDataCreator;	nvrt::RTDALDataCreator * m_DALDataCreator;
	AttributeMap m_currentAttributes;	AttributeMap m_currentAttributes;
	std::vector<nvrt::RTNodeHandle*> m_currentChildren; //! a list of all children for the current object	std::vector<nvrt::RTNodeHandle*> m_currentChildren; //! a list of all children for the current object
	std::vector<nvrt::RTNodeHandle*> m_topLevelChildren; //! a list of all children for the toplevel object	std::vector<nvrt::RTNodeHandle*> m_topLevelChildren; //! a list of all children for the toplevel object
	bool m_parentTransformChanged; //! tr ue if the transform for any parent children has been changed	bool m_parentTransformChanged; //! tr ue if the transform for any parent children has been changed
	std::vector<std::pair<nvrt::RTMaterialHandle,nvrt::RTGeometryHandle> > m_currentGeometries;	std::vector<std::pair<nvrt::RTMaterialHandle,nvrt::RTGeometryHandle> > m_currentGeometries;
	nvrt::RTGroupHandle * m_currentGroup;	nvrt::RTGroupHandle * m_currentGroup;
	unsigned int m_currentGroupID;	unsigned int m_currentGroupID;
	nvmath::Mat44f m_currentTransformation;	nvmath::Mat44f m_currentTransformation;

End of changes. 6 change blocks.
	18 lines changed or deleted	26 lines changed or added

	RTVariable.h	RTVariable.h

	skipping to change at line 952	skipping to change at line 952
	NVRT_API void setSize( unsigned int size );	NVRT_API void setSize( unsigned int size );

	protected:	protected:
	/! \brief Default-constructor of RTVariableUser /	/! \brief Default-constructor of RTVariableUser /
	NVRT_API RTVariableUser( RTvariable var );	NVRT_API RTVariableUser( RTvariable var );

	/! \brief Destructor of RTVariableUser /	/! \brief Destructor of RTVariableUser /
	NVRT_API virtual ~RTVariableUser();	NVRT_API virtual ~RTVariableUser();

	private:	private:

	#if !defined(NDEBUG)
	bool m_set;	bool m_set;

	#endif
	unsigned int m_size;	unsigned int m_size;
	void * m_value;	void * m_value;
	};	};

	}	}

End of changes. 2 change blocks.
	2 lines changed or deleted	0 lines changed or added

	RenderArea.h	RenderArea.h

	skipping to change at line 20	skipping to change at line 20
	// INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS BEEN ADVISED OF THE	// INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS BEEN ADVISED OF THE
	// POSSIBILITY OF SUCH DAMAGES	// POSSIBILITY OF SUCH DAMAGES

	/*!	/*!
	* \file	* \file
	* \brief	* \brief
	*/	*/

	#pragma once	#pragma once


	#ifndef NVS_RENDERAREA_H	#ifndef CPX_RENDERAREA_H
	#define NVS_RENDERAREA_H	#define CPX_RENDERAREA_H


	#include "nvscale.h"	#include "complex.h"


	namespace nvs	namespace cpx
	{	{
	class GPUInfo;	class GPUInfo;

	/*!	/*!
	* \brief Create an affinity GLcontext and FBO for offscreen rendering	* \brief Create an affinity GLcontext and FBO for offscreen rendering

	* \par Namespace: nvs	* \par Namespace: cpx
	* \remarks	* \remarks
	* A scene graph implementation can use this utility class to easily cr eate a	* A scene graph implementation can use this utility class to easily cr eate a
	* GLcontext tied to a specific GPU. An FBO with color and depth buffer s is	* GLcontext tied to a specific GPU. An FBO with color and depth buffer s is
	* bound to the created context to facilitate offscreen rendering. Othe r pieces	* bound to the created context to facilitate offscreen rendering. Othe r pieces
	* of the MultiGPU SDK can then be used to perform distributed renderin g and	* of the MultiGPU SDK can then be used to perform distributed renderin g and
	* final image composition.	* final image composition.
	*/	*/
	class RenderArea	class RenderArea
	{	{
	private:	private:

	skipping to change at line 56	skipping to change at line 56
	friend class FactoryImpl;	friend class FactoryImpl;
	RenderArea() {}	RenderArea() {}
	virtual ~RenderArea(void) {}	virtual ~RenderArea(void) {}

	public:	public:
	/*!	/*!
	* \brief Create the affinity GLcontext and image buffer	* \brief Create the affinity GLcontext and image buffer
	* \param gpu	* \param gpu
	* GPUInfo which specifies which GPU to create the affinity GLconte xt on.	* GPUInfo which specifies which GPU to create the affinity GLconte xt on.
	* \param format	* \param format

	* Specifies features of the underlying frame buffer. See nvscale.h	* Specifies features of the underlying frame buffer. See complex.h
	* for a list of possible values. Note that not all formats are eq ually	* for a list of possible values. Note that not all formats are eq ually
	* efficient to transfer for compositing. When in doubt, use the d efault.	* efficient to transfer for compositing. When in doubt, use the d efault.
	* \param colorSamples	* \param colorSamples
	* Minimum number of desired color samples as specified in the	* Minimum number of desired color samples as specified in the
	* GL_NV_framebuffer_multisample_coverage extension (see extension documentation).	* GL_NV_framebuffer_multisample_coverage extension (see extension documentation).
	* \param coverageSamples	* \param coverageSamples
	* Minimum number of desired coverage samples as specified in the	* Minimum number of desired coverage samples as specified in the
	* GL_NV_framebuffer_multisample_coverage extension (see extension documentation).	* GL_NV_framebuffer_multisample_coverage extension (see extension documentation).
	* \param share_area	* \param share_area
	* RenderArea to share GL resources with, or NULL. NOTE: For GL res ources to	* RenderArea to share GL resources with, or NULL. NOTE: For GL res ources to
	* be shared, the two RenderAreas must be bound to the SAME GPU.	* be shared, the two RenderAreas must be bound to the SAME GPU.
	* \return	* \return

	* 'NVS_SUCCESS' if the GLcontext and image buffer were created suc	* 'CPX_R_SUCCESS' if the GLcontext and image buffer were created s
	cessfully;\n	uccessfully;\n
	* 'NVS_CTX_CREATION_FAILED' if the GLcontext could not be created;	* 'CPX_R_CTX_CREATION_FAILED' if the GLcontext could not be create
	\n	d;\n
	* 'NVS_MISSING_EXTENSION' if a required GL extensions is not prese	* 'CPX_R_MISSING_EXTENSION' if a required GL extensions is not pre
	nt;\n	sent;\n
	* 'NVS_INVALID_FBO' if the FBO is of an incorrect format;\n	* 'CPX_R_INVALID_FBO' if the FBO is of an incorrect format;\n
	* 'NVS_GL_ERROR' in case of GL errors;\n	* 'CPX_R_GL_ERROR' in case of GL errors;\n
	* 'NVS_INVALID_OBJECT' in case of an invalid GPUInfo pointer.\n	* 'CPX_R_INVALID_OBJECT' in case of an invalid GPUInfo pointer.\n
	* \remarks	* \remarks
	* If the function succeeds, the created GLcontext will be current on	* If the function succeeds, the created GLcontext will be current on
	* the calling thread and configured for off-screen rendering. The	* the calling thread and configured for off-screen rendering. The
	* RenderArea is initially created with 0 width and height, and mus t be	* RenderArea is initially created with 0 width and height, and mus t be
	* resized before it can be used.	* resized before it can be used.
	* \warning	* \warning
	* All other RenderArea methods except makeCurrent() may only be in voked	* All other RenderArea methods except makeCurrent() may only be in voked
	* when the receiving RenderArea is already current on the calling thread.	* when the receiving RenderArea is already current on the calling thread.
	* \sa resize	* \sa resize
	*/	*/

	virtual NVS_API Result initialize(GPUInfo *gpu, int format = NVS_CH _DEFAULT_CHANNELS,	virtual CPX_API Result initialize(GPUInfo *gpu, int format = CPX_CH _DEFAULT_CHANNELS,
	int colorSamples=0, int coverageS amples=0,	int colorSamples=0, int coverageS amples=0,
	RenderArea *share_area = NULL) = 0;	RenderArea *share_area = NULL) = 0;

	/*!	/*!
	* \brief Destroy the underlying image buffer and affinity context.	* \brief Destroy the underlying image buffer and affinity context.

		* \return
		* 'CPX_R_SUCCESS' if cleanup succeeded;\n
		* 'CPX_R_CONTEXT_MISMATCH' if the receiver was not current at time
		-of-call;\n
		* 'CPX_R_GENERIC_FAILURE' otherwise.\n
	* \remarks	* \remarks
	* Must be called from the thread on which the context is current.	* Must be called from the thread on which the context is current.
	*/	*/

	virtual NVS_API Result terminate(void) = 0;	virtual CPX_API Result terminate(void) = 0;

	/*!	/*!
	* \brief Make the underlying affinity context current on the calli ng thread	* \brief Make the underlying affinity context current on the calli ng thread
	* \warning	* \warning
	* All other RenderArea methods except initialize() may only be inv oked	* All other RenderArea methods except initialize() may only be inv oked
	* when the receiving RenderArea is already current on the calling thread.	* when the receiving RenderArea is already current on the calling thread.
	* \return	* \return

	* 'NVS_SUCCESS' if the underlying call succeeded;\n	* 'CPX_R_SUCCESS' if the underlying call succeeded;\n
	* 'NVS_GENERIC_FAILURE' otherwise.\n	* 'CPX_R_GENERIC_FAILURE' otherwise.\n
	*/	*/

	virtual NVS_API Result makeCurrent(void) = 0;	virtual CPX_API Result makeCurrent(void) = 0;

	/*!	/*!
	* \brief Release the current context by making the NULL context cu rrent.	* \brief Release the current context by making the NULL context cu rrent.
	* \remarks	* \remarks
	* Must be called from the thread on which the context is current.	* Must be called from the thread on which the context is current.
	* \return	* \return

	* 'NVS_SUCCESS' if the underlying call succeeded;\n	* 'CPX_R_SUCCESS' if the underlying call succeeded;\n
	* 'NVS_GENERIC_FAILURE' otherwise.\n	* 'CPX_R_CONTEXT_MISMATCH' if the receiver was not current at time
		-of-call;\n
		* 'CPX_R_GENERIC_FAILURE' otherwise.\n
	*/	*/

	virtual NVS_API Result releaseCurrent(void) = 0;	virtual CPX_API Result releaseCurrent(void) = 0;

	/*!	/*!
	* \brief Mark the end of the frame.	* \brief Mark the end of the frame.
	* \remarks	* \remarks
	* Must be called at the end of the frame. If also using the	* Must be called at the end of the frame. If also using the
	* compositor, should be called after Node::composite().	* compositor, should be called after Node::composite().
	* \return	* \return

	* 'NVS_SUCCESS' if the call succeeded;\n	* 'CPX_R_SUCCESS' if the call succeeded;\n
	* 'NVS_GENERIC_FAILURE' otherwise.\n	* 'CPX_R_CONTEXT_MISMATCH' if the receiver was not current at time
		-of-call;\n
		* 'CPX_R_GENERIC_FAILURE' otherwise.\n
	*/	*/

	virtual NVS_API Result endFrame(void) = 0;	virtual CPX_API Result endFrame(void) = 0;

	/*!	/*!
	* \brief Reallocate storage given the new dimensions of the Render Area.	* \brief Reallocate storage given the new dimensions of the Render Area.
	* \remarks	* \remarks
	* Must be called from the thread on which the context is current.	* Must be called from the thread on which the context is current.
	* \return	* \return

	* 'NVS_SUCCESS' if the FBOs were resized successfully;\n	* 'CPX_R_SUCCESS' if the FBOs were resized successfully;\n
	* 'NVS_INVALID_FBO' if the FBO is of an incorrect format;\n	* 'CPX_R_CONTEXT_MISMATCH' if the receiver was not current at time
	* 'NVS_GL_ERROR' in case of GL errors.\n	-of-call;\n
		* 'CPX_R_INVALID_FBO' if the FBO is of an incorrect format;\n
		* 'CPX_R_GL_ERROR' in case of GL errors.\n
	*/	*/

	virtual NVS_API Result resize(int width, int height) = 0;	virtual CPX_API Result resize(int width, int height) = 0;

	/*!	/*!
	* \brief Display framebuffer contents in a window	* \brief Display framebuffer contents in a window
	* \param title C-style string label for the window created	* \param title C-style string label for the window created
	* \return	* \return

	* 'NVS_SUCCESS' if the call succeeded;\n	* 'CPX_R_SUCCESS' if the call succeeded;\n
	* 'NVS_GENERIC_FAILURE' otherwise.\n	* 'CPX_R_CONTEXT_MISMATCH' if the receiver was not current at time
		-of-call;\n
		* 'CPX_R_GENERIC_FAILURE' otherwise.\n
	* \remarks	* \remarks
	* Create a window (or reuse the last one) and copy the image curre ntly	* Create a window (or reuse the last one) and copy the image curre ntly
	* residing in this RenderArea to it for inspection. When composit ion	* residing in this RenderArea to it for inspection. When composit ion
	* is behaving unexpectedly, this function can aid debugging by mak ing	* is behaving unexpectedly, this function can aid debugging by mak ing
	* the normally-offscreen "source" images visible in an independent	* the normally-offscreen "source" images visible in an independent
	* manner. The displayed image does not update automatically, but	* manner. The displayed image does not update automatically, but
	* showFBContents() may be called repeatedly to update it manually.	* showFBContents() may be called repeatedly to update it manually.
	* \warning	* \warning
	* Must be called from the thread on which the context is current.	* Must be called from the thread on which the context is current.
	* This is a slow operation intended for debugging only.	* This is a slow operation intended for debugging only.
	*/	*/

	virtual NVS_API Result showFBContents(const char *title) = 0;	virtual CPX_API Result showFBContents(const char *title) = 0;

	/*!	/*!
	* \brief Destroy the window displaying the frame buffer contents.	* \brief Destroy the window displaying the frame buffer contents.
	* \return	* \return

	* 'NVS_SUCCESS' if the call succeeded;\n	* 'CPX_R_SUCCESS' if the call succeeded;\n
	* 'NVS_GENERIC_FAILURE' otherwise.\n	* 'CPX_R_CONTEXT_MISMATCH' if the receiver was not current at time
		-of-call;\n
		* 'CPX_R_GENERIC_FAILURE' otherwise.\n
	* \remarks	* \remarks
	* Must be called from the thread on which the context is current.	* Must be called from the thread on which the context is current.
	*/	*/

	virtual NVS_API Result hideFBContents(void) = 0;	virtual CPX_API Result hideFBContents(void) = 0;
	};	};


	} // namespace nvs	} // namespace cpx


	#endif // NVS_RENDERAREA_H	#endif // CPX_RENDERAREA_H

End of changes. 23 change blocks.
	37 lines changed or deleted	52 lines changed or added

	SearchTraverser.h	SearchTraverser.h

	skipping to change at line 27	skipping to change at line 27

	namespace nvsg	namespace nvsg
	{	{
	class AnimationState;	class AnimationState;
	class IndependentPrimitiveSet;	class IndependentPrimitiveSet;
	class MeshedPrimitiveSet;	class MeshedPrimitiveSet;
	class Path;	class Path;
	class StrippedPrimitiveSet;	class StrippedPrimitiveSet;
	template<typename T> class Animation;	template<typename T> class Animation;
	template<typename T> class KeyFramedAnimationDescription;	template<typename T> class KeyFramedAnimationDescription;

		template<typename T> class OwnedObject;
	}	}

	namespace nvtraverser	namespace nvtraverser
	{	{
	//! Traverser for searching all objects of one class type.	//! Traverser for searching all objects of one class type.
	/** With a search traverser you can scan over a scene and get a vector of pointers to the objects you're searching.	/** With a search traverser you can scan over a scene and get a vector of pointers to the objects you're searching.
	* It's possible to search for objects of a specific class or for object s that have a specific base class. */	* It's possible to search for objects of a specific class or for object s that have a specific base class. */
	class SearchTraverser : public SharedTraverser	class SearchTraverser : public SharedTraverser
	{	{
	public:	public:

End of changes. 1 change blocks.
	0 lines changed or deleted	1 lines changed or added

	SystemInfo.h	SystemInfo.h

	skipping to change at line 20	skipping to change at line 20
	// INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS BEEN ADVISED OF THE	// INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS BEEN ADVISED OF THE
	// POSSIBILITY OF SUCH DAMAGES	// POSSIBILITY OF SUCH DAMAGES

	/*!	/*!
	* \file	* \file
	* \brief	* \brief
	*/	*/

	#pragma once	#pragma once


	#ifndef NVS_SYSTEM_INFO_H	#ifndef CPX_SYSTEM_INFO_H
	#define NVS_SYSTEM_INFO_H	#define CPX_SYSTEM_INFO_H


	#include "nvscale.h"	#include "complex.h"


	namespace nvs	namespace cpx
	{	{
	/*!	/*!
	* \brief GPUInfo provides the interface to get information about a	* \brief GPUInfo provides the interface to get information about a
	* a specific GPU needed to configure a compositor network.	* a specific GPU needed to configure a compositor network.

	* \par Namespace: nvs	* \par Namespace: cpx
	*/	*/
	class GPUInfo	class GPUInfo
	{	{
	private:	private:
	GPUInfo(const GPUInfo &);	GPUInfo(const GPUInfo &);
	GPUInfo& operator=(const GPUInfo &);	GPUInfo& operator=(const GPUInfo &);

	protected:	protected:
	GPUInfo();	GPUInfo();
	virtual ~GPUInfo();	virtual ~GPUInfo();

	public:	public:
	/*!	/*!

	* \brief Get the index of the represented GPU in the NVScale names pace.	* \brief Get the index of the represented GPU in the CompleX names pace.
	* \return	* \return
	* The integer index of the represented GPU.	* The integer index of the represented GPU.
	* \remarks	* \remarks
	* The value returned here is the unique name by which the represen ted	* The value returned here is the unique name by which the represen ted

	* GPU is known within the NVScale framework. It can be used to	* GPU is known within the CompleX framework. It can be used to
	* obtaining this GPUinfo object from the SystemInfo instance, to c reate	* obtaining this GPUinfo object from the SystemInfo instance, to c reate
	* an affiliated RenderArea, or anywhere else a GPU index is requir ed	* an affiliated RenderArea, or anywhere else a GPU index is requir ed

	* within the NVScale API.	* within the CompleX API.
	* \warning	* \warning

	* The integer index of the represented GPU in the NVScale namespac e is	* The integer index of the represented GPU in the CompleX namespac e is
	* NOT guaranteed to correspond to its index in any OS-maintained l ist	* NOT guaranteed to correspond to its index in any OS-maintained l ist
	* of GPUs, in the windows GPU affinity mask, or anywhere else outs ide	* of GPUs, in the windows GPU affinity mask, or anywhere else outs ide

	* the NVScale namespace. However, handles identifying the represe nted	* the CompleX namespace. However, handles identifying the represe nted
	* GPU in these contexts may also be retrieved from this GPUInfo ob ject.	* GPU in these contexts may also be retrieved from this GPUInfo ob ject.
	* \sa getDisplayString(), getAffinityHandle()	* \sa getDisplayString(), getAffinityHandle()
	*/	*/

	virtual NVS_API int getGPUIndex() const = 0;	virtual CPX_API int getGPUIndex() const = 0;

	/*!	/*!
	* \brief Get the X11 display string for this GPU.	* \brief Get the X11 display string for this GPU.
	* \return	* \return
	* A string which may be used to retrieve the X Display object	* A string which may be used to retrieve the X Display object
	* corresponding to this GPU from XOpenDisplay(), or NULL on failur e.	* corresponding to this GPU from XOpenDisplay(), or NULL on failur e.
	* \warning	* \warning
	* This method is only to be used on Linux systems, it will always return	* This method is only to be used on Linux systems, it will always return

	* failure on Windows. Use getAffinityIndex() on Windows.	* failure on Windows. Use getAffinityHandle() on Windows.
	*/	*/

	virtual NVS_API const char *getDisplayString() const = 0;	virtual CPX_API const char *getDisplayString() const = 0;

	/*!	/*!
	* \brief Get the affinity handle for this GPU.	* \brief Get the affinity handle for this GPU.
	* \return	* \return
	* A pointer to a handle which may be set in the affinity mask pass ed to	* A pointer to a handle which may be set in the affinity mask pass ed to
	* wglCreateAffinityDCNV() to obtain an HDC corresponding to this G PU,	* wglCreateAffinityDCNV() to obtain an HDC corresponding to this G PU,
	* or NULL on failure.	* or NULL on failure.
	* \warning	* \warning
	* This method is only to be used on Windows systems, it will alway s return	* This method is only to be used on Windows systems, it will alway s return
	* failure on Linux. Use getDisplayString() on Linux.	* failure on Linux. Use getDisplayString() on Linux.
	*/	*/

	virtual NVS_API PHANDLE getAffinityHandle() const = 0;	virtual CPX_API PHANDLE getAffinityHandle() const = 0;

	/*!	/*!
	* \brief Determine if the named compositor type is supported.	* \brief Determine if the named compositor type is supported.
	* \param type	* \param type

	* The type of compositor to check for, see the CompositionTechniqu	* The type of compositor for which to check support. If:\n
	e documentation	* CPX_CT_SCREEN: True if this GPU can participate in a screen
	* for more details.	* composition network;\n
		* CPX_CT_DEPTH: True if this GPU can participate in a depth
		* composition network (proper depth buffer formats are
		* available, etc.);\n
		* CPX_CT_ALPHA: True if this GPU can participate in an alpha
		* composition network (proper alpha channel formats are
		* available, etc.);\n
		* CPX_CT_SKIP: True if this GPU can participate trivially in a
		* skip-composition network (GPU is not excluded from
		* composition on technique-independent grounds, etc.).\n
	* \return	* \return

	* True if the compositing mode is supported, false otherwise.	* True if the technique is supported, false otherwise.
	*/	*/

	virtual NVS_API bool supportsCompositor(CompositionTechnique type) const = 0;	virtual CPX_API bool supportsCompositor(CompositionTechnique type) const = 0;

	/*!	/*!
	* \brief Determine if the named compositor option is supported.	* \brief Determine if the named compositor option is supported.
	* \param option	* \param option

	* The option to check for, see the CompositorOption documentation	* The option to check for. If:\n
	for	* CPX_OPT_STEREO: True if quadbuffer stereo contexts can be create
	* more details.	d on
		* this GPU;\n
		* CPX_OPT_MSAA: True if multisample anti-aliased frame buffers can
		be
		* created on this GPU;\n
		* CPX_OPT_PRODUCTION_MODE: True if this GPU can be used without
		* triggering the "developer only" warning and watermark.\n
	* \return	* \return
	* True if the compositing option is supported, false otherwise.	* True if the compositing option is supported, false otherwise.
	*/	*/

	virtual NVS_API bool supportsOption(CompositorOption option) const = 0;	virtual CPX_API bool supportsOption(CompositorOption option) const = 0;

	/*!	/*!

	* \brief Get the amount of memory the card has.	* \brief Get the specified memory capacity for this GPU in megabyt es
	* \return	* \return

	* An integer representing the amount of memory in megabytes.	* An integer representing the memory capacity (sum of allocated an
		d
		* unallocated) in megabytes.
	*/	*/

	virtual NVS_API int getMemory() const = 0;	virtual CPX_API int getMemory() const = 0;

	/*!	/*!
	* \brief Determine if the GPU is the primary display device.	* \brief Determine if the GPU is the primary display device.
	* \return	* \return
	* True if the GPU is the primary display device, false otherwise.	* True if the GPU is the primary display device, false otherwise.
	* \remark	* \remark
	* The primary display device is the device which new windows are	* The primary display device is the device which new windows are
	* created on by default.	* created on by default.
	*/	*/

	virtual NVS_API bool isPrimaryDisplay() const = 0;	virtual CPX_API bool isPrimaryDisplay() const = 0;

	// JB_NOTE: Still need a perf accessor.
	};	};

	/*!	/*!
	* \brief SystemInfo provides the interface to get system information	* \brief SystemInfo provides the interface to get system information
	* needed to configure the compositor network.	* needed to configure the compositor network.

	* \par Namespace: nvs	* \par Namespace: cpx
	*/	*/
	class SystemInfo	class SystemInfo
	{	{
	private:	private:
	SystemInfo(const SystemInfo &);	SystemInfo(const SystemInfo &);
	SystemInfo& operator=(const SystemInfo &);	SystemInfo& operator=(const SystemInfo &);

	protected:	protected:
	SystemInfo();	SystemInfo();
	virtual ~SystemInfo();	virtual ~SystemInfo();

	public:	public:
	/*!	/*!
	* \brief Obtain the one global SystemInfo instance for queries.	* \brief Obtain the one global SystemInfo instance for queries.
	*/	*/

	static NVS_API SystemInfo *getInstance();	static CPX_API SystemInfo *getInstance();

	/*!	/*!
	* \brief Get the number of GPUs recognized by the system.	* \brief Get the number of GPUs recognized by the system.
	* \remarks	* \remarks
	* gpu_name_t values in the range [0,getNumGPUs()) name GPUs eligib le for use	* gpu_name_t values in the range [0,getNumGPUs()) name GPUs eligib le for use

	* as producers or consumers in an NVScale distribution and composi tion	* as producers or consumers in an CompleX distribution and composi tion
	* network.	* network.
	*/	*/

	virtual NVS_API int getNumGPUs() const = 0;	virtual CPX_API int getNumGPUs() const = 0;

	/*!	/*!
	* \brief Get the GPUInfo object corresponding to a particular GPU.	* \brief Get the GPUInfo object corresponding to a particular GPU.
	* \param gpuIdx	* \param gpuIdx
	* The name of the GPU about which to get info.	* The name of the GPU about which to get info.
	* \return	* \return
	* Pointer to the GPUInfo instance on success, NULL on failure.	* Pointer to the GPUInfo instance on success, NULL on failure.
	* \remarks	* \remarks

	* The name used here is that of the GPU in the NVScale namespace:	* The name used here is that of the GPU in the CompleX namespace:
	an	an
	* integral value in [0, getNumGPUs()). Other functions in the NVS	* integral value in [0, getNumGPUs()). Other functions in the Com
	cale	pleX
	* API which take gpu_name_t parameters expect them to be in this n amespace	* API which take gpu_name_t parameters expect them to be in this n amespace
	* too.	* too.
	*/	*/

	virtual NVS_API GPUInfo *getGPUInfo(int gpuIdx) const = 0;	virtual CPX_API GPUInfo *getGPUInfo(int gpuIdx) const = 0;

	/*!	/*!
	* \brief Get a GPU index from a display string.	* \brief Get a GPU index from a display string.
	* \param display	* \param display
	* A string containing an X11 display name.	* A string containing an X11 display name.
	* \return	* \return
	* On success an integer which can be used to query the GPU info th rough with getGPUInfo().	* On success an integer which can be used to query the GPU info th rough with getGPUInfo().
	* On failure -1.	* On failure -1.
	* \warning	* \warning
	* This method will always fail on Windows, use getGPUInfoFromAffin ity() on Windows.	* This method will always fail on Windows, use getGPUInfoFromAffin ity() on Windows.
	*/	*/

	virtual NVS_API GPUInfo getGPUInfoFromDisplay(const char display) const = 0;	virtual CPX_API GPUInfo getGPUInfoFromDisplay(const char display) const = 0;

	/*!	/*!
	* \brief Get a GPU index from an affinity index.	* \brief Get a GPU index from an affinity index.
	* \param affHandle	* \param affHandle
	* A pointer to an HGPUNV.	* A pointer to an HGPUNV.
	* \return	* \return
	* On success an integer which can be used to query the GPU info th rough with getGPUInfo().	* On success an integer which can be used to query the GPU info th rough with getGPUInfo().
	* On failure -1.	* On failure -1.
	* \warning	* \warning
	* This method will always fail on Linux, use getGPUInfoFromDisplay () on Linux.	* This method will always fail on Linux, use getGPUInfoFromDisplay () on Linux.
	*/	*/

	virtual NVS_API GPUInfo *getGPUInfoFromAffinity(PHANDLE affHandle) const = 0;	virtual CPX_API GPUInfo *getGPUInfoFromAffinity(PHANDLE affHandle) const = 0;
	};	};
	};	};

	#endif	#endif

End of changes. 30 change blocks.
	40 lines changed or deleted	55 lines changed or added

	Tools.h	Tools.h

	skipping to change at line 16	skipping to change at line 16
	// BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGE S	// BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGE S
	// WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,	// WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
	// BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNI ARY LOSS)	// BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNI ARY LOSS)
	// ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVI DIA HAS	// ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVI DIA HAS
	// BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES	// BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES

	#pragma once	#pragma once
	/** \file */	/** \file */

	#include "nvsgcommon.h"	#include "nvsgcommon.h"

		#include "nvsg/CoreTypes.h"
	#include <vector>	#include <vector>

	#include <stdio.h>	#include <stdio.h>

	namespace nvutil	namespace nvutil
	{	{

	//! Find files matching a pattern	//! Find files matching a pattern
	/** Tries to find files matching \a mask and output results (full path)	/** Tries to find files matching \a mask and output results (full path)
	* to \a results	* to \a results

	skipping to change at line 165	skipping to change at line 166
	NVSG_API const std::string& getNextToken();	NVSG_API const std::string& getNextToken();
	NVSG_API bool hasMoreTokens() const;	NVSG_API bool hasMoreTokens() const;

	private:	private:
	unsigned int m_currentPos;	unsigned int m_currentPos;
	std::string m_inputString;	std::string m_inputString;
	std::string m_token;	std::string m_token;
	std::string m_delim;	std::string m_delim;
	};	};


		//! Sets or clears a collection of object hints recursively.
		/** Sets the object hints \a setHints and clears the hints \a clearHints
		recursively, from \a root downward.
		*/
		extern NVSG_API void ApplyNodeHints( nvsg::NodeHandle * root, unsigned in
		t setHints, unsigned int clearHints = 0 );

	} // namespace nvutil	} // namespace nvutil

End of changes. 2 change blocks.
	0 lines changed or deleted	8 lines changed or added

	nvsg.h	nvsg.h

	skipping to change at line 21	skipping to change at line 21

	#pragma once	#pragma once
	/** \file */	/** \file */

	#include "nvsg/nvsgapi.h"	#include "nvsg/nvsgapi.h"
	#include "nvutil/BitMask.h"	#include "nvutil/BitMask.h"

	#include <string>	#include <string>
	#include <vector>	#include <vector>


		#if defined(_WIN32) && _MSC_VER >= 1500
		# if _BIND_TO_CURRENT_CRT_VERSION >= 1 \|\| _BIND_TO_CURRENT_MFC_VERSION >=
		1 \|\| _BIND_TO_CURRENT_VCLIBS_VERSION >= 1
		# pragma message ("WARNING: At least one of the macros _BIND_TO_CURRENT
		_CRT_VERSION, _BIND_TO_CURRENT_VCLIBS_VERSION or BIND_TO_CURRENT_MFC_VERSIO
		N is defined. This can lead to runtime issues.")
		# endif
		#endif

	#if defined(LINUX)	#if defined(LINUX)
	// Linux specific library entry points	// Linux specific library entry points
	void nvsgLibInit() __attribute__((constructor));	void nvsgLibInit() __attribute__((constructor));
	void nvsgLibExit() __attribute__((destructor));	void nvsgLibExit() __attribute__((destructor));
	#endif	#endif

	extern void enterCritSec();	extern void enterCritSec();
	extern void leaveCritSec();	extern void leaveCritSec();

	//! Scene graph classes - core SceniX.	//! Scene graph classes - core SceniX.

End of changes. 1 change blocks.
	0 lines changed or deleted	9 lines changed or added

	optix.h	optix.h

	/*	/*

	* Copyright NVIDIA Corporation 2008	* Copyright (c) 2008 - 2009 NVIDIA Corporation. All rights reserved.
	* TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROV	*
	IDED	* NVIDIA Corporation and its licensors retain all intellectual property an
	* AS IS AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXP	d proprietary
	RESS	* rights in and to this software, related documentation and any modificati
	* OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHAN	ons thereto.
	TABILITY	* Any use, reproduction, disclosure or distribution of this software and r
	* AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL NVIDIA OR ITS S	elated
	UPPLIERS	* documentation without an express license agreement from NVIDIA Corporati
	* BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGE	on is strictly
	S	* prohibited.
	* WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS	*
	PROFITS,	* TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROV
	* BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNI	IDED AS IS
	ARY LOSS)	* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS OR
	* ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVI	IMPLIED,
	DIA HAS	* INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND
	* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES	FITNESS FOR A
		* PARTICULAR PURPOSE. IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS BE LIABLE
		FOR ANY
		* SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES WHATSOEVER (INCL
		UDING, WITHOUT
		* LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS, BUSINESS INTERRUPTION,
		LOSS OF
		* BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS) ARISING OUT OF THE US
		E OF OR
		* INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS BEEN ADVISED OF THE P
		OSSIBILITY OF
		* SUCH DAMAGES
	*/	*/

	#ifndef __optix_optix_h__	#ifndef __optix_optix_h__
	#define __optix_optix_h__	#define __optix_optix_h__


	#define OPTIX_VERSION 1000 /* 1.0.0 (major = OPTIX_VERSION/1000, minor = (O PTIX_VERSION%1000)/10, micro = OPTIX_VERSION%10 */	#define OPTIX_VERSION 1002 /* 1.0.2 (major = OPTIX_VERSION/1000, minor = (O PTIX_VERSION%1000)/10, micro = OPTIX_VERSION%10 */

	#ifndef RTAPI	#ifndef RTAPI
	#if defined( _WIN32 )	#if defined( _WIN32 )
	#define RTAPI __declspec(dllimport)	#define RTAPI __declspec(dllimport)
	#else	#else
	#define RTAPI	#define RTAPI
	#endif	#endif
	#endif	#endif

	/************************************	/************************************

End of changes. 2 change blocks.
	19 lines changed or deleted	30 lines changed or added

	optix_gl_interop.h	optix_gl_interop.h

	/*	/*

	* Copyright NVIDIA Corporation 2008	* Copyright (c) 2008 - 2009 NVIDIA Corporation. All rights reserved.
	* TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROV	*
	IDED	* NVIDIA Corporation and its licensors retain all intellectual property an
	* AS IS AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXP	d proprietary
	RESS	* rights in and to this software, related documentation and any modificati
	* OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHAN	ons thereto.
	TABILITY	* Any use, reproduction, disclosure or distribution of this software and r
	* AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL NVIDIA OR ITS S	elated
	UPPLIERS	* documentation without an express license agreement from NVIDIA Corporati
	* BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGE	on is strictly
	S	* prohibited.
	* WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS	*
	PROFITS,	* TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROV
	* BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNI	IDED AS IS
	ARY LOSS)	* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS OR
	* ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVI	IMPLIED,
	DIA HAS	* INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND
	* BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES	FITNESS FOR A
		* PARTICULAR PURPOSE. IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS BE LIABLE
		FOR ANY
		* SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES WHATSOEVER (INCL
		UDING, WITHOUT
		* LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS, BUSINESS INTERRUPTION,
		LOSS OF
		* BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS) ARISING OUT OF THE US
		E OF OR
		* INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS BEEN ADVISED OF THE P
		OSSIBILITY OF
		* SUCH DAMAGES
	*/	*/

	#ifndef __optix_optix_gl_interop_h__	#ifndef __optix_optix_gl_interop_h__
	#define __optix_optix_gl_interop_h__	#define __optix_optix_gl_interop_h__

	#include "optix.h"	#include "optix.h"

	/************************************	/************************************
	**	**
	** OpenGL Interop functions	** OpenGL Interop functions

End of changes. 1 change blocks.
	18 lines changed or deleted	29 lines changed or added

This html diff was produced by rfcdiff 1.41. The latest version is available from http://tools.ietf.org/tools/rfcdiff/

	CameraManipulator.h	CameraManipulator.h

	skipping to change at line 49	skipping to change at line 49
	NVSG_ZOOM, /!< Addresses input mask for a zoom op eration. /	NVSG_ZOOM, /!< Addresses input mask for a zoom op eration. /
	NVSG_DOLLY_ZOOM, /!< Addresses input mask for a dolly-z oom operation. /	NVSG_DOLLY_ZOOM, /!< Addresses input mask for a dolly-z oom operation. /
	NVSG_LOOK_AT, /!< Addresses input mask for a look-at operation. /	NVSG_LOOK_AT, /!< Addresses input mask for a look-at operation. /
	NVSG_FLY_FORWARD, /!< Addresses input mask for a fly for ward operation. /	NVSG_FLY_FORWARD, /!< Addresses input mask for a fly for ward operation. /
	NVSG_FLY_BACKWARD, /!< Addresses input mask for a fly bac kward operation. /	NVSG_FLY_BACKWARD, /!< Addresses input mask for a fly bac kward operation. /
	NVSG_WALK_FORWARD, /!< Addresses input mask for a walk fo rward operation. /	NVSG_WALK_FORWARD, /!< Addresses input mask for a walk fo rward operation. /
	NVSG_WALK_BACKWARD, /!< Addresses input mask for a walk ba ckward operation. /	NVSG_WALK_BACKWARD, /!< Addresses input mask for a walk ba ckward operation. /
	NVSG_TILT, /!< Addresses input mask for a tilt op eration. /	NVSG_TILT, /!< Addresses input mask for a tilt op eration. /
	NVSG_TRANSLATE, /!< Addresses input mask for a transla te operation. /	NVSG_TRANSLATE, /!< Addresses input mask for a transla te operation. /
	NVSG_LOCK_AXIS, /!< Addresses input mask for a lock ax is operation. /	NVSG_LOCK_AXIS, /!< Addresses input mask for a lock ax is operation. /

	NVSK_CUSTOM_OPERATION_0, /*!< Reserved to address a custom opera	NVSG_CUSTOM_OPERATION_0, /*!< Reserved to address a custom opera
	tion. */	tion. */
	NVSK_CUSTOM_OPERATION_1, /*!< Reserved to address a custom opera	NVSG_CUSTOM_OPERATION_1, /*!< Reserved to address a custom opera
	tion. */	tion. */
	NVSK_CUSTOM_OPERATION_2, /*!< Reserved to address a custom opera	NVSG_CUSTOM_OPERATION_2, /*!< Reserved to address a custom opera
	tion. */	tion. */
	NVSK_CUSTOM_OPERATION_3, /*!< Reserved to address a custom opera	NVSG_CUSTOM_OPERATION_3, /*!< Reserved to address a custom opera
	tion. */	tion. */
	NVSK_CUSTOM_OPERATION_4, /*!< Reserved to address a custom opera	NVSG_CUSTOM_OPERATION_4, /*!< Reserved to address a custom opera
	tion. */	tion. */
	NVSK_CUSTOM_OPERATION_5, /*!< Reserved to address a custom opera	NVSG_CUSTOM_OPERATION_5, /*!< Reserved to address a custom opera
	tion. */	tion. */
	NVSK_CUSTOM_OPERATION_6, /*!< Reserved to address a custom opera	NVSG_CUSTOM_OPERATION_6, /*!< Reserved to address a custom opera
	tion. */	tion. */
	NVSK_CUSTOM_OPERATION_7, /*!< Reserved to address a custom opera	NVSG_CUSTOM_OPERATION_7, /*!< Reserved to address a custom opera
	tion. */	tion. */
	NVSK_CUSTOM_OPERATION_8, /*!< Reserved to address a custom opera	NVSG_CUSTOM_OPERATION_8, /*!< Reserved to address a custom opera
	tion. */	tion. */
	NVSG_CAMERA_OPERATION_COUNT,	NVSG_CAMERA_OPERATION_COUNT,
	NVSG_NO_CAMERA_OPERATION = ~0	NVSG_NO_CAMERA_OPERATION = ~0
	};	};

	/! \brief Called on destruction /	/! \brief Called on destruction /
	NVSG_API virtual ~CameraManipulator();	NVSG_API virtual ~CameraManipulator();

	/! \brief Resets the input mask for all supported operations. /	/! \brief Resets the input mask for all supported operations. /
	NVSG_API void setDefaultInputMask();	NVSG_API void setDefaultInputMask();


End of changes. 1 change blocks.
	18 lines changed or deleted	18 lines changed or added

	CgmFx.h	CgmFx.h

	skipping to change at line 66	skipping to change at line 66
	#define cgsGetLastListing cgGetLastListing	#define cgsGetLastListing cgGetLastListing
	#define cgsIsProgram cgIsProgram	#define cgsIsProgram cgIsProgram
	#define cgsCompileProgram cgCompileProgram	#define cgsCompileProgram cgCompileProgram
	#define cgsIsProgramCompiled cgIsProgramCompiled	#define cgsIsProgramCompiled cgIsProgramCompiled
	#define cgsGetProgramString cgGetProgramString	#define cgsGetProgramString cgGetProgramString
	#define cgsGetProgramProfile cgGetProgramProfile	#define cgsGetProgramProfile cgGetProgramProfile
	#define cgsGetProgramInput cgGetProgramInput	#define cgsGetProgramInput cgGetProgramInput
	#define cgsGetProgramOutput cgGetProgramOutput	#define cgsGetProgramOutput cgGetProgramOutput
	#define cgsGetArrayType cgGetArrayType	#define cgsGetArrayType cgGetArrayType
	#define cgsGetArraySize cgGetArraySize	#define cgsGetArraySize cgGetArraySize

		#define cgsSetArraySize cgSetArraySize
	#define cgsIsParameter cgIsParameter	#define cgsIsParameter cgIsParameter
	#define cgsGetParameterName cgGetParameterName	#define cgsGetParameterName cgGetParameterName
	#define cgsGetParameterType cgGetParameterType	#define cgsGetParameterType cgGetParameterType
	#define cgsGetParameterClass cgGetParameterClass	#define cgsGetParameterClass cgGetParameterClass
	#define cgsGetParameterNamedType cgGetParameterNamedType	#define cgsGetParameterNamedType cgGetParameterNamedType
	#define cgsGetParameterSemantic cgGetParameterSemantic	#define cgsGetParameterSemantic cgGetParameterSemantic
	#define cgsGetParameterDirection cgGetParameterDirection	#define cgsGetParameterDirection cgGetParameterDirection
	#define cgsIsParameterReferenced cgIsParameterReferenced	#define cgsIsParameterReferenced cgIsParameterReferenced
	#define cgsIsParameterUsed cgIsParameterUsed	#define cgsIsParameterUsed cgIsParameterUsed
	#define cgsGetParameterValues cgGetParameterValues	#define cgsGetParameterValues cgGetParameterValues
	#define cgsGetParameterValuefc cgGetParameterValuefc	#define cgsGetParameterValuefc cgGetParameterValuefc
	#define cgsGetParameterValuefr cgGetParameterValuefr	#define cgsGetParameterValuefr cgGetParameterValuefr
	#define cgsGetParameterValueic cgGetParameterValueic	#define cgsGetParameterValueic cgGetParameterValueic
	#define cgsGetStringParameterValue cgGetStringParameterValue	#define cgsGetStringParameterValue cgGetStringParameterValue
	#define cgsSetParameterValuefc cgSetParameterValuefc	#define cgsSetParameterValuefc cgSetParameterValuefc
	#define cgsSetParameterValueic cgSetParameterValueic	#define cgsSetParameterValueic cgSetParameterValueic

		#define cgsGetArrayParameter cgGetArrayParameter
		#define cgsDestroyParameter cgDestroyParameter
		#define cgsConnectParameter cgConnectParameter
		#define cgsDisconnectParameter cgDisconnectParameter
		#define cgsGetNamedUserType cgGetNamedUserType
	#define cgsSetStringParameterValue cgSetStringParameterValue	#define cgsSetStringParameterValue cgSetStringParameterValue
	#define cgsSetMatrixParameterfc cgSetMatrixParameterfc	#define cgsSetMatrixParameterfc cgSetMatrixParameterfc
	#define cgsGetTechniqueName cgGetTechniqueName	#define cgsGetTechniqueName cgGetTechniqueName
	#define cgsIsTechnique cgIsTechnique	#define cgsIsTechnique cgIsTechnique
	#define cgsValidateTechnique cgValidateTechnique	#define cgsValidateTechnique cgValidateTechnique
	#define cgsIsTechniqueValidated cgIsTechniqueValidated	#define cgsIsTechniqueValidated cgIsTechniqueValidated
	#define cgsIsPass cgIsPass	#define cgsIsPass cgIsPass
	#define cgsGetPassName cgGetPassName	#define cgsGetPassName cgGetPassName
	#define cgsSetPassState cgSetPassState	#define cgsSetPassState cgSetPassState
	#define cgsResetPassState cgResetPassState	#define cgsResetPassState cgResetPassState

	skipping to change at line 159	skipping to change at line 165
	#define cgmGetFirstPassAnnotation cgGetFirstPassAnnotation	#define cgmGetFirstPassAnnotation cgGetFirstPassAnnotation
	#define cgmGetFirstParameterAnnotation cgGetFirstParameterAnnotation	#define cgmGetFirstParameterAnnotation cgGetFirstParameterAnnotation
	#define cgmGetNextAnnotation cgGetNextAnnotation	#define cgmGetNextAnnotation cgGetNextAnnotation
	#define cgmCreateSamplerState cgCreateSamplerState	#define cgmCreateSamplerState cgCreateSamplerState
	#define cgmSetFloatStateAssignment cgSetFloatStateAssignment	#define cgmSetFloatStateAssignment cgSetFloatStateAssignment
	#define cgmSetIntStateAssignment cgSetIntStateAssignment	#define cgmSetIntStateAssignment cgSetIntStateAssignment
	#define cgmSetBoolStateAssignment cgSetBoolStateAssignment	#define cgmSetBoolStateAssignment cgSetBoolStateAssignment
	#define cgmSetFloatArrayStateAssignment cgSetFloatArrayStateAssignment	#define cgmSetFloatArrayStateAssignment cgSetFloatArrayStateAssignment
	#define cgmSetIntArrayStateAssignment cgSetIntArrayStateAssignment	#define cgmSetIntArrayStateAssignment cgSetIntArrayStateAssignment
	#define cgmSetBoolArrayStateAssignment cgSetBoolArrayStateAssignment	#define cgmSetBoolArrayStateAssignment cgSetBoolArrayStateAssignment

		#define cgmCreateParameter cgCreateParameter

	#else // #ifdef NVSG_DISABLE_CG_MULTIPLEX	#else // #ifdef NVSG_DISABLE_CG_MULTIPLEX

	//	//
	// Types	// Types
	//	//
	typedef nvutil::RCVector<CGcontext> CGMcontextVec;	typedef nvutil::RCVector<CGcontext> CGMcontextVec;
	typedef nvutil::SmartPtr<CGMcontextVec> CGMcontext;	typedef nvutil::SmartPtr<CGMcontextVec> CGMcontext;
	typedef nvutil::RCVector<CGeffect> CGMeffectVec;	typedef nvutil::RCVector<CGeffect> CGMeffectVec;
	typedef nvutil::SmartPtr<CGMeffectVec> CGMeffect;	typedef nvutil::SmartPtr<CGMeffectVec> CGMeffect;

	skipping to change at line 270	skipping to change at line 277
	void cgsCompileProgram(CGMprogram program);	void cgsCompileProgram(CGMprogram program);
	CGbool cgsIsProgramCompiled(CGMprogram program);	CGbool cgsIsProgramCompiled(CGMprogram program);
	const char * cgsGetProgramString(CGMprogram prog, CGenum pname);	const char * cgsGetProgramString(CGMprogram prog, CGenum pname);
	CGprofile cgsGetProgramProfile(CGMprogram prog);	CGprofile cgsGetProgramProfile(CGMprogram prog);
	CGenum cgsGetProgramInput(CGMprogram program);	CGenum cgsGetProgramInput(CGMprogram program);
	CGenum cgsGetProgramOutput(CGMprogram program);	CGenum cgsGetProgramOutput(CGMprogram program);

	// Parameter functions	// Parameter functions
	CGtype cgsGetArrayType(CGMparameter param);	CGtype cgsGetArrayType(CGMparameter param);
	int cgsGetArraySize(CGMparameter param, int dimension);	int cgsGetArraySize(CGMparameter param, int dimension);

		void cgsSetArraySize(CGMparameter param, int size);
	CGbool cgsIsParameter(CGMparameter param);	CGbool cgsIsParameter(CGMparameter param);
	const char * cgsGetParameterName(CGMparameter param);	const char * cgsGetParameterName(CGMparameter param);
	CGtype cgsGetParameterType(CGMparameter param);	CGtype cgsGetParameterType(CGMparameter param);
	CGparameterclass cgsGetParameterClass(CGMparameter param);	CGparameterclass cgsGetParameterClass(CGMparameter param);
	CGtype cgsGetParameterNamedType(CGMparameter param);	CGtype cgsGetParameterNamedType(CGMparameter param);
	const char * cgsGetParameterSemantic(CGMparameter param);	const char * cgsGetParameterSemantic(CGMparameter param);
	CGenum cgsGetParameterDirection(CGMparameter param);	CGenum cgsGetParameterDirection(CGMparameter param);
	CGbool cgsIsParameterReferenced(CGMparameter param);	CGbool cgsIsParameterReferenced(CGMparameter param);
	CGbool cgsIsParameterUsed(CGMparameter param, CGMeffect);	CGbool cgsIsParameterUsed(CGMparameter param, CGMeffect);
	const double * cgsGetParameterValues(CGMparameter param, CGenum value_type, int *nvalues);	const double * cgsGetParameterValues(CGMparameter param, CGenum value_type, int *nvalues);
	int cgsGetParameterValuefc(CGMparameter param, int n, float *vals);	int cgsGetParameterValuefc(CGMparameter param, int n, float *vals);
	int cgsGetParameterValuefr(CGMparameter param, int n, float *vals);	int cgsGetParameterValuefr(CGMparameter param, int n, float *vals);
	int cgsGetParameterValueic(CGMparameter param, int n, int *vals);	int cgsGetParameterValueic(CGMparameter param, int n, int *vals);
	const char * cgsGetStringParameterValue(CGMparameter param);	const char * cgsGetStringParameterValue(CGMparameter param);
	void cgsSetParameterValuefc(CGMparameter param, int n, const float *vals);	void cgsSetParameterValuefc(CGMparameter param, int n, const float *vals);
	void cgsSetParameterValueic(CGMparameter param, int n, const int *vals);	void cgsSetParameterValueic(CGMparameter param, int n, const int *vals);
	void cgsSetStringParameterValue(CGMparameter param, const char *str);	void cgsSetStringParameterValue(CGMparameter param, const char *str);
	void cgsSetMatrixParameterfc(CGMparameter param, const float *matrix);	void cgsSetMatrixParameterfc(CGMparameter param, const float *matrix);


		CGparameter cgsGetArrayParameter( CGMparameter aparam, int index );
		void cgsDestroyParameter(CGparameter param);
		void cgsConnectParameter(CGparameter from, CGparameter to);
		void cgsDisconnectParameter(CGparameter param);

	// Type Functions	// Type Functions

		CGtype cgsGetNamedUserType(CGMeffect effect, const char *name);
	// Resource Functions	// Resource Functions
	// Enum Functions	// Enum Functions
	// Profile Functions	// Profile Functions
	// Error Functions	// Error Functions
	// Misc Functions	// Misc Functions

	// CgFX Functions	// CgFX Functions
	const char * cgsGetTechniqueName(CGMtechnique);	const char * cgsGetTechniqueName(CGMtechnique);
	CGbool cgsIsTechnique(CGMtechnique);	CGbool cgsIsTechnique(CGMtechnique);
	CGbool cgsValidateTechnique(CGMtechnique);	CGbool cgsValidateTechnique(CGMtechnique);

	skipping to change at line 356	skipping to change at line 370
	// Parameter functions	// Parameter functions
	CGMparameter cgmGetNextParameter(CGMparameter current);	CGMparameter cgmGetNextParameter(CGMparameter current);
	CGMparameter cgmGetFirstLeafParameter(CGMprogram prog, CGenum name_space);	CGMparameter cgmGetFirstLeafParameter(CGMprogram prog, CGenum name_space);
	CGMparameter cgmGetNextLeafParameter(CGMparameter current);	CGMparameter cgmGetNextLeafParameter(CGMparameter current);
	CGMparameter cgmGetFirstStructParameter(CGMparameter param);	CGMparameter cgmGetFirstStructParameter(CGMparameter param);
	CGMparameter cgmGetArrayParameter(CGMparameter aparam, int index);	CGMparameter cgmGetArrayParameter(CGMparameter aparam, int index);
	void cgmSetParameterValuefc(CGMparameter param, int n, const float *vals);	void cgmSetParameterValuefc(CGMparameter param, int n, const float *vals);
	void cgmSetParameterValueic(CGMparameter param, int n, const int *vals);	void cgmSetParameterValueic(CGMparameter param, int n, const int *vals);
	void cgmSetStringParameterValue(CGMparameter param, const char *str);	void cgmSetStringParameterValue(CGMparameter param, const char *str);


		CGMparameter cgmCreateParameter(CGMcontext context, CGtype type);
		void cgmDestroyParameter(CGMparameter param);

	// Type Functions	// Type Functions
	// Resource Functions	// Resource Functions
	// Enum Functions	// Enum Functions
	// Profile Functions	// Profile Functions
	// Error Functions	// Error Functions
	// Misc Functions	// Misc Functions

	// CgFX Functions	// CgFX Functions
	CGMeffect cgmCreateEffect(CGMcontext, const char code, const char *args);	CGMeffect cgmCreateEffect(CGMcontext, const char code, const char *args);
	CGMeffect cgmCreateEffectFromFile(CGMcontext, const char filename, const c har *args);	CGMeffect cgmCreateEffectFromFile(CGMcontext, const char filename, const c har *args);

End of changes. 7 change blocks.
	0 lines changed or deleted	17 lines changed or added

	GLContext.h	GLContext.h

	skipping to change at line 17253	skipping to change at line 17253
	* have become corrupted during the period that the buffer was mapped. */	* have become corrupted during the period that the buffer was mapped. */
	NVSG_API GLboolean GLUnmapIndexBuffer(GLuint buffer);	NVSG_API GLboolean GLUnmapIndexBuffer(GLuint buffer);

	//! Returns the 64-bit video memory address for the specified buffer	//! Returns the 64-bit video memory address for the specified buffer
	/** Vertex and index buffers might be collected in a higher-level buffer ob ject.	/** Vertex and index buffers might be collected in a higher-level buffer ob ject.
	* This function returns the 64-bit video memory address of the higher-lev el buffer object.	* This function returns the 64-bit video memory address of the higher-lev el buffer object.
	* \note This funtion requires the GL_NV_vertex_buffer_unified_memory exte nsion.	* \note This funtion requires the GL_NV_vertex_buffer_unified_memory exte nsion.
	* \returns The 64-bit video memory address for the specified buffer. */	* \returns The 64-bit video memory address for the specified buffer. */
	NVSG_API GLuint64EXT GLGetBufferAddress(GLuint buffer);	NVSG_API GLuint64EXT GLGetBufferAddress(GLuint buffer);


		//! Returns the size of the specified buffer
		/** Vertex and index buffers might be collected in a higher-level buffer ob
		ject.
		* This function returns the size of the higher-level buffer object.
		* \note This funtion requires the GL_NV_vertex_buffer_unified_memory exte
		nsion.
		* \returns The size of the higher-level buffer object. */
		NVSG_API GLsizeiptr GLGetBufferSize(GLuint buffer);

	//! Returns the start offset for the specified buffer	//! Returns the start offset for the specified buffer
	/** Vertex buffers might be collected in a higher-level buffer object.	/** Vertex buffers might be collected in a higher-level buffer object.
	* This function returns the start offset inside the higher-level buffer o bject.	* This function returns the start offset inside the higher-level buffer o bject.
	* \returns The start offset inside the higher-level vertex buffer object. */	* \returns The start offset inside the higher-level vertex buffer object. */
	NVSG_API GLsizeiptr GLGetVertexBufferOffset(GLuint buffer);	NVSG_API GLsizeiptr GLGetVertexBufferOffset(GLuint buffer);

	//! VBO / Cache Filling Methods	//! VBO / Cache Filling Methods
	/** Build the caches from the attributes sent.	/** Build the caches from the attributes sent.
	* \returns A buffer cache. */	* \returns A buffer cache. */
	NVSG_API void GLBuildVertexBufferCache( nvgl::GLArrayBufferCache * vi,	NVSG_API void GLBuildVertexBufferCache( nvgl::GLArrayBufferCache * vi,

End of changes. 1 change blocks.
	0 lines changed or deleted	9 lines changed or added

	Object.h	Object.h

	skipping to change at line 151	skipping to change at line 151
	* Object, until an object code is encountered a handler function is reg istered for. */	* Object, until an object code is encountered a handler function is reg istered for. */
	class Object : public nvutil::HandledObject, public DALHostHolder // an object can host DAL data	class Object : public nvutil::HandledObject, public DALHostHolder // an object can host DAL data
	{	{
	public:	public:

	enum	enum
	{	{
	/*! \brief Flags the Object as always visible	/*! \brief Flags the Object as always visible
	* \remarks A visible-flagged Object will not be considered by the	* \remarks A visible-flagged Object will not be considered by the
	* frameworks cull step. By default, this hint is not set. */	* frameworks cull step. By default, this hint is not set. */

	NVSG_HINT_ALWAYS_VISIBLE = BIT0, // always visible	NVSG_HINT_ALWAYS_VISIBLE = BIT0, // always visi ble

	/*! \brief Flags the Object as always invisible	/*! \brief Flags the Object as always invisible
	* \remarks An invisible-flagged Object will not be processed by the	* \remarks An invisible-flagged Object will not be processed by the
	* render framework. By default, this hint is not set. */	* render framework. By default, this hint is not set. */

	NVSG_HINT_ALWAYS_INVISIBLE = BIT1, // never visible	NVSG_HINT_ALWAYS_INVISIBLE = BIT1, // never visib le
	NVSG_HINT_VISIBILITY_MASK = NVSG_HINT_ALWAYS_VISIBLE \| NVSG_HINT_ALWA YS_INVISIBLE,	NVSG_HINT_VISIBILITY_MASK = NVSG_HINT_ALWAYS_VISIBLE \| NVSG_HINT_ALWA YS_INVISIBLE,

	/* \brief Flags the Object not to cast shadows	/* \brief Flags the Object not to cast shadows
	* \remarks Shadow algorithms can consider this hint for optimized	* \remarks Shadow algorithms can consider this hint for optimized
	* strategy. */	* strategy. */

	NVSG_HINT_NO_SHADOW_CASTER = BIT2,	NVSG_HINT_NO_SHADOW_CASTER = BIT2,

	/* \brief Flags the Object not to receive shadows	/* \brief Flags the Object not to receive shadows
	* \remarks Shadow algorithms can consider this hint for optimized	* \remarks Shadow algorithms can consider this hint for optimized
	* strategy. */	* strategy. */

	NVSG_HINT_NO_SHADOW_RECEIVER = BIT3,	NVSG_HINT_NO_SHADOW_RECEIVER = BIT3,

	/* \brief Flags the Object as overlay Object	/* \brief Flags the Object as overlay Object
	* \remarks An overlay Object will always be rendered on top of other	* \remarks An overlay Object will always be rendered on top of other
	* non-overlay Objects independent of the Objects z-depth. By default ,	* non-overlay Objects independent of the Objects z-depth. By default ,
	* this hint is not set. */	* this hint is not set. */

	NVSG_HINT_OVERLAY = BIT4,	NVSG_HINT_OVERLAY = BIT4,

	/*! \brief Flags the Object as frequently altering	/*! \brief Flags the Object as frequently altering
	* \remarks The processing framework considers dynamic-flagged object s	* \remarks The processing framework considers dynamic-flagged object s
	* different from ordinary non-dynamic Objects to yield optimized ren der	* different from ordinary non-dynamic Objects to yield optimized ren der
	* performance. By default, an Object is not flagged dynamic. */	* performance. By default, an Object is not flagged dynamic. */

	NVSG_HINT_DYNAMIC = BIT5,	NVSG_HINT_DYNAMIC = BIT5,

	/*! \brief Flags the Object as not being considered for clipping	/*! \brief Flags the Object as not being considered for clipping
	* \remarks During rendering, active clip planes have no effect on Ob jects	* \remarks During rendering, active clip planes have no effect on Ob jects
	* that have the NVSG_HINT_DONT_CLIP bit set. This hint only applies to	* that have the NVSG_HINT_DONT_CLIP bit set. This hint only applies to
	* Node-derived Objects. */	* Node-derived Objects. */

	NVSG_HINT_DONT_CLIP = BIT6,	NVSG_HINT_DONT_CLIP = BIT6,


	NVSG_HINT_LAST_HINT = NVSG_HINT_DONT_CLIP,	/* \brief Advises the ray tracing framework to use high quality AS b
		uilder
		* \remarks The flag advises the ray tracing engine to use high qual
		ity AS builder for
		* this particular object. Higher quality acceleration structures po
		tentially take longer
		* to be built and probably require more memory, but often support c
		onsiderably faster ray
		* tracing than lower quality acceleration structures. */
		NVSG_HINT_HIGH_QUALITY_ACCELERATION_BUILDER = BIT7,

		NVSG_HINT_LAST_HINT = NVSG_HINT_HIGH_QUALITY_
		ACCELERATION_BUILDER,

	/! \brief All possible hints /	/! \brief All possible hints /

	NVSG_HINT_ALL_HINTS = (NVSG_HINT_LAST_HINT << 1) - 1	NVSG_HINT_ALL_HINTS = (NVSG_HINT_LAST_HINT << 1) - 1
	};	};

	enum	enum
	{	{
	NVSG_INCARNATION = BIT0,	NVSG_INCARNATION = BIT0,
	NVSG_INCARNATION_VALID = NVSG_INCARNATION, // alias	NVSG_INCARNATION_VALID = NVSG_INCARNATION, // alias
	NVSG_TREE_INCARNATION = BIT1,	NVSG_TREE_INCARNATION = BIT1,
	NVSG_TREE_INCARNATION_VALID = NVSG_TREE_INCARNATION, // alias	NVSG_TREE_INCARNATION_VALID = NVSG_TREE_INCARNATION, // alias
	NVSG_SWITCH_INCARNATION = BIT2,	NVSG_SWITCH_INCARNATION = BIT2,
	NVSG_SWITCH_INCARNATION_VALID = NVSG_SWITCH_INCARNATION, // alias	NVSG_SWITCH_INCARNATION_VALID = NVSG_SWITCH_INCARNATION, // alias

	skipping to change at line 418	skipping to change at line 425
	NVSG_API const void* getUserData() const;	NVSG_API const void* getUserData() const;

	/*! \brief Retrieves Object hints	/*! \brief Retrieves Object hints
	* \param mask	* \param mask
	* Specifies a bit mask to indicate the Object hints to retrieve.	* Specifies a bit mask to indicate the Object hints to retrieve.
	* \return	* \return
	* The function returns the Object's hint bits filtered by the input ma sk.	* The function returns the Object's hint bits filtered by the input ma sk.
	* \remarks	* \remarks
	* An object can be given hints indicating a certain Object properties.	* An object can be given hints indicating a certain Object properties.
	* Currently supported Object hints are NVSG_HINT_DYNAMIC, NVSG_HINT_AL WAYS_VISIBLE,	* Currently supported Object hints are NVSG_HINT_DYNAMIC, NVSG_HINT_AL WAYS_VISIBLE,

	* NVSG_HINT_ALWAYS_INVISIBLE, NVSG_HINT_OVERLAY, NVSG_HINT_SHADOW_CAST	* NVSG_HINT_ALWAYS_INVISIBLE, NVSG_HINT_OVERLAY, NVSG_HINT_SHADOW_CAST
	ER, and	ER,
	* NVSG_HINT_SHADOW_RECEIVER.	* NVSG_HINT_SHADOW_RECEIVER, and NVSG_HINT_HIGH_QUALITY_ACCELERATION_B
		UILDER.
	* \sa setHints, addHints, removeHints */	* \sa setHints, addHints, removeHints */
	NVSG_API unsigned int getHints( unsigned int mask = ~0 ) const;	NVSG_API unsigned int getHints( unsigned int mask = ~0 ) const;

	/*! \brief Assigns indicated hints to the Object	/*! \brief Assigns indicated hints to the Object
	* \param hints	* \param hints
	* Specifies the hints to assign to the Object. Allowed bits are	* Specifies the hints to assign to the Object. Allowed bits are
	* NVSG_HINT_DYNAMIC, NVSG_HINT_ALWAYS_VISIBLE, NVSG_HINT_ALWAYS_INVISI BLE,	* NVSG_HINT_DYNAMIC, NVSG_HINT_ALWAYS_VISIBLE, NVSG_HINT_ALWAYS_INVISI BLE,
	* NVSG_HINT_OVERLAY, NVSG_HINT_SHADOW_CASTER, NVSG_HINT_SHADOW_RECEIVE R,	* NVSG_HINT_OVERLAY, NVSG_HINT_SHADOW_CASTER, NVSG_HINT_SHADOW_RECEIVE R,

	* or any combination of these.	* NVSG_HINT_HIGH_QUALITY_ACCELERATION_BUILDER or any combination of th ese.
	* \remarks	* \remarks
	* The function assigns the indicated hints to the Object. Previously a ssigned	* The function assigns the indicated hints to the Object. Previously a ssigned
	* hints will be overriden. If you intend to keep previosly assigned hi nts,	* hints will be overriden. If you intend to keep previosly assigned hi nts,
	* you should use addHints instead.	* you should use addHints instead.
	* \sa getHints, addHints, removeHints */	* \sa getHints, addHints, removeHints */
	NVSG_API void setHints( unsigned int hints );	NVSG_API void setHints( unsigned int hints );

	/*! \brief Adds indicated hints to the Object	/*! \brief Adds indicated hints to the Object
	* \param hints	* \param hints
	* Specifies the hints to add to the Object. Allowed bits are	* Specifies the hints to add to the Object. Allowed bits are

End of changes. 11 change blocks.
	13 lines changed or deleted	26 lines changed or added

	Quatt.h	Quatt.h

	skipping to change at line 145	skipping to change at line 145
	template<typename T>	template<typename T>
	T distance( const Quatt<T> & q0, const Quatt<T> & q1 );	T distance( const Quatt<T> & q0, const Quatt<T> & q1 );

	/*! \brief Test if a quaternion is normalized.	/*! \brief Test if a quaternion is normalized.
	* \param q A reference to the constant quaternion to test.	* \param q A reference to the constant quaternion to test.
	* \param eps An optional value giving the allowed epsilon. The default is a type dependent value.	* \param eps An optional value giving the allowed epsilon. The default is a type dependent value.
	* \return \c true if the quaternion is normalized, otherwise \c false.	* \return \c true if the quaternion is normalized, otherwise \c false.
	* \remarks A quaternion \a q is considered to be normalized, when it's magnitude differs less	* \remarks A quaternion \a q is considered to be normalized, when it's magnitude differs less
	* than some small value \a eps from one. */	* than some small value \a eps from one. */
	template<typename T>	template<typename T>

	bool isNormalized( const Quatt<T> & q, T eps = std::numeric_limits<T>:: epsilon() )	bool isNormalized( const Quatt<T> & q, T eps = std::numeric_limits<T>:: epsilon() * 2 )
	{	{
	return( abs( magnitude( q ) - 1 ) <= eps );	return( abs( magnitude( q ) - 1 ) <= eps );
	}	}

	/*! \brief Test if a quaternion is null.	/*! \brief Test if a quaternion is null.
	* \param q A reference to the constant quaternion to test.	* \param q A reference to the constant quaternion to test.
	* \param eps An optional value giving the allowed epsilon. The default is a type dependent value.	* \param eps An optional value giving the allowed epsilon. The default is a type dependent value.
	* \return \c true if the quaternion is null, otherwise \c false.	* \return \c true if the quaternion is null, otherwise \c false.
	* \remarks A quaternion \a q is considered to be null, if it's magnitud e is less than some small	* \remarks A quaternion \a q is considered to be null, if it's magnitud e is less than some small
	* value \a eps. */	* value \a eps. */

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	RayIntersectTraverser.h	RayIntersectTraverser.h

	skipping to change at line 433	skipping to change at line 433
	, unsigned int primitiveIndex //!< I ndex of the intersected primitive	, unsigned int primitiveIndex //!< I ndex of the intersected primitive
	, const std::vector<unsigned int> & ve rtexIndices //!< Indices of the vertices of the intersected primitive	, const std::vector<unsigned int> & ve rtexIndices //!< Indices of the vertices of the intersected primitive
	);	);

	#if !defined(NDEBUG)	#if !defined(NDEBUG)
	/** Dump intersection map - for Debug*/	/** Dump intersection map - for Debug*/
	NVSG_API void dumpIntersectionList();	NVSG_API void dumpIntersectionList();
	#endif	#endif

	private:	private:

	bool equal( nvmath::Vec3f v0, nvmath::Vec3f v1 ) const;	bool equal( nvmath::Vec3f v0, nvmath::Vec3f v1, float width ) const;
	bool lookForLineAttribute( const nvsg::StateSet *ss );	bool lookForLineAttribute( const nvsg::StateSet *ss );
	bool lookForPointAttribute( const nvsg::StateSet *ss );	bool lookForPointAttribute( const nvsg::StateSet *ss );

	static const nvmath::Vec3f _RAY_ORIGIN_DEFAULT; //!< Default value : (0.f, 0.f, 0.f)	static const nvmath::Vec3f _RAY_ORIGIN_DEFAULT; //!< Default value : (0.f, 0.f, 0.f)
	static const nvmath::Vec3f _RAY_DIRECTION_DEFAULT; //!< Default value : (0.f, 0.f, -1.f)	static const nvmath::Vec3f _RAY_DIRECTION_DEFAULT; //!< Default value : (0.f, 0.f, -1.f)

	bool m_backFaceCulling; //!< true: consider b ackface culling	bool m_backFaceCulling; //!< true: consider b ackface culling
	bool m_camClipping; //!< true: use camera far/near clipping planes	bool m_camClipping; //!< true: use camera far/near clipping planes

	std::stack<std::vector<nvutil::SmartPtr<nvsg::ClipPlaneHandle> > > m_ clipPlanes; //!< vector of active clip planes	std::stack<std::vector<nvutil::SmartPtr<nvsg::ClipPlaneHandle> > > m_ clipPlanes; //!< vector of active clip planes

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	TransformManipulator.h	TransformManipulator.h

	skipping to change at line 57	skipping to change at line 57
	{	{
	NVSG_PAN = 0, /!< Addresses input mask for a pan ope ration. /	NVSG_PAN = 0, /!< Addresses input mask for a pan ope ration. /
	NVSG_DOLLY, /!< Addresses input mask for a dolly o peration. /	NVSG_DOLLY, /!< Addresses input mask for a dolly o peration. /
	NVSG_ROTATE, /!< Addresses input mask for a xy-rota te operation. /	NVSG_ROTATE, /!< Addresses input mask for a xy-rota te operation. /
	NVSG_SCALE, /!< Addresses input mask for a scale o peration. /	NVSG_SCALE, /!< Addresses input mask for a scale o peration. /
	NVSG_LOCK_AXIS, /!< Addresses input mask for a lock ax is operation. /	NVSG_LOCK_AXIS, /!< Addresses input mask for a lock ax is operation. /
	NVSG_RESERVE0, /!< Reserved for future extension. /	NVSG_RESERVE0, /!< Reserved for future extension. /
	NVSG_RESERVE1, /!< Reserved for future extension. /	NVSG_RESERVE1, /!< Reserved for future extension. /
	NVSG_RESERVE2, /!< Reserved for future extension. /	NVSG_RESERVE2, /!< Reserved for future extension. /
	NVSG_RESERVE3, /!< Reserved for future extension. /	NVSG_RESERVE3, /!< Reserved for future extension. /

	NVSK_CUSTOM_OPERATION_0, /*!< Reserved to address a custom opera	NVSG_CUSTOM_OPERATION_0, /*!< Reserved to address a custom opera
	tion. */	tion. */
	NVSK_CUSTOM_OPERATION_1, /*!< Reserved to address a custom opera	NVSG_CUSTOM_OPERATION_1, /*!< Reserved to address a custom opera
	tion. */	tion. */
	NVSK_CUSTOM_OPERATION_2, /*!< Reserved to address a custom opera	NVSG_CUSTOM_OPERATION_2, /*!< Reserved to address a custom opera
	tion. */	tion. */
	NVSK_CUSTOM_OPERATION_3, /*!< Reserved to address a custom opera	NVSG_CUSTOM_OPERATION_3, /*!< Reserved to address a custom opera
	tion. */	tion. */
	NVSK_CUSTOM_OPERATION_4, /*!< Reserved to address a custom opera	NVSG_CUSTOM_OPERATION_4, /*!< Reserved to address a custom opera
	tion. */	tion. */
	NVSK_CUSTOM_OPERATION_5, /*!< Reserved to address a custom opera	NVSG_CUSTOM_OPERATION_5, /*!< Reserved to address a custom opera
	tion. */	tion. */
	NVSK_CUSTOM_OPERATION_6, /*!< Reserved to address a custom opera	NVSG_CUSTOM_OPERATION_6, /*!< Reserved to address a custom opera
	tion. */	tion. */
	NVSK_CUSTOM_OPERATION_7, /*!< Reserved to address a custom opera	NVSG_CUSTOM_OPERATION_7, /*!< Reserved to address a custom opera
	tion. */	tion. */
	NVSK_CUSTOM_OPERATION_8, /*!< Reserved to address a custom opera	NVSG_CUSTOM_OPERATION_8, /*!< Reserved to address a custom opera
	tion. */	tion. */
	NVSG_TRANSFORM_OPERATION_COUNT,	NVSG_TRANSFORM_OPERATION_COUNT,
	NVSG_NO_TRANSFORM_OPERATION	NVSG_NO_TRANSFORM_OPERATION
	};	};

	/*! \brief Default constructor.	/*! \brief Default constructor.
	* \remarks Initialize the TransformManipulator object.*/	* \remarks Initialize the TransformManipulator object.*/
	NVSG_API TransformManipulator();	NVSG_API TransformManipulator();

	/*! \brief Default destructor.	/*! \brief Default destructor.
	* \remarks The destructor takes care of decrementing the reference co unt of the	* \remarks The destructor takes care of decrementing the reference co unt of the

End of changes. 1 change blocks.
	18 lines changed or deleted	18 lines changed or added