use of com.badlogic.gdx.utils.JsonValue in project bdx by GoranM.
the class GameObject method mesh.
public void mesh(Mesh mesh) {
String meshName = mesh.name();
if (// You're already set to the current mesh
mesh == this.mesh)
return;
JsonValue mOrigin = null;
JsonValue mDimNoScale = null;
ArrayList<Scene> sceneList = new ArrayList<Scene>(Bdx.scenes);
if (sceneList.indexOf(scene) >= 0)
Collections.swap(sceneList, sceneList.indexOf(scene), 0);
else
sceneList.add(0, scene);
for (Scene sce : sceneList) {
if (sce.meshes.containsKey(meshName)) {
mOrigin = sce.json.get("origins").get(meshName);
mDimNoScale = sce.json.get("dimensions").get(meshName);
break;
}
}
origin = mOrigin == null ? new Vector3f() : new Vector3f(mOrigin.asFloatArray());
dimensionsNoScale = mDimNoScale == null ? new Vector3f(1, 1, 1) : new Vector3f(mDimNoScale.asFloatArray());
Matrix4 trans;
if (modelInstance != null) {
trans = modelInstance.transform;
this.mesh.instances.remove(this);
} else
trans = new Matrix4();
this.mesh = mesh;
modelInstance = mesh.getInstance();
modelInstance.transform.set(trans);
}
use of com.badlogic.gdx.utils.JsonValue in project bdx by GoranM.
the class Scene method cloneNoChildren.
private GameObject cloneNoChildren(GameObject gobj) {
GameObject g = instantiator.newObject(gobj.json);
g.json = gobj.json;
g.name = gobj.name;
g.visibleNoChildren(gobj.visible());
g.scene = this;
g.mesh(gobj.mesh());
g.body = Bullet.cloneBody(gobj.body);
g.currBodyType = gobj.currBodyType;
g.currBoundsType = gobj.currBoundsType;
g.origin = gobj.origin;
g.dimensionsNoScale = gobj.dimensionsNoScale;
g.body.setUserPointer(g);
g.scale(gobj.scale());
g.props = new HashMap<String, JsonValue>(gobj.props);
if (g instanceof Camera) {
Camera c = (Camera) g;
Camera cobj = (Camera) gobj;
c.initData(cobj.type);
c.size(cobj.size());
c.resolution(cobj.resolution());
if (c.type == Camera.Type.PERSPECTIVE) {
c.fov(cobj.fov());
} else {
c.zoom(cobj.zoom());
}
c.near(cobj.near());
c.far(cobj.far());
c.update();
cameras.add(c);
} else if (g instanceof Text) {
Text t = (Text) g;
Text tt = (Text) gobj;
t.font = tt.font;
t.text(tt.text());
t.capacity = tt.capacity;
t.mesh(t.mesh().copy());
t.alignment(tt.alignment());
} else if (g instanceof Light) {
Light l = (Light) g;
Light ll = (Light) gobj;
l.energy(ll.energy());
l.color(ll.color());
l.spotSize(ll.spotSize());
l.exponent(ll.exponent());
l.type = ll.type;
l.makeLightData();
l.updateLight();
l.on(true);
}
return g;
}
use of com.badlogic.gdx.utils.JsonValue in project bdx by GoranM.
the class Scene method init.
public void init() {
requestedRestart = false;
requestedEnd = false;
paused = false;
visible = true;
if (shapeRenderer == null)
shapeRenderer = new ShapeRenderer();
drawCommands = new ArrayList<ArrayList<Object>>();
lastFrameBuffer = new RenderBuffer(null);
environment = new Environment();
environment.set(new ColorAttribute(ColorAttribute.AmbientLight, 0, 0, 0, 1));
environment.set(new PointLightsAttribute());
environment.set(new SpotLightsAttribute());
environment.set(new DirectionalLightsAttribute());
screenShaders = new ArrayList<ScreenShader>();
defaultMaterial = new Material("__BDX_DEFAULT");
defaultMaterial.set(new ColorAttribute(ColorAttribute.AmbientLight, 1, 1, 1, 1));
defaultMaterial.set(new ColorAttribute(ColorAttribute.Diffuse, 1, 1, 1, 1));
defaultMaterial.set(new BlendingAttribute());
defaultMaterial.set(new BDXColorAttribute(BDXColorAttribute.Tint, 0, 0, 0));
defaultMesh = new Mesh(new ModelBuilder().createBox(1.0f, 1.0f, 1.0f, defaultMaterial, Usage.Position | Usage.Normal | Usage.TextureCoordinates), this);
meshes = new HashMap<String, Mesh>();
textures = new HashMap<String, Texture>();
materials = new HashMap<String, Material>();
modelToFrame = new HashMap<>();
materials.put(defaultMaterial.id, defaultMaterial);
BroadphaseInterface broadphase = new DbvtBroadphase();
DefaultCollisionConfiguration collisionConfiguration = new DefaultCollisionConfiguration();
SequentialImpulseConstraintSolver solver = new SequentialImpulseConstraintSolver();
CollisionDispatcher dispatcher = new CollisionDispatcher(collisionConfiguration);
toBeAdded = new ArrayList<GameObject>();
toBeRemoved = new ArrayList<GameObject>();
objects = new LinkedListNamed<GameObject>();
lights = new LinkedListNamed<Light>();
templates = new HashMap<String, GameObject>();
json = new JsonReader().parse(scene);
name = json.get("name").asString();
world = new DiscreteDynamicsWorld(dispatcher, broadphase, solver, collisionConfiguration);
world.setDebugDrawer(new Bullet.DebugDrawer(json.get("physviz").asBoolean()));
gravity(new Vector3f(0, 0, -json.get("gravity").asFloat()));
float[] ac = json.get("ambientColor").asFloatArray();
ambientLight(new Color(ac[0], ac[1], ac[2], 1));
if (!clearColorDefaultSet) {
float[] cc = json.get("clearColor").asFloatArray();
Bdx.display.clearColor.set(cc[0], cc[1], cc[2], 0);
clearColorDefaultSet = true;
}
if (json.get("framerateProfile").asBoolean()) {
Bdx.profiler.init();
}
float[] fc = json.get("clearColor").asFloatArray();
fogColor = new Color(fc[0], fc[1], fc[2], 1);
fog(json.get("mistOn").asBoolean());
fogRange(json.get("mistStart").asFloat(), json.get("mistDepth").asFloat());
for (JsonValue mat : json.get("materials")) {
String texName = mat.get("texture").asString();
boolean hasAlpha = mat.get("alpha_blend").asString().equals("ALPHA");
float opacity = hasAlpha ? mat.get("opacity").asFloat() : 1;
Material material = new Material(mat.name);
float[] c = mat.get("color").asFloatArray();
material.set(ColorAttribute.createDiffuse(c[0], c[1], c[2], opacity));
float[] s = mat.get("spec_color").asFloatArray();
material.set(ColorAttribute.createSpecular(s[0], s[1], s[2], 1));
material.set(FloatAttribute.createShininess(mat.get("shininess").asFloat()));
material.set(new BDXColorAttribute(BDXColorAttribute.Tint, 0, 0, 0));
IntAttribute shadeless = (IntAttribute) new BDXIntAttribute();
if (mat.get("shadeless").asBoolean())
shadeless.value = 1;
material.set(shadeless);
float emitStrength = mat.get("emit").asFloat();
material.set(new BDXColorAttribute(BDXColorAttribute.Emit, emitStrength, emitStrength, emitStrength));
if (mat.get("backface_culling").asBoolean())
material.set(new IntAttribute(IntAttribute.CullFace, GL20.GL_BACK));
else
material.set(new IntAttribute(IntAttribute.CullFace, GL20.GL_NONE));
if (texName != null) {
Texture texture = textures.get(texName);
if (texture == null) {
texture = new Texture(Gdx.files.internal("bdx/textures/" + texName));
textures.put(texName, texture);
}
texture.setWrap(TextureWrap.Repeat, TextureWrap.Repeat);
material.texture(texture);
}
material.set(new DepthTestAttribute());
if (hasAlpha) {
BlendingAttribute ba = new BlendingAttribute(GL20.GL_SRC_ALPHA, GL20.GL_ONE_MINUS_SRC_ALPHA);
ba.opacity = opacity;
material.set(ba);
// Discard pixels that fail this alpha test (sub-1% alpha)
material.set(FloatAttribute.createAlphaTest(0.01f));
// Turn on back-to-front sorting for alpha-enabled objects by default
material.backToFrontSorting(true);
} else {
BlendingAttribute ba = new BlendingAttribute();
ba.blended = false;
material.set(ba);
}
materials.put(mat.name, material);
}
for (JsonValue model : json.get("models")) {
meshes.put(model.name, new Mesh(createModel(model), this, model.name));
}
HashMap<String, JsonValue> fonts = new HashMap<>();
for (JsonValue fontj : json.get("fonts")) {
String font = fontj.asString();
fonts.put(font, new JsonReader().parse(Gdx.files.internal("bdx/fonts/" + font + ".fntx")));
}
FAnim.loadActions(json.get("actions"));
for (JsonValue gobj : json.get("objects")) {
GameObject g = instantiator.newObject(gobj);
g.json = gobj;
g.name = gobj.name;
g.scene = this;
g.props = new HashMap<String, JsonValue>();
for (JsonValue prop : gobj.get("properties")) {
g.props.put(prop.name, prop);
}
String meshName = gobj.get("mesh_name").asString();
if (meshName != null) {
g.visibleNoChildren(gobj.get("visible").asBoolean());
g.mesh(meshName);
} else {
g.visibleNoChildren(false);
g.mesh(defaultMesh);
}
com.badlogic.gdx.graphics.Mesh mesh = g.modelInstance.model.meshes.first();
float[] trans = gobj.get("transform").asFloatArray();
JsonValue origin = json.get("origins").get(meshName);
JsonValue dimensions = json.get("dimensions").get(meshName);
g.origin = origin == null ? new Vector3f() : new Vector3f(origin.asFloatArray());
g.dimensionsNoScale = dimensions == null ? new Vector3f(1, 1, 1) : new Vector3f(dimensions.asFloatArray());
JsonValue physics = gobj.get("physics");
g.currBodyType = GameObject.BodyType.valueOf(physics.get("body_type").asString());
g.currBoundsType = GameObject.BoundsType.valueOf(physics.get("bounds_type").asString());
g.body = Bullet.makeBody(mesh, trans, g.origin, g.currBodyType, g.currBoundsType, physics);
g.body.setUserPointer(g);
g.scale(getGLMatrixScale(trans));
String type = gobj.get("type").asString();
if (type.equals("FONT")) {
Text t = (Text) g;
t.font = fonts.get(gobj.get("font").asString());
t.text(gobj.get("text").asString());
t.capacity = t.text().length();
String align = gobj.get("alignment").asString();
if (align.equals("RIGHT"))
t.alignment(Text.Alignment.RIGHT);
else if (align.equals("CENTER"))
t.alignment(Text.Alignment.CENTER);
else
t.alignment(Text.Alignment.LEFT);
} else if (type.equals("LAMP")) {
JsonValue settings = gobj.get("lamp");
Light l = (Light) g;
if (settings.getString("type").equals("SUN"))
l.type = Light.Type.SUN;
else if (settings.getString("type").equals("SPOT"))
l.type = Light.Type.SPOT;
else
// POINT lamps; HEMI and AREA aren't supported, so they're turned into POINTs
l.type = Light.Type.POINT;
l.energy(settings.getFloat("energy"));
float[] c = settings.get("color").asFloatArray();
l.color(new Color(c[0], c[1], c[2], c[3]));
if (l.type.equals(Light.Type.SPOT)) {
l.spotSize(settings.getFloat("spot_size"));
}
} else if (type.equals("CAMERA")) {
Camera c = (Camera) g;
float[] projection = gobj.get("camera").get("projection").asFloatArray();
Vector2f resolution = new Vector2f(json.get("resolution").asFloatArray());
if (gobj.get("camera").get("type").asString().equals("PERSP")) {
c.initData(Camera.Type.PERSPECTIVE);
c.size(resolution);
c.resolution(resolution);
c.projection(new Matrix4f(projection));
c.fov(c.fov());
} else {
c.initData(Camera.Type.ORTHOGRAPHIC);
c.size(resolution);
c.resolution(resolution);
c.zoom(2 / projection[0]);
}
Matrix4 pm = new Matrix4(projection);
pm.inv();
Vector3 vec = new Vector3(0, 0, -1);
vec.prj(pm);
c.near(-vec.z);
vec.set(0, 0, 1);
vec.prj(pm);
c.far(-vec.z);
}
templates.put(g.name, g);
}
hookParentChild();
cameras = new ArrayListNamed<Camera>();
addInstances();
camera = (Camera) objects.get(json.get("cameras").asStringArray()[0]);
String frameType = json.get("frame_type").asString();
Viewport.Type viewportType;
if (frameType.equals("LETTERBOX")) {
viewportType = Viewport.Type.LETTERBOX;
} else if (frameType.equals("EXTEND")) {
viewportType = Viewport.Type.EXTEND;
} else {
// "SCALE"
viewportType = Viewport.Type.SCALE;
}
viewport = new Viewport(this, viewportType);
for (GameObject g : sortByPriority(new ArrayList<GameObject>(objects))) {
initGameObject(g);
}
valid = true;
}
use of com.badlogic.gdx.utils.JsonValue in project bdx by GoranM.
the class Text method text.
public void text(String txt) {
// Reform quads according to Angel Code font format
Mesh mesh = modelInstance.model.meshes.first();
int vertexSize = mesh.getVertexSize() / 4;
int numVertices = mesh.getNumVertices();
float[] verts = new float[numVertices * vertexSize];
int vi = 0;
// number of quads
int capacity = (numVertices / 3) / 2;
text = txt.substring(0, Math.min(txt.length(), capacity));
JsonValue cm = font.get("common");
float su = 1.f / cm.get("scaleW").asInt();
float sv = 1.f / cm.get("scaleH").asInt();
JsonValue char_data = font.get("char");
JsonValue at_c = char_data.get(Integer.toString('O'));
boolean builtin = font.get("info").get("face").asString().equals("Bfont");
float scale = 0.0225f * (builtin ? 1.4f : 1f);
float unit_height = at_c.get("height").asInt() * scale;
int posX = 0;
int posY = 0;
float z = 0;
int totalWidth = 0;
String[] lines = text.split("[\n]");
int cap = 0;
int past_vi = 0;
for (String l : lines) {
for (int i = 0; i < Math.min(l.length(), capacity - cap); ++i) {
// Write chars for the line or text object capacity, whichever's shorter
char chr = ' ';
if (i < l.length())
chr = l.charAt(i);
JsonValue c = char_data.get(Integer.toString(chr));
if (c == null)
c = char_data.get(Integer.toString(' '));
int x = posX + c.get("xoffset").asInt();
int y = posY - c.get("yoffset").asInt();
int w = c.get("width").asInt();
int h = c.get("height").asInt();
posX += c.get("xadvance").asInt();
if (i < l.length() && x + w > totalWidth)
totalWidth = x + w;
float u = c.get("x").asInt();
float v = c.get("y").asInt();
float[][] quad = { { x, y - h, z, 0, 0, 1, u, v + h }, { x + w, y - h, z, 0, 0, 1, u + w, v + h }, { x + w, y, z, 0, 0, 1, u + w, v }, { x + w, y, z, 0, 0, 1, u + w, v }, { x, y, z, 0, 0, 1, u, v }, { x, y - h, z, 0, 0, 1, u, v + h } };
z += 0.0001;
for (float[] vert : quad) {
vert[0] *= scale;
vert[1] *= scale;
vert[0] -= 0.05 + (builtin ? 0.03 : 0);
vert[1] += unit_height * (0.76 - (builtin ? 0.05 : 0));
vert[6] *= su;
vert[7] *= sv;
for (float f : vert) {
verts[vi++] = f;
}
}
}
cap += l.length();
// Set up the Y for the next text line
posY -= (int) (cm.get("lineHeight").asInt() * this.lineHeight);
posX = 0;
for (int i = past_vi; i < vi; i += Bdx.VERT_STRIDE) {
if (alignment == Alignment.CENTER)
verts[i] -= (totalWidth / 2f) * scale;
else if (alignment == Alignment.RIGHT)
verts[i] -= totalWidth * scale;
}
past_vi = vi;
totalWidth = 0;
}
mesh.setVertices(verts, 0, verts.length);
}
use of com.badlogic.gdx.utils.JsonValue in project libgdx by libgdx.
the class G3dModelLoader method parseMeshes.
private void parseMeshes(ModelData model, JsonValue json) {
JsonValue meshes = json.get("meshes");
if (meshes != null) {
model.meshes.ensureCapacity(meshes.size);
for (JsonValue mesh = meshes.child; mesh != null; mesh = mesh.next) {
ModelMesh jsonMesh = new ModelMesh();
String id = mesh.getString("id", "");
jsonMesh.id = id;
JsonValue attributes = mesh.require("attributes");
jsonMesh.attributes = parseAttributes(attributes);
jsonMesh.vertices = mesh.require("vertices").asFloatArray();
JsonValue meshParts = mesh.require("parts");
Array<ModelMeshPart> parts = new Array<ModelMeshPart>();
for (JsonValue meshPart = meshParts.child; meshPart != null; meshPart = meshPart.next) {
ModelMeshPart jsonPart = new ModelMeshPart();
String partId = meshPart.getString("id", null);
if (partId == null) {
throw new GdxRuntimeException("Not id given for mesh part");
}
for (ModelMeshPart other : parts) {
if (other.id.equals(partId)) {
throw new GdxRuntimeException("Mesh part with id '" + partId + "' already in defined");
}
}
jsonPart.id = partId;
String type = meshPart.getString("type", null);
if (type == null) {
throw new GdxRuntimeException("No primitive type given for mesh part '" + partId + "'");
}
jsonPart.primitiveType = parseType(type);
jsonPart.indices = meshPart.require("indices").asShortArray();
parts.add(jsonPart);
}
jsonMesh.parts = parts.toArray(ModelMeshPart.class);
model.meshes.add(jsonMesh);
}
}
}
Aggregations