void CALL HGE_Impl::Gfx_RenderQuad(const hgeQuad *quad)
{
glEnable(GL_TEXTURE_2D); // Enable Texture Mapping
glBindTexture(GL_TEXTURE_2D, quad->tex);
_SetBlendMode(quad->blend);
//TODO: insert code here
GLfloat verteces[12] = {
quad->v[3].x, quad->v[3].y, quad->v[3].z,
quad->v[2].x, quad->v[2].y, quad->v[2].z,
quad->v[1].x, quad->v[1].y, quad->v[1].z,
quad->v[0].x, quad->v[0].y, quad->v[0].z,
};
GLfloat texCoords[8] = {
quad->v[3].tx, quad->v[3].ty,
quad->v[2].tx, quad->v[2].ty,
quad->v[1].tx, quad->v[1].ty,
quad->v[0].tx, quad->v[0].ty,
};
GLubyte colors[16] = {
(GLubyte)GETR(quad->v[3].col), (GLubyte)GETG(quad->v[3].col), (GLubyte)GETB(quad->v[3].col), (GLubyte)GETA(quad->v[3].col),
(GLubyte)GETR(quad->v[2].col), (GLubyte)GETG(quad->v[2].col), (GLubyte)GETB(quad->v[2].col), (GLubyte)GETA(quad->v[2].col),
(GLubyte)GETR(quad->v[1].col), (GLubyte)GETG(quad->v[1].col), (GLubyte)GETB(quad->v[1].col), (GLubyte)GETA(quad->v[1].col),
(GLubyte)GETR(quad->v[0].col), (GLubyte)GETG(quad->v[0].col), (GLubyte)GETB(quad->v[0].col), (GLubyte)GETA(quad->v[0].col),
};
glVertexPointer(3, GL_FLOAT, 0, verteces);
glEnableClientState(GL_VERTEX_ARRAY);
glTexCoordPointer(2, GL_FLOAT, 0, texCoords);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glColorPointer(4, GL_UNSIGNED_BYTE, 0, colors);
glEnableClientState(GL_COLOR_ARRAY);
glDrawArrays(GL_QUADS, 0, 4);
glDisable(GL_TEXTURE_2D); // Enable Texture Mapping
glDisable(GL_BLEND); // Enable Texture Mapping
glBindTexture(GL_TEXTURE_2D, 0);
}
void d3d_vertex_normal_color(double x, double y, double z, double nx, double ny, double nz, int color, double alpha)
{
glColor4f(GETR(color), GETG(color), GETB(color), alpha);
glNormal3f(nx, ny, nz);
glVertex3d(x,y,z);
glColor4ubv(enigma::currentcolor);
}
void CALL HGE_Impl::Gfx_Clear(DWORD color)
{
//TODO: set given color
glClearColor((float)GETR(color)/0xff, (float)GETG(color)/0xff, (float)GETB(color)/0xff, (float)GETA(color)/0xff);
glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_ACCUM_BUFFER_BIT);
}
void HGEImage::convertToDisplayFormat()
{
DWORD *pLockPtr = mHGE->Texture_Lock(mTexture);
if (pLockPtr == NULL)
{
throw GCN_EXCEPTION("Locking of the texture failed. HGE only support locking of 32bit textures.");
}
int i;
int end = mHGE->Texture_GetWidth(mTexture, true) *
mHGE->Texture_GetHeight(mTexture, true);
for (i = 0; i < end; i++)
{
DWORD color = pLockPtr[i];
if (GETR(color) == 0xFF
&& GETG(color) == 0x00
&& GETB(color) == 0xFF)
{
pLockPtr[i] = ARGB(0x00, 0x00, 0x00, 0x00);
}
}
mHGE->Texture_Unlock(mTexture);
mHGESprite = new hgeSprite(mTexture,
0,
0,
mHGE->Texture_GetWidth(mTexture, true),
mHGE->Texture_GetHeight(mTexture, true));
}
void d3d_vertex_normal_color(gs_scalar x, gs_scalar y, gs_scalar z, gs_scalar nx, gs_scalar ny, gs_scalar nz, int color, double alpha)
{
glColor4f(GETR(color), GETG(color), GETB(color), alpha);
glNormal3f(nx, ny, nz);
glVertex3d(x,y,z);
glColor4ubv(enigma::currentcolor);
}
void d3d_vertex_texture_color(double x, double y, double z, double tx, double ty, int color, double alpha)
{
glColor4f(GETR(color), GETG(color), GETB(color), alpha);
glTexCoord2f(tx,ty);
glVertex3d(x,y,z);
glColor4ubv(enigma::currentcolor);
}
void d3d_vertex_texture_color(gs_scalar x, gs_scalar y, gs_scalar z, gs_scalar tx, gs_scalar ty, int color, double alpha)
{
glColor4f(GETR(color), GETG(color), GETB(color), alpha);
glTexCoord2f(tx,ty);
glVertex3d(x,y,z);
glColor4ubv(enigma::currentcolor);
}
void ncGraphics::clear(unsigned int color) {
glClearColor(
GETR(color) / 255.f,
GETG(color) / 255.f,
GETB(color) / 255.f,
GETA(color) / 255.f
);
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
}
// Problem 1
void ExSolvePoisson(int xRes, int yRes, int _iterations, double _accuracy, double* field, double* b)
{
// double dt = fluid.dt;
double *p_old = new double[xRes*yRes];
double *p_new = new double[xRes*yRes];
for (int y = 0; y < yRes; y++)
for (int x = 0; x < xRes; x++){
p_old[x + y*xRes] = 0.0;
p_new[x + y*xRes] = GETF(x, y);
// printf("%f\n", p_new[x + y*xRes]);
}
for (int iter = 0; iter < _iterations; ++iter)
{
double *p_old_ = p_old;
p_old = p_new;
p_new = p_old_;
double residual = 0;
// note that the boundaries are handles by the framework, so you iterations should be similar to:
for (int y = 1; y < yRes - 1; y++) {
for (int x = 1; x < xRes - 1; x++)
{
double d = GETB(x, y);
double p_old_FD = p_old[x+1 + y*xRes] + p_old[x + (y+1)*xRes] + p_old[x-1 + y*xRes] + p_old[x + (y-1)*xRes];
p_new[x + y*xRes] = 0.25 * ( d + p_old_FD );
double Ap_new = 4.0 * p_new[x + y*xRes] - (p_new[x+1 + y*xRes] + p_new[x + (y+1)*xRes] + p_new[x-1 + y*xRes] + p_new[x + (y-1)*xRes]);
residual += fabs(d - Ap_new);
// printf("b = %f\n", p_old[x+y*xRes]);
}
}
residual /= (double)(xRes*yRes);
//for your debugging, and ours, please add these prints after every iteration
if(iter==_iterations-1)
printf("Pressure solver: iter=%d , res=%f \n",iter, residual);
if(residual<_accuracy) {
printf("Pressure solver: iter=%d , converged \n",iter,residual);
break; // optional
}
}
for (int y = 1; y < yRes - 1; y++)
for (int x = 1; x < xRes - 1; x++){
GETF(x, y) = p_new[x + y*xRes];
}
}
void HGE_CALL HGE_Impl::Gfx_Clear(hgeU32 color)
{
float c[4] = {
(float)GETA(color) / 256,
(float)GETR(color) / 256,
(float)GETG(color) / 256,
(float)GETB(color) / 256 };
m_pD3DDeviceContext->ClearRenderTargetView(pRTView, c);
//m_pD3DDeviceContext->ClearDepthStencilView(pDSView, D3D11_CLEAR_DEPTH, 1.0f, 0);
}
/* jpeg_save_img:
* Write an image out into a JPEG file. */
int jpeg_save_img(const img I, FILE *fp) {
struct jpeg_compress_struct cinfo;
struct my_error_mgr jerr;
JSAMPROW *buffer;
cinfo.err = jpeg_std_error(&jerr.pub);
jerr.pub.error_exit = my_error_exit;
if (setjmp(jerr.jb)) {
/* Oops, something went wrong. */
I->err = IE_SYSERROR;
jpeg_destroy_compress(&cinfo);
return 0;
}
jpeg_create_compress(&cinfo);
/* Compressor will write to fp. */
jpeg_stdio_dest(&cinfo, fp);
/* Image parameters. */
cinfo.image_width = I->width;
cinfo.image_height = I->height;
cinfo.input_components = 3;
cinfo.in_color_space = JCS_RGB;
/* Default parameters. */
jpeg_set_defaults(&cinfo);
/* XXX compression quality? */
jpeg_start_compress(&cinfo, TRUE);
buffer = cinfo.mem->alloc_sarray((j_common_ptr)&cinfo, JPOOL_IMAGE, I->width * 3, 1);
while (cinfo.next_scanline < cinfo.image_height) {
pel *p, *end;
unsigned char *q;
/* Copy image data into correct format. */
for (p = I->data[cinfo.next_scanline], end = p + I->width, q = (unsigned char*)buffer[0]; p < end; ++p) {
*q++ = (unsigned char)GETR(*p);
*q++ = (unsigned char)GETG(*p);
*q++ = (unsigned char)GETB(*p);
}
/* Write scanline. */
jpeg_write_scanlines(&cinfo, buffer, 1);
}
jpeg_finish_compress(&cinfo);
jpeg_destroy_compress(&cinfo);
return 1;
}
bool CApp::init() {
if (SDL_Init(SDL_INIT_EVERYTHING) != 0)
return false;
_window = SDL_CreateWindow(TITLE, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, SCREEN_W, SCREEN_H, 0);
_renderer = SDL_CreateRenderer(_window, -1, SDL_RENDERER_PRESENTVSYNC);
SDL_SetRenderDrawColor(_renderer, GETR(COLOR_BG), GETG(COLOR_BG), GETB(COLOR_BG), SDL_ALPHA_OPAQUE);
SDL_RenderClear(_renderer);
_game.set_renderer(_renderer);
_currentState = &_game;
return true;
}
Color HGEImage::getPixel(int x, int y)
{
DWORD *pLockPtr = mHGE->Texture_Lock(mTexture);
if (pLockPtr == NULL)
{
throw GCN_EXCEPTION("Locking of the texture failed. HGE only support locking of 32bit textures.");
}
DWORD color = pLockPtr[x + y * mHGE->Texture_GetWidth(mTexture, true)];
mHGE->Texture_Unlock(mTexture);
return Color(GETR(color),
GETG(color),
GETB(color),
GETA(color ));
}
/*
Get the color of a pen.
*/
static void GDI_get_pen(int pen, unsigned char* pRed, unsigned char* pGreen, unsigned char* pBlue)
{
if (This.m_nDepth != 8 && This.m_bModifiablePalette == FALSE)
{
*pRed = GETR(pen);
*pGreen = GETG(pen);
*pBlue = GETB(pen);
}
else
{
assert(0 <= pen && pen < This.m_nTotalColors);
if (This.m_nTotalColors <= pen)
pen = 0;
*pRed = This.m_PalEntries[pen].peRed;
*pGreen = This.m_PalEntries[pen].peGreen;
*pBlue = This.m_PalEntries[pen].peBlue;
}
}
/*****
* Name: ReadColormap
* Return Type: Boolean
* Description: reads the colormap of a GIF/GZF image.
* In:
* plc: current PLC
* gif: plc image object.
* Returns:
* True when colormap has been read, False if not.
*****/
static Boolean
ReadColormap(PLC *plc, PLCImageGIF *gif)
{
register int i;
Byte rgb[3];
_XmHTMLDebug(15, ("plc.c: ReadColormap for %s\n", plc->url));
/* read it */
for(i = 0; i < gif->cmapsize; ++i)
{
if(!_PLCReadOK(plc, rgb, sizeof(rgb)))
return(False);
GETR(gif->cmap[i]) = rgb[0];
GETG(gif->cmap[i]) = rgb[1];
GETB(gif->cmap[i]) = rgb[2];
}
return(True);
}
void do_bumpmapping(BITMAP *dest, BITMAP *bumpmap, BITMAP *colormap, int light_x, int light_y)
{
int x, y, nx, ny, lx, ly, c;
float k;
for(y = 1; y < bumpmap->h - 1; y++)
for(x = 1; x < bumpmap->w - 1; x++)
{
nx = PIXEL(bumpmap, x + 1, y) - PIXEL(bumpmap, x - 1, y);
ny = PIXEL(bumpmap, x, y + 1) - PIXEL(bumpmap, x, y - 1);
lx = x - light_x - 128;
ly = y - light_y - 128;
nx -= lx;
ny -= ly;
clamp(&nx, 0, 255);
clamp(&ny, 0, 255);
c = PIXEL(colormap, x, y);
k = envmap[nx][ny] * 0.00390625;
PIXEL(dest, x, y) = MAKECOL(GETR(c) * k, GETG(c) * k, GETB(c) * k);
}
}
void ObjectPool::SetBWbools(const char* filename, int NumOfObject)
{
HGE *hge = hgeCreate(HGE_VERSION);
HTEXTURE pic = hge->Texture_Load(filename);
int width = hge->Texture_GetWidth(pic);
int height = hge->Texture_GetHeight(pic);
BWpic bwpic;
bwpic.width = width;
bwpic.height = height;
bwpic.bools = (bool**)malloc(sizeof(bool*)*width);
for (int i = 0; i < width; i++)
bwpic.bools[i] = (bool*)malloc(sizeof(bool)*height);
DWORD *color = hge->Texture_Lock(pic);
for (int i = 0; i < width; i++)
for (int j = 0; j < height;j++)
if (GETR(color[j*width + i]) == 0 && GETG(color[j*width + i]) == 0 && GETB(color[j*width + i]) == 0)
bwpic.bools[j][i] = true;
else bwpic.bools[j][i] = false;
bwpic.number = NumOfObject;
hge->Texture_Unlock(pic);
hge->Texture_Free(pic);
BWpics.push_back(bwpic);
BWpics.shrink_to_fit();
}
void d3d_vertex_color(double x, double y, double z, int color, double alpha)
{
glColor4f(GETR(color), GETG(color), GETB(color), alpha);
glVertex3d(x,y,z);
glColor4ubv(enigma::currentcolor);
}
HTEXTURE HGE_CALL HGE_Impl::Texture_Load(const char *filename, hgeU32 size, bool bMipmap)
{
HRESULT hr;
void *data;
hgeU32 _size;
ID3D11Resource* pRes;
ID3D11Resource* pStagingRes;
ID3D11Texture2D* pTex;
ID3D11ShaderResourceView* pSRV;
//D3DXIMAGE_INFO info;
CTextureList *texItem;
//load file to buffer
if (size)
{
//If argument is already the buffer
data = (void *)filename; _size = size;
}
else
{
data = pHGE->Resource_Load(filename, &_size);
if (!data) return NULL;
}
//Get image info
D3DX11_IMAGE_INFO imgInfo;
hr = D3DX11GetImageInfoFromMemory(
(LPCSTR)data,
_size,
NULL,
&imgInfo,
NULL);
if (hr)
{
_PostError("Cannot get image info.\n");
if (!size) Resource_Free(data);
return NULL;
}
D3DX11_IMAGE_LOAD_INFO loadImgInfo;
loadImgInfo.MipLevels = bMipmap ? 0 : 1;
loadImgInfo.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
loadImgInfo.Usage = D3D11_USAGE_STAGING;
loadImgInfo.BindFlags = 0;// (autogen) ? (D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_RENDER_TARGET) : (D3D11_BIND_SHADER_RESOURCE);
loadImgInfo.CpuAccessFlags = D3D11_CPU_ACCESS_READ | D3D11_CPU_ACCESS_WRITE;
loadImgInfo.MiscFlags = 0;
//Create Staging texture first
hr = D3DX11CreateTextureFromMemory(
m_pD3DDevice,
(LPCVOID)data,
_size,
&loadImgInfo,
NULL,
&pStagingRes,
0);
if (hr)
{
_PostError("Can't create texture");
if (!size) Resource_Free(data);
return NULL;
}
//shouldn't access the file buffer anymore
if (!size) Resource_Free(data);
//Convert 0xFF00FFFF to transparent color
D3D11_TEXTURE2D_DESC TDesc;
((ID3D11Texture2D*)pStagingRes)->GetDesc(&TDesc);
if (bUseTransparentColor)
{
DWORD* pLockPtr = (DWORD*)Texture_Lock((HTEXTURE)pStagingRes, false);
int end = TDesc.Width * TDesc.Height;
for (int i = 0; i < end; i++)
{
DWORD& currentPixel = pLockPtr[i];
if (GETR(currentPixel) == 0xFF &&
GETG(currentPixel) == 0x00 &&
GETB(currentPixel) == 0xFF)
{
currentPixel = ARGB(0x00, 0x00, 0x00, 0x00);
}
}
//Create default texture with data
//from the staging texture
TDesc.Usage = D3D11_USAGE_DEFAULT;
TDesc.CPUAccessFlags = 0;
TDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
TDesc.MipLevels = bMipmap ? 0 : 1;
D3D11_SUBRESOURCE_DATA sr;
sr.pSysMem = pLockPtr;
sr.SysMemPitch = TDesc.Width * 4;
sr.SysMemSlicePitch = TDesc.Width * TDesc.Height * 4;
hr = m_pD3DDevice->CreateTexture2D(&TDesc, &sr, &pTex);
if (hr)
{
_PostError("Can't create texture");
if (!size) Resource_Free(data);
pStagingRes->Release();
return NULL;
}
Texture_Unlock((HTEXTURE)pStagingRes);
SAFE_RELEASE(pStagingRes);
}
D3D11_SHADER_RESOURCE_VIEW_DESC SRVDesc;
memset(&SRVDesc, 0, sizeof(SRVDesc));
SRVDesc.Format = TDesc.Format;
SRVDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
SRVDesc.Texture2D.MipLevels = bMipmap ? 0 : 1;
hr = m_pD3DDevice->CreateShaderResourceView(pTex, &SRVDesc, &pSRV);
if (hr)
{
_PostError("Can't create texture");
if (!size) Resource_Free(data);
return NULL;
}
pSRV->GetResource(&pRes);
// hr = CreateWICTextureFromMemory(
// pd3dDevice,
// pd3dImmediateContext,
// (uint8_t*)data,
// _size,
// &pRes,
// &pSRV,
// 0);
texItem = new CTextureList;
texItem->tex = (HTEXTURE)pTex;
texItem->m_pSRV = pSRV;
texItem->width = TDesc.Width;
texItem->height = TDesc.Height;
texItem->next = textures;
textures = texItem;
return (HTEXTURE)texItem;
}
void Render(void)
{
static int sn = 0;
if (params.antiFlicker)
{
renderSurf = scrSurf[sn];
sn = 1 - sn;
} else renderSurf = screen;
if ((drawFrame || isAvgImageWrited /* isLongImageWrited */) && SDL_MUSTLOCK(renderSurf))
{
if (SDL_LockSurface(renderSurf) < 0)
{
printf("Can't lock surface\n");
return;
}
}
renderPitch = renderSurf->pitch / 4;
if (dev_extport.Is16Colors()) renderPtr = Render16c;
else if (dev_extport.IsMulticolor()) renderPtr = RenderMulticolor;
// else if (dev_extport.Is512x192()) renderPtr = Render512x192;
// else if (dev_extport.Is384x304()) renderPtr = Render384x304;
else renderPtr = RenderSpeccy;
InitActClk();
prevRenderClk = 0;
while (cpuClk < INT_LENGTH)
{
CpuStep();
CpuInt();
}
if (drawFrame || isAvgImageWrited /* isLongImageWrited */)
{
while (cpuClk < MAX_FRAME_TACTS)
{
CpuStep();
renderPtr(cpuClk);
}
}
else
{
while (cpuClk < MAX_FRAME_TACTS) {
CpuStep();
}
}
renderPtr = NULL;
lastDevClk = devClk;
cpuClk -= MAX_FRAME_TACTS;
devClk = cpuClk;
if ((drawFrame || isAvgImageWrited /* isLongImageWrited */) && SDL_MUSTLOCK(renderSurf)) SDL_UnlockSurface(renderSurf);
if (params.antiFlicker && (drawFrame || isAvgImageWrited /* isLongImageWrited */)) AntiFlicker(renderSurf, scrSurf[sn]);
// if (isLongImageWrited)
// {
// int * src = (int *)screen->pixels + (PITCH * (32 + longImagePos)) + 32;
//
// for (int i = 256; i--;)
// {
// unsigned int c = *src;
// int r = GETR(c);
// int g = GETG(c);
// int b = GETB(c);
//
// longImageFile.PutBYTE(r);
// longImageFile.PutBYTE(g);
// longImageFile.PutBYTE(b);
//
// *(src++) = DRGB(255 - r, 255 - g, 255 - b);
// }
//
// longImageHeight++;
// longImagePos = (longImagePos + 1) % 192;
// }
if (isAvgImageWrited)
{
int * src = (int *)screen->pixels;
long * dst = avgImageBuffer;
for (int i = HEIGHT; i--;)
{
int * line = src;
for (int j = WIDTH; j--;)
{
unsigned int c = *(line++);
*(dst++) += (long)GETR(c);
*(dst++) += (long)GETG(c);
*(dst++) += (long)GETB(c);
}
src += PITCH;
}
// avgImageFrames++;
}
}
void d3d_vertex_color(gs_scalar x, gs_scalar y, gs_scalar z, int color, double alpha) {
glColor4f(GETR(color), GETG(color), GETB(color), alpha);
glVertex3d(x,y,z);
glColor4ubv(enigma::currentcolor);
}
int main(int argc, char *argv[])
{
MACRO_VARS // :.
int times,f_name_i = 1;
byte b,nible,*loaded_file,stack_i;
struct space *f;
uint stack[256];
/* BF VM vars */
byte *mem;
uint pos = 0;
/* end */
if(argc == 3){
f_name_i = 2;
if(argv[1][0] == '-' && argv[1][1] == 'v')
v = 1;
}
f = loadfile(argv[f_name_i]);
loaded_file = f->p;
mem = alloc_mem(MEM_SIZE);
nible = 0; // starting by nible 0
times = 1; // run a command, at least once
b = GETB();
if(v) printf("b = 0x%x\n", b);
while(b){
if(b & BIT7){
if(v) printf("Isn't a char\n");
if(nible){
if(v) printf("Second nible\n");
if(b & BIT3){ // it is XXXX1XXXb?
if(v) printf("Is a number of times to repeat\n");
switch(b & 0x07){ // 00000111b
case 0: times = 0; break;
case 1: times = 2; break;
case 2: times = 4; break;
case 3: times = 8; break;
case 4: times = 16; break;
case 5: times = 32; break;
case 6: times = 64; break;
case 7: times = 128; break;
}
if(times == 0){
}
if(v) printf("Repeat %i\n", times);
}
else{
if(v) printf("Is a command\n");
times = 1;
b <<= 4;
b |= 0x80; // set first bt
}
}
else{
if(v) printf("First nible\n");
times = 1;
}
for(; times >= 1; times--){
if(v) printf("Executando a %i_a vez\n", times);
switch(b & 0x70){ // 01110000b
case 0x00: // ,
//if(v) printf("Digite um caracter:\n");
mem[pos] = inC();
break;
case 0x10: // +
if(times > 1){
mem[pos] += times;
if(v) printf("%i x +\n", times);
times = 0;
}
else{
if(v) printf("+\n");
mem[pos]++;
}
break;
case 0x20: // >
if(v) printf(">\n");
if(pos >= MEM_SIZE){
printf("Fatal programer stupid!\nStop! traing to acess mem after end of BF machine\n");
exit(1);
}
pos++;
break;
case 0x30: // [
if(v) printf("[\n");
if(mem[pos])
stack[stack_i++] = MACRO_i;
else
while(b != ']') b = GETB();
break;
case 0x40: // .
outC(mem[pos]);
if(v) printf(" = 0x%x\n", mem[pos]);
break;
case 0x50: // -
if(times > 1){
mem[pos] -= times;
if(v) printf("%i x -\n", times);
times = 0;
}
else{
if(v) printf("-\n");
mem[pos]--;
}
break;
case 0x60: // <
if(v) printf("<\n");
if(pos <= 0){
printf("Fatal programer stupid!\nStop! traing to acess mem before star of BF machine\n");
exit(1);
}
pos--;
break;
case 0x70: // ]
if(v) printf("]\n");
MACRO_i = stack[stack_i--];
break;
}
}
if(!nible) nible = 1;
else{
b = GETB();
if(v) printf("b = 0x%x\n", b);
nible = 0;
}
}
else{
if(v) printf("%c", b); //printf("Is a char: %c\n", b);
nible = 0;
b = GETB();
}
}
//printf("%s", mem);
printf("\n");
return(0);
}
void mb86233_cpu_device::ALU( UINT32 alu)
{
float ftmp;
switch(alu)
{
case 0x00: /* NOP */
break;
case 0x01: /* D = D & A */
GETD().u &= GETA().u;
FLAGSI( GETD().u);
break;
case 0x02: /* D = D | A */
GETD().u |= GETA().u;
FLAGSI( GETD().u);
break;
case 0x03: /* D = D ^ A */
GETD().u ^= GETA().u;
FLAGSI( GETD().u);
break;
case 0x04: /* D = D ~ A */
GETD().u = ~GETA().u;
FLAGSI( GETD().u);
break;
case 0x05: /* CMP D,A */
ftmp = GETD().f - GETA().f;
FLAGSF( ftmp);
m_icount--;
break;
case 0x06: /* D = D + A */
GETD().f += GETA().f;
FLAGSF( GETD().f);
m_icount--;
break;
case 0x07: /* D = D - A */
GETD().f -= GETA().f;
FLAGSF( GETD().f);
m_icount--;
break;
case 0x08: /* P = A * B */
GETP().f = GETA().f * GETB().f;
m_icount--;
break;
case 0x09: /* D = D + P; P = A * B */
GETD().f += GETP().f;
GETP().f = GETA().f * GETB().f;
FLAGSF( GETD().f);
m_icount--;
break;
case 0x0A: /* D = D - P; P = A * B */
GETD().f -= GETP().f;
GETP().f = GETA().f * GETB().f;
FLAGSF( GETD().f);
m_icount--;
break;
case 0x0B: /* D = fabs(D) */
GETD().f = fabs( GETD().f );
FLAGSF( GETD().f);
m_icount--;
break;
case 0x0C: /* D = D + P */
GETD().f += GETP().f;
FLAGSF( GETD().f);
m_icount--;
break;
case 0x0D: /* D = P; P = A * B */
GETD().f = GETP().f;
GETP().f = GETA().f * GETB().f;
FLAGSF( GETD().f);
m_icount--;
break;
case 0x0E: /* D = float(D) */
GETD().f = (float)GETD().i;
FLAGSF( GETD().f);
m_icount--;
break;
case 0x0F: /* D = int(D) */
switch((m_fpucontrol>>1)&3)
{
//case 0: GETD().i = floor(GETD().f+0.5f); break;
//case 1: GETD().i = ceil(GETD().f); break;
case 2: GETD().i = floor(GETD().f); break; // Manx TT
case 3: GETD().i = (INT32)GETD().f; break;
default: popmessage("TGP uses D = int(D) with FPU control = %02x, contact MAMEdev",m_fpucontrol>>1); break;
}
FLAGSI( GETD().i);
break;
case 0x10: /* D = D / A */
if ( GETA().u != 0 )
GETD().f = GETD().f / GETA().f;
FLAGSF( GETD().f);
m_icount--;
break;
case 0x11: /* D = -D */
GETD().f = -GETD().f;
FLAGSF( GETD().f);
m_icount--;
break;
case 0x13: /* D = A + B */
GETD().f = GETA().f + GETB().f;
FLAGSF( GETD().f);
m_icount--;
break;
case 0x14: /* D = B - A */
GETD().f = GETB().f - GETA().f;
FLAGSF( GETD().f);
m_icount--;
break;
case 0x16: /* LSR D, SHIFT */
GETD().u >>= GETSHIFT();
FLAGSI( GETD().u);
break;
case 0x17: /* LSL D, SHIFT */
GETD().u <<= GETSHIFT();
FLAGSI( GETD().u);
break;
case 0x18: /* ASR D, SHIFT */
// GETD().u = (GETD().u & 0x80000000) | (GETD().u >> GETSHIFT());
GETD().i >>= GETSHIFT();
FLAGSI( GETD().u);
break;
case 0x1A: /* D = D + A */
GETD().i += GETA().i;
FLAGSI( GETD().u);
break;
case 0x1B: /* D = D - A */
GETD().i -= GETA().i;
FLAGSI( GETD().u);
break;
default:
fatalerror( "TGP: Unknown ALU op %x at PC:%04x\n", alu, GETPC() );
}
}
static void ALU( mb86233_state *cpustate, UINT32 alu)
{
float ftmp;
switch(alu)
{
case 0x00: /* NOP */
break;
case 0x01: /* D = D & A */
GETD().u &= GETA().u;
FLAGSI(cpustate, GETD().u);
break;
case 0x02: /* D = D | A */
GETD().u |= GETA().u;
FLAGSI(cpustate, GETD().u);
break;
case 0x03: /* D = D ^ A */
GETD().u ^= GETA().u;
FLAGSI(cpustate, GETD().u);
break;
case 0x05: /* CMP D,A */
ftmp = GETD().f - GETA().f;
FLAGSF(cpustate, ftmp);
cpustate->icount--;
break;
case 0x06: /* D = D + A */
GETD().f += GETA().f;
FLAGSF(cpustate, GETD().f);
cpustate->icount--;
break;
case 0x07: /* D = D - A */
GETD().f -= GETA().f;
FLAGSF(cpustate, GETD().f);
cpustate->icount--;
break;
case 0x08: /* P = A * B */
GETP().f = GETA().f * GETB().f;
cpustate->icount--;
break;
case 0x09: /* D = D + P; P = A * B */
GETD().f += GETP().f;
GETP().f = GETA().f * GETB().f;
FLAGSF(cpustate, GETD().f);
cpustate->icount--;
break;
case 0x0A: /* D = D - P; P = A * B */
GETD().f -= GETP().f;
GETP().f = GETA().f * GETB().f;
FLAGSF(cpustate, GETD().f);
cpustate->icount--;
break;
case 0x0B: /* D = fabs(D) */
GETD().f = fabs( GETD().f );
FLAGSF(cpustate, GETD().f);
cpustate->icount--;
break;
case 0x0C: /* D = D + P */
GETD().f += GETP().f;
FLAGSF(cpustate, GETD().f);
cpustate->icount--;
break;
case 0x0D: /* D = P; P = A * B */
GETD().f = GETP().f;
GETP().f = GETA().f * GETB().f;
FLAGSF(cpustate, GETD().f);
cpustate->icount--;
break;
case 0x0E: /* D = float(D) */
GETD().f = (float)GETD().i;
FLAGSF(cpustate, GETD().f);
cpustate->icount--;
break;
case 0x0F: /* D = int(D) */
GETD().i = (INT32)GETD().f;
FLAGSI(cpustate, GETD().u);
break;
case 0x10: /* D = D / A */
if ( GETA().u != 0 )
GETD().f = GETD().f / GETA().f;
FLAGSF(cpustate, GETD().f);
cpustate->icount--;
break;
case 0x11: /* D = -D */
GETD().f = -GETD().f;
FLAGSF(cpustate, GETD().f);
cpustate->icount--;
break;
case 0x13: /* D = A + B */
GETD().f = GETA().f + GETB().f;
FLAGSF(cpustate, GETD().f);
cpustate->icount--;
break;
case 0x14: /* D = B - A */
GETD().f = GETB().f - GETA().f;
FLAGSF(cpustate, GETD().f);
cpustate->icount--;
break;
case 0x16: /* LSR D, SHIFT */
GETD().u >>= GETSHIFT();
FLAGSI(cpustate, GETD().u);
break;
case 0x17: /* LSL D, SHIFT */
GETD().u <<= GETSHIFT();
FLAGSI(cpustate, GETD().u);
break;
case 0x18: /* ASR D, SHIFT */
// GETD().u = (GETD().u & 0x80000000) | (GETD().u >> GETSHIFT());
GETD().i >>= GETSHIFT();
FLAGSI(cpustate, GETD().u);
break;
case 0x1A: /* D = D + A */
GETD().i += GETA().i;
FLAGSI(cpustate, GETD().u);
break;
case 0x1B: /* D = D - A */
GETD().i -= GETA().i;
FLAGSI(cpustate, GETD().u);
break;
default:
logerror( "TGP: Unknown ALU op %x at PC:%04x\n", alu, GETPC() );
break;
}
}
void CALL BSGL_Impl::Gfx_Clear(DWORD color) {
glClearColor((GLfloat)GETR(color), (GLfloat)GETG(color),
(GLfloat)GETB(color), (GLfloat)GETA(color));
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
}
void CConvertYuvToRgb::Convert(DWORD dwWidth,DWORD dwHeight,DWORD dwYStride,DWORD dwUVStride,LPBYTE lpY,LPBYTE lpU,LPBYTE lpV,LPBYTE lpOutput,int rPos,int gPos,int bPos)
{
int i,j,k,m;
int nWidthUV;
int nHeightUV;
int nPosUV;
int nWidth;
int nWidth3;
BYTE kY;
BYTE kU;
BYTE kV;
LPBYTE lpInPos;
if(dwYStride==0)
dwYStride = dwWidth;
if(dwUVStride==0)
dwUVStride = dwWidth/2;
lpInPos = lpOutput;
nWidthUV = dwWidth/2;
nHeightUV = dwHeight/2;
nWidth = dwWidth;
nWidth3 = 3*dwWidth;
nPosUV = 0;
k = 0;
m = 0;
for(j=0;j<nHeightUV;j++)
{
for(i=0;i<nWidthUV;i++)
{
kV = lpV[nPosUV];
kU = lpU[nPosUV];
kY = lpY[k];
lpInPos[m+bPos] = GETB(kY,kV);
lpInPos[m+gPos] = GETG(kY,kU,kV);
lpInPos[m+rPos] = GETR(kY,kU);
kY = lpY[k+1];
lpInPos[m+bPos+3] = GETB(kY,kV);
lpInPos[m+gPos+3] = GETG(kY,kU,kV);
lpInPos[m+rPos+3] = GETR(kY,kU);
kY = lpY[k+dwYStride];
lpInPos[m+nWidth3+bPos] = GETB(kY,kV);
lpInPos[m+nWidth3+gPos] = GETG(kY,kU,kV);
lpInPos[m+nWidth3+rPos] = GETR(kY,kU);
kY = lpY[k+1+dwYStride];
lpInPos[m+nWidth3+bPos+3] = GETB(kY,kV);
lpInPos[m+nWidth3+gPos+3] = GETG(kY,kV,kV);
lpInPos[m+nWidth3+rPos+3] = GETR(kY,kU);
m += 6;
k += 2;
nPosUV++;
}
k += ((dwYStride - nWidth) + dwYStride); //(dwYStride - nWidth) учитываем выравнивание в первой строке (которую прошли)
nPosUV += (dwUVStride - nWidthUV); //Учитываем выравнивание, если оно было
m += nWidth3;
}
}
