PrevUpHomeNext

Client-side wrapper of the GL context

Client context settings
Blending
Buffer clearing
Buffer masking
Capabilities
Clip control
Computing
Depth test
Stencil test
Scissor test
Viewport
Drawing
Hints
Limit queries
Numeric queries
String queries
Logic operations
Pixel operations
Synchronization
Rasterization
Object binding

ClientContext

#include <oglplus/client_context.hpp>

The ClientContext class keeps local copies of most of the GL context state variable values and allows to query and manipulate them more efficiently. During construction an instance of ClientContext queries the values of all GL state variables, which are managed by it. When successfully constructed the members of this instance can be used to obtain the cached value without actually querying GL. Furthermore the values can also be modified and pushed and subsequently popped from a stack. The modification operations compare the new value with the current and call to the functions from the GL API which change the GL state are made only if they are different. The stack functionality allows to temporarily change the value of a GL context setting and restore the previous value later.

[Note] Note

In order to function properly, the use of ClientContext should not be mixed with direct or indirect (through Context) calls to the GL API changing the GL state, because this would cause the internal state of ClientContext to go out of sync. This also means that in order to manage the state of a single GL context only a single instance of ClientContext should be used. 

class ClientContext
 : public client::CapabilityState
 , public client::ViewportState
 , public client::ClipControlState
 , public client::BufferMaskingState
 , public client::BufferClearingOps
 , public client::BufferClearingState
 , public client::RasterizationState
 , public client::RasterizationOps
 , public client::DrawingState
 , public client::DrawingOps
 , public client::ComputingOps
 , public client::DepthTestState
 , public client::StencilTestState
 , public client::ScissorTestState
 , public client::LogicOpState
 , public client::PixelState
 , public client::PixelOps
 , public client::BlendingOps
 , public client::BlendingState
 , public client::Synchronization
 , public client::HintState
 , public client::LimitQueries
 , public client::NumericQueries
 , public client::StringQueries
 , public client::CurrentObjects
{ };

Examples of usage 

ClientContext gl; 1


gl.ClearColor.Set(0.3f, 0.3f, 0.3f, 0.0f);
gl.ClearDepth.Set(1.0f);
gl.Caps.DepthTest.Disable();
gl.Caps.Blend.Enable();
gl.BlendFunc.Set(BlendFunction::SrcAlpha, BlendFunction::OneMinusSrcAlpha);

gl.LineWidth.Set(1.5f);

gl.Viewport.Set(800, 600);

gl.Clear().ColorBuffer().DepthBuffer().StencilBuffer();

Program prog;
VertexArray vao;

/* ... */

gl.Program.Bind(prog); 2
gl.VertexArray.Bind(vao); 3

{
	auto no_blend = gl.Caps.Blend.Push(false); 4
	auto no_depth = gl.Caps.DepthTest.Push(false);

	gl.DrawArrays(PrimitiveType::TriangleStrip, 0, n);

	assert(no_depth); 5
	no_depth.Pop(); 6
	assert(!no_depth); 7

	gl.DrawArrays(PrimitiveType::TriangleStrip, 0, n);
} 8


gl.DrawElements(PrimitiveType::TriangleStrip, m, DataType::UnsignedInt);

1

Stateful (caching) wrapper for a GL context. During the construction of this instance the values of current GL context variables are queried and stored internally.

2

When using ClientContext, then Program::Use must not be used and programs must be made current this way, in order to keep the client context in a consistent state.

3

Likewise, other objects bound to their binding points, must be bound through the client context wrapper, not by Object::Bind.

4

Push a new value false (= disabled) for Capability::Blend. The previous setting (whatever it was) remains stored on the stack and GL is updated only if the new setting is different from the currently specified. Note that for this to work, the result of Push must be stored in a named variable.

5

The setting holders returned by Push, can be tested if they still hold the pushed value.

6

Explicitly pop the pushed setting of Capability::DepthTest and restored the previous one (actually call GL only if they differ).

7

After the value in the holder has been popped conversion to bool returns false and must not be popped again.

8

When the no_blend instance goes out of scope and is destroyed, then the setting is automatically popped from the stack.

Client context settings

#include <oglplus/client/setting.hpp>

Setting holder

Instances of SettingHolder are created by various instantiations of SettingStack when a new value is pushed on top of the stack. The purpose of a setting holder is to keep that value on top of the stack. While an instance of SettingHolder is alive, then the associated value is kept on the stack. Once the holder is destroyed, the associated value is popped from the stack an the previous GL context setting is restored (to the next value on the stack). The values can also be popped (once) explicitly by calling the Pop member function.

OGLplus library client applications should never need to instantiate SettingHolder directly. Either use the auto keyword or the typedefs in SettingStack. 

namespace client {

template <typename T, ...>
class SettingHolder
{
public:
	SettingHolder(const SettingHolder&) = delete;

	SettingHolder(SettingHolder&&)
	noexcept;

	~SettingHolder(void) 1
	noexcept;

	void Pop(void) 2
	noexcept;

	explicit
	operator bool (void) const 3
	noexcept;
};

} // namespace client

1

Implicitly pops the value which this holder keeps from the setting stack which created this instance of Holder.

2

Explicitly pops the value which this holder keeps from the setting stack which created this instance of Holder. This function can be only called if the value has not been popped yet.

3

Returns true if the setting has not been popped yet, returns false otherwise.

Setting stack

Instances of SettingStack are used to maintain and manage the the values of a single particular GL context setting. In the constructor they query the initial value of the managed setting and push it on top of the stack. The user can then repeatedly query the values (without actually querying GL state) by the Set member functions, change the value of the setting (both locally and in the GL context if necessary) by calling the Set member functions, Push new values on top of the stack while keeping the previous ones (and changing the GL context if necessary) and finally to Pop the values from the stack either implicitly or explicitly (and updating the GL context accordingly).

OGLplus library client applications should never need to instantiate SettingStack directly. The (direct or indirect) members of ClientContext should be used. 

namespace client {

template <typename T, ...>
class SettingStack
{
public:
	SettingStack(const SettingStack&) = delete;

	SettingStack(void); 1

	typedef SettingHolder<T, ...> Holder;

	SettingStack& operator [] (Index index);
	SettingStack& Indexed(Index index); 2

	Holder Push(T value); 3

	template <typename ... A>
	Holder Push(A&& ... a); 4

	T Get(void) const 5
	noexcept;

	void Set(T value); 6

	template <typename ... A>
	void Set(A&& ... a); 7
};

} // namespace client

1

Queries the current value of the setting that this stack manages and pushes it on itself as the first element.

2

Returns a reference to itself if index is zero, otherwise the behavior is undefined. This function and the indexing operator are here to make the interface of SettingStack compatible with SettingStackIndexed.

3

Pushes a new value on top of the setting stack. When the returned instance of Holder gets destroyed (or its Pop member function is called explicitly) then this value is popped from the stack. Storing the returned instance keeps the value on the stack. Care must be taken to destroy the instances of Holder in the reverse of the order in which they were created. This can be easily achieved by storing the holders in local variables.

4

This overload of Push constructs a new instance of T from the specified arguments and pushes it on the stack.

5

Returns the value of the setting on the top of this setting stack.

6

Changes the current setting value without pushing on the stack.

7

This overload of Set changes the value by constructing a new instance of T from the specified arguments.

Indexed setting stack

Instances of SettingStackIndexed are used to manage the values of indexed GL context settings. They maintain a sequence of SettingStack instances, each for a single setting at a particular index. The individual setting stacks are accessed via the Indexed member function or the operator[]. The settings on the zero-th index can be also manipulated directly be calling the Push, Get and Set member functions which have the same semantics as in SettingStack.

OGLplus library client applications should never need to instantiate SettingStack directly. The (direct or indirect) members of ClientContext should be used. 

namespace client {

template <typename Derived, typename T, typename Index = GLuint>
class SettingStackIndexed
{
public:
	SettingStackIndexed(const SettingStackIndexed&) = delete;

	SettingStackIndexed(void); 1

	Derived& operator [] (Index index);
	Derived& Indexed(Index index); 2

	typedef SettingHolder<T, GLuint> Holder;

	Holder Push(T value); 3

	template <typename ... A>
	Holder Push(A&& ... a);

	T Get(void) const 4
	noexcept;

	void Set(T value); 5

	template <typename ... A>
	void Set(A&& ... a);
};

} // namespace client

1

Initialized the SettingStack on index zero.

2

Returns a reference to the setting stack at the specified index. The value of index should not exceed the maximum value for the managed indexed setting.

3

Pushes a new value on the stack at index zero.

4

Gets the value from the stack at index zero.

5

Sets a new value on the stack at index zero.

Blending

#include <oglplus/client/blending.hpp>

Operations 
namespace client {

using oglplus::context::BlendingOps;

} // namespace client
State 
namespace client {

class BlendingState
{
public:
	SettingStackIndexed<
		SettingStack<context::BlendEquationSeparate, ...>,
		context::BlendEquationSeparate,
		DrawBufferIndex
	> BlendEquation; 1

	SettingStackIndexed<
		SettingStack<context::BlendFunctionSeparate, ...>,
		context::BlendFunctionSeparate,
		DrawBufferIndex
	> BlendEquation; 2

	SettingStack<context::RGBAValue, ...> BlendColor; 3
};

} // namespace client

1

Indexed set of stacks managing the blend equations for the individual draw buffers.

2

Indexed set of stacks managing the blend functions for the individual draw buffers.

3

Stack managing the setting of blend color.

Buffer clearing

#include <oglplus/client/buffer_clearing.hpp>

Operations 
namespace client {

using oglplus::context::BufferClearingOps;

} // namespace client
State 
namespace client {

class BufferClearingState
{
public:
	SettingStack<context::RGBAValue, ...> ClearColor; 1

	SettingStack<GLfloat, ...> ClearDepth; 2

	SettingStack<GLint, ...> ClearStencil; 3
};

} // namespace client

1

Stack managing the setting of clear color.

2

Stack managing the setting of clear depth value.

3

Stack managing the setting of clear stencil value.

Buffer masking

#include <oglplus/client/buffer_masking.hpp>

State 
namespace client {

class BufferMaskingState
{
public:
	SettingStackIndexed<
		SettingStack<context::RGBAMask, ...>,
		context::RGBAMask,
		DrawBufferIndex
	> ColorMask; 1

	SettingStack<Boolean, ...> DepthMask; 2

private:
	template <SingleFace Value>
	class StencilMaskStack 3
	 : SettingStack<Boolean, ...>
	{ };
public:

	enums::EnumToClass<
		Nothing,
		SingleFace,
		StencilMaskStack
	> StencilMask; 4
};

} // namespace client

1

Stack managing the setting of color channel mask.

2

Stack managing the setting of depth mask.

3

This class template is here for documentation purposes only and is not part of the public interface.

4

Stacks managing the setting of stencil mask separatelly for the front and the back face.

Capabilities

#include <oglplus/client/capabilities.hpp>

State 
namespace client {

class CapabilityState
{
private:
	template <Capability Value>
	class CurrentCapabilityIndexed 1
	 : SettingStack<Boolean, ...>
	{
	public:
		Boolean IsEnabled(void) const 2
		noexcept;

		explicit
		operator Boolean (void) const 3
		noexcept;

		void Enable(Boolean status = true); 4

		void Disable(void); 5
	};

	template <Capability Value>
	class CurrentCapability 6
	 : SettingStackIndexed<CurrentCapabilityIndexed<Value>, Boolean>
	{
	public:
		Boolean IsEnabled(void) const
		noexcept;

		explicit
		operator Boolean (void) const
		noexcept;

		void Enable(Boolean status = true);

		void Disable(void);
	};
public:

	enums::EnumToClass<
		Nothing,
		Capability,
		CurrentCapability
	> Caps; 7
};

} // namespace client

1

This class template is here for documentation purposes only and is not part of the public interface.

2

Checks if the capability is currently enabled (true) or disabled (false).

3

Checks if the capability is currently enabled (true) or disabled (false).

4

Enables (by default) or sets the capability to the specified status.

5

Disables the capability.

6

This class template is here for documentation purposes only and is not part of the public interface.

7

Stacks managing the state (enabled or disabled) individually for each capability in the Capability enumeration.

Clip control

#include <oglplus/client/clip_control.hpp>

State 
namespace client {

class ClipControlState
{
public:
	SettingStack<context::ClipControlParams, ...> ClipControl; 1
};

} // namespace client

1

Stack managing the setting of clipping control parameters

Computing

#include <oglplus/client/computing.hpp>

Operations 
namespace client {

using oglplus::context::ComputingOps;

} // namespace client

Depth test

#include <oglplus/client/depth_test.hpp>

State 
namespace client {

class DepthTestState
{
public:
	SettingStack<CompareFunction, ...> DepthFunc; 1
};

} // namespace client

1

Stack managing the setting of depth compare function.

Stencil test

#include <oglplus/client/stencil_test.hpp>

State 
namespace client {

class StencilTestState
{
private:
	template <SingleFace Value>
	class StencilFuncStack 1
	 : SettingStack<context::StencilFuncArgs, ...>
	{ };
public:
	enums::EnumToClass<
		Nothing,
		SingleFace,
		StencilFuncStack
	> StencilFunc; 2

private:
	template <SingleFace Value>
	class StencilOpStack 3
	 : SettingStack<context::StencilOperations, ...>
	{ };
public:
	enums::EnumToClass<
		Nothing,
		SingleFace,
		StencilOpStack
	> StencilOp; 4
};

} // namespace client

1

This class template is here for documentation purposes only and is not part of the public interface.

2

Stack managing the setting of stencil function arguments.

3

This class template is here for documentation purposes only and is not part of the public interface.

4

Stack managing the setting of stencil operations.

Scissor test

#include <oglplus/client/scissor_test.hpp>

State 
namespace client {

class ScissorTestState
{
	SettingStackIndexed<
		SettingStack<context::ScissorRectangle, ...>,
		context::ScissorRectangle,
		ViewportIndex
	> Scissor; 1
};

} // namespace client

1

Indexed set of stacks managing the scissor rectangles for the individual viewports.

Viewport

#include <oglplus/client/viewport.hpp>

State 
namespace client {

class ViewportState
{
	SettingStackIndexed<
		SettingStack<context::ViewportExtents, ...>,
		context::ViewportExtents,
		ViewportIndex
	> Viewport; 1

	SettingStackIndexed<
		SettingStack<context::ViewportDepthRange, ...>,
		context::ViewportDepthRange,
		ViewportIndex
	> DepthRange; 2
};

} // namespace client

1

Indexed set of stacks managing the extents for individual viewports.

2

Indexed set of stacks managing the depth ranges for individual viewports.

Drawing

#include <oglplus/client/drawing.hpp>

Operations 
namespace client {

using oglplus::context::DrawingOps;

} // namespace client
State 
namespace client {

class DrawingState
{
public:
	SettingStack<GLint, ...> PrimitiveRestartIndex; 1
};

} // namespace client

1

Stack managing the setting of primitive restart index.

Hints

#include <oglplus/client/hint.hpp>

State 
namespace client {

class HintState
{
private:
	template <HintTarget Value>
	class Hint 1
	 : SettingStack<HintOption, ...>
	{ };
public:

	enums::EnumToClass<
		Nothing,
		HintTarget,
		Hint
	> Hints; 2
};

} // namespace client

1

This class template is here for documentation purposes only and is not part of the public interface.

2

Set of stacks managing the setting of HintOption settings individually for each value in the HintTarget enumeration.

Limit queries

#include <oglplus/client/limit_queries.hpp> 

namespace client {

class LimitQueries
{
private:
	template <LimitQuery Limit>
	class LimitGetter 1
	{
	public:
		typedef	<Unspecified> value_type; 2

		static value_type Get(void); 3

		static value_type Get(GLuint index); 4

		operator value_type(void) const; 5
	};
public:
	enums::EnumToClass<
		Nothing,
		LimitQuery,
		LimitGetter
	> Limits; 6
};

} // namespace client

1

This class template is here for documentation purposes only and is not part of the public interface.

2

The type of the value associated with the Limit.

3

Returns the value of the Limit.

4

Returns the value of the Limit if this particular LimitQuery is indexed.

5

Returns the value of the Limit.

6

Set of classes with static member functions which allow to get the values of various limits.

Numeric queries

#include <oglplus/client/numeric_queries.hpp> 

namespace client {

using oglplus::context::NumericQueries;

} // namespace client

String queries

#include <oglplus/client/string_queries.hpp> 

namespace client {

using oglplus::context::StringQueries;

} // namespace client

Logic operations

#include <oglplus/client/logic_ops.hpp>

State 
namespace client {

class LogicOpState
{
public:
	SettingStack<ColorLogicOperation, ...> LogicOp; 1
};

} // namespace client

1

Stack managing the setting of color logic operation.

Pixel operations

#include <oglplus/client/pixel_ops.hpp>

Operations 
namespace client {

using oglplus::context::PixelOps;

} // namespace client
State 
namespace client {

class PixelState
{
private:
	template <PixelParameter Parameter>
	class PixelParams 1
	 : SettingStack<<Unspecified>, ...> 2
	{ };
public:
	enums::EnumToClass<
		Nothing,
		PixelParameter,
		PixelParams
	> PixelStore; 3
};

} // namespace client

1

This class template is here for documentation purposes only and is not part of the public interface.

2

Stack of numeric values (booleans, integers, floats) appropriate for the pixel Parameter type.

3

Set of stacks managing the setting of numeric pixel parameters individually for each value in the PixelParameter enumeration.

Synchronization

#include <oglplus/client/synchronization.hpp> 

namespace client {

using oglplus::context::Synchronization;

} // namespace client

Rasterization

#include <oglplus/client/rasterization.hpp>

Operations 
namespace client {

using oglplus::context::RasterizationOps;

} // namespace client
State 
namespace client {

class RasterizationState
{
public:
	SettingStack<FaceOrientation, ...> FrontFace; 1

	SettingStack<Face, ...> CullFace; 2

	SettingStack<PolygonMode, ...> PolygonMode; 3

	SettingStack<context::PolygonOffsPara, ...> PolygonOffset; 4

#if GL_VERSION_3_2 || GL_ARB_provoking_vertex
	SettingStack<ProvokeMode, ...> ProvokingVertex; 5
#endif

	SettingStack<GLfloat, ...> LineWidth; 6
	SettingStack<GLfloat, ...> PointSize; 7
	SettingStack<GLfloat, ...> PointFadeThresholdSize; 8

#if GL_VERSION_4_0
	SettingStack<GLfloat, ...> MinSampleShading; 9
#endif

#if GL_NV_fragment_coverage_to_color
	SettingStack<FragDataSlot, ...> FragmentCoverageColor; 10

#endif
};

} // namespace client

1

Stack managing the setting of the front face orientation.

2

Stack managing the setting of cull face.

3

Stack managing the setting of polygon rasterization mode.

4

Stack managing the setting of polygon offset parameters.

5

Stack managing the setting of provoking vertex mode.

6

Stack managing the setting of line width value.

7

Stack managing the setting of point size value.

8

Stack managing the setting of point fade threshold size value.

9

Stack managing the setting of the minimal sample shading value.

10

Stack managing the setting of the draw buffer used for fragment coverage to color.

Object binding

#include <oglplus/client/object_binding.hpp> 

namespace client {

class CurrentObjects
{
private: 1
	template <typename ObjTag>
	struct CurrentObject
	{
		template <typename ObjBindingOps<ObjTag>::Target ObjTarget>
		class WithTarget
		 : public SettingStack<GLuint, ...> 2
		 , public BoundObjOps<ObjTag> 3
		{
		public:
			WithTarget(void);

			ObjectName<ObjTag> Get(void) const 4
			noexcept;

			operator ObjectName<ObjTag> (void) const
			noexcept;

			typedef SettingHolder<GLuint, ...> Holder;

			Holder Push(ObjectName<ObjTag> obj); 5

			void Bind(ObjectName<ObjTag> obj); 6
		};
	};

	template <typename ObjTag>
	class CurrentObjectsWithTarget 7
	 : public enums::EnumToClass<
		Nothing,
		typename ObjBindingOps<ObjTag>::Target,
		CurrentObject<ObjTag>::template WithTarget
	>
	{ };
public:
	CurrentObjectsWithTarget<tag::Framebuffer> Framebuffer;
	CurrentObjectsWithTarget<tag::Renderbuffer> Renderbuffer;
	CurrentObjectsWithTarget<tag::TransformFeedback> TransformFeedback;
	CurrentObjectsWithTarget<tag::Buffer> Buffer;

1

These private classes are here for documentation purposes only. Their public interface can be used in library client code, but the class names (as documented here) are not part of the public interface.

2

Stack of unwrapped object names.

3

This class has the same interface as BoundObjOps for the objecgt type specified by ObjTag.

4

Returns the current object binding.

5

Unwraps the object name, binds it to ObjTarget and pushes it onto the stack.

6

Unwraps the object name, binds it to ObjTarget and calls SettingStack::Set.

7

Set of stacks of objects names the top of which is currently bound to a named binding point. 

private: 1
	class BufferNameAndRange
	{
	public:
		BufferName Buffer(void) const;

		bool BoundRange(void) const; 2

		BufferSize Offset(void) const; 3
		BufferSize Size(void) const;
	};

	template <BufferIndexedTarget BufTarget>
	class CurrentIndexBuffers 4
	 : public SettingStack<BufferNameAndRange, ...>
	{
	public:
		CurrentIndexBuffers(GLuint index);

		BufferNameAndRange Get(void) const; 5
		noexcept;

		operator BufferNameAndRange (void) const
		noexcept;

		typedef SettingHolder<BufferNameAndRange, ...> Holder;

		Holder Push(BufferName obj); 6

		Holder Push(BufferName obj, BufferSize offset, BufferSize size); 7

		void BindBase(BufferName obj); 8

		void BindRange(BufferName obj, BufferSize offset, BufferSize size); 9

	};

	template <BufferIndexedTarget BufTarget>
	class CurrentIndexedTargetBuffers 10
	{
	public:
		CurrentIndexBuffers<BufTarget>& Index(GLuint index); 11
		CurrentIndexBuffers<BufTarget>& operator [] (GLuint index);
	};
public:
	typedef enums::EnumToClass<
		Nothing,
		BufferIndexedTarget,
		CurrentIndexedTargetBuffers
	> BufferIndexed;

1

These private classes are here for documentation purposes only. Their public interface can be used in library client code, but the class names (as documented here) are not part of the public interface.

2

Indicates whether just a subrange of the buffer (true), or the whole buffer (false) is bound.

3

These functions return meaningful values only if BoundRange returns true.

4

Stack of buffer names the top of which is currently bound to the specified BufferIndexedTarget with a particular index.

5

Returns the current indexed buffer binding.

6

Unwraps the buffer name, binds it to indexed BufTarget and pushes it onto the stack.

7

Unwraps the buffer name, binds the specified range to indexed BufTarget and pushes it onto the stack.

8

Unwraps the buffer name, binds it to indexed BufTarget and calls SettingStack::Set.

9

Unwraps the buffer name, binds the specified range to indexed BufTarget and calls SettingStack::Set.

10

Set of stacks managing the buffers bound to the indvidual indices of the specified BufferIndexedTarget.

11

Returns the stack managing objects bound to the specified index of a BufferIndexedTarget. 

private: 1
	template <typename ObjTag>
	class CurrentObjectWithoutTarget 2
	 : public SettingStack<GLuint, ...>
	{
	public:
		CurrentObjectWithoutTarget(void);

		ObjectName<ObjTag> Get(void) const
		noexcept;

		operator ObjectName<ObjTag> (void) const
		noexcept;

		typedef SettingHolder<GLuint, ...> Holder;

		Holder Push(ObjectName<ObjTag> obj); 3

		void Bind(ObjectName<ObjTag> obj); 4

	};
public:
	CurrentObjectWithoutTarget<tag::Program> Program;
	CurrentObjectWithoutTarget<tag::ProgramPipeline> ProgramPipeline;
	CurrentObjectWithoutTarget<tag::VertexArray> VertexArray;

1

These private classes are here for documentation purposes only. Their public interface can be used in library client code, but the class names (as documented here) are not part of the public interface.

2

Stack of objects the top of which is currently bound to an implicit binding point.

3

Unwraps the object name, binds it to the implicit binding point and pushes it onto the stack.

4

Unwraps the object name, binds it to the implicit binding point and calls SettingStack::Set. 

private: 1
	template <TextureTarget TexTarget>
	class CurrentUnitTexture 2
	 : public SettingStack<GLuint, ...>
	{
		CurrentUnitTexture(TextureUnitSelector tex_unit);

		TextureName Get(void) const
		noexcept;

		operator TextureName (void) const
		noexcept;

		typedef SettingHolder<GLuint, ...> Holder;

		Holder Push(TextureName tex); 3

		void Bind(TextureName tex); 4
	};

	class CurrentTextures 5
	{
	private:
		typedef enums::EnumToClass<
			TextureUnitSelector,
			TextureTarget,
			CurrentUnitTexture
		> CurrentUnitTextures;
	public:
		CurrentUnitTextures& Unit(TextureUnitSelector index); 6
		CurrentUnitTextures& operator [] (TextureUnitSelector index);
	};
public:
	CurrentTextures Texture;

1

These private classes are here for documentation purposes only. Their public interface can be used in library client code, but the class names (as documented here) are not part of the public interface.

2

Stack of texture names the top of which is currently bound to the specified TexTarget.

3

Unwraps the texture name, binds it to TexTarget and pushes it onto the stack.

4

Unwraps the texture name, binds it to TexTarget and calls SettingStack::Set.

5

Set of stacks (each for a particular texture unit) managing the binding of textures to binding points.

6

Returns a reference to the stack of texture bindings on the texture unit at the specified index.

Copyright © 2008-2015 Matúš Chochlík

Distributed under the Boost Software License, Version 1.0. See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt

PrevUpHomeNext