unsigned char *loadImage( String path,int *width,int *height,int *depth ){
FILE *f=fopenFile( path,"rb" );
if( !f ) return 0;
unsigned char *data=stbi_load_from_file( f,width,height,depth,0 );
fclose( f );
return data;
}
void Texture::loadImage(const string& filePath){
FILE *file = fopen(filePath.c_str(), "rb");
if(!file)
throw runtime_error("texture image file cannot be opened");
//or give option to replace with default.png?
data = stbi_load_from_file(file, &width, &height, &channel, 0);
fclose(file);
}
/*
Constructor
shader = shader to use for drawing
filenames = locations of the 6 textures
cubemapVertices = (36) vertices of the cubemap
Author: Bas Rops - 22-05-2014
Last edit: <name> - dd-mm-yyyy
*/
Cubemap::Cubemap(ShaderProgram* shader, std::string filenames[6], const std::vector<glm::vec3> &cubemapVertices)
{
if (shader != NULL)
this->shader = shader;
else
std::cout << "Error initializing Cubemap: Shader == NULL" << std::endl;
//Generate 1 texture
glGenTextures(1, &texid);
//Bind the texture as a cubemap texture
glBindTexture(GL_TEXTURE_CUBE_MAP, texid);
//Set cubemap parameters
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
//Load all 6 textures for the cubemap
for (int i = 0; i < 6; i++)
{
std::string* filename = &filenames[i];
//Open the file
FILE* pFile = fopen(filename->c_str(), "rb");
if (pFile)
{
//Get the data from the texture
BYTE* data = stbi_load_from_file(pFile, &width, &height, &components, 4);
//Close the file
fclose(pFile);
glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
//Data no longer required, since it has been copied into a texture
delete data;
}
else
std::cout << "Error while loading cubemap texture: " << *filename << " does not exist." << std::endl;
}
//Add all vertices of the cubemap to a VBO
std::vector<VertexPosition> vertices;
for(const glm::vec3 &vertex : cubemapVertices)
{
vertices.push_back(VertexPosition(vertex));
}
vbo = new VBO<VertexPosition>();
vbo->bind();
vbo->setData(vertices.size(), &vertices[0], GL_DYNAMIC_DRAW);
vertices.clear();
}
void Texture::initFail(GLenum type, std::string fname, std::vector<std::array<GLenum, 2> > params)
{
std::cout << "InitFail " << fname;
try
{
FILE *file = fopen(fname.c_str(), "rb");
if (!file)
return ;
int width, height, comp;
unsigned char* imgdata = stbi_load_from_file(file, &width, &height, &comp, 0);
fclose(file);
//png::image<png::rgba_pixel> image (fname);
//GLubyte* imgdata = extractData(image, false, false);
glGenTextures(1, &textureID);
glBindTexture(GL_TEXTURE_2D, textureID);
glTexImage2D(GL_TEXTURE_2D, 0, type, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, imgdata);
std::cout << comp << " " << textureID << " " << GL_RGB << " " << type << " " << width << " " << height << std::endl;
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
for(int i=0; i<params.size(); i++)
{
glTexParameteri(GL_TEXTURE_2D, params[i][0], params[i][1]);
}
glBindTexture(GL_TEXTURE_2D, 0);
stbi_image_free(imgdata);
inited = true;
std::cout << " - success" << std::endl;
}
catch(png::std_error& e)
{
std::cout << " - fail" << std::endl;
}
}
void Texture::LoadFromFile()
{
FILE* file = fopen(this->filename, "rb");
imgData = stbi_load_from_file(file, &width, &height, &components, 4);
fclose(file);
glGenTextures(1, &glID);
glBindTexture(GL_TEXTURE_2D, glID);
gluBuild2DMipmaps(GL_TEXTURE_2D, 4, width, height, GL_RGBA, GL_UNSIGNED_BYTE, imgData);
stbi_image_free(imgData);
glBindTexture(GL_TEXTURE_2D, 0);
}
unsigned char *BBWin8Game::LoadImageData( String path,int *width,int *height,int *format ){
FILE *f=OpenFile( path,"rb" );
if( !f ) return 0;
unsigned char *data=stbi_load_from_file( f,width,height,format,0 );
fclose( f );
gc_force_sweep=true;
return data;
}
unsigned char* loadImage(const char* filename, int* imageWidth, int* imageHeight, int* comp) {
int req_comp=0;
FILE *file = fopen(filename, "rb");
if (!file) {
cerr << "TextureManager.cpp line 11: image file not found" << endl;
return 0;
}
unsigned char* image = stbi_load_from_file(file, imageWidth, imageHeight,
comp, req_comp);
return image;
}
Texture::Texture(std::string fileName, int reqComponents)
{
FILE * file = fopen(fileName.c_str(), "r");
if(file)
{
buffer = stbi_load_from_file(file,&width,&height,&nComps,reqComponents);
loaded = true;
fclose(file);
}
else
{
throw ParseException(fileName, "Unrecognized File: " + fileName);
}
}
int SImgX_STB::LoadFromFile( LPCWSTR pszFileName )
{
if(m_pImg) delete m_pImg;
m_pImg = NULL;
FILE *f=_wfopen(pszFileName,L"rb");
if(!f) return 0;
int w=0,h=0;
unsigned char *data = stbi_load_from_file(f,&w,&h,NULL,4);
fclose(f);
if(!data)
{
return 0;
}
_DoPromultiply(data,w,h);
m_pImg = new SImgFrame_STB(data,w,h);
return 1;
}
//===Load the "iNum" numbers of texture file
void Texture::LoadTex(const char * texture_file_path)
{
//===Load the texture file
GLint iChannel=0;
FILE* pFile=fopen(texture_file_path,"rb");
const unsigned char* pImageData=stbi_load_from_file(pFile,&m_iTexWidth,&m_iTexHeight,&iChannel,0);
//====//check the texture picture
if (pImageData==NULL)
{
fprintf(stderr,"The %s texture picture is null.Please check.\n",texture_file_path);
getchar();
return ;
}
//Generate the texture id
glGenTextures(1,&m_iTexture);
glBindTexture(GL_TEXTURE_2D,m_iTexture);
//====//
glPixelStorei(GL_UNPACK_ALIGNMENT,1);
//===//check the texture id
if (glIsTexture(m_iTexture)==GL_FALSE)
{
fprintf(stderr,"Is not currently the name of texture.Or some error occurs.Please check.\n");
getchar();
return ;
}
//Generate the texture
glTexImage2D(GL_TEXTURE_2D,0,GL_RGB,m_iTexWidth,m_iTexHeight,0,GL_RGB,GL_UNSIGNED_BYTE,pImageData);
//Release the texture picture buffer
free((void *)pImageData);
pImageData=NULL;
//Set the texture parameters
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP_TO_EDGE);
}
sdl_surface load_image(std::string filename, bool alpha, bool convert)
{
int width, height, depth;
unsigned char * data = stbi_load_from_file(get_resource_file(filename.c_str()), &width, &height, &depth, 0);
if(data == 0)
throw std::logic_error("sdlw error: couldn't load file " + filename + " because: " + stbi_failure_reason());
// Note the order of creation and destruction here. First create an SDL_Surface from
// the stb image data. This only references the stb image data, it does not copy it.
// This SDL_Surface has to be released before the stb image data can be free'd.
SDL_Surface * raw = SDL_CreateRGBSurfaceFrom(data, width, height, depth*8, (width*depth),
0xFF, 0xFF00, 0xFF0000, alpha ? 0xFF000000 : 0);
if(raw == 0)
throw std::logic_error("sdlw error: could not create surface from file " + filename);
sdl_surface res;
if(convert)
{
// Convert the raw surface to an sdl_surface that has the display pixel format. We now
// have a copy of the image data.
res = sdl_surface(alpha ? SDL_DisplayFormatAlpha(raw) : SDL_DisplayFormat(raw));
// Release the unconverted SDL_Surface.
SDL_FreeSurface(raw);
}
else
{
// Just take ownership of the raw surface
res = sdl_surface(raw);
}
// Free the stb image data.
stbi_image_free(data);
return res;
}
ReplayCreateStatus IMG_CreateReplayDevice(const char *logfile, IReplayDriver **driver)
{
FILE *f = FileIO::fopen(logfile, "rb");
if(!f)
return eReplayCreate_FileIOFailed;
FetchTexture texDetails;
ResourceFormat rgba8_unorm;
rgba8_unorm.compByteWidth = 1;
rgba8_unorm.compCount = 4;
rgba8_unorm.compType = eCompType_UNorm;
rgba8_unorm.special = false;
ResourceFormat rgba32_float = rgba8_unorm;
rgba32_float.compByteWidth = 4;
rgba32_float.compType = eCompType_Float;
texDetails.creationFlags = eTextureCreate_SwapBuffer|eTextureCreate_RTV;
texDetails.cubemap = false;
texDetails.customName = true;
texDetails.name = logfile;
texDetails.ID = ResourceId();
texDetails.byteSize = 0;
texDetails.msQual = 0;
texDetails.msSamp = 1;
// reasonable defaults for everything but dds
texDetails.numSubresources = 1;
texDetails.dimension = 2;
texDetails.arraysize = 1;
texDetails.depth = 1;
texDetails.mips = 1;
byte *data = NULL;
size_t datasize = 0;
bool dds = false;
if(is_exr_file(f))
{
texDetails.format = rgba32_float;
FileIO::fseek64(f, 0, SEEK_SET);
const char *err = NULL;
int ret = LoadEXRFP((float **)&data, (int *)&texDetails.width, (int *)&texDetails.height, f, &err);
datasize = texDetails.width*texDetails.height*4*sizeof(float);
// could be an unsupported form of EXR, like deep image or other
if(ret != 0)
{
if(data) free(data);
RDCERR("EXR file detected, but couldn't load with LoadEXR %d: '%s'", ret, err);
return eReplayCreate_APIUnsupported;
}
}
else if(stbi_is_hdr_from_file(f))
{
texDetails.format = rgba32_float;
FileIO::fseek64(f, 0, SEEK_SET);
int ignore = 0;
data = (byte *)stbi_loadf_from_file(f, (int *)&texDetails.width, (int *)&texDetails.height, &ignore, 4);
datasize = texDetails.width*texDetails.height*4*sizeof(float);
}
else if(is_dds_file(f))
{
dds = true;
}
else
{
int ignore = 0;
int ret = stbi_info_from_file(f, (int *)&texDetails.width, (int *)&texDetails.height, &ignore);
// just in case (we shouldn't have come in here if this weren't true), make sure
// the format is supported
if(ret == 0 ||
texDetails.width == 0 || texDetails.width == ~0U ||
texDetails.height == 0 || texDetails.height == ~0U)
{
return eReplayCreate_APIUnsupported;
}
texDetails.format = rgba8_unorm;
data = stbi_load_from_file(f, (int *)&texDetails.width, (int *)&texDetails.height, &ignore, 4);
datasize = texDetails.width*texDetails.height*4*sizeof(byte);
}
// if we don't have data at this point (and we're not a dds file) then the
// file was corrupted and we failed to load it
if(!dds && data == NULL)
{
return eReplayCreate_FileCorrupted;
}
IReplayDriver *proxy = NULL;
auto status = RenderDoc::Inst().CreateReplayDriver(RDC_Unknown, NULL, &proxy);
if(status != eReplayCreate_Success || !proxy)
{
if(proxy) proxy->Shutdown();
return status;
}
ResourceId id;
if(!dds)
{
id = proxy->CreateProxyTexture(texDetails);
proxy->SetProxyTextureData(id, 0, 0, data, datasize);
free(data);
}
else
{
FileIO::fseek64(f, 0, SEEK_SET);
dds_data read_data = load_dds_from_file(f);
if(read_data.subdata == NULL)
{
proxy->Shutdown();
return eReplayCreate_FileCorrupted;
}
texDetails.cubemap = read_data.cubemap;
texDetails.arraysize = read_data.slices;
texDetails.width = read_data.width;
texDetails.height = read_data.height;
texDetails.depth = read_data.depth;
texDetails.mips = read_data.mips;
texDetails.numSubresources = texDetails.arraysize*texDetails.mips;
texDetails.format = read_data.format;
texDetails.dimension = 1;
if(texDetails.width > 1) texDetails.dimension = 2;
if(texDetails.depth > 1) texDetails.dimension = 3;
id = proxy->CreateProxyTexture(texDetails);
for(uint32_t i=0; i < texDetails.numSubresources; i++)
{
proxy->SetProxyTextureData(id, i/texDetails.mips, i%texDetails.mips, read_data.subdata[i], (size_t)read_data.subsizes[i]);
delete[] read_data.subdata[i];
}
delete[] read_data.subdata;
delete[] read_data.subsizes;
}
*driver = new ImageViewer(proxy, logfile, id);
FileIO::fclose(f);
return eReplayCreate_Success;
}
int main( int argc, char** argv )
{
std::cout << "Starting..\n";
std::vector<std::string> file_names;
parse_args(argc, argv, file_names);
file_names.push_back(std::string("b0e0.hgt"));
InitGraphics();
glfwSetWindowTitle( "p7" );
// Ensure we can capture the escape key being pressed below
glfwEnable( GLFW_STICKY_KEYS );
// Dark blue background
glClearColor(0.7f, 0.7f, 0.7f, 0.0f);
// Enable depth test
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
// Accept fragment if it closer to the camera than the former one
glDepthFunc(GL_LESS);
// glFrontFace(GL_CCW);
// Create and compile our GLSL program from the shaders
GLuint programIDs[2] = { LoadShaders( "tvs.vertexshader", "cfs.fragmentshader" ), LoadShaders( "tvs2.vertexshader", "cfs.fragmentshader" )};
std::cout << "Linked shaders..\n";
// Get a handle for our "MVP" uniform
GLuint MatrixIDs[2] = {glGetUniformLocation(programIDs[0], "MVP"), glGetUniformLocation(programIDs[1], "MVP")};
GLuint EdgexIDs[2] = {glGetUniformLocation(programIDs[0], "Edgex"), glGetUniformLocation(programIDs[1], "Edgex")};
GLuint EdgeyIDs[2] = {glGetUniformLocation(programIDs[0], "Edgey"), glGetUniformLocation(programIDs[1], "Edgey")};
GLuint HeightIDs[2] = {glGetUniformLocation(programIDs[0], "height"), glGetUniformLocation(programIDs[1], "height")};
GLuint TextureIDs[2] = {glGetUniformLocation(programIDs[0], "tex2d"), glGetUniformLocation(programIDs[1], "tex2d")};
GLuint TimeIDs[2] = {glGetUniformLocation(programIDs[0], "time"), glGetUniformLocation(programIDs[1], "time")};
GLuint AlphaIDs[2] = {glGetUniformLocation(programIDs[0], "alpha"), glGetUniformLocation(programIDs[1], "alpha")};
std::cout << "Got uniforms..\n";
std::cout << glGetString(GL_VERSION) << std::endl;
std::cout << "Loadin textures...\n";
char texName[] = "texture3.jpg";
std::cout << texName << std::endl;
int t1x,t1y,t1comp;
FILE* t1f = fopen(texName, "rb");
unsigned char* tex1data = stbi_load_from_file(t1f, &t1x, &t1y, &t1comp,0);
unsigned int tex_2d;
glGenTextures(1, &tex_2d);
glBindTexture(GL_TEXTURE_2D, tex_2d);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, t1x, t1y, 0, GL_RGB, GL_UNSIGNED_BYTE, tex1data);
/*
char texNameCl[] = "textureClouds3.png";
std::cout << texNameCl << std::endl;
int t2x,t2y,t2comp;
FILE* t2f = fopen(texNameCl, "rb");
unsigned char* tex2data = stbi_load_from_file (t2f, &t2x, &t2y, &t2comp,0);
unsigned int tex_cl;
glGenTextures(1, &tex_cl);
glBindTexture(GL_TEXTURE_2D, tex_cl);
//-->
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, t2x, t2y, 0, GL_RGB, GL_UNSIGNED_BYTE, tex2data);
*/
std::cout << "Done!\n";
const int side(1201);
const int vBOsize(file_names.size());
//Vertices:
short piece_map[360][181];
for(int i=0; i<360; i++)
for(int y=0; y<=180; y++)
piece_map[i][y] = -1;
unsigned int numberOfVertices=side*side;
GLuint vaoObjects[vBOsize+1], vertexBufferObject, vBOs[vBOsize+1];
std::vector<std::pair<int, int> > edges(vBOsize+1);
// -->
std::cout << "Generating arrays...\n";
glGenVertexArrays(vBOsize, vaoObjects);
std::cout << "Done\n";
glGenBuffers(vBOsize, vBOs);
int height;
// <---
for(short i=0; i< vBOsize; i++)
{
std::vector< int > vertexPositionsVec(3*numberOfVertices);
int* vertexPositions = &vertexPositionsVec[0];
loadVertices(file_names[i], vertexPositionsVec, true, side, edges[i], height);
glBindVertexArray(vaoObjects[i]);
glBindBuffer(GL_ARRAY_BUFFER, vBOs[i]);
glVertexAttribPointer(
0, // attribute. No particular reason for 0, but must match the layout in the shader.
3, // size
GL_INT, // type
GL_FALSE, // normalized?
0, // stride
(void*)0 // array buffer offset
);
glBufferData(GL_ARRAY_BUFFER, sizeof(int)*3*numberOfVertices, vertexPositions, GL_STATIC_DRAW);
if(i<vBOsize-1)
{
piece_map[edges[i].second+180][edges[i].first+90]=i;
std::cout << edges[i].second+180 << " " << edges[i].first+90 << std::endl;
}
}
//Indices::
GLuint indexBufferObject, iBOs[maxLoD], numberOfIndices;
std::vector<GLuint> nOIs(maxLoD);
glGenBuffers(maxLoD, iBOs);
for(unsigned int density=1, i=0; i<maxLoD; i++, density*=2)
{
std::cout << "Entering for with i: " << i << "\n";
nOIs[i]=(side-1)/density;
if((side-1)%density!=0)
nOIs[i]+=1;
nOIs[i]=6*(nOIs[i]*(nOIs[i]));
std::cout << "Allocating memory...\n";
GLuint* indices = new GLuint [nOIs[i]];
std::cout << "Done.\n";
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, iBOs[i]);
std::cout << "Density: " << density << " Number of indices: " << nOIs[i] << std::endl;
genIndices(indices, side, density);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLuint)*nOIs[i], indices, GL_STATIC_DRAW);
std::cout << "Leaving for with i: " << i << "\n";
}
// Projection matrix : 45° Field of View, 4:3 ratio, display range : 0.1 unit <-> 100 units
glm::mat4 Projection =
// glm::mat4(1.0f);
glm::perspective(45.0f, 4.0f / 3.0f, 100.f, 30000.0f);
// Camera matrix
// int xVw = edges[0].first*side, yVw = edges[0].second*side;
int xVw = 6000, yVw = -6000;
height = 3000;
glm::mat4 View = glm::lookAt(
glm::vec3(xVw,yVw,2*height), // Camera is at (4,3,-3), in World Space
glm::vec3(xVw,yVw,0), // and looks at the origin
glm::vec3(0,1,0) // Head is up (set to 0,-1,0 to look upside-down)
);
// Model matrix : an identity matrix (model will be at the origin)
glm::mat4 Model = glm::mat4(1.0f);
// Our ModelViewProjection : multiplication of our 3 matrices
glm::mat4 MVP = Projection * View * Model; // Remember, matrix multiplication is the other way around
std::cout << "Init done.\n";
glfwSetKeyCallback(Key_Callback);
double last_time = glfwGetTime(), last_reset=last_time;
int FPScounter=0;
x = edges[0].second*12010;
startx=x;
y = edges[0].first*12010;
starty=y;
std::cout << edges[0].first << " " << edges[0].second << std::endl;
do {
int ex = x/12010+180;
int ey = y/12010+90;
//time statistics:
FPScounter++;
double cur_time = glfwGetTime();
if(cur_time-last_reset>=2)
{
double FPS = (float)FPScounter/(cur_time-last_reset);
std::cout << "FPS: " << FPS << " lod: " << iBOindex << std::endl;
std::cout << ex << " " << ey << " " << alpha << std::endl;
if(autolod && abs(FPS-optfps)>4)
{
if(FPS<optfps && iBOindex<maxLoD)
iBOindex++;
if(FPS>4*optfps && iBOindex > 0)
iBOindex--;
}
FPScounter=0;
last_reset=cur_time;
}
last_time=cur_time;
// Clear the screen
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Use our shader
glUseProgram(programIDs[ball]);
glm::mat4 Vw;
// Send our transformation to the currently bound shader,
// in the "MVP" uniform
Vw=MVP * glm::translate( mat4(1.0),vec3((-x + 6000)*ball,(-y - 6000)*ball,(z - 12000)*ball))
* glm::rotate(mat4(1.0), oz, glm::vec3(0,1,0))
* glm::rotate(mat4(1.0), ox, glm::vec3(1,0,0))
* glm::rotate(mat4(1.0), oy, glm::vec3(0,0,1))
* glm::translate( mat4(1.0), vec3(-x*(1-ball), -y*(1-ball), z*(1-ball)));
glUniformMatrix4fv(MatrixIDs[ball], 1, GL_FALSE, &Vw[0][0]);
glUniform1i(HeightIDs[ball], 0);
glUniform1f(TimeIDs[ball], glfwGetTime());
glUniform1f(AlphaIDs[ball], (float)alpha*0.1);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, tex_2d);
glUniform1i(TextureIDs[ball], /*GL_TEXTURE0+*/0);
indexBufferObject=iBOs[iBOindex];
numberOfIndices=nOIs[iBOindex];
// std::cout << ex << " " << ey << std::endl;
if(ball==0)
{
glCullFace(GL_FRONT);
for(int i = max(ex-3,0); i<= min(ex+3,360) ; i++)
for(int j=max(ey-3,0); j<= min(ey+3,180); j++)
{
glUniform1i(EdgexIDs[ball], (i-180));
glUniform1i(EdgeyIDs[ball], (j-90));
int point;
if(piece_map[i][j]==-1)
{
point=vBOsize-1;
draw(vaoObjects[point], vBOs[point], iBOs[maxLoD-1], nOIs[maxLoD-1]);
}
else
{
point = piece_map[i][j];
draw(vaoObjects[point], vBOs[point], indexBufferObject, numberOfIndices);
}
// std::cout << "Drawing " << file_names[point] << "with mods " << i-180 << " " << j-90 << std::endl
// << i << " " << ex << " " << j << " " << ey << std::endl;
}
}
else
{
glCullFace(GL_FRONT);
for(int i=/*edges[0].second+180+*/0; i</*edges[0].second+18*/360; i++)
for(int j=/*edges[0].first+90+*/0; j<=/*edges[0].first+90*/180; j++)
{
glUniform1i(EdgexIDs[ball], (i-180));
glUniform1i(EdgeyIDs[ball], (j-90));
int point;
if(piece_map[i][j]==-1)
{
point=vBOsize-1;
draw(vaoObjects[point], vBOs[point], iBOs[maxLoD-1], nOIs[maxLoD-1]);
}
else
{
point = piece_map[i][j];
draw(vaoObjects[point], vBOs[point], indexBufferObject, numberOfIndices);
}
}
}
//CLOUDS
/*
Vw=MVP * glm::translate( mat4(1.0),vec3((-x + 6000)*ball,(-y - 6000)*ball,(z - 12000)*ball))
* glm::rotate(mat4(1.0), oz+(float)glfwGetTime(), glm::vec3(0,1,0))
* glm::rotate(mat4(1.0), ox, glm::vec3(1,0,0))
* glm::rotate(mat4(1.0), oy, glm::vec3(0,0,1))
* glm::translate( mat4(1.0), vec3(-x*(1-ball), -y*(1-ball), z*(1-ball)));
glUniformMatrix4fv(MatrixIDs[ball], 1, GL_FALSE, &Vw[0][0]);
glUniform1i(HeightIDs[ball], 100);
glUniform1f(TimeIDs[ball], glfwGetTime());
glUniform1f(AlphaIDs[ball], 0.25);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, tex_cl);
glUniform1i(TextureIDs[ball], 0);
indexBufferObject=iBOs[iBOindex];
numberOfIndices=nOIs[iBOindex];
// std::cout << ex << " " << ey << std::endl;
if(ball==0)
{
glCullFace(GL_FRONT);
for(int i = max(ex-3,0); i<= min(ex+3,360) ;i++)
for(int j=max(ey-3,0); j<= min(ey+3,180); j++)
{
glUniform1i(EdgexIDs[ball], (i-180));
glUniform1i(EdgeyIDs[ball], (j-90));
int point;
{
point=vBOsize-1;
draw(vaoObjects[point], vBOs[point], iBOs[maxLoD-1], nOIs[maxLoD-1]);
}
}
}
else
{
glCullFace(GL_FRONT);
for(int i=0; i<360;i++)
for(int j=0; j<=180;j++)
{
glUniform1i(EdgexIDs[ball], (i-180));
glUniform1i(EdgeyIDs[ball], (j-90));
int point;
{
point=vBOsize-1;
draw(vaoObjects[point], vBOs[point], iBOs[maxLoD-1], nOIs[maxLoD-1]);
}
}
}*/
// Swap buffers
glfwSwapBuffers();
} // Check if the ESC key was pressed or the window was closed
while( glfwGetKey( GLFW_KEY_ESC ) != GLFW_PRESS &&
glfwGetWindowParam( GLFW_OPENED ) );
// Cleanup VBO and shader
glDeleteProgram(programIDs[0]);
glDeleteProgram(programIDs[1]);
// CleanVBOs(vaoObjects, vBOs, vBOsize+1, iBOs, tex_2d);
std::cout << "Cleaning done, terminating..\n";
// Close OpenGL window and terminate GLFW
glfwTerminate();
return 0;
}
static int deal(FILE *fp, char *filename, int pipemode)
{
color *image;
void (*outputcolor)();
int width, height, comp, i, j, istep, jstep, ch, scale, scalew, scaleh,
offset, imagewidth, imageheight,
margintopbottom, marginleftright, marginleft, margintop,
paddingtopbottom, paddingleftright, paddingleft, paddingright,
paddingtop, paddingbottom,
ipaddingleftright, ipaddingleft, ipaddingright;
image = stbi_load_from_file(fp, &width, &height, &comp, 0);
/* error handling */
if (image == NULL) {
if ((!qflag) && (stbi_failure_reason() != NULL))
warnx("%s: %s", filename, stbi_failure_reason());
goto ERR_DEAL;
}
if (width <= 0 || height <= 0) {
if (!qflag)
warnx("%s %s (width: %d, height: %d)", filename,
"is an invalid image", width, height);
goto ERR_DEAL;
}
/* ok, it is surely a valid image */
/* get terminal size before processing each image */
terminalsize();
/* set scale parameters */
scale = 1;
if (Sflag) {
if (cflag) outputcolor = outputcolor_3;
else outputcolor = outputcolor_1;
scale = (int)Sval; /* TODO */
istep = 2 * (jstep = scale);
imageheight = (int)ceil((double)height / (double)istep);
imagewidth = (int)ceil((double)width / (double)jstep);
} else if (2 * width <= outputwidth && height <= outputheight) {
if (cflag) outputcolor = outputcolor_4;
else outputcolor = outputcolor_2;
istep = jstep = 1;
imagewidth = width * 2;
imageheight = height;
} else {
if (cflag) outputcolor = outputcolor_3;
else outputcolor = outputcolor_1;
scalew = (int)ceil((double)width / (double)outputwidth);
scaleh = (int)ceil((double)height / 2.0 / (double)outputheight);
if (Hval == 0 && hval == 0 && (wval > 0 || Wval > 0)) scale = scalew;
else if ((hval > 0 || Hval > 0) && wval == 0 && Wval == 0) scale = scaleh;
else scale = ((scalew) > (scaleh) ? (scalew) : (scaleh));
istep = 2 * (jstep = scale);
imageheight = (int)ceil((double)height / (double)istep);
imagewidth = (int)ceil((double)width / (double)jstep);
}
if (istep * jstep >= INT_MAX / 256 || width * height >= INT_MAX / 3) {
if (!qflag)
warnx("%s %s (width: %d, height: %d)",
filename, "is too large", width, height);
goto ERR_DEAL;
}
/* setting parameters */
margintopbottom = terminalheight - outputheight - iflag;
marginleftright = terminalwidth - outputwidth;
paddingtopbottom = outputheight - imageheight;
paddingleftright = outputwidth - imagewidth;
if (Rflag && !Lflag) {
marginleft = marginleftright;
} else if (Lflag && !Rflag) {
marginleft = 0;
} else if ((Lflag && Rflag) || Cflag || Tflag || Bflag) {
marginleft = marginleftright / 2;
} else {
marginleft = 0;
}
if (PRflag && !PLflag) {
paddingleft = paddingleftright;
} else if (PLflag && !PRflag) {
paddingleft = 0;
} else if ((PLflag && PRflag) || PCflag || PTflag || PBflag) {
paddingleft = paddingleftright / 2;
} else if (Rflag && !Lflag) {
paddingleft = paddingleftright;
} else if (Lflag && !Rflag) {
paddingleft = 0;
} else if ((Lflag && Rflag) || Cflag || Tflag || Bflag) {
paddingleft = paddingleftright / 2;
} else {
paddingleft = 0;
}
if (Bflag) {
margintop = margintopbottom;
} else if (Tflag) {
margintop = 0;
} else if (Cflag) {
margintop = margintopbottom / 2;
} else {
margintop = 0;
}
if (PBflag) {
paddingtop = paddingtopbottom;
} else if (PTflag) {
paddingtop = 0;
} else if (PCflag) {
paddingtop = paddingtopbottom / 2;
} else if (Bflag) {
paddingtop = paddingtopbottom;
} else if (Tflag) {
paddingtop = 0;
} else if (Cflag) {
paddingtop = paddingtopbottom / 2;
} else {
paddingtop = 0;
}
paddingright = paddingleftright - paddingleft;
paddingbottom = paddingtopbottom - paddingtop;
/* start up */
setdefaultcolor();
if (uflag) {
cursorhide();
cursorsave();
}
/* main process */
if (Eflag && filecount == 0) erasescreen();
if (Cflag || Tflag || Bflag) {
if (!eflag) {
if (margintop >= 0) cursormove(margintop + 1, 1);
for (i = 0; i < paddingtop; i++) {
if (marginleft > 0) cursorforward(marginleft);
replicatespace(outputwidth);
cursordown_cursorhorizontalabsolute();
}
}
if (margintop + paddingtop >= 0) cursormove(margintop + paddingtop + 1, 1);
}
if (iflag) {
ipaddingleftright = outputwidth - strlen(filename);
if (PRflag && !PLflag) {
ipaddingleft = ipaddingleftright;
} else if (PLflag && !PRflag) {
ipaddingleft = 0;
} else if ((PLflag && PRflag) || PCflag || PTflag || PBflag) {
ipaddingleft = ipaddingleftright / 2;
} else if (Rflag && !Lflag) {
ipaddingleft = ipaddingleftright;
} else if (Lflag && !Rflag) {
ipaddingleft = 0;
} else if ((Lflag && Rflag) || Cflag || Tflag || Bflag) {
ipaddingleft = ipaddingleftright / 2;
} else {
ipaddingleft = 0;
}
ipaddingright = ipaddingleftright - ipaddingleft;
if (Cflag || Lflag || Rflag || Tflag || Bflag ||
PCflag || PLflag || PRflag || PTflag || PBflag) {
if (marginleft > 0) cursorforward(marginleft);
if (ipaddingleft > 0) {
if (eflag) {
cursorforward(ipaddingleft);
} else {
replicatespace(ipaddingleft);
}
} else if (ipaddingleftright < 0) {
filename[outputwidth] = '\0';
}
}
printf("%s", filename);
if (Cflag || Tflag || Bflag || PCflag || PTflag || PBflag) {
if (ipaddingright > 0) {
if (!eflag) {
replicatespace(ipaddingright);
}
}
if (Cflag || Tflag || Bflag) {
cursordown_cursorhorizontalabsolute();
} else {
newline();
}
} else {
newline();
}
}
for (i = 0; i < height; i += istep) {
if (Cflag || Lflag || Rflag || Tflag || Bflag ||
PCflag || PLflag || PRflag || PTflag || PBflag) {
if (marginleft > 0) cursorforward(marginleft);
if (paddingleft > 0) {
if (eflag) {
cursorforward(paddingleft);
} else {
replicatespace(paddingleft);
}
}
}
for (j = 0; j < width; j += jstep) {
offset = (i * width + j) * comp;
outputcolor(image, height, width, offset, i, j,
(i + istep > height ? height - i : istep),
(j + jstep > width ? width - j : jstep), comp);
}
setdefaultcolor();
if (Cflag || Tflag || Bflag || PCflag || PTflag || PBflag) {
if (paddingright > 0) {
if (!eflag) {
replicatespace(paddingright);
}
}
if (Cflag || Tflag || Bflag) {
cursordown_cursorhorizontalabsolute();
} else {
newline();
}
} else {
newline();
}
}
if (Cflag || Tflag) {
if (!eflag) {
for (i = 0; i < paddingbottom; i++) {
if (marginleft > 0) cursorforward(marginleft);
if (outputwidth > 0) replicatespace(outputwidth);
cursordown_cursorhorizontalabsolute();
}
}
}
/* clean up */
setdefaultcolor();
if (uflag) {
cursorunsave();
cursorshow();
}
fflush(stdout);
stbi_image_free(image);
++filecount;
/* debug mode */
if (dflag) {
cursorsave();
cursormove(1, 1);
printf(PACKAGE);
if (iflag) printf(" -i");
if (qflag) printf(" -q");
if (sflag) printf(" -s %lf", sval);
if (rflag) printf(" -r %ld", rval);
if (Lflag) printf(" -L");
if (Rflag) printf(" -R");
if (Cflag) printf(" -C");
if (Tflag) printf(" -T");
if (Bflag) printf(" -B");
if (Eflag) printf(" -E");
if (hflag) printf(" -h %ld", hval);
if (Hflag) printf(" -H %ld", Hval);
if (wflag) printf(" -w %ld", wval);
if (Wflag) printf(" -W %ld", Wval);
printf(" %s\n", filename);
printf("terminalwidth: %d\n", terminalwidth);
printf("terminalheight: %d\n", terminalheight);
printf("outputwidth: %d\n", outputwidth);
printf("outputheight: %d\n", outputheight);
printf("imagewidth: %d\n", imagewidth);
printf("imageheight: %d\n", imageheight);
printf("margintop: %d\n", margintop);
printf("marginleft: %d\n", marginleft);
printf("paddingtop: %d\n", paddingtop);
printf("paddingleft: %d\n", paddingleft);
printf("paddingbottom: %d\n", paddingbottom);
printf("paddingright: %d\n", paddingright);
fflush(stdout);
cursorunsave();
}
/* check next file if pipe or fifo */
if (pipemode) {
ch = getc(fp);
if (ch != EOF) {
if (ch != '\0' && ch != '\n') {
ungetc(ch, fp);
} else if ((ch = getc(fp)) != '\0' && ch != '\n') {
ungetc(ch, fp);
} else if ((ch = getc(fp)) != '\0' && ch != '\n') {
ungetc(ch, fp);
}
if (ch != EOF) {
if (sflag && sval > 0) {
usleep(sval * 1e6);
}
deal(fp, filename, pipemode);
}
}
}
return 0;
ERR_DEAL:
return 1;
}
void Image::load(FILE* f)
{
data = stbi_load_from_file(f, &width, &height, &ncomponents, 0);
}
ReplayCreateStatus IMG_CreateReplayDevice(const char *logfile, IReplayDriver **driver)
{
FILE *f = FileIO::fopen(logfile, "rb");
if(!f)
return eReplayCreate_FileIOFailed;
// make sure the file is a type we recognise before going further
if(is_exr_file(f))
{
const char *err = NULL;
FileIO::fseek64(f, 0, SEEK_END);
uint64_t size = FileIO::ftell64(f);
FileIO::fseek64(f, 0, SEEK_SET);
std::vector<byte> buffer;
buffer.resize((size_t)size);
FileIO::fread(&buffer[0], 1, buffer.size(), f);
EXRImage exrImage;
InitEXRImage(&exrImage);
int ret = ParseMultiChannelEXRHeaderFromMemory(&exrImage, &buffer[0], &err);
FreeEXRImage(&exrImage);
// could be an unsupported form of EXR, like deep image or other
if(ret != 0)
{
FileIO::fclose(f);
RDCERR(
"EXR file detected, but couldn't load with ParseMultiChannelEXRHeaderFromMemory %d: '%s'",
ret, err);
return eReplayCreate_APIUnsupported;
}
}
else if(stbi_is_hdr_from_file(f))
{
FileIO::fseek64(f, 0, SEEK_SET);
int ignore = 0;
float *data = stbi_loadf_from_file(f, &ignore, &ignore, &ignore, 4);
if(!data)
{
FileIO::fclose(f);
RDCERR("HDR file recognised, but couldn't load with stbi_loadf_from_file");
return eReplayCreate_FileCorrupted;
}
free(data);
}
else if(is_dds_file(f))
{
FileIO::fseek64(f, 0, SEEK_SET);
dds_data read_data = load_dds_from_file(f);
if(read_data.subdata == NULL)
{
FileIO::fclose(f);
RDCERR("DDS file recognised, but couldn't load");
return eReplayCreate_FileCorrupted;
}
for(int i = 0; i < read_data.slices * read_data.mips; i++)
delete[] read_data.subdata[i];
delete[] read_data.subdata;
delete[] read_data.subsizes;
}
else
{
int width = 0, height = 0;
int ignore = 0;
int ret = stbi_info_from_file(f, &width, &height, &ignore);
// just in case (we shouldn't have come in here if this weren't true), make sure
// the format is supported
if(ret == 0 || width == 0 || width == ~0U || height == 0 || height == ~0U)
{
FileIO::fclose(f);
return eReplayCreate_APIUnsupported;
}
byte *data = stbi_load_from_file(f, &ignore, &ignore, &ignore, 4);
if(!data)
{
FileIO::fclose(f);
RDCERR("File recognised, but couldn't load with stbi_load_from_file");
return eReplayCreate_FileCorrupted;
}
free(data);
}
FileIO::fclose(f);
IReplayDriver *proxy = NULL;
auto status = RenderDoc::Inst().CreateReplayDriver(RDC_Unknown, NULL, &proxy);
if(status != eReplayCreate_Success || !proxy)
{
if(proxy)
proxy->Shutdown();
return status;
}
*driver = new ImageViewer(proxy, logfile);
return eReplayCreate_Success;
}
void
ASCGLES2Texture::Load()
{
#ifdef __OBJC__
stbi_convert_iphone_png_to_rgb(1);
#endif
//Open the texture file
FILE* pFile = NULL;
#ifdef ASC_IOS
pFile = fopen(m_strTextureName.c_str(), "rb");
#else
fopen_s(&pFile, m_strTextureName.c_str(), "rb");
#endif
if(NULL == pFile)
{
assert_nowex("Guts, failed to load texture file: ", m_strTextureName);
m_bLoaded = false;
return;
}
UINT32 uForceChannels = 0;
SINT32 iChannels;
SINT32 iWidth;
SINT32 iHeight;
//Load in the texture data
UINT8* pImg = stbi_load_from_file(pFile, &iWidth, &iHeight, &iChannels, uForceChannels);
//Close the texture file
fclose( pFile );
if(NULL == pImg)
{
assert_nowex("Guts, failed to load texture because: ", stbi_failure_reason());
m_bLoaded = false;
return;
}
if( ( uForceChannels >= 1 ) && ( uForceChannels <= 4 ) )
{
iChannels = SC_SINT(uForceChannels);
}
m_uiWidth = iWidth;
m_uiHeight = iHeight;
//Generate the texture
glGenTextures(1, &m_uTextureID);
//Bind the texture
glBindTexture( GL_TEXTURE_2D, m_uTextureID );
UINT32 uTextureFormat = ( iChannels == 3 ) ? GL_RGB : GL_RGBA;
if(uTextureFormat != GL_RGBA)
{
//assert_now("Guts, Texture is not RGBA, dont realy want this");
}
glTexImage2D( GL_TEXTURE_2D, 0, uTextureFormat, m_uiWidth, m_uiHeight, 0, uTextureFormat, GL_UNSIGNED_BYTE, pImg);
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
glBindTexture( GL_TEXTURE_2D, 0 );
ASCMemoryManagement::ReleaseMemory(pImg, false);
m_bLoaded = true;
}
/* --- private --- */
void Texture2D::loadTextureData(const char* textureFile)
{
FILE* file = NULL;
file = fopen( textureFile, "rb");
if(file == NULL)
{
BREAKPOINT(Texture could not be loaded!);
return;
}
int x;
int y;
int numComponents;
m_textureData = stbi_load_from_file( file, &x, &y, &numComponents, 0);
fclose(file);
m_width = x;
m_height = y;
m_numComponents = numComponents;
m_componentSizeInBytes = 1;
m_isLocalDataAvailable = true;
}
}
void ImageViewer::RefreshFile()
{
FILE *f = NULL;
for(int attempt = 0; attempt < 10 && f == NULL; attempt++)
{
f = FileIO::fopen(m_Filename.c_str(), "rb");
if(f)
break;
Threading::Sleep(40);
}
if(!f)
{
RDCERR("Couldn't open %s! Exclusive lock elsewhere?", m_Filename.c_str());
return;
}
FetchTexture texDetails;
ResourceFormat rgba8_unorm;
rgba8_unorm.compByteWidth = 1;
rgba8_unorm.compCount = 4;
rgba8_unorm.compType = eCompType_UNorm;
rgba8_unorm.special = false;
ResourceFormat rgba32_float = rgba8_unorm;
rgba32_float.compByteWidth = 4;
rgba32_float.compType = eCompType_Float;
texDetails.creationFlags = eTextureCreate_SwapBuffer | eTextureCreate_RTV;
texDetails.cubemap = false;
texDetails.customName = true;
texDetails.name = m_Filename;
texDetails.ID = m_TextureID;
texDetails.byteSize = 0;
texDetails.msQual = 0;
texDetails.msSamp = 1;
texDetails.format = rgba8_unorm;
// reasonable defaults
texDetails.numSubresources = 1;
texDetails.dimension = 2;
texDetails.arraysize = 1;
texDetails.width = 1;
texDetails.height = 1;
texDetails.depth = 1;
texDetails.mips = 1;
byte *data = NULL;
size_t datasize = 0;
bool dds = false;
if(is_exr_file(f))
{
texDetails.format = rgba32_float;
FileIO::fseek64(f, 0, SEEK_END);
uint64_t size = FileIO::ftell64(f);
FileIO::fseek64(f, 0, SEEK_SET);
std::vector<byte> buffer;
buffer.resize((size_t)size);
FileIO::fread(&buffer[0], 1, buffer.size(), f);
FileIO::fclose(f);
EXRImage exrImage;
InitEXRImage(&exrImage);
const char *err = NULL;
int ret = ParseMultiChannelEXRHeaderFromMemory(&exrImage, &buffer[0], &err);
if(ret != 0)
{
RDCERR(
"EXR file detected, but couldn't load with ParseMultiChannelEXRHeaderFromMemory %d: '%s'",
ret, err);
return;
}
texDetails.width = exrImage.width;
texDetails.height = exrImage.height;
datasize = texDetails.width * texDetails.height * 4 * sizeof(float);
data = (byte *)malloc(datasize);
for(int i = 0; i < exrImage.num_channels; i++)
exrImage.requested_pixel_types[i] = TINYEXR_PIXELTYPE_FLOAT;
ret = LoadMultiChannelEXRFromMemory(&exrImage, &buffer[0], &err);
int channels[4] = {-1, -1, -1, -1};
for(int i = 0; i < exrImage.num_channels; i++)
{
switch(exrImage.channel_names[i][0])
{
case 'R': channels[0] = i; break;
case 'G': channels[1] = i; break;
case 'B': channels[2] = i; break;
case 'A': channels[3] = i; break;
}
}
float *rgba = (float *)data;
float **src = (float **)exrImage.images;
for(uint32_t i = 0; i < texDetails.width * texDetails.height; i++)
{
for(int c = 0; c < 4; c++)
{
if(channels[c] >= 0)
rgba[i * 4 + c] = src[channels[c]][i];
else if(c < 3) // RGB channels default to 0
rgba[i * 4 + c] = 0.0f;
else // alpha defaults to 1
rgba[i * 4 + c] = 1.0f;
}
}
FreeEXRImage(&exrImage);
// shouldn't get here but let's be safe
if(ret != 0)
{
free(data);
RDCERR("EXR file detected, but couldn't load with LoadEXRFromMemory %d: '%s'", ret, err);
return;
}
}
else if(stbi_is_hdr_from_file(f))
{
texDetails.format = rgba32_float;
FileIO::fseek64(f, 0, SEEK_SET);
int ignore = 0;
data = (byte *)stbi_loadf_from_file(f, (int *)&texDetails.width, (int *)&texDetails.height,
&ignore, 4);
datasize = texDetails.width * texDetails.height * 4 * sizeof(float);
}
else if(is_dds_file(f))
{
dds = true;
}
else
{
int ignore = 0;
int ret = stbi_info_from_file(f, (int *)&texDetails.width, (int *)&texDetails.height, &ignore);
// just in case (we shouldn't have come in here if this weren't true), make sure
// the format is supported
if(ret == 0 || texDetails.width == 0 || texDetails.width == ~0U || texDetails.height == 0 ||
texDetails.height == ~0U)
{
FileIO::fclose(f);
return;
}
texDetails.format = rgba8_unorm;
data = stbi_load_from_file(f, (int *)&texDetails.width, (int *)&texDetails.height, &ignore, 4);
datasize = texDetails.width * texDetails.height * 4 * sizeof(byte);
}
// if we don't have data at this point (and we're not a dds file) then the
// file was corrupted and we failed to load it
if(!dds && data == NULL)
{
FileIO::fclose(f);
return;
}
m_FrameRecord.frameInfo.initDataSize = 0;
m_FrameRecord.frameInfo.persistentSize = 0;
m_FrameRecord.frameInfo.fileSize = datasize;
dds_data read_data = {0};
if(dds)
{
FileIO::fseek64(f, 0, SEEK_SET);
read_data = load_dds_from_file(f);
if(read_data.subdata == NULL)
{
FileIO::fclose(f);
return;
}
texDetails.cubemap = read_data.cubemap;
texDetails.arraysize = read_data.slices;
texDetails.width = read_data.width;
texDetails.height = read_data.height;
texDetails.depth = read_data.depth;
texDetails.mips = read_data.mips;
texDetails.numSubresources = texDetails.arraysize * texDetails.mips;
texDetails.format = read_data.format;
texDetails.dimension = 1;
if(texDetails.width > 1)
texDetails.dimension = 2;
if(texDetails.depth > 1)
texDetails.dimension = 3;
m_FrameRecord.frameInfo.fileSize = 0;
for(uint32_t i = 0; i < texDetails.numSubresources; i++)
m_FrameRecord.frameInfo.fileSize += read_data.subsizes[i];
}
// recreate proxy texture if necessary.
// we rewrite the texture IDs so that the
// outside world doesn't need to know about this
// (we only ever have one texture in the image
// viewer so we can just set all texture IDs
// used to that).
if(m_TextureID != ResourceId())
{
if(m_TexDetails.width != texDetails.width || m_TexDetails.height != texDetails.height ||
m_TexDetails.depth != texDetails.depth || m_TexDetails.cubemap != texDetails.cubemap ||
m_TexDetails.mips != texDetails.mips || m_TexDetails.arraysize != texDetails.arraysize ||
m_TexDetails.width != texDetails.width || m_TexDetails.format != texDetails.format)
{
m_TextureID = ResourceId();
}
}
if(m_TextureID == ResourceId())
m_TextureID = m_Proxy->CreateProxyTexture(texDetails);
if(!dds)
{
m_Proxy->SetProxyTextureData(m_TextureID, 0, 0, data, datasize);
free(data);
}
else
{
for(uint32_t i = 0; i < texDetails.numSubresources; i++)
{
m_Proxy->SetProxyTextureData(m_TextureID, i / texDetails.mips, i % texDetails.mips,
read_data.subdata[i], (size_t)read_data.subsizes[i]);
delete[] read_data.subdata[i];
}
delete[] read_data.subdata;
delete[] read_data.subsizes;
}
FileIO::fclose(f);
}
void DGTexture::load() {
FILE* fh;
char magic[10]; // Used to identity file types
GLint format = 0, internalFormat = 0;
if (_isLoaded)
return;
if (!_hasResource) {
log->error(DGModTexture, "%s: %s", DGMsg210004, this->name());
return;
}
fh = fopen(_resource, "rb");
if (fh != NULL) {
if (fread(&magic, sizeof(magic), 1, fh) == 0) {
// Couldn't read magic number
log->error(DGModTexture, "%s: %s", DGMsg210002, _resource);
}
if (memcmp(TEXIdent, &magic, 7) == 0) {
short numTextures = 0;
TEXMainHeader header;
TEXSubHeader subheader;
GLint compressed, size;
fseek(fh, 8, SEEK_SET); // Skip identifier
if (!fread(&header, 1, sizeof(header), fh))
return;
numTextures = header.numTextures;
_width = (GLuint)header.width;
_height = (GLuint)header.height;
// Skip subheaders based on the index
if (_indexInBundle) {
unsigned int i;
for (i = 0; i < _indexInBundle; i++) {
if (!fread(&subheader, 1, sizeof(subheader), fh))
return;
fseek(fh, sizeof(char) * subheader.size, SEEK_CUR);
}
}
if (!fread(&subheader, 1, sizeof(subheader), fh))
return;
_depth = (GLuint)subheader.depth;
size = (GLint)subheader.size;
internalFormat = (GLint)subheader.format;
_bitmap = (GLubyte*)malloc(size * sizeof(GLubyte));
if (!fread(_bitmap, 1, sizeof(GLubyte) * size, fh))
return;
glGenTextures(1, &_ident);
glBindTexture(GL_TEXTURE_2D, _ident);
if (header.compressionLevel) {
glCompressedTexImage2D(GL_TEXTURE_2D, 0, internalFormat, _width, _height,
0, size, _bitmap);
glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_COMPRESSED, &compressed);
if (compressed == GL_TRUE)
_isLoaded = true;
else
log->error(DGModTexture, "%s: %s", DGMsg210002, fh);
}
else {
glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, _width, _height, 0, GL_RGB, GL_UNSIGNED_BYTE, _bitmap); // Only RGB is supported
_isLoaded = true;
}
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_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
free(_bitmap);
}
else {
int x, y, comp;
fseek(fh, 0, SEEK_SET);
_bitmap = (GLubyte*)stbi_load_from_file(fh, &x, &y, &comp, STBI_default);
if (_bitmap) {
_width = x;
_height = y;
_depth = comp;
switch (comp) {
case STBI_grey:
format = GL_LUMINANCE;
if (_compressionLevel)
internalFormat = GL_COMPRESSED_LUMINANCE;
else
internalFormat = GL_LUMINANCE;
break;
case STBI_grey_alpha:
format = GL_LUMINANCE_ALPHA;
if (_compressionLevel)
internalFormat = GL_COMPRESSED_LUMINANCE_ALPHA;
else
internalFormat = GL_LUMINANCE_ALPHA;
break;
case STBI_rgb:
format = GL_RGB;
if (_compressionLevel)
internalFormat = GL_COMPRESSED_RGB;
else
internalFormat = GL_RGB;
break;
case STBI_rgb_alpha:
format = GL_RGBA;
if (_compressionLevel)
internalFormat = GL_COMPRESSED_RGBA;
else
internalFormat = GL_RGBA;
break;
default:
log->warning(DGModTexture, "%s: (%s) %d", DGMsg210003, _resource, comp);
break;
}
glGenTextures(1, &_ident);
glBindTexture(GL_TEXTURE_2D, _ident);
glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, _width, _height,
0, format, GL_UNSIGNED_BYTE, _bitmap);
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_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
free(_bitmap);
_isLoaded = true;
}
else {
// Nothing loaded
log->error(DGModTexture, "%s: (%s) %s", DGMsg210001, _resource, stbi_failure_reason());
}
}
fclose(fh);
}
else {
// File not found
log->error(DGModTexture, "%s: %s", DGMsg210000, _resource);
}
}
