/**
* reads a list of ShaderNode{} blocks
*
* @param statements the list of statements to parse
* @throws IOException
*/
protected void readShaderNode(List<Statement> statements) throws IOException {
for (Statement statement : statements) {
String line = statement.getLine();
String[] split = statement.getLine().split("[ \\{]");
if (line.startsWith("Definition")) {
ShaderNodeDefinition def = findDefinition(statement);
shaderNode.setDefinition(def);
if (def.isNoOutput()) {
techniqueDef.getShaderGenerationInfo().getUnusedNodes().remove(shaderNode.getName());
}
} else if (line.startsWith("Condition")) {
String condition = line.substring(line.lastIndexOf(":") + 1).trim();
extractCondition(condition, statement);
shaderNode.setCondition(conditionParser.getFormattedExpression());
} else if (line.startsWith("InputMapping")) {
for (Statement statement1 : statement.getContents()) {
VariableMapping mapping = readInputMapping(statement1);
techniqueDef
.getShaderGenerationInfo()
.getUnusedNodes()
.remove(mapping.getRightVariable().getNameSpace());
shaderNode.getInputMapping().add(mapping);
}
} else if (line.startsWith("OutputMapping")) {
for (Statement statement1 : statement.getContents()) {
VariableMapping mapping = readOutputMapping(statement1);
techniqueDef.getShaderGenerationInfo().getUnusedNodes().remove(shaderNode.getName());
shaderNode.getOutputMapping().add(mapping);
}
} else {
throw new MatParseException("ShaderNodeDefinition", split[0], statement);
}
}
}
/**
* searcha variable in the given list and updates its type and namespace
*
* @param var the variable to update
* @param list the variables list
* @return true if the variable has been found and updated
*/
protected boolean updateVariableFromList(ShaderNodeVariable var, List<ShaderNodeVariable> list) {
for (ShaderNodeVariable shaderNodeVariable : list) {
if (shaderNodeVariable.getName().equals(var.getName())) {
var.setType(shaderNodeVariable.getType());
var.setMultiplicity(shaderNodeVariable.getMultiplicity());
var.setNameSpace(shaderNode.getName());
return true;
}
}
return false;
}
/**
* reads an input mapping
*
* @param statement1 the statement being read
* @return the mapping
* @throws IOException
*/
public VariableMapping readInputMapping(Statement statement1) throws IOException {
VariableMapping mapping = null;
try {
mapping = parseMapping(statement1, new boolean[] {false, true});
} catch (Exception e) {
throw new MatParseException("Unexpected mapping format", statement1, e);
}
ShaderNodeVariable left = mapping.getLeftVariable();
ShaderNodeVariable right = mapping.getRightVariable();
if (!updateVariableFromList(left, shaderNode.getDefinition().getInputs())) {
throw new MatParseException(
left.getName() + " is not an input variable of " + shaderNode.getDefinition().getName(),
statement1);
}
if (left.getType().startsWith("sampler") && !right.getNameSpace().equals("MatParam")) {
throw new MatParseException("Samplers can only be assigned to MatParams", statement1);
}
if (right.getNameSpace().equals("Global")) {
right.setType("vec4"); // Globals are all vec4 for now (maybe forever...)
// updateCondition(right, mapping);
storeGlobal(right, statement1);
} else if (right.getNameSpace().equals("Attr")) {
if (shaderNode.getDefinition().getType() == Shader.ShaderType.Fragment) {
throw new MatParseException(
"Cannot have an attribute as input in a fragment shader" + right.getName(), statement1);
}
updateVarFromAttributes(mapping.getRightVariable(), mapping);
// updateCondition(mapping.getRightVariable(), mapping);
storeAttribute(mapping.getRightVariable());
} else if (right.getNameSpace().equals("MatParam")) {
MatParam param = findMatParam(right.getName());
if (param == null) {
throw new MatParseException(
"Could not find a Material Parameter named " + right.getName(), statement1);
}
if (shaderNode.getDefinition().getType() == Shader.ShaderType.Vertex) {
if (updateRightFromUniforms(param, mapping, vertexDeclaredUniforms, statement1)) {
storeVertexUniform(mapping.getRightVariable());
}
} else {
if (updateRightFromUniforms(param, mapping, fragmentDeclaredUniforms, statement1)) {
if (mapping.getRightVariable().getType().contains("|")) {
String type = fixSamplerType(left.getType(), mapping.getRightVariable().getType());
if (type != null) {
mapping.getRightVariable().setType(type);
} else {
throw new MatParseException(
param.getVarType().toString()
+ " can only be matched to one of "
+ param.getVarType().getGlslType().replaceAll("\\|", ",")
+ " found "
+ left.getType(),
statement1);
}
}
storeFragmentUniform(mapping.getRightVariable());
}
}
} else if (right.getNameSpace().equals("WorldParam")) {
UniformBinding worldParam = findWorldParam(right.getName());
if (worldParam == null) {
throw new MatParseException(
"Could not find a World Parameter named " + right.getName(), statement1);
}
if (shaderNode.getDefinition().getType() == Shader.ShaderType.Vertex) {
if (updateRightFromUniforms(worldParam, mapping, vertexDeclaredUniforms)) {
storeVertexUniform(mapping.getRightVariable());
}
} else {
if (updateRightFromUniforms(worldParam, mapping, fragmentDeclaredUniforms)) {
storeFragmentUniform(mapping.getRightVariable());
}
}
} else {
ShaderNode node = nodes.get(right.getNameSpace());
if (node == null) {
throw new MatParseException(
"Undeclared node"
+ right.getNameSpace()
+ ". Make sure this node is declared before the current node",
statement1);
}
ShaderNodeVariable var = findNodeOutput(node.getDefinition().getOutputs(), right.getName());
if (var == null) {
throw new MatParseException(
"Cannot find output variable" + right.getName() + " form ShaderNode " + node.getName(),
statement1);
}
right.setNameSpace(node.getName());
right.setType(var.getType());
right.setMultiplicity(var.getMultiplicity());
mapping.setRightVariable(right);
storeVaryings(node, mapping.getRightVariable());
}
checkTypes(mapping, statement1);
return mapping;
}