// 表示の初期化
void initCube(struct engine* engine) {
// 法線ベクトル有効化
glEnable(GL_NORMALIZE);
// デプステスト有効化
glEnable(GL_DEPTH_TEST);
// 面の破棄処理有効化
glEnable(GL_CULL_FACE);
// 背面を破棄する
glCullFace(GL_BACK);
// 陰影モード設定
glShadeModel(GL_SMOOTH);
// 利用するテクスチャは非圧縮とする
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
// テクスチャ割当を生成
glGenTextures(1, &texName[0]);
glBindTexture(GL_TEXTURE_2D, &texName[0]);
// テクスチャ表示設定
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
png_uint_32 width,height;
GLint type;
GLubyte *textureImage;
// PNG画像をOpenGL|ESのテクスチャとしてロードする(AssetManager経由)
loadPngImage(engine->assetManager, "texture.png", &width, &height, &type, &textureImage);
// テクスチャーデータを割り当てる
glTexImage2D(GL_TEXTURE_2D, 0, type, width, height, 0, type, GL_UNSIGNED_BYTE, textureImage);
}
static int loadThemeImage(const char *image)
{
char dirspec[256];
int i;
uint16_t width;
uint16_t height;
uint8_t *imagedata;
if ((strlen(image) + strlen(theme_name) + 20 ) > sizeof(dirspec)) {
return 1;
}
for (i=0; i < sizeof(images) / sizeof(images[0]); i++) {
if (strcmp(image, images[i].name) == 0) {
if (images[i].image == NULL) {
images[i].image = MALLOC(sizeof(pixmap_t));
}
sprintf(dirspec,"/Extra/Themes/%s/%s.png", theme_name, image);
width = 0;
height = 0;
imagedata = NULL;
if ((loadPngImage(dirspec, &width, &height, &imagedata)) != 0) {
printf("ERROR: GUI: could not open '%s/%s.png'!\n", theme_name, image);
sleep(5);
return 1;
}
images[i].image->width = width;
images[i].image->height = height;
images[i].image->pixels = (pixel_t *)imagedata;
flipRB(images[i].image);
return 0;
}
}
return 1;
}
void initTexture(int textureIndex, char fileName[])
{
glBindTexture ( GL_TEXTURE_2D, texture_id[textureIndex] );
//free (textureImage);
int height, width;
bool hasAlpha;
bool success = loadPngImage(fileName, width, height, hasAlpha, &textureImage);
if (!success) {
std::cout << "Unable to load png file" << std::endl;
return;
}
std::cout << "Image loaded " << width << " " << height << " alpha " << hasAlpha << std::endl;
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glTexImage2D(GL_TEXTURE_2D, 0, hasAlpha ? 4 : 3, width,
height, 0, hasAlpha ? GL_RGBA : GL_RGB, GL_UNSIGNED_BYTE,
textureImage);
//free (textureImage);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
free (textureImage);
}
void init(void) {
GLubyte *textureImage;
glClearColor(0.0, 0.0, 0.0, 0.0);
glEnable(GL_DEPTH_TEST);
// The following two lines enable semi transparent
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
int width, height;
bool hasAlpha;
char filename[] = "logo.png";
bool success = loadPngImage(filename, width, height, hasAlpha, &textureImage);
if (!success) {
std::cout << "Unable to load png file" << std::endl;
return;
}
std::cout << "Image loaded " << width << " " << height << " alpha " << hasAlpha << std::endl;
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width,
height, 0, GL_RGBA, GL_UNSIGNED_BYTE,
textureImage);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glEnable(GL_TEXTURE_2D);
glShadeModel(GL_FLAT);
}
bool Image::Load(char* pathToFile)
{
m_width = -1;
m_width = -1;
m_hasAlpha = false;
// further must be changed
bool ret = loadPngImage(pathToFile, m_width, m_height, m_hasAlpha, m_buffer);
return ret;
}
bool loadPngTexture(const char* filename, int& width, int& height, bool& alpha, unsigned char*& tex)
{
if (loadPngImage(filename, width, height, alpha, tex))
{
return true;
}
else
{
width = 0;
height = 0;
alpha = false;
tex = 0;
return false;
}
}
bool CGLCG::LoadShader(const TCHAR *shaderFile)
{
CCGShader cgShader;
TCHAR shaderPath[MAX_PATH];
TCHAR tempPath[MAX_PATH];
CGprofile vertexProfile, fragmentProfile;
GLenum error;
if(!fboFunctionsLoaded) {
MessageBox(NULL, TEXT("Your OpenGL graphics driver does not support framebuffer objects.\nYou will not be able to use CG shaders in OpenGL mode."), TEXT("CG Error"),
MB_OK|MB_ICONEXCLAMATION);
return false;
}
vertexProfile = cgGLGetLatestProfile(CG_GL_VERTEX);
fragmentProfile = cgGLGetLatestProfile(CG_GL_FRAGMENT);
cgGLDisableProfile(vertexProfile);
cgGLDisableProfile(fragmentProfile);
ClearPasses();
if (shaderFile == NULL || *shaderFile==TEXT('\0'))
return true;
lstrcpy(shaderPath, shaderFile);
ReduceToPath(shaderPath);
SetCurrentDirectory(shaderPath);
if(!cgShader.LoadShader(_tToChar(shaderFile)))
return false;
cgGLSetOptimalOptions(vertexProfile);
cgGLSetOptimalOptions(fragmentProfile);
/* insert dummy pass that will contain the original texture
*/
shaderPasses.push_back(shaderPass());
for(CCGShader::passVector::iterator it=cgShader.shaderPasses.begin();
it!=cgShader.shaderPasses.end();it++) {
shaderPass pass;
pass.scaleParams = it->scaleParams;
/* if this is the last pass (the only one that can have CG_SCALE_NONE)
and no filter has been set use the GUI setting
*/
if(pass.scaleParams.scaleTypeX==CG_SCALE_NONE && !it->filterSet) {
pass.linearFilter = GUI.BilinearFilter;
} else {
pass.linearFilter = it->linearFilter;
}
pass.frameCounterMod = it->frameCounterMod;
pass.floatFbo = it->floatFbo;
// paths in the meta file can be relative
_tfullpath(tempPath,_tFromChar(it->cgShaderFile),MAX_PATH);
char *fileContents = ReadShaderFileContents(tempPath);
if(!fileContents)
return false;
// individual shader might include files, these should be relative to shader
ReduceToPath(tempPath);
SetCurrentDirectory(tempPath);
pass.cgVertexProgram = cgCreateProgram( cgContext, CG_SOURCE, fileContents,
vertexProfile, "main_vertex", NULL);
checkForCgError("Compiling vertex program");
pass.cgFragmentProgram = cgCreateProgram( cgContext, CG_SOURCE, fileContents,
fragmentProfile, "main_fragment", NULL);
checkForCgError("Compiling fragment program");
// set path back for next pass
SetCurrentDirectory(shaderPath);
delete [] fileContents;
if(!pass.cgVertexProgram || !pass.cgFragmentProgram) {
return false;
}
cgGLLoadProgram(pass.cgVertexProgram);
cgGLLoadProgram(pass.cgFragmentProgram);
/* generate framebuffer and texture for this pass and apply
default texture settings
*/
glGenFramebuffers(1,&pass.fbo);
glGenTextures(1,&pass.tex);
glBindTexture(GL_TEXTURE_2D,pass.tex);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
shaderPasses.push_back(pass);
}
for(std::vector<CCGShader::lookupTexture>::iterator it=cgShader.lookupTextures.begin();it!=cgShader.lookupTextures.end();it++) {
lookupTexture tex;
strcpy(tex.id,it->id);
/* generate texture for the lut and apply specified filter setting
*/
glGenTextures(1,&tex.tex);
glBindTexture(GL_TEXTURE_2D,tex.tex);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, it->linearfilter?GL_LINEAR:GL_NEAREST);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, it->linearfilter?GL_LINEAR:GL_NEAREST);
_tfullpath(tempPath,_tFromChar(it->texturePath),MAX_PATH);
// simple file extension png/tga decision
int strLen = strlen(it->texturePath);
if(strLen>4) {
if(!strcasecmp(&it->texturePath[strLen-4],".png")) {
int width, height;
bool hasAlpha;
GLubyte *texData;
if(loadPngImage(tempPath,width,height,hasAlpha,&texData)) {
glPixelStorei(GL_UNPACK_ROW_LENGTH, width);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width,
height, 0, hasAlpha ? GL_RGBA : GL_RGB, GL_UNSIGNED_BYTE, texData);
free(texData);
}
} else if(!strcasecmp(&it->texturePath[strLen-4],".tga")) {
STGA stga;
if(loadTGA(tempPath,stga)) {
glPixelStorei(GL_UNPACK_ROW_LENGTH, stga.width);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, stga.width,
stga.height, 0, GL_RGBA, GL_UNSIGNED_BYTE, stga.data);
}
}
}
lookupTextures.push_back(tex);
}
/* enable texture unit 1 for the lookup textures
*/
glClientActiveTexture(GL_TEXTURE1);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2,GL_FLOAT,0,lut_coords);
glClientActiveTexture(GL_TEXTURE0);
/* generate textures and set default values for the pref-filled PREV deque.
*/
for(int i=0;i<prevPasses.size();i++) {
glGenTextures(1,&prevPasses[i].tex);
glBindTexture(GL_TEXTURE_2D,prevPasses[i].tex);
glTexImage2D(GL_TEXTURE_2D,0,GL_RGB,512,512,0,GL_RGB,GL_UNSIGNED_SHORT_5_6_5,NULL);
glBindTexture(GL_TEXTURE_2D,0);
prevPasses[i].textureSize.x = prevPasses[i].textureSize.y = prevPasses[i].textureSize.x = prevPasses[i].textureSize.y = 0;
memset(prevPasses[i].texCoords,0,sizeof(prevPasses[i].texCoords));
}
shaderLoaded = true;
return true;
}
void readTex(const std::string &fileName) {
std::string filePath = fileName;
int w, h;
png_bytepp p = readpng(filePath.c_str(), &w, &h);
/*
gData = new unsigned char [w * h * 3];
for(int y=0; y<h; y++) {
png_bytep r = p[h-1-y]; // get the row
for (int x = 0; x < 3*w; x += 3) {
int index = x + (3 * w * y);
gData[index] = r[x];
gData[index + 1] = r[x+1];
gData[index + 2] = r[x+2];
//std::cout << index << " " << int(r[x]) << std::endl;
//std::cout << index + 1 << " " << int(r[x+1]) << std::endl;
//std::cout << index + 2 << " " << int(r[x+2]) << std::endl;
}
}
*/
std::cout << "READ" << std::endl;
//gWidth = w;
//gHeight = h;
GLubyte *textureImage;
int width, height;
bool hasAlpha;
//char filename[] = "yoshihq2x.png";
//char filename[] = "yoshi_side.png";
char *filename = new char[filePath.size()+1];
filename[filePath.size()]=0;
memcpy(filename,filePath.c_str(),filePath.size());
bool success = loadPngImage(filename, width, height, hasAlpha, &textureImage);
if (!success) {
std::cout << "Unable to load png file" << std::endl;
return;
}
gWidth = width;
gHeight = height;
gData = new unsigned char [width * height * 4];
std::cout << "Image loaded " << width << " " << height << " alpha " << hasAlpha << std::endl;
int count = 0;
for (int i = 0; i < width * height; i++) {
if (hasAlpha) {
gData[4*i] = textureImage[4*i];
gData[4*i + 1] = textureImage[4*i + 1];
gData[4*i + 2] = textureImage[4*i + 2];
gData[4*i + 3] = textureImage[4*i + 3];
} else {
gData[4*i] = textureImage[3*i]; // since textureImage now is just RGB
gData[4*i + 1] = textureImage[3*i + 1];
gData[4*i + 2] = textureImage[3*i + 2];
gData[4*i + 3] = 0;
}
//std::cout << i << " "<< int(textureImage[i]) << std::endl;
/*
if (i % 4 == 0) {
continue;
} else {
gData[count] = textureImage[i];
count++;
}
*/
}
}
