/** * Compute the {@link IndexMappingSet} for the given glTF instance. * The {@link IndexMappingSet} will contain index mappings for all * top-level dictionaries of the given glTF. * * @param gltf The glTF * @return The {@link IndexMappingSet} */ static IndexMappingSet create(GlTF gltf) { IndexMappingSet indexMappingSet = new IndexMappingSet(); indexMappingSet.generate("accessors", gltf.getAccessors()); indexMappingSet.generate("animations", gltf.getAnimations()); indexMappingSet.generate("buffers", gltf.getBuffers()); indexMappingSet.generate("bufferViews", gltf.getBufferViews()); indexMappingSet.generate("cameras", gltf.getCameras()); indexMappingSet.generate("images", gltf.getImages()); indexMappingSet.generate("materials", gltf.getMaterials()); indexMappingSet.generate("meshes", gltf.getMeshes()); indexMappingSet.generate("nodes", gltf.getNodes()); indexMappingSet.generate("programs", gltf.getPrograms()); indexMappingSet.generate("samplers", gltf.getSamplers()); indexMappingSet.generate("scenes", gltf.getScenes()); indexMappingSet.generate("shaders", gltf.getShaders()); indexMappingSet.generate("skins", gltf.getSkins()); indexMappingSet.generate("techniques", gltf.getTechniques()); indexMappingSet.generate("textures", gltf.getTextures()); return indexMappingSet; }
/** * Create a default {@link Material}, and assign it to all the given * {@link MeshPrimitive} instances * * @param meshPrimitives The {@link MeshPrimitive} instances * @param withNormals Whether the {@link MeshPrimitive} instances have * normal information */ private void assignDefaultMaterial( Iterable<? extends MeshPrimitive> meshPrimitives, boolean withNormals) { Material material = mtlMaterialHandler.createMaterialWithColor( withNormals, 0.75f, 0.75f, 0.75f); String materialId = GltfIds.generateId("material", gltf.getMaterials()); gltf.addMaterials(materialId, material); for (MeshPrimitive meshPrimitive : meshPrimitives) { meshPrimitive.setMaterial(materialId); } }
Technique technique = gltf.getTechniques().get(techniqueId); String programId = technique.getProgram(); Program program = gltf.getPrograms().get(programId); String vertexShaderId = program.getVertexShader(); String fragmentShaderId = program.getFragmentShader(); Shader vertexShader = gltf.getShaders().get(vertexShaderId); Shader fragmentShader = gltf.getShaders().get(fragmentShaderId); String vertexShaderUriString = vertexShader.getUri(); String fragmentShaderUriString = fragmentShader.getUri();
gltf = new GlTF(); gltf.setAsset(createAsset()); mtlMaterialHandler = new MtlMaterialHandlerV1(gltf); bufferStructureBuilder = new BufferStructureBuilder(); gltf.setAccessors(accessors); gltf.setBufferViews(bufferViews); gltf.setBuffers(buffers); String meshId = GltfIds.generateId("mesh", gltf.getMeshes()); gltf.addMeshes(meshId, mesh); String nodeId = GltfIds.generateId("node", gltf.getNodes()); gltf.addNodes(nodeId, node); String sceneId = GltfIds.generateId("scene", gltf.getScenes()); gltf.addScenes(sceneId, scene); gltf.setScene(sceneId);
Map<String, Buffer> oldBuffers = copy(outputGltf.getBuffers()); Map<String, Image> oldImages = copy(outputGltf.getImages()); Map<String, Shader> oldShaders = copy(outputGltf.getShaders()); copy(outputGltf.getBufferViews()); Map<String, BufferView> newBufferViews = new LinkedHashMap<String, BufferView>(); if (inputGltf.getBuffers() != null) outputGltf.setBuffers(newBuffers); if (inputGltf.getImages() != null) outputGltf.setImages(newImages); if (inputGltf.getShaders() != null) outputGltf.setShaders(newShaders); outputGltf.setBufferViews(newBufferViews);
String vertexShaderUri, String fragmentShaderUri) Map<String, Technique> techniques = gltf.getTechniques(); if (techniques != null) String programId = GltfIds.generateId("program", gltf.getPrograms()); vertexShader.setType(GltfConstants.GL_VERTEX_SHADER); String vertexShaderId = GltfIds.generateId( "vertexShader_for_" + programId, gltf.getShaders()); gltf.addShaders(vertexShaderId, vertexShader); fragmentShader.setType(GltfConstants.GL_FRAGMENT_SHADER); String fragmentShaderId = GltfIds.generateId( "fragmentShader_for_" + programId, gltf.getShaders()); gltf.addShaders(fragmentShaderId, fragmentShader); gltf.addPrograms(programId, program); technique.setStates(states); gltf.addTechniques(techniqueId, technique);
samplerId = GltfIds.generateId("sampler", gltf.getSamplers()); gltf.addSamplers(samplerId, sampler); String imageId = GltfIds.generateId("image", gltf.getImages()); gltf.addImages(imageId, image); texture.setType(GltfConstants.GL_UNSIGNED_BYTE); texture.setSampler(samplerId); textureId = GltfIds.generateId("texture", gltf.getTextures()); gltf.addTextures(textureId, texture);
Optionals.of(inputGltf.getBuffers()).values(), Buffer::getUri); existingImageUriStrings = collectUriStrings( Optionals.of(inputGltf.getImages()).values(), Image::getUri); existingShaderUriStrings = collectUriStrings( Optionals.of(inputGltf.getShaders()).values(), Shader::getUri); Optionals.of(outputGltf.getBuffers()).forEach((id, value) -> storeBufferAsDefault(gltfModel, id, value)); Optionals.of(outputGltf.getImages()).forEach((id, value) -> storeImageAsDefault(gltfModel, id, value)); Optionals.of(outputGltf.getShaders()).forEach((id, value) -> storeShaderAsDefault(gltfModel, id, value));
getGltf().getNodes(), nodeId, context)); if (validatorResult.hasErrors()) Node node = getGltf().getNodes().get(nodeId); getGltf().getMeshes(), meshes, "meshes", false, context)); if (validatorResult.hasErrors()) getGltf().getNodes(), children, "children", false, context)); if (validatorResult.hasErrors()) getGltf().getCameras(), cameraId, context.with("node.camera"))); if (validatorResult.hasErrors()) getGltf().getSkins(), skinId, context.with("node.skin"))); if (validatorResult.hasErrors()) getGltf().getNodes(), skeletons, "skeletons", false, context)); if (validatorResult.hasErrors())
getGltf().getTextures(), textureId, context)); if (validatorResult.hasErrors()) Texture texture = getGltf().getTextures().get(textureId); getGltf().getImages(), imageId, context.with("image"))); if (validatorResult.hasErrors()) getGltf().getSamplers(), samplerId, context.with("sampler"))); if (validatorResult.hasErrors())
getGltf().getMaterials(), materialId, context)); if (validatorResult.hasErrors()) Material material = getGltf().getMaterials().get(materialId); getGltf().getTechniques(), techniqueId, context)); if (validatorResult.hasErrors())
getGltf().getPrograms(), programId, context)); if (validatorResult.hasErrors()) Program program = getGltf().getPrograms().get(programId); getGltf().getShaders(), vertexShaderId, context)); if (validatorResult.hasErrors()) Shader vertexShader = getGltf().getShaders().get(vertexShaderId); Integer vertexShaderType = vertexShader.getType(); if (vertexShaderType != GltfConstants.GL_VERTEX_SHADER) getGltf().getShaders(), fragmentShaderId, context)); if (validatorResult.hasErrors()) Shader fragmentShader = getGltf().getShaders().get(fragmentShaderId); Integer fragmentShaderType = fragmentShader.getType(); if (fragmentShaderType != GltfConstants.GL_FRAGMENT_SHADER)
/** * Create the {@link ShaderModel} instances */ private void createShaderModels() { Map<String, Shader> shaders = Optionals.of(gltf.getShaders()); for (Entry<String, Shader> entry : shaders.entrySet()) { Shader shader = entry.getValue(); Integer type = shader.getType(); ShaderType shaderType = null; if (type == GltfConstants.GL_VERTEX_SHADER) { shaderType = ShaderType.VERTEX_SHADER; } else { shaderType = ShaderType.FRAGMENT_SHADER; } DefaultShaderModel shaderModel = new DefaultShaderModel(shader.getUri(), shaderType); shaderModels.add(shaderModel); } }
getGltf().getTechniques(), techniqueId, context)); if (validatorResult.hasErrors()) Technique technique = getGltf().getTechniques().get(techniqueId); getGltf().getPrograms(), programId, context)); if (validatorResult.hasErrors())
/** * Create the {@link TextureModel} instances */ private void createTextureModels() { Map<String, Texture> textures = Optionals.of(gltf.getTextures()); Map<String, Sampler> samplers = Optionals.of(gltf.getSamplers()); for (Entry<String, Texture> entry : textures.entrySet()) { Texture texture = entry.getValue(); String samplerId = texture.getSampler(); Sampler sampler = samplers.get(samplerId); int magFilter = Optionals.of( sampler.getMagFilter(), sampler.defaultMagFilter()); int minFilter = Optionals.of( sampler.getMinFilter(), sampler.defaultMinFilter()); int wrapS = Optionals.of( sampler.getWrapS(), sampler.defaultWrapS()); int wrapT = Optionals.of( sampler.getWrapT(), sampler.defaultWrapT()); textureModels.add(new DefaultTextureModel( magFilter, minFilter, wrapS, wrapT)); } }
/** * Create the {@link ProgramModel} instances */ private void createProgramModels() { Map<String, Program> programs = Optionals.of(gltf.getPrograms()); for (int i = 0; i < programs.size(); i++) { programModels.add(new DefaultProgramModel()); } }
/** * Create the {@link TechniqueModel} instances */ private void createTechniqueModels() { Map<String, Technique> techniques = Optionals.of(gltf.getTechniques()); for (int i = 0; i < techniques.size(); i++) { techniqueModels.add(new DefaultTechniqueModel()); } }
/** * Create the {@link MeshModel} instances */ private void createMeshModels() { Map<String, Mesh> meshes = Optionals.of(gltf.getMeshes()); for (int i = 0; i < meshes.size(); i++) { meshModels.add(new DefaultMeshModel()); } }
/** * Create the {@link NodeModel} instances */ private void createNodeModels() { Map<String, Node> nodes = Optionals.of(gltf.getNodes()); for (int i = 0; i < nodes.size(); i++) { nodeModels.add(new DefaultNodeModel()); } }