The Experts below are selected from a list of 69 Experts worldwide ranked by ideXlab platform

Henry Packard Moreton - One of the best experts on this subject based on the ideXlab platform.

  • a user programmable vertex engine
    International Conference on Computer Graphics and Interactive Techniques, 2001
    Co-Authors: Erik Lindholm, Mark J Kilgard, Henry Packard Moreton
    Abstract:

    In this paper we describe the design, programming interface, and implementation of a very efficient user-programmable vertex engine. The vertex engine of NVIDIA's GeForce3 GPU evolved from a highly tuned Fixed-Function Pipeline requiring considerable knowledge to program. Programs operate only on a stream of independent vertices traversing the pipe. Embedded in the broader Fixed Function Pipeline, our approach preserves parallelism sacrificed by previous approaches. The programmer is presented with a straightforward programming model, which is supported by transparent multi-threading and bypassing to preserve parallelism and performance. In the remainder of the paper we discuss the motivation behind our design and contrast it with previous work. We present the programming model, the instruction set selection process, and details of the hardware implementation. Finally, we discuss important API design issues encountered when creating an interface to such a device. We close with thoughts about the future of programmable graphics devices.

  • SIGGRAPH - A user-programmable vertex engine
    Proceedings of the 28th annual conference on Computer graphics and interactive techniques - SIGGRAPH '01, 2001
    Co-Authors: Erik Lindholm, Mark J Kilgard, Henry Packard Moreton
    Abstract:

    In this paper we describe the design, programming interface, and implementation of a very efficient user-programmable vertex engine. The vertex engine of NVIDIA's GeForce3 GPU evolved from a highly tuned Fixed-Function Pipeline requiring considerable knowledge to program. Programs operate only on a stream of independent vertices traversing the pipe. Embedded in the broader Fixed Function Pipeline, our approach preserves parallelism sacrificed by previous approaches. The programmer is presented with a straightforward programming model, which is supported by transparent multi-threading and bypassing to preserve parallelism and performance. In the remainder of the paper we discuss the motivation behind our design and contrast it with previous work. We present the programming model, the instruction set selection process, and details of the hardware implementation. Finally, we discuss important API design issues encountered when creating an interface to such a device. We close with thoughts about the future of programmable graphics devices.

Erik Lindholm - One of the best experts on this subject based on the ideXlab platform.

  • a user programmable vertex engine
    International Conference on Computer Graphics and Interactive Techniques, 2001
    Co-Authors: Erik Lindholm, Mark J Kilgard, Henry Packard Moreton
    Abstract:

    In this paper we describe the design, programming interface, and implementation of a very efficient user-programmable vertex engine. The vertex engine of NVIDIA's GeForce3 GPU evolved from a highly tuned Fixed-Function Pipeline requiring considerable knowledge to program. Programs operate only on a stream of independent vertices traversing the pipe. Embedded in the broader Fixed Function Pipeline, our approach preserves parallelism sacrificed by previous approaches. The programmer is presented with a straightforward programming model, which is supported by transparent multi-threading and bypassing to preserve parallelism and performance. In the remainder of the paper we discuss the motivation behind our design and contrast it with previous work. We present the programming model, the instruction set selection process, and details of the hardware implementation. Finally, we discuss important API design issues encountered when creating an interface to such a device. We close with thoughts about the future of programmable graphics devices.

  • SIGGRAPH - A user-programmable vertex engine
    Proceedings of the 28th annual conference on Computer graphics and interactive techniques - SIGGRAPH '01, 2001
    Co-Authors: Erik Lindholm, Mark J Kilgard, Henry Packard Moreton
    Abstract:

    In this paper we describe the design, programming interface, and implementation of a very efficient user-programmable vertex engine. The vertex engine of NVIDIA's GeForce3 GPU evolved from a highly tuned Fixed-Function Pipeline requiring considerable knowledge to program. Programs operate only on a stream of independent vertices traversing the pipe. Embedded in the broader Fixed Function Pipeline, our approach preserves parallelism sacrificed by previous approaches. The programmer is presented with a straightforward programming model, which is supported by transparent multi-threading and bypassing to preserve parallelism and performance. In the remainder of the paper we discuss the motivation behind our design and contrast it with previous work. We present the programming model, the instruction set selection process, and details of the hardware implementation. Finally, we discuss important API design issues encountered when creating an interface to such a device. We close with thoughts about the future of programmable graphics devices.

Mark J Kilgard - One of the best experts on this subject based on the ideXlab platform.

  • a user programmable vertex engine
    International Conference on Computer Graphics and Interactive Techniques, 2001
    Co-Authors: Erik Lindholm, Mark J Kilgard, Henry Packard Moreton
    Abstract:

    In this paper we describe the design, programming interface, and implementation of a very efficient user-programmable vertex engine. The vertex engine of NVIDIA's GeForce3 GPU evolved from a highly tuned Fixed-Function Pipeline requiring considerable knowledge to program. Programs operate only on a stream of independent vertices traversing the pipe. Embedded in the broader Fixed Function Pipeline, our approach preserves parallelism sacrificed by previous approaches. The programmer is presented with a straightforward programming model, which is supported by transparent multi-threading and bypassing to preserve parallelism and performance. In the remainder of the paper we discuss the motivation behind our design and contrast it with previous work. We present the programming model, the instruction set selection process, and details of the hardware implementation. Finally, we discuss important API design issues encountered when creating an interface to such a device. We close with thoughts about the future of programmable graphics devices.

  • SIGGRAPH - A user-programmable vertex engine
    Proceedings of the 28th annual conference on Computer graphics and interactive techniques - SIGGRAPH '01, 2001
    Co-Authors: Erik Lindholm, Mark J Kilgard, Henry Packard Moreton
    Abstract:

    In this paper we describe the design, programming interface, and implementation of a very efficient user-programmable vertex engine. The vertex engine of NVIDIA's GeForce3 GPU evolved from a highly tuned Fixed-Function Pipeline requiring considerable knowledge to program. Programs operate only on a stream of independent vertices traversing the pipe. Embedded in the broader Fixed Function Pipeline, our approach preserves parallelism sacrificed by previous approaches. The programmer is presented with a straightforward programming model, which is supported by transparent multi-threading and bypassing to preserve parallelism and performance. In the remainder of the paper we discuss the motivation behind our design and contrast it with previous work. We present the programming model, the instruction set selection process, and details of the hardware implementation. Finally, we discuss important API design issues encountered when creating an interface to such a device. We close with thoughts about the future of programmable graphics devices.

Vladimir Zdraveski - One of the best experts on this subject based on the ideXlab platform.

  • programmable vs Fixed Function Pipeline in real time computer graphics
    IEEE EUROCON, 2019
    Co-Authors: Mladen Korunoski, Marjan Gushev, Vladimir Zdraveski
    Abstract:

    This paper explains the concepts behind the programmable rendering Pipeline, as opposed to the Fixed-Function Pipeline, and how the former can help with creating stunning visuals without degrading performance. In order to demonstrate these concepts, a practical implementation of water simulation using OpenGL is presented and relevant experiments are conducted. Additionally, the execution results are compared and the speedup of using the programmable Pipeline over the Fixed-Function Pipeline, in the case of water simulation, are given.

  • EUROCON - Programmable vs. Fixed-Function Pipeline in Real-Time Computer Graphics
    IEEE EUROCON 2019 -18th International Conference on Smart Technologies, 2019
    Co-Authors: Mladen Korunoski, Marjan Gushev, Vladimir Zdraveski
    Abstract:

    This paper explains the concepts behind the programmable rendering Pipeline, as opposed to the Fixed-Function Pipeline, and how the former can help with creating stunning visuals without degrading performance. In order to demonstrate these concepts, a practical implementation of water simulation using OpenGL is presented and relevant experiments are conducted. Additionally, the execution results are compared and the speedup of using the programmable Pipeline over the Fixed-Function Pipeline, in the case of water simulation, are given.

David H. Eberly - One of the best experts on this subject based on the ideXlab platform.

  • Advanced Rendering Topics
    3D Game Engine Architecture, 2020
    Co-Authors: David H. Eberly
    Abstract:

    This chapter discusses obtaining visual effects that are considered more advanced than vertex coloring, lighting and materials, texturing, and multitexturing. The chapter consists of two sections. Section 5.1 elaborates on the Effect class that was introduced in Section 3.4.5. Wild Magic has a collection of derived classes that implement various effects obtainable through the Fixed-Function Pipeline —through graphics API features that were available before the introduction of shader programming. The first section describes all these derived classes.

  • 3D Game Engine Architecture : Engineering Real-Time Applications with Wild Magic
    2004
    Co-Authors: David H. Eberly
    Abstract:

    * About the Author* Preface*Chapter 1 Introduction*1.1 Drawing a Triangle*1.2 Drawing a Triangle Mesh*1.3 Drawing a Complicated Scene*1.4 Abstraction of Systems*Chapter 2 Core Systems*2.1 The Low-Level System*2.1.1 Basic Data Structures*2.1.2 Encapsulating Platform-Specific Concepts*2.1.3 Endianness*2.1.4 System Time*2.1.5 File Handling*2.1.6 Memory Allocation and Deallocation*2.2 The Mathematics System*2.2.1 Basic Mathematics Functions*2.2.2 Fast Functions*2.2.3 Vectors*2.2.4 Matrices*2.2.5 Quaternions*2.2.6 Lines and Planes*2.2.7 Colors*2.3 The Object System*2.3.1 Run-Time Type Information*2.3.2 Names and Unique Identifiers*2.3.3 Sharing and Smart Pointers*2.3.4 Controllers*2.3.5 Streaming*2.3.6 Cloning*2.3.7 String Trees*2.3.8 Initialization and Termination*Chapter 3 Scene Graphs and Renderers*3.1 The Core Classes*3.1.1 Motivation for the Classes*3.1.2 Spatial Hierarchy Design*3.1.3 Instancing*3.2 Geometric State*3.2.1 Transformations*3.2.2 Bounding Volumes*3.2.3 The Core Classes and Geometric Updates*3.3 Geometric Types*3.3.1 Points*3.3.2 Line Segments*3.3.3 Triangle Meshes*3.3.4 Particles*3.4 Render State*3.4.1 Global State*3.4.2 Lights*3.4.3 Textures*3.4.4 Multitexturing*3.4.5 Effects*3.4.6 The Core Classes and Render State Updates*3.5 Renderers and Cameras*3.5.1 Camera Models*3.5.2 Basic Architecture for Rendering*3.5.3 Single-Pass Drawing*3.5.4 The DrawPrimitive Function*3.5.5 Cached Textures and Vertex Attributes*3.5.6 Global Effects and Multipass Support*Chapter 4 Advanced Scene Graph Topics*4.1 Level of Detail*4.1.1 Billboards*4.1.2 Display of Particles*4.1.3 Discrete Level of Detail*4.1.4 Continuous Level of Detail*4.1.5 Infinite Level of Detail*4.2 Sorting*4.2.1 Binary Space Partitioning Trees*4.2.2 Portals*4.2.3 Sorting Children of a Node*4.2.4 Deferred Drawing*4.3 Curves and Surfaces*4.3.1 Parametric Curves*4.3.2 Parametric Surfaces*4.3.3 Curve Tessellation by Subdivision*4.3.4 Surface Tessellation by Subdivision*4.4 Terrain*4.4.1 Data Representations*4.4.2 Level of Detail*4.4.3 Terrain Pages and Memory Management*4.5 Controllers and Animation*4.5.1 Keyframe Animation*4.5.2 Morphing*4.5.3 Points and Particles*4.5.4 Skin and Bones*4.5.5 Inverse Kinematics*Chapter 5 Advanced Rendering Topics*5.1 Special Effects Using the Fixed-Function Pipeline*5.1.1 Vertex Coloring*5.1.2 Single Textures*5.1.3 Dark Maps*5.1.4 Light Maps*5.1.5 Gloss Maps*5.1.6 Bump Maps*5.1.7 Environment Maps*5.1.8 Projected Textures*5.1.9 Planar Shadows*5.1.10 Planar Reflection*5.2 Special Effects Using Vertex and Pixel Shaders*5.2.1 Scene Graph Support*5.2.2 Renderer Support*5.2.3 Automatic Source Code Generation*Chapter 6 Collision Detection*6.1 Distance-Based Methods*6.1.1 A Plan of Attack*6.1.2 Root Finding Using Newton's Method*6.1.3 Root Finding Using Bisection*6.1.4 Hybrid Root Finding*6.1.5 An Abstract Interface for Distance Calculations*6.2 Intersection-Based Methods*6.2.1 An Abstract Interface for Intersection Queries*6.3 Line-Object Intersection*6.3.1 Intersections between Linear Components and Triangles*6.3.2 Intersections between Linear Components and Bounding Volumes*6.3.3 Picking*6.3.4 Staying on Top of Things*6.3.5 Staying Out of Things*6.4 Object-Object Intersection*6.4.1 Collision Groups*6.4.2 Hierarchical Collision Detection*6.4.3 Spatial and Temporal Coherence*Chapter 7 Physics*7.1 Numerical Methods for Solving Differential Equations*7.1.1 Euler's Method*7.1.2 Midpoint Method*7.1.3 Runge-Kutta Fourth-Order Method*7.1.4 Implicit Equations and Methods*7.2 Particle Physics*7.3 Mass-Spring Systems*7.3.1 Curve Masses*7.3.2 Surface Masses*7.3.3 Volume Masses*7.3.4 Arbitrary Configurations*7.4 Deformable Bodies*7.5 Rigid Bodies*7.5.1 The Rigid Body Class*7.5.2 Computing the Inertia Tensor*Chapter 8 Applications*8.1 Abstraction of the Application*8.1.1 Processing Command Line Parameters*8.1.2 The Application Class*8.1.3 The ConsoleApplication Class*8.1.4 TheWindowApplication Class*8.1.5 TheWindowApplication3 Class*8.2 Sample Applications*8.2.1 BillboardNode Sample*8.2.2 BspNode Sample*8.2.3 CachedArray Sample*8.2.4 Castle Sample*8.2.5 ClodMesh Sample*8.2.6 Collision Sample*8.2.7 InverseKinematics Sample*8.2.8 Portals Sample*8.2.9 ScreenPolygon Sample*8.2.10 SkinnedBiped Sample*8.2.11 SortFaces Sample*8.2.12 Terrain Sample*8.3 Sample Tools*8.3.1 3dsToWmof Importer*8.3.2 Maya Exporter*8.3.3 BmpToWmif Converter*8.3.4 WmifToBmp Converter*8.3.5 ScenePrinter Tool*8.3.6 SceneTree Tool*8.3.7 SceneViewer Tool*Appendix A Coding Conventions* A.1 File Naming and Organization* A.2 Comment Preamble and Separators* A.3 White Space* A.3.1 Indentation* A.3.2 Blank Lines* A.3.3 Function Declarators* A.3.4 Constructor Initializers* A.3.5 Function Calls* A.3.6 Conditionals* A.4 Braces* A.5 Pointer Types* A.6 Identifier Names* A.6.1 Variables* A.6.2 Classes and Functions* A.6.3 Enumerations* A.7 C++ Exceptions* A.8 Header File Organization* A.8.1 Include Guards and Nested Header Files* A.8.2 Minimizing Compilation Time* Bibliography* Index* About the CD-ROM

  • 3D Game Engine Design: A Practical Approach to Real-Time Computer Graphics
    2000
    Co-Authors: David H. Eberly
    Abstract:

    *Preface *1 Introduction *2 The Graphics System *2.1 The Foundation *2.1.1 Coordinate Systems *2.1.2 Handedness and Cross Products *2.1.3 Points and Vectors *2.2 Transformations *2.2.1 Linear Transformations *2.2.2 Affine Transformations *2.2.3 Projective Transformations *2.2.4 Properties of Perspective Projection *2.2.5 Homogeneous Points and Matrices *2.3 Cameras *2.3.1 The Perspective Camera Model *2.3.2 Model or Object Space *2.3.3 World Space *2.3.4 View, Camera, or Eye Space *2.3.5 Clip, Projection, or Homogeneous Space *2.3.6 Window Space *2.3.7 Putting Them All Together *2.4 Culling and Clipping *2.4.1 Object Culling *2.4.2 Back Face Culling *2.4.3 Clipping to the View Frustum *2.5 Rasterizing *2.5.1 Line Segments *2.5.2 Circles *2.5.3 Ellipses *2.5.4 Triangles *2.6 Vertex Attributes *2.6.1 Colors *2.6.2 Lighting and Materials *2.6.3 Textures *2.6.4 Transparency and Opacity *2.6.5 Fog *2.6.6 And Many More *2.6.7 Rasterizing Attributes *2.7 Issues of Software, Hardware, and APIs *2.7.1 A General Discussion *2.7.2 Portability versus Performance *2.8 API Conventions *2.8.1 Matrix Representation and Storage *2.8.2 Matrix Composition *2.8.3 View Matrices *2.8.4 Projection Matrices *2.8.5 Window Handedness *2.8.6 Rotations *2.8.7 Fast Computations using the Graphics API *3 Renderers *3.1 Software Rendering *3.2 Hardware Rendering *3.3 The Fixed-Function Pipeline *3.4 Vertex and Pixel Shaders *3.5 An Abstract Rendering API *4 Special Effects Using Shaders *4.1 Vertex Colors *4.2 Lighting and Materials *4.3 Textures *4.4 Multitextures *4.5 Bump Maps *4.6 Gloss Maps *4.7 Sphere Maps *4.8 Cube Maps *4.9 Refraction *4.10 Planar Reflection *4.11 Planar Shadows *4.12 Projected Textures *4.13 Shadow Maps *4.14 Volumetric Fog *4.15 Skinning *4.16 Miscellaneous *4.16.1 Iridescence *4.16.2 Water Effects *4.16.3 Volumetric Textures *5 Scene Graphs *5.1 The Need for High-Level Data Management *5.2 The Need for Low-Level Data Structures *5.3 Geometric State *5.3.1 Vertices and Vertex Attributes *5.3.2 Transformations *5.3.3 Bounding Volumes *5.4 Render State *5.4.1 Global State *5.4.2 Lights *5.4.3 Effects *5.5 The Update Pass *5.5.1 Geometric State Updates *5.5.2 Render State Updates *5.6 The Culling Pass *5.6.1 Hierarchical Culling *5.6.2 Sorted Culling *5.7 The Drawing Pass *5.7.1 Single-Pass Drawing *5.7.2 Single Effect, Multipass Drawing *5.7.3 Multiple Effect, Multipass Drawing *5.7.4 Caching Data on the Graphics Hardware *5.7.5 Sorting to Reduce State Changes *5.8 Scene Graph Design Issues *5.8.1 Organization Based on Geometric State *5.8.2 Organization Based on Render State *5.8.3 Scene Graph Operations and Threading *5.8.4 The Producer-Consumer Model *6 Scene Graph Compilers *6.1 The Need for Platform-Specific Optimization *6.2 The Need for Reducing Memory Fragmentation *6.3 A Scene Graph as a Dynamic Expression *6.4 Compilation from High-Level to Low-Level Data *6.5 Control of Compilation via Node Tags *7 Memory Management *7.1 Memory Budgets for Game Consoles *7.2 General Concepts for Memory Management *7.2.1 Allocation, Deallocation, and Fragmentation *7.2.2 Sequential-Fit Methods *7.2.3 Buddy-System Methods *7.2.4 Segregated-Storage Methods *7.3 Design Choices *7.3.1 Memory Utilization *7.3.2 Fast Allocation and Deallocation *8 Controller-Based Animation *8.1 Vertex Morphing *8.2 Keyframe Animation *8.3 Inverse Kinematics *8.4 Skin and Bones *8.5 Particle Systems *9 Spatial Sorting *9.1 Spatial Partitioning *9.1.1 Quadtrees and Octrees *9.1.2 BSP Trees *9.1.3 User-Defined Maps *9.2 Node-Based Sorting *9.3 Portals *9.4 Occlusion Culling *10 Level of Detail *10.1 Discrete Level of Detail *10.1.1 Sprites and Billboards *10.1.2 Model Switching *10.2 Continuous Level of Detail *10.2.1 General Concepts *10.2.2 Application to Regular Meshes *10.2.3 Application to General Meshes *10.3 Infinite Level of Detail *10.3.1 General Concepts *10.3.2 Application to Parametric Curves *10.3.3 Application to Parametric Surfaces *11 Terrain *11.1 Data Representations *11.2 Level of Detail for Height Fields *11.3 Terrain Pages and Memory Management *12 Collision Detection *12.1 Static Line-Object Intersections *12.2 Static Object-Object Intersections *12.3 Dynamic Line-Object Intersections *12.3.1 Distance-Based Approach *12.3.2 Intersection-Based Approach *12.4 Dynamic Object-Object Intersections *12.4.1 Distance-Based Approach *12.4.2 Intersection-Based Approach *12.5 Path Finding to Avoid Collisions *13 Physics *13.1 Basic Concepts *13.2 Particle Systems *13.3 Mass-Spring Systems *13.4 Deformable Bodies *13.5 Rigid Bodies *14 Object-Oriented Infrastructure *14.1 Object-Oriented Software Construction *14.2 Style, Naming Conventions, and Namespaces *14.3 Run-Time Type Information *14.4 Templates *14.5 Shared Objects and Reference Counting *14.6 Streaming *14.7 Startup and Shutdown *14.8 An Application Layer *15 Mathematical Topics *15.1 Standard Objects *15.2 Curves *15.3 Surfaces *15.4 Distance Algorithms *15.5 Intersection Algorithms *15.6 Numerical Algorithms *15.7 All About Rotations *15.7.1 Rotation Matrices *15.7.2 Quaternions *15.7.3 Euler Angles *15.7.4 Performance Issues *15.8 The Curse of Nonuniform Scaling * Bibliography * Index