Classes/Engine3d/TextureData.cpp

#include <stdio.h>
#include "TextureData.h"

TextureData::TextureData( char *texturedataname )
{
        numberoftextures=1;
        texturesize = new int[numberoftextures];
        texturewidth = new int[numberoftextures];
        textureheight = new int[numberoftextures];

        readfile(texturedataname,0);  
}

TextureData::~TextureData(){}

void TextureData::setpointertexture(int *ipointertexture) { pointertexture=ipointertexture;}
int *TextureData::getpointertexture() { return pointertexture; }

void TextureData::settexturesize(int isize, int steg) { texturesize[steg]=isize;}
int TextureData::gettexturesize(int steg) { return texturesize[steg]; }

void TextureData::settexturewidth(int iwidth, int steg) { texturewidth[steg]=iwidth;}
int TextureData::gettexturewidth(int steg) { return texturewidth[steg]; }

void TextureData::settextureheight(int iheight, int steg) { textureheight[steg]=iheight;}
int TextureData::gettextureheight(int steg) { return textureheight[steg]; }

int TextureData::getnumberoftextures() { return numberoftextures; }

void TextureData::readpicture(char *chunkybuffer, int langd, int width, int height, unsigned char* kbuffer )
{
                int d1l,d3l;

                unsigned char *k,*alpha,*red,*green,*blue;
                
                d1l=(langd-512)/4;
                
                k=kbuffer+512;
                red=k+d1l;
                green=k+(d1l*2);
                blue=k+(d1l*3);
                alpha=k+(d1l*4);

                for ( int d7l=0 ; d7l<height ; d7l++ )
                {

                d3l=width*4;

                        for ( int d2l=0 ; d2l<width ; d2l++ )
                        {
                                d3l=d3l-4;

                                --alpha;
                                chunkybuffer[d3l+3]=alpha[0];                   //alpha

                                --red;  
                                chunkybuffer[d3l+2]=red[0];             //red

                                --green;                
                                chunkybuffer[d3l+1]=green[0];           //green
        
                                --blue;
                                chunkybuffer[d3l]=blue[0];              //blue

                        }
        
                        chunkybuffer=chunkybuffer+(width*4);
                }

}


void TextureData::readfile(char *filename, int filenumber  )  
{
            FILE *f;
                
                f = fopen(filename, "rb");
          
                fseek(f,0,2);
                settexturesize(ftell(f), filenumber);
                fseek(f,0,0);

        unsigned char *bbuffer = new unsigned char[gettexturesize(filenumber)];
        int *bbuffer2 = new int[gettexturesize(filenumber)*4];
                
                fread((void *) bbuffer, gettexturesize(filenumber), 1, f);
        fclose(f);

                char *dbuffer=(char*)bbuffer;
                dbuffer=dbuffer+(3*2);

                char d=dbuffer[0];
                dbuffer[0]=dbuffer[1];
                dbuffer[1]=d;

                short *xbuffer=(short*)dbuffer;

                dbuffer=dbuffer+(1*2);

                d=dbuffer[0];
                dbuffer[0]=dbuffer[1];
                dbuffer[1]=d;
                
                short *ybuffer=(short*)dbuffer;

                readpicture((char*) bbuffer2, gettexturesize(filenumber), (int) xbuffer[0], (int) ybuffer[0], bbuffer );

                settexturesize(256*256*4,filenumber);
                settexturewidth(256,filenumber);
                settextureheight(256,filenumber);

                int *temppointer= new int[gettexturesize(filenumber)];

        setpointertexture(temppointer);
                
                float ustep=(float)xbuffer[0]/(float)gettexturewidth(filenumber);
                float vstep=(float)ybuffer[0]/(float)gettextureheight(filenumber);

                int *pointer=(int*)getpointertexture();
                float v=0;

                for ( int y=0 ; y<256; y++ )
                {
                        float u=0;
                        for ( int x=0 ; x<256 ; x++ )
                        {
                                int tempu=(int)u;
                                int tempv=(int)v;
                                pointer[x+y*256]=bbuffer2[tempu+tempv*xbuffer[0]];
                                u+=ustep;
                        }
                        v+=vstep;
                }


                delete bbuffer2;
                delete bbuffer;
}


1	bearsoft	1.1	#include <stdio.h>
2			#include "TextureData.h"
3
4			TextureData::TextureData( char *texturedataname )
5			{
6			numberoftextures=1;
7			texturesize = new int[numberoftextures];
8			texturewidth = new int[numberoftextures];
9			textureheight = new int[numberoftextures];
10
11			readfile(texturedataname,0);
12			}
13
14			TextureData::~TextureData(){}
15
16			void TextureData::setpointertexture(int *ipointertexture) { pointertexture=ipointertexture;}
17			int *TextureData::getpointertexture() { return pointertexture; }
18
19			void TextureData::settexturesize(int isize, int steg) { texturesize[steg]=isize;}
20			int TextureData::gettexturesize(int steg) { return texturesize[steg]; }
21
22			void TextureData::settexturewidth(int iwidth, int steg) { texturewidth[steg]=iwidth;}
23			int TextureData::gettexturewidth(int steg) { return texturewidth[steg]; }
24
25			void TextureData::settextureheight(int iheight, int steg) { textureheight[steg]=iheight;}
26			int TextureData::gettextureheight(int steg) { return textureheight[steg]; }
27
28			int TextureData::getnumberoftextures() { return numberoftextures; }
29
30			void TextureData::readpicture(char chunkybuffer, int langd, int width, int height, unsigned char kbuffer )
31			{
32			int d1l,d3l;
33
34			unsigned char k,alpha,red,green,*blue;
35
36			d1l=(langd-512)/4;
37
38			k=kbuffer+512;
39			red=k+d1l;
40			green=k+(d1l*2);
41			blue=k+(d1l*3);
42			alpha=k+(d1l*4);
43
44			for ( int d7l=0 ; d7l<height ; d7l++ )
45			{
46
47			d3l=width*4;
48
49			for ( int d2l=0 ; d2l<width ; d2l++ )
50			{
51			d3l=d3l-4;
52
53			--alpha;
54			chunkybuffer[d3l+3]=alpha[0]; //alpha
55
56			--red;
57			chunkybuffer[d3l+2]=red[0]; //red
58
59			--green;
60			chunkybuffer[d3l+1]=green[0]; //green
61
62			--blue;
63			chunkybuffer[d3l]=blue[0]; //blue
64
65			}
66
67			chunkybuffer=chunkybuffer+(width*4);
68			}
69
70			}
71
72
73			void TextureData::readfile(char *filename, int filenumber )
74			{
75			FILE *f;
76
77			f = fopen(filename, "rb");
78
79			fseek(f,0,2);
80			settexturesize(ftell(f), filenumber);
81			fseek(f,0,0);
82
83			unsigned char *bbuffer = new unsigned char[gettexturesize(filenumber)];
84			int bbuffer2 = new int[gettexturesize(filenumber)4];
85
86			fread((void *) bbuffer, gettexturesize(filenumber), 1, f);
87			fclose(f);
88
89			char dbuffer=(char)bbuffer;
90			dbuffer=dbuffer+(3*2);
91
92			char d=dbuffer[0];
93			dbuffer[0]=dbuffer[1];
94			dbuffer[1]=d;
95
96			short xbuffer=(short)dbuffer;
97
98			dbuffer=dbuffer+(1*2);
99
100			d=dbuffer[0];
101			dbuffer[0]=dbuffer[1];
102			dbuffer[1]=d;
103
104			short ybuffer=(short)dbuffer;
105
106			readpicture((char*) bbuffer2, gettexturesize(filenumber), (int) xbuffer[0], (int) ybuffer[0], bbuffer );
107
108			settexturesize(2562564,filenumber);
109			settexturewidth(256,filenumber);
110			settextureheight(256,filenumber);
111
112			int *temppointer= new int[gettexturesize(filenumber)];
113
114			setpointertexture(temppointer);
115
116			float ustep=(float)xbuffer[0]/(float)gettexturewidth(filenumber);
117			float vstep=(float)ybuffer[0]/(float)gettextureheight(filenumber);
118
119			int pointer=(int)getpointertexture();
120			float v=0;
121
122			for ( int y=0 ; y<256; y++ )
123			{
124			float u=0;
125			for ( int x=0 ; x<256 ; x++ )
126			{
127			int tempu=(int)u;
128			int tempv=(int)v;
129			pointer[x+y256]=bbuffer2[tempu+tempvxbuffer[0]];
130			u+=ustep;
131			}
132			v+=vstep;
133			}
134
135
136			delete bbuffer2;
137			delete bbuffer;
138			}
139
140
141