Renaming some GL classes

include/anki/Gl.h

@@ -26,10 +26,10 @@
 
 #include "anki/gl/GlBufferHandle.h"
 #include "anki/gl/GlTextureHandle.h"
-#include "anki/gl/GlProgramHandle.h"
+#include "anki/gl/GlShaderHandle.h"
 
 #include "anki/gl/GlFramebufferHandle.h"
-#include "anki/gl/GlProgramPipelineHandle.h"
+#include "anki/gl/GlPipelineHandle.h"
 
 #include "anki/gl/GlCommandBufferHandle.h"
 #include "anki/gl/GlDevice.h"

include/anki/gl/GlCommon.h

@@ -33,7 +33,7 @@
 namespace anki {
 
 // Forward
-class GlProgram;
+class GlShader;
 class GlProgramBlock;
 
 /// @addtogroup opengl_private
@@ -95,7 +95,7 @@ ANKI_ENUM_ALLOW_NUMERIC_OPERATIONS(ShaderType, inline)
 /// Shader program variable. The type is attribute or uniform
 class GlProgramVariable
 {
-	friend class GlProgram;
+	friend class GlShader;
 
 public:
 	/// Shader program variable type
@@ -170,7 +170,7 @@ public:
 
 private:
 	Type m_type; ///< It's type
-	GlProgram* m_prog = nullptr;
+	GlShader* m_prog = nullptr;
 	char* m_name; ///< The name inside the shader program
 
 	GLenum m_dataType = GL_NONE; ///< GL_FLOAT or GL_FLOAT_VEC2 etc.
@@ -214,7 +214,7 @@ private:
 /// Interface shader block
 class GlProgramBlock
 {
-	friend class GlProgram;
+	friend class GlShader;
 
 public:
 	static const U32 MAX_VARIABLES_PER_BLOCK = 16;

include/anki/gl/GlProgramPipeline.h → include/anki/gl/GlPipeline.h

@@ -3,11 +3,11 @@
 // Code licensed under the BSD License.
 // http://www.anki3d.org/LICENSE
 
-#ifndef ANKI_GL_GL_PROGRAM_PIPELINE_H
-#define ANKI_GL_GL_PROGRAM_PIPELINE_H
+#ifndef ANKI_GL_GL_PIPELINE_H
+#define ANKI_GL_GL_PIPELINE_H
 
 #include "anki/gl/GlObject.h"
-#include "anki/gl/GlProgramHandle.h"
+#include "anki/gl/GlShaderHandle.h"
 
 namespace anki {
 
@@ -15,35 +15,35 @@ namespace anki {
 /// @{
 
 /// Program pipeline
-class GlProgramPipeline: public GlObject
+class GlPipeline: public GlObject
 {
 public:
 	using Base = GlObject;
 
-	GlProgramPipeline() = default;
+	GlPipeline() = default;
 
-	~GlProgramPipeline()
+	~GlPipeline()
 	{
 		destroy();
 	}
 
 	ANKI_USE_RESULT Error create(
-		const GlProgramHandle* progsBegin, const GlProgramHandle* progsEnd,
+		const GlShaderHandle* progsBegin, const GlShaderHandle* progsEnd,
 		GlAllocator<U8> alloc);
 
-	GlProgramHandle getAttachedProgram(GLenum type) const;
+	GlShaderHandle getAttachedProgram(GLenum type) const;
 
 	/// Bind the pipeline to the state
 	void bind();
 
 private:
-	Array<GlProgramHandle, 6> m_progs;
+	Array<GlShaderHandle, 6> m_shaders;
 
 	/// Create pipeline object
 	void createPpline();
 
 	/// Attach all the programs
-	void attachProgramsInternal(const GlProgramHandle* progs, PtrSize count);
+	void attachProgramsInternal(const GlShaderHandle* progs, PtrSize count);
 
 	void destroy();
 };

include/anki/gl/GlProgramPipelineHandle.h → include/anki/gl/GlPipelineHandle.h

@@ -3,8 +3,8 @@
 // Code licensed under the BSD License.
 // http://www.anki3d.org/LICENSE
 
-#ifndef ANKI_GL_GL_PROGRAM_PIPELINE_HANDLE_H
-#define ANKI_GL_GL_PROGRAM_PIPELINE_HANDLE_H
+#ifndef ANKI_GL_GL_PIPELINE_HANDLE_H
+#define ANKI_GL_GL_PIPELINE_HANDLE_H
 
 #include "anki/gl/GlContainerHandle.h"
 
@@ -12,26 +12,26 @@ namespace anki {
 
 // Forward
 class GlCommandBufferHandle;
-class GlProgramPipeline;
-class GlProgramHandle;
+class GlPipeline;
+class GlShaderHandle;
 
 /// @addtogroup opengl_other
 /// @{
 
 /// Program pipeline handle
-class GlProgramPipelineHandle: public GlContainerHandle<GlProgramPipeline>
+class GlPipelineHandle: public GlContainerHandle<GlPipeline>
 {
 public:
-	using Base = GlContainerHandle<GlProgramPipeline>;
+	using Base = GlContainerHandle<GlPipeline>;
 
-	GlProgramPipelineHandle();
+	GlPipelineHandle();
 
-	~GlProgramPipelineHandle();
+	~GlPipelineHandle();
 
 	/// Create a pipeline
 	ANKI_USE_RESULT Error create(
 		GlCommandBufferHandle& commands,
-		const GlProgramHandle* progsBegin, const GlProgramHandle* progsEnd)
+		const GlShaderHandle* progsBegin, const GlShaderHandle* progsEnd)
 	{
 		return commonConstructor(commands, progsBegin, progsEnd);
 	}
@@ -39,17 +39,17 @@ public:
 	/// Create using initializer list
 	ANKI_USE_RESULT Error create(
 		GlCommandBufferHandle& commands,
-		std::initializer_list<GlProgramHandle> progs);
+		std::initializer_list<GlShaderHandle> progs);
 
 	/// Bind it to the state
 	void bind(GlCommandBufferHandle& commands);
 
 	/// Get an attached program. It may serialize
-	GlProgramHandle getAttachedProgram(GLenum type) const;
+	GlShaderHandle getAttachedProgram(GLenum type) const;
 
 public:
 	ANKI_USE_RESULT Error commonConstructor(GlCommandBufferHandle& commands,
-		const GlProgramHandle* progsBegin, const GlProgramHandle* progsEnd);
+		const GlShaderHandle* progsBegin, const GlShaderHandle* progsEnd);
 };
 
 /// @}

include/anki/gl/GlProgram.h → include/anki/gl/GlShader.h

@@ -3,8 +3,8 @@
 // Code licensed under the BSD License.
 // http://www.anki3d.org/LICENSE
 
-#ifndef ANKI_GL_GL_PROGRAM_H
-#define ANKI_GL_GL_PROGRAM_H
+#ifndef ANKI_GL_GL_SHADER_H
+#define ANKI_GL_GL_SHADER_H
 
 #include "anki/gl/GlObject.h"
 #include "anki/util/Dictionary.h"
@@ -12,15 +12,12 @@
 
 namespace anki {
 
-// Forward
-class GlProgram;
-
 /// @addtogroup opengl_private
 /// @{
 
 /// Shader program. It only contains a single shader and it can be combined 
 /// with other programs in a program pipiline.
-class GlProgram: public GlObject
+class GlShader: public GlObject
 {
 	friend class GlProgramVariable;
 	friend class GlProgramBlock;
@@ -31,14 +28,14 @@ public:
 	template<typename T>
 	using DArray = DArray<T, GlAllocator<T>>;
 
-	GlProgram() = default;
+	GlShader() = default;
 
-	~GlProgram()
+	~GlShader()
 	{
 		destroy();
 	}
 
-	/// Create the program
+	/// Create the shader.
 	/// @param shaderType The type of the shader in the program
 	/// @param source The shader's source
 	/// @param alloc The allocator to be used for internally
@@ -80,7 +77,7 @@ private:
 
 	void destroy();
 
-	/// Query the program for blocks
+	/// Query the shader for blocks
 	ANKI_USE_RESULT Error initBlocksOfType(GLenum programInterface, 
 		U count, U index, char*& namesPtr, U& namesLen);
 

include/anki/gl/GlProgramHandle.h → include/anki/gl/GlShaderHandle.h

@@ -3,31 +3,31 @@
 // Code licensed under the BSD License.
 // http://www.anki3d.org/LICENSE
 
-#ifndef ANKI_GL_GL_PROGRAM_HANDLE_H
-#define ANKI_GL_GL_PROGRAM_HANDLE_H
+#ifndef ANKI_GL_GL_SHADER_HANDLE_H
+#define ANKI_GL_GL_SHADER_HANDLE_H
 
 #include "anki/gl/GlContainerHandle.h"
 
 namespace anki {
 
 // Forward
-class GlProgram;
+class GlShader;
 class GlClientBufferHandle;
 
 /// @addtogroup opengl_containers
 /// @{
 
 /// Program handle
-class GlProgramHandle: public GlContainerHandle<GlProgram>
+class GlShaderHandle: public GlContainerHandle<GlShader>
 {
 public:
-	using Base = GlContainerHandle<GlProgram>;
+	using Base = GlContainerHandle<GlShader>;
 
-	GlProgramHandle();
+	GlShaderHandle();
 
-	~GlProgramHandle();
+	~GlShaderHandle();
 
-	/// Create program
+	/// Create shader program.
 	ANKI_USE_RESULT Error create(GlCommandBufferHandle& commands, 
 		GLenum shaderType, const GlClientBufferHandle& source);
 

include/anki/renderer/DebugDrawer.h

@@ -84,7 +84,7 @@ private:
 
 	ProgramResourcePointer m_frag;
 	ProgramResourcePointer m_vert;
-	GlProgramPipelineHandle m_ppline;
+	GlPipelineHandle m_ppline;
 	GlCommandBufferHandle m_jobs;
 
 	static const U MAX_POINTS_PER_DRAW = 256;

include/anki/renderer/Hdr.h

@@ -79,9 +79,9 @@ private:
 	ProgramResourcePointer m_hblurFrag;
 	ProgramResourcePointer m_vblurFrag;
 
-	GlProgramPipelineHandle m_tonePpline;
-	GlProgramPipelineHandle m_hblurPpline;
-	GlProgramPipelineHandle m_vblurPpline;
+	GlPipelineHandle m_tonePpline;
+	GlPipelineHandle m_hblurPpline;
+	GlPipelineHandle m_vblurPpline;
 
 	GlTextureHandle m_hblurRt; ///< pass0Fai with the horizontal blur FAI
 	GlTextureHandle m_vblurRt; ///< The final FAI

include/anki/renderer/Is.h

@@ -79,7 +79,7 @@ private:
 	// Light shaders
 	ProgramResourcePointer m_lightVert;
 	ProgramResourcePointer m_lightFrag;
-	GlProgramPipelineHandle m_lightPpline;
+	GlPipelineHandle m_lightPpline;
 
 	/// Shadow mapping
 	Sm m_sm;

include/anki/renderer/Lf.h

@@ -38,16 +38,16 @@ public:
 private:
 	// Pseudo flares
 	ProgramResourcePointer m_pseudoFrag;
-	GlProgramPipelineHandle m_pseudoPpline;
+	GlPipelineHandle m_pseudoPpline;
 
 	// Sprite billboards
 	ProgramResourcePointer m_realVert;
 	ProgramResourcePointer m_realFrag;
-	GlProgramPipelineHandle m_realPpline;
+	GlPipelineHandle m_realPpline;
 
 	// Final HDR blit
 	ProgramResourcePointer m_blitFrag;
-	GlProgramPipelineHandle m_blitPpline;
+	GlPipelineHandle m_blitPpline;
 
 	GlTextureHandle m_rt;
 	GlFramebufferHandle m_fb;

include/anki/renderer/MainRenderer.h

@@ -37,7 +37,7 @@ public:
 
 private:
 	ProgramResourcePointer m_blitFrag;
-	GlProgramPipelineHandle m_blitPpline;
+	GlPipelineHandle m_blitPpline;
 
 	/// Optimize job chain
 	Array<GlCommandBufferInitHints, JOB_CHAINS_COUNT> m_jobsInitHints; 

include/anki/renderer/Pps.h

@@ -96,7 +96,7 @@ private:
 
 	GlFramebufferHandle m_fb;
 	ProgramResourcePointer m_frag;
-	GlProgramPipelineHandle m_ppline;
+	GlPipelineHandle m_ppline;
 	GlTextureHandle m_rt;
 
 	Pps(Renderer* r);

include/anki/renderer/Renderer.h

@@ -172,7 +172,7 @@ public:
 		return m_tilesCount;
 	}
 
-	const GlProgramHandle& getDrawQuadVertexProgram() const
+	const GlShaderHandle& getDrawQuadVertexProgram() const
 	{
 		return m_drawQuadVert->getGlProgram();
 	}
@@ -216,7 +216,7 @@ public:
 	/// Create a pipeline object that has as a vertex shader the m_drawQuadVert
 	/// and the given fragment progam
 	ANKI_USE_RESULT Error createDrawQuadProgramPipeline(
-		GlProgramHandle frag, GlProgramPipelineHandle& ppline);
+		GlShaderHandle frag, GlPipelineHandle& ppline);
 
 	/// Init the renderer given an initialization class
 	/// @param initializer The initializer class

include/anki/renderer/RenderingPass.h

@@ -69,7 +69,7 @@ protected:
 		GlFramebufferHandle m_fb;
 		GlTextureHandle m_rt; 
 		ProgramResourcePointer m_frag;
-		GlProgramPipelineHandle m_ppline;
+		GlPipelineHandle m_ppline;
 	};
 
 	enum class DirectionEnum: U

include/anki/renderer/Ssao.h

@@ -37,9 +37,9 @@ private:
 	ProgramResourcePointer m_ssaoFrag;
 	ProgramResourcePointer m_hblurFrag;
 	ProgramResourcePointer m_vblurFrag;
-	GlProgramPipelineHandle m_ssaoPpline;
-	GlProgramPipelineHandle m_hblurPpline;
-	GlProgramPipelineHandle m_vblurPpline;
+	GlPipelineHandle m_ssaoPpline;
+	GlPipelineHandle m_hblurPpline;
+	GlPipelineHandle m_vblurPpline;
 	
 	Timestamp m_commonUboUpdateTimestamp = getGlobTimestamp();
 	GlBufferHandle m_uniformsBuff;

include/anki/renderer/Sslr.h

@@ -35,12 +35,12 @@ private:
 
 	// 1st pass
 	ProgramResourcePointer m_reflectionFrag;
-	GlProgramPipelineHandle m_reflectionPpline;
+	GlPipelineHandle m_reflectionPpline;
 	GlSamplerHandle m_depthMapSampler;
 
 	// 2nd pass: blit
 	ProgramResourcePointer m_blitFrag;
-	GlProgramPipelineHandle m_blitPpline;
+	GlPipelineHandle m_blitPpline;
 
 	Sslr(Renderer* r)
 	:	BlurringRenderingPass(r)

include/anki/renderer/Tiler.h

@@ -72,7 +72,7 @@ private:
 
 	/// Main shader program
 	ProgramResourcePointer m_frag;
-	GlProgramPipelineHandle m_ppline;
+	GlPipelineHandle m_ppline;
 
 	/// Used to check if the camera is changed and we need to update the planes
 	const Camera* m_prevCam = nullptr;

include/anki/resource/Material.h

@@ -331,7 +331,7 @@ public:
 	}
 
 	ANKI_USE_RESULT Error getProgramPipeline(
-		const RenderingKey& key, GlProgramPipelineHandle& out);
+		const RenderingKey& key, GlPipelineHandle& out);
 
 	/// Load a material file
 	ANKI_USE_RESULT Error load(
@@ -351,7 +351,7 @@ private:
 	Dictionary<MaterialVariable*> m_varDict;
 
 	ResourceDArray<ProgramResourcePointer> m_progs;
-	ResourceVector<GlProgramPipelineHandle> m_pplines;
+	ResourceVector<GlPipelineHandle> m_pplines;
 
 	U32 m_shaderBlockSize;
 

include/anki/resource/Model.h

@@ -68,7 +68,7 @@ public:
 	ANKI_USE_RESULT Error getRenderingDataSub(
 		const RenderingKey& key, 
 		GlCommandBufferHandle& vertJobs,
-		GlProgramPipelineHandle& ppline,
+		GlPipelineHandle& ppline,
 		const U8* subMeshIndicesArray, 
 		U32 subMeshIndicesCount,
 		Array<U32, ANKI_GL_MAX_SUB_DRAWCALLS>& indicesCountArray,
@@ -89,7 +89,7 @@ private:
 	/// Called by @a create multiple times to create and populate a single
 	/// vertex descriptor
 	static ANKI_USE_RESULT Error createVertexDesc(
-		const GlProgramHandle& prog,
+		const GlShaderHandle& prog,
 		const Mesh& mesh,
 		GlCommandBufferHandle& vertexJobs);
 

include/anki/resource/ProgramResource.h

@@ -24,9 +24,9 @@ public:
 	~ProgramResource()
 	{}
 
-	const GlProgramHandle& getGlProgram() const
+	const GlShaderHandle& getGlProgram() const
 	{
-		return m_prog;
+		return m_shader;
 	}
 
 	/// Resource load
@@ -55,7 +55,7 @@ public:
 		TempResourceString& out);
 
 private:
-	GlProgramHandle m_prog;
+	GlShaderHandle m_shader;
 }; 
 /// @}
 

src/gl/GlProgramPipeline.cpp → src/gl/GlPipeline.cpp

@@ -3,15 +3,15 @@
 // Code licensed under the BSD License.
 // http://www.anki3d.org/LICENSE
 
-#include "anki/gl/GlProgramPipeline.h"
-#include "anki/gl/GlProgram.h"
+#include "anki/gl/GlPipeline.h"
+#include "anki/gl/GlShader.h"
 #include "anki/util/Logger.h"
 
 namespace anki {
 
 //==============================================================================
-Error GlProgramPipeline::create(
-	const GlProgramHandle* progsBegin, const GlProgramHandle* progsEnd,
+Error GlPipeline::create(
+	const GlShaderHandle* progsBegin, const GlShaderHandle* progsEnd,
 	GlAllocator<U8> alloc)
 {
 	ANKI_ASSERT(progsBegin != nullptr && progsEnd != nullptr);
@@ -27,9 +27,9 @@ Error GlProgramPipeline::create(
 
 	glBindProgramPipeline(m_glName);
 
-	for(U i = 0; i < m_progs.size(); i++)
+	for(U i = 0; i < m_shaders.size(); i++)
 	{
-		GlProgramHandle& prog = m_progs[i];
+		GlShaderHandle& prog = m_shaders[i];
 
 		if(prog.isCreated())
 		{
@@ -73,7 +73,7 @@ Error GlProgramPipeline::create(
 }
 
 //==============================================================================
-void GlProgramPipeline::destroy()
+void GlPipeline::destroy()
 {
 	if(m_glName)
 	{
@@ -83,18 +83,18 @@ void GlProgramPipeline::destroy()
 }
 
 //==============================================================================
-void GlProgramPipeline::attachProgramsInternal(
-	const GlProgramHandle* progs, PtrSize count)
+void GlPipeline::attachProgramsInternal(
+	const GlShaderHandle* progs, PtrSize count)
 {
 	U mask = 0;
 	while(count-- != 0)
 	{
-		const GlProgramHandle& prog = progs[count];
+		const GlShaderHandle& prog = progs[count];
 		ShaderType type = computeShaderTypeIndex(prog._get().getType());
 		U idx = enumToType(type);
 
-		ANKI_ASSERT(!m_progs[idx].isCreated() && "Attaching the same");
-		m_progs[idx] = prog;
+		ANKI_ASSERT(!m_shaders[idx].isCreated() && "Attaching the same");
+		m_shaders[idx] = prog;
 		mask |= 1 << idx;
 	}
 
@@ -123,19 +123,19 @@ void GlProgramPipeline::attachProgramsInternal(
 }
 
 //==============================================================================
-void GlProgramPipeline::bind()
+void GlPipeline::bind()
 {
 	ANKI_ASSERT(isCreated());
 	glBindProgramPipeline(m_glName);
 }
 
 //==============================================================================
-GlProgramHandle GlProgramPipeline::getAttachedProgram(GLenum type) const
+GlShaderHandle GlPipeline::getAttachedProgram(GLenum type) const
 {
 	ANKI_ASSERT(isCreated());
 	ShaderType stype = computeShaderTypeIndex(type);
 	U idx = enumToType(stype);
-	GlProgramHandle prog = m_progs[idx];
+	GlShaderHandle prog = m_shaders[idx];
 	ANKI_ASSERT(prog.isCreated() && "Asking for non-created program");
 	return prog;
 }

src/gl/GlProgramPipelineHandle.cpp → src/gl/GlPipelineHandle.cpp

@@ -3,29 +3,29 @@
 // Code licensed under the BSD License.
 // http://www.anki3d.org/LICENSE
 
-#include "anki/gl/GlProgramPipelineHandle.h"
-#include "anki/gl/GlProgramPipeline.h"
+#include "anki/gl/GlPipelineHandle.h"
+#include "anki/gl/GlPipeline.h"
 #include "anki/gl/GlHandleDeferredDeleter.h"
 
 namespace anki {
 
 //==============================================================================
-GlProgramPipelineHandle::GlProgramPipelineHandle()
+GlPipelineHandle::GlPipelineHandle()
 {}
 
 //==============================================================================
-GlProgramPipelineHandle::~GlProgramPipelineHandle()
+GlPipelineHandle::~GlPipelineHandle()
 {}
 
 //==============================================================================
-Error GlProgramPipelineHandle::create(
+Error GlPipelineHandle::create(
 	GlCommandBufferHandle& commands,
-	std::initializer_list<GlProgramHandle> iprogs)
+	std::initializer_list<GlShaderHandle> iprogs)
 {
-	Array<GlProgramHandle, 6> progs;
+	Array<GlShaderHandle, 6> progs;
 
 	U count = 0;
-	for(GlProgramHandle prog : iprogs)
+	for(GlShaderHandle prog : iprogs)
 	{
 		progs[count++] = prog;
 	}
@@ -34,23 +34,23 @@ Error GlProgramPipelineHandle::create(
 }
 
 //==============================================================================
-Error GlProgramPipelineHandle::commonConstructor(
+Error GlPipelineHandle::commonConstructor(
 	GlCommandBufferHandle& commands,
-	const GlProgramHandle* progsBegin, const GlProgramHandle* progsEnd)
+	const GlShaderHandle* progsBegin, const GlShaderHandle* progsEnd)
 {
 	class Command: public GlCommand
 	{
 	public:
-		GlProgramPipelineHandle m_ppline;
-		Array<GlProgramHandle, 6> m_progs;
+		GlPipelineHandle m_ppline;
+		Array<GlShaderHandle, 6> m_progs;
 		U8 m_progsCount;
 
-		Command(GlProgramPipelineHandle& ppline, 
-			const GlProgramHandle* progsBegin, const GlProgramHandle* progsEnd)
+		Command(GlPipelineHandle& ppline, 
+			const GlShaderHandle* progsBegin, const GlShaderHandle* progsEnd)
 		:	m_ppline(ppline)
 		{
 			m_progsCount = 0;
-			const GlProgramHandle* prog = progsBegin;
+			const GlShaderHandle* prog = progsBegin;
 			do
 			{
 				m_progs[m_progsCount++] = *prog;
@@ -72,10 +72,10 @@ Error GlProgramPipelineHandle::commonConstructor(
 		}
 	};
 
-	using Alloc = GlAllocator<GlProgramPipeline>;
-	using DeleteCommand = GlDeleteObjectCommand<GlProgramPipeline, Alloc>;
+	using Alloc = GlAllocator<GlPipeline>;
+	using DeleteCommand = GlDeleteObjectCommand<GlPipeline, Alloc>;
 	using Deleter = 
-		GlHandleDeferredDeleter<GlProgramPipeline, Alloc, DeleteCommand>;
+		GlHandleDeferredDeleter<GlPipeline, Alloc, DeleteCommand>;
 
 	Error err = _createAdvanced(
 		&commands._get().getQueue().getDevice(),
@@ -93,16 +93,16 @@ Error GlProgramPipelineHandle::commonConstructor(
 }
 
 //==============================================================================
-void GlProgramPipelineHandle::bind(GlCommandBufferHandle& commands)
+void GlPipelineHandle::bind(GlCommandBufferHandle& commands)
 {
 	ANKI_ASSERT(isCreated());
 
 	class Command: public GlCommand
 	{
 	public:
-		GlProgramPipelineHandle m_ppline;
+		GlPipelineHandle m_ppline;
 
-		Command(GlProgramPipelineHandle& ppline)
+		Command(GlPipelineHandle& ppline)
 		:	m_ppline(ppline)
 		{}
 
@@ -125,7 +125,7 @@ void GlProgramPipelineHandle::bind(GlCommandBufferHandle& commands)
 }
 
 //==============================================================================
-GlProgramHandle GlProgramPipelineHandle::getAttachedProgram(GLenum type) const
+GlShaderHandle GlPipelineHandle::getAttachedProgram(GLenum type) const
 {
 	ANKI_ASSERT(isCreated());
 	Error err = serializeOnGetter();
@@ -135,7 +135,7 @@ GlProgramHandle GlProgramPipelineHandle::getAttachedProgram(GLenum type) const
 	}
 	else
 	{
-		return GlProgramHandle();
+		return GlShaderHandle();
 	}
 }
 

src/gl/GlProgram.cpp → src/gl/GlShader.cpp

@@ -3,7 +3,7 @@
 // Code licensed under the BSD License.
 // http://www.anki3d.org/LICENSE
 
-#include "anki/gl/GlProgram.h"
+#include "anki/gl/GlShader.h"
 #include "anki/util/StringList.h"
 #include "anki/util/Logger.h"
 
@@ -210,7 +210,7 @@ void GlProgramVariable::writeClientMemory(void* buff, U32 buffSize,
 }
 
 //==============================================================================
-// GlProgram                                                                   =
+// GlShader                                                                    =
 //==============================================================================
 
 /// Check if the variable name is worth beeng processed.
@@ -269,7 +269,7 @@ static Bool sanitizeSymbolName(char* name)
 const U SYMBOL_MAX_NAME_LENGTH = 256;
 
 //==============================================================================
-Error GlProgram::create(GLenum type, const CString& source, 
+Error GlShader::create(GLenum type, const CString& source, 
 	GlAllocator<U8>& alloc, const CString& cacheDir)
 {
 	ANKI_ASSERT(source);
@@ -384,7 +384,7 @@ Error GlProgram::create(GLenum type, const CString& source,
 }
 
 //==============================================================================
-Error GlProgram::handleError(GlAllocator<U8>& alloc, String& src)
+Error GlShader::handleError(GlAllocator<U8>& alloc, String& src)
 {
 	Error err = ErrorCode::NONE;
 
@@ -438,7 +438,7 @@ Error GlProgram::handleError(GlAllocator<U8>& alloc, String& src)
 }
 
 //==============================================================================
-Error GlProgram::populateVariablesAndBlock(GlAllocator<U8>& alloc)
+Error GlShader::populateVariablesAndBlock(GlAllocator<U8>& alloc)
 {
 	Error err = ErrorCode::NONE;
 
@@ -582,7 +582,7 @@ Error GlProgram::populateVariablesAndBlock(GlAllocator<U8>& alloc)
 }
 
 //==============================================================================
-void GlProgram::destroy()
+void GlShader::destroy()
 {
 	if(m_glName != 0)
 	{
@@ -596,7 +596,7 @@ void GlProgram::destroy()
 }
 
 //==============================================================================
-Error GlProgram::initVariablesOfType(
+Error GlShader::initVariablesOfType(
 	GLenum interface, U activeCount, U indexOffset, U blkIndexOffset,
 	char*& namesPtr, U& namesLen)
 {
@@ -724,7 +724,7 @@ Error GlProgram::initVariablesOfType(
 }
 
 //==============================================================================
-Error GlProgram::initBlocksOfType(
+Error GlShader::initBlocksOfType(
 	GLenum interface, U activeCount, U indexOffset, 
 	char*& namesPtr, U& namesLen)
 {
@@ -795,7 +795,7 @@ Error GlProgram::initBlocksOfType(
 }
 
 //==============================================================================
-const GlProgramVariable* GlProgram::tryFindVariable(const CString& name) const
+const GlProgramVariable* GlShader::tryFindVariable(const CString& name) const
 {
 	ANKI_ASSERT(isCreated());
 
@@ -814,7 +814,7 @@ const GlProgramVariable* GlProgram::tryFindVariable(const CString& name) const
 }
 
 //==============================================================================
-const GlProgramBlock* GlProgram::tryFindBlock(const CString& name) const
+const GlProgramBlock* GlShader::tryFindBlock(const CString& name) const
 {
 	ANKI_ASSERT(isCreated());
 

src/gl/GlProgramHandle.cpp → src/gl/GlShaderHandle.cpp

@@ -3,38 +3,38 @@
 // Code licensed under the BSD License.
 // http://www.anki3d.org/LICENSE
 
-#include "anki/gl/GlProgramHandle.h"
+#include "anki/gl/GlShaderHandle.h"
 #include "anki/gl/GlDevice.h"
 #include "anki/gl/GlClientBufferHandle.h"
 #include "anki/gl/GlHandleDeferredDeleter.h"
-#include "anki/gl/GlProgram.h"
+#include "anki/gl/GlShader.h"
 
 namespace anki {
 
 //==============================================================================
 /// Create program command
-class GlProgramCreateCommand: public GlCommand
+class GlShaderCreateCommand: public GlCommand
 {
 public:
-	GlProgramHandle m_prog;
+	GlShaderHandle m_shader;
 	GLenum m_type;
 	GlClientBufferHandle m_source;
 
-	GlProgramCreateCommand(GlProgramHandle prog, 
+	GlShaderCreateCommand(GlShaderHandle shader, 
 		GLenum type, GlClientBufferHandle source)
-	:	m_prog(prog), 
+	:	m_shader(shader), 
 		m_type(type), 
 		m_source(source)
 	{}
 
 	Error operator()(GlCommandBuffer* commands)
 	{
-		Error err = m_prog._get().create(m_type, 
+		Error err = m_shader._get().create(m_type, 
 			reinterpret_cast<const char*>(m_source.getBaseAddress()),
 			commands->getQueue().getDevice()._getAllocator(),
 			commands->getQueue().getDevice()._getCacheDirectory());
 
-		GlHandleState oldState = m_prog._setState(
+		GlHandleState oldState = m_shader._setState(
 			(err) ? GlHandleState::ERROR : GlHandleState::CREATED);
 		ANKI_ASSERT(oldState == GlHandleState::TO_BE_CREATED);
 		(void)oldState;
@@ -44,20 +44,20 @@ public:
 };
 
 //==============================================================================
-GlProgramHandle::GlProgramHandle()
+GlShaderHandle::GlShaderHandle()
 {}
 
 //==============================================================================
-GlProgramHandle::~GlProgramHandle()
+GlShaderHandle::~GlShaderHandle()
 {}
 
 //==============================================================================
-Error GlProgramHandle::create(GlCommandBufferHandle& commands, 
+Error GlShaderHandle::create(GlCommandBufferHandle& commands, 
 	GLenum type, const GlClientBufferHandle& source)
 {
-	using Alloc = GlAllocator<GlProgram>;
-	using DeleteCommand = GlDeleteObjectCommand<GlProgram, Alloc>;
-	using Deleter = GlHandleDeferredDeleter<GlProgram, Alloc, DeleteCommand>;
+	using Alloc = GlAllocator<GlShader>;
+	using DeleteCommand = GlDeleteObjectCommand<GlShader, Alloc>;
+	using Deleter = GlHandleDeferredDeleter<GlShader, Alloc, DeleteCommand>;
 
 	Error err = _createAdvanced(
 		&commands._get().getQueue().getDevice(),
@@ -68,7 +68,7 @@ Error GlProgramHandle::create(GlCommandBufferHandle& commands,
 	{
 		_setState(GlHandleState::TO_BE_CREATED);
 
-		commands._pushBackNewCommand<GlProgramCreateCommand>(
+		commands._pushBackNewCommand<GlShaderCreateCommand>(
 			*this, type, source);
 	}
 
@@ -76,13 +76,13 @@ Error GlProgramHandle::create(GlCommandBufferHandle& commands,
 }
 
 //==============================================================================
-GLenum GlProgramHandle::getType() const
+GLenum GlShaderHandle::getType() const
 {
 	return (serializeOnGetter()) ? GL_NONE : _get().getType();
 }
 
 //==============================================================================
-const GlProgramVariable* GlProgramHandle::getVariablesBegin() const
+const GlProgramVariable* GlShaderHandle::getVariablesBegin() const
 {
 	Error err = serializeOnGetter();
 	const GlProgramVariable* out = nullptr;
@@ -96,7 +96,7 @@ const GlProgramVariable* GlProgramHandle::getVariablesBegin() const
 }
 
 //==============================================================================
-const GlProgramVariable* GlProgramHandle::getVariablesEnd() const
+const GlProgramVariable* GlShaderHandle::getVariablesEnd() const
 {
 	Error err = serializeOnGetter();
 	const GlProgramVariable* out = nullptr;
@@ -111,13 +111,13 @@ const GlProgramVariable* GlProgramHandle::getVariablesEnd() const
 
 //==============================================================================
 const GlProgramVariable* 
-	GlProgramHandle::tryFindVariable(const CString& name) const
+	GlShaderHandle::tryFindVariable(const CString& name) const
 {
 	return (serializeOnGetter()) ? nullptr : _get().tryFindVariable(name);
 }
 
 //==============================================================================
-const GlProgramBlock* GlProgramHandle::tryFindBlock(const CString& name) const
+const GlProgramBlock* GlShaderHandle::tryFindBlock(const CString& name) const
 {
 	return (serializeOnGetter()) ? nullptr : _get().tryFindBlock(name);
 }

src/renderer/Renderer.cpp

@@ -298,14 +298,14 @@ Error Renderer::createRenderTarget(U32 w, U32 h, GLenum internalFormat,
 
 //==============================================================================
 Error Renderer::createDrawQuadProgramPipeline(
-	GlProgramHandle frag, GlProgramPipelineHandle& ppline)
+	GlShaderHandle frag, GlPipelineHandle& ppline)
 {
 	GlCommandBufferHandle cmdBuff;
 	Error err = cmdBuff.create(m_gl);
 
 	if(!err)
 	{
-		Array<GlProgramHandle, 2> progs = 
+		Array<GlShaderHandle, 2> progs = 
 			{{m_drawQuadVert->getGlProgram(), frag}};
 
 		err = ppline.create(cmdBuff, &progs[0], &progs[0] + 2);

src/resource/Material.cpp

@@ -275,7 +275,7 @@ ProgramResourcePointer& Material::getProgram(
 
 //==============================================================================
 Error Material::getProgramPipeline(
-	const RenderingKey& key, GlProgramPipelineHandle& out)
+	const RenderingKey& key, GlPipelineHandle& out)
 {
 	ANKI_ASSERT(enumToType(key.m_pass) < m_passesCount);
 	ANKI_ASSERT(key.m_lod < m_lodsCount);
@@ -295,12 +295,12 @@ Error Material::getProgramPipeline(
 	U idx = enumToType(key.m_pass) * m_lodsCount * tessCount
 		+ key.m_lod * tessCount + key.m_tessellation;
 
-	GlProgramPipelineHandle& ppline = m_pplines[idx];
+	GlPipelineHandle& ppline = m_pplines[idx];
 
 	// Lazily create it
 	if(ANKI_UNLIKELY(!ppline.isCreated()))
 	{
-		Array<GlProgramHandle, 5> progs;
+		Array<GlShaderHandle, 5> progs;
 		U progCount = 0;
 
 		progs[progCount++] = 
@@ -613,7 +613,7 @@ Error Material::populateVariables(const MaterialProgramCreator& loader)
 		// Find the input variable in one of the programs
 		for(const ProgramResourcePointer& progr : m_progs)
 		{
-			const GlProgramHandle& prog = progr->getGlProgram();
+			const GlShaderHandle& prog = progr->getGlProgram();
 
 			glvar = prog.tryFindVariable(in.m_name.toCString());
 			if(glvar)

src/resource/Model.cpp

@@ -44,7 +44,7 @@ ModelPatchBase::~ModelPatchBase()
 
 //==============================================================================
 Error ModelPatchBase::createVertexDesc(
-	const GlProgramHandle& prog,
+	const GlShaderHandle& prog,
 	const Mesh& mesh,
 	GlCommandBufferHandle& vertexJobs)
 {
@@ -104,7 +104,7 @@ Error ModelPatchBase::createVertexDesc(
 Error ModelPatchBase::getRenderingDataSub(
 	const RenderingKey& key, 
 	GlCommandBufferHandle& vertJobs, 
-	GlProgramPipelineHandle& ppline,
+	GlPipelineHandle& ppline,
 	const U8* subMeshIndexArray, 
 	U32 subMeshIndexCount,
 	Array<U32, ANKI_GL_MAX_SUB_DRAWCALLS>& indicesCountArray,
@@ -191,7 +191,7 @@ Error ModelPatchBase::create(GlDevice* gl)
 		for(U pass = 0; pass < mtl.getPassesCount(); ++pass)
 		{
 			RenderingKey key((Pass)pass, lod, false);
-			GlProgramHandle prog;
+			GlShaderHandle prog;
 			const Mesh* mesh;
 
 			// Get mesh
@@ -206,7 +206,7 @@ Error ModelPatchBase::create(GlDevice* gl)
 			shaderKey.m_lod = std::min(key.m_lod, 
 				(U8)(getMaterial().getLevelsOfDetail() - 1));
 
-			GlProgramPipelineHandle ppline;
+			GlPipelineHandle ppline;
 			ANKI_CHECK(m_mtl->getProgramPipeline(shaderKey, ppline));
 			prog = ppline.getAttachedProgram(GL_VERTEX_SHADER);
 			

src/resource/ProgramResource.cpp

@@ -50,7 +50,7 @@ Error ProgramResource::load(const CString& filename, const CString& extraSrc,
 
 	std::strcpy(reinterpret_cast<char*>(glsource.getBaseAddress()), &source[0]);
 
-	ANKI_CHECK(m_prog.create(cmdb, 
+	ANKI_CHECK(m_shader.create(cmdb, 
 		computeGlShaderType(pars.getShaderType()), glsource));
 
 	cmdb.flush();

src/scene/ModelNode.cpp

@@ -71,7 +71,7 @@ Error ModelPatchNode::buildRendering(RenderingBuildData& data)
 	U32 drawcallCount;
 
 	GlCommandBufferHandle vertJobs;
-	GlProgramPipelineHandle ppline;
+	GlPipelineHandle ppline;
 
 	Error err = m_modelPatch->getRenderingDataSub(
 		data.m_key, vertJobs, ppline, 

src/scene/ParticleEmitter.cpp

@@ -321,7 +321,7 @@ Error ParticleEmitter::buildRendering(RenderingBuildData& data)
 	RenderingKey key = data.m_key;
 	key.m_lod = 0;
 
-	GlProgramPipelineHandle ppline;
+	GlPipelineHandle ppline;
 	err = m_particleEmitterResource->getMaterial().getProgramPipeline(
 		key, ppline);
 	

src/scene/StaticGeometryNode.cpp

@@ -120,7 +120,7 @@ Error StaticGeometryPatchNode::buildRendering(RenderingBuildData& data)
 	Array<PtrSize, ANKI_GL_MAX_SUB_DRAWCALLS> indicesOffsetArray;
 	U32 drawCount;
 	GlCommandBufferHandle vertJobs;
-	GlProgramPipelineHandle ppline;
+	GlPipelineHandle ppline;
 
 	err = m_modelPatch->getRenderingDataSub(
 		data.m_key, vertJobs, ppline,