void rect::twips_to_pixels()
{
m_x_min = TWIPS_TO_PIXELS(m_x_min);
m_y_min = TWIPS_TO_PIXELS(m_y_min);
m_x_max = TWIPS_TO_PIXELS(m_x_max);
m_y_max = TWIPS_TO_PIXELS(m_y_max);
}
void rect::print() const
// Debug spew.
{
log_msg("xmin = %g, ymin = %g, xmax = %g, ymax = %g\n",
TWIPS_TO_PIXELS(m_x_min),
TWIPS_TO_PIXELS(m_y_min),
TWIPS_TO_PIXELS(m_x_max),
TWIPS_TO_PIXELS(m_y_max));
}
void root::set_display_viewport(int x0, int y0, int w, int h)
{
m_viewport_x0 = x0;
m_viewport_y0 = y0;
m_viewport_width = w;
m_viewport_height = h;
// Recompute pixel scale.
float scale_x = m_viewport_width / TWIPS_TO_PIXELS(m_def->m_frame_size.width());
float scale_y = m_viewport_height / TWIPS_TO_PIXELS(m_def->m_frame_size.height());
m_pixel_scale = fmax(scale_x, scale_y);
}
void draw_line_strip(const void* coords, int vertex_count)
// Draw the line strip formed by the sequence of points.
{
// Set up current style.
m_current_styles[LINE_STYLE].apply();
// apply line width
float scale = fabsf(m_current_matrix.get_x_scale()) + fabsf(m_current_matrix.get_y_scale());
float w = m_current_styles[LINE_STYLE].m_width * scale / 2.0f;
w = TWIPS_TO_PIXELS(w);
// GLfloat width_info[2];
// glGetFloatv(GL_LINE_WIDTH_RANGE, width_info);
// if (w > width_info[1])
// {
// printf("Your OpenGL implementation does not support the line width"
// " requested. Lines will be drawn with reduced width.");
// }
glLineWidth(w <= 1.0f ? 1.0f : w);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
apply_matrix(m_current_matrix);
// Send the line-strip to OpenGL
glEnableClientState(GL_VERTEX_ARRAY);
#if TU_USES_FLOAT_AS_COORDINATE_COMPONENT
glVertexPointer(2, GL_FLOAT, sizeof(float) * 2, coords);
#else
glVertexPointer(2, GL_SHORT, sizeof(Sint16) * 2, coords);
#endif
glEnable(GL_LINE_SMOOTH);
glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
glDrawArrays(GL_LINE_STRIP, 0, vertex_count);
glDisable(GL_LINE_SMOOTH);
// Draw a round dot on the beginning and end coordinates to lines.
glPointSize(w);
glEnable(GL_POINT_SMOOTH);
glDrawArrays(GL_POINTS, 0, vertex_count);
glDisable(GL_POINT_SMOOTH);
glPointSize(1);
glDisableClientState(GL_VERTEX_ARRAY);
// restore defaults
glPointSize(1);
glLineWidth(1);
glPopMatrix();
}
void point::twips_to_pixels()
{
m_x = TWIPS_TO_PIXELS(m_x);
m_y = TWIPS_TO_PIXELS(m_y);
}
void matrix::print() const
// Debug log.
{
log_msg("| %4.4f %4.4f %4.4f |\n", float(m_[0][0]), float(m_[0][1]), TWIPS_TO_PIXELS(m_[0][2]));
log_msg("| %4.4f %4.4f %4.4f |\n", float(m_[1][0]), float(m_[1][1]), TWIPS_TO_PIXELS(m_[1][2]));
}
// useless stuff ?
void x3ds_instance::update_material()
{
GLint aux_buffers;
glGetIntegerv(GL_AUX_BUFFERS, &aux_buffers);
if (aux_buffers < 2)
{
static int n = 0;
if (n < 1)
{
n++;
log_error("Your video card does not have AUX buffers, can't snapshot movieclips\n");
}
return;
}
glPushAttrib(GL_ALL_ATTRIB_BITS);
// update textures
for (stringi_hash<gc_ptr <bitmap_info> >::iterator it =
m_material.begin(); it != m_material.end(); ++it)
{
as_value target = m_map[it->first];
character* ch = find_target(target);
if (ch)
{
if (ch->get_parent() == NULL)
{
log_error("Can't snapshot _root movieclip, material '%s'\n", it->first.c_str());
continue;
}
GLint draw_buffer;
glGetIntegerv(GL_DRAW_BUFFER, &draw_buffer);
glDrawBuffer(GL_AUX1);
glReadBuffer(GL_AUX1);
// save "ch" matrix
matrix ch_matrix = ch->get_matrix();
float ch_width = TWIPS_TO_PIXELS(ch->get_width());
float ch_height = TWIPS_TO_PIXELS(ch->get_height());
// get viewport size
GLint vp[4];
glGetIntegerv(GL_VIEWPORT, vp);
int vp_width = vp[2];
int vp_height = vp[3];
// get texture size
int tw = 1; while (tw < ch_width) { tw <<= 1; }
int th = 1; while (th < ch_height) { th <<= 1; }
// texture size must be <= viewport size
if (tw > vp_width)
{
tw = vp_width;
}
if (th > vp_height)
{
th = vp_height;
}
ch->set_member("_width", tw);
ch->set_member("_height", th);
rect bound;
ch->get_bound(&bound);
// parent world matrix moves point(0,0) to "pzero"
matrix mparent = ch->get_parent()->get_world_matrix();
point pzero;
mparent.transform_by_inverse(&pzero, point(0, 0));
// after transformation of "ch" matrix left-top corner is in point(bound.m_x_min, bound.m_y_min),
// therefore we need to move point(bound.m_x_min, bound.m_y_min) to point(pzero.m_x, pzero.m_y)
// that "ch" movieclip's left-top corner will be in point(0,0) of screen
matrix m = ch->get_matrix();
float xt = (pzero.m_x - bound.m_x_min) / m.get_x_scale();
float yt = (pzero.m_y - bound.m_y_min) / m.get_y_scale();
// move "ch" to left-bottom corner (as point of origin of OpenGL is in left-bottom)
// later glCopyTexImage2D will copy snapshot of "ch" into texture
yt += PIXELS_TO_TWIPS(vp_height - th) / m.get_y_scale();
m.concatenate_translation(xt, yt);
ch->set_matrix(m);
glClearColor(1, 1, 1, 1);
glClear(GL_COLOR_BUFFER_BIT);
ch->display();
// restore "ch" matrix
ch->set_matrix(ch_matrix);
gc_ptr<bitmap_info> bi = it->second;
if (bi->m_texture_id == 0)
{
glGenTextures(1, (GLuint*) &bi->m_texture_id);
bi->m_original_height = (int) ch_height;
bi->m_original_width = (int) ch_width;
}
glBindTexture(GL_TEXTURE_2D, bi->m_texture_id);
glEnable(GL_TEXTURE_2D);
glDisable(GL_TEXTURE_GEN_S);
glDisable(GL_TEXTURE_GEN_T);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); // GL_NEAREST ?
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 0,0, tw, th, 0);
glDisable(GL_TEXTURE_2D);
glDrawBuffer(draw_buffer);
glReadBuffer(draw_buffer);
}
}
glPopAttrib();
}
