Ejemplo n.º 1
1
void
MapOverlayBitmap::Draw(Canvas &canvas,
                       const WindowProjection &projection) noexcept
{
  if (!simple_bounds.Overlaps(projection.GetScreenBounds()))
    /* not visible, outside of screen area */
    return;

  const RasterPoint vertices[] = {
    projection.GeoToScreen(bounds.top_left),
    projection.GeoToScreen(bounds.top_right),
    projection.GeoToScreen(bounds.bottom_left),
    projection.GeoToScreen(bounds.bottom_right),
  };

  const ScopeVertexPointer vp(vertices);

  GLTexture &texture = *bitmap.GetNative();
  texture.Bind();

  const PixelSize allocated = texture.GetAllocatedSize();
  const unsigned src_x = 0, src_y = 0;
  const unsigned src_width = texture.GetWidth();
  const unsigned src_height = texture.GetHeight();

  GLfloat x0 = (GLfloat)src_x / allocated.cx;
  GLfloat y0 = (GLfloat)src_y / allocated.cy;
  GLfloat x1 = (GLfloat)(src_x + src_width) / allocated.cx;
  GLfloat y1 = (GLfloat)(src_y + src_height) / allocated.cy;

  if (bitmap.IsFlipped()) {
    y0 = 1 - y0;
    y1 = 1 - y1;
  }

  const Point2D<GLfloat> coord[] = {
    {x0, y0},
    {x1, y0},
    {x0, y1},
    {x1, y1},
  };

  const ScopeTextureConstantAlpha blend(alpha);

#ifdef USE_GLSL
  OpenGL::texture_shader->Use();
  glEnableVertexAttribArray(OpenGL::Attribute::TEXCOORD);
  glVertexAttribPointer(OpenGL::Attribute::TEXCOORD, 2, GL_FLOAT, GL_FALSE,
                        0, coord);
#else
  const GLEnable<GL_TEXTURE_2D> scope;
  glEnableClientState(GL_TEXTURE_COORD_ARRAY);
  glTexCoordPointer(2, GL_FLOAT, 0, coord);
#endif

  glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);

#ifdef USE_GLSL
  glDisableVertexAttribArray(OpenGL::Attribute::TEXCOORD);
  OpenGL::solid_shader->Use();
#else
  glDisableClientState(GL_TEXTURE_COORD_ARRAY);
#endif
}
Ejemplo n.º 2
0
void Shape_Blitter::OGL_Draw(SDL_Rect& dst)
{
#ifdef HAVE_OPENGL
  // Set up texture
  TextureManager TMgr;
  TMgr.ShapeDesc = m_desc;
  get_shape_bitmap_and_shading_table(m_desc, &TMgr.Texture, &TMgr.ShadingTables,
                                     _shading_normal);
  TMgr.IsShadeless = false;
  TMgr.TransferMode = _shadeless_transfer;

  switch (m_type)
  {
  case Shape_Texture_Wall:
    TMgr.TextureType = OGL_Txtr_Wall;
    break;
  case Shape_Texture_Landscape:
  {
    TMgr.TextureType = OGL_Txtr_Landscape;
    LandscapeOptions *LandOpts = View_GetLandscapeOptions(TMgr.ShapeDesc);
    TMgr.LandscapeVertRepeat = LandOpts->VertRepeat;
    TMgr.Landscape_AspRatExp = LandOpts->OGL_AspRatExp;
  }
  break;
  case Shape_Texture_Sprite:
    TMgr.TextureType = OGL_Txtr_Inhabitant;
    break;
  case Shape_Texture_WeaponInHand:
  case Shape_Texture_Interface:
    TMgr.TextureType = OGL_Txtr_WeaponsInHand;
    break;
  }
  if (!TMgr.Setup()) {
    return;
  }

  // Get dimensions
  // DJB Doubles to floats...
  GLfloat U_Scale = TMgr.U_Scale;
  GLfloat V_Scale = TMgr.V_Scale;
  GLfloat U_Offset = TMgr.U_Offset;
  GLfloat V_Offset = TMgr.V_Offset;

  // Draw shape
  SglColor4f(tint_color_r, tint_color_g, tint_color_b, tint_color_a);
  glEnable(GL_TEXTURE_2D);
  glEnable(GL_BLEND);
  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  TMgr.SetupTextureMatrix();
  TMgr.RenderNormal();

  bool rotating = (rotation > 0.1 || rotation < -0.1);
  if (rotating) {
    glMatrixMode(GL_MODELVIEW);
    glPushMatrix();
    glTranslatef((dst.x + dst.w/2.0), (dst.y + dst.h/2.0), 0.0);
    glRotatef(rotation, 0.0, 0.0, 1.0);
    glTranslatef(-(dst.x + dst.w/2.0), -(dst.y + dst.h/2.0), 0.0);
  }

  if (m_type == Shape_Texture_Interface) {
    if (crop_rect.x > 0) {
      U_Offset += crop_rect.x * U_Scale / static_cast<double>(m_scaled_src.w);
    }
    if (crop_rect.y > 0) {
      V_Offset += crop_rect.y * V_Scale / static_cast<double>(m_scaled_src.h);
    }
    if (crop_rect.w < m_scaled_src.w) {
      U_Scale *= crop_rect.w / static_cast<double>(m_scaled_src.w);
    }
    if (crop_rect.h < m_scaled_src.h) {
      V_Scale *= crop_rect.h / static_cast<double>(m_scaled_src.h);
    }

    // DJB OpenGL  Change from triangle fan
    GLfloat t[8] = {
      U_Offset, V_Offset,
      U_Offset + U_Scale, V_Offset,
      U_Offset + U_Scale, V_Offset + V_Scale,
      U_Offset, V_Offset + V_Scale
    };
    GLshort v[8] = {
      dst.x, dst.y,
      dst.x + dst.w, dst.y,
      dst.x + dst.w, dst.y + dst.h,
      dst.x, dst.y + dst.h
    };
    glVertexPointer(2, GL_SHORT, 0, v);
    glEnableClientState(GL_VERTEX_ARRAY);
    glTexCoordPointer(2, GL_FLOAT, 0, t);
    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
    glDrawArrays(GL_TRIANGLE_FAN, 0, 4);

    /*
    glBegin(GL_TRIANGLE_FAN);
    glTexCoord2d(U_Offset, V_Offset);
    glVertex2i(dst.x, dst.y);
    glTexCoord2d(U_Offset + U_Scale, V_Offset);
    glVertex2i(dst.x + dst.w, dst.y);
    glTexCoord2d(U_Offset + U_Scale, V_Offset + V_Scale);
    glVertex2i(dst.x + dst.w, dst.y + dst.h);
    glTexCoord2d(U_Offset, V_Offset + V_Scale);
    glVertex2i(dst.x, dst.y + dst.h);
    glEnd();
     */
  }
  else if (m_type == Shape_Texture_Landscape) {
    U_Scale = -TMgr.Texture->width / static_cast<double>(TMgr.Texture->height);
    U_Offset = 0.5 - U_Scale/2.0;

    crop_rect.x = m_scaled_src.w/4;
    crop_rect.w = m_scaled_src.w/2;
    crop_rect.y = m_scaled_src.h/4;
    crop_rect.h = m_scaled_src.h/2;
    if (crop_rect.x > 0) {
      V_Offset += crop_rect.x * V_Scale / static_cast<double>(m_scaled_src.w);
    }
    if (crop_rect.y > 0) {
      U_Offset += crop_rect.y * U_Scale / static_cast<double>(m_scaled_src.h);
    }
    if (crop_rect.w < m_scaled_src.w) {
      V_Scale *= crop_rect.w / static_cast<double>(m_scaled_src.w);
    }
    if (crop_rect.h < m_scaled_src.h) {
      U_Scale *= crop_rect.h / static_cast<double>(m_scaled_src.h);
    }

    // DJB OpenGL Change from glBegin/glEnd
    GLfloat t[8] = {
      V_Offset, U_Offset,
      V_Offset + V_Scale, U_Offset,
      V_Offset + V_Scale, U_Offset + U_Scale,
      V_Offset, U_Offset + U_Scale
    };
    GLshort v[8] = {
      dst.x, dst.y,
      dst.x + dst.w, dst.y,
      dst.x + dst.w, dst.y + dst.h,
      dst.x, dst.y + dst.h
    };
    glVertexPointer(2, GL_SHORT, 0, v);
    glEnableClientState(GL_VERTEX_ARRAY);
    glTexCoordPointer(2, GL_FLOAT, 0, t);
    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
    glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
    /*
    glBegin(GL_TRIANGLE_FAN);
    glTexCoord2d(V_Offset, U_Offset);
    glVertex2i(dst.x, dst.y);
    glTexCoord2d(V_Offset + V_Scale, U_Offset);
    glVertex2i(dst.x + dst.w, dst.y);
    glTexCoord2d(V_Offset + V_Scale, U_Offset + U_Scale);
    glVertex2i(dst.x + dst.w, dst.y + dst.h);
    glTexCoord2d(V_Offset, U_Offset + U_Scale);
    glVertex2i(dst.x, dst.y + dst.h);
    glEnd();
     */
  }
  else
  {
    if (crop_rect.x > 0) {
      V_Offset += crop_rect.x * V_Scale / static_cast<double>(m_scaled_src.w);
    }
    if (crop_rect.y > 0) {
      U_Offset += crop_rect.y * U_Scale / static_cast<double>(m_scaled_src.h);
    }
    if (crop_rect.w < m_scaled_src.w) {
      V_Scale *= crop_rect.w / static_cast<double>(m_scaled_src.w);
    }
    if (crop_rect.h < m_scaled_src.h) {
      U_Scale *= crop_rect.h / static_cast<double>(m_scaled_src.h);
    }

    // DJB OpenGL 
    GLfloat t[8] = {
      U_Offset, V_Offset,
      U_Offset, V_Offset + V_Scale,
      U_Offset + U_Scale, V_Offset + V_Scale,
      U_Offset + U_Scale, V_Offset
    };
    GLshort v[8] = {
      dst.x, dst.y,
      dst.x + dst.w, dst.y,
      dst.x + dst.w, dst.y + dst.h,
      dst.x, dst.y + dst.h
    };
    glVertexPointer(2, GL_SHORT, 0, v);
    glEnableClientState(GL_VERTEX_ARRAY);
    glTexCoordPointer(2, GL_FLOAT, 0, t);
    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
    glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
    /*
    glBegin(GL_TRIANGLE_FAN);
    glTexCoord2d(U_Offset, V_Offset);
    glVertex2i(dst.x, dst.y);
    glTexCoord2d(U_Offset, V_Offset + V_Scale);
    glVertex2i(dst.x + dst.w, dst.y);
    glTexCoord2d(U_Offset + U_Scale, V_Offset + V_Scale);
    glVertex2i(dst.x + dst.w, dst.y + dst.h);
    glTexCoord2d(U_Offset + U_Scale, V_Offset);
    glVertex2i(dst.x, dst.y + dst.h);
    glEnd();
    */
  }

  if (rotating) {
    glPopMatrix();
  }

  if (TMgr.IsGlowMapped()) {
    TMgr.RenderGlowing();
  }
  TMgr.RestoreTextureMatrix();
#endif
}
Ejemplo n.º 3
0
void Bomb::display() {
  
  GLfloat tex[] = {0,1,0, 1,1,0, 0,0,0, 1,0,0};
  GLfloat particle_vertices[] = {0,16,0, 16,16,0, 0,0,0, 16,0,0};
  
  if (!exploding) {
    glColor4f(alpha, alpha, alpha, alpha);
    
    float start_x = x;
    float start_y = y;

    float width = 48.0f;
    float height = 48.0f;

    float end_x = start_x + width;
    float end_y = start_y - height;

    float dx = end_x - start_x;
    float dy = end_y - start_y;

    GLfloat vertices[] = {0,dy,0, dx,dy,0, 0,0,0, dx,0,0};
    
    TexManager::Instance()->bindTexture(9);
  
    glLoadIdentity();
    glTranslatef(start_x - width/2, start_y + height/2, 0.0);
    glTranslatef(width/2, -height/2, 0.0);
    glRotatef(angle, 0.0f, 0.0f, 1.0f);
    glTranslatef(-width/2, height/2, 0.0);

    glEnableClientState(GL_VERTEX_ARRAY);
    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
  
    glVertexPointer(3, GL_FLOAT, 0, vertices);
    glTexCoordPointer(3, GL_FLOAT, 0, tex);
  
    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
  
    glDisableClientState(GL_VERTEX_ARRAY);
    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
  } else {
    TexManager::Instance()->bindTexture(6);

    if (!destroyed) {
      for (int i=0; i < PARTICLE_TOTAL; i++) {
        if (!particles[i]->dead) {
          glLoadIdentity();
          glTranslatef(particles[i]->x - 16, particles[i]->y - 16, 0.0f);

          glEnableClientState(GL_VERTEX_ARRAY);
          glEnableClientState(GL_TEXTURE_COORD_ARRAY);

          glVertexPointer(3, GL_FLOAT, 0, particle_vertices);
          glTexCoordPointer(3, GL_FLOAT, 0, tex);

          glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);

          glDisableClientState(GL_VERTEX_ARRAY);
          glDisableClientState(GL_TEXTURE_COORD_ARRAY);
        }
      }
    }
  }
  
  TexManager::Instance()->unbindTexture();
}
Ejemplo n.º 4
0
Archivo: AEVA.c Proyecto: Oddity007/AE
void AEVADrawRange(const AEVA* va, const AEVA* ia, GLuint start, GLuint count){
	
	if(not va) return;
	if(count==0) count = (ia ? ia : va)->elementCount;
	char* offset=NULL;
	if(va->format.storageType) glBindBuffer(GL_ARRAY_BUFFER, va->data.vbo);
	else{
		glBindBuffer(GL_ARRAY_BUFFER, 0);
		offset=va->data.pointer;
	}
	
	size_t stride=AEVAFormatByteSize(& va->format);
	
	for(int i=0;i<va->format.textureCoordsPerVertex;i++){
		glClientActiveTexture(GL_TEXTURE0+i);
		glTexCoordPointer(2, GL_FLOAT, stride, offset);
		glEnableClientState(GL_TEXTURE_COORD_ARRAY);
		offset+=sizeof(float[2]); 
	}
	glClientActiveTexture(GL_TEXTURE0);
	
	if(va->format.hasColors) {
		glEnableClientState(GL_COLOR_ARRAY);
		glColorPointer(4, GL_UNSIGNED_BYTE, stride, offset);
		offset+=sizeof(GLubyte[4]);
	}
	
	if(va->format.hasNormals){
		glEnableClientState(GL_NORMAL_ARRAY);
		glNormalPointer(GL_FLOAT, stride, offset);
		offset+=sizeof(float[3]);
	}
	
	glEnableClientState(GL_VERTEX_ARRAY);
	glVertexPointer(3, GL_FLOAT, stride, offset);
	
	
	if(ia) {
		char* indexOffset=NULL;
		size_t indexStride=0;
		//glEnableClientState(GL_INDEX_ARRAY);
		if(ia->format.storageType) glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ia->data.vbo);
		else indexOffset=ia->data.pointer;
		indexStride=ia->format.indexType==AEVAFormatIndexType32Bit ? sizeof(GLuint) : sizeof(GLushort);
		GLuint indexType=GL_UNSIGNED_SHORT;
		#ifndef AEiOS
		if(ia->format.indexType==AEVAFormatIndexType32Bit) indexType=GL_UNSIGNED_INT;
		#endif
		glDrawElements(ia->format.isQuads ? GL_QUADS : GL_TRIANGLES, count, indexType, indexOffset+indexStride*start);
		//glDisableClientState(GL_INDEX_ARRAY);
		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
	}
	else glDrawArrays(va->format.isQuads ? GL_QUADS : GL_TRIANGLES, start, count);
	
	for(int i=0;i<va->format.textureCoordsPerVertex;i++){
		glClientActiveTexture(GL_TEXTURE0+i);
		glDisableClientState(GL_TEXTURE_COORD_ARRAY);
	}
	glClientActiveTexture(GL_TEXTURE0);
	
	if(va->format.hasColors) glDisableClientState(GL_COLOR_ARRAY);
	
	if(va->format.hasNormals) glDisableClientState(GL_NORMAL_ARRAY);
	
	glDisableClientState(GL_VERTEX_ARRAY);
}
void OGLRender::Initialize(void)
{
    glMatrixMode(GL_MODELVIEW);
    OPENGL_CHECK_ERRORS;
    glLoadIdentity();
    OPENGL_CHECK_ERRORS;

    glViewportWrapper(0, windowSetting.statusBarHeightToUse, windowSetting.uDisplayWidth, windowSetting.uDisplayHeight);
    OPENGL_CHECK_ERRORS;

#if SDL_VIDEO_OPENGL
    COGLGraphicsContext *pcontext = (COGLGraphicsContext *)(CGraphicsContext::g_pGraphicsContext);
    if( pcontext->IsExtensionSupported("GL_IBM_texture_mirrored_repeat") )
    {
        OGLXUVFlagMaps[TEXTURE_UV_FLAG_MIRROR].realFlag = GL_MIRRORED_REPEAT_IBM;
    }
    else if( pcontext->IsExtensionSupported("ARB_texture_mirrored_repeat") )
    {
        OGLXUVFlagMaps[TEXTURE_UV_FLAG_MIRROR].realFlag = GL_MIRRORED_REPEAT_ARB;
    }
    else
    {
        OGLXUVFlagMaps[TEXTURE_UV_FLAG_MIRROR].realFlag = GL_REPEAT;
    }

    if( pcontext->IsExtensionSupported("GL_ARB_texture_border_clamp") || pcontext->IsExtensionSupported("GL_EXT_texture_edge_clamp") )
    {
        m_bSupportClampToEdge = true;
        OGLXUVFlagMaps[TEXTURE_UV_FLAG_CLAMP].realFlag = GL_CLAMP_TO_EDGE;
    }
    else
    {
        m_bSupportClampToEdge = false;
        OGLXUVFlagMaps[TEXTURE_UV_FLAG_CLAMP].realFlag = GL_CLAMP;
    }

    glVertexPointer( 4, GL_FLOAT, sizeof(float)*5, &(g_vtxProjected5[0][0]) );
    OPENGL_CHECK_ERRORS;
    glEnableClientState( GL_VERTEX_ARRAY );
    OPENGL_CHECK_ERRORS;

    if( m_bMultiTexture )
    {
        pglClientActiveTextureARB( GL_TEXTURE0_ARB );
        OPENGL_CHECK_ERRORS;
        glTexCoordPointer( 2, GL_FLOAT, sizeof( TLITVERTEX ), &(g_vtxBuffer[0].tcord[0].u) );
        OPENGL_CHECK_ERRORS;
        glEnableClientState( GL_TEXTURE_COORD_ARRAY );
        OPENGL_CHECK_ERRORS;

        pglClientActiveTextureARB( GL_TEXTURE1_ARB );
        OPENGL_CHECK_ERRORS;
        glTexCoordPointer( 2, GL_FLOAT, sizeof( TLITVERTEX ), &(g_vtxBuffer[0].tcord[1].u) );
        OPENGL_CHECK_ERRORS;
        glEnableClientState( GL_TEXTURE_COORD_ARRAY );
        OPENGL_CHECK_ERRORS;
    }
    else
    {
        glTexCoordPointer( 2, GL_FLOAT, sizeof( TLITVERTEX ), &(g_vtxBuffer[0].tcord[0].u) );
        OPENGL_CHECK_ERRORS;
        glEnableClientState( GL_TEXTURE_COORD_ARRAY );
        OPENGL_CHECK_ERRORS;
    }

    if (m_bSupportFogCoordExt)
    {
        pglFogCoordPointerEXT( GL_FLOAT, sizeof(float)*5, &(g_vtxProjected5[0][4]) );
        OPENGL_CHECK_ERRORS;
        glEnableClientState( GL_FOG_COORDINATE_ARRAY_EXT );
        OPENGL_CHECK_ERRORS;
        glFogi( GL_FOG_COORDINATE_SOURCE_EXT, GL_FOG_COORDINATE_EXT );
        OPENGL_CHECK_ERRORS;
        glFogi(GL_FOG_MODE, GL_LINEAR); // Fog Mode
        OPENGL_CHECK_ERRORS;
        glFogf(GL_FOG_DENSITY, 1.0f); // How Dense Will The Fog Be
        OPENGL_CHECK_ERRORS;
        glHint(GL_FOG_HINT, GL_FASTEST); // Fog Hint Value
        OPENGL_CHECK_ERRORS;
        glFogi( GL_FOG_COORDINATE_SOURCE_EXT, GL_FOG_COORDINATE_EXT );
        OPENGL_CHECK_ERRORS;
        glFogf( GL_FOG_START, 0.0f );
        OPENGL_CHECK_ERRORS;
        glFogf( GL_FOG_END, 1.0f );
        OPENGL_CHECK_ERRORS;
    }

    //glColorPointer( 1, GL_UNSIGNED_BYTE, sizeof(TLITVERTEX), &g_vtxBuffer[0].r);
    glColorPointer( 4, GL_UNSIGNED_BYTE, sizeof(uint8)*4, &(g_oglVtxColors[0][0]) );
    OPENGL_CHECK_ERRORS;
    glEnableClientState( GL_COLOR_ARRAY );
    OPENGL_CHECK_ERRORS;

    if( pcontext->IsExtensionSupported("GL_NV_depth_clamp") )
    {
        glEnable(GL_DEPTH_CLAMP_NV);
        OPENGL_CHECK_ERRORS;
    }

#elif SDL_VIDEO_OPENGL_ES2
    OGLXUVFlagMaps[TEXTURE_UV_FLAG_MIRROR].realFlag = GL_MIRRORED_REPEAT;
    m_bSupportClampToEdge = true;
    OGLXUVFlagMaps[TEXTURE_UV_FLAG_CLAMP].realFlag = GL_CLAMP_TO_EDGE;
#endif

#ifdef PAULSCODE
    hardwareType = Android_JNI_GetHardwareType();
#endif
}
Ejemplo n.º 6
0
void font_printf(int x, int y, float scale, const char *fmt, ...)
{
	va_list args;
	char buf[256];
	
	// calculate glyph size
	const float glyphsize = 8.0f * scale;

	GLfloat verts[] = {
		x + glyphsize,	y,
		x,				y,
		x + glyphsize,	y + glyphsize,
		x,				y + glyphsize
	};
	
	GLfloat texcoords[] = {
		1.0f,			0.0f,
		0.0f,			0.0f,
		1.0f,			1.0f,
		0.0f,			1.0f
	};
	
	// format arguments
	va_start(args, fmt);
	vsnprintf(buf, sizeof(buf), fmt, args);
	va_end(args);
	
	// initialize font texture if necessary
	if (fonttexid == 0)
		font_init();

	// setup rendering
	glBindTexture(GL_TEXTURE_2D, fonttexid);
	glVertexPointer(2, GL_FLOAT, 0, verts);
	glTexCoordPointer(2, GL_FLOAT, 0, texcoords);
	glEnableClientState(GL_VERTEX_ARRAY);
	glEnableClientState(GL_TEXTURE_COORD_ARRAY);

	// loop for each glyph
	const char *ptr = buf;
	while (*ptr != 0)
	{
		// calculate x/y position of glyph within texture
		const int x = ((*ptr) % 16) * 8;
		const int y = ((*ptr) / 16) * 8;

		// set texture coordinates
		texcoords[1] = (float)y / (16*8);
		texcoords[3] = texcoords[1];
		texcoords[2] = (float)x / (16*8);
		texcoords[6] = texcoords[2];
		
		texcoords[0] = (float)(x + 8) / (16*8);
		texcoords[4] = texcoords[0];
		texcoords[5] = (float)(y + 8) / (16*8);
		texcoords[7] = texcoords[5];
		
		// render the glyph
		glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
		
		// advance x position
		verts[0] += glyphsize;
		verts[2] += glyphsize;
		verts[4] += glyphsize;
		verts[6] += glyphsize;

		// advance to next glyph
		ptr++;
	}
}
void SAssPiece::DrawForList() const
{
	if (isEmpty) {
		return;
	}
	LOG_SL(LOG_SECTION_PIECE, L_DEBUG, "Compiling piece %s", name.c_str());
	//! Add GL commands to the pieces displaylist

	const SAssVertex* sAssV = &vertices[0];

	//! pass the tangents as 3D texture coordinates
	//! (array elements are float3's, which are 12
	//! bytes in size and each represent a single
	//! xyz triple)
	//! TODO: test if we have this many texunits
	//! (if not, could only send the s-tangents)?

	if (!sTangents.empty()) {
		glClientActiveTexture(GL_TEXTURE5);
		glEnableClientState(GL_TEXTURE_COORD_ARRAY);
		glTexCoordPointer(3, GL_FLOAT, sizeof(float3), &sTangents[0].x);
	}
	if (!tTangents.empty()) {
		glClientActiveTexture(GL_TEXTURE6);
		glEnableClientState(GL_TEXTURE_COORD_ARRAY);
		glTexCoordPointer(3, GL_FLOAT, sizeof(float3), &tTangents[0].x);
	}

	glClientActiveTexture(GL_TEXTURE0);
	glEnableClientState(GL_TEXTURE_COORD_ARRAY);
	glTexCoordPointer(2, GL_FLOAT, sizeof(SAssVertex), &sAssV->textureX);

	glEnableClientState(GL_VERTEX_ARRAY);
	glVertexPointer(3, GL_FLOAT, sizeof(SAssVertex), &sAssV->pos.x);

	glEnableClientState(GL_NORMAL_ARRAY);
	glNormalPointer(GL_FLOAT, sizeof(SAssVertex), &sAssV->normal.x);

	/*
	 * since aiProcess_SortByPType is being used,
	 * we're sure we'll get only 1 type here,
	 * so combination check isn't needed, also
	 * anything more complex than triangles is
	 * being split thanks to aiProcess_Triangulate
	 */
	glDrawElements(GL_TRIANGLES, vertexDrawOrder.size(), GL_UNSIGNED_INT, &vertexDrawOrder[0]);

	if (!sTangents.empty()) {
		glClientActiveTexture(GL_TEXTURE6);
		glDisableClientState(GL_TEXTURE_COORD_ARRAY);
	}
	if (!tTangents.empty()) {
		glClientActiveTexture(GL_TEXTURE5);
		glDisableClientState(GL_TEXTURE_COORD_ARRAY);
	}

	glClientActiveTexture(GL_TEXTURE0);
	glDisableClientState(GL_TEXTURE_COORD_ARRAY);

	glDisableClientState(GL_VERTEX_ARRAY);
	glDisableClientState(GL_NORMAL_ARRAY);

	LOG_SL(LOG_SECTION_PIECE, L_DEBUG, "Completed compiling piece %s",
			name.c_str());
}
Ejemplo n.º 8
0
bool CFXRings::DoFrame(CDemo* pDemo, float fEffectTime, float fDemoTime)
{
	assert(pDemo);

	if(!m_pResHorTexture)
	{
		FXRuntimeError("Horizontal texture resource not found");
		return false;
	}

	UtilGL::Texturing::CTexture2D* pHorTexture = const_cast<UtilGL::Texturing::CTexture2D*>(((CResourceTexture2D*)m_pResHorTexture)->GetTexture2D());

	if(!pHorTexture)
	{
		FXRuntimeError("WARNING: Horizontal texture not available");
		return false;
	}

	if(!m_pResVertTexture)
	{
		FXRuntimeError("Vertical texture resource not found");
		return false;
	}

	UtilGL::Texturing::CTexture2D* pVertTexture = const_cast<UtilGL::Texturing::CTexture2D*>(((CResourceTexture2D*)m_pResVertTexture)->GetTexture2D());

	if(!pVertTexture)
	{
		FXRuntimeError("WARNING: Texture not available");
		return false;
	}

	// Vars

	CVarFloat::CValueFloat valueAlpha;
	CVarFloat::CValueFloat valueHorRingRadius;
	CVarFloat::CValueFloat valueHorRingWidth;
	CVarFloat::CValueFloat valueVertRingRadius;
	CVarFloat::CValueFloat valueVertRingWidth;
	CVarFloat::CValueFloat valueCylinderHeight;
	CVarCombo::CValueCombo valueBlendMode;
	CVarCombo::CValueCombo valueKeepPreviousCamera;
	CVarFloat::CValueFloat valueOscillationAmplitude;
	CVarFloat::CValueFloat valueOscillationFrequency;
	CVarFloat::CValueFloat valueRotationSpeed;
	CVarFloat::CValueFloat valueTileU;
	CVarFloat::CValueFloat valueTileV;

	EvaluateVar("Alpha",                  fEffectTime, &valueAlpha);
	EvaluateVar("Horizontal Ring Radius", fEffectTime, &valueHorRingRadius);
	EvaluateVar("Horizontal Ring Width",  fEffectTime, &valueHorRingWidth);
	EvaluateVar("Vertical Ring Radius",   fEffectTime, &valueVertRingRadius);
	EvaluateVar("Vertical Ring Width",    fEffectTime, &valueVertRingWidth);
	EvaluateVar("Cylinder Height",        fEffectTime, &valueCylinderHeight);
	EvaluateVar("Blend Mode",             fEffectTime, &valueBlendMode);
	EvaluateVar("Keep Previous Camera",   fEffectTime, &valueKeepPreviousCamera);
	EvaluateVar("Oscillation Amplitude",  fEffectTime, &valueOscillationAmplitude);
	EvaluateVar("Oscillation Frequency",  fEffectTime, &valueOscillationFrequency);
	EvaluateVar("Rotation Speed",         fEffectTime, &valueRotationSpeed);
	EvaluateVar("Tile U",                 fEffectTime, &valueTileU);
	EvaluateVar("Tile V",                 fEffectTime, &valueTileV);

	// States

	int nSrcBlend = UtilGL::States::BLEND_SRCALPHA;
	int nDstBlend = UtilGL::States::BLEND_INVSRCALPHA;

	if(valueBlendMode.GetValue() == "Add")
	{
		nDstBlend = UtilGL::States::BLEND_ONE;
	}
	else if(valueBlendMode.GetValue() == "Color Mult")
	{
		nSrcBlend = UtilGL::States::BLEND_DSTCOLOR;
		nDstBlend = UtilGL::States::BLEND_ZERO;
	}

	UtilGL::States::Set(UtilGL::States::BLENDING,     UtilGL::States::ENABLED);
	UtilGL::States::Set(UtilGL::States::LIGHTING,     UtilGL::States::DISABLED);
	UtilGL::States::Set(UtilGL::States::ZBUFFERWRITE, UtilGL::States::DISABLED);
	UtilGL::States::Set(UtilGL::States::BFCULLING,    UtilGL::States::DISABLED);

	UtilGL::States::Set(UtilGL::States::SRCBLEND, nSrcBlend);
	UtilGL::States::Set(UtilGL::States::DSTBLEND, nDstBlend);

	// Transforming

	CMatrix mtxCam;

	CMatrix  mtxAddLocal, mtxAddWorld;
	CVector3 v3AddCamPos, v3AddCamAngles;
	EvaluateAddTransformVars(this, fEffectTime, &mtxAddLocal, &mtxAddWorld, &v3AddCamPos, &v3AddCamAngles);

	mtxCam.RotateX(v3AddCamAngles.X());
	mtxCam.RotateY(v3AddCamAngles.Y());
	mtxCam.RotateZ(v3AddCamAngles.Z());
	mtxCam.SetPosition(v3AddCamPos);

	if(valueKeepPreviousCamera.GetValue() == "No")
	{
		UtilGL::Transforming::SetMatrix(UtilGL::Transforming::MATRIX_VIEW, mtxCam.Inverse());

		UtilGL::Transforming::ClearMatrix(UtilGL::Transforming::MATRIX_PROJECTION);
		glMatrixMode(GL_PROJECTION);
		gluPerspective(60.0f, pDemo->GetAspect(), 1.0f, 1000.0f);
	}

	CMatrix mtxTexturing;
	mtxTexturing.BuildScaling(valueTileU.GetValue(), valueTileV.GetValue(), 1.0f);

	UtilGL::Transforming::SetMatrix(UtilGL::Transforming::MATRIX_WORLD,   mtxAddWorld);
	UtilGL::Transforming::SetMatrix(UtilGL::Transforming::MATRIX_TEXTURE, mtxTexturing);

	// Render

	glEnableClientState(GL_VERTEX_ARRAY);

	VECRINGS::iterator it;

	for(it = m_vecRings.begin(); it != m_vecRings.end(); ++it)
	{
		float fDistToCenter         = it->fDistToCenter         * valueCylinderHeight.GetValue();
		float fRotSpeed             = it->fRotSpeed             * valueRotationSpeed.GetValue();
		float fOscillationAmplitude = it->fOscillationAmplitude * valueOscillationAmplitude.GetValue();
		float fOscillationFrequency = it->fOscillationFrequency * valueOscillationFrequency.GetValue();
		float fHorRingWidth         = it->fWidth                * valueHorRingWidth.GetValue();
		float fHorRingRadius        = it->fRadius               * valueHorRingRadius.GetValue();
		float fVertRingWidth        = it->fWidth                * valueVertRingWidth.GetValue();
		float fVertRingRadius       = it->fRadius               * valueVertRingRadius.GetValue();

		if(!IS_ZERO(fOscillationAmplitude))
		{
			fDistToCenter += sinf(((it->fOscillationOffset + fEffectTime) * PI) * fOscillationFrequency) * fOscillationAmplitude;
		}

		CMatrix localMatrix = mtxAddLocal;
		localMatrix.PreRotateY(it->fRotAngleStart + (fRotSpeed * 360.0f * fEffectTime));
		localMatrix.Translate (0.0f, fDistToCenter, 0.0f);

		// Compute Mesh

		for(int i = 0; i < m_nSubdivisions + 1; i++)
		{
			float fRadius = it->eType == SRing::HORIZONTAL ? fHorRingRadius : fVertRingRadius;
			float fWidth  = it->eType == SRing::HORIZONTAL ? fHorRingWidth  : fVertRingWidth;

			m_pv3MeshVertices[i] = m_pv3Circle[i] * fRadius;
			m_pv3MeshVertices[i + m_nSubdivisions + 1] = m_pv3MeshVertices[i];

			if(it->eType == SRing::HORIZONTAL)
			{
				if(IS_ZERO(fRadius)) fRadius = 0.001f;
				float fWidthRatio = fWidth / fRadius;
				m_pv3MeshVertices[i + m_nSubdivisions + 1] = m_pv3MeshVertices[i + m_nSubdivisions + 1] * (1.0f - fWidthRatio);
			}

			if(it->eType == SRing::VERTICAL)
			{
				m_pv3MeshVertices[i + m_nSubdivisions + 1].SetY(m_pv3MeshVertices[i + m_nSubdivisions + 1].Y() + fWidth);
			}

			localMatrix.Transform(&m_pv3MeshVertices[i]);
			localMatrix.Transform(&m_pv3MeshVertices[i + m_nSubdivisions + 1]);
		}

		// Draw

		CVector4 v4Color(1.0f, 1.0f, 1.0f, it->fAlpha * valueAlpha.GetValue());
		UtilGL::States::SetColor(v4Color);

		glVertexPointer(3, GL_FLOAT, 0, m_pv3MeshVertices);

		UtilGL::Texturing::CTexture2D* pTexture = it->eType == SRing::HORIZONTAL ? pHorTexture : pVertTexture;

		if(pTexture)
		{
			UtilGL::States::Set(UtilGL::States::TEXTURE2D, UtilGL::States::ENABLED);
			glEnableClientState(GL_TEXTURE_COORD_ARRAY);
			glTexCoordPointer(2, GL_FLOAT, 0, m_pv2MeshMapping);
			pTexture->SetActive();
			pTexture->SetTiling(true);
		}
		else
		{
			UtilGL::States::Set(UtilGL::States::TEXTURE2D, UtilGL::States::DISABLED);
			glDisableClientState(GL_TEXTURE_COORD_ARRAY);
		}

		glDrawRangeElements(GL_QUADS, 0, (m_nSubdivisions * 2) + 1, m_nSubdivisions * 4, GL_UNSIGNED_INT, m_pnMeshFaceList);
	}

 	glDisableClientState(GL_VERTEX_ARRAY);
	glDisableClientState(GL_TEXTURE_COORD_ARRAY);

	// States

	UtilGL::States::Set(UtilGL::States::BLENDING,     UtilGL::States::DISABLED);
	UtilGL::States::Set(UtilGL::States::ZBUFFERWRITE, UtilGL::States::ENABLED);
	UtilGL::States::Set(UtilGL::States::TEXTURE2D,    UtilGL::States::DISABLED);
	UtilGL::States::Set(UtilGL::States::BFCULLING,    UtilGL::States::ENABLED);

	UtilGL::Transforming::ClearMatrix(UtilGL::Transforming::MATRIX_TEXTURE);

	return true;
}
Ejemplo n.º 9
0
void YuiSwapBuffers(void)
{
   int buf_width, buf_height;
   int error;
   
   
   pthread_mutex_lock(&g_mtxGlLock);
   if( g_Display == EGL_NO_DISPLAY ) 
   {
      pthread_mutex_unlock(&g_mtxGlLock);
      return;
   }

   if( eglMakeCurrent(g_Display,g_Surface,g_Surface,g_Context) == EGL_FALSE )
   {
         printf( "eglMakeCurrent fail %04x",eglGetError());
         pthread_mutex_unlock(&g_mtxGlLock);
         return;
   }   
      
   glClearColor( 0.0f,0.0f,0.0f,1.0f);
   glClear(GL_COLOR_BUFFER_BIT);

   
   if( g_FrameBuffer == 0 )
   {
      glEnable(GL_TEXTURE_2D);
      glGenTextures(1,&g_FrameBuffer);
      glBindTexture(GL_TEXTURE_2D, g_FrameBuffer);
      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1024, 1024, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);   
      glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
      glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
      glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
      error = glGetError();
      if( error != GL_NO_ERROR )
      {
         printf("gl error %d", error );
         return;
      }
   }else{
      glBindTexture(GL_TEXTURE_2D, g_FrameBuffer);
   }
   

   VIDCore->GetGlSize(&buf_width, &buf_height);
   glTexSubImage2D(GL_TEXTURE_2D, 0,0,0,buf_width,buf_height,GL_RGBA,GL_UNSIGNED_BYTE,dispbuffer);
   
   
   if( g_VertexBuffer == 0 )
   {
      glGenBuffers(1, &g_VertexBuffer);
      glBindBuffer(GL_ARRAY_BUFFER, g_VertexBuffer);
      glBufferData(GL_ARRAY_BUFFER, sizeof(vertices),vertices,GL_STATIC_DRAW);
      error = glGetError();
      if( error != GL_NO_ERROR )
      {
         printf("gl error %d", error );
         return;
      }      
   }else{
      glBindBuffer(GL_ARRAY_BUFFER, g_VertexBuffer);
   }
  
  if( buf_width != g_buf_width ||  buf_height != g_buf_height )
  {
     vertices[6]=vertices[10]=(float)buf_width/1024.f;
     vertices[11]=vertices[15]=(float)buf_height/1024.f;
     glBufferData(GL_ARRAY_BUFFER, sizeof(vertices),vertices,GL_STATIC_DRAW);
     glVertexPointer(2, GL_FLOAT, sizeof(float)*4, 0);
     glTexCoordPointer(2, GL_FLOAT, sizeof(float)*4, (void*)(sizeof(float)*2));   
     glEnableClientState(GL_VERTEX_ARRAY);
     glEnableClientState(GL_TEXTURE_COORD_ARRAY);
     g_buf_width  = buf_width;
     g_buf_height = buf_height;
  }
    
   glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
   eglSwapBuffers(g_Display,g_Surface);
   
   pthread_mutex_unlock(&g_mtxGlLock);
}
Ejemplo n.º 10
0
static void text_draw(FT_Face     face,wchar_t * str,RNG_Int width ,RNG_Int height,RNG_Color  color,RNG_Vector offset)
{
	static GLdouble quad[4][2];
	static GLubyte expanded_data [128*128*4];
	static GLfloat textureCoordinates[4][2];
	glTranslated(offset.x,offset.y,0);
	for(int k=0; str[k]!='\0'; k++)
	{
		//对空格进行特殊处理
		if(str[k]==32)
		{
			for(int i =0; i<128*128*4; i++)
			{
				expanded_data[i]=0;
			}
		}
		else
		{
			FT_Load_Glyph( face, FT_Get_Char_Index( face, str[k]), FT_LOAD_DEFAULT );
			FT_Render_Glyph( face->glyph, FT_RENDER_MODE_NORMAL  );
			for(int j=0; j <face->glyph->bitmap.rows; j++)
			{
				for(int i=0; i < face->glyph->bitmap.width; i++)
				{
					if(face->glyph->bitmap.buffer[i + face->glyph->bitmap.width*j])
					{
						expanded_data[4*(i+j*face->glyph->bitmap.width)] = 255;
						expanded_data[4*(i+j*face->glyph->bitmap.width)+1]=255;
						expanded_data[4*(i+j*face->glyph->bitmap.width)+2]=255;
						expanded_data[4*(i+j*face->glyph->bitmap.width)+3]=255;
					}
					else
					{
						expanded_data[4*(i+j*face->glyph->bitmap.width)] = 0;
						expanded_data[4*(i+j*face->glyph->bitmap.width)+1]=0;
						expanded_data[4*(i+j*face->glyph->bitmap.width)+2]=0;
						expanded_data[4*(i+j*face->glyph->bitmap.width)+3]=0;
					}
				}
			}
		}

		//左下
		quad[0][0]=0;
		quad[0][1]=0;
		//右下
		quad[1][0]=width;
		quad[1][1]=0;
		//左上
		quad[2][0]=0;
		quad[2][1]=height;
		//右上
		quad[3][0]=width;
		quad[3][1]=height;
		//左下
		textureCoordinates[0][0]=0;
		textureCoordinates[0][1]=1;
		//右下
		textureCoordinates[1][0]=1;
		textureCoordinates[1][1]=1;

		//左上
		textureCoordinates[2][0]=0;
		textureCoordinates[2][1]=0;

		//右上
		glColor4d(color.red,color.green,color.blue,color.alpha);
		textureCoordinates[3][0]=1;
		textureCoordinates[3][1]=0;
		glBindTexture(GL_TEXTURE_2D,texture);
		glTexImage2D(GL_TEXTURE_2D,0,GL_RGBA,face->glyph->bitmap.width,face->glyph->bitmap.rows,0,GL_RGBA,GL_UNSIGNED_BYTE,expanded_data);
		glTranslatef(width,0,0);
		glTexCoordPointer(2, GL_FLOAT, 0, textureCoordinates);
		glVertexPointer(2,GL_DOUBLE,0,quad);
		glDrawArrays(GL_TRIANGLE_STRIP,0,4);
	}
}
Ejemplo n.º 11
0
void CStatMeshInstance::Draw(unsigned flags)
{
	guard(CStatMeshInstance::Draw);
	int i;

	if (!pMesh->Lods.Num()) return;

	/*const*/ CStaticMeshLod& Mesh = pMesh->Lods[LodNum];	//?? not 'const' because of BuildTangents(); change this?
	int NumSections = Mesh.Sections.Num();
	if (!NumSections || !Mesh.NumVerts) return;

//	if (!Mesh.HasNormals)  Mesh.BuildNormals();
	if (!Mesh.HasTangents) Mesh.BuildTangents();

	// copy of CSkelMeshInstance::Draw sorting code
#if SORT_BY_OPACITY
	// sort sections by material opacity
	int SectionMap[MAX_MESHMATERIALS];
	int secPlace = 0;
	for (int opacity = 0; opacity < 2; opacity++)
	{
		for (i = 0; i < NumSections; i++)
		{
			UUnrealMaterial *Mat = Mesh.Sections[i].Material;
			int op = 0;			// sort value
			if (Mat && Mat->IsTranslucent()) op = 1;
			if (op == opacity) SectionMap[secPlace++] = i;
		}
	}
	assert(secPlace == NumSections);
#endif // SORT_BY_OPACITY

	// draw mesh
	glEnable(GL_LIGHTING);

	glEnableClientState(GL_VERTEX_ARRAY);
	glEnableClientState(GL_TEXTURE_COORD_ARRAY);
	glEnableClientState(GL_NORMAL_ARRAY);

	glVertexPointer(3, GL_FLOAT, sizeof(CStaticMeshVertex), &Mesh.Verts[0].Position);
	glNormalPointer(GL_BYTE, sizeof(CStaticMeshVertex), &Mesh.Verts[0].Normal);
	if (UVIndex == 0)
	{
		glTexCoordPointer(2, GL_FLOAT, sizeof(CStaticMeshVertex), &Mesh.Verts[0].UV.U);
	}
	else
	{
		glTexCoordPointer(2, GL_FLOAT, sizeof(CMeshUVFloat), &Mesh.ExtraUV[UVIndex-1][0].U);
	}

	/*??
		Can move tangent/binormal setup here too, but this will require to force shader to use fixed attribute locations
		(use glBindAttribLocation before glLinkProgram instead of querying atttribute via glGetAtribLocation).
		In this case:
		- can remove GCurrentShader
		- can eliminate hasTangent checks below and always bind attributes (when supports GL2.0)
		- can share code between SkeletalMesh and StaticMesh:
		  - sort sections
		  - setup arrays; differences:
		    - position and normals are taken from different arrays in static and skeletal meshes
		    - ShowInfluences in SkeletalMeshInstance should disable material binding
		  - draw sections using glDrawElements()
		  - un-setup arrays
		  - use VAO+VBO for rendering
	*/

	for (i = 0; i < NumSections; i++)
	{
#if SORT_BY_OPACITY
		int MaterialIndex = SectionMap[i];
#else
		int MaterialIndex = i;
#endif
		const CMeshSection &Sec = Mesh.Sections[MaterialIndex];
		if (!Sec.NumFaces) continue;

		SetMaterial(Sec.Material, MaterialIndex);

		// check tangent space
		GLint aNormal = -1;
		GLint aTangent = -1;
//		GLint aBinormal = -1;
		const CShader *Sh = GCurrentShader;
		if (Sh)
		{
			aNormal    = Sh->GetAttrib("normal");
			aTangent   = Sh->GetAttrib("tangent");
//			aBinormal  = Sh->GetAttrib("binormal");
		}
		if (aNormal >= 0)
		{
			glEnableVertexAttribArray(aNormal);
			// send 4 components to decode binormal in shader
			glVertexAttribPointer(aNormal, 4, GL_BYTE, GL_FALSE, sizeof(CStaticMeshVertex), &Mesh.Verts[0].Normal);
		}
		if (aTangent >= 0)
		{
			glEnableVertexAttribArray(aTangent);
			glVertexAttribPointer(aTangent, 3, GL_BYTE, GL_FALSE, sizeof(CStaticMeshVertex), &Mesh.Verts[0].Tangent);
		}
/*		if (aBinormal >= 0)
		{
			glEnableVertexAttribArray(aBinormal);
			glVertexAttribPointer(aBinormal, 3, GL_BYTE, GL_FALSE, sizeof(CStaticMeshVertex), &Mesh.Verts[0].Binormal);
		} */
		// draw
		//?? place this code into CIndexBuffer?
		if (Mesh.Indices.Is32Bit())
			glDrawElements(GL_TRIANGLES, Sec.NumFaces * 3, GL_UNSIGNED_INT, &Mesh.Indices.Indices32[Sec.FirstIndex]);
		else
			glDrawElements(GL_TRIANGLES, Sec.NumFaces * 3, GL_UNSIGNED_SHORT, &Mesh.Indices.Indices16[Sec.FirstIndex]);

		// disable tangents
		if (aNormal >= 0)
			glDisableVertexAttribArray(aNormal);
		if (aTangent >= 0)
			glDisableVertexAttribArray(aTangent);
//		if (aBinormal >= 0)
//			glDisableVertexAttribArray(aBinormal);
	}

	glDisableClientState(GL_VERTEX_ARRAY);
	glDisableClientState(GL_TEXTURE_COORD_ARRAY);
	glDisableClientState(GL_NORMAL_ARRAY);

	glDisable(GL_LIGHTING);
	BindDefaultMaterial(true);

	// draw mesh normals
	if (flags & DF_SHOW_NORMALS)
	{
		//!! TODO: performance issues when displaying a large mesh (1M+ triangles) with normals/tangents.
		//!! Possible solution:
		//!! 1. use vertex buffer for normals, use single draw call
		//!! 2. cache normal data between render frames
		//!! 3. DecodeTangents() will do Unpack() for normal and tangent too, so this work is duplicated here
		int NumVerts = Mesh.NumVerts;
		glBegin(GL_LINES);
		glColor3f(0.5, 1, 0);
		CVecT tmp, unpacked;
		const float VisualLength = 2.0f;
		for (i = 0; i < NumVerts; i++)
		{
			glVertex3fv(Mesh.Verts[i].Position.v);
			Unpack(unpacked, Mesh.Verts[i].Normal);
			VectorMA(Mesh.Verts[i].Position, VisualLength, unpacked, tmp);
			glVertex3fv(tmp.v);
		}
#if SHOW_TANGENTS
		glColor3f(0, 0.5f, 1);
		for (i = 0; i < NumVerts; i++)
		{
			const CVec3 &v = Mesh.Verts[i].Position;
			glVertex3fv(v.v);
			Unpack(unpacked, Mesh.Verts[i].Tangent);
			VectorMA(v, VisualLength, unpacked, tmp);
			glVertex3fv(tmp.v);
		}
		glColor3f(1, 0, 0.5f);
		for (i = 0; i < NumVerts; i++)
		{
			const CMeshVertex& vert = Mesh.Verts[i];
			// decode binormal
			CVecT normal, tangent, binormal;
			vert.DecodeTangents(normal, tangent, binormal);
			// render
			const CVecT &v = vert.Position;
			glVertex3fv(v.v);
			VectorMA(v, VisualLength, binormal, tmp);
			glVertex3fv(tmp.v);
		}
#endif // SHOW_TANGENTS
		glEnd();
	}

	unguard;
}
Ejemplo n.º 12
0
void CCanvasContext::drawImageBatch(CImage *image, const vector<float> &coords)
{
	//LOG("drawImageBatch: %d", coords.size());
	int count = (int)(coords.size() / 8);
	if( !image || count <= 0 )
		return;

	//glPushMatrix();
	
	glEnable(GL_TEXTURE_2D);
	glBindTexture(GL_TEXTURE_2D, image->getTexture());
	
	if( image->hasAlpha() )
	{
		glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
		glEnable(GL_BLEND);
	}
	else
	{
		glDisable(GL_BLEND);
	}
	
	glEnableClientState(GL_VERTEX_ARRAY);
	glEnableClientState(GL_TEXTURE_COORD_ARRAY);
	
	int vertexCount = count * 6;
	
	static int maxVertex = 100;
	static GLfloat *vertices = NULL;
	static GLfloat *textureCoords = NULL;
	if( !vertices )
	{
		vertices = (GLfloat *) malloc(maxVertex * 2 * sizeof(GLfloat));
	}
	if( !textureCoords )
	{
		textureCoords = (GLfloat *) malloc(maxVertex * 2 * sizeof(GLfloat));
	}
	
	if( vertexCount > maxVertex )
	{
		int newMaxVertex = maxVertex * 2;
		if( vertexCount > newMaxVertex )
		{
			newMaxVertex = vertexCount;
		}
		GLfloat *newVertexBuf = (GLfloat *) malloc(newMaxVertex * 2 * sizeof(GLfloat));
		GLfloat *newTextureCoordBuf = (GLfloat *) malloc(newMaxVertex * 2 * sizeof(GLfloat));
		
		free(vertices);
		free(textureCoords);
		
		vertices = newVertexBuf;
		textureCoords = newTextureCoordBuf;
		maxVertex = newMaxVertex;
	}

	for( int i=0; i<count; i++ )
	{
		float sx = coords[i*8];
		float sy = coords[i*8+1];
		float sw = coords[i*8+2];
		float sh = coords[i*8+3];
		
		float dx = coords[i*8+4];
		float dy = coords[i*8+5];
		float dw = coords[i*8+6];
		float dh = coords[i*8+7];
		
		// 6个点的订单坐标,其中2,3点和4,5点相同
		
		vertices[i*12] = dx;
		vertices[i*12+1] = dy;
		
		vertices[i*12+2] = dx + dw;
		vertices[i*12+3] = dy;
		
		vertices[i*12+4] = dx;
		vertices[i*12+5] = dy + dh;
		
		vertices[i*12+6] = dx + dw;
		vertices[i*12+7] = dy;
		
		vertices[i*12+8] = dx;
		vertices[i*12+9] = dy + dh;
		
		vertices[i*12+10] = dx + dw;
		vertices[i*12+11] = dy + dh;
		
		// 6个点的纹理坐标,其中2,3点和4,5点相同
		unsigned long POTWidth = image->POTWidth();
		unsigned long POTHeight = image->POTHeight();

		textureCoords[i*12] = sx / POTWidth;
		textureCoords[i*12+1] = sy / POTHeight;
		
		textureCoords[i*12+2] = (sx + sw) / POTWidth;
		textureCoords[i*12+3] = sy / POTHeight;
		
		textureCoords[i*12+4] = sx / POTWidth;
		textureCoords[i*12+5] = (sy + sh) / POTHeight;
		
		textureCoords[i*12+6] = (sx + sw) / POTWidth;
		textureCoords[i*12+7] = sy / POTHeight;
		
		textureCoords[i*12+8] = sx / POTWidth;
		textureCoords[i*12+9] = (sy + sh) / POTHeight;
		
		textureCoords[i*12+10] = (sx + sw) / POTWidth;
		textureCoords[i*12+11] = (sy + sh) / POTHeight;
	}

	glVertexPointer(2, GL_FLOAT, 0, vertices);
	glTexCoordPointer(2, GL_FLOAT, 0, textureCoords);
	
	glDrawArrays(GL_TRIANGLES, 0, vertexCount);
	
	//free(vertices);
	//free(textureCoords);
	
	glDisable(GL_VERTEX_ARRAY);
	glDisable(GL_TEXTURE_COORD_ARRAY);
	glDisable(GL_TEXTURE_2D);
	glDisable(GL_BLEND);
	//glPopMatrix();
}
Ejemplo n.º 13
0
Archivo: AEVA.c Proyecto: Oddity007/AE
static inline void AEVABind(const AEVA* va, const AEVA* ia){
	static AEVA lastVA, lastIA, blank;
	
	if(not ia){
		lastIA = blank;
		//glDisableClientState(GL_INDEX_ARRAY);
		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
	}
	else if(not AEVAsAreEqual(ia, & lastIA)){
		//glEnableClientState(GL_INDEX_ARRAY);
		
		if(ia->format.storageType) {
			glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ia->data.vbo);
			IndexOffset=NULL;
		}
		else {
			glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
			IndexOffset=ia->data.pointer;
		}
		
		IndexStride=ia->format.indexType==AEVAFormatIndexType32Bit ? sizeof(GLuint) : sizeof(GLushort);
		
		IndexType=GL_UNSIGNED_SHORT;
		#ifndef AEiOS
		if(ia->format.indexType==AEVAFormatIndexType32Bit) IndexType=GL_UNSIGNED_INT;
		#endif
		lastIA = *ia;
		
		//puts("Binding Indices.");
	}
	
	if(not va or not AEVAsAreEqual(& lastIA, va)){
		for(int i=0;i<lastVA.format.textureCoordsPerVertex;i++){
			glClientActiveTexture(GL_TEXTURE0+i);
			glDisableClientState(GL_TEXTURE_COORD_ARRAY);
		}
		glClientActiveTexture(GL_TEXTURE0);
	
		if(lastVA.format.hasColors) glDisableClientState(GL_COLOR_ARRAY);
	
		if(lastVA.format.hasNormals) glDisableClientState(GL_NORMAL_ARRAY);
	
		glDisableClientState(GL_VERTEX_ARRAY);
		
		lastVA=blank;
		if(not va) return;
		
		lastVA =  *va;
		
		char* offset=NULL;
		if(va->format.storageType) glBindBuffer(GL_ARRAY_BUFFER, va->data.vbo);
		else{
			glBindBuffer(GL_ARRAY_BUFFER, 0);
			offset=va->data.pointer;
		}
		size_t stride=AEVAFormatByteSize(& va->format);
		for(int i=0;i<va->format.textureCoordsPerVertex;i++){
			glClientActiveTexture(GL_TEXTURE0+i);
			glTexCoordPointer(2, GL_FLOAT, stride, offset);
			glEnableClientState(GL_TEXTURE_COORD_ARRAY);
			offset+=sizeof(float[2]); 
		}
		glClientActiveTexture(GL_TEXTURE0);
		if(va->format.hasColors) {
			glEnableClientState(GL_COLOR_ARRAY);
			glColorPointer(4, GL_UNSIGNED_BYTE, stride, offset);
			offset+=sizeof(GLubyte[4]);
		}
		if(va->format.hasNormals){
			glEnableClientState(GL_NORMAL_ARRAY);
			glNormalPointer(GL_FLOAT, stride, offset);
			offset+=sizeof(float[3]);
		}
		glEnableClientState(GL_VERTEX_ARRAY);
		glVertexPointer(3, GL_FLOAT, stride, offset);
		
		//puts("Binding Vertices.");
	}
}
Ejemplo n.º 14
0
void RenderTarget::draw(const Vertex* vertices, unsigned int vertexCount,
                        PrimitiveType type, const RenderStates& states)
{
    // Nothing to draw?
    if (!vertices || (vertexCount == 0))
        return;

    if (activate(true))
    {
        // First set the persistent OpenGL states if it's the very first call
        if (!m_cache.glStatesSet)
            resetGLStates();

        // Check if the vertex count is low enough so that we can pre-transform them
        bool useVertexCache = (vertexCount <= StatesCache::VertexCacheSize);
        if (useVertexCache)
        {
            // Pre-transform the vertices and store them into the vertex cache
            for (unsigned int i = 0; i < vertexCount; ++i)
            {
                Vertex& vertex = m_cache.vertexCache[i];
                vertex.position = states.transform * vertices[i].position;
                vertex.color = vertices[i].color;
                vertex.texCoords = vertices[i].texCoords;
            }

            // Since vertices are transformed, we must use an identity transform to render them
            if (!m_cache.useVertexCache)
                applyTransform(Transform::Identity);
        }
        else
        {
            applyTransform(states.transform);
        }

        // Apply the view
        if (m_cache.viewChanged)
            applyCurrentView();

        // Apply the blend mode
        if (states.blendMode != m_cache.lastBlendMode)
            applyBlendMode(states.blendMode);

        // Apply the texture
        Uint64 textureId = states.texture ? states.texture->m_cacheId : 0;
        if (textureId != m_cache.lastTextureId)
            applyTexture(states.texture);

        // Apply the shader
        if (states.shader)
            applyShader(states.shader);

        // If we pre-transform the vertices, we must use our internal vertex cache
        if (useVertexCache)
        {
            // ... and if we already used it previously, we don't need to set the pointers again
            if (!m_cache.useVertexCache)
                vertices = m_cache.vertexCache;
            else
                vertices = NULL;
        }

        // Setup the pointers to the vertices' components
        if (vertices)
        {
            const char* data = reinterpret_cast<const char*>(vertices);
            glCheck(glVertexPointer(2, GL_FLOAT, sizeof(Vertex), data + 0));
            glCheck(glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(Vertex), data + 8));
            glCheck(glTexCoordPointer(2, GL_FLOAT, sizeof(Vertex), data + 12));
        }

        // Find the OpenGL primitive type
        static const GLenum modes[] = {GL_POINTS, GL_LINES, GL_LINE_STRIP, GL_TRIANGLES,
                                       GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_QUADS};
        GLenum mode = modes[type];

        // Draw the primitives
        glCheck(glDrawArrays(mode, 0, vertexCount));

        // Unbind the shader, if any
        if (states.shader)
            applyShader(NULL);

        // Update the cache
        m_cache.useVertexCache = useVertexCache;
    }
}
Ejemplo n.º 15
0
void GlPolyQuad::draw(float, Camera *) {

  assert(polyQuadEdges.size() % 2 == 0 && polyQuadEdges.size() > 2 && polyQuadEdgesColors.size() == (polyQuadEdges.size() / 2));

  vector<Coord> vertexArray;
  vector<float> texCoordsArray;
  vector<Vector<float, 4> >colorsArray;
  vector<unsigned short> quadIndices;
  vector<unsigned short> outlineIndices;

  unsigned int nbSubdivisionsPerSegment = 1;
  unsigned int nbVertices = polyQuadEdges.size();
  vector<Coord> *vertices = &polyQuadEdges;
  GlShaderProgram *currentShader = GlShaderProgram::getCurrentActiveShader();

  if (currentShader != NULL && currentShader->getName() == "fisheye") {
    nbSubdivisionsPerSegment = 20;
    vertices = &vertexArray;
    nbVertices = ((polyQuadEdges.size() / 2) - 1) * nbSubdivisionsPerSegment * 2;
    vertexArray.reserve(nbVertices);
  }

  texCoordsArray.reserve(nbVertices * 2);
  colorsArray.reserve(nbVertices);
  quadIndices.reserve(nbVertices);
  outlineIndices.resize(nbVertices);

  for (size_t i = 0 ; i < (polyQuadEdges.size() / 2) - 1 ; ++i) {
    Vector<float, 4> startColor;
    Vector<float, 4> endColor;
    startColor[0] = polyQuadEdgesColors[i].getRGL();
    startColor[1] = polyQuadEdgesColors[i].getGGL();
    startColor[2] = polyQuadEdgesColors[i].getBGL();
    startColor[3] = polyQuadEdgesColors[i].getAGL();
    endColor[0] = polyQuadEdgesColors[i+1].getRGL();
    endColor[1] = polyQuadEdgesColors[i+1].getGGL();
    endColor[2] = polyQuadEdgesColors[i+1].getBGL();
    endColor[3] = polyQuadEdgesColors[i+1].getAGL();

    if (nbSubdivisionsPerSegment == 1) {

      texCoordsArray.push_back(static_cast<GLfloat>(i));
      texCoordsArray.push_back(0.0f);
      texCoordsArray.push_back(static_cast<GLfloat>(i));
      texCoordsArray.push_back(1.0f);
      colorsArray.push_back(startColor);
      colorsArray.push_back(startColor);

      quadIndices.push_back(2*i);
      quadIndices.push_back(2*i+1);

      outlineIndices[i] = 2*i;
      outlineIndices[nbVertices - (i+1)] = 2*i+1;

    }
    else {

      for (unsigned int j = 0 ; j < nbSubdivisionsPerSegment ; ++j) {

        unsigned int n = i * nbSubdivisionsPerSegment + j;

        Coord v1 = polyQuadEdges[2*i] + (j / static_cast<float>(nbSubdivisionsPerSegment - 1)) * (polyQuadEdges[2*(i+1)] - polyQuadEdges[2*i]);
        Coord v2 = polyQuadEdges[2*i+1] + (j / static_cast<float>(nbSubdivisionsPerSegment - 1)) * (polyQuadEdges[2*(i+1)+1] - polyQuadEdges[2*i+1]);
        vertexArray.push_back(v1);
        vertexArray.push_back(v2);

        float texCoordFactor = ((polyQuadEdges[2*i].dist(polyQuadEdges[2*i+2])) / (nbSubdivisionsPerSegment - 1)) / (polyQuadEdges[2*i].dist(polyQuadEdges[2*i+1]));
        texCoordsArray.push_back(static_cast<GLfloat>(i) + static_cast<GLfloat>(j) * texCoordFactor);
        texCoordsArray.push_back(0.0f);
        texCoordsArray.push_back(static_cast<GLfloat>(i) + static_cast<GLfloat>(j) * texCoordFactor);
        texCoordsArray.push_back(1.0f);

        Vector<float, 4> color = startColor + (j / static_cast<float>(nbSubdivisionsPerSegment - 1)) * (endColor - startColor);
        colorsArray.push_back(color);
        colorsArray.push_back(color);

        quadIndices.push_back(2*n);
        quadIndices.push_back(2*n+1);

        outlineIndices[n] = 2*n;
        outlineIndices[nbVertices - (n+1)] = 2*n+1;
      }
    }

    if (nbSubdivisionsPerSegment == 1 && i == (polyQuadEdges.size() / 2) - 2) {

      quadIndices.push_back(2*(i+1));
      quadIndices.push_back(2*(i+1)+1);
      outlineIndices[i+1] = 2*(i+1);
      outlineIndices[nbVertices - (i+2)] = 2*(i+1)+1;
      texCoordsArray.push_back(static_cast<GLfloat>(i+1));
      texCoordsArray.push_back(0.0f);
      texCoordsArray.push_back(static_cast<GLfloat>(i+1));
      texCoordsArray.push_back(1.0f);
      colorsArray.push_back(endColor);
      colorsArray.push_back(endColor);

    }

  }

  outlineIndices.push_back(0);

  if (textureName != "") {
    GlTextureManager::getInst().activateTexture(textureName);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
  }

  glDisable(GL_CULL_FACE);

  glDisable(GL_LIGHTING);

  glEnableClientState(GL_VERTEX_ARRAY);
  glEnableClientState(GL_TEXTURE_COORD_ARRAY);
  glEnableClientState(GL_COLOR_ARRAY);

  glVertexPointer(3, GL_FLOAT, 3 * sizeof(float), &((*vertices)[0][0]));
  glTexCoordPointer(2, GL_FLOAT, 2 * sizeof(float), &texCoordsArray[0]);
  glColorPointer(4, GL_FLOAT, 4 * sizeof(float), &colorsArray[0][0]);

  if (nbSubdivisionsPerSegment > 1) {
    glDrawElements(GL_QUAD_STRIP, vertexArray.size(), GL_UNSIGNED_SHORT, &quadIndices[0]);
  }
  else {
    glDrawElements(GL_QUAD_STRIP, polyQuadEdges.size(), GL_UNSIGNED_SHORT, &quadIndices[0]);
  }

  glDisableClientState(GL_TEXTURE_COORD_ARRAY);
  glDisableClientState(GL_COLOR_ARRAY);

  if (textureName != "") {
    GlTextureManager::getInst().desactivateTexture();
  }

  if (outlined) {
    glLineWidth(outlineWidth);
    setMaterial(outlineColor);

    if (nbSubdivisionsPerSegment > 1) {
      glDrawElements(GL_LINE_LOOP, vertexArray.size(), GL_UNSIGNED_SHORT, &outlineIndices[0]);
    }
    else {
      glDrawElements(GL_LINE_LOOP, polyQuadEdges.size(), GL_UNSIGNED_SHORT, &outlineIndices[0]);
    }

    if (outlineWidth != 1) {
      glLineWidth(1);
    }
  }

  glDisableClientState(GL_VERTEX_ARRAY);

  glEnable(GL_CULL_FACE);
  glEnable(GL_LIGHTING);

}
Ejemplo n.º 16
0
void TextButton::render() {
#ifndef OPENBLOX_NO_GRAPHICS
    if(tex == 0) {
        glGenTextures(1, &tex);
    }
    if(Visible) {
        QRectF drawRect = QRectF(QRect(AbsolutePosition->x, AbsolutePosition->y, AbsoluteSize->x, AbsoluteSize->y));
        ob_type::Color3* bgColor = BackgroundColor3;
        ob_type::Color3* borderColor = BorderColor3;
        float bgTrans = BackgroundTransparency;
        double RotationAtRender = Rotation;
        ob_type::Color3* txtColor = TextColor3;

        double halfX = drawRect.x() + (drawRect.width()/2);
        double halfY = drawRect.y() + (drawRect.height()/2);
        glTranslated(halfX, halfY, 0);
        glRotated(RotationAtRender, 0, 0, 1);
        glTranslated(-halfX, -halfY, 0);

        glColor4d(bgColor->r, bgColor->g, bgColor->b, 1 - bgTrans);

        const GLdouble vertices[] {
            drawRect.x(), drawRect.y() + drawRect.height(), //Bottom Left
            drawRect.x(), drawRect.y(), //Top Left
            drawRect.x() + drawRect.width(), drawRect.y(), //Top Right
            drawRect.x() + drawRect.width(), drawRect.y() + drawRect.height(), //Bottom Right
        };

        glEnableClientState(GL_VERTEX_ARRAY);

        glVertexPointer(2, GL_DOUBLE, 0, vertices);
        glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, quad_indices);

        if(needsRecalc) { //Needs to be done on render thread
            needsRecalc = false;
            prepareText(tex, Font, Text, 0, 0, 0, 0, ob_enum::TextXAlignment::Left, ob_enum::TextYAlignment::Top, {255, 255, 255, 255}, NULL, NULL, &tw, &th);
        } else {
            glBindTexture(GL_TEXTURE_2D, tex);
        }

        int tx = drawRect.x();
        int ty = drawRect.y();

        if(TextXAlignment != ob_enum::TextXAlignment::Left && TextYAlignment != ob_enum::TextYAlignment::Top) {
            if(TextXAlignment == ob_enum::TextXAlignment::Center) {
                tx = drawRect.x() + (drawRect.width() / 2) - (tw / 2);
            }
            if(TextXAlignment == ob_enum::TextXAlignment::Right) {
                tx = drawRect.x() + drawRect.width() - tw;
            }
            if(TextYAlignment == ob_enum::TextYAlignment::Center) {
                ty = drawRect.y() + (drawRect.height() / 2) - (th / 2);
            }
            if(TextYAlignment == ob_enum::TextYAlignment::Bottom) {
                ty = drawRect.y() + drawRect.height() - th;
            }
        }

        if(TextYAlignment == ob_enum::TextYAlignment::Top) {
            ty = ty - 6;
        }

        {
            const GLdouble minX = tx;
            const GLdouble maxX = minX + tw;
            const GLdouble minY = ty;
            const GLdouble maxY = minY + th;

            glColor4d(txtColor->r, txtColor->g, txtColor->b, 1 - TextTransparency);

            const GLdouble vertices[] {
                minX, maxY, //Bottom Left
                minX, minY, //Top Left
                maxX, minY, //Top Right
                maxX, maxY, //Bottom Right
            };

            glEnableClientState(GL_TEXTURE_COORD_ARRAY);

            glVertexPointer(2, GL_DOUBLE, 0, vertices);
            glTexCoordPointer(2, GL_FLOAT, 0, quad_texCoords);

            glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, quad_indices);

            glBindTexture(GL_TEXTURE_2D, 0);
            glDisableClientState(GL_TEXTURE_COORD_ARRAY);
        }

        glBindTexture(GL_TEXTURE_2D, 0);

        int bsp = BorderSizePixel;
        if(bsp > 0) {
            const GLdouble line_vertices[] {
                drawRect.x(), drawRect.y() + drawRect.height() + bsp, //Bottom Left
                drawRect.x(), drawRect.y() - bsp, //Top Left
                drawRect.x() + drawRect.width() + bsp, drawRect.y(), //Top Right
                drawRect.x() + drawRect.width(), drawRect.y() + drawRect.height() + bsp, //Bottom Right
                drawRect.x() - bsp, drawRect.y(), //Top Left Second Pass
                drawRect.x() + drawRect.width(), drawRect.y() - bsp, //Top Right Second Pass,
                drawRect.x() + drawRect.width() + bsp, drawRect.y() + drawRect.height(), //Bottom Right Second Pass
                drawRect.x() - bsp, drawRect.y() + drawRect.height()
            };
            glVertexPointer(2, GL_DOUBLE, 0, line_vertices);

            glColor4d(borderColor->r, borderColor->g, borderColor->b, 1 - bgTrans);

            glLineWidth(bsp);

            glDrawElements(GL_LINES, 8, GL_UNSIGNED_BYTE, quad_lines);
        }

        glDisableClientState(GL_VERTEX_ARRAY);

        std::vector<GuiObject*> toRender;
        for(std::vector<Instance*>::size_type i = 0; i != children.size(); i++) {
            Instance* kid = children[i];
            if(kid) {
                if(GuiObject* go = dynamic_cast<GuiObject*>(kid)) {
                    toRender.push_back(go);
                }
            }
        }
        std::sort(toRender.begin(), toRender.end(), [](GuiObject* go1, GuiObject* go2)->bool{
            return go1->getZIndex() < go2->getZIndex();
        });
        for(std::vector<GuiObject*>::size_type i = 0; i != toRender.size(); i++) {
            GuiObject* kid = toRender[i];
            if(kid) {
                kid->render();
            }
        }

        glTranslated(halfX, halfY, 0);
        glRotated(-RotationAtRender, 0, 0, 1);
        glTranslated(-halfX, -halfY, 0);
    }
#endif
}
Ejemplo n.º 17
0
void RenderGPUGeometry( struct GPUGeometry * g )
{
	struct VertexData ** vd  = g->vertexdatas;
	char ** names = g->names;
	int NumVertexSets = g->vertexcount;
	struct IndexData * id = g->indices;

	int i;
	int tcarrayset = 0;
	int normalarrayset = 0;
	int colorarrayset = 0;

	//Can't render.
	if( !vd[0] ) return;
	if( !(vd[0]->vbo) ) return;

	for( i = 0; i < MAX_TEXTURES; i++ )
	{
		if( g->textures[i] )
		{
			ActivateTexture( g->textures[i] );
		}
	}

	for( i = 1; i < NumVertexSets; ++i )
	{
		const char * name = names[i];

		if( !vd[i] ) continue;
		if( !vd[i]->vbo ) continue;

		glBindBufferARB( GL_ARRAY_BUFFER_ARB, vd[i]->vbo );

		if( strcmp( name, "texture" ) == 0 )
		{
		    glEnableClientState( GL_TEXTURE_COORD_ARRAY );
			glTexCoordPointer( vd[i]->stride, GL_FLOAT, 0, 0 );
			tcarrayset = 1;
		}
		else if( strcmp( name, "color" ) == 0 )
		{
		    glEnableClientState( GL_COLOR_ARRAY );
			glColorPointer( vd[i]->stride, GL_FLOAT, 0, 0 );
			colorarrayset = 1;
		}
		else if( strcmp( name, "normal" ) == 0 )
		{
		    glEnableClientState( GL_NORMAL_ARRAY );
			glNormalPointer( GL_FLOAT, vd[i]->stride*4, 0 );
			normalarrayset = 1;
		}
		else if( CurrentShader )
		{
			int iTexPosID = glGetAttribLocationARB( CurrentShader->program, name );
			glEnableVertexAttribArrayARB( iTexPosID );
			glVertexAttribPointerARB( iTexPosID, vd[i]->stride, GL_FLOAT, 0, 0, 0 );
		}
	}

	glBindBufferARB( GL_ARRAY_BUFFER_ARB, vd[0]->vbo );
	glVertexPointer( vd[0]->stride, GL_FLOAT, 0, 0 );

#ifdef USE_IBO
	glEnableClientState( GL_VERTEX_ARRAY );
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, id->ido);
	glDrawElements(GL_TRIANGLES, id->indexcount, GL_UNSIGNED_INT, 0);
	glDisableClientState( GL_VERTEX_ARRAY );
#else
	glEnableClientState( GL_VERTEX_ARRAY );
	glDrawElements( g->mode, id->indexcount, GL_UNSIGNED_INT, id->indexdata );
	glDisableClientState( GL_VERTEX_ARRAY );
#endif

	if( tcarrayset )
	{
	    glDisableClientState( GL_TEXTURE_COORD_ARRAY );
	}

	if( colorarrayset )
	{
	    glDisableClientState( GL_COLOR_ARRAY );
	}

	if( normalarrayset )
	{
		glDisableClientState( GL_NORMAL_ARRAY );
	}

	for( i = 0; i < MAX_TEXTURES; i++ )
	{
		if( g->textures[i] )
		{
			DeactivateTexture( g->textures[i] );
		}
	}

}
Ejemplo n.º 18
0
int main(int argc, char *argv[])
{
    SDL_Surface *screen;
    if ( SDL_Init(SDL_INIT_VIDEO) != 0 ) {
        printf("Unable to initialize SDL: %s\n", SDL_GetError());
        return 1;
    }

    SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
    screen = SDL_SetVideoMode( 640, 480, 24, SDL_OPENGL );
    if ( !screen ) {
        printf("Unable to set video mode: %s\n", SDL_GetError());
        return 1;
    }
    
    glClearColor( 0, 0, 0, 0 );
    glClear( GL_COLOR_BUFFER_BIT );

    // Create a texture

    GLuint texture;
    glGenTextures( 1, &texture );
    glBindTexture( GL_TEXTURE_2D, texture );
    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
    GLubyte textureData[16*16*4];
    for (int x = 0; x < 16; x++) {
      for (int y = 0; y < 16; y++) {
        *((int*)&textureData[(x*16 + y) * 4]) = x*16 + ((y*16) << 8);
      }
    }
    glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0,
                  GL_RGBA, GL_UNSIGNED_BYTE, textureData );

    // Create a second texture

    GLuint texture2;
    glGenTextures( 1, &texture2 );
    glBindTexture( GL_TEXTURE_2D, texture2 );
    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
    GLubyte texture2Data[] = { 0xff,    0,    0, 0xff,
                                  0, 0xff,    0, 0xaa,
                                  0,    0, 0xff, 0x55,
                               0x80, 0x90, 0x70,    0 };
    glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0,
                  GL_RGBA, GL_UNSIGNED_BYTE, texture2Data );
    
    // BEGIN

#if USE_GLEW
    glewInit();
#endif

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    // original: glFrustum(-0.6435469817188064, 0.6435469817188064 ,-0.48266022190470925, 0.48266022190470925 ,0.5400000214576721, 2048);
    //glFrustum(-0.6435469817188064, 0.1435469817188064 ,-0.48266022190470925, 0.88266022190470925 ,0.5400000214576721, 2048);
    GLfloat pm[] = { 1.372136116027832, 0, 0, 0, 0, 0.7910231351852417, 0, 0, -0.6352481842041016, 0.29297152161598206, -1.0005275011062622, -1, 0, 0, -1.080284833908081, 0 };
    glLoadMatrixf(pm);

    glMatrixMode(GL_MODELVIEW);
    GLfloat matrixData[] = { -1, 0, 0, 0,
                              0, 0,-1, 0,
                              0, 1, 0, 0,
                              0, 0, 0, 1 };
    glLoadMatrixf(matrixData);
    //glTranslated(-512,-512,-527); // XXX this should be uncommented, but if it is then nothing is shown

//    glEnable(GL_CULL_FACE);
  //  glEnable(GL_DEPTH_TEST);

    //glClear(GL_DEPTH_BUFFER_BIT);

//    glEnableClientState(GL_NORMAL_ARRAY);
  //  glEnableClientState(GL_COLOR_ARRAY);
    glEnableClientState(GL_TEXTURE_COORD_ARRAY);

    glActiveTexture(GL_TEXTURE0);

    glEnableClientState(GL_VERTEX_ARRAY);

    GLuint arrayBuffer, elementBuffer;
    glGenBuffers(1, &arrayBuffer);
    glGenBuffers(1, &elementBuffer);

    GLubyte arrayData[] = {
/*
[0, 0,   0, 67] ==>  128 float
[0, 0, 128, 67] ==>  256 float
[0, 0,   0, 68] ==>  512 float
[0, 0, 128, 68] ==> 1024 float

[vertex x        ] [vertex y         ] [vertex z         ] [nr]                [texture u        ] [texture v        ] [lm u   ] [lm v   ] [color r,g,b,a    ] */
  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 128, 128, 128, 128, //  0
  0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,  67,   0,   0,   0,   0,   0,   0,   0,   0, 128, 128, 128, 128, //  1
  0,   0,   0,  68,   0,   0,   0,  68,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,  67,   0,   0,   0,  67,   0,   0,   0,   0, 128, 128, 128, 128, //  2
  0,   0,   0,   0,   0,   0,   0,  68,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,  67,   0,   0,   0,   0, 128, 128, 128, 128, //  3
  0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,  67,   0,   0,   0,   0,   0,   0,   0,   0, 128, 128, 128, 128, //  4
  0,   0, 128,  68,   0,   0,   0,   0,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0, 128,  67,   0,   0,   0,   0,   0,   0,   0,   0, 128, 128, 128, 128, //  5
  0,   0, 128,  68,   0,   0,   0,  68,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0, 128,  67,   0,   0,   0,  67,   0,   0,   0,   0, 128, 128, 128, 128, //  6
  0,   0,   0,  68,   0,   0,   0,  68,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,  67,   0,   0,   0,  67,   0,   0,   0,   0, 128, 128, 128, 128, //  7
  0,   0,   0,   0,   0,   0,   0,  68,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,  67,   0,   0,   0,   0, 128, 128, 128, 128, //  8
  0,   0,   0,  68,   0,   0,   0,  68,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,  67,   0,   0,   0,  67,   0,   0,   0,   0, 128, 128, 128, 128, //  9
  0,   0,   0,  68,   0,   0, 128,  68,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,  67,   0,   0, 128,  67,   0,   0,   0,   0, 128, 128, 128, 128, // 10
  0,   0,   0,   0,   0,   0, 128,  68,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 128,  67,   0,   0,   0,   0, 128, 128, 128, 128, // 11
  0,   0,   0,  68,   0,   0,   0,  68,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,  67,   0,   0,   0,  67,   0,   0,   0,   0, 128, 128, 128, 128, // 12
  0,   0, 128,  68,   0,   0,   0,  68,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0, 128,  67,   0,   0,   0,  67,   0,   0,   0,   0, 128, 128, 128, 128, // 13
  0,   0, 128,  68,   0,   0, 128,  68,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0, 128,  67,   0,   0, 128,  67,   0,   0,   0,   0, 128, 128, 128, 128, // 14
  0,   0,   0,  68,   0,   0, 128,  68,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,  67,   0,   0, 128,  67,   0,   0,   0,   0, 128, 128, 128, 128, // 15

  0,   0,   0,  68,   0,   0,   0,  68,   0,   0, 128,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 128, 128, 128, 128,
  0,   0,   0,  68,   0,   0,   0,   0,   0,   0, 128,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 128, 128, 128, 128,
  0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 128, 128, 128, 128,
  0,   0,   0,  68,   0,   0,   0,  68,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 128, 128, 128, 128,
  0,   0,   0,   0,   0,   0,   0,  68,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 128, 128, 128, 128,
  0,   0,   0,   0,   0,   0,   0,  68,   0,   0, 128,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 128, 128, 128, 128,
  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 128, 128, 128, 128,
  0,   0,   0,  68,   0,   0,   0,  68,   0,   0, 128,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 128, 128, 128, 128,
  0,   0,   0,  68,   0,   0,   0,  68,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 128, 128, 128, 128,
  0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 128, 128, 128, 128,
  0,   0,   0,  68,   0,   0,   0,   0,   0,   0, 128,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 128, 128, 128, 128,
  0,   0, 128,  68,   0,   0,   0,  68,   0,   0, 128,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 128, 128, 128, 128,
  0,   0, 128,  68,   0,   0,   0,  68,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 128, 128, 128, 128,
  0,   0, 128,  68,   0,   0,   0,   0,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 128, 128, 128, 128,
  0,   0,   0,  68,   0,   0, 128,  68,   0,   0, 128,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 128, 128, 128, 128,
  0,   0,   0,  68,   0,   0,   0,  68,   0,   0, 128,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 128, 128, 128, 128,
  0,   0,   0,  68,   0,   0,   0,  68,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 128, 128, 128, 128,
  0,   0,   0,  68,   0,   0, 128,  68,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 128, 128, 128, 128,
  0,   0,   0,   0,   0,   0,   0,  68,   0,   0, 128,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 128, 128, 128, 128,
  0,   0,   0,   0,   0,   0,   0,  68,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 128, 128, 128, 128,
  0,   0,   0,   0,   0,   0, 128,  68,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 128, 128, 128, 128,
  0,   0,   0,  68,   0,   0, 128,  68,   0,   0, 128,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 128, 128, 128, 128,
  0,   0,   0,  68,   0,   0, 128,  68,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 128, 128, 128, 128,
  0,   0,   0,  68,   0,   0,   0,  68,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 128, 128, 128, 128,
  0,   0,   0,  68,   0,   0,   0,  68,   0,   0, 128,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 128, 128, 128, 128,
  0,   0, 128,  68,   0,   0,   0,  68,   0,   0, 128,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 128, 128, 128, 128,
  0,   0, 128,  68,   0,   0,   0,  68,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 128, 128, 128, 128,
  0,   0, 128,  68,   0,   0, 128,  68,   0,   0,   0,  68,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 128, 128, 128, 128
    };
    assert(sizeof(arrayData) == 1408);
    glBindBuffer(GL_ARRAY_BUFFER, arrayBuffer);
    glBufferData(GL_ARRAY_BUFFER, sizeof(arrayData), arrayData, GL_STATIC_DRAW);
    glBindBuffer(GL_ARRAY_BUFFER, 0);

    GLushort elementData[] = { 1, 2, 0, 2, 3, 0, 5, 6, 4, 6, 7, 4, 9, 10, 8, 10, 11, 8, 13, 14, 12, 14, 15, 12 };
    assert(sizeof(elementData) == 48);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementBuffer);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(elementData), elementData, GL_STATIC_DRAW);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

    glBindBuffer(GL_ARRAY_BUFFER, arrayBuffer);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementBuffer);

    // sauer vertex data is apparently 0-12: V3F, 12: N1B, 16-24: T2F, 24-28: T2S, 28-32: C4B
    glVertexPointer(3, GL_FLOAT, 32, (void*)0); // all these apply to the ARRAY_BUFFER that is bound
    glTexCoordPointer(2, GL_FLOAT, 32, (void*)16);
//    glClientActiveTexture(GL_TEXTURE1); // XXX seems to be ignored in native build
//    glTexCoordPointer(2, GL_SHORT, 32, (void*)24);
//    glClientActiveTexture(GL_TEXTURE0); // likely not needed, it is a cleanup
//    glNormalPointer(GL_BYTE, 32, (void*)12);
//    glColorPointer(4, GL_UNSIGNED_BYTE, 32, (void*)28);

    glBindTexture(GL_TEXTURE_2D, texture); // diffuse?
    glActiveTexture(GL_TEXTURE0);
    glActiveTexture(GL_TEXTURE1);
    glBindTexture(GL_TEXTURE_2D, texture2); // lightmap?
    glActiveTexture(GL_TEXTURE0);

    GLint ok;

    const char *vertexShader = "uniform mat4 u_modelView;\n"
                               "uniform mat4 u_projection;\n"
                               "varying vec4 v_texCoord0;\n"
                               "void main(void)\n"
                               "{\n" // (gl_ProjectionMatrix * gl_ModelViewMatrix * gl_Vertex)
                                     // (u_projection * u_modelView * a_position)
                               "    gl_Position = (u_projection * u_modelView * gl_Vertex) + vec4(200, 0, 0, 0);\n"
                               "    v_texCoord0.xy = gl_MultiTexCoord0.xy/20.0;\n" // added /100 here
                               "}\n";
    const char *fragmentShader = "uniform sampler2D diffusemap;\n"
                                 "varying vec4 v_texCoord0;\n"
                                 "void main(void)\n"
                                 "{\n"
                                 "    vec4 diffuse = texture2D(diffusemap, v_texCoord0.xy);\n"
                                 "    gl_FragColor = diffuse;\n"
                                 "}\n";

    GLuint vs = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(vs, 1, &vertexShader, NULL);
    glCompileShader(vs);
    glGetShaderiv(vs, GL_COMPILE_STATUS, &ok);
    if (!ok) {
      printf("Shader compilation error with vertex\n");
      GLint infoLen = 0;
      glGetShaderiv (vs, GL_INFO_LOG_LENGTH, &infoLen);
      if (infoLen > 1)
      {
         char* infoLog = (char *)malloc(sizeof(char) * infoLen+1);
         glGetShaderInfoLog(vs, infoLen, NULL, infoLog);
         printf("Error compiling shader:\n%s\n", infoLog);            
      }
    }

    GLuint fs = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fs, 1, &fragmentShader, NULL);
    glCompileShader(fs);
    glGetShaderiv(fs, GL_COMPILE_STATUS, &ok);
    if (!ok) {
      printf("Shader compilation error with fragment\n");
      GLint infoLen = 0;
      glGetShaderiv (vs, GL_INFO_LOG_LENGTH, &infoLen);
      if (infoLen > 1)
      {
         char* infoLog = (char *)malloc(sizeof(char) * infoLen+1);
         glGetShaderInfoLog(vs, infoLen, NULL, infoLog);
         printf("Error compiling shader:\n%s\n", infoLog);            
      }
    }

    GLuint program = glCreateProgram();

    glAttachShader(program, vs);
    glAttachShader(program, fs);
    glLinkProgram(program);
    glGetProgramiv(program, GL_LINK_STATUS, &ok);
    assert(ok);

    glUseProgram(program);

    //GLint lightmapLocation = glGetUniformLocation(program, "lightmap");
    //assert(lightmapLocation >= 0);
    //glUniform1i(lightmapLocation, 1); // sampler2D? Is it the texture unit?

    GLint diffusemapLocation = glGetUniformLocation(program, "diffusemap");
    assert(diffusemapLocation >= 0);
    glUniform1i(diffusemapLocation, 0);

    //GLint texgenscrollLocation = glGetUniformLocation(program, "texgenscroll");
    //assert(texgenscrollLocation >= 0);

    //GLint colorparamsLocation = glGetUniformLocation(program, "colorparams");
    //assert(colorparamsLocation >= 0);

    //GLfloat texgenscrollData[] = { 0, 0, 0, 0 };
    //glUniform4fv(texgenscrollLocation, 1, texgenscrollData);

    //GLfloat colorparamsData[] = { 2, 2, 2, 1 };
    //glUniform4fv(colorparamsLocation, 1, colorparamsData);

    {
      GLfloat data[16];
      glGetFloatv(GL_MODELVIEW_MATRIX, data);
      printf("Modelview: ");
      for (int i = 0; i < 16; i++) printf("%.3f, ", data[i]);
      printf("\n");
      //memset(data, 0, 16*4);
      GLint modelViewLocation = glGetUniformLocation(program, "u_modelView");
      assert(modelViewLocation >= 0);
      glUniformMatrix4fv(modelViewLocation, 1, GL_FALSE, data);
    }
    {
      GLfloat data[16];
      glGetFloatv(GL_PROJECTION_MATRIX, data);
      printf("Projection: ");
      for (int i = 0; i < 16; i++) printf("%.3f, ", data[i]);
      printf("\n");
      //memset(data, 0, 16*4);
      GLint projectionLocation = glGetUniformLocation(program, "u_projection");
      assert(projectionLocation >= 0);
      glUniformMatrix4fv(projectionLocation, 1, GL_FALSE, data);
    }

/*
    glBindAttribLocation(program, 0, "a_position");
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 32, (void*)0);
    glEnableVertexAttribArray(0);

    glBindAttribLocation(program, 1, "v_texCoord0");
    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 32, (void*)16);
    glEnableVertexAttribArray(1);
*/

    glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, (void*)12);
    glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, (void*) 0);
    glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, (void*)24);
    glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, (void*)36);

    // END

    SDL_GL_SwapBuffers();
  
#if !EMSCRIPTEN
    SDL_Delay(1500);
#endif

 //   SDL_Quit();
    
    return 0;
}
Ejemplo n.º 19
0
void PhatPlane::Render(PhatContext *context, PhatTexture *texture) {
    bool drawit = true;

    /*
     switch(pinningType) {
     default:
     case PT_TOPLEFT: {
     if((position.x*scale.x*_screenscale.x > -size.x*scale.x*_screenscale.x) && (position.x*scale.x*_screenscale.x < _visiblearea.x*scale.x*_screenscale.x)) {
     if((position.y*scale.y*_screenscale.y > -size.y*scale.y*_screenscale.y) && (position.y*scale.y*_screenscale.y < _visiblearea.y*scale.y*_screenscale.y)) {
     drawit = true;
     }
     }
     }break;
     case PT_CENTER: {
     if((position.x*scale.x*_screenscale.x > -(size.x/2.0)*scale.x*_screenscale.x) && (position.x*scale.x*_screenscale.x < _visiblearea.x+(size.x/2.0)*scale.x*_screenscale.x)) {
     if((position.y*scale.y*_screenscale.y > -(size.y/2.0)*scale.y*_screenscale.y) && (position.y*scale.y*_screenscale.y < _visiblearea.y+(size.y/2.0)*scale.y*_screenscale.y)) {
     drawit = true;
     }
     }
     }break;
     }
     */
    
    if (Colour.a <= 0.0f) {
        drawit = false;
    }
    
	if(drawit) {
		glLoadIdentity();
        
		//Translation
        glTranslatef((Position.x-Pivot.x)*context->Scaling.x, (Position.y-Pivot.y)*context->Scaling.y, 0.0);
        //glTranslatef(0.0f, 0.0f, 0.0f);
		
		//Rotation
		glRotatef(Rotation.z, 0.0, 0.0, 1.0);
        glRotatef(Rotation.y, 0.0, 1.0, 0.0);
        glRotatef(Rotation.x, 1.0, 0.0, 0.0);
        
		//Scaling
		glScalef(Scaling.x, Scaling.y, Scaling.z);
		
		//Coloring
		glColor4f(Colour.r, Colour.g, Colour.b, Colour.a);
        
        //Blending
        glEnable(GL_BLEND);
        glDisable(GL_DEPTH_TEST);
        switch (Blendmode) {
            default:
            case NORMAL:    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);  break;
            case NORMAL_ONE:glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);        break;
            case GROW:      glBlendFunc(GL_SRC_ALPHA, GL_DST_ALPHA);            break;
            case GROW_TEST: glBlendFunc(GL_DST_ALPHA, GL_ONE_MINUS_SRC_ALPHA);  break;
        }
        
        if(texture) {
            glEnable(GL_TEXTURE_2D);
            glBindTexture(GL_TEXTURE_2D, texture->TextureID);
        }else {
            glDisable(GL_TEXTURE_2D);
        }
        
		GLfloat squareVertices[] = {
            -(Size.x/2.0f)*Scaling.x, -(Size.y/2.0f)*Scaling.y,
			 (Size.x/2.0f)*Scaling.x, -(Size.y/2.0f)*Scaling.y,
            -(Size.x/2.0f)*Scaling.x,  (Size.y/2.0f)*Scaling.y,
			 (Size.x/2.0f)*Scaling.x,  (Size.y/2.0f)*Scaling.y,
		};
        
		GLfloat normals[] = {
			0.0, 0.0, 1.0,
			0.0, 0.0, 1.0,
			0.0, 0.0, 1.0,
			0.0, 0.0, 1.0
		};
        
		GLfloat texCoords[] = {
            0.0f, 1.0f,
            1.0f, 1.0f,
            0.0f, 0.0f,
            1.0f, 0.0f
        };
		if(texture) {
            texture->PhatPlane_CropForAnimation();
            if (texture->TexFlip.x) {
                texCoords[0] = texture->TexCoord[1].x;
                texCoords[2] = texture->TexCoord[0].x;
                texCoords[4] = texture->TexCoord[3].x;
                texCoords[6] = texture->TexCoord[2].x;
            }else {
                texCoords[0] = texture->TexCoord[0].x;
                texCoords[2] = texture->TexCoord[1].x;
                texCoords[4] = texture->TexCoord[2].x;
                texCoords[6] = texture->TexCoord[3].x;
            }
            if (texture->TexFlip.y) { 
                texCoords[1] = texture->TexCoord[2].y;
				texCoords[3] = texture->TexCoord[3].y;
				texCoords[5] = texture->TexCoord[0].y;
				texCoords[7] = texture->TexCoord[1].y;
            }else {
				texCoords[1] = texture->TexCoord[0].y;
				texCoords[3] = texture->TexCoord[1].y;
				texCoords[5] = texture->TexCoord[2].y;
				texCoords[7] = texture->TexCoord[3].y;
            }
		}
        
		glEnableClientState(GL_VERTEX_ARRAY);
		glEnableClientState(GL_NORMAL_ARRAY);
		
		glVertexPointer(2, GL_FLOAT, 0, squareVertices);
		glNormalPointer(GL_FLOAT, 0, normals);
        
		if(texture) {
			glEnableClientState(GL_TEXTURE_COORD_ARRAY);
			glTexCoordPointer(2, GL_FLOAT, 0, texCoords);
		}
         
		glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
        
		glDisableClientState(GL_VERTEX_ARRAY);
		glDisableClientState(GL_NORMAL_ARRAY);
		glDisableClientState(GL_TEXTURE_COORD_ARRAY);
        
		glDisable(GL_BLEND);
		glEnable(GL_DEPTH_TEST);
	}
    
}
Ejemplo n.º 20
0
void nuiGLPainter::DrawArray(nuiRenderArray* pArray)
{
  mRenderOperations++;
  mBatches++;

  //glEnable(GL_TEXTURE_2D);
  //glEnable(GL_TEXTURE_2D);

  if (!mEnableDrawArray)
  {
    pArray->Release();
    return;
  }
 
  static uint32 ops = 0;
  static uint32 skipped_ops = 0;
  
  ops++;
  const nuiMatrix& rM(mMatrixStack.top());
  float bounds[6];
  pArray->GetBounds(bounds);

  if (rM.Elt.M11 == 1.0f
   && rM.Elt.M22 == 1.0f
   && rM.Elt.M33 == 1.0f
   && rM.Elt.M44 == 1.0f
   
   && rM.Elt.M12 == 0.0f
   && rM.Elt.M13 == 0.0f
      //&& rM.Elt.M14 == 0.0f
   
   && rM.Elt.M21 == 0.0f
   && rM.Elt.M23 == 0.0f
      //&& rM.Elt.M24 == 0.0f
   
   && rM.Elt.M31 == 0.0f
   && rM.Elt.M32 == 0.0f
   && rM.Elt.M34 == 0.0f
   
   && rM.Elt.M41 == 0.0f
   && rM.Elt.M42 == 0.0f
   && rM.Elt.M43 == 0.0f)
  {
    bounds[0] += rM.Elt.M14;
    bounds[1] += rM.Elt.M24;
    //bounds[2] += rM.Elt.M34;
    bounds[3] += rM.Elt.M14;
    bounds[4] += rM.Elt.M24;
    //bounds[5] += rM.Elt.M34;
    
    if (
        (bounds[0] > mClip.Right()) ||
        (bounds[1] > mClip.Bottom()) ||
        (bounds[3] < mClip.Left()) ||
        (bounds[4] < mClip.Top())
        )
    {
      skipped_ops++;
      
//      #ifdef _DEBUG
//      if (!(skipped_ops % 100))
//        printf("optim (%d / %d) - %2.2f%%\n", skipped_ops, ops, (float)skipped_ops * 100.0f / (float)ops);
//      #endif
      
      return;
    }
  }
//  else
//  {
//    nglVectorf v1(bounds[0], bounds[1], 0); // topleft(x, y)
//    nglVectorf v2(bounds[3], bounds[4], 0); // bottomright(x, y)
//    v1 = rM * v1;
//    v2 = rM * v2;
//    
//    if (
//        (v1[0] > mClip.Right()) ||
//        (v1[1] > mClip.Bottom()) ||
//        (v2[0] < mClip.Left()) ||
//        (v2[1] < mClip.Top())
//       )
//    {
//      return;
//    }
//  }
  
  uint32 s = pArray->GetSize();
  
  total += s;
  totalinframe += s;
  mins = MIN(mins, s);
  maxs = MAX(maxs, s);
  //printf("DA (%d) min = %d  max = %d\n", s, mins, maxs);
  
  if (!s)
  {
    pArray->Release();
    return;
  }
  
  if (mClip.GetWidth() <= 0 || mClip.GetHeight() <= 0)
  {
    pArray->Release();
    return;
  }
  
  mVertices += s;
  GLenum mode = pArray->GetMode();
  //NGL_OUT(_T("GL Array Mode: %d   vertice count %d\n"), mode, size);

/*
  switch (pArray->GetMode())
  {
  LOGENUM(GL_POINTS);
  LOGENUM(GL_LINES);
  LOGENUM(GL_LINE_LOOP);
  LOGENUM(GL_LINE_STRIP);
  //LOGENUM(GL_TRIANGLES);
  LOGENUM(GL_TRIANGLE_STRIP);
  LOGENUM(GL_TRIANGLE_FAN);
  //LOGENUM(GL_QUADS);
  LOGENUM(GL_QUAD_STRIP);
  LOGENUM(GL_POLYGON);
  }
*/


  NUI_RETURN_IF_RENDERING_DISABLED;

  bool NeedTranslateHack = pArray->IsShape() || ((mode == GL_POINTS || mode == GL_LINES || mode == GL_LINE_LOOP || mode == GL_LINE_STRIP) && !pArray->Is3DMesh());
  float hackX;
  float hackY;
  if (NeedTranslateHack)
  {
    const float ratio=0.5f;
#ifdef _UIKIT_
    hackX = ratio;
    hackY = ratio;
#else
    if (mAngle == 0)
    {
      hackX = ratio;
      hackY = ratio;
    }
    else if (mAngle == 90)
    {
      hackX = 0;
      hackY = ratio;
    }
    else if (mAngle == 180)
    {
      hackX = 0;
      hackY = 0;
    }
    else/*mAngle == 270*/
    {
      hackX = ratio;
      hackY = 0;
    }
#endif
    glTranslatef(hackX, hackY, 0);
  }


#ifdef NUI_USE_ANTIALIASING
  if (mState.mAntialiasing)
  {
#ifdef NUI_USE_MULTISAMPLE_AA
    glHint(GL_MULTISAMPLE_FILTER_HINT_NV, GL_NICEST);
    glEnable(GL_MULTISAMPLE_ARB);
    nuiCheckForGLErrors();
#else
    glEnable(GL_POLYGON_SMOOTH);
    glEnable(GL_BLEND);
    BlendFuncSeparate(GL_SRC_ALPHA_SATURATE, GL_ONE);
    nuiCheckForGLErrors();
#endif
  }
#endif // NUI_USE_ANTIALIASING

  if (pArray->IsArrayEnabled(nuiRenderArray::eVertex))
  {
    glEnableClientState(GL_VERTEX_ARRAY);
    glVertexPointer(3, GL_FLOAT, sizeof(nuiRenderArray::Vertex), &pArray->GetVertices()[0].mX);
    nuiCheckForGLErrors();
  }
  else
    glDisableClientState(GL_VERTEX_ARRAY);

  if (pArray->IsArrayEnabled(nuiRenderArray::eColor))
  {
    glEnableClientState(GL_COLOR_ARRAY);
    glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(nuiRenderArray::Vertex), &pArray->GetVertices()[0].mR);
    nuiCheckForGLErrors();
  }
  else
  {
    glDisableClientState(GL_COLOR_ARRAY);
    nuiColor c;
    switch (pArray->GetMode())
    {
    case GL_POINTS:
    case GL_LINES:
    case GL_LINE_LOOP:
    case GL_LINE_STRIP:
      c = mState.mStrokeColor;
      break;

    case GL_TRIANGLES:
    case GL_TRIANGLE_STRIP:
    case GL_TRIANGLE_FAN:
#ifndef _OPENGL_ES_
    case GL_QUADS:
    case GL_QUAD_STRIP:
    case GL_POLYGON:
#endif
      c = mState.mFillColor;
      break;
    }
    glColor4f(c.Red(), c.Green(), c.Blue(), c.Alpha());
    nuiCheckForGLErrors();
  }

  if (pArray->IsArrayEnabled(nuiRenderArray::eTexCoord))
  {
    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
    glTexCoordPointer(2, GL_FLOAT, sizeof(nuiRenderArray::Vertex), &pArray->GetVertices()[0].mTX);
    nuiCheckForGLErrors();
  }
  else
  {
    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
  }
  //glDisableClientState(GL_COLOR_ARRAY);
  //glColor4f(0.5,0.5,0.5,0.5);
  
/*
  if (pArray->IsArrayEnabled(nuiRenderArray::eNormal))
  {
    glEnableClientState(GL_NORMAL_ARRAY);
    glNormalPointer(GL_FLOAT, sizeof(nuiRenderArray::Vertex)-12, &pArray->GetVertices()[0].mNX);
    nuiCheckForGLErrors();
  }
  else
    glDisableClientState(GL_NORMAL_ARRAY);
*/

/*
  if (pArray->IsArrayEnabled(nuiRenderArray::eEdgeFlag))
  {
    glEnableClientState(GL_EDGE_FLAG_ARRAY);
    glEdgeFlagPointer(sizeof(nuiRenderArray::Vertex), &pArray->GetVertices()[0].mEdgeFlag);
    nuiCheckForGLErrors();
  }
  else
    glDisableClientState(GL_EDGE_FLAG_ARRAY);
*/
  
  nuiCheckForGLErrors();

  if (mpSurface && mTwoPassBlend)
  {
    glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_FALSE);
    uint32 arraycount = pArray->GetIndexArrayCount();
    
    if (!arraycount)
    {
      glDrawArrays(mode, 0, s);
    }
    else
    {
      for (uint32 i = 0; i < arraycount; i++)
      {
        nuiRenderArray::IndexArray& array(pArray->GetIndexArray(i));
#ifdef _UIKIT_
        glDrawElements(array.mMode, array.mIndices.size(), GL_UNSIGNED_SHORT, &(array.mIndices[0]));
#else
        glDrawElements(array.mMode, array.mIndices.size(), GL_UNSIGNED_INT, &(array.mIndices[0]));
#endif
      }
    }
    nuiCheckForGLErrors();

    glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_TRUE);
    glBlendFunc(mSrcAlpha, mDstAlpha);
    if (!arraycount)
    {
      glDrawArrays(mode, 0, s);
    }
    else
    {
      for (uint32 i = 0; i < arraycount; i++)
      {
        nuiRenderArray::IndexArray& array(pArray->GetIndexArray(i));
#ifdef _UIKIT_
        glDrawElements(array.mMode, array.mIndices.size(), GL_UNSIGNED_SHORT, &(array.mIndices[0]));
#else
        glDrawElements(array.mMode, array.mIndices.size(), GL_UNSIGNED_INT, &(array.mIndices[0]));
#endif
      }
    }
    glBlendFunc(mSrcColor, mDstColor);
    nuiCheckForGLErrors();
    glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
  }
  else
  {
    uint32 arraycount = pArray->GetIndexArrayCount();
    
    if (!arraycount)
    {
      glDrawArrays(mode, 0, s);
    }
    else
    {
      for (uint32 i = 0; i < arraycount; i++)
      {
        nuiRenderArray::IndexArray& array(pArray->GetIndexArray(i));
#ifdef _UIKIT_
        glDrawElements(array.mMode, array.mIndices.size(), GL_UNSIGNED_SHORT, &(array.mIndices[0]));
#else
        glDrawElements(array.mMode, array.mIndices.size(), GL_UNSIGNED_INT, &(array.mIndices[0]));
#endif
      }
    }
    nuiCheckForGLErrors();
  }
  

#ifdef NUI_USE_ANTIALIASING
  if (mState.mAntialiasing)
  {
#ifdef NUI_USE_MULTISAMPLE_AA
    glDisable(GL_MULTISAMPLE_ARB);
#else
    glDisable(GL_POLYGON_SMOOTH);
    glDisable(GL_BLEND);
    BlendFuncSeparate(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
#endif
    nuiCheckForGLErrors();
  }
  else
#endif // NUI_USE_ANTIALIASING
  {
//#TEST meeloo disabling AA texture
//     if (pArray->UseGLAATexture())
//     {
//       glMatrixMode(GL_TEXTURE);
//       glPopMatrix();
//       glMatrixMode(GL_MODELVIEW);
//       glPopMatrix();
// 
//       if (mState.mpTexture && mState.mTexturing)
//       {
//         if (mTextureTarget != GL_TEXTURE_2D)
//         {
//           glDisable(GL_TEXTURE_2D);
//           glEnable(mTextureTarget);
//         }
// 
//         UploadTexture(mState.mpTexture);
//       }
//       else
//       {
//         glDisable(GL_TEXTURE_2D);
//       }
// 
//       if (!mState.mBlending)
//         glDisable(GL_BLEND);
//       if (mState.mBlendFunc != nuiBlendTransp)
//       {
//         GLenum src, dst;
//         nuiGetBlendFuncFactors(mState.mBlendFunc, src, dst);
//         glBlendFunc(src, dst);
//       }
//       //ApplyTexture(mState, true);
//     }
//     else

    if (NeedTranslateHack)
      glTranslatef(-hackX, -hackY, 0);
  }

//  glColor3f(1.0f, 1.0f, 1.0f);
  glColor4f(1.0f, 1.0f, 1.0f, 1.0f);

  pArray->Release();
  nuiCheckForGLErrors();
}
// virtual (default)
void LLVertexBuffer::setupVertexBuffer(U32 data_mask) const
{
	LLMemType mt(LLMemType::MTYPE_VERTEX_DATA);
	stop_glerror();
	volatile U8* base = useVBOs() ? NULL : mMappedData;
	S32 stride = mStride;

	if ((data_mask & mTypeMask) != data_mask)
	{
		llerrs << "LLVertexBuffer::setupVertexBuffer missing required components for supplied data mask." << llendl;
	}

	if (data_mask & MAP_NORMAL)
	{
		glNormalPointer(GL_FLOAT, stride, (void*)(base + mOffsets[TYPE_NORMAL]));
	}
	if (data_mask & MAP_TEXCOORD3)
	{
		glClientActiveTextureARB(GL_TEXTURE3_ARB);
		glTexCoordPointer(2,GL_FLOAT, stride, (void*)(base + mOffsets[TYPE_TEXCOORD3]));
		glClientActiveTextureARB(GL_TEXTURE0_ARB);
	}
	if (data_mask & MAP_TEXCOORD2)
	{
		glClientActiveTextureARB(GL_TEXTURE2_ARB);
		glTexCoordPointer(2,GL_FLOAT, stride, (void*)(base + mOffsets[TYPE_TEXCOORD2]));
		glClientActiveTextureARB(GL_TEXTURE0_ARB);
	}
	if (data_mask & MAP_TEXCOORD1)
	{
		glClientActiveTextureARB(GL_TEXTURE1_ARB);
		glTexCoordPointer(2,GL_FLOAT, stride, (void*)(base + mOffsets[TYPE_TEXCOORD1]));
		glClientActiveTextureARB(GL_TEXTURE0_ARB);
	}
	if (data_mask & MAP_BINORMAL)
	{
		glClientActiveTextureARB(GL_TEXTURE2_ARB);
		glTexCoordPointer(3,GL_FLOAT, stride, (void*)(base + mOffsets[TYPE_BINORMAL]));
		glClientActiveTextureARB(GL_TEXTURE0_ARB);
	}
	if (data_mask & MAP_TEXCOORD0)
	{
		glTexCoordPointer(2,GL_FLOAT, stride, (void*)(base + mOffsets[TYPE_TEXCOORD0]));
	}
	if (data_mask & MAP_COLOR)
	{
		glColorPointer(4, GL_UNSIGNED_BYTE, stride, (void*)(base + mOffsets[TYPE_COLOR]));
	}
	
	if (data_mask & MAP_WEIGHT)
	{
		glVertexAttribPointerARB(1, 1, GL_FLOAT, FALSE, stride, (void*)(base + mOffsets[TYPE_WEIGHT]));
	}
	if (data_mask & MAP_CLOTHWEIGHT)
	{
		glVertexAttribPointerARB(4, 4, GL_FLOAT, TRUE,  stride, (void*)(base + mOffsets[TYPE_CLOTHWEIGHT]));
	}
	if (data_mask & MAP_VERTEX)
	{
		glVertexPointer(3,GL_FLOAT, stride, (void*)(base + 0));
	}

	llglassertok();
}
Ejemplo n.º 22
0
void Renderer::drawRoom()
{
	glEnableClientState(GL_VERTEX_ARRAY);
	glVertexPointer(3, GL_DOUBLE, 0, vertexBuffer);

	if(lighting){
		glEnableClientState(GL_NORMAL_ARRAY);
		glNormalPointer(GL_DOUBLE, 0, normalBuffer);
	}

	if(materials){
		glMaterialfv(GL_FRONT,GL_AMBIENT,brickAmbient);
		glMaterialfv(GL_FRONT,GL_DIFFUSE,brickDiffuse);
		glMaterialfv(GL_FRONT,GL_SPECULAR,brickSpecular);
		glMaterialfv(GL_FRONT,GL_EMISSION,brickEmission);
		glMaterialf (GL_FRONT,GL_SHININESS,brickShininess);
	}

	if(textured){
		glEnable(GL_TEXTURE_2D);
		glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);

		//animate the sky texture
		double x1,x2;
		
		x1 = textureCoord[24];
		x2 = textureCoord[28];
		
		x1 += 0.0002;
		x2 += 0.0002;
		
		textureCoord[24] = textureCoord[26] = x1;
		textureCoord[28] = textureCoord[30] = x2;
		
		glEnableClientState(GL_TEXTURE_COORD_ARRAY);
		glTexCoordPointer(2, GL_DOUBLE, 0, textureCoord);
		
		glEnable(GL_TEXTURE_2D);
		
		glBindTexture(GL_TEXTURE_2D, textureID[0]);
		glDrawArrays(GL_QUADS,0,8);
		glDrawArrays(GL_QUADS,16,8);
		glBindTexture(GL_TEXTURE_2D, textureID[1]);
		glMaterialfv(GL_FRONT, GL_EMISSION, skyEmission);
		glDrawArrays(GL_QUADS,12,4);
		glBindTexture(GL_TEXTURE_2D, textureID[2]);
		glDrawArrays(GL_QUADS,8,4);
		glMaterialfv(GL_FRONT, GL_EMISSION, defEmission);
		
		glDisable(GL_TEXTURE_2D);
	}
	else {
		glColor3d(1,1,0);
		glDrawArrays(GL_QUADS,0,4);
		glColor3d(1,0,0);
		glDrawArrays(GL_QUADS,4,4);
		glColor3d(1,.5,0);
		glDrawArrays(GL_QUADS,8,4);
		glColor3d(0,1,0);
		glDrawArrays(GL_QUADS,12,4);
		glColor3d(0,0,1);
		glDrawArrays(GL_QUADS,16,4);
		glColor3d(1,0,1);
		glDrawArrays(GL_QUADS,20,4);
	}
}
Ejemplo n.º 23
0
//--------------------------------------------------------------
void ofVbo::bind() const{
	bool programmable = ofIsGLProgrammableRenderer();
	if(programmable){
		if(vaoID==0){
			glGenVertexArrays(1, &const_cast<ofVbo*>(this)->vaoID);
			if(vaoID!=0){
				retainVAO(vaoID);
				vaoChanged = true;
			}
		}
		glBindVertexArray(vaoID);
	}

	if(vaoChanged || !programmable){
		if(bUsingVerts){
			if(!programmable){
				positionAttribute.bind();
				#ifndef TARGET_PROGRAMMABLE_GL
				glEnableClientState(GL_VERTEX_ARRAY);
				glVertexPointer(positionAttribute.numCoords, GL_FLOAT,
								positionAttribute.stride,
								(void*)positionAttribute.offset);
				#endif
			}else{
				positionAttribute.enable();
			}
		}else if(programmable){
			positionAttribute.disable();
		}

		if(bUsingColors) {
			if(!programmable){
				colorAttribute.bind();
				#ifndef TARGET_PROGRAMMABLE_GL
				glEnableClientState(GL_COLOR_ARRAY);
				glColorPointer(colorAttribute.numCoords, GL_FLOAT,
						colorAttribute.stride,
							   (void*)colorAttribute.offset);
				#endif
			}else{
				colorAttribute.enable();
			}
		}else if(programmable){
			colorAttribute.disable();
		}

		if(bUsingNormals) {
			if(!programmable){
				normalAttribute.bind();
				#ifndef TARGET_PROGRAMMABLE_GL
				glEnableClientState(GL_NORMAL_ARRAY);
				glNormalPointer(GL_FLOAT, normalAttribute.stride,
								(void*)normalAttribute.offset);
				#endif
			}else{
				normalAttribute.enable();
			}
		}else if(programmable){
			normalAttribute.disable();
		}

		if(bUsingTexCoords) {
			if(!programmable){
				texCoordAttribute.bind();
				#ifndef TARGET_PROGRAMMABLE_GL
				glEnableClientState(GL_TEXTURE_COORD_ARRAY);
				glTexCoordPointer(texCoordAttribute.numCoords,
								  GL_FLOAT, texCoordAttribute.stride,
								  (void*)texCoordAttribute.offset);
				#endif
			}else{
				texCoordAttribute.enable();
			}
		}else if(programmable){
			texCoordAttribute.disable();
		}
        
        if (bUsingIndices) {
            indexAttribute.bind();
        }

		map<int,VertexAttribute>::const_iterator it;
		for(it = customAttributes.begin();it!=customAttributes.end();it++){
			it->second.enable();
		}

		vaoChanged=false;
	}

	if(programmable){
		ofGetGLProgrammableRenderer()->setAttributes(true,getUsingColors(),getUsingTexCoords(),getUsingNormals());
	}
}
Ejemplo n.º 24
0
void	CRenderer::BindVertexBuffer( void* pBufferId, size_t vertexCount, const CVertexFormat& vertexFormat )
{
	glBindBuffer( GL_ARRAY_BUFFER, *((GLuint*)pBufferId) );
	static_cast< CSpecificData* >( m_pSpecificData )->m_boundVertexBuffer = *((GLuint*)pBufferId);

	// Position
	GLuint attribIndex = 0;
	glEnableVertexAttribArray( attribIndex );
	glVertexAttribPointer( 0, 3, GL_FLOAT, false, (GLsizei)vertexFormat.GetSize(), 0 );
	++attribIndex;

	// Normal
	if ( vertexFormat.HasSingleElement( CVertexFormat::eSE_Normal ) )
	{
		glEnableVertexAttribArray( attribIndex );
		glVertexAttribPointer( attribIndex, 3, GL_FLOAT, false, (GLsizei)vertexFormat.GetSize(), (void*)vertexFormat.GetSingleElementOffset( CVertexFormat::eSE_Normal ) );
		++attribIndex;
	}

	// Color
	if  (vertexFormat.HasSingleElement( CVertexFormat::eSE_Color ))
	{
		glEnableVertexAttribArray( attribIndex );
		glVertexAttribPointer( attribIndex, 3, GL_FLOAT, false, (GLsizei)vertexFormat.GetSize(), (void*)vertexFormat.GetSingleElementOffset( CVertexFormat::eSE_Color ) );
		++attribIndex;
	}

	// UV
	for ( size_t iInstance = 0; iInstance < vertexFormat.GetMultipleElementCount(CVertexFormat::eME_UV); ++iInstance )
	{
		glEnableVertexAttribArray( attribIndex );
		glVertexAttribPointer( attribIndex, 2, GL_FLOAT, false, (GLsizei)vertexFormat.GetSize(), (void*)vertexFormat.GetMultipleElementOffset( CVertexFormat::eME_UV, iInstance ) );
		++attribIndex;
	}

	// Bones
	if  (vertexFormat.HasSingleElement( CVertexFormat::eSE_BoneWeights ))
	{
		glEnableVertexAttribArray( attribIndex );
		glVertexAttribPointer( attribIndex, 4, GL_FLOAT, false, (GLsizei)vertexFormat.GetSize(), (void*)vertexFormat.GetSingleElementOffset( CVertexFormat::eSE_BoneWeights ) );
		++attribIndex;

		glEnableVertexAttribArray( attribIndex );
		glVertexAttribPointer( attribIndex, 4, GL_FLOAT, false, (GLsizei)vertexFormat.GetSize(), (void*)(vertexFormat.GetSingleElementOffset( CVertexFormat::eSE_BoneWeights ) + sizeof(float)*4) );
		++attribIndex;
	}

#if defined(OLD_OPENGL)
	// Position
	glEnableClientState( GL_VERTEX_ARRAY );
	glVertexPointer( 3, GL_FLOAT, (GLsizei)vertexFormat.GetSize(), (void*)vertexFormat.GetSingleElementOffset( CVertexFormat::eSE_Position ) );

	// Normal
	if ( vertexFormat.HasSingleElement( CVertexFormat::eSE_Normal ) )
	{
		glEnableClientState( GL_NORMAL_ARRAY );
		glNormalPointer( GL_FLOAT, (GLsizei)vertexFormat.GetSize(), (void*)vertexFormat.GetSingleElementOffset( CVertexFormat::eSE_Normal ) );
	}

	// Color
	if ( vertexFormat.HasSingleElement( CVertexFormat::eSE_Color ) )
	{
		glEnableClientState( GL_COLOR_ARRAY );
		glColorPointer( 3, GL_FLOAT, vertexFormat.GetSize(), (void*)vertexFormat.GetSingleElementOffset( CVertexFormat::eSE_Color ) );
	}
	
	// UV
	for( size_t iInstance = 0 ; iInstance < vertexFormat.GetMultipleElementCount( CVertexFormat::eME_UV ) ; ++iInstance )
	{
		glEnableClientState( GL_TEXTURE_COORD_ARRAY );
		glTexCoordPointer( 2, GL_FLOAT, (GLsizei)vertexFormat.GetSize(), (void*)vertexFormat.GetMultipleElementOffset( CVertexFormat::eME_UV, iInstance ) );
	}
#endif
}
Ejemplo n.º 25
0
void VertexBufferRenderer::setup(Mesh &obj, bool init_texcoord)
{
	// special lights which have been bound that contribute to texturing 
//	unsigned int tex_offset = Texture::tex_use+1;

#if !defined(OPENGL_ES) && !defined(ARCH_DC)	
	if (obj.buffer_state && lockObj != &obj)
	{
		// Bind the vertex buffers from the cache data 
		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER_ARB, obj.cache_data.elementBufferNum);
		glBindBuffer(GL_ARRAY_BUFFER_ARB, obj.cache_data.dataBufferNum);
		
		// set the vertex pointer 
		glVertexPointer(3,GL_FLOAT,0,BUFFER_OFFSET(0));
		glEnableClientState(GL_VERTEX_ARRAY);
		
		// set the normal pointer 
		glNormalPointer(GL_FLOAT,0,BUFFER_OFFSET(obj.normalCacheOffset));
		glEnableClientState(GL_NORMAL_ARRAY);
		
		// activate uv map pointers for multitexture layers 
		if (init_texcoord) 
		{
			for (unsigned int m = 0; m < obj.cache_data.max_uvs; m++)
			{
				Texture::setTexture(m);
				glTexCoordPointer(2, GL_FLOAT, 0, BUFFER_OFFSET(obj.uvCacheOffset+(sizeof(va_uv)*obj.cache_data.vertex_count*m)));
			}
			glEnableClientState(GL_TEXTURE_COORD_ARRAY);
		}
	}
	else 
#endif
		if (lockObj != &obj)
		{
#if !defined(OPENGL_ES) && !defined(ARCH_DC)
			glBindBuffer(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
			glBindBuffer(GL_ARRAY_BUFFER_ARB, 0);
			
			glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER_ARB);
			glUnmapBuffer(GL_ARRAY_BUFFER_ARB);
#endif
			
			if (obj.hasColorMap)
			{
				glColorPointer(3, GL_FLOAT, 0, (const GLvoid *)(obj.cache_data.data+(obj.colorMapOffset)));
			}
			
			glVertexPointer(3, GL_FLOAT, 0,  (const GLvoid *)obj.cache_data.data);
			glEnableClientState(GL_VERTEX_ARRAY);
			
#ifndef ARCH_DC	// DC doesn't process normals
			glNormalPointer(GL_FLOAT, 0,  (const GLvoid *)(obj.cache_data.data+(obj.normalCacheOffset)));
			glEnableClientState(GL_NORMAL_ARRAY);
#endif		
			
			if (init_texcoord) 
			{
				for (unsigned int m = 0; m < obj.cache_data.max_uvs; m++)
				{
					Texture::setTexture(m);
					glTexCoordPointer(2, GL_FLOAT, 0,  (const GLvoid *)(obj.cache_data.data+obj.uvCacheOffset+(sizeof(va_uv)*obj.cache_data.vertex_count*m)));
				}
				glEnableClientState(GL_TEXTURE_COORD_ARRAY);
			}
			
		}
	
	if (obj.dynamic_colors)	// Mostly just for Dreamcast lighting at the moment
	{
		glColorPointer(3, GL_FLOAT, 0, (const GLvoid *)obj.dynamic_colors);				
		glEnableClientState(GL_COLOR_ARRAY);	
	}
	
#ifdef ARCH_PSP
	sceGuSignal(GU_BEHAVIOR_SUSPEND, 2);
#endif
	
	lockObj = &obj;
}