View difference between Paste ID: 678ha0mA and ujsqyeqs

 #ifdef _MSC_VER
 // We'll also define this to stop MSVC complaining about sprintf().
 #define _CRT_SECURE_NO_WARNINGS
 #pragma comment(lib, "Irrlicht_d.lib")
-float4x4 viewProjection;
+#endif
 
-struct VS_INPUT
+#include <irrlicht.h>
 #include <driverChoice.h>
-	float4 vPosition: POSITION;
+
-	float3 vNormal  : NORMAL;
+using namespace irr;
-	float4 color    : COLOR;
+
-	float2 texCoord : TEXCOORD0;
+using namespace core;
-	float4 W0       : TEXCOORD1;
+using namespace scene;
-	float4 W1       : TEXCOORD2;
+using namespace video;
-	float4 W2       : TEXCOORD3;
+using namespace io;
-	float4 W3       : TEXCOORD4;
+using namespace gui;
-	//float4 Stemp    : TEXCOORD5;
+
 struct StarInst
 {
 	irr::core::matrix4 Transformation;
-struct VS_OUTPUT
+	//irr::f32 Temperature;
 	//irr::f32 Temperature1;
-	float4 Position   :POSITION;   // vertex position
+	//irr::f32 Temperature2;
-	float2 tcoord         : TEXCOORD1;
+	//irr::f32 Temperature3;
 	bool operator==(const StarInst &other) const
 	{
-VS_OUTPUT vsmain(VS_INPUT Inputs)
+		if ((this->Transformation == other.Transformation) /*&& (this->Temperature == other.Temperature)*/)
 			return true;
-	VS_OUTPUT tout;
+
-	float4x4 transformation = float4x4(Inputs.W0, Inputs.W1, Inputs.W2, Inputs.W3);
+
-	float4 pos = mul(Inputs.vPosition, transformation);
+		return false;
-	tout.Position = mul(pos, viewProjection);
+	}
-	tout.tcoord = Inputs.texCoord;
+
 
-	return tout;
+
-}
+class ShaderCB : public video::IShaderConstantSetCallBack
 {
-Texture2D tex1 : register(t0);
+public:
-//TODO find out why only s1 works and not s0?
+	ShaderCB(irr::video::E_DRIVER_TYPE currentdriver)
-SamplerState sampler1 : register(s1);
+		: firstUpdate(true)
 	{
-float4 psmain(VS_OUTPUT input) : SV_Target
+		Currentdriver = currentdriver;
 	}
-	return tex1.Sample(sampler1, input.tcoord);
+
 	void OnSetConstants(video::IMaterialRendererServices* services, s32 userData)
 	{
 		if (firstUpdate)
 		{
 			viewProjectionId = services->getVertexShaderConstantID("viewProjection");
 			firstUpdate = false;
 		}
 
 		core::matrix4 viewProjection;
 		viewProjection = services->getVideoDriver()->getTransform(video::ETS_PROJECTION);
 		viewProjection *= services->getVideoDriver()->getTransform(video::ETS_VIEW);
 		services->setVertexShaderConstant(viewProjectionId, viewProjection.pointer(), 16);
 
 		//setPixelShaderConstant
 	}
 
 private:
 	irr::video::E_DRIVER_TYPE Currentdriver;
 	bool firstUpdate;
 
 	s32 viewProjectionId;
 };
 
 class InstanceManager : public scene::ISceneNode
 {
 
 	/*
 	First, we declare some member variables:
 	The Node array,  the mesh buffer, the mesh and the material instanced scenenode
 	we also need to keep track of the shader callback.
 	*/
 	video::SMaterial Material;
 	IMeshBuffer* bBuffer;
 	IMesh* aMesh;
 	ShaderCB* callback;
 	/*Variable to handle shader instancing*/
 	IMesh* bMesh;
 	bool fakeinstancing;
 	//CMeshBuffer dupBuffer;
 	/*
 	We treat the instance manager as a scene node so we don't really have to care about it in the future
 	*/
 	core::aabbox3d<f32> mbb;
 public:
 
 	InstanceManager(scene::ISceneNode* parent, scene::ISceneManager* mgr, s32 id, bool Fakeinstancing)
 		: scene::ISceneNode(parent, mgr, id)//, dupBuffer( irr::video::E_INDEX_TYPE::EIT_16BIT)
 	{
 		fakeinstancing = false;
 
 		//lodused =0;
 
 
 		//scene::ISceneNode* bg= mgr->addCubeSceneNode(50000,0,ID_IsNotPickable);
 		//bg->setMaterialFlag(irr::video::E_MATERIAL_FLAG::EMF_LIGHTING,false);
 		//bg->setMaterialFlag(irr::video::E_MATERIAL_FLAG::EMF_BACK_FACE_CULLING,false);
 
 		//shader
 		s32 mtrlShader = -1;
 
 		callback = new ShaderCB(mgr->getVideoDriver()->getDriverType());
 
 		if (mgr->getVideoDriver()->getDriverType() == EDT_OPENGL)
 			mtrlShader = SceneManager->getVideoDriver()->getGPUProgrammingServices()->addHighLevelShaderMaterialFromFiles("media/shaders/instancing.vert", "", video::EVST_VS_2_0,
 			"media/shaders/instancing.frag", "", video::EPST_PS_2_0, callback, video::EMT_SOLID);
 		else if (mgr->getVideoDriver()->getDriverType() == EDT_DIRECT3D9)
 			mtrlShader = SceneManager->getVideoDriver()->getGPUProgrammingServices()->addHighLevelShaderMaterialFromFiles("../../media/InstancingFVF.hlsl", "vsmain", video::EVST_VS_3_0,
 			"../../media/InstancingFVF.hlsl", "psmain", video::EPST_PS_3_0, callback, video::EMT_SOLID);
 		else if (mgr->getVideoDriver()->getDriverType() == EDT_DIRECT3D11)
 			mtrlShader = SceneManager->getVideoDriver()->getGPUProgrammingServices()->addHighLevelShaderMaterialFromFiles("../../media/InstancingFVF.hlsl", "vsmain", video::EVST_VS_4_0,
 			"../../media/InstancingFVF.hlsl", "psmain", video::EPST_PS_4_0, callback, video::EMT_SOLID);
 
 		callback->drop();
 
 		aMesh = SceneManager->getGeometryCreator()->createSphereMesh(2);
 		Material.Lighting = false;
 		Material.setTexture(0, SceneManager->getVideoDriver()->getTexture("../../media/wall.jpg"));
 		Material.MaterialType = (video::E_MATERIAL_TYPE)mtrlShader;
 		//Material.BackfaceCulling = false;
 
 		IVertexDescriptor* index = mgr->getVideoDriver()->getVertexDescriptor("BaseInstanceIndex");
 
 		if (!index)
 		{
 			IVertexDescriptor* stdv = mgr->getVideoDriver()->getVertexDescriptor(0);
 			index = mgr->getVideoDriver()->addVertexDescriptor("BaseInstanceIndex");
 
 			for (u32 i = 0; i < stdv->getAttributeCount(); i++)
 			{
 				index->addAttribute(stdv->getAttribute(i)->getName(), stdv->getAttribute(i)->getElementCount(), stdv->getAttribute(i)->getSemantic(), stdv->getAttribute(i)->getType(), 0);
 			}
 
 			index->addAttribute("InstancingIndex1", 4, EVAS_TEXCOORD1, EVAT_FLOAT, 1);
 			index->addAttribute("InstancingIndex2", 4, EVAS_TEXCOORD2, EVAT_FLOAT, 1);
 			index->addAttribute("InstancingIndex3", 4, EVAS_TEXCOORD3, EVAT_FLOAT, 1);
 			index->addAttribute("InstancingIndex4", 4, EVAS_TEXCOORD4, EVAT_FLOAT, 1);
 			//index->addAttribute("InstancingIndex5", 4, EVAS_TEXCOORD5, EVAT_FLOAT, 1);
 		}
 
 		//dupBuffer.SetvertexDescriptor(Instanced2tcoords);
 		IVertexBuffer* InstanceIndex = new CVertexBuffer<StarInst>(index);
 
 		bBuffer = aMesh->getMeshBuffer(0);
 
 		mgr->getVideoDriver()->setMinHardwareBufferVertexCount(0);
 		bBuffer->setHardwareMappingHint(scene::EHM_STATIC);
 		bBuffer->getVertexBuffer()->setVertexDescriptor(index);
 		InstanceIndex->setHardwareMappingHint(scene::EHM_DYNAMIC);
 		bBuffer->addVertexBuffer(InstanceIndex);
 
 		InstanceIndex->drop();
 	}
 
 	/*The node array is put here to be public only for the purpose of the demo in the future a function coud take care of this without having it public*/
 
 	core::array<ISceneNode*> totalNodeArray;
 
 
 	/*Create an empty scenenode and return the pointer to the user
 	this empty scene node is used for irrlicht and the user to manage the instance
 	Each instance can be manipulated individualy through thier own empty scenenode*/
 	ISceneNode* AddInstance(vector3df pos, f32 scale, vector3df rotation)
 	{
 		ISceneNode* empty = SceneManager->addEmptySceneNode();
 		//empty->grab();
 		//empty->setParent(NULL);
 		empty->setPosition(pos);
 		empty->setScale(vector3df(scale));
 		empty->setRotation(rotation);
 		totalNodeArray.push_back(empty);
 		return empty;
 	}
 	/*
 	we always register this for rendering since visibility is handeled in the sub node
 	*/
 	virtual void OnRegisterSceneNode()
 	{
 		SceneManager->registerNodeForRendering(this);
 
 		ISceneNode::OnRegisterSceneNode();
 	}
 
 	/*
 	In the render() method most of the interesting stuff happens: The manager goes through the node array and upload thier matrices to the shader callback
 	In OpenGL we render per batches of 248 and in dx per batches of 62 this is due to the amount of variable register availible being diferent in both drivers
 	in the future if a vertex texture patch is accepted both could be made to render every node in a single draw call and fetch thier matrices from a texture
 	*/
 	virtual void OnAnimate(u32 timeMs)
 	{
 		ISceneNode::OnAnimate(timeMs);
 
 		bBuffer->getVertexBuffer(1)->clear();
 		mbb.reset(0,0,0);
 
 		const SViewFrustum* frust = SceneManager->getActiveCamera()->getViewFrustum();
 		for (u32 i = 0; i<totalNodeArray.size(); i++)
 		{
 			//totalNodeArray[i]->OnAnimate(timeMs);
 			bool cliped = false;
 			for (s32 e = 0; e<scene::SViewFrustum::VF_PLANE_COUNT; ++e)
 				if ((frust->planes[e].classifyPointRelation(totalNodeArray[i]->getAbsolutePosition())) == core::EIntersectionRelation3D::ISREL3D_FRONT)
 				{
 					// cliped = true;
 					break;
 				}
 			if (!cliped)
 			{
 				StarInst currinst;
 				currinst.Transformation = totalNodeArray[i]->getAbsoluteTransformation();
 				bBuffer->getVertexBuffer(1)->addVertex(&currinst);
 				mbb.addInternalPoint(totalNodeArray[i]->getAbsolutePosition());
 			}
 		}
 		bBuffer->getVertexBuffer(1)->setDirty();
 
 		// std::cout<<bBuffer->getVertexBuffer(1)->getVertexCount()<<std::endl;
 	}
 
 	virtual void render()
 	{
 		SceneManager->getVideoDriver()->setTransform(video::ETS_WORLD, AbsoluteTransformation);
 		SceneManager->getVideoDriver()->setMaterial(Material);
 		int nRemainingBoxes = totalNodeArray.size();
 
 
 		// if (fakeinstancing == false)
 
 		SceneManager->getVideoDriver()->drawInstancedMeshBuffer(bBuffer);
 
 		video::SMaterial m;
 		m.Lighting = false;
 		SceneManager->getVideoDriver()->setMaterial(m);
 
 		for (u32 i = 0; i < totalNodeArray.size(); ++i)
 		{
 			core::aabbox3df box = aMesh->getBoundingBox();
 			totalNodeArray[i]->getAbsoluteTransformation().transformBoxEx(box);
 			SceneManager->getVideoDriver()->draw3DBox( box, video::SColor(255, 255, 255, 255));
 		}
 
 		SceneManager->getVideoDriver()->draw3DBox(mbb, video::SColor(255, 255, 255, 255));
 		// else
 		//   SceneManager->getVideoDriver()->drawMeshBuffer(&dupBuffer);
 
 	}
 
 	/*
 	Here we return the bounding box for the whole instance batch to make sure the node does not get culled wen there is still even a single instance in the view fulstrum
 	*/
 
 	virtual const core::aabbox3d<f32>& getBoundingBox() const
 	{
 		return mbb;
 	}
 
 	virtual u32 getMaterialCount() const
 	{
 		return 1;
 	}
 
 	virtual video::SMaterial& getMaterial(u32 i)
 	{
 		return Material;
 	}
 };
 
 int main()
 {
 
 	video::E_DRIVER_TYPE driverType = driverChoiceConsole();
 	if (driverType == video::EDT_COUNT)
 		return 1;
 	bool usefakeinst = false;
 	bool animate = false;
 	char i;
 
 	printf("Please press 'y' if you want to use Shader Instancing.\n");
 	std::cin >> i;
 	if (i == 'y')
 	{
 		usefakeinst = true;
 	}
 	printf("Please press 'y' if you want each instance to be animated.\n");
 	std::cin >> i;
 	if (i == 'y')
 	{
 		animate = true;
 	}
 	// create device and exit if creation failed
 
 	IrrlichtDevice * device = createDevice(driverType, core::dimension2d<u32>(800, 600), 32u, false);
 
 	if (device == 0)
 		return 1; // could not create selected driver.
 
 	/* The creation was successful, now we set the event receiver and
 	store pointers to the driver and to the gui environment. */
 
 
 	device->setWindowCaption(L"Irrlicht Engine - Hardware Instancing Demo");
 
 	video::IVideoDriver* driver = device->getVideoDriver();
 	scene::ISceneManager* smgr = device->getSceneManager();
 	IGUIEnvironment* env = device->getGUIEnvironment();
 	InstanceManager* InstancingTest = new InstanceManager(smgr->getRootSceneNode(), smgr, -1, usefakeinst);
 
 	//!save transformation in one EmptySceneNode which doesn't render itself
 	f32 scale = 1.5f;
 	for (f32 i = 0; i<5; i++)
 		for (f32 j = 1; j<5; j++)
 			for (f32 k = 0; k<10; k++)
 			{
 
 				scene::ISceneNode* empty = InstancingTest->AddInstance(vector3df(i*scale, j*scale, k*scale), scale, vector3df(rand() % 360, rand() % 360, rand() % 360));
 				if (animate)
 				{
 					scene::ISceneNodeAnimator* anim =
 						smgr->createFlyCircleAnimator(vector3df(i*scale, j*scale, k*scale), rand() / 20, rand()*0.0000001);
 					if (anim)
 					{
 						empty->addAnimator(anim);
 						anim->drop();
 					}
 				}
 
 			}
 
 	scene::ICameraSceneNode* cam = smgr->addCameraSceneNodeFPS();
 	cam->setFarValue(2000);
 
 	device->getCursorControl()->setVisible(false);
 
 	InstancingTest->drop();
 
 	s32 lastFPS = -1;
 	while (device->run())
 	{
 		if (device->isWindowActive())
 		{
 			driver->beginScene(true, true, SColor(255, 122, 122, 122));
 
 			smgr->drawAll();
 			env->drawAll();
 
 			driver->endScene();
 
 			int fps = driver->getFPS();
 
 			if (lastFPS != fps)
 			{
 				core::stringw str = L"fps: ";
 				str += fps;
 				str += ", poly: ";
 				str += driver->getPrimitiveCountDrawn();
 				str += ", Node count:";
 				str += InstancingTest->totalNodeArray.size();
 				device->setWindowCaption(str.c_str());
 				lastFPS = fps;
 			}
 		}
 	}
 
 	device->drop();
 
 	return 0;
 }