use of com.badlogic.gdx.graphics.g3d.utils.ModelBuilder in project libgdx by libgdx.
the class FogTest method create.
@Override
public void create() {
modelBatch = new ModelBatch();
environment = new Environment();
environment.set(new ColorAttribute(ColorAttribute.AmbientLight, 0.4f, 0.4f, 0.4f, 1.f));
environment.set(new ColorAttribute(ColorAttribute.Fog, 0.13f, 0.13f, 0.13f, 1f));
environment.add(new DirectionalLight().set(0.8f, 0.8f, 0.8f, -1f, -0.8f, -0.2f));
cam = new PerspectiveCamera(67, Gdx.graphics.getWidth(), Gdx.graphics.getHeight());
cam.position.set(30f, 10f, 30f);
cam.lookAt(0, 0, 0);
cam.near = 0.1f;
cam.far = 45f;
cam.update();
ModelBuilder modelBuilder = new ModelBuilder();
model = modelBuilder.createBox(5f, 5f, 5f, new Material(ColorAttribute.createDiffuse(Color.GREEN)), Usage.Position | Usage.Normal);
instance = new ModelInstance(model);
Gdx.input.setInputProcessor(new InputMultiplexer(this, inputController = new CameraInputController(cam)));
}
use of com.badlogic.gdx.graphics.g3d.utils.ModelBuilder in project libgdx by libgdx.
the class MaterialTest method create.
@Override
public void create() {
texture = new Texture(Gdx.files.internal("data/badlogic.jpg"), true);
// Create material attributes. Each material can contain x-number of attributes.
textureAttribute = new TextureAttribute(TextureAttribute.Diffuse, texture);
colorAttribute = new ColorAttribute(ColorAttribute.Diffuse, Color.ORANGE);
blendingAttribute = new BlendingAttribute(GL20.GL_SRC_ALPHA, GL20.GL_ONE_MINUS_SRC_ALPHA);
ModelBuilder builder = new ModelBuilder();
model = builder.createBox(1, 1, 1, new Material(), Usage.Position | Usage.Normal | Usage.TextureCoordinates);
model.manageDisposable(texture);
modelInstance = new ModelInstance(model);
modelInstance.transform.rotate(Vector3.X, 45);
material = modelInstance.materials.get(0);
builder.begin();
MeshPartBuilder mpb = builder.part("back", GL20.GL_TRIANGLES, Usage.Position | Usage.TextureCoordinates, new Material(textureAttribute));
mpb.rect(-2, -2, -2, 2, -2, -2, 2, 2, -2, -2, 2, -2, 0, 0, 1);
backModel = builder.end();
background = new ModelInstance(backModel);
modelBatch = new ModelBatch();
camera = new PerspectiveCamera(45, 4, 4);
camera.position.set(0, 0, 3);
camera.direction.set(0, 0, -1);
camera.update();
Gdx.input.setInputProcessor(this);
}
use of com.badlogic.gdx.graphics.g3d.utils.ModelBuilder in project bdx by GoranM.
the class GameObject method join.
public void join(HashMap<Mesh, ArrayList<Matrix4f>> map) {
// Collect transformed vertex arrays for each material & calculate number of indices
int VERT_STRIDE = Bdx.VERT_STRIDE;
HashMap<Material, ArrayList<float[]>> tvaMap = new HashMap<Material, ArrayList<float[]>>();
HashMap<Material, Integer> lenMap = new HashMap<Material, Integer>();
Mesh m;
Node node;
Material mat;
MeshPart meshPart;
float[] va, tva;
int numIndices, numVertices, offset, j, len;
Vector3f p = new Vector3f();
Vector3f s = new Vector3f();
Matrix3f o = new Matrix3f();
Vector3f vP = new Vector3f();
Vector3f nP = new Vector3f();
Vector3f vPT = new Vector3f();
Vector3f nPT = new Vector3f();
Vector3f pos = position();
Vector3f sca = scale();
Matrix3f oriInv = orientation().inverted();
for (Map.Entry<Mesh, ArrayList<Matrix4f>> e : map.entrySet()) {
m = e.getKey();
node = m.model.nodes.get(0);
for (Matrix4f t : e.getValue()) {
t.get(p);
p.sub(pos);
p = oriInv.mult(p.div(sca));
t.getRotationScale(o);
o = oriInv.mult(o);
s.set(t.m30, t.m31, t.m32);
if (s.length() == 0) {
s.set(1, 1, 1);
}
s = s.div(sca);
for (NodePart nodePart : node.parts) {
meshPart = nodePart.meshPart;
numIndices = meshPart.size;
numVertices = numIndices * VERT_STRIDE;
offset = meshPart.offset * VERT_STRIDE;
va = meshPart.mesh.getVertices(offset, numVertices, new float[numVertices]);
tva = new float[numVertices];
j = 0;
for (int i = 0; i < numIndices; i++) {
vP.set(va[j], va[j + 1], va[j + 2]);
nP.set(va[j + 3], va[j + 4], va[j + 5]);
vPT.set(o.mult(vP.mul(s)));
vPT.add(p);
nPT.set(o.mult(vP.plus(nP)));
nPT.sub(o.mult(vP));
tva[j] = vPT.x;
tva[j + 1] = vPT.y;
tva[j + 2] = vPT.z;
tva[j + 3] = nPT.x;
tva[j + 4] = nPT.y;
tva[j + 5] = nPT.z;
tva[j + 6] = va[j + 6];
tva[j + 7] = va[j + 7];
j += VERT_STRIDE;
}
mat = m.materials.get(nodePart.material.id);
ArrayList<float[]> l;
if (tvaMap.containsKey(mat)) {
l = tvaMap.get(mat);
len = lenMap.get(mat);
} else {
l = new ArrayList<float[]>();
tvaMap.put(mat, l);
len = 0;
}
l.add(tva);
lenMap.put(mat, len + tva.length);
}
}
}
// Build a unique model out of meshparts for each material
ModelBuilder builder = new ModelBuilder();
builder.begin();
short idx = 0;
MeshPartBuilder mpb;
for (Map.Entry<Material, ArrayList<float[]>> e : tvaMap.entrySet()) {
mat = e.getKey();
len = lenMap.get(mat);
tva = new float[len];
j = 0;
for (float[] verts : e.getValue()) {
numVertices = verts.length;
for (int i = 0; i < numVertices; i++) {
tva[i + j] = verts[i];
}
j += numVertices;
}
mpb = builder.part(mat.name(), GL20.GL_TRIANGLES, Usage.Position | Usage.Normal | Usage.TextureCoordinates, mat);
mpb.vertex(tva);
try {
for (short i = 0; i < len / VERT_STRIDE; i++) {
mpb.index(idx);
idx += 1;
}
} catch (Error error) {
throw new RuntimeException("MODEL ERROR: Models with more than 32767 vertices are not supported. Decrease the number of objects to join.");
}
}
Model finishedModel = builder.end();
// Update mesh
mesh(new Mesh(finishedModel, scene));
// Update dimensionsNoScale and origin
com.badlogic.gdx.graphics.Mesh mesh = finishedModel.meshes.first();
BoundingBox bbox = mesh.calculateBoundingBox();
Vector3 dimensions = bbox.getDimensions(new Vector3());
Vector3 center = bbox.getCenter(new Vector3());
dimensionsNoScale = new Vector3f(dimensions.x, dimensions.y, dimensions.z);
origin = new Vector3f(center.x, center.y, center.z);
// Update body
updateBody();
if (json.get("mesh_name").asString() == null) {
visible = json.get("visible").asBoolean();
}
}
use of com.badlogic.gdx.graphics.g3d.utils.ModelBuilder 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.graphics.g3d.utils.ModelBuilder in project nhglib by VoidZombie.
the class Main method engineStarted.
@Override
public void engineStarted() {
super.engineStarted();
Nhg.debugLogs = true;
Gdx.input.setCursorCatched(true);
world = new NhgWorld(nhg.messaging, nhg.entities, nhg.assets, new DefaultWorldStrategy(), new Bounds(2f, 2f, 2f));
fpsLogger = new FPSLogger();
renderer20 = new ImmediateModeRenderer20(false, true, 0);
nhg.input.addListener(this);
nhg.assets.queueAsset(new Asset("scene", "myscene.nhs", Scene.class));
nhg.assets.queueAsset(new Asset("inputMap", "input.nhc", JsonValue.class));
GraphicsSystem graphicsSystem = nhg.entities.getEntitySystem(GraphicsSystem.class);
graphicsSystem.setClearColor(Color.GRAY);
Environment environment = graphicsSystem.getEnvironment();
GammaCorrectionAttribute gammaCorrectionAttribute = new GammaCorrectionAttribute();
gammaCorrectionAttribute.gammaCorrection = true;
environment.set(gammaCorrectionAttribute);
// Subscribe to asset events
nhg.messaging.get(Strings.Events.assetLoaded, Strings.Events.assetLoadingFinished).subscribe(new Consumer<Message>() {
@Override
public void accept(Message message) throws Exception {
if (message.is(Strings.Events.assetLoaded)) {
Asset asset = (Asset) message.data.get(Strings.Defaults.assetKey);
if (asset.is("scene")) {
scene = nhg.assets.get(asset);
world.loadScene(scene);
world.setReferenceEntity("camera");
ModelBuilder mb = new ModelBuilder();
Model planeModel = mb.createBox(2f, 0.01f, 20f, new Material(), VertexAttributes.Usage.Position | VertexAttributes.Usage.Normal | VertexAttributes.Usage.TextureCoordinates);
int plane = scene.sceneGraph.createSceneEntity("plane");
scene.sceneGraph.addSceneEntity(plane);
ModelComponent modelComponent = nhg.entities.createComponent(plane, ModelComponent.class);
modelComponent.initWithModel(planeModel);
NodeComponent nodeComponent = nhg.entities.getComponent(plane, NodeComponent.class);
nodeComponent.setTranslation(0, 0, 0, true);
Integer cameraEntity = scene.sceneGraph.getSceneEntity("camera");
cameraNode = nhg.entities.getComponent(cameraEntity, NodeComponent.class);
} else if (asset.is("inputMap")) {
nhg.input.fromJson((JsonValue) nhg.assets.get(asset));
nhg.input.setActiveContext("game", true);
nhg.input.setActiveContext("global", true);
}
}
}
});
}
Aggregations