static int lua_Pass_getParameterByIndex(lua_State* state)
{
// Get the number of parameters.
int paramCount = lua_gettop(state);
// Attempt to match the parameters to a valid binding.
switch (paramCount)
{
case 2:
{
if ((lua_type(state, 1) == LUA_TUSERDATA) &&
lua_type(state, 2) == LUA_TNUMBER)
{
// Get parameter 1 off the stack.
unsigned int param1 = (unsigned int)luaL_checkunsigned(state, 2);
Pass* instance = getInstance(state);
void* returnPtr = ((void*)instance->getParameterByIndex(param1));
if (returnPtr)
{
gameplay::ScriptUtil::LuaObject* object = (gameplay::ScriptUtil::LuaObject*)lua_newuserdata(state, sizeof(gameplay::ScriptUtil::LuaObject));
object->instance = returnPtr;
object->owns = false;
luaL_getmetatable(state, "MaterialParameter");
lua_setmetatable(state, -2);
}
else
{
lua_pushnil(state);
}
return 1;
}
lua_pushstring(state, "lua_Pass_getParameterByIndex - Failed to match the given parameters to a valid function signature.");
lua_error(state);
break;
}
default:
{
lua_pushstring(state, "Invalid number of parameters (expected 2).");
lua_error(state);
break;
}
}
return 0;
}
bool hasParameter( Material* material, const char* name )
{
unsigned int mc = material->getTechniqueCount();
for (unsigned int i = 0; i < mc; ++i)
{
Technique *tech = material->getTechniqueByIndex( i );
unsigned int pc = tech->getPassCount();
for (unsigned int j = 0; j < pc; ++j)
{
Pass *pass = tech->getPassByIndex(j);
Effect *effect = pass->getEffect();
if (effect->getUniform( name ) != NULL)
return true;
}
}
return false;
}
// HUD utils
//---------------------------------------------------------------------------------------------------------------
void CHud::UpdMiniTer()
{
MaterialPtr mm = MaterialManager::getSingleton().getByName("circle_minimap");
Pass* pass = mm->getTechnique(0)->getPass(0);
if (!pass) return;
try
{ GpuProgramParametersSharedPtr par = pass->getFragmentProgramParameters();
bool ter = app->scn->sc->ter;
if (par->_findNamedConstantDefinition("showTerrain",false))
par->setNamedConstant("showTerrain", pSet->mini_terrain && ter ? 1.f : 0.f);
if (par->_findNamedConstantDefinition("showBorder",false))
par->setNamedConstant("showBorder", pSet->mini_border && ter ? 1.f : 0.f);
if (par->_findNamedConstantDefinition("square",false))
par->setNamedConstant("square", pSet->mini_zoomed && ter ? 0.f : 1.f);
}
catch(...){ }
}
int lua_Pass_getVertexAttributeBinding(lua_State* state)
{
// Get the number of parameters.
int paramCount = lua_gettop(state);
// Attempt to match the parameters to a valid binding.
switch (paramCount)
{
case 1:
{
if ((lua_type(state, 1) == LUA_TUSERDATA))
{
Pass* instance = getInstance(state);
void* returnPtr = (void*)instance->getVertexAttributeBinding();
if (returnPtr)
{
ScriptUtil::LuaObject* object = (ScriptUtil::LuaObject*)lua_newuserdata(state, sizeof(ScriptUtil::LuaObject));
object->instance = returnPtr;
object->owns = false;
luaL_getmetatable(state, "VertexAttributeBinding");
lua_setmetatable(state, -2);
}
else
{
lua_pushnil(state);
}
return 1;
}
else
{
lua_pushstring(state, "lua_Pass_getVertexAttributeBinding - Failed to match the given parameters to a valid function signature.");
lua_error(state);
}
break;
}
default:
{
lua_pushstring(state, "Invalid number of parameters (expected 1).");
lua_error(state);
break;
}
}
return 0;
}
Material* MaterialCache2D::CreateMaterial(Texture2D* texture, BlendMode blendMode)
{
Material* material = new Material(context_);
if (texture)
material->SetName(texture->GetName() + "_" + blendModeNames[blendMode]);
else
material->SetName(blendModeNames[blendMode]);
Technique* tech = new Technique(context_);
Pass* pass = tech->CreatePass(PASS_ALPHA);
pass->SetBlendMode(blendMode);
pass->SetVertexShader("Basic");
pass->SetVertexShaderDefines("DIFFMAP VERTEXCOLOR");
pass->SetPixelShader("Basic");
pass->SetPixelShaderDefines("DIFFMAP VERTEXCOLOR");
pass->SetDepthWrite(false);
material->SetTechnique(0, tech);
material->SetCullMode(CULL_NONE);
material->SetTexture(TU_DIFFUSE, texture);
return material;
}
void DepthOfFieldListener::notifyMaterialSetup(uint32 pass_id, MaterialPtr &mat)
{
if (pass_id == 1)
{
float blurScale =.5f;
Vector4 pixelSize(1.0f / (mViewportWidth * blurScale), 1.0f / (mViewportHeight * blurScale), 0.0f, 0.0f);
mat->load();
Pass *pass = mat->getBestTechnique()->getPass(0);
GpuProgramParametersSharedPtr params = pass->getFragmentProgramParameters();
if (params->_findNamedConstantDefinition("pixelSize"))
params->setNamedConstant("pixelSize", pixelSize);
}
else if (pass_id == 2)
{
float blurScale =.5f;
Vector4 pixelSize(1.0f / mViewportWidth, 1.0f / mViewportHeight,1.0f / (mViewportWidth * blurScale), 1.0f / (mViewportHeight * blurScale) );
Pass *pass = mat->getBestTechnique()->getPass(0);
GpuProgramParametersSharedPtr params = pass->getFragmentProgramParameters();
if (params->_findNamedConstantDefinition("pixelSize"))
params->setNamedConstant("pixelSize", pixelSize);
// this is the camera you're using
#ifndef SR_EDITOR
Camera *cam = mApp->mSplitMgr->mCameras.front();
#else
Camera *cam = mApp->mCamera;
#endif
if (params->_findNamedConstantDefinition("far"))
params->setNamedConstant("far", cam->getFarClipDistance());
if (params->_findNamedConstantDefinition("dofparams"))
{
Vector4 dofParams(0.0f,mApp->pSet->dof_focus,mApp->pSet->dof_far,1.0);
params->setNamedConstant("dofparams", dofParams);
}
}
}
//------------------------------------------------------------------------------//
void ShaderTranslator::translate(ScriptNodePtr& pScriptNode, const String& group)
{
ShaderType st;
if (pScriptNode->name == "vertex_shader")
{
st = ST_VERTEX_SHADER;
}
else if (pScriptNode->name == "pixel_shader")
{
st = ST_PIXEL_SHADER;
}
StringKeyValueMap::iterator it = pScriptNode->keyValueMap.find("name");
if(it == pScriptNode->keyValueMap.end())
{
TITAN_EXCEPT_ITEMLOST(
"The vertex shader must have name attribute"
);
return;
}
String shaderName = it->second;
ShaderPtr pShader = ShaderMgr::getSingleton().create(shaderName, group, st);
pScriptNode->keyValueMap.erase(it);
//set shader attributes
pShader->setParams(pScriptNode->keyValueMap);
ShaderParamsPtr pParams = pShader->getShaderParams();
ScriptNodePtrList::iterator sit = pScriptNode->children.begin(), sitEnd = pScriptNode->children.end();
while (sit != sitEnd)
{
translateShaderParam(*sit, pParams);
++sit;
}
Pass* parent = any_cast<Pass*>(pScriptNode->parent->createObj);
if(st == ST_VERTEX_SHADER)
{
parent->setVertexShader(shaderName);
}
else if(st == ST_PIXEL_SHADER)
{
parent->setPixelShader(shaderName);
}
}
void MeshBatch::updateVertexAttributeBinding()
{
GP_ASSERT(_material);
// Update our vertex attribute bindings.
for (unsigned int i = 0, techniqueCount = _material->getTechniqueCount(); i < techniqueCount; ++i)
{
Technique* t = _material->getTechniqueByIndex(i);
GP_ASSERT(t);
for (unsigned int j = 0, passCount = t->getPassCount(); j < passCount; ++j)
{
Pass* p = t->getPassByIndex(j);
GP_ASSERT(p);
VertexAttributeBinding* b = VertexAttributeBinding::create(_vertexFormat, _vertices, p->getEffect());
p->setVertexAttributeBinding(b);
SAFE_RELEASE(b);
}
}
}
void PlayPen_testManualBlend::setupContent()
{
// create material
MaterialPtr mat = MaterialManager::getSingleton().create("TestMat",
TRANSIENT_RESOURCE_GROUP);
Pass * p = mat->getTechnique(0)->getPass(0);
p->setLightingEnabled(false);
p->createTextureUnitState("Dirt.jpg");
TextureUnitState* t = p->createTextureUnitState("ogrelogo.png");
t->setColourOperationEx(LBX_BLEND_MANUAL, LBS_TEXTURE, LBS_CURRENT,
ColourValue::White, ColourValue::White, 0.75);
Entity *planeEnt = mSceneMgr->createEntity("Plane", SceneManager::PT_PLANE);
mSceneMgr->getRootSceneNode()->createChildSceneNode()->attachObject(planeEnt);
planeEnt->setMaterialName("TestMat");
mCamera->setPosition(0,0,600);
mCamera->lookAt(Vector3::ZERO);
}
//-------------------------------------------------------------------------------------------------------
// utility
//-------------------------------------------------------------------------------------------------------
void CarModel::UpdateLightMap()
{
MaterialPtr mtr;
for (int i=0; i < NumMaterials; ++i)
{
mtr = MaterialManager::getSingleton().getByName(sMtr[i]);
if (!mtr.isNull())
{ Material::TechniqueIterator techIt = mtr->getTechniqueIterator();
while (techIt.hasMoreElements())
{ Technique* tech = techIt.getNext();
Technique::PassIterator passIt = tech->getPassIterator();
while (passIt.hasMoreElements())
{ Pass* pass = passIt.getNext();
if (pass->hasFragmentProgram())
{
GpuProgramParametersSharedPtr params = pass->getFragmentProgramParameters();
params->setIgnoreMissingParams(true); // don't throw exception if material doesnt use lightmap
params->setNamedConstant("enableTerrainLightMap", bLightMapEnabled ? 1.f : 0.f);
} } } } }
}
inline void doUnbindPassOpacityMap( PassRenderNode & node
, Pass & pass )
{
auto unit = pass.getTextureUnit( TextureChannel::eOpacity );
if ( unit )
{
unit->getSampler()->unbind( 0u );
unit->getTexture()->unbind( 0u );
}
}
/// Add a CodeGen pass at this point in the pipeline after checking for target
/// and command line overrides.
///
/// addPass cannot return a pointer to the pass instance because is internal the
/// PassManager and the instance we create here may already be freed.
AnalysisID TargetPassConfig::addPass(AnalysisID PassID, bool verifyAfter,
bool printAfter) {
IdentifyingPassPtr TargetID = getPassSubstitution(PassID);
IdentifyingPassPtr FinalPtr = overridePass(PassID, TargetID);
if (!FinalPtr.isValid())
return nullptr;
Pass *P;
if (FinalPtr.isInstance())
P = FinalPtr.getInstance();
else {
P = Pass::createPass(FinalPtr.getID());
if (!P)
llvm_unreachable("Pass ID not registered");
}
AnalysisID FinalID = P->getPassID();
addPass(P, verifyAfter, printAfter); // Ends the lifetime of P.
return FinalID;
}
int lua_Pass_setVertexAttributeBinding(lua_State* state)
{
// Get the number of parameters.
int paramCount = lua_gettop(state);
// Attempt to match the parameters to a valid binding.
switch (paramCount)
{
case 2:
{
if ((lua_type(state, 1) == LUA_TUSERDATA) &&
(lua_type(state, 2) == LUA_TUSERDATA || lua_type(state, 2) == LUA_TTABLE || lua_type(state, 2) == LUA_TNIL))
{
// Get parameter 1 off the stack.
bool param1Valid;
ScriptUtil::LuaArray<VertexAttributeBinding> param1 = ScriptUtil::getObjectPointer<VertexAttributeBinding>(2, "VertexAttributeBinding", false, ¶m1Valid);
if (!param1Valid)
{
lua_pushstring(state, "Failed to convert parameter 1 to type 'VertexAttributeBinding'.");
lua_error(state);
}
Pass* instance = getInstance(state);
instance->setVertexAttributeBinding(param1);
return 0;
}
lua_pushstring(state, "lua_Pass_setVertexAttributeBinding - Failed to match the given parameters to a valid function signature.");
lua_error(state);
break;
}
default:
{
lua_pushstring(state, "Invalid number of parameters (expected 2).");
lua_error(state);
break;
}
}
return 0;
}
void MaterialGenerator::createSSAOTechnique()
{
Technique* ssaopasstech = mMaterial->createTechnique();
ssaopasstech->setName("geom");
ssaopasstech->setSchemeName("geom");
Pass* ssaopass = ssaopasstech->createPass();
ssaopass->setDepthWriteEnabled( mDef->mProps->depthWrite );
ssaopass->setDepthCheckEnabled( mDef->mProps->depthCheck );
HighLevelGpuProgramManager& hmgr = HighLevelGpuProgramManager::getSingleton();
// choose vertex program
std::string vprogname = "geom_vs";
if ( mDef->mProps->transparent )
vprogname = "geom_coord_vs";
// choose fragment program
std::string fprogname = "geom_ps";
if ( !mDef->mProps->ssao )
fprogname = "geom_white_ps"; // no contribution to ssao, will just return (0,0,0,0)
else if ( mDef->mProps->transparent )
fprogname = "geom_alpha_ps";
ssaopass->setVertexProgram(vprogname);
ssaopass->setFragmentProgram(fprogname);
if (mDef->mProps->ssaoReject)
ssaopass->setAlphaRejectSettings(CMPF_GREATER, 128);
if ( !mDef->mProps->transparent )
{
ssaopass->setCullingMode( chooseCullingMode() );
}
else
{
ssaopass->setCullingMode( CULL_NONE );
ssaopass->setAlphaRejectSettings(CMPF_GREATER_EQUAL, 128);
ssaopass->createTextureUnitState( mDiffuseMap );
}
}
Renderer2D::Renderer2D(Context* context) :
Drawable(context, DRAWABLE_GEOMETRY),
material_(new Material(context)),
indexBuffer_(new IndexBuffer(context_)),
viewMask_(DEFAULT_VIEWMASK)
{
material_->SetName("Urho2D");
Technique* tech = new Technique(context_);
Pass* pass = tech->CreatePass("alpha");
pass->SetVertexShader("Urho2D");
pass->SetPixelShader("Urho2D");
pass->SetDepthWrite(false);
cachedTechniques_[BLEND_REPLACE] = tech;
material_->SetTechnique(0, tech);
material_->SetCullMode(CULL_NONE);
frame_.frameNumber_ = 0;
SubscribeToEvent(E_BEGINVIEWUPDATE, URHO3D_HANDLER(Renderer2D, HandleBeginViewUpdate));
}
inline void doBindPassOpacityMap( PassRenderNode & node
, Pass & pass )
{
auto unit = pass.getTextureUnit( TextureChannel::eOpacity );
if ( unit )
{
node.m_textures.find( unit->getIndex() )->second.get().setValue( 0 );
unit->getTexture()->bind( 0u );
unit->getSampler()->bind( 0u );
}
}
//-----------------------------------------------------------------------------
void SGMaterialSerializerListener::createSGPassList(Material* mat, SGPassList& passList)
{
for (unsigned short techniqueIndex = 0; techniqueIndex < mat->getNumTechniques(); ++techniqueIndex)
{
Technique* curTechnique = mat->getTechnique(techniqueIndex);
for (unsigned short passIndex = 0; passIndex < curTechnique->getNumPasses(); ++passIndex)
{
Pass* curPass = curTechnique->getPass(passIndex);
const Any& passUserData = curPass->getUserObjectBindings().getUserAny(ShaderGenerator::SGPass::UserKey);
// Case this pass created by the shader generator.
if (passUserData.isEmpty() == false)
{
ShaderGenerator::SGPass* passEntry = any_cast<ShaderGenerator::SGPass*>(passUserData);
passList.push_back(passEntry);
}
}
}
}
void MaterialDemo::Draw(const GameTime& gameTime)
{
ID3D11DeviceContext* direct3DDeviceContext = mGame->Direct3DDeviceContext();
direct3DDeviceContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
Pass* pass = mBasicMaterial->CurrentTechnique()->Passes().at(0);
ID3D11InputLayout* inputLayout = mBasicMaterial->InputLayouts().at(pass);
direct3DDeviceContext->IASetInputLayout(inputLayout);
UINT stride = mBasicMaterial->VertexSize();
UINT offset = 0;
direct3DDeviceContext->IASetVertexBuffers(0, 1, &mVertexBuffer, &stride, &offset);
direct3DDeviceContext->IASetIndexBuffer(mIndexBuffer, DXGI_FORMAT_R32_UINT, 0);
XMMATRIX worldMatrix = XMLoadFloat4x4(&mWorldMatrix);
XMMATRIX wvp = worldMatrix * mCamera->ViewMatrix() * mCamera->ProjectionMatrix();
mBasicMaterial->WorldViewProjection() << wvp;
pass->Apply(0, direct3DDeviceContext);
direct3DDeviceContext->DrawIndexed(mIndexCount, 0, 0);
}
void Nau::loadFilesAndFoldersAux(std::string sceneName, bool unitize) {
m_ProjectName = "Model Display";
Camera *aNewCam = m_pRenderManager->getCamera ("MainCamera").get();
std::shared_ptr<Viewport> v = m_pRenderManager->getViewport("__nauDefault");//createViewport ("MainViewport", nau::math::vec4(0.0f, 0.0f, 0.0f, 1.0f));
aNewCam->setViewport (v);
setActiveCameraName("MainCamera");
if (unitize) {
aNewCam->setPerspective (60.0f, 0.01f, 100.0f);
aNewCam->setPropf4(Camera::POSITION, 0.0f, 0.0f, 5.0f, 1.0f);
}
else
aNewCam->setPerspective (60.0f, 1.0f, 10000.0f);
// creates a directional light by default
std::shared_ptr<Light> &l = m_pRenderManager->getLight("MainDirectionalLight");
l->setPropf4(Light::DIRECTION,1.0f,-1.0f,-1.0f, 0.0f);
l->setPropf4(Light::COLOR, 0.9f,0.9f,0.9f,1.0f);
l->setPropf4(Light::AMBIENT,0.5f,0.5f,0.5f,1.0f );
std::shared_ptr<Pipeline> &aPipeline = m_pRenderManager->createPipeline("MainPipeline");
Pass *aPass = aPipeline->createPass("MainPass");
aPass->setCamera ("MainCamera");
aPass->setViewport (v);
aPass->setPropb(Pass::COLOR_CLEAR, true);
aPass->setPropb(Pass::DEPTH_CLEAR, true);
aPass->addLight ("MainDirectionalLight");
aPass->addScene(sceneName);
m_pRenderManager->setActivePipeline("MainPipeline");
// RENDERMANAGER->prepareTriangleIDsAndTangents(true,true);
}
MaterialPtr PGSampleApp::buildDepthShadowMaterial(const String& textureName)
{
String matName = "DepthShadows/" + textureName;
#if OGRE_VERSION_MAJOR <= 1
#if OGRE_VERSION_MINOR <= 8
MaterialPtr ret = MaterialManager::getSingleton().getByName(matName);
#else
MaterialPtr ret = MaterialManager::getSingleton().getByName(matName);
#endif
#endif
if (ret.isNull())
{
#if OGRE_VERSION_MAJOR <= 1
#if OGRE_VERSION_MINOR <= 8
MaterialPtr baseMat = MaterialManager::getSingleton().getByName("Ogre/shadow/depth/integrated/pssm");
#else
MaterialPtr baseMat = MaterialManager::getSingleton().getByName("Ogre/shadow/depth/integrated/pssm").staticCast<Material>();
#endif
#endif
ret = baseMat->clone(matName);
Pass* p = ret->getTechnique(0)->getPass(0);
p->getTextureUnitState("diffuse")->setTextureName(textureName);
Vector4 splitPoints;
const PSSMShadowCameraSetup::SplitPointList& splitPointList =
static_cast<PSSMShadowCameraSetup*>(mPSSMSetup.get())->getSplitPoints();
for (int i = 0; i < 3; ++i)
{
splitPoints[i] = splitPointList[i];
}
p->getFragmentProgramParameters()->setNamedConstant("pssmSplitPoints", splitPoints);
}
return ret;
}
//-----------------------------------------------------------------------------
void FFPRenderStateBuilder::resolveColourStageFlags( ShaderGenerator::SGPass* sgPass, TargetRenderState* renderState )
{
const SubRenderStateList& subRenderStateList = renderState->getTemplateSubRenderStateList();
FFPColour* colourSubState = NULL;
// Find the colour sub state.
for (SubRenderStateListConstIterator it=subRenderStateList.begin(); it != subRenderStateList.end(); ++it)
{
SubRenderState* curSubRenderState = *it;
if (curSubRenderState->getType() == FFPColour::Type)
{
colourSubState = static_cast<FFPColour*>(curSubRenderState);
break;
}
}
for (SubRenderStateListConstIterator it=subRenderStateList.begin(); it != subRenderStateList.end(); ++it)
{
SubRenderState* curSubRenderState = *it;
// Add vertex shader specular lighting output in case of specular enabled.
if (curSubRenderState->getType() == FFPLighting::Type)
{
FFPLighting* lightingSubState = static_cast<FFPLighting*>(curSubRenderState);
colourSubState->addResolveStageMask(FFPColour::SF_VS_OUTPUT_DIFFUSE);
Pass* srcPass = sgPass->getSrcPass();
if (srcPass->getShininess() > 0.0 &&
srcPass->getSpecular() != ColourValue::Black)
{
colourSubState->addResolveStageMask(FFPColour::SF_VS_OUTPUT_SPECULAR);
}
break;
}
}
}
SharedPtr<Material> Renderer2D::CreateMaterial(Texture2D* texture, BlendMode blendMode)
{
SharedPtr<Material> newMaterial = material_->Clone();
HashMap<int, SharedPtr<Technique> >::Iterator techIt = cachedTechniques_.Find((int)blendMode);
if (techIt == cachedTechniques_.End())
{
SharedPtr<Technique> tech(new Technique(context_));
Pass* pass = tech->CreatePass("alpha");
pass->SetVertexShader("Urho2D");
pass->SetPixelShader("Urho2D");
pass->SetDepthWrite(false);
pass->SetBlendMode(blendMode);
techIt = cachedTechniques_.Insert(MakePair((int)blendMode, tech));
}
newMaterial->SetTechnique(0, techIt->second_.Get());
newMaterial->SetName(texture->GetName() + "_" + blendModeNames[blendMode]);
newMaterial->SetTexture(TU_DIFFUSE, texture);
return newMaterial;
}
const MaterialPtr &MaterialGenerator::getMaterial(Perm permutation)
{
/// Check input validity
size_t totalBits = bitNames.size();
size_t totalPerms = 1<<totalBits;
assert(permutation < totalPerms);
/// Check if material/shader permutation already was generated
MaterialMap::iterator i = mMaterials.find(permutation);
if(i != mMaterials.end())
{
return i->second;
}
else
{
/// Create it
MaterialPtr templ = getTemplateMaterial(permutation & matMask);
GpuProgramPtr vs = getVertexShader(permutation & vsMask);
GpuProgramPtr fs = getFragmentShader(permutation & fsMask);
/// Create material name
String name=materialBaseName;
for(size_t bit=0; bit<totalBits; ++bit)
if(permutation & (1<<bit))
name += bitNames[bit];
std::cerr << name << " " << vs->getName() << " " << fs->getName() << std::endl;
/// Create material from template, and set shaders
MaterialPtr mat = templ->clone(name);
Technique *tech = mat->getTechnique(0);
Pass *pass = tech->getPass(0);
pass->setFragmentProgram(fs->getName());
pass->setVertexProgram(vs->getName());
/// And store it
mMaterials[permutation] = mat;
return mMaterials[permutation];
}
}
unsigned int Model::draw(bool wireframe)
{
GP_ASSERT(_mesh);
unsigned int partCount = _mesh->getPartCount();
if (partCount == 0)
{
// No mesh parts (index buffers).
if (_material)
{
Technique* technique = _material->getTechnique();
GP_ASSERT(technique);
unsigned int passCount = technique->getPassCount();
for (unsigned int i = 0; i < passCount; ++i)
{
Pass* pass = technique->getPassByIndex(i);
GP_ASSERT(pass);
pass->bind();
GL_ASSERT( glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0) );
if (!wireframe || !drawWireframe(_mesh))
{
GL_ASSERT( glDrawArrays(_mesh->getPrimitiveType(), 0, _mesh->getVertexCount()) );
}
pass->unbind();
}
}
}
else
{
for (unsigned int i = 0; i < partCount; ++i)
{
MeshPart* part = _mesh->getPart(i);
GP_ASSERT(part);
// Get the material for this mesh part.
Material* material = getMaterial(i);
if (material)
{
Technique* technique = material->getTechnique();
GP_ASSERT(technique);
unsigned int passCount = technique->getPassCount();
for (unsigned int j = 0; j < passCount; ++j)
{
Pass* pass = technique->getPassByIndex(j);
GP_ASSERT(pass);
pass->bind();
GL_ASSERT( glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, part->_indexBuffer) );
if (!wireframe || !drawWireframe(part))
{
GL_ASSERT( glDrawElements(part->getPrimitiveType(), part->getIndexCount(), part->getIndexFormat(), 0) );
}
pass->unbind();
}
}
}
}
return partCount;
}
int GameScript::getSafeTextureUnitState(TextureUnitState** tu, const String materialName, int techniqueNum, int passNum, int textureUnitNum)
{
try
{
MaterialPtr m = MaterialManager::getSingleton().getByName(materialName);
if (m.isNull())
return 1;
// verify technique
if (techniqueNum < 0 || techniqueNum > m->getNumTechniques())
return 2;
Technique* t = m->getTechnique(techniqueNum);
if (!t)
return 2;
//verify pass
if (passNum < 0 || passNum > t->getNumPasses())
return 3;
Pass* p = t->getPass(passNum);
if (!p)
return 3;
//verify texture unit
if (textureUnitNum < 0 || textureUnitNum > p->getNumTextureUnitStates())
return 4;
TextureUnitState* tut = p->getTextureUnitState(textureUnitNum);
if (!tut)
return 4;
*tu = tut;
return 0;
}
catch (Exception e)
{
this->log("Exception in getSafeTextureUnitState(): " + e.getFullDescription());
}
return 1;
}
void Model::setMaterialNodeBinding(Material *material)
{
if (_node)
{
material->setNodeBinding(_node);
unsigned int techniqueCount = material->getTechniqueCount();
for (unsigned int i = 0; i < techniqueCount; ++i)
{
Technique* technique = material->getTechnique(i);
technique->setNodeBinding(_node);
unsigned int passCount = technique->getPassCount();
for (unsigned int j = 0; j < passCount; ++j)
{
Pass* pass = technique->getPass(j);
pass->setNodeBinding(_node);
}
}
}
}
void CarModel::UpdateBraking()
{
if (brakes)
brakes->setVisible(bBraking && mbVisible);
std::string texName = sDirname + (bBraking ? "_body00_brake.png" : "_body00_add.png");
MaterialPtr mtr = MaterialManager::getSingleton().getByName(sMtr[Mtr_CarBody]);
if (!mtr.isNull())
{ Material::TechniqueIterator techIt = mtr->getTechniqueIterator();
while (techIt.hasMoreElements())
{ Technique* tech = techIt.getNext();
Technique::PassIterator passIt = tech->getPassIterator();
while (passIt.hasMoreElements())
{ Pass* pass = passIt.getNext();
Pass::TextureUnitStateIterator tusIt = pass->getTextureUnitStateIterator();
while (tusIt.hasMoreElements())
{
TextureUnitState* tus = tusIt.getNext();
if (tus->getName() == "diffuseMap")
{ tus->setTextureName( texName ); return; }
} } } }
}
void MaterialFactory::update()
{
for (std::vector<std::string>::const_iterator it = timeMtrs.begin();
it != timeMtrs.end(); ++it)
{
MaterialPtr mtr = MaterialManager::getSingleton().getByName( (*it) );
if (!mtr.isNull())
{ Material::TechniqueIterator techIt = mtr->getTechniqueIterator();
while (techIt.hasMoreElements())
{ Technique* tech = techIt.getNext();
Technique::PassIterator passIt = tech->getPassIterator();
while (passIt.hasMoreElements())
{ Pass* pass = passIt.getNext();
// time
if (pass->hasFragmentProgram() && pass->getFragmentProgramParameters()->_findNamedConstantDefinition("time", false))
pass->getFragmentProgramParameters()->setNamedConstantFromTime( "time", 1 );
}
}
}
}
}
int lua_Pass_setStateBlock(lua_State* state)
{
// Get the number of parameters.
int paramCount = lua_gettop(state);
// Attempt to match the parameters to a valid binding.
switch (paramCount)
{
case 2:
{
if ((lua_type(state, 1) == LUA_TUSERDATA) &&
(lua_type(state, 2) == LUA_TUSERDATA || lua_type(state, 2) == LUA_TTABLE || lua_type(state, 2) == LUA_TNIL))
{
// Get parameter 1 off the stack.
ScriptUtil::LuaArray<RenderState::StateBlock> param1 = ScriptUtil::getObjectPointer<RenderState::StateBlock>(2, "RenderStateStateBlock", false);
Pass* instance = getInstance(state);
instance->setStateBlock(param1);
return 0;
}
else
{
lua_pushstring(state, "lua_Pass_setStateBlock - Failed to match the given parameters to a valid function signature.");
lua_error(state);
}
break;
}
default:
{
lua_pushstring(state, "Invalid number of parameters (expected 2).");
lua_error(state);
break;
}
}
return 0;
}
void Text3D::UpdateTextMaterials(bool forceUpdate)
{
batches_.Resize(uiBatches_.Size());
geometries_.Resize(uiBatches_.Size());
for (unsigned i = 0; i < batches_.Size(); ++i)
{
if (!geometries_[i])
{
Geometry* geometry = new Geometry(context_);
geometry->SetVertexBuffer(0, vertexBuffer_, MASK_POSITION | MASK_COLOR | MASK_TEXCOORD1);
batches_[i].geometry_ = geometries_[i] = geometry;
}
if (!batches_[i].material_ || forceUpdate)
{
// If material not defined, create a reasonable default from scratch
if (!material_)
{
Material* material = new Material(context_);
Technique* tech = new Technique(context_);
Pass* pass = tech->CreatePass(PASS_ALPHA);
pass->SetVertexShader("Basic_DiffVCol");
pass->SetPixelShader("Basic_AlphaVCol");
pass->SetBlendMode(BLEND_ALPHA);
material->SetTechnique(0, tech);
material->SetCullMode(CULL_NONE);
batches_[i].material_ = material;
}
else
batches_[i].material_ = material_->Clone();
}
Material* material = batches_[i].material_;
material->SetTexture(TU_DIFFUSE, uiBatches_[i].texture_);
}
}
