void GLColorTarget::GenerateFramebuffer(
const uint& Width,
const uint& Height,
const uint& ProgramID)
{
m_Width = Width;
m_Height = Height;
m_Shader = ProgramID;
//- Generate Frame buffer --------------------------------------------------
glGenFramebuffers(1, &m_FrameBuffer); GLERROR();
glBindFramebuffer(GL_FRAMEBUFFER, m_FrameBuffer); GLERROR();
//- Generate RenderBuffer -------------------------------------------------
glGenRenderbuffers(1, &m_DepthBuffer); GLERROR();
glBindRenderbuffer(GL_RENDERBUFFER, m_DepthBuffer); GLERROR();
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT24, Width, Height); GLERROR();
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_DepthBuffer); GLERROR();
if(glCheckFramebufferStatus(GL_DRAW_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
LogError("Framebuffer error at %s,%d", __FILE__, __LINE__);
Destroy();
}
}
uint GLColorTarget::GenerateDepthTexture()
{
//- Generate Frame buffer --------------------------------------------------
glGenFramebuffers(1, &m_DepthFrameBuffer); GLERROR();
glBindFramebuffer(GL_FRAMEBUFFER, m_DepthFrameBuffer); GLERROR();
glGenTextures(1, &m_DepthTexture); GLERROR();
glBindTexture(GL_TEXTURE_2D, m_DepthTexture); GLERROR();
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT16,
DEPTHTEXRES, DEPTHTEXRES, 0, GL_DEPTH_COMPONENT, GL_FLOAT, 0); GLERROR();
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); GLERROR();
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); GLERROR();
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); GLERROR();
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); GLERROR();
glFramebufferTexture(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, m_DepthTexture, 0); GLERROR();
if(glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
LogError("Framebuffer error at %s,%d", __FILE__, __LINE__);
DeleteBuffers(1, &m_DepthTexture);
DeleteBuffers(1, &m_DepthBuffer);
return 0;
}
glDrawBuffer(GL_NONE);
return m_DepthTexture;
}
void GLColorTarget::SetupRendersurface()
{
//- Setup Rendersurface ---------------------------------------------------
float vertices[] = { -1.0f, -1.0f, 0.0f,
1.0f, -1.0f, 0.0f,
1.0f, 1.0f, 0.0f,
-1.0f, 1.0f, 0.0f };
float texcoords[] = { 0.0f, 0.0f,
1.0f, 0.0f,
1.0f, 1.0f,
0.0f, 1.0f };
ushort faces[] = { 0, 1, 2, 2, 3, 0 };
glGenBuffers(1, &m_Vertex); GLERROR();
glBindBuffer(GL_ARRAY_BUFFER, m_Vertex); GLERROR();
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); GLERROR();
glGenBuffers(1, &m_Texcoords); GLERROR();
glBindBuffer(GL_ARRAY_BUFFER, m_Texcoords); GLERROR();
glBufferData(GL_ARRAY_BUFFER, sizeof(texcoords), texcoords, GL_STATIC_DRAW); GLERROR();
glGenBuffers(1, &m_Indices); GLERROR();
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_Indices); GLERROR();
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(faces), faces, GL_STATIC_DRAW); GLERROR();
}
void PickingPass::ClearPicking()
{
GLERROR("PRE");
m_PickingColorsToEntity.clear();
m_EntityColors.clear();
m_ColorCounter[0] = 0;
m_ColorCounter[1] = 1;
m_PickingBuffer.Bind();
glClearColor(0.f, 0.f, 0.f, 0.f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
m_PickingBuffer.Unbind();
GLERROR("END");
}
dd::Texture::Texture(std::string path)
{
std::unique_ptr<Image> image = std::make_unique<PNG>(path);
if (image->Width == 0 && image->Height == 0 || image->Format == Image::ImageFormat::Unknown) {
image = std::make_unique<PNG>("Textures/ErrorTexture.png");
if (image->Width == 0 && image->Height == 0 || image->Format == Image::ImageFormat::Unknown) {
LOG_ERROR("Couldn't even load the error texture. This is a dark day indeed.");
return;
}
}
GLint format;
switch (image->Format) {
case Image::ImageFormat::RGB:
format = GL_RGB;
break;
case Image::ImageFormat::RGBA:
format = GL_RGBA;
break;
}
// Construct the OpenGL texture
glGenTextures(1, &m_Texture);
glBindTexture(GL_TEXTURE_2D, m_Texture);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glTexImage2D(GL_TEXTURE_2D, 0, format, image->Width, image->Height, 0, format, GL_UNSIGNED_BYTE, image->Data);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
GLERROR("Texture load");
}
void glBlendEquation (GLenum equation)
{
int e;
switch (equation) {
case GL_FUNC_SUBTRACT:
e = GE_SUBTRACT;
break;
case GL_FUNC_REVERSE_SUBTRACT:
e = GE_REVERSE_SUBTRACT;
break;
case GL_MIN:
e = GE_MIN;
break;
case GL_MAX:
e = GE_MAX;
break;
case GL_FUNC_ADD:
e = GE_ADD;
break;
default:
GLERROR(GL_INVALID_ENUM);
return;
}
__pspgl_context_writereg_masked(pspgl_curctx, CMD_BLEND_FUNC, (e << 8), 0xf00);
}
void glGetStatisticsuivPSP(GLenum stats, GLuint *ret)
{
switch(stats) {
case GL_STATS_FRAMETIME_PSP:
ret[0] = __pspgl_ticks_to_us(pspgl_curctx->draw->flip_end -
pspgl_curctx->draw->prev_end);
return;
case GL_STATS_APPTIME_PSP:
ret[0] = __pspgl_ticks_to_us(pspgl_curctx->draw->flip_start -
pspgl_curctx->draw->prev_end);
break;
case GL_STATS_SWAPTIME_PSP:
ret[0] = __pspgl_ticks_to_us(pspgl_curctx->draw->flip_end -
pspgl_curctx->draw->flip_start);
break;
case GL_STATS_CMDISSUES_PSP:
ret[0] = pspgl_curctx->stats.buffer_issues;
break;
case GL_STATS_QUEUEWAITTIME_PSP:
ret[0] = __pspgl_ticks_to_us(pspgl_curctx->stats.queuewait);
break;
default:
GLERROR(GL_INVALID_ENUM);
}
}
void glMaterialfv (GLenum face, GLenum pname, const GLfloat *params)
{
switch (pname) {
case GL_AMBIENT:
pspgl_curctx->material.ambient = COLOR4(params);
/* material ambient is overloaded by glColor() */
if (getReg(CMD_ENA_LIGHTING) & 0xff) {
sendCommandi(CMD_MATERIAL_AMB_C, pspgl_curctx->material.ambient);
sendCommandi(CMD_MATERIAL_AMB_A, pspgl_curctx->material.ambient >> 24);
}
break;
case GL_EMISSION:
sendCommandi(CMD_MATERIAL_EMS_C, COLOR3(params));
break;
case GL_DIFFUSE:
sendCommandi(CMD_MATERIAL_DIF_C, COLOR3(params));
break;
case GL_AMBIENT_AND_DIFFUSE:
glMaterialfv(face, GL_AMBIENT, params);
glMaterialfv(face, GL_DIFFUSE, params);
break;
case GL_SPECULAR:
sendCommandi(CMD_MATERIAL_SPC_C, COLOR3(params));
break;
case GL_SHININESS:
sendCommandf(CMD_MATERIAL_SPEC_POW, params[0]);
break;
default:
GLERROR(GL_INVALID_ENUM);
return;
}
GLuint glGenLists(GLsizei range)
{
struct hashtable *hash = &pspgl_curctx->shared->display_lists;
GLuint id, start, i;
if (range < 0)
GLERROR(GL_INVALID_VALUE);
if (range <= 0)
return 0;
start = id = __pspgl_hash_uniquekey(hash);
again:
for(i = 0; i < range; i++) {
if (id < start && id+range >= start) {
/* no space in the ID range */
id = 0;
break;
}
if (__pspgl_hash_lookup(hash, id+i) != NULL) {
id = id+i+1;
goto again;
}
}
for(i = 0; i < range; i++)
__pspgl_hash_insert(hash, id+i, "foo");
return id;
}
static
int map_sfunc (GLenum opcode)
{
int ret;
switch (opcode) {
case GL_ZERO:
ret = GU_ZERO;
break;
case GL_INVERT:
ret = GU_INVERT;
break;
case GL_KEEP:
ret = GU_KEEP;
break;
case GL_REPLACE:
ret = GU_REPLACE;
break;
case GL_INCR:
ret = GU_INCR;
break;
case GL_DECR:
ret = GU_DECR;
break;
default:
GLERROR(GL_INVALID_ENUM);
ret = 0;
}
return ret;
}
void glEnd (void)
{
struct pspgl_context *c = pspgl_curctx;
if (likely(c->beginend.vertex_count > 0)) {
long prim = __pspgl_glprim2geprim(c->beginend.primitive);
if (unlikely(prim < 0))
goto out_error;
/* If we've finished a line loop, connect the last
edge to the first vertex to close the loop. */
if (c->beginend.primitive == GL_LINE_LOOP) {
struct t2f_c4ub_n3f_v3f *vbuf = (struct t2f_c4ub_n3f_v3f *) c->beginend.vbuf_adr;
vbuf += c->beginend.vertex_count;
memcpy(vbuf, &c->beginend.line_loop_start, sizeof(*vbuf));
c->beginend.vertex_count++;
}
__pspgl_context_render_prim(pspgl_curctx, prim, c->beginend.vertex_count,
GE_TEXTURE_32BITF | GE_COLOR_8888 | GE_NORMAL_32BITF | GE_VERTEX_32BITF,
c->beginend.vbuf_adr, NULL);
}
pspgl_curctx->beginend.primitive = -1;
return;
out_error:
GLERROR(GL_INVALID_ENUM);
}
void glGetBufferSubDataARB(GLenum target, GLintptrARB offset,
GLsizeiptrARB size, GLvoid *data)
{
struct pspgl_bufferobj *buf, **bufp;
void *p;
GLenum error;
bufp = __pspgl_bufferobj_for_target(target);
if (bufp == NULL)
return;
buf = *bufp;
error = GL_INVALID_OPERATION;
if (buf == NULL || buf->data == NULL || buf->mapped)
goto out_error;
error = GL_INVALID_VALUE;
if (size < 0 || offset+size > buf->data->size)
goto out_error;
p = __pspgl_buffer_map(buf->data, GL_READ_ONLY);
memcpy(data, p+offset, size);
__pspgl_buffer_unmap(buf->data, GL_READ_ONLY);
return;
out_error:
GLERROR(error);
}
void glPushMatrix (void)
{
struct pspgl_context *c = pspgl_curctx;
struct pspgl_matrix_stack *curstk = c->current_matrix_stack;
unsigned flags;
assert(curstk->flags & MF_VFPU);
/* Make sure VFPU state is written back to memory */
__pspgl_matrix_sync(c, curstk);
if (unlikely(++curstk->depth == curstk->limit))
goto out_error;
/* No need to copy matrix values, since it's already in the
VFPU. Do need to copy the flags though. */
flags = c->current_matrix->flags;
c->current_matrix = &curstk->stack[curstk->depth];
c->current_matrix->flags = flags;
return;
out_error:
curstk->depth--;
GLERROR(GL_STACK_OVERFLOW);
}
GLuint dd::ShaderProgram::Link()
{
if (m_Shaders.size() == 0)
{
LOG_ERROR("Failed to link shader program: No shaders bound");
return 0;
}
if (m_ShaderProgramHandle == 0)
{
m_ShaderProgramHandle = glCreateProgram();
}
LOG_INFO("Linking shader program");
for (auto &shader : m_Shaders)
{
glAttachShader(m_ShaderProgramHandle, shader->GetHandle());
}
glLinkProgram(m_ShaderProgramHandle);
if (GLERROR("glLinkProgram"))
return 0;
return m_ShaderProgramHandle;
}
void glGenTextures (GLsizei n, GLuint *textures)
{
struct hashtable *hash = &pspgl_curctx->shared->texture_objects;
GLsizei i;
GLenum error;
error = GL_INVALID_VALUE;
if (unlikely(n < 0))
goto out_error;
for(i = 0; i < n; i++) {
unsigned id;
struct pspgl_texobj *tobj;
id = __pspgl_hash_uniquekey(hash);
tobj = __pspgl_texobj_new(id, 0);
error = GL_OUT_OF_MEMORY;
if (tobj == NULL)
goto out_error;
__pspgl_hash_insert(hash, id, tobj);
textures[i] = id;
}
return;
out_error:
GLERROR(error);
}
void glPopClientAttrib(void)
{
struct pspgl_context *c = pspgl_curctx;
struct pspgl_saved_clattrib *a;
unsigned mask;
if (c->clattribstackdepth == 0)
goto out_error;
a = c->clattribstack[--c->clattribstackdepth];
mask = a->attrmask;
if (mask & GL_CLIENT_VERTEX_ARRAY_BIT) {
struct varray *va = &c->vertex_array;
if (va->vertex.buffer)
__pspgl_bufferobj_free(va->vertex.buffer);
if (va->normal.buffer)
__pspgl_bufferobj_free(va->normal.buffer);
if (va->color.buffer)
__pspgl_bufferobj_free(va->color.buffer);
if (va->texcoord.buffer)
__pspgl_bufferobj_free(va->texcoord.buffer);
if (va->weight.buffer)
__pspgl_bufferobj_free(va->weight.buffer);
if (va->arraybuffer)
__pspgl_bufferobj_free(va->arraybuffer);
if (va->indexbuffer)
__pspgl_bufferobj_free(va->indexbuffer);
if (va->locked.cached_array)
__pspgl_buffer_free(va->locked.cached_array);
*va = a->varray;
}
if (mask & GL_CLIENT_PIXEL_STORE_BIT) {
if (c->pack.pbo)
__pspgl_bufferobj_free(c->pack.pbo);
c->pack = a->pack;
if (c->unpack.pbo)
__pspgl_bufferobj_free(c->unpack.pbo);
c->unpack = a->unpack;
}
free(a);
return;
out_error:
GLERROR(GL_STACK_UNDERFLOW);
}
uint GLColorTarget::GenerateColorTexture()
{
//- Generate Texture ------------------------------------------------------
const uint& nt = m_NrTextures;
uint tBuffer = 0;
glBindFramebuffer(GL_FRAMEBUFFER, m_FrameBuffer); GLERROR();
glBindRenderbuffer(GL_RENDERBUFFER, m_DepthBuffer); GLERROR();
glGenTextures(1, &tBuffer); GLERROR();
glBindTexture(GL_TEXTURE_2D, tBuffer); GLERROR();
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); GLERROR();
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); GLERROR();
glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE); GLERROR();
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, m_Width, m_Height, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL); GLERROR();
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0+nt, GL_TEXTURE_2D, tBuffer, 0); GLERROR();
// Store consecutive textures
m_Texture[m_NrTextures++] = tBuffer;
if(glCheckFramebufferStatus(GL_DRAW_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
LogError("Framebuffer error at %s,%d", __FILE__, __LINE__);
Destroy();
return 0;
}
SetColorBuffers();
return tBuffer;
}
dd::Shader::Shader(GLenum shaderType, std::string resourceName)
: m_ShaderType(shaderType)
, m_FileName(resourceName)
{
m_ShaderHandle = glCreateShader(shaderType);
if (GLERROR("glCreateShader"))
return;
Compile();
}
/*
=================
gl_texture_delete
=================
*/
void gl_texture_delete (int gltex)
{
GLuint tex = gltex;
if (gltex)
{
glDeleteTextures(1, &tex);
GLERROR();
}
}
void glDisableStatsPSP(GLenum stats)
{
switch(stats) {
case GL_STATS_TIMING_PSP:
pspgl_curctx->stats.enabled = GL_FALSE;
break;
default:
GLERROR(GL_INVALID_ENUM);
}
}
void glShadeModel (GLenum mode)
{
switch (mode) {
case GL_FLAT:
case GL_SMOOTH:
sendCommandi(CMD_SHADEMODEL, (mode & 1));
break;
default:
GLERROR(GL_INVALID_ENUM);
}
}
void dd::Shader::Compile()
{
LOG_INFO("Compiling shader \"%s\"", m_FileName.c_str());
std::string shaderFile;
std::ifstream in(m_FileName, std::ios::in);
if (!in)
{
LOG_ERROR("Error: Failed to open shader file \"%s\"", m_FileName.c_str());
return;
}
in.seekg(0, std::ios::end);
shaderFile.resize((int)in.tellg());
in.seekg(0, std::ios::beg);
in.read(&shaderFile[0], shaderFile.size());
in.close();
const GLchar* shaderFileC = shaderFile.c_str();
const GLint length = shaderFile.length();
glShaderSource(m_ShaderHandle, 1, &shaderFileC, &length);
if(GLERROR("glShaderSource"))
return;
glCompileShader(m_ShaderHandle);
GLint compileStatus;
glGetShaderiv(m_ShaderHandle, GL_COMPILE_STATUS, &compileStatus);
if(compileStatus != GL_TRUE)
{
LOG_ERROR("Shader compilation failed");
GLsizei infoLogLength;
glGetShaderiv(m_ShaderHandle, GL_INFO_LOG_LENGTH, &infoLogLength);
GLchar* infolog = new GLchar[infoLogLength];
glGetShaderInfoLog(m_ShaderHandle, infoLogLength, &infoLogLength, infolog);
LOG_ERROR(infolog);
delete[] infolog;
}
if(GLERROR("glCompileShader"))
return;
}
void glResetStatsPSP(GLenum stats)
{
switch(stats) {
case GL_STATS_CMDISSUES_PSP:
pspgl_curctx->stats.buffer_issues = 0;
case GL_STATS_QUEUEWAITTIME_PSP:
pspgl_curctx->stats.queuewait = 0;
break;
default:
GLERROR(GL_INVALID_ENUM);
}
}
void DrawBloomPass::ClearBuffer()
{
if (m_Quality == 0) {
return;
}
GLERROR("PRE");
for (int i = 0; i < m_BloomLod; i++) {
m_GaussianFrameBuffer_horiz[i].Bind();
glClearColor(0.f, 0.f, 0.f, 0.f);
glClear(GL_COLOR_BUFFER_BIT);
m_GaussianFrameBuffer_horiz[i].Unbind();
m_GaussianFrameBuffer_vert[i].Bind();
glClearColor(0.f, 0.f, 0.f, 0.f);
glClear(GL_COLOR_BUFFER_BIT);
m_GaussianFrameBuffer_vert[i].Unbind();
}
m_GaussianCombineBuffer.Bind();
glClearColor(0.f, 0.f, 0.f, 0.f);
glClear(GL_COLOR_BUFFER_BIT);
m_GaussianCombineBuffer.Unbind();
GLERROR("END");
}
void glStencilFunc( GLenum func, GLint ref, GLuint mask)
{
unsigned char sref = (unsigned char) ref;
if (unlikely(func < GL_NEVER) || unlikely(func > GL_ALWAYS))
goto out_error;
func &= 0x0007;
sendCommandi(CMD_STENCIL_FUNC, (mask << 16) | (sref << 8) | stenciltestfunc_mapping[func]);
return;
out_error:
GLERROR(GL_INVALID_ENUM);
}
static
void update_texfilter (struct pspgl_context *c, int shift, GLenum param)
{
switch (param) {
case GL_NEAREST:
case GL_LINEAR:
case GL_NEAREST_MIPMAP_NEAREST:
case GL_LINEAR_MIPMAP_NEAREST:
case GL_NEAREST_MIPMAP_LINEAR:
case GL_LINEAR_MIPMAP_LINEAR:
__pspgl_context_writereg_masked(c, CMD_TEXFILT, filter_gl2ge(param) << shift, 0xff << shift);
break;
default:
GLERROR(GL_INVALID_ENUM);
}
}
void glLightModelfv (GLenum pname, const GLfloat *params)
{
switch (pname) {
case GL_LIGHT_MODEL_AMBIENT:
sendCommandi(CMD_AMBIENT_COLOR, COLOR3(params));
sendCommandi(CMD_AMBIENT_ALPHA, (int) (255.0 * CLAMPF(params[3])));
break;
case GL_LIGHT_MODEL_COLOR_CONTROL:
sendCommandi(CMD_LIGHTMODEL,
(params[0] == GL_SEPARATE_SPECULAR_COLOR) ? 1 : 0);
break;
default:
GLERROR(GL_INVALID_ENUM);
return;
}
}
void glCullFace (GLenum mode)
{
switch (mode) {
case GL_BACK:
case GL_FRONT:
pspgl_curctx->polygon.cull_front = (mode == GL_FRONT);
/* Because the PSP uses a right-handed screen coord system,
the cull face direction is reversed with respect to the
normal sense of CMD_CULL_FACE. */
sendCommandi(CMD_CULL_FACE, (pspgl_curctx->polygon.front_cw ^ pspgl_curctx->polygon.cull_front));
break;
case GL_FRONT_AND_BACK:
default:
GLERROR(GL_INVALID_ENUM);
}
}
std::string GLError::GetErrorString(GLenum error) {
#define GLERROR(e) case e : return std::string(#e)
switch (error) {
GLERROR(GL_NO_ERROR);
GLERROR(GL_INVALID_ENUM);
GLERROR(GL_INVALID_VALUE);
GLERROR(GL_INVALID_OPERATION);
GLERROR(GL_INVALID_FRAMEBUFFER_OPERATION);
GLERROR(GL_OUT_OF_MEMORY);
default: return std::string("GL_UNKNOWN_ERROR");
}
#undef GLERROR
}
void *__pspgl_buffer_map(struct pspgl_buffer *data, GLenum access)
{
void *p = data->base;
assert(data->mapped >= 0);
switch(access) {
case GL_READ_WRITE_ARB:
/* FALLTHROUGH */
case GL_READ_ONLY_ARB:
/* Need to invalidate if written by hardware, but only the first time */
if (!data->mapped)
sceKernelDcacheInvalidateRange(data->base, data->size);
break;
case GL_WRITE_ONLY_ARB:
/* Write-only streams are uncached to prevent cache
pollution. If data->mapped != 0, this should be a
no-op. */
p = __pspgl_uncached(p, data->size);
break;
default:
GLERROR(GL_INVALID_ENUM);
return NULL;
}
/* Buffers at the head are first to be moved into system
memory. Mapping means we want it in system memory if
possible, so make it more likely. XXX This is an overly
simplistic policy, and there's no corresponding mechanism
to move things into vidmem yet. */
if (!list_pin) {
buffer_remove(data);
buffer_insert_head(data);
}
data->mapped++;
return p;
}
