void Framebuffer::Initialize( void )
{
// Don't attempt to reload if we've already tried to (unless we use Clear first).
if( FramebufferHandle || Texture || Depthbuffer )
return;
// If framebuffers are disabled, create a blank 2x2 texture instead.
if( ! Raptor::Game->Cfg.SettingAsBool( "g_framebuffers", true ) )
{
glGenTextures( 1, &Texture );
glBindTexture( GL_TEXTURE_2D, Texture );
glEnable( GL_TEXTURE_2D );
unsigned char raw[ 16 ] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, raw );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, TextureFilter );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
glBindTexture( GL_TEXTURE_2D, 0 );
LoadedTime.Reset();
return;
}
// Some systems require power-of-two dimensions.
if( ForcePowerOfTwo )
{
AllocW = Num::NextPowerOfTwo(W);
AllocH = Num::NextPowerOfTwo(H);
}
else
{
AllocW = W;
AllocH = H;
}
// Limit framebuffers to maximum texture resolution.
GLint tex_max = Raptor::Game->Cfg.SettingAsInt( "g_texture_maxres", 0 );
if( ! tex_max )
glGetIntegerv( GL_MAX_TEXTURE_SIZE, &tex_max );
if( tex_max > 0 )
{
if( ForcePowerOfTwo )
{
int tex_max_pow2 = Num::NextPowerOfTwo(tex_max);
tex_max = (tex_max_pow2 > tex_max) ? (tex_max_pow2 / 2) : tex_max_pow2;
}
if( AllocW > tex_max )
AllocW = tex_max;
if( AllocH > tex_max )
AllocH = tex_max;
}
// Framebuffer
glGenFramebuffers( 1, &FramebufferHandle );
glBindFramebuffer( GL_FRAMEBUFFER, FramebufferHandle );
// Renderbuffer
glGenTextures( 1, &Texture );
glBindTexture( GL_TEXTURE_2D, Texture );
void *raw = malloc( AllocW * AllocH * 4 );
memset( raw, 0, AllocW * AllocH * 4 );
glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, AllocW, AllocH, 0, GL_RGBA, GL_UNSIGNED_BYTE, raw );
free( raw );
raw = NULL;
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, TextureFilter );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, Texture, 0 );
GLenum draw_buffers[ 1 ] = { GL_COLOR_ATTACHMENT0 };
glDrawBuffers( 1, draw_buffers );
// Depthbuffer
glGenRenderbuffers( 1, &Depthbuffer );
glBindRenderbuffer( GL_RENDERBUFFER, Depthbuffer );
glRenderbufferStorage( GL_RENDERBUFFER, GL_DEPTH_COMPONENT, AllocW, AllocH );
glFramebufferRenderbuffer( GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, Depthbuffer );
// Make sure everything worked.
GLenum framebuffer_status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
if( framebuffer_status == GL_FRAMEBUFFER_COMPLETE )
Initialized = true;
#ifdef GL_FRAMEBUFFER_UNSUPPORTED
else if( (framebuffer_status == GL_FRAMEBUFFER_UNSUPPORTED) && ! ForcePowerOfTwo )
{
ForcePowerOfTwo = true;
Clear();
Reload();
}
#endif
else
{
std::string status_string = "UNKNOWN ERROR";
if( framebuffer_status == GL_INVALID_ENUM )
status_string = "GL_INVALID_ENUM";
#ifdef GL_FRAMEBUFFER_UNDEFINED
else if( framebuffer_status == GL_FRAMEBUFFER_UNDEFINED )
status_string = "GL_FRAMEBUFFER_UNDEFINED";
#endif
#ifdef GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT
else if( framebuffer_status == GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT )
status_string = "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT";
#endif
#ifdef GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT
else if( framebuffer_status == GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT )
status_string = "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT";
#endif
#ifdef GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER
else if( framebuffer_status == GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER )
status_string = "GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER";
#endif
#ifdef GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER
else if( framebuffer_status == GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER )
status_string = "GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER";
#endif
#ifdef GL_FRAMEBUFFER_UNSUPPORTED
else if( framebuffer_status == GL_FRAMEBUFFER_UNSUPPORTED )
status_string = "GL_FRAMEBUFFER_UNSUPPORTED";
#endif
#ifdef GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE
else if( framebuffer_status == GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE )
status_string = "GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE";
#endif
#ifdef GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS
else if( framebuffer_status == GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS )
status_string = "GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS";
#endif
else
status_string = std::string("0x") + Num::ToHexString( framebuffer_status );
Raptor::Game->Console.Print( std::string("Framebuffer::Initialize: OpenGL Error ") + status_string, TextConsole::MSG_ERROR );
}
// Unbind things so we don't accidentally use them when we don't mean to.
glBindTexture( GL_TEXTURE_2D, 0 );
glBindFramebuffer( GL_FRAMEBUFFER, 0 );
LoadedTime.Reset();
}
/////////////
// main //
//////////////
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) {
// mglStrokeText( string, x, y, scalex, scaley, linewidth, color, rotation )
if ( nrhs<3 )
return;
// Set character string variable
// Set scale
// Set starting position
int buflen=mxGetN( prhs[0] )*mxGetM( prhs[0] )+1;
char * inputString=(char*) malloc(buflen);
mxGetString( prhs[0], inputString, buflen);
float x,y,scaleX,scaleY;
float linewidth,rot;
float color[3];
x=(float) *mxGetPr( prhs[1] );
y=(float) *mxGetPr( prhs[2] );
if (nrhs>3)
scaleX=(float) *mxGetPr( prhs[3] );
else
scaleX=1.0;
if (nrhs>4)
scaleY=(float) *mxGetPr( prhs[4] );
else
scaleY=scaleX;
if (nrhs>5)
linewidth=(float) *mxGetPr( prhs[5] );
else
linewidth=1;
if (nrhs>6) {
color[0]=(float)*mxGetPr( prhs[6] );
color[1]=(float)*(mxGetPr( prhs[6] )+1);
color[2]=(float)*(mxGetPr( prhs[6] )+2);
} else {
color[0]=1.0;
color[1]=1.0;
color[2]=1.0;
}
if (nrhs>7)
rot=(float) *mxGetPr( prhs[7] );
else
rot=0.0;
glLineWidth(linewidth);
int rectWidth=0;
GLint range[2];
glGetIntegerv(GL_POINT_SIZE_RANGE,range);
if (range[1]<linewidth) {
rectWidth=linewidth+1;
} else {
glPointSize(linewidth+1);
}
char space[]=" ";
int iS,iC,numstrokes;
float * strokesX;
float * strokesY;
glColor3f(color[0],color[1],color[2]);
glEnable(GL_LINE_SMOOTH);
bool charFound;
// Select each character in string
for (iS=0; iS<buflen-1; iS++) {
// note that buflen includes null \0 character which we ignore
iC=0;
charFound=false;
if (inputString[iS]==(*space)) {
// advance x
x+=(scaleX*1.1);
continue;
} else {
// Find index of corresponding character
for (iC=0; iC<MGLNUMCHARS; iC++) {
if (inputString[iS]==MGLChars[iC]) {
// mexPrintf("%c %c\n",inputString[iS],MGLChars[iC]);
numstrokes=MGLCharNumStrokes[iC];
strokesX=MGLCharStrokesX[iC];
strokesY=MGLCharStrokesY[iC];
// Draw character
// mexPrintf("%i %i\n",iC, iS);
drawStrokeCharacter( x, y, strokesX, strokesY, scaleX, scaleY, numstrokes, MGLCharsWithDots[iC], rot, rectWidth );
// Update x,y
x+=(scaleX*1.1); // letter spacing
charFound=true;
break;
}
}
if (!charFound) {
// draw hash
iC=33;
numstrokes=MGLCharNumStrokes[iC];
strokesX=MGLCharStrokesX[iC];
strokesY=MGLCharStrokesY[iC];
// Draw character
// mexPrintf("%i %i\n",iC, iS);
drawStrokeCharacter( x, y, strokesX, strokesY, scaleX, scaleY, numstrokes, MGLCharsWithDots[iC], rot, rectWidth );
// Update x,y
x+=(scaleX*1.1); // letter spacing
}
}
}
if (nlhs==2) {
plhs[0] = mxCreateDoubleMatrix(1,1,mxREAL);
plhs[1] = mxCreateDoubleMatrix(1,1,mxREAL);
*mxGetPr(plhs[0]) = x;
*mxGetPr(plhs[1]) = y;
}
}
int main(int argc, const char * argv[]) {
if(!glfwInit()){
return -1;
}
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
auto window = glfwCreateWindow(WIDTH, HEIGHT, "Transformation", nullptr, nullptr);
if (nullptr == window) {
std::cout << "Failed to create GLFW windows" << std::endl;
glfwTerminate();
return -1;
}
glfwMakeContextCurrent(window);
int actualWidth;
int actualHeight;
glfwGetFramebufferSize(window, &actualWidth, &actualHeight);
glViewport(0, 0, actualWidth, actualHeight);
glfwSetKeyCallback(window, key_callback);
GLint nrAttributes;
glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &nrAttributes);
std::cout << "Maximum number of vertex attributes supported: " << nrAttributes << std::endl;
GLuint shaderProgram = createShaderProgramWithFilenames("vertex.vsh", "fragment.fsh");
GLfloat vertices[] = {
// Positions // Colors // Texture Coords
0.5f, 0.5f, 0.0f, 1.0f, 0.0f, 0.0f, 1.f, 1.0f, // Top Right
0.5f, -0.5f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.f, // Bottom Right
-0.5f, -0.5f, 0.0f, 0.0f, 0.0f, 1.0f, 0.f, 0.f, // Bottom Left
-0.5f, 0.5f, 0.0f, 1.0f, 1.0f, 0.0f, 0.f, 1.f // Top Left
};
GLuint indices[] = { // Note that we start from 0!
0, 1, 3, // First Triangle
1, 2, 3 // Second Triangle
};
GLuint VAO;
glGenVertexArrays(1, &VAO);
glBindVertexArray(VAO);
GLuint VBO;
glGenBuffers(1, &VBO);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
GLuint EBO;
glGenBuffers(1, &EBO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)0);
glEnableVertexAttribArray(0);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat)));
glEnableVertexAttribArray(1);
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)(6 * sizeof(GLfloat)));
glEnableVertexAttribArray(2);
glBindVertexArray(0);
int width, height;
unsigned char* image = SOIL_load_image("container.jpg", &width, &height, 0, SOIL_LOAD_RGB);
GLuint texture;
glGenTextures(1, &texture);
glBindTexture(GL_TEXTURE_2D, texture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, image);
glGenerateMipmap(GL_TEXTURE_2D);
SOIL_free_image_data(image);
glBindTexture(GL_TEXTURE_2D, 0);
unsigned char* image2 = SOIL_load_image("awesomeface.png", &width, &height, 0, SOIL_LOAD_RGB);
GLuint texture2;
glGenTextures(1, &texture2);
glBindTexture(GL_TEXTURE_2D, texture2);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, image2);
glGenerateMipmap(GL_TEXTURE_2D);
SOIL_free_image_data(image2);
glBindTexture(GL_TEXTURE_2D, 0);
// glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
while (!glfwWindowShouldClose(window)) {
glfwPollEvents();
//do rendering
glClearColor(0.2, 0.3, 0.3, 1.0);
glClear(GL_COLOR_BUFFER_BIT);
glUseProgram(shaderProgram);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, texture);
glUniform1i(glGetUniformLocation(shaderProgram, "ourTexture1"), 0);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, texture2);
glUniform1i(glGetUniformLocation(shaderProgram, "ourTexture2"), 1);
glUniform1f(glGetUniformLocation(shaderProgram, "mixValue"), mixValue);
glm::mat4 trans;
trans = glm::translate(trans, glm::vec3(0.5f, -0.5f, 0.0f));
trans = glm::rotate(trans, glm::radians((GLfloat)glfwGetTime() * 50.0f),
glm::vec3(0.0f, 0.0f, 1.0f));
GLuint transformLoc = glGetUniformLocation(shaderProgram, "transforms");
glUniformMatrix4fv(transformLoc, 1, GL_FALSE, glm::value_ptr(trans));
//draw the first triangles
glBindVertexArray(VAO);
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
trans = glm::mat4(); //reset the previous matrix
trans = glm::translate(trans, glm::vec3(-0.5f, 0.5f, 0.0f));
float scaleFactor = sinf((GLfloat)glfwGetTime()) ;
trans = glm::scale(trans,glm::vec3(scaleFactor, scaleFactor, 1.0f ));
glUniformMatrix4fv(transformLoc, 1, GL_FALSE, glm::value_ptr(trans));
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
glBindVertexArray(0);
glfwSwapBuffers(window);
}
glDeleteVertexArrays(1, &VAO);
glDeleteBuffers(1, &VBO);
glDeleteBuffers(1, &EBO);
glDeleteProgram(shaderProgram);
glfwTerminate();
return 0;
}
void _glGetIntegerv( int pname,Array<int> params,int offset ) {
glGetIntegerv( pname,¶ms[offset] );
}
int PTex :: Set(const unsigned char *buf,int width, int height,GLint format) {
if( ! buf ) {
ERROR("PTex::Set: Null pointer buf");
return -1;
}
//sprawdzamy czy nie jest wiekszy niz na to pozwala OpenGL
int max_size;
glGetIntegerv(GL_MAX_TEXTURE_SIZE, &max_size);
if( (width > max_size) || (height > max_size) ) {
ERROR("Image size exceeds max texture size, which is "+toString(max_size)+" pixels for each side");
return -2;
}
glGenTextures( 1, &texnum );
texbinded = true;
glBindTexture( GL_TEXTURE_2D, texnum );
// glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT );
// glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT );
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_WRAP_S, GL_CLAMP_TO_BORDER );
// glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER );
switch( ic_filtering ) {
case FM_NEAREST:
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
break;
case FM_LINEAR:
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
break;
case FM_BILINEAR:
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST );
break;
default:
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR );
break;
}
/*
gluBuild2DMipmapLevels( GL_TEXTURE_2D,
GL_RGBA,
image->w, image->h,
GL_RGBA,
GL_UNSIGNED_BYTE,
0, //mipmap image level
0, //mipmap base level
0, //mipmap max level
image->pixels );
*/
glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, GL_UNSIGNED_BYTE, buf);
glHint(GL_GENERATE_MIPMAP_HINT, GL_FASTEST);//GL_FASTEST);
glGenerateMipmap(GL_TEXTURE_2D);
img_w = width;
img_h = height;
GLint par;
glGetTexLevelParameteriv( GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &par);
w = par;
glGetTexLevelParameteriv( GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &par);
h = par;
return 1;
}
bool ImGui_ImplSdlGL3_CreateDeviceObjects()
{
// Backup GL state
GLint last_texture, last_array_buffer, last_vertex_array;
glGetIntegerv(GL_TEXTURE_BINDING_2D, &last_texture);
glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &last_array_buffer);
glGetIntegerv(GL_VERTEX_ARRAY_BINDING, &last_vertex_array);
const GLchar *vertex_shader =
"#version 330\n"
"uniform mat4 ProjMtx;\n"
"in vec2 Position;\n"
"in vec2 UV;\n"
"in vec4 Color;\n"
"out vec2 Frag_UV;\n"
"out vec4 Frag_Color;\n"
"void main()\n"
"{\n"
" Frag_UV = UV;\n"
" Frag_Color = Color;\n"
" gl_Position = ProjMtx * vec4(Position.xy,0,1);\n"
"}\n";
const GLchar* fragment_shader =
"#version 330\n"
"uniform sampler2D Texture;\n"
"in vec2 Frag_UV;\n"
"in vec4 Frag_Color;\n"
"out vec4 Out_Color;\n"
"void main()\n"
"{\n"
" Out_Color = Frag_Color * texture( Texture, Frag_UV.st);\n"
"}\n";
g_ShaderHandle = glCreateProgram();
g_VertHandle = glCreateShader(GL_VERTEX_SHADER);
g_FragHandle = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(g_VertHandle, 1, &vertex_shader, 0);
glShaderSource(g_FragHandle, 1, &fragment_shader, 0);
glCompileShader(g_VertHandle);
glCompileShader(g_FragHandle);
glAttachShader(g_ShaderHandle, g_VertHandle);
glAttachShader(g_ShaderHandle, g_FragHandle);
glLinkProgram(g_ShaderHandle);
g_AttribLocationTex = glGetUniformLocation(g_ShaderHandle, "Texture");
g_AttribLocationProjMtx = glGetUniformLocation(g_ShaderHandle, "ProjMtx");
g_AttribLocationPosition = glGetAttribLocation(g_ShaderHandle, "Position");
g_AttribLocationUV = glGetAttribLocation(g_ShaderHandle, "UV");
g_AttribLocationColor = glGetAttribLocation(g_ShaderHandle, "Color");
glGenBuffers(1, &g_VboHandle);
glGenBuffers(1, &g_ElementsHandle);
glGenVertexArrays(1, &g_VaoHandle);
glBindVertexArray(g_VaoHandle);
glBindBuffer(GL_ARRAY_BUFFER, g_VboHandle);
glEnableVertexAttribArray(g_AttribLocationPosition);
glEnableVertexAttribArray(g_AttribLocationUV);
glEnableVertexAttribArray(g_AttribLocationColor);
#define OFFSETOF(TYPE, ELEMENT) ((size_t)&(((TYPE *)0)->ELEMENT))
glVertexAttribPointer(g_AttribLocationPosition, 2, GL_FLOAT, GL_FALSE, sizeof(ImDrawVert), (GLvoid*)OFFSETOF(ImDrawVert, pos));
glVertexAttribPointer(g_AttribLocationUV, 2, GL_FLOAT, GL_FALSE, sizeof(ImDrawVert), (GLvoid*)OFFSETOF(ImDrawVert, uv));
glVertexAttribPointer(g_AttribLocationColor, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(ImDrawVert), (GLvoid*)OFFSETOF(ImDrawVert, col));
#undef OFFSETOF
ImGui_ImplSdlGL3_CreateFontsTexture();
// Restore modified GL state
glBindTexture(GL_TEXTURE_2D, last_texture);
glBindBuffer(GL_ARRAY_BUFFER, last_array_buffer);
glBindVertexArray(last_vertex_array);
return true;
}
void Mouse::update(float dt)
{
memcpy(m_lastButtonState, m_buttonState, sizeof(bool) * 2);
#ifdef _WIN32
m_buttonState[0] = (GetAsyncKeyState(VK_LBUTTON) & 0x8000) ? true : false;
m_buttonState[1] = (GetAsyncKeyState(VK_RBUTTON) & 0x8000) ? true : false;
#elif defined __APPLE__
#ifndef MARBLE_IOS_BUILD
Uint8 mouseState = SDL_GetMouseState(NULL, NULL);
m_buttonState[0] = (mouseState & SDL_BUTTON(SDL_BUTTON_LEFT)) ? true : false;
m_buttonState[1] = (mouseState & SDL_BUTTON(SDL_BUTTON_RIGHT)) ? true : false;
#endif
#endif
/*
This next section of code allows for really smooth mouse movement no matter
what the frame rate (well... within reason). The last 10 positions
are stored in a list. Each frame a new relative position is added and the oldest is removed.
These positions are then added together using a weighting value. The most recent position
has the most weight, whereas the oldest as the lowest weighting. This value is then averaged
to produce the new relative mouse position.
*/
elapsed_time += dt;
if (elapsed_time > timestep_threshold)
{
static std::list<std::pair<float, float> > mousePositionHistory;
if (m_mouseLocked) {
int x, y;
getMousePos(x, y);
GLint viewport[4];
glGetIntegerv(GL_VIEWPORT, viewport);
if ( !firstFrame ) {
//Add the current mouse position - starting position
mousePositionHistory.push_front(std::make_pair((float)x - (viewport[2] / 2), (float)y - (viewport[3] / 2)));
if (mousePositionHistory.size() > 10)
{
//Make sure only the last 10 positions are stored
mousePositionHistory.pop_back();
}
m_relativeMousePosX = 0.0f;
m_relativeMousePosY = 0.0f;
float weight = 1.0f;
//Calculate a weighted average
for (std::list<std::pair<float, float> >::iterator i = mousePositionHistory.begin();
i != mousePositionHistory.end(); ++i)
{
m_relativeMousePosX += (*i).first * weight;
m_relativeMousePosY += (*i).second * weight;
weight *= 0.5f;
}
m_relativeMousePosX /= 10.0f;
m_relativeMousePosY /= 10.0f;
}
firstFrame = false;
//Put the mouse in the middle of the screen
setMousePos(viewport[2] / 2, viewport[3] / 2);
showCursor(false);
}
elapsed_time = 0.0f;
}
}
void processFn(struct fnargs* args) {
switch (args->fn) {
case glfnUNDEFINED:
abort(); // bad glfn
break;
case glfnActiveTexture:
glActiveTexture((GLenum)args->a0);
break;
case glfnAttachShader:
glAttachShader((GLint)args->a0, (GLint)args->a1);
break;
case glfnBindAttribLocation:
glBindAttribLocation((GLint)args->a0, (GLint)args->a1, (GLchar*)args->a2);
free((void*)args->a2);
break;
case glfnBindBuffer:
glBindBuffer((GLenum)args->a0, (GLuint)args->a1);
break;
case glfnBindFramebuffer:
glBindFramebuffer((GLenum)args->a0, (GLint)args->a1);
break;
case glfnBindRenderbuffer:
glBindRenderbuffer((GLenum)args->a0, (GLint)args->a1);
break;
case glfnBindTexture:
glBindTexture((GLenum)args->a0, (GLint)args->a1);
break;
case glfnBlendColor:
glBlendColor(*(GLfloat*)&args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2, *(GLfloat*)&args->a3);
break;
case glfnBlendEquation:
glBlendEquation((GLenum)args->a0);
break;
case glfnBlendEquationSeparate:
glBlendEquationSeparate((GLenum)args->a0, (GLenum)args->a1);
break;
case glfnBlendFunc:
glBlendFunc((GLenum)args->a0, (GLenum)args->a1);
break;
case glfnBlendFuncSeparate:
glBlendFuncSeparate((GLenum)args->a0, (GLenum)args->a1, (GLenum)args->a2, (GLenum)args->a3);
break;
case glfnBufferData:
glBufferData((GLenum)args->a0, (GLsizeiptr)args->a1, (GLvoid*)args->a2, (GLenum)args->a3);
break;
case glfnBufferSubData:
glBufferSubData((GLenum)args->a0, (GLint)args->a1, (GLsizeiptr)args->a2, (GLvoid*)args->a3);
break;
case glfnCheckFramebufferStatus:
ret = glCheckFramebufferStatus((GLenum)args->a0);
break;
case glfnClear:
glClear((GLenum)args->a0);
break;
case glfnClearColor:
glClearColor(*(GLfloat*)&args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2, *(GLfloat*)&args->a3);
break;
case glfnClearDepthf:
glClearDepthf(*(GLfloat*)&args->a0);
break;
case glfnClearStencil:
glClearStencil((GLint)args->a0);
break;
case glfnColorMask:
glColorMask((GLboolean)args->a0, (GLboolean)args->a1, (GLboolean)args->a2, (GLboolean)args->a3);
break;
case glfnCompileShader:
glCompileShader((GLint)args->a0);
break;
case glfnCompressedTexImage2D:
glCompressedTexImage2D((GLenum)args->a0, (GLint)args->a1, (GLenum)args->a2, (GLint)args->a3, (GLint)args->a4, (GLint)args->a5, (GLsizeiptr)args->a6, (GLvoid*)args->a7);
break;
case glfnCompressedTexSubImage2D:
glCompressedTexSubImage2D((GLenum)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3, (GLint)args->a4, (GLint)args->a5, (GLenum)args->a6, (GLsizeiptr)args->a7, (GLvoid*)args->a8);
break;
case glfnCopyTexImage2D:
glCopyTexImage2D((GLenum)args->a0, (GLint)args->a1, (GLenum)args->a2, (GLint)args->a3, (GLint)args->a4, (GLint)args->a5, (GLint)args->a6, (GLint)args->a7);
break;
case glfnCopyTexSubImage2D:
glCopyTexSubImage2D((GLenum)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3, (GLint)args->a4, (GLint)args->a5, (GLint)args->a6, (GLint)args->a7);
break;
case glfnCreateProgram:
ret = glCreateProgram();
break;
case glfnCreateShader:
ret = glCreateShader((GLenum)args->a0);
break;
case glfnCullFace:
glCullFace((GLenum)args->a0);
break;
case glfnDeleteBuffer:
glDeleteBuffers(1, (const GLuint*)(&args->a0));
break;
case glfnDeleteFramebuffer:
glDeleteFramebuffers(1, (const GLuint*)(&args->a0));
break;
case glfnDeleteProgram:
glDeleteProgram((GLint)args->a0);
break;
case glfnDeleteRenderbuffer:
glDeleteRenderbuffers(1, (const GLuint*)(&args->a0));
break;
case glfnDeleteShader:
glDeleteShader((GLint)args->a0);
break;
case glfnDeleteTexture:
glDeleteTextures(1, (const GLuint*)(&args->a0));
break;
case glfnDepthFunc:
glDepthFunc((GLenum)args->a0);
break;
case glfnDepthMask:
glDepthMask((GLboolean)args->a0);
break;
case glfnDepthRangef:
glDepthRangef(*(GLfloat*)&args->a0, *(GLfloat*)&args->a1);
break;
case glfnDetachShader:
glDetachShader((GLint)args->a0, (GLint)args->a1);
break;
case glfnDisable:
glDisable((GLenum)args->a0);
break;
case glfnDisableVertexAttribArray:
glDisableVertexAttribArray((GLint)args->a0);
break;
case glfnDrawArrays:
glDrawArrays((GLenum)args->a0, (GLint)args->a1, (GLint)args->a2);
break;
case glfnDrawElements:
glDrawElements((GLenum)args->a0, (GLint)args->a1, (GLenum)args->a2, (void*)args->a3);
break;
case glfnEnable:
glEnable((GLenum)args->a0);
break;
case glfnEnableVertexAttribArray:
glEnableVertexAttribArray((GLint)args->a0);
break;
case glfnFinish:
glFinish();
break;
case glfnFlush:
glFlush();
break;
case glfnFramebufferRenderbuffer:
glFramebufferRenderbuffer((GLenum)args->a0, (GLenum)args->a1, (GLenum)args->a2, (GLint)args->a3);
break;
case glfnFramebufferTexture2D:
glFramebufferTexture2D((GLenum)args->a0, (GLenum)args->a1, (GLenum)args->a2, (GLint)args->a3, (GLint)args->a4);
break;
case glfnFrontFace:
glFrontFace((GLenum)args->a0);
break;
case glfnGenBuffer:
glGenBuffers(1, (GLuint*)&ret);
break;
case glfnGenFramebuffer:
glGenFramebuffers(1, (GLuint*)&ret);
break;
case glfnGenRenderbuffer:
glGenRenderbuffers(1, (GLuint*)&ret);
break;
case glfnGenTexture:
glGenTextures(1, (GLuint*)&ret);
break;
case glfnGenerateMipmap:
glGenerateMipmap((GLenum)args->a0);
break;
case glfnGetActiveAttrib:
glGetActiveAttrib(
(GLuint)args->a0,
(GLuint)args->a1,
(GLsizei)args->a2,
NULL,
(GLint*)args->a4,
(GLenum*)args->a5,
(GLchar*)args->a6);
break;
case glfnGetActiveUniform:
glGetActiveUniform(
(GLuint)args->a0,
(GLuint)args->a1,
(GLsizei)args->a2,
NULL,
(GLint*)args->a4,
(GLenum*)args->a5,
(GLchar*)args->a6);
break;
case glfnGetAttachedShaders:
glGetAttachedShaders((GLuint)args->a0, (GLsizei)args->a1, (GLsizei*)args->a2, (GLuint*)args->a3);
break;
case glfnGetAttribLocation:
ret = glGetAttribLocation((GLint)args->a0, (GLchar*)args->a1);
free((void*)args->a1);
break;
case glfnGetBooleanv:
glGetBooleanv((GLenum)args->a0, (GLboolean*)args->a1);
break;
case glfnGetBufferParameteri:
glGetBufferParameteriv((GLenum)args->a0, (GLenum)args->a1, (GLint*)&ret);
break;
case glfnGetFloatv:
glGetFloatv((GLenum)args->a0, (GLfloat*)args->a1);
break;
case glfnGetIntegerv:
glGetIntegerv((GLenum)args->a0, (GLint*)args->a1);
break;
case glfnGetError:
ret = glGetError();
break;
case glfnGetFramebufferAttachmentParameteriv:
glGetFramebufferAttachmentParameteriv((GLenum)args->a0, (GLenum)args->a1, (GLenum)args->a2, (GLint*)&ret);
break;
case glfnGetProgramiv:
glGetProgramiv((GLint)args->a0, (GLenum)args->a1, (GLint*)&ret);
break;
case glfnGetProgramInfoLog:
glGetProgramInfoLog((GLuint)args->a0, (GLsizei)args->a1, (GLsizei*)args->a2, (GLchar*)args->a3);
break;
case glfnGetRenderbufferParameteriv:
glGetRenderbufferParameteriv((GLenum)args->a0, (GLenum)args->a1, (GLint*)&ret);
break;
case glfnGetShaderiv:
glGetShaderiv((GLint)args->a0, (GLenum)args->a1, (GLint*)&ret);
break;
case glfnGetShaderInfoLog:
glGetShaderInfoLog((GLuint)args->a0, (GLsizei)args->a1, (GLsizei*)args->a2, (GLchar*)args->a3);
break;
case glfnGetShaderPrecisionFormat:
glGetShaderPrecisionFormat((GLenum)args->a0, (GLenum)args->a1, (GLint*)args->a2, (GLint*)args->a3);
break;
case glfnGetShaderSource:
glGetShaderSource((GLuint)args->a0, (GLsizei)args->a1, (GLsizei*)args->a2, (GLchar*)args->a3);
break;
case glfnGetString:
ret = (uintptr_t)glGetString((GLenum)args->a0);
break;
case glfnGetTexParameterfv:
glGetTexParameterfv((GLenum)args->a0, (GLenum)args->a1, (GLfloat*)args->a2);
break;
case glfnGetTexParameteriv:
glGetTexParameteriv((GLenum)args->a0, (GLenum)args->a1, (GLint*)args->a2);
break;
case glfnGetUniformfv:
glGetUniformfv((GLuint)args->a0, (GLint)args->a1, (GLfloat*)args->a2);
break;
case glfnGetUniformiv:
glGetUniformiv((GLuint)args->a0, (GLint)args->a1, (GLint*)args->a2);
break;
case glfnGetUniformLocation:
ret = glGetUniformLocation((GLint)args->a0, (GLchar*)args->a1);
free((void*)args->a1);
break;
case glfnGetVertexAttribfv:
glGetVertexAttribfv((GLuint)args->a0, (GLenum)args->a1, (GLfloat*)args->a2);
break;
case glfnGetVertexAttribiv:
glGetVertexAttribiv((GLuint)args->a0, (GLenum)args->a1, (GLint*)args->a2);
break;
case glfnHint:
glHint((GLenum)args->a0, (GLenum)args->a1);
break;
case glfnIsBuffer:
ret = glIsBuffer((GLint)args->a0);
break;
case glfnIsEnabled:
ret = glIsEnabled((GLenum)args->a0);
break;
case glfnIsFramebuffer:
ret = glIsFramebuffer((GLint)args->a0);
break;
case glfnIsProgram:
ret = glIsProgram((GLint)args->a0);
break;
case glfnIsRenderbuffer:
ret = glIsRenderbuffer((GLint)args->a0);
break;
case glfnIsShader:
ret = glIsShader((GLint)args->a0);
break;
case glfnIsTexture:
ret = glIsTexture((GLint)args->a0);
break;
case glfnLineWidth:
glLineWidth(*(GLfloat*)&args->a0);
break;
case glfnLinkProgram:
glLinkProgram((GLint)args->a0);
break;
case glfnPixelStorei:
glPixelStorei((GLenum)args->a0, (GLint)args->a1);
break;
case glfnPolygonOffset:
glPolygonOffset(*(GLfloat*)&args->a0, *(GLfloat*)&args->a1);
break;
case glfnReadPixels:
glReadPixels((GLint)args->a0, (GLint)args->a1, (GLsizei)args->a2, (GLsizei)args->a3, (GLenum)args->a4, (GLenum)args->a5, (void*)args->a6);
break;
case glfnReleaseShaderCompiler:
glReleaseShaderCompiler();
break;
case glfnRenderbufferStorage:
glRenderbufferStorage((GLenum)args->a0, (GLenum)args->a1, (GLint)args->a2, (GLint)args->a3);
break;
case glfnSampleCoverage:
glSampleCoverage(*(GLfloat*)&args->a0, (GLboolean)args->a1);
break;
case glfnScissor:
glScissor((GLint)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3);
break;
case glfnShaderSource:
#if defined(os_ios) || defined(os_osx)
glShaderSource((GLuint)args->a0, (GLsizei)args->a1, (const GLchar *const *)args->a2, NULL);
#else
glShaderSource((GLuint)args->a0, (GLsizei)args->a1, (const GLchar **)args->a2, NULL);
#endif
free(*(void**)args->a2);
free((void*)args->a2);
break;
case glfnStencilFunc:
glStencilFunc((GLenum)args->a0, (GLint)args->a1, (GLuint)args->a2);
break;
case glfnStencilFuncSeparate:
glStencilFuncSeparate((GLenum)args->a0, (GLenum)args->a1, (GLint)args->a2, (GLuint)args->a3);
break;
case glfnStencilMask:
glStencilMask((GLuint)args->a0);
break;
case glfnStencilMaskSeparate:
glStencilMaskSeparate((GLenum)args->a0, (GLuint)args->a1);
break;
case glfnStencilOp:
glStencilOp((GLenum)args->a0, (GLenum)args->a1, (GLenum)args->a2);
break;
case glfnStencilOpSeparate:
glStencilOpSeparate((GLenum)args->a0, (GLenum)args->a1, (GLenum)args->a2, (GLenum)args->a3);
break;
case glfnTexImage2D:
glTexImage2D(
(GLenum)args->a0,
(GLint)args->a1,
(GLint)args->a2,
(GLsizei)args->a3,
(GLsizei)args->a4,
0, // border
(GLenum)args->a5,
(GLenum)args->a6,
(const GLvoid*)args->a7);
break;
case glfnTexSubImage2D:
glTexSubImage2D(
(GLenum)args->a0,
(GLint)args->a1,
(GLint)args->a2,
(GLint)args->a3,
(GLsizei)args->a4,
(GLsizei)args->a5,
(GLenum)args->a6,
(GLenum)args->a7,
(const GLvoid*)args->a8);
break;
case glfnTexParameterf:
glTexParameterf((GLenum)args->a0, (GLenum)args->a1, *(GLfloat*)&args->a2);
break;
case glfnTexParameterfv:
glTexParameterfv((GLenum)args->a0, (GLenum)args->a1, (GLfloat*)args->a2);
break;
case glfnTexParameteri:
glTexParameteri((GLenum)args->a0, (GLenum)args->a1, (GLint)args->a2);
break;
case glfnTexParameteriv:
glTexParameteriv((GLenum)args->a0, (GLenum)args->a1, (GLint*)args->a2);
break;
case glfnUniform1f:
glUniform1f((GLint)args->a0, *(GLfloat*)&args->a1);
break;
case glfnUniform1fv:
glUniform1fv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)args->a2);
break;
case glfnUniform1i:
glUniform1i((GLint)args->a0, (GLint)args->a1);
break;
case glfnUniform1iv:
glUniform1iv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)args->a2);
break;
case glfnUniform2f:
glUniform2f((GLint)args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2);
break;
case glfnUniform2fv:
glUniform2fv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)args->a2);
break;
case glfnUniform2i:
glUniform2i((GLint)args->a0, (GLint)args->a1, (GLint)args->a2);
break;
case glfnUniform2iv:
glUniform2iv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)args->a2);
break;
case glfnUniform3f:
glUniform3f((GLint)args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2, *(GLfloat*)&args->a3);
break;
case glfnUniform3fv:
glUniform3fv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)args->a2);
break;
case glfnUniform3i:
glUniform3i((GLint)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3);
break;
case glfnUniform3iv:
glUniform3iv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)args->a2);
break;
case glfnUniform4f:
glUniform4f((GLint)args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2, *(GLfloat*)&args->a3, *(GLfloat*)&args->a4);
break;
case glfnUniform4fv:
glUniform4fv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)args->a2);
break;
case glfnUniform4i:
glUniform4i((GLint)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3, (GLint)args->a4);
break;
case glfnUniform4iv:
glUniform4iv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)args->a2);
break;
case glfnUniformMatrix2fv:
glUniformMatrix2fv((GLint)args->a0, (GLsizeiptr)args->a1, 0, (GLvoid*)args->a2);
break;
case glfnUniformMatrix3fv:
glUniformMatrix3fv((GLint)args->a0, (GLsizeiptr)args->a1, 0, (GLvoid*)args->a2);
break;
case glfnUniformMatrix4fv:
glUniformMatrix4fv((GLint)args->a0, (GLsizeiptr)args->a1, 0, (GLvoid*)args->a2);
break;
case glfnUseProgram:
glUseProgram((GLint)args->a0);
break;
case glfnValidateProgram:
glValidateProgram((GLint)args->a0);
break;
case glfnVertexAttrib1f:
glVertexAttrib1f((GLint)args->a0, *(GLfloat*)&args->a1);
break;
case glfnVertexAttrib1fv:
glVertexAttrib1fv((GLint)args->a0, (GLfloat*)args->a1);
break;
case glfnVertexAttrib2f:
glVertexAttrib2f((GLint)args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2);
break;
case glfnVertexAttrib2fv:
glVertexAttrib2fv((GLint)args->a0, (GLfloat*)args->a1);
break;
case glfnVertexAttrib3f:
glVertexAttrib3f((GLint)args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2, *(GLfloat*)&args->a3);
break;
case glfnVertexAttrib3fv:
glVertexAttrib3fv((GLint)args->a0, (GLfloat*)args->a1);
break;
case glfnVertexAttrib4f:
glVertexAttrib4f((GLint)args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2, *(GLfloat*)&args->a3, *(GLfloat*)&args->a4);
break;
case glfnVertexAttrib4fv:
glVertexAttrib4fv((GLint)args->a0, (GLfloat*)args->a1);
break;
case glfnVertexAttribPointer:
glVertexAttribPointer((GLuint)args->a0, (GLint)args->a1, (GLenum)args->a2, (GLboolean)args->a3, (GLsizei)args->a4, (const GLvoid*)args->a5);
break;
case glfnViewport:
glViewport((GLint)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3);
break;
}
}
void gles2_glGetIntegerv(void *_glfuncs, GLenum pname, GLint* params)
{
glGetIntegerv(pname, params);
}
static void init(const WindowInfo &window,const ContextInfo &context, const FramebufferInfo &framebuffer)
{
//initializam de 2 ori?
if(_initialized)
{
std::cout<<"EROARE! GLUT - nu ma poti initializa de 2 ori, ar rezulta crash/eroare"<<std::endl;
return;
}
//copiaza informatie pentru fereastra,context,framebuffer
_context_information = context;
_window_information = window;
_framebuffer_information = framebuffer;
//cerem glut un context OpenGL
glutInitContextVersion(context.major_version, context.minor_version);
glutInitContextFlags(GLUT_DEBUG);
if (context.core)
{
glutInitContextProfile(GLUT_CORE_PROFILE);
}
else {
glutInitContextProfile(GLUT_COMPATIBILITY_PROFILE);
}
//argumente fake pentru ca nu folosim glut in linie de comanda
int fakeargc = 1;
char *fakeargv[] = {"fake", NULL};
glutInit(&fakeargc, fakeargv);
glutInitDisplayMode(framebuffer.flags);
glutInitWindowPosition(window.start_position_x, window.start_position_y);
glutInitWindowSize(window.width, window.height);
glutCreateWindow(window.name.c_str());
//leaga functiile locale la GLUT
glutIdleFunc(_idleCallback);
glutCloseFunc(_closeCallback);
glutDisplayFunc(_displayCallback);
glutReshapeFunc(_reshapeCallback);
glutKeyboardFunc(_keyboardDownCallback);
glutKeyboardUpFunc(_keyboardUpCallback);
glutSpecialFunc(_specialDownCallback);
glutSpecialUpFunc(_specialUpCallback);
glutMotionFunc(_motionCallback);
glutPassiveMotionFunc(_passiveMotionCallback);
glutMouseFunc(_mouseCallback);
glutMouseWheelFunc(_mouseWheelCallback);
//scrie la consola diverse detalii utile
const unsigned char* renderer = glGetString( GL_RENDERER );
const unsigned char* vendor = glGetString( GL_VENDOR );
const unsigned char* version = glGetString( GL_VERSION );
std::cout<<"*******************************************************************************"<<std::endl;
std::cout<<"GLUT:initializare"<<std::endl;
std::cout<<"GLUT:\tVendor : "<<vendor<<std::endl;
std::cout<<"GLUT:\tRenderer : "<<renderer<<std::endl;
std::cout<<"GLUT:\tutilizez versiunea de OpenGl : "<<version<<std::endl;
std::cout<<"GLUT:\tFereasta initiala se numeste `"<<window.name<<"`, are dimensiunile ("<<window.width<<"X"<<window.height;
std::cout<<") incepe de la coordonatele de ecran ("<<window.start_position_x<<"X"<<window.start_position_y;
std::cout<<") si "<<((window.is_reshapable)?"este":"nu este")<<" redimensionabila"<<std::endl;
std::cout<<"GLUT:\tFramebuffer initial contine buffere(duble) pentru"<<std::endl;
if(glutGet(GLUT_WINDOW_RGBA))
{
int r_bits, g_bits, b_bits, a_bits;
glGetIntegerv(GL_RED_BITS, &r_bits); glGetIntegerv(GL_GREEN_BITS, &g_bits);
glGetIntegerv(GL_BLUE_BITS, &b_bits); glGetIntegerv(GL_ALPHA_BITS, &a_bits);
std::cout<<"\tCuloare R"<<r_bits<<"G"<<g_bits<<"B"<<b_bits<<"A"<<a_bits<<std::endl;
}
if(_framebuffer_information.flags&GLUT_DEPTH)
{
int d_bits; glGetIntegerv(GL_DEPTH_BITS, &d_bits);
std::cout<<"\tAdancime DEPTH"<<d_bits<<std::endl;
}
if(_framebuffer_information.flags&GLUT_STENCIL)
{
int s_bits; glGetIntegerv(GL_STENCIL_BITS, &s_bits);
std::cout<<"\tStencil STENCIL"<<s_bits<<std::endl;
}
if(_framebuffer_information.flags&GLUT_MULTISAMPLE)
{
std::cout << "\tmultisampling cu 4 sample-uri per pixel" << std::endl;
}
std::cout<<"GLUT:\tContextul OpenGL este "<<_context_information.major_version<<"."<<_context_information.minor_version;
std::cout<<" si profilul este de "<<((_context_information.core)?"core":"compatibilitate")<<std::endl;
std::cout<<"*******************************************************************************"<<std::endl;
//cand glut este inchis este returnat la main pentru oportunitatea de cleanup corect
glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_GLUTMAINLOOP_RETURNS);
//am terminat cu initializarea!
_initialized=true;
}
bool checkCaps()
{
caps Caps(caps::CORE);
GLint NumCompressedTextureFormats = 0;
glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &NumCompressedTextureFormats);
std::vector<GLint> CompressedTextureFormats(NumCompressedTextureFormats);
glGetIntegerv(GL_COMPRESSED_TEXTURE_FORMATS, &CompressedTextureFormats[0]);
if(this->checkExtension("GL_EXT_texture_compression_s3tc"))
{
if(std::find(CompressedTextureFormats.begin(), CompressedTextureFormats.end(), GL_COMPRESSED_RGB_S3TC_DXT1_EXT) == CompressedTextureFormats.end())
return false;
if(std::find(CompressedTextureFormats.begin(), CompressedTextureFormats.end(), GL_COMPRESSED_RGBA_S3TC_DXT1_EXT) == CompressedTextureFormats.end())
return false;
if(std::find(CompressedTextureFormats.begin(), CompressedTextureFormats.end(), GL_COMPRESSED_RGBA_S3TC_DXT3_EXT) == CompressedTextureFormats.end())
return false;
if(std::find(CompressedTextureFormats.begin(), CompressedTextureFormats.end(), GL_COMPRESSED_RGBA_S3TC_DXT5_EXT) == CompressedTextureFormats.end())
return false;
}
if(this->checkExtension("GL_EXT_texture_sRGB") && this->checkExtension("GL_EXT_texture_compression_s3tc"))
{
if(std::find(CompressedTextureFormats.begin(), CompressedTextureFormats.end(), GL_COMPRESSED_SRGB_S3TC_DXT1_EXT) == CompressedTextureFormats.end())
return false;
if(std::find(CompressedTextureFormats.begin(), CompressedTextureFormats.end(), GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT) == CompressedTextureFormats.end())
return false;
if(std::find(CompressedTextureFormats.begin(), CompressedTextureFormats.end(), GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT) == CompressedTextureFormats.end())
return false;
if(std::find(CompressedTextureFormats.begin(), CompressedTextureFormats.end(), GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT) == CompressedTextureFormats.end())
return false;
}
if(std::find(CompressedTextureFormats.begin(), CompressedTextureFormats.end(), GL_COMPRESSED_RED_RGTC1) == CompressedTextureFormats.end())
return false;
if(std::find(CompressedTextureFormats.begin(), CompressedTextureFormats.end(), GL_COMPRESSED_SIGNED_RED_RGTC1) == CompressedTextureFormats.end())
return false;
if(std::find(CompressedTextureFormats.begin(), CompressedTextureFormats.end(), GL_COMPRESSED_RG_RGTC2) == CompressedTextureFormats.end())
return false;
if(std::find(CompressedTextureFormats.begin(), CompressedTextureFormats.end(), GL_COMPRESSED_SIGNED_RG_RGTC2) == CompressedTextureFormats.end())
return false;
if(std::find(CompressedTextureFormats.begin(), CompressedTextureFormats.end(), GL_COMPRESSED_RGBA_BPTC_UNORM) == CompressedTextureFormats.end())
return false;
if(std::find(CompressedTextureFormats.begin(), CompressedTextureFormats.end(), GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM) == CompressedTextureFormats.end())
return false;
if(std::find(CompressedTextureFormats.begin(), CompressedTextureFormats.end(), GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT) == CompressedTextureFormats.end())
return false;
if(std::find(CompressedTextureFormats.begin(), CompressedTextureFormats.end(), GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT) == CompressedTextureFormats.end())
return false;
if(std::find(CompressedTextureFormats.begin(), CompressedTextureFormats.end(), GL_COMPRESSED_RGB8_ETC2) == CompressedTextureFormats.end())
return false;
if(std::find(CompressedTextureFormats.begin(), CompressedTextureFormats.end(), GL_COMPRESSED_SRGB8_ETC2) == CompressedTextureFormats.end())
return false;
if(std::find(CompressedTextureFormats.begin(), CompressedTextureFormats.end(), GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2) == CompressedTextureFormats.end())
return false;
if(std::find(CompressedTextureFormats.begin(), CompressedTextureFormats.end(), GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2) == CompressedTextureFormats.end())
return false;
if(std::find(CompressedTextureFormats.begin(), CompressedTextureFormats.end(), GL_COMPRESSED_RGBA8_ETC2_EAC) == CompressedTextureFormats.end())
return false;
if(std::find(CompressedTextureFormats.begin(), CompressedTextureFormats.end(), GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC) == CompressedTextureFormats.end())
return false;
if(std::find(CompressedTextureFormats.begin(), CompressedTextureFormats.end(), GL_COMPRESSED_R11_EAC) == CompressedTextureFormats.end())
return false;
if(std::find(CompressedTextureFormats.begin(), CompressedTextureFormats.end(), GL_COMPRESSED_SIGNED_R11_EAC) == CompressedTextureFormats.end())
return false;
if(std::find(CompressedTextureFormats.begin(), CompressedTextureFormats.end(), GL_COMPRESSED_RG11_EAC) == CompressedTextureFormats.end())
return false;
if(std::find(CompressedTextureFormats.begin(), CompressedTextureFormats.end(), GL_COMPRESSED_SIGNED_RG11_EAC) == CompressedTextureFormats.end())
return false;
return true;
}
void Engine::display(bool select)
{
// Setup a perspective projection
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
if (select) {
GLint viewport[4];
glGetIntegerv(GL_VIEWPORT, viewport);
gluPickMatrix(static_cast<GLdouble>(lastMouseX), static_cast<GLdouble>(viewport[3] - lastMouseY), cfg::selectTolerance, cfg::selectTolerance, viewport);
}
gluPerspective(90.f, app->GetWidth()/static_cast<float>(app->GetHeight()), 1.f, 10000.f);
// Clear color and depth buffer
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Apply some transformations
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(cameraPositionX, cameraPositionY, -cameraDistance);
glRotatef(cameraRotationX, 1.f, 0.f, 0.f);
glRotatef(cameraRotationY, 0.f, 1.f, 0.f);
// 3D artists normally use (0,0,1) UP vector instead of (0,1,0)
glRotatef(-90, 1.f, 0.f, 0.f);
// Axes
if (!select && drawAxes) {
glDisable(GL_LIGHTING);
glLineWidth(2.f);
glBegin(GL_LINES);
glColor3f(1.f, 0.f, 0.f);
glVertex3f(0.f, 0.f, 0.f);
glVertex3f(cameraDistance, 0.f, 0.f);
glColor3f(0.f, 1.f, 0.f);
glVertex3f(0.f, 0.f, 0.f);
glVertex3f(0.f, cameraDistance, 0.f);
glColor3f(0.f, 0.f, 1.f);
glVertex3f(0.f, 0.f, 0.f);
glVertex3f(0.f, 0.f, cameraDistance);
glEnd();
glEnable(GL_LIGHTING);
}
// Draw
model->draw();
// Finally, display rendered frame on screen
if (!select)
app->Display();
++frames;
if (frames >= 1000) {
elapsedTime = clock->GetElapsedTime();
cout << "FPS: " << (frames/(elapsedTime-lastTime)) << endl;
lastTime = elapsedTime;
frames = 0;
}
}
GLint getInteger(GLenum token)
{
GLint value;
glGetIntegerv(token, &value);
return value;
}
GLvoid NEHE22::DrawGLScene(){
if (bumps) {
if (useMultitexture && maxTexelUnits>1){
doMesh2TexelUnits();
}
else{
doMesh1TexelUnits();
}
}
else{
doMeshNoBumps();
}
//draw FPS text
GLint matrixMode;
GLboolean lightingOn;
lightingOn= glIsEnabled(GL_LIGHTING); /* lighting on? */
if (lightingOn) glDisable(GL_LIGHTING);
glGetIntegerv(GL_MATRIX_MODE, &matrixMode); /* matrix mode? */
glDisable(GL_TEXTURE_2D);
glDisable(GL_DEPTH_TEST);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glPushAttrib(GL_COLOR_BUFFER_BIT); /* save current colour */
glTranslatef(0.0f,0.0f,-1.0f);
glColor3f(0.8f,0.8f,0.8f);//set text color
computeFPS();
Utils::drawText(-0.98f,-0.98f, GLUT_BITMAP_HELVETICA_12, FPSstr);
glPopAttrib();
glPopMatrix();
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(matrixMode);
if (lightingOn) glEnable(GL_LIGHTING);
glEnable(GL_TEXTURE_2D); // Enable Texture Mapping
glEnable(GL_DEPTH_TEST);
glutSwapBuffers();
// handle keyboard input
if (keys['e']){
keys['e']=false;
emboss=!emboss;
}
if (keys['m']){
keys['m']=false;
useMultitexture=((!useMultitexture) && multitextureSupported);
}
if (keys['b']){
keys['b']=false;
bumps=!bumps;
}
if (keys['f']){
keys['f']=false;
filter++;
filter%=3;
}
if(specialKeys[GLUT_KEY_PAGE_UP]){
z-=0.02f;
}
if(specialKeys[GLUT_KEY_PAGE_DOWN]){
z+=0.02f;
}
if (specialKeys[GLUT_KEY_UP]){
xspeed-=0.01f;
}
if (specialKeys[GLUT_KEY_DOWN]){
xspeed+=0.01f;
}
if (specialKeys[GLUT_KEY_RIGHT]){
yspeed+=0.01f;
}
if (specialKeys[GLUT_KEY_LEFT]){
yspeed-=0.01f;
}
}
/* Render::renderSceneShadowMap: shadow mapping */
void Render::renderSceneShadowMap(PMDObject *objs, const short *order, int num, Stage *stage, bool useMMDLikeCartoon, bool useCartoonRendering, float lightIntensity, const float *lightDirection, const float *lightColor, int shadowMappingTextureSize, bool shadowMappingLightFirst, float shadowMappingSelfDensity)
{
short i;
GLint viewport[4]; /* store viewport */
GLdouble modelview[16]; /* store model view transform */
GLdouble projection[16]; /* store projection transform */
bool toonLight = true;
#ifdef RENDER_SHADOWAUTOVIEW
float eyeDist;
btVector3 v;
#endif /* RENDER_SHADOWAUTOVIEW */
static GLfloat lightdim[] = { 0.2f, 0.2f, 0.2f, 1.0f };
static const GLfloat lightblk[] = { 0.0f, 0.0f, 0.0f, 1.0f };
/* render the depth texture */
/* store the current viewport */
glGetIntegerv(GL_VIEWPORT, viewport);
/* store the current projection matrix */
glGetDoublev(GL_PROJECTION_MATRIX, projection);
/* switch to FBO for depth buffer rendering */
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_fboID);
/* clear the buffer */
/* clear only the depth buffer, since other buffers will not be used */
glClear(GL_DEPTH_BUFFER_BIT);
/* set the viewport to the required texture size */
glViewport(0, 0, shadowMappingTextureSize, shadowMappingTextureSize);
/* reset the projection matrix */
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
/* set the model view matrix to make the light position as eye point and capture the whole scene in the view */
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
#ifdef RENDER_SHADOWAUTOVIEW
/* set the distance to cover all the model range */
eyeDist = m_shadowMapAutoViewRadius / sinf(RENDER_SHADOWAUTOVIEWANGLE * 0.5f * 3.1415926f / 180.0f);
/* set the perspective */
gluPerspective(RENDER_SHADOWAUTOVIEWANGLE, 1.0, 1.0, eyeDist + m_shadowMapAutoViewRadius + 50.0f); /* +50.0f is needed to cover the background */
/* the viewpoint should be at eyeDist far toward light direction from the model center */
v = m_lightVec * eyeDist + m_shadowMapAutoViewEyePoint;
gluLookAt(v.x(), v.y(), v.z(), m_shadowMapAutoViewEyePoint.x(), m_shadowMapAutoViewEyePoint.y(), m_shadowMapAutoViewEyePoint.z(), 0.0, 1.0, 0.0);
#else
/* fixed view */
gluPerspective(25.0, 1.0, 1.0, 120.0);
gluLookAt(30.0, 77.0, 30.0, 0.0, 17.0, 0.0, 0.0, 1.0, 0.0);
#endif /* RENDER_SHADOWAUTOVIEW */
/* keep the current model view for later process */
glGetDoublev(GL_MODELVIEW_MATRIX, modelview);
/* do not write into frame buffer other than depth information */
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
/* also, lighting is not needed */
glDisable(GL_LIGHTING);
/* disable rendering the front surface to get the depth of back face */
glCullFace(GL_FRONT);
/* disable alpha test */
glDisable(GL_ALPHA_TEST);
/* we are now writing to depth texture using FBO, so disable the depth texture mapping here */
glActiveTextureARB(GL_TEXTURE3_ARB);
glDisable(GL_TEXTURE_2D);
glActiveTextureARB(GL_TEXTURE0_ARB);
/* set polygon offset to avoid "moire" */
glEnable(GL_POLYGON_OFFSET_FILL);
glPolygonOffset(4.0, 4.0);
/* render objects for depth */
/* only objects that wants to drop shadow should be rendered here */
for (i = 0; i < num; i++) {
if (objs[order[i]].isEnable() == true) {
objs[order[i]].getPMDModel()->renderForShadow();
}
}
/* reset the polygon offset */
glDisable(GL_POLYGON_OFFSET_FILL);
/* switch to default FBO */
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
/* revert configurations to normal rendering */
glViewport(viewport[0], viewport[1], viewport[2], viewport[3]);
glMatrixMode(GL_PROJECTION);
glLoadMatrixd(projection);
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
glEnable(GL_LIGHTING);
glCullFace(GL_BACK);
glEnable(GL_ALPHA_TEST);
/* clear all the buffers */
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
/* render the full scene */
/* set model view matrix, as the same as normal rendering */
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glMultMatrixf(m_rotMatrix);
/* render the whole scene */
if (shadowMappingLightFirst) {
/* render light setting, later render only the shadow part with dark setting */
stage->renderBackground();
stage->renderFloor();
for (i = 0; i < num; i++) {
if (objs[order[i]].isEnable() == true) {
if (objs[order[i]].getPMDModel()->getToonFlag() == false && toonLight == true) {
/* disable toon lighting */
updateLight(true, false, lightIntensity, lightDirection, lightColor);
toonLight = false;
} else if (objs[order[i]].getPMDModel()->getToonFlag() == true && toonLight == false) {
/* enable toon lighting */
updateLight(useMMDLikeCartoon, useCartoonRendering, lightIntensity, lightDirection, lightColor);
toonLight = true;
}
objs[order[i]].getPMDModel()->renderModel();
objs[order[i]].getPMDModel()->renderEdge();
}
}
if (toonLight == false) {
/* restore toon lighting */
updateLight(useMMDLikeCartoon, useCartoonRendering, lightIntensity, lightDirection, lightColor);
}
} else {
/* render in dark setting, later render only the non-shadow part with light setting */
/* light setting for non-toon objects */
lightdim[0] = lightdim[1] = lightdim[2] = 0.55f - 0.2f * shadowMappingSelfDensity;
glLightfv(GL_LIGHT0, GL_DIFFUSE, lightdim);
glLightfv(GL_LIGHT0, GL_AMBIENT, lightdim);
glLightfv(GL_LIGHT0, GL_SPECULAR, lightblk);
/* render the non-toon objects (back, floor, non-toon models) */
stage->renderBackground();
stage->renderFloor();
for (i = 0; i < num; i++) {
if (objs[order[i]].isEnable() == true && objs[order[i]].getPMDModel()->getToonFlag() == false)
objs[order[i]].getPMDModel()->renderModel();
}
/* for toon objects, they should apply the model-defined toon texture color at texture coordinates (0, 0) for shadow rendering */
/* so restore the light setting */
if (useCartoonRendering == true)
updateLight(useMMDLikeCartoon, useCartoonRendering, lightIntensity, lightDirection, lightColor);
/* render the toon objects */
for (i = 0; i < num; i++) {
if (objs[order[i]].isEnable() == true && objs[order[i]].getPMDModel()->getToonFlag() == true) {
/* set texture coordinates for shadow mapping */
objs[order[i]].getPMDModel()->updateShadowColorTexCoord(shadowMappingSelfDensity);
/* tell model to render with the shadow corrdinates */
objs[order[i]].getPMDModel()->setSelfShadowDrawing(true);
/* render model and edge */
objs[order[i]].getPMDModel()->renderModel();
objs[order[i]].getPMDModel()->renderEdge();
/* disable shadow rendering */
objs[order[i]].getPMDModel()->setSelfShadowDrawing(false);
}
}
if (useCartoonRendering == false)
updateLight(useMMDLikeCartoon, useCartoonRendering, lightIntensity, lightDirection, lightColor);
}
/* render the part clipped by the depth texture */
/* activate the texture unit for shadow mapping and make it current */
glActiveTextureARB(GL_TEXTURE3_ARB);
/* set texture matrix (note: matrices should be set in reverse order) */
glMatrixMode(GL_TEXTURE);
glLoadIdentity();
/* move the range from [-1,1] to [0,1] */
glTranslated(0.5, 0.5, 0.5);
glScaled(0.5, 0.5, 0.5);
/* multiply the model view matrix when the depth texture was rendered */
glMultMatrixd(modelview);
/* multiply the inverse matrix of current model view matrix */
glMultMatrixf(m_rotMatrixInv);
/* revert to model view matrix mode */
glMatrixMode(GL_MODELVIEW);
/* enable texture mapping with texture coordinate generation */
glEnable(GL_TEXTURE_2D);
glEnable(GL_TEXTURE_GEN_S);
glEnable(GL_TEXTURE_GEN_T);
glEnable(GL_TEXTURE_GEN_R);
glEnable(GL_TEXTURE_GEN_Q);
/* bind the depth texture rendered at the first step */
glBindTexture(GL_TEXTURE_2D, m_depthTextureID);
/* depth texture set up was done, now switch current texture unit to default */
glActiveTextureARB(GL_TEXTURE0_ARB);
/* set depth func to allow overwrite for the same surface in the following rendering */
glDepthFunc(GL_LEQUAL);
if (shadowMappingLightFirst) {
/* the area clipped by depth texture by alpha test is dark part */
glAlphaFunc(GL_GEQUAL, 0.1f);
/* light setting for non-toon objects */
lightdim[0] = lightdim[1] = lightdim[2] = 0.55f - 0.2f * shadowMappingSelfDensity;
glLightfv(GL_LIGHT0, GL_DIFFUSE, lightdim);
glLightfv(GL_LIGHT0, GL_AMBIENT, lightdim);
glLightfv(GL_LIGHT0, GL_SPECULAR, lightblk);
/* render the non-toon objects (back, floor, non-toon models) */
stage->renderBackground();
stage->renderFloor();
for (i = 0; i < num; i++) {
if (objs[order[i]].isEnable() == true && objs[order[i]].getPMDModel()->getToonFlag() == false)
objs[order[i]].getPMDModel()->renderModel();
}
/* for toon objects, they should apply the model-defined toon texture color at texture coordinates (0, 0) for shadow rendering */
/* so restore the light setting */
if (useCartoonRendering == true)
updateLight(useMMDLikeCartoon, useCartoonRendering, lightIntensity, lightDirection, lightColor);
/* render the toon objects */
for (i = 0; i < num; i++) {
if (objs[order[i]].isEnable() == true && objs[order[i]].getPMDModel()->getToonFlag() == true) {
/* set texture coordinates for shadow mapping */
objs[order[i]].getPMDModel()->updateShadowColorTexCoord(shadowMappingSelfDensity);
/* tell model to render with the shadow corrdinates */
objs[order[i]].getPMDModel()->setSelfShadowDrawing(true);
/* render model and edge */
objs[order[i]].getPMDModel()->renderModel();
/* disable shadow rendering */
objs[order[i]].getPMDModel()->setSelfShadowDrawing(false);
}
}
if (useCartoonRendering == false)
updateLight(useMMDLikeCartoon, useCartoonRendering, lightIntensity, lightDirection, lightColor);
} else {
/* the area clipped by depth texture by alpha test is light part */
glAlphaFunc(GL_GEQUAL, 0.001f);
stage->renderBackground();
stage->renderFloor();
for (i = 0; i < num; i++) {
if (objs[order[i]].isEnable() == true) {
if (objs[order[i]].getPMDModel()->getToonFlag() == false && toonLight == true) {
/* disable toon lighting */
updateLight(true, false, lightIntensity, lightDirection, lightColor);
toonLight = false;
} else if (objs[order[i]].getPMDModel()->getToonFlag() == true && toonLight == false) {
/* enable toon lighting */
updateLight(useMMDLikeCartoon, useCartoonRendering, lightIntensity, lightDirection, lightColor);
toonLight = true;
}
objs[order[i]].getPMDModel()->renderModel();
}
}
if (toonLight == false) {
/* restore toon lighting */
updateLight(useMMDLikeCartoon, useCartoonRendering, lightIntensity, lightDirection, lightColor);
}
}
/* reset settings */
glDepthFunc(GL_LESS);
glAlphaFunc(GL_GEQUAL, 0.05f);
glActiveTextureARB(GL_TEXTURE3_ARB);
glDisable(GL_TEXTURE_GEN_S);
glDisable(GL_TEXTURE_GEN_T);
glDisable(GL_TEXTURE_GEN_R);
glDisable(GL_TEXTURE_GEN_Q);
glDisable(GL_TEXTURE_2D);
glActiveTextureARB(GL_TEXTURE0_ARB);
}
void GFXGLDevice::enumerateAdapters( Vector<GFXAdapter*> &adapterList )
{
AssertFatal( SDL_WasInit(SDL_INIT_VIDEO), "");
PlatformGL::init(); // for hints about context creation
// Create a dummy window & openGL context so that gl functions can be used here
SDL_Window* tempWindow = SDL_CreateWindow(
"", // window title
SDL_WINDOWPOS_UNDEFINED, // initial x position
SDL_WINDOWPOS_UNDEFINED, // initial y position
640, // width, in pixels
480, // height, in pixels
SDL_WINDOW_OPENGL | SDL_WINDOW_HIDDEN // flags - see below
);
SDL_ClearError();
SDL_GLContext tempContext = SDL_GL_CreateContext( tempWindow );
if( !tempContext )
{
const char *err = SDL_GetError();
Con::printf( err );
AssertFatal(0, err );
return;
}
SDL_ClearError();
SDL_GL_MakeCurrent( tempWindow, tempContext );
const char *err = SDL_GetError();
if( err && err[0] )
{
Con::printf( err );
AssertFatal(0, err );
}
//check minimun Opengl 3.2
int major, minor;
glGetIntegerv(GL_MAJOR_VERSION, &major);
glGetIntegerv(GL_MINOR_VERSION, &minor);
if( major < 3 || ( major == 3 && minor < 2 ) )
{
Con::errorf("GFXGLDevice: Error! Need OpenGL 3.2 at least, have %i.%i.", major, minor);
return;
}
loadGLCore();
GFXAdapter *toAdd = new GFXAdapter;
toAdd->mIndex = 0;
const char* renderer = (const char*) glGetString( GL_RENDERER );
AssertFatal( renderer != NULL, "GL_RENDERER returned NULL!" );
if (renderer)
{
dStrcpy(toAdd->mName, renderer);
dStrncat(toAdd->mName, " OpenGL", GFXAdapter::MaxAdapterNameLen);
}
else
dStrcpy(toAdd->mName, "OpenGL");
toAdd->mType = OpenGL;
toAdd->mShaderModel = 0.f;
toAdd->mCreateDeviceInstanceDelegate = mCreateDeviceInstance;
// Enumerate all available resolutions:
EnumerateVideoModes(toAdd->mAvailableModes);
// Add to the list of available adapters.
adapterList.push_back(toAdd);
// Cleanup window & open gl context
SDL_DestroyWindow( tempWindow );
SDL_GL_DeleteContext( tempContext );
}
/* Render::pickModel: pick up a model at the screen position */
int Render::pickModel(PMDObject *objs, int num, int x, int y, int *allowDropPicked)
{
int i;
GLuint selectionBuffer[512];
GLint viewport[4];
GLint hits;
GLuint *data;
GLuint minDepth = 0, minDepthAllowDrop = 0;
int minID, minIDAllowDrop;
GLuint depth;
int id;
/* get current viewport */
glGetIntegerv(GL_VIEWPORT, viewport);
/* set selection buffer */
glSelectBuffer(512, selectionBuffer);
/* begin selection mode */
glRenderMode(GL_SELECT);
/* save projection matrix */
glMatrixMode(GL_PROJECTION);
glPushMatrix();
/* set projection matrix for picking */
glLoadIdentity();
/* apply picking matrix */
gluPickMatrix(x, viewport[3] - y, 15.0, 15.0, viewport);
/* apply normal projection matrix */
applyProjectionMatrix();
/* switch to model view mode */
glMatrixMode(GL_MODELVIEW);
/* initialize name buffer */
glInitNames();
glPushName(0);
/* draw models with selection names */
for (i = 0; i < num; i++) {
if (objs[i].isEnable() == true) {
glLoadName(i);
objs[i].getPMDModel()->renderForPick();
}
}
/* restore projection matrix */
glMatrixMode(GL_PROJECTION);
glPopMatrix();
/* switch to model view mode */
glMatrixMode(GL_MODELVIEW);
/* end selection mode and get number of hits */
hits = glRenderMode(GL_RENDER);
if (hits == 0) return -1;
data = &(selectionBuffer[0]);
minID = -1;
minIDAllowDrop = -1;
for (i = 0; i < hits; i++) {
depth = *(data + 1);
id = *(data + 3);
if (minID == -1 || minDepth > depth) {
minDepth = depth;
minID = id;
}
if (allowDropPicked && objs[id].allowMotionFileDrop()) {
if (minIDAllowDrop == -1 || minDepthAllowDrop > depth) {
minDepthAllowDrop = depth;
minIDAllowDrop = id;
}
}
data += *data + 3;
}
if (allowDropPicked)
*allowDropPicked = minIDAllowDrop;
return minID;
}
Engine::Engine(util::Dir *data_dir, const char *windowtitle)
:
running(false),
window_size{800, 600},
camgame_phys{10 * coord::settings::phys_per_tile, 10 * coord::settings::phys_per_tile, 0},
camgame_window{400, 300},
camhud_window{0, 600},
tile_halfsize{48, 24}, // TODO: get from convert script
data_dir(data_dir),
audio_manager{48000, AUDIO_S16LSB, 2, 4096}
{
// enqueue the engine's own input handler to the
// execution list.
this->register_input_action(&this->input_handler);
this->input_handler.register_resize_action(this);
if (SDL_Init(SDL_INIT_VIDEO) < 0) {
throw util::Error("SDL video initialization: %s", SDL_GetError());
} else {
log::msg("initialized SDL video subsystems.");
}
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 2);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1);
SDL_GL_SetAttribute(SDL_GL_ACCELERATED_VISUAL, 1);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
int32_t window_flags = SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE | SDL_WINDOW_MAXIMIZED;
this->window = SDL_CreateWindow(
windowtitle,
SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED,
this->window_size.x,
this->window_size.y,
window_flags
);
if (this->window == nullptr) {
throw util::Error("Failed creating SDL window: %s", SDL_GetError());
}
// load support for the PNG image formats, jpg bit: IMG_INIT_JPG
int wanted_image_formats = IMG_INIT_PNG;
int sdlimg_inited = IMG_Init(wanted_image_formats);
if ((sdlimg_inited & wanted_image_formats) != wanted_image_formats) {
throw util::Error("Failed to init PNG support: %s", IMG_GetError());
}
this->glcontext = SDL_GL_CreateContext(this->window);
if (this->glcontext == nullptr) {
throw util::Error("Failed creating OpenGL context: %s", SDL_GetError());
}
// initialize glew, for shaders n stuff
GLenum glew_state = glewInit();
if (glew_state != GLEW_OK) {
throw util::Error("GLEW initialization failed");
}
if (!GLEW_VERSION_2_1) {
throw util::Error("OpenGL 2.1 not available");
}
// to quote the standard doc:
// 'The value gives a rough estimate
// of the largest texture that the GL can handle'
// -> wat?
// anyways, we need at least 1024x1024.
int max_texture_size;
glGetIntegerv(GL_MAX_TEXTURE_SIZE, &max_texture_size);
log::dbg("Maximum supported texture size: %d", max_texture_size);
if (max_texture_size < 1024) {
throw util::Error("Maximum supported texture size too small: %d", max_texture_size);
}
int max_texture_units;
glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &max_texture_units);
log::dbg("Maximum supported texture units: %d", max_texture_units);
if (max_texture_size < 2) {
throw util::Error("Your GPU has too less texture units: %d", max_texture_units);
}
// vsync on
SDL_GL_SetSwapInterval(1);
// enable alpha blending
glEnable(GL_BLEND);
// order of drawing relevant for depth
// what gets drawn last is displayed on top.
glDisable(GL_DEPTH_TEST);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
// initialize debug text font
this->dejavuserif20 = new Font{"DejaVu Serif", "Book", 20};
// initialize job manager with cpucount-2 worker threads
int number_of_worker_threads = SDL_GetCPUCount() - 2;
if (number_of_worker_threads <= 0) {
number_of_worker_threads = 1;
}
this->job_manager = new job::JobManager{number_of_worker_threads};
// initialize audio
auto devices = audio::AudioManager::get_devices();
if (devices.empty()) {
throw util::Error{"No audio devices found"};
}
}
Renderer::Renderer()
{
//the shader used for rendering models
this->debug=true;
this->modelShader.compileShaderFromFile("model.vsh",GLSLShader::VERTEX);
this->modelShader.compileShaderFromFile("model.fsh",GLSLShader::FRAGMENT);
this->modelShader.bindAttribLocation(0,"vertexPosition");
this->modelShader.bindAttribLocation(1,"vertexNormal");
this->modelShader.bindAttribLocation(2,"vertexUv");
if(debug)
cout<<this->modelShader.log();
this->modelShader.link();
if(debug)
cout<<this->modelShader.log();
this->modelShader.setUniform("tex1",0);
//the shader used for rendering the terrain
this->debug=true;
//bbox
this->bBoxShader.compileShaderFromFile("bbox.vsh",GLSLShader::VERTEX);
this->bBoxShader.compileShaderFromFile("bbox.fsh",GLSLShader::FRAGMENT);
this->bBoxShader.bindAttribLocation(3,"bBoxCordsVertex");
if(debug)
cout<<this->bBoxShader.log();
this->bBoxShader.link();
if(debug)
cout<<this->bBoxShader.log();
glUseProgram(0);
if(debug)
{
//info
const GLubyte *vendor = glGetString(GL_VENDOR);
const GLubyte *renderer = glGetString(GL_RENDERER);
const GLubyte *version = glGetString(GL_VERSION);
const GLubyte *glslver = glGetString(GL_SHADING_LANGUAGE_VERSION);
GLint major,minor;
glGetIntegerv(GL_MAJOR_VERSION,&major);
glGetIntegerv(GL_MINOR_VERSION,&minor);
cout <<"vendor: "<<vendor<<endl;
cout <<"renderer: "<<renderer<<endl;
cout <<"openGL version: "<<version<<endl;
cout <<"GLSL version: "<<glslver<<endl;
cout <<"GL version, maj min: "<<major<<minor<<endl;
}
glEnable(GL_DEPTH_TEST); // enable depth-testing
glDepthFunc(GL_LESS); // set depth-testing function type
//glEnable(GL_CULL_FACE); // enable culling of back-faces
//glCullFace(GL_BACK); // enable culling of back-faces
//glFrontFace(GL_CCW);
this->viewMatrix=mat4(0.0f);
this->projMatrix=mat4(0.0f);
}
void vsx_statelist::render()
{
if (render_first)
{
glewInit();
GLint viewport[4];
glGetIntegerv(GL_VIEWPORT, viewport);
if (tex1.has_buffer_support())
{
tex1.init_buffer(viewport[2], viewport[3]);
tex_to.init_buffer(viewport[2], viewport[3]);
get_files_recursive(own_path+"visuals_faders", &fader_file_list,"",".svn CVS");
for (std::list<vsx_string>::iterator it = fader_file_list.begin(); it != fader_file_list.end(); ++it)
{
#ifdef VSXU_DEBUG
printf("initializing fader %s\n", (*it).c_str());
#endif
vsx_engine* lvxe = new vsx_engine();
lvxe->dump_modules_to_disk = false;
lvxe->init(sound_type);
lvxe->start();
lvxe->load_state(*it);
faders.push_back(lvxe);
fade_id = 0;
}
}
transitioning = false;
render_first = false;
if ( state_iter == statelist.end() ) return;
// mark all state_info instances volatile
for (state_iter = statelist.begin(); state_iter != statelist.end(); state_iter++)
{
(*state_iter).is_volatile = true;
}
// go through statelist and load and validate every plugin
std::vector<state_info> new_statelist;
for (state_iter = statelist.begin(); state_iter != statelist.end(); state_iter++)
{
if (init_current((*state_iter).engine, &(*state_iter)) > 0)
{
continue;
}
new_statelist.push_back(*state_iter);
if (option_preload_all == true)
{
while ( (*state_iter).engine->modules_left_to_load )
{
(*state_iter).engine->process_message_queue( &(*state_iter).cmd_in, cmd_out = &(*state_iter).cmd_out,false, true);
(*state_iter).engine->render();
}
}
}
statelist = new_statelist;
// mark all state_info instances non-volatile (engine will be deleted when state_iter will be deleted)
for (state_iter = statelist.begin(); state_iter != statelist.end(); state_iter++)
{
(*state_iter).is_volatile = true;
}
// reset state_iter to a random state
state_iter = statelist.begin();
int steps = rand() % statelist.size();
while (steps) {
++state_iter;
if (state_iter == statelist.end()) state_iter = statelist.begin();
--steps;
}
vxe = (*state_iter).engine;
cmd_in = &(*state_iter).cmd_in;
cmd_out = &(*state_iter).cmd_out;
} // render first
// prevent from rendering by mistake
if ( !statelist.size() ) return;
if ((*state_iter).engine != vxe) // change is on the way
{
if ( tex_to.has_buffer_support() )
{
tex_to.begin_capture();
if ((*state_iter).engine)
{
(*state_iter).engine->process_message_queue(&(*state_iter).cmd_in,&(*state_iter).cmd_out);
(*state_iter).engine->render();
}
glColorMask(false, false, false, true);
glClearColor(0,0,0,1);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glColorMask(true, true, true, true);
tex_to.end_capture();
if (
(*state_iter).engine->modules_left_to_load == 0 &&
(*state_iter).engine->commands_internal.count() == 0 &&
transition_time > 1.0f
)
{
transition_time = 1.0f;
timer.start();
fade_id = rand() % (faders.size());
}
} else
{
transition_time = -1.0f;
}
if (transition_time <= 0.0)
{
vxe = (*state_iter).engine;
cmd_in = &(*state_iter).cmd_in;
cmd_out = &(*state_iter).cmd_out;
transitioning = false;
transition_time = 2.0f;
if (cmd_out && cmd_in)
{
if (vxe)
{
vxe->process_message_queue(cmd_in,cmd_out);
}
cmd_out->clear(true);
}
if (vxe)
{
vxe->render();
}
} else
{
if (cmd_out && cmd_in)
{
if (vxe)
{
vxe->process_message_queue(cmd_in,cmd_out);
}
cmd_out->clear(true);
}
// begin capture
if (tex1.has_buffer_support())
{
tex1.begin_capture();
}
// render
if (vxe)
{
vxe->render();
}
glColorMask(false, false, false, true);
glClearColor(0,0,0,1);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glColorMask(true, true, true, true);
// end capture and send to fader
if (tex1.has_buffer_support())
{
tex1.end_capture();
vsx_module_param_texture* param_t_a = (vsx_module_param_texture*)faders[fade_id]->get_in_param_by_name("visual_fader", "texture_a_in");
vsx_module_param_texture* param_t_b = (vsx_module_param_texture*)faders[fade_id]->get_in_param_by_name("visual_fader", "texture_b_in");
vsx_module_param_float* param_pos = (vsx_module_param_float*)faders[fade_id]->get_in_param_by_name("visual_fader", "fade_pos_in");
vsx_module_param_float* fade_pos_from_engine = (vsx_module_param_float*)faders[fade_id]->get_in_param_by_name("visual_fader", "fade_pos_from_engine");
faders[fade_id]->process_message_queue(&l_cmd_in, &l_cmd_out);
l_cmd_out.clear();
if (param_t_a && param_t_b && param_pos && fade_pos_from_engine)
{
param_t_a->set(&tex1);
param_t_b->set(&tex_to);
fade_pos_from_engine->set(1.0f);
float t = transition_time;
if (t > 1.0f) t = 1.0f;
if (t < 0.0f) t = 0.0f;
param_pos->set(1.0-t);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
faders[fade_id]->render();
}
}
if (transition_time <= 1.0f)
{
transition_time -= timer.dtime();
}
}
} else
{
if (cmd_out && cmd_in)
{
vxe->process_message_queue(cmd_in, cmd_out);
cmd_out->clear();
}
vxe->render();
if (randomizer)
{
randomizer_time -= vxe->engine_info.real_dtime;
if (randomizer_time < 0.0f)
{
random_state();
randomizer_time = (float)(rand()%1000)*0.001f*15.0f+10.0f;
}
}
}
}
/* Initialise the double buffered display */
bool screenInitialise()
{
GLint glMaxTUs;
GLenum err;
glErrors();
err = glewInit();
if (GLEW_OK != err)
{
debug(LOG_FATAL, "Error: %s", glewGetErrorString(err));
exit(1);
}
/* Dump general information about OpenGL implementation to the console and the dump file */
ssprintf(opengl.vendor, "OpenGL Vendor: %s", glGetString(GL_VENDOR));
addDumpInfo(opengl.vendor);
debug(LOG_3D, "%s", opengl.vendor);
ssprintf(opengl.renderer, "OpenGL Renderer: %s", glGetString(GL_RENDERER));
addDumpInfo(opengl.renderer);
debug(LOG_3D, "%s", opengl.renderer);
ssprintf(opengl.version, "OpenGL Version: %s", glGetString(GL_VERSION));
addDumpInfo(opengl.version);
debug(LOG_3D, "%s", opengl.version);
ssprintf(opengl.GLEWversion, "GLEW Version: %s", glewGetString(GLEW_VERSION));
if (strncmp(opengl.GLEWversion, "1.9.", 4) == 0) // work around known bug with KHR_debug extension support in this release
{
debug(LOG_WARNING, "Your version of GLEW is old and buggy, please upgrade to at least version 1.10.");
khr_debug = false;
}
else
{
khr_debug = GLEW_KHR_debug;
}
addDumpInfo(opengl.GLEWversion);
debug(LOG_3D, "%s", opengl.GLEWversion);
GLubyte const *extensionsBegin = glGetString(GL_EXTENSIONS);
if (extensionsBegin == nullptr)
{
static GLubyte const emptyString[] = "";
extensionsBegin = emptyString;
}
GLubyte const *extensionsEnd = extensionsBegin + strlen((char const *)extensionsBegin);
std::vector<std::string> glExtensions;
for (GLubyte const *i = extensionsBegin; i < extensionsEnd;)
{
GLubyte const *j = std::find(i, extensionsEnd, ' ');
glExtensions.push_back(std::string(i, j));
i = j + 1;
}
/* Dump extended information about OpenGL implementation to the console */
std::string line;
for (unsigned n = 0; n < glExtensions.size(); ++n)
{
std::string word = " ";
word += glExtensions[n];
if (n + 1 != glExtensions.size())
{
word += ',';
}
if (line.size() + word.size() > 160)
{
debug(LOG_3D, "OpenGL Extensions:%s", line.c_str());
line.clear();
}
line += word;
}
debug(LOG_3D, "OpenGL Extensions:%s", line.c_str());
debug(LOG_3D, "Notable OpenGL features:");
debug(LOG_3D, " * OpenGL 1.2 %s supported!", GLEW_VERSION_1_2 ? "is" : "is NOT");
debug(LOG_3D, " * OpenGL 1.3 %s supported!", GLEW_VERSION_1_3 ? "is" : "is NOT");
debug(LOG_3D, " * OpenGL 1.4 %s supported!", GLEW_VERSION_1_4 ? "is" : "is NOT");
debug(LOG_3D, " * OpenGL 1.5 %s supported!", GLEW_VERSION_1_5 ? "is" : "is NOT");
debug(LOG_3D, " * OpenGL 2.0 %s supported!", GLEW_VERSION_2_0 ? "is" : "is NOT");
debug(LOG_3D, " * OpenGL 2.1 %s supported!", GLEW_VERSION_2_1 ? "is" : "is NOT");
debug(LOG_3D, " * OpenGL 3.0 %s supported!", GLEW_VERSION_3_0 ? "is" : "is NOT");
debug(LOG_3D, " * Texture compression %s supported.", GLEW_ARB_texture_compression ? "is" : "is NOT");
debug(LOG_3D, " * Two side stencil %s supported.", GLEW_EXT_stencil_two_side ? "is" : "is NOT");
debug(LOG_3D, " * ATI separate stencil is%s supported.", GLEW_ATI_separate_stencil ? "" : " NOT");
debug(LOG_3D, " * Stencil wrap %s supported.", GLEW_EXT_stencil_wrap ? "is" : "is NOT");
debug(LOG_3D, " * Anisotropic filtering %s supported.", GLEW_EXT_texture_filter_anisotropic ? "is" : "is NOT");
debug(LOG_3D, " * Rectangular texture %s supported.", GLEW_ARB_texture_rectangle ? "is" : "is NOT");
debug(LOG_3D, " * FrameBuffer Object (FBO) %s supported.", GLEW_EXT_framebuffer_object ? "is" : "is NOT");
debug(LOG_3D, " * ARB Vertex Buffer Object (VBO) %s supported.", GLEW_ARB_vertex_buffer_object ? "is" : "is NOT");
debug(LOG_3D, " * NPOT %s supported.", GLEW_ARB_texture_non_power_of_two ? "is" : "is NOT");
debug(LOG_3D, " * texture cube_map %s supported.", GLEW_ARB_texture_cube_map ? "is" : "is NOT");
glGetIntegerv(GL_MAX_TEXTURE_UNITS, &glMaxTUs);
debug(LOG_3D, " * Total number of Texture Units (TUs) supported is %d.", (int) glMaxTUs);
debug(LOG_3D, " * GL_ARB_timer_query %s supported!", GLEW_ARB_timer_query ? "is" : "is NOT");
debug(LOG_3D, " * KHR_DEBUG support %s detected", khr_debug ? "was" : "was NOT");
if (!GLEW_VERSION_2_0)
{
debug(LOG_FATAL, "OpenGL 2.0 not supported! Please upgrade your drivers.");
return false;
}
screenWidth = MAX(screenWidth, 640);
screenHeight = MAX(screenHeight, 480);
std::pair<int, int> glslVersion(0, 0);
sscanf((char const *)glGetString(GL_SHADING_LANGUAGE_VERSION), "%d.%d", &glslVersion.first, &glslVersion.second);
/* Dump information about OpenGL 2.0+ implementation to the console and the dump file */
GLint glMaxTIUs, glMaxTCs, glMaxTIUAs, glmaxSamples, glmaxSamplesbuf;
debug(LOG_3D, " * OpenGL GLSL Version : %s", glGetString(GL_SHADING_LANGUAGE_VERSION));
ssprintf(opengl.GLSLversion, "OpenGL GLSL Version : %s", glGetString(GL_SHADING_LANGUAGE_VERSION));
addDumpInfo(opengl.GLSLversion);
glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &glMaxTIUs);
debug(LOG_3D, " * Total number of Texture Image Units (TIUs) supported is %d.", (int) glMaxTIUs);
glGetIntegerv(GL_MAX_TEXTURE_COORDS, &glMaxTCs);
debug(LOG_3D, " * Total number of Texture Coords (TCs) supported is %d.", (int) glMaxTCs);
glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB, &glMaxTIUAs);
debug(LOG_3D, " * Total number of Texture Image Units ARB(TIUAs) supported is %d.", (int) glMaxTIUAs);
glGetIntegerv(GL_SAMPLE_BUFFERS, &glmaxSamplesbuf);
debug(LOG_3D, " * (current) Max Sample buffer is %d.", (int) glmaxSamplesbuf);
glGetIntegerv(GL_SAMPLES, &glmaxSamples);
debug(LOG_3D, " * (current) Max Sample level is %d.", (int) glmaxSamples);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
pie_Skybox_Init();
// Generate backdrop render
backdropGfx = new GFX(GFX_TEXTURE, GL_TRIANGLE_STRIP, 2);
if (GLEW_ARB_timer_query)
{
glGenQueries(PERF_COUNT, perfpos);
}
if (khr_debug)
{
glDebugMessageCallback((GLDEBUGPROC)khr_callback, NULL);
glEnable(GL_DEBUG_OUTPUT);
// Do not want to output notifications. Some drivers spam them too much.
glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DEBUG_SEVERITY_NOTIFICATION, 0, NULL, GL_FALSE);
debug(LOG_3D, "Enabling KHR_debug message callback");
}
glErrors();
return true;
}
// This is the main rendering function that you have to implement and provide to ImGui (via setting up 'RenderDrawListsFn' in the ImGuiIO structure)
// If text or lines are blurry when integrating ImGui in your engine:
// - in your Render function, try translating your projection matrix by (0.5f,0.5f) or (0.375f,0.375f)
void ImGui_ImplSdlGL3_RenderDrawLists(ImDrawData* draw_data)
{
// Backup GL state
GLint last_program; glGetIntegerv(GL_CURRENT_PROGRAM, &last_program);
GLint last_texture; glGetIntegerv(GL_TEXTURE_BINDING_2D, &last_texture);
GLint last_array_buffer; glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &last_array_buffer);
GLint last_element_array_buffer; glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &last_element_array_buffer);
GLint last_vertex_array; glGetIntegerv(GL_VERTEX_ARRAY_BINDING, &last_vertex_array);
GLint last_blend_src; glGetIntegerv(GL_BLEND_SRC, &last_blend_src);
GLint last_blend_dst; glGetIntegerv(GL_BLEND_DST, &last_blend_dst);
GLint last_blend_equation_rgb; glGetIntegerv(GL_BLEND_EQUATION_RGB, &last_blend_equation_rgb);
GLint last_blend_equation_alpha; glGetIntegerv(GL_BLEND_EQUATION_ALPHA, &last_blend_equation_alpha);
GLint last_viewport[4]; glGetIntegerv(GL_VIEWPORT, last_viewport);
GLboolean last_enable_blend = glIsEnabled(GL_BLEND);
GLboolean last_enable_cull_face = glIsEnabled(GL_CULL_FACE);
GLboolean last_enable_depth_test = glIsEnabled(GL_DEPTH_TEST);
GLboolean last_enable_scissor_test = glIsEnabled(GL_SCISSOR_TEST);
// Setup render state: alpha-blending enabled, no face culling, no depth testing, scissor enabled
glEnable(GL_BLEND);
glBlendEquation(GL_FUNC_ADD);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDisable(GL_CULL_FACE);
glDisable(GL_DEPTH_TEST);
glEnable(GL_SCISSOR_TEST);
glActiveTexture(GL_TEXTURE0);
// Handle cases of screen coordinates != from framebuffer coordinates (e.g. retina displays)
ImGuiIO& io = ImGui::GetIO();
int fb_width = (int)(io.DisplaySize.x * io.DisplayFramebufferScale.x);
int fb_height = (int)(io.DisplaySize.y * io.DisplayFramebufferScale.y);
draw_data->ScaleClipRects(io.DisplayFramebufferScale);
// Setup orthographic projection matrix
glViewport(0, 0, (GLsizei)fb_width, (GLsizei)fb_height);
const float ortho_projection[4][4] =
{
{ 2.0f/io.DisplaySize.x, 0.0f, 0.0f, 0.0f },
{ 0.0f, 2.0f/-io.DisplaySize.y, 0.0f, 0.0f },
{ 0.0f, 0.0f, -1.0f, 0.0f },
{-1.0f, 1.0f, 0.0f, 1.0f },
};
glUseProgram(g_ShaderHandle);
glUniform1i(g_AttribLocationTex, 0);
glUniformMatrix4fv(g_AttribLocationProjMtx, 1, GL_FALSE, &ortho_projection[0][0]);
glBindVertexArray(g_VaoHandle);
for (int n = 0; n < draw_data->CmdListsCount; n++)
{
const ImDrawList* cmd_list = draw_data->CmdLists[n];
const ImDrawIdx* idx_buffer_offset = 0;
glBindBuffer(GL_ARRAY_BUFFER, g_VboHandle);
glBufferData(GL_ARRAY_BUFFER, (GLsizeiptr)cmd_list->VtxBuffer.size() * sizeof(ImDrawVert), (GLvoid*)&cmd_list->VtxBuffer.front(), GL_STREAM_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_ElementsHandle);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, (GLsizeiptr)cmd_list->IdxBuffer.size() * sizeof(ImDrawIdx), (GLvoid*)&cmd_list->IdxBuffer.front(), GL_STREAM_DRAW);
for (const ImDrawCmd* pcmd = cmd_list->CmdBuffer.begin(); pcmd != cmd_list->CmdBuffer.end(); pcmd++)
{
if (pcmd->UserCallback)
{
pcmd->UserCallback(cmd_list, pcmd);
}
else
{
glBindTexture(GL_TEXTURE_2D, (GLuint)(intptr_t)pcmd->TextureId);
glScissor((int)pcmd->ClipRect.x, (int)(fb_height - pcmd->ClipRect.w), (int)(pcmd->ClipRect.z - pcmd->ClipRect.x), (int)(pcmd->ClipRect.w - pcmd->ClipRect.y));
glDrawElements(GL_TRIANGLES, (GLsizei)pcmd->ElemCount, sizeof(ImDrawIdx) == 2 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT, idx_buffer_offset);
}
idx_buffer_offset += pcmd->ElemCount;
}
}
// Restore modified GL state
glUseProgram(last_program);
glBindTexture(GL_TEXTURE_2D, last_texture);
glBindBuffer(GL_ARRAY_BUFFER, last_array_buffer);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, last_element_array_buffer);
glBindVertexArray(last_vertex_array);
glBlendEquationSeparate(last_blend_equation_rgb, last_blend_equation_alpha);
glBlendFunc(last_blend_src, last_blend_dst);
if (last_enable_blend) glEnable(GL_BLEND); else glDisable(GL_BLEND);
if (last_enable_cull_face) glEnable(GL_CULL_FACE); else glDisable(GL_CULL_FACE);
if (last_enable_depth_test) glEnable(GL_DEPTH_TEST); else glDisable(GL_DEPTH_TEST);
if (last_enable_scissor_test) glEnable(GL_SCISSOR_TEST); else glDisable(GL_SCISSOR_TEST);
glViewport(last_viewport[0], last_viewport[1], (GLsizei)last_viewport[2], (GLsizei)last_viewport[3]);
}
bool FBODefinition::Create()
{
#if MYFW_WINDOWS
if( glGenFramebuffers == 0 )
{
return false;
}
#endif
#if MYFW_IOS || MYFW_ANDROID
//return false;
#endif
#if !USE_D3D
GLint maxsize;
glGetIntegerv( GL_MAX_RENDERBUFFER_SIZE, &maxsize );
LOGInfo( LOGTag, "CreateFBO - maxsize: %d\n", maxsize );
#if MYFW_ANDROID
int range[2], precision;
glGetShaderPrecisionFormat( GL_FRAGMENT_SHADER, GL_HIGH_FLOAT, range, &precision );
LOGInfo( LOGTag, "CreateFBO - High float precision: %d\n", precision );
LOGInfo( LOGTag, "CreateFBO - High float range min: %d\n", range[0] );
LOGInfo( LOGTag, "CreateFBO - High float range max: %d\n", range[1] );
glGetShaderPrecisionFormat( GL_FRAGMENT_SHADER, GL_MEDIUM_FLOAT, range, &precision );
LOGInfo( LOGTag, "CreateFBO - Medium float precision: %d\n", precision );
LOGInfo( LOGTag, "CreateFBO - Medium float range min: %d\n", range[0] );
LOGInfo( LOGTag, "CreateFBO - Medium float range max: %d\n", range[1] );
glGetShaderPrecisionFormat( GL_FRAGMENT_SHADER, GL_LOW_FLOAT, range, &precision );
LOGInfo( LOGTag, "CreateFBO - Low float precision: %d\n", precision );
LOGInfo( LOGTag, "CreateFBO - Low float range min: %d\n", range[0] );
LOGInfo( LOGTag, "CreateFBO - Low float range max: %d\n", range[1] );
#endif
if( m_TextureWidth > (unsigned int)maxsize || m_TextureHeight > (unsigned int)maxsize )
{
// requested size is too big.
return false;
}
MyAssert( m_FrameBufferID == 0 );
// get a framebuffer, render buffer and a texture from opengl.
glGenFramebuffers( 1, &m_FrameBufferID );
checkGlError( "glGenFramebuffers" );
if( m_NeedColorTexture )
{
m_pColorTexture = MyNew TextureDefinition();
glGenTextures( 1, &m_pColorTexture->m_TextureID );
m_pColorTexture->m_MinFilter = m_MinFilter;
m_pColorTexture->m_MagFilter = m_MagFilter;
m_pColorTexture->m_WrapS = GL_CLAMP_TO_EDGE;
m_pColorTexture->m_WrapT = GL_CLAMP_TO_EDGE;
m_pColorTexture->m_Width = m_Width;
m_pColorTexture->m_Height = m_Height;
}
checkGlError( "glGenTextures" );
if( m_DepthBits != 0 )
{
m_pDepthTexture = MyNew TextureDefinition();
MyAssert( m_DepthBits == 16 || m_DepthBits == 24 || m_DepthBits == 32 );
if( m_DepthIsTexture )
{
glGenTextures( 1, &m_pDepthTexture->m_TextureID );
checkGlError( "glGenTextures" );
}
else
{
glGenRenderbuffers( 1, &m_pDepthTexture->m_TextureID );
checkGlError( "glGenRenderbuffers" );
}
m_pDepthTexture->m_Width = m_Width;
m_pDepthTexture->m_Height = m_Height;
}
// create the texture
if( m_pColorTexture && m_pColorTexture->m_TextureID != 0 )
{
glBindTexture( GL_TEXTURE_2D, m_pColorTexture->m_TextureID );
//glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, m_TextureWidth, m_TextureHeight, 0, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, NULL );
glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, m_TextureWidth, m_TextureHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL );
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_MAG_FILTER, m_MinFilter );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, m_MagFilter );
glBindTexture( GL_TEXTURE_2D, 0 );
checkGlError( "glBindTexture" );
}
// create a depth renderbuffer.
if( m_pDepthTexture && m_pDepthTexture->m_TextureID != 0 )
{
#if !MYFW_OPENGLES2
GLint depthformat = GL_DEPTH_COMPONENT32;
if( m_DepthBits == 24 )
depthformat = GL_DEPTH_COMPONENT24;
else if( m_DepthBits == 16 )
depthformat = GL_DEPTH_COMPONENT16;
#else
GLint depthformat = GL_DEPTH_COMPONENT16;
#endif
if( m_DepthIsTexture )
{
glBindTexture( GL_TEXTURE_2D, m_pDepthTexture->m_TextureID );
checkGlError( "glBindTexture" );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
checkGlError( "glTexParameteri" );
glTexImage2D( GL_TEXTURE_2D, 0, depthformat, m_TextureWidth, m_TextureHeight, 0,
GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, 0 );
//GL_DEPTH_COMPONENT, GL_FLOAT, 0 );
checkGlError( "glTexImage2D" );
glBindTexture( GL_TEXTURE_2D, 0 );
checkGlError( "glBindTexture" );
}
else
{
glBindRenderbuffer( GL_RENDERBUFFER, m_pDepthTexture->m_TextureID );
glRenderbufferStorage( GL_RENDERBUFFER, depthformat, m_TextureWidth, m_TextureHeight );
checkGlError( "glRenderbufferStorageEXT" );
}
}
// attach everything to the FBO
{
MyBindFramebuffer( GL_FRAMEBUFFER, m_FrameBufferID, 0, 0 );
// attach color texture
if( m_pColorTexture && m_pColorTexture->m_TextureID != 0 )
glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_pColorTexture->m_TextureID, 0 );
// attach depth renderbuffer
if( m_pDepthTexture && m_pDepthTexture->m_TextureID != 0 )
{
if( m_DepthIsTexture )
{
glFramebufferTexture2D( GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, m_pDepthTexture->m_TextureID, 0 );
}
else
{
glFramebufferRenderbuffer( GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_pDepthTexture->m_TextureID );
}
}
MyBindFramebuffer( GL_FRAMEBUFFER, 0, 0, 0 );
checkGlError( "glBindFramebufferEXT" );
}
// any problems?
GLint status = glCheckFramebufferStatus( GL_FRAMEBUFFER );
checkGlError( "glCheckFramebufferStatus" );
if( status != GL_FRAMEBUFFER_COMPLETE )
{
LOGInfo( LOGTag, "CreateFBO - error\n" );
//MyAssert( false );
Invalidate( true );
return false;
}
LOGInfo( LOGTag, "CreateFBO - complete (%d, %d)\n", m_TextureWidth, m_TextureHeight );
#else
return false;
#endif
return true;
}
void Shader::load(const char *name) {
Parser *parser = new Parser(name);
// matrixes
num_matrixes = 0;
for(int i = 0; i < NUM_MATRIXES; i++) {
char buf[1024];
sprintf(buf,"matrix%d",i);
if(parser->get(buf)) {
matrixes[num_matrixes].num = i;
getMatrix(parser->get(buf),&matrixes[num_matrixes]);
num_matrixes++;
}
}
// vertex program local parameters
num_vertex_parameters = 0;
for(int i = 0; i < NUM_LOCAL_PARAMETERS; i++) {
char buf[1024];
sprintf(buf,"vertex_local%d",i);
if(parser->get(buf)) {
vertex_parameters[num_vertex_parameters].num = i;
getLocalParameter(parser->get(buf),&vertex_parameters[num_vertex_parameters]);
num_vertex_parameters++;
}
}
// fragement program local parameters
num_fragment_parameters = 0;
for(int i = 0; i < NUM_LOCAL_PARAMETERS; i++) {
char buf[1024];
sprintf(buf,"fragment_local%d",i);
if(parser->get(buf)) {
fragment_parameters[num_fragment_parameters].num = i;
getLocalParameter(parser->get(buf),&fragment_parameters[num_fragment_parameters]);
num_fragment_parameters++;
}
}
char *data;
// vertex program
vertex_target = 0;
vertex_id = 0;
if((data = parser->get("vertex"))) {
int error = -1;
if(!strncmp(data,"!!ARBvp1.0",10)) {
vertex_target = GL_VERTEX_PROGRAM_ARB;
glGenProgramsARB(1,&vertex_id);
glBindProgramARB(vertex_target,vertex_id);
glProgramStringARB(vertex_target,GL_PROGRAM_FORMAT_ASCII_ARB,strlen(data),data);
glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB,&error);
} else {
char *s = data;
while(*s != '\0' && *s != '\n') s++;
*s = '\0';
fprintf(stderr,"Shader::Shader(): unknown vertex program header \"%s\" in \"%s\" file\n",data,name);
}
if(error != -1) {
int line = 0;
char *s = data;
while(error-- && *s) if(*s++ == '\n') line++;
while(s >= data && *s != '\n') s--;
char *e = ++s;
while(*e != '\0' && *e != '\n') e++;
*e = '\0';
fprintf(stderr,"Shader::Shader(): vertex program error in \"%s\" file at line %d:\n\"%s\"\n",name,line,s);
}
}
// fragment program
fragment_target = 0;
fragment_id = 0;
if((data = parser->get("fragment"))) {
int error = -1;
if(!strncmp(data,"!!ARBfp1.0",10)) {
fragment_target = GL_FRAGMENT_PROGRAM_ARB;
glGenProgramsARB(1,&fragment_id);
glBindProgramARB(fragment_target,fragment_id);
glProgramStringARB(fragment_target,GL_PROGRAM_FORMAT_ASCII_ARB,strlen(data),data);
glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB,&error);
} else if(!strncmp(data,"!!FP1.0",7)) {
fragment_target = GL_FRAGMENT_PROGRAM_NV;
glGenProgramsNV(1,&fragment_id);
glBindProgramNV(fragment_target,fragment_id);
glLoadProgramNV(fragment_target,fragment_id,strlen(data),(GLubyte*)data);
glGetIntegerv(GL_PROGRAM_ERROR_POSITION_NV,&error);
} else if(!strncmp(data,"!!ARBtec1.0",11)) { // arb texture env combine
fragment_target = GL_COMBINE;
fragment_id = compileARBtec(data);
} else {
char *s = data;
while(*s != '\0' && *s != '\n') s++;
*s = '\0';
fprintf(stderr,"Shader::Shader(): unknown fragment program header \"%s\" in \"%s\" file\n",data,name);
}
if(error != -1) {
int line = 0;
char *s = data;
while(error-- && *s) if(*s++ == '\n') line++;
while(s >= data && *s != '\n') s--;
char *e = ++s;
while(*e != '\0' && *e != '\n') e++;
*e = '\0';
fprintf(stderr,"Shader::Shader(): fragment program error in \"%s\" file at line %d:\n\"%s\"\n",name,line,s);
}
}
delete parser;
}
//============================================================
// <T>根据代码获得设置内容。</T>
//
// @param 代码
// @return 内容
//============================================================
TInt GlRenderGetInteger(TInt code){
GLint value = 0;
glGetIntegerv(code, &value);
return value;
}
void opengl_extensions_init()
{
opengl_get_extensions();
// if S3TC compression is found, then "GL_ARB_texture_compression" must be an extension
Use_compressed_textures = Is_Extension_Enabled(OGL_EXT_TEXTURE_COMPRESSION_S3TC);
Texture_compression_available = Is_Extension_Enabled(OGL_ARB_TEXTURE_COMPRESSION);
// Swifty put this in, but it's not doing anything. Once he uses it, he can uncomment it.
//int use_base_vertex = Is_Extension_Enabled(OGL_ARB_DRAW_ELEMENTS_BASE_VERTEX);
//allow VBOs to be used
if ( !Cmdline_nohtl && !Cmdline_novbo && Is_Extension_Enabled(OGL_ARB_VERTEX_BUFFER_OBJECT) ) {
Use_VBOs = 1;
}
if ( !Cmdline_no_pbo && Is_Extension_Enabled(OGL_ARB_PIXEL_BUFFER_OBJECT) ) {
Use_PBOs = 1;
}
// setup the best fog function found
if ( !Fred_running ) {
if ( Is_Extension_Enabled(OGL_EXT_FOG_COORD) ) {
OGL_fogmode = 2;
} else {
OGL_fogmode = 1;
}
}
// if we can't do cubemaps then turn off Cmdline_env
if ( !(Is_Extension_Enabled(OGL_ARB_TEXTURE_CUBE_MAP) && Is_Extension_Enabled(OGL_ARB_TEXTURE_ENV_COMBINE)) ) {
Cmdline_env = 0;
}
if ( !(Is_Extension_Enabled(OGL_EXT_GEOMETRY_SHADER4) && Is_Extension_Enabled(OGL_EXT_TEXTURE_ARRAY) && Is_Extension_Enabled(OGL_ARB_DRAW_ELEMENTS_BASE_VERTEX)) ) {
Cmdline_shadow_quality = 0;
mprintf((" No hardware support for shadow mapping. Shadows will be disabled. \n"));
}
if ( !Cmdline_noglsl && Is_Extension_Enabled(OGL_ARB_SHADER_OBJECTS) && Is_Extension_Enabled(OGL_ARB_FRAGMENT_SHADER)
&& Is_Extension_Enabled(OGL_ARB_VERTEX_SHADER) ) {
int ver = 0, major = 0, minor = 0;
const char *glsl_ver = (const char*)glGetString(GL_SHADING_LANGUAGE_VERSION);
sscanf(glsl_ver, "%d.%d", &major, &minor);
ver = (major * 100) + minor;
GLSL_version = ver;
// we require a minimum GLSL version
if (!is_minimum_GLSL_version()) {
mprintf((" OpenGL Shading Language version %s is not sufficient to use GLSL mode in FSO. Defaulting to fixed-function renderer.\n", glGetString(GL_SHADING_LANGUAGE_VERSION) ));
}
}
// can't have this stuff without GLSL support
if ( !is_minimum_GLSL_version() ) {
Cmdline_normal = 0;
Cmdline_height = 0;
Cmdline_postprocess = 0;
Cmdline_shadow_quality = 0;
Cmdline_no_deferred_lighting = 1;
}
if ( GLSL_version < 120 || !Is_Extension_Enabled(OGL_EXT_FRAMEBUFFER_OBJECT) || !Is_Extension_Enabled(OGL_ARB_FLOATING_POINT_TEXTURES) ) {
mprintf((" No hardware support for deferred lighting. Deferred lighting will be disabled. \n"));
Cmdline_no_deferred_lighting = 1;
Cmdline_no_batching = true;
}
if (is_minimum_GLSL_version()) {
GLint max_texture_units;
glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS_ARB, &max_texture_units);
// we need enough texture slots for this stuff to work
if (max_texture_units < 6) {
mprintf(( "Not enough texture units for height map support. We need at least 6, we found %d.\n", max_texture_units ));
Cmdline_height = 0;
} else if (max_texture_units < 5) {
mprintf(( "Not enough texture units for height and normal map support. We need at least 5, we found %d.\n", max_texture_units ));
Cmdline_normal = 0;
Cmdline_height = 0;
} else if (max_texture_units < 4) {
mprintf(( "Not enough texture units found for GLSL support. We need at least 4, we found %d.\n", max_texture_units ));
GLSL_version = 0;
}
}
}
void gl_renderer::init()
{
const SDL_VideoInfo* info = NULL;
bpp = 0;
flags = SDL_OPENGL | SDL_RESIZABLE;
//width = 640;
//height = 480;
width = 1024;
height = 786;
angle = 0;
GLint stencil = 0;
current_camera = game_camera[0] = new desktop_camera();
/* ----- SDL init --------------- */
if(SDL_Init(SDL_INIT_VIDEO) < 0) {
fprintf(stderr, "Video initialization failed: %s\n", SDL_GetError());
exit(-1);
}
atexit(SDL_Quit);
info = SDL_GetVideoInfo();
bpp = info->vfmt->BitsPerPixel;
/* ----- OpenGL attribute setting via SDL --------------- */
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 5);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 5);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 5);
SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
/* ----- Setting up the screen surface --------------- */
screen = SDL_SetVideoMode(width, height, bpp, flags);
if (screen == 0) {
fprintf(stderr, "Video mode set failed: %s\n", SDL_GetError());
exit(-1);
}
glGetIntegerv(GL_STENCIL_BITS, &stencil);
if(stencil == 0){
printf("Stencil buffer not available!\n");
exit(-1);
}
SDL_WM_SetCaption("Norbit fridge in space simulator", NULL);
light1 = (Light){{ 0.0f, 1.5f,-1.5f, 1.0f}, { 0.7f, 0.7f, 0.7f, 1.0f},
{ 0.7f, 0.7f, 0.7f, 1.0f}, { 1.0f, 1.0f, 1.0f, 1.0f}};
light2 = (Light){{-1.5f,-1.8f, 0.0f, 1.0f}, { 0.4f, 0.4f, 0.4f, 1.0f},
{ 0.4f, 0.4f, 0.4f, 1.0f}, { 1.0f, 1.0f, 1.0f, 1.0f}};
/* ----- OpenGL init --------------- */
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
/* The following function replaces gluPerspective */
gluPerspective(45.0f, (GLfloat)width/(GLfloat)height, 0.001f, 100000.0f);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glEnable(GL_TEXTURE_2D);
glEnable(GL_COLOR_MATERIAL);
glShadeModel(GL_SMOOTH);
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClearDepth(1.0f);
glDepthFunc(GL_LEQUAL);
glEnable(GL_DEPTH_TEST);
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT1);
glEnable(GL_LIGHT2);
ship_shape = new obj_shape(new string("ptr_mk1.obj"));
star_shape = new sphere_shape(5.0f);
background_stars = new skybox();
background_stars->init(200.0f);
}
static void Init( int argc, char *argv[] )
{
GLuint texObj[2];
GLint units;
if (!glutExtensionSupported("GL_ARB_multitexture")) {
printf("Sorry, GL_ARB_multitexture not supported by this renderer.\n");
exit(1);
}
if (!glutExtensionSupported("GL_EXT_paletted_texture")) {
printf("Sorry, GL_EXT_paletted_texture not supported by this renderer.\n");
exit(1);
}
glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &units);
printf("%d texture units supported\n", units);
/* allocate two texture objects */
glGenTextures(2, texObj);
/* setup texture obj 0 */
glBindTexture(GL_TEXTURE_2D, texObj[0]);
#ifdef LINEAR_FILTER
/* linear filtering looks much nicer but is much slower for Mesa */
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
foo
#else
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
#endif
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
load_tex(TEXTURE_1_FILE, 0);
#if 0
if (!LoadRGBMipmaps(TEXTURE_1_FILE, GL_RGB)) {
printf("Error: couldn't load texture image\n");
exit(1);
}
#endif
/* setup texture obj 1 */
glBindTexture(GL_TEXTURE_2D, texObj[1]);
#ifdef LINEAR_FILTER
/* linear filtering looks much nicer but is much slower for Mesa */
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
foo
#else
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
#endif
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
load_tex(TEXTURE_2_FILE, 1);
#if 0
if (!LoadRGBMipmaps(TEXTURE_2_FILE, GL_RGB)) {
printf("Error: couldn't load texture image\n");
exit(1);
}
#endif
/* now bind the texture objects to the respective texture units */
#ifdef GL_ARB_multitexture
glActiveTextureARB(GL_TEXTURE0_ARB);
glBindTexture(GL_TEXTURE_2D, texObj[0]);
glActiveTextureARB(GL_TEXTURE1_ARB);
glBindTexture(GL_TEXTURE_2D, texObj[1]);
#endif
glShadeModel(GL_FLAT);
glClearColor(0.3, 0.3, 0.4, 1.0);
ModeMenu(TEXBOTH);
if (argc > 1 && strcmp(argv[1], "-info")==0) {
printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER));
printf("GL_VERSION = %s\n", (char *) glGetString(GL_VERSION));
printf("GL_VENDOR = %s\n", (char *) glGetString(GL_VENDOR));
printf("GL_EXTENSIONS = %s\n", (char *) glGetString(GL_EXTENSIONS));
}
}
bool CRenderSystemGLES::InitRenderSystem()
{
GLint maxTextureSize;
glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxTextureSize);
m_maxTextureSize = maxTextureSize;
m_bVSync = false;
m_iVSyncMode = 0;
m_iSwapStamp = 0;
m_iSwapTime = 0;
m_iSwapRate = 0;
m_bVsyncInit = false;
m_renderCaps = 0;
// Get the GLES version number
m_RenderVersionMajor = 0;
m_RenderVersionMinor = 0;
const char* ver = (const char*)glGetString(GL_VERSION);
if (ver != 0)
{
sscanf(ver, "%d.%d", &m_RenderVersionMajor, &m_RenderVersionMinor);
if (!m_RenderVersionMajor)
sscanf(ver, "%*s %*s %d.%d", &m_RenderVersionMajor, &m_RenderVersionMinor);
m_RenderVersion = ver;
}
// Get our driver vendor and renderer
m_RenderVendor = (const char*) glGetString(GL_VENDOR);
m_RenderRenderer = (const char*) glGetString(GL_RENDERER);
m_RenderExtensions = " ";
m_RenderExtensions += (const char*) glGetString(GL_EXTENSIONS);
m_RenderExtensions += " ";
LogGraphicsInfo();
if (IsExtSupported("GL_TEXTURE_NPOT"))
{
m_renderCaps |= RENDER_CAPS_NPOT;
}
if (IsExtSupported("GL_EXT_texture_format_BGRA8888"))
{
m_renderCaps |= RENDER_CAPS_BGRA;
}
if (IsExtSupported("GL_IMG_texture_format_BGRA8888"))
{
m_renderCaps |= RENDER_CAPS_BGRA;
}
if (IsExtSupported("GL_APPLE_texture_format_BGRA8888"))
{
m_renderCaps |= RENDER_CAPS_BGRA_APPLE;
}
m_bRenderCreated = true;
InitialiseGUIShader();
return true;
}
static CoglBool
_cogl_driver_update_features (CoglContext *context,
CoglError **error)
{
CoglPrivateFeatureFlags private_flags = 0;
char **gl_extensions;
/* We have to special case getting the pointer to the glGetString
function because we need to use it to determine what functions we
can expect */
context->glGetString =
(void *) _cogl_renderer_get_proc_address (context->display->renderer,
"glGetString",
TRUE);
gl_extensions = _cogl_context_get_gl_extensions (context);
if (G_UNLIKELY (COGL_DEBUG_ENABLED (COGL_DEBUG_WINSYS)))
{
char *all_extensions = g_strjoinv (" ", gl_extensions);
COGL_NOTE (WINSYS,
"Checking features\n"
" GL_VENDOR: %s\n"
" GL_RENDERER: %s\n"
" GL_VERSION: %s\n"
" GL_EXTENSIONS: %s",
context->glGetString (GL_VENDOR),
context->glGetString (GL_RENDERER),
_cogl_context_get_gl_version (context),
all_extensions);
g_free (all_extensions);
}
context->glsl_major = 1;
context->glsl_minor = 0;
_cogl_gpu_info_init (context, &context->gpu);
_cogl_feature_check_ext_functions (context,
-1 /* GL major version */,
-1 /* GL minor version */,
gl_extensions);
#ifdef HAVE_COGL_GLES
if (context->driver == COGL_DRIVER_GLES1)
{
int max_clip_planes;
GE( context, glGetIntegerv (GL_MAX_CLIP_PLANES, &max_clip_planes) );
if (max_clip_planes >= 4)
private_flags |= COGL_PRIVATE_FEATURE_FOUR_CLIP_PLANES;
}
#endif
if (context->driver == COGL_DRIVER_GLES2)
{
/* Note GLES 2 core doesn't support mipmaps for npot textures or
* repeat modes other than CLAMP_TO_EDGE. */
COGL_FLAGS_SET (context->features, COGL_FEATURE_ID_GLSL, TRUE);
COGL_FLAGS_SET (context->features, COGL_FEATURE_ID_OFFSCREEN, TRUE);
COGL_FLAGS_SET (context->features,
COGL_FEATURE_ID_TEXTURE_NPOT_BASIC, TRUE);
COGL_FLAGS_SET (context->features, COGL_FEATURE_ID_DEPTH_RANGE, TRUE);
COGL_FLAGS_SET (context->features,
COGL_FEATURE_ID_MIRRORED_REPEAT, TRUE);
COGL_FLAGS_SET (context->features,
COGL_FEATURE_ID_PER_VERTEX_POINT_SIZE, TRUE);
private_flags |= COGL_PRIVATE_FEATURE_BLEND_CONSTANT;
}
else if (context->driver == COGL_DRIVER_GLES1)
private_flags |= (COGL_PRIVATE_FEATURE_GL_FIXED |
COGL_PRIVATE_FEATURE_ALPHA_TEST |
COGL_PRIVATE_FEATURE_BUILTIN_POINT_SIZE_UNIFORM);
private_flags |= (COGL_PRIVATE_FEATURE_VBOS |
COGL_PRIVATE_FEATURE_ANY_GL |
COGL_PRIVATE_FEATURE_ALPHA_TEXTURES);
/* Both GLES 1.1 and GLES 2.0 support point sprites in core */
COGL_FLAGS_SET (context->features, COGL_FEATURE_ID_POINT_SPRITE, TRUE);
if (context->glGenRenderbuffers)
COGL_FLAGS_SET (context->features, COGL_FEATURE_ID_OFFSCREEN, TRUE);
if (context->glBlitFramebuffer)
private_flags |= COGL_PRIVATE_FEATURE_OFFSCREEN_BLIT;
if (_cogl_check_extension ("GL_OES_element_index_uint", gl_extensions))
COGL_FLAGS_SET (context->features,
COGL_FEATURE_ID_UNSIGNED_INT_INDICES, TRUE);
if (_cogl_check_extension ("GL_OES_depth_texture", gl_extensions))
COGL_FLAGS_SET (context->features, COGL_FEATURE_ID_DEPTH_TEXTURE, TRUE);
if (_cogl_check_extension ("GL_OES_texture_npot", gl_extensions))
{
COGL_FLAGS_SET (context->features,
COGL_FEATURE_ID_TEXTURE_NPOT, TRUE);
COGL_FLAGS_SET (context->features,
COGL_FEATURE_ID_TEXTURE_NPOT_BASIC, TRUE);
COGL_FLAGS_SET (context->features,
COGL_FEATURE_ID_TEXTURE_NPOT_MIPMAP, TRUE);
COGL_FLAGS_SET (context->features,
COGL_FEATURE_ID_TEXTURE_NPOT_REPEAT, TRUE);
}
else if (_cogl_check_extension ("GL_IMG_texture_npot", gl_extensions))
{
COGL_FLAGS_SET (context->features,
COGL_FEATURE_ID_TEXTURE_NPOT_BASIC, TRUE);
COGL_FLAGS_SET (context->features,
COGL_FEATURE_ID_TEXTURE_NPOT_MIPMAP, TRUE);
}
if (context->glTexImage3D)
COGL_FLAGS_SET (context->features, COGL_FEATURE_ID_TEXTURE_3D, TRUE);
if (context->glMapBuffer)
/* The GL_OES_mapbuffer extension doesn't support mapping for
read */
COGL_FLAGS_SET (context->features,
COGL_FEATURE_ID_MAP_BUFFER_FOR_WRITE, TRUE);
if (context->glEGLImageTargetTexture2D)
private_flags |= COGL_PRIVATE_FEATURE_TEXTURE_2D_FROM_EGL_IMAGE;
if (_cogl_check_extension ("GL_OES_packed_depth_stencil", gl_extensions))
private_flags |= COGL_PRIVATE_FEATURE_OES_PACKED_DEPTH_STENCIL;
if (_cogl_check_extension ("GL_EXT_texture_format_BGRA8888", gl_extensions))
private_flags |= COGL_PRIVATE_FEATURE_TEXTURE_FORMAT_BGRA8888;
if (_cogl_check_extension ("GL_EXT_unpack_subimage", gl_extensions))
private_flags |= COGL_PRIVATE_FEATURE_UNPACK_SUBIMAGE;
/* A nameless vendor implemented the extension, but got the case wrong
* per the spec. */
if (_cogl_check_extension ("GL_OES_EGL_sync", gl_extensions) ||
_cogl_check_extension ("GL_OES_egl_sync", gl_extensions))
private_flags |= COGL_PRIVATE_FEATURE_OES_EGL_SYNC;
/* Cache features */
context->private_feature_flags |= private_flags;
g_strfreev (gl_extensions);
return TRUE;
}
