Examples with Group net.drewke.tdme.engine.model.Group used on opensource projects

Example 6 with Group

use of net.drewke.tdme.engine.model.Group in project tdme by andreasdr.

the class Object3DGroup method createGroups.

/**
	 * Creates a object 3d groups recursively for given group and it sub groups
	 * @param object 3D base
	 * @param object 3D groups
	 * @param groups
	 * @param animated
	 * @param use mesh manager
	 */
private static void createGroups(Object3DBase object3D, ArrayList<Object3DGroup> object3DGroups, HashMap<String, Group> groups, boolean animated, boolean useMeshManager, Engine.AnimationProcessingTarget animationProcessingTarget) {
    for (Group group : groups.getValuesIterator()) {
        // skip on joints
        if (group.isJoint() == true) {
            continue;
        }
        // determine face count
        int faceCount = group.getFaceCount();
        // skip on groups without faces
        if (faceCount > 0) {
            // create group render data
            Object3DGroup object3DGroup = new Object3DGroup();
            // add it to group render data list
            object3DGroups.add(object3DGroup);
            // determine mesh id
            object3DGroup.id = group.getModel().getId() + ":" + group.getId() + ":" + animationProcessingTarget.toString().toLowerCase();
            if (animated == true && (animationProcessingTarget == AnimationProcessingTarget.CPU || animationProcessingTarget == AnimationProcessingTarget.CPU_NORENDERING)) {
                //
                object3DGroup.id += ":" + (counter++);
            }
            object3DGroup.object = object3D;
            object3DGroup.group = group;
            object3DGroup.animated = animated;
            if (useMeshManager == true) {
                MeshManager meshManager = Engine.getInstance().getMeshManager();
                object3DGroup.mesh = meshManager.getMesh(object3DGroup.id);
                if (object3DGroup.mesh == null) {
                    object3DGroup.mesh = Object3DGroupMesh.createMesh(animationProcessingTarget, group, object3D.transformationsMatrices);
                    meshManager.addMesh(object3DGroup.id, object3DGroup.mesh);
                }
            } else {
                object3DGroup.mesh = Object3DGroupMesh.createMesh(animationProcessingTarget, group, object3D.transformationsMatrices);
            }
            object3DGroup.materialDiffuseTextureIdsByEntities = new int[group.getFacesEntities().length];
            object3DGroup.dynamicDiffuseTextureIdsByEntities = new int[group.getFacesEntities().length];
            object3DGroup.materialSpecularTextureIdsByEntities = new int[group.getFacesEntities().length];
            object3DGroup.materialDisplacementTextureIdsByEntities = new int[group.getFacesEntities().length];
            object3DGroup.materialNormalTextureIdsByEntities = new int[group.getFacesEntities().length];
            for (int j = 0; j < group.getFacesEntities().length; j++) {
                object3DGroup.materialDiffuseTextureIdsByEntities[j] = GLTEXTUREID_NONE;
                object3DGroup.dynamicDiffuseTextureIdsByEntities[j] = GLTEXTUREID_NONE;
                object3DGroup.materialSpecularTextureIdsByEntities[j] = GLTEXTUREID_NONE;
                object3DGroup.materialDisplacementTextureIdsByEntities[j] = GLTEXTUREID_NONE;
                object3DGroup.materialNormalTextureIdsByEntities[j] = GLTEXTUREID_NONE;
            }
            // determine renderer
            object3DGroup.renderer = new Object3DGroupVBORenderer(object3DGroup);
            // skinning
            Skinning skinning = group.getSkinning();
            if (skinning != null) {
                object3DGroup.groupTransformationsMatricesVector = new ArrayList<Matrix4x4>();
                for (Joint joint : skinning.getJoints()) {
                    object3DGroup.groupTransformationsMatricesVector.add(object3D.transformationsMatrices.get(joint.getGroupId()));
                }
            } else {
                object3DGroup.groupTransformationsMatricesVector = null;
            }
            //
            object3DGroup.groupTransformationsMatrix = object3D.transformationsMatrices.get(group.getId());
        }
        // but still check sub groups
        createGroups(object3D, object3DGroups, group.getSubGroups(), animated, useMeshManager, animationProcessingTarget);
    }
}

Example 7 with Group

use of net.drewke.tdme.engine.model.Group in project tdme by andreasdr.

the class Object3DBase method createTransformationsMatrices.

/**
	 * Creates all groups transformation matrices
	 * @param groups
	 * @depth
	 */
protected void createTransformationsMatrices(HashMap<String, Group> groups) {
    // iterate through groups
    for (Group group : groups.getValuesIterator()) {
        // put and associate transformation matrices with group
        transformationsMatrices.put(group.getId(), new Matrix4x4().identity());
        // calculate sub groups
        HashMap<String, Group> subGroups = group.getSubGroups();
        if (subGroups.size() > 0) {
            createTransformationsMatrices(subGroups);
        }
    }
}

Example 8 with Group

use of net.drewke.tdme.engine.model.Group in project tdme by andreasdr.

the class PrimitiveModel method createOrientedBoundingBoxModel.

/**
	 * Creates a model from oriented bounding box
	 * @param bounding box
	 * @param id
	 * @return model
	 */
public static Model createOrientedBoundingBoxModel(OrientedBoundingBox orientedBoundingBox, String id) {
    // ground model
    Model model = new Model(id, id, UpVector.Y_UP, RotationOrder.XYZ, null);
    // material
    Material material = new Material("tdme.primitive.material");
    material.getAmbientColor().set(0.5f, 0.5f, 0.5f, 1.0f);
    material.getDiffuseColor().set(1.0f, 0.5f, 0.5f, 0.5f);
    material.getSpecularColor().set(0f, 0f, 0f, 1f);
    model.getMaterials().put(material.getId(), material);
    // group
    Group group = new Group(model, null, "group", "group");
    // faces entity
    FacesEntity groupFacesEntity = new FacesEntity(group, "faces entity");
    groupFacesEntity.setMaterial(material);
    // faces entity 
    ArrayList<FacesEntity> groupFacesEntities = new ArrayList<FacesEntity>();
    groupFacesEntities.add(groupFacesEntity);
    // triangle vertices indexes
    int[][] fvi = OrientedBoundingBox.facesVerticesIndexes;
    // vertices
    ArrayList<Vector3> vertices = new ArrayList<Vector3>();
    for (Vector3 vertex : orientedBoundingBox.vertices) {
        vertices.add(vertex.clone());
    }
    Vector3[] axes = orientedBoundingBox.axes;
    // normals
    ArrayList<Vector3> normals = new ArrayList<Vector3>();
    normals.add(axes[0].clone().scale(-1f));
    normals.add(axes[0].clone());
    normals.add(axes[1].clone().scale(-1f));
    normals.add(axes[1].clone());
    normals.add(axes[2].clone().scale(-1f));
    normals.add(axes[2].clone());
    // faces
    ArrayList<Face> faces = new ArrayList<Face>();
    //	left
    faces.add(new Face(group, fvi[0][0], fvi[0][1], fvi[0][2], 0, 0, 0));
    faces.add(new Face(group, fvi[1][0], fvi[1][1], fvi[1][2], 0, 0, 0));
    //	right
    faces.add(new Face(group, fvi[2][0], fvi[2][1], fvi[2][2], 1, 1, 1));
    faces.add(new Face(group, fvi[3][0], fvi[3][1], fvi[3][2], 1, 1, 1));
    //	top
    faces.add(new Face(group, fvi[4][0], fvi[4][1], fvi[4][2], 2, 2, 2));
    faces.add(new Face(group, fvi[5][0], fvi[5][1], fvi[5][2], 2, 2, 2));
    //	bottom
    faces.add(new Face(group, fvi[6][0], fvi[6][1], fvi[6][2], 3, 3, 3));
    faces.add(new Face(group, fvi[7][0], fvi[7][1], fvi[7][2], 3, 3, 3));
    //	near
    faces.add(new Face(group, fvi[8][0], fvi[8][1], fvi[8][2], 4, 4, 4));
    faces.add(new Face(group, fvi[9][0], fvi[9][1], fvi[9][2], 4, 4, 4));
    //	far
    faces.add(new Face(group, fvi[10][0], fvi[10][1], fvi[10][2], 5, 5, 5));
    faces.add(new Face(group, fvi[11][0], fvi[11][1], fvi[11][2], 5, 5, 5));
    // set up faces entity
    groupFacesEntity.setFaces(faces);
    // setup group vertex data
    group.setVertices(vertices);
    group.setNormals(normals);
    group.setFacesEntities(groupFacesEntities);
    // determine features
    group.determineFeatures();
    // register group
    model.getGroups().put("group", group);
    model.getSubGroups().put("group", group);
    // prepare for indexed rendering
    ModelHelper.prepareForIndexedRendering(model);
    //
    return model;
}

Example 9 with Group

use of net.drewke.tdme.engine.model.Group in project tdme by andreasdr.

the class PrimitiveModel method createCapsuleModel.

/**
	 * Creates a model from capsule
	 * @param sphere
	 * @param id
	 * @param number of x segments
	 * @param number of y segments
	 * @return model
	 */
public static Model createCapsuleModel(Capsule capsule, String id, int segmentsX, int segmentsY) {
    // capsule properties
    float radius = capsule.radius;
    Vector3 a = capsule.a;
    Vector3 b = capsule.b;
    // rotation quaternion
    Quaternion rotationQuaternion = new Quaternion();
    rotationQuaternion.identity();
    // angle between a and b
    Vector3 yAxis = new Vector3(0f, -1f, 0f);
    Vector3 abNormalized = a.clone().sub(b).normalize();
    float[] abNormalizedVectorXYZ = abNormalized.getArray();
    Vector3 rotationAxis;
    if (Math.abs(abNormalizedVectorXYZ[0]) < MathTools.EPSILON && Math.abs(abNormalizedVectorXYZ[2]) < MathTools.EPSILON) {
        rotationAxis = new Vector3(abNormalizedVectorXYZ[1], 0f, 0f);
    } else {
        rotationAxis = Vector3.computeCrossProduct(yAxis, abNormalized).normalize();
    }
    float angle = Vector3.computeAngle(yAxis, abNormalized, yAxis);
    rotationQuaternion.rotate(angle, rotationAxis);
    // ground model
    Model model = new Model(id, id, UpVector.Y_UP, RotationOrder.XYZ, null);
    // material
    Material material = new Material("tdme.primitive.material");
    material.getAmbientColor().set(0.5f, 0.5f, 0.5f, 1.0f);
    material.getDiffuseColor().set(1.0f, 0.5f, 0.5f, 0.5f);
    material.getSpecularColor().set(0f, 0f, 0f, 1f);
    model.getMaterials().put(material.getId(), material);
    // group
    Group group = new Group(model, null, "group", "group");
    // faces entity
    FacesEntity groupFacesEntity = new FacesEntity(group, "faces entity");
    groupFacesEntity.setMaterial(material);
    // faces entity 
    ArrayList<FacesEntity> groupFacesEntities = new ArrayList<FacesEntity>();
    groupFacesEntities.add(groupFacesEntity);
    // vertices
    ArrayList<Vector3> vertices = new ArrayList<Vector3>();
    for (int i = 0; i < (segmentsY + 2) * segmentsX; i++) vertices.add(null);
    //	top half sphere
    for (int ySegment = segmentsY / 2; ySegment <= segmentsY; ySegment++) for (int xSegment = 0; xSegment < segmentsX; xSegment++) {
        Vector3 vertex = new Vector3();
        rotationQuaternion.multiply(new Vector3((float) (Math.sin(Math.PI * ySegment / segmentsY) * Math.cos(Math.PI * 2 * xSegment / segmentsX)), (float) (Math.cos(Math.PI * ySegment / segmentsY)), (float) (Math.sin(Math.PI * ySegment / segmentsY) * Math.sin(Math.PI * 2 * xSegment / segmentsX))), vertex);
        vertex.scale(radius);
        vertex.add(a);
        vertices.set(ySegment * segmentsX + xSegment, vertex);
    }
    //	bottom half sphere
    for (int i = 0; i < (segmentsY + 1) * segmentsX; i++) vertices.add(null);
    for (int ySegment = 0; ySegment <= segmentsY / 2; ySegment++) for (int xSegment = 0; xSegment < segmentsX; xSegment++) {
        Vector3 vertex = new Vector3();
        rotationQuaternion.multiply(new Vector3((float) (Math.sin(Math.PI * ySegment / segmentsY) * Math.cos(Math.PI * 2 * xSegment / segmentsX)), (float) (Math.cos(Math.PI * ySegment / segmentsY)), (float) (Math.sin(Math.PI * ySegment / segmentsY) * Math.sin(Math.PI * 2 * xSegment / segmentsX))), vertex);
        vertex.scale(radius);
        vertex.add(b);
        vertices.set(ySegment * segmentsX + xSegment, vertex);
    }
    // normals
    ArrayList<Vector3> normals = new ArrayList<Vector3>();
    // faces
    ArrayList<Face> faces = new ArrayList<Face>();
    int vi0, vi1, vi2;
    int ni;
    for (int y = 0; y <= segmentsY + 1; y++) {
        for (int x = 0; x < segmentsX; x++) {
            vi0 = ((y + 0) % (segmentsY + 1)) * segmentsX + ((x + 0) % (segmentsX));
            vi1 = ((y + 1) % (segmentsY + 1)) * segmentsX + ((x + 1) % (segmentsX));
            vi2 = ((y + 1) % (segmentsY + 1)) * segmentsX + ((x + 0) % (segmentsX));
            ni = normals.size();
            for (Vector3 normal : ModelHelper.computeNormals(new Vector3[] { vertices.get(vi0), vertices.get(vi1), vertices.get(vi2) })) {
                normals.add(normal);
            }
            faces.add(new Face(group, vi0, vi1, vi2, ni + 0, ni + 1, ni + 2));
            vi0 = ((y + 0) % (segmentsY + 1)) * segmentsX + ((x + 0) % (segmentsX));
            vi1 = ((y + 0) % (segmentsY + 1)) * segmentsX + ((x + 1) % (segmentsX));
            vi2 = ((y + 1) % (segmentsY + 1)) * segmentsX + ((x + 1) % (segmentsX));
            ni = normals.size();
            for (Vector3 normal : ModelHelper.computeNormals(new Vector3[] { vertices.get(vi0), vertices.get(vi1), vertices.get(vi2) })) {
                normals.add(normal);
            }
            faces.add(new Face(group, vi0, vi1, vi2, ni + 0, ni + 1, ni + 2));
        }
    }
    // set up faces entity
    groupFacesEntity.setFaces(faces);
    // setup group vertex data
    group.setVertices(vertices);
    group.setNormals(normals);
    group.setFacesEntities(groupFacesEntities);
    // determine features
    group.determineFeatures();
    // register group
    model.getGroups().put("group", group);
    model.getSubGroups().put("group", group);
    // prepare for indexed rendering
    ModelHelper.prepareForIndexedRendering(model);
    //
    return model;
}

Example 10 with Group

use of net.drewke.tdme.engine.model.Group in project tdme by andreasdr.

the class PrimitiveModel method createSphereModel.

/**
	 * Creates a model from oriented bounding box
	 * @param sphere
	 * @param id
	 * @param number of x segments
	 * @param number of y segments
	 * @return model
	 */
public static Model createSphereModel(Sphere sphere, String id, int segmentsX, int segmentsY) {
    // sphere properties
    float radius = sphere.radius;
    Vector3 center = sphere.center;
    // ground model
    Model model = new Model(id, id, UpVector.Y_UP, RotationOrder.XYZ, null);
    // material
    Material material = new Material("tdme.primitive.material");
    material.getAmbientColor().set(0.5f, 0.5f, 0.5f, 1.0f);
    material.getDiffuseColor().set(1.0f, 0.5f, 0.5f, 0.5f);
    material.getSpecularColor().set(0f, 0f, 0f, 1f);
    model.getMaterials().put(material.getId(), material);
    // group
    Group group = new Group(model, null, "group", "group");
    // faces entity
    FacesEntity groupFacesEntity = new FacesEntity(group, "faces entity");
    groupFacesEntity.setMaterial(material);
    // faces entity 
    ArrayList<FacesEntity> groupFacesEntities = new ArrayList<FacesEntity>();
    groupFacesEntities.add(groupFacesEntity);
    // vertices
    ArrayList<Vector3> vertices = new ArrayList<Vector3>();
    for (int i = 0; i < (segmentsY + 1) * segmentsX; i++) vertices.add(null);
    for (int ySegment = 0; ySegment <= segmentsY; ySegment++) for (int xSegment = 0; xSegment < segmentsX; xSegment++) {
        Vector3 vertex = new Vector3((float) (Math.sin(Math.PI * ySegment / segmentsY) * Math.cos(Math.PI * 2 * xSegment / segmentsX)), (float) (Math.cos(Math.PI * ySegment / segmentsY)), (float) (Math.sin(Math.PI * ySegment / segmentsY) * Math.sin(Math.PI * 2 * xSegment / segmentsX))).scale(radius).add(center);
        vertices.set(ySegment * segmentsX + xSegment, vertex);
    }
    // normals
    ArrayList<Vector3> normals = new ArrayList<Vector3>();
    // faces
    ArrayList<Face> faces = new ArrayList<Face>();
    int vi0, vi1, vi2;
    int ni;
    for (int y = 0; y <= segmentsY; y++) {
        for (int x = 0; x < segmentsX; x++) {
            vi0 = ((y + 0) % (segmentsY + 1)) * segmentsX + ((x + 0) % (segmentsX));
            vi1 = ((y + 1) % (segmentsY + 1)) * segmentsX + ((x + 1) % (segmentsX));
            vi2 = ((y + 1) % (segmentsY + 1)) * segmentsX + ((x + 0) % (segmentsX));
            ni = normals.size();
            for (Vector3 normal : ModelHelper.computeNormals(new Vector3[] { vertices.get(vi0), vertices.get(vi1), vertices.get(vi2) })) {
                normals.add(normal);
            }
            faces.add(new Face(group, vi0, vi1, vi2, ni + 0, ni + 1, ni + 2));
            vi0 = ((y + 0) % (segmentsY + 1)) * segmentsX + ((x + 0) % (segmentsX));
            vi1 = ((y + 0) % (segmentsY + 1)) * segmentsX + ((x + 1) % (segmentsX));
            vi2 = ((y + 1) % (segmentsY + 1)) * segmentsX + ((x + 1) % (segmentsX));
            ni = normals.size();
            for (Vector3 normal : ModelHelper.computeNormals(new Vector3[] { vertices.get(vi0), vertices.get(vi1), vertices.get(vi2) })) {
                normals.add(normal);
            }
            faces.add(new Face(group, vi0, vi1, vi2, ni + 0, ni + 1, ni + 2));
        }
    }
    // set up faces entity
    groupFacesEntity.setFaces(faces);
    // setup group vertex data
    group.setVertices(vertices);
    group.setNormals(normals);
    group.setFacesEntities(groupFacesEntities);
    // determine features
    group.determineFeatures();
    // register group
    model.getGroups().put("group", group);
    model.getSubGroups().put("group", group);
    // prepare for indexed rendering
    ModelHelper.prepareForIndexedRendering(model);
    //
    return model;
}