mirror of
https://github.com/glest/glest-source.git
synced 2025-09-30 09:29:25 +02:00
Made changes to properly isolate new unit rotation code so that it is disabled by default
This commit is contained in:
Mark Vejvoda
151
source/shared_lib/sources/graphics/gl/opengl.cpp
Normal file
151
source/shared_lib/sources/graphics/gl/opengl.cpp
Normal file
@@ -0,0 +1,151 @@
|
||||
// ==============================================================
|
||||
// This file is part of Glest Shared Library (www.glest.org)
|
||||
//
|
||||
// Copyright (C) 2001-2008 Marti<74>o Figueroa
|
||||
//
|
||||
// You can redistribute this code and/or modify it under
|
||||
// the terms of the GNU General Public License as published
|
||||
// by the Free Software Foundation; either version 2 of the
|
||||
// License, or (at your option) any later version
|
||||
// ==============================================================
|
||||
|
||||
#include "opengl.h"
|
||||
|
||||
#include <stdexcept>
|
||||
|
||||
#include "graphics_interface.h"
|
||||
#include "context_gl.h"
|
||||
#include "gl_wrap.h"
|
||||
#include "leak_dumper.h"
|
||||
|
||||
using namespace Shared::Platform;
|
||||
using namespace std;
|
||||
|
||||
namespace Shared{ namespace Graphics{ namespace Gl{
|
||||
|
||||
// =====================================================
|
||||
// class Globals
|
||||
// =====================================================
|
||||
|
||||
bool isGlExtensionSupported(const char *extensionName){
|
||||
const char *s;
|
||||
GLint len;
|
||||
const GLubyte *extensionStr= glGetString(GL_EXTENSIONS);
|
||||
|
||||
s= reinterpret_cast<const char *>(extensionStr);
|
||||
len= strlen(extensionName);
|
||||
|
||||
if(s != NULL) {
|
||||
while ((s = strstr (s, extensionName)) != NULL) {
|
||||
s+= len;
|
||||
if((*s == ' ') || (*s == '\0')) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
bool isGlVersionSupported(int major, int minor, int release){
|
||||
|
||||
const char *strVersion= getGlVersion();
|
||||
|
||||
//major
|
||||
const char *majorTok= strVersion;
|
||||
int majorSupported= atoi(majorTok);
|
||||
|
||||
if(majorSupported<major){
|
||||
return false;
|
||||
}
|
||||
else if(majorSupported>major){
|
||||
return true;
|
||||
}
|
||||
|
||||
//minor
|
||||
int i=0;
|
||||
while(strVersion[i]!='.'){
|
||||
++i;
|
||||
}
|
||||
const char *minorTok= &strVersion[i]+1;
|
||||
int minorSupported= atoi(minorTok);
|
||||
|
||||
if(minorSupported<minor){
|
||||
return false;
|
||||
}
|
||||
else if(minorSupported>minor){
|
||||
return true;
|
||||
}
|
||||
|
||||
//release
|
||||
++i;
|
||||
while(strVersion[i]!='.'){
|
||||
++i;
|
||||
}
|
||||
const char *releaseTok= &strVersion[i]+1;
|
||||
|
||||
if(atoi(releaseTok)<release){
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
const char *getGlVersion(){
|
||||
return reinterpret_cast<const char *>(glGetString(GL_VERSION));
|
||||
}
|
||||
|
||||
const char *getGlRenderer(){
|
||||
return reinterpret_cast<const char *>(glGetString(GL_RENDERER));
|
||||
}
|
||||
|
||||
const char *getGlVendor(){
|
||||
return reinterpret_cast<const char *>(glGetString(GL_VENDOR));
|
||||
}
|
||||
|
||||
const char *getGlExtensions(){
|
||||
return reinterpret_cast<const char *>(glGetString(GL_EXTENSIONS));
|
||||
}
|
||||
|
||||
const char *getGlPlatformExtensions(){
|
||||
Context *c= GraphicsInterface::getInstance().getCurrentContext();
|
||||
return getPlatformExtensions(static_cast<ContextGl*>(c)->getPlatformContextGl());
|
||||
}
|
||||
|
||||
int getGlMaxLights(){
|
||||
int i;
|
||||
glGetIntegerv(GL_MAX_LIGHTS, &i);
|
||||
return i;
|
||||
}
|
||||
|
||||
int getGlMaxTextureSize(){
|
||||
int i;
|
||||
glGetIntegerv(GL_MAX_TEXTURE_SIZE, &i);
|
||||
return i;
|
||||
}
|
||||
|
||||
int getGlMaxTextureUnits(){
|
||||
int i;
|
||||
glGetIntegerv(GL_MAX_TEXTURE_UNITS, &i);
|
||||
return i;
|
||||
}
|
||||
|
||||
int getGlModelviewMatrixStackDepth(){
|
||||
int i;
|
||||
glGetIntegerv(GL_MAX_MODELVIEW_STACK_DEPTH, &i);
|
||||
return i;
|
||||
}
|
||||
|
||||
int getGlProjectionMatrixStackDepth(){
|
||||
int i;
|
||||
glGetIntegerv(GL_MAX_PROJECTION_STACK_DEPTH, &i);
|
||||
return i;
|
||||
}
|
||||
|
||||
void checkGlExtension(const char *extensionName){
|
||||
if(!isGlExtensionSupported(extensionName)){
|
||||
throw runtime_error("OpenGL extension not supported: " + string(extensionName));
|
||||
}
|
||||
}
|
||||
|
||||
}}}// end namespace
|
||||
373
source/shared_lib/sources/graphics/gl/texture_gl.cpp
Normal file
373
source/shared_lib/sources/graphics/gl/texture_gl.cpp
Normal file
@@ -0,0 +1,373 @@
|
||||
// ==============================================================
|
||||
// This file is part of Glest Shared Library (www.glest.org)
|
||||
//
|
||||
// Copyright (C) 2001-2008 Marti<74>o Figueroa
|
||||
//
|
||||
// You can redistribute this code and/or modify it under
|
||||
// the terms of the GNU General Public License as published
|
||||
// by the Free Software Foundation; either version 2 of the
|
||||
// License, or (at your option) any later version
|
||||
// ==============================================================
|
||||
|
||||
#include "texture_gl.h"
|
||||
|
||||
#include <stdexcept>
|
||||
|
||||
#include "opengl.h"
|
||||
#include "leak_dumper.h"
|
||||
|
||||
using namespace std;
|
||||
|
||||
namespace Shared{ namespace Graphics{ namespace Gl{
|
||||
|
||||
using namespace Platform;
|
||||
|
||||
GLint toWrapModeGl(Texture::WrapMode wrapMode){
|
||||
switch(wrapMode){
|
||||
case Texture::wmClamp:
|
||||
return GL_CLAMP;
|
||||
case Texture::wmRepeat:
|
||||
return GL_REPEAT;
|
||||
case Texture::wmClampToEdge:
|
||||
return GL_CLAMP_TO_EDGE;
|
||||
default:
|
||||
assert(false);
|
||||
return GL_CLAMP;
|
||||
}
|
||||
}
|
||||
|
||||
GLint toFormatGl(Texture::Format format, int components){
|
||||
switch(format){
|
||||
case Texture::fAuto:
|
||||
switch(components){
|
||||
case 1:
|
||||
return GL_LUMINANCE;
|
||||
case 3:
|
||||
return GL_RGB;
|
||||
case 4:
|
||||
return GL_RGBA;
|
||||
default:
|
||||
assert(false);
|
||||
return GL_RGBA;
|
||||
}
|
||||
break;
|
||||
case Texture::fLuminance:
|
||||
return GL_LUMINANCE;
|
||||
case Texture::fAlpha:
|
||||
return GL_ALPHA;
|
||||
case Texture::fRgb:
|
||||
return GL_RGB;
|
||||
case Texture::fRgba:
|
||||
return GL_RGBA;
|
||||
default:
|
||||
assert(false);
|
||||
return GL_RGB;
|
||||
}
|
||||
}
|
||||
|
||||
GLint toInternalFormatGl(Texture::Format format, int components){
|
||||
switch(format){
|
||||
case Texture::fAuto:
|
||||
switch(components){
|
||||
case 1:
|
||||
return GL_LUMINANCE8;
|
||||
case 3:
|
||||
return GL_RGB8;
|
||||
case 4:
|
||||
return GL_RGBA8;
|
||||
default:
|
||||
assert(false);
|
||||
return GL_RGBA8;
|
||||
}
|
||||
break;
|
||||
case Texture::fLuminance:
|
||||
return GL_LUMINANCE8;
|
||||
case Texture::fAlpha:
|
||||
return GL_ALPHA8;
|
||||
case Texture::fRgb:
|
||||
return GL_RGB8;
|
||||
case Texture::fRgba:
|
||||
return GL_RGBA8;
|
||||
default:
|
||||
assert(false);
|
||||
return GL_RGB8;
|
||||
}
|
||||
}
|
||||
|
||||
// =====================================================
|
||||
// class Texture1DGl
|
||||
// =====================================================
|
||||
|
||||
void Texture1DGl::init(Filter filter, int maxAnisotropy){
|
||||
assertGl();
|
||||
|
||||
if(!inited){
|
||||
|
||||
//params
|
||||
GLint wrap= toWrapModeGl(wrapMode);
|
||||
GLint glFormat= toFormatGl(format, pixmap.getComponents());
|
||||
GLint glInternalFormat= toInternalFormatGl(format, pixmap.getComponents());
|
||||
|
||||
//pixel init var
|
||||
const uint8* pixels= pixmapInit? pixmap.getPixels(): NULL;
|
||||
|
||||
//gen texture
|
||||
glGenTextures(1, &handle);
|
||||
glBindTexture(GL_TEXTURE_1D, handle);
|
||||
|
||||
//wrap params
|
||||
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, wrap);
|
||||
|
||||
//maxAnisotropy
|
||||
if(isGlExtensionSupported("GL_EXT_texture_filter_anisotropic")){
|
||||
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAX_ANISOTROPY_EXT, maxAnisotropy);
|
||||
}
|
||||
|
||||
if(mipmap){
|
||||
GLuint glFilter= filter==fTrilinear? GL_LINEAR_MIPMAP_LINEAR: GL_LINEAR_MIPMAP_NEAREST;
|
||||
|
||||
//build mipmaps
|
||||
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, glFilter);
|
||||
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
||||
|
||||
int error= gluBuild1DMipmaps(
|
||||
GL_TEXTURE_1D, glInternalFormat, pixmap.getW(),
|
||||
glFormat, GL_UNSIGNED_BYTE, pixels);
|
||||
|
||||
if(error!=0){
|
||||
throw runtime_error("Error building texture 1D mipmaps");
|
||||
}
|
||||
}
|
||||
else{
|
||||
//build single texture
|
||||
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
||||
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
||||
|
||||
glTexImage1D(
|
||||
GL_TEXTURE_1D, 0, glInternalFormat, pixmap.getW(),
|
||||
0, glFormat, GL_UNSIGNED_BYTE, pixels);
|
||||
|
||||
GLint error= glGetError();
|
||||
if(error!=GL_NO_ERROR){
|
||||
throw runtime_error("Error creating texture 1D");
|
||||
}
|
||||
}
|
||||
inited= true;
|
||||
}
|
||||
|
||||
assertGl();
|
||||
}
|
||||
|
||||
void Texture1DGl::end(){
|
||||
if(inited){
|
||||
assertGl();
|
||||
glDeleteTextures(1, &handle);
|
||||
assertGl();
|
||||
}
|
||||
}
|
||||
|
||||
// =====================================================
|
||||
// class Texture2DGl
|
||||
// =====================================================
|
||||
|
||||
void Texture2DGl::init(Filter filter, int maxAnisotropy){
|
||||
assertGl();
|
||||
|
||||
if(!inited){
|
||||
|
||||
//params
|
||||
GLint wrap= toWrapModeGl(wrapMode);
|
||||
GLint glFormat= toFormatGl(format, pixmap.getComponents());
|
||||
GLint glInternalFormat= toInternalFormatGl(format, pixmap.getComponents());
|
||||
|
||||
//pixel init var
|
||||
const uint8* pixels= pixmapInit? pixmap.getPixels(): NULL;
|
||||
|
||||
//gen texture
|
||||
glGenTextures(1, &handle);
|
||||
glBindTexture(GL_TEXTURE_2D, handle);
|
||||
|
||||
//wrap params
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrap);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrap);
|
||||
|
||||
//maxAnisotropy
|
||||
if(isGlExtensionSupported("GL_EXT_texture_filter_anisotropic")){
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, maxAnisotropy);
|
||||
}
|
||||
|
||||
if(mipmap){
|
||||
GLuint glFilter= filter==fTrilinear? GL_LINEAR_MIPMAP_LINEAR: GL_LINEAR_MIPMAP_NEAREST;
|
||||
|
||||
//build mipmaps
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, glFilter);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
||||
|
||||
int error= gluBuild2DMipmaps(
|
||||
GL_TEXTURE_2D, glInternalFormat,
|
||||
pixmap.getW(), pixmap.getH(),
|
||||
glFormat, GL_UNSIGNED_BYTE, pixels);
|
||||
|
||||
if(error!=0){
|
||||
throw runtime_error("Error building texture 2D mipmaps");
|
||||
}
|
||||
}
|
||||
else{
|
||||
//build single texture
|
||||
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, glInternalFormat,
|
||||
pixmap.getW(), pixmap.getH(),
|
||||
0, glFormat, GL_UNSIGNED_BYTE, pixels);
|
||||
|
||||
GLint error= glGetError();
|
||||
if(error!=GL_NO_ERROR){
|
||||
throw runtime_error("Error creating texture 2D");
|
||||
}
|
||||
}
|
||||
inited= true;
|
||||
}
|
||||
|
||||
assertGl();
|
||||
}
|
||||
|
||||
void Texture2DGl::end(){
|
||||
if(inited){
|
||||
assertGl();
|
||||
glDeleteTextures(1, &handle);
|
||||
assertGl();
|
||||
}
|
||||
}
|
||||
|
||||
// =====================================================
|
||||
// class Texture3DGl
|
||||
// =====================================================
|
||||
|
||||
void Texture3DGl::init(Filter filter, int maxAnisotropy){
|
||||
assertGl();
|
||||
|
||||
if(!inited){
|
||||
|
||||
//params
|
||||
GLint wrap= toWrapModeGl(wrapMode);
|
||||
GLint glFormat= toFormatGl(format, pixmap.getComponents());
|
||||
GLint glInternalFormat= toInternalFormatGl(format, pixmap.getComponents());
|
||||
|
||||
//pixel init var
|
||||
const uint8* pixels= pixmapInit? pixmap.getPixels(): NULL;
|
||||
|
||||
//gen texture
|
||||
glGenTextures(1, &handle);
|
||||
glBindTexture(GL_TEXTURE_3D, handle);
|
||||
|
||||
//wrap params
|
||||
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, wrap);
|
||||
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, wrap);
|
||||
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, wrap);
|
||||
|
||||
//build single texture
|
||||
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
||||
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
||||
|
||||
glTexImage3D(
|
||||
GL_TEXTURE_3D, 0, glInternalFormat,
|
||||
pixmap.getW(), pixmap.getH(), pixmap.getD(),
|
||||
0, glFormat, GL_UNSIGNED_BYTE, pixels);
|
||||
|
||||
GLint error= glGetError();
|
||||
if(error!=GL_NO_ERROR){
|
||||
throw runtime_error("Error creating texture 3D");
|
||||
}
|
||||
inited= true;
|
||||
}
|
||||
|
||||
assertGl();
|
||||
}
|
||||
|
||||
void Texture3DGl::end(){
|
||||
if(inited){
|
||||
assertGl();
|
||||
glDeleteTextures(1, &handle);
|
||||
assertGl();
|
||||
}
|
||||
}
|
||||
|
||||
// =====================================================
|
||||
// class TextureCubeGl
|
||||
// =====================================================
|
||||
|
||||
void TextureCubeGl::init(Filter filter, int maxAnisotropy){
|
||||
assertGl();
|
||||
|
||||
if(!inited){
|
||||
|
||||
//gen texture
|
||||
glGenTextures(1, &handle);
|
||||
glBindTexture(GL_TEXTURE_CUBE_MAP, handle);
|
||||
|
||||
//wrap
|
||||
GLint wrap= toWrapModeGl(wrapMode);
|
||||
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, wrap);
|
||||
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, wrap);
|
||||
|
||||
//filter
|
||||
if(mipmap){
|
||||
GLuint glFilter= filter==fTrilinear? GL_LINEAR_MIPMAP_LINEAR: GL_LINEAR_MIPMAP_NEAREST;
|
||||
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, glFilter);
|
||||
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
||||
}
|
||||
else{
|
||||
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
||||
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
||||
}
|
||||
|
||||
for(int i=0; i<6; ++i){
|
||||
//params
|
||||
const Pixmap2D *currentPixmap= pixmap.getFace(i);
|
||||
|
||||
GLint glFormat= toFormatGl(format, currentPixmap->getComponents());
|
||||
GLint glInternalFormat= toInternalFormatGl(format, currentPixmap->getComponents());
|
||||
|
||||
//pixel init var
|
||||
const uint8* pixels= pixmapInit? currentPixmap->getPixels(): NULL;
|
||||
GLenum target= GL_TEXTURE_CUBE_MAP_POSITIVE_X + i;
|
||||
|
||||
if(mipmap){
|
||||
int error= gluBuild2DMipmaps(
|
||||
target, glInternalFormat,
|
||||
currentPixmap->getW(), currentPixmap->getH(),
|
||||
glFormat, GL_UNSIGNED_BYTE, pixels);
|
||||
|
||||
if(error!=0){
|
||||
throw runtime_error("Error building texture cube mipmaps");
|
||||
}
|
||||
}
|
||||
else{
|
||||
glTexImage2D(
|
||||
target, 0, glInternalFormat,
|
||||
currentPixmap->getW(), currentPixmap->getH(),
|
||||
0, glFormat, GL_UNSIGNED_BYTE, pixels);
|
||||
}
|
||||
|
||||
if(glGetError()!=GL_NO_ERROR){
|
||||
throw runtime_error("Error creating texture cube");
|
||||
}
|
||||
}
|
||||
inited= true;
|
||||
|
||||
}
|
||||
|
||||
assertGl();
|
||||
}
|
||||
|
||||
void TextureCubeGl::end(){
|
||||
if(inited){
|
||||
assertGl();
|
||||
glDeleteTextures(1, &handle);
|
||||
assertGl();
|
||||
}
|
||||
}
|
||||
|
||||
}}}//end namespace
|
||||
Reference in New Issue
Block a user