static int
DisplaySuperquadrics(superquadricsstruct * sp)
{
int polys = 0;
glDrawBuffer(GL_BACK);
if (sp->wireframe)
glClear(GL_COLOR_BUFFER_BIT);
else
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
if (sp->viewcount < 1) {
sp->viewcount = sp->viewwait;
/* ReshapeSuperquadrics(-1, -1);*/
}
glPushMatrix();
glTranslatef(0.0, 0.0, -((GLfloat) (sp->dist) / 16.0) - (sp->Mode * 3.0 - 1.0)); /* viewing transform */
glRotatef(sp->rotx, 1.0, 0.0, 0.0); /* pitch */
glRotatef(sp->rotz, 0.0, 0.0, 1.0); /* bank */
glRotatef(sp->roty, 0.0, 1.0, 0.0); /* "spin", like heading but comes after P & B */
SetCull(0, sp);
polys = DoneScale(sp);
glPopMatrix();
/* Remember to flush & swap the buffers after calling this function! */
return polys;
}
void GLRenderState::Bind()
{
SetBlend(srcBlend, dstBlend);
SetBlendFunc(blendFunc);
SetAlphaTest(alphaTest, alphaRef);
SetCull(cullMode);
SetDepthTest(depthTest);
SetDepthWrite(depthWrite);
/*
if(!curState)
{
curState = this;
return;
}
if(curState->GetSrcBlend() != srcBlend ||
curState->GetDstBlend() != dstBlend)
{
SetBlend(srcBlend, dstBlend);
}
if(curState->GetBlendFunc() != blendFunc)
{
SetBlendFunc(blendFunc);
}
if(curState->GetAlphaTest() != alphaTest ||
curState->GetAlphaRef() != alphaRef)
{
SetAlphaTest(alphaTest, alphaRef);
}
if(curState->GetDepthTest() != depthTest)
{
SetDepthTest(depthTest);
}
if(curState->GetDepthWrite() != depthWrite)
{
SetDepthWrite(depthWrite);
}
if(curState->GetCullMode() != cullMode)
{
SetCull(cullMode);
}
*/
curState = this;
}
static int
DisplaySuperquadrics(ModeInfo *mi)
{
superquadricsstruct *sp = &superquadrics[MI_SCREEN(mi)];
int polys = 0;
glDrawBuffer(GL_BACK);
if (sp->wireframe)
glClear(GL_COLOR_BUFFER_BIT);
else
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
if (sp->viewcount < 1) {
sp->viewcount = sp->viewwait;
/* ReshapeSuperquadrics(-1, -1);*/
}
glPushMatrix();
glTranslatef(0.0, 0.0, -((GLfloat) (sp->dist) / 16.0) - (sp->Mode * 3.0 - 1.0)); /* viewing transform */
glRotatef(sp->rotx, 1.0, 0.0, 0.0); /* pitch */
glRotatef(sp->rotz, 0.0, 0.0, 1.0); /* bank */
glRotatef(sp->roty, 0.0, 1.0, 0.0); /* "spin", like heading but comes after P & B */
SetCull(0, sp);
glScalef(0.7, 0.7, 0.7); /* jwz: scale it down a bit */
# ifdef HAVE_MOBILE /* Keep it the same relative size when rotated. */
{
GLfloat h = MI_HEIGHT(mi) / (GLfloat) MI_WIDTH(mi);
int o = (int) current_device_rotation();
if (o != 0 && o != 180 && o != -180)
glScalef (1/h, 1/h, 1/h);
}
# endif
polys = DoneScale(sp);
glPopMatrix();
/* Remember to flush & swap the buffers after calling this function! */
return polys;
}
static void
InitSuperquadrics(int wfmode, int snorm, int res, int count, float speed, superquadricsstruct * sp)
{
GLfloat ambient[] =
{0.4, 0.4, 0.4, 1.0};
GLfloat position[] =
{10.0, 1.0, 1.0, 10.0};
GLfloat mat_diffuse[] =
{1.0, 0.5, 0.5, 1.0};
GLfloat mat_specular[] =
{0.8, 0.8, 0.8, 1.0};
GLfloat mat_shininess[] =
{50.0};
int t;
for (t = 0; t < 4; ++t) {
sp->curmat[t][0] = 0.0;
sp->curmat[t][1] = 0.0;
sp->curmat[t][2] = 0.0;
sp->curmat[t][3] = 1.0;
}
sp->rotx = 35.0;
sp->roty = 0.0;
sp->rotz = 0.0;
sp->dist = (16 << 3);
sp->wireframe = sp->flatshade = sp->shownorms = 0;
sp->maxcount = count;
if (sp->maxcount < 1)
sp->maxcount = 1;
sp->maxwait = sp->maxcount >> 1;
SetCull(1, sp);
sp->mono = 0;
sp->spinspeed = speed;
sp->viewcount = sp->viewwait = (sp->maxcount < 2) ? 1 : (sp->maxcount << 3);
if (res < MinRes)
res = MinRes;
if (res > MaxRes)
res = MaxRes;
sp->resolution = res;
if (wfmode == 2)
sp->flatshade = 1;
else if (wfmode)
sp->wireframe = 1;
if (snorm)
sp->shownorms = 1;
glClearColor(0.0,0.0,0.0,1.0);
glClearDepth(1.0);
if (sp->wireframe) {
glShadeModel(GL_FLAT);
glDisable(GL_LIGHTING);
glColor3f(mat_diffuse[0], mat_diffuse[1], mat_diffuse[2]);
} else {
if (sp->flatshade) {
glShadeModel(GL_FLAT);
position[0] = 1.0;
position[3] = 0.0;
}
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glDepthFunc(GL_LEQUAL);
glEnable(GL_DEPTH_TEST);
glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
glLightfv(GL_LIGHT0, GL_POSITION, position);
/*glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, mat_diffuse); */
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, mat_specular);
glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, mat_shininess);
glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);
glFrontFace(GL_CW);
glEnable(GL_NORMALIZE);
}
MakeUpStuff(1, sp);
SetCurrentShape(sp);
MakeUpStuff(1, sp); /* Initialize it */
sp->counter = sp->maxcount;
}
__forceinline static void SetGPState(const PolyParam* gp, int pass, u32 cflip=0)
{
if (gp->pcw.Texture && gp->tsp.FilterMode > 1)
{
gl4ShaderUniforms.trilinear_alpha = 0.25 * (gp->tsp.MipMapD & 0x3);
if (gp->tsp.FilterMode == 2)
// Trilinear pass A
gl4ShaderUniforms.trilinear_alpha = 1.0 - gl4ShaderUniforms.trilinear_alpha;
}
else
gl4ShaderUniforms.trilinear_alpha = 1.0;
s32 clipping = SetTileClip(gp->tileclip, -1);
if (pass == 0)
{
CurrentShader = gl4GetProgram(Type == ListType_Punch_Through ? 1 : 0,
clipping,
Type == ListType_Punch_Through ? gp->pcw.Texture : 0,
1,
gp->tsp.IgnoreTexA,
0,
0,
2,
false, // TODO Can PT have two different textures for area 0 and 1 ??
0,
false,
false,
false,
pass);
}
else
{
// Two volumes mode only supported for OP and PT
bool two_volumes_mode = (gp->tsp1.full != -1) && Type != ListType_Translucent;
bool color_clamp = gp->tsp.ColorClamp && (pvrrc.fog_clamp_min != 0 || pvrrc.fog_clamp_max != 0xffffffff);
int depth_func = 0;
if (Type == ListType_Translucent)
{
if (SortingEnabled)
depth_func = 6; //GEQUAL
else
depth_func = gp->isp.DepthMode;
}
CurrentShader = gl4GetProgram(Type == ListType_Punch_Through ? 1 : 0,
clipping,
gp->pcw.Texture,
gp->tsp.UseAlpha,
gp->tsp.IgnoreTexA,
gp->tsp.ShadInstr,
gp->pcw.Offset,
gp->tsp.FogCtrl,
two_volumes_mode,
depth_func,
gp->pcw.Gouraud,
gp->tcw.PixelFmt == PixelBumpMap,
color_clamp,
pass);
}
glcache.UseProgram(CurrentShader->program);
gl4ShaderUniforms.tsp0 = gp->tsp;
gl4ShaderUniforms.tsp1 = gp->tsp1;
gl4ShaderUniforms.tcw0 = gp->tcw;
gl4ShaderUniforms.tcw1 = gp->tcw1;
if (Type == ListType_Opaque || Type == ListType_Punch_Through) // TODO Can PT have a >0 and <1 alpha?
{
gl4ShaderUniforms.tsp0.SrcInstr = 1;
gl4ShaderUniforms.tsp0.DstInstr = 0;
gl4ShaderUniforms.tsp1.SrcInstr = 1;
gl4ShaderUniforms.tsp1.DstInstr = 0;
}
gl4ShaderUniforms.Set(CurrentShader);
SetTileClip(gp->tileclip, CurrentShader->pp_ClipTest);
// This bit controls which pixels are affected
// by modvols
const u32 stencil = (gp->pcw.Shadow!=0)?0x80:0;
glcache.StencilFunc(GL_ALWAYS, stencil, stencil);
if (CurrentShader->pp_Texture)
{
for (int i = 0; i < 2; i++)
{
glActiveTexture(GL_TEXTURE0 + i);
GLuint texid = i == 0 ? gp->texid : gp->texid1;
glBindTexture(GL_TEXTURE_2D, texid == -1 ? 0 : texid);
if (texid != -1)
{
TSP tsp = i == 0 ? gp->tsp : gp->tsp1;
TCW tcw = i == 0 ? gp->tcw : gp->tcw1;
glBindSampler(i, texSamplers[i]);
SetTextureRepeatMode(i, GL_TEXTURE_WRAP_S, tsp.ClampU, tsp.FlipU);
SetTextureRepeatMode(i, GL_TEXTURE_WRAP_T, tsp.ClampV, tsp.FlipV);
//set texture filter mode
if (tsp.FilterMode == 0)
{
//disable filtering, mipmaps
glSamplerParameteri(texSamplers[i], GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glSamplerParameteri(texSamplers[i], GL_TEXTURE_MAG_FILTER, GL_NEAREST);
}
else
{
//bilinear filtering
//PowerVR supports also trilinear via two passes, but we ignore that for now
glSamplerParameteri(texSamplers[i], GL_TEXTURE_MIN_FILTER, (tcw.MipMapped && settings.rend.UseMipmaps) ? GL_LINEAR_MIPMAP_NEAREST : GL_LINEAR);
glSamplerParameteri(texSamplers[i], GL_TEXTURE_MAG_FILTER, GL_LINEAR);
}
}
}
glActiveTexture(GL_TEXTURE0);
}
//set cull mode !
//cflip is required when exploding triangles for triangle sorting
//gcflip is global clip flip, needed for when rendering to texture due to mirrored Y direction
SetCull(gp->isp.CullMode ^ cflip ^ gcflip);
/* Set Z mode, only if required */
if (Type == ListType_Punch_Through || (Type == ListType_Translucent && SortingEnabled))
{
glcache.DepthFunc(Zfunction[6]); // Greater or equal
}
else
{
glcache.DepthFunc(Zfunction[gp->isp.DepthMode]);
}
// Depth buffer is updated in pass 0 (and also in pass 1 for OP PT)
if (pass < 2)
glcache.DepthMask(!gp->isp.ZWriteDis);
else
glcache.DepthMask(GL_FALSE);
}
