Java ObjLoader类代码示例

import com.badlogic.gdx.graphics.g3d.loader.ObjLoader; //导入依赖的package包/类
/** Creates a new AssetManager with all default loaders. */
public AssetManager (FileHandleResolver resolver) {
	setLoader(BitmapFont.class, new BitmapFontLoader(resolver));
	setLoader(Music.class, new MusicLoader(resolver));
	setLoader(Pixmap.class, new PixmapLoader(resolver));
	setLoader(Sound.class, new SoundLoader(resolver));
	setLoader(TextureAtlas.class, new TextureAtlasLoader(resolver));
	setLoader(Texture.class, new TextureLoader(resolver));
	setLoader(Skin.class, new SkinLoader(resolver));
	setLoader(ParticleEffect.class, new ParticleEffectLoader(resolver));
	setLoader(PolygonRegion.class, new PolygonRegionLoader(resolver));
	setLoader(I18NBundle.class, new I18NBundleLoader(resolver));
	setLoader(Model.class, ".g3dj", new G3dModelLoader(new JsonReader(), resolver));
	setLoader(Model.class, ".g3db", new G3dModelLoader(new UBJsonReader(), resolver));
	setLoader(Model.class, ".obj", new ObjLoader(resolver));
	executor = new AsyncExecutor(1);
}
 

import com.badlogic.gdx.graphics.g3d.loader.ObjLoader; //导入依赖的package包/类
@Override
public void create () {
	ObjLoader objLoader = new ObjLoader();
	sphere = objLoader.loadObj(Gdx.files.internal("data/sphere.obj"));
	sphere.materials.get(0).set(new ColorAttribute(ColorAttribute.Diffuse, Color.WHITE));
	cam = new PerspectiveCamera(45, Gdx.graphics.getWidth(), Gdx.graphics.getHeight());
	cam.far = 200;
	Random rand = new Random();
	for (int i = 0; i < instances.length; i++) {
		instances[i] = new ModelInstance(sphere, rand.nextFloat() * 100 - rand.nextFloat() * 100, rand.nextFloat() * 100
			- rand.nextFloat() * 100, rand.nextFloat() * -100 - 3);
	}
	batch = new SpriteBatch();
	font = new BitmapFont();
	logo = new TextureRegion(new Texture(Gdx.files.internal("data/badlogicsmall.jpg")));
	modelBatch = new ModelBatch();
}
 

import com.badlogic.gdx.graphics.g3d.loader.ObjLoader; //导入依赖的package包/类
@Override
public void create () {
	texture = new Texture(Gdx.files.internal("data/badlogic.jpg"), true);
	texture.setFilter(TextureFilter.MipMap, TextureFilter.Linear);
	ObjLoader objLoader = new ObjLoader();
	mesh = objLoader.loadObj(Gdx.files.internal("data/cube.obj"));
	mesh.materials.get(0).set(new TextureAttribute(TextureAttribute.Diffuse, texture));
	modelInstance = new ModelInstance(mesh);
	modelBatch = new ModelBatch();

	cam = new PerspectiveCamera(67, Gdx.graphics.getWidth(), Gdx.graphics.getHeight());
	cam.position.set(3, 3, 3);
	cam.direction.set(-1, -1, -1);
	batch = new SpriteBatch();
	font = new BitmapFont();
}
 

import com.badlogic.gdx.graphics.g3d.loader.ObjLoader; //导入依赖的package包/类
private static ModelInstance getInstance(String objPath, String texturePath) {
    Model model = loader.loadModel(Gdx.files.internal(objPath), new ObjLoader.ObjLoaderParameters(true));
    ModelInstance instance = new ModelInstance(model);
    Texture texture = new Texture(Gdx.files.internal(texturePath));
    instance.materials.get(0).set(TextureAttribute.createDiffuse(texture));
    return instance;
}
 

import com.badlogic.gdx.graphics.g3d.loader.ObjLoader; //导入依赖的package包/类
private void loadSphere(String planetId) {
	ModelLoader loader = new ObjLoader();
	sphereModel = loader.loadModel(Gdx.files.internal("models/sphere01.obj"),
			new SphereTextureProvider(planetId));
	environmentSphere = new ModelInstance(sphereModel);
	Attribute attribute = environmentSphere.materials.get(0).get(
			ColorAttribute.getAttributeType(ColorAttribute.DiffuseAlias));

	((ColorAttribute) attribute).color.r = 1;
	((ColorAttribute) attribute).color.g = 1;
	((ColorAttribute) attribute).color.b = 1;

}
 

import com.badlogic.gdx.graphics.g3d.loader.ObjLoader; //导入依赖的package包/类
public void create () {
	ShaderProgram.pedantic = false;
	/*
	 * shader = new ShaderProgram(Gdx.files.internal("data/shaders/default.vert").readString(), Gdx.files.internal(
	 * "data/shaders/depthtocolor.frag").readString()); if (!shader.isCompiled()) { Gdx.app.log("EdgeDetectionTest",
	 * "couldn't compile scene shader: " + shader.getLog()); }
	 */
	batchShader = new ShaderProgram(Gdx.files.internal("data/shaders/batch.vert").readString(), Gdx.files.internal(
		"data/shaders/convolution.frag").readString());
	if (!batchShader.isCompiled()) {
		Gdx.app.log("EdgeDetectionTest", "couldn't compile post-processing shader: " + batchShader.getLog());
	}

	ObjLoader objLoader = new ObjLoader();
	scene = objLoader.loadObj(Gdx.files.internal("data/scene.obj"));
	sceneInstance = new ModelInstance(scene);
	modelBatch = new ModelBatch();
	fbo = new FrameBuffer(Format.RGB565, Gdx.graphics.getWidth(), Gdx.graphics.getHeight(), true);
	cam = new PerspectiveCamera(67, Gdx.graphics.getWidth(), Gdx.graphics.getHeight());
	cam.position.set(0, 0, 10);
	cam.lookAt(0, 0, 0);
	cam.far = 30;
	batch = new SpriteBatch();
	batch.setShader(batchShader);
	fboRegion = new TextureRegion(fbo.getColorBufferTexture());
	fboRegion.flip(false, true);
	logger = new FPSLogger();
	calculateOffsets();
}
 

import com.badlogic.gdx.graphics.g3d.loader.ObjLoader; //导入依赖的package包/类
private static Model getModel(String objPath) {
    return loader.loadModel(Gdx.files.internal(objPath), new ObjLoader.ObjLoaderParameters(true));
}
 

import com.badlogic.gdx.graphics.g3d.loader.ObjLoader; //导入依赖的package包/类
/**
 * Needs an initialized com.badlogic.gdx.physics.bullet.Bullet.
 */

public static void init() {
	loader = new ObjLoader();
	param = new ObjLoader.ObjLoaderParameters(true);

	BoundingBox boundingBox = new BoundingBox();


	FUEL = load("models/fuel.obj");
	FUEL.calculateBoundingBox(boundingBox);
	FUEL_SHAPE = new btBoxShape(boundingBox.getDimensions(new Vector3()).scl(0.8f));

	SHIELD = load("models/shield.obj");
	SHIELD.calculateBoundingBox(boundingBox);
	SHIELD_SHAPE = new btBoxShape(boundingBox.getDimensions(new Vector3()).scl(0.8f));


	ARTIFACT_MODELS.put(ATTRIBUTE_SPEED, 			load("models/artifact_speed.obj"));
	ARTIFACT_MODELS.put(ATTRIBUTE_INERTIA, 			load("models/artifact_inertia.obj"));
	ARTIFACT_MODELS.put(ATTRIBUTE_LANDSLIDE, 		load("models/artifact_landslide.obj"));
	ARTIFACT_MODELS.put(ATTRIBUTE_FUEL_CAPACITY, 	load("models/artifact_fuel.obj"));
	ARTIFACT_MODELS.put(ATTRIBUTE_SHIELD_CAPACITY, 	load("models/artifact_shield.obj"));
	ARTIFACT_MODELS.put(ATTRIBUTE_SCAN_RADIUS, 		load("models/artifact_radius.obj"));
	ARTIFACT_MODELS.put(ATTRIBUTE_LUCK, 			load("models/artifact_luck.obj"));
	ARTIFACT_MODELS.put(OPERATOR_PLUS, 				load("models/artifact_plus.obj"));
	ARTIFACT_MODELS.put(OPERATOR_MINUS, 			load("models/artifact_minus.obj"));
	ARTIFACT_MODELS.put(OPERATOR_MULTIPLY, 			load("models/artifact_multiply.obj"));
	ARTIFACT_MODELS.put(OPERATOR_DIVIDE, 			load("models/artifact_divide.obj"));
	ARTIFACT_MODELS.put(VALUE_100,		 			load("models/artifact_100.obj"));
	ARTIFACT_MODELS.put(VALUE_200,		 			load("models/artifact_200.obj"));
	ARTIFACT_MODELS.put(VALUE_500,		 			load("models/artifact_500.obj"));
	ARTIFACT_MODELS.put(VALUE_1000,		 			load("models/artifact_1000.obj"));
	ARTIFACT_MODELS.put(VALUE_2000,		 			load("models/artifact_2000.obj"));

	PLANET_PORTAL = 		load("models/planetPortal.obj");
	PLANET_PORTAL_TORUS = 	load("models/portalTorus.obj");

	PORTAL_STAND_COLLISION = Bullet.obtainStaticNodeShape(PLANET_PORTAL.nodes);

	Model portalTorusCollisionModel = load("models/planetPortalCollisionTube.obj");
	PORTAL_TUBE_COLLISION = Bullet.obtainStaticNodeShape(portalTorusCollisionModel.nodes);

	Model portalTriggerModel = load("models/portalTrigger.obj");
	PORTAL_TRIGGER_COLLISION = Bullet.obtainStaticNodeShape(portalTriggerModel.nodes);

	RACE_WAY_POINT = load("models/race_waypoint.obj");
	RACE_WAY_POINT.calculateBoundingBox(boundingBox);
	//Model raceWayPointTrigger = load("models/race_waypoint_trigger.obj");
	RACE_WAY_POINT_COLLISION = new btBoxShape(boundingBox.getDimensions(new Vector3()).scl(0.5f));
}
 

import com.badlogic.gdx.graphics.g3d.loader.ObjLoader; //导入依赖的package包/类
public Rocket() {
	// init graphic
	ModelLoader loader = new ObjLoader();
	model = loader.loadModel(Gdx.files.internal("models/rocket.obj"), new ObjLoader.ObjLoaderParameters(true));
	rocketModelInstance = new ModelInstance(model);


	ModelBuilder modelBuilder = new ModelBuilder();
	final long attributes = VertexAttributes.Usage.Position | VertexAttributes.Usage.Normal;

	// damage shield
	Material shieldMaterial = new Material();
	shieldMaterial.set(ColorAttribute.createDiffuse(0, 0.3f, 1, 0.5f));
	shieldMaterial.set(ColorAttribute.createSpecular(1, 1, 1, 1f));
	shieldMaterial.set(new BlendingAttribute(1f));
	Model shieldModel = modelBuilder.createSphere(4, 4, 4, 32, 32, shieldMaterial, attributes);
	shieldModelInstance = new ModelInstance(shieldModel);

	Material tractorBeamMaterial = new Material();
	tractorBeamMaterial.set(ColorAttribute.createDiffuse(0, 0, 1, 1));
	tractorBeamMaterial.set(ColorAttribute.createSpecular(1, 1, 1, 1f));
	tractorBeamMaterial.set(new BlendingAttribute(0.1f));
	Model tractorBeamModel = modelBuilder.createSphere(5, 5, 5, 32, 32, tractorBeamMaterial, attributes);
	tractorBeamModelInstance = new ModelInstance(tractorBeamModel);


	// init physic
	//BoundingBox boundingBox = new BoundingBox();
	//model.calculateBoundingBox(boundingBox);
	//btCollisionShape shape = new btBoxShape(boundingBox.getDimensions(new Vector3()).scl(0.5f));
	btCollisionShape shape = new btBoxShape(new Vector3(1, 1, 1));

	rocketModelInstance.transform.setToRotation(0, 0, 1, 0);
	rocketModelInstance.transform.trn(START_POSITION);
	float mass = 1;
	addRigidBody(shape, mass, SpaceShipProperties.properties.getLandslide(), CollisionTypes.ROCKET.mask,
			new RocketMotionState(rocketModelInstance.transform));
	rigidBodyList.get(0).setActivationState(4); // disable deactivation
	rigidBodyList.get(0).setLinearVelocity(tmpMovement.set(getDirection()).nor().scl(
			SpaceShipProperties.properties.getEnginePower()));

	thrustSound = App.audioController.getSound("thrust.wav");
	if (App.config.playAudio) {
		thrustSound.loop();
		thrustSound.play();
	}
}
 

import com.badlogic.gdx.graphics.g3d.loader.ObjLoader; //导入依赖的package包/类
@Override
    public void create() {
        debrisInstance = new ArrayList<ModelInstance>();
        casketInstance = new ArrayList<ModelInstance>();
        debris = Main.getDebris();
        casket = debris.subList(0, 100);

        light = new DirectionalLight().set(222f, 222f, 222f, 300f, 300f, 300f);
        enviroment = new Environment();
        enviroment.set(new ColorAttribute(ColorAttribute.AmbientLight, 2.4f, 3.4f, 2.4f, 3f));
        enviroment.add(light);

        modelBatch = new ModelBatch();

        cam = new OrthographicCamera(Gdx.graphics.getWidth(), Gdx.graphics.getHeight());
//        cam.rotate(90, 0, 0, 1);
        cam.position.set(50f, 50f,50f);
        cam.lookAt(0, 0, 0);
        cam.near = 1f;
        cam.far = 4000f;
        cam.update();

        ModelBuilder modelBuilder = new ModelBuilder();
        ObjLoader loader = new ObjLoader();
        model = loader.loadModel(Gdx.files.internal("textures/Earth.obj"));
        //
//        model = modelBuilder.createSphere(128f, 128f, 128f, 20, 20,
//                new Material(ColorAttribute.AmbientAlias),
//                VertexAttributes.Usage.Position | VertexAttributes.Usage.Normal | VertexAttributes.Usage.TextureCoordinates);
        instance = new ModelInstance(model);
        instance.transform.scale(128, 128, 128);
        instance.transform.rotate(1, 0, 0, 180);
        instance.transform.rotate(0, 0, 1, 90);

        space = loader.loadModel(Gdx.files.internal("textures/space/spacesphere.obj"));
        spaceInstance = new ModelInstance(space);
        spaceInstance.transform.scale(10,10,10);

        for (int i = 0; i < 100; i++) {
            debrisModel = loader.loadModel(Gdx.files.internal("textures/Nuka_Cola_Fridge.obj"));
            casketInstance.add(new ModelInstance(debrisModel));
        }

        for (Placemark pm : debris) {
            Random rand = new Random();
            debrisModel = modelBuilder.createSphere(3f, 3f, 3f, 4, 4,
                    new Material(ColorAttribute.createDiffuse(rand.nextFloat(), rand.nextFloat(), rand.nextFloat(), rand.nextFloat())),
                    VertexAttributes.Usage.Position | VertexAttributes.Usage.Normal | VertexAttributes.Usage.TextureCoordinates);
            ModelInstance mi = new ModelInstance(debrisModel);
            Coordinate coordinate = pm.getNextCoordinate(100f);
            mi.transform.translate((float) coordinate.x, (float) coordinate.y, (float) coordinate.z);
            debrisInstance.add(mi);
        }
        camController = new CameraInputController(cam);
        Gdx.input.setInputProcessor(camController);
    }