Ogre Forums

Code: Select all

@property( syntax == glsl )
	uniform sampler3D texPerlinNoise;
@else
	Texture3D texPerlinNoise : register( t14 );
	SamplerState texPerlinNoiseSampler : register( s14 );
@end

Code: Select all

@property( syntax == glsl )
  	worldPos.xyz += ( texture( texPerlinNoise, 0.2*worldPos.xyz +
					float3(passBuf.globalTime*0.3) ).xyz - 0.2 ) * colour.x * passBuf.windIntensity;
@else
  	worldPos.xyz += ( texPerlinNoise.SampleLevel( texPerlinNoiseSampler,
					0.2*worldPos.xyz +
					float3( passBuf.globalTime*0.3, passBuf.globalTime*0.3, passBuf.globalTime*0.3 ), 0 ).xyz -
					float3( 0.2, 0.2, 0.2 ) ) * input.colour.x * passBuf.windIntensity;
@end

Code: Select all

class HlmsWindListener : public Ogre::HlmsListener {

protected:
#if OGRE_DEBUG_MODE
	Ogre::SceneManager* mSceneManager;
#endif

	const float mWindFactor{ 2 };
	float mGlobalTime{ 0 };

public:
	HlmsWindListener() {}
	~HlmsWindListener() {}

	virtual Ogre::uint32 getPassBufferSize(const Ogre::CompositorShadowNode* shadowNode, bool casterPass,
		bool dualParaboloid, Ogre::SceneManager* sceneManager) const {

		unsigned int fogSize = (4 * 2) * 4; // float4 + float4 in bytes
		unsigned int windSize = (1) * 4;
		unsigned int timeSize = (1) * 4;
		return (!casterPass) ? fogSize + windSize + timeSize: 0u;

	}

	virtual float* preparePassBuffer(const Ogre::CompositorShadowNode* shadowNode, bool casterPass,
		bool dualParaboloid, Ogre::SceneManager* sceneManager,
		float* passBufferPtr) {


		if (!casterPass )
		{
			//Linear Fog parameters
			*passBufferPtr++ = sceneManager->getFogStart();
			*passBufferPtr++ = sceneManager->getFogEnd();
			*passBufferPtr++ = 0.0;
			*passBufferPtr++ = 0.0f;

			*passBufferPtr++ = sceneManager->getFogColour().r;
			*passBufferPtr++ = sceneManager->getFogColour().g;
			*passBufferPtr++ = sceneManager->getFogColour().b;
			*passBufferPtr++ = 1.0f;

			*passBufferPtr++ = mWindFactor;
			
			mGlobalTime += 1;
			if (mGlobalTime >= 1000) mGlobalTime = 0;

			*passBufferPtr++ = mGlobalTime;
		}
		return passBufferPtr;
	}
};

class HlmsWind : public Ogre::HlmsPbs {

	HlmsWindListener mWindListener;
	Ogre::DescriptorSetTexture const* m_descriptorSet{ nullptr };

	Ogre::TextureGpu* mNoiseTexture{ nullptr };

	void calculateHashForPreCreate(Ogre::Renderable* renderable, Ogre::PiecesMap* inOutPieces) override {

		HlmsPbs::calculateHashForPreCreate(renderable, inOutPieces);

		setProperty("wind_enabled", 1);
	}



	void loadNoiseTexture(Ogre::SceneManager* manager) {
		Ogre::Image2 image;
		image.load("windNoise.png", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);

		Ogre::TextureGpuManager* textureManager =
			manager->getDestinationRenderSystem()->getTextureGpuManager();

		mNoiseTexture = textureManager->createTexture(
			"WindNoise",
			Ogre::GpuPageOutStrategy::SaveToSystemRam,
			Ogre::TextureFlags::ManualTexture,
			Ogre::TextureTypes::Type2D);

		mNoiseTexture->setResolution(image.getWidth(), image.getHeight());
		mNoiseTexture->setPixelFormat(image.getPixelFormat());
	
		mNoiseTexture->scheduleTransitionTo(Ogre::GpuResidency::Resident);

		Ogre::StagingTexture* stagingTexture = textureManager->getStagingTexture(image.getWidth(),
			image.getHeight(),
			1u, 1u,
			image.getPixelFormat());
		stagingTexture->startMapRegion();
		Ogre::TextureBox texBox = stagingTexture->mapRegion(image.getWidth(), image.getHeight(), 1u, 1u,
			image.getPixelFormat());

		//for( uint8 mip=0; mip<numMipmaps; ++mip )
		texBox.copyFrom(image.getData(0));
		stagingTexture->stopMapRegion();
		stagingTexture->upload(texBox, mNoiseTexture, 0, 0, 0);
		textureManager->removeStagingTexture(stagingTexture);
		stagingTexture = 0;

		mNoiseTexture->notifyDataIsReady();
	}

public:
	HlmsWind(Ogre::Archive* dataFolder, Ogre::ArchiveVec* libraryFolders)
		: Ogre::HlmsPbs(dataFolder, libraryFolders)
	{
		mType = Ogre::HLMS_USER0;
		mTypeName = "Wind";
		mTypeNameStr = "Wind";

		setListener(&mWindListener);

		mReservedTexSlots = 1u;



	}

	virtual ~HlmsWind() {
	//	destroyDescriptorSet();
	}


	void setupNoiseTexture(Ogre::SceneManager* manager) {
		loadNoiseTexture(manager);

		createDescriptorSet();
	}

	void notifyPropertiesMergedPreGenerationStep(void)
	{
		HlmsPbs::notifyPropertiesMergedPreGenerationStep();

		setTextureReg(Ogre::VertexShader, "WindNoise", 14);
	}


	static void getDefaultPaths(Ogre::String& outDataFolderPath, Ogre::StringVector& outLibraryFoldersPaths) {

		//We need to know what RenderSystem is currently in use, as the
		//name of the compatible shading language is part of the path
		Ogre::RenderSystem* renderSystem = Ogre::Root::getSingleton().getRenderSystem();
		Ogre::String shaderSyntax = "GLSL";
		if (renderSystem->getName() == "Direct3D11 Rendering Subsystem")
			shaderSyntax = "HLSL";
		else if (renderSystem->getName() == "Metal Rendering Subsystem")
			shaderSyntax = "Metal";


		//Fill the library folder paths with the relevant folders
		outLibraryFoldersPaths.clear();
		outLibraryFoldersPaths.push_back("Hlms/Common/" + shaderSyntax);
		outLibraryFoldersPaths.push_back("Hlms/Common/Any");
		outLibraryFoldersPaths.push_back("Hlms/Pbs/Any");
		outLibraryFoldersPaths.push_back("Hlms/Pbs/Any/Main");
		outLibraryFoldersPaths.push_back("Hlms/Wind/Any");

		//Fill the data folder path
		outDataFolderPath = "Hlms/pbs/" + shaderSyntax;
	}

    void createDescriptorSet(void){

        destroyDescriptorSet();

        Ogre::DescriptorSetTexture descSet;

        descSet.mTextures.push_back(mNoiseTexture);
		
        descSet.mShaderTypeTexCount[Ogre::VertexShader] = 1u;

        Ogre::HlmsManager* hlmsManager = Ogre::Root::getSingleton().getHlmsManager();
        m_descriptorSet = hlmsManager->getDescriptorSetTexture(descSet);
    }
    //-----------------------------------------------------------------------------------
    void destroyDescriptorSet(void) {

        if (m_descriptorSet)
        {
            Ogre::HlmsManager* hlmsManager = Ogre::Root::getSingleton().getHlmsManager();
            hlmsManager->destroyDescriptorSetTexture(m_descriptorSet);
            m_descriptorSet = 0;
        }
    }

	
    Ogre::uint32 fillBuffersFor(const Ogre::HlmsCache* cache, const Ogre::QueuedRenderable& queuedRenderable,
        bool casterPass, Ogre::uint32 lastCacheHash,
        Ogre::CommandBuffer* commandBuffer, bool isV1)
    {

        *commandBuffer->addCommand<Ogre::CbTextures>() =
            Ogre::CbTextures(0, std::numeric_limits<Ogre::uint16>::max(), m_descriptorSet);

        return Ogre::HlmsPbs::fillBuffersFor(cache, queuedRenderable, casterPass, lastCacheHash, commandBuffer, isV1);
    }
};

Code: Select all

@piece( custom_vs_preTransform  )
@property(wind_enabled)
	
  	worldPos.xz +=  texPerlinNoise.SampleLevel( texPerlinNoiseSampler,
				worldPos.xyz* passBuf.globalTime,	0	 ).xyz * 100 ;			
@end
@end

Code: Select all

@piece( custom_vs_uniformDeclaration)
	Texture3D texPerlinNoise : register( t14 );
	SamplerState texPerlinNoiseSampler : register( s14 );
@end

/// Extra per-pass global data we need for applying our fog
@piece( custom_passBuffer )
    //Fog
    float4 fogParams;
    float4 fogColor;

	float windFactor;
	float globalTime;
@end

Code: Select all

	Ogre::TextureBox texBox = stagingTexture->mapRegion(image.getWidth(), image.getHeight(), image.getDepth(), image.getNumSlices(),
			image.getPixelFormat());
					texBox.copyFrom(image.getData(0));
			

Code: Select all

            Ogre::HlmsSamplerblock samplerblock;
        samplerblock.mU = Ogre::TextureAddressingMode::TAM_WRAP;
        samplerblock.mV = Ogre::TextureAddressingMode::TAM_WRAP;
        samplerblock.mW = Ogre::TextureAddressingMode::TAM_WRAP;
        samplerblock.mMaxAnisotropy = 8;
        samplerblock.mMagFilter = Ogre::FO_ANISOTROPIC;
        mSamplerblockWrap = Ogre::Root::getSingleton().getHlmsManager()->getSamplerblock(samplerblock);

    mWindNoiseTexture = textureMgr->createOrRetrieveTexture(
                                    "windNoise.dds",
                                    Ogre::GpuPageOutStrategy::Discard,
                                    Ogre::TextureFlags::PrefersLoadingFromFileAsSRGB,
                                    Ogre::TextureTypes::Type3D,
                                    Ogre::ResourceGroupManager::AUTODETECT_RESOURCE_GROUP_NAME );
    mWindNoiseTexture->scheduleTransitionTo( Ogre::GpuResidency::Resident );

Code: Select all

vsParams->setNamedConstant( "texPerlinNoise", 14 );

Code: Select all

    *commandBuffer->addCommand<Ogre::CbTexture>() = Ogre::CbTexture( 14, const_cast<Ogre::TextureGpu*>(mWindNoiseTexture), mSamplerblockWrap );

Code: Select all

		
		
		
	 Ogre::DescriptorSetTexture descSet;

        descSet.mTextures.push_back(mNoiseTexture);
	
        descSet.mShaderTypeTexCount[Ogre::VertexShader] = 1u;
		descSet.mShaderTypeTexCount[Ogre::PixelShader] = 0u;

        Ogre::HlmsManager* hlmsManager = Ogre::Root::getSingleton().getHlmsManager();
        m_descriptorSet = hlmsManager->getDescriptorSetTexture(descSet);
        
		Ogre::DescriptorSetSampler baseSet;
		baseSet.mSamplers.push_back(m_samplerBlock);
		baseSet.mShaderTypeSamplerCount[Ogre::VertexShader] = baseSet.mSamplers.size();
		m_descriptorSetSampler = mHlmsManager->getDescriptorSetSampler(baseSet);
		
		
		
	
		*commandBuffer->addCommand<Ogre::CbSamplers>() =
			Ogre::CbSamplers(14, m_descriptorSetSampler);

        *commandBuffer->addCommand<Ogre::CbTextures>() =
            Ogre::CbTextures(14, std::numeric_limits<Ogre::uint16>::max(),
                m_descriptorSet);
		
		

Code: Select all

MeshSerializer_v2.1 R2

Code: Select all

Ogre::Item* item = graphics.getSceneManager()->createItem("Grass1.mesh", Ogre::ResourceGroupManager::AUTODETECT_RESOURCE_GROUP_NAME, Ogre::SCENE_STATIC);
Ogre::SceneNode* sn = graphics.getSceneManager()->getRootSceneNode()->createChildSceneNode(Ogre::SCENE_STATIC, position, orientation);
sn->scale(Ogre::Vector3(0.5, 0.5, 0.5)*sY);
sn->attachObject(item);
item->setRenderQueueGroup(254);

Code: Select all

		sceneManager->setFog(Ogre::FOG_LINEAR, Ogre::ColourValue(1, 0, 1),NULL,10 , 300.0f);

Code: Select all

*passBufferPtr++ = fogStart
*passBufferPtr++ = fogEnd
*passBufferPtr++ = fogColor.r
*passBufferPtr++ = fogColor.g
*passBufferPtr++ = fogColor.b
*passBufferPtr++ = globalTimer

Code: Select all

@piece( custom_passBuffer )
float fogStart
float fogEnd
float globalTimer <<< error!! this should be after fogcolor
float3 fogColor

Code: Select all

@piece( custom_passBuffer )
    //Fog
    float4 fogParams;
    float4 fogColor;

	float windFactor;
	float globalTime;
	float padding0;
	float padding1;
@end