Exemplo n.º 1
0
/*
============
R_CreateVBO2

RB: OPTIMIZE rewrite to not use memcpy
============
*/
VBO_t          *R_CreateVBO2(const char *name, int numVertexes, srfVert_t * verts, unsigned int stateBits, vboUsage_t usage)
{
	VBO_t          *vbo;
	int             i, j;

	byte           *data;
	int             dataSize;
	int             dataOfs;

	vec4_t          tmp;
	int				glUsage;

	switch (usage)
	{
		case VBO_USAGE_STATIC:
			glUsage = GL_STATIC_DRAW_ARB;
			break;

		case VBO_USAGE_DYNAMIC:
			glUsage = GL_DYNAMIC_DRAW_ARB;
			break;

		default:
			Com_Error(ERR_FATAL, "bad vboUsage_t given: %i", usage);
	}

	if(!numVertexes)
		return NULL;

	if(strlen(name) >= MAX_QPATH)
	{
		ri.Error(ERR_DROP, "R_CreateVBO2: \"%s\" is too long\n", name);
	}

	// make sure the render thread is stopped
	R_SyncRenderThread();

	vbo = ri.Hunk_Alloc(sizeof(*vbo), h_low);
	Com_AddToGrowList(&tr.vbos, vbo);

	Q_strncpyz(vbo->name, name, sizeof(vbo->name));

	vbo->ofsXYZ = 0;
	vbo->ofsTexCoords = 0;
	vbo->ofsLightCoords = 0;
	vbo->ofsBinormals = 0;
	vbo->ofsTangents = 0;
	vbo->ofsNormals = 0;
	vbo->ofsColors = 0;
	vbo->ofsPaintColors = 0;
	vbo->ofsLightDirections = 0;
	vbo->ofsBoneIndexes = 0;
	vbo->ofsBoneWeights = 0;

	vbo->sizeXYZ = 0;
	vbo->sizeTangents = 0;
	vbo->sizeBinormals = 0;
	vbo->sizeNormals = 0;

	// create VBO
	dataSize = numVertexes * (sizeof(vec4_t) * 9);
	data = ri.Hunk_AllocateTempMemory(dataSize);
	dataOfs = 0;

	// set up xyz array
	for(i = 0; i < numVertexes; i++)
	{
		for(j = 0; j < 3; j++)
		{
			tmp[j] = verts[i].xyz[j];
		}
		tmp[3] = 1;

		memcpy(data + dataOfs, (vec_t *) tmp, sizeof(vec4_t));
		dataOfs += sizeof(vec4_t);
	}

	// feed vertex texcoords
	if(stateBits & ATTR_TEXCOORD)
	{
		vbo->ofsTexCoords = dataOfs;
		for(i = 0; i < numVertexes; i++)
		{
			for(j = 0; j < 2; j++)
			{
				tmp[j] = verts[i].st[j];
			}
			tmp[2] = 0;
			tmp[3] = 1;

			memcpy(data + dataOfs, (vec_t *) tmp, sizeof(vec4_t));
			dataOfs += sizeof(vec4_t);
		}
	}

	// feed vertex lightmap texcoords
	if(stateBits & ATTR_LIGHTCOORD)
	{
		vbo->ofsLightCoords = dataOfs;
		for(i = 0; i < numVertexes; i++)
		{
			for(j = 0; j < 2; j++)
			{
				tmp[j] = verts[i].lightmap[j];
			}
			tmp[2] = 0;
			tmp[3] = 1;

			memcpy(data + dataOfs, (vec_t *) tmp, sizeof(vec4_t));
			dataOfs += sizeof(vec4_t);
		}
	}

	// feed vertex tangents
	if(stateBits & ATTR_TANGENT)
	{
		vbo->ofsTangents = dataOfs;
		for(i = 0; i < numVertexes; i++)
		{
			for(j = 0; j < 3; j++)
			{
				tmp[j] = verts[i].tangent[j];
			}
			tmp[3] = 1;

			memcpy(data + dataOfs, (vec_t *) tmp, sizeof(vec4_t));
			dataOfs += sizeof(vec4_t);
		}
	}

	// feed vertex binormals
	if(stateBits & ATTR_BINORMAL)
	{
		vbo->ofsBinormals = dataOfs;
		for(i = 0; i < numVertexes; i++)
		{
			for(j = 0; j < 3; j++)
			{
				tmp[j] = verts[i].binormal[j];
			}
			tmp[3] = 1;

			memcpy(data + dataOfs, (vec_t *) tmp, sizeof(vec4_t));
			dataOfs += sizeof(vec4_t);
		}
	}

	// feed vertex normals
	if(stateBits & ATTR_NORMAL)
	{
		vbo->ofsNormals = dataOfs;
		for(i = 0; i < numVertexes; i++)
		{
			for(j = 0; j < 3; j++)
			{
				tmp[j] = verts[i].normal[j];
			}
			tmp[3] = 1;

			memcpy(data + dataOfs, (vec_t *) tmp, sizeof(vec4_t));
			dataOfs += sizeof(vec4_t);
		}
	}

	// feed vertex colors
	if(stateBits & ATTR_COLOR)
	{
		vbo->ofsColors = dataOfs;
		for(i = 0; i < numVertexes; i++)
		{
			for(j = 0; j < 4; j++)
			{
				tmp[j] = verts[i].lightColor[j];
			}

			memcpy(data + dataOfs, (vec_t *) tmp, sizeof(vec4_t));
			dataOfs += sizeof(vec4_t);
		}
	}

#if !defined(COMPAT_Q3A) && !defined(COMPAT_ET)
	// feed vertex paint colors
	if(stateBits & ATTR_PAINTCOLOR)
	{
		vbo->ofsPaintColors = dataOfs;
		for(i = 0; i < numVertexes; i++)
		{
			for(j = 0; j < 4; j++)
			{
				tmp[j] = verts[i].paintColor[j];
			}

			memcpy(data + dataOfs, (vec_t *) tmp, sizeof(vec4_t));
			dataOfs += sizeof(vec4_t);
		}
	}

	// feed vertex light directions
	if(stateBits & ATTR_LIGHTDIRECTION)
	{
		vbo->ofsLightDirections = dataOfs;
		for(i = 0; i < numVertexes; i++)
		{
			for(j = 0; j < 3; j++)
			{
				tmp[j] = verts[i].lightDirection[j];
			}
			tmp[3] = 1;

			memcpy(data + dataOfs, (vec_t *) tmp, sizeof(vec4_t));
			dataOfs += sizeof(vec4_t);
		}
	}
#endif

	vbo->vertexesSize = dataSize;
	vbo->vertexesNum = numVertexes;

	glGenBuffersARB(1, &vbo->vertexesVBO);

	glBindBufferARB(GL_ARRAY_BUFFER_ARB, vbo->vertexesVBO);
	glBufferDataARB(GL_ARRAY_BUFFER_ARB, dataSize, data, glUsage);

	glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);

	GL_CheckErrors();

	ri.Hunk_FreeTempMemory(data);

	return vbo;
}
Exemplo n.º 2
0
DynamicTexture::DynamicTexture(const ImageTextureConfig& config) :
	Texture(config)
{
	glGenBuffersARB(1, &m_bufferId);	
	m_dataSize = getByteSizeofPixel(config.format) * m_width * m_height * m_depth;
}
Exemplo n.º 3
0
/**
 *  erzeugt die OpenGL-Vertices.
 *
 *  @author OLiver
 *  @author FloSoft
 */
void TerrainRenderer::GenerateOpenGL(const GameWorldViewer& gwv)
{
    width = gwv.GetWidth();
    height = gwv.GetHeight();
    LandscapeType lt = gwv.GetLandscapeType();

    GenerateVertices(gwv);

    // We have 2 triangles per map point
    unsigned int triangleCount = width * height * 2;

    // Ränder zählen
    borders.resize(width * height);
    for(MapCoord y = 0; y < height; ++y)
    {
        for(MapCoord x = 0; x < width; ++x)
        {
            MapPoint pt(x, y);
            TerrainType t1 = gwv.GetNode(pt).t1; //-V807
            TerrainType t2 = gwv.GetNode(pt).t2;
            unsigned int pos = GetVertexIdx(pt);

            if( (borders[pos].left_right[0] = TerrainData::GetEdgeType(lt, t2, t1)) )
                borders[pos].left_right_offset[0] = triangleCount++;
            if( (borders[pos].left_right[1] = TerrainData::GetEdgeType(lt, t1, t2)) )
                borders[pos].left_right_offset[1] = triangleCount++;

            t1 = gwv.GetNodeAround(pt, 3).t1;
            if( (borders[pos].right_left[0] = TerrainData::GetEdgeType(lt, t1, t2)) )
                borders[pos].right_left_offset[0] = triangleCount++;
            if( (borders[pos].right_left[1] = TerrainData::GetEdgeType(lt, t2, t1)) )
                borders[pos].right_left_offset[1] = triangleCount++;

            t1 = gwv.GetNode(pt).t1;
            t2 = gwv.GetNodeAround(pt, 5).t2;
            if( (borders[pos].top_down[0] = TerrainData::GetEdgeType(lt, t2, t1)) )
                borders[pos].top_down_offset[0] = triangleCount++;
            if( (borders[pos].top_down[1] = TerrainData::GetEdgeType(lt, t1, t2)) )
                borders[pos].top_down_offset[1] = triangleCount++;
        }
    }

    gl_vertices.resize(triangleCount);
    gl_texcoords.resize(triangleCount);
    gl_colors.resize(triangleCount);

    // Normales Terrain erzeugen
    for(MapCoord y = 0; y < height; ++y)
    {
        for(MapCoord x = 0; x < width; ++x)
        {
            MapPoint pt(x, y);
            UpdateTrianglePos(pt, gwv, false);
            UpdateTriangleColor(pt, gwv, false);
            UpdateTriangleTerrain(pt, gwv, false);
        }
    }

    // Ränder erzeugen
    for(MapCoord y = 0; y < height; ++y)
    {
        for(MapCoord x = 0; x < width; ++x)
        {
            MapPoint pt(x, y);
            UpdateBorderTrianglePos(pt, gwv, false);
            UpdateBorderTriangleColor(pt, gwv, false);
            UpdateBorderTriangleTerrain(pt, gwv, false);
        }
    }

    if(SETTINGS.video.vbo)
    {
        // Generiere und Binde den Vertex Buffer
        glGenBuffersARB(1, (GLuint*)&vbo_vertices);
        glBindBufferARB(GL_ARRAY_BUFFER_ARB, vbo_vertices);
        glBufferDataARB(GL_ARRAY_BUFFER_ARB, gl_vertices.size() * sizeof(Triangle), &gl_vertices.front(), GL_STATIC_DRAW_ARB);
        glVertexPointer(2, GL_FLOAT, 0, NULL);

        // Generiere und Binde den Textur Koordinaten Buffer
        glGenBuffersARB(1, (GLuint*)&vbo_texcoords);
        glBindBufferARB(GL_ARRAY_BUFFER_ARB, vbo_texcoords);
        glBufferDataARB(GL_ARRAY_BUFFER_ARB, gl_texcoords.size() * sizeof(Triangle), &gl_texcoords.front(), GL_STATIC_DRAW_ARB );
        glTexCoordPointer(2, GL_FLOAT, 0, NULL);

        // Generiere und Binde den Color Buffer
        glGenBuffersARB(1, (GLuint*)&vbo_colors);
        glBindBufferARB(GL_ARRAY_BUFFER_ARB, vbo_colors);
        glBufferDataARB(GL_ARRAY_BUFFER_ARB, gl_colors.size() * sizeof(ColorTriangle), &gl_colors.front(), GL_STATIC_DRAW_ARB );
        glColorPointer(3, GL_FLOAT, 0, NULL);

        vboBuffersUsed = true;
    }
    else
    {
        glVertexPointer(2, GL_FLOAT, 0, &gl_vertices.front());
        glTexCoordPointer(2, GL_FLOAT, 0, &gl_texcoords.front());
        glColorPointer(3, GL_FLOAT, 0, &gl_colors.front());
    }
}
Exemplo n.º 4
0
/*
============
R_CreateVBO
============
*/
VBO_t          *R_CreateVBO(const char *name, byte * vertexes, int vertexesSize, vboUsage_t usage)
{
	VBO_t          *vbo;
	int				glUsage;

	switch (usage)
	{
		case VBO_USAGE_STATIC:
			glUsage = GL_STATIC_DRAW_ARB;
			break;

		case VBO_USAGE_DYNAMIC:
			glUsage = GL_DYNAMIC_DRAW_ARB;
			break;

		default:
			Com_Error(ERR_FATAL, "bad vboUsage_t given: %i", usage);
	}

	if(strlen(name) >= MAX_QPATH)
	{
		ri.Error(ERR_DROP, "R_CreateVBO: \"%s\" is too long\n", name);
	}

	// make sure the render thread is stopped
	R_SyncRenderThread();

	vbo = ri.Hunk_Alloc(sizeof(*vbo), h_low);
	Com_AddToGrowList(&tr.vbos, vbo);

	Q_strncpyz(vbo->name, name, sizeof(vbo->name));

	vbo->ofsXYZ = 0;
	vbo->ofsTexCoords = 0;
	vbo->ofsLightCoords = 0;
	vbo->ofsBinormals = 0;
	vbo->ofsTangents = 0;
	vbo->ofsNormals = 0;
	vbo->ofsColors = 0;
	vbo->ofsPaintColors = 0;
	vbo->ofsLightDirections = 0;
	vbo->ofsBoneIndexes = 0;
	vbo->ofsBoneWeights = 0;

	vbo->sizeXYZ = 0;
	vbo->sizeTangents = 0;
	vbo->sizeBinormals = 0;
	vbo->sizeNormals = 0;

	vbo->vertexesSize = vertexesSize;

	glGenBuffersARB(1, &vbo->vertexesVBO);

	glBindBufferARB(GL_ARRAY_BUFFER_ARB, vbo->vertexesVBO);
	glBufferDataARB(GL_ARRAY_BUFFER_ARB, vertexesSize, vertexes, glUsage);

	glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);

	GL_CheckErrors();

	return vbo;
}
Exemplo n.º 5
0
	void OpenGLTexture::createManual(int _width, int _height, TextureUsage _usage, PixelFormat _format, void* _data)
	{
		MYGUI_PLATFORM_ASSERT(!mTextureID, "Texture already exist");

		//FIXME перенести в метод
		mInternalPixelFormat = 0;
		mPixelFormat = 0;
		mNumElemBytes = 0;
		if (_format == PixelFormat::L8)
		{
			mInternalPixelFormat = GL_LUMINANCE8;
			mPixelFormat = GL_LUMINANCE;
			mNumElemBytes = 1;
		}
		else if (_format == PixelFormat::L8A8)
		{
			mInternalPixelFormat = GL_LUMINANCE8_ALPHA8;
			mPixelFormat = GL_LUMINANCE_ALPHA;
			mNumElemBytes = 2;
		}
		else if (_format == PixelFormat::R8G8B8)
		{
			mInternalPixelFormat = GL_RGB8;
			mPixelFormat = GL_BGR;
			mNumElemBytes = 3;
		}
		else if (_format == PixelFormat::R8G8B8A8)
		{
			mInternalPixelFormat = GL_RGBA8;
			mPixelFormat = GL_BGRA;
			mNumElemBytes = 4;
		}
		else
		{
			MYGUI_PLATFORM_EXCEPT("format not support");
		}

		mWidth = _width;
		mHeight = _height;
		mDataSize = _width * _height * mNumElemBytes;
		setUsage(_usage);
		//MYGUI_PLATFORM_ASSERT(mUsage, "usage format not support");

		mOriginalFormat = _format;
		mOriginalUsage = _usage;

		// Set unpack alignment to one byte
		int alignment = 0;
		glGetIntegerv( GL_UNPACK_ALIGNMENT, &alignment );
	    glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );

		// создаем тукстуру
		glGenTextures(1, &mTextureID);
		glBindTexture(GL_TEXTURE_2D, mTextureID);
        // Set texture parameters
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
		glTexImage2D(GL_TEXTURE_2D, 0, mInternalPixelFormat, mWidth, mHeight, 0, mPixelFormat, GL_UNSIGNED_BYTE, (GLvoid*)_data);
		glBindTexture(GL_TEXTURE_2D, 0);

		// Restore old unpack alignment
	    glPixelStorei( GL_UNPACK_ALIGNMENT, alignment );

		if (!_data)
		{
			//создаем текстурнный буфер
			glGenBuffersARB(1, &mPboID);
			glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, mPboID);
			glBufferDataARB(GL_PIXEL_UNPACK_BUFFER_ARB, mDataSize, 0, mUsage);
			glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
		}
	}
Exemplo n.º 6
0
void CRenderCaptureGL::BeginRender()
{
  if (!m_asyncChecked)
  {
#ifndef HAS_GLES
    m_asyncSupported = g_Windowing.IsExtSupported("GL_ARB_pixel_buffer_object");
    m_occlusionQuerySupported = g_Windowing.IsExtSupported("GL_ARB_occlusion_query");

    if (m_flags & CAPTUREFLAG_CONTINUOUS)
    {
      if (!m_occlusionQuerySupported)
        CLog::Log(LOGWARNING, "CRenderCaptureGL: GL_ARB_occlusion_query not supported, performance might suffer");
      if (!g_Windowing.IsExtSupported("GL_ARB_pixel_buffer_object"))
        CLog::Log(LOGWARNING, "CRenderCaptureGL: GL_ARB_pixel_buffer_object not supported, performance might suffer");
      if (UseOcclusionQuery())
        CLog::Log(LOGWARNING, "CRenderCaptureGL: GL_ARB_occlusion_query disabled, performance might suffer");
    }
#endif
    m_asyncChecked = true;
  }

#ifndef HAS_GLES
  if (m_asyncSupported)
  {
    if (!m_pbo)
      glGenBuffersARB(1, &m_pbo);

    if (UseOcclusionQuery() && m_occlusionQuerySupported)
    {
      //generate an occlusion query if we don't have one
      if (!m_query)
        glGenQueriesARB(1, &m_query);
    }
    else
    {
      //don't use an occlusion query, clean up any old one
      if (m_query)
      {
        glDeleteQueriesARB(1, &m_query);
        m_query = 0;
      }
    }

    //start the occlusion query
    if (m_query)
      glBeginQueryARB(GL_SAMPLES_PASSED_ARB, m_query);

    //allocate data on the pbo and pixel buffer
    glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, m_pbo);
    if (m_bufferSize != m_width * m_height * 4)
    {
      m_bufferSize = m_width * m_height * 4;
      glBufferDataARB(GL_PIXEL_PACK_BUFFER_ARB, m_bufferSize, 0, GL_STREAM_READ_ARB);
      delete[] m_pixels;
      m_pixels = new uint8_t[m_bufferSize];
    }
  }
  else
#endif
  {
    if (m_bufferSize != m_width * m_height * 4)
    {
      delete[] m_pixels;
      m_bufferSize = m_width * m_height * 4;
      m_pixels = new uint8_t[m_bufferSize];
    }
  }
}
Exemplo n.º 7
0
void dcVBO::GenBuffersARB(int size, GLuint* buffers)
{
    glGenBuffersARB(size, buffers);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBBufferObject_nglGenBuffersARB(JNIEnv *env, jclass clazz, jint n, jobject buffers, jint buffers_position, jlong function_pointer) {
	GLuint *buffers_address = ((GLuint *)(*env)->GetDirectBufferAddress(env, buffers)) + buffers_position;
	glGenBuffersARBPROC glGenBuffersARB = (glGenBuffersARBPROC)((intptr_t)function_pointer);
	glGenBuffersARB(n, buffers_address);
}
Exemplo n.º 9
0
bool C3ds::load(std::string id, std::string file, float scale) {
  this->id = id;
  std::ifstream in;
  ChunkInfo info;
  int Offset, SubChunkSize, Value, MatDex, MeshDex, Loop, LOff;
  short Val;
  float fVal;
  bool CopyVal = false;
  MatDex = -1;
  MeshDex = -1;
  in.open(file.c_str(), std::ios::binary);
  if (in.fail())
    return false;
  in.seekg(0, std::ios::end);
  fileSize = in.tellg();
  in.seekg(0, std::ios::beg);
  if (data != NULL)
    delete data;
  data = new unsigned char[fileSize];
  if (data == NULL) {
    in.close();
    return false;
  }
  in.read((char*) data, fileSize);
  in.close();

  Offset = 0;
  info = getChunkInfo(Offset);
  if (info.ID != 0x4D4D)
    return false;
  if (info.Size != fileSize)
    return false;
  countParts(fileSize);
  std::cout << "-- 3DS File has " << nMesh << " Meshes, only loading first --"
            << std::endl;
  Offset = 6;

  while (Offset < fileSize) {
    info = getChunkInfo(Offset);

    switch (info.ID) {
      case 0x0002:  // Version
        memcpy(&Value, &data[Offset + 6], 4);
        //printf("Chunk 0002 (Version) - %d\nOffset %d\n",Value,info.Size);
        Offset += info.Size;
        break;

      case 0x0011:  // RGB1
        //printf("Chunk 0011 (RGB1) %d %d %d\nOffset %d\n",data[Offset+6],data[Offset+7],data[Offset+8],info.Size);

        if (CopyVal) {
          color = (glRGBA) {data[Offset+6],data[Offset+7],data[Offset+8]};
          CopyVal = false;
        }
        Offset += info.Size;
        break;

      case 0x0012:  // RGB2
        //printf("Chunk 0012 (RGB2) %d %d %d\nOffset %d\n",data[Offset+6],data[Offset+7],data[Offset+8],info.Size);
        Offset += info.Size;
        break;

      case 0x0030:  // Quantity value for parent chunks
        memcpy(&Val, &data[Offset + 6], 2);
        //printf("Chunk 0030 (Qty Value) %d\nOffset %d\n",Val,info.Size);
        Offset += info.Size;
        break;

      case 0x0100:  // Config (Ignore)
        //printf("Chunk 0100 (Config)\nOffset %d\n",info.Size);
        Offset += info.Size;
        break;

      case 0x3D3D:  // Start of Obj
        //printf("Chunk 3D3D (Start of Obj)\nOffset %d\n",info.Size);
        SubChunkSize = info.Size + Offset;  // Set end limit for subchunk
        Offset += 6;
        break;

      case 0x3D3E:  // Editor config (Ignore)
        //printf("Chunk 3D3E (Editor Config)\nOffset %d\n",info.Size);
        Offset += info.Size;
        break;

      case 0x4000:  // Start of Mesh
        //printf("Chunk 4000 (Start of Mesh) - %s\nOffset %d\n",&data[Offset+6],info.Size);
        Offset += 6;
        while (data[Offset] != 0)  // Seek end of string
          Offset++;

        Offset++;  // One more to move past the NULL
        MeshDex++;
        if (MeshDex == 1)
          Offset = fileSize;
        break;

      case 0x4100:  // Mesh data
        //printf("Chunk 4100 (Mesh Data)\nOffset %d\n",info.Size);
        Offset += 6;
        break;

      case 0x4110:  // Vertex List
        memcpy(&Val, &data[Offset + 6], 2);
        //printf("Chunk 4110 (Vertex List) %d Vertices\nOffset %d\n",Val,info.Size);
        numVerts = Val;
        vertex = new FVector[Val + 1];
        sphereRadius = 0;
        for (Loop = 0, LOff = Offset + 8; Loop != Val; ++Loop, LOff += 12) {
          memcpy(&(vertex[Loop].x), &data[LOff], 4);
          memcpy(&(vertex[Loop].y), &data[LOff + 4], 4);
          memcpy(&(vertex[Loop].z), &data[LOff + 8], 4);
          if (vertex[Loop].magnitude() > sphereRadius)
            sphereRadius = vertex[Loop].magnitude();
        }
        Offset += info.Size;
        break;

      case 0x4111:  // Vertex Options
        //printf("Chunk 4111 (Vertex Options)\nOffset %d\n",info.Size);
        Offset += info.Size;
        break;

      case 0x4120:  // Face List
        memcpy(&Val, &data[Offset + 6], 2);
        //printf("Chunk 4120 (Face List) %d polys\nOffset %d\n",Val,info.Size);
        numFaces = Val;
        face = new Face[Val + 1];
        for (Loop = 0, LOff = Offset + 8; Loop != Val; ++Loop, LOff += 8) {
          memcpy(&(face[Loop].p1), &data[LOff], 2);
          memcpy(&(face[Loop].p2), &data[LOff + 2], 2);
          memcpy(&(face[Loop].p3), &data[LOff + 4], 2);
        }
        Offset += info.Size;
        break;

      case 0x4130:  // Material Desc
        Offset += info.Size;
        break;

      case 0x4140:  // UV Map List
        memcpy(&Val, &data[Offset + 6], 2);
        //printf("Chunk 4120 (UV Map List)\nOffset %d\n",info.Size);
        numTexCoords = Val;
        texcoord = new UVTexCoord[Val + 1];
        for (Loop = 0, LOff = Offset + 8; Loop != Val; ++Loop, LOff += 8) {
          memcpy(&(texcoord[Loop].u), &data[LOff], 4);
          memcpy(&(texcoord[Loop].v), &data[LOff + 4], 4);
        }
        Offset += info.Size;
        break;

      case 0xA000:  // Material Name
        //printf("Chunk A000 (Material Name) - %s\nOffset %d\n",&data[Offset+6],info.Size);
        //texture=data[Offset+6]; //lstrcpy(Matl[MatDex].Name,(LPSTR)&data[Offset+6]);
        Offset += info.Size;
        break;

      case 0xA010:  // Material - Ambient Color
        //printf("Chunk A010 (Material - Amb Col)\nOffset %d\n",info.Size);
        //memcpy(&Val,&data[Offset+6],2);
        ambientColor =
            (glRGBA) {data[Offset+6]/255.0f,data[Offset+7]/255.0f,data[Offset+8]/255.0f,data[Offset+9]/255.0f};
        Offset += info.Size;

        break;

      case 0xA020:  // Material - Diffuse Color
        //printf("Chunk A020 (Material - Dif Col)\nOffset %d\n",info.Size);
        CopyVal = true;
        diffuseColor =
            (glRGBA) {data[Offset+6]/255.0f,data[Offset+7]/255.0f,data[Offset+8]/255.0f,data[Offset+9]/255.0f};
        Offset += info.Size;
        //Offset+=6;//Info.Size;
        break;

      case 0xA030:  // Material - Spec Color
        specColor =
            (glRGBA) {data[Offset+6]/255.0f,data[Offset+7]/255.0f,data[Offset+8]/255.0f,data[Offset+9]/255.0f};

        Offset += info.Size;
        //Offset+=6;//Info.Size;
        break;

      case 0xA040:  // Material - Shininess
        //printf("Chunk A040 (Material - Shininess)\nOffset %d\n",info.Size);
        shininess = data[Offset + 6];
        Offset += 6;         		//Info.Size;
        break;

      case 0xA041:  // Material - Shine Strength
        //printf("Chunk A041 (Material - Shine Strength)\nOffset %d\n",info.Size);
        Offset += 6;         		//Info.Size;
        break;

      case 0xA050:  // Material - Transparency
        //printf("Chunk A050 (Material - Transparency)\nOffset %d\n",info.Size);
        transparency = data[Offset + 6];

        Offset += 6;       			//Info.Size;
        break;

      case 0xA100:  // Material - Type (Flat,Gourad, Phong, Metal)
        memcpy(&Val, &data[Offset + 6], 2);
        //printf("Chunk A100 (Material Type) %d\nOffset %d\n",Val,info.Size);
        texSmooth = Val;
        Offset += info.Size;
        break;

      case 0xA200:  // Material - Start of Texture Info
        //printf("Chunk A200 (Material Tex Map)\nOffset %d\n",info.Size);
        Offset += 6;
        break;

      case 0xA300:  // Material - Texture Name
        //printf("Chunk A300 (Material Tex Map Name) %s\nOffset %d\n",&data[Offset+6],info.Size);

        texture = (char *) &data[Offset + 6];
        Offset += info.Size;
        break;

      case 0xA351:  // Material - Texture Options
        memcpy(&Val, &data[Offset + 6], 2);
        //printf("Chunk A351 (Material Tex Options) %d\nOffset %d\n",Val,info.Size);
        Offset += info.Size;
        break;

      case 0xA354:  // Material - Texture U Scale
        memcpy(&fVal, &data[Offset + 6], 4);
        //printf("Chunk A354 (Material Tex U Scale) %f\nOffset %d\n",fVal,info.Size);
        TexCoordUScale = fVal;
        Offset += info.Size;
        break;

      case 0xA356:  // Material - Texture V Scale
        memcpy(&fVal, &data[Offset + 6], 4);
        //printf("Chunk A356 (Material Tex V Scale) %f\nOffset %d\n",fVal,info.Size);
        TexCoordVScale = fVal;
        Offset += info.Size;
        break;

      case 0xA35A:  // Material - Texture V Offset
        memcpy(&fVal, &data[Offset + 6], 4);
        //printf("Chunk A35A (Material Tex V Offset) %f\nOffset %d\n",fVal,info.Size);
        Offset += info.Size;
        break;

      case 0xA35C:  // Material - Texture V Offset
        memcpy(&fVal, &data[Offset + 6], 4);
        //printf("Chunk A35C (Material Tex Rotation) %f\nOffset %d\n",fVal,info.Size);
        Offset += info.Size;
        break;

      case 0xAFFF:  // Material Start
        //printf("Chunk AFFF (Start of Material)\nOffset %d\n",info.Size);
        MatDex++;
        Offset += 6;
        break;

      default:

        Offset += info.Size;
        break;
    }

  }
  std::string path = "resources/images/";

  if (!TextureMgr::get().load(texture, path + texture)) {
    std::cerr << "[Could not load texture '" << texture << "', using none]"
              << std::endl;
    texture = "";
  }
  if (TexCoordUScale <= 0.001f || TexCoordVScale <= 0.001f) {
    TexCoordUScale = 1.0f;
    TexCoordVScale = 1.0f;
  }
  /*for(int i=0;i<numTexCoords;i++)
   {
   texcoord[i].u*=TexCoordUScale;
   texcoord[i].v*=TexCoordVScale;
   }*/
  calcNormals();
  //drawelements
  buffer = new GLuint[4];
  glGenBuffersARB(4, buffer);

  glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, buffer[0]);
  glBufferDataARB(GL_ELEMENT_ARRAY_BUFFER_ARB, (numFaces) * sizeof(Face), face,
                  GL_STATIC_DRAW_ARB);
  //glEnableClientState(GL_VERTEX_ARRAY);
  glBindBufferARB(GL_ARRAY_BUFFER_ARB, buffer[1]);
  glBufferDataARB(GL_ARRAY_BUFFER_ARB, (numVerts * 3) * sizeof(float), vertex,
                  GL_STATIC_DRAW_ARB);
  //glEnableClientState(GL_NORMAL_ARRAY);
  glBindBufferARB(GL_ARRAY_BUFFER_ARB, buffer[2]);
  glBufferDataARB(GL_ARRAY_BUFFER_ARB, (numVerts * 3) * sizeof(float), normal,
                  GL_STATIC_DRAW_ARB);
  if (texcoord) {
    //	glEnableClientState(GL_TEXTURE_COORD_ARRAY);
    glBindBufferARB(GL_ARRAY_BUFFER_ARB, buffer[3]);
    glBufferDataARB(GL_ARRAY_BUFFER_ARB, (numVerts * 2) * sizeof(float),
                    texcoord, GL_STATIC_DRAW_ARB);
  }

  //replace when models have shininess
  shininess = 128;

  this->scale = scale;
  sphereRadius *= (scale * 2);
  return true;
}
Exemplo n.º 10
0
	bool cVertexBufferVBO::Compile(tVertexCompileFlag aFlags)
	{
		if(mbCompiled) return false;
		mbCompiled = true;

		//Create tangents
		if(aFlags & eVertexCompileFlag_CreateTangents)
		{
			mbTangents = true;

			mVertexFlags |= eVertexFlag_Texture1;

			int idx = cMath::Log2ToInt((int)eVertexFlag_Texture1);

			int lSize = GetVertexNum()*4;
			mvVertexArray[idx].resize(lSize);

			cMath::CreateTriTangentVectors(&(mvVertexArray[cMath::Log2ToInt((int)eVertexFlag_Texture1)][0]),
				&mvIndexArray[0], GetIndexNum(),

				&(mvVertexArray[cMath::Log2ToInt((int)eVertexFlag_Position)][0]),
				kvVertexElements[cMath::Log2ToInt((int)eVertexFlag_Position)],

				&(mvVertexArray[cMath::Log2ToInt((int)eVertexFlag_Texture0)][0]),
				&(mvVertexArray[cMath::Log2ToInt((int)eVertexFlag_Normal)][0]),
				GetVertexNum()
				);
		}

		GLenum usageType = GL_STATIC_DRAW_ARB;
		if(mUsageType== eVertexBufferUsageType_Dynamic) usageType = GL_DYNAMIC_DRAW_ARB;
		else if(mUsageType== eVertexBufferUsageType_Stream) usageType = GL_STREAM_DRAW_ARB;

		//Create the VBO vertex arrays
		for(int i=0;i< klNumOfVertexFlags; i++)
		{
			if(mVertexFlags & kvVertexFlags[i])
			{
				glGenBuffersARB(1,(GLuint *)&mvArrayHandle[i]);
				glBindBufferARB(GL_ARRAY_BUFFER_ARB, mvArrayHandle[i]);

				glBufferDataARB(GL_ARRAY_BUFFER_ARB, mvVertexArray[i].size()*sizeof(float),
						&(mvVertexArray[i][0]), usageType);

				glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);

				//Log("%d-Handle: %d, size: %d \n",i,mvArrayHandle[i], mvVertexArray);
			}
		}

	    //Create the VBO index array
		glGenBuffersARB(1,(GLuint *)&mlElementHandle);
		glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB,mlElementHandle);
		glBufferDataARB(GL_ELEMENT_ARRAY_BUFFER_ARB, GetIndexNum()*sizeof(unsigned int),
														&mvIndexArray[0], usageType);
		glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB,0);

		//Log("VBO compile done!\n");

		return true;
	}
Exemplo n.º 11
0
/* Poly-listy - inicializace
*/
void poly_vertex_array_init_arb(EDIT_MESH_POLY * p_poly)
{
  VERTEX_ARRAYS *p_va = &p_poly->varray;

  glGenBuffersARB(1, (GLuint *) & p_va->ati_handle);
}
Exemplo n.º 12
0
CGLMBuffer::CGLMBuffer( GLMContext *ctx, EGLMBufferType type, uint size, uint options )
{
	m_ctx = ctx;
	m_type = type;
	switch(m_type)
	{
		case	kGLMVertexBuffer:		m_buffGLTarget = GL_ARRAY_BUFFER_ARB; break;
		case	kGLMIndexBuffer:		m_buffGLTarget = GL_ELEMENT_ARRAY_BUFFER_ARB; break;
		case	kGLMUniformBuffer:		m_buffGLTarget = GL_UNIFORM_BUFFER_EXT; break;
		case	kGLMPixelBuffer:		m_buffGLTarget = GL_PIXEL_UNPACK_BUFFER_ARB; break;
		
		default:	//Assert(!"Unknown buffer type" );
		break;
	}
	m_size = size;
	m_bound = false;
	m_mapped = false;
	m_lastMappedAddress = NULL;

	m_enableAsyncMap = false;
	m_enableExplicitFlush = false;
	m_dirtyMinOffset = m_dirtyMaxOffset = 0;								// adjust/grow on lock, clear on unlock

	m_ctx->CheckCurrent();
	m_revision = rand();

	// make a decision about pseudo mode
	// this looked like it didn't help much or was actually slower, so leave it available but only as opt-in.
	// a more clever implementation would be able to select pseudo buf storage for small batches only..
	m_pseudo = false;	// (m_type==kGLMIndexBuffer) && (CommandLine()->FindParm("-gl_enable_pseudobufs"));	
	if (m_pseudo)
	{
		m_name		= 0;		
		m_pseudoBuf	= (char*)malloc( size );
		
		m_ctx->BindBufferToCtx( m_type, NULL );		// exit with no buffer bound
	}
	else
	{
		glGenBuffersARB( 1, &m_name );
		GLMCheckError();

		m_ctx->BindBufferToCtx( m_type, this );	// causes glBindBufferARB

		// buffers start out static, but if they get orphaned and gl_bufmode is non zero,
		// then they will get flipped to dynamic.
		
		GLenum hint = GL_STATIC_DRAW_ARB;
		switch(m_type)
		{
			case	kGLMVertexBuffer:		hint = (options & GLMBufferOptionDynamic) ? GL_DYNAMIC_DRAW_ARB : GL_STATIC_DRAW_ARB; break;
			case	kGLMIndexBuffer:		hint = (options & GLMBufferOptionDynamic) ? GL_DYNAMIC_DRAW_ARB : GL_STATIC_DRAW_ARB; break;
			case	kGLMUniformBuffer:		hint = GL_DYNAMIC_DRAW_ARB; break;	// "fwiw" - shrug
			case	kGLMPixelBuffer:		hint = (options & GLMBufferOptionDynamic) ? GL_DYNAMIC_DRAW_ARB : GL_STATIC_DRAW_ARB; break;
			
			default:	//Assert(!"Unknown buffer type" );
			break;
		}

		glBufferDataARB( m_buffGLTarget, m_size, NULL, hint );	// may ultimately need more hints to set the usage correctly (esp for streaming)

		this->SetModes( false, true, true );

		m_ctx->BindBufferToCtx( m_type, NULL );	// unbind me
	}
}
Exemplo n.º 13
0
void loadMap(char *name){
  
  FILE *mapData = fopen(name, "rb");
  int a, b;
  
  fread(randSeed, sizeof(randSeed), 1, mapData);
  fread(buf, sizeof(Vertex)*(MAPSIZE-2)*(MAPSIZE-2)*5, 1, mapData);
  fread(ind, sizeof(unsigned int)*MAPSIZE*MAPSIZE*12, 1, mapData);
  
  
    
  unsigned int *partInd = (unsigned int *)malloc(sizeof(unsigned int)*(MAPSIZE/partialTerrainCount)*(MAPSIZE/partialTerrainCount)*12);
  //fprintf(fout, "%d\n", (1024/partialTerrainCount)*(1024/partialTerrainCount)*12);
  for(int i=0; i<partialTerrainCount; i++){
    for(int j=0; j<partialTerrainCount; j++){
      
      fread(&partIBSizes[i][j], sizeof(unsigned int), 1, mapData);
      //fprintf(fout, "%d %d %d\n", i, j, partIBSizes[i][j]);
      fread(partInd, sizeof(unsigned int)*partIBSizes[i][j], 1, mapData);
      
      
      glGenBuffersARB(1, &partIB[i][j]);
      glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, partIB[i][j]);
      glBufferDataARB(GL_ELEMENT_ARRAY_BUFFER_ARB, sizeof(unsigned int)*partIBSizes[i][j], partInd, GL_STATIC_DRAW_ARB);
      //fprintf(fout, "%d %d %d %d %d\n", i, j,  partIBSizes[i][j], partIB[i][j], partInd[0]);
    }  
  }
  
  free(partInd);
  
  fprintf(fout,"testo\n");
  
  glGenBuffersARB(1, &vb);
  glBindBufferARB(GL_ARRAY_BUFFER_ARB, vb); 
  glBufferDataARB(GL_ARRAY_BUFFER_ARB, sizeof(Vertex)*(MAPSIZE-2)*(MAPSIZE-2)*5, buf, GL_STATIC_DRAW_ARB);
 
   glGenBuffersARB(1, &ib);
  glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, ib);
  glBufferDataARB(GL_ELEMENT_ARRAY_BUFFER_ARB, sizeof(unsigned int)*MAPSIZE*MAPSIZE*12, ind, GL_STATIC_DRAW_ARB);
      
 
  memcpy(bufBig, buf, sizeof(Vertex)*(MAPSIZE-2)*(MAPSIZE-2)*5);
  
  
  
  fread(map.data, sizeof(float)*MAPSIZE*MAPSIZE, 1, mapData);
  
  fread(earth.data, sizeof(float)*MAPSIZE*MAPSIZE, 1, mapData);
  fread(dirt.data, sizeof(float)*MAPSIZE*MAPSIZE, 1, mapData);
  
  fread(temp.data, sizeof(int)*(MAPSIZE+2)*(MAPSIZE+2), 1, mapData);
  fread(norms.data, sizeof(vec3)*MAPSIZE*MAPSIZE, 1, mapData);
  
  fread(&mw, sizeof(int), 1, mapData);
  
    
  for(int a=0; a<mw; a++){
    int k, m;
      
    fread(&k, sizeof(int), 1, mapData);
    fread(&m, sizeof(int), 1, mapData);
  
  
    fread(buf, sizeof(Vertex)*k, 1, mapData);
    fread(ind, sizeof(unsigned int)*m, 1, mapData);
  
  
  
    glGenBuffersARB(1, &wvb[a]);
    glBindBufferARB(GL_ARRAY_BUFFER_ARB, wvb[a]); 
    glBufferDataARB(GL_ARRAY_BUFFER_ARB, sizeof(Vertex)*k, buf, GL_STATIC_DRAW_ARB);
 
 
    glGenBuffersARB(1, &wib[a]);
    glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, wib[a]);
    glBufferDataARB(GL_ELEMENT_ARRAY_BUFFER_ARB, sizeof(unsigned int)*m, ind, GL_STATIC_DRAW_ARB);
    wsizes[a] = m;
 
 
  }
  
  
  fread(&riverCount, sizeof(int), 1, mapData);
  fread(sup2.data, sizeof(char)*MAPSIZE*MAPSIZE, 1, mapData);
  fread(sup.data, sizeof(float)*MAPSIZE*MAPSIZE, 1, mapData);
  
  fprintf(fout, "river count%d\n", riverCount);
  fflush(stdout);
  for(int a=0; a<riverCount; a++){
    int k, m;
    
    fread(&k, sizeof(int), 1, mapData);
    int arr[2];
    
    fprintf(fout, " r%d size: %d\n", a, k);
    fflush(stdout);
    while(k--){
      fread((void*)arr, sizeof(int)*3, 1, mapData);
      
      fflush(stdout);
      rivers[a].push_back( (int3){arr[0], arr[1], arr[2]});
    }
    
    
    fread(&k, sizeof(int), 1, mapData);
    fread(&m, sizeof(int), 1, mapData);
  
  
    fread(buf, sizeof(Vertex)*k, 1, mapData);
    fread(ind, sizeof(unsigned int)*m, 1, mapData);
  
  
    fflush(fout);
    glGenBuffersARB(1, &rivervb[a]);
    glBindBufferARB(GL_ARRAY_BUFFER_ARB, rivervb[a]); 
    glBufferDataARB(GL_ARRAY_BUFFER_ARB, sizeof(Vertex)*k, buf, GL_STATIC_DRAW_ARB);
 
 
    glGenBuffersARB(1, &riverib[a]);
    glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, riverib[a]);
    glBufferDataARB(GL_ELEMENT_ARRAY_BUFFER_ARB, sizeof(unsigned int)*m, ind, GL_STATIC_DRAW_ARB);
    riversizes[a] = m;
  }
  
  fclose(mapData);
  
  for(int i=0; i<MAPSIZE-1; i++){
    for(int j=0; j<MAPSIZE-1; j++){
      height[i][j] = (map[i][j] + map[i][j+1] + map[i+1][j] + map[i+1][j+1])/4;
    }
  }  
}
Exemplo n.º 14
0
OCLRendererThread::OCLRendererThread(const size_t threadIndex, OCLRenderer *renderer,
			cl::Device device) : index(threadIndex), renderer(renderer),
		dev(device), usedDeviceMemory(0) {
	const GameLevel &gameLevel(*(renderer->gameLevel));
	const unsigned int width = gameLevel.gameConfig->GetScreenWidth();
	const unsigned int height = gameLevel.gameConfig->GetScreenHeight();

	const CompiledScene &compiledScene(*(renderer->compiledScene));

	if (renderer->renderThread.size() > 1)
		cpuFrameBuffer = new FrameBuffer(width, height);
	else
		cpuFrameBuffer = NULL;

	//--------------------------------------------------------------------------
	// OpenCL setup
	//--------------------------------------------------------------------------

	// Allocate a context with the selected device

	VECTOR_CLASS<cl::Device> devices;
	devices.push_back(dev);
	cl::Platform platform = dev.getInfo<CL_DEVICE_PLATFORM>();

	// The first thread uses OpenCL/OpenGL interoperability
	if (index == 0) {
#if defined (__APPLE__)
		CGLContextObj kCGLContext = CGLGetCurrentContext();
		CGLShareGroupObj kCGLShareGroup = CGLGetShareGroup(kCGLContext);
		cl_context_properties cps[] = {
			CL_CONTEXT_PROPERTY_USE_CGL_SHAREGROUP_APPLE, (cl_context_properties)kCGLShareGroup,
			0
		};
#else
#ifdef WIN32
		cl_context_properties cps[] = {
			CL_GL_CONTEXT_KHR, (intptr_t)wglGetCurrentContext(),
			CL_WGL_HDC_KHR, (intptr_t)wglGetCurrentDC(),
			CL_CONTEXT_PLATFORM, (cl_context_properties)platform(),
			0
		};
#else
		cl_context_properties cps[] = {
			CL_GL_CONTEXT_KHR, (intptr_t)glXGetCurrentContext(),
			CL_GLX_DISPLAY_KHR, (intptr_t)glXGetCurrentDisplay(),
			CL_CONTEXT_PLATFORM, (cl_context_properties)platform(),
			0
		};
#endif
#endif

		ctx = new cl::Context(devices, cps);
	} else
		ctx = new cl::Context(devices);

	// Allocate the queue for this device
	cmdQueue = new cl::CommandQueue(*ctx, dev);

	//--------------------------------------------------------------------------
	// Allocate the buffers
	//--------------------------------------------------------------------------

	passFrameBuffer = NULL;
	tmpFrameBuffer = NULL;
	frameBuffer = NULL;
	toneMapFrameBuffer = NULL;
	bvhBuffer = NULL;
	gpuTaskBuffer = NULL;
	cameraBuffer = NULL;
	infiniteLightBuffer = NULL;
	matBuffer = NULL;
	matIndexBuffer = NULL;
	texMapBuffer = NULL;
	texMapRGBBuffer = NULL;
	texMapInstanceBuffer = NULL;
	bumpMapInstanceBuffer = NULL;

	AllocOCLBufferRW(&passFrameBuffer, sizeof(Pixel) * width * height, "Pass FrameBuffer");
	AllocOCLBufferRW(&tmpFrameBuffer, sizeof(Pixel) * width * height, "Temporary FrameBuffer");
	if (index == 0) {
		AllocOCLBufferRW(&frameBuffer, sizeof(Pixel) * width * height, "FrameBuffer");
		AllocOCLBufferRW(&toneMapFrameBuffer, sizeof(Pixel) * width * height, "ToneMap FrameBuffer");
	}
	AllocOCLBufferRW(&gpuTaskBuffer, sizeof(ocl_kernels::GPUTask) * width * height, "GPUTask");
	AllocOCLBufferRO(&cameraBuffer, sizeof(compiledscene::Camera), "Camera");
	AllocOCLBufferRO(&infiniteLightBuffer, (void *)(gameLevel.scene->infiniteLight->GetTexture()->GetTexMap()->GetPixels()),
			sizeof(Spectrum) * gameLevel.scene->infiniteLight->GetTexture()->GetTexMap()->GetWidth() *
			gameLevel.scene->infiniteLight->GetTexture()->GetTexMap()->GetHeight(), "Inifinite Light");

	AllocOCLBufferRO(&matBuffer, (void *)(&compiledScene.mats[0]),
			sizeof(compiledscene::Material) * compiledScene.mats.size(), "Materials");
	AllocOCLBufferRO(&matIndexBuffer, (void *)(&compiledScene.sphereMats[0]),
			sizeof(unsigned int) * compiledScene.sphereMats.size(), "Material Indices");

	if (compiledScene.texMaps.size() > 0) {
		AllocOCLBufferRO(&texMapBuffer, (void *)(&compiledScene.texMaps[0]),
				sizeof(compiledscene::TexMap) * compiledScene.texMaps.size(), "Texture Maps");

		AllocOCLBufferRO(&texMapRGBBuffer, (void *)(compiledScene.rgbTexMem),
				sizeof(Spectrum) * compiledScene.totRGBTexMem, "Texture Map Images");

		AllocOCLBufferRO(&texMapInstanceBuffer, (void *)(&compiledScene.sphereTexs[0]),
				sizeof(compiledscene::TexMapInstance) * compiledScene.sphereTexs.size(), "Texture Map Instances");

		if (compiledScene.sphereBumps.size() > 0)
			AllocOCLBufferRO(&bumpMapInstanceBuffer, (void *)(&compiledScene.sphereBumps[0]),
					sizeof(compiledscene::BumpMapInstance) * compiledScene.sphereBumps.size(), "Bump Map Instances");
	}

	SFERA_LOG("[OCLRenderer] Total OpenCL device memory used: " << fixed << setprecision(2) << usedDeviceMemory / (1024 * 1024) << "Mbytes");

	if (index == 0) {
		//--------------------------------------------------------------------------
		// Create pixel buffer object for display
		//--------------------------------------------------------------------------

		glGenBuffersARB(1, &pbo);
		glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, pbo);
		glBufferDataARB(GL_PIXEL_UNPACK_BUFFER_ARB, width * height *
				sizeof(GLubyte) * 4, 0, GL_STREAM_DRAW_ARB);
		glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
		pboBuff = new cl::BufferGL(*ctx, CL_MEM_READ_WRITE, pbo);
	}

	//--------------------------------------------------------------------------
	// Compile the kernel source
	//--------------------------------------------------------------------------

	// Set #define symbols
	stringstream ss;
	ss.precision(6);
	ss << scientific <<
			" -D PARAM_SCREEN_WIDTH=" << width <<
			" -D PARAM_SCREEN_HEIGHT=" << height <<
			" -D PARAM_SCREEN_SAMPLEPERPASS="******" -D PARAM_RAY_EPSILON=" << EPSILON << "f" <<
			" -D PARAM_MAX_DIFFUSE_BOUNCE=" << gameLevel.maxPathDiffuseBounces <<
			" -D PARAM_MAX_SPECULARGLOSSY_BOUNCE=" << gameLevel.maxPathSpecularGlossyBounces <<
			" -D PARAM_IL_SHIFT_U=" << gameLevel.scene->infiniteLight->GetShiftU() << "f" <<
			" -D PARAM_IL_SHIFT_V=" << gameLevel.scene->infiniteLight->GetShiftV() << "f" <<
			" -D PARAM_IL_GAIN_R=" << gameLevel.scene->infiniteLight->GetGain().r << "f" <<
			" -D PARAM_IL_GAIN_G=" << gameLevel.scene->infiniteLight->GetGain().g << "f" <<
			" -D PARAM_IL_GAIN_B=" << gameLevel.scene->infiniteLight->GetGain().b << "f" <<
			" -D PARAM_IL_MAP_WIDTH=" << gameLevel.scene->infiniteLight->GetTexture()->GetTexMap()->GetWidth() <<
			" -D PARAM_IL_MAP_HEIGHT=" << gameLevel.scene->infiniteLight->GetTexture()->GetTexMap()->GetHeight() <<
			" -D PARAM_GAMMA=" << gameLevel.toneMap->GetGamma() << "f" <<
			" -D PARAM_MEM_TYPE=" << gameLevel.gameConfig->GetOpenCLMemType();

	if (compiledScene.enable_MAT_MATTE)
		ss << " -D PARAM_ENABLE_MAT_MATTE";
	if (compiledScene.enable_MAT_MIRROR)
		ss << " -D PARAM_ENABLE_MAT_MIRROR";
	if (compiledScene.enable_MAT_GLASS)
		ss << " -D PARAM_ENABLE_MAT_GLASS";
	if (compiledScene.enable_MAT_METAL)
		ss << " -D PARAM_ENABLE_MAT_METAL";
	if (compiledScene.enable_MAT_ALLOY)
		ss << " -D PARAM_ENABLE_MAT_ALLOY";

	if (texMapBuffer) {
		ss << " -D PARAM_HAS_TEXTUREMAPS";

		if (compiledScene.sphereBumps.size() > 0)
			ss << " -D PARAM_HAS_BUMPMAPS";
	}

	switch (gameLevel.toneMap->GetType()) {
		case TONEMAP_REINHARD02:
			ss << " -D PARAM_TM_LINEAR_SCALE=1.0f";
			break;
		case TONEMAP_LINEAR: {
			LinearToneMap *tm = (LinearToneMap *)gameLevel.toneMap;
			ss << " -D PARAM_TM_LINEAR_SCALE=" << tm->scale << "f";
			break;
		}
		default:
			assert (false);

	}

#if defined(__APPLE__)
	ss << " -D __APPLE__";
#endif

	SFERA_LOG("[OCLRenderer] Defined symbols: " << ss.str());
	SFERA_LOG("[OCLRenderer] Compiling kernels");

	cl::Program::Sources source(1, std::make_pair(KernelSource_kernel_core.c_str(), KernelSource_kernel_core.length()));
	cl::Program program = cl::Program(*ctx, source);
	try {
		VECTOR_CLASS<cl::Device> buildDevice;
		buildDevice.push_back(dev);
		program.build(buildDevice, ss.str().c_str());
	} catch (cl::Error err) {
		cl::STRING_CLASS strError = program.getBuildInfo<CL_PROGRAM_BUILD_LOG>(dev);
		SFERA_LOG("[OCLRenderer] Kernel compilation error:\n" << strError.c_str());

		throw err;
	}

	kernelInit = new cl::Kernel(program, "Init");
	kernelInit->setArg(0, *gpuTaskBuffer);
	cmdQueue->enqueueNDRangeKernel(*kernelInit, cl::NullRange,
			cl::NDRange(RoundUp<unsigned int>(width * height, WORKGROUP_SIZE)),
			cl::NDRange(WORKGROUP_SIZE));

	kernelInitFrameBuffer = new cl::Kernel(program, "InitFB");
	if (index == 0) {
		kernelInitFrameBuffer->setArg(0, *frameBuffer);
		cmdQueue->enqueueNDRangeKernel(*kernelInitFrameBuffer, cl::NullRange,
			cl::NDRange(RoundUp<unsigned int>(width * height, WORKGROUP_SIZE)),
			cl::NDRange(WORKGROUP_SIZE));
	}
	kernelInitFrameBuffer->setArg(0, *passFrameBuffer);

	kernelPathTracing = new cl::Kernel(program, "PathTracing");
	unsigned int argIndex = 0;
	kernelPathTracing->setArg(argIndex++, *gpuTaskBuffer);
	argIndex++;
	kernelPathTracing->setArg(argIndex++, *cameraBuffer);
	kernelPathTracing->setArg(argIndex++, *infiniteLightBuffer);
	kernelPathTracing->setArg(argIndex++, *passFrameBuffer);
	kernelPathTracing->setArg(argIndex++, *matBuffer);
	kernelPathTracing->setArg(argIndex++, *matIndexBuffer);
	if (texMapBuffer) {
		kernelPathTracing->setArg(argIndex++, *texMapBuffer);
		kernelPathTracing->setArg(argIndex++, *texMapRGBBuffer);
		kernelPathTracing->setArg(argIndex++, *texMapInstanceBuffer);
		if (compiledScene.sphereBumps.size() > 0)
			kernelPathTracing->setArg(argIndex++, *bumpMapInstanceBuffer);
	}

	kernelApplyBlurLightFilterXR1 = new cl::Kernel(program, "ApplyBlurLightFilterXR1");
	kernelApplyBlurLightFilterXR1->setArg(0, *passFrameBuffer);
	kernelApplyBlurLightFilterXR1->setArg(1, *tmpFrameBuffer);

	kernelApplyBlurLightFilterYR1 = new cl::Kernel(program, "ApplyBlurLightFilterYR1");
	kernelApplyBlurLightFilterYR1->setArg(0, *tmpFrameBuffer);
	kernelApplyBlurLightFilterYR1->setArg(1, *passFrameBuffer);

	kernelApplyBlurHeavyFilterXR1 = new cl::Kernel(program, "ApplyBlurHeavyFilterXR1");
	kernelApplyBlurHeavyFilterXR1->setArg(0, *passFrameBuffer);
	kernelApplyBlurHeavyFilterXR1->setArg(1, *tmpFrameBuffer);

	kernelApplyBlurHeavyFilterYR1 = new cl::Kernel(program, "ApplyBlurHeavyFilterYR1");
	kernelApplyBlurHeavyFilterYR1->setArg(0, *tmpFrameBuffer);
	kernelApplyBlurHeavyFilterYR1->setArg(1, *passFrameBuffer);

	kernelApplyBoxFilterXR1 = new cl::Kernel(program, "ApplyBoxFilterXR1");
	kernelApplyBoxFilterXR1->setArg(0, *passFrameBuffer);
	kernelApplyBoxFilterXR1->setArg(1, *tmpFrameBuffer);

	kernelApplyBoxFilterYR1 = new cl::Kernel(program, "ApplyBoxFilterYR1");
	kernelApplyBoxFilterYR1->setArg(0, *tmpFrameBuffer);
	kernelApplyBoxFilterYR1->setArg(1, *passFrameBuffer);

	if (index == 0) {
		kernelBlendFrame = new cl::Kernel(program, "BlendFrame");
		kernelBlendFrame->setArg(0, *passFrameBuffer);
		kernelBlendFrame->setArg(1, *frameBuffer);

		kernelToneMapLinear = new cl::Kernel(program, "ToneMapLinear");
		kernelToneMapLinear->setArg(0, *frameBuffer);
		kernelToneMapLinear->setArg(1, *toneMapFrameBuffer);

		kernelUpdatePixelBuffer = new cl::Kernel(program, "UpdatePixelBuffer");
		kernelUpdatePixelBuffer->setArg(0, *toneMapFrameBuffer);
		kernelUpdatePixelBuffer->setArg(1, *pboBuff);
	} else {
		kernelBlendFrame = NULL;
		kernelToneMapLinear = NULL;
		kernelUpdatePixelBuffer = NULL;
	}
}
Exemplo n.º 15
0
void ObjMeshGPUDeformer::MakeDisplayListsTriangles(int mode)
{
  #ifdef OBJMESHGPUDEFORMER_USING_VBOS
    printf("Creating VBOs...\n");
  #else
    printf("Creating display lists...\n");
  #endif

  // mode must be either OBJMESHRENDER_SMOOTH | OBJMESHRENDER_MATERIAL
  //                  or OBJMESHRENDER_SMOOTH | OBJMESHRENDER_MATERIAL | OBJMESHRENDER_TEXTURE

  if ((mode != (OBJMESHRENDER_SMOOTH | OBJMESHRENDER_MATERIAL)) &&
    (mode != (OBJMESHRENDER_SMOOTH | OBJMESHRENDER_MATERIAL | OBJMESHRENDER_TEXTURE)))
  {
    printf("Error: invalid rendering mode.\n");
    exit(1);
  }

  if (mode & OBJMESHRENDER_COLOR)
    glEnable(GL_COLOR_MATERIAL);
  else if (mode & OBJMESHRENDER_MATERIAL)
    glDisable(GL_COLOR_MATERIAL);

  #ifdef OBJMESHGPUDEFORMER_USING_VBOS
    vboID = (GLuint*) malloc (sizeof(GLuint) * 5 * numGroups);
    glGenBuffersARB(5 * numGroups, vboID);
  #else
    // create standard display lists
    displayListStart = glGenLists(numGroups);
  #endif

  // create the array data
  vboNormalEnabled = (int*) calloc (numGroups, sizeof(int));
  vboTex1Enabled = (int*) calloc (numGroups, sizeof(int));

  for(int groupNo=0; groupNo<numGroups; groupNo++)
  {
    // allocate space for group vbo data
    float * vtxBuffer = (float*) malloc (sizeof(float) * 9 * numGroupTriangles[groupNo]);
    float * normalBuffer = NULL;
    if (mode & OBJMESHRENDER_SMOOTH)
    {
      vboNormalEnabled[groupNo] = 1;
      normalBuffer = (float*) malloc (sizeof(float) * 9 * numGroupTriangles[groupNo]);
    }
    float * tex0Buffer = (float*) malloc (sizeof(float) * 6 * numGroupTriangles[groupNo]);
    float * tex1Buffer = NULL;
    if (mode & OBJMESHRENDER_TEXTURE)
    {
      vboTex1Enabled[groupNo] = 1;
      tex1Buffer = (float*) malloc (sizeof(float) * 6 * numGroupTriangles[groupNo]);
    }
    GLuint * indexBuffer = (GLuint*) malloc (sizeof(GLuint) * 3 * numGroupTriangles[groupNo]);

    const ObjMesh::Group * groupHandle = mesh->getGroupHandle(groupNo);

    int triangleCount = 0;
    for(unsigned int iFace = 0; iFace < groupHandle->getNumFaces(); iFace++)
    {
      const ObjMesh::Face * faceHandle = groupHandle->getFaceHandle(iFace);

      // triangulate the face on the fly
      for(unsigned int iVtx = 0; iVtx < faceHandle->getNumVertices() - 2; iVtx++)
      {
        unsigned int triangleVertex[3] = { 0, iVtx + 1, iVtx + 2 };

        for (int vtx=0; vtx<3; vtx++)
        {
          const ObjMesh::Vertex * vertex = faceHandle->getVertexHandle(triangleVertex[vtx]);
          Vec3d pos = mesh->getPosition(*vertex);
          for (int dof=0; dof<3; dof++)
            vtxBuffer[9*triangleCount + 3*vtx + dof] = pos[dof];

          if (vboNormalEnabled[groupNo])
          {
            Vec3d normal = mesh->getNormal(*vertex);
            for (int dof=0; dof<3; dof++)
              normalBuffer[9*triangleCount + 3*vtx + dof] = normal[dof];
          }

          int vertexIndex = vertex->getPositionIndex();
          Vec3d uv = Vec3d(gpgpuVertexTextureCoordinates[2*vertexIndex+0], 
                           gpgpuVertexTextureCoordinates[2*vertexIndex+1], 0);
          for (int dof=0; dof<2; dof++)
            tex0Buffer[6*triangleCount + 2*vtx + dof] = uv[dof];

          if (vboTex1Enabled[groupNo])
          {
            Vec3d uv = mesh->getTextureCoordinate(*vertex);
            for (int dof=0; dof<2; dof++)
              tex1Buffer[6*triangleCount + 2*vtx + dof] = uv[dof];
          }
        }

        for (int dof=0; dof<3; dof++)
          indexBuffer[3*triangleCount+dof] = 3*triangleCount+dof;

        triangleCount++;
      }
    }

    #ifdef OBJMESHGPUDEFORMER_USING_VBOS
      // upload the VBOs
      glBindBufferARB(GL_ARRAY_BUFFER_ARB, vboID[5*groupNo+0]);
      glBufferDataARB(GL_ARRAY_BUFFER_ARB, sizeof(float) * 9 * numGroupTriangles[groupNo], vtxBuffer, GL_STATIC_DRAW_ARB);

      glBindBufferARB(GL_ARRAY_BUFFER_ARB, vboID[5*groupNo+1]);
      if (vboNormalEnabled[groupNo])
        glBufferDataARB(GL_ARRAY_BUFFER_ARB, sizeof(float) * 9 * numGroupTriangles[groupNo], normalBuffer, GL_STATIC_DRAW_ARB);

      glBindBufferARB(GL_ARRAY_BUFFER_ARB, vboID[5*groupNo+2]);
      glBufferDataARB(GL_ARRAY_BUFFER_ARB, sizeof(float) * 6 * numGroupTriangles[groupNo], tex0Buffer, GL_STATIC_DRAW_ARB);

      glBindBufferARB(GL_ARRAY_BUFFER_ARB, vboID[5*groupNo+3]);
      if (vboTex1Enabled[groupNo])
        glBufferDataARB(GL_ARRAY_BUFFER_ARB, sizeof(float) * 6 * numGroupTriangles[groupNo], tex1Buffer, GL_STATIC_DRAW_ARB);

      glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, vboID[5*groupNo+4]); 
      glBufferDataARB(GL_ELEMENT_ARRAY_BUFFER_ARB, sizeof(GLuint) * 3 * numGroupTriangles[groupNo], indexBuffer, GL_STATIC_DRAW_ARB);

    #else

      PrintGLerror("before starting a new list");
      glNewList(displayListStart + groupNo, GL_COMPILE);

      glEnableClientState(GL_VERTEX_ARRAY);
      glVertexPointer(3, GL_FLOAT, 0, vtxBuffer);

      if (vboNormalEnabled[groupNo])
      {
        glEnableClientState(GL_NORMAL_ARRAY);
        glNormalPointer(GL_FLOAT, 0, normalBuffer);
      }

      glClientActiveTextureARB(GL_TEXTURE0_ARB); 
      glTexCoordPointer(2, GL_FLOAT, 0, tex0Buffer); 
      glEnableClientState(GL_TEXTURE_COORD_ARRAY); 

      if (vboTex1Enabled[groupNo])
      {
        glClientActiveTextureARB(GL_TEXTURE1_ARB); 
        glTexCoordPointer(2, GL_FLOAT, 0, tex1Buffer); 
        glEnableClientState(GL_TEXTURE_COORD_ARRAY);
      }

      glDrawElements(GL_TRIANGLES, 3 * numGroupTriangles[groupNo], GL_INT, indexBuffer);

      glDisableClientState(GL_VERTEX_ARRAY);
      glDisableClientState(GL_NORMAL_ARRAY);
      glClientActiveTextureARB(GL_TEXTURE0_ARB); 
      glDisableClientState(GL_TEXTURE_COORD_ARRAY);
      glClientActiveTextureARB(GL_TEXTURE1_ARB); 
      glDisableClientState(GL_TEXTURE_COORD_ARRAY);

      glEndList();    

      char msg[4096];
      sprintf(msg,"displayList creation, groupNo: %d\n",groupNo);
      PrintGLerror(msg);
    #endif

    // de-allocate space for group vbo data
    free(vtxBuffer);
    free(normalBuffer);
    free(tex0Buffer);
    free(tex1Buffer);
    free(indexBuffer);
  }

  #ifdef OBJMESHGPUDEFORMER_USING_VBOS
    // unbind buffers
    glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
    glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
  #endif
}
Exemplo n.º 16
0
panel panel_create(int width, int height, image font) {
    panel result = {width, height, font.width, font.height, NULL, NULL, 0, 0, 0, 0, 0};

    result.font = texture_create(font);
    result.foreground = malloc(4*width*height);
    result.background = malloc(4*width*height);

    // program and shader handles
    GLhandleARB vertex_shader, fragment_shader;

    int length;
    GLint shader_ok;

    // create and compiler vertex shader
    vertex_shader = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
    length = strlen(vertex_source);
    glShaderSourceARB(vertex_shader, 1, &vertex_source, &length);
    glCompileShaderARB(vertex_shader);
    glGetObjectParameterivARB(vertex_shader, GL_COMPILE_STATUS, &shader_ok);
    assert(shader_ok);

    // create and compiler fragment shader
    fragment_shader = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
    length = strlen(fragment_source);
    glShaderSourceARB(fragment_shader, 1, &fragment_source, &length);
    glCompileShaderARB(fragment_shader);
    glGetObjectParameterivARB(fragment_shader, GL_COMPILE_STATUS, &shader_ok);
    assert(shader_ok);

    // create program
    result.shader_program = glCreateProgramObjectARB();

    // attach shaders
    glAttachObjectARB(result.shader_program, vertex_shader);
    glAttachObjectARB(result.shader_program, fragment_shader);

    // link the program and check for errors
    glLinkProgramARB(result.shader_program);
    glGetObjectParameterivARB(result.shader_program, GL_LINK_STATUS, &shader_ok);
    assert(shader_ok);

    // we don't need these anymore
    glDeleteObjectARB(vertex_shader);
    glDeleteObjectARB(fragment_shader);

    // generate and bind the buffer object
    glGenBuffersARB(1, &result.vbo);
    glBindBufferARB(GL_ARRAY_BUFFER_ARB, result.vbo);

    // fill with data
    glBufferDataARB(GL_ARRAY_BUFFER_ARB, sizeof(GLfloat)*6*5, quad_data, GL_STATIC_DRAW_ARB);

    glActiveTexture(GL_TEXTURE1);
    glGenTextures(1, &result.fg_tex);
    glBindTexture(GL_TEXTURE_2D, result.fg_tex);

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, result.width, result.height, 0, GL_RGBA, GL_UNSIGNED_BYTE, result.foreground);

    glActiveTexture(GL_TEXTURE2);
    glGenTextures(1, &result.bg_tex);
    glBindTexture(GL_TEXTURE_2D, result.bg_tex);

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, result.width, result.height, 0, GL_RGBA, GL_UNSIGNED_BYTE, result.background);

    glUseProgramObjectARB(result.shader_program);

    glUniform1iARB(glGetUniformLocationARB(result.shader_program, "font"), 0);
    glUniform1iARB(glGetUniformLocationARB(result.shader_program, "foreground"), 1);
    glUniform1iARB(glGetUniformLocationARB(result.shader_program, "background"), 2);
    glUniform2fARB(glGetUniformLocationARB(result.shader_program, "panel_size"), width, height);

    return result;
}
Exemplo n.º 17
0
void ObjMeshGPUDeformer::MakeDisplayListsEdges()
{
  printf("Creating display list for edges...\n");

  #ifdef OBJMESHGPUDEFORMER_USING_VBOS
    vboEdgesID = (GLuint*) malloc (sizeof(GLuint) * 3 * numGroups);
    glGenBuffersARB(3 * numGroups, vboEdgesID);
  #else
    displayListEdgesStart = glGenLists(numGroups);
  #endif

  for(int groupNo=0; groupNo<numGroups; groupNo++)
  {
    int numGroupEdges = 3 * numGroupTriangles[groupNo];
    float * vtxBuffer = (float*) malloc (sizeof(float) * 6 * numGroupEdges);
    float * stBuffer = (float*) malloc (sizeof(float) * 4 * numGroupEdges);
    GLuint * indexBuffer = (GLuint*) malloc (sizeof(GLuint) * 2 * numGroupEdges);

    const ObjMesh::Group * groupHandle = mesh->getGroupHandle(groupNo);
    int edgeCount = 0;

    for(unsigned int iFace = 0; iFace < groupHandle->getNumFaces(); iFace++)
    {
      const ObjMesh::Face * faceHandle = groupHandle->getFaceHandle(iFace);

      for(unsigned int iVtx = 0; iVtx < faceHandle->getNumVertices() - 1; iVtx++)
      {
        unsigned int edgeVertex[2] = { iVtx, iVtx + 1 };

        for (int vtx=0; vtx<2; vtx++)
        {
          const ObjMesh::Vertex * vertex = faceHandle->getVertexHandle(edgeVertex[vtx]);
          int vertexIndex = vertex->getPositionIndex();
          Vec3d pos = mesh->getPosition(*vertex);
          for (int dof=0; dof<3; dof++)
            vtxBuffer[6*edgeCount + 3*vtx + dof] = pos[dof];

          float s = gpgpuVertexTextureCoordinates[2*vertexIndex+0];
          float t = gpgpuVertexTextureCoordinates[2*vertexIndex+1];
          float st[2] = {s, t};

          for (int dof=0; dof<2; dof++)
            stBuffer[4*edgeCount + 2*vtx + dof] = st[dof];

          for (int dof=0; dof<2; dof++)
            indexBuffer[2 * edgeCount + dof] = 2 * edgeCount + dof;
        }
       
        edgeCount++;
      }
    }

    #ifdef OBJMESHGPUDEFORMER_USING_VBOS
      glBindBufferARB(GL_ARRAY_BUFFER_ARB, vboEdgesID[3*groupNo+0]);
      glBufferDataARB(GL_ARRAY_BUFFER_ARB, sizeof(float) * 6 * numGroupEdges, vtxBuffer, GL_STATIC_DRAW_ARB);

      glBindBufferARB(GL_ARRAY_BUFFER_ARB, vboEdgesID[3*groupNo+1]);
      glBufferDataARB(GL_ARRAY_BUFFER_ARB, sizeof(float) * 4 * numGroupEdges, stBuffer, GL_STATIC_DRAW_ARB);

      glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, vboEdgesID[3*groupNo+2]); 
      glBufferDataARB(GL_ELEMENT_ARRAY_BUFFER_ARB, sizeof(GLuint) * 2 * numGroupEdges, indexBuffer, GL_STATIC_DRAW_ARB);
    #else
      PrintGLerror("before starting a new edge list");
      glNewList(displayListEdgesStart + groupNo, GL_COMPILE);

      glEnableClientState(GL_VERTEX_ARRAY);
      glVertexPointer(3, GL_FLOAT, 0, vtxBuffer);

      glClientActiveTextureARB(GL_TEXTURE0_ARB); 
      glTexCoordPointer(2, GL_FLOAT, 0, stBuffer); 
      glEnableClientState(GL_TEXTURE_COORD_ARRAY); 

      glDrawElements(GL_LINES, 2 * numGroupEdges, GL_INT, indexBuffer);

      glDisableClientState(GL_VERTEX_ARRAY);
      glClientActiveTextureARB(GL_TEXTURE0_ARB); 
      glDisableClientState(GL_TEXTURE_COORD_ARRAY);

      glEndList();    
    #endif

    free(indexBuffer);
    free(stBuffer);
    free(vtxBuffer);
  }

  #ifdef OBJMESHGPUDEFORMER_USING_VBOS
    // unbind buffer
    glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
    glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
  #endif
}    
Exemplo n.º 18
0
enum piglit_result
piglit_display(void)
{
	uint32_t buffer_size = 4096;
	bool pass = true;
	GLuint vbo;
	float green[] = {0, 1, 0, 0};
	uint32_t count = piglit_width * piglit_height;
	int i;

	glClearColor(1, 0, 0, 0);
	glClear(GL_COLOR_BUFFER_BIT);

	piglit_ortho_projection(piglit_width, piglit_height, false);
	glColor4fv(green);

	glGenBuffersARB(1, &vbo);
	glBindBufferARB(GL_ARRAY_BUFFER, vbo);
	glBufferData(GL_ARRAY_BUFFER, buffer_size, NULL, GL_STREAM_DRAW);
	glEnableClientState(GL_VERTEX_ARRAY);
	glVertexPointer(2, GL_FLOAT, 0, NULL);

	for (i = 0; i < count; i++) {
		int x = i % piglit_width;
		int y = (i / piglit_height) % piglit_height;
		float vert[] = {
			x,     y,
			x + 1, y,
			x + 1, y + 1,
			x,     y + 1,
		};
		uint32_t offset = i % (buffer_size / sizeof(vert));
		uint32_t indices[4] = {
			offset * 4,
			offset * 4 + 1,
			offset * 4 + 2,
			offset * 4 + 3
		};

		glBufferSubData(GL_ARRAY_BUFFER, offset * sizeof(vert),
				sizeof(vert), vert);

		switch (mode) {
		case DRAWARRAYS:
			glDrawArrays(GL_TRIANGLE_FAN, offset * 4, 4);
			break;
		case DRAWELEMENTS:
			glDrawElements(GL_TRIANGLE_FAN, 4, GL_UNSIGNED_INT,
				       indices);
			break;
		case DRAWRANGEELEMENTS:
			glDrawRangeElements(GL_TRIANGLE_FAN,
					    indices[0], indices[3],
					    4, GL_UNSIGNED_INT,
					    indices);
			break;
		}
	}

	pass = piglit_probe_rect_rgba(0, 0, piglit_width, piglit_height, green);

	piglit_present_results();

	return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
Exemplo n.º 19
0
void VolumeRayCasting::initContext(GLContextData& contextData) const
{
  DataItem* dataItem=new DataItem();
  contextData.addDataItem(this,dataItem);

  const char* datasetName = "bin/data/BostonTeapot.raw";
  int volumesize = 256*256*256;
  /*load sample data*/
  std::vector<unsigned char> volumeData;
  volumeData.resize(volumesize);
  std::ifstream ifs(datasetName, std::ios::binary);

  std::cout<<"open dataset file "<<std::endl;
  if(!ifs.is_open())
    {
      /* fail to open dataset file */
      std::cout<<"fail to open dataset file: "<<strerror(errno)<<std::endl;
      return;
    }
  ifs.read(reinterpret_cast<char *>(&volumeData.front()), volumesize * sizeof(float));
  ifs.close();

  /* Select the Volume Rendering texture object: */
  glBindTexture(GL_TEXTURE_3D,dataItem->volumeTex);
	
  /* Upload the Volume Rendering texture image: */
  glTexImage3D(GL_TEXTURE_3D, 0, GL_R8, 32, 32, 32, 0,  GL_RED, GL_UNSIGNED_BYTE, &volumeData.front());
  glTexParameteri(GL_TEXTURE_3D,GL_TEXTURE_WRAP_S,GL_CLAMP_TO_EDGE);
  glTexParameteri(GL_TEXTURE_3D,GL_TEXTURE_WRAP_T,GL_CLAMP_TO_EDGE);
  glTexParameteri(GL_TEXTURE_3D,GL_TEXTURE_WRAP_R,GL_CLAMP_TO_EDGE);
  glTexParameteri(GL_TEXTURE_3D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
  glTexParameteri(GL_TEXTURE_3D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
	
  /* Protect the Volume Rendering texture object: */
  glBindTexture(GL_TEXTURE_3D,0);
  //debug
  std::cout<<dataItem->volumeTex<<std::endl;
  /* Select the Tansfer Function texture object: */
  glBindTexture(GL_TEXTURE_2D,dataItem->transferFuncTex);
	
  /* Upload the Tansfer Function texture image: */
  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, transFuncData.size(), 1, 0, GL_RGBA, GL_FLOAT, &transFuncData.front());
  glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP_TO_EDGE);
  glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP_TO_EDGE);
  glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
  glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
	
  /* Protect the Tansfer Function texture object: */
  glBindTexture(GL_TEXTURE_2D,0);
  //debug
  std::cout<<dataItem->transferFuncTex<<std::endl;

  glClearColor(0.0, 0.0, 0.0, 0.0);
  glEnable(GL_BLEND);
  glBlendEquation(GL_FUNC_ADD);
  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  glEnable(GL_CULL_FACE);
  glCullFace(GL_FRONT);
  glDisable(GL_DEPTH_TEST);
  glColorMask(true, true, true, true);
  glDepthMask(true);
  glEnable(GL_MULTISAMPLE);

  if(dataItem->haveShaders)
    {
      {
    GLhandleARB vertexShader=glCompileVertexShaderFromFile("bin/Shaders/VolumeRayCasting.vert");
    GLhandleARB fragmentShader=glCompileFragmentShaderFromFile("bin/Shaders/VolumeRayCasting.frag");

	dataItem->rayCastingShader=glLinkShader(vertexShader,fragmentShader);

	glDeleteObjectARB(vertexShader);
	glDeleteObjectARB(fragmentShader);
      }	
    }


  std::vector<Vector2f> rectVertices;
  rectVertices.push_back(Vector2f(0.0f,0.0f));
  rectVertices.push_back(Vector2f(0.0f,1.0f));
  rectVertices.push_back(Vector2f(1.0f,1.0f));
  rectVertices.push_back(Vector2f(1.0f,0.0f));
  glGenBuffersARB(1,&(dataItem->rectVArrayBufferId));
  glBindBufferARB(GL_ARRAY_BUFFER, dataItem->rectVArrayBufferId);
  glBufferDataARB(GL_ARRAY_BUFFER, rectVertices.size()*sizeof(Vector2f), &rectVertices.front(),GL_STATIC_DRAW);
  glBindBufferARB(GL_ARRAY_BUFFER, 0);

  GLuint index = glGetAttribLocationARB(dataItem->rayCastingShader, "Vertex");
  glGenVertexArrays(1,&(dataItem->rectVerticesArrayId));
  glBindVertexArray(dataItem->rectVerticesArrayId);
  glBindBufferARB(GL_ARRAY_BUFFER, dataItem->rectVArrayBufferId);
  glEnableVertexAttribArrayARB(index);
  glVertexAttribPointerARB(index,2, GL_FLOAT,false,0,NULL);
  glBindVertexArray(0);
  glBindBufferARB(GL_ARRAY_BUFFER, 0);

  //debug
  std::cout<<"initial 1"<<std::endl;

  glNewList(dataItem->displayListIds[0],GL_COMPILE);
  glBindVertexArray(dataItem->rectVerticesArrayId);
  glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
  glBindVertexArray(0);
  glEndList();
  //debug
  std::cout<<"initial finish"<<std::endl;

}
Exemplo n.º 20
0
/////////////////////////////////////////////////////////
// render
//
/////////////////////////////////////////////////////////
void vertex_draw :: render(GemState *state)
{
  bool rebuild=(state->VertexDirty);
  //if(rebuild)post("rebuild");

  if (state->VertexArray == NULL || state->VertexArraySize <= 0) {
    //  post("no vertex array!");
    return;
  }
  int size = state->VertexArraySize;

  int color=m_color;
  if (state->ColorArray == NULL || state->HaveColorArray == 0) {
    //color = 0;
  }

  bool texcoord=m_texcoord;
  if (texcoord && (state->TexCoordArray == NULL
                   || state->HaveTexCoordArray == 0)) {
    post("no Texture Coordinate array!");
    texcoord = 0;
  }

  GLint drawType=m_drawType;
  if (state->drawType && m_defaultDraw) {
    drawType = state->drawType;
  }

  glShadeModel( GL_SMOOTH );
  glEnable(GL_BLEND);
  glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);

#ifndef __VBO
///////////////////////////////////////////
// vertex_array_object

# ifdef __APPLE__
  if (m_vao) {
    if (!glIsVertexArrayAPPLE(1)) {
      post("vertex draw: not using VAO");
    }
    glBindVertexArrayAPPLE(1);
  }
# endif

  glDisableClientState(GL_INDEX_ARRAY);

  if(color && (state->ColorArray != NULL || state->HaveColorArray == 0) ) {
    glEnableClientState(GL_COLOR_ARRAY);
    glColorPointer(4,GL_FLOAT,0,state->ColorArray);
  } else {
    glDisableClientState(GL_COLOR_ARRAY);
  }

  if(texcoord) {
    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
    glTexCoordPointer(2,GL_FLOAT,0,state->TexCoordArray);
//    glTexCoordPointer(2,GL_FLOAT,16,state->TexCoordArray);
  } else {
    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
  }

  if(state->HaveNormalArray || state->NormalArray!=NULL) {
    glEnableClientState(GL_NORMAL_ARRAY);
    glNormalPointer(GL_FLOAT,0,state->NormalArray);
//      glNormalPointer(GL_FLOAT,16,state->NormalArray);
  }

  glEnableClientState(GL_VERTEX_ARRAY);
  glVertexPointer(4,GL_FLOAT,0,
                  reinterpret_cast<GLfloat *>(state->VertexArray));

#if defined GL_VERTEX_ARRAY_RANGE_APPLE
  glVertexArrayParameteriAPPLE(GL_VERTEX_ARRAY_STORAGE_HINT_APPLE,
                               GL_STORAGE_SHARED_APPLE);
  glVertexArrayRangeAPPLE( size,
                           reinterpret_cast<GLvoid *>(state->VertexArray));
  glEnableClientState( GL_VERTEX_ARRAY_RANGE_APPLE );
  glFlushVertexArrayRangeAPPLE( size,
                                reinterpret_cast<GLvoid *>(state->VertexArray));
#endif

  glDrawArrays(m_drawType,0,size);
  glDisableClientState(GL_VERTEX_ARRAY);

#if defined GL_VERTEX_ARRAY_RANGE_APPLE
  glDisableClientState(GL_VERTEX_ARRAY_RANGE_APPLE);
  glVertexArrayRangeAPPLE(0,0);
# endif

  if(color) {
    glDisableClientState(GL_COLOR_ARRAY);
  }
  glDisableClientState(GL_TEXTURE_COORD_ARRAY);
  glDisableClientState(GL_NORMAL_ARRAY);

  glDisable(GL_BLEND);

#else   /* YES, we want VBO ! */

  // set-up the VertexArray
  if (m_vao) {
    if (rebuild || !m_nVBOVertices ) {
      if(!m_nVBOVertices) {
        glGenBuffersARB( 1, &m_nVBOVertices );
      }

      glBindBufferARB(GL_ARRAY_BUFFER_ARB, m_nVBOVertices);
      glBufferDataARB( GL_ARRAY_BUFFER_ARB,
                       size * state->VertexArrayStride * sizeof(float),
                       state->VertexArray, GL_DYNAMIC_DRAW_ARB );
      glVertexPointer( state->VertexArrayStride, GL_FLOAT,0,
                       reinterpret_cast<char*>(NULL));
    } else {
      glBindBufferARB(GL_ARRAY_BUFFER_ARB, m_nVBOVertices);
      glVertexPointer( state->VertexArrayStride, GL_FLOAT,0,
                       reinterpret_cast<char*>(NULL));
    }
    glEnableClientState( GL_VERTEX_ARRAY );
  }

  // setup the ColorArray
  if( state->HaveColorArray || state->ColorArray != NULL ) {
    glEnableClientState(GL_COLOR_ARRAY);
    if (rebuild || !m_nVBOColor ) {
      if(!m_nVBOColor) {
        glGenBuffersARB( 1, &m_nVBOColor );
      }

      glBindBufferARB(GL_ARRAY_BUFFER_ARB, m_nVBOColor);
      glBufferDataARB( GL_ARRAY_BUFFER_ARB, size*4*sizeof(float),
                       state->ColorArray, GL_DYNAMIC_DRAW_ARB );
      glColorPointer(4,GL_FLOAT,0,reinterpret_cast<char*>(NULL));
    } else {
      glBindBufferARB(GL_ARRAY_BUFFER_ARB, m_nVBOColor);
      glColorPointer(4,GL_FLOAT,0,reinterpret_cast<char*>(NULL));
    }
  } else {
    glDisableClientState(GL_COLOR_ARRAY);
  }

  // setup the TexCoordArray
  if ( state->HaveTexCoordArray || state->TexCoordArray != NULL ) {
    if (rebuild || !m_nVBOTexCoords ) {
      if(!m_nVBOTexCoords) {
        glGenBuffersARB( 1, &m_nVBOTexCoords );
      }
      glBindBufferARB( GL_ARRAY_BUFFER_ARB, m_nVBOTexCoords);
      glBufferDataARB( GL_ARRAY_BUFFER_ARB, size*2*sizeof(float),
                       state->TexCoordArray, GL_DYNAMIC_DRAW_ARB );
      glTexCoordPointer(2, GL_FLOAT, 0, reinterpret_cast<char *>(NULL));
    } else {
      glBindBufferARB( GL_ARRAY_BUFFER_ARB, m_nVBOTexCoords);
      glTexCoordPointer(2, GL_FLOAT, 0, reinterpret_cast<char *>(NULL));
    }
  }

  // setup the NormalArray
  if(state->HaveNormalArray || state->NormalArray!=NULL) {
    glEnableClientState(GL_NORMAL_ARRAY);
    if (rebuild || !m_nVBONormals ) {
      if(!m_nVBONormals) {
        glGenBuffersARB( 1, &m_nVBONormals );
      }
      glBindBufferARB( GL_ARRAY_BUFFER_ARB, m_nVBONormals );
      glBufferDataARB( GL_ARRAY_BUFFER_ARB, size*1*sizeof(float),
                       state->NormalArray, GL_DYNAMIC_DRAW_ARB );
      glNormalPointer(GL_FLOAT,0, reinterpret_cast<char *>(NULL));
    } else {
      glBindBufferARB( GL_ARRAY_BUFFER_ARB, m_nVBONormals );
      glNormalPointer(GL_FLOAT,0, reinterpret_cast<char *>(NULL));
    }
  }

//  glEnableClientState(GL_VERTEX_ARRAY);
//  glVertexPointer( 4, GL_FLOAT,0, reinterpret_cast<char*>(NULL));

  glDrawArrays(drawType,0,size);
  glDisableClientState(GL_VERTEX_ARRAY);
  if(color) {
    glDisableClientState(GL_COLOR_ARRAY);
  }

  glDisableClientState(GL_TEXTURE_COORD_ARRAY);
  glDisableClientState(GL_NORMAL_ARRAY);
  // if(texcoord)glDisableClientState(GL_TEXTURE_COORD_ARRAY);
  glDisable(GL_BLEND);
# endif /* VBO */
}
Exemplo n.º 21
0
void MeshRenderer :: setMesh(const Mesh& mesh)
{
    m_pbuffer->makeCurrent();

    clearVertexBufferObject();
    m_mesh = &mesh;

    GLuint vbo_id = -1, vbo_faces_id = -1;
    glGenBuffersARB(1, &vbo_id);
    if (mesh.hasFaces())
        glGenBuffersARB(1, &vbo_faces_id);

    VertexBufferObject& vbo = m_vertex_buffer_object;
    vbo.nb_faces = 0;
    vbo.vertex_id = vbo_id;
    vbo.faces_id = vbo_faces_id;
    vbo.has_faces = mesh.hasFaces();
    vbo.has_color = mesh.hasColors();
    vbo.has_texcoords = mesh.hasTexcoords();
    vbo.color_offset = mesh.vertices.size()*sizeof(Vec3f);
    vbo.texture_offset = mesh.vertices.size()*sizeof(Vec3f) + mesh.colors.size() * sizeof(Vec3b);
    vbo.nb_vertices = mesh.vertices.size();

    glBindBufferARB(GL_ARRAY_BUFFER_ARB, vbo.vertex_id);
    glBufferDataARB(GL_ARRAY_BUFFER_ARB,
                    mesh.colors.size()*sizeof(Vec3b)
                    + mesh.vertices.size()*sizeof(Vec3f)
                    + mesh.texcoords.size()*sizeof(Point2f), // size
                    0, // null pointer: just allocate memory
                    GL_STATIC_DRAW_ARB);
    glBufferSubDataARB(GL_ARRAY_BUFFER_ARB, 0, mesh.vertices.size()*sizeof(Vec3f), &mesh.vertices[0]);

    if (vbo.has_texcoords)
        glBufferSubDataARB(GL_ARRAY_BUFFER_ARB, vbo.texture_offset, mesh.texcoords.size()*sizeof(Point2f), &mesh.texcoords[0]);
    else if (vbo.has_color)
        glBufferSubDataARB(GL_ARRAY_BUFFER_ARB, vbo.color_offset, mesh.colors.size()*sizeof(Vec3b), &mesh.colors[0]);

    if (vbo.has_faces)
    {
        vbo.nb_faces = mesh.faces.size();
        glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, vbo.faces_id);
        glBufferDataARB(GL_ELEMENT_ARRAY_BUFFER_ARB,
                        mesh.faces.size() * 3 * sizeof(GLuint), // size
                        (GLuint*)&mesh.faces[0],
                        GL_STATIC_DRAW_ARB);
    }

    if (mesh.texture.data)
    {
        glGenTextures( 1, &vbo.texture_id );
        glBindTexture( GL_TEXTURE_2D, vbo.texture_id );
        glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE );
        glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
        //glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_BASE_LEVEL,0);
        //glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAX_LEVEL,0);
        //glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP_TO_EDGE);
        //glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP_TO_EDGE);
        glTexImage2D(GL_TEXTURE_2D, 0,
                     GL_RGB8, mesh.texture.cols, mesh.texture.rows,
                     0, GL_BGR, GL_UNSIGNED_BYTE,mesh.texture.data);
    }   

    vbo.initialized = true;
}
Exemplo n.º 22
0
/**
 *  erzeugt die OpenGL-Vertices.
 *
 *  @author OLiver
 *  @author FloSoft
 */
void TerrainRenderer::GenerateOpenGL(const GameWorldViewer* gwv)
{
    width = gwv->GetWidth();
    height = gwv->GetHeight();
    LandscapeType lt = gwv->GetLandscapeType();

    GenerateVertices(gwv);

    unsigned int offset = width * height * 2;

    // Ränder zählen
    borders = new Borders[width * height];
    for(MapCoord y = 0; y < height; ++y)
    {
        for(MapCoord x = 0; x < width; ++x)
        {
            MapPoint pt(x, y);
            unsigned char t1 = gwv->GetNode(pt).t1;
            unsigned char t2 = gwv->GetNode(pt).t2;
            unsigned int pos = GetTRIdx(pt);

            if( (borders[pos].left_right[0] = BORDER_TABLES[lt][t1][t2][1]) )
            {
                borders[pos].left_right_offset[0] = offset + border_count;
                ++border_count;
            }
            if( (borders[pos].left_right[1] = BORDER_TABLES[lt][t1][t2][0]) )
            {
                borders[pos].left_right_offset[1] = offset + border_count;
                ++border_count;
            }

            t1 = gwv->GetNodeAround(pt, 3).t1;
            if( (borders[pos].right_left[0] = BORDER_TABLES[lt][t2][t1][1]) )
            {
                borders[pos].right_left_offset[0] = offset + border_count;
                ++border_count;
            }
            if( (borders[pos].right_left[1] = BORDER_TABLES[lt][t2][t1][0]) )
            {
                borders[pos].right_left_offset[1] = offset + border_count;
                ++border_count;
            }

            t1 = gwv->GetNode(pt).t1;
            t2 = gwv->GetNodeAround(pt, 5).t2;
            if( (borders[pos].top_down[0] = BORDER_TABLES[lt][t1][t2][1]) )
            {
                borders[pos].top_down_offset[0] = offset + border_count;
                ++border_count;
            }
            if( (borders[pos].top_down[1] = BORDER_TABLES[lt][t1][t2][0]) )
            {
                borders[pos].top_down_offset[1] = offset + border_count;
                ++border_count;
            }
        }
    }

    gl_vertices = new Triangle[offset + border_count];
    gl_texcoords = new Triangle[offset + border_count];
    gl_colors = new ColorTriangle[offset + border_count];

    // Normales Terrain erzeugen
    for(MapCoord y = 0; y < height; ++y)
    {
        for(MapCoord x = 0; x < width; ++x)
        {
            MapPoint pt(x, y);
            UpdateTrianglePos(pt, gwv, false);
            UpdateTriangleColor(pt, gwv, false);
            UpdateTriangleTerrain(pt, gwv, false);
        }
    }

    // Ränder erzeugen
    for(MapCoord y = 0; y < height; ++y)
    {
        for(MapCoord x = 0; x < width; ++x)
        {
            MapPoint pt(x, y);
            UpdateBorderTrianglePos(pt, gwv, false);
            UpdateBorderTriangleColor(pt, gwv, false);
            UpdateBorderTriangleTerrain(pt, gwv, false);
        }
    }
    //unsigned buffer_size = (offset ) * 2 * 3 * sizeof(float);

    if(SETTINGS.video.vbo)
    {
        // Generiere und Binde den Vertex Buffer
        glGenBuffersARB(1, (GLuint*)&vbo_vertices);
        glBindBufferARB(GL_ARRAY_BUFFER_ARB, vbo_vertices);
        glBufferDataARB(GL_ARRAY_BUFFER_ARB, (offset + border_count) * 3 * 2 * sizeof(float), gl_vertices, GL_STATIC_DRAW_ARB);
        glVertexPointer(2, GL_FLOAT, 0, NULL);

        // Generiere und Binde den Textur Koordinaten Buffer
        glGenBuffersARB(1, (GLuint*)&vbo_texcoords);
        glBindBufferARB(GL_ARRAY_BUFFER_ARB, vbo_texcoords);
        glBufferDataARB(GL_ARRAY_BUFFER_ARB, (offset + border_count) * 3 * 2 * sizeof(float), gl_texcoords, GL_STATIC_DRAW_ARB );
        glTexCoordPointer(2, GL_FLOAT, 0, NULL);

        // Generiere und Binde den Color Buffer
        glGenBuffersARB(1, (GLuint*)&vbo_colors);
        glBindBufferARB(GL_ARRAY_BUFFER_ARB, vbo_colors);
        glBufferDataARB(GL_ARRAY_BUFFER_ARB, (offset + border_count) * 3 * 3 * sizeof(float), gl_colors, GL_STATIC_DRAW_ARB );
        glColorPointer(3, GL_FLOAT, 0, NULL);
    }
    else
    {
        glVertexPointer(2, GL_FLOAT, 0, gl_vertices);
        glTexCoordPointer(2, GL_FLOAT, 0, gl_texcoords);
        glColorPointer(3, GL_FLOAT, 0, gl_colors);
    }
}
Exemplo n.º 23
0
// calls each blocks renderToVBO function to create the VBO
bool VBOChunk::buildVBO(World &world, std::vector<Vertex> *vb, std::vector<TexVert> *tb, std::vector<ColVert> *cb,
                        std::vector<Vertex> *tvb, std::vector<TexVert> *ttb, std::vector<ColVert> *tcb)
{
    Block *block;

    vertBuffer = vb;
    texBuffer = tb;
    colBuffer = cb;

    transVertBuffer = tvb;
    transTexBuffer = ttb;
    transColBuffer = tcb;

    for(int xx = 0; xx < 16; xx++)
    {
        for(int yy = 0; yy < 16; yy++)
        {
            for(int zz = 0; zz < 16; zz++)
            {
                block = world.getBlock(xx + posx, yy + posy, zz + posz);
                if(block)
                    block->renderToVBO(world, *this, xx, yy, zz);
            }
        }
    }
    vertexCount = vertBuffer->size();
    transVertexCount = transVertBuffer->size();
    
    bool r = false;

    if(vertexCount > 0)
    {
        r = true;
        std::vector<Vertex>::iterator iter = vertBuffer->begin();
        glGenBuffersARB(1, &m_VBOverticies);                        // get a valid name
        glBindBufferARB(GL_ARRAY_BUFFER_ARB, m_VBOverticies);       // bind the buffer
        // load the data
        glBufferDataARB(GL_ARRAY_BUFFER_ARB, vertBuffer->size()*3*sizeof(float), &(*iter), GL_STATIC_DRAW_ARB);

        std::vector<TexVert>::iterator titer = texBuffer->begin();
        glGenBuffersARB(1, &m_VBOtex);
        glBindBufferARB(GL_ARRAY_BUFFER_ARB, m_VBOtex);
        glBufferDataARB(GL_ARRAY_BUFFER_ARB, texBuffer->size()*2*sizeof(float), &(*titer), GL_STATIC_DRAW_ARB);

        std::vector<ColVert>::iterator citer = colBuffer->begin();
        glGenBuffersARB(1, &m_VBOcol);
        glBindBufferARB(GL_ARRAY_BUFFER_ARB, m_VBOcol);
        glBufferDataARB(GL_ARRAY_BUFFER_ARB, colBuffer->size()*4*sizeof(float), &(*citer), GL_STATIC_DRAW_ARB);
    }
    if(transVertexCount > 0)
    {
        r = true;
        std::vector<Vertex>::iterator tit = transVertBuffer->begin();
        glGenBuffersARB(1, &m_transVBOverticies);
        glBindBufferARB(GL_ARRAY_BUFFER_ARB, m_transVBOverticies);
        glBufferDataARB(GL_ARRAY_BUFFER_ARB, transVertBuffer->size()*3*sizeof(float), &(*tit), GL_STATIC_DRAW_ARB);

        std::vector<TexVert>::iterator ttit = transTexBuffer->begin();
        glGenBuffersARB(1, &m_transVBOtex);
        glBindBufferARB(GL_ARRAY_BUFFER_ARB, m_transVBOtex);
        glBufferDataARB(GL_ARRAY_BUFFER_ARB, transTexBuffer->size()*2*sizeof(float), &(*ttit), GL_STATIC_DRAW_ARB);

        std::vector<ColVert>::iterator tcit = transColBuffer->begin();
        glGenBuffersARB(1, &m_transVBOcol);
        glBindBufferARB(GL_ARRAY_BUFFER_ARB, m_transVBOcol);
        glBufferDataARB(GL_ARRAY_BUFFER_ARB, transColBuffer->size()*4*sizeof(float), &(*tcit), GL_STATIC_DRAW_ARB);
    }

    vertBuffer->clear();
    texBuffer->clear();
    colBuffer->clear();

    transVertBuffer->clear();
    transTexBuffer->clear();
    transColBuffer->clear();

    vertBuffer = 0;
    texBuffer = 0;
    colBuffer = 0;

    transVertBuffer = 0;
    transTexBuffer = 0;
    transColBuffer = 0;

    return r;
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBBufferObject_nglGenBuffersARB(JNIEnv *env, jclass clazz, jint n, jlong buffers, jlong function_pointer) {
	GLuint *buffers_address = (GLuint *)(intptr_t)buffers;
	glGenBuffersARBPROC glGenBuffersARB = (glGenBuffersARBPROC)((intptr_t)function_pointer);
	glGenBuffersARB(n, buffers_address);
}
Exemplo n.º 25
0
int main(int argc, char **argv)
{
	SDL_Window *window;
	SDL_GLContext context;
	SDL_Event evt;
	MOJOSHADER_glContext *shaderContext;
	MOJOSHADER_effect *effect;
	MOJOSHADER_glEffect *glEffect;
	SDL_Surface *bitmap;
	GLuint texture;
	GLuint buffers[2];
	FILE *fileIn;
	unsigned int fileLen;
	unsigned char *effectData;
	unsigned int passes;
	MOJOSHADER_effectStateChanges changes;
	Uint8 run = 1;

	/* Create the window and GL context */
	SDL_Init(SDL_INIT_VIDEO);
	SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
	SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
	SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
	SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
	SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
	SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8);
	SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
	SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_DEBUG_FLAG);
	window = SDL_CreateWindow(
		"Sprite Test",
		SDL_WINDOWPOS_CENTERED,
		SDL_WINDOWPOS_CENTERED,
		SCREEN_WIDTH,
		SCREEN_HEIGHT,
		SDL_WINDOW_OPENGL
	);
	context = SDL_GL_CreateContext(window);
	shaderContext = MOJOSHADER_glCreateContext(
		MOJOSHADER_PROFILE,
		GetGLProcAddress,
		NULL,
		NULL,
		NULL,
		NULL
	);
	MOJOSHADER_glMakeContextCurrent(shaderContext);

	/* ARB_debug_output setup */
	glDebugMessageCallbackARB(GLDebugCallback, NULL);
	glDebugMessageControlARB(
		GL_DONT_CARE,
		GL_DONT_CARE,
		GL_DONT_CARE,
		0,
		NULL,
		GL_TRUE
	);

	/* Set up the viewport, create the texture/buffer data */
	glViewport(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
	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);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, GL_REPEAT);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_LOD_BIAS, 0.0f);
	bitmap = SDL_LoadBMP("../Sprite.bmp");
	glTexImage2D(
		GL_TEXTURE_2D,
		0,
		GL_RGB,
		bitmap->w,
		bitmap->h,
		0,
		GL_BGR,
		GL_UNSIGNED_BYTE,
		bitmap->pixels
	);
	SDL_FreeSurface(bitmap);
	glGenBuffersARB(2, buffers);
	glBindBufferARB(GL_ARRAY_BUFFER, buffers[0]);
	glBufferDataARB(
		GL_ARRAY_BUFFER,
		sizeof(vertexstruct_t) * 4,
		vertex_array,
		GL_STATIC_DRAW
	);
	glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER, buffers[1]);
	glBufferDataARB(
		GL_ELEMENT_ARRAY_BUFFER,
		12,
		index_array,
		GL_STATIC_DRAW
	);

	/* Load and read the SpriteBatch effect file */
	fileIn = fopen("../SpriteEffect.fxb", "rb");
	fseek(fileIn, 0, SEEK_END);
	fileLen = ftell(fileIn);
	fseek(fileIn, 0, SEEK_SET);
	effectData = (unsigned char*) malloc(fileLen);
	fread(effectData, 1, fileLen, fileIn);
	fclose(fileIn);
	effect = MOJOSHADER_parseEffect(
		MOJOSHADER_PROFILE,
		effectData,
		fileLen,
		NULL,
		0,
		NULL,
		0,
		NULL,
		NULL,
		NULL
	);
	free(effectData);
	glEffect = MOJOSHADER_glCompileEffect(effect);
	MOJOSHADER_effectSetRawValueName(
		effect,
		"MatrixTransform",
		transform_matrix,
		0,
		64
	);

	while (run)
	{
		while (SDL_PollEvent(&evt) > 0)
		{
			if (evt.type == SDL_QUIT)
			{
				run = 0;
			}
		}

		/* Clear the screen to black. */
		glClear(GL_COLOR_BUFFER_BIT);

		/* Bind the effect */
		MOJOSHADER_glEffectBegin(glEffect, &passes, 0, &changes);
		MOJOSHADER_glEffectBeginPass(glEffect, 0);

		/* Set the attrib pointers now, while the effect is bound */
		MOJOSHADER_glSetVertexAttribute(
			MOJOSHADER_USAGE_POSITION,
			0,
			3,
			MOJOSHADER_ATTRIBUTE_FLOAT,
			0,
			sizeof(vertexstruct_t),
			(void*) 0
		);
		MOJOSHADER_glSetVertexAttribute(
			MOJOSHADER_USAGE_COLOR,
			0,
			4,
			MOJOSHADER_ATTRIBUTE_UBYTE,
			1,
			sizeof(vertexstruct_t),
			(void*) 12
		);
		MOJOSHADER_glSetVertexAttribute(
			MOJOSHADER_USAGE_TEXCOORD,
			0,
			2,
			MOJOSHADER_ATTRIBUTE_FLOAT,
			0,
			sizeof(vertexstruct_t),
			(void*) 16
		);

		/* Flush all changes to the shader and constant buffers */
		MOJOSHADER_glProgramReady();

		/* Draw! */
		glDrawRangeElements(
			GL_TRIANGLES,
			0,
			3,
			6,
			GL_UNSIGNED_SHORT,
			NULL
		);

		/* We've finished drawing. Present what we've drawn. */
		MOJOSHADER_glEffectEndPass(glEffect);
		MOJOSHADER_glEffectEnd(glEffect);
		SDL_GL_SwapWindow(window);
	}

	/* Clean up. We out. */
	glDeleteBuffersARB(2, buffers);
	glDeleteTextures(1, &texture);
	MOJOSHADER_glDeleteEffect(glEffect);
	MOJOSHADER_freeEffect(effect);
	MOJOSHADER_glMakeContextCurrent(NULL);
	MOJOSHADER_glDestroyContext(shaderContext);
	SDL_GL_DeleteContext(context);
	SDL_DestroyWindow(window);
	SDL_Quit();
	return 0;
}
Exemplo n.º 26
0
/*
============
R_CreateIBO2
============
*/
IBO_t          *R_CreateIBO2(const char *name, int numTriangles, srfTriangle_t * triangles, vboUsage_t usage)
{
	IBO_t          *ibo;
	int             i, j;

	byte           *indexes;
	int             indexesSize;
	int             indexesOfs;

	srfTriangle_t  *tri;
	glIndex_t       index;
	int				glUsage;

	switch (usage)
	{
		case VBO_USAGE_STATIC:
			glUsage = GL_STATIC_DRAW_ARB;
			break;

		case VBO_USAGE_DYNAMIC:
			glUsage = GL_DYNAMIC_DRAW_ARB;
			break;

		default:
			Com_Error(ERR_FATAL, "bad vboUsage_t given: %i", usage);
	}

	if(!numTriangles)
		return NULL;

	if(strlen(name) >= MAX_QPATH)
	{
		ri.Error(ERR_DROP, "R_CreateIBO2: \"%s\" is too long\n", name);
	}

	// make sure the render thread is stopped
	R_SyncRenderThread();

	ibo = ri.Hunk_Alloc(sizeof(*ibo), h_low);
	Com_AddToGrowList(&tr.ibos, ibo);

	Q_strncpyz(ibo->name, name, sizeof(ibo->name));

	indexesSize = numTriangles * 3 * sizeof(glIndex_t);
	indexes = ri.Hunk_AllocateTempMemory(indexesSize);
	indexesOfs = 0;

	//ri.Printf(PRINT_ALL, "sizeof(glIndex_t) = %i\n", sizeof(glIndex_t));

	for(i = 0, tri = triangles; i < numTriangles; i++, tri++)
	{
		for(j = 0; j < 3; j++)
		{
			index = tri->indexes[j];
			memcpy(indexes + indexesOfs, &index, sizeof(glIndex_t));
			indexesOfs += sizeof(glIndex_t);
		}
	}

	ibo->indexesSize = indexesSize;
	ibo->indexesNum = numTriangles * 3;

	glGenBuffersARB(1, &ibo->indexesVBO);

	glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, ibo->indexesVBO);
	glBufferDataARB(GL_ELEMENT_ARRAY_BUFFER_ARB, indexesSize, indexes, glUsage);

	glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);

	GL_CheckErrors();

	ri.Hunk_FreeTempMemory(indexes);

	return ibo;
}
Exemplo n.º 27
0
void GeoPatchContext::Init() {
	frac = 1.0 / double(edgeLen-1);

	vbotemp = new VBOVertex[NUMVERTICES()];

	unsigned short *idx;
	midIndices.reset(new unsigned short[VBO_COUNT_MID_IDX()]);
	for (int i=0; i<4; i++) {
		loEdgeIndices[i].reset(new unsigned short[VBO_COUNT_LO_EDGE()]);
		hiEdgeIndices[i].reset(new unsigned short[VBO_COUNT_HI_EDGE()]);
	}
	/* also want vtx indices for tris not touching edge of patch */
	idx = midIndices.get();
	for (int x=1; x<edgeLen-2; x++) {
		for (int y=1; y<edgeLen-2; y++) {
			idx[0] = x + edgeLen*y;
			idx[1] = x+1 + edgeLen*y;
			idx[2] = x + edgeLen*(y+1);
			idx+=3;

			idx[0] = x+1 + edgeLen*y;
			idx[1] = x+1 + edgeLen*(y+1);
			idx[2] = x + edgeLen*(y+1);
			idx+=3;
		}
	}
	{
		for (int x=1; x<edgeLen-3; x+=2) {
			// razor teeth near edge 0
			idx[0] = x + edgeLen;
			idx[1] = x+1;
			idx[2] = x+1 + edgeLen;
			idx+=3;
			idx[0] = x+1;
			idx[1] = x+2 + edgeLen;
			idx[2] = x+1 + edgeLen;
			idx+=3;
		}
		for (int x=1; x<edgeLen-3; x+=2) {
			// near edge 2
			idx[0] = x + edgeLen*(edgeLen-2);
			idx[1] = x+1 + edgeLen*(edgeLen-2);
			idx[2] = x+1 + edgeLen*(edgeLen-1);
			idx+=3;
			idx[0] = x+1 + edgeLen*(edgeLen-2);
			idx[1] = x+2 + edgeLen*(edgeLen-2);
			idx[2] = x+1 + edgeLen*(edgeLen-1);
			idx+=3;
		}
		for (int y=1; y<edgeLen-3; y+=2) {
			// near edge 1
			idx[0] = edgeLen-2 + y*edgeLen;
			idx[1] = edgeLen-1 + (y+1)*edgeLen;
			idx[2] = edgeLen-2 + (y+1)*edgeLen;
			idx+=3;
			idx[0] = edgeLen-2 + (y+1)*edgeLen;
			idx[1] = edgeLen-1 + (y+1)*edgeLen;
			idx[2] = edgeLen-2 + (y+2)*edgeLen;
			idx+=3;
		}
		for (int y=1; y<edgeLen-3; y+=2) {
			// near edge 3
			idx[0] = 1 + y*edgeLen;
			idx[1] = 1 + (y+1)*edgeLen;
			idx[2] = (y+1)*edgeLen;
			idx+=3;
			idx[0] = 1 + (y+1)*edgeLen;
			idx[1] = 1 + (y+2)*edgeLen;
			idx[2] = (y+1)*edgeLen;
			idx+=3;
		}
	}
	// full detail edge triangles
	{
		idx = hiEdgeIndices[0].get();
		for (int x=0; x<edgeLen-1; x+=2) {
			idx[0] = x; idx[1] = x+1; idx[2] = x+1 + edgeLen;
			idx+=3;
			idx[0] = x+1; idx[1] = x+2; idx[2] = x+1 + edgeLen;
			idx+=3;
		}
		idx = hiEdgeIndices[1].get();
		for (int y=0; y<edgeLen-1; y+=2) {
			idx[0] = edgeLen-1 + y*edgeLen;
			idx[1] = edgeLen-1 + (y+1)*edgeLen;
			idx[2] = edgeLen-2 + (y+1)*edgeLen;
			idx+=3;
			idx[0] = edgeLen-1 + (y+1)*edgeLen;
			idx[1] = edgeLen-1 + (y+2)*edgeLen;
			idx[2] = edgeLen-2 + (y+1)*edgeLen;
			idx+=3;
		}
		idx = hiEdgeIndices[2].get();
		for (int x=0; x<edgeLen-1; x+=2) {
			idx[0] = x + (edgeLen-1)*edgeLen;
			idx[1] = x+1 + (edgeLen-2)*edgeLen;
			idx[2] = x+1 + (edgeLen-1)*edgeLen;
			idx+=3;
			idx[0] = x+1 + (edgeLen-2)*edgeLen;
			idx[1] = x+2 + (edgeLen-1)*edgeLen;
			idx[2] = x+1 + (edgeLen-1)*edgeLen;
			idx+=3;
		}
		idx = hiEdgeIndices[3].get();
		for (int y=0; y<edgeLen-1; y+=2) {
			idx[0] = y*edgeLen;
			idx[1] = 1 + (y+1)*edgeLen;
			idx[2] = (y+1)*edgeLen;
			idx+=3;
			idx[0] = (y+1)*edgeLen;
			idx[1] = 1 + (y+1)*edgeLen;
			idx[2] = (y+2)*edgeLen;
			idx+=3;
		}
	}
	// these edge indices are for patches with no
	// neighbour of equal or greater detail -- they reduce
	// their edge complexity by 1 division
	{
		idx = loEdgeIndices[0].get();
		for (int x=0; x<edgeLen-2; x+=2) {
			idx[0] = x;
			idx[1] = x+2;
			idx[2] = x+1+edgeLen;
			idx += 3;
		}
		idx = loEdgeIndices[1].get();
		for (int y=0; y<edgeLen-2; y+=2) {
			idx[0] = (edgeLen-1) + y*edgeLen;
			idx[1] = (edgeLen-1) + (y+2)*edgeLen;
			idx[2] = (edgeLen-2) + (y+1)*edgeLen;
			idx += 3;
		}
		idx = loEdgeIndices[2].get();
		for (int x=0; x<edgeLen-2; x+=2) {
			idx[0] = x+edgeLen*(edgeLen-1);
			idx[2] = x+2+edgeLen*(edgeLen-1);
			idx[1] = x+1+edgeLen*(edgeLen-2);
			idx += 3;
		}
		idx = loEdgeIndices[3].get();
		for (int y=0; y<edgeLen-2; y+=2) {
			idx[0] = y*edgeLen;
			idx[2] = (y+2)*edgeLen;
			idx[1] = 1 + (y+1)*edgeLen;
			idx += 3;
		}
	}

	// these will hold the optimised indices
	std::vector<unsigned short> pl_short[NUM_INDEX_LISTS];
	// populate the N indices lists from the arrays built during InitTerrainIndices()
	for( int i=0; i<NUM_INDEX_LISTS; ++i ) {
		const unsigned int edge_hi_flags = i;
		indices_tri_counts[i] = getIndices(pl_short[i], edge_hi_flags);
	}

	// iterate over each index list and optimize it
	for( int i=0; i<NUM_INDEX_LISTS; ++i ) {
		int tri_count = indices_tri_counts[i];
		VertexCacheOptimizerUShort vco;
		VertexCacheOptimizerUShort::Result res = vco.Optimize(&pl_short[i][0], tri_count);
		assert(0 == res);
	}

	// everything should be hunky-dory for setting up as OpenGL index buffers now.
	for( int i=0; i<NUM_INDEX_LISTS; ++i ) {
		glGenBuffersARB(1, &indices_list[i]);
		glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER, indices_list[i]);
		glBufferDataARB(GL_ELEMENT_ARRAY_BUFFER, sizeof(unsigned short)*indices_tri_counts[i]*3, &(pl_short[i][0]), GL_STATIC_DRAW);
		glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER, 0);
	}

	// default it to the last entry which uses the hi-res borders
	indices_vbo			= indices_list[NUM_INDEX_LISTS-1];
	indices_tri_count	= indices_tri_counts[NUM_INDEX_LISTS-1];

	if (midIndices) {
		midIndices.reset();
		for (int i=0; i<4; i++) {
			loEdgeIndices[i].reset();
			hiEdgeIndices[i].reset();
		}
	}
}
Exemplo n.º 28
0
void Model::initAnimated(MPQFile &f)
{
	origVertices = new ModelVertex[header.nVertices];
	memcpy(origVertices, f.getBuffer() + header.ofsVertices, header.nVertices * sizeof(ModelVertex));

	glGenBuffersARB(1,&vbuf);
	glGenBuffersARB(1,&tbuf);
	const size_t size = header.nVertices * sizeof(float);
	vbufsize = 3 * size;

	initCommon(f);

	if (header.nAnimations > 0) {
		anims = new ModelAnimation[header.nAnimations];
		memcpy(anims, f.getBuffer() + header.ofsAnimations, header.nAnimations * sizeof(ModelAnimation));

		animfiles = new MPQFile[header.nAnimations];
		char tempname[256];
		for(size_t i=0; i<header.nAnimations; i++) {
			sprintf(tempname, "%s%04d-%02d.anim", fullname.c_str(), anims[i].animID, anims[i].subAnimID);
			if (MPQFile::getSize(tempname) > 0) {
				animfiles[i].openFile(tempname);
			}
		}
	}

	if (animBones) {
		// init bones...
		bones = new Bone[header.nBones];
		ModelBoneDef *mb = (ModelBoneDef*)(f.getBuffer() + header.ofsBones);
		for (size_t i=0; i<header.nBones; i++) {
			bones[i].init(f, mb[i], globalSequences, animfiles);
		}
	}

	if (!animGeometry) {
		glBindBufferARB(GL_ARRAY_BUFFER_ARB, vbuf);
		glBufferDataARB(GL_ARRAY_BUFFER_ARB, vbufsize, vertices, GL_STATIC_DRAW_ARB);
		glGenBuffersARB(1,&nbuf);
		glBindBufferARB(GL_ARRAY_BUFFER_ARB, nbuf);
		glBufferDataARB(GL_ARRAY_BUFFER_ARB, vbufsize, normals, GL_STATIC_DRAW_ARB);
		delete[] vertices;
		delete[] normals;
	}
	Vec2D *texcoords = new Vec2D[header.nVertices];
	for (size_t i=0; i<header.nVertices; i++) 
		texcoords[i] = origVertices[i].texcoords;
	glBindBufferARB(GL_ARRAY_BUFFER_ARB, tbuf);
	glBufferDataARB(GL_ARRAY_BUFFER_ARB, 2*size, texcoords, GL_STATIC_DRAW_ARB);
	delete[] texcoords;

	if (animTextures) {
		texAnims = new TextureAnim[header.nTexAnims];
		ModelTexAnimDef *ta = (ModelTexAnimDef*)(f.getBuffer() + header.ofsTexAnims);
		for (size_t i=0; i<header.nTexAnims; i++) {
			texAnims[i].init(f, ta[i], globalSequences);
		}
	}

	// particle systems
	if (header.nParticleEmitters) {
		ModelParticleEmitterDef *pdefs = (ModelParticleEmitterDef *)(f.getBuffer() + header.ofsParticleEmitters);
		particleSystems = new ParticleSystem[header.nParticleEmitters];
		for (size_t i=0; i<header.nParticleEmitters; i++) {
			particleSystems[i].model = this;
			particleSystems[i].init(f, pdefs[i], globalSequences);
		}
	}

	// ribbons
	if (header.nRibbonEmitters) {
		ModelRibbonEmitterDef *rdefs = (ModelRibbonEmitterDef *)(f.getBuffer() + header.ofsRibbonEmitters);
		ribbons = new RibbonEmitter[header.nRibbonEmitters];
		for (size_t i=0; i<header.nRibbonEmitters; i++) {
			ribbons[i].model = this;
			ribbons[i].init(f, rdefs[i], globalSequences);
		}
	}

	// just use the first camera, meh
	if (header.nCameras>0) {
		ModelCameraDef *camDefs = (ModelCameraDef*)(f.getBuffer() + header.ofsCameras);
		cam.init(f, camDefs[0], globalSequences);
	}

	// init lights
	if (header.nLights) {
		lights = new ModelLight[header.nLights];
		ModelLightDef *lDefs = (ModelLightDef*)(f.getBuffer() + header.ofsLights);
		for (size_t i=0; i<header.nLights; i++) 
			lights[i].init(f, lDefs[i], globalSequences);
	}

	animcalc = false;
}
void
piglit_init(int argc, char **argv)
{
	GLfloat *vb;
	GLuint *ib;
	GLuint vbo;
	GLint OffsetAttrib;
	GLboolean user_va = GL_FALSE;
	int i;

	for (i = 1; i < argc; i++) {
		if (!strcmp(argv[i], "user_varrays")) {
			user_va = GL_TRUE;
			puts("Testing user vertex arrays.");
		}
	}

	piglit_require_GLSL();
	if (!user_va)
		piglit_require_extension("GL_ARB_vertex_buffer_object");
	piglit_require_extension("GL_ARB_draw_instanced");
	piglit_require_extension("GL_ARB_draw_elements_base_vertex");

	glMatrixMode(GL_MODELVIEW);
	glPushMatrix();
	glLoadIdentity();

	if (!user_va) {
		glGenBuffersARB(1, &vbo);
		glBindBufferARB(GL_ARRAY_BUFFER_ARB, vbo);
		glBufferDataARB(GL_ARRAY_BUFFER_ARB,
				NUM_QUADS * 8 * sizeof(GLfloat) +
				2 * 4 * sizeof(GLuint),
				NULL, GL_DYNAMIC_DRAW);
		vb = glMapBufferARB(GL_ARRAY_BUFFER_ARB, GL_WRITE_ONLY_ARB);
	} else {
		vb = malloc(NUM_QUADS * 8 * sizeof(GLfloat) +
			    2 * 4 * sizeof(GLuint));
	}

	for (i = 0; i < NUM_QUADS; i++) {
		float x1 = 10;
		float y1 = 10 + i * 20;
		float x2 = 20;
		float y2 = 20 + i * 20;

		vb[i * 8 + 0] = x1; vb[i * 8 + 1] = y1;
		vb[i * 8 + 2] = x2; vb[i * 8 + 3] = y1;
		vb[i * 8 + 4] = x2; vb[i * 8 + 5] = y2;
		vb[i * 8 + 6] = x1; vb[i * 8 + 7] = y2;
	}
	ib_offset = NUM_QUADS * 8 * sizeof(GLfloat);
	ib = (GLuint *)((char *)vb + ib_offset);
	for (i = 0; i < 8; i++)
		ib[i] = i;

	if (user_va) {
		ib_offset = (uintptr_t)ib;
	} else {
		glUnmapBufferARB(GL_ARRAY_BUFFER_ARB);
		glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, vbo);
	}

	glEnableClientState(GL_VERTEX_ARRAY);
	glVertexPointer(2, GL_FLOAT, 0, user_va ? vb : NULL);

	VertShader = piglit_compile_shader_text(GL_VERTEX_SHADER, VertShaderText);
	assert(VertShader);

	FragShader = piglit_compile_shader_text(GL_FRAGMENT_SHADER, FragShaderText);
	assert(FragShader);

	Program = piglit_link_simple_program(VertShader, FragShader);

	glUseProgram(Program);

	OffsetAttrib = glGetAttribLocation(Program, "yOffsetPerInstance");
	glVertexAttrib1f(OffsetAttrib, 20);
}