//---------------------------------------------------------------------
	MaterialPtr TerrainMaterialGeneratorA::SM2Profile::generate(const Terrain* terrain)
	{
		// re-use old material if exists
		MaterialPtr mat = terrain->_getMaterial();
		if (mat.isNull())
		{
			MaterialManager& matMgr = MaterialManager::getSingleton();

			// it's important that the names are deterministic for a given terrain, so
			// use the terrain pointer as an ID
			const String& matName = terrain->getMaterialName();
			mat = matMgr.getByName(matName);
			if (mat.isNull())
			{
				mat = matMgr.create(matName, ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
			}
		}
		// clear everything
		mat->removeAllTechniques();
		
		// Automatically disable normal & parallax mapping if card cannot handle it
		// We do this rather than having a specific technique for it since it's simpler
		GpuProgramManager& gmgr = GpuProgramManager::getSingleton();
		if (!gmgr.isSyntaxSupported("ps_4_0") && !gmgr.isSyntaxSupported("ps_3_0") && !gmgr.isSyntaxSupported("ps_2_x")
			&& !gmgr.isSyntaxSupported("fp40") && !gmgr.isSyntaxSupported("arbfp1") && !gmgr.isSyntaxSupported("glsl")
            && !gmgr.isSyntaxSupported("glsles"))
		{
			setLayerNormalMappingEnabled(false);
			setLayerParallaxMappingEnabled(false);
		}

		addTechnique(mat, terrain, HIGH_LOD);

		// LOD
		if(mCompositeMapEnabled)
		{
			addTechnique(mat, terrain, LOW_LOD);
			Material::LodValueList lodValues;
			lodValues.push_back(TerrainGlobalOptions::getSingleton().getCompositeMapDistance());
			mat->setLodLevels(lodValues);
			Technique* lowLodTechnique = mat->getTechnique(1);
			lowLodTechnique->setLodIndex(1);
		}

		updateParams(mat, terrain);

		return mat;

	}
    //---------------------------------------------------------------------
    ushort LodStrategy::getIndexDescending(Real value, const Material::LodValueList& materialLodValueList)
    {
        Material::LodValueList::const_iterator i, iend;
        iend = materialLodValueList.end();
        unsigned short index = 0;
        for (i = materialLodValueList.begin(); i != iend; ++i, ++index)
        {
            if (*i < value)
            {
				return index ? index - 1 : 0;
            }
        }

        // If we fall all the way through, use the highest value
        return static_cast<ushort>(materialLodValueList.size() - 1);
    }
	//---------------------------------------------------------------------
	MaterialPtr TerrainMaterialGeneratorC::SM2Profile::generate(const Terrain* terrain)
	{
		// re-use old material if exists
		MaterialPtr mat = terrain->_getMaterial();
		if (mat.isNull())
		{
			MaterialManager& matMgr = MaterialManager::getSingleton();
 
			// it's important that the names are deterministic for a given terrain, so
			// use the terrain pointer as an ID
			const String& matName = terrain->getMaterialName();
			mat = matMgr.getByName(matName);
			if (mat.isNull())
			{
				mat = matMgr.create(matName, ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
			}
		}
		// clear everything
		mat->removeAllTechniques();
 
		addTechnique(mat, terrain, HIGH_LOD);
 
		// LOD
		if(mCompositeMapEnabled)
		{
			addTechnique(mat, terrain, LOW_LOD);
			Material::LodValueList lodValues;
			lodValues.push_back(TerrainGlobalOptions::getSingleton().getCompositeMapDistance());
			mat->setLodLevels(lodValues);
			Technique* lowLodTechnique = mat->getTechnique(1);
			lowLodTechnique->setLodIndex(1);
		}
 
		updateParams(mat, terrain);
 
		return mat;
 
	}
Example #4
0
void TerrainMaterial::Profile::createMaterial(const String& matName, const Terrain* terrain, bool renderCompositeMap)
{
	sh::Factory::getInstance().destroyMaterialInstance(matName);

	MaterialPtr mat = MaterialManager::getSingleton().getByName(matName);
	if (!mat.isNull())
		MaterialManager::getSingleton().remove(matName);

	mMaterial = sh::Factory::getInstance().createMaterialInstance(matName);

	if (!renderCompositeMap)
	{
		MaterialPtr ogreMat = static_cast<sh::OgreMaterial*>(mMaterial->getMaterial())->getOgreMaterial();

		Material::LodValueList list;
		list.push_back(TerrainGlobalOptions::getSingleton().getCompositeMapDistance());
		ogreMat->setLodLevels(list);
	}

	mMaterial->setProperty("allow_fixed_function", sh::makeProperty<sh::BooleanValue>(new sh::BooleanValue(false)));

	sh::MaterialInstancePass* p = mMaterial->createPass();

	p->setProperty("vertex_program",   STR("terrain_vertex"));
	p->setProperty("fragment_program", STR("terrain_fragment"));

	p->mShaderProperties.setProperty("composite_map", sh::makeProperty<sh::BooleanValue>(new sh::BooleanValue(renderCompositeMap)));

	typedef sh::MaterialInstanceTextureUnit* MatTex;

	//  global normal map ?-
	MatTex normalMap = p->createTextureUnit("normalMap");
	normalMap->setProperty("direct_texture",   STR(terrain->getTerrainNormalMap()->getName()));
	normalMap->setProperty("tex_address_mode", STR("clamp"));

	//  light map
	MatTex lightMap = p->createTextureUnit("lightMap");
	lightMap->setProperty("direct_texture",   STR(terrain->getLightmap()->getName()));
	lightMap->setProperty("tex_address_mode", STR("clamp"));

	uint maxLayers = getMaxLayers(terrain),
		numBlendTextures = std::min(terrain->getBlendTextureCount(maxLayers), terrain->getBlendTextureCount()),  // = 1
		numLayers = std::min(maxLayers, static_cast<uint>(terrain->getLayerCount()));

	p->mShaderProperties.setProperty("num_layers",    STR(toStr(numLayers)));
	p->mShaderProperties.setProperty("num_blendmaps", STR(toStr(numBlendTextures)));

	//  blend maps
	for (uint i = 0; i < numBlendTextures; ++i)
	{
		MatTex blendTex = p->createTextureUnit("blendMap" + toStr(i));
		blendTex->setProperty("direct_texture",   STR("blendmapRTT"));
		blendTex->setProperty("tex_address_mode", STR("clamp"));
	}

	//  layer diffuse+spec
	for (uint i = 0; i < numLayers; ++i)
	{
		MatTex diffuseTex = p->createTextureUnit("diffuseMap" + toStr(i));
		diffuseTex->setProperty("direct_texture", STR(terrain->getLayerTextureName(i, 0)));
		p->mShaderProperties.setProperty("blendmap_component_" + toStr(i),
			STR(toStr(i / 4) + "." + getComponent(i % 4)));
	}

	//  layer normal+height
	for (uint i = 0; i < numLayers; ++i)
	{
		MatTex normalTex = p->createTextureUnit("normalMap" + toStr(i));
		normalTex->setProperty("direct_texture", STR(terrain->getLayerTextureName(i, 1)));
	}

	//  shadow
	if (!renderCompositeMap)
	{
		for (int i = 0; i < 3; ++i)
		{
			MatTex shadowTex = p->createTextureUnit("shadowMap" + toStr(i));
			shadowTex->setProperty("content_type", STR("shadow"));
		}
	}

	//  composite map
	MatTex compositeMap = p->createTextureUnit("compositeMap");
	compositeMap->setProperty("direct_texture", STR(terrain->getCompositeMap()->getName()));

	//  uv multipliers ?-
	uint numUVMul = numLayers / 4;
	if (numLayers % 4)
		++numUVMul;
	for (int i = 0; i < numUVMul; ++i)
	{
		int ii = i * 4;
		sh::Vector4* uvMul = new sh::Vector4(
			terrain->getLayerUVMultiplier(ii),     terrain->getLayerUVMultiplier(ii + 1),
			terrain->getLayerUVMultiplier(ii + 2), terrain->getLayerUVMultiplier(ii + 3) );

		for (int j=0; j<4; ++j)
		{
			p->mShaderProperties.setProperty("uv_component_" + toStr(i*4+j), STR(
				toStr(i) + "." + getComponent(j) ));
		}
		p->mShaderProperties.setProperty("uv_mul_" + toStr(i), sh::makeProperty<sh::Vector4>(uvMul));
	}
	p->mShaderProperties.setProperty("num_uv_mul", STR(toStr(numUVMul)));

	p->mShaderProperties.setProperty("shadowtexture_offset", STR(toStr(0)));
}