kpriv/freebsd-ports
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
freebsd-ports/games/ioquake3/files/extra-patch-cellshading
Alejandro Pulver 4a0fd0bbc9 - Add CELLSHADING and MP3 options (patches from official site). 
- Don't use += when initializing MAKE_ENV.
- Add note in pkg-message about CELLSHADING option.

Obtained from:	http://ioquake3.org/?page=patches
2007-09-14 18:14:05 +00:00

933 lines
24 KiB
Text
Raw Blame History

Index: code/renderer/tr_image.c
===================================================================
--- code/renderer/tr_image.c (revision 933)
+++ code/renderer/tr_image.c (working copy)
@@ -34,7 +34,24 @@
#define JPEG_INTERNALS
#include "../jpeg-6/jpeglib.h"
+/**
+ * Headers for cell shading
+ * @author Jordi Prats Catala
+ * @author Guillermo Miranda Alamo
+ */
+/*
+byte getImageR(byte *targa_rgba, int x, int y, int columns, int rows);
+byte getImageG(byte *targa_rgba, int x, int y, int columns, int rows);
+byte getImageB(byte *targa_rgba, int x, int y, int columns, int rows);
+byte getImageA(byte *targa_rgba, int x, int y, int columns, int rows);
+void setImageR(byte *targa_rgba, int x, int y, int columns, int rows, byte value);
+void setImageG(byte *targa_rgba, int x, int y, int columns, int rows, byte value);
+void setImageB(byte *targa_rgba, int x, int y, int columns, int rows, byte value);
+void setImageA(byte *targa_rgba, int x, int y, int columns, int rows, byte value);
+*/
+//void kuwahara(int columns, int rows, byte *targa_rgba);
+
static void LoadBMP( const char *name, byte **pic, int *width, int *height );
static void LoadTGA( const char *name, byte **pic, int *width, int *height );
static void LoadJPG( const char *name, byte **pic, int *width, int *height );
@@ -799,7 +816,643 @@
return image;
}
+/****************************
+RGB GET/SET
+****************************/
+//RED
+static byte getImageR(byte *targa_rgba, int x, int y, int columns, int rows)
+{
+ byte *pixbuf;
+
+ x*=((x<0)?-1:1);
+ y*=((y<0)?-1:1);
+ if(rows<=y)
+ y=y%rows;
+ if(columns<=x)
+ x=x%columns;
+ x*=((x<0)?-1:1);
+ y*=((y<0)?-1:1);
+
+
+ pixbuf = targa_rgba + y*columns*4;
+
+ pixbuf+=(x*4);
+
+ return *pixbuf;
+}
+
+static void setImageR(byte *targa_rgba, int x, int y, int columns, int rows, byte value)
+{
+ byte *pixbuf;
+
+ x*=((x<0)?-1:1);
+ y*=((y<0)?-1:1);
+
+ pixbuf = targa_rgba + y*columns*4;
+
+ pixbuf+=(x*4);
+
+ *pixbuf=value;
+}
+//GREEN
+static byte getImageG(byte *targa_rgba, int x, int y, int columns, int rows)
+{
+ byte *pixbuf;
+
+ x*=((x<0)?-1:1);
+ y*=((y<0)?-1:1);
+ if(rows<=y)
+ y=y%rows;
+ if(columns<=x)
+ x=x%columns;
+ x*=((x<0)?-1:1);
+ y*=((y<0)?-1:1);
+
+ pixbuf = targa_rgba + y*columns*4;
+
+ pixbuf+=(x*4);
+
+ pixbuf++;
+ return *pixbuf;
+}
+
+static void setImageG(byte *targa_rgba, int x, int y, int columns, int rows, byte value)
+{
+ byte *pixbuf;
+
+ x*=((x<0)?-1:1);
+ y*=((y<0)?-1:1);
+
+ pixbuf = targa_rgba + y*columns*4;
+
+ pixbuf+=(x*4);
+ pixbuf++;
+ *pixbuf=value;
+}
+//BLUE
+static byte getImageB(byte *targa_rgba, int x, int y, int columns, int rows)
+{
+ byte *pixbuf;
+
+ x*=((x<0)?-1:1);
+ y*=((y<0)?-1:1);
+ if(rows<=y)
+ y=y%rows;
+ if(columns<=x)
+ x=x%columns;
+ x*=((x<0)?-1:1);
+ y*=((y<0)?-1:1);
+
+ pixbuf = targa_rgba + y*columns*4;
+
+ pixbuf+=(x*4);
+ pixbuf+=2;
+ return *pixbuf;
+}
+
+static void setImageB(byte *targa_rgba, int x, int y, int columns, int rows, byte value)
+{
+ byte *pixbuf;
+
+ x*=((x<0)?-1:1);
+ y*=((y<0)?-1:1);
+
+ pixbuf = targa_rgba + y*columns*4;
+
+ pixbuf+=(x*4);
+ pixbuf+=2;
+ *pixbuf=value;
+}
+//ALPHA
+static byte getImageA(byte *targa_rgba, int x, int y, int columns, int rows)
+{
+ byte *pixbuf;
+
+ x*=((x<0)?-1:1);
+ y*=((y<0)?-1:1);
+
+ pixbuf = targa_rgba + y*columns*4;
+
+ pixbuf+=(x*4);
+ pixbuf+=3;
+ return *pixbuf;
+}
+
+static void setImageA(byte *targa_rgba, int x, int y, int columns, int rows, byte value)
+{
+ byte *pixbuf;
+
+ x*=((x<0)?-1:1);
+ y*=((y<0)?-1:1);
+
+ pixbuf = targa_rgba + y*columns*4;
+
+ pixbuf+=(x*4);
+ pixbuf+=3;
+ *pixbuf=value;
+}
+
+//RGB
+static void getImageRGB(byte *targa_rgba, int x, int y, int columns, int rows, vec3_t rgb)
+{
+ byte *pixbuf;
+
+ x*=((x<0)?-1:1);
+ y*=((y<0)?-1:1);
+ //if(rows<=y)
+ y=y%rows;
+ //if(columns<=x)
+ x=x%columns;
+ //x*=((x<0)?-1:1);
+ //y*=((y<0)?-1:1);
+
+ pixbuf = targa_rgba + y*columns*4 + x*4;
+
+ rgb[0]=*pixbuf;
+ rgb[1]=*(pixbuf+1);
+ rgb[2]=*(pixbuf+2);
+}
+
+static void setImageRGB(byte *targa_rgba, int x, int y, int columns, int rows, vec3_t rgb)
+{
+ byte *pixbuf;
+
+ //x*=((x<0)?-1:1);
+ //y*=((y<0)?-1:1);
+
+ pixbuf = targa_rgba + y*columns*4 + (x*4);
+
+ *pixbuf=(byte)(rgb[0]);
+ *(pixbuf+1)=(byte)(rgb[1]);
+ *(pixbuf+2)=(byte)(rgb[2]);
+}
+
+/****************************
+NO BRAINER'S BLUR
+****************************/
+static void blur(int columns, int rows, byte *targa_rgba)
+{
+ int row, column;
+ float sum;
+
+
+ for(row=0; row<rows; row++)
+ {
+ //pixbuf = targa_rgba + row*columns*4;
+ for(column=0; column<columns; column++)
+ {
+ sum=0;
+ sum+=getImageR(targa_rgba,column-1,row-1,columns,rows);
+ sum+=getImageR(targa_rgba,column,row-1,columns,rows);
+ sum+=getImageR(targa_rgba,column+1,row-1,columns,rows);
+ sum+=getImageR(targa_rgba,column-1,row,columns,rows);
+ sum+=getImageR(targa_rgba,column,row,columns,rows);
+ sum+=getImageR(targa_rgba,column+1,row,columns,rows);
+ sum+=getImageR(targa_rgba,column-1,row+1,columns,rows);
+ sum+=getImageR(targa_rgba,column,row+1,columns,rows);
+ sum+=getImageR(targa_rgba,column+1,row+1,columns,rows);
+
+ sum/=9.0f;
+
+ setImageR(targa_rgba, column, row, columns, rows, (byte)sum);
+ ////////////////////
+ sum=0;
+ sum+=getImageG(targa_rgba,column-1,row-1,columns,rows);
+ sum+=getImageG(targa_rgba,column,row-1,columns,rows);
+ sum+=getImageG(targa_rgba,column+1,row-1,columns,rows);
+ sum+=getImageG(targa_rgba,column-1,row,columns,rows);
+ sum+=getImageG(targa_rgba,column,row,columns,rows);
+ sum+=getImageG(targa_rgba,column+1,row,columns,rows);
+ sum+=getImageG(targa_rgba,column-1,row+1,columns,rows);
+ sum+=getImageG(targa_rgba,column,row+1,columns,rows);
+ sum+=getImageG(targa_rgba,column+1,row+1,columns,rows);
+
+ sum/=9.0f;
+
+ setImageG(targa_rgba, column, row, columns, rows, (byte)sum);
+ ////////////////////////
+ sum=0;
+ sum+=getImageB(targa_rgba,column-1,row-1,columns,rows);
+ sum+=getImageB(targa_rgba,column,row-1,columns,rows);
+ sum+=getImageB(targa_rgba,column+1,row-1,columns,rows);
+ sum+=getImageB(targa_rgba,column-1,row,columns,rows);
+ sum+=getImageB(targa_rgba,column,row,columns,rows);
+ sum+=getImageB(targa_rgba,column+1,row,columns,rows);
+ sum+=getImageB(targa_rgba,column-1,row+1,columns,rows);
+ sum+=getImageB(targa_rgba,column,row+1,columns,rows);
+ sum+=getImageB(targa_rgba,column+1,row+1,columns,rows);
+
+ sum/=9.0f;
+
+ setImageB(targa_rgba, column, row, columns, rows, (byte)sum);
+
+ // "halftoning"
+ /*if((row%5==0)&&(column%5==1))
+ {
+ gris=0;
+ gris+=red;
+ gris+=green;
+ gris+=blue;
+ gris/=3;
+
+ gris=255-gris;
+ if(gris<0)
+ gris=0;
+
+ setImageR(targa_rgba, column, row, columns, rows, (byte)gris);
+ setImageG(targa_rgba, column, row, columns, rows, (byte)gris);
+ setImageB(targa_rgba, column, row, columns, rows, (byte)gris);
+
+ }*/
+
+ }
+ }
+
+}
+
+
+/****************************
+COLORED LIGHTMAP
+****************************/
+void whiteTextureOne(int columns, int rows, byte *targa_rgba){
+ //byte *pixbyf;
+ int row, column;
+ long rMean=0, gMean=0, bMean=0;
+ int pixels=0;
+
+ for(row=0;row<rows;row++){
+ for(column=0;column<columns;column++){
+ // Don't count fully transparent pixels
+ if(getImageA(targa_rgba,column,row,columns,rows)==0)
+ continue;
+ // Sum pixels values
+ rMean+=getImageR(targa_rgba,column,row,columns,rows);
+ gMean+=getImageG(targa_rgba,column,row,columns,rows);
+ bMean+=getImageB(targa_rgba,column,row,columns,rows);
+ pixels++;
+ }
+ }
+
+ // Calculate average
+ if(pixels>0){
+ rMean=((float)rMean/(float)pixels);
+ gMean=((float)gMean/(float)pixels);
+ bMean=((float)bMean/(float)pixels);
+ }
+ else{
+ return;
+ }
+
+ for(row=0;row<rows;row++){
+ for(column=0;column<columns;column++){
+ if(getImageA(targa_rgba,column,row,columns,rows)<32)
+ continue;
+ setImageR(targa_rgba,column,row,columns,rows,rMean);
+ setImageG(targa_rgba,column,row,columns,rows,gMean);
+ setImageB(targa_rgba,column,row,columns,rows,bMean);
+ }
+ }
+}
+
+int diffSquare(int mean, int val){
+ float variance = (val-mean)/255.0f;
+ float radius = mean<128?mean:255-mean;
+ return mean+(radius*variance);
+}
+
+/****************************
+DECONTRAST
+****************************/
+void whiteTextureTwo(int columns, int rows, byte *targa_rgba){
+ int row, column;
+ long rMean=0, gMean=0, bMean=0;
+ int r=0, g=0, b=0;
+ int pixels=0;
+
+
+ for(row=0;row<rows;row++){
+ for(column=0;column<columns;column++){
+ // Don't count fully transparent pixels
+ if(getImageA(targa_rgba,column,row,columns,rows)<32)
+ continue;
+ // Sum pixels values
+ rMean+=getImageR(targa_rgba,column,row,columns,rows);
+ gMean+=getImageG(targa_rgba,column,row,columns,rows);
+ bMean+=getImageB(targa_rgba,column,row,columns,rows);
+ pixels++;
+ }
+ }
+
+ // Calculate average
+ if(pixels>0){
+ rMean=rMean/pixels;
+ gMean=gMean/pixels;
+ bMean=bMean/pixels;
+ }
+ else{
+ return;
+ }
+
+
+ for(row=0;row<rows;row++){
+ for(column=0;column<columns;column++){
+ if(getImageA(targa_rgba,column,row,columns,rows)<32)
+ continue;
+ r=getImageR(targa_rgba,column,row,columns,rows);
+ g=getImageG(targa_rgba,column,row,columns,rows);
+ b=getImageB(targa_rgba,column,row,columns,rows);
+
+ setImageR(targa_rgba,column,row,columns,rows,diffSquare(rMean,r));
+ setImageG(targa_rgba,column,row,columns,rows,diffSquare(gMean,g));
+ setImageB(targa_rgba,column,row,columns,rows,diffSquare(bMean,b));
+
+ }
+ }
+}
+
+/****************************
+KUWAHARA ,FAILS SOMEWHERE
+****************************/
+#define KWH_RADIUS 2
+static void mean_variance(int x0, int y0, int x1, int y1, int columns, int rows, byte *targa_rgba, vec4_t mv )
+{
+ short min=255*3, max=0;
+ unsigned short count= 0;
+ short row, column;
+ unsigned short value;
+ vec3_t rgb;
+
+ mv[0]=mv[1]=mv[2]=mv[3]=0;
+
+ for(row=y0;row<=y1;row++)
+ {
+ for(column=x0;column<=x1;column++)
+ {
+ getImageRGB(targa_rgba,column,row,columns,rows,rgb);
+
+ VectorAdd(mv,rgb,mv);
+
+ count++;
+ value=rgb[0]+rgb[1]+rgb[2];
+ if(value<min) min=value;
+ if(value>max) max=value;
+ }
+ }
+
+ mv[0]/=count;
+ mv[1]/=count;
+ mv[2]/=count;
+ mv[3]= (max-min)/3.0f;
+}
+
+
+static void rgb_kuwahara(int x, int y, int columns, int rows, byte *targa_rgba, vec4_t bmv)
+{
+ vec4_t mv;
+ bmv[0]=bmv[1]=bmv[2]=bmv[3]=255;
+
+ mean_variance(x-KWH_RADIUS, y-KWH_RADIUS, x, y, columns, rows, targa_rgba, mv);
+ if( mv[3] < bmv[3] )
+ {
+ Vector4Copy(mv,bmv);
+ }
+
+ mean_variance(x, y-KWH_RADIUS, x+KWH_RADIUS, y, columns, rows, targa_rgba, mv);
+ if( mv[3] < bmv[3] )
+ {
+ Vector4Copy(mv,bmv);
+ }
+
+ mean_variance(x, y, x+KWH_RADIUS, y+KWH_RADIUS, columns, rows, targa_rgba, mv);
+ if( mv[3] < bmv[3] )
+ {
+ Vector4Copy(mv,bmv);
+ }
+
+ mean_variance(x-KWH_RADIUS, y, x, y+KWH_RADIUS, columns, rows, targa_rgba, mv);
+ if( mv[3] < bmv[3] )
+ {
+ Vector4Copy(mv,bmv);
+ }
+}
+
+static void kuwahara(int columns, int rows, byte *targa_rgba){
+ int row, column;
+ vec4_t rgbv;
+
+ for(row=0;row<rows;row++){
+ for(column=0;column<columns;column++){
+ rgb_kuwahara(column, row, columns, rows, targa_rgba, rgbv);
+ setImageRGB(targa_rgba,column,row,columns,rows,rgbv);
+ }
+ }
+}
+
+
+#define FLT_MAX 3.40282346638528860000e+38
+static void kuwahara3(int columns, int rows, byte *targa_rgba)
+{
+ byte channel;
+ int size = 10;
+ int index1,index2;
+ int width = columns-4;
+ int height = rows-4;
+ int size2 = (size+1)/2;
+ int offset = (size-1)/2;
+ const int width2 = columns + offset;
+ const int height2 = rows + offset;
+ int x1start = 4;
+ int y1start = 4;
+ int x2, y2;
+ int sum, sum2, n, v=0, xbase, ybase;
+ int y1,x1;
+ int xbase2=0, ybase2=0;
+ float var, min;
+ float** mean, **variance;
+
+ //blur(columns, rows, targa_rgba);
+
+ // I hate malloc I hate malloc I hate malloc I hate malloc I hate malloc I hate malloc
+ mean = (float**)malloc(sizeof(float*)*width2);
+ for(index1=0;index1<width2;index1++)
+ mean[index1] = (float*)malloc(sizeof(float)*height2);
+
+ variance = (float**)malloc(sizeof(float*)*width2);
+ for(index2=0;index2<width2;index2++)
+ variance[index2] = (float*)malloc(sizeof(float)*height2);
+
+ // For each channel (R,G,B)
+ // for(channel=0;channel<2;channel++)
+ // FTL
+ for(channel=0;channel<3;channel++){
+ for (y1=y1start-offset; y1<y1start+height; y1++) {
+
+ for (x1=x1start-offset; x1<x1start+width; x1++) {
+ sum=0; sum2=0; n=0;
+ for (x2=x1; x2<x1+size2; x2++) {
+ for (y2=y1; y2<y1+size2; y2++) {
+ //v = i(x2, y2);
+ switch(channel){
+ case 0:
+ v = getImageR(targa_rgba,x2,y2,columns,rows);
+ break;
+ case 1:
+ v = getImageG(targa_rgba,x2,y2,columns,rows);
+ break;
+ case 2:
+ v = getImageB(targa_rgba,x2,y2,columns,rows);
+ break;
+ }
+ //v = *targa_rgba + y2*columns*4+x2*4;
+ v/=10;
+ v*=10;
+ sum += v;
+ sum2 += v*v;
+ n++;
+ }
+ }
+ //cerr << "Accedo" << endl;
+ mean[x1+offset][y1+offset] = (float)(sum/n);
+ variance[x1+offset][y1+offset] = (float)((n*sum2-sum*sum)/n);
+ }
+ }
+
+ for (y1=y1start; y1<y1start+height; y1++) {
+ /*if ((y1%20)==0)
+ cout << (0.7+0.3*(y1-y1start)/height);*/
+ for (x1=x1start; x1<x1start+width; x1++) {
+ min = FLT_MAX;
+ xbase = x1; ybase=y1;
+ var = variance[xbase][ybase];
+ if (var<min){
+ min= var;
+ xbase2=xbase;
+ ybase2=ybase;
+ }
+ xbase = x1+offset;
+ var = variance[xbase][ybase];
+ if (var<min){
+ min= var;
+ xbase2=xbase;
+ ybase2=ybase;
+ }
+ ybase = y1+offset;
+ var = variance[xbase][ybase];
+ if (var<min){
+ min= var;
+ xbase2=xbase;
+ ybase2=ybase;
+ }
+ xbase = x1;
+ var = variance[xbase][ybase];
+ if (var<min){
+ min= var;
+ xbase2=xbase;
+ ybase2=ybase;
+ }
+ //i(x1, y1)=(int)(mean[xbase2][ybase2]+0.5);
+ switch(channel){
+ case 0:
+ setImageR(targa_rgba,x1,y1,columns,rows,(byte)(mean[xbase2][ybase2]+0.5));
+ break;
+ case 1:
+ setImageG(targa_rgba,x1,y1,columns,rows,(byte)(mean[xbase2][ybase2]+0.5));
+ break;
+ case 2:
+ setImageB(targa_rgba,x1,y1,columns,rows,(byte)(mean[xbase2][ybase2]+0.5));
+ break;
+ }
+ }
+ }
+ }
+ // Fuck mean & variance, this is hell (!+) Bad Religion
+ for(index1=0;index1<width2;index1++)
+ free(mean[index1]);
+ free(mean);
+
+ for(index2=0;index2<width2;index2++)
+ free(variance[index2]);
+ free(variance);
+
+ //blur(columns, rows, targa_rgba);
+}
+
+/****************************
+Symmetric Nearest Neighbour
+****************************/
+
+#define SNN_RADIUS 3
+
+static int deltaE(int l1,int a1,int b1,int l2,int a2,int b2)
+{
+ return (l1-l2)*(l1-l2) + (a1-a2)*(a1-a2) + (b1-b2)*(b1-b2);
+}
+
+static void snn(int columns, int rows, byte *targa_rgba)
+{
+
+ int row, column;
+ unsigned short sumR, sumG, sumB;
+ unsigned short count;
+ short u, v;
+ byte r, g, b;
+ byte r1, g1, b1;
+ byte r2, g2, b2;
+ for(row=0;row<rows;row++){
+ for(column=0;column<columns;column++){
+ sumR=0;
+ sumG=0;
+ sumB=0;
+ count=0;
+
+ r=getImageR(targa_rgba,column,row,columns,rows);
+ g=getImageG(targa_rgba,column,row,columns,rows);
+ b=getImageB(targa_rgba,column,row,columns,rows);
+
+ for(v=-SNN_RADIUS;v<=0;v++)
+ {
+ for(u=-SNN_RADIUS;u<=SNN_RADIUS;u++)
+ {
+ if(v==0&&u>=0) break;
+ // Sum pixels values
+ r1=getImageR(targa_rgba,column+u,row+v,columns,rows);
+ g1=getImageG(targa_rgba,column+u,row+v,columns,rows);
+ b1=getImageB(targa_rgba,column+u,row+v,columns,rows);
+
+ r2=getImageR(targa_rgba,column-u,row-v,columns,rows);
+ g2=getImageG(targa_rgba,column-u,row-v,columns,rows);
+ b2=getImageB(targa_rgba,column-u,row-v,columns,rows);
+
+ if ( deltaE(r,g,b,r1,g1,b1) < deltaE(r,g,b,r2,g2,b2))
+ {
+ sumR += r1;
+ sumG += g1;
+ sumB += b1;
+ }
+ else
+ {
+ sumR += r2;
+ sumG += g2;
+ sumB += b2;
+ }
+ count++;
+ }
+ }
+
+ r=(byte)((int)(2*sumR+r)/(int)(2*count+1));
+ g=(byte)((int)(2*sumG+g)/(int)(2*count+1));
+ b=(byte)((int)(2*sumB+b)/(int)(2*count+1));
+
+ setImageR(targa_rgba,column,row,columns,rows,r);
+ setImageG(targa_rgba,column,row,columns,rows,g);
+ setImageB(targa_rgba,column,row,columns,rows,b);
+ }
+ }
+}
+
+
+
/*
=========================================================
@@ -1968,6 +2621,50 @@
} else if ( !Q_stricmp( name+len-4, ".jpg" ) ) {
LoadJPG( name, pic, width, height );
}
+
+ switch(r_celshadalgo->integer)
+ {
+ case 1:
+ whiteTextureOne(*width,*height,*pic);
+ break;
+ case 2:
+ whiteTextureTwo(*width,*height,*pic);
+ break;
+ case 10:
+ kuwahara(*width,*height,*pic);
+ break;
+ case 11:
+ blur(*width,*height,*pic);
+ kuwahara(*width,*height,*pic);
+ break;
+ case 12:
+ kuwahara(*width,*height,*pic);
+ blur(*width,*height,*pic);
+ break;
+ case 13:
+ blur(*width,*height,*pic);
+ kuwahara(*width,*height,*pic);
+ blur(*width,*height,*pic);
+ break;
+ case 20:
+ snn(*width,*height,*pic);
+ break;
+ case 21:
+ blur(*width,*height,*pic);
+ snn(*width,*height,*pic);
+ break;
+ case 22:
+ snn(*width,*height,*pic);
+ blur(*width,*height,*pic);
+ break;
+ case 23:
+ blur(*width,*height,*pic);
+ snn(*width,*height,*pic);
+ blur(*width,*height,*pic);
+ break;
+ default:
+ break;
+ }
}
Index: code/renderer/tr_init.c
===================================================================
--- code/renderer/tr_init.c (revision 933)
+++ code/renderer/tr_init.c (working copy)
@@ -111,6 +111,10 @@
cvar_t *r_roundImagesDown;
cvar_t *r_colorMipLevels;
cvar_t *r_picmip;
+// Next one added for cell shading algorithm selection
+cvar_t *r_celshadalgo;
+//. next one for enable/disable cel bordering all together.
+cvar_t *r_celoutline;
cvar_t *r_showtris;
cvar_t *r_showsky;
cvar_t *r_shownormals;
@@ -1110,6 +1114,10 @@
r_debugSurface = ri.Cvar_Get ("r_debugSurface", "0", CVAR_CHEAT);
r_nobind = ri.Cvar_Get ("r_nobind", "0", CVAR_CHEAT);
r_showtris = ri.Cvar_Get ("r_showtris", "0", CVAR_CHEAT);
+ // for cell shading algorithm selection
+ r_celshadalgo = ri.Cvar_Get ("r_celshadalgo", "1", CVAR_LATCH);
+ // cel outline option
+ r_celoutline = ri.Cvar_Get("r_celoutline","1", CVAR_ARCHIVE);
r_showsky = ri.Cvar_Get ("r_showsky", "0", CVAR_CHEAT);
r_shownormals = ri.Cvar_Get ("r_shownormals", "0", CVAR_CHEAT);
r_clear = ri.Cvar_Get ("r_clear", "0", CVAR_CHEAT);
Index: code/renderer/tr_local.h
===================================================================
--- code/renderer/tr_local.h (revision 933)
+++ code/renderer/tr_local.h (working copy)
@@ -1063,6 +1063,8 @@
extern cvar_t *r_uiFullScreen; // ui is running fullscreen
extern cvar_t *r_logFile; // number of frames to emit GL logs
+extern cvar_t *r_celshadalgo; // Cell shading, chooses method: 0 = disabled, 1 = kuwahara, 2 = whiteTexture
+extern cvar_t *r_celoutline; //. cel outline. 1 on, 0 off. (maybe other options later)
extern cvar_t *r_showtris; // enables wireframe rendering of the world
extern cvar_t *r_showsky; // forces sky in front of all surfaces
extern cvar_t *r_shownormals; // draws wireframe normals
Index: code/renderer/tr_shade.c
===================================================================
--- code/renderer/tr_shade.c (revision 933)
+++ code/renderer/tr_shade.c (working copy)
@@ -201,6 +201,86 @@
}
+//R_DRAWCEL
+static void R_DrawCel( int numIndexes, const glIndex_t *indexes ) {
+ int primitives;
+
+ if(
+ //. ignore the 2d projection. do i smell the HUD?
+ (backEnd.projection2D == qtrue) ||
+ //. ignore general entitites that are sprites. SEE NOTE #3.
+ (backEnd.currentEntity->e.reType == RT_SPRITE) ||
+ //. ignore these liquids. why? ever see liquid with tris on the surface? exactly. SEE NOTE #4.
+ (tess.shader->contentFlags & (CONTENTS_WATER | CONTENTS_LAVA | CONTENTS_SLIME | CONTENTS_FOG)) ||
+ //. ignore things that are two sided, meaning mostly things that have transparency. SEE NOTE #1.
+ (tess.shader->cullType == CT_TWO_SIDED)
+
+ ) {
+ return;
+ }
+
+ primitives = r_primitives->integer;
+
+ // default is to use triangles if compiled vertex arrays are present
+ if ( primitives == 0 ) {
+ if ( qglLockArraysEXT ) {
+ primitives = 2;
+ } else {
+ primitives = 1;
+ }
+ }
+
+ //. correction for mirrors. SEE NOTE #2.
+ if(backEnd.viewParms.isMirror == qtrue) { qglCullFace (GL_FRONT); }
+ else { qglCullFace (GL_BACK); }
+
+ qglEnable (GL_BLEND);
+ qglBlendFunc (GL_SRC_ALPHA ,GL_ONE_MINUS_SRC_ALPHA);
+ qglColor3f (0.0f,0.0f,0.0f);
+ qglLineWidth( (float) r_celoutline->integer );
+
+ if(primitives == 2) {
+ qglDrawElements( GL_TRIANGLES, numIndexes, GL_INDEX_TYPE, indexes );
+ } else if(primitives == 1) {
+ R_DrawStripElements( numIndexes, indexes, qglArrayElement );
+ } else if(primitives == 3) {
+ R_DrawStripElements( numIndexes, indexes, R_ArrayElementDiscrete );
+ }
+
+ //. correction for mirrors. SEE NOTE #2.
+ if(backEnd.viewParms.isMirror == qtrue) { qglCullFace (GL_BACK); }
+ else { qglCullFace (GL_FRONT); }
+
+ qglDisable (GL_BLEND);
+
+ return;
+
+/* Notes
+
+1. this is going to be a pain in the arse. it fixes things like light `beams` from being cel'd but it
+also will ignore any other shader set with no culling. this usually is everything that is translucent.
+but this is a good hack to clean up the screen untill something more selective comes along. or who knows
+group desision might actually be that this is liked. if so i take back calling it a `hack`, lol.
+ = bob.
+
+2. mirrors display correctly because the normals of the displayed are inverted of normal space. so to
+continue to have them display correctly, we must invert them inversely from a normal inversion.
+ = bob.
+
+3. this turns off a lot of space hogging sprite cel outlines. picture if you will five people in a small
+room all shooting rockets. each smoke puff gets a big black square around it, each explosion gets a big
+black square around it, and now nobody can see eachother because everyones screen is solid black.
+ = bob.
+
+4. ignoring liquids means you will not get black tris lines all over the top of your liquid. i put this in
+after seeing the lava on q3dm7 and water on q3ctf2 that had black lines all over the top, making the
+liquids look solid instead of... liquid.
+ = bob.
+
+*/
+}
+
+
/*
=============================================================
@@ -245,6 +325,33 @@
GL_Bind( bundle->image[ index ] );
}
+//DRAWCEL
+static void DrawCel (shaderCommands_t *input) {
+
+ GL_Bind( tr.whiteImage );
+ qglColor3f (1,1,1);
+
+ GL_State( GLS_POLYMODE_LINE | GLS_DEPTHMASK_TRUE );
+
+ qglDisableClientState (GL_COLOR_ARRAY);
+ qglDisableClientState (GL_TEXTURE_COORD_ARRAY);
+
+ qglVertexPointer (3, GL_FLOAT, 16, input->xyz); // padded for SIMD
+
+ if (qglLockArraysEXT) {
+ qglLockArraysEXT(0, input->numVertexes);
+ GLimp_LogComment( "glLockArraysEXT\n" );
+ }
+
+ R_DrawCel( input->numIndexes, input->indexes );
+
+ if (qglUnlockArraysEXT) {
+ qglUnlockArraysEXT();
+ GLimp_LogComment( "glUnlockArraysEXT\n" );
+ }
+
+}
+
/*
================
DrawTris
@@ -1140,6 +1247,12 @@
qglPolygonOffset( r_offsetFactor->value, r_offsetUnits->value );
}
+ //. show me cel outlines.
+ //. there has to be a better place to put this.
+ if(r_celoutline->integer > 0) {
+ DrawCel(&tess);
+ }
+
//
// if there is only a single pass then we can enable color
// and texture arrays before we compile, otherwise we need
Index: code/renderer/tr_shader.c
===================================================================
--- code/renderer/tr_shader.c (revision 933)
+++ code/renderer/tr_shader.c (working copy)
@@ -2744,7 +2744,17 @@
*/
qhandle_t RE_RegisterShaderNoMip( const char *name ) {
shader_t *sh;
+ // Remember previous value
+ int old_r_celshadalgo;
+ /*
+ * This will prevent sprites, like buttons, go through
+ * cel shading filters, like kuwahara.
+ * @author gmiranda
+ */
+ old_r_celshadalgo = r_celshadalgo->integer;
+ r_celshadalgo->integer=0;
+
if ( strlen( name ) >= MAX_QPATH ) {
Com_Printf( "Shader name exceeds MAX_QPATH\n" );
return 0;
@@ -2752,6 +2762,9 @@
sh = R_FindShader( name, LIGHTMAP_2D, qfalse );
+ // Restore value
+ r_celshadalgo->integer=old_r_celshadalgo;
+
// we want to return 0 if the shader failed to
// load for some reason, but R_FindShader should
// still keep a name allocated for it, so if
Reference in a new issue View git blame Copy permalink