UsdAttribute
UsdPrim::CreateAttribute(const std::vector<std::string> &nameElts,
const SdfValueTypeName &typeName,
SdfVariability variability) const
{
return CreateAttribute(nameElts, typeName, /*custom=*/true, variability);
}
UsdAttribute
UsdPrim::CreateAttribute(const TfToken& name,
const SdfValueTypeName &typeName,
SdfVariability variability) const
{
return CreateAttribute(name, typeName, /*custom=*/true, variability);
}
UsdAttribute
UsdPrim::CreateAttribute(const std::vector<std::string> &nameElts,
const SdfValueTypeName &typeName,
bool custom,
SdfVariability variability) const
{
return CreateAttribute(TfToken(SdfPath::JoinIdentifier(nameElts)),
typeName, custom, variability);
}
void EC_DynamicComponent::DeserializeCommon(std::vector<DeserializeData>& deserializedAttributes, AttributeChange::Type change)
{
// Sort both lists in alphabetical order.
AttributeVector oldAttributes = NonEmptyAttributes();
std::stable_sort(oldAttributes.begin(), oldAttributes.end(), &CmpAttributeById);
std::stable_sort(deserializedAttributes.begin(), deserializedAttributes.end(), &CmpAttributeDataById);
std::vector<DeserializeData> addAttributes;
std::vector<DeserializeData> remAttributes;
AttributeVector::iterator iter1 = oldAttributes.begin();
std::vector<DeserializeData>::iterator iter2 = deserializedAttributes.begin();
// Check what attributes we need to add or remove from the dynamic component (done by comparing two list differences).
while(iter1 != oldAttributes.end() || iter2 != deserializedAttributes.end())
{
// No point to continue the iteration if other list is empty. We can just push all new attributes into the dynamic component.
if(iter1 == oldAttributes.end())
{
for(;iter2 != deserializedAttributes.end(); ++iter2)
addAttributes.push_back(*iter2);
break;
}
// Only old attributes are left and they can be removed from the dynamic component.
else if(iter2 == deserializedAttributes.end())
{
for(;iter1 != oldAttributes.end(); ++iter1)
remAttributes.push_back(DeserializeData((*iter1)->Id()));
break;
}
// Attribute has already created and we only need to update it's value.
if((*iter1)->Id() == (*iter2).id_)
{
//SetAttribute(QString::fromStdString(iter2->name_), QString::fromStdString(iter2->value_), change);
for(AttributeVector::const_iterator attr_iter = attributes.begin(); attr_iter != attributes.end(); ++attr_iter)
if((*attr_iter)->Id() == iter2->id_)
(*attr_iter)->FromString(iter2->value_.toStdString(), change);
++iter2;
++iter1;
}
// Found a new attribute that need to be created and added to the component.
else if((*iter1)->Id() > (*iter2).id_)
{
addAttributes.push_back(*iter2);
++iter2;
}
// Couldn't find the attribute in a new list so it need to be removed from the component.
else
{
remAttributes.push_back(DeserializeData((*iter1)->Id()));
++iter1;
}
}
while(!addAttributes.empty())
{
DeserializeData attributeData = addAttributes.back();
IAttribute *attribute = CreateAttribute(attributeData.type_, attributeData.id_);
if (attribute)
attribute->FromString(attributeData.value_.toStdString(), change);
addAttributes.pop_back();
}
while(!remAttributes.empty())
{
DeserializeData attributeData = remAttributes.back();
RemoveAttribute(attributeData.id_);
remAttributes.pop_back();
}
}
/** Tokenize data. */
TokenNode *Tokenize(const char *line, const char *fileName)
{
AttributeNode *ap;
TokenNode *current;
char *temp;
unsigned int x;
unsigned int offset;
unsigned int lineNumber;
char inElement;
char found;
head = NULL;
current = NULL;
inElement = 0;
lineNumber = 1;
x = 0;
/* Skip any initial white space. */
while(IsSpace(line[x], &lineNumber)) {
x += 1;
}
/* Skip any XML stuff. */
if(!strncmp(line + x, "<?", 2)) {
while(line[x]) {
if(line[x] == '\n') {
lineNumber += 1;
}
if(!strncmp(line + x, "?>", 2)) {
x += 2;
break;
}
x += 1;
}
}
/* Process the XML data. */
while(line[x]) {
/* Skip comments and white space. */
do {
/* Skip white space. */
while(IsSpace(line[x], &lineNumber)) {
x += 1;
}
/* Skip comments */
found = 0;
if(!strncmp(line + x, "<!--", 4)) {
while(line[x]) {
if(line[x] == '\n') {
lineNumber += 1;
}
if(!strncmp(line + x, "-->", 3)) {
x += 3;
found = 1;
break;
}
x += 1;
}
}
} while(found);
switch(line[x]) {
case '<':
x += 1;
if(line[x] == '/') {
/* Close tag. */
x += 1;
temp = ReadElementName(line + x);
if(current) {
if(JLIKELY(temp)) {
if(JUNLIKELY(current->type != LookupType(temp, NULL))) {
Warning(_("%s[%u]: close tag \"%s\" does not "
"match open tag \"%s\""),
fileName, lineNumber, temp,
GetTokenName(current));
}
} else {
Warning(_("%s[%u]: unexpected and invalid close tag"),
fileName, lineNumber);
}
current = current->parent;
} else {
if(temp) {
Warning(_("%s[%u]: close tag \"%s\" without open tag"),
fileName, lineNumber, temp);
} else {
Warning(_("%s[%u]: invalid close tag"), fileName, lineNumber);
}
}
if(temp) {
x += strlen(temp);
Release(temp);
}
} else {
/* Open tag. */
current = CreateNode(current, fileName, lineNumber);
temp = ReadElementName(line + x);
if(JLIKELY(temp)) {
x += strlen(temp);
LookupType(temp, current);
Release(temp);
} else {
Warning(_("%s[%u]: invalid open tag"), fileName, lineNumber);
}
}
inElement = 1;
break;
case '/':
/* End of open/close tag. */
if(inElement) {
x += 1;
if(JLIKELY(line[x] == '>' && current)) {
x += 1;
current = current->parent;
inElement = 0;
} else {
Warning(_("%s[%u]: invalid tag"), fileName, lineNumber);
}
} else {
goto ReadDefault;
}
break;
case '>':
/* End of open tag. */
x += 1;
inElement = 0;
break;
default:
ReadDefault:
if(inElement) {
/* In the open tag; read attributes. */
ap = CreateAttribute(current);
ap->name = ReadElementName(line + x);
if(ap->name) {
x += strlen(ap->name);
if(line[x] == '=') {
x += 1;
}
if(line[x] == '\"') {
x += 1;
}
ap->value = ReadAttributeValue(line + x, fileName,
&offset, &lineNumber);
x += offset;
if(line[x] == '\"') {
x += 1;
}
}
} else {
/* In tag body; read text. */
temp = ReadElementValue(line + x, fileName, &offset, &lineNumber);
x += offset;
if(temp) {
if(current) {
if(current->value) {
current->value = Reallocate(current->value,
strlen(current->value) +
strlen(temp) + 1);
strcat(current->value, temp);
Release(temp);
} else {
current->value = temp;
}
} else {
if(JUNLIKELY(temp[0])) {
Warning(_("%s[%u]: unexpected text: \"%s\""),
fileName, lineNumber, temp);
}
Release(temp);
}
}
}
break;
}
}
return head;
}
/** Tokenize a data. */
TokenNode *Tokenize(const char *line, const char *fileName) {
TokenNode *np;
AttributeNode *ap;
char *temp;
int inElement;
int x;
int found;
int lineNumber;
head = NULL;
current = NULL;
inElement = 0;
lineNumber = 1;
x = 0;
/* Skip any initial white space */
while(IsSpace(line[x], &lineNumber)) ++x;
/* Skip any XML stuff */
if(!strncmp(line + x, "<?", 2)) {
while(line[x]) {
if(line[x] == '\n') {
++lineNumber;
}
if(!strncmp(line + x, "?>", 2)) {
x += 2;
break;
}
++x;
}
}
while(line[x]) {
do {
while(IsSpace(line[x], &lineNumber)) ++x;
/* Skip comments */
found = 0;
if(!strncmp(line + x, "<!--", 4)) {
while(line[x]) {
if(line[x] == '\n') {
++lineNumber;
}
if(!strncmp(line + x, "-->", 3)) {
x += 3;
found = 1;
break;
}
++x;
}
}
} while(found);
switch(line[x]) {
case '<':
++x;
if(line[x] == '/') {
++x;
temp = ReadElementName(line + x);
if(current) {
if(temp) {
if(current->type != LookupType(temp, NULL)) {
Warning("%s[%d]: close tag \"%s\" does not "
"match open tag \"%s\"",
fileName, lineNumber, temp,
GetTokenName(current));
}
} else {
Warning("%s[%d]: unexpected and invalid close tag",
fileName, lineNumber);
}
current = current->parent;
} else {
if(temp) {
Warning("%s[%d]: close tag \"%s\" without open "
"tag", fileName, lineNumber, temp);
} else {
Warning("%s[%d]: invalid close tag", fileName, lineNumber);
}
}
if(temp) {
x += strlen(temp);
Release(temp);
}
} else {
np = current;
current = NULL;
np = CreateNode(np, fileName, lineNumber);
temp = ReadElementName(line + x);
if(temp) {
x += strlen(temp);
LookupType(temp, np);
Release(temp);
} else {
Warning("%s[%d]: invalid open tag", fileName, lineNumber);
}
}
inElement = 1;
break;
case '/':
if(inElement) {
++x;
if(line[x] == '>' && current) {
++x;
current = current->parent;
inElement = 0;
} else {
Warning("%s[%d]: invalid tag", fileName, lineNumber);
}
} else {
goto ReadDefault;
}
break;
case '>':
++x;
inElement = 0;
break;
default:
ReadDefault:
if(inElement) {
ap = CreateAttribute(current);
ap->name = ReadElementName(line + x);
if(ap->name) {
x += strlen(ap->name);
if(line[x] == '=') {
++x;
}
if(line[x] == '\"') {
++x;
}
ap->value = ReadAttributeValue(line + x, fileName,
&lineNumber);
if(ap->value) {
x += strlen(ap->value);
}
if(line[x] == '\"') {
++x;
}
}
} else {
temp = ReadElementValue(line + x, fileName, &lineNumber);
if(temp) {
x += strlen(temp);
if(current) {
if(current->value) {
current->value = Reallocate(current->value,
strlen(current->value) + strlen(temp) + 1);
strcat(current->value, temp);
Release(temp);
} else {
current->value = temp;
}
} else {
if(temp[0]) {
Warning("%s[%d]: unexpected text: \"%s\"",
fileName, lineNumber, temp);
}
Release(temp);
}
}
}
break;
}
}
return head;
}
UINT ShaderGL::CreateFromMemory(char* source)
{
mSource = source;
mProgram = glCreateProgram();
if (mProgram < 0)
{
Debug::ShowError(
"Could not create shader program.",
"Shader Loader Error");
}
if (strstr(mSource, "VERTEX_SHADER") != nullptr)
{
const char *vshader[2] = { "#version 330\n#define VERSION_GL\n#define VERTEX_SHADER\n\0", mSource };
if (!Compile(vshader, mVertexShader, GL_VERTEX_SHADER, 2))
return S_FALSE;
glAttachShader(mProgram, mVertexShader);
}
if (strstr(mSource, "GEOMETRY_SHADER") != nullptr)
{
const char *gshader[2] = { "#version 330\n#define VERSION_GL\n#define GEOMETRY_SHADER\n\0", mSource };
if (!Compile(gshader, mGeometryShader, GL_GEOMETRY_SHADER, 2))
return S_FALSE;
glAttachShader(mProgram, mGeometryShader);
}
if (strstr(mSource, "FRAGMENT_SHADER") != nullptr)
{
const char *fshader[2] = { "#version 330\n#define VERSION_GL\n#define FRAGMENT_SHADER\n\0", mSource };
if (!Compile(fshader, mFragmentShader, GL_FRAGMENT_SHADER, 2))
return S_FALSE;
glAttachShader(mProgram, mFragmentShader);
}
Debug::Log("Shader Compiled Successfully!");
int didCompile;
glLinkProgram(mProgram);
glGetProgramiv(mProgram, GL_LINK_STATUS, &didCompile);
if (didCompile == GL_FALSE)
{
char* compileLog;
int length;
glGetProgramiv(mProgram, GL_INFO_LOG_LENGTH, &length);
compileLog = (char*)malloc(length);
glGetProgramInfoLog(mProgram, length, &length, compileLog);
Debug::Log("\nLink Shader Log");
Debug::Log(compileLog);
free(compileLog);
Release();
return S_FALSE;
}
CreateAttribute("Position", VertexAttribute::POSITION);
CreateAttribute("TexCoord0", VertexAttribute::TEXCOORD0);
CreateAttribute("TexCoord1", VertexAttribute::TEXCOORD1);
CreateAttribute("TexCoord2", VertexAttribute::TEXCOORD2);
CreateAttribute("QuadCoord0", VertexAttribute::QUADCOORD0);
CreateAttribute("QuadCoord1", VertexAttribute::QUADCOORD1);
CreateAttribute("QuadCoord2", VertexAttribute::QUADCOORD2);
CreateAttribute("Normal", VertexAttribute::NORMAL);
CreateAttribute("Color", VertexAttribute::COLOR);
CreateAttribute("Tangent", VertexAttribute::TANGENT);
CreateAttribute("BoneCount", VertexAttribute::BONE_COUNT);
CreateAttribute("BoneMatrix", VertexAttribute::BONE_INDEX);
CreateAttribute("BoneWeight", VertexAttribute::BONE_WEIGHT);
if (CreateAttribute("Matrix", VertexAttribute::MATRIX))
mAttributeSize += 3;
VertexLayoutGL* layout = new VertexLayoutGL();
UINT size = (UINT)mAttributes.size();
for (UINT x = 0; x < size; ++x)
{
layout->AddAttribute(mAttributes[x]);
}
mLayout = std::shared_ptr< VertexLayout >(layout);
CreateUniform("_WorldViewProj", ShaderUniform::WORLD_VIEW_PROJ);
CreateUniform("_WorldView", ShaderUniform::WORLD_VIEW);
CreateUniform("_World", ShaderUniform::WORLD);
CreateUniform("_InvWorld", ShaderUniform::INV_WORLD);
CreateUniform("_View", ShaderUniform::VIEW);
CreateUniform("_InvView", ShaderUniform::INV_VIEW);
CreateUniform("_Proj", ShaderUniform::PROJ);
CreateUniform("_InvProj", ShaderUniform::INV_PROJ);
CreateUniform("_Ambient", ShaderUniform::AMBIENT);
CreateUniform("_Diffuse", ShaderUniform::DIFFUSE);
CreateUniform("_Specular", ShaderUniform::SPECULAR);
CreateUniform("_SpecComp", ShaderUniform::SPEC_COMP);
CreateUniform("_LightPos", ShaderUniform::LIGHT_POS);
CreateUniform("_LightDir", ShaderUniform::LIGHT_DIR);
CreateUniform("_LightColor", ShaderUniform::LIGHT_COLOR);
CreateUniform("_LightAttn", ShaderUniform::LIGHT_ATTN);
CreateUniform("_LightMatrix", ShaderUniform::LIGHT_MATRIX);
CreateUniform("_LightCubeMatrix", ShaderUniform::LIGHT_CUBE_MATRIX);
CreateUniform("_CameraPos", ShaderUniform::CAMERA_POS);
CreateUniform("_Bones", ShaderUniform::BONES);
CreateUniform("_DeltaTime", ShaderUniform::DELTA_TIME);
UINT numTextureCube = 0;
if (CreateUniform("_TextureCube", ShaderUniform::LIGHT_TEXTURE_CUBE))
++numTextureCube;
UINT numTexture = 0;
char texName[16];
for (int x = 0; x < MAX_TEXTURES; ++x)
{
sprintf_s(texName, "_Texture%d", x);
if (CreateUniform(texName, ShaderUniform::TEXTURE))
++numTexture;
}
mNumSamplers = numTexture + numTextureCube;
if (mNumSamplers > 0)
{
mSampler = new Sampler*[mNumSamplers];
UINT index = 0;
for (; index < numTextureCube; ++index)
mSampler[index] = new SamplerCubeGL();
for (; index < mNumSamplers; ++index)
mSampler[index] = new SamplerGL();
}
Debug::Log("Shader Created Successfully!");
return S_OK;
}
UsdMayaAdaptor::AttributeAdaptor
UsdMayaAdaptor::SchemaAdaptor::CreateAttribute(const TfToken& attrName)
{
MDGModifier modifier;
return CreateAttribute(attrName, modifier);
}
