void draw_ingame_interface()
{
#ifdef OPENGL_TRACE
CHECK_GL_ERRORS();
#endif //OPENGL_TRACE
#ifdef OLD_CLOSE_BAG
// watch for closing a bag
if(ground_items_win >= 0)
{
int old_view= view_ground_items;
view_ground_items= get_show_window(ground_items_win);
// watch for telling the server we need to close the bag
if(old_view && !view_ground_items)
{
unsigned char protocol_name;
protocol_name= S_CLOSE_BAG;
my_tcp_send(my_socket,&protocol_name,1);
}
}
#endif //OLD_CLOSE_BAG
glColor3f(1.0f, 1.0f, 1.0f);
draw_hud_frame();
//draw_hud_interface();
display_spells_we_have();
#ifdef OPENGL_TRACE
CHECK_GL_ERRORS();
#endif //OPENGL_TRACE
}
void Enter2DModeExtended(int width, int height)
{
#ifdef OPENGL_TRACE
CHECK_GL_ERRORS();
#endif //OPENGL_TRACE
if (use_fog) glDisable(GL_FOG);
glPushAttrib(GL_LIGHTING_BIT|GL_DEPTH_BUFFER_BIT);
glDisable(GL_LIGHTING);
glDisable(GL_DEPTH_TEST);
glViewport(0, 0, width, height);
#ifdef OPENGL_TRACE
CHECK_GL_ERRORS();
#endif //OPENGL_TRACE
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
glOrtho(0.0, (GLdouble)width, (GLdouble)height, 0.0, -1.0, 1.0);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
#ifdef OPENGL_TRACE
CHECK_GL_ERRORS();
#endif //OPENGL_TRACE
}
texture_t::texture_t(aasset_buffer_t& buffer)
: _alpha(false)
{
raw_bitmap_t bitmap;
png_load_from_memory(buffer, &bitmap);
//Now generate the OpenGL texture object
glGenTextures(1, &_id);
glBindTexture(GL_TEXTURE_2D, _id);
CHECK_GL_ERRORS("Error texture bind");
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);
CHECK_GL_ERRORS("Error texture parameter setting");
glTexImage2D(GL_TEXTURE_2D, 0, bitmap.format(), bitmap.width(), bitmap.height(), 0, bitmap.format(),
GL_UNSIGNED_BYTE, (GLvoid*) bitmap.data());
CHECK_GL_ERRORS("Error texture createing");
glBindTexture(GL_TEXTURE_2D, 0);
CHECK_GL_ERRORS("Couldn't load texture");
if (bitmap.alpha()) _alpha = true;
}
TextureFBO::TextureFBO(unsigned int width, unsigned int height, int targets, bool storeDepth, int format) {
this->width = width;
this->height = height;
texture.resize(targets);
// Initialize Texture
glGenTextures(targets, &texture[0]);
for (size_t i = 0; i < targets; i++) {
glBindTexture(GL_TEXTURE_2D, texture[i]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, GL_RGBA, GL_FLOAT, NULL);
}
if(!storeDepth){
//Create depth bufferGLuint rboId;
glGenRenderbuffers(1, &depth);
glBindRenderbuffer(GL_RENDERBUFFER_EXT, depth);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT24, width, height);
glBindRenderbuffer(GL_RENDERBUFFER, 0);
}else{
glGenTextures(1, &depth);
glBindTexture(GL_TEXTURE_2D, depth);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE);
//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL);
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT24, width, height, 0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL);
}
CHECK_GL_ERRORS();
// Create FBO and attach buffers
glGenFramebuffers(1, &fbo);
glBindFramebuffer(GL_FRAMEBUFFER, fbo);
std::vector<GLenum> attachments;
for (uint i = 0; i < targets; i++) {
attachments.push_back(GL_COLOR_ATTACHMENT0+i);
glFramebufferTexture2D(GL_FRAMEBUFFER, attachments[i], GL_TEXTURE_2D, texture[i], 0);
}
glDrawBuffers(targets, attachments.data());
if (!storeDepth) {
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, depth);
}else{
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, depth, 0);
}
CHECK_GL_ERRORS();
CHECK_GL_FBO_COMPLETENESS();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
}
int draw_string_zoomed_width (int x, int y, const unsigned char * our_string, int max_width, int max_lines, float text_zoom)
{
float displayed_font_x_size= DEFAULT_FONT_X_LEN*text_zoom;
float displayed_font_y_size= DEFAULT_FONT_Y_LEN*text_zoom;
unsigned char cur_char;
int i;
int cur_x,cur_y;
int current_lines= 1;
#ifdef OPENGL_TRACE
CHECK_GL_ERRORS();
#endif //OPENGL_TRACE
glEnable(GL_ALPHA_TEST);//enable alpha filtering, so we have some alpha key
glAlphaFunc(GL_GREATER,0.1f);
bind_texture(font_text);
i=0;
cur_x=x;
cur_y=y;
glBegin(GL_QUADS);
while(1)
{
cur_char=our_string[i];
// watch for special characters
if(!cur_char) // end of line
{
break;
}
else if (cur_char == '\n' || cur_char == '\r') // newline
{
cur_y+=displayed_font_y_size;
cur_x=x;
i++;
current_lines++;
if(current_lines>max_lines)break;
continue;
}
else if (cur_x+displayed_font_x_size-x>=max_width){
cur_y+=displayed_font_y_size;
cur_x=x;
current_lines++;
if(current_lines>max_lines)break;
}
cur_x+=draw_char_scaled(cur_char, cur_x, cur_y, displayed_font_x_size, displayed_font_y_size);
i++;
}
glEnd();
glDisable(GL_ALPHA_TEST);
#ifdef OPENGL_TRACE
CHECK_GL_ERRORS();
#endif //OPENGL_TRACE
return current_lines;
}
void draw_scene()
{
CHECK_GL_ERRORS();
glClearColor(skybox_fog_color[0], skybox_fog_color[1], skybox_fog_color[2], 0.0);
if(!shadows_on || !have_stencil)glClear(GL_DEPTH_BUFFER_BIT|GL_COLOR_BUFFER_BIT);
else glClear(GL_DEPTH_BUFFER_BIT|GL_COLOR_BUFFER_BIT|GL_STENCIL_BUFFER_BIT);
if (!have_display)
{
new_zoom_level = zoom_level; // No scrolling when switching modes...
if (quickbar_relocatable && quickbar_win >= 0) // Hack
{
if (get_show_window (quickbar_win) && windows_list.window[quickbar_win].cur_x < window_width - hud_x && window_height - windows_list.window[quickbar_win].cur_y > hud_y)
hide_window (quickbar_win);
}
}
glLoadIdentity (); // Reset The Matrix
Enter2DMode ();
display_windows (1);
// Have to draw the dragged item *after* all windows
glColor3f(1.0f,1.0f,1.0f);
if (item_dragged != -1)
drag_item (item_dragged, 0, 0);
else if (use_item != -1 && current_cursor == CURSOR_USE_WITEM)
drag_item (use_item, 0, 1);
else if (storage_item_dragged != -1)
drag_item (storage_item_dragged, 1, 0);
draw_special_cursors();
Leave2DMode ();
if(elwin_mouse >= 0)
{
if (current_cursor != elwin_mouse) change_cursor(elwin_mouse);
elwin_mouse = -1;
}
SDL_GL_SwapBuffers();
CHECK_GL_ERRORS();
/* start or stop the harvesting effect depending on harvesting state */
check_harvesting_effect();
if (draw_delay > 0)
{
SDL_Delay (draw_delay);
draw_delay = 0;
}
}
void draw_string_small(int x, int y,const unsigned char * our_string,int max_lines)
{
//int displayed_font_x_size=SMALL_FONT_X_LEN;
//int displayed_font_y_size=SMALL_FONT_Y_LEN;
unsigned char cur_char;
int i;
int cur_x,cur_y;
int current_lines=0;
#ifdef OPENGL_TRACE
CHECK_GL_ERRORS();
#endif //OPENGL_TRACE
glEnable(GL_ALPHA_TEST);//enable alpha filtering, so we have some alpha key
glAlphaFunc(GL_GREATER,0.1f);
#ifdef NEW_TEXTURES
bind_texture(font_text);
#else /* NEW_TEXTURES */
get_and_set_texture_id(font_text);
#endif /* NEW_TEXTURES */
i=0;
cur_x=x;
cur_y=y;
glBegin(GL_QUADS);
while(1)
{
cur_char=our_string[i];
if(!cur_char)
{
break;
}
else if(cur_char=='\n')
{
cur_y+=SMALL_FONT_Y_LEN;
cur_x=x;
i++;
current_lines++;
if(current_lines>=max_lines)break;
continue;
}
cur_x+=draw_char_scaled(cur_char, cur_x, cur_y, SMALL_FONT_X_LEN, SMALL_FONT_Y_LEN);
i++;
}
glEnd();
glDisable(GL_ALPHA_TEST);
#ifdef OPENGL_TRACE
CHECK_GL_ERRORS();
#endif //OPENGL_TRACE
}
void AppManager::runKernel(double dt){
kernel1->bind();
glViewport(0, 0, Nx, Ny);
lax_f->use();
float rx = (float)dt/(1.0f/(float)Nx);
float ry = (float)dt/(1.0f/(float)Ny);
//set uniforms
glUniform1f(lax_f->getUniform("rx"), rx);
glUniform1f(lax_f->getUniform("ry"), ry);
glUniform1f(lax_f->getUniform("gamma"), gamma);
glUniform1i(lax_f->getUniform("QTex"), 0);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, kernel0->getTexture());
glBindVertexArray(vao);
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, NULL);
glBindVertexArray(0);
lax_f->disuse();
kernel1->unbind();
// Flip kernels for next iteration
TextureFBO* temp = kernel0;
kernel0 = kernel1;
kernel1 = temp;
CHECK_GL_ERRORS();
/* DOWNLOAD RESULTS */
glBindTexture(GL_TEXTURE_2D, kernel0->getTexture());
std::vector<GLfloat> data(Nx*Ny*4);
glGetTexImage(GL_TEXTURE_2D,0,GL_RGBA,GL_FLOAT,&data[0]);
glBindTexture(GL_TEXTURE_2D, 0);
float max = 0.0;
for (size_t x = 0; x < Nx; x++) {
for (size_t y = 0; y < Ny; y++) {
max = glm::max(max,data[(Nx * y + x)*4]);
}
}
std::cout << max << std::endl;
/* DOWNLOAD END */
CHECK_GL_ERRORS();
}
GLuint compileShader(const char *shaderFilename, ShaderType shaderType) {
GLchar *shaderSource;
GLuint shader;
shaderSource = fileToCharArray(shaderFilename);
switch (shaderType) {
case ShaderTypeVertex:
shader = glCreateShader(GL_VERTEX_SHADER);
break;
case ShaderTypeFragment:
shader = glCreateShader(GL_FRAGMENT_SHADER);
break;
case ShaderTypeGeometry:
shader = glCreateShader(GL_GEOMETRY_SHADER);
break;
default:
return 0;
}
CHECK_GL_ERRORS();
glShaderSource(shader, 1, (const GLchar**)&shaderSource, 0);
CHECK_GL_ERRORS();
glCompileShader(shader);
CHECK_GL_ERRORS();
free(shaderSource);
int isShaderCompiled;
glGetShaderiv(shader, GL_COMPILE_STATUS, &isShaderCompiled);
if (isShaderCompiled == FALSE) {
int maxLength;
glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &maxLength);
char *infoLog = (char *)malloc(maxLength);
glGetShaderInfoLog(shader, maxLength, &maxLength, infoLog);
printf("Error compiling shader: %s\n", shaderFilename);
printf("Error: %s\n", infoLog);
free(infoLog);
return 0;
}
return shader;
}
void OpenGL3RenderState::set_scissor(OpenGL3ContextState& state, const ScissorDesc& scissor_desc) const
{
if (state.scissor_test == scissor_desc.enabled && state.scissor == scissor_desc.scissor_rect)
return;
if (scissor_desc.enabled)
glEnable(GL_SCISSOR_TEST);
else
glDisable(GL_SCISSOR_TEST);
CHECK_GL_ERRORS();
glScissor(scissor_desc.scissor_rect.ll().x(), scissor_desc.scissor_rect.ll().y(),
scissor_desc.scissor_rect.width(), scissor_desc.scissor_rect.height());
CHECK_GL_ERRORS();
state.scissor = scissor_desc.scissor_rect;
state.scissor_test = scissor_desc.enabled;
}
void reload_fonts()
{
int i;
int poor_man_save=poor_man;
int use_mipmaps_save=use_mipmaps;
poor_man=0;
use_mipmaps=0;
for(i=0;i < FONTS_ARRAY_SIZE; i++){
if(fonts[i] != NULL){
if(fonts[i]->texture_id>=0){
glDeleteTextures(1, (GLuint*)&texture_cache[fonts[i]->texture_id].texture_id);
texture_cache[fonts[i]->texture_id].texture_id=0;
get_texture_id(fonts[i]->texture_id);
}
}
}
poor_man=poor_man_save;
use_mipmaps=use_mipmaps_save;
#ifdef OPENGL_TRACE
CHECK_GL_ERRORS();
#endif //OPENGL_TRACE
}
void HZMap::build(){
glBindFramebuffer(GL_FRAMEBUFFER, fbo);
glBindTexture(GL_TEXTURE_2D, texture);
int numLevels = 1 + (int)glm::floor(glm::log2(glm::max((float)width, (float)height)));
int cWidth = width;
int cHeight = height;
for (int i = 1; i < numLevels; i++) {
HZMbuilder->use();
glUniform2iv(HZMbuilder->getUniform("lastMipSize"),1,
glm::value_ptr(glm::ivec2(cWidth,cHeight)));
cWidth /= 2;
cHeight /= 2;
cWidth = (cWidth > 0) ? cWidth : 1;
cHeight = (cHeight > 0) ? cHeight : 1;
glViewport(0,0,cWidth,cHeight);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, i-1);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, i-1);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, texture, i);
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
CHECK_GL_ERRORS();
CHECK_GL_FBO_COMPLETENESS();
// Render full screen quad
quad->render(HZMbuilder);
}
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, numLevels-1);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
}
void display_book(book * b, int type)
{
page ** p=&b->pages[b->active_page];
int x=0;
switch(type){
case 2:
glPushMatrix();
glTranslatef(x,0,0);
display_page(b,*p);
glPopMatrix();
if(b->no_pages<=b->active_page)
break;
p++;
x+=250;
case 1:
default:
glPushMatrix();
glTranslatef(x,0,0);
display_page(b,*p);
glPopMatrix();
break;
}
#ifdef OPENGL_TRACE
CHECK_GL_ERRORS();
#endif //OPENGL_TRACE
}
void AppManager::createVAO(){
GLfloat quad_vertices[] = {
-1.0f, -1.0f,
1.0f, -1.0f,
1.0f, 1.0f,
-1.0f, 1.0f,
};
vert = new BO<GL_ARRAY_BUFFER>(quad_vertices, sizeof(quad_vertices));
GLubyte quad_indices[] = {
0, 1, 2, //triangle 1
2, 3, 0, //triangle 2
};
ind = new BO<GL_ELEMENT_ARRAY_BUFFER>(quad_indices, sizeof(quad_indices));
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
visualize->use();
vert->bind();
visualize->setAttributePointer("position", 2);
ind->bind();
glBindVertexArray(0);
CHECK_GL_ERRORS();
}
void OpenGL3Driver::bind_uniform(const UniformBuffer& uniform, size_t unit)
{
const OpenGL3UniformBuffer* buffer = static_cast<const OpenGL3UniformBuffer*>(uniform.impl());
// TODO: need to add state checks
buffer->bind(current_shader_program_, unit);
CHECK_GL_ERRORS();
}
void AppManager::render(){
double dt = 1e-45f;//timer.elapsedAndRestart();
runKernel(dt);
glViewport(0, 0, window_width*2, window_height*2);
visualize->use();
float rx = (1.0f/(float)Nx);
float ry = (1.0f/(float)Ny);
glUniform1f(visualize->getUniform("rx"), rx);
glUniform1f(visualize->getUniform("ry"), ry);
glUniform1i(visualize->getUniform("QTex"), 0);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, kernel0->getTexture());
glBindVertexArray(vao);
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, NULL);
glBindVertexArray(0);
visualize->disuse();
CHECK_GL_ERRORS();
}
void display_highlight_markers() {
int i;
if (!highlighting_enabled) return;
glDisable(GL_TEXTURE_2D);
glDisable(GL_LIGHTING);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE);
glEnable(GL_ALPHA_TEST);
for(i = 0; i < NUMBER_OF_HIGHLIGHT_MARKERS; i++) {
if (markers[i].active) {
markers[i].timeleft -= (cur_time - last_time);
if (markers[i].timeleft > 0) {
display_highlight_marker(&markers[i]);
} else {
// This marker has lived long enough now.
markers[i].active = 0;
}
}
}
glDisable(GL_ALPHA_TEST);
glEnable(GL_LIGHTING);
glDisable(GL_BLEND);
#ifdef OPENGL_TRACE
CHECK_GL_ERRORS();
#endif //OPENGL_TRACE
}
static __inline__ void render_submesh(int meshId, int submeshCount, struct CalRenderer * pCalRenderer, float meshVertices[30000][3], float meshNormals[30000][3], float meshTextureCoordinates[30000][2], CalIndex meshFaces[50000][3], Uint32 use_lightning, Uint32 use_textures)
{
int submeshId;
int faceCount=0;
for(submeshId = 0; submeshId < submeshCount; submeshId++) {
// select mesh and submesh for further data access
if(CalRenderer_SelectMeshSubmesh(pCalRenderer,meshId, submeshId)) {
// get the transformed vertices of the submesh
CalRenderer_GetVertices(pCalRenderer,&meshVertices[0][0]);
// get the transformed normals of the submesh
if (use_lightning)
{
CalRenderer_GetNormals(pCalRenderer,&meshNormals[0][0]);
}
// get the texture coordinates of the submesh
if (use_textures)
{
CalRenderer_GetTextureCoordinates(pCalRenderer,0,&meshTextureCoordinates[0][0]);
}
// get the faces of the submesh
faceCount = CalRenderer_GetFaces(pCalRenderer, &meshFaces[0][0]);
// set the vertex and normal buffers
glVertexPointer(3, GL_FLOAT, 0, &meshVertices[0][0]);
if (use_lightning)
{
glEnableClientState(GL_NORMAL_ARRAY);
glNormalPointer(GL_FLOAT, 0, &meshNormals[0][0]);
}
else
{
glDisableClientState(GL_NORMAL_ARRAY);
}
// draw the submesh
if (use_textures)
{
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, 0, &meshTextureCoordinates[0][0]);
}
else
{
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
}
if(sizeof(CalIndex)==2)
glDrawElements(GL_TRIANGLES, faceCount * 3, GL_UNSIGNED_SHORT, &meshFaces[0][0]);
else
glDrawElements(GL_TRIANGLES, faceCount * 3, GL_UNSIGNED_INT, &meshFaces[0][0]);
}
}
#ifdef OPENGL_TRACE
CHECK_GL_ERRORS();
#endif //OPENGL_TRACE
}
void load_exploration_map ()
{
FILE *fp = NULL;
char exploration_map_filename[256];
if(!minimap_texture)
return;
my_strcp (exploration_map_filename, map_file_name);
exploration_map_filename[strlen(exploration_map_filename)-4] = 0;
strcat (exploration_map_filename, ".xm");
safe_strncpy (current_exploration_map_filename, exploration_map_filename, sizeof (current_exploration_map_filename));
fp = open_file_config (exploration_map_filename, "rb");
if(fp)
{
if (fread(exploration_map, sizeof(GLubyte), 256 * 256, fp) != 256 * 256)
{
memset(exploration_map, 0, 256 * 256 * sizeof(GLubyte));
LOG_ERROR("%s() read failed for file [%s]\n", __FUNCTION__, exploration_map_filename);
}
fclose(fp);
}
else
{
memset(exploration_map, 0, 256 * 256 * sizeof(GLubyte));
}
if(poor_man)
{
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
}
else if(use_mipmaps)
{
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP_SGIS, GL_TRUE);
}
else
{
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
}
if(have_extension(arb_texture_compression))
{
if(have_extension(ext_texture_compression_s3tc))
glTexImage2D(GL_TEXTURE_2D,0,GL_COMPRESSED_RGB_S3TC_DXT1_EXT, minimap_size, minimap_size,0,GL_LUMINANCE,GL_UNSIGNED_BYTE,&exploration_map);
else
glTexImage2D(GL_TEXTURE_2D,0,GL_COMPRESSED_LUMINANCE, minimap_size, minimap_size,0,GL_ALPHA,GL_UNSIGNED_BYTE,&exploration_map);
}
else
glTexImage2D(GL_TEXTURE_2D,0,GL_LUMINANCE, minimap_size, minimap_size,0,GL_LUMINANCE,GL_UNSIGNED_BYTE,&exploration_map);
CHECK_GL_ERRORS();
}
void GLDraw::DrawRect(
const Rect &r,
const Rect *clip,
const Vec3 &zRot, // (X, Y) is rotation center, Z is rotation in degrees
r::Material &m,
asset::MaterialLoader *l,
bool sampleMaterialColor,
const Vec4 &rgba
) {
int flags = 0;
if (clip) {
flags |= kScissorTest_Enable;
float x = ((clip->x - m_srcvp[0]) * m_todst[0]) + m_dstvp[0];
float y = ((clip->y - m_srcvp[1]) * m_todst[1]) + m_dstvp[1];
float w = clip->w * m_todst[0];
float h = clip->h * m_todst[1];
gls.Scissor(
FloorFastInt(x),
FloorFastInt(m_dstvp[3]-(y+h)),
FloorFastInt(w),
FloorFastInt(h)
);
} else {
flags |= kScissorTest_Disable;
}
gl.MatrixMode(GL_MODELVIEW);
gl.PushMatrix();
gl.Translatef((float)r.x, (float)r.y, 0.f);
if (zRot[2] != 0.f) {
float cx = zRot[0]-r.x;
float cy = zRot[1]-r.y;
gl.Translatef(cx, cy, 0.f);
gl.Rotatef(zRot[2], 0.f, 0.f, 1.f);
gl.Translatef(-cx, -cy, 0.f);
}
gl.Scalef(r.w / kBaseRectSize, r.h / kBaseRectSize, 1.f);
m.BindStates(flags);
m.BindTextures(l);
m.shader->Begin(r::Shader::kPass_Default, m);
m_rect->BindAll(m.shader.get().get());
Shader::Uniforms u(rgba);
m.shader->BindStates(u, sampleMaterialColor);
gls.Commit();
m_rect->CompileArrayStates(*m.shader.get());
m_rect->Draw();
CHECK_GL_ERRORS();
m.shader->End();
gl.PopMatrix();
}
void draw() {
glBindVertexArray(vao);
CHECK_GL_ERRORS();
glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer[0]);
glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer[1]);
glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer[2]);
glBindBuffer(GL_ARRAY_BUFFER, indexBuffer);
CHECK_GL_ERRORS();
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
glEnableVertexAttribArray(2);
CHECK_GL_ERRORS();
glDrawElements(GL_TRIANGLE_STRIP, numIndices, GL_UNSIGNED_SHORT, 0);
CHECK_GL_ERRORS();
}
void OpenGL3Driver::set_default_render_target()
{
if (current_render_target_ != nullptr)
{
current_render_target_->disable();
CHECK_GL_ERRORS();
}
current_render_target_ = nullptr;
}
void switch_from_game_map()
{
#ifndef NEW_TEXTURES
glDeleteTextures(1,&map_text);
#ifdef OPENGL_TRACE
CHECK_GL_ERRORS();
#endif //OPENGL_TRACE
#endif /* NEW_TEXTURES */
}
void AppManager::createProgram(){
lax_f = new Program("kernel.vert","lax-f.frag");
visualize = new Program("kernel.vert","visualize.frag");
copy = new Program("kernel.vert","copy.frag");
//Set uniforms
CHECK_GL_ERRORS();
}
void display::draw_rect_2d(float x1, float y1, float x2, float y2,
float s1, float t1, float s2, float t2)
{
#if 0
glBegin(GL_QUADS);
// lower left
glNormal3f(0, 0, 1);
glTexCoord2f(s1, t1);
glVertex2f(x1, y1);
// lower right
glNormal3f(0, 0, 1);
glTexCoord2f(s2, t1);
glVertex2f(x2, y1);
// upper right
glNormal3f(0, 0, 1);
glTexCoord2f(s2, t2);
glVertex2f(x2, y2);
// upper left
glNormal3f(0, 0, 1);
glTexCoord2f(s1, t2);
glVertex2f(x1, y2);
glEnd();
CHECK_GL_ERRORS();
#else
glPolygonMode(GL_FRONT, GL_FILL);
glBegin(GL_TRIANGLE_STRIP);
// upper left
//glNormal3f(0, 0, 1);
glTexCoord2f(s1, t2);
glVertex2f(x1, y2);
// lower left
//glNormal3f(0, 0, 1);
glTexCoord2f(s1, t1);
glVertex2f(x1, y1);
// upper right
//glNormal3f(0, 0, 1);
glTexCoord2f(s2, t2);
glVertex2f(x2, y2);
// lower right
//glNormal3f(0, 0, 1);
glTexCoord2f(s2, t1);
glVertex2f(x2, y1);
glEnd(); CHECK_GL_ERRORS();
#endif
} // display::draw_rectangle()
void CubeTextureFBO::setTarget(GLuint cubemap_side) {
for (size_t i = 0; i < texture.size(); i++) {
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0+(uint)i, cubemap_side, texture[i], 0);
}
if (store_depths) {
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, cubemap_side, depth, 0);
}
CHECK_GL_ERRORS();
CHECK_GL_FBO_COMPLETENESS();
}
void AppManager::setOpenGLStates(){
//glEnable(GL_DEPTH_TEST);
//glDepthFunc(GL_LEQUAL);
glEnable(GL_CULL_FACE);
glViewport(0, 0, window_width, window_height);
glClearColor(0.0, 0.0, 0.0, 1.0);
CHECK_GL_ERRORS();
}
void Leave2DMode()
{
#ifdef OPENGL_TRACE
CHECK_GL_ERRORS();
#endif //OPENGL_TRACE
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopAttrib();
glViewport(0, hud_y, window_width-hud_x, window_height-hud_y);
if (use_fog) glEnable(GL_FOG);
else glDisable(GL_FOG);
//glViewport(0, 0, window_width-hud_x, window_height-hud_y); // Reset The Current Viewport
#ifdef OPENGL_TRACE
CHECK_GL_ERRORS();
#endif //OPENGL_TRACE
}
static void draw_side_stats_bar(window_info *win, const int x, const int y, const int baselev, const int cur_exp, const int nl_exp, size_t colour)
{
const int max_len = win->len_x - x - 1;
const int bar_height = win->small_font_len_y - (int)(0.5 + win->current_scale * 2);
int len = max_len - (float)max_len/(float)((float)(nl_exp-exp_lev[baselev])/(float)(nl_exp-cur_exp));
GLfloat colours[2][2][3] = { { {0.11f, 0.11f, 0.11f}, {0.3f, 0.5f, 0.2f} },
{ {0.10f,0.10f,0.80f}, {0.40f,0.40f,1.00f} } };
if (colour > 1)
colour = 0;
#ifdef OPENGL_TRACE
CHECK_GL_ERRORS();
#endif //OPENGL_TRACE
glDisable(GL_TEXTURE_2D);
if(len >= 0){
glBegin(GL_QUADS);
//draw the colored section
glColor3fv(colours[colour][0]);
glVertex3i(x, y+bar_height, 0);
glColor3fv(colours[colour][1]);
glVertex3i(x, y, 0);
glColor3fv(colours[colour][1]);
glVertex3i(x+len, y, 0);
glColor3fv(colours[colour][0]);
glVertex3i(x+len, y+bar_height, 0);
glEnd();
}
// draw the bar frame
glColor3f(0.77f, 0.57f, 0.39f);
glBegin(GL_LINE_LOOP);
glVertex3i(x, y, 0);
glVertex3i(x+max_len, y, 0);
glVertex3i(x+max_len, y+bar_height, 0);
glVertex3i(x, y+bar_height, 0);
glEnd();
glEnable(GL_TEXTURE_2D);
#ifdef OPENGL_TRACE
CHECK_GL_ERRORS();
#endif //OPENGL_TRACE
}
int display_emotes_handler(window_info *win){
int i,pos;
actor *act = get_actor_ptr_from_id(yourself);
static int last_pos=0;
//check if vbar has been moved
pos=vscrollbar_get_pos(emotes_win, EMOTES_SCROLLBAR_ITEMS);
if(pos!=last_pos){
last_pos=pos;
update_selectables();
}
//draw texts
glEnable(GL_TEXTURE_2D);
SET_COLOR(c_orange1);
draw_string_small(20, 15, (unsigned char*)"Categories",1);
draw_string_small(20, emotes_rect_y+30+5, (unsigned char*)"Emotes",1);
for(i=0;i<EMOTES_CATEGORIES;i++){
if(cur_cat==i) SET_COLOR(c_blue2);
else glColor3f(1.0f, 1.0f, 1.0f);
draw_string_small(23, 32+13*i, (unsigned char*)emote_cats[i],1);
}
for(i=0;i<EMOTES_SHOWN;i++){
if(emote_sel[cur_cat]==selectables[i]) SET_COLOR(c_blue2);
else glColor3f(1.0f, 1.0f, 1.0f);
if(cur_cat&&act&&selectables[i]==act->poses[cur_cat-1]) SET_COLOR(c_green1);
if(selectables[i])
draw_string_small(23, 30+emotes_rect_y+20+1+13*i, (unsigned char*)selectables[i]->name,1);
}
glColor3f(0.77f, 0.57f, 0.39f);
//do grids
glDisable(GL_TEXTURE_2D);
rendergrid(1, 1, 20, 30, emotes_rect_x, emotes_rect_y);
rendergrid(1, 1, 20, 30+emotes_rect_y+20, emotes_rect_x2, emotes_rect_y2);
glEnable(GL_TEXTURE_2D);
//draw description
if(emote_sel[cur_cat]){
draw_string_small(20, emotes_menu_y_len-36, emote_str1,2);
draw_string_small(20, emotes_menu_y_len-36+16, emote_str2,1);
}
#ifdef OPENGL_TRACE
CHECK_GL_ERRORS();
#endif //OPENGL_TRACE
return 1;
}
