blender/source/gameengine/Ketsji/BL_Texture.cpp
2011-12-30 11:49:58 +00:00

685 lines
16 KiB
C++

/** \file gameengine/Ketsji/BL_Texture.cpp
* \ingroup ketsji
*/
// ------------------------------------
#include "GL/glew.h"
#include <iostream>
#include <map>
#include <stdlib.h>
#include "BL_Material.h"
#include "BL_Texture.h"
#include "MT_assert.h"
#include "DNA_texture_types.h"
#include "DNA_image_types.h"
#include "IMB_imbuf_types.h"
#include "BKE_image.h"
#include "BLI_blenlib.h"
#include "RAS_OpenGLRasterizer/RAS_GLExtensionManager.h"
#include "RAS_ICanvas.h"
#include "RAS_Rect.h"
#include "KX_GameObject.h"
#define spit(x) std::cout << x << std::endl;
#include "MEM_guardedalloc.h"
#include "GPU_draw.h"
extern "C" {
// envmaps
#include "IMB_imbuf.h"
void my_envmap_split_ima(EnvMap *env, ImBuf *ibuf);
void my_free_envmapdata(EnvMap *env);
}
// (n&(n-1)) zeros the least significant bit of n
static int is_power_of_2_i(int num)
{
return ((num)&(num-1))==0;
}
static int power_of_2_min_i(int num)
{
while (!is_power_of_2_i(num))
num= num&(num-1);
return num;
}
// Place holder for a full texture manager
class BL_TextureObject
{
public:
unsigned int gl_texture;
void* ref_buffer;
};
typedef std::map<char*, BL_TextureObject> BL_TextureMap;
static BL_TextureMap g_textureManager;
BL_Texture::BL_Texture()
: mTexture(0),
mOk(0),
mNeedsDeleted(0),
mType(0),
mUnit(0),
mEnvState(0)
{
// --
}
BL_Texture::~BL_Texture()
{
// --
}
void BL_Texture::DeleteTex()
{
if( mNeedsDeleted ) {
glDeleteTextures(1, (GLuint*)&mTexture);
mNeedsDeleted = 0;
mOk = 0;
}
if(mEnvState) {
glDeleteLists((GLuint)mEnvState, 1);
mEnvState =0;
}
if(mDisableState) {
glDeleteLists((GLuint)mDisableState, 1);
mDisableState =0;
}
g_textureManager.clear();
}
bool BL_Texture::InitFromImage(int unit, Image *img, bool mipmap)
{
ImBuf *ibuf;
if (!img || img->ok==0)
{
mOk = false;
return mOk;
}
ibuf= BKE_image_get_ibuf(img, NULL);
if (ibuf==NULL)
{
img->ok = 0;
mOk = false;
return mOk;
}
mTexture = img->bindcode;
mType = GL_TEXTURE_2D;
mUnit = unit;
ActivateUnit(mUnit);
if (mTexture != 0) {
glBindTexture(GL_TEXTURE_2D, mTexture );
Validate();
return mOk;
}
// look for an existing gl image
BL_TextureMap::iterator mapLook = g_textureManager.find(img->id.name);
if (mapLook != g_textureManager.end())
{
if (mapLook->second.gl_texture != 0)
{
mTexture = mapLook->second.gl_texture;
glBindTexture(GL_TEXTURE_2D, mTexture);
mOk = IsValid();
return mOk;
}
}
mNeedsDeleted = 1;
glGenTextures(1, (GLuint*)&mTexture);
InitGLTex(ibuf->rect, ibuf->x, ibuf->y, mipmap);
// track created units
BL_TextureObject obj;
obj.gl_texture = mTexture;
obj.ref_buffer = img;
g_textureManager.insert(std::pair<char*, BL_TextureObject>((char*)img->id.name, obj));
glDisable(GL_TEXTURE_2D);
ActivateUnit(0);
Validate();
return mOk;
}
void BL_Texture::InitGLTex(unsigned int *pix,int x,int y,bool mipmap)
{
if (!is_power_of_2_i(x) || !is_power_of_2_i(y) ) {
InitNonPow2Tex(pix, x,y,mipmap);
return;
}
glBindTexture(GL_TEXTURE_2D, mTexture );
if( mipmap ) {
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
gluBuild2DMipmaps( GL_TEXTURE_2D, GL_RGBA, x, y, GL_RGBA, GL_UNSIGNED_BYTE, pix );
}
else {
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, x, y, 0, GL_RGBA, GL_UNSIGNED_BYTE, pix );
}
if (GLEW_EXT_texture_filter_anisotropic)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, GPU_get_anisotropic());
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
}
void BL_Texture::InitNonPow2Tex(unsigned int *pix,int x,int y,bool mipmap)
{
int nx= power_of_2_min_i(x);
int ny= power_of_2_min_i(y);
unsigned int *newPixels = (unsigned int *)malloc(nx*ny*sizeof(unsigned int));
gluScaleImage(GL_RGBA, x, y, GL_UNSIGNED_BYTE, pix, nx,ny, GL_UNSIGNED_BYTE, newPixels);
glBindTexture(GL_TEXTURE_2D, mTexture );
if( mipmap ) {
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
gluBuild2DMipmaps( GL_TEXTURE_2D, GL_RGBA, nx, ny, GL_RGBA, GL_UNSIGNED_BYTE, newPixels );
}
else {
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, nx, ny, 0, GL_RGBA, GL_UNSIGNED_BYTE, newPixels );
}
if (GLEW_EXT_texture_filter_anisotropic)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, GPU_get_anisotropic());
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
free(newPixels);
}
bool BL_Texture::InitCubeMap(int unit, EnvMap *cubemap)
{
if (!GLEW_ARB_texture_cube_map)
{
spit("cubemaps not supported");
mOk = false;
return mOk;
}
else if (!cubemap || cubemap->ima->ok==0)
{
mOk = false;
return mOk;
}
ImBuf *ibuf= BKE_image_get_ibuf(cubemap->ima, NULL);
if (ibuf==0)
{
cubemap->ima->ok = 0;
mOk = false;
return mOk;
}
mNeedsDeleted = 1;
mType = GL_TEXTURE_CUBE_MAP_ARB;
mTexture = 0;
mUnit = unit;
ActivateUnit(mUnit);
BL_TextureMap::iterator mapLook = g_textureManager.find(cubemap->ima->id.name);
if (mapLook != g_textureManager.end())
{
if (mapLook->second.gl_texture != 0 && mapLook->second.ref_buffer == cubemap->ima)
{
mTexture = mapLook->second.gl_texture;
glBindTexture(GL_TEXTURE_CUBE_MAP_ARB, mTexture);
mOk = IsValid();
return mOk;
}
}
glGenTextures(1, (GLuint*)&mTexture);
glBindTexture(GL_TEXTURE_CUBE_MAP_ARB, mTexture);
// track created units
BL_TextureObject obj;
obj.gl_texture = mTexture;
obj.ref_buffer = cubemap->ima;
g_textureManager.insert(std::pair<char*, BL_TextureObject>((char*)cubemap->ima->id.name, obj));
bool needs_split = false;
if (!cubemap->cube[0])
{
needs_split = true;
spit ("Re-Generating texture buffer");
}
if (needs_split)
my_envmap_split_ima(cubemap, ibuf);
if (!is_power_of_2_i(cubemap->cube[0]->x) || !is_power_of_2_i(cubemap->cube[0]->y))
{
spit("invalid envmap size please render with CubeRes @ power of two");
my_free_envmapdata(cubemap);
mOk = false;
return mOk;
}
#define SetCubeMapFace(face, num) \
glTexImage2D(face, 0,GL_RGBA, \
cubemap->cube[num]->x, \
cubemap->cube[num]->y, \
0, GL_RGBA, GL_UNSIGNED_BYTE, \
cubemap->cube[num]->rect)
SetCubeMapFace(GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB, 5);
SetCubeMapFace(GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB, 3);
SetCubeMapFace(GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB, 0);
SetCubeMapFace(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB, 1);
SetCubeMapFace(GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB, 2);
SetCubeMapFace(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB, 4);
glTexParameteri( GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
glTexParameteri( GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glTexParameteri( GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
glTexParameteri( GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
if(GLEW_VERSION_1_2)
glTexParameteri( GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE );
if (needs_split)
my_free_envmapdata(cubemap);
glDisable(GL_TEXTURE_CUBE_MAP_ARB);
ActivateUnit(0);
mOk = IsValid();
return mOk;
}
bool BL_Texture::IsValid()
{
return (mTexture!= 0)?glIsTexture(mTexture)!=0:false;
}
void BL_Texture::Validate()
{
mOk = IsValid();
}
bool BL_Texture::Ok()
{
return (mTexture!= 0);
}
unsigned int BL_Texture::GetTextureType() const
{
return mType;
}
int BL_Texture::GetMaxUnits()
{
GLint unit=0;
if(GLEW_ARB_multitexture) {
glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &unit);
return (MAXTEX>=unit?unit:MAXTEX);
}
return 0;
}
void BL_Texture::ActivateFirst()
{
if(GLEW_ARB_multitexture)
glActiveTextureARB(GL_TEXTURE0_ARB);
}
void BL_Texture::ActivateUnit(int unit)
{
if(GLEW_ARB_multitexture)
if(unit <= MAXTEX)
glActiveTextureARB(GL_TEXTURE0_ARB+unit);
}
void BL_Texture::DisableUnit()
{
if(GLEW_ARB_multitexture)
glActiveTextureARB(GL_TEXTURE0_ARB+mUnit);
glMatrixMode(GL_TEXTURE);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
if(GLEW_ARB_texture_cube_map && glIsEnabled(GL_TEXTURE_CUBE_MAP_ARB))
glDisable(GL_TEXTURE_CUBE_MAP_ARB);
else
{
if (glIsEnabled(GL_TEXTURE_2D))
glDisable(GL_TEXTURE_2D);
}
glDisable(GL_TEXTURE_GEN_S);
glDisable(GL_TEXTURE_GEN_T);
glDisable(GL_TEXTURE_GEN_R);
glDisable(GL_TEXTURE_GEN_Q);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
}
void BL_Texture::DisableAllTextures()
{
for(int i=0; i<MAXTEX; i++) {
if(GLEW_ARB_multitexture)
glActiveTextureARB(GL_TEXTURE0_ARB+i);
glMatrixMode(GL_TEXTURE);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glDisable(GL_TEXTURE_2D);
glDisable(GL_TEXTURE_GEN_S);
glDisable(GL_TEXTURE_GEN_T);
glDisable(GL_TEXTURE_GEN_R);
glDisable(GL_TEXTURE_GEN_Q);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
}
if(GLEW_ARB_multitexture)
glActiveTextureARB(GL_TEXTURE0_ARB);
}
void BL_Texture::ActivateTexture()
{
if(GLEW_ARB_multitexture)
glActiveTextureARB(GL_TEXTURE0_ARB+mUnit);
if (mType == GL_TEXTURE_CUBE_MAP_ARB && GLEW_ARB_texture_cube_map)
{
glBindTexture( GL_TEXTURE_CUBE_MAP_ARB, mTexture );
glEnable(GL_TEXTURE_CUBE_MAP_ARB);
}
else {
if(GLEW_ARB_texture_cube_map )
glDisable(GL_TEXTURE_CUBE_MAP_ARB);
glBindTexture( GL_TEXTURE_2D, mTexture );
glEnable(GL_TEXTURE_2D);
}
}
void BL_Texture::SetMapping(int mode)
{
if(!(mode &USEREFL)) {
glDisable(GL_TEXTURE_GEN_S);
glDisable(GL_TEXTURE_GEN_T);
glDisable(GL_TEXTURE_GEN_R);
glDisable(GL_TEXTURE_GEN_Q);
return;
}
if( mType == GL_TEXTURE_CUBE_MAP_ARB &&
GLEW_ARB_texture_cube_map &&
mode &USEREFL)
{
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_ARB );
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_ARB );
glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_ARB );
glEnable(GL_TEXTURE_GEN_S);
glEnable(GL_TEXTURE_GEN_T);
glEnable(GL_TEXTURE_GEN_R);
glDisable(GL_TEXTURE_GEN_Q);
return;
}
else
{
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP );
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP );
glEnable(GL_TEXTURE_GEN_S);
glEnable(GL_TEXTURE_GEN_T);
glDisable(GL_TEXTURE_GEN_R);
glDisable(GL_TEXTURE_GEN_Q);
}
}
void BL_Texture::setTexEnv(BL_Material *mat, bool modulate)
{
if(modulate || !GLEW_ARB_texture_env_combine){
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
return;
}
if(glIsList(mEnvState))
{
glCallList(mEnvState);
return;
}
if(!mEnvState)
mEnvState = glGenLists(1);
glNewList(mEnvState, GL_COMPILE_AND_EXECUTE);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB );
GLfloat blend_operand = GL_SRC_COLOR;
GLfloat blend_operand_prev = GL_SRC_COLOR;
GLfloat alphaOp = GL_SRC_ALPHA;
GLenum combiner = GL_COMBINE_RGB_ARB;
GLenum source0 = GL_SOURCE0_RGB_ARB;
GLenum source1 = GL_SOURCE1_RGB_ARB;
GLenum source2 = GL_SOURCE2_RGB_ARB;
GLenum op0 = GL_OPERAND0_RGB_ARB;
GLenum op1 = GL_OPERAND1_RGB_ARB;
GLenum op2 = GL_OPERAND2_RGB_ARB;
// switch to alpha combiners
if( mat->flag[mUnit] &TEXALPHA ) {
combiner = GL_COMBINE_ALPHA_ARB;
source0 = GL_SOURCE0_ALPHA_ARB;
source1 = GL_SOURCE1_ALPHA_ARB;
source2 = GL_SOURCE2_ALPHA_ARB;
op0 = GL_OPERAND0_ALPHA_ARB;
op1 = GL_OPERAND1_ALPHA_ARB;
op2 = GL_OPERAND2_ALPHA_ARB;
blend_operand = GL_SRC_ALPHA;
blend_operand_prev = GL_SRC_ALPHA;
// invert
if(mat->flag[mUnit] &TEXNEG) {
blend_operand_prev = GL_ONE_MINUS_SRC_ALPHA;
blend_operand = GL_ONE_MINUS_SRC_ALPHA;
}
}
else {
if(mat->flag[mUnit] &TEXNEG) {
blend_operand_prev=GL_ONE_MINUS_SRC_COLOR;
blend_operand = GL_ONE_MINUS_SRC_COLOR;
}
}
bool using_alpha = false;
if(mat->flag[mUnit] &USEALPHA){
alphaOp = GL_ONE_MINUS_SRC_ALPHA;
using_alpha=true;
}
else if(mat->flag[mUnit] &USENEGALPHA){
alphaOp = GL_SRC_ALPHA;
using_alpha = true;
}
switch( mat->blend_mode[mUnit] ) {
case BLEND_MIX:
{
// ------------------------------
if(!using_alpha) {
GLfloat base_col[4];
base_col[0] = base_col[1] = base_col[2] = 0.f;
base_col[3] = 1.f-mat->color_blend[mUnit];
glTexEnvfv( GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR,base_col );
}
glTexEnvf( GL_TEXTURE_ENV, combiner, GL_INTERPOLATE_ARB);
glTexEnvf( GL_TEXTURE_ENV, source0, GL_PREVIOUS_ARB);
glTexEnvf( GL_TEXTURE_ENV, op0, blend_operand_prev );
glTexEnvf( GL_TEXTURE_ENV, source1, GL_TEXTURE );
glTexEnvf( GL_TEXTURE_ENV, op1, blend_operand);
if(!using_alpha)
glTexEnvf( GL_TEXTURE_ENV, source2, GL_CONSTANT_ARB );
else
glTexEnvf( GL_TEXTURE_ENV, source2, GL_TEXTURE );
glTexEnvf( GL_TEXTURE_ENV, op2, alphaOp);
}break;
case BLEND_MUL:
{
// ------------------------------
glTexEnvf( GL_TEXTURE_ENV, combiner, GL_MODULATE);
glTexEnvf( GL_TEXTURE_ENV, source0, GL_PREVIOUS_ARB);
glTexEnvf( GL_TEXTURE_ENV, op0, blend_operand_prev);
glTexEnvf( GL_TEXTURE_ENV, source1, GL_TEXTURE );
if(using_alpha)
glTexEnvf( GL_TEXTURE_ENV, op1, alphaOp);
else
glTexEnvf( GL_TEXTURE_ENV, op1, blend_operand);
}break;
case BLEND_ADD:
{
// ------------------------------
glTexEnvf( GL_TEXTURE_ENV, combiner, GL_ADD_SIGNED_ARB);
glTexEnvf( GL_TEXTURE_ENV, source0, GL_PREVIOUS_ARB );
glTexEnvf( GL_TEXTURE_ENV, op0, blend_operand_prev );
glTexEnvf( GL_TEXTURE_ENV, source1, GL_TEXTURE );
if(using_alpha)
glTexEnvf( GL_TEXTURE_ENV, op1, alphaOp);
else
glTexEnvf( GL_TEXTURE_ENV, op1, blend_operand);
}break;
case BLEND_SUB:
{
// ------------------------------
glTexEnvf( GL_TEXTURE_ENV, combiner, GL_SUBTRACT_ARB);
glTexEnvf( GL_TEXTURE_ENV, source0, GL_PREVIOUS_ARB );
glTexEnvf( GL_TEXTURE_ENV, op0, blend_operand_prev );
glTexEnvf( GL_TEXTURE_ENV, source1, GL_TEXTURE );
glTexEnvf( GL_TEXTURE_ENV, op1, blend_operand);
}break;
case BLEND_SCR:
{
// ------------------------------
glTexEnvf( GL_TEXTURE_ENV, combiner, GL_ADD);
glTexEnvf( GL_TEXTURE_ENV, source0, GL_PREVIOUS_ARB );
glTexEnvf( GL_TEXTURE_ENV, op0, blend_operand_prev );
glTexEnvf( GL_TEXTURE_ENV, source1, GL_TEXTURE );
if(using_alpha)
glTexEnvf( GL_TEXTURE_ENV, op1, alphaOp);
else
glTexEnvf( GL_TEXTURE_ENV, op1, blend_operand);
} break;
}
glTexEnvf( GL_TEXTURE_ENV, GL_RGB_SCALE_ARB, 1.0);
glEndList();
}
int BL_Texture::GetPow2(int n)
{
if(!is_power_of_2_i(n))
n = power_of_2_min_i(n);
return n;
}
void BL_Texture::SplitEnvMap(EnvMap *map)
{
if (!map || !map->ima || (map->ima && !map->ima->ok)) return;
ImBuf *ibuf= BKE_image_get_ibuf(map->ima, NULL);
if (ibuf)
my_envmap_split_ima(map, ibuf);
}
unsigned int BL_Texture::mDisableState = 0;
extern "C" {
void my_envmap_split_ima(EnvMap *env, ImBuf *ibuf)
{
int dx, part;
my_free_envmapdata(env);
dx= ibuf->y;
dx/= 2;
if(3*dx != ibuf->x) {
printf("Incorrect envmap size\n");
env->ok= 0;
env->ima->ok= 0;
}
else {
for(part=0; part<6; part++) {
env->cube[part]= IMB_allocImBuf(dx, dx, 24, IB_rect);
}
IMB_rectcpy(env->cube[0], ibuf,
0, 0, 0, 0, dx, dx);
IMB_rectcpy(env->cube[1], ibuf,
0, 0, dx, 0, dx, dx);
IMB_rectcpy(env->cube[2], ibuf,
0, 0, 2*dx, 0, dx, dx);
IMB_rectcpy(env->cube[3], ibuf,
0, 0, 0, dx, dx, dx);
IMB_rectcpy(env->cube[4], ibuf,
0, 0, dx, dx, dx, dx);
IMB_rectcpy(env->cube[5], ibuf,
0, 0, 2*dx, dx, dx, dx);
env->ok= 2;// ENV_OSA
}
}
void my_free_envmapdata(EnvMap *env)
{
unsigned int part;
for(part=0; part<6; part++) {
ImBuf *ibuf= env->cube[part];
if(ibuf) {
IMB_freeImBuf(ibuf);
env->cube[part]= NULL;
}
}
env->ok= 0;
}
} // extern C