int main(int argc, char** argv)
{
try {
TCLAP::CmdLine cmd("Command description message", ' ', "0.9");
TCLAP::ValueArg<std::string> trainingData("d", "data", "training data", true, "", "string");
cmd.add(trainingData);
TCLAP::ValueArg<int> maxIteration("i", "iter", "max iterations", true, 10, "int");
cmd.add(maxIteration);
TCLAP::ValueArg<double> learningRate("s", "step", "leraning rate", true, 0.001, "double");
cmd.add(learningRate);
TCLAP::ValueArg<double> variance("l", "l1", "variance", true, 0.001, "double");
cmd.add(variance);
TCLAP::ValueArg<string> modelPath("m", "model", "model path", true, "./lccrf.weights.txt", "string");
cmd.add(modelPath);
// Parse the argv array.
cmd.parse(argc, argv);
LCCRF lccrf;
lccrf.Fit(trainingData.getValue(), maxIteration.getValue(), learningRate.getValue(), variance.getValue());
lccrf.Save(modelPath.getValue());
return 0;
}
catch (TCLAP::ArgException &e) // catch any exceptions
{
std::cerr << "error: " << e.error() << " for arg " << e.argId() << std::endl;
return 1;
}
}
recondite::Model* reProjectAssets::ImportModel(const wxString& path) {
import::ModelImporter modelImporter;
import::ModelImporterOptions options;
ModelData modelData;
int error = modelImporter.ImportModel(path.c_str().AsChar(), modelData, options);
if (!error) {
modelData.CalculateBoundings();
wxFileName modelPath(path);
wxString modelName = modelPath.GetName();
WriteModel(modelData, modelName);
if (modelData.GetLineMeshCount() == 0) {
CreateSelectionWireframeForModel(modelData);
}
recondite::Model* model = _component->GetEngine()->content->Models()->LoadFromData(modelData, modelName.c_str().AsChar());
wxString modelHandle = GetAssetPath(rAssetType::Model, modelName);
_manifest.Add(rAssetType::Model, modelName.c_str().AsChar(), modelHandle.c_str().AsChar());
return model;
}
return nullptr;
}
void AssimpModel::loadTextures(const std::string& model)
{
for (unsigned int material = 0 ; material < m_scene->mNumMaterials; material++) {
aiString path;
unsigned int index = 0;
while(AI_SUCCESS == m_scene->mMaterials[material]->GetTexture(aiTextureType_DIFFUSE, index, &path)) {
GLuint& texture = m_textures[path.data];
boost::filesystem::path modelPath(model);
std::string basepath = modelPath.remove_leaf().string();
std::string fileloc = basepath + "/" + path.C_Str();
texture = SOIL_load_OGL_texture
(
fileloc.c_str(),
SOIL_LOAD_AUTO,
SOIL_CREATE_NEW_ID,
SOIL_FLAG_MIPMAPS | SOIL_FLAG_INVERT_Y | SOIL_FLAG_NTSC_SAFE_RGB | SOIL_FLAG_COMPRESS_TO_DXT
);
index++;
}
}
}
int main(int argc, char** argv)
{
#define MAX_OBJ_FILENAME 500;
std::string modelName;
if (argc != 2) {
std::cerr << "Usage: " << argv[0] << " <model.obj>" << std::endl;
#if _DEBUG
modelName = std::string("test.obj");
#else
return -1;
#endif
} else {
modelName = std::string(argv[1]);
}
std::cout << "Loading " << modelName << std::endl;
std::string modelPath(MODEL_DIRECTORY);
modelPath += std::string(DIRECTORY_SEPARATOR) + modelName;
std:: ifstream objFile(modelPath.c_str());
#if _MSC_VER
std::cerr << "MSVC detected" << std::endl;
#else
if (false == objFile.is_open())
{
std::cerr << "Unable to load " << modelPath << std::endl;
return -2;
}
#endif
MyGLApp objViewer(modelName.c_str());
objViewer.start();
SDL_Quit();
return 0;
}
int main ( int argc, char *argv[] )
{
std::vector<std::string> args (argv, argv + argc);
if ( args.size() == 1 )
{
PrintUsage (args[0]);
return EXIT_FAILURE;
}
std::string animationFile;
std::string outputPath ("model.glm");
unsigned i;
for ( i = 1; i < args.size(); i++ )
{
if ( args[i].compare ("-o") == 0 )
{
i++;
if ( args.size() > i )
{
outputPath = args[i];
continue;
}
else
{
PrintUsage (args[0]);
return EXIT_FAILURE;
}
}
else if ( args[i].compare ("-anim") == 0 )
{
i++;
if ( args.size() > i )
{
animationFile = args[i];
continue;
}
else
{
PrintUsage (args[0]);
return EXIT_FAILURE;
}
}
}
std::unique_ptr<Skeleton> skeleton;
std::string modelPath (args.back());
std::cout << "Converting " << modelPath << " to GLM.\n";
if ( !animationFile.empty() )
{
skeleton = LoadGLA (animationFile);
if ( !skeleton )
{
return EXIT_FAILURE;
}
std::cout << "Using " << animationFile << " for skeleton.\n";
}
FbxManager *fbxManager = FbxManager::Create();
FbxIOSettings *ios = FbxIOSettings::Create (fbxManager, IOSROOT);
fbxManager->SetIOSettings (ios);
FbxImporter *importer = FbxImporter::Create (fbxManager, "");
if ( !importer->Initialize (modelPath.c_str(), -1, fbxManager->GetIOSettings()) )
{
std::cerr << "ERROR: Failed to import '" << modelPath << "': " << importer->GetStatus().GetErrorString() << ".\n";
importer->Destroy();
fbxManager->Destroy();
return EXIT_FAILURE;
}
FbxScene *scene = FbxScene::Create (fbxManager, "model");
importer->Import (scene);
importer->Destroy();
FbxNode *root = scene->GetRootNode();
if ( root == nullptr )
{
std::cerr << "ERROR: The scene's root node could not be found.\n";
fbxManager->Destroy();
return EXIT_FAILURE;
}
std::vector<FbxNode *> modelRoots (GetLodRootModels (*root));
if ( modelRoots.empty() )
{
std::cerr << "ERROR: No model LODs found.\n";
fbxManager->Destroy();
return EXIT_FAILURE;
}
std::sort (modelRoots.begin(), modelRoots.end(),
[]( const FbxNode *a, const FbxNode *b ) { return std::strcmp (a->GetName(), b->GetName()) < 0; });
if ( !MakeGLMFile (*scene, modelRoots, skeleton.get(), outputPath) )
{
std::cerr << "ERROR: Failed to create GLM file " << outputPath << ".\n";
fbxManager->Destroy();
return EXIT_FAILURE;
}
std::cout << "GLM file has been written to '" << outputPath << "'.\n";
fbxManager->Destroy();
return 0;
}
int main(int argc, char** argv)
{
if (!glfwInit()) // 初始化glfw库
{
std::cout << "Error::GLFW could not initialize GLFW!" << std::endl;
return -1;
}
// 开启OpenGL 3.3 core profile
std::cout << "Start OpenGL core profile version 3.3" << std::endl;
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);
// 创建窗口
GLFWwindow* window = glfwCreateWindow(WINDOW_WIDTH, WINDOW_HEIGHT,
"Demo of geometry shader(explode effect)", NULL, NULL);
if (!window)
{
std::cout << "Error::GLFW could not create winddow!" << std::endl;
glfwTerminate();
std::system("pause");
return -1;
}
// 创建的窗口的context指定为当前context
glfwMakeContextCurrent(window);
// 注册窗口键盘事件回调函数
glfwSetKeyCallback(window, key_callback);
// 注册鼠标事件回调函数
glfwSetCursorPosCallback(window, mouse_move_callback);
// 注册鼠标滚轮事件回调函数
glfwSetScrollCallback(window, mouse_scroll_callback);
// 鼠标捕获 停留在程序内
glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
// 初始化GLEW 获取OpenGL函数
glewExperimental = GL_TRUE; // 让glew获取所有拓展函数
GLenum status = glewInit();
if (status != GLEW_OK)
{
std::cout << "Error::GLEW glew version:" << glewGetString(GLEW_VERSION)
<< " error string:" << glewGetErrorString(status) << std::endl;
glfwTerminate();
std::system("pause");
return -1;
}
// 设置视口参数
glViewport(0, 0, WINDOW_WIDTH, WINDOW_HEIGHT);
//Section1 加载模型数据 为了方便更换模型 我们从文件读取模型文件路径
Model objModel;
std::ifstream modelPath("modelPath.txt");
if (!modelPath)
{
std::cerr << "Error::could not read model path file." << std::endl;
glfwTerminate();
std::system("pause");
return -1;
}
std::string modelFilePath;
std::getline(modelPath, modelFilePath);
if (modelFilePath.empty())
{
std::cerr << "Error::model path empty." << std::endl;
glfwTerminate();
std::system("pause");
return -1;
}
if (!objModel.loadModel(modelFilePath))
{
glfwTerminate();
std::system("pause");
return -1;
}
// Section2 准备着色器程序
Shader shader("model.vertex", "model.frag", "model.gs"); // 添加了几何着色器
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
// 开始游戏主循环
while (!glfwWindowShouldClose(window))
{
GLfloat currentFrame = (GLfloat)glfwGetTime();
deltaTime = currentFrame - lastFrame;
lastFrame = currentFrame;
glfwPollEvents(); // 处理例如鼠标 键盘等事件
do_movement(); // 根据用户操作情况 更新相机属性
// 清除颜色缓冲区 重置为指定颜色
glClearColor(0.18f, 0.04f, 0.14f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
shader.use();
glm::mat4 projection = glm::perspective(camera.mouse_zoom,
(GLfloat)(WINDOW_WIDTH) / WINDOW_HEIGHT, 1.0f, 100.0f); // 投影矩阵
glm::mat4 view = camera.getViewMatrix(); // 视变换矩阵
glUniformMatrix4fv(glGetUniformLocation(shader.programId, "projection"),
1, GL_FALSE, glm::value_ptr(projection));
glUniformMatrix4fv(glGetUniformLocation(shader.programId, "view"),
1, GL_FALSE, glm::value_ptr(view));
glm::mat4 model;
model = glm::translate(model, glm::vec3(0.0f, -1.0f, -1.0f)); // 适当调整位置
model = glm::scale(model, glm::vec3(0.25f, 0.25f, 0.25f)); // 适当缩小模型
glUniformMatrix4fv(glGetUniformLocation(shader.programId, "model"),
1, GL_FALSE, glm::value_ptr(model));
glUniform1f(glGetUniformLocation(shader.programId, "time"), glfwGetTime());
// 这里填写场景绘制代码
objModel.draw(shader); // 绘制物体
glBindVertexArray(0);
glUseProgram(0);
glfwSwapBuffers(window); // 交换缓存
}
// 释放资源
glfwTerminate();
return 0;
}
