Moin,
wie schon im Titel, ich suche ein ganz simples 3D-Framework. Ich muss nur ein simples Drahtgitter-Model auf dem Handy anzeigen. Jemand eine Empfehlung für mich?
hand, mogel
ich hab gerade nur google benutzt, weil wenn ein Drahtgitter Modell ne STL ist, da gibts mittlerweile viele Web Libs, die hier sieht gut aus A Simple STL Viewer with Three.js
Für andere Formate muss es mittlerweile auch einiges geben, weil viele Portale im 3D Druck Umfeld rendern da alles mögliche
danke,
aber es soll weder STL noch sonstwas in der Richtung dargestellt werden. Eher die üblichen X/Y/Z-Pfeile um die Ausrichtung der Hand, nach dem Bewegungssensor, anzuzeigen.
Prinzipiell würde mir folgendes ausreichen:
public void drawLine(int x0, int y0, int z0, int x1, int y1, int z1) {
// der Teil bzw. die Umrechnung von 3D nach 2D ist mir völlig unklar
}
dann kann ich die drei Linien übergeben und gut ist. Ggf. kann ich dann noch das Biegen der Finger mit ein paar weiteren Linien darstellen.
hand, mogel
achso ok dann hab ich dich falsch verstanden, du willst selbst was zeichnen
Aber dann check das hier, da kannst du einfach selbst malen, hab ich für Diagramme benutzt HTML Canvas Drawing
Jedes „gaaanz simple Framework“ wird irgendwann von Leuten aufgegriffen, weil es gaaaanz simpel ist, und dann sagen Leute: „Ja, aber 3D-Modelle laden wäre auch gut“, und „Licht wäre gut“ und dann „Schatten wäre gut“, und dann „Animationen wären gut“, und dann „Ich würde gerne eine UNSIGNED_SHORT_5_5_5_1-Datentextur mit glTexSubImage3D auf ein primitive mappen“.
die Umrechnung von 3D nach 2D ist mir völlig unklar
Man kann bei einer Funktion wie der angedeuteten drawLine selbst die Umprechnung von 3D in 2D machen. Das ist auch recht einfach: Die Z-Koordinaten ignorieren, und dann eine 2D-Linie malen. Und wenn du jetzt sagst: „Das ist dann nicht 3D“, dann … stimmt das in mancher Hinsicht richtig, aber … bei „richtigem 3D“ passiert letztendlich das gleiche, nur werden noch viewport-Transformationen und Perspektivische Verzerrungen reingerechnet. Details stehen in Computer Graphics: Principles and Practice, Kapitel 5 und 6.
Das willst du nicht. Das ist frustrierend.
Ich kann keine konkrete Empfehlung für ein 3D-Framework auf Android geben. Websuchen liefern etliches, einschließlich der „echten Game-Engines“ wie Unity oder Unreal. Aber libGDX wird gelegentlich empfohlen, und soll relativ einfach sein.
Ausgehend von sowas wie Basic 3D using libGDX | blog.xoppa.com (mit direkt auf GitHub verlinkten, vollständigen Beispielen) sollte es relativ einfach sein, den Würfel durch ein paar Koordinatenachsen zu ersetzen, die man sich mit ModelBuilder#createCylinder und ModelBuilder#createCone zusammenschustert.
Gerade mal ausprobiert:
- Den Projektgenerator auf Creating a Project - libGDX runterladen. (Ich hab beim Erstellen nur ‚Desktop‘ ausgewählt - hab’ gerade kein Android zur Hand)
- Projekt mit „Import existing Grade Project“ in Eclipse importiert
- Den Code von blog/tutorials/src/com/xoppa/blog/libgdx/g3d/basic3d/step3/Basic3DTest.java at master · xoppa/blog · GitHub in meine
MyGdxGame.javareingeklatscht - Ein bißchen mit dem
ModelBuilderrumgepfuscht…
Ergebnis:
Wenn das damals schon so einfach gewesen wäre 
/*******************************************************************************
* Copyright 2011 See AUTHORS file.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
******************************************************************************/
package com.mygdx.game;
import com.badlogic.gdx.ApplicationListener;
import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.graphics.Color;
import com.badlogic.gdx.graphics.GL20;
import com.badlogic.gdx.graphics.PerspectiveCamera;
import com.badlogic.gdx.graphics.VertexAttributes.Usage;
import com.badlogic.gdx.graphics.g3d.Environment;
import com.badlogic.gdx.graphics.g3d.Model;
import com.badlogic.gdx.graphics.g3d.ModelBatch;
import com.badlogic.gdx.graphics.g3d.ModelInstance;
import com.badlogic.gdx.graphics.g3d.attributes.ColorAttribute;
import com.badlogic.gdx.graphics.g3d.environment.DirectionalLight;
import com.badlogic.gdx.graphics.g3d.Material;
import com.badlogic.gdx.graphics.g3d.utils.CameraInputController;
import com.badlogic.gdx.graphics.g3d.utils.ModelBuilder;
import com.badlogic.gdx.math.Vector3;
/**
* See: http://blog.xoppa.com/basic-3d-using-libgdx-2/
* @author Xoppa
*/
public class MyGdxGame implements ApplicationListener {
public Environment environment;
public PerspectiveCamera cam;
public CameraInputController camController;
public ModelBatch modelBatch;
public Model modelX;
public Model modelY;
public Model modelZ;
public ModelInstance instanceX;
public ModelInstance instanceY;
public ModelInstance instanceZ;
@Override
public void create() {
environment = new Environment();
environment.set(new ColorAttribute(ColorAttribute.AmbientLight, 0.4f, 0.4f, 0.4f, 1f));
environment.add(new DirectionalLight().set(0.8f, 0.8f, 0.8f, -1f, -0.8f, -0.2f));
modelBatch = new ModelBatch();
cam = new PerspectiveCamera(67, Gdx.graphics.getWidth(), Gdx.graphics.getHeight());
cam.position.set(2f, 2f, 2f);
cam.lookAt(0,0,0);
cam.near = 1f;
cam.far = 300f;
cam.update();
ModelBuilder modelBuilder = new ModelBuilder();
modelX = modelBuilder.createCylinder(0.1f, 1.0f, 0.1f, 10,
new Material(ColorAttribute.createDiffuse(Color.RED)), Usage.Position | Usage.Normal);
instanceX = new ModelInstance(modelX);
modelY = modelBuilder.createCylinder(0.1f, 1.0f, 0.1f, 10,
new Material(ColorAttribute.createDiffuse(Color.GREEN)), Usage.Position | Usage.Normal);
instanceY = new ModelInstance(modelY);
instanceY.transform.rotate(Vector3.Z, 90);
modelZ = modelBuilder.createCylinder(0.1f, 1.0f, 0.1f, 10,
new Material(ColorAttribute.createDiffuse(Color.BLUE)), Usage.Position | Usage.Normal);
instanceZ = new ModelInstance(modelZ);
instanceZ.transform.rotate(Vector3.X, 90);
camController = new CameraInputController(cam);
Gdx.input.setInputProcessor(camController);
}
@Override
public void render() {
camController.update();
Gdx.gl.glViewport(0, 0, Gdx.graphics.getWidth(), Gdx.graphics.getHeight());
Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT | GL20.GL_DEPTH_BUFFER_BIT);
modelBatch.begin(cam);
modelBatch.render(instanceX, environment);
modelBatch.render(instanceY, environment);
modelBatch.render(instanceZ, environment);
modelBatch.end();
}
@Override
public void dispose() {
modelBatch.dispose();
modelX.dispose();
modelY.dispose();
modelZ.dispose();
}
@Override
public void resize(int width, int height) {
}
@Override
public void pause() {
}
@Override
public void resume() {
}
}
Hallo mogel,
eine einfache 2D-Linie in eine beliebige Richtung kannst du ganz einfach pixelweise selber zeichnen, mit dem Bresenham’s line algorithm. Siehe dir mal diese Erklärung an:
Eine Umrechnung von 3D nach 2D kannst du auch ganz einfach erreichen, wie Marco13 bereits geschrieben hat, indem du „die dritte“ Koordinate/Komponente der Endpunkte einfach „fallen lässt“.
Ich hoffe, ich konnte dir weiterhelfen.
Ansonsten schaue dir auch gerne diese (Stackexchange) und diese (Stackoverflow) Antworten an.
Nun, @mogel, … was du mit dem letzten Beitrag machen musst, weißt du. Ich hatte zwar kurz überlegt, bei meiner Antwort auch ganz ironisch auf „Seite 75“ im genannten Buch zu verweisen (die fangen da wirklich gaaanz unten an…), aber wir haben nicht mehr die 80er (auch wenn sich reines OpenGLES in Android manchmal ein bißchen wie die 90er anfühlt…)
1 „Gefällt mir“
danke für die Antworten - ich schau mir das alles erstmal genauer an
Kurze Rückmeldung,
das Projekt ist (mehr oder weniger nur für mich) gestorben, da ich ab November woanders arbeitet.
Ich habe mir mal libGDX genauer angeschaut und auch ein Beispiel gefunden, wo man die libGDX als View einbinden kann. Wäre dann natürlich die Perfektion gewesen. Als Herausforderung hat sich nur die Anbindung der libGDX an das bestehende Projekt gezeigt.
Da aber die Zeit für Präsentation näher rückte und ich die halbe Hardware geschrottet habe, musste ich mich erstmal auf was Anders konzentrieren. Das Projekt ist dann aber (mit Bravour) vom Förder abgenommen worden. So eigentlich alles soweit super.
hand, mogel
1 „Gefällt mir“