s_renderbuffer.c revision 379e0a3ada995b4cf57d142e0dd4618022e0aadc
1ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul/* 2ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * Mesa 3-D graphics library 3ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * Version: 6.5 4ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * 5ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * Copyright (C) 1999-2006 Brian Paul All Rights Reserved. 6ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * 7ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * Permission is hereby granted, free of charge, to any person obtaining a 8ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * copy of this software and associated documentation files (the "Software"), 9ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * to deal in the Software without restriction, including without limitation 10ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * the rights to use, copy, modify, merge, publish, distribute, sublicense, 11ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * and/or sell copies of the Software, and to permit persons to whom the 12ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * Software is furnished to do so, subject to the following conditions: 13ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * 14ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * The above copyright notice and this permission notice shall be included 15ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * in all copies or substantial portions of the Software. 16ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * 17ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 18ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 19ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 20ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN 21ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 22ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 23ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul */ 24ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 25ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 26ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul/** 27379e0a3ada995b4cf57d142e0dd4618022e0aadcBrian Paul * Functions for allocating/managing software-based renderbuffers. 28ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * Also, routines for reading/writing software-based renderbuffer data as 29ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * ubytes, ushorts, uints, etc. 30ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul */ 31ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 32ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 33379e0a3ada995b4cf57d142e0dd4618022e0aadcBrian Paul#include "main/glheader.h" 34379e0a3ada995b4cf57d142e0dd4618022e0aadcBrian Paul#include "main/imports.h" 35379e0a3ada995b4cf57d142e0dd4618022e0aadcBrian Paul#include "main/context.h" 36379e0a3ada995b4cf57d142e0dd4618022e0aadcBrian Paul#include "main/fbobject.h" 37379e0a3ada995b4cf57d142e0dd4618022e0aadcBrian Paul#include "main/formats.h" 38379e0a3ada995b4cf57d142e0dd4618022e0aadcBrian Paul#include "main/mtypes.h" 39379e0a3ada995b4cf57d142e0dd4618022e0aadcBrian Paul#include "main/renderbuffer.h" 40379e0a3ada995b4cf57d142e0dd4618022e0aadcBrian Paul#include "swrast/s_renderbuffer.h" 41ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 42ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 43ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul/* 44ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * Routines for get/put values in common buffer formats follow. 45ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul */ 46ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 47ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul/* Returns a bytes per pixel of the DataType in the get/put span 48ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * functions for at least a subset of the available combinations a 49ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * renderbuffer can have. 50ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * 51ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * It would be nice to see gl_renderbuffer start talking about a 52ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * gl_format instead of a GLenum DataType. 53ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul */ 54ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic int 55ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulget_datatype_bytes(struct gl_renderbuffer *rb) 56ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 57ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul int component_size; 58ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 59ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul switch (rb->DataType) { 60ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul case GL_FLOAT_32_UNSIGNED_INT_24_8_REV: 61ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul component_size = 8; 62ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul break; 63ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul case GL_FLOAT: 64ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul case GL_UNSIGNED_INT: 65ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul case GL_UNSIGNED_INT_24_8_EXT: 66ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul component_size = 4; 67ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul break; 68ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul case GL_UNSIGNED_SHORT: 69ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul component_size = 2; 70ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul break; 71ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul case GL_UNSIGNED_BYTE: 72ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul component_size = 1; 73ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul break; 74ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul default: 75ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul component_size = 1; 76ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul assert(0); 77ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 78ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 79ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul switch (rb->_BaseFormat) { 80ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul case GL_DEPTH_COMPONENT: 81ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul case GL_DEPTH_STENCIL: 82ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul return component_size; 83ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul default: 84ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul return 4 * component_size; 85ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 86ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 87ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 88ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul/* This is commonly used by most of the accessors. */ 89ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void * 90ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulget_pointer_generic(struct gl_context *ctx, struct gl_renderbuffer *rb, 91ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLint x, GLint y) 92ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 93ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (!rb->Data) 94ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul return NULL; 95ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 96ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul return ((char *) rb->Data + 97ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul (y * rb->RowStride + x) * _mesa_get_format_bytes(rb->Format)); 98ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 99ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 100ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul/* GetRow() implementation for formats where DataType matches the rb->Format. 101ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul */ 102ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 103ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulget_row_generic(struct gl_context *ctx, struct gl_renderbuffer *rb, 104ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint count, GLint x, GLint y, void *values) 105ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 106ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul void *src = rb->GetPointer(ctx, rb, x, y); 107ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul memcpy(values, src, count * _mesa_get_format_bytes(rb->Format)); 108ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 109ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 110ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul/* Only used for float textures currently, but might also be used for 111ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * RGBA8888, RGBA16, etc. 112ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul */ 113ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 114ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulget_values_generic(struct gl_context *ctx, struct gl_renderbuffer *rb, 115ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint count, const GLint x[], const GLint y[], void *values) 116ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 117ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul int format_bytes = _mesa_get_format_bytes(rb->Format) / sizeof(GLfloat); 118ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint i; 119ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 120ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 121ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const void *src = rb->GetPointer(ctx, rb, x[i], y[i]); 122ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul char *dst = (char *) values + i * format_bytes; 123ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul memcpy(dst, src, format_bytes); 124ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 125ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 126ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 127ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul/* For the GL_RED/GL_RG/GL_RGB format/DataType combinations (and 128ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * GL_LUMINANCE/GL_INTENSITY?), the Put functions are a matter of 129ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * storing those initial components of the value per pixel into the 130ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * destination. 131ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul */ 132ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 133ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulput_row_generic(struct gl_context *ctx, struct gl_renderbuffer *rb, 134ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint count, GLint x, GLint y, 135ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const void *values, const GLubyte *mask) 136ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 137ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul void *row = rb->GetPointer(ctx, rb, x, y); 138ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul int format_bytes = _mesa_get_format_bytes(rb->Format) / sizeof(GLfloat); 139ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul int datatype_bytes = get_datatype_bytes(rb); 140ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul unsigned int i; 141ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 142ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (mask) { 143ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 144ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul char *dst = (char *) row + i * format_bytes; 145ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const char *src = (const char *) values + i * datatype_bytes; 146ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 147ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (mask[i]) { 148ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul memcpy(dst, src, format_bytes); 149ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 150ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 151ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 152ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul else { 153ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 154ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul char *dst = (char *) row + i * format_bytes; 155ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const char *src = (const char *) values + i * datatype_bytes; 156ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul memcpy(dst, src, format_bytes); 157ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 158ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 159ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 160ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 161ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 162ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulput_mono_row_generic(struct gl_context *ctx, struct gl_renderbuffer *rb, 163ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint count, GLint x, GLint y, 164ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const void *value, const GLubyte *mask) 165ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 166ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul void *row = rb->GetPointer(ctx, rb, x, y); 167ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul int format_bytes = _mesa_get_format_bytes(rb->Format) / sizeof(GLfloat); 168ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul unsigned int i; 169ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 170ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (mask) { 171ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 172ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul char *dst = (char *) row + i * format_bytes; 173ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (mask[i]) { 174ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul memcpy(dst, value, format_bytes); 175ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 176ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 177ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 178ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul else { 179ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 180ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul char *dst = (char *) row + i * format_bytes; 181ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul memcpy(dst, value, format_bytes); 182ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 183ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 184ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 185ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 186ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 187ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 188ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulput_values_generic(struct gl_context *ctx, struct gl_renderbuffer *rb, 189ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint count, const GLint x[], const GLint y[], 190ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const void *values, const GLubyte *mask) 191ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 192ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul int format_bytes = _mesa_get_format_bytes(rb->Format) / sizeof(GLfloat); 193ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul int datatype_bytes = get_datatype_bytes(rb); 194ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul unsigned int i; 195ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 196ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 197ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (!mask || mask[i]) { 198ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul void *dst = rb->GetPointer(ctx, rb, x[i], y[i]); 199ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const char *src = (const char *) values + i * datatype_bytes; 200ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul memcpy(dst, src, format_bytes); 201ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 202ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 203ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 204ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 205ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 206ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 207ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulput_mono_values_generic(struct gl_context *ctx, 208ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul struct gl_renderbuffer *rb, 209ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint count, const GLint x[], const GLint y[], 210ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const void *value, const GLubyte *mask) 211ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 212ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul int format_bytes = _mesa_get_format_bytes(rb->Format) / sizeof(GLfloat); 213ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul unsigned int i; 214ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 215ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 216ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (!mask || mask[i]) { 217ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul void *dst = rb->GetPointer(ctx, rb, x[i], y[i]); 218ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul memcpy(dst, value, format_bytes); 219ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 220ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 221ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 222ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 223ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul/********************************************************************** 224ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * Functions for buffers of 1 X GLubyte values. 225ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * Typically stencil. 226ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul */ 227ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 228ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 229ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulget_values_ubyte(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count, 230ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLint x[], const GLint y[], void *values) 231ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 232ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLubyte *dst = (GLubyte *) values; 233ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint i; 234ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul ASSERT(rb->DataType == GL_UNSIGNED_BYTE); 235ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 236ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLubyte *src = (GLubyte *) rb->Data + y[i] * rb->RowStride + x[i]; 237ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i] = *src; 238ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 239ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 240ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 241ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 242ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 243ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulput_row_ubyte(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count, 244ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLint x, GLint y, const void *values, const GLubyte *mask) 245ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 246ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLubyte *src = (const GLubyte *) values; 247ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLubyte *dst = (GLubyte *) rb->Data + y * rb->RowStride + x; 248ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul ASSERT(rb->DataType == GL_UNSIGNED_BYTE); 249ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (mask) { 250ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint i; 251ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 252ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (mask[i]) { 253ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i] = src[i]; 254ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 255ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 256ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 257ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul else { 258ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul memcpy(dst, values, count * sizeof(GLubyte)); 259ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 260ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 261ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 262ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 263ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 264ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulput_mono_row_ubyte(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count, 265ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLint x, GLint y, const void *value, const GLubyte *mask) 266ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 267ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLubyte val = *((const GLubyte *) value); 268ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLubyte *dst = (GLubyte *) rb->Data + y * rb->RowStride + x; 269ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul ASSERT(rb->DataType == GL_UNSIGNED_BYTE); 270ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (mask) { 271ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint i; 272ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 273ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (mask[i]) { 274ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i] = val; 275ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 276ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 277ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 278ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul else { 279ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint i; 280ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 281ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i] = val; 282ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 283ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 284ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 285ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 286ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 287ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 288ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulput_values_ubyte(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count, 289ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLint x[], const GLint y[], 290ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const void *values, const GLubyte *mask) 291ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 292ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLubyte *src = (const GLubyte *) values; 293ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint i; 294ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul ASSERT(rb->DataType == GL_UNSIGNED_BYTE); 295ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 296ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (!mask || mask[i]) { 297ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLubyte *dst = (GLubyte *) rb->Data + y[i] * rb->RowStride + x[i]; 298ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul *dst = src[i]; 299ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 300ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 301ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 302ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 303ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 304ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 305ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulput_mono_values_ubyte(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count, 306ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLint x[], const GLint y[], 307ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const void *value, const GLubyte *mask) 308ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 309ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLubyte val = *((const GLubyte *) value); 310ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint i; 311ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul ASSERT(rb->DataType == GL_UNSIGNED_BYTE); 312ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 313ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (!mask || mask[i]) { 314ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLubyte *dst = (GLubyte *) rb->Data + y[i] * rb->RowStride + x[i]; 315ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul *dst = val; 316ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 317ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 318ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 319ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 320ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 321ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul/********************************************************************** 322ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * Functions for buffers of 1 X GLushort values. 323ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * Typically depth/Z. 324ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul */ 325ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 326ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 327ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulget_values_ushort(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count, 328ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLint x[], const GLint y[], void *values) 329ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 330ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLushort *dst = (GLushort *) values; 331ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint i; 332ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul ASSERT(rb->DataType == GL_UNSIGNED_SHORT); 333ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 334ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLushort *src = (GLushort *) rb->Data + y[i] * rb->RowStride + x[i]; 335ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i] = *src; 336ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 337ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 338ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 339ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 340ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 341ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulput_row_ushort(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count, 342ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLint x, GLint y, const void *values, const GLubyte *mask) 343ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 344ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLushort *src = (const GLushort *) values; 345ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLushort *dst = (GLushort *) rb->Data + y * rb->RowStride + x; 346ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul ASSERT(rb->DataType == GL_UNSIGNED_SHORT); 347ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (mask) { 348ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint i; 349ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 350ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (mask[i]) { 351ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i] = src[i]; 352ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 353ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 354ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 355ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul else { 356ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul memcpy(dst, src, count * sizeof(GLushort)); 357ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 358ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 359ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 360ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 361ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 362ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulput_mono_row_ushort(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count, 363ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLint x, GLint y, const void *value, const GLubyte *mask) 364ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 365ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLushort val = *((const GLushort *) value); 366ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLushort *dst = (GLushort *) rb->Data + y * rb->RowStride + x; 367ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul ASSERT(rb->DataType == GL_UNSIGNED_SHORT); 368ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (mask) { 369ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint i; 370ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 371ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (mask[i]) { 372ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i] = val; 373ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 374ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 375ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 376ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul else { 377ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint i; 378ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 379ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i] = val; 380ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 381ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 382ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 383ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 384ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 385ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 386ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulput_values_ushort(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count, 387ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLint x[], const GLint y[], const void *values, 388ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLubyte *mask) 389ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 390ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLushort *src = (const GLushort *) values; 391ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint i; 392ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul ASSERT(rb->DataType == GL_UNSIGNED_SHORT); 393ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 394ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (!mask || mask[i]) { 395ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLushort *dst = (GLushort *) rb->Data + y[i] * rb->RowStride + x[i]; 396ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul *dst = src[i]; 397ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 398ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 399ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 400ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 401ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 402ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 403ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulput_mono_values_ushort(struct gl_context *ctx, struct gl_renderbuffer *rb, 404ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint count, const GLint x[], const GLint y[], 405ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const void *value, const GLubyte *mask) 406ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 407ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLushort val = *((const GLushort *) value); 408ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul ASSERT(rb->DataType == GL_UNSIGNED_SHORT); 409ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (mask) { 410ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint i; 411ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 412ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (mask[i]) { 413ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLushort *dst = (GLushort *) rb->Data + y[i] * rb->RowStride + x[i]; 414ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul *dst = val; 415ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 416ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 417ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 418ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul else { 419ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint i; 420ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 421ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLushort *dst = (GLushort *) rb->Data + y[i] * rb->RowStride + x[i]; 422ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul *dst = val; 423ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 424ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 425ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 426ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 427ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 428ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul/********************************************************************** 429ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * Functions for buffers of 1 X GLuint values. 430ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * Typically depth/Z or color index. 431ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul */ 432ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 433ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 434ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulget_values_uint(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count, 435ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLint x[], const GLint y[], void *values) 436ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 437ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint *dst = (GLuint *) values; 438ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint i; 439ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul ASSERT(rb->DataType == GL_UNSIGNED_INT || 440ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->DataType == GL_UNSIGNED_INT_24_8_EXT); 441ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 442ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLuint *src = (GLuint *) rb->Data + y[i] * rb->RowStride + x[i]; 443ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i] = *src; 444ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 445ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 446ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 447ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 448ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 449ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulput_row_uint(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count, 450ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLint x, GLint y, const void *values, const GLubyte *mask) 451ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 452ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLuint *src = (const GLuint *) values; 453ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint *dst = (GLuint *) rb->Data + y * rb->RowStride + x; 454ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul ASSERT(rb->DataType == GL_UNSIGNED_INT || 455ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->DataType == GL_UNSIGNED_INT_24_8_EXT); 456ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (mask) { 457ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint i; 458ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 459ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (mask[i]) { 460ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i] = src[i]; 461ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 462ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 463ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 464ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul else { 465ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul memcpy(dst, src, count * sizeof(GLuint)); 466ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 467ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 468ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 469ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 470ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 471ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulput_mono_row_uint(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count, 472ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLint x, GLint y, const void *value, const GLubyte *mask) 473ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 474ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLuint val = *((const GLuint *) value); 475ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint *dst = (GLuint *) rb->Data + y * rb->RowStride + x; 476ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul ASSERT(rb->DataType == GL_UNSIGNED_INT || 477ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->DataType == GL_UNSIGNED_INT_24_8_EXT); 478ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (mask) { 479ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint i; 480ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 481ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (mask[i]) { 482ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i] = val; 483ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 484ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 485ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 486ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul else { 487ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint i; 488ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 489ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i] = val; 490ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 491ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 492ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 493ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 494ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 495ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 496ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulput_values_uint(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count, 497ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLint x[], const GLint y[], const void *values, 498ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLubyte *mask) 499ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 500ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLuint *src = (const GLuint *) values; 501ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint i; 502ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul ASSERT(rb->DataType == GL_UNSIGNED_INT || 503ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->DataType == GL_UNSIGNED_INT_24_8_EXT); 504ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 505ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (!mask || mask[i]) { 506ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint *dst = (GLuint *) rb->Data + y[i] * rb->RowStride + x[i]; 507ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul *dst = src[i]; 508ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 509ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 510ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 511ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 512ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 513ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 514ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulput_mono_values_uint(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count, 515ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLint x[], const GLint y[], const void *value, 516ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLubyte *mask) 517ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 518ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLuint val = *((const GLuint *) value); 519ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint i; 520ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul ASSERT(rb->DataType == GL_UNSIGNED_INT || 521ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->DataType == GL_UNSIGNED_INT_24_8_EXT); 522ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 523ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (!mask || mask[i]) { 524ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint *dst = (GLuint *) rb->Data + y[i] * rb->RowStride + x[i]; 525ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul *dst = val; 526ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 527ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 528ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 529ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 530ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 531ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul/********************************************************************** 532ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * Functions for buffers of 3 X GLubyte (or GLbyte) values. 533ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * Typically color buffers. 534ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * NOTE: the incoming and outgoing colors are RGBA! We ignore incoming 535ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * alpha values and return 255 for outgoing alpha values. 536ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul */ 537ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 538ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void * 539ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulget_pointer_ubyte3(struct gl_context *ctx, struct gl_renderbuffer *rb, 540ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLint x, GLint y) 541ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 542ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul ASSERT(rb->Format == MESA_FORMAT_RGB888); 543ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul /* No direct access since this buffer is RGB but caller will be 544ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * treating it as if it were RGBA. 545ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul */ 546ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul return NULL; 547ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 548ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 549ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 550ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 551ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulget_row_ubyte3(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count, 552ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLint x, GLint y, void *values) 553ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 554ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLubyte *src = ((const GLubyte *) rb->Data) + 555ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 3 * (y * rb->RowStride + x); 556ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLubyte *dst = (GLubyte *) values; 557ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint i; 558ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul ASSERT(rb->Format == MESA_FORMAT_RGB888); 559ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul ASSERT(rb->DataType == GL_UNSIGNED_BYTE); 560ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 561ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + 0] = src[i * 3 + 0]; 562ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + 1] = src[i * 3 + 1]; 563ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + 2] = src[i * 3 + 2]; 564ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + 3] = 255; 565ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 566ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 567ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 568ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 569ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 570ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulget_values_ubyte3(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count, 571ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLint x[], const GLint y[], void *values) 572ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 573ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLubyte *dst = (GLubyte *) values; 574ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint i; 575ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul ASSERT(rb->Format == MESA_FORMAT_RGB888); 576ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul ASSERT(rb->DataType == GL_UNSIGNED_BYTE); 577ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 578ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLubyte *src 579ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul = (GLubyte *) rb->Data + 3 * (y[i] * rb->RowStride + x[i]); 580ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + 0] = src[0]; 581ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + 1] = src[1]; 582ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + 2] = src[2]; 583ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + 3] = 255; 584ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 585ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 586ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 587ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 588ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 589ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulput_row_ubyte3(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count, 590ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLint x, GLint y, const void *values, const GLubyte *mask) 591ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 592ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul /* note: incoming values are RGB+A! */ 593ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLubyte *src = (const GLubyte *) values; 594ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLubyte *dst = (GLubyte *) rb->Data + 3 * (y * rb->RowStride + x); 595ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint i; 596ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul ASSERT(rb->Format == MESA_FORMAT_RGB888); 597ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul ASSERT(rb->DataType == GL_UNSIGNED_BYTE); 598ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 599ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (!mask || mask[i]) { 600ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 3 + 0] = src[i * 4 + 0]; 601ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 3 + 1] = src[i * 4 + 1]; 602ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 3 + 2] = src[i * 4 + 2]; 603ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 604ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 605ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 606ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 607ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 608ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 609ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulput_row_rgb_ubyte3(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count, 610ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLint x, GLint y, const void *values, const GLubyte *mask) 611ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 612ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul /* note: incoming values are RGB+A! */ 613ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLubyte *src = (const GLubyte *) values; 614ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLubyte *dst = (GLubyte *) rb->Data + 3 * (y * rb->RowStride + x); 615ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint i; 616ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul ASSERT(rb->Format == MESA_FORMAT_RGB888); 617ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul ASSERT(rb->DataType == GL_UNSIGNED_BYTE); 618ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 619ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (!mask || mask[i]) { 620ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 3 + 0] = src[i * 3 + 0]; 621ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 3 + 1] = src[i * 3 + 1]; 622ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 3 + 2] = src[i * 3 + 2]; 623ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 624ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 625ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 626ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 627ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 628ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 629ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulput_mono_row_ubyte3(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count, 630ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLint x, GLint y, const void *value, const GLubyte *mask) 631ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 632ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul /* note: incoming value is RGB+A! */ 633ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLubyte val0 = ((const GLubyte *) value)[0]; 634ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLubyte val1 = ((const GLubyte *) value)[1]; 635ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLubyte val2 = ((const GLubyte *) value)[2]; 636ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLubyte *dst = (GLubyte *) rb->Data + 3 * (y * rb->RowStride + x); 637ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul ASSERT(rb->Format == MESA_FORMAT_RGB888); 638ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul ASSERT(rb->DataType == GL_UNSIGNED_BYTE); 639ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (!mask && val0 == val1 && val1 == val2) { 640ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul /* optimized case */ 641ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul memset(dst, val0, 3 * count); 642ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 643ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul else { 644ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint i; 645ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 646ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (!mask || mask[i]) { 647ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 3 + 0] = val0; 648ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 3 + 1] = val1; 649ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 3 + 2] = val2; 650ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 651ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 652ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 653ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 654ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 655ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 656ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 657ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulput_values_ubyte3(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count, 658ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLint x[], const GLint y[], const void *values, 659ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLubyte *mask) 660ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 661ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul /* note: incoming values are RGB+A! */ 662ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLubyte *src = (const GLubyte *) values; 663ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint i; 664ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul ASSERT(rb->Format == MESA_FORMAT_RGB888); 665ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul ASSERT(rb->DataType == GL_UNSIGNED_BYTE); 666ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 667ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (!mask || mask[i]) { 668ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLubyte *dst = (GLubyte *) rb->Data + 3 * (y[i] * rb->RowStride + x[i]); 669ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[0] = src[i * 4 + 0]; 670ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[1] = src[i * 4 + 1]; 671ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[2] = src[i * 4 + 2]; 672ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 673ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 674ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 675ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 676ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 677ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 678ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulput_mono_values_ubyte3(struct gl_context *ctx, struct gl_renderbuffer *rb, 679ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint count, const GLint x[], const GLint y[], 680ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const void *value, const GLubyte *mask) 681ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 682ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul /* note: incoming value is RGB+A! */ 683ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLubyte val0 = ((const GLubyte *) value)[0]; 684ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLubyte val1 = ((const GLubyte *) value)[1]; 685ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLubyte val2 = ((const GLubyte *) value)[2]; 686ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint i; 687ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul ASSERT(rb->Format == MESA_FORMAT_RGB888); 688ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul ASSERT(rb->DataType == GL_UNSIGNED_BYTE); 689ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 690ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (!mask || mask[i]) { 691ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLubyte *dst = ((GLubyte *) rb->Data) + 692ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 3 * (y[i] * rb->RowStride + x[i]); 693ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[0] = val0; 694ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[1] = val1; 695ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[2] = val2; 696ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 697ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 698ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 699ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 700ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 701ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul/********************************************************************** 702ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * Functions for buffers of 4 X GLubyte (or GLbyte) values. 703ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * Typically color buffers. 704ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul */ 705ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 706ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 707ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulget_values_ubyte4(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count, 708ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLint x[], const GLint y[], void *values) 709ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 710ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul /* treat 4*GLubyte as 1*GLuint */ 711ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint *dst = (GLuint *) values; 712ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint i; 713ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul ASSERT(rb->DataType == GL_UNSIGNED_BYTE); 714ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul ASSERT(rb->Format == MESA_FORMAT_RGBA8888 || 715ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->Format == MESA_FORMAT_RGBA8888_REV); 716ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 717ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLuint *src = (GLuint *) rb->Data + (y[i] * rb->RowStride + x[i]); 718ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i] = *src; 719ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 720ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 721ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 722ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 723ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 724ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulput_row_ubyte4(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count, 725ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLint x, GLint y, const void *values, const GLubyte *mask) 726ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 727ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul /* treat 4*GLubyte as 1*GLuint */ 728ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLuint *src = (const GLuint *) values; 729ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint *dst = (GLuint *) rb->Data + (y * rb->RowStride + x); 730ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul ASSERT(rb->DataType == GL_UNSIGNED_BYTE); 731ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul ASSERT(rb->Format == MESA_FORMAT_RGBA8888 || 732ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->Format == MESA_FORMAT_RGBA8888_REV); 733ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (mask) { 734ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint i; 735ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 736ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (mask[i]) { 737ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i] = src[i]; 738ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 739ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 740ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 741ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul else { 742ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul memcpy(dst, src, 4 * count * sizeof(GLubyte)); 743ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 744ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 745ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 746ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 747ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 748ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulput_row_rgb_ubyte4(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count, 749ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLint x, GLint y, const void *values, const GLubyte *mask) 750ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 751ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul /* Store RGB values in RGBA buffer */ 752ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLubyte *src = (const GLubyte *) values; 753ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLubyte *dst = (GLubyte *) rb->Data + 4 * (y * rb->RowStride + x); 754ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint i; 755ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul ASSERT(rb->DataType == GL_UNSIGNED_BYTE); 756ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul ASSERT(rb->Format == MESA_FORMAT_RGBA8888 || 757ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->Format == MESA_FORMAT_RGBA8888_REV); 758ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 759ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (!mask || mask[i]) { 760ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + 0] = src[i * 3 + 0]; 761ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + 1] = src[i * 3 + 1]; 762ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + 2] = src[i * 3 + 2]; 763ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + 3] = 0xff; 764ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 765ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 766ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 767ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 768ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 769ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 770ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulput_mono_row_ubyte4(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count, 771ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLint x, GLint y, const void *value, const GLubyte *mask) 772ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 773ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul /* treat 4*GLubyte as 1*GLuint */ 774ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLuint val = *((const GLuint *) value); 775ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint *dst = (GLuint *) rb->Data + (y * rb->RowStride + x); 776ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul ASSERT(rb->DataType == GL_UNSIGNED_BYTE); 777ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul ASSERT(rb->Format == MESA_FORMAT_RGBA8888 || 778ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->Format == MESA_FORMAT_RGBA8888_REV); 779ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (!mask && val == 0) { 780ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul /* common case */ 781ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul memset(dst, 0, count * 4 * sizeof(GLubyte)); 782ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 783ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul else { 784ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul /* general case */ 785ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (mask) { 786ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint i; 787ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 788ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (mask[i]) { 789ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i] = val; 790ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 791ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 792ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 793ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul else { 794ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint i; 795ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 796ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i] = val; 797ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 798ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 799ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 800ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 801ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 802ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 803ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 804ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulput_values_ubyte4(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count, 805ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLint x[], const GLint y[], const void *values, 806ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLubyte *mask) 807ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 808ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul /* treat 4*GLubyte as 1*GLuint */ 809ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLuint *src = (const GLuint *) values; 810ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint i; 811ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul ASSERT(rb->DataType == GL_UNSIGNED_BYTE); 812ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul ASSERT(rb->Format == MESA_FORMAT_RGBA8888 || 813ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->Format == MESA_FORMAT_RGBA8888_REV); 814ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 815ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (!mask || mask[i]) { 816ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint *dst = (GLuint *) rb->Data + (y[i] * rb->RowStride + x[i]); 817ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul *dst = src[i]; 818ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 819ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 820ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 821ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 822ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 823ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 824ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulput_mono_values_ubyte4(struct gl_context *ctx, struct gl_renderbuffer *rb, 825ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint count, const GLint x[], const GLint y[], 826ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const void *value, const GLubyte *mask) 827ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 828ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul /* treat 4*GLubyte as 1*GLuint */ 829ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLuint val = *((const GLuint *) value); 830ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint i; 831ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul ASSERT(rb->DataType == GL_UNSIGNED_BYTE); 832ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul ASSERT(rb->Format == MESA_FORMAT_RGBA8888 || 833ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->Format == MESA_FORMAT_RGBA8888_REV); 834ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 835ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (!mask || mask[i]) { 836ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint *dst = (GLuint *) rb->Data + (y[i] * rb->RowStride + x[i]); 837ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul *dst = val; 838ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 839ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 840ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 841ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 842ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 843ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul/********************************************************************** 844ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * Functions for buffers of 4 X GLushort (or GLshort) values. 845ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * Typically accum buffer. 846ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul */ 847ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 848ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 849ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulget_values_ushort4(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count, 850ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLint x[], const GLint y[], void *values) 851ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 852ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLushort *dst = (GLushort *) values; 853ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint i; 854ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul ASSERT(rb->DataType == GL_UNSIGNED_SHORT || rb->DataType == GL_SHORT); 855ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 856ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLushort *src 857ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul = (GLushort *) rb->Data + 4 * (y[i] * rb->RowStride + x[i]); 858ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i] = *src; 859ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 860ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 861ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 862ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 863ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 864ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulput_row_ushort4(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count, 865ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLint x, GLint y, const void *values, const GLubyte *mask) 866ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 867ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLushort *src = (const GLushort *) values; 868ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLushort *dst = (GLushort *) rb->Data + 4 * (y * rb->RowStride + x); 869ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul ASSERT(rb->DataType == GL_UNSIGNED_SHORT || rb->DataType == GL_SHORT); 870ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (mask) { 871ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint i; 872ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 873ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (mask[i]) { 874ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + 0] = src[i * 4 + 0]; 875ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + 1] = src[i * 4 + 1]; 876ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + 2] = src[i * 4 + 2]; 877ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + 3] = src[i * 4 + 3]; 878ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 879ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 880ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 881ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul else { 882ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul memcpy(dst, src, 4 * count * sizeof(GLushort)); 883ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 884ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 885ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 886ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 887ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 888ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulput_row_rgb_ushort4(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count, 889ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLint x, GLint y, const void *values, const GLubyte *mask) 890ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 891ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul /* Put RGB values in RGBA buffer */ 892ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLushort *src = (const GLushort *) values; 893ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLushort *dst = (GLushort *) rb->Data + 4 * (y * rb->RowStride + x); 894ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul ASSERT(rb->DataType == GL_UNSIGNED_SHORT || rb->DataType == GL_SHORT); 895ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (mask) { 896ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint i; 897ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 898ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (mask[i]) { 899ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + 0] = src[i * 3 + 0]; 900ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + 1] = src[i * 3 + 1]; 901ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + 2] = src[i * 3 + 2]; 902ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + 3] = 0xffff; 903ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 904ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 905ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 906ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul else { 907ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul memcpy(dst, src, 4 * count * sizeof(GLushort)); 908ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 909ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 910ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 911ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 912ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 913ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulput_mono_row_ushort4(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count, 914ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLint x, GLint y, const void *value, const GLubyte *mask) 915ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 916ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLushort val0 = ((const GLushort *) value)[0]; 917ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLushort val1 = ((const GLushort *) value)[1]; 918ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLushort val2 = ((const GLushort *) value)[2]; 919ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLushort val3 = ((const GLushort *) value)[3]; 920ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLushort *dst = (GLushort *) rb->Data + 4 * (y * rb->RowStride + x); 921ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul ASSERT(rb->DataType == GL_UNSIGNED_SHORT || rb->DataType == GL_SHORT); 922ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (!mask && val0 == 0 && val1 == 0 && val2 == 0 && val3 == 0) { 923ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul /* common case for clearing accum buffer */ 924ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul memset(dst, 0, count * 4 * sizeof(GLushort)); 925ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 926ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul else { 927ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint i; 928ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 929ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (!mask || mask[i]) { 930ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + 0] = val0; 931ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + 1] = val1; 932ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + 2] = val2; 933ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + 3] = val3; 934ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 935ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 936ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 937ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 938ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 939ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 940ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 941ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulput_values_ushort4(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count, 942ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLint x[], const GLint y[], const void *values, 943ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLubyte *mask) 944ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 945ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLushort *src = (const GLushort *) values; 946ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint i; 947ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul ASSERT(rb->DataType == GL_UNSIGNED_SHORT || rb->DataType == GL_SHORT); 948ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 949ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (!mask || mask[i]) { 950ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLushort *dst = 951ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul ((GLushort *) rb->Data) + 4 * (y[i] * rb->RowStride + x[i]); 952ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[0] = src[i * 4 + 0]; 953ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[1] = src[i * 4 + 1]; 954ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[2] = src[i * 4 + 2]; 955ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[3] = src[i * 4 + 3]; 956ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 957ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 958ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 959ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 960ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 961ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 962ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulput_mono_values_ushort4(struct gl_context *ctx, struct gl_renderbuffer *rb, 963ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint count, const GLint x[], const GLint y[], 964ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const void *value, const GLubyte *mask) 965ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 966ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLushort val0 = ((const GLushort *) value)[0]; 967ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLushort val1 = ((const GLushort *) value)[1]; 968ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLushort val2 = ((const GLushort *) value)[2]; 969ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLushort val3 = ((const GLushort *) value)[3]; 970ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint i; 971ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul ASSERT(rb->DataType == GL_UNSIGNED_SHORT || rb->DataType == GL_SHORT); 972ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 973ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (!mask || mask[i]) { 974ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLushort *dst = ((GLushort *) rb->Data) + 975ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 4 * (y[i] * rb->RowStride + x[i]); 976ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[0] = val0; 977ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[1] = val1; 978ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[2] = val2; 979ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[3] = val3; 980ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 981ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 982ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 983ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 984ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul/********************************************************************** 985ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * Functions for MESA_FORMAT_R8. 986ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul */ 987ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 988ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulget_row_r8(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count, 989ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLint x, GLint y, void *values) 990ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 991ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLubyte *src = rb->GetPointer(ctx, rb, x, y); 992ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint *dst = values; 993ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint i; 994ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 995ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 996ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i] = 0xff000000 | src[i]; 997ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 998ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 999ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1000ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 1001ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulget_values_r8(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count, 1002ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLint x[], const GLint y[], void *values) 1003ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 1004ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint *dst = (GLuint *) values; 1005ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint i; 1006ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1007ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 1008ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLubyte *src = rb->GetPointer(ctx, rb, x[i], y[i]); 1009ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i] = 0xff000000 | *src; 1010ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 1011ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 1012ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1013ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul/********************************************************************** 1014ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * Functions for MESA_FORMAT_GR88. 1015ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul */ 1016ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 1017ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulget_row_rg88(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count, 1018ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLint x, GLint y, void *values) 1019ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 1020ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLushort *src = rb->GetPointer(ctx, rb, x, y); 1021ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint *dst = values; 1022ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint i; 1023ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1024ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 1025ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i] = 0xff000000 | src[i]; 1026ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 1027ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 1028ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1029ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 1030ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulget_values_rg88(struct gl_context *ctx, struct gl_renderbuffer *rb, 1031ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint count, const GLint x[], const GLint y[], void *values) 1032ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 1033ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint *dst = (GLuint *) values; 1034ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint i; 1035ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1036ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 1037ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLshort *src = rb->GetPointer(ctx, rb, x[i], y[i]); 1038ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i] = 0xff000000 | *src; 1039ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 1040ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 1041ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1042ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul/********************************************************************** 1043ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * Functions for MESA_FORMAT_R16. 1044ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul */ 1045ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 1046ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulget_row_r16(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count, 1047ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLint x, GLint y, void *values) 1048ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 1049ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLushort *src = rb->GetPointer(ctx, rb, x, y); 1050ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLushort *dst = values; 1051ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint i; 1052ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1053ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 1054ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + RCOMP] = src[i]; 1055ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + GCOMP] = 0; 1056ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + BCOMP] = 0; 1057ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + ACOMP] = 0xffff; 1058ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 1059ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 1060ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1061ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 1062ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulget_values_r16(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count, 1063ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLint x[], const GLint y[], void *values) 1064ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 1065ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLushort *dst = values; 1066ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint i; 1067ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1068ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 1069ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLushort *src = rb->GetPointer(ctx, rb, x[i], y[i]); 1070ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + RCOMP] = *src; 1071ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + GCOMP] = 0; 1072ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + BCOMP] = 0; 1073ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + ACOMP] = 0xffff; 1074ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 1075ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 1076ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1077ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul/********************************************************************** 1078ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * Functions for MESA_FORMAT_RG1616. 1079ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul */ 1080ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 1081ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulget_row_rg1616(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count, 1082ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLint x, GLint y, void *values) 1083ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 1084ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLushort *src = rb->GetPointer(ctx, rb, x, y); 1085ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLushort *dst = values; 1086ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint i; 1087ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1088ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 1089ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + RCOMP] = src[i * 2]; 1090ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + GCOMP] = src[i * 2 + 1]; 1091ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + BCOMP] = 0; 1092ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + ACOMP] = 0xffff; 1093ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 1094ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 1095ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1096ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 1097ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulget_values_rg1616(struct gl_context *ctx, struct gl_renderbuffer *rb, 1098ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint count, const GLint x[], const GLint y[], void *values) 1099ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 1100ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLushort *dst = values; 1101ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint i; 1102ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1103ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 1104ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLshort *src = rb->GetPointer(ctx, rb, x[i], y[i]); 1105ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + RCOMP] = src[0]; 1106ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + GCOMP] = src[1]; 1107ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + BCOMP] = 0; 1108ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + ACOMP] = 0xffff; 1109ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 1110ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 1111ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1112ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul/********************************************************************** 1113ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * Functions for MESA_FORMAT_INTENSITY_FLOAT32. 1114ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul */ 1115ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 1116ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulget_row_i_float32(struct gl_context *ctx, struct gl_renderbuffer *rb, 1117ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint count, GLint x, GLint y, void *values) 1118ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 1119ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLfloat *src = rb->GetPointer(ctx, rb, x, y); 1120ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLfloat *dst = values; 1121ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint i; 1122ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1123ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 1124ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + RCOMP] = 1125ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + GCOMP] = 1126ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + BCOMP] = 1127ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + ACOMP] = src[i]; 1128ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 1129ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 1130ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1131ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 1132ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulget_values_i_float32(struct gl_context *ctx, struct gl_renderbuffer *rb, 1133ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint count, const GLint x[], const GLint y[], 1134ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul void *values) 1135ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 1136ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLfloat *dst = values; 1137ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint i; 1138ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1139ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 1140ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLfloat *src = rb->GetPointer(ctx, rb, x[i], y[i]); 1141ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + RCOMP] = 1142ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + GCOMP] = 1143ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + BCOMP] = 1144ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + ACOMP] = src[0]; 1145ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 1146ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 1147ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1148ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul/********************************************************************** 1149ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * Functions for MESA_FORMAT_LUMINANCE_FLOAT32. 1150ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul */ 1151ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 1152ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulget_row_l_float32(struct gl_context *ctx, struct gl_renderbuffer *rb, 1153ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint count, GLint x, GLint y, void *values) 1154ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 1155ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLfloat *src = rb->GetPointer(ctx, rb, x, y); 1156ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLfloat *dst = values; 1157ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint i; 1158ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1159ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 1160ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + RCOMP] = 1161ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + GCOMP] = 1162ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + BCOMP] = src[i]; 1163ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + ACOMP] = 1.0; 1164ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 1165ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 1166ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1167ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 1168ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulget_values_l_float32(struct gl_context *ctx, struct gl_renderbuffer *rb, 1169ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint count, const GLint x[], const GLint y[], 1170ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul void *values) 1171ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 1172ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLfloat *dst = values; 1173ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint i; 1174ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1175ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 1176ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLfloat *src = rb->GetPointer(ctx, rb, x[i], y[i]); 1177ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + RCOMP] = 1178ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + GCOMP] = 1179ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + BCOMP] = src[0]; 1180ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + ACOMP] = 1.0; 1181ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 1182ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 1183ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1184ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul/********************************************************************** 1185ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * Functions for MESA_FORMAT_ALPHA_FLOAT32. 1186ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul */ 1187ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 1188ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulget_row_a_float32(struct gl_context *ctx, struct gl_renderbuffer *rb, 1189ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint count, GLint x, GLint y, void *values) 1190ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 1191ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLfloat *src = rb->GetPointer(ctx, rb, x, y); 1192ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLfloat *dst = values; 1193ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint i; 1194ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1195ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 1196ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + RCOMP] = 0.0; 1197ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + GCOMP] = 0.0; 1198ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + BCOMP] = 0.0; 1199ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + ACOMP] = src[i]; 1200ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 1201ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 1202ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1203ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 1204ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulget_values_a_float32(struct gl_context *ctx, struct gl_renderbuffer *rb, 1205ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint count, const GLint x[], const GLint y[], 1206ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul void *values) 1207ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 1208ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLfloat *dst = values; 1209ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint i; 1210ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1211ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 1212ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLfloat *src = rb->GetPointer(ctx, rb, x[i], y[i]); 1213ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + RCOMP] = 0.0; 1214ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + GCOMP] = 0.0; 1215ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + BCOMP] = 0.0; 1216ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + ACOMP] = src[0]; 1217ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 1218ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 1219ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1220ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 1221ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulput_row_a_float32(struct gl_context *ctx, struct gl_renderbuffer *rb, 1222ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint count, GLint x, GLint y, 1223ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const void *values, const GLubyte *mask) 1224ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 1225ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul float *dst = rb->GetPointer(ctx, rb, x, y); 1226ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const float *src = values; 1227ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul unsigned int i; 1228ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1229ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (mask) { 1230ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 1231ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (mask[i]) { 1232ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i] = src[i * 4 + ACOMP]; 1233ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 1234ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 1235ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 1236ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul else { 1237ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 1238ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i] = src[i * 4 + ACOMP]; 1239ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 1240ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 1241ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 1242ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1243ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 1244ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulput_mono_row_a_float32(struct gl_context *ctx, struct gl_renderbuffer *rb, 1245ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint count, GLint x, GLint y, 1246ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const void *value, const GLubyte *mask) 1247ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 1248ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul float *dst = rb->GetPointer(ctx, rb, x, y); 1249ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const float *src = value; 1250ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul unsigned int i; 1251ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1252ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (mask) { 1253ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 1254ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (mask[i]) { 1255ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i] = src[ACOMP]; 1256ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 1257ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 1258ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 1259ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul else { 1260ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 1261ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i] = src[ACOMP]; 1262ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 1263ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 1264ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 1265ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1266ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 1267ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulput_values_a_float32(struct gl_context *ctx, struct gl_renderbuffer *rb, 1268ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint count, const GLint x[], const GLint y[], 1269ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const void *values, const GLubyte *mask) 1270ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 1271ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const float *src = values; 1272ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul unsigned int i; 1273ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1274ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 1275ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (!mask || mask[i]) { 1276ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul float *dst = rb->GetPointer(ctx, rb, x[i], y[i]); 1277ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1278ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul *dst = src[i * 4 + ACOMP]; 1279ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 1280ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 1281ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 1282ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1283ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 1284ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulput_mono_values_a_float32(struct gl_context *ctx, 1285ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul struct gl_renderbuffer *rb, 1286ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint count, const GLint x[], const GLint y[], 1287ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const void *value, const GLubyte *mask) 1288ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 1289ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const float *src = value; 1290ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul unsigned int i; 1291ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1292ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 1293ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (!mask || mask[i]) { 1294ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul float *dst = rb->GetPointer(ctx, rb, x[i], y[i]); 1295ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul *dst = src[ACOMP]; 1296ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 1297ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 1298ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 1299ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1300ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul/********************************************************************** 1301ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * Functions for MESA_FORMAT_R_FLOAT32. 1302ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul */ 1303ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 1304ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulget_row_r_float32(struct gl_context *ctx, struct gl_renderbuffer *rb, 1305ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint count, GLint x, GLint y, void *values) 1306ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 1307ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLfloat *src = rb->GetPointer(ctx, rb, x, y); 1308ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLfloat *dst = values; 1309ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint i; 1310ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1311ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 1312ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + RCOMP] = src[i]; 1313ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + GCOMP] = 0.0; 1314ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + BCOMP] = 0.0; 1315ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + ACOMP] = 1.0; 1316ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 1317ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 1318ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1319ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 1320ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulget_values_r_float32(struct gl_context *ctx, struct gl_renderbuffer *rb, 1321ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint count, const GLint x[], const GLint y[], 1322ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul void *values) 1323ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 1324ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLfloat *dst = values; 1325ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint i; 1326ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1327ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 1328ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLfloat *src = rb->GetPointer(ctx, rb, x[i], y[i]); 1329ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + RCOMP] = src[0]; 1330ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + GCOMP] = 0.0; 1331ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + BCOMP] = 0.0; 1332ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + ACOMP] = 1.0; 1333ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 1334ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 1335ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1336ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul/********************************************************************** 1337ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * Functions for MESA_FORMAT_RG_FLOAT32. 1338ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul */ 1339ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 1340ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulget_row_rg_float32(struct gl_context *ctx, struct gl_renderbuffer *rb, 1341ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint count, GLint x, GLint y, void *values) 1342ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 1343ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLfloat *src = rb->GetPointer(ctx, rb, x, y); 1344ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLfloat *dst = values; 1345ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint i; 1346ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1347ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 1348ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + RCOMP] = src[i * 2 + 0]; 1349ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + GCOMP] = src[i * 2 + 1]; 1350ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + BCOMP] = 0.0; 1351ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + ACOMP] = 1.0; 1352ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 1353ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 1354ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1355ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic void 1356ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulget_values_rg_float32(struct gl_context *ctx, struct gl_renderbuffer *rb, 1357ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint count, const GLint x[], const GLint y[], 1358ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul void *values) 1359ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 1360ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLfloat *dst = values; 1361ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint i; 1362ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1363ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < count; i++) { 1364ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul const GLfloat *src = rb->GetPointer(ctx, rb, x[i], y[i]); 1365ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + RCOMP] = src[0]; 1366ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + GCOMP] = src[1]; 1367ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + BCOMP] = 0.0; 1368ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul dst[i * 4 + ACOMP] = 1.0; 1369ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 1370ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 1371ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1372ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul/** 1373ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * This is the default software fallback for gl_renderbuffer's span 1374ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * access functions. 1375ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * 1376ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * The assumptions are that rb->Data will be a pointer to (0,0), that pixels 1377ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * are packed in the type of rb->Format, and that subsequent rows appear 1378ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * rb->RowStride pixels later. 1379ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul */ 1380ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulvoid 1381379e0a3ada995b4cf57d142e0dd4618022e0aadcBrian Paul_swrast_set_renderbuffer_accessors(struct gl_renderbuffer *rb) 1382ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 1383ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->GetPointer = get_pointer_generic; 1384ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->GetRow = get_row_generic; 1385ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1386ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul switch (rb->Format) { 1387ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul case MESA_FORMAT_RGB888: 1388ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->DataType = GL_UNSIGNED_BYTE; 1389ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->GetPointer = get_pointer_ubyte3; 1390ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->GetRow = get_row_ubyte3; 1391ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->GetValues = get_values_ubyte3; 1392ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutRow = put_row_ubyte3; 1393ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutRowRGB = put_row_rgb_ubyte3; 1394ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutMonoRow = put_mono_row_ubyte3; 1395ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutValues = put_values_ubyte3; 1396ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutMonoValues = put_mono_values_ubyte3; 1397ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul break; 1398ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1399ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul case MESA_FORMAT_RGBA8888: 1400ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul case MESA_FORMAT_RGBA8888_REV: 1401ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->DataType = GL_UNSIGNED_BYTE; 1402ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->GetValues = get_values_ubyte4; 1403ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutRow = put_row_ubyte4; 1404ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutRowRGB = put_row_rgb_ubyte4; 1405ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutMonoRow = put_mono_row_ubyte4; 1406ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutValues = put_values_ubyte4; 1407ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutMonoValues = put_mono_values_ubyte4; 1408ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul break; 1409ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1410ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul case MESA_FORMAT_R8: 1411ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->DataType = GL_UNSIGNED_BYTE; 1412ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->GetValues = get_values_r8; 1413ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->GetRow = get_row_r8; 1414ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutRow = put_row_generic; 1415ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutRowRGB = put_row_generic; 1416ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutMonoRow = put_mono_row_generic; 1417ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutValues = put_values_generic; 1418ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutMonoValues = put_mono_values_generic; 1419ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul break; 1420ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1421ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul case MESA_FORMAT_GR88: 1422ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->DataType = GL_UNSIGNED_BYTE; 1423ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->GetValues = get_values_rg88; 1424ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->GetRow = get_row_rg88; 1425ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutRow = put_row_generic; 1426ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutRowRGB = put_row_generic; 1427ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutMonoRow = put_mono_row_generic; 1428ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutValues = put_values_generic; 1429ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutMonoValues = put_mono_values_generic; 1430ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul break; 1431ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1432ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul case MESA_FORMAT_R16: 1433ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->DataType = GL_UNSIGNED_SHORT; 1434ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->GetValues = get_values_r16; 1435ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->GetRow = get_row_r16; 1436ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutRow = put_row_generic; 1437ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutRowRGB = put_row_generic; 1438ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutMonoRow = put_mono_row_generic; 1439ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutValues = put_values_generic; 1440ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutMonoValues = put_mono_values_generic; 1441ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul break; 1442ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1443ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul case MESA_FORMAT_RG1616: 1444ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->DataType = GL_UNSIGNED_SHORT; 1445ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->GetValues = get_values_rg1616; 1446ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->GetRow = get_row_rg1616; 1447ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutRow = put_row_generic; 1448ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutRowRGB = put_row_generic; 1449ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutMonoRow = put_mono_row_generic; 1450ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutValues = put_values_generic; 1451ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutMonoValues = put_mono_values_generic; 1452ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul break; 1453ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1454ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul case MESA_FORMAT_SIGNED_RGBA_16: 1455ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->DataType = GL_SHORT; 1456ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->GetValues = get_values_ushort4; 1457ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutRow = put_row_ushort4; 1458ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutRowRGB = put_row_rgb_ushort4; 1459ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutMonoRow = put_mono_row_ushort4; 1460ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutValues = put_values_ushort4; 1461ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutMonoValues = put_mono_values_ushort4; 1462ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul break; 1463ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1464ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul case MESA_FORMAT_S8: 1465ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->DataType = GL_UNSIGNED_BYTE; 1466ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->GetValues = get_values_ubyte; 1467ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutRow = put_row_ubyte; 1468ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutRowRGB = NULL; 1469ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutMonoRow = put_mono_row_ubyte; 1470ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutValues = put_values_ubyte; 1471ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutMonoValues = put_mono_values_ubyte; 1472ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul break; 1473ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1474ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul case MESA_FORMAT_Z16: 1475ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->DataType = GL_UNSIGNED_SHORT; 1476ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->GetValues = get_values_ushort; 1477ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutRow = put_row_ushort; 1478ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutRowRGB = NULL; 1479ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutMonoRow = put_mono_row_ushort; 1480ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutValues = put_values_ushort; 1481ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutMonoValues = put_mono_values_ushort; 1482ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul break; 1483ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1484ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul case MESA_FORMAT_Z32: 1485ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul case MESA_FORMAT_X8_Z24: 1486ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul case MESA_FORMAT_Z24_X8: 1487ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->DataType = GL_UNSIGNED_INT; 1488ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->GetValues = get_values_uint; 1489ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutRow = put_row_uint; 1490ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutRowRGB = NULL; 1491ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutMonoRow = put_mono_row_uint; 1492ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutValues = put_values_uint; 1493ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutMonoValues = put_mono_values_uint; 1494ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul break; 1495ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1496ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul case MESA_FORMAT_Z24_S8: 1497ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul case MESA_FORMAT_S8_Z24: 1498ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->DataType = GL_UNSIGNED_INT_24_8_EXT; 1499ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->GetValues = get_values_uint; 1500ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutRow = put_row_uint; 1501ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutRowRGB = NULL; 1502ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutMonoRow = put_mono_row_uint; 1503ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutValues = put_values_uint; 1504ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutMonoValues = put_mono_values_uint; 1505ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul break; 1506ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1507ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul case MESA_FORMAT_RGBA_FLOAT32: 1508ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->GetRow = get_row_generic; 1509ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->GetValues = get_values_generic; 1510ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutRow = put_row_generic; 1511ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutRowRGB = NULL; 1512ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutMonoRow = put_mono_row_generic; 1513ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutValues = put_values_generic; 1514ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutMonoValues = put_mono_values_generic; 1515ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul break; 1516ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1517ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul case MESA_FORMAT_INTENSITY_FLOAT32: 1518ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->GetRow = get_row_i_float32; 1519ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->GetValues = get_values_i_float32; 1520ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutRow = put_row_generic; 1521ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutRowRGB = NULL; 1522ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutMonoRow = put_mono_row_generic; 1523ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutValues = put_values_generic; 1524ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutMonoValues = put_mono_values_generic; 1525ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul break; 1526ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1527ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul case MESA_FORMAT_LUMINANCE_FLOAT32: 1528ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->GetRow = get_row_l_float32; 1529ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->GetValues = get_values_l_float32; 1530ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutRow = put_row_generic; 1531ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutRowRGB = NULL; 1532ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutMonoRow = put_mono_row_generic; 1533ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutValues = put_values_generic; 1534ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutMonoValues = put_mono_values_generic; 1535ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul break; 1536ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1537ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul case MESA_FORMAT_ALPHA_FLOAT32: 1538ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->GetRow = get_row_a_float32; 1539ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->GetValues = get_values_a_float32; 1540ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutRow = put_row_a_float32; 1541ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutRowRGB = NULL; 1542ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutMonoRow = put_mono_row_a_float32; 1543ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutValues = put_values_a_float32; 1544ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutMonoValues = put_mono_values_a_float32; 1545ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul break; 1546ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1547ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul case MESA_FORMAT_RG_FLOAT32: 1548ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->GetRow = get_row_rg_float32; 1549ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->GetValues = get_values_rg_float32; 1550ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutRow = put_row_generic; 1551ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutRowRGB = NULL; 1552ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutMonoRow = put_mono_row_generic; 1553ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutValues = put_values_generic; 1554ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutMonoValues = put_mono_values_generic; 1555ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul break; 1556ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1557ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul case MESA_FORMAT_R_FLOAT32: 1558ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->GetRow = get_row_r_float32; 1559ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->GetValues = get_values_r_float32; 1560ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutRow = put_row_generic; 1561ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutRowRGB = NULL; 1562ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutMonoRow = put_mono_row_generic; 1563ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutValues = put_values_generic; 1564ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->PutMonoValues = put_mono_values_generic; 1565ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul break; 1566ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1567ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul default: 1568ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul break; 1569ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 1570ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 1571ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1572ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul/** 1573ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * This is a software fallback for the gl_renderbuffer->AllocStorage 1574ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * function. 1575ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * Device drivers will typically override this function for the buffers 1576ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * which it manages (typically color buffers, Z and stencil). 1577ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * Other buffers (like software accumulation and aux buffers) which the driver 1578ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * doesn't manage can be handled with this function. 1579ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * 1580ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * This one multi-purpose function can allocate stencil, depth, accum, color 1581ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * or color-index buffers! 1582ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * 1583ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * This function also plugs in the appropriate GetPointer, Get/PutRow and 1584ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * Get/PutValues functions. 1585ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul */ 1586ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic GLboolean 1587ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulsoft_renderbuffer_storage(struct gl_context *ctx, struct gl_renderbuffer *rb, 1588ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLenum internalFormat, 1589ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint width, GLuint height) 1590ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 1591ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul switch (internalFormat) { 1592ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul case GL_RGB: 1593ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul case GL_R3_G3_B2: 1594ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul case GL_RGB4: 1595ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul case GL_RGB5: 1596ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul case GL_RGB8: 1597ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul case GL_RGB10: 1598ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul case GL_RGB12: 1599ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul case GL_RGB16: 1600ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->Format = MESA_FORMAT_RGB888; 1601ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul break; 1602ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul case GL_RGBA: 1603ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul case GL_RGBA2: 1604ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul case GL_RGBA4: 1605ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul case GL_RGB5_A1: 1606ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul case GL_RGBA8: 1607ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul#if 1 1608ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul case GL_RGB10_A2: 1609ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul case GL_RGBA12: 1610ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul#endif 1611ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (_mesa_little_endian()) 1612ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->Format = MESA_FORMAT_RGBA8888_REV; 1613ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul else 1614ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->Format = MESA_FORMAT_RGBA8888; 1615ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul break; 1616ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul case GL_RGBA16: 1617ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul case GL_RGBA16_SNORM: 1618ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul /* for accum buffer */ 1619ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->Format = MESA_FORMAT_SIGNED_RGBA_16; 1620ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul break; 1621ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul case GL_STENCIL_INDEX: 1622ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul case GL_STENCIL_INDEX1_EXT: 1623ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul case GL_STENCIL_INDEX4_EXT: 1624ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul case GL_STENCIL_INDEX8_EXT: 1625ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul case GL_STENCIL_INDEX16_EXT: 1626ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->Format = MESA_FORMAT_S8; 1627ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul break; 1628ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul case GL_DEPTH_COMPONENT: 1629ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul case GL_DEPTH_COMPONENT16: 1630ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->Format = MESA_FORMAT_Z16; 1631ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul break; 1632ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul case GL_DEPTH_COMPONENT24: 1633ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->Format = MESA_FORMAT_X8_Z24; 1634ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul break; 1635ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul case GL_DEPTH_COMPONENT32: 1636ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->Format = MESA_FORMAT_Z32; 1637ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul break; 1638ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul case GL_DEPTH_STENCIL_EXT: 1639ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul case GL_DEPTH24_STENCIL8_EXT: 1640ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->Format = MESA_FORMAT_Z24_S8; 1641ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul break; 1642ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul default: 1643ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul /* unsupported format */ 1644ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul return GL_FALSE; 1645ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 1646ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1647379e0a3ada995b4cf57d142e0dd4618022e0aadcBrian Paul _swrast_set_renderbuffer_accessors(rb); 1648ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1649ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul ASSERT(rb->DataType); 1650ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul ASSERT(rb->GetPointer); 1651ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul ASSERT(rb->GetRow); 1652ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul ASSERT(rb->GetValues); 1653ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul ASSERT(rb->PutRow); 1654ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul ASSERT(rb->PutMonoRow); 1655ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul ASSERT(rb->PutValues); 1656ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul ASSERT(rb->PutMonoValues); 1657ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1658ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul /* free old buffer storage */ 1659ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (rb->Data) { 1660ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul free(rb->Data); 1661ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->Data = NULL; 1662ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 1663ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1664ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->RowStride = width; 1665ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1666ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (width > 0 && height > 0) { 1667ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul /* allocate new buffer storage */ 1668ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->Data = malloc(width * height * _mesa_get_format_bytes(rb->Format)); 1669ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1670ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (rb->Data == NULL) { 1671ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->Width = 0; 1672ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->Height = 0; 1673ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->RowStride = 0; 1674ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul _mesa_error(ctx, GL_OUT_OF_MEMORY, 1675ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul "software renderbuffer allocation (%d x %d x %d)", 1676ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul width, height, _mesa_get_format_bytes(rb->Format)); 1677ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul return GL_FALSE; 1678ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 1679ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 1680ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1681ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->Width = width; 1682ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->Height = height; 1683ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->_BaseFormat = _mesa_base_fbo_format(ctx, internalFormat); 1684ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1685ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (rb->Name == 0 && 1686ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul internalFormat == GL_RGBA16_SNORM && 1687ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->_BaseFormat == 0) { 1688ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul /* NOTE: This is a special case just for accumulation buffers. 1689ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * This is a very limited use case- there's no snorm texturing or 1690ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * rendering going on. 1691ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul */ 1692ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->_BaseFormat = GL_RGBA; 1693ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 1694ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul else { 1695ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul /* the internalFormat should have been error checked long ago */ 1696ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul ASSERT(rb->_BaseFormat); 1697ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 1698ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1699ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul return GL_TRUE; 1700ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 1701ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1702ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1703ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulvoid 1704379e0a3ada995b4cf57d142e0dd4618022e0aadcBrian Paul_swrast_map_soft_renderbuffer(struct gl_context *ctx, 1705379e0a3ada995b4cf57d142e0dd4618022e0aadcBrian Paul struct gl_renderbuffer *rb, 1706379e0a3ada995b4cf57d142e0dd4618022e0aadcBrian Paul GLuint x, GLuint y, GLuint w, GLuint h, 1707379e0a3ada995b4cf57d142e0dd4618022e0aadcBrian Paul GLbitfield mode, 1708379e0a3ada995b4cf57d142e0dd4618022e0aadcBrian Paul GLubyte **out_map, 1709379e0a3ada995b4cf57d142e0dd4618022e0aadcBrian Paul GLint *out_stride) 1710ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 1711ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLubyte *map = rb->Data; 1712ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul int cpp = _mesa_get_format_bytes(rb->Format); 1713ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul int stride = rb->RowStride * cpp; 1714ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1715ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul ASSERT(rb->Data); 1716ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1717ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul map += y * stride; 1718ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul map += x * cpp; 1719ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1720ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul *out_map = map; 1721ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul *out_stride = stride; 1722ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 1723ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1724ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1725ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulvoid 1726379e0a3ada995b4cf57d142e0dd4618022e0aadcBrian Paul_swrast_unmap_soft_renderbuffer(struct gl_context *ctx, 1727379e0a3ada995b4cf57d142e0dd4618022e0aadcBrian Paul struct gl_renderbuffer *rb) 1728ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 1729ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 1730ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1731ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1732ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1733ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul/** 1734ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * Allocate a software-based renderbuffer. This is called via the 1735ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * ctx->Driver.NewRenderbuffer() function when the user creates a new 1736ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * renderbuffer. 1737ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * This would not be used for hardware-based renderbuffers. 1738ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul */ 1739ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstruct gl_renderbuffer * 1740379e0a3ada995b4cf57d142e0dd4618022e0aadcBrian Paul_swrast_new_soft_renderbuffer(struct gl_context *ctx, GLuint name) 1741ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 1742ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul struct gl_renderbuffer *rb = _mesa_new_renderbuffer(ctx, name); 1743ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (rb) { 1744ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->AllocStorage = soft_renderbuffer_storage; 1745ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul /* Normally, one would setup the PutRow, GetRow, etc functions here. 1746ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * But we're doing that in the soft_renderbuffer_storage() function 1747ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * instead. 1748ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul */ 1749ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 1750ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul return rb; 1751ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 1752ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1753ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1754ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul/** 1755ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * Add software-based color renderbuffers to the given framebuffer. 1756ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * This is a helper routine for device drivers when creating a 1757ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * window system framebuffer (not a user-created render/framebuffer). 1758ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * Once this function is called, you can basically forget about this 1759ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * renderbuffer; core Mesa will handle all the buffer management and 1760ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * rendering! 1761ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul */ 1762ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic GLboolean 1763ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Pauladd_color_renderbuffers(struct gl_context *ctx, struct gl_framebuffer *fb, 1764ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint rgbBits, GLuint alphaBits, 1765ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLboolean frontLeft, GLboolean backLeft, 1766ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLboolean frontRight, GLboolean backRight) 1767ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 1768ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul gl_buffer_index b; 1769ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1770ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (rgbBits > 16 || alphaBits > 16) { 1771ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul _mesa_problem(ctx, 1772ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul "Unsupported bit depth in add_color_renderbuffers"); 1773ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul return GL_FALSE; 1774ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 1775ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1776ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul assert(MAX_COLOR_ATTACHMENTS >= 4); 1777ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1778ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (b = BUFFER_FRONT_LEFT; b <= BUFFER_BACK_RIGHT; b++) { 1779ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul struct gl_renderbuffer *rb; 1780ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1781ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (b == BUFFER_FRONT_LEFT && !frontLeft) 1782ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul continue; 1783ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul else if (b == BUFFER_BACK_LEFT && !backLeft) 1784ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul continue; 1785ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul else if (b == BUFFER_FRONT_RIGHT && !frontRight) 1786ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul continue; 1787ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul else if (b == BUFFER_BACK_RIGHT && !backRight) 1788ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul continue; 1789ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1790ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul assert(fb->Attachment[b].Renderbuffer == NULL); 1791ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1792ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb = _mesa_new_renderbuffer(ctx, 0); 1793ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (!rb) { 1794ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul _mesa_error(ctx, GL_OUT_OF_MEMORY, "Allocating color buffer"); 1795ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul return GL_FALSE; 1796ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 1797ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1798ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->InternalFormat = GL_RGBA; 1799ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1800ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->AllocStorage = soft_renderbuffer_storage; 1801ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul _mesa_add_renderbuffer(fb, b, rb); 1802ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 1803ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1804ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul return GL_TRUE; 1805ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 1806ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1807ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1808ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul/** 1809ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * Add a software-based depth renderbuffer to the given framebuffer. 1810ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * This is a helper routine for device drivers when creating a 1811ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * window system framebuffer (not a user-created render/framebuffer). 1812ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * Once this function is called, you can basically forget about this 1813ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * renderbuffer; core Mesa will handle all the buffer management and 1814ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * rendering! 1815ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul */ 1816ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic GLboolean 1817ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Pauladd_depth_renderbuffer(struct gl_context *ctx, struct gl_framebuffer *fb, 1818ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint depthBits) 1819ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 1820ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul struct gl_renderbuffer *rb; 1821ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1822ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (depthBits > 32) { 1823ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul _mesa_problem(ctx, 1824ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul "Unsupported depthBits in add_depth_renderbuffer"); 1825ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul return GL_FALSE; 1826ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 1827ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1828ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul assert(fb->Attachment[BUFFER_DEPTH].Renderbuffer == NULL); 1829ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1830ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb = _mesa_new_renderbuffer(ctx, 0); 1831ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (!rb) { 1832ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul _mesa_error(ctx, GL_OUT_OF_MEMORY, "Allocating depth buffer"); 1833ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul return GL_FALSE; 1834ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 1835ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1836ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (depthBits <= 16) { 1837ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->InternalFormat = GL_DEPTH_COMPONENT16; 1838ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 1839ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul else if (depthBits <= 24) { 1840ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->InternalFormat = GL_DEPTH_COMPONENT24; 1841ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 1842ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul else { 1843ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->InternalFormat = GL_DEPTH_COMPONENT32; 1844ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 1845ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1846ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->AllocStorage = soft_renderbuffer_storage; 1847ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul _mesa_add_renderbuffer(fb, BUFFER_DEPTH, rb); 1848ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1849ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul return GL_TRUE; 1850ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 1851ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1852ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1853ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul/** 1854ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * Add a software-based stencil renderbuffer to the given framebuffer. 1855ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * This is a helper routine for device drivers when creating a 1856ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * window system framebuffer (not a user-created render/framebuffer). 1857ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * Once this function is called, you can basically forget about this 1858ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * renderbuffer; core Mesa will handle all the buffer management and 1859ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * rendering! 1860ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul */ 1861ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic GLboolean 1862ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Pauladd_stencil_renderbuffer(struct gl_context *ctx, struct gl_framebuffer *fb, 1863ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint stencilBits) 1864ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 1865ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul struct gl_renderbuffer *rb; 1866ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1867ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (stencilBits > 16) { 1868ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul _mesa_problem(ctx, 1869ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul "Unsupported stencilBits in add_stencil_renderbuffer"); 1870ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul return GL_FALSE; 1871ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 1872ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1873ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul assert(fb->Attachment[BUFFER_STENCIL].Renderbuffer == NULL); 1874ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1875ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb = _mesa_new_renderbuffer(ctx, 0); 1876ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (!rb) { 1877ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul _mesa_error(ctx, GL_OUT_OF_MEMORY, "Allocating stencil buffer"); 1878ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul return GL_FALSE; 1879ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 1880ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1881ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul assert(stencilBits <= 8); 1882ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->InternalFormat = GL_STENCIL_INDEX8; 1883ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1884ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->AllocStorage = soft_renderbuffer_storage; 1885ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul _mesa_add_renderbuffer(fb, BUFFER_STENCIL, rb); 1886ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1887ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul return GL_TRUE; 1888ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 1889ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1890ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1891ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul/** 1892ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * Add a software-based accumulation renderbuffer to the given framebuffer. 1893ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * This is a helper routine for device drivers when creating a 1894ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * window system framebuffer (not a user-created render/framebuffer). 1895ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * Once this function is called, you can basically forget about this 1896ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * renderbuffer; core Mesa will handle all the buffer management and 1897ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * rendering! 1898ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul */ 1899ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic GLboolean 1900ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Pauladd_accum_renderbuffer(struct gl_context *ctx, struct gl_framebuffer *fb, 1901ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint redBits, GLuint greenBits, 1902ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint blueBits, GLuint alphaBits) 1903ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 1904ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul struct gl_renderbuffer *rb; 1905ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1906ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (redBits > 16 || greenBits > 16 || blueBits > 16 || alphaBits > 16) { 1907ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul _mesa_problem(ctx, 1908ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul "Unsupported accumBits in add_accum_renderbuffer"); 1909ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul return GL_FALSE; 1910ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 1911ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1912ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul assert(fb->Attachment[BUFFER_ACCUM].Renderbuffer == NULL); 1913ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1914ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb = _mesa_new_renderbuffer(ctx, 0); 1915ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (!rb) { 1916ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul _mesa_error(ctx, GL_OUT_OF_MEMORY, "Allocating accum buffer"); 1917ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul return GL_FALSE; 1918ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 1919ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1920ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->InternalFormat = GL_RGBA16_SNORM; 1921ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->AllocStorage = soft_renderbuffer_storage; 1922ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul _mesa_add_renderbuffer(fb, BUFFER_ACCUM, rb); 1923ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1924ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul return GL_TRUE; 1925ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 1926ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1927ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1928ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1929ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul/** 1930ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * Add a software-based aux renderbuffer to the given framebuffer. 1931ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * This is a helper routine for device drivers when creating a 1932ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * window system framebuffer (not a user-created render/framebuffer). 1933ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * Once this function is called, you can basically forget about this 1934ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * renderbuffer; core Mesa will handle all the buffer management and 1935ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * rendering! 1936ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * 1937ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * NOTE: color-index aux buffers not supported. 1938ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul */ 1939ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulstatic GLboolean 1940ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Pauladd_aux_renderbuffers(struct gl_context *ctx, struct gl_framebuffer *fb, 1941ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint colorBits, GLuint numBuffers) 1942ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 1943ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLuint i; 1944ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1945ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (colorBits > 16) { 1946ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul _mesa_problem(ctx, 1947ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul "Unsupported colorBits in add_aux_renderbuffers"); 1948ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul return GL_FALSE; 1949ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 1950ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1951ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul assert(numBuffers <= MAX_AUX_BUFFERS); 1952ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1953ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul for (i = 0; i < numBuffers; i++) { 1954ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul struct gl_renderbuffer *rb = _mesa_new_renderbuffer(ctx, 0); 1955ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1956ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul assert(fb->Attachment[BUFFER_AUX0 + i].Renderbuffer == NULL); 1957ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1958ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (!rb) { 1959ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul _mesa_error(ctx, GL_OUT_OF_MEMORY, "Allocating aux buffer"); 1960ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul return GL_FALSE; 1961ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 1962ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1963ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul assert (colorBits <= 8); 1964ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->InternalFormat = GL_RGBA; 1965ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1966ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul rb->AllocStorage = soft_renderbuffer_storage; 1967ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul _mesa_add_renderbuffer(fb, BUFFER_AUX0 + i, rb); 1968ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 1969ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul return GL_TRUE; 1970ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 1971ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1972ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1973ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul/** 1974ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * Create/attach software-based renderbuffers to the given framebuffer. 1975ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * This is a helper routine for device drivers. Drivers can just as well 1976ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul * call the individual _mesa_add_*_renderbuffer() routines directly. 1977ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul */ 1978ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paulvoid 1979379e0a3ada995b4cf57d142e0dd4618022e0aadcBrian Paul_swrast_add_soft_renderbuffers(struct gl_framebuffer *fb, 1980379e0a3ada995b4cf57d142e0dd4618022e0aadcBrian Paul GLboolean color, 1981379e0a3ada995b4cf57d142e0dd4618022e0aadcBrian Paul GLboolean depth, 1982379e0a3ada995b4cf57d142e0dd4618022e0aadcBrian Paul GLboolean stencil, 1983379e0a3ada995b4cf57d142e0dd4618022e0aadcBrian Paul GLboolean accum, 1984379e0a3ada995b4cf57d142e0dd4618022e0aadcBrian Paul GLboolean alpha, 1985379e0a3ada995b4cf57d142e0dd4618022e0aadcBrian Paul GLboolean aux) 1986ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul{ 1987ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLboolean frontLeft = GL_TRUE; 1988ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLboolean backLeft = fb->Visual.doubleBufferMode; 1989ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLboolean frontRight = fb->Visual.stereoMode; 1990ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul GLboolean backRight = fb->Visual.stereoMode && fb->Visual.doubleBufferMode; 1991ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 1992ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (color) { 1993ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul assert(fb->Visual.redBits == fb->Visual.greenBits); 1994ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul assert(fb->Visual.redBits == fb->Visual.blueBits); 1995ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul add_color_renderbuffers(NULL, fb, 1996ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul fb->Visual.redBits, 1997ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul fb->Visual.alphaBits, 1998ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul frontLeft, backLeft, 1999ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul frontRight, backRight); 2000ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 2001ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 2002ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (depth) { 2003ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul assert(fb->Visual.depthBits > 0); 2004ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul add_depth_renderbuffer(NULL, fb, fb->Visual.depthBits); 2005ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 2006ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 2007ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (stencil) { 2008ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul assert(fb->Visual.stencilBits > 0); 2009ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul add_stencil_renderbuffer(NULL, fb, fb->Visual.stencilBits); 2010ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 2011ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 2012ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (accum) { 2013ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul assert(fb->Visual.accumRedBits > 0); 2014ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul assert(fb->Visual.accumGreenBits > 0); 2015ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul assert(fb->Visual.accumBlueBits > 0); 2016ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul add_accum_renderbuffer(NULL, fb, 2017ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul fb->Visual.accumRedBits, 2018ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul fb->Visual.accumGreenBits, 2019ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul fb->Visual.accumBlueBits, 2020ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul fb->Visual.accumAlphaBits); 2021ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 2022ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 2023ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (aux) { 2024ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul assert(fb->Visual.numAuxBuffers > 0); 2025ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul add_aux_renderbuffers(NULL, fb, fb->Visual.redBits, 2026ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul fb->Visual.numAuxBuffers); 2027ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 2028ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul 2029ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul#if 0 2030ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul if (multisample) { 2031ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul /* maybe someday */ 2032ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul } 2033ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul#endif 2034ff8e6420fbbbd80c8fd7327f2f2b68e016b7f5c0Brian Paul} 2035