void apply(CoreRenderingStatus & target, const CoreRenderingStatus & actual, bool forced) {
// Blending
if(forced || target.blendingParametersChanged(actual)) {
const BlendingParameters & targetParams = target.getBlendingParameters();
const BlendingParameters & actualParams = actual.getBlendingParameters();
if(forced || targetParams.isEnabled() != actualParams.isEnabled()) {
if(actualParams.isEnabled()) {
glEnable(GL_BLEND);
} else {
glDisable(GL_BLEND);
}
}
if(forced ||
targetParams.getBlendFuncSrcRGB() != actualParams.getBlendFuncSrcRGB() ||
targetParams.getBlendFuncDstRGB() != actualParams.getBlendFuncDstRGB() ||
targetParams.getBlendFuncSrcAlpha() != actualParams.getBlendFuncSrcAlpha() ||
targetParams.getBlendFuncDstAlpha() != actualParams.getBlendFuncDstAlpha()) {
glBlendFuncSeparate(BlendingParameters::functionToGL(actualParams.getBlendFuncSrcRGB()),
BlendingParameters::functionToGL(actualParams.getBlendFuncDstRGB()),
BlendingParameters::functionToGL(actualParams.getBlendFuncSrcAlpha()),
BlendingParameters::functionToGL(actualParams.getBlendFuncDstAlpha()));
}
if(forced || targetParams.getBlendColor() != actualParams.getBlendColor()) {
glBlendColor(actualParams.getBlendColor().getR(),
actualParams.getBlendColor().getG(),
actualParams.getBlendColor().getB(),
actualParams.getBlendColor().getA());
}
if(forced ||
targetParams.getBlendEquationRGB() != actualParams.getBlendEquationRGB() ||
targetParams.getBlendEquationAlpha() != actualParams.getBlendEquationAlpha()) {
glBlendEquationSeparate(BlendingParameters::equationToGL(actualParams.getBlendEquationRGB()),
BlendingParameters::equationToGL(actualParams.getBlendEquationAlpha()));
}
target.updateBlendingParameters(actual);
}
// ColorBuffer
if(forced || target.colorBufferParametersChanged(actual)) {
glColorMask(
actual.getColorBufferParameters().isRedWritingEnabled() ? GL_TRUE : GL_FALSE,
actual.getColorBufferParameters().isGreenWritingEnabled() ? GL_TRUE : GL_FALSE,
actual.getColorBufferParameters().isBlueWritingEnabled() ? GL_TRUE : GL_FALSE,
actual.getColorBufferParameters().isAlphaWritingEnabled() ? GL_TRUE : GL_FALSE
);
target.setColorBufferParameters(actual.getColorBufferParameters());
}
GET_GL_ERROR();
// CullFace
if(forced || target.cullFaceParametersChanged(actual)) {
if(actual.getCullFaceParameters().isEnabled()) {
glEnable(GL_CULL_FACE);
} else {
glDisable(GL_CULL_FACE);
}
switch(actual.getCullFaceParameters().getMode()) {
case CullFaceParameters::CULL_BACK:
glCullFace(GL_BACK);
break;
case CullFaceParameters::CULL_FRONT:
glCullFace(GL_FRONT);
break;
case CullFaceParameters::CULL_FRONT_AND_BACK:
glCullFace(GL_FRONT_AND_BACK);
break;
default:
throw std::invalid_argument("Invalid CullFaceParameters::cullFaceMode_t enumerator");
}
target.setCullFaceParameters(actual.getCullFaceParameters());
}
// DepthBuffer
if(forced || target.depthBufferParametersChanged(actual)) {
if(actual.getDepthBufferParameters().isTestEnabled()) {
glEnable(GL_DEPTH_TEST);
} else {
glDisable(GL_DEPTH_TEST);
}
if(actual.getDepthBufferParameters().isWritingEnabled()) {
glDepthMask(GL_TRUE);
} else {
glDepthMask(GL_FALSE);
}
glDepthFunc(Comparison::functionToGL(actual.getDepthBufferParameters().getFunction()));
target.setDepthBufferParameters(actual.getDepthBufferParameters());
}
GET_GL_ERROR();
// Line
if(forced || target.lineParametersChanged(actual)) {
auto width = actual.getLineParameters().getWidth();
glLineWidth(RenderingContext::getCompabilityMode() ? width : std::min(width, 1.0f));
target.setLineParameters(actual.getLineParameters());
}
// stencil
if (forced || target.stencilParametersChanged(actual)) {
const StencilParameters & targetParams = target.getStencilParameters();
const StencilParameters & actualParams = actual.getStencilParameters();
if(forced || targetParams.isEnabled() != actualParams.isEnabled()) {
if(actualParams.isEnabled()) {
glEnable(GL_STENCIL_TEST);
} else {
glDisable(GL_STENCIL_TEST);
}
}
if(forced || targetParams.differentFunctionParameters(actualParams)) {
glStencilFunc(Comparison::functionToGL(actualParams.getFunction()), actualParams.getReferenceValue(), actualParams.getBitMask().to_ulong());
}
if(forced || targetParams.differentActionParameters(actualParams)) {
glStencilOp(convertStencilAction(actualParams.getFailAction()),
convertStencilAction(actualParams.getDepthTestFailAction()),
convertStencilAction(actualParams.getDepthTestPassAction()));
}
target.updateStencilParameters(actual);
}
GET_GL_ERROR();
#ifdef LIB_GL
if(RenderingContext::getCompabilityMode()) {
// AlphaTest
if(forced || target.alphaTestParametersChanged(actual)) {
if(actual.getAlphaTestParameters().isEnabled()) {
glDisable(GL_ALPHA_TEST);
} else {
glEnable(GL_ALPHA_TEST);
}
glAlphaFunc(Comparison::functionToGL(actual.getAlphaTestParameters().getMode()), actual.getAlphaTestParameters().getReferenceValue());
target.setAlphaTestParameters(actual.getAlphaTestParameters());
}
GET_GL_ERROR();
}
#endif /* LIB_GL */
// Lighting
if(forced || target.lightingParametersChanged(actual)) {
#ifdef LIB_GL
if(RenderingContext::getCompabilityMode()) {
if(actual.getLightingParameters().isEnabled()) {
glEnable(GL_LIGHTING);
} else {
glDisable(GL_LIGHTING);
}
}
#endif /* LIB_GL */
target.setLightingParameters(actual.getLightingParameters());
}
GET_GL_ERROR();
#ifdef LIB_GL
// polygonMode
if(forced || target.polygonModeParametersChanged(actual) ) {
glPolygonMode(GL_FRONT_AND_BACK, PolygonModeParameters::modeToGL(actual.getPolygonModeParameters().getMode()));
target.setPolygonModeParameters(actual.getPolygonModeParameters());
}
GET_GL_ERROR();
#endif /* LIB_GL */
// PolygonOffset
if(forced || target.polygonOffsetParametersChanged(actual)) {
if(actual.getPolygonOffsetParameters().isEnabled()) {
glEnable(GL_POLYGON_OFFSET_FILL);
#ifdef LIB_GL
glEnable(GL_POLYGON_OFFSET_LINE);
glEnable(GL_POLYGON_OFFSET_POINT);
#endif /* LIB_GL */
glPolygonOffset(actual.getPolygonOffsetParameters().getFactor(), actual.getPolygonOffsetParameters().getUnits());
} else {
glDisable(GL_POLYGON_OFFSET_FILL);
#ifdef LIB_GL
glDisable(GL_POLYGON_OFFSET_LINE);
glDisable(GL_POLYGON_OFFSET_POINT);
#endif /* LIB_GL */
}
target.setPolygonOffsetParameters(actual.getPolygonOffsetParameters());
}
GET_GL_ERROR();
// PrimitiveRestart
#ifdef LIB_GL
if(forced || target.primitiveRestartParametersChanged(actual)) {
if(actual.getPrimitiveRestartParameters().isEnabled()) {
glEnable(GL_PRIMITIVE_RESTART);
glPrimitiveRestartIndex(actual.getPrimitiveRestartParameters().getIndex());
} else {
glDisable(GL_PRIMITIVE_RESTART);
}
target.setPrimitiveRestartParameters(actual.getPrimitiveRestartParameters());
}
GET_GL_ERROR();
#endif /* LIB_GL */
// Textures
if(forced || target.texturesChanged(actual)) {
for(uint_fast8_t unit = 0; unit < MAX_TEXTURES; ++unit) {
const auto & texture = actual.getTexture(unit);
const auto & oldTexture = target.getTexture(unit);
if(forced || texture != oldTexture) {
glActiveTexture(GL_TEXTURE0 + static_cast<GLenum>(unit));
if( texture ) {
glBindTexture(texture->getGLTextureType(), texture->getGLId());
#if defined(LIB_GL)
BufferObject* buffer = texture->getBufferObject();
if(buffer)
glTexBuffer( GL_TEXTURE_BUFFER, texture->getFormat().pixelFormat.glInternalFormat, buffer->getGLId() );
#endif
} else if( oldTexture ) {
glBindTexture(oldTexture->getGLTextureType(), 0);
} else {
glBindTexture(GL_TEXTURE_2D, 0);
}
}
}
target.updateTextures(actual);
}
GET_GL_ERROR();
}
int main( int argc , char ** argv )
{
int ret = 0;
struct DIVERSsysteme systeme;
struct typeFORthreads online;
Mix_Music *sound = NULL;
SDL_GLContext contexteOpenGL;
initonline(&online, &systeme);
/*pthread_t lethread1;*/
if (argc == *argv[0]){}/*juste pour les warnings*/
srand(2); /*define a random*/
SDL_Init (SDL_INIT_VIDEO);
atexit(SDL_Quit);
TTF_Init();
atexit(TTF_Quit);
IMG_Init(IMG_INIT_PNG);
atexit(IMG_Quit);
Mix_Init(MIX_INIT_MP3);
atexit(Mix_Quit);
systeme.screen = SDL_CreateWindow("Reconquete salvatrice", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 0, 0,SDL_WINDOW_OPENGL | SDL_WINDOW_FULLSCREEN_DESKTOP);
contexteOpenGL = SDL_GL_CreateContext(systeme.screen);
SDL_GetWindowSize(systeme.screen , &screenw , &screenh);
SDL_ShowCursor(SDL_DISABLE);
SDL_SetRelativeMouseMode(true);
glMatrixMode( GL_PROJECTION );
glLoadIdentity();
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
gluOrtho2D(0,screenw,0,screenh);
glEnable(GL_TEXTURE_2D);
glAlphaFunc(GL_GREATER,0.5f);
glEnable(GL_ALPHA_TEST);
initsystem(&systeme);
initsauvegarde(systeme.sauvegarde, NBargSAVE, C);
Mix_OpenAudio(22050, MIX_DEFAULT_FORMAT, 1, 1024);
Mix_AllocateChannels(0);
Mix_VolumeMusic(64);
#if FASTLOG == 1/*juste pour moi, pour éviter le log*/
sprintf(systeme.sauvegarde[0], "cegdd");
sprintf(systeme.sauvegarde[1], "mdpbidon");
/*pthread_create(&lethread1, NULL, *thread1, &online);*/
chargersauvegarde(&systeme);
if (chargementcarte(&systeme, &online) != 1) {return EXIT_FAILURE;}
return EXIT_SUCCESS;
#endif /* FASTLOG*/
sound = Mix_LoadMUS("game.mp3");
if (sound == NULL){ printf("musique non trouvée"); return EXIT_FAILURE;}
else if (Mix_PlayMusic(sound, -1) < 0){ printf("musique non jouable"); return EXIT_FAILURE;}
/*si le login est accepté*/
ret = login(&systeme);
while (ret != 0)
{
if (ret == 2)
{
/*creation thread pour socket*/
/*pthread_create(&lethread1, NULL, *thread1, &online);*/
chargersauvegarde(&systeme);
Mix_PauseMusic ();
/*lancement du jeu*/
if (chargementcarte(&systeme, &online) != 1) {return EXIT_FAILURE;}
return EXIT_SUCCESS;
}
else if (ret == 5)
{
Mix_PauseMusic ();
chargementarcade(&systeme);
if (Mix_PlayMusic(sound, -1) < 0){ printf("musique non jouable"); return EXIT_FAILURE;}
}
else
{
printf("login return : %d", ret);
}
ret = login(&systeme);
}
Mix_FreeMusic(sound);
TTF_CloseFont(systeme.police1);
TTF_CloseFont(systeme.police);
SDL_GL_DeleteContext(contexteOpenGL);
return 0;
}
void GLGSRender::ExecCMD()
{
if(!LoadProgram())
{
ConLog.Error("LoadProgram failed.");
Emu.Pause();
return;
}
if(!m_fbo.IsCreated() || RSXThread::m_width != last_width || RSXThread::m_height != last_height || last_depth_format != m_surface_depth_format)
{
ConLog.Warning("New FBO (%dx%d)", RSXThread::m_width, RSXThread::m_height);
last_width = RSXThread::m_width;
last_height = RSXThread::m_height;
last_depth_format = m_surface_depth_format;
m_fbo.Create();
checkForGlError("m_fbo.Create");
m_fbo.Bind();
m_rbo.Create(4 + 1);
checkForGlError("m_rbo.Create");
for(int i=0; i<4; ++i)
{
m_rbo.Bind(i);
m_rbo.Storage(GL_RGBA, RSXThread::m_width, RSXThread::m_height);
checkForGlError("m_rbo.Storage(GL_RGBA)");
}
m_rbo.Bind(4);
switch(m_surface_depth_format)
{
case 1:
m_rbo.Storage(GL_DEPTH_COMPONENT16, RSXThread::m_width, RSXThread::m_height);
checkForGlError("m_rbo.Storage(GL_DEPTH_COMPONENT16)");
break;
case 2:
m_rbo.Storage(GL_DEPTH24_STENCIL8, RSXThread::m_width, RSXThread::m_height);
checkForGlError("m_rbo.Storage(GL_DEPTH24_STENCIL8)");
break;
default:
ConLog.Error("Bad depth format! (%d)", m_surface_depth_format);
assert(0);
break;
}
for(int i=0; i<4; ++i)
{
m_fbo.Renderbuffer(GL_COLOR_ATTACHMENT0 + i, m_rbo.GetId(i));
checkForGlError(wxString::Format("m_fbo.Renderbuffer(GL_COLOR_ATTACHMENT%d)", i));
}
m_fbo.Renderbuffer(GL_DEPTH_ATTACHMENT, m_rbo.GetId(4));
checkForGlError("m_fbo.Renderbuffer(GL_DEPTH_ATTACHMENT)");
if(m_surface_depth_format == 2)
{
m_fbo.Renderbuffer(GL_STENCIL_ATTACHMENT, m_rbo.GetId(4));
checkForGlError("m_fbo.Renderbuffer(GL_STENCIL_ATTACHMENT)");
}
}
if(!m_set_surface_clip_horizontal)
{
m_surface_clip_x = 0;
m_surface_clip_w = RSXThread::m_width;
}
if(!m_set_surface_clip_vertical)
{
m_surface_clip_y = 0;
m_surface_clip_h = RSXThread::m_height;
}
m_fbo.Bind();
if(Ini.GSDumpDepthBuffer.GetValue())
WriteDepthBuffer();
static const GLenum draw_buffers[] = { GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1, GL_COLOR_ATTACHMENT2, GL_COLOR_ATTACHMENT3 };
switch(m_surface_colour_target)
{
case 0x0:
break;
case 0x1:
glDrawBuffer(draw_buffers[0]);
break;
case 0x2:
glDrawBuffer(draw_buffers[1]);
break;
case 0x13:
glDrawBuffers(2, draw_buffers);
break;
case 0x17:
glDrawBuffers(3, draw_buffers);
break;
case 0x1f:
glDrawBuffers(4, draw_buffers);
break;
default:
ConLog.Error("Bad surface colour target: %d", m_surface_colour_target);
break;
}
if(m_set_color_mask)
{
glColorMask(m_color_mask_r, m_color_mask_g, m_color_mask_b, m_color_mask_a);
checkForGlError("glColorMask");
}
if(m_set_viewport_horizontal && m_set_viewport_vertical)
{
glViewport(m_viewport_x, RSXThread::m_height-m_viewport_y-m_viewport_h, m_viewport_w, m_viewport_h);
checkForGlError("glViewport");
}
if(m_set_scissor_horizontal && m_set_scissor_vertical)
{
glScissor(m_scissor_x, RSXThread::m_height-m_scissor_y-m_scissor_h, m_scissor_w, m_scissor_h);
checkForGlError("glScissor");
}
if(m_clear_surface_mask)
{
GLbitfield f = 0;
if (m_clear_surface_mask & 0x1)
{
glClearDepth(m_clear_surface_z / (float)0xffffff);
f |= GL_DEPTH_BUFFER_BIT;
}
if (m_clear_surface_mask & 0x2)
{
glClearStencil(m_clear_surface_s);
f |= GL_STENCIL_BUFFER_BIT;
}
if (m_clear_surface_mask & 0xF0)
{
glClearColor(
m_clear_surface_color_r / 255.0f,
m_clear_surface_color_g / 255.0f,
m_clear_surface_color_b / 255.0f,
m_clear_surface_color_a / 255.0f);
f |= GL_COLOR_BUFFER_BIT;
}
glClear(f);
}
if(m_set_front_polygon_mode)
{
glPolygonMode(GL_FRONT, m_front_polygon_mode);
checkForGlError("glPolygonMode");
}
Enable(m_depth_test_enable, GL_DEPTH_TEST);
Enable(m_set_alpha_test, GL_ALPHA_TEST);
Enable(m_set_depth_bounds_test, GL_DEPTH_BOUNDS_TEST_EXT);
Enable(m_set_blend, GL_BLEND);
Enable(m_set_logic_op, GL_LOGIC_OP);
Enable(m_set_cull_face_enable, GL_CULL_FACE);
Enable(m_set_dither, GL_DITHER);
Enable(m_set_stencil_test, GL_STENCIL_TEST);
Enable(m_set_line_smooth, GL_LINE_SMOOTH);
Enable(m_set_poly_smooth, GL_POLYGON_SMOOTH);
Enable(m_set_poly_offset_fill, GL_POLYGON_OFFSET_FILL);
Enable(m_set_poly_offset_line, GL_POLYGON_OFFSET_LINE);
Enable(m_set_poly_offset_point, GL_POLYGON_OFFSET_POINT);
//Enable(m_set_restart_index, GL_PRIMITIVE_RESTART); //Requires OpenGL 3.1+
if(m_set_clip_plane)
{
Enable(m_clip_plane_0, GL_CLIP_PLANE0);
Enable(m_clip_plane_1, GL_CLIP_PLANE1);
Enable(m_clip_plane_2, GL_CLIP_PLANE2);
Enable(m_clip_plane_3, GL_CLIP_PLANE3);
Enable(m_clip_plane_4, GL_CLIP_PLANE4);
Enable(m_clip_plane_5, GL_CLIP_PLANE5);
checkForGlError("m_set_clip_plane");
}
checkForGlError("glEnable");
if(m_set_two_sided_stencil_test_enable)
{
if(m_set_stencil_fail && m_set_stencil_zfail && m_set_stencil_zpass)
{
glStencilOpSeparate(GL_FRONT, m_stencil_fail, m_stencil_zfail, m_stencil_zpass);
checkForGlError("glStencilOpSeparate");
}
if(m_set_stencil_mask)
{
glStencilMaskSeparate(GL_FRONT, m_stencil_mask);
checkForGlError("glStencilMaskSeparate");
}
if(m_set_stencil_func && m_set_stencil_func_ref && m_set_stencil_func_mask)
{
glStencilFuncSeparate(GL_FRONT, m_stencil_func, m_stencil_func_ref, m_stencil_func_mask);
checkForGlError("glStencilFuncSeparate");
}
if(m_set_back_stencil_fail && m_set_back_stencil_zfail && m_set_back_stencil_zpass)
{
glStencilOpSeparate(GL_BACK, m_back_stencil_fail, m_back_stencil_zfail, m_back_stencil_zpass);
checkForGlError("glStencilOpSeparate(GL_BACK)");
}
if(m_set_back_stencil_mask)
{
glStencilMaskSeparate(GL_BACK, m_back_stencil_mask);
checkForGlError("glStencilMaskSeparate(GL_BACK)");
}
if(m_set_back_stencil_func && m_set_back_stencil_func_ref && m_set_back_stencil_func_mask)
{
glStencilFuncSeparate(GL_BACK, m_back_stencil_func, m_back_stencil_func_ref, m_back_stencil_func_mask);
checkForGlError("glStencilFuncSeparate(GL_BACK)");
}
}
else
{
if(m_set_stencil_fail && m_set_stencil_zfail && m_set_stencil_zpass)
{
glStencilOp(m_stencil_fail, m_stencil_zfail, m_stencil_zpass);
checkForGlError("glStencilOp");
}
if(m_set_stencil_mask)
{
glStencilMask(m_stencil_mask);
checkForGlError("glStencilMask");
}
if(m_set_stencil_func && m_set_stencil_func_ref && m_set_stencil_func_mask)
{
glStencilFunc(m_stencil_func, m_stencil_func_ref, m_stencil_func_mask);
checkForGlError("glStencilFunc");
}
}
if(m_set_shade_mode)
{
glShadeModel(m_shade_mode);
checkForGlError("glShadeModel");
}
if(m_set_depth_mask)
{
glDepthMask(m_depth_mask);
checkForGlError("glDepthMask");
}
if(m_set_depth_func)
{
glDepthFunc(m_depth_func);
//ConLog.Warning("glDepthFunc(0x%x)", m_depth_func);
checkForGlError("glDepthFunc");
}
if(m_set_depth_bounds)
{
//ConLog.Warning("glDepthBounds(%f, %f)", m_depth_bounds_min, m_depth_bounds_max);
glDepthBounds(m_depth_bounds_min, m_depth_bounds_max);
checkForGlError("glDepthBounds");
}
if(m_set_clip)
{
//ConLog.Warning("glDepthRangef(%f, %f)", m_clip_min, m_clip_max);
glDepthRangef(m_clip_min, m_clip_max);
checkForGlError("glDepthRangef");
}
if(m_set_line_width)
{
glLineWidth(m_line_width / 255.f);
checkForGlError("glLineWidth");
}
if(m_set_blend_equation)
{
glBlendEquationSeparate(m_blend_equation_rgb, m_blend_equation_alpha);
checkForGlError("glBlendEquationSeparate");
}
if(m_set_blend_sfactor && m_set_blend_dfactor)
{
glBlendFuncSeparate(m_blend_sfactor_rgb, m_blend_dfactor_rgb, m_blend_sfactor_alpha, m_blend_dfactor_alpha);
checkForGlError("glBlendFuncSeparate");
}
if(m_set_blend_color)
{
glBlendColor(m_blend_color_r, m_blend_color_g, m_blend_color_b, m_blend_color_a);
checkForGlError("glBlendColor");
}
if(m_set_cull_face)
{
glCullFace(m_cull_face);
checkForGlError("glCullFace");
}
if(m_set_alpha_func && m_set_alpha_ref)
{
glAlphaFunc(m_alpha_func, m_alpha_ref);
checkForGlError("glAlphaFunc");
}
if(m_set_fog_mode)
{
glFogi(GL_FOG_MODE, m_fog_mode);
checkForGlError("glFogi(GL_FOG_MODE)");
}
if(m_set_fog_params)
{
glFogf(GL_FOG_START, m_fog_param0);
checkForGlError("glFogf(GL_FOG_START)");
glFogf(GL_FOG_END, m_fog_param1);
checkForGlError("glFogf(GL_FOG_END)");
}
if(m_set_restart_index)
{
ConLog.Warning("m_set_restart_index requires glPrimitiveRestartIndex()");
//glPrimitiveRestartIndex(m_restart_index); //Requires OpenGL 3.1+
//checkForGlError("glPrimitiveRestartIndex");
}
if(m_indexed_array.m_count && m_draw_array_count)
{
ConLog.Warning("m_indexed_array.m_count && draw_array_count");
}
for(u32 i=0; i<m_textures_count; ++i)
{
if(!m_textures[i].IsEnabled()) continue;
glActiveTexture(GL_TEXTURE0 + i);
checkForGlError("glActiveTexture");
m_gl_textures[i].Create();
m_gl_textures[i].Bind();
checkForGlError(wxString::Format("m_gl_textures[%d].Bind", i));
m_program.SetTex(i);
m_gl_textures[i].Init(m_textures[i]);
checkForGlError(wxString::Format("m_gl_textures[%d].Init", i));
}
m_vao.Bind();
if(m_indexed_array.m_count)
{
LoadVertexData(m_indexed_array.index_min, m_indexed_array.index_max - m_indexed_array.index_min + 1);
}
EnableVertexData(m_indexed_array.m_count ? true : false);
InitVertexData();
InitFragmentData();
if(m_indexed_array.m_count)
{
switch(m_indexed_array.m_type)
{
case 0:
glDrawElements(m_draw_mode - 1, m_indexed_array.m_count, GL_UNSIGNED_INT, nullptr);
checkForGlError("glDrawElements #4");
break;
case 1:
glDrawElements(m_draw_mode - 1, m_indexed_array.m_count, GL_UNSIGNED_SHORT, nullptr);
checkForGlError("glDrawElements #2");
break;
default:
ConLog.Error("Bad indexed array type (%d)", m_indexed_array.m_type);
break;
}
DisableVertexData();
m_indexed_array.Reset();
}
if(m_draw_array_count)
{
//ConLog.Warning("glDrawArrays(%d,%d,%d)", m_draw_mode - 1, m_draw_array_first, m_draw_array_count);
glDrawArrays(m_draw_mode - 1, 0, m_draw_array_count);
checkForGlError("glDrawArrays");
DisableVertexData();
}
if(Ini.GSDumpColorBuffers.GetValue())
WriteBuffers();
}
void texture_palette_draw(void)
{
int i,x,y,yadd,sel,k,idx,page,page_cnt;
texture_type *texture;
// viewport setup
main_wind_set_viewport(&txt_palette_box,TRUE,FALSE);
// texture page switch
page_cnt=max_map_texture/txt_wind_per_page;
yadd=(txt_wind_row_count*txt_pixel_sz)/page_cnt;
for (i=0;i!=page_cnt;i++) {
y=txt_palette_y+(i*yadd);
glColor4f(0.5f,0.5f,0.5f,1.0f);
glBegin(GL_QUADS);
glVertex2i(0,y);
glVertex2i(16,y);
glVertex2i(16,(y+yadd));
glVertex2i(0,(y+yadd));
glEnd();
glColor4f(0.0f,0.0f,0.0f,1.0f);
glBegin(GL_LINE_LOOP);
glVertex2i(0,y);
glVertex2i(16,y);
glVertex2i(16,(y+yadd));
glVertex2i(0,(y+yadd));
glEnd();
if (txt_page==i) {
glColor4f(0.0f,0.0f,1.0f,1.0f);
glBegin(GL_TRIANGLES);
glVertex2i(1,(y+1));
glVertex2i(15,(y+(yadd/2)));
glVertex2i(1,((y+yadd)-1));
glEnd();
}
}
// textures
glEnable(GL_ALPHA_TEST);
glAlphaFunc(GL_NOTEQUAL,0);
glColor4f(1.0f,1.0f,1.0f,1.0f);
glEnable(GL_TEXTURE_2D);
for (i=0;i!=max_map_texture;i++) {
texture=&map.textures[i];
page=i/txt_wind_per_page;
if (page!=txt_page) continue;
idx=i-(txt_page*txt_wind_per_page);
k=idx/txt_wind_column_count;
x=((idx-(k*txt_wind_column_count))*txt_pixel_sz)+16;
y=txt_palette_y+(k*txt_pixel_sz);
// the textures
if (texture->frames[0].bitmap.gl_id!=-1) {
glBindTexture(GL_TEXTURE_2D,texture->frames[0].bitmap.gl_id);
glBegin(GL_QUADS);
glTexCoord2f(0,0);
glVertex2i(x,y);
glTexCoord2f(1,0);
glVertex2i((x+txt_pixel_sz),y);
glTexCoord2f(1,1);
glVertex2i((x+txt_pixel_sz),(y+txt_pixel_sz));
glTexCoord2f(0,1);
glVertex2i(x,(y+txt_pixel_sz));
glEnd();
}
}
glDisable(GL_TEXTURE_2D);
glDisable(GL_ALPHA_TEST);
// lines
glColor4f(0.0f,0.0f,0.0f,1.0f);
for (i=0;i!=max_map_texture;i++) {
page=i/txt_wind_per_page;
if (page!=txt_page) continue;
idx=i-(txt_page*txt_wind_per_page);
k=idx/txt_wind_column_count;
x=((idx-(k*txt_wind_column_count))*txt_pixel_sz)+16;
y=txt_palette_y+(k*txt_pixel_sz);
glBegin(GL_LINE_LOOP);
glVertex2i(x,(y+1));
glVertex2i((x+txt_pixel_sz),(y+1));
glVertex2i((x+txt_pixel_sz),(y+txt_pixel_sz));
glVertex2i(x,(y+txt_pixel_sz));
glEnd();
}
// selection
sel=texture_palette_get_selected_texture();
if (sel==-1) return;
page=sel/txt_wind_per_page;
if (page!=txt_page) return;
idx=sel-(txt_page*txt_wind_per_page);
k=idx/txt_wind_column_count;
x=((idx-(k*txt_wind_column_count))*txt_pixel_sz)+16;
y=txt_palette_y+(k*txt_pixel_sz);
glColor4f(1.0f,0.0f,0.0f,1.0f);
glBegin(GL_LINE_LOOP);
glVertex2i(x,(y+1));
glVertex2i((x+txt_pixel_sz),(y+1));
glVertex2i((x+txt_pixel_sz),(y+txt_pixel_sz));
glVertex2i(x,(y+txt_pixel_sz));
glEnd();
}
void DrawMenu()
{
if(!menuactive)
return;
// Darken behind menu
DimArea(0, 0, 1, 1, 0.5);
extern int messageToPrint;
if(messageToPrint)
{
}
else
{
//extern void M_Drawer();
//M_Drawer();
// DRAW MENU
int x = currentMenu->x;
int y = currentMenu->y;
int max = currentMenu->numitems;
glColor4f(1,1,1,1);
glEnable(GL_TEXTURE_2D);
glEnable(GL_ALPHA_TEST);
glDisable(GL_BLEND);
glAlphaFunc(GL_GREATER, 0);
for (int i = 0; i < max; i++)
{
if (currentMenu->menuitems[i].name[0])
{
//screen->DrawPatchClean (W_GetNumForName(currentMenu->menuitems[i].name), x, y);
int lump = W_GetNumForName(currentMenu->menuitems[i].name);
patch_t *patch = (patch_t *)W_CacheLumpNum (lump, PU_CACHE);
glpatch_t &glp = get_glpatch(lump, false);
glBindTexture(GL_TEXTURE_2D, glp.texture);
DrawTexturedQuad(x/320.0,
y/200.0,
patch->width()/320.0,
patch->height()/200.0,
glp.h, glp.w);
}
y += LINEHEIGHT;
}
// DRAW SKULL
//if (drawSkull)
{
extern short whichSkull;
extern char skullName[2][9];
//screen->DrawPatchClean (W_GetNumForName(skullName[whichSkull]),
// x + SKULLXOFF, currentMenu->y - 5 + itemOn*LINEHEIGHT);
int lump = W_GetNumForName(skullName[whichSkull]);
patch_t *patch = (patch_t *)W_CacheLumpNum (lump, PU_CACHE);
glpatch_t &glp = get_glpatch(lump, false);
glBindTexture(GL_TEXTURE_2D, glp.texture);
double xscale = 1.0/320.0;
double yscale = 1.0/240.0;
x += SKULLXOFF;
y = currentMenu->y - 5 + itemOn*LINEHEIGHT;
//DrawTexturedQuad(x*xscale, y*yscale, patch->width()*xscale, patch->height()*yscale, 1, 1);
DrawTexturedQuad(x/320.0,
y/200.0,
patch->width()/320.0,
patch->height()/200.0,
glp.h, glp.w);
}
}
}
void CProjectileDrawer::DrawGroundFlashes()
{
static const GLfloat black[] = {0.0f, 0.0f, 0.0f, 0.0f};
glDepthMask(GL_FALSE);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE);
glActiveTexture(GL_TEXTURE0);
groundFXAtlas->BindTexture();
glEnable(GL_TEXTURE_2D);
glEnable(GL_ALPHA_TEST);
glAlphaFunc(GL_GREATER, 0.01f);
glPolygonOffset(-20, -1000);
glEnable(GL_POLYGON_OFFSET_FILL);
glFogfv(GL_FOG_COLOR, black);
{
GML_STDMUTEX_LOCK(rflash); // DrawGroundFlashes
ph->groundFlashes.delete_delayed();
ph->groundFlashes.add_delayed();
}
CGroundFlash::va = GetVertexArray();
CGroundFlash::va->Initialize();
CGroundFlash::va->EnlargeArrays(8, 0, VA_SIZE_TC);
GroundFlashContainer& gfc = ph->groundFlashes;
GroundFlashContainer::render_iterator gfi;
bool depthTest = true;
bool depthMask = false;
for (gfi = gfc.render_begin(); gfi != gfc.render_end(); ++gfi) {
CGroundFlash* gf = *gfi;
const bool los = gu->spectatingFullView || loshandler->InAirLos(gf->pos, gu->myAllyTeam);
const bool vis = camera->InView(gf->pos, gf->size);
if (depthTest != gf->depthTest) {
depthTest = gf->depthTest;
if (depthTest) {
glEnable(GL_DEPTH_TEST);
} else {
glDisable(GL_DEPTH_TEST);
}
}
if (depthMask != gf->depthMask) {
depthMask = gf->depthMask;
if (depthMask) {
glDepthMask(GL_TRUE);
} else {
glDepthMask(GL_FALSE);
}
}
if ((gf->alwaysVisible || los) && vis) {
gf->Draw();
}
CGroundFlash::va->DrawArrayTC(GL_QUADS);
CGroundFlash::va->Initialize();
}
glFogfv(GL_FOG_COLOR, mapInfo->atmosphere.fogColor);
glDisable(GL_POLYGON_OFFSET_FILL);
glDisable(GL_ALPHA_TEST);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDisable(GL_BLEND);
glEnable(GL_DEPTH_TEST);
glDepthMask(GL_TRUE);
}
void draw_minimap_title_bar(window_info *win)
{
#ifdef NEW_TEXTURES
float u_first_start= (float)31/255;
float u_first_end = 0.0f;
float v_first_start = (float)160/255;
float v_first_end = (float)175/255;
float u_last_start = 0.0f;
float u_last_end = (float)31/255;
float v_last_start = (float)160/255;
float v_last_end = (float)175/255;
#else /* NEW_TEXTURES */
float u_first_start= (float)31/255;
float u_first_end= 0;
float v_first_start= 1.0f-(float)160/255;
float v_first_end= 1.0f-(float)175/255;
float u_last_start= 0;
float u_last_end= (float)31/255;
float v_last_start= 1.0f-(float)160/255;
float v_last_end= 1.0f-(float)175/255;
#endif /* NEW_TEXTURES */
int close_button_x = win->len_x/2 + 32 - 1;
glPushMatrix();
glColor3f(1.0f,1.0f,1.0f);
#ifdef NEW_TEXTURES
bind_texture(icons_text);
#else /* NEW_TEXTURES */
get_and_set_texture_id(icons_text);
#endif /* NEW_TEXTURES */
glEnable(GL_ALPHA_TEST);
glAlphaFunc(GL_GREATER,0.03f);
glEnable(GL_TEXTURE_2D);
glBegin(GL_QUADS);
glTexCoord2f(u_first_end, v_first_start);
glVertex3i(win->len_x/2-32, ELW_TITLE_HEIGHT, 0);
glTexCoord2f(u_first_end, v_first_end);
glVertex3i(win->len_x/2-32, 0, 0);
glTexCoord2f(u_first_start, v_first_end);
glVertex3i(win->len_x/2, 0, 0);
glTexCoord2f(u_first_start, v_first_start);
glVertex3i(win->len_x/2, ELW_TITLE_HEIGHT, 0);
glTexCoord2f(u_last_end, v_last_start);
glVertex3i(win->len_x/2, ELW_TITLE_HEIGHT, 0);
glTexCoord2f(u_last_end, v_last_end);
glVertex3i(win->len_x/2, 0, 0);
glTexCoord2f(u_last_start, v_last_end);
glVertex3i(win->len_x/2+32, 0, 0);
glTexCoord2f(u_last_start, v_last_start);
glVertex3i(win->len_x/2+32, ELW_TITLE_HEIGHT, 0);
glEnd();
glDisable(GL_ALPHA_TEST);
glDisable(GL_TEXTURE_2D);
//draw the X background
glColor3f(0.156f,0.078f,0.0f);
glBegin(GL_POLYGON);
glVertex2f(close_button_x + ELW_TITLE_HEIGHT, ELW_TITLE_HEIGHT);
glVertex2f(close_button_x, ELW_TITLE_HEIGHT);
glVertex2f(close_button_x, 0);
glVertex2f(close_button_x + ELW_TITLE_HEIGHT, 0);
glEnd();
//draw the rectngle
glColor3f(win->line_color[0],win->line_color[1],win->line_color[2]);
glBegin(GL_LINE_STRIP);
glVertex2i(close_button_x + ELW_TITLE_HEIGHT-2 - gx_adjust, ELW_TITLE_HEIGHT-1 - gy_adjust);
glVertex2i(close_button_x + 1 - gx_adjust, ELW_TITLE_HEIGHT-1 - gy_adjust);
glVertex2i(close_button_x + 1 - gx_adjust, 2 - gy_adjust);
glVertex2i(close_button_x + ELW_TITLE_HEIGHT-2 - gx_adjust, 2 - gy_adjust);
glVertex2i(close_button_x + ELW_TITLE_HEIGHT-2 - gx_adjust, ELW_TITLE_HEIGHT-1 - gy_adjust);
glEnd();
//draw the X
glLineWidth(2.0f);
glBegin(GL_LINES);
glVertex2i(close_button_x + 3, 4);
glVertex2i(close_button_x + ELW_TITLE_HEIGHT-3, ELW_TITLE_HEIGHT-4);
glVertex2i(close_button_x + ELW_TITLE_HEIGHT-3, 4);
glVertex2i(close_button_x + 3, ELW_TITLE_HEIGHT-4);
glEnd();
glLineWidth(1.0f);
glPopMatrix();
#ifdef OPENGL_TRACE
CHECK_GL_ERRORS();
#endif //OPENGL_TRACE
}
void AlphaTest(const unsigned int func, float alpha)
{
glEnable(GL_ALPHA_TEST);
glAlphaFunc(func,alpha);
}
void draw_messages (int x, int y, text_message *msgs, int msgs_size, Uint8 filter, int msg_start, int offset_start, int cursor, int width, int height, float text_zoom, select_info* select)
{
float displayed_font_x_size = DEFAULT_FONT_X_LEN * text_zoom;
float displayed_font_y_size = DEFAULT_FONT_Y_LEN * text_zoom;
float selection_red = 255 / 255.0f;
float selection_green = 162 / 255.0f;
float selection_blue = 0;
unsigned char cur_char;
int i;
int imsg, ichar;
int cur_x, cur_y;
int cursor_x = x-1, cursor_y = y-1;
unsigned char ch;
int cur_line = 0;
int cur_col = 0;
unsigned char last_color_char = 0;
int in_select = 0;
imsg = msg_start;
ichar = offset_start;
if (msgs[imsg].data == NULL || msgs[imsg].deleted) return;
if (width < displayed_font_x_size || height < displayed_font_y_size)
// no point in trying
return;
#ifndef MAP_EDITOR2
if (filter != FILTER_ALL)
{
// skip all messages of the wrong channel
while (1)
{
if (skip_message(&msgs[imsg], filter))
{
ichar = 0;
if (++imsg >= msgs_size) imsg = 0;
if (msgs[imsg].data == NULL || imsg == msg_start || msgs[imsg].deleted)
// nothing to draw
return;
}
else
{
break;
}
}
if (msgs[imsg].data == NULL || msgs[imsg].deleted) return;
}
#endif //! MAP_EDITOR2
ch = msgs[imsg].data[ichar];
if (!is_color (ch))
{
// search backwards for the last color
for (i = ichar-1; i >= 0; i--)
{
ch = msgs[imsg].data[i];
if (is_color (ch))
{
find_font_char (ch);
last_color_char = ch;
break;
}
}
if (i < 0)
{
// no color character found, try the message color
if (msgs[imsg].r >= 0)
glColor3f (msgs[imsg].r, msgs[imsg].g, msgs[imsg].b);
}
}
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)
{
if (i == cursor)
{
cursor_x = cur_x;
cursor_y = cur_y;
if (cursor_x - x > width - displayed_font_x_size)
{
cursor_x = x;
cursor_y = cur_y + displayed_font_y_size;
}
}
cur_char = msgs[imsg].data[ichar];
// watch for special characters
if (cur_char == '\0')
{
// end of message
if (++imsg >= msgs_size) {
imsg = 0;
}
#ifndef MAP_EDITOR2
if (filter != FILTER_ALL)
{
// skip all messages of the wrong channel
while (skip_message (&msgs[imsg], filter))
{
if (++imsg >= msgs_size) imsg = 0;
if (msgs[imsg].data == NULL || imsg == msg_start) break;
}
}
#endif
if (msgs[imsg].data == NULL || imsg == msg_start || msgs[imsg].deleted) break;
rewrap_message (&msgs[imsg], text_zoom, width, NULL);
ichar = 0;
last_color_char = 0;
}
if (select != NULL && select->lines && select->lines[cur_line].msg == -1)
{
select->lines[cur_line].msg = imsg;
select->lines[cur_line].chr = ichar;
}
if (cur_char == '\n' || cur_char == '\r' || cur_char == '\0')
{
// newline
cur_y += displayed_font_y_size;
if (cur_y - y > height - displayed_font_y_size) break;
cur_x = x;
if (cur_char != '\0') ichar++;
i++;
cur_line++;
cur_col = 0;
continue;
}
if (pos_selected(imsg, ichar, select))
{
if (!in_select)
{
glColor3f (selection_red, selection_green, selection_blue);
in_select = 1;
}
}
else
{
if (in_select)
{
if (last_color_char)
find_font_char (last_color_char);
else if (msgs[imsg].r < 0)
find_font_char (to_color_char (c_grey1));
else
glColor3f (msgs[imsg].r, msgs[imsg].g, msgs[imsg].b);
in_select = 0;
}
}
if (is_color (cur_char))
{
last_color_char = cur_char;
if (in_select)
{
// don't draw color characters in a selection
i++;
ichar++;
continue;
}
}
cur_x += draw_char_scaled (cur_char, cur_x, cur_y, displayed_font_x_size, displayed_font_y_size);
cur_col++;
ichar++;
i++;
if (cur_x - x > width - displayed_font_x_size)
{
// ignore rest of this line, but keep track of
// color characters
while (1)
{
ch = msgs[imsg].data[ichar];
if (ch == '\0' || ch == '\n' || ch == '\r')
break;
if (is_color (ch))
last_color_char = ch;
ichar++;
i++;
}
}
}
if (cursor_x >= x && cursor_y >= y && cursor_y - y <= height - displayed_font_y_size)
{
draw_char_scaled ('_', cursor_x, cursor_y, displayed_font_x_size, displayed_font_y_size);
}
glEnd();
glDisable(GL_ALPHA_TEST);
#ifdef OPENGL_TRACE
CHECK_GL_ERRORS();
#endif //OPENGL_TRACE
}
int modelEngine::redrawModels()
{
// Set matrix mode
glMatrixMode(GL_MODELVIEW);
// Move camera
glLoadIdentity();
// move camera back to see the cube
glTranslatef(0.f, 0.f, -40);
// Start with a clear screen
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
// Cycle through all models and redraw them
WAVEFRONT_MODEL_T *modelData = NULL;
int j = 0;
for(j = 0; j < numModels; j++)
{
//===========
int i;
WAVEFRONT_MODEL_T *model = (WAVEFRONT_MODEL_T *)models[j];
// Check if model is enabled
if(model->modelEnabled)
{
// Save old matrix
glPushMatrix();
// Move model
glTranslatef(model->translate[0], model->translate[1], model->translate[2]);
// Rotate model
glRotatef(model->rotate[0], 1.0, 0.0, 0.0);
glRotatef(model->rotate[1], 0.0, 1.0, 0.0);
glRotatef(model->rotate[2], 0.0, 0.0, 1.0);
// Scale model
glScalef(model->scale[0], model->scale[1], model->scale[2]);
for (i=0; i<model->num_materials; i++) {
WAVEFRONT_MATERIAL_T *mat = model->material + i;
if (mat->texture == -1) continue;
glBindTexture(GL_TEXTURE_2D, mat->texture ? mat->texture:0);
if (mat->vbo[VBO_VERTEX]) {
glBindBuffer(GL_ARRAY_BUFFER, mat->vbo[VBO_VERTEX]);
glVertexPointer(3, GL_FLOAT, 0, NULL);
}
if (mat->vbo[VBO_NORMAL]) {
glEnableClientState(GL_NORMAL_ARRAY);
glBindBuffer(GL_ARRAY_BUFFER, mat->vbo[VBO_NORMAL]);
glNormalPointer(GL_FLOAT, 0, NULL);
} else {
glDisableClientState(GL_NORMAL_ARRAY);
}
if (mat->vbo[VBO_TEXTURE]) {
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glBindBuffer(GL_ARRAY_BUFFER, mat->vbo[VBO_TEXTURE]);
glTexCoordPointer(2, GL_FLOAT, 0, NULL);
} else {
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
}
//==========================
// Set model material propertiesOOTH);
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, model->ambientColor);
checkGLError();
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, model->specularColor);
checkGLError();
glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, model->shininess);
checkGLError();
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, model->difuseColor);
checkGLError();
//===========================
glDrawArrays(GL_TRIANGLES, 0, mat->numverts);
}
glBindBuffer(GL_ARRAY_BUFFER, 0);
// Check if model has text data in it
if(modelText[j].textReady)
{
glPopMatrix();
// If yes, draw fonts
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glEnableClientState( GL_VERTEX_ARRAY );
// Alpha test enable
glEnable(GL_ALPHA_TEST);
// If fragment has alpha greater than value, draw it, otherwise discard
glAlphaFunc(GL_GREATER, 0.5);
// Save old matrix
glPushMatrix();
// Move model
glTranslatef(model->translate[0] + modelText[j].offset.x, model->translate[1] + modelText[j].offset.y, model->translate[2] + modelText[j].offset.z);
// Rotate model
glRotatef(model->rotate[0], 1.0, 0.0, 0.0);
glRotatef(model->rotate[1], 0.0, 1.0, 0.0);
glRotatef(model->rotate[2], 0.0, 0.0, 1.0);
// Scale model
glScalef(model->scale[0], model->scale[1], model->scale[2]);
// Move model
//glTranslatef(modelText[j].offset.x, modelText[j].offset.y, modelText[j].offset.z);
// Draw on screen
// Bind texture atlas texture
glBindTexture(GL_TEXTURE_2D, atlas->id);
// Bind buffers
// Bind vertex buffer
glBindBuffer(GL_ARRAY_BUFFER, modelText[j].vertexBuffer);
glVertexPointer(3, GL_FLOAT, 0, NULL);
// Bind texture buffer
glBindBuffer(GL_ARRAY_BUFFER, modelText[j].texBuffer);
glTexCoordPointer(2, GL_FLOAT, 0, NULL);
glColor4f(modelText[j].fontColor.r, modelText[j].fontColor.g, modelText[j].fontColor.b, modelText[j].fontColor.a);
glDrawArrays(GL_TRIANGLES, 0, modelText[j].characters * 6);
glBindBuffer(GL_ARRAY_BUFFER, 0);
//glEnableClientState(GL_NORMAL_ARRAY);
//glDisableClientState(GL_COLOR_ARRAY);
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
// Alpha test disable
glDisable(GL_ALPHA_TEST);
}
// At end restore matrix
glPopMatrix();
}
}
eglSwapBuffers(state.display, state.surface);
return 0;
}
int main(int argc, char **argv){
printf("%d arguments\n",argc);
for(int n = 0;n<argc;n++) {
printf("Argument %d: %s\n",n,argv[n]);
}
printf("\n");
listCudaAttributes();
glewInit();
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE);
if(argc >= 2) {
screenHeight = atoi(argv[1]);
screenWidth = screenHeight;
} else {
screenHeight = glutGet(GLUT_SCREEN_HEIGHT);
screenWidth = glutGet(GLUT_SCREEN_WIDTH);
if(screenHeight > screenWidth) {
screenHeight = screenWidth;
} else {
screenWidth = screenHeight;
}
}
printf("window height is: %d, window width is: %d\n",screenHeight, screenWidth);
textSpaceMultiplier = 10.0f / float(screenHeight);
glutInitWindowSize(screenWidth,screenHeight);
glutCreateWindow("Disease Propagation Simulation");
glEnable(GL_DEPTH_TEST);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_ALPHA_TEST);
glAlphaFunc(GL_GREATER, 0.1f);
gluPerspective(45,1.0,1.0,40000.0);
cameraDistance = 5000;
glutMouseFunc(onMouseStateChange);
glutMotionFunc(onMouseMove);
glutKeyboardFunc(keyPressed);
glutDisplayFunc(onDisplay);
glewInit();
updateMapSize(2000);
initialise(NUM_ACTORS);
glutTimerFunc(10, onRedrawTimer, 10); // redraw only every given millisec
glutMainLoop();
return 0;
}
void OpenGL::Begin()
{
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
glAlphaFunc( GL_GREATER, 1.0f );
glEnable( GL_BLEND );
}
void ClippingNode::onBeforeVisit()
{
///////////////////////////////////
// INIT
// increment the current layer
s_layer++;
// mask of the current layer (ie: for layer 3: 00000100)
GLint mask_layer = 0x1 << s_layer;
// mask of all layers less than the current (ie: for layer 3: 00000011)
GLint mask_layer_l = mask_layer - 1;
// mask of all layers less than or equal to the current (ie: for layer 3: 00000111)
_mask_layer_le = mask_layer | mask_layer_l;
// manually save the stencil state
_currentStencilEnabled = glIsEnabled(GL_STENCIL_TEST);
glGetIntegerv(GL_STENCIL_WRITEMASK, (GLint *)&_currentStencilWriteMask);
glGetIntegerv(GL_STENCIL_FUNC, (GLint *)&_currentStencilFunc);
glGetIntegerv(GL_STENCIL_REF, &_currentStencilRef);
glGetIntegerv(GL_STENCIL_VALUE_MASK, (GLint *)&_currentStencilValueMask);
glGetIntegerv(GL_STENCIL_FAIL, (GLint *)&_currentStencilFail);
glGetIntegerv(GL_STENCIL_PASS_DEPTH_FAIL, (GLint *)&_currentStencilPassDepthFail);
glGetIntegerv(GL_STENCIL_PASS_DEPTH_PASS, (GLint *)&_currentStencilPassDepthPass);
// enable stencil use
glEnable(GL_STENCIL_TEST);
// check for OpenGL error while enabling stencil test
CHECK_GL_ERROR_DEBUG();
// all bits on the stencil buffer are readonly, except the current layer bit,
// this means that operation like glClear or glStencilOp will be masked with this value
glStencilMask(mask_layer);
// manually save the depth test state
glGetBooleanv(GL_DEPTH_WRITEMASK, &_currentDepthWriteMask);
// disable depth test while drawing the stencil
//glDisable(GL_DEPTH_TEST);
// disable update to the depth buffer while drawing the stencil,
// as the stencil is not meant to be rendered in the real scene,
// it should never prevent something else to be drawn,
// only disabling depth buffer update should do
glDepthMask(GL_FALSE);
///////////////////////////////////
// CLEAR STENCIL BUFFER
// manually clear the stencil buffer by drawing a fullscreen rectangle on it
// setup the stencil test func like this:
// for each pixel in the fullscreen rectangle
// never draw it into the frame buffer
// if not in inverted mode: set the current layer value to 0 in the stencil buffer
// if in inverted mode: set the current layer value to 1 in the stencil buffer
glStencilFunc(GL_NEVER, mask_layer, mask_layer);
glStencilOp(!_inverted ? GL_ZERO : GL_REPLACE, GL_KEEP, GL_KEEP);
// draw a fullscreen solid rectangle to clear the stencil buffer
//ccDrawSolidRect(Vec2::ZERO, ccpFromSize([[Director sharedDirector] winSize]), Color4F(1, 1, 1, 1));
drawFullScreenQuadClearStencil();
///////////////////////////////////
// DRAW CLIPPING STENCIL
// setup the stencil test func like this:
// for each pixel in the stencil node
// never draw it into the frame buffer
// if not in inverted mode: set the current layer value to 1 in the stencil buffer
// if in inverted mode: set the current layer value to 0 in the stencil buffer
glStencilFunc(GL_NEVER, mask_layer, mask_layer);
glStencilOp(!_inverted ? GL_REPLACE : GL_ZERO, GL_KEEP, GL_KEEP);
// enable alpha test only if the alpha threshold < 1,
// indeed if alpha threshold == 1, every pixel will be drawn anyways
if (_alphaThreshold < 1) {
#if (CC_TARGET_PLATFORM == CC_PLATFORM_MAC || CC_TARGET_PLATFORM == CC_PLATFORM_WINDOWS || CC_TARGET_PLATFORM == CC_PLATFORM_LINUX)
// manually save the alpha test state
_currentAlphaTestEnabled = glIsEnabled(GL_ALPHA_TEST);
glGetIntegerv(GL_ALPHA_TEST_FUNC, (GLint *)&_currentAlphaTestFunc);
glGetFloatv(GL_ALPHA_TEST_REF, &_currentAlphaTestRef);
// enable alpha testing
glEnable(GL_ALPHA_TEST);
// check for OpenGL error while enabling alpha test
CHECK_GL_ERROR_DEBUG();
// pixel will be drawn only if greater than an alpha threshold
glAlphaFunc(GL_GREATER, _alphaThreshold);
#else
#endif
}
//Draw _stencil
}
void State::Apply()
{
if (last_state == this)
{
return;
}
last_state = this;
if (global_modulation)
{
GLfloat modulated_color[4];
int modulation = global_modulation & 0xff;
if (modulation == MEDIUM)
{
modulated_color[0] = (color[0] + global_color[0]) / 2.0f;
modulated_color[1] = (color[1] + global_color[1]) / 2.0f;
modulated_color[2] = (color[2] + global_color[2]) / 2.0f;
modulated_color[3] = (global_modulation & ALPHA) ? (color[3] + global_color[3]) / 2.0f : color[3];
}
else if (modulation == MULTIPLY)
{
modulated_color[0] = color[0] * global_color[0];
modulated_color[1] = color[1] * global_color[1];
modulated_color[2] = color[2] * global_color[2];
modulated_color[3] = (global_modulation & ALPHA) ? (color[3] * global_color[3]) : color[3];
}
else if (modulation == ADD)
{
modulated_color[0] = color[0] + global_color[0];
modulated_color[1] = color[1] + global_color[1];
modulated_color[2] = color[2] + global_color[2];
modulated_color[3] = (global_modulation & ALPHA) ? (color[3] + global_color[3]) : color[3];
}
else if (modulation == INVERSE)
{
modulated_color[0] = global_color[0] - color[0];
modulated_color[1] = global_color[1] - color[1];
modulated_color[2] = global_color[2] - color[2];
modulated_color[3] = (global_modulation & ALPHA) ? (global_color[3] - color[3]) : color[3];
}
glColor4fv(modulated_color);
}
else
{
glColor4fv(color);
}
if ((global_blend_func_src != GL_ZERO) && (global_blend_func_dst != GL_ZERO))
{
if ((blend_func_src != last_blend_func_src) || (blend_func_dst != last_blend_func_dst))
{
last_blend_func_src = blend_func_src;
last_blend_func_dst = blend_func_dst;
if ((blend_func_src != GL_ONE) || (blend_func_dst != GL_ZERO))
{
glEnable(GL_BLEND); // TODO: enable only if not already enabled
glBlendFunc(blend_func_src, blend_func_dst);
}
else
{
glDisable(GL_BLEND);
}
}
}
if ((alpha_func != last_alpha_func) || (alpha_ref != last_alpha_ref))
{
last_alpha_func = alpha_func;
last_alpha_ref = alpha_ref;
if (alpha_func != GL_ALWAYS)
{
glEnable(GL_ALPHA_TEST); // TODO: enable only if not already enabled
glAlphaFunc(alpha_func, alpha_ref);
}
else
{
glDisable(GL_ALPHA_TEST);
}
}
if (shade_model != last_shade_model)
{
last_shade_model = shade_model;
glShadeModel(shade_model);
}
if (cull_face_mode != last_cull_face_mode)
{
last_cull_face_mode = cull_face_mode;
if (cull_face_mode != GL_FALSE)
{
glEnable(GL_CULL_FACE); // TODO: enable only if not already enabled
glCullFace(cull_face_mode);
}
else
{
glDisable(GL_CULL_FACE);
}
}
if (fog != last_fog)
{
last_fog = fog;
if (fog)
{
fog->Apply();
}
else
{
Fog::ApplyBasic();
}
}
for (int i=0; i<MAX_TEXTURE_UNITS; i++)
{
if (texture_modifier[i] != last_texture_modifier[i])
{
last_texture_modifier[i] = texture_modifier[i];
if (texture_modifier[i])
{
texture_modifier[i]->Apply();
}
else
{
TextureModifier::ApplyBasic();
}
}
}
#ifdef CG_SHADER
if (shader != last_shader)
{
last_shader = shader;
if (shader)
{
shader->Apply();
}
else
{
Shader::ApplyBasic();
}
}
#endif
}
static void DrawFire(ModeInfo * mi)
{
int j;
firestruct *fs = &fire[MI_SCREEN(mi)];
Bool wire = MI_IS_WIREFRAME(mi);
if (do_trackmouse && !MI_IS_ICONIC(mi))
trackmouse(mi);
if (do_wander)
{
GLfloat x, y, z;
# define SINOID(SCALE,SIZE) \
((((1 + sin((frame * (SCALE)) / 2 * M_PI)) / 2.0) * (SIZE)) - (SIZE)/2)
x = SINOID(0.031, 0.85);
y = SINOID(0.017, 0.25);
z = SINOID(0.023, 0.85);
frame++;
fs->obs[0] = x + DEF_OBS[0];
fs->obs[1] = y + DEF_OBS[1];
fs->obs[2] = z + DEF_OBS[2];
fs->dir[1] = y;
fs->dir[2] = z;
}
glEnable(GL_DEPTH_TEST);
if (fs->fog)
glEnable(GL_FOG);
else
glDisable(GL_FOG);
glDepthMask(GL_TRUE);
glClearColor(0.5, 0.5, 0.8, 1.0); /* sky in the distance */
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glPushMatrix();
calcposobs(fs);
gluLookAt(fs->obs[0], fs->obs[1], fs->obs[2],
fs->obs[0] + fs->dir[0], fs->obs[1] + fs->dir[1],
fs->obs[2] + fs->dir[2], 0.0, 1.0, 0.0);
glEnable(GL_TEXTURE_2D);
/* draw ground using the computed texture */
#ifdef HAVE_GLBINDTEXTURE
if (do_texture) {
glColor4f(1.0,1.0,1.0,1.0); /* white to get texture in it's true color */
glBindTexture(GL_TEXTURE_2D, fs->groundid);
}
else
#endif /* HAVE_GLBINDTEXTURE */
glColor4f(0.54, 0.27, 0.07, 1.0); /* untextured ground color */
glBegin(GL_QUADS);
glTexCoord2fv(qt[0]);
glVertex3fv(q[0]);
glTexCoord2fv(qt[1]);
glVertex3fv(q[1]);
glTexCoord2fv(qt[2]);
glVertex3fv(q[2]);
glTexCoord2fv(qt[3]);
glVertex3fv(q[3]);
glEnd();
glAlphaFunc(GL_GEQUAL, 0.9);
#ifdef HAVE_GLBINDTEXTURE
if (fs->num_trees)
{
/* here do_texture IS True - and color used is white */
glEnable(GL_ALPHA_TEST);
glBindTexture(GL_TEXTURE_2D,fs->treeid);
for(j=0;j<fs->num_trees;j++)
drawtree(fs->treepos[j].x ,fs->treepos[j].y ,fs->treepos[j].z );
glDisable(GL_ALPHA_TEST);
}
#endif /* HAVE_GLBINDTEXTURE */
glDisable(GL_TEXTURE_2D);
glDepthMask(GL_FALSE);
if (fs->shadows) {
/* draw shadows with black color */
glBegin(wire ? GL_LINE_STRIP : GL_TRIANGLES);
for (j = 0; j < fs->np; j++) {
glColor4f(black[0], black[1], black[2], fs->p[j].c[0][3]);
glVertex3f(fs->p[j].p[0][0], 0.1, fs->p[j].p[0][2]);
glColor4f(black[0], black[1], black[2], fs->p[j].c[1][3]);
glVertex3f(fs->p[j].p[1][0], 0.1, fs->p[j].p[1][2]);
glColor4f(black[0], black[1], black[2], fs->p[j].c[2][3]);
glVertex3f(fs->p[j].p[2][0], 0.1, fs->p[j].p[2][2]);
}
glEnd();
}
glBegin(wire ? GL_LINE_STRIP : GL_TRIANGLES);
for (j = 0; j < fs->np; j++) {
/* draw particles: colors are computed in setpart */
glColor4fv(fs->p[j].c[0]);
glVertex3fv(fs->p[j].p[0]);
glColor4fv(fs->p[j].c[1]);
glVertex3fv(fs->p[j].p[1]);
glColor4fv(fs->p[j].c[2]);
glVertex3fv(fs->p[j].p[2]);
setpart(fs, &fs->p[j]);
}
glEnd();
/* draw rain particles if no fire particles */
if (!fs->np)
{
float timeused = gettimerain();
glDisable(GL_TEXTURE_2D);
glShadeModel(GL_SMOOTH);
glBegin(GL_LINES);
for (j = 0; j < NUMPART; j++) {
glColor4f(0.7f,0.95f,1.0f,0.0f);
glVertex3fv(fs->r[j].oldpos);
glColor4f(0.3f,0.7f,1.0f,1.0f);
glVertex3fv(fs->r[j].pos);
setpartrain(fs, &fs->r[j],timeused);
}
glEnd();
glShadeModel(GL_FLAT);
}
glDisable(GL_TEXTURE_2D);
glDisable(GL_ALPHA_TEST);
glDisable(GL_DEPTH_TEST);
glDisable(GL_FOG);
/* manage framerate display */
if (MI_IS_FPS(mi)) do_fps (mi);
glPopMatrix();
}
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= 11.0*text_zoom;
float displayed_font_y_size= 18.0*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);
#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];
// 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;
}
bool CProjectileDrawer::DrawProjectileModel(const CProjectile* p, bool shadowPass) {
if (!(p->weapon || p->piece) || (p->model == NULL)) {
return false;
}
if (p->weapon) {
// weapon-projectile
const CWeaponProjectile* wp = dynamic_cast<const CWeaponProjectile*>(p);
#define SET_TRANSFORM_VECTORS(dir) \
float3 rightdir, updir; \
\
if (fabs(dir.y) < 0.95f) { \
rightdir = dir.cross(UpVector); \
rightdir.SafeANormalize(); \
} else { \
rightdir = float3(1.0f, 0.0f, 0.0f); \
} \
\
updir = rightdir.cross(dir);
#define TRANSFORM_DRAW(mat) \
glPushMatrix(); \
glMultMatrixf(mat); \
glCallList(wp->model->GetRootPiece()->dispListID); \
glPopMatrix();
switch (wp->GetProjectileType()) {
case CWeaponProjectile::WEAPON_BASE_PROJECTILE:
case CWeaponProjectile::WEAPON_EXPLOSIVE_PROJECTILE:
case CWeaponProjectile::WEAPON_LASER_PROJECTILE:
case CWeaponProjectile::WEAPON_TORPEDO_PROJECTILE: {
if (!shadowPass) {
unitDrawer->SetTeamColour(wp->colorTeam);
}
float3 dir(wp->speed);
dir.SafeANormalize();
SET_TRANSFORM_VECTORS(dir);
CMatrix44f transMatrix(wp->drawPos, -rightdir, updir, dir);
TRANSFORM_DRAW(transMatrix);
} break;
case CWeaponProjectile::WEAPON_MISSILE_PROJECTILE: {
if (!shadowPass) {
unitDrawer->SetTeamColour(wp->colorTeam);
}
SET_TRANSFORM_VECTORS(wp->dir);
CMatrix44f transMatrix(wp->drawPos + wp->dir * wp->radius * 0.9f, -rightdir, updir, wp->dir);
TRANSFORM_DRAW(transMatrix);
} break;
case CWeaponProjectile::WEAPON_STARBURST_PROJECTILE: {
if (!shadowPass) {
unitDrawer->SetTeamColour(wp->colorTeam);
}
SET_TRANSFORM_VECTORS(wp->dir);
CMatrix44f transMatrix(wp->drawPos, -rightdir, updir, wp->dir);
TRANSFORM_DRAW(transMatrix);
} break;
default: {
} break;
}
#undef SET_TRANSFORM_VECTORS
#undef TRANSFORM_DRAW
} else {
// piece-projectile
const CPieceProjectile* pp = dynamic_cast<const CPieceProjectile*>(p);
if (!shadowPass) {
unitDrawer->SetTeamColour(pp->colorTeam);
}
if (pp->alphaThreshold != 0.1f) {
glPushAttrib(GL_COLOR_BUFFER_BIT);
glAlphaFunc(GL_GEQUAL, pp->alphaThreshold);
}
glPushMatrix();
glTranslatef3(pp->pos);
glRotatef(pp->spinAngle, pp->spinVec.x, pp->spinVec.y, pp->spinVec.z);
glCallList(pp->dispList);
glPopMatrix();
if (pp->alphaThreshold != 0.1f) {
glPopAttrib();
}
}
return true;
}
void draw_string_zoomed_clipped (int x, int y, const unsigned char* our_string, int cursor_pos, int width, int height, 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 cursor_x = x-1, cursor_y = y-1;
if (width < displayed_font_x_size || height < displayed_font_y_size)
// no point in trying
return;
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)
{
if (i == cursor_pos)
{
cursor_x = cur_x;
cursor_y = cur_y;
if (cursor_x - x > width - displayed_font_x_size)
{
cursor_x = x;
cursor_y = cur_y + displayed_font_y_size;
}
}
cur_char = our_string[i];
// watch for special characters
if (!cur_char)
{
// end of string
break;
}
else if (cur_char == '\n' || cur_char == '\r')
{
// newline
cur_y += displayed_font_y_size;
if (cur_y - y > height - displayed_font_y_size) break;
cur_x = x;
i++;
continue;
}
cur_x += draw_char_scaled (cur_char, cur_x, cur_y, displayed_font_x_size, displayed_font_y_size);
i++;
if (cur_x - x > width - displayed_font_x_size)
{
// ignore rest of this line
while (our_string[i] != '\0' && our_string[i] != '\n' && our_string[i] != '\r') i++;
}
}
if (cursor_x >= x && cursor_y >= y && cursor_y - y <= height - displayed_font_y_size)
{
draw_char_scaled ('_', cursor_x, cursor_y, displayed_font_x_size, displayed_font_y_size);
}
glEnd();
glDisable(GL_ALPHA_TEST);
#ifdef OPENGL_TRACE
CHECK_GL_ERRORS();
#endif //OPENGL_TRACE
}
int WINAPI WinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpCmdLine,
int nCmdShow)
{
WNDCLASSEX wcex;
HWND hwnd;
HDC hDC;
HGLRC hRC;
MSG msg;
BOOL bQuit = FALSE;
float theta = 0.0f;
// register window class
wcex.cbSize = sizeof(WNDCLASSEX);
wcex.style = CS_OWNDC;
wcex.lpfnWndProc = WindowProc;
wcex.cbClsExtra = 0;
wcex.cbWndExtra = 0;
wcex.hInstance = hInstance;
wcex.hIcon = LoadIcon(NULL, IDI_APPLICATION);
wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
wcex.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
wcex.lpszMenuName = NULL;
wcex.lpszClassName = "GLSample";
wcex.hIconSm = LoadIcon(NULL, IDI_APPLICATION);
if (!RegisterClassEx(&wcex))
return 0;
// create main window
hwnd = CreateWindowEx(0,
"GLSample",
"SOIL Sample",
WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT,
CW_USEDEFAULT,
512,
512,
NULL,
NULL,
hInstance,
NULL);
ShowWindow(hwnd, nCmdShow);
// check my error handling
/*
SOIL_load_OGL_texture( "img_test.png", SOIL_LOAD_AUTO, SOIL_CREATE_NEW_ID, 0 );
std::cout << "'" << SOIL_last_result() << "'" << std::endl;
*/
// enable OpenGL for the window
EnableOpenGL(hwnd, &hDC, &hRC);
glEnable( GL_BLEND );
//glDisable( GL_BLEND );
// straight alpha
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
// premultiplied alpha (remember to do the same in glColor!!)
//glBlendFunc( GL_ONE, GL_ONE_MINUS_SRC_ALPHA );
// do I want alpha thresholding?
glEnable( GL_ALPHA_TEST );
glAlphaFunc( GL_GREATER, 0.5f );
// log what the use is asking us to load
std::string load_me = lpCmdLine;
if( load_me.length() > 2 )
{
//load_me = load_me.substr( 1, load_me.length() - 2 );
load_me = load_me.substr( 0, load_me.length() - 0 );
} else
{
//load_me = "img_test_uncompressed.dds";
//load_me = "img_test_indexed.tga";
//load_me = "img_test.dds";
load_me = "img_test.png";
//load_me = "odd_size.jpg";
//load_me = "img_cheryl.jpg";
//load_me = "oak_odd.png";
//load_me = "field_128_cube.dds";
//load_me = "field_128_cube_nomip.dds";
//load_me = "field_128_cube_uc.dds";
//load_me = "field_128_cube_uc_nomip.dds";
//load_me = "Goblin.dds";
//load_me = "parquet.dds";
//load_me = "stpeters_probe.hdr";
//load_me = "VeraMoBI_sdf.png";
// for testing the texture rectangle code
//load_me = "test_rect.png";
}
std::cout << "'" << load_me << "'" << std::endl;
// 1st try to load it as a single-image-cubemap
// (note, need DDS ordered faces: "EWUDNS")
GLuint tex_ID;
int time_me;
std::cout << "Attempting to load as a cubemap" << std::endl;
time_me = clock();
tex_ID = SOIL_load_OGL_single_cubemap(
load_me.c_str(),
SOIL_DDS_CUBEMAP_FACE_ORDER,
SOIL_LOAD_AUTO,
SOIL_CREATE_NEW_ID,
SOIL_FLAG_POWER_OF_TWO
| SOIL_FLAG_MIPMAPS
//| SOIL_FLAG_COMPRESS_TO_DXT
//| SOIL_FLAG_TEXTURE_REPEATS
//| SOIL_FLAG_INVERT_Y
| SOIL_FLAG_DDS_LOAD_DIRECT
);
time_me = clock() - time_me;
std::cout << "the load time was " << 0.001f * time_me << " seconds (warning: low resolution timer)" << std::endl;
if( tex_ID > 0 )
{
glEnable( GL_TEXTURE_CUBE_MAP );
glEnable( GL_TEXTURE_GEN_S );
glEnable( GL_TEXTURE_GEN_T );
glEnable( GL_TEXTURE_GEN_R );
glTexGeni( GL_S, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP );
glTexGeni( GL_T, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP );
glTexGeni( GL_R, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP );
glBindTexture( GL_TEXTURE_CUBE_MAP, tex_ID );
// report
std::cout << "the loaded single cube map ID was " << tex_ID << std::endl;
//std::cout << "the load time was " << 0.001f * time_me << " seconds (warning: low resolution timer)" << std::endl;
} else
{
std::cout << "Attempting to load as a HDR texture" << std::endl;
time_me = clock();
tex_ID = SOIL_load_OGL_HDR_texture(
load_me.c_str(),
//SOIL_HDR_RGBE,
//SOIL_HDR_RGBdivA,
SOIL_HDR_RGBdivA2,
0,
SOIL_CREATE_NEW_ID,
SOIL_FLAG_POWER_OF_TWO
| SOIL_FLAG_MIPMAPS
//| SOIL_FLAG_COMPRESS_TO_DXT
);
time_me = clock() - time_me;
std::cout << "the load time was " << 0.001f * time_me << " seconds (warning: low resolution timer)" << std::endl;
// did I fail?
if( tex_ID < 1 )
{
// loading of the single-image-cubemap failed, try it as a simple texture
std::cout << "Attempting to load as a simple 2D texture" << std::endl;
// load the texture, if specified
time_me = clock();
tex_ID = SOIL_load_OGL_texture(
load_me.c_str(),
SOIL_LOAD_AUTO,
SOIL_CREATE_NEW_ID,
SOIL_FLAG_POWER_OF_TWO
| SOIL_FLAG_MIPMAPS
//| SOIL_FLAG_MULTIPLY_ALPHA
//| SOIL_FLAG_COMPRESS_TO_DXT
| SOIL_FLAG_DDS_LOAD_DIRECT
//| SOIL_FLAG_NTSC_SAFE_RGB
//| SOIL_FLAG_CoCg_Y
//| SOIL_FLAG_TEXTURE_RECTANGLE
);
time_me = clock() - time_me;
std::cout << "the load time was " << 0.001f * time_me << " seconds (warning: low resolution timer)" << std::endl;
}
if( tex_ID > 0 )
{
// enable texturing
glEnable( GL_TEXTURE_2D );
//glEnable( 0x84F5 );// enables texture rectangle
// bind an OpenGL texture ID
glBindTexture( GL_TEXTURE_2D, tex_ID );
// report
std::cout << "the loaded texture ID was " << tex_ID << std::endl;
//std::cout << "the load time was " << 0.001f * time_me << " seconds (warning: low resolution timer)" << std::endl;
} else
{
// loading of the texture failed...why?
glDisable( GL_TEXTURE_2D );
std::cout << "Texture loading failed: '" << SOIL_last_result() << "'" << std::endl;
}
}
// program main loop
const float ref_mag = 0.1f;
while (!bQuit)
{
// check for messages
if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
{
// handle or dispatch messages
if (msg.message == WM_QUIT)
{
bQuit = TRUE;
}
else
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
else
{
// OpenGL animation code goes here
theta = clock() * 0.1;
float tex_u_max = 1.0f;//0.2f;
float tex_v_max = 1.0f;//0.2f;
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClear(GL_COLOR_BUFFER_BIT);
glPushMatrix();
glScalef( 0.8f, 0.8f, 0.8f );
//glRotatef(-0.314159f*theta, 0.0f, 0.0f, 1.0f);
glColor4f( 1.0f, 1.0f, 1.0f, 1.0f );
glNormal3f( 0.0f, 0.0f, 1.0f );
glBegin(GL_QUADS);
glNormal3f( -ref_mag, -ref_mag, 1.0f );
glTexCoord2f( 0.0f, tex_v_max );
glVertex3f( -1.0f, -1.0f, -0.1f );
glNormal3f( ref_mag, -ref_mag, 1.0f );
glTexCoord2f( tex_u_max, tex_v_max );
glVertex3f( 1.0f, -1.0f, -0.1f );
glNormal3f( ref_mag, ref_mag, 1.0f );
glTexCoord2f( tex_u_max, 0.0f );
glVertex3f( 1.0f, 1.0f, -0.1f );
glNormal3f( -ref_mag, ref_mag, 1.0f );
glTexCoord2f( 0.0f, 0.0f );
glVertex3f( -1.0f, 1.0f, -0.1f );
glEnd();
glPopMatrix();
tex_u_max = 1.0f;
tex_v_max = 1.0f;
glPushMatrix();
glScalef( 0.8f, 0.8f, 0.8f );
glRotatef(theta, 0.0f, 0.0f, 1.0f);
glColor4f( 1.0f, 1.0f, 1.0f, 1.0f );
glNormal3f( 0.0f, 0.0f, 1.0f );
glBegin(GL_QUADS);
glTexCoord2f( 0.0f, tex_v_max ); glVertex3f( 0.0f, 0.0f, 0.1f );
glTexCoord2f( tex_u_max, tex_v_max ); glVertex3f( 1.0f, 0.0f, 0.1f );
glTexCoord2f( tex_u_max, 0.0f ); glVertex3f( 1.0f, 1.0f, 0.1f );
glTexCoord2f( 0.0f, 0.0f ); glVertex3f( 0.0f, 1.0f, 0.1f );
glEnd();
glPopMatrix();
{
/* check for errors */
GLenum err_code = glGetError();
while( GL_NO_ERROR != err_code )
{
printf( "OpenGL Error @ %s: %i", "drawing loop", err_code );
err_code = glGetError();
}
}
SwapBuffers(hDC);
Sleep (1);
}
}
// and show off the screenshot capability
/*
load_me += "-screenshot.tga";
SOIL_save_screenshot( load_me.c_str(), SOIL_SAVE_TYPE_TGA, 0, 0, 512, 512 );
//*/
//*
load_me += "-screenshot.bmp";
SOIL_save_screenshot( load_me.c_str(), SOIL_SAVE_TYPE_BMP, 0, 0, 512, 512 );
//*/
/*
load_me += "-screenshot.dds";
SOIL_save_screenshot( load_me.c_str(), SOIL_SAVE_TYPE_DDS, 0, 0, 512, 512 );
//*/
// shutdown OpenGL
DisableOpenGL(hwnd, hDC, hRC);
// destroy the window explicitly
DestroyWindow(hwnd);
return msg.wParam;
}
void draw_ortho_ingame_string(float x, float y,float z, const unsigned char * our_string,
int max_lines, float font_x_scale, float font_y_scale)
{
float u_start,u_end,v_start,v_end;
int col,row;
float displayed_font_x_size;
float displayed_font_y_size;
float displayed_font_x_width;
#ifndef SKY_FPV_OPTIONAL
int font_x_size=FONT_X_SPACING;
int font_y_size=FONT_Y_SPACING;
#endif // not SKY_FPV_OPTIONAL
int font_bit_width, ignored_bits;
unsigned char cur_char;
int chr;
int i;
float cur_x,cur_y;
int current_lines=0;
#ifndef SKY_FPV_OPTIONAL
/*
if(big)
{
displayed_font_x_size=0.17*zoom_level*name_zoom/3.0;
displayed_font_y_size=0.25*zoom_level*name_zoom/3.0;
}
else
{
displayed_font_x_size=SMALL_INGAME_FONT_X_LEN*zoom_level*name_zoom/3.0;
displayed_font_y_size=SMALL_INGAME_FONT_Y_LEN*zoom_level*name_zoom/3.0;
}
*/
#endif // not SKY_FPV_OPTIONAL
displayed_font_x_size=font_x_scale*name_zoom*12.0;
displayed_font_y_size=font_y_scale*name_zoom*12.0;
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);
#ifndef SKY_FPV_OPTIONAL
while(1)
{
cur_char=our_string[i];
if(!cur_char)
{
break;
}
else if(cur_char=='\n')
{
cur_y+=displayed_font_y_size;
cur_x=x;
i++;
current_lines++;
if(current_lines>=max_lines)break;
continue;
}
else if (is_color (cur_char))
{
glEnd(); //Ooops - NV bug fix!!
}
chr=find_font_char(cur_char);
if(chr >= 0)
{
col=chr/FONT_CHARS_PER_LINE;
row=chr%FONT_CHARS_PER_LINE;
font_bit_width=get_font_width(chr);
displayed_font_x_width=((float)font_bit_width)*displayed_font_x_size/12.0;
ignored_bits=(12-font_bit_width)/2; // how many bits on each side of the char are ignored?
if(ignored_bits < 0)ignored_bits=0;
//now get the texture coordinates
u_start=(float)(row*font_x_size+ignored_bits)/256.0f;
u_end=(float)(row*font_x_size+font_x_size-7-ignored_bits)/256.0f;
#ifdef NEW_TEXTURES
v_start=(float)(1+col*font_y_size)/256.0f;
v_end=(float)(col*font_y_size+font_y_size-1)/256.0f;
#else
v_start=(float)1.0f-(1+col*font_y_size)/256.0f;
v_end=(float)1.0f-(col*font_y_size+font_y_size-1)/256.0f;
#endif //NEW_TEXTURES
//v_end=(float)1.0f-(col*font_y_size+font_y_size-2)/256.0f;
glTexCoord2f(u_start,v_start);
glVertex3f(cur_x,cur_y+displayed_font_y_size,z);
glTexCoord2f(u_start,v_end);
glVertex3f(cur_x,cur_y,z);
glTexCoord2f(u_end,v_end);
glVertex3f(cur_x+displayed_font_x_width,cur_y,z);
glTexCoord2f(u_end,v_start);
glVertex3f(cur_x+displayed_font_x_width,cur_y+displayed_font_y_size,z);
//cur_x+=displayed_font_x_size;
cur_x+=displayed_font_x_width;
}
else if (is_color (cur_char))
{
glBegin(GL_QUADS); //Ooops - NV bug fix!!
}
#else // SKY_FPV_OPTIONAL
while(1){
cur_char=our_string[i];
if(!cur_char){
break;
} else if(cur_char=='\n'){
cur_y+=displayed_font_y_size;
cur_x=x;
#endif // SKY_FPV_OPTIONAL
i++;
#ifdef SKY_FPV_OPTIONAL
current_lines++;
if(current_lines>=max_lines)break;
continue;
} else if (is_color (cur_char)){
glEnd(); //Ooops - NV bug fix!!
glBegin(GL_QUADS);
}
chr=find_font_char(cur_char);
if(chr >= 0){
col=chr/FONT_CHARS_PER_LINE;
row=chr%FONT_CHARS_PER_LINE;
font_bit_width=get_font_width(chr);
displayed_font_x_width=((float)font_bit_width)*displayed_font_x_size/12.0;
ignored_bits=(12-font_bit_width)/2; // how many bits on each side of the char are ignored?
if(ignored_bits < 0)ignored_bits=0;
//now get the texture coordinates
u_start=(float)(row*FONT_X_SPACING+ignored_bits)/256.0f;
u_end=(float)(row*FONT_X_SPACING+FONT_X_SPACING-7-ignored_bits)/256.0f;
#ifdef NEW_TEXTURES
v_start=(float)(1+col*FONT_Y_SPACING)/256.0f;
v_end=(float)(col*FONT_Y_SPACING+FONT_Y_SPACING-1)/256.0f;
#else
v_start=(float)1.0f-(1+col*FONT_Y_SPACING)/256.0f;
v_end=(float)1.0f-(col*FONT_Y_SPACING+FONT_Y_SPACING-1)/256.0f;
#endif //NEW_TEXTURES
glTexCoord2f(u_start,v_start);
glVertex3f(cur_x,cur_y+displayed_font_y_size,z);
glTexCoord2f(u_start,v_end);
glVertex3f(cur_x,cur_y,z);
glTexCoord2f(u_end,v_end);
glVertex3f(cur_x+displayed_font_x_width,cur_y,z);
glTexCoord2f(u_end,v_start);
glVertex3f(cur_x+displayed_font_x_width,cur_y+displayed_font_y_size,z);
cur_x+=displayed_font_x_width;
} else if(is_color (cur_char)){
glEnd(); //Ooops - NV bug fix!!
glBegin(GL_QUADS);
#endif // SKY_FPV_OPTIONAL
}
#ifdef SKY_FPV_OPTIONAL
i++;
}
#endif // SKY_FPV_OPTIONAL
glEnd();
glDisable(GL_ALPHA_TEST);
}
void draw_ingame_string(float x, float y,const unsigned char * our_string,
int max_lines, float font_x_scale, float font_y_scale)
{
float u_start,u_end,v_start,v_end;
int col,row;
float displayed_font_x_size;
float displayed_font_y_size;
float displayed_font_x_width;
#ifndef SKY_FPV_OPTIONAL
//int font_x_size=FONT_X_SPACING;
//int font_y_size=FONT_Y_SPACING;
#endif // not SKY_FPV_OPTIONAL
int font_bit_width, ignored_bits;
unsigned char cur_char;
int chr;
int i;
float cur_x,cur_y;
int current_lines=0;
#ifdef SKY_FPV_OPTIONAL
double model[16], proj[16],hx,hy,hz;
int view[4];
displayed_font_x_size=font_x_scale*name_zoom*12.0*font_scale;
displayed_font_y_size=font_y_scale*name_zoom*12.0*font_scale;
glGetDoublev(GL_MODELVIEW_MATRIX, model);
glGetDoublev(GL_PROJECTION_MATRIX, proj);
glGetIntegerv(GL_VIEWPORT, view);
gluProject((double)x,0.0f,(double)y,model, proj, view, &hx,&hy,&hz);
glPushMatrix();
glLoadIdentity();
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
glOrtho(view[0],view[2]+view[0],view[1],view[3]+view[1],0.0f,-1.0f);
#endif // SKY_FPV_OPTIONAL
#ifndef SKY_FPV_OPTIONAL
displayed_font_x_size=font_x_scale*zoom_level*name_zoom/3.0;
displayed_font_y_size=font_y_scale*zoom_level*name_zoom/3.0;
#endif // not SKY_FPV_OPTIONAL
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;
#ifndef SKY_FPV_OPTIONAL
cur_x=x;
cur_y=y;
#else // SKY_FPV_OPTIONAL
cur_x=hx;
cur_y=hy;
#endif // SKY_FPV_OPTIONAL
glBegin(GL_QUADS);
#ifndef SKY_FPV_OPTIONAL
while(1)
{
cur_char=our_string[i];
if(!cur_char)
{
break;
}
else if(cur_char=='\n')
{
cur_y+=displayed_font_y_size;
cur_x=x;
i++;
current_lines++;
if(current_lines>=max_lines)break;
continue;
}
else if(is_color (cur_char))
{
glEnd(); //Ooops - NV bug fix!!
}
chr=find_font_char(cur_char);
if(chr >= 0)
{
col=chr/FONT_CHARS_PER_LINE;
row=chr%FONT_CHARS_PER_LINE;
font_bit_width=get_font_width(chr);
displayed_font_x_width=((float)font_bit_width)*displayed_font_x_size/12.0;
ignored_bits=(12-font_bit_width)/2; // how many bits on each side of the char are ignored?
if(ignored_bits < 0)ignored_bits=0;
//now get the texture coordinates
u_start=(float)(row*FONT_X_SPACING+ignored_bits)/256.0f;
u_end=(float)(row*FONT_X_SPACING+FONT_X_SPACING-7-ignored_bits)/256.0f;
#ifdef NEW_TEXTURES
v_start=(float)(1+col*FONT_Y_SPACING)/256.0f;
v_end=(float)(col*FONT_Y_SPACING+FONT_Y_SPACING-1)/256.0f;
#else
v_start=(float)1.0f-(1+col*FONT_Y_SPACING)/256.0f;
v_end=(float)1.0f-(col*FONT_Y_SPACING+FONT_Y_SPACING-1)/256.0f;
#endif //NEW_TEXTURES
glTexCoord2f(u_start,v_start);
glVertex3f(cur_x,0,cur_y+displayed_font_y_size);
glTexCoord2f(u_start,v_end);
glVertex3f(cur_x,0,cur_y);
glTexCoord2f(u_end,v_end);
glVertex3f(cur_x+displayed_font_x_width,0,cur_y);
glTexCoord2f(u_end,v_start);
glVertex3f(cur_x+displayed_font_x_width,0,cur_y+displayed_font_y_size);
cur_x+=displayed_font_x_width;
}
else if (is_color (cur_char))
{
glBegin(GL_QUADS); //Ooops - NV bug fix!!
}
#else // SKY_FPV_OPTIONAL
while(1){
cur_char=our_string[i];
if(!cur_char){
break;
}else if(cur_char=='\n'){
cur_y+=displayed_font_y_size;
cur_x=hx;
#endif // SKY_FPV_OPTIONAL
i++;
#ifdef SKY_FPV_OPTIONAL
current_lines++;
if(current_lines>=max_lines)break;
continue;
}
else if (is_color (cur_char))
{
glEnd(); //Ooops - NV bug fix!!
glBegin(GL_QUADS);
}
chr=find_font_char(cur_char);
if(chr >= 0){
col=chr/FONT_CHARS_PER_LINE;
row=chr%FONT_CHARS_PER_LINE;
font_bit_width=get_font_width(chr);
displayed_font_x_width=((float)font_bit_width)*displayed_font_x_size/12.0;
ignored_bits=(12-font_bit_width)/2; // how many bits on each side of the char are ignored?
if(ignored_bits < 0)ignored_bits=0;
//now get the texture coordinates
u_start=(float)(row*FONT_X_SPACING+ignored_bits)/256.0f;
u_end=(float)(row*FONT_X_SPACING+FONT_X_SPACING-7-ignored_bits)/256.0f;
#ifdef NEW_TEXTURES
v_start=(float)(1+col*FONT_Y_SPACING)/256.0f;
v_end=(float)(col*FONT_Y_SPACING+FONT_Y_SPACING-1)/256.0f;
#else
v_start=(float)1.0f-(1+col*FONT_Y_SPACING)/256.0f;
v_end=(float)1.0f-(col*FONT_Y_SPACING+FONT_Y_SPACING-1)/256.0f;
#endif // NEW_TEXTURES
glTexCoord2f(u_start,v_start);
glVertex3f(cur_x,cur_y+displayed_font_y_size,0);
glTexCoord2f(u_start,v_end);
glVertex3f(cur_x,cur_y,0);
glTexCoord2f(u_end,v_end);
glVertex3f(cur_x+displayed_font_x_width,cur_y,0);
glTexCoord2f(u_end,v_start);
glVertex3f(cur_x+displayed_font_x_width,cur_y+displayed_font_y_size,0);
cur_x+=displayed_font_x_width;
}
else if (is_color (cur_char))
{
glEnd(); //Ooops - NV bug fix!!
glBegin(GL_QUADS);
#endif // SKY_FPV_OPTIONAL
}
#ifdef SKY_FPV_OPTIONAL
i++;
}
#endif // SKY_FPV_OPTIONAL
glEnd();
glDisable(GL_ALPHA_TEST);
#ifdef SKY_FPV_OPTIONAL
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
#endif // SKY_FPV_OPTIONAL
}
#endif //!MAP_EDITOR_2
#endif //ELC
// font handling
int get_font_width(int cur_char)
{
// ignore unknown characters
if (cur_char < 0) {
return 0;
}
// return width of character + spacing between chars (supports variable width fonts)
return (fonts[cur_font_num]->widths[cur_char] + fonts[cur_font_num]->spacing);
}
int get_char_width(unsigned char cur_char)
{
return get_font_width(get_font_char(cur_char));
}
int get_string_width(const unsigned char *str)
{
return get_nstring_width(str, strlen((char*)str));
}
int get_nstring_width(const unsigned char *str, int len)
{
int i, wdt=0;
for(i=0; i<len; i++) {
wdt+= get_char_width(str[i]);
}
// adjust to ignore the final spacing
wdt-= fonts[cur_font_num]->spacing;
return wdt;
}
ULong ZScreen_Main::ProcessScreen(ZGame * GameEnv )
{
bool Loop;
if( GameEnv->prior_page_up != GameEnv->page_up )
{
GameEnv->prior_page_up = GameEnv->page_up;
GameEnv->GuiManager.RemoveAllFrames();
TitleBackground.SetPosition(0,0);
TitleBackground.SetSize( (float)GameEnv->ScreenResolution.x, (float)GameEnv->ScreenResolution.y );
TitleBackground.SetTexture(0);
TitleBackground.SetZPosition(50.0f);
GameEnv->GuiManager.AddFrame(&TitleBackground);
Title_Size.x = SclX(1000.0f); Title_Size.y = SclY(100.0f);
Title.SetPosition(1-Title_Size.x / 2.0f, GameEnv->ScreenResolution.y / 8.0f );
Title.SetSize(Title_Size.x,Title_Size.y);
Title.SetTexture(1);
Title.SetZPosition(49.0f);
TitleBackground.AddFrame(&Title);
Version_Size.x = SclX(53.0*8.0); Version_Size.y = SclY(8.0);
Frame_Version.SetPosition(GameEnv->ScreenResolution.x - Version_Size.x , GameEnv->ScreenResolution.y - Version_Size.y );
Frame_Version.SetSize(SclX(53.0*8.0+1.0),SclY(100.0));
Frame_Version.SetZPosition(49.0f);
Frame_Version.SetDisplayText((char *)COMPILEOPTION_VERSIONSTRING);
Frame_Version.TextureNum = 3;
Frame_Version.SetStyle(GameEnv->TileSetStyles->GetStyle(0));
TitleBackground.AddFrame(&Frame_Version);
PlayGame_Size.x = SclX(9.0*32.0 + 1.0); PlayGame_Size.y = SclY(32.0);
Frame_PlayGame.SetPosition(GameEnv->ScreenResolution.x / 2.0f - PlayGame_Size.x / 2.0f, GameEnv->ScreenResolution.y / 1.64f - SclY(32.0f) );
Frame_PlayGame.SetSize(PlayGame_Size.x+SclX(128.0f),PlayGame_Size.y);
Frame_PlayGame.SetZPosition(49.0f);
Frame_PlayGame.SetDisplayText((char *)"PLAY GAME");
Frame_PlayGame.TextureNum = 3;
Frame_PlayGame.SetStyle(GameEnv->TileSetStyles->GetStyle(1));
TitleBackground.AddFrame(&Frame_PlayGame);
Frame_Options.SetDisplayText((char *)"OPTIONS");
Frame_Options.SetStyle(GameEnv->TileSetStyles->GetStyle(1));
Frame_Options.GetTextDisplaySize(&Options_Size);
Frame_Options.SetPosition(GameEnv->ScreenResolution.x / 2.0f - Options_Size.x / 2.0f, GameEnv->ScreenResolution.y / 1.64f + SclY(32.0f) );
Frame_Options.SetSize(Options_Size.x+1.0f,Options_Size.y);
Frame_Options.SetZPosition(49.0f);
Frame_Options.TextureNum = 3;
TitleBackground.AddFrame(&Frame_Options);
Frame_Quit.SetDisplayText((char *)"QUIT");
Frame_Quit.SetStyle(GameEnv->TileSetStyles->GetStyle(1));
Frame_Quit.GetTextDisplaySize(&Frame_Size);
Frame_Quit.SetPosition(GameEnv->ScreenResolution.x / 2.0f - Frame_Size.x / 2.0f, GameEnv->ScreenResolution.y / 1.64f + SclY(96.0f) );
Frame_Quit.SetSize(Frame_Size.x+1.0f,Frame_Size.y);
Frame_Quit.SetZPosition(49.0f);
Frame_Quit.TextureNum = 3;
TitleBackground.AddFrame(&Frame_Quit);
//printf("FrameAdress : %lx\n",(unsigned int)&Frame_PlayGame);
}
// for (Loop = true; Loop; )
{
// glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
glAlphaFunc(GL_GREATER, 0.2f);
glEnable(GL_ALPHA_TEST);
glEnable(GL_TEXTURE_2D);
//Loop = GameEnv->EventManager.ProcessEvents();
Loop = true;
ResultCode = CHOICE_NONE;
if (Frame_PlayGame.Is_MouseIn() ) { Frame_PlayGame.SetColor(0.5f,0.5f,1.0f); }
if (Frame_PlayGame.Is_MouseOut()) { Frame_PlayGame.SetColor(1.0f,1.0f,1.0f); }
if (Frame_Options.Is_MouseIn() ) { Frame_Options.SetColor(0.5f,0.5f,1.0f); }
if (Frame_Options.Is_MouseOut()) { Frame_Options.SetColor(1.0f,1.0f,1.0f); }
if (Frame_Quit.Is_MouseIn() ) { Frame_Quit.SetColor(0.5f,0.5f,1.0f); }
if (Frame_Quit.Is_MouseOut()) { Frame_Quit.SetColor(1.0f,1.0f,1.0f); }
if (Frame_PlayGame.Is_MouseClick()) {Loop = false; ResultCode = CHOICE_PLAYGAME; }
if (Frame_Options.Is_MouseClick()) {Loop = false; ResultCode = CHOICE_OPTIONS; }
if (Frame_Quit.Is_MouseClick()) {Loop = false; ResultCode = CHOICE_QUIT; }
//GameEnv->GuiManager.Render();
/*
//SDL_GL_SwapBuffers( );
SDL_GL_SwapWindow(GameEnv->screen);
SDL_Delay(10);
*/
}
//if( !GameEnv->Menu_Up )
// GameEnv->GuiManager.RemoveAllFrames();
return(ResultCode);
}
void GL_RenderPolyWithShader(gl_poly_t *poly, FShader *shader)
{
unsigned int i, numLayers;
FShaderLayer *layer;
FTexture *tex;
float scaleX, scaleY;
GL_BindArrays(poly);
GL_SetupFog(poly->lightLevel, poly->fogR, poly->fogG, poly->fogB);
// non-masked, so disable transparency
if (!DrawingDeferredLines && poly->a == 1.f)
{
glDisable(GL_BLEND);
}
numLayers = shader->layers.Size();
for (i = 0; i < numLayers; i++)
{
layer = shader->layers[i];
tex = TexMan[layer->name];
scaleX = TexMan[shader->name]->GetWidth() * 1.f / TexMan[layer->name]->GetWidth();
scaleY = TexMan[shader->name]->GetHeight() * 1.f / TexMan[layer->name]->GetHeight();
scaleX = scaleX * poly->scaleX * layer->scaleX;
scaleY = scaleY * poly->scaleY * layer->scaleY;
glMatrixMode(GL_TEXTURE);
glLoadIdentity();
glScalef(scaleX, scaleY, 1.f);
glTranslatef(layer->offsetX + poly->offX, layer->offsetY + poly->offY, 0.f);
// layer rotations happen around the center of the sector
glTranslatef(-poly->rotationX + layer->centerX, -poly->rotationY + layer->centerY, 0.f);
glRotatef(layer->rotation, 0.f, 0.f, 1.f);
glTranslatef(poly->rotationX - layer->centerX, poly->rotationY - layer->centerY, 0.f);
glRotatef(poly->rot, 0.f, 0.f, 1.f);
glMatrixMode(GL_MODELVIEW);
textureList.BindTexture(TexMan[layer->name]);
glBlendFunc(layer->blendFuncSrc, layer->blendFuncDst);
// don't use fog on additive layers if not the first layer
if (i && layer->blendFuncDst == GL_ONE)
{
glDisable(GL_FOG);
}
switch (layer->texGen)
{
case SHADER_TexGen_Sphere:
glEnable(GL_TEXTURE_GEN_S);
glEnable(GL_TEXTURE_GEN_T);
break;
default:
glDisable(GL_TEXTURE_GEN_S);
glDisable(GL_TEXTURE_GEN_T);
break;
}
glColor4f(poly->r * layer->r.GetVal(), poly->g * layer->g.GetVal(), poly->b * layer->b.GetVal(), poly->a * layer->alpha.GetVal());
glDrawArrays(GL_TRIANGLE_FAN, 0, poly->numPts);
if (!i) // this only happens on the first pass
{
glDepthFunc(GL_EQUAL); // only draw if it matches up with first layer
glDepthMask(GL_FALSE); // z values already written!
glAlphaFunc(GL_GREATER, 0.f); // always draw the whole layer (masking is handled on the first pass)
glEnable(GL_BLEND);
}
if (gl_depthfog && !Player->fixedcolormap)
{
glEnable(GL_FOG);
}
}
glMatrixMode(GL_TEXTURE);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDisable(GL_TEXTURE_GEN_S);
glDisable(GL_TEXTURE_GEN_T);
glDepthFunc(GL_LEQUAL);
glDepthMask(GL_TRUE);
GL_UnbindArrays(poly);
}
void glAlphaFuncLogged(GLenum func, GLclampf ref) {
printf("glAlphaFunc(%s, %.2f)\n", GLEnumName(func), ref);
glAlphaFunc(func, ref);
}
void GL_RenderPoly(gl_poly_t *poly)
{
FAnimDef *anim = NULL;
// float alpha;
// unsigned short tex1, tex2, curFrame;
if (!poly->initialized) return;
GL_BindArrays(poly);
if (MaskSkybox)
{
glColor4f(1.f, 1.f, 1.f, 1.f);
textureList.BindGLTexture(0);
glDrawArrays(GL_TRIANGLE_FAN, 0, poly->numPts);
}
else
{
GL_SetupFog(poly->lightLevel, poly->fogR, poly->fogG, poly->fogB);
// non-masked, so disable transparency
if (!DrawingDeferredLines && poly->a == 1.f)
{
glDisable(GL_BLEND);
}
if (poly->doomTex > 0)
{
if (gl_blend_animations && gl_texture && !gl_wireframe && !textureList.IsTransparent())
{
anim = GL_GetAnimForLump(poly->doomTex);
}
}
else
{
return;
}
glMatrixMode(GL_TEXTURE);
glLoadIdentity();
glScalef(poly->scaleX, poly->scaleY, 1.f);
glTranslatef(poly->offX, poly->offY, 0.f);
glRotatef(poly->rot, 0.f, 0.f, 1.f);
glMatrixMode(GL_MODELVIEW);
glColor4f(poly->r, poly->g, poly->b, poly->a);
glDrawArrays(GL_TRIANGLE_FAN, 0, poly->numPts);
glEnable(GL_BLEND);
glMatrixMode(GL_TEXTURE);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
}
numTris += poly->numPts - 2;
if (r_fogboundary && poly->isFogBoundary)
{
#if 0
// draw poly again with depth-dependent alpha edges
// note that fog boundaries are always walls, so they're always quads
float a1, a2;
fixed_t x, y, dist;
int i;
glDisable(GL_TEXTURE_2D);
glAlphaFunc(GL_GREATER, 0.f);
x = (fixed_t)(-poly->vertices[3] * MAP_SCALE);
y = (fixed_t)(poly->vertices[5] * MAP_SCALE);
dist = R_PointToDist2(x, y);
a1 = dist / 384.f * INV_FRACUNIT;
x = (fixed_t)(-poly->vertices[6] * MAP_SCALE);
y = (fixed_t)(poly->vertices[8] * MAP_SCALE);
dist = R_PointToDist2(x, y);
a2 = dist / 384.f * INV_FRACUNIT;
a1 *= 0.75f * byte2float[poly->fbLightLevel];
a2 *= 0.75f * byte2float[poly->fbLightLevel];
//a1 = 0.f;
//a2 = 1.f;
glColor4f(byte2float[poly->fbR] * byte2float[poly->fbLightLevel], byte2float[poly->fbG] * byte2float[poly->fbLightLevel], byte2float[poly->fbB] * byte2float[poly->fbLightLevel], a1 * a1);
glBegin(GL_TRIANGLE_FAN);
for (i = 0; i < poly->numPts; i++)
{
if (i == poly->numPts / 2)
{
glColor4f(byte2float[poly->fbR] * byte2float[poly->fbLightLevel], byte2float[poly->fbG] * byte2float[poly->fbLightLevel], byte2float[poly->fbB] * byte2float[poly->fbLightLevel], a2 * a2);
}
glVertex3fv(&poly->vertices[i * 3]);
}
glEnd();
glEnable(GL_TEXTURE_2D);
#endif
}
// all this really does is potentially unlocks the vertex arrays
GL_UnbindArrays(poly);
}
void GLVideo::UpdateScreen (DCanvas *canvas)
{
if(palettechanged)
{
extern void UpdateShaderPalette(SDL_Color *colors);
UpdateShaderPalette(newPalette);
palettechanged = false;
}
SDL_GL_SwapBuffers();
// viewheight or viewwidth not the same as screen?
if(screenw != realviewheight || screenh != realviewheight)
glViewport(viewwindowx, screenh - (realviewheight + viewwindowy), realviewwidth, realviewheight);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
// make textures transparent where they are black?
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_ALPHA_TEST);
glAlphaFunc(GL_GREATER, 0);
// Switch to 3D
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
float aspect = (float)realviewwidth/realviewheight;
float fov = 70.0;
gluPerspective(fov, aspect, 0.08f, 100.0f);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
// Render doom level
if(gamestate == GS_LEVEL && !automapactive)
RenderWorld();
// Switch to 2D
glDisable(GL_DEPTH_TEST);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0.0f, 1, 1, 0.0f, -1.0f, 1.0f);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
if(gamestate == GS_LEVEL && !automapactive)
{
// Draw player weapon
DrawScreenSprites();
// Draw crosshair
DrawCrosshair();
}
// Render menu/console/automap over whole screen
if(screenw != realviewwidth || screenh != realviewheight)
{
glViewport(0, 0, screenw, screenh);
}
// Draw automap
if(automapactive)
RenderAutomap();
// Render view border
extern void R_DrawViewBorder();
R_DrawViewBorder();
// Draw status bar
if(gamestate == GS_LEVEL)
if(screenw != realviewwidth || screenh != realviewheight)
{
glColor4f(0,1,0,1);
glDisable(GL_TEXTURE_2D);
extern int ST_X, ST_Y, ST_WIDTH, ST_HEIGHT;
DrawQuad((float)ST_X/screenw, (float)ST_Y/screenh, (float)ST_WIDTH/screenw, (float)ST_HEIGHT/screenh);
}
// Draw status bar border
// Draw player redscreen, berserk, pickup
// DrawTint();
// Render the grayscale+colormap result to a texture
extern void RenderToTexture(size_t screenw, size_t screenh);
RenderToTexture(screenw, screenh);
// Shader will convert this into RGB output
extern void RenderedTextureToScreen(size_t screenw, size_t screenh);
RenderedTextureToScreen(screenw, screenh);
// Console
DrawConsole(screenw, screenh);
// Menu
DrawMenu();
}
void EmisorParticulas::render()
{
if(particulas.size() > 0 )
{
Camera* camera = World::getInstance()->currentCamera;
top = camera->getLocalVector(Vector3(0,1,0));
right = camera->getLocalVector(Vector3(1,0,0));
std::sort( particulas.begin(), particulas.end(), isCloserToCamera );
for(std::map<std::string, int>::iterator it = textures.begin(); it != textures.end(); ++it)
{
glPushMatrix();
Mesh* plane = new Mesh();
plane->vertices.reserve((it)->second*4*numParticulasPorFuente); // numParticulasPorFuente pq cada particula ha de tenir numParticulasPorFuente fills
plane->uvs.reserve((it)->second*4*numParticulasPorFuente);
int indexOfTexture = 0;
for(int i = 0; i<particulas.size(); ++i)
{
/*if(particulas[i]->texture->filename == ((*it).first))
{
Particula* particula = particulas[i];
Vector3 pos = particula->pos;
plane->vertices.push_back(pos + (top*particula->size) - (right*particula->size) );
plane->vertices.push_back(pos + (top*particula->size)*-1 - (right*particula->size) );
plane->vertices.push_back(pos + (top*particula->size)*-1 + (right*particula->size) );
plane->vertices.push_back(pos + (top*particula->size) + (right*particula->size) );
plane->uvs.push_back( Vector2(0,1) );
plane->uvs.push_back( Vector2(0,0) );
plane->uvs.push_back( Vector2(1,0) );
plane->uvs.push_back( Vector2(1,1) );
indexOfTexture = i;
}*/
if(particulas[i]->texture->filename == ((*it).first))
{
for(std::vector<Particula*>::iterator itSurtidor = particulas[i]->surtidor.begin(); itSurtidor != particulas[i]->surtidor.end(); ++itSurtidor)
{
Particula* particula = (*itSurtidor);
Vector3 pos = particula->pos;
plane->vertices.push_back(pos + (top*particula->size) - (right*particula->size) );
plane->vertices.push_back(pos + (top*particula->size)*-1 - (right*particula->size) );
plane->vertices.push_back(pos + (top*particula->size)*-1 + (right*particula->size) );
plane->vertices.push_back(pos + (top*particula->size) + (right*particula->size) );
plane->uvs.push_back( Vector2(0,1) );
plane->uvs.push_back( Vector2(0,0) );
plane->uvs.push_back( Vector2(1,0) );
plane->uvs.push_back( Vector2(1,1) );
indexOfTexture = i;
}
}
}
plane->primitive = GL_QUADS;
glPushAttrib( GL_ALL_ATTRIB_BITS );
glAlphaFunc( GL_GREATER, particulas[indexOfTexture]/*->surtidor[0]*/->alpha);
glEnable( GL_ALPHA_TEST );
glEnable(GL_BLEND);
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
particulas[indexOfTexture]->texture->bind();
glColor3f(0.19,0.19,0.19);
plane->render();
particulas[indexOfTexture]->texture->unbind();
glPopAttrib();
glPopMatrix();
}
}
}
/*
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!1
만약에 Render했는데 화면에 안나온다!!! 그러면!
static VECTOR4 vConst( 1.0f, 1.0f, 1.0f, 100.0f );
m_pd3dDevice->SetVertexShaderConstantF( 95, (float*)&vConst, 1 );
SetTransformView( matView );
SetTransformProj( matProj );
SetDiffuse( 1.0, 1.0, 1.0 );
SetAmbient( 1.0, 1.0, 1.0 );
이걸 렌더 하기전에 불러줬는지 확인해라!!!!!!!!!!!!!!!!!!!!! 크아아악!
좆도 고생했네!
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!1
*/
BOOL CModelObject::Render( const MATRIX *mWorld )
{
CObject3D *pObject3D;
O3D_ELEMENT *pElem;
int i;
int nNextFrame;
MATRIX m1;
#ifdef _DEBUG
if( m_nLoop == 0 )
XERROR( "경고 : %s : CModelObject::m_nLoop가 지정되지 않았다.", m_pMotion->m_szName );
#endif
if( m_pMotion ) // m_pMotion이 널이라면 m_mUpdateBone도 널이다.
m_pMotion->AnimateBone( m_mUpdateBone, m_pMotionOld, m_fFrameCurrent, GetNextFrame(), m_nFrameOld, m_bMotionBlending, m_fBlendWeight ); // 일단 뼈대가 있다면 뼈대 애니메이션 시킴
// AnimateBone( NULL ); // 일단 뼈대가 있다면 뼈대 애니메이션 시킴
if( m_pBone ) // m_pBone이 있다면 뼈대가 있다는 얘기. VS를 써야 한다.
{
MATRIX *pmBones;
MATRIX m1;
MATRIX *pmBonesInv = m_pBaseBoneInv ;
pmBones = m_mUpdateBone;
if( m_pBone->m_bSendVS ) // 뼈대개수가 MAX_VS_BONE이하라서 한번에 다 전송한다.
{
int nMaxBone = m_pBone->m_nMaxBone;
const MATRIX *pmView = GetTransformView();
#ifdef __XDEBUG
if( nMaxBone > MAX_VS_BONE )
XERROR( "CModelObject::Render : 뼈대개수가 최대치를 초과했다. %d", nMaxBone );
#endif
for( i = 0; i < nMaxBone; i ++ ) // MAX_VS_BONE개 이하
{
MatrixMultiply( m1, pmBonesInv[i], pmBones[i] );
glCurrentPaletteMatrixOES( i );
MatrixMultiply( m1, m1, *mWorld );
MatrixMultiply( m1, m1, *pmView );
glLoadMatrixf( m1.f );
}
}
/*
MATRIX mView, mProj;
MATRIX mViewProj, mViewProjTranspose, mInvWorld;
VECTOR4 vLight = s_vLight;
VECTOR4 vLightPos = s_vLightPos;
mViewProj = *mWorld * s_mView * s_mProj;
MATRIXTranspose( &mViewProjTranspose, &mViewProj );
MATRIXTranspose( &mWorldTranspose, mWorld );
MATRIXInverse( &mInvWorld, NULL, mWorld );
Vec4Transform( &vLight, &vLight, &mInvWorld );
Vec4Normalize( &vLight, &vLight );
Vec4Transform( &vLightPos, &vLightPos, &mInvWorld );
// Vec4Transform( &vEyePos, &vEyePos, &mInvWorld );
m_pd3dDevice->SetVertexShaderConstantF( 84, (float*)&mViewProjTranspose, 4 );
// m_pd3dDevice->SetVertexShaderConstantF( 88, (float*)&mWorldTranspose, 4 );
// m_pd3dDevice->SetVertexShaderConstantF( 88, (float*)&vEyePos, 1 ); // specular use
// m_pd3dDevice->SetVertexShaderConstantF( 89, (float*)&fSpecular, 1 ); // specular use
// m_pd3dDevice->SetVertexShaderConstantF( 90, (float*)&fLightCol, 1 ); // specular use
m_pd3dDevice->SetVertexShaderConstantF( 91, (float*)&vLightPos, 1 );
m_pd3dDevice->SetVertexShaderConstantF( 92, (float*)&vLight, 1 );
m_pd3dDevice->SetVertexShaderConstantF( 93, (float*)&s_fDiffuse, 1 );
m_pd3dDevice->SetVertexShaderConstantF( 94, (float*)&s_fAmbient, 1 );
// m_pd3dDevice->SetVertexShaderConstant( 95, &vConst, 1 );
*/
}
/*
*/
if( m_nNoEffect == 0 )
{
// 기본 설정
// pd3dDevice->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
// pd3dDevice->SetTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE );
// pd3dDevice->SetTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
// pd3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_DISABLE );
glAlphaFunc( GL_GEQUAL, 0 );
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
// pd3dDevice->SetRenderState( D3DRS_ALPHAFUNC, D3DCMP_GREATEREQUAL );
// pd3dDevice->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA );
// pd3dDevice->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA );
}
DWORD dwBlendFactor = m_dwColor | ( m_dwBlendFactor << 24 );
//DWORD dwBlendFactor = 0xffff0000 ;//| ( m_dwBlendFactor << 24 );
// 오브젝트의 반투명 효과 세팅
if( m_dwBlendFactor < 255 || m_dwColor )
{
const GLfloat fAmbient[] = { 0, 0, 0, 1.0f };
const GLfloat fDiffuse[] = { 1.0f, 1.0f, 1.0f, (float)((dwBlendFactor>>24)&0xff)/255.0f };
glMaterialfv( GL_FRONT_AND_BACK, GL_AMBIENT, fAmbient );
glMaterialfv( GL_FRONT_AND_BACK, GL_DIFFUSE, fDiffuse );
glEnable( GL_BLEND );
glEnable( GL_ALPHA_TEST );
} else
{
void applyShaderStage(Q3ShaderStage* shaderStage, int faceIndex)
{
if(shaderStage->alphaEnabled)
{
glEnable(GL_ALPHA_TEST);
glAlphaFunc(shaderStage->alphaFunc, 0.5f);
}
else
glDisable(GL_ALPHA_TEST);
glDepthFunc(shaderStage->depthFunc);
//
// if(shaderStage->srcBlend == -1 || shaderStage->destBlend == -1)
// {
// glDisable(GL_BLEND);
// }
if(shaderStage->srcBlend == GL_ONE && shaderStage->destBlend == GL_ZERO)
{
glDisable(GL_BLEND);//
}
else
{
glBlendFunc(shaderStage->srcBlend, shaderStage->destBlend);
glEnable(GL_BLEND);
}
if(shaderStage->textureName == "$lightmap")
{
unsigned int texture;
if(faceIndex == -1)
{
unsigned char* data = new unsigned char[128*128*4];
memset(data, 255, 128*128*4);
texture = textureFactory->buildLightMap(data);
}
else
texture = qmap->pLightMap[qmap->pFace[faceIndex].lm_index].textureId;
textureFactory->applyTexture(texture, 0);
}
else
{
if(shaderStage->animMapTextureIds.size() == 0)
{
textureFactory->applyTexture(shaderStage->textureId, 0);
}
else
{
if(((float)renderTime - shaderStage->lastAnimFrameTime) / 1000 > (1 / shaderStage->animFrequency))
{
shaderStage->lastAnimFrame++;
if(shaderStage->lastAnimFrame >= shaderStage->animMapTextureIds.size())
shaderStage->lastAnimFrame = 0;
shaderStage->lastAnimFrameTime = renderTime;
}
textureFactory->applyTexture(shaderStage->animMapTextureIds.at(shaderStage->lastAnimFrame), 0);
}
}
}
void CProjectileDrawer::Draw(bool drawReflection, bool drawRefraction) {
glDisable(GL_BLEND);
glEnable(GL_TEXTURE_2D);
glDepthMask(GL_TRUE);
ISky::SetupFog();
{
GML_STDMUTEX_LOCK(rpiece); // Draw
ph->flyingPieces3DO.delete_delayed();
ph->flyingPieces3DO.add_delayed();
ph->flyingPiecesS3O.delete_delayed();
ph->flyingPiecesS3O.add_delayed();
}
zSortedProjectiles.clear();
int numFlyingPieces = ph->flyingPieces3DO.render_size() + ph->flyingPiecesS3O.render_size();
int drawnPieces = 0;
Update();
{
GML_RECMUTEX_LOCK(proj); // Draw
unitDrawer->SetupForUnitDrawing();
for (int modelType = MODELTYPE_3DO; modelType < MODELTYPE_OTHER; modelType++) {
modelRenderers[modelType]->PushRenderState();
DrawProjectiles(modelType, numFlyingPieces, &drawnPieces, drawReflection, drawRefraction);
modelRenderers[modelType]->PopRenderState();
}
unitDrawer->CleanUpUnitDrawing();
// z-sort the model-less projectiles
DrawProjectilesSet(renderProjectiles, drawReflection, drawRefraction);
ph->currentParticles = 0;
CProjectile::inArray = false;
CProjectile::va = GetVertexArray();
CProjectile::va->Initialize();
// draw the particle effects
for (std::set<CProjectile*, distcmp>::iterator it = zSortedProjectiles.begin(); it != zSortedProjectiles.end(); ++it) {
(*it)->Draw();
}
}
glEnable(GL_BLEND);
glDisable(GL_FOG);
if (CProjectile::inArray) {
// Alpha transculent particles
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_TEXTURE_2D);
textureAtlas->BindTexture();
glColor4f(1.0f, 1.0f, 1.0f, 0.2f);
glAlphaFunc(GL_GREATER, 0.0f);
glEnable(GL_ALPHA_TEST);
glDepthMask(GL_FALSE);
// note: nano-particles (CGfxProjectile instances) also
// contribute to the count, but have their own creation
// cutoff
ph->currentParticles += CProjectile::DrawArray();
}
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDisable(GL_ALPHA_TEST);
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
glDepthMask(GL_TRUE);
ph->currentParticles = int(ph->currentParticles * 0.2f);
ph->currentParticles += int(0.2f * drawnPieces + 0.3f * numFlyingPieces);
ph->currentParticles += (renderProjectiles.size() * 0.8f);
// NOTE: should projectiles that have a model be counted here?
for (int modelType = MODELTYPE_3DO; modelType < MODELTYPE_OTHER; modelType++) {
ph->currentParticles += (modelRenderers[modelType]->GetNumProjectiles() * 0.8f);
}
ph->UpdateParticleSaturation();
}
void SetExtGLFuncs(void)
{
//----------------------------------------------------//
SetFixes(); // update fix infos
//----------------------------------------------------//
#ifdef _WINDOWS
if((iForceVSync>=0) && // force vsync?
strstr((char *)glGetString(GL_EXTENSIONS), // and extension available?
"WGL_EXT_swap_control"))
{
PFNWGLSWAPINTERVALFARPROC wglSwapIntervalEXT=
(PFNWGLSWAPINTERVALFARPROC)wglGetProcAddress("wglSwapIntervalEXT");
if(wglSwapIntervalEXT) wglSwapIntervalEXT(iForceVSync);
}
#endif
#ifdef _MACGL
SetVSync(iForceVSync);
#endif
if(iUseExts && !(dwActFixes&1024) && // extensions wanted? and not turned off by game fix?
strstr((char *)glGetString(GL_EXTENSIONS), // and blend_subtract available?
"GL_EXT_blend_subtract"))
{ // -> get ogl blend function pointer
#ifdef _WINDOWS
glBlendEquationEXTEx=(PFNGLBLENDEQU)wglGetProcAddress("glBlendEquationEXT");
#elif defined(_MACGL)
// no prob, OSX > 10.4.3 has this
#else
glBlendEquationEXTEx=(PFNGLBLENDEQU)glXGetProcAddress("glBlendEquationEXT");
#endif
}
else // no subtract blending?
{
if(glBlendEquationEXTEx) // -> change to additive blending (if subract was active)
glBlendEquationEXTEx(FUNC_ADD_EXT);
#if !defined(_MACGL) // BTW, why set to null? strange...
glBlendEquationEXTEx=(PFNGLBLENDEQU)NULL; // -> no more blend function pointer
#endif
}
//----------------------------------------------------//
if(iUseExts && bAdvancedBlend && // advanced blending wanted ?
strstr((char *)glGetString(GL_EXTENSIONS), // and extension avail?
"GL_EXT_texture_env_combine"))
{
bUseMultiPass=FALSE;bGLBlend=TRUE; // -> no need for 2 passes, perfect
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, COMBINE_EXT);
glTexEnvf(GL_TEXTURE_ENV, COMBINE_RGB_EXT, GL_MODULATE);
glTexEnvf(GL_TEXTURE_ENV, COMBINE_ALPHA_EXT, GL_MODULATE);
glTexEnvf(GL_TEXTURE_ENV, RGB_SCALE_EXT, 2.0f);
}
else // no advanced blending wanted/available:
{
if(bAdvancedBlend) bUseMultiPass=TRUE; // -> pseudo-advanced with 2 passes
else bUseMultiPass=FALSE; // -> or simple 'bright color' mode
bGLBlend=FALSE; // -> no ext blending!
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
}
//----------------------------------------------------//
// init standard tex quality 0-2, and big alpha mode 3
if(!(dwActFixes&0x4000) && iFilterType && iTexQuality>=3)
bSmallAlpha=TRUE;
else bSmallAlpha=FALSE;
if(bOpaquePass) // opaque mode?
{
if(dwActFixes&32)
{
TCF[0]=CP8RGBA_0;
PalTexturedColourFn=CP8RGBA; // -> init col func
}
else
{
TCF[0]=XP8RGBA_0;
PalTexturedColourFn=XP8RGBA; // -> init col func
}
TCF[1]=XP8RGBA_1;
glAlphaFunc(GL_GREATER,0.49f);
}
else // no opaque mode?
{
TCF[0]=TCF[1]=P8RGBA;
PalTexturedColourFn=P8RGBA; // -> init col func
glAlphaFunc(GL_NOTEQUAL,0); // --> set alpha func
}
//----------------------------------------------------//
LoadSubTexFn=LoadSubTexturePageSort; // init load tex ptr
giWantedFMT=GL_RGBA; // init ogl tex format
switch(iTexQuality) // -> quality:
{
//--------------------------------------------------//
case 0: // -> don't care
giWantedRGBA=4;
giWantedTYPE=GL_UNSIGNED_BYTE;
break;
//--------------------------------------------------//
case 1: // -> R4G4B4A4
if(bGLExt)
{
giWantedRGBA=GL_RGBA4;
giWantedTYPE=GL_UNSIGNED_SHORT_4_4_4_4_EXT;
LoadSubTexFn=LoadPackedSubTexturePageSort;
if(bOpaquePass)
{
if(dwActFixes&32) PTCF[0]=CP4RGBA_0;
else PTCF[0]=XP4RGBA_0;
PTCF[1]=XP4RGBA_1;
}
else
{
PTCF[0]=PTCF[1]=P4RGBA;
}
}
else
{
giWantedRGBA=GL_RGBA4;
giWantedTYPE=GL_UNSIGNED_BYTE;
}
break;
//--------------------------------------------------//
case 2: // -> R5B5G5A1
if(bGLExt)
{
giWantedRGBA=GL_RGB5_A1;
giWantedTYPE=GL_UNSIGNED_SHORT_5_5_5_1_EXT;
LoadSubTexFn=LoadPackedSubTexturePageSort;
if(bOpaquePass)
{
if(dwActFixes&32) PTCF[0]=CP5RGBA_0;
else PTCF[0]=XP5RGBA_0;
PTCF[1]=XP5RGBA_1;
}
else
{
PTCF[0]=PTCF[1]=P5RGBA;
}
}
else
{
giWantedRGBA=GL_RGB5_A1;giWantedTYPE=GL_UNSIGNED_BYTE;
}
break;
//--------------------------------------------------//
case 3: // -> R8G8B8A8
giWantedRGBA=GL_RGBA8;
giWantedTYPE=GL_UNSIGNED_BYTE;
if(bSmallAlpha)
{
if(bOpaquePass) // opaque mode?
{
if(dwActFixes&32) {TCF[0]=CP8RGBAEx_0;PalTexturedColourFn=CP8RGBAEx;}
else {TCF[0]=XP8RGBAEx_0;PalTexturedColourFn=XP8RGBAEx;}
TCF[1]=XP8RGBAEx_1;
}
}
break;
//--------------------------------------------------//
case 4: // -> R8G8B8A8
giWantedRGBA = GL_RGBA8;
giWantedTYPE = GL_UNSIGNED_BYTE;
if(strstr((char *)glGetString(GL_EXTENSIONS), // and extension avail?
"GL_EXT_bgra"))
{
giWantedFMT = GL_BGRA_EXT;
if(bOpaquePass) // opaque mode?
{
if(bSmallAlpha)
{
if(dwActFixes&32) {TCF[0]=CP8BGRAEx_0;PalTexturedColourFn=CP8RGBAEx;}
else {TCF[0]=XP8BGRAEx_0;PalTexturedColourFn=XP8RGBAEx;}
TCF[1]=XP8BGRAEx_1;
}
else
{
if(dwActFixes&32) {TCF[0]=CP8BGRA_0;PalTexturedColourFn=CP8RGBA;}
else {TCF[0]=XP8BGRA_0;PalTexturedColourFn=XP8RGBA;}
TCF[1]=XP8BGRA_1;
}
}
else // no opaque mode?
{
TCF[0]=TCF[1]=P8BGRA; // -> init col func
}
}
else
{
iTexQuality=3;
if(bSmallAlpha)
{
if(bOpaquePass) // opaque mode?
{
if(dwActFixes&32) {TCF[0]=CP8RGBAEx_0;PalTexturedColourFn=CP8RGBAEx;}
else {TCF[0]=XP8RGBAEx_0;PalTexturedColourFn=XP8RGBAEx;}
TCF[1]=XP8RGBAEx_1;
}
}
}
break;
//--------------------------------------------------//
}
bBlendEnable=FALSE; // init blending: off
glDisable(GL_BLEND);
SetScanTrans(); // init scan lines (if wanted)
}
