std::string fs_replace_extension(std::string path, std::string ext)
{
if (fs_ext(path) == "") return path;
path = fs_path(path) + fs_stem(path);
if (ext[0] == '.') return path + ext;
else return path + "." + ext;
}
bool Shader::generateInstances()
{
for (int i = 0; i < m_instances.size(); ++i)
{
LUMIX_DELETE(m_allocator, m_instances[i]);
}
m_instances.clear();
uint32 count = 1 << m_combintions.m_define_count;
auto* binary_manager = m_resource_manager.get(ResourceManager::SHADER_BINARY);
char basename[MAX_PATH_LENGTH];
PathUtils::getBasename(basename, sizeof(basename), getPath().c_str());
for (uint32 mask = 0; mask < count; ++mask)
{
ShaderInstance* instance = LUMIX_NEW(m_allocator, ShaderInstance)(*this);
m_instances.push(instance);
instance->m_define_mask = getDefineMaskFromDense(mask);
for (int pass_idx = 0; pass_idx < m_combintions.m_pass_count; ++pass_idx)
{
const char* pass = m_combintions.m_passes[pass_idx];
char path[MAX_PATH_LENGTH];
copyString(path, "shaders/compiled/");
catString(path, basename);
catString(path, "_");
catString(path, pass);
char mask_str[10];
int actual_mask = mask & m_combintions.m_vs_local_mask[pass_idx];
toCString(actual_mask, mask_str, sizeof(mask_str));
catString(path, mask_str);
catString(path, "_vs.shb");
Path vs_path(path);
auto* vs_binary = static_cast<ShaderBinary*>(binary_manager->load(vs_path));
addDependency(*vs_binary);
instance->m_binaries[pass_idx * 2] = vs_binary;
copyString(path, "shaders/compiled/");
catString(path, basename);
catString(path, "_");
catString(path, pass);
actual_mask = mask & m_combintions.m_fs_local_mask[pass_idx];
toCString(actual_mask, mask_str, sizeof(mask_str));
catString(path, mask_str);
catString(path, "_fs.shb");
Path fs_path(path);
auto* fs_binary = static_cast<ShaderBinary*>(binary_manager->load(fs_path));
addDependency(*fs_binary);
instance->m_binaries[pass_idx * 2 + 1] = fs_binary;
}
}
return true;
}
bool create_directories_if_necessary(const std::string& path)
{
namespace fs = boost::filesystem;
boost::system::error_code ec;
fs::path fs_path(path);
if (fs::is_directory(fs_path, ec)) {
return true;
}
return fs::create_directories(fs_path, ec);
}
uint kstat(char* path, struct stat* buffer){
fs_node_t* node = fs_path(df_root, path);
if(node == NULL)
return (uint) -1;
buffer->st_ino = node->inode;
buffer->st_size = node->length;
return 0;
}
FILE kfopen(char* path, uint offset){
fs_node_t* node = fs_path(df_root, path);
if(node == NULL){
node = vfs_touch(df_root, path);
if(node == NULL)
return (FILE) -1;
}
return fd_create(node, offset);
}
bool Shader::generateInstances()
{
bool is_opengl = getRenderer().isOpenGL();
for (int i = 0; i < m_instances.size(); ++i)
{
LUMIX_DELETE(m_allocator, m_instances[i]);
}
m_instances.clear();
uint32 count = 1 << m_combintions.define_count;
auto* binary_manager = m_resource_manager.get(SHADER_BINARY_HASH);
char basename[MAX_PATH_LENGTH];
PathUtils::getBasename(basename, sizeof(basename), getPath().c_str());
for (uint32 mask = 0; mask < count; ++mask)
{
ShaderInstance* instance = LUMIX_NEW(m_allocator, ShaderInstance)(*this);
m_instances.push(instance);
instance->define_mask = getDefineMaskFromDense(*this, mask);
m_all_defines_mask |= instance->define_mask;
for (int pass_idx = 0; pass_idx < m_combintions.pass_count; ++pass_idx)
{
const char* pass = m_combintions.passes[pass_idx];
StaticString<MAX_PATH_LENGTH> path("shaders/compiled", is_opengl ? "_gl/" : "/");
int actual_mask = mask & m_combintions.vs_local_mask[pass_idx];
path << basename << "_" << pass << actual_mask << "_vs.shb";
Path vs_path(path);
auto* vs_binary = static_cast<ShaderBinary*>(binary_manager->load(vs_path));
addDependency(*vs_binary);
instance->binaries[pass_idx * 2] = vs_binary;
path.data[0] = '\0';
actual_mask = mask & m_combintions.fs_local_mask[pass_idx];
path << "shaders/compiled" << (is_opengl ? "_gl/" : "/") << basename;
path << "_" << pass << actual_mask << "_fs.shb";
Path fs_path(path);
auto* fs_binary = static_cast<ShaderBinary*>(binary_manager->load(fs_path));
addDependency(*fs_binary);
instance->binaries[pass_idx * 2 + 1] = fs_binary;
}
}
return true;
}
// get full path of a shell entry
bool ShellEntry::get_path(PTSTR path, size_t path_count) const
{
/*
path[0] = TEXT('\0');
if (FAILED(path_from_pidl(get_parent_folder(), &*_pidl, path, MAX_PATH)))
return false;
*/
FileSysShellPath fs_path(create_absolute_pidl());
LPCTSTR ret = fs_path;
if (ret) {
lstrcpyn(path, ret, path_count);
return true;
} else
return false;
}
void vfs_ls(char* path){
fs_node_t* dir = fs_path(df_root, path);
if(dir == NULL){
vga_puts("vfs_ls(): invalid path\n");
return;
}
fs_node_t* link = dir->holds;
vga_puts("directory listing for ");
vga_puts(path);
vga_puts("\n");
while(link != NULL){
vga_puts(link->name);
if(link->flags == FS_DIRECTORY)
vga_puts("/");
vga_puts("\n");
link = link->link;
}
}
fs_node_t* vfs_get_dir(fs_node_t* node, char* name){
char* cpy = (char*) kmalloc(strlen(name) + 2);
char* ref = cpy;
strmov(cpy, name);
cpy[strlen(name) + 1] = 1; //Any nonzero value works here
name = cpy;
int i;
for(i = strlen(name); i >= 0; i--)
if(name[i] == '/'){
name[i] = 0;
break;
}
fs_node_t* output;
if(strlen(name) == 0)
output = df_root;
else
output = fs_path(node, name);
kfree(ref);
return output;
}
