ShuriZma
/
dolphin
mirror of https://github.com/dolphin-emu/dolphin.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
dolphin/Source/Core/VideoBackends/Software/HwRasterizer.cpp

391 lines
11 KiB
C++
Raw Blame History

// Copyright 2013 Dolphin Emulator Project
// Licensed under GPLv2
// Refer to the license.txt file included.
#include "Common/CommonTypes.h"
#include "Common/MemoryUtil.h"
#include "VideoBackends/OGL/GLInterfaceBase.h"
#include "VideoBackends/Software/BPMemLoader.h"
#include "VideoBackends/Software/DebugUtil.h"
#include "VideoBackends/Software/HwRasterizer.h"
#include "VideoBackends/Software/NativeVertexFormat.h"
#include "VideoCommon/VideoCommon.h"
#define TEMP_SIZE (1024*1024*4)
namespace HwRasterizer
{
static float efbHalfWidth;
static float efbHalfHeight;
static bool hasTexture;
static u8 *temp;
// Programs
static GLuint colProg, texProg, clearProg;
// Texture type
static GLenum texType;
// Color
static GLint col_apos = -1, col_atex = -1;
// Tex
static GLint tex_apos = -1, tex_atex = -1, tex_utex = -1;
// Clear shader
static GLint clear_apos = -1, clear_ucol = -1;
static void CreateShaders()
{
// Color Vertices
static const char *fragcolText =
"#ifdef GL_ES\n"
"precision highp float;\n"
"#endif\n"
"varying vec4 TexCoordOut;\n"
"void main() {\n"
" gl_FragColor = TexCoordOut;\n"
"}\n";
// Texture Vertices
static const char *fragtexText =
"#ifdef GL_ES\n"
"precision highp float;\n"
"#define texture2DRect texture2D\n"
"#define sampler2DRect sampler2D\n"
"#endif\n"
"varying vec4 TexCoordOut;\n"
"uniform sampler2DRect Texture;\n"
"void main() {\n"
" gl_FragColor = texture2DRect(Texture, TexCoordOut.xy);\n"
"}\n";
// Clear shader
static const char *fragclearText =
"#ifdef GL_ES\n"
"precision highp float;\n"
"#endif\n"
"uniform vec4 Color;\n"
"void main() {\n"
" gl_FragColor = Color;\n"
"}\n";
// Generic passthrough vertice shaders
static const char *vertShaderText =
"attribute vec4 pos;\n"
"attribute vec4 TexCoordIn;\n "
"varying vec4 TexCoordOut;\n "
"void main() {\n"
" gl_Position = pos;\n"
" TexCoordOut = TexCoordIn;\n"
"}\n";
static const char *vertclearText =
"attribute vec4 pos;\n"
"void main() {\n"
" gl_Position = pos;\n"
"}\n";
// Color Program
colProg = OpenGL_CompileProgram(vertShaderText, fragcolText);
// Texture Program
texProg = OpenGL_CompileProgram(vertShaderText, fragtexText);
// Clear Program
clearProg = OpenGL_CompileProgram(vertclearText, fragclearText);
// Color attributes
col_apos = glGetAttribLocation(colProg, "pos");
col_atex = glGetAttribLocation(colProg, "TexCoordIn");
// Texture attributes
tex_apos = glGetAttribLocation(texProg, "pos");
tex_atex = glGetAttribLocation(texProg, "TexCoordIn");
tex_utex = glGetUniformLocation(texProg, "Texture");
// Clear attributes
clear_apos = glGetAttribLocation(clearProg, "pos");
clear_ucol = glGetUniformLocation(clearProg, "Color");
}
void Init()
{
efbHalfWidth = EFB_WIDTH / 2.0f;
efbHalfHeight = 480 / 2.0f;
temp = (u8*)AllocateMemoryPages(TEMP_SIZE);
}
void Shutdown()
{
glDeleteProgram(colProg);
glDeleteProgram(texProg);
glDeleteProgram(clearProg);
}
void Prepare()
{
//legacy multitexturing: select texture channel only.
glActiveTexture(GL_TEXTURE0);
glPixelStorei(GL_UNPACK_ALIGNMENT, 4); // 4-byte pixel alignment
if (GLInterface->GetMode() == GLInterfaceMode::MODE_OPENGL)
{
glShadeModel(GL_SMOOTH);
glDisable(GL_BLEND);
glClearDepth(1.0f);
glEnable(GL_SCISSOR_TEST);
glDisable(GL_LIGHTING);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glClientActiveTexture(GL_TEXTURE0);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
glEnable(GL_TEXTURE_RECTANGLE_ARB);
glStencilFunc(GL_ALWAYS, 0, 0);
glDisable(GL_STENCIL_TEST);
}
// used by hw rasterizer if it enables blending and depth test
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDepthFunc(GL_LEQUAL);
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
CreateShaders();
if (GLInterface->GetMode() == GLInterfaceMode::MODE_OPENGL)
texType = GL_TEXTURE_RECTANGLE;
else
texType = GL_TEXTURE_2D;
GL_REPORT_ERRORD();
}
static float width, height;
static void LoadTexture()
{
FourTexUnits &texUnit = bpmem.tex[0];
u32 imageAddr = texUnit.texImage3[0].image_base;
// Texture Rectangle uses pixel coordinates
// While GLES uses texture coordinates
if (GLInterface->GetMode() == GLInterfaceMode::MODE_OPENGL)
{
width = (float)texUnit.texImage0[0].width;
height = (float)texUnit.texImage0[0].height;
}
else
{
width = 1;
height = 1;
}
TexCacheEntry &cacheEntry = textures[imageAddr];
cacheEntry.Update();
glBindTexture(texType, cacheEntry.texture);
glTexParameteri(texType, GL_TEXTURE_MAG_FILTER, texUnit.texMode0[0].mag_filter ? GL_LINEAR : GL_NEAREST);
glTexParameteri(texType, GL_TEXTURE_MIN_FILTER, (texUnit.texMode0[0].min_filter >= 4) ? GL_LINEAR : GL_NEAREST);
GL_REPORT_ERRORD();
}
void BeginTriangles()
{
// disabling depth test sometimes allows more things to be visible
glEnable(GL_DEPTH_TEST);
glEnable(GL_BLEND);
hasTexture = bpmem.tevorders[0].enable0;
if (hasTexture)
LoadTexture();
}
void EndTriangles()
{
glBindTexture(texType, 0);
glDisable(GL_DEPTH_TEST);
glDisable(GL_BLEND);
}
static void DrawColorVertex(OutputVertexData *v0, OutputVertexData *v1, OutputVertexData *v2)
{
float x0 = (v0->screenPosition.x / efbHalfWidth) - 1.0f;
float y0 = 1.0f - (v0->screenPosition.y / efbHalfHeight);
float z0 = v0->screenPosition.z / (float)0x00ffffff;
float x1 = (v1->screenPosition.x / efbHalfWidth) - 1.0f;
float y1 = 1.0f - (v1->screenPosition.y / efbHalfHeight);
float z1 = v1->screenPosition.z / (float)0x00ffffff;
float x2 = (v2->screenPosition.x / efbHalfWidth) - 1.0f;
float y2 = 1.0f - (v2->screenPosition.y / efbHalfHeight);
float z2 = v2->screenPosition.z / (float)0x00ffffff;
float r0 = v0->color[0][OutputVertexData::RED_C] / 255.0f;
float g0 = v0->color[0][OutputVertexData::GRN_C] / 255.0f;
float b0 = v0->color[0][OutputVertexData::BLU_C] / 255.0f;
float r1 = v1->color[0][OutputVertexData::RED_C] / 255.0f;
float g1 = v1->color[0][OutputVertexData::GRN_C] / 255.0f;
float b1 = v1->color[0][OutputVertexData::BLU_C] / 255.0f;
float r2 = v2->color[0][OutputVertexData::RED_C] / 255.0f;
float g2 = v2->color[0][OutputVertexData::GRN_C] / 255.0f;
float b2 = v2->color[0][OutputVertexData::BLU_C] / 255.0f;
static const GLfloat verts[3][3] = {
{ x0, y0, z0 },
{ x1, y1, z1 },
{ x2, y2, z2 }
};
static const GLfloat col[3][4] = {
{ r0, g0, b0, 1.0f },
{ r1, g1, b1, 1.0f },
{ r2, g2, b2, 1.0f }
};
{
glUseProgram(colProg);
glEnableVertexAttribArray(col_apos);
glEnableVertexAttribArray(col_atex);
glVertexAttribPointer(col_apos, 3, GL_FLOAT, GL_FALSE, 0, verts);
glVertexAttribPointer(col_atex, 4, GL_FLOAT, GL_FALSE, 0, col);
glDrawArrays(GL_TRIANGLES, 0, 3);
glDisableVertexAttribArray(col_atex);
glDisableVertexAttribArray(col_apos);
}
GL_REPORT_ERRORD();
}
static void DrawTextureVertex(OutputVertexData *v0, OutputVertexData *v1, OutputVertexData *v2)
{
float x0 = (v0->screenPosition.x / efbHalfWidth) - 1.0f;
float y0 = 1.0f - (v0->screenPosition.y / efbHalfHeight);
float z0 = v0->screenPosition.z;
float x1 = (v1->screenPosition.x / efbHalfWidth) - 1.0f;
float y1 = 1.0f - (v1->screenPosition.y / efbHalfHeight);
float z1 = v1->screenPosition.z;
float x2 = (v2->screenPosition.x / efbHalfWidth) - 1.0f;
float y2 = 1.0f - (v2->screenPosition.y / efbHalfHeight);
float z2 = v2->screenPosition.z;
float s0 = v0->texCoords[0].x / width;
float t0 = v0->texCoords[0].y / height;
float s1 = v1->texCoords[0].x / width;
float t1 = v1->texCoords[0].y / height;
float s2 = v2->texCoords[0].x / width;
float t2 = v2->texCoords[0].y / height;
static const GLfloat verts[3][3] = {
{ x0, y0, z0 },
{ x1, y1, z1 },
{ x2, y2, z2 }
};
static const GLfloat tex[3][2] = {
{ s0, t0 },
{ s1, t1 },
{ s2, t2 }
};
{
glUseProgram(texProg);
glEnableVertexAttribArray(tex_apos);
glEnableVertexAttribArray(tex_atex);
glVertexAttribPointer(tex_apos, 3, GL_FLOAT, GL_FALSE, 0, verts);
glVertexAttribPointer(tex_atex, 2, GL_FLOAT, GL_FALSE, 0, tex);
glUniform1i(tex_utex, 0);
glDrawArrays(GL_TRIANGLES, 0, 3);
glDisableVertexAttribArray(tex_atex);
glDisableVertexAttribArray(tex_apos);
}
GL_REPORT_ERRORD();
}
void DrawTriangleFrontFace(OutputVertexData *v0, OutputVertexData *v1, OutputVertexData *v2)
{
if (hasTexture)
DrawTextureVertex(v0, v1, v2);
else
DrawColorVertex(v0, v1, v2);
}
void Clear()
{
u8 r = (bpmem.clearcolorAR & 0x00ff);
u8 g = (bpmem.clearcolorGB & 0xff00) >> 8;
u8 b = (bpmem.clearcolorGB & 0x00ff);
u8 a = (bpmem.clearcolorAR & 0xff00) >> 8;
GLfloat left = (GLfloat)bpmem.copyTexSrcXY.x / efbHalfWidth - 1.0f;
GLfloat top = 1.0f - (GLfloat)bpmem.copyTexSrcXY.y / efbHalfHeight;
GLfloat right = (GLfloat)(left + bpmem.copyTexSrcWH.x + 1) / efbHalfWidth - 1.0f;
GLfloat bottom = 1.0f - (GLfloat)(top + bpmem.copyTexSrcWH.y + 1) / efbHalfHeight;
GLfloat depth = (GLfloat)bpmem.clearZValue / (GLfloat)0x00ffffff;
static const GLfloat verts[4][3] = {
{ left, top, depth },
{ right, top, depth },
{ right, bottom, depth },
{ left, bottom, depth }
};
{
glUseProgram(clearProg);
glVertexAttribPointer(clear_apos, 3, GL_FLOAT, GL_FALSE, 0, verts);
glUniform4f(clear_ucol, r, g, b, a);
glEnableVertexAttribArray(col_apos);
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
glDisableVertexAttribArray(col_apos);
}
GL_REPORT_ERRORD();
}
TexCacheEntry::TexCacheEntry()
{
Create();
}
void TexCacheEntry::Create()
{
FourTexUnits &texUnit = bpmem.tex[0];
texImage0.hex = texUnit.texImage0[0].hex;
texImage1.hex = texUnit.texImage1[0].hex;
texImage2.hex = texUnit.texImage2[0].hex;
texImage3.hex = texUnit.texImage3[0].hex;
texTlut.hex = texUnit.texTlut[0].hex;
int image_width = texImage0.width;
int image_height = texImage0.height;
DebugUtil::GetTextureRGBA(temp, 0, 0, image_width, image_height);
glGenTextures(1, (GLuint *)&texture);
glBindTexture(texType, texture);
glTexImage2D(texType, 0, GL_RGBA, (GLsizei)image_width, (GLsizei)image_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, temp);
GL_REPORT_ERRORD();
}
void TexCacheEntry::Destroy()
{
if (texture == 0)
return;
glDeleteTextures(1, &texture);
texture = 0;
}
void TexCacheEntry::Update()
{
FourTexUnits &texUnit = bpmem.tex[0];
// extra checks cause textures to be reloaded much more
if (texUnit.texImage0[0].hex != texImage0.hex ||
// texUnit.texImage1[0].hex != texImage1.hex ||
// texUnit.texImage2[0].hex != texImage2.hex ||
texUnit.texImage3[0].hex != texImage3.hex ||
texUnit.texTlut[0].hex != texTlut.hex)
{
Destroy();
Create();
}
}
}
Reference in New Issue View Git Blame Copy Permalink