// <DEFINENAME> [ ":" <PARAMNAME> ]
private void readDefine(String statement) throws IOException {
String[] split = statement.split(":");
if (split.length == 1) {
String defineName = split[0].trim();
presetDefines.add(defineName);
} else if (split.length == 2) {
String defineName = split[0].trim();
String paramName = split[1].trim();
MatParam param = materialDef.getMaterialParam(paramName);
if (param == null) {
logger.log(
Level.WARNING,
"In technique ''{0}'':\n"
+ "Define ''{1}'' mapped to non-existent"
+ " material parameter ''{2}'', ignoring.",
new Object[] {technique.getName(), defineName, paramName});
return;
}
VarType paramType = param.getVarType();
technique.addShaderParamDefine(paramName, paramType, defineName);
} else {
throw new IOException("Define syntax incorrect");
}
}
private void readTechnique(Statement techStat) throws IOException {
isUseNodes = false;
String[] split = techStat.getLine().split(whitespacePattern);
if (split.length == 1) {
technique = new TechniqueDef(null);
} else if (split.length == 2) {
String techName = split[1];
technique = new TechniqueDef(techName);
} else {
throw new IOException("Technique statement syntax incorrect");
}
for (Statement statement : techStat.getContents()) {
readTechniqueStatement(statement);
}
if (isUseNodes) {
nodesLoaderDelegate.computeConditions();
// used for caching later, the shader here is not a file.
technique.setShaderFile(
technique.hashCode() + "", technique.hashCode() + "", "GLSL100", "GLSL100");
}
if (shaderName.containsKey(Shader.ShaderType.Vertex)
&& shaderName.containsKey(Shader.ShaderType.Fragment)) {
technique.setShaderFile(shaderName, shaderLanguage);
}
materialDef.addTechniqueDef(technique);
technique = null;
shaderLanguage.clear();
shaderName.clear();
}
// <DEFINENAME> [ ":" <PARAMNAME> ]
private void readDefine(String statement) throws IOException {
String[] split = statement.split(":");
if (split.length == 1) {
// add preset define
technique.addShaderPresetDefine(split[0].trim(), VarType.Boolean, true);
} else if (split.length == 2) {
technique.addShaderParamDefine(split[1].trim(), split[0].trim());
} else {
throw new IOException("Define syntax incorrect");
}
}
private void readForcedRenderState(List<Statement> renderStates) throws IOException {
renderState = new RenderState();
for (Statement statement : renderStates) {
readRenderStateStatement(statement);
}
technique.setForcedRenderState(renderState);
renderState = null;
}
// ShadowMode <MODE>
private void readShadowMode(String statement) throws IOException {
String[] split = statement.split(whitespacePattern);
if (split.length != 2) {
throw new IOException("ShadowMode statement syntax incorrect");
}
ShadowMode sm = ShadowMode.valueOf(split[1]);
technique.setShadowMode(sm);
}
// LightMode <SPACE>
private void readLightSpace(String statement) throws IOException {
String[] split = statement.split(whitespacePattern);
if (split.length != 2) {
throw new IOException("LightSpace statement syntax incorrect");
}
TechniqueDef.LightSpace ls = TechniqueDef.LightSpace.valueOf(split[1]);
technique.setLightSpace(ls);
}
private void readShaderDefinition(
Shader.ShaderType shaderType, String name, String... languages) {
shaderNames.put(shaderType, name);
if (langSize != 0 && langSize != languages.length) {
throw new AssetLoadException(
"Technique "
+ technique.getName()
+ " must have the same number of languages for each shader type.");
}
langSize = languages.length;
for (int i = 0; i < languages.length; i++) {
if (i >= shaderLanguages.size()) {
shaderLanguages.add(new EnumMap<Shader.ShaderType, String>(Shader.ShaderType.class));
}
shaderLanguages.get(i).put(shaderType, languages[i]);
}
}
private void readTechniqueStatement(Statement statement) throws IOException {
String[] split = statement.getLine().split("[ \\{]");
if (split[0].equals("VertexShader")
|| split[0].equals("FragmentShader")
|| split[0].equals("GeometryShader")
|| split[0].equals("TessellationControlShader")
|| split[0].equals("TessellationEvaluationShader")) {
readShaderStatement(statement.getLine());
} else if (split[0].equals("LightMode")) {
readLightMode(statement.getLine());
} else if (split[0].equals("LightSpace")) {
readLightSpace(statement.getLine());
} else if (split[0].equals("ShadowMode")) {
readShadowMode(statement.getLine());
} else if (split[0].equals("WorldParameters")) {
readWorldParams(statement.getContents());
} else if (split[0].equals("RenderState")) {
readRenderState(statement.getContents());
} else if (split[0].equals("ForcedRenderState")) {
readForcedRenderState(statement.getContents());
} else if (split[0].equals("Defines")) {
readDefines(statement.getContents());
} else if (split[0].equals("ShaderNodesDefinitions")) {
initNodesLoader();
if (isUseNodes) {
nodesLoaderDelegate.readNodesDefinitions(statement.getContents());
}
} else if (split[0].equals("VertexShaderNodes")) {
initNodesLoader();
if (isUseNodes) {
nodesLoaderDelegate.readVertexShaderNodes(statement.getContents());
}
} else if (split[0].equals("FragmentShaderNodes")) {
initNodesLoader();
if (isUseNodes) {
nodesLoaderDelegate.readFragmentShaderNodes(statement.getContents());
}
} else if (split[0].equals("NoRender")) {
technique.setNoRender(true);
} else {
throw new MatParseException(null, split[0], statement);
}
}
private void readTechnique(Statement techStat) throws IOException {
isUseNodes = false;
String[] split = techStat.getLine().split(whitespacePattern);
String name;
if (split.length == 1) {
name = TechniqueDef.DEFAULT_TECHNIQUE_NAME;
} else if (split.length == 2) {
name = split[1];
} else {
throw new IOException("Technique statement syntax incorrect");
}
String techniqueUniqueName = materialDef.getAssetName() + "@" + name;
technique = new TechniqueDef(name, techniqueUniqueName.hashCode());
for (Statement statement : techStat.getContents()) {
readTechniqueStatement(statement);
}
technique.setShaderPrologue(createShaderPrologue(presetDefines));
switch (technique.getLightMode()) {
case Disable:
technique.setLogic(new DefaultTechniqueDefLogic(technique));
break;
case MultiPass:
technique.setLogic(new MultiPassLightingLogic(technique));
break;
case SinglePass:
technique.setLogic(new SinglePassLightingLogic(technique));
break;
case StaticPass:
technique.setLogic(new StaticPassLightingLogic(technique));
break;
case SinglePassAndImageBased:
technique.setLogic(new SinglePassAndImageBasedLightingLogic(technique));
break;
default:
throw new UnsupportedOperationException();
}
List<TechniqueDef> techniqueDefs = new ArrayList<>();
if (isUseNodes) {
nodesLoaderDelegate.computeConditions();
// used for caching later, the shader here is not a file.
// KIRILL 9/19/2015
// Not sure if this is needed anymore, since shader caching
// is now done by TechniqueDef.
technique.setShaderFile(
technique.hashCode() + "", technique.hashCode() + "", "GLSL100", "GLSL100");
techniqueDefs.add(technique);
} else if (shaderNames.containsKey(Shader.ShaderType.Vertex)
&& shaderNames.containsKey(Shader.ShaderType.Fragment)) {
if (shaderLanguages.size() > 1) {
for (int i = 1; i < shaderLanguages.size(); i++) {
TechniqueDef td = null;
try {
td = (TechniqueDef) technique.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
td.setShaderFile(shaderNames, shaderLanguages.get(i));
techniqueDefs.add(td);
}
}
technique.setShaderFile(shaderNames, shaderLanguages.get(0));
techniqueDefs.add(technique);
} else {
technique = null;
shaderLanguages.clear();
shaderNames.clear();
presetDefines.clear();
langSize = 0;
logger.log(Level.WARNING, "Fixed function technique was ignored");
logger.log(
Level.WARNING,
"Fixed function technique ''{0}'' was ignored for material {1}",
new Object[] {name, key});
return;
}
for (TechniqueDef techniqueDef : techniqueDefs) {
materialDef.addTechniqueDef(techniqueDef);
}
technique = null;
langSize = 0;
shaderLanguages.clear();
shaderNames.clear();
presetDefines.clear();
}
private void readWorldParams(List<Statement> worldParams) throws IOException {
for (Statement statement : worldParams) {
technique.addWorldParam(statement.getLine());
}
}