//-------------------------------------------------------------------------
bool ScriptTranslator::passValidatePropertyValidVector4(Ogre::ScriptCompiler* compiler,
Ogre::PropertyAbstractNode* prop)
{
Ogre::Vector4 val;
if(getVector4(prop->values.begin(), prop->values.end(), &val))
{
return true;
}
compiler->addError(Ogre::ScriptCompiler::CE_INVALIDPARAMETERS, prop->file, prop->line,
"PU Compiler: " + prop->values.front()->getValue() + " is not a valid Vector4");
return false;
}
void NIFStream::getVector4s(osg::Vec4Array* vec, size_t size)
{
vec->reserve(size);
for(size_t i = 0;i < size;i++)
vec->push_back(getVector4());
}
void PUMaterialPassTranslator::translate( PUScriptCompiler* compiler, PUAbstractNode *node )
{
PUObjectAbstractNode* obj = reinterpret_cast<PUObjectAbstractNode*>(node);
PUObjectAbstractNode* parent = obj->parent ? reinterpret_cast<PUObjectAbstractNode*>(obj->parent) : 0;
if (parent)
obj->context = parent->context;
PUMaterial *material = static_cast<PUMaterial *>(obj->context);
for(PUAbstractNodeList::iterator i = obj->children.begin(); i != obj->children.end(); ++i)
{
if((*i)->type == ANT_PROPERTY)
{
PUPropertyAbstractNode *prop = reinterpret_cast<PUPropertyAbstractNode*>((*i));
if (prop->name == matToken[TOKEN_MAT_LIGHTING])
{
if (passValidateProperty(compiler, prop, matToken[TOKEN_MAT_LIGHTING], VAL_STRING))
{
std::string val;
if(getString(*prop->values.front(), &val))
{
if (val == matToken[TOKEN_MAT_ON])
{
material->isEnabledLight = true;
}
else if (val == matToken[TOKEN_MAT_OFF])
{
material->isEnabledLight = false;
}
}
}
}
else if (prop->name == matToken[TOKEN_MAT_AMIBIENT])
{
if (passValidateProperty(compiler, prop, matToken[TOKEN_MAT_AMIBIENT], VAL_VECTOR4))
{
Vec4 val;
if(getVector4(prop->values.begin(), prop->values.end(), &val))
{
material->ambientColor = val;
}
}
}
else if (prop->name == matToken[TOKEN_MAT_DIFFUSE])
{
if (passValidateProperty(compiler, prop, matToken[TOKEN_MAT_AMIBIENT], VAL_VECTOR4))
{
Vec4 val;
if(getVector4(prop->values.begin(), prop->values.end(), &val))
{
material->diffuseColor = val;
}
}
}
else if (prop->name == matToken[TOKEN_MAT_SPECULAR])
{
PUAbstractNodeList::const_iterator it = prop->values.begin();
PUAbstractNodeList::const_iterator end = prop->values.end();
unsigned int n = 0;
Vec4 color;
float shininess;
while(it != end)
{
float v = 0;
if(getFloat(**it, &v))
{
switch(n)
{
case 0:
color.x = v;
break;
case 1:
color.y = v;
break;
case 2:
color.z = v;
break;
case 3:
color.w = v;
break;
case 4:
shininess = v;
break;
}
}
++n;
++it;
}
material->specularColor = color;
material->shininess = shininess;
}
else if (prop->name == matToken[TOKEN_MAT_EMISSIVE])
{
if (passValidateProperty(compiler, prop, matToken[TOKEN_MAT_AMIBIENT], VAL_VECTOR4))
{
Vec4 val;
if(getVector4(prop->values.begin(), prop->values.end(), &val))
{
material->emissiveColor = val;
}
}
}
else if (prop->name == matToken[TOKEN_MAT_BLEND])
{
//if (passValidateProperty(compiler, prop, matToken[TOKEN_MAT_BLEND], VAL_STRING))
if (!prop->values.empty())
{
std::string val;
if(getString(*prop->values.front(), &val))
{
if (val == matToken[TOKEN_MAT_BLEND_ADD])
{
material->blendFunc.src = GL_ONE;
material->blendFunc.dst= GL_ONE;
}
else if (val == matToken[TOKEN_MAT_BLEND_ALPHA])
{
material->blendFunc = BlendFunc::ALPHA_NON_PREMULTIPLIED;
}
else if (val == matToken[TOKEN_MAT_BLEND_COLOR])
{
material->blendFunc.src = GL_SRC_COLOR;
material->blendFunc.dst= GL_ONE_MINUS_SRC_COLOR;
}
else if (val == matToken[TOKEN_MAT_BLEND_MODULATE])
{
material->blendFunc.src = GL_DST_COLOR;
material->blendFunc.dst= GL_ZERO;
}
else if (val == matToken[TOKEN_MAT_BLEND_REPLACE])
{
material->blendFunc.src = GL_ONE;
material->blendFunc.dst= GL_ZERO;
}
else if (val == matToken[TOKEN_MAT_BLEND_SRC_COLOR])
{
material->blendFunc.src = GL_SRC_COLOR;
}
else if (val == matToken[TOKEN_MAT_BLEND_DEST_COLOR])
{
material->blendFunc.src = GL_DST_COLOR;
}
}
if (prop->values.size() == 2)
{
if (getString(*prop->values.back(), &val))
{
if (val == matToken[TOKEN_MAT_BLEND_ONE])
{
material->blendFunc.dst = GL_ONE;
}
else if (val == matToken[TOKEN_MAT_BLEND_ZERO])
{
material->blendFunc.dst = GL_ZERO;
}
else if (val == matToken[TOKEN_MAT_BLEND_SRC_COLOR])
{
material->blendFunc.dst = GL_SRC_COLOR;
}
else if (val == matToken[TOKEN_MAT_BLEND_DEST_COLOR])
{
material->blendFunc.dst = GL_DST_COLOR;
}
}
}
}
}
else if (prop->name == matToken[TOKEN_MAT_DEPTH_CHECK])
{
if (passValidateProperty(compiler, prop, matToken[TOKEN_MAT_DEPTH_CHECK], VAL_STRING))
{
std::string val;
if(getString(*prop->values.front(), &val))
{
if (val == matToken[TOKEN_MAT_ON])
{
material->depthTest = true;
}
else if (val == matToken[TOKEN_MAT_OFF])
{
material->depthTest = false;
}
}
}
}
else if (prop->name == matToken[TOKEN_MAT_DEPTH_WRITE])
{
if (passValidateProperty(compiler, prop, matToken[TOKEN_MAT_DEPTH_WRITE], VAL_STRING))
{
std::string val;
if(getString(*prop->values.front(), &val))
{
if (val == matToken[TOKEN_MAT_ON])
{
material->depthWrite = true;
}
else if (val == matToken[TOKEN_MAT_OFF])
{
material->depthWrite = false;
}
}
}
}
}
else if ((*i)->type == ANT_OBJECT)
{
PUObjectAbstractNode* child = reinterpret_cast<PUObjectAbstractNode*>(*i);
if(child->cls == matToken[TOKEN_MAT_TEXTURE_UNIT])
{
PUMaterialTextureUnitTranslator materialTextureUnitTranslator;
materialTextureUnitTranslator.translate(compiler, *i);
}
}
}
}
RenderPass RenderStage::createRenderPassFromJson(const JSONValue& renderPassJSON)
{
GraphicSystem& graphicSystem = renderer.getGraphicSystem();
RenderPass renderPass;
auto clearColorJSON = renderPassJSON.getJSONValue("clearColor");
auto colorWriteJSON = renderPassJSON.getJSONValue("colorWrite");
auto depthWriteJSON = renderPassJSON.getJSONValue("depthWrite");
auto renderTargetLayerJSON = renderPassJSON.getJSONValue("renderTargetLayer");
auto flagsJSON = renderPassJSON.getJSONValue("flags");
if(!clearColorJSON.isNull())
renderPass.clearColor = clearColorJSON.getVector4();
if(!colorWriteJSON.isNull())
renderPass.colorWrite = colorWriteJSON.getBool();
if(!depthWriteJSON.isNull())
renderPass.depthWrite = depthWriteJSON.getBool();
if(!renderTargetLayerJSON.isNull())
renderPass.renderTargetLayer = renderTargetLayerJSON.getInt();
if(!flagsJSON.isNull())
{
unsigned int flags = 0;
for(unsigned int i = 0; i < flagsJSON.getSize(); ++i)
{
if(flagsJSON.getJSONArrayItem(i).getString().compare("CLEAR_COLOR") == 0)
flags |= CLEAR_COLOR;
if(flagsJSON.getJSONArrayItem(i).getString().compare("CLEAR_DEPTH") == 0)
flags |= CLEAR_DEPTH;
}
renderPass.flags = flags;
}
auto viewPortJSON = renderPassJSON.getJSONValue("viewPort");
if(!viewPortJSON.isNull())
{
FixedArray<int, 4> viewPort = viewPortJSON.getInt4();
renderPass.viewPort.set(viewPort[0], viewPort[1], viewPort[2], viewPort[3]);
}
else
renderPass.viewPort = renderer.getScreenViewPort();
auto renderTargetJSON = renderPassJSON.getJSONValue("renderTarget");
renderPass.renderTarget = graphicSystem.createRenderTarget(renderTargetJSON);
auto shaderPasses = renderPassJSON.getJSONValue("shaderPasses");
if(!shaderPasses.isNull())
{
for(unsigned int i = 0; i < shaderPasses.getSize(); ++i)
{
auto shaderPassJSON = shaderPasses.getJSONArrayItem(i);
auto programJSON = shaderPassJSON.getJSONValue("shaderProgram");
auto vertexDataJSON = shaderPassJSON.getJSONValue("vertexData");
auto rasterStateJSON = shaderPassJSON.getJSONValue("rasterState");
auto shaderParameterBlocksJSON = shaderPassJSON.getJSONValue("shaderParameterBlocks");
auto texturesJSON = shaderPassJSON.getJSONValue("textures");
ShaderPass shaderPass;
if(!vertexDataJSON.isNull())
{
if(vertexDataJSON.getString().compare("fullScreenQuad") == 0)
shaderPass.vertexData = renderer.getFullScreenQuad();
}
if(!rasterStateJSON.isNull())
{
auto blendFunctionJSON = rasterStateJSON.getJSONValue("blendFunction");
auto compareFunctionJSON = rasterStateJSON.getJSONValue("compareFunction");
auto cullFaceJSON = rasterStateJSON.getJSONValue("cullFace");
auto blendState = !blendFunctionJSON.isNull() ? BlendState(true, enumFromString<BlendFunction>(blendFunctionJSON.getString())) : BlendState(false, BlendFunction::Replace);
auto compareState = !compareFunctionJSON.isNull() ? CompareState(true, enumFromString<CompareFunction>(compareFunctionJSON.getString())) : CompareState(false, CompareFunction::Never);
auto cullState = !cullFaceJSON.isNull() ? CullState(true, enumFromString<CullFace>(cullFaceJSON.getString())) : CullState(false, CullFace::Back);
shaderPass.rasterState = RasterState(blendState, compareState, cullState);
}
if(!shaderParameterBlocksJSON.isNull())
{
for(unsigned int j = 0; j < shaderParameterBlocksJSON.getSize(); ++j)
{
ShaderParameterBlock* block = graphicSystem.createShaderParameterBlock(shaderParameterBlocksJSON.getJSONArrayItem(j));
if(block)
shaderPass.shaderParameterBlocks.pushBack(block);
}
}
if(!texturesJSON.isNull())
{
for(unsigned int j = 0; j < texturesJSON.getSize(); ++j)
{
Texture* texture = graphicSystem.createTexture(texturesJSON.getJSONArrayItem(j));
if(texture)
shaderPass.textures.pushBack(texture);
}
}
if(!programJSON.isNull())
shaderPass.program = graphicSystem.createShaderProgram(programJSON);
renderPass.shaderPasses.pushBack(shaderPass);
}
}
return renderPass;
}