示例#1
0
void GLVideo::GL_Test()
{
	static bool once = false;

	if(!once)
	{
		once=true;

		// Niceness
		glClearColor(0.0f,0.0f,0.0f,0.0f);
		glClearDepth(1.0f);
		glDepthFunc(GL_LEQUAL);
		glEnable(GL_DEPTH_TEST);
		glEnable(GL_STENCIL_TEST);
		glShadeModel(GL_SMOOTH);
		glDisable(GL_CULL_FACE);
		glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
	}

	Printf(PRINT_HIGH, "GL_VERSION: %s\n", glGetString(GL_VERSION));
	Printf(PRINT_HIGH, "GL_RENDERER: %s\n", glGetString(GL_RENDERER));
//	Printf(PRINT_HIGH, "GL_EXTENSIONS: %s\n", glGetString(GL_EXTENSIONS));

	extern void EnableShader();
	EnableShader();
}
示例#2
0
void CGrassDrawer::SetupGlStateFar()
{
	assert(globalRendering->haveGLSL);

	//glEnable(GL_ALPHA_TEST);
	//glAlphaFunc(GL_GREATER, 0.01f);
	glEnable(GL_BLEND);
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
	glDepthMask(GL_FALSE);

	glMatrixMode(GL_PROJECTION);
		glPushMatrix();
		glMultMatrixf(camera->GetViewMatrix());
	glMatrixMode(GL_MODELVIEW);
		glPushMatrix();
		glLoadIdentity();

	EnableShader(GRASS_PROGRAM_DIST);

	glActiveTextureARB(GL_TEXTURE0_ARB);
		glBindTexture(GL_TEXTURE_2D, farTex);
	glActiveTextureARB(GL_TEXTURE1_ARB);
		glBindTexture(GL_TEXTURE_2D, readMap->GetGrassShadingTexture());
	glActiveTextureARB(GL_TEXTURE2_ARB);
		glBindTexture(GL_TEXTURE_2D, readMap->GetShadingTexture());
	glActiveTextureARB(GL_TEXTURE3_ARB);
		glBindTexture(GL_TEXTURE_2D, infoTextureHandler->GetCurrentInfoTexture());

	if (shadowHandler->ShadowsLoaded())
		shadowHandler->SetupShadowTexSampler(GL_TEXTURE4);

	glActiveTextureARB(GL_TEXTURE0_ARB);
}
示例#3
0
void CScreensaverCyclone::DrawEntry(int primitive, const sLight* data, unsigned int size)
{
  m_modelProjMat = m_projMat * m_modelMat;
  EnableShader();
  glBufferData(GL_ARRAY_BUFFER, sizeof(sLight)*size, data, GL_DYNAMIC_DRAW);
  glDrawArrays(primitive, 0, size);
  DisableShader();
}
示例#4
0
void CScreensaverCyclone::DrawSphere(const sColor& color)
{
  m_uniformColor = color;
  m_normalMat = glm::transpose(glm::inverse(glm::mat3(m_modelMat)));
  m_modelProjMat = m_projMat * m_modelMat;
  EnableShader();
  glBufferData(GL_ARRAY_BUFFER, sizeof(sLight)*m_sphereTriangleFan1.size(), &m_sphereTriangleFan1[0], GL_DYNAMIC_DRAW);
  glDrawArrays(GL_TRIANGLE_FAN, 0, m_sphereTriangleFan1.size());
  glBufferData(GL_ARRAY_BUFFER, sizeof(sLight)*m_sphereTriangleFan2.size(), &m_sphereTriangleFan2[0], GL_DYNAMIC_DRAW);
  glDrawArrays(GL_TRIANGLE_FAN, 0, m_sphereTriangleFan2.size());
  DisableShader();
}
示例#5
0
void CGrassDrawer::SetupGlStateFar()
{
	assert(globalRendering->haveGLSL);

	CBaseGroundDrawer* gd = readMap->GetGroundDrawer();

	//glEnable(GL_ALPHA_TEST);
	//glAlphaFunc(GL_GREATER, 0.01f);
	glEnable(GL_BLEND);
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
	glDepthMask(GL_FALSE);

	glMatrixMode(GL_PROJECTION);
		glPushMatrix();
		glMultMatrixf(camera->GetViewMatrix());
	glMatrixMode(GL_MODELVIEW);
		glPushMatrix();
		glLoadIdentity();

	EnableShader(GRASS_PROGRAM_DIST);

	glActiveTextureARB(GL_TEXTURE0_ARB);
		glBindTexture(GL_TEXTURE_2D, farTex);
	glActiveTextureARB(GL_TEXTURE1_ARB);
		glBindTexture(GL_TEXTURE_2D, readMap->GetGrassShadingTexture());
	glActiveTextureARB(GL_TEXTURE2_ARB);
		glBindTexture(GL_TEXTURE_2D, readMap->GetShadingTexture());
	if (gd->DrawExtraTex()) {
		glActiveTextureARB(GL_TEXTURE3_ARB);
			glBindTexture(GL_TEXTURE_2D, gd->GetActiveInfoTexture());
	}
	if (shadowHandler->shadowsLoaded) {
		glActiveTextureARB(GL_TEXTURE4_ARB);
			glBindTexture(GL_TEXTURE_2D, shadowHandler->shadowTexture);
			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE_ARB, GL_COMPARE_R_TO_TEXTURE);
			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC_ARB, GL_LEQUAL);
			glTexParameteri(GL_TEXTURE_2D, GL_DEPTH_TEXTURE_MODE_ARB, GL_ALPHA);
	}

	glActiveTextureARB(GL_TEXTURE0_ARB);
}
示例#6
0
void CGrassDrawer::SetupGlStateNear()
{
	// bind textures
	{
		glActiveTextureARB(GL_TEXTURE0_ARB);
			glBindTexture(GL_TEXTURE_2D, grassBladeTex);
		glActiveTextureARB(GL_TEXTURE1_ARB);
			glBindTexture(GL_TEXTURE_2D, readMap->GetGrassShadingTexture());
		glActiveTextureARB(GL_TEXTURE2_ARB);
			glBindTexture(GL_TEXTURE_2D, readMap->GetShadingTexture());
		glActiveTextureARB(GL_TEXTURE3_ARB);
			glBindTexture(GL_TEXTURE_2D, infoTextureHandler->GetCurrentInfoTexture());
		glActiveTextureARB(GL_TEXTURE5_ARB);
			glBindTexture(GL_TEXTURE_CUBE_MAP_ARB, cubeMapHandler->GetSpecularTextureID());
	}

	// bind shader
	if (globalRendering->haveGLSL) {
		EnableShader(GRASS_PROGRAM_NEAR);

		if (shadowHandler->shadowsLoaded) {
			glActiveTextureARB(GL_TEXTURE4_ARB);
				glBindTexture(GL_TEXTURE_2D, shadowHandler->shadowTexture);
				glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE_ARB, GL_COMPARE_R_TO_TEXTURE);
				glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC_ARB, GL_LEQUAL);
				glTexParameteri(GL_TEXTURE_2D, GL_DEPTH_TEXTURE_MODE_ARB, GL_ALPHA);
		}

		glMatrixMode(GL_PROJECTION);
			glPushMatrix();
			glMultMatrixf(camera->GetViewMatrix());
		glMatrixMode(GL_MODELVIEW);
			glPushMatrix();
			glLoadIdentity();
	} else {
		// FPP enable textures
		glActiveTextureARB(GL_TEXTURE0_ARB);
			glEnable(GL_TEXTURE_2D);
		glActiveTextureARB(GL_TEXTURE1_ARB);
			glEnable(GL_TEXTURE_2D);
			glMultiTexCoord4f(GL_TEXTURE1_ARB, 1.0f,1.0f,1.0f,1.0f); // workaround a nvidia bug with TexGen
			SetTexGen(1.0f / (mapDims.mapx * SQUARE_SIZE), 1.0f / (mapDims.mapy * SQUARE_SIZE), 0.0f, 0.0f);
		glActiveTextureARB(GL_TEXTURE2_ARB);
			glEnable(GL_TEXTURE_2D);
			glMultiTexCoord4f(GL_TEXTURE2_ARB, 1.0f,1.0f,1.0f,1.0f); // workaround a nvidia bug with TexGen
			SetTexGen(1.0f / (mapDims.pwr2mapx * SQUARE_SIZE), 1.0f / (mapDims.pwr2mapy * SQUARE_SIZE), 0.0f, 0.0f);
			glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);
			glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_PREVIOUS_ARB);
			glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_TEXTURE);
			glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_MODULATE);
			glTexEnvi(GL_TEXTURE_ENV, GL_RGB_SCALE_ARB, 2);
		if (infoTextureHandler->IsEnabled()) {
			glActiveTextureARB(GL_TEXTURE3_ARB);
				glEnable(GL_TEXTURE_2D);
				glMultiTexCoord4f(GL_TEXTURE3_ARB, 1.0f,1.0f,1.0f,1.0f); // workaround a nvidia bug with TexGen
				SetTexGen(1.0f / (mapDims.pwr2mapx * SQUARE_SIZE), 1.0f / (mapDims.pwr2mapy * SQUARE_SIZE), 0.0f, 0.0f);
				glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_ADD_SIGNED_ARB);
				glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_MODULATE);
				glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_PREVIOUS_ARB);
				glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_ARB, GL_TEXTURE);
				glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);
		}
	}

	glActiveTextureARB(GL_TEXTURE0_ARB);
	glDisable(GL_BLEND);
	glDisable(GL_ALPHA_TEST);
	glDepthMask(GL_TRUE);
	ISky::SetupFog();
}
示例#7
0
void CScreensaverPlasma::Render()
{
  glDisable(GL_BLEND);

  int i, j;
  float rgb[3];
  float temp;
  int index;

  //Update constants
  for (i = 0; i < NUMCONSTS; i++)
  {
    m_ct[i] += m_cv[i];
    if(m_ct[i] > PIx2)
      m_ct[i] -= PIx2;
    m_c[i] = sinf(m_ct[i]) * m_focus;
  }

  // Update colors
  for(i = 0; i < m_plasmasize; i++)
  {
    for(j = 0; j < int(float(m_plasmasize) / m_aspectRatio); j++)
    {
      // Calculate vertex colors
      rgb[0] = m_plasma[i][j][0];
      rgb[1] = m_plasma[i][j][1];
      rgb[2] = m_plasma[i][j][2];
      m_plasma[i][j][0] = 0.7f
              * (m_c[0] * m_position[i][j][0] + m_c[1] * m_position[i][j][1]
              + m_c[2] * (m_position[i][j][0] * m_position[i][j][0] + 1.0f)
              + m_c[3] * m_position[i][j][0] * m_position[i][j][1]
              + m_c[4] * rgb[1] + m_c[5] * rgb[2]);
      m_plasma[i][j][1] = 0.7f
              * (m_c[6] * m_position[i][j][0] + m_c[7] * m_position[i][j][1]
              + m_c[8] * m_position[i][j][0] * m_position[i][j][0]
              + m_c[9] * (m_position[i][j][1] * m_position[i][j][1] - 1.0f)
              + m_c[10] * rgb[0] + m_c[11] * rgb[2]);
      m_plasma[i][j][2] = 0.7f
              * (m_c[12] * m_position[i][j][0] + m_c[13] * m_position[i][j][1]
              + m_c[14] * (1.0f - m_position[i][j][0] * m_position[i][j][1])
              + m_c[15] * m_position[i][j][1] * m_position[i][j][1]
              + m_c[16] * rgb[0] + m_c[17] * rgb[1]);

      // Don't let the colors change too much
      temp = m_plasma[i][j][0] - rgb[0];
      if(temp > m_maxdiff)
        m_plasma[i][j][0] = rgb[0] + m_maxdiff;
      if(temp < -m_maxdiff)
        m_plasma[i][j][0] = rgb[0] - m_maxdiff;
      temp = m_plasma[i][j][1] - rgb[1];
      if(temp > m_maxdiff)
        m_plasma[i][j][1] = rgb[1] + m_maxdiff;
      if(temp < -m_maxdiff)
        m_plasma[i][j][1] = rgb[1] - m_maxdiff;
      temp = m_plasma[i][j][2] - rgb[2];
      if(temp > m_maxdiff)
        m_plasma[i][j][2] = rgb[2] + m_maxdiff;
      if(temp < -m_maxdiff)
        m_plasma[i][j][2] = rgb[2] - m_maxdiff;

      // Put colors into texture
      index = (i * TEXSIZE + j) * 3;
      m_plasmamap[index] = fabstrunc(m_plasma[i][j][0]);
      m_plasmamap[index+1] = fabstrunc(m_plasma[i][j][1]);
      m_plasmamap[index+2] = fabstrunc(m_plasma[i][j][2]);
    }
  }

  // Update texture
  if (!glIsTexture(m_tex))
  {
    glGenTextures(1, &m_tex);
    glBindTexture(GL_TEXTURE_2D, m_tex);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
    glPixelStorei(GL_UNPACK_ROW_LENGTH, TEXSIZE);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, TEXSIZE, TEXSIZE, 0, GL_RGB, GL_FLOAT, m_plasmamap);
    glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
  }
  else
  {
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, m_tex);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
    glPixelStorei(GL_UNPACK_ROW_LENGTH, TEXSIZE);
    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, int(float(m_plasmasize) / m_aspectRatio), m_plasmasize, GL_RGB, GL_FLOAT, m_plasmamap);
    glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
  }

  // Draw it
  // The "- 1" cuts off right and top edges to get rid of blending to black
  float texright = float(m_plasmasize - 1) / float(TEXSIZE);
  float textop = float(int(float(m_plasmasize) / m_aspectRatio) - 1) / float(TEXSIZE);

  struct PackedVertex
  {
    float x, y, z;
    float u1, v1;
  } packets[4];

  packets[0].x = -1.0f;
  packets[0].y = -1.0f;
  packets[0].z = 0.0f;
  packets[0].u1 = 0.0f;
  packets[0].v1 = 0.0f;

  packets[1].x = 1.0f;
  packets[1].y = -1.0f;
  packets[1].z = 0.0f;
  packets[1].u1 = 0.0f;
  packets[1].v1 = texright;

  packets[2].x = -1.0f;
  packets[2].y = 1.0f;
  packets[2].z = 0.0f;
  packets[2].u1 = textop;
  packets[2].v1 = 0.0f;

  packets[3].x = 1.0f;
  packets[3].y = 1.0f;
  packets[3].z = 0.0f;
  packets[3].u1 = textop;
  packets[3].v1 = texright;

  EnableShader();

  glBindBuffer(GL_ARRAY_BUFFER, m_vertexVBO);
  glBufferData(GL_ARRAY_BUFFER, sizeof(PackedVertex)*4, &packets[0], GL_STATIC_DRAW);

  glVertexAttribPointer(m_hPos,  3, GL_FLOAT, 0, sizeof(PackedVertex), BUFFER_OFFSET(offsetof(PackedVertex, x)));
  glEnableVertexAttribArray(m_hPos);

  glVertexAttribPointer(m_hCord, 2, GL_FLOAT, 0, sizeof(PackedVertex), BUFFER_OFFSET(offsetof(PackedVertex, u1)));
  glEnableVertexAttribArray(m_hCord);

  glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);

  glDisableVertexAttribArray(m_hPos);
  glDisableVertexAttribArray(m_hCord);

  glBindBuffer(GL_ARRAY_BUFFER, 0);

  DisableShader();

  glBindTexture(GL_TEXTURE_2D, 0);
}