void CubeWorld::createWorldChunks (void)
{
//std::vector<int> VertexArray;
Ogre::MaterialPtr mat = Ogre::MaterialManager::getSingleton().create("BoxColor", "General", true );
Ogre::Technique* tech = mat->getTechnique(0);
Ogre::Pass* pass = tech->getPass(0);
Ogre::TextureUnitState* tex = pass->createTextureUnitState();
tex->setColourOperationEx(Ogre::LBX_MODULATE, Ogre::LBS_MANUAL, Ogre::LBS_CURRENT, Ogre::ColourValue(0, 0.5, 0));
Ogre::ManualObject* MeshChunk = new Ogre::ManualObject("MeshMatChunk");
MeshChunk->begin("TerrainImage");
for (int z = 0; z < WORLD_SIZE; z += CHUNK_SIZE)
{
for (int y = 0; y < WORLD_SIZE; y += CHUNK_SIZE)
{
for (int x = 0; x < WORLD_SIZE; x += CHUNK_SIZE)
{
createChunk(MeshChunk, x,y,z); /* WFaces or not */
//createChunkWater(x, y, z);
}
}
}
}
void CubeWorld::displaySimpleWorld (void)
{
Ogre::MaterialPtr mat = Ogre::MaterialManager::getSingleton().create("BoxColor", "General", true );
Ogre::Technique* tech = mat->getTechnique(0);
Ogre::Pass* pass = tech->getPass(0);
Ogre::TextureUnitState* tex = pass->createTextureUnitState();
tex->setColourOperationEx(Ogre::LBX_MODULATE, Ogre::LBS_MANUAL, Ogre::LBS_CURRENT, Ogre::ColourValue(0, 0.5, 0));
Ogre::ManualObject* testBox = createCubeMesh("TestBox1", "BoxColor");
Ogre::SceneNode* headNode = mSceneMgr->getRootSceneNode()->createChildSceneNode();
Ogre::MeshPtr Mesh = testBox->convertToMesh("TestBox2");
Ogre::StaticGeometry* pGeom = new Ogre::StaticGeometry (mSceneMgr, "Boxes");
Ogre::Entity* pEnt = mSceneMgr->createEntity("TestBox2");
pGeom->setRegionDimensions(Ogre::Vector3(300, 300, 300));
for (int z = 0; z < WORLD_SIZE; ++z)
{
for (int y = 0; y < WORLD_SIZE; ++y)
{
for (int x = 0; x < WORLD_SIZE; ++x)
{
if (GetBlock(x,y,z)) pGeom->addEntity(pEnt, Ogre::Vector3(x,y,z));
}
}
}
pGeom->build ();
}
void CubeWorld::updateSkyTextureLight (void)
{
if (m_SkyMaterial.isNull())
return;
Ogre::Technique* tech = m_SkyMaterial->getTechnique(0);
#if defined(__linux__) || defined(__APPLE__)
if (tech == NULL) return;
#else
if (tech == nullptr) return;
#endif
Ogre::Pass* pass = tech->getPass(0);
#if defined(__linux__) || defined(__APPLE__)
if (pass == NULL) return;
#else
if (pass == nulptr) return;
#endif
Ogre::TextureUnitState* tex = pass->getTextureUnitState(1);
#if defined(__linux__) || defined(__APPLE__)
if (tex == NULL) return;
#else
if (tex == nullptr) return;
#endif
// Update the texture unit's color operation with the world light level
tex->setColourOperationEx(Ogre::LBX_MODULATE, Ogre::LBS_MANUAL, Ogre::LBS_CURRENT, m_LightColor);
}
//--------------------------------------------------------------------------------
void MaterialUtil::updateSelectedVersion(const MaterialPtr& _material)
{
String name = _material->getName();
String selName = getSelectedVersionName(name);
MaterialPtr material, selectedMaterial;
if(selName == name)
{
name = getUnselectedVersionName(selName);
selectedMaterial = _material;
material = MaterialManager::getSingleton().getByName(name);
}
else
{
material = _material;
selectedMaterial = MaterialManager::getSingleton().getByName(selName);
}
if(!material.isNull() && !selectedMaterial.isNull())
{
material->copyDetailsTo(selectedMaterial);
Ogre::Technique* technique = selectedMaterial->getBestTechnique();
Pass* pass0 = technique->getPass(0);
Pass* passNew = technique->createPass();
passNew->setDiffuse(1, 1, 1, 1);
passNew->setPolygonMode(Ogre::PM_WIREFRAME);
if(pass0->getNumTextureUnitStates() != 0)
{
Ogre::TextureUnitState* tu = pass0->getTextureUnitState(0);
tu->setColourOperationEx(Ogre::LBX_MODULATE,
Ogre::LBS_TEXTURE, Ogre::LBS_MANUAL,
ColourValue::White, ColourValue(1, 0.6f, 0.6f, 1));
}
}
}
void OgreBtDebugDrawer::initialize(Ogre::SceneManager* const sceneManager,
const bool drawTrajectory) {
mDrawTrajectory = drawTrajectory;
mContactPoints = &mContactPoints1;
mLines = new Ogre::ManualObject("BulletPhysicsLines1");
mLines2 = new Ogre::ManualObject("BulletPhysicsLines2");
mTriangles = new Ogre::ManualObject("BulletPhysicsTriangles1");
mTriangles2 = new Ogre::ManualObject("BulletPhysicsTriangles2");
mLines->setDynamic(true);
mLines2->setDynamic(true);
mTriangles->setDynamic(true);
mTriangles2->setDynamic(true);
//mLines->estimateVertexCount( 100000 );
//mLines->estimateIndexCount( 0 );
sceneManager->getRootSceneNode()->attachObject(mLines);
sceneManager->getRootSceneNode()->attachObject(mLines2);
sceneManager->getRootSceneNode()->attachObject(mTriangles);
sceneManager->getRootSceneNode()->attachObject(mTriangles2);
static const char* matName = "OgreBulletCollisionsDebugDefault";
Ogre::MaterialPtr mtl =
Ogre::MaterialManager::getSingleton().getDefaultSettings()->clone(
matName);
mtl->setReceiveShadows(false);
mtl->setSceneBlending(Ogre::SBT_TRANSPARENT_ALPHA);
mtl->setDepthBias(0.1, 0);
Ogre::TextureUnitState * tu =
mtl->getTechnique(0)->getPass(0)->createTextureUnitState();
tu->setColourOperationEx(Ogre::LBX_SOURCE1, Ogre::LBS_DIFFUSE);
mtl->getTechnique(0)->setLightingEnabled(false);
//mtl->getTechnique(0)->setSelfIllumination( ColourValue::White );
//for the ogre text
Ogre::Root::getSingleton().addFrameListener(this);
//TODO: Add 3D text writing capability to ogreBtdebugdrawer #133.
// olm = Ogre::OverlayManager::getSingletonPtr();
// panel = static_cast<Ogre::OverlayContainer*>(olm->createOverlayElement(
// "Panel", "OGREBTDEBUGDRAWER_GUI"));
// panel->setMetricsMode(Ogre::GMM_PIXELS);
// panel->setPosition(0, 0);
// panel->setDimensions(1.0f, 1.0f);
// overlay = olm->create("OGREBTDEBUGDRAWER_OVERLAY");
// overlay->add2D(panel);
//
// szElement = "element_";
// overlay = olm->getByName("OGREBTDEBUGDRAWER_OVERLAY");
// panel = static_cast<Ogre::OverlayContainer*>(olm->getOverlayElement(
// "OGREBTDEBUGDRAWER_GUI"));
// textArea =
// static_cast<Ogre::TextAreaOverlayElement*>(olm->createOverlayElement(
// "TextArea", szElement));
// panel->addChild(textArea);
// overlay->show();
}
void CubeWorld::createSolidTexture (const TCHAR* pName)
{
Ogre::MaterialPtr mat = Ogre::MaterialManager::getSingleton().create("BoxColor", "General", true );
Ogre::Technique* tech = mat->getTechnique(0);
Ogre::Pass* pass = tech->getPass(0);
Ogre::TextureUnitState* tex = pass->createTextureUnitState();
tex->setColourOperationEx(Ogre::LBX_MODULATE, Ogre::LBS_MANUAL, Ogre::LBS_CURRENT, Ogre::ColourValue(0, 0.5, 0));
}
static void
SubEntity_tintColour(
SubEntity* self,
const String& groupName,
const String& materialName,
const Ogre::ColourValue& colour
) {
Ogre::MaterialPtr baseMaterial = Ogre::MaterialManager::getSingleton().getByName(materialName);
Ogre::MaterialPtr materialPtr = baseMaterial->clone(groupName);
materialPtr->compile();
Ogre::TextureUnitState* ptus = materialPtr->getTechnique(0)->getPass(0)->getTextureUnitState(0);
ptus->setColourOperationEx(Ogre::LBX_MODULATE, Ogre::LBS_MANUAL, Ogre::LBS_TEXTURE, colour);
self->setMaterial(materialPtr);
}
void
setupMaterial() {
Ogre::MaterialPtr material = Ogre::MaterialManager::getSingleton().getDefaultSettings()->clone(
MATERIAL_NAME
);
material->setReceiveShadows(false);
material->setSceneBlending(Ogre::SBT_TRANSPARENT_ALPHA);
material->setDepthBias(0.1, 0);
Ogre::TextureUnitState* textureUnitState = material->getTechnique(0)->getPass(0)->createTextureUnitState();
textureUnitState->setColourOperationEx(
Ogre::LBX_SOURCE1,
Ogre::LBS_DIFFUSE
);
material->getTechnique(0)->setLightingEnabled(false);
}
void CubeWorld::createWaterTexture (const TCHAR* pName)
{
Ogre::MaterialPtr mat = Ogre::MaterialManager::getSingleton().create(pName, "General", true );
Ogre::Technique* tech = mat->getTechnique(0);
Ogre::Pass* pass = tech->getPass(0);
Ogre::TextureUnitState* tex = pass->createTextureUnitState();
tech->setLightingEnabled(false);
pass->setSceneBlending(Ogre::SBT_TRANSPARENT_ALPHA);
pass->setDepthWriteEnabled(false);
tex->setColourOperationEx(Ogre::LBX_SOURCE1, Ogre::LBS_MANUAL, Ogre::LBS_CURRENT, Ogre::ColourValue(0, 0, 1));
tex->setAlphaOperation(Ogre::LBX_SOURCE1, Ogre::LBS_MANUAL, Ogre::LBS_CURRENT, 0.5);
}
void CubeWorld::createTexture (const TCHAR* pName, const TCHAR* pImageFilename)
{
Ogre::MaterialPtr mat = Ogre::MaterialManager::getSingleton().create(pName, "General", true );
Ogre::Technique* tech = mat->getTechnique(0);
Ogre::Pass* pass = tech->getPass(0);
Ogre::TextureUnitState* tex = pass->createTextureUnitState();
tex->setTextureName(pImageFilename);
tex->setNumMipmaps(4);
tex->setTextureAnisotropy(1);
tex->setTextureFiltering(Ogre::FO_POINT, Ogre::FO_POINT, Ogre::FO_POINT);
pass->setVertexColourTracking(Ogre::TVC_DIFFUSE);
tex->setColourOperationEx(Ogre::LBX_MODULATE, Ogre::LBS_DIFFUSE, Ogre::LBS_TEXTURE);
tech->setLightingEnabled(false);
}
Ogre::MaterialPtr OgrePlanarReflectionMaterial::createMaterial(const Ogre::TexturePtr& texture, const Ogre::Camera& projectionCamera)
{
using namespace::Ogre;
Ogre::MaterialPtr matPtr = MaterialManager::getSingleton().create(this->getName(),"General");
Ogre::TextureUnitState* t;
if(! textureFilename.getValue().empty() )
{
t = matPtr->getTechnique(0)->getPass(0)->createTextureUnitState(textureFilename.getValue());
}
t = matPtr->getTechnique(0)->getPass(0)->createTextureUnitState(texture->getName() );
t->setColourOperationEx(Ogre::LBX_BLEND_MANUAL, Ogre::LBS_TEXTURE, Ogre::LBS_CURRENT,
Ogre::ColourValue::White, Ogre::ColourValue::White,
blendingFactor.getValue());
t->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP);
t->setProjectiveTexturing(true,&projectionCamera);
matPtr->compile();
return matPtr;
}
void CubeWorld::createSkyTexture(const TCHAR* pName)
{
Ogre::MaterialPtr mat = Ogre::MaterialManager::getSingleton().create(pName, "General", true);
Ogre::Technique* tech = mat->getTechnique(0);
Ogre::Pass* pass = tech->getPass(0);
Ogre::TextureUnitState* tex = pass->createTextureUnitState();
pass->setLightingEnabled(false);
pass->setDepthCheckEnabled(false);
pass->setDepthWriteEnabled(false);
pass->setFog(true);
tex->setTextureName("clouds.jpg");
tex->setScrollAnimation(0.05, 0);
// This is a new texture state to simulate lightning
tex = pass->createTextureUnitState();
tex->setColourOperationEx(Ogre::LBX_MODULATE, Ogre::LBS_MANUAL, Ogre::LBS_CURRENT, Ogre::ColourValue(1, 1, 1));
m_SkyMaterial = mat;
updateSkyTextureLight();
}
// void TerrainPageSurfaceCompiler::addTextureUnitsToPass(Ogre::Pass* pass, const Ogre::String& splatTextureName) {
//
// if (getMaxTextureUnits() - pass->getNumTextureUnitStates() < 2 || pass->getParent()->getNumPasses() > 1) {
// addPassToTechnique(pass->getParent(), splatTextureName);
// // S_LOG_WARNING("Trying to add texture units to pass with too few available texture unit states.");
// return;
// }
//
// S_LOG_VERBOSE("Adding new texture unit (detailtexture: " << mTextureName << " alphatexture: " << splatTextureName << ") to pass nr " << pass->getIndex() << " in technique for material " << pass->getParent()->getParent()->getName());
//
// /* pass->setSelfIllumination(Ogre::ColourValue(1,1,1));
// pass->setAmbient(Ogre::ColourValue(1,1,1));
// pass->setDiffuse(Ogre::ColourValue(1,1,1));
// pass->setLightingEnabled(true);*/
// Ogre::TextureUnitState * textureUnitStateSplat = pass->createTextureUnitState();
// textureUnitStateSplat->setTextureName(splatTextureName);
//
// textureUnitStateSplat->setTextureCoordSet(0);
// textureUnitStateSplat->setTextureFiltering(Ogre::TFO_ANISOTROPIC);
// textureUnitStateSplat->setAlphaOperation(Ogre::LBX_SOURCE1, Ogre::LBS_TEXTURE, Ogre::LBS_TEXTURE);
// textureUnitStateSplat->setColourOperationEx(Ogre::LBX_SOURCE1, Ogre::LBS_CURRENT, Ogre::LBS_CURRENT);
// textureUnitStateSplat->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP);
// // textureUnitStateSplat->setColourOperationEx(Ogre::LBX_BLEND_DIFFUSE_ALPHA, Ogre::LBS_CURRENT, Ogre::LBS_TEXTURE);
// // textureUnitStateSplat->setColourOperationEx(Ogre::LBX_BLEND_TEXTURE_ALPHA, Ogre::LBS_CURRENT, Ogre::LBS_TEXTURE);
//
// Ogre::TextureUnitState * textureUnitState = pass->createTextureUnitState();
// textureUnitState->setTextureName(mTextureName);
// textureUnitState->setTextureAddressingMode(Ogre::TextureUnitState::TAM_WRAP);
// /* textureUnitState->setTextureCoordSet(0);*/
// textureUnitState->setTextureScale(0.025, 0.025);
// textureUnitState->setColourOperationEx(Ogre::LBX_BLEND_CURRENT_ALPHA, Ogre::LBS_TEXTURE, Ogre::LBS_CURRENT);
//
// /* Ogre::TextureUnitState * alphaTextureState= pass->createTextureUnitState();
// alphaTextureState->setTextureName(mTextureName);
// // alphaTextureState->setTextureName(splatTextureName);
// alphaTextureState->setTextureCoordSet(0);
// alphaTextureState->setTextureFiltering(Ogre::TFO_ANISOTROPIC);
// alphaTextureState->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP);
// alphaTextureState->setColourOperationEx(Ogre::LBX_BLEND_DIFFUSE_ALPHA, Ogre::LBS_CURRENT, Ogre::LBS_TEXTURE);
//
//
//
// // detailTextureState->setAlphaOperation(Ogre::LBX_SOURCE1, Ogre::LBS_TEXTURE, Ogre::LBS_TEXTURE);
// // detailTextureState->setColourOperationEx(Ogre::LBX_SOURCE1, Ogre::LBS_CURRENT, Ogre::LBS_CURRENT);
//
// Ogre::TextureUnitState * detailTextureState = pass->createTextureUnitState();
// detailTextureState ->setTextureName(splatTextureName);
// // detailTextureState ->setTextureName(mTextureName);
// detailTextureState ->setTextureAddressingMode(Ogre::TextureUnitState::TAM_WRAP);
// detailTextureState ->setTextureCoordSet(0);
// detailTextureState ->setTextureScale(0.01, 0.01);
// //detailTextureState ->setColourOperationEx(Ogre::LBX_BLEND_CURRENT_ALPHA, Ogre::LBS_TEXTURE, Ogre::LBS_CURRENT);*/
//
// }
//
Ogre::Pass* Simple::addPassToTechnique(const TerrainPageGeometry& geometry, Ogre::Technique* technique, const Layer& layer, std::set<std::string>& managedTextures) const
{
//check if we instead can reuse the existing pass
// if (technique->getNumPasses() != 0) {
// Ogre::Pass* pass = technique->getPass(technique->getNumPasses() - 1);
// if (4 - pass->getNumTextureUnitStates() >= 2) {
// //there's more than two texture units available, use those instead of creating a new pass
// S_LOG_VERBOSE("Reusing existing pass. ("<< pass->getNumTextureUnitStates() << " of "<< mNumberOfTextureUnitsOnCard << " texture unit used)");
// addTextureUnitsToPass(pass, splatTextureName);
// return pass;
// }
//
// }
const OgreImage& ogreImage = *layer.blendMap;
Ogre::Image image;
image.loadDynamicImage(const_cast<unsigned char*>(ogreImage.getData()), ogreImage.getResolution(), ogreImage.getResolution(), 1, Ogre::PF_A8);
std::stringstream splatTextureNameSS;
splatTextureNameSS << "terrain_" << mPage.getWFPosition().x() << "_" << mPage.getWFPosition().y() << "_" << technique->getNumPasses();
const Ogre::String splatTextureName(splatTextureNameSS.str());
Ogre::TexturePtr blendMapTexture;
if (Ogre::Root::getSingletonPtr()->getTextureManager()->resourceExists(splatTextureName)) {
blendMapTexture = static_cast<Ogre::TexturePtr>(Ogre::Root::getSingletonPtr()->getTextureManager()->getByName(splatTextureName));
blendMapTexture->loadImage(image);
Ogre::HardwarePixelBufferSharedPtr hardwareBuffer(blendMapTexture->getBuffer());
//blit the whole image to the hardware buffer
Ogre::PixelBox sourceBox(image.getPixelBox());
hardwareBuffer->blitFromMemory(sourceBox);
} else {
blendMapTexture = Ogre::Root::getSingletonPtr()->getTextureManager()->loadImage(splatTextureName, "General", image, Ogre::TEX_TYPE_2D, 0);
managedTextures.insert(blendMapTexture->getName());
}
//we need to create the image, update it and then destroy it again (to keep the memory usage down)
// if (layer->getBlendMapTextureName() == "") {
// //no texture yet; let's create one
// layer->createBlendMapImage();
// layer->updateBlendMapImage(geometry);
// layer->createTexture();
// } else {
// //a texture exists, so we just need to update the image
// layer->updateBlendMapImage(geometry); //calling this will also update the texture since the method will blit the image onto it
// }
Ogre::Pass* pass = technique->createPass();
pass->setSceneBlending(Ogre::SBT_TRANSPARENT_ALPHA);
pass->setAmbient(1, 1, 1);
pass->setDiffuse(1, 1, 1, 1);
pass->setLightingEnabled(false);
Ogre::TextureUnitState * textureUnitState = pass->createTextureUnitState();
textureUnitState->setTextureName(layer.surfaceLayer.getDiffuseTextureName());
textureUnitState->setTextureAddressingMode(Ogre::TextureUnitState::TAM_WRAP);
textureUnitState->setTextureCoordSet(0);
textureUnitState->setTextureScale(1.0f / layer.surfaceLayer.getScale(), 1.0f / layer.surfaceLayer.getScale());
Ogre::TextureUnitState * textureUnitStateSplat = pass->createTextureUnitState();
textureUnitStateSplat->setTextureName(blendMapTexture->getName());
textureUnitStateSplat->setTextureCoordSet(0);
textureUnitStateSplat->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP);
textureUnitStateSplat->setTextureFiltering(Ogre::TFO_ANISOTROPIC);
// textureUnitStateSplat->setAlphaOperation(Ogre::LBX_SOURCE1, Ogre::LBS_TEXTURE, Ogre::LBS_TEXTURE);
textureUnitStateSplat->setAlphaOperation(Ogre::LBX_BLEND_DIFFUSE_COLOUR, Ogre::LBS_TEXTURE, Ogre::LBS_CURRENT);
textureUnitStateSplat->setColourOperationEx(Ogre::LBX_SOURCE1, Ogre::LBS_CURRENT, Ogre::LBS_CURRENT);
return pass;
}
void gkMaterialLoader::loadSubMeshMaterial(gkSubMesh* mesh, const gkString& group)
{
using namespace Ogre;
gkMaterialProperties& gma = mesh->getMaterial();
if (gma.m_name.empty())
gma.m_name = "<gkBuiltin/DefaultMaterial>";
Ogre::MaterialPtr oma = Ogre::MaterialManager::getSingleton().getByName(gma.m_name.c_str(), group);
if (!oma.isNull())
return;
oma = Ogre::MaterialManager::getSingleton().create(gma.m_name, group);
if (gma.m_mode & gkMaterialProperties::MA_INVISIBLE)
{
// disable writing to this material
oma->setReceiveShadows(false);
oma->setColourWriteEnabled(false);
oma->setDepthWriteEnabled(false);
oma->setDepthCheckEnabled(false);
oma->setLightingEnabled(false);
return;
}
if (gma.m_mode & gkMaterialProperties::MA_TWOSIDE)
{
oma->setCullingMode(Ogre::CULL_NONE);
oma->setManualCullingMode(Ogre::MANUAL_CULL_NONE);
}
// apply lighting params
bool enableLights = (gma.m_mode & gkMaterialProperties::MA_LIGHTINGENABLED) != 0;
oma->setReceiveShadows((gma.m_mode & gkMaterialProperties::MA_RECEIVESHADOWS) != 0);
oma->setLightingEnabled(enableLights);
if (enableLights)
{
gkColor emissive, ambient, specular, diffuse;
emissive = gma.m_diffuse * gma.m_emissive;
ambient = gma.m_diffuse * gma.m_ambient;
specular = gma.m_specular * gma.m_spec;
diffuse = gma.m_diffuse * (gma.m_emissive + gma.m_refraction);
emissive.a = ambient.a = specular.a = 1.f;
oma->setSelfIllumination(emissive);
oma->setAmbient(ambient);
oma->setSpecular(specular);
oma->setDiffuse(diffuse);
oma->setShininess(gma.m_hardness);
}
Ogre::Pass* pass = oma->getTechnique(0)->getPass(0);
bool matBlending = gkEngine::getSingleton().getUserDefs().matblending;
if (matBlending && (gma.m_mode & gkMaterialProperties::MA_HASRAMPBLEND))
{
switch (gma.m_rblend)
{
case GK_BT_MULTIPLY:
pass->setSceneBlending(SBT_MODULATE);
break;
case GK_BT_SUBTRACT:
pass->setSceneBlending(SBF_ONE_MINUS_SOURCE_COLOUR, SBF_ONE);
break;
case GK_BT_DARKEN:
pass->setSceneBlendingOperation(SBO_MIN);
pass->setSceneBlending(SBF_ONE, SBF_ONE);
break;
case GK_BT_LIGHTEN:
pass->setSceneBlendingOperation(SBO_MAX);
pass->setSceneBlending(SBF_ONE, SBF_ONE);
break;
case GK_BT_SCREEN:
pass->setSceneBlending(SBF_ONE_MINUS_DEST_COLOUR, SBF_ONE);
break;
case GK_BT_ADDITIVE:
pass->setSceneBlending(SBT_ADD);
break;
case GK_BT_MIXTURE:
default:
pass->setSceneBlending(SBF_ONE, SBF_ZERO);
break;
}
}
bool hasNormap = false;
bool rtss = gkEngine::getSingleton().getUserDefs().rtss;
for (int i = 0; i < gma.m_totaltex; ++i)
{
gkTextureProperties& gte = gma.m_textures[i];
#ifdef OGREKIT_USE_RTSHADER_SYSTEM
if (gte.m_mode & gkTextureProperties::TM_NORMAL)
{
hasNormap = true;
continue;
}
#endif
Ogre::TextureUnitState* otus = pass->createTextureUnitState(gte.m_name, gte.m_layer);
LayerBlendOperationEx op = LBX_MODULATE;
switch (gte.m_blend)
{
case GK_BT_ADDITIVE:
op = LBX_ADD;
break;
case GK_BT_SUBTRACT:
op = LBX_SUBTRACT;
break;
case GK_BT_DARKEN:
case GK_BT_LIGHTEN:
case GK_BT_SCREEN:
case GK_BT_COLOR:
//break; TODO: support more mode
case GK_BT_MULTIPLY:
case GK_BT_MIXTURE:
default:
op = LBX_MODULATE;
break;
}
if (i == 0)
otus->setColourOperationEx(op, LBS_DIFFUSE, LBS_TEXTURE);
else
otus->setColourOperationEx(op);
otus->setTextureScale(gte.m_scale[0],gte.m_scale[1]);
}
if (gma.m_mode & gkMaterialProperties::MA_ALPHABLEND)
{
pass->setSceneBlending(Ogre::SBT_TRANSPARENT_ALPHA);
pass->setDepthWriteEnabled(false);
}
if (gma.m_mode & gkMaterialProperties::MA_ALPHACLIP)
{
pass->setAlphaRejectSettings(Ogre::CMPF_GREATER_EQUAL, 254);
}
#ifdef OGREKIT_USE_RTSHADER_SYSTEM
if (rtss)
{
//pass->setSpecular(ColourValue::Black);
//pass->setShininess(0.0);
RTShader::RenderState* rs = 0;
RTShader::ShaderGenerator* sg = Ogre::RTShader::ShaderGenerator::getSingletonPtr();
bool ok = sg->createShaderBasedTechnique(gma.m_name, group,
Ogre::MaterialManager::DEFAULT_SCHEME_NAME, Ogre::RTShader::ShaderGenerator::DEFAULT_SCHEME_NAME);
if (ok && hasNormap)
{
rs = sg->getRenderState(RTShader::ShaderGenerator::DEFAULT_SCHEME_NAME, gma.m_name, 0);
rs->reset();
for (int i = 0; i < gma.m_totaltex; ++i)
{
gkTextureProperties& gte = gma.m_textures[i];
if (gte.m_mode & gkTextureProperties::TM_NORMAL)
{
GK_ASSERT(rs);
RTShader::SubRenderState* srs= sg->createSubRenderState(RTShader::NormalMapLighting::Type);
RTShader::NormalMapLighting* nsrs = static_cast<RTShader::NormalMapLighting*>(srs);
if (gte.m_texmode & gkTextureProperties::TX_OBJ_SPACE)
nsrs->setNormalMapSpace(RTShader::NormalMapLighting::NMS_OBJECT);
else
nsrs->setNormalMapSpace(RTShader::NormalMapLighting::NMS_TANGENT);
nsrs->setNormalMapTextureName(gte.m_name);
nsrs->setTexCoordIndex(gte.m_layer);
rs->addTemplateSubRenderState(srs);
}
}
sg->invalidateMaterial(RTShader::ShaderGenerator::DEFAULT_SCHEME_NAME, gma.m_name);
}
}
#endif
}
// 设置选中的外观颜色.
void CEditDobject_NT::SetSelectLook(Ogre::ColourValue color)
{
if(0 == m_materialSelVector.size())
{
// 选中材质的名字.
Ogre::String strCloneName;
int iCount = m_EntityList.size();
Ogre::Entity* pEntity = NULL;
for(int i = 0; i < iCount; i++)
{
pEntity = m_EntityList[i].pEntity;
if(pEntity)
{
Ogre::SubEntity* pSubEntiy = pEntity->getSubEntity(0);
if(pSubEntiy)
{
Ogre::MaterialPtr pMaterial = pSubEntiy->getMaterial();
if(pMaterial.isNull())
{
return;
}//
const Ogre::String& strName = pMaterial->getName();
if("BaseWhite" == strName)
{
continue;
}
strCloneName = strName;
strCloneName += "_select";
Ogre::MaterialManager* pMaterialManager = (Ogre::MaterialManager*)(pMaterial->getCreator());
if(NULL == pMaterialManager)
{
return;
}
Ogre::MaterialPtr pMaterialClone = pMaterialManager->getByName(strCloneName);
if(pMaterialClone.isNull())
{
pMaterialClone = pMaterial->clone(strCloneName);
}
//if(!pMaterialClone)
//{
// return;
//}//
Ogre::Technique* pTechnique = pMaterialClone->getBestTechnique();
Ogre::Pass* pPass = pTechnique->getPass(0);
//pPass->setSceneBlending(SBT_ADD);
//pPass->setSceneBlending(SBF_SOURCE_ALPHA , SBF_ONE_MINUS_SOURCE_ALPHA );
//pTextureState->setAlphaOperation(LBX_MODULATE, LBS_TEXTURE, LBS_MANUAL, 1, Transparence, 1);//
Ogre::TextureUnitState* pTextureState = pPass->getTextureUnitState(0);
pTextureState->setColourOperationEx(Ogre::LBX_ADD , Ogre::LBS_TEXTURE , Ogre::LBS_MANUAL, color, color );
pSubEntiy->setMaterialName(strCloneName);
m_materialSelVector.push_back(pMaterialClone);
m_materilaOldVector.push_back(pMaterial);
}
}
}
}
else
{
int iIndex = 0;
int iCount = m_EntityList.size();
Ogre::Entity* pEntity = NULL;
for(int i = 0; i < iCount; i++)
{
pEntity = m_EntityList[i].pEntity;
if(pEntity)
{
Ogre::SubEntity* pSubEntiy = pEntity->getSubEntity(0);
if(pSubEntiy)
{
if(iIndex >= (int)m_materialSelVector.size())
{
continue;
}
std::string strMaterialName = m_materialSelVector[iIndex]->getName();
pSubEntiy->setMaterialName(strMaterialName);
iIndex++;
}
}
}
}
}
bool LagomPlayerBase::Update(float time_elapsed)
{
_health += getIntFactory().HealthRegeneration*time_elapsed/1000.0f;
if(_health >= getIntFactory().Health)
_health = getIntFactory().Health;
_factoryHighlightRemaining -= time_elapsed;
if(_factoryHighlightRemaining < 0.0f)
_factoryHighlightRemaining = 0.0f;
float newCooldown = _buildCooldown - time_elapsed;
if( (newCooldown > 0.0f) != (_buildCooldown > 0.0f))
_factoryHighlightRemaining = getIntFactory().ConstructionHighlightTime;
_buildCooldown = newCooldown;
Ogre::ColourValue playerColor = Lagom::getSingleton().GetPlayerColor();
Ogre::ColourValue staticColor = playerColor*.05f + Ogre::ColourValue(.1,.1,.1,.0f);
Ogre::ColourValue pulseColor = playerColor * _state.GetPulsePower();
_materialInstance->setCustomParameter(0,Ogre::Vector4(staticColor.r,staticColor.g,staticColor.b,.0f));
_materialInstance->setCustomParameter(1,Ogre::Vector4(pulseColor.r,pulseColor.g,pulseColor.b,_state.GetPulseTime()));
if( _selectedActorFactory !=_actorFactories.end() && _selectedActorFactory->second != _constructionObject)
{
if(_constructionObject)
_sceneNode->removeChild(_constructionObject);
_constructionObject=_selectedActorFactory->second;
_constructionObject->setPosition(getIntFactory().ConstructionOffset);
if(_constructionObject)
_sceneNode->addChild(_constructionObject);
}
if(_constructionObject)
{
Ogre::ColourValue constructionColour(0.0f,0.0f,0.0f,0.0f);
float constructionAlpha = 1.0f;
if(_draggingConstruction)
{
if(checkConstructionRestriction(_selectedActorFactory->first,_currentDragLocation))
constructionColour=playerColor;
else
constructionColour=Ogre::ColourValue::Black;
}
else if(_buildCooldown <= 0.0f)
{
if(_hoverConstructing)
constructionColour = Ogre::ColourValue::White;
else if(_factoryHighlightRemaining>= 0.0f)
{
float highlight = _factoryHighlightRemaining / getIntFactory().ConstructionHighlightTime;
float rev_h = 1.0f - highlight;
constructionColour = Ogre::ColourValue(playerColor.r*rev_h + highlight,playerColor.g*rev_h + highlight,playerColor.b*rev_h + highlight,1.0f);
}
else
constructionColour=playerColor;
}
else
{
constructionAlpha = std::max(std::min(1.0f - _buildCooldown / _buildCooldownMax,1.0f),0.0f);
constructionAlpha *= getIntFactory().ConstructionAlphaFactor;
}
Ogre::MaterialPtr materialPtr = Ogre::MaterialManager::getSingleton().getByName(getIntFactory().ConstructingMaterial);
Ogre::TextureUnitState* ptus = materialPtr->getTechnique(0)->getPass(0)->getTextureUnitState(0); //1st pass, first texture unit
Ogre::TextureUnitState* ptus2 = materialPtr->getTechnique(0)->getPass(1)->getTextureUnitState(0); //2nd pass, first texture unit
ptus->setColourOperationEx(Ogre::LBX_SOURCE1, Ogre::LBS_MANUAL, Ogre::LBS_TEXTURE, constructionColour);
ptus->setAlphaOperation(Ogre::LBX_SOURCE1, Ogre::LBS_MANUAL, Ogre::LBS_TEXTURE, .25f * constructionAlpha);
ptus2->setColourOperationEx(Ogre::LBX_SOURCE1, Ogre::LBS_MANUAL, Ogre::LBS_TEXTURE, constructionColour);
ptus2->setAlphaOperation(Ogre::LBX_SOURCE1, Ogre::LBS_MANUAL, Ogre::LBS_TEXTURE, .25f* constructionAlpha);
if(!_draggingConstruction)
{
float rotation_speed = time_elapsed / 500.0f;
Ogre::Quaternion rot1;
rot1.FromAngleAxis(Ogre::Radian(rotation_speed), Ogre::Vector3( 0.0f , 1.0f, 0.0f).normalisedCopy() );
_constructionObject->rotate( rot1);
}
else
{
_constructionObject->setOrientation(1.0f,0.0f,0.0f,0.0f);
static_cast<Ogre::Entity*>(_constructionObject->getAttachedObject(0))->setMaterialName(getIntFactory().ConstructingMaterial);
}
}
_energy = 1000.0f;
if(_health <= 0.0f)
return false;
return true;
}
Ogre::MaterialPtr MaterialGenerator::create(bool renderCompositeMap, bool displayCompositeMap)
{
assert(!renderCompositeMap || !displayCompositeMap);
static int count = 0;
std::stringstream name;
name << "terrain/mat" << count++;
if (!mShaders)
{
Ogre::MaterialPtr mat = Ogre::MaterialManager::getSingleton().create(name.str(),
Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
Ogre::Technique* technique = mat->getTechnique(0);
technique->removeAllPasses();
if (displayCompositeMap)
{
Ogre::Pass* pass = technique->createPass();
pass->setVertexColourTracking(Ogre::TVC_AMBIENT|Ogre::TVC_DIFFUSE);
pass->createTextureUnitState(mCompositeMap)->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP);
}
else
{
assert(mLayerList.size() == mBlendmapList.size()+1);
std::vector<Ogre::TexturePtr>::iterator blend = mBlendmapList.begin();
for (std::vector<LayerInfo>::iterator layer = mLayerList.begin(); layer != mLayerList.end(); ++layer)
{
Ogre::Pass* pass = technique->createPass();
pass->setLightingEnabled(false);
pass->setVertexColourTracking(Ogre::TVC_NONE);
// TODO: How to handle fog?
pass->setFog(true, Ogre::FOG_NONE);
bool first = (layer == mLayerList.begin());
Ogre::TextureUnitState* tus;
if (!first)
{
pass->setSceneBlending(Ogre::SBT_TRANSPARENT_ALPHA);
pass->setDepthFunction(Ogre::CMPF_EQUAL);
tus = pass->createTextureUnitState((*blend)->getName());
tus->setAlphaOperation(Ogre::LBX_BLEND_TEXTURE_ALPHA,
Ogre::LBS_TEXTURE,
Ogre::LBS_TEXTURE);
tus->setColourOperationEx(Ogre::LBX_BLEND_DIFFUSE_ALPHA,
Ogre::LBS_TEXTURE,
Ogre::LBS_TEXTURE);
tus->setIsAlpha(true);
tus->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP);
float scale = (16/(16.f+1.f));
tus->setTextureScale(1.f/scale,1.f/scale);
}
// Add the actual layer texture on top of the alpha map.
tus = pass->createTextureUnitState(layer->mDiffuseMap);
if (!first)
tus->setColourOperationEx(Ogre::LBX_BLEND_DIFFUSE_ALPHA,
Ogre::LBS_TEXTURE,
Ogre::LBS_CURRENT);
tus->setTextureScale(1/16.f,1/16.f);
if (!first)
++blend;
}
if (!renderCompositeMap)
{
Ogre::Pass* lightingPass = technique->createPass();
lightingPass->setSceneBlending(Ogre::SBT_MODULATE);
lightingPass->setVertexColourTracking(Ogre::TVC_AMBIENT|Ogre::TVC_DIFFUSE);
lightingPass->setFog(true, Ogre::FOG_NONE);
}
}
return mat;
}
#if TERRAIN_USE_SHADER
else
{
sh::MaterialInstance* material = sh::Factory::getInstance().createMaterialInstance (name.str());
material->setProperty ("allow_fixed_function", sh::makeProperty<sh::BooleanValue>(new sh::BooleanValue(false)));
if (displayCompositeMap)
{
sh::MaterialInstancePass* p = material->createPass ();
p->setProperty ("vertex_program", sh::makeProperty<sh::StringValue>(new sh::StringValue("terrain_vertex")));
p->setProperty ("fragment_program", sh::makeProperty<sh::StringValue>(new sh::StringValue("terrain_fragment")));
p->mShaderProperties.setProperty ("is_first_pass", sh::makeProperty(new sh::BooleanValue(true)));
p->mShaderProperties.setProperty ("render_composite_map", sh::makeProperty(new sh::BooleanValue(false)));
p->mShaderProperties.setProperty ("display_composite_map", sh::makeProperty(new sh::BooleanValue(true)));
p->mShaderProperties.setProperty ("num_layers", sh::makeProperty (new sh::StringValue("0")));
p->mShaderProperties.setProperty ("num_blendmaps", sh::makeProperty (new sh::StringValue("0")));
p->mShaderProperties.setProperty ("normal_map_enabled", sh::makeProperty (new sh::BooleanValue(false)));
p->mShaderProperties.setProperty ("parallax_enabled", sh::makeProperty (new sh::BooleanValue(false)));
p->mShaderProperties.setProperty ("normal_maps",
sh::makeProperty (new sh::IntValue(0)));
sh::MaterialInstanceTextureUnit* tex = p->createTextureUnit ("compositeMap");
tex->setProperty ("direct_texture", sh::makeProperty (new sh::StringValue(mCompositeMap)));
tex->setProperty ("tex_address_mode", sh::makeProperty (new sh::StringValue("clamp")));
// shadow. TODO: repeated, put in function
if (mShadows)
{
for (int i = 0; i < (mSplitShadows ? 3 : 1); ++i)
{
sh::MaterialInstanceTextureUnit* shadowTex = p->createTextureUnit ("shadowMap" + Ogre::StringConverter::toString(i));
shadowTex->setProperty ("content_type", sh::makeProperty<sh::StringValue> (new sh::StringValue("shadow")));
}
}
p->mShaderProperties.setProperty ("shadowtexture_offset", sh::makeProperty (new sh::StringValue(
Ogre::StringConverter::toString(1))));
p->mShaderProperties.setProperty ("pass_index", sh::makeProperty(new sh::IntValue(0)));
}
else
{
bool shadows = mShadows && !renderCompositeMap;
int layerOffset = 0;
while (layerOffset < (int)mLayerList.size())
{
int blendmapOffset = (layerOffset == 0) ? 1 : 0; // the first layer of the first pass is the base layer and does not need a blend map
// Check how many layers we can fit in this pass
int numLayersInThisPass = 0;
int numBlendTextures = 0;
std::vector<std::string> blendTextures;
int remainingTextureUnits = OGRE_MAX_TEXTURE_LAYERS;
if (shadows)
remainingTextureUnits -= (mSplitShadows ? 3 : 1);
while (remainingTextureUnits && layerOffset + numLayersInThisPass < (int)mLayerList.size())
{
int layerIndex = numLayersInThisPass + layerOffset;
int neededTextureUnits=0;
int neededBlendTextures=0;
if (layerIndex != 0)
{
std::string blendTextureName = mBlendmapList[getBlendmapIndexForLayer(layerIndex)]->getName();
if (std::find(blendTextures.begin(), blendTextures.end(), blendTextureName) == blendTextures.end())
{
blendTextures.push_back(blendTextureName);
++neededBlendTextures;
++neededTextureUnits; // blend texture
}
}
++neededTextureUnits; // layer texture
// Check if this layer has a normal map
if (mNormalMapping && !mLayerList[layerIndex].mNormalMap.empty() && !renderCompositeMap)
++neededTextureUnits; // normal map
if (neededTextureUnits <= remainingTextureUnits)
{
// We can fit another!
remainingTextureUnits -= neededTextureUnits;
numBlendTextures += neededBlendTextures;
++numLayersInThisPass;
}
else
break; // We're full
}
sh::MaterialInstancePass* p = material->createPass ();
p->setProperty ("vertex_program", sh::makeProperty<sh::StringValue>(new sh::StringValue("terrain_vertex")));
p->setProperty ("fragment_program", sh::makeProperty<sh::StringValue>(new sh::StringValue("terrain_fragment")));
if (layerOffset != 0)
{
p->setProperty ("scene_blend", sh::makeProperty(new sh::StringValue("alpha_blend")));
// Only write if depth is equal to the depth value written by the previous pass.
p->setProperty ("depth_func", sh::makeProperty(new sh::StringValue("equal")));
}
p->mShaderProperties.setProperty ("render_composite_map", sh::makeProperty(new sh::BooleanValue(renderCompositeMap)));
p->mShaderProperties.setProperty ("display_composite_map", sh::makeProperty(new sh::BooleanValue(displayCompositeMap)));
p->mShaderProperties.setProperty ("num_layers", sh::makeProperty (new sh::StringValue(Ogre::StringConverter::toString(numLayersInThisPass))));
p->mShaderProperties.setProperty ("num_blendmaps", sh::makeProperty (new sh::StringValue(Ogre::StringConverter::toString(numBlendTextures))));
p->mShaderProperties.setProperty ("normal_map_enabled",
sh::makeProperty (new sh::BooleanValue(false)));
// blend maps
// the index of the first blend map used in this pass
int blendmapStart;
if (mLayerList.size() == 1) // special case. if there's only one layer, we don't need blend maps at all
blendmapStart = 0;
else
blendmapStart = getBlendmapIndexForLayer(layerOffset+blendmapOffset);
for (int i = 0; i < numBlendTextures; ++i)
{
sh::MaterialInstanceTextureUnit* blendTex = p->createTextureUnit ("blendMap" + Ogre::StringConverter::toString(i));
blendTex->setProperty ("direct_texture", sh::makeProperty (new sh::StringValue(mBlendmapList[blendmapStart+i]->getName())));
blendTex->setProperty ("tex_address_mode", sh::makeProperty (new sh::StringValue("clamp")));
}
// layer maps
bool anyNormalMaps = false;
bool anyParallax = false;
size_t normalMaps = 0;
for (int i = 0; i < numLayersInThisPass; ++i)
{
const LayerInfo& layer = mLayerList[layerOffset+i];
// diffuse map
sh::MaterialInstanceTextureUnit* diffuseTex = p->createTextureUnit ("diffuseMap" + Ogre::StringConverter::toString(i));
diffuseTex->setProperty ("direct_texture", sh::makeProperty (new sh::StringValue(layer.mDiffuseMap)));
// normal map (optional)
bool useNormalMap = mNormalMapping && !mLayerList[layerOffset+i].mNormalMap.empty() && !renderCompositeMap;
bool useParallax = useNormalMap && mParallaxMapping && layer.mParallax;
bool useSpecular = layer.mSpecular;
if (useNormalMap)
{
anyNormalMaps = true;
anyParallax = anyParallax || useParallax;
sh::MaterialInstanceTextureUnit* normalTex = p->createTextureUnit ("normalMap" + Ogre::StringConverter::toString(i));
normalTex->setProperty ("direct_texture", sh::makeProperty (new sh::StringValue(layer.mNormalMap)));
}
p->mShaderProperties.setProperty ("use_normal_map_" + Ogre::StringConverter::toString(i),
sh::makeProperty (new sh::BooleanValue(useNormalMap)));
p->mShaderProperties.setProperty ("use_parallax_" + Ogre::StringConverter::toString(i),
sh::makeProperty (new sh::BooleanValue(useParallax)));
p->mShaderProperties.setProperty ("use_specular_" + Ogre::StringConverter::toString(i),
sh::makeProperty (new sh::BooleanValue(useSpecular)));
boost::hash_combine(normalMaps, useNormalMap);
boost::hash_combine(normalMaps, useNormalMap && layer.mParallax);
boost::hash_combine(normalMaps, useSpecular);
if (i+layerOffset > 0)
{
int blendTextureIndex = getBlendmapIndexForLayer(layerOffset+i);
std::string blendTextureComponent = getBlendmapComponentForLayer(layerOffset+i);
p->mShaderProperties.setProperty ("blendmap_component_" + Ogre::StringConverter::toString(i),
sh::makeProperty (new sh::StringValue(Ogre::StringConverter::toString(blendTextureIndex-blendmapStart) + "." + blendTextureComponent)));
}
else
{
// just to make it shut up about blendmap_component_0 not existing in the first pass.
// it might be retrieved, but will never survive the preprocessing step.
p->mShaderProperties.setProperty ("blendmap_component_" + Ogre::StringConverter::toString(i),
sh::makeProperty (new sh::StringValue("")));
}
}
p->mShaderProperties.setProperty ("normal_map_enabled",
sh::makeProperty (new sh::BooleanValue(anyNormalMaps)));
p->mShaderProperties.setProperty ("parallax_enabled",
sh::makeProperty (new sh::BooleanValue(anyParallax)));
// Since the permutation handler can't handle dynamic property names,
// combine normal map settings for all layers into one value
p->mShaderProperties.setProperty ("normal_maps",
sh::makeProperty (new sh::IntValue(normalMaps)));
// shadow
if (shadows)
{
for (int i = 0; i < (mSplitShadows ? 3 : 1); ++i)
{
sh::MaterialInstanceTextureUnit* shadowTex = p->createTextureUnit ("shadowMap" + Ogre::StringConverter::toString(i));
shadowTex->setProperty ("content_type", sh::makeProperty<sh::StringValue> (new sh::StringValue("shadow")));
}
}
p->mShaderProperties.setProperty ("shadowtexture_offset", sh::makeProperty (new sh::StringValue(
Ogre::StringConverter::toString(numBlendTextures + numLayersInThisPass))));
// Make sure the pass index is fed to the permutation handler, because blendmap components may be different
p->mShaderProperties.setProperty ("pass_index", sh::makeProperty(new sh::IntValue(layerOffset)));
assert ((int)p->mTexUnits.size() == OGRE_MAX_TEXTURE_LAYERS - remainingTextureUnits);
layerOffset += numLayersInThisPass;
}
}
}
#endif
return Ogre::MaterialManager::getSingleton().getByName(name.str());
}