int function::call(state *E) {
exo::instruction *pc = &i_store[0];
while (true) {
exo::instruction I = *pc;
exo::opcodes::opcode OP = GET_OP(I);
std::cout << I << " (" << OP << ")" << std::endl;
switch (OP) {
case opcodes::NOOP:
break;
case opcodes::RTN:
return GET_A(I);
case opcodes::JMP:
pc += GET_Bx(I);
break;
case opcodes::LOADK:
E->set(GET_A(I), k_store[GET_B(I)]);
break;
case opcodes::MOVE:
E->set(GET_B(I), E->get(GET_A(I)));
break;
}
pc++;
}
}
int encode_SNM_INFO( uint8_t *base,
size_t *idx,
const snm_hdr_t *hdr,
const n2n_SNM_INFO_t *info )
{
int i, retval = 0;
retval += encode_SNM_hdr(base, idx, hdr);
retval += encode_uint16(base, idx, info->sn_num);
retval += encode_uint16(base, idx, info->comm_num);
if (GET_S(hdr->flags) || GET_A(hdr->flags)) /* SNM / ADV adresses */
{
for (i = 0; i < info->sn_num; i++)
{
retval += encode_sock(base, idx, &info->sn_ptr[i]);
}
}
if (GET_C(hdr->flags) || GET_N(hdr->flags))
{
for (i = 0; i < info->comm_num; i++)
{
retval += encode_SNM_comm(base, idx, &info->comm_ptr[i]);
}
}
return retval;
}
void CGUITextureGL::Begin(UTILS::Color color)
{
CBaseTexture* texture = m_texture.m_textures[m_currentFrame];
texture->LoadToGPU();
if (m_diffuse.size())
m_diffuse.m_textures[0]->LoadToGPU();
texture->BindToUnit(0);
// Setup Colors
m_col[0] = (GLubyte)GET_R(color);
m_col[1] = (GLubyte)GET_G(color);
m_col[2] = (GLubyte)GET_B(color);
m_col[3] = (GLubyte)GET_A(color);
bool hasAlpha = m_texture.m_textures[m_currentFrame]->HasAlpha() || m_col[3] < 255;
if (m_diffuse.size())
{
if (m_col[0] == 255 && m_col[1] == 255 && m_col[2] == 255 && m_col[3] == 255 )
{
m_renderSystem->EnableShader(SM_MULTI);
}
else
{
m_renderSystem->EnableShader(SM_MULTI_BLENDCOLOR);
}
hasAlpha |= m_diffuse.m_textures[0]->HasAlpha();
m_diffuse.m_textures[0]->BindToUnit(1);
}
else
{
if (m_col[0] == 255 && m_col[1] == 255 && m_col[2] == 255 && m_col[3] == 255)
{
m_renderSystem->EnableShader(SM_TEXTURE_NOBLEND);
}
else
{
m_renderSystem->EnableShader(SM_TEXTURE);
}
}
if (hasAlpha)
{
glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE_MINUS_DST_ALPHA, GL_ONE);
glEnable(GL_BLEND);
}
else
{
glDisable(GL_BLEND);
}
m_packedVertices.clear();
m_idx.clear();
}
void pb_rgba_cover_pixel(pb_rgba *pb, const unsigned int x, const unsigned int y, const uint32_t value)
{
// Quick reject if the foreground pixel has both 0 opacity
// and 0 for color component values
if (0 == value) {
return;
}
if (0 == GET_A(value)) {
// Combine the colors, but don't
// change the alpha of the background
} else if (255 == GET_A(value)) {
// The foreground opacity is full, so set
// the color
// and set the background alpha to full as well
pb_rgba_set_pixel(pb, x, y, value);
} else {
// All other cases where doing a cover of something
// other than full opacity
uint8_t alpha = GET_A(value);
int32_t dstPixel = pb_rgba_get_pixel(pb, x, y);
int dstColor = RGBA(
lerp255(GET_R(dstPixel), GET_R(value), alpha),
lerp255(GET_G(dstPixel), GET_G(value), alpha),
lerp255(GET_B(dstPixel), GET_B(value), alpha),
lerp255(GET_A(dstPixel), GET_A(value), alpha)
);
pb_rgba_set_pixel(pb, x, y, dstColor);
/*
pix_rgba * B = (pix_rgba *)&pb->data[(y*(pb)->pixelpitch) + x];
B->r = lerp255(B->r, GET_R(value), alpha);
B->g = lerp255(B->g, GET_R(value), alpha);
B->b = lerp255(B->b, GET_R(value), alpha);
B->a = lerp255(B->a, GET_R(value), alpha);
*/
}
}
bool CRenderSystemGLES::ClearBuffers(color_t color)
{
if (!m_bRenderCreated)
return false;
float r = GET_R(color) / 255.0f;
float g = GET_G(color) / 255.0f;
float b = GET_B(color) / 255.0f;
float a = GET_A(color) / 255.0f;
glClearColor(r, g, b, a);
GLbitfield flags = GL_COLOR_BUFFER_BIT;
glClear(flags);
return true;
}
void CGUITextureGL::Begin(color_t color)
{
m_col[0] = (GLubyte)GET_R(color);
m_col[1] = (GLubyte)GET_G(color);
m_col[2] = (GLubyte)GET_B(color);
m_col[3] = (GLubyte)GET_A(color);
CBaseTexture* texture = m_texture.m_textures[m_currentFrame];
glActiveTextureARB(GL_TEXTURE0_ARB);
texture->LoadToGPU();
if (m_diffuse.size())
m_diffuse.m_textures[0]->LoadToGPU();
glBindTexture(GL_TEXTURE_2D, texture->GetTextureObject());
glEnable(GL_TEXTURE_2D);
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND); // Turn Blending On
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
// diffuse coloring
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
glTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_MODULATE);
glTexEnvf(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_TEXTURE0);
glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
glTexEnvf(GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_PRIMARY_COLOR);
glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR);
VerifyGLState();
if (m_diffuse.size())
{
glActiveTextureARB(GL_TEXTURE1_ARB);
glBindTexture(GL_TEXTURE_2D, m_diffuse.m_textures[0]->GetTextureObject());
glEnable(GL_TEXTURE_2D);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
glTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_MODULATE);
glTexEnvf(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_TEXTURE1);
glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
glTexEnvf(GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_PREVIOUS);
glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR);
VerifyGLState();
}
//glDisable(GL_TEXTURE_2D); // uncomment these 2 lines to switch to wireframe rendering
//glBegin(GL_LINE_LOOP);
glBegin(GL_QUADS);
}
bool CRenderSystemGL::ClearBuffers(color_t color)
{
if (!m_bRenderCreated)
return false;
/* clear is not affected by stipple pattern, so we can only clear on first frame */
if(m_stereoMode == RENDER_STEREO_MODE_INTERLACED && m_stereoView == RENDER_STEREO_VIEW_RIGHT)
return true;
float r = GET_R(color) / 255.0f;
float g = GET_G(color) / 255.0f;
float b = GET_B(color) / 255.0f;
float a = GET_A(color) / 255.0f;
glClearColor(r, g, b, a);
GLbitfield flags = GL_COLOR_BUFFER_BIT;
glClear(flags);
return true;
}
int decode_SNM_INFO( n2n_SNM_INFO_t *pkt,
const snm_hdr_t *hdr,
const uint8_t *base,
size_t * rem,
size_t * idx )
{
int i, retval = 0;
memset(pkt, 0, sizeof(n2n_SNM_INFO_t));
retval += decode_uint16(&pkt->sn_num, base, rem, idx);
retval += decode_uint16(&pkt->comm_num, base, rem, idx);
if (GET_S(hdr->flags) || GET_A(hdr->flags)) /* SNM / ADV adresses */
{
if (alloc_supernodes(&pkt->sn_ptr, pkt->sn_num))
{
return -1;
}
for (i = 0; i < pkt->sn_num; i++)
{
retval += decode_sock(&pkt->sn_ptr[i], base, rem, idx);
}
}
if (GET_C(hdr->flags) || GET_N(hdr->flags))
{
if (alloc_communities(&pkt->comm_ptr, pkt->comm_num))
{
free_supernodes(&pkt->sn_ptr);
return -1;
}
for (i = 0; i < pkt->comm_num; i++)
{
retval += decode_SNM_comm(&pkt->comm_ptr[i], base, rem, idx);
}
}
return retval;
}
void CGUITextureGL::DrawQuad(const CRect &rect, color_t color, CBaseTexture *texture, const CRect *texCoords)
{
if (texture)
{
glActiveTextureARB(GL_TEXTURE0_ARB);
texture->LoadToGPU();
glBindTexture(GL_TEXTURE_2D, texture->GetTextureObject());
glEnable(GL_TEXTURE_2D);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
glTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_MODULATE);
glTexEnvf(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_TEXTURE1);
glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
glTexEnvf(GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_PREVIOUS);
glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR);
}
else
glDisable(GL_TEXTURE_2D);
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND); // Turn Blending On
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
// diffuse coloring
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
glTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_MODULATE);
glTexEnvf(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_TEXTURE0);
glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
glTexEnvf(GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_PRIMARY_COLOR);
glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR);
VerifyGLState();
glBegin(GL_QUADS);
glColor4ub((GLubyte)GET_R(color), (GLubyte)GET_G(color), (GLubyte)GET_B(color), (GLubyte)GET_A(color));
CRect coords = texCoords ? *texCoords : CRect(0.0f, 0.0f, 1.0f, 1.0f);
glTexCoord2f(coords.x1, coords.y1);
glVertex3f(rect.x1, rect.y1, 0);
glTexCoord2f(coords.x2, coords.y1);
glVertex3f(rect.x2, rect.y1, 0);
glTexCoord2f(coords.x2, coords.y2);
glVertex3f(rect.x2, rect.y2, 0);
glTexCoord2f(coords.x1, coords.y2);
glVertex3f(rect.x1, rect.y2, 0);
glEnd();
if (texture)
glDisable(GL_TEXTURE_2D);
}
void log_SNM_hdr( const snm_hdr_t *hdr )
{
traceEvent( TRACE_DEBUG, "HEADER type=%d S=%d C=%d N=%d A=%d E=%d Seq=%d", hdr->type,
GET_S(hdr->flags), GET_C(hdr->flags), GET_N(hdr->flags), GET_A(hdr->flags), GET_E(hdr->flags),
hdr->seq_num );
}
void CGUITextureGLES::DrawQuad(const CRect &rect, color_t color, CBaseTexture *texture, const CRect *texCoords)
{
CRenderSystemGLES *renderSystem = dynamic_cast<CRenderSystemGLES*>(&CServiceBroker::GetRenderSystem());
if (texture)
{
texture->LoadToGPU();
texture->BindToUnit(0);
}
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND); // Turn Blending On
VerifyGLState();
GLubyte col[4];
GLfloat ver[4][3];
GLfloat tex[4][2];
GLubyte idx[4] = {0, 1, 3, 2}; //determines order of triangle strip
if (texture)
renderSystem->EnableGUIShader(SM_TEXTURE);
else
renderSystem->EnableGUIShader(SM_DEFAULT);
GLint posLoc = renderSystem->GUIShaderGetPos();
GLint tex0Loc = renderSystem->GUIShaderGetCoord0();
GLint uniColLoc= renderSystem->GUIShaderGetUniCol();
glVertexAttribPointer(posLoc, 3, GL_FLOAT, 0, 0, ver);
if (texture)
glVertexAttribPointer(tex0Loc, 2, GL_FLOAT, 0, 0, tex);
glEnableVertexAttribArray(posLoc);
if (texture)
glEnableVertexAttribArray(tex0Loc);
// Setup Colors
col[0] = (GLubyte)GET_R(color);
col[1] = (GLubyte)GET_G(color);
col[2] = (GLubyte)GET_B(color);
col[3] = (GLubyte)GET_A(color);
glUniform4f(uniColLoc, col[0] / 255.0f, col[1] / 255.0f, col[2] / 255.0f, col[3] / 255.0f);
ver[0][0] = ver[3][0] = rect.x1;
ver[0][1] = ver[1][1] = rect.y1;
ver[1][0] = ver[2][0] = rect.x2;
ver[2][1] = ver[3][1] = rect.y2;
ver[0][2] = ver[1][2] = ver[2][2] = ver[3][2]= 0;
if (texture)
{
// Setup texture coordinates
CRect coords = texCoords ? *texCoords : CRect(0.0f, 0.0f, 1.0f, 1.0f);
tex[0][0] = tex[3][0] = coords.x1;
tex[0][1] = tex[1][1] = coords.y1;
tex[1][0] = tex[2][0] = coords.x2;
tex[2][1] = tex[3][1] = coords.y2;
}
glDrawElements(GL_TRIANGLE_STRIP, 4, GL_UNSIGNED_BYTE, idx);
glDisableVertexAttribArray(posLoc);
if (texture)
glDisableVertexAttribArray(tex0Loc);
renderSystem->DisableGUIShader();
}
void CSlideShowPic::Render(float *x, float *y, CBaseTexture* pTexture, color_t color)
{
#ifdef HAS_DX
static const DWORD FVF_VERTEX = D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX1;
Vertex vertex[5];
for (int i = 0; i < 4; i++)
{
vertex[i].pos = XMFLOAT3( x[i], y[i], 0);
CD3DHelper::XMStoreColor(&vertex[i].color, color);
vertex[i].texCoord = XMFLOAT2(0.0f, 0.0f);
vertex[i].texCoord2 = XMFLOAT2(0.0f, 0.0f);
}
if (pTexture)
{
vertex[1].texCoord.x = vertex[2].texCoord.x = (float) pTexture->GetWidth() / pTexture->GetTextureWidth();
vertex[2].texCoord.y = vertex[3].texCoord.y = (float) pTexture->GetHeight() / pTexture->GetTextureHeight();
}
else
{
vertex[1].texCoord.x = vertex[2].texCoord.x = 1.0f;
vertex[2].texCoord.y = vertex[3].texCoord.y = 1.0f;
}
vertex[4] = vertex[0]; // Not used when pTexture != NULL
CGUIShaderDX* pGUIShader = g_Windowing.GetGUIShader();
pGUIShader->Begin(SHADER_METHOD_RENDER_TEXTURE_BLEND);
// Set state to render the image
if (pTexture)
{
pTexture->LoadToGPU();
CDXTexture* dxTexture = reinterpret_cast<CDXTexture*>(pTexture);
ID3D11ShaderResourceView* shaderRes = dxTexture->GetShaderResource();
pGUIShader->SetShaderViews(1, &shaderRes);
pGUIShader->DrawQuad(vertex[0], vertex[1], vertex[2], vertex[3]);
}
else
{
if (!UpdateVertexBuffer(vertex))
return;
ID3D11DeviceContext* pContext = g_Windowing.Get3D11Context();
unsigned stride = sizeof(Vertex);
unsigned offset = 0;
pContext->IASetVertexBuffers(0, 1, &m_vb, &stride, &offset);
pContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_LINESTRIP);
pGUIShader->Draw(5, 0);
pGUIShader->RestoreBuffers();
}
#elif defined(HAS_GL)
if (pTexture)
{
int unit = 0;
pTexture->LoadToGPU();
pTexture->BindToUnit(unit++);
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND); // Turn Blending On
// diffuse coloring
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
glTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_MODULATE);
glTexEnvf(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_TEXTURE0);
glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
glTexEnvf(GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_PRIMARY_COLOR);
glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR);
if(g_Windowing.UseLimitedColor())
{
// compress range
pTexture->BindToUnit(unit++); // dummy bind
const GLfloat rgba1[4] = {(235.0 - 16.0f) / 255.0f, (235.0 - 16.0f) / 255.0f, (235.0 - 16.0f) / 255.0f, 1.0f};
glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE , GL_COMBINE);
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, rgba1);
glTexEnvi (GL_TEXTURE_ENV, GL_COMBINE_RGB , GL_MODULATE);
glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE0_RGB , GL_PREVIOUS);
glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE1_RGB , GL_CONSTANT);
glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND0_RGB , GL_SRC_COLOR);
glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND1_RGB , GL_SRC_COLOR);
glTexEnvi (GL_TEXTURE_ENV, GL_COMBINE_ALPHA , GL_REPLACE);
glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE0_ALPHA , GL_PREVIOUS);
// transition
pTexture->BindToUnit(unit++); // dummy bind
const GLfloat rgba2[4] = {16.0f / 255.0f, 16.0f / 255.0f, 16.0f / 255.0f, 0.0f};
glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE , GL_COMBINE);
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, rgba2);
glTexEnvi (GL_TEXTURE_ENV, GL_COMBINE_RGB , GL_ADD);
glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE0_RGB , GL_PREVIOUS);
glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE1_RGB , GL_CONSTANT);
glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND0_RGB , GL_SRC_COLOR);
glTexEnvi (GL_TEXTURE_ENV, GL_OPERAND1_RGB , GL_SRC_COLOR);
glTexEnvi (GL_TEXTURE_ENV, GL_COMBINE_ALPHA , GL_REPLACE);
glTexEnvi (GL_TEXTURE_ENV, GL_SOURCE0_ALPHA , GL_PREVIOUS);
}
}
else
glDisable(GL_TEXTURE_2D);
glPolygonMode(GL_FRONT_AND_BACK, pTexture ? GL_FILL : GL_LINE);
glBegin(GL_QUADS);
float u1 = 0, u2 = 1, v1 = 0, v2 = 1;
if (pTexture)
{
u2 = (float)pTexture->GetWidth() / pTexture->GetTextureWidth();
v2 = (float)pTexture->GetHeight() / pTexture->GetTextureHeight();
}
glColor4ub((GLubyte)GET_R(color), (GLubyte)GET_G(color), (GLubyte)GET_B(color), (GLubyte)GET_A(color));
glTexCoord2f(u1, v1);
glVertex3f(x[0], y[0], 0);
// Bottom-left vertex (corner)
glColor4ub((GLubyte)GET_R(color), (GLubyte)GET_G(color), (GLubyte)GET_B(color), (GLubyte)GET_A(color));
glTexCoord2f(u2, v1);
glVertex3f(x[1], y[1], 0);
// Bottom-right vertex (corner)
glColor4ub((GLubyte)GET_R(color), (GLubyte)GET_G(color), (GLubyte)GET_B(color), (GLubyte)GET_A(color));
glTexCoord2f(u2, v2);
glVertex3f(x[2], y[2], 0);
// Top-right vertex (corner)
glColor4ub((GLubyte)GET_R(color), (GLubyte)GET_G(color), (GLubyte)GET_B(color), (GLubyte)GET_A(color));
glTexCoord2f(u1, v2);
glVertex3f(x[3], y[3], 0);
glEnd();
#elif defined(HAS_GLES)
if (pTexture)
{
pTexture->LoadToGPU();
pTexture->BindToUnit(0);
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND); // Turn Blending On
g_Windowing.EnableGUIShader(SM_TEXTURE);
}
else
{
glDisable(GL_TEXTURE_2D);
g_Windowing.EnableGUIShader(SM_DEFAULT);
}
float u1 = 0, u2 = 1, v1 = 0, v2 = 1;
if (pTexture)
{
u2 = (float)pTexture->GetWidth() / pTexture->GetTextureWidth();
v2 = (float)pTexture->GetHeight() / pTexture->GetTextureHeight();
}
GLubyte col[4];
GLfloat ver[4][3];
GLfloat tex[4][2];
GLubyte idx[4] = {0, 1, 3, 2}; //determines order of triangle strip
GLint posLoc = g_Windowing.GUIShaderGetPos();
GLint tex0Loc = g_Windowing.GUIShaderGetCoord0();
GLint uniColLoc= g_Windowing.GUIShaderGetUniCol();
glVertexAttribPointer(posLoc, 3, GL_FLOAT, 0, 0, ver);
glVertexAttribPointer(tex0Loc, 2, GL_FLOAT, 0, 0, tex);
glEnableVertexAttribArray(posLoc);
glEnableVertexAttribArray(tex0Loc);
// Setup Colour values
col[0] = (GLubyte)GET_R(color);
col[1] = (GLubyte)GET_G(color);
col[2] = (GLubyte)GET_B(color);
col[3] = (GLubyte)GET_A(color);
for (int i=0; i<4; i++)
{
// Setup vertex position values
ver[i][0] = x[i];
ver[i][1] = y[i];
ver[i][2] = 0.0f;
}
// Setup texture coordinates
tex[0][0] = tex[3][0] = u1;
tex[0][1] = tex[1][1] = v1;
tex[1][0] = tex[2][0] = u2;
tex[2][1] = tex[3][1] = v2;
glUniform4f(uniColLoc,(col[0] / 255.0f), (col[1] / 255.0f), (col[2] / 255.0f), (col[3] / 255.0f));
glDrawElements(GL_TRIANGLE_STRIP, 4, GL_UNSIGNED_BYTE, idx);
glDisableVertexAttribArray(posLoc);
glDisableVertexAttribArray(tex0Loc);
g_Windowing.DisableGUIShader();
#else
// SDL render
g_Windowing.BlitToScreen(m_pImage, NULL, NULL);
#endif
}
void CGUITextureGL::DrawQuad(const CRect &rect, color_t color, CBaseTexture *texture, const CRect *texCoords)
{
if (texture)
{
texture->LoadToGPU();
texture->BindToUnit(0);
}
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND); // Turn Blending On
VerifyGLState();
GLubyte col[4];
GLubyte idx[4] = {0, 1, 3, 2}; //determines order of the vertices
GLuint vertexVBO;
GLuint indexVBO;
struct PackedVertex
{
float x, y, z;
float u1, v1;
}vertex[4];
if (texture)
g_Windowing.EnableShader(SM_TEXTURE);
else
g_Windowing.EnableShader(SM_DEFAULT);
GLint posLoc = g_Windowing.ShaderGetPos();
GLint tex0Loc = g_Windowing.ShaderGetCoord0();
GLint uniColLoc = g_Windowing.ShaderGetUniCol();
// Setup Colors
col[0] = (GLubyte)GET_R(color);
col[1] = (GLubyte)GET_G(color);
col[2] = (GLubyte)GET_B(color);
col[3] = (GLubyte)GET_A(color);
glUniform4f(uniColLoc, col[0] / 255.0f, col[1] / 255.0f, col[2] / 255.0f, col[3] / 255.0f);
// bottom left
vertex[0].x = rect.x1;
vertex[0].y = rect.y1;
vertex[0].z = 0;
// bottom right
vertex[1].x = rect.x2;
vertex[1].y = rect.y1;
vertex[1].z = 0;
// top right
vertex[2].x = rect.x2;
vertex[2].y = rect.y2;
vertex[2].z = 0;
// top left
vertex[3].x = rect.x1;
vertex[3].y = rect.y2;
vertex[3].z = 0;
if (texture)
{
CRect coords = texCoords ? *texCoords : CRect(0.0f, 0.0f, 1.0f, 1.0f);
vertex[0].u1 = vertex[3].u1 = coords.x1;
vertex[0].v1 = vertex[1].v1 = coords.y1;
vertex[1].u1 = vertex[2].u1 = coords.x2;
vertex[2].v1 = vertex[3].v1 = coords.y2;
}
glGenBuffers(1, &vertexVBO);
glBindBuffer(GL_ARRAY_BUFFER, vertexVBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(PackedVertex)*4, &vertex[0], GL_STATIC_DRAW);
glVertexAttribPointer(posLoc, 3, GL_FLOAT, 0, sizeof(PackedVertex), BUFFER_OFFSET(offsetof(PackedVertex, x)));
glEnableVertexAttribArray(posLoc);
if (texture)
{
glVertexAttribPointer(tex0Loc, 2, GL_FLOAT, 0, sizeof(PackedVertex), BUFFER_OFFSET(offsetof(PackedVertex, u1)));
glEnableVertexAttribArray(tex0Loc);
}
glGenBuffers(1, &indexVBO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexVBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLubyte)*4, idx, GL_STATIC_DRAW);
glDrawElements(GL_TRIANGLE_STRIP, 4, GL_UNSIGNED_BYTE, 0);
glDisableVertexAttribArray(posLoc);
if (texture)
glDisableVertexAttribArray(tex0Loc);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glDeleteBuffers(1, &vertexVBO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glDeleteBuffers(1, &indexVBO);
g_Windowing.DisableShader();
}
void CGUITextureGLES::DrawQuad(const CRect &rect, color_t color, CBaseTexture *texture, const CRect *texCoords)
{
if (texture)
{
glActiveTexture(GL_TEXTURE0);
texture->LoadToGPU();
glBindTexture(GL_TEXTURE_2D, texture->GetTextureObject());
glEnable(GL_TEXTURE_2D);
}
else
glDisable(GL_TEXTURE_2D);
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND); // Turn Blending On
VerifyGLState();
GLfloat col[4][4];
GLfloat ver[4][3];
GLfloat tex[4][2];
GLubyte idx[4] = {0, 1, 3, 2}; //determines order of triangle strip
g_Windowing.EnableGUIShader(SM_TEXTURE);
GLint posLoc = g_Windowing.GUIShaderGetPos();
GLint colLoc = g_Windowing.GUIShaderGetCol();
GLint tex0Loc = g_Windowing.GUIShaderGetCoord0();
glVertexAttribPointer(posLoc, 3, GL_FLOAT, 0, 0, ver);
glVertexAttribPointer(colLoc, 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, col);
glVertexAttribPointer(tex0Loc, 2, GL_FLOAT, 0, 0, tex);
glEnableVertexAttribArray(posLoc);
glEnableVertexAttribArray(tex0Loc);
glEnableVertexAttribArray(colLoc);
for (int i=0; i<4; i++)
{
// Setup Colour Values
col[i][0] = (GLubyte)GET_R(color);
col[i][1] = (GLubyte)GET_G(color);
col[i][2] = (GLubyte)GET_B(color);
col[i][3] = (GLubyte)GET_A(color);
}
// Setup vertex position values
// ver[0][3] = ver[1][3] = ver[2][3] = ver[3][3] = 0.0f; // FIXME, ver has only 3 elements - this is not correct
ver[0][0] = ver[3][0] = rect.x1;
ver[0][1] = ver[1][1] = rect.y1;
ver[1][0] = ver[2][0] = rect.x2;
ver[2][1] = ver[3][1] = rect.y2;
// Setup texture coordinates
CRect coords = texCoords ? *texCoords : CRect(0.0f, 0.0f, 1.0f, 1.0f);
tex[0][0] = tex[3][0] = coords.x1;
tex[0][1] = tex[1][1] = coords.y1;
tex[1][0] = tex[2][0] = coords.x2;
tex[2][1] = tex[3][1] = coords.y2;
glDrawElements(GL_TRIANGLE_STRIP, 4, GL_UNSIGNED_BYTE, idx);
glDisableVertexAttribArray(posLoc);
glDisableVertexAttribArray(colLoc);
glDisableVertexAttribArray(tex0Loc);
g_Windowing.DisableGUIShader();
if (texture)
glDisable(GL_TEXTURE_2D);
}
void CGUITextureGLES::DrawQuad(const CRect &rect, color_t color, CBaseTexture *texture, const CRect *texCoords)
{
if (texture)
{
glActiveTexture(GL_TEXTURE0);
texture->LoadToGPU();
glBindTexture(GL_TEXTURE_2D, texture->GetTextureObject());
}
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND); // Turn Blending On
VerifyGLState();
GLubyte col[4][4];
GLfloat ver[4][3];
GLfloat tex[4][2];
GLubyte idx[4] = {0, 1, 3, 2}; //determines order of triangle strip
if (texture)
g_Windowing.EnableGUIShader(SM_TEXTURE);
else
g_Windowing.EnableGUIShader(SM_DEFAULT);
GLint posLoc = g_Windowing.GUIShaderGetPos();
GLint colLoc = g_Windowing.GUIShaderGetCol();
GLint tex0Loc = g_Windowing.GUIShaderGetCoord0();
glVertexAttribPointer(posLoc, 3, GL_FLOAT, 0, 0, ver);
if(colLoc >= 0)
glVertexAttribPointer(colLoc, 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, col);
if (texture)
glVertexAttribPointer(tex0Loc, 2, GL_FLOAT, 0, 0, tex);
glEnableVertexAttribArray(posLoc);
if (texture)
glEnableVertexAttribArray(tex0Loc);
if(colLoc >= 0)
glEnableVertexAttribArray(colLoc);
for (int i=0; i<4; i++)
{
// Setup Colour Values
col[i][0] = (GLubyte)GET_R(color);
col[i][1] = (GLubyte)GET_G(color);
col[i][2] = (GLubyte)GET_B(color);
col[i][3] = (GLubyte)GET_A(color);
}
// Setup vertex position values
#define ROUND_TO_PIXEL(x) (float)(MathUtils::round_int(x))
ver[0][0] = ROUND_TO_PIXEL(g_graphicsContext.ScaleFinalXCoord(rect.x1, rect.y1));
ver[0][1] = ROUND_TO_PIXEL(g_graphicsContext.ScaleFinalYCoord(rect.x1, rect.y1));
ver[0][2] = ROUND_TO_PIXEL(g_graphicsContext.ScaleFinalZCoord(rect.x1, rect.y1));
ver[1][0] = ROUND_TO_PIXEL(g_graphicsContext.ScaleFinalXCoord(rect.x2, rect.y1));
ver[1][1] = ROUND_TO_PIXEL(g_graphicsContext.ScaleFinalYCoord(rect.x2, rect.y1));
ver[1][2] = ROUND_TO_PIXEL(g_graphicsContext.ScaleFinalZCoord(rect.x2, rect.y1));
ver[2][0] = ROUND_TO_PIXEL(g_graphicsContext.ScaleFinalXCoord(rect.x2, rect.y2));
ver[2][1] = ROUND_TO_PIXEL(g_graphicsContext.ScaleFinalYCoord(rect.x2, rect.y2));
ver[2][2] = ROUND_TO_PIXEL(g_graphicsContext.ScaleFinalZCoord(rect.x2, rect.y2));
ver[3][0] = ROUND_TO_PIXEL(g_graphicsContext.ScaleFinalXCoord(rect.x1, rect.y2));
ver[3][1] = ROUND_TO_PIXEL(g_graphicsContext.ScaleFinalYCoord(rect.x1, rect.y2));
ver[3][2] = ROUND_TO_PIXEL(g_graphicsContext.ScaleFinalZCoord(rect.x1, rect.y2));
if (texture)
{
// Setup texture coordinates
CRect coords = texCoords ? *texCoords : CRect(0.0f, 0.0f, 1.0f, 1.0f);
tex[0][0] = tex[3][0] = coords.x1;
tex[0][1] = tex[1][1] = coords.y1;
tex[1][0] = tex[2][0] = coords.x2;
tex[2][1] = tex[3][1] = coords.y2;
}
glDrawElements(GL_TRIANGLE_STRIP, 4, GL_UNSIGNED_BYTE, idx);
glDisableVertexAttribArray(posLoc);
if(colLoc >= 0)
glDisableVertexAttribArray(colLoc);
if (texture)
glDisableVertexAttribArray(tex0Loc);
g_Windowing.DisableGUIShader();
}
void execute_function(VM *vm) {
restart: {
Frame *frame = vm->current;
Closure *closure = frame->closure;
Chunk *chunk = closure->chunk;
StackObject *registers = frame->registers;
while (frame->pc < chunk->numinstructions) {
int instruction = chunk->instructions[frame->pc];
OpCode o = GET_O(instruction);
int a = GET_A(instruction);
int b = GET_B(instruction);
int c = GET_C(instruction);
switch (o) {
case OP_MOVE:
{
if (b < 256) {
copy_object(®isters[a], ®isters[b]);
} else {
copy_constant(vm, ®isters[a], chunk->constants[b - 256]);
}
} break;
case OP_GETUPVAR:
{
Upval *upval = closure->upvals[b];
if (!upval->open) {
// upval is closed
copy_object(®isters[a], upval->data.o);
} else {
// still on stack
copy_object(®isters[a], &upval->data.ref.frame->registers[upval->data.ref.slot]);
}
} break;
case OP_SETUPVAR:
{
Upval *upval = closure->upvals[b];
if (!upval->open) {
// upval is closed
copy_object(upval->data.o, ®isters[a]);
} else {
// still on stack
copy_object(&upval->data.ref.frame->registers[upval->data.ref.slot], ®isters[a]);
}
} break;
case OP_ADD:
{
// TODO - make string coercion better
// TODO - make string type with special operators
if (IS_STR(b) || IS_STR(c)) {
char *arg1 = TO_STR(b);
char *arg2 = TO_STR(c);
char *arg3 = malloc((strlen(arg1) + strlen(arg2) + 1) + sizeof *arg3);
strcpy(arg3, arg1);
strcat(arg3, arg2);
registers[a].value.o = make_string_ref(vm, arg3);
registers[a].type = OBJECT_REFERENCE; // put this after
free(arg1);
free(arg2);
} else {
if (!(IS_INT(b) || IS_REAL(b)) || !(IS_INT(c) || IS_REAL(c))) {
fatal("Cannot add types.");
}
if (IS_INT(b) && IS_INT(c)) {
int arg1 = AS_INT(b);
int arg2 = AS_INT(c);
registers[a].type = OBJECT_INT;
registers[a].value.i = arg1 + arg2;
} else {
double arg1 = IS_INT(b) ? (double) AS_INT(b) : AS_REAL(b);
double arg2 = IS_INT(c) ? (double) AS_INT(c) : AS_REAL(c);
registers[a].type = OBJECT_REAL;
registers[a].value.d = arg1 + arg2;
}
}
} break;
case OP_SUB:
{
if (!(IS_INT(b) || IS_REAL(b)) || !(IS_INT(c) || IS_REAL(c))) {
fatal("Tried to sub non-numbers.");
}
if (IS_INT(b) && IS_INT(c)) {
int arg1 = AS_INT(b);
int arg2 = AS_INT(c);
registers[a].type = OBJECT_INT;
registers[a].value.i = arg1 - arg2;
} else {
double arg1 = IS_INT(b) ? (double) AS_INT(b) : AS_REAL(b);
double arg2 = IS_INT(c) ? (double) AS_INT(c) : AS_REAL(c);
registers[a].type = OBJECT_REAL;
registers[a].value.d = arg1 - arg2;
}
} break;
case OP_MUL:
{
if (!(IS_INT(b) || IS_REAL(b)) || !(IS_INT(c) || IS_REAL(c))) {
fatal("Tried to mul non-numbers.");
}
if (IS_INT(b) && IS_INT(c)) {
int arg1 = AS_INT(b);
int arg2 = AS_INT(c);
registers[a].type = OBJECT_INT;
registers[a].value.i = arg1 * arg2;
} else {
double arg1 = IS_INT(b) ? (double) AS_INT(b) : AS_REAL(b);
double arg2 = IS_INT(c) ? (double) AS_INT(c) : AS_REAL(c);
registers[a].type = OBJECT_REAL;
registers[a].value.d = arg1 * arg2;
}
} break;
case OP_DIV:
{
if (!(IS_INT(b) || IS_REAL(b)) || !(IS_INT(c) || IS_REAL(c))) {
fatal("Tried to div non-numbers.");
}
if ((IS_INT(c) && AS_INT(c) == 0) || (IS_REAL(c) && AS_REAL(c) == 0)) {
fatal("Div by 0.");
}
if (IS_INT(b) && IS_INT(c)) {
int arg1 = AS_INT(b);
int arg2 = AS_INT(c);
registers[a].type = OBJECT_INT;
registers[a].value.i = arg1 / arg2;
} else {
double arg1 = IS_INT(b) ? (double) AS_INT(b) : AS_REAL(b);
double arg2 = IS_INT(c) ? (double) AS_INT(c) : AS_REAL(c);
registers[a].type = OBJECT_REAL;
registers[a].value.d = arg1 / arg2;
}
} break;
case OP_MOD:
{
if (!(IS_INT(b) || IS_REAL(b)) || !(IS_INT(c) || IS_REAL(c))) {
fatal("Tried to div non-numbers.");
}
if ((IS_INT(c) && AS_INT(c) == 0) || (IS_REAL(c) && AS_REAL(c) == 0)) {
fatal("Mod by 0.");
}
if (IS_INT(b) && IS_INT(c)) {
int arg1 = AS_INT(b);
int arg2 = AS_INT(c);
registers[a].type = OBJECT_INT;
registers[a].value.i = arg1 % arg2;
} else {
double arg1 = IS_INT(b) ? (double) AS_INT(b) : AS_REAL(b);
double arg2 = IS_INT(c) ? (double) AS_INT(c) : AS_REAL(c);
registers[a].type = OBJECT_REAL;
registers[a].value.i = fmod(arg1, arg2);
}
} break;
case OP_POW:
{
if (!(IS_INT(b) || IS_REAL(b)) || !(IS_INT(c) || IS_REAL(c))) {
fatal("Tried to div non-numbers.");
}
if (IS_INT(b) && IS_INT(c)) {
int arg1 = AS_INT(b);
int arg2 = AS_INT(c);
registers[a].type = OBJECT_INT;
registers[a].value.i = (int) pow(arg1, arg2);
} else {
double arg1 = IS_INT(b) ? (double) AS_INT(b) : AS_REAL(b);
double arg2 = IS_INT(c) ? (double) AS_INT(c) : AS_REAL(c);
registers[a].type = OBJECT_REAL;
registers[a].value.d = pow(arg1, arg2);
}
} break;
case OP_NEG:
{
if (IS_INT(b)) {
registers[a].type = OBJECT_INT;
registers[a].value.i = -AS_INT(b);
} else if (IS_REAL(b)) {
registers[a].type = OBJECT_INT;
registers[a].value.i = -AS_REAL(b);
} else {
fatal("Tried to negate non-numeric type.");
}
} break;
case OP_NOT:
{
if (registers[a].type != OBJECT_BOOL) {
fatal("Expected boolean type, not %d.", registers[a].type);
}
registers[a].value.i = registers[a].value.i == 1 ? 0 : 1;
} break;
case OP_EQ:
{
if ((IS_INT(b) || IS_REAL(b)) && (IS_INT(c) || IS_REAL(c))) {
double arg1 = IS_INT(b) ? (double) AS_INT(b) : AS_REAL(b);
double arg2 = IS_INT(c) ? (double) AS_INT(c) : AS_REAL(c);
registers[a].type = OBJECT_BOOL;
registers[a].value.i = arg1 == arg2;
} else {
fatal("Comparison of reference types not yet supported.");
}
} break;
case OP_LT:
{
if (!(IS_INT(b) || IS_REAL(b)) || !(IS_INT(c) || IS_REAL(c))) {
fatal("Tried to compare non-numbers.");
}
double arg1 = IS_INT(b) ? (double) AS_INT(b) : AS_REAL(b);
double arg2 = IS_INT(c) ? (double) AS_INT(c) : AS_REAL(c);
registers[a].type = OBJECT_BOOL;
registers[a].value.i = arg1 < arg2;
} break;
case OP_LE:
{
if (!(IS_INT(b) || IS_REAL(b)) || !(IS_INT(c) || IS_REAL(c))) {
fatal("Tried to compare non-numbers.");
}
double arg1 = IS_INT(b) ? (double) AS_INT(b) : AS_REAL(b);
double arg2 = IS_INT(c) ? (double) AS_INT(c) : AS_REAL(c);
registers[a].type = OBJECT_BOOL;
registers[a].value.i = arg1 <= arg2;
} break;
case OP_CLOSURE:
{
Closure *child = make_closure(chunk->children[b]);
int i;
for (i = 0; i < chunk->children[b]->numupvars; i++) {
int inst = chunk->instructions[++frame->pc];
OpCode oc = GET_O(inst);
int ac = GET_A(inst);
int bc = GET_B(inst);
int cc = GET_C(inst);
if (oc == OP_MOVE) {
// first upval for this variable
child->upvals[ac] = make_upval(vm, bc);
} else {
// share upval
child->upvals[ac] = closure->upvals[bc];
child->upvals[ac]->refcount++;
}
}
registers[a].value.o = make_closure_ref(vm, child);
registers[a].type = OBJECT_REFERENCE; // put this after
} break;
case OP_CALL:
{
if (registers[b].type != OBJECT_REFERENCE || registers[b].value.o->type != OBJECT_CLOSURE) {
fatal("Tried to call non-closure.");
}
// TODO - safety issue (see compile.c for notes)
Closure *child = registers[b].value.o->value.c;
Frame *subframe = make_frame(frame, child);
int i;
for (i = 0; i < child->chunk->numparams; i++) {
copy_object(&subframe->registers[i + 1], ®isters[c + i]);
}
vm->current = subframe;
goto restart;
} break;
case OP_RETURN:
{
UpvalNode *head;
for (head = vm->open; head != NULL; ) {
Upval *u = head->upval;
if (u->data.ref.frame == frame) {
StackObject *o = malloc(sizeof *o);
if (!o) {
fatal("Out of memory.");
}
u->open = 0;
copy_object(o, ®isters[u->data.ref.slot]);
u->data.o = o;
if (vm->open == head) {
vm->open = head->next;
} else {
head->next->prev = head->prev;
head->prev->next = head->next;
}
UpvalNode *temp = head;
head = head->next;
free(temp);
} else {
head = head->next;
}
}
if (vm->current->parent != NULL) {
Frame *p = vm->current->parent;
StackObject *target = &p->registers[GET_A(p->closure->chunk->instructions[p->pc++])];
if (b < 256) {
// debug
char *d = obj_to_str(®isters[b]);
printf("Return value: %s\n", d);
free(d);
copy_object(target, ®isters[b]);
} else {
copy_constant(vm, target, chunk->constants[b - 256]);
}
free_frame(frame);
vm->current = p;
goto restart;
} else {
// debug
char *d = obj_to_str(®isters[b]);
printf("Return value: %s\n", d);
free(d);
free_frame(frame);
vm->current = NULL;
return;
}
} break;
case OP_JUMP:
frame->pc += c ? -b : b;
break;
case OP_JUMP_TRUE:
{
if (registers[a].type != OBJECT_BOOL) {
fatal("Expected boolean type, not %d.", registers[a].type);
}
if (registers[a].value.i == 1) {
frame->pc += c ? -b : b;
}
} break;
case OP_JUMP_FALSE:
{
if (registers[a].type != OBJECT_BOOL) {
fatal("Expected boolean type, not %d.", registers[a].type);
}
if (registers[a].value.i == 0) {
frame->pc += c ? -b : b;
}
} break;
case OP_ENTER_TRY:
{
vm->catchframe = make_catch_frame(frame, vm->catchframe, frame->pc + b);
} break;
case OP_LEAVE_TRY:
{
CatchFrame *temp = vm->catchframe;
vm->catchframe = vm->catchframe->parent;
free_catch_frame(temp);
} break;
case OP_THROW:
{
// TODO - replace unwinding of stack with an exceptions
// table per-chunk. It will have an instructions range,
// the starting instruction of a handler, and the type of
// exception that it may handle.
// Exception table:
// From To Target Type
// 0 4 5 Class TestExc1
// 0 12 12 Class TestExc2
// TODO - implement a way to expect an exception
// of a given type instead of a generic catch-all.
char *s = obj_to_str(®isters[a]);
printf("Exception value: %s!\n", s);
free(s);
// TODO - this is probably wrong. Not sure how complicated
// it will be to handle upvalues and frame destruction here,
// so we're just doing it a shitty way for now :D [GO LAZE].
if (!vm->catchframe) {
// TODO - print a stack trace [ requires debug symbols :( ]
fatal("Exception thrown outside of handler.");
}
while (vm->current != vm->catchframe->frame) {
// TODO - destruct frame
vm->current = vm->current->parent;
}
vm->current->pc = vm->catchframe->target;
CatchFrame *temp = vm->catchframe;
vm->catchframe = vm->catchframe->parent;
free_catch_frame(temp);
goto restart;
} break;
}
frame->pc++;
}
fatal("VM left instruction-space.");
}
}
/**
* Copy an episodic memory (an anecdote) from one ape to another during chat.
* @param local_sim Pointer to the simulation
* @param local Pointer to the ape conveying the anecdote
* @param other Pointer to the ape to which the anecdote will be copied
* @return Returns 1 if the copy was successful, 0 otherwise
*/
n_byte episodic_anecdote(
noble_simulation * local_sim,
noble_being * local,
noble_being * other)
{
episodic_memory * local_episodic = GET_EPI(local_sim, local);
episodic_memory * other_episodic = GET_EPI(local_sim, other);
n_int affect;
n_byte event;
n_int replace,mult=1;
if (local_episodic == 0L || other_episodic == 0L || local == other)
{
return 0;
}
affect = (n_int)(local_episodic[GET_A(local,ATTENTION_EPISODE)].affect)-EPISODIC_AFFECT_ZERO;
event = local_episodic[GET_A(local,ATTENTION_EPISODE)].event;
/** both protagonists must be awake */
if ((event==0) ||
(being_awake_local(local_sim, local)==FULLY_ASLEEP) ||
(being_awake_local(local_sim, other)==FULLY_ASLEEP))
{
return 0;
}
if (being_awake_local(local_sim, local)!=FULLY_AWAKE)
{
/** more likely to make errors while drowsy */
mult=2;
}
/** mutate with some probability */
if (math_random(local->seed) <
(ANECDOTE_EVENT_MUTATION_RATE+
(local->learned_preference[PREFERENCE_ANECDOTE_EVENT_MUTATION])*100)*mult)
{
event = (n_byte)(math_random(local->seed) % EVENTS);
}
if (math_random(local->seed) <
(ANECDOTE_AFFECT_MUTATION_RATE+
(local->learned_preference[PREFERENCE_ANECDOTE_AFFECT_MUTATION])*100)*mult)
{
/** affect gets exaggerated or downplayed */
affect = (affect * (64 + (n_int)(math_random(local->seed) & 127))) / 128;
/** keep affect within range */
if (affect<-32000) affect=-32000;
if (affect>32000) affect=32000;
}
/** find an index within the other episodic memory in which to insert */
replace = episodic_memory_replace_index(
event,affect,
local_episodic[GET_A(local,ATTENTION_EPISODE)].first_name[BEING_MEETER],
local_episodic[GET_A(local,ATTENTION_EPISODE)].family_name[BEING_MEETER],
local_episodic[GET_A(local,ATTENTION_EPISODE)].first_name[BEING_MET],
local_episodic[GET_A(local,ATTENTION_EPISODE)].family_name[BEING_MET],
local,local_sim);
if (replace==-1) return 0;
other_episodic[replace] = local_episodic[GET_A(local,ATTENTION_EPISODE)];
other_episodic[replace].event = event;
other_episodic[replace].affect = (n_byte2)(affect+EPISODIC_AFFECT_ZERO);
/** other ape pays attention to the incoming anecdote */
GET_A(local,ATTENTION_EPISODE) = (n_byte)replace;
return 1;
}
void CGUITextureD3D::Begin(color_t color)
{
int unit = 0;
CBaseTexture* texture = m_texture.m_textures[m_currentFrame];
LPDIRECT3DDEVICE9 p3DDevice = g_Windowing.Get3DDevice();
texture->LoadToGPU();
if (m_diffuse.size())
m_diffuse.m_textures[0]->LoadToGPU();
// Set state to render the image
texture->BindToUnit(unit);
p3DDevice->SetTextureStageState( unit, D3DTSS_COLOROP , D3DTOP_MODULATE );
p3DDevice->SetTextureStageState( unit, D3DTSS_COLORARG1, D3DTA_TEXTURE );
p3DDevice->SetTextureStageState( unit, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
p3DDevice->SetTextureStageState( unit, D3DTSS_ALPHAOP , D3DTOP_MODULATE );
p3DDevice->SetTextureStageState( unit, D3DTSS_ALPHAARG1, D3DTA_TEXTURE );
p3DDevice->SetTextureStageState( unit, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE );
unit++;
if (m_diffuse.size())
{
m_diffuse.m_textures[0]->BindToUnit(1);
p3DDevice->SetTextureStageState( unit, D3DTSS_COLORARG1, D3DTA_TEXTURE );
p3DDevice->SetTextureStageState( unit, D3DTSS_COLORARG2, D3DTA_CURRENT );
p3DDevice->SetTextureStageState( unit, D3DTSS_COLOROP , D3DTOP_MODULATE );
p3DDevice->SetTextureStageState( unit, D3DTSS_ALPHAARG1, D3DTA_TEXTURE );
p3DDevice->SetTextureStageState( unit, D3DTSS_ALPHAARG2, D3DTA_CURRENT );
p3DDevice->SetTextureStageState( unit, D3DTSS_ALPHAOP , D3DTOP_MODULATE );
unit++;
}
if(g_Windowing.UseLimitedColor())
{
m_col = D3DCOLOR_RGBA(GET_R(color) * (235 - 16) / 255
, GET_G(color) * (235 - 16) / 255
, GET_B(color) * (235 - 16) / 255
, GET_A(color));
p3DDevice->SetTextureStageState( unit, D3DTSS_COLOROP , D3DTOP_ADD );
p3DDevice->SetTextureStageState( unit, D3DTSS_COLORARG1, D3DTA_CURRENT) ;
p3DDevice->SetRenderState( D3DRS_TEXTUREFACTOR, D3DCOLOR_RGBA(16,16,16, 0) );
p3DDevice->SetTextureStageState( unit, D3DTSS_COLORARG2, D3DTA_TFACTOR );
unit++;
}
else
m_col = color;
p3DDevice->SetTextureStageState( unit, D3DTSS_COLOROP, D3DTOP_DISABLE);
p3DDevice->SetTextureStageState( unit, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
p3DDevice->SetRenderState( D3DRS_ALPHATESTENABLE, TRUE );
p3DDevice->SetRenderState( D3DRS_ALPHAREF, 0 );
p3DDevice->SetRenderState( D3DRS_ALPHAFUNC, D3DCMP_GREATEREQUAL );
p3DDevice->SetRenderState( D3DRS_ZENABLE, FALSE );
p3DDevice->SetRenderState( D3DRS_FOGENABLE, FALSE );
p3DDevice->SetRenderState( D3DRS_FOGTABLEMODE, D3DFOG_NONE );
p3DDevice->SetRenderState( D3DRS_FILLMODE, D3DFILL_SOLID );
p3DDevice->SetRenderState( D3DRS_CULLMODE, D3DCULL_NONE );
p3DDevice->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
p3DDevice->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA );
p3DDevice->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA );
p3DDevice->SetRenderState( D3DRS_LIGHTING, FALSE);
p3DDevice->SetFVF( D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX2 );
}
void dis(Chunk *chunk) {
int i;
for (i = 0; i < chunk->numinstructions; i++) {
int instruction = chunk->instructions[i];
OpCode o = GET_O(instruction);
int a = GET_A(instruction);
int b = GET_B(instruction);
int c = GET_C(instruction);
switch (o) {
case OP_RETURN:
case OP_LEAVE_TRY:
printf("%d\t%-15s%d", i + 1, opcode_names[o], b);
break;
case OP_THROW:
printf("%d\t%-15s%d", i + 1, opcode_names[0], a);
break;
case OP_MOVE:
case OP_NEG:
case OP_NOT:
{
printf("%d\t%-15s%d %d", i + 1, opcode_names[o], a, b);
if (b > 255) {
printf("\t; b=");
print_const(chunk->constants[b - 256]);
}
} break;
case OP_GETUPVAR:
case OP_SETUPVAR:
case OP_CLOSURE:
printf("%d\t%-15s%d %d", i + 1, opcode_names[o], a, b);
break;
case OP_JUMP:
case OP_JUMP_TRUE:
case OP_JUMP_FALSE:
{
int offset = c == 1 ? -b : b;
printf("%d\t%-15s%d %d\t; j=%d", i + 1, opcode_names[o], a, b, i + offset + 2);
} break;
case OP_ADD:
case OP_SUB:
case OP_MUL:
case OP_DIV:
case OP_MOD:
case OP_POW:
case OP_EQ:
case OP_LT:
case OP_LE:
{
printf("%d\t%-15s%d %d %d", i + 1, opcode_names[o], a, b, c);
if (a > 255) {
printf("\t; a=");
print_const(chunk->constants[a - 256]);
}
if (b > 255) {
printf("\t; b=");
print_const(chunk->constants[b - 256]);
}
} break;
case OP_CALL:
printf("%d\t%-15s%d %d %d", i + 1, opcode_names[o], a, b, c);
break;
case OP_ENTER_TRY:
printf("%d\t%-15s%d\t; j=%d", i + 1, opcode_names[o], b, i + b + 1);
break;
}
printf("\n");
}
for (i = 0; i < chunk->numchildren; i++) {
dis(chunk->children[i]);
}
}
/***********************************************************************
* plugin main ppu thread
***********************************************************************/
static void vsh_menu_thread(uint64_t arg)
{
#ifdef DEBUG
dbg_init();
dbg_printf("programstart:\n");
#endif
uint16_t oldpad = 0, curpad = 0;
CellPadData pdata;
// wait for XMB, feedback
sys_timer_sleep(13);
//vshtask_notify("sprx running...");
play_rco_sound("system_plugin", "snd_trophy");
#ifdef HAVE_STARFIELD
init_once(/* stars */);
#endif
// custom bg_color init
a = GET_A(bg_color_menu[1]);
r = GET_R(bg_color_menu[1]);
g = GET_G(bg_color_menu[1]);
b = GET_B(bg_color_menu[1]);
while(1)
{
// if VSH Menu is running, we get pad data over our MyPadGetData()
// else, we use the vsh pad_data struct
if(menu_running)
MyPadGetData(0, &pdata);
else
VSHPadGetData(&pdata);
// if pad_data and we are in XMB(vshmain_EB757101() == 0)
if((pdata.len > 0)
&& (vshmain_EB757101() == 0)
)
{
curpad = (pdata.button[2] | (pdata.button[3] << 8));
if((curpad & PAD_SELECT) && (curpad != oldpad))
{
switch(menu_running)
{
// VSH Menu not running, start VSH Menu
case 0:
// main view and start on first entry
view = line = 0;
//
pause_RSX_rendering();
// create VSH Menu heap memory from memory container 1("app")
create_heap(64); // 64 MB
// initialize VSH Menu graphic (init drawing context, alloc buffers, blah, blah, blah...)
init_graphic();
// stop vsh pad
start_stop_vsh_pad(0);
// set menu_running
menu_running = 1;
break;
// VSH Menu is running, stop VSH Menu
case 1:
stop_VSH_Menu();
// restart vsh pad
start_stop_vsh_pad(1);
break;
}
oldpad = 0;
sys_timer_usleep(300000);
}
// VSH Menu is running, draw menu / check pad
if(menu_running)
{
#ifdef DEBUG
dbg_printf("%p\n", pdata);
#endif
draw_frame(&pdata);
flip_frame();
if(curpad != oldpad)
{
if(curpad & PAD_UP)
{
if(line <= 0){
line = 0;
}else{
line--;
play_rco_sound("system_plugin", "snd_cursor");
}
}
if(curpad & PAD_DOWN)
{
if(line >= max_menu[view]-1){
line = max_menu[view]-1;
}else{
line++;
play_rco_sound("system_plugin", "snd_cursor");
}
}
if(curpad & PAD_LEFT
|| curpad & PAD_RIGHT) do_leftright_action(curpad);
if(curpad & PAD_CROSS) do_menu_action();
}
// ...
sys_timer_usleep(30);
} // end VSH Menu is running
oldpad = curpad;
}else{
oldpad = 0;
}
}
#ifdef DEBUG
dbg_fini();
#endif
sys_ppu_thread_exit(0);
}
void CGUITextureGLES::Begin(color_t color)
{
CBaseTexture* texture = m_texture.m_textures[m_currentFrame];
glActiveTexture(GL_TEXTURE0);
texture->LoadToGPU();
if (m_diffuse.size())
m_diffuse.m_textures[0]->LoadToGPU();
glBindTexture(GL_TEXTURE_2D, texture->GetTextureObject());
// Setup Colors
for (int i = 0; i < 4; i++)
{
m_col[i][0] = (GLubyte)GET_R(color);
m_col[i][1] = (GLubyte)GET_G(color);
m_col[i][2] = (GLubyte)GET_B(color);
m_col[i][3] = (GLubyte)GET_A(color);
}
bool hasAlpha = m_texture.m_textures[m_currentFrame]->HasAlpha() || m_col[0][3] < 255;
if (m_diffuse.size())
{
if (m_col[0][0] == 255 && m_col[0][1] == 255 && m_col[0][2] == 255 && m_col[0][3] == 255 )
{
g_Windowing.EnableGUIShader(SM_MULTI);
}
else
{
g_Windowing.EnableGUIShader(SM_MULTI_BLENDCOLOR);
}
hasAlpha |= m_diffuse.m_textures[0]->HasAlpha();
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, m_diffuse.m_textures[0]->GetTextureObject());
GLint tex1Loc = g_Windowing.GUIShaderGetCoord1();
glVertexAttribPointer(tex1Loc, 2, GL_FLOAT, 0, 0, m_tex1);
glEnableVertexAttribArray(tex1Loc);
hasAlpha = true;
}
else
{
if ( hasAlpha )
{
g_Windowing.EnableGUIShader(SM_TEXTURE);
}
else
{
g_Windowing.EnableGUIShader(SM_TEXTURE_NOBLEND);
}
}
GLint posLoc = g_Windowing.GUIShaderGetPos();
GLint colLoc = g_Windowing.GUIShaderGetCol();
GLint tex0Loc = g_Windowing.GUIShaderGetCoord0();
glVertexAttribPointer(posLoc, 3, GL_FLOAT, 0, 0, m_vert);
if(colLoc >= 0)
glVertexAttribPointer(colLoc, 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, m_col);
glVertexAttribPointer(tex0Loc, 2, GL_FLOAT, 0, 0, m_tex0);
glEnableVertexAttribArray(posLoc);
if(colLoc >= 0)
glEnableVertexAttribArray(colLoc);
glEnableVertexAttribArray(tex0Loc);
if ( hasAlpha )
{
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
glEnable( GL_BLEND );
}
else
{
glDisable(GL_BLEND);
}
}
static int process_sn_msg( n2n_sn_t *sss,
const struct sockaddr_in *sender_sock,
const uint8_t *msg_buf,
size_t msg_size,
time_t now)
{
snm_hdr_t hdr; /* common fields in the packet header */
size_t rem;
size_t idx;
size_t msg_type;
n2n_sock_t sender_sn;
traceEvent( TRACE_DEBUG, "process_sn_msg(%lu)", msg_size );
sn_cpy(&sender_sn, (const n2n_sock_t *) sender_sock);
sender_sn.port = htons(sender_sn.port);
rem = msg_size; /* Counts down bytes of packet to protect against buffer overruns. */
idx = 0; /* marches through packet header as parts are decoded. */
if (decode_SNM_hdr(&hdr, msg_buf, &rem, &idx) < 0)
{
traceEvent(TRACE_ERROR, "Failed to decode header");
return -1; /* failed to decode packet */
}
log_SNM_hdr(&hdr);
msg_type = hdr.type; /* message type */
if (msg_type == SNM_TYPE_REQ_LIST_MSG)
{
n2n_SNM_REQ_t req;
if (sss->snm_discovery_state != N2N_SNM_STATE_READY)
{
traceEvent(TRACE_ERROR, "Received SNM REQ but supernode is NOT READY");
return -1;
}
decode_SNM_REQ(&req, &hdr, msg_buf, &rem, &idx);
log_SNM_REQ(&req);
if (GET_A(hdr.flags))
{
/* request for ADV */
if (GET_E(hdr.flags))
{
/* request from edge wanting to register a new community */
struct comm_info *ci = NULL;
int need_write = 0;
if (req.comm_num != 1)
{
traceEvent(TRACE_ERROR, "Received SNM REQ from edge with comm_num=%d", req.comm_num);
return -1;
}
need_write = add_new_community(&sss->communities, req.comm_ptr[0].name, &ci);
if (need_write)
{
write_comm_list_to_file(sss->communities.filename,
sss->communities.list_head);
advertise_community_to_all(sss, ci->community_name);
}
}
send_snm_adv(sss, &sender_sn, NULL);
}
else
{
/* request for INFO */
send_snm_rsp(sss, &sender_sn, &hdr, &req);
}
if (!GET_E(hdr.flags))
{
update_and_save_supernodes(&sss->supernodes, &sender_sn, 1);
}
}
else if (msg_type == SNM_TYPE_RSP_LIST_MSG)
{
n2n_SNM_INFO_t rsp;
int sn_num = 0;
struct sn_info *new_sn = NULL;
if (sss->snm_discovery_state == N2N_SNM_STATE_READY)
{
traceEvent(TRACE_ERROR, "Received SNM RSP but supernode is READY");
return -1;
}
decode_SNM_INFO(&rsp, &hdr, msg_buf, &rem, &idx);
log_SNM_INFO(&rsp);
sn_num = process_snm_rsp(&sss->supernodes, &sss->communities,
&sender_sn, &hdr, &rsp);
/* send requests to the recently added supernodes */
new_sn = sss->supernodes.list_head;
while (sn_num > 0 && new_sn)
{
send_snm_req(sss, &new_sn->sn, 1, NULL, 0);
new_sn = new_sn->next;
sn_num--;
}
}
else if (msg_type == SNM_TYPE_ADV_MSG)
{
n2n_SNM_ADV_t adv;
int communities_updated = 0;
decode_SNM_ADV(&adv, &hdr, msg_buf, &rem, &idx);
log_SNM_ADV(&adv);
communities_updated = process_snm_adv(&sss->supernodes,
&sss->communities,
&sender_sn, &adv);
if (communities_updated && GET_A(hdr.flags))
{
/* sending supernode is requesting ADV */
send_snm_adv(sss, &sender_sn, sss->communities.list_head);
}
/* new supernode will be advertised on REG SUPER ACK */
}
return 0;
}
