//----------------------------------------------------------------------------
MaterialInstance* Texture2DMaterial::CreateInstance (Texture2D* texture) const
{
MaterialInstance* instance = new0 MaterialInstance(this, 0);
instance->SetVertexConstant(0, "gPVWMatrix", new0 PVWMatrixConstant());
instance->SetPixelTexture(0, "gDiffuseSampler", texture);
//Shader::SamplerFilter filter = GetPixelShader()->GetFilter(0);
//if (filter != Shader::SF_NEAREST && filter != Shader::SF_LINEAR
// && !texture->HasMipmaps() && texture->GetFormat()!=Texture::TF_DXT1
// && texture->GetFormat()!=Texture::TF_DXT3 && texture->GetFormat()!=
// Texture::TF_DXT5)
//{
// //texture->GenerateMipmaps();
//}
return instance;
}
void MaterialNode::createLayout( const MaterialInstance& host ) const
{
for( OutputsMap::const_iterator it = m_outputs.begin(); it != m_outputs.end(); ++it )
{
(*it)->createLayout( host.data() );
}
onCreateLayout( host );
}
//----------------------------------------------------------------------------
void RawTerrainPage::UpdateWorldData (double applicationTime)
{
TriMesh::UpdateWorldData(applicationTime);
PX2::Light *light = 0;
for (int i=0; i<(int)mInfulencedLights.size(); i++)
{
Light *lit = mInfulencedLights[i];
if (lit->GetType() == Light::LT_DIRECTIONAL)
{
light = lit;
break;
}
}
if (light!=0 && light!=mDirLight)
{
mDirLight = light;
mMtlInst->SetVertexConstant(0, "gLightColour",
new0 LightDiffuseConstant(mDirLight));
mMtlInst->SetVertexConstant(0, "gLightAttenuation",
new0 LightAttenuationConstant(mDirLight));
mMtlInst->SetVertexConstant(0, "gLightModelDirection",
new0 LightModelDVectorConstant(mDirLight));
for (int i=0; i<(int)mJunglers.size(); i++)
{
Jungler *jungler = mJunglers[i];
MaterialInstance *inst = jungler->GetMtlInst();
if (inst)
{
inst->SetVertexConstant(0, "gLightColour",
new0 LightDiffuseConstant(mDirLight));
inst->SetVertexConstant(0, "gLightAttenuation",
new0 LightAttenuationConstant(mDirLight));
inst->SetVertexConstant(0, "gLightModelDirection",
new0 LightModelDVectorConstant(mDirLight));
}
}
}
}
//----------------------------------------------------------------------------
void UIText::ReCreate()
{
if (RU_NONE == mRectUseage)
{
PX2_FM.RenderText(this, mFont,
mText.c_str(), mDrawStyle, mOffset[0], mOffset[1], mSpace,
mFontColor, mBorderShadowColor, mShadowBorderSize,
mFontScale, mIsDoCharTranslate, 0.0f);
}
else if (RU_ALIGNS == mRectUseage)
{
PX2_FM.RenderTextRect(this, mFont, mText.c_str(),
mDrawStyle, mTextAligns, mRect, mSpace, mOffset[0], mOffset[1],
mFontColor, mBorderShadowColor, mShadowBorderSize, mFontScale,
mIsDoCharTranslate);
}
else if (RU_CLIPWARP == mRectUseage)
{
PX2_FM.RenderTextRect(this, mFont, mText.c_str(),
mDrawStyle, mRect, mSpace, mOffset[0], mOffset[1],
mIsAutoWarp, mFontColor,
mBorderShadowColor, mShadowBorderSize, mFontScale,
mIsDoCharTranslate, mIsPointAsPunctuation);
}
mFontTex = mFont->GetTexture();
MaterialInstance *mtlInst = GetMaterialInstance();
mtlInst->SetPixelTexture(0, "SamplerBase", mFontTex);
VertexBuffer *vb = GetVertexBuffer();
IndexBuffer *ib = GetIndexBuffer();
if ((vb && Renderer::IsOneBind(vb)) || (ib && Renderer::IsOneBind(ib)))
{
Renderer::UpdateAll(vb);
Renderer::UpdateAll(ib);
}
mIsNeedReCreate = false;
}
bool Material::load( const QUrl& url )
{
if(!url.isValid())
return false;
QFile file(url.toLocalFile());
if(!file.open(QIODevice::ReadOnly))
return false;
QByteArray data = file.readAll();
QList<GluonObject*> objects = GluonCore::GDLHandler::instance()->parseGDL(data, this);
if(objects.count() <= 0)
return false;
GluonCore::GluonObject* obj = objects.at(0);
QList<QByteArray> properties = obj->dynamicPropertyNames();
MaterialInstance* defaultInstance = d->instances.find("default").value();
foreach(QByteArray propertyName, properties)
{
if(propertyName == "vertexShader")
{
d->vertShaderSource = obj->property(propertyName).toByteArray();
}
else if(propertyName == "fragmentShader")
{
d->fragShaderSource = obj->property(propertyName).toByteArray();
}
else if(propertyName == "languageVersion")
{
d->languageVersion = obj->property(propertyName).toString();
}
else
{
defaultInstance->setProperty(propertyName, obj->property(propertyName));
}
}
return true;
}
//----------------------------------------------------------------------------
void BoxSurface::DisableSorting ()
{
for (int face = 0; face < 6; face++)
{
TriMesh* mesh = StaticCast<TriMesh>(GetChild(face));
MaterialInstance* instance = mesh->GetMaterialInstance();
const int numPasses = instance->GetNumPasses();
for (int p = 0; p < numPasses; ++p)
{
const MaterialPass* pass = instance->GetPass(p);
CullProperty* cproperty = pass->GetCullProperty();
cproperty->Enabled = true;
DepthProperty* dproperty = pass->GetDepthProperty();
dproperty->Enabled = true;
dproperty->Writable = true;
dproperty->Compare = DepthProperty::CM_LEQUAL;
}
}
mDoSort = false;
}
//----------------------------------------------------------------------------
MaterialInstance* StandardESMaterial_AlphaTest::CreateInstance (
PX2::Texture2D *diffTex, PX2::Light *dirLight, PX2::Shine* shine) const
{
MaterialInstance *instance = new0 MaterialInstance(this, 0);
if (!dirLight)
{
dirLight = new0 Light(Light::LT_DIRECTIONAL);
dirLight->Ambient = Float4(1.0f, 1.0f, 1.0f, 1.0f);
dirLight->Diffuse = Float4(1.0f, 1.0f, 1.0f, 1.0f);
}
if (!shine)
{
shine = new0 Shine();
shine->Ambient = Float4(1.0f, 1.0f, 1.0f, 1.0f);
shine->Diffuse = Float4(1.0f, 1.0f, 1.0f, 1.0f);
}
// vertex
instance->SetVertexConstant(0, "gPVWMatrix", new0 PVWMatrixConstant());
instance->SetVertexConstant(0, "gShineEmissive",
new0 ShineEmissiveConstant(shine));
instance->SetVertexConstant(0, "gShineAmbient",
new0 ShineAmbientConstant(shine));
instance->SetVertexConstant(0, "gShineDiffuse",
new0 ShineDiffuseConstant(shine));
instance->SetVertexConstant(0, "gLightAmbient",
new0 LightAmbientConstant(dirLight));
instance->SetVertexConstant(0, "gLightDiffuse",
new0 LightDiffuseConstant(dirLight));
instance->SetVertexConstant(0, "gLightModelDirection",
new0 LightModelDVectorConstant(dirLight));
// pixel
if (diffTex)
{
if (!diffTex->HasMipmaps())
diffTex->GenerateMipmaps();
}
instance->SetPixelTexture(0, "gDiffuseSampler", diffTex);
return instance;
}
void MNCamera::preRender( Renderer& renderer, const MaterialInstance& instance, const MaterialEntity& entity ) const
{
Camera& camera = renderer.getActiveCamera();
RuntimeDataBuffer& data = instance.data();
m_nearZ->setValue( data, camera.getNearClippingPlane() );
m_farZ->setValue( data, camera.getFarClippingPlane() );
m_viewportWidth->setValue( data, (float)renderer.getViewportWidth() );
m_viewportHeight->setValue( data, (float)renderer.getViewportHeight() );
Matrix invMtx, transInvMtx;
const Matrix& viewMtx = camera.getViewMtx();
invMtx.setInverse( viewMtx );
transInvMtx.setTransposed( invMtx );
m_invView->setValue( data, transInvMtx );
const Matrix& projMtx = camera.getProjectionMtx();
invMtx.setInverse( projMtx );
transInvMtx.setTransposed( invMtx );
m_invProj->setValue( data, transInvMtx );
}
void MNSpatialEntity::preRender( Renderer& renderer, const MaterialInstance& instance, const MaterialEntity& entity ) const
{
RuntimeDataBuffer& data = instance.data();
SpatialEntity* parentNode = data[ m_parentNode ];
if ( !parentNode )
{
// initialize the parent entity if it wasn't initialized yet
parentNode = DynamicCast< SpatialEntity >( entity.getParent() );
data[ m_parentNode ] = parentNode;
}
if ( parentNode )
{
Camera& camera = renderer.getActiveCamera();
const Matrix& worldMtx = parentNode->getGlobalMtx();
m_worldMtx->setValue( data, worldMtx );
Matrix worldView;
worldView.setMul( worldMtx, camera.getViewMtx() );
m_worldViewMtx->setValue( data, worldView );
}
}
void MNBool::preRender( Renderer& renderer, const MaterialInstance& instance, const MaterialEntity& entity ) const
{
m_output->setValue( instance.data(), m_value );
}
//----------------------------------------------------------------------------
void FramesMesh::_Cal(const std::string &texPackFilename)
{
const TexPack &texPack = PX2_RM.GetTexPack(texPackFilename);
if (!texPack.IsValid()) return;
std::string outPath;
std::string outBaseFilename;
StringHelp::SplitFilename(texPackFilename, outPath, outBaseFilename);
std::string outBaseName;
std::string outExt;
StringHelp::SplitBaseFilename(outBaseFilename, outBaseName, outExt);
VertexFormat *vf = PX2_GR.GetVertexFormat(GraphicsRoot::VFT_PCT1);
SetVertexFormat(vf);
mNumAllFrames = (int)texPack.Elements.size();
mNumFramesPerDir = mNumAllFrames / mNumDir;
if (0 == mNumFramesPerDir)
{
//assertion(false, "no frames");
//return;
}
VBIBObj &obj = VBIBManager::GetSingleton().GetVBID(texPackFilename);
if (obj.IsValued)
{
SetVertexBuffer(obj.mVB);
SetIndexBuffer(obj.mIB);
}
else
{
int numVertex = mNumAllFrames * 4;
int numIndex = mNumAllFrames * 6;
int frameIndex = 0;
VertexBuffer *vb = new0 VertexBuffer(numVertex, vf->GetStride());
VertexBufferAccessor vba(vf, vb);
for (int i = 0; i < mNumDir; i++)
{
for (int j = 0; j < mNumFramesPerDir; j++)
{
std::string eleName = outBaseName + "_" + StringHelp::IntToString(i * 45) + "_" + StringHelp::IntToString(j + 1);
const TexPackElement &ele = PX2_RM.GetTexPackElement(texPackFilename, eleName);
float xPlusPer = 0.0f;
float widthPer = 0.0f;
float zPlusPer = 0.0f;
float heightPer = 0.0f;
if (0 != ele.OW)
{
xPlusPer = (float)ele.OX / (float)ele.OW;
widthPer = (float)ele.W / (float)ele.OW;
}
if (0 != ele.OH)
{
zPlusPer = 1.0f - (float)(ele.OY + ele.H) / (float)ele.OH;
heightPer = (float)ele.H / (float)ele.OH;
}
float width = mSize;
float height = mSize;
float xPos = 0.0f - width * 0.5f;
float zPos = 0.0f - height * 0.5f;
xPos += xPlusPer * width;
zPos += zPlusPer * height;
width *= widthPer;
height *= heightPer;
Float3 p0 = Float3(xPos, zPos, 0.0f);
Float3 p1 = Float3(xPos + width, zPos, 0.0f);
Float3 p2 = Float3(xPos, zPos + height, 0.0f);
Float3 p3 = Float3(xPos + width, zPos + height, 0.0f);
float uBegin = (float)ele.X / (float)ele.TexWidth;
float uEnd = (float)(ele.X + ele.W) / (float)ele.TexWidth;
float vBegin = (float)(ele.TexHeight - ele.Y - ele.H) / (float)ele.TexHeight;
float vEnd = (float)(ele.TexHeight - ele.Y) / (float)ele.TexHeight;
vba.Position<Float3>(frameIndex * 4 + 0) = p0;
vba.Position<Float3>(frameIndex * 4 + 1) = p1;
vba.Position<Float3>(frameIndex * 4 + 2) = p2;
vba.Position<Float3>(frameIndex * 4 + 3) = p3;
vba.TCoord<Float2>(0, frameIndex * 4 + 0) = Float2(uBegin, vBegin);
vba.TCoord<Float2>(0, frameIndex * 4 + 1) = Float2(uEnd, vBegin);
vba.TCoord<Float2>(0, frameIndex * 4 + 2) = Float2(uBegin, vEnd);
vba.TCoord<Float2>(0, frameIndex * 4 + 3) = Float2(uEnd, vEnd);
frameIndex++;
}
}
IndexBuffer *ib = new0 IndexBuffer(numIndex, 2);
for (int i = 0; i < mNumAllFrames; i++)
{
unsigned short *indices = (unsigned short*)ib->GetData();
indices[i * 6 + 0] = (uint16_t)(i * 4 + 0);
indices[i * 6 + 1] = (uint16_t)(i * 4 + 1);
indices[i * 6 + 2] = (uint16_t)(i * 4 + 2);
indices[i * 6 + 3] = (uint16_t)(i * 4 + 1);
indices[i * 6 + 4] = (uint16_t)(i * 4 + 3);
indices[i * 6 + 5] = (uint16_t)(i * 4 + 2);
}
SetVertexBuffer(vb);
SetIndexBuffer(ib);
VBIBManager::GetSingleton().AddVBIB(texPackFilename, vb, ib);
}
Texture2D *tex = (Texture2D*)PX2_RM.BlockLoad(texPack.ImageFullPath);
MaterialInstance *mi = new0 MaterialInstance(
"Data/engine_mtls/tex2d/tex2d.px2obj", "tex2d", false);
mi->SetPixelTexture(0, "SampleBase", tex);
SetMaterialInstance(mi);
mi->GetMaterial()->GetCullProperty(0, 0)->Enabled = false;
mIsNeedReCal = false;
}
//----------------------------------------------------------------------------
MaterialInstance* JunglerMaterial::CreateInstance (
PX2::Texture2D *diffTex, PX2::Light *dirLight, PX2::Shine* shine) const
{
MaterialInstance *instance = new0 MaterialInstance(this, 0);
if (!dirLight)
{
dirLight = new0 Light(Light::LT_DIRECTIONAL);
dirLight->Ambient = Float4(1.0f, 1.0f, 1.0f, 1.0f);
dirLight->Diffuse = Float4(1.0f, 1.0f, 1.0f, 1.0f);
}
if (!shine)
{
shine = new0 Shine();
shine->Ambient = Float4(0.3f, 0.3f, 0.3f, 1.0f);
shine->Diffuse = Float4(1.0f, 1.0f, 1.0f, 1.0f);
}
// vertex
instance->SetVertexConstant(0, "gPVWMatrix", new0 PVWMatrixConstant());
instance->SetVertexConstant(0, "gShineEmissive",
new0 ShineEmissiveConstant(shine));
instance->SetVertexConstant(0, "gShineAmbient",
new0 ShineAmbientConstant(shine));
instance->SetVertexConstant(0, "gShineDiffuse",
new0 ShineDiffuseConstant(shine));
instance->SetVertexConstant(0, "gLightColour",
new0 LightDiffuseConstant(dirLight));
instance->SetVertexConstant(0, "gLightAttenuation",
new0 LightAttenuationConstant(dirLight));
instance->SetVertexConstant(0, "gLightModelDirection",
new0 LightModelDVectorConstant(dirLight));
UserConstantPtr userConst = new0 UserConstant();
instance->SetVertexConstant(0, "gUser", userConst);
ShaderFloat *cSF = instance->GetVertexConstant(0, "gUser");
(*cSF)[0] = 0.0f;
(*cSF)[1] = 1.0f;
(*cSF)[2] = 0.1f;
// pixel
instance->SetPixelTexture(0, "gDiffuseSampler", diffTex);
return instance;
}
void MNSpatialEntity::onCreateLayout( const MaterialInstance& host ) const
{
RuntimeDataBuffer& data = host.data();
data.registerVar( m_parentNode );
data[ m_parentNode ] = NULL;
}
//-----------------------------------------------------------------------------
void ProjTreeItem::SetTreeLevel(ProjTreeLevel level, bool isShowHelpNode)
{
mTreeLevel = level;
mIsShowHelpNode = isShowHelpNode;
Project *proj = DynamicCast<Project>(mObject);
Scene *scene = DynamicCast<Scene>(mObject);
if (proj || scene)
return;
Actor *actor = DynamicCast<Actor>(mObject);
Movable *mov = DynamicCast<Movable>(mObject);
Node *node = DynamicCast<Node>(mObject);
Renderable *renderable = DynamicCast<Renderable>(mObject);
EffectableController *effectableCtrl = DynamicCast<EffectableController>(mObject);
Material *mtl = DynamicCast<Material>(mObject);
MaterialTechnique *mtlTechnique = DynamicCast<MaterialTechnique>(mObject);
MaterialPass *mtlPass = DynamicCast<MaterialPass>(mObject);
if (!mObject)
{ // IT_CATALOG
for (int i = 0; i < (int)mChildItems.size(); i++)
{
ProjTreeItem *item = mChildItems[i];
if (item) item->SetTreeLevel(level, isShowHelpNode);
}
return;
}
else
{
ClearChildren();
}
bool addCtrl = false;
bool addModule = false;
bool addNode = false;
bool addMaterial = false;
if (PTL_GENERAL == mTreeLevel)
{
}
else if (PTL_CHILDREN == mTreeLevel)
{
if (!scene && !proj && node)
{
addNode = true;
}
}
else if (PTL_CONTROLS == mTreeLevel)
{
if (!scene && !proj && mov)
{
addCtrl = true;
}
if (!scene && !proj && node)
{
addNode = true;
}
if (effectableCtrl)
{
addModule = true;
}
}
else if (PTL_MATERIALS == mTreeLevel)
{
if (!scene && !proj && mov)
{
addCtrl = true;
}
if (!scene && !proj && node)
{
addNode = true;
}
if (renderable)
{
addMaterial = true;
}
}
else if (PTL_DETAIL == mTreeLevel)
{
if (!scene && !proj && mov)
{
addCtrl = true;
}
if (!scene && !proj && node)
{
addNode = true;
}
if (renderable)
{
addMaterial = true;
}
}
if (addCtrl)
{
int numCtrls = mov->GetNumControllers();
for (int i = 0; i < numCtrls; i++)
{
Controller *ctrl = mov->GetController(i);
AddChild(ctrl, mIconID, mTreeLevel, mIsShowHelpNode);
}
}
if (addMaterial)
{
MaterialInstance *mtlInst = renderable->GetMaterialInstance();
Material *mtl = mtlInst->GetMaterial();
AddChild(mtl, mIconID, mTreeLevel, mIsShowHelpNode);
}
if (mtl)
{
int numTechniques = mtl->GetNumTechniques();
for (int i = 0; i < numTechniques; i++)
{
MaterialTechnique *mtlTechnique = mtl->GetTechnique(i);
AddChild(mtlTechnique, mIconID, mTreeLevel, isShowHelpNode);
}
}
if (mtlTechnique)
{
int numPasses = mtlTechnique->GetNumPasses();
for (int i = 0; i < numPasses; i++)
{
MaterialPass *mtlPass = mtlTechnique->GetPass(i);
AddChild(mtlPass, mIconID, mTreeLevel, isShowHelpNode);
}
}
if (mtlPass)
{
AddChild(mtlPass->GetVertexShader(), mIconID, mTreeLevel, isShowHelpNode);
AddChild(mtlPass->GetPixelShader(), mIconID, mTreeLevel, isShowHelpNode);
AddChild(mtlPass->GetAlphaProperty(), mIconID, mTreeLevel, isShowHelpNode);
AddChild(mtlPass->GetCullProperty(), mIconID, mTreeLevel, isShowHelpNode);
AddChild(mtlPass->GetDepthProperty(), mIconID, mTreeLevel, isShowHelpNode);
AddChild(mtlPass->GetOffsetProperty(), mIconID, mTreeLevel, isShowHelpNode);
AddChild(mtlPass->GetStencilProperty(), mIconID, mTreeLevel, isShowHelpNode);
AddChild(mtlPass->GetWireProperty(), mIconID, mTreeLevel, isShowHelpNode);
}
if (addModule)
{
int numModules = effectableCtrl->GetNumModules();
for (int i = 0; i < numModules; i++)
{
EffectModule *module = effectableCtrl->GetModule(i);
AddChild(module, mIconID, mTreeLevel, mIsShowHelpNode);
}
}
if (addNode)
{
int numChildren = node->GetNumChildren();
for (int i = 0; i < numChildren; i++)
{
Movable *child = node->GetChild(i);
if (child)
{
bool ingore = false;
if (!isShowHelpNode && ("HelpNode" == child->GetName()))
ingore = true;
if (!ingore)
{
AddChild(child, mIconID, mTreeLevel, mIsShowHelpNode);
}
}
}
}
}
