commit x64 compilation from lulu cause the other branch dont seems to compile properly at home
This commit is contained in:
272
include/engine/core/shader_nml.cpp
Normal file
272
include/engine/core/shader_nml.cpp
Normal file
@ -0,0 +1,272 @@
|
||||
/* -----------------------------------------------------------------------------
|
||||
GSFramework
|
||||
Copyright 2001-2013 Emmanuel Julien. All Rights Reserved.
|
||||
----------------------------------------------------------------------------- */
|
||||
|
||||
|
||||
#include "core/shader.h"
|
||||
#include "metafile/nml.h"
|
||||
#include "filesystem/filesystem.h"
|
||||
#include "platform.h"
|
||||
#include "log/log.h"
|
||||
|
||||
using namespace GS::Core;
|
||||
using GS::NML::Tag;
|
||||
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
void Shader::ParseVaryingTag(Tag *tag)
|
||||
{
|
||||
if (!tag || tag->name != "Varying")
|
||||
return;
|
||||
|
||||
NMLTagForeach(it, *tag)
|
||||
if (it->name == "Variable")
|
||||
{
|
||||
Tag *t_name = it->GetTypedTag("Name", Variant::VariantString),
|
||||
*t_type = it->GetTypedTag("Type", Variant::VariantString);
|
||||
if (t_name && t_type)
|
||||
DeclareVarying(t_name->GetString(), t_type->GetString());
|
||||
}
|
||||
}
|
||||
void Shader::ParseInputTag(Tag *tag)
|
||||
{
|
||||
if (!tag || tag->name != "Input")
|
||||
return;
|
||||
|
||||
NMLTagForeach(it, *tag)
|
||||
{
|
||||
ShaderInput::Type type = ShaderInput::None;
|
||||
uint scope = 0;
|
||||
|
||||
// Parse shader input.
|
||||
if (it->name == "Attribute")
|
||||
{
|
||||
type = ShaderInput::Attribute;
|
||||
scope = ShaderInput::Vertex;
|
||||
}
|
||||
else if (it->name == "Uniform")
|
||||
{
|
||||
type = ShaderInput::Uniform;
|
||||
scope = ShaderInput::Pixel;
|
||||
}
|
||||
|
||||
if (type != ShaderInput::None)
|
||||
{
|
||||
String input_name;
|
||||
ShaderInput::DataType data_type = ShaderInput::NoData;
|
||||
ShaderInput::Semantic semantic = ShaderInput::Constant;
|
||||
|
||||
if (Tag *t = it->GetTypedTag("Name", Variant::VariantString))
|
||||
input_name = t->GetString();
|
||||
|
||||
if (Tag *t = it->GetTypedTag("Semantic", Variant::VariantString))
|
||||
{
|
||||
String cs(t->GetString());
|
||||
|
||||
#if 1 // Legacy semantic support (changed with 1.3.0).
|
||||
if (cs == "Texture")
|
||||
cs = "Texture2D";
|
||||
else if (cs == "NativeTexture")
|
||||
cs = "Texture2D";
|
||||
else if (cs == "CubeTexture")
|
||||
cs = "TextureCube";
|
||||
else if (cs == "User")
|
||||
cs = "Constant";
|
||||
#endif
|
||||
|
||||
uint n = 0;
|
||||
for (; n < ShaderInput::LastSemantic; ++n)
|
||||
if (cs == ShaderInput::semantic_desc[n].name)
|
||||
{
|
||||
semantic = (ShaderInput::Semantic)n;
|
||||
data_type = ShaderInput::semantic_desc[semantic].data_type;
|
||||
break;
|
||||
}
|
||||
|
||||
if (n == ShaderInput::LastSemantic)
|
||||
__LOG_E__ << "Unknown shader input semantic '" << cs << "'.\n";
|
||||
}
|
||||
|
||||
if (Tag *t = it->GetTag("Type"))
|
||||
{
|
||||
String type(t->GetString());
|
||||
|
||||
if (type == "float") data_type = ShaderInput::Float;
|
||||
else if (type == "vec2") data_type = ShaderInput::Vector2;
|
||||
else if (type == "vec3") data_type = ShaderInput::Vector3;
|
||||
else if (type == "vec4") data_type = ShaderInput::Vector4;
|
||||
else if (type == "mat3") data_type = ShaderInput::Matrix3;
|
||||
else if (type == "mat4") data_type = ShaderInput::Matrix4;
|
||||
else
|
||||
__LOG_E__ << "Unknown type '" << type << "' for input '" << input_name << "'.\n";
|
||||
}
|
||||
|
||||
if (Tag *t = it->GetTag("Scope"))
|
||||
{
|
||||
scope = 0;
|
||||
if (t->GetTag("Vertex"))
|
||||
scope |= ShaderInput::Vertex;
|
||||
if (t->GetTag("Pixel") || t->GetTag("Fragment"))
|
||||
scope |= ShaderInput::Pixel;
|
||||
}
|
||||
|
||||
ShaderInput *input = NULL;
|
||||
|
||||
if (semantic != ShaderInput::LastSemantic)
|
||||
input = DeclareInput(input_name, data_type, semantic, type, (ShaderInput::Scope)scope);
|
||||
else
|
||||
__LOG_W__ << "Unknown shader input semantic in shader '" << name << "'.\n";
|
||||
|
||||
if (input)
|
||||
switch (input->semantic)
|
||||
{
|
||||
case ShaderInput::Texture2D:
|
||||
case ShaderInput::TextureCube:
|
||||
if (Tag *t = it->GetTypedTag("Texture", Variant::VariantString))
|
||||
input->parm_t = t->GetString();
|
||||
break;
|
||||
|
||||
case ShaderInput::Constant:
|
||||
if (Tag *t = it->GetTag("Vector"))
|
||||
input->parm_v.FromMetaTag(*t);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
bool Shader::FromMetaTag(Tag &tag)
|
||||
{
|
||||
if (tag.name != "Shader")
|
||||
return false;
|
||||
|
||||
Clear();
|
||||
|
||||
NMLTagForeach(pt, tag)
|
||||
{
|
||||
if (pt->name == "Name")
|
||||
name = pt->GetString();
|
||||
|
||||
else if (pt->name == "Varying")
|
||||
ParseVaryingTag(pt);
|
||||
else if (pt->name == "Input")
|
||||
ParseInputTag(pt);
|
||||
|
||||
else if (pt->name == "VertexDeclaration")
|
||||
vertex_decl = pt->GetString();
|
||||
else if (pt->name == "PixelDeclaration")
|
||||
pixel_decl = pt->GetString();
|
||||
else if (pt->name == "GeometryDeclaration")
|
||||
geometry_decl = pt->GetString();
|
||||
|
||||
else if (pt->name == "VertexSource")
|
||||
vertex = pt->GetString();
|
||||
else if ((pt->name == "PixelSource") || (pt->name == "FragmentSource"))
|
||||
pixel = pt->GetString();
|
||||
else if (pt->name == "GeometrySource")
|
||||
geometry = pt->GetString();
|
||||
|
||||
else if (pt->name == "Vertex")
|
||||
{
|
||||
Array <char> buffer;
|
||||
if (Platform::Get().io->FileLoad(pt->GetString(), buffer))
|
||||
vertex.Set(buffer, &buffer[buffer.GetCount()]);
|
||||
}
|
||||
else if ((pt->name == "Pixel") || (pt->name == "Fragment"))
|
||||
{
|
||||
Array <char> buffer;
|
||||
if (Platform::Get().io->FileLoad(pt->GetString(), buffer))
|
||||
pixel.Set(buffer, &buffer[buffer.GetCount()]);
|
||||
}
|
||||
else if (pt->name == "Geometry")
|
||||
{
|
||||
Array <char> buffer;
|
||||
if (Platform::Get().io->FileLoad(pt->GetString(), buffer))
|
||||
geometry.Set(buffer, &buffer[buffer.GetCount()]);
|
||||
}
|
||||
else
|
||||
__LOG_W__ << "Unknown tag '" << pt->name << "' in <Shader>.\n";
|
||||
}
|
||||
return true;
|
||||
}
|
||||
Tag *Shader::AsMetaTag() const
|
||||
{
|
||||
Tag *root = new Tag("Shader");
|
||||
if (!root)
|
||||
__ERR__(__LOG_E__ << "Could not serialize shader. Failed to create root tag.\n", NULL)
|
||||
|
||||
if (input_list.GetCount())
|
||||
if (Tag *it = root->AddChild("Input"))
|
||||
ListForeachPtr(ShaderInput *, input, input_list)
|
||||
{
|
||||
Tag *t = NULL;
|
||||
switch (input->type)
|
||||
{
|
||||
case ShaderInput::Attribute: t = new Tag("Attribute"); break;
|
||||
case ShaderInput::Uniform: t = new Tag("Uniform"); break;
|
||||
}
|
||||
if (!t)
|
||||
continue;
|
||||
|
||||
t->AddChild("Name", input->name);
|
||||
t->AddChild("Semantic", ShaderInput::semantic_desc[input->semantic].name);
|
||||
|
||||
if (Tag *st = t->AddChild("Scope"))
|
||||
{
|
||||
if (input->scope & ShaderInput::Vertex)
|
||||
st->AddChild("Vertex");
|
||||
if (input->scope & ShaderInput::Pixel)
|
||||
st->AddChild("Pixel");
|
||||
if (input->scope & ShaderInput::Geometry)
|
||||
st->AddChild("Geometry");
|
||||
}
|
||||
|
||||
switch (input->semantic)
|
||||
{
|
||||
case ShaderInput::Constant:
|
||||
switch (input->data_type)
|
||||
{
|
||||
case ShaderInput::Float: t->AddChild("Type", "float"); break;
|
||||
case ShaderInput::Vector2: t->AddChild("Type", "vec2"); break;
|
||||
case ShaderInput::Vector3: t->AddChild("Type", "vec3"); break;
|
||||
case ShaderInput::Vector4: t->AddChild("Type", "vec4"); break;
|
||||
case ShaderInput::Matrix3: t->AddChild("Type", "mat3"); break;
|
||||
case ShaderInput::Matrix4: t->AddChild("Type", "mat4"); break;
|
||||
}
|
||||
|
||||
t->AddChild(input->parm_v.AsMetaTag("Vector"));
|
||||
break;
|
||||
}
|
||||
|
||||
if (!input->parm_t.IsEmpty())
|
||||
t->AddChild("Texture", input->parm_t.c_str());
|
||||
|
||||
it->AddChild(t);
|
||||
}
|
||||
|
||||
if (varying_list.GetCount())
|
||||
if (Tag *it = root->AddChild("Varying"))
|
||||
ListForeachPtr(ShaderVarying *, varying, varying_list)
|
||||
if (Tag *v = it->AddChild("Variable"))
|
||||
{
|
||||
v->AddChild("Name", varying->name);
|
||||
v->AddChild("Type", varying->type);
|
||||
}
|
||||
|
||||
if (!geometry_decl.IsEmpty())
|
||||
root->AddChild("GeometryDeclaration", geometry_decl);
|
||||
if (!vertex_decl.IsEmpty())
|
||||
root->AddChild("VertexDeclaration", vertex_decl);
|
||||
if (!pixel_decl.IsEmpty())
|
||||
root->AddChild("PixelDeclaration", pixel_decl);
|
||||
|
||||
if (!geometry.IsEmpty())
|
||||
root->AddChild("GeometrySource", geometry);
|
||||
if (!vertex.IsEmpty())
|
||||
root->AddChild("VertexSource", vertex);
|
||||
if (!pixel.IsEmpty())
|
||||
root->AddChild("PixelSource", pixel);
|
||||
|
||||
return root;
|
||||
}
|
||||
//------------------------------------------------------------------------------
|
||||
Reference in New Issue
Block a user