/* ============ 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; }
DynamicTexture::DynamicTexture(const ImageTextureConfig& config) : Texture(config) { glGenBuffersARB(1, &m_bufferId); m_dataSize = getByteSizeofPixel(config.format) * m_width * m_height * m_depth; }
/** * 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()); } }
/* ============ 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; }
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); } }
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]; } } }
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); }
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; }
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; }
/* 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); }
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 } }
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; } } }
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; } }
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 }
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; }
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 }
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; }
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; }
///////////////////////////////////////////////////////// // 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 */ }
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; }
/** * 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); } }
// 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); }
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; }
/* ============ 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; }
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(); } } }
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); }