Zugl.: Hamburg, Techn. Universiẗat, Diss., 2009.

En Computación Gráfica uno de los conceptos más importantes es el \emph{Rendering}, definido como el proceso que a partir de los datos de una escena tridimensional genera una imagen en una ventana de visualización en 2 dimensiones. El rendering siempre se ha enfocado en generar imágenes fotorrealistas, aunque para diversas aplicaciones y escenarios se desea una imagen abstracta y/o estilizada. El proceso que puede generar ese tipo de imágenes es llamado Rendering No Fotorrealista, o NPR por sus siglas en inglés (Non Photorealistic Rendering). El NPR integra conceptos de Computación Gráfica y de Geometría Diferencial, y puede aplicarse en visualización científica e ilustración técnica, con el fin de destacar áreas o contornos de los objetos que son de interés para el observador; en la producción de imágenes que imiten medios tradicionales como la pintura o la acuarela; y en la generación de imágenes que imiten dibujos animados, entre otras áreas. En esta memoria se diseña e implementa un marco de trabajo (framework en inglés) para Computación Gráfica que permite desarrollar técnicas NPR y de rendering tradicional. El diseño del marco de trabajo contempla el estudio de los puntos comunes de diferentes técnicas de NPR y de las áreas asociadas, y, siguiendo el paradigma de la Orientación a Objetos, define distintas componentes internas que pueden ser extendidas para implementar técnicas de NPR y de rendering tradicional. La implementación se realiza en el lenguaje de programación C++ utilizando bibliotecas de código abierto o compatibles con código abierto: se utilizan la biblioteca gráfica OpenGL y el lenguaje Cg para comunicarse con los procesadores de la tarjeta de vídeo (GPU). El marco de trabajo incluye técnicas ya implementadas: para el rendering tradicional se implementaron graficadores de Gouraud y de Phong, mientras que para las técnicas NPR se implementaron graficadores de dibujado animado (Cel-Shading) y de modelos de tonos (Gooch Shading). Se implementaron extractores de líneas de interés (Siluetas y Contornos Sugestivos), así como una clase abstracta que permite definir nuevos tipos de líneas a extraer. La demostración de estas implementaciones se realiza mediante una aplicación de prueba que permite cargar modelos tridimensionales estáticos y animados; los resultados obtenidos se muestran mediante imágenes de los modelos tridimensionales cargados en la aplicación de prueba. Finalmente se realiza una discusión sobre el trabajo futuro, sobre las posibles líneas de investigación a seguir en estudios de post-grado y sobre el uso del marco de trabajo para implementar técnicas de rendering no NPR. Se concluye que el marco de trabajo se puede utilizar para el desarrollo de técnicas NPR y de rendering tradicional, que su desempeño es adecuado para el rendering en tiempo real para escenas tridimensionales de tamaño medio y que puede ser utilizado en aplicaciones reales.

Vizz3D is a 3D graphics code analysis tool, developed at Växjö University that optionally can use Java3D or OpenGL. However, initially Java3D was the only programming interface used. No other version was considered. Therefore the applications structure was built with the Java3D way of thought in mind. But code visualization with 3D graphics can be a demanding task for the computers processor and its graphics hardware and Java3D is known to be somewhat inefficient. So an OpenGL version was introduced. This thesis reflects on the work restructuring the application’s code to fit both versions within Vizz3D in a structured and object-oriented way. The thesis shows the efforts to be taken to make an existing ever evolving tool easily extendible to other API’s. Additional aspects of OpenGL specific implementations are discussed throughout the thesis.

This thesis describes methods for advanced visualization of 3D data. Order-independent transparent data between multiple datasets of varying types can be combined using an A-buffer. In this thesis, an implementation of such a buffer is presented. An optimisation of the A-buffer, based on the discarding of unnecessary fragments will be presented. A line integral convolution method for 3D volumes will also be presented, where noise input, and resolution of the input- compared to output volumes will be discussed. The resulting method is able to visualize multiple types of data with order-independent transparency. The rendering speed is generally fast enough for an interactive user-experience.

An OpenGL applications usually renders to a single frame. Multi-view or 3D displays on the other hand, needs more more images representing different viewing directions on the same scene, but modifying a large number of applications would be unsuitable and problematic. However, intercepting and modifying these calls before they reach the GPU would dramatically decrease the amount of work needed to support a large number of applications on a new type of multi-view or 3D display. This thesis describes different ways on intercepting, enqueueing and replaying these calls to support rendering form different view points. Intercepting with both an own implementation of opengl32.dll and an OpenGL driver is discussed, and enqueueing using classes, function pointers and enumeration of functions is tried. The different techniques are discussed quickly with the focus being a working implementation. This resulting in an fully blown OpenGL interceptor with the ability to enqueue and replay a frame multiple times while modifying parameters such as the projection matrix. This implementation uses an own implementation of opengl32.dll that is placed in the application directory to be loaded before the real one. Enqueueing is performed by enumerating all OpenGL calls, pushing this enumeration value and all call data to a list Replaying is done by reading the same list and calling the function pointer associated with the enumeration value with the data in the list.

This master thesis deals with the large terrain rendering in real time using WebGL. The thesis also deals with ways of measuring and representation of terrain height data. The paper also compares several frameworks for WebGL and also describes the practical use of HTML5 technologies such as WebWorkers. Furthermore, it also compares the performance and compatibility of current web browsers with HTML5 technologies.

This master thesis deals with interactive cloth simulation accelerated by GPU. In the first part there is a description of all technologies used during implementation of a program. The second part discusses various simulation methods. It is mainly focused on particle systems as a most used method. These parts are followed by a design of the program, which is implemented as a part of this thesis. The program was implemented in four variants. The first variant is CPU implementation, which was then optimalized with OpenMP. CUDA implementation is based on these implementations. Last variant implemented in this thesis is optimized CUDA implementation. All these implementations are evaluated from compute complexity point of view and suitability for real time graphics.

3D user interfaces are common today when for example doing industrial design, architecture and 3dmodelling but they are not commonly used in regular interfaces. The hardware requirements for suchinterfaces are not difficult to reach with today’s computers, laptops and mobile devices with only in-tegrated graphics cards.The report found that users of 3D interfaces found them more fun to use and gives a better overviewwhen viewing dense information. Problems exists when using small screens and reading text. Futureimprovements to software tools and APIs as well as improvements in hardware, and new technologiessuch as virtual- and augmented reality will make 3D interfaces easier to develop, use and run. / 3D-gränssnitt är vanliga idag när man till exempel arbetar med industridesign och arkitektritningarmen de används vanligtvis inte i vanliga program. Hårdvarurestriktioner har varit en stor faktor var-för de inte har haft dessa, men dagens datorer och mobila enheter som har integrerade grafikkort somklarar av att köra de flesta 3D-gränssnitt.Rapporten fann att användare av 3D-gränssnitt tyckte de var roligare att använda och ger en bättreöverblick när informationsdensiteten är hög. Problem uppstår när man använder små skärmar ochbehöver läsa text. Framtida förbättringar i mjukvaruverktyg och API:er, förbättringar i hårdvara ochnya teknologier som t.ex. virtuell- och förstärktverklighet kommer göra att 3D-grännsnitt

No description available.

Any kind of graphics simulation can be thought of like a fancy flipbook. This notion is, of course, nothing new. For instance, in a game, the central computing unit (CPU) needs to process frame by frame, figuring out what is happening, and then finally issues draw calls to the graphics processing unit (GPU) to render the frame and display it onto the monitor. Traditionally, the CPU has to process a lot of things: from the creation of the window environment for the processed frames to be displayed, handling game logic, processing artificial intelligence (AI) for non-player characters (NPC), to the physics, and issuing draw calls; and all of these have to be done within roughly 0.0167 seconds to maintain real-time performance of 60 frames per second (fps). The main goal of this thesis is to move the physics pipeline of any kind of simulation to the GPU instead of the CPU. The main tool to make this possible would be the usage of OpenGL Compute Shaders. OpenGL is a high-performance graphics application programming interface (API), used as an abstraction layer for the CPU to communicate with the GPU. OpenGL was created by the Khronos Group primarily for graphics, or drawing frames only. In the later versions of OpenGL, the Khronos Group has introduced Compute Shader, which can be used for general-purpose computing on the GPU (GPGPU). This means the GPU can be used to process any arbitrary math computations, and not limited to only process the vertices and fragments of polygons. This thesis features Broad Phase and Narrow Phase collision detection stages, and a collision Resolution Phase with Sequential Impulses entirely on the GPU with real-time performance.