Abstract: One embodiment of the present invention sets forth a technique for decomposing and filling cubic Bèzier segments of paths without tessellating the paths. Path rendering may be accelerated when a GPU or other processor is configured to perform the decomposition operations. Cubic Bèzier paths are classified and decomposed into simple cubic Bèzier path segments based on the classification. A stencil buffer is then generated that indicates pixels that are inside of the decomposed cubic Bèzier segments. The paths are then filled according to the stencil buffer to produce a filled path.

Abstract: One embodiment of the present invention sets forth a technique for converting dashed strokes into quadratic Bèzier segment sequences. Path rendering with stroking and dashing may be accelerated when a graphics processing unit or other processor is configured to subdivide quadratic Bèzier segments based on the remaining distance for a current dash pattern element and the arc length of the current quadratic Bèzier path segment to generate “on” dash pattern segments. Each “on” dash pattern segment is then bounded by a conservative geometric hull. A point containment technique is then used to identify pixels within each conservative geometric hull that are within half of the stroke width of any point along a path to be stroked.

Abstract: One embodiment of the present invention sets forth a technique for improving path rendering on computer systems with an available graphics processing unit. The technique involves reducing complex path objects to simpler geometric objects suitable for rendering on a graphics processing unit. The process involves a central processing unit “baking” a set of complex path rendering objects to generate a set of simpler graphics objects. A graphics processing unit then renders the simpler graphics objects. This division of processing load can advantageously yield higher overall rendering performance.

Abstract: One embodiment of the present invention sets forth a technique for subdividing stroked higher-order curved segments into quadratic Bèzier curve segments. Path stroking may be accelerated when a GPU or other processor is configured to perform the subdivision operations. Cubic Bèzier path segments are subdivided into quadratic Bèzier curve segments and other lower-order segments at key features. The quadratic Bèzier curve segments approximate the cubic Bèzier path segments. A variance metric is computed for each quadratic Bèzier curve segment, and when the variance metric indicates that the quadratic Bèzier curve segment deviates by more than a threshold from the corresponding portion of the cubic Bèzier path segment, the quadratic Bèzier curve segment is further subdivided. The path composed of the quadratic Bèzier curve segments is then stroked by rendering hull geometry that encloses the path.

Abstract: One embodiment of the present invention sets forth a technique for stroking rendered paths. Path rendering may be accelerated when a graphics processing unit or other processor is configured to identify pixels that are within half of the stroke width of any point along a path to be stroked. The path is represented by quadratic Bèzier segments and a cubic equation is evaluated to determine whether or not each point in a conservative hull that bounds the quadratic Bèzier segment is within the stroke width.

Abstract: One embodiment of the present invention sets forth a technique for subdividing stroked higher-order curved segments into quadratic Bèzier curve segments. Path stroking may be accelerated when a GPU or other processor is configured to perform the subdivision operations. Cubic Bèzier path segments are subdivided into quadratic Bèzier curve segments and other lower-order segments at key features. The quadratic Bèzier curve segments approximate the cubic Bèzier path segments. A variance metric is computed for each quadratic Bèzier curve segment, and when the variance metric indicates that the quadratic Bèzier curve segment deviates by more than a threshold from the corresponding portion of the cubic Bèzier path segment, the quadratic Bèzier curve segment is further subdivided. The path composed of the quadratic Bèzier curve segments is then stroked by rendering hull geometry that encloses the path.

Abstract: One embodiment of the present invention sets forth a technique for decomposing and filling cubic Bèzier segments of paths without tessellating the paths. Path rendering may be accelerated when a GPU or other processor is configured to perform the decomposition operations. Cubic Bèzier paths are classified and decomposed into simple cubic Bèzier path segments based on the classification. A stencil buffer is then generated that indicates pixels that are inside of the decomposed cubic Bèzier segments. The paths are then filled according to the stencil buffer to produce a filled path.

Abstract: One embodiment of the present invention sets forth a technique for rendering clipped paths by first generating clip stencil buffer state indicating pixels that are inside of the clip path. The clip stencil buffer state may also store an opacity value for each covered pixel to generate a mask that modulates the opacity of a draw path that is clipped. Clipped draw stencil buffer state is then generated indicating pixels of the draw path that should be covered based on the clip stencil buffer state and coverage of the draw path. The clipped draw path is then filled or stroked to produce the clipped draw path. The clip and draw paths may be filled or stroked without tessellating the paths. Path rendering may be accelerated when a GPU or other processor that is configured to perform operations to generate the clip stencil buffer state and the clipped draw stencil buffer state, and to fill or stroke the clipped draw path.

Abstract: One embodiment of the present invention sets forth a technique for rendering paths by first generating a stencil buffer indicating pixels of the path that should be covered and then covering the path. The paths may be filled or stroked without tessellating the paths. Path rendering may be accelerated when a graphics processing unit or other processor that is configured to perform operations to generate the stencil buffer and cover the path to fill or stroke the path. When the paths are rendered in a top-to-bottom (front-to-back) order, an opacity stencil may be generated and used to avoid determining path coverage and shading for pixels that are opaque.

Abstract: One embodiment of the present invention sets forth a technique for rendering paths by first generating a stencil buffer indicating pixels of the path that should be covered and then covering the path. The paths may be filled or stroked without tessellating the paths. Path rendering may be accelerated when a graphics processing unit or other processor that is configured to perform operations to generate the stencil buffer and cover the path to fill or stroke the path.

Abstract: One embodiment of the present invention sets forth a technique for compositing a rendered path object into an image buffer. A shader program executing within a graphics processing unit (GPU) performs a stenciling operation for the path object and subsequently performs a texture barrier operation, which invalidates caches configured to store texture and frame buffer data within the GPU. The shader program then performs covering operation for the path object in which the shader renders color samples for the path object and composites the color samples into an image buffer. The shader program binds to the image buffer for access as both a texture map and a writeable image. Stencil values are reset when corresponding pixels are written once per path object, and texture caches are invalidated via the texture barrier operation, which is performed after each covering operation per path object.

Abstract: One embodiment of the present invention sets forth a technique for improving antialiasing quality, while minimizing performance degradation, by adaptively selecting between multisampling and supersampling on a per pixel basis. The resulting performance may be generally comparable to multisampling. At the same time, however, the resulting quality may be generally comparable to supersampling. The antialiasing technique disclosed herein determines whether to use multisampling or supersampling on a particular pixel being rendered, based on the specific coverage of the associated geometry primitive. Because many pixel centers are covered by a geometry primitive, a statistical performance advantage is gained when pixels in a rendered image can be generating using multisampling rather than supersampling. The cases where pixel centers are not covered tend to be less frequent, but are very significant to image quality. High image quality is maintained by rendering these cases using supersampling.

Abstract: One embodiment of the invention includes a method for extending an object-oriented programming language to include support for a shading language vector data type. The method generally includes defining a template class for a shading language vector, defining a template class for a swizzled vector, and partially specializing the vector template class for vectors of one, two, three, and four elements. The partial specialization includes a union of instances of the vector swizzle template, where each instance represents a desired vector swizzle. In addition to defining the vector and vector swizzle data types, the templates classes may overload operators provided by the object-oriented programming language to perform operations corresponding to operations of the operators in the shading language.

Abstract: One embodiment of the invention includes a method for extending an object-oriented programming language to include support for a shading language vector data type. The method generally includes defining a template class for a shading language vector, defining a template class for a swizzled vector, and partially specializing the vector template class for vectors of one, two, three, and four elements. The partial specialization includes a union of instances of the vector swizzle template, where each instance represents a desired vector swizzle. In addition to defining the vector and vector swizzle data types, the templates classes may overload operators provided by the object-oriented programming language to perform operations corresponding to operations of the operators in the shading language.

Abstract: Systems and methods for compiling high-level primitive programs are used to generate primitive program micro-code for execution by a primitive processor. A compiler is configured to produce micro-code for a specific target primitive processor based on the target primitive processor's capabilities. The compiler supports features of the high-level primitive program by providing conversions for different applications programming interface conventions, determining output primitive types, initializing attribute arrays based on primitive input profile modifiers, and determining vertex set lengths from specified primitive input types.

Abstract: Methods and systems for processing a geometry shader program developed in a high-level shading language are disclosed. Specifically, in one embodiment, after having received the geometry shader program configured to be executed by a first processing unit in a programmable execution environment, the high-level shading language instructions of the geometry shader program is converted into low-level programming language instructions. The low-level programming language instructions are then linked with the low-level programming language instructions of a domain-specific shader program, which is configured to be executed by a second processing unit also residing in the programmable execution environment. The linked instructions of the geometry shader program are directed to the first processing unit, and the linked instructions of the domain-specific shader program are directed to the second processing unit.

Abstract: One embodiment of the present invention sets forth a technique for performing a computer-implemented method for tessellating patches. An input block is received that defines a plurality of input patch attributes for each patch as well as instructions for processing each input patch. A plurality of threads is launched to execute the instructions to generate each vertex of a corresponding output patch based on the input patch. Reads of values written during instruction execution are synchronized so threads can read and further process the values of other threads. An output patch is then assembled from the outputs of each of the threads; and emitting the output patch for further processing.

Abstract: One embodiment of the present invention sets forth a technique to setup efficient bump mapping using a geometry shader. This approach uses a vertex shader, a primitive assembly unit, and a geometry shader. The vertex shader performs vertex operations, such as calculating a per-vertex normal vector, and emits vertex data. The primitive assembly unit processes the vertex data and constructs primitives. Each primitive includes a series of one or more vertices, each of which may be shared amongst multiple primitives, and state information defining the primitive. The geometry shader processes each primitive, calculating an object-space to texture-space mapping for each vertex of the primitive and, subsequently, using this mapping to transform the object-space view vector and the object-space light vectors associated with each vertex of the primitive to texture-space equivalents.

Abstract: Systems and methods for compiling high-level primitive programs are used to generate primitive program micro-code for execution by a primitive processor. A compiler is configured to produce micro-code for a specific target primitive processor based on the target primitive processor's capabilities. The compiler supports features of the high-level primitive program by providing conversions for different applications programming interface conventions, determining output primitive types, initializing attribute arrays based on primitive input profile modifiers, and determining vertex set lengths from specified primitive input types.

Abstract: In a raster unit of a graphics processor, a method for bounding region accumulation for graphics rendering. The method includes receiving a plurality of graphics primitives for rasterization in a raster stage of a graphics processor and rasterizing the graphics primitives to generate a plurality pixels related to the graphics primitives and a plurality of respective bounding regions related to the graphics primitives. Upon receiving an accumulation start command, the bounding regions are accumulated in an accumulation register. The accumulation continues until an accumulation stop command is received. The operation results in an accumulated bounding region. Access to the accumulated bounding region is enabled to facilitate a subsequent graphics rendering operation.