GitHub-Proxy/tinygltf
1
0
Fork 0
mirror of https://git.mirrors.martin98.com/https://github.com/syoyo/tinygltf.git synced 2025-09-13 07:23:15 +08:00
Code Issues Packages Projects Releases Wiki Activity

Support macOS + OpenGL 3.3+ GPU

Browse Source
This commit is contained in:
Syoyo Fujita 2019-01-14 22:10:32 +09:00
parent d6b0b0b990
commit b864ea7349
4 changed files with 244 additions and 246 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
examples/basic/README.md
View File

@ -2,10 +2,12 @@
## Requirements ## Requirements
* glew
* glfw3 * glfw3
* premake5(linux) * premake5(linux)
* OpenGL 3.3+ GPU
## Build on Linux ## Build on Linux and macOS
``` ```
$ premake5 gmake $ premake5 gmake

482
examples/basic/main.cpp
View File

@ -1,12 +1,12 @@
#include <iostream> #include <fstream>
#include <fstream> #include <iostream>
#include <GL/glew.h> #include <GL/glew.h>
#include <GLFW/glfw3.h> #include <GLFW/glfw3.h>
#include <glm/gtc/matrix_transform.hpp> #include <glm/gtc/matrix_transform.hpp>
#include "window.h"
#include "shaders.h" #include "shaders.h"
#include "window.h"
#define TINYGLTF_IMPLEMENTATION #define TINYGLTF_IMPLEMENTATION
#define STB_IMAGE_IMPLEMENTATION #define STB_IMAGE_IMPLEMENTATION
@ -17,322 +17,318 @@
#define BUFFER_OFFSET(i) ((char *)NULL + (i)) #define BUFFER_OFFSET(i) ((char *)NULL + (i))
bool loadModel(tinygltf::Model &model, const char *filename) {
tinygltf::TinyGLTF loader;
std::string err;
std::string warn;
bool loadModel(tinygltf::Model &model, const char* filename) bool res = loader.LoadASCIIFromFile(&model, &err, &warn, filename);
{ if (!warn.empty()) {
tinygltf::TinyGLTF loader; std::cout << "WARN: " << warn << std::endl;
std::string err; }
std::string warn;
bool res = loader.LoadASCIIFromFile(&model, &err, &warn, filename); if (!err.empty()) {
if (!warn.empty()) { std::cout << "ERR: " << err << std::endl;
std::cout << "WARN: " << warn << std::endl; }
}
if (!err.empty()) { if (!res)
std::cout << "ERR: " << err << std::endl; std::cout << "Failed to load glTF: " << filename << std::endl;
} else
std::cout << "Loaded glTF: " << filename << std::endl;
if (!res) return res;
std::cout << "Failed to load glTF: " << filename << std::endl;
else std::cout << "Loaded glTF: " << filename << std::endl;
return res;
} }
std::map<int, GLuint> bindMesh(std::map<int, GLuint> vbos,
tinygltf::Model &model, tinygltf::Mesh &mesh) {
for (size_t i = 0; i < model.bufferViews.size(); ++i) {
const tinygltf::BufferView &bufferView = model.bufferViews[i];
if (bufferView.target == 0) { // TODO impl drawarrays
std::cout << "WARN: bufferView.target is zero" << std::endl;
continue; // Unsupported bufferView.
/*
From spec2.0 readme:
https://github.com/KhronosGroup/glTF/tree/master/specification/2.0
... drawArrays function should be used with a count equal to
the count property of any of the accessors referenced by the attributes
property (they are all equal for a given primitive).
*/
}
std::map<int, GLuint> bindMesh(std::map<int, GLuint> vbos, tinygltf::Model &model, tinygltf::Mesh &mesh) tinygltf::Buffer buffer = model.buffers[bufferView.buffer];
{ std::cout << "bufferview.target " << bufferView.target << std::endl;
for (size_t i = 0; i < model.bufferViews.size(); ++i) {
const tinygltf::BufferView &bufferView = model.bufferViews[i];
if (bufferView.target == 0) { // TODO impl drawarrays
std::cout << "WARN: bufferView.target is zero" << std::endl;
continue; // Unsupported bufferView.
/*
From spec2.0 readme: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0
... drawArrays function should be used with a count equal to the count
property of any of the accessors referenced by the attributes property
(they are all equal for a given primitive).
*/
}
tinygltf::Buffer buffer = model.buffers[bufferView.buffer]; GLuint vbo;
std::cout << "bufferview.target " << bufferView.target << std::endl; glGenBuffers(1, &vbo);
vbos[i] = vbo;
glBindBuffer(bufferView.target, vbo);
GLuint vbo; std::cout << "buffer.data.size = " << buffer.data.size()
glGenBuffers(1, &vbo); << ", bufferview.byteOffset = " << bufferView.byteOffset
vbos[i] = vbo; << std::endl;
glBindBuffer(bufferView.target, vbo);
std::cout << "buffer.data.size = " << buffer.data.size() << ", bufferview.byteOffset = " glBufferData(bufferView.target, bufferView.byteLength,
<< bufferView.byteOffset << std::endl; &buffer.data.at(0) + bufferView.byteOffset, GL_STATIC_DRAW);
}
glBufferData(bufferView.target, bufferView.byteLength, for (size_t i = 0; i < mesh.primitives.size(); ++i) {
&buffer.data.at(0) + bufferView.byteOffset, GL_STATIC_DRAW); tinygltf::Primitive primitive = mesh.primitives[i];
} tinygltf::Accessor indexAccessor = model.accessors[primitive.indices];
for (size_t i = 0; i < mesh.primitives.size(); ++i) for (auto &attrib : primitive.attributes) {
{ tinygltf::Accessor accessor = model.accessors[attrib.second];
tinygltf::Primitive primitive = mesh.primitives[i]; int byteStride =
tinygltf::Accessor indexAccessor = model.accessors[primitive.indices]; accessor.ByteStride(model.bufferViews[accessor.bufferView]);
glBindBuffer(GL_ARRAY_BUFFER, vbos[accessor.bufferView]);
for (auto& attrib : primitive.attributes) int size = 1;
{ if (accessor.type != TINYGLTF_TYPE_SCALAR) {
tinygltf::Accessor accessor = model.accessors[attrib.second]; size = accessor.type;
int byteStride = accessor.ByteStride(model.bufferViews[accessor.bufferView]); }
glBindBuffer(GL_ARRAY_BUFFER, vbos[accessor.bufferView]);
int size = 1; int vaa = -1;
if (accessor.type != TINYGLTF_TYPE_SCALAR) { if (attrib.first.compare("POSITION") == 0) vaa = 0;
size = accessor.type; if (attrib.first.compare("NORMAL") == 0) vaa = 1;
} if (attrib.first.compare("TEXCOORD_0") == 0) vaa = 2;
if (vaa > -1) {
glEnableVertexAttribArray(vaa);
glVertexAttribPointer(vaa, size, accessor.componentType,
accessor.normalized ? GL_TRUE : GL_FALSE,
byteStride, BUFFER_OFFSET(accessor.byteOffset));
} else
std::cout << "vaa missing: " << attrib.first << std::endl;
}
int vaa = -1; GLuint texid;
if (attrib.first.compare("POSITION") == 0) vaa = 0; glGenTextures(1, &texid);
if (attrib.first.compare("NORMAL") == 0) vaa = 1;
if (attrib.first.compare("TEXCOORD_0") == 0) vaa = 2;
if (vaa > -1)
{
glEnableVertexAttribArray(vaa);
glVertexAttribPointer(
vaa,
size,
accessor.componentType,
accessor.normalized ? GL_TRUE : GL_FALSE,
byteStride,
BUFFER_OFFSET(accessor.byteOffset)
);
}
else std::cout << "vaa missing: " << attrib.first << std::endl;
}
GLuint texid; tinygltf::Texture &tex = model.textures[0];
glGenTextures(1, &texid); tinygltf::Image &image = model.images[tex.source];
tinygltf::Texture &tex = model.textures[0]; glBindTexture(GL_TEXTURE_2D, texid);
tinygltf::Image &image = model.images[tex.source]; glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glBindTexture(GL_TEXTURE_2D, texid); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, image.width, image.height, 0,
glPixelStorei(GL_UNPACK_ALIGNMENT, 1); GL_RGBA, GL_UNSIGNED_BYTE, &image.image.at(0));
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); }
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, image.width, return vbos;
image.height, 0, GL_RGBA, GL_UNSIGNED_BYTE,
&image.image.at(0));
}
return vbos;
} }
// bind models // bind models
void bindModelNodes(std::map<int, GLuint> vbos, tinygltf::Model &model, tinygltf::Node &node) void bindModelNodes(std::map<int, GLuint> vbos, tinygltf::Model &model,
{ tinygltf::Node &node) {
bindMesh(vbos, model, model.meshes[node.mesh]); bindMesh(vbos, model, model.meshes[node.mesh]);
for (size_t i = 0; i < node.children.size(); i++) { for (size_t i = 0; i < node.children.size(); i++) {
bindModelNodes(vbos, model, model.nodes[node.children[i]]); bindModelNodes(vbos, model, model.nodes[node.children[i]]);
} }
} }
GLuint bindModel(tinygltf::Model &model) { GLuint bindModel(tinygltf::Model &model) {
std::map<int, GLuint> vbos; std::map<int, GLuint> vbos;
GLuint vao; GLuint vao;
glGenVertexArrays(1, &vao); glGenVertexArrays(1, &vao);
glBindVertexArray(vao); glBindVertexArray(vao);
const tinygltf::Scene &scene = model.scenes[model.defaultScene]; const tinygltf::Scene &scene = model.scenes[model.defaultScene];
for (size_t i = 0; i < scene.nodes.size(); ++i) { for (size_t i = 0; i < scene.nodes.size(); ++i) {
bindModelNodes(vbos, model, model.nodes[scene.nodes[i]]); bindModelNodes(vbos, model, model.nodes[scene.nodes[i]]);
} }
glBindVertexArray(0); glBindVertexArray(0);
// cleanup vbos // cleanup vbos
for (size_t i = 0; i < vbos.size(); ++i) for (size_t i = 0; i < vbos.size(); ++i) {
{ glDeleteBuffers(1, &vbos[i]);
glDeleteBuffers(1, &vbos[i]); }
}
return vao; return vao;
} }
void drawMesh(tinygltf::Model &model, tinygltf::Mesh &mesh) {
for (size_t i = 0; i < mesh.primitives.size(); ++i) {
tinygltf::Primitive primitive = mesh.primitives[i];
tinygltf::Accessor indexAccessor = model.accessors[primitive.indices];
glDrawElements(primitive.mode, indexAccessor.count,
void drawMesh(tinygltf::Model &model, tinygltf::Mesh &mesh) indexAccessor.componentType,
{ BUFFER_OFFSET(indexAccessor.byteOffset));
for (size_t i = 0; i < mesh.primitives.size(); ++i) }
{
tinygltf::Primitive primitive = mesh.primitives[i];
tinygltf::Accessor indexAccessor = model.accessors[primitive.indices];
glDrawElements(primitive.mode, indexAccessor.count, indexAccessor.componentType,
BUFFER_OFFSET(indexAccessor.byteOffset));
}
} }
// recursively draw node and children nodes of model // recursively draw node and children nodes of model
void drawModelNodes(tinygltf::Model &model, tinygltf::Node &node) void drawModelNodes(tinygltf::Model &model, tinygltf::Node &node) {
{ drawMesh(model, model.meshes[node.mesh]);
drawMesh(model, model.meshes[node.mesh]); for (size_t i = 0; i < node.children.size(); i++) {
for (size_t i = 0; i < node.children.size(); i++) { drawModelNodes(model, model.nodes[node.children[i]]);
drawModelNodes(model, model.nodes[node.children[i]]); }
}
} }
void drawModel(GLuint vao, tinygltf::Model &model) void drawModel(GLuint vao, tinygltf::Model &model) {
{ glBindVertexArray(vao);
glBindVertexArray(vao);
const tinygltf::Scene &scene = model.scenes[model.defaultScene]; const tinygltf::Scene &scene = model.scenes[model.defaultScene];
for (size_t i = 0; i < scene.nodes.size(); ++i) { for (size_t i = 0; i < scene.nodes.size(); ++i) {
drawModelNodes(model, model.nodes[scene.nodes[i]]); drawModelNodes(model, model.nodes[scene.nodes[i]]);
} }
glBindVertexArray(0); glBindVertexArray(0);
} }
void dbgModel(tinygltf::Model &model) {
for (auto &mesh : model.meshes) {
std::cout << "mesh : " << mesh.name << std::endl;
for (auto &primitive : mesh.primitives) {
const tinygltf::Accessor &indexAccessor =
model.accessors[primitive.indices];
std::cout << "indexaccessor: count " << indexAccessor.count << ", type "
<< indexAccessor.componentType << std::endl;
tinygltf::Material &mat = model.materials[primitive.material];
for (auto &mats : mat.values) {
std::cout << "mat : " << mats.first.c_str() << std::endl;
}
void dbgModel(tinygltf::Model &model) for (auto &image : model.images) {
{ std::cout << "image name : " << image.uri << std::endl;
for (auto &mesh : model.meshes) std::cout << " size : " << image.image.size() << std::endl;
{ std::cout << " w/h : " << image.width << "/" << image.height
std::cout << "mesh : " << mesh.name << std::endl; << std::endl;
for (auto &primitive : mesh.primitives) }
{
const tinygltf::Accessor &indexAccessor = model.accessors[primitive.indices];
std::cout << "indexaccessor: count " << indexAccessor.count << ", type " << std::cout << "indices : " << primitive.indices << std::endl;
indexAccessor.componentType << std::endl; std::cout << "mode : "
<< "(" << primitive.mode << ")" << std::endl;
tinygltf::Material &mat = model.materials[primitive.material]; for (auto &attrib : primitive.attributes) {
for (auto &mats : mat.values) std::cout << "attribute : " << attrib.first.c_str() << std::endl;
{ }
std::cout << "mat : " << mats.first.c_str() << std::endl; }
} }
for (auto &image : model.images)
{
std::cout << "image name : " << image.uri << std::endl;
std::cout << " size : " << image.image.size() << std::endl;
std::cout << " w/h : " << image.width << "/" << image.height << std::endl;
}
std::cout << "indices : " << primitive.indices << std::endl;
std::cout << "mode : " << "(" << primitive.mode << ")" << std::endl;
for (auto &attrib : primitive.attributes)
{
std::cout << "attribute : " << attrib.first.c_str() << std::endl;
}
}
}
} }
glm::mat4 genView(glm::vec3 pos, glm::vec3 lookat) {
// Camera matrix
glm::mat4 view = glm::lookAt(
pos, // Camera in World Space
lookat, // and looks at the origin
glm::vec3(0, 1, 0) // Head is up (set to 0,-1,0 to look upside-down)
);
glm::mat4 genView(glm::vec3 pos, glm::vec3 lookat) return view;
{
// Camera matrix
glm::mat4 view = glm::lookAt(
pos, // Camera in World Space
lookat, // and looks at the origin
glm::vec3(0, 1, 0) // Head is up (set to 0,-1,0 to look upside-down)
);
return view;
} }
glm::mat4 genMVP(glm::mat4 view_mat, glm::mat4 model_mat, float fov, int w, int h) glm::mat4 genMVP(glm::mat4 view_mat, glm::mat4 model_mat, float fov, int w,
{ int h) {
glm::mat4 Projection = glm::perspective(glm::radians(fov), (float)w / (float)h, 0.01f, 1000.0f); glm::mat4 Projection =
glm::perspective(glm::radians(fov), (float)w / (float)h, 0.01f, 1000.0f);
// Or, for an ortho camera : // Or, for an ortho camera :
//glm::mat4 Projection = glm::ortho(-10.0f,10.0f,-10.0f,10.0f,0.0f,100.0f); // In world coordinates // glm::mat4 Projection = glm::ortho(-10.0f,10.0f,-10.0f,10.0f,0.0f,100.0f);
// // In world coordinates
glm::mat4 mvp = Projection * view_mat * model_mat;
glm::mat4 mvp = Projection * view_mat * model_mat; return mvp;
return mvp;
} }
void displayLoop(Window& window, const std::string &filename) void displayLoop(Window &window, const std::string &filename) {
{ Shaders shader = Shaders();
Shaders shader = Shaders(); glUseProgram(shader.pid);
glUseProgram(shader.pid);
// grab uniforms to modify // grab uniforms to modify
GLuint MVP_u = glGetUniformLocation(shader.pid, "MVP"); GLuint MVP_u = glGetUniformLocation(shader.pid, "MVP");
GLuint sun_position_u = glGetUniformLocation(shader.pid, "sun_position"); GLuint sun_position_u = glGetUniformLocation(shader.pid, "sun_position");
GLuint sun_color_u = glGetUniformLocation(shader.pid, "sun_color"); GLuint sun_color_u = glGetUniformLocation(shader.pid, "sun_color");
tinygltf::Model model; tinygltf::Model model;
if (!loadModel(model, filename.c_str())) return; if (!loadModel(model, filename.c_str())) return;
GLuint vao = bindModel(model); GLuint vao = bindModel(model);
//dbgModel(model); return; // dbgModel(model); return;
// Model matrix : an identity matrix (model will be at the origin) // Model matrix : an identity matrix (model will be at the origin)
glm::mat4 model_mat = glm::mat4(1.0f); glm::mat4 model_mat = glm::mat4(1.0f);
glm::mat4 model_rot = glm::mat4(1.0f); glm::mat4 model_rot = glm::mat4(1.0f);
glm::vec3 model_pos = glm::vec3(-3, 0, -3); glm::vec3 model_pos = glm::vec3(-3, 0, -3);
// generate a camera view, based on eye-position and lookAt world-position // generate a camera view, based on eye-position and lookAt world-position
glm::mat4 view_mat = genView(glm::vec3(2,2,2), model_pos); glm::mat4 view_mat = genView(glm::vec3(2, 2, 2), model_pos);
glm::vec3 sun_position = glm::vec3(3.0, 10.0, -5.0); glm::vec3 sun_position = glm::vec3(3.0, 10.0, -5.0);
glm::vec3 sun_color = glm::vec3(1.0); glm::vec3 sun_color = glm::vec3(1.0);
while (!window.Close()) while (!window.Close()) {
{ window.Resize();
window.Resize();
glClearColor(0.2, 0.2, 0.2, 1.0); glClearColor(0.2, 0.2, 0.2, 1.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glm::mat4 trans =
glm::translate(glm::mat4(1.0f), model_pos); // reposition model
model_rot = glm::rotate(model_rot, glm::radians(0.8f),
glm::vec3(0, 1, 0)); // rotate model on y axis
model_mat = trans * model_rot;
glm::mat4 trans = glm::translate(glm::mat4(1.0f), model_pos); // reposition model // build a model-view-projection
model_rot = glm::rotate(model_rot, glm::radians(0.8f), glm::vec3(0,1,0)); // rotate model on y axis GLint w, h;
model_mat = trans*model_rot; glfwGetWindowSize(window.window, &w, &h);
glm::mat4 mvp = genMVP(view_mat, model_mat, 45.0f, w, h);
// build a model-view-projection glUniformMatrix4fv(MVP_u, 1, GL_FALSE, &mvp[0][0]);
GLint w, h;
glfwGetWindowSize(window.window, &w, &h);
glm::mat4 mvp = genMVP(view_mat, model_mat, 45.0f, w, h);
glUniformMatrix4fv(MVP_u, 1, GL_FALSE, &mvp[0][0]);
glUniform3fv(sun_position_u, 1, &sun_position[0]); glUniform3fv(sun_position_u, 1, &sun_position[0]);
glUniform3fv(sun_color_u, 1, &sun_color[0]); glUniform3fv(sun_color_u, 1, &sun_color[0]);
drawModel(vao, model); drawModel(vao, model);
glfwSwapBuffers(window.window); glfwSwapBuffers(window.window);
glfwPollEvents(); glfwPollEvents();
} }
} }
int main(int argc, char **argv) {
int main(int argc, char **argv)
{
std::string filename = "../../models/Cube/Cube.gltf"; std::string filename = "../../models/Cube/Cube.gltf";
if (argc > 1) { if (argc > 1) {
filename = argv[1]; filename = argv[1];
} }
if (!glfwInit()) return -1; if (!glfwInit()) return -1;
Window window = Window(800, 600, "TinyGLTF basic example");
glfwMakeContextCurrent(window.window);
glewInit(); // Force create 3.3 profile.
std::cout << glGetString(GL_RENDERER) << ", " << glGetString(GL_VERSION) << std::endl; glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
#ifdef __APPLE__
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
#endif
glEnable(GL_DEPTH_TEST); Window window = Window(800, 600, "TinyGLTF basic example");
glDepthFunc(GL_LESS); glfwMakeContextCurrent(window.window);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); #ifdef __APPLE__
glEnable(GL_BLEND); // https://stackoverflow.com/questions/50192625/openggl-segmentation-fault
glewExperimental = GL_TRUE;
#endif
displayLoop(window, filename); glewInit();
std::cout << glGetString(GL_RENDERER) << ", " << glGetString(GL_VERSION)
<< std::endl;
glfwTerminate(); if (!GLEW_VERSION_3_3) {
return 0; std::cerr << "OpenGL 3.3 is required to execute this app." << std::endl;
return EXIT_FAILURE;
}
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND);
displayLoop(window, filename);
glfwTerminate();
return 0;
} }

2
examples/basic/premake5.lua
View File

@ -30,7 +30,7 @@ solution "basic_viewer"
includedirs { "/usr/local/include" } includedirs { "/usr/local/include" }
buildoptions { "-Wno-deprecated-declarations" } buildoptions { "-Wno-deprecated-declarations" }
libdirs { "/usr/local/lib" } libdirs { "/usr/local/lib" }
links { "glfw3", "GLEW" } links { "glfw", "GLEW" }
linkoptions { "-framework OpenGL", "-framework Cocoa", "-framework IOKit", "-framework CoreVideo" } linkoptions { "-framework OpenGL", "-framework Cocoa", "-framework IOKit", "-framework CoreVideo" }
configuration "Debug" configuration "Debug"

2
examples/basic/shaders.cpp
View File

@ -19,7 +19,7 @@ uniform vec3 sun_color; \n\
out vec4 color;\n\ out vec4 color;\n\
void main() {\n\ void main() {\n\
float lum = max(dot(normal, normalize(sun_position)), 0.0);\n\ float lum = max(dot(normal, normalize(sun_position)), 0.0);\n\
color = texture2D(tex, texcoord) * vec4((0.3 + 0.7 * lum) * sun_color, 1.0);\n\ color = texture(tex, texcoord) * vec4((0.3 + 0.7 * lum) * sun_color, 1.0);\n\
}\n\ }\n\
"; ";