std::string ResLoader::Locate(std::string const & name)
{
#if defined(KLAYGE_PLATFORM_ANDROID)
android_app* state = Context::Instance().AppState();
AAssetManager* am = state->activity->assetManager;
AAsset* asset = AAssetManager_open(am, name.c_str(), AASSET_MODE_UNKNOWN);
if (asset != nullptr)
{
AAsset_close(asset);
return name;
}
#elif defined(KLAYGE_PLATFORM_IOS)
std::string::size_type found = name.find_last_of(".");
if (found != std::string::npos)
{
std::string::size_type found2 = name.find_last_of("/");
CFBundleRef main_bundle = CFBundleGetMainBundle();
CFStringRef file_name = CFStringCreateWithCString(kCFAllocatorDefault,
name.substr(found2 + 1, found - found2 - 1).c_str(), kCFStringEncodingASCII);
CFStringRef file_ext = CFStringCreateWithCString(kCFAllocatorDefault,
name.substr(found + 1).c_str(), kCFStringEncodingASCII);
CFURLRef file_url = CFBundleCopyResourceURL(main_bundle, file_name, file_ext, NULL);
CFRelease(file_name);
CFRelease(file_ext);
if (file_url != nullptr)
{
CFStringRef file_path = CFURLCopyFileSystemPath(file_url, kCFURLPOSIXPathStyle);
char const * path = CFStringGetCStringPtr(file_path, CFStringGetSystemEncoding());
std::string const res_name(path);
CFRelease(file_url);
CFRelease(file_path);
return res_name;
}
}
#else
typedef KLAYGE_DECLTYPE(paths_) PathsType;
KLAYGE_FOREACH(PathsType::const_reference path, paths_)
{
std::string const res_name(path + name);
if (filesystem::exists(filesystem::path(res_name)))
{
return res_name;
}
else
{
std::string::size_type const pkt_offset(res_name.find("//"));
if (pkt_offset != std::string::npos)
{
std::string pkt_name = res_name.substr(0, pkt_offset);
filesystem::path pkt_path(pkt_name);
if (filesystem::exists(pkt_path)
&& (filesystem::is_regular_file(pkt_path)
|| filesystem::is_symlink(pkt_path)))
{
std::string::size_type const password_offset = pkt_name.find("|");
std::string password;
if (password_offset != std::string::npos)
{
password = pkt_name.substr(password_offset + 1);
pkt_name = pkt_name.substr(0, password_offset - 1);
}
std::string const file_name = res_name.substr(pkt_offset + 2);
#ifdef KLAYGE_TR2_LIBRARY_FILESYSTEM_V3_SUPPORT
uint64_t timestamp = filesystem::last_write_time(pkt_path).time_since_epoch().count();
#else
uint64_t timestamp = filesystem::last_write_time(pkt_path);
#endif
ResIdentifierPtr pkt_file = MakeSharedPtr<ResIdentifier>(name, timestamp,
MakeSharedPtr<std::ifstream>(pkt_name.c_str(), std::ios_base::binary));
if (*pkt_file)
{
if (Find7z(pkt_file, password, file_name) != 0xFFFFFFFF)
{
return res_name;
}
}
}
}
}
}
void showGraph(TGraph* graph,
const std::string& xAxisTitle,
Float_t* genX,
double yMin, double yMax, const std::string& yAxisTitle,
const std::string& outputFileName)
{
TCanvas* canvas = new TCanvas("canvas", "canvas", 800, 600);
canvas->SetFillColor(10);
canvas->SetBorderSize(2);
canvas->SetTopMargin(0.10);
canvas->SetLeftMargin(0.16);
canvas->SetRightMargin(0.14);
canvas->SetBottomMargin(0.12);
int numPoints = graph->GetN();
double xMin, xMax, yDummy;
graph->GetPoint(0, xMin, yDummy);
graph->GetPoint(numPoints - 1, xMax, yDummy);
TH1* dummyHistogram = new TH1D("dummyHistogram", "dummyHistogram", numPoints/100, xMin, xMax);
dummyHistogram->SetStats(false);
dummyHistogram->SetMinimum(yMin);
dummyHistogram->SetMaximum(yMax);
TAxis* xAxis = dummyHistogram->GetXaxis();
xAxis->SetTitle(xAxisTitle.data());
xAxis->SetTitleOffset(1.15);
TAxis* yAxis = dummyHistogram->GetYaxis();
yAxis->SetTitle(yAxisTitle.data());
yAxis->SetTitleOffset(1.15);
dummyHistogram->Draw("axis");
TGraph* genMarker = 0;
if ( genX ) {
genMarker = new TGraph(2);
genMarker->SetPoint(0, xMin, *genX);
genMarker->SetPoint(1, xMax, *genX);
genMarker->SetLineColor(8);
genMarker->SetLineWidth(1);
genMarker->SetMarkerColor(8);
genMarker->SetMarkerStyle(20);
genMarker->SetMarkerSize(1);
genMarker->Draw("L");
}
graph->SetLineColor(1);
graph->SetLineWidth(2);
graph->SetMarkerColor(1);
graph->SetMarkerStyle(20);
graph->SetMarkerSize(1);
graph->Draw("L");
canvas->Update();
size_t idx = outputFileName.find_last_of('.');
std::string outputFileName_plot = std::string(outputFileName, 0, idx);
if ( idx != std::string::npos ) canvas->Print(std::string(outputFileName_plot).append(std::string(outputFileName, idx)).data());
canvas->Print(std::string(outputFileName_plot).append(".png").data());
canvas->Print(std::string(outputFileName_plot).append(".pdf").data());
canvas->Print(std::string(outputFileName_plot).append(".root").data());
delete dummyHistogram;
delete genMarker;
delete canvas;
}
// Returns the current directory
std::string GetCurrentDir()
{
// Get the current working directory (getcwd uses malloc)
#ifdef _WIN32
wchar_t *dir;
if (!(dir = _wgetcwd(nullptr, 0))) {
#else
char *dir;
if (!(dir = getcwd(nullptr, 0))) {
#endif
LOG_ERROR(Common_Filesystem, "GetCurrentDirectory failed: %s",
GetLastErrorMsg());
return nullptr;
}
#ifdef _WIN32
std::string strDir = Common::UTF16ToUTF8(dir);
#else
std::string strDir = dir;
#endif
free(dir);
return strDir;
}
// Sets the current directory to the given directory
bool SetCurrentDir(const std::string &directory)
{
#ifdef _WIN32
return _wchdir(Common::UTF8ToUTF16W(directory).c_str()) == 0;
#else
return chdir(directory.c_str()) == 0;
#endif
}
#if defined(__APPLE__)
std::string GetBundleDirectory()
{
CFURLRef BundleRef;
char AppBundlePath[MAXPATHLEN];
// Get the main bundle for the app
BundleRef = CFBundleCopyBundleURL(CFBundleGetMainBundle());
CFStringRef BundlePath = CFURLCopyFileSystemPath(BundleRef, kCFURLPOSIXPathStyle);
CFStringGetFileSystemRepresentation(BundlePath, AppBundlePath, sizeof(AppBundlePath));
CFRelease(BundleRef);
CFRelease(BundlePath);
return AppBundlePath;
}
#endif
#ifdef _WIN32
std::string& GetExeDirectory()
{
static std::string exe_path;
if (exe_path.empty())
{
wchar_t wchar_exe_path[2048];
GetModuleFileNameW(nullptr, wchar_exe_path, 2048);
exe_path = Common::UTF16ToUTF8(wchar_exe_path);
exe_path = exe_path.substr(0, exe_path.find_last_of('\\'));
}
return exe_path;
}
#else
/**
* @return The user’s home directory on POSIX systems
*/
static const std::string& GetHomeDirectory() {
static std::string home_path;
if (home_path.empty()) {
const char* envvar = getenv("HOME");
if (envvar) {
home_path = envvar;
} else {
auto pw = getpwuid(getuid());
ASSERT_MSG(pw, "$HOME isn’t defined, and the current user can’t be found in /etc/passwd.");
home_path = pw->pw_dir;
}
}
return home_path;
}
/**
* Follows the XDG Base Directory Specification to get a directory path
* @param envvar The XDG environment variable to get the value from
* @return The directory path
* @sa http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html
*/
static const std::string GetUserDirectory(const std::string& envvar) {
const char* directory = getenv(envvar.c_str());
std::string user_dir;
if (directory) {
user_dir = directory;
} else {
std::string subdirectory;
if (envvar == "XDG_DATA_HOME")
subdirectory = DIR_SEP ".local" DIR_SEP "share";
else if (envvar == "XDG_CONFIG_HOME")
subdirectory = DIR_SEP ".config";
else if (envvar == "XDG_CACHE_HOME")
subdirectory = DIR_SEP ".cache";
else
ASSERT_MSG(false, "Unknown XDG variable %s.", envvar.c_str());
user_dir = GetHomeDirectory() + subdirectory;
}
ASSERT_MSG(!user_dir.empty(), "User directory %s musn’t be empty.", envvar.c_str());
ASSERT_MSG(user_dir[0] == '/', "User directory %s must be absolute.", envvar.c_str());
return user_dir;
}
#endif
std::string GetSysDirectory()
{
std::string sysDir;
#if defined (__APPLE__)
sysDir = GetBundleDirectory();
sysDir += DIR_SEP;
sysDir += SYSDATA_DIR;
#else
sysDir = SYSDATA_DIR;
#endif
sysDir += DIR_SEP;
LOG_DEBUG(Common_Filesystem, "Setting to %s:", sysDir.c_str());
return sysDir;
}
// Returns a string with a Citra data dir or file in the user's home
// directory. To be used in "multi-user" mode (that is, installed).
const std::string& GetUserPath(const unsigned int DirIDX, const std::string &newPath)
{
static std::string paths[NUM_PATH_INDICES];
// Set up all paths and files on the first run
if (paths[D_USER_IDX].empty())
{
#ifdef _WIN32
paths[D_USER_IDX] = GetExeDirectory() + DIR_SEP USERDATA_DIR DIR_SEP;
paths[D_CONFIG_IDX] = paths[D_USER_IDX] + CONFIG_DIR DIR_SEP;
paths[D_CACHE_IDX] = paths[D_USER_IDX] + CACHE_DIR DIR_SEP;
#else
if (FileUtil::Exists(ROOT_DIR DIR_SEP USERDATA_DIR)) {
paths[D_USER_IDX] = ROOT_DIR DIR_SEP USERDATA_DIR DIR_SEP;
paths[D_CONFIG_IDX] = paths[D_USER_IDX] + CONFIG_DIR DIR_SEP;
paths[D_CACHE_IDX] = paths[D_USER_IDX] + CACHE_DIR DIR_SEP;
} else {
std::string data_dir = GetUserDirectory("XDG_DATA_HOME");
std::string config_dir = GetUserDirectory("XDG_CONFIG_HOME");
std::string cache_dir = GetUserDirectory("XDG_CACHE_HOME");
paths[D_USER_IDX] = data_dir + DIR_SEP EMU_DATA_DIR DIR_SEP;
paths[D_CONFIG_IDX] = config_dir + DIR_SEP EMU_DATA_DIR DIR_SEP;
paths[D_CACHE_IDX] = cache_dir + DIR_SEP EMU_DATA_DIR DIR_SEP;
}
#endif
paths[D_GAMECONFIG_IDX] = paths[D_USER_IDX] + GAMECONFIG_DIR DIR_SEP;
paths[D_MAPS_IDX] = paths[D_USER_IDX] + MAPS_DIR DIR_SEP;
paths[D_SDMC_IDX] = paths[D_USER_IDX] + SDMC_DIR DIR_SEP;
paths[D_NAND_IDX] = paths[D_USER_IDX] + NAND_DIR DIR_SEP;
paths[D_SYSDATA_IDX] = paths[D_USER_IDX] + SYSDATA_DIR DIR_SEP;
paths[D_SHADERCACHE_IDX] = paths[D_USER_IDX] + SHADERCACHE_DIR DIR_SEP;
paths[D_SHADERS_IDX] = paths[D_USER_IDX] + SHADERS_DIR DIR_SEP;
paths[D_STATESAVES_IDX] = paths[D_USER_IDX] + STATESAVES_DIR DIR_SEP;
paths[D_SCREENSHOTS_IDX] = paths[D_USER_IDX] + SCREENSHOTS_DIR DIR_SEP;
paths[D_DUMP_IDX] = paths[D_USER_IDX] + DUMP_DIR DIR_SEP;
paths[D_DUMPFRAMES_IDX] = paths[D_DUMP_IDX] + DUMP_FRAMES_DIR DIR_SEP;
paths[D_DUMPAUDIO_IDX] = paths[D_DUMP_IDX] + DUMP_AUDIO_DIR DIR_SEP;
paths[D_DUMPTEXTURES_IDX] = paths[D_DUMP_IDX] + DUMP_TEXTURES_DIR DIR_SEP;
paths[D_LOGS_IDX] = paths[D_USER_IDX] + LOGS_DIR DIR_SEP;
paths[F_DEBUGGERCONFIG_IDX] = paths[D_CONFIG_IDX] + DEBUGGER_CONFIG;
paths[F_LOGGERCONFIG_IDX] = paths[D_CONFIG_IDX] + LOGGER_CONFIG;
paths[F_MAINLOG_IDX] = paths[D_LOGS_IDX] + MAIN_LOG;
}
if (!newPath.empty())
{
if (!FileUtil::IsDirectory(newPath))
{
LOG_ERROR(Common_Filesystem, "Invalid path specified %s", newPath.c_str());
return paths[DirIDX];
}
else
{
paths[DirIDX] = newPath;
}
switch (DirIDX)
{
case D_ROOT_IDX:
paths[D_USER_IDX] = paths[D_ROOT_IDX] + DIR_SEP;
paths[D_SYSCONF_IDX] = paths[D_USER_IDX] + SYSCONF_DIR + DIR_SEP;
paths[F_SYSCONF_IDX] = paths[D_SYSCONF_IDX] + SYSCONF;
break;
case D_USER_IDX:
paths[D_USER_IDX] = paths[D_ROOT_IDX] + DIR_SEP;
paths[D_CONFIG_IDX] = paths[D_USER_IDX] + CONFIG_DIR DIR_SEP;
paths[D_GAMECONFIG_IDX] = paths[D_USER_IDX] + GAMECONFIG_DIR DIR_SEP;
paths[D_MAPS_IDX] = paths[D_USER_IDX] + MAPS_DIR DIR_SEP;
paths[D_CACHE_IDX] = paths[D_USER_IDX] + CACHE_DIR DIR_SEP;
paths[D_SDMC_IDX] = paths[D_USER_IDX] + SDMC_DIR DIR_SEP;
paths[D_NAND_IDX] = paths[D_USER_IDX] + NAND_DIR DIR_SEP;
paths[D_SHADERCACHE_IDX] = paths[D_USER_IDX] + SHADERCACHE_DIR DIR_SEP;
paths[D_SHADERS_IDX] = paths[D_USER_IDX] + SHADERS_DIR DIR_SEP;
paths[D_STATESAVES_IDX] = paths[D_USER_IDX] + STATESAVES_DIR DIR_SEP;
paths[D_SCREENSHOTS_IDX] = paths[D_USER_IDX] + SCREENSHOTS_DIR DIR_SEP;
paths[D_DUMP_IDX] = paths[D_USER_IDX] + DUMP_DIR DIR_SEP;
paths[D_DUMPFRAMES_IDX] = paths[D_DUMP_IDX] + DUMP_FRAMES_DIR DIR_SEP;
paths[D_DUMPAUDIO_IDX] = paths[D_DUMP_IDX] + DUMP_AUDIO_DIR DIR_SEP;
paths[D_DUMPTEXTURES_IDX] = paths[D_DUMP_IDX] + DUMP_TEXTURES_DIR DIR_SEP;
paths[D_LOGS_IDX] = paths[D_USER_IDX] + LOGS_DIR DIR_SEP;
paths[D_SYSCONF_IDX] = paths[D_USER_IDX] + SYSCONF_DIR DIR_SEP;
paths[F_EMUCONFIG_IDX] = paths[D_CONFIG_IDX] + EMU_CONFIG;
paths[F_DEBUGGERCONFIG_IDX] = paths[D_CONFIG_IDX] + DEBUGGER_CONFIG;
paths[F_LOGGERCONFIG_IDX] = paths[D_CONFIG_IDX] + LOGGER_CONFIG;
paths[F_MAINLOG_IDX] = paths[D_LOGS_IDX] + MAIN_LOG;
break;
case D_CONFIG_IDX:
paths[F_EMUCONFIG_IDX] = paths[D_CONFIG_IDX] + EMU_CONFIG;
paths[F_DEBUGGERCONFIG_IDX] = paths[D_CONFIG_IDX] + DEBUGGER_CONFIG;
paths[F_LOGGERCONFIG_IDX] = paths[D_CONFIG_IDX] + LOGGER_CONFIG;
break;
case D_DUMP_IDX:
paths[D_DUMPFRAMES_IDX] = paths[D_DUMP_IDX] + DUMP_FRAMES_DIR DIR_SEP;
paths[D_DUMPAUDIO_IDX] = paths[D_DUMP_IDX] + DUMP_AUDIO_DIR DIR_SEP;
paths[D_DUMPTEXTURES_IDX] = paths[D_DUMP_IDX] + DUMP_TEXTURES_DIR DIR_SEP;
break;
case D_LOGS_IDX:
paths[F_MAINLOG_IDX] = paths[D_LOGS_IDX] + MAIN_LOG;
}
}
return paths[DirIDX];
}
size_t WriteStringToFile(bool text_file, const std::string &str, const char *filename)
{
return FileUtil::IOFile(filename, text_file ? "w" : "wb").WriteBytes(str.data(), str.size());
}
size_t ReadFileToString(bool text_file, const char *filename, std::string &str)
{
IOFile file(filename, text_file ? "r" : "rb");
if (!file)
return false;
str.resize(static_cast<u32>(file.GetSize()));
return file.ReadArray(&str[0], str.size());
}
std::string strip_extension(const std::string& fname)
{
return fname.substr(0, fname.find_last_of('.'));
}
/// processes all 'driver' options in the XML file
void process_xml_options(const std::string& xml_fname)
{
// *************************************************************
// going to remove any path from the argument and change to that
// path; this is done so that all files referenced from the
// local path of the XML file are found
// *************************************************************
// set the filename to use as the argument, by default
std::string filename = xml_fname;
// get the current pathname
size_t BUFSIZE = 128;
boost::shared_array<char> cwd;
while (true)
{
cwd = boost::shared_array<char>((new char[BUFSIZE]));
if (getcwd(cwd.get(), BUFSIZE) == cwd.get())
break;
if (errno != ERANGE)
{
std::cerr << "process_xml_options() - unable to allocate sufficient memory!" << std::endl;
return;
}
BUFSIZE *= 2;
}
// separate the path from the filename
size_t last_path_sep = xml_fname.find_last_of('/');
if (last_path_sep != std::string::npos)
{
// get the new working path
std::string pathname = xml_fname.substr(0,last_path_sep+1);
// change to the new working path
chdir(pathname.c_str());
// get the new filename
filename = xml_fname.substr(last_path_sep+1,std::string::npos);
}
// read the XML Tree
shared_ptr<const XMLTree> driver_tree = XMLTree::read_from_xml(filename);
if (!driver_tree)
{
std::cerr << "process_xml_options() - unable to open file " << xml_fname;
std::cerr << " for reading" << std::endl;
chdir(cwd.get());
return;
}
// find the driver tree
driver_tree = find_subtree(driver_tree, "driver");
// make sure that the driver node was found
if (!driver_tree)
{
chdir(cwd.get());
return;
}
// process tags
process_tag("window", driver_tree, process_window_tag);
process_tag("camera", driver_tree, process_camera_tag);
// change back to current directory
chdir(cwd.get());
}
//OpenGL initialization function
void OnInit() {
//get the mesh path for loading of textures
std::string mesh_path = mesh_filename.substr(0, mesh_filename.find_last_of("/")+1);
//load the obj model
if(!obj.Load(mesh_filename.c_str(), meshes, vertices, indices, materials)) {
cout<<"Cannot load the 3ds mesh"<<endl;
exit(EXIT_FAILURE);
}
GL_CHECK_ERRORS
//load material textures
for(size_t k=0;k<materials.size();k++) {
//if the diffuse texture name is not empty
if(materials[k]->map_Kd != "") {
//generate a new OpenGL array texture
GLuint id = 0;
glGenTextures(1, &id);
glBindTexture(GL_TEXTURE_2D, id);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(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);
int texture_width = 0, texture_height = 0, channels=0;
const string& filename = materials[k]->map_Kd;
std::string full_filename = mesh_path;
full_filename.append(filename);
//use SOIL to load the texture
GLubyte* pData = SOIL_load_image(full_filename.c_str(), &texture_width, &texture_height, &channels, SOIL_LOAD_AUTO);
if(pData == NULL) {
cerr<<"Cannot load image: "<<full_filename.c_str()<<endl;
exit(EXIT_FAILURE);
}
//Flip the image on Y axis
int i,j;
for( j = 0; j*2 < texture_height; ++j )
{
int index1 = j * texture_width * channels;
int index2 = (texture_height - 1 - j) * texture_width * channels;
for( i = texture_width * channels; i > 0; --i )
{
GLubyte temp = pData[index1];
pData[index1] = pData[index2];
pData[index2] = temp;
++index1;
++index2;
}
}
//get the image format
GLenum format = GL_RGBA;
switch(channels) {
case 2: format = GL_RG32UI; break;
case 3: format = GL_RGB; break;
case 4: format = GL_RGBA; break;
}
//allocate texture
glTexImage2D(GL_TEXTURE_2D, 0, format, texture_width, texture_height, 0, format, GL_UNSIGNED_BYTE, pData);
//release the SOIL image data
SOIL_free_image_data(pData);
//add loaded texture ID to vector
textures.push_back(id);
}
}
GL_CHECK_ERRORS
//load flat shader
flatShader.LoadFromFile(GL_VERTEX_SHADER, "shaders/flat.vert");
flatShader.LoadFromFile(GL_FRAGMENT_SHADER, "shaders/flat.frag");
//compile and link shader
flatShader.CreateAndLinkProgram();
flatShader.Use();
//add attribute and uniform
flatShader.AddAttribute("vVertex");
flatShader.AddUniform("MVP");
flatShader.UnUse();
//load mesh rendering shader
shader.LoadFromFile(GL_VERTEX_SHADER, "shaders/shader.vert");
shader.LoadFromFile(GL_FRAGMENT_SHADER, "shaders/shader.frag");
//compile and link shader
shader.CreateAndLinkProgram();
shader.Use();
//add attribute and uniform
shader.AddAttribute("vVertex");
shader.AddAttribute("vNormal");
shader.AddAttribute("vUV");
shader.AddUniform("MV");
shader.AddUniform("N");
shader.AddUniform("P");
shader.AddUniform("textureMap");
shader.AddUniform("useDefault");
shader.AddUniform("light_position");
shader.AddUniform("diffuse_color");
//set values of constant uniforms as initialization
glUniform1i(shader("textureMap"), 0);
shader.UnUse();
GL_CHECK_ERRORS
//setup the vertex array object and vertex buffer object for the mesh
//geometry handling
glGenVertexArrays(1, &vaoID);
glGenBuffers(1, &vboVerticesID);
glGenBuffers(1, &vboIndicesID);
//here we are using interleaved attributes so we can just push data to one
//buffer object and then assign different atribute pointer to identofy the
//different attributes
glBindVertexArray(vaoID);
glBindBuffer (GL_ARRAY_BUFFER, vboVerticesID);
//pass mesh vertices
glBufferData (GL_ARRAY_BUFFER, sizeof(Vertex)*vertices.size(), &(vertices[0].pos.x), GL_STATIC_DRAW);
GL_CHECK_ERRORS
//enable vertex attribute array for vertex position
glEnableVertexAttribArray(shader["vVertex"]);
glVertexAttribPointer(shader["vVertex"], 3, GL_FLOAT, GL_FALSE,sizeof(Vertex),0);
GL_CHECK_ERRORS
//enable vertex attribute array for vertex normal
glEnableVertexAttribArray(shader["vNormal"]);
glVertexAttribPointer(shader["vNormal"], 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (const GLvoid*)(offsetof(Vertex, normal)) );
GL_CHECK_ERRORS
//enable vertex attribute array for vertex texture coordinates
glEnableVertexAttribArray(shader["vUV"]);
glVertexAttribPointer(shader["vUV"], 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (const GLvoid*)(offsetof(Vertex, uv)) );
GL_CHECK_ERRORS
//if we have a single material, it means the 3ds model contains one mesh
//we therefore load it into an element array buffer
if(materials.size()==1) {
//pass indices to the element array buffer if there is a single material
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vboIndicesID);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLushort)*indices.size(), &(indices[0]), GL_STATIC_DRAW);
}
GL_CHECK_ERRORS
glBindVertexArray(0);
//setup vao and vbo stuff for the light position crosshair
glm::vec3 crossHairVertices[6];
crossHairVertices[0] = glm::vec3(-0.5f,0,0);
crossHairVertices[1] = glm::vec3(0.5f,0,0);
crossHairVertices[2] = glm::vec3(0, -0.5f,0);
crossHairVertices[3] = glm::vec3(0, 0.5f,0);
crossHairVertices[4] = glm::vec3(0,0, -0.5f);
crossHairVertices[5] = glm::vec3(0,0, 0.5f);
//setup light gizmo vertex array and vertex buffer object IDs
glGenVertexArrays(1, &lightVAOID);
glGenBuffers(1, &lightVerticesVBO);
glBindVertexArray(lightVAOID);
glBindBuffer (GL_ARRAY_BUFFER, lightVerticesVBO);
//pass crosshair vertices to the buffer object
glBufferData (GL_ARRAY_BUFFER, sizeof(crossHairVertices), &(crossHairVertices[0].x), GL_STATIC_DRAW);
GL_CHECK_ERRORS
//enable vertex attribute array for vertex position
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0,0);
GL_CHECK_ERRORS
//use spherical coordinates to get the light position
lightPosOS.x = radius * cos(theta)*sin(phi);
lightPosOS.y = radius * cos(phi);
lightPosOS.z = radius * sin(theta)*sin(phi);
//enable depth test and culling
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
//set the background colour to corn blue
glClearColor(0.5,0.5,1,1);
cout<<"Initialization successfull"<<endl;
}
GLuint load_texture_from_file(std::string filename)
{
//define return variable
GLuint texture;
//strip extension
std::string extension;
int delimiter_index = filename.find_last_of('.');
//if a '.' was found
if (delimiter_index != std::string::npos)
{
//get extension substring
extension = filename.substr(delimiter_index + 1);
//convert to uppercase
std::transform(extension.begin(), extension.end(), extension.begin(), ::toupper);
//get c_string
const char* ext = extension.c_str();
//check filetype
if (strcmp(ext, "JPG") || strcmp(ext, "BMP") || strcmp(ext, "PNG"))
{
//make the texture
glGenTextures(1, &texture);
//bind the texture
glBindTexture(GL_TEXTURE_2D, texture);
//set our texture filtering
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
//set our texture parameters
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
//load .jpg using SOIL
int width, height;
unsigned char* image = SOIL_load_image(filename.c_str(), &width, &height, 0, SOIL_LOAD_RGB);
//generate the texture from image
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, image);
//generate mipmaps (openGL scaling objects)
glGenerateMipmap(GL_TEXTURE_2D);
//free the texture thing
glBindTexture(GL_TEXTURE_2D, 0);
if (texture == -1)
{
//THERE WAS AN ERROR - do something
}
else
return texture;
}
else
{
//disagree.
//throw an error? prompt the user? be displeased.
//(tell the user to check the input file type)
}
}
return texture;
}
void BasicOpenGLView::loadMaterial(std::string m_Material)
{
std::ifstream t(m_Material.c_str());
std::stringstream buffer;
buffer << t.rdbuf();
/**
* we assume file contents like this:
* vertex path/to/vertex/shader.vs
* fragment path/to/fragment/shader.fs
*
* with an optional
* texture path/to/texture.png
*
* paths are relative to the m_Material path
*/
if(mProgram)
{
delete mProgram;
mProgram = NULL;
}
if(mTextureHandle)
{
glDeleteTextures(1, & mTextureHandle);
mTextureHandle = 0;
}
std::string filePath = m_Material.substr(0, m_Material.find_last_of("/") + 1);
const std::string vertex("vertex");
const std::string fragment("fragment");
const std::string texture("texture");
const std::string bump("bumpmap");
const std::string alphatex("alphatex");
mProgram = new Program();
std::string line;
while(std::getline(buffer, line))
{
if(line.compare(0, vertex.size(), vertex) == 0)
{
std::string vertexPath = filePath + line.substr(vertex.size() + 1);
std::ifstream v(vertexPath.c_str());
std::stringstream vbuffer;
vbuffer << v.rdbuf();
Shader * vShader = new Shader(vbuffer.str(), Shader::VERTEX);
if(vShader->load())
{
mProgram->push_back(vShader);
}
}
else if(line.compare(0, fragment.size(), fragment) == 0)
{
std::string fragmentPath = filePath + line.substr(fragment.size() + 1);
std::ifstream f(fragmentPath.c_str());
std::stringstream fbuffer;
fbuffer << f.rdbuf();
Shader * fShader = new Shader(fbuffer.str(), Shader::FRAGMENT);
if(fShader->load())
{
mProgram->push_back(fShader);
}
}
else if(line.compare(0, texture.size(), texture) == 0)
{
std::string texturePath = filePath + line.substr(texture.size() + 1);
/**
* @todo assignment 3
* use the texturePath to load an image from disc, and transfer its data to
* OpenGL and store the OpenGL image handle in mTextureHandle
*/
QImage tex;
if (tex.load(texturePath.c_str())) {
QImage ogTex = QGLWidget::convertToGLFormat(tex);
// copy the texture to opengl
glGenTextures(1, &mTextureHandle);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, mTextureHandle);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, ogTex.width(), ogTex.height(), 0, GL_RGBA, GL_UNSIGNED_BYTE, tex.bits());
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
} else {
printf("Error finding texture\n");
}
}
else if(line.compare(0, bump.size(), bump) == 0)
{
std::string texturePath = filePath + line.substr(bump.size() + 1);
/**
* @todo assignment 3
* use the texturePath to load an image from disc, and transfer its data to
* OpenGL and store the OpenGL image handle in mBumpTextureHandle
*/
QImage tex;
if (tex.load(texturePath.c_str())) {
QImage ogTex = QGLWidget::convertToGLFormat(tex);
// copy the bumpmap to opengl
glGenTextures(1, &mBumpTextureHandle);
glBindTexture(GL_TEXTURE_2D, mBumpTextureHandle);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, ogTex.width(), ogTex.height(), 0, GL_RGBA, GL_UNSIGNED_BYTE, tex.bits());
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
} else {
printf("Error finding bumpmap\n");
}
}
else if(line.compare(0, alphatex.size(), alphatex) == 0)
{
std::string texturePath = filePath + line.substr(alphatex.size() + 1);
/**
* JB: add in alpha texture
*/
QImage tex;
if (tex.load(texturePath.c_str())) {
QImage ogTex = QGLWidget::convertToGLFormat(tex);
// copy the bumpmap to opengl
glGenTextures(1, &mAlphaTextureHandle);
glBindTexture(GL_TEXTURE_2D, mAlphaTextureHandle);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, ogTex.width(), ogTex.height(), 0, GL_RGBA, GL_UNSIGNED_BYTE, tex.bits());
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
} else {
printf("Error finding alpha texture\n");
printf(texturePath.c_str());
}
}
else
{
/**
* unknown file contents
*/
}
}
if(!mProgram->link())
{
delete mProgram;
mProgram = NULL;
}
}
// remove the extension from a filename
std::string
remove_extension(std::string const& filename)
{
std::string::size_type const n = filename.find_last_of('.');
return std::string(filename.begin(), filename.begin()+n);
}
/**
* @brief appDirPath : 获取 application 所在路径（不包含文件名称）
* @return : application 所在路径（不包含文件名称）
*/
J_EXTERN_C J_ATTR_EXPORT const char* appDirPath()
{
static std::string _path = "";
if (_path.empty()) {
#ifdef __unix__
std::stringstream ss;
ss << "/proc/" << getpid() << "/exe";
#endif
//
char buffer[J_PATH_MAX + 2];
unsigned int length = 0;
#ifdef _MSC_VER
length = (unsigned int)GetModuleFileNameA(NULL, buffer, J_PATH_MAX + 1);
#elif defined(__unix__)
length = (unsigned int)readlink(ss.str().c_str(), buffer, J_PATH_MAX);
#endif
//
if (length == 0) {
// error
} else if (length <= J_PATH_MAX) {
buffer[J_PATH_MAX + 1] = '\0';
_path = buffer;
} else {
// J_PATH_MAX sized buffer wasn't large enough to contain the full path, use heap
char *bufferNew = 0;
int i = 1;
size_t size;
do {
++i;
size = J_PATH_MAX * i;
bufferNew = reinterpret_cast<char *>(realloc(bufferNew, (size + 1) * sizeof(char)));
if (bufferNew) {
#ifdef _MSC_VER
length = (unsigned int)GetModuleFileNameA(NULL, buffer, J_PATH_MAX + 1);
#elif defined(__unix__)
length = (unsigned int)readlink(ss.str().c_str(), buffer, J_PATH_MAX);
#endif
}
} while (bufferNew && length == size);
if (bufferNew) {
*(bufferNew + size) = '\0';
}
_path = bufferNew;
free(bufferNew);
}
//
if (!_path.empty()) {
//
int index = _path.find_last_of('/');
if (index == -1) {
index = _path.find_last_of('\\');
}
if (index != -1) {
_path = _path.substr(0, index);
}
// replace '\\' with '/'
std::string::iterator iter = _path.begin();
for (; iter != _path.end(); ++iter) {
if (*iter == '\\') {
*iter = '/';
}
}
}
}
return _path.c_str();
}
U32 LLControlGroup::loadFromFile(const std::string& filename, bool set_default_values)
{
if(mIncludedFiles.find(filename) != mIncludedFiles.end())
return 0; //Already included this file.
mIncludedFiles.insert(filename);
std::string name;
LLSD settings;
LLSD control_map;
llifstream infile;
infile.open(filename);
if(!infile.is_open())
{
llwarns << "Cannot find file " << filename << " to load." << llendl;
return 0;
}
S32 ret = LLSDSerialize::fromXML(settings, infile);
if (ret <= 0)
{
infile.close();
llwarns << "Unable to open LLSD control file " << filename << ". Trying Legacy Method." << llendl;
return loadFromFileLegacy(filename, TRUE, TYPE_STRING);
}
U32 validitems = 0;
bool hidefromsettingseditor = false;
for(LLSD::map_const_iterator itr = settings.beginMap(); itr != settings.endMap(); ++itr)
{
bool persist = true;
name = (*itr).first;
control_map = (*itr).second;
if(name == "Include")
{
if(control_map.isArray())
{
#if LL_WINDOWS
size_t pos = filename.find_last_of("\\");
#else
size_t pos = filename.find_last_of("/");
#endif
if(pos!=std::string::npos)
{
const std::string dir = filename.substr(0,++pos);
for(LLSD::array_const_iterator array_itr = control_map.beginArray(); array_itr != control_map.endArray(); ++array_itr)
validitems+=loadFromFile(dir+(*array_itr).asString(),set_default_values);
}
}
continue;
}
if(control_map.has("Persist"))
{
persist = control_map["Persist"].asInteger();
}
// Sometimes we want to use the settings system to provide cheap persistence, but we
// don't want the settings themselves to be easily manipulated in the UI because
// doing so can cause support problems. So we have this option:
if(control_map.has("HideFromEditor"))
{
hidefromsettingseditor = control_map["HideFromEditor"].asInteger();
}
else
{
hidefromsettingseditor = false;
}
// If the control exists just set the value from the input file.
LLControlVariable* existing_control = getControl(name);
if(existing_control)
{
if(set_default_values)
{
// Override all previously set properties of this control.
// ... except for type. The types must match.
eControlType new_type = typeStringToEnum(control_map["Type"].asString());
if(existing_control->isType(new_type))
{
existing_control->setDefaultValue(control_map["Value"]);
existing_control->setPersist(persist);
existing_control->setHiddenFromSettingsEditor(hidefromsettingseditor);
existing_control->setComment(control_map["Comment"].asString());
}
else
{
llerrs << "Mismatched type of control variable '"
<< name << "' found while loading '"
<< filename << "'." << llendl;
}
}
else if(existing_control->isPersisted())
{
existing_control->setValue(control_map["Value"]);
}
// *NOTE: If not persisted and not setting defaults,
// the value should not get loaded.
}
else
{
bool IsCOA = control_map.has("IsCOA") && !!control_map["IsCOA"].asInteger();
declareControl(name,
typeStringToEnum(control_map["Type"].asString()),
control_map["Value"],
control_map["Comment"].asString(),
persist,
hidefromsettingseditor,
IsCOA
);
}
++validitems;
}
return validitems;
}
void ModelRenderer::LoadFromX(const std::string &path)
{
// X ファイル とテクスチャのロード
_mesh = Mesh::CreateFromX(path);
// マテリアル情報の取得
D3DXMATERIAL *materials = (D3DXMATERIAL*)(_mesh->GetMaterialBuffer()->GetBufferPointer());
// テクスチャのロード
TextureSP texture;
for(size_t i = 0; i < _mesh->GetMaterialNumber(); i++){
// 特定の部分でテクスチャが存在しない場合
if(NULL == materials[i].pTextureFilename){
texture = NULL;
_textures.push_back(texture);
D3DCOLORVALUE value = materials[i].MatD3D.Diffuse;
// マテリアルから色情報を取得
D3DXVECTOR4 color = D3DXVECTOR4(value.r, value.g, value.b, value.a);
_diffuseColors.push_back(color);
continue;
}
_diffuseColors.push_back(D3DXVECTOR4(0,0,0,0));
//---------------------------------------------------
// テクスチャのパスを自動的に生成
// ファイルパスの前部分を格納する
std::string texturePath;
// Xファイルのパスから必要部分だけ抜き出す
// "/" "\\"を検索しパスの区切りの最後の部分を検索する
// Xファイルとテクスチャは同じフォルダにあるとし、
// Xファイルのあるフォルダのパスまでを抜き取る
// パスの最後の"/"を検索
std::size_t index = path.find_last_of("/");
if(index != std::string::npos)
{
texturePath = path.substr(0, index + 1);
}
// 該当なしなら"\\"で再検索
else
{
index = path.find_last_of("\\");
if(index != std::string::npos)
{
// パスの区切りが"\\"のときは"\\"の部分をはずしかわりに"/"をつける
texturePath = path.substr(0, index);
texturePath += "/";
}
}
//------------------------------------------------------------------
// Xファイルに記述されているテクスチャのパスの最後の部分だけを抜き出し前部分に追加
std::string stringBuffer;
stringBuffer = materials[i].pTextureFilename;
// パスの最後の"/"を検索
index = stringBuffer.find_last_of("/");
if(index != std::string::npos)
{
std::string stringBuffer2;
stringBuffer2 = stringBuffer.substr(index + 1);
texturePath += stringBuffer2;
}
// 該当なしなら"\\"で再検索
else{
index = stringBuffer.find_last_of("\\");
if(index != std::string::npos)
{
std::string stringBuffer2;
stringBuffer2 = stringBuffer.substr(index + 1);
texturePath += stringBuffer2;
}
// 該当なしならそのまま追加
else{
texturePath += stringBuffer;
}
}
// 独自テクスチャクラスとして生成
texture = Texture::CreateFromFile(texturePath, D3DX_DEFAULT);
_textures.push_back(texture);
}
}
// ------------------------------------------------------------------------------------------------
// Imports the given file into the given scene structure.
void IFCImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler)
{
std::shared_ptr<IOStream> stream(pIOHandler->Open(pFile));
if (!stream) {
ThrowException("Could not open file for reading");
}
// if this is a ifczip file, decompress its contents first
if(GetExtension(pFile) == "ifczip") {
#ifndef ASSIMP_BUILD_NO_COMPRESSED_IFC
unzFile zip = unzOpen( pFile.c_str() );
if(zip == NULL) {
ThrowException("Could not open ifczip file for reading, unzip failed");
}
// chop 'zip' postfix
std::string fileName = pFile.substr(0,pFile.length() - 3);
std::string::size_type s = pFile.find_last_of('\\');
if(s == std::string::npos) {
s = pFile.find_last_of('/');
}
if(s != std::string::npos) {
fileName = fileName.substr(s+1);
}
// search file (same name as the IFCZIP except for the file extension) and place file pointer there
if(UNZ_OK == unzGoToFirstFile(zip)) {
do {
// get file size, etc.
unz_file_info fileInfo;
char filename[256];
unzGetCurrentFileInfo( zip , &fileInfo, filename, sizeof(filename), 0, 0, 0, 0 );
if (GetExtension(filename) != "ifc") {
continue;
}
uint8_t* buff = new uint8_t[fileInfo.uncompressed_size];
LogInfo("Decompressing IFCZIP file");
unzOpenCurrentFile(zip);
size_t total = 0;
int read = 0;
do {
int bufferSize = fileInfo.uncompressed_size < INT16_MAX ? fileInfo.uncompressed_size : INT16_MAX;
void* buffer = malloc(bufferSize);
read = unzReadCurrentFile(zip, buffer, bufferSize);
if (read > 0) {
memcpy((char*)buff + total, buffer, read);
total += read;
}
free(buffer);
} while (read > 0);
size_t filesize = fileInfo.uncompressed_size;
if (total == 0 || size_t(total) != filesize)
{
delete[] buff;
ThrowException("Failed to decompress IFC ZIP file");
}
unzCloseCurrentFile( zip );
stream.reset(new MemoryIOStream(buff,fileInfo.uncompressed_size,true));
break;
if (unzGoToNextFile(zip) == UNZ_END_OF_LIST_OF_FILE) {
ThrowException("Found no IFC file member in IFCZIP file (1)");
}
} while(true);
}
else {
ThrowException("Found no IFC file member in IFCZIP file (2)");
}
unzClose(zip);
#else
ThrowException("Could not open ifczip file for reading, assimp was built without ifczip support");
#endif
}
std::unique_ptr<STEP::DB> db(STEP::ReadFileHeader(stream));
const STEP::HeaderInfo& head = static_cast<const STEP::DB&>(*db).GetHeader();
if(!head.fileSchema.size() || head.fileSchema.substr(0,3) != "IFC") {
ThrowException("Unrecognized file schema: " + head.fileSchema);
}
if (!DefaultLogger::isNullLogger()) {
LogDebug("File schema is \'" + head.fileSchema + '\'');
if (head.timestamp.length()) {
LogDebug("Timestamp \'" + head.timestamp + '\'');
}
if (head.app.length()) {
LogDebug("Application/Exporter identline is \'" + head.app + '\'');
}
}
// obtain a copy of the machine-generated IFC scheme
::Assimp::STEP::EXPRESS::ConversionSchema schema;
Schema_2x3::GetSchema(schema);
// tell the reader which entity types to track with special care
static const char* const types_to_track[] = {
"ifcsite", "ifcbuilding", "ifcproject"
};
// tell the reader for which types we need to simulate STEPs reverse indices
static const char* const inverse_indices_to_track[] = {
"ifcrelcontainedinspatialstructure", "ifcrelaggregates", "ifcrelvoidselement", "ifcreldefinesbyproperties", "ifcpropertyset", "ifcstyleditem"
};
// feed the IFC schema into the reader and pre-parse all lines
STEP::ReadFile(*db, schema, types_to_track, inverse_indices_to_track);
const STEP::LazyObject* proj = db->GetObject("ifcproject");
if (!proj) {
ThrowException("missing IfcProject entity");
}
ConversionData conv(*db,proj->To<Schema_2x3::IfcProject>(),pScene,settings);
SetUnits(conv);
SetCoordinateSpace(conv);
ProcessSpatialStructures(conv);
MakeTreeRelative(conv);
// NOTE - this is a stress test for the importer, but it works only
// in a build with no entities disabled. See
// scripts/IFCImporter/CPPGenerator.py
// for more information.
#ifdef ASSIMP_IFC_TEST
db->EvaluateAll();
#endif
// do final data copying
if (conv.meshes.size()) {
pScene->mNumMeshes = static_cast<unsigned int>(conv.meshes.size());
pScene->mMeshes = new aiMesh*[pScene->mNumMeshes]();
std::copy(conv.meshes.begin(),conv.meshes.end(),pScene->mMeshes);
// needed to keep the d'tor from burning us
conv.meshes.clear();
}
if (conv.materials.size()) {
pScene->mNumMaterials = static_cast<unsigned int>(conv.materials.size());
pScene->mMaterials = new aiMaterial*[pScene->mNumMaterials]();
std::copy(conv.materials.begin(),conv.materials.end(),pScene->mMaterials);
// needed to keep the d'tor from burning us
conv.materials.clear();
}
// apply world coordinate system (which includes the scaling to convert to meters and a -90 degrees rotation around x)
aiMatrix4x4 scale, rot;
aiMatrix4x4::Scaling(static_cast<aiVector3D>(IfcVector3(conv.len_scale)),scale);
aiMatrix4x4::RotationX(-AI_MATH_HALF_PI_F,rot);
pScene->mRootNode->mTransformation = rot * scale * conv.wcs * pScene->mRootNode->mTransformation;
// this must be last because objects are evaluated lazily as we process them
if ( !DefaultLogger::isNullLogger() ){
LogDebug((Formatter::format(),"STEP: evaluated ",db->GetEvaluatedObjectCount()," object records"));
}
}
void MEDITIO::write_ascii (const std::string & fname,
const std::vector<Number> * vec,
const std::vector<std::string> * solution_names)
{
// Current lacks in implementation:
// (i) only 3D meshes.
// (ii) only QUAD4, TRI3, TET4 elements, others are omitted !
// (iii) no distinction between materials.
// (iv) no vector output, just first scalar as output
// libmesh_assert three dimensions (should be extended later)
libmesh_assert_equal_to (MeshOutput<MeshBase>::mesh().mesh_dimension(), 3);
// Open the output file stream
std::ofstream out_stream (fname.c_str());
// Make sure it opened correctly
if (!out_stream.good())
libmesh_file_error(fname.c_str());
// Get a reference to the mesh
const MeshBase & the_mesh = MeshOutput<MeshBase>::mesh();
// Begin interfacing with the MEdit data file
{
// header:
out_stream << "MeshVersionFormatted 1\n";
out_stream << "Dimension 3\n";
out_stream << "# Mesh generated by libmesh\n\n";
// write the nodes:
out_stream << "# Set of mesh vertices\n";
out_stream << "Vertices\n";
out_stream << the_mesh.n_nodes() << "\n";
for (unsigned int v=0; v<the_mesh.n_nodes(); v++)
out_stream << the_mesh.point(v)(0) << " " << the_mesh.point(v)(1) << " " << the_mesh.point(v)(2) << " 0\n";
}
{
// write the connectivity:
out_stream << "\n# Set of Polys\n\n";
// count occurrences of output elements:
int n_tri3 = 0;
int n_quad4 = 0;
int n_tet4 = 0;
{
MeshBase::const_element_iterator it = the_mesh.active_elements_begin();
const MeshBase::const_element_iterator end = the_mesh.active_elements_end();
for ( ; it != end; ++it)
{
if ((*it)->type() == TRI3) n_tri3++;
if ((*it)->type() == QUAD4) n_quad4++;
if ((*it)->type() == QUAD9) n_quad4+=4; // (QUAD9 is written as 4 QUAD4.)
if ((*it)->type() == TET4) n_tet4++;
} // for
}
// First: write out TRI3 elements:
out_stream << "Triangles\n";
out_stream << n_tri3 << "\n";
{
MeshBase::const_element_iterator it = the_mesh.active_elements_begin();
const MeshBase::const_element_iterator end = the_mesh.active_elements_end();
for ( ; it != end; ++it)
if ((*it)->type() == TRI3)
out_stream << (*it)->node_id(0)+1 << " "
<< (*it)->node_id(1)+1 << " "
<< (*it)->node_id(2)+1 << " 0\n";
}
// Second: write out QUAD4 elements:
out_stream << "Quadrilaterals\n";
out_stream << n_quad4 << "\n";
{
MeshBase::const_element_iterator it = the_mesh.active_elements_begin();
const MeshBase::const_element_iterator end = the_mesh.active_elements_end();
for ( ; it != end; ++it)
if ((*it)->type() == QUAD4)
{
out_stream << (*it)->node_id(0)+1 << " "
<< (*it)->node_id(1)+1 << " "
<< (*it)->node_id(2)+1 << " "
<< (*it)->node_id(3)+1 <<" 0\n";
} // if
else if ((*it)->type() == QUAD9)
{
out_stream << (*it)->node_id(0)+1 << " "
<< (*it)->node_id(4)+1 << " "
<< (*it)->node_id(8)+1 << " "
<< (*it)->node_id(7)+1 <<" 0\n";
out_stream << (*it)->node_id(7)+1 << " "
<< (*it)->node_id(8)+1 << " "
<< (*it)->node_id(6)+1 << " "
<< (*it)->node_id(3)+1 <<" 0\n";
out_stream << (*it)->node_id(4)+1 << " "
<< (*it)->node_id(1)+1 << " "
<< (*it)->node_id(5)+1 << " "
<< (*it)->node_id(8)+1 <<" 0\n";
out_stream << (*it)->node_id(8)+1 << " "
<< (*it)->node_id(5)+1 << " "
<< (*it)->node_id(2)+1 << " "
<< (*it)->node_id(6)+1 <<" 0\n";
} // if
}
// Third: write out TET4 elements:
out_stream << "Tetrahedra\n";
out_stream << n_tet4 << "\n";
{
MeshBase::const_element_iterator it = the_mesh.active_elements_begin();
const MeshBase::const_element_iterator end = the_mesh.active_elements_end();
for ( ; it != end; ++it)
if ((*it)->type() == TET4)
{
out_stream << (*it)->node_id(0)+1 << " "
<< (*it)->node_id(1)+1 << " "
<< (*it)->node_id(2)+1 << " "
<< (*it)->node_id(3)+1 <<" 0\n";
} // if
}
}
// end of the out file
out_stream << '\n' << "# end of file\n";
// optionally write the data
if ((solution_names != libmesh_nullptr) &&
(vec != libmesh_nullptr))
{
// Open the ".bb" file stream
std::size_t idx = fname.find_last_of(".");
std::string bbname = fname.substr(0,idx) + ".bb";
std::ofstream bbout (bbname.c_str());
// Make sure it opened correctly
if (!bbout.good())
libmesh_file_error(bbname.c_str());
// Header: 3: 3D mesh, 1: scalar output, 2: node-indexed
const std::size_t n_vars = solution_names->size();
bbout << "3 1 " << the_mesh.n_nodes() << " 2\n";
for (dof_id_type n=0; n<the_mesh.n_nodes(); n++)
bbout << std::setprecision(10) << (*vec)[n*n_vars + scalar_idx] << " ";
bbout << "\n";
} // endif
}
void Map::saveOtbm(const std::string& fileName)
{
try {
FileStreamPtr fin = g_resources.createFile(fileName);
if(!fin)
stdext::throw_exception(stdext::format("failed to open file '%s' for write", fileName));
fin->cache();
std::string dir;
if(fileName.find_last_of('/') == std::string::npos)
dir = g_resources.getWorkDir();
else
dir = fileName.substr(0, fileName.find_last_of('/'));
uint32 version = 0;
if(g_things.getOtbMajorVersion() < ClientVersion820)
version = 1;
else
version = 2;
/// Usually when a map has empty house/spawn file it means the map is new.
/// TODO: Ask the user for a map name instead of those ugly uses of substr
std::string::size_type sep_pos;
std::string houseFile = getHouseFile();
std::string spawnFile = getSpawnFile();
std::string cpyf;
if((sep_pos = fileName.rfind('.')) != std::string::npos && stdext::ends_with(fileName, ".otbm"))
cpyf = fileName.substr(0, sep_pos);
if(houseFile.empty())
houseFile = cpyf + "-houses.xml";
if(spawnFile.empty())
spawnFile = cpyf + "-spawns.xml";
/// we only need the filename to save to, the directory should be resolved by the OTBM loader not here
if((sep_pos = spawnFile.rfind('/')) != std::string::npos)
spawnFile = spawnFile.substr(sep_pos + 1);
if((sep_pos = houseFile.rfind('/')) != std::string::npos)
houseFile = houseFile.substr(sep_pos + 1);
fin->addU32(0); // file version
OutputBinaryTreePtr root(new OutputBinaryTree(fin));
{
root->addU32(version);
Size mapSize = getSize();
root->addU16(mapSize.width());
root->addU16(mapSize.height());
root->addU32(g_things.getOtbMajorVersion());
root->addU32(g_things.getOtbMinorVersion());
root->startNode(OTBM_MAP_DATA);
{
root->addU8(OTBM_ATTR_DESCRIPTION);
root->addString(m_attribs.get<std::string>(OTBM_ATTR_DESCRIPTION));
root->addU8(OTBM_ATTR_SPAWN_FILE);
root->addString(spawnFile);
root->addU8(OTBM_ATTR_HOUSE_FILE);
root->addString(houseFile);
int px = -1, py = -1, pz =-1;
bool firstNode = true;
for(uint8_t z = 0; z <= Otc::MAX_Z; ++z) {
for(const auto& it : m_tileBlocks[z]) {
const TileBlock& block = it.second;
for(const TilePtr& tile : block.getTiles()) {
if(unlikely(!tile || tile->isEmpty()))
continue;
const Position& pos = tile->getPosition();
if(unlikely(!pos.isValid()))
continue;
if(pos.x < px || pos.x >= px + 256
|| pos.y < py || pos.y >= py + 256
|| pos.z != pz) {
if(!firstNode)
root->endNode(); /// OTBM_TILE_AREA
firstNode = false;
root->startNode(OTBM_TILE_AREA);
px = pos.x & 0xFF00;
py = pos.y & 0xFF00;
pz = pos.z;
root->addPos(px, py, pz);
}
root->startNode(tile->isHouseTile() ? OTBM_HOUSETILE : OTBM_TILE);
root->addPoint(Point(pos.x, pos.y) & 0xFF);
if(tile->isHouseTile())
root->addU32(tile->getHouseId());
if(tile->getFlags()) {
root->addU8(OTBM_ATTR_TILE_FLAGS);
root->addU32(tile->getFlags());
}
const auto& itemList = tile->getItems();
const ItemPtr& ground = tile->getGround();
if(ground) {
// Those types are called "complex" needs other stuff to be written.
// For containers, there is container items, for depot, depot it and so on.
if(!ground->isContainer() && !ground->isDepot()
&& !ground->isDoor() && !ground->isTeleport()) {
root->addU8(OTBM_ATTR_ITEM);
root->addU16(ground->getServerId());
} else
ground->serializeItem(root);
}
for(const ItemPtr& item : itemList)
if(!item->isGround())
item->serializeItem(root);
root->endNode(); // OTBM_TILE
}
}
}
if(!firstNode)
root->endNode(); // OTBM_TILE_AREA
root->startNode(OTBM_TOWNS);
for(const TownPtr& town : g_towns.getTowns()) {
root->startNode(OTBM_TOWN);
root->addU32(town->getId());
root->addString(town->getName());
Position townPos = town->getPos();
root->addPos(townPos.x, townPos.y, townPos.z);
root->endNode();
}
root->endNode();
if(version > 1) {
root->startNode(OTBM_WAYPOINTS);
for(const auto& it : m_waypoints) {
root->startNode(OTBM_WAYPOINT);
root->addString(it.second);
Position pos = it.first;
root->addPos(pos.x, pos.y, pos.z);
root->endNode();
}
root->endNode();
}
}
root->endNode(); // OTBM_MAP_DATA
}
root->endNode();
fin->flush();
fin->close();
} catch(std::exception& e) {
g_logger.error(stdext::format("Failed to save '%s': %s", fileName, e.what()));
}
}
bool Maker::SearchImplicitRules(const std::string &goal, const std::string &preferredPath, bool outerMost, bool err, Time &timeval)
{
std::list<RuleList *>matchedRules;
size_t n = goal.find_last_of(CmdFiles::DIR_SEP);
std::string dir;
std::string name;
if (n != std::string::npos)
{
dir = goal.substr(0, n+1);
name = goal.substr(n+1);
}
else
{
name = goal;
}
bool nonMatchAnything = false;
for (RuleContainer::ImplicitIterator it = RuleContainer::Instance()->ImplicitBegin();
it != RuleContainer::Instance()->ImplicitEnd(); ++it)
{
if ((*it)->GetTarget().find_first_of(CmdFiles::DIR_SEP) != std::string::npos)
{
size_t start;
n = Eval::MatchesPattern(goal, (*it)->GetTarget(), start);
if (n == goal.size())
{
matchedRules.push_back(*it);
if ((*it)->GetTarget() != "%")
nonMatchAnything = true;
}
}
else
{
size_t start;
n = Eval::MatchesPattern(name, (*it)->GetTarget(), start);
if (n == name.size())
{
matchedRules.push_back(*it);
if ((*it)->GetTarget() != "%")
nonMatchAnything = true;
}
}
}
if (nonMatchAnything)
{
for (std::list<RuleList *>::iterator it = matchedRules.begin();
it != matchedRules.end();)
{
std::list<RuleList *>::iterator it1 = it;
++it;
if ((*it1)->GetTarget() == "%")
if (!(*it1)->GetDoubleColon())
matchedRules.erase(it1);
}
}
for (std::list<RuleList *>::iterator it = matchedRules.begin();
it != matchedRules.end();)
{
std::list<RuleList *>::iterator it1 = it;
++it;
if (!(*it1)->HasCommands())
matchedRules.erase(it1);
}
for (std::list<RuleList *>::iterator it = matchedRules.begin();
it != matchedRules.end(); ++it)
{
std::string stem = Eval::FindStem(goal, (*it)->GetTarget());
if (ExistsOrMentioned(stem, *it, preferredPath, dir, false, outerMost))
return true;
}
// no matches so far, dig into indirections...
for (std::list<RuleList *>::iterator it = matchedRules.begin();
it != matchedRules.end(); ++it)
{
if ((*it)->GetTarget() != "%" || !(*it)->GetDoubleColon())
{
std::string stem = Eval::FindStem(goal, (*it)->GetTarget());
if (ExistsOrMentioned(stem, *it, preferredPath, dir, true, outerMost))
return true;
}
}
RuleList *dflt = RuleContainer::Instance()->Lookup(".DEFAULT");
if (dflt)
{
// have a default, enter it
EnterDefaultRule(goal, dflt);
return true;
}
if (outerMost && err)
{
std::set<std::string>::iterator it = ignoreFailedTargets.find(goal);
if (it == ignoreFailedTargets.end())
{
Time time;
GetFileTime(goal, preferredPath, time);
if (!time)
{
missingTarget = true;
Eval::error("No rule to make target '" + goal + "'");
}
else if (time > timeval)
timeval = time;
}
}
return false;
}
void DICOMSegmentationIO::Write()
{
ValidateOutputLocation();
mitk::LocaleSwitch localeSwitch("C");
LocalFile localFile(this);
const std::string path = localFile.GetFileName();
auto input = dynamic_cast<const LabelSetImage *>(this->GetInput());
if (input == nullptr)
mitkThrow() << "Cannot write non-image data";
// Get DICOM information from referenced image
vector<DcmDataset *> dcmDatasets;
DcmFileFormat *readFileFormat = new DcmFileFormat();
try
{
// TODO: Generate dcmdataset witk DICOM tags from property list; ATM the source are the filepaths from the
// property list
mitk::StringLookupTableProperty::Pointer filesProp =
dynamic_cast<mitk::StringLookupTableProperty *>(input->GetProperty("files").GetPointer());
if (filesProp.IsNull())
{
mitkThrow() << "No property with dicom file path.";
return;
}
StringLookupTable filesLut = filesProp->GetValue();
const StringLookupTable::LookupTableType &lookUpTableMap = filesLut.GetLookupTable();
for (auto it : lookUpTableMap)
{
const char *fileName = (it.second).c_str();
if (readFileFormat->loadFile(fileName, EXS_Unknown).good())
dcmDatasets.push_back(readFileFormat->getAndRemoveDataset());
}
}
catch (const std::exception &e)
{
MITK_ERROR << "An error occurred while getting the dicom informations: " << e.what() << endl;
return;
}
// Iterate over all layers. For each a dcm file will be generated
for (unsigned int layer = 0; layer < input->GetNumberOfLayers(); ++layer)
{
vector<itkInternalImageType::Pointer> segmentations;
try
{
// Cast mitk layer image to itk
ImageToItk<itkInputImageType>::Pointer imageToItkFilter = ImageToItk<itkInputImageType>::New();
// BUG: It must be the layer image, but there are some errors with it (dcmqi: generate the dcmSeg "No frame data
// available") --> input->GetLayerImage(layer)
imageToItkFilter->SetInput(input);
imageToItkFilter->Update();
// Cast from original itk type to dcmqi input itk image type
typedef itk::CastImageFilter<itkInputImageType, itkInternalImageType> castItkImageFilterType;
castItkImageFilterType::Pointer castFilter = castItkImageFilterType::New();
castFilter->SetInput(imageToItkFilter->GetOutput());
castFilter->Update();
itkInternalImageType::Pointer itkLabelImage = castFilter->GetOutput();
itkLabelImage->DisconnectPipeline();
// Iterate over all labels. For each a segmentation image will be created
const LabelSet *labelSet = input->GetLabelSet(layer);
for (auto itLabel = labelSet->IteratorConstBegin(); itLabel != labelSet->IteratorConstEnd(); ++itLabel)
{
// Thresold over the image with the given label value
itk::ThresholdImageFilter<itkInternalImageType>::Pointer thresholdFilter =
itk::ThresholdImageFilter<itkInternalImageType>::New();
thresholdFilter->SetInput(itkLabelImage);
thresholdFilter->ThresholdOutside(itLabel->first, itLabel->first);
thresholdFilter->SetOutsideValue(0);
thresholdFilter->Update();
itkInternalImageType::Pointer segmentImage = thresholdFilter->GetOutput();
segmentImage->DisconnectPipeline();
segmentations.push_back(segmentImage);
}
}
catch (const itk::ExceptionObject &e)
{
MITK_ERROR << e.GetDescription() << endl;
return;
}
// Create segmentation meta information
const std::string &tmpMetaInfoFile = this->CreateMetaDataJsonFile(layer);
MITK_INFO << "Writing image: " << path << std::endl;
try
{
// Convert itk segmentation images to dicom image
dcmqi::ImageSEGConverter *converter = new dcmqi::ImageSEGConverter();
DcmDataset *result = converter->itkimage2dcmSegmentation(dcmDatasets, segmentations, tmpMetaInfoFile);
// Write dicom file
DcmFileFormat dcmFileFormat(result);
std::string filePath = path.substr(0, path.find_last_of("."));
// If there is more than one layer, we have to write more than 1 dicom file
if (input->GetNumberOfLayers() != 1)
filePath = filePath + std::to_string(layer) + ".dcm";
else
filePath = filePath + ".dcm";
dcmFileFormat.saveFile(filePath.c_str(), EXS_LittleEndianExplicit);
// Clean up
if (converter != nullptr)
delete converter;
if (result != nullptr)
delete result;
}
catch (const std::exception &e)
{
MITK_ERROR << "An error occurred during writing the DICOM Seg: " << e.what() << endl;
return;
}
} // Write a dcm file for the next layer
// End of image writing; clean up
if (readFileFormat)
delete readFileFormat;
for (auto obj : dcmDatasets)
delete obj;
dcmDatasets.clear();
}
void Font::Load( std::string file )
{
assert( !m_Initialized );
std::string TexName = file.substr( file.find_last_of( '/' ) + 1, file.find_last_of( '.' ) );// +".png";
TexName = TexName.substr( TexName.find_last_of( '\\' ) + 1, TexName.find_last_of( '.' ) ) +".png";
m_Tex = Object_Factory<Texture>::Instance().GetAsset( TexName );
assert( m_Tex != nullptr );
std::ifstream Data;
Data.open( file, std::ios::in | std::ios::binary );
assert( Data.is_open() );
Data.seekg( 0, std::ios::beg );
short buffer[256]; ///memory to read into
char* buff = (char*)buffer;
Data.read( buff, 512 );
assert( !Data.fail() );
Data.close();
for ( int i = 0; i < 256; ++i )
{
m_Widths[i] = (int)buffer[i];
}
m_Shader = Object_Factory<GLSLProgram>::Instance().GetAsset( "font_default.glslp" );
assert( m_Shader != nullptr );
uint32_t& Tex_width = m_Tex->width;
uint32_t& Tex_height = m_Tex->height;
m_vStride = 5 * sizeof( float );
m_vCount = 4 * 256;
m_Vertices = new float[m_vCount * 5];
//Textures are assumed to have 16 characters per line
for ( int loop = 0; loop<256; loop++ )
{
float cx = ( (float)( loop % 16 ) ) / 16.0f; /// X Position Of Current Character
float cy = ( (float)( loop / 16 ) ) / 16.0f; /// Y Position Of Current Character
m_Vertices[( loop * 20 )] = 0;
m_Vertices[1 + ( loop * 20 )] = 0; /// Vertex Coord (Bottom Left)
m_Vertices[2 + ( loop * 20 )] = 0;
m_Vertices[3 + ( loop * 20 )] = cx;
m_Vertices[4 + ( loop * 20 )] = 1 - ( cy + 1.f / 16 ); /// Texture Coord (Bottom Left)
m_Vertices[5 + ( loop * 20 )] = 1;
m_Vertices[6 + ( loop * 20 )] = 0; /// Vertex Coord (Bottom Right)
m_Vertices[7 + ( loop * 20 )] = 0;
m_Vertices[8 + ( loop * 20 )] = cx + ( 1.f / 16 );
m_Vertices[9 + ( loop * 20 )] = 1 - ( cy + 1.f / 16 ); /// Texture Coord (Bottom Right)
m_Vertices[10 + ( loop * 20 )] = 1;
m_Vertices[11 + ( loop * 20 )] = 1; /// Vertex Coord (Top Right)
m_Vertices[12 + ( loop * 20 )] = 0;
m_Vertices[13 + ( loop * 20 )] = cx + ( 1.f / 16 );
m_Vertices[14 + ( loop * 20 )] = 1 - cy; /// Texture Coord (Top Right)
m_Vertices[15 + ( loop * 20 )] = 0;
m_Vertices[16 + ( loop * 20 )] = 1; /// Vertex Coord (Top Left)
m_Vertices[17 + ( loop * 20 )] = 0;
m_Vertices[18 + ( loop * 20 )] = cx;
m_Vertices[19 + ( loop * 20 )] = 1 - cy; /// Texture Coord (Top Left)
}
Init();
}
bool WorkerCPU::init(const std::string& videoStream)
{
learningRate = std::stof(cfg.value("LearningRate", "MogParameters"));
const int nmixtures = std::stoi(cfg.value("NumMixtures", "MogParameters"));
if(nmixtures <= 0)
{
std::cerr << "Parameter NumMixtures is wrong, must be more than 0\n";
return false;
}
// Inicjalizuj frame grabbera
#if defined(SAPERA_SUPPORT)
// Sprawdz suffix videoStream (.ccf)
size_t pos = videoStream.find_last_of(".ccf");
if(pos+1 == videoStream.length())
{
grabber = std::unique_ptr<FrameGrabber>(new SaperaFrameGrabber());
}
else
#endif
{
grabber = std::unique_ptr<FrameGrabber>(new OpenCvFrameGrabber());
}
if(!grabber->init(videoStream))
return false;
dstFrame = cv::Mat(grabber->frameHeight(), grabber->frameWidth(), CV_8UC1);
// Pobierz dane o formacie ramki
int width = grabber->frameWidth();
int height = grabber->frameHeight();
int channels = grabber->frameNumChannels();
mog = cv::BackgroundSubtractorMOG(200, nmixtures,
std::stof(cfg.value("BackgroundRatio", "MogParameters")));
mog.initialize(cv::Size(height, width), CV_8UC1);
std::cout << "\n frame width: " << width <<
"\n frame height: " << height <<
"\n num channels: " << channels << "x" << grabber->framePixelDepth() << " bits \n";
//inputFrameSize = width * height * channels * sizeof(cl_uchar);
if(channels == 3)
{
std::cout << " preprocessing frame: grayscalling\n";
preprocess = 1;
}
else if(channels == 1 && grabber->needBayer())
{
std::string bayerCfg = cfg.value("Bayer", "General");
if(bayerCfg == "RG") bayer = Bayer_RG;
else if(bayerCfg == "BG") bayer = Bayer_BG;
else if(bayerCfg == "GR") bayer = Bayer_GR;
else if(bayerCfg == "GB") bayer = Bayer_GB;
else
{
std::cerr << "Unknown 'Bayer' parameter (must be RG, BG, GR or GB)";
return false;
}
std::cout << " preprocessing frame: bayer " << bayerCfg << "\n";
preprocess = 2;
}
else
{
std::cout << " preprocessing frame: none (already monochrome format)\n";
preprocess = 0;
}
showIntermediateFrame = cfg.value("ShowIntermediateFrame", "General") == "yes";
if(showIntermediateFrame)
interFrame = cv::Mat(height, width, CV_8UC1);
return true;
}
ImageTypex::Pointer Image_Convert_Base::GetITKPointer(std::string file_name)
{
std::string file_suffix;
//get file name suffix
if (file_name.empty())
{
std::cout<<"input a file name first!"<<std::endl;
return NULL;
}
else
{
std::size_t pos = file_name.find_last_of(".");
file_suffix = file_name.substr(pos);
}
if (file_suffix == ".nii")
{
//nifti io
//typedef itk::NiftiImageIO NiftiIOType;
NiftiIOType::Pointer niftiIO =
NiftiIOType::New();
//itk read nii file
//typedef itk::Image<float, 3> ImageType;
//typedef itk::ImageSeriesReader< ImageType > ReaderType;
ReaderType_Convert::Pointer reader = ReaderType_Convert::New();
reader->SetImageIO(niftiIO);
reader->SetFileName(file_name);
try
{
reader->Update();
}
catch (itk::ExceptionObject& e)
{
std::cout<<"read nii error"<<std::endl;
std::cerr<<e;
}
//-------add --------//
itk::OrientImageFilter<ImageTypex,ImageTypex>::Pointer orientor =
itk::OrientImageFilter<ImageTypex,ImageTypex>::New();
orientor->UseImageDirectionOn();
orientor->SetDesiredCoordinateOrientation(itk::SpatialOrientation::ITK_COORDINATE_ORIENTATION_RAI);
orientor->SetInput(reader->GetOutput());
try
{
orientor->Update();
}
catch (itk::ExceptionObject& e)
{
std::cout<<"orientai ror"<<std::endl;
std::cerr<<e;
return NULL;
}
return orientor->GetOutput();
}
else
{
return NULL;
}
}
bool ImportedModel::initMaterials2(const aiScene* pScene, const std::string& Filename)
{
// Extract the directory part from the file name
std::string::size_type SlashIndex = Filename.find_last_of("/");
std::string Dir;
if (SlashIndex == std::string::npos)
Dir = ".";
else if (SlashIndex == 0)
Dir = "/";
else
Dir = Filename.substr(0, SlashIndex);
bool Ret = true;
string fullPath;
// Initialize the materials
for (unsigned int i = 0 ; i < pScene->mNumMaterials ; i++)
{
const aiMaterial* pMaterial = pScene->mMaterials[i];
bool success = false;
/*
utl::debug("i", i);
utl::debug("aiTextureType_NONE", pMaterial->GetTextureCount(aiTextureType_NONE));
utl::debug("aiTextureType_DIFFUSE", pMaterial->GetTextureCount(aiTextureType_DIFFUSE));
utl::debug("aiTextureType_SPECULAR", pMaterial->GetTextureCount(aiTextureType_SPECULAR));
utl::debug("aiTextureType_AMBIENT", pMaterial->GetTextureCount(aiTextureType_AMBIENT));
utl::debug("aiTextureType_EMISSIVE", pMaterial->GetTextureCount(aiTextureType_EMISSIVE));
utl::debug("aiTextureType_NORMALS", pMaterial->GetTextureCount(aiTextureType_NORMALS));
utl::debug("aiTextureType_DIFFUSE", pMaterial->GetTextureCount(aiTextureType_DIFFUSE));
utl::debug("aiTextureType_UNKNOWN", pMaterial->GetTextureCount(aiTextureType_UNKNOWN));
*/
/// we're only intersted in teh diffuse texture
if (pMaterial->GetTextureCount(aiTextureType_DIFFUSE) > 0)
{
aiString path;
if (pMaterial->GetTexture(aiTextureType_DIFFUSE, 0, &path, NULL, NULL, NULL, NULL, NULL) == AI_SUCCESS)
{
fullPath = Dir + "/" + path.data;
// utl::debug("fullPath", fullPath);
m_textures[i].m_id = utl::loadTexture(fullPath);
success = true;
}
}
// utl::debug(fullPath, m_textures[i].m_id);
// if (!success)
// m_textures[i].m_id = utl::loadTexture("Assets/models/weapons/Ak_47/ak-47.jpg");
// m_textures[i].m_id = utl::loadTexture("Assets/models/weapons/M9/Tex_0009_1.jpg");
// utl::debugLn("final: " + fullPath, m_textures[i].m_id);
}
return Ret;
}
US_BEGIN_NAMESPACE
std::vector<std::string> AutoLoadModulesFromPath(const std::string& absoluteBasePath, const std::string& subDir)
{
std::vector<std::string> loadedModules;
std::string loadPath = absoluteBasePath + DIR_SEP + subDir;
DIR* dir = opendir(loadPath.c_str());
#ifdef CMAKE_INTDIR
// Try intermediate output directories
if (dir == NULL)
{
std::size_t indexOfLastSeparator = absoluteBasePath.find_last_of(DIR_SEP);
if (indexOfLastSeparator != std::string::npos)
{
std::string intermediateDir = absoluteBasePath.substr(indexOfLastSeparator+1);
bool equalSubDir = intermediateDir.size() == std::strlen(CMAKE_INTDIR);
for (std::size_t i = 0; equalSubDir && i < intermediateDir.size(); ++i)
{
if (std::tolower(intermediateDir[i]) != std::tolower(CMAKE_INTDIR[i]))
{
equalSubDir = false;
}
}
if (equalSubDir)
{
loadPath = absoluteBasePath.substr(0, indexOfLastSeparator+1) + subDir + DIR_SEP + CMAKE_INTDIR;
dir = opendir(loadPath.c_str());
}
}
}
#endif
if (dir != NULL)
{
struct dirent *ent = NULL;
while ((ent = readdir(dir)) != NULL)
{
bool loadFile = true;
#ifdef _DIRENT_HAVE_D_TYPE
if (ent->d_type != DT_UNKNOWN && ent->d_type != DT_REG)
{
loadFile = false;
}
#endif
std::string entryFileName(ent->d_name);
// On Linux, library file names can have version numbers appended. On other platforms, we
// check the file ending. This could be refined for Linux in the future.
#if !defined(US_PLATFORM_LINUX)
if (entryFileName.rfind(library_suffix()) != (entryFileName.size() - library_suffix().size()))
{
loadFile = false;
}
#endif
if (!loadFile) continue;
std::string libPath = loadPath;
if (!libPath.empty() && libPath.find_last_of(DIR_SEP) != libPath.size() -1)
{
libPath += DIR_SEP;
}
libPath += entryFileName;
US_DEBUG << "Auto-loading module " << libPath;
if (!load_impl(libPath))
{
US_WARN << "Auto-loading of module " << libPath << " failed.";
}
else
{
loadedModules.push_back(libPath);
}
}
closedir(dir);
}
return loadedModules;
}
bool run_matlab_command(::std::string const& cmd,
ArgsT const& args,
ConsumerT& consumer)
{
int pipefd[2];
// Create a pipe to let to communicate with MATLAB.
// Specifically, we want to read the output from MATLAB.
// So, the parent process read from the pipe, while the child process
// write on it.
if (::pipe(pipefd) == -1)
{
char const* err_str = ::strerror(errno);
::std::ostringstream oss;
oss << "[dcs::des::cloud::detail::matlab::run_matlab_command] pipe(2) failed: "
<< ::std::string(err_str);
throw ::std::runtime_error(oss.str());
}
// // Install signal handlers
// struct ::sigaction sig_act;
// struct ::sigaction old_sigterm_act;
// struct ::sigaction old_sigint_act;
// //::memset(&sig_act, 0, sizeof(sig_act));
// ::sigemptyset(&sig_act.sa_mask);
// sig_act.sa_flags = 0;
// sig_act.sa_handler = self_type::process_signals;
// ::sigaction(SIGTERM, &sig_act, &old_sigterm_act);
// ::sigaction(SIGINT, &sig_act, &old_sigint_act);
// Spawn a new process
// Between fork() and execve() only async-signal-safe functions
// must be called if multithreaded applications should be supported.
// That's why the following code is executed before fork() is called.
::pid_t pid = ::fork();
// check: pid == -1 --> error
if (pid == -1)
{
char const* err_str = ::strerror(errno);
::std::ostringstream oss;
oss << "[dcs::des::cloud::detail::matlab::run_matlab_command] fork(2) failed: "
<< ::std::string(err_str);
throw ::std::runtime_error(oss.str());
}
if (pid == 0)
{
// The child
// // Cancel signal handler set for parent
// sig_act.sa_handler = SIG_DFL;
// ::sigaction(SIGTERM, &sig_act, 0);
// ::sigaction(SIGINT, &sig_act, 0);
// Get the maximum number of files this process is allowed to open
#if defined(F_MAXFD)
int maxdescs = ::fcntl(-1, F_MAXFD, 0);
if (maxdescs == -1)
{
#if defined(_SC_OPEN_MAX)
maxdescs = ::sysconf(_SC_OPEN_MAX);
#else
::rlimit limit;
if (::getrlimit(RLIMIT_NOFILE, &limit) < 0)
{
char const* err_str = ::strerror(errno);
::std::ostringstream oss;
oss << "[dcs::des::cloud::detail::matlab::run_matlab_command] getrlimit(2) failed: "
<< ::std::string(err_str);
throw ::std::runtime_error(oss.str());
}
maxdescs = limit.rlim_cur;
#endif // _SC_OPEN_MAX
}
#else // F_MAXFD
#if defined(_SC_OPEN_MAX)
int maxdescs = ::sysconf(_SC_OPEN_MAX);
#else // _SC_OPEN_MAX
::rlimit limit;
if (::getrlimit(RLIMIT_NOFILE, &limit) < 0)
{
char const* err_str = ::strerror(errno);
::std::ostringstream oss;
oss << "[dcs::des::cloud::detail::matlab::run_matlab_command] getrlimit(2) failed: "
<< ::std::string(err_str);
throw ::std::runtime_error(oss.str());
}
maxdescs = limit.rlim_cur;
#endif // _SC_OPEN_MAX
#endif // F_MAXFD
if (maxdescs == -1)
{
maxdescs = 1024;
}
::std::vector<bool> close_fd(maxdescs, true);
// Associate the child's stdout to the pipe write fd.
close_fd[STDOUT_FILENO] = false;
if (pipefd[1] != STDOUT_FILENO)
{
if (::dup2(pipefd[1], STDOUT_FILENO) != STDOUT_FILENO)
{
char const* err_str = ::strerror(errno);
::std::ostringstream oss;
oss << "[dcs::des::cloud::detail::matlab::run_matlab_command] dup2(2) failed: "
<< ::std::string(err_str);
throw ::std::runtime_error(oss.str());
}
}
else
{
close_fd[pipefd[1]] = false;
}
// ::close(STDOUT_FILENO);
// ::dup(pipefd[1]);
// Check if the command already has path information
::std::string cmd_path;
::std::string cmd_name;
typename ::std::string::size_type pos;
pos = cmd.find_last_of('/');
if (pos != ::std::string::npos)
{
cmd_path = cmd.substr(0, pos);
cmd_name = cmd.substr(pos+1);
}
//FIXME: use scoped_ptr in place of "new"
::std::size_t nargs = args.size()+1;
char** argv = new char*[nargs + 2];
argv[0] = new char[cmd_name.size()+1];
::std::strncpy(argv[0], cmd_name.c_str(), cmd_name.size()+1); // by convention, the first argument is always the command name
typename ArgsT::size_type i(1);
typename ArgsT::const_iterator end_it(args.end());
for (typename ArgsT::const_iterator it = args.begin(); it != end_it; ++it)
{
argv[i] = new char[it->size()+1];
::std::strncpy(argv[i], it->c_str(), it->size()+1);
++i;
}
argv[nargs] = 0;
//char** envp(0);
// Close unused file descriptors
#ifdef DCS_DEBUG
// Keep standard error open for debug
close_fd[STDERR_FILENO] = false;
#endif // DCS_DEBUG
for (int fd = 0; fd < maxdescs; ++fd)
{
if (close_fd[fd])
{
::close(fd);
}
}
//[XXX]
#ifdef DCS_DEBUG
::std::cerr << "Executing MATLAB: " << cmd;//XXX
for (::std::size_t i=0; i < args.size(); ++i)//XXX
{//XXX
::std::cerr << " " << args[i] << ::std::flush;//XXX
}//XXX
::std::cerr << ::std::endl;//XXX
#endif // DCS_DEBUG
//[/XXX]
//DCS_DEBUG_TRACE("Executing: " << cmd << " " << args[0] << " " << args[1] << " " << args[2] << " - " << args[3]);
//::execve(cmd.c_str(), argv, envp);
::execvp(cmd.c_str(), argv);
// Actually we should delete argv and envp data. As we must not
// call any non-async-signal-safe functions though we simply exit.
::write(STDERR_FILENO, "execvp() failed\n", 17);
//_exit(EXIT_FAILURE);
_exit(127);
}
// The parent
// // Associate the parent's stdin to the pipe read fd.
::close(pipefd[1]);
// ::close(STDIN_FILENO);
// ::dup(pipefd[0]);
if (pipefd[0] != STDIN_FILENO)
{
if (::dup2(pipefd[0], STDIN_FILENO) != STDIN_FILENO)
{
char const* err_str = ::strerror(errno);
::std::ostringstream oss;
oss << "[dcs::des::cloud::detail::matlab::run_matlab_command] dup2(2) failed: "
<< ::std::string(err_str);
throw ::std::runtime_error(oss.str());
}
::close(pipefd[0]);
}
typedef ::boost::iostreams::file_descriptor_source fd_device_type;
typedef ::boost::iostreams::stream_buffer<fd_device_type> fd_streambuf_type;
//fd_device_type fd_src(pipefd[0], ::boost::iostreams::close_handle);
fd_device_type fd_src(STDIN_FILENO, ::boost::iostreams::close_handle);
fd_streambuf_type fd_buf(fd_src);
::std::istream is(&fd_buf);
consumer(is);
DCS_DEBUG_TRACE("END parsing MATLAB output");//XXX
DCS_DEBUG_TRACE("IS state: " << is.good() << " - " << is.eof() << " - " << is.fail() << " - " << is.bad());//XXX
// Wait the child termination (in order to prevent zombies)
int status;
// ::pid_t wait_pid;
// wait_pid = ::wait(&status);
// if (wait_pid != pid)
// {
// throw ::std::runtime_error("[dcs::des::cloud::detail::rls_miso_matlab_app_proxy::run_matlab] Unexpected child process.");
// }
if (::waitpid(pid, &status, 0) == -1)
{
char const* err_str = ::strerror(errno);
::std::ostringstream oss;
oss << "[dcs::des::cloud::detail::matlab::run_matlab_command] waitpid(2) failed: "
<< ::std::string(err_str);
throw ::std::runtime_error(oss.str());
}
DCS_DEBUG_TRACE("MATLAB exited");//XXX
bool ok(true);
if (WIFEXITED(status))
{
DCS_DEBUG_TRACE("MATLAB exited with a call to 'exit(" << WEXITSTATUS(status) << ")'");//XXX
if (WEXITSTATUS(status))
{
// status != 0 --> error in the execution
::std::clog << "[Warning] MATLAB command exited with status " << WEXITSTATUS(status) << ::std::endl;
ok = false;
}
}
else if (WIFSIGNALED(status))
{
DCS_DEBUG_TRACE("MATLAB exited with a call to 'kill(" << WTERMSIG(status) << ")'");//XXX
::std::clog << "[Warning] MATLAB command received signal " << WTERMSIG(status) << ::std::endl;
ok = false;
}
else
{
DCS_DEBUG_TRACE("MATLAB exited with an unexpected way");//XXX
ok = false;
}
// // Restore signal handler
// ::sigaction(SIGTERM, &old_sigterm_act, 0);
// ::sigaction(SIGINT, &old_sigint_act, 0);
return ok;
}
void ResourceListBuilder::BuildPakResourceList(const std::string &pakfilename)
{
// open the pak file in binary read mode
File pakfile(pakfilename, "rb");
if (pakfile == NULL)
{
// error opening pakfile!
printf("Could not find pakfile \"%s\".\n", pakfilename.c_str());
return;
}
// Check a pakfile for resources
// get the header
size_t pakheadersize = sizeof(pakheader_s);
pakheader_s pakheader;
size_t retval = fread(&pakheader, 1, pakheadersize, pakfile);
if (retval != pakheadersize)
{
// unexpected size.
if (verbal)
{
printf("Reading pakfile header failed. Wrong size (" SIZE_T_SPECIFIER " read, " SIZE_T_SPECIFIER " expected).\n", retval, pakheadersize);
printf("Is \"%s\" a valid pakfile?\n", pakfilename.c_str());
}
return;
}
// verify pak identity
if (pakheader.pakid != 1262698832)
{
if (verbal)
{
printf("Pakfile \"%s\" does not appear to be a Half-Life pakfile (ID mismatch).\n", pakfilename.c_str());
}
return;
}
// count the number of files in the pak
size_t fileinfosize = sizeof(fileinfo_s);
size_t filecount = pakheader.dirsize / fileinfosize;
// re-verify integrity of header
if (pakheader.dirsize % fileinfosize != 0 || filecount == 0)
{
if (verbal)
{
printf("Pakfile \"%s\" does not appear to be a Half-Life pakfile (invalid dirsize).\n", pakfilename.c_str());
}
return;
}
// load file list to memory
if(fseek(pakfile, pakheader.diroffset, SEEK_SET))
{
if (verbal)
{
printf("Error seeking for file list.\nPakfile \"%s\" is not a pakfile, or is corrupted.\n", pakfilename.c_str());
}
return;
}
std::vector<fileinfo_s> filelist(filecount);
retval = fread(filelist.data(), 1, pakheader.dirsize, pakfile);
if (retval != pakheader.dirsize)
{
if (verbal)
{
printf("Error seeking for file list.\nPakfile \"%s\" is not a pakfile, or is corrupted.\n", pakfilename.c_str());
}
return;
}
if (verbal)
{
printf("Scanning pak file \"%s\" for resources (" SIZE_T_SPECIFIER " files in pak)\n", pakfilename.c_str(), filecount);
}
// Read filelist for possible resources
for (size_t i = 0; i < filecount; i++)
{
const std::string fileLower = strToLowerCopy(filelist[i].name);
const size_t dotIndex = fileLower.find_last_of('.');
if(dotIndex != std::string::npos)
{
const std::string extension = fileLower.substr(dotIndex + 1);
if (
extension == "mdl" ||
extension == "wav" ||
extension == "spr" ||
extension == "bmp" ||
extension == "tga" ||
extension == "txt" ||
extension == "wad"
)
{
// resource, add to list
std::string resStr = replaceCharAllCopy(filelist[i].name, '\\', '/');
resources[strToLowerCopy(resStr)] = resStr;
if (resourcedisp)
{
printf("Added \"%s\" to resource list\n", resStr.c_str());
}
}
}
}
}
GLhandleARB LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shader_level, GLenum type, std::map<std::string, std::string>* defines, S32 texture_index_channels)
{
std::pair<std::multimap<std::string, CachedObjectInfo >::iterator, std::multimap<std::string, CachedObjectInfo>::iterator> range;
range = mShaderObjects.equal_range(filename);
for (std::multimap<std::string, CachedObjectInfo>::iterator it = range.first; it != range.second;++it)
{
if((*it).second.mLevel == shader_level && (*it).second.mType == type && (*it).second.mDefinitions == (defines ? *defines : std::map<std::string, std::string>()))
{
//LL_INFOS("ShaderLoading") << "Loading cached shader for " << filename << LL_ENDL;
return (*it).second.mHandle;
}
}
GLenum error = GL_NO_ERROR;
if (gDebugGL)
{
error = glGetError();
if (error != GL_NO_ERROR)
{
LL_WARNS("ShaderLoading") << "GL ERROR entering loadShaderFile(): " << error << LL_ENDL;
}
}
LL_DEBUGS("ShaderLoading") << "Loading shader file: " << filename << " class " << shader_level << LL_ENDL;
if (filename.empty())
{
return 0;
}
//read in from file
LLFILE* file = NULL;
S32 try_gpu_class = shader_level;
S32 gpu_class;
//find the most relevant file
for (gpu_class = try_gpu_class; gpu_class > 0; gpu_class--)
{ //search from the current gpu class down to class 1 to find the most relevant shader
std::stringstream fname;
fname << getShaderDirPrefix();
fname << gpu_class << "/" << filename;
LL_DEBUGS("ShaderLoading") << "Looking in " << fname.str() << LL_ENDL;
file = LLFile::fopen(fname.str(), "r"); /* Flawfinder: ignore */
if (file)
{
//LL_INFOS("ShaderLoading") << "Loading file: shaders/class" << gpu_class << "/" << filename << " (Want class " << gpu_class << ")" << LL_ENDL;
break; // done
}
}
if (file == NULL)
{
LL_WARNS("ShaderLoading") << "GLSL Shader file not found: " << filename << LL_ENDL;
return 0;
}
//we can't have any lines longer than 1024 characters
//or any shaders longer than 4096 lines... deal - DaveP
GLcharARB buff[1024];
GLcharARB* text[4096];
GLuint count = 0;
S32 major_version = gGLManager.mGLSLVersionMajor;
S32 minor_version = gGLManager.mGLSLVersionMinor;
if (major_version == 1 && minor_version < 30)
{
if (minor_version < 10)
{
//should NEVER get here -- if major version is 1 and minor version is less than 10,
// viewer should never attempt to use shaders, continuing will result in undefined behavior
LL_ERRS() << "Unsupported GLSL Version." << LL_ENDL;
}
if (minor_version <= 19)
{
text[count++] = strdup("#version 110\n");
text[count++] = strdup("#define ATTRIBUTE attribute\n");
text[count++] = strdup("#define VARYING varying\n");
text[count++] = strdup("#define VARYING_FLAT varying\n");
// Need to enable extensions here instead of in the shader files,
// before any non-preprocessor directives (per spec)
text[count++] = strdup("#extension GL_ARB_texture_rectangle : enable\n");
text[count++] = strdup("#extension GL_ARB_shader_texture_lod : enable\n");
}
else if (minor_version <= 29)
{
//set version to 1.20
text[count++] = strdup("#version 120\n");
text[count++] = strdup("#define FXAA_GLSL_120 1\n");
text[count++] = strdup("#define FXAA_FAST_PIXEL_OFFSET 0\n");
text[count++] = strdup("#define ATTRIBUTE attribute\n");
text[count++] = strdup("#define VARYING varying\n");
text[count++] = strdup("#define VARYING_FLAT varying\n");
// Need to enable extensions here instead of in the shader files,
// before any non-preprocessor directives (per spec)
text[count++] = strdup("#extension GL_ARB_texture_rectangle : enable\n");
text[count++] = strdup("#extension GL_ARB_shader_texture_lod : enable\n");
}
}
else
{
if (major_version < 4)
{
//set version to 1.30
text[count++] = strdup("#version 130\n");
// Need to enable extensions here instead of in the shader files,
// before any non-preprocessor directives (per spec)
text[count++] = strdup("#extension GL_ARB_texture_rectangle : enable\n");
text[count++] = strdup("#extension GL_ARB_shader_texture_lod : enable\n");
//some implementations of GLSL 1.30 require integer precision be explicitly declared
text[count++] = strdup("precision mediump int;\n");
text[count++] = strdup("precision highp float;\n");
}
else
{ //set version to 400
text[count++] = strdup("#version 400\n");
// Need to enable extensions here instead of in the shader files,
// before any non-preprocessor directives (per spec)
text[count++] = strdup("#extension GL_ARB_texture_rectangle : enable\n");
text[count++] = strdup("#extension GL_ARB_shader_texture_lod : enable\n");
}
text[count++] = strdup("#define DEFINE_GL_FRAGCOLOR 1\n");
text[count++] = strdup("#define FXAA_GLSL_130 1\n");
text[count++] = strdup("#define ATTRIBUTE in\n");
if (type == GL_VERTEX_SHADER_ARB)
{ //"varying" state is "out" in a vertex program, "in" in a fragment program
// ("varying" is deprecated after version 1.20)
text[count++] = strdup("#define VARYING out\n");
text[count++] = strdup("#define VARYING_FLAT flat out\n");
}
else
{
text[count++] = strdup("#define VARYING in\n");
text[count++] = strdup("#define VARYING_FLAT flat in\n");
}
//backwards compatibility with legacy texture lookup syntax
text[count++] = strdup("#define texture2D texture\n");
text[count++] = strdup("#define textureCube texture\n");
text[count++] = strdup("#define texture2DLod textureLod\n");
text[count++] = strdup("#define shadow2D(a,b) vec2(texture(a,b))\n");
if (major_version > 1 || minor_version >= 40)
{ //GLSL 1.40 replaces texture2DRect et al with texture
text[count++] = strdup("#define texture2DRect texture\n");
text[count++] = strdup("#define shadow2DRect(a,b) vec2(texture(a,b))\n");
}
}
if(defines)
{
for (std::map<std::string,std::string>::iterator iter = defines->begin(); iter != defines->end(); ++iter)
{
std::string define = "#define " + iter->first + " " + iter->second + "\n";
text[count++] = (GLcharARB *) strdup(define.c_str());
}
}
if (texture_index_channels > 0 && type == GL_FRAGMENT_SHADER_ARB)
{
//use specified number of texture channels for indexed texture rendering
/* prepend shader code that looks like this:
uniform sampler2D tex0;
uniform sampler2D tex1;
uniform sampler2D tex2;
.
.
.
uniform sampler2D texN;
VARYING_FLAT ivec4 vary_texture_index;
vec4 ret = vec4(1,0,1,1);
vec4 diffuseLookup(vec2 texcoord)
{
switch (vary_texture_index.r))
{
case 0: ret = texture2D(tex0, texcoord); break;
case 1: ret = texture2D(tex1, texcoord); break;
case 2: ret = texture2D(tex2, texcoord); break;
.
.
.
case N: return texture2D(texN, texcoord); break;
}
return ret;
}
*/
text[count++] = strdup("#define HAS_DIFFUSE_LOOKUP 1\n");
//uniform declartion
for (S32 i = 0; i < texture_index_channels; ++i)
{
std::string decl = llformat("uniform sampler2D tex%d;\n", i);
text[count++] = strdup(decl.c_str());
}
if (texture_index_channels > 1)
{
text[count++] = strdup("VARYING_FLAT ivec4 vary_texture_index;\n");
}
text[count++] = strdup("vec4 diffuseLookup(vec2 texcoord)\n");
text[count++] = strdup("{\n");
if (texture_index_channels == 1)
{ //don't use flow control, that's silly
text[count++] = strdup("return texture2D(tex0, texcoord);\n");
text[count++] = strdup("}\n");
}
else if (major_version > 1 || minor_version >= 30)
{ //switches are supported in GLSL 1.30 and later
if (gGLManager.mIsNVIDIA || (gGLManager.mIsATI && gGLManager.mGLVersion < 3.3f))
{ //switches are unreliable on old drivers
for (S32 i = 0; i < texture_index_channels; ++i)
{
std::string if_string = llformat("\t%sif (vary_texture_index.r == %d) { return texture2D(tex%d, texcoord); }\n", i > 0 ? "else " : "", i, i);
text[count++] = strdup(if_string.c_str());
}
text[count++] = strdup("\treturn vec4(1,0,1,1);\n");
text[count++] = strdup("}\n");
}
else
{
text[count++] = strdup("\tvec4 ret = vec4(1,0,1,1);\n");
text[count++] = strdup("\tswitch (vary_texture_index.r)\n");
text[count++] = strdup("\t{\n");
//switch body
for (S32 i = 0; i < texture_index_channels; ++i)
{
std::string case_str = llformat("\t\tcase %d: ret = texture2D(tex%d, texcoord); break;\n", i, i);
text[count++] = strdup(case_str.c_str());
}
text[count++] = strdup("\t}\n");
text[count++] = strdup("\treturn ret;\n");
text[count++] = strdup("}\n");
}
}
else
{ //should never get here. Indexed texture rendering requires GLSL 1.30 or later
// (for passing integers between vertex and fragment shaders)
LL_ERRS() << "Indexed texture rendering requires GLSL 1.30 or later." << LL_ENDL;
}
}
else
{
text[count++] = strdup("#define HAS_DIFFUSE_LOOKUP 0\n");
}
//copy file into memory
while( fgets((char *)buff, 1024, file) != NULL && count < LL_ARRAY_SIZE(text) )
{
text[count++] = (GLcharARB *)strdup((char *)buff);
}
fclose(file);
//create shader object
GLhandleARB ret = glCreateShaderObjectARB(type);
if (gDebugGL)
{
error = glGetError();
if (error != GL_NO_ERROR)
{
LL_WARNS("ShaderLoading") << "GL ERROR in glCreateShaderObjectARB: " << error << LL_ENDL;
glDeleteObjectARB(ret); //no longer need handle
ret=0;
}
}
//load source
if(ret)
{
glShaderSourceARB(ret, count, (const GLcharARB**) text, NULL);
if (gDebugGL)
{
error = glGetError();
if (error != GL_NO_ERROR)
{
LL_WARNS("ShaderLoading") << "GL ERROR in glShaderSourceARB: " << error << LL_ENDL;
glDeleteObjectARB(ret); //no longer need handle
ret=0;
}
}
}
//compile source
if(ret)
{
glCompileShaderARB(ret);
if (gDebugGL)
{
error = glGetError();
if (error != GL_NO_ERROR)
{
LL_WARNS("ShaderLoading") << "GL ERROR in glCompileShaderARB: " << error << LL_ENDL;
glDeleteObjectARB(ret); //no longer need handle
ret=0;
}
}
}
std::string error_str;
if (error == GL_NO_ERROR)
{
//check for errors
GLint success = GL_TRUE;
glGetObjectParameterivARB(ret, GL_OBJECT_COMPILE_STATUS_ARB, &success);
if (gDebugGL || success == GL_FALSE)
{
error = glGetError();
if (error != GL_NO_ERROR || success == GL_FALSE)
{
//an error occured, print log
LL_WARNS("ShaderLoading") << "GLSL Compilation Error: (" << error << ") in " << filename << LL_ENDL;
dumpObjectLog(ret);
error_str = get_object_log(ret);
#if LL_WINDOWS
std::stringstream ostr;
//dump shader source for debugging
for (GLuint i = 0; i < count; i++)
{
ostr << i << ": " << text[i];
if (i % 128 == 0)
{ //dump every 128 lines
LL_WARNS("ShaderLoading") << "\n" << ostr.str() << LL_ENDL;
ostr = std::stringstream();
}
}
LL_WARNS("ShaderLoading") << "\n" << ostr.str() << LL_ENDL;
#else
std::string str;
for (GLuint i = 0; i < count; i++) {
str.append(text[i]);
if (i % 128 == 0)
{
LL_WARNS("ShaderLoading") << str << LL_ENDL;
str = "";
}
}
#endif
glDeleteObjectARB(ret); //no longer need handle
ret = 0;
}
}
if(ret)
dumpObjectLog(ret,false);
}
static const LLCachedControl<bool> dump_raw_shaders("ShyotlDumpRawShaders",false);
if(dump_raw_shaders || !ret)
{
std::stringstream ostr;
for (GLuint i = 0; i < count; i++)
{
ostr << text[i];
}
std::string delim = gDirUtilp->getDirDelimiter();
std::string shader_name = filename.substr(filename.find_last_of("/")+1); //shader_name.glsl
shader_name = shader_name.substr(0,shader_name.find_last_of(".")); //shader_name
std::string maindir = gDirUtilp->getExpandedFilename(LL_PATH_LOGS,"shader_dump"+delim);
//mkdir is NOT recursive. Step through the folders one by one.
LLFile::mkdir(maindir); //..Roaming/SecondLife/logs/shader_dump/
LLFile::mkdir(maindir+="class" + llformat("%i",gpu_class) + delim); //..shader_dump/class1/
LLFile::mkdir(maindir+=filename.substr(0,filename.find_last_of("/")+1)); //..shader_dump/class1/windlight/
LLAPRFile file(maindir + shader_name + (ret ? "" : llformat("_FAILED(%i)",error)) + ".glsl", LL_APR_W);
file.write(ostr.str().c_str(),ostr.str().length());
if(!error_str.empty())
{
LLAPRFile file2(maindir + shader_name + "_ERROR.txt", LL_APR_W);
file2.write(error_str.c_str(),error_str.length());
}
}
stop_glerror();
//free memory
for (GLuint i = 0; i < count; i++)
{
free(text[i]);
}
//successfully loaded, save results
if (ret)
{
// Add shader file to map
mShaderObjects.insert(make_pair(filename,CachedObjectInfo(ret,try_gpu_class,type,defines)));
shader_level = try_gpu_class;
}
else
{
if (shader_level > 1)
{
shader_level--;
return loadShaderFile(filename,shader_level,type, defines, texture_index_channels);
}
LL_WARNS("ShaderLoading") << "Failed to load " << filename << LL_ENDL;
}
return ret;
}
// Win 32 DIR parser
void ResourceListBuilder::ListDir(const std::string &path, const std::string &filepath, bool reporterror)
{
WIN32_FIND_DATA filedata;
// add *.* for searching all files.
std::string searchdir = path + filepath + "*.*";
// find first file
HANDLE filehandle = FindFirstFile(searchdir.c_str(), &filedata);
if (filehandle == INVALID_HANDLE_VALUE)
{
if (firstdir && reporterror)
{
if (GetLastError() & ERROR_PATH_NOT_FOUND || GetLastError() & ERROR_FILE_NOT_FOUND)
{
printf("The directory you specified (%s) can not be found or is empty.\n", path.c_str());
}
else
{
printf("There was an error with the directory you specified (%s) - ERROR NO: %lu.\n", path.c_str(), GetLastError());
}
}
return;
}
firstdir = false;
do
{
std::string file = filepath + filedata.cFileName;
// Check for directory
if (filedata.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
{
// Look for files in subdir, but ignore . and ..
if (strcmp(filedata.cFileName, ".") && strcmp(filedata.cFileName, ".."))
{
// Call this function recursive
ListDir(path, file + PATH_SEPARATOR, reporterror);
}
}
else
{
const std::string fileLower = strToLowerCopy(file);
const size_t dotIndex = fileLower.find_last_of('.');
if(dotIndex != std::string::npos)
{
const std::string extension = fileLower.substr(dotIndex + 1);
if (
extension == "mdl" ||
extension == "wav" ||
extension == "spr" ||
extension == "bmp" ||
extension == "tga" ||
extension == "txt" ||
extension == "wad"
)
{
// resource, add to list
replaceCharAll(file, '\\', '/'); // replace backslashes
resources[strToLowerCopy(file)] = file;
if (resourcedisp)
{
printf("Added \"%s\" to resource list\n", file.c_str());
}
}
if ((extension == "pad") && pakparse)
{
// get pakfilelist
BuildPakResourceList(path + file);
}
}
}
} while (FindNextFile(filehandle, &filedata));
// Close search
FindClose(filehandle);
}
void showHistogram2d(TH2* histogram,
const std::string& xAxisTitle, const std::string& yAxisTitle,
int zAxisNormOption, double zMin, double zMax,
Float_t* genX, Float_t* genY,
const std::string& outputFileName)
{
TCanvas* canvas = new TCanvas("canvas", "canvas", 900, 800);
canvas->SetFillColor(10);
canvas->SetBorderSize(2);
canvas->SetTopMargin(0.10);
canvas->SetLeftMargin(0.12);
canvas->SetRightMargin(0.14);
canvas->SetBottomMargin(0.12);
histogram->SetTitle("");
histogram->SetStats(false);
int numBinsX = histogram->GetNbinsX();
int numBinsY = histogram->GetNbinsY();
if ( zAxisNormOption == kNormByQuantiles ) {
std::vector<double> binContents;
for ( int iBinX = 1; iBinX <= numBinsX; ++iBinX ) {
for ( int iBinY = 1; iBinY <= numBinsY; ++iBinY ) {
binContents.push_back(histogram->GetBinContent(iBinX, iBinY));
}
}
std::sort(binContents.begin(), binContents.end());
histogram->SetMinimum(binContents[TMath::Nint(0.05*binContents.size())]);
histogram->SetMaximum(binContents[TMath::Nint(0.95*binContents.size())]);
} else if ( zAxisNormOption == kNormByNegLogMax ) {
double maxBinContent = 0.;
for ( int iBinX = 1; iBinX <= numBinsX; ++iBinX ) {
for ( int iBinY = 1; iBinY <= numBinsY; ++iBinY ) {
double binContent = histogram->GetBinContent(iBinX, iBinY);
if ( binContent > maxBinContent ) {
std::cout << "binX = " << iBinX << " (x = " << histogram->GetXaxis()->GetBinCenter(iBinX) << "),"
<< " binY = " << iBinY << " (y = " << histogram->GetYaxis()->GetBinCenter(iBinY) << "): maxBinContent = " << maxBinContent << std::endl;
maxBinContent = binContent;
}
}
}
double logMaxBinContent = TMath::Log(maxBinContent);
for ( int iBinX = 1; iBinX <= numBinsX; ++iBinX ) {
for ( int iBinY = 1; iBinY <= numBinsY; ++iBinY ) {
double binContent = histogram->GetBinContent(iBinX, iBinY);
if ( binContent > 0. ) {
histogram->SetBinContent(iBinX, iBinY, -TMath::Log(binContent) + logMaxBinContent);
} else {
histogram->SetBinContent(iBinX, iBinY, -1.);
}
}
}
histogram->SetMinimum(0.);
histogram->SetMaximum(zMax);
} else if ( zAxisNormOption == kNormByValue ) {
histogram->SetMinimum(zMin);
histogram->SetMaximum(zMax);
} else assert(0);
TAxis* xAxis = histogram->GetXaxis();
xAxis->SetTitle(xAxisTitle.data());
xAxis->SetTitleOffset(1.15);
TAxis* yAxis = histogram->GetYaxis();
yAxis->SetTitle(yAxisTitle.data());
yAxis->SetTitleOffset(1.30);
gStyle->SetPalette(1,0);
histogram->Draw("COLZ");
TMarker* genMarker = 0;
if ( genX && genY ) {
genMarker = new TMarker(*genX, *genY, 34);
genMarker->SetMarkerColor(1);
genMarker->SetMarkerSize(2);
genMarker->Draw();
}
canvas->Update();
size_t idx = outputFileName.find_last_of('.');
std::string outputFileName_plot = std::string(outputFileName, 0, idx);
if ( idx != std::string::npos ) canvas->Print(std::string(outputFileName_plot).append(std::string(outputFileName, idx)).data());
canvas->Print(std::string(outputFileName_plot).append(".png").data());
canvas->Print(std::string(outputFileName_plot).append(".pdf").data());
canvas->Print(std::string(outputFileName_plot).append(".root").data());
delete genMarker;
delete canvas;
}
void sqr_tools::CPieceUnitEditImp::CreateRS( std::string pieceName, std::string& rsName )
{
if (MODEL)
{
CEditPieceGroup* pPieceGroup = NULL;
pPieceGroup = new CEditPieceGroup;
MODEL->GetEditPieceGroup(pPieceGroup);
if (pPieceGroup)
{
for (unsigned int i = 0; i < pPieceGroup->GetPieceClassNum(); i++)
{
CPieceClass& Pc = *pPieceGroup->GetPieceClass(i);
for( unsigned int j = 0; j < Pc.size(); ++j )
{
if (pieceName.compare(Pc[j]->GetPieceName()) != 0)
continue;
int maxIndex = 0;
for (unsigned int k = 0; k < Pc[j]->GetRSNum(); k++)
{
std::string rsIndexName = Pc[j]->GetRS(k)->GetRSIndexName();
if (rsIndexName.substr(0,4) != "默认")
continue;
int index;
std::string strIndex = rsIndexName.substr(4);
std::stringstream ss(strIndex);
ss >> index;
if (index >= maxIndex)
{
maxIndex = index + 1;
}
}
std::string pieceResName;
CPathSetImp::GetInst()->GetResFileName(rsName, pieceResName);
CEditRenderStyle* pRs = new CEditRenderStyle( pieceResName.c_str(),L"res" );
if( !pieceResName.empty() )
{
if(pRs->BinLoad()<0)
{
std::string str = pieceResName + "没载入成功";
MessageBox(NULL, str.c_str(), "提示",MB_OK);
return;
}
}
char temp[256];
sprintf_s(temp, "%i", maxIndex);
std::string strIndexName = "默认" + string(temp);
CEditPieceRenderStyle* rs = new CEditPieceRenderStyle((CEditPiece*)Pc[j], pRs);
rs->SetRSIndexName(strIndexName);
int index = rsName.find_last_of("\\") + 1;
rsName = rsName.substr(index) + "(" + strIndexName + ")";
return;
}
}
}
pPieceGroup->Release();
}
}
std::string get_filename(const std::string& str)
{
std::size_t found = str.find_last_of("/\\");
return str.substr(found+1);
}
bool Model::loadCollada(std::string filename){
//Load the collada xml file
rapidxml::file<> xmlFile(filename.c_str());
rapidxml::xml_document<> doc;
doc.parse<0>(xmlFile.data());
bool zup = std::string(doc.first_node()->first_node("asset")->first_node("up_axis")->value()) == "Z_UP";
//Load textures
rapidxml::xml_node<> *images = doc.first_node()->first_node("library_images");
if(images->first_node("image") == 0){
Logger::error << "Couldn't load model: file contains no texture data." << std::endl;
return false;
}
std::map<std::string, unsigned int> textures;
for(rapidxml::xml_node<> *image = images->first_node("image"); image != 0; image = image->next_sibling("image")){
textures.insert(std::pair<std::string, unsigned int>(image->first_attribute("id")->value(), loadTextureFromPNG(filename.substr(0, filename.find_last_of("\\/")+1) + image->first_node("init_from")->value())));
}
//Load effects
//TODO: only supports common profiles using phong techniques
rapidxml::xml_node<> *effectsNode = doc.first_node()->first_node("library_effects");
if(effectsNode->first_node("effect") == 0){
Logger::error << "Couldn't load model: file contains no effects data." << std::endl;
return false;
}
std::map<std::string, Material> effects;
for(rapidxml::xml_node<> *effect = effectsNode->first_node("effect"); effect != 0; effect = effect->next_sibling("effect")){
rapidxml::xml_node<> *profile = effect->first_node("profile_COMMON");
if(profile != 0){
rapidxml::xml_node<> *technique = profile->first_node("technique");
Material mat;
rapidxml::xml_node<> *phong = technique->first_node("phong");
if(phong != 0){
if(phong->first_node("emission") != 0){
mat.emission = getVec4(phong->first_node("emission")->first_node("color"));
}
if(phong->first_node("ambient") != 0){
mat.ambient = getVec4(phong->first_node("ambient")->first_node("color"));
}
if(phong->first_node("diffuse") != 0){
if(phong->first_node("diffuse")->first_node("color") != 0){
mat.diffuse = getVec4(phong->first_node("diffuse")->first_node("color"));
}
if(phong->first_node("diffuse")->first_node("texture") != 0){
mat.diffuseTexture = textures.at(searchByAttribute(profile, "sid",
searchByAttribute(profile, "sid", phong->first_node("diffuse")->first_node("texture")->first_attribute("texture")->value(), "newparam")
->first_node("sampler2D")->first_node("source")->value()
, "newparam")->first_node("surface")->first_node("init_from")->value());
}
}
if(phong->first_node("specular") != 0){
if(phong->first_node("specular")->first_node("color") != 0){
mat.specular = getVec4(phong->first_node("specular")->first_node("color"));
}
if(phong->first_node("specular")->first_node("texture") != 0){
mat.specularTexture = textures.at(searchByAttribute(profile, "sid",
searchByAttribute(profile, "sid", phong->first_node("specular")->first_node("texture")->first_attribute("texture")->value(), "newparam")
->first_node("sampler2D")->first_node("source")->value()
, "newparam")->first_node("surface")->first_node("init_from")->value());
}
}
if(phong->first_node("shininess") != 0){
mat.shininess = std::stof(phong->first_node("shininess")->first_node("float")->value());
}
} else {
Logger::error << "Couldn't load model: material doesn't use the phong technique." << std::endl;
return false;
}
if(technique->first_node("extra") != 0 && technique->first_node("extra")->first_node("technique")->first_node("bump") != 0){
mat.bumpmapTexture = textures.at(searchByAttribute(profile, "sid",
searchByAttribute(profile, "sid", technique->first_node("extra")->first_node("technique")->first_node("bump")->first_node("texture")->first_attribute("texture")->value(), "newparam")
->first_node("sampler2D")->first_node("source")->value()
, "newparam")->first_node("surface")->first_node("init_from")->value());
}
effects.insert(std::pair<std::string, Material>(effect->first_attribute("id")->value(), mat));
} else {
Logger::error << "Couldn't load model: material doesn't have a profile_COMMON tag." << std::endl;
return false;
}
}
//Load materials
//TODO: make them overridable (collada spec))
rapidxml::xml_node<> *materialsNode = doc.first_node()->first_node("library_materials");
if(materialsNode->first_node("material") == 0){
Logger::error << "Couldn't load model: file contains no material data." << std::endl;
return false;
}
std::map<std::string, Material> materials;
for(rapidxml::xml_node<> *material = materialsNode->first_node("material"); material != 0; material = material->next_sibling("material")){
materials.insert(std::pair<std::string, Material>(material->first_attribute("id")->value(), effects.at(std::string(material->first_node("instance_effect")->first_attribute("url")->value()).substr(1))));
}
//Load geometry
std::map<std::string, Mesh> meshes;
rapidxml::xml_node<> *geometries = doc.first_node()->first_node("library_geometries");
if(geometries->first_node("geometry") == 0){
Logger::error << "Couldn't load model: file contains no geometry data." << std::endl;
return false;
}
for(rapidxml::xml_node<> *geometry = geometries->first_node("geometry"); geometry != 0; geometry = geometry->next_sibling("geometry")){
Mesh mesh;
rapidxml::xml_node<> *meshNode = geometry->first_node("mesh");
if(meshNode == 0){
Logger::error << "Couldn't load model: The loader can only load geometry of type \"mesh\" (geometry with name: " << geometry->first_attribute("name")->value() << ")." << std::endl;
return false;
}
if(meshNode->first_node("polylist") == 0){
Logger::error << "Couldn't load model: The loader can only load meshes that use polylists. (geometry with name: " << geometry->first_attribute("name")->value() << ")." << std::endl;
return false;
}
//TODO: allow for multiple data types
//<name, <stride, data>>
std::map<std::string, std::pair<unsigned int, std::vector<float>>> sources;
GLenum dataType;
for(rapidxml::xml_node<> *source = meshNode->first_node("source"); source != 0; source = source->next_sibling("source")){
std::vector<float> container;
dataType = readData(&container, source);
if(dataType == GL_NONE){
return false;
}
sources.insert(std::pair<std::string, std::pair<unsigned int, std::vector<float>>>(source->first_attribute("id")->value(), std::pair<unsigned int, std::vector<float>>(std::stoi(source->first_node("technique_common")->first_node("accessor")->first_attribute("stride")->value()), container)));
}
//TODO: same data vertex merging (aka indexing)
for(rapidxml::xml_node<> *polylist = meshNode->first_node("polylist"); polylist != 0; polylist = polylist->next_sibling("polylist")){
std::vector<float> openglData;
std::vector<unsigned int> indices;
std::vector<std::string> tempContainer;
std::vector<int> colladaIndices;
split(polylist->first_node("p")->value(), " ", &tempContainer);
for(std::string s : tempContainer){
colladaIndices.push_back(std::stoi(s));
}
std::vector<float> vertexData;
float vertexOffset;
float vertexStride;
std::vector<float> normalData;
float normalOffset;
float normalStride;
std::vector<float> uvData;
float uvOffset;
float uvStride;
std::pair<unsigned int, std::vector<float>> pair;
for(rapidxml::xml_node<> *input = polylist->first_node("input"); input != 0; input = input->next_sibling("input")){
std::string semantic(input->first_attribute("semantic")->value());
if(semantic == "VERTEX"){
pair = sources.at(std::string(meshNode->first_node("vertices")->first_node("input")->first_attribute("source")->value()).substr(1));
vertexData = pair.second;
vertexOffset = std::stoi(input->first_attribute("offset")->value());
vertexStride = pair.first;
} else if(semantic == "NORMAL"){
pair = sources.at(std::string(input->first_attribute("source")->value()).substr(1));
normalData = pair.second;
normalOffset = std::stoi(input->first_attribute("offset")->value());
normalStride = pair.first;
} else if(semantic == "TEXCOORD"){
pair = sources.at(std::string(input->first_attribute("source")->value()).substr(1));
uvData = pair.second;
uvOffset = std::stoi(input->first_attribute("offset")->value());
uvStride = pair.first;
} else {
Logger::error << "Unknown input semantic: " << semantic << std::endl;
return 0;
}
}
PolyGroup poly;
poly.elements = std::stoi(polylist->first_attribute("count")->value())*3;
//Generate vertices
for(unsigned int i = 0; i < poly.elements; i++){
openglData.push_back(vertexData.at(colladaIndices.at(i*3+vertexOffset)*vertexStride));
if(zup){
openglData.push_back(vertexData.at(colladaIndices.at(i*3+vertexOffset)*vertexStride+2));
openglData.push_back(-vertexData.at(colladaIndices.at(i*3+vertexOffset)*vertexStride+1));
} else {
openglData.push_back(vertexData.at(colladaIndices.at(i*3+vertexOffset)*vertexStride+1));
openglData.push_back(vertexData.at(colladaIndices.at(i*3+vertexOffset)*vertexStride+2));
}
openglData.push_back(normalData.at(colladaIndices.at(i*3+normalOffset)*normalStride));
if(zup){
openglData.push_back(normalData.at(colladaIndices.at(i*3+normalOffset)*normalStride+2));
openglData.push_back(-normalData.at(colladaIndices.at(i*3+normalOffset)*normalStride+1));
} else {
openglData.push_back(normalData.at(colladaIndices.at(i*3+normalOffset)*normalStride+1));
openglData.push_back(normalData.at(colladaIndices.at(i*3+normalOffset)*normalStride+2));
}
openglData.push_back(uvData.at(colladaIndices.at(i*3+uvOffset)*uvStride));
//collada stores the uv data the other way around. how silly.
openglData.push_back(1.0f - uvData.at(colladaIndices.at(i*3+uvOffset)*uvStride+1));
//temp index
indices.push_back(i);
}
poly.vaoid = sendToOpengl(openglData, indices);
poly.material = materials.at(polylist->first_attribute("material")->value());
mesh.addPolyGroup(poly);
}
meshes.insert(std::pair<std::string, Mesh>(geometry->first_attribute("id")->value(), mesh));
//this->meshes.insert(std::pair<std::string, std::pair<glm::mat4, Mesh>>(std::string(geometry->first_attribute("id")->value()).substr(1), std::pair<glm::mat4, Mesh>(glm::mat4(1.0f), mesh)));
}
//Load scene
rapidxml::xml_node<> *scenes = doc.first_node()->first_node("library_visual_scenes");
if(scenes->first_node("visual_scene") == 0){
Logger::error << "Couldn't load model: file contains no scene data." << std::endl;
return false;
} else {
rapidxml::xml_node<> *scene = scenes->first_node("visual_scene");
for(rapidxml::xml_node<> *node = scene->first_node("node"); node != 0; node = node->next_sibling("node")){
if(node->first_node("instance_geometry") != 0){
std::vector<float> matrix;
std::vector<std::string> tempContainer;
glm::mat4 mat4 = glm::mat4(1.0f);
if(node->first_node("matrix") == 0){
split(node->first_node("translate")->value(), " ", &tempContainer);
mat4 = glm::translate(mat4, glm::vec3(std::stof(tempContainer[0]), std::stof(tempContainer[2]), -std::stof(tempContainer[1])));
tempContainer.clear();
split(searchByAttribute(node, "sid", "rotationX", "rotate")->value(), " ", &tempContainer);
mat4 = glm::rotate(mat4, glm::radians(std::stof(tempContainer[3])), glm::vec3(1.0f, 0.0f, 0.0f));
tempContainer.clear();
split(searchByAttribute(node, "sid", "rotationZ", "rotate")->value(), " ", &tempContainer);
mat4 = glm::rotate(mat4, glm::radians(std::stof(tempContainer[3])), glm::vec3(0.0f, 1.0f, 0.0f));
tempContainer.clear();
split(searchByAttribute(node, "sid", "rotationY", "rotate")->value(), " ", &tempContainer);
mat4 = glm::rotate(mat4, glm::radians(std::stof(tempContainer[3])), glm::vec3(0.0f, 0.0f, -1.0f));
tempContainer.clear();
split(node->first_node("scale")->value(), " ", &tempContainer);
mat4 = glm::scale(mat4, glm::vec3(std::stof(tempContainer[0]), std::stof(tempContainer[2]), std::stof(tempContainer[1])));
//mat4 = glm::mat4(1.0f);
} else {
split(node->first_node("matrix")->value(), " ", &tempContainer);
for(std::string s : tempContainer){
matrix.push_back(std::stof(s));
}
glm::mat4 mat4 = glm::make_mat4(matrix.data());
if(std::string(doc.first_node()->first_node("asset")->first_node("up_axis")->value()) == "Z_UP"){
mat4 = convertToRightHandedCoords(mat4);
}
}
this->meshes.insert(std::pair<std::string,std::pair<glm::mat4, Mesh>>(
node->first_attribute("id")->value(),
std::pair<glm::mat4, Mesh>(
mat4,
meshes.at(std::string(node->first_node("instance_geometry")->first_attribute("url")->value()).substr(1)))));
}
}
}
rapidjson::Document animDoc;
if(readJsonFile(filename.substr(0, filename.find_last_of("/")+1) + "animation.json", animDoc)){
rapidxml::xml_node<> *animations = doc.first_node()->first_node("library_animations");
if(animations->first_node("animation") != 0){
std::map<std::string, std::vector< std::pair<float, glm::vec3> > > locationKeyframes;
std::map<std::string, std::vector< std::pair<float, glm::vec3> > > rotationKeyframes;
for(rapidxml::xml_node<> *animNode = animations->first_node("animation"); animNode != 0; animNode = animNode->next_sibling("animation")){
std::vector<float> inputContainer;
readData(&inputContainer, searchByAttribute(
animNode,
"id",
std::string(searchByAttribute(
animNode->first_node("sampler"),
"semantic",
"INPUT",
"input"
)->first_attribute("source")->value()).substr(1),
"source"));
std::vector<float> outputContainer;
readData(&outputContainer, searchByAttribute(
animNode,
"id",
std::string(searchByAttribute(
animNode->first_node("sampler"),
"semantic",
"OUTPUT",
"input"
)->first_attribute("source")->value()).substr(1),
"source"));/*
std::vector< std::pair<float, glm::vec3> > keyframes;
for(int i = 0; i < inputContainer.size(); i++){
keyframes.push_back(std::pair<float, glm::vec3>(inputContainer.at(i), outputContainer.at(i)));
}*/
std::string target = animNode->first_node("channel")->first_attribute("target")->value();
std::string meshName = target.substr(0, target.find_first_of("/"));
if(target.substr(target.find_first_of("/")+1, target.find_first_of(".")-target.find_first_of("/")-2) == "rotation"){
if(!rotationKeyframes.count(meshName)){
rotationKeyframes.insert(std::pair<std::string, std::vector< std::pair<float, glm::vec3> > >(meshName, std::vector< std::pair<float, glm::vec3> >()));
}
for(int i = 0; i < inputContainer.size(); i++){
if(rotationKeyframes.at(meshName).size() <= i){
rotationKeyframes.at(meshName).push_back(std::pair<float, glm::vec3>(inputContainer.at(i), glm::vec3(0.0f, 0.0f, 0.0f)));
}
if(target.substr(target.find_first_of("/")+1, target.find_first_of(".")-target.find_first_of("/")-1) == "rotationX"){
rotationKeyframes.at(meshName).at(i).second.x = outputContainer.at(i);
} else if(target.substr(target.find_first_of("/")+1, target.find_first_of(".")-target.find_first_of("/")-1) == "rotationY"){
rotationKeyframes.at(meshName).at(i).second.y = outputContainer.at(i);
} else if(target.substr(target.find_first_of("/")+1, target.find_first_of(".")-target.find_first_of("/")-1) == "rotationZ"){
rotationKeyframes.at(meshName).at(i).second.z = outputContainer.at(i);
}
}
} else if(target.substr(target.find_first_of("/")+1, target.find_first_of(".")) == "location"){
if(locationKeyframes.count(meshName)){
locationKeyframes.insert(std::pair<std::string, std::vector< std::pair<float, glm::vec3> > >(meshName, std::vector< std::pair<float, glm::vec3> >()));
}
for(int i = 0; i < inputContainer.size(); i++){
if(locationKeyframes.at(meshName).size() <= i){
locationKeyframes.at(meshName).push_back(std::pair<float, glm::vec3>(inputContainer.at(i), glm::vec3(0.0f, 0.0f, 0.0f)));
}
if(target.substr(target.find_first_of(".")+1) == "X"){
locationKeyframes.at(meshName).at(i).second.x = outputContainer.at(i);
} else if(target.substr(target.find_first_of(".")+1) == "Y"){
locationKeyframes.at(meshName).at(i).second.y = outputContainer.at(i);
} else if(target.substr(target.find_first_of(".")+1) == "Z"){
locationKeyframes.at(meshName).at(i).second.z = outputContainer.at(i);
}
}
} else {
Logger::info << "unknown animation target: " << target << std::endl;
}
}
for (rapidjson::SizeType i = 0; i < animDoc.Size(); i++) {
Animation animation;
rapidjson::Value& animjson = animDoc[i];
animation.mesh = animjson["mesh"].GetString();
int start = animjson["startKeyframe"].GetInt();
int end = animjson["endKeyframe"].GetInt();
for(int j = start; j <= end; j++){
glm::mat4 mat4 = this->meshes.at(animation.mesh).first;
glm::vec3 rotation = rotationKeyframes.count(animation.mesh) ? rotationKeyframes.at(animation.mesh).at(j).second : glm::vec3(0.0f, 0.0f, 0.0f);
glm::vec3 translation = locationKeyframes.count(animation.mesh) ? locationKeyframes.at(animation.mesh).at(j).second : glm::vec3(0.0f, 0.0f, 0.0f);
if(zup){
mat4 = glm::translate(mat4, glm::vec3(translation.x, translation.z, -translation.y));
mat4 = glm::rotate(mat4, glm::radians(rotation.x), glm::vec3(1.0f, 0.0f, 0.0f));
mat4 = glm::rotate(mat4, glm::radians(rotation.z), glm::vec3(0.0f, 1.0f, 0.0f));
mat4 = glm::rotate(mat4, glm::radians(rotation.y), glm::vec3(0.0f, 0.0f, -1.0f));
} else {
mat4 = glm::translate(mat4, glm::vec3(translation.x, translation.y, translation.z));
mat4 = glm::rotate(mat4, glm::radians(rotation.x), glm::vec3(1.0f, 0.0f, 0.0f));
mat4 = glm::rotate(mat4, glm::radians(rotation.y), glm::vec3(0.0f, 1.0f, 0.0f));
mat4 = glm::rotate(mat4, glm::radians(rotation.z), glm::vec3(0.0f, 0.0f, 1.0f));
}
animation.keyframes.push_back(std::make_pair(rotationKeyframes.at(animation.mesh).at(j).first, mat4));
}
this->animations.insert(std::make_pair(animjson["name"].GetString(), animation));
}
}
}
return true;
}