Si cela peut t'aider, voici un code de base qui utilise le GLSL, c'est basic, mais c'est son but, si cela
peut te permettre d'y voir plus clair. Ce code fonctionne sans soucis
la partie code C++ Irrlicht:

#include <irrlicht.h>


using namespace irr;
using namespace core;
using namespace scene;
using namespace video;

#ifdef _IRR_WINDOWS_
	#pragma comment(lib, "Irrlicht.lib")
#endif

/*
	données globales
*/
bool _bExit = false;
ISceneNode* cube1;

//=============================================================================================
// surcharge de la classe IEventReceiver, pour la gestion des entrés clavier dans notre cas.
class MyEventReceiver : public IEventReceiver
{
public:
	virtual bool OnEvent(const SEvent& event)
	{
		if (event.EventType == irr::EET_KEY_INPUT_EVENT )
		{
			switch(event.KeyInput.Key)
			{
				case KEY_ESCAPE:
				{
					_bExit = true;
					return true;
				}
			}
		}
		return false;
	}
};
//=============================================================================================


//=============================================================================================
//procedure 'main', point d'entrée du programme commun à toute les plateformes.
int main()
{
	// définition de notre classe dérivé, pour la gestion
	// des entrées clavier
	MyEventReceiver    _EventReceiver;


	// Ici driver OGL car emploi de GLSL, donc uniquement OpenGL
	video::E_DRIVER_TYPE driverType;
	driverType = video::EDT_OPENGL;
	IrrlichtDevice *device = createDevice( driverType, 
											dimension2d<s32>(800, 600), 
											32,
											false, 
											false, 
											true, 
											&_EventReceiver);
	

	//	petite redifinition du titre de la fenetre.
	device->setWindowCaption(L"Tuto_Shader1 - Premier shader GLSL");


	/*
		une fois le device créé, on va récupérer un certain nombre
		de pointeur qui vont nous être utile pour la suite.
		Entre-autre: video driver, SceneManager et GUI.
	*/
	IVideoDriver* driver		= device->getVideoDriver();
	ISceneManager* scenegraph	= device->getSceneManager();
	IGPUProgrammingServices *gpu= driver->getGPUProgrammingServices();



	s32 matid = video::EMT_SOLID;
	matid = gpu->addHighLevelShaderMaterialFromFiles(	"../shaders/exemple1.vs",	"main",	video::EVST_VS_2_0,
														"../shaders/exemple1.ps",	"main",	video::EPST_PS_2_0,
														NULL,	video::EMT_SOLID,	0);


	// notre petit mesh, tranquille
	// cube 1 
	cube1 = scenegraph->addCubeSceneNode(2.0f, scenegraph->getRootSceneNode());
	
	// si notre petit cube est créé comme il s doit, alors on applique quelques 
	// menu intialisation
	if (cube1)
	{	
		SMaterial *mat = &cube1->getMaterial(0);
		mat->setFlag(EMF_LIGHTING  , false);
		mat->setTexture( 0, driver->getTexture("../../../media/stones.jpg") );
		// instruction clé, c'est là que l'on stipule au moteur3D que le rendu de notre cube1 ne vas
		// pas passer par le pipeline fixe, mais à travers un shader 
		cube1->setMaterialType( (video::E_MATERIAL_TYPE) matid );
	}


	/*
		creation de notre camera, ici une camera un peu particulière,
		il s'agit d'une camera de type FPS, qui simule une vue à la première
		personne.
	*/
	// définition des touches de controle de notre futur camera.
	SKeyMap keyMap[4] = 
	{
		{EKA_MOVE_FORWARD,	KEY_UP},
		{EKA_MOVE_BACKWARD,	KEY_DOWN},
		{EKA_STRAFE_LEFT,	KEY_LEFT},
		{EKA_STRAFE_RIGHT,	KEY_RIGHT},
	};
	/*
		phase de creation et de positionnement.
	*/
	ICameraSceneNode* cam = scenegraph->addCameraSceneNodeFPS( scenegraph->getRootSceneNode() , 100.0f, 50.0f, -1, keyMap, 4);
	cam->setPosition(core::vector3df(0,3,-5));
	cam->setRotation( core::vector3df(20,0,0) );
		

	// boucle principale de rendu
	int lastFPS = -1;

	while(device->run() & !_bExit)
	{
		driver->beginScene(true, true, SColor(255,100,101,140));
			scenegraph->drawAll();
		driver->endScene();


		// affichage dans le titre de quelques info
		int fps = driver->getFPS();
		if (lastFPS != fps)
		{
			core::stringw str = L"Tuto_Shader1 - Premier shader";
			str += " FPS:";
			str += fps;
			device->setWindowCaption(str.c_str());
			lastFPS = fps;
		}

	}
	/*
		Une  fois sortie, c'est la fin, avec la libération de toutes les 
		ressources créées par 'createDevice'.
	*/
	device->drop();

	return 0;
}
//=============================================================================================

maintenant le fichier exemple1.vs

varying vec3 normal;
void main()
{
   normal = gl_NormalMatrix * gl_Normal;
   gl_Position = ftransform();
}

et le fichier exemple1.ps

varying vec3 normal;
void main()
{
   float intensity;
   vec4 color;
   vec3 n = normalize(normal);

   intensity = dot(vec3(gl_LightSource[0].position),n);

   if (intensity > 0.95)
      color = vec4(1.0,0.5,0.5,1.0);
   else if (intensity > 0.5)
      color = vec4(0.6,0.3,0.3,1.0);
   else if (intensity > 0.25)
      color = vec4(0.4,0.2,0.2,1.0);
   else
      color = vec4(0.2,0.1,0.1,1.0);

   gl_FragColor = color;
}

Voila, le media pour la texture n'a pas vraiment d'importance.