sigonasr2
/
jmonkeyengine
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

*reverted J3MLoader

Browse Source
experimental
michael 10 years ago
parent f64eb5ff09
commit 9e74c4e2bb
1 changed files with 195 additions and 187 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 382
      jme3-core/src/plugins/java/com/jme3/material/plugins/J3MLoader.java

382
jme3-core/src/plugins/java/com/jme3/material/plugins/J3MLoader.java
Unescape View File

@ -40,6 +40,7 @@ import com.jme3.material.TechniqueDef.ShadowMode;
import com.jme3.math.ColorRGBA;
import com.jme3.math.Vector2f;
import com.jme3.math.Vector3f;
import com.jme3.shader.Shader;
import com.jme3.shader.VarType;
import com.jme3.texture.Texture;
import com.jme3.texture.Texture.WrapMode;
@ -48,8 +49,10 @@ import com.jme3.texture.image.ColorSpace;
import com.jme3.util.PlaceholderAssets;
import com.jme3.util.blockparser.BlockLanguageParser;
import com.jme3.util.blockparser.Statement;
import java.io.IOException;
import java.io.InputStream;
import java.util.EnumMap;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
@ -57,10 +60,10 @@ import java.util.logging.Logger;
public class J3MLoader implements AssetLoader {
private static final Logger logger = Logger.getLogger(J3MLoader.class.getName());
// private ErrorLogger errors;
// private ErrorLogger errors;
private ShaderNodeLoaderDelegate nodesLoaderDelegate;
boolean isUseNodes = false;
private AssetManager assetManager;
private AssetKey key;
@ -68,16 +71,15 @@ public class J3MLoader implements AssetLoader {
private Material material;
private TechniqueDef technique;
private RenderState renderState;
private String vertLanguage;
private String fragLanguage;
private String vertName;
private String fragName;
private EnumMap<Shader.ShaderType, String> shaderLanguage;
private EnumMap<Shader.ShaderType, String> shaderName;
private static final String whitespacePattern = "\\p{javaWhitespace}+";
public J3MLoader(){
public J3MLoader() {
shaderLanguage = new EnumMap<Shader.ShaderType, String>(Shader.ShaderType.class);
shaderName = new EnumMap<Shader.ShaderType, String>(Shader.ShaderType.class);
}
@ -91,20 +93,25 @@ public class J3MLoader implements AssetLoader {
if (typeAndLang.length != 2) {
throw new IOException("Shader statement syntax incorrect: " + statement);
}
if (typeAndLang[0].equals("VertexShader")) {
vertName = split[1].trim();
vertLanguage = typeAndLang[1];
} else if (typeAndLang[0].equals("FragmentShader")) {
fragName = split[1].trim();
fragLanguage = typeAndLang[1];
for (Shader.ShaderType shaderType : Shader.ShaderType.values()) {
if (typeAndLang[0].equals(shaderType.toString() + "Shader")) {
readShaderDefinition(shaderType, split[1].trim(), typeAndLang[1]);
}
}
}
private void readShaderDefinition(Shader.ShaderType shaderType, String name, String language) {
System.out.println(shaderType);
System.out.println(name);
shaderName.put(shaderType, name);
shaderLanguage.put(shaderType, language);
}
// LightMode <MODE>
private void readLightMode(String statement) throws IOException{
private void readLightMode(String statement) throws IOException {
String[] split = statement.split(whitespacePattern);
if (split.length != 2){
if (split.length != 2) {
throw new IOException("LightMode statement syntax incorrect");
}
LightMode lm = LightMode.valueOf(split[1]);
@ -112,29 +119,29 @@ public class J3MLoader implements AssetLoader {
}
// ShadowMode <MODE>
private void readShadowMode(String statement) throws IOException{
private void readShadowMode(String statement) throws IOException {
String[] split = statement.split(whitespacePattern);
if (split.length != 2){
if (split.length != 2) {
throw new IOException("ShadowMode statement syntax incorrect");
}
ShadowMode sm = ShadowMode.valueOf(split[1]);
technique.setShadowMode(sm);
}
private Object readValue(VarType type, String value) throws IOException{
if (type.isTextureType()){
private Object readValue(VarType type, String value) throws IOException {
if (type.isTextureType()) {
// String texturePath = readString("[\n;(//)(\\})]");
String texturePath = value.trim();
boolean flipY = false;
boolean repeat = false;
if (texturePath.startsWith("Flip Repeat ")){
if (texturePath.startsWith("Flip Repeat ")) {
texturePath = texturePath.substring(12).trim();
flipY = true;
repeat = true;
}else if (texturePath.startsWith("Flip ")){
} else if (texturePath.startsWith("Flip ")) {
texturePath = texturePath.substring(5).trim();
flipY = true;
}else if (texturePath.startsWith("Repeat ")){
} else if (texturePath.startsWith("Repeat ")) {
texturePath = texturePath.substring(7).trim();
repeat = true;
}
@ -156,270 +163,273 @@ public class J3MLoader implements AssetLoader {
Texture tex;
try {
tex = assetManager.loadTexture(texKey);
} catch (AssetNotFoundException ex){
} catch (AssetNotFoundException ex) {
logger.log(Level.WARNING, "Cannot locate {0} for material {1}", new Object[]{texKey, key});
tex = null;
}
if (tex != null){
if (repeat){
if (tex != null) {
if (repeat) {
tex.setWrap(WrapMode.Repeat);
}
}else{
}
} else {
tex = new Texture2D(PlaceholderAssets.getPlaceholderImage(assetManager));
if (repeat){
if (repeat) {
tex.setWrap(WrapMode.Repeat);
}
tex.setKey(texKey);
}
}
return tex;
}else{
} else {
String[] split = value.trim().split(whitespacePattern);
switch (type){
switch (type) {
case Float:
if (split.length != 1){
if (split.length != 1) {
throw new IOException("Float value parameter must have 1 entry: " + value);
}
return Float.parseFloat(split[0]);
return Float.parseFloat(split[0]);
case Vector2:
if (split.length != 2){
if (split.length != 2) {
throw new IOException("Vector2 value parameter must have 2 entries: " + value);
}
return new Vector2f(Float.parseFloat(split[0]),
Float.parseFloat(split[1]));
Float.parseFloat(split[1]));
case Vector3:
if (split.length != 3){
if (split.length != 3) {
throw new IOException("Vector3 value parameter must have 3 entries: " + value);
}
return new Vector3f(Float.parseFloat(split[0]),
Float.parseFloat(split[1]),
Float.parseFloat(split[2]));
Float.parseFloat(split[1]),
Float.parseFloat(split[2]));
case Vector4:
if (split.length != 4){
if (split.length != 4) {
throw new IOException("Vector4 value parameter must have 4 entries: " + value);
}
return new ColorRGBA(Float.parseFloat(split[0]),
Float.parseFloat(split[1]),
Float.parseFloat(split[2]),
Float.parseFloat(split[3]));
Float.parseFloat(split[1]),
Float.parseFloat(split[2]),
Float.parseFloat(split[3]));
case Int:
if (split.length != 1){
if (split.length != 1) {
throw new IOException("Int value parameter must have 1 entry: " + value);
}
return Integer.parseInt(split[0]);
case Boolean:
if (split.length != 1){
if (split.length != 1) {
throw new IOException("Boolean value parameter must have 1 entry: " + value);
}
return Boolean.parseBoolean(split[0]);
default:
throw new UnsupportedOperationException("Unknown type: "+type);
throw new UnsupportedOperationException("Unknown type: " + type);
}
}
}
// <TYPE> <NAME> [ "(" <FFBINDING> ")" ] [ ":" <DEFAULTVAL> ] [-LINEAR]
private void readParam(String statement) throws IOException{
private void readParam(String statement) throws IOException {
String name;
String defaultVal = null;
ColorSpace colorSpace = null;
String[] split = statement.split("-");
if(split.length>1){
if(split[1].equalsIgnoreCase("LINEAR")){
if (split.length > 1) {
if (split[1].equalsIgnoreCase("LINEAR")) {
colorSpace = ColorSpace.Linear;
}
statement = split[0].trim();
}
split = statement.split(":");
// Parse default val
if (split.length == 1){
if (split.length == 1) {
// Doesn't contain default value
}else{
if (split.length != 2){
} else {
if (split.length != 2) {
throw new IOException("Parameter statement syntax incorrect");
}
statement = split[0].trim();
defaultVal = split[1].trim();
defaultVal = split[1].trim();
}
// Parse ffbinding
int startParen = statement.indexOf("(");
if (startParen != -1){
if (startParen != -1) {
// get content inside parentheses
int endParen = statement.indexOf(")", startParen);
String bindingStr = statement.substring(startParen+1, endParen).trim();
String bindingStr = statement.substring(startParen + 1, endParen).trim();
// don't care about bindingStr
statement = statement.substring(0, startParen);
}
// Parse type + name
split = statement.split(whitespacePattern);
if (split.length != 2){
if (split.length != 2) {
throw new IOException("Parameter statement syntax incorrect");
}
VarType type;
if (split[0].equals("Color")){
if (split[0].equals("Color")) {
type = VarType.Vector4;
}else{
} else {
type = VarType.valueOf(split[0]);
}
name = split[1];
Object defaultValObj = null;
if (defaultVal != null){
if (defaultVal != null) {
defaultValObj = readValue(type, defaultVal);
}
if(type.isTextureType()){
materialDef.addMaterialParamTexture(type, name, colorSpace);
}else{
if (type.isTextureType()) {
materialDef.addMaterialParamTexture(type, name, colorSpace);
} else {
materialDef.addMaterialParam(type, name, defaultValObj);
}
}
private void readValueParam(String statement) throws IOException{
private void readValueParam(String statement) throws IOException {
// Use limit=1 incase filename contains colons
String[] split = statement.split(":", 2);
if (split.length != 2){
if (split.length != 2) {
throw new IOException("Value parameter statement syntax incorrect");
}
String name = split[0].trim();
// parse value
MatParam p = material.getMaterialDef().getMaterialParam(name);
if (p == null){
throw new IOException("The material parameter: "+name+" is undefined.");
if (p == null) {
throw new IOException("The material parameter: " + name + " is undefined.");
}
Object valueObj = readValue(p.getVarType(), split[1]);
if (p.getVarType().isTextureType()){
if (p.getVarType().isTextureType()) {
material.setTextureParam(name, p.getVarType(), (Texture) valueObj);
}else{
} else {
material.setParam(name, p.getVarType(), valueObj);
}
}
private void readMaterialParams(List<Statement> paramsList) throws IOException{
for (Statement statement : paramsList){
private void readMaterialParams(List<Statement> paramsList) throws IOException {
for (Statement statement : paramsList) {
readParam(statement.getLine());
}
}
private void readExtendingMaterialParams(List<Statement> paramsList) throws IOException{
for (Statement statement : paramsList){
private void readExtendingMaterialParams(List<Statement> paramsList) throws IOException {
for (Statement statement : paramsList) {
readValueParam(statement.getLine());
}
}
private void readWorldParams(List<Statement> worldParams) throws IOException{
for (Statement statement : worldParams){
private void readWorldParams(List<Statement> worldParams) throws IOException {
for (Statement statement : worldParams) {
technique.addWorldParam(statement.getLine());
}
}
private boolean parseBoolean(String word){
private boolean parseBoolean(String word) {
return word != null && word.equals("On");
}
private void readRenderStateStatement(Statement statement) throws IOException{
private void readRenderStateStatement(Statement statement) throws IOException {
String[] split = statement.getLine().split(whitespacePattern);
if (split[0].equals("Wireframe")){
if (split[0].equals("Wireframe")) {
renderState.setWireframe(parseBoolean(split[1]));
}else if (split[0].equals("FaceCull")){
} else if (split[0].equals("FaceCull")) {
renderState.setFaceCullMode(FaceCullMode.valueOf(split[1]));
}else if (split[0].equals("DepthWrite")){
} else if (split[0].equals("DepthWrite")) {
renderState.setDepthWrite(parseBoolean(split[1]));
}else if (split[0].equals("DepthTest")){
} else if (split[0].equals("DepthTest")) {
renderState.setDepthTest(parseBoolean(split[1]));
}else if (split[0].equals("Blend")){
} else if (split[0].equals("Blend")) {
renderState.setBlendMode(BlendMode.valueOf(split[1]));
}else if (split[0].equals("AlphaTestFalloff")){
} else if (split[0].equals("AlphaTestFalloff")) {
renderState.setAlphaTest(true);
renderState.setAlphaFallOff(Float.parseFloat(split[1]));
}else if (split[0].equals("PolyOffset")){
} else if (split[0].equals("PolyOffset")) {
float factor = Float.parseFloat(split[1]);
float units = Float.parseFloat(split[2]);
renderState.setPolyOffset(factor, units);
}else if (split[0].equals("ColorWrite")){
} else if (split[0].equals("ColorWrite")) {
renderState.setColorWrite(parseBoolean(split[1]));
}else if (split[0].equals("PointSprite")){
} else if (split[0].equals("PointSprite")) {
renderState.setPointSprite(parseBoolean(split[1]));
}else if (split[0].equals("DepthFunc")){
} else if (split[0].equals("DepthFunc")) {
renderState.setDepthFunc(RenderState.TestFunction.valueOf(split[1]));
}else if (split[0].equals("AlphaFunc")){
} else if (split[0].equals("AlphaFunc")) {
renderState.setAlphaFunc(RenderState.TestFunction.valueOf(split[1]));
} else {
throw new MatParseException(null, split[0], statement);
}
}
private void readAdditionalRenderState(List<Statement> renderStates) throws IOException{
private void readAdditionalRenderState(List<Statement> renderStates) throws IOException {
renderState = material.getAdditionalRenderState();
for (Statement statement : renderStates){
for (Statement statement : renderStates) {
readRenderStateStatement(statement);
}
renderState = null;
}
private void readRenderState(List<Statement> renderStates) throws IOException{
private void readRenderState(List<Statement> renderStates) throws IOException {
renderState = new RenderState();
for (Statement statement : renderStates){
for (Statement statement : renderStates) {
readRenderStateStatement(statement);
}
technique.setRenderState(renderState);
renderState = null;
}
private void readForcedRenderState(List<Statement> renderStates) throws IOException{
private void readForcedRenderState(List<Statement> renderStates) throws IOException {
renderState = new RenderState();
for (Statement statement : renderStates){
for (Statement statement : renderStates) {
readRenderStateStatement(statement);
}
technique.setForcedRenderState(renderState);
renderState = null;
}
// <DEFINENAME> [ ":" <PARAMNAME> ]
private void readDefine(String statement) throws IOException{
private void readDefine(String statement) throws IOException {
String[] split = statement.split(":");
if (split.length == 1){
if (split.length == 1) {
// add preset define
technique.addShaderPresetDefine(split[0].trim(), VarType.Boolean, true);
}else if (split.length == 2){
} else if (split.length == 2) {
technique.addShaderParamDefine(split[1].trim(), split[0].trim());
}else{
} else {
throw new IOException("Define syntax incorrect");
}
}
private void readDefines(List<Statement> defineList) throws IOException{
for (Statement statement : defineList){
private void readDefines(List<Statement> defineList) throws IOException {
for (Statement statement : defineList) {
readDefine(statement.getLine());
}
}
private void readTechniqueStatement(Statement statement) throws IOException{
String[] split = statement.getLine().split("[ \\{]");
private void readTechniqueStatement(Statement statement) throws IOException {
String[] split = statement.getLine().split("[ \\{]");
if (split[0].equals("VertexShader") ||
split[0].equals("FragmentShader")){
split[0].equals("FragmentShader") ||
split[0].equals("GeometryShader") ||
split[0].equals("TesselationControlShader") ||
split[0].equals("TesselationEvaluationShader")) {
readShaderStatement(statement.getLine());
}else if (split[0].equals("LightMode")){
} else if (split[0].equals("LightMode")) {
readLightMode(statement.getLine());
}else if (split[0].equals("ShadowMode")){
} else if (split[0].equals("ShadowMode")) {
readShadowMode(statement.getLine());
}else if (split[0].equals("WorldParameters")){
} else if (split[0].equals("WorldParameters")) {
readWorldParams(statement.getContents());
}else if (split[0].equals("RenderState")){
} else if (split[0].equals("RenderState")) {
readRenderState(statement.getContents());
}else if (split[0].equals("ForcedRenderState")){
} else if (split[0].equals("ForcedRenderState")) {
readForcedRenderState(statement.getContents());
}else if (split[0].equals("Defines")){
readDefines(statement.getContents());
} else if (split[0].equals("Defines")) {
readDefines(statement.getContents());
} else if (split[0].equals("ShaderNodesDefinitions")) {
initNodesLoader();
if (isUseNodes) {
@ -432,23 +442,23 @@ public class J3MLoader implements AssetLoader {
}
} else if (split[0].equals("FragmentShaderNodes")) {
initNodesLoader();
if (isUseNodes) {
if (isUseNodes) {
nodesLoaderDelegate.readFragmentShaderNodes(statement.getContents());
}
} else {
throw new MatParseException(null, split[0], statement);
}
}
private void readTransparentStatement(String statement) throws IOException{
private void readTransparentStatement(String statement) throws IOException {
String[] split = statement.split(whitespacePattern);
if (split.length != 2){
if (split.length != 2) {
throw new IOException("Transparent statement syntax incorrect");
}
material.setTransparent(parseBoolean(split[1]));
}
private void readTechnique(Statement techStat) throws IOException{
private void readTechnique(Statement techStat) throws IOException {
isUseNodes = false;
String[] split = techStat.getLine().split(whitespacePattern);
if (split.length == 1) {
@ -459,64 +469,62 @@ public class J3MLoader implements AssetLoader {
} else {
throw new IOException("Technique statement syntax incorrect");
}
for (Statement statement : techStat.getContents()){
for (Statement statement : techStat.getContents()) {
readTechniqueStatement(statement);
}
if(isUseNodes){
if (isUseNodes) {
nodesLoaderDelegate.computeConditions();
//used for caching later, the shader here is not a file.
technique.setShaderFile(technique.hashCode() + "", technique.hashCode() + "", "GLSL100", "GLSL100");
}
if (vertName != null && fragName != null){
technique.setShaderFile(vertName, fragName, vertLanguage, fragLanguage);
if (shaderName.containsKey(Shader.ShaderType.Vertex) && shaderName.containsKey(Shader.ShaderType.Fragment)) {
technique.setShaderFile(shaderName, shaderLanguage);
}
materialDef.addTechniqueDef(technique);
technique = null;
vertName = null;
fragName = null;
vertLanguage = null;
fragLanguage = null;
shaderLanguage.clear();
shaderName.clear();
}
private void loadFromRoot(List<Statement> roots) throws IOException{
if (roots.size() == 2){
private void loadFromRoot(List<Statement> roots) throws IOException {
if (roots.size() == 2) {
Statement exception = roots.get(0);
String line = exception.getLine();
if (line.startsWith("Exception")){
if (line.startsWith("Exception")) {
throw new AssetLoadException(line.substring("Exception ".length()));
}else{
} else {
throw new IOException("In multiroot material, expected first statement to be 'Exception'");
}
}else if (roots.size() != 1){
} else if (roots.size() != 1) {
throw new IOException("Too many roots in J3M/J3MD file");
}
boolean extending = false;
Statement materialStat = roots.get(0);
String materialName = materialStat.getLine();
if (materialName.startsWith("MaterialDef")){
if (materialName.startsWith("MaterialDef")) {
materialName = materialName.substring("MaterialDef ".length()).trim();
extending = false;
}else if (materialName.startsWith("Material")){
} else if (materialName.startsWith("Material")) {
materialName = materialName.substring("Material ".length()).trim();
extending = true;
}else{
} else {
throw new IOException("Specified file is not a Material file");
}
String[] split = materialName.split(":", 2);
if (materialName.equals("")){
throw new MatParseException("Material name cannot be empty", materialStat);
if (materialName.equals("")) {
throw new MatParseException("Material name cannot be empty", materialStat);
}
if (split.length == 2){
if (!extending){
throw new MatParseException("Must use 'Material' when extending.", materialStat);
if (split.length == 2) {
if (!extending) {
throw new MatParseException("Must use 'Material' when extending.", materialStat);
}
String extendedMat = split[1].trim();
@ -529,65 +537,65 @@ public class J3MLoader implements AssetLoader {
material = new Material(def);
material.setKey(key);
// material.setAssetName(fileName);
}else if (split.length == 1){
if (extending){
throw new MatParseException("Expected ':', got '{'", materialStat);
} else if (split.length == 1) {
if (extending) {
throw new MatParseException("Expected ':', got '{'", materialStat);
}
materialDef = new MaterialDef(assetManager, materialName);
// NOTE: pass file name for defs so they can be loaded later
materialDef.setAssetName(key.getName());
}else{
throw new MatParseException("Cannot use colon in material name/path", materialStat);
} else {
throw new MatParseException("Cannot use colon in material name/path", materialStat);
}
for (Statement statement : materialStat.getContents()){
for (Statement statement : materialStat.getContents()) {
split = statement.getLine().split("[ \\{]");
String statType = split[0];
if (extending){
if (statType.equals("MaterialParameters")){
if (extending) {
if (statType.equals("MaterialParameters")) {
readExtendingMaterialParams(statement.getContents());
}else if (statType.equals("AdditionalRenderState")){
} else if (statType.equals("AdditionalRenderState")) {
readAdditionalRenderState(statement.getContents());
}else if (statType.equals("Transparent")){
} else if (statType.equals("Transparent")) {
readTransparentStatement(statement.getLine());
}
}else{
if (statType.equals("Technique")){
} else {
if (statType.equals("Technique")) {
readTechnique(statement);
}else if (statType.equals("MaterialParameters")){
} else if (statType.equals("MaterialParameters")) {
readMaterialParams(statement.getContents());
}else{
throw new MatParseException("Expected material statement, got '"+statType+"'", statement);
} else {
throw new MatParseException("Expected material statement, got '" + statType + "'", statement);
}
}
}
}
public Object load(AssetInfo info) throws IOException {
public Object load(AssetInfo info) throws IOException {
this.assetManager = info.getManager();
InputStream in = info.openStream();
InputStream in = info.openStream();
try {
key = info.getKey();
key = info.getKey();
loadFromRoot(BlockLanguageParser.parse(in));
} finally {
if (in != null){
if (in != null) {
in.close();
}
}
if (material != null){
if (!(info.getKey() instanceof MaterialKey)){
if (material != null) {
if (!(info.getKey() instanceof MaterialKey)) {
throw new IOException("Material instances must be loaded via MaterialKey");
}
// material implementation
return material;
}else{
} else {
// material definition
return materialDef;
}
}
public MaterialDef loadMaterialDef(List<Statement> roots, AssetManager manager, AssetKey key) throws IOException {
this.key = key;
this.assetManager = manager;
@ -597,11 +605,11 @@ public class J3MLoader implements AssetLoader {
protected void initNodesLoader() {
if (!isUseNodes) {
isUseNodes = fragName == null && vertName == null;
if (isUseNodes) {
if(nodesLoaderDelegate == null){
isUseNodes = shaderName.get(Shader.ShaderType.Vertex) == null && shaderName.get(Shader.ShaderType.Fragment) == null;
if (isUseNodes) {
if (nodesLoaderDelegate == null) {
nodesLoaderDelegate = new ShaderNodeLoaderDelegate();
}else{
} else {
nodesLoaderDelegate.clear();
}
nodesLoaderDelegate.setTechniqueDef(technique);
@ -609,6 +617,6 @@ public class J3MLoader implements AssetLoader {
nodesLoaderDelegate.setAssetManager(assetManager);
}
}
}
}
}

Write Preview
Loading…
Cancel
Save